Rast_incr_void_ptr moved back to libgis

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

display/d.rast.arrow/main.c

@@ -367,10 +367,10 @@ int main(int argc, char **argv)
 	    }
 
 	    if (no_arrow) {
-		ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(raster_type));
+		ptr = G_incr_void_ptr(ptr, Rast_raster_size(raster_type));
 		if (opt7->answer)
 		    mag_ptr =
-			Rast_incr_void_ptr(mag_ptr,
+			G_incr_void_ptr(mag_ptr,
 					Rast_raster_size(mag_raster_type));
 		no_arrow = FALSE;
 		continue;
@@ -494,10 +494,10 @@ int main(int argc, char **argv)
 		}
 	    }
 
-	    ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(raster_type));
+	    ptr = G_incr_void_ptr(ptr, Rast_raster_size(raster_type));
 	    if (opt7->answer)
 		mag_ptr =
-		    Rast_incr_void_ptr(mag_ptr, Rast_raster_size(mag_raster_type));
+		    G_incr_void_ptr(mag_ptr, Rast_raster_size(mag_raster_type));
 	}
     }
 

general/g.region/zoom.c

@@ -37,7 +37,7 @@ int zoom(struct Cell_head *window, const char *name, const char *mapset)
 	for (col = 0; col < ncols; col++) {
 	    if (!Rast_is_null_value(rast_ptr, map_type))
 		break;
-	    rast_ptr = Rast_incr_void_ptr(rast_ptr, Rast_raster_size(map_type));
+	    rast_ptr = G_incr_void_ptr(rast_ptr, Rast_raster_size(map_type));
 	}
 	if (col == ncols)
 	    continue;
@@ -50,7 +50,7 @@ int zoom(struct Cell_head *window, const char *name, const char *mapset)
 	for (mark = col; col < ncols; col++) {
 	    if (!Rast_is_null_value(rast_ptr, map_type))
 		mark = col;
-	    rast_ptr = Rast_incr_void_ptr(rast_ptr, Rast_raster_size(map_type));
+	    rast_ptr = G_incr_void_ptr(rast_ptr, Rast_raster_size(map_type));
 	}
 	if (mark > right)
 	    right = mark;

imagery/i.pca/main.c

@@ -260,12 +260,12 @@ static int calc_mu(int *fds, double *mu, int bands)
 	    for (col = 0; col < cols; col++) {
 		/* skip null cells */
 		if (Rast_is_null_value(rowbuf, maptype)) {
-		    ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(maptype));
+		    ptr = G_incr_void_ptr(ptr, Rast_raster_size(maptype));
 		    continue;
 		}
 
 		sum += Rast_get_raster_value_d(rowbuf, maptype);
-		ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(maptype));
+		ptr = G_incr_void_ptr(ptr, Rast_raster_size(maptype));
 	    }
 	}
 
@@ -327,8 +327,8 @@ static int calc_covariance(int *fds, double **covar, double *mu, int bands)
 		    /* skip null cells */
 		    if (Rast_is_null_value(ptr1, maptype) ||
 			Rast_is_null_value(ptr2, maptype2)) {
-			ptr1 = Rast_incr_void_ptr(ptr1, Rast_raster_size(maptype));
-			ptr2 = Rast_incr_void_ptr(ptr2, Rast_raster_size(maptype2));
+			ptr1 = G_incr_void_ptr(ptr1, Rast_raster_size(maptype));
+			ptr2 = G_incr_void_ptr(ptr2, Rast_raster_size(maptype2));
 			continue;
 		    }
 
@@ -337,8 +337,8 @@ static int calc_covariance(int *fds, double **covar, double *mu, int bands)
 			 mu[j]) * ((double)Rast_get_raster_value_d(ptr2,
 						   maptype2) - mu[k]);
 
-		    ptr1 = Rast_incr_void_ptr(ptr1, Rast_raster_size(maptype));
-		    ptr2 = Rast_incr_void_ptr(ptr2, Rast_raster_size(maptype2));
+		    ptr1 = G_incr_void_ptr(ptr1, Rast_raster_size(maptype));
+		    ptr2 = G_incr_void_ptr(ptr2, Rast_raster_size(maptype2));
 		}
 
 		covar[k][j] = covar[j][k];
@@ -445,16 +445,16 @@ write_pca(double **eigmat, int *inp_fd, char *out_basename,
 			if (Rast_is_null_value(rowptr, maptype)) {
 			    if (scale) {
 				Rast_set_null_value(outptr, 1, CELL_TYPE);
-				outptr = Rast_incr_void_ptr(outptr, cell_mapsiz);
+				outptr = G_incr_void_ptr(outptr, cell_mapsiz);
 			    }
 			    else {
 				Rast_set_null_value(outptr, 1, DCELL_TYPE);
 				outptr =
-				    Rast_incr_void_ptr(outptr, dcell_mapsiz);
+				    G_incr_void_ptr(outptr, dcell_mapsiz);
 			    }
 
 			    rowptr =
-				Rast_incr_void_ptr(rowptr,
+				G_incr_void_ptr(rowptr,
 						Rast_raster_size(maptype));
 			    continue;
 			}
@@ -502,11 +502,11 @@ write_pca(double **eigmat, int *inp_fd, char *out_basename,
 			}
 
 			outptr = (scale) ?
-			    Rast_incr_void_ptr(outptr, cell_mapsiz) :
-			    Rast_incr_void_ptr(outptr, dcell_mapsiz);
+			    G_incr_void_ptr(outptr, cell_mapsiz) :
+			    G_incr_void_ptr(outptr, dcell_mapsiz);
 
 			rowptr =
-			    Rast_incr_void_ptr(rowptr, Rast_raster_size(maptype));
+			    G_incr_void_ptr(rowptr, Rast_raster_size(maptype));
 		    }
 		}		/* for j = 0 to bands */
 

imagery/i.rectify/perform.c

