Cleanup: reduce variable scope

19 files changed, 238 insertions, 477 deletions

diff --git a/source/blender/blenfont/intern/blf.c b/source/blender/blenfont/intern/blf.c
index c5c2bc3f3ba..547112ecf66 100644
--- a/source/blender/blenfont/intern/blf.c
+++ b/source/blender/blenfont/intern/blf.c
@@ -92,9 +92,7 @@ static FontBLF *blf_get(int fontid)
 
 int BLF_init(void)
 {
-  int i;
-
-  for (i = 0; i < BLF_MAX_FONT; i++) {
+  for (int i = 0; i < BLF_MAX_FONT; i++) {
     global_font[i] = NULL;
   }
 
@@ -111,11 +109,8 @@ void BLF_default_dpi(int dpi)
 
 void BLF_exit(void)
 {
-  FontBLF *font;
-  int i;
-
-  for (i = 0; i < BLF_MAX_FONT; i++) {
-    font = global_font[i];
+  for (int i = 0; i < BLF_MAX_FONT; i++) {
+    FontBLF *font = global_font[i];
     if (font) {
       blf_font_free(font);
       global_font[i] = NULL;
@@ -127,11 +122,8 @@ void BLF_exit(void)
 
 void BLF_cache_clear(void)
 {
-  FontBLF *font;
-  int i;
-
-  for (i = 0; i < BLF_MAX_FONT; i++) {
-    font = global_font[i];
+  for (int i = 0; i < BLF_MAX_FONT; i++) {
+    FontBLF *font = global_font[i];
     if (font) {
       blf_glyph_cache_clear(font);
       blf_kerning_cache_clear(font);
@@ -141,11 +133,8 @@ void BLF_cache_clear(void)
 
 static int blf_search(const char *name)
 {
-  FontBLF *font;
-  int i;
-
-  for (i = 0; i < BLF_MAX_FONT; i++) {
-    font = global_font[i];
+  for (int i = 0; i < BLF_MAX_FONT; i++) {
+    FontBLF *font = global_font[i];
     if (font && (STREQ(font->name, name))) {
       return i;
     }
@@ -156,9 +145,7 @@ static int blf_search(const char *name)
 
 static int blf_search_available(void)
 {
-  int i;
-
-  for (i = 0; i < BLF_MAX_FONT; i++) {
+  for (int i = 0; i < BLF_MAX_FONT; i++) {
     if (!global_font[i]) {
       return i;
     }
@@ -192,13 +179,10 @@ bool BLF_has_glyph(int fontid, unsigned int unicode)
 
 int BLF_load(const char *name)
 {
-  FontBLF *font;
-  int i;
-
   /* check if we already load this font. */
-  i = blf_search(name);
+  int i = blf_search(name);
   if (i >= 0) {
-    font = global_font[i];
+    FontBLF *font = global_font[i];
     font->reference_count++;
     return i;
   }
@@ -208,26 +192,22 @@ int BLF_load(const char *name)
 
 int BLF_load_unique(const char *name)
 {
-  FontBLF *font;
-  char *filename;
-  int i;
-
   /* Don't search in the cache!! make a new
    * object font, this is for keep fonts threads safe.
    */
-  i = blf_search_available();
+  int i = blf_search_available();
   if (i == -1) {
     printf("Too many fonts!!!\n");
     return -1;
   }
 
-  filename = blf_dir_search(name);
+  char *filename = blf_dir_search(name);
   if (!filename) {
     printf("Can't find font: %s\n", name);
     return -1;
   }
 
-  font = blf_font_new(name, filename);
+  FontBLF *font = blf_font_new(name, filename);
   MEM_freeN(filename);
 
   if (!font) {
@@ -251,9 +231,7 @@ void BLF_metrics_attach(int fontid, unsigned char *mem, int mem_size)
 
 int BLF_load_mem(const char *name, const unsigned char *mem, int mem_size)
 {
-  int i;
-
-  i = blf_search(name);
+  int i = blf_search(name);
   if (i >= 0) {
     /*font = global_font[i];*/ /*UNUSED*/
     return i;
@@ -263,14 +241,11 @@ int BLF_load_mem(const char *name, const unsigned char *mem, int mem_size)
 
 int BLF_load_mem_unique(const char *name, const unsigned char *mem, int mem_size)
 {
-  FontBLF *font;
-  int i;
-
   /*
    * Don't search in the cache, make a new object font!
    * this is to keep the font thread safe.
    */
-  i = blf_search_available();
+  int i = blf_search_available();
   if (i == -1) {
     printf("Too many fonts!!!\n");
     return -1;
@@ -281,7 +256,7 @@ int BLF_load_mem_unique(const char *name, const unsigned char *mem, int mem_size
     return -1;
   }
 
-  font = blf_font_new_from_mem(name, mem, mem_size);
+  FontBLF *font = blf_font_new_from_mem(name, mem, mem_size);
   if (!font) {
     printf("Can't load font: %s from memory!!\n", name);
     return -1;
@@ -294,11 +269,8 @@ int BLF_load_mem_unique(const char *name, const unsigned char *mem, int mem_size
 
 void BLF_unload(const char *name)
 {
-  FontBLF *font;
-  int i;
-
-  for (i = 0; i < BLF_MAX_FONT; i++) {
-    font = global_font[i];
+  for (int i = 0; i < BLF_MAX_FONT; i++) {
+    FontBLF *font = global_font[i];
 
     if (font && (STREQ(font->name, name))) {
       BLI_assert(font->reference_count > 0);
diff --git a/source/blender/blenfont/intern/blf_dir.c b/source/blender/blenfont/intern/blf_dir.c
index 9603470615d..51d3849aa48 100644
--- a/source/blender/blenfont/intern/blf_dir.c
+++ b/source/blender/blenfont/intern/blf_dir.c
@@ -115,11 +115,8 @@ char **BLF_dir_get(int *ndir)
 
 void BLF_dir_free(char **dirs, int count)
 {
-  char *path;
-  int i;
-
-  for (i = 0; i < count; i++) {
-    path = dirs[i];
+  for (int i = 0; i < count; i++) {
+    char *path = dirs[i];
     MEM_freeN(path);
   }
   MEM_freeN(dirs);
diff --git a/source/blender/blenfont/intern/blf_font.c b/source/blender/blenfont/intern/blf_font.c
index 1b27b6dd4c1..1501ee07b66 100644
--- a/source/blender/blenfont/intern/blf_font.c
+++ b/source/blender/blenfont/intern/blf_font.c
@@ -316,8 +316,7 @@ static GlyphBLF **blf_font_ensure_ascii_table(FontBLF *font, GlyphCacheBLF *gc)
   /* build ascii on demand */
   if (glyph_ascii_table['0'] == NULL) {
     GlyphBLF *g;
-    unsigned int i;
-    for (i = 0; i < 256; i++) {
+    for (uint i = 0; i < 256; i++) {
       g = blf_glyph_search(gc, i);
       if (!g) {
         FT_UInt glyph_index = FT_Get_Char_Index(font->face, i);
diff --git a/source/blender/blenfont/intern/blf_glyph.c b/source/blender/blenfont/intern/blf_glyph.c
index 8e74d5bba7c..f3c5c057dec 100644
--- a/source/blender/blenfont/intern/blf_glyph.c
+++ b/source/blender/blenfont/intern/blf_glyph.c
@@ -205,9 +205,7 @@ void blf_glyph_cache_clear(FontBLF *font)
 void blf_glyph_cache_free(GlyphCacheBLF *gc)
 {
   GlyphBLF *g;
-  unsigned int i;
-
-  for (i = 0; i < ARRAY_SIZE(gc->bucket); i++) {
+  for (uint i = 0; i < ARRAY_SIZE(gc->bucket); i++) {
     while ((g = BLI_pophead(&gc->bucket[i]))) {
       blf_glyph_free(g);
     }
diff --git a/source/blender/blenfont/intern/blf_thumbs.c b/source/blender/blenfont/intern/blf_thumbs.c
index 6aa39e3aa71..3153a55b697 100644
--- a/source/blender/blenfont/intern/blf_thumbs.c
+++ b/source/blender/blenfont/intern/blf_thumbs.c
@@ -67,7 +67,6 @@ void BLF_thumb_preview(const char *filename,
 
   FontBLF *font;
   GlyphCacheBLF *gc;
-  int i;
 
   /* Create a new blender font obj and fill it with default values */
   font = blf_font_new("thumb_font", filename);
@@ -91,7 +90,7 @@ void BLF_thumb_preview(const char *filename,
 
   blf_draw_buffer__start(font);
 
-  for (i = 0; i < draw_str_lines; i++) {
+  for (int i = 0; i < draw_str_lines; i++) {
     const char *draw_str_i18n = i18n_draw_str[i] != NULL ? i18n_draw_str[i] : draw_str[i];
     const size_t draw_str_i18n_len = strlen(draw_str_i18n);
     int draw_str_i18n_nbr = 0;
diff --git a/source/blender/blenkernel/intern/CCGSubSurf.c b/source/blender/blenkernel/intern/CCGSubSurf.c
index e3543290b65..ec2fb5f5bdb 100644
--- a/source/blender/blenkernel/intern/CCGSubSurf.c
+++ b/source/blender/blenkernel/intern/CCGSubSurf.c
@@ -72,8 +72,7 @@ static CCGVert *_vert_new(CCGVertHDL vHDL, CCGSubSurf *ss)
 }
 static void _vert_remEdge(CCGVert *v, CCGEdge *e)
 {
-  int i;
-  for (i = 0; i < v->numEdges; i++) {
+  for (int i = 0; i < v->numEdges; i++) {
     if (v->edges[i] == e) {
       v->edges[i] = v->edges[--v->numEdges];
       break;
@@ -82,8 +81,7 @@ static void _vert_remEdge(CCGVert *v, CCGEdge *e)
 }
 static void _vert_remFace(CCGVert *v, CCGFace *f)
 {
-  int i;
-  for (i = 0; i < v->numFaces; i++) {
+  for (int i = 0; i < v->numFaces; i++) {
     if (v->faces[i] == f) {
       v->faces[i] = v->faces[--v->numFaces];
       break;
@@ -104,8 +102,7 @@ static void _vert_addFace(CCGVert *v, CCGFace *f, CCGSubSurf *ss)
 }
 static CCGEdge *_vert_findEdgeTo(const CCGVert *v, const CCGVert *vQ)
 {
-  int i;
-  for (i = 0; i < v->numEdges; i++) {
+  for (int i = 0; i < v->numEdges; i++) {
     CCGEdge *e = v->edges[v->numEdges - 1 - i];  // XXX, note reverse
     if ((e->v0 == v && e->v1 == vQ) || (e->v1 == v && e->v0 == vQ)) {
       return e;
@@ -155,8 +152,7 @@ static CCGEdge *_edge_new(CCGEdgeHDL eHDL, CCGVert *v0, CCGVert *v1, float creas
 }
 static void _edge_remFace(CCGEdge *e, CCGFace *f)
 {
-  int i;
-  for (i = 0; i < e->numFaces; i++) {
+  for (int i = 0; i < e->numFaces; i++) {
     if (e->faces[i] == f) {
       e->faces[i] = e->faces[--e->numFaces];
       break;
@@ -205,13 +201,12 @@ static CCGFace *_face_new(
       sizeof(CCGFace) + sizeof(CCGVert *) * numVerts + sizeof(CCGEdge *) * numVerts +
           ss->meshIFC.vertDataSize * num_face_data + ss->meshIFC.faceUserSize);
   byte *userData;
-  int i;
 
   f->numVerts = numVerts;
   f->fHDL = fHDL;
   f->flags = 0;
 
-  for (i = 0; i < numVerts; i++) {
+  for (int i = 0; i < numVerts; i++) {
     FACE_getVerts(f)[i] = verts[i];
     FACE_getEdges(f)[i] = edges[i];
     _vert_addFace(verts[i], f, ss);
@@ -1418,9 +1413,7 @@ CCGEdge *ccgSubSurf_getFaceEdge(CCGFace *f, int index)
 }
 int ccgSubSurf_getFaceEdgeIndex(CCGFace *f, CCGEdge *e)
 {
-  int i;
-
-  for (i = 0; i < f->numVerts; i++) {
+  for (int i = 0; i < f->numVerts; i++) {
     if (FACE_getEdges(f)[i] == e) {
       return i;
     }
diff --git a/source/blender/blenkernel/intern/CCGSubSurf_inline.h b/source/blender/blenkernel/intern/CCGSubSurf_inline.h
index 91a7129b433..4681602c071 100644
--- a/source/blender/blenkernel/intern/CCGSubSurf_inline.h
+++ b/source/blender/blenkernel/intern/CCGSubSurf_inline.h
@@ -142,8 +142,7 @@ BLI_INLINE float *ccg_face_getIFNo(
 
 BLI_INLINE int ccg_face_getVertIndex(CCGFace *f, CCGVert *v)
 {
-  int i;
-  for (i = 0; i < f->numVerts; i++) {
+  for (int i = 0; i < f->numVerts; i++) {
     if (FACE_getVerts(f)[i] == v) {
       return i;
     }
@@ -153,8 +152,7 @@ BLI_INLINE int ccg_face_getVertIndex(CCGFace *f, CCGVert *v)
 
 BLI_INLINE int ccg_face_getEdgeIndex(CCGFace *f, CCGEdge *e)
 {
-  int i;
-  for (i = 0; i < f->numVerts; i++) {
+  for (int i = 0; i < f->numVerts; i++) {
     if (FACE_getEdges(f)[i] == e) {
       return i;
     }
@@ -215,8 +213,7 @@ BLI_INLINE void Normalize(float no[3])
 
 BLI_INLINE bool VertDataEqual(const float a[], const float b[], const CCGSubSurf *ss)
 {
-  int i;
-  for (i = 0; i < ss->meshIFC.numLayers; i++) {
+  for (int i = 0; i < ss->meshIFC.numLayers; i++) {
     if (a[i] != b[i]) {
       return false;
     }
@@ -231,32 +228,28 @@ BLI_INLINE void VertDataZero(float v[], const CCGSubSurf *ss)
 
 BLI_INLINE void VertDataCopy(float dst[], const float src[], const CCGSubSurf *ss)
 {
-  int i;
-  for (i = 0; i < ss->meshIFC.numLayers; i++) {
+  for (int i = 0; i < ss->meshIFC.numLayers; i++) {
     dst[i] = src[i];
   }
 }
 
 BLI_INLINE void VertDataAdd(float a[], const float b[], const CCGSubSurf *ss)
 {
-  int i;
-  for (i = 0; i < ss->meshIFC.numLayers; i++) {
+  for (int i = 0; i < ss->meshIFC.numLayers; i++) {
     a[i] += b[i];
   }
 }
 
 BLI_INLINE void VertDataSub(float a[], const float b[], const CCGSubSurf *ss)
 {
-  int i;
-  for (i = 0; i < ss->meshIFC.numLayers; i++) {
+  for (int i = 0; i < ss->meshIFC.numLayers; i++) {
     a[i] -= b[i];
   }
 }
 
 BLI_INLINE void VertDataMulN(float v[], float f, const CCGSubSurf *ss)
 {
-  int i;
-  for (i = 0; i < ss->meshIFC.numLayers; i++) {
+  for (int i = 0; i < ss->meshIFC.numLayers; i++) {
     v[i] *= f;
   }
 }
@@ -268,8 +261,7 @@ BLI_INLINE void VertDataAvg4(float v[],
                              const float d[],
                              const CCGSubSurf *ss)
 {
-  int i;
-  for (i = 0; i < ss->meshIFC.numLayers; i++) {
+  for (int i = 0; i < ss->meshIFC.numLayers; i++) {
     v[i] = (a[i] + b[i] + c[i] + d[i]) * 0.25f;
   }
 }
diff --git a/source/blender/blenkernel/intern/CCGSubSurf_legacy.c b/source/blender/blenkernel/intern/CCGSubSurf_legacy.c
index b723d39ca08..22a4bf18f7f 100644
--- a/source/blender/blenkernel/intern/CCGSubSurf_legacy.c
+++ b/source/blender/blenkernel/intern/CCGSubSurf_legacy.c
@@ -49,8 +49,7 @@ static int _edge_isBoundary(const CCGEdge *e)
 
 static bool _vert_isBoundary(const CCGVert *v)
 {
-  int i;
-  for (i = 0; i < v->numEdges; i++) {
+  for (int i = 0; i < v->numEdges; i++) {
     if (_edge_isBoundary(v->edges[i])) {
       return true;
     }
diff --git a/source/blender/blenkernel/intern/appdir.c b/source/blender/blenkernel/intern/appdir.c
index 2cc715464ad..236f1391443 100644
--- a/source/blender/blenkernel/intern/appdir.c
+++ b/source/blender/blenkernel/intern/appdir.c
@@ -746,8 +746,6 @@ bool BKE_appdir_program_python_search(char *fullpath,
       python_ver,
       basename,
   };
-  int i;
-
   bool is_found = false;
 
   BLI_snprintf(python_ver, sizeof(python_ver), "%s%d.%d", basename, version_major, version_minor);
@@ -756,7 +754,7 @@ bool BKE_appdir_program_python_search(char *fullpath,
     const char *python_bin_dir = BKE_appdir_folder_id(BLENDER_SYSTEM_PYTHON, "bin");
     if (python_bin_dir) {
 
-      for (i = 0; i < ARRAY_SIZE(python_names); i++) {
+      for (int i = 0; i < ARRAY_SIZE(python_names); i++) {
         BLI_join_dirfile(fullpath, fullpath_len, python_bin_dir, python_names[i]);
 
         if (
@@ -774,7 +772,7 @@ bool BKE_appdir_program_python_search(char *fullpath,
   }
 
   if (is_found == false) {
-    for (i = 0; i < ARRAY_SIZE(python_names); i++) {
+    for (int i = 0; i < ARRAY_SIZE(python_names); i++) {
       if (BLI_path_program_search(fullpath, fullpath_len, python_names[i])) {
         is_found = true;
         break;
diff --git a/source/blender/blenkernel/intern/armature_update.c b/source/blender/blenkernel/intern/armature_update.c
index 97c717572bc..de00372c3ec 100644
--- a/source/blender/blenkernel/intern/armature_update.c
+++ b/source/blender/blenkernel/intern/armature_update.c
@@ -125,7 +125,6 @@ static void splineik_init_tree_from_pchan(Scene *UNUSED(scene),
   /* perform binding step if required */
   if ((ikData->flag & CONSTRAINT_SPLINEIK_BOUND) == 0) {
     float segmentLen = (1.0f / (float)segcount);
-    int i;
 
     /* setup new empty array for the points list */
     if (ikData->points) {
@@ -140,7 +139,7 @@ static void splineik_init_tree_from_pchan(Scene *UNUSED(scene),
     /* perform binding of the joints to parametric positions along the curve based
      * proportion of the total length that each bone occupies
      */
-    for (i = 0; i < segcount; i++) {
+    for (int i = 0; i < segcount; i++) {
       /* 'head' joints, traveling towards the root of the chain
        * - 2 methods; the one chosen depends on whether we've got usable lengths
        */
@@ -549,11 +548,9 @@ static void splineik_execute_tree(
 
   /* for each pose-tree, execute it if it is spline, otherwise just free it */
   while ((tree = pchan_root->siktree.first) != NULL) {
-    int i;
-
     /* Firstly, calculate the bone matrix the standard way,
      * since this is needed for roll control. */
-    for (i = tree->chainlen - 1; i >= 0; i--) {
+    for (int i = tree->chainlen - 1; i >= 0; i--) {
       BKE_pose_where_is_bone(depsgraph, scene, ob, tree->chain[i], ctime, 1);
     }
 
@@ -565,7 +562,7 @@ static void splineik_execute_tree(
        * - the chain is traversed in the opposite order to storage order (i.e. parent to children)
        *   so that dependencies are correct
        */
-      for (i = tree->chainlen - 1; i >= 0; i--) {
+      for (int i = tree->chainlen - 1; i >= 0; i--) {
         bPoseChannel *pchan = tree->chain[i];
         splineik_evaluate_bone(tree, ob, pchan, i, &state);
       }
diff --git a/source/blender/blenkernel/intern/bvhutils.c b/source/blender/blenkernel/intern/bvhutils.c
index bea8fdd5719..7440cc1f735 100644
--- a/source/blender/blenkernel/intern/bvhutils.c
+++ b/source/blender/blenkernel/intern/bvhutils.c
@@ -963,7 +963,6 @@ static BVHTree *bvhtree_from_mesh_faces_create_tree(float epsilon,
                                                     int faces_num_active)
 {
   BVHTree *tree = NULL;
-  int i;
 
   if (faces_num) {
     if (faces_mask) {
@@ -978,7 +977,7 @@ static BVHTree *bvhtree_from_mesh_faces_create_tree(float epsilon,
     tree = BLI_bvhtree_new(faces_num_active, epsilon, tree_type, axis);
     if (tree) {
       if (vert && face) {
-        for (i = 0; i < faces_num; i++) {
+        for (int i = 0; i < faces_num; i++) {
           float co[4][3];
           if (faces_mask && !BLI_BITMAP_TEST_BOOL(faces_mask, i)) {
             continue;
diff --git a/source/blender/blenkernel/intern/camera.c b/source/blender/blenkernel/intern/camera.c
index 45d44a6829e..eef2ab94078 100644
--- a/source/blender/blenkernel/intern/camera.c
+++ b/source/blender/blenkernel/intern/camera.c
@@ -527,9 +527,8 @@ typedef struct CameraViewFrameData {
 static void camera_to_frame_view_cb(const float co[3], void *user_data)
 {
   CameraViewFrameData *data = (CameraViewFrameData *)user_data;
-  unsigned int i;
 
-  for (i = 0; i < CAMERA_VIEWFRAME_NUM_PLANES; i++) {
+  for (uint i = 0; i < CAMERA_VIEWFRAME_NUM_PLANES; i++) {
     const float nd = dist_signed_squared_to_plane_v3(co, data->plane_tx[i]);
     CLAMP_MAX(data->dist_vals_sq[i], nd);
   }
@@ -548,7 +547,6 @@ static void camera_frame_fit_data_init(const Scene *scene,
                                        CameraViewFrameData *data)
 {
   float camera_rotmat_transposed_inversed[4][4];
-  unsigned int i;
 
   /* setup parameters */
   BKE_camera_params_init(params);
@@ -585,7 +583,7 @@ static void camera_frame_fit_data_init(const Scene *scene,
       NULL);
 
   /* Rotate planes and get normals from them */
-  for (i = 0; i < CAMERA_VIEWFRAME_NUM_PLANES; i++) {
+  for (uint i = 0; i < CAMERA_VIEWFRAME_NUM_PLANES; i++) {
     mul_m4_v4(camera_rotmat_transposed_inversed, data->plane_tx[i]);
     normalize_v3_v3(data->normal_tx[i], data->plane_tx[i]);
   }
@@ -606,7 +604,6 @@ static bool camera_frame_fit_calc_from_data(CameraParams *params,
                                             float *r_scale)
 {
   float plane_tx[CAMERA_VIEWFRAME_NUM_PLANES][4];
-  unsigned int i;
 
   if (data->tot <= 1) {
     return false;
@@ -620,7 +617,7 @@ static bool camera_frame_fit_calc_from_data(CameraParams *params,
     float scale_diff;
 
     /* apply the dist-from-plane's to the transformed plane points */
-    for (i = 0; i < CAMERA_VIEWFRAME_NUM_PLANES; i++) {
+    for (int i = 0; i < CAMERA_VIEWFRAME_NUM_PLANES; i++) {
       dists[i] = sqrtf_signed(data->dist_vals_sq[i]);
     }
 
@@ -648,7 +645,7 @@ static bool camera_frame_fit_calc_from_data(CameraParams *params,
   float plane_isect_pt_1[3], plane_isect_pt_2[3];
 
   /* apply the dist-from-plane's to the transformed plane points */
-  for (i = 0; i < CAMERA_VIEWFRAME_NUM_PLANES; i++) {
+  for (int i = 0; i < CAMERA_VIEWFRAME_NUM_PLANES; i++) {
     float co[3];
     mul_v3_v3fl(co, data->normal_tx[i], sqrtf_signed(data->dist_vals_sq[i]));
     plane_from_point_normal_v3(plane_tx[i], co, data->normal_tx[i]);
diff --git a/source/blender/blenkernel/intern/cloth.c b/source/blender/blenkernel/intern/cloth.c
index 62e2294345d..770a9379e2d 100644
--- a/source/blender/blenkernel/intern/cloth.c
+++ b/source/blender/blenkernel/intern/cloth.c
@@ -172,24 +172,18 @@ void cloth_init(ClothModifierData *clmd)
 
 static BVHTree *bvhtree_build_from_cloth(ClothModifierData *clmd, float epsilon)
 {
-  unsigned int i;
-  BVHTree *bvhtree;
-  Cloth *cloth;
-  ClothVertex *verts;
-  const MVertTri *vt;
-
   if (!clmd) {
     return NULL;
   }
 
-  cloth = clmd->clothObject;
+  Cloth *cloth = clmd->clothObject;
 
   if (!cloth) {
     return NULL;
   }
 
-  verts = cloth->verts;
-  vt = cloth->tri;
+  ClothVertex *verts = cloth->verts;
+  const MVertTri *vt = cloth->tri;
 
   /* in the moment, return zero if no faces there */
   if (!cloth->primitive_num) {
@@ -197,11 +191,11 @@ static BVHTree *bvhtree_build_from_cloth(ClothModifierData *clmd, float epsilon)
   }
 
   /* create quadtree with k=26 */
-  bvhtree = BLI_bvhtree_new(cloth->primitive_num, epsilon, 4, 26);
+  BVHTree *bvhtree = BLI_bvhtree_new(cloth->primitive_num, epsilon, 4, 26);
 
   /* fill tree */
   if (clmd->hairdata == NULL) {
-    for (i = 0; i < cloth->primitive_num; i++, vt++) {
+    for (int i = 0; i < cloth->primitive_num; i++, vt++) {
       float co[3][3];
 
       copy_v3_v3(co[0], verts[vt->tri[0]].xold);
@@ -214,7 +208,7 @@ static BVHTree *bvhtree_build_from_cloth(ClothModifierData *clmd, float epsilon)
   else {
     MEdge *edges = cloth->edges;
 
-    for (i = 0; i < cloth->primitive_num; i++) {
+    for (int i = 0; i < cloth->primitive_num; i++) {
       float co[2][3];
 
       copy_v3_v3(co[0], verts[edges[i].v1].xold);
@@ -997,8 +991,7 @@ BLI_INLINE void spring_verts_ordered_set(ClothSpring *spring, int v0, int v1)
 static void cloth_free_edgelist(LinkNodePair *edgelist, unsigned int mvert_num)
 {
   if (edgelist) {
-    unsigned int i;
-    for (i = 0; i < mvert_num; i++) {
+    for (uint i = 0; i < mvert_num; i++) {
       BLI_linklist_free(edgelist[i].list, NULL);
     }
 
diff --git a/source/blender/blenkernel/intern/collision.c b/source/blender/blenkernel/intern/collision.c
index 115980d577e..72525272254 100644
--- a/source/blender/blenkernel/intern/collision.c
+++ b/source/blender/blenkernel/intern/collision.c
@@ -114,13 +114,11 @@ BVHTree *bvhtree_build_from_mvert(const MVert *mvert,
                                   int tri_num,
                                   float epsilon)
 {
-  BVHTree *tree;
-  const MVertTri *vt;
-  int i;
-
-  tree = BLI_bvhtree_new(tri_num, epsilon, 4, 26);
+  BVHTree *tree = BLI_bvhtree_new(tri_num, epsilon, 4, 26);
 
   /* fill tree */
+  int i;
+  const MVertTri *vt;
   for (i = 0, vt = tri; i < tri_num; i++, vt++) {
     float co[3][3];
 
@@ -144,8 +142,6 @@ void bvhtree_update_from_mvert(BVHTree *bvhtree,
                                int tri_num,
                                bool moving)
 {
-  const MVertTri *vt;
-  int i;
 
   if ((bvhtree == NULL) || (mvert == NULL)) {
     return;
@@ -155,6 +151,8 @@ void bvhtree_update_from_mvert(BVHTree *bvhtree,
     moving = false;
   }
 
+  const MVertTri *vt;
+  int i;
   for (i = 0, vt = tri; i < tri_num; i++, vt++) {
     float co[3][3];
     bool ret;
diff --git a/source/blender/blenkernel/intern/colortools.c b/source/blender/blenkernel/intern/colortools.c
index 09731c15c0a..77a29bf41b8 100644
--- a/source/blender/blenkernel/intern/colortools.c
+++ b/source/blender/blenkernel/intern/colortools.c
@@ -347,8 +347,7 @@ void BKE_curvemap_reset(CurveMap *cuma, const rctf *clipr, int preset, int slope
       cuma->curve[1].y = 1;
       break;
     case CURVE_PRESET_MID9: {
-      int i;
-      for (i = 0; i < cuma->totpoint; i++) {
+      for (int i = 0; i < cuma->totpoint; i++) {
         cuma->curve[i].x = i / ((float)cuma->totpoint - 1);
         cuma->curve[i].y = 0.5;
       }
@@ -421,8 +420,7 @@ void BKE_curvemap_reset(CurveMap *cuma, const rctf *clipr, int preset, int slope
     const int num_points = cuma->totpoint * 2 - 1;
     CurveMapPoint *new_points = MEM_mallocN(num_points * sizeof(CurveMapPoint),
                                             "curve symmetric points");
-    int i;
-    for (i = 0; i < cuma->totpoint; i++) {
+    for (int i = 0; i < cuma->totpoint; i++) {
       const int src_last_point = cuma->totpoint - i - 1;
       const int dst_last_point = num_points - i - 1;
       new_points[i] = cuma->curve[src_last_point];
@@ -969,12 +967,9 @@ void BKE_curvemapping_changed_all(CurveMapping *cumap)
 /* table should be verified */
 float BKE_curvemap_evaluateF(const CurveMapping *cumap, const CurveMap *cuma, float value)
 {
-  float fi;
-  int i;
-
   /* index in table */
-  fi = (value - cuma->mintable) * cuma->range;
-  i = (int)fi;
+  float fi = (value - cuma->mintable) * cuma->range;
+  int i = (int)fi;
 
   /* fi is table float index and should check against table range i.e. [0.0 CM_TABLE] */
   if (fi < 0.0f || fi > CM_TABLE) {
diff --git a/source/blender/blenkernel/intern/constraint.c b/source/blender/blenkernel/intern/constraint.c
index ee386b3403b..e7fe10cf19c 100644
--- a/source/blender/blenkernel/intern/constraint.c
+++ b/source/blender/blenkernel/intern/constraint.c
@@ -3811,7 +3811,6 @@ static void transform_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *t
     float newloc[3], newrot[3][3], neweul[3], newsize[3];
     float dbuf[4], sval[3];
     float *const dvec = dbuf + 1;
-    int i;
 
     /* obtain target effect */
     switch (data->from) {
@@ -3854,7 +3853,7 @@ static void transform_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *t
 
     /* determine where in range current transforms lie */
     if (data->expo) {
-      for (i = 0; i < 3; i++) {
+      for (int i = 0; i < 3; i++) {
         if (from_max[i] - from_min[i]) {
           sval[i] = (dvec[i] - from_min[i]) / (from_max[i] - from_min[i]);
         }
@@ -3865,7 +3864,7 @@ static void transform_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *t
     }
     else {
       /* clamp transforms out of range */
-      for (i = 0; i < 3; i++) {
+      for (int i = 0; i < 3; i++) {
         CLAMP(dvec[i], from_min[i], from_max[i]);
         if (from_max[i] - from_min[i]) {
           sval[i] = (dvec[i] - from_min[i]) / (from_max[i] - from_min[i]);
@@ -3881,7 +3880,7 @@ static void transform_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *t
       case TRANS_SCALE:
         to_min = data->to_min_scale;
         to_max = data->to_max_scale;
-        for (i = 0; i < 3; i++) {
+        for (int i = 0; i < 3; i++) {
           newsize[i] = to_min[i] + (sval[(int)data->map[i]] * (to_max[i] - to_min[i]));
         }
         switch (data->mix_mode_scale) {
@@ -3897,7 +3896,7 @@ static void transform_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *t
       case TRANS_ROTATION:
         to_min = data->to_min_rot;
         to_max = data->to_max_rot;
-        for (i = 0; i < 3; i++) {
+        for (int i = 0; i < 3; i++) {
           neweul[i] = to_min[i] + (sval[(int)data->map[i]] * (to_max[i] - to_min[i]));
         }
         switch (data->mix_mode_rot) {
@@ -3924,7 +3923,7 @@ static void transform_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *t
       default:
         to_min = data->to_min;
         to_max = data->to_max;
-        for (i = 0; i < 3; i++) {
+        for (int i = 0; i < 3; i++) {
           newloc[i] = (to_min[i] + (sval[(int)data->map[i]] * (to_max[i] - to_min[i])));
         }
         switch (data->mix_mode_loc) {
diff --git a/source/blender/blenkernel/intern/crazyspace.c b/source/blender/blenkernel/intern/crazyspace.c
index e4f851819a8..01c05c62b70 100644
--- a/source/blender/blenkernel/intern/crazyspace.c
+++ b/source/blender/blenkernel/intern/crazyspace.c
@@ -194,30 +194,22 @@ void BKE_crazyspace_set_quats_mesh(Mesh *me,
                                    float (*mappedcos)[3],
                                    float (*quats)[4])
 {
-  int i;
-  MVert *mvert;
-  MLoop *mloop;
-  MPoly *mp;
-
-  mvert = me->mvert;
-  for (i = 0; i < me->totvert; i++, mvert++) {
+  MVert *mvert = me->mvert;
+  for (int i = 0; i < me->totvert; i++, mvert++) {
     mvert->flag &= ~ME_VERT_TMP_TAG;
   }
 
   /* first store two sets of tangent vectors in vertices, we derive it just from the face-edges */
   mvert = me->mvert;
-  mp = me->mpoly;
-  mloop = me->mloop;
-
-  for (i = 0; i < me->totpoly; i++, mp++) {
-    MLoop *ml_prev, *ml_curr, *ml_next;
-    int j;
+  MPoly *mp = me->mpoly;
+  MLoop *mloop = me->mloop;
 
-    ml_next = &mloop[mp->loopstart];
-    ml_curr = &ml_next[mp->totloop - 1];
-    ml_prev = &ml_next[mp->totloop - 2];
+  for (int i = 0; i < me->totpoly; i++, mp++) {
+    MLoop *ml_next = &mloop[mp->loopstart];
+    MLoop *ml_curr = &ml_next[mp->totloop - 1];
+    MLoop *ml_prev = &ml_next[mp->totloop - 2];
 
-    for (j = 0; j < mp->totloop; j++) {
+    for (int j = 0; j < mp->totloop; j++) {
       if ((mvert[ml_curr->v].flag & ME_VERT_TMP_TAG) == 0) {
         const float *co_prev, *co_curr, *co_next; /* orig */
         const float *vd_prev, *vd_curr, *vd_next; /* deform */
diff --git a/source/blender/blenkernel/intern/curve.c b/source/blender/blenkernel/intern/curve.c
index 7fe8834c2ec..f50b3e3dc79 100644
--- a/source/blender/blenkernel/intern/curve.c
+++ b/source/blender/blenkernel/intern/curve.c
@@ -782,11 +782,10 @@ float BKE_nurb_calc_length(const Nurb *nu, int resolution)
 /* be sure to call makeknots after this */
 void BKE_nurb_points_add(Nurb *nu, int number)
 {
-  BPoint *bp;
-  int i;
-
   nu->bp = MEM_recallocN(nu->bp, (nu->pntsu + number) * sizeof(BPoint));
 
+  BPoint *bp;
+  int i;
   for (i = 0, bp = &nu->bp[nu->pntsu]; i < number; i++, bp++) {
     bp->radius = 1.0f;
   }
@@ -1718,12 +1717,10 @@ static void forward_diff_bezier_cotangent(const float p0[3],
    * they need to be rotated for this,
    *
    * This could also be optimized like BKE_curve_forward_diff_bezier */
-  int a;
-  for (a = 0; a <= it; a++) {
+  for (int a = 0; a <= it; a++) {
     float t = (float)a / (float)it;
 
-    int i;
-    for (i = 0; i < 3; i++) {
+    for (int i = 0; i < 3; i++) {
       p[i] = (-6.0f * t + 6.0f) * p0[i] + (18.0f * t - 12.0f) * p1[i] +
              (-18.0f * t + 6.0f) * p2[i] + (6.0f * t) * p3[i];
     }
@@ -4074,17 +4071,14 @@ void BKE_nurb_handles_autocalc(Nurb *nu, int flag)
   const float eps = 0.0001f;
   const float eps_sq = eps * eps;
 
-  BezTriple *bezt2, *bezt1, *bezt0;
-  int i;
-
   if (nu == NULL || nu->bezt == NULL) {
     return;
   }
 
-  bezt2 = nu->bezt;
-  bezt1 = bezt2 + (nu->pntsu - 1);
-  bezt0 = bezt1 - 1;
-  i = nu->pntsu;
+  BezTriple *bezt2 = nu->bezt;
+  BezTriple *bezt1 = bezt2 + (nu->pntsu - 1);
+  BezTriple *bezt0 = bezt1 - 1;
+  int i = nu->pntsu;
 
   while (i--) {
     bool align = false, leftsmall = false, rightsmall = false;
@@ -4546,14 +4540,12 @@ void BKE_curve_nurbs_vert_coords_apply_with_mat4(ListBase *lb,
                                                  const bool constrain_2d)
 {
   const float *co = vert_coords[0];
-  Nurb *nu;
-  int i;
 
-  for (nu = lb->first; nu; nu = nu->next) {
+  LISTBASE_FOREACH (Nurb *, nu, lb) {
     if (nu->type == CU_BEZIER) {
       BezTriple *bezt = nu->bezt;
 
-      for (i = 0; i < nu->pntsu; i++, bezt++) {
+      for (int i = 0; i < nu->pntsu; i++, bezt++) {
         mul_v3_m4v3(bezt->vec[0], mat, co);
         co += 3;
         mul_v3_m4v3(bezt->vec[1], mat, co);
@@ -4565,7 +4557,7 @@ void BKE_curve_nurbs_vert_coords_apply_with_mat4(ListBase *lb,
     else {
       BPoint *bp = nu->bp;
 
-      for (i = 0; i < nu->pntsu * nu->pntsv; i++, bp++) {
+      for (int i = 0; i < nu->pntsu * nu->pntsv; i++, bp++) {
         mul_v3_m4v3(bp->vec, mat, co);
         co += 3;
       }
@@ -4655,14 +4647,11 @@ float (*BKE_curve_nurbs_key_vert_coords_alloc(ListBase *lb, float *key, int *r_v
 
 void BKE_curve_nurbs_key_vert_tilts_apply(ListBase *lb, const float *key)
 {
-  Nurb *nu;
-  int i;
-
-  for (nu = lb->first; nu; nu = nu->next) {
+  LISTBASE_FOREACH (Nurb *, nu, lb) {
     if (nu->type == CU_BEZIER) {
       BezTriple *bezt = nu->bezt;
 
-      for (i = 0; i < nu->pntsu; i++, bezt++) {
+      for (int i = 0; i < nu->pntsu; i++, bezt++) {
         bezt->tilt = key[9];
         bezt->radius = key[10];
         key += KEYELEM_FLOAT_LEN_BEZTRIPLE;
@@ -4671,7 +4660,7 @@ void BKE_curve_nurbs_key_vert_tilts_apply(ListBase *lb, const float *key)
     else {
       BPoint *bp = nu->bp;
 
-      for (i = 0; i < nu->pntsu * nu->pntsv; i++, bp++) {
+      for (int i = 0; i < nu->pntsu * nu->pntsv; i++, bp++) {
         bp->tilt = key[3];
         bp->radius = key[4];
         key += KEYELEM_FLOAT_LEN_BPOINT;
@@ -5197,37 +5186,32 @@ void BKE_curve_translate(Curve *cu, const float offset[3], const bool do_keys)
 {
   ListBase *nurb_lb = BKE_curve_nurbs_get(cu);
   Nurb *nu;
-  int i;
-
-  for (nu = nurb_lb->first; nu; nu = nu->next) {
-    BezTriple *bezt;
-    BPoint *bp;
 
+  LISTBASE_FOREACH (Nurb *, nu, nurb_lb) {
     if (nu->type == CU_BEZIER) {
-      i = nu->pntsu;
-      for (bezt = nu->bezt; i--; bezt++) {
+      int i = nu->pntsu;
+      for (BezTriple *bezt = nu->bezt; i--; bezt++) {
         add_v3_v3(bezt->vec[0], offset);
         add_v3_v3(bezt->vec[1], offset);
         add_v3_v3(bezt->vec[2], offset);
       }
     }
     else {
-      i = nu->pntsu * nu->pntsv;
-      for (bp = nu->bp; i--; bp++) {
+      int i = nu->pntsu * nu->pntsv;
+      for (BPoint *bp = nu->bp; i--; bp++) {
         add_v3_v3(bp->vec, offset);
       }
     }
   }
 
   if (do_keys && cu->key) {
-    KeyBlock *kb;
-    for (kb = cu->key->block.first; kb; kb = kb->next) {
+    LISTBASE_FOREACH (KeyBlock *, kb, &cu->key->block) {
       float *fp = kb->data;
       int n = kb->totelem;
 
-      for (nu = cu->nurb.first; nu; nu = nu->next) {
+      LISTBASE_FOREACH (Nurb *, nu, &cu->nurb) {
         if (nu->type == CU_BEZIER) {
-          for (i = nu->pntsu; i && (n -= KEYELEM_ELEM_LEN_BEZTRIPLE) >= 0; i--) {
+          for (int i = nu->pntsu; i && (n -= KEYELEM_ELEM_LEN_BEZTRIPLE) >= 0; i--) {
             add_v3_v3(&fp[0], offset);
             add_v3_v3(&fp[3], offset);
             add_v3_v3(&fp[6], offset);
@@ -5235,7 +5219,7 @@ void BKE_curve_translate(Curve *cu, const float offset[3], const bool do_keys)
           }
         }
         else {
-          for (i = nu->pntsu * nu->pntsv; i && (n -= KEYELEM_ELEM_LEN_BPOINT) >= 0; i--) {
+          for (int i = nu->pntsu * nu->pntsv; i && (n -= KEYELEM_ELEM_LEN_BPOINT) >= 0; i--) {
             add_v3_v3(fp, offset);
             fp += KEYELEM_FLOAT_LEN_BPOINT;
           }
@@ -5251,17 +5235,14 @@ void BKE_curve_material_index_remove(Curve *cu, int index)
 
   if (curvetype == OB_FONT) {
     struct CharInfo *info = cu->strinfo;
-    int i;
-    for (i = cu->len_char32 - 1; i >= 0; i--, info++) {
+    for (int i = cu->len_char32 - 1; i >= 0; i--, info++) {
       if (info->mat_nr && info->mat_nr >= index) {
         info->mat_nr--;
       }
     }
   }
   else {
-    Nurb *nu;
-
-    for (nu = cu->nurb.first; nu; nu = nu->next) {
+    LISTBASE_FOREACH (Nurb *, nu, &cu->nurb) {
       if (nu->mat_nr && nu->mat_nr >= index) {
         nu->mat_nr--;
       }
@@ -5275,17 +5256,14 @@ bool BKE_curve_material_index_used(Curve *cu, int index)
 
   if (curvetype == OB_FONT) {
     struct CharInfo *info = cu->strinfo;
-    int i;
-    for (i = cu->len_char32 - 1; i >= 0; i--, info++) {
+    for (int i = cu->len_char32 - 1; i >= 0; i--, info++) {
       if (info->mat_nr == index) {
         return true;
       }
     }
   }
   else {
-    Nurb *nu;
-
-    for (nu = cu->nurb.first; nu; nu = nu->next) {
+    LISTBASE_FOREACH (Nurb *, nu, &cu->nurb) {
       if (nu->mat_nr == index) {
         return true;
       }
@@ -5301,15 +5279,12 @@ void BKE_curve_material_index_clear(Curve *cu)
 
   if (curvetype == OB_FONT) {
     struct CharInfo *info = cu->strinfo;
-    int i;
-    for (i = cu->len_char32 - 1; i >= 0; i--, info++) {
+    for (int i = cu->len_char32 - 1; i >= 0; i--, info++) {
       info->mat_nr = 0;
     }
   }
   else {
-    Nurb *nu;
-
-    for (nu = cu->nurb.first; nu; nu = nu->next) {
+    LISTBASE_FOREACH (Nurb *, nu, &cu->nurb) {
       nu->mat_nr = 0;
     }
   }
diff --git a/source/blender/blenkernel/intern/customdata.c b/source/blender/blenkernel/intern/customdata.c
index e2adaabca33..b10d910cd66 100644
--- a/source/blender/blenkernel/intern/customdata.c
+++ b/source/blender/blenkernel/intern/customdata.c
@@ -199,9 +199,7 @@ static void layerCopy_mdeformvert(const void *source, void *dest, int count)
 
 static void layerFree_mdeformvert(void *data, int count, int size)
 {
-  int i;
-
-  for (i = 0; i < count; i++) {
+  for (int i = 0; i < count; i++) {
     MDeformVert *dvert = POINTER_OFFSET(data, i * size);
 
     if (dvert->dw) {
@@ -232,9 +230,7 @@ void bpy_bm_generic_invalidate(struct BPy_BMGeneric *UNUSED(self))
 
 static void layerFree_bmesh_elem_py_ptr(void *data, int count, int size)
 {
-  int i;
-
-  for (i = 0; i < count; i++) {
+  for (int i = 0; i < count; i++) {
     void **ptr = POINTER_OFFSET(data, i * size);
     if (*ptr) {
       bpy_bm_generic_invalidate(*ptr);
@@ -416,9 +412,7 @@ static void layerCopy_tface(const void *source, void *dest, int count)
 {
   const MTFace *source_tf = (const MTFace *)source;
   MTFace *dest_tf = (MTFace *)dest;
-  int i;
-
-  for (i = 0; i < count; i++) {
+  for (int i = 0; i < count; i++) {
     dest_tf[i] = source_tf[i];
   }
 }
@@ -475,9 +469,8 @@ static void layerDefault_tface(void *data, int count)
 {
   static MTFace default_tf = {{{0, 0}, {1, 0}, {1, 1}, {0, 1}}};
   MTFace *tf = (MTFace *)data;
-  int i;
 
-  for (i = 0; i < count; i++) {
+  for (int i = 0; i < count; i++) {
     tf[i] = default_tf;
   }
 }
@@ -523,9 +516,8 @@ static void layerCopy_origspace_face(const void *source, void *dest, int count)
 {
   const OrigSpaceFace *source_tf = (const OrigSpaceFace *)source;
   OrigSpaceFace *dest_tf = (OrigSpaceFace *)dest;
-  int i;
 
-  for (i = 0; i < count; i++) {
+  for (int i = 0; i < count; i++) {
     dest_tf[i] = source_tf[i];
   }
 }
@@ -579,9 +571,8 @@ static void layerDefault_origspace_face(void *data, int count)
 {
   static OrigSpaceFace default_osf = {{{0, 0}, {1, 0}, {1, 1}, {0, 1}}};
   OrigSpaceFace *osf = (OrigSpaceFace *)data;
-  int i;
 
-  for (i = 0; i < count; i++) {
+  for (int i = 0; i < count; i++) {
     osf[i] = default_osf;
   }
 }
@@ -620,11 +611,10 @@ static void layerSwap_mdisps(void *data, const int *ci)
 
 static void layerCopy_mdisps(const void *source, void *dest, int count)
 {
-  int i;
   const MDisps *s = source;
   MDisps *d = dest;
 
-  for (i = 0; i < count; i++) {
+  for (int 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);
@@ -642,10 +632,9 @@ static void layerCopy_mdisps(const void *source, void *dest, int count)
 
 static void layerFree_mdisps(void *data, int count, int UNUSED(size))
 {
-  int i;
   MDisps *d = data;
 
-  for (i = 0; i < count; i++) {
+  for (int i = 0; i < count; i++) {
     if (d[i].disps) {
       MEM_freeN(d[i].disps);
     }
@@ -695,9 +684,8 @@ static size_t layerFilesize_mdisps(CDataFile *UNUSED(cdf), const void *data, int
 {
   const MDisps *d = data;
   size_t size = 0;
-  int i;
 
-  for (i = 0; i < count; i++) {
+  for (int i = 0; i < count; i++) {
     size += sizeof(float[3]) * d[i].totdisp;
   }
 
@@ -724,11 +712,10 @@ static void layerInterp_paint_mask(
 
 static void layerCopy_grid_paint_mask(const void *source, void *dest, int count)
 {
-  int i;
   const GridPaintMask *s = source;
   GridPaintMask *d = dest;
 
-  for (i = 0; i < count; i++) {
+  for (int i = 0; i < count; i++) {
     if (s[i].data) {
       d[i].data = MEM_dupallocN(s[i].data);
       d[i].level = s[i].level;
@@ -742,10 +729,9 @@ static void layerCopy_grid_paint_mask(const void *source, void *dest, int count)
 
 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 (int i = 0; i < count; i++) {
     if (gpm[i].data) {
       MEM_freeN(gpm[i].data);
     }
@@ -895,8 +881,7 @@ static void layerDefault_mloopcol(void *data, int count)
 {
   MLoopCol default_mloopcol = {255, 255, 255, 255};
   MLoopCol *mlcol = (MLoopCol *)data;
-  int i;
-  for (i = 0; i < count; i++) {
+  for (int i = 0; i < count; i++) {
     mlcol[i] = default_mloopcol;
   }
 }
@@ -1007,13 +992,12 @@ static void layerInterp_mloopuv(
 {
   float uv[2];
   int flag = 0;
-  int i;
 
   zero_v2(uv);
 
   if (sub_weights) {
     const float *sub_weight = sub_weights;
-    for (i = 0; i < count; i++) {
+    for (int i = 0; i < count; i++) {
       float weight = (weights ? weights[i] : 1.0f) * (*sub_weight);
       const MLoopUV *src = sources[i];
       madd_v2_v2fl(uv, src->uv, weight);
@@ -1024,7 +1008,7 @@ static void layerInterp_mloopuv(
     }
   }
   else {
-    for (i = 0; i < count; i++) {
+    for (int i = 0; i < count; i++) {
       float weight = weights ? weights[i] : 1;
       const MLoopUV *src = sources[i];
       madd_v2_v2fl(uv, src->uv, weight);
@@ -1109,13 +1093,11 @@ static void layerInterp_mloop_origspace(
     const void **sources, const float *weights, const float *sub_weights, int count, void *dest)
 {
   float uv[2];
-  int i;
-
   zero_v2(uv);
 
   if (sub_weights) {
     const float *sub_weight = sub_weights;
-    for (i = 0; i < count; i++) {
+    for (int i = 0; i < count; i++) {
       float weight = weights ? weights[i] : 1.0f;
       const OrigSpaceLoop *src = sources[i];
       madd_v2_v2fl(uv, src->uv, (*sub_weight) * weight);
@@ -1123,7 +1105,7 @@ static void layerInterp_mloop_origspace(
     }
   }
   else {
-    for (i = 0; i < count; i++) {
+    for (int i = 0; i < count; i++) {
       float weight = weights ? weights[i] : 1.0f;
       const OrigSpaceLoop *src = sources[i];
       madd_v2_v2fl(uv, src->uv, weight);
@@ -1139,7 +1121,6 @@ static void layerInterp_mcol(
     const void **sources, const float *weights, const float *sub_weights, int count, void *dest)
 {
   MCol *mc = dest;
-  int i, j, k;
   struct {
     float a;
     float r;
@@ -1147,20 +1128,18 @@ static void layerInterp_mcol(
     float b;
   } col[4] = {{0.0f}};
 
-  const float *sub_weight;
-
   if (count <= 0) {
     return;
   }
 
-  sub_weight = sub_weights;
-  for (i = 0; i < count; i++) {
+  const float *sub_weight = sub_weights;
+  for (int i = 0; i < count; i++) {
     float weight = weights ? weights[i] : 1;
 
-    for (j = 0; j < 4; j++) {
+    for (int j = 0; j < 4; j++) {
       if (sub_weights) {
         const MCol *src = sources[i];
-        for (k = 0; k < 4; k++, sub_weight++, src++) {
+        for (int 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;
@@ -1179,7 +1158,7 @@ static void layerInterp_mcol(
   }
 
   /* Delay writing to the destination in case dest is in sources. */
-  for (j = 0; j < 4; j++) {
+  for (int j = 0; j < 4; j++) {
 
     /* Subdivide smooth or fractal can cause problems without clamping
      * although weights should also not cause this situation */
@@ -1207,9 +1186,8 @@ static void layerDefault_mcol(void *data, int count)
 {
   static MCol default_mcol = {255, 255, 255, 255};
   MCol *mcol = (MCol *)data;
-  int i;
 
-  for (i = 0; i < 4 * count; i++) {
+  for (int i = 0; i < 4 * count; i++) {
     mcol[i] = default_mcol;
   }
 }
@@ -1225,23 +1203,21 @@ static void layerInterp_bweight(const void **sources,
                                 int count,
                                 void *dest)
 {
-  float f;
   float **in = (float **)sources;
-  int i;
 
   if (count <= 0) {
     return;
   }
 
-  f = 0.0f;
+  float f = 0.0f;
 
   if (weights) {
-    for (i = 0; i < count; i++) {
+    for (int i = 0; i < count; i++) {
       f += *in[i] * weights[i];
     }
   }
   else {
-    for (i = 0; i < count; i++) {
+    for (int i = 0; i < count; i++) {
       f += *in[i];
     }
   }
@@ -1256,23 +1232,22 @@ static void layerInterp_shapekey(const void **sources,
                                  int count,
                                  void *dest)
 {
-  float co[3];
   float **in = (float **)sources;
-  int i;
 
   if (count <= 0) {
     return;
   }
 
+  float co[3];
   zero_v3(co);
 
   if (weights) {
-    for (i = 0; i < count; i++) {
+    for (int i = 0; i < count; i++) {
       madd_v3_v3fl(co, in[i], weights[i]);
     }
   }
   else {
-    for (i = 0; i < count; i++) {
+    for (int i = 0; i < count; i++) {
       add_v3_v3(co, in[i]);
     }
   }
@@ -1284,9 +1259,8 @@ static void layerInterp_shapekey(const void **sources,
 static void layerDefault_mvert_skin(void *data, int count)
 {
   MVertSkin *vs = data;
-  int i;
 
-  for (i = 0; i < count; i++) {
+  for (int i = 0; i < count; i++) {
     copy_v3_fl(vs[i].radius, 0.25f);
     vs[i].flag = 0;
   }
@@ -1304,13 +1278,13 @@ static void layerInterp_mvert_skin(const void **sources,
                                    void *dest)
 {
   MVertSkin *vs_dst = dest;
-  float radius[3], w;
-  int i;
 
+  float radius[3];
   zero_v3(radius);
-  for (i = 0; i < count; i++) {
+
+  for (int i = 0; i < count; i++) {
     const MVertSkin *vs_src = sources[i];
-    w = weights ? weights[i] : 1.0f;
+    float w = weights ? weights[i] : 1.0f;
 
     madd_v3_v3fl(radius, vs_src->radius, w);
   }
@@ -1437,8 +1411,7 @@ static void layerDefault_propcol(void *data, int count)
   /* Default to white, full alpha. */
   MPropCol default_propcol = {{1.0f, 1.0f, 1.0f, 1.0f}};
   MPropCol *pcol = (MPropCol *)data;
-  int i;
-  for (i = 0; i < count; i++) {
+  for (int i = 0; i < count; i++) {
     copy_v4_v4(pcol[i].color, default_propcol.color);
   }
 }
@@ -2093,38 +2066,36 @@ static const char *layerType_getName(int type)
 
 void customData_mask_layers__print(const CustomData_MeshMasks *mask)
 {
-  int i;
-
   printf("verts mask=0x%lx:\n", (long unsigned int)mask->vmask);
-  for (i = 0; i < CD_NUMTYPES; i++) {
+  for (int i = 0; i < CD_NUMTYPES; i++) {
     if (mask->vmask & CD_TYPE_AS_MASK(i)) {
       printf("  %s\n", layerType_getName(i));
     }
   }
 
   printf("edges mask=0x%lx:\n", (long unsigned int)mask->emask);
-  for (i = 0; i < CD_NUMTYPES; i++) {
+  for (int i = 0; i < CD_NUMTYPES; i++) {
     if (mask->emask & CD_TYPE_AS_MASK(i)) {
       printf("  %s\n", layerType_getName(i));
     }
   }
 
   printf("faces mask=0x%lx:\n", (long unsigned int)mask->fmask);
-  for (i = 0; i < CD_NUMTYPES; i++) {
+  for (int i = 0; i < CD_NUMTYPES; i++) {
     if (mask->fmask & CD_TYPE_AS_MASK(i)) {
       printf("  %s\n", layerType_getName(i));
     }
   }
 
   printf("loops mask=0x%lx:\n", (long unsigned int)mask->lmask);
-  for (i = 0; i < CD_NUMTYPES; i++) {
+  for (int i = 0; i < CD_NUMTYPES; i++) {
     if (mask->lmask & CD_TYPE_AS_MASK(i)) {
       printf("  %s\n", layerType_getName(i));
     }
   }
 
   printf("polys mask=0x%lx:\n", (long unsigned int)mask->pmask);
-  for (i = 0; i < CD_NUMTYPES; i++) {
+  for (int i = 0; i < CD_NUMTYPES; i++) {
     if (mask->pmask & CD_TYPE_AS_MASK(i)) {
       printf("  %s\n", layerType_getName(i));
     }
@@ -2253,8 +2224,7 @@ bool CustomData_merge(const struct CustomData *source,
 /* NOTE: Take care of referenced layers by yourself! */
 void CustomData_realloc(CustomData *data, int totelem)
 {
-  int i;
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     CustomDataLayer *layer = &data->layers[i];
     const LayerTypeInfo *typeInfo;
     if (layer->flag & CD_FLAG_NOFREE) {
@@ -2313,9 +2283,7 @@ void CustomData_reset(CustomData *data)
 
 void CustomData_free(CustomData *data, int totelem)
 {
-  int i;
-
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     customData_free_layer__internal(&data->layers[i], totelem);
   }
 
@@ -2329,9 +2297,7 @@ void CustomData_free(CustomData *data, int totelem)
 
 void CustomData_free_typemask(struct CustomData *data, int totelem, CustomDataMask mask)
 {
-  int i;
-
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     CustomDataLayer *layer = &data->layers[i];
     if (!(mask & CD_TYPE_AS_MASK(layer->type))) {
       continue;
@@ -2350,9 +2316,9 @@ void CustomData_free_typemask(struct CustomData *data, int totelem, CustomDataMa
 static void customData_update_offsets(CustomData *data)
 {
   const LayerTypeInfo *typeInfo;
-  int i, offset = 0;
+  int offset = 0;
 
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     typeInfo = layerType_getInfo(data->layers[i].type);
 
     data->layers[i].offset = offset;
@@ -2366,9 +2332,7 @@ static void customData_update_offsets(CustomData *data)
 /* to use when we're in the middle of modifying layers */
 static int CustomData_get_layer_index__notypemap(const CustomData *data, int type)
 {
-  int i;
-
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       return i;
     }
@@ -2400,9 +2364,7 @@ int CustomData_get_layer_index_n(const struct CustomData *data, int type, int n)
 
 int CustomData_get_named_layer_index(const CustomData *data, int type, const char *name)
 {
-  int i;
-
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       if (STREQ(data->layers[i].name, name)) {
         return i;
@@ -2482,9 +2444,7 @@ int CustomData_get_stencil_layer(const CustomData *data, int type)
 
 void CustomData_set_layer_active(CustomData *data, int type, int n)
 {
-  int i;
-
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       data->layers[i].active = n;
     }
@@ -2493,9 +2453,7 @@ void CustomData_set_layer_active(CustomData *data, int type, int n)
 
 void CustomData_set_layer_render(CustomData *data, int type, int n)
 {
-  int i;
-
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       data->layers[i].active_rnd = n;
     }
@@ -2504,9 +2462,7 @@ void CustomData_set_layer_render(CustomData *data, int type, int n)
 
 void CustomData_set_layer_clone(CustomData *data, int type, int n)
 {
-  int i;
-
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       data->layers[i].active_clone = n;
     }
@@ -2515,9 +2471,7 @@ void CustomData_set_layer_clone(CustomData *data, int type, int n)
 
 void CustomData_set_layer_stencil(CustomData *data, int type, int n)
 {
-  int i;
-
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       data->layers[i].active_mask = n;
     }
@@ -2528,9 +2482,7 @@ void CustomData_set_layer_stencil(CustomData *data, int type, int n)
  * CustomData_get_render_layer_index. */
 void CustomData_set_layer_active_index(CustomData *data, int type, int n)
 {
-  int i;
-
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       data->layers[i].active = n - i;
     }
@@ -2539,9 +2491,7 @@ void CustomData_set_layer_active_index(CustomData *data, int type, int n)
 
 void CustomData_set_layer_render_index(CustomData *data, int type, int n)
 {
-  int i;
-
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       data->layers[i].active_rnd = n - i;
     }
@@ -2550,9 +2500,7 @@ void CustomData_set_layer_render_index(CustomData *data, int type, int n)
 
 void CustomData_set_layer_clone_index(CustomData *data, int type, int n)
 {
-  int i;
-
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       data->layers[i].active_clone = n - i;
     }
@@ -2561,9 +2509,7 @@ void CustomData_set_layer_clone_index(CustomData *data, int type, int n)
 
 void CustomData_set_layer_stencil_index(CustomData *data, int type, int n)
 {
-  int i;
-
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       data->layers[i].active_mask = n - i;
     }
@@ -2572,9 +2518,7 @@ void CustomData_set_layer_stencil_index(CustomData *data, int type, int n)
 
 void CustomData_set_layer_flag(struct CustomData *data, int type, int flag)
 {
-  int i;
-
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       data->layers[i].flag |= flag;
     }
@@ -2759,7 +2703,6 @@ bool CustomData_free_layer(CustomData *data, int type, int totelem, int index)
 {
   const int index_first = CustomData_get_layer_index(data, type);
   const int n = index - index_first;
-  int i;
 
   BLI_assert(index >= index_first);
   if ((index_first == -1) || (n < 0)) {
@@ -2769,14 +2712,14 @@ 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 (int i = index + 1; i < data->totlayer; i++) {
     data->layers[i - 1] = data->layers[i];
   }
 
   data->totlayer--;
 
   /* if layer was last of type in array, set new active layer */
-  i = CustomData_get_layer_index__notypemap(data, type);
+  int i = CustomData_get_layer_index__notypemap(data, type);
 
   if (i != -1) {
     /* don't decrement zero index */
@@ -2810,8 +2753,7 @@ bool CustomData_free_layer(CustomData *data, int type, int totelem, int index)
 
 bool CustomData_free_layer_active(CustomData *data, int type, int totelem)
 {
-  int index = 0;
-  index = CustomData_get_active_layer_index(data, type);
+  const int index = CustomData_get_active_layer_index(data, type);
   if (index == -1) {
     return false;
   }
@@ -2833,9 +2775,9 @@ bool CustomData_has_layer(const CustomData *data, int type)
 
 int CustomData_number_of_layers(const CustomData *data, int type)
 {
-  int i, number = 0;
+  int number = 0;
 
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     if (data->layers[i].type == type) {
       number++;
     }
@@ -2846,9 +2788,9 @@ int CustomData_number_of_layers(const CustomData *data, int type)
 
 int CustomData_number_of_layers_typemask(const CustomData *data, CustomDataMask mask)
 {
-  int i, number = 0;
+  int number = 0;
 
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     if (mask & CD_TYPE_AS_MASK(data->layers[i].type)) {
       number++;
     }
@@ -2861,13 +2803,11 @@ static void *customData_duplicate_referenced_layer_index(CustomData *data,
                                                          const int layer_index,
                                                          const int totelem)
 {
-  CustomDataLayer *layer;
-
   if (layer_index == -1) {
     return NULL;
   }
 
-  layer = &data->layers[layer_index];
+  CustomDataLayer *layer = &data->layers[layer_index];
 
   if (layer->flag & CD_FLAG_NOFREE) {
     /* MEM_dupallocN won't work in case of complex layers, like e.g.
@@ -2894,10 +2834,8 @@ static void *customData_duplicate_referenced_layer_index(CustomData *data,
 
 void *CustomData_duplicate_referenced_layer(CustomData *data, const int type, const int totelem)
 {
-  int layer_index;
-
   /* get the layer index of the first layer of type */
-  layer_index = CustomData_get_active_layer_index(data, type);
+  int layer_index = CustomData_get_active_layer_index(data, type);
 
   return customData_duplicate_referenced_layer_index(data, layer_index, totelem);
 }
@@ -2907,10 +2845,8 @@ void *CustomData_duplicate_referenced_layer_n(CustomData *data,
                                               const int n,
                                               const int totelem)
 {
-  int layer_index;
-
   /* get the layer index of the desired layer */
-  layer_index = CustomData_get_layer_index_n(data, type, n);
+  int layer_index = CustomData_get_layer_index_n(data, type, n);
 
   return customData_duplicate_referenced_layer_index(data, layer_index, totelem);
 }
@@ -2920,26 +2856,21 @@ void *CustomData_duplicate_referenced_layer_named(CustomData *data,
                                                   const char *name,
                                                   const int totelem)
 {
-  int layer_index;
-
   /* get the layer index of the desired layer */
-  layer_index = CustomData_get_named_layer_index(data, type, name);
+  int layer_index = CustomData_get_named_layer_index(data, type, name);
 
   return customData_duplicate_referenced_layer_index(data, layer_index, totelem);
 }
 
 bool CustomData_is_referenced_layer(struct CustomData *data, int type)
 {
-  CustomDataLayer *layer;
-  int layer_index;
-
   /* get the layer index of the first layer of type */
-  layer_index = CustomData_get_active_layer_index(data, type);
+  int layer_index = CustomData_get_active_layer_index(data, type);
   if (layer_index == -1) {
     return false;
   }
 
-  layer = &data->layers[layer_index];
+  CustomDataLayer *layer = &data->layers[layer_index];
 
   return (layer->flag & CD_FLAG_NOFREE) != 0;
 }
@@ -2980,9 +2911,7 @@ void CustomData_free_temporary(CustomData *data, int totelem)
 
 void CustomData_set_only_copy(const struct CustomData *data, CustomDataMask mask)
 {
-  int i;
-
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     if (!(mask & CD_TYPE_AS_MASK(data->layers[i].type))) {
       data->layers[i].flag |= CD_FLAG_NOCOPY;
     }
@@ -3044,12 +2973,10 @@ static void CustomData_copy_data_layer(const CustomData *source,
 void CustomData_copy_data_named(
     const CustomData *source, CustomData *dest, int source_index, int dest_index, int count)
 {
-  int src_i, dest_i;
-
   /* copies a layer at a time */
-  for (src_i = 0; src_i < source->totlayer; src_i++) {
+  for (int src_i = 0; src_i < source->totlayer; src_i++) {
 
-    dest_i = CustomData_get_named_layer_index(
+    int dest_i = CustomData_get_named_layer_index(
         dest, source->layers[src_i].type, source->layers[src_i].name);
 
     /* if we found a matching layer, copy the data */
@@ -3062,11 +2989,9 @@ void CustomData_copy_data_named(
 void CustomData_copy_data(
     const CustomData *source, CustomData *dest, int source_index, int dest_index, int count)
 {
-  int src_i, dest_i;
-
   /* copies a layer at a time */
-  dest_i = 0;
-  for (src_i = 0; src_i < source->totlayer; src_i++) {
+  int dest_i = 0;
+  for (int 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)
@@ -3119,12 +3044,9 @@ void CustomData_copy_layer_type_data(const CustomData *source,
 
 void CustomData_free_elem(CustomData *data, int index, int count)
 {
-  int i;
-  const LayerTypeInfo *typeInfo;
-
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     if (!(data->layers[i].flag & CD_FLAG_NOFREE)) {
-      typeInfo = layerType_getInfo(data->layers[i].type);
+      const LayerTypeInfo *typeInfo = layerType_getInfo(data->layers[i].type);
 
       if (typeInfo->free) {
         size_t offset = (size_t)index * typeInfo->size;
@@ -3145,8 +3067,6 @@ void CustomData_interp(const CustomData *source,
                        int count,
                        int dest_index)
 {
-  int src_i, dest_i;
-  int j;
   const void *source_buf[SOURCE_BUF_SIZE];
   const void **sources = source_buf;
 
@@ -3156,8 +3076,8 @@ 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++) {
+  int dest_i = 0;
+  for (int src_i = 0; src_i < source->totlayer; src_i++) {
     const LayerTypeInfo *typeInfo = layerType_getInfo(source->layers[src_i].type);
     if (!typeInfo->interp) {
       continue;
@@ -3179,7 +3099,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 (int j = 0; j < count; j++) {
         sources[j] = POINTER_OFFSET(src_data, (size_t)src_indices[j] * typeInfo->size);
       }
 
@@ -3212,11 +3132,8 @@ void CustomData_interp(const CustomData *source,
  */
 void CustomData_swap_corners(struct CustomData *data, int index, const int *corner_indices)
 {
-  const LayerTypeInfo *typeInfo;
-  int i;
-
-  for (i = 0; i < data->totlayer; i++) {
-    typeInfo = layerType_getInfo(data->layers[i].type);
+  for (int i = 0; i < data->totlayer; i++) {
+    const LayerTypeInfo *typeInfo = layerType_getInfo(data->layers[i].type);
 
     if (typeInfo->swap) {
       const size_t offset = (size_t)index * typeInfo->size;
@@ -3231,14 +3148,13 @@ void CustomData_swap_corners(struct CustomData *data, int index, const int *corn
  */
 void CustomData_swap(struct CustomData *data, const int index_a, const int index_b)
 {
-  int i;
   char buff_static[256];
 
   if (index_a == index_b) {
     return;
   }
 
-  for (i = 0; i < data->totlayer; i++) {
+  for (int 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;
@@ -3259,12 +3175,10 @@ void CustomData_swap(struct CustomData *data, const int index_a, const int index
 
 void *CustomData_get(const CustomData *data, int index, int type)
 {
-  int layer_index;
-
   BLI_assert(index >= 0);
 
   /* get the layer index of the active layer of type */
-  layer_index = CustomData_get_active_layer_index(data, type);
+  int layer_index = CustomData_get_active_layer_index(data, type);
   if (layer_index == -1) {
     return NULL;
   }
@@ -3277,12 +3191,10 @@ void *CustomData_get(const CustomData *data, int index, int type)
 
 void *CustomData_get_n(const CustomData *data, int type, int index, int n)
 {
-  int layer_index;
-
   BLI_assert(index >= 0 && n >= 0);
 
   /* get the layer index of the first layer of type */
-  layer_index = data->typemap[type];
+  int layer_index = data->typemap[type];
   if (layer_index == -1) {
     return NULL;
   }
@@ -3436,12 +3348,10 @@ void CustomData_to_bmeshpoly(CustomData *fdata, CustomData *ldata, int totloop)
 
 void CustomData_from_bmeshpoly(CustomData *fdata, CustomData *ldata, int total)
 {
-  int i;
-
   /* avoid accumulating extra layers */
   BLI_assert(!CustomData_from_bmeshpoly_test(fdata, ldata, false));
 
-  for (i = 0; i < ldata->totlayer; i++) {
+  for (int i = 0; i < ldata->totlayer; i++) {
     if (ldata->layers[i].type == CD_MLOOPUV) {
       CustomData_add_layer_named(fdata, CD_MTFACE, CD_CALLOC, NULL, total, ldata->layers[i].name);
     }
@@ -3619,12 +3529,6 @@ bool CustomData_bmesh_merge(const CustomData *source,
                             BMesh *bm,
                             const char htype)
 {
-  BMHeader *h;
-  BMIter iter;
-  CustomData destold;
-  void *tmp;
-  int iter_type;
-  int totelem;
 
   if (CustomData_number_of_layers_typemask(source, mask) == 0) {
     return false;
@@ -3632,7 +3536,7 @@ bool CustomData_bmesh_merge(const CustomData *source,
 
   /* copy old layer description so that old data can be copied into
    * the new allocation */
-  destold = *dest;
+  CustomData destold = *dest;
   if (destold.layers) {
     destold.layers = MEM_dupallocN(destold.layers);
   }
@@ -3644,6 +3548,8 @@ bool CustomData_bmesh_merge(const CustomData *source,
     return false;
   }
 
+  int iter_type;
+  int totelem;
   switch (htype) {
     case BM_VERT:
       iter_type = BM_VERTS_OF_MESH;
@@ -3672,9 +3578,11 @@ bool CustomData_bmesh_merge(const CustomData *source,
   CustomData_bmesh_init_pool(dest, totelem, htype);
 
   if (iter_type != BM_LOOPS_OF_FACE) {
+    BMHeader *h;
+    BMIter iter;
     /*ensure all current elements follow new customdata layout*/
     BM_ITER_MESH (h, &iter, bm, iter_type) {
-      tmp = NULL;
+      void *tmp = NULL;
       CustomData_bmesh_copy_data(&destold, dest, h->data, &tmp);
       CustomData_bmesh_free_block(&destold, &h->data);
       h->data = tmp;
@@ -3683,12 +3591,13 @@ bool CustomData_bmesh_merge(const CustomData *source,
   else {
     BMFace *f;
     BMLoop *l;
+    BMIter iter;
     BMIter liter;
 
     /*ensure all current elements follow new customdata layout*/
     BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
       BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
-        tmp = NULL;
+        void *tmp = NULL;
         CustomData_bmesh_copy_data(&destold, dest, l->head.data, &tmp);
         CustomData_bmesh_free_block(&destold, &l->head.data);
         l->head.data = tmp;
@@ -3707,16 +3616,13 @@ bool CustomData_bmesh_merge(const CustomData *source,
 
 void CustomData_bmesh_free_block(CustomData *data, void **block)
 {
-  const LayerTypeInfo *typeInfo;
-  int i;
-
   if (*block == NULL) {
     return;
   }
 
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     if (!(data->layers[i].flag & CD_FLAG_NOFREE)) {
-      typeInfo = layerType_getInfo(data->layers[i].type);
+      const LayerTypeInfo *typeInfo = layerType_getInfo(data->layers[i].type);
 
       if (typeInfo->free) {
         int offset = data->layers[i].offset;
@@ -3756,7 +3662,6 @@ void CustomData_bmesh_free_block_data(CustomData *data, void *block)
 
 static void CustomData_bmesh_alloc_block(CustomData *data, void **block)
 {
-
   if (*block) {
     CustomData_bmesh_free_block(data, block);
   }
@@ -3810,13 +3715,11 @@ static void CustomData_bmesh_set_default_n(CustomData *data, void **block, int n
 
 void CustomData_bmesh_set_default(CustomData *data, void **block)
 {
-  int i;
-
   if (*block == NULL) {
     CustomData_bmesh_alloc_block(data, block);
   }
 
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     CustomData_bmesh_set_default_n(data, block, i);
   }
 }
@@ -3830,7 +3733,6 @@ void CustomData_bmesh_copy_data_exclude_by_type(const CustomData *source,
   /* Note that having a version of this function without a 'mask_exclude'
    * would cause too much duplicate code, so add a check instead. */
   const bool no_mask = (mask_exclude == 0);
-  int dest_i, src_i;
 
   if (*dest_block == NULL) {
     CustomData_bmesh_alloc_block(dest, dest_block);
@@ -3840,8 +3742,8 @@ void CustomData_bmesh_copy_data_exclude_by_type(const CustomData *source,
   }
 
   /* copies a layer at a time */
-  dest_i = 0;
-  for (src_i = 0; src_i < source->totlayer; src_i++) {
+  int dest_i = 0;
+  for (int 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)
@@ -3898,10 +3800,8 @@ void CustomData_bmesh_copy_data(const CustomData *source,
  */
 void *CustomData_bmesh_get(const CustomData *data, void *block, int type)
 {
-  int layer_index;
-
   /* get the layer index of the first layer of type */
-  layer_index = CustomData_get_active_layer_index(data, type);
+  int layer_index = CustomData_get_active_layer_index(data, type);
   if (layer_index == -1) {
     return NULL;
   }
@@ -3911,10 +3811,8 @@ void *CustomData_bmesh_get(const CustomData *data, void *block, int type)
 
 void *CustomData_bmesh_get_n(const CustomData *data, void *block, int type, int n)
 {
-  int layer_index;
-
   /* get the layer index of the first layer of type */
-  layer_index = CustomData_get_layer_index(data, type);
+  int layer_index = CustomData_get_layer_index(data, type);
   if (layer_index == -1) {
     return NULL;
   }
@@ -3957,10 +3855,8 @@ bool CustomData_layer_has_interp(const struct CustomData *data, int layer_n)
 
 bool CustomData_has_math(const struct CustomData *data)
 {
-  int i;
-
   /* interpolates a layer at a time */
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     if (CustomData_layer_has_math(data, i)) {
       return true;
     }
@@ -3972,12 +3868,9 @@ bool CustomData_has_math(const struct CustomData *data)
 /* a non bmesh version would have to check layer->data */
 bool CustomData_bmesh_has_free(const struct CustomData *data)
 {
-  const LayerTypeInfo *typeInfo;
-  int i;
-
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     if (!(data->layers[i].flag & CD_FLAG_NOFREE)) {
-      typeInfo = layerType_getInfo(data->layers[i].type);
+      const LayerTypeInfo *typeInfo = layerType_getInfo(data->layers[i].type);
       if (typeInfo->free) {
         return true;
       }
@@ -3988,10 +3881,8 @@ bool CustomData_bmesh_has_free(const struct CustomData *data)
 
 bool CustomData_has_interp(const struct CustomData *data)
 {
-  int i;
-
   /* interpolates a layer at a time */
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     if (CustomData_layer_has_interp(data, i)) {
       return true;
     }
@@ -4002,8 +3893,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 (int i = 0; i < data->totlayer; i++) {
     if (data->layers[i].flag & CD_FLAG_NOFREE) {
       return true;
     }
@@ -4210,16 +4100,13 @@ void CustomData_to_bmesh_block(const CustomData *source,
                                void **dest_block,
                                bool use_default_init)
 {
-  const LayerTypeInfo *typeInfo;
-  int dest_i, src_i;
-
   if (*dest_block == NULL) {
     CustomData_bmesh_alloc_block(dest, dest_block);
   }
 
   /* copies a layer at a time */
-  dest_i = 0;
-  for (src_i = 0; src_i < source->totlayer; src_i++) {
+  int dest_i = 0;
+  for (int 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)
@@ -4242,7 +4129,7 @@ void CustomData_to_bmesh_block(const CustomData *source,
       const void *src_data = source->layers[src_i].data;
       void *dest_data = POINTER_OFFSET(*dest_block, offset);
 
-      typeInfo = layerType_getInfo(dest->layers[dest_i].type);
+      const LayerTypeInfo *typeInfo = layerType_getInfo(dest->layers[dest_i].type);
       const size_t src_offset = (size_t)src_index * typeInfo->size;
 
       if (typeInfo->copy) {
@@ -4273,11 +4160,9 @@ void CustomData_from_bmesh_block(const CustomData *source,
                                  void *src_block,
                                  int dest_index)
 {
-  int dest_i, src_i;
-
   /* copies a layer at a time */
-  dest_i = 0;
-  for (src_i = 0; src_i < source->totlayer; src_i++) {
+  int dest_i = 0;
+  for (int 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)
@@ -4431,9 +4316,8 @@ static bool CustomData_is_property_layer(int type)
 
 static bool cd_layer_find_dupe(CustomData *data, const char *name, int type, int index)
 {
-  int i;
   /* see if there is a duplicate */
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     if (i != index) {
       CustomDataLayer *layer = &data->layers[i];
 
@@ -4520,7 +4404,6 @@ bool CustomData_verify_versions(struct CustomData *data, int index)
   const LayerTypeInfo *typeInfo;
   CustomDataLayer *layer = &data->layers[index];
   bool keeplayer = true;
-  int i;
 
   if (layer->type >= CD_NUMTYPES) {
     keeplayer = false; /* unknown layer type from future version */
@@ -4548,7 +4431,7 @@ bool CustomData_verify_versions(struct CustomData *data, int index)
   }
 
   if (!keeplayer) {
-    for (i = index + 1; i < data->totlayer; i++) {
+    for (int i = index + 1; i < data->totlayer; i++) {
       data->layers[i - 1] = data->layers[i];
     }
     data->totlayer--;
@@ -4576,13 +4459,12 @@ bool CustomData_layer_validate(CustomDataLayer *layer, const uint totitems, cons
 
 void CustomData_layers__print(CustomData *data)
 {
-  int i;
-  const CustomDataLayer *layer;
 
   printf("{\n");
 
+  int i;
+  const CustomDataLayer *layer;
   for (i = 0, layer = data->layers; i < data->totlayer; i++, layer++) {
-
     const char *name = CustomData_layertype_name(layer->type);
     const int size = CustomData_sizeof(layer->type);
     const char *structname;
@@ -4612,13 +4494,9 @@ static void customdata_external_filename(char filename[FILE_MAX],
 
 void CustomData_external_reload(CustomData *data, ID *UNUSED(id), CustomDataMask mask, int totelem)
 {
-  CustomDataLayer *layer;
-  const LayerTypeInfo *typeInfo;
-  int i;
-
-  for (i = 0; i < data->totlayer; i++) {
-    layer = &data->layers[i];
-    typeInfo = layerType_getInfo(layer->type);
+  for (int i = 0; i < data->totlayer; i++) {
+    CustomDataLayer *layer = &data->layers[i];
+    const LayerTypeInfo *typeInfo = layerType_getInfo(layer->type);
 
     if (!(mask & CD_TYPE_AS_MASK(layer->type))) {
       /* pass */
@@ -4640,13 +4518,13 @@ void CustomData_external_read(CustomData *data, ID *id, CustomDataMask mask, int
   CDataFileLayer *blay;
   char filename[FILE_MAX];
   const LayerTypeInfo *typeInfo;
-  int i, update = 0;
+  int update = 0;
 
   if (!external) {
     return;
   }
 
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     layer = &data->layers[i];
     typeInfo = layerType_getInfo(layer->type);
 
@@ -4674,7 +4552,7 @@ void CustomData_external_read(CustomData *data, ID *id, CustomDataMask mask, int
     return;
   }
 
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     layer = &data->layers[i];
     typeInfo = layerType_getInfo(layer->type);
 
@@ -4716,7 +4594,7 @@ void CustomData_external_write(
   CDataFile *cdf;
   CDataFileLayer *blay;
   const LayerTypeInfo *typeInfo;
-  int i, update = 0;
+  int update = 0;
   char filename[FILE_MAX];
 
   if (!external) {
@@ -4724,7 +4602,7 @@ void CustomData_external_write(
   }
 
   /* test if there is anything to write */
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     layer = &data->layers[i];
     typeInfo = layerType_getInfo(layer->type);
 
@@ -4746,7 +4624,7 @@ void CustomData_external_write(
 
   cdf = cdf_create(CDF_TYPE_MESH);
 
-  for (i = 0; i < data->totlayer; i++) {
+  for (int i = 0; i < data->totlayer; i++) {
     layer = &data->layers[i];
     typeInfo = layerType_getInfo(layer->type);
 
@@ -4768,6 +4646,7 @@ void CustomData_external_write(
     return;
   }
 
+  int i;
   for (i = 0; i < data->totlayer; i++) {
     layer = &data->layers[i];
     typeInfo = layerType_getInfo(layer->type);
@@ -4844,16 +4723,13 @@ void CustomData_external_add(
 void CustomData_external_remove(CustomData *data, ID *id, int type, int totelem)
 {
   CustomDataExternal *external = data->external;
-  CustomDataLayer *layer;
-  // char filename[FILE_MAX];
-  int layer_index;  // i, remove_file;
 
-  layer_index = CustomData_get_active_layer_index(data, type);
+  int layer_index = CustomData_get_active_layer_index(data, type);
   if (layer_index == -1) {
     return;
   }
 
-  layer = &data->layers[layer_index];
+  CustomDataLayer *layer = &data->layers[layer_index];
 
   if (!external) {
     return;
@@ -4870,15 +4746,12 @@ void CustomData_external_remove(CustomData *data, ID *id, int type, int totelem)
 
 bool CustomData_external_test(CustomData *data, int type)
 {
-  CustomDataLayer *layer;
-  int layer_index;
-
-  layer_index = CustomData_get_active_layer_index(data, type);
+  int layer_index = CustomData_get_active_layer_index(data, type);
   if (layer_index == -1) {
     return false;
   }
 
-  layer = &data->layers[layer_index];
+  CustomDataLayer *layer = &data->layers[layer_index];
   return (layer->flag & CD_FLAG_EXTERNAL) != 0;
 }
 
@@ -4974,15 +4847,13 @@ static void customdata_data_transfer_interp_generic(const CustomDataTransferLaye
   tmp_dst = MEM_mallocN(data_size, __func__);
 
   if (count > 1 && !interp_cd) {
-    int i;
-
     if (data_flag) {
       /* Boolean case, we can 'interpolate' in two groups,
        * and choose value from highest weighted group. */
       float tot_weight_true = 0.0f;
       int item_true_idx = -1, item_false_idx = -1;
 
-      for (i = 0; i < count; i++) {
+      for (int i = 0; i < count; i++) {
         if (check_bit_flag(sources[i], data_size, data_flag)) {
           tot_weight_true += weights[i];
           item_true_idx = i;
@@ -4997,7 +4868,7 @@ static void customdata_data_transfer_interp_generic(const CustomDataTransferLaye
       /* We just choose highest weighted source. */
       float max_weight = 0.0f;
 
-      for (i = 0; i < count; i++) {
+      for (int i = 0; i < count; i++) {
         if (weights[i] > max_weight) {
           max_weight = weights[i];
           best_src_idx = i;
@@ -5086,7 +4957,6 @@ void CustomData_data_transfer(const MeshPairRemap *me_remap,
 {
   MeshPairRemapItem *mapit = me_remap->items;
   const int totelem = me_remap->items_num;
-  int i;
 
   const int data_type = laymap->data_type;
   const void *data_src = laymap->data_src;
@@ -5126,11 +4996,10 @@ void CustomData_data_transfer(const MeshPairRemap *me_remap,
 
   interp = laymap->interp ? laymap->interp : customdata_data_transfer_interp_generic;
 
-  for (i = 0; i < totelem; i++, data_dst = POINTER_OFFSET(data_dst, data_step), mapit++) {
+  for (int i = 0; i < totelem; i++, data_dst = POINTER_OFFSET(data_dst, data_step), mapit++) {
     const int sources_num = mapit->sources_num;
     const float mix_factor = laymap->mix_factor *
                              (laymap->mix_weights ? laymap->mix_weights[i] : 1.0f);
-    int j;
 
     if (!sources_num) {
       /* No sources for this element, skip it. */
@@ -5143,7 +5012,7 @@ void CustomData_data_transfer(const MeshPairRemap *me_remap,
         tmp_data_src = MEM_reallocN((void *)tmp_data_src, sizeof(*tmp_data_src) * tmp_buff_size);
       }
 
-      for (j = 0; j < sources_num; j++) {
+      for (int j = 0; j < sources_num; j++) {
         const size_t src_idx = (size_t)mapit->indices_src[j];
         tmp_data_src[j] = POINTER_OFFSET(data_src, (data_step * src_idx) + data_offset);
       }