diff --git a/lang/cem/libcc.ansi/assert/assert.c b/lang/cem/libcc.ansi/assert/assert.c
index ac143b51c..be1df2037 100644
--- a/lang/cem/libcc.ansi/assert/assert.c
+++ b/lang/cem/libcc.ansi/assert/assert.c
@@ -3,11 +3,12 @@
  */
 /* $Id$ */
 
-#include	<assert.h>
-#include	<stdio.h>
-#include	<stdlib.h>
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
 
-void __bad_assertion(const char *mess) {
+void __bad_assertion(const char* mess)
+{
 
 	fputs(mess, stderr);
 	abort();
diff --git a/lang/cem/libcc.ansi/ctype/tolower.c b/lang/cem/libcc.ansi/ctype/tolower.c
index ff95ae0d8..0d5ece39d 100644
--- a/lang/cem/libcc.ansi/ctype/tolower.c
+++ b/lang/cem/libcc.ansi/ctype/tolower.c
@@ -1,5 +1,6 @@
-#include	<ctype.h>
+#include <ctype.h>
 
-int tolower(int c) {
-	return isupper(c) ? c - 'A' + 'a' : c ;
+int tolower(int c)
+{
+	return isupper(c) ? c - 'A' + 'a' : c;
 }
diff --git a/lang/cem/libcc.ansi/ctype/toupper.c b/lang/cem/libcc.ansi/ctype/toupper.c
index 521ae5569..8b77933c5 100644
--- a/lang/cem/libcc.ansi/ctype/toupper.c
+++ b/lang/cem/libcc.ansi/ctype/toupper.c
@@ -1,5 +1,6 @@
-#include	<ctype.h>
+#include <ctype.h>
 
-int toupper(int c) {
-	return islower(c) ? c - 'a' + 'A' : c ;
+int toupper(int c)
+{
+	return islower(c) ? c - 'a' + 'A' : c;
 }
diff --git a/lang/cem/libcc.ansi/errno/errlist.c b/lang/cem/libcc.ansi/errno/errlist.c
index 4d45c447b..1177777b1 100644
--- a/lang/cem/libcc.ansi/errno/errlist.c
+++ b/lang/cem/libcc.ansi/errno/errlist.c
@@ -4,44 +4,44 @@
  */
 /* $Id$ */
 
-#include	<errno.h>
+#include <errno.h>
 
-const char *_sys_errlist[] = {
-        "Error 0",
-        "Not owner",
-        "No such file or directory",
-        "No such process",
-        "Interrupted system call",
-        "I/O error",
-        "No such device or address",
-        "Arg list too long",
-        "Exec format error",
-        "Bad file number",
-        "No children",
-        "No more processes",
-        "Not enough core",
-        "Permission denied",
-        "Bad address",
-        "Block device required",
-        "Mount device busy",
-        "File exists",
-        "Cross-device link",
-        "No such device",
-        "Not a directory",
-        "Is a directory",
-        "Invalid argument",
-        "File table overflow",
-        "Too many open files",
-        "Not a typewriter",
-        "Text file busy",
-        "File too large",
-        "No space left on device",
-        "Illegal seek",
-        "Read-only file system",
-        "Too many links",
-        "Broken pipe",
-        "Math argument",
-        "Result too large"
+const char* _sys_errlist[] = {
+	"Error 0",
+	"Not owner",
+	"No such file or directory",
+	"No such process",
+	"Interrupted system call",
+	"I/O error",
+	"No such device or address",
+	"Arg list too long",
+	"Exec format error",
+	"Bad file number",
+	"No children",
+	"No more processes",
+	"Not enough core",
+	"Permission denied",
+	"Bad address",
+	"Block device required",
+	"Mount device busy",
+	"File exists",
+	"Cross-device link",
+	"No such device",
+	"Not a directory",
+	"Is a directory",
+	"Invalid argument",
+	"File table overflow",
+	"Too many open files",
+	"Not a typewriter",
+	"Text file busy",
+	"File too large",
+	"No space left on device",
+	"Illegal seek",
+	"Read-only file system",
+	"Too many links",
+	"Broken pipe",
+	"Math argument",
+	"Result too large"
 };
 
 const int _sys_nerr = sizeof(_sys_errlist) / sizeof(_sys_errlist[0]);
diff --git a/lang/cem/libcc.ansi/locale/localeconv.c b/lang/cem/libcc.ansi/locale/localeconv.c
index 766a4b87c..16da65cd6 100644
--- a/lang/cem/libcc.ansi/locale/localeconv.c
+++ b/lang/cem/libcc.ansi/locale/localeconv.c
@@ -3,15 +3,15 @@
  */
 /* $Id$ */
 
-#include	<limits.h>
-#include	<locale.h>
+#include <limits.h>
+#include <locale.h>
 
 extern struct lconv _lc;
 
-struct lconv *
+struct lconv*
 localeconv(void)
 {
-	register struct lconv *lcp = &_lc;
+	register struct lconv* lcp = &_lc;
 
 	lcp->decimal_point = ".";
 	lcp->thousands_sep = "";
diff --git a/lang/cem/libcc.ansi/locale/setlocale.c b/lang/cem/libcc.ansi/locale/setlocale.c
index 9b61ed58e..76780c444 100644
--- a/lang/cem/libcc.ansi/locale/setlocale.c
+++ b/lang/cem/libcc.ansi/locale/setlocale.c
@@ -3,26 +3,28 @@
  */
 /* $Id$ */
 
-#include	<locale.h>
-#include	<string.h>
+#include <locale.h>
+#include <string.h>
 
 struct lconv _lc;
 
-char *
-setlocale(int category, const char *locale)
+char* setlocale(int category, const char* locale)
 {
-	if (!locale) return "C";
-	if (*locale && strcmp(locale, "C")) return (char *)NULL;
-	
-	switch(category) {
-	case LC_ALL:
-	case LC_CTYPE:
-	case LC_COLLATE:
-	case LC_TIME:
-	case LC_NUMERIC:
-	case LC_MONETARY:
-		return *locale ? (char *)locale : "C";
-	default:
-		return (char *)NULL;
+	if (!locale)
+		return "C";
+	if (*locale && strcmp(locale, "C"))
+		return (char*)NULL;
+
+	switch (category)
+	{
+		case LC_ALL:
+		case LC_CTYPE:
+		case LC_COLLATE:
+		case LC_TIME:
+		case LC_NUMERIC:
+		case LC_MONETARY:
+			return *locale ? (char*)locale : "C";
+		default:
+			return (char*)NULL;
 	}
 }
diff --git a/lang/cem/libcc.ansi/malloc/calloc.c b/lang/cem/libcc.ansi/malloc/calloc.c
index 2e9d3be16..814841fd5 100644
--- a/lang/cem/libcc.ansi/malloc/calloc.c
+++ b/lang/cem/libcc.ansi/malloc/calloc.c
@@ -4,20 +4,20 @@
 
 void* calloc(size_t nmemb, size_t size)
 {
-    size_t bytes = nmemb * size;
-    void* ptr;
-    
-    /* Test for overflow.
+	size_t bytes = nmemb * size;
+	void* ptr;
+
+	/* Test for overflow.
      * See http://stackoverflow.com/questions/1815367/multiplication-of-large-numbers-how-to-catch-overflow
      */
 
-    if ((nmemb == 0) || (size == 0) || (nmemb > (SIZE_MAX / size)))
-        return NULL;
-    
-    ptr = malloc(bytes);
-    if (!ptr)
-        return NULL;
+	if ((nmemb == 0) || (size == 0) || (nmemb > (SIZE_MAX / size)))
+		return NULL;
 
-    memset(ptr, 0, bytes);
-    return ptr;
+	ptr = malloc(bytes);
+	if (!ptr)
+		return NULL;
+
+	memset(ptr, 0, bytes);
+	return ptr;
 }
diff --git a/lang/cem/libcc.ansi/malloc/malloc.c b/lang/cem/libcc.ansi/malloc/malloc.c
index 7eaaacaba..71f3c80b2 100644
--- a/lang/cem/libcc.ansi/malloc/malloc.c
+++ b/lang/cem/libcc.ansi/malloc/malloc.c
@@ -3,7 +3,7 @@
 #include <unistd.h>
 #include "malloc.h"
 
-block_t __mem_root = {&__mem_root, 0};
+block_t __mem_root = { &__mem_root, 0 };
 block_t* __mem_freelist = &__mem_root;
 
 /* Pulls more memory from the system. */
@@ -57,7 +57,7 @@ void* malloc(size_t size)
 			 * The size field is already set. */
 			prev->next = p->next;
 			__mem_freelist = prev;
-			return (void*) (p+1);
+			return (void*)(p + 1);
 		}
 		else if (p->size > nblocks)
 		{
@@ -67,7 +67,7 @@ void* malloc(size_t size)
 			p += p->size; /* p now points at our new block */
 			p->size = nblocks;
 			__mem_freelist = prev;
-			return (void*) (p+1);
+			return (void*)(p + 1);
 		}
 
 		if (p == __mem_freelist)
@@ -84,7 +84,7 @@ void* malloc(size_t size)
 	}
 }
 
-void free(void *ptr)
+void free(void* ptr)
 {
 	block_t* h = BLOCKOF(ptr);
 	block_t* p;
@@ -118,7 +118,7 @@ void free(void *ptr)
 
 		p = p->next;
 	}
-	
+
 	/* If we can, merge the next block onto the end of h. */
 
 	if ((h + h->size) == p->next)
@@ -148,4 +148,3 @@ void free(void *ptr)
 	/* ...and update the ring pointer. */
 	__mem_freelist = p;
 }
-
diff --git a/lang/cem/libcc.ansi/malloc/realloc.c b/lang/cem/libcc.ansi/malloc/realloc.c
index 7e6dfbb70..c941d8091 100644
--- a/lang/cem/libcc.ansi/malloc/realloc.c
+++ b/lang/cem/libcc.ansi/malloc/realloc.c
@@ -4,7 +4,7 @@
 #include <string.h>
 #include "malloc.h"
 
-void* realloc(void *ptr, size_t size)
+void* realloc(void* ptr, size_t size)
 {
 	block_t* h;
 	size_t nblocks;
@@ -25,7 +25,7 @@ void* realloc(void *ptr, size_t size)
 	/* Overflow check. */
 	if (nblocks < size)
 		return NULL;
-	
+
 	/* Shrinking the block? Don't bother doing anything (it's never worth it). */
 	if (nblocks <= h->size)
 		return ptr;
diff --git a/lang/cem/libcc.ansi/math/asin.c b/lang/cem/libcc.ansi/math/asin.c
index 2a7ddd7c7..1e3180086 100644
--- a/lang/cem/libcc.ansi/math/asin.c
+++ b/lang/cem/libcc.ansi/math/asin.c
@@ -6,66 +6,76 @@
  */
 /* $Id$ */
 
-#include	<math.h>
-#include	<errno.h>
-#include	"localmath.h"
+#include <math.h>
+#include <errno.h>
+#include "localmath.h"
 
 static double
 asin_acos(double x, int cosfl)
 {
 	int negative = x < 0;
-	int     i;
-	double  g;
+	int i;
+	double g;
 	static double p[] = {
 		-0.27368494524164255994e+2,
-		 0.57208227877891731407e+2,
+		0.57208227877891731407e+2,
 		-0.39688862997540877339e+2,
-		 0.10152522233806463645e+2,
+		0.10152522233806463645e+2,
 		-0.69674573447350646411e+0
 	};
 	static double q[] = {
 		-0.16421096714498560795e+3,
-		 0.41714430248260412556e+3,
+		0.41714430248260412556e+3,
 		-0.38186303361750149284e+3,
-		 0.15095270841030604719e+3,
+		0.15095270841030604719e+3,
 		-0.23823859153670238830e+2,
-		 1.0
+		1.0
 	};
 
-	if (__IsNan(x)) {
+	if (__IsNan(x))
+	{
 		errno = EDOM;
 		return x;
 	}
 
-	if (negative) {
+	if (negative)
+	{
 		x = -x;
 	}
-	if (x > 0.5) {
+	if (x > 0.5)
+	{
 		i = 1;
-		if (x > 1) {
+		if (x > 1)
+		{
 			errno = EDOM;
 			return 0;
 		}
 		g = 0.5 - 0.5 * x;
-		x = - sqrt(g);
+		x = -sqrt(g);
 		x += x;
 	}
-	else {
+	else
+	{
 		/* ??? avoid underflow ??? */
 		i = 0;
 		g = x * x;
 	}
 	x += x * g * POLYNOM4(g, p) / POLYNOM5(g, q);
-	if (cosfl) {
-		if (! negative) x = -x;
+	if (cosfl)
+	{
+		if (!negative)
+			x = -x;
 	}
-	if ((cosfl == 0) == (i == 1)) {
+	if ((cosfl == 0) == (i == 1))
+	{
 		x = (x + M_PI_4) + M_PI_4;
 	}
-	else if (cosfl && negative && i == 1) {
+	else if (cosfl && negative && i == 1)
+	{
 		x = (x + M_PI_2) + M_PI_2;
 	}
-	if (! cosfl && negative) x = -x;
+	if (!cosfl && negative)
+		x = -x;
 	return x;
 }
 
diff --git a/lang/cem/libcc.ansi/math/atan.c b/lang/cem/libcc.ansi/math/atan.c
index 055d0fdba..eb04d095f 100644
--- a/lang/cem/libcc.ansi/math/atan.c
+++ b/lang/cem/libcc.ansi/math/atan.c
@@ -6,10 +6,10 @@
  */
 /* $Id$ */
 
-#include	<float.h>
-#include	<math.h>
-#include	<errno.h>
-#include	"localmath.h"
+#include <float.h>
+#include <math.h>
+#include <errno.h>
+#include "localmath.h"
 
 double
 atan(double x)
@@ -26,47 +26,52 @@ atan(double x)
 		-0.83758299368150059274e+0
 	};
 	static double q[] = {
-		 0.41066306682575781263e+2,
-		 0.86157349597130242515e+2,
-		 0.59578436142597344465e+2,
-		 0.15024001160028576121e+2,
-		 1.0
+		0.41066306682575781263e+2,
+		0.86157349597130242515e+2,
+		0.59578436142597344465e+2,
+		0.15024001160028576121e+2,
+		1.0
 	};
 	static double a[] = {
 		0.0,
-		0.52359877559829887307710723554658381,  /* pi/6 */
+		0.52359877559829887307710723554658381, /* pi/6 */
 		M_PI_2,
-		1.04719755119659774615421446109316763   /* pi/3 */
+		1.04719755119659774615421446109316763 /* pi/3 */
 	};
 
-	int     neg = x < 0;
-	int     n;
-	double  g;
+	int neg = x < 0;
+	int n;
+	double g;
 
-	if (__IsNan(x)) {
+	if (__IsNan(x))
+	{
 		errno = EDOM;
 		return x;
 	}
-	if (neg) {
+	if (neg)
+	{
 		x = -x;
 	}
-	if (x > 1.0) {
-		x = 1.0/x;
+	if (x > 1.0)
+	{
+		x = 1.0 / x;
 		n = 2;
 	}
-	else    n = 0;
+	else
+		n = 0;
 
-	if (x > 0.26794919243112270647) {       /* 2-sqtr(3) */
+	if (x > 0.26794919243112270647)
+	{ /* 2-sqtr(3) */
 		n = n + 1;
-		x = (((0.73205080756887729353*x-0.5)-0.5)+x)/
-			(1.73205080756887729353+x);
+		x = (((0.73205080756887729353 * x - 0.5) - 0.5) + x) / (1.73205080756887729353 + x);
 	}
 
 	/* ??? avoid underflow ??? */
 
 	g = x * x;
 	x += x * g * POLYNOM3(g, p) / POLYNOM4(g, q);
-	if (n > 1) x = -x;
+	if (n > 1)
+		x = -x;
 	x += a[n];
 	return neg ? -x : x;
 }
diff --git a/lang/cem/libcc.ansi/math/atan2.c b/lang/cem/libcc.ansi/math/atan2.c
index b822f989a..6f8362468 100644
--- a/lang/cem/libcc.ansi/math/atan2.c
+++ b/lang/cem/libcc.ansi/math/atan2.c
@@ -6,35 +6,41 @@
  */
 /* $Id$ */
 
-#include	<math.h>
-#include	<errno.h>
-#include	"localmath.h"
+#include <math.h>
+#include <errno.h>
+#include "localmath.h"
 
 double
 atan2(double y, double x)
 {
 	double absx, absy, val;
 
-	if (x == 0 && y == 0) {
+	if (x == 0 && y == 0)
+	{
 		errno = EDOM;
 		return 0;
 	}
 	absy = y < 0 ? -y : y;
 	absx = x < 0 ? -x : x;
-	if (absy - absx == absy) {
+	if (absy - absx == absy)
+	{
 		/* x negligible compared to y */
 		return y < 0 ? -M_PI_2 : M_PI_2;
 	}
-	if (absx - absy == absx) {
+	if (absx - absy == absx)
+	{
 		/* y negligible compared to x */
 		val = 0.0;
 	}
-	else	val = atan(y/x);
-	if (x > 0) {
+	else
+		val = atan(y / x);
+	if (x > 0)
+	{
 		/* first or fourth quadrant; already correct */
 		return val;
 	}
-	if (y < 0) {
+	if (y < 0)
+	{
 		/* third quadrant */
 		return val - M_PI;
 	}
diff --git a/lang/cem/libcc.ansi/math/ceil.c b/lang/cem/libcc.ansi/math/ceil.c
index eab485e2e..2d06949a2 100644
--- a/lang/cem/libcc.ansi/math/ceil.c
+++ b/lang/cem/libcc.ansi/math/ceil.c
@@ -6,14 +6,14 @@
  */
 /* $Id$ */
 
-#include	<math.h>
+#include <math.h>
 
 double
 ceil(double x)
 {
 	double val;
 
-	return modf(x, &val) > 0 ? val + 1.0 : val ;
+	return modf(x, &val) > 0 ? val + 1.0 : val;
 	/*	this also works if modf always returns a positive
 		fractional part
 	*/
diff --git a/lang/cem/libcc.ansi/math/exp.c b/lang/cem/libcc.ansi/math/exp.c
index 95014d6bc..1583d913c 100644
--- a/lang/cem/libcc.ansi/math/exp.c
+++ b/lang/cem/libcc.ansi/math/exp.c
@@ -6,11 +6,10 @@
  */
 /* $Id$ */
 
-#include	<math.h>
-#include	<float.h>
-#include	<errno.h>
-#include	"localmath.h"
-
+#include <math.h>
+#include <float.h>
+#include <errno.h>
+#include "localmath.h"
 
 double
 exp(double x)
@@ -32,41 +31,46 @@ exp(double x)
 		0.63121894374398503557e-3,
 		0.75104028399870046114e-6
 	};
-	double	xn, g;
-	int	n;
-	int	negative = x < 0;
+	double xn, g;
+	int n;
+	int negative = x < 0;
 
-	if (__IsNan(x)) {
+	if (__IsNan(x))
+	{
 		errno = EDOM;
 		return x;
 	}
-	if (x < M_LN_MIN_D) {
+	if (x < M_LN_MIN_D)
+	{
 		errno = ERANGE;
 		return 0.0;
 	}
-	if (x > M_LN_MAX_D) {
+	if (x > M_LN_MAX_D)
+	{
 		errno = ERANGE;
 		return HUGE_VAL;
 	}
 
-	if (negative) x = -x;
- 
+	if (negative)
+		x = -x;
+
 	/* ??? avoid underflow ??? */
 
-	n = x * M_LOG2E + 0.5;	/* 1/ln(2) = log2(e), 0.5 added for rounding */
+	n = x * M_LOG2E + 0.5; /* 1/ln(2) = log2(e), 0.5 added for rounding */
 	xn = n;
 	{
-		double	x1 = (long) x;
-		double	x2 = x - x1;
+		double x1 = (long)x;
+		double x2 = x - x1;
 
-		g = ((x1-xn*0.693359375)+x2) - xn*(-2.1219444005469058277e-4);
+		g = ((x1 - xn * 0.693359375) + x2) - xn * (-2.1219444005469058277e-4);
 	}
-	if (negative) {
+	if (negative)
+	{
 		g = -g;
 		n = -n;
 	}
 	xn = g * g;
 	x = g * POLYNOM2(xn, p);
 	n += 1;
-	return (ldexp(0.5 + x/(POLYNOM3(xn, q) - x), n));
+	return (ldexp(0.5 + x / (POLYNOM3(xn, q) - x), n));
 }
diff --git a/lang/cem/libcc.ansi/math/fabs.c b/lang/cem/libcc.ansi/math/fabs.c
index e7a533de5..526d5d63e 100644
--- a/lang/cem/libcc.ansi/math/fabs.c
+++ b/lang/cem/libcc.ansi/math/fabs.c
@@ -9,5 +9,5 @@
 double
 fabs(double x)
 {
-	return  x < 0 ? -x : x;
+	return x < 0 ? -x : x;
 }
diff --git a/lang/cem/libcc.ansi/math/floor.c b/lang/cem/libcc.ansi/math/floor.c
index 0be49ca42..4f1cd2dc0 100644
--- a/lang/cem/libcc.ansi/math/floor.c
+++ b/lang/cem/libcc.ansi/math/floor.c
@@ -6,14 +6,14 @@
  */
 /* $Id$ */
 
-#include	<math.h>
+#include <math.h>
 
 double
 floor(double x)
 {
 	double val;
 
-	return modf(x, &val) < 0 ? val - 1.0 : val ;
+	return modf(x, &val) < 0 ? val - 1.0 : val;
 	/*	this also works if modf always returns a positive
 		fractional part
 	*/
diff --git a/lang/cem/libcc.ansi/math/fmod.c b/lang/cem/libcc.ansi/math/fmod.c
index ae0783e6b..4a784a98f 100644
--- a/lang/cem/libcc.ansi/math/fmod.c
+++ b/lang/cem/libcc.ansi/math/fmod.c
@@ -6,29 +6,34 @@
 #include <math.h>
 #include <errno.h>
 
-double
-(fmod)(double x, double y)
-{				/* compute fmod(x, y) */
+double(fmod)(double x, double y)
+{ /* compute fmod(x, y) */
 	double t;
 	int n, neg;
 	int ychar, xchar;
 
-    	if (y == 0.0) {
+	if (y == 0.0)
+	{
 		errno = EDOM;
 		return 0.0;
-    	}
-    				/* fmod(finite, finite) */
-	if (y < 0.0) y = -y;
-	if (x < 0.0) x = -x, neg = 1;
-	else neg = 0;
+	}
+	/* fmod(finite, finite) */
+	if (y < 0.0)
+		y = -y;
+	if (x < 0.0)
+		x = -x, neg = 1;
+	else
+		neg = 0;
 	t = frexp(y, &ychar);
-				/* substract |y| until |x| < |y| */
+	/* substract |y| until |x| < |y| */
 
 	t = frexp(x, &xchar);
-	for (n = xchar - ychar; 0 <= n; --n) {
-				/* try to substract |y|*2^n */
-	    t = ldexp(y, n);
-	    if (t <= x) x -= t;
+	for (n = xchar - ychar; 0 <= n; --n)
+	{
+		/* try to substract |y|*2^n */
+		t = ldexp(y, n);
+		if (t <= x)
+			x -= t;
 	}
 	return (neg ? -x : x);
 }
diff --git a/lang/cem/libcc.ansi/math/hypot.c b/lang/cem/libcc.ansi/math/hypot.c
index 612a4bde1..ad181d157 100644
--- a/lang/cem/libcc.ansi/math/hypot.c
+++ b/lang/cem/libcc.ansi/math/hypot.c
@@ -10,25 +10,30 @@
 /* $Id$ */
 
 double
-hypot(double x,double y)
+hypot(double x, double y)
 {
 	/*	Computes sqrt(x*x+y*y), avoiding overflow */
 
-	if (x < 0) x = -x;
-	if (y < 0) y = -y;
-	if (x > y) {
+	if (x < 0)
+		x = -x;
+	if (y < 0)
+		y = -y;
+	if (x > y)
+	{
 		double t = y;
 		y = x;
 		x = t;
 	}
 	/* sqrt(x*x+y*y) = sqrt(y*y*(x*x/(y*y)+1.0)) = y*sqrt(x*x/(y*y)+1.0) */
-	if (y == 0.0) return 0.0;
+	if (y == 0.0)
+		return 0.0;
 	x /= y;
-	return y*sqrt(x*x+1.0);
+	return y * sqrt(x * x + 1.0);
 }
 
-struct complex {
-	double r,i;
+struct complex
+{
+	double r, i;
 };
 
 double
diff --git a/lang/cem/libcc.ansi/math/isnan.c b/lang/cem/libcc.ansi/math/isnan.c
index b64c6d905..7f1b31aed 100644
--- a/lang/cem/libcc.ansi/math/isnan.c
+++ b/lang/cem/libcc.ansi/math/isnan.c
@@ -4,8 +4,8 @@ __IsNan(double d)
 #else
 	float f = d;
 
-	if ((*((long *) &f) & 0x7f800000) == 0x7f800000 &&
-	    (*((long *) &f) & 0x007fffff) != 0) return 1;
+	if ((*((long*)&f) & 0x7f800000) == 0x7f800000 && (*((long*)&f) & 0x007fffff) != 0)
+		return 1;
 #endif
 	return 0;
 }
diff --git a/lang/cem/libcc.ansi/math/ldexp.c b/lang/cem/libcc.ansi/math/ldexp.c
index eb7e3d9ee..7f1b0ee19 100644
--- a/lang/cem/libcc.ansi/math/ldexp.c
+++ b/lang/cem/libcc.ansi/math/ldexp.c
@@ -4,9 +4,9 @@
  */
 /* $Id$ */
 
-#include	<math.h>
-#include	<float.h>
-#include	<errno.h>
+#include <math.h>
+#include <float.h>
+#include <errno.h>
 
 double
 ldexp(double fl, int exp)
@@ -14,42 +14,52 @@ ldexp(double fl, int exp)
 	int sign = 1;
 	int currexp;
 
-	if (__IsNan(fl)) {
+	if (__IsNan(fl))
+	{
 		errno = EDOM;
 		return fl;
 	}
-	if (fl == 0.0) return 0.0;
-	if (fl<0) {
+	if (fl == 0.0)
+		return 0.0;
+	if (fl < 0)
+	{
 		fl = -fl;
 		sign = -1;
 	}
-	if (fl > DBL_MAX) {		/* for infinity */
+	if (fl > DBL_MAX)
+	{ /* for infinity */
 		errno = ERANGE;
 		return sign * fl;
 	}
-	fl = frexp(fl,&currexp);
+	fl = frexp(fl, &currexp);
 	exp += currexp;
-	if (exp > 0) {
-		if (exp > DBL_MAX_EXP) {
+	if (exp > 0)
+	{
+		if (exp > DBL_MAX_EXP)
+		{
 			errno = ERANGE;
 			return sign * HUGE_VAL;
 		}
-		while (exp>30) {
-			fl *= (double) (1L << 30);
+		while (exp > 30)
+		{
+			fl *= (double)(1L << 30);
 			exp -= 30;
 		}
-		fl *= (double) (1L << exp);
+		fl *= (double)(1L << exp);
 	}
-	else	{
+	else
+	{
 		/* number need not be normalized */
-		if (exp < DBL_MIN_EXP - DBL_MANT_DIG) {
+		if (exp < DBL_MIN_EXP - DBL_MANT_DIG)
+		{
 			return 0.0;
 		}
-		while (exp<-30) {
-			fl /= (double) (1L << 30);
+		while (exp < -30)
+		{
+			fl /= (double)(1L << 30);
 			exp += 30;
 		}
-		fl /= (double) (1L << -exp);
+		fl /= (double)(1L << -exp);
 	}
 	return sign * fl;
 }
diff --git a/lang/cem/libcc.ansi/math/log.c b/lang/cem/libcc.ansi/math/log.c
index c1ec51f95..3be9c87c7 100644
--- a/lang/cem/libcc.ansi/math/log.c
+++ b/lang/cem/libcc.ansi/math/log.c
@@ -6,10 +6,10 @@
  */
 /* $Id$ */
 
-#include	<math.h>
-#include	<float.h>
-#include	<errno.h>
-#include	"localmath.h"
+#include <math.h>
+#include <float.h>
+#include <errno.h>
+#include "localmath.h"
 
 double
 log(double x)
@@ -20,47 +20,55 @@ log(double x)
 	*/
 	static double a[] = {
 		-0.64124943423745581147e2,
-		 0.16383943563021534222e2,
+		0.16383943563021534222e2,
 		-0.78956112887491257267e0
 	};
 	static double b[] = {
 		-0.76949932108494879777e3,
-		 0.31203222091924532844e3,
+		0.31203222091924532844e3,
 		-0.35667977739034646171e2,
-		 1.0
+		1.0
 	};
 
-	double	znum, zden, z, w;
-	int	exponent;
+	double znum, zden, z, w;
+	int exponent;
 
-	if (__IsNan(x)) {
+	if (__IsNan(x))
+	{
 		errno = EDOM;
 		return x;
 	}
-	if (x < 0) {
+	if (x < 0)
+	{
 		errno = EDOM;
 		return -HUGE_VAL;
 	}
-	else if (x == 0) {
+	else if (x == 0)
+	{
 		errno = ERANGE;
 		return -HUGE_VAL;
 	}
 
-	if (x <= DBL_MAX) {
+	if (x <= DBL_MAX)
+	{
 	}
-	else return x;	/* for infinity and Nan */
+	else
+		return x; /* for infinity and Nan */
 	x = frexp(x, &exponent);
-	if (x > M_1_SQRT2) {
+	if (x > M_1_SQRT2)
+	{
 		znum = (x - 0.5) - 0.5;
 		zden = x * 0.5 + 0.5;
 	}
-	else {
+	else
+	{
 		znum = x - 0.5;
 		zden = znum * 0.5 + 0.5;
 		exponent--;
 	}
-	z = znum/zden; w = z * z;
-	x = z + z * w * (POLYNOM2(w,a)/POLYNOM3(w,b));
+	z = znum / zden;
+	w = z * z;
+	x = z + z * w * (POLYNOM2(w, a) / POLYNOM3(w, b));
 	z = exponent;
 	x += z * (-2.121944400546905827679e-4);
 	return x + z * 0.693359375;
diff --git a/lang/cem/libcc.ansi/math/log10.c b/lang/cem/libcc.ansi/math/log10.c
index b759c8478..9eb270ec2 100644
--- a/lang/cem/libcc.ansi/math/log10.c
+++ b/lang/cem/libcc.ansi/math/log10.c
@@ -6,22 +6,25 @@
  */
 /* $Id$ */
 
-#include	<math.h>
-#include	<errno.h>
-#include	"localmath.h"
+#include <math.h>
+#include <errno.h>
+#include "localmath.h"
 
 double
 log10(double x)
 {
-	if (__IsNan(x)) {
+	if (__IsNan(x))
+	{
 		errno = EDOM;
 		return x;
 	}
-	if (x < 0) {
+	if (x < 0)
+	{
 		errno = EDOM;
 		return -HUGE_VAL;
 	}
-	else if (x == 0) {
+	else if (x == 0)
+	{
 		errno = ERANGE;
 		return -HUGE_VAL;
 	}
diff --git a/lang/cem/libcc.ansi/math/pow.c b/lang/cem/libcc.ansi/math/pow.c
index 639dc07e5..0e6d6c99b 100644
--- a/lang/cem/libcc.ansi/math/pow.c
+++ b/lang/cem/libcc.ansi/math/pow.c
@@ -6,94 +6,116 @@
  */
 /* $Id$ */
 
-#include	<math.h>
-#include	<float.h>
-#include	<errno.h>
-#include	<limits.h>
+#include <math.h>
+#include <float.h>
+#include <errno.h>
+#include <limits.h>
 
 double
 pow(double x, double y)
 {
-	double	y_intpart, y_fractpart, fp;
-	int	negexp, negx;
-	int	ex, newexp;
+	double y_intpart, y_fractpart, fp;
+	int negexp, negx;
+	int ex, newexp;
 	unsigned long yi;
 
-	if (x == 1.0) return x;
+	if (x == 1.0)
+		return x;
 
-	if (x == 0 && y <= 0) {
+	if (x == 0 && y <= 0)
+	{
 		errno = EDOM;
 		return 0;
 	}
 
-	if (y == 0) return 1.0;
+	if (y == 0)
+		return 1.0;
 
-	if (y < 0) {
+	if (y < 0)
+	{
 		y = -y;
 		negexp = 1;
 	}
-	else	negexp = 0;
+	else
+		negexp = 0;
 
 	y_fractpart = modf(y, &y_intpart);
 
-	if (y_fractpart != 0) {
-		if (x < 0) {
+	if (y_fractpart != 0)
+	{
+		if (x < 0)
+		{
 			errno = EDOM;
 			return 0;
 		}
 	}
 
 	negx = 0;
-	if (x < 0) {
+	if (x < 0)
+	{
 		x = -x;
 		negx = 1;
 	}
 
-	if (y_intpart > ULONG_MAX) {
-		if (negx && modf(y_intpart/2.0, &y_fractpart) == 0) {
+	if (y_intpart > ULONG_MAX)
+	{
+		if (negx && modf(y_intpart / 2.0, &y_fractpart) == 0)
+		{
 			negx = 0;
 		}
 
 		x = log(x);
 
 		/* Beware of overflow in the multiplication */
-		if (x > 1.0 && y > DBL_MAX/x) {
+		if (x > 1.0 && y > DBL_MAX / x)
+		{
 			errno = ERANGE;
 			return HUGE_VAL;
 		}
-		if (negexp) y = -y;
+		if (negexp)
+			y = -y;
 
-		if (negx) return -exp(x*y);
+		if (negx)
+			return -exp(x * y);
 		return exp(x * y);
 	}
 
-	if (y_fractpart != 0) {
+	if (y_fractpart != 0)
+	{
 		fp = exp(y_fractpart * log(x));
 	}
-	else	fp = 1.0;
+	else
+		fp = 1.0;
 	yi = y_intpart;
-	if (! (yi & 1)) negx = 0;
+	if (!(yi & 1))
+		negx = 0;
 	x = frexp(x, &ex);
 	newexp = 0;
-	for (;;) {
-		if (yi & 1) {
+	for (;;)
+	{
+		if (yi & 1)
+		{
 			fp *= x;
 			newexp += ex;
 		}
 		yi >>= 1;
-		if (yi == 0) break;
+		if (yi == 0)
+			break;
 		x *= x;
 		ex <<= 1;
-		if (x < 0.5) {
+		if (x < 0.5)
+		{
 			x += x;
 			ex -= 1;
 		}
 	}
-	if (negexp) {
-		fp = 1.0/fp;
+	if (negexp)
+	{
+		fp = 1.0 / fp;
 		newexp = -newexp;
 	}
-	if (negx) {
+	if (negx)
+	{
 		return -ldexp(fp, newexp);
 	}
 	return ldexp(fp, newexp);
diff --git a/lang/cem/libcc.ansi/math/sin.c b/lang/cem/libcc.ansi/math/sin.c
index 9c4591d5a..a55fa93d0 100644
--- a/lang/cem/libcc.ansi/math/sin.c
+++ b/lang/cem/libcc.ansi/math/sin.c
@@ -6,10 +6,10 @@
  */
 /* $Id$ */
 
-#include	<math.h>
-#include	<float.h>
-#include	<errno.h>
-#include	"localmath.h"
+#include <math.h>
+#include <float.h>
+#include <errno.h>
+#include "localmath.h"
 
 static double
 sinus(double x, int cos_flag)
@@ -21,39 +21,44 @@ sinus(double x, int cos_flag)
 
 	static double r[] = {
 		-0.16666666666666665052e+0,
-		 0.83333333333331650314e-2,
+		0.83333333333331650314e-2,
 		-0.19841269841201840457e-3,
-		 0.27557319210152756119e-5,
+		0.27557319210152756119e-5,
 		-0.25052106798274584544e-7,
-		 0.16058936490371589114e-9,
+		0.16058936490371589114e-9,
 		-0.76429178068910467734e-12,
-		 0.27204790957888846175e-14
+		0.27204790957888846175e-14
 	};
 
-	double  y;
-	int     neg = 1;
+	double y;
+	int neg = 1;
 
-	if (__IsNan(x)) {
+	if (__IsNan(x))
+	{
 		errno = EDOM;
 		return x;
 	}
-	if (x < 0) {
+	if (x < 0)
+	{
 		x = -x;
 		neg = -1;
 	}
-	if (cos_flag) {
+	if (cos_flag)
+	{
 		neg = 1;
 		y = M_PI_2 + x;
 	}
-	else    y = x;
+	else
+		y = x;
 
 	/* ??? avoid loss of significance, if y is too large, error ??? */
 
 	y = y * M_1_PI + 0.5;
 
-	if (y >= DBL_MAX/M_PI) return 0.0;
+	if (y >= DBL_MAX / M_PI)
+		return 0.0;
 
-	/*      Use extended precision to calculate reduced argument.
+/*      Use extended precision to calculate reduced argument.
 		Here we used 12 bits of the mantissa for a1.
 		Also split x in integer part x1 and fraction part x2.
 	*/
@@ -63,8 +68,10 @@ sinus(double x, int cos_flag)
 		double x1, x2;
 
 		modf(y, &y);
-		if (modf(0.5*y, &x1)) neg = -neg;
-		if (cos_flag) y -= 0.5;
+		if (modf(0.5 * y, &x1))
+			neg = -neg;
+		if (cos_flag)
+			y -= 0.5;
 		x2 = modf(x, &x1);
 		x = x1 - y * A1;
 		x += x2;
@@ -72,8 +79,9 @@ sinus(double x, int cos_flag)
 #undef A1
 #undef A2
 	}
- 
-	if (x < 0) {
+
+	if (x < 0)
+	{
 		neg = -neg;
 		x = -x;
 	}
@@ -82,7 +90,7 @@ sinus(double x, int cos_flag)
 
 	y = x * x;
 	x += x * y * POLYNOM7(y, r);
-	return neg==-1 ? -x : x;
+	return neg == -1 ? -x : x;
 }
 
 double
@@ -94,6 +102,7 @@ sin(double x)
 double
 cos(double x)
 {
-	if (x < 0) x = -x;
+	if (x < 0)
+		x = -x;
 	return sinus(x, 1);
 }
diff --git a/lang/cem/libcc.ansi/math/sinh.c b/lang/cem/libcc.ansi/math/sinh.c
index bce95441d..00ad3fc36 100644
--- a/lang/cem/libcc.ansi/math/sinh.c
+++ b/lang/cem/libcc.ansi/math/sinh.c
@@ -6,10 +6,10 @@
  */
 /* $Id$ */
 
-#include	<math.h>
-#include	<float.h>
-#include	<errno.h>
-#include	"localmath.h"
+#include <math.h>
+#include <float.h>
+#include <errno.h>
+#include "localmath.h"
 
 static double
 sinh_cosh(double x, int cosh_flag)
@@ -27,42 +27,48 @@ sinh_cosh(double x, int cosh_flag)
 	};
 	static double q[] = {
 		-0.21108770058106271242e+7,
-		 0.36162723109421836460e+5,
+		0.36162723109421836460e+5,
 		-0.27773523119650701167e+3,
-		 1.0
+		1.0
 	};
-	int	negative = x < 0;
-	double	y = negative ? -x : x;
+	int negative = x < 0;
+	double y = negative ? -x : x;
 
-	if (__IsNan(x)) {
+	if (__IsNan(x))
+	{
 		errno = EDOM;
 		return x;
 	}
-	if (! cosh_flag && y <= 1.0) {
+	if (!cosh_flag && y <= 1.0)
+	{
 		/* ??? check for underflow ??? */
 		y = y * y;
-		return x + x * y * POLYNOM3(y, p)/POLYNOM3(y,q);
+		return x + x * y * POLYNOM3(y, p) / POLYNOM3(y, q);
 	}
 
-	if (y >= M_LN_MAX_D) {
-		/* exp(y) would cause overflow */
-#define LNV	0.69316101074218750000e+0
-#define VD2M1	0.52820835025874852469e-4
-		double	w = y - LNV;
-		
-		if (w < M_LN_MAX_D+M_LN2-LNV) {
+	if (y >= M_LN_MAX_D)
+	{
+/* exp(y) would cause overflow */
+#define LNV 0.69316101074218750000e+0
+#define VD2M1 0.52820835025874852469e-4
+		double w = y - LNV;
+
+		if (w < M_LN_MAX_D + M_LN2 - LNV)
+		{
 			x = exp(w);
 			x += VD2M1 * x;
 		}
-		else {
+		else
+		{
 			errno = ERANGE;
 			x = HUGE_VAL;
 		}
 	}
-	else {
-		double	z = exp(y);
-		
-		x = 0.5 * (z + (cosh_flag ? 1.0 : -1.0)/z);
+	else
+	{
+		double z = exp(y);
+
+		x = 0.5 * (z + (cosh_flag ? 1.0 : -1.0) / z);
 	}
 	return negative ? -x : x;
 }
@@ -76,6 +82,7 @@ sinh(double x)
 double
 cosh(double x)
 {
-	if (x < 0) x = -x;
+	if (x < 0)
+		x = -x;
 	return sinh_cosh(x, 1);
 }
diff --git a/lang/cem/libcc.ansi/math/sqrt.c b/lang/cem/libcc.ansi/math/sqrt.c
index 172f35059..17cfcdc0e 100644
--- a/lang/cem/libcc.ansi/math/sqrt.c
+++ b/lang/cem/libcc.ansi/math/sqrt.c
@@ -6,11 +6,11 @@
  */
 /* $Id$ */
 
-#include	<math.h>
-#include	<float.h>
-#include	<errno.h>
+#include <math.h>
+#include <float.h>
+#include <errno.h>
 
-#define NITER	5
+#define NITER 5
 
 double
 sqrt(double x)
@@ -18,25 +18,31 @@ sqrt(double x)
 	int exponent;
 	double val;
 
-	if (__IsNan(x)) {
+	if (__IsNan(x))
+	{
 		errno = EDOM;
 		return x;
 	}
-	if (x <= 0) {
-		if (x < 0) errno = EDOM;
+	if (x <= 0)
+	{
+		if (x < 0)
+			errno = EDOM;
 		return 0;
 	}
 
-	if (x > DBL_MAX) return x;	/* for infinity */
+	if (x > DBL_MAX)
+		return x; /* for infinity */
 
 	val = frexp(x, &exponent);
-	if (exponent & 1) {
+	if (exponent & 1)
+	{
 		exponent--;
 		val *= 2;
 	}
-	val = ldexp(val + 1.0, exponent/2 - 1);
+	val = ldexp(val + 1.0, exponent / 2 - 1);
 	/* was: val = (val + 1.0)/2.0; val = ldexp(val, exponent/2); */
-	for (exponent = NITER - 1; exponent >= 0; exponent--) {
+	for (exponent = NITER - 1; exponent >= 0; exponent--)
+	{
 		val = (val + x / val) / 2.0;
 	}
 	return val;
diff --git a/lang/cem/libcc.ansi/math/tan.c b/lang/cem/libcc.ansi/math/tan.c
index 159071d87..0d7a32589 100644
--- a/lang/cem/libcc.ansi/math/tan.c
+++ b/lang/cem/libcc.ansi/math/tan.c
@@ -6,10 +6,10 @@
  */
 /* $Id$ */
 
-#include	<math.h>
-#include	<float.h>
-#include	<errno.h>
-#include	"localmath.h"
+#include <math.h>
+#include <float.h>
+#include <errno.h>
+#include "localmath.h"
 
 double
 tan(double x)
@@ -21,56 +21,61 @@ tan(double x)
 
 	int negative = x < 0;
 	int invert = 0;
-	double  y;
-	static double   p[] = {
-		 1.0,
+	double y;
+	static double p[] = {
+		1.0,
 		-0.13338350006421960681e+0,
-		 0.34248878235890589960e-2,
+		0.34248878235890589960e-2,
 		-0.17861707342254426711e-4
 	};
-	static double   q[] = {
-		 1.0,
+	static double q[] = {
+		1.0,
 		-0.46671683339755294240e+0,
-		 0.25663832289440112864e-1,
+		0.25663832289440112864e-1,
 		-0.31181531907010027307e-3,
-		 0.49819433993786512270e-6
+		0.49819433993786512270e-6
 	};
 
-	if (__IsNan(x)) {
+	if (__IsNan(x))
+	{
 		errno = EDOM;
 		return x;
 	}
-	if (negative) x = -x;
- 
+	if (negative)
+		x = -x;
+
 	/* ??? avoid loss of significance, error if x is too large ??? */
 
 	y = x * M_2_PI + 0.5;
 
-	if (y >= DBL_MAX/M_PI_2) return 0.0;
+	if (y >= DBL_MAX / M_PI_2)
+		return 0.0;
 
-	/*      Use extended precision to calculate reduced argument.
+/*      Use extended precision to calculate reduced argument.
 		Here we used 12 bits of the mantissa for a1.
 		Also split x in integer part x1 and fraction part x2.
 	*/
-    #define A1 1.57080078125
-    #define A2 -4.454455103380768678308e-6
+#define A1 1.57080078125
+#define A2 -4.454455103380768678308e-6
 	{
 		double x1, x2;
 
 		modf(y, &y);
-		if (modf(0.5*y, &x1)) invert = 1;
+		if (modf(0.5 * y, &x1))
+			invert = 1;
 		x2 = modf(x, &x1);
 		x = x1 - y * A1;
 		x += x2;
 		x -= y * A2;
-    #undef A1
-    #undef A2
+#undef A1
+#undef A2
 	}
 
 	/* ??? avoid underflow ??? */
 	y = x * x;
-	x += x * y * POLYNOM2(y, p+1);
+	x += x * y * POLYNOM2(y, p + 1);
 	y = POLYNOM4(y, q);
-	if (negative) x = -x;
-	return invert ? -y/x : x/y;
+	if (negative)
+		x = -x;
+	return invert ? -y / x : x / y;
 }
diff --git a/lang/cem/libcc.ansi/math/tanh.c b/lang/cem/libcc.ansi/math/tanh.c
index 0e351029b..1bf90dd9b 100644
--- a/lang/cem/libcc.ansi/math/tanh.c
+++ b/lang/cem/libcc.ansi/math/tanh.c
@@ -6,10 +6,10 @@
  */
 /* $Id$ */
 
-#include	<float.h>
-#include	<math.h>
-#include	<errno.h>
-#include	"localmath.h"
+#include <float.h>
+#include <math.h>
+#include <errno.h>
+#include "localmath.h"
 
 double
 tanh(double x)
@@ -25,31 +25,36 @@ tanh(double x)
 		-0.96437492777225469787e+0
 	};
 	static double q[] = {
-		 0.48402357071988688686e+4,
-		 0.22337720718962312926e+4,
-		 0.11274474380534949335e+3,
-		 1.0
+		0.48402357071988688686e+4,
+		0.22337720718962312926e+4,
+		0.11274474380534949335e+3,
+		1.0
 	};
-	int 	negative = x < 0;
+	int negative = x < 0;
 
-	if (__IsNan(x)) {
+	if (__IsNan(x))
+	{
 		errno = EDOM;
 		return x;
 	}
-	if (negative) x = -x;
+	if (negative)
+		x = -x;
 
-	if (x >= 0.5*M_LN_MAX_D) {
+	if (x >= 0.5 * M_LN_MAX_D)
+	{
 		x = 1.0;
 	}
-#define LN3D2	0.54930614433405484570e+0	/* ln(3)/2 */
-	else if (x > LN3D2) {
-		x = 0.5 - 1.0/(exp(x+x)+1.0);
+#define LN3D2 0.54930614433405484570e+0 /* ln(3)/2 */
+	else if (x > LN3D2)
+	{
+		x = 0.5 - 1.0 / (exp(x + x) + 1.0);
 		x += x;
 	}
-	else {
+	else
+	{
 		/* ??? avoid underflow ??? */
-		double g = x*x;
-		x += x * g * POLYNOM2(g, p)/POLYNOM3(g, q);
+		double g = x * x;
+		x += x * g * POLYNOM2(g, p) / POLYNOM3(g, q);
 	}
 	return negative ? -x : x;
 }
diff --git a/lang/cem/libcc.ansi/misc/closedir.c b/lang/cem/libcc.ansi/misc/closedir.c
index 826026f13..12f7c825a 100644
--- a/lang/cem/libcc.ansi/misc/closedir.c
+++ b/lang/cem/libcc.ansi/misc/closedir.c
@@ -4,33 +4,32 @@
 	last edit:	11-Nov-1988	D A Gwyn
 */
 
-#include	<errno.h>
-#include	<stdlib.h>
-#include	<sys/errno.h>
-#include	<sys/types.h>
-#include	<dirent.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <sys/errno.h>
+#include <sys/types.h>
+#include <dirent.h>
 
-typedef void	*pointer;		/* (void *) if you have it */
+typedef void* pointer; /* (void *) if you have it */
 
 #ifndef NULL
-#define	NULL	0
+#define NULL 0
 #endif
 
 int _close(int d);
 
-int
-closedir(register DIR *dirp)		/* stream from opendir */
+int closedir(register DIR* dirp) /* stream from opendir */
 {
-	register int	fd;
+	register int fd;
 
-	if ( dirp == NULL || dirp->dd_buf == NULL )
-		{
+	if (dirp == NULL || dirp->dd_buf == NULL)
+	{
 		errno = EFAULT;
-		return -1;		/* invalid pointer */
-		}
+		return -1; /* invalid pointer */
+	}
 
-	fd = dirp->dd_fd;		/* bug fix thanks to R. Salz */
-	free( (pointer)dirp->dd_buf );
-	free( (pointer)dirp );
-	return _close( fd );
+	fd = dirp->dd_fd; /* bug fix thanks to R. Salz */
+	free((pointer)dirp->dd_buf);
+	free((pointer)dirp);
+	return _close(fd);
 }
diff --git a/lang/cem/libcc.ansi/misc/getdents.c b/lang/cem/libcc.ansi/misc/getdents.c
index e9d34c19a..c6d40723c 100644
--- a/lang/cem/libcc.ansi/misc/getdents.c
+++ b/lang/cem/libcc.ansi/misc/getdents.c
@@ -29,91 +29,92 @@
 	to always work, you shouldn't be using this source file at all.
 */
 
-#include	<errno.h>
-#include	<stdlib.h>
-#include	<string.h>
-#include	<sys/errno.h>
-#include	<sys/types.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/errno.h>
+#include <sys/types.h>
 #ifdef BSD_SYSV
-#include	<sys/_dir.h>		/* BSD flavor, not System V */
+#include <sys/_dir.h> /* BSD flavor, not System V */
 #else
-#if	defined(UFS)
-#define	DIRSIZ		14		/* 14 char filename in Version 7 */
+#if defined(UFS)
+#define DIRSIZ 14 /* 14 char filename in Version 7 */
 #endif
-#define	MAXNAMLEN	255
-struct  direct {
-	off_t	d_off;			/* offset of next disk directory entry */
-	u_long	d_fileno;		/* file number of entry */
-	u_short	d_reclen;		/* length of this record */
-	u_short	d_namlen;		/* length of string in d_name */
-	char	d_name[MAXNAMLEN + 1];	/* name (up to MAXNAMLEN + 1) */
+#define MAXNAMLEN 255
+struct direct
+{
+	off_t d_off; /* offset of next disk directory entry */
+	u_long d_fileno; /* file number of entry */
+	u_short d_reclen; /* length of this record */
+	u_short d_namlen; /* length of string in d_name */
+	char d_name[MAXNAMLEN + 1]; /* name (up to MAXNAMLEN + 1) */
 };
-#undef	MAXNAMLEN			/* avoid conflict with SVR3 */
+#undef MAXNAMLEN /* avoid conflict with SVR3 */
 
-#define	d_ino	d_fileno		/* compatability */
+#define d_ino d_fileno /* compatability */
 
-#ifdef d_ino				/* 4.3BSD/NFS using d_fileno */
-#undef	d_ino				/* (not absolutely necessary) */
+#ifdef d_ino /* 4.3BSD/NFS using d_fileno */
+#undef d_ino /* (not absolutely necessary) */
 #else
-#define	d_fileno	d_ino		/* (struct direct) member */
+#define d_fileno d_ino /* (struct direct) member */
 #endif
 #endif
-#include	<sys/dirent.h>
-#include	<sys/stat.h>
+#include <sys/dirent.h>
+#include <sys/stat.h>
 #ifdef UNK
 #ifndef UFS
-#error	UNK applies only to UFS
+#error UNK applies only to UFS
 /* One could do something similar for getdirentries(), but I didn't bother. */
 #endif
-#include	<signal.h>
+#include <signal.h>
 #endif
 
-#if	defined(UFS) + defined(BFS) + defined(NFS) != 1	/* sanity check */
-#error	exactly one of UFS, BFS, or NFS must be defined
+#if defined(UFS) + defined(BFS) + defined(NFS) != 1 /* sanity check */
+#error exactly one of UFS, BFS, or NFS must be defined
 #endif
 
 #ifdef UFS
-#define	RecLen( dp )	(sizeof(struct direct))	/* fixed-length entries */
-#else	/* BFS || NFS */
-#define	RecLen( dp )	((dp)->d_reclen)	/* variable-length entries */
+#define RecLen(dp) (sizeof(struct direct)) /* fixed-length entries */
+#else /* BFS || NFS */
+#define RecLen(dp) ((dp)->d_reclen) /* variable-length entries */
 #endif
 
 #ifdef NFS
 #ifdef BSD_SYSV
-#define	getdirentries	_getdirentries	/* package hides this system call */
+#define getdirentries _getdirentries /* package hides this system call */
 #endif
-extern int	getdirentries(int fd, char *buf, int nbytes, long *basep);
-static long	dummy;			/* getdirentries() needs basep */
-#define	GetBlock( fd, buf, n )	getdirentries( fd, buf, (unsigned)n, &dummy )
-#else	/* UFS || BFS */
+extern int getdirentries(int fd, char* buf, int nbytes, long* basep);
+static long dummy; /* getdirentries() needs basep */
+#define GetBlock(fd, buf, n) getdirentries(fd, buf, (unsigned)n, &dummy)
+#else /* UFS || BFS */
 #ifdef BSD_SYSV
-#define read	_read			/* avoid emulation overhead */
+#define read _read /* avoid emulation overhead */
 #endif
-extern int	read();
-#define	GetBlock( fd, buf, n )	read( fd, buf, (unsigned)n )
+extern int read();
+#define GetBlock(fd, buf, n) read(fd, buf, (unsigned)n)
 #endif
 
 #ifdef UNK
-extern int	_getdents();		/* actual system call */
+extern int _getdents(); /* actual system call */
 #endif
 
-extern int	_fstat(int fd, struct stat *buf);
-extern off_t	_lseek(int d, int offset, int whence);
+extern int _fstat(int fd, struct stat* buf);
+extern off_t _lseek(int d, int offset, int whence);
 
 #ifndef DIRBLKSIZ
-#define	DIRBLKSIZ	4096		/* directory file read buffer size */
+#define DIRBLKSIZ 4096 /* directory file read buffer size */
 #endif
 
 #ifndef NULL
-#define	NULL	0
+#define NULL 0
 #endif
 
 #ifndef SEEK_CUR
-#define	SEEK_CUR	1
+#define SEEK_CUR 1
 #endif
 
-#ifndef S_ISDIR				/* macro to test for directory file */
-#define	S_ISDIR( mode )		(((mode) & S_IFMT) == S_IFDIR)
+#ifndef S_ISDIR /* macro to test for directory file */
+#define S_ISDIR(mode) (((mode)&S_IFMT) == S_IFDIR)
 #endif
 
 #ifdef UFS
@@ -124,166 +125,168 @@ extern off_t	_lseek(int d, int offset, int whence);
 */
 
 static int
-NameLen( char name[] )				/* return # chars in embedded name */
-		/* -> name embedded in struct direct */
+NameLen(char name[]) /* return # chars in embedded name */
+/* -> name embedded in struct direct */
 {
-	register char	*s;		/* -> name[.] */
-	register char	*stop = &name[DIRSIZ];	/* -> past end of name field */
+	register char* s; /* -> name[.] */
+	register char* stop = &name[DIRSIZ]; /* -> past end of name field */
 
-	for ( s = &name[1];		/* (empty names are impossible) */
-	      *s != '\0'		/* not NUL terminator */
-	   && ++s < stop;		/* < DIRSIZ characters scanned */
+	for (s = &name[1]; /* (empty names are impossible) */
+	     *s != '\0' /* not NUL terminator */
+	     && ++s < stop; /* < DIRSIZ characters scanned */
 	    )
 		;
 
-	return s - name;		/* # valid characters in name */
+	return s - name; /* # valid characters in name */
 }
 
-#else	/* BFS || NFS */
+#else /* BFS || NFS */
 
-#define	NameLen( name )	strlen( name )	/* names are always NUL-terminated */
+#define NameLen(name) strlen(name) /* names are always NUL-terminated */
 
 #endif
 
 #ifdef UNK
-static enum	{ maybe, no, yes }	state = maybe;
-					/* does _getdents() work? */
+static enum { maybe,
+	no,
+	yes } state
+    = maybe;
+/* does _getdents() work? */
 
 /*ARGSUSED*/
 static void
-sig_catch(int sig)			/* sig must be SIGSYS */
+sig_catch(int sig) /* sig must be SIGSYS */
 {
-	state = no;			/* attempted _getdents() faulted */
+	state = no; /* attempted _getdents() faulted */
 }
 #endif
 
-int
-getdents(int fildes, char *buf, unsigned nbyte)	/* returns # bytes read;
+int getdents(int fildes, char* buf, unsigned nbyte) /* returns # bytes read;
 						    0 on EOF, -1 on error */
 /* fildes == directory file descriptor */
 /* *buf == where to put the (struct dirent)s */
 /* nbyte == size of buf[] */
 {
-	int			serrno;	/* entry errno */
-	off_t			offset;	/* initial directory file offset */
-	struct stat		statb;	/* fstat() info */
-	union	{
-		char		dblk[DIRBLKSIZ];
-					/* directory file block buffer */
-		struct direct	dummy;	/* just for alignment */
-		}	u;		/* (avoids having to malloc()) */
-	register struct direct	*dp;	/* -> u.dblk[.] */
-	register struct dirent	*bp;	/* -> buf[.] */
+	int serrno; /* entry errno */
+	off_t offset; /* initial directory file offset */
+	struct stat statb; /* fstat() info */
+	union {
+		char dblk[DIRBLKSIZ];
+		/* directory file block buffer */
+		struct direct dummy; /* just for alignment */
+	} u; /* (avoids having to malloc()) */
+	register struct direct* dp; /* -> u.dblk[.] */
+	register struct dirent* bp; /* -> buf[.] */
 
 #ifdef UNK
-	switch ( state )
-		{
-		void		(*shdlr)();	/* entry SIGSYS handler */
-		register int	retval;	/* return from _getdents() if any */
+	switch (state)
+	{
+		void (*shdlr)(); /* entry SIGSYS handler */
+		register int retval; /* return from _getdents() if any */
 
-	case yes:			/* _getdents() is known to work */
-		return _getdents( fildes, buf, nbyte );
+		case yes: /* _getdents() is known to work */
+			return _getdents(fildes, buf, nbyte);
 
-	case maybe:			/* first time only */
-		shdlr = signal( SIGSYS, sig_catch );
-		retval = _getdents( fildes, buf, nbyte );	/* try it */
-		(void)signal( SIGSYS, shdlr );
+		case maybe: /* first time only */
+			shdlr = signal(SIGSYS, sig_catch);
+			retval = _getdents(fildes, buf, nbyte); /* try it */
+			(void)signal(SIGSYS, shdlr);
 
-		if ( state == maybe )	/* SIGSYS did not occur */
+			if (state == maybe) /* SIGSYS did not occur */
 			{
-			state = yes;	/* so _getdents() must have worked */
-			return retval;
+				state = yes; /* so _getdents() must have worked */
+				return retval;
 			}
-		/* else fall through into emulation */
+			/* else fall through into emulation */
 
-/*	case no:*/	/* fall through into emulation */
-		}
+			/*	case no:*/ /* fall through into emulation */
+	}
 #endif
 
-	if ( buf == NULL
+	if (buf == NULL
 #ifdef ATT_SPEC
-	  || (unsigned long)buf % sizeof(long) != 0	/* ugh */
+	    || (unsigned long)buf % sizeof(long) != 0 /* ugh */
 #endif
-	   )	{
-		errno = EFAULT;		/* invalid pointer */
+	    )
+	{
+		errno = EFAULT; /* invalid pointer */
 		return -1;
-		}
+	}
 
-	if ( _fstat( fildes, &statb ) != 0 )
-		return -1;		/* errno set by fstat() */
+	if (_fstat(fildes, &statb) != 0)
+		return -1; /* errno set by fstat() */
 
-	if ( !S_ISDIR( statb.st_mode ) )
-		{
-		errno = ENOTDIR;	/* not a directory */
+	if (!S_ISDIR(statb.st_mode))
+	{
+		errno = ENOTDIR; /* not a directory */
 		return -1;
-		}
+	}
 
-	if ( (offset = _lseek( fildes, (off_t)0, SEEK_CUR )) < 0 )
-		return -1;		/* errno set by lseek() */
+	if ((offset = _lseek(fildes, (off_t)0, SEEK_CUR)) < 0)
+		return -1; /* errno set by lseek() */
 
-#ifdef BFS				/* no telling what remote hosts do */
-	if ( (unsigned long)offset % DIRBLKSIZ != 0 )
-		{
-		errno = ENOENT;		/* file pointer probably misaligned */
+#ifdef BFS /* no telling what remote hosts do */
+	if ((unsigned long)offset % DIRBLKSIZ != 0)
+	{
+		errno = ENOENT; /* file pointer probably misaligned */
 		return -1;
-		}
+	}
 #endif
 
-	serrno = errno;			/* save entry errno */
+	serrno = errno; /* save entry errno */
 
-	for ( bp = (struct dirent *)buf; bp == (struct dirent *)buf; )
-		{			/* convert next directory block */
-		int	size;
+	for (bp = (struct dirent*)buf; bp == (struct dirent*)buf;)
+	{ /* convert next directory block */
+		int size;
 
-		do	size = GetBlock( fildes, u.dblk, DIRBLKSIZ );
-		while ( size == -1 && errno == EINTR );
+		do
+			size = GetBlock(fildes, u.dblk, DIRBLKSIZ);
+		while (size == -1 && errno == EINTR);
 
-		if ( size <= 0 )
-			return size;	/* EOF or error (EBADF) */
+		if (size <= 0)
+			return size; /* EOF or error (EBADF) */
 
-		for ( dp = (struct direct *)u.dblk;
-		      (char *)dp < &u.dblk[size];
-		      dp = (struct direct *)((char *)dp + RecLen( dp ))
-		    )	{
+		for (dp = (struct direct*)u.dblk;
+		     (char*)dp < &u.dblk[size];
+		     dp = (struct direct*)((char*)dp + RecLen(dp)))
+		{
 #ifndef UFS
-			if ( dp->d_reclen <= 0 )
-				{
-				errno = EIO;	/* corrupted directory */
+			if (dp->d_reclen <= 0)
+			{
+				errno = EIO; /* corrupted directory */
 				return -1;
-				}
+			}
 #endif
 
-			if ( dp->d_fileno != 0 )
-				{	/* non-empty; copy to user buffer */
-				register int	reclen =
-					DIRENTSIZ( NameLen( dp->d_name ) );
+			if (dp->d_fileno != 0)
+			{ /* non-empty; copy to user buffer */
+				register int reclen = DIRENTSIZ(NameLen(dp->d_name));
 
-				if ( (char *)bp + reclen > &buf[nbyte] )
-					{
+				if ((char*)bp + reclen > &buf[nbyte])
+				{
 					errno = EINVAL;
-					return -1;	/* buf too small */
-					}
+					return -1; /* buf too small */
+				}
 
 				bp->d_ino = dp->d_fileno;
-				bp->d_off = offset + ((char *)dp - u.dblk);
+				bp->d_off = offset + ((char*)dp - u.dblk);
 				bp->d_reclen = reclen;
-				(void)strncpy( bp->d_name, dp->d_name,
-					       reclen - DIRENTBASESIZ
-					     );	/* adds NUL padding */
+				(void)strncpy(bp->d_name, dp->d_name,
+				    reclen - DIRENTBASESIZ); /* adds NUL padding */
 
-				bp = (struct dirent *)((char *)bp + reclen);
-				}
+				bp = (struct dirent*)((char*)bp + reclen);
 			}
-
-#ifndef BFS	/* 4.2BSD screwed up; fixed in 4.3BSD */
-		if ( (char *)dp > &u.dblk[size] )
-			{
-			errno = EIO;	/* corrupted directory */
-			return -1;
-			}
-#endif
 		}
 
-	errno = serrno;			/* restore entry errno */
-	return (char *)bp - buf;	/* return # bytes read */
+#ifndef BFS /* 4.2BSD screwed up; fixed in 4.3BSD */
+		if ((char*)dp > &u.dblk[size])
+		{
+			errno = EIO; /* corrupted directory */
+			return -1;
+		}
+#endif
+	}
+
+	errno = serrno; /* restore entry errno */
+	return (char*)bp - buf; /* return # bytes read */
 }
diff --git a/lang/cem/libcc.ansi/misc/getgrent.c b/lang/cem/libcc.ansi/misc/getgrent.c
index 343884a22..33517f961 100644
--- a/lang/cem/libcc.ansi/misc/getgrent.c
+++ b/lang/cem/libcc.ansi/misc/getgrent.c
@@ -5,131 +5,130 @@
  */
 /* $Id$ */
 
-#include	<stdlib.h>
-#include	<string.h>
-#include	<grp.h>
+#include <stdlib.h>
+#include <string.h>
+#include <grp.h>
 
-#define	O_RDONLY	0
+#define O_RDONLY 0
 
-int open(const char *path, int flags);
+int open(const char* path, int flags);
 
-#if	defined(__BSD4_2)
-typedef int off_t;                              /* see lseek(2) */
+#if defined(__BSD4_2)
+typedef int off_t; /* see lseek(2) */
 #else
 typedef long off_t;
 #endif
 
 off_t _lseek(int d, off_t offset, int whence);
-int _read(int d, char *buf, int nbytes);
+int _read(int d, char* buf, int nbytes);
 int _close(int d);
 
-#define	RBUFSIZE	1024
+#define RBUFSIZE 1024
 static char _gr_file[] = "/etc/group";
 static char _grbuf[256];
 static char _buffer[RBUFSIZE];
-static char *_pnt;
-static char *_buf;
-static int  _gfd = -1;
-static int  _bufcnt;
+static char* _pnt;
+static char* _buf;
+static int _gfd = -1;
+static int _bufcnt;
 static struct group grp;
 
-int
-setgrent(void)
+int setgrent(void)
 {
-        if (_gfd >= 0)
-	        _lseek(_gfd, 0L, 0);
-        else
-	        _gfd = open(_gr_file, O_RDONLY);
+	if (_gfd >= 0)
+		_lseek(_gfd, 0L, 0);
+	else
+		_gfd = open(_gr_file, O_RDONLY);
 
-        _bufcnt = 0;
-        return _gfd;
+	_bufcnt = 0;
+	return _gfd;
 }
 
-void
-endgrent(void) 
+void endgrent(void)
 {
-        if (_gfd >= 0)
-	        _close(_gfd);
+	if (_gfd >= 0)
+		_close(_gfd);
 
-        _gfd = -1;
-        _bufcnt = 0;
+	_gfd = -1;
+	_bufcnt = 0;
 }
 
-
 static int
-getline(void) 
+getline(void)
 {
-        if (_gfd < 0 && setgrent() < 0)
-	        return 0;
+	if (_gfd < 0 && setgrent() < 0)
+		return 0;
 
-        _buf = _grbuf;
-        do {
-	        if (--_bufcnt <= 0){
-	                if ((_bufcnt = _read(_gfd, _buffer, RBUFSIZE)) <= 0)
-		                return 0;
-	                else
-		                _pnt = _buffer;
+	_buf = _grbuf;
+	do
+	{
+		if (--_bufcnt <= 0)
+		{
+			if ((_bufcnt = _read(_gfd, _buffer, RBUFSIZE)) <= 0)
+				return 0;
+			else
+				_pnt = _buffer;
 		}
-	        *_buf++ = *_pnt++;
-        } while (*_pnt != '\n');
-        _pnt++;
-        _bufcnt--;
-        *_buf = 0;
-        _buf = _grbuf;
-        return 1;
+		*_buf++ = *_pnt++;
+	} while (*_pnt != '\n');
+	_pnt++;
+	_bufcnt--;
+	*_buf = 0;
+	_buf = _grbuf;
+	return 1;
 }
 
 static void
-skip_period(void) 
+skip_period(void)
 {
-        while (*_buf && *_buf != ':')
-	        _buf++;
-        *_buf++ = '\0';
+	while (*_buf && *_buf != ':')
+		_buf++;
+	*_buf++ = '\0';
 }
 
-struct group *
-getgrent(void) 
+struct group*
+getgrent(void)
 {
-        if (getline() == 0)
-               return 0;
+	if (getline() == 0)
+		return 0;
 
-        grp.gr_name = _buf;
-        skip_period();
-        grp.gr_passwd = _buf;
-        skip_period();
-        grp.gr_gid = atoi(_buf);
-        skip_period();
-        return &grp;
+	grp.gr_name = _buf;
+	skip_period();
+	grp.gr_passwd = _buf;
+	skip_period();
+	grp.gr_gid = atoi(_buf);
+	skip_period();
+	return &grp;
 }
 
-struct group *
-getgrnam(const char *name)
+struct group*
+getgrnam(const char* name)
 {
-        struct group *g;
+	struct group* g;
 
-        setgrent();
-        while ((g = getgrent()) != 0)
-	        if (!strcmp(g -> gr_name, name))
-	                break;
-        endgrent();
-        if (g != 0)
-	        return g;
-        else
-	        return 0;
+	setgrent();
+	while ((g = getgrent()) != 0)
+		if (!strcmp(g->gr_name, name))
+			break;
+	endgrent();
+	if (g != 0)
+		return g;
+	else
+		return 0;
 }
 
-struct group *
+struct group*
 getgrgid(int gid)
 {
-        struct group   *g;
+	struct group* g;
 
-        setgrent();
-        while ((g = getgrent()) != 0)
-	        if (g -> gr_gid == gid)
-	                break;
-        endgrent();
-        if (g != 0)
-	        return g;
-        else
-	        return 0;
+	setgrent();
+	while ((g = getgrent()) != 0)
+		if (g->gr_gid == gid)
+			break;
+	endgrent();
+	if (g != 0)
+		return g;
+	else
+		return 0;
 }
diff --git a/lang/cem/libcc.ansi/misc/getopt.c b/lang/cem/libcc.ansi/misc/getopt.c
index cad57fc10..9c9b88e20 100644
--- a/lang/cem/libcc.ansi/misc/getopt.c
+++ b/lang/cem/libcc.ansi/misc/getopt.c
@@ -3,56 +3,66 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
-#include	<string.h>
+#include <stdio.h>
+#include <string.h>
 
-#define ERR(s, c)       if(opterr){\
-	fputs(argv[0], stderr);\
-	fputs(s, stderr);\
-	fputc(c, stderr);\
-	fputc('\n', stderr);}
+#define ERR(s, c)               \
+	if (opterr)                 \
+	{                           \
+		fputs(argv[0], stderr); \
+		fputs(s, stderr);       \
+		fputc(c, stderr);       \
+		fputc('\n', stderr);    \
+	}
 
-int     opterr = 1;
-int     optind = 1;
-int	optopt;
-char    *optarg;
+int opterr = 1;
+int optind = 1;
+int optopt;
+char* optarg;
 
-int
-getopt(int argc, char **argv, char *opts)
+int getopt(int argc, char** argv, char* opts)
 {
 	static int sp = 1;
 	register c;
-	register char *cp;
+	register char* cp;
 
 	if (sp == 1)
-		if (optind >= argc ||
-		   argv[optind][0] != '-' || argv[optind][1] == '\0')
+		if (optind >= argc || argv[optind][0] != '-' || argv[optind][1] == '\0')
 			return EOF;
-		else if (!strcmp(argv[optind], "--")) {
+		else if (!strcmp(argv[optind], "--"))
+		{
 			optind++;
 			return EOF;
 		}
 	optopt = c = argv[optind][sp];
-	if (c == ':' || (cp=strchr(opts, c)) == NULL) {
-		ERR (": illegal option -- ", c);
-		if (argv[optind][++sp] == '\0') {
+	if (c == ':' || (cp = strchr(opts, c)) == NULL)
+	{
+		ERR(": illegal option -- ", c);
+		if (argv[optind][++sp] == '\0')
+		{
 			optind++;
 			sp = 1;
 		}
 		return '?';
 	}
-	if (*++cp == ':') {
-		if (argv[optind][sp+1] != '\0')
-			optarg = &argv[optind++][sp+1];
-		else if (++optind >= argc) {
-			ERR (": option requires an argument -- ", c);
+	if (*++cp == ':')
+	{
+		if (argv[optind][sp + 1] != '\0')
+			optarg = &argv[optind++][sp + 1];
+		else if (++optind >= argc)
+		{
+			ERR(": option requires an argument -- ", c);
 			sp = 1;
 			return '?';
-		} else
+		}
+		else
 			optarg = argv[optind++];
 		sp = 1;
-	} else {
-		if (argv[optind][++sp] == '\0') {
+	}
+	else
+	{
+		if (argv[optind][++sp] == '\0')
+		{
 			sp = 1;
 			optind++;
 		}
diff --git a/lang/cem/libcc.ansi/misc/getpass.c b/lang/cem/libcc.ansi/misc/getpass.c
index ec209f37f..4b21512ee 100644
--- a/lang/cem/libcc.ansi/misc/getpass.c
+++ b/lang/cem/libcc.ansi/misc/getpass.c
@@ -3,22 +3,21 @@
  */
 /* $Id$ */
 
-#include    <stdlib.h>
-#include	<signal.h>
-#include	<string.h>
-#include	<sgtty.h>
-#include    <fcntl.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <string.h>
+#include <sgtty.h>
+#include <fcntl.h>
 
-int _open(const char *path, int flags);
-int _write(int d, const char *buf, int nbytes);
-int _read(int d, char *buf, int nbytes);
+int _open(const char* path, int flags);
+int _write(int d, const char* buf, int nbytes);
+int _read(int d, char* buf, int nbytes);
 int _close(int d);
 
-int _stty(int, struct sgttyb *);
-int _gtty(int, struct sgttyb *);
+int _stty(int, struct sgttyb*);
+int _gtty(int, struct sgttyb*);
 
-char *
-getpass(const char *prompt)
+char* getpass(const char* prompt)
 {
 	int i = 0;
 	struct sgttyb tty, ttysave;
@@ -26,7 +25,8 @@ getpass(const char *prompt)
 	int fd;
 	void (*savesig)(int);
 
-	if ((fd = _open("/dev/tty", O_RDONLY)) < 0) fd = 0;
+	if ((fd = _open("/dev/tty", O_RDONLY)) < 0)
+		fd = 0;
 	savesig = signal(SIGINT, SIG_IGN);
 	_write(2, prompt, strlen(prompt));
 	_gtty(fd, &tty);
@@ -39,7 +39,8 @@ getpass(const char *prompt)
 	pwdbuf[i - 1] = '\0';
 	_stty(fd, &ttysave);
 	_write(2, "\n", 1);
-	if (fd != 0) _close(fd);
+	if (fd != 0)
+		_close(fd);
 	signal(SIGINT, savesig);
-	return(pwdbuf);
+	return (pwdbuf);
 }
diff --git a/lang/cem/libcc.ansi/misc/getw.c b/lang/cem/libcc.ansi/misc/getw.c
index 70efda78d..7b1f1f95e 100644
--- a/lang/cem/libcc.ansi/misc/getw.c
+++ b/lang/cem/libcc.ansi/misc/getw.c
@@ -3,17 +3,19 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
+#include <stdio.h>
 
-int getw(register FILE *stream)
+int getw(register FILE* stream)
 {
 	register int cnt = sizeof(int);
 	int w;
-	register char *p = (char *) &w;
+	register char* p = (char*)&w;
 
-	while (cnt--) {
+	while (cnt--)
+	{
 		*p++ = getc(stream);
 	}
-	if (feof(stream) || ferror(stream)) return EOF;
+	if (feof(stream) || ferror(stream))
+		return EOF;
 	return w;
 }
diff --git a/lang/cem/libcc.ansi/misc/mktemp.c b/lang/cem/libcc.ansi/misc/mktemp.c
index 695dad4e1..a5b789050 100644
--- a/lang/cem/libcc.ansi/misc/mktemp.c
+++ b/lang/cem/libcc.ansi/misc/mktemp.c
@@ -3,28 +3,32 @@
 /* no _-protected system-calls? */
 
 unsigned int getpid(void);
-int access(char *, int);
+int access(char*, int);
 
-char *mktemp(char *template)
+char* mktemp(char* template)
 {
-  register int pid, k;
-  register char *p;
+	register int pid, k;
+	register char* p;
 
-  pid = getpid();		/* get process id as semi-unique number */
-  p = template;
-  while (*p) p++;		/* find end of string */
+	pid = getpid(); /* get process id as semi-unique number */
+	p = template;
+	while (*p)
+		p++; /* find end of string */
 
-  /* Replace XXXXXX at end of template with pid. */
-  while (*--p == 'X') {
-	*p = '0' + (pid % 10);
-	pid /= 10;
-  }
-  p++;
-  for (k = 'a'; k <= 'z'; k++) {
-	*p = k;
-	if (access(template, 0) < 0) {
-		return template;
+	/* Replace XXXXXX at end of template with pid. */
+	while (*--p == 'X')
+	{
+		*p = '0' + (pid % 10);
+		pid /= 10;
 	}
-  }
-  return("/");
+	p++;
+	for (k = 'a'; k <= 'z'; k++)
+	{
+		*p = k;
+		if (access(template, 0) < 0)
+		{
+			return template;
+		}
+	}
+	return ("/");
 }
diff --git a/lang/cem/libcc.ansi/misc/opendir.c b/lang/cem/libcc.ansi/misc/opendir.c
index 7e3842055..b7b3472d0 100644
--- a/lang/cem/libcc.ansi/misc/opendir.c
+++ b/lang/cem/libcc.ansi/misc/opendir.c
@@ -4,64 +4,63 @@
 	last edit:	16-Jun-1987	D A Gwyn
 */
 
-#include	<errno.h>
-#include	<stdlib.h>
-#include	<sys/errno.h>
-#include	<sys/types.h>
-#include	<sys/stat.h>
-#include	<dirent.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <sys/errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
 
-typedef void	*pointer;		/* (void *) if you have it */
+typedef void* pointer; /* (void *) if you have it */
 
-extern int _open(const char *path, int flags, int mode);
+extern int _open(const char* path, int flags, int mode);
 extern int _close(int d);
-extern int _fstat(int fd, struct stat *buf);
+extern int _fstat(int fd, struct stat* buf);
 
 #ifndef NULL
-#define	NULL	0
+#define NULL 0
 #endif
 
 #ifndef O_RDONLY
-#define	O_RDONLY	0
+#define O_RDONLY 0
 #endif
 
-#ifndef S_ISDIR				/* macro to test for directory file */
-#define	S_ISDIR( mode )		(((mode) & S_IFMT) == S_IFDIR)
+#ifndef S_ISDIR /* macro to test for directory file */
+#define S_ISDIR(mode) (((mode)&S_IFMT) == S_IFDIR)
 #endif
 
-DIR *
-opendir(const char *dirname)		/* name of directory */
+DIR* opendir(const char* dirname) /* name of directory */
 {
-	register DIR	*dirp;		/* -> malloc'ed storage */
-	register int	fd;		/* file descriptor for read */
-	struct stat	sbuf;		/* result of fstat() */
+	register DIR* dirp; /* -> malloc'ed storage */
+	register int fd; /* file descriptor for read */
+	struct stat sbuf; /* result of fstat() */
 
-	if ( (fd = _open( dirname, O_RDONLY, 0 )) < 0 )
-		return NULL;		/* errno set by open() */
+	if ((fd = _open(dirname, O_RDONLY, 0)) < 0)
+		return NULL; /* errno set by open() */
 
-	if ( _fstat( fd, &sbuf ) != 0 || !S_ISDIR( sbuf.st_mode ) )
-		{
-		(void)_close( fd );
+	if (_fstat(fd, &sbuf) != 0 || !S_ISDIR(sbuf.st_mode))
+	{
+		(void)_close(fd);
 		errno = ENOTDIR;
-		return NULL;		/* not a directory */
-		}
+		return NULL; /* not a directory */
+	}
 
-	if ( (dirp = (DIR *)malloc( sizeof(DIR) )) == NULL
-	  || (dirp->dd_buf = (char *)malloc( (unsigned)DIRBUF )) == NULL
-	   )	{
-		register int	serrno = errno;
-					/* errno set to ENOMEM by sbrk() */
+	if ((dirp = (DIR*)malloc(sizeof(DIR))) == NULL
+	    || (dirp->dd_buf = (char*)malloc((unsigned)DIRBUF)) == NULL)
+	{
+		register int serrno = errno;
+		/* errno set to ENOMEM by sbrk() */
 
-		if ( dirp != NULL )
-			free( (pointer)dirp );
+		if (dirp != NULL)
+			free((pointer)dirp);
 
-		(void)_close( fd );
+		(void)_close(fd);
 		errno = serrno;
-		return NULL;		/* not enough memory */
-		}
+		return NULL; /* not enough memory */
+	}
 
 	dirp->dd_fd = fd;
-	dirp->dd_loc = dirp->dd_size = 0;	/* refill needed */
+	dirp->dd_loc = dirp->dd_size = 0; /* refill needed */
 
 	return dirp;
 }
diff --git a/lang/cem/libcc.ansi/misc/popen.c b/lang/cem/libcc.ansi/misc/popen.c
index b0dd8d400..b3352e9ad 100644
--- a/lang/cem/libcc.ansi/misc/popen.c
+++ b/lang/cem/libcc.ansi/misc/popen.c
@@ -3,55 +3,57 @@
  */
 /* $Id$ */
 
-#include	<errno.h>
-#include	<stdio.h>
-#include	<signal.h>
-#if	defined(__BSD4_2)
+#include <errno.h>
+#include <stdio.h>
+#include <signal.h>
+#if defined(__BSD4_2)
 union wait {
-	int	w_status;
+	int w_status;
 };
 typedef union wait wait_arg;
 #else
 typedef int wait_arg;
-#endif	/* __BSD4_2 */
-#include	"../stdio/loc_incl.h"
+#endif /* __BSD4_2 */
+#include "../stdio/loc_incl.h"
 
 int _close(int d);
 #if defined(__USG)
 static
 #endif
-int _dup2(int oldd, int newd);		/* not present in System 5 */
-int _execl(const char *name, ... );
+    int
+    _dup2(int oldd, int newd); /* not present in System 5 */
+int _execl(const char* name, ...);
 int _fork(void);
 int _pipe(int fildes[2]);
-int _wait(wait_arg *status);
+int _wait(wait_arg* status);
 void _exit(int status);
 
 static int pids[FOPEN_MAX];
 
-FILE *
-popen(const char *command, const char *type)
+FILE* popen(const char* command, const char* type)
 {
 	int piped[2];
 	int Xtype = *type == 'r' ? 0 : *type == 'w' ? 1 : 2;
 	int pid;
 
-	if (Xtype == 2 ||
-	    _pipe(piped) < 0 ||
-	    (pid = _fork()) < 0) return 0;
-	
-	if (pid == 0) {
-		/* child */
-		register int *p;
+	if (Xtype == 2 || _pipe(piped) < 0 || (pid = _fork()) < 0)
+		return 0;
 
-		for (p = pids; p < &pids[ FOPEN_MAX]; p++) {
-			if (*p) _close(p - pids);
+	if (pid == 0)
+	{
+		/* child */
+		register int* p;
+
+		for (p = pids; p < &pids[FOPEN_MAX]; p++)
+		{
+			if (*p)
+				_close(p - pids);
 		}
 		_close(piped[Xtype]);
 		_dup2(piped[!Xtype], !Xtype);
 		_close(piped[!Xtype]);
-		_execl("/bin/sh", "sh", "-c", command, (char *) 0);
-		_exit(127);	/* like system() ??? */
+		_execl("/bin/sh", "sh", "-c", command, (char*)0);
+		_exit(127); /* like system() ??? */
 	}
 
 	pids[piped[Xtype]] = pid;
@@ -59,14 +61,13 @@ popen(const char *command, const char *type)
 	return fdopen(piped[Xtype], type);
 }
 
-#if	defined(__BSD4_2)
-#define	ret_val	status.w_status
+#if defined(__BSD4_2)
+#define ret_val status.w_status
 #else
-#define	ret_val	status
+#define ret_val status
 #endif
 
-int
-pclose(FILE *stream)
+int pclose(FILE* stream)
 {
 	int fd = fileno(stream);
 	wait_arg status;
@@ -75,17 +76,20 @@ pclose(FILE *stream)
 	void (*quitsave)(int) = signal(SIGQUIT, SIG_IGN);
 
 	fclose(stream);
-	while ((wret = _wait(&status)) != -1) {
-		if (wret == pids[fd]) break;
+	while ((wret = _wait(&status)) != -1)
+	{
+		if (wret == pids[fd])
+			break;
 	}
-	if (wret == -1) ret_val = -1;
+	if (wret == -1)
+		ret_val = -1;
 	signal(SIGINT, intsave);
 	signal(SIGQUIT, quitsave);
 	pids[fd] = 0;
 	return ret_val;
 }
 
-#if	defined(__USG)
+#if defined(__USG)
 int _dup(int fildes);
 
 static int
@@ -95,16 +99,21 @@ _dup2(int oldd, int newd)
 	int fdbuf[FOPEN_MAX];
 
 	/* ignore the error on the close() */
-	tmp = errno; (void) _close(newd); errno = tmp;
-	while ((fd = _dup(oldd)) != newd) {
-		if (fd == -1) break;
+	tmp = errno;
+	(void)_close(newd);
+	errno = tmp;
+	while ((fd = _dup(oldd)) != newd)
+	{
+		if (fd == -1)
+			break;
 		fdbuf[i++] = fd;
 	}
 	tmp = errno;
-	while (--i >= 0) {
+	while (--i >= 0)
+	{
 		_close(fdbuf[i]);
 	}
 	errno = tmp;
 	return -(fd == -1);
 }
-#endif	/* __USG */
+#endif /* __USG */
diff --git a/lang/cem/libcc.ansi/misc/putw.c b/lang/cem/libcc.ansi/misc/putw.c
index a195a2d32..d5c137df2 100644
--- a/lang/cem/libcc.ansi/misc/putw.c
+++ b/lang/cem/libcc.ansi/misc/putw.c
@@ -3,17 +3,18 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
+#include <stdio.h>
 
-int
-putw(int w, register FILE *stream)
+int putw(int w, register FILE* stream)
 {
 	register int cnt = sizeof(int);
-	register char *p = (char *) &w;
+	register char* p = (char*)&w;
 
-	while (cnt--) {
+	while (cnt--)
+	{
 		putc(*p++, stream);
 	}
-	if (ferror(stream)) return EOF;
+	if (ferror(stream))
+		return EOF;
 	return w;
 }
diff --git a/lang/cem/libcc.ansi/misc/readdir.c b/lang/cem/libcc.ansi/misc/readdir.c
index 2497e4673..ac1d800b1 100644
--- a/lang/cem/libcc.ansi/misc/readdir.c
+++ b/lang/cem/libcc.ansi/misc/readdir.c
@@ -4,44 +4,41 @@
 	last edit:	25-Apr-1987	D A Gwyn
 */
 
-#include	<errno.h>
-#include	<sys/errno.h>
-#include	<sys/types.h>
-#include	<dirent.h>
+#include <errno.h>
+#include <sys/errno.h>
+#include <sys/types.h>
+#include <dirent.h>
 
 /* SVR3 system call, or emulation for getdents() */
-extern int getdents(int fildes, char *buf, unsigned nbyte);
+extern int getdents(int fildes, char* buf, unsigned nbyte);
 
 #ifndef NULL
-#define	NULL	0
+#define NULL 0
 #endif
 
-struct dirent *
-readdir(register DIR *dirp)
+struct dirent*
+readdir(register DIR* dirp)
 {
-	register struct dirent	*dp;	/* -> directory data */
+	register struct dirent* dp; /* -> directory data */
 
-	if ( dirp == NULL || dirp->dd_buf == NULL )
-		{
+	if (dirp == NULL || dirp->dd_buf == NULL)
+	{
 		errno = EFAULT;
-		return NULL;		/* invalid pointer */
-		}
+		return NULL; /* invalid pointer */
+	}
 
-	do	{
-		if ( dirp->dd_loc >= dirp->dd_size )	/* empty or obsolete */
+	do
+	{
+		if (dirp->dd_loc >= dirp->dd_size) /* empty or obsolete */
 			dirp->dd_loc = dirp->dd_size = 0;
 
-		if ( dirp->dd_size == 0	/* need to refill buffer */
-		  && (dirp->dd_size =
-			getdents( dirp->dd_fd, dirp->dd_buf, (unsigned)DIRBUF )
-		     ) <= 0
-		   )
-			return NULL;	/* EOF or error */
+		if (dirp->dd_size == 0 /* need to refill buffer */
+		    && (dirp->dd_size = getdents(dirp->dd_fd, dirp->dd_buf, (unsigned)DIRBUF)) <= 0)
+			return NULL; /* EOF or error */
 
-		dp = (struct dirent *)&dirp->dd_buf[dirp->dd_loc];
+		dp = (struct dirent*)&dirp->dd_buf[dirp->dd_loc];
 		dirp->dd_loc += dp->d_reclen;
-		}
-	while ( dp->d_ino == 0L );	/* don't rely on getdents() */
+	} while (dp->d_ino == 0L); /* don't rely on getdents() */
 
 	return dp;
 }
diff --git a/lang/cem/libcc.ansi/misc/rewinddir.c b/lang/cem/libcc.ansi/misc/rewinddir.c
index 6186153cd..e8c9e4749 100644
--- a/lang/cem/libcc.ansi/misc/rewinddir.c
+++ b/lang/cem/libcc.ansi/misc/rewinddir.c
@@ -8,30 +8,29 @@
 	rewinddir() to forget about buffered data.
 */
 
-#include	<errno.h>
-#include	<sys/errno.h>
-#include	<sys/types.h>
-#include	<dirent.h>
+#include <errno.h>
+#include <sys/errno.h>
+#include <sys/types.h>
+#include <dirent.h>
 
-extern off_t	_lseek(int d, int offset, int whence);
+extern off_t _lseek(int d, int offset, int whence);
 
 #ifndef NULL
-#define	NULL	0
+#define NULL 0
 #endif
 
 #ifndef SEEK_SET
-#define	SEEK_SET	0
+#define SEEK_SET 0
 #endif
 
-void
-rewinddir(register DIR *dirp)
+void rewinddir(register DIR* dirp)
 {
-	if ( dirp == NULL || dirp->dd_buf == NULL )
-		{
+	if (dirp == NULL || dirp->dd_buf == NULL)
+	{
 		errno = EFAULT;
-		return;			/* invalid pointer */
-		}
+		return; /* invalid pointer */
+	}
 
-	dirp->dd_loc = dirp->dd_size = 0;	/* invalidate buffer */
-	(void)_lseek( dirp->dd_fd, (off_t)0, SEEK_SET );	/* may set errno */
+	dirp->dd_loc = dirp->dd_size = 0; /* invalidate buffer */
+	(void)_lseek(dirp->dd_fd, (off_t)0, SEEK_SET); /* may set errno */
 }
diff --git a/lang/cem/libcc.ansi/misc/seekdir.c b/lang/cem/libcc.ansi/misc/seekdir.c
index b162a3346..c53629292 100644
--- a/lang/cem/libcc.ansi/misc/seekdir.c
+++ b/lang/cem/libcc.ansi/misc/seekdir.c
@@ -10,36 +10,35 @@
 		practically impossible to do right.  Avoid using them!
 */
 
-#include	<errno.h>
-#include	<sys/errno.h>
-#include	<sys/types.h>
-#include	<dirent.h>
+#include <errno.h>
+#include <sys/errno.h>
+#include <sys/types.h>
+#include <dirent.h>
 
 extern off_t _lseek(int d, int offset, int whence);
 
 #ifndef NULL
-#define	NULL	0
+#define NULL 0
 #endif
 
 #ifndef SEEK_SET
-#define	SEEK_SET	0
+#define SEEK_SET 0
 #endif
 
-typedef int	bool;			/* Boolean data type */
-#define	false	0
-#define	true	1
+typedef int bool; /* Boolean data type */
+#define false 0
+#define true 1
 
-void
-seekdir(register DIR *dirp, register off_t loc)
+void seekdir(register DIR* dirp, register off_t loc)
 /* loc == position from telldir() */
 {
-	register bool	rewind;		/* "start over when stymied" flag */
+	register bool rewind; /* "start over when stymied" flag */
 
-	if ( dirp == NULL || dirp->dd_buf == NULL )
-		{
+	if (dirp == NULL || dirp->dd_buf == NULL)
+	{
 		errno = EFAULT;
-		return;			/* invalid pointer */
-		}
+		return; /* invalid pointer */
+	}
 
 	/* A (struct dirent)'s d_off is an invented quantity on 4.nBSD
 	   NFS-supporting systems, so it is not safe to lseek() to it. */
@@ -52,58 +51,57 @@ seekdir(register DIR *dirp, register off_t loc)
 	   or even to use binary search on the directory blocks.  I
 	   doubt that the extra code for that would be worthwhile. */
 
-	if ( dirp->dd_loc >= dirp->dd_size	/* invalid index */
-	  || ((struct dirent *)&dirp->dd_buf[dirp->dd_loc])->d_off > loc
-					/* too far along in buffer */
-	   )
-		dirp->dd_loc = 0;	/* reset to beginning of buffer */
+	if (dirp->dd_loc >= dirp->dd_size /* invalid index */
+	    || ((struct dirent*)&dirp->dd_buf[dirp->dd_loc])->d_off > loc
+	    /* too far along in buffer */
+	    )
+		dirp->dd_loc = 0; /* reset to beginning of buffer */
 	/* else save time by starting at current dirp->dd_loc */
 
-	for ( rewind = true; ; )
-		{
-		register struct dirent	*dp;
+	for (rewind = true;;)
+	{
+		register struct dirent* dp;
 
 		/* See whether the matching entry is in the current buffer. */
 
-		if ( (dirp->dd_loc < dirp->dd_size	/* valid index */
-		   || readdir( dirp ) != NULL	/* next buffer read */
-		   && (dirp->dd_loc = 0, true)	/* beginning of buffer set */
-		     )
-		  && (dp = (struct dirent *)&dirp->dd_buf[dirp->dd_loc])->d_off
-			<= loc		/* match possible in this buffer */
-		   )	{
-			for ( /* dp initialized above */ ;
-			      (char *)dp < &dirp->dd_buf[dirp->dd_size];
-			      dp = (struct dirent *)((char *)dp + dp->d_reclen)
-			    )
-				if ( dp->d_off == loc )
-					{	/* found it! */
-					dirp->dd_loc =
-						(char *)dp - dirp->dd_buf;
+		if ((dirp->dd_loc < dirp->dd_size /* valid index */
+		        || readdir(dirp) != NULL /* next buffer read */
+		            && (dirp->dd_loc = 0, true) /* beginning of buffer set */
+		        )
+		    && (dp = (struct dirent*)&dirp->dd_buf[dirp->dd_loc])->d_off
+		        <= loc /* match possible in this buffer */
+		    )
+		{
+			for (/* dp initialized above */;
+			     (char*)dp < &dirp->dd_buf[dirp->dd_size];
+			     dp = (struct dirent*)((char*)dp + dp->d_reclen))
+				if (dp->d_off == loc)
+				{ /* found it! */
+					dirp->dd_loc = (char*)dp - dirp->dd_buf;
 					return;
-					}
-
-			rewind = false;	/* no point in backing up later */
-			dirp->dd_loc = dirp->dd_size;	/* set end of buffer */
-			}
-		else			/* whole buffer past matching entry */
-			if ( !rewind )
-				{	/* no point in searching further */
-				errno = EINVAL;
-				return;	/* no entry at specified loc */
 				}
-			else	{	/* rewind directory and start over */
-				rewind = false;	/* but only once! */
 
-				dirp->dd_loc = dirp->dd_size = 0;
-
-				if ( _lseek( dirp->dd_fd, (off_t)0, SEEK_SET )
-					!= 0
-				   )
-					return;	/* errno already set (EBADF) */
-
-				if ( loc == 0 )
-					return; /* save time */
-				}
+			rewind = false; /* no point in backing up later */
+			dirp->dd_loc = dirp->dd_size; /* set end of buffer */
 		}
+		else /* whole buffer past matching entry */
+		    if (!rewind)
+		{ /* no point in searching further */
+			errno = EINVAL;
+			return; /* no entry at specified loc */
+		}
+		else
+		{ /* rewind directory and start over */
+			rewind = false; /* but only once! */
+
+			dirp->dd_loc = dirp->dd_size = 0;
+
+			if (_lseek(dirp->dd_fd, (off_t)0, SEEK_SET)
+			    != 0)
+				return; /* errno already set (EBADF) */
+
+			if (loc == 0)
+				return; /* save time */
+		}
+	}
 }
diff --git a/lang/cem/libcc.ansi/misc/sleep.c b/lang/cem/libcc.ansi/misc/sleep.c
index 4bc8f2d57..1b7c9a8d7 100644
--- a/lang/cem/libcc.ansi/misc/sleep.c
+++ b/lang/cem/libcc.ansi/misc/sleep.c
@@ -3,44 +3,48 @@
  */
 /* $Id$ */
 
-#include	<signal.h>
-#include	<setjmp.h>
+#include <signal.h>
+#include <setjmp.h>
 
 int _alarm(int n);
 void _pause(void);
 
-static jmp_buf	setjmpbuf;
+static jmp_buf setjmpbuf;
 
 static void
 alfun(int sig)
 {
 	longjmp(setjmpbuf, 1);
-}		/* used with sleep() below */
+} /* used with sleep() below */
 
-void
-sleep(int n)
+void sleep(int n)
 {
-/* sleep(n) pauses for 'n' seconds by scheduling an alarm interrupt. */
+	/* sleep(n) pauses for 'n' seconds by scheduling an alarm interrupt. */
 	unsigned oldalarm = 0;
 	void (*oldsig)(int) = 0;
 
-	if (n <= 0) return;
-	if (setjmp(setjmpbuf)) {
+	if (n <= 0)
+		return;
+	if (setjmp(setjmpbuf))
+	{
 		signal(SIGALRM, oldsig);
 		_alarm(oldalarm);
 		return;
 	}
-	oldalarm = _alarm(5000);	/* Who cares how long, as long
+	oldalarm = _alarm(5000); /* Who cares how long, as long
 					 * as it is long enough
 					 */
-	if (oldalarm > n) oldalarm -= n;
-	else if (oldalarm) {
+	if (oldalarm > n)
+		oldalarm -= n;
+	else if (oldalarm)
+	{
 		n = oldalarm;
 		oldalarm = 1;
 	}
 	oldsig = signal(SIGALRM, alfun);
 	_alarm(n);
-	for (;;)  {
+	for (;;)
+	{
 		/* allow for other handlers ... */
 		_pause();
 	}
diff --git a/lang/cem/libcc.ansi/misc/telldir.c b/lang/cem/libcc.ansi/misc/telldir.c
index d96d78c62..9db00740a 100644
--- a/lang/cem/libcc.ansi/misc/telldir.c
+++ b/lang/cem/libcc.ansi/misc/telldir.c
@@ -7,28 +7,27 @@
 		practically impossible to do right.  Avoid using them!
 */
 
-#include	<errno.h>
-#include	<sys/errno.h>
-#include	<sys/types.h>
-#include	<dirent.h>
+#include <errno.h>
+#include <sys/errno.h>
+#include <sys/types.h>
+#include <dirent.h>
 
 extern off_t _lseek(int d, int offset, int whence);
 
 #ifndef SEEK_CUR
-#define	SEEK_CUR	1
+#define SEEK_CUR 1
 #endif
 
-off_t
-telldir(register DIR *dirp)		/* return offset of next entry */
+off_t telldir(register DIR* dirp) /* return offset of next entry */
 {
-	if ( dirp == NULL || dirp->dd_buf == NULL )
-		{
+	if (dirp == NULL || dirp->dd_buf == NULL)
+	{
 		errno = EFAULT;
-		return -1;		/* invalid pointer */
-		}
+		return -1; /* invalid pointer */
+	}
 
-	if ( dirp->dd_loc < dirp->dd_size )	/* valid index */
-		return ((struct dirent *)&dirp->dd_buf[dirp->dd_loc])->d_off;
-	else				/* beginning of next directory block */
-		return _lseek( dirp->dd_fd, (off_t)0, SEEK_CUR );
+	if (dirp->dd_loc < dirp->dd_size) /* valid index */
+		return ((struct dirent*)&dirp->dd_buf[dirp->dd_loc])->d_off;
+	else /* beginning of next directory block */
+		return _lseek(dirp->dd_fd, (off_t)0, SEEK_CUR);
 }
diff --git a/lang/cem/libcc.ansi/setjmp/sigmisc.c b/lang/cem/libcc.ansi/setjmp/sigmisc.c
index 3c807e126..d9c58d092 100644
--- a/lang/cem/libcc.ansi/setjmp/sigmisc.c
+++ b/lang/cem/libcc.ansi/setjmp/sigmisc.c
@@ -3,37 +3,38 @@
  */
 /* $Id$ */
 
-#if	defined(_POSIX_SOURCE)
+#if defined(_POSIX_SOURCE)
 
 /* This can't be done in setjmp.e, since SIG_SETMASK is defined in
  * <signal.h>. This is a C-file, which can't be included.
  */
 
-#include	<sys/types.h>
-#include	<signal.h>
-#include	<stddef.h>
+#include <sys/types.h>
+#include <signal.h>
+#include <stddef.h>
 
-int _sigprocmask(int, sigset_t *, sigset_t *);
+int _sigprocmask(int, sigset_t*, sigset_t*);
 
 static void
-__testsigset(void) {
+__testsigset(void)
+{
 	/* This switch compiles when a sigset_t has the right size. */
-	switch(0) {
-	case 0: 
-	case sizeof(sigset_t) <= sizeof(long): break;
+	switch (0)
+	{
+		case 0:
+		case sizeof(sigset_t) <= sizeof(long):
+			break;
 	}
 }
 
-void
-__newsigset(sigset_t *p)
+void __newsigset(sigset_t* p)
 {
 	/* The SIG_SETMASK is not significant */
 	_sigprocmask(SIG_SETMASK, NULL, p);
 }
 
-void
-__oldsigset(sigset_t *p)
+void __oldsigset(sigset_t* p)
 {
 	_sigprocmask(SIG_SETMASK, p, NULL);
 }
-#endif	/* _POSIX_SOURCE */
+#endif /* _POSIX_SOURCE */
diff --git a/lang/cem/libcc.ansi/signal/raise.c b/lang/cem/libcc.ansi/signal/raise.c
index 42b3b4cec..e1aedaa01 100644
--- a/lang/cem/libcc.ansi/signal/raise.c
+++ b/lang/cem/libcc.ansi/signal/raise.c
@@ -4,13 +4,12 @@
  */
 /* $Id$ */
 
-#if	defined(_POSIX_SOURCE)
+#if defined(_POSIX_SOURCE)
 #include <sys/types.h>
 #endif
 #include <signal.h>
 
-int
-raise(int sig)
+int raise(int sig)
 {
 	if (sig < 0 || sig > _NSIG)
 		return -1;
diff --git a/lang/cem/libcc.ansi/stdio/clearerr.c b/lang/cem/libcc.ansi/stdio/clearerr.c
index 3455229a2..8bfaaca79 100644
--- a/lang/cem/libcc.ansi/stdio/clearerr.c
+++ b/lang/cem/libcc.ansi/stdio/clearerr.c
@@ -3,10 +3,9 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
+#include <stdio.h>
 
-void
-(clearerr)(FILE *stream)
+void(clearerr)(FILE* stream)
 {
 	clearerr(stream);
 }
diff --git a/lang/cem/libcc.ansi/stdio/data.c b/lang/cem/libcc.ansi/stdio/data.c
index 92be83b11..debff7771 100644
--- a/lang/cem/libcc.ansi/stdio/data.c
+++ b/lang/cem/libcc.ansi/stdio/data.c
@@ -3,24 +3,24 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
+#include <stdio.h>
 
 struct __iobuf __stdin = {
 	0, 0, _IOREAD, 0,
-	(unsigned char *)NULL, (unsigned char *)NULL, 
+	(unsigned char*)NULL, (unsigned char*)NULL,
 };
 
 struct __iobuf __stdout = {
 	0, 1, _IOWRITE, 0,
-	(unsigned char *)NULL, (unsigned char *)NULL, 
+	(unsigned char*)NULL, (unsigned char*)NULL,
 };
 
 struct __iobuf __stderr = {
 	0, 2, _IOWRITE | _IOLBF, 0,
-	(unsigned char *)NULL, (unsigned char *)NULL, 
+	(unsigned char*)NULL, (unsigned char*)NULL,
 };
 
-FILE *__iotab[FOPEN_MAX] = {
+FILE* __iotab[FOPEN_MAX] = {
 	&__stdin,
 	&__stdout,
 	&__stderr,
diff --git a/lang/cem/libcc.ansi/stdio/doprnt.c b/lang/cem/libcc.ansi/stdio/doprnt.c
index 395c45704..dca935aad 100644
--- a/lang/cem/libcc.ansi/stdio/doprnt.c
+++ b/lang/cem/libcc.ansi/stdio/doprnt.c
@@ -3,25 +3,29 @@
  */
 /* $Id$ */
 
-#include	<ctype.h>
-#include	<stdio.h>
-#include	<stdarg.h>
-#include	<string.h>
-#include	"loc_incl.h"
+#include <ctype.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include "loc_incl.h"
 
 /* gnum() is used to get the width and precision fields of a format. */
-static const char *
-gnum(register const char *f, int *ip, va_list *app)
+static const char*
+gnum(register const char* f, int* ip, va_list* app)
 {
-	register int	i, c;
+	register int i, c;
 
-	if (*f == '*') {
+	if (*f == '*')
+	{
 		*ip = va_arg((*app), int);
 		f++;
-	} else {
+	}
+	else
+	{
 		i = 0;
-		while ((c = *f - '0') >= 0 && c <= 9) {
-			i = i*10 + c;
+		while ((c = *f - '0') >= 0 && c <= 9)
+		{
+			i = i * 10 + c;
 			f++;
 		}
 		*ip = i;
@@ -29,91 +33,121 @@ gnum(register const char *f, int *ip, va_list *app)
 	return f;
 }
 
-#if	_EM_WSIZE == _EM_PSIZE
-#define set_pointer(flags)				/* nothing */
-#elif	_EM_LSIZE == _EM_PSIZE
-#define set_pointer(flags)	(flags |= FL_LONG)
+#if _EM_WSIZE == _EM_PSIZE
+#define set_pointer(flags) /* nothing */
+#elif _EM_LSIZE == _EM_PSIZE
+#define set_pointer(flags) (flags |= FL_LONG)
 #else
 #error garbage pointer size
-#define set_pointer(flags)		/* compilation might continue */
+#define set_pointer(flags) /* compilation might continue */
 #endif
 
-#define PUTC(c) \
-	do { \
+#define PUTC(c)                  \
+	do                           \
+	{                            \
 		int i = putc(c, stream); \
-		if (i == EOF) \
-		{ \
-			if (ferror(stream)) \
-				return -1; \
-		} \
+		if (i == EOF)            \
+		{                        \
+			if (ferror(stream))  \
+				return -1;       \
+		}                        \
 	} while (0)
 
 /* print an ordinal number */
-static char *
-o_print(va_list *ap, int flags, char *s, char c, int precision, int is_signed)
+static char*
+o_print(va_list* ap, int flags, char* s, char c, int precision, int is_signed)
 {
 	long signed_val;
 	unsigned long unsigned_val;
-	char *old_s = s;
+	char* old_s = s;
 	int base;
 
-	switch (flags & (FL_SHORT | FL_LONG)) {
-	case FL_SHORT:
-		if (is_signed) {
-			signed_val = (short) va_arg(*ap, int);
-		} else {
-			unsigned_val = (unsigned short) va_arg(*ap, unsigned);
-		}
-		break;
-	case FL_LONG:
-		if (is_signed) {
-			signed_val = va_arg(*ap, long);
-		} else {
-			unsigned_val = va_arg(*ap, unsigned long);
-		}
-		break;
-	default:
-		if (is_signed) {
-			signed_val = va_arg(*ap, int);
-		} else {
-			unsigned_val = va_arg(*ap, unsigned int);
-		}
-		break;
+	switch (flags & (FL_SHORT | FL_LONG))
+	{
+		case FL_SHORT:
+			if (is_signed)
+			{
+				signed_val = (short)va_arg(*ap, int);
+			}
+			else
+			{
+				unsigned_val = (unsigned short)va_arg(*ap, unsigned);
+			}
+			break;
+		case FL_LONG:
+			if (is_signed)
+			{
+				signed_val = va_arg(*ap, long);
+			}
+			else
+			{
+				unsigned_val = va_arg(*ap, unsigned long);
+			}
+			break;
+		default:
+			if (is_signed)
+			{
+				signed_val = va_arg(*ap, int);
+			}
+			else
+			{
+				unsigned_val = va_arg(*ap, unsigned int);
+			}
+			break;
 	}
 
-	if (is_signed) {
-		if (signed_val < 0) {
+	if (is_signed)
+	{
+		if (signed_val < 0)
+		{
 			*s++ = '-';
 			signed_val = -signed_val;
-		} else if (flags & FL_SIGN) *s++ = '+';
-		else if (flags & FL_SPACE) *s++ = ' ';
+		}
+		else if (flags & FL_SIGN)
+			*s++ = '+';
+		else if (flags & FL_SPACE)
+			*s++ = ' ';
 		unsigned_val = signed_val;
 	}
-	if ((flags & FL_ALT) && (c == 'o')) *s++ = '0';
-	if (!unsigned_val) {
-		 if (!precision)
+	if ((flags & FL_ALT) && (c == 'o'))
+		*s++ = '0';
+	if (!unsigned_val)
+	{
+		if (!precision)
 			return s;
-	} else if (((flags & FL_ALT) && (c == 'x' || c == 'X'))
-		    || c == 'p') {
+	}
+	else if (((flags & FL_ALT) && (c == 'x' || c == 'X'))
+	    || c == 'p')
+	{
 		*s++ = '0';
 		*s++ = (c == 'X' ? 'X' : 'x');
 	}
 
-	switch (c) {
-	case 'b':	base = 2;	break;
-	case 'o':	base = 8;	break;
-	case 'd':
-	case 'i':
-	case 'u':	base = 10;	break;
-	case 'x':
-	case 'X':
-	case 'p':	base = 16;	break;
+	switch (c)
+	{
+		case 'b':
+			base = 2;
+			break;
+		case 'o':
+			base = 8;
+			break;
+		case 'd':
+		case 'i':
+		case 'u':
+			base = 10;
+			break;
+		case 'x':
+		case 'X':
+		case 'p':
+			base = 16;
+			break;
 	}
 
 	s = _i_compute(unsigned_val, base, s, precision);
 
 	if (c == 'X')
-		while (old_s != s) {
+		while (old_s != s)
+		{
 			*old_s = toupper(*old_s);
 			old_s++;
 		}
@@ -121,20 +155,22 @@ o_print(va_list *ap, int flags, char *s, char c, int precision, int is_signed)
 	return s;
 }
 
-int
-_doprnt(register const char *fmt, va_list ap, FILE *stream)
+int _doprnt(register const char* fmt, va_list ap, FILE* stream)
 {
-	register char	*s;
-	register int	j;
-	int		i, c, width, precision, zfill, flags, between_fill;
-	int		nrchars=0;
-	const char	*oldfmt;
-	char		*s1, buf[1025];
+	register char* s;
+	register int j;
+	int i, c, width, precision, zfill, flags, between_fill;
+	int nrchars = 0;
+	const char* oldfmt;
+	char *s1, buf[1025];
 
-	while (c = *fmt++) {
-		if (c != '%') {
-#ifdef	CPM
-			if (c == '\n') {
+	while (c = *fmt++)
+	{
+		if (c != '%')
+		{
+#ifdef CPM
+			if (c == '\n')
+			{
 				PUTC('\r');
 			}
 #endif
@@ -143,125 +179,164 @@ _doprnt(register const char *fmt, va_list ap, FILE *stream)
 			continue;
 		}
 		flags = 0;
-		do {
-			switch(*fmt) {
-			case '-':	flags |= FL_LJUST;	break;
-			case '+':	flags |= FL_SIGN;	break;
-			case ' ':	flags |= FL_SPACE;	break;
-			case '#':	flags |= FL_ALT;	break;
-			case '0':	flags |= FL_ZEROFILL;	break;
-			default:	flags |= FL_NOMORE;	continue;
+		do
+		{
+			switch (*fmt)
+			{
+				case '-':
+					flags |= FL_LJUST;
+					break;
+				case '+':
+					flags |= FL_SIGN;
+					break;
+				case ' ':
+					flags |= FL_SPACE;
+					break;
+				case '#':
+					flags |= FL_ALT;
+					break;
+				case '0':
+					flags |= FL_ZEROFILL;
+					break;
+				default:
+					flags |= FL_NOMORE;
+					continue;
 			}
 			fmt++;
-		} while(!(flags & FL_NOMORE));
+		} while (!(flags & FL_NOMORE));
 
 		oldfmt = fmt;
 		fmt = gnum(fmt, &width, &ap);
-		if (fmt != oldfmt) flags |= FL_WIDTHSPEC;
+		if (fmt != oldfmt)
+			flags |= FL_WIDTHSPEC;
 
-		if (*fmt == '.') {
-			fmt++; oldfmt = fmt;
+		if (*fmt == '.')
+		{
+			fmt++;
+			oldfmt = fmt;
 			fmt = gnum(fmt, &precision, &ap);
-			if (precision >= 0) flags |= FL_PRECSPEC;
+			if (precision >= 0)
+				flags |= FL_PRECSPEC;
 		}
 
-		if ((flags & FL_WIDTHSPEC) && width < 0) {
+		if ((flags & FL_WIDTHSPEC) && width < 0)
+		{
 			width = -width;
 			flags |= FL_LJUST;
 		}
-		if (!(flags & FL_WIDTHSPEC)) width = 0;
+		if (!(flags & FL_WIDTHSPEC))
+			width = 0;
 
-		if (flags & FL_SIGN) flags &= ~FL_SPACE;
-
-		if (flags & FL_LJUST) flags &= ~FL_ZEROFILL;
+		if (flags & FL_SIGN)
+			flags &= ~FL_SPACE;
 
+		if (flags & FL_LJUST)
+			flags &= ~FL_ZEROFILL;
 
 		s = s1 = buf;
 
-		switch (*fmt) {
-		case 'h':	flags |= FL_SHORT; fmt++; break;
-		case 'l':	flags |= FL_LONG; fmt++; break;
-		case 'L':	flags |= FL_LONGDOUBLE; fmt++; break;
+		switch (*fmt)
+		{
+			case 'h':
+				flags |= FL_SHORT;
+				fmt++;
+				break;
+			case 'l':
+				flags |= FL_LONG;
+				fmt++;
+				break;
+			case 'L':
+				flags |= FL_LONGDOUBLE;
+				fmt++;
+				break;
 		}
 
-		switch (c = *fmt++) {
-		default:
-#ifdef	CPM
-			if (c == '\n') {
-				PUTC('\r');
-				nrchars++;
-			}
+		switch (c = *fmt++)
+		{
+			default:
+#ifdef CPM
+				if (c == '\n')
+				{
+					PUTC('\r');
+					nrchars++;
+				}
 #endif
-			PUTC(c);
-			nrchars++;
-			continue;
-		case 'n':
-			if (flags & FL_SHORT)
-				*va_arg(ap, short *) = (short) nrchars;
-			else if (flags & FL_LONG)
-				*va_arg(ap, long *) = (long) nrchars;
-			else
-				*va_arg(ap, int *) = (int) nrchars;
-			continue;
-		case 's':
-			s1 = va_arg(ap, char *);
-			if (s1 == NULL)
-				s1 = "(null)";
-			s = s1;
-			while (precision || !(flags & FL_PRECSPEC)) {
-				if (*s == '\0')
-					break;
-				s++;
-				precision--;
-			}
-			break;
-		case 'p':
-			set_pointer(flags);
+				PUTC(c);
+				nrchars++;
+				continue;
+			case 'n':
+				if (flags & FL_SHORT)
+					*va_arg(ap, short*) = (short)nrchars;
+				else if (flags & FL_LONG)
+					*va_arg(ap, long*) = (long)nrchars;
+				else
+					*va_arg(ap, int*) = (int)nrchars;
+				continue;
+			case 's':
+				s1 = va_arg(ap, char*);
+				if (s1 == NULL)
+					s1 = "(null)";
+				s = s1;
+				while (precision || !(flags & FL_PRECSPEC))
+				{
+					if (*s == '\0')
+						break;
+					s++;
+					precision--;
+				}
+				break;
+			case 'p':
+				set_pointer(flags);
 			/* fallthrough */
-		case 'b':
-		case 'o':
-		case 'u':
-		case 'x':
-		case 'X':
-			if (!(flags & FL_PRECSPEC)) precision = 1;
-			else if (c != 'p') flags &= ~FL_ZEROFILL;
-			s = o_print(&ap, flags, s, c, precision, 0);
-			break;
-		case 'd':
-		case 'i':
-			flags |= FL_SIGNEDCONV;
-			if (!(flags & FL_PRECSPEC)) precision = 1;
-			else flags &= ~FL_ZEROFILL;
-			s = o_print(&ap, flags, s, c, precision, 1);
-			break;
-		case 'c':
-			*s++ = va_arg(ap, int);
-			break;
+			case 'b':
+			case 'o':
+			case 'u':
+			case 'x':
+			case 'X':
+				if (!(flags & FL_PRECSPEC))
+					precision = 1;
+				else if (c != 'p')
+					flags &= ~FL_ZEROFILL;
+				s = o_print(&ap, flags, s, c, precision, 0);
+				break;
+			case 'd':
+			case 'i':
+				flags |= FL_SIGNEDCONV;
+				if (!(flags & FL_PRECSPEC))
+					precision = 1;
+				else
+					flags &= ~FL_ZEROFILL;
+				s = o_print(&ap, flags, s, c, precision, 1);
+				break;
+			case 'c':
+				*s++ = va_arg(ap, int);
+				break;
 #ifndef ACKCONF_NO_STDIO_FLOAT
-		case 'G':
-		case 'g':
-			if ((flags & FL_PRECSPEC) && (precision == 0))
-				precision = 1;
-		case 'f':
-		case 'E':
-		case 'e':
-			if (!(flags & FL_PRECSPEC)) 
-				precision = 6;
+			case 'G':
+			case 'g':
+				if ((flags & FL_PRECSPEC) && (precision == 0))
+					precision = 1;
+			case 'f':
+			case 'E':
+			case 'e':
+				if (!(flags & FL_PRECSPEC))
+					precision = 6;
 
-			if (precision >= sizeof(buf))
-				precision = sizeof(buf) - 1;
+				if (precision >= sizeof(buf))
+					precision = sizeof(buf) - 1;
 
-			flags |= FL_SIGNEDCONV;
-			s = _f_print(&ap, flags, s, c, precision);
-			break;
-#endif	/* ACKCONF_NO_STDIO_FLOAT */
-		case 'r':
-			ap = va_arg(ap, va_list);
-			fmt = va_arg(ap, char *);
-			continue;
+				flags |= FL_SIGNEDCONV;
+				s = _f_print(&ap, flags, s, c, precision);
+				break;
+#endif /* ACKCONF_NO_STDIO_FLOAT */
+			case 'r':
+				ap = va_arg(ap, va_list);
+				fmt = va_arg(ap, char*);
+				continue;
 		}
 		zfill = ' ';
-		if (flags & FL_ZEROFILL) zfill = '0';
+		if (flags & FL_ZEROFILL)
+			zfill = '0';
 		j = s - s1;
 
 		/* between_fill is true under the following conditions:
@@ -274,35 +349,45 @@ _doprnt(register const char *fmt, va_list ap, FILE *stream)
 		between_fill = 0;
 		if ((flags & FL_ZEROFILL)
 		    && (((c == 'x' || c == 'X') && (flags & FL_ALT))
-			|| (c == 'p')
-			|| ((flags & FL_SIGNEDCONV)
-			    && ( *s1 == '+' || *s1 == '-' || *s1 == ' '))))
+		           || (c == 'p')
+		           || ((flags & FL_SIGNEDCONV)
+		                  && (*s1 == '+' || *s1 == '-' || *s1 == ' '))))
 			between_fill++;
 
 		if ((i = width - j) > 0)
-			if (!(flags & FL_LJUST)) {	/* right justify */
+			if (!(flags & FL_LJUST))
+			{ /* right justify */
 				nrchars += i;
-				if (between_fill) {
-				    if (flags & FL_SIGNEDCONV) {
-					j--; nrchars++;
-					PUTC(*s1++);
-				    } else {
-					j -= 2; nrchars += 2;
-					PUTC(*s1++);
-					PUTC(*s1++);
+				if (between_fill)
+				{
+					if (flags & FL_SIGNEDCONV)
+					{
+						j--;
+						nrchars++;
+						PUTC(*s1++);
+					}
+					else
+					{
+						j -= 2;
+						nrchars += 2;
+						PUTC(*s1++);
+						PUTC(*s1++);
 					}
 				}
-				do {
+				do
+				{
 					PUTC(zfill);
 				} while (--i);
 			}
 
 		nrchars += j;
-		while (--j >= 0) {
+		while (--j >= 0)
+		{
 			PUTC(*s1++);
 		}
 
-		if (i > 0) nrchars += i;
+		if (i > 0)
+			nrchars += i;
 		while (--i >= 0)
 			PUTC(zfill);
 	}
diff --git a/lang/cem/libcc.ansi/stdio/doscan.c b/lang/cem/libcc.ansi/stdio/doscan.c
index eb93a4029..52e957a5d 100644
--- a/lang/cem/libcc.ansi/stdio/doscan.c
+++ b/lang/cem/libcc.ansi/stdio/doscan.c
@@ -3,26 +3,26 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
-#include	<stdlib.h>
-#include	<ctype.h>
-#include	<stdarg.h>
-#include	"loc_incl.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <stdarg.h>
+#include "loc_incl.h"
 
-#if	_EM_WSIZE == _EM_PSIZE
-#define set_pointer(flags)				/* nothing */
-#elif	_EM_LSIZE == _EM_PSIZE
-#define set_pointer(flags)	(flags |= FL_LONG)
+#if _EM_WSIZE == _EM_PSIZE
+#define set_pointer(flags) /* nothing */
+#elif _EM_LSIZE == _EM_PSIZE
+#define set_pointer(flags) (flags |= FL_LONG)
 #else
 #error garbage pointer size
-#define set_pointer(flags)		/* compilation might continue */
+#define set_pointer(flags) /* compilation might continue */
 #endif
 
-#define	NUMLEN	512
-#define	NR_CHARS	256
+#define NUMLEN 512
+#define NR_CHARS 256
 
-static char	Xtable[NR_CHARS];
-static char	inp_buf[NUMLEN];
+static char Xtable[NR_CHARS];
+static char inp_buf[NUMLEN];
 
 /* Collect a number of characters which constitite an ordinal number.
  * When the type is 'i', the base can be 8, 10, or 16, depending on the
@@ -30,65 +30,85 @@ static char	inp_buf[NUMLEN];
  * according to the format of the number. At the end of the function, base
  * is then set to 0, so strtol() will get the right argument.
  */
-static char *
-o_collect(register int c, register FILE *stream, char type,
-			int width, int *basep)
+static char*
+o_collect(register int c, register FILE* stream, char type,
+    int width, int* basep)
 {
-	register char *bufp = inp_buf;
+	register char* bufp = inp_buf;
 	register int base;
 
-	switch (type) {
-	case 'i':	/* i means octal, decimal or hexadecimal */
-	case 'p':
-	case 'x':
-	case 'X':	base = 16;	break;
-	case 'd':
-	case 'u':	base = 10;	break;
-	case 'o':	base = 8;	break;
-	case 'b':	base = 2;	break;
+	switch (type)
+	{
+		case 'i': /* i means octal, decimal or hexadecimal */
+		case 'p':
+		case 'x':
+		case 'X':
+			base = 16;
+			break;
+		case 'd':
+		case 'u':
+			base = 10;
+			break;
+		case 'o':
+			base = 8;
+			break;
+		case 'b':
+			base = 2;
+			break;
 	}
 
-	if (c == '-' || c == '+') {
-		*bufp++ = c;
-		if (--width)
-		    c = getc(stream);
-	}
-
-	if (width && c == '0' && base == 16) {
+	if (c == '-' || c == '+')
+	{
 		*bufp++ = c;
 		if (--width)
 			c = getc(stream);
-		if (c != 'x' && c != 'X') {
-			if (type == 'i') base = 8;
+	}
+
+	if (width && c == '0' && base == 16)
+	{
+		*bufp++ = c;
+		if (--width)
+			c = getc(stream);
+		if (c != 'x' && c != 'X')
+		{
+			if (type == 'i')
+				base = 8;
 		}
-		else if (width) {
+		else if (width)
+		{
 			*bufp++ = c;
 			if (--width)
 				c = getc(stream);
 		}
 	}
-	else if (type == 'i') base = 10;
+	else if (type == 'i')
+		base = 10;
 
-	while (width) {
+	while (width)
+	{
 		if (((base == 10) && isdigit(c))
 		    || ((base == 16) && isxdigit(c))
 		    || ((base == 8) && isdigit(c) && (c < '8'))
-		    || ((base == 2) && isdigit(c) && (c < '2'))) {
+		    || ((base == 2) && isdigit(c) && (c < '2')))
+		{
 			*bufp++ = c;
 			if (--width)
 				c = getc(stream);
 		}
-		else break;
+		else
+			break;
 	}
 
-	if (width && c != EOF) ungetc(c, stream);
-	if (type == 'i') base = 0;
+	if (width && c != EOF)
+		ungetc(c, stream);
+	if (type == 'i')
+		base = 0;
 	*basep = base;
 	*bufp = '\0';
 	return bufp - 1;
 }
 
-#ifndef	ACKCONF_NO_STDIO_FLOAT
+#ifndef ACKCONF_NO_STDIO_FLOAT
 /* The function f_collect() reads a string that has the format of a
  * floating-point number. The function returns as soon as a format-error
  * is encountered, leaving the offending character in the input. This means
@@ -97,353 +117,425 @@ o_collect(register int c, register FILE *stream, char type,
  * not necessary, although the use of the width field can cause incomplete
  * numbers to be passed to strtod(). (e.g. 1.3e+)
  */
-static char *
-f_collect(register int c, register FILE *stream, register int width)
+static char*
+f_collect(register int c, register FILE* stream, register int width)
 {
-	register char *bufp = inp_buf;
+	register char* bufp = inp_buf;
 	int digit_seen = 0;
 
-	if (c == '-' || c == '+') {
+	if (c == '-' || c == '+')
+	{
 		*bufp++ = c;
 		if (--width)
 			c = getc(stream);
 	}
 
-	while (width && isdigit(c)) {
+	while (width && isdigit(c))
+	{
 		digit_seen++;
 		*bufp++ = c;
 		if (--width)
 			c = getc(stream);
 	}
-	if (width && c == '.') {
-		*bufp++ = c;
-		if(--width)
-			c = getc(stream);
-		while (width && isdigit(c)) {
-			digit_seen++;
-			*bufp++ = c;
-			if (--width)
-				c = getc(stream);
-		}
-	}
-
-	if (!digit_seen) {
-		if (width && c != EOF) ungetc(c, stream);
-		return inp_buf - 1;
-	}
-	else digit_seen = 0;
-
-	if (width && (c == 'e' || c == 'E')) {
+	if (width && c == '.')
+	{
 		*bufp++ = c;
 		if (--width)
 			c = getc(stream);
-		if (width && (c == '+' || c == '-')) {
-			*bufp++ = c;
-			if (--width)
-				c = getc(stream);
-		}
-		while (width && isdigit(c)) {
+		while (width && isdigit(c))
+		{
 			digit_seen++;
 			*bufp++ = c;
 			if (--width)
 				c = getc(stream);
 		}
-		if (!digit_seen) {
-			if (width && c != EOF) ungetc(c,stream);
+	}
+
+	if (!digit_seen)
+	{
+		if (width && c != EOF)
+			ungetc(c, stream);
+		return inp_buf - 1;
+	}
+	else
+		digit_seen = 0;
+
+	if (width && (c == 'e' || c == 'E'))
+	{
+		*bufp++ = c;
+		if (--width)
+			c = getc(stream);
+		if (width && (c == '+' || c == '-'))
+		{
+			*bufp++ = c;
+			if (--width)
+				c = getc(stream);
+		}
+		while (width && isdigit(c))
+		{
+			digit_seen++;
+			*bufp++ = c;
+			if (--width)
+				c = getc(stream);
+		}
+		if (!digit_seen)
+		{
+			if (width && c != EOF)
+				ungetc(c, stream);
 			return inp_buf - 1;
 		}
 	}
 
-	if (width && c != EOF) ungetc(c, stream);
+	if (width && c != EOF)
+		ungetc(c, stream);
 	*bufp = '\0';
 	return bufp - 1;
 }
-#endif	/* ACKCONF_NO_STDIO_FLOAT */
-
+#endif /* ACKCONF_NO_STDIO_FLOAT */
 
 /*
  * the routine that does the scanning 
  */
 
-int
-_doscan(register FILE *stream, const char *format, va_list ap)
+int _doscan(register FILE* stream, const char* format, va_list ap)
 {
-	int		done = 0;	/* number of items done */
-	int		nrchars = 0;	/* number of characters read */
-	int		conv = 0;	/* # of conversions */
-	int		base;		/* conversion base */
-	unsigned long	val;		/* an integer value */
-	register char	*str;		/* temporary pointer */
-	char		*tmp_string;	/* ditto */
-	unsigned	width;		/* width of field */
-	int		flags;		/* some flags */
-	int		reverse;	/* reverse the checking in [...] */
-	int		kind;
-	register int	ic;		/* the input character */
-#ifndef	ACKCONF_NO_STDIO_FLOAT
-	long double	ld_val;
+	int done = 0; /* number of items done */
+	int nrchars = 0; /* number of characters read */
+	int conv = 0; /* # of conversions */
+	int base; /* conversion base */
+	unsigned long val; /* an integer value */
+	register char* str; /* temporary pointer */
+	char* tmp_string; /* ditto */
+	unsigned width; /* width of field */
+	int flags; /* some flags */
+	int reverse; /* reverse the checking in [...] */
+	int kind;
+	register int ic; /* the input character */
+#ifndef ACKCONF_NO_STDIO_FLOAT
+	long double ld_val;
 #endif
 
-	if (!*format) return 0;
+	if (!*format)
+		return 0;
 
-	while (1) {
-		if (isspace(*format)) {
+	while (1)
+	{
+		if (isspace(*format))
+		{
 			while (isspace(*format))
-				format++;	/* skip whitespace */
+				format++; /* skip whitespace */
 			ic = getc(stream);
 			nrchars++;
-			while (isspace (ic)) {
+			while (isspace(ic))
+			{
 				ic = getc(stream);
 				nrchars++;
 			}
-			if (ic != EOF) ungetc(ic,stream);
+			if (ic != EOF)
+				ungetc(ic, stream);
 			nrchars--;
 		}
-		if (!*format) break;	/* end of format */
+		if (!*format)
+			break; /* end of format */
 
-		if (*format != '%') {
+		if (*format != '%')
+		{
 			ic = getc(stream);
 			nrchars++;
-			if (ic != *format++) {
-				if (ic != EOF) ungetc(ic,stream);
+			if (ic != *format++)
+			{
+				if (ic != EOF)
+					ungetc(ic, stream);
 				nrchars--;
-				break;	/* error */
+				break; /* error */
 			}
 			continue;
 		}
 		format++;
-		if (*format == '%') {
+		if (*format == '%')
+		{
 			ic = getc(stream);
 			nrchars++;
-			if (ic == '%') {
+			if (ic == '%')
+			{
 				format++;
 				continue;
 			}
-			else break;
+			else
+				break;
 		}
 		flags = 0;
-		if (*format == '*') {
+		if (*format == '*')
+		{
 			format++;
 			flags |= FL_NOASSIGN;
 		}
-		if (isdigit (*format)) {
+		if (isdigit(*format))
+		{
 			flags |= FL_WIDTHSPEC;
-			for (width = 0; isdigit (*format);)
+			for (width = 0; isdigit(*format);)
 				width = width * 10 + *format++ - '0';
 		}
 
-		switch (*format) {
-		case 'h': flags |= FL_SHORT; format++; break;
-		case 'l': flags |= FL_LONG; format++; break;
-		case 'L': flags |= FL_LONGDOUBLE; format++; break;
+		switch (*format)
+		{
+			case 'h':
+				flags |= FL_SHORT;
+				format++;
+				break;
+			case 'l':
+				flags |= FL_LONG;
+				format++;
+				break;
+			case 'L':
+				flags |= FL_LONGDOUBLE;
+				format++;
+				break;
 		}
 		kind = *format;
-		if ((kind != 'c') && (kind != '[') && (kind != 'n')) {
-			do {
+		if ((kind != 'c') && (kind != '[') && (kind != 'n'))
+		{
+			do
+			{
 				ic = getc(stream);
 				nrchars++;
 			} while (isspace(ic));
-			if (ic == EOF) break;		/* outer while */
-		} else if (kind != 'n') {		/* %c or %[ */
+			if (ic == EOF)
+				break; /* outer while */
+		}
+		else if (kind != 'n')
+		{ /* %c or %[ */
 			ic = getc(stream);
-			if (ic == EOF) break;		/* outer while */
+			if (ic == EOF)
+				break; /* outer while */
 			nrchars++;
 		}
-		switch (kind) {
-		default:
-			/* not recognized, like %q */
-			return conv || (ic != EOF) ? done : EOF;
-			break;
-		case 'n':
-			if (!(flags & FL_NOASSIGN)) {	/* silly, though */
-				if (flags & FL_SHORT)
-					*va_arg(ap, short *) = (short) nrchars;
-				else if (flags & FL_LONG)
-					*va_arg(ap, long *) = (long) nrchars;
-				else
-					*va_arg(ap, int *) = (int) nrchars;
-			}
-			break;
-		case 'p':		/* pointer */
-			set_pointer(flags);
+		switch (kind)
+		{
+			default:
+				/* not recognized, like %q */
+				return conv || (ic != EOF) ? done : EOF;
+				break;
+			case 'n':
+				if (!(flags & FL_NOASSIGN))
+				{ /* silly, though */
+					if (flags & FL_SHORT)
+						*va_arg(ap, short*) = (short)nrchars;
+					else if (flags & FL_LONG)
+						*va_arg(ap, long*) = (long)nrchars;
+					else
+						*va_arg(ap, int*) = (int)nrchars;
+				}
+				break;
+			case 'p': /* pointer */
+				set_pointer(flags);
 			/* fallthrough */
-		case 'b':		/* binary */
-		case 'd':		/* decimal */
-		case 'i':		/* general integer */
-		case 'o':		/* octal */
-		case 'u':		/* unsigned */
-		case 'x':		/* hexadecimal */
-		case 'X':		/* ditto */
-			if (!(flags & FL_WIDTHSPEC) || width > NUMLEN)
-				width = NUMLEN;
-			if (!width) return done;
+			case 'b': /* binary */
+			case 'd': /* decimal */
+			case 'i': /* general integer */
+			case 'o': /* octal */
+			case 'u': /* unsigned */
+			case 'x': /* hexadecimal */
+			case 'X': /* ditto */
+				if (!(flags & FL_WIDTHSPEC) || width > NUMLEN)
+					width = NUMLEN;
+				if (!width)
+					return done;
 
-			str = o_collect(ic, stream, kind, width, &base);
-			if (str < inp_buf
-			    || (str == inp_buf
-				    && (*str == '-'
-					|| *str == '+'))) return done;
+				str = o_collect(ic, stream, kind, width, &base);
+				if (str < inp_buf
+				    || (str == inp_buf
+				           && (*str == '-'
+				                  || *str == '+')))
+					return done;
 
-			/*
+				/*
 			 * Although the length of the number is str-inp_buf+1
 			 * we don't add the 1 since we counted it already
 			 */
-			nrchars += str - inp_buf;
+				nrchars += str - inp_buf;
 
-			if (!(flags & FL_NOASSIGN)) {
-				if (kind == 'd' || kind == 'i')
-				    val = strtol(inp_buf, &tmp_string, base);
-				else
-				    val = strtoul(inp_buf, &tmp_string, base);
-				if (flags & FL_LONG)
-					*va_arg(ap, unsigned long *) = (unsigned long) val;
-				else if (flags & FL_SHORT)
-					*va_arg(ap, unsigned short *) = (unsigned short) val;
-				else
-					*va_arg(ap, unsigned *) = (unsigned) val;
-			}
-			break;
-		case 'c':
-			if (!(flags & FL_WIDTHSPEC))
-				width = 1;
-			if (!(flags & FL_NOASSIGN))
-				str = va_arg(ap, char *);
-			if (!width) return done;
-
-			while (width && ic != EOF) {
 				if (!(flags & FL_NOASSIGN))
-					*str++ = (char) ic;
-				if (--width) {
-					ic = getc(stream);
-					nrchars++;
+				{
+					if (kind == 'd' || kind == 'i')
+						val = strtol(inp_buf, &tmp_string, base);
+					else
+						val = strtoul(inp_buf, &tmp_string, base);
+					if (flags & FL_LONG)
+						*va_arg(ap, unsigned long*) = (unsigned long)val;
+					else if (flags & FL_SHORT)
+						*va_arg(ap, unsigned short*) = (unsigned short)val;
+					else
+						*va_arg(ap, unsigned*) = (unsigned)val;
 				}
-			}
-
-			if (width) {
-				if (ic != EOF) ungetc(ic,stream);
-				nrchars--;
-			}
-			break;
-		case 's':
-			if (!(flags & FL_WIDTHSPEC))
-				width = 0xffff;
-			if (!(flags & FL_NOASSIGN))
-				str = va_arg(ap, char *);
-			if (!width) return done;
-
-			while (width && ic != EOF && !isspace(ic)) {
+				break;
+			case 'c':
+				if (!(flags & FL_WIDTHSPEC))
+					width = 1;
 				if (!(flags & FL_NOASSIGN))
-					*str++ = (char) ic;
-				if (--width) {
-					ic = getc(stream);
-					nrchars++;
-				}
-			}
-			/* terminate the string */
-			if (!(flags & FL_NOASSIGN))
-				*str = '\0';	
-			if (width) {
-				if (ic != EOF) ungetc(ic,stream);
-				nrchars--;
-			}
-			break;
-		case '[':
-			if (!(flags & FL_WIDTHSPEC))
-				width = 0xffff;
-			if (!width) return done;
+					str = va_arg(ap, char*);
+				if (!width)
+					return done;
 
-			if ( *++format == '^' ) {
-				reverse = 1;
-				format++;
-			} else
-				reverse = 0;
-
-			for (str = Xtable; str < &Xtable[NR_CHARS]
-							; str++)
-				*str = 0;
-
-			if (*format == ']') Xtable[*format++] = 1;
-
-			while (*format && *format != ']') {
-				Xtable[*format++] = 1;
-				if (*format == '-') {
-					format++;
-					if (*format
-					    && *format != ']'
-					    && *(format) >= *(format -2)) {
-						int c;
-
-						for( c = *(format -2) + 1
-						    ; c <= *format ; c++)
-							Xtable[c] = 1;
-						format++;
+				while (width && ic != EOF)
+				{
+					if (!(flags & FL_NOASSIGN))
+						*str++ = (char)ic;
+					if (--width)
+					{
+						ic = getc(stream);
+						nrchars++;
 					}
-					else Xtable['-'] = 1;
 				}
-			}
-			if (!*format || !(Xtable[ic] ^ reverse)) {
-				if (ic != EOF) ungetc(ic, stream);
-				return done;
-			}
 
-			if (!(flags & FL_NOASSIGN))
-				str = va_arg(ap, char *);
-
-			do {
+				if (width)
+				{
+					if (ic != EOF)
+						ungetc(ic, stream);
+					nrchars--;
+				}
+				break;
+			case 's':
+				if (!(flags & FL_WIDTHSPEC))
+					width = 0xffff;
 				if (!(flags & FL_NOASSIGN))
-					*str++ = (char) ic;
-				if (--width) {
-					ic = getc(stream);
-					nrchars++;
+					str = va_arg(ap, char*);
+				if (!width)
+					return done;
+
+				while (width && ic != EOF && !isspace(ic))
+				{
+					if (!(flags & FL_NOASSIGN))
+						*str++ = (char)ic;
+					if (--width)
+					{
+						ic = getc(stream);
+						nrchars++;
+					}
 				}
-			} while (width && ic != EOF && (Xtable[ic] ^ reverse));
+				/* terminate the string */
+				if (!(flags & FL_NOASSIGN))
+					*str = '\0';
+				if (width)
+				{
+					if (ic != EOF)
+						ungetc(ic, stream);
+					nrchars--;
+				}
+				break;
+			case '[':
+				if (!(flags & FL_WIDTHSPEC))
+					width = 0xffff;
+				if (!width)
+					return done;
 
-			if (width) {
-				if (ic != EOF) ungetc(ic, stream);
-				nrchars--;
-			}
-			if (!(flags & FL_NOASSIGN)) {	/* terminate string */
-				*str = '\0';	
-			}
-			break;
-#ifndef	ACKCONF_NO_STDIO_FLOAT
-		case 'e':
-		case 'E':
-		case 'f':
-		case 'g':
-		case 'G':
-			if (!(flags & FL_WIDTHSPEC) || width > NUMLEN)
-				width = NUMLEN;
+				if (*++format == '^')
+				{
+					reverse = 1;
+					format++;
+				}
+				else
+					reverse = 0;
 
-			if (!width) return done;
-			str = f_collect(ic, stream, width);
+				for (str = Xtable; str < &Xtable[NR_CHARS]; str++)
+					*str = 0;
 
-			if (str < inp_buf
-			    || (str == inp_buf
-				&& (*str == '-'
-				    || *str == '+'))) return done;
+				if (*format == ']')
+					Xtable[*format++] = 1;
 
-			/*
+				while (*format && *format != ']')
+				{
+					Xtable[*format++] = 1;
+					if (*format == '-')
+					{
+						format++;
+						if (*format
+						    && *format != ']'
+						    && *(format) >= *(format - 2))
+						{
+							int c;
+
+							for (c = *(format - 2) + 1; c <= *format; c++)
+								Xtable[c] = 1;
+							format++;
+						}
+						else
+							Xtable['-'] = 1;
+					}
+				}
+				if (!*format || !(Xtable[ic] ^ reverse))
+				{
+					if (ic != EOF)
+						ungetc(ic, stream);
+					return done;
+				}
+
+				if (!(flags & FL_NOASSIGN))
+					str = va_arg(ap, char*);
+
+				do
+				{
+					if (!(flags & FL_NOASSIGN))
+						*str++ = (char)ic;
+					if (--width)
+					{
+						ic = getc(stream);
+						nrchars++;
+					}
+				} while (width && ic != EOF && (Xtable[ic] ^ reverse));
+
+				if (width)
+				{
+					if (ic != EOF)
+						ungetc(ic, stream);
+					nrchars--;
+				}
+				if (!(flags & FL_NOASSIGN))
+				{ /* terminate string */
+					*str = '\0';
+				}
+				break;
+#ifndef ACKCONF_NO_STDIO_FLOAT
+			case 'e':
+			case 'E':
+			case 'f':
+			case 'g':
+			case 'G':
+				if (!(flags & FL_WIDTHSPEC) || width > NUMLEN)
+					width = NUMLEN;
+
+				if (!width)
+					return done;
+				str = f_collect(ic, stream, width);
+
+				if (str < inp_buf
+				    || (str == inp_buf
+				           && (*str == '-'
+				                  || *str == '+')))
+					return done;
+
+				/*
 			 * Although the length of the number is str-inp_buf+1
 			 * we don't add the 1 since we counted it already
 			 */
-			nrchars += str - inp_buf;
+				nrchars += str - inp_buf;
 
-			if (!(flags & FL_NOASSIGN)) {
-				ld_val = strtod(inp_buf, &tmp_string);
-				if (flags & FL_LONGDOUBLE)
-					*va_arg(ap, long double *) = (long double) ld_val;
-				else
-				    if (flags & FL_LONG)
-					*va_arg(ap, double *) = (double) ld_val;
-				else
-					*va_arg(ap, float *) = (float) ld_val;
-			}
-			break;
+				if (!(flags & FL_NOASSIGN))
+				{
+					ld_val = strtod(inp_buf, &tmp_string);
+					if (flags & FL_LONGDOUBLE)
+						*va_arg(ap, long double*) = (long double)ld_val;
+					else if (flags & FL_LONG)
+						*va_arg(ap, double*) = (double)ld_val;
+					else
+						*va_arg(ap, float*) = (float)ld_val;
+				}
+				break;
 #endif
-		}		/* end switch */
+		} /* end switch */
 		conv++;
-		if (!(flags & FL_NOASSIGN) && kind != 'n') done++;
+		if (!(flags & FL_NOASSIGN) && kind != 'n')
+			done++;
 		format++;
 	}
 	return conv || (ic != EOF) ? done : EOF;
diff --git a/lang/cem/libcc.ansi/stdio/ecvt.c b/lang/cem/libcc.ansi/stdio/ecvt.c
index 9a15b5cde..4821fccbc 100644
--- a/lang/cem/libcc.ansi/stdio/ecvt.c
+++ b/lang/cem/libcc.ansi/stdio/ecvt.c
@@ -1,15 +1,15 @@
 /* $Id$ */
 
-#include    "loc_incl.h"
+#include "loc_incl.h"
 
 #ifndef ACKCONF_NO_STDIO_FLOAT
 
-#include	"../stdlib/ext_fmt.h"
-void _dbl_ext_cvt(double value, struct EXTEND *e);
-char *_ext_str_cvt(struct EXTEND *e, int ndigit, int *decpt, int * sign, int ecvtflag);
+#include "../stdlib/ext_fmt.h"
+void _dbl_ext_cvt(double value, struct EXTEND* e);
+char* _ext_str_cvt(struct EXTEND* e, int ndigit, int* decpt, int* sign, int ecvtflag);
 
-static char *
-cvt(long double value, int ndigit, int *decpt, int *sign, int ecvtflag)
+static char*
+cvt(long double value, int ndigit, int* decpt, int* sign, int ecvtflag)
 {
 	struct EXTEND e;
 
@@ -17,17 +17,15 @@ cvt(long double value, int ndigit, int *decpt, int *sign, int ecvtflag)
 	return _ext_str_cvt(&e, ndigit, decpt, sign, ecvtflag);
 }
 
-char *
-_ecvt(long double value, int ndigit, int *decpt, int *sign)
+char* _ecvt(long double value, int ndigit, int* decpt, int* sign)
 {
 
 	return cvt(value, ndigit, decpt, sign, 1);
 }
 
-char *
-_fcvt(long double value, int ndigit, int *decpt, int *sign)
+char* _fcvt(long double value, int ndigit, int* decpt, int* sign)
 {
 	return cvt(value, ndigit, decpt, sign, 0);
 }
 
-#endif	/* ACKCONF_NO_STDIO_FLOAT */
+#endif /* ACKCONF_NO_STDIO_FLOAT */
diff --git a/lang/cem/libcc.ansi/stdio/fclose.c b/lang/cem/libcc.ansi/stdio/fclose.c
index 0003535a7..7ed925251 100644
--- a/lang/cem/libcc.ansi/stdio/fclose.c
+++ b/lang/cem/libcc.ansi/stdio/fclose.c
@@ -8,23 +8,25 @@
 #include <unistd.h>
 #include "loc_incl.h"
 
-int
-fclose(FILE *fp)
+int fclose(FILE* fp)
 {
 	register int i, retval = 0;
 
-	for (i=0; i<FOPEN_MAX; i++)
-		if (fp == __iotab[i]) {
+	for (i = 0; i < FOPEN_MAX; i++)
+		if (fp == __iotab[i])
+		{
 			__iotab[i] = 0;
 			break;
 		}
 	if (i >= FOPEN_MAX)
 		return EOF;
-	if (fflush(fp)) retval = EOF;
-	if (close(fileno(fp))) retval = EOF;
-	if ( io_testflag(fp,_IOMYBUF) && fp->_buf )
-		free((void *)fp->_buf);
+	if (fflush(fp))
+		retval = EOF;
+	if (close(fileno(fp)))
+		retval = EOF;
+	if (io_testflag(fp, _IOMYBUF) && fp->_buf)
+		free((void*)fp->_buf);
 	if (fp != stdin && fp != stdout && fp != stderr)
-		free((void *)fp);
+		free((void*)fp);
 	return retval;
 }
diff --git a/lang/cem/libcc.ansi/stdio/fdopen.c b/lang/cem/libcc.ansi/stdio/fdopen.c
index a665ddd3f..d6b46bafe 100644
--- a/lang/cem/libcc.ansi/stdio/fdopen.c
+++ b/lang/cem/libcc.ansi/stdio/fdopen.c
@@ -3,50 +3,54 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
-#include	<stdlib.h>
-#include	"../stdio/loc_incl.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include "../stdio/loc_incl.h"
 
-FILE *
-fdopen(int fd, const char *mode)
+FILE* fdopen(int fd, const char* mode)
 {
 	register int i;
-	FILE *stream;
+	FILE* stream;
 	int flags = 0;
 
-	if (fd < 0) return (FILE *)NULL;
-	for (i = 0; __iotab[i] != 0 ; i++) 
-		if (i >= FOPEN_MAX-1)
-			return (FILE *)NULL;
+	if (fd < 0)
+		return (FILE*)NULL;
+	for (i = 0; __iotab[i] != 0; i++)
+		if (i >= FOPEN_MAX - 1)
+			return (FILE*)NULL;
 
-	switch(*mode++) {
-	case 'r':
-		flags |= _IOREAD | _IOREADING;
-		break;
-	case 'a':
-		flags |= _IOAPPEND;
-	case 'w':
-		flags |= _IOWRITE | _IOWRITING;
-		break;
-	default:
-		return (FILE *)NULL;
-	}
-	while(*mode) {
-		switch(*mode++) {
-		case 'b':
-			continue;
-		case '+':
-			flags |= _IOREAD | _IOWRITE;
-			continue;
-		/* The sequence may be followed by aditional characters */
-		default:
+	switch (*mode++)
+	{
+		case 'r':
+			flags |= _IOREAD | _IOREADING;
 			break;
+		case 'a':
+			flags |= _IOAPPEND;
+		case 'w':
+			flags |= _IOWRITE | _IOWRITING;
+			break;
+		default:
+			return (FILE*)NULL;
+	}
+	while (*mode)
+	{
+		switch (*mode++)
+		{
+			case 'b':
+				continue;
+			case '+':
+				flags |= _IOREAD | _IOWRITE;
+				continue;
+			/* The sequence may be followed by aditional characters */
+			default:
+				break;
 		}
 		break;
 	}
 
-	if ((stream = (FILE *) malloc(sizeof(FILE))) == NULL) {
-		return (FILE *)NULL;
+	if ((stream = (FILE*)malloc(sizeof(FILE))) == NULL)
+	{
+		return (FILE*)NULL;
 	}
 
 	if ((flags & _IOREAD) && (flags & _IOWRITE))
diff --git a/lang/cem/libcc.ansi/stdio/feof.c b/lang/cem/libcc.ansi/stdio/feof.c
index 5c7d4a74c..550792f36 100644
--- a/lang/cem/libcc.ansi/stdio/feof.c
+++ b/lang/cem/libcc.ansi/stdio/feof.c
@@ -3,10 +3,9 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
+#include <stdio.h>
 
-int
-(feof)(FILE *stream)
+int(feof)(FILE* stream)
 {
 	return feof(stream);
 }
diff --git a/lang/cem/libcc.ansi/stdio/ferror.c b/lang/cem/libcc.ansi/stdio/ferror.c
index 44880785d..d0271f0eb 100644
--- a/lang/cem/libcc.ansi/stdio/ferror.c
+++ b/lang/cem/libcc.ansi/stdio/ferror.c
@@ -3,10 +3,9 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
+#include <stdio.h>
 
-int
-(ferror)(FILE *stream)
+int(ferror)(FILE* stream)
 {
 	return ferror(stream);
 }
diff --git a/lang/cem/libcc.ansi/stdio/fflush.c b/lang/cem/libcc.ansi/stdio/fflush.c
index 573764fd4..f5ef6c355 100644
--- a/lang/cem/libcc.ansi/stdio/fflush.c
+++ b/lang/cem/libcc.ansi/stdio/fflush.c
@@ -8,67 +8,71 @@
 #include <unistd.h>
 #include "loc_incl.h"
 
-int
-fflush(FILE *stream)
+int fflush(FILE* stream)
 {
 	int count, c1, i, retval = 0;
 
-	if (!stream) {
-	    for(i= 0; i < FOPEN_MAX; i++)
-		if (__iotab[i] && fflush(__iotab[i]))
-			retval = EOF;
-	    return retval;
+	if (!stream)
+	{
+		for (i = 0; i < FOPEN_MAX; i++)
+			if (__iotab[i] && fflush(__iotab[i]))
+				retval = EOF;
+		return retval;
 	}
 
 	if (!stream->_buf
 	    || (!io_testflag(stream, _IOREADING)
-		&& !io_testflag(stream, _IOWRITING)))
+	           && !io_testflag(stream, _IOWRITING)))
 		return 0;
-	if (io_testflag(stream, _IOREADING)) {
+	if (io_testflag(stream, _IOREADING))
+	{
 		/* (void) fseek(stream, 0L, SEEK_CUR); */
 		int adjust = 0;
-		if (stream->_buf && !io_testflag(stream,_IONBF))
+		if (stream->_buf && !io_testflag(stream, _IONBF))
 			adjust = stream->_count;
 		stream->_count = 0;
-		lseek(fileno(stream), (off_t) adjust, SEEK_CUR);
+		lseek(fileno(stream), (off_t)adjust, SEEK_CUR);
 		if (io_testflag(stream, _IOWRITE))
 			stream->_flags &= ~(_IOREADING | _IOWRITING);
 		stream->_ptr = stream->_buf;
 		return 0;
-	} else if (io_testflag(stream, _IONBF)) return 0;
+	}
+	else if (io_testflag(stream, _IONBF))
+		return 0;
 
-	if (io_testflag(stream, _IOREAD))		/* "a" or "+" mode */
+	if (io_testflag(stream, _IOREAD)) /* "a" or "+" mode */
 		stream->_flags &= ~_IOWRITING;
 
 	count = stream->_ptr - stream->_buf;
 	stream->_ptr = stream->_buf;
 
-	if ( count <= 0 )
+	if (count <= 0)
 		return 0;
 
-	if (io_testflag(stream, _IOAPPEND)) {
-		if (lseek(fileno(stream), 0L, SEEK_END) == -1) {
+	if (io_testflag(stream, _IOAPPEND))
+	{
+		if (lseek(fileno(stream), 0L, SEEK_END) == -1)
+		{
 			stream->_flags |= _IOERR;
 			return EOF;
 		}
 	}
-	c1 = write(stream->_fd, (char *)stream->_buf, count);
+	c1 = write(stream->_fd, (char*)stream->_buf, count);
 
 	stream->_count = 0;
 
-	if ( count == c1 )
+	if (count == c1)
 		return 0;
 
 	stream->_flags |= _IOERR;
-	return EOF; 
+	return EOF;
 }
 
-void
-__cleanup(void)
+void __cleanup(void)
 {
 	register int i;
 
-	for(i= 0; i < FOPEN_MAX; i++)
+	for (i = 0; i < FOPEN_MAX; i++)
 		if (__iotab[i] && io_testflag(__iotab[i], _IOWRITING))
-			(void) fflush(__iotab[i]);
+			(void)fflush(__iotab[i]);
 }
diff --git a/lang/cem/libcc.ansi/stdio/fgetc.c b/lang/cem/libcc.ansi/stdio/fgetc.c
index 9e3df5016..08e7ca461 100644
--- a/lang/cem/libcc.ansi/stdio/fgetc.c
+++ b/lang/cem/libcc.ansi/stdio/fgetc.c
@@ -3,10 +3,9 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
+#include <stdio.h>
 
-int
-fgetc(FILE *stream)
+int fgetc(FILE* stream)
 {
 	return getc(stream);
 }
diff --git a/lang/cem/libcc.ansi/stdio/fgetpos.c b/lang/cem/libcc.ansi/stdio/fgetpos.c
index 20ff8bed5..687fbef17 100644
--- a/lang/cem/libcc.ansi/stdio/fgetpos.c
+++ b/lang/cem/libcc.ansi/stdio/fgetpos.c
@@ -3,12 +3,12 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
+#include <stdio.h>
 
-int
-fgetpos(FILE *stream, fpos_t *pos)
+int fgetpos(FILE* stream, fpos_t* pos)
 {
 	*pos = ftell(stream);
-	if (*pos == -1) return -1;
+	if (*pos == -1)
+		return -1;
 	return 0;
 }
diff --git a/lang/cem/libcc.ansi/stdio/fgets.c b/lang/cem/libcc.ansi/stdio/fgets.c
index c5476429d..6f4890e0c 100644
--- a/lang/cem/libcc.ansi/stdio/fgets.c
+++ b/lang/cem/libcc.ansi/stdio/fgets.c
@@ -3,24 +3,29 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
+#include <stdio.h>
 
-char *
-fgets(char *s, register int n, register FILE *stream)
+char* fgets(char* s, register int n, register FILE* stream)
 {
 	register int ch;
-	register char *ptr;
+	register char* ptr;
 
 	ptr = s;
-	while (--n > 0 && (ch = getc(stream)) != EOF) {
+	while (--n > 0 && (ch = getc(stream)) != EOF)
+	{
 		*ptr++ = ch;
-		if ( ch == '\n')
+		if (ch == '\n')
 			break;
 	}
-	if (ch == EOF) {
-		if (feof(stream)) {
-			if (ptr == s) return NULL;
-		} else return NULL;
+	if (ch == EOF)
+	{
+		if (feof(stream))
+		{
+			if (ptr == s)
+				return NULL;
+		}
+		else
+			return NULL;
 	}
 	*ptr = '\0';
 	return s;
diff --git a/lang/cem/libcc.ansi/stdio/fileno.c b/lang/cem/libcc.ansi/stdio/fileno.c
index b36b7cf29..eef38788a 100644
--- a/lang/cem/libcc.ansi/stdio/fileno.c
+++ b/lang/cem/libcc.ansi/stdio/fileno.c
@@ -3,10 +3,9 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
+#include <stdio.h>
 
-int
-(fileno)(FILE *stream)
+int(fileno)(FILE* stream)
 {
 	return stream->_fd;
 }
diff --git a/lang/cem/libcc.ansi/stdio/fillbuf.c b/lang/cem/libcc.ansi/stdio/fillbuf.c
index d01e208bf..c323da4cd 100644
--- a/lang/cem/libcc.ansi/stdio/fillbuf.c
+++ b/lang/cem/libcc.ansi/stdio/fillbuf.c
@@ -8,57 +8,67 @@
 #include <unistd.h>
 #include "loc_incl.h"
 
-int
-__fillbuf(register FILE *stream)
+int __fillbuf(register FILE* stream)
 {
 	static unsigned char ch[FOPEN_MAX];
 	register int i;
 
 	stream->_count = 0;
-	if (fileno(stream) < 0) return EOF;
-	if (io_testflag(stream, _IOEOF)) return EOF;
-	if (!io_testflag(stream, _IOREAD)) {
+	if (fileno(stream) < 0)
+		return EOF;
+	if (io_testflag(stream, _IOEOF))
+		return EOF;
+	if (!io_testflag(stream, _IOREAD))
+	{
 		stream->_flags |= _IOERR;
 		return EOF;
 	}
-	if (io_testflag(stream, _IOWRITING)) {
+	if (io_testflag(stream, _IOWRITING))
+	{
 		stream->_flags |= _IOERR;
 		return EOF;
 	}
 
 	if (!io_testflag(stream, _IOREADING))
 		stream->_flags |= _IOREADING;
-	
-	if (!io_testflag(stream, _IONBF) && !stream->_buf) {
-		stream->_buf = (unsigned char *) malloc(BUFSIZ);
-		if (!stream->_buf) {
+
+	if (!io_testflag(stream, _IONBF) && !stream->_buf)
+	{
+		stream->_buf = (unsigned char*)malloc(BUFSIZ);
+		if (!stream->_buf)
+		{
 			stream->_flags |= _IONBF;
 		}
-		else {
+		else
+		{
 			stream->_flags |= _IOMYBUF;
 			stream->_bufsiz = BUFSIZ;
 		}
 	}
 
 	/* flush line-buffered output when filling an input buffer */
-	for (i = 0; i < FOPEN_MAX; i++) {
+	for (i = 0; i < FOPEN_MAX; i++)
+	{
 		if (__iotab[i] && io_testflag(__iotab[i], _IOLBF))
 			if (io_testflag(__iotab[i], _IOWRITING))
-				(void) fflush(__iotab[i]);
+				(void)fflush(__iotab[i]);
 	}
 
-	if (!stream->_buf) {
+	if (!stream->_buf)
+	{
 		stream->_buf = &ch[fileno(stream)];
 		stream->_bufsiz = 1;
 	}
 	stream->_ptr = stream->_buf;
-	stream->_count = read(stream->_fd, (char *)stream->_buf, stream->_bufsiz);
+	stream->_count = read(stream->_fd, (char*)stream->_buf, stream->_bufsiz);
 
-	if (stream->_count <= 0){
-		if (stream->_count == 0) {
+	if (stream->_count <= 0)
+	{
+		if (stream->_count == 0)
+		{
 			stream->_flags |= _IOEOF;
 		}
-		else 
+		else
 			stream->_flags |= _IOERR;
 
 		return EOF;
diff --git a/lang/cem/libcc.ansi/stdio/fltpr.c b/lang/cem/libcc.ansi/stdio/fltpr.c
index ad8e16d46..091111949 100644
--- a/lang/cem/libcc.ansi/stdio/fltpr.c
+++ b/lang/cem/libcc.ansi/stdio/fltpr.c
@@ -3,16 +3,16 @@
  */
 /* $Id$ */
 
-#include	<string.h>
-#include	<stdarg.h>
-#include	"loc_incl.h"
+#include <string.h>
+#include <stdarg.h>
+#include "loc_incl.h"
 
-#ifndef	ACKCONF_NO_STDIO_FLOAT
+#ifndef ACKCONF_NO_STDIO_FLOAT
 
-static char *
-_pfloat(long double r, register char *s, int n, int flags)
+static char*
+_pfloat(long double r, register char* s, int n, int flags)
 {
-	register char *s1;
+	register char* s1;
 	int sign, dp;
 	register int i;
 
@@ -24,29 +24,34 @@ _pfloat(long double r, register char *s, int n, int flags)
 	else if (flags & FL_SPACE)
 		*s++ = ' ';
 
-	if (dp<=0)
+	if (dp <= 0)
 		*s++ = '0';
-	for (i=dp; i>0; i--)
-		if (*s1) *s++ = *s1++;
-		else *s++ = '0';
-	if (((i=n) > 0) || (flags & FL_ALT))
+	for (i = dp; i > 0; i--)
+		if (*s1)
+			*s++ = *s1++;
+		else
+			*s++ = '0';
+	if (((i = n) > 0) || (flags & FL_ALT))
 		*s++ = '.';
-	while (++dp <= 0) {
-		if (--i<0)
+	while (++dp <= 0)
+	{
+		if (--i < 0)
 			break;
 		*s++ = '0';
 	}
 	while (--i >= 0)
-		if (*s1) *s++ = *s1++;
-		else *s++ = '0';
+		if (*s1)
+			*s++ = *s1++;
+		else
+			*s++ = '0';
 	return s;
 }
 
-static char *
-_pscien(long double r, register char *s, int n, int flags)
+static char*
+_pscien(long double r, register char* s, int n, int flags)
 {
-	int sign, dp; 
-	register char *s1;
+	int sign, dp;
+	register char* s1;
 
 	s1 = _ecvt(r, n + 1, &dp, &sign);
 	if (sign)
@@ -60,30 +65,38 @@ _pscien(long double r, register char *s, int n, int flags)
 	if ((n > 0) || (flags & FL_ALT))
 		*s++ = '.';
 	while (--n >= 0)
-		if (*s1) *s++ = *s1++;
-		else *s++ = '0';
+		if (*s1)
+			*s++ = *s1++;
+		else
+			*s++ = '0';
 	*s++ = 'e';
-	if ( r != 0 ) --dp ;
-	if ( dp<0 ) {
-		*s++ = '-' ; dp= -dp ;
-	} else {
-		*s++ = '+' ;
+	if (r != 0)
+		--dp;
+	if (dp < 0)
+	{
+		*s++ = '-';
+		dp = -dp;
 	}
-	if (dp >= 100) {
+	else
+	{
+		*s++ = '+';
+	}
+	if (dp >= 100)
+	{
 		*s++ = '0' + (dp / 100);
 		dp %= 100;
 	}
-	*s++ = '0' + (dp/10);
-	*s++ = '0' + (dp%10);
+	*s++ = '0' + (dp / 10);
+	*s++ = '0' + (dp % 10);
 	return s;
 }
 
-#define	NDIGINEXP(exp)		(((exp) >= 100 || (exp) <= -100) ? 3 : 2)
-#define	LOW_EXP			-4
-#define	USE_EXP(exp, ndigits)	(((exp) < LOW_EXP + 1) || (exp >= ndigits + 1))
+#define NDIGINEXP(exp) (((exp) >= 100 || (exp) <= -100) ? 3 : 2)
+#define LOW_EXP -4
+#define USE_EXP(exp, ndigits) (((exp) < LOW_EXP + 1) || (exp >= ndigits + 1))
 
-static char *
-_gcvt(long double value, int ndigit, char *s, int flags)
+static char*
+_gcvt(long double value, int ndigit, char* s, int flags)
 {
 	int sign, dp;
 	register char *s1, *s2;
@@ -92,7 +105,8 @@ _gcvt(long double value, int ndigit, char *s, int flags)
 
 	s1 = _ecvt(value, ndigit, &dp, &sign);
 	s2 = s;
-	if (sign) *s2++ = '-';
+	if (sign)
+		*s2++ = '-';
 	else if (flags & FL_SIGN)
 		*s2++ = '+';
 	else if (flags & FL_SPACE)
@@ -102,78 +116,97 @@ _gcvt(long double value, int ndigit, char *s, int flags)
 		for (i = nndigit - 1; i > 0 && s1[i] == '0'; i--)
 			nndigit--;
 
-	if (USE_EXP(dp,ndigit))	{
+	if (USE_EXP(dp, ndigit))
+	{
 		/* Use E format */
 		dp--;
 		*s2++ = *s1++;
-		if ((nndigit > 1) || (flags & FL_ALT)) *s2++ = '.';
-		while (--nndigit > 0) *s2++ = *s1++;
+		if ((nndigit > 1) || (flags & FL_ALT))
+			*s2++ = '.';
+		while (--nndigit > 0)
+			*s2++ = *s1++;
 		*s2++ = 'e';
-		if (dp < 0) {
+		if (dp < 0)
+		{
 			*s2++ = '-';
 			dp = -dp;
 		}
-		else	 *s2++ = '+';
+		else
+			*s2++ = '+';
 		s2 += NDIGINEXP(dp);
 		*s2 = 0;
-		for (i = NDIGINEXP(dp); i > 0; i--) {
+		for (i = NDIGINEXP(dp); i > 0; i--)
+		{
 			*--s2 = dp % 10 + '0';
 			dp /= 10;
 		}
 		return s;
 	}
 	/* Use f format */
-	if (dp <= 0) {
-		if (*s1 != '0')	{
+	if (dp <= 0)
+	{
+		if (*s1 != '0')
+		{
 			/* otherwise the whole number is 0 */
 			*s2++ = '0';
 			*s2++ = '.';
 		}
-		while (dp < 0) {
+		while (dp < 0)
+		{
 			dp++;
 			*s2++ = '0';
 		}
 	}
-	for (i = 1; i <= nndigit; i++) {
+	for (i = 1; i <= nndigit; i++)
+	{
 		*s2++ = *s1++;
-		if (i == dp) *s2++ = '.';
+		if (i == dp)
+			*s2++ = '.';
 	}
-	if (i <= dp) {
-		while (i++ <= dp) *s2++ = '0';
+	if (i <= dp)
+	{
+		while (i++ <= dp)
+			*s2++ = '0';
 		*s2++ = '.';
 	}
-	if ((s2[-1]=='.') && !(flags & FL_ALT)) s2--;
+	if ((s2[-1] == '.') && !(flags & FL_ALT))
+		s2--;
 	*s2 = '\0';
 	return s;
 }
 
-char *
-_f_print(va_list *ap, int flags, char *s, char c, int precision)
+char* _f_print(va_list* ap, int flags, char* s, char c, int precision)
 {
-	register char *old_s = s;
+	register char* old_s = s;
 	long double ld_val;
 
-	if (flags & FL_LONGDOUBLE) ld_val = va_arg(*ap, long double);
-	else ld_val = (long double) va_arg(*ap, double);
+	if (flags & FL_LONGDOUBLE)
+		ld_val = va_arg(*ap, long double);
+	else
+		ld_val = (long double)va_arg(*ap, double);
 
-	switch(c) {
-	case 'f':
-		s = _pfloat(ld_val, s, precision, flags);
-		break;
-	case 'e':
-	case 'E':
-		s = _pscien(ld_val, s, precision , flags);
-		break;
-	case 'g':
-	case 'G':
-		s = _gcvt(ld_val, precision, s, flags);
-		s += strlen(s);
-		break;
+	switch (c)
+	{
+		case 'f':
+			s = _pfloat(ld_val, s, precision, flags);
+			break;
+		case 'e':
+		case 'E':
+			s = _pscien(ld_val, s, precision, flags);
+			break;
+		case 'g':
+		case 'G':
+			s = _gcvt(ld_val, precision, s, flags);
+			s += strlen(s);
+			break;
 	}
-	if ( c == 'E' || c == 'G') {
-		while (*old_s && *old_s != 'e') old_s++;
-		if (*old_s == 'e') *old_s = 'E';
+	if (c == 'E' || c == 'G')
+	{
+		while (*old_s && *old_s != 'e')
+			old_s++;
+		if (*old_s == 'e')
+			*old_s = 'E';
 	}
 	return s;
 }
-#endif	/* ACKCONF_NO_STDIO_FLOAT */
+#endif /* ACKCONF_NO_STDIO_FLOAT */
diff --git a/lang/cem/libcc.ansi/stdio/flushbuf.c b/lang/cem/libcc.ansi/stdio/flushbuf.c
index 22340e2e3..9518de70d 100644
--- a/lang/cem/libcc.ansi/stdio/flushbuf.c
+++ b/lang/cem/libcc.ansi/stdio/flushbuf.c
@@ -11,107 +11,136 @@
 extern void (*_clean)(void);
 
 static int
-do_write(int d, char *buf, int nbytes)
+do_write(int d, char* buf, int nbytes)
 {
 	int c;
 
 	/* POSIX actually allows write() to return a positive value less
 	   than nbytes, so loop ...
 	*/
-	while ((c = write(d, buf, nbytes)) > 0 && c < nbytes) {
+	while ((c = write(d, buf, nbytes)) > 0 && c < nbytes)
+	{
 		nbytes -= c;
 		buf += c;
 	}
 	return c > 0;
 }
 
-int
-__flushbuf(int c, FILE * stream)
+int __flushbuf(int c, FILE* stream)
 {
 	_clean = __cleanup;
-	if (fileno(stream) < 0) return EOF;
-	if (!io_testflag(stream, _IOWRITE)) return EOF;
-	if (io_testflag(stream, _IOREADING) && !feof(stream)) return EOF;
+	if (fileno(stream) < 0)
+		return EOF;
+	if (!io_testflag(stream, _IOWRITE))
+		return EOF;
+	if (io_testflag(stream, _IOREADING) && !feof(stream))
+		return EOF;
 
 	stream->_flags &= ~_IOREADING;
 	stream->_flags |= _IOWRITING;
-	if (!io_testflag(stream, _IONBF)) {
-		if (!stream->_buf) {
-			if (stream == stdout && isatty(fileno(stdout))) {
-				if (!(stream->_buf =
-					    (unsigned char *) malloc(BUFSIZ))) {
+	if (!io_testflag(stream, _IONBF))
+	{
+		if (!stream->_buf)
+		{
+			if (stream == stdout && isatty(fileno(stdout)))
+			{
+				if (!(stream->_buf = (unsigned char*)malloc(BUFSIZ)))
+				{
 					stream->_flags |= _IONBF;
-				} else {
-					stream->_flags |= _IOLBF|_IOMYBUF;
+				}
+				else
+				{
+					stream->_flags |= _IOLBF | _IOMYBUF;
 					stream->_bufsiz = BUFSIZ;
 					stream->_count = -1;
 				}
-			} else {
-				if (!(stream->_buf =
-					    (unsigned char *) malloc(BUFSIZ))) {
+			}
+			else
+			{
+				if (!(stream->_buf = (unsigned char*)malloc(BUFSIZ)))
+				{
 					stream->_flags |= _IONBF;
-				} else {
+				}
+				else
+				{
 					stream->_flags |= _IOMYBUF;
 					stream->_bufsiz = BUFSIZ;
 					if (!io_testflag(stream, _IOLBF))
 						stream->_count = BUFSIZ - 1;
-					else	stream->_count = -1;
+					else
+						stream->_count = -1;
 				}
 			}
 			stream->_ptr = stream->_buf;
 		}
 	}
 
-	if (io_testflag(stream, _IONBF)) {
+	if (io_testflag(stream, _IONBF))
+	{
 		char c1 = c;
 
 		stream->_count = 0;
-		if (io_testflag(stream, _IOAPPEND)) {
-			if (lseek(fileno(stream), 0L, SEEK_END) == -1) {
+		if (io_testflag(stream, _IOAPPEND))
+		{
+			if (lseek(fileno(stream), 0L, SEEK_END) == -1)
+			{
 				stream->_flags |= _IOERR;
 				return EOF;
 			}
 		}
-		if (write(fileno(stream), &c1, 1) != 1) {
+		if (write(fileno(stream), &c1, 1) != 1)
+		{
 			stream->_flags |= _IOERR;
 			return EOF;
 		}
-		return (unsigned char) c;
-	} else if (io_testflag(stream, _IOLBF)) {
+		return (unsigned char)c;
+	}
+	else if (io_testflag(stream, _IOLBF))
+	{
 		*stream->_ptr++ = c;
 		/* stream->_count has been updated in putc macro. */
-		if (c == '\n' || stream->_count == -stream->_bufsiz) {
+		if (c == '\n' || stream->_count == -stream->_bufsiz)
+		{
 			int count = -stream->_count;
 
-			stream->_ptr  = stream->_buf;
+			stream->_ptr = stream->_buf;
 			stream->_count = 0;
 
-			if (io_testflag(stream, _IOAPPEND)) {
-				if (lseek(fileno(stream), 0L, SEEK_END) == -1) {
+			if (io_testflag(stream, _IOAPPEND))
+			{
+				if (lseek(fileno(stream), 0L, SEEK_END) == -1)
+				{
 					stream->_flags |= _IOERR;
 					return EOF;
 				}
 			}
-			if (! do_write(fileno(stream), (char *)stream->_buf,
-					count)) {
+			if (!do_write(fileno(stream), (char*)stream->_buf,
+			        count))
+			{
 				stream->_flags |= _IOERR;
 				return EOF;
 			}
 		}
-	} else {
+	}
+	else
+	{
 		int count = stream->_ptr - stream->_buf;
 
 		stream->_count = stream->_bufsiz - 1;
 		stream->_ptr = stream->_buf + 1;
 
-		if (count > 0) {
-			if (io_testflag(stream, _IOAPPEND)) {
-				if (lseek(fileno(stream), 0L, SEEK_END) == -1) {
+		if (count > 0)
+		{
+			if (io_testflag(stream, _IOAPPEND))
+			{
+				if (lseek(fileno(stream), 0L, SEEK_END) == -1)
+				{
 					stream->_flags |= _IOERR;
 					return EOF;
 				}
 			}
-			if (! do_write(fileno(stream), (char *)stream->_buf, count)) {
+			if (!do_write(fileno(stream), (char*)stream->_buf, count))
+			{
 				*(stream->_buf) = c;
 				stream->_flags |= _IOERR;
 				return EOF;
@@ -119,5 +148,5 @@ __flushbuf(int c, FILE * stream)
 		}
 		*(stream->_buf) = c;
 	}
-	return (unsigned char) c;
+	return (unsigned char)c;
 }
diff --git a/lang/cem/libcc.ansi/stdio/fopen.c b/lang/cem/libcc.ansi/stdio/fopen.c
index a0bd9f40c..e3b935494 100644
--- a/lang/cem/libcc.ansi/stdio/fopen.c
+++ b/lang/cem/libcc.ansi/stdio/fopen.c
@@ -10,7 +10,7 @@
 #include <unistd.h>
 #include "loc_incl.h"
 
-#define	PMODE		0666
+#define PMODE 0666
 
 /* Since the O_CREAT flag is not available on all systems, we can't get it
  * from the standard library. Furthermore, even if we know that <fcntl.h>
@@ -31,48 +31,50 @@
  * Remember to fix freopen.c if changing this.
  */
 
-FILE *
-fopen(const char *name, const char *mode)
+FILE* fopen(const char* name, const char* mode)
 {
 	register int i;
 	int rwmode = 0, rwflags = 0;
-	FILE *stream;
+	FILE* stream;
 	int fd, flags = 0;
 
-	for (i = 0; __iotab[i] != 0 ; i++) 
-		if ( i >= FOPEN_MAX-1 )
-			return (FILE *)NULL;
+	for (i = 0; __iotab[i] != 0; i++)
+		if (i >= FOPEN_MAX - 1)
+			return (FILE*)NULL;
 
-	switch(*mode++) {
-	case 'r':
-		flags |= _IOREAD | _IOREADING;	
-		rwmode = O_RDONLY;
-		break;
-	case 'w':
-		flags |= _IOWRITE | _IOWRITING;
-		rwmode = O_WRONLY;
-		rwflags = O_CREAT | O_TRUNC;
-		break;
-	case 'a': 
-		flags |= _IOWRITE | _IOWRITING | _IOAPPEND;
-		rwmode = O_WRONLY;
-		rwflags |= O_APPEND | O_CREAT;
-		break;         
-	default:
-		return (FILE *)NULL;
+	switch (*mode++)
+	{
+		case 'r':
+			flags |= _IOREAD | _IOREADING;
+			rwmode = O_RDONLY;
+			break;
+		case 'w':
+			flags |= _IOWRITE | _IOWRITING;
+			rwmode = O_WRONLY;
+			rwflags = O_CREAT | O_TRUNC;
+			break;
+		case 'a':
+			flags |= _IOWRITE | _IOWRITING | _IOAPPEND;
+			rwmode = O_WRONLY;
+			rwflags |= O_APPEND | O_CREAT;
+			break;
+		default:
+			return (FILE*)NULL;
 	}
 
-	while (*mode) {
-		switch(*mode++) {
-		case 'b':
-			continue;
-		case '+':
-			rwmode = O_RDWR;
-			flags |= _IOREAD | _IOWRITE;
-			continue;
-		/* The sequence may be followed by additional characters */
-		default:
-			break;
+	while (*mode)
+	{
+		switch (*mode++)
+		{
+			case 'b':
+				continue;
+			case '+':
+				rwmode = O_RDWR;
+				flags |= _IOREAD | _IOWRITE;
+				continue;
+			/* The sequence may be followed by additional characters */
+			default:
+				break;
 		}
 		break;
 	}
@@ -82,22 +84,25 @@ fopen(const char *name, const char *mode)
 	 */
 	if ((rwflags & O_TRUNC)
 	    || (((fd = open(name, rwmode)) < 0)
-		    && (rwflags & O_CREAT))) {
-		if (((fd = creat(name, PMODE)) > 0) && flags  | _IOREAD) {
-			(void) close(fd);
+	           && (rwflags & O_CREAT)))
+	{
+		if (((fd = creat(name, PMODE)) > 0) && flags | _IOREAD)
+		{
+			(void)close(fd);
 			fd = open(name, rwmode);
 		}
-			
 	}
 
-	if (fd < 0) return (FILE *)NULL;
+	if (fd < 0)
+		return (FILE*)NULL;
 
-	if (( stream = (FILE *) malloc(sizeof(FILE))) == NULL ) {
+	if ((stream = (FILE*)malloc(sizeof(FILE))) == NULL)
+	{
 		close(fd);
-		return (FILE *)NULL;
+		return (FILE*)NULL;
 	}
 
-	if ((flags & (_IOREAD | _IOWRITE))  == (_IOREAD | _IOWRITE))
+	if ((flags & (_IOREAD | _IOWRITE)) == (_IOREAD | _IOWRITE))
 		flags &= ~(_IOREADING | _IOWRITING);
 
 	stream->_count = 0;
diff --git a/lang/cem/libcc.ansi/stdio/fprintf.c b/lang/cem/libcc.ansi/stdio/fprintf.c
index 6caeee311..cdcb16fee 100644
--- a/lang/cem/libcc.ansi/stdio/fprintf.c
+++ b/lang/cem/libcc.ansi/stdio/fprintf.c
@@ -3,19 +3,18 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
-#include	<stdarg.h>
-#include	"loc_incl.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include "loc_incl.h"
 
-int
-fprintf(FILE *stream, const char *format, ...)
+int fprintf(FILE* stream, const char* format, ...)
 {
 	va_list ap;
 	int retval;
-	
+
 	va_start(ap, format);
 
-	retval = _doprnt (format, ap, stream);
+	retval = _doprnt(format, ap, stream);
 
 	va_end(ap);
 
diff --git a/lang/cem/libcc.ansi/stdio/fputc.c b/lang/cem/libcc.ansi/stdio/fputc.c
index 334a34151..a0ac05c82 100644
--- a/lang/cem/libcc.ansi/stdio/fputc.c
+++ b/lang/cem/libcc.ansi/stdio/fputc.c
@@ -3,10 +3,9 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
+#include <stdio.h>
 
-int
-fputc(int c, FILE *stream)
+int fputc(int c, FILE* stream)
 {
 	return putc(c, stream);
 }
diff --git a/lang/cem/libcc.ansi/stdio/fputs.c b/lang/cem/libcc.ansi/stdio/fputs.c
index cd1ce3362..8b1f33397 100644
--- a/lang/cem/libcc.ansi/stdio/fputs.c
+++ b/lang/cem/libcc.ansi/stdio/fputs.c
@@ -3,16 +3,17 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
+#include <stdio.h>
 
-int
-fputs(register const char *s, register FILE *stream)
+int fputs(register const char* s, register FILE* stream)
 {
 	register int i = 0;
 
-	while (*s) 
-		if (putc(*s++, stream) == EOF) return EOF;
-		else i++;
+	while (*s)
+		if (putc(*s++, stream) == EOF)
+			return EOF;
+		else
+			i++;
 
 	return i;
 }
diff --git a/lang/cem/libcc.ansi/stdio/fread.c b/lang/cem/libcc.ansi/stdio/fread.c
index f4ac6b9d4..cf0806345 100644
--- a/lang/cem/libcc.ansi/stdio/fread.c
+++ b/lang/cem/libcc.ansi/stdio/fread.c
@@ -3,20 +3,22 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
+#include <stdio.h>
 
 size_t
-fread(void *ptr, size_t size, size_t nmemb, register FILE *stream)
+fread(void* ptr, size_t size, size_t nmemb, register FILE* stream)
 {
-	register char *cp = ptr;
+	register char* cp = ptr;
 	register int c;
 	size_t ndone = 0;
 	register size_t s;
 
 	if (size)
-		while ( ndone < nmemb ) {
+		while (ndone < nmemb)
+		{
 			s = size;
-			do {
+			do
+			{
 				if ((c = getc(stream)) != EOF)
 					*cp++ = c;
 				else
diff --git a/lang/cem/libcc.ansi/stdio/freopen.c b/lang/cem/libcc.ansi/stdio/freopen.c
index b51acba83..3f4e0a169 100644
--- a/lang/cem/libcc.ansi/stdio/freopen.c
+++ b/lang/cem/libcc.ansi/stdio/freopen.c
@@ -9,75 +9,82 @@
 #include <unistd.h>
 #include "loc_incl.h"
 
-#define	PMODE		0666
+#define PMODE 0666
 
 /* Do not "optimize" this file to use the open with O_CREAT if the file
  * does not exist. The reason is given in fopen.c.
  */
 
-FILE *
-freopen(const char *name, const char *mode, FILE *stream)
+FILE* freopen(const char* name, const char* mode, FILE* stream)
 {
 	register int i;
 	int rwmode = 0, rwflags = 0;
 	int fd, flags = stream->_flags & (_IONBF | _IOFBF | _IOLBF | _IOMYBUF);
 
-	(void) fflush(stream);				/* ignore errors */
-	(void) close(fileno(stream));
+	(void)fflush(stream); /* ignore errors */
+	(void)close(fileno(stream));
 
-	switch(*mode++) {
-	case 'r':
-		flags |= _IOREAD;	
-		rwmode = O_RDONLY;
-		break;
-	case 'w':
-		flags |= _IOWRITE;
-		rwmode = O_WRONLY;
-		rwflags = O_CREAT | O_TRUNC;
-		break;
-	case 'a': 
-		flags |= _IOWRITE | _IOAPPEND;
-		rwmode = O_WRONLY;
-		rwflags |= O_APPEND | O_CREAT;
-		break;         
-	default:
-		return (FILE *)NULL;
+	switch (*mode++)
+	{
+		case 'r':
+			flags |= _IOREAD;
+			rwmode = O_RDONLY;
+			break;
+		case 'w':
+			flags |= _IOWRITE;
+			rwmode = O_WRONLY;
+			rwflags = O_CREAT | O_TRUNC;
+			break;
+		case 'a':
+			flags |= _IOWRITE | _IOAPPEND;
+			rwmode = O_WRONLY;
+			rwflags |= O_APPEND | O_CREAT;
+			break;
+		default:
+			return (FILE*)NULL;
 	}
 
-	while (*mode) {
-		switch(*mode++) {
-		case 'b':
-			continue;
-		case '+':
-			rwmode = O_RDWR;
-			flags |= _IOREAD | _IOWRITE;
-			continue;
-		/* The sequence may be followed by aditional characters */
-		default:
-			break;
+	while (*mode)
+	{
+		switch (*mode++)
+		{
+			case 'b':
+				continue;
+			case '+':
+				rwmode = O_RDWR;
+				flags |= _IOREAD | _IOWRITE;
+				continue;
+			/* The sequence may be followed by aditional characters */
+			default:
+				break;
 		}
 		break;
 	}
 
 	if ((rwflags & O_TRUNC)
 	    || (((fd = open(name, rwmode)) < 0)
-		    && (rwflags & O_CREAT))) {
-		if (((fd = creat(name, PMODE)) < 0) && flags | _IOREAD) {
-			(void) close(fd);
+	           && (rwflags & O_CREAT)))
+	{
+		if (((fd = creat(name, PMODE)) < 0) && flags | _IOREAD)
+		{
+			(void)close(fd);
 			fd = open(name, rwmode);
 		}
 	}
 
-	if (fd < 0) {
-		for( i = 0; i < FOPEN_MAX; i++) {
-			if (stream == __iotab[i]) {
+	if (fd < 0)
+	{
+		for (i = 0; i < FOPEN_MAX; i++)
+		{
+			if (stream == __iotab[i])
+			{
 				__iotab[i] = 0;
 				break;
 			}
 		}
 		if (stream != stdin && stream != stdout && stream != stderr)
-			free((void *)stream);
-		return (FILE *)NULL;
+			free((void*)stream);
+		return (FILE*)NULL;
 	}
 
 	stream->_count = 0;
diff --git a/lang/cem/libcc.ansi/stdio/fscanf.c b/lang/cem/libcc.ansi/stdio/fscanf.c
index 25349b24e..05e69af50 100644
--- a/lang/cem/libcc.ansi/stdio/fscanf.c
+++ b/lang/cem/libcc.ansi/stdio/fscanf.c
@@ -3,12 +3,11 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
-#include	<stdarg.h>
-#include	"loc_incl.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include "loc_incl.h"
 
-int
-fscanf(FILE *stream, const char *format, ...)
+int fscanf(FILE* stream, const char* format, ...)
 {
 	va_list ap;
 	int retval;
diff --git a/lang/cem/libcc.ansi/stdio/fseek.c b/lang/cem/libcc.ansi/stdio/fseek.c
index 83d7640a3..2ab275cdc 100644
--- a/lang/cem/libcc.ansi/stdio/fseek.c
+++ b/lang/cem/libcc.ansi/stdio/fseek.c
@@ -8,8 +8,7 @@
 #include <unistd.h>
 #include "loc_incl.h"
 
-int
-fseek(FILE *stream, long int offset, int whence)
+int fseek(FILE* stream, long int offset, int whence)
 {
 	int adjust = 0;
 	long pos;
@@ -17,16 +16,20 @@ fseek(FILE *stream, long int offset, int whence)
 	stream->_flags &= ~(_IOEOF | _IOERR);
 	/* Clear both the end of file and error flags */
 
-	if (io_testflag(stream, _IOREADING)) {
+	if (io_testflag(stream, _IOREADING))
+	{
 		if (whence == SEEK_CUR
 		    && stream->_buf
-		    && !io_testflag(stream,_IONBF))
+		    && !io_testflag(stream, _IONBF))
 			adjust = stream->_count;
 		stream->_count = 0;
-	} else if (io_testflag(stream,_IOWRITING)) {
+	}
+	else if (io_testflag(stream, _IOWRITING))
+	{
 		fflush(stream);
-	} else	/* neither reading nor writing. The buffer must be empty */
-		/* EMPTY */ ;
+	}
+	else /* neither reading nor writing. The buffer must be empty */
+		/* EMPTY */;
 
 	pos = lseek(fileno(stream), offset - adjust, whence);
 	if (io_testflag(stream, _IOREAD) && io_testflag(stream, _IOWRITE))
diff --git a/lang/cem/libcc.ansi/stdio/fsetpos.c b/lang/cem/libcc.ansi/stdio/fsetpos.c
index a2a06ce0b..629abeed6 100644
--- a/lang/cem/libcc.ansi/stdio/fsetpos.c
+++ b/lang/cem/libcc.ansi/stdio/fsetpos.c
@@ -3,10 +3,9 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
+#include <stdio.h>
 
-int
-fsetpos(FILE *stream, fpos_t *pos)
+int fsetpos(FILE* stream, fpos_t* pos)
 {
 	return fseek(stream, *pos, SEEK_SET);
 }
diff --git a/lang/cem/libcc.ansi/stdio/ftell.c b/lang/cem/libcc.ansi/stdio/ftell.c
index 54c266c38..1fcbca25f 100644
--- a/lang/cem/libcc.ansi/stdio/ftell.c
+++ b/lang/cem/libcc.ansi/stdio/ftell.c
@@ -6,26 +6,27 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
-#include	"loc_incl.h"
+#include "loc_incl.h"
 
-long ftell(FILE *stream)
+long ftell(FILE* stream)
 {
 	long result;
 	int adjust = 0;
 
-	if (io_testflag(stream,_IOREADING))
+	if (io_testflag(stream, _IOREADING))
 		adjust = -stream->_count;
-	else if (io_testflag(stream,_IOWRITING)
-		    && stream->_buf
-		    && !io_testflag(stream,_IONBF))
+	else if (io_testflag(stream, _IOWRITING)
+	    && stream->_buf
+	    && !io_testflag(stream, _IONBF))
 		adjust = stream->_ptr - stream->_buf;
-	else adjust = 0;
+	else
+		adjust = 0;
 
 	result = lseek(fileno(stream), 0, SEEK_CUR);
 
-	if ( result == -1 )
+	if (result == -1)
 		return result;
 
-	result += (long) adjust;
+	result += (long)adjust;
 	return result;
 }
diff --git a/lang/cem/libcc.ansi/stdio/fwrite.c b/lang/cem/libcc.ansi/stdio/fwrite.c
index ed9a89f66..325257174 100644
--- a/lang/cem/libcc.ansi/stdio/fwrite.c
+++ b/lang/cem/libcc.ansi/stdio/fwrite.c
@@ -3,26 +3,27 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
+#include <stdio.h>
 
 size_t
-fwrite(const void *ptr, size_t size, size_t nmemb,
-	    register FILE *stream)
+fwrite(const void* ptr, size_t size, size_t nmemb,
+    register FILE* stream)
 {
-	register const unsigned char *cp = ptr;
+	register const unsigned char* cp = ptr;
 	register size_t s;
 	size_t ndone = 0;
 
 	if (size)
-		while ( ndone < nmemb ) {
+		while (ndone < nmemb)
+		{
 			s = size;
-			do {
+			do
+			{
 				if (putc((int)*cp, stream)
-					== EOF)
+				    == EOF)
 					return ndone;
 				cp++;
-			} 
-			while (--s);
+			} while (--s);
 			ndone++;
 		}
 	return ndone;
diff --git a/lang/cem/libcc.ansi/stdio/getc.c b/lang/cem/libcc.ansi/stdio/getc.c
index bd5e8cb77..20bdfa9f9 100644
--- a/lang/cem/libcc.ansi/stdio/getc.c
+++ b/lang/cem/libcc.ansi/stdio/getc.c
@@ -3,10 +3,9 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
+#include <stdio.h>
 
-int
-(getc)(FILE *stream)
+int(getc)(FILE* stream)
 {
 	return getc(stream);
 }
diff --git a/lang/cem/libcc.ansi/stdio/getchar.c b/lang/cem/libcc.ansi/stdio/getchar.c
index 8c2955ba4..e76f15d40 100644
--- a/lang/cem/libcc.ansi/stdio/getchar.c
+++ b/lang/cem/libcc.ansi/stdio/getchar.c
@@ -3,10 +3,9 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
+#include <stdio.h>
 
-int
-(getchar)(void)
+int(getchar)(void)
 {
 	return getchar();
 }
diff --git a/lang/cem/libcc.ansi/stdio/gets.c b/lang/cem/libcc.ansi/stdio/gets.c
index 74595a153..c58db3378 100644
--- a/lang/cem/libcc.ansi/stdio/gets.c
+++ b/lang/cem/libcc.ansi/stdio/gets.c
@@ -3,23 +3,27 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
+#include <stdio.h>
 
-char *
-gets(char *s)
+char* gets(char* s)
 {
-	register FILE *stream = stdin;
+	register FILE* stream = stdin;
 	register int ch;
-	register char *ptr;
+	register char* ptr;
 
 	ptr = s;
 	while ((ch = getc(stream)) != EOF && ch != '\n')
 		*ptr++ = ch;
 
-	if (ch == EOF) {
-		if (feof(stream)) {
-			if (ptr == s) return NULL;
-		} else return NULL;
+	if (ch == EOF)
+	{
+		if (feof(stream))
+		{
+			if (ptr == s)
+				return NULL;
+		}
+		else
+			return NULL;
 	}
 
 	*ptr = '\0';
diff --git a/lang/cem/libcc.ansi/stdio/icompute.c b/lang/cem/libcc.ansi/stdio/icompute.c
index 78c63580f..bc73f1ddb 100644
--- a/lang/cem/libcc.ansi/stdio/icompute.c
+++ b/lang/cem/libcc.ansi/stdio/icompute.c
@@ -3,19 +3,18 @@
  */
 /* $Id$ */
 
-#include	"loc_incl.h"
+#include "loc_incl.h"
 
 /* This routine is used in doprnt.c as well as in tmpfile.c and tmpnam.c. */
 
-char *
-_i_compute(unsigned long val, int base, char *s, int nrdigits)
+char* _i_compute(unsigned long val, int base, char* s, int nrdigits)
 {
 	int c;
 
-	c= val % base ;
-	val /= base ;
+	c = val % base;
+	val /= base;
 	if (val || nrdigits > 1)
 		s = _i_compute(val, base, s, nrdigits - 1);
-	*s++ = (c>9 ? c-10+'a' : c+'0');
+	*s++ = (c > 9 ? c - 10 + 'a' : c + '0');
 	return s;
 }
diff --git a/lang/cem/libcc.ansi/stdio/isatty.c b/lang/cem/libcc.ansi/stdio/isatty.c
index 10b2bdb36..97d7ca442 100644
--- a/lang/cem/libcc.ansi/stdio/isatty.c
+++ b/lang/cem/libcc.ansi/stdio/isatty.c
@@ -3,11 +3,11 @@
  */
 /* $Id$ */
 
-int _gtty(int d, char *buf);
+int _gtty(int d, char* buf);
 
 int _isatty(int d)
 {
-	char buf[128]; 
+	char buf[128];
 	/* not a sgttyb struct; it might not be large enough;
 	   I know for a fact that it isn't large enough on PC/IX,
 	   where gtty is an ioctl(..., TCGETA, ...)
diff --git a/lang/cem/libcc.ansi/stdio/perror.c b/lang/cem/libcc.ansi/stdio/perror.c
index f7329f6dc..1ff33f2c3 100644
--- a/lang/cem/libcc.ansi/stdio/perror.c
+++ b/lang/cem/libcc.ansi/stdio/perror.c
@@ -3,17 +3,17 @@
  */
 /* $Id$ */
 
-#include	<errno.h>
-#include	<stdio.h>
-#include	<string.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
 
-void
-perror(const char *s)
+void perror(const char* s)
 {
-	if (s && *s) {
-		(void) fputs(s, stderr);
-		(void) fputs(": ", stderr);
+	if (s && *s)
+	{
+		(void)fputs(s, stderr);
+		(void)fputs(": ", stderr);
 	}
-	(void) fputs(strerror(errno), stderr);
-	(void) fputs("\n", stderr);
+	(void)fputs(strerror(errno), stderr);
+	(void)fputs("\n", stderr);
 }
diff --git a/lang/cem/libcc.ansi/stdio/printf.c b/lang/cem/libcc.ansi/stdio/printf.c
index da49b2efc..d52d47525 100644
--- a/lang/cem/libcc.ansi/stdio/printf.c
+++ b/lang/cem/libcc.ansi/stdio/printf.c
@@ -3,12 +3,11 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
-#include	<stdarg.h>
-#include	"loc_incl.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include "loc_incl.h"
 
-int
-printf(const char *format, ...)
+int printf(const char* format, ...)
 {
 	va_list ap;
 	int retval;
diff --git a/lang/cem/libcc.ansi/stdio/putc.c b/lang/cem/libcc.ansi/stdio/putc.c
index cf79939b2..ee47c72cc 100644
--- a/lang/cem/libcc.ansi/stdio/putc.c
+++ b/lang/cem/libcc.ansi/stdio/putc.c
@@ -3,10 +3,9 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
+#include <stdio.h>
 
-int
-(putc)(int c, FILE *stream)
+int(putc)(int c, FILE* stream)
 {
 	return putc(c, stream);
 }
diff --git a/lang/cem/libcc.ansi/stdio/putchar.c b/lang/cem/libcc.ansi/stdio/putchar.c
index 2cddd5e10..ecf091f74 100644
--- a/lang/cem/libcc.ansi/stdio/putchar.c
+++ b/lang/cem/libcc.ansi/stdio/putchar.c
@@ -3,10 +3,9 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
+#include <stdio.h>
 
-int
-(putchar)(int c)
+int(putchar)(int c)
 {
 	return putchar(c);
 }
diff --git a/lang/cem/libcc.ansi/stdio/puts.c b/lang/cem/libcc.ansi/stdio/puts.c
index 99dfc8db8..faa762426 100644
--- a/lang/cem/libcc.ansi/stdio/puts.c
+++ b/lang/cem/libcc.ansi/stdio/puts.c
@@ -3,18 +3,21 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
+#include <stdio.h>
 
-int
-puts(register const char *s)
+int puts(register const char* s)
 {
-	register FILE *file = stdout;
+	register FILE* file = stdout;
 	register int i = 0;
 
-	while (*s) {
-		if (putc(*s++, file) == EOF) return EOF;
-		else i++;
+	while (*s)
+	{
+		if (putc(*s++, file) == EOF)
+			return EOF;
+		else
+			i++;
 	}
-	if (putc('\n', file) == EOF) return EOF;
+	if (putc('\n', file) == EOF)
+		return EOF;
 	return i + 1;
 }
diff --git a/lang/cem/libcc.ansi/stdio/remove.c b/lang/cem/libcc.ansi/stdio/remove.c
index 204c4a25d..fb0f4de8e 100644
--- a/lang/cem/libcc.ansi/stdio/remove.c
+++ b/lang/cem/libcc.ansi/stdio/remove.c
@@ -7,7 +7,7 @@
 #include <stdio.h>
 #include <unistd.h>
 
-int
-remove(const char *filename) {
+int remove(const char* filename)
+{
 	return unlink(filename);
 }
diff --git a/lang/cem/libcc.ansi/stdio/rewind.c b/lang/cem/libcc.ansi/stdio/rewind.c
index f3c9b22c3..41791a7d0 100644
--- a/lang/cem/libcc.ansi/stdio/rewind.c
+++ b/lang/cem/libcc.ansi/stdio/rewind.c
@@ -3,12 +3,11 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
-#include	"loc_incl.h"
+#include <stdio.h>
+#include "loc_incl.h"
 
-void
-rewind(FILE *stream)
+void rewind(FILE* stream)
 {
-	(void) fseek(stream, 0L, SEEK_SET);
+	(void)fseek(stream, 0L, SEEK_SET);
 	clearerr(stream);
 }
diff --git a/lang/cem/libcc.ansi/stdio/scanf.c b/lang/cem/libcc.ansi/stdio/scanf.c
index 2157419db..c8c03c52b 100644
--- a/lang/cem/libcc.ansi/stdio/scanf.c
+++ b/lang/cem/libcc.ansi/stdio/scanf.c
@@ -3,12 +3,11 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
-#include	<stdarg.h>
-#include	"loc_incl.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include "loc_incl.h"
 
-int
-scanf(const char *format, ...)
+int scanf(const char* format, ...)
 {
 	va_list ap;
 	int retval;
@@ -21,5 +20,3 @@ scanf(const char *format, ...)
 
 	return retval;
 }
-
-
diff --git a/lang/cem/libcc.ansi/stdio/setbuf.c b/lang/cem/libcc.ansi/stdio/setbuf.c
index aafacdbf6..c906bc47a 100644
--- a/lang/cem/libcc.ansi/stdio/setbuf.c
+++ b/lang/cem/libcc.ansi/stdio/setbuf.c
@@ -3,11 +3,10 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
-#include	"loc_incl.h"
+#include <stdio.h>
+#include "loc_incl.h"
 
-void
-setbuf(register FILE *stream, char *buf)
+void setbuf(register FILE* stream, char* buf)
 {
-	(void) setvbuf(stream, buf, (buf ? _IOFBF : _IONBF), (size_t) BUFSIZ);
+	(void)setvbuf(stream, buf, (buf ? _IOFBF : _IONBF), (size_t)BUFSIZ);
 }
diff --git a/lang/cem/libcc.ansi/stdio/setvbuf.c b/lang/cem/libcc.ansi/stdio/setvbuf.c
index 2c5e769df..b7571ccc6 100644
--- a/lang/cem/libcc.ansi/stdio/setvbuf.c
+++ b/lang/cem/libcc.ansi/stdio/setvbuf.c
@@ -3,14 +3,13 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
-#include	<stdlib.h>
-#include	"loc_incl.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include "loc_incl.h"
 
 extern void (*_clean)(void);
 
-int
-setvbuf(register FILE *stream, char *buf, int mode, size_t size)
+int setvbuf(register FILE* stream, char* buf, int mode, size_t size)
 {
 	int retval = 0;
 
@@ -18,29 +17,37 @@ setvbuf(register FILE *stream, char *buf, int mode, size_t size)
 	if (mode != _IOFBF && mode != _IOLBF && mode != _IONBF)
 		return EOF;
 
-	if (stream->_buf && io_testflag(stream,_IOMYBUF) )
-		free((void *)stream->_buf);
+	if (stream->_buf && io_testflag(stream, _IOMYBUF))
+		free((void*)stream->_buf);
 
 	stream->_flags &= ~(_IOMYBUF | _IONBF | _IOLBF);
 
-	if (buf && size <= 0) retval = EOF;
-	if (!buf && (mode != _IONBF)) {
-		if (size <= 0 || (buf = (char *) malloc(size)) == NULL) {
+	if (buf && size <= 0)
+		retval = EOF;
+	if (!buf && (mode != _IONBF))
+	{
+		if (size <= 0 || (buf = (char*)malloc(size)) == NULL)
+		{
 			retval = EOF;
-		} else {
+		}
+		else
+		{
 			stream->_flags |= _IOMYBUF;
 		}
 	}
 
-	stream->_buf = (unsigned char *) buf;
+	stream->_buf = (unsigned char*)buf;
 
 	stream->_count = 0;
 	stream->_flags |= mode;
 	stream->_ptr = stream->_buf;
 
-	if (!buf) {
+	if (!buf)
+	{
 		stream->_bufsiz = 1;
-	} else {
+	}
+	else
+	{
 		stream->_bufsiz = size;
 	}
 
diff --git a/lang/cem/libcc.ansi/stdio/snprintf.c b/lang/cem/libcc.ansi/stdio/snprintf.c
index 7d428118c..603b0a3d1 100644
--- a/lang/cem/libcc.ansi/stdio/snprintf.c
+++ b/lang/cem/libcc.ansi/stdio/snprintf.c
@@ -3,12 +3,11 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
-#include	<stdarg.h>
-#include	"loc_incl.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include "loc_incl.h"
 
-int
-snprintf(char * s, size_t len, const char *format, ...)
+int snprintf(char* s, size_t len, const char* format, ...)
 {
 	va_list ap;
 	int retval;
@@ -16,14 +15,14 @@ snprintf(char * s, size_t len, const char *format, ...)
 
 	va_start(ap, format);
 
-	tmp_stream._fd     = -1;
-	tmp_stream._flags  = _IOWRITE + _IONBF + _IOWRITING;
-	tmp_stream._buf    = (unsigned char *) s;
-	tmp_stream._ptr    = (unsigned char *) s;
-	tmp_stream._count  = len;
+	tmp_stream._fd = -1;
+	tmp_stream._flags = _IOWRITE + _IONBF + _IOWRITING;
+	tmp_stream._buf = (unsigned char*)s;
+	tmp_stream._ptr = (unsigned char*)s;
+	tmp_stream._count = len;
 
 	retval = _doprnt(format, ap, &tmp_stream);
-	putc('\0',&tmp_stream);
+	putc('\0', &tmp_stream);
 
 	va_end(ap);
 
diff --git a/lang/cem/libcc.ansi/stdio/sprintf.c b/lang/cem/libcc.ansi/stdio/sprintf.c
index 6e52bce4a..78349a3a5 100644
--- a/lang/cem/libcc.ansi/stdio/sprintf.c
+++ b/lang/cem/libcc.ansi/stdio/sprintf.c
@@ -3,12 +3,11 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
-#include	<stdarg.h>
-#include	"loc_incl.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include "loc_incl.h"
 
-int
-sprintf(char * s, const char *format, ...)
+int sprintf(char* s, const char* format, ...)
 {
 	va_list ap;
 	int retval;
@@ -16,14 +15,14 @@ sprintf(char * s, const char *format, ...)
 
 	va_start(ap, format);
 
-	tmp_stream._fd     = -1;
-	tmp_stream._flags  = _IOWRITE + _IONBF + _IOWRITING;
-	tmp_stream._buf    = (unsigned char *) s;
-	tmp_stream._ptr    = (unsigned char *) s;
-	tmp_stream._count  = 32767;
+	tmp_stream._fd = -1;
+	tmp_stream._flags = _IOWRITE + _IONBF + _IOWRITING;
+	tmp_stream._buf = (unsigned char*)s;
+	tmp_stream._ptr = (unsigned char*)s;
+	tmp_stream._count = 32767;
 
 	retval = _doprnt(format, ap, &tmp_stream);
-	putc('\0',&tmp_stream);
+	putc('\0', &tmp_stream);
 
 	va_end(ap);
 
diff --git a/lang/cem/libcc.ansi/stdio/sscanf.c b/lang/cem/libcc.ansi/stdio/sscanf.c
index b352db03e..723f6c231 100644
--- a/lang/cem/libcc.ansi/stdio/sscanf.c
+++ b/lang/cem/libcc.ansi/stdio/sscanf.c
@@ -3,12 +3,12 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
-#include	<stdarg.h>
-#include	<string.h>
-#include	"loc_incl.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include "loc_incl.h"
 
-int sscanf(const char *s, const char *format, ...)
+int sscanf(const char* s, const char* format, ...)
 {
 	va_list ap;
 	int retval;
@@ -16,11 +16,11 @@ int sscanf(const char *s, const char *format, ...)
 
 	va_start(ap, format);
 
-	tmp_stream._fd     = -1;
-	tmp_stream._flags  = _IOREAD + _IONBF + _IOREADING;
-	tmp_stream._buf    = (unsigned char *) s;
-	tmp_stream._ptr    = (unsigned char *) s;
-	tmp_stream._count  = strlen(s);
+	tmp_stream._fd = -1;
+	tmp_stream._flags = _IOREAD + _IONBF + _IOREADING;
+	tmp_stream._buf = (unsigned char*)s;
+	tmp_stream._ptr = (unsigned char*)s;
+	tmp_stream._count = strlen(s);
 
 	retval = _doscan(&tmp_stream, format, ap);
 
diff --git a/lang/cem/libcc.ansi/stdio/tmpfile.c b/lang/cem/libcc.ansi/stdio/tmpfile.c
index 19c91593d..cc525220d 100644
--- a/lang/cem/libcc.ansi/stdio/tmpfile.c
+++ b/lang/cem/libcc.ansi/stdio/tmpfile.c
@@ -9,20 +9,22 @@
 #include <string.h>
 #include "loc_incl.h"
 
-FILE *
-tmpfile(void) {
-	static char name_buffer[L_tmpnam] = "/tmp/tmp." ;
-	static char *name = NULL;
-	FILE *file;
+FILE* tmpfile(void)
+{
+	static char name_buffer[L_tmpnam] = "/tmp/tmp.";
+	static char* name = NULL;
+	FILE* file;
 
-	if (!name) {
+	if (!name)
+	{
 		name = name_buffer + strlen(name_buffer);
 		name = _i_compute(getpid(), 10, name, 5);
 		*name = '\0';
 	}
 
-	file = fopen(name_buffer,"wb+");
-	if (!file) return (FILE *)NULL;
-	(void) remove(name_buffer);
+	file = fopen(name_buffer, "wb+");
+	if (!file)
+		return (FILE*)NULL;
+	(void)remove(name_buffer);
 	return file;
 }
diff --git a/lang/cem/libcc.ansi/stdio/tmpnam.c b/lang/cem/libcc.ansi/stdio/tmpnam.c
index 9c6bc6be5..02df608ba 100644
--- a/lang/cem/libcc.ansi/stdio/tmpnam.c
+++ b/lang/cem/libcc.ansi/stdio/tmpnam.c
@@ -9,20 +9,24 @@
 #include <unistd.h>
 #include "loc_incl.h"
 
-char *
-tmpnam(char *s) {
+char* tmpnam(char* s)
+{
 	static char name_buffer[L_tmpnam] = "/tmp/tmp.";
 	static unsigned long count = 0;
-	static char *name = NULL;
+	static char* name = NULL;
 
-	if (!name) { 
+	if (!name)
+	{
 		name = name_buffer + strlen(name_buffer);
 		name = _i_compute(getpid(), 10, name, 5);
 		*name++ = '.';
 		*name = '\0';
 	}
-	if (++count > TMP_MAX) count = 1;	/* wrap-around */
+	if (++count > TMP_MAX)
+		count = 1; /* wrap-around */
 	*_i_compute(count, 10, name, 3) = '\0';
-	if (s) return strcpy(s, name_buffer);
-	else return name_buffer;
+	if (s)
+		return strcpy(s, name_buffer);
+	else
+		return name_buffer;
 }
diff --git a/lang/cem/libcc.ansi/stdio/ungetc.c b/lang/cem/libcc.ansi/stdio/ungetc.c
index 6e832d67b..cf690a52a 100644
--- a/lang/cem/libcc.ansi/stdio/ungetc.c
+++ b/lang/cem/libcc.ansi/stdio/ungetc.c
@@ -3,24 +3,25 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
-#include	"loc_incl.h"
+#include <stdio.h>
+#include "loc_incl.h"
 
-int
-ungetc(int ch, FILE *stream)
+int ungetc(int ch, FILE* stream)
 {
-	unsigned char *p;
+	unsigned char* p;
 
-	if (ch == EOF  || !io_testflag(stream,_IOREADING))
+	if (ch == EOF || !io_testflag(stream, _IOREADING))
 		return EOF;
-	if (stream->_ptr == stream->_buf) {
-		if (stream->_count != 0) return EOF;
+	if (stream->_ptr == stream->_buf)
+	{
+		if (stream->_count != 0)
+			return EOF;
 		stream->_ptr++;
 	}
 	stream->_count++;
-	p = --(stream->_ptr);		/* ??? Bloody vax assembler !!! */
+	p = --(stream->_ptr); /* ??? Bloody vax assembler !!! */
 	/* ungetc() in sscanf() shouldn't write in rom */
-	if (*p != (unsigned char) ch)
-		*p = (unsigned char) ch;
+	if (*p != (unsigned char)ch)
+		*p = (unsigned char)ch;
 	return ch;
 }
diff --git a/lang/cem/libcc.ansi/stdio/vfprintf.c b/lang/cem/libcc.ansi/stdio/vfprintf.c
index 96dcea9f5..fd896a720 100644
--- a/lang/cem/libcc.ansi/stdio/vfprintf.c
+++ b/lang/cem/libcc.ansi/stdio/vfprintf.c
@@ -3,12 +3,11 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
-#include	<stdarg.h>
-#include	"loc_incl.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include "loc_incl.h"
 
-int
-vfprintf(FILE *stream, const char *format, va_list arg)
+int vfprintf(FILE* stream, const char* format, va_list arg)
 {
-	return _doprnt (format, arg, stream);
+	return _doprnt(format, arg, stream);
 }
diff --git a/lang/cem/libcc.ansi/stdio/vprintf.c b/lang/cem/libcc.ansi/stdio/vprintf.c
index bc25f7363..bf884e576 100644
--- a/lang/cem/libcc.ansi/stdio/vprintf.c
+++ b/lang/cem/libcc.ansi/stdio/vprintf.c
@@ -3,12 +3,11 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
-#include	<stdarg.h>
-#include	"loc_incl.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include "loc_incl.h"
 
-int
-vprintf(const char *format, va_list arg)
+int vprintf(const char* format, va_list arg)
 {
 	return _doprnt(format, arg, stdout);
 }
diff --git a/lang/cem/libcc.ansi/stdio/vsnprintf.c b/lang/cem/libcc.ansi/stdio/vsnprintf.c
index 870e23df2..033e39d72 100644
--- a/lang/cem/libcc.ansi/stdio/vsnprintf.c
+++ b/lang/cem/libcc.ansi/stdio/vsnprintf.c
@@ -3,24 +3,23 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
-#include	<stdarg.h>
-#include	"loc_incl.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include "loc_incl.h"
 
-int
-vsnprintf(char *s, size_t len, const char *format, va_list arg)
+int vsnprintf(char* s, size_t len, const char* format, va_list arg)
 {
 	int retval;
 	FILE tmp_stream;
 
-	tmp_stream._fd     = -1;
-	tmp_stream._flags  = _IOWRITE + _IONBF + _IOWRITING;
-	tmp_stream._buf    = (unsigned char *) s;
-	tmp_stream._ptr    = (unsigned char *) s;
-	tmp_stream._count  = len;
+	tmp_stream._fd = -1;
+	tmp_stream._flags = _IOWRITE + _IONBF + _IOWRITING;
+	tmp_stream._buf = (unsigned char*)s;
+	tmp_stream._ptr = (unsigned char*)s;
+	tmp_stream._count = len;
 
 	retval = _doprnt(format, arg, &tmp_stream);
-	putc('\0',&tmp_stream);
+	putc('\0', &tmp_stream);
 
 	return retval;
 }
diff --git a/lang/cem/libcc.ansi/stdio/vsprintf.c b/lang/cem/libcc.ansi/stdio/vsprintf.c
index b4ae4ed74..b0cbc124c 100644
--- a/lang/cem/libcc.ansi/stdio/vsprintf.c
+++ b/lang/cem/libcc.ansi/stdio/vsprintf.c
@@ -3,24 +3,23 @@
  */
 /* $Id$ */
 
-#include	<stdio.h>
-#include	<stdarg.h>
-#include	"loc_incl.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include "loc_incl.h"
 
-int
-vsprintf(char *s, const char *format, va_list arg)
+int vsprintf(char* s, const char* format, va_list arg)
 {
 	int retval;
 	FILE tmp_stream;
 
-	tmp_stream._fd     = -1;
-	tmp_stream._flags  = _IOWRITE + _IONBF + _IOWRITING;
-	tmp_stream._buf    = (unsigned char *) s;
-	tmp_stream._ptr    = (unsigned char *) s;
-	tmp_stream._count  = 32767;
+	tmp_stream._fd = -1;
+	tmp_stream._flags = _IOWRITE + _IONBF + _IOWRITING;
+	tmp_stream._buf = (unsigned char*)s;
+	tmp_stream._ptr = (unsigned char*)s;
+	tmp_stream._count = 32767;
 
 	retval = _doprnt(format, arg, &tmp_stream);
-	putc('\0',&tmp_stream);
+	putc('\0', &tmp_stream);
 
 	return retval;
 }
diff --git a/lang/cem/libcc.ansi/stdlib/abort.c b/lang/cem/libcc.ansi/stdlib/abort.c
index d5ceff27c..afad36bf9 100644
--- a/lang/cem/libcc.ansi/stdlib/abort.c
+++ b/lang/cem/libcc.ansi/stdlib/abort.c
@@ -4,18 +4,17 @@
  */
 /* $Id$ */
 
-#if	defined(_POSIX_SOURCE)
-#include	<sys/types.h>
+#if defined(_POSIX_SOURCE)
+#include <sys/types.h>
 #endif
-#include	<signal.h>
-#include	<stdlib.h>
+#include <signal.h>
+#include <stdlib.h>
 
 extern void (*_clean)(void);
 
-void
-abort(void)
+void abort(void)
 {
-	if (_clean) _clean();		/* flush all output files */
+	if (_clean)
+		_clean(); /* flush all output files */
 	raise(SIGABRT);
 }
-
diff --git a/lang/cem/libcc.ansi/stdlib/abs.c b/lang/cem/libcc.ansi/stdlib/abs.c
index 04a0fb642..3270f087a 100644
--- a/lang/cem/libcc.ansi/stdlib/abs.c
+++ b/lang/cem/libcc.ansi/stdlib/abs.c
@@ -4,10 +4,9 @@
  */
 /* $Id$ */
 
-#include	<stdlib.h>
+#include <stdlib.h>
 
-int
-abs(register int i)
+int abs(register int i)
 {
 	return i >= 0 ? i : -i;
 }
diff --git a/lang/cem/libcc.ansi/stdlib/atexit.c b/lang/cem/libcc.ansi/stdlib/atexit.c
index 77e343336..c9dc7964a 100644
--- a/lang/cem/libcc.ansi/stdlib/atexit.c
+++ b/lang/cem/libcc.ansi/stdlib/atexit.c
@@ -1,14 +1,13 @@
 /* $Id$ */
 
-#include	<stdlib.h>
+#include <stdlib.h>
 
-#define	NEXITS	32
+#define NEXITS 32
 
 extern void (*__functab[NEXITS])(void);
 extern int __funccnt;
 
-int
-atexit(void (*func)(void))
+int atexit(void (*func)(void))
 {
 	if (__funccnt >= NEXITS)
 		return 1;
diff --git a/lang/cem/libcc.ansi/stdlib/atof.c b/lang/cem/libcc.ansi/stdlib/atof.c
index 834dc9242..c46304817 100644
--- a/lang/cem/libcc.ansi/stdlib/atof.c
+++ b/lang/cem/libcc.ansi/stdlib/atof.c
@@ -4,16 +4,15 @@
  */
 /* $Id$ */
 
-#include	<stdlib.h>
-#include	<errno.h>
+#include <stdlib.h>
+#include <errno.h>
 
-double
-(atof)(const char *nptr)
+double(atof)(const char* nptr)
 {
 	double d;
 	int e = errno;
 
-	d = strtod(nptr, (char **) NULL);
+	d = strtod(nptr, (char**)NULL);
 	errno = e;
 	return d;
 }
diff --git a/lang/cem/libcc.ansi/stdlib/atoi.c b/lang/cem/libcc.ansi/stdlib/atoi.c
index f8dd99d8f..6cd0c8d05 100644
--- a/lang/cem/libcc.ansi/stdlib/atoi.c
+++ b/lang/cem/libcc.ansi/stdlib/atoi.c
@@ -4,24 +4,27 @@
  */
 /* $Id$ */
 
-#include	<ctype.h>
+#include <ctype.h>
 
 /* We do not use strtol here for backwards compatibility in behaviour on
    overflow.
 */
-int
-atoi(register const char *nptr)
+int atoi(register const char* nptr)
 {
 	int total = 0;
 	int minus = 0;
 
-	while (isspace(*nptr)) nptr++;
-	if (*nptr == '+') nptr++;
-	else if (*nptr == '-') {
+	while (isspace(*nptr))
+		nptr++;
+	if (*nptr == '+')
+		nptr++;
+	else if (*nptr == '-')
+	{
 		minus = 1;
 		nptr++;
 	}
-	while (isdigit(*nptr)) {
+	while (isdigit(*nptr))
+	{
 		total *= 10;
 		total += (*nptr++ - '0');
 	}
diff --git a/lang/cem/libcc.ansi/stdlib/atol.c b/lang/cem/libcc.ansi/stdlib/atol.c
index 456852cb5..27adb3479 100644
--- a/lang/cem/libcc.ansi/stdlib/atol.c
+++ b/lang/cem/libcc.ansi/stdlib/atol.c
@@ -4,24 +4,27 @@
  */
 /* $Id$ */
 
-#include	<ctype.h>
+#include <ctype.h>
 
 /* We do not use strtol here for backwards compatibility in behaviour on
    overflow.
 */
-long
-atol(register const char *nptr)
+long atol(register const char* nptr)
 {
 	long total = 0;
 	int minus = 0;
 
-	while (isspace(*nptr)) nptr++;
-	if (*nptr == '+') nptr++;
-	else if (*nptr == '-') {
+	while (isspace(*nptr))
+		nptr++;
+	if (*nptr == '+')
+		nptr++;
+	else if (*nptr == '-')
+	{
 		minus = 1;
 		nptr++;
 	}
-	while (isdigit(*nptr)) {
+	while (isdigit(*nptr))
+	{
 		total *= 10;
 		total += (*nptr++ - '0');
 	}
diff --git a/lang/cem/libcc.ansi/stdlib/bsearch.c b/lang/cem/libcc.ansi/stdlib/bsearch.c
index 0958e3d78..519fff9dd 100644
--- a/lang/cem/libcc.ansi/stdlib/bsearch.c
+++ b/lang/cem/libcc.ansi/stdlib/bsearch.c
@@ -4,25 +4,27 @@
  */
 /* $Id$ */
 
-#include	<stdlib.h>
+#include <stdlib.h>
 
-void *
-bsearch(register const void *key, register const void *base,
-	register size_t nmemb, register size_t size,
-	int (*compar)(const void *, const void *))
+void* bsearch(register const void* key, register const void* base,
+    register size_t nmemb, register size_t size,
+    int (*compar)(const void*, const void*))
 {
-	register const void *mid_point;
-	register int  cmp;
+	register const void* mid_point;
+	register int cmp;
 
-	while (nmemb > 0) {
-		mid_point = (char *)base + size * (nmemb >> 1);
+	while (nmemb > 0)
+	{
+		mid_point = (char*)base + size * (nmemb >> 1);
 		if ((cmp = (*compar)(key, mid_point)) == 0)
-			return (void *)mid_point;
-		if (cmp >= 0) {
-			base  = (char *)mid_point + size;
+			return (void*)mid_point;
+		if (cmp >= 0)
+		{
+			base = (char*)mid_point + size;
 			nmemb = (nmemb - 1) >> 1;
-		} else
+		}
+		else
 			nmemb >>= 1;
 	}
-	return (void *)NULL;
+	return (void*)NULL;
 }
diff --git a/lang/cem/libcc.ansi/stdlib/div.c b/lang/cem/libcc.ansi/stdlib/div.c
index 659363564..42f739b0e 100644
--- a/lang/cem/libcc.ansi/stdlib/div.c
+++ b/lang/cem/libcc.ansi/stdlib/div.c
@@ -4,17 +4,17 @@
  */
 /* $Id$ */
 
-#include	<stdlib.h>
+#include <stdlib.h>
 
-div_t
-div(register int numer, register int denom)
+div_t div(register int numer, register int denom)
 {
 	div_t r;
 
-	r.quot = numer / denom;		/* might trap if denom == 0 */
+	r.quot = numer / denom; /* might trap if denom == 0 */
 	r.rem = numer % denom;
 
-	if (r.rem != 0 && (numer > 0) != (r.rem > 0)) {
+	if (r.rem != 0 && (numer > 0) != (r.rem > 0))
+	{
 		r.quot++;
 		r.rem -= denom;
 	}
diff --git a/lang/cem/libcc.ansi/stdlib/exit.c b/lang/cem/libcc.ansi/stdlib/exit.c
index 16be42f4d..ef8976bc0 100644
--- a/lang/cem/libcc.ansi/stdlib/exit.c
+++ b/lang/cem/libcc.ansi/stdlib/exit.c
@@ -8,7 +8,7 @@
 #include <stdio.h>
 #include <unistd.h>
 
-#define	NEXITS	32
+#define NEXITS 32
 
 void (*__functab[NEXITS])(void);
 int __funccnt = 0;
@@ -20,16 +20,16 @@ static void
 _calls(void)
 {
 	register int i = __funccnt;
-	
+
 	/* "Called in reversed order of their registration" */
 	while (--i >= 0)
 		(*__functab[i])();
 }
 
-void
-exit(int status)
+void exit(int status)
 {
 	_calls();
-	if (_clean) _clean();
-	_exit(status) ;
+	if (_clean)
+		_clean();
+	_exit(status);
 }
diff --git a/lang/cem/libcc.ansi/stdlib/ext_comp.c b/lang/cem/libcc.ansi/stdlib/ext_comp.c
index 2133e64bd..c9b0b8b13 100644
--- a/lang/cem/libcc.ansi/stdlib/ext_comp.c
+++ b/lang/cem/libcc.ansi/stdlib/ext_comp.c
@@ -11,27 +11,26 @@
    bytes. In this case, these routines may become obsolete. ???
 */
 
-#include	"ext_fmt.h"
-#include	<float.h>
-#include	<errno.h>
-#include	<ctype.h>
-#include    <ack/config.h>
+#include "ext_fmt.h"
+#include <float.h>
+#include <errno.h>
+#include <ctype.h>
+#include <ack/config.h>
 
-static int b64_add(struct mantissa *e1, struct mantissa *e2);
-static b64_sft(struct mantissa *e1, int n);
+static int b64_add(struct mantissa* e1, struct mantissa* e2);
+static b64_sft(struct mantissa* e1, int n);
 
-static
-mul_ext(struct EXTEND *e1, struct EXTEND *e2, struct EXTEND *e3)
+static mul_ext(struct EXTEND* e1, struct EXTEND* e2, struct EXTEND* e3)
 {
 	/*	Multiply the extended numbers e1 and e2, and put the
 		result in e3.
 	*/
-	register int	i,j;		/* loop control	*/
-	unsigned short	mp[4];
-	unsigned short	mc[4];
-	unsigned short	result[8];	/* result */
+	register int i, j; /* loop control	*/
+	unsigned short mp[4];
+	unsigned short mc[4];
+	unsigned short result[8]; /* result */
 
-	register unsigned short *pres;
+	register unsigned short* pres;
 
 	/* first save the sign (XOR)			*/
 	e3->sign = e1->sign ^ e2->sign;
@@ -46,47 +45,58 @@ mul_ext(struct EXTEND *e1, struct EXTEND *e2, struct EXTEND *e3)
 	/* assign unknown long formats		*/
 	/* to known unsigned word formats	*/
 	mp[0] = e1->m1 >> 16;
-	mp[1] = (unsigned short) e1->m1;
+	mp[1] = (unsigned short)e1->m1;
 	mp[2] = e1->m2 >> 16;
-	mp[3] = (unsigned short) e1->m2;
+	mp[3] = (unsigned short)e1->m2;
 	mc[0] = e2->m1 >> 16;
-	mc[1] = (unsigned short) e2->m1;
+	mc[1] = (unsigned short)e2->m1;
 	mc[2] = e2->m2 >> 16;
-	mc[3] = (unsigned short) e2->m2;
-	for (i = 8; i--;) {
+	mc[3] = (unsigned short)e2->m2;
+	for (i = 8; i--;)
+	{
 		result[i] = 0;
 	}
 	/*
 	 *	fill registers with their components
 	 */
-	for(i=4, pres = &result[4];i--;pres--) if (mp[i]) {
-		unsigned short k = 0;
-		unsigned long mpi = mp[i];
-		for(j=4;j--;) {
-			unsigned long tmp = (unsigned long)pres[j] + k;
-			if (mc[j]) tmp += mpi * mc[j];
-			pres[j] = tmp;
-			k = tmp >> 16;
+	for (i = 4, pres = &result[4]; i--; pres--)
+		if (mp[i])
+		{
+			unsigned short k = 0;
+			unsigned long mpi = mp[i];
+			for (j = 4; j--;)
+			{
+				unsigned long tmp = (unsigned long)pres[j] + k;
+				if (mc[j])
+					tmp += mpi * mc[j];
+				pres[j] = tmp;
+				k = tmp >> 16;
+			}
+			pres[-1] = k;
 		}
-		pres[-1] = k;
-	}
 
-	if (! (result[0] & 0x8000)) {
+	if (!(result[0] & 0x8000))
+	{
 		e3->exp--;
-		for (i = 0; i <= 3; i++) {
+		for (i = 0; i <= 3; i++)
+		{
 			result[i] <<= 1;
-			if (result[i+1]&0x8000) result[i] |= 1;
+			if (result[i + 1] & 0x8000)
+				result[i] |= 1;
 		}
 		result[4] <<= 1;
-	}	
+	}
 	/*
 	 *	combine the registers to a total
 	 */
 	e3->m1 = ((unsigned long)(result[0]) << 16) + result[1];
 	e3->m2 = ((unsigned long)(result[2]) << 16) + result[3];
-	if (result[4] & 0x8000) {
-		if (++e3->m2 == 0) {
-			if (++e3->m1 == 0) {
+	if (result[4] & 0x8000)
+	{
+		if (++e3->m2 == 0)
+		{
+			if (++e3->m1 == 0)
+			{
 				e3->m1 = 0x80000000;
 				e3->exp++;
 			}
@@ -94,8 +104,7 @@ mul_ext(struct EXTEND *e1, struct EXTEND *e2, struct EXTEND *e3)
 	}
 }
 
-static
-add_ext(struct EXTEND *e1, struct EXTEND *e2, struct EXTEND *e3)
+static add_ext(struct EXTEND* e1, struct EXTEND* e2, struct EXTEND* e3)
 {
 	/*	Add two extended numbers e1 and e2, and put the result
 		in e3
@@ -103,11 +112,13 @@ add_ext(struct EXTEND *e1, struct EXTEND *e2, struct EXTEND *e3)
 	struct EXTEND ce2;
 	int diff;
 
-	if ((e2->m1 | e2->m2) == 0L) {
+	if ((e2->m1 | e2->m2) == 0L)
+	{
 		*e3 = *e1;
 		return;
 	}
-	if ((e1->m1 | e1->m2) == 0L) {
+	if ((e1->m1 | e1->m2) == 0L)
+	{
 		*e3 = *e2;
 		return;
 	}
@@ -117,52 +128,66 @@ add_ext(struct EXTEND *e1, struct EXTEND *e2, struct EXTEND *e3)
 
 	/* adjust mantissas to equal power */
 	diff = e3->exp - e1->exp;
-	if (diff < 0) {
+	if (diff < 0)
+	{
 		diff = -diff;
 		e3->exp += diff;
 		b64_sft(&(e3->mantissa), diff);
 	}
-	else if (diff > 0) {
+	else if (diff > 0)
+	{
 		e1->exp += diff;
 		b64_sft(&(e1->mantissa), diff);
 	}
-	if (e1->sign != e3->sign) {
+	if (e1->sign != e3->sign)
+	{
 		/* e3 + e1 = e3 - (-e1) */
-		if (e1->m1 > e3->m1 ||
-                    (e1->m1 == e3->m1 && e1->m2 > e3->m2)) {
-                	/*      abs(e1) > abs(e3) */
-                	if (e3->m2 > e1->m2) {
-                        	e1->m1 -= 1;    /* carry in */
-                	}
-                	e1->m1 -= e3->m1;
-                	e1->m2 -= e3->m2;
-                	*e3 = *e1;
-        	}
-        	else {
-                	if (e1->m2 > e3->m2)
-                        	e3->m1 -= 1;    /* carry in */
-                	e3->m1 -= e1->m1;
-                	e3->m2 -= e1->m2;
-        	}
-	}
-	else {
-		if (b64_add(&e3->mantissa,&e1->mantissa)) {/* addition carry */
-			b64_sft(&e3->mantissa,1);/* shift mantissa one bit RIGHT */
-			e3->m1 |= 0x80000000L;	/* set max bit	*/
-			e3->exp++;		/* increase the exponent */
+		if (e1->m1 > e3->m1 || (e1->m1 == e3->m1 && e1->m2 > e3->m2))
+		{
+			/*      abs(e1) > abs(e3) */
+			if (e3->m2 > e1->m2)
+			{
+				e1->m1 -= 1; /* carry in */
+			}
+			e1->m1 -= e3->m1;
+			e1->m2 -= e3->m2;
+			*e3 = *e1;
+		}
+		else
+		{
+			if (e1->m2 > e3->m2)
+				e3->m1 -= 1; /* carry in */
+			e3->m1 -= e1->m1;
+			e3->m2 -= e1->m2;
 		}
 	}
-	if ((e3->m2 | e3->m1) != 0L) {
+	else
+	{
+		if (b64_add(&e3->mantissa, &e1->mantissa))
+		{ /* addition carry */
+			b64_sft(&e3->mantissa, 1); /* shift mantissa one bit RIGHT */
+			e3->m1 |= 0x80000000L; /* set max bit	*/
+			e3->exp++; /* increase the exponent */
+		}
+	}
+	if ((e3->m2 | e3->m1) != 0L)
+	{
 		/* normalize */
-		if (e3->m1 == 0L) {
-			e3->m1 = e3->m2; e3->m2 = 0L; e3->exp -= 32;
+		if (e3->m1 == 0L)
+		{
+			e3->m1 = e3->m2;
+			e3->m2 = 0L;
+			e3->exp -= 32;
 		}
-		if (!(e3->m1 & 0x80000000)) {
+		if (!(e3->m1 & 0x80000000))
+		{
 			unsigned long l = 0x40000000;
 			int cnt = -1;
 
-			while (! (l & e3->m1)) {
-				l >>= 1; cnt--;
+			while (!(l & e3->m1))
+			{
+				l >>= 1;
+				cnt--;
 			}
 			e3->exp += cnt;
 			b64_sft(&(e3->mantissa), cnt);
@@ -171,35 +196,41 @@ add_ext(struct EXTEND *e1, struct EXTEND *e2, struct EXTEND *e3)
 }
 
 static int
-cmp_ext(struct EXTEND *e1, struct EXTEND *e2)
+cmp_ext(struct EXTEND* e1, struct EXTEND* e2)
 {
-        struct EXTEND tmp; 
-         
-        e2->sign = ! e2->sign; 
-        add_ext(e1, e2, &tmp);  
-        e2->sign = ! e2->sign;
-        if (tmp.m1 == 0 && tmp.m2 == 0) return 0; 
-        if (tmp.sign) return -1;
-        return 1;
+	struct EXTEND tmp;
+
+	e2->sign = !e2->sign;
+	add_ext(e1, e2, &tmp);
+	e2->sign = !e2->sign;
+	if (tmp.m1 == 0 && tmp.m2 == 0)
+		return 0;
+	if (tmp.sign)
+		return -1;
+	return 1;
 }
 
-static
-b64_sft(struct mantissa *e1, int n)
+static b64_sft(struct mantissa* e1, int n)
 {
-	if (n > 0) {
-		if (n > 63) {
+	if (n > 0)
+	{
+		if (n > 63)
+		{
 			e1->l_32 = 0;
 			e1->h_32 = 0;
 			return;
 		}
-		if (n >= 32) {
+		if (n >= 32)
+		{
 			e1->l_32 = e1->h_32;
 			e1->h_32 = 0;
 			n -= 32;
 		}
-		if (n > 0) {
+		if (n > 0)
+		{
 			e1->l_32 >>= n;
-			if (e1->h_32 != 0) {
+			if (e1->h_32 != 0)
+			{
 				e1->l_32 |= (e1->h_32 << (32 - n));
 				e1->h_32 >>= n;
 			}
@@ -207,20 +238,25 @@ b64_sft(struct mantissa *e1, int n)
 		return;
 	}
 	n = -n;
-	if (n > 0) {
-		if (n > 63) {
+	if (n > 0)
+	{
+		if (n > 63)
+		{
 			e1->l_32 = 0;
 			e1->h_32 = 0;
 			return;
 		}
-		if (n >= 32) {
+		if (n >= 32)
+		{
 			e1->h_32 = e1->l_32;
 			e1->l_32 = 0;
 			n -= 32;
 		}
-		if (n > 0) {
+		if (n > 0)
+		{
 			e1->h_32 <<= n;
-			if (e1->l_32 != 0) {
+			if (e1->l_32 != 0)
+			{
 				e1->h_32 |= (e1->l_32 >> (32 - n));
 				e1->l_32 <<= n;
 			}
@@ -229,25 +265,25 @@ b64_sft(struct mantissa *e1, int n)
 }
 
 static int
-b64_add(struct mantissa *e1, struct mantissa *e2)
-		/*
+b64_add(struct mantissa* e1, struct mantissa* e2)
+/*
 		 * pointers to 64 bit 'registers'
 		 */
 {
-	register int	overflow;
-	int		carry;
+	register int overflow;
+	int carry;
 
-			/* add higher pair of 32 bits */
-	overflow = ((unsigned long) 0xFFFFFFFF - e1->h_32 < e2->h_32);
+	/* add higher pair of 32 bits */
+	overflow = ((unsigned long)0xFFFFFFFF - e1->h_32 < e2->h_32);
 	e1->h_32 += e2->h_32;
 
-			/* add lower pair of 32 bits */
-	carry = ((unsigned long) 0xFFFFFFFF - e1->l_32 < e2->l_32);
+	/* add lower pair of 32 bits */
+	carry = ((unsigned long)0xFFFFFFFF - e1->l_32 < e2->l_32);
 	e1->l_32 += e2->l_32;
 	if ((carry) && (++e1->h_32 == 0))
-		return(1);		/* had a 64 bit overflow */
+		return (1); /* had a 64 bit overflow */
 	else
-		return(overflow);	/* return status from higher add */
+		return (overflow); /* return status from higher add */
 }
 
 /* The following tables can be computed with the following bc(1)
@@ -325,164 +361,172 @@ for (i=1;i<20;i++) {
 0
 
 */
-static struct EXTEND ten_powers[] = {	/* representation of 10 ** i */
-	{ 0,	0,	0x80000000,	0 },
-	{ 0,	3,	0xA0000000,	0 },
-	{ 0,	6,	0xC8000000,	0 },
-	{ 0,	9,	0xFA000000,	0 },
-	{ 0,	13,	0x9C400000,	0 },
-	{ 0,	16,	0xC3500000,	0 },
-	{ 0,	19,	0xF4240000,	0 },
-	{ 0,	23,	0x98968000,	0 },
-	{ 0,	26,	0xBEBC2000,	0 },
-	{ 0,	29,	0xEE6B2800,	0 },
-	{ 0,	33,	0x9502F900,	0 },
-	{ 0,	36,	0xBA43B740,	0 },
-	{ 0,	39,	0xE8D4A510,	0 },
-	{ 0,	43,	0x9184E72A,	0 },
-	{ 0,	46,	0xB5E620F4,	0x80000000 },
-	{ 0,	49,	0xE35FA931,	0xA0000000 },
-	{ 0,	53,	0x8E1BC9BF,	0x04000000 },
-	{ 0,	56,	0xB1A2BC2E,	0xC5000000 },
-	{ 0,	59,	0xDE0B6B3A,	0x76400000 },
-	{ 0,	63,	0x8AC72304,	0x89E80000 },
-	{ 0,	66,	0xAD78EBC5,	0xAC620000 },
-	{ 0,	69,	0xD8D726B7,	0x177A8000 },
-	{ 0,	73,	0x87867832,	0x6EAC9000 },
-	{ 0,	76,	0xA968163F,	0x0A57B400 },
-	{ 0,	79,	0xD3C21BCE,	0xCCEDA100 },
-	{ 0,	83,	0x84595161,	0x401484A0 },
-	{ 0,	86,	0xA56FA5B9,	0x9019A5C8 },
-	{ 0,	89,	0xCECB8F27,	0xF4200F3A }
+static struct EXTEND ten_powers[] = { /* representation of 10 ** i */
+	{ 0, 0, 0x80000000, 0 },
+	{ 0, 3, 0xA0000000, 0 },
+	{ 0, 6, 0xC8000000, 0 },
+	{ 0, 9, 0xFA000000, 0 },
+	{ 0, 13, 0x9C400000, 0 },
+	{ 0, 16, 0xC3500000, 0 },
+	{ 0, 19, 0xF4240000, 0 },
+	{ 0, 23, 0x98968000, 0 },
+	{ 0, 26, 0xBEBC2000, 0 },
+	{ 0, 29, 0xEE6B2800, 0 },
+	{ 0, 33, 0x9502F900, 0 },
+	{ 0, 36, 0xBA43B740, 0 },
+	{ 0, 39, 0xE8D4A510, 0 },
+	{ 0, 43, 0x9184E72A, 0 },
+	{ 0, 46, 0xB5E620F4, 0x80000000 },
+	{ 0, 49, 0xE35FA931, 0xA0000000 },
+	{ 0, 53, 0x8E1BC9BF, 0x04000000 },
+	{ 0, 56, 0xB1A2BC2E, 0xC5000000 },
+	{ 0, 59, 0xDE0B6B3A, 0x76400000 },
+	{ 0, 63, 0x8AC72304, 0x89E80000 },
+	{ 0, 66, 0xAD78EBC5, 0xAC620000 },
+	{ 0, 69, 0xD8D726B7, 0x177A8000 },
+	{ 0, 73, 0x87867832, 0x6EAC9000 },
+	{ 0, 76, 0xA968163F, 0x0A57B400 },
+	{ 0, 79, 0xD3C21BCE, 0xCCEDA100 },
+	{ 0, 83, 0x84595161, 0x401484A0 },
+	{ 0, 86, 0xA56FA5B9, 0x9019A5C8 },
+	{ 0, 89, 0xCECB8F27, 0xF4200F3A }
 };
-static struct EXTEND big_ten_powers[] = {  /* representation of 10 ** (28*i) */
-	{ 0,	0,	0x80000000,	0 },
-	{ 0,	93,	0x813F3978,	0xF8940984 },
-	{ 0,	186,	0x82818F12,	0x81ED44A0 },
-	{ 0,	279,	0x83C7088E,	0x1AAB65DB },
-	{ 0,	372,	0x850FADC0,	0x9923329E },
-	{ 0,	465,	0x865B8692,	0x5B9BC5C2 },
-	{ 0,	558,	0x87AA9AFF,	0x79042287 },
-	{ 0,	651,	0x88FCF317,	0xF22241E2 },
-	{ 0,	744,	0x8A5296FF,	0xE33CC930 },
-	{ 0,	837,	0x8BAB8EEF,	0xB6409C1A },
-	{ 0,	930,	0x8D07E334,	0x55637EB3 },
-	{ 0,	1023,	0x8E679C2F,	0x5E44FF8F },
-	{ 0,	1116,	0x8FCAC257,	0x558EE4E6 },
-	{ 0,	1209,	0x91315E37,	0xDB165AA9 },
-	{ 0,	1302,	0x929B7871,	0xDE7F22B9 },
-	{ 0,	1395,	0x940919BB,	0xD4620B6D },
-	{ 0,	1488,	0x957A4AE1,	0xEBF7F3D4 },
-	{ 0,	1581,	0x96EF14C6,	0x454AA840 },
-	{ 0,	1674,	0x98678061,	0x27ECE4F5 },
-	{ 0,	1767,	0x99E396C1,	0x3A3ACFF2 }
+static struct EXTEND big_ten_powers[] = { /* representation of 10 ** (28*i) */
+	{ 0, 0, 0x80000000, 0 },
+	{ 0, 93, 0x813F3978, 0xF8940984 },
+	{ 0, 186, 0x82818F12, 0x81ED44A0 },
+	{ 0, 279, 0x83C7088E, 0x1AAB65DB },
+	{ 0, 372, 0x850FADC0, 0x9923329E },
+	{ 0, 465, 0x865B8692, 0x5B9BC5C2 },
+	{ 0, 558, 0x87AA9AFF, 0x79042287 },
+	{ 0, 651, 0x88FCF317, 0xF22241E2 },
+	{ 0, 744, 0x8A5296FF, 0xE33CC930 },
+	{ 0, 837, 0x8BAB8EEF, 0xB6409C1A },
+	{ 0, 930, 0x8D07E334, 0x55637EB3 },
+	{ 0, 1023, 0x8E679C2F, 0x5E44FF8F },
+	{ 0, 1116, 0x8FCAC257, 0x558EE4E6 },
+	{ 0, 1209, 0x91315E37, 0xDB165AA9 },
+	{ 0, 1302, 0x929B7871, 0xDE7F22B9 },
+	{ 0, 1395, 0x940919BB, 0xD4620B6D },
+	{ 0, 1488, 0x957A4AE1, 0xEBF7F3D4 },
+	{ 0, 1581, 0x96EF14C6, 0x454AA840 },
+	{ 0, 1674, 0x98678061, 0x27ECE4F5 },
+	{ 0, 1767, 0x99E396C1, 0x3A3ACFF2 }
 };
 
 static struct EXTEND r_ten_powers[] = { /* representation of 10 ** -i */
-	{ 0,	0,	0x80000000,	0 },
-	{ 0,	-4,	0xCCCCCCCC,	0xCCCCCCCD },
-	{ 0,	-7,	0xA3D70A3D,	0x70A3D70A },
-	{ 0,	-10,	0x83126E97,	0x8D4FDF3B },
-	{ 0,	-14,	0xD1B71758,	0xE219652C },
-	{ 0,	-17,	0xA7C5AC47,	0x1B478423 },
-	{ 0,	-20,	0x8637BD05,	0xAF6C69B6 },
-	{ 0,	-24,	0xD6BF94D5,	0xE57A42BC },
-	{ 0,	-27,	0xABCC7711,	0x8461CEFD },
-	{ 0,	-30,	0x89705F41,	0x36B4A597 },
-	{ 0,	-34,	0xDBE6FECE,	0xBDEDD5BF },
-	{ 0,	-37,	0xAFEBFF0B,	0xCB24AAFF },
-	{ 0,	-40,	0x8CBCCC09,	0x6F5088CC },
-	{ 0,	-44,	0xE12E1342,	0x4BB40E13 },
-	{ 0,	-47,	0xB424DC35,	0x095CD80F },
-	{ 0,	-50,	0x901D7CF7,	0x3AB0ACD9 },
-	{ 0,	-54,	0xE69594BE,	0xC44DE15B },
-	{ 0,	-57,	0xB877AA32,	0x36A4B449 },
-	{ 0,	-60,	0x9392EE8E,	0x921D5D07 },
-	{ 0,	-64,	0xEC1E4A7D,	0xB69561A5 },
-	{ 0,	-67,	0xBCE50864,	0x92111AEB },
-	{ 0,	-70,	0x971DA050,	0x74DA7BEF },
-	{ 0,	-74,	0xF1C90080,	0xBAF72CB1 },
-	{ 0,	-77,	0xC16D9A00,	0x95928A27 },
-	{ 0,	-80,	0x9ABE14CD,	0x44753B53 },
-	{ 0,	-84,	0xF79687AE,	0xD3EEC551 },
-	{ 0,	-87,	0xC6120625,	0x76589DDB },
-	{ 0,	-90,	0x9E74D1B7,	0x91E07E48 }
+	{ 0, 0, 0x80000000, 0 },
+	{ 0, -4, 0xCCCCCCCC, 0xCCCCCCCD },
+	{ 0, -7, 0xA3D70A3D, 0x70A3D70A },
+	{ 0, -10, 0x83126E97, 0x8D4FDF3B },
+	{ 0, -14, 0xD1B71758, 0xE219652C },
+	{ 0, -17, 0xA7C5AC47, 0x1B478423 },
+	{ 0, -20, 0x8637BD05, 0xAF6C69B6 },
+	{ 0, -24, 0xD6BF94D5, 0xE57A42BC },
+	{ 0, -27, 0xABCC7711, 0x8461CEFD },
+	{ 0, -30, 0x89705F41, 0x36B4A597 },
+	{ 0, -34, 0xDBE6FECE, 0xBDEDD5BF },
+	{ 0, -37, 0xAFEBFF0B, 0xCB24AAFF },
+	{ 0, -40, 0x8CBCCC09, 0x6F5088CC },
+	{ 0, -44, 0xE12E1342, 0x4BB40E13 },
+	{ 0, -47, 0xB424DC35, 0x095CD80F },
+	{ 0, -50, 0x901D7CF7, 0x3AB0ACD9 },
+	{ 0, -54, 0xE69594BE, 0xC44DE15B },
+	{ 0, -57, 0xB877AA32, 0x36A4B449 },
+	{ 0, -60, 0x9392EE8E, 0x921D5D07 },
+	{ 0, -64, 0xEC1E4A7D, 0xB69561A5 },
+	{ 0, -67, 0xBCE50864, 0x92111AEB },
+	{ 0, -70, 0x971DA050, 0x74DA7BEF },
+	{ 0, -74, 0xF1C90080, 0xBAF72CB1 },
+	{ 0, -77, 0xC16D9A00, 0x95928A27 },
+	{ 0, -80, 0x9ABE14CD, 0x44753B53 },
+	{ 0, -84, 0xF79687AE, 0xD3EEC551 },
+	{ 0, -87, 0xC6120625, 0x76589DDB },
+	{ 0, -90, 0x9E74D1B7, 0x91E07E48 }
 };
 
 static struct EXTEND r_big_ten_powers[] = { /* representation of 10 ** -(28*i) */
-	{ 0,	0,	0x80000000,	0 },
-	{ 0,	-94,	0xFD87B5F2,	0x8300CA0E },
-	{ 0,	-187,	0xFB158592,	0xBE068D2F },
-	{ 0,	-280,	0xF8A95FCF,	0x88747D94 },
-	{ 0,	-373,	0xF64335BC,	0xF065D37D },
-	{ 0,	-466,	0xF3E2F893,	0xDEC3F126 },
-	{ 0,	-559,	0xF18899B1,	0xBC3F8CA2 },
-	{ 0,	-652,	0xEF340A98,	0x172AACE5 },
-	{ 0,	-745,	0xECE53CEC,	0x4A314EBE },
-	{ 0,	-838,	0xEA9C2277,	0x23EE8BCB },
-	{ 0,	-931,	0xE858AD24,	0x8F5C22CA },
-	{ 0,	-1024,	0xE61ACF03,	0x3D1A45DF },
-	{ 0,	-1117,	0xE3E27A44,	0x4D8D98B8 },
-	{ 0,	-1210,	0xE1AFA13A,	0xFBD14D6E },
-	{ 0,	-1303,	0xDF82365C,	0x497B5454 },
-	{ 0,	-1396,	0xDD5A2C3E,	0xAB3097CC },
-	{ 0,	-1489,	0xDB377599,	0xB6074245 },
-	{ 0,	-1582,	0xD91A0545,	0xCDB51186 },
-	{ 0,	-1675,	0xD701CE3B,	0xD387BF48 },
-	{ 0,	-1768,	0xD4EEC394,	0xD6258BF8 }
+	{ 0, 0, 0x80000000, 0 },
+	{ 0, -94, 0xFD87B5F2, 0x8300CA0E },
+	{ 0, -187, 0xFB158592, 0xBE068D2F },
+	{ 0, -280, 0xF8A95FCF, 0x88747D94 },
+	{ 0, -373, 0xF64335BC, 0xF065D37D },
+	{ 0, -466, 0xF3E2F893, 0xDEC3F126 },
+	{ 0, -559, 0xF18899B1, 0xBC3F8CA2 },
+	{ 0, -652, 0xEF340A98, 0x172AACE5 },
+	{ 0, -745, 0xECE53CEC, 0x4A314EBE },
+	{ 0, -838, 0xEA9C2277, 0x23EE8BCB },
+	{ 0, -931, 0xE858AD24, 0x8F5C22CA },
+	{ 0, -1024, 0xE61ACF03, 0x3D1A45DF },
+	{ 0, -1117, 0xE3E27A44, 0x4D8D98B8 },
+	{ 0, -1210, 0xE1AFA13A, 0xFBD14D6E },
+	{ 0, -1303, 0xDF82365C, 0x497B5454 },
+	{ 0, -1396, 0xDD5A2C3E, 0xAB3097CC },
+	{ 0, -1489, 0xDB377599, 0xB6074245 },
+	{ 0, -1582, 0xD91A0545, 0xCDB51186 },
+	{ 0, -1675, 0xD701CE3B, 0xD387BF48 },
+	{ 0, -1768, 0xD4EEC394, 0xD6258BF8 }
 };
 
-#define	TP	(int)(sizeof(ten_powers)/sizeof(ten_powers[0]))
-#define BTP	(int)(sizeof(big_ten_powers)/sizeof(big_ten_powers[0]))
-#define MAX_EXP	(TP * BTP - 1)
+#define TP (int)(sizeof(ten_powers) / sizeof(ten_powers[0]))
+#define BTP (int)(sizeof(big_ten_powers) / sizeof(big_ten_powers[0]))
+#define MAX_EXP (TP * BTP - 1)
 
-static
-add_exponent(struct EXTEND *e, int exp)
+static add_exponent(struct EXTEND* e, int exp)
 {
 	int neg = exp < 0;
 	int divsz, modsz;
 	struct EXTEND x;
 
-	if (neg) exp = -exp;
+	if (neg)
+		exp = -exp;
 	divsz = exp / TP;
 	modsz = exp % TP;
-	if (neg) {
+	if (neg)
+	{
 		mul_ext(e, &r_ten_powers[modsz], &x);
 		mul_ext(&x, &r_big_ten_powers[divsz], e);
 	}
-	else {
+	else
+	{
 		mul_ext(e, &ten_powers[modsz], &x);
 		mul_ext(&x, &big_ten_powers[divsz], e);
 	}
 }
 
-_str_ext_cvt(const char *s, char **ss, struct EXTEND *e)
+_str_ext_cvt(const char* s, char** ss, struct EXTEND* e)
 {
 	/*	Like strtod, but for extended precision */
-	register int	c;
-	int		dotseen = 0;
-	int		digitseen = 0;
-	int		exp = 0;
+	register int c;
+	int dotseen = 0;
+	int digitseen = 0;
+	int exp = 0;
 
-	if (ss) *ss = (char *)s;
-	while (isspace(*s)) s++;
+	if (ss)
+		*ss = (char*)s;
+	while (isspace(*s))
+		s++;
 
 	e->sign = 0;
 	e->exp = 0;
 	e->m1 = e->m2 = 0;
 
 	c = *s;
-	switch(c) {
-	case '-':
-		e->sign = 1;
-	case '+':
-		s++;
+	switch (c)
+	{
+		case '-':
+			e->sign = 1;
+		case '+':
+			s++;
 	}
-	while (c = *s++, isdigit(c) || (c == '.' && ! dotseen++)) {
-		if (c == '.') continue;
+	while (c = *s++, isdigit(c) || (c == '.' && !dotseen++))
+	{
+		if (c == '.')
+			continue;
 		digitseen = 1;
-		if (e->m1 <= (unsigned long)(0xFFFFFFFF)/10) {
-			struct mantissa	a1;
+		if (e->m1 <= (unsigned long)(0xFFFFFFFF) / 10)
+		{
+			struct mantissa a1;
 
 			a1 = e->mantissa;
 			b64_sft(&(e->mantissa), -3);
@@ -492,55 +536,67 @@ _str_ext_cvt(const char *s, char **ss, struct EXTEND *e)
 			a1.l_32 = c - '0';
 			b64_add(&(e->mantissa), &a1);
 		}
-		else exp++;
-		if (dotseen) exp--;
+		else
+			exp++;
+		if (dotseen)
+			exp--;
 	}
-	if (! digitseen) return;
+	if (!digitseen)
+		return;
 
-	if (ss) *ss = (char *)s - 1;
+	if (ss)
+		*ss = (char*)s - 1;
 
-	if (c == 'E' || c == 'e') {
-		int	exp1 = 0;
-		int	sign = 1;
-		int	exp_overflow = 0;
+	if (c == 'E' || c == 'e')
+	{
+		int exp1 = 0;
+		int sign = 1;
+		int exp_overflow = 0;
 
-		switch(*s) {
-		case '-':
-			sign = -1;
-		case '+':
-			s++;
+		switch (*s)
+		{
+			case '-':
+				sign = -1;
+			case '+':
+				s++;
 		}
-		if (c = *s, isdigit(c)) {
-			do {
+		if (c = *s, isdigit(c))
+		{
+			do
+			{
 				int tmp;
 
 				exp1 = 10 * exp1 + (c - '0');
-				if ((tmp = sign * exp1 + exp) > MAX_EXP ||
-				     tmp < -MAX_EXP) {
+				if ((tmp = sign * exp1 + exp) > MAX_EXP || tmp < -MAX_EXP)
+				{
 					exp_overflow = 1;
 				}
 			} while (c = *++s, isdigit(c));
-			if (ss) *ss = (char *)s;
+			if (ss)
+				*ss = (char*)s;
 		}
 		exp += sign * exp1;
-		if (exp_overflow) {
+		if (exp_overflow)
+		{
 			exp = sign * MAX_EXP;
-			if (e->m1 != 0 || e->m2 != 0) errno = ERANGE;
+			if (e->m1 != 0 || e->m2 != 0)
+				errno = ERANGE;
 		}
 	}
-	if (e->m1 == 0 && e->m2 == 0) return;
+	if (e->m1 == 0 && e->m2 == 0)
+		return;
 	e->exp = 63;
-	while (! (e->m1 & 0x80000000)) {
-		b64_sft(&(e->mantissa),-1);
+	while (!(e->m1 & 0x80000000))
+	{
+		b64_sft(&(e->mantissa), -1);
 		e->exp--;
 	}
 	add_exponent(e, exp);
 }
 
-#include	<math.h>
+#include <math.h>
 
-static
-ten_mult(struct EXTEND *e)
+static ten_mult(struct EXTEND* e)
 {
 	struct EXTEND e1 = *e;
 
@@ -552,50 +608,58 @@ ten_mult(struct EXTEND *e)
 #define NDIGITS 128
 #define NSIGNIFICANT 19
 
-char *
-_ext_str_cvt(struct EXTEND *e, int ndigit, int *decpt, int *sign, int ecvtflag)
+char* _ext_str_cvt(struct EXTEND* e, int ndigit, int* decpt, int* sign, int ecvtflag)
 {
 	/*	Like cvt(), but for extended precision */
 
-	static char buf[NDIGITS+1];
+	static char buf[NDIGITS + 1];
 	struct EXTEND m;
-	register char *p = buf;
-	register char *pe;
+	register char* p = buf;
+	register char* pe;
 	int findex = 0;
 
-	if (ndigit < 0) ndigit = 0;
-	if (ndigit > NDIGITS) ndigit = NDIGITS;
+	if (ndigit < 0)
+		ndigit = 0;
+	if (ndigit > NDIGITS)
+		ndigit = NDIGITS;
 	pe = &buf[ndigit];
 	buf[0] = '\0';
 
 	*sign = 0;
-	if (e->sign) {
+	if (e->sign)
+	{
 		*sign = 1;
 		e->sign = 0;
 	}
 
 	*decpt = 0;
-	if (e->m1 != 0) {
-		register struct EXTEND *pp = &big_ten_powers[1];
+	if (e->m1 != 0)
+	{
+		register struct EXTEND* pp = &big_ten_powers[1];
 
-		while(cmp_ext(e,pp) >= 0) {
+		while (cmp_ext(e, pp) >= 0)
+		{
 			pp++;
 			findex = pp - big_ten_powers;
-			if (findex >= BTP) break;
+			if (findex >= BTP)
+				break;
 		}
 		pp--;
 		findex = pp - big_ten_powers;
-		mul_ext(e,&r_big_ten_powers[findex],e);
+		mul_ext(e, &r_big_ten_powers[findex], e);
 		*decpt += findex * TP;
 		pp = &ten_powers[1];
-		while(pp < &ten_powers[TP] && cmp_ext(e, pp) >= 0) pp++;
+		while (pp < &ten_powers[TP] && cmp_ext(e, pp) >= 0)
+			pp++;
 		pp--;
 		findex = pp - ten_powers;
 		*decpt += findex;
 
-		if (cmp_ext(e, &ten_powers[0]) < 0) {
+		if (cmp_ext(e, &ten_powers[0]) < 0)
+		{
 			pp = &r_big_ten_powers[1];
-			while(cmp_ext(e,pp) < 0) pp++;
+			while (cmp_ext(e, pp) < 0)
+				pp++;
 			pp--;
 			findex = pp - r_big_ten_powers;
 			mul_ext(e, &big_ten_powers[findex], e);
@@ -604,31 +668,37 @@ _ext_str_cvt(struct EXTEND *e, int ndigit, int *decpt, int *sign, int ecvtflag)
 			ten_mult(e);
 			(*decpt)--;
 			pp = &r_ten_powers[0];
-			while(cmp_ext(e, pp) < 0) pp++;
+			while (cmp_ext(e, pp) < 0)
+				pp++;
 			findex = pp - r_ten_powers;
 			mul_ext(e, &ten_powers[findex], e);
 			*decpt -= findex;
 			findex = 0;
 		}
-		(*decpt)++;	/* because now value in [1.0, 10.0) */
+		(*decpt)++; /* because now value in [1.0, 10.0) */
 	}
-	if (! ecvtflag) {
+	if (!ecvtflag)
+	{
 		/* for fcvt() we need ndigit digits behind the dot */
 		pe += *decpt;
-		if (pe > &buf[NDIGITS]) pe = &buf[NDIGITS];
+		if (pe > &buf[NDIGITS])
+			pe = &buf[NDIGITS];
 	}
 	m.exp = -62;
 	m.sign = 0;
 	m.m1 = 0xA0000000;
 	m.m2 = 0;
-	while (p <= pe) {
+	while (p <= pe)
+	{
 		struct EXTEND oneminm;
 
-		if (p - pe > NSIGNIFICANT) {
+		if (p - pe > NSIGNIFICANT)
+		{
 			findex = 0;
 			e->m1 = 0;
 		}
-		if (findex) {
+		if (findex)
+		{
 			struct EXTEND tc, oldtc;
 			int count = 0;
 
@@ -637,7 +707,8 @@ _ext_str_cvt(struct EXTEND *e, int ndigit, int *decpt, int *sign, int ecvtflag)
 			oldtc.m1 = 0;
 			oldtc.m2 = 0;
 			tc = ten_powers[findex];
-			while (cmp_ext(e, &tc) >= 0) {
+			while (cmp_ext(e, &tc) >= 0)
+			{
 				oldtc = tc;
 				add_ext(&tc, &ten_powers[findex], &tc);
 				count++;
@@ -648,46 +719,59 @@ _ext_str_cvt(struct EXTEND *e, int ndigit, int *decpt, int *sign, int ecvtflag)
 			findex--;
 			continue;
 		}
-		if (e->m1) {
+		if (e->m1)
+		{
 			m.sign = 1;
 			add_ext(&ten_powers[0], &m, &oneminm);
 			m.sign = 0;
-			if (e->exp >= 0) {
+			if (e->exp >= 0)
+			{
 				struct EXTEND x;
 
-				x.m2 = 0; x.exp = e->exp;
+				x.m2 = 0;
+				x.exp = e->exp;
 				x.sign = 1;
-				x.m1 = e->m1>>(31-e->exp);
+				x.m1 = e->m1 >> (31 - e->exp);
 				*p++ = (x.m1) + '0';
-				x.m1 = x.m1 << (31-e->exp);
+				x.m1 = x.m1 << (31 - e->exp);
 				add_ext(e, &x, e);
 			}
-			else *p++ = '0';
+			else
+				*p++ = '0';
 			/* Check that remainder is still significant */
-			if (cmp_ext(&m, e) > 0 || cmp_ext(e, &oneminm) > 0) {
-				if (e->m1 && e->exp >= -1) *(p-1) += 1;
+			if (cmp_ext(&m, e) > 0 || cmp_ext(e, &oneminm) > 0)
+			{
+				if (e->m1 && e->exp >= -1)
+					*(p - 1) += 1;
 				e->m1 = 0;
 				continue;
 			}
 			ten_mult(&m);
 			ten_mult(e);
 		}
-		else *p++ = '0';
+		else
+			*p++ = '0';
 	}
-	if (pe >= buf) {
+	if (pe >= buf)
+	{
 		p = pe;
-		*p += 5;	/* round of at the end */
-		while (*p > '9') {
+		*p += 5; /* round of at the end */
+		while (*p > '9')
+		{
 			*p = '0';
-			if (p > buf) ++*--p;
-			else {
+			if (p > buf)
+				++*--p;
+			else
+			{
 				*p = '1';
 				++*decpt;
-				if (! ecvtflag) {
+				if (!ecvtflag)
+				{
 					/* maybe add another digit at the end,
 					   because the point was shifted right
 					*/
-					if (pe > buf) *pe = '0';
+					if (pe > buf)
+						*pe = '0';
 					pe++;
 				}
 			}
@@ -697,7 +781,7 @@ _ext_str_cvt(struct EXTEND *e, int ndigit, int *decpt, int *sign, int ecvtflag)
 	return buf;
 }
 
-_dbl_ext_cvt(double value, struct EXTEND *e)
+_dbl_ext_cvt(double value, struct EXTEND* e)
 {
 	/*	Convert double to extended
 	*/
@@ -705,7 +789,8 @@ _dbl_ext_cvt(double value, struct EXTEND *e)
 
 	value = frexp(value, &exponent);
 	e->sign = value < 0.0;
-	if (e->sign) value = -value;
+	if (e->sign)
+		value = -value;
 	e->exp = exponent - 1;
 	value *= 4294967296.0;
 	e->m1 = value;
@@ -717,7 +802,7 @@ _dbl_ext_cvt(double value, struct EXTEND *e)
 static struct EXTEND max_d;
 
 double
-_ext_dbl_cvt(struct EXTEND *e)
+_ext_dbl_cvt(struct EXTEND* e)
 {
 	/*	Convert extended to double
 	*/
@@ -725,19 +810,25 @@ _ext_dbl_cvt(struct EXTEND *e)
 	int sign = e->sign;
 
 	e->sign = 0;
-	if (e->m1 == 0 && e->m2 == 0) {
+	if (e->m1 == 0 && e->m2 == 0)
+	{
 		return 0.0;
 	}
-	if (max_d.exp == 0) {
+	if (max_d.exp == 0)
+	{
 		_dbl_ext_cvt(DBL_MAX, &max_d);
 	}
-	if (cmp_ext(&max_d, e) < 0) {
+	if (cmp_ext(&max_d, e) < 0)
+	{
 		f = HUGE_VAL;
 		errno = ERANGE;
 	}
-	else	f = ldexp((double)e->m1*4294967296.0 + (double)e->m2, e->exp-63);
-	if (sign) f = -f;
-	if (f == 0.0 && (e->m1 != 0 || e->m2 != 0)) {
+	else
+		f = ldexp((double)e->m1 * 4294967296.0 + (double)e->m2, e->exp - 63);
+	if (sign)
+		f = -f;
+	if (f == 0.0 && (e->m1 != 0 || e->m2 != 0))
+	{
 		errno = ERANGE;
 	}
 	return f;
diff --git a/lang/cem/libcc.ansi/stdlib/getenv.c b/lang/cem/libcc.ansi/stdlib/getenv.c
index 592e0c05d..3db5c3797 100644
--- a/lang/cem/libcc.ansi/stdlib/getenv.c
+++ b/lang/cem/libcc.ansi/stdlib/getenv.c
@@ -15,9 +15,9 @@ extern char* _findenv(const char* name, int* offset);
  */
 char* getenv(const char* name)
 {
-    int offset;
+	int offset;
 
-    return(_findenv(name,&offset));
+	return (_findenv(name, &offset));
 }
 
 /*
@@ -31,21 +31,22 @@ char* getenv(const char* name)
  */
 char* _findenv(register const char* name, int* offset)
 {
-    extern char **environ;
-    register int    len;
-    register char **P;
-    register const char *C;
+	extern char** environ;
+	register int len;
+	register char** P;
+	register const char* C;
 
 	if (!environ)
 		return NULL;
 
-    for (C = name,len = 0;*C && *C != '=';++C,++len);
-    for (P = environ;*P;++P)
-        if (!strncmp(*P,name,len))
-            if (*(C = *P + len) == '=') {
-                *offset = P - environ;
-                return (char*)(++C);
-            }
-    return(NULL);
+	for (C = name, len = 0; *C && *C != '='; ++C, ++len)
+		;
+	for (P = environ; *P; ++P)
+		if (!strncmp(*P, name, len))
+			if (*(C = *P + len) == '=')
+			{
+				*offset = P - environ;
+				return (char*)(++C);
+			}
+	return (NULL);
 }
-
diff --git a/lang/cem/libcc.ansi/stdlib/labs.c b/lang/cem/libcc.ansi/stdlib/labs.c
index c19464939..e0acaed86 100644
--- a/lang/cem/libcc.ansi/stdlib/labs.c
+++ b/lang/cem/libcc.ansi/stdlib/labs.c
@@ -4,10 +4,9 @@
  */
 /* $Id$ */
 
-#include	<stdlib.h>
+#include <stdlib.h>
 
-long
-labs(register long l)
+long labs(register long l)
 {
 	return l >= 0 ? l : -l;
 }
diff --git a/lang/cem/libcc.ansi/stdlib/ldiv.c b/lang/cem/libcc.ansi/stdlib/ldiv.c
index 4f2b25eb2..e35c06715 100644
--- a/lang/cem/libcc.ansi/stdlib/ldiv.c
+++ b/lang/cem/libcc.ansi/stdlib/ldiv.c
@@ -4,17 +4,18 @@
  */
 /* $Id$ */
 
-#include	<stdlib.h>
+#include <stdlib.h>
 
 ldiv_t
 ldiv(register long numer, register long denom)
 {
 	ldiv_t r;
 
-	r.quot = numer / denom;		/* might trap if denom == 0 */
+	r.quot = numer / denom; /* might trap if denom == 0 */
 	r.rem = numer % denom;
 
-	if (r.rem != 0 && (numer > 0) != (r.rem > 0)) {
+	if (r.rem != 0 && (numer > 0) != (r.rem > 0))
+	{
 		r.quot++;
 		r.rem -= denom;
 	}
diff --git a/lang/cem/libcc.ansi/stdlib/mblen.c b/lang/cem/libcc.ansi/stdlib/mblen.c
index f3c54a540..4c8f728e9 100644
--- a/lang/cem/libcc.ansi/stdlib/mblen.c
+++ b/lang/cem/libcc.ansi/stdlib/mblen.c
@@ -4,15 +4,16 @@
  */
 /* $Id$ */
 
-#include	<stdlib.h>
-#include	<limits.h>
+#include <stdlib.h>
+#include <limits.h>
 
-#define	CHAR_SHIFT	8
+#define CHAR_SHIFT 8
 
-int
-(mblen)(const char *s, size_t n)
+int(mblen)(const char* s, size_t n)
 {
-	if (s == (const char *)NULL) return 0;	/* no state dependent codings */
-	if (n <= 0) return 0;
+	if (s == (const char*)NULL)
+		return 0; /* no state dependent codings */
+	if (n <= 0)
+		return 0;
 	return (*s != 0);
 }
diff --git a/lang/cem/libcc.ansi/stdlib/mbstowcs.c b/lang/cem/libcc.ansi/stdlib/mbstowcs.c
index e2a6cf362..34d120e60 100644
--- a/lang/cem/libcc.ansi/stdlib/mbstowcs.c
+++ b/lang/cem/libcc.ansi/stdlib/mbstowcs.c
@@ -4,17 +4,17 @@
  */
 /* $Id$ */
 
-#include	<stdlib.h>
+#include <stdlib.h>
 
 size_t
-mbstowcs(register wchar_t *pwcs, register const char *s, size_t n)
+mbstowcs(register wchar_t* pwcs, register const char* s, size_t n)
 {
 	register int i = n;
 
-	while (--i >= 0) {
+	while (--i >= 0)
+	{
 		if (!(*pwcs++ = *s++))
 			return n - i - 1;
 	}
 	return n - i;
 }
-
diff --git a/lang/cem/libcc.ansi/stdlib/mbtowc.c b/lang/cem/libcc.ansi/stdlib/mbtowc.c
index 3b1687c55..8e80ca263 100644
--- a/lang/cem/libcc.ansi/stdlib/mbtowc.c
+++ b/lang/cem/libcc.ansi/stdlib/mbtowc.c
@@ -4,14 +4,16 @@
  */
 /* $Id$ */
 
-#include	<stdlib.h>
-#include	<limits.h>
+#include <stdlib.h>
+#include <limits.h>
 
-int
-mbtowc(wchar_t *pwc, register const char *s, size_t n)
+int mbtowc(wchar_t* pwc, register const char* s, size_t n)
 {
-	if (s == (const char *)NULL) return 0;
-	if (n <= 0) return 0;
-	if (pwc) *pwc = *s;
+	if (s == (const char*)NULL)
+		return 0;
+	if (n <= 0)
+		return 0;
+	if (pwc)
+		*pwc = *s;
 	return (*s != 0);
 }
diff --git a/lang/cem/libcc.ansi/stdlib/putenv.c b/lang/cem/libcc.ansi/stdlib/putenv.c
index a1f94aba4..09412f341 100644
--- a/lang/cem/libcc.ansi/stdlib/putenv.c
+++ b/lang/cem/libcc.ansi/stdlib/putenv.c
@@ -4,39 +4,45 @@
  */
 /* $Id$ */
 
-#include	<stdlib.h>
-#include	<string.h>
+#include <stdlib.h>
+#include <string.h>
 
-#define	ENTRY_INC	10
-#define	rounded(x)	(((x / ENTRY_INC) + 1) * ENTRY_INC)
+#define ENTRY_INC 10
+#define rounded(x) (((x / ENTRY_INC) + 1) * ENTRY_INC)
 
-extern char **environ;
+extern char** environ;
 
-int
-putenv(char *name)
+int putenv(char* name)
 {
-	register char **v = environ;
-	register char *r;
+	register char** v = environ;
+	register char* r;
 	static int size = 0;
 	/* When size != 0, it contains the number of entries in the
 	 * table (including the final NULL pointer). This means that the
 	 * last non-null entry  is environ[size - 2].
 	 */
 
-	if (!name) return 0;
-	if (r = strchr(name, '=')) {
+	if (!name)
+		return 0;
+	if (r = strchr(name, '='))
+	{
 		register const char *p, *q;
 
 		*r = '\0';
 
-		if (v != NULL) {
-			while ((p = *v) != NULL) {
+		if (v != NULL)
+		{
+			while ((p = *v) != NULL)
+			{
 				q = name;
 				while (*q && (*q++ == *p++))
-					/* EMPTY */ ;
-				if (*q || (*p != '=')) {
+					/* EMPTY */;
+				if (*q || (*p != '='))
+				{
 					v++;
-				} else {
+				}
+				else
+				{
 					/* The name was already in the
 					 * environment.
 					 */
@@ -50,23 +56,28 @@ putenv(char *name)
 		v = environ;
 	}
 
-	if (!size) {
-		register char **p;
+	if (!size)
+	{
+		register char** p;
 		register int i = 0;
 
 		if (v)
-			do {
+			do
+			{
 				i++;
 			} while (*v++);
-		if (!(v = malloc(rounded(i) * sizeof(char **))))
+		if (!(v = malloc(rounded(i) * sizeof(char**))))
 			return 1;
 		size = i;
 		p = environ;
 		environ = v;
-		while (*v++ = *p++);		/* copy the environment */
+		while (*v++ = *p++)
+			; /* copy the environment */
 		v = environ;
-	} else if (!(size % ENTRY_INC)) {
-		if (!(v = realloc(environ, rounded(size) * sizeof(char **))))
+	}
+	else if (!(size % ENTRY_INC))
+	{
+		if (!(v = realloc(environ, rounded(size) * sizeof(char**))))
 			return 1;
 		environ = v;
 	}
diff --git a/lang/cem/libcc.ansi/stdlib/qsort.c b/lang/cem/libcc.ansi/stdlib/qsort.c
index c7211fea8..c3129fcff 100644
--- a/lang/cem/libcc.ansi/stdlib/qsort.c
+++ b/lang/cem/libcc.ansi/stdlib/qsort.c
@@ -4,36 +4,38 @@
  */
 /* $Id$ */
 
-#include	<stdlib.h>
+#include <stdlib.h>
 
-static	void qsort1(char *, char *, size_t);
-static	int (*qcompar)(const char *, const char *);
-static	void qexchange(char *, char *, size_t);
-static	void q3exchange(char *, char *, char *, size_t);
+static void qsort1(char*, char*, size_t);
+static int (*qcompar)(const char*, const char*);
+static void qexchange(char*, char*, size_t);
+static void q3exchange(char*, char*, char*, size_t);
 
-void
-qsort(void *base, size_t nel, size_t width,
-      int (*compar)(const void *, const void *))
+void qsort(void* base, size_t nel, size_t width,
+    int (*compar)(const void*, const void*))
 {
 	/* when nel is 0, the expression '(nel - 1) * width' is wrong */
-	if (!nel) return;
-	qcompar = (int (*)(const char *, const char *)) compar;
-	qsort1(base, (char *)base + (nel - 1) * width, width);
+	if (!nel)
+		return;
+	qcompar = (int (*)(const char*, const char*))compar;
+	qsort1(base, (char*)base + (nel - 1) * width, width);
 }
 
 static void
-qsort1(char *a1, char *a2, register size_t width)
+qsort1(char* a1, char* a2, register size_t width)
 {
 	register char *left, *right;
 	register char *lefteq, *righteq;
 	int cmp;
 
-	for (;;) {
-		if (a2 <= a1) return;
+	for (;;)
+	{
+		if (a2 <= a1)
+			return;
 		left = a1;
 		right = a2;
-		lefteq = righteq = a1 + width * (((a2-a1)+width)/(2*width));
-		/*
+		lefteq = righteq = a1 + width * (((a2 - a1) + width) / (2 * width));
+	/*
 		   Pick an element in the middle of the array.
 		   We will collect the equals around it.
 		   "lefteq" and "righteq" indicate the left and right
@@ -41,13 +43,16 @@ qsort1(char *a1, char *a2, register size_t width)
 		   Smaller elements end up left of it, larger elements end
 		   up right of it.
 		*/
-again:
-		while (left < lefteq && (cmp = (*qcompar)(left, lefteq)) <= 0) {
-			if (cmp < 0) {
+	again:
+		while (left < lefteq && (cmp = (*qcompar)(left, lefteq)) <= 0)
+		{
+			if (cmp < 0)
+			{
 				/* leave it where it is */
 				left += width;
 			}
-			else {
+			else
+			{
 				/* equal, so exchange with the element to
 				   the left of the "equal"-interval.
 				*/
@@ -55,11 +60,14 @@ again:
 				qexchange(left, lefteq, width);
 			}
 		}
-		while (right > righteq) {
-			if ((cmp = (*qcompar)(right, righteq)) < 0) {
+		while (right > righteq)
+		{
+			if ((cmp = (*qcompar)(right, righteq)) < 0)
+			{
 				/* smaller, should go to left part
 				*/
-				if (left < lefteq) {
+				if (left < lefteq)
+				{
 					/* yes, we had a larger one at the
 					   left, so we can just exchange
 					*/
@@ -80,16 +88,19 @@ again:
 				lefteq += width;
 				left = lefteq;
 			}
-			else if (cmp == 0) {
+			else if (cmp == 0)
+			{
 				/* equal, so exchange with the element to
 				   the right of the "equal-interval"
 				*/
 				righteq += width;
 				qexchange(right, righteq, width);
 			}
-			else	/* just leave it */ right -= width;
+			else /* just leave it */
+				right -= width;
 		}
-		if (left < lefteq) {
+		if (left < lefteq)
+		{
 			/* larger element to the left, but no more room,
 			   so move the "equal-interval" one place to the
 			   left, and the larger element to the right
@@ -112,12 +123,13 @@ again:
 }
 
 static void
-qexchange(register char *p, register char *q,
-	  register size_t n)
+qexchange(register char* p, register char* q,
+    register size_t n)
 {
 	register int c;
 
-	while (n-- > 0) {
+	while (n-- > 0)
+	{
 		c = *p;
 		*p++ = *q;
 		*q++ = c;
@@ -125,12 +137,13 @@ qexchange(register char *p, register char *q,
 }
 
 static void
-q3exchange(register char *p, register char *q, register char *r,
-	   register size_t n)
+q3exchange(register char* p, register char* q, register char* r,
+    register size_t n)
 {
 	register int c;
 
-	while (n-- > 0) {
+	while (n-- > 0)
+	{
 		c = *p;
 		*p++ = *r;
 		*r++ = *q;
diff --git a/lang/cem/libcc.ansi/stdlib/rand.c b/lang/cem/libcc.ansi/stdlib/rand.c
index 87b5e1b5c..20f72e26b 100644
--- a/lang/cem/libcc.ansi/stdlib/rand.c
+++ b/lang/cem/libcc.ansi/stdlib/rand.c
@@ -4,14 +4,14 @@
  */
 /* $Id$ */
 
-#include	<stdlib.h>
+#include <stdlib.h>
 
 static unsigned long int next = 1;
 
 int rand(void)
 {
 	next = next * 1103515245 + 12345;
-	return (unsigned int)(next/(2 * (RAND_MAX +1L)) % (RAND_MAX+1L));
+	return (unsigned int)(next / (2 * (RAND_MAX + 1L)) % (RAND_MAX + 1L));
 }
 
 void srand(unsigned int seed)
diff --git a/lang/cem/libcc.ansi/stdlib/setenv.c b/lang/cem/libcc.ansi/stdlib/setenv.c
index 086b2118d..e6f7b8d88 100644
--- a/lang/cem/libcc.ansi/stdlib/setenv.c
+++ b/lang/cem/libcc.ansi/stdlib/setenv.c
@@ -8,7 +8,7 @@
 #include <string.h>
 
 extern char* _findenv(const char* name, int* offset);
-extern char **environ;
+extern char** environ;
 
 /*
  * setenv(name,value,rewrite)
@@ -17,71 +17,78 @@ extern char **environ;
  */
 int setenv(register const char* name, register const char* value, int rewrite)
 {
-    static int  alloced = 0;        /* if allocated space before */
-    register char   *C;
-    int l_value,
-        offset;
+	static int alloced = 0; /* if allocated space before */
+	register char* C;
+	int l_value,
+	    offset;
 
-    if (*value == '=')          /* no `=' in value */
-        ++value;
-    l_value = strlen(value);
-    if ((C = _findenv(name,&offset))) { /* find if already exists */
-        if (!rewrite)
-            return(0);
-        if (strlen(C) >= l_value) { /* old larger; copy over */
-            while (*C++ = *value++);
-            return(0);
-        }
-    }
-    else {                  /* create new slot */
-        register int    cnt = 0;
-        register char   **P;
+	if (*value == '=') /* no `=' in value */
+		++value;
+	l_value = strlen(value);
+	if ((C = _findenv(name, &offset)))
+	{ /* find if already exists */
+		if (!rewrite)
+			return (0);
+		if (strlen(C) >= l_value)
+		{ /* old larger; copy over */
+			while (*C++ = *value++)
+				;
+			return (0);
+		}
+	}
+	else
+	{ /* create new slot */
+		register int cnt = 0;
+		register char** P;
 
 		if (environ)
-			for (P = environ;*P;++P,++cnt);
-        if (alloced) {          /* just increase size */
-            environ = (char **)realloc((char *)environ,
-                (unsigned)(sizeof(char *) * (cnt + 2)));
-            if (!environ)
-                return(-1);
-        }
-        else {              /* get new space */
-            alloced = 1;        /* copy old entries into it */
-            P = (char **)malloc((unsigned)(sizeof(char *) *
-                (cnt + 2)));
-            if (!P)
-                return(-1);
-            if (environ)
-				bcopy(environ,P,cnt * sizeof(char *));
-            environ = P;
-        }
-        environ[cnt + 1] = NULL;
-        offset = cnt;
-    }
-    for (C = name;*C && *C != '=';++C); /* no `=' in name */
-    if (!(environ[offset] =         /* name + `=' + value */
-        malloc((unsigned)((int)(C - name) + l_value + 2))))
-        return(-1);
-    for (C = environ[offset];(*C = *name++) && *C != '=';++C);
-    for (*C++ = '=';*C++ = *value++;);
-    return(0);
+			for (P = environ; *P; ++P, ++cnt)
+				;
+		if (alloced)
+		{ /* just increase size */
+			environ = (char**)realloc((char*)environ,
+			    (unsigned)(sizeof(char*) * (cnt + 2)));
+			if (!environ)
+				return (-1);
+		}
+		else
+		{ /* get new space */
+			alloced = 1; /* copy old entries into it */
+			P = (char**)malloc((unsigned)(sizeof(char*) * (cnt + 2)));
+			if (!P)
+				return (-1);
+			if (environ)
+				bcopy(environ, P, cnt * sizeof(char*));
+			environ = P;
+		}
+		environ[cnt + 1] = NULL;
+		offset = cnt;
+	}
+	for (C = name; *C && *C != '='; ++C)
+		; /* no `=' in name */
+	if (!(environ[offset] = /* name + `=' + value */
+	        malloc((unsigned)((int)(C - name) + l_value + 2))))
+		return (-1);
+	for (C = environ[offset]; (*C = *name++) && *C != '='; ++C)
+		;
+	for (*C++ = '='; *C++ = *value++;)
+		;
+	return (0);
 }
 
 /*
  * unsetenv(name) --
  *	Delete environmental variable "name".
  */
-int
-unsetenv(const char* name)
+int unsetenv(const char* name)
 {
-    register char   **P;
-    int offset;
+	register char** P;
+	int offset;
 
-    while (_findenv(name,&offset))      /* if set multiple times */
-        for (P = &environ[offset];;++P)
-            if (!(*P = *(P + 1)))
-                break;
+	while (_findenv(name, &offset)) /* if set multiple times */
+		for (P = &environ[offset];; ++P)
+			if (!(*P = *(P + 1)))
+				break;
 
-    return 0;
+	return 0;
 }
-
diff --git a/lang/cem/libcc.ansi/stdlib/strtod.c b/lang/cem/libcc.ansi/stdlib/strtod.c
index 222a744b9..48f60e200 100644
--- a/lang/cem/libcc.ansi/stdlib/strtod.c
+++ b/lang/cem/libcc.ansi/stdlib/strtod.c
@@ -1,15 +1,15 @@
 /* $Id$ */
 
-#include	<stdlib.h>
-#include	"ext_fmt.h"
+#include <stdlib.h>
+#include "ext_fmt.h"
 
-#ifndef	ACKCONF_NO_STDIO_FLOAT
+#ifndef ACKCONF_NO_STDIO_FLOAT
 
-void _str_ext_cvt(const char *s, char **ss, struct EXTEND *e);
-double _ext_dbl_cvt(struct EXTEND *e);
+void _str_ext_cvt(const char* s, char** ss, struct EXTEND* e);
+double _ext_dbl_cvt(struct EXTEND* e);
 
 double
-strtod(const char *p, char **pp)
+strtod(const char* p, char** pp)
 {
 	struct EXTEND e;
 
diff --git a/lang/cem/libcc.ansi/stdlib/strtol.c b/lang/cem/libcc.ansi/stdlib/strtol.c
index ad9a5166c..ce072d49d 100644
--- a/lang/cem/libcc.ansi/stdlib/strtol.c
+++ b/lang/cem/libcc.ansi/stdlib/strtol.c
@@ -4,30 +4,30 @@
  */
 /* $Id$ */
 
-#include	<ctype.h>
-#include	<errno.h>
-#include	<limits.h>
-#include	<stdlib.h>
+#include <ctype.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdlib.h>
 
 static unsigned long
-string2long(register const char *nptr, char **endptr,
-			int base, int is_signed);
+string2long(register const char* nptr, char** endptr,
+    int base, int is_signed);
 
 long int
-strtol(register const char *nptr, char **endptr, int base)
+strtol(register const char* nptr, char** endptr, int base)
 {
 	return (signed long)string2long(nptr, endptr, base, 1);
 }
 
 unsigned long int
-strtoul(register const char *nptr, char **endptr, int base)
+strtoul(register const char* nptr, char** endptr, int base)
 {
 	return (unsigned long)string2long(nptr, endptr, base, 0);
 }
 
 static unsigned long
-string2long(register const char *nptr, char ** const endptr,
-			int base, int is_signed)
+string2long(register const char* nptr, char** const endptr,
+    int base, int is_signed)
 {
 	register unsigned int v;
 	register unsigned long val = 0;
@@ -35,62 +35,82 @@ string2long(register const char *nptr, char ** const endptr,
 	int ovfl = 0, sign = 1;
 	const char *startnptr = nptr, *nrstart;
 
-	if (endptr) *endptr = (char *)nptr;
-	while (isspace(*nptr)) nptr++;
+	if (endptr)
+		*endptr = (char*)nptr;
+	while (isspace(*nptr))
+		nptr++;
 	c = *nptr;
 
-	if (c == '-' || c == '+') {
-		if (c == '-') sign = -1;
+	if (c == '-' || c == '+')
+	{
+		if (c == '-')
+			sign = -1;
 		nptr++;
 	}
-	nrstart = nptr;			/* start of the number */
+	nrstart = nptr; /* start of the number */
 
 	/* When base is 0, the syntax determines the actual base */
 	if (base == 0)
 		if (*nptr == '0')
-			if (*++nptr == 'x' || *nptr == 'X') {
+			if (*++nptr == 'x' || *nptr == 'X')
+			{
 				base = 16;
 				nptr++;
 			}
-			else	base = 8;
-		else	base = 10;
-	else if (base==16 && *nptr=='0' && (*++nptr =='x' || *nptr =='X'))
+			else
+				base = 8;
+		else
+			base = 10;
+	else if (base == 16 && *nptr == '0' && (*++nptr == 'x' || *nptr == 'X'))
 		nptr++;
 
-	while (isdigit(c = *nptr) || isalpha(c)) {
-		if (!ovfl) {
+	while (isdigit(c = *nptr) || isalpha(c))
+	{
+		if (!ovfl)
+		{
 			if (isalpha(c))
 				v = 10 + (isupper(c) ? c - 'A' : c - 'a');
 			else
 				v = c - '0';
-			if (v >= base) break;
-			if (val > (ULONG_MAX - v) / base) ++ovfl;
-			else val = (val * base) + v;
+			if (v >= base)
+				break;
+			if (val > (ULONG_MAX - v) / base)
+				++ovfl;
+			else
+				val = (val * base) + v;
 		}
 		nptr++;
 	}
-	if (endptr) {
-		if (nrstart == nptr) *endptr = (char *)startnptr;
-		else *endptr = (char *)nptr;
+	if (endptr)
+	{
+		if (nrstart == nptr)
+			*endptr = (char*)startnptr;
+		else
+			*endptr = (char*)nptr;
 	}
 
-	if (!ovfl) {
+	if (!ovfl)
+	{
 		/* Overflow is only possible when converting a signed long.
 		 * The "-(LONG_MIN+1)+(unsigned long) 1" construction is there
 		 * to prevent overflow warnings on -LONG_MIN.
 		 */
 		if (is_signed
-		    && (   (sign < 0 && val > -(LONG_MIN+1)+(unsigned long) 1)
-			|| (sign > 0 && val > LONG_MAX)))
-		    ovfl++;
+		    && ((sign < 0 && val > -(LONG_MIN + 1) + (unsigned long)1)
+		           || (sign > 0 && val > LONG_MAX)))
+			ovfl++;
 	}
 
-	if (ovfl) {
+	if (ovfl)
+	{
 		errno = ERANGE;
 		if (is_signed)
-			if (sign < 0) return LONG_MIN;
-			else return LONG_MAX;
-		else return ULONG_MAX;
+			if (sign < 0)
+				return LONG_MIN;
+			else
+				return LONG_MAX;
+		else
+			return ULONG_MAX;
 	}
 	return (sign * val);
 }
diff --git a/lang/cem/libcc.ansi/stdlib/system.c b/lang/cem/libcc.ansi/stdlib/system.c
index 99a8d6e6a..ba31b0477 100644
--- a/lang/cem/libcc.ansi/stdlib/system.c
+++ b/lang/cem/libcc.ansi/stdlib/system.c
@@ -4,7 +4,7 @@
  */
 /* $Id$ */
 
-#if	defined(_POSIX_SOURCE)
+#if defined(_POSIX_SOURCE)
 #include <sys/types.h>
 #endif
 #include <stdlib.h>
@@ -13,48 +13,55 @@
 extern char** environ;
 
 extern int _fork(void);
-extern int _wait(int *);
+extern int _wait(int*);
 extern void _exit(int);
-extern void _execve(const char *path, const char ** argv, const char ** envp);
+extern void _execve(const char* path, const char** argv, const char** envp);
 extern void _close(int);
 
-#define	FAIL	127
+#define FAIL 127
 
-static const char *exec_tab[] = {
-	"sh",			/* argv[0] */
-	"-c",			/* argument to the shell */
-	NULL,			/* to be filled with user command */
-	NULL			/* terminating NULL */
-	};
+static const char* exec_tab[] = {
+	"sh", /* argv[0] */
+	"-c", /* argument to the shell */
+	NULL, /* to be filled with user command */
+	NULL /* terminating NULL */
+};
 
-int
-system(const char *str)
+int system(const char* str)
 {
 	int pid, exitstatus, waitval;
 	int i;
 
-	if ((pid = _fork()) < 0) return str ? -1 : 0;
+	if ((pid = _fork()) < 0)
+		return str ? -1 : 0;
 
-	if (pid == 0) {
+	if (pid == 0)
+	{
 		for (i = 3; i <= 20; i++)
 			_close(i);
-		if (!str) str = "cd .";		/* just testing for a shell */
-		exec_tab[2] = str;		/* fill in command */
-		_execve("/bin/sh", exec_tab, (char const**) environ);
+		if (!str)
+			str = "cd ."; /* just testing for a shell */
+		exec_tab[2] = str; /* fill in command */
+		_execve("/bin/sh", exec_tab, (char const**)environ);
 		/* get here if execve fails ... */
-		_exit(FAIL);	/* see manual page */
+		_exit(FAIL); /* see manual page */
 	}
-	while ((waitval = _wait(&exitstatus)) != pid) {
-		if (waitval == -1) break;
+	while ((waitval = _wait(&exitstatus)) != pid)
+	{
+		if (waitval == -1)
+			break;
 	}
-	if (waitval == -1) {
+	if (waitval == -1)
+	{
 		/* no child ??? or maybe interrupted ??? */
 		exitstatus = -1;
 	}
-	if (!str) {
-		if (exitstatus == FAIL << 8)		/* execve() failed */
+	if (!str)
+	{
+		if (exitstatus == FAIL << 8) /* execve() failed */
 			exitstatus = 0;
-		else exitstatus = 1;			/* /bin/sh exists */
+		else
+			exitstatus = 1; /* /bin/sh exists */
 	}
 	return exitstatus;
 }
diff --git a/lang/cem/libcc.ansi/stdlib/wcstombs.c b/lang/cem/libcc.ansi/stdlib/wcstombs.c
index fccd626ed..2803b7b2a 100644
--- a/lang/cem/libcc.ansi/stdlib/wcstombs.c
+++ b/lang/cem/libcc.ansi/stdlib/wcstombs.c
@@ -4,16 +4,17 @@
  */
 /* $Id$ */
 
-#include	<stdlib.h>
-#include	<locale.h>
-#include	<limits.h>
+#include <stdlib.h>
+#include <locale.h>
+#include <limits.h>
 
 size_t
-wcstombs(register char *s, register const wchar_t *pwcs, size_t n)
+wcstombs(register char* s, register const wchar_t* pwcs, size_t n)
 {
 	register int i = n;
 
-	while (--i >= 0) {
+	while (--i >= 0)
+	{
 		if (!(*s++ = *pwcs++))
 			break;
 	}
diff --git a/lang/cem/libcc.ansi/stdlib/wctomb.c b/lang/cem/libcc.ansi/stdlib/wctomb.c
index 3322b0d9c..d80f0baf0 100644
--- a/lang/cem/libcc.ansi/stdlib/wctomb.c
+++ b/lang/cem/libcc.ansi/stdlib/wctomb.c
@@ -4,13 +4,13 @@
  */
 /* $Id$ */
 
-#include	<stdlib.h>
-#include	<limits.h>
+#include <stdlib.h>
+#include <limits.h>
 
-int
-wctomb(char *s, wchar_t wchar)
+int wctomb(char* s, wchar_t wchar)
 {
-	if (!s) return 0;		/* no state dependent codings */
+	if (!s)
+		return 0; /* no state dependent codings */
 
 	*s = wchar;
 	return 1;
diff --git a/lang/cem/libcc.ansi/string/memchr.c b/lang/cem/libcc.ansi/string/memchr.c
index 067776b4b..0d891e83d 100644
--- a/lang/cem/libcc.ansi/string/memchr.c
+++ b/lang/cem/libcc.ansi/string/memchr.c
@@ -4,19 +4,21 @@
  */
 /* $Id$ */
 
-#include	<string.h>
+#include <string.h>
 
-void *
-memchr(const void *s, register int c, register size_t n)
+void* memchr(const void* s, register int c, register size_t n)
 {
-	register const unsigned char *s1 = s;
+	register const unsigned char* s1 = s;
 
-	c = (unsigned char) c;
-	if (n) {
+	c = (unsigned char)c;
+	if (n)
+	{
 		n++;
-		while (--n > 0) {
-			if (*s1++ != c) continue;
-			return (void *) --s1;
+		while (--n > 0)
+		{
+			if (*s1++ != c)
+				continue;
+			return (void*)--s1;
 		}
 	}
 	return NULL;
diff --git a/lang/cem/libcc.ansi/string/memcmp.c b/lang/cem/libcc.ansi/string/memcmp.c
index b44eefcf4..625dbaafb 100644
--- a/lang/cem/libcc.ansi/string/memcmp.c
+++ b/lang/cem/libcc.ansi/string/memcmp.c
@@ -4,17 +4,19 @@
  */
 /* $Id$ */
 
-#include	<string.h>
+#include <string.h>
 
-int
-memcmp(const void *s1, const void *s2, size_t n)
+int memcmp(const void* s1, const void* s2, size_t n)
 {
 	register const unsigned char *p1 = s1, *p2 = s2;
 
-	if (n) {
+	if (n)
+	{
 		n++;
-		while (--n > 0) {
-			if (*p1++ == *p2++) continue;
+		while (--n > 0)
+		{
+			if (*p1++ == *p2++)
+				continue;
 			return *--p1 - *--p2;
 		}
 	}
diff --git a/lang/cem/libcc.ansi/string/memcpy.c b/lang/cem/libcc.ansi/string/memcpy.c
index 32d4ba29c..d648815cd 100644
--- a/lang/cem/libcc.ansi/string/memcpy.c
+++ b/lang/cem/libcc.ansi/string/memcpy.c
@@ -4,18 +4,18 @@
  */
 /* $Id$ */
 
-#include	<string.h>
+#include <string.h>
 
-void *
-memcpy(void *s1, const void *s2, register size_t n)
+void* memcpy(void* s1, const void* s2, register size_t n)
 {
-	register char *p1 = s1;
-	register const char *p2 = s2;
+	register char* p1 = s1;
+	register const char* p2 = s2;
 
-
-	if (n) {
+	if (n)
+	{
 		n++;
-		while (--n > 0) {
+		while (--n > 0)
+		{
 			*p1++ = *p2++;
 		}
 	}
diff --git a/lang/cem/libcc.ansi/string/memmove.c b/lang/cem/libcc.ansi/string/memmove.c
index ec1dd8bad..78fbd0c6a 100644
--- a/lang/cem/libcc.ansi/string/memmove.c
+++ b/lang/cem/libcc.ansi/string/memmove.c
@@ -4,26 +4,31 @@
  */
 /* $Id$ */
 
-#include	<string.h>
+#include <string.h>
 
-void *
-memmove(void *s1, const void *s2, register size_t n)
+void* memmove(void* s1, const void* s2, register size_t n)
 {
-	register char *p1 = s1;
-	register const char *p2 = s2;
+	register char* p1 = s1;
+	register const char* p2 = s2;
 
-	if (n>0) {
-		if (p2 <= p1 && p2 + n > p1) {
+	if (n > 0)
+	{
+		if (p2 <= p1 && p2 + n > p1)
+		{
 			/* overlap, copy backwards */
 			p1 += n;
 			p2 += n;
 			n++;
-			while (--n > 0) {
+			while (--n > 0)
+			{
 				*--p1 = *--p2;
 			}
-		} else {
+		}
+		else
+		{
 			n++;
-			while (--n > 0) {
+			while (--n > 0)
+			{
 				*p1++ = *p2++;
 			}
 		}
diff --git a/lang/cem/libcc.ansi/string/memset.c b/lang/cem/libcc.ansi/string/memset.c
index 266b10c07..649f8c783 100644
--- a/lang/cem/libcc.ansi/string/memset.c
+++ b/lang/cem/libcc.ansi/string/memset.c
@@ -4,16 +4,17 @@
  */
 /* $Id$ */
 
-#include	<string.h>
+#include <string.h>
 
-void *
-memset(void *s, register int c, register size_t n)
+void* memset(void* s, register int c, register size_t n)
 {
-	register char *s1 = s;
+	register char* s1 = s;
 
-	if (n>0) {
+	if (n > 0)
+	{
 		n++;
-		while (--n > 0) {
+		while (--n > 0)
+		{
 			*s1++ = c;
 		}
 	}
diff --git a/lang/cem/libcc.ansi/string/strcat.c b/lang/cem/libcc.ansi/string/strcat.c
index 4ef13ea17..613050957 100644
--- a/lang/cem/libcc.ansi/string/strcat.c
+++ b/lang/cem/libcc.ansi/string/strcat.c
@@ -4,17 +4,16 @@
  */
 /* $Id$ */
 
-#include	<string.h>
+#include <string.h>
 
-char *
-strcat(char *ret, register const char *s2)
+char* strcat(char* ret, register const char* s2)
 {
-	register char *s1 = ret;
+	register char* s1 = ret;
 
 	while (*s1++ != '\0')
-		/* EMPTY */ ;
+		/* EMPTY */;
 	s1--;
 	while (*s1++ = *s2++)
-		/* EMPTY */ ;
+		/* EMPTY */;
 	return ret;
 }
diff --git a/lang/cem/libcc.ansi/string/strchr.c b/lang/cem/libcc.ansi/string/strchr.c
index 2e7df4c23..da906e136 100644
--- a/lang/cem/libcc.ansi/string/strchr.c
+++ b/lang/cem/libcc.ansi/string/strchr.c
@@ -4,15 +4,16 @@
  */
 /* $Id$ */
 
-#include	<string.h>
+#include <string.h>
 
-char *
-strchr(register const char *s, register int c)
+char* strchr(register const char* s, register int c)
 {
-	c = (char) c;
+	c = (char)c;
 
-	while (c != *s) {
-		if (*s++ == '\0') return NULL;
+	while (c != *s)
+	{
+		if (*s++ == '\0')
+			return NULL;
 	}
-	return (char *)s;
+	return (char*)s;
 }
diff --git a/lang/cem/libcc.ansi/string/strcmp.c b/lang/cem/libcc.ansi/string/strcmp.c
index bfe801905..12406c956 100644
--- a/lang/cem/libcc.ansi/string/strcmp.c
+++ b/lang/cem/libcc.ansi/string/strcmp.c
@@ -4,17 +4,20 @@
  */
 /* $Id$ */
 
-#include	<string.h>
+#include <string.h>
 
-int
-strcmp(register const char *s1, register const char *s2)
+int strcmp(register const char* s1, register const char* s2)
 {
-	while (*s1 == *s2++) {
-		if (*s1++ == '\0') {
+	while (*s1 == *s2++)
+	{
+		if (*s1++ == '\0')
+		{
 			return 0;
 		}
 	}
-	if (*s1 == '\0') return -1;
-	if (*--s2 == '\0') return 1;
-	return (unsigned char) *s1 - (unsigned char) *s2;
+	if (*s1 == '\0')
+		return -1;
+	if (*--s2 == '\0')
+		return 1;
+	return (unsigned char)*s1 - (unsigned char)*s2;
 }
diff --git a/lang/cem/libcc.ansi/string/strcoll.c b/lang/cem/libcc.ansi/string/strcoll.c
index 8a9b408b6..6e9a634af 100644
--- a/lang/cem/libcc.ansi/string/strcoll.c
+++ b/lang/cem/libcc.ansi/string/strcoll.c
@@ -4,14 +4,15 @@
  */
 /* $Id$ */
 
-#include	<string.h>
-#include	<locale.h>
+#include <string.h>
+#include <locale.h>
 
-int
-strcoll(register const char *s1, register const char *s2)
+int strcoll(register const char* s1, register const char* s2)
 {
-	while (*s1 == *s2++) {
-		if (*s1++ == '\0') {
+	while (*s1 == *s2++)
+	{
+		if (*s1++ == '\0')
+		{
 			return 0;
 		}
 	}
diff --git a/lang/cem/libcc.ansi/string/strcpy.c b/lang/cem/libcc.ansi/string/strcpy.c
index bd77c0d50..652f76376 100644
--- a/lang/cem/libcc.ansi/string/strcpy.c
+++ b/lang/cem/libcc.ansi/string/strcpy.c
@@ -4,15 +4,14 @@
  */
 /* $Id$ */
 
-#include	<string.h>
+#include <string.h>
 
-char *
-strcpy(char *ret, register const char *s2)
+char* strcpy(char* ret, register const char* s2)
 {
-	register char *s1 = ret;
+	register char* s1 = ret;
 
 	while (*s1++ = *s2++)
-		/* EMPTY */ ;
+		/* EMPTY */;
 
 	return ret;
 }
diff --git a/lang/cem/libcc.ansi/string/strcspn.c b/lang/cem/libcc.ansi/string/strcspn.c
index f99a5c441..37b22857e 100644
--- a/lang/cem/libcc.ansi/string/strcspn.c
+++ b/lang/cem/libcc.ansi/string/strcspn.c
@@ -4,16 +4,17 @@
  */
 /* $Id$ */
 
-#include	<string.h>
+#include <string.h>
 
 size_t
-strcspn(const char *string, const char *notin)
+strcspn(const char* string, const char* notin)
 {
 	register const char *s1, *s2;
 
-	for (s1 = string; *s1; s1++) {
-		for(s2 = notin; *s2 != *s1 && *s2; s2++)
-			/* EMPTY */ ;
+	for (s1 = string; *s1; s1++)
+	{
+		for (s2 = notin; *s2 != *s1 && *s2; s2++)
+			/* EMPTY */;
 		if (*s2)
 			break;
 	}
diff --git a/lang/cem/libcc.ansi/string/strdup.c b/lang/cem/libcc.ansi/string/strdup.c
index d197171a9..0e7999ad7 100644
--- a/lang/cem/libcc.ansi/string/strdup.c
+++ b/lang/cem/libcc.ansi/string/strdup.c
@@ -7,12 +7,11 @@
 #include <stdlib.h>
 #include <string.h>
 
-char*
-strdup(const char *s)
+char* strdup(const char* s)
 {
 	int len = strlen(s);
-	char *p = malloc(len+1);
+	char* p = malloc(len + 1);
 	if (p)
-		memcpy(p, s, len+1);
+		memcpy(p, s, len + 1);
 	return p;
 }
diff --git a/lang/cem/libcc.ansi/string/strerror.c b/lang/cem/libcc.ansi/string/strerror.c
index 62f787ce6..c00276ac5 100644
--- a/lang/cem/libcc.ansi/string/strerror.c
+++ b/lang/cem/libcc.ansi/string/strerror.c
@@ -4,19 +4,18 @@
  */
 /* $Id$ */
 
-#include	<string.h>
+#include <string.h>
 
 /*
  * I don't know why, but X3J11 says that strerror() should be in declared
  * in <string.h>.  That is why the function is defined here.
  */
-char *
-strerror(register int errnum)
+char* strerror(register int errnum)
 {
-	extern const char *_sys_errlist[];
+	extern const char* _sys_errlist[];
 	extern const int _sys_nerr;
 
-  	if (errnum < 0 || errnum >= _sys_nerr)
+	if (errnum < 0 || errnum >= _sys_nerr)
 		return "unknown error";
-	return (char *)_sys_errlist[errnum];
+	return (char*)_sys_errlist[errnum];
 }
diff --git a/lang/cem/libcc.ansi/string/strlen.c b/lang/cem/libcc.ansi/string/strlen.c
index 48bee4e9d..acf3a8acf 100644
--- a/lang/cem/libcc.ansi/string/strlen.c
+++ b/lang/cem/libcc.ansi/string/strlen.c
@@ -4,15 +4,15 @@
  */
 /* $Id$ */
 
-#include	<string.h>
+#include <string.h>
 
 size_t
-strlen(const char *org)
+strlen(const char* org)
 {
-	register const char *s = org;
+	register const char* s = org;
 
 	while (*s++)
-		/* EMPTY */ ;
+		/* EMPTY */;
 
 	return --s - org;
 }
diff --git a/lang/cem/libcc.ansi/string/strncat.c b/lang/cem/libcc.ansi/string/strncat.c
index f0b8313c3..77013ccb0 100644
--- a/lang/cem/libcc.ansi/string/strncat.c
+++ b/lang/cem/libcc.ansi/string/strncat.c
@@ -4,22 +4,26 @@
  */
 /* $Id$ */
 
-#include	<string.h>
+#include <string.h>
 
-char *
-strncat(char *ret, register const char *s2, size_t n)
+char* strncat(char* ret, register const char* s2, size_t n)
 {
-	register char *s1 = ret;
+	register char* s1 = ret;
 
-	if (n > 0) {
+	if (n > 0)
+	{
 		while (*s1++)
-			/* EMPTY */ ;
+			/* EMPTY */;
 		s1--;
-		while (*s1++ = *s2++)  {
-			if (--n > 0) continue;
+		while (*s1++ = *s2++)
+		{
+			if (--n > 0)
+				continue;
 			*s1 = '\0';
 			break;
 		}
 		return ret;
-	} else return s1;
+	}
+	else
+		return s1;
 }
diff --git a/lang/cem/libcc.ansi/string/strncmp.c b/lang/cem/libcc.ansi/string/strncmp.c
index 950ede4fe..b0e16b014 100644
--- a/lang/cem/libcc.ansi/string/strncmp.c
+++ b/lang/cem/libcc.ansi/string/strncmp.c
@@ -4,22 +4,26 @@
  */
 /* $Id$ */
 
-#include	<string.h>
+#include <string.h>
 
-int
-strncmp(register const char *s1, register const char *s2, register size_t n)
+int strncmp(register const char* s1, register const char* s2, register size_t n)
 {
-	if (n) {
-		do {
+	if (n)
+	{
+		do
+		{
 			if (*s1 != *s2++)
 				break;
 			if (*s1++ == '\0')
 				return 0;
 		} while (--n > 0);
-		if (n > 0) {
-			if (*s1 == '\0') return -1;
-			if (*--s2 == '\0') return 1;
-			return (unsigned char) *s1 - (unsigned char) *s2;
+		if (n > 0)
+		{
+			if (*s1 == '\0')
+				return -1;
+			if (*--s2 == '\0')
+				return 1;
+			return (unsigned char)*s1 - (unsigned char)*s2;
 		}
 	}
 	return 0;
diff --git a/lang/cem/libcc.ansi/string/strncpy.c b/lang/cem/libcc.ansi/string/strncpy.c
index 0c0bfd625..bdf9129e7 100644
--- a/lang/cem/libcc.ansi/string/strncpy.c
+++ b/lang/cem/libcc.ansi/string/strncpy.c
@@ -4,20 +4,22 @@
  */
 /* $Id$ */
 
-#include	<string.h>
+#include <string.h>
 
-char *
-strncpy(char *ret, register const char *s2, register size_t n)
+char* strncpy(char* ret, register const char* s2, register size_t n)
 {
-	register char *s1 = ret;
+	register char* s1 = ret;
 
-	if (n>0) {
-		while((*s1++ = *s2++) && --n > 0)
-			/* EMPTY */ ;
-		if ((*--s2 == '\0') && --n > 0) {
-			do {
+	if (n > 0)
+	{
+		while ((*s1++ = *s2++) && --n > 0)
+			/* EMPTY */;
+		if ((*--s2 == '\0') && --n > 0)
+		{
+			do
+			{
 				*s1++ = '\0';
-			} while(--n > 0);
+			} while (--n > 0);
 		}
 	}
 	return ret;
diff --git a/lang/cem/libcc.ansi/string/strpbrk.c b/lang/cem/libcc.ansi/string/strpbrk.c
index 98a4fab7e..aa517445d 100644
--- a/lang/cem/libcc.ansi/string/strpbrk.c
+++ b/lang/cem/libcc.ansi/string/strpbrk.c
@@ -4,19 +4,19 @@
  */
 /* $Id$ */
 
-#include	<string.h>
+#include <string.h>
 
-char *
-strpbrk(register const char *string, register const char *brk)
+char* strpbrk(register const char* string, register const char* brk)
 {
-	register const char *s1;
+	register const char* s1;
 
-	while (*string) {
+	while (*string)
+	{
 		for (s1 = brk; *s1 && *s1 != *string; s1++)
-			/* EMPTY */ ;
+			/* EMPTY */;
 		if (*s1)
-			return (char *)string;
+			return (char*)string;
 		string++;
 	}
-	return (char *)NULL;
+	return (char*)NULL;
 }
diff --git a/lang/cem/libcc.ansi/string/strrchr.c b/lang/cem/libcc.ansi/string/strrchr.c
index 964b59f5e..b55ced1cd 100644
--- a/lang/cem/libcc.ansi/string/strrchr.c
+++ b/lang/cem/libcc.ansi/string/strrchr.c
@@ -4,19 +4,19 @@
  */
 /* $Id$ */
 
-#include	<string.h>
+#include <string.h>
 
-char *
-strrchr(register const char *s, int c)
+char* strrchr(register const char* s, int c)
 {
-	register const char *result = NULL;
+	register const char* result = NULL;
 
-	c = (char) c;
+	c = (char)c;
 
-	do {
+	do
+	{
 		if (c == *s)
 			result = s;
 	} while (*s++ != '\0');
 
-	return (char *)result;
+	return (char*)result;
 }
diff --git a/lang/cem/libcc.ansi/string/strspn.c b/lang/cem/libcc.ansi/string/strspn.c
index ceb609f2e..908d6f9ea 100644
--- a/lang/cem/libcc.ansi/string/strspn.c
+++ b/lang/cem/libcc.ansi/string/strspn.c
@@ -4,16 +4,17 @@
  */
 /* $Id$ */
 
-#include	<string.h>
+#include <string.h>
 
 size_t
-strspn(const char *string, const char *in)
+strspn(const char* string, const char* in)
 {
 	register const char *s1, *s2;
 
-	for (s1 = string; *s1; s1++) {
+	for (s1 = string; *s1; s1++)
+	{
 		for (s2 = in; *s2 && *s2 != *s1; s2++)
-			/* EMPTY */ ;
+			/* EMPTY */;
 		if (*s2 == '\0')
 			break;
 	}
diff --git a/lang/cem/libcc.ansi/string/strstr.c b/lang/cem/libcc.ansi/string/strstr.c
index 578223542..2b9b1178d 100644
--- a/lang/cem/libcc.ansi/string/strstr.c
+++ b/lang/cem/libcc.ansi/string/strstr.c
@@ -4,16 +4,16 @@
  */
 /* $Id$ */
 
-#include	<string.h>
+#include <string.h>
 
-char *
-strstr(register const char *s, register const char *wanted)
+char* strstr(register const char* s, register const char* wanted)
 {
 	register const int len = strlen(wanted);
 
-	if (len == 0) return (char *)s;
+	if (len == 0)
+		return (char*)s;
 	while (*s != *wanted || strncmp(s, wanted, len))
 		if (*s++ == '\0')
-			return (char *)NULL;
-	return (char *)s;
+			return (char*)NULL;
+	return (char*)s;
 }
diff --git a/lang/cem/libcc.ansi/string/strtok.c b/lang/cem/libcc.ansi/string/strtok.c
index d2bbbde51..9582ea7c3 100644
--- a/lang/cem/libcc.ansi/string/strtok.c
+++ b/lang/cem/libcc.ansi/string/strtok.c
@@ -4,23 +4,25 @@
  */
 /* $Id$ */
 
-#include	<string.h>
+#include <string.h>
 
-char *
-strtok(register char *string, const char *separators)
+char* strtok(register char* string, const char* separators)
 {
 	register char *s1, *s2;
-	static char *savestring;
+	static char* savestring;
 
-	if (string == NULL) {
+	if (string == NULL)
+	{
 		string = savestring;
-		if (string == NULL) return (char *)NULL;
+		if (string == NULL)
+			return (char*)NULL;
 	}
 
 	s1 = string + strspn(string, separators);
-	if (*s1 == '\0') {
+	if (*s1 == '\0')
+	{
 		savestring = NULL;
-		return (char *)NULL;
+		return (char*)NULL;
 	}
 
 	s2 = strpbrk(s1, separators);
diff --git a/lang/cem/libcc.ansi/string/strxfrm.c b/lang/cem/libcc.ansi/string/strxfrm.c
index 7ce96a9f8..f6163bd5b 100644
--- a/lang/cem/libcc.ansi/string/strxfrm.c
+++ b/lang/cem/libcc.ansi/string/strxfrm.c
@@ -4,18 +4,21 @@
  */
 /* $Id$ */
 
-#include	<string.h>
+#include <string.h>
 
 size_t
-strxfrm(register char *s1, register const char *save, register size_t n)
+strxfrm(register char* s1, register const char* save, register size_t n)
 {
-	register const char *s2 = save;
+	register const char* s2 = save;
 
-	while (*s2) {
-		if (n > 1) {
+	while (*s2)
+	{
+		if (n > 1)
+		{
 			n--;
 			*s1++ = *s2++;
-		} else
+		}
+		else
 			s2++;
 	}
 	if (n > 0)
diff --git a/lang/cem/libcc.ansi/time/asctime.c b/lang/cem/libcc.ansi/time/asctime.c
index 2b0adc9ad..dda8b8006 100644
--- a/lang/cem/libcc.ansi/time/asctime.c
+++ b/lang/cem/libcc.ansi/time/asctime.c
@@ -3,24 +3,25 @@
  */
 /* $Id$ */
 
-#include	<string.h>
-#include	<time.h>
-#include	"loc_time.h"
+#include <string.h>
+#include <time.h>
+#include "loc_time.h"
 
-#define	DATE_STR	"??? ??? ?? ??:??:?? ????\n"
+#define DATE_STR "??? ??? ?? ??:??:?? ????\n"
 
-static char *
-two_digits(register char *pb, int i, int nospace)
+static char*
+two_digits(register char* pb, int i, int nospace)
 {
 	*pb = (i / 10) % 10 + '0';
-	if (!nospace && *pb == '0') *pb = ' ';
+	if (!nospace && *pb == '0')
+		*pb = ' ';
 	pb++;
 	*pb++ = (i % 10) + '0';
 	return ++pb;
 }
 
-static char *
-four_digits(register char *pb, int i)
+static char*
+four_digits(register char* pb, int i)
 {
 	i %= 10000;
 	*pb++ = (i / 1000) + '0';
@@ -32,28 +33,28 @@ four_digits(register char *pb, int i)
 	return ++pb;
 }
 
-char *asctime(const struct tm *timeptr)
+char* asctime(const struct tm* timeptr)
 {
 	static char buf[26];
-	register char *pb = buf;
-	register const char *ps;
+	register char* pb = buf;
+	register const char* ps;
 	register int n;
 
 	strcpy(pb, DATE_STR);
 	ps = _days[timeptr->tm_wday];
 	n = ABB_LEN;
-	while(--n >= 0) *pb++ = *ps++;
+	while (--n >= 0)
+		*pb++ = *ps++;
 	pb++;
 	ps = _months[timeptr->tm_mon];
 	n = ABB_LEN;
-	while(--n >= 0) *pb++ = *ps++;
+	while (--n >= 0)
+		*pb++ = *ps++;
 	pb++;
 	pb = two_digits(
-		    two_digits(
-			    two_digits(two_digits(pb, timeptr->tm_mday, 0)
-					, timeptr->tm_hour, 1)
-			    , timeptr->tm_min, 1)
-		    , timeptr->tm_sec, 1);
+	    two_digits(
+	        two_digits(two_digits(pb, timeptr->tm_mday, 0), timeptr->tm_hour, 1), timeptr->tm_min, 1),
+	    timeptr->tm_sec, 1);
 
 	four_digits(pb, timeptr->tm_year + 1900);
 	return buf;
diff --git a/lang/cem/libcc.ansi/time/clock.c b/lang/cem/libcc.ansi/time/clock.c
index 3c7f81d37..e5d25779f 100644
--- a/lang/cem/libcc.ansi/time/clock.c
+++ b/lang/cem/libcc.ansi/time/clock.c
@@ -3,69 +3,72 @@
  */
 /* $Id$ */
 
-#include	<time.h>
+#include <time.h>
 
-#if	defined(__BSD4_2)
+#if defined(__BSD4_2)
 
-#define	RUSAGE_SELF	0
-#define	RUSAGE_CHILDREN	-1
+#define RUSAGE_SELF 0
+#define RUSAGE_CHILDREN -1
 
-struct rusage {
-	struct timeval ru_utime;	/* user time used */
-	struct timeval ru_stime;	/* system time used */
-	long	ru_maxrss;
-	long	ru_ixrss;		/* integral shared memory size */
-	long	ru_idrss;		/* integral unshared data size */
-	long	ru_isrss;		/* integral unshared stack size */
-	long	ru_minflt;		/* page reclaims */
-	long	ru_majflt;		/* page faults */
-	long	ru_nswap;		/* swaps */
-	long	ru_inblock;		/* block input operations */
-	long	ru_oublock;		/* block output operations */
-	long	ru_msgsnd;		/* messages sent */
-	long	ru_msgrcv;		/* messages received */
-	long	ru_nsignals;		/* signals received */
-	long	ru_nvcsw;		/* voluntary context switches */
-	long	ru_nivcsw;		/* involuntary context switches */
+struct rusage
+{
+	struct timeval ru_utime; /* user time used */
+	struct timeval ru_stime; /* system time used */
+	long ru_maxrss;
+	long ru_ixrss; /* integral shared memory size */
+	long ru_idrss; /* integral unshared data size */
+	long ru_isrss; /* integral unshared stack size */
+	long ru_minflt; /* page reclaims */
+	long ru_majflt; /* page faults */
+	long ru_nswap; /* swaps */
+	long ru_inblock; /* block input operations */
+	long ru_oublock; /* block output operations */
+	long ru_msgsnd; /* messages sent */
+	long ru_msgrcv; /* messages received */
+	long ru_nsignals; /* signals received */
+	long ru_nvcsw; /* voluntary context switches */
+	long ru_nivcsw; /* involuntary context switches */
 };
 
-void _getrusage(int who, struct rusage *rusage);
+void _getrusage(int who, struct rusage* rusage);
 
-#elif	defined(_POSIX_SOURCE) || defined(__USG)
+#elif defined(_POSIX_SOURCE) || defined(__USG)
 
-struct tms {
-	time_t	tms_utime;		/* user time */
-	time_t	tms_stime;		/* system time */
-	time_t	tms_cutime;		/* user time, children */
-	time_t	tms_cstime;		/* system time, children */
+struct tms
+{
+	time_t tms_utime; /* user time */
+	time_t tms_stime; /* system time */
+	time_t tms_cutime; /* user time, children */
+	time_t tms_cstime; /* system time, children */
 };
 
-long _times(struct tms *buffer);
+long _times(struct tms* buffer);
 
-#else					/* Version 7 UNIX */
+#else /* Version 7 UNIX */
 
-struct tbuffer {
+struct tbuffer
+{
 	long proc_user_time;
 	long proc_system_time;
 	long child_user_time;
 	long child_system_time;
 };
 
-long _times(struct tbuffer *buffer);
+long _times(struct tbuffer* buffer);
 
 #endif
 
 clock_t
 clock(void)
 {
-#if	defined(__BSD4_2)
+#if defined(__BSD4_2)
 	struct rusage rusage;
 
 	_getrusage(RUSAGE_SELF, &rusage);
 
 	return (((unsigned long)rusage.ru_utime.tv_sec * CLOCKS_PER_SEC)
-		+ rusage.ru_utime.tv_usec);
-#elif	defined(_POSIX_SOURCE) || defined(__USG)
+	    + rusage.ru_utime.tv_usec);
+#elif defined(_POSIX_SOURCE) || defined(__USG)
 	struct tms tms;
 
 	_times(&tms);
diff --git a/lang/cem/libcc.ansi/time/ctime.c b/lang/cem/libcc.ansi/time/ctime.c
index f7e81b41f..775ef806c 100644
--- a/lang/cem/libcc.ansi/time/ctime.c
+++ b/lang/cem/libcc.ansi/time/ctime.c
@@ -3,10 +3,9 @@
  */
 /* $Id$ */
 
-#include	<time.h>
+#include <time.h>
 
-char *
-(ctime)(const time_t *timer)
+char*(ctime)(const time_t* timer)
 {
 	return asctime(localtime(timer));
 }
diff --git a/lang/cem/libcc.ansi/time/difftime.c b/lang/cem/libcc.ansi/time/difftime.c
index 0ff2d6c3d..cd01e0080 100644
--- a/lang/cem/libcc.ansi/time/difftime.c
+++ b/lang/cem/libcc.ansi/time/difftime.c
@@ -3,15 +3,18 @@
  */
 /* $Id$ */
 
-#include	<time.h>
+#include <time.h>
 
 double
 difftime(time_t time1, time_t time0)
 {
 	/* be careful: time_t may be unsigned */
-	if ((time_t)-1 > 0 && time0 > time1) {
-		return - (double) (time0 - time1);
-	} else {
+	if ((time_t)-1 > 0 && time0 > time1)
+	{
+		return -(double)(time0 - time1);
+	}
+	else
+	{
 		return (double)(time1 - time0);
 	}
 }
diff --git a/lang/cem/libcc.ansi/time/gmtime.c b/lang/cem/libcc.ansi/time/gmtime.c
index 03578a91c..0dcb1c25d 100644
--- a/lang/cem/libcc.ansi/time/gmtime.c
+++ b/lang/cem/libcc.ansi/time/gmtime.c
@@ -3,15 +3,15 @@
  */
 /* $Id$ */
 
-#include	<time.h>
-#include	<limits.h>
-#include	"loc_time.h"
+#include <time.h>
+#include <limits.h>
+#include "loc_time.h"
 
-struct tm *
-gmtime(register const time_t *timer)
+struct tm*
+gmtime(register const time_t* timer)
 {
 	static struct tm br_time;
-	register struct tm *timep = &br_time;
+	register struct tm* timep = &br_time;
 	time_t tim = *timer;
 	register unsigned long dayclock, dayno;
 	int year = EPOCH_YR;
@@ -22,15 +22,17 @@ gmtime(register const time_t *timer)
 	timep->tm_sec = dayclock % 60;
 	timep->tm_min = (dayclock % 3600) / 60;
 	timep->tm_hour = dayclock / 3600;
-	timep->tm_wday = (dayno + 4) % 7;	/* day 0 was a thursday */
-	while (dayno >= YEARSIZE(year)) {
+	timep->tm_wday = (dayno + 4) % 7; /* day 0 was a thursday */
+	while (dayno >= YEARSIZE(year))
+	{
 		dayno -= YEARSIZE(year);
 		year++;
 	}
 	timep->tm_year = year - YEAR0;
 	timep->tm_yday = dayno;
 	timep->tm_mon = 0;
-	while (dayno >= _ytab[LEAPYEAR(year)][timep->tm_mon]) {
+	while (dayno >= _ytab[LEAPYEAR(year)][timep->tm_mon])
+	{
 		dayno -= _ytab[LEAPYEAR(year)][timep->tm_mon];
 		timep->tm_mon++;
 	}
diff --git a/lang/cem/libcc.ansi/time/localtime.c b/lang/cem/libcc.ansi/time/localtime.c
index a475f3a2a..87fd2ad2a 100644
--- a/lang/cem/libcc.ansi/time/localtime.c
+++ b/lang/cem/libcc.ansi/time/localtime.c
@@ -3,8 +3,8 @@
  */
 /* $Id$ */
 
-#include	<time.h>
-#include	"loc_time.h"
+#include <time.h>
+#include "loc_time.h"
 
 /* We must be careful, since an int can't represent all the seconds in a day.
  * Hence the adjustment of minutes when adding timezone and dst information.
@@ -12,20 +12,21 @@
  * Furthermore, it is assumed that both fit into an integer when expressed as
  * minutes (this is about 22 days, so this should not cause any problems). 
  */
-struct tm *
-localtime(const time_t *timer)
+struct tm*
+localtime(const time_t* timer)
 {
-	struct tm *timep;
+	struct tm* timep;
 	unsigned dst;
 
 	_tzset();
-	timep = gmtime(timer);			/* tm->tm_isdst == 0 */
+	timep = gmtime(timer); /* tm->tm_isdst == 0 */
 	timep->tm_min -= _timezone / 60;
 	timep->tm_sec -= _timezone % 60;
 	mktime(timep);
 
 	dst = _dstget(timep);
-	if (dst) {
+	if (dst)
+	{
 		timep->tm_min += dst / 60;
 		timep->tm_sec += dst % 60;
 		mktime(timep);
diff --git a/lang/cem/libcc.ansi/time/misc.c b/lang/cem/libcc.ansi/time/misc.c
index 00da98fa4..8a21fb561 100644
--- a/lang/cem/libcc.ansi/time/misc.c
+++ b/lang/cem/libcc.ansi/time/misc.c
@@ -3,139 +3,141 @@
  */
 /* $Id$ */
 
-#include	<ctype.h>
-#include	<time.h>
-#include	<stdlib.h>
-#include	<string.h>
+#include <ctype.h>
+#include <time.h>
+#include <stdlib.h>
+#include <string.h>
 
-#if	defined(__BSD4_2)
+#if defined(__BSD4_2)
 
-extern int _gettimeofday(struct timeval *tp, struct timezone *tzp);
+extern int _gettimeofday(struct timeval* tp, struct timezone* tzp);
 
-#elif	!defined(_POSIX_SOURCE) && !defined(__USG)
-#if	!defined(_MINIX)		/* MINIX has no ftime() */
-struct timeb {
-	long	time;
+#elif !defined(_POSIX_SOURCE) && !defined(__USG)
+#if !defined(_MINIX) /* MINIX has no ftime() */
+struct timeb
+{
+	long time;
 	unsigned short millitm;
-	short	timezone;
-	short	dstflag;
+	short timezone;
+	short dstflag;
 };
-void _ftime(struct timeb *bp);
+void _ftime(struct timeb* bp);
 #endif
 #endif
 
-#include	"loc_time.h"
+#include "loc_time.h"
 
-#define	RULE_LEN	120
-#define	TZ_LEN		10
+#define RULE_LEN 120
+#define TZ_LEN 10
 
 /* Make sure that the strings do not end up in ROM.
  * These strings probably contain the wrong value, and we cannot obtain the
  * right value from the system. TZ is the only help.
  */
-static char ntstr[TZ_LEN + 1] = "GMT";	/* string for normal time */
-static char dststr[TZ_LEN + 1] = "GDT";	/* string for daylight saving */
+static char ntstr[TZ_LEN + 1] = "GMT"; /* string for normal time */
+static char dststr[TZ_LEN + 1] = "GDT"; /* string for daylight saving */
 
-long	_timezone = 0;
-long	_dst_off = 60 * 60;
-int	_daylight = 0;
-char	*_tzname[2] = {ntstr, dststr};
+long _timezone = 0;
+long _dst_off = 60 * 60;
+int _daylight = 0;
+char* _tzname[2] = { ntstr, dststr };
 
-#if	defined(__USG) || defined(_POSIX_SOURCE)
-char	*tzname[2] = {ntstr, dststr};
+#if defined(__USG) || defined(_POSIX_SOURCE)
+char* tzname[2] = { ntstr, dststr };
 
-#if	defined(__USG)
-long	timezone = 0;
-int	daylight = 0;
+#if defined(__USG)
+long timezone = 0;
+int daylight = 0;
 #endif
 #endif
 
-static struct dsttype {
-	char ds_type;		/* Unknown, Julian, Zero-based or M */
-	int ds_date[3];		/* months, weeks, days */
-	long ds_sec;		/* usually 02:00:00 */
-}	dststart = { 'U', { 0, 0, 0 }, 2 * 60 * 60 }
-	, dstend = { 'U', { 0, 0, 0 }, 2 * 60 * 60 };
+static struct dsttype
+{
+	char ds_type; /* Unknown, Julian, Zero-based or M */
+	int ds_date[3]; /* months, weeks, days */
+	long ds_sec; /* usually 02:00:00 */
+} dststart = { 'U', { 0, 0, 0 }, 2 * 60 * 60 }, dstend = { 'U', { 0, 0, 0 }, 2 * 60 * 60 };
 
-const char *_days[] = {
-			"Sunday", "Monday", "Tuesday", "Wednesday",
-			"Thursday", "Friday", "Saturday"
-		};
+const char* _days[] = {
+	"Sunday", "Monday", "Tuesday", "Wednesday",
+	"Thursday", "Friday", "Saturday"
+};
 
-const char *_months[] = {
-			"January", "February", "March",
-			"April", "May", "June",
-			"July", "August", "September",
-			"October", "November", "December"
-		};
+const char* _months[] = {
+	"January", "February", "March",
+	"April", "May", "June",
+	"July", "August", "September",
+	"October", "November", "December"
+};
 
 const int _ytab[2][12] = {
-		{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
-		{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
-	};
+	{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
+	{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
+};
 
-#if	!defined(_POSIX_SOURCE) && !defined(__USG)
-#define	USE_TABLE	1
+#if !defined(_POSIX_SOURCE) && !defined(__USG)
+#define USE_TABLE 1
 #endif
 
-#if	USE_TABLE
+#if USE_TABLE
 static int usetable = 1;
 
-typedef struct table {
-	const char *tz_name;
+typedef struct table
+{
+	const char* tz_name;
 	const int daylight;
 	const long zoneoffset;
 } TABLE;
 
-#define HOUR(x)	((x) * 60*60)
+#define HOUR(x) ((x)*60 * 60)
 
 static TABLE TimezoneTable[] = {
-	{"GMT", 0,	HOUR(0) },	/* Greenwich Mean */
-	{"BST", 60*60,	HOUR(0) },	/* British Summer */
-	{"WAT", 0,	HOUR(1) },	/* West Africa */
-	{"AT", 0,	HOUR(2) },	/* Azores */
-	{"BST", 0,	HOUR(3) },	/* Brazil Standard */
-	{"NFT", 0,	HOUR(3.5) },	/* Newfoundland */
-	{"NDT", 60*60,	HOUR(3.5) },	/* Newfoundland Daylight */
-	{"AST", 0,	HOUR(4) },	/* Atlantic Standard */
-	{"ADT", 60*60,	HOUR(4) },	/* Atlantic Daylight */
-	{"EST", 0,	HOUR(5) },	/* Eastern Standard */
-	{"EDT", 60*60,	HOUR(5) },	/* Eastern Daylight */
-	{"CST", 0,	HOUR(6) },	/* Central Standard */
-	{"CDT", 60*60,	HOUR(6) },	/* Central Daylight */
-	{"MST", 0,	HOUR(7) },	/* Mountain Standard */
-	{"MDT", 60*60,	HOUR(7) },	/* Mountain Daylight */
-	{"PST", 0,	HOUR(8) },	/* Pacific Standard */
-	{"PDT", 60*60,	HOUR(8) },	/* Pacific Daylight */
-	{"YST", 0,	HOUR(9) },	/* Yukon Standard */
-	{"YDT", 60*60,	HOUR(9) },	/* Yukon Daylight */
-	{"HST", 0,	HOUR(10) },	/* Hawaii Standard */
-	{"HDT", 60*60,	HOUR(10) },	/* Hawaii Daylight */
-	{"NT", 0,	HOUR(11) },	/* Nome */
-	{"IDLW", 0,	HOUR(12) },	/* International Date Line West */
-	{"MET", 0,	-HOUR(1) },	/* Middle European */
-	{"MDT", 60*60,	-HOUR(1) },	/* Middle European Summer */
-	{"EET", 0,	-HOUR(2) },	/* Eastern Europe, USSR Zone 1 */
-	{"BT", 0,	-HOUR(3) },	/* Baghdad, USSR Zone 2 */
-	{"IT", 0,	-HOUR(3.5) },	/* Iran */
-	{"ZP4", 0,	-HOUR(4) },	/* USSR Zone 3 */
-	{"ZP5", 0,	-HOUR(5) },	/* USSR Zone 4 */
-	{"IST", 0,	-HOUR(5.5) },	/* Indian Standard */
-	{"ZP6", 0,	-HOUR(6) },	/* USSR Zone 5 */
-	{"NST", 0,	-HOUR(6.5) },	/* North Sumatra */
-	{"SST", 0,	-HOUR(7) },	/* South Sumatra, USSR Zone 6 */
-	{"WAST", 0,	-HOUR(7) },	/* West Australian Standard */
-	{"WADT", 60*60,	-HOUR(7) },	/* West Australian Daylight */
-	{"JT", 0,	-HOUR(7.5) },	/* Java (3pm in Cronusland!) */
-	{"CCT", 0,	-HOUR(8) },	/* China Coast, USSR Zone 7 */
-	{"JST", 0,	-HOUR(9) },	/* Japan Standard, USSR Zone 8 */
-	{"CAST", 0,	-HOUR(9.5) },	/* Central Australian Standard */
-	{"CADT", 60*60,	-HOUR(9.5) },	/* Central Australian Daylight */
-	{"EAST", 0,	-HOUR(10) },	/* Eastern Australian Standard */
-	{"EADT", 60*60,	-HOUR(10) },	/* Eastern Australian Daylight */
-	{"NZT", 0,	-HOUR(12) },	/* New Zealand */
-	{"NZDT", 60*60,	-HOUR(12) },	/* New Zealand Daylight */
-	{  NULL, 0, 0  }
+	{ "GMT", 0, HOUR(0) }, /* Greenwich Mean */
+	{ "BST", 60 * 60, HOUR(0) }, /* British Summer */
+	{ "WAT", 0, HOUR(1) }, /* West Africa */
+	{ "AT", 0, HOUR(2) }, /* Azores */
+	{ "BST", 0, HOUR(3) }, /* Brazil Standard */
+	{ "NFT", 0, HOUR(3.5) }, /* Newfoundland */
+	{ "NDT", 60 * 60, HOUR(3.5) }, /* Newfoundland Daylight */
+	{ "AST", 0, HOUR(4) }, /* Atlantic Standard */
+	{ "ADT", 60 * 60, HOUR(4) }, /* Atlantic Daylight */
+	{ "EST", 0, HOUR(5) }, /* Eastern Standard */
+	{ "EDT", 60 * 60, HOUR(5) }, /* Eastern Daylight */
+	{ "CST", 0, HOUR(6) }, /* Central Standard */
+	{ "CDT", 60 * 60, HOUR(6) }, /* Central Daylight */
+	{ "MST", 0, HOUR(7) }, /* Mountain Standard */
+	{ "MDT", 60 * 60, HOUR(7) }, /* Mountain Daylight */
+	{ "PST", 0, HOUR(8) }, /* Pacific Standard */
+	{ "PDT", 60 * 60, HOUR(8) }, /* Pacific Daylight */
+	{ "YST", 0, HOUR(9) }, /* Yukon Standard */
+	{ "YDT", 60 * 60, HOUR(9) }, /* Yukon Daylight */
+	{ "HST", 0, HOUR(10) }, /* Hawaii Standard */
+	{ "HDT", 60 * 60, HOUR(10) }, /* Hawaii Daylight */
+	{ "NT", 0, HOUR(11) }, /* Nome */
+	{ "IDLW", 0, HOUR(12) }, /* International Date Line West */
+	{ "MET", 0, -HOUR(1) }, /* Middle European */
+	{ "MDT", 60 * 60, -HOUR(1) }, /* Middle European Summer */
+	{ "EET", 0, -HOUR(2) }, /* Eastern Europe, USSR Zone 1 */
+	{ "BT", 0, -HOUR(3) }, /* Baghdad, USSR Zone 2 */
+	{ "IT", 0, -HOUR(3.5) }, /* Iran */
+	{ "ZP4", 0, -HOUR(4) }, /* USSR Zone 3 */
+	{ "ZP5", 0, -HOUR(5) }, /* USSR Zone 4 */
+	{ "IST", 0, -HOUR(5.5) }, /* Indian Standard */
+	{ "ZP6", 0, -HOUR(6) }, /* USSR Zone 5 */
+	{ "NST", 0, -HOUR(6.5) }, /* North Sumatra */
+	{ "SST", 0, -HOUR(7) }, /* South Sumatra, USSR Zone 6 */
+	{ "WAST", 0, -HOUR(7) }, /* West Australian Standard */
+	{ "WADT", 60 * 60, -HOUR(7) }, /* West Australian Daylight */
+	{ "JT", 0, -HOUR(7.5) }, /* Java (3pm in Cronusland!) */
+	{ "CCT", 0, -HOUR(8) }, /* China Coast, USSR Zone 7 */
+	{ "JST", 0, -HOUR(9) }, /* Japan Standard, USSR Zone 8 */
+	{ "CAST", 0, -HOUR(9.5) }, /* Central Australian Standard */
+	{ "CADT", 60 * 60, -HOUR(9.5) }, /* Central Australian Daylight */
+	{ "EAST", 0, -HOUR(10) }, /* Eastern Australian Standard */
+	{ "EADT", 60 * 60, -HOUR(10) }, /* Eastern Australian Daylight */
+	{ "NZT", 0, -HOUR(12) }, /* New Zealand */
+	{ "NZDT", 60 * 60, -HOUR(12) }, /* New Zealand Daylight */
+	{ NULL, 0, 0 }
 };
 
 /*
@@ -147,155 +149,196 @@ static TABLE TimezoneTable[] = {
 static void
 ZoneFromTable(long timezone)
 {
-	register TABLE *tptr = TimezoneTable;
+	register TABLE* tptr = TimezoneTable;
 
-	while (tptr->tz_name != NULL) {
-		if (tptr->zoneoffset == timezone) {
-			if (tptr->daylight == 0) {
-				strncpy(ntstr,tptr->tz_name, TZ_LEN);
+	while (tptr->tz_name != NULL)
+	{
+		if (tptr->zoneoffset == timezone)
+		{
+			if (tptr->daylight == 0)
+			{
+				strncpy(ntstr, tptr->tz_name, TZ_LEN);
 				ntstr[TZ_LEN] = '\0';
-			} else {
-				strncpy(dststr,tptr->tz_name, TZ_LEN);
+			}
+			else
+			{
+				strncpy(dststr, tptr->tz_name, TZ_LEN);
 				dststr[TZ_LEN] = '\0';
 			}
 		}
 		tptr++;
 	}
 }
-#endif	/* USE_TABLE */
+#endif /* USE_TABLE */
 
-static const char *
-parseZoneName(register char *buf, register const char *p)
+static const char*
+parseZoneName(register char* buf, register const char* p)
 {
 	register int n = 0;
 
-	if (*p == ':') return NULL;
-	while (*p && !isdigit(*p) && *p != ',' && *p != '-' && *p != '+') {
+	if (*p == ':')
+		return NULL;
+	while (*p && !isdigit(*p) && *p != ',' && *p != '-' && *p != '+')
+	{
 		if (n < TZ_LEN)
 			*buf++ = *p;
 		p++;
 		n++;
 	}
-	if (n < 3) return NULL;				/* error */
+	if (n < 3)
+		return NULL; /* error */
 	*buf = '\0';
 	return p;
 }
 
-static const char *
-parseTime(register long *tm, const char *p, register struct dsttype *dst)
+static const char*
+parseTime(register long* tm, const char* p, register struct dsttype* dst)
 {
 	register int n = 0;
-	register const char *q = p;
+	register const char* q = p;
 	char ds_type = (dst ? dst->ds_type : '\0');
 
-	if (dst) dst->ds_type = 'U';
+	if (dst)
+		dst->ds_type = 'U';
 
 	*tm = 0;
-	while(*p >= '0' && *p <= '9') {
+	while (*p >= '0' && *p <= '9')
+	{
 		n = 10 * n + (*p++ - '0');
 	}
-	if (q == p) return NULL;	/* "The hour shall be required" */
-	if (n < 0 || n >= 24)	return NULL;
+	if (q == p)
+		return NULL; /* "The hour shall be required" */
+	if (n < 0 || n >= 24)
+		return NULL;
 	*tm = n * 60 * 60;
-	if (*p == ':') {
+	if (*p == ':')
+	{
 		p++;
 		n = 0;
-		while(*p >= '0' && *p <= '9') {
+		while (*p >= '0' && *p <= '9')
+		{
 			n = 10 * n + (*p++ - '0');
 		}
-		if (q == p) return NULL;	/* format error */
-		if (n < 0 || n >= 60)	return NULL;
+		if (q == p)
+			return NULL; /* format error */
+		if (n < 0 || n >= 60)
+			return NULL;
 		*tm += n * 60;
-		if (*p == ':') {
+		if (*p == ':')
+		{
 			p++;
 			n = 0;
-			while(*p >= '0' && *p <= '9') {
+			while (*p >= '0' && *p <= '9')
+			{
 				n = 10 * n + (*p++ - '0');
 			}
-			if (q == p) return NULL;	/* format error */
-			if (n < 0 || n >= 60)	return NULL;
+			if (q == p)
+				return NULL; /* format error */
+			if (n < 0 || n >= 60)
+				return NULL;
 			*tm += n;
 		}
 	}
-	if (dst) {
+	if (dst)
+	{
 		dst->ds_type = ds_type;
 		dst->ds_sec = *tm;
 	}
 	return p;
 }
 
-static const char *
-parseDate(register char *buf, register const char *p, struct dsttype *dstinfo)
+static const char*
+parseDate(register char* buf, register const char* p, struct dsttype* dstinfo)
 {
-	register const char *q;
+	register const char* q;
 	register int n = 0;
 	int cnt = 0;
-	const int bnds[3][2] =	{	{ 1, 12 },
-					{ 1, 5 },
-					{ 0, 6}
-				 };
+	const int bnds[3][2] = { { 1, 12 },
+		{ 1, 5 },
+		{ 0, 6 } };
 	char ds_type;
 
-	if (*p != 'M') {
-		if (*p == 'J') {
+	if (*p != 'M')
+	{
+		if (*p == 'J')
+		{
 			*buf++ = *p++;
 			ds_type = 'J';
 		}
-		else	ds_type = 'Z';
+		else
+			ds_type = 'Z';
 		q = p;
-		while(*p >= '0' && *p <= '9') {
+		while (*p >= '0' && *p <= '9')
+		{
 			n = 10 * n + (*p - '0');
 			*buf++ = *p++;
 		}
-		if (q == p) return NULL;	/* format error */
-		if (n < (ds_type == 'J') || n > 365) return NULL;
+		if (q == p)
+			return NULL; /* format error */
+		if (n < (ds_type == 'J') || n > 365)
+			return NULL;
 		dstinfo->ds_type = ds_type;
 		dstinfo->ds_date[0] = n;
 		return p;
 	}
 	ds_type = 'M';
-	do {
+	do
+	{
 		*buf++ = *p++;
 		q = p;
 		n = 0;
-		while(*p >= '0' && *p <= '9') {
+		while (*p >= '0' && *p <= '9')
+		{
 			n = 10 * n + (*p - '0');
 			*buf++ = *p++;
 		}
-		if (q == p) return NULL;	/* format error */
-		if (n < bnds[cnt][0] || n > bnds[cnt][1]) return NULL;
+		if (q == p)
+			return NULL; /* format error */
+		if (n < bnds[cnt][0] || n > bnds[cnt][1])
+			return NULL;
 		dstinfo->ds_date[cnt] = n;
 		cnt++;
 	} while (cnt < 3 && *p == '.');
-	if (cnt != 3) return NULL;
+	if (cnt != 3)
+		return NULL;
 	*buf = '\0';
 	dstinfo->ds_type = ds_type;
 	return p;
 }
 
-static const char *
-parseRule(register char *buf, register const char *p)
+static const char*
+parseRule(register char* buf, register const char* p)
 {
 	long tim;
-	register const char *q;
+	register const char* q;
 
-	if (!(p = parseDate(buf, p, &dststart))) return NULL;
+	if (!(p = parseDate(buf, p, &dststart)))
+		return NULL;
 	buf += strlen(buf);
-	if (*p == '/') {
+	if (*p == '/')
+	{
 		q = ++p;
-		if (!(p = parseTime(&tim, p, &dststart))) return NULL;
-		while( p != q) *buf++ = *q++;
+		if (!(p = parseTime(&tim, p, &dststart)))
+			return NULL;
+		while (p != q)
+			*buf++ = *q++;
 	}
-	if (*p != ',') return NULL;
+	if (*p != ',')
+		return NULL;
 	p++;
-	if (!(p = parseDate(buf, p, &dstend))) return NULL;
+	if (!(p = parseDate(buf, p, &dstend)))
+		return NULL;
 	buf += strlen(buf);
-	if (*p == '/') {
+	if (*p == '/')
+	{
 		q = ++p;
-		if (!(p = parseTime(&tim, p, &dstend))) return NULL;
-		while(*buf++ = *q++);
+		if (!(p = parseTime(&tim, p, &dstend)))
+			return NULL;
+		while (*buf++ = *q++)
+			;
 	}
-	if (*p) return NULL;
+	if (*p)
+		return NULL;
 	return p;
 }
 
@@ -304,18 +347,20 @@ parseRule(register char *buf, register const char *p)
  * The function returns as soon as it spots an error.
  */
 static void
-parseTZ(const char *p)
+parseTZ(const char* p)
 {
 	long tz, dst = 60 * 60, sign = 1;
 	static char lastTZ[2 * RULE_LEN];
 	static char buffer[RULE_LEN];
 
-	if (!p) return;
+	if (!p)
+		return;
 
-#if	USE_TABLE
+#if USE_TABLE
 	usetable = 0;
 #endif
-	if (*p == ':') {
+	if (*p == ':')
+	{
 		/*
 		 * According to POSIX, this is implementation defined.
 		 * Since it depends on the particular operating system, we
@@ -324,7 +369,8 @@ parseTZ(const char *p)
 		return;
 	}
 
-	if (!strcmp(lastTZ, p)) return;		/* nothing changed */
+	if (!strcmp(lastTZ, p))
+		return; /* nothing changed */
 
 	*_tzname[0] = '\0';
 	*_tzname[1] = '\0';
@@ -333,43 +379,55 @@ parseTZ(const char *p)
 	dstend.ds_type = 'U';
 	dstend.ds_sec = 2 * 60 * 60;
 
-	if (strlen(p) > 2 * RULE_LEN) return;
+	if (strlen(p) > 2 * RULE_LEN)
+		return;
 	strcpy(lastTZ, p);
 
-	if (!(p = parseZoneName(buffer, p))) return;
+	if (!(p = parseZoneName(buffer, p)))
+		return;
 
-	if (*p == '-') {
+	if (*p == '-')
+	{
 		sign = -1;
 		p++;
-	} else if (*p == '+') p++;
+	}
+	else if (*p == '+')
+		p++;
 
-	if (!(p = parseTime(&tz, p, NULL))) return;
+	if (!(p = parseTime(&tz, p, NULL)))
+		return;
 	tz *= sign;
 	_timezone = tz;
 	strncpy(_tzname[0], buffer, TZ_LEN);
 
-	if (!(_daylight = (*p != '\0'))) return;
+	if (!(_daylight = (*p != '\0')))
+		return;
 
 	buffer[0] = '\0';
-	if (!(p = parseZoneName(buffer, p))) return;
+	if (!(p = parseZoneName(buffer, p)))
+		return;
 	strncpy(_tzname[1], buffer, TZ_LEN);
 
 	buffer[0] = '\0';
 	if (*p && (*p != ','))
-		if (!(p = parseTime(&dst, p, NULL))) return;
-	_dst_off = dst;			/* dst was initialized to 1 hour */
-	if (*p) {
-		if (*p != ',') return;
+		if (!(p = parseTime(&dst, p, NULL)))
+			return;
+	_dst_off = dst; /* dst was initialized to 1 hour */
+	if (*p)
+	{
+		if (*p != ',')
+			return;
 		p++;
-		if (strlen(p) > RULE_LEN) return;
-		if (!(p = parseRule(buffer, p))) return;
+		if (strlen(p) > RULE_LEN)
+			return;
+		if (!(p = parseRule(buffer, p)))
+			return;
 	}
 }
 
-void
-_tzset(void)
+void _tzset(void)
 {
-#if	defined(__BSD4_2)
+#if defined(__BSD4_2)
 
 	struct timeval tv;
 	struct timezone tz;
@@ -378,9 +436,9 @@ _tzset(void)
 	_daylight = tz.tz_dsttime;
 	_timezone = tz.tz_minuteswest * 60L;
 
-#elif	!defined(_POSIX_SOURCE) && !defined(__USG)
+#elif !defined(_POSIX_SOURCE) && !defined(__USG)
 
-#if	!defined(_MINIX)		/* MINIX has no ftime() */
+#if !defined(_MINIX) /* MINIX has no ftime() */
 	struct timeb tim;
 
 	_ftime(&tim);
@@ -388,54 +446,58 @@ _tzset(void)
 	_daylight = tim.dstflag;
 #endif
 
-#endif	/* !_POSIX_SOURCE && !__USG */
+#endif /* !_POSIX_SOURCE && !__USG */
 
-	parseTZ(getenv("TZ"));		/* should go inside #if */
+	parseTZ(getenv("TZ")); /* should go inside #if */
 
-#if	defined(__USG) || defined(_POSIX_SOURCE)
+#if defined(__USG) || defined(_POSIX_SOURCE)
 	tzname[0] = _tzname[0];
 	tzname[1] = _tzname[1];
-#if	defined(__USG)
+#if defined(__USG)
 	timezone = _timezone;
 	daylight = _daylight;
 #endif
-#endif	/* __USG || _POSIX_SOURCE */
+#endif /* __USG || _POSIX_SOURCE */
 }
 
 static int
-last_sunday(register int day, register struct tm *timep)
+last_sunday(register int day, register struct tm* timep)
 {
 	int first = FIRSTSUNDAY(timep);
 
-	if (day >= 58 && LEAPYEAR(YEAR0 + timep->tm_year)) day++;
-	if (day < first) return first;
+	if (day >= 58 && LEAPYEAR(YEAR0 + timep->tm_year))
+		day++;
+	if (day < first)
+		return first;
 	return day - (day - first) % 7;
 }
 
 static int
-date_of(register struct dsttype *dst, struct tm *timep)
+date_of(register struct dsttype* dst, struct tm* timep)
 {
 	int leap = LEAPYEAR(YEAR0 + timep->tm_year);
 	int firstday, tmpday;
 	register int day, month;
 
-	if (dst->ds_type != 'M') {
-		return dst->ds_date[0] -
-			    (dst->ds_type == 'J'
-				&& leap
-				&& dst->ds_date[0] < 58);
+	if (dst->ds_type != 'M')
+	{
+		return dst->ds_date[0] - (dst->ds_type == 'J'
+		                             && leap
+		                             && dst->ds_date[0] < 58);
 	}
 	day = 0;
 	month = 1;
-	while (month < dst->ds_date[0]) {
+	while (month < dst->ds_date[0])
+	{
 		day += _ytab[leap][month - 1];
 		month++;
 	}
 	firstday = (day + FIRSTDAYOF(timep)) % 7;
 	tmpday = day;
 	day += (dst->ds_date[2] - firstday + 7) % 7
-		+ 7 * (dst->ds_date[1] - 1);
-	if (day >= tmpday + _ytab[leap][month]) day -= 7;
+	    + 7 * (dst->ds_date[1] - 1);
+	if (day >= tmpday + _ytab[leap][month])
+		day -= 7;
 	return day;
 }
 
@@ -444,7 +506,7 @@ date_of(register struct dsttype *dst, struct tm *timep)
  * Britain). 
  */
 unsigned
-_dstget(register struct tm *timep)
+_dstget(register struct tm* timep)
 {
 	int begindst, enddst;
 	register struct dsttype *dsts = &dststart, *dste = &dstend;
@@ -454,43 +516,53 @@ _dstget(register struct tm *timep)
 		_tzset();
 
 	timep->tm_isdst = _daylight;
-	if (!_daylight) return 0;
+	if (!_daylight)
+		return 0;
 
 	if (dsts->ds_type != 'U')
 		begindst = date_of(dsts, timep);
-	else begindst = last_sunday(89, timep);	/* last Sun before Apr */
+	else
+		begindst = last_sunday(89, timep); /* last Sun before Apr */
 	if (dste->ds_type != 'U')
 		enddst = date_of(dste, timep);
-	else enddst = last_sunday(272, timep);	/* last Sun in Sep */
+	else
+		enddst = last_sunday(272, timep); /* last Sun in Sep */
 
 	/* assume begindst != enddst (otherwise it would be no use) */
-	if (begindst < enddst) {		/* northern hemisphere */
+	if (begindst < enddst)
+	{ /* northern hemisphere */
 		if (timep->tm_yday > begindst && timep->tm_yday < enddst)
 			do_dst = 1;
-	} else {				/* southern hemisphere */
+	}
+	else
+	{ /* southern hemisphere */
 		if (timep->tm_yday > begindst || timep->tm_yday < enddst)
 			do_dst = 1;
 	}
 
 	if (!do_dst
-	    && (timep->tm_yday == begindst || timep->tm_yday == enddst)) {
-		long dsttranssec;	/* transition when day is this old */
+	    && (timep->tm_yday == begindst || timep->tm_yday == enddst))
+	{
+		long dsttranssec; /* transition when day is this old */
 		long cursec;
 
 		if (timep->tm_yday == begindst)
 			dsttranssec = dsts->ds_sec;
-		else	dsttranssec = dste->ds_sec;
+		else
+			dsttranssec = dste->ds_sec;
 		cursec = ((timep->tm_hour * 60) + timep->tm_min) * 60L
-			    + timep->tm_sec;
+		    + timep->tm_sec;
 
 		if ((timep->tm_yday == begindst && cursec >= dsttranssec)
 		    || (timep->tm_yday == enddst && cursec < dsttranssec))
 			do_dst = 1;
 	}
 #if USE_TABLE
-	if (usetable) ZoneFromTable(_timezone);
+	if (usetable)
+		ZoneFromTable(_timezone);
 #endif
-	if (do_dst) return _dst_off;
+	if (do_dst)
+		return _dst_off;
 	timep->tm_isdst = 0;
 	return 0;
 }
diff --git a/lang/cem/libcc.ansi/time/mktime.c b/lang/cem/libcc.ansi/time/mktime.c
index 6d4008082..174d2c266 100644
--- a/lang/cem/libcc.ansi/time/mktime.c
+++ b/lang/cem/libcc.ansi/time/mktime.c
@@ -3,16 +3,16 @@
  */
 /* $Id$ */
 
-#include	<time.h>
-#include	<limits.h>
-#include	"loc_time.h"
+#include <time.h>
+#include <limits.h>
+#include "loc_time.h"
 
 /* The code assumes that unsigned long can be converted to time_t.
  * A time_t should not be wider than unsigned long, since this would mean
  * that the check for overflow at the end could fail.
  */
 time_t
-mktime(register struct tm *timep)
+mktime(register struct tm* timep)
 {
 	register long day, year;
 	register int tm_year;
@@ -23,88 +23,102 @@ mktime(register struct tm *timep)
 
 	timep->tm_min += timep->tm_sec / 60;
 	timep->tm_sec %= 60;
-	if (timep->tm_sec < 0) {
+	if (timep->tm_sec < 0)
+	{
 		timep->tm_sec += 60;
 		timep->tm_min--;
 	}
 	timep->tm_hour += timep->tm_min / 60;
 	timep->tm_min = timep->tm_min % 60;
-	if (timep->tm_min < 0) {
+	if (timep->tm_min < 0)
+	{
 		timep->tm_min += 60;
 		timep->tm_hour--;
 	}
 	day = timep->tm_hour / 24;
-	timep->tm_hour= timep->tm_hour % 24;
-	if (timep->tm_hour < 0) {
+	timep->tm_hour = timep->tm_hour % 24;
+	if (timep->tm_hour < 0)
+	{
 		timep->tm_hour += 24;
 		day--;
 	}
 	timep->tm_year += timep->tm_mon / 12;
 	timep->tm_mon %= 12;
-	if (timep->tm_mon < 0) {
+	if (timep->tm_mon < 0)
+	{
 		timep->tm_mon += 12;
 		timep->tm_year--;
 	}
 	day += (timep->tm_mday - 1);
-	while (day < 0) {
+	while (day < 0)
+	{
 		day += YEARSIZE(YEAR0 + timep->tm_year - 1);
 		timep->tm_year--;
 	}
-	while (day >= YEARSIZE(YEAR0 + timep->tm_year)) {
+	while (day >= YEARSIZE(YEAR0 + timep->tm_year))
+	{
 		day -= YEARSIZE(YEAR0 + timep->tm_year);
 		timep->tm_year++;
 	}
-	while (day >= _ytab[LEAPYEAR(YEAR0 + timep->tm_year)][timep->tm_mon]) {
+	while (day >= _ytab[LEAPYEAR(YEAR0 + timep->tm_year)][timep->tm_mon])
+	{
 		day -= _ytab[LEAPYEAR(YEAR0 + timep->tm_year)][timep->tm_mon];
-		if (++(timep->tm_mon) == 12) {
+		if (++(timep->tm_mon) == 12)
+		{
 			timep->tm_mon = 0;
 			timep->tm_year++;
 		}
 	}
 	timep->tm_mday = day + 1;
-	_tzset();			/* set timezone and dst info  */
+	_tzset(); /* set timezone and dst info  */
 	year = EPOCH_YR;
-	if (timep->tm_year < year - YEAR0) return (time_t)-1;
+	if (timep->tm_year < year - YEAR0)
+		return (time_t)-1;
 	seconds = 0;
-	day = 0;			/* means days since day 0 now */
+	day = 0; /* means days since day 0 now */
 	overflow = 0;
 
-	/* Assume that when day becomes negative, there will certainly
+/* Assume that when day becomes negative, there will certainly
 	 * be overflow on seconds.
 	 * The check for overflow needs not to be done for leapyears
 	 * divisible by 400.
 	 * The code only works when year (1970) is not a leapyear.
 	 */
-#if	EPOCH_YR != 1970
-#error	EPOCH_YR != 1970
+#if EPOCH_YR != 1970
+#error EPOCH_YR != 1970
 #endif
 	tm_year = timep->tm_year + YEAR0;
 
-	if (LONG_MAX / 365 < tm_year - year) overflow++;
+	if (LONG_MAX / 365 < tm_year - year)
+		overflow++;
 	day = (tm_year - year) * 365;
-	if (LONG_MAX - day < (tm_year - year) / 4 + 1) overflow++;
+	if (LONG_MAX - day < (tm_year - year) / 4 + 1)
+		overflow++;
 	day += (tm_year - year) / 4
-		+ ((tm_year % 4) && tm_year % 4 < year % 4);
+	    + ((tm_year % 4) && tm_year % 4 < year % 4);
 	day -= (tm_year - year) / 100
-		+ ((tm_year % 100) && tm_year % 100 < year % 100);
+	    + ((tm_year % 100) && tm_year % 100 < year % 100);
 	day += (tm_year - year) / 400
-		+ ((tm_year % 400) && tm_year % 400 < year % 400);
+	    + ((tm_year % 400) && tm_year % 400 < year % 400);
 
 	yday = month = 0;
-	while (month < timep->tm_mon) {
+	while (month < timep->tm_mon)
+	{
 		yday += _ytab[LEAPYEAR(tm_year)][month];
 		month++;
 	}
 	yday += (timep->tm_mday - 1);
-	if (day + yday < 0) overflow++;
+	if (day + yday < 0)
+		overflow++;
 	day += yday;
 
 	timep->tm_yday = yday;
-	timep->tm_wday = (day + 4) % 7;		/* day 0 was thursday (4) */
+	timep->tm_wday = (day + 4) % 7; /* day 0 was thursday (4) */
 
 	seconds = ((timep->tm_hour * 60L) + timep->tm_min) * 60L + timep->tm_sec;
 
-	if ((TIME_MAX - seconds) / SECS_DAY < day) overflow++;
+	if ((TIME_MAX - seconds) / SECS_DAY < day)
+		overflow++;
 	seconds += day * SECS_DAY;
 
 	/* Now adjust according to timezone and daylight saving time */
@@ -118,13 +132,17 @@ mktime(register struct tm *timep)
 		dst = _dstget(timep);
 	else if (timep->tm_isdst)
 		dst = _dst_off;
-	else dst = 0;
+	else
+		dst = 0;
 
-	if (dst > seconds) overflow++;	/* dst is always non-negative */
+	if (dst > seconds)
+		overflow++; /* dst is always non-negative */
 	seconds -= dst;
 
-	if (overflow) return (time_t)-1;
+	if (overflow)
+		return (time_t)-1;
 
-	if ((time_t)seconds != seconds) return (time_t)-1;
+	if ((time_t)seconds != seconds)
+		return (time_t)-1;
 	return (time_t)seconds;
 }
diff --git a/lang/cem/libcc.ansi/time/strftime.c b/lang/cem/libcc.ansi/time/strftime.c
index c002d3179..cae3b6eb3 100644
--- a/lang/cem/libcc.ansi/time/strftime.c
+++ b/lang/cem/libcc.ansi/time/strftime.c
@@ -3,17 +3,19 @@
  */
 /* $Id$ */
 
-#include	<time.h>
-#include	"loc_time.h"
+#include <time.h>
+#include "loc_time.h"
 
 /* The width can be -1 in both s_prnt() as in u_prnt(). This
  * indicates that as many characters as needed should be printed.
  */
-static char *
-s_prnt(char *s, size_t maxsize, const char *str, int width)
+static char*
+s_prnt(char* s, size_t maxsize, const char* str, int width)
 {
-	while (width > 0 || (width < 0 && *str)) {
-		if (!maxsize) break;
+	while (width > 0 || (width < 0 && *str))
+	{
+		if (!maxsize)
+			break;
 		*s++ = *str++;
 		maxsize--;
 		width--;
@@ -21,8 +23,8 @@ s_prnt(char *s, size_t maxsize, const char *str, int width)
 	return s;
 }
 
-static char *
-u_prnt(char *s, size_t maxsize, unsigned val, int width)
+static char*
+u_prnt(char* s, size_t maxsize, unsigned val, int width)
 {
 	int c;
 
@@ -30,143 +32,156 @@ u_prnt(char *s, size_t maxsize, unsigned val, int width)
 	val = val / 10;
 	if (--width > 0 || (width < 0 && val != 0))
 		s = u_prnt(s, (maxsize ? maxsize - 1 : 0), val, width);
-	if (maxsize) *s++ = c + '0';
+	if (maxsize)
+		*s++ = c + '0';
 	return s;
 }
 
 size_t
-strftime(char *s, size_t maxsize,
-		const char *format, const struct tm *timeptr)
+strftime(char* s, size_t maxsize,
+    const char* format, const struct tm* timeptr)
 {
 	size_t n;
 	char *firsts, *olds;
 
-	if (!format) return 0;
+	if (!format)
+		return 0;
 
-	_tzset();	/* for %Z conversion */
+	_tzset(); /* for %Z conversion */
 	firsts = s;
-	while (maxsize && *format) {
-		while (maxsize && *format && *format != '%') {
+	while (maxsize && *format)
+	{
+		while (maxsize && *format && *format != '%')
+		{
 			*s++ = *format++;
 			maxsize--;
 		}
-		if (!maxsize || !*format) break;
+		if (!maxsize || !*format)
+			break;
 		format++;
 
 		olds = s;
-		switch (*format++) {
-		case 'a':
-			s = s_prnt(s, maxsize,
-					_days[timeptr->tm_wday], ABB_LEN);
-			maxsize -= s - olds;
-			break;
-		case 'A':
-			s = s_prnt(s, maxsize, _days[timeptr->tm_wday], -1);
-			maxsize -= s - olds;
-			break;
-		case 'b':
-			s = s_prnt(s, maxsize,
-					_months[timeptr->tm_mon], ABB_LEN);
-			maxsize -= s - olds;
-			break;
-		case 'B':
-			s = s_prnt(s, maxsize, _months[timeptr->tm_mon], -1);
-			maxsize -= s - olds;
-			break;
-		case 'c':
-			n = strftime(s, maxsize,
-					"%a %b %d %H:%M:%S %Y", timeptr);
-			if (n) maxsize -= n;
-			else maxsize = 0;
-			s += n;
-			break;
-		case 'd':
-			s = u_prnt(s, maxsize, timeptr->tm_mday, 2);
-			maxsize -= s - olds;
-			break;
-		case 'H':
-			s = u_prnt(s, maxsize, timeptr->tm_hour, 2);
-			maxsize -= s - olds;
-			break;
-		case 'I':
-			s = u_prnt(s, maxsize,
-					(timeptr->tm_hour + 11) % 12 + 1, 2);
-			maxsize -= s - olds;
-			break;
-		case 'j':
-			s = u_prnt(s, maxsize, timeptr->tm_yday + 1, 3);
-			maxsize -= s - olds;
-			break;
-		case 'm':
-			s = u_prnt(s, maxsize, timeptr->tm_mon + 1, 2);
-			maxsize -= s - olds;
-			break;
-		case 'M':
-			s = u_prnt(s, maxsize, timeptr->tm_min, 2);
-			maxsize -= s - olds;
-			break;
-		case 'p':
-			s = s_prnt(s, maxsize,
+		switch (*format++)
+		{
+			case 'a':
+				s = s_prnt(s, maxsize,
+				    _days[timeptr->tm_wday], ABB_LEN);
+				maxsize -= s - olds;
+				break;
+			case 'A':
+				s = s_prnt(s, maxsize, _days[timeptr->tm_wday], -1);
+				maxsize -= s - olds;
+				break;
+			case 'b':
+				s = s_prnt(s, maxsize,
+				    _months[timeptr->tm_mon], ABB_LEN);
+				maxsize -= s - olds;
+				break;
+			case 'B':
+				s = s_prnt(s, maxsize, _months[timeptr->tm_mon], -1);
+				maxsize -= s - olds;
+				break;
+			case 'c':
+				n = strftime(s, maxsize,
+				    "%a %b %d %H:%M:%S %Y", timeptr);
+				if (n)
+					maxsize -= n;
+				else
+					maxsize = 0;
+				s += n;
+				break;
+			case 'd':
+				s = u_prnt(s, maxsize, timeptr->tm_mday, 2);
+				maxsize -= s - olds;
+				break;
+			case 'H':
+				s = u_prnt(s, maxsize, timeptr->tm_hour, 2);
+				maxsize -= s - olds;
+				break;
+			case 'I':
+				s = u_prnt(s, maxsize,
+				    (timeptr->tm_hour + 11) % 12 + 1, 2);
+				maxsize -= s - olds;
+				break;
+			case 'j':
+				s = u_prnt(s, maxsize, timeptr->tm_yday + 1, 3);
+				maxsize -= s - olds;
+				break;
+			case 'm':
+				s = u_prnt(s, maxsize, timeptr->tm_mon + 1, 2);
+				maxsize -= s - olds;
+				break;
+			case 'M':
+				s = u_prnt(s, maxsize, timeptr->tm_min, 2);
+				maxsize -= s - olds;
+				break;
+			case 'p':
+				s = s_prnt(s, maxsize,
 				    (timeptr->tm_hour < 12) ? "AM" : "PM", 2);
-			maxsize -= s - olds;
-			break;
-		case 'S':
-			s = u_prnt(s, maxsize, timeptr->tm_sec, 2);
-			maxsize -= s - olds;
-			break;
-		case 'U':
-			s = u_prnt(s, maxsize,		/* ??? */
-			    (timeptr->tm_yday + 7 - timeptr->tm_wday) / 7, 2);
-			maxsize -= s - olds;
-			break;
-		case 'w':
-			s = u_prnt(s, maxsize, timeptr->tm_wday, 1);
-			maxsize -= s - olds;
-			break;
-		case 'W':
-			s = u_prnt(s, maxsize,		/* ??? */
-			    (timeptr->tm_yday+7-(timeptr->tm_wday+6)%7)/7,2);
-			maxsize -= s - olds;
-			break;
-		case 'x':
-			n = strftime(s, maxsize, "%a %b %d %Y", timeptr);
-			if (n) maxsize -= n;
-			else maxsize = 0;
-			s += n;
-			break;
-		case 'X':
-			n = strftime(s, maxsize, "%H:%M:%S", timeptr);
-			if (n) maxsize -= n;
-			else maxsize = 0;
-			s += n;
-			break;
-		case 'y':
-			s = u_prnt(s, maxsize, timeptr->tm_year % 100, 2);
-			maxsize -= s - olds;
-			break;
-		case 'Y':
-			s = u_prnt(s, maxsize, timeptr->tm_year + YEAR0, -1);
-			maxsize -= s - olds;
-			break;
-		case 'Z':
-			s = s_prnt(s, maxsize,
-					_tzname[(timeptr->tm_isdst > 0)], -1);
-			maxsize -= s - olds;
-			break;
-		case '%':
-			*s++ = '%';
-			maxsize--;
-			break;
-		default:
-			/* A conversion error. Leave the loop. */
-			while (*format) format++;
-			break;
+				maxsize -= s - olds;
+				break;
+			case 'S':
+				s = u_prnt(s, maxsize, timeptr->tm_sec, 2);
+				maxsize -= s - olds;
+				break;
+			case 'U':
+				s = u_prnt(s, maxsize, /* ??? */
+				    (timeptr->tm_yday + 7 - timeptr->tm_wday) / 7, 2);
+				maxsize -= s - olds;
+				break;
+			case 'w':
+				s = u_prnt(s, maxsize, timeptr->tm_wday, 1);
+				maxsize -= s - olds;
+				break;
+			case 'W':
+				s = u_prnt(s, maxsize, /* ??? */
+				    (timeptr->tm_yday + 7 - (timeptr->tm_wday + 6) % 7) / 7, 2);
+				maxsize -= s - olds;
+				break;
+			case 'x':
+				n = strftime(s, maxsize, "%a %b %d %Y", timeptr);
+				if (n)
+					maxsize -= n;
+				else
+					maxsize = 0;
+				s += n;
+				break;
+			case 'X':
+				n = strftime(s, maxsize, "%H:%M:%S", timeptr);
+				if (n)
+					maxsize -= n;
+				else
+					maxsize = 0;
+				s += n;
+				break;
+			case 'y':
+				s = u_prnt(s, maxsize, timeptr->tm_year % 100, 2);
+				maxsize -= s - olds;
+				break;
+			case 'Y':
+				s = u_prnt(s, maxsize, timeptr->tm_year + YEAR0, -1);
+				maxsize -= s - olds;
+				break;
+			case 'Z':
+				s = s_prnt(s, maxsize,
+				    _tzname[(timeptr->tm_isdst > 0)], -1);
+				maxsize -= s - olds;
+				break;
+			case '%':
+				*s++ = '%';
+				maxsize--;
+				break;
+			default:
+				/* A conversion error. Leave the loop. */
+				while (*format)
+					format++;
+				break;
 		}
-
 	}
-	if (maxsize) {
+	if (maxsize)
+	{
 		*s = '\0';
 		return s - firsts;
 	}
-	return 0;	/* The buffer is full */
+	return 0; /* The buffer is full */
 }
diff --git a/lang/cem/libcc.ansi/time/time.c b/lang/cem/libcc.ansi/time/time.c
index f4def4c98..1379723a3 100644
--- a/lang/cem/libcc.ansi/time/time.c
+++ b/lang/cem/libcc.ansi/time/time.c
@@ -11,13 +11,14 @@
 #ifndef ACKCONF_TIME_IS_A_SYSCALL
 
 time_t
-time(time_t *timer)
+time(time_t* timer)
 {
 	struct timeval tv;
 	struct timezone tz;
 	gettimeofday(&tv, &tz);
 
-	if (timer) *timer = tv.tv_sec;
+	if (timer)
+		*timer = tv.tv_sec;
 	return tv.tv_sec;
 }
 
diff --git a/lang/cem/libcc.ansi/time/tzset.c b/lang/cem/libcc.ansi/time/tzset.c
index 04d498db8..94b38d6d5 100644
--- a/lang/cem/libcc.ansi/time/tzset.c
+++ b/lang/cem/libcc.ansi/time/tzset.c
@@ -5,11 +5,10 @@
 
 /* This function is present for System V && POSIX */
 
-#include	<time.h>
-#include	"loc_time.h"
+#include <time.h>
+#include "loc_time.h"
 
-void
-tzset(void)
+void tzset(void)
 {
-	_tzset();	/* does the job */
+	_tzset(); /* does the job */
 }