@@ -40,7 +40,7 @@ int perform_georef(int infd, void *rast)
 	 */
 
 	if (Rast_get_raster_row_nomask
-	    (infd, Rast_incr_void_ptr(rast, rast_size), row, map_type) < 0)
+	    (infd, G_incr_void_ptr(rast, rast_size), row, map_type) < 0)
 	    return 0;
 
 	for (i = curidx; i < matrix_rows; i++) {
@@ -54,7 +54,7 @@ int perform_georef(int infd, void *rast)
 	    cmap = col_map[idx];
 	    left = row_left[idx];
 	    right = row_right[idx];
-	    do_cell(row, Rast_incr_void_ptr(rast, rast_size), cell_buf[idx]);
+	    do_cell(row, G_incr_void_ptr(rast, rast_size), cell_buf[idx]);
 
 	    row_min[idx]++;
 	    if (row_min[idx] > row_max[idx])
@@ -73,8 +73,8 @@ static int do_cell(int row, void *in, void *out)
     void *inptr, *outptr;
 
     for (; left <= right; left++) {
-	inptr = Rast_incr_void_ptr(in, cmap[left] * rast_size);
-	outptr = Rast_incr_void_ptr(out, left * rast_size);
+	inptr = G_incr_void_ptr(in, cmap[left] * rast_size);
+	outptr = G_incr_void_ptr(out, left * rast_size);
 	if (rmap[left] < 0)
 	    continue;
 	if (rmap[left] != row)
@@ -82,8 +82,8 @@ static int do_cell(int row, void *in, void *out)
 	Rast_raster_cpy(outptr, inptr, 1, map_type);
     }
     for (; left <= right; right--) {
-	inptr = Rast_incr_void_ptr(in, cmap[right] * rast_size);
-	outptr = Rast_incr_void_ptr(out, right * rast_size);
+	inptr = G_incr_void_ptr(in, cmap[right] * rast_size);
+	outptr = G_incr_void_ptr(out, right * rast_size);
 	if (rmap[right] < 0)
 	    continue;
 	if (rmap[right] != row)
@@ -91,8 +91,8 @@ static int do_cell(int row, void *in, void *out)
 	Rast_raster_cpy(outptr, inptr, 1, map_type);
     }
     for (col = left; col <= right; col++) {
-	inptr = Rast_incr_void_ptr(in, cmap[col] * rast_size);
-	outptr = Rast_incr_void_ptr(out, col * rast_size);
+	inptr = G_incr_void_ptr(in, cmap[col] * rast_size);
+	outptr = G_incr_void_ptr(out, col * rast_size);
 	if (rmap[col] == row)
 	    Rast_raster_cpy(outptr, inptr, 1, map_type);
     }

include/gisdefs.h

@@ -58,6 +58,7 @@ void *G__malloc(const char *, int, size_t);
 void *G__calloc(const char *, int, size_t, size_t);
 void *G__realloc(const char *, int, void *, size_t);
 void G_free(void *);
+void *G_incr_void_ptr(const void *, const size_t);
 
 #define G_malloc(n)     G__malloc(__FILE__, __LINE__, (n))
 #define G_calloc(m, n)  G__calloc(__FILE__, __LINE__, (m), (n))

include/raster.h

@@ -492,7 +492,6 @@ void Rast_init_fp_range(struct FPRange *);
 void Rast_get_fp_range_min_max(const struct FPRange *, DCELL *, DCELL *);
 
 /* raster.c */
-void *Rast_incr_void_ptr(const void *, const size_t);
 int Rast_raster_cmp(const void *, const void *, RASTER_MAP_TYPE);
 void Rast_raster_cpy(void *, const void *, int, RASTER_MAP_TYPE);
 void Rast_set_raster_value_c(void *, CELL, RASTER_MAP_TYPE);

lib/display/raster.c

@@ -106,7 +106,7 @@ static int draw_cell(int A_row,
     if (D__overlay_mode)
 	for (i = 0; i < ncols; i++) {
 	    set[i] = Rast_is_null_value(array, data_type);
-	    array = Rast_incr_void_ptr(array, Rast_raster_size(data_type));
+	    array = G_incr_void_ptr(array, Rast_raster_size(data_type));
 	}
 
     A_row =
@@ -178,9 +178,9 @@ int D_draw_raster_RGB(int A_row,
 			Rast_is_null_value(g_raster, g_type) ||
 			Rast_is_null_value(b_raster, b_type));
 
-	    r_raster = Rast_incr_void_ptr(r_raster, r_size);
-	    g_raster = Rast_incr_void_ptr(g_raster, g_size);
-	    b_raster = Rast_incr_void_ptr(b_raster, b_size);
+	    r_raster = G_incr_void_ptr(r_raster, r_size);
+	    g_raster = G_incr_void_ptr(g_raster, g_size);
+	    b_raster = G_incr_void_ptr(b_raster, b_size);
 	}
 
     A_row = COM_raster(ncols, A_row, r_buf, g_buf, b_buf,

lib/g3d/g3dfpxdr.c

@@ -153,11 +153,11 @@ int G3d_copyToXdr(const void *src, int nofNum)
 
     if (useXdr == G3D_NO_XDR) {
 	G3d_copyValues(src, 0, srcType, xdrTmp, 0, type, nofNum);
-	xdrTmp = Rast_incr_void_ptr(xdrTmp, nofNum * G3d_externLength(type));
+	xdrTmp = G_incr_void_ptr(xdrTmp, nofNum * G3d_externLength(type));
 	return 1;
     }
 
-    for (i = 0; i < nofNum; i++, src = Rast_incr_void_ptr(src, eltLength)) {
+    for (i = 0; i < nofNum; i++, src = G_incr_void_ptr(src, eltLength)) {
 
 	if (G3d_isNullValueNum(src, srcType)) {
 	    G3d_setXdrNullNum(xdrTmp, isFloat);
@@ -185,7 +185,7 @@ int G3d_copyToXdr(const void *src, int nofNum)
 	    }
 	}
 
-	xdrTmp = Rast_incr_void_ptr(xdrTmp, externLength);
+	xdrTmp = G_incr_void_ptr(xdrTmp, externLength);
     }
 
     return 1;
@@ -228,11 +228,11 @@ int G3d_copyFromXdr(int nofNum, void *dst)
 
     if (useXdr == G3D_NO_XDR) {
 	G3d_copyValues(xdrTmp, 0, type, dst, 0, dstType, nofNum);
-	xdrTmp = Rast_incr_void_ptr(xdrTmp, nofNum * G3d_externLength(type));
+	xdrTmp = G_incr_void_ptr(xdrTmp, nofNum * G3d_externLength(type));
 	return 1;
     }
 
-    for (i = 0; i < nofNum; i++, dst = Rast_incr_void_ptr(dst, eltLength)) {
+    for (i = 0; i < nofNum; i++, dst = G_incr_void_ptr(dst, eltLength)) {
 
 	if (G3d_isXdrNullNum(xdrTmp, isFloat)) {
 	    G3d_setNullValue(dst, 1, dstType);
@@ -260,7 +260,7 @@ int G3d_copyFromXdr(int nofNum, void *dst)
 	    }
 	}
 
-	xdrTmp = Rast_incr_void_ptr(xdrTmp, externLength);
+	xdrTmp = G_incr_void_ptr(xdrTmp, externLength);
     }
 
     return 1;

lib/g3d/g3dmisc.c

@@ -69,8 +69,8 @@ G3d_copyValues(const void *src, int offsSrc, int typeSrc, void *dst,
 
     eltLength = G3d_length(typeSrc);
 
-    src = Rast_incr_void_ptr(src, eltLength * offsSrc);
-    dst = Rast_incr_void_ptr(dst, eltLength * offsDst);
+    src = G_incr_void_ptr(src, eltLength * offsSrc);
+    dst = G_incr_void_ptr(dst, eltLength * offsDst);
 
     memcpy(dst, src, nElts * eltLength);
 }

lib/g3d/g3drange.c

@@ -33,11 +33,11 @@ G3d_range_updateFromTile(G3D_Map * map, const void *tile, int rows, int cols,
 	for (z = 0; z < depths; z++) {
 	    for (y = 0; y < rows; y++) {
 		Rast_row_update_fp_range(tile, cols, range, cellType);
-		tile = Rast_incr_void_ptr(tile, map->tileX * G3d_length(type));
+		tile = G_incr_void_ptr(tile, map->tileX * G3d_length(type));
 	    }
 	    if (yRedundant)
 		tile =
-		    Rast_incr_void_ptr(tile,
+		    G_incr_void_ptr(tile,
 				    map->tileX * yRedundant *
 				    G3d_length(type));
 	}
@@ -47,7 +47,7 @@ G3d_range_updateFromTile(G3D_Map * map, const void *tile, int rows, int cols,
     if (yRedundant) {
 	for (z = 0; z < depths; z++) {
 	    Rast_row_update_fp_range(tile, map->tileX * rows, range, cellType);
-	    tile = Rast_incr_void_ptr(tile, map->tileXY * G3d_length(type));
+	    tile = G_incr_void_ptr(tile, map->tileXY * G3d_length(type));
 	}
 	return;
     }

lib/g3d/g3dvolume.c

@@ -250,7 +250,7 @@ G3d_makeAlignedVolumeFile(void *map, const char *fileName,
 	    for (x = 0; x < nx; x++) {
 		/* G3d_putValueRegion? */
 		if (!G3d_putValue(mapVolume, x, y, z,
-				  Rast_incr_void_ptr(volumeBuf,
+				  G_incr_void_ptr(volumeBuf,
 						  (z * ny * nx + y * nx +
 						   x) * eltLength),
 				  G3d_fileTypeMap(mapVolume)))

lib/g3d/getblock.c

@@ -122,15 +122,15 @@ G3d_getBlock(G3D_Map * map, int x0, int y0, int z0, int nx, int ny, int nz,
 	for (y = y0; y < y1; y++) {
 	    for (x = x0; x < x1; x++) {
 		G3d_getValueRegion(map, x, y, z, block, type);
-		block = Rast_incr_void_ptr(block, length);
+		block = G_incr_void_ptr(block, length);
 	    }
 	    nNull = x0 + nx - x;
 	    G3d_setNullValue(block, nNull, type);
-	    block = Rast_incr_void_ptr(block, length * nNull);
+	    block = G_incr_void_ptr(block, length * nNull);
 	}
 	nNull = (y0 + ny - y) * nx;
 	G3d_setNullValue(block, nNull, type);
-	block = Rast_incr_void_ptr(block, length * nNull);
+	block = G_incr_void_ptr(block, length * nNull);
     }
     nNull = (z0 + nz - z) * ny * nx;
     G3d_setNullValue(block, nNull, type);

lib/g3d/tileread.c

@@ -39,13 +39,13 @@ G3d_xdrTile2tile(G3D_Map * map, void *tile, int rows, int cols, int depths,
 		    G3d_error("G3d_xdrTile2tile: error in G3d_copyFromXdr");
 		    return 0;
 		}
-		tile = Rast_incr_void_ptr(tile, cols * length);
+		tile = G_incr_void_ptr(tile, cols * length);
 		G3d_setNullValue(tile, xRedundant, type);
-		tile = Rast_incr_void_ptr(tile, xLength);
+		tile = G_incr_void_ptr(tile, xLength);
 	    }
 	    if (yRedundant) {
 		G3d_setNullValue(tile, map->tileX * yRedundant, type);
-		tile = Rast_incr_void_ptr(tile, yLength);
+		tile = G_incr_void_ptr(tile, yLength);
 	    }
 	}
 	if (!zRedundant)
@@ -61,9 +61,9 @@ G3d_xdrTile2tile(G3D_Map * map, void *tile, int rows, int cols, int depths,
 		G3d_error("G3d_xdrTile2tile: error in G3d_copyFromXdr");
 		return 0;
 	    }
-	    tile = Rast_incr_void_ptr(tile, map->tileX * rows * length);
+	    tile = G_incr_void_ptr(tile, map->tileX * rows * length);
 	    G3d_setNullValue(tile, map->tileX * yRedundant, type);
-	    tile = Rast_incr_void_ptr(tile, yLength);
+	    tile = G_incr_void_ptr(tile, yLength);
 	}
 	if (!zRedundant)
 	    return 1;
@@ -80,7 +80,7 @@ G3d_xdrTile2tile(G3D_Map * map, void *tile, int rows, int cols, int depths,
     if (!zRedundant)
 	return 1;
 
-    tile = Rast_incr_void_ptr(tile, map->tileXY * depths * length);
+    tile = G_incr_void_ptr(tile, map->tileXY * depths * length);
     G3d_setNullValue(tile, map->tileXY * zRedundant, type);
 
     return 1;

lib/g3d/tilewrite.c

@@ -39,11 +39,11 @@ G3d_tile2xdrTile(G3D_Map * map, const void *tile, int rows, int cols,
 		    G3d_error("G3d_tile2xdrTile: error in G3d_copyToXdr");
 		    return 0;
 		}
-		tile = Rast_incr_void_ptr(tile, map->tileX * G3d_length(type));
+		tile = G_incr_void_ptr(tile, map->tileX * G3d_length(type));
 	    }
 	    if (yRedundant)
 		tile =
-		    Rast_incr_void_ptr(tile,
+		    G_incr_void_ptr(tile,
 				    map->tileX * yRedundant *
 				    G3d_length(type));
 	}
@@ -56,7 +56,7 @@ G3d_tile2xdrTile(G3D_Map * map, const void *tile, int rows, int cols,
 		G3d_error("G3d_tile2xdrTile: error in G3d_copyToXdr");
 		return 0;
 	    }
-	    tile = Rast_incr_void_ptr(tile, map->tileXY * G3d_length(type));
+	    tile = G_incr_void_ptr(tile, map->tileXY * G3d_length(type));
 	}
 	return 1;
     }

lib/gis/alloc.c

@@ -129,3 +129,40 @@ void G_free(void *buf)
 {
     free(buf);
 }
+
+/*!
+ * \brief Advance void pointer
+ *
+ * Advances void pointer by <i>size</i> bytes. Returns new pointer
+ * value.
+ *
+ * Useful in raster row processing loops, substitutes
+ *
+ \code
+ CELL *cell; 
+ cell += n;
+ \endcode
+ *
+ * Now 
+ \code
+ rast = G_incr_void_ptr(rast, Rast_raster_size(data_type))
+ \endcode
+ *
+ * (where rast is void* and <i>data_type</i> is RASTER_MAP_TYPE can be
+ * used instead of rast++.)
+ *
+ * Very useful to generalize the row processing - loop i.e.
+ * \code
+ *   void * buf_ptr += Rast_raster_size(data_type)
+ * \endcode
+ *
+ * \param ptr pointer
+ * \param size buffer size
+ *
+ * \return pointer to the data
+ */
+void *G_incr_void_ptr(const void *ptr, const size_t size)
+{
+    /* assuming that the size of unsigned char is 1 */
+    return (void *)((const unsigned char *)ptr + size);
+}

lib/gpde/N_arrays_io.c

@@ -106,7 +106,7 @@ N_array_2d *N_read_rast_to_array_2d(char *name, N_array_2d * array)
 	}
 
 	for (x = 0, ptr = rast; x < cols;
-	     x++, ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(type))) {
+	     x++, ptr = G_incr_void_ptr(ptr, Rast_raster_size(type))) {
 	    if (type == CELL_TYPE) {
 		if (Rast_is_c_null_value(ptr)) {
 		    N_put_array_2d_value_null(data, x, y);

lib/raster/cats.c

@@ -634,7 +634,7 @@ int Rast_mark_raster_cats(const void *rast_row,
 	if (i > pcats->ncats)
 	    return -1;
 	pcats->marks[i]++;
-	rast_row = Rast_incr_void_ptr(rast_row, Rast_raster_size(data_type));
+	rast_row = G_incr_void_ptr(rast_row, Rast_raster_size(data_type));
     }
     return 1;
 }

lib/raster/color_look.c

@@ -280,7 +280,7 @@ void Rast__lookup_colors(const void *raster, unsigned char *red,
 
     for (; n-- > 0;
 	 ptr =
-	 Rast_incr_void_ptr(ptr, Rast_raster_size(data_type)), red++, grn++, blu++,
+	 G_incr_void_ptr(ptr, Rast_raster_size(data_type)), red++, grn++, blu++,
 	 *set++ = found) {
 	/* if the cell is the same as last one, use the prev color values */
 	if (ptr != raster && Rast_raster_cmp(ptr, last_ptr, data_type) == 0) {

lib/raster/get_row.c

@@ -676,7 +676,7 @@ static int get_map_row(int fd, void *rast, int row, RASTER_MAP_TYPE data_type,
 
     for (i = 0; i < R__.window.cols; i++) {
 	Rast_set_raster_value_c(rast, temp_buf[i], data_type);
-	rast = Rast_incr_void_ptr(rast, size);
+	rast = G_incr_void_ptr(rast, size);
     }
 
     G__freea(temp_buf);
@@ -1183,7 +1183,7 @@ static int embed_nulls(int fd, void *buf, int row, RASTER_MAP_TYPE map_type,
 	       is not set and calls G_set_[f/d]_null_value() otherwise */
 	    Rast__set_null_value(buf, 1, null_is_zero, map_type);
 	}
-	buf = Rast_incr_void_ptr(buf, Rast_raster_size(map_type));
+	buf = G_incr_void_ptr(buf, Rast_raster_size(map_type));
     }
 
     G__freea(null_buf);

lib/raster/get_row_colr.c

@@ -57,7 +57,7 @@ int Rast_get_raster_row_colors(int fd, int row, struct Colors *colors,
     }
 
     if (nul)
-	for (i = 0, p = array; i < cols; i++, p = Rast_incr_void_ptr(p, size))
+	for (i = 0, p = array; i < cols; i++, p = G_incr_void_ptr(p, size))
 	    nul[i] = Rast_is_null_value(p, type);
 
     set = G__alloca(cols);

lib/raster/put_row.c

@@ -601,8 +601,8 @@ static int put_data_gdal(int fd, const void *rast, int row, int n,
 	    Rast_set_raster_value_d(dst, null_val, map_type);
 	else
 	    memcpy(dst, src, size);
-	src = Rast_incr_void_ptr(src, size);
-	dst = Rast_incr_void_ptr(dst, size);
+	src = G_incr_void_ptr(src, size);
+	dst = G_incr_void_ptr(dst, size);
     }
 
     err = Rast_gdal_raster_IO(fcb->gdal->band, GF_Write, 0, row, n, 1, work_buf,

lib/raster/range.c

@@ -483,7 +483,7 @@ void Rast_row_update_fp_range(const void *rast, int n,
 	}
 
 	if (Rast_is_null_value(rast, data_type)) {
-	    rast = Rast_incr_void_ptr(rast, Rast_raster_size(data_type));
+	    rast = G_incr_void_ptr(rast, Rast_raster_size(data_type));
 	    continue;
 	}
 	if (range->first_time) {
@@ -498,7 +498,7 @@ void Rast_row_update_fp_range(const void *rast, int n,
 		range->max = val;
 	}
 
-	rast = Rast_incr_void_ptr(rast, Rast_raster_size(data_type));
+	rast = G_incr_void_ptr(rast, Rast_raster_size(data_type));
     }
 }
 

lib/raster/raster.c

@@ -16,43 +16,6 @@
 #include <grass/raster.h>
 
 /*!
- * \brief Advance void pointer
- *
- * Advances void pointer by <i>size</i> bytes. Returns new pointer
- * value.
- *
- * Useful in raster row processing loops, substitutes
- *
- \code
- CELL *cell; 
- cell += n;
- \endcode
- *
- * Now 
- \code
- rast = Rast_incr_void_ptr(rast, Rast_raster_size(data_type))
- \endcode
- *
- * (where rast is void* and <i>data_type</i> is RASTER_MAP_TYPE can be
- * used instead of rast++.)
- *
- * Very useful to generalize the row processing - loop i.e.
- * \code
- *   void * buf_ptr += Rast_raster_size(data_type)
- * \endcode
- *
- * \param ptr pointer
- * \param size buffer size
- *
- * \return pointer to the data
- */
-void *Rast_incr_void_ptr(const void *ptr, const size_t size)
-{
-    /* assuming that the size of unsigned char is 1 */
-    return (void *)((const unsigned char *)ptr + size);
-}
-
-/*!
  * \brief Compares raster values.
  *
  * \param v1,v2 values to be compared

ps/ps.map/outl_io.c

@@ -42,11 +42,11 @@ int o_read_row(void *buf)
 	}
 	else {
 	    Rast_set_null_value(ptr, 1, map_type);
-	    ptr = Rast_incr_void_ptr(ptr, raster_size);
+	    ptr = G_incr_void_ptr(ptr, raster_size);
 
 	    Rast_get_raster_row(in_file_d, ptr, row_count++, map_type);
 
-	    ptr = Rast_incr_void_ptr(ptr, raster_size * (row_length + 1));
+	    ptr = G_incr_void_ptr(ptr, raster_size * (row_length + 1));
 	    Rast_set_null_value(ptr, 1, map_type);
 	}
     }

ps/ps.map/ps_outline.c

@@ -124,13 +124,13 @@ int draw_outline(void)
 	    e1 = G_col_to_easting((double)col - 1., &(PS.w));
 	    e2 = G_col_to_easting((double)col, &(PS.w));
 	    e3 = G_col_to_easting((double)col + 1., &(PS.w));
-	    tl = Rast_incr_void_ptr(buffer[top], col * raster_size);
+	    tl = G_incr_void_ptr(buffer[top], col * raster_size);
 	    /* top left in window */
-	    tr = Rast_incr_void_ptr(buffer[top], (col + 1) * raster_size);
+	    tr = G_incr_void_ptr(buffer[top], (col + 1) * raster_size);
 	    /* top right in window */
-	    bl = Rast_incr_void_ptr(buffer[bottom], col * raster_size);
+	    bl = G_incr_void_ptr(buffer[bottom], col * raster_size);
 	    /* bottom left in window */
-	    br = Rast_incr_void_ptr(buffer[bottom], (col + 1) * raster_size);
+	    br = G_incr_void_ptr(buffer[bottom], (col + 1) * raster_size);
 	    /* bottom right in window */
 	    draw_boundaries();
 	    if (k == 3)

ps/ps.map/ps_raster.c

@@ -138,7 +138,7 @@ int PS_raster_plot(void)
 			}
 		    }
 		    ptr =
-			Rast_incr_void_ptr(ptr,
+			G_incr_void_ptr(ptr,
 					Rast_raster_size(map_type) *
 					PS.col_delta);
 		}
@@ -170,7 +170,7 @@ int PS_raster_plot(void)
 			    g = gg;
 			if (i == 2)
 			    b = bb;
-			cptr[i] = Rast_incr_void_ptr(cptr[i],
+			cptr[i] = G_incr_void_ptr(cptr[i],
 						  Rast_raster_size(grp_map_type
 								[0]) *
 						  PS.col_delta);

raster/r.carve/raster.c

@@ -17,7 +17,7 @@ void *read_raster(void *buf, const int fd, const RASTER_MAP_TYPE rtype)
 
 	Rast_get_raster_row(fd, tmpbuf, i, rtype);
 	tmpbuf =
-	    Rast_incr_void_ptr(tmpbuf, Rast_raster_size(rtype) * G_window_cols());
+	    G_incr_void_ptr(tmpbuf, Rast_raster_size(rtype) * G_window_cols());
     }
 
     return tmpbuf;
@@ -37,7 +37,7 @@ void *write_raster(void *buf, const int fd, const RASTER_MAP_TYPE rtype)
 
 	Rast_put_raster_row(fd, tmpbuf, rtype);
 	tmpbuf =
-	    Rast_incr_void_ptr(tmpbuf, Rast_raster_size(rtype) * G_window_cols());
+	    G_incr_void_ptr(tmpbuf, Rast_raster_size(rtype) * G_window_cols());
     }
 
     return tmpbuf;

raster/r.cost/main.c

@@ -443,7 +443,7 @@ int main(int argc, char *argv[])
 			p = *(int *)ptr2;
 		    }
 		    segment_put(&in_seg, &p, row, i);
-		    ptr2 = Rast_incr_void_ptr(ptr2, dsize);
+		    ptr2 = G_incr_void_ptr(ptr2, dsize);
 		}
 		break;
 	    case FCELL_TYPE:
@@ -455,7 +455,7 @@ int main(int argc, char *argv[])
 			p = *(float *)ptr2;
 		    }
 		    segment_put(&in_seg, &p, row, i);
