Cleanup: use post increment/decrement

When the result isn't used, prefer post increment/decrement
(already used nearly everywhere in Blender).

1 files changed, 74 insertions, 74 deletions

diff --git a/source/blender/blenkernel/intern/customdata.c b/source/blender/blenkernel/intern/customdata.c
index 59dbfc293dd..8ac0f71cd7e 100644
--- a/source/blender/blenkernel/intern/customdata.c
+++ b/source/blender/blenkernel/intern/customdata.c
@@ -173,7 +173,7 @@ static void layerCopy_mdeformvert(const void *source, void *dest, int count)
 
   memcpy(dest, source, count * size);
 
-  for (i = 0; i < count; ++i) {
+  for (i = 0; i < count; i++) {
     MDeformVert *dvert = POINTER_OFFSET(dest, i * size);
 
     if (dvert->totweight) {
@@ -193,7 +193,7 @@ static void layerFree_mdeformvert(void *data, int count, int size)
 {
   int i;
 
-  for (i = 0; i < count; ++i) {
+  for (i = 0; i < count; i++) {
     MDeformVert *dvert = POINTER_OFFSET(data, i * size);
 
     if (dvert->dw) {
@@ -209,7 +209,7 @@ static void layerCopy_bmesh_elem_py_ptr(const void *UNUSED(source), void *dest,
 {
   int i, size = sizeof(void *);
 
-  for (i = 0; i < count; ++i) {
+  for (i = 0; i < count; i++) {
     void **ptr = POINTER_OFFSET(dest, i * size);
     *ptr = NULL;
   }
@@ -226,7 +226,7 @@ static void layerFree_bmesh_elem_py_ptr(void *data, int count, int size)
 {
   int i;
 
-  for (i = 0; i < count; ++i) {
+  for (i = 0; i < count; i++) {
     void **ptr = POINTER_OFFSET(data, i * size);
     if (*ptr) {
       bpy_bm_generic_invalidate(*ptr);
@@ -258,11 +258,11 @@ static void layerInterp_mdeformvert(const void **sources,
 
   /* build a list of unique def_nrs for dest */
   totweight = 0;
-  for (i = 0; i < count; ++i) {
+  for (i = 0; i < count; i++) {
     const MDeformVert *source = sources[i];
     float interp_weight = weights ? weights[i] : 1.0f;
 
-    for (j = 0; j < source->totweight; ++j) {
+    for (j = 0; j < source->totweight; j++) {
       MDeformWeight *dw = &source->dw[j];
       float weight = dw->weight * interp_weight;
 
@@ -407,7 +407,7 @@ static void layerCopy_tface(const void *source, void *dest, int count)
   MTFace *dest_tf = (MTFace *)dest;
   int i;
 
-  for (i = 0; i < count; ++i) {
+  for (i = 0; i < count; i++) {
     dest_tf[i] = source_tf[i];
   }
 }
@@ -425,13 +425,13 @@ static void layerInterp_tface(
   }
 
   sub_weight = sub_weights;
-  for (i = 0; i < count; ++i) {
+  for (i = 0; i < count; i++) {
     float weight = weights ? weights[i] : 1;
     const MTFace *src = sources[i];
 
-    for (j = 0; j < 4; ++j) {
+    for (j = 0; j < 4; j++) {
       if (sub_weights) {
-        for (k = 0; k < 4; ++k, ++sub_weight) {
+        for (k = 0; k < 4; k++, sub_weight++) {
           madd_v2_v2fl(uv[j], src->uv[k], (*sub_weight) * weight);
         }
       }
@@ -452,7 +452,7 @@ static void layerSwap_tface(void *data, const int *corner_indices)
   float uv[4][2];
   int j;
 
-  for (j = 0; j < 4; ++j) {
+  for (j = 0; j < 4; j++) {
     const int source_index = corner_indices[j];
     copy_v2_v2(uv[j], tf->uv[source_index]);
   }
@@ -514,7 +514,7 @@ static void layerCopy_origspace_face(const void *source, void *dest, int count)
   OrigSpaceFace *dest_tf = (OrigSpaceFace *)dest;
   int i;
 
-  for (i = 0; i < count; ++i) {
+  for (i = 0; i < count; i++) {
     dest_tf[i] = source_tf[i];
   }
 }
@@ -532,13 +532,13 @@ static void layerInterp_origspace_face(
   }
 
   sub_weight = sub_weights;
-  for (i = 0; i < count; ++i) {
+  for (i = 0; i < count; i++) {
     float weight = weights ? weights[i] : 1;
     const OrigSpaceFace *src = sources[i];
 
-    for (j = 0; j < 4; ++j) {
+    for (j = 0; j < 4; j++) {
       if (sub_weights) {
-        for (k = 0; k < 4; ++k, ++sub_weight) {
+        for (k = 0; k < 4; k++, sub_weight++) {
           madd_v2_v2fl(uv[j], src->uv[k], (*sub_weight) * weight);
         }
       }
@@ -558,7 +558,7 @@ static void layerSwap_origspace_face(void *data, const int *corner_indices)
   float uv[4][2];
   int j;
 
-  for (j = 0; j < 4; ++j) {
+  for (j = 0; j < 4; j++) {
     copy_v2_v2(uv[j], osf->uv[corner_indices[j]]);
   }
   memcpy(osf->uv, uv, sizeof(osf->uv));
@@ -613,7 +613,7 @@ static void layerCopy_mdisps(const void *source, void *dest, int count)
   const MDisps *s = source;
   MDisps *d = dest;
 
-  for (i = 0; i < count; ++i) {
+  for (i = 0; i < count; i++) {
     if (s[i].disps) {
       d[i].disps = MEM_dupallocN(s[i].disps);
       d[i].hidden = MEM_dupallocN(s[i].hidden);
@@ -634,7 +634,7 @@ static void layerFree_mdisps(void *data, int count, int UNUSED(size))
   int i;
   MDisps *d = data;
 
-  for (i = 0; i < count; ++i) {
+  for (i = 0; i < count; i++) {
     if (d[i].disps) {
       MEM_freeN(d[i].disps);
     }
@@ -653,7 +653,7 @@ static int layerRead_mdisps(CDataFile *cdf, void *data, int count)
   MDisps *d = data;
   int i;
 
-  for (i = 0; i < count; ++i) {
+  for (i = 0; i < count; i++) {
     if (!d[i].disps) {
       d[i].disps = MEM_calloc_arrayN(d[i].totdisp, 3 * sizeof(float), "mdisps read");
     }
@@ -672,7 +672,7 @@ static int layerWrite_mdisps(CDataFile *cdf, const void *data, int count)
   const MDisps *d = data;
   int i;
 
-  for (i = 0; i < count; ++i) {
+  for (i = 0; i < count; i++) {
     if (!cdf_write_data(cdf, d[i].totdisp * 3 * sizeof(float), d[i].disps)) {
       CLOG_ERROR(&LOG, "failed to write multires displacement %d/%d %d", i, count, d[i].totdisp);
       return 0;
@@ -688,7 +688,7 @@ static size_t layerFilesize_mdisps(CDataFile *UNUSED(cdf), const void *data, int
   size_t size = 0;
   int i;
 
-  for (i = 0; i < count; ++i) {
+  for (i = 0; i < count; i++) {
     size += d[i].totdisp * 3 * sizeof(float);
   }
 
@@ -701,7 +701,7 @@ static void layerCopy_grid_paint_mask(const void *source, void *dest, int count)
   const GridPaintMask *s = source;
   GridPaintMask *d = dest;
 
-  for (i = 0; i < count; ++i) {
+  for (i = 0; i < count; i++) {
     if (s[i].data) {
       d[i].data = MEM_dupallocN(s[i].data);
       d[i].level = s[i].level;
@@ -718,7 +718,7 @@ static void layerFree_grid_paint_mask(void *data, int count, int UNUSED(size))
   int i;
   GridPaintMask *gpm = data;
 
-  for (i = 0; i < count; ++i) {
+  for (i = 0; i < count; i++) {
     if (gpm[i].data) {
       MEM_freeN(gpm[i].data);
     }
@@ -887,7 +887,7 @@ static void layerInterp_mloopcol(
   } col = {0};
 
   const float *sub_weight = sub_weights;
-  for (int i = 0; i < count; ++i) {
+  for (int i = 0; i < count; i++) {
     float weight = weights ? weights[i] : 1;
     const MLoopCol *src = sources[i];
     if (sub_weights) {
@@ -1128,13 +1128,13 @@ static void layerInterp_mcol(
   }
 
   sub_weight = sub_weights;
-  for (i = 0; i < count; ++i) {
+  for (i = 0; i < count; i++) {
     float weight = weights ? weights[i] : 1;
 
-    for (j = 0; j < 4; ++j) {
+    for (j = 0; j < 4; j++) {
       if (sub_weights) {
         const MCol *src = sources[i];
-        for (k = 0; k < 4; ++k, ++sub_weight, ++src) {
+        for (k = 0; k < 4; k++, sub_weight++, src++) {
           const float w = (*sub_weight) * weight;
           col[j].a += src->a * w;
           col[j].r += src->r * w;
@@ -1153,7 +1153,7 @@ static void layerInterp_mcol(
   }
 
   /* Delay writing to the destination in case dest is in sources. */
-  for (j = 0; j < 4; ++j) {
+  for (j = 0; j < 4; j++) {
 
     /* Subdivide smooth or fractal can cause problems without clamping
      * although weights should also not cause this situation */
@@ -1170,7 +1170,7 @@ static void layerSwap_mcol(void *data, const int *corner_indices)
   MCol col[4];
   int j;
 
-  for (j = 0; j < 4; ++j) {
+  for (j = 0; j < 4; j++) {
     col[j] = mcol[corner_indices[j]];
   }
 
@@ -1210,12 +1210,12 @@ static void layerInterp_bweight(const void **sources,
   f = 0.0f;
 
   if (weights) {
-    for (i = 0; i < count; ++i) {
+    for (i = 0; i < count; i++) {
       f += *in[i] * weights[i];
     }
   }
   else {
-    for (i = 0; i < count; ++i) {
+    for (i = 0; i < count; i++) {
       f += *in[i];
     }
   }
@@ -1241,12 +1241,12 @@ static void layerInterp_shapekey(const void **sources,
   zero_v3(co);
 
   if (weights) {
-    for (i = 0; i < count; ++i) {
+    for (i = 0; i < count; i++) {
       madd_v3_v3fl(co, in[i], weights[i]);
     }
   }
   else {
-    for (i = 0; i < count; ++i) {
+    for (i = 0; i < count; i++) {
       add_v3_v3(co, in[i]);
     }
   }
@@ -1862,7 +1862,7 @@ bool CustomData_merge(const struct CustomData *source,
   int number = 0, maxnumber = -1;
   bool changed = false;
 
-  for (i = 0; i < source->totlayer; ++i) {
+  for (i = 0; i < source->totlayer; i++) {
     layer = &source->layers[i];
     /*typeInfo = layerType_getInfo(layer->type);*/ /*UNUSED*/
 
@@ -1934,7 +1934,7 @@ bool CustomData_merge(const struct CustomData *source,
 void CustomData_realloc(CustomData *data, int totelem)
 {
   int i;
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     CustomDataLayer *layer = &data->layers[i];
     const LayerTypeInfo *typeInfo;
     if (layer->flag & CD_FLAG_NOFREE) {
@@ -1995,7 +1995,7 @@ void CustomData_free(CustomData *data, int totelem)
 {
   int i;
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     customData_free_layer__internal(&data->layers[i], totelem);
   }
 
@@ -2011,7 +2011,7 @@ void CustomData_free_typemask(struct CustomData *data, int totelem, CustomDataMa
 {
   int i;
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     CustomDataLayer *layer = &data->layers[i];
     if (!(mask & CD_TYPE_AS_MASK(layer->type))) {
       continue;
@@ -2032,7 +2032,7 @@ static void customData_update_offsets(CustomData *data)
   const LayerTypeInfo *typeInfo;
   int i, offset = 0;
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     typeInfo = layerType_getInfo(data->layers[i].type);
 
     data->layers[i].offset = offset;
@@ -2048,7 +2048,7 @@ static int CustomData_get_layer_index__notypemap(const CustomData *data, int typ
 {
   int i;
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       return i;
     }
@@ -2082,7 +2082,7 @@ int CustomData_get_named_layer_index(const CustomData *data, int type, const cha
 {
   int i;
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       if (STREQ(data->layers[i].name, name)) {
         return i;
@@ -2164,7 +2164,7 @@ void CustomData_set_layer_active(CustomData *data, int type, int n)
 {
   int i;
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       data->layers[i].active = n;
     }
@@ -2175,7 +2175,7 @@ void CustomData_set_layer_render(CustomData *data, int type, int n)
 {
   int i;
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       data->layers[i].active_rnd = n;
     }
@@ -2186,7 +2186,7 @@ void CustomData_set_layer_clone(CustomData *data, int type, int n)
 {
   int i;
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       data->layers[i].active_clone = n;
     }
@@ -2197,7 +2197,7 @@ void CustomData_set_layer_stencil(CustomData *data, int type, int n)
 {
   int i;
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       data->layers[i].active_mask = n;
     }
@@ -2210,7 +2210,7 @@ void CustomData_set_layer_active_index(CustomData *data, int type, int n)
 {
   int i;
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       data->layers[i].active = n - i;
     }
@@ -2221,7 +2221,7 @@ void CustomData_set_layer_render_index(CustomData *data, int type, int n)
 {
   int i;
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       data->layers[i].active_rnd = n - i;
     }
@@ -2232,7 +2232,7 @@ void CustomData_set_layer_clone_index(CustomData *data, int type, int n)
 {
   int i;
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       data->layers[i].active_clone = n - i;
     }
@@ -2243,7 +2243,7 @@ void CustomData_set_layer_stencil_index(CustomData *data, int type, int n)
 {
   int i;
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       data->layers[i].active_mask = n - i;
     }
@@ -2254,7 +2254,7 @@ void CustomData_set_layer_flag(struct CustomData *data, int type, int flag)
 {
   int i;
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       data->layers[i].flag |= flag;
     }
@@ -2265,7 +2265,7 @@ void CustomData_clear_layer_flag(struct CustomData *data, int type, int flag)
 {
   const int nflag = ~flag;
 
-  for (int i = 0; i < data->totlayer; ++i) {
+  for (int i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       data->layers[i].flag &= nflag;
     }
@@ -2355,7 +2355,7 @@ static CustomDataLayer *customData_add_layer__internal(CustomData *data,
   data->totlayer++;
 
   /* keep layers ordered by type */
-  for (; index > 0 && data->layers[index - 1].type > type; --index) {
+  for (; index > 0 && data->layers[index - 1].type > type; index--) {
     data->layers[index] = data->layers[index - 1];
   }
 
@@ -2447,7 +2447,7 @@ bool CustomData_free_layer(CustomData *data, int type, int totelem, int index)
 
   customData_free_layer__internal(&data->layers[index], totelem);
 
-  for (i = index + 1; i < data->totlayer; ++i) {
+  for (i = index + 1; i < data->totlayer; i++) {
     data->layers[i - 1] = data->layers[i];
   }
 
@@ -2628,7 +2628,7 @@ void CustomData_free_temporary(CustomData *data, int totelem)
   int i, j;
   bool changed = false;
 
-  for (i = 0, j = 0; i < data->totlayer; ++i) {
+  for (i = 0, j = 0; i < data->totlayer; i++) {
     layer = &data->layers[i];
 
     if (i != j) {
@@ -2660,7 +2660,7 @@ void CustomData_set_only_copy(const struct CustomData *data, CustomDataMask mask
 {
   int i;
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     if (!(mask & CD_TYPE_AS_MASK(data->layers[i].type))) {
       data->layers[i].flag |= CD_FLAG_NOCOPY;
     }
@@ -2725,7 +2725,7 @@ void CustomData_copy_data_named(
   int src_i, dest_i;
 
   /* copies a layer at a time */
-  for (src_i = 0; src_i < source->totlayer; ++src_i) {
+  for (src_i = 0; src_i < source->totlayer; src_i++) {
 
     dest_i = CustomData_get_named_layer_index(
         dest, source->layers[src_i].type, source->layers[src_i].name);
@@ -2744,7 +2744,7 @@ void CustomData_copy_data(
 
   /* copies a layer at a time */
   dest_i = 0;
-  for (src_i = 0; src_i < source->totlayer; ++src_i) {
+  for (src_i = 0; src_i < source->totlayer; src_i++) {
 
     /* find the first dest layer with type >= the source type
      * (this should work because layers are ordered by type)
@@ -2800,7 +2800,7 @@ void CustomData_free_elem(CustomData *data, int index, int count)
   int i;
   const LayerTypeInfo *typeInfo;
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     if (!(data->layers[i].flag & CD_FLAG_NOFREE)) {
       typeInfo = layerType_getInfo(data->layers[i].type);
 
@@ -2835,7 +2835,7 @@ void CustomData_interp(const CustomData *source,
 
   /* interpolates a layer at a time */
   dest_i = 0;
-  for (src_i = 0; src_i < source->totlayer; ++src_i) {
+  for (src_i = 0; src_i < source->totlayer; src_i++) {
     const LayerTypeInfo *typeInfo = layerType_getInfo(source->layers[src_i].type);
     if (!typeInfo->interp) {
       continue;
@@ -2857,7 +2857,7 @@ void CustomData_interp(const CustomData *source,
     if (dest->layers[dest_i].type == source->layers[src_i].type) {
       void *src_data = source->layers[src_i].data;
 
-      for (j = 0; j < count; ++j) {
+      for (j = 0; j < count; j++) {
         sources[j] = POINTER_OFFSET(src_data, (size_t)src_indices[j] * typeInfo->size);
       }
 
@@ -2893,7 +2893,7 @@ void CustomData_swap_corners(struct CustomData *data, int index, const int *corn
   const LayerTypeInfo *typeInfo;
   int i;
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     typeInfo = layerType_getInfo(data->layers[i].type);
 
     if (typeInfo->swap) {
@@ -2916,7 +2916,7 @@ void CustomData_swap(struct CustomData *data, const int index_a, const int index
     return;
   }
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     const LayerTypeInfo *typeInfo = layerType_getInfo(data->layers[i].type);
     const size_t size = typeInfo->size;
     const size_t offset_a = size * index_a;
@@ -3392,7 +3392,7 @@ void CustomData_bmesh_free_block(CustomData *data, void **block)
     return;
   }
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     if (!(data->layers[i].flag & CD_FLAG_NOFREE)) {
       typeInfo = layerType_getInfo(data->layers[i].type);
 
@@ -3422,7 +3422,7 @@ void CustomData_bmesh_free_block_data(CustomData *data, void *block)
     return;
   }
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     if (!(data->layers[i].flag & CD_FLAG_NOFREE)) {
       typeInfo = layerType_getInfo(data->layers[i].type);
 
@@ -3476,7 +3476,7 @@ void CustomData_bmesh_set_default(CustomData *data, void **block)
     CustomData_bmesh_alloc_block(data, block);
   }
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     CustomData_bmesh_set_default_n(data, block, i);
   }
 }
@@ -3498,7 +3498,7 @@ void CustomData_bmesh_copy_data(const CustomData *source,
 
   /* copies a layer at a time */
   dest_i = 0;
-  for (src_i = 0; src_i < source->totlayer; ++src_i) {
+  for (src_i = 0; src_i < source->totlayer; src_i++) {
 
     /* find the first dest layer with type >= the source type
      * (this should work because layers are ordered by type)
@@ -3609,7 +3609,7 @@ bool CustomData_has_math(const struct CustomData *data)
   int i;
 
   /* interpolates a layer at a time */
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     if (CustomData_layer_has_math(data, i)) {
       return true;
     }
@@ -3624,7 +3624,7 @@ bool CustomData_bmesh_has_free(const struct CustomData *data)
   const LayerTypeInfo *typeInfo;
   int i;
 
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     if (!(data->layers[i].flag & CD_FLAG_NOFREE)) {
       typeInfo = layerType_getInfo(data->layers[i].type);
       if (typeInfo->free) {
@@ -3640,7 +3640,7 @@ bool CustomData_has_interp(const struct CustomData *data)
   int i;
 
   /* interpolates a layer at a time */
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     if (CustomData_layer_has_interp(data, i)) {
       return true;
     }
@@ -3652,7 +3652,7 @@ bool CustomData_has_interp(const struct CustomData *data)
 bool CustomData_has_referenced(const struct CustomData *data)
 {
   int i;
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     if (data->layers[i].flag & CD_FLAG_NOFREE) {
       return true;
     }
@@ -3832,11 +3832,11 @@ void CustomData_bmesh_interp(CustomData *data,
   }
 
   /* interpolates a layer at a time */
-  for (i = 0; i < data->totlayer; ++i) {
+  for (i = 0; i < data->totlayer; i++) {
     CustomDataLayer *layer = &data->layers[i];
     const LayerTypeInfo *typeInfo = layerType_getInfo(layer->type);
     if (typeInfo->interp) {
-      for (j = 0; j < count; ++j) {
+      for (j = 0; j < count; j++) {
         sources[j] = POINTER_OFFSET(src_blocks[j], layer->offset);
       }
       CustomData_bmesh_interp_n(
@@ -3869,7 +3869,7 @@ void CustomData_to_bmesh_block(const CustomData *source,
 
   /* copies a layer at a time */
   dest_i = 0;
-  for (src_i = 0; src_i < source->totlayer; ++src_i) {
+  for (src_i = 0; src_i < source->totlayer; src_i++) {
 
     /* find the first dest layer with type >= the source type
      * (this should work because layers are ordered by type)
@@ -3927,7 +3927,7 @@ void CustomData_from_bmesh_block(const CustomData *source,
 
   /* copies a layer at a time */
   dest_i = 0;
-  for (src_i = 0; src_i < source->totlayer; ++src_i) {
+  for (src_i = 0; src_i < source->totlayer; src_i++) {
 
     /* find the first dest layer with type >= the source type
      * (this should work because layers are ordered by type)
@@ -4198,7 +4198,7 @@ bool CustomData_verify_versions(struct CustomData *data, int index)
   }
 
   if (!keeplayer) {
-    for (i = index + 1; i < data->totlayer; ++i) {
+    for (i = index + 1; i < data->totlayer; i++) {
       data->layers[i - 1] = data->layers[i];
     }
     data->totlayer--;