prefer uint8_t to char in pointer arithmetic

Signed-off-by: Loic Dachary <loic@dachary.org>

5 files changed, 28 insertions, 28 deletions

diff --git a/src/gf.c b/src/gf.c
index 701739b..62f5d7b 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -482,7 +482,7 @@ int gf_init_hard(gf_t *gf, int w, int mult_type,
   h->arg2 = arg2;
   h->base_gf = base_gf;
   h->private = (void *) gf->scratch;
-  h->private = (char*)h->private + (sizeof(gf_internal_t));
+  h->private = (uint8_t *)h->private + (sizeof(gf_internal_t));
   gf->extract_word.w32 = NULL;
 
   switch(w) {
@@ -687,8 +687,8 @@ static void gf_slow_multiply_region(gf_region_data *rd, void *src, void *dest, v
       fprintf(stderr, "Error: gf_slow_multiply_region: w=%d not implemented.\n", h->w);
       exit(1);
     }
-    src = (char*)src + wb;
-    dest = (char*)dest + wb;
+    src = (uint8_t *)src + wb;
+    dest = (uint8_t *)dest + wb;
   }
 }
 
@@ -803,8 +803,8 @@ void gf_set_region_data(gf_region_data *rd,
   
     rd->s_start = src;
     rd->d_start = dest;
-    rd->s_top = (char*)src + bytes;
-    rd->d_top = (char*)src + bytes;
+    rd->s_top = (uint8_t *)src + bytes;
+    rd->d_top = (uint8_t *)src + bytes;
     return;
   }
 
@@ -833,12 +833,12 @@ void gf_set_region_data(gf_region_data *rd,
 
   uls %= a;
   if (uls != 0) uls = (a-uls);
-  rd->s_start = (char*)rd->src + uls;
-  rd->d_start = (char*)rd->dest + uls;
+  rd->s_start = (uint8_t *)rd->src + uls;
+  rd->d_start = (uint8_t *)rd->dest + uls;
   bytes -= uls;
   bytes -= (bytes % align);
-  rd->s_top = (char*)rd->s_start + bytes;
-  rd->d_top = (char*)rd->d_start + bytes;
+  rd->s_top = (uint8_t *)rd->s_start + bytes;
+  rd->d_top = (uint8_t *)rd->d_start + bytes;
 
 }
 
@@ -849,7 +849,7 @@ void gf_do_initial_region_alignment(gf_region_data *rd)
 
 void gf_do_final_region_alignment(gf_region_data *rd)
 {
-  gf_slow_multiply_region(rd, rd->s_top, rd->d_top, (char*)rd->src+rd->bytes);
+  gf_slow_multiply_region(rd, rd->s_top, rd->d_top, (uint8_t *)rd->src+rd->bytes);
 }
 
 void gf_multby_zero(void *dest, int bytes, int xor) 
@@ -1018,7 +1018,7 @@ static void gf_unaligned_xor(void *src, void *dest, int bytes)
   }
   
   d8 = (uint8_t *) d64;