-		    ptr2 = Rast_incr_void_ptr(ptr2, dsize);
+		    ptr2 = G_incr_void_ptr(ptr2, dsize);
 		}
 		break;
 
@@ -468,7 +468,7 @@ int main(int argc, char *argv[])
 			p = *(double *)ptr2;
 		    }
 		    segment_put(&in_seg, &p, row, i);
-		    ptr2 = Rast_incr_void_ptr(ptr2, dsize);
+		    ptr2 = G_incr_void_ptr(ptr2, dsize);
 		}
 		break;
 	    }
@@ -670,7 +670,7 @@ int main(int argc, char *argv[])
 		    }
 		    got_one = 1;
 		}
-		ptr2 = Rast_incr_void_ptr(ptr2, dsize2);
+		ptr2 = G_incr_void_ptr(ptr2, dsize2);
 	    }
 	}
 	G_percent(1, 1, 2);

raster/r.in.ascii/main.c

@@ -226,7 +226,7 @@ int main(int argc, char *argv[])
 	    else {
 		Rast_set_null_value(rast_ptr, 1, data_type);
 	    }
-	    rast_ptr = Rast_incr_void_ptr(rast_ptr, Rast_raster_size(data_type));
+	    rast_ptr = G_incr_void_ptr(rast_ptr, Rast_raster_size(data_type));
 	}
 	fwrite(rast, Rast_raster_size(data_type), ncols, ft);
 	rast_ptr = rast;

