Remove unnecessary return values

Miscellaneous clean-up


git-svn-id: https://svn.osgeo.org/grass/grass/trunk@34484 15284696-431f-4ddb-bdfa-cd5b030d7da7

include/gisdefs.h

@@ -79,24 +79,24 @@ int G_begin_polygon_area_calculations(void);
 double G_area_of_polygon(const double *, const double *, int);
 
 /* area_ellipse.c */
-int G_begin_zone_area_on_ellipsoid(double, double, double);
+void G_begin_zone_area_on_ellipsoid(double, double, double);
 double G_darea0_on_ellipsoid(double);
 double G_area_for_zone_on_ellipsoid(double, double);
 
 /* area_poly1.c */
-int G_begin_ellipsoid_polygon_area(double, double);
+void G_begin_ellipsoid_polygon_area(double, double);
 double G_ellipsoid_polygon_area(const double *, const double *, int);
 
 /* area_poly2.c */
 double G_planimetric_polygon_area(const double *, const double *, int);
 
 /* area_sphere.c */
-int G_begin_zone_area_on_sphere(double, double);
+void G_begin_zone_area_on_sphere(double, double);
 double G_darea0_on_sphere(double);
 double G_area_for_zone_on_sphere(double, double);
 
 /* ascii_chk.c */
-int G_ascii_check(char *);
+void G_ascii_check(char *);
 
 
 /* asprintf.c */
@@ -114,14 +114,14 @@ int G_asprintf(char **, const char *, ...)
 
 /* auto_mask.c */
 int G__check_for_auto_masking(void);
-int G_suppress_masking(void);
-int G_unsuppress_masking(void);
+void G_suppress_masking(void);
+void G_unsuppress_masking(void);
 
 /* basename.c */
 char *G_basename(char *, const char *);
 
 /* bres_line.c */
-int G_bresenham_line(int, int, int, int, int (*)(int, int));
+void G_bresenham_line(int, int, int, int, int (*)(int, int));
 
 /* cats.c */
 int G_read_cats(const char *, const char *, struct Categories *);
@@ -135,12 +135,12 @@ char *G_get_c_raster_cat(CELL *, struct Categories *);
 char *G_get_f_raster_cat(FCELL *, struct Categories *);
 char *G_get_d_raster_cat(DCELL *, struct Categories *);
 char *G_get_raster_cat(void *, struct Categories *, RASTER_MAP_TYPE);
-int G_unmark_raster_cats(struct Categories *);
-int G_mark_c_raster_cats(const CELL *, int, struct Categories *);
-int G_mark_f_raster_cats(const FCELL *, int, struct Categories *);
-int G_mark_d_raster_cats(const DCELL *, int, struct Categories *);
+void G_unmark_raster_cats(struct Categories *);
+void G_mark_c_raster_cats(const CELL *, int, struct Categories *);
+void G_mark_f_raster_cats(const FCELL *, int, struct Categories *);
+void G_mark_d_raster_cats(const DCELL *, int, struct Categories *);
 int G_mark_raster_cats(const void *, int, struct Categories *, RASTER_MAP_TYPE);
