style cleanup: BM_ITER / BM_ITER_INDEX / BMO_ITER

13 files changed, 136 insertions, 136 deletions

diff --git a/source/blender/bmesh/intern/bmesh_construct.c b/source/blender/bmesh/intern/bmesh_construct.c
index ec2b9ac006f..179feeccb18 100644
--- a/source/blender/bmesh/intern/bmesh_construct.c
+++ b/source/blender/bmesh/intern/bmesh_construct.c
@@ -495,7 +495,7 @@ void BMO_remove_tagged_faces(BMesh *bm, const short oflag)
 	BMFace *f;
 	BMIter iter;
 
-	BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
+	BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
 		if (BMO_elem_flag_test(bm, f, oflag)) {
 			BM_face_kill(bm, f);
 		}
@@ -507,7 +507,7 @@ void BMO_remove_tagged_edges(BMesh *bm, const short oflag)
 	BMEdge *e;
 	BMIter iter;
 
-	BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
+	BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
 		if (BMO_elem_flag_test(bm, e, oflag)) {
 			BM_edge_kill(bm, e);
 		}
@@ -519,7 +519,7 @@ void BMO_remove_tagged_verts(BMesh *bm, const short oflag)
 	BMVert *v;
 	BMIter iter;
 
-	BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+	BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
 		if (BMO_elem_flag_test(bm, v, oflag)) {
 			BM_vert_kill(bm, v);
 		}
@@ -545,14 +545,14 @@ static void bmo_remove_tagged_context_verts(BMesh *bm, const short oflag)
 	BMIter iter;
 	BMIter itersub;
 