raster/r.in.mat/main.c

@@ -424,7 +424,7 @@ int main(int argc, char *argv[])
 	for (col = 0; col < ncols; col++) {
 	    array_ptr = array_data;
 	    array_ptr =
-		Rast_incr_void_ptr(array_ptr,
+		G_incr_void_ptr(array_ptr,
 				(row +
 				 col * mrows) * Rast_raster_size(map_type));
 
@@ -453,7 +453,7 @@ int main(int argc, char *argv[])
 		}
 	    }
 	    rastline_ptr =
-		Rast_incr_void_ptr(rastline_ptr, Rast_raster_size(map_type));
+		G_incr_void_ptr(rastline_ptr, Rast_raster_size(map_type));
 	}
 
 #ifdef DEBUG
@@ -465,7 +465,7 @@ int main(int argc, char *argv[])
 	    else
 		fprintf(stderr, "+");
 	    rastline_ptr =
-		Rast_incr_void_ptr(rastline_ptr, Rast_raster_size(map_type));
+		G_incr_void_ptr(rastline_ptr, Rast_raster_size(map_type));
 	}
 	fprintf(stderr, "]\n");
 #endif

raster/r.in.xyz/main.c

@@ -691,7 +691,7 @@ int main(int argc, char *argv[])
 	    if (bin_index) {
 		ptr = index_array;
 		ptr =
-		    Rast_incr_void_ptr(ptr,
+		    G_incr_void_ptr(ptr,
 				    ((arr_row * cols) +
 				     arr_col) * Rast_raster_size(CELL_TYPE));
 
@@ -753,7 +753,7 @@ int main(int argc, char *argv[])
 		    min = Rast_get_raster_value_d(min_array + offset, rtype);
 		    max = Rast_get_raster_value_d(max_array + offset, rtype);
 		    Rast_set_raster_value_d(ptr, max - min, rtype);
-		    ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(rtype));
+		    ptr = G_incr_void_ptr(ptr, Rast_raster_size(rtype));
 		}
 		break;
 
@@ -770,7 +770,7 @@ int main(int argc, char *argv[])
 		    else
 			Rast_set_raster_value_d(ptr, (sum / n), rtype);
 
-		    ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(rtype));
+		    ptr = G_incr_void_ptr(ptr, Rast_raster_size(rtype));
 		}
 		break;
 
@@ -805,7 +805,7 @@ int main(int argc, char *argv[])
 						 rtype);
 
 		    }
-		    ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(rtype));
+		    ptr = G_incr_void_ptr(ptr, Rast_raster_size(rtype));
 		}
 		break;
 	    case METHOD_MEDIAN:	/* median, if only one point in cell we will use that */
@@ -853,7 +853,7 @@ int main(int argc, char *argv[])
 			    Rast_set_raster_value_d(ptr, z, rtype);
 			}
 		    }
-		    ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(rtype));
+		    ptr = G_incr_void_ptr(ptr, Rast_raster_size(rtype));
 		}
 		break;
 	    case METHOD_PERCENTILE:	/* rank = (pth*(n+1))/100; interpolate linearly */
@@ -897,7 +897,7 @@ int main(int argc, char *argv[])
 			z = (z + nodes[node_id].z) / 2;
 			Rast_set_raster_value_d(ptr, z, rtype);
 		    }
-		    ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(rtype));
+		    ptr = G_incr_void_ptr(ptr, Rast_raster_size(rtype));
 		}
 		break;
 	    case METHOD_SKEWNESS:	/* skewness = sum(xi-mean)^3/(N-1)*s^3 */
@@ -945,7 +945,7 @@ int main(int argc, char *argv[])
 			}
 			Rast_set_raster_value_d(ptr, skew, rtype);
 		    }
-		    ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(rtype));
+		    ptr = G_incr_void_ptr(ptr, Rast_raster_size(rtype));
 		}
 		break;
 	    case METHOD_TRIMMEAN:
@@ -1002,7 +1002,7 @@ int main(int argc, char *argv[])
 			}
 			Rast_set_raster_value_d(ptr, mean, rtype);
 		    }
-		    ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(rtype));
+		    ptr = G_incr_void_ptr(ptr, Rast_raster_size(rtype));
 		}
 		break;
 

raster/r.in.xyz/support.c