-int G_rewind_raster_cats(struct Categories *);
+void G_rewind_raster_cats(struct Categories *);
 char *G_get_next_marked_d_raster_cat(struct Categories *, DCELL *, DCELL *,
 				     long *);
 char *G_get_next_marked_c_raster_cat(struct Categories *, CELL *, CELL *,
@@ -164,28 +164,28 @@ char *G_get_ith_f_raster_cat(const struct Categories *, int, void *, void *);
 char *G_get_ith_c_raster_cat(const struct Categories *, int, void *, void *);
 char *G_get_ith_raster_cat(const struct Categories *, int, void *, void *,
 			   RASTER_MAP_TYPE);
-int G_init_cats(CELL, const char *, struct Categories *);
-int G_init_raster_cats(const char *, struct Categories *);
-int G_set_cats_title(const char *, struct Categories *);
-int G_set_raster_cats_title(const char *, struct Categories *);
-int G_set_cats_fmt(const char *, double, double, double, double,
+void G_init_cats(CELL, const char *, struct Categories *);
+void G_init_raster_cats(const char *, struct Categories *);
+void G_set_cats_title(const char *, struct Categories *);
+void G_set_raster_cats_title(const char *, struct Categories *);
+void G_set_cats_fmt(const char *, double, double, double, double,
 		   struct Categories *);
-int G_set_raster_cats_fmt(const char *, double, double, double, double,
-			  struct Categories *);
-int G_free_cats(struct Categories *);
-int G_free_raster_cats(struct Categories *);
-int G_copy_raster_cats(struct Categories *, const struct Categories *);
+void G_set_raster_cats_fmt(const char *, double, double, double, double,
+			   struct Categories *);
+void G_free_cats(struct Categories *);
+void G_free_raster_cats(struct Categories *);
+void G_copy_raster_cats(struct Categories *, const struct Categories *);
 int G_number_of_raster_cats(struct Categories *);
 int G_sort_cats(struct Categories *);
 
 /* cell_stats.c */
-int G_init_cell_stats(struct Cell_stats *);
+void G_init_cell_stats(struct Cell_stats *);
 int G_update_cell_stats(const CELL *, int, struct Cell_stats *);
 int G_find_cell_stat(CELL, long *, const struct Cell_stats *);
 int G_rewind_cell_stats(struct Cell_stats *);
 int G_next_cell_stat(CELL *, long *, struct Cell_stats *);
-int G_get_stats_for_null_value(long *, const struct Cell_stats *);
-int G_free_cell_stats(struct Cell_stats *);
+void G_get_stats_for_null_value(long *, const struct Cell_stats *);
+void G_free_cell_stats(struct Cell_stats *);
 
 /* cell_title.c */
 char *G_get_cell_title(const char *, const char *);
@@ -194,11 +194,8 @@ char *G_get_cell_title(const char *, const char *);
 int G_cell_stats_histo_eq(struct Cell_stats *, CELL, CELL, CELL, CELL, int,
 			  void (*)(CELL, CELL, CELL));
 
-/* chop.c */
-char *G_chop(char *);
-
 /* clear_scrn.c */
-int G_clear_screen(void);
+void G_clear_screen(void);
 
 /* clicker.c */
 void G_clicker(void);
@@ -208,33 +205,33 @@ int G_close_cell(int);
 int G_unopen_cell(int);
 
 /* color_compat.c */
-int G_make_ryg_colors(struct Colors *, CELL, CELL);
-int G_make_ryg_fp_colors(struct Colors *, DCELL, DCELL);
-int G_make_aspect_colors(struct Colors *, CELL, CELL);
-int G_make_aspect_fp_colors(struct Colors *, DCELL, DCELL);
-int G_make_byr_colors(struct Colors *, CELL, CELL);
-int G_make_byr_fp_colors(struct Colors *, DCELL, DCELL);
-int G_make_bgyr_colors(struct Colors *, CELL, CELL);
-int G_make_bgyr_fp_colors(struct Colors *, DCELL, DCELL);
-int G_make_byg_colors(struct Colors *, CELL, CELL);
-int G_make_byg_fp_colors(struct Colors *, DCELL, DCELL);
-int G_make_grey_scale_colors(struct Colors *, CELL, CELL);
-int G_make_grey_scale_fp_colors(struct Colors *, DCELL, DCELL);
-int G_make_gyr_colors(struct Colors *, CELL, CELL);
-int G_make_gyr_fp_colors(struct Colors *, DCELL, DCELL);
-int G_make_rainbow_colors(struct Colors *, CELL, CELL);
-int G_make_rainbow_fp_colors(struct Colors *, DCELL, DCELL);
-int G_make_ramp_colors(struct Colors *, CELL, CELL);
-int G_make_ramp_fp_colors(struct Colors *, DCELL, DCELL);
-int G_make_wave_colors(struct Colors *, CELL, CELL);
-int G_make_wave_fp_colors(struct Colors *, DCELL, DCELL);
+void G_make_ryg_colors(struct Colors *, CELL, CELL);
+void G_make_ryg_fp_colors(struct Colors *, DCELL, DCELL);
+void G_make_aspect_colors(struct Colors *, CELL, CELL);
+void G_make_aspect_fp_colors(struct Colors *, DCELL, DCELL);
+void G_make_byr_colors(struct Colors *, CELL, CELL);
+void G_make_byr_fp_colors(struct Colors *, DCELL, DCELL);
+void G_make_bgyr_colors(struct Colors *, CELL, CELL);
+void G_make_bgyr_fp_colors(struct Colors *, DCELL, DCELL);
+void G_make_byg_colors(struct Colors *, CELL, CELL);
+void G_make_byg_fp_colors(struct Colors *, DCELL, DCELL);
+void G_make_grey_scale_colors(struct Colors *, CELL, CELL);
+void G_make_grey_scale_fp_colors(struct Colors *, DCELL, DCELL);
+void G_make_gyr_colors(struct Colors *, CELL, CELL);
+void G_make_gyr_fp_colors(struct Colors *, DCELL, DCELL);
+void G_make_rainbow_colors(struct Colors *, CELL, CELL);
+void G_make_rainbow_fp_colors(struct Colors *, DCELL, DCELL);
+void G_make_ramp_colors(struct Colors *, CELL, CELL);
+void G_make_ramp_fp_colors(struct Colors *, DCELL, DCELL);
+void G_make_wave_colors(struct Colors *, CELL, CELL);
+void G_make_wave_fp_colors(struct Colors *, DCELL, DCELL);
 
 /* color_free.c */
-int G_free_colors(struct Colors *);
-int G__color_free_rules(struct _Color_Info_ *);
-int G__color_free_lookup(struct _Color_Info_ *);
-int G__color_free_fp_lookup(struct _Color_Info_ *);
-int G__color_reset(struct Colors *);
+void G_free_colors(struct Colors *);
+void G__color_free_rules(struct _Color_Info_ *);
+void G__color_free_lookup(struct _Color_Info_ *);
+void G__color_free_fp_lookup(struct _Color_Info_ *);
+void G__color_reset(struct Colors *);
 
 /* color_get.c */
 int G_get_color(CELL, int *, int *, int *, struct Colors *);
@@ -243,74 +240,78 @@ int G_get_raster_color(const void *, int *, int *, int *, struct Colors *,
 int G_get_c_raster_color(const CELL *, int *, int *, int *, struct Colors *);
 int G_get_f_raster_color(const FCELL *, int *, int *, int *, struct Colors *);
 int G_get_d_raster_color(const DCELL *, int *, int *, int *, struct Colors *);
-int G_get_null_value_color(int *, int *, int *, const struct Colors *);
-int G_get_default_color(int *, int *, int *, const struct Colors *);
+void G_get_null_value_color(int *, int *, int *, const struct Colors *);
+void G_get_default_color(int *, int *, int *, const struct Colors *);
 
 /* color_hist.c */
-int G_make_histogram_eq_colors(struct Colors *, struct Cell_stats *);
-int G_make_histogram_log_colors(struct Colors *, struct Cell_stats *, int,
-				int);
+void G_make_histogram_eq_colors(struct Colors *, struct Cell_stats *);
+void G_make_histogram_log_colors(struct Colors *, struct Cell_stats *, int, int);
 
 /* color_init.c */
-int G_init_colors(struct Colors *);
+void G_init_colors(struct Colors *);
 
 /* color_insrt.c */
 int G__insert_color_into_lookup(CELL, int, int, int, struct _Color_Info_ *);
 
 /* color_invrt.c */
-int G_invert_colors(struct Colors *);
+void G_invert_colors(struct Colors *);
 
 /* color_look.c */
-int G_lookup_colors(const CELL *, unsigned char *, unsigned char *,
-		    unsigned char *, unsigned char *, int, struct Colors *);
-int G_lookup_c_raster_colors(const CELL *, unsigned char *, unsigned char *,
+void G_lookup_colors(const CELL *, unsigned char *, unsigned char *,
+		     unsigned char *, unsigned char *, int, struct Colors *);
+void G_lookup_c_raster_colors(const CELL *, unsigned char *, unsigned char *,
+			      unsigned char *, unsigned char *, int,
+			      struct Colors *);
+void G_lookup_raster_colors(const void *, unsigned char *, unsigned char *,
+			    unsigned char *, unsigned char *, int,
+			    struct Colors *, RASTER_MAP_TYPE);
+void G_lookup_f_raster_colors(const FCELL *, unsigned char *, unsigned char *,
 			     unsigned char *, unsigned char *, int,
 			     struct Colors *);
-int G_lookup_raster_colors(const void *, unsigned char *, unsigned char *,
-			   unsigned char *, unsigned char *, int,
-			   struct Colors *, RASTER_MAP_TYPE);
-int G_lookup_f_raster_colors(const FCELL *, unsigned char *, unsigned char *,
+void G_lookup_d_raster_colors(const DCELL *, unsigned char *, unsigned char *,
 			     unsigned char *, unsigned char *, int,
 			     struct Colors *);
-int G_lookup_d_raster_colors(const DCELL *, unsigned char *, unsigned char *,
-			     unsigned char *, unsigned char *, int,
-			     struct Colors *);
-int G__lookup_colors(const void *, unsigned char *, unsigned char *,
-		     unsigned char *, unsigned char *, int, struct Colors *,
-		     int, int, RASTER_MAP_TYPE);
-int G__interpolate_color_rule(DCELL, unsigned char *, unsigned char *,
-			      unsigned char *, const struct _Color_Rule_ *);
+void G__lookup_colors(const void *, unsigned char *, unsigned char *,
+		      unsigned char *, unsigned char *, int, struct Colors *,
+		      int, int, RASTER_MAP_TYPE);
+void G__interpolate_color_rule(DCELL, unsigned char *, unsigned char *,
+			       unsigned char *, const struct _Color_Rule_ *);
 
 /* color_org.c */
-int G__organize_colors(struct Colors *);
+void G__organize_colors(struct Colors *);
 
 /* color_rand.c */
-int G_make_random_colors(struct Colors *, CELL, CELL);
+void G_make_random_colors(struct Colors *, CELL, CELL);
 
 /* color_range.c */
-int G_set_color_range(CELL, CELL, struct Colors *);
-int G_set_d_color_range(DCELL, DCELL, struct Colors *);
-int G_get_color_range(CELL *, CELL *, const struct Colors *);
-int G_get_d_color_range(DCELL *, DCELL *, const struct Colors *);
+void G_set_color_range(CELL, CELL, struct Colors *);
+void G_set_d_color_range(DCELL, DCELL, struct Colors *);
+void G_get_color_range(CELL *, CELL *, const struct Colors *);
+void G_get_d_color_range(DCELL *, DCELL *, const struct Colors *);
 
 /* color_read.c */
 int G_read_colors(const char *, const char *, struct Colors *);
-int G_mark_colors_as_fp(struct Colors *);
+void G_mark_colors_as_fp(struct Colors *);
 
 /* color_remove.c */
 int G_remove_colors(const char *, const char *);
 
 /* color_rule.c */
-int G_add_d_raster_color_rule(const DCELL *, int, int, int, const DCELL *,
-			      int, int, int, struct Colors *);
-int G_add_f_raster_color_rule(const FCELL *, int, int, int, const FCELL *,
-			      int, int, int, struct Colors *);
-int G_add_c_raster_color_rule(const CELL *, int, int, int, const CELL *, int,
-			      int, int, struct Colors *);
-int G_add_raster_color_rule(const void *, int, int, int, const void *, int,
-			    int, int, struct Colors *, RASTER_MAP_TYPE);
-int G_add_color_rule(const CELL, int, int, int, const CELL, int, int, int,
-		     struct Colors *);
+void G_add_d_raster_color_rule(const DCELL *, int, int, int,
+			       const DCELL *, int, int, int,
+			       struct Colors *);
+void G_add_f_raster_color_rule(const FCELL *, int, int, int,
+			       const FCELL *, int, int, int,
+			       struct Colors *);
+void G_add_c_raster_color_rule(const CELL *, int, int, int,
+			       const CELL *, int, int, int,
+			       struct Colors *);
+void G_add_raster_color_rule(const void *, int, int, int,
+			     const void *, int, int, int,
+			     struct Colors *, RASTER_MAP_TYPE);
+void G_add_color_rule(const CELL, int, int, int,
+		      const CELL, int, int, int,
+		      struct Colors *);
 int G_add_modular_d_raster_color_rule(const DCELL *, int, int, int,
 				      const DCELL *, int, int, int,
 				      struct Colors *);
@@ -320,10 +321,11 @@ int G_add_modular_f_raster_color_rule(const FCELL *, int, int, int,
 int G_add_modular_c_raster_color_rule(const CELL *, int, int, int,
 				      const CELL *, int, int, int,
 				      struct Colors *);
-int G_add_modular_raster_color_rule(const void *, int, int, int, const void *,
-				    int, int, int, struct Colors *,
-				    RASTER_MAP_TYPE);
-int G_add_modular_color_rule(CELL, int, int, int, CELL, int, int, int,
+int G_add_modular_raster_color_rule(const void *, int, int, int,
+				    const void *, int, int, int,
+				    struct Colors *, RASTER_MAP_TYPE);
+int G_add_modular_color_rule(CELL, int, int, int,
+			     CELL, int, int, int,
 			     struct Colors *);
 
 /* color_rule_get.c */
@@ -344,44 +346,46 @@ int G_read_color_rule(void *, DCELL, DCELL, DCELL *, int *, int *, int *,
 int G_read_color_rules(struct Colors *, DCELL, DCELL, read_rule_fn *, void *);
 int G_load_colors(struct Colors *, const char *, CELL, CELL);
 int G_load_fp_colors(struct Colors *, const char *, DCELL, DCELL);
-int G_make_colors(struct Colors *, const char *, CELL, CELL);
-int G_make_fp_colors(struct Colors *, const char *, DCELL, DCELL);
+void G_make_colors(struct Colors *, const char *, CELL, CELL);
+void G_make_fp_colors(struct Colors *, const char *, DCELL, DCELL);
 
 /* color_set.c */
-int G_set_color(CELL, int, int, int, struct Colors *);
-int G_set_d_color(DCELL, int, int, int, struct Colors *);
-int G_set_null_value_color(int, int, int, struct Colors *);
-int G_set_default_color(int, int, int, struct Colors *);
+void G_set_color(CELL, int, int, int, struct Colors *);
+void G_set_d_color(DCELL, int, int, int, struct Colors *);
+void G_set_null_value_color(int, int, int, struct Colors *);
+void G_set_default_color(int, int, int, struct Colors *);
 
 /* color_shift.c */
-int G_shift_colors(int, struct Colors *);
-int G_shift_d_colors(DCELL, struct Colors *);
+void G_shift_colors(int, struct Colors *);
+void G_shift_d_colors(DCELL, struct Colors *);
 
 /* color_str.c */
 int G_str_to_color(const char *, int *, int *, int *);
 
 /* color_write.c */
 int G_write_colors(const char *, const char *, struct Colors *);
-int G__write_colors(FILE *, struct Colors *);
+void G__write_colors(FILE *, struct Colors *);
 
 /* color_xform.c */
-int G_histogram_eq_colors(struct Colors *, struct Colors *,
-			  struct Cell_stats *);
+void G_histogram_eq_colors(struct Colors *, struct Colors *,
+			   struct Cell_stats *);
 void G_histogram_eq_colors_fp(struct Colors *,
 			      struct Colors *, struct FP_stats *);
-int G_log_colors(struct Colors *, struct Colors *, int);
-int G_abs_log_colors(struct Colors *, struct Colors *, int);
+void G_log_colors(struct Colors *, struct Colors *, int);
+void G_abs_log_colors(struct Colors *, struct Colors *, int);
 
 /* commas.c */
 int G_insert_commas(char *);
-int G_remove_commas(char *);
+void G_remove_commas(char *);
 
 /* copy.c */
-int G_copy(void *, const void *, int);
+void G_copy(void *, const void *, int);
+
+/* copy_dir.c */
+int G_recursive_copy(const char *, const char *);
 
 /* copy_file.c */
 int G_copy_file(const char *, const char *);
-int G_recursive_copy(const char *, const char *);
 
 /* dalloc.c */
 double *G_alloc_vector(size_t);
@@ -418,7 +422,7 @@ double G_distance_point_to_line_segment(double, double, double, double,
 					double, double);
 
 /* done_msg.c */
-int G_done_msg(const char *, ...) __attribute__ ((format(printf, 1, 2)));
+void G_done_msg(const char *, ...) __attribute__ ((format(printf, 1, 2)));
 
 /* eigen_tools.c */
 int G_tqli(double[], double[], int, double **);
@@ -454,13 +458,13 @@ void G_verbose_message(const char *, ...)
     __attribute__ ((format(printf, 1, 2)));
 void G_important_message(const char *, ...)
     __attribute__ ((format(printf, 1, 2)));
-int G_fatal_error(const char *, ...) __attribute__ ((format(printf, 1, 2)))
+void G_fatal_error(const char *, ...) __attribute__ ((format(printf, 1, 2)))
     __attribute__ ((noreturn));
-int G_warning(const char *, ...) __attribute__ ((format(printf, 1, 2)));
+void G_warning(const char *, ...) __attribute__ ((format(printf, 1, 2)));
 int G_suppress_warnings(int);
 int G_sleep_on_error(int);
-int G_set_error_routine(int (*)(const char *, int));
-int G_unset_error_routine(void);
+void G_set_error_routine(int (*)(const char *, int));
+void G_unset_error_routine(void);
 void G_init_logging(void);
 
 /* file_name.c */
@@ -501,7 +505,7 @@ int G__write_row_ptrs(int);
 /* fpreclass.c */
 void G_fpreclass_clear(struct FPReclass *);
 void G_fpreclass_reset(struct FPReclass *);
-int G_fpreclass_init(struct FPReclass *);
+void G_fpreclass_init(struct FPReclass *);
 void G_fpreclass_set_domain(struct FPReclass *, DCELL, DCELL);
 void G_fpreclass_set_range(struct FPReclass *, DCELL, DCELL);
 int G_fpreclass_get_limits(const struct FPReclass *, DCELL *, DCELL *,
@@ -546,9 +550,9 @@ int G_begin_geodesic_equation(double, double, double, double);
 double G_geodesic_lat_from_lon(double);
 
 /* geodist.c */
-int G_begin_geodesic_distance(double, double);
-int G_set_geodesic_distance_lat1(double);
-int G_set_geodesic_distance_lat2(double);
+void G_begin_geodesic_distance(double, double);
+void G_set_geodesic_distance_lat1(double);
+void G_set_geodesic_distance_lat2(double);
 double G_geodesic_distance_lon_to_lon(double, double);
 double G_geodesic_distance(double, double, double, double);
 
@@ -602,36 +606,36 @@ char *G_gisbase(void);
 char *G_gisdbase(void);
 
 /* gisinit.c */
-int G__gisinit(const char *, const char *);
-int G__no_gisinit(const char *);
-int G__check_gisinit(void);
+void G__gisinit(const char *, const char *);
+void G__no_gisinit(const char *);
+void G__check_gisinit(void);
 
 /* histo_eq.c */
-int G_histogram_eq(const struct Histogram *, unsigned char **, CELL *,
-		   CELL *);
+void G_histogram_eq(const struct Histogram *, unsigned char **,
+		    CELL *, CELL *);
 
 /* histogram.c */
-int G_init_histogram(struct Histogram *);
+void G_init_histogram(struct Histogram *);
 int G_read_histogram(const char *, const char *, struct Histogram *);
 int G_write_histogram(const char *, const struct Histogram *);
 int G_write_histogram_cs(const char *, struct Cell_stats *);
-int G_make_histogram_cs(struct Cell_stats *, struct Histogram *);
+void G_make_histogram_cs(struct Cell_stats *, struct Histogram *);
 int G_get_histogram_num(const struct Histogram *);
 CELL G_get_histogram_cat(int, const struct Histogram *);
 long G_get_histogram_count(int, const struct Histogram *);
-int G_free_histogram(struct Histogram *);
+void G_free_histogram(struct Histogram *);
 int G_sort_histogram(struct Histogram *);
 int G_sort_histogram_by_count(struct Histogram *);
-int G_remove_histogram(const char *);
+void G_remove_histogram(const char *);
 int G_add_histogram(CELL, long, struct Histogram *);
 int G_set_histogram(CELL, long, struct Histogram *);
-int G_extend_histogram(CELL, long, struct Histogram *);
-int G_zero_histogram(struct Histogram *);
+void G_extend_histogram(CELL, long, struct Histogram *);
+void G_zero_histogram(struct Histogram *);
 
 /* history.c */
 int G_read_history(const char *, const char *, struct History *);
 int G_write_history(const char *, struct History *);
-int G_short_history(const char *, const char *, struct History *);
+void G_short_history(const char *, const char *, struct History *);
 int G_command_history(struct History *);
 
 /* home.c */
@@ -671,7 +675,7 @@ int G_is_mapset(const char *);
 struct Key_Value *G_create_key_value(void);
 int G_set_key_value(const char *, const char *, struct Key_Value *);
 char *G_find_key_value(const char *, const struct Key_Value *);
-int G_free_key_value(struct Key_Value *);
+void G_free_key_value(struct Key_Value *);
 
 /* key_value2.c */
 int G_fwrite_key_value(FILE *, const struct Key_Value *);
@@ -690,25 +694,25 @@ int G_legal_filename(const char *);
 int G_check_input_output_name(const char *, const char *, int);
 
 /* line_dist.c */
-int G_set_distance_to_line_tolerance(double);
+void G_set_distance_to_line_tolerance(double);
 double G_distance2_point_to_line(double, double, double, double, double,
 				 double);
 
 /* list.c */
-int G_list_element(const char *, const char *, const char *,
-		   int (*)(const char *, const char *, const char *));
+void G_list_element(const char *, const char *, const char *,
+		    int (*)(const char *, const char *, const char *));
 char **G_list(int, const char *, const char *, const char *);
 void G_free_list(char **);
 
 /* ll_format.c */
-int G_lat_format(double, char *);
+void G_lat_format(double, char *);
 char *G_lat_format_string(void);
-int G_lon_format(double, char *);
+void G_lon_format(double, char *);
 char *G_lon_format_string(void);
-int G_llres_format(double, char *);
+void G_llres_format(double, char *);
 char *G_llres_format_string(void);
-int G_lat_parts(double, int *, int *, double *, char *);
-int G_lon_parts(double, int *, int *, double *, char *);
+void G_lat_parts(double, int *, int *, double *, char *);
+void G_lon_parts(double, int *, int *, double *, char *);
 
 /* ll_scan.c */
 int G_lat_scan(const char *, double *);
@@ -803,14 +807,14 @@ int G_is_null_value(const void *, RASTER_MAP_TYPE);
 int G_is_c_null_value(const CELL *);
 int G_is_f_null_value(const FCELL *);
 int G_is_d_null_value(const DCELL *);
-int G_insert_null_values(void *, char *, int, RASTER_MAP_TYPE);
-int G_insert_c_null_values(CELL *, char *, int);
-int G_insert_f_null_values(FCELL *, char *, int);
-int G_insert_d_null_values(DCELL *, char *, int);
+void G_insert_null_values(void *, char *, int, RASTER_MAP_TYPE);
+void G_insert_c_null_values(CELL *, char *, int);
+void G_insert_f_null_values(FCELL *, char *, int);
+void G_insert_d_null_values(DCELL *, char *, int);
 int G__check_null_bit(const unsigned char *, int, int);
-int G__convert_01_flags(const char *, unsigned char *, int);
-int G__convert_flags_01(char *, const unsigned char *, int);
-int G__init_null_bits(unsigned char *, int);
+void G__convert_01_flags(const char *, unsigned char *, int);
+void G__convert_flags_01(char *, const unsigned char *, int);
+void G__init_null_bits(unsigned char *, int);
 
 /* open.c */
 int G_open_new(const char *, const char *);
@@ -862,7 +866,7 @@ struct Flag *G_define_flag(void);
 struct Option *G_define_option(void);
 struct Option *G_define_standard_option(int);
 int G_parser(int, char **);
-int G_usage(void);
+void G_usage(void);
 char *G_recreate_command(void);
 
 /* paths.c */
@@ -880,17 +884,17 @@ void G_percent(long, long, int);
 void G_percent_reset(void);
 
 /* plot.c */
-int G_setup_plot(double, double, double, double, int (*)(int, int),
-		 int (*)(int, int));
-int G_setup_fill(int);
-int G_plot_where_xy(double, double, int *, int *);
-int G_plot_where_en(int, int, double *, double *);
-int G_plot_point(double, double);
-int G_plot_line(double, double, double, double);
-int G_plot_line2(double, double, double, double);
+void G_setup_plot(double, double, double, double, int (*)(int, int),
+		  int (*)(int, int));
+void G_setup_fill(int);
+void G_plot_where_xy(double, double, int *, int *);
+void G_plot_where_en(int, int, double *, double *);
+void G_plot_point(double, double);
+void G_plot_line(double, double, double, double);
+void G_plot_line2(double, double, double, double);
 int G_plot_polygon(const double *, const double *, int);
 int G_plot_area(double *const *, double *const *, int *, int);
-int G_plot_fx(double (*)(double), double, double);
+void G_plot_fx(double (*)(double), double, double);
 
 /* pole_in_poly.c */
 int G_pole_in_polygon(const double *, const double *, int);
@@ -945,11 +949,11 @@ void G_putenv(const char *, const char *);
 void G_quant_clear(struct Quant *);
 void G_quant_free(struct Quant *);
 int G__quant_organize_fp_lookup(struct Quant *);
-int G_quant_init(struct Quant *);
+void G_quant_init(struct Quant *);
 int G_quant_is_truncate(const struct Quant *);
 int G_quant_is_round(const struct Quant *);
-int G_quant_truncate(struct Quant *);
-int G_quant_round(struct Quant *);
+void G_quant_truncate(struct Quant *);
+void G_quant_round(struct Quant *);
 int G_quant_get_limits(const struct Quant *, DCELL *, DCELL *, CELL *,
 		       CELL *);
 int G_quant_nof_rules(const struct Quant *);
@@ -986,30 +990,30 @@ double G_transverse_radius_of_curvature(double, double, double);
 double G_radius_of_conformal_tangent_sphere(double, double, double);
 
 /* range.c */
-int G__remove_fp_range(const char *);
-int G_construct_default_range(struct Range *);
+void G__remove_fp_range(const char *);
+void G_construct_default_range(struct Range *);
 int G_read_fp_range(const char *, const char *, struct FPRange *);
 int G_read_range(const char *, const char *, struct Range *);
 int G_write_range(const char *, const struct Range *);
 int G_write_fp_range(const char *, const struct FPRange *);
-int G_update_range(CELL, struct Range *);
-int G_update_fp_range(DCELL, struct FPRange *);
-int G_row_update_range(const CELL *, int, struct Range *);
-int G__row_update_range(const CELL *, int, struct Range *, int);
-int G_row_update_fp_range(const void *, int, struct FPRange *,
+void G_update_range(CELL, struct Range *);
+void G_update_fp_range(DCELL, struct FPRange *);
+void G_row_update_range(const CELL *, int, struct Range *);
+void G__row_update_range(const CELL *, int, struct Range *, int);
+void G_row_update_fp_range(const void *, int, struct FPRange *,
 			  RASTER_MAP_TYPE);
-int G_init_range(struct Range *);
-int G_get_range_min_max(const struct Range *, CELL *, CELL *);
-int G_init_fp_range(struct FPRange *);
-int G_get_fp_range_min_max(const struct FPRange *, DCELL *, DCELL *);
+void G_init_range(struct Range *);
+void G_get_range_min_max(const struct Range *, CELL *, CELL *);
+void G_init_fp_range(struct FPRange *);
+void G_get_fp_range_min_max(const struct FPRange *, DCELL *, DCELL *);
 
 /* raster.c */
 void *G_incr_void_ptr(const void *, const size_t);
 int G_raster_cmp(const void *, const void *, RASTER_MAP_TYPE);
-int G_raster_cpy(void *, const void *, int, RASTER_MAP_TYPE);
-int G_set_raster_value_c(void *, CELL, RASTER_MAP_TYPE);
-int G_set_raster_value_f(void *, FCELL, RASTER_MAP_TYPE);
-int G_set_raster_value_d(void *, DCELL, RASTER_MAP_TYPE);
+void G_raster_cpy(void *, const void *, int, RASTER_MAP_TYPE);
+void G_set_raster_value_c(void *, CELL, RASTER_MAP_TYPE);
+void G_set_raster_value_f(void *, FCELL, RASTER_MAP_TYPE);
+void G_set_raster_value_d(void *, DCELL, RASTER_MAP_TYPE);
 CELL G_get_raster_value_c(const void *, RASTER_MAP_TYPE);
 FCELL G_get_raster_value_f(const void *, RASTER_MAP_TYPE);
 DCELL G_get_raster_value_d(const void *, RASTER_MAP_TYPE);
@@ -1031,7 +1035,7 @@ char *G__read_Cell_head_array(char **, struct Cell_head *, int);
 int G_is_reclass(const char *, const char *, char *, char *);
 int G_is_reclassed_to(const char *, const char *, int *, char ***);
 int G_get_reclass(const char *, const char *, struct Reclass *);
-int G_free_reclass(struct Reclass *);
+void G_free_reclass(struct Reclass *);
 int G_put_reclass(const char *, const struct Reclass *);
 
 /* remove.c */
@@ -1066,7 +1070,7 @@ void G_get_set_window(struct Cell_head *);
 int G_set_window(struct Cell_head *);
 
 /* short_way.c */
-int G_shortest_way(double *, double *);
+void G_shortest_way(double *, double *);
 
 /* sleep.c */
 void G_sleep(unsigned int);
@@ -1080,7 +1084,7 @@ int G_strcasecmp(const char *, const char *);
 char *G_store(const char *);
 char *G_strchg(char *, char, char);
 char *G_str_replace(char *, const char *, const char *);
-int G_strip(char *);
+void G_strip(char *);
 char *G_chop(char *);
 void G_str_to_upper(char *);
 void G_str_to_lower(char *);
@@ -1098,7 +1102,7 @@ int G_system(const char *);
 /* tempfile.c */
 char *G_tempfile(void);
 char *G__tempfile(int);
-int G__temp_element(char *);
+void G__temp_element(char *);
 
 /* timestamp.c */
 void G_init_timestamp(struct TimeStamp *);
@@ -1107,7 +1111,7 @@ void G_set_timestamp_range(struct TimeStamp *, const DateTime *,
 			   const DateTime *);
 int G__read_timestamp(FILE *, struct TimeStamp *);
 int G__write_timestamp(FILE *, const struct TimeStamp *);
-int G_get_timestamps(const struct TimeStamp *, DateTime *, DateTime *, int *);
+void G_get_timestamps(const struct TimeStamp *, DateTime *, DateTime *, int *);
 int G_read_raster_timestamp(const char *, const char *, struct TimeStamp *);
 int G_read_vector_timestamp(const char *, const char *, struct TimeStamp *);
 int G_write_raster_timestamp(const char *, const struct TimeStamp *);
@@ -1123,10 +1127,13 @@ int G_write_grid3_timestamp(const char *, const struct TimeStamp *);
 /* token.c */
 char **G_tokenize(const char *, const char *);
 int G_number_of_tokens(char **);
-int G_free_tokens(char **);
+void G_free_tokens(char **);
 
 /* trim_dec.c */
-int G_trim_decimal(char *);
+void G_trim_decimal(char *);
+
+/* user_config.c */
+char *G_rc_path(const char *, const char *);
 
 /* verbose.c */
 int G_verbose(void);
@@ -1136,7 +1143,7 @@ int G_verbose_max(void);
 int G_set_verbose(int);
 
 /* view.c */
-int G_3dview_warning(int);
+void G_3dview_warning(int);
 int G_get_3dview_defaults(struct G_3dview *, struct Cell_head *);
 int G_put_3dview(const char *, const char *, const struct G_3dview *,
 		 const struct Cell_head *);
@@ -1146,13 +1153,13 @@ int G_get_3dview(const char *, const char *, struct G_3dview *);
 char *G_whoami(void);
 
 /* wind_2_box.c */
-int G_adjust_window_to_box(const struct Cell_head *, struct Cell_head *, int,
-			   int);
+void G_adjust_window_to_box(const struct Cell_head *, struct Cell_head *, int,
+			    int);
 
 /* wind_format.c */
-int G_format_northing(double, char *, int);
-int G_format_easting(double, char *, int);
-int G_format_resolution(double, char *, int);
+void G_format_northing(double, char *, int);
+void G_format_easting(double, char *, int);
+void G_format_resolution(double, char *, int);
 
 /* wind_in.c */
 int G_point_in_region(double, double);
@@ -1176,7 +1183,7 @@ int G_scan_easting(const char *, double *, int);
 int G_scan_resolution(const char *, double *, int);
 
 /* window_map.c */
-int G__create_window_mapping(int);
+void G__create_window_mapping(int);
 double G_northing_to_row(double, const struct Cell_head *);
 double G_adjust_east_longitude(double, double);
 double G_adjust_easting(double, const struct Cell_head *);
@@ -1185,22 +1192,22 @@ double G_row_to_northing(double, const struct Cell_head *);
 double G_col_to_easting(double, const struct Cell_head *);
 int G_window_rows(void);
 int G_window_cols(void);
-int G__init_window(void);
+void G__init_window(void);
 int G_row_repeat_nomask(int, int);
 
 /* wr_cellhd.c */
-int G__write_Cell_head(FILE *, const struct Cell_head *, int);
-int G__write_Cell_head3(FILE *, const struct Cell_head *, int);
+void G__write_Cell_head(FILE *, const struct Cell_head *, int);
+void G__write_Cell_head3(FILE *, const struct Cell_head *, int);
 
 /* writ_zeros.c */
-int G_write_zeros(int, size_t);
+void G_write_zeros(int, size_t);
 
 /* zero.c */
-int G_zero(void *, int);
+void G_zero(void *, int);
 
 /* zero_cell.c */
-int G_zero_cell_buf(CELL *);
-int G_zero_raster_buf(void *, RASTER_MAP_TYPE);
+void G_zero_cell_buf(CELL *);
+void G_zero_raster_buf(void *, RASTER_MAP_TYPE);
 
 /* zone.c */
 int G_zone(void);

lib/g3d/g3dcolor.c

@@ -326,7 +326,6 @@ G3d_writeColors(const char *name, const char *mapset, struct Colors *colors)
  /* adapted from G_write_colors */
 {
     FILE *fd;
-    int stat;
 
     if (strcmp(mapset, G_mapset()) != 0) {
 	G_warning(_("mapset <%s> is not the current mapset"), mapset);
@@ -337,10 +336,10 @@ G3d_writeColors(const char *name, const char *mapset, struct Colors *colors)
     if (!fd)
 	return -1;
 
-    stat = G__write_colors(fd, colors);
+    G__write_colors(fd, colors);
     fclose(fd);
 
-    return stat;
+    return 1;
 }
 
 /*---------------------------------------------------------------------------*/

lib/g3d/g3drange.c

@@ -214,5 +214,6 @@ int G3d_range_write(G3D_Map * map)
 
 int G3d_range_init(G3D_Map * map)
 {
-    return G_init_fp_range(&(map->range));
+    G_init_fp_range(&(map->range));
+    return 0;
 }

lib/gis/area_ellipse.c

@@ -46,15 +46,13 @@ static struct state *st = &state;
  * \param[in] a semi-major axis
  * \param[in] e2 ellipsoid eccentricity
  * \param[in] s scale factor
- * \return always returns 0
+ * \return
  */
 
-int G_begin_zone_area_on_ellipsoid(double a, double e2, double s)
+void G_begin_zone_area_on_ellipsoid(double a, double e2, double s)
 {
     st->E = sqrt(e2);
     st->M = s * a * a * M_PI * (1 - e2) / st->E;
-
-    return 0;
 }
 
 

lib/gis/area_poly1.c

@@ -61,10 +61,10 @@ static double Qbar(double x)
  *
  * \param[in] a semi-major axis
  * \param[in] e2 ellipsoid eccentricity
- * \return always returns 0
+ * \return
  */
 
-int G_begin_ellipsoid_polygon_area(double a, double e2)
+void G_begin_ellipsoid_polygon_area(double a, double e2)
 {
     double e4, e6;
 
@@ -86,8 +86,6 @@ int G_begin_ellipsoid_polygon_area(double a, double e2)
     st->E = 4 * M_PI * st->Qp * st->AE;
     if (st->E < 0.0)
 	st->E = -st->E;
-
-    return 0;
 }
 
 

lib/gis/area_sphere.c

@@ -39,12 +39,12 @@ static struct state *st = &state;
  *
  * \param[in] r radius of sphere
  * \param[in] s scale factor
- * \return int
+ * \return
  */
 
-int G_begin_zone_area_on_sphere(double r, double s)
+void G_begin_zone_area_on_sphere(double r, double s)
 {
-    return (st->M = s * 2.0 * r * r * M_PI);
+    st->M = s * 2.0 * r * r * M_PI;
 }
 
 

lib/gis/ascii_chk.c

@@ -28,10 +28,10 @@
  * tabs, which are turned into spaces.
  *
  * \param[in,out] string buffer to have non-ascii characters removed
- * \return always returns 0
+ * \return
  */
 
-int G_ascii_check(char *string)
+void G_ascii_check(char *string)
 {
     char *ptr1, *ptr2;
 
@@ -46,6 +46,4 @@ int G_ascii_check(char *string)
 	ptr1++;
     }
     *ptr2 = 0;
-
-    return 0;
 }

lib/gis/auto_mask.c

@@ -76,10 +76,10 @@ int G__check_for_auto_masking(void)
 /**
  * \brief Suppresses masking.
  *
- * \return always returns 0
+ * \return
  */
 
-int G_suppress_masking(void)
+void G_suppress_masking(void)
 {
     if (G__.auto_mask > 0) {
 	G_close_cell(G__.mask_fd);
@@ -87,23 +87,19 @@ int G_suppress_masking(void)
 	G__.mask_fd = -1;
     }
     G__.auto_mask = -2;
-
-    return 0;
 }
 
 
 /**
  * \brief Unsuppresses masking.
  *
- * \return always returns 0
+ * \return
  */
 
-int G_unsuppress_masking(void)
+void G_unsuppress_masking(void)
 {
     if (G__.auto_mask < -1) {
 	G__.mask_fd = -1;
 	G__check_for_auto_masking();
     }
-
-    return 0;
 }

lib/gis/bres_line.c

@@ -32,10 +32,10 @@
  * \param[in] x1
  * \param[in] y1
  * \param[in] point pointer to point plotting function
- * \return always returns 0
+ * \return
  */
 
-int G_bresenham_line(int x0, int y0, int x1, int y1, int (*point) (int, int))
+void G_bresenham_line(int x0, int y0, int x1, int y1, int (*point) (int, int))
 {
     int dx, dy;
     int xinc, yinc;
@@ -90,6 +90,4 @@ int G_bresenham_line(int x0, int y0, int x1, int y1, int (*point) (int, int))
     }
 
     point(x1, y1);
-
-    return 0;
 }

lib/gis/cats.c

@@ -325,7 +325,7 @@
 #include <grass/gis.h>
 #include <grass/glocale.h>
 
-static int get_cond(char **, char *, DCELL);
+static void get_cond(char **, char *, DCELL);
 static int get_fmt(char **, char *, int *);
 static int cmp(const void *, const void *);
 
@@ -725,16 +725,15 @@ char *G_get_raster_cat(void *rast,
  * used and which weren't.
  *
  *  \param pcats
- *  \return int
+ *  \return
  */
 
-int G_unmark_raster_cats(struct Categories *pcats)
+void G_unmark_raster_cats(struct Categories *pcats)
 {				/* structure to hold category info */
     int i;
 
     for (i = 0; i < pcats->ncats; i++)
 	pcats->marks[i] = 0;
-    return 0;
 }
 
 
@@ -749,14 +748,13 @@ int G_unmark_raster_cats(struct Categories *pcats)
  *  \param rast_row
  *  \param ncols
  *  \param pcats
- *  \return int
+ *  \return
  */
 
-int G_mark_c_raster_cats(const CELL * rast_row,	/* raster row to update stats */
-			 int ncols, struct Categories *pcats)
+void G_mark_c_raster_cats(const CELL * rast_row,	/* raster row to update stats */
+			  int ncols, struct Categories *pcats)
 {				/* structure to hold category info */
     G_mark_raster_cats(rast_row, ncols, pcats, CELL_TYPE);
-    return 0;
 }
 
 
@@ -771,14 +769,13 @@ int G_mark_c_raster_cats(const CELL * rast_row,	/* raster row to update stats */
  *  \param rast_row
  *  \param ncols
  *  \param pcats
- *  \return int
+ *  \return 
  */
 
-int G_mark_f_raster_cats(const FCELL * rast_row,	/* raster row to update stats */
+void G_mark_f_raster_cats(const FCELL * rast_row,	/* raster row to update stats */
 			 int ncols, struct Categories *pcats)
 {				/* structure to hold category info */
     G_mark_raster_cats(rast_row, ncols, pcats, FCELL_TYPE);
-    return 0;
 }
 
 
@@ -793,14 +790,13 @@ int G_mark_f_raster_cats(const FCELL * rast_row,	/* raster row to update stats *
  *  \param rast_row
  *  \param ncols
  *  \param pcats
- *  \return int
+ *  \return 
  */
 
-int G_mark_d_raster_cats(const DCELL * rast_row,	/* raster row to update stats */
-			 int ncols, struct Categories *pcats)
+void G_mark_d_raster_cats(const DCELL * rast_row,	/* raster row to update stats */
+			  int ncols, struct Categories *pcats)
 {				/* structure to hold category info */
     G_mark_raster_cats(rast_row, ncols, pcats, DCELL_TYPE);
-    return 0;
 }
 
 
@@ -848,13 +844,12 @@ int G_mark_raster_cats(const void *rast_row,	/* raster row to update stats */
  * cat label.
  *
  *  \param pcats
- *  \return int
+ *  \return
  */
 
-int G_rewind_raster_cats(struct Categories *pcats)
+void G_rewind_raster_cats(struct Categories *pcats)
 {
     pcats->last_marked_rule = -1;
-    return 0;
 }
 
 char *G_get_next_marked_d_raster_cat(struct Categories *pcats,	/* structure to hold category info */
@@ -955,7 +950,7 @@ static int get_fmt(char **f, char *fmt, int *i)
     return 1;
 }
 
-static int get_cond(char **f, char *value, DCELL val)
+static void get_cond(char **f, char *value, DCELL val)
 {
     char *ff;
 
@@ -981,8 +976,6 @@ static int get_cond(char **f, char *value, DCELL val)
     }
     *value = 0;
     *f = ff;
-
-    return 0;
 }
 
 
@@ -1406,14 +1399,12 @@ char *G_get_ith_raster_cat(const struct Categories *pcats, int i, void *rast1,
  *  \param n
  *  \param title
  *  \param cats
- *  \return int
  */
 
-int G_init_cats(CELL num, const char *title, struct Categories *pcats)
+void G_init_cats(CELL num, const char *title, struct Categories *pcats)
 {
     G_init_raster_cats(title, pcats);
     pcats->num = num;
-    return 0;
 }
 
 
@@ -1426,10 +1417,10 @@ int G_init_cats(CELL num, const char *title, struct Categories *pcats)
  *
  *  \param title
  *  \param pcats
- *  \return int
+ *  \return
  */
 
-int G_init_raster_cats(const char *title, struct Categories *pcats)
+void G_init_raster_cats(const char *title, struct Categories *pcats)
 {
     G_set_raster_cats_title(title, pcats);
     pcats->labels = NULL;
@@ -1443,7 +1434,6 @@ int G_init_raster_cats(const char *title, struct Categories *pcats)
     pcats->a2 = 0.0;
     pcats->last_marked_rule = -1;
     G_quant_init(&pcats->q);
-    return 0;
 }
 
 
@@ -1455,13 +1445,12 @@ int G_init_raster_cats(const char *title, struct Categories *pcats)
  *
  *  \param title
  *  \param cats
- *  \return int
+ *  \return
  */
 
-int G_set_cats_title(const char *title, struct Categories *pcats)
+void G_set_cats_title(const char *title, struct Categories *pcats)
 {
     G_set_raster_cats_title(title, pcats);
-    return 0;
 }
 
 
@@ -1472,24 +1461,22 @@ int G_set_cats_title(const char *title, struct Categories *pcats)
  *
  *  \param title
  *  \param pcats
- *  \return int
+ *  \return
  */
 
-int G_set_raster_cats_title(const char *title, struct Categories *pcats)
+void G_set_raster_cats_title(const char *title, struct Categories *pcats)
 {
     if (title == NULL)
 	title = "";
     pcats->title = G_store(title);
     G_newlines_to_spaces(pcats->title);
     G_strip(pcats->title);
-    return 0;
 }
 
-int G_set_cats_fmt(const char *fmt, double m1, double a1, double m2,
-		   double a2, struct Categories *pcats)
+void G_set_cats_fmt(const char *fmt, double m1, double a1, double m2,
+		    double a2, struct Categories *pcats)
 {
     G_set_raster_cats_fmt(fmt, m1, a1, m2, a2, pcats);
-    return 0;
 }
 
 
@@ -1504,10 +1491,9 @@ int G_set_cats_fmt(const char *fmt, double m1, double a1, double m2,
  *  \param m2
  *  \param a2
  *  \param pcats
- *  \return int
  */
 
-int G_set_raster_cats_fmt(const char *fmt, double m1, double a1, double m2,
+void G_set_raster_cats_fmt(const char *fmt, double m1, double a1, double m2,
 			  double a2, struct Categories *pcats)
 {
     pcats->m1 = m1;
@@ -1518,7 +1504,6 @@ int G_set_raster_cats_fmt(const char *fmt, double m1, double a1, double m2,
     pcats->fmt = G_store(fmt);
     G_newlines_to_spaces(pcats->fmt);
     G_strip(pcats->fmt);
-    return 0;
 }
 
 
@@ -1529,13 +1514,12 @@ int G_set_raster_cats_fmt(const char *fmt, double m1, double a1, double m2,
  * and<i>G_set_cat.</i>
  *
  *  \param cats
- *  \return int
+ *  \return
  */
 
-int G_free_cats(struct Categories *pcats)
+void G_free_cats(struct Categories *pcats)
 {
     G_free_raster_cats(pcats);
-    return 0;
 }
 
 
@@ -1545,10 +1529,10 @@ int G_free_cats(struct Categories *pcats)
  * Same as existing G_free_cats()
  *
  *  \param pcats
- *  \return int
+ *  \return
  */
 
-int G_free_raster_cats(struct Categories *pcats)
+void G_free_raster_cats(struct Categories *pcats)
 {
     int i;
 
@@ -1571,7 +1555,6 @@ int G_free_raster_cats(struct Categories *pcats)
     G_quant_free(&pcats->q);
     pcats->ncats = 0;
     pcats->nalloc = 0;
-    return 0;
 }
 
 
@@ -1586,12 +1569,11 @@ int G_free_raster_cats(struct Categories *pcats)
  *
  *  \param pcats_to
  *  \param pcats_from
- *  \return int
+ *  \return
  */
 
-int
-G_copy_raster_cats(struct Categories *pcats_to,
-		   const struct Categories *pcats_from)
+void G_copy_raster_cats(struct Categories *pcats_to,
+			const struct Categories *pcats_from)
 {
     int i;
     char *descr;
@@ -1602,7 +1584,6 @@ G_copy_raster_cats(struct Categories *pcats_to,
 	descr = G_get_ith_d_raster_cat(pcats_from, i, &d1, &d2);
 	G_set_d_raster_cat(&d1, &d2, descr, pcats_to);
     }
-    return 0;
 }
 
 int G_number_of_raster_cats(struct Categories *pcats)

lib/gis/cell_stats.c

@@ -9,7 +9,7 @@ static const int NCATS = 1 << SHIFT;
 #define NODE struct Cell_stats_node
 
 static int next_node(struct Cell_stats *);
-static int init_node(NODE *, int, int);
+static void init_node(NODE *, int, int);
 
 
 /*!
@@ -28,17 +28,15 @@ static int init_node(NODE *, int, int);
  *
  * Set the count for NULL-values to zero.
  *
- *  \return int
+ *  \return
  */
 
-int G_init_cell_stats(struct Cell_stats *s)
+void G_init_cell_stats(struct Cell_stats *s)
 {
     s->N = 0;
     s->tlen = INCR;
     s->node = (NODE *) G_malloc(s->tlen * sizeof(NODE));
     s->null_data_count = 0;
-
-    return 1;
 }
 
 
@@ -161,7 +159,7 @@ int G_update_cell_stats(const CELL * cell, int n, struct Cell_stats *s)
     return 0;
 }
 
-static int init_node(NODE * node, int idx, int offset)
+static void init_node(NODE * node, int idx, int offset)
 {
     long *count;
     int i;
@@ -172,8 +170,6 @@ static int init_node(NODE * node, int idx, int offset)
     node->idx = idx;
     node->count[offset] = 1;
     node->left = 0;
-
-    return 0;
 }
 
 
@@ -390,13 +386,12 @@ int G_next_cell_stat(CELL * cat, long *count, struct Cell_stats *s)
  *
  *  \param count
  *  \param s
- *  \return int
+ *  \return
  */
 
-int G_get_stats_for_null_value(long *count, const struct Cell_stats *s)
+void G_get_stats_for_null_value(long *count, const struct Cell_stats *s)
 {
     *count = s->null_data_count;
-    return 1;
 }
 
 
@@ -407,16 +402,14 @@ int G_get_stats_for_null_value(long *count, const struct Cell_stats *s)
  * called any time after calling<i>G_init_cell_stats.</i>
  *
  *  \param s
- *  \return int
+ *  \return
  */
 
-int G_free_cell_stats(struct Cell_stats *s)
+void G_free_cell_stats(struct Cell_stats *s)
 {
     int i;
 
     for (i = 1; i <= s->N; i++)
 	G_free(s->node[i].count);
     G_free(s->node);
-
-    return 0;
 }

lib/gis/clear_scrn.c

@@ -9,13 +9,11 @@
 #include <stdlib.h>
 #include <grass/gis.h>
 
-int G_clear_screen(void)
+void G_clear_screen(void)
 {
 #ifdef __MINGW32__
     system("cls");
 #else
     system("clear");
 #endif
-
-    return 0;
 }

lib/gis/color_compat.c

@@ -32,28 +32,28 @@
  *  \param colors
  *  \param min
  *  \param max
- *  \return int
+ *  \return
  */
 
-int G_make_wave_colors(struct Colors *colors, CELL min, CELL max)
+void G_make_wave_colors(struct Colors *colors, CELL min, CELL max)
 {
-    return G_make_colors(colors, "wave", min, max);
+    G_make_colors(colors, "wave", min, max);
 }
 
-int G_make_wave_fp_colors(struct Colors *colors, DCELL min, DCELL max)
+void G_make_wave_fp_colors(struct Colors *colors, DCELL min, DCELL max)
 {
-    return G_make_fp_colors(colors, "wave", min, max);
+    G_make_fp_colors(colors, "wave", min, max);
 }
 
 
-int G_make_ryg_colors(struct Colors *colors, CELL min, CELL max)
+void G_make_ryg_colors(struct Colors *colors, CELL min, CELL max)
 {
-    return G_make_colors(colors, "ryg", min, max);
+    G_make_colors(colors, "ryg", min, max);
 }
 
-int G_make_ryg_fp_colors(struct Colors *colors, DCELL min, DCELL max)
+void G_make_ryg_fp_colors(struct Colors *colors, DCELL min, DCELL max)
 {
-    return G_make_fp_colors(colors, "ryg", min, max);
+    G_make_fp_colors(colors, "ryg", min, max);
 }
 
 /*!
@@ -66,17 +66,17 @@ int G_make_ryg_fp_colors(struct Colors *colors, DCELL min, DCELL max)
  *  \param colors
  *  \param min
  *  \param max
- *  \return int
+ *  \return
  */
 
-int G_make_ramp_colors(struct Colors *colors, CELL min, CELL max)
+void G_make_ramp_colors(struct Colors *colors, CELL min, CELL max)
 {
-    return G_make_colors(colors, "ramp", min, max);
+    G_make_colors(colors, "ramp", min, max);
 }
 
-int G_make_ramp_fp_colors(struct Colors *colors, DCELL min, DCELL max)
+void G_make_ramp_fp_colors(struct Colors *colors, DCELL min, DCELL max)
 {
-    return G_make_fp_colors(colors, "ramp", min, max);
+    G_make_fp_colors(colors, "ramp", min, max);
 }
 
 /*!
@@ -91,28 +91,28 @@ int G_make_ramp_fp_colors(struct Colors *colors, DCELL min, DCELL max)
  *  \param colors
  *  \param min
  *  \param max
- *  \return int
+ *  \return
  */
 
-int G_make_rainbow_colors(struct Colors *colors, CELL min, CELL max)
+void G_make_rainbow_colors(struct Colors *colors, CELL min, CELL max)
 {
-    return G_make_colors(colors, "rainbow", min, max);
+    G_make_colors(colors, "rainbow", min, max);
 }
 
-int G_make_rainbow_fp_colors(struct Colors *colors, DCELL min, DCELL max)
+void G_make_rainbow_fp_colors(struct Colors *colors, DCELL min, DCELL max)
 {
-    return G_make_fp_colors(colors, "rainbow", min, max);
+    G_make_fp_colors(colors, "rainbow", min, max);
 }
 
 
-int G_make_gyr_colors(struct Colors *colors, CELL min, CELL max)
+void G_make_gyr_colors(struct Colors *colors, CELL min, CELL max)
 {
-    return G_make_colors(colors, "gyr", min, max);
+    G_make_colors(colors, "gyr", min, max);
 }
 
-int G_make_gyr_fp_colors(struct Colors *colors, DCELL min, DCELL max)
+void G_make_gyr_fp_colors(struct Colors *colors, DCELL min, DCELL max)
 {
-    return G_make_fp_colors(colors, "gyr", min, max);
+    G_make_fp_colors(colors, "gyr", min, max);
 }
 
 /*!
@@ -124,47 +124,47 @@ int G_make_gyr_fp_colors(struct Colors *colors, DCELL min, DCELL max)
  *  \param colors
  *  \param min
  *  \param max
- *  \return int
+ *  \return
  */
 
-int G_make_grey_scale_colors(struct Colors *colors, CELL min, CELL max)
+void G_make_grey_scale_colors(struct Colors *colors, CELL min, CELL max)
 {
-    return G_make_colors(colors, "grey", min, max);
+    G_make_colors(colors, "grey", min, max);
 }
 
-int G_make_grey_scale_fp_colors(struct Colors *colors, DCELL min, DCELL max)
+void G_make_grey_scale_fp_colors(struct Colors *colors, DCELL min, DCELL max)
 {
-    return G_make_fp_colors(colors, "grey", min, max);
+    G_make_fp_colors(colors, "grey", min, max);
 }
 
-int G_make_byr_colors(struct Colors *colors, CELL min, CELL max)
+void G_make_byr_colors(struct Colors *colors, CELL min, CELL max)
 {
-    return G_make_colors(colors, "byr", min, max);
+    G_make_colors(colors, "byr", min, max);
 }
 
-int G_make_byr_fp_colors(struct Colors *colors, DCELL min, DCELL max)
+void G_make_byr_fp_colors(struct Colors *colors, DCELL min, DCELL max)
 {
-    return G_make_fp_colors(colors, "byr", min, max);
+    G_make_fp_colors(colors, "byr", min, max);
 }
 
-int G_make_bgyr_colors(struct Colors *colors, CELL min, CELL max)
+void G_make_bgyr_colors(struct Colors *colors, CELL min, CELL max)
 {
-    return G_make_colors(colors, "bgyr", min, max);
+    G_make_colors(colors, "bgyr", min, max);
 }
 
-int G_make_bgyr_fp_colors(struct Colors *colors, DCELL min, DCELL max)
+void G_make_bgyr_fp_colors(struct Colors *colors, DCELL min, DCELL max)
 {
-    return G_make_fp_colors(colors, "bgyr", min, max);
+    G_make_fp_colors(colors, "bgyr", min, max);
 }
 
-int G_make_byg_colors(struct Colors *colors, CELL min, CELL max)
+void G_make_byg_colors(struct Colors *colors, CELL min, CELL max)
 {
-    return G_make_colors(colors, "byg", min, max);
+    G_make_colors(colors, "byg", min, max);
 }
 
-int G_make_byg_fp_colors(struct Colors *colors, DCELL min, DCELL max)
+void G_make_byg_fp_colors(struct Colors *colors, DCELL min, DCELL max)
 {
-    return G_make_fp_colors(colors, "byg", min, max);
+    G_make_fp_colors(colors, "byg", min, max);
 }
 
 /*!
@@ -175,15 +175,15 @@ int G_make_byg_fp_colors(struct Colors *colors, DCELL min, DCELL max)
  *  \param colors
  *  \param min
  *  \param max
- *  \return int
+ *  \return
  */
 
-int G_make_aspect_colors(struct Colors *colors, CELL min, CELL max)
+void G_make_aspect_colors(struct Colors *colors, CELL min, CELL max)
 {
-    return G_make_colors(colors, "aspect", min, max);
+    G_make_colors(colors, "aspect", min, max);
 }
 
-int G_make_aspect_fp_colors(struct Colors *colors, DCELL min, DCELL max)
+void G_make_aspect_fp_colors(struct Colors *colors, DCELL min, DCELL max)
 {
-    return G_make_fp_colors(colors, "aspect", min, max);
+    G_make_fp_colors(colors, "aspect", min, max);
 }

lib/gis/color_free.c

@@ -11,15 +11,13 @@
  * well as after <i>G_init_colors.</i>
  *
  *  \param colors
- *  \return int
+ *  \return
  */
 
-int G_free_colors(struct Colors *colors)
+void G_free_colors(struct Colors *colors)
 {
     G__color_reset(colors);
     G_init_colors(colors);
-
-    return 0;
 }
 
 /*******************************************
@@ -27,7 +25,7 @@ int G_free_colors(struct Colors *colors)
  * library
  *******************************************/
 
-int G__color_free_rules(struct _Color_Info_ *cp)
+void G__color_free_rules(struct _Color_Info_ *cp)
 {
     struct _Color_Rule_ *rule, *next;
 
@@ -36,11 +34,9 @@ int G__color_free_rules(struct _Color_Info_ *cp)
 	G_free(rule);
     }
     cp->rules = NULL;
-
-    return 0;
 }
 
-int G__color_free_lookup(struct _Color_Info_ *cp)
+void G__color_free_lookup(struct _Color_Info_ *cp)
 {
     if (cp->lookup.active) {
 	G_free(cp->lookup.red);
@@ -49,11 +45,9 @@ int G__color_free_lookup(struct _Color_Info_ *cp)
 	G_free(cp->lookup.set);
 	cp->lookup.active = 0;
     }
-
-    return 0;
 }
 
-int G__color_free_fp_lookup(struct _Color_Info_ *cp)
+void G__color_free_fp_lookup(struct _Color_Info_ *cp)
 {
     if (cp->fp_lookup.active) {
 	G_free(cp->fp_lookup.vals);
@@ -61,11 +55,9 @@ int G__color_free_fp_lookup(struct _Color_Info_ *cp)
 	cp->fp_lookup.active = 0;
 	cp->fp_lookup.nalloc = 0;
     }
-
-    return 0;
 }
 
-int G__color_reset(struct Colors *colors)
+void G__color_reset(struct Colors *colors)
 {
     G__color_free_lookup(&colors->fixed);
     G__color_free_lookup(&colors->modular);
@@ -73,6 +65,4 @@ int G__color_reset(struct Colors *colors)
     G__color_free_rules(&colors->modular);
     colors->version = 0;
     /* this routine should NOT init the colors */
-
-    return 0;
 }

lib/gis/color_get.c

@@ -153,10 +153,10 @@ int G_get_d_raster_color(const DCELL * rast,
  *  \param[out] grn green value
  *  \param[out] blu blue value
  *  \param[in] colors Colors struct
- *  \return always returns 0
+ *  \return
  */
 
-int G_get_null_value_color(int *red, int *grn, int *blu,
+void G_get_null_value_color(int *red, int *grn, int *blu,
 			   const struct Colors *colors)
 {
     if (colors->null_set) {
@@ -171,8 +171,6 @@ int G_get_null_value_color(int *red, int *grn, int *blu,
     }
     else
 	*red = *blu = *grn = 255;	/* white */
-
-    return 0;
 }
 
 
@@ -186,11 +184,11 @@ int G_get_null_value_color(int *red, int *grn, int *blu,
  *  \param[out] grn green value
  *  \param[out] blu blue value
  *  \param[in] colors Colors struct
- *  \return always returns 0
+ *  \return
  */
 
-int G_get_default_color(int *red, int *grn, int *blu,
-			const struct Colors *colors)
+void G_get_default_color(int *red, int *grn, int *blu,
+			 const struct Colors *colors)
 {
     if (colors->undef_set) {
 	*red = (int)colors->undef_red;
@@ -199,6 +197,4 @@ int G_get_default_color(int *red, int *grn, int *blu,
     }
     else
 	*red = *blu = *grn = 255;	/* white */
-
-    return 0;
 }

lib/gis/color_hist.c

@@ -36,11 +36,11 @@
  *
  *  \param colors
  *  \param s
- *  \return int
+ *  \return
  */
 
-int G_make_histogram_eq_colors(struct Colors *colors,
-			       struct Cell_stats *statf)
+void G_make_histogram_eq_colors(struct Colors *colors,
+				struct Cell_stats *statf)
 {
     long count, total;
     CELL prev = 0, cat;
@@ -61,7 +61,7 @@ int G_make_histogram_eq_colors(struct Colors *colors,
 	if (count > 0)
 	    total += count;
     if (total <= 0)
-	return 0;
+	return;
 
     span = total / 256.0;
     first = 1;
@@ -94,13 +94,10 @@ int G_make_histogram_eq_colors(struct Colors *colors,
 	G_add_color_rule(prev, grey, grey, grey, cat, grey, grey, grey,
 			 colors);
     }
-
-    return 0;
 }
 
-
-int G_make_histogram_log_colors(struct Colors *colors,
-				struct Cell_stats *statf, int min, int max)
+void G_make_histogram_log_colors(struct Colors *colors,
+				 struct Cell_stats *statf, int min, int max)
 {
     long count, total;
     double lmin, lmax;
@@ -121,7 +118,7 @@ int G_make_histogram_log_colors(struct Colors *colors,
 	if (count > 0)
 	    total += count;
     if (total <= 0)
-	return 0;
+	return;
 
     first = 1;
     grey = 0;
@@ -157,6 +154,4 @@ int G_make_histogram_log_colors(struct Colors *colors,
 	G_add_color_rule(prev, grey, grey, grey, cat, grey, grey, grey,
 			 colors);
     }
-
-    return 0;
 }

lib/gis/color_init.c

@@ -17,10 +17,10 @@
  * to <i>G_add_color_rule</i> and<i>G_set_color.</i>
  *
  *  \param colors
- *  \return int
+ *  \return
  */
 
-int G_init_colors(struct Colors *colors)
+void G_init_colors(struct Colors *colors)
 {
     colors->version = 0;
     colors->null_set = 0;
@@ -45,6 +45,4 @@ int G_init_colors(struct Colors *colors)
     colors->modular.fp_lookup.active = 0;
     colors->modular.fp_lookup.nalloc = 0;
     colors->organizing = 0;
-
-    return 0;
 }

lib/gis/color_invrt.c

@@ -1,8 +1,6 @@
 #include <grass/gis.h>
 
-int G_invert_colors(struct Colors *colors)
+void G_invert_colors(struct Colors *colors)
 {
     colors->invert = !colors->invert;
-
-    return 0;
 }

lib/gis/color_look.c

@@ -32,17 +32,15 @@
  *
  * Modified to return a color for NULL-values.
  *
- * \return int
+ * \return
  */
 
-int G_lookup_colors(const CELL * cell,
-		    unsigned char *red, unsigned char *grn,
-		    unsigned char *blu, unsigned char *set, int n,
-		    struct Colors *colors)
+void G_lookup_colors(const CELL * cell,
+		     unsigned char *red, unsigned char *grn,
+		     unsigned char *blu, unsigned char *set, int n,
+		     struct Colors *colors)
 {
     G_lookup_c_raster_colors(cell, red, grn, blu, set, n, colors);
-
-    return 0;
 }
 
 /* I don't think it should exist, because it requires openning
@@ -70,13 +68,13 @@ int G_lookup_colors(const CELL * cell,
  *  \param set
  *  \param n
  *  \param colors
- *  \return int
+ *  \return
  */
 
-int G_lookup_c_raster_colors(const CELL * cell,
-			     unsigned char *red, unsigned char *grn,
-			     unsigned char *blu, unsigned char *set, int n,
-			     struct Colors *colors)
+void G_lookup_c_raster_colors(const CELL * cell,
+			      unsigned char *red, unsigned char *grn,
+			      unsigned char *blu, unsigned char *set, int n,
+			      struct Colors *colors)
 {
     G__organize_colors(colors);	/* make sure the lookup tables are in place */
 
@@ -89,8 +87,6 @@ int G_lookup_c_raster_colors(const CELL * cell,
     /* now lookup unset colors using the modular rules */
     G__lookup_colors((void *)cell, red, grn, blu, set, n, colors, 1, 0,
 		     CELL_TYPE);
-
-    return 0;
 }
 
 
@@ -112,13 +108,13 @@ int G_lookup_c_raster_colors(const CELL * cell,
  *  \param n
  *  \param colors
  *  \param cell_type
- *  \return int
+ *  \return 
  */
 
-int G_lookup_raster_colors(const void *raster,
-			   unsigned char *red, unsigned char *grn,
-			   unsigned char *blu, unsigned char *set, int n,
-			   struct Colors *colors, RASTER_MAP_TYPE map_type)
+void G_lookup_raster_colors(const void *raster,
+			    unsigned char *red, unsigned char *grn,
+			    unsigned char *blu, unsigned char *set, int n,
+			    struct Colors *colors, RASTER_MAP_TYPE map_type)
 {
     G__organize_colors(colors);	/* make sure the lookup tables are in place */
     /* in case of float color rules, fp_lookup table is created */
@@ -130,8 +126,6 @@ int G_lookup_raster_colors(const void *raster,
 
     /* now lookup unset colors using the modular rules */
     G__lookup_colors(raster, red, grn, blu, set, n, colors, 1, 0, map_type);
-
-    return 0;
 }
 
 
@@ -149,12 +143,12 @@ int G_lookup_raster_colors(const void *raster,
  *  \param set
  *  \param n
  *  \param colors
- *  \return int
+ *  \return
  */
 
-int G_lookup_f_raster_colors(const FCELL * fcell, unsigned char *red,
-			     unsigned char *grn, unsigned char *blu,
-			     unsigned char *set, int n, struct Colors *colors)
+void G_lookup_f_raster_colors(const FCELL * fcell, unsigned char *red,
+			      unsigned char *grn, unsigned char *blu,
+			      unsigned char *set, int n, struct Colors *colors)
 {
     G__organize_colors(colors);	/* make sure the lookup tables are in place */
     /* in case of float color rules, fp_lookup table is created */
@@ -168,8 +162,6 @@ int G_lookup_f_raster_colors(const FCELL * fcell, unsigned char *red,
     /* now lookup unset colors using the modular rules */
     G__lookup_colors((void *)fcell, red, grn, blu, set, n, colors, 1, 0,
 		     FCELL_TYPE);
-
-    return 0;
 }
 
 
@@ -187,12 +179,12 @@ int G_lookup_f_raster_colors(const FCELL * fcell, unsigned char *red,
  *  \param set
  *  \param n
  *  \param colors
- *  \return int
+ *  \return
  */
 
-int G_lookup_d_raster_colors(const DCELL * dcell, unsigned char *red,
-			     unsigned char *grn, unsigned char *blu,
-			     unsigned char *set, int n, struct Colors *colors)
+void G_lookup_d_raster_colors(const DCELL * dcell, unsigned char *red,
+			      unsigned char *grn, unsigned char *blu,
+			      unsigned char *set, int n, struct Colors *colors)
 {
     G__organize_colors(colors);	/* make sure the lookup tables are in place */
     /* in case of float color rules, fp_lookup table is created */
@@ -206,8 +198,6 @@ int G_lookup_d_raster_colors(const DCELL * dcell, unsigned char *red,
     /* now lookup unset colors using the modular rules */
     G__lookup_colors((void *)dcell, red, grn, blu, set, n, colors, 1, 0,
 		     DCELL_TYPE);
-
-    return 0;
 }
 
 
@@ -228,10 +218,10 @@ static int less(double x, double y)
 }
 
 
-int G__lookup_colors(const void *raster, unsigned char *red,
-		     unsigned char *grn, unsigned char *blu,
-		     unsigned char *set, int n, struct Colors *colors,
-		     int mod, int rules_only, RASTER_MAP_TYPE data_type)
+void G__lookup_colors(const void *raster, unsigned char *red,
+		      unsigned char *grn, unsigned char *blu,
+		      unsigned char *set, int n, struct Colors *colors,
+		      int mod, int rules_only, RASTER_MAP_TYPE data_type)
 {
     struct _Color_Info_ *cp;
     struct _Color_Rule_ *rule;
@@ -439,13 +429,11 @@ int G__lookup_colors(const void *raster, unsigned char *red,
 	   fprintf (stderr, "rule found %d %.2lf %d %d %d\n\n", cat, val, *red, *grn, *blu);
 	 */
     }
-
-    return 0;
 }
 
-int G__interpolate_color_rule(DCELL val, unsigned char *red,
-			      unsigned char *grn, unsigned char *blu,
-			      const struct _Color_Rule_ *rule)
+void G__interpolate_color_rule(DCELL val, unsigned char *red,
+			       unsigned char *grn, unsigned char *blu,
+			       const struct _Color_Rule_ *rule)
 {
     DCELL delta;
 
@@ -470,6 +458,4 @@ int G__interpolate_color_rule(DCELL val, unsigned char *red,
 	*grn = rule->low.grn;
 	*blu = rule->low.blu;
     }
-
-    return 0;
 }

lib/gis/color_org.c

@@ -3,11 +3,11 @@
 
 #define LOOKUP_COLORS 2048
 
-static int organize_lookup(struct Colors *, int);
+static void organize_lookup(struct Colors *, int);
 static int organize_fp_lookup(struct Colors *, int);
 static int double_comp(const void *, const void *);
 
-int G__organize_colors(struct Colors *colors)
+void G__organize_colors(struct Colors *colors)
 {
     /* don't do anything if called recursively */
     if (!colors->organizing) {
@@ -21,8 +21,6 @@ int G__organize_colors(struct Colors *colors)
 
 	colors->organizing = 0;
     }
-
-    return 0;
 }
 
 static int organize_fp_lookup(struct Colors *colors, int mod)
@@ -93,7 +91,7 @@ static int organize_fp_lookup(struct Colors *colors, int mod)
     return 0;
 }
 
-static int organize_lookup(struct Colors *colors, int mod)
+static void organize_lookup(struct Colors *colors, int mod)
 {
     int i, n;
     CELL x;
@@ -102,7 +100,7 @@ static int organize_lookup(struct Colors *colors, int mod)
 
     /* don't do anything if the color structure is float */
     if (colors->is_float)
-	return 0;
+	return;
 
     if (mod)
 	cp = &colors->modular;
@@ -110,11 +108,11 @@ static int organize_lookup(struct Colors *colors, int mod)
 	cp = &colors->fixed;
 
     if (cp->lookup.active)
-	return 0;
+	return;
 
     n = (CELL) cp->max - (CELL) cp->min + 1;
     if (n >= LOOKUP_COLORS || n <= 0)
-	return 0;
+	return;
 
     x = (CELL) cp->min;
     for (i = 0; i < n; i++)
@@ -132,8 +130,6 @@ static int organize_lookup(struct Colors *colors, int mod)
 		     cp->lookup.set, n, colors, mod, 1, CELL_TYPE);
 
     cp->lookup.active = 1;
-
-    return 0;
 }
 
 static int double_comp(const void *xx, const void *yy)

lib/gis/color_rand.c

@@ -2,6 +2,7 @@
 #include <stdio.h>		/*  For NULL */
 #include <stdlib.h>		/*  For rand() and srand() */
 #include <grass/gis.h>
+#include <grass/glocale.h>
 
 #define MAX_COLORS 1024
 #define DEVIATION 128
@@ -16,10 +17,10 @@
  *  \param colors
  *  \param min
  *  \param max
- *  \return int
+ *  \return
  */
 
-int G_make_random_colors(struct Colors *colors, CELL min, CELL max)
+void G_make_random_colors(struct Colors *colors, CELL min, CELL max)
 {
     unsigned char red, grn, blu;
     int count;
@@ -27,7 +28,8 @@ int G_make_random_colors(struct Colors *colors, CELL min, CELL max)
 
     G_init_colors(colors);
     if (min > max)
-	return -1;
+	G_fatal_error(_("G_make_random_colors: min (%d) > max (%d)"),
+		      min, max);
 
     srand(time(NULL));
 
@@ -42,6 +44,4 @@ int G_make_random_colors(struct Colors *colors, CELL min, CELL max)
 	G_add_modular_color_rule(n, red, grn, blu, n, red, grn, blu, colors);
     }
     G_set_color_range(min, max, colors);
-
-    return 1;
 }

lib/gis/color_range.c

@@ -1,7 +1,7 @@
 #include <math.h>
 #include <grass/gis.h>
 
-int G_set_color_range(CELL min, CELL max, struct Colors *colors)
+void G_set_color_range(CELL min, CELL max, struct Colors *colors)
 {
     if (min < max) {
 	colors->cmin = (DCELL) min;
@@ -11,11 +11,9 @@ int G_set_color_range(CELL min, CELL max, struct Colors *colors)
 	colors->cmin = (DCELL) max;
 	colors->cmax = (DCELL) min;
     }
-
-    return 0;
 }
 
-int G_set_d_color_range(DCELL min, DCELL max, struct Colors *colors)
+void G_set_d_color_range(DCELL min, DCELL max, struct Colors *colors)
 {
     if (min < max) {
 	colors->cmin = min;
@@ -25,8 +23,6 @@ int G_set_d_color_range(DCELL min, DCELL max, struct Colors *colors)
 	colors->cmin = max;
 	colors->cmax = min;
     }
-
-    return 0;
 }
 
 /* returns min and max category in the range or huge numbers
@@ -41,7 +37,7 @@ int G_set_d_color_range(DCELL min, DCELL max, struct Colors *colors)
  *  \return int
  */
 
-int G_get_color_range(CELL * min, CELL * max, const struct Colors *colors)
+void G_get_color_range(CELL * min, CELL * max, const struct Colors *colors)
 {
     if (!colors->is_float) {
 	*min = (CELL) floor(colors->cmin);
@@ -51,15 +47,11 @@ int G_get_color_range(CELL * min, CELL * max, const struct Colors *colors)
 	*min = -255 * 255 * 255;
 	*max = 255 * 255 * 255;
     }
-
-    return 0;
 }
 
 /* returns min and max values in the range */
-int G_get_d_color_range(DCELL * min, DCELL * max, const struct Colors *colors)
+void G_get_d_color_range(DCELL * min, DCELL * max, const struct Colors *colors)
 {
     *min = colors->cmin;
     *max = colors->cmax;
-
-    return 0;
 }

lib/gis/color_read.c

@@ -393,9 +393,7 @@ static int read_old_colors(FILE * fd, struct Colors *colors)
  *  \return int
  */
 
-int G_mark_colors_as_fp(struct Colors *colors)
+void G_mark_colors_as_fp(struct Colors *colors)
 {
     colors->is_float = 1;
-
-    return 0;
 }

lib/gis/color_rule.c

@@ -18,10 +18,10 @@
 
 #define LIMIT(x) if (x < 0) x = 0; else if (x > 255) x = 255;
 
-static int add_color_rule(const void *, int, int, int,
-			  const void *, int, int, int,
-			  struct _Color_Info_ *, int,
-			  DCELL *, DCELL *, RASTER_MAP_TYPE);
+static void add_color_rule(const void *, int, int, int,
+			   const void *, int, int, int,
+			   struct _Color_Info_ *, int,
+			   DCELL *, DCELL *, RASTER_MAP_TYPE);
 
 
 /*!
@@ -34,17 +34,16 @@ static int add_color_rule(const void *, int, int, int,
  *  \param v2 cell value
  *  \param r2,g2,b2 color value
  *  \param[in,out] colors pointer to color table structure
- *  \return 1
+ *  \return
  */
 
-int
-G_add_d_raster_color_rule(const DCELL * val1, int r1, int g1, int b1,
-			  const DCELL * val2, int r2, int g2, int b2,
-			  struct Colors *colors)
+void G_add_d_raster_color_rule(
+    const DCELL * val1, int r1, int g1, int b1,
+    const DCELL * val2, int r2, int g2, int b2,
+    struct Colors *colors)
 {
     add_color_rule(val1, r1, g1, b1, val2, r2, g2, b2, &colors->fixed,
 		   colors->version, &colors->cmin, &colors->cmax, DCELL_TYPE);
-    return 1;
 }
 
 
@@ -58,17 +57,16 @@ G_add_d_raster_color_rule(const DCELL * val1, int r1, int g1, int b1,
  *  \param v2 cell value
  *  \param r2,g2,b2 color value
  *  \param[in,out] colors pointer to color table structure
- *  \return 1
+ *  \return
  */
 
-int
-G_add_f_raster_color_rule(const FCELL * cat1, int r1, int g1, int b1,
-			  const FCELL * cat2, int r2, int g2, int b2,
-			  struct Colors *colors)
+void G_add_f_raster_color_rule(
+    const FCELL * cat1, int r1, int g1, int b1,
+    const FCELL * cat2, int r2, int g2, int b2,
+    struct Colors *colors)
 {
     add_color_rule(cat1, r1, g1, b1, cat2, r2, g2, b2, &colors->fixed,
 		   colors->version, &colors->cmin, &colors->cmax, FCELL_TYPE);
-    return 1;
 }
 
 
@@ -82,17 +80,16 @@ G_add_f_raster_color_rule(const FCELL * cat1, int r1, int g1, int b1,
  *  \param v2 cell value
  *  \param r2,g2,b2 color value
  *  \param[in,out] colors pointer to color table structure
- *  \return 1
+ *  \return
  */
 
-int
-G_add_c_raster_color_rule(const CELL * cat1, int r1, int g1, int b1,
-			  const CELL * cat2, int r2, int g2, int b2,
-			  struct Colors *colors)
+void G_add_c_raster_color_rule(
+    const CELL * cat1, int r1, int g1, int b1,
+    const CELL * cat2, int r2, int g2, int b2,
+    struct Colors *colors)
 {
     add_color_rule(cat1, r1, g1, b1, cat2, r2, g2, b2, &colors->fixed,
 		   colors->version, &colors->cmin, &colors->cmax, CELL_TYPE);
-    return 1;
 }
 
 
@@ -115,17 +112,16 @@ G_add_c_raster_color_rule(const CELL * cat1, int r1, int g1, int b1,
  *  \param r2,g2,b2 color value
  *  \param[in,out] colors pointer to color table structure
  *  \param data_type raster data type (CELL, FCELL, DCELL)
- *  \return 1
+ *  \return
  */
 
-int
-G_add_raster_color_rule(const void *val1, int r1, int g1, int b1,
-			const void *val2, int r2, int g2, int b2,
-			struct Colors *colors, RASTER_MAP_TYPE data_type)
+void G_add_raster_color_rule(
+    const void *val1, int r1, int g1, int b1,
+    const void *val2, int r2, int g2, int b2,
+    struct Colors *colors, RASTER_MAP_TYPE data_type)
 {
     add_color_rule(val1, r1, g1, b1, val2, r2, g2, b2, &colors->fixed,
 		   colors->version, &colors->cmin, &colors->cmax, data_type);
-    return 1;
 }
 
 
@@ -158,17 +154,17 @@ G_add_raster_color_rule(const void *val1, int r1, int g1, int b1,
  *  \param cat2 cell value
  *  \param r2,g2,b2 color value
  *  \param[in,out] colors pointer to color table structure
- *  \return 1
+ *  \return
  */
 
-int
-G_add_color_rule(CELL cat1, int r1, int g1, int b1, CELL cat2, int r2, int g2,
-		 int b2, struct Colors *colors)
+void G_add_color_rule(
+    CELL cat1, int r1, int g1, int b1,
+    CELL cat2, int r2, int g2,
+    int b2, struct Colors *colors)
 {
     add_color_rule((void *)&cat1, r1, g1, b1, (void *)&cat2, r2, g2, b2,
 		   &colors->fixed, colors->version, &colors->cmin,
 		   &colors->cmax, CELL_TYPE);
-    return 1;
 }
 
 /**
@@ -183,10 +179,10 @@ G_add_color_rule(CELL cat1, int r1, int g1, int b1, CELL cat2, int r2, int g2,
  * \return -1 on failure
  * \return 1 on success
  */
-int
-G_add_modular_d_raster_color_rule(const DCELL * val1, int r1, int g1, int b1,
-				  const DCELL * val2, int r2, int g2, int b2,
-				  struct Colors *colors)
+int G_add_modular_d_raster_color_rule(
+    const DCELL * val1, int r1, int g1, int b1,
+    const DCELL * val2, int r2, int g2, int b2,
+    struct Colors *colors)
 {
     DCELL min, max;
 
@@ -214,10 +210,10 @@ G_add_modular_d_raster_color_rule(const DCELL * val1, int r1, int g1, int b1,
  * \return -1 on failure
  * \return 1 on success
  */
-int
-G_add_modular_f_raster_color_rule(const FCELL * val1, int r1, int g1, int b1,
-				  const FCELL * val2, int r2, int g2, int b2,
-				  struct Colors *colors)
+int G_add_modular_f_raster_color_rule(
+    const FCELL * val1, int r1, int g1, int b1,
+    const FCELL * val2, int r2, int g2, int b2,
+    struct Colors *colors)
 {
     DCELL min, max;
 
@@ -245,10 +241,10 @@ G_add_modular_f_raster_color_rule(const FCELL * val1, int r1, int g1, int b1,
  * \return -1 on failure
  * \return 1 on success
  */
-int
-G_add_modular_c_raster_color_rule(const CELL * val1, int r1, int g1, int b1,
-				  const CELL * val2, int r2, int g2, int b2,
-				  struct Colors *colors)
+int G_add_modular_c_raster_color_rule(
+    const CELL * val1, int r1, int g1, int b1,
+    const CELL * val2, int r2, int g2, int b2,
+    struct Colors *colors)
 {
     return G_add_modular_color_rule(*val1, r1, g1, b1, *val2, r2, g2, b2,
 				    colors);
@@ -270,11 +266,10 @@ G_add_modular_c_raster_color_rule(const CELL * val1, int r1, int g1, int b1,
  * \return -1 on failure
  * \return 1 on success
  */
-int
-G_add_modular_raster_color_rule(const void *val1, int r1, int g1, int b1,
-				const void *val2, int r2, int g2, int b2,
-				struct Colors *colors,
-				RASTER_MAP_TYPE data_type)
+int G_add_modular_raster_color_rule(
+    const void *val1, int r1, int g1, int b1,
+    const void *val2, int r2, int g2, int b2,
+    struct Colors *colors, RASTER_MAP_TYPE data_type)
 {
     CELL min, max;
 
@@ -306,9 +301,10 @@ G_add_modular_raster_color_rule(const void *val1, int r1, int g1, int b1,
  * \return -1 on failure
  * \return 1 on success
  */
-int
-G_add_modular_color_rule(CELL cat1, int r1, int g1, int b1, CELL cat2, int r2,
-			 int g2, int b2, struct Colors *colors)
+int G_add_modular_color_rule(
+    CELL cat1, int r1, int g1,
+    int b1, CELL cat2, int r2,
+    int g2, int b2, struct Colors *colors)
 {
     CELL min, max;
 
@@ -325,10 +321,10 @@ G_add_modular_color_rule(CELL cat1, int r1, int g1, int b1, CELL cat2, int r2,
     return 1;
 }
 
-static int add_color_rule(const void *pt1, int r1, int g1, int b1,
-			  const void *pt2, int r2, int g2, int b2,
-			  struct _Color_Info_ *cp, int version, DCELL * cmin,
-			  DCELL * cmax, RASTER_MAP_TYPE data_type)
+static void add_color_rule(const void *pt1, int r1, int g1, int b1,
+			   const void *pt2, int r2, int g2, int b2,
+			   struct _Color_Info_ *cp, int version, DCELL * cmin,
+			   DCELL * cmax, RASTER_MAP_TYPE data_type)
 {
     struct _Color_Rule_ *rule, *next;
     unsigned char red, grn, blu;
@@ -382,9 +378,9 @@ static int add_color_rule(const void *pt1, int r1, int g1, int b1,
 
     /* keep track of the overall min and max, excluding null */
     if (G_is_d_null_value(&(rule->low.value)))
-	return 0;
+	return;
     if (G_is_d_null_value(&(rule->high.value)))
-	return 0;
+	return;
     min = rule->low.value;
     max = rule->high.value;
     if (min <= max) {
@@ -453,6 +449,4 @@ static int add_color_rule(const void *pt1, int r1, int g1, int b1,
 	G__color_free_lookup(cp);
 	G__color_free_fp_lookup(cp);
     }
-
-    return 0;
 }

lib/gis/color_rules.c

@@ -222,8 +222,7 @@ int G_read_color_rules(struct Colors *colors, DCELL min, DCELL max,
     return 1;
 }
 
-static int load_rules_file(struct Colors *colors, const char *path, DCELL min,
-			   DCELL max)
+static int load_rules_file(struct Colors *colors, const char *path, DCELL min, DCELL max)
 {
     FILE *fp;
     int ret;
@@ -245,29 +244,27 @@ int G_load_colors(struct Colors *colors, const char *path, CELL min, CELL max)
     return load_rules_file(colors, path, (DCELL) min, (DCELL) max);
 }
 
-int G_load_fp_colors(struct Colors *colors, const char *path, DCELL min,
-		     DCELL max)
+int G_load_fp_colors(struct Colors *colors, const char *path, DCELL min, DCELL max)
 {
     return load_rules_file(colors, path, min, max);
 }
 
-static int load_rules_name(struct Colors *colors, const char *name, DCELL min,
-			   DCELL max)
+static void load_rules_name(struct Colors *colors, const char *name, DCELL min, DCELL max)
 {
     char path[GPATH_MAX];
 
     sprintf(path, "%s/etc/colors/%s", G_gisbase(), name);
 
-    return load_rules_file(colors, path, min, max);
+    if (!load_rules_file(colors, path, min, max))
+	G_fatal_error(_("Unable to load color rules <%s>"), name);
 }
 
-int G_make_colors(struct Colors *colors, const char *name, CELL min, CELL max)
+void G_make_colors(struct Colors *colors, const char *name, CELL min, CELL max)
 {
     return load_rules_name(colors, name, (DCELL) min, (DCELL) max);
 }
 
-int G_make_fp_colors(struct Colors *colors, const char *name, DCELL min,
-		     DCELL max)
+void G_make_fp_colors(struct Colors *colors, const char *name, DCELL min, DCELL max)
 {
     return load_rules_name(colors, name, min, max);
 }

lib/gis/color_set.c

@@ -22,25 +22,23 @@
  *  \param green
  *  \param blue
  *  \param colors
- *  \return int
+ *  \return
  */
 
-int G_set_color(CELL cat, int r, int g, int b, struct Colors *colors)
+void G_set_color(CELL cat, int r, int g, int b, struct Colors *colors)
 {
-    CELL tmp = cat;
-
-    if (G_is_c_null_value(&tmp))
-	return G_set_null_value_color(r, g, b, colors);
-    return G_add_color_rule(cat, r, g, b, cat, r, g, b, colors);
+    if (G_is_c_null_value(&cat))
+	G_set_null_value_color(r, g, b, colors);
+    else
+	G_add_color_rule(cat, r, g, b, cat, r, g, b, colors);
 }
 
-int G_set_d_color(DCELL val, int r, int g, int b, struct Colors *colors)
+void G_set_d_color(DCELL val, int r, int g, int b, struct Colors *colors)
 {
-    DCELL tmp = val;
-
-    if (G_is_d_null_value(&tmp))
-	return G_set_null_value_color(r, g, b, colors);
-    return G_add_d_raster_color_rule(&val, r, g, b, &val, r, g, b, colors);
+    if (G_is_d_null_value(&val))
+	G_set_null_value_color(r, g, b, colors);
+    else
+	G_add_d_raster_color_rule(&val, r, g, b, &val, r, g, b, colors);
 }
 
 
@@ -53,16 +51,15 @@ int G_set_d_color(DCELL val, int r, int g, int b, struct Colors *colors)
  *  \param g
  *  \param b
  *  \param colors
- *  \return int
+ *  \return
  */
 
-int G_set_null_value_color(int red, int grn, int blu, struct Colors *colors)
+void G_set_null_value_color(int red, int grn, int blu, struct Colors *colors)
 {
     colors->null_red = red;
     colors->null_grn = grn;
     colors->null_blu = blu;
     colors->null_set = 1;
-    return 1;
 }
 
 
@@ -76,14 +73,13 @@ int G_set_null_value_color(int red, int grn, int blu, struct Colors *colors)
  *  \param g
  *  \param b
  *  \param colors
- *  \return int
+ *  \return
  */
 
-int G_set_default_color(int red, int grn, int blu, struct Colors *colors)
+void G_set_default_color(int red, int grn, int blu, struct Colors *colors)
 {
     colors->undef_red = red;
     colors->undef_grn = grn;
     colors->undef_blu = blu;
     colors->undef_set = 1;
-    return 1;
 }

lib/gis/color_shift.c

@@ -1,14 +1,10 @@
 #include <grass/gis.h>
-int G_shift_colors(int shift, struct Colors *colors)
+void G_shift_colors(int shift, struct Colors *colors)
 {
     colors->shift += (DCELL) shift;
-
-    return 0;
 }
 
-int G_shift_d_colors(DCELL shift, struct Colors *colors)
+void G_shift_d_colors(DCELL shift, struct Colors *colors)
 {
     colors->shift += shift;
-
-    return 0;
 }

lib/gis/color_write.c

@@ -24,12 +24,12 @@
 #define THRESHOLD .0000000000000000000000000000005
 /* .5 * 10 ^(-30) */
 
-static int write_new_colors(FILE *, struct Colors *);
-static int write_rules(FILE *, struct _Color_Rule_ *, DCELL, DCELL);
-static int write_old_colors(FILE *, struct Colors *);
-static int forced_write_old_colors(FILE *, struct Colors *);
-static int format_min(char *, double);
-static int format_max(char *, double);
+static void write_rules(FILE *, struct _Color_Rule_ *, DCELL, DCELL);
+static void write_new_colors(FILE *, struct Colors *);
+static void write_old_colors(FILE *, struct Colors *);
+static void forced_write_old_colors(FILE *, struct Colors *);
+static void format_min(char *, double);
+static void format_max(char *, double);
 
 
 /*!
@@ -80,7 +80,6 @@ int G_write_colors(const char *name, const char *mapset,
     char element[512];
     char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
     FILE *fd;
-    int stat;
 
     if (G__name_is_fully_qualified(name, xname, xmapset)) {
 	if (strcmp(xmapset, mapset) != 0)
@@ -100,22 +99,22 @@ int G_write_colors(const char *name, const char *mapset,
     if (!(fd = G_fopen_new(element, name)))
 	return -1;
 
-    stat = G__write_colors(fd, colors);
+    G__write_colors(fd, colors);
     fclose(fd);
-    return stat;
+    return 1;
 }
 
-int G__write_colors(FILE * fd, struct Colors *colors)
+void G__write_colors(FILE * fd, struct Colors *colors)
 {
     if (getenv("FORCE_GRASS3_COLORS"))
-	return forced_write_old_colors(fd, colors);
+	forced_write_old_colors(fd, colors);
     else if (colors->version < 0)
-	return write_old_colors(fd, colors);
+	write_old_colors(fd, colors);
     else
-	return write_new_colors(fd, colors);
+	write_new_colors(fd, colors);
 }
 
-static int write_new_colors(FILE * fd, struct Colors *colors)
+static void write_new_colors(FILE * fd, struct Colors *colors)
 {
     char str1[100], str2[100];
 
@@ -152,12 +151,10 @@ static int write_new_colors(FILE * fd, struct Colors *colors)
     }
     if (colors->fixed.rules)
 	write_rules(fd, colors->fixed.rules, colors->cmin, colors->cmax);
-
-    return 1;
 }
 
-static int write_rules(FILE * fd, struct _Color_Rule_ *crules, DCELL dmin, DCELL dmax	/* overall min and max data values in color table */
-    )
+/* overall min and max data values in color table */
+static void write_rules(FILE * fd, struct _Color_Rule_ *crules, DCELL dmin, DCELL dmax)
 {
     struct _Color_Rule_ *rule;
     char str[100];
@@ -193,11 +190,9 @@ static int write_rules(FILE * fd, struct _Color_Rule_ *crules, DCELL dmin, DCELL
 	}
 	fprintf(fd, "\n");
     }
-
-    return 0;
 }
 
-static int write_old_colors(FILE * fd, struct Colors *colors)
+static void write_old_colors(FILE * fd, struct Colors *colors)
 {
     int i, n;
 
@@ -221,11 +216,9 @@ static int write_old_colors(FILE * fd, struct Colors *colors)
 		    (int)colors->fixed.lookup.blu[i]);
 	fprintf(fd, "\n");
     }
-
-    return 1;
 }
 
-static int forced_write_old_colors(FILE * fd, struct Colors *colors)
+static void forced_write_old_colors(FILE * fd, struct Colors *colors)
 {
     int red, grn, blu;
     CELL cat;
@@ -241,11 +234,9 @@ static int forced_write_old_colors(FILE * fd, struct Colors *colors)
 	    fprintf(fd, " %d %d", grn, blu);
 	fprintf(fd, "\n");
     }
-
-    return 1;
 }
 
-static int format_min(char *str, double dval)
+static void format_min(char *str, double dval)
 {
     double dtmp;
 
@@ -256,11 +247,9 @@ static int format_min(char *str, double dval)
 	sprintf(str, "%.*f", PRECISION, dval - THRESHOLD);
 	/* because precision is probably higher than PRECISION */
     }
-
-    return 0;
 }
 
-static int format_max(char *str, double dval)
+static void format_max(char *str, double dval)
 {
     double dtmp;
 
@@ -271,6 +260,4 @@ static int format_max(char *str, double dval)
 	sprintf(str, "%.*f", PRECISION, dval + THRESHOLD);
 	/* because precision is probably higher than PRECISION */
     }
-
-    return 0;
 }

lib/gis/color_xform.c

@@ -53,11 +53,11 @@
  *  \param dst
  *  \param src
  *  \param statf
- *  \return int
+ *  \return
  */
 
-int G_histogram_eq_colors(struct Colors *dst,
-			  struct Colors *src, struct Cell_stats *statf)
+void G_histogram_eq_colors(struct Colors *dst,
+			   struct Colors *src, struct Cell_stats *statf)
 {
     DCELL min, max;
     int red, grn, blu;
@@ -83,7 +83,7 @@ int G_histogram_eq_colors(struct Colors *dst,
 	    total += count;
 
     if (total <= 0)
-	return 0;
+	return;
 
     sum = 0;
     prev = 0;
@@ -111,8 +111,6 @@ int G_histogram_eq_colors(struct Colors *dst,
 	grn = grn2;
 	blu = blu2;
     }
-
-    return 0;
 }
 
 /*!
@@ -191,10 +189,10 @@ void G_histogram_eq_colors_fp(struct Colors *dst,
  *  \param dst
  *  \param src
  *  \param samples
- *  \return int
+ *  \return
  */
 
-int G_log_colors(struct Colors *dst, struct Colors *src, int samples)
+void G_log_colors(struct Colors *dst, struct Colors *src, int samples)
 {
     DCELL min, max;
     double lmin, lmax;
@@ -243,8 +241,6 @@ int G_log_colors(struct Colors *dst, struct Colors *src, int samples)
 	grn = grn2;
 	blu = blu2;
     }
-
-    return 0;
 }
 
 /*!
@@ -253,10 +249,10 @@ int G_log_colors(struct Colors *dst, struct Colors *src, int samples)
  *  \param dst
  *  \param src
  *  \param samples
- *  \return int
+ *  \return
  */
 
-int G_abs_log_colors(struct Colors *dst, struct Colors *src, int samples)
+void G_abs_log_colors(struct Colors *dst, struct Colors *src, int samples)
 {
     DCELL min, max;
     double lmin, lmax;
@@ -316,7 +312,5 @@ int G_abs_log_colors(struct Colors *dst, struct Colors *src, int samples)
 	grn = grn2;
 	blu = blu2;
     }
-
-    return 0;
 }
 

lib/gis/commas.c

@@ -82,10 +82,10 @@ int G_insert_commas(char *buf)
  *  - 1234       stays   1234
  *
  * \param[in,out] buf string
- * \return always returns 0
+ * \return
  */
 
-int G_remove_commas(char *buf)
+void G_remove_commas(char *buf)
 {
     char *b;
 
@@ -94,6 +94,4 @@ int G_remove_commas(char *buf)
 	    *buf++ = *b;
 
     *buf = 0;
-
-    return 0;
 }

lib/gis/copy.c

@@ -25,10 +25,9 @@
  * \param[in]  b source (from)
  * \param[in]  n number of bytes to copy
  *
- * \return always returns 0
+ * \return
  */
-int G_copy(void *a, const void *b, int n)
+void G_copy(void *a, const void *b, int n)
 {
     memcpy(a, b, n);
-    return 0;
 }

lib/gis/done_msg.c

@@ -23,10 +23,10 @@
  * \brief Print a final message.
  *
  * \param[in] msg string.  Cannot be NULL.
- * \return always returns 0
+ * \return
  */
 
-int G_done_msg(const char *msg, ...)
+void G_done_msg(const char *msg, ...)
 {
     char buffer[2000];
     va_list ap;
@@ -36,6 +36,4 @@ int G_done_msg(const char *msg, ...)
     va_end(ap);
 
     G_message(_("%s complete. %s"), G_program_name(), buffer);
-
-    return 0;
 }

lib/gis/error.c

@@ -54,19 +54,18 @@ static int message_id = 1;
 
 static int print_word(FILE *, char **, int *, const int);
 static void print_sentence(FILE *, const int, const char *);
-static int print_error(const char *, const int);
+static void print_error(const char *, const int);
 static int mail_msg(const char *, int);
 static int write_error(const char *, int, time_t, const char *);
-static int log_error(const char *, int);
+static void log_error(const char *, int);
 
-static int vfprint_error(int type, const char *template, va_list ap)
+static void vfprint_error(int type, const char *template, va_list ap)
 {
     char buffer[2000];		/* G_asprintf does not work */
 
     vsprintf(buffer, template, ap);
 
-    /* . */
-    return print_error(buffer, type);
+    print_error(buffer, type);
 }
 
 /*!
@@ -85,8 +84,6 @@ void G_message(const char *msg, ...)
 	vfprint_error(MSG, msg, ap);
 	va_end(ap);
     }
-
-    return;
 }
 
 /*!
@@ -106,8 +103,6 @@ void G_verbose_message(const char *msg, ...)
 	vfprint_error(MSG, msg, ap);
 	va_end(ap);
     }
-
-    return;
 }
 
 /*!
@@ -130,8 +125,6 @@ void G_important_message(const char *msg, ...)
 	vfprint_error(MSG, msg, ap);
 	va_end(ap);
     }
-
-    return;
 }
 
 /*!
@@ -152,7 +145,7 @@ void G_important_message(const char *msg, ...)
  * \return Terminates with an exit status of EXIT_FAILURE if no external
  * routine is specified by G_set_error_routine()
  */
-int G_fatal_error(const char *msg, ...)
+void G_fatal_error(const char *msg, ...)
 {
     va_list ap;
 
@@ -173,20 +166,18 @@ int G_fatal_error(const char *msg, ...)
  *
  * \param msg string (cannot be NULL)
  *
- * \return 0
+ * \return
  */
-int G_warning(const char *msg, ...)
+void G_warning(const char *msg, ...)
 {
     va_list ap;
 
     if (no_warn)
-	return 0;
+	return;
 
     va_start(ap, msg);
     vfprint_error(WARN, msg, ap);
     va_end(ap);
-
-    return 0;
 }
 
 /*!
@@ -228,12 +219,11 @@ int G_sleep_on_error(int flag)
  * \param error_routine routine will be called like this: error_routine(msg,
  * fatal)
  *
- * \return 0
+ * \return
  */
-int G_set_error_routine(int (*error_routine) (const char *, int))
+void G_set_error_routine(int (*error_routine) (const char *, int))
 {
     ext_error = error_routine;	/* Roger Bivand 17 June 2000 */
-    return 0;
 }
 
 /*!
@@ -244,15 +234,13 @@ int G_set_error_routine(int (*error_routine) (const char *, int))
  *
  * \return 0
  */
-int G_unset_error_routine(void)
+void G_unset_error_routine(void)
 {
     ext_error = 0;		/* Roger Bivand 17 June 2000 */
-
-    return 0;
 }
 
 /* Print info to stderr and optionally to log file and optionally send mail */
-static int print_error(const char *msg, const int type)
+static void print_error(const char *msg, const int type)
 {
     int fatal, format;
 
@@ -297,11 +285,9 @@ static int print_error(const char *msg, const int type)
 	    print_sentence(stderr, type, msg);
 	}
     }
-
-    return 0;
 }
 
-static int log_error(const char *msg, int fatal)
+static void log_error(const char *msg, int fatal)
 {
     char cwd[GPATH_MAX];
     time_t clock;
@@ -316,8 +302,6 @@ static int log_error(const char *msg, int fatal)
     /* write the error log file */
     if ((gisbase = G_gisbase()))
 	write_error(msg, fatal, clock, cwd);
-
-    return 0;
 }
 
 void G_init_logging(void)

lib/gis/fpreclass.c

@@ -284,12 +284,10 @@ void G_fpreclass_reset(struct FPReclass *r)
 
 /*--------------------------------------------------------------------------*/
 
-int G_fpreclass_init(struct FPReclass *r)
+void G_fpreclass_init(struct FPReclass *r)
 {
     r->maxNofRules = 0;
     G_fpreclass_reset(r);
-
-    return 1;
 }
 
 /*--------------------------------------------------------------------------*/
@@ -312,9 +310,9 @@ void G_fpreclass_set_range(struct FPReclass *r, DCELL low, DCELL high)
 
 /*--------------------------------------------------------------------------*/
 
-static void
-fpreclass_set_limits(struct FPReclass *r, DCELL dLow, DCELL dHigh, DCELL rLow,
-		     DCELL rHigh)
+static void fpreclass_set_limits(struct FPReclass *r,
+				 DCELL dLow, DCELL dHigh,
+				 DCELL rLow, DCELL rHigh)
 {
     r->dMin = dLow;
     r->dMax = dHigh;
@@ -324,9 +322,9 @@ fpreclass_set_limits(struct FPReclass *r, DCELL dLow, DCELL dHigh, DCELL rLow,
 
 /*--------------------------------------------------------------------------*/
 
-static void
-fpreclass_update_limits(struct FPReclass *r, DCELL dLow, DCELL dHigh,
-			DCELL rLow, DCELL rHigh)
+static void fpreclass_update_limits(struct FPReclass *r,
+				    DCELL dLow, DCELL dHigh,
+				    DCELL rLow, DCELL rHigh)
 {
     if (NO_EXPLICIT_RULE) {
 	fpreclass_set_limits(r, dLow, dHigh, rLow, rHigh);
@@ -341,9 +339,9 @@ fpreclass_update_limits(struct FPReclass *r, DCELL dLow, DCELL dHigh,
 
 /*--------------------------------------------------------------------------*/
 
-int
-G_fpreclass_get_limits(const struct FPReclass *r, DCELL * dMin, DCELL * dMax,
-		       DCELL * rMin, DCELL * rMax)
+int G_fpreclass_get_limits(const struct FPReclass *r,
+			   DCELL * dMin, DCELL * dMax,
+			   DCELL * rMin, DCELL * rMax)
 {
     if (NO_EXPLICIT_RULE) {
 	if (NO_DEFAULT_RULE)
@@ -381,9 +379,9 @@ int G_fpreclass_nof_rules(const struct FPReclass *r)
 
 /*--------------------------------------------------------------------------*/
 
-void
-G_fpreclass_get_ith_rule(const struct FPReclass *r, int i, DCELL * dLow,
-			 DCELL * dHigh, DCELL * rLow, DCELL * rHigh)
+void G_fpreclass_get_ith_rule(const struct FPReclass *r, int i,
+			      DCELL *dLow, DCELL *dHigh,
+			      DCELL *rLow, DCELL *rHigh)
 {
     *dLow = r->table[i].dLow;
     *dHigh = r->table[i].dHigh;
@@ -424,9 +422,8 @@ G_fpreclass_set_neg_infinite_rule(struct FPReclass *r, DCELL dLeft, DCELL c)
 
 /*--------------------------------------------------------------------------*/
 
-int
-G_fpreclass_get_neg_infinite_rule(const struct FPReclass *r, DCELL * dLeft,
-				  DCELL * c)
+int G_fpreclass_get_neg_infinite_rule(const struct FPReclass *r,
+				      DCELL *dLeft, DCELL *c)
 {
     if (r->infiniteLeftSet == 0)
 	return 0;
@@ -439,8 +436,7 @@ G_fpreclass_get_neg_infinite_rule(const struct FPReclass *r, DCELL * dLeft,
 
 /*--------------------------------------------------------------------------*/
 
-void
-G_fpreclass_set_pos_infinite_rule(struct FPReclass *r, DCELL dRight, DCELL c)
+void G_fpreclass_set_pos_infinite_rule(struct FPReclass *r, DCELL dRight, DCELL c)
 {
     r->infiniteDRight = dRight;
     r->infiniteRRight = c;
@@ -450,9 +446,8 @@ G_fpreclass_set_pos_infinite_rule(struct FPReclass *r, DCELL dRight, DCELL c)
 
 /*--------------------------------------------------------------------------*/
 
-int
-G_fpreclass_get_pos_infinite_rule(const struct FPReclass *r, DCELL * dRight,
-				  DCELL * c)
+int G_fpreclass_get_pos_infinite_rule(const struct FPReclass *r,
+				      DCELL *dRight, DCELL *c)
 {
     if (r->infiniteRightSet == 0)
 	return 0;
@@ -465,9 +460,9 @@ G_fpreclass_get_pos_infinite_rule(const struct FPReclass *r, DCELL * dRight,
 
 /*--------------------------------------------------------------------------*/
 
-void
-G_fpreclass_add_rule(struct FPReclass *r, DCELL dLow, DCELL dHigh, DCELL rLow,
-		     DCELL rHigh)
+void G_fpreclass_add_rule(struct FPReclass *r,
+			  DCELL dLow, DCELL dHigh,
+			  DCELL rLow, DCELL rHigh)
 {
     int i;
     struct FPReclass_table *p;
@@ -528,9 +523,10 @@ void G_fpreclass_reverse_rule_order(struct FPReclass *r)
 
 /*--------------------------------------------------------------------------*/
 
-static DCELL
-fpreclass_interpolate(DCELL dLow, DCELL dHigh, DCELL rLow, DCELL rHigh,
-		      DCELL dValue)
+static DCELL fpreclass_interpolate(
+    DCELL dLow, DCELL dHigh,
+    DCELL rLow, DCELL rHigh,
+    DCELL dValue)
 {
     if (rLow == rHigh)
 	return rLow;
@@ -542,8 +538,7 @@ fpreclass_interpolate(DCELL dLow, DCELL dHigh, DCELL rLow, DCELL rHigh,
 
 /*--------------------------------------------------------------------------*/
 
-static DCELL
-fpreclass_get_default_cell_value(const struct FPReclass *r, DCELL cellVal)
+static DCELL fpreclass_get_default_cell_value(const struct FPReclass *r, DCELL cellVal)
 {
     DCELL tmp;
 
@@ -593,9 +588,8 @@ DCELL G_fpreclass_get_cell_value(const struct FPReclass * r, DCELL cellVal)
 
 /*--------------------------------------------------------------------------*/
 
-void
-G_fpreclass_perform_di(const struct FPReclass *r, const DCELL * dcell,
-		       CELL * cell, int n)
+void G_fpreclass_perform_di(const struct FPReclass *r,
+			    const DCELL *dcell, CELL *cell, int n)
 {
     int i;
 
@@ -608,9 +602,8 @@ G_fpreclass_perform_di(const struct FPReclass *r, const DCELL * dcell,
 
 /*--------------------------------------------------------------------------*/
 
-void
-G_fpreclass_perform_df(const struct FPReclass *r, const DCELL * dcell,
-		       FCELL * cell, int n)
+void G_fpreclass_perform_df(const struct FPReclass *r,
+			    const DCELL *dcell, FCELL *cell, int n)
 {
     int i;
 
@@ -623,9 +616,8 @@ G_fpreclass_perform_df(const struct FPReclass *r, const DCELL * dcell,
 
 /*--------------------------------------------------------------------------*/
 
-void
-G_fpreclass_perform_dd(const struct FPReclass *r, const DCELL * dcell,
-		       DCELL * cell, int n)
+void G_fpreclass_perform_dd(const struct FPReclass *r,
+			    const DCELL *dcell, DCELL *cell, int n)
 {
     int i;
 
@@ -638,9 +630,8 @@ G_fpreclass_perform_dd(const struct FPReclass *r, const DCELL * dcell,
 
 /*--------------------------------------------------------------------------*/
 
-void
-G_fpreclass_perform_fi(const struct FPReclass *r, const FCELL * fcell,
-		       CELL * cell, int n)
+void G_fpreclass_perform_fi(const struct FPReclass *r,
+			    const FCELL *fcell, CELL *cell, int n)
 {
     int i;
 
@@ -653,9 +644,8 @@ G_fpreclass_perform_fi(const struct FPReclass *r, const FCELL * fcell,
 
 /*--------------------------------------------------------------------------*/
 
-void
-G_fpreclass_perform_ff(const struct FPReclass *r, const FCELL * fcell,
-		       FCELL * cell, int n)
+void G_fpreclass_perform_ff(const struct FPReclass *r,
+			    const FCELL *fcell, FCELL *cell, int n)
 {
     int i;
 
@@ -668,9 +658,8 @@ G_fpreclass_perform_ff(const struct FPReclass *r, const FCELL * fcell,
 
 /*--------------------------------------------------------------------------*/
 
-void
-G_fpreclass_perform_fd(const struct FPReclass *r, const FCELL * fcell,
-		       DCELL * cell, int n)
+void G_fpreclass_perform_fd(const struct FPReclass *r,
+			    const FCELL *fcell, DCELL *cell, int n)
 {
     int i;
 
@@ -683,9 +672,8 @@ G_fpreclass_perform_fd(const struct FPReclass *r, const FCELL * fcell,
 
 /*--------------------------------------------------------------------------*/
 
-void
-G_fpreclass_perform_ii(const struct FPReclass *r, const CELL * icell,
-		       CELL * cell, int n)
+void G_fpreclass_perform_ii(const struct FPReclass *r,
+			    const CELL *icell, CELL *cell, int n)
 {
     int i;
 
@@ -698,9 +686,8 @@ G_fpreclass_perform_ii(const struct FPReclass *r, const CELL * icell,
 
 /*--------------------------------------------------------------------------*/
 
-void
-G_fpreclass_perform_if(const struct FPReclass *r, const CELL * icell,
-		       FCELL * cell, int n)
+void G_fpreclass_perform_if(const struct FPReclass *r,
+			    const CELL *icell, FCELL *cell, int n)
 {
     int i;
 
@@ -713,9 +700,8 @@ G_fpreclass_perform_if(const struct FPReclass *r, const CELL * icell,
 
 /*--------------------------------------------------------------------------*/
 
-void
-G_fpreclass_perform_id(const struct FPReclass *r, const CELL * icell,
-		       DCELL * cell, int n)
+void G_fpreclass_perform_id(const struct FPReclass *r,
+			    const CELL *icell, DCELL *cell, int n)
 {
     int i;
 

lib/gis/geodesic.c

@@ -28,8 +28,8 @@
  */
 
 
-static int adjust_lat(double *);
-static int adjust_lon(double *);
+static void adjust_lat(double *);
+static void adjust_lon(double *);
 
 static struct state {
     double A, B;
@@ -80,22 +80,18 @@ double G_geodesic_lat_from_lon(double lon)
     return Degrees(atan(st->A * sin(lon) - st->B * cos(lon)));
 }
 
-static int adjust_lon(double *lon)
+static void adjust_lon(double *lon)
 {
     while (*lon > 180.0)
 	*lon -= 360.0;
     while (*lon < -180.0)
 	*lon += 360.0;
-
-    return 0;
 }
 
-static int adjust_lat(double *lat)
+static void adjust_lat(double *lat)
 {
     if (*lat > 90.0)
 	*lat = 90.0;
     if (*lat < -90.0)
 	*lat = -90.0;
-
-    return 0;
 }

lib/gis/geodist.c

@@ -49,17 +49,15 @@ static struct state *st = &state;
  *
  * \param[in] a semi-major axis in meters
  * \param[in] e2 ellipsoid eccentricity
- * \return always returns 0
+ * \return
  */
 
-int G_begin_geodesic_distance(double a, double e2)
+void G_begin_geodesic_distance(double a, double e2)
 {
     st->al = a;
     st->boa = sqrt(1 - e2);
     st->f = 1 - st->boa;
     st->ff64 = st->f * st->f / 64;
-
-    return 0;
 }
 
 
@@ -72,14 +70,12 @@ int G_begin_geodesic_distance(double a, double e2)
  * <b>Note:</b> Must be called first.
  *
  * \param[in] lat1 first latitude
- * \return always returns 0
+ * \return
  */
 
-int G_set_geodesic_distance_lat1(double lat1)
+void G_set_geodesic_distance_lat1(double lat1)
 {
     st->t1r = atan(st->boa * tan(Radians(lat1)));
-
-    return 0;
 }
 
 
@@ -91,10 +87,10 @@ int G_set_geodesic_distance_lat1(double lat1)
  * <b>Note:</b> Must be called second.
  *
  * \param[in] lat2 second latitidue
- * \return always returns 0
+ * \return
  */
 
-int G_set_geodesic_distance_lat2(double lat2)
+void G_set_geodesic_distance_lat2(double lat2)
 {
     double stm, ctm, sdtm, cdtm;
     double tm, dtm;
@@ -117,8 +113,6 @@ int G_set_geodesic_distance_lat2(double lat2)
 
     st->t3 = sdtm * sdtm;
     st->t4 = cdtm * cdtm - stm * stm;
-
-    return 0;
 }
 
 

lib/gis/gisinit.c

@@ -41,12 +41,12 @@ static int gisinit(void);
  * \return exit() is called on error
  */
 
-int G__gisinit(const char *version, const char *pgm)
+void G__gisinit(const char *version, const char *pgm)
 {
     char *mapset;
 
     if (initialized)
-	return 0;
+	return;
 
     G_set_program_name(pgm);
 
@@ -67,8 +67,6 @@ int G__gisinit(const char *version, const char *pgm)
     }
 
     gisinit();
-
-    return 0;
 }
 
 
@@ -77,34 +75,31 @@ int G__gisinit(const char *version, const char *pgm)
  *
  * Initializes GIS engine, but does not check for a valid mapset.
  *
- * \return always returns 0 on success
+ * \return
  */
 
-int G__no_gisinit(const char *version)
+void G__no_gisinit(const char *version)
 {
     if (initialized)
-	return 0;
+	return;
 
     if (strcmp(version, GIS_H_VERSION) != 0)
 	G_fatal_error(_("Incompatible library version for module"));
 
     gisinit();
-
-    return 0;
 }
 
 
 /**
  * \brief Checks to see if GIS engine is initialized.
  *
- * \return 1 on success
- * \return exit() is called on error
+ * \return
  */
 
-int G__check_gisinit(void)
+void G__check_gisinit(void)
 {
     if (initialized)
-	return 1;
+	return;
     G_warning(_("System not initialized. Programmer forgot to call G_gisinit()."));
     G_sleep(3);
     exit(EXIT_FAILURE);

lib/gis/histo_eq.c

@@ -10,8 +10,9 @@
 * inputs are histo, output is map,min,max
 ****************************************************************/
 #include <grass/gis.h>
-int G_histogram_eq(const struct Histogram *histo,
-		   unsigned char **map, CELL * min, CELL * max)
+
+void G_histogram_eq(const struct Histogram *histo,
+		    unsigned char **map, CELL *min, CELL *max)
 {
     int i;
     int x;
@@ -30,7 +31,7 @@ int G_histogram_eq(const struct Histogram *histo,
 	*min = *max = G_get_histogram_cat(0, histo);
 	*map = xmap = (unsigned char *)G_malloc(1);
 	*xmap = 0;
-	return 0;
+	return;
     }
     if ((*min = G_get_histogram_cat(first = 0, histo)) == 0)
 	*min = G_get_histogram_cat(++first, histo);
@@ -50,7 +51,7 @@ int G_histogram_eq(const struct Histogram *histo,
     if (total <= 0) {
 	for (i = 0; i < len; i++)
 	    xmap[i] = 0;
-	return 0;
+	return;
     }
 
     span = total / 256;
@@ -73,6 +74,4 @@ int G_histogram_eq(const struct Histogram *histo,
 	while (prev++ <= cat)
 	    *xmap++ = x;
     }
-
-    return 0;
 }

lib/gis/histogram.c

@@ -16,15 +16,13 @@ static int cmp_count(const void *, const void *);
  * initializes the histogram structure for calls to G_set_histogram()
  * and G_add_histogram()
  * \param  histogram
- * \return int
+ * \return
  */
 
-int G_init_histogram(struct Histogram *histogram)
+void G_init_histogram(struct Histogram *histogram)
 {
     histogram->num = 0;
     histogram->list = NULL;
-
-    return 0;
 }
 
 
@@ -158,9 +156,9 @@ int G_write_histogram_cs(const char *name, struct Cell_stats *statf)
  *
  * \param statf: cell statistics
  * \param histogram: raster histogram
- * \return 0 
+ * \return 
  */
-int G_make_histogram_cs(struct Cell_stats *statf, struct Histogram *histogram)
+void G_make_histogram_cs(struct Cell_stats *statf, struct Histogram *histogram)
 {
     CELL cat;
     long count;
@@ -171,8 +169,6 @@ int G_make_histogram_cs(struct Cell_stats *statf, struct Histogram *histogram)
 	G_add_histogram(cat, count, histogram);
 
     G_sort_histogram(histogram);
-
-    return 0;
 }
 
 
@@ -231,14 +227,12 @@ long G_get_histogram_count(int n, const struct Histogram *histogram)
  * \param histogram: struct for histogram
  * \return 
  */
-int G_free_histogram(struct Histogram *histogram)
+void G_free_histogram(struct Histogram *histogram)
 {
     if (histogram->num > 0)
 	G_free(histogram->list);
     histogram->num = 0;
     histogram->list = NULL;
-
-    return 1;
 }
 
 /*!
@@ -365,14 +359,12 @@ static FILE *fopen_histogram_new(const char *name)
  *
  *  Removes the histogram information associated with map layer "name"
  * \param name: name of map
- * \return 0
+ * \return
  */
 
-int G_remove_histogram(const char *name)
+void G_remove_histogram(const char *name)
 {
     G_remove_misc("cell_misc", "histogram", name);
-
-    return 0;
 }
 
 
@@ -436,16 +428,14 @@ int G_set_histogram(CELL cat, long count, struct Histogram *histogram)
  * \param histogram: struct for histogram
  * \return 
  */
-int G_extend_histogram(CELL cat, long count, struct Histogram *histogram)
+void G_extend_histogram(CELL cat, long count, struct Histogram *histogram)
 {
     histogram->num++;
     histogram->list =
-	(LIST *) G_realloc((char *)histogram->list,
+	(LIST *) G_realloc(histogram->list,
 			   histogram->num * sizeof(LIST));
     histogram->list[histogram->num - 1].cat = cat;
     histogram->list[histogram->num - 1].count = count;
-
-    return 0;
 }
 
 
@@ -455,12 +445,10 @@ int G_extend_histogram(CELL cat, long count, struct Histogram *histogram)
  * \param histogram: struct for histogram
  * \return 
  */
-int G_zero_histogram(struct Histogram *histogram)
+void G_zero_histogram(struct Histogram *histogram)
 {
     int i;
 
     for (i = 0; i < histogram->num; i++)
 	histogram->list[i].count = 0;
-
-    return 0;
 }

lib/gis/history.c

@@ -196,10 +196,10 @@ int G_write_history(const char *name, struct History *hist)
  *  \param name
  *  \param type
  *  \param history
- *  \return int
+ *  \return
  */
 
-int G_short_history(const char *name, const char *type, struct History *hist)
+void G_short_history(const char *name, const char *type, struct History *hist)
 {
     strncpy(hist->mapid, G_date(), RECORD_LEN);
     strncpy(hist->title, name, RECORD_LEN);
@@ -211,8 +211,6 @@ int G_short_history(const char *name, const char *type, struct History *hist)
     strcpy(hist->datsrc_1, "");
     strcpy(hist->datsrc_2, "");
     hist->edlinecnt = 0;
-
-    return 1;
 }
 
 /*!

lib/gis/key_value1.c

@@ -140,9 +140,9 @@ char *G_find_key_value(const char *key, const struct Key_Value *kv)
 
    \param[in] kv Key_Value structure
 
-   \return 0
+   \return
  */
-int G_free_key_value(struct Key_Value *kv)
+void G_free_key_value(struct Key_Value *kv)
 {
     int n;
 
@@ -155,6 +155,4 @@ int G_free_key_value(struct Key_Value *kv)
     kv->nitems = 0;		/* just for safe measure */
     kv->nalloc = 0;
     G_free(kv);
-
-    return 0;
 }

lib/gis/line_dist.c

@@ -5,13 +5,11 @@
 #define TOLERANCE 1.0e-10
 static double tolerance = TOLERANCE;
 
-int G_set_distance_to_line_tolerance(double t)
+void G_set_distance_to_line_tolerance(double t)
 {
     if (t <= 0.0)
 	t = TOLERANCE;
     tolerance = t;
-
-    return 0;
 }
 
 double G_distance2_point_to_line(double x, double y,	/* point */

lib/gis/list.c

@@ -48,12 +48,12 @@ static void sigpipe_catch(int);
    \param lister     If given will call this routine to get a list
    title. NULL if no titles desired. 
 
-   \return Number of elements
+   \return
 */
-int G_list_element(const char *element,
-		   const char *desc,
-		   const char *mapset,
-		   int (*lister) (const char *, const char *, const char *))
+void G_list_element(const char *element,
+		    const char *desc,
+		    const char *mapset,
+		    int (*lister) (const char *, const char *, const char *))
 {
     int n;
     FILE *more;
@@ -123,8 +123,6 @@ int G_list_element(const char *element,
 #ifdef SIGPIPE
     signal(SIGPIPE, sigpipe);
 #endif
-
-    return 0;
 }
 
 static void sigpipe_catch(int n)

lib/gis/ll_format.c

@@ -35,10 +35,10 @@ NOTE: These routines are used by G_format_northing(), G_format_easting(), and
 #include <grass/gis.h>
 #include <string.h>
 
-static int format(char *, int, int, double, char);
-static int ll_parts(double, int *, int *, double *);
+static void format(char *, int, int, double, char);
+static void ll_parts(double, int *, int *, double *);
 
-int G_lat_format(double lat, char *buf)
+void G_lat_format(double lat, char *buf)
 {
     int d, m;
     char h;
@@ -46,8 +46,6 @@ int G_lat_format(double lat, char *buf)
 
     G_lat_parts(lat, &d, &m, &s, &h);
     format(buf, d, m, s, h);
-
-    return 0;
 }
 
 char *G_lat_format_string(void)
@@ -55,7 +53,7 @@ char *G_lat_format_string(void)
     return "dd:mm:ss{N|S}";
 }
 
-int G_lon_format(double lon, char *buf)
+void G_lon_format(double lon, char *buf)
 {
     int d, m;
     char h;
@@ -63,15 +61,14 @@ int G_lon_format(double lon, char *buf)
 
     G_lon_parts(lon, &d, &m, &s, &h);
     format(buf, d, m, s, h);
-
-    return 0;
 }
+
 char *G_lon_format_string(void)
 {
     return "ddd:mm:ss{E|W}";
 }
 
-int G_llres_format(double res, char *buf)
+void G_llres_format(double res, char *buf)
 {
     int d, m;
     char h;
@@ -80,16 +77,14 @@ int G_llres_format(double res, char *buf)
     G_lat_parts(res, &d, &m, &s, &h);
     h = 0;
     format(buf, d, m, s, h);
-
-    return 0;
 }
+
 char *G_llres_format_string(void)
 {
     return "dd:mm:ss";
 }
 
-
-static int format(char *buf, int d, int m, double s, char h)
+static void format(char *buf, int d, int m, double s, char h)
 {
     char temp[50];
     double ss;
@@ -117,14 +112,12 @@ static int format(char *buf, int d, int m, double s, char h)
 	sprintf(buf, "%d%c", d, h);
     else
 	sprintf(buf, "0");
-
-    return 0;
 }
 
-int G_lat_parts(double lat,	/* lat in degrees to be split into parts */
-		int *d, int *m,	/* degrees, minutes */
-		double *s,	/* seconds */
-		char *h		/* hemisphere */
+void G_lat_parts(double lat,		/* lat in degrees to be split into parts */
+		 int *d, int *m,	/* degrees, minutes */
+		 double *s,		/* seconds */
+		 char *h		/* hemisphere */
     )
 {
     if (lat < 0) {
@@ -135,14 +128,12 @@ int G_lat_parts(double lat,	/* lat in degrees to be split into parts */
 	*h = 'N';
 
     ll_parts(lat, d, m, s);
-
-    return 0;
 }
 
-int G_lon_parts(double lon,	/* lon in degrees to be split into parts */
-		int *d, int *m,	/* degrees, minutes */
-		double *s,	/* seconds */
-		char *h		/* hemisphere */
+void G_lon_parts(double lon,		/* lon in degrees to be split into parts */
+		 int *d, int *m,	/* degrees, minutes */
+		 double *s,		/* seconds */
+		 char *h		/* hemisphere */
     )
 {
     while (lon > 180.0)
@@ -158,14 +149,13 @@ int G_lon_parts(double lon,	/* lon in degrees to be split into parts */
 	*h = 'E';
 
     ll_parts(lon, d, m, s);
-
-    return 0;
 }
 
-static int ll_parts(double ll,	/* ll in degrees to be split into parts */
-		    int *d, int *m,	/* degrees, minutes */
-		    double *s)
-{				/* seconds */
+static void ll_parts(double ll,		/* ll in degrees to be split into parts */
+		     int *d, int *m,	/* degrees, minutes */
+		     double *s		/* seconds */
+)
+{
     if (ll == 0.0) {
 	*d = 0;
 	*m = 0;
@@ -180,6 +170,4 @@ static int ll_parts(double ll,	/* ll in degrees to be split into parts */
 	if (*s < 0)
 	    *s = 0;
     }
-
-    return 0;
 }

lib/gis/ls.c

@@ -140,8 +140,6 @@ void G_ls(const char *dir, FILE * stream)
 	G_free(dir_listing[i]);
 
     G_free(dir_listing);
-
-    return;
 }
 
 /**
@@ -218,6 +216,4 @@ void G_ls_format(char **list, int num_items, int perline, FILE * stream)
 	    }
 	}
     }
-
-    return;
 }

lib/gis/null_val.c

@@ -24,7 +24,7 @@
 #include <grass/gis.h>
 #include <grass/glocale.h>
 
-static int EmbedGivenNulls(void *, char *, RASTER_MAP_TYPE, int);
+static void EmbedGivenNulls(void *, char *, RASTER_MAP_TYPE, int);
 
 /****************************************************************************
 * int EmbedGivenNulls (void *cell, char *nulls, RASTER_MAP_TYPE map_type,
@@ -37,7 +37,7 @@ static int EmbedGivenNulls(void *, char *, RASTER_MAP_TYPE, int);
 *   	    	ncols	    =>	??
 * RETURN VAL:	??
 *****************************************************************************/
-static int EmbedGivenNulls(void *cell, char *nulls, RASTER_MAP_TYPE map_type,
+static void EmbedGivenNulls(void *cell, char *nulls, RASTER_MAP_TYPE map_type,
 			   int ncols)
 {
     CELL *c;
@@ -69,8 +69,6 @@ static int EmbedGivenNulls(void *cell, char *nulls, RASTER_MAP_TYPE map_type,
 	    }
 	}
     }
-
-    return 1;
 }
 
 /*========================== Library Functions =============================*/
@@ -96,8 +94,6 @@ void G__set_null_value(void *rast, int numVals, int null_is_zero,
     }
 
     G_set_null_value(rast, numVals, data_type);
-
-    return;
 }
 
 /****************************************************************************
@@ -127,8 +123,6 @@ void G_set_null_value(void *buf, int numVals, RASTER_MAP_TYPE data_type)
     default:
 	G_warning(_("G_set_null_value: wrong data type!"));
     }
-
-    return;
 }
 
 /****************************************************************************
@@ -344,13 +338,13 @@ int G_is_d_null_value(const DCELL * dcellVal)
  *  \param flags
  *  \param count
  *  \param data_type
- *  \return int
+ *  \return
  */
 
-int G_insert_null_values(void *rast, char *null_row, int ncols,
-			 RASTER_MAP_TYPE data_type)
+void G_insert_null_values(void *rast, char *null_row, int ncols,
+			  RASTER_MAP_TYPE data_type)
 {
-    return (EmbedGivenNulls(rast, null_row, data_type, ncols));
+    EmbedGivenNulls(rast, null_row, data_type, ncols);
 }
 
 /****************************************************************************
@@ -373,12 +367,12 @@ int G_insert_null_values(void *rast, char *null_row, int ncols,
  *  \param cell
  *  \param flags
  *  \param count
- *  \return int
+ *  \return
  */
 
-int G_insert_c_null_values(CELL * cellVal, char *null_row, int ncols)
+void G_insert_c_null_values(CELL * cellVal, char *null_row, int ncols)
 {
-    return (EmbedGivenNulls((void *)cellVal, null_row, CELL_TYPE, ncols));
+    EmbedGivenNulls((void *)cellVal, null_row, CELL_TYPE, ncols);
 }
 
 /****************************************************************************
@@ -401,12 +395,12 @@ int G_insert_c_null_values(CELL * cellVal, char *null_row, int ncols)
  *  \param fcell
  *  \param flags
  *  \param count
- *  \return int
+ *  \return
  */
 
-int G_insert_f_null_values(FCELL * fcellVal, char *null_row, int ncols)
+void G_insert_f_null_values(FCELL * fcellVal, char *null_row, int ncols)
 {
-    return (EmbedGivenNulls((void *)fcellVal, null_row, FCELL_TYPE, ncols));
+    EmbedGivenNulls((void *)fcellVal, null_row, FCELL_TYPE, ncols);
 }
 
 /****************************************************************************
@@ -429,12 +423,12 @@ int G_insert_f_null_values(FCELL * fcellVal, char *null_row, int ncols)
  *  \param dcell
  *  \param flags
  *  \param count
- *  \return int
+ *  \return
  */
 
-int G_insert_d_null_values(DCELL * dcellVal, char *null_row, int ncols)
+void G_insert_d_null_values(DCELL * dcellVal, char *null_row, int ncols)
 {
-    return (EmbedGivenNulls((void *)dcellVal, null_row, DCELL_TYPE, ncols));
+    EmbedGivenNulls((void *)dcellVal, null_row, DCELL_TYPE, ncols);
 }
 
 /****************************************************************************
@@ -531,7 +525,7 @@ int G__set_flags_from_01_random(const char *zero_ones, unsigned char *flags,
 *   	    	n   	    =>	??
 * RETURN VAL:	??
 *****************************************************************************/
-int G__convert_01_flags(const char *zero_ones, unsigned char *flags, int n)
+void G__convert_01_flags(const char *zero_ones, unsigned char *flags, int n)
 {
     unsigned char *v;
     int count;
@@ -557,8 +551,6 @@ int G__convert_01_flags(const char *zero_ones, unsigned char *flags, int n)
 
 	v++;
     }
-
-    return 0;
 }
 
 /****************************************************************************
@@ -570,7 +562,7 @@ int G__convert_01_flags(const char *zero_ones, unsigned char *flags, int n)
 *   	    	n   	    =>	??
 * RETURN VAL:	??
 *****************************************************************************/
-int G__convert_flags_01(char *zero_ones, const unsigned char *flags, int n)
+void G__convert_flags_01(char *zero_ones, const unsigned char *flags, int n)
 {
     const unsigned char *v;
     int count;
@@ -593,8 +585,6 @@ int G__convert_flags_01(char *zero_ones, const unsigned char *flags, int n)
 
 	v++;
     }
-
-    return 0;
 }
 
 /****************************************************************************
@@ -605,7 +595,7 @@ int G__convert_flags_01(char *zero_ones, const unsigned char *flags, int n)
 *   	    	cols	=>  ??
 * RETURN VAL:	??
 *****************************************************************************/
-int G__init_null_bits(unsigned char *flags, int cols)
+void G__init_null_bits(unsigned char *flags, int cols)
 {
     unsigned char *v;
     int size;
@@ -625,6 +615,4 @@ int G__init_null_bits(unsigned char *flags, int cols)
 
 	v++;
     }
-
-    return 0;
 }

lib/gis/parser.c

@@ -123,7 +123,7 @@ static struct state {
 
 static struct state *st = &state;
 
-static int show_options(int, const char *);
+static void show_options(int, const char *);
 static int show(const char *, int);
 static int set_flag(int);
 static int contains(const char *, int);
@@ -135,10 +135,10 @@ static int check_int(const char *, const char **);
 static int check_double(const char *, const char **);
 static int check_string(const char *, const char **, int *);
 static int check_required(void);
-static int split_opts(void);
+static void split_opts(void);
 static int check_multiple_opts(void);
 static int check_overwrite(void);
-static int split_gisprompt(const char *, char *, char *, char *);
+static void split_gisprompt(const char *, char *, char *, char *);
 
 static void G_gui(void);
 static void G_tcltk(void);
@@ -1040,10 +1040,10 @@ static int uses_new_gisprompt(void)
  * the standard usage message and print additional information about how 
  * the two options work together.
  *
- * \return always returns 0
+ * \return
  */
 
-int G_usage(void)
+void G_usage(void)
 {
     struct Option *opt;
     struct Flag *flag;
@@ -1212,8 +1212,6 @@ int G_usage(void)
 	    opt = opt->next_opt;
 	}
     }
-
-    return 0;
 }
 
 
@@ -2049,7 +2047,7 @@ static void G_tcltk(void)
  *
  **************************************************************************/
 
-static int show_options(int maxlen, const char *str)
+static void show_options(int maxlen, const char *str)
 {
     char *buff = G_store(str);
     char *p1, *p2;
@@ -2075,8 +2073,6 @@ static int show_options(int maxlen, const char *str)
     fprintf(stderr, "%s\n", p1);
 
     G_free(buff);
-
-    return 0;
 }
 
 static int show(const char *item, int len)
@@ -2411,7 +2407,7 @@ static int check_required(void)
     return (err);
 }
 
-static int split_opts(void)
+static void split_opts(void)
 {
     struct Option *opt;
     char *ptr1;
@@ -2422,7 +2418,7 @@ static int split_opts(void)
 
 
     if (!st->n_opts)
-	return 0;
+	return;
 
     opt = &st->first_option;
     while (opt != NULL) {
@@ -2467,8 +2463,6 @@ static int split_opts(void)
 	}
 	opt = opt->next_opt;
     }
-
-    return 0;
 }
 
 static int check_multiple_opts(void)
@@ -2579,8 +2573,8 @@ static int check_overwrite(void)
     return (error);
 }
 
-static int split_gisprompt(const char *gisprompt, char *age, char *element,
-			   char *desc)
+static void split_gisprompt(const char *gisprompt, char *age, char *element,
+			    char *desc)
 {
     const char *ptr1;
     char *ptr2;
@@ -2605,8 +2599,6 @@ static int split_gisprompt(const char *gisprompt, char *age, char *element,
 	*ptr2 = *ptr1;
     }
     *ptr2 = '\0';
-
-    return 0;
 }
 
 /**

lib/gis/percent.c

@@ -68,8 +68,6 @@ void G_percent(long n, long d, int s)
 	st->prev = -1;
 	st->first = 1;
     }
-
-    return;
 }
 
 

lib/gis/plot.c

@@ -17,16 +17,16 @@
 #include <math.h>
 #include <grass/gis.h>
 
-static int fastline(double, double, double, double);
-static int slowline(double, double, double, double);
-static int plot_line(double, double, double, double, int (*)());
+static void fastline(double, double, double, double);
+static void slowline(double, double, double, double);
+static void plot_line(double, double, double, double, void (*)());
 static double nearest(double, double);
 static int edge(double, double, double, double);
 static int edge_point(double, int);
 
 static int edge_order(const void *, const void *);
-static int row_solid_fill(int, double, double);
-static int row_dotted_fill(int, double, double);
+static void row_solid_fill(int, double, double);
+static void row_dotted_fill(int, double, double);
 static int ifloor(double);
 static int iceil(double);
 
@@ -47,7 +47,7 @@ static struct state {
     int np;
     int npalloc;
 
-    int (*row_fill)(int, double, double);
+    void (*row_fill)(int, double, double);
     int (*move)(int, int);
     int (*cont)(int, int);
 } state;
@@ -102,11 +102,11 @@ static struct state *st = &state;
  * to x,y. Cont(~) is responsible for clipping
  *
  *  \param ~
- *  \return int
+ *  \return
  */
 
-int G_setup_plot(double t, double b, double l, double r,
-		 int (*Move) (int, int), int (*Cont) (int, int))
+void G_setup_plot(double t, double b, double l, double r,
+		  int (*Move) (int, int), int (*Cont) (int, int))
 {
     G_get_set_window(&st->window);
 
@@ -129,8 +129,6 @@ int G_setup_plot(double t, double b, double l, double r,
 
     st->move = Move;
     st->cont = Cont;
-
-    return 0;
 }
 
 /*!
@@ -142,9 +140,9 @@ int G_setup_plot(double t, double b, double l, double r,
  * row_solid_fill is used.
  *
  *  \param int
- *  \return int
+ *  \return
  */
-int G_setup_fill(int gap)
+void G_setup_fill(int gap)
 {
     if (gap > 0) {
 	st->row_fill = row_dotted_fill;
@@ -152,8 +150,6 @@ int G_setup_fill(int gap)
     }
     else
 	st->row_fill = row_solid_fill;
-
-    return 0;
 }
 
 #define X(e) (st->left + st->xconv * ((e) - st->window.west))
@@ -173,15 +169,13 @@ int G_setup_fill(int gap)
  *  \param north
  *  \param x
  *  \param y
- *  \return int
+ *  \return
  */
 
-int G_plot_where_xy(double east, double north, int *x, int *y)
+void G_plot_where_xy(double east, double north, int *x, int *y)
 {
     *x = ifloor(X(G_adjust_easting(east, &st->window)) + 0.5);
     *y = ifloor(Y(north) + 0.5);
-
-    return 0;
 }
 
 
@@ -195,26 +189,22 @@ int G_plot_where_xy(double east, double north, int *x, int *y)
  *  \param y
  *  \param east
  *  \param north
- *  \return int
+ *  \return
  */
 
-int G_plot_where_en(int x, int y, double *east, double *north)
+void G_plot_where_en(int x, int y, double *east, double *north)
 {
     *east = G_adjust_easting(EAST(x), &st->window);
     *north = NORTH(y);
-
-    return 0;
 }
 
-int G_plot_point(double east, double north)
+void G_plot_point(double east, double north)
 {
     int x, y;
 
     G_plot_where_xy(east, north, &x, &y);
     st->move(x, y);
     st->cont(x, y);
-
-    return 0;
 }
 
 /*
@@ -235,29 +225,27 @@ int G_plot_point(double east, double north)
  *  \param north1
  *  \param east2
  *  \param north2
- *  \return int
+ *  \return
  */
 
-int G_plot_line(double east1, double north1, double east2, double north2)
+void G_plot_line(double east1, double north1, double east2, double north2)
 {
-    return plot_line(east1, north1, east2, north2, fastline);
+    plot_line(east1, north1, east2, north2, fastline);
 }
 
-int G_plot_line2(double east1, double north1, double east2, double north2)
+void G_plot_line2(double east1, double north1, double east2, double north2)
 {
-    return plot_line(east1, north1, east2, north2, slowline);
+    plot_line(east1, north1, east2, north2, slowline);
 }
 
 /* fastline converts double rows/cols to ints then plots
  * this is ok for graphics, but not the best for vector to raster
  */
 
-static int fastline(double x1, double y1, double x2, double y2)
+static void fastline(double x1, double y1, double x2, double y2)
 {
     st->move(ifloor(x1 + 0.5), ifloor(y1 + 0.5));
     st->cont(ifloor(x2 + 0.5), ifloor(y2 + 0.5));
-
-    return 0;
 }
 
 /* NOTE (shapiro): 
@@ -266,7 +254,7 @@ static int fastline(double x1, double y1, double x2, double y2)
  *   be adjusted for this: left=-0.5; right = window.cols-0.5;
  */
 
-static int slowline(double x1, double y1, double x2, double y2)
+static void slowline(double x1, double y1, double x2, double y2)
 {
     double dx, dy;
     double m, b;
@@ -320,12 +308,10 @@ static int slowline(double x1, double y1, double x2, double y2)
 	    }
 	}
     }
-
-    return 0;
 }
 
-static int plot_line(double east1, double north1, double east2, double north2,
-		     int (*line) (double, double, double, double))
+static void plot_line(double east1, double north1, double east2, double north2,
+		      void (*line)(double, double, double, double))
 {
     double x1, x2, y1, y2;
 
@@ -371,8 +357,6 @@ static int plot_line(double east1, double north1, double east2, double north2,
 	x2 = X(east2);
 	line(x1, y1, x2, y2);
     }
-
-    return 0;
 }
 
 /*
@@ -750,7 +734,7 @@ static int edge_order(const void *aa, const void *bb)
     return (0);
 }
 
-static int row_solid_fill(int y, double x1, double x2)
+static void row_solid_fill(int y, double x1, double x2)
 {
     int i1, i2;
 
@@ -760,16 +744,14 @@ static int row_solid_fill(int y, double x1, double x2)
 	st->move(i1, y);
 	st->cont(i2, y);
     }
-
-    return 0;
 }
 
-static int row_dotted_fill(int y, double x1, double x2)
+static void row_dotted_fill(int y, double x1, double x2)
 {
     int i1, i2, i;
 
     if (y != iceil(y / st->dotted_fill_gap) * st->dotted_fill_gap)
-	return 0;
+	return;
 
     i1 = iceil(x1 / st->dotted_fill_gap) * st->dotted_fill_gap;
     i2 = ifloor(x2);
@@ -779,8 +761,6 @@ static int row_dotted_fill(int y, double x1, double x2)
 	    st->cont(i, y);
 	}
     }
-
-    return 0;
 }
 
 static int ifloor(double x)
@@ -821,7 +801,7 @@ static int iceil(double x)
  *  \return int
  */
 
-int G_plot_fx(double (*f) (double), double east1, double east2)
+void G_plot_fx(double (*f) (double), double east1, double east2)
 {
     double east, north, north1;
     double incr;
@@ -848,7 +828,6 @@ int G_plot_fx(double (*f) (double), double east1, double east2)
 	    east = east1;
 	}
     }
-    G_plot_line(east, north, east2, f(east2));
 
-    return 0;
+    G_plot_line(east, north, east2, f(east2));
 }

lib/gis/pole_in_poly.c

@@ -16,7 +16,7 @@
  *       no check is made by this routine for valid projection
  ***********************************************************/
 
-static int mystats(double, double, double, double, double *, double *);
+static void mystats(double, double, double, double, double *, double *);
 
 
 /*!
@@ -63,8 +63,8 @@ int G_pole_in_polygon(const double *x, const double *y, int n)
     return total_area >= 0.0 ? 1 : -1;
 }
 
-static int mystats(double x0, double y0, double x1, double y1, double *len,
-		   double *area)
+static void mystats(double x0, double y0, double x1, double y1, double *len,
+		    double *area)
 {
     if (x1 > x0)
 	while (x1 - x0 > 180)
@@ -79,6 +79,4 @@ static int mystats(double x0, double y0, double x1, double y1, double *len,
 	*area = (x0 - x1) * (y0 + y1) / 2.0;
     else
 	*area = (x1 - x0) * (y1 + y0) / 2.0;
-
-    return 0;
 }

lib/gis/put_row.c

@@ -189,8 +189,6 @@ static void write_error(int fd, int row)
     G_warning(_("map [%s] - unable to write row %d"), fcb->name, row);
 
     fcb->io_error = 1;
-
-    return;
 }
 
 /*--------------------------------------------------------------------------*/

lib/gis/quant.c

@@ -416,18 +416,16 @@ int G__quant_organize_fp_lookup(struct Quant *q)
  * Initializes the <em>q</em> struct.
  *
  *  \param q
- *  \return int
+ *  \return
  */
 
-int G_quant_init(struct Quant *quant)
+void G_quant_init(struct Quant *quant)
 {
     quant->fp_lookup.active = 0;
     quant->maxNofRules = 0;
     quant->truncate_only = 0;
     quant->round_only = 0;
     G_quant_clear(quant);
-
-    return 1;
 }
 
 /*--------------------------------------------------------------------------*/
@@ -446,7 +444,6 @@ int G_quant_is_round(const struct Quant *quant)
 
 /*--------------------------------------------------------------------------*/
 
-
 /*!
  * \brief 
  *
@@ -454,9 +451,15 @@ int G_quant_is_round(const struct Quant *quant)
  * rules to perform simple truncation on floats.
  *
  *  \param q
- *  \return int
+ *  \return
  */
 
+void G_quant_truncate(struct Quant *quant)
+{
+    quant->truncate_only = 1;
+}
+
+/*--------------------------------------------------------------------------*/
 
 /*!
  * \brief 
@@ -465,21 +468,12 @@ int G_quant_is_round(const struct Quant *quant)
  * rules to perform simple rounding on floats.
  *
  *  \param q
- *  \return int
+ *  \return
  */
 
-int G_quant_truncate(struct Quant *quant)
-{
-    quant->truncate_only = 1;
-    return 1;
-}
-
-/*--------------------------------------------------------------------------*/
-
-int G_quant_round(struct Quant *quant)
+void G_quant_round(struct Quant *quant)
 {
     quant->round_only = 1;
-    return 1;
 }
 
 /*--------------------------------------------------------------------------*/

lib/gis/range.c

@@ -92,11 +92,9 @@
 /* range functions for type "Range" */
 
 /*-------------------------------------------------------------------------*/
-int G__remove_fp_range(const char *name)
+void G__remove_fp_range(const char *name)
 {
     G_remove_misc("cell_misc", "f_range", name);
-
-    return 0;
 }
 
 
@@ -106,15 +104,13 @@ int G__remove_fp_range(const char *name)
  * Sets the integer range <em>r</em> to [1,255]
  *
  *  \param r
- *  \return int
+ *  \return
  */
 
-int G_construct_default_range(struct Range *range)
+void G_construct_default_range(struct Range *range)
 {
     G_update_range(DEFAULT_CELL_MIN, range);
     G_update_range(DEFAULT_CELL_MAX, range);
-
-    return 0;
 }
 
 
@@ -371,7 +367,7 @@ int G_write_range(const char *name, const struct Range *range)
  * created.
  *
  *  \param r
- *  \return int
+ *  \return
  */
 
 int G_write_fp_range(const char *name, const struct FPRange *range)
@@ -425,44 +421,41 @@ int G_write_fp_range(const char *name, const struct FPRange *range)
  *  \param cat
  *  \param range
  *
- *  \return int
+ *  \return
  */
 
-int G_update_range(CELL cat, struct Range *range)
+void G_update_range(CELL cat, struct Range *range)
 {
     if (!G_is_c_null_value(&cat)) {
 	if (range->first_time) {
 	    range->first_time = 0;
 	    range->min = cat;
 	    range->max = cat;
-	    return 0;
+	    return;
 	}
 	if (cat < range->min)
 	    range->min = cat;
 	if (cat > range->max)
 	    range->max = cat;
     }
-
-    return 0;
 }
 
 /*-------------------------------------------------------------------------*/
 
-int G_update_fp_range(DCELL val, struct FPRange *range)
+void G_update_fp_range(DCELL val, struct FPRange *range)
 {
     if (!G_is_d_null_value(&val)) {
 	if (range->first_time) {
 	    range->first_time = 0;
 	    range->min = val;
 	    range->max = val;
-	    return 0;
+	    return;
 	}
 	if (val < range->min)
 	    range->min = val;
 	if (val > range->max)
 	    range->max = val;
     }
-    return 0;
 }
 
 /*-------------------------------------------------------------------------*/
@@ -478,20 +471,18 @@ int G_update_fp_range(DCELL val, struct FPRange *range)
  *  \param cell
  *  \param n
  *  \param range
- *  \return int
+ *  \return
  */
 
-int G_row_update_range(const CELL * cell, int n, struct Range *range)
+void G_row_update_range(const CELL *cell, int n, struct Range *range)
 {
     G__row_update_range(cell, n, range, 0);
-
-    return 0;
 }
 
 /*-------------------------------------------------------------------------*/
 
-int G__row_update_range(const CELL * cell, int n,
-			struct Range *range, int ignore_zeros)
+void G__row_update_range(const CELL *cell, int n,
+			 struct Range *range, int ignore_zeros)
 {
     CELL cat;
 
@@ -510,14 +501,12 @@ int G__row_update_range(const CELL * cell, int n,
 	if (cat > range->max)
 	    range->max = cat;
     }
-
-    return 0;
 }
 
 /*-------------------------------------------------------------------------*/
 
-int G_row_update_fp_range(const void *rast, int n,
-			  struct FPRange *range, RASTER_MAP_TYPE data_type)
+void G_row_update_fp_range(const void *rast, int n,
+			   struct FPRange *range, RASTER_MAP_TYPE data_type)
 {
     DCELL val = 0L;
 
@@ -552,8 +541,6 @@ int G_row_update_fp_range(const void *rast, int n,
 
 	rast = G_incr_void_ptr(rast, G_raster_size(data_type));
     }
-
-    return 0;
 }
 
 /*-------------------------------------------------------------------------*/
@@ -568,16 +555,14 @@ int G_row_update_fp_range(const void *rast, int n,
  * no min/max have been defined - probably a <tt>"first"</tt> boolean flag.
  *
  *  \param range
- *  \return int
+ *  \return
  */
 
-int G_init_range(struct Range *range)
+void G_init_range(struct Range *range)
 {
     G_set_c_null_value(&(range->min), 1);
     G_set_c_null_value(&(range->max), 1);
     range->first_time = 1;
-
-    return 0;
 }
 
 /*-------------------------------------------------------------------------*/
@@ -596,11 +581,11 @@ int G_init_range(struct Range *range)
  *  \param range
  *  \param min
  *  \param max
- *  \return int
+ *  \return
  */
 
 
-int G_get_range_min_max(const struct Range *range, CELL * min, CELL * max)
+void G_get_range_min_max(const struct Range *range, CELL * min, CELL * max)
 {
     if (range->first_time) {
 	G_set_c_null_value(min, 1);
@@ -617,8 +602,6 @@ int G_get_range_min_max(const struct Range *range, CELL * min, CELL * max)
 	else
 	    *max = range->max;
     }
-
-    return 0;
 }
 
 /*-------------------------------------------------------------------------*/
@@ -631,16 +614,14 @@ int G_get_range_min_max(const struct Range *range, CELL * min, CELL * max)
  * <tt>"first"</tt> boolean flag.
  *
  *  \param r
- *  \return int
+ *  \return
  */
 
-int G_init_fp_range(struct FPRange *range)
+void G_init_fp_range(struct FPRange *range)
 {
     G_set_d_null_value(&(range->min), 1);
     G_set_d_null_value(&(range->max), 1);
     range->first_time = 1;
-
-    return 0;
 }
 
 /*-------------------------------------------------------------------------*/
@@ -656,11 +637,11 @@ int G_init_fp_range(struct FPRange *range)
  *  \param r
  *  \param min
  *  \param max
- *  \return int
+ *  \return
  */
 
-int G_get_fp_range_min_max(const struct FPRange *range,
-			   DCELL * min, DCELL * max)
+void G_get_fp_range_min_max(const struct FPRange *range,
+			    DCELL *min, DCELL *max)
 {
     if (range->first_time) {
 	G_set_d_null_value(min, 1);
@@ -677,6 +658,4 @@ int G_get_fp_range_min_max(const struct FPRange *range,
 	else
 	    *max = range->max;
     }
-
-    return 0;
 }

lib/gis/raster.c

@@ -99,13 +99,12 @@ int G_raster_cmp(const void *v1, const void *v2, RASTER_MAP_TYPE data_type)
  *  \param q
  *  \param n
  *  \param data_type
- *  \return int
+ *  \return
  */
 
-int G_raster_cpy(void *v1, const void *v2, int n, RASTER_MAP_TYPE data_type)
+void G_raster_cpy(void *v1, const void *v2, int n, RASTER_MAP_TYPE data_type)
 {
-    G_copy((char *)v1, (char *)v2, n * G_raster_size(data_type));
-    return 0;
+    G_copy(v1, v2, n * G_raster_size(data_type));
 }
 
 
@@ -119,17 +118,17 @@ int G_raster_cpy(void *v1, const void *v2, int n, RASTER_MAP_TYPE data_type)
  *  \param p
  *  \param val
  *  \param data_type
- *  \return int
+ *  \return
  */
 
-int G_set_raster_value_c(void *rast, CELL cval, RASTER_MAP_TYPE data_type)
+void G_set_raster_value_c(void *rast, CELL cval, RASTER_MAP_TYPE data_type)
 {
     CELL c;
 
     c = cval;
     if (G_is_c_null_value(&c)) {
 	G_set_null_value(rast, 1, data_type);
-	return 0;
+	return;
     }
     switch (data_type) {
     case CELL_TYPE:
@@ -142,8 +141,6 @@ int G_set_raster_value_c(void *rast, CELL cval, RASTER_MAP_TYPE data_type)
 	*((DCELL *) rast) = (DCELL) cval;
 	break;
     }
-
-    return 0;
 }
 
 
@@ -157,17 +154,17 @@ int G_set_raster_value_c(void *rast, CELL cval, RASTER_MAP_TYPE data_type)
  *  \param p
  *  \param val
  *  \param data_type
- *  \return int
+ *  \return
  */
 
-int G_set_raster_value_f(void *rast, FCELL fval, RASTER_MAP_TYPE data_type)
+void G_set_raster_value_f(void *rast, FCELL fval, RASTER_MAP_TYPE data_type)
 {
     FCELL f;
 
     f = fval;
     if (G_is_f_null_value(&f)) {
 	G_set_null_value(rast, 1, data_type);
-	return 0;
+	return;
     }
     switch (data_type) {
     case CELL_TYPE:
@@ -180,8 +177,6 @@ int G_set_raster_value_f(void *rast, FCELL fval, RASTER_MAP_TYPE data_type)
 	*((DCELL *) rast) = (DCELL) fval;
 	break;
     }
-
-    return 0;
 }
 
 
@@ -195,17 +190,17 @@ int G_set_raster_value_f(void *rast, FCELL fval, RASTER_MAP_TYPE data_type)
  *  \param p
  *  \param val
  *  \param data_type
- *  \return int
+ *  \return
  */
 
-int G_set_raster_value_d(void *rast, DCELL dval, RASTER_MAP_TYPE data_type)
+void G_set_raster_value_d(void *rast, DCELL dval, RASTER_MAP_TYPE data_type)
 {
     DCELL d;
 
     d = dval;
     if (G_is_d_null_value(&d)) {
 	G_set_null_value(rast, 1, data_type);
-	return -1;
+	return;
     }
     switch (data_type) {
     case CELL_TYPE:
@@ -218,8 +213,6 @@ int G_set_raster_value_d(void *rast, DCELL dval, RASTER_MAP_TYPE data_type)
 	*((DCELL *) rast) = dval;
 	break;
     }
-
-    return 0;
 }
 
 

lib/gis/reclass.c

@@ -150,7 +150,7 @@ int G_get_reclass(const char *name, const char *mapset,
     return stat;
 }
 
-int G_free_reclass(struct Reclass *reclass)
+void G_free_reclass(struct Reclass *reclass)
 {
     switch (reclass->type) {
     case RECLASS_TABLE:
@@ -167,8 +167,6 @@ int G_free_reclass(struct Reclass *reclass)
     default:
 	break;
     }
-
-    return 0;
 }
 
 static int reclass_type(FILE * fd, char **rname, char **rmapset)

lib/gis/rhumbline.c

@@ -32,10 +32,10 @@
 #include "pi.h"
 
 
-static int adjust_lat(double *);
+static void adjust_lat(double *);
 
 #if 0
-static int adjust_lon(double *);
+static void adjust_lon(double *);
 #endif /* unused */
 
 static struct state {
@@ -109,24 +109,20 @@ double G_rhumbline_lat_from_lon(double lon)
 
 
 #if 0
-static int adjust_lon(double *lon)
+static void adjust_lon(double *lon)
 {
     while (*lon > 180.0)
 	*lon -= 360.0;
     while (*lon < -180.0)
 	*lon += 360.0;
-
-    return 0;
 }
 #endif /* unused */
 
 
-static int adjust_lat(double *lat)
+static void adjust_lat(double *lat)
 {
     if (*lat > 90.0)
 	*lat = 90.0;
     if (*lat < -90.0)
 	*lat = -90.0;
-
-    return 0;
 }

lib/gis/short_way.c

@@ -27,10 +27,10 @@
  *
  * \param[in] east1 east (x) coordinate of first point
  * \param[in] east2 east (x) coordinate of second point
- * \return always returns 0
+ * \return
  */
 
-int G_shortest_way(double *east1, double *east2)
+void G_shortest_way(double *east1, double *east2)
 {
     if (G_projection() == PROJECTION_LL) {
 	if (*east1 > *east2)
@@ -40,6 +40,4 @@ int G_shortest_way(double *east1, double *east2)
 	    while ((*east2 - *east1) > 180)
 		*east1 += 360;
     }
-
-    return 0;
 }

lib/gis/strings.c

@@ -195,9 +195,9 @@ char *G_str_replace(char *buffer, const char *old_str, const char *new_str)
  *
  * \param[in,out] buf buffer to be worked on
  *
- * \return 0
+ * \return
  */
-int G_strip(char *buf)
+void G_strip(char *buf)
 {
     char *a, *b;
 
@@ -212,8 +212,6 @@ int G_strip(char *buf)
 	a++;
 	*a = 0;
     }
-
-    return 0;
 }
 
 /*!

lib/gis/tempfile.c

@@ -84,10 +84,10 @@ char *G__tempfile(int pid)
  * \brief Populates <b>element</b> with a path string.
  *
  * \param[in,out] element
- * \return always returns 0
+ * \return
  */
 
-int G__temp_element(char *element)
+void G__temp_element(char *element)
 {
     const char *machine;
 
@@ -98,6 +98,4 @@ int G__temp_element(char *element)
 	strcat(element, machine);
     }
     G__make_mapset_element(element);
-
-    return 0;
 }

lib/gis/timestamp.c

@@ -247,10 +247,10 @@ int G_scan_timestamp(struct TimeStamp *ts, const char *buf)
  *  \param dt1    first DateTime struct to be filled
  *  \param dt2    second DateTime struct to be filled
  *  \param count  return code
- *  \return int   always 0
+ *  \return
  */
-int G_get_timestamps(const struct TimeStamp *ts,
-		     DateTime * dt1, DateTime * dt2, int *count)
+void G_get_timestamps(const struct TimeStamp *ts,
+		      DateTime * dt1, DateTime * dt2, int *count)
 {
     *count = 0;
     if (ts->count > 0) {
@@ -261,8 +261,6 @@ int G_get_timestamps(const struct TimeStamp *ts,
 	datetime_copy(dt2, &ts->dt[1]);
 	*count = 2;
     }
-
-    return 0;
 }
 
 

lib/gis/token.c

@@ -92,14 +92,12 @@ int G_number_of_tokens(char **tokens)
  * tokens to release memory.
  *
  * \param[in,out] tokens
- * \return always returns 0
+ * \return
  */
 
-int G_free_tokens(char **tokens)
+void G_free_tokens(char **tokens)
 {
     if (tokens[0] != NULL)
 	G_free(tokens[0]);
     G_free(tokens);
-
-    return (0);
 }

lib/gis/trim_dec.c

@@ -23,23 +23,21 @@
  * Example: 23.45000 would come back as 23.45
  *
  * \param[in,out] buf
- * \return always returns 0
+ * \return
  */
 
-int G_trim_decimal(char *buf)
+void G_trim_decimal(char *buf)
 {
     char *mark;
 
     /* find the . */
     while (*buf != '.')
 	if (*buf++ == 0)
-	    return 0;
+	    return;
 
     mark = buf;
     while (*++buf)
 	if (*buf != '0')
 	    mark = buf + 1;
     *mark = 0;
-
-    return 0;
 }

lib/gis/view.c

@@ -42,14 +42,12 @@ static int Suppress_warn = 0;
  * the window when the view was saved overlaps the current window.
  *
  * \param[in] b
- * \return always returns 0
+ * \return
  */
 
-int G_3dview_warning(int b)
+void G_3dview_warning(int b)
 {
     Suppress_warn = b ? 0 : 1;
-
-    return 0;
 }
 
 

lib/gis/wind_2_box.c

@@ -27,11 +27,11 @@
  * \param[in,out] dst destination window
  * \param[in] rows number of rows in box
  * \param[in] cols number of columns in box
- * \return always returns 0
+ * \return
  */
 
-int G_adjust_window_to_box(const struct Cell_head *src,
-			   struct Cell_head *dst, int rows, int cols)
+void G_adjust_window_to_box(const struct Cell_head *src,
+			    struct Cell_head *dst, int rows, int cols)
 {
     double ew, ns;
 
@@ -53,6 +53,4 @@ int G_adjust_window_to_box(const struct Cell_head *src,
     /* compute rows and cols */
     dst->rows = (dst->north - dst->south) / dst->ns_res;
     dst->cols = (dst->east - dst->west) / dst->ew_res;
-
-    return 0;
 }

lib/gis/wind_format.c

@@ -18,7 +18,7 @@
 #include <grass/gis.h>
 
 
-static int format_double(double, char *);
+static void format_double(double, char *);
 
 
 /**
@@ -30,17 +30,15 @@ static int format_double(double, char *);
  * \param[in] north northing
  * \param[in,out] buf buffer to hold formatted string
  * \param[in] projection
- * \return always returns 0
+ * \return
  */
 
-int G_format_northing(double north, char *buf, int projection)
+void G_format_northing(double north, char *buf, int projection)
 {
     if (projection == PROJECTION_LL)
 	G_lat_format(north, buf);
     else
 	format_double(north, buf);
-
-    return 0;
 }
 
 
@@ -53,17 +51,15 @@ int G_format_northing(double north, char *buf, int projection)
  * \param[in] east easting
  * \param[in,out] buf buffer to hold formatted string
  * \param[in] projection
- * \return always returns 0
+ * \return
  */
 
-int G_format_easting(double east, char *buf, int projection)
+void G_format_easting(double east, char *buf, int projection)
 {
     if (projection == PROJECTION_LL)
 	G_lon_format(east, buf);
     else
 	format_double(east, buf);
-
-    return 0;
 }
 
 
@@ -76,23 +72,19 @@ int G_format_easting(double east, char *buf, int projection)
  *  \param[in] resolution
  *  \param[in,out] buf buffer to hold formatted string
  *  \param[in] projection
- *  \return always returns 0
+ *  \return
  */
 
-int G_format_resolution(double res, char *buf, int projection)
+void G_format_resolution(double res, char *buf, int projection)
 {
     if (projection == PROJECTION_LL)
 	G_llres_format(res, buf);
     else
 	format_double(res, buf);
-
-    return 0;
 }
 
-static int format_double(double value, char *buf)
+static void format_double(double value, char *buf)
 {
     sprintf(buf, "%.8f", value);
     G_trim_decimal(buf);
-
-    return 0;
 }

lib/gis/window_map.c

@@ -30,10 +30,10 @@
  * any way.
  *
  * \param[in] fd file descriptor
- * \return always returns 0
+ * \return
  */
 
-int G__create_window_mapping(int fd)
+void G__create_window_mapping(int fd)
 {
     struct fileinfo *fcb = &G__.fileinfo[fd];
     COLUMN_MAPPING *col;
@@ -45,7 +45,7 @@ int G__create_window_mapping(int fd)
     G__init_window();
 
     if (fcb->open_mode >= 0 && fcb->open_mode != OPEN_OLD)	/* open for write? */
-	return 0;
+	return;
     if (fcb->open_mode == OPEN_OLD)	/* already open ? */
 	G_free(fcb->col_map);
 
@@ -109,8 +109,6 @@ int G__create_window_mapping(int fd)
     fcb->C2 =
 	(fcb->cellhd.north - G__.window.north +
 	 G__.window.ns_res / 2.0) / fcb->cellhd.ns_res;
-
-    return 0;
 }
 
 
@@ -314,17 +312,15 @@ int G_window_cols(void)
 /**
  * \brief Initialize window.
  *
- * \return always returns 0
+ * \return
  */
 
-int G__init_window(void)
+void G__init_window(void)
 {
     if (!G__.window_set) {
 	G__.window_set = 1;
 	G_get_window(&G__.window);
     }
-
-    return 0;
 }
 
 

lib/gis/wr_cellhd.c

@@ -24,11 +24,11 @@
  * \param[in,out] fd header file
  * \param[in] cellhd pointed to cell header structure
  * \param[in] is_cellhd 1 cell header; 0 window
- * \return always returns 1
+ * \return
  */
 
-int G__write_Cell_head(FILE * fd,
-		       const struct Cell_head *cellhd, int is_cellhd)
+void G__write_Cell_head(FILE * fd,
+			const struct Cell_head *cellhd, int is_cellhd)
 {
     char buf[1024];
     int fmt;
@@ -63,8 +63,6 @@ int G__write_Cell_head(FILE * fd,
 	fprintf(fd, "format:     %d\n", cellhd->format);
 	fprintf(fd, "compressed: %d\n", cellhd->compressed);
     }
-
-    return 1;
 }
 
 
@@ -74,11 +72,11 @@ int G__write_Cell_head(FILE * fd,
  * \param[in,out] fd header file
  * \param[in] cellhd pointer to cell header structure
  * \param[in] is_cellhd 1 cell header; 0 window
- * \return always returns 1
+ * \return
  */
 
-int G__write_Cell_head3(FILE * fd,
-			const struct Cell_head *cellhd, int is_cellhd)
+void G__write_Cell_head3(FILE * fd,
+			 const struct Cell_head *cellhd, int is_cellhd)
 {
     char buf[1024];
     int fmt;
@@ -102,6 +100,4 @@ int G__write_Cell_head3(FILE * fd,
 
     G_format_resolution(cellhd->tb_res, buf, fmt);
     fprintf(fd, "t-b resol:  %s\n", buf);
-
-    return 1;
 }

lib/gis/writ_zeros.c

@@ -23,17 +23,17 @@
  *
  * \param[in] fd file descriptor
  * \param[in] n number of bytes to write
- * \return always returns 0
+ * \return
  */
 
-int G_write_zeros(int fd, size_t n)
+void G_write_zeros(int fd, size_t n)
 {
     char zeros[1024];
     char *z;
     int i;
 
     if (n <= 0)
-	return 0;
+	return;
 
     /* There is a subtle gotcha to be avoided here.
      *
@@ -61,6 +61,4 @@ int G_write_zeros(int fd, size_t n)
 	write(fd, zeros, i);
 	n -= i;
     }
-
-    return 0;
 }

lib/gis/zero.c

@@ -23,12 +23,10 @@
  *
  * \param[in,out] buf
  * \param[in] i number of bytes to be zeroed
- * \return always returns 0
+ * \return
  */
 
-int G_zero(void *buf, int i)
+void G_zero(void *buf, int i)
 {
     memset(buf, 0, i);
-
-    return 0;
 }

lib/gis/zero_cell.c

@@ -25,17 +25,15 @@
  * using <i>G_allocate_cell_buf.</i>
  *
  * \param[in] buf
- * \return always returns 0
+ * \return
  */
 
-int G_zero_cell_buf(CELL * buf)
+void G_zero_cell_buf(CELL * buf)
 {
     int i = G_window_cols();
 
     while (i--)
 	*buf++ = 0;
-
-    return 0;
 }
 
 
@@ -48,10 +46,10 @@ int G_zero_cell_buf(CELL * buf)
  *
  *  \param[in,out] rast
  *  \param[in] data_type RASTER_MAP_TYPE
- *  \return always returns 0
+ *  \return
  */
 
-int G_zero_raster_buf(void *rast, RASTER_MAP_TYPE data_type)
+void G_zero_raster_buf(void *rast, RASTER_MAP_TYPE data_type)
 {
     int i;
     unsigned char *ptr;
@@ -62,6 +60,4 @@ int G_zero_raster_buf(void *rast, RASTER_MAP_TYPE data_type)
 
     while (i--)
 	*ptr++ = 0;
-
-    return 0;
 }

lib/ogsf/Gvl3.c

@@ -63,8 +63,7 @@ int Gvl_load_colors_data(void **color_data, const char *name)
  */
 int Gvl_unload_colors_data(void *color_data)
 {
-    if (!G_free_colors(color_data))
-	return (-1);
+    G_free_colors(color_data);
 
     G_free(color_data);
 

raster/r.contour/main.c

@@ -269,13 +269,13 @@ double *getlevels(struct Option *levels,
 
 	dstep = atof(step->answer);
 	/* fix if step < 1, Roger Bivand 1/2001: */
-	dmax = (max->answer) ? atof(max->answer) : dstep == 0 ?
-	    G_fatal_error(_("This step value is not allowed.")) : zmax -
-	    fmod(zmax, dstep);
-	dmin =
-	    (min->answer) ? atof(min->answer) : dstep ==
-	    0 ? G_fatal_error(_("This step value is not allowed.")) :
-	    fmod(zmin, dstep) ? zmin - fmod(zmin, dstep) + dstep : zmin;
+	dmax = (max->answer) ? atof(max->answer) :
+	    dstep == 0 ? (G_fatal_error(_("This step value is not allowed.")), 0) :
+	    zmax - fmod(zmax, dstep);
+	dmin = (min->answer) ? atof(min->answer) :
+	    dstep == 0 ? (G_fatal_error(_("This step value is not allowed.")), 0) :
+	    fmod(zmin, dstep) ? zmin - fmod(zmin, dstep) + dstep :
+	    zmin;
 
 	while (dmin < zmin) {
 	    dmin += dstep;

raster/r.flow/mem.h

@@ -52,7 +52,7 @@ void put_row_seg( /* l, row */ );
 	(segment_get(as.seg, &v, \
 			row + as.row_offset, col + as.col_offset) < 1 ? \
 	  (sprintf(string,"r.flow: cannot read segment file for %s",as.name), \
-	   G_fatal_error(string)) : \
+	   G_fatal_error(string), 0) :					\
 	  v) : \
 	(parm.mem ? \
 	   aspect_fly(el.buf[row - 1] + col, \
@@ -64,7 +64,7 @@ void put_row_seg( /* l, row */ );
     (parm.seg ? \
 	(segment_get(l.seg, &v, row + l.row_offset, col + l.col_offset) < 1 ? \
 	  (sprintf(string,"r.flow: cannot read segment file for %s",l.name),\
-	   G_fatal_error(string)) : \
+	   G_fatal_error(string), 0) : \
 	 v) : \
 	l.buf[row][col])
 
@@ -73,6 +73,6 @@ void put_row_seg( /* l, row */ );
 	(v = w, \
 	 segment_put(l.seg, &v, row + l.row_offset, col + l.col_offset) < 1 ? \
 	  (sprintf(string,"r.flow: cannot write segment file for %s",l.name), \
-	   G_fatal_error(string)) : \
+	   G_fatal_error(string), 0) : \
 	 0) : \
 	(l.buf[row][col] = w))