-	BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+	BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
 		if (BMO_elem_flag_test(bm, v, oflag)) {
 			/* Visit edge */
-			BM_ITER(e, &itersub, bm, BM_EDGES_OF_VERT, v) {
+			BM_ITER (e, &itersub, bm, BM_EDGES_OF_VERT, v) {
 				BMO_elem_flag_enable(bm, e, oflag);
 			}
 			/* Visit face */
-			BM_ITER(f, &itersub, bm, BM_FACES_OF_VERT, v) {
+			BM_ITER (f, &itersub, bm, BM_FACES_OF_VERT, v) {
 				BMO_elem_flag_enable(bm, f, oflag);
 			}
 		}
@@ -571,9 +571,9 @@ static void bmo_remove_tagged_context_edges(BMesh *bm, const short oflag)
 	BMIter iter;
 	BMIter itersub;
 
-	BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
+	BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
 		if (BMO_elem_flag_test(bm, e, oflag)) {
-			BM_ITER(f, &itersub, bm, BM_FACES_OF_EDGE, e) {
+			BM_ITER (f, &itersub, bm, BM_FACES_OF_EDGE, e) {
 				BMO_elem_flag_enable(bm, f, oflag);
 			}
 		}
@@ -610,7 +610,7 @@ void BMO_remove_tagged_context(BMesh *bm, const short oflag, const int type)
 		case DEL_EDGES:
 		{
 			/* flush down to vert */
-			BM_ITER(e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
+			BM_ITER (e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
 				if (BMO_elem_flag_test(bm, e, oflag)) {
 					BMO_elem_flag_enable(bm, e->v1, oflag);
 					BMO_elem_flag_enable(bm, e->v2, oflag);
@@ -618,7 +618,7 @@ void BMO_remove_tagged_context(BMesh *bm, const short oflag, const int type)
 			}
 			bmo_remove_tagged_context_edges(bm, oflag);
 			/* remove loose vertice */
-			BM_ITER(v, &viter, bm, BM_VERTS_OF_MESH, NULL) {
+			BM_ITER (v, &viter, bm, BM_VERTS_OF_MESH, NULL) {
 				if (BMO_elem_flag_test(bm, v, oflag) && (!(v->e)))
 					BMO_elem_flag_enable(bm, v, DEL_WIREVERT);
 			}
@@ -649,7 +649,7 @@ void BMO_remove_tagged_context(BMesh *bm, const short oflag, const int type)
 		case DEL_FACES:
 		{
 			/* go through and mark all edges and all verts of all faces for delet */
-			BM_ITER(f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
+			BM_ITER (f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
 				if (BMO_elem_flag_test(bm, f, oflag)) {
 					for (e = BM_iter_new(&eiter, bm, BM_EDGES_OF_FACE, f); e; e = BM_iter_step(&eiter))
 						BMO_elem_flag_enable(bm, e, oflag);
@@ -658,7 +658,7 @@ void BMO_remove_tagged_context(BMesh *bm, const short oflag, const int type)
 				}
 			}
 			/* now go through and mark all remaining faces all edges for keeping */
-			BM_ITER(f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
+			BM_ITER (f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
 				if (!BMO_elem_flag_test(bm, f, oflag)) {
 					for (e = BM_iter_new(&eiter, bm, BM_EDGES_OF_FACE, f); e; e = BM_iter_step(&eiter)) {
 						BMO_elem_flag_disable(bm, e, oflag);
@@ -669,7 +669,7 @@ void BMO_remove_tagged_context(BMesh *bm, const short oflag, const int type)
 				}
 			}
 			/* also mark all the vertices of remaining edges for keeping */
-			BM_ITER(e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
+			BM_ITER (e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
 				if (!BMO_elem_flag_test(bm, e, oflag)) {
 					BMO_elem_flag_disable(bm, e->v1, oflag);
 					BMO_elem_flag_disable(bm, e->v2, oflag);
@@ -687,13 +687,13 @@ void BMO_remove_tagged_context(BMesh *bm, const short oflag, const int type)
 		case DEL_ALL:
 		{
 			/* does this option even belong in here? */
-			BM_ITER(f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
+			BM_ITER (f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
 				BMO_elem_flag_enable(bm, f, oflag);
 			}
-			BM_ITER(e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
+			BM_ITER (e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
 				BMO_elem_flag_enable(bm, e, oflag);
 			}
-			BM_ITER(v, &viter, bm, BM_VERTS_OF_MESH, NULL) {
+			BM_ITER (v, &viter, bm, BM_VERTS_OF_MESH, NULL) {
 				BMO_elem_flag_enable(bm, v, oflag);
 			}
 
diff --git a/source/blender/bmesh/intern/bmesh_core.c b/source/blender/bmesh/intern/bmesh_core.c
index 8b1fee3b33f..ce1474e37af 100644
--- a/source/blender/bmesh/intern/bmesh_core.c
+++ b/source/blender/bmesh/intern/bmesh_core.c
@@ -1746,7 +1746,7 @@ int BM_vert_splice(BMesh *bm, BMVert *v, BMVert *vtarget)
 	}
 
 	/* retarget all the loops of v to vtarget */
-	BM_ITER(l, &liter, bm, BM_LOOPS_OF_VERT, v) {
+	BM_ITER (l, &liter, bm, BM_LOOPS_OF_VERT, v) {
 		l->v = vtarget;
 	}
 
@@ -1792,7 +1792,7 @@ int bmesh_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len)
 	visithash = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, __func__);
 
 	maxindex = 0;
-	BM_ITER(e, &eiter, bm, BM_EDGES_OF_VERT, v) {
+	BM_ITER (e, &eiter, bm, BM_EDGES_OF_VERT, v) {
 		if (BLI_ghash_haskey(visithash, e)) {
 			continue;
 		}
@@ -1805,7 +1805,7 @@ int bmesh_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len)
 		while ((e = BLI_array_pop(stack))) {
 			BLI_ghash_insert(visithash, e, SET_INT_IN_POINTER(maxindex));
 
-			BM_ITER(l, &liter, bm, BM_LOOPS_OF_EDGE, e) {
+			BM_ITER (l, &liter, bm, BM_LOOPS_OF_EDGE, e) {
 				nl = (l->v == v) ? l->prev : l->next;
 				if (!BLI_ghash_haskey(visithash, nl->e)) {
 					BLI_array_append(stack, nl->e);
@@ -1825,7 +1825,7 @@ int bmesh_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len)
 
 	/* Replace v with the new verts in each group */
 #if 0
-	BM_ITER(l, &liter, bm, BM_LOOPS_OF_VERT, v) {
+	BM_ITER (l, &liter, bm, BM_LOOPS_OF_VERT, v) {
 		/* call first since its faster then a hash lookup */
 		if (l->v != v) {
 			continue;
@@ -1851,7 +1851,7 @@ int bmesh_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len)
 	 * bad practice but save alloc'ing a new array - note, the comment above is useful, keep it
 	 * if you are tidying up code - campbell */
 	BLI_array_empty(stack);
-	BM_ITER(l, &liter, bm, BM_LOOPS_OF_VERT, v) {
+	BM_ITER (l, &liter, bm, BM_LOOPS_OF_VERT, v) {
 		if (l->v == v) {
 			BLI_array_append(stack, (BMEdge *)l);
 		}
@@ -1865,7 +1865,7 @@ int bmesh_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len)
 
 	BLI_array_free(stack);
 
-	BM_ITER(e, &eiter, bm, BM_EDGES_OF_VERT, v) {
+	BM_ITER (e, &eiter, bm, BM_EDGES_OF_VERT, v) {
 		i = GET_INT_FROM_POINTER(BLI_ghash_lookup(visithash, e));
 		if (i == 0) {
 			continue;
diff --git a/source/blender/bmesh/intern/bmesh_interp.c b/source/blender/bmesh/intern/bmesh_interp.c
index 2a3242d87c1..d8a977c5431 100644
--- a/source/blender/bmesh/intern/bmesh_interp.c
+++ b/source/blender/bmesh/intern/bmesh_interp.c
@@ -489,7 +489,7 @@ void BM_face_multires_bounds_smooth(BMesh *bm, BMFace *f)
 	if (!CustomData_has_layer(&bm->ldata, CD_MDISPS))
 		return;
 	
-	BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) {
+	BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
 		MDisps *mdp = CustomData_bmesh_get(&bm->ldata, l->prev->head.data, CD_MDISPS);
 		MDisps *mdl = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MDISPS);
 		MDisps *mdn = CustomData_bmesh_get(&bm->ldata, l->next->head.data, CD_MDISPS);
@@ -521,7 +521,7 @@ void BM_face_multires_bounds_smooth(BMesh *bm, BMFace *f)
 		}
 	}
 	
-	BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) {
+	BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
 		MDisps *mdl1 = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MDISPS);
 		MDisps *mdl2;
 		float co1[3], co2[3], co[3];
@@ -726,7 +726,7 @@ static void update_data_blocks(BMesh *bm, CustomData *olddata, CustomData *data)
 
 		CustomData_bmesh_init_pool(data, bm->totvert, BM_VERT);
 
-		BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+		BM_ITER (eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
 			block = NULL;
 			CustomData_bmesh_set_default(data, &block);
 			CustomData_bmesh_copy_data(olddata, data, eve->head.data, &block);
@@ -739,7 +739,7 @@ static void update_data_blocks(BMesh *bm, CustomData *olddata, CustomData *data)
 
 		CustomData_bmesh_init_pool(data, bm->totedge, BM_EDGE);
 
-		BM_ITER(eed, &iter, bm, BM_EDGES_OF_MESH, NULL) {
+		BM_ITER (eed, &iter, bm, BM_EDGES_OF_MESH, NULL) {
 			block = NULL;
 			CustomData_bmesh_set_default(data, &block);
 			CustomData_bmesh_copy_data(olddata, data, eed->head.data, &block);
@@ -753,8 +753,8 @@ static void update_data_blocks(BMesh *bm, CustomData *olddata, CustomData *data)
 		BMLoop *l;
 
 		CustomData_bmesh_init_pool(data, bm->totloop, BM_LOOP);
-		BM_ITER(efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
-			BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
+		BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
+			BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, efa) {
 				block = NULL;
 				CustomData_bmesh_set_default(data, &block);
 				CustomData_bmesh_copy_data(olddata, data, l->head.data, &block);
@@ -768,7 +768,7 @@ static void update_data_blocks(BMesh *bm, CustomData *olddata, CustomData *data)
 
 		CustomData_bmesh_init_pool(data, bm->totface, BM_FACE);
 
-		BM_ITER(efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
+		BM_ITER (efa, &iter, bm, BM_FACES_OF_MESH, NULL) {
 			block = NULL;
 			CustomData_bmesh_set_default(data, &block);
 			CustomData_bmesh_copy_data(olddata, data, efa->head.data, &block);
diff --git a/source/blender/bmesh/intern/bmesh_iterators.c b/source/blender/bmesh/intern/bmesh_iterators.c
index b53896ae722..b234d4514c0 100644
--- a/source/blender/bmesh/intern/bmesh_iterators.c
+++ b/source/blender/bmesh/intern/bmesh_iterators.c
@@ -93,7 +93,7 @@ int BM_iter_as_array(BMesh *bm, const char type, void *data, void **array, const
 		BMIter iter;
 		void *val;
 
-		BM_ITER(val, &iter, bm, type, data) {
+		BM_ITER (val, &iter, bm, type, data) {
 			array[i] = val;
 			i++;
 			if (i == len) {
diff --git a/source/blender/bmesh/intern/bmesh_marking.c b/source/blender/bmesh/intern/bmesh_marking.c
index 3492b4257cb..faf2d79046a 100644
--- a/source/blender/bmesh/intern/bmesh_marking.c
+++ b/source/blender/bmesh/intern/bmesh_marking.c
@@ -84,7 +84,7 @@ void BM_mesh_select_mode_flush(BMesh *bm)
 	int ok;
 
 	if (bm->selectmode & SCE_SELECT_VERTEX) {
-		BM_ITER(e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
+		BM_ITER (e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
 			if (BM_elem_flag_test(e->v1, BM_ELEM_SELECT) &&
 			    BM_elem_flag_test(e->v2, BM_ELEM_SELECT) &&
 			    !BM_elem_flag_test(e, BM_ELEM_HIDDEN))
@@ -95,7 +95,7 @@ void BM_mesh_select_mode_flush(BMesh *bm)
 				BM_elem_flag_disable(e, BM_ELEM_SELECT);
 			}
 		}
-		BM_ITER(f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
+		BM_ITER (f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
 			ok = TRUE;
 			if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) {
 				l_iter = l_first = BM_FACE_FIRST_LOOP(f);
@@ -114,7 +114,7 @@ void BM_mesh_select_mode_flush(BMesh *bm)
 		}
 	}
 	else if (bm->selectmode & SCE_SELECT_EDGE) {
-		BM_ITER(f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
+		BM_ITER (f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
 			ok = TRUE;
 			if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) {
 				l_iter = l_first = BM_FACE_FIRST_LOOP(f);
@@ -154,7 +154,7 @@ void BM_mesh_deselect_flush(BMesh *bm)
 
 	int ok;
 
-	BM_ITER(e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
+	BM_ITER (e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
 		if (!(BM_elem_flag_test(e->v1, BM_ELEM_SELECT) &&
 		      BM_elem_flag_test(e->v2, BM_ELEM_SELECT) &&
 		      !BM_elem_flag_test(e, BM_ELEM_HIDDEN)))
@@ -163,7 +163,7 @@ void BM_mesh_deselect_flush(BMesh *bm)
 		}
 	}
 
-	BM_ITER(f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
+	BM_ITER (f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
 		ok = TRUE;
 		if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) {
 			l_iter = l_first = BM_FACE_FIRST_LOOP(f);
@@ -205,7 +205,7 @@ void BM_mesh_select_flush(BMesh *bm)
 
 	int ok;
 
-	BM_ITER(e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
+	BM_ITER (e, &eiter, bm, BM_EDGES_OF_MESH, NULL) {
 		if (BM_elem_flag_test(e->v1, BM_ELEM_SELECT) &&
 		    BM_elem_flag_test(e->v2, BM_ELEM_SELECT) &&
 		    !BM_elem_flag_test(e, BM_ELEM_HIDDEN))
@@ -214,7 +214,7 @@ void BM_mesh_select_flush(BMesh *bm)
 		}
 	}
 
-	BM_ITER(f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
+	BM_ITER (f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
 		ok = TRUE;
 		if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) {
 			l_iter = l_first = BM_FACE_FIRST_LOOP(f);
@@ -360,10 +360,10 @@ void BM_face_select_set(BMesh *bm, BMFace *f, int select)
 		BM_elem_flag_disable(f, BM_ELEM_SELECT);
 
 		/* flush down to edges */
-		BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) {
+		BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
 			BMIter fiter;
 			BMFace *f2;
-			BM_ITER(f2, &fiter, bm, BM_FACES_OF_EDGE, l->e) {
+			BM_ITER (f2, &fiter, bm, BM_FACES_OF_EDGE, l->e) {
 				if (BM_elem_flag_test(f2, BM_ELEM_SELECT))
 					break;
 			}
@@ -374,10 +374,10 @@ void BM_face_select_set(BMesh *bm, BMFace *f, int select)
 		}
 
 		/* flush down to verts */
-		BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) {
+		BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
 			BMIter eiter;
 			BMEdge *e;
-			BM_ITER(e, &eiter, bm, BM_EDGES_OF_VERT, l->v) {
+			BM_ITER (e, &eiter, bm, BM_EDGES_OF_VERT, l->v) {
 				if (BM_elem_flag_test(e, BM_ELEM_SELECT))
 					break;
 			}
@@ -405,10 +405,10 @@ void BM_mesh_select_mode_set(BMesh *bm, int selectmode)
 	if (bm->selectmode & SCE_SELECT_VERTEX) {
 		/* disabled because selection flushing handles these */
 #if 0
-		BM_ITER(ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
+		BM_ITER (ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
 			BM_elem_flag_disable(ele, BM_ELEM_SELECT);
 		}
-		BM_ITER(ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
+		BM_ITER (ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
 			BM_elem_flag_disable(ele, BM_ELEM_SELECT);
 		}
 #endif
@@ -417,12 +417,12 @@ void BM_mesh_select_mode_set(BMesh *bm, int selectmode)
 	else if (bm->selectmode & SCE_SELECT_EDGE) {
 		/* disabled because selection flushing handles these */
 #if 0
-		BM_ITER(ele, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+		BM_ITER (ele, &iter, bm, BM_VERTS_OF_MESH, NULL) {
 			BM_elem_flag_disable(ele, BM_ELEM_SELECT);
 		}
 #endif
 
-		BM_ITER(ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
+		BM_ITER (ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
 			if (BM_elem_flag_test(ele, BM_ELEM_SELECT)) {
 				BM_edge_select_set(bm, (BMEdge *)ele, TRUE);
 			}
@@ -432,11 +432,11 @@ void BM_mesh_select_mode_set(BMesh *bm, int selectmode)
 	else if (bm->selectmode & SCE_SELECT_FACE) {
 		/* disabled because selection flushing handles these */
 #if 0
-		BM_ITER(ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
+		BM_ITER (ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
 			BM_elem_flag_disable(ele, BM_ELEM_SELECT);
 		}
 #endif
-		BM_ITER(ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
+		BM_ITER (ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
 			if (BM_elem_flag_test(ele, BM_ELEM_SELECT)) {
 				BM_face_select_set(bm, (BMFace *)ele, TRUE);
 			}
@@ -543,7 +543,7 @@ BMFace *BM_active_face_get(BMesh *bm, int sloppy)
 		}
 		/* Last attempt: try to find any selected face */
 		if (f == NULL) {
-			BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
+			BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
 				if (BM_elem_flag_test(f, BM_ELEM_SELECT)) {
 					break;
 				}
@@ -896,7 +896,7 @@ static void vert_flush_hide_set(BMesh *bm, BMVert *v)
 	BMEdge *e;
 	int hide = TRUE;
 
-	BM_ITER(e, &iter, bm, BM_EDGES_OF_VERT, v) {
+	BM_ITER (e, &iter, bm, BM_EDGES_OF_VERT, v) {
 		hide = hide && BM_elem_flag_test(e, BM_ELEM_HIDDEN);
 	}
 
@@ -909,7 +909,7 @@ static void edge_flush_hide(BMesh *bm, BMEdge *e)
 	BMFace *f;
 	int hide = TRUE;
 
-	BM_ITER(f, &iter, bm, BM_FACES_OF_EDGE, e) {
+	BM_ITER (f, &iter, bm, BM_FACES_OF_EDGE, e) {
 		hide = hide && BM_elem_flag_test(f, BM_ELEM_HIDDEN);
 	}
 
@@ -925,10 +925,10 @@ void BM_vert_hide_set(BMesh *bm, BMVert *v, int hide)
 
 	BM_elem_flag_set(v, BM_ELEM_HIDDEN, hide);
 
-	BM_ITER(e, &iter, bm, BM_EDGES_OF_VERT, v) {
+	BM_ITER (e, &iter, bm, BM_EDGES_OF_VERT, v) {
 		BM_elem_flag_set(e, BM_ELEM_HIDDEN, hide);
 
-		BM_ITER(f, &fiter, bm, BM_FACES_OF_EDGE, e) {
+		BM_ITER (f, &fiter, bm, BM_FACES_OF_EDGE, e) {
 			BM_elem_flag_set(f, BM_ELEM_HIDDEN, hide);
 		}
 	}
@@ -941,7 +941,7 @@ void BM_edge_hide_set(BMesh *bm, BMEdge *e, int hide)
 	/* BMVert *v; */
 
 	/* edge hiding: faces around the edge */
-	BM_ITER(f, &iter, bm, BM_FACES_OF_EDGE, e) {
+	BM_ITER (f, &iter, bm, BM_FACES_OF_EDGE, e) {
 		BM_elem_flag_set(f, BM_ELEM_HIDDEN, hide);
 	}
 	
@@ -959,11 +959,11 @@ void BM_face_hide_set(BMesh *bm, BMFace *f, int hide)
 
 	BM_elem_flag_set(f, BM_ELEM_HIDDEN, hide);
 
-	BM_ITER(l, &iter, bm, BM_LOOPS_OF_FACE, f) {
+	BM_ITER (l, &iter, bm, BM_LOOPS_OF_FACE, f) {
 		edge_flush_hide(bm, l->e);
 	}
 
-	BM_ITER(l, &iter, bm, BM_LOOPS_OF_FACE, f) {
+	BM_ITER (l, &iter, bm, BM_LOOPS_OF_FACE, f) {
 		vert_flush_hide_set(bm, l->v);
 	}
 }
diff --git a/source/blender/bmesh/intern/bmesh_mesh.c b/source/blender/bmesh/intern/bmesh_mesh.c
index c15937abf1d..826d4db4556 100644
--- a/source/blender/bmesh/intern/bmesh_mesh.c
+++ b/source/blender/bmesh/intern/bmesh_mesh.c
@@ -104,15 +104,15 @@ void BM_mesh_data_free(BMesh *bm)
 	BMIter iter;
 	BMIter itersub;
 	
-	BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+	BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
 		CustomData_bmesh_free_block(&(bm->vdata), &(v->head.data));
 	}
-	BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
+	BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
 		CustomData_bmesh_free_block(&(bm->edata), &(e->head.data));
 	}
-	BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
+	BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
 		CustomData_bmesh_free_block(&(bm->pdata), &(f->head.data));
-		BM_ITER(l, &itersub, bm, BM_LOOPS_OF_FACE, f) {
+		BM_ITER (l, &itersub, bm, BM_LOOPS_OF_FACE, f) {
 			CustomData_bmesh_free_block(&(bm->ldata), &(l->head.data));
 		}
 	}
@@ -211,7 +211,7 @@ void BM_mesh_normals_update(BMesh *bm, const short skip_hidden)
 	float (*edgevec)[3];
 	
 	/* calculate all face normals */
-	BM_ITER(f, &faces, bm, BM_FACES_OF_MESH, NULL) {
+	BM_ITER (f, &faces, bm, BM_FACES_OF_MESH, NULL) {
 		if (skip_hidden && BM_elem_flag_test(f, BM_ELEM_HIDDEN))
 			continue;
 #if 0	/* UNUSED */
@@ -223,7 +223,7 @@ void BM_mesh_normals_update(BMesh *bm, const short skip_hidden)
 	}
 	
 	/* Zero out vertex normals */
-	BM_ITER(v, &verts, bm, BM_VERTS_OF_MESH, NULL) {
+	BM_ITER (v, &verts, bm, BM_VERTS_OF_MESH, NULL) {
 		if (skip_hidden && BM_elem_flag_test(v, BM_ELEM_HIDDEN))
 			continue;
 
@@ -235,7 +235,7 @@ void BM_mesh_normals_update(BMesh *bm, const short skip_hidden)
 	 * normals */
 	index = 0;
 	edgevec = MEM_callocN(sizeof(float) * 3 * bm->totedge, "BM normal computation array");
-	BM_ITER(e, &edges, bm, BM_EDGES_OF_MESH, NULL) {
+	BM_ITER (e, &edges, bm, BM_EDGES_OF_MESH, NULL) {
 		BM_elem_index_set(e, index); /* set_inline */
 
 		if (e->l) {
@@ -251,12 +251,12 @@ void BM_mesh_normals_update(BMesh *bm, const short skip_hidden)
 	bm->elem_index_dirty &= ~BM_EDGE;
 
 	/* add weighted face normals to vertices */
-	BM_ITER(f, &faces, bm, BM_FACES_OF_MESH, NULL) {
+	BM_ITER (f, &faces, bm, BM_FACES_OF_MESH, NULL) {
 
 		if (skip_hidden && BM_elem_flag_test(f, BM_ELEM_HIDDEN))
 			continue;
 
-		BM_ITER(l, &loops, bm, BM_LOOPS_OF_FACE, f) {
+		BM_ITER (l, &loops, bm, BM_LOOPS_OF_FACE, f) {
 			float *e1diff, *e2diff;
 			float dotprod;
 			float fac;
@@ -282,7 +282,7 @@ void BM_mesh_normals_update(BMesh *bm, const short skip_hidden)
 	}
 	
 	/* normalize the accumulated vertex normals */
-	BM_ITER(v, &verts, bm, BM_VERTS_OF_MESH, NULL) {
+	BM_ITER (v, &verts, bm, BM_VERTS_OF_MESH, NULL) {
 		if (skip_hidden && BM_elem_flag_test(v, BM_ELEM_HIDDEN))
 			continue;
 
@@ -312,7 +312,7 @@ static void bm_rationalize_normals(BMesh *bm, int undo)
 	BMIter iter;
 	
 	if (undo) {
-		BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
+		BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
 			if (BM_elem_flag_test(f, BM_ELEM_TAG)) {
 				BM_face_normal_flip(bm, f);
 			}
@@ -327,7 +327,7 @@ static void bm_rationalize_normals(BMesh *bm, int undo)
 	BMO_push(bm, &bmop);
 	bmo_righthandfaces_exec(bm, &bmop);
 	
-	BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
+	BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
 		BM_elem_flag_set(f, BM_ELEM_TAG, BMO_elem_flag_test(bm, f, FACE_FLIP));
 	}
 
@@ -350,10 +350,10 @@ static void UNUSED_FUNCTION(bm_mdisps_space_set)(Object *ob, BMesh *bm, int from
 		
 		mdisps = CustomData_get_layer(&dm->loopData, CD_MDISPS);
 		
-		BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
+		BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
 			BMLoop *l;
 			BMIter liter;
-			BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) {
+			BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
 				MDisps *lmd = CustomData_bmesh_get(&bm->ldata, l->head.data, CD_MDISPS);
 				
 				if (!lmd->disps) {
@@ -463,7 +463,7 @@ void BM_mesh_elem_index_ensure(BMesh *bm, const char hflag)
 	if (hflag & BM_VERT) {
 		if (bm->elem_index_dirty & BM_VERT) {
 			int index = 0;
-			BM_ITER(ele, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+			BM_ITER (ele, &iter, bm, BM_VERTS_OF_MESH, NULL) {
 				BM_elem_index_set(ele, index); /* set_ok */
 				index++;
 			}
@@ -478,7 +478,7 @@ void BM_mesh_elem_index_ensure(BMesh *bm, const char hflag)
 	if (hflag & BM_EDGE) {
 		if (bm->elem_index_dirty & BM_EDGE) {
 			int index = 0;
-			BM_ITER(ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
+			BM_ITER (ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
 				BM_elem_index_set(ele, index); /* set_ok */
 				index++;
 			}
@@ -493,7 +493,7 @@ void BM_mesh_elem_index_ensure(BMesh *bm, const char hflag)
 	if (hflag & BM_FACE) {
 		if (bm->elem_index_dirty & BM_FACE) {
 			int index = 0;
-			BM_ITER(ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
+			BM_ITER (ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
 				BM_elem_index_set(ele, index); /* set_ok */
 				index++;
 			}
@@ -540,7 +540,7 @@ void BM_mesh_elem_index_validate(BMesh *bm, const char *location, const char *fu
 		int err_val = 0;
 		int err_idx = 0;
 
-		BM_ITER(ele, &iter, bm, iter_types[i], NULL) {
+		BM_ITER (ele, &iter, bm, iter_types[i], NULL) {
 			if (!is_dirty) {
 				if (BM_elem_index_get(ele) != index) {
 					err_val = BM_elem_index_get(ele);
diff --git a/source/blender/bmesh/intern/bmesh_mesh_conv.c b/source/blender/bmesh/intern/bmesh_mesh_conv.c
index c8876e55431..cc96cfbef6d 100644
--- a/source/blender/bmesh/intern/bmesh_mesh_conv.c
+++ b/source/blender/bmesh/intern/bmesh_mesh_conv.c
@@ -336,7 +336,7 @@ void BM_mesh_bm_from_me(BMesh *bm, Mesh *me, int set_key, int act_key_nr)
 		if (i == me->act_face) bm->act_face = f;
 
 		j = 0;
-		BM_ITER_INDEX(l, &iter, bm, BM_LOOPS_OF_FACE, f, j) {
+		BM_ITER_INDEX (l, &iter, bm, BM_LOOPS_OF_FACE, f, j) {
 			/* Save index of correspsonding MLoop */
 			BM_elem_index_set(l, mpoly->loopstart + j); /* set_loop */
 		}
@@ -355,8 +355,8 @@ void BM_mesh_bm_from_me(BMesh *bm, Mesh *me, int set_key, int act_key_nr)
 		 * but is an optimization, to avoid copying a bunch of interpolated customdata
 		 * for each BMLoop (from previous BMLoops using the same edge), always followed
 		 * by freeing the interpolated data and overwriting it with data from the Mesh. */
-		BM_ITER(f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
-			BM_ITER(l, &liter, bm, BM_LOOPS_OF_FACE, f) {
+		BM_ITER (f, &fiter, bm, BM_FACES_OF_MESH, NULL) {
+			BM_ITER (l, &liter, bm, BM_LOOPS_OF_FACE, f) {
 				int li = BM_elem_index_get(l);
 				CustomData_to_bmesh_block(&me->ldata, &bm->ldata, li, &l->head.data);
 				BM_elem_index_set(l, 0); /* set_loop */
@@ -379,9 +379,9 @@ void BM_mesh_bm_from_me(BMesh *bm, Mesh *me, int set_key, int act_key_nr)
 		BMFace  *face;
 		MSelect *msel;
 
-		BM_ITER_INDEX(vert, &iter, bm, BM_VERTS_OF_MESH, NULL, i) { vert_array[i] = vert; }
-		BM_ITER_INDEX(edge, &iter, bm, BM_EDGES_OF_MESH, NULL, i) { edge_array[i] = edge; }
-		BM_ITER_INDEX(face, &iter, bm, BM_FACES_OF_MESH, NULL, i) { face_array[i] = face; }
+		BM_ITER_INDEX (vert, &iter, bm, BM_VERTS_OF_MESH, NULL, i) { vert_array[i] = vert; }
+		BM_ITER_INDEX (edge, &iter, bm, BM_EDGES_OF_MESH, NULL, i) { edge_array[i] = edge; }
+		BM_ITER_INDEX (face, &iter, bm, BM_FACES_OF_MESH, NULL, i) { face_array[i] = face; }
 
 		for (i = 0, msel = me->mselect; i < me->totselect; i++, msel++) {
 			switch (msel->type) {
@@ -432,7 +432,7 @@ static BMVert **bm_to_mesh_vertex_map(BMesh *bm, int ototvert)
 	vertMap = MEM_callocN(sizeof(*vertMap) * ototvert, "vertMap");
 	if (CustomData_has_layer(&bm->vdata, CD_SHAPE_KEYINDEX)) {
 		int *keyi;
-		BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+		BM_ITER (eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
 			keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
 			if (keyi) {
 				if (((index = *keyi) != ORIGINDEX_NONE) && (index < ototvert)) {
@@ -448,7 +448,7 @@ static BMVert **bm_to_mesh_vertex_map(BMesh *bm, int ototvert)
 		}
 	}
 	else {
-		BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+		BM_ITER (eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
 			if (i < ototvert) {
 				vertMap[i] = eve;
 			}
@@ -564,7 +564,7 @@ void BM_mesh_bm_to_me(BMesh *bm, Mesh *me, int dotess)
 	mesh_update_customdata_pointers(me, 0);
 
 	i = 0;
-	BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+	BM_ITER (v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
 		float *bweight = CustomData_bmesh_get(&bm->vdata, v->head.data, CD_BWEIGHT);
 
 		mvert->bweight = bweight ? (char)((*bweight) * 255) : 0;
@@ -588,7 +588,7 @@ void BM_mesh_bm_to_me(BMesh *bm, Mesh *me, int dotess)
 
 	med = medge;
 	i = 0;
-	BM_ITER(e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
+	BM_ITER (e, &iter, bm, BM_EDGES_OF_MESH, NULL) {
 		float *crease = CustomData_bmesh_get(&bm->edata, e->head.data, CD_CREASE);
 		float *bweight = CustomData_bmesh_get(&bm->edata, e->head.data, CD_BWEIGHT);
 
@@ -614,7 +614,7 @@ void BM_mesh_bm_to_me(BMesh *bm, Mesh *me, int dotess)
 
 	i = 0;
 	j = 0;
-	BM_ITER(f, &iter, bm, BM_FACES_OF_MESH, NULL) {
+	BM_ITER (f, &iter, bm, BM_FACES_OF_MESH, NULL) {
 		mpoly->loopstart = j;
 		mpoly->totloop = f->len;
 		mpoly->mat_nr = f->mat_nr;
@@ -783,7 +783,7 @@ void BM_mesh_bm_to_me(BMesh *bm, Mesh *me, int dotess)
 
 				ofs = MEM_callocN(sizeof(float) * 3 * bm->totvert,  "currkey->data");
 				mvert = me->mvert;
-				BM_ITER_INDEX(eve, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
+				BM_ITER_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
 					keyi = CustomData_bmesh_get(&bm->vdata, eve->head.data, CD_SHAPE_KEYINDEX);
 					if (keyi && *keyi != ORIGINDEX_NONE) {
 						sub_v3_v3v3(ofs[i], mvert->co, fp[*keyi]);
@@ -806,7 +806,7 @@ void BM_mesh_bm_to_me(BMesh *bm, Mesh *me, int dotess)
 			oldkey = currkey->data;
 
 			mvert = me->mvert;
-			BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+			BM_ITER (eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
 
 				if (currkey == actkey) {
 					copy_v3_v3(fp, eve->co);
diff --git a/source/blender/bmesh/intern/bmesh_mesh_validate.c b/source/blender/bmesh/intern/bmesh_mesh_validate.c
index f91e9d82879..6f30134f66c 100644
--- a/source/blender/bmesh/intern/bmesh_mesh_validate.c
+++ b/source/blender/bmesh/intern/bmesh_mesh_validate.c
@@ -70,7 +70,7 @@ int BM_mesh_validate(BMesh *bm)
 	bm->elem_index_dirty |= BM_ALL;
 	BM_mesh_elem_index_ensure(bm, BM_ALL);
 
-	BM_ITER_INDEX(v, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
+	BM_ITER_INDEX (v, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
 		if (BM_elem_flag_test(v, BM_ELEM_SELECT | BM_ELEM_HIDDEN) == (BM_ELEM_SELECT | BM_ELEM_HIDDEN)) {
 			ERRMSG("vert %d: is hidden and selected", i);
 		}
@@ -83,13 +83,13 @@ int BM_mesh_validate(BMesh *bm)
 	}
 
 	/* check edges */
-	BM_ITER_INDEX(e, &iter, bm, BM_EDGES_OF_MESH, NULL, i) {
+	BM_ITER_INDEX (e, &iter, bm, BM_EDGES_OF_MESH, NULL, i) {
 		if (e->v1 == e->v2)
 		ERRMSG("edge %d: duplicate index: %d", i, BM_elem_index_get(e->v1));
 	}
 
 	/* edge radial structure */
-	BM_ITER_INDEX(e, &iter, bm, BM_EDGES_OF_MESH, NULL, i) {
+	BM_ITER_INDEX (e, &iter, bm, BM_EDGES_OF_MESH, NULL, i) {
 		if (BM_elem_flag_test(e, BM_ELEM_SELECT | BM_ELEM_HIDDEN) == (BM_ELEM_SELECT | BM_ELEM_HIDDEN)) {
 			ERRMSG("edge %d: is hidden and selected", i);
 		}
@@ -117,7 +117,7 @@ int BM_mesh_validate(BMesh *bm)
 	}
 
 	/* face structure */
-	BM_ITER_INDEX(f, &iter, bm, BM_FACES_OF_MESH, NULL, i) {
+	BM_ITER_INDEX (f, &iter, bm, BM_FACES_OF_MESH, NULL, i) {
 		BMLoop *l_iter;
 		BMLoop *l_first;
 
diff --git a/source/blender/bmesh/intern/bmesh_mods.c b/source/blender/bmesh/intern/bmesh_mods.c
index 20306d3bd4a..f4aa1133d27 100644
--- a/source/blender/bmesh/intern/bmesh_mods.c
+++ b/source/blender/bmesh/intern/bmesh_mods.c
@@ -286,8 +286,8 @@ BMEdge *BM_verts_connect(BMesh *bm, BMVert *v1, BMVert *v2, BMFace **r_f)
 	BMFace *f_iter;
 
 	/* be warned: this can do weird things in some ngon situation, see BM_face_legal_splits */
-	BM_ITER(f_iter, &fiter, bm, BM_FACES_OF_VERT, v1) {
-		BM_ITER(v_iter, &viter, bm, BM_FACES_OF_VERT, f_iter) {
+	BM_ITER (f_iter, &fiter, bm, BM_FACES_OF_VERT, v1) {
+		BM_ITER (v_iter, &viter, bm, BM_FACES_OF_VERT, f_iter) {
 			if (v_iter == v2) {
 				BMLoop *nl;
 
@@ -521,7 +521,7 @@ BMEdge *BM_vert_collapse_faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac,
 		BMFace *f;
 		BLI_array_staticdeclare(faces, 8);
 
-		BM_ITER(f, &iter, bm, BM_FACES_OF_VERT, kv) {
+		BM_ITER (f, &iter, bm, BM_FACES_OF_VERT, kv) {
 			BLI_array_append(faces, f);
 		}
 
@@ -556,7 +556,7 @@ BMEdge *BM_vert_collapse_faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac,
 			for (i = 0; i < 2; i++) {
 				/* cant kill data we loop on, build a list and remove those */
 				BLI_array_empty(bad_faces);
-				BM_ITER(f, &fiter, bm, BM_FACES_OF_VERT, verts[i]) {
+				BM_ITER (f, &fiter, bm, BM_FACES_OF_VERT, verts[i]) {
 					if (f->len < 3) {
 						BLI_array_append(bad_faces, f);
 					}
diff --git a/source/blender/bmesh/intern/bmesh_operators.c b/source/blender/bmesh/intern/bmesh_operators.c
index a1cdcc65f1c..32abaf10f64 100644
--- a/source/blender/bmesh/intern/bmesh_operators.c
+++ b/source/blender/bmesh/intern/bmesh_operators.c
@@ -473,7 +473,7 @@ static int bmo_mesh_flag_count(BMesh *bm, const char htype, const short oflag,
 
 	for (i = 0; i < 3; i++) {
 		if (htype & flag_types[i]) {
-			BM_ITER(ele_f, &iter, bm, iter_types[i], NULL) {
+			BM_ITER (ele_f, &iter, bm, iter_types[i], NULL) {
 				if (BMO_elem_flag_test_bool(bm, ele_f, oflag) == test_for_enabled)
 					count++;
 			}
@@ -508,7 +508,7 @@ void BMO_mesh_flag_disable_all(BMesh *bm, BMOperator *UNUSED(op), const char hty
 
 	for (i = 0; i < 3; i++) {
 		if (htype & flag_types[i]) {
-			BM_ITER(ele, &iter, bm, iter_types[i], NULL) {
+			BM_ITER (ele, &iter, bm, iter_types[i], NULL) {
 				BMO_elem_flag_disable(bm, ele, oflag);
 			}
 		}
@@ -663,21 +663,21 @@ static void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, const char *slot
 		/* TODO - collapse these loops into one */
 
 		if (htype & BM_VERT) {
-			BM_ITER(ele, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+			BM_ITER (ele, &iter, bm, BM_VERTS_OF_MESH, NULL) {
 				((BMHeader **)output->data.p)[i] = ele;
 				i++;
 			}
 		}
 
 		if (htype & BM_EDGE) {
-			BM_ITER(ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
+			BM_ITER (ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
 				((BMHeader **)output->data.p)[i] = ele;
 				i++;
 			}
 		}
 
 		if (htype & BM_FACE) {
-			BM_ITER(ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
+			BM_ITER (ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
 				((BMHeader **)output->data.p)[i] = ele;
 				i++;
 			}
@@ -714,7 +714,7 @@ static void bmo_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, const char *sl
 		/* TODO - collapse these loops into one */
 
 		if (htype & BM_VERT) {
-			BM_ITER(ele, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+			BM_ITER (ele, &iter, bm, BM_VERTS_OF_MESH, NULL) {
 				if (!BM_elem_flag_test(ele, BM_ELEM_HIDDEN) &&
 				    BM_elem_flag_test_bool(ele, hflag) == test_for_enabled)
 				{
@@ -725,7 +725,7 @@ static void bmo_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, const char *sl
 		}
 
 		if (htype & BM_EDGE) {
-			BM_ITER(ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
+			BM_ITER (ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
 				if (!BM_elem_flag_test(ele, BM_ELEM_HIDDEN) &&
 				    BM_elem_flag_test_bool(ele, hflag) == test_for_enabled)
 				{
@@ -736,7 +736,7 @@ static void bmo_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, const char *sl
 		}
 
 		if (htype & BM_FACE) {
-			BM_ITER(ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
+			BM_ITER (ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
 				if (!BM_elem_flag_test(ele, BM_ELEM_HIDDEN) &&
 				    BM_elem_flag_test_bool(ele, hflag) == test_for_enabled)
 				{
@@ -828,7 +828,7 @@ static void bmo_slot_buffer_from_flag(BMesh *bm, BMOperator *op, const char *slo
 		/* TODO - collapse these loops into one */
 
 		if (htype & BM_VERT) {
-			BM_ITER(ele, &iter, bm, BM_VERTS_OF_MESH, NULL) {
+			BM_ITER (ele, &iter, bm, BM_VERTS_OF_MESH, NULL) {
 				if (BMO_elem_flag_test_bool(bm, (BMElemF *)ele, oflag) == test_for_enabled) {
 					ele_array[i] = ele;
 					i++;
@@ -837,7 +837,7 @@ static void bmo_slot_buffer_from_flag(BMesh *bm, BMOperator *op, const char *slo
 		}
 
 		if (htype & BM_EDGE) {
-			BM_ITER(ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
+			BM_ITER (ele, &iter, bm, BM_EDGES_OF_MESH, NULL) {
 				if (BMO_elem_flag_test_bool(bm, (BMElemF *)ele, oflag) == test_for_enabled) {
 					ele_array[i] = ele;
 					i++;
@@ -846,7 +846,7 @@ static void bmo_slot_buffer_from_flag(BMesh *bm, BMOperator *op, const char *slo
 		}
 
 		if (htype & BM_FACE) {
-			BM_ITER(ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
+			BM_ITER (ele, &iter, bm, BM_FACES_OF_MESH, NULL) {
 				if (BMO_elem_flag_test_bool(bm, (BMElemF *)ele, oflag) == test_for_enabled) {
 					ele_array[i] = ele;
 					i++;
@@ -1035,19 +1035,19 @@ static void bmo_flag_layer_alloc(BMesh *bm)
 	bm->toolflagpool = newpool = BLI_mempool_create(sizeof(BMFlagLayer) * bm->totflags, 512, 512, 0);
 	
 	/* now go through and memcpy all the flags. Loops don't get a flag layer at this time.. */
-	BM_ITER_INDEX(ele, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
+	BM_ITER_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
 		oldflags = ele->oflags;
 		ele->oflags = BLI_mempool_calloc(newpool);
 		memcpy(ele->oflags, oldflags, old_totflags_size);
 		BM_elem_index_set(ele, i); /* set_inline */
 	}
-	BM_ITER_INDEX(ele, &iter, bm, BM_EDGES_OF_MESH, NULL, i) {
+	BM_ITER_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, NULL, i) {
 		oldflags = ele->oflags;
 		ele->oflags = BLI_mempool_calloc(newpool);
 		memcpy(ele->oflags, oldflags, old_totflags_size);
 		BM_elem_index_set(ele, i); /* set_inline */
 	}
-	BM_ITER_INDEX(ele, &iter, bm, BM_FACES_OF_MESH, NULL, i) {
+	BM_ITER_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, NULL, i) {
 		oldflags = ele->oflags;
 		ele->oflags = BLI_mempool_calloc(newpool);
 		memcpy(ele->oflags, oldflags, old_totflags_size);
@@ -1080,19 +1080,19 @@ static void bmo_flag_layer_free(BMesh *bm)
 	bm->toolflagpool = newpool = BLI_mempool_create(new_totflags_size, 512, 512, BLI_MEMPOOL_SYSMALLOC);
 	
 	/* now go through and memcpy all the flag */
-	BM_ITER_INDEX(ele, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
+	BM_ITER_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
 		oldflags = ele->oflags;
 		ele->oflags = BLI_mempool_calloc(newpool);
 		memcpy(ele->oflags, oldflags, new_totflags_size);
 		BM_elem_index_set(ele, i); /* set_inline */
 	}
-	BM_ITER_INDEX(ele, &iter, bm, BM_EDGES_OF_MESH, NULL, i) {
+	BM_ITER_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, NULL, i) {
 		oldflags = ele->oflags;
 		ele->oflags = BLI_mempool_calloc(newpool);
 		memcpy(ele->oflags, oldflags, new_totflags_size);
 		BM_elem_index_set(ele, i); /* set_inline */
 	}
-	BM_ITER_INDEX(ele, &iter, bm, BM_FACES_OF_MESH, NULL, i) {
+	BM_ITER_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, NULL, i) {
 		oldflags = ele->oflags;
 		ele->oflags = BLI_mempool_calloc(newpool);
 		memcpy(ele->oflags, oldflags, new_totflags_size);
@@ -1115,15 +1115,15 @@ static void bmo_flag_layer_clear(BMesh *bm)
 	const int totflags_offset = bm->totflags - 1;
 
 	/* now go through and memcpy all the flag */
-	BM_ITER_INDEX(ele, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
+	BM_ITER_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, NULL, i) {
 		memset(ele->oflags + totflags_offset, 0, sizeof(BMFlagLayer));
 		BM_elem_index_set(ele, i); /* set_inline */
 	}
-	BM_ITER_INDEX(ele, &iter, bm, BM_EDGES_OF_MESH, NULL, i) {
+	BM_ITER_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, NULL, i) {
 		memset(ele->oflags + totflags_offset, 0, sizeof(BMFlagLayer));
 		BM_elem_index_set(ele, i); /* set_inline */
 	}
-	BM_ITER_INDEX(ele, &iter, bm, BM_FACES_OF_MESH, NULL, i) {
+	BM_ITER_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, NULL, i) {
 		memset(ele->oflags + totflags_offset, 0, sizeof(BMFlagLayer));
 		BM_elem_index_set(ele, i); /* set_inline */
 	}
diff --git a/source/blender/bmesh/intern/bmesh_polygon.c b/source/blender/bmesh/intern/bmesh_polygon.c
index 1b480ab0315..869ab4f74e4 100644
--- a/source/blender/bmesh/intern/bmesh_polygon.c
+++ b/source/blender/bmesh/intern/bmesh_polygon.c
@@ -164,7 +164,7 @@ float BM_face_area_calc(BMesh *bm, BMFace *f)
 
 	BLI_array_fixedstack_declare(verts, BM_NGON_STACK_SIZE, f->len, __func__);
 
-	BM_ITER_INDEX(l, &iter, bm, BM_LOOPS_OF_FACE, f, i) {
+	BM_ITER_INDEX (l, &iter, bm, BM_LOOPS_OF_FACE, f, i) {
 		copy_v3_v3(verts[i], l->v->co);
 	}
 
@@ -360,7 +360,7 @@ void BM_vert_normal_update(BMesh *bm, BMVert *v)
 
 	zero_v3(v->no);
 
-	BM_ITER(l, &liter, bm, BM_LOOPS_OF_VERT, v) {
+	BM_ITER (l, &liter, bm, BM_LOOPS_OF_VERT, v) {
 		/* Same calculation used in BM_mesh_normals_update */
 		sub_v3_v3v3(vec1, l->v->co, l->prev->v->co);
 		sub_v3_v3v3(vec2, l->next->v->co, l->v->co);
@@ -384,7 +384,7 @@ void BM_vert_normal_update_all(BMesh *bm, BMVert *v)
 	BMIter iter;
 	BMFace *f;
 
-	BM_ITER(f, &iter, bm, BM_FACES_OF_VERT, v) {
+	BM_ITER (f, &iter, bm, BM_FACES_OF_VERT, v) {
 		BM_face_normal_update(bm, f);
 	}
 
diff --git a/source/blender/bmesh/intern/bmesh_queries.c b/source/blender/bmesh/intern/bmesh_queries.c
index b021fb4c320..c615f81f3f8 100644
--- a/source/blender/bmesh/intern/bmesh_queries.c
+++ b/source/blender/bmesh/intern/bmesh_queries.c
@@ -125,7 +125,7 @@ BMLoop *BM_face_other_vert_loop(BMFace *f, BMVert *v_prev, BMVert *v)
 
 	BLI_assert(BM_edge_exists(v_prev, v) != NULL);
 
-	BM_ITER(l_iter, &liter, NULL, BM_LOOPS_OF_VERT, v) {
+	BM_ITER (l_iter, &liter, NULL, BM_LOOPS_OF_VERT, v) {
 		if (l_iter->f == f) {
 			break;
 		}
@@ -379,7 +379,7 @@ int BM_vert_edge_count_nonwire(BMVert *v)
 	int count = 0;
 	BMIter eiter;
 	BMEdge *edge;
-	BM_ITER(edge, &eiter, NULL, BM_EDGES_OF_VERT, v) {
+	BM_ITER (edge, &eiter, NULL, BM_EDGES_OF_VERT, v) {
 		if (edge->l) {
 			count++;
 		}
@@ -416,7 +416,7 @@ int BM_vert_face_count(BMVert *v)
 	BMLoop *l;
 	BMIter iter;
 
-	BM_ITER(l, &iter, NULL, BM_LOOPS_OF_VERT, v) {
+	BM_ITER (l, &iter, NULL, BM_LOOPS_OF_VERT, v) {
 		count++;
 	}
 
@@ -877,7 +877,7 @@ BMEdge *BM_edge_exists(BMVert *v1, BMVert *v2)
 	BMIter iter;
 	BMEdge *e;
 
-	BM_ITER(e, &iter, NULL, BM_EDGES_OF_VERT, v1) {
+	BM_ITER (e, &iter, NULL, BM_EDGES_OF_VERT, v1) {
 		if (e->v1 == v2 || e->v2 == v2)
 			return e;
 	}
@@ -902,7 +902,7 @@ int BM_face_exists_overlap(BMesh *bm, BMVert **varr, int len, BMFace **r_overlap
 	int i, amount;
 
 	for (i = 0; i < len; i++) {
-		BM_ITER(f, &viter, bm, BM_FACES_OF_VERT, varr[i]) {
+		BM_ITER (f, &viter, bm, BM_FACES_OF_VERT, varr[i]) {
 			amount = BM_verts_in_face(bm, f, varr, len);
 			if (amount >= len) {
 				if (r_overlapface) {
@@ -932,7 +932,7 @@ int BM_face_exists(BMesh *bm, BMVert **varr, int len, BMFace **r_existface)
 	int i, amount;
 
 	for (i = 0; i < len; i++) {
-		BM_ITER(f, &viter, bm, BM_FACES_OF_VERT, varr[i]) {
+		BM_ITER (f, &viter, bm, BM_FACES_OF_VERT, varr[i]) {
 			amount = BM_verts_in_face(bm, f, varr, len);
 			if (amount == len && amount == f->len) {
 				if (r_existface) {
@@ -978,15 +978,15 @@ int BM_face_exists_multi(BMesh *bm, BMVert **varr, BMEdge **earr, int len)
 	for (i = 0; i < len; i++) {
 		/* save some time by looping over edge faces rather then vert faces
 		 * will still loop over some faces twice but not as many */
-		BM_ITER(f, &fiter, bm, BM_FACES_OF_EDGE, earr[i]) {
+		BM_ITER (f, &fiter, bm, BM_FACES_OF_EDGE, earr[i]) {
 			BM_elem_flag_disable(f, BM_ELEM_INTERNAL_TAG);
-			BM_ITER(v, &viter, bm, BM_VERTS_OF_FACE, f) {
+			BM_ITER (v, &viter, bm, BM_VERTS_OF_FACE, f) {
 				BM_elem_flag_disable(v, BM_ELEM_INTERNAL_TAG);
 			}
 		}
 
 		/* clear all edge tags */
-		BM_ITER(e, &fiter, bm, BM_EDGES_OF_VERT, varr[i]) {
+		BM_ITER (e, &fiter, bm, BM_EDGES_OF_VERT, varr[i]) {
 			BM_elem_flag_disable(e, BM_ELEM_INTERNAL_TAG);
 		}
 	}
@@ -1005,10 +1005,10 @@ int BM_face_exists_multi(BMesh *bm, BMVert **varr, BMEdge **earr, int len)
 	/* 1) tag all faces connected to edges - if all their verts are boundary */
 	tot_tag = 0;
 	for (i = 0; i < len; i++) {
-		BM_ITER(f, &fiter, bm, BM_FACES_OF_EDGE, earr[i]) {
+		BM_ITER (f, &fiter, bm, BM_FACES_OF_EDGE, earr[i]) {
 			if (!BM_elem_flag_test(f, BM_ELEM_INTERNAL_TAG)) {
 				ok = TRUE;
-				BM_ITER(v, &viter, bm, BM_VERTS_OF_FACE, f) {
+				BM_ITER (v, &viter, bm, BM_VERTS_OF_FACE, f) {
 					if (!BM_elem_flag_test(v, BM_ELEM_INTERNAL_TAG)) {
 						ok = FALSE;
 						break;
@@ -1036,7 +1036,7 @@ int BM_face_exists_multi(BMesh *bm, BMVert **varr, BMEdge **earr, int len)
 	 *    check each have 2 tagges faces connected (faces that only use 'varr' verts) */
 	ok = TRUE;
 	for (i = 0; i < len; i++) {
-		BM_ITER(e, &fiter, bm, BM_EDGES_OF_VERT, varr[i]) {
+		BM_ITER (e, &fiter, bm, BM_EDGES_OF_VERT, varr[i]) {
 
 			if (/* non-boundary edge */
 			    BM_elem_flag_test(e, BM_ELEM_INTERNAL_TAG) == FALSE &&
@@ -1045,7 +1045,7 @@ int BM_face_exists_multi(BMesh *bm, BMVert **varr, BMEdge **earr, int len)
 			    BM_elem_flag_test(e->v2, BM_ELEM_INTERNAL_TAG) == TRUE)
 			{
 				int tot_face_tag = 0;
-				BM_ITER(f, &fiter, bm, BM_FACES_OF_EDGE, e) {
+				BM_ITER (f, &fiter, bm, BM_FACES_OF_EDGE, e) {
 					if (BM_elem_flag_test(f, BM_ELEM_INTERNAL_TAG)) {
 						tot_face_tag++;
 					}
diff --git a/source/blender/bmesh/intern/bmesh_walkers_impl.c b/source/blender/bmesh/intern/bmesh_walkers_impl.c
index cccda674b0f..6f283116236 100644
--- a/source/blender/bmesh/intern/bmesh_walkers_impl.c
+++ b/source/blender/bmesh/intern/bmesh_walkers_impl.c
@@ -115,7 +115,7 @@ static void bmw_ShellWalker_begin(BMWalker *walker, void *data)
 			/* starting the walk at a vert, add all the edges
 			 * to the worklist */
 			v = (BMVert *)h;
-			BM_ITER(e, &eiter, walker->bm, BM_EDGES_OF_VERT, v) {
+			BM_ITER (e, &eiter, walker->bm, BM_EDGES_OF_VERT, v) {
 				bmw_ShellWalker_visitEdge(walker, e);
 			}
 			break;
@@ -151,7 +151,7 @@ static void *bmw_ShellWalker_step(BMWalker *walker)
 
 	for (i = 0; i < 2; i++) {
 		v = i ? e->v2 : e->v1;
-		BM_ITER(e2, &iter, walker->bm, BM_EDGES_OF_VERT, v) {
+		BM_ITER (e2, &iter, walker->bm, BM_EDGES_OF_VERT, v) {
 			bmw_ShellWalker_visitEdge(walker, e2);
 		}
 	}
@@ -249,7 +249,7 @@ static void *bmw_ConnectedVertexWalker_step(BMWalker *walker)
 
 	BMW_state_remove(walker);
 
-	BM_ITER(e, &iter, walker->bm, BM_EDGES_OF_VERT, v) {
+	BM_ITER (e, &iter, walker->bm, BM_EDGES_OF_VERT, v) {
 		v2 = BM_edge_other_vert(e, v);
 		if (!BLI_ghash_haskey(walker->visithash, v2)) {
 			bmw_ConnectedVertexWalker_visitVertex(walker, v2);
@@ -450,7 +450,7 @@ static void bmw_LoopWalker_begin(BMWalker *walker, void *data)
 		BMFace *f_iter;
 		BMFace *f_best = NULL;
 
-		BM_ITER(f_iter, &iter, walker->bm, BM_FACES_OF_EDGE, e) {
+		BM_ITER (f_iter, &iter, walker->bm, BM_FACES_OF_EDGE, e) {
 			if (f_best == NULL || f_best->len < f_iter->len) {
 				f_best = f_iter;
 			}
@@ -606,7 +606,7 @@ static void *bmw_LoopWalker_step(BMWalker *walker)
 		for (i = 0; i < 2; i++) {
 			v = i ? e->v2 : e->v1;
 
-			BM_ITER(nexte, &eiter, walker->bm, BM_EDGES_OF_VERT, v) {
+			BM_ITER (nexte, &eiter, walker->bm, BM_EDGES_OF_VERT, v) {
 				if ((nexte->l == NULL) &&
 				    bmw_mask_check_edge(walker, nexte) &&
 				    !BLI_ghash_haskey(walker->visithash, nexte))
@@ -953,7 +953,7 @@ static void *bmw_UVEdgeWalker_step(BMWalker *walker)
 	 * mloopuv's coordinates. in addition, push on l->next if necessary */
 	for (i = 0; i < 2; i++) {
 		cl = i ? nl : l;
-		BM_ITER(l2, &liter, walker->bm, BM_LOOPS_OF_VERT, cl->v) {
+		BM_ITER (l2, &liter, walker->bm, BM_LOOPS_OF_VERT, cl->v) {
 			d1 = CustomData_bmesh_get_layer_n(&walker->bm->ldata,
 			                                  cl->head.data, walker->layer);