@@ -15,7 +15,7 @@
 static void *get_cell_ptr(void *array, int cols, int row, int col,
 			  RASTER_MAP_TYPE map_type)
 {
-    return Rast_incr_void_ptr(array,
+    return G_incr_void_ptr(array,
 			   ((row * (size_t) cols) +
 			    col) * Rast_raster_size(map_type));
 }
@@ -38,7 +38,7 @@ int blank_array(void *array, int nrows, int ncols, RASTER_MAP_TYPE map_type,
 	for (row = 0; row < nrows; row++) {
 	    for (col = 0; col < ncols; col++) {
 		Rast_set_raster_value_c(ptr, 0, map_type);
-		ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(map_type));
+		ptr = G_incr_void_ptr(ptr, Rast_raster_size(map_type));
 	    }
 	}
 	break;

raster/r.le/r.le.patch/trace.c

@@ -376,7 +376,7 @@ void cell_clip_drv(int col0, int row0, int ncols, int nrows, double **value,
 	    void *rast1, *rast2;
 
 	    rast1 = cor_cell_buf;
-	    rast2 = Rast_incr_void_ptr(rast1, Rast_raster_size(CELL_TYPE));
+	    rast2 = G_incr_void_ptr(rast1, Rast_raster_size(CELL_TYPE));
 	    while (Rast_next_cell_stat(rast1, &count, &stats))
 		Rast_set_raster_cat(rast1, rast2, Rast_get_raster_cat(rast1, &cats,
 								CELL_TYPE),
@@ -629,17 +629,17 @@ void cell_clip(DCELL ** buf, DCELL ** null_buf, int row0, int col0, int nrows,
 	case CELL_TYPE:
 	    rastptr = tmp;
 	    for (x = 0; x < col0; x++)
-		rastptr = Rast_incr_void_ptr(rastptr, Rast_raster_size(CELL_TYPE));
+		rastptr = G_incr_void_ptr(rastptr, Rast_raster_size(CELL_TYPE));
 	    break;
 	case FCELL_TYPE:
 	    rastptr = ftmp;
 	    for (x = 0; x < col0; x++)
-		rastptr = Rast_incr_void_ptr(rastptr, Rast_raster_size(FCELL_TYPE));
+		rastptr = G_incr_void_ptr(rastptr, Rast_raster_size(FCELL_TYPE));
 	    break;
 	case DCELL_TYPE:
 	    rastptr = dtmp;
 	    for (x = 0; x < col0; x++)
-		rastptr = Rast_incr_void_ptr(rastptr, Rast_raster_size(DCELL_TYPE));
+		rastptr = G_incr_void_ptr(rastptr, Rast_raster_size(DCELL_TYPE));
 	    break;
 	}
 
@@ -667,7 +667,7 @@ void cell_clip(DCELL ** buf, DCELL ** null_buf, int row0, int col0, int nrows,
 		    else
 			*(*(null_buf + i + 1 - row0) + j + 1 - col0) = 1.0;
 		}
-		rastptr = Rast_incr_void_ptr(rastptr, Rast_raster_size(CELL_TYPE));
+		rastptr = G_incr_void_ptr(rastptr, Rast_raster_size(CELL_TYPE));
 		break;
 
 	    case FCELL_TYPE:
@@ -683,7 +683,7 @@ void cell_clip(DCELL ** buf, DCELL ** null_buf, int row0, int col0, int nrows,
 		    else
 			*(*(null_buf + i + 1 - row0) + j + 1 - col0) = 1.0;
 		}
-		rastptr = Rast_incr_void_ptr(rastptr, Rast_raster_size(FCELL_TYPE));
+		rastptr = G_incr_void_ptr(rastptr, Rast_raster_size(FCELL_TYPE));
 		break;
 
 	    case DCELL_TYPE:
@@ -699,7 +699,7 @@ void cell_clip(DCELL ** buf, DCELL ** null_buf, int row0, int col0, int nrows,
 		    else
 			*(*(null_buf + i + 1 - row0) + j + 1 - col0) = 1.0;
 		}
-		rastptr = Rast_incr_void_ptr(rastptr, Rast_raster_size(CELL_TYPE));
+		rastptr = G_incr_void_ptr(rastptr, Rast_raster_size(CELL_TYPE));
 		break;
 	    }
 

raster/r.le/r.le.trace/main.c

@@ -631,17 +631,17 @@ void cell_clip(DCELL ** buf, DCELL ** null_buf, int row0, int col0, int nrows,
 	case CELL_TYPE:
 	    rastptr = tmp;
 	    for (x = 0; x < col0; x++)
-		rastptr = Rast_incr_void_ptr(rastptr, Rast_raster_size(CELL_TYPE));
+		rastptr = G_incr_void_ptr(rastptr, Rast_raster_size(CELL_TYPE));
 	    break;
 	case FCELL_TYPE:
 	    rastptr = ftmp;
 	    for (x = 0; x < col0; x++)
-		rastptr = Rast_incr_void_ptr(rastptr, Rast_raster_size(FCELL_TYPE));
+		rastptr = G_incr_void_ptr(rastptr, Rast_raster_size(FCELL_TYPE));
 	    break;
 	case DCELL_TYPE:
 	    rastptr = dtmp;
 	    for (x = 0; x < col0; x++)
-		rastptr = Rast_incr_void_ptr(rastptr, Rast_raster_size(DCELL_TYPE));
+		rastptr = G_incr_void_ptr(rastptr, Rast_raster_size(DCELL_TYPE));
 	    break;
 	}
 
@@ -664,7 +664,7 @@ void cell_clip(DCELL ** buf, DCELL ** null_buf, int row0, int col0, int nrows,
 		else {
 		    *(*(null_buf + i + 1 - row0) + j + 1 - col0) = 0.0;
 		}
-		rastptr = Rast_incr_void_ptr(rastptr, Rast_raster_size(CELL_TYPE));
+		rastptr = G_incr_void_ptr(rastptr, Rast_raster_size(CELL_TYPE));
 		break;
 
 	    case FCELL_TYPE:
@@ -676,7 +676,7 @@ void cell_clip(DCELL ** buf, DCELL ** null_buf, int row0, int col0, int nrows,
 		else {
 		    *(*(null_buf + i + 1 - row0) + j + 1 - col0) = 0.0;
 		}
-		rastptr = Rast_incr_void_ptr(rastptr, Rast_raster_size(FCELL_TYPE));
+		rastptr = G_incr_void_ptr(rastptr, Rast_raster_size(FCELL_TYPE));
 		break;
 
 	    case DCELL_TYPE:
@@ -688,7 +688,7 @@ void cell_clip(DCELL ** buf, DCELL ** null_buf, int row0, int col0, int nrows,
 		else {
 		    *(*(null_buf + i + 1 - row0) + j + 1 - col0) = 0.0;
 		}
-		rastptr = Rast_incr_void_ptr(rastptr, Rast_raster_size(CELL_TYPE));
+		rastptr = G_incr_void_ptr(rastptr, Rast_raster_size(CELL_TYPE));
 		break;
 	    }
 

raster/r.null/mask.c

@@ -35,7 +35,7 @@ int mask_raster_array(void *rast, int ncols,
 	    Rast_set_raster_value_d(rast, new_null, data_type);
 	if (mask_d_select(&x, &d_mask))
 	    Rast_set_null_value(rast, 1, data_type);
-	rast = Rast_incr_void_ptr(rast, Rast_raster_size(data_type));
+	rast = G_incr_void_ptr(rast, Rast_raster_size(data_type));
     }
 
     return 0;

raster/r.out.arc/main.c

@@ -178,7 +178,7 @@ int main(int argc, char *argv[])
 	   exit(EXIT_FAILURE);
 	 */
 	for (col = 0, ptr = raster; col < ncols; col++,
-	     ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(out_type))) {
+	     ptr = G_incr_void_ptr(ptr, Rast_raster_size(out_type))) {
 	    if (!Rast_is_null_value(ptr, out_type)) {
 		if (out_type == CELL_TYPE)
 		    fprintf(fp, "%d", *((CELL *) ptr));

raster/r.out.ascii/formspecific.c

@@ -42,7 +42,7 @@ int write_GRASS(int fd,
 	    return (row);
 
 	for (col = 0, ptr = raster; col < ncols; col++,
-	     ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(out_type))) {
+	     ptr = G_incr_void_ptr(ptr, Rast_raster_size(out_type))) {
 	    if (!Rast_is_null_value(ptr, out_type)) {
 		if (out_type == CELL_TYPE)
 		    fprintf(fp, "%d", *((CELL *) ptr));
@@ -96,7 +96,7 @@ int write_MODFLOW(int fd,
 
 	colcnt = 0;
 	for (col = 0, ptr = raster; col < ncols; col++,
-	     ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(out_type))) {
+	     ptr = G_incr_void_ptr(ptr, Rast_raster_size(out_type))) {
 	    if (out_type == CELL_TYPE) {
 		if (Rast_is_null_value(ptr, out_type))
 		    *((CELL *) ptr) = 0;
@@ -182,7 +182,7 @@ int write_GSGRID(int fd,
 
 	colcnt = 0;
 	for (col = 0, ptr = raster; col < ncols; col++,
-	     ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(out_type))) {
+	     ptr = G_incr_void_ptr(ptr, Rast_raster_size(out_type))) {
 	    colcnt += 1;
 	    if (!Rast_is_null_value(ptr, out_type)) {
 		if (out_type == CELL_TYPE)

raster/r.out.bin/main.c

@@ -337,7 +337,7 @@ int main(int argc, char *argv[])
 	G_percent(row, nrows, 2);
 
 	for (col = 0, ptr = raster; col < ncols; col++,
-	     ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(out_type))) {
+	     ptr = G_incr_void_ptr(ptr, Rast_raster_size(out_type))) {
 	    if (!Rast_is_null_value(ptr, out_type)) {
 		if (out_type == CELL_TYPE) {
 		    number_i = *((CELL *) ptr);

raster/r.out.mat/main.c

@@ -307,7 +307,7 @@ int main(int argc, char *argv[])
     /* load entire map into memory */
     for (row = 0, ptr = raster; row < mrows; row++,
 	 ptr =
-	 Rast_incr_void_ptr(ptr,
+	 G_incr_void_ptr(ptr,
 			 (G_window_cols() + 1) * Rast_raster_size(map_type))) {
 	if (Rast_get_raster_row(fd, ptr, row, map_type) < 0)
 	    G_fatal_error("reading map");
@@ -325,7 +325,7 @@ int main(int argc, char *argv[])
 
 	    ptr = raster;
 	    ptr =
-		Rast_incr_void_ptr(ptr,
+		G_incr_void_ptr(ptr,
 				(col +
 				 row * (ncols +
 					1)) * Rast_raster_size(map_type));

raster/r.out.vtk/writeascii.c

@@ -190,7 +190,7 @@ write_vtk_structured_coordinates(int fd, FILE * fp, char *varname,
 	nspos -= y_extent;
 
 	for (col = 0, ptr = raster; col < ncols;
-	     col++, ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(out_type))) {
+	     col++, ptr = G_incr_void_ptr(ptr, Rast_raster_size(out_type))) {
 	    ewpos =
 		region.ew_res / 2 + region.west + colcount * region.ew_res;
 	    ewpos -= x_extent;
@@ -251,7 +251,7 @@ write_vtk_polygonal_coordinates(int fd, FILE * fp, char *varname,
 	nspos -= y_extent;
 
 	for (col = 0, ptr = raster; col < ncols;
-	     col++, ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(out_type))) {
+	     col++, ptr = G_incr_void_ptr(ptr, Rast_raster_size(out_type))) {
 	    ewpos =
 		region.ew_res / 2 + region.west + colcount * region.ew_res;
 	    ewpos -= x_extent;
@@ -360,7 +360,7 @@ write_vtk_data(int fd, FILE * fp, char *varname, struct Cell_head region,
 	}
 
 	for (col = 0, ptr = raster; col < ncols;
-	     col++, ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(out_type))) {
+	     col++, ptr = G_incr_void_ptr(ptr, Rast_raster_size(out_type))) {
 
 	    value = get_raster_value_as_double(out_type, ptr, nullvalue);
 	    fprintf(fp, "%.*f ", dp, value);
@@ -417,9 +417,9 @@ write_vtk_rgb_image_data(int redfd, int greenfd, int bluefd, FILE * fp,
 	for (col = 0, redptr = redraster, greenptr = greenraster, blueptr =
 	     blueraster; col < ncols;
 	     col++, redptr =
-	     Rast_incr_void_ptr(redptr, Rast_raster_size(out_type)), greenptr =
-	     Rast_incr_void_ptr(greenptr, Rast_raster_size(out_type)), blueptr =
-	     Rast_incr_void_ptr(blueptr, Rast_raster_size(out_type))) {
+	     G_incr_void_ptr(redptr, Rast_raster_size(out_type)), greenptr =
+	     G_incr_void_ptr(greenptr, Rast_raster_size(out_type)), blueptr =
+	     G_incr_void_ptr(blueptr, Rast_raster_size(out_type))) {
 
 	    r = get_raster_value_as_double(out_type, redptr, 0.0);
 	    g = get_raster_value_as_double(out_type, greenptr, 0.0);
@@ -484,9 +484,9 @@ write_vtk_vector_data(int xfd, int yfd, int zfd, FILE * fp,
 	for (col = 0, xptr = xraster, yptr = yraster, zptr =
 	     zraster; col < ncols;
 	     col++, xptr =
-	     Rast_incr_void_ptr(xptr, Rast_raster_size(out_type)), yptr =
-	     Rast_incr_void_ptr(yptr, Rast_raster_size(out_type)), zptr =
-	     Rast_incr_void_ptr(zptr, Rast_raster_size(out_type))) {
+	     G_incr_void_ptr(xptr, Rast_raster_size(out_type)), yptr =
+	     G_incr_void_ptr(yptr, Rast_raster_size(out_type)), zptr =
+	     G_incr_void_ptr(zptr, Rast_raster_size(out_type))) {
 
 	    x = get_raster_value_as_double(out_type, xptr, 0.0);
 	    y = get_raster_value_as_double(out_type, yptr, 0.0);

raster/r.patch/do_patch.c

@@ -56,8 +56,8 @@ int do_patch(void *result, void *patch,
 		}
 	    }			/* NULL support */
 	}
-	result = Rast_incr_void_ptr(result, Rast_raster_size(out_type));
-	patch = Rast_incr_void_ptr(patch, Rast_raster_size(out_type));
+	result = G_incr_void_ptr(result, Rast_raster_size(out_type));
+	patch = G_incr_void_ptr(patch, Rast_raster_size(out_type));
     }
     return more;
 }

raster/r.proj/main.c

@@ -432,7 +432,7 @@ int main(int argc, char **argv)
 			    &col_idx, &row_idx, &incellhd);
 	    }
 
-	    obufptr = Rast_incr_void_ptr(obufptr, cell_size);
+	    obufptr = G_incr_void_ptr(obufptr, cell_size);
 	    xcoord2 += outcellhd.ew_res;
 	    xcoord1 = xcoord2;
 	    ycoord1 = ycoord2;

raster/r.resample/main.c

@@ -140,7 +140,7 @@ int main(int argc, char *argv[])
 	void *rast1, *rast2;
 
 	rast1 = rast;
-	rast2 = Rast_incr_void_ptr(rast, Rast_raster_size(data_type));
+	rast2 = G_incr_void_ptr(rast, Rast_raster_size(data_type));
 
 	G_message(_("Creating new cats file..."));
 	while (Rast_get_next_marked_raster_cat(&cats,

raster/r.slope.aspect/main.c

@@ -629,14 +629,14 @@ int main(int argc, char *argv[])
 		asp_ptr = asp_raster;
 	    else
 		asp_ptr =
-		    Rast_incr_void_ptr(asp_raster, Rast_raster_size(data_type));
+		    G_incr_void_ptr(asp_raster, Rast_raster_size(data_type));
 	}
 	if (slope_fd >= 0) {
 	    if (Wrap)
 		slp_ptr = slp_raster;
 	    else
 		slp_ptr =
-		    Rast_incr_void_ptr(slp_raster, Rast_raster_size(data_type));
+		    G_incr_void_ptr(slp_raster, Rast_raster_size(data_type));
 	}
 
 	if (pcurv_fd >= 0) {
@@ -644,7 +644,7 @@ int main(int argc, char *argv[])
 		pcurv_ptr = pcurv_raster;
 	    else
 		pcurv_ptr =
-		    Rast_incr_void_ptr(pcurv_raster, Rast_raster_size(data_type));
+		    G_incr_void_ptr(pcurv_raster, Rast_raster_size(data_type));
 	}
 
 	if (tcurv_fd >= 0) {
@@ -652,21 +652,21 @@ int main(int argc, char *argv[])
 		tcurv_ptr = tcurv_raster;
 	    else
 		tcurv_ptr =
-		    Rast_incr_void_ptr(tcurv_raster, Rast_raster_size(data_type));
+		    G_incr_void_ptr(tcurv_raster, Rast_raster_size(data_type));
 	}
 
 	if (dx_fd >= 0) {
 	    if (Wrap)
 		dx_ptr = dx_raster;
 	    else
-		dx_ptr = Rast_incr_void_ptr(dx_raster, Rast_raster_size(data_type));
+		dx_ptr = G_incr_void_ptr(dx_raster, Rast_raster_size(data_type));
 	}
 
 	if (dy_fd >= 0) {
 	    if (Wrap)
 		dy_ptr = dy_raster;
 	    else
-		dy_ptr = Rast_incr_void_ptr(dy_raster, Rast_raster_size(data_type));
+		dy_ptr = G_incr_void_ptr(dy_raster, Rast_raster_size(data_type));
 	}
 
 	if (dxx_fd >= 0) {
@@ -674,7 +674,7 @@ int main(int argc, char *argv[])
 		dxx_ptr = dxx_raster;
 	    else
 		dxx_ptr =
-		    Rast_incr_void_ptr(dxx_raster, Rast_raster_size(data_type));
+		    G_incr_void_ptr(dxx_raster, Rast_raster_size(data_type));
 	}
 
 	if (dyy_fd >= 0) {
@@ -682,7 +682,7 @@ int main(int argc, char *argv[])
 		dyy_ptr = dyy_raster;
 	    else
 		dyy_ptr =
-		    Rast_incr_void_ptr(dyy_raster, Rast_raster_size(data_type));
+		    G_incr_void_ptr(dyy_raster, Rast_raster_size(data_type));
 	}
 
 	if (dxy_fd >= 0) {
@@ -690,7 +690,7 @@ int main(int argc, char *argv[])
 		dxy_ptr = dxy_raster;
 	    else
 		dxy_ptr =
-		    Rast_incr_void_ptr(dxy_raster, Rast_raster_size(data_type));
+		    G_incr_void_ptr(dxy_raster, Rast_raster_size(data_type));
 	}
 
 
@@ -711,47 +711,47 @@ int main(int argc, char *argv[])
 		if (slope_fd > 0) {
 		    Rast_set_null_value(slp_ptr, 1, data_type);
 		    slp_ptr =
-			Rast_incr_void_ptr(slp_ptr, Rast_raster_size(data_type));
+			G_incr_void_ptr(slp_ptr, Rast_raster_size(data_type));
 		}
 		if (aspect_fd > 0) {
 		    Rast_set_null_value(asp_ptr, 1, data_type);
 		    asp_ptr =
-			Rast_incr_void_ptr(asp_ptr, Rast_raster_size(data_type));
+			G_incr_void_ptr(asp_ptr, Rast_raster_size(data_type));
 		}
 		if (pcurv_fd > 0) {
 		    Rast_set_null_value(pcurv_ptr, 1, data_type);
 		    pcurv_ptr =
-			Rast_incr_void_ptr(pcurv_ptr, Rast_raster_size(data_type));
+			G_incr_void_ptr(pcurv_ptr, Rast_raster_size(data_type));
 		}
 		if (tcurv_fd > 0) {
 		    Rast_set_null_value(tcurv_ptr, 1, data_type);
 		    tcurv_ptr =
-			Rast_incr_void_ptr(tcurv_ptr, Rast_raster_size(data_type));
+			G_incr_void_ptr(tcurv_ptr, Rast_raster_size(data_type));
 		}
 		if (dx_fd > 0) {
 		    Rast_set_null_value(dx_ptr, 1, data_type);
 		    dx_ptr =
-			Rast_incr_void_ptr(dx_ptr, Rast_raster_size(data_type));
+			G_incr_void_ptr(dx_ptr, Rast_raster_size(data_type));
 		}
 		if (dy_fd > 0) {
 		    Rast_set_null_value(dy_ptr, 1, data_type);
 		    dy_ptr =
-			Rast_incr_void_ptr(dy_ptr, Rast_raster_size(data_type));
+			G_incr_void_ptr(dy_ptr, Rast_raster_size(data_type));
 		}
 		if (dxx_fd > 0) {
 		    Rast_set_null_value(dxx_ptr, 1, data_type);
 		    dxx_ptr =
-			Rast_incr_void_ptr(dxx_ptr, Rast_raster_size(data_type));
+			G_incr_void_ptr(dxx_ptr, Rast_raster_size(data_type));
 		}
 		if (dyy_fd > 0) {
 		    Rast_set_null_value(dyy_ptr, 1, data_type);
 		    dyy_ptr =
-			Rast_incr_void_ptr(dyy_ptr, Rast_raster_size(data_type));
+			G_incr_void_ptr(dyy_ptr, Rast_raster_size(data_type));
 		}
 		if (dxy_fd > 0) {
 		    Rast_set_null_value(dxy_ptr, 1, data_type);
 		    dxy_ptr =
-			Rast_incr_void_ptr(dxy_ptr, Rast_raster_size(data_type));
+			G_incr_void_ptr(dxy_ptr, Rast_raster_size(data_type));
 		}
 		continue;
 	    }			/* no data */
@@ -816,7 +816,7 @@ int main(int argc, char *argv[])
 			Rast_set_raster_value_d(slp_ptr,
 					     (DCELL) slp_in_perc, data_type);
 		}
-		slp_ptr = Rast_incr_void_ptr(slp_ptr, Rast_raster_size(data_type));
+		slp_ptr = G_incr_void_ptr(slp_ptr, Rast_raster_size(data_type));
 	    }			/* computing slope */
 
 	    if (aspect_fd > 0) {
@@ -848,7 +848,7 @@ int main(int argc, char *argv[])
 		}
 		else
 		    Rast_set_null_value(asp_ptr, 1, data_type);
-		asp_ptr = Rast_incr_void_ptr(asp_ptr, Rast_raster_size(data_type));
+		asp_ptr = G_incr_void_ptr(asp_ptr, Rast_raster_size(data_type));
 
 		/* now update min and max */
 		if (min_asp > aspect)
@@ -862,7 +862,7 @@ int main(int argc, char *argv[])
 		    *((CELL *) dx_ptr) = (CELL) (scik1 * dx);
 		else
 		    Rast_set_raster_value_d(dx_ptr, (DCELL) dx, data_type);
-		dx_ptr = Rast_incr_void_ptr(dx_ptr, Rast_raster_size(data_type));
+		dx_ptr = G_incr_void_ptr(dx_ptr, Rast_raster_size(data_type));
 	    }
 
 	    if (dy_fd > 0) {
@@ -870,7 +870,7 @@ int main(int argc, char *argv[])
 		    *((CELL *) dy_ptr) = (CELL) (scik1 * dy);
 		else
 		    Rast_set_raster_value_d(dy_ptr, (DCELL) dy, data_type);
-		dy_ptr = Rast_incr_void_ptr(dy_ptr, Rast_raster_size(data_type));
+		dy_ptr = G_incr_void_ptr(dy_ptr, Rast_raster_size(data_type));
 	    }
 
 	    if (dxx_fd <= 0 && dxy_fd <= 0 && dyy_fd <= 0 &&
@@ -892,7 +892,7 @@ int main(int argc, char *argv[])
 		    *((CELL *) dxx_ptr) = (CELL) (scik1 * dxx);
 		else
 		    Rast_set_raster_value_d(dxx_ptr, (DCELL) dxx, data_type);
-		dxx_ptr = Rast_incr_void_ptr(dxx_ptr, Rast_raster_size(data_type));
+		dxx_ptr = G_incr_void_ptr(dxx_ptr, Rast_raster_size(data_type));
 	    }
 
 	    if (dyy_fd > 0) {
@@ -900,7 +900,7 @@ int main(int argc, char *argv[])
 		    *((CELL *) dyy_ptr) = (CELL) (scik1 * dyy);
 		else
 		    Rast_set_raster_value_d(dyy_ptr, (DCELL) dyy, data_type);
-		dyy_ptr = Rast_incr_void_ptr(dyy_ptr, Rast_raster_size(data_type));
+		dyy_ptr = G_incr_void_ptr(dyy_ptr, Rast_raster_size(data_type));
 	    }
 
 	    if (dxy_fd > 0) {
@@ -908,7 +908,7 @@ int main(int argc, char *argv[])
 		    *((CELL *) dxy_ptr) = (CELL) (scik1 * dxy);
 		else
 		    Rast_set_raster_value_d(dxy_ptr, (DCELL) dxy, data_type);
-		dxy_ptr = Rast_incr_void_ptr(dxy_ptr, Rast_raster_size(data_type));
+		dxy_ptr = G_incr_void_ptr(dxy_ptr, Rast_raster_size(data_type));
 	    }
 
 	    /* compute curvature */
@@ -945,7 +945,7 @@ int main(int argc, char *argv[])
 		else
 		    Rast_set_raster_value_d(pcurv_ptr, (DCELL) pcurv, data_type);
 		pcurv_ptr =
-		    Rast_incr_void_ptr(pcurv_ptr, Rast_raster_size(data_type));
+		    G_incr_void_ptr(pcurv_ptr, Rast_raster_size(data_type));
 	    }
 
 	    if (tcurv_fd > 0) {
@@ -954,7 +954,7 @@ int main(int argc, char *argv[])
 		else
 		    Rast_set_raster_value_d(tcurv_ptr, (DCELL) tcurv, data_type);
 		tcurv_ptr =
-		    Rast_incr_void_ptr(tcurv_ptr, Rast_raster_size(data_type));
+		    G_incr_void_ptr(tcurv_ptr, Rast_raster_size(data_type));
 	    }
 
 	}			/* column for loop */

raster/r.stats/raw_stats.c

@@ -63,7 +63,7 @@ int raw_stats(int fd[], int with_coordinates, int with_xy, int with_labels)
 
 		if ((nulls_found == nfiles) || (nulls_found && no_nulls)) {
 		    for (i = 0; i < nfiles; i++)
-			rastp[i] = Rast_incr_void_ptr(rastp[i],
+			rastp[i] = G_incr_void_ptr(rastp[i],
 						   Rast_raster_size(map_type
 								 [i]));
 		    continue;
@@ -103,7 +103,7 @@ int raw_stats(int fd[], int with_coordinates, int with_xy, int with_labels)
 						   &labels[i]));
 		}
 		rastp[i] =
-		    Rast_incr_void_ptr(rastp[i], Rast_raster_size(map_type[i]));
+		    G_incr_void_ptr(rastp[i], Rast_raster_size(map_type[i]));
 	    }
 	    fprintf(stdout, "\n");
 	}

raster/r.to.rast3/main.c

@@ -119,7 +119,7 @@ void raster_to_g3d(void *map, G3D_Region region, int *fd)
 
 	    for (x = 0, ptr = rast; x < cols; x++,
 		 ptr =
-		 Rast_incr_void_ptr(ptr, Rast_raster_size(globalRastMapType))) {
+		 G_incr_void_ptr(ptr, Rast_raster_size(globalRastMapType))) {
 		if (globalRastMapType == CELL_TYPE) {
 		    if (Rast_is_null_value(ptr, globalRastMapType)) {
 			G3d_setNullValue(&dvalue, 1, DCELL_TYPE);

raster/r.to.rast3elev/main.c

@@ -238,9 +238,9 @@ void elev_raster_to_g3d(Database db, G3D_Region region)
 
 	for (x = 0, input_ptr = input_rast, elev_ptr = elev_rast; x < cols;
 	     x++, input_ptr =
-	     Rast_incr_void_ptr(input_ptr, Rast_raster_size(db.inputmaptype)),
+	     G_incr_void_ptr(input_ptr, Rast_raster_size(db.inputmaptype)),
 	     elev_ptr =
-	     Rast_incr_void_ptr(elev_ptr, Rast_raster_size(db.elevmaptype))) {
+	     G_incr_void_ptr(elev_ptr, Rast_raster_size(db.elevmaptype))) {
 
 	    /*Get the elevation and the input map value */
 	    inval =

raster/r.to.vect/areas.c

@@ -100,7 +100,7 @@ static int update_width(struct area_table *, int);
 static int nabors(void);
 
 #define get_raster_value(ptr, col) \
-	Rast_get_raster_value_d(Rast_incr_void_ptr(ptr, (col)*data_size), data_type)
+	Rast_get_raster_value_d(G_incr_void_ptr(ptr, (col)*data_size), data_type)
 
 /* extract_areas - trace boundaries of polygons in file */
 

raster/r.univar/r.univar_main.c

@@ -197,14 +197,14 @@ process_raster(univar_stat * stats, int fd, const struct Cell_head *region)
 	for (col = 0; col < cols; col++) {
 
 	    if (Rast_is_null_value(ptr, map_type)) {
-		ptr = Rast_incr_void_ptr(ptr, value_sz);
+		ptr = G_incr_void_ptr(ptr, value_sz);
 		continue;
 	    }
 
 	    if (nextp) {
 		/* put the value into stats->XXXcell_array */
 		memcpy(nextp, ptr, value_sz);
-		nextp = Rast_incr_void_ptr(nextp, value_sz);
+		nextp = G_incr_void_ptr(nextp, value_sz);
 	    }
 
 	    {
@@ -229,7 +229,7 @@ process_raster(univar_stat * stats, int fd, const struct Cell_head *region)
 		}
 	    }
 
-	    ptr = Rast_incr_void_ptr(ptr, value_sz);
+	    ptr = G_incr_void_ptr(ptr, value_sz);
 	    stats->n++;
 	}
 	if (!(param.shell_style->answer))

raster/r.walk/main.c

@@ -722,7 +722,7 @@ int main(int argc, char *argv[])
 			p = *(int *)ptr2;
 		    }
 		    segment_put(&dtm_in_seg, &p, row, i);
-		    ptr2 = Rast_incr_void_ptr(ptr2, dtm_dsize);
+		    ptr2 = G_incr_void_ptr(ptr2, dtm_dsize);
 		}
 		break;
 	    case FCELL_TYPE:
@@ -734,7 +734,7 @@ int main(int argc, char *argv[])
 			p = *(float *)ptr2;
 		    }
 		    segment_put(&dtm_in_seg, &p, row, i);
-		    ptr2 = Rast_incr_void_ptr(ptr2, dtm_dsize);
+		    ptr2 = G_incr_void_ptr(ptr2, dtm_dsize);
 		}
 		break;
 
@@ -747,7 +747,7 @@ int main(int argc, char *argv[])
 			p = *(double *)ptr2;
 		    }
 		    segment_put(&dtm_in_seg, &p, row, i);
-		    ptr2 = Rast_incr_void_ptr(ptr2, dtm_dsize);
+		    ptr2 = G_incr_void_ptr(ptr2, dtm_dsize);
 		}
 		break;
 	    }
@@ -781,7 +781,7 @@ int main(int argc, char *argv[])
 			p = *(int *)ptr2;
 		    }
 		    segment_put(&cost_in_seg, &p, row, i);
-		    ptr2 = Rast_incr_void_ptr(ptr2, cost_dsize);
+		    ptr2 = G_incr_void_ptr(ptr2, cost_dsize);
 		}
 		break;
 	    case FCELL_TYPE:
@@ -793,7 +793,7 @@ int main(int argc, char *argv[])
 			p = *(float *)ptr2;
 		    }
 		    segment_put(&cost_in_seg, &p, row, i);
-		    ptr2 = Rast_incr_void_ptr(ptr2, cost_dsize);
+		    ptr2 = G_incr_void_ptr(ptr2, cost_dsize);
 		}
 		break;
 
