Fix implicit conversions in checksumming test programs.

tests/cksum_read.c

@@ -17,16 +17,16 @@ read_table(const char *table_fname, size_t *table_len)
   struct cksum_table *table = NULL;
   FILE *tablefp;
   size_t table_size = 0, table_used = 0;
-  unsigned long cksum_temp;
+  uint32_t cksum_temp;
   int code;
 
   if (!(tablefp = fopen(table_fname, "r")))
     {
       perror("failed to open table file");
-      *table_len = -1;
+      *table_len = (size_t)-1;
       return NULL;
     }
-  while (fscanf(tablefp, "%08lx %d\n", &cksum_temp, &code) == 2)
+  while (fscanf(tablefp, "%08"PRIx32" %d\n", &cksum_temp, &code) == 2)
     {
       ENSURE_ARRAY_SIZE(table, table_size, table_used + 1);
       table[table_used].code = code;

tests/cksum_write.c

@@ -63,6 +63,16 @@ fname_create(const char *prefix, const char *suffix)
   return fname;
 }
 
+static inline void
+check_positive(int v, const char *msg)
+{
+  if (v < 1)
+    {
+      fprintf(stderr, "error: number of %s must be positive!\n", msg);
+      exit(EXIT_FAILURE);
+    }
+}
+
 #ifdef TEST_CHUNK_WRITE
 static void
 get_chunk(double *chunkBuf, double *var, int varShape[3],
@@ -159,6 +169,7 @@ main(int argc, char *argv[])
 #endif
       case 'm':
         nlon = parse_intarg("error parsing number of longitudes");
+        check_positive(nlon, "longitudes");
 #ifdef TEST_CHUNK_WRITE
         if (nlon < 2)
           {
@@ -169,13 +180,16 @@ main(int argc, char *argv[])
 #endif
         break;
       case 'n':
-        nlat = parse_intarg("error parsing number of latitudes");
+        check_positive(nlat = parse_intarg("error parsing number of latitudes"),
+                       "latitudes");
         break;
       case 'o':
-        nlev = parse_intarg("error parsing number of levels");
+        check_positive(nlev = parse_intarg("error parsing number of levels"),
+                       "levels");
         break;
       case 't':
-        nts = parse_intarg("error parsing number of timesteps");
+        check_positive(nts = parse_intarg("error parsing number of timesteps"),
+                       "timesteps");
         break;
       default: /* '?' */
         fprintf(stderr, "Usage: %s [-m nlon] [-n nlat] [-o nlev] [-t nts]\n", argv[0]);
@@ -183,18 +197,18 @@ main(int argc, char *argv[])
       }
   }
 
-  lons = malloc(nlon * sizeof (lons[0]));
+  lons = malloc((size_t)nlon * sizeof (lons[0]));
   for (i = 0; i < nlon; ++i)
     lons[i] = ((double)(i * 360))/nlon;
-  lats = malloc(nlat * sizeof (lats[0]));
+  lats = malloc((size_t)nlat * sizeof (lats[0]));
   for (i = 0; i < nlat; ++i)
     lats[i] = ((double)(i * 180))/nlat - 90.0;
-  levs = malloc(nlev * sizeof (levs[0]));
+  levs = malloc((size_t)nlev * sizeof (levs[0]));
   for (i = 0; i < nlev; ++i)
     levs[i] = 101300 - floor(3940.3 * (exp(2.3579 * (double)(i)/(nlev - 1)) - 1.0));
 
-  varSize[0] = nlon * nlat;
-  varSize[1] = nlon * nlat * nlev;
+  varSize[0] = (size_t)nlon * (size_t)nlat;
+  varSize[1] = (size_t)nlon * (size_t)nlat * (size_t)nlev;
 
   // Create a regular lon/lat grid
   gridID = gridCreate(grid, nlon*nlat);
@@ -257,7 +271,7 @@ main(int argc, char *argv[])
                 datatype);
         exit(EXIT_FAILURE);
       }
-    mscale = INT64_C(1) << mant_bits;
+    mscale = (double)(INT64_C(1) << mant_bits);
     mrscale = 1.0/mscale;
   }
 
