r.surf.idw: fix SHORT overflow (OSGeo#6396)

Co-authored-by: @metzm

Author: neteler

raster/r.surf.idw/dist.c

@@ -23,14 +23,14 @@ static double t1r, t2r;
 #define DIST_PARAMS struct dist_params
 DIST_PARAMS
 {
-    short targetrow; /* interpolation row for which params apply */
+    int targetrow; /* interpolation row for which params apply */
     double t1, t2, t3, t4;
 };
 
 static DIST_PARAMS *lat_params, *nextcalc;
 
 /* must be called once to establish the ellipsoid */
-int G_begin_geodesic_distance_l(short nrows, double a, double e2)
+int G_begin_geodesic_distance_l(int nrows, double a, double e2)
 {
     int i;
 

raster/r.surf.idw/ll.c

@@ -9,7 +9,7 @@
 /*      by locating the two data closest to the specified column in     */
 /*      a linked list of row data                                       */
 
-int first_west_LL(EW *ewptr, SHORT col)
+int first_west_LL(EW *ewptr, int col)
 {
     if (ewptr->start == NULL) /* no data in this row */
         ewptr->walive = ewptr->ealive = FALSE;
@@ -31,7 +31,7 @@ int first_west_LL(EW *ewptr, SHORT col)
     return 0;
 }
 
-double offset_distance_LL(SHORT offset)
+double offset_distance_LL(int offset)
 {
     extern double *lat_diff;
 
@@ -46,13 +46,13 @@ int completed_row_LL(EW *ewptr)
     return (!ewptr->walive && !ewptr->ealive);
 }
 
-int find_neighbors_LL(EW *ewptr, NEIGHBOR *nbr_head, SHORT row, SHORT col,
-                      int npoints, SHORT *neighbors)
+int find_neighbors_LL(EW *ewptr, NEIGHBOR *nbr_head, int row, int col,
+                      int npoints, int *neighbors)
 {
     MELEMENT **Mptr;  /* double indirection !! */
     int westward = 1; /* 1 if west of interpolation point */
     double distance;
-    short *active; /* TRUE if active search in this direction */
+    int *active; /* TRUE if active search in this direction */
 
     active = &ewptr->walive; /* TRUE if searching west in this row */
     Mptr = &ewptr->west;     /* process search west first, then east */
@@ -84,7 +84,7 @@ int find_neighbors_LL(EW *ewptr, NEIGHBOR *nbr_head, SHORT row, SHORT col,
 /*      This function exhausts all possible nearest neighhbors          */
 /*      within the row indexed by the ew search pointer                 */
 
-int exhaust_search_LL(EW *ewptr, NEIGHBOR *nbr_head, SHORT row, SHORT col)
+int exhaust_search_LL(EW *ewptr, NEIGHBOR *nbr_head, int row, int col)
 {
     double distance;
 
@@ -129,7 +129,7 @@ int extend_east(EW *ewptr)
     return 0;
 }
 
-double distance_LL(SHORT row, SHORT col, MELEMENT *Mptr)
+double distance_LL(int row, int col, MELEMENT *Mptr)
 {
     extern double *rowlook, *collook;
 
@@ -142,13 +142,13 @@ double distance_LL(SHORT row, SHORT col, MELEMENT *Mptr)
 /*      Lookup tables storing pre-processed latitude and longitude data */
 /*      are created for later use in selecting nearest neighbors        */
 
-int LL_lookup_tables(SHORT nrows, SHORT ncols)
+int LL_lookup_tables(int nrows, int ncols)
 {
     extern double *rowlook, *collook, *lat_diff;
     extern struct Cell_head window;
     double *nextrow, *nextcol, *next_diff,
         lon = 0., lat = window.north - (0.5 * window.ns_res);
-    SHORT i;
+    int i;
 
     nextrow = rowlook = (double *)G_calloc(nrows, sizeof(double));
     for (i = 0; i < nrows; i++, nextrow++, lat -= window.ns_res)

raster/r.surf.idw/main.c

@@ -43,35 +43,35 @@ CELL *cell, *mask;
 double *rowlook, *collook, *lat_diff, /* distances between latitudes */
     ew2;
 
-short ll; /* TRUE if latitude-longitude projection */
+int ll; /* TRUE if latitude-longitude projection */
 
 /* function pointers for LL function substitutes */
 
-int first_west(EW *, SHORT);
-int first_west_LL(EW *, SHORT);
-int (*init_row_search)(EW *, SHORT); /* function pointer */
+int first_west(EW *, int);
+int first_west_LL(EW *, int);
+int (*init_row_search)(EW *, int); /* function pointer */
 
 int completed_row(EW *);
 int completed_row_LL(EW *);
 
 /* function pointer */
 int (*comp_row_search)(EW *);
 
-int find_neighbors(EW *, NEIGHBOR *, SHORT, SHORT, int, SHORT *);
-int find_neighbors_LL(EW *, NEIGHBOR *, SHORT, SHORT, int, SHORT *);
+int find_neighbors(EW *, NEIGHBOR *, int, int, int, int *);
+int find_neighbors_LL(EW *, NEIGHBOR *, int, int, int, int *);
 
 /* function pointer */
-int (*locate_neighbors)(EW *, NEIGHBOR *, SHORT, SHORT, int, SHORT *);
+int (*locate_neighbors)(EW *, NEIGHBOR *, int, int, int, int *);
 
-int exhaust_search(EW *, NEIGHBOR *, SHORT, SHORT);
-int exhaust_search_LL(EW *, NEIGHBOR *, SHORT, SHORT);
+int exhaust_search(EW *, NEIGHBOR *, int, int);
+int exhaust_search_LL(EW *, NEIGHBOR *, int, int);
 
 /* function pointer */
-int (*exhaust_row)(EW *, NEIGHBOR *, SHORT, SHORT);
+int (*exhaust_row)(EW *, NEIGHBOR *, int, int);
 
-double offset_distance(SHORT);
-double offset_distance_LL(SHORT);
-double (*check_offset)(SHORT); /* function pointer */
+double offset_distance(int);
+double offset_distance_LL(int);
+double (*check_offset)(int); /* function pointer */
 
 static int error_flag = 0;
 static char *input;
@@ -80,8 +80,8 @@ static char *output;
 int main(int argc, char **argv)
 {
     MELEMENT *rowlist;
-    SHORT nrows, ncols;
-    SHORT datarows;
+    int nrows, ncols;
+    int datarows;
     int npoints;
     struct GModule *module;
     struct History history;
@@ -199,7 +199,7 @@ int main(int argc, char **argv)
 /*      calculations depends on the projection type; function   */
 /*      pointers are set dependent on projection type           */
 
-int lookup_and_function_ptrs(SHORT nrows, SHORT ncols)
+int lookup_and_function_ptrs(int nrows, int ncols)
 {
     double a, e2; /* used to control geodetic distance calculations */
 
@@ -232,15 +232,15 @@ int lookup_and_function_ptrs(SHORT nrows, SHORT ncols)
 /*      a matrix by interpolating from a given set of           */
 /*      irregularly spaced data points                          */
 
-int interpolate(MELEMENT rowlist[], SHORT nrows, SHORT ncols, SHORT datarows,
+int interpolate(MELEMENT rowlist[], int nrows, int ncols, int datarows,
                 int npoints, int out_fd, int maskfd)
 {
     extern CELL *cell;
 
     MELEMENT *Rptr;
     EW *search, *ewptr, *current_row, /* start row for north/south search */
         *lastrow;                     /* last element in search array */
-    SHORT row, col;
+    int row, col;
     NEIGHBOR *nbr_head, *Nptr;
     double sum1, sum2;
 
@@ -325,13 +325,13 @@ int interpolate(MELEMENT rowlist[], SHORT nrows, SHORT ncols, SHORT datarows,
 /*      to be interpolated using data value of its neighbors    */
 
 int make_neighbors_list(
-    EW *firstrow, EW *lastrow, EW *curr_row, SHORT row, SHORT col,
+    EW *firstrow, EW *lastrow, EW *curr_row, int row, int col,
     NEIGHBOR *head, /* head points to dummy plus npoints neighbors */
     int npoints)
 {
     extern CELL *cell;
 
-    SHORT neighbors = 0,          /* number of neighbors in current list */
+    int neighbors = 0,            /* number of neighbors in current list */
         nsearch = 1, ssearch = 1; /* expand search north and south */
     EW *north, *south;
 
@@ -393,11 +393,11 @@ int make_neighbors_list(
 /******* END OF FUNCTION "MAKE_NEIGHBORS_LIST" ******************/
 
 int search(EW **ewptr, /* double-indirection !! */
-           NEIGHBOR *head, SHORT row, SHORT col, int npoints, SHORT *neighbors,
-           EW *boundary, SHORT south /* search proceeds southward if == 1 */
+           NEIGHBOR *head, int row, int col, int npoints, int *neighbors,
+           EW *boundary, int south /* search proceeds southward if == 1 */
 )
 {
-    SHORT new = 0; /* no prior search in first row in list */
+    int new = 0; /* no prior search in first row in list */
     EW *current, *prior;
 
     /* reset ewptr if row it points to has been thoroughly searched */
@@ -442,7 +442,7 @@ int search(EW **ewptr, /* double-indirection !! */
 }
 
 int exhaust(EW **ewptr, /* double-indirection !! */
-            NEIGHBOR *head, SHORT row, SHORT col)
+            NEIGHBOR *head, int row, int col)
 {
     EW *current;
 
@@ -469,7 +469,7 @@ int exhaust(EW **ewptr, /* double-indirection !! */
     return 0;
 }
 
-double offset_distance(SHORT offset)
+double offset_distance(int offset)
 {
     return (offset * offset); /* compare squared distances in this case */
 }
@@ -483,8 +483,8 @@ int completed_row(EW *ewptr)
 }
 
 EW *next_row(EW *ewptr,
-             EW *boundary, /* row boundary of map in search direction */
-             SHORT *new, SHORT south /* search proceeds southward if == 1 */
+             EW *boundary,       /* row boundary of map in search direction */
+             int *new, int south /* search proceeds southward if == 1 */
 )
 {
     if (ewptr->next)
@@ -505,7 +505,7 @@ EW *next_row(EW *ewptr,
 /*      by locating the two data closest to the specified column in     */
 /*      a linked list of row data                                       */
 
-int first_west(EW *ewptr, SHORT col)
+int first_west(EW *ewptr, int col)
 {
     if (ewptr->start == NULL) { /* no data in this row */
         ewptr->west = ewptr->east = NULL;
@@ -525,8 +525,8 @@ int first_west(EW *ewptr, SHORT col)
 /*      This function evaluates nearest neighbor status for a given     */
 /*      datum and resets the row search pointer based on the result     */
 
-int find_neighbors(EW *ewptr, NEIGHBOR *nbr_head, SHORT row, SHORT col,
-                   int npoints, SHORT *neighbors)
+int find_neighbors(EW *ewptr, NEIGHBOR *nbr_head, int row, int col, int npoints,
+                   int *neighbors)
 {
     MELEMENT **Mptr;  /* double indirection !! */
     int westward = 1; /* 1 if west of interpolation point */
@@ -559,7 +559,7 @@ int find_neighbors(EW *ewptr, NEIGHBOR *nbr_head, SHORT row, SHORT col,
 /*      This function exhausts all possible nearest neighhbors          */
 /*      within the row indexed by the ew search pointer                 */
 
-int exhaust_search(EW *ewptr, NEIGHBOR *nbr_head, SHORT row, SHORT col)
+int exhaust_search(EW *ewptr, NEIGHBOR *nbr_head, int row, int col)
 {
     double distance;
 
@@ -586,7 +586,7 @@ int exhaust_search(EW *ewptr, NEIGHBOR *nbr_head, SHORT row, SHORT col)
 /************************************************************************/
 /*      triangulate returns the square of the hypoteneuse               */
 
-double triangulate(MELEMENT *Mptr, SHORT row, SHORT col)
+double triangulate(MELEMENT *Mptr, int row, int col)
 {
     extern double *rowlook, *collook;
     int rowoff, coloff;
@@ -653,7 +653,7 @@ int sort_neighbors(NEIGHBOR *nbr_head, double distance)
 }
 
 int free_row_lists(/* frees indexed row lists of data */
-                   MELEMENT *rowlist, SHORT nrows)
+                   MELEMENT *rowlist, int nrows)
 {
     int i;
     MELEMENT *Mptr, *prev;
@@ -674,11 +674,11 @@ int free_row_lists(/* frees indexed row lists of data */
 MELEMENT *row_lists(
     /* Search and make array-indexed doubly-linked lists of original data points
      */
-    SHORT rows, SHORT cols, /* total rows and columns in window */
-    SHORT *datarows,        /* number of rows with non-zero input data */
-    int *npts,              /* number of data points available */
-    int fd,                 /* file descriptor, input */
-    CELL *cell              /* array of data for a single row */
+    int rows, int cols, /* total rows and columns in window */
+    int *datarows,      /* number of rows with non-zero input data */
+    int *npts,          /* number of data points available */
+    int fd,             /* file descriptor, input */
+    CELL *cell          /* array of data for a single row */
 )
 {
     int row, col;        /* row and column indices */
@@ -737,7 +737,7 @@ MELEMENT *row_lists(
 /*      Lookup tables containing distance squared (in units of ns.res)  */
 /*      are created for later use in selecting nearest neighbors        */
 
-int lookup_tables(SHORT nrows, SHORT ncols)
+int lookup_tables(int nrows, int ncols)
 {
     extern double *rowlook, *collook, ew2;
     extern struct Cell_head window;

raster/r.surf.idw/main.h

@@ -1,11 +1,9 @@
 #include <grass/raster.h>
 
-#define SHORT    short
-
 #define MELEMENT struct Melement
 MELEMENT
 {
-    short x, y; /* grid coordinates */
+    int x, y; /* grid coordinates */
     int value;
     MELEMENT *next, *prior; /* next and prior element in row list */
 };
@@ -27,16 +25,16 @@ NEIGHBOR
 #define EW struct ew
 EW
 {
-    MELEMENT *east, /* next eastward search in this row */
-        *west,      /* next westward search in this row */
-        *start;     /* starting point of east and west search in this row */
-    short ealive, walive; /* used only for latitude-longitude,
+    MELEMENT *east,     /* next eastward search in this row */
+        *west,          /* next westward search in this row */
+        *start;         /* starting point of east and west search in this row */
+    int ealive, walive; /* used only for latitude-longitude,
                              TRUE if search is active in this direction */
     EW *next;
 };
 
 /* dist.c */
-int G_begin_geodesic_distance_l(short, double, double);
+int G_begin_geodesic_distance_l(int, double, double);
 double LL_set_geodesic_distance_lat(double);
 double set_sdlmr(double);
 int LL_set_geodesic_distance(double *, int, int);
@@ -46,20 +44,20 @@ int free_dist_params(void);
 /* ll.c */
 int extend_west(EW *);
 int extend_east(EW *);
-double distance_LL(SHORT, SHORT, MELEMENT *);
-int LL_lookup_tables(SHORT, SHORT);
+double distance_LL(int, int, MELEMENT *);
+int LL_lookup_tables(int, int);
 
 /* main.c */
-int lookup_and_function_ptrs(SHORT, SHORT);
-int interpolate(MELEMENT[], SHORT, SHORT, SHORT, int, int, int);
-int make_neighbors_list(EW *, EW *, EW *, SHORT, SHORT, NEIGHBOR *, int);
-int search(EW **, NEIGHBOR *, SHORT, SHORT, int, SHORT *, EW *, SHORT);
-int exhaust(EW **, NEIGHBOR *, SHORT, SHORT);
-EW *next_row(EW *, EW *, SHORT *, SHORT);
-double triangulate(MELEMENT *, SHORT, SHORT);
+int lookup_and_function_ptrs(int, int);
+int interpolate(MELEMENT[], int, int, int, int, int, int);
+int make_neighbors_list(EW *, EW *, EW *, int, int, NEIGHBOR *, int);
+int search(EW **, NEIGHBOR *, int, int, int, int *, EW *, int);
+int exhaust(EW **, NEIGHBOR *, int, int);
+EW *next_row(EW *, EW *, int *, int);
+double triangulate(MELEMENT *, int, int);
 int add_neighbor(MELEMENT **, NEIGHBOR *, double, int);
 int replace_neighbor(MELEMENT **, NEIGHBOR *, double);
 int sort_neighbors(NEIGHBOR *, double);
-int free_row_lists(MELEMENT *, SHORT);
-MELEMENT *row_lists(SHORT, SHORT, SHORT *, int *, int, CELL *);
-int lookup_tables(SHORT, SHORT);
+int free_row_lists(MELEMENT *, int);
+MELEMENT *row_lists(int, int, int *, int *, int, CELL *);
+int lookup_tables(int, int);