@@ -806,7 +806,7 @@ int main(int argc, char *argv[])
 			p = *(double *)ptr2;
 		    }
 		    segment_put(&cost_in_seg, &p, row, i);
-		    ptr2 = Rast_incr_void_ptr(ptr2, cost_dsize);
+		    ptr2 = G_incr_void_ptr(ptr2, cost_dsize);
 		}
 		break;
 	    }
@@ -919,7 +919,7 @@ int main(int argc, char *argv[])
 			segment_put(&out_seg, value_start_pt, row, col);
 		    }
 		}
-		ptr2 = Rast_incr_void_ptr(ptr2, dsize2);
+		ptr2 = G_incr_void_ptr(ptr2, dsize2);
 	    }
 	}
 

raster/r.watershed/ram/init_vars.c

@@ -192,7 +192,7 @@ int init_vars(int argc, char *argv[])
 	    if (er_flag) {
 		r_h[index] = alt_value;
 	    }
-	    ptr = Rast_incr_void_ptr(ptr, ele_size);
+	    ptr = G_incr_void_ptr(ptr, ele_size);
 	}
     }
     Rast_close_cell(fd);

raster/r.watershed/seg/init_vars.c

@@ -233,7 +233,7 @@ int init_vars(int argc, char *argv[])
 	    if (er_flag) {
 		cseg_put(&r_h, &alt_value, r, c);
 	    }
