finished upgrading allocation syntax

Author: badasahog

src/assign.c

@@ -1291,14 +1291,14 @@ void savetl(SEXP s)
       internal_error(__func__, "reached maximum %d items for savetl", nalloc); // # nocov
     }
     nalloc = nalloc>(INT_MAX/2) ? INT_MAX : nalloc*2;
-    char *tmp = (char *)realloc(saveds, nalloc*sizeof(SEXP));
+    char *tmp = realloc(saveds, sizeof(SEXP)*nalloc);
     if (tmp==NULL) {
       // C spec states that if realloc() fails the original block is left untouched; it is not freed or moved. We rely on that here.
       savetl_end();                                                      // # nocov  free(saveds) happens inside savetl_end
       error(_("Failed to realloc saveds to %d items in savetl"), nalloc);   // # nocov
     }
     saveds = (SEXP *)tmp;
-    tmp = (char *)realloc(savedtl, nalloc*sizeof(R_len_t));
+    tmp = realloc(savedtl, sizeof(R_len_t)*nalloc);
     if (tmp==NULL) {
       savetl_end();                                                      // # nocov
       error(_("Failed to realloc savedtl to %d items in savetl"), nalloc);  // # nocov

src/chmatch.c

@@ -96,8 +96,8 @@ static SEXP chmatchMain(SEXP x, SEXP table, int nomatch, bool chin, bool chmatch
     // For example: A,B,C,B,D,E,A,A   =>   A(TL=1),B(2),C(3),D(4),E(5)   =>   dupMap    1  2  3  5  6 | 8  7  4
     //                                                                        dupLink   7  8          |    6     (blank=0)
     unsigned int mapsize = tablelen+nuniq; // lto compilation warning #5760 // +nuniq to store a 0 at the end of each group
-    int *counts = (int *)calloc(nuniq, sizeof(int));
-    int *map =    (int *)calloc(mapsize, sizeof(int));
+    int *counts = calloc(nuniq, sizeof(*counts));
+    int *map =    calloc(mapsize, sizeof(*map));
     if (!counts || !map) {
       // # nocov start
       free(counts); free(map);

src/forder.c

@@ -117,7 +117,7 @@ static void push(const int *x, const int n) {
   int newn = gs_thread_n[me] + n;
   if (gs_thread_alloc[me] < newn) {
     gs_thread_alloc[me] = (newn < nrow/3) ? (1+(newn*2)/4096)*4096 : nrow;  // [2|3] to not overflow and 3 not 2 to avoid allocating close to nrow (nrow groups occurs when all size 1 groups)
-    gs_thread[me] = realloc(gs_thread[me], gs_thread_alloc[me]*sizeof(int));
+    gs_thread[me] = realloc(gs_thread[me], sizeof(*gs_thread[me])*gs_thread_alloc[me]);
     if (gs_thread[me]==NULL) STOP(_("Failed to realloc thread private group size buffer to %d*4bytes"), (int)gs_thread_alloc[me]);
   }
   memcpy(gs_thread[me]+gs_thread_n[me], x, n*sizeof(int));
@@ -131,10 +131,10 @@ static void flush(void) {
   int newn = gs_n + n;
   if (gs_alloc < newn) {
     gs_alloc = (newn < nrow/3) ? (1+(newn*2)/4096)*4096 : nrow;
-    gs = realloc(gs, gs_alloc*sizeof(int));
+    gs = realloc(gs, sizeof(*gs)*gs_alloc);
     if (gs==NULL) STOP(_("Failed to realloc group size result to %d*4bytes"), (int)gs_alloc);
   }
-  memcpy(gs+gs_n, gs_thread[me], n*sizeof(int));
+  memcpy(gs+gs_n, gs_thread[me], sizeof(int)*n);
   gs_n += n;
   gs_thread_n[me] = 0;
 }
@@ -316,7 +316,7 @@ static void range_str(const SEXP *x, int n, uint64_t *out_min, uint64_t *out_max
       if (ustr_alloc<=ustr_n) {
         ustr_alloc = (ustr_alloc==0) ? 16384 : ustr_alloc*2;  // small initial guess, negligible time to alloc 128KB (32 pages)
         if (ustr_alloc>n) ustr_alloc = n;  // clamp at n. Reaches n when fully unique (no dups)
-        ustr = realloc(ustr, ustr_alloc * sizeof(SEXP));
+        ustr = realloc(ustr, sizeof(SEXP) * ustr_alloc);
         if (ustr==NULL) STOP(_("Unable to realloc %d * %d bytes in range_str"), ustr_alloc, (int)sizeof(SEXP));  // # nocov
       }
       ustr[ustr_n++] = s;
@@ -345,7 +345,7 @@ static void range_str(const SEXP *x, int n, uint64_t *out_min, uint64_t *out_max
     SEXP *ustr3 = malloc(sizeof(*ustr3) * ustr_n);
     if (!ustr3)
       STOP(_("Failed to alloc ustr3 when converting strings to UTF8"));  // # nocov
-    memcpy(ustr3, STRING_PTR_RO(ustr2), ustr_n*sizeof(SEXP));
+    memcpy(ustr3, STRING_PTR_RO(ustr2), sizeof(SEXP) * ustr_n);
     // need to reset ustr_maxlen because we need ustr_maxlen for utf8 strings
     ustr_maxlen = 0;
     for (int i=0; i<ustr_n; i++) {
@@ -551,9 +551,9 @@ SEXP forder(SEXP DT, SEXP by, SEXP retGrpArg, SEXP retStatsArg, SEXP sortGroupsA
 
   int ncol=length(by);
   int keyAlloc = (ncol+n_cplx)*8 + 1;         // +1 for NULL to mark end; calloc to initialize with NULLs
-  key = calloc(keyAlloc, sizeof(uint8_t *));  // needs to be before loop because part II relies on part I, column-by-column.
+  key = calloc(keyAlloc, sizeof(*key));  // needs to be before loop because part II relies on part I, column-by-column.
   if (!key)
-    STOP(_("Unable to allocate %"PRIu64" bytes of working memory"), (uint64_t)keyAlloc*sizeof(uint8_t *));  // # nocov
+    STOP(_("Unable to allocate %"PRIu64" bytes of working memory"), (uint64_t)keyAlloc*sizeof(*key));  // # nocov
   nradix=0; // the current byte we're writing this column to; might be squashing into it (spare>0)
   int spare=0;  // the amount of bits remaining on the right of the current nradix byte
   bool isReal=false;
@@ -665,10 +665,10 @@ SEXP forder(SEXP DT, SEXP by, SEXP retGrpArg, SEXP retStatsArg, SEXP sortGroupsA
 
     for (int b=0; b<nbyte; b++) {
       if (key[nradix+b]==NULL) {
-        uint8_t *tt = calloc(nrow, sizeof(uint8_t));  // 0 initialize so that NA's can just skip (NA is always the 0 offset)
+        uint8_t *tt = calloc(nrow, sizeof(*tt));  // 0 initialize so that NA's can just skip (NA is always the 0 offset)
         if (!tt) {
           free(key); // # nocov
-          STOP(_("Unable to allocate %"PRIu64" bytes of working memory"), (uint64_t)nrow*sizeof(uint8_t)); // # nocov
+          STOP(_("Unable to allocate %"PRIu64" bytes of working memory"), (uint64_t)nrow*sizeof(*tt)); // # nocov
         }
         key[nradix+b] = tt;
       }
@@ -796,9 +796,9 @@ SEXP forder(SEXP DT, SEXP by, SEXP retGrpArg, SEXP retStatsArg, SEXP sortGroupsA
   }
 
   if (retgrp) {
-    gs_thread = calloc(nth, sizeof(int *));     // thread private group size buffers
-    gs_thread_alloc = calloc(nth, sizeof(int));
-    gs_thread_n = calloc(nth, sizeof(int));
+    gs_thread = calloc(nth, sizeof(*gs_thread));     // thread private group size buffers
+    gs_thread_alloc = calloc(nth, sizeof(*gs_thread_alloc));
+    gs_thread_n = calloc(nth, sizeof(*gs_thread_n));
     if (!gs_thread || !gs_thread_alloc || !gs_thread_n) {
       free(gs_thread); free(gs_thread_alloc); free(gs_thread_n); // # nocov
       STOP(_("Could not allocate (very tiny) group size thread buffers")); // # nocov
@@ -1242,9 +1242,9 @@ void radix_r(const int from, const int to, const int radix) {
   // the counts are uint16_t but the cumulate needs to be int32_t (or int64_t in future) to hold the offsets
   // If skip==true and we're already done, we still need the first row of this cummulate (diff to get total group sizes) to push() or recurse below
 
-  int *starts = calloc(nBatch*256, sizeof(int));  // keep starts the same shape and ugrp order as counts
+  int *starts = calloc(nBatch*256, sizeof(*starts));  // keep starts the same shape and ugrp order as counts
   if (!starts)
-    STOP(_("Failed to allocate %d bytes for '%s'."), (int)(nBatch*256*sizeof(int)), "starts"); // # nocov
+    STOP(_("Failed to allocate %d bytes for '%s'."), (int)(nBatch*256*sizeof(*starts)), "starts"); // # nocov
   for (int j=0, sum=0; j<ngrp; j++) {  // iterate through columns (ngrp bytes)
     uint16_t *tmp1 = counts+ugrp[j];
     int      *tmp2 = starts+ugrp[j];

src/fsort.c

@@ -273,7 +273,7 @@ SEXP fsort(SEXP x, SEXP verboseArg) {
     {
       // each thread has its own small stack of counts
       // don't use VLAs here: perhaps too big for stack yes but more that VLAs apparently fail with schedule(dynamic)
-      uint64_t *restrict mycounts = calloc((toBit/8 + 1)*256, sizeof(uint64_t));
+      uint64_t *restrict mycounts = calloc((toBit/8 + 1)*256, sizeof(*mycounts));
       if (!mycounts) {
         failed=true; alloc_fail=true;  // # nocov
       }

src/gsumm.c

@@ -117,7 +117,7 @@ SEXP gforce(SEXP env, SEXP jsub, SEXP o, SEXP f, SEXP l, SEXP irowsArg) {
     int bitshift = MAX(nb-8, 0);  // TODO: experiment nb/2.  Here it doesn't have to be /2 currently.
     int highSize = ((nrow-1)>>bitshift) + 1;
     //Rprintf(_("When assigning grp[o] = g, highSize=%d  nb=%d  bitshift=%d  nBatch=%d\n"), highSize, nb, bitshift, nBatch);
-    int *counts = calloc(nBatch*highSize, sizeof(int));  // TODO: cache-line align and make highSize a multiple of 64
+    int *counts = calloc(nBatch*highSize, sizeof(*counts));  // TODO: cache-line align and make highSize a multiple of 64
     int *TMP   = malloc(sizeof(*TMP) * nrow*2l); // must multiple the long int otherwise overflow may happen, #4295
     if (!counts || !TMP ) {
       free(counts); free(TMP); // # nocov
@@ -625,7 +625,7 @@ SEXP gmean(SEXP x, SEXP narmArg)
       for (int i=0; i<ngrp; i++) ansp[i] /= grpsize[i];
     } else {
       // narm==true and anyNA==true
-      int *restrict nna_counts = calloc(ngrp, sizeof(int));
+      int *restrict nna_counts = calloc(ngrp, sizeof(*nna_counts));
       if (!nna_counts)
         error(_("Unable to allocate %d * %zu bytes for non-NA counts in gmean na.rm=TRUE"), ngrp, sizeof(int)); // # nocov
       #pragma omp parallel for num_threads(getDTthreads(highSize, false))
@@ -678,8 +678,8 @@ SEXP gmean(SEXP x, SEXP narmArg)
       }
     } else {
       // narm==true and anyNA==true
-      int *restrict nna_counts_r = calloc(ngrp, sizeof(int));
-      int *restrict nna_counts_i = calloc(ngrp, sizeof(int));
+      int *restrict nna_counts_r = calloc(ngrp, sizeof(*nna_counts_r));
+      int *restrict nna_counts_i = calloc(ngrp, sizeof(*nna_counts_i));
       if (!nna_counts_r || !nna_counts_i) {
         // # nocov start
         free(nna_counts_r); free(nna_counts_i);

src/rbindlist.c

@@ -92,11 +92,11 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg, SEXP ignor
         SET_TRUELENGTH(s,-nuniq);
       }
     }
-    if (nuniq>0) uniq = realloc(uniq, nuniq*sizeof(SEXP));  // shrink to only what we need to release the spare
+    if (nuniq>0) uniq = realloc(uniq, sizeof(SEXP)*nuniq);  // shrink to only what we need to release the spare
 
     // now count the dups (if any) and how they're distributed across the items
-    int *counts = (int *)calloc(nuniq, sizeof(int)); // counts of names for each colnames
-    int *maxdup = (int *)calloc(nuniq, sizeof(int)); // the most number of dups for any name within one colname vector
+    int *counts = calloc(nuniq, sizeof(*counts)); // counts of names for each colnames
+    int *maxdup = calloc(nuniq, sizeof(*maxdup)); // the most number of dups for any name within one colname vector
     if (!counts || !maxdup) {
       // # nocov start
       for (int i=0; i<nuniq; ++i) SET_TRUELENGTH(uniq[i], 0);
@@ -445,7 +445,7 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg, SEXP ignor
               if (allocLevel<INT_MAX) {
                 int64_t new = (int64_t)allocLevel+n-k+1024; // if all remaining levels in this item haven't been seen before, plus 1024 margin in case of many very short levels
                 allocLevel = (new>(int64_t)INT_MAX) ? INT_MAX : (int)new;
-                tt = (SEXP *)realloc(levelsRaw, allocLevel*sizeof(SEXP));  // first time levelsRaw==NULL and realloc==malloc in that case
+                tt = realloc(levelsRaw, sizeof(SEXP)*allocLevel);  // first time levelsRaw==NULL and realloc==malloc in that case
               }
               if (tt==NULL) {
                 // # nocov start