Generate fatal errors rather than returning a status, for:

 Rast_set_window
 G_adjust_Cell_head
 G_adjust_Cell_head3
 G_align_window
 G__get_window
 G__read_Cell_head
 G__read_Cell_head_array



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

general/g.region/adjust.c

@@ -5,8 +5,5 @@
 
 void adjust_window(struct Cell_head *window, int row_flag, int col_flag, int depth_flag)
 {
-    const char *err = G_adjust_Cell_head3(window, row_flag, col_flag, depth_flag);
-
-    if (err)
-	G_fatal_error(_("Invalid region: %s"), err);
+    G_adjust_Cell_head3(window, row_flag, col_flag, depth_flag);
 }

general/g.region/local_proto.h

@@ -12,9 +12,6 @@
 #define PRINT_NANGLE 0x100
 #define PRINT_GMT    0x200
 
-/* adjust.c */
-void adjust_window(struct Cell_head *, int, int, int);
-
 /* zoom.c */
 int zoom(struct Cell_head *, const char *, const char *);
 

general/g.region/main.c

@@ -37,7 +37,6 @@ int main(int argc, char *argv[])
     const char *value;
     const char *name;
     const char *mapset;
-    const char *err;
     char **rast_ptr, **vect_ptr;
 
     struct GModule *module;
@@ -396,9 +395,7 @@ int main(int argc, char *argv[])
 	mapset = G_find_file2("windows", name, "");
 	if (!mapset)
 	    G_fatal_error(_("Region <%s> not found"), name);
-	if (G__get_window(&window, "windows", name, mapset) != NULL)
-	    G_fatal_error(_("Unable to read region <%s> in <%s>"), name,
-			  mapset);
+	G__get_window(&window, "windows", name, mapset);
     }
 
     /* 3dview= */
@@ -786,19 +783,18 @@ int main(int argc, char *argv[])
 	if (!mapset)
 	    G_fatal_error(_("Raster map <%s> not found"), name);
 	Rast_get_cellhd(name, mapset, &temp_window);
-	if ((err = G_align_window(&window, &temp_window)))
-	    G_fatal_error(_("Raster map <%s@%s>: %s"), name, mapset, err);
+	G_align_window(&window, &temp_window);
     }
 
     /* save= */
     if ((name = parm.save->answer)) {
 	G_copy(&temp_window, &window, sizeof(window));
-	adjust_window(&temp_window, 0, 0, 0);
+	G_adjust_Cell_head3(&temp_window, 0, 0, 0);
 	if (G__put_window(&temp_window, "windows", name) < 0)
 	    G_fatal_error(_("Unable to set region <%s>"), name);
     }
 
-    adjust_window(&window, row_flag, col_flag, 0);
+    G_adjust_Cell_head3(&window, row_flag, col_flag, 0);
     if (set_flag) {
 	if (G_put_window(&window) < 0)
 	    G_fatal_error(_("Unable to update current region"));

general/g.region/zoom.c

@@ -14,7 +14,7 @@ int zoom(struct Cell_head *window, const char *name, const char *mapset)
     int top, bottom, left, right, mark;
     double north, south, east, west;
 
-    adjust_window(window, 0, 0, 0);
+    G_adjust_Cell_head3(window, 0, 0, 0);
     Rast_set_window(window);
     nrows = window->rows;
     ncols = window->cols;

imagery/i.atcorr/main.cpp

@@ -98,8 +98,7 @@ static void adjust_region (char *name, const char *mapset)
 
     Rast_get_cellhd(name, mapset, &iimg_head);
 
-    if(Rast_set_window(&iimg_head) < 0) 
-	G_fatal_error (_("Invalid graphics region coordinates"));
+    Rast_set_window(&iimg_head);
 }
 
 

include/gisdefs.h

@@ -47,11 +47,11 @@
 #include <sys/types.h>
 
 /* adj_cellhd.c */
-const char *G_adjust_Cell_head(struct Cell_head *, int, int);
-const char *G_adjust_Cell_head3(struct Cell_head *, int, int, int);
+void G_adjust_Cell_head(struct Cell_head *, int, int);
+void G_adjust_Cell_head3(struct Cell_head *, int, int, int);
 
 /* align_window.c */
-const char *G_align_window(struct Cell_head *, const struct Cell_head *);
+void G_align_window(struct Cell_head *, const struct Cell_head *);
 
 /* alloc.c */
 #define G_incr_void_ptr(ptr, size) \
@@ -264,8 +264,8 @@ struct Key_Value *G_get_projinfo(void);
 /* get_window.c */
 void G_get_window(struct Cell_head *);
 void G_get_default_window(struct Cell_head *);
-char *G__get_window(struct Cell_head *, const char *, const char *,
-		    const char *);
+void G__get_window(struct Cell_head *, const char *, const char *,
+		   const char *);
 
 /* getl.c */
 int G_getl(char *, int, FILE *);
@@ -531,8 +531,8 @@ double G_transverse_radius_of_curvature(double, double, double);
 double G_radius_of_conformal_tangent_sphere(double, double, double);
 
 /* rd_cellhd.c */
-char *G__read_Cell_head(FILE *, struct Cell_head *, int);
-char *G__read_Cell_head_array(char **, struct Cell_head *, int);
+void G__read_Cell_head(FILE *, struct Cell_head *, int);
+void G__read_Cell_head_array(char **, struct Cell_head *, int);
 
 /* remove.c */
 int G_remove(const char *, const char *);
@@ -556,7 +556,7 @@ void G_fseek(FILE *, off_t, int);
 
 /* set_window.c */
 void G_get_set_window(struct Cell_head *);
-int G_set_window(struct Cell_head *);
+void G_set_window(struct Cell_head *);
 
 /* short_way.c */
 void G_shortest_way(double *, double *);

include/rasterdefs.h