-	    ptr = Rast_incr_void_ptr(ptr, ele_size);
+	    ptr = G_incr_void_ptr(ptr, ele_size);
 	}
     }
     Rast_close_cell(fd);

raster3d/r3.cross.rast/main.c

@@ -163,7 +163,7 @@ void rast3d_cross_section(void *map, G3D_Region region, int elevfd, int outfd)
 			_("Unable to get elevation raster row"));
 
 	for (x = 0, ptr = elevrast; x < cols; x++, ptr =
-	     Rast_incr_void_ptr(ptr, Rast_raster_size(globalElevMapType))) {
+	     G_incr_void_ptr(ptr, Rast_raster_size(globalElevMapType))) {
 
 	    /*we guess the elevation input map has no null values */
 	    isnull = 0;

raster3d/r3.out.vtk/writeVTKData.c

@@ -138,9 +138,9 @@ void write_vtk_points(input_maps * in, FILE * fp, G3D_Region region, int dp,
 	    for (x = 0, ptr_top = rast_top, ptr_bottom = rast_bottom;
 		 x < cols;
 		 x++, ptr_top =
-		 Rast_incr_void_ptr(ptr_top, Rast_raster_size(in->topMapType)),
+		 G_incr_void_ptr(ptr_top, Rast_raster_size(in->topMapType)),
 		 ptr_bottom =
-		 Rast_incr_void_ptr(ptr_bottom,
+		 G_incr_void_ptr(ptr_bottom,
 				 Rast_raster_size(in->bottomMapType))) {
 
 		/*Get the values */

swig/perl/R_slope_aspect/r_slope_aspect/r_slope_aspect.c

@@ -656,14 +656,14 @@ int r_slope_aspect(int argc, char *argv[])
 		asp_ptr = asp_raster;
 	    else
 		asp_ptr =
-		    Rast_incr_void_ptr(asp_raster, Rast_raster_size(data_type));
+		    G_incr_void_ptr(asp_raster, Rast_raster_size(data_type));
 	}
 	if (slope_fd >= 0) {
 	    if (Wrap)
 		slp_ptr = slp_raster;
 	    else
 		slp_ptr =
-		    Rast_incr_void_ptr(slp_raster, Rast_raster_size(data_type));
+		    G_incr_void_ptr(slp_raster, Rast_raster_size(data_type));
 	}
 
 	if (pcurv_fd >= 0) {
@@ -671,7 +671,7 @@ int r_slope_aspect(int argc, char *argv[])
 		pcurv_ptr = pcurv_raster;
 	    else
 		pcurv_ptr =
-		    Rast_incr_void_ptr(pcurv_raster, Rast_raster_size(data_type));
+		    G_incr_void_ptr(pcurv_raster, Rast_raster_size(data_type));
 	}
 
 	if (tcurv_fd >= 0) {
@@ -679,21 +679,21 @@ int r_slope_aspect(int argc, char *argv[])
 		tcurv_ptr = tcurv_raster;
 	    else
 		tcurv_ptr =
-		    Rast_incr_void_ptr(tcurv_raster, Rast_raster_size(data_type));
+		    G_incr_void_ptr(tcurv_raster, Rast_raster_size(data_type));
 	}
 
 	if (dx_fd >= 0) {
 	    if (Wrap)
 		dx_ptr = dx_raster;
 	    else
-		dx_ptr = Rast_incr_void_ptr(dx_raster, Rast_raster_size(data_type));
+		dx_ptr = G_incr_void_ptr(dx_raster, Rast_raster_size(data_type));
 	}
 
 	if (dy_fd >= 0) {
 	    if (Wrap)
 		dy_ptr = dy_raster;
 	    else
-		dy_ptr = Rast_incr_void_ptr(dy_raster, Rast_raster_size(data_type));
+		dy_ptr = G_incr_void_ptr(dy_raster, Rast_raster_size(data_type));
 	}
 
 	if (dxx_fd >= 0) {
@@ -701,7 +701,7 @@ int r_slope_aspect(int argc, char *argv[])
 		dxx_ptr = dxx_raster;
 	    else
 		dxx_ptr =
-		    Rast_incr_void_ptr(dxx_raster, Rast_raster_size(data_type));
+		    G_incr_void_ptr(dxx_raster, Rast_raster_size(data_type));
 	}
 
 	if (dyy_fd >= 0) {
@@ -709,7 +709,7 @@ int r_slope_aspect(int argc, char *argv[])
 		dyy_ptr = dyy_raster;
 	    else
 		dyy_ptr =
-		    Rast_incr_void_ptr(dyy_raster, Rast_raster_size(data_type));
+		    G_incr_void_ptr(dyy_raster, Rast_raster_size(data_type));
 	}
 
 	if (dxy_fd >= 0) {
@@ -717,7 +717,7 @@ int r_slope_aspect(int argc, char *argv[])
 		dxy_ptr = dxy_raster;
 	    else
 		dxy_ptr =
-		    Rast_incr_void_ptr(dxy_raster, Rast_raster_size(data_type));
+		    G_incr_void_ptr(dxy_raster, Rast_raster_size(data_type));
 	}
 
 
@@ -738,47 +738,47 @@ int r_slope_aspect(int argc, char *argv[])
 		if (slope_fd > 0) {
 		    Rast_set_null_value(slp_ptr, 1, data_type);
 		    slp_ptr =
-			Rast_incr_void_ptr(slp_ptr, Rast_raster_size(data_type));
+			G_incr_void_ptr(slp_ptr, Rast_raster_size(data_type));
 		}
 		if (aspect_fd > 0) {
 		    Rast_set_null_value(asp_ptr, 1, data_type);
 		    asp_ptr =
-			Rast_incr_void_ptr(asp_ptr, Rast_raster_size(data_type));
+			G_incr_void_ptr(asp_ptr, Rast_raster_size(data_type));
 		}
 		if (pcurv_fd > 0) {
 		    Rast_set_null_value(pcurv_ptr, 1, data_type);
 		    pcurv_ptr =
-			Rast_incr_void_ptr(pcurv_ptr, Rast_raster_size(data_type));
+			G_incr_void_ptr(pcurv_ptr, Rast_raster_size(data_type));
 		}
 		if (tcurv_fd > 0) {
 		    Rast_set_null_value(tcurv_ptr, 1, data_type);
 		    tcurv_ptr =
-			Rast_incr_void_ptr(tcurv_ptr, Rast_raster_size(data_type));
+			G_incr_void_ptr(tcurv_ptr, Rast_raster_size(data_type));
 		}
 		if (dx_fd > 0) {
 		    Rast_set_null_value(dx_ptr, 1, data_type);
 		    dx_ptr =
-			Rast_incr_void_ptr(dx_ptr, Rast_raster_size(data_type));
+			G_incr_void_ptr(dx_ptr, Rast_raster_size(data_type));
 		}
 		if (dy_fd > 0) {
 		    Rast_set_null_value(dy_ptr, 1, data_type);
 		    dy_ptr =
-			Rast_incr_void_ptr(dy_ptr, Rast_raster_size(data_type));
+			G_incr_void_ptr(dy_ptr, Rast_raster_size(data_type));
 		}
 		if (dxx_fd > 0) {
 		    Rast_set_null_value(dxx_ptr, 1, data_type);
 		    dxx_ptr =
-			Rast_incr_void_ptr(dxx_ptr, Rast_raster_size(data_type));
+			G_incr_void_ptr(dxx_ptr, Rast_raster_size(data_type));
 		}
 		if (dyy_fd > 0) {
 		    Rast_set_null_value(dyy_ptr, 1, data_type);
 		    dyy_ptr =
-			Rast_incr_void_ptr(dyy_ptr, Rast_raster_size(data_type));
+			G_incr_void_ptr(dyy_ptr, Rast_raster_size(data_type));
 		}
 		if (dxy_fd > 0) {
 		    Rast_set_null_value(dxy_ptr, 1, data_type);
 		    dxy_ptr =
-			Rast_incr_void_ptr(dxy_ptr, Rast_raster_size(data_type));
+			G_incr_void_ptr(dxy_ptr, Rast_raster_size(data_type));
 		}
 		continue;
 	    }			/* no data */
@@ -843,7 +843,7 @@ int r_slope_aspect(int argc, char *argv[])
 			Rast_set_raster_value_d(slp_ptr,
 					     (DCELL) slp_in_perc, data_type);
 		}
-		slp_ptr = Rast_incr_void_ptr(slp_ptr, Rast_raster_size(data_type));
+		slp_ptr = G_incr_void_ptr(slp_ptr, Rast_raster_size(data_type));
 	    }			/* computing slope */
 
 	    if (aspect_fd > 0) {
@@ -875,7 +875,7 @@ int r_slope_aspect(int argc, char *argv[])
 		}
 		else
 		    Rast_set_null_value(asp_ptr, 1, data_type);