-  while (d8 < (uint8_t *) ((char*)dest+bytes)) {
+  while (d8 < (uint8_t *) ((uint8_t *)dest+bytes)) {
     *d8 ^= *s8;
     d8++;
     s8++;
diff --git a/src/gf_general.c b/src/gf_general.c
index c410598..b5ca7a9 100644
--- a/src/gf_general.c
+++ b/src/gf_general.c
@@ -326,7 +326,7 @@ void gf_general_set_up_single_timing_test(int w, void *ra, void *rb, int size)
   uint64_t *r64;
   int i;
 
-  top = (char*)rb+size;
+  top = (uint8_t *)rb+size;
 
   /* If w is 8, 16, 32, 64 or 128, fill the regions with random bytes.
      However, don't allow for zeros in rb, because that will screw up
@@ -365,7 +365,7 @@ void gf_general_set_up_single_timing_test(int w, void *ra, void *rb, int size)
           r64[1] = g.w128[1];
           break;
       }
-      rb = (char*)rb + (w/8);
+      rb = (uint8_t *)rb + (w/8);
     }
   } else if (w == 4) {
     r8a = (uint8_t *) ra;
@@ -407,7 +407,7 @@ int gf_general_do_single_timing_test(gf_t *gf, void *ra, void *rb, int size, cha
 
   h = (gf_internal_t *) gf->scratch;
   w = h->w;
-  top = (char*)ra + size;
+  top = (uint8_t *)ra + size;
 
   if (w == 8 || w == 4) {
     r8a = (uint8_t *) ra; 
diff --git a/src/gf_w128.c b/src/gf_w128.c
index 6af88b4..61cf3d7 100644
--- a/src/gf_w128.c
+++ b/src/gf_w128.c
@@ -620,7 +620,7 @@ gf_w128_split_4_128_sse_multiply_region(gf_t *gf, void *src, void *dest, gf_val_
 
   /* Doing this instead of gf_do_initial_region_alignment() because that doesn't hold 128-bit vals */
 
-  gf_w128_multiply_region_from_single(gf, src, dest, val, ((char*)rd.s_start-(char*)src), xor);
+  gf_w128_multiply_region_from_single(gf, src, dest, val, ((uint8_t *)rd.s_start-(uint8_t *)src), xor);
 
   s64 = (uint64_t *) rd.s_start;
   d64 = (uint64_t *) rd.d_start;
@@ -690,7 +690,7 @@ gf_w128_split_4_128_sse_multiply_region(gf_t *gf, void *src, void *dest, gf_val_
 
   /* Doing this instead of gf_do_final_region_alignment() because that doesn't hold 128-bit vals */
 
-  gf_w128_multiply_region_from_single(gf, rd.s_top, rd.d_top, val, ((char*)src+bytes)-(char*)rd.s_top, xor);
+  gf_w128_multiply_region_from_single(gf, rd.s_top, rd.d_top, val, ((uint8_t *)src+bytes)-(uint8_t *)rd.s_top, xor);
 }
 #endif
 
@@ -720,7 +720,7 @@ gf_w128_split_4_128_sse_altmap_multiply_region(gf_t *gf, void *src, void *dest,
 
   /* Doing this instead of gf_do_initial_region_alignment() because that doesn't hold 128-bit vals */
 
-  gf_w128_multiply_region_from_single(gf, src, dest, val, ((char*)rd.s_start-(char*)src), xor);
+  gf_w128_multiply_region_from_single(gf, src, dest, val, ((uint8_t *)rd.s_start-(uint8_t *)src), xor);
 
   s64 = (uint64_t *) rd.s_start;
   d64 = (uint64_t *) rd.d_start;
@@ -800,7 +800,7 @@ gf_w128_split_4_128_sse_altmap_multiply_region(gf_t *gf, void *src, void *dest,
   }
   /* Doing this instead of gf_do_final_region_alignment() because that doesn't hold 128-bit vals */
 
-  gf_w128_multiply_region_from_single(gf, rd.s_top, rd.d_top, val, ((char*)src+bytes)-(char*)rd.s_top, xor);
+  gf_w128_multiply_region_from_single(gf, rd.s_top, rd.d_top, val, ((uint8_t *)src+bytes)-(uint8_t *)rd.s_top, xor);
 }
 #endif
 
@@ -1382,7 +1382,7 @@ gf_w128_composite_multiply_region_alt(gf_t *gf, void *src, void *dest, gf_val_12
   gf_region_data rd;
 
   gf_set_region_data(&rd, gf, src, dest, bytes, 0, xor, 64);
-  gf_w128_multiply_region_from_single(gf, src, dest, val, ((char*)rd.s_start-(char*)src), xor);
+  gf_w128_multiply_region_from_single(gf, src, dest, val, ((uint8_t *)rd.s_start-(uint8_t *)src), xor);
 
   slow = (uint8_t *) rd.s_start;
   dlow = (uint8_t *) rd.d_start;
@@ -1398,7 +1398,7 @@ gf_w128_composite_multiply_region_alt(gf_t *gf, void *src, void *dest, gf_val_12
   base_gf->multiply_region.w64(base_gf, shigh, dhigh, base_gf->multiply.w64(base_gf, h->prim_poly, val1
         ), sub_reg_size, 1);
 
-  gf_w128_multiply_region_from_single(gf, rd.s_top, rd.d_top, val, ((char*)src+bytes)-(char*)rd.s_top, xor);
+  gf_w128_multiply_region_from_single(gf, rd.s_top, rd.d_top, val, ((uint8_t *)src+bytes)-(uint8_t *)rd.s_top, xor);
 }
 
 
@@ -1584,7 +1584,7 @@ int gf_w128_group_init(gf_t *gf)
   g_r = scratch->arg2;
   size_r = (1 << g_r);
 
-  gt->r_table = (gf_val_128_t)((char*)scratch->private + (2 * sizeof(uint64_t *)));
+  gt->r_table = (gf_val_128_t)((uint8_t *)scratch->private + (2 * sizeof(uint64_t *)));
   gt->m_table = gt->r_table + size_r;
   gt->m_table[2] = 0;
   gt->m_table[3] = 0;
diff --git a/src/gf_w8.c b/src/gf_w8.c
index 89ef6a2..d3e2bf6 100644
--- a/src/gf_w8.c
+++ b/src/gf_w8.c
@@ -1319,13 +1319,13 @@ gf_w8_composite_multiply_region_alt(gf_t *gf, void *src, void *dest, gf_val_32_t
   gf_set_region_data(&rd, gf, src, dest, bytes, val, xor, 32);
   gf_do_initial_region_alignment(&rd);
 
-  sub_reg_size = ((char*)rd.d_top - (char*)rd.d_start) / 2;
+  sub_reg_size = ((uint8_t *)rd.d_top - (uint8_t *)rd.d_start) / 2;
 
   base_gf->multiply_region.w32(base_gf, rd.s_start, rd.d_start, val0, sub_reg_size, xor);
-  base_gf->multiply_region.w32(base_gf, (char*)rd.s_start+sub_reg_size, rd.d_start, val1, sub_reg_size, 1);
-  base_gf->multiply_region.w32(base_gf, rd.s_start, (char*)rd.d_start+sub_reg_size, val1, sub_reg_size, xor);
-  base_gf->multiply_region.w32(base_gf, (char*)rd.s_start+sub_reg_size, (char*)rd.d_start+sub_reg_size, val0, sub_reg_size, 1);
-  base_gf->multiply_region.w32(base_gf, (char*)rd.s_start+sub_reg_size, (char*)rd.d_start+sub_reg_size, base_gf->multiply.w32(base_gf, h->prim_poly, val1), sub_reg_size, 1);
+  base_gf->multiply_region.w32(base_gf, (uint8_t *)rd.s_start+sub_reg_size, rd.d_start, val1, sub_reg_size, 1);
+  base_gf->multiply_region.w32(base_gf, rd.s_start, (uint8_t *)rd.d_start+sub_reg_size, val1, sub_reg_size, xor);
+  base_gf->multiply_region.w32(base_gf, (uint8_t *)rd.s_start+sub_reg_size, (uint8_t *)rd.d_start+sub_reg_size, val0, sub_reg_size, 1);
+  base_gf->multiply_region.w32(base_gf, (uint8_t *)rd.s_start+sub_reg_size, (uint8_t *)rd.d_start+sub_reg_size, base_gf->multiply.w32(base_gf, h->prim_poly, val1), sub_reg_size, 1);
 
    gf_do_final_region_alignment(&rd);
 }
diff --git a/src/gf_wgen.c b/src/gf_wgen.c
index 68c6bb0..06f7993 100644
--- a/src/gf_wgen.c
+++ b/src/gf_wgen.c
@@ -916,11 +916,11 @@ gf_wgen_cauchy_region(gf_t *gf, void *src, void *dest, gf_val_32_t val, int byte
   for (i = 0; i < h->w; i++) {
     for (j = 0; j < h->w; j++) {
       if (val & (1 << j)) {
-        gf_multby_one(src, ((char*)dest) + j*rs, rs, (written & (1 << j)));
+        gf_multby_one(src, ((uint8_t *)dest) + j*rs, rs, (written & (1 << j)));
         written |= (1 << j);
       }
     }
-    src = (char*)src + rs;
+    src = (uint8_t *)src + rs;
     val = gf->multiply.w32(gf, val, 2);
   }
 }