@@ -318,7 +332,8 @@ main(int argc, char *argv[])
         // Write var1 and var2
 #ifdef TEST_CHUNK_WRITE
         {
-          size_t maxChunkSize = (nlon + 1)/2 * nlat * nlev;
+          size_t maxChunkSize
+            = ((size_t)nlon + 1)/2 * (size_t)nlat * (size_t)nlev;
           double *chunkBuf = malloc(maxChunkSize * sizeof (double));
           int varShape[2][3] = { { nlon, nlat, 1 }, { nlon, nlat, nlev } },
             chunk[3][2] = { { 0, nlon/2 - 1 }, { 0, nlat - 1 }, { 0, 0 } };
@@ -365,7 +380,9 @@ main(int argc, char *argv[])
         {
           uint32_t cksum;
           int code;
-          cksum = memcrc_finish(&checksum_state[i], (off_t)varSize[i] * sizeof (var[i][0]) * nts);
+          cksum = memcrc_finish(&checksum_state[i],
+                                (off_t)(varSize[i] * sizeof (var[i][0])
+                                        * (size_t)nts));
           code = vlistInqVarCode(vlistID, varID[i]);
           if (fprintf(tablefp, "%08lx %d\n", (unsigned long)cksum, code) < 0)
             {

tests/deco2d_model.c

@@ -56,11 +56,13 @@ modelRegionCompute(double region[], int nlev, int nlat, int nlon,
     for (unsigned j = 0; j < n; ++j)
       for (unsigned i = 0; i < m; ++i)
         region[k * kstride + j * jstride + i]
-          = sign_flat(round((cos(2.0 * M_PI * (lons[(i + is + tsID)%nlon]
-                                               - lons[0])
+          = sign_flat(round((cos(2.0 * M_PI
+                                 * (lons[(i + is + (unsigned)tsID)
+                                         %(unsigned)nlon] - lons[0])
                                  / (lons[nlon-1] - lons[0]))
-                             * sin(2.0 * M_PI * (lats[(j + js + k + ks)%nlat]
-                                                 - lats[0])
+                             * sin(2.0 * M_PI
+                                   * (lats[(j + js + k + ks)%(unsigned)nlat]
+                                      - lats[0])
                                    / (lats[nlat-1] - lats[0]))
                              ) * mscale)) * mrscale;
 }
@@ -138,26 +140,26 @@ modelRun(struct model_config setup, MPI_Comm comm)
   gridID = gridCreate ( GRID_LONLAT, nlon*nlat );
   gridDefXsize ( gridID, nlon );
   gridDefYsize ( gridID, nlat );
-  lons = xmalloc(nlon * sizeof (lons[0]));
+  lons = xmalloc((size_t)nlon * sizeof (lons[0]));
   for (i = 0; i < nlon; ++i)
     lons[i] = ((double)(i * 360))/nlon;
-  lats = xmalloc(nlat * sizeof (lats[0]));
+  lats = xmalloc((size_t)nlat * sizeof (lats[0]));
   for (i = 0; i < nlat; ++i)
     lats[i] = ((double)(i * 180))/nlat - 90.0;
   gridDefXvals ( gridID, lons );
   gridDefYvals ( gridID, lats );
 
-  levs = xmalloc(setup.max_nlev * sizeof (levs[0]));
+  levs = xmalloc((size_t)setup.max_nlev * sizeof (levs[0]));
   for (i = 0; i < setup.max_nlev; ++i)
     levs[i] = 101300.0
       - 3940.3 * (exp(1.3579 * (double)(i)/(setup.max_nlev - 1)) - 1.0);
 
   vlistID = vlistCreate ();
 
-  varDesc = xmalloc(nVars * sizeof (varDesc[0]));
+  varDesc = xmalloc((size_t)nVars * sizeof (varDesc[0]));
   for (int varIdx = 0; varIdx < nVars; varIdx++ )
     {
-      int varLevs = random()%4;
+      int varLevs = (int)random()%4;
       switch (varLevs)
         {
         case 1:
@@ -182,9 +184,10 @@ modelRun(struct model_config setup, MPI_Comm comm)
         = zaxisCreate(ZAXIS_PRESSURE, varDesc[varIdx].nlev);
       zaxisDefLevels(varDesc[varIdx].zaxisID, levs);
       zaxisIDset:
-      varDesc[varIdx].id = vlistDefVar(vlistID, gridID, varDesc[varIdx].zaxisID,
-                                       TIME_VARIABLE);
-      varDesc[varIdx].size = nlon * nlat * varDesc[varIdx].nlev;
+      varDesc[varIdx].id
+        = vlistDefVar(vlistID, gridID, varDesc[varIdx].zaxisID, TIME_VARIABLE);
+      varDesc[varIdx].size
+        = (size_t)nlon * (size_t)nlat * (size_t)varDesc[varIdx].nlev;
 #ifdef USE_MPI
       {
         int start[2], chunkSize[3], varSize[2] = { nlon, nlat };
@@ -378,8 +381,9 @@ modelRun(struct model_config setup, MPI_Comm comm)
                 uint32_t cksum;
                 int code;
                 cksum = memcrc_finish(&varDesc[i].checksum_state,
-                                      (off_t)varDesc[i].size
-                                      * sizeof (var[0]) * setup.nts);
+                                      (off_t)(varDesc[i].size
+                                              * sizeof (var[0])
+                                              * (size_t)setup.nts));
                 code = vlistInqVarCode(vlistID, varDesc[i].id);
                 if (fprintf(tablefp, "%08lx %d\n", (unsigned long)cksum,
                             code) < 0)

tests/simple_model.c

@@ -45,9 +45,9 @@ modelRegionCompute(double region[], size_t offset, size_t len,
   for (local_pos = 0; local_pos < len; ++local_pos)
     {
       size_t global_pos = offset + local_pos;
-      int k = global_pos / (nlon * nlat);
-      int j = (global_pos % (nlon * nlat))/ nlon;
-      int i = global_pos % nlon;
+      int k = (int)(global_pos / (size_t)(nlon * nlat));
+      int j = (int)(global_pos % (size_t)(nlon * nlat) / (size_t)nlon);
+      int i = (int)(global_pos % (size_t)nlon);
       region[local_pos]
         = sign_flat(round((cos(2.0 * M_PI * (lons[(i + tsID)%nlon] - lons[0])
                                / (lons[nlon-1] - lons[0]))
@@ -105,26 +105,26 @@ modelRun(struct model_config setup, MPI_Comm comm)
   gridID = gridCreate ( GRID_LONLAT, nlon*nlat );
   gridDefXsize ( gridID, nlon );
   gridDefYsize ( gridID, nlat );
-  lons = xmalloc(nlon * sizeof (lons[0]));
+  lons = xmalloc((size_t)nlon * sizeof (lons[0]));
   for (i = 0; i < nlon; ++i)
     lons[i] = ((double)(i * 360))/nlon;
-  lats = xmalloc(nlat * sizeof (lats[0]));
+  lats = xmalloc((size_t)nlat * sizeof (lats[0]));
   for (i = 0; i < nlat; ++i)
     lats[i] = ((double)(i * 180))/nlat - 90.0;
   gridDefXvals ( gridID, lons );
   gridDefYvals ( gridID, lats );
 
-  levs = xmalloc(setup.max_nlev * sizeof (levs[0]));
+  levs = xmalloc((size_t)setup.max_nlev * sizeof (levs[0]));
   for (i = 0; i < setup.max_nlev; ++i)
     levs[i] = 101300.0
       - 3940.3 * (exp(1.3579 * (double)(i)/(setup.max_nlev - 1)) - 1.0);
 
   vlistID = vlistCreate ();
 
-  varDesc = xmalloc(nVars * sizeof (varDesc[0]));
+  varDesc = xmalloc((size_t)nVars * sizeof (varDesc[0]));
   for (int varIdx = 0; varIdx < nVars; varIdx++ )
     {
-      int varLevs = random()%4;
+      int varLevs = (int)random()%4;
       switch (varLevs)
         {
         case 1:
@@ -149,9 +149,10 @@ modelRun(struct model_config setup, MPI_Comm comm)
         = zaxisCreate(ZAXIS_PRESSURE, varDesc[varIdx].nlev);
       zaxisDefLevels(varDesc[varIdx].zaxisID, levs);
       zaxisIDset:
-      varDesc[varIdx].id = vlistDefVar(vlistID, gridID, varDesc[varIdx].zaxisID,
-                                       TIME_VARIABLE);
-      varDesc[varIdx].size = nlon * nlat * varDesc[varIdx].nlev;
+      varDesc[varIdx].id
+        = vlistDefVar(vlistID, gridID, varDesc[varIdx].zaxisID, TIME_VARIABLE);
+      varDesc[varIdx].size
+        = (size_t)nlon * (size_t)nlat * (size_t)varDesc[varIdx].nlev;
 #ifdef USE_MPI
       {
         struct PPM_extent range
@@ -213,15 +214,15 @@ modelRun(struct model_config setup, MPI_Comm comm)
               int start = varDesc[varID].start;
               int chunk = varDesc[varID].chunkSize;
 #else
-              int chunk = varDesc[varID].size;
+              int chunk = (int)varDesc[varID].size;
               int start = 0;
 #endif
               if (varslice_size < chunk)
                 {
-                  varslice = xrealloc(varslice, chunk * sizeof (var[0]));
-                  varslice_size = chunk;
+                  varslice = xrealloc(varslice, (size_t)chunk * sizeof (var[0]));
+                  varslice_size = (size_t)chunk;
                 }
-              modelRegionCompute(varslice, start, chunk,
+              modelRegionCompute(varslice, (size_t)start, (size_t)chunk,
                                  varDesc[varID].nlev, nlat, nlon,
                                  tsID, lons, lats,
                                  mscale, mrscale);
@@ -276,8 +277,9 @@ modelRun(struct model_config setup, MPI_Comm comm)
                 uint32_t cksum;
                 int code;
                 cksum = memcrc_finish(&varDesc[i].checksum_state,
-                                      (off_t)varDesc[i].size
-                                      * sizeof (var[0]) * setup.nts);
+                                      (off_t)(varDesc[i].size
+                                              * sizeof (var[0])
+                                              * (size_t)setup.nts));
                 code = vlistInqVarCode(vlistID, varDesc[i].id);
                 if (fprintf(tablefp, "%08lx %d\n", (unsigned long)cksum,
                             code) < 0)

tests/simple_model_helper.c

@@ -40,7 +40,7 @@ var_scale(int datatype, double *mscale, double *mrscale)
               datatype);
       exit(EXIT_FAILURE);
     }
-  *mscale = INT64_C(1) << mant_bits;
+  *mscale = (double)(INT64_C(1) << mant_bits);
   *mrscale = 1.0 / *mscale;
 }
 

tests/stream_cksum.c

@@ -49,8 +49,8 @@ cksum_stream(const char *fname, size_t *table_len)
         nvars = -1;
         break;
       }
-    checksum_state = xcalloc(nvars, sizeof (checksum_state[0]));
-    varSize = xmalloc(nvars * sizeof (varSize[0]));
+    checksum_state = xcalloc((size_t)nvars, sizeof (checksum_state[0]));
+    varSize = xmalloc((size_t)nvars * sizeof (varSize[0]));
 
     for (i = 0; i < nvars; ++i)
       {
@@ -90,8 +90,8 @@ cksum_stream(const char *fname, size_t *table_len)
           break;
         }
       if (varSize[i].y == 0) varSize[i].y = 1;
-      varSize[i].chars = (size_t)varSize[i].x * varSize[i].y * varSize[i].z
-        * sizeof (buf[0]);
+      varSize[i].chars = (size_t)varSize[i].x * (size_t)varSize[i].y
+        * (size_t)varSize[i].z * sizeof (buf[0]);
       if (var_size_max_chars < varSize[i].chars)
         var_size_max_chars = varSize[i].chars;
     }
@@ -122,7 +122,7 @@ cksum_stream(const char *fname, size_t *table_len)
         ++tsID;
       }
 
-    file_vars = xmalloc(nvars * sizeof (file_vars[0]));
+    file_vars = xmalloc((size_t)nvars * sizeof (file_vars[0]));
     for (i = 0; i < nvars; ++i)
       {
         file_vars[i].code = vlistInqVarCode(vlistID, i);
@@ -138,7 +138,7 @@ cksum_stream(const char *fname, size_t *table_len)
   free(checksum_state);
   free(varSize);
   free(buf);
-  *table_len = nvars;
+  *table_len = (size_t)nvars;
 
   return file_vars;
 }