-		asp_ptr = Rast_incr_void_ptr(asp_ptr, Rast_raster_size(data_type));
+		asp_ptr = G_incr_void_ptr(asp_ptr, Rast_raster_size(data_type));
 
 		/* now update min and max */
 		if (min_asp > aspect)
@@ -889,7 +889,7 @@ int r_slope_aspect(int argc, char *argv[])
 		    *((CELL *) dx_ptr) = (CELL) (scik1 * dx);
 		else
 		    Rast_set_raster_value_d(dx_ptr, (DCELL) dx, data_type);
-		dx_ptr = Rast_incr_void_ptr(dx_ptr, Rast_raster_size(data_type));
+		dx_ptr = G_incr_void_ptr(dx_ptr, Rast_raster_size(data_type));
 	    }
 
 	    if (dy_fd > 0) {
@@ -897,7 +897,7 @@ int r_slope_aspect(int argc, char *argv[])
 		    *((CELL *) dy_ptr) = (CELL) (scik1 * dy);
 		else
 		    Rast_set_raster_value_d(dy_ptr, (DCELL) dy, data_type);
-		dy_ptr = Rast_incr_void_ptr(dy_ptr, Rast_raster_size(data_type));
+		dy_ptr = G_incr_void_ptr(dy_ptr, Rast_raster_size(data_type));
 	    }
 
 	    if (dxx_fd <= 0 && dxy_fd <= 0 && dyy_fd <= 0 &&
@@ -919,7 +919,7 @@ int r_slope_aspect(int argc, char *argv[])
 		    *((CELL *) dxx_ptr) = (CELL) (scik1 * dxx);
 		else
 		    Rast_set_raster_value_d(dxx_ptr, (DCELL) dxx, data_type);
-		dxx_ptr = Rast_incr_void_ptr(dxx_ptr, Rast_raster_size(data_type));
+		dxx_ptr = G_incr_void_ptr(dxx_ptr, Rast_raster_size(data_type));
 	    }
 
 	    if (dyy_fd > 0) {
@@ -927,7 +927,7 @@ int r_slope_aspect(int argc, char *argv[])
 		    *((CELL *) dyy_ptr) = (CELL) (scik1 * dyy);
 		else
 		    Rast_set_raster_value_d(dyy_ptr, (DCELL) dyy, data_type);
-		dyy_ptr = Rast_incr_void_ptr(dyy_ptr, Rast_raster_size(data_type));
+		dyy_ptr = G_incr_void_ptr(dyy_ptr, Rast_raster_size(data_type));
 	    }
 
 	    if (dxy_fd > 0) {
@@ -935,7 +935,7 @@ int r_slope_aspect(int argc, char *argv[])
 		    *((CELL *) dxy_ptr) = (CELL) (scik1 * dxy);
 		else
 		    Rast_set_raster_value_d(dxy_ptr, (DCELL) dxy, data_type);
-		dxy_ptr = Rast_incr_void_ptr(dxy_ptr, Rast_raster_size(data_type));
+		dxy_ptr = G_incr_void_ptr(dxy_ptr, Rast_raster_size(data_type));
 	    }
 
 	    /* compute curvature */
@@ -972,7 +972,7 @@ int r_slope_aspect(int argc, char *argv[])
 		else
 		    Rast_set_raster_value_d(pcurv_ptr, (DCELL) pcurv, data_type);
 		pcurv_ptr =
-		    Rast_incr_void_ptr(pcurv_ptr, Rast_raster_size(data_type));
+		    G_incr_void_ptr(pcurv_ptr, Rast_raster_size(data_type));
 	    }
 
 	    if (tcurv_fd > 0) {
@@ -981,7 +981,7 @@ int r_slope_aspect(int argc, char *argv[])
 		else
 		    Rast_set_raster_value_d(tcurv_ptr, (DCELL) tcurv, data_type);
 		tcurv_ptr =
-		    Rast_incr_void_ptr(tcurv_ptr, Rast_raster_size(data_type));
+		    G_incr_void_ptr(tcurv_ptr, Rast_raster_size(data_type));
 	    }
 
 	}			/* column for loop */

vector/lidar/lidarlib/zones.c

@@ -282,7 +282,7 @@ void P_Aux_to_Raster(double **matrix, int fd)
 	Rast_set_d_null_value(raster, ncols);
 
 	for (col = 0, ptr = raster; col < ncols;
-	     col++, ptr = Rast_incr_void_ptr(ptr, Rast_raster_size(DCELL_TYPE))) {
+	     col++, ptr = G_incr_void_ptr(ptr, Rast_raster_size(DCELL_TYPE))) {
 	    Rast_set_raster_value_d(ptr, (DCELL) (matrix[row][col]), DCELL_TYPE);
 	}
 	Rast_put_d_raster_row(fd, raster);

vector/v.neighbors/main.c

@@ -138,7 +138,7 @@ int main(int argc, char *argv[])
 		value = count;
 		Rast_set_raster_value_d(rp, value, CELL_TYPE);
 	    }
-	    rp = Rast_incr_void_ptr(rp, Rast_raster_size(CELL_TYPE));
+	    rp = G_incr_void_ptr(rp, Rast_raster_size(CELL_TYPE));
 	}
 
 	Rast_put_raster_row(out_fd, result, CELL_TYPE);