style cleanup: scanfill, spelling and use NULL rather then 0

1 files changed, 382 insertions, 378 deletions

diff --git a/source/blender/blenlib/intern/scanfill.c b/source/blender/blenlib/intern/scanfill.c
index d1b2c5b00ee..89ab192c920 100644
--- a/source/blender/blenlib/intern/scanfill.c
+++ b/source/blender/blenlib/intern/scanfill.c
@@ -45,7 +45,7 @@
 #include "BLI_threads.h"
 
 /* callbacks for errors and interrupts and some goo */
-static void (*BLI_localErrorCallBack)(const char*) = NULL;
+static void (*BLI_localErrorCallBack)(const char *) = NULL;
 static int (*BLI_localInterruptCallBack)(void) = NULL;
 
 void BLI_setErrorCallBack(void (*f)(const char *))
@@ -59,7 +59,7 @@ void BLI_setInterruptCallBack(int (*f)(void))
 }
 
 /* just flush the error to /dev/null if the error handler is missing */
-void callLocalErrorCallBack(const char* msg)
+void callLocalErrorCallBack(const char *msg)
 {
 	if (BLI_localErrorCallBack) {
 		BLI_localErrorCallBack(msg);
@@ -81,9 +81,9 @@ static int callLocalInterruptCallBack(void)
 
 /* local types */
 typedef struct PolyFill {
-	int edges,verts;
-	float min[3],max[3];
-	short f,nr;
+	int edges, verts;
+	float min[3], max[3];
+	short f, nr;
 } PolyFill;
 
 typedef struct ScanFillVertLink {
@@ -94,7 +94,7 @@ typedef struct ScanFillVertLink {
 
 /* local funcs */
 
-#define COMPLIMIT	0.00003
+#define COMPLIMIT   0.00003f
 
 static ScanFillVertLink *scdata;
 
@@ -104,29 +104,29 @@ ListBase fillfacebase = {NULL, NULL};
 
 static int cox, coy;
 
-/* ****  FUBCTIONS FOR QSORT *************************** */
+/* ****  FUNCTIONS FOR QSORT *************************** */
 
 
 static int vergscdata(const void *a1, const void *a2)
 {
-	const ScanFillVertLink *x1=a1,*x2=a2;
+	const ScanFillVertLink *x1 = a1, *x2 = a2;
 	
-	if ( x1->v1->co[coy] < x2->v1->co[coy] ) return 1;
-	else if ( x1->v1->co[coy] > x2->v1->co[coy]) return -1;
-	else if ( x1->v1->co[cox] > x2->v1->co[cox] ) return 1;
-	else if ( x1->v1->co[cox] < x2->v1->co[cox]) return -1;
+	if      (x1->v1->co[coy] < x2->v1->co[coy]) return  1;
+	else if (x1->v1->co[coy] > x2->v1->co[coy]) return -1;
+	else if (x1->v1->co[cox] > x2->v1->co[cox]) return  1;
+	else if (x1->v1->co[cox] < x2->v1->co[cox]) return -1;
 
 	return 0;
 }
 
 static int vergpoly(const void *a1, const void *a2)
 {
-	const PolyFill *x1=a1, *x2=a2;
+	const PolyFill *x1 = a1, *x2 = a2;
 
-	if ( x1->min[cox] > x2->min[cox] ) return 1;
-	else if ( x1->min[cox] < x2->min[cox] ) return -1;
-	else if ( x1->min[coy] > x2->min[coy] ) return 1;
-	else if ( x1->min[coy] < x2->min[coy] ) return -1;
+	if      (x1->min[cox] > x2->min[cox]) return  1;
+	else if (x1->min[cox] < x2->min[cox]) return -1;
+	else if (x1->min[coy] > x2->min[coy]) return  1;
+	else if (x1->min[coy] < x2->min[coy]) return -1;
 	
 	return 0;
 }
@@ -144,27 +144,27 @@ struct mem_elements {
  * free in the end, with argument '-1'
  */
 #define MEM_ELEM_BLOCKSIZE 16384
-static struct mem_elements *  melem__cur= NULL;
-static int                    melem__offs= 0; /* the current free address */
-static ListBase               melem__lb= {NULL, NULL};
+static struct mem_elements *melem__cur = NULL;
+static int melem__offs = 0;                   /* the current free address */
+static ListBase melem__lb = {NULL, NULL};
 
 static void *mem_element_new(int size)
 {
-	BLI_assert(!(size>10000 || size==0)); /* this is invalid use! */
+	BLI_assert(!(size > 10000 || size == 0)); /* this is invalid use! */
 
-	size = (size + 3 ) & ~3; 	/* allocate in units of 4 */
+	size = (size + 3) & ~3;     /* allocate in units of 4 */
 	
 	if (melem__cur && (size + melem__offs < MEM_ELEM_BLOCKSIZE)) {
-		void *adr= (void *) (melem__cur->data+melem__offs);
-		 melem__offs+= size;
+		void *adr = (void *) (melem__cur->data + melem__offs);
+		melem__offs += size;
 		return adr;
 	}
 	else {
-		melem__cur= MEM_callocN( sizeof(struct mem_elements), "newmem");
-		melem__cur->data= MEM_callocN(MEM_ELEM_BLOCKSIZE, "newmem");
+		melem__cur = MEM_callocN(sizeof(struct mem_elements), "newmem");
+		melem__cur->data = MEM_callocN(MEM_ELEM_BLOCKSIZE, "newmem");
 		BLI_addtail(&melem__lb, melem__cur);
 
-		melem__offs= size;
+		melem__offs = size;
 		return melem__cur->data;
 	}
 }
@@ -172,15 +172,15 @@ static void mem_element_reset(int keep_first)
 {
 	struct mem_elements *first;
 
-	if ((first= melem__lb.first)) { /* can be false if first fill fails */
+	if ((first = melem__lb.first)) { /* can be false if first fill fails */
 		if (keep_first) {
 			BLI_remlink(&melem__lb, first);
 		}
 
-		melem__cur= melem__lb.first;
+		melem__cur = melem__lb.first;
 		while (melem__cur) {
 			MEM_freeN(melem__cur->data);
-			melem__cur= melem__cur->next;
+			melem__cur = melem__cur->next;
 		}
 		BLI_freelistN(&melem__lb);
 
@@ -195,17 +195,17 @@ static void mem_element_reset(int keep_first)
 		}
 	}
 
-	melem__cur= first;
-	melem__offs= 0;
+	melem__cur = first;
+	melem__offs = 0;
 }
 
 void BLI_end_edgefill(void)
 {
 	mem_element_reset(TRUE);
 	
-	fillvertbase.first= fillvertbase.last= 0;
-	filledgebase.first= filledgebase.last= 0;
-	fillfacebase.first= fillfacebase.last= 0;
+	fillvertbase.first = fillvertbase.last = 0;
+	filledgebase.first = filledgebase.last = 0;
+	fillfacebase.first = fillfacebase.last = 0;
 	
 	BLI_unlock_thread(LOCK_SCANFILL);	
 }
@@ -221,7 +221,7 @@ ScanFillVert *BLI_addfillvert(const float vec[3])
 {
 	ScanFillVert *eve;
 	
-	eve= mem_element_new(sizeof(ScanFillVert));
+	eve = mem_element_new(sizeof(ScanFillVert));
 	BLI_addtail(&fillvertbase, eve);
 	
 	eve->co[0] = vec[0];
@@ -235,11 +235,11 @@ ScanFillEdge *BLI_addfilledge(ScanFillVert *v1, ScanFillVert *v2)
 {
 	ScanFillEdge *newed;
 
-	newed= mem_element_new(sizeof(ScanFillEdge));
+	newed = mem_element_new(sizeof(ScanFillEdge));
 	BLI_addtail(&filledgebase, newed);
 	
-	newed->v1= v1;
-	newed->v2= v2;
+	newed->v1 = v1;
+	newed->v2 = v2;
 
 	return newed;
 }
@@ -249,12 +249,12 @@ static void addfillface(ScanFillVert *v1, ScanFillVert *v2, ScanFillVert *v3)
 	/* does not make edges */
 	ScanFillFace *evl;
 
-	evl= mem_element_new(sizeof(ScanFillFace));
+	evl = mem_element_new(sizeof(ScanFillFace));
 	BLI_addtail(&fillfacebase, evl);
 	
-	evl->v1= v1;
-	evl->v2= v2;
-	evl->v3= v3;
+	evl->v1 = v1;
+	evl->v2 = v2;
+	evl->v3 = v3;
 }
 
 static int boundisect(PolyFill *pf2, PolyFill *pf1)
@@ -262,46 +262,46 @@ static int boundisect(PolyFill *pf2, PolyFill *pf1)
 	/* has pf2 been touched (intersected) by pf1 ? with bounding box */
 	/* test first if polys exist */
 
-	if (pf1->edges==0 || pf2->edges==0) return 0;
+	if (pf1->edges == 0 || pf2->edges == 0) return 0;
 
-	if (pf2->max[cox] < pf1->min[cox] ) return 0;
-	if (pf2->max[coy] < pf1->min[coy] ) return 0;
+	if (pf2->max[cox] < pf1->min[cox]) return 0;
+	if (pf2->max[coy] < pf1->min[coy]) return 0;
 
-	if (pf2->min[cox] > pf1->max[cox] ) return 0;
-	if (pf2->min[coy] > pf1->max[coy] ) return 0;
+	if (pf2->min[cox] > pf1->max[cox]) return 0;
+	if (pf2->min[coy] > pf1->max[coy]) return 0;
 
 	/* join */
-	if (pf2->max[cox]<pf1->max[cox]) pf2->max[cox]= pf1->max[cox];
-	if (pf2->max[coy]<pf1->max[coy]) pf2->max[coy]= pf1->max[coy];
+	if (pf2->max[cox] < pf1->max[cox]) pf2->max[cox] = pf1->max[cox];
+	if (pf2->max[coy] < pf1->max[coy]) pf2->max[coy] = pf1->max[coy];
 
-	if (pf2->min[cox]>pf1->min[cox]) pf2->min[cox]= pf1->min[cox];
-	if (pf2->min[coy]>pf1->min[coy]) pf2->min[coy]= pf1->min[coy];
+	if (pf2->min[cox] > pf1->min[cox]) pf2->min[cox] = pf1->min[cox];
+	if (pf2->min[coy] > pf1->min[coy]) pf2->min[coy] = pf1->min[coy];
 
 	return 1;
 }
 
 
-static void mergepolysSimp(PolyFill *pf1, PolyFill *pf2)	/* add pf2 to pf1 */
+static void mergepolysSimp(PolyFill *pf1, PolyFill *pf2)    /* add pf2 to pf1 */
 {
 	ScanFillVert *eve;
 	ScanFillEdge *eed;
 
 	/* replace old poly numbers */
-	eve= fillvertbase.first;
+	eve = fillvertbase.first;
 	while (eve) {
 		if (eve->poly_nr == pf2->nr) eve->poly_nr = pf1->nr;
-		eve= eve->next;
+		eve = eve->next;
 	}
-	eed= filledgebase.first;
+	eed = filledgebase.first;
 	while (eed) {
 		if (eed->poly_nr == pf2->nr) eed->poly_nr = pf1->nr;
-		eed= eed->next;
+		eed = eed->next;
 	}
 
-	pf1->verts+= pf2->verts;
-	pf1->edges+= pf2->edges;
-	pf2->verts= pf2->edges= 0;
-	pf1->f= (pf1->f | pf2->f);
+	pf1->verts += pf2->verts;
+	pf1->edges += pf2->edges;
+	pf2->verts = pf2->edges = 0;
+	pf1->f = (pf1->f | pf2->f);
 }
 
 static short testedgeside(const float v1[3], const float v2[3], const float v3[3])
@@ -309,13 +309,15 @@ static short testedgeside(const float v1[3], const float v2[3], const float v3[3
 {
 	float inp;
 
-	inp= (v2[cox]-v1[cox])*(v1[coy]-v3[coy])
-		+(v1[coy]-v2[coy])*(v1[cox]-v3[cox]);
+	inp = (v2[cox] - v1[cox]) * (v1[coy] - v3[coy]) +
+	      (v1[coy] - v2[coy]) * (v1[cox] - v3[cox]);
 
-	if (inp < 0.0f) return 0;
-	else if (inp==0) {
-		if (v1[cox]==v3[cox] && v1[coy]==v3[coy]) return 0;
-		if (v2[cox]==v3[cox] && v2[coy]==v3[coy]) return 0;
+	if (inp < 0.0f) {
+		return 0;
+	}
+	else if (inp == 0) {
+		if (v1[cox] == v3[cox] && v1[coy] == v3[coy]) return 0;
+		if (v2[cox] == v3[cox] && v2[coy] == v3[coy]) return 0;
 	}
 	return 1;
 }
@@ -324,41 +326,43 @@ static short addedgetoscanvert(ScanFillVertLink *sc, ScanFillEdge *eed)
 {
 	/* find first edge to the right of eed, and insert eed before that */
 	ScanFillEdge *ed;
-	float fac,fac1,x,y;
+	float fac, fac1, x, y;
 
-	if (sc->first==0) {
-		sc->first= sc->last= eed;
-		eed->prev= eed->next=0;
+	if (sc->first == NULL) {
+		sc->first = sc->last = eed;
+		eed->prev = eed->next = NULL;
 		return 1;
 	}
 
-	x= eed->v1->co[cox];
-	y= eed->v1->co[coy];
+	x = eed->v1->co[cox];
+	y = eed->v1->co[coy];
 
-	fac1= eed->v2->co[coy]-y;
-	if (fac1==0.0f) {
-		fac1= 1.0e10f*(eed->v2->co[cox]-x);
+	fac1 = eed->v2->co[coy] - y;
+	if (fac1 == 0.0f) {
+		fac1 = 1.0e10f * (eed->v2->co[cox] - x);
 
 	}
-	else fac1= (x-eed->v2->co[cox])/fac1;
+	else fac1 = (x - eed->v2->co[cox]) / fac1;
 
-	ed= sc->first;
+	ed = sc->first;
 	while (ed) {
 
-		if (ed->v2==eed->v2) return 0;
-
-		fac= ed->v2->co[coy]-y;
-		if (fac==0.0f) {
-			fac= 1.0e10f*(ed->v2->co[cox]-x);
+		if (ed->v2 == eed->v2) return 0;
 
+		fac = ed->v2->co[coy] - y;
+		if (fac == 0.0f) {
+			fac = 1.0e10f * (ed->v2->co[cox] - x);
 		}
-		else fac= (x-ed->v2->co[cox])/fac;
-		if (fac>fac1) break;
+		else {
+			fac = (x - ed->v2->co[cox]) / fac;
+		}
+
+		if (fac > fac1) break;
 
-		ed= ed->next;
+		ed = ed->next;
 	}
 	if (ed) BLI_insertlinkbefore((ListBase *)&(sc->first), ed, eed);
-	else BLI_addtail((ListBase *)&(sc->first),eed);
+	else BLI_addtail((ListBase *)&(sc->first), eed);
 
 	return 1;
 }
@@ -368,29 +372,29 @@ static ScanFillVertLink *addedgetoscanlist(ScanFillEdge *eed, int len)
 {
 	/* inserts edge at correct location in ScanFillVertLink list */
 	/* returns sc when edge already exists */
-	ScanFillVertLink *sc,scsearch;
+	ScanFillVertLink *sc, scsearch;
 	ScanFillVert *eve;
 
 	/* which vert is left-top? */
 	if (eed->v1->co[coy] == eed->v2->co[coy]) {
 		if (eed->v1->co[cox] > eed->v2->co[cox]) {
-			eve= eed->v1;
-			eed->v1= eed->v2;
-			eed->v2= eve;
+			eve = eed->v1;
+			eed->v1 = eed->v2;
+			eed->v2 = eve;
 		}
 	}
 	else if (eed->v1->co[coy] < eed->v2->co[coy]) {
-		eve= eed->v1;
-		eed->v1= eed->v2;
-		eed->v2= eve;
+		eve = eed->v1;
+		eed->v1 = eed->v2;
+		eed->v2 = eve;
 	}
 	/* find location in list */
-	scsearch.v1= eed->v1;
-	sc= (ScanFillVertLink *)bsearch(&scsearch,scdata,len,
-		sizeof(ScanFillVertLink), vergscdata);
+	scsearch.v1 = eed->v1;
+	sc = (ScanFillVertLink *)bsearch(&scsearch, scdata, len,
+	                                 sizeof(ScanFillVertLink), vergscdata);
 
-	if (sc==0) printf("Error in search edge: %p\n", (void *)eed);
-	else if (addedgetoscanvert(sc,eed)==0) return sc;
+	if (sc == 0) printf("Error in search edge: %p\n", (void *)eed);
+	else if (addedgetoscanvert(sc, eed) == 0) return sc;
 
 	return 0;
 }
@@ -398,26 +402,26 @@ static ScanFillVertLink *addedgetoscanlist(ScanFillEdge *eed, int len)
 static short boundinsideEV(ScanFillEdge *eed, ScanFillVert *eve)
 /* is eve inside boundbox eed */
 {
-	float minx,maxx,miny,maxy;
+	float minx, maxx, miny, maxy;
 
-	if (eed->v1->co[cox]<eed->v2->co[cox]) {
-		minx= eed->v1->co[cox];
-		maxx= eed->v2->co[cox];
+	if (eed->v1->co[cox] < eed->v2->co[cox]) {
+		minx = eed->v1->co[cox];
+		maxx = eed->v2->co[cox];
 	}
 	else {
-		minx= eed->v2->co[cox];
-		maxx= eed->v1->co[cox];
+		minx = eed->v2->co[cox];
+		maxx = eed->v1->co[cox];
 	}
-	if (eve->co[cox]>=minx && eve->co[cox]<=maxx) {
-		if (eed->v1->co[coy]<eed->v2->co[coy]) {
-			miny= eed->v1->co[coy];
-			maxy= eed->v2->co[coy];
+	if (eve->co[cox] >= minx && eve->co[cox] <= maxx) {
+		if (eed->v1->co[coy] < eed->v2->co[coy]) {
+			miny = eed->v1->co[coy];
+			maxy = eed->v2->co[coy];
 		}
 		else {
-			miny= eed->v2->co[coy];
-			maxy= eed->v1->co[coy];
+			miny = eed->v2->co[coy];
+			maxy = eed->v1->co[coy];
 		}
-		if (eve->co[coy]>=miny && eve->co[coy]<=maxy) return 1;
+		if (eve->co[coy] >= miny && eve->co[coy] <= maxy) return 1;
 	}
 	return 0;
 }
@@ -429,93 +433,93 @@ static void testvertexnearedge(void)
 	 * being close to an edge, if true insert */
 
 	ScanFillVert *eve;
-	ScanFillEdge *eed,*ed1;
-	float dist,vec1[2],vec2[2],vec3[2];
+	ScanFillEdge *eed, *ed1;
+	float dist, vec1[2], vec2[2], vec3[2];
 
-	eve= fillvertbase.first;
+	eve = fillvertbase.first;
 	while (eve) {
-		if (eve->h==1) {
-			vec3[0]= eve->co[cox];
-			vec3[1]= eve->co[coy];
+		if (eve->h == 1) {
+			vec3[0] = eve->co[cox];
+			vec3[1] = eve->co[coy];
 			/* find the edge which has vertex eve */
-			ed1= filledgebase.first;
+			ed1 = filledgebase.first;
 			while (ed1) {
-				if (ed1->v1==eve || ed1->v2==eve) break;
-				ed1= ed1->next;
+				if (ed1->v1 == eve || ed1->v2 == eve) break;
+				ed1 = ed1->next;
 			}
-			if (ed1->v1==eve) {
-				ed1->v1= ed1->v2;
-				ed1->v2= eve;
+			if (ed1->v1 == eve) {
+				ed1->v1 = ed1->v2;
+				ed1->v2 = eve;
 			}
-			eed= filledgebase.first;
+			eed = filledgebase.first;
 			while (eed) {
 				if (eve != eed->v1 && eve != eed->v2 && eve->poly_nr == eed->poly_nr) {
-					if (compare_v3v3(eve->co,eed->v1->co, COMPLIMIT)) {
-						ed1->v2= eed->v1;
+					if (compare_v3v3(eve->co, eed->v1->co, COMPLIMIT)) {
+						ed1->v2 = eed->v1;
 						eed->v1->h++;
-						eve->h= 0;
+						eve->h = 0;
 						break;
 					}
-					else if (compare_v3v3(eve->co,eed->v2->co, COMPLIMIT)) {
-						ed1->v2= eed->v2;
+					else if (compare_v3v3(eve->co, eed->v2->co, COMPLIMIT)) {
+						ed1->v2 = eed->v2;
 						eed->v2->h++;
-						eve->h= 0;
+						eve->h = 0;
 						break;
 					}
 					else {
-						vec1[0]= eed->v1->co[cox];
-						vec1[1]= eed->v1->co[coy];
-						vec2[0]= eed->v2->co[cox];
-						vec2[1]= eed->v2->co[coy];
-						if (boundinsideEV(eed,eve)) {
-							dist= dist_to_line_v2(vec1,vec2,vec3);
-							if (dist<(float)COMPLIMIT) {
+						vec1[0] = eed->v1->co[cox];
+						vec1[1] = eed->v1->co[coy];
+						vec2[0] = eed->v2->co[cox];
+						vec2[1] = eed->v2->co[coy];
+						if (boundinsideEV(eed, eve)) {
+							dist = dist_to_line_v2(vec1, vec2, vec3);
+							if (dist < COMPLIMIT) {
 								/* new edge */
-								ed1= BLI_addfilledge(eed->v1, eve);
+								ed1 = BLI_addfilledge(eed->v1, eve);
 								
 								/* printf("fill: vertex near edge %x\n",eve); */
-								ed1->f= 0;
+								ed1->f = 0;
 								ed1->poly_nr = eed->poly_nr;
-								eed->v1= eve;
-								eve->h= 3;
+								eed->v1 = eve;
+								eve->h = 3;
 								break;
 							}
 						}
 					}
 				}
-				eed= eed->next;
+				eed = eed->next;
 			}
 		}
-		eve= eve->next;
+		eve = eve->next;
 	}
 }
 
 static void splitlist(ListBase *tempve, ListBase *temped, short nr)
 {
 	/* everything is in templist, write only poly nr to fillist */
-	ScanFillVert *eve,*nextve;
-	ScanFillEdge *eed,*nexted;
+	ScanFillVert *eve, *nextve;
+	ScanFillEdge *eed, *nexted;
 
-	BLI_movelisttolist(tempve,&fillvertbase);
-	BLI_movelisttolist(temped,&filledgebase);
+	BLI_movelisttolist(tempve, &fillvertbase);
+	BLI_movelisttolist(temped, &filledgebase);
 
-	eve= tempve->first;
+	eve = tempve->first;
 	while (eve) {
-		nextve= eve->next;
+		nextve = eve->next;
 		if (eve->poly_nr == nr) {
-			BLI_remlink(tempve,eve);
-			BLI_addtail(&fillvertbase,eve);
+			BLI_remlink(tempve, eve);
+			BLI_addtail(&fillvertbase, eve);
 		}
-		eve= nextve;
+		eve = nextve;
 	}
-	eed= temped->first;
+	eed = temped->first;
 	while (eed) {
-		nexted= eed->next;
-		if (eed->poly_nr==nr) {
-			BLI_remlink(temped,eed);
-			BLI_addtail(&filledgebase,eed);
+		nexted = eed->next;
+		if (eed->poly_nr == nr) {
+			BLI_remlink(temped, eed);
+			BLI_addtail(&filledgebase, eed);
 		}
-		eed= nexted;
+		eed = nexted;
 	}
 }
 
@@ -523,105 +527,105 @@ static void splitlist(ListBase *tempve, ListBase *temped, short nr)
 static int scanfill(PolyFill *pf)
 {
 	ScanFillVertLink *sc = NULL, *sc1;
-	ScanFillVert *eve,*v1,*v2,*v3;
-	ScanFillEdge *eed,*nexted,*ed1,*ed2,*ed3;
+	ScanFillVert *eve, *v1, *v2, *v3;
+	ScanFillEdge *eed, *nexted, *ed1, *ed2, *ed3;
 	float miny = 0.0;
-	int a,b,verts, maxface, totface;
-	short nr, test, twoconnected=0;
+	int a, b, verts, maxface, totface;
+	short nr, test, twoconnected = 0;
 
-	nr= pf->nr;
+	nr = pf->nr;
 
 	/* PRINTS */
 #if 0
-	verts= pf->verts;
-	eve= fillvertbase.first;
+	verts = pf->verts;
+	eve = fillvertbase.first;
 	while (eve) {
-		printf("vert: %x co: %f %f\n",eve,eve->co[cox],eve->co[coy]);
-		eve= eve->next;
+		printf("vert: %x co: %f %f\n", eve, eve->co[cox], eve->co[coy]);
+		eve = eve->next;
 	}	
-	eed= filledgebase.first;
+	eed = filledgebase.first;
 	while (eed) {
-		printf("edge: %x  verts: %x %x\n",eed,eed->v1,eed->v2);
-		eed= eed->next;
+		printf("edge: %x  verts: %x %x\n", eed, eed->v1, eed->v2);
+		eed = eed->next;
 	}
 #endif
 
 	/* STEP 0: remove zero sized edges */
-	eed= filledgebase.first;
+	eed = filledgebase.first;
 	while (eed) {
-		if (eed->v1->co[cox]==eed->v2->co[cox]) {
-			if (eed->v1->co[coy]==eed->v2->co[coy]) {
-				if (eed->v1->f==255 && eed->v2->f!=255) {
-					eed->v2->f= 255;
-					eed->v2->tmp.v= eed->v1->tmp.v;
+		if (eed->v1->co[cox] == eed->v2->co[cox]) {
+			if (eed->v1->co[coy] == eed->v2->co[coy]) {
+				if (eed->v1->f == 255 && eed->v2->f != 255) {
+					eed->v2->f = 255;
+					eed->v2->tmp.v = eed->v1->tmp.v;
 				}
-				else if (eed->v2->f==255 && eed->v1->f!=255) {
-					eed->v1->f= 255;
-					eed->v1->tmp.v= eed->v2->tmp.v;
+				else if (eed->v2->f == 255 && eed->v1->f != 255) {
+					eed->v1->f = 255;
+					eed->v1->tmp.v = eed->v2->tmp.v;
 				}
-				else if (eed->v2->f==255 && eed->v1->f==255) {
-					eed->v1->tmp.v= eed->v2->tmp.v;
+				else if (eed->v2->f == 255 && eed->v1->f == 255) {
+					eed->v1->tmp.v = eed->v2->tmp.v;
 				}
 				else {
-					eed->v2->f= 255;
+					eed->v2->f = 255;
 					eed->v2->tmp.v = eed->v1;
 				}
 			}
 		}
-		eed= eed->next;
+		eed = eed->next;
 	}
 
 	/* STEP 1: make using FillVert and FillEdge lists a sorted
 	 * ScanFillVertLink list
 	 */
-	sc= scdata= (ScanFillVertLink *)MEM_callocN(pf->verts*sizeof(ScanFillVertLink),"Scanfill1");
-	eve= fillvertbase.first;
-	verts= 0;
+	sc = scdata = (ScanFillVertLink *)MEM_callocN(pf->verts * sizeof(ScanFillVertLink), "Scanfill1");
+	eve = fillvertbase.first;
+	verts = 0;
 	while (eve) {
 		if (eve->poly_nr == nr) {
 			if (eve->f != 255) {
 				verts++;
-				eve->f= 0;	/* flag for connectedges later on */
-				sc->v1= eve;
+				eve->f = 0;  /* flag for connectedges later on */
+				sc->v1 = eve;
 				sc++;
 			}
 		}
-		eve= eve->next;
+		eve = eve->next;
 	}
 
 	qsort(scdata, verts, sizeof(ScanFillVertLink), vergscdata);
 
-	eed= filledgebase.first;
+	eed = filledgebase.first;
 	while (eed) {
-		nexted= eed->next;
-		BLI_remlink(&filledgebase,eed);
+		nexted = eed->next;
+		BLI_remlink(&filledgebase, eed);
 		/* This code is for handling zero-length edges that get
 		 * collapsed in step 0. It was removed for some time to
 		 * fix trunk bug #4544, so if that comes back, this code
 		 * may need some work, or there will have to be a better
 		 * fix to #4544. */
-		if (eed->v1->f==255) {
-			v1= eed->v1;
+		if (eed->v1->f == 255) {
+			v1 = eed->v1;
 			while ((eed->v1->f == 255) && (eed->v1->tmp.v != v1)) 
 				eed->v1 = eed->v1->tmp.v;
 		}
-		if (eed->v2->f==255) {
-			v2= eed->v2;
+		if (eed->v2->f == 255) {
+			v2 = eed->v2;
 			while ((eed->v2->f == 255) && (eed->v2->tmp.v != v2))
 				eed->v2 = eed->v2->tmp.v;
 		}
-		if (eed->v1!=eed->v2) addedgetoscanlist(eed,verts);
+		if (eed->v1 != eed->v2) addedgetoscanlist(eed, verts);
 
-		eed= nexted;
+		eed = nexted;
 	}
 #if 0
-	sc= scdata;
-	for (a=0;a<verts;a++) {
-		printf("\nscvert: %x\n",sc->v1);
-		eed= sc->first;
+	sc = scdata;
+	for (a = 0; a < verts; a++) {
+		printf("\nscvert: %x\n", sc->v1);
+		eed = sc->first;
 		while (eed) {
-			printf(" ed %x %x %x\n",eed,eed->v1,eed->v2);
-			eed= eed->next;
+			printf(" ed %x %x %x\n", eed, eed->v1, eed->v2);
+			eed = eed->next;
 		}
 		sc++;
 	}
@@ -630,70 +634,70 @@ static int scanfill(PolyFill *pf)
 
 	/* STEP 2: FILL LOOP */
 
-	if (pf->f==0) twoconnected= 1;
+	if (pf->f == 0) twoconnected = 1;
 
 	/* (temporal) security: never much more faces than vertices */
-	totface= 0;
-	maxface= 2*verts;		/* 2*verts: based at a filled circle within a triangle */
+	totface = 0;
+	maxface = 2 * verts;       /* 2*verts: based at a filled circle within a triangle */
 
-	sc= scdata;
-	for (a=0;a<verts;a++) {
+	sc = scdata;
+	for (a = 0; a < verts; a++) {
 		/* printf("VERTEX %d %x\n",a,sc->v1); */
-		ed1= sc->first;
-		while (ed1) {	/* set connectflags  */
-			nexted= ed1->next;
-			if (ed1->v1->h==1 || ed1->v2->h==1) {
-				BLI_remlink((ListBase *)&(sc->first),ed1);
-				BLI_addtail(&filledgebase,ed1);
-				if (ed1->v1->h>1) ed1->v1->h--;
-				if (ed1->v2->h>1) ed1->v2->h--;
+		ed1 = sc->first;
+		while (ed1) {   /* set connectflags  */
+			nexted = ed1->next;
+			if (ed1->v1->h == 1 || ed1->v2->h == 1) {
+				BLI_remlink((ListBase *)&(sc->first), ed1);
+				BLI_addtail(&filledgebase, ed1);
+				if (ed1->v1->h > 1) ed1->v1->h--;
+				if (ed1->v2->h > 1) ed1->v2->h--;
 			}
-			else ed1->v2->f= 1;
+			else ed1->v2->f = 1;
 
-			ed1= nexted;
+			ed1 = nexted;
 		}
-		while (sc->first) {	/* for as long there are edges */
-			ed1= sc->first;
-			ed2= ed1->next;
+		while (sc->first) { /* for as long there are edges */
+			ed1 = sc->first;
+			ed2 = ed1->next;
 			
 			/* commented out... the ESC here delivers corrupted memory (and doesnt work during grab) */
 			/* if (callLocalInterruptCallBack()) break; */
-			if (totface>maxface) {
+			if (totface > maxface) {
 				/* printf("Fill error: endless loop. Escaped at vert %d,  tot: %d.\n", a, verts); */
-				a= verts;
+				a = verts;
 				break;
 			}
-			if (ed2==0) {
-				sc->first=sc->last= 0;
+			if (ed2 == 0) {
+				sc->first = sc->last = NULL;
 				/* printf("just 1 edge to vert\n"); */
-				BLI_addtail(&filledgebase,ed1);
-				ed1->v2->f= 0;
+				BLI_addtail(&filledgebase, ed1);
+				ed1->v2->f = 0;
 				ed1->v1->h--; 
 				ed1->v2->h--;
 			}
 			else {
 				/* test rest of vertices */
-				v1= ed1->v2;
-				v2= ed1->v1;
-				v3= ed2->v2;
+				v1 = ed1->v2;
+				v2 = ed1->v1;
+				v3 = ed2->v2;
 				/* this happens with a serial of overlapping edges */
-				if (v1==v2 || v2==v3) break;
+				if (v1 == v2 || v2 == v3) break;
 				/* printf("test verts %x %x %x\n",v1,v2,v3); */
-				miny = ( (v1->co[coy])<(v3->co[coy]) ? (v1->co[coy]) : (v3->co[coy]) );
+				miny = ( (v1->co[coy]) < (v3->co[coy]) ? (v1->co[coy]) : (v3->co[coy]) );
 				/*  miny= MIN2(v1->co[coy],v3->co[coy]); */
-				sc1= sc+1;
-				test= 0;
+				sc1 = sc + 1;
+				test = 0;
 
-				for (b=a+1;b<verts;b++) {
-					if (sc1->v1->f==0) {
+				for (b = a + 1; b < verts; b++) {
+					if (sc1->v1->f == 0) {
 						if (sc1->v1->co[coy] <= miny) break;
 
-						if (testedgeside(v1->co,v2->co,sc1->v1->co))
-							if (testedgeside(v2->co,v3->co,sc1->v1->co))
-								if (testedgeside(v3->co,v1->co,sc1->v1->co)) {
+						if (testedgeside(v1->co, v2->co, sc1->v1->co))
+							if (testedgeside(v2->co, v3->co, sc1->v1->co))
+								if (testedgeside(v3->co, v1->co, sc1->v1->co)) {
 									/* point in triangle */
 								
-									test= 1;
+									test = 1;
 									break;
 								}
 					}
@@ -703,11 +707,11 @@ static int scanfill(PolyFill *pf)
 					/* make new edge, and start over */
 					/* printf("add new edge %x %x and start again\n",v2,sc1->v1); */
 
-					ed3= BLI_addfilledge(v2, sc1->v1);
+					ed3 = BLI_addfilledge(v2, sc1->v1);
 					BLI_remlink(&filledgebase, ed3);
 					BLI_insertlinkbefore((ListBase *)&(sc->first), ed2, ed3);
-					ed3->v2->f= 1;
-					ed3->f= 2;
+					ed3->v2->f = 1;
+					ed3->f = 2;
 					ed3->v1->h++; 
 					ed3->v2->h++;
 				}
@@ -716,64 +720,64 @@ static int scanfill(PolyFill *pf)
 					/* printf("add face %x %x %x\n",v1,v2,v3); */
 					addfillface(v1, v2, v3);
 					totface++;
-					BLI_remlink((ListBase *)&(sc->first),ed1);
-					BLI_addtail(&filledgebase,ed1);
-					ed1->v2->f= 0;
+					BLI_remlink((ListBase *)&(sc->first), ed1);
+					BLI_addtail(&filledgebase, ed1);
+					ed1->v2->f = 0;
 					ed1->v1->h--; 
 					ed1->v2->h--;
 					/* ed2 can be removed when it's a boundary edge */
 					if ((ed2->f == 0 && twoconnected) || (ed2->f == FILLBOUNDARY)) {
-						BLI_remlink((ListBase *)&(sc->first),ed2);
-						BLI_addtail(&filledgebase,ed2);
-						ed2->v2->f= 0;
+						BLI_remlink((ListBase *)&(sc->first), ed2);
+						BLI_addtail(&filledgebase, ed2);
+						ed2->v2->f = 0;
 						ed2->v1->h--; 
 						ed2->v2->h--;
 					}
 
 					/* new edge */
-					ed3= BLI_addfilledge(v1, v3);
+					ed3 = BLI_addfilledge(v1, v3);
 					BLI_remlink(&filledgebase, ed3);
-					ed3->f= 2;
+					ed3->f = 2;
 					ed3->v1->h++; 
 					ed3->v2->h++;
 					
 					/* printf("add new edge %x %x\n",v1,v3); */
-					sc1= addedgetoscanlist(ed3, verts);
+					sc1 = addedgetoscanlist(ed3, verts);
 					
-					if (sc1) {	/* ed3 already exists: remove if a boundary */
+					if (sc1) {  /* ed3 already exists: remove if a boundary */
 						/* printf("Edge exists\n"); */
 						ed3->v1->h--; 
 						ed3->v2->h--;
 
-						ed3= sc1->first;
+						ed3 = sc1->first;
 						while (ed3) {
-							if ( (ed3->v1==v1 && ed3->v2==v3) || (ed3->v1==v3 && ed3->v2==v1) ) {
-								if (twoconnected || ed3->f==FILLBOUNDARY) {
-									BLI_remlink((ListBase *)&(sc1->first),ed3);
-									BLI_addtail(&filledgebase,ed3);
+							if ( (ed3->v1 == v1 && ed3->v2 == v3) || (ed3->v1 == v3 && ed3->v2 == v1) ) {
+								if (twoconnected || ed3->f == FILLBOUNDARY) {
+									BLI_remlink((ListBase *)&(sc1->first), ed3);
+									BLI_addtail(&filledgebase, ed3);
 									ed3->v1->h--; 
 									ed3->v2->h--;
 								}
 								break;
 							}
-							ed3= ed3->next;
+							ed3 = ed3->next;
 						}
 					}
 
 				}
 			}
 			/* test for loose edges */
-			ed1= sc->first;
+			ed1 = sc->first;
 			while (ed1) {
-				nexted= ed1->next;
-				if (ed1->v1->h<2 || ed1->v2->h<2) {
-					BLI_remlink((ListBase *)&(sc->first),ed1);
-					BLI_addtail(&filledgebase,ed1);
-					if (ed1->v1->h>1) ed1->v1->h--;
-					if (ed1->v2->h>1) ed1->v2->h--;
+				nexted = ed1->next;
+				if (ed1->v1->h < 2 || ed1->v2->h < 2) {
+					BLI_remlink((ListBase *)&(sc->first), ed1);
+					BLI_addtail(&filledgebase, ed1);
+					if (ed1->v1->h > 1) ed1->v1->h--;
+					if (ed1->v2->h > 1) ed1->v2->h--;
 				}
 
-				ed1= nexted;
+				ed1 = nexted;
 			}
 		}
 		sc++;
@@ -804,20 +808,20 @@ int BLI_edgefill(const short do_quad_tri_speedup)
 	 */
 	ListBase tempve, temped;
 	ScanFillVert *eve;
-	ScanFillEdge *eed,*nexted;
-	PolyFill *pflist,*pf;
+	ScanFillEdge *eed, *nexted;
+	PolyFill *pflist, *pf;
 	float limit, *minp, *maxp, *v1, *v2, norm[3], len;
-	short a,c,poly=0,ok=0,toggle=0;
-	int totfaces= 0; /* total faces added */
+	short a, c, poly = 0, ok = 0, toggle = 0;
+	int totfaces = 0; /* total faces added */
 
 	/* reset variables */
-	eve= fillvertbase.first;
+	eve = fillvertbase.first;
 	a = 0;
 	while (eve) {
-		eve->f= 0;
-		eve->poly_nr= 0;
-		eve->h= 0;
-		eve= eve->next;
+		eve->f = 0;
+		eve->poly_nr = 0;
+		eve->h = 0;
+		eve = eve->next;
 		a += 1;
 	}
 
@@ -849,36 +853,36 @@ int BLI_edgefill(const short do_quad_tri_speedup)
 
 	/* first test vertices if they are in edges */
 	/* including resetting of flags */
-	eed= filledgebase.first;
+	eed = filledgebase.first;
 	while (eed) {
-		eed->poly_nr= 0;
-		eed->v1->f= 1;
-		eed->v2->f= 1;
+		eed->poly_nr = 0;
+		eed->v1->f = 1;
+		eed->v2->f = 1;
 
-		eed= eed->next;
+		eed = eed->next;
 	}
 
-	eve= fillvertbase.first;
+	eve = fillvertbase.first;
 	while (eve) {
 		if (eve->f & 1) {
-			ok=1; 
+			ok = 1;
 			break;
 		}
-		eve= eve->next;
+		eve = eve->next;
 	}
 
-	if (ok==0) return 0;
+	if (ok == 0) return 0;
 
 	/* NEW NEW! define projection: with 'best' normal */
 	/* just use the first three different vertices */
 	
 	/* THIS PART STILL IS PRETTY WEAK! (ton) */
 
-	eve= fillvertbase.last;
-	len= 0.0;
-	v1= eve->co;
-	v2= 0;
-	eve= fillvertbase.first;
+	eve = fillvertbase.last;
+	len = 0.0;
+	v1 = eve->co;
+	v2 = 0;
+	eve = fillvertbase.first;
 	limit = 1e-8f;
 
 	while (eve) {
@@ -889,69 +893,69 @@ int BLI_edgefill(const short do_quad_tri_speedup)
 
 				if (inner > limit) {
 					limit = inner;
-					len= normal_tri_v3(norm, v1, v2, eve->co);
+					len = normal_tri_v3(norm, v1, v2, eve->co);
 				}
 			}
 		}
 		else if (!compare_v3v3(v1, eve->co, COMPLIMIT))
-			v2= eve->co;
+			v2 = eve->co;
 
-		eve= eve->next;
+		eve = eve->next;
 	}
 
-	if (len==0.0f) return 0;	/* no fill possible */
+	if (len == 0.0f) return 0;  /* no fill possible */
 
 	axis_dominant_v3(&cox, &coy, norm);
 
 	/* STEP 1: COUNT POLYS */
-	eve= fillvertbase.first;
+	eve = fillvertbase.first;
 	while (eve) {
 		/* get first vertex with no poly number */
-		if (eve->poly_nr==0) {
+		if (eve->poly_nr == 0) {
 			poly++;
 			/* now a sortof select connected */
-			ok= 1;
+			ok = 1;
 			eve->poly_nr = poly;
 			
 			while (ok) {
 				
-				ok= 0;
+				ok = 0;
 				toggle++;
-				if (toggle & 1) eed= filledgebase.first;
-				else eed= filledgebase.last;
+				if (toggle & 1) eed = filledgebase.first;
+				else eed = filledgebase.last;
 
 				while (eed) {
 					if (eed->v1->poly_nr == 0 && eed->v2->poly_nr == poly) {
 						eed->v1->poly_nr = poly;
-						eed->poly_nr= poly;
-						ok= 1;
+						eed->poly_nr = poly;
+						ok = 1;
 					}
 					else if (eed->v2->poly_nr == 0 && eed->v1->poly_nr == poly) {
 						eed->v2->poly_nr = poly;
-						eed->poly_nr= poly;
-						ok= 1;
+						eed->poly_nr = poly;
+						ok = 1;
 					}
 					else if (eed->poly_nr == 0) {
 						if (eed->v1->poly_nr == poly && eed->v2->poly_nr == poly) {
-							eed->poly_nr= poly;
-							ok= 1;
+							eed->poly_nr = poly;
+							ok = 1;
 						}
 					}
-					if (toggle & 1) eed= eed->next;
-					else eed= eed->prev;
+					if (toggle & 1) eed = eed->next;
+					else eed = eed->prev;
 				}
 			}
 		}
-		eve= eve->next;
+		eve = eve->next;
 	}
 	/* printf("amount of poly's: %d\n",poly); */
 
 	/* STEP 2: remove loose edges and strings of edges */
-	eed= filledgebase.first;
+	eed = filledgebase.first;
 	while (eed) {
-		if (eed->v1->h++ >250) break;
-		if (eed->v2->h++ >250) break;
-		eed= eed->next;
+		if (eed->v1->h++ > 250) break;
+		if (eed->v2->h++ > 250) break;
+		eed = eed->next;
 	}
 	if (eed) {
 		/* otherwise it's impossible to be sure you can clear vertices */
@@ -962,31 +966,31 @@ int BLI_edgefill(const short do_quad_tri_speedup)
 	/* does it only for vertices with ->h==1 */
 	testvertexnearedge();
 
-	ok= 1;
+	ok = 1;
 	while (ok) {
-		ok= 0;
+		ok = 0;
 		toggle++;
-		if (toggle & 1) eed= filledgebase.first;
-		else eed= filledgebase.last;
+		if (toggle & 1) eed = filledgebase.first;
+		else eed = filledgebase.last;
 		while (eed) {
-			if (toggle & 1) nexted= eed->next;
-			else nexted= eed->prev;
-			if (eed->v1->h==1) {
+			if (toggle & 1) nexted = eed->next;
+			else nexted = eed->prev;
+			if (eed->v1->h == 1) {
 				eed->v2->h--;
-				BLI_remlink(&fillvertbase,eed->v1); 
-				BLI_remlink(&filledgebase,eed); 
-				ok= 1;
+				BLI_remlink(&fillvertbase, eed->v1);
+				BLI_remlink(&filledgebase, eed);
+				ok = 1;
 			}
-			else if (eed->v2->h==1) {
+			else if (eed->v2->h == 1) {
 				eed->v1->h--;
-				BLI_remlink(&fillvertbase,eed->v2); 
-				BLI_remlink(&filledgebase,eed); 
-				ok= 1;
+				BLI_remlink(&fillvertbase, eed->v2);
+				BLI_remlink(&filledgebase, eed);
+				ok = 1;
 			}
-			eed= nexted;
+			eed = nexted;
 		}
 	}
-	if (filledgebase.first==0) {
+	if (filledgebase.first == 0) {
 		/* printf("All edges removed\n"); */
 		return 0;
 	}
@@ -1004,33 +1008,33 @@ int BLI_edgefill(const short do_quad_tri_speedup)
 
 
 	/* STEP 3: MAKE POLYFILL STRUCT */
-	pflist= (PolyFill *)MEM_callocN(poly*sizeof(PolyFill),"edgefill");
-	pf= pflist;
-	for (a=1;a<=poly;a++) {
-		pf->nr= a;
-		pf->min[0]=pf->min[1]=pf->min[2]= 1.0e20;
-		pf->max[0]=pf->max[1]=pf->max[2]= -1.0e20;
+	pflist = (PolyFill *)MEM_callocN(poly * sizeof(PolyFill), "edgefill");
+	pf = pflist;
+	for (a = 1; a <= poly; a++) {
+		pf->nr = a;
+		pf->min[0] = pf->min[1] = pf->min[2] = 1.0e20;
+		pf->max[0] = pf->max[1] = pf->max[2] = -1.0e20;
 		pf++;
 	}
-	eed= filledgebase.first;
+	eed = filledgebase.first;
 	while (eed) {
-		pflist[eed->poly_nr-1].edges++;
-		eed= eed->next;
+		pflist[eed->poly_nr - 1].edges++;
+		eed = eed->next;
 	}
 
-	eve= fillvertbase.first;
+	eve = fillvertbase.first;
 	while (eve) {
-		pflist[eve->poly_nr-1].verts++;
-		minp= pflist[eve->poly_nr-1].min;
-		maxp= pflist[eve->poly_nr-1].max;
+		pflist[eve->poly_nr - 1].verts++;
+		minp = pflist[eve->poly_nr - 1].min;
+		maxp = pflist[eve->poly_nr - 1].max;
 
-		minp[cox]= (minp[cox])<(eve->co[cox]) ? (minp[cox]) : (eve->co[cox]);
-		minp[coy]= (minp[coy])<(eve->co[coy]) ? (minp[coy]) : (eve->co[coy]);
-		maxp[cox]= (maxp[cox])>(eve->co[cox]) ? (maxp[cox]) : (eve->co[cox]);
-		maxp[coy]= (maxp[coy])>(eve->co[coy]) ? (maxp[coy]) : (eve->co[coy]);
-		if (eve->h > 2) pflist[eve->poly_nr-1].f = 1;
+		minp[cox] = (minp[cox]) < (eve->co[cox]) ? (minp[cox]) : (eve->co[cox]);
+		minp[coy] = (minp[coy]) < (eve->co[coy]) ? (minp[coy]) : (eve->co[coy]);
+		maxp[cox] = (maxp[cox]) > (eve->co[cox]) ? (maxp[cox]) : (eve->co[cox]);
+		maxp[coy] = (maxp[coy]) > (eve->co[coy]) ? (maxp[coy]) : (eve->co[coy]);
+		if (eve->h > 2) pflist[eve->poly_nr - 1].f = 1;
 
-		eve= eve->next;
+		eve = eve->next;
 	}
 
 	/* STEP 4: FIND HOLES OR BOUNDS, JOIN THEM
@@ -1038,40 +1042,40 @@ int BLI_edgefill(const short do_quad_tri_speedup)
 	 *    the edgefill itself has good auto-hole detection)
 	 * WATCH IT: ONLY WORKS WITH SORTED POLYS!!! */
 	
-	if (poly>1) {
+	if (poly > 1) {
 		short *polycache, *pc;
 
 		/* so, sort first */
 		qsort(pflist, poly, sizeof(PolyFill), vergpoly);
 
 #if 0
-		pf= pflist;
-		for (a=1;a<=poly;a++) {
-			printf("poly:%d edges:%d verts:%d flag: %d\n",a,pf->edges,pf->verts,pf->f);
+		pf = pflist;
+		for (a = 1; a <= poly; a++) {
+			printf("poly:%d edges:%d verts:%d flag: %d\n", a, pf->edges, pf->verts, pf->f);
 			PRINT2(f, f, pf->min[0], pf->min[1]);
 			pf++;
 		}
 #endif
 	
-		polycache= pc= MEM_callocN(sizeof(short)*poly, "polycache");
-		pf= pflist;
-		for (a=0; a<poly; a++, pf++) {
-			for (c=a+1;c<poly;c++) {
+		polycache = pc = MEM_callocN(sizeof(short) * poly, "polycache");
+		pf = pflist;
+		for (a = 0; a < poly; a++, pf++) {
+			for (c = a + 1; c < poly; c++) {
 				
 				/* if 'a' inside 'c': join (bbox too)
 				 * Careful: 'a' can also be inside another poly.
 				 */
-				if (boundisect(pf, pflist+c)) {
-					*pc= c;
+				if (boundisect(pf, pflist + c)) {
+					*pc = c;
 					pc++;
 				}
 				/* only for optimize! */
 				/* else if (pf->max[cox] < (pflist+c)->min[cox]) break; */
 				
 			}
-			while (pc!=polycache) {
+			while (pc != polycache) {
 				pc--;
-				mergepolysSimp(pf, pflist+ *pc);
+				mergepolysSimp(pf, pflist + *pc);
 			}
 		}
 		MEM_freeN(polycache);
@@ -1079,32 +1083,32 @@ int BLI_edgefill(const short do_quad_tri_speedup)
 
 #if 0
 	printf("after merge\n");
-	pf= pflist;
-	for (a=1;a<=poly;a++) {
-		printf("poly:%d edges:%d verts:%d flag: %d\n",a,pf->edges,pf->verts,pf->f);
+	pf = pflist;
+	for (a = 1; a <= poly; a++) {
+		printf("poly:%d edges:%d verts:%d flag: %d\n", a, pf->edges, pf->verts, pf->f);
 		pf++;
 	}
 #endif
 
 	/* STEP 5: MAKE TRIANGLES */
 
-	tempve.first= fillvertbase.first;
-	tempve.last= fillvertbase.last;
-	temped.first= filledgebase.first;
-	temped.last= filledgebase.last;
-	fillvertbase.first=fillvertbase.last= 0;
-	filledgebase.first=filledgebase.last= 0;
-
-	pf= pflist;
-	for (a=0;a<poly;a++) {
-		if (pf->edges>1) {
-			splitlist(&tempve,&temped,pf->nr);
+	tempve.first = fillvertbase.first;
+	tempve.last = fillvertbase.last;
+	temped.first = filledgebase.first;
+	temped.last = filledgebase.last;
+	fillvertbase.first = fillvertbase.last = 0;
+	filledgebase.first = filledgebase.last = 0;
+
+	pf = pflist;
+	for (a = 0; a < poly; a++) {
+		if (pf->edges > 1) {
+			splitlist(&tempve, &temped, pf->nr);
 			totfaces += scanfill(pf);
 		}
 		pf++;
 	}
-	BLI_movelisttolist(&fillvertbase,&tempve);
-	BLI_movelisttolist(&filledgebase,&temped);
+	BLI_movelisttolist(&fillvertbase, &tempve);
+	BLI_movelisttolist(&filledgebase, &temped);
 
 	/* FREE */