@@ -515,7 +515,7 @@ DCELL Rast_get_sample_cubic(int, const struct Cell_head *, struct Categories *,
 DCELL Rast_get_sample(int, const struct Cell_head *, struct Categories *, double, double, int, INTERP_TYPE);
 
 /* set_window.c */
-int Rast_set_window(struct Cell_head *);
+void Rast_set_window(struct Cell_head *);
 
 /* window_map.c */
 void Rast__create_window_mapping(int);

lib/display/setup.c

@@ -43,8 +43,7 @@ void D_setup(int clear)
     D_get_window(&dt, &db, &dl, &dr);
 
     G_get_set_window(&region);
-    if (Rast_set_window(&region) < 0)
-	G_fatal_error("Invalid graphics coordinates");
+    Rast_set_window(&region);
 
     D_do_conversions(&region, dt, db, dl, dr);
 

lib/g3d/g3dregion.c

@@ -152,12 +152,9 @@ G3d_regionFromToCellHead(struct Cell_head *region2d, G3D_Region * region3d)
 void G3d_adjustRegion(G3D_Region * region)
 {
     struct Cell_head region2d;
-    const char *err;
 
     G3d_regionToCellHead(region, &region2d);
-    if ((err = G_adjust_Cell_head3(&region2d, 1, 1, 1)) != NULL) {
-	G_fatal_error("G3d_adjustRegion: %s", err);
-    }
+    G_adjust_Cell_head3(&region2d, 1, 1, 1);
     G3d_regionFromToCellHead(&region2d, region);
 
     if (region->depths <= 0)
@@ -181,12 +178,9 @@ void G3d_adjustRegion(G3D_Region * region)
 void G3d_adjustRegionRes(G3D_Region * region)
 {
     struct Cell_head region2d;
-    const char *err;
 
     G3d_regionToCellHead(region, &region2d);
-    if ((err = G_adjust_Cell_head3(&region2d, 1, 1, 1)) != NULL) {
-	G_fatal_error("G3d_adjustRegionRes: %s", err);
-    }
+    G_adjust_Cell_head3(&region2d, 1, 1, 1);
     G3d_regionFromToCellHead(&region2d, region);
 
     if (region->tb_res <= 0)

lib/gis/adj_cellhd.c

@@ -36,25 +36,24 @@
  * \param col_flag compute e-w resolution
 
  * \return NULL on success
- * \return localized text string on error
  */
-const char *G_adjust_Cell_head(struct Cell_head *cellhd, int row_flag, int col_flag)
+void G_adjust_Cell_head(struct Cell_head *cellhd, int row_flag, int col_flag)
 {
     if (!row_flag) {
 	if (cellhd->ns_res <= 0)
-	    return (_("Illegal n-s resolution value"));
+	    G_fatal_error(_("Illegal n-s resolution value"));
     }
     else {
 	if (cellhd->rows <= 0)
-	    return (_("Illegal row value"));
+	    G_fatal_error(_("Illegal row value"));
     }
     if (!col_flag) {
 	if (cellhd->ew_res <= 0)
-	    return (_("Illegal e-w resolution value"));
+	    G_fatal_error(_("Illegal e-w resolution value"));
     }
     else {
 	if (cellhd->cols <= 0)
-	    return (_("Illegal col value"));
+	    G_fatal_error(_("Illegal col value"));
     }
 
     /* for lat/lon, check north,south. force east larger than west */
@@ -79,7 +78,7 @@ const char *G_adjust_Cell_head(struct Cell_head *cellhd, int row_flag, int col_f
 		cellhd->north = 90.0;
 	    }
 	    else
-		return (_("Illegal latitude for North"));
+		G_fatal_error(_("Illegal latitude for North"));
 	}
 
 	if (cellhd->south < -90.0) {
@@ -90,7 +89,7 @@ const char *G_adjust_Cell_head(struct Cell_head *cellhd, int row_flag, int col_f
 		cellhd->south = -90.0;
 	    }
 	    else
-		return (_("Illegal latitude for South"));
+		G_fatal_error(_("Illegal latitude for South"));
 	}
 
 #if 0
@@ -126,12 +125,12 @@ const char *G_adjust_Cell_head(struct Cell_head *cellhd, int row_flag, int col_f
     /* check the edge values */
     if (cellhd->north <= cellhd->south) {
 	if (cellhd->proj == PROJECTION_LL)
-	    return (_("North must be north of South"));
+	    G_fatal_error(_("North must be north of South"));
 	else
-	    return (_("North must be larger than South"));
+	    G_fatal_error(_("North must be larger than South"));
     }
     if (cellhd->east <= cellhd->west)
-	return (_("East must be larger than West"));
+	G_fatal_error(_("East must be larger than West"));
 
     /* compute rows and columns, if not set */
     if (!row_flag) {
@@ -150,15 +149,13 @@ const char *G_adjust_Cell_head(struct Cell_head *cellhd, int row_flag, int col_f
     }
 
     if (cellhd->cols < 0 || cellhd->rows < 0) {
-	return (_("Invalid coordinates"));
+	G_fatal_error(_("Invalid coordinates"));
     }
 
 
     /* (re)compute the resolutions */
     cellhd->ns_res = (cellhd->north - cellhd->south) / cellhd->rows;
     cellhd->ew_res = (cellhd->east - cellhd->west) / cellhd->cols;
-
-    return NULL;
 }
 
 /*!
@@ -186,42 +183,41 @@ const char *G_adjust_Cell_head(struct Cell_head *cellhd, int row_flag, int col_f
  * \param depth_flag compute t-b resolution
  *
  * \return NULL on success
- * \return localized text string on error
  */
-const char *G_adjust_Cell_head3(struct Cell_head *cellhd, int row_flag,
-				int col_flag, int depth_flag)
+void G_adjust_Cell_head3(struct Cell_head *cellhd, int row_flag,
+			 int col_flag, int depth_flag)
 {
     if (!row_flag) {
 	if (cellhd->ns_res <= 0)
-	    return (_("Illegal n-s resolution value"));
+	    G_fatal_error(_("Illegal n-s resolution value"));
 	if (cellhd->ns_res3 <= 0)
-	    return (_("Illegal n-s3 resolution value"));
+	    G_fatal_error(_("Illegal n-s3 resolution value"));
     }
     else {
 	if (cellhd->rows <= 0)
-	    return (_("Illegal row value"));
+	    G_fatal_error(_("Illegal row value"));
 	if (cellhd->rows3 <= 0)
-	    return (_("Illegal row3 value"));
+	    G_fatal_error(_("Illegal row3 value"));
     }
     if (!col_flag) {
 	if (cellhd->ew_res <= 0)
-	    return (_("Illegal e-w resolution value"));
+	    G_fatal_error(_("Illegal e-w resolution value"));
 	if (cellhd->ew_res3 <= 0)
-	    return (_("Illegal e-w3 resolution value"));
+	    G_fatal_error(_("Illegal e-w3 resolution value"));
     }
     else {
 	if (cellhd->cols <= 0)
-	    return (_("Illegal col value"));
+	    G_fatal_error(_("Illegal col value"));
 	if (cellhd->cols3 <= 0)
-	    return (_("Illegal col3 value"));
+	    G_fatal_error(_("Illegal col3 value"));
     }
     if (!depth_flag) {
 	if (cellhd->tb_res <= 0)
-	    return (_("Illegal t-b3 resolution value"));
+	    G_fatal_error(_("Illegal t-b3 resolution value"));
     }
     else {
 	if (cellhd->depths <= 0)
-	    return (_("Illegal depths value"));
+	    G_fatal_error(_("Illegal depths value"));
     }
 
     /* for lat/lon, check north,south. force east larger than west */
@@ -246,7 +242,7 @@ const char *G_adjust_Cell_head3(struct Cell_head *cellhd, int row_flag,
 		cellhd->north = 90.0;
 	    }
 	    else
-		return (_("Illegal latitude for North"));
+		G_fatal_error(_("Illegal latitude for North"));
 	}
 
 	if (cellhd->south < -90.0) {
@@ -257,7 +253,7 @@ const char *G_adjust_Cell_head3(struct Cell_head *cellhd, int row_flag,
 		cellhd->south = -90.0;
 	    }
 	    else
-		return (_("Illegal latitude for South"));
+		G_fatal_error(_("Illegal latitude for South"));
 	}
 
 #if 0
@@ -293,14 +289,14 @@ const char *G_adjust_Cell_head3(struct Cell_head *cellhd, int row_flag,
     /* check the edge values */
     if (cellhd->north <= cellhd->south) {
 	if (cellhd->proj == PROJECTION_LL)
-	    return (_("North must be north of South"));
+	    G_fatal_error(_("North must be north of South"));
 	else
-	    return (_("North must be larger than South"));
+	    G_fatal_error(_("North must be larger than South"));
     }
     if (cellhd->east <= cellhd->west)
-	return (_("East must be larger than West"));
+	G_fatal_error(_("East must be larger than West"));
     if (cellhd->top <= cellhd->bottom)
-	return (_("Top must be larger than Bottom"));
+	G_fatal_error(_("Top must be larger than Bottom"));
 
 
     /* compute rows and columns, if not set */
@@ -342,7 +338,7 @@ const char *G_adjust_Cell_head3(struct Cell_head *cellhd, int row_flag,
 
     if (cellhd->cols < 0 || cellhd->rows < 0 || cellhd->cols3 < 0 ||
 	cellhd->rows3 < 0 || cellhd->depths < 0) {
-	return (_("Invalid coordinates"));
+	G_fatal_error(_("Invalid coordinates"));
     }
 
     /* (re)compute the resolutions */
@@ -351,6 +347,4 @@ const char *G_adjust_Cell_head3(struct Cell_head *cellhd, int row_flag,
     cellhd->ew_res = (cellhd->east - cellhd->west) / cellhd->cols;
     cellhd->ew_res3 = (cellhd->east - cellhd->west) / cellhd->cols3;
     cellhd->tb_res = (cellhd->top - cellhd->bottom) / cellhd->depths;
-
-    return NULL;
 }

lib/gis/align_window.c

@@ -35,10 +35,9 @@
  * \param ref pointer to Cell_head
  *
  * \return NULL on success
- * \return Pointer to an error string on failure
  */
 
-const char *G_align_window(struct Cell_head *window, const struct Cell_head *ref)
+void G_align_window(struct Cell_head *window, const struct Cell_head *ref)
 {
     int preserve;
 
@@ -71,5 +70,5 @@ const char *G_align_window(struct Cell_head *window, const struct Cell_head *ref
 		window->east -= window->ew_res;
     }
 
-    return G_adjust_Cell_head(window, 0, 0);
+    G_adjust_Cell_head(window, 0, 0);
 }

lib/gis/get_window.c

@@ -46,7 +46,7 @@ static struct state *st = &state;
 
 void G_get_window(struct Cell_head *window)
 {
-    const char *regvar, *err;
+    const char *regvar;
 
     if (G_is_initialized(&st->initialized)) {
 	*window = st->dbwindow;
@@ -58,21 +58,17 @@ void G_get_window(struct Cell_head *window)
 
     if (regvar) {
 	char **tokens = G_tokenize(regvar, ";");
-	err = G__read_Cell_head_array(tokens, &st->dbwindow, 0);
+	G__read_Cell_head_array(tokens, &st->dbwindow, 0);
 	G_free_tokens(tokens);
     }
     else {
 	char *wind = getenv("WIND_OVERRIDE");
 	if (wind)
-	    err = G__get_window(&st->dbwindow, "windows", wind, G_mapset());
+	    G__get_window(&st->dbwindow, "windows", wind, G_mapset());
 	else
-	    err = G__get_window(&st->dbwindow, "", "WIND", G_mapset());
+	    G__get_window(&st->dbwindow, "", "WIND", G_mapset());
     }
 
-    if (err)
-	G_fatal_error(_("Region for current mapset %s. "
-			"Run \"g.region\" to fix the current region."), err);
-
     *window = st->dbwindow;
 
     if (!G__.window_set) {
@@ -97,10 +93,7 @@ void G_get_window(struct Cell_head *window)
 
 void G_get_default_window(struct Cell_head *window)
 {
-    const char *err = G__get_window(window, "", "DEFAULT_WIND", "PERMANENT");
-
-    if (err)
-	G_fatal_error(_("Default region %s"), err);
+    G__get_window(window, "", "DEFAULT_WIND", "PERMANENT");
 }
 
 /*!
@@ -114,29 +107,19 @@ void G_get_default_window(struct Cell_head *window)
   \return string on error
   \return NULL on success
 */
-char *G__get_window(struct Cell_head *window,
-		    const char *element, const char *name, const char *mapset)
+void G__get_window(struct Cell_head *window,
+		   const char *element, const char *name, const char *mapset)
 {
     FILE *fp;
-    char *err;
 
     G_zero(window, sizeof(struct Cell_head));
 
     /* Read from file */
     fp = G_fopen_old(element, name, mapset);
     if (!fp)
-	return G_store(_("is not set"));
+	G_fatal_error(_("Unable to open element file <%s> for <%s@%s>"),
+			element, name, mapset);
 
-    err = G__read_Cell_head(fp, window, 0);
+    G__read_Cell_head(fp, window, 0);
     fclose(fp);
-
-    if (err) {
-	char msg[1024];
-
-	sprintf(msg, _("is invalid\n%s"), err);
-	G_free(err);
-	return G_store(msg);
-    }
-
-    return NULL;
 }

lib/gis/rd_cellhd.c

@@ -7,11 +7,9 @@
 #include <grass/gis.h>
 #include <grass/glocale.h>
 
-#define ERROR(x,line) return error(x,line)
 static int scan_item(const char *, char *, char *);
 static int scan_int(const char *, int *);
 static double scan_double(const char *, double *);
-static char *error(const char *, int);
 
 #define F_PROJ   1
 #define F_ZONE   2
@@ -38,13 +36,10 @@ static char *error(const char *, int);
 #define SET(x) flags|=(1<<x)
 #define TEST(x) (flags&(1<<x))
 
-char *G__read_Cell_head_array(char **array,
-			      struct Cell_head *cellhd, int is_cellhd);
-
-char *G__read_Cell_head(FILE * fd, struct Cell_head *cellhd, int is_cellhd)
+void G__read_Cell_head(FILE * fd, struct Cell_head *cellhd, int is_cellhd)
 {
     int count;
-    char *result, **array;
+    char **array;
     char buf[1024];
 
     G_debug(2, "G__read_Cell_head");
@@ -64,7 +59,7 @@ char *G__read_Cell_head(FILE * fd, struct Cell_head *cellhd, int is_cellhd)
 	count++;
     }
 
-    result = G__read_Cell_head_array(array, cellhd, is_cellhd);
+    G__read_Cell_head_array(array, cellhd, is_cellhd);
 
     count = 0;
     while (array[count]) {
@@ -72,20 +67,17 @@ char *G__read_Cell_head(FILE * fd, struct Cell_head *cellhd, int is_cellhd)
 	count++;
     }
     G_free(array);
-
-    return result;
 }
 
 /* Read window from NULL terminated array of strings */
-char *G__read_Cell_head_array(char **array,
-			      struct Cell_head *cellhd, int is_cellhd)
+void G__read_Cell_head_array(char **array,
+			     struct Cell_head *cellhd, int is_cellhd)
 {
     char *buf;
     char label[200];
     char value[200];
     int i, line;
     int flags;
-    const char *err;
 
     G_debug(2, "G__read_Cell_head_array");
 
@@ -122,7 +114,7 @@ char *G__read_Cell_head_array(char **array,
 
 	switch (scan_item(buf, label, value)) {
 	case -1:
-	    ERROR(buf, line);
+	    G_fatal_error(_("Syntax error"));
 	case 0:
 	    continue;
 	case 1:
@@ -130,29 +122,29 @@ char *G__read_Cell_head_array(char **array,
 	}
 	if (strncmp(label, "proj", 4) == 0) {
 	    if (TEST(F_PROJ))
-		ERROR(_("duplicate projection field"), line);
+		G_fatal_error(_("duplicate projection field"));
 
 	    if (!scan_int(value, &cellhd->proj))
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 
 	    SET(F_PROJ);
 	    continue;
 	}
 	if (strncmp(label, "zone", 4) == 0) {
 	    if (TEST(F_ZONE))
-		ERROR(_("duplicate zone field"), line);
+		G_fatal_error(_("duplicate zone field"));
 
 	    if (!scan_int(value, &cellhd->zone))
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 
 	    SET(F_ZONE);
 	    continue;
 	}
     }
     if (!TEST(F_PROJ))
-	ERROR(_("projection field missing"), 0);
+	G_fatal_error(_("projection field missing"));
     if (!TEST(F_ZONE))
-	ERROR(_("zone field missing"), 0);
+	G_fatal_error(_("zone field missing"));
 
     /* read the other info */
     i = 0;
@@ -160,7 +152,7 @@ char *G__read_Cell_head_array(char **array,
 	G_debug(3, "region item: %s", buf);
 	switch (scan_item(buf, label, value)) {
 	case -1:
-	    ERROR(buf, line);
+	    G_fatal_error(_("Syntax error"));
 	case 0:
 	    continue;
 	case 1:
@@ -174,184 +166,184 @@ char *G__read_Cell_head_array(char **array,
 
 	if (strncmp(label, "nort", 4) == 0) {
 	    if (TEST(F_NORTH))
-		ERROR(_("duplicate north field"), line);
+		G_fatal_error(_("duplicate north field"));
 	    if (!G_scan_northing(value, &cellhd->north, cellhd->proj))
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    SET(F_NORTH);
 	    continue;
 	}
 	if (strncmp(label, "sout", 4) == 0) {
 	    if (TEST(F_SOUTH))
-		ERROR(_("duplicate south field"), line);
+		G_fatal_error(_("duplicate south field"));
 	    if (!G_scan_northing(value, &cellhd->south, cellhd->proj))
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    SET(F_SOUTH);
 	    continue;
 	}
 	if (strncmp(label, "east", 4) == 0) {
 	    if (TEST(F_EAST))
-		ERROR(_("duplicate east field"), line);
+		G_fatal_error(_("duplicate east field"));
 	    if (!G_scan_easting(value, &cellhd->east, cellhd->proj))
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    SET(F_EAST);
 	    continue;
 	}
 	if (strncmp(label, "west", 4) == 0) {
 	    if (TEST(F_WEST))
-		ERROR(_("duplicate west field"), line);
+		G_fatal_error(_("duplicate west field"));
 	    if (!G_scan_easting(value, &cellhd->west, cellhd->proj))
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    SET(F_WEST);
 	    continue;
 	}
 	if (strncmp(label, "top", 3) == 0) {
 	    if (TEST(F_TOP))
-		ERROR(_("duplicate top field"), line);
+		G_fatal_error(_("duplicate top field"));
 	    if (!scan_double(value, &cellhd->top))
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    SET(F_TOP);
 	    continue;
 	}
 	if (strncmp(label, "bottom", 6) == 0) {
 	    if (TEST(F_BOTTOM))
-		ERROR(_("duplicate bottom field"), line);
+		G_fatal_error(_("duplicate bottom field"));
 	    if (!scan_double(value, &cellhd->bottom))
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    SET(F_BOTTOM);
 	    continue;
 	}
 	if (strncmp(label, "e-w ", 4) == 0 && strlen(label) == 9) {
 	    if (TEST(F_EWRES))
-		ERROR(_("duplicate e-w resolution field"), line);
+		G_fatal_error(_("duplicate e-w resolution field"));
 	    if (!G_scan_resolution(value, &cellhd->ew_res, cellhd->proj))
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    if (cellhd->ew_res <= 0.0)
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    SET(F_EWRES);
 	    continue;
 	}
 	if (strncmp(label, "e-w resol3", 10) == 0) {
 	    if (TEST(F_EWRES3))
-		ERROR(_("duplicate 3D e-w resolution field"), line);
+		G_fatal_error(_("duplicate 3D e-w resolution field"));
 	    if (!G_scan_resolution(value, &cellhd->ew_res3, cellhd->proj))
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    if (cellhd->ew_res3 <= 0.0)
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    SET(F_EWRES3);
 	    continue;
 	}
 	if (strncmp(label, "n-s ", 4) == 0 && strlen(label) == 9) {
 	    if (TEST(F_NSRES))
-		ERROR(_("duplicate n-s resolution field"), line);
+		G_fatal_error(_("duplicate n-s resolution field"));
 	    if (!G_scan_resolution(value, &cellhd->ns_res, cellhd->proj))
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    if (cellhd->ns_res <= 0.0)
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    SET(F_NSRES);
 	    continue;
 	}
 	if (strncmp(label, "n-s resol3", 10) == 0) {
 	    if (TEST(F_NSRES3))
-		ERROR(_("duplicate 3D n-s resolution field"), line);
+		G_fatal_error(_("duplicate 3D n-s resolution field"));
 	    if (!G_scan_resolution(value, &cellhd->ns_res3, cellhd->proj))
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    if (cellhd->ns_res3 <= 0.0)
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    SET(F_NSRES3);
 	    continue;
 	}
 	if (strncmp(label, "t-b ", 4) == 0) {
 	    if (TEST(F_TBRES))
-		ERROR(_("duplicate t-b resolution field"), line);
+		G_fatal_error(_("duplicate t-b resolution field"));
 	    if (!scan_double(value, &cellhd->tb_res))
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    if (cellhd->tb_res <= 0.0)
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    SET(F_TBRES);
 	    continue;
 	}
 	if (strncmp(label, "rows", 4) == 0 && strlen(label) == 4) {
 	    if (TEST(F_ROWS))
-		ERROR(_("duplicate rows field"), line);
+		G_fatal_error(_("duplicate rows field"));
 	    if (!scan_int(value, &cellhd->rows))
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    if (cellhd->rows <= 0)
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    SET(F_ROWS);
 	    continue;
 	}
 	if (strncmp(label, "rows3", 5) == 0) {
 	    if (TEST(F_ROWS3))
-		ERROR(_("duplicate 3D rows field"), line);
+		G_fatal_error(_("duplicate 3D rows field"));
 	    if (!scan_int(value, &cellhd->rows3))
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    if (cellhd->rows3 <= 0)
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    SET(F_ROWS3);
 	    continue;
 	}
 	if (strncmp(label, "cols", 4) == 0 && strlen(label) == 4) {
 	    if (TEST(F_COLS))
-		ERROR(_("duplicate cols field"), line);
+		G_fatal_error(_("duplicate cols field"));
 	    if (!scan_int(value, &cellhd->cols))
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    if (cellhd->cols <= 0)
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    SET(F_COLS);
 	    continue;
 	}
 	if (strncmp(label, "cols3", 5) == 0) {
 	    if (TEST(F_COLS3))
-		ERROR(_("duplicate 3D cols field"), line);
+		G_fatal_error(_("duplicate 3D cols field"));
 	    if (!scan_int(value, &cellhd->cols3))
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    if (cellhd->cols3 <= 0)
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    SET(F_COLS3);
 	    continue;
 	}
 	if (strncmp(label, "depths", 6) == 0) {
 	    if (TEST(F_DEPTHS))
-		ERROR(_("duplicate depths field"), line);
+		G_fatal_error(_("duplicate depths field"));
 	    if (!scan_int(value, &cellhd->depths))
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    if (cellhd->depths <= 0)
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    SET(F_DEPTHS);
 	    continue;
 	}
 	if (strncmp(label, "form", 4) == 0) {
 	    if (TEST(F_FORMAT))
-		ERROR(_("duplicate format field"), line);
+		G_fatal_error(_("duplicate format field"));
 	    if (!scan_int(value, &cellhd->format))
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    SET(F_FORMAT);
 	    continue;
 	}
 	if (strncmp(label, "comp", 4) == 0) {
 	    if (TEST(F_COMP))
-		ERROR(_("duplicate compressed field"), line);
+		G_fatal_error(_("duplicate compressed field"));
 	    if (!scan_int(value, &cellhd->compressed))
-		ERROR(buf, line);
+		G_fatal_error(_("Syntax error"));
 	    SET(F_COMP);
 	    continue;
 	}
-	ERROR(buf, line);
+	G_fatal_error(_("Syntax error"));
     }
 
     /* check some of the fields */
     if (!TEST(F_NORTH))
-	ERROR(_("north field missing"), 0);
+	G_fatal_error(_("north field missing"));
     if (!TEST(F_SOUTH))
-	ERROR(_("south field missing"), 0);
+	G_fatal_error(_("south field missing"));
     if (!TEST(F_WEST))
-	ERROR(_("west field missing"), 0);
+	G_fatal_error(_("west field missing"));
     if (!TEST(F_EAST))
-	ERROR(_("east field missing"), 0);
+	G_fatal_error(_("east field missing"));
     if (!TEST(F_EWRES) && !TEST(F_COLS))
-	ERROR(_("cols field missing"), 0);
+	G_fatal_error(_("cols field missing"));
     if (!TEST(F_NSRES) && !TEST(F_ROWS))
-	ERROR(_("rows field missing"), 0);
+	G_fatal_error(_("rows field missing"));
     /* This next stmt is commented out to allow wr_cellhd.c to write
      * headers that will be readable by GRASS 3.1
      if ((TEST(F_ROWS) && TEST(F_NSRES))
@@ -362,13 +354,13 @@ char *G__read_Cell_head_array(char **array,
     /* 3D defined? */
     if (TEST(F_EWRES3) || TEST(F_NSRES3) || TEST(F_COLS3) || TEST(F_ROWS3)) {
 	if (!TEST(F_EWRES3))
-	    ERROR(_("ewres3 field missing"), 0);
+	    G_fatal_error(_("ewres3 field missing"));
 	if (!TEST(F_NSRES3))
-	    ERROR(_("nsres3 field missing"), 0);
+	    G_fatal_error(_("nsres3 field missing"));
 	if (!TEST(F_COLS3))
-	    ERROR(_("cols3 field missing"), 0);
+	    G_fatal_error(_("cols3 field missing"));
 	if (!TEST(F_ROWS3))
-	    ERROR(_("rows3 field missing"), 0);
+	    G_fatal_error(_("rows3 field missing"));
     }
     else {			/* use 2D */
 	cellhd->ew_res3 = cellhd->ew_res;
@@ -378,11 +370,7 @@ char *G__read_Cell_head_array(char **array,
     }
 
     /* Adjust and complete the cell header  */
-    if ((err = G_adjust_Cell_head(cellhd, TEST(F_ROWS), TEST(F_COLS))))
-	ERROR(err, 0);
-
-
-    return NULL;
+    G_adjust_Cell_head(cellhd, TEST(F_ROWS), TEST(F_COLS));
 }
 
 static int scan_item(const char *buf, char *label, char *value)
@@ -420,14 +408,3 @@ static double scan_double(const char *buf, double *n)
     return (sscanf(buf, "%lf%1s", n, dummy) == 1 && *dummy == 0);
 }
 
-static char *error(const char *msg, int line)
-{
-    char buf[1024];
-
-    if (line)
-	sprintf(buf, _("line %d: <%s>"), line, msg);
-    else
-	sprintf(buf, "<%s>", msg);
-
-    return G_store(buf);
-}

lib/gis/set_window.c

@@ -38,25 +38,18 @@ void G_get_set_window(struct Cell_head *window)
  * \return -1 on error
  * \return  1 on success
  */
-int G_set_window(struct Cell_head *window)
+void G_set_window(struct Cell_head *window)
 {
-    const char *err;
-
     /* adjust window, check for valid window */
     /* adjust the real one, not a copy
        G_copy (&twindow, window, sizeof(struct Cell_head));
        window = &twindow;
      */
 
-    if ((err = G_adjust_Cell_head(window, 0, 0))) {
-	G_warning("G_set_window(): %s", err);
-	return -1;
-    }
+    G_adjust_Cell_head(window, 0, 0);
 
     /* copy the window to the current window */
     G_copy((char *)&G__.window, (char *)window, sizeof(*window));
 
     G__.window_set = 1;
-
-    return 1;
 }

lib/raster/set_window.c

@@ -23,15 +23,11 @@
  * Any opened cell files has its file-to-window mapping reworked.
  *
  * \param window window to become operative window
- * 
- * \return -1 on error
- * \return  1 on success
  */
-int Rast_set_window(struct Cell_head *window)
+void Rast_set_window(struct Cell_head *window)
 {
     int i;
     int maskfd;
-    const char *err;
 
     Rast__init();
 
@@ -41,10 +37,7 @@ int Rast_set_window(struct Cell_head *window)
        window = &twindow;
      */
 
-    if ((err = G_adjust_Cell_head(window, 0, 0))) {
-	G_warning("Rast_set_window(): %s", err);
-	return -1;
-    }
+    G_adjust_Cell_head(window, 0, 0);
 
     /* except for MASK, cell files open for read must have same projection
      * and zone as new window
@@ -57,11 +50,9 @@ int Rast_set_window(struct Cell_head *window)
 	    if (fcb->cellhd.zone == window->zone &&
 		fcb->cellhd.proj == window->proj)
 		continue;
-	    if (i != maskfd) {
-		G_warning(_("Rast_set_window(): projection/zone differs from that of "
-			   "currently open raster maps"));
-		return -1;
-	    }
+	    if (i != maskfd)
+		G_fatal_error(_("Rast_set_window(): projection/zone differs from that of "
+				"currently open raster maps"));
 	}
     }
 
@@ -122,6 +113,4 @@ int Rast_set_window(struct Cell_head *window)
 
     /* we want the number of bytes per cell to be maximum
        so that there is enough memory for reading and writing rows */
-
-    return 1;
 }

lib/rst/interp_float/output2d.c

@@ -93,8 +93,7 @@ int IL_output_2d(struct interp_params *params, struct Cell_head *cellhd,	/* curr
 	return -1;
     }
 
-    if (Rast_set_window(cellhd) < 0)
-	return -1;
+    Rast_set_window(cellhd);
 
     if (nrows != G_window_rows()) {
 	G_warning(_("Rows changed from %d to %d"), nrows,

lib/rst/interp_float/resout2d.c

@@ -58,10 +58,7 @@ int IL_resample_output_2d(struct interp_params *params, double zmin, double zmax
 
     /* change region to output cell file region */
     G_verbose_message(_("Temporarily changing the region to desired resolution..."));
-    if (Rast_set_window(outhd) < 0) {
-	G_warning(_("Unable to set region"));
-	return -1;
-    }
+    Rast_set_window(outhd);
     mapset = G_mapset();
 
     cell1 = Rast_allocate_f_buf();
@@ -481,10 +478,7 @@ int IL_resample_output_2d(struct interp_params *params, double zmin, double zmax
 
 /* change region to initial region */
     G_verbose_message(_("Changing the region back to initial..."));
-    if (Rast_set_window(winhd) < 0) {
-	G_warning(_("Unable to set region"));
-	return -1;
-    }
+    Rast_set_window(winhd);
 
     return 1;
 }

ps/ps.map/main.c

@@ -288,8 +288,7 @@ int main(int argc, char *argv[])
 
     /* set current window */
     G_get_set_window(&PS.w);
-    if (Rast_set_window(&PS.w) == -1)
-	G_fatal_error(_("Current region cannot be set."));
+    Rast_set_window(&PS.w);
 
     while (1) {
 	char *key;

ps/ps.map/r_text.c

@@ -162,7 +162,7 @@ int read_text(char *east, char *north, char *text)
 		width = 1.;
 		error(key, data, "illegal width request");
 	    }
-	    if (t1 && t1[0] == 'i')
+	    if (t1[0] == 'i')
 		width = width / 72.0;
 	    continue;
 	}
@@ -174,7 +174,7 @@ int read_text(char *east, char *north, char *text)
 		hwidth = 0.;
 		error(key, data, "illegal width request");
 	    }
-	    if (t1 && t1[0] == 'i')
+	    if (t1[0] == 'i')
 		hwidth = hwidth / 72.0;
 	    continue;
 	}

ps/ps.map/r_wind.c

@@ -29,11 +29,7 @@ int read_wind(char *name, char *mapset)
 
     sprintf(fullname, "%s in %s", name, mapset);
 
-    if (G__get_window(&window, "windows", name, mapset) != NULL) {
-	error(fullname, "", "can't read region definition file");
-	gobble_input();
-	return 0;
-    }
+    G__get_window(&window, "windows", name, mapset);
 
     width = 1.;
     color_R = color_G = color_B = 0;

raster/r.external/main.c

@@ -648,8 +648,7 @@ int main(int argc, char *argv[])
     if (!hBand)
 	G_fatal_error(_("Selected band (%d) does not exist"), band);
 
-    if (Rast_set_window(&cellhd) < 0)
-	G_fatal_error(_("Unable to set window"));
+    Rast_set_window(&cellhd);
 
     query_band(hBand, output, flag_r->answer, &cellhd, &info);
     create_map(input, band, output, &cellhd, &info, title, flip);

raster/r.flow/io.c

@@ -194,8 +194,7 @@ void write_density_file(void)
     struct Colors colors;
     CELL val1, val2;
 
-    if (Rast_set_window(&region) < 0)
-	G_fatal_error(_("Cannot reset current region"));
+    Rast_set_window(&region);
 
     G_message(_("Writing density file"));
     dsfd = Rast_open_new(parm.dsout, DCELL_TYPE);

raster/r.horizon/main.c

@@ -463,8 +463,7 @@ int main(int argc, char *argv[])
 	n100 = ceil(n / 100.);
 	m100 = ceil(m / 100.);
 
-	if (Rast_set_window(&new_cellhd) == -1)
-	    exit(EXIT_FAILURE);
+	Rast_set_window(&new_cellhd);
     }
 
     struct Key_Value *in_proj_info, *in_unit_info;
@@ -501,20 +500,7 @@ int main(int argc, char *argv[])
 	      (int)(wbufferZone / stepx), (int)(sbufferZone / stepy),
 	      (int)(nbufferZone / stepy));
 
-    if (bufferZone > 0.) {
-	/* Set the region window back to the original */
-	if (Rast_set_window(&cellhd) == -1)
-	    exit(EXIT_FAILURE);
-    }
-
-    /* sorry, I've moved OUTGR() to calculate() - into the loop */
-    /*      if(isMode(WHOLE_RASTER))
-       {
-       OUTGR(cellhd.rows,cellhd.cols);
-       }
-     */
-    if (Rast_set_window(&cellhd) == -1)
-	exit(EXIT_FAILURE);
+    Rast_set_window(&cellhd);
 
     exit(EXIT_SUCCESS);
 }
@@ -601,8 +587,7 @@ int OUTGR(int numrows, int numcols)
     int fd1 = 0;
     int i, iarc, j;
 
-    if (Rast_set_window(&cellhd) < 0)
-	exit(EXIT_FAILURE);
+    Rast_set_window(&cellhd);
 
     if (horizon != NULL) {
 	cell1 = Rast_allocate_f_buf();
@@ -1239,10 +1224,8 @@ void calculate(double xcoord, double ycoord, int buffer_e, int buffer_w,
 	    }
 
 	    /* return back the buffered region */
-	    if (bufferZone > 0.) {
-		if (Rast_set_window(&new_cellhd) == -1)
-		    exit(0);
-	    }
+	    if (bufferZone > 0.)
+		Rast_set_window(&new_cellhd);
 
 	    /* write metadata */
 	    Rast_short_history(shad_filename, "raster", &history);

raster/r.in.arc/gethead.c

@@ -20,7 +20,6 @@ int gethead(FILE * fd, struct Cell_head *cellhd, int *missingval)
     int nodata, res, s, w, r, c;
     char label[100], value[100];
     char buf[1024];
-    const char *err;
 
     s = nodata = res = w = r = c = 0;
 
@@ -98,10 +97,7 @@ int gethead(FILE * fd, struct Cell_head *cellhd, int *missingval)
 	return 0;
     }
 
-    if (err = G_adjust_Cell_head(cellhd, 1, 1)) {
-	G_warning(err);
-	return 0;
-    }
+    G_adjust_Cell_head(cellhd, 1, 1);
 
     return 1;
 }

raster/r.in.arc/main.c

@@ -129,8 +129,7 @@ int main(int argc, char *argv[])
 
     nrows = cellhd.rows;
     ncols = cellhd.cols;
-    if (Rast_set_window(&cellhd) < 0)
-	G_fatal_error(_("Can't set window"));
+    Rast_set_window(&cellhd);
 
     if (nrows != G_window_rows())
 	G_fatal_error(_("OOPS: rows changed from %d to %d"), nrows,

raster/r.in.ascii/gethead.c

@@ -87,7 +87,6 @@ int gethead(FILE * fd,
     int n, s, e, w, r, c;
     char label[100], value[100];
     char buf[1024];
-    const char *err;
     int ret, len;
 
     /* rsb fix */
@@ -221,10 +220,7 @@ int gethead(FILE * fd,
 	}
     }
 
-    if ((err = G_adjust_Cell_head(cellhd, 1, 1))) {
-	G_warning(err);
-	return 0;
-    }
+    G_adjust_Cell_head(cellhd, 1, 1);
 
     return 1;
 }

raster/r.in.ascii/main.c

@@ -189,8 +189,7 @@ int main(int argc, char *argv[])
 
     nrows = cellhd.rows;
     ncols = cellhd.cols;
-    if (Rast_set_window(&cellhd) < 0)
-	G_fatal_error(_("Can't set window"));
+    Rast_set_window(&cellhd);
 
     if (nrows != G_window_rows())
 	G_fatal_error(_("OOPS: rows changed from %d to %d"), nrows,

raster/r.in.bin/main.c

@@ -226,7 +226,6 @@ int main(int argc, char *argv[])
     struct GRD_HEADER header;
     int row;
     struct History history;
-    const char *err;
     off_t expected;
 
     G_gisinit(argv[0]);
@@ -459,8 +458,7 @@ int main(int argc, char *argv[])
     }
 
     /* Adjust Cell Header to New Values */
-    if (err = G_adjust_Cell_head(&cellhd, 1, 1))
-	G_fatal_error("%s", err);
+    G_adjust_Cell_head(&cellhd, 1, 1);
 
     if (cellhd.proj == PROJECTION_LL && cellhd.ew_res / cellhd.ns_res > 10.)
 	/* TODO: find a reasonable value */
@@ -473,8 +471,7 @@ int main(int argc, char *argv[])
     grass_nrows = nrows = cellhd.rows;
     grass_ncols = ncols = cellhd.cols;
 
-    if (Rast_set_window(&cellhd) < 0)
-	G_fatal_error(_("Unable to set window"));
+    Rast_set_window(&cellhd);
 
     if (grass_nrows != G_window_rows())
 	G_fatal_error("rows changed from %d to %d",

raster/r.in.gdal/main.c

@@ -451,8 +451,7 @@ int main(int argc, char *argv[])
     /* -------------------------------------------------------------------- */
     /*      Set the active window to match the available data.              */
     /* -------------------------------------------------------------------- */
-    if (Rast_set_window(&cellhd) < 0)
-	exit(EXIT_FAILURE);
+    Rast_set_window(&cellhd);
 
     /* -------------------------------------------------------------------- */
     /*      Do we want to generate a simple raster, or an imagery group?    */

raster/r.in.gridatb/adjcellhd.c

@@ -10,9 +10,7 @@ int adjcellhd(struct Cell_head *cellhd)
 
     retval = 0;
 
-    if (Rast_set_window(cellhd) < 0) {
-	retval = 1;
-    }
+    Rast_set_window(cellhd);
 
     if (cellhd->rows != G_window_rows()) {
 	retval = 2;

raster/r.in.mat/main.c

@@ -67,7 +67,6 @@ int main(int argc, char *argv[])
     float *pval_f;		/* for misc use */
     double *pval_d;		/* for misc use */
     char c;			/* for misc use */
-    const char *err;
 
     char map_name[65], map_title[1024];	/* 65 = 64 + null-terminator */
     double map_name_d[1024];	/* I'm not sure why you'd save char strings as double, but whatever */
@@ -389,9 +388,7 @@ int main(int argc, char *argv[])
 
     region.proj = G_projection();
     region.zone = G_zone();
-    err = G_adjust_Cell_head(&region, 1, 1);
-    if (err)
-	G_fatal_error(err);
+    G_adjust_Cell_head(&region, 1, 1);
     Rast_set_window(&region);
 
     G_verbose_message("");

raster/r.out.gridatb/adjcellhd.c

@@ -5,8 +5,7 @@ int adjcellhd(struct Cell_head *cellhd)
 {
     int retval = 0;
 
-    if (G_set_window(cellhd) < 0)
-	retval = 1;
+    G_set_window(cellhd);
 
     if (cellhd->rows != G_window_rows())
 	retval = 2;

raster/r.region/main.c

@@ -31,7 +31,6 @@ int main(int argc, char *argv[])
     struct Cell_head cellhd, window;
     const char *value;
     const char *name;
-    const char *err;
 
     struct GModule *module;
     struct
@@ -163,10 +162,8 @@ int main(int argc, char *argv[])
     if (flag.cur->answer)
 	G_get_window(&window);
 
-    if ((name = parm.region->answer)) {	/* region= */
-	if (G__get_window(&window, "windows", name, "") != NULL)
-	    G_fatal_error(_("Unable to read region <%s>"), name);
-    }
+    if ((name = parm.region->answer))	/* region= */
+	G__get_window(&window, "windows", name, "");
 
     if ((name = parm.view->answer)) {	/* 3dview= */
 	struct G_3dview v;
@@ -311,15 +308,13 @@ int main(int argc, char *argv[])
 
 	Rast_get_cellhd(name, "", &temp_window);
 
-	if ((err = G_align_window(&window, &temp_window)))
-	    G_fatal_error("%s: %s", name, err);
+	G_align_window(&window, &temp_window);
     }
 
     window.rows = cellhd.rows;
     window.cols = cellhd.cols;
 
-    if ((err = G_adjust_Cell_head(&window, 1, 1)))
-	G_fatal_error(_("Invalid region: %s"), err);
+    G_adjust_Cell_head(&window, 1, 1);
 
     cellhd.north = window.north;
     cellhd.south = window.south;

raster/r.resamp.rst/main.c

@@ -464,14 +464,12 @@ int main(int argc, char *argv[])
 		    IL_secpar_loop_2d, IL_crst, IL_crstg, IL_write_temp_2d);
 
     G_message(_("Temporarily changing the region to desired resolution ..."));
-    if (Rast_set_window(&outhd) < 0)
-	G_fatal_error(_("Cannot set region to output region"));
+    Rast_set_window(&outhd);
 
     bitmask = IL_create_bitmask(&params);
     /* change region to initial region */
     G_message(_("Changing back to the original region ..."));
-    if (Rast_set_window(&winhd) < 0)
-	G_fatal_error(_("Cannot set region to back to the initial region"));
+    Rast_set_window(&winhd);
 
     ertot = 0.;
     cursegm = 0;

raster/r.sun/main.c

@@ -1157,9 +1157,7 @@ int OUTGR(void)
 	fd12 = Rast_open_fp_new(glob_rad);
     }
 
-
-    if (Rast_set_window(&cellhd) < 0)
-	G_fatal_error("Cannot set region to output region!");
+    Rast_set_window(&cellhd);
 
     if (m != G_window_rows())
 	G_fatal_error("OOPS: rows changed from %d to %d", m, G_window_rows());