Reformat.

Author: davidgiven

modules/src/alloc/Salloc.c

@@ -7,25 +7,25 @@
 
 /*	The memory allocation routines offered in this file are:
 
-	char *Salloc(str, n)	: allocate n bytes, initialized with the string
-					str
+    char *Salloc(str, n)	: allocate n bytes, initialized with the string
+                    str
 */
 
 #if __STDC__
 #include <stdlib.h>
 #else
-extern char *malloc();
+extern char* malloc();
 #endif
 
-#include	"alloc.h"
+#include "alloc.h"
 
-char *Salloc(char *str, unsigned int sz)
+char* Salloc(char* str, unsigned int sz)
 {
 	/*	Salloc() is not a primitive function: it just allocates a
-		piece of storage and copies a given string into it.
+	    piece of storage and copies a given string into it.
 	*/
-	char *res = malloc(sz);
-	char *m = res;
+	char* res = malloc(sz);
+	char* m = res;
 
 	while (sz--)
 		*m++ = *str++;

modules/src/alloc/alloc.h

@@ -8,35 +8,32 @@
 /*	PROGRAM'S INTERFACE TO MEMORY ALLOCATION ROUTINES		*/
 
 /*	This file serves as the interface between the program and the
-	memory allocating routines.
-	There are 3 memory allocation routines:
-		char *malloc(n)		allocate n bytes
-		char *Salloc(str, n)	allocate n bytes and fill them with
-					string str
+    memory allocating routines.
+    There are 3 memory allocation routines:
+        char *malloc(n)		allocate n bytes
+        char *Salloc(str, n)	allocate n bytes and fill them with
+                    string str
 */
 
-char *Salloc(char *, unsigned int);
-char *st_alloc(char **, unsigned int, int);
-char *std_alloc(char **, unsigned int, int, int *);
-void clear(char *, unsigned int);
-void botch(char *, unsigned int);
+char* Salloc(char*, unsigned int);
+char* st_alloc(char**, unsigned int, int);
+char* std_alloc(char**, unsigned int, int, int*);
+void clear(char*, unsigned int);
+void botch(char*, unsigned int);
 
 /*	S T R U C T U R E - S T O R A G E  D E F I N I T I O N S	*/
 
-typedef struct _ALLOC_ {
-	struct _ALLOC_ *_A_next;
-} *_PALLOC_;
+typedef struct _ALLOC_
+{
+	struct _ALLOC_* _A_next;
+}* _PALLOC_;
 
-
-#define	_A_st_free(ptr, phead, size)	(((_PALLOC_)ptr)->_A_next = \
-						(_PALLOC_)(*phead), \
-					 *((_PALLOC_ *)phead) = \
-						(_PALLOC_) ptr)
-#ifndef	BOTCH_FREE
-#define st_free(ptr, phead, size)	_A_st_free(ptr, phead, size)
-#else	/* def BOTCH_FREE */
-#define	st_free(ptr, phead, size)	(botch((char *)(ptr), size), \
-						_A_st_free(ptr, phead, size))
-#endif	/* BOTCH_FREE */
+#define _A_st_free(ptr, phead, size)                                                               \
+	(((_PALLOC_)ptr)->_A_next = (_PALLOC_)(*phead), *((_PALLOC_*)phead) = (_PALLOC_)ptr)
+#ifndef BOTCH_FREE
+#define st_free(ptr, phead, size) _A_st_free(ptr, phead, size)
+#else /* def BOTCH_FREE */
+#define st_free(ptr, phead, size) (botch((char*)(ptr), size), _A_st_free(ptr, phead, size))
+#endif /* BOTCH_FREE */
 
 #endif /* __ALLOC_INCLUDED__ */

modules/src/alloc/botch.c

@@ -4,17 +4,19 @@
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
 /*	botch - write garbage over a chunk of memory, useful if you want
-		to check if freed memory is used inappopriately.
+        to check if freed memory is used inappopriately.
 */
 
 #include "alloc.h"
 
-void botch(char *ptr, unsigned int n)
+void botch(char* ptr, unsigned int n)
 {
-	while (n >= sizeof (long))	{	
-			/* high-speed botch loop */
-		*(long *)ptr = 025252525252L;
-		ptr += sizeof (long), n -= sizeof (long);
+	while (n >= sizeof(long))
+	{
+		/* high-speed botch loop */
+		*(long*)ptr = 025252525252L;
+		ptr += sizeof(long), n -= sizeof(long);
 	}
-	while (n--) *ptr++ = '\252';
+	while (n--)
+		*ptr++ = '\252';
 }

modules/src/alloc/clear.c

@@ -4,18 +4,19 @@
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
 /*	clear - clear a block of memory, and try to do it fast.
-*/
+ */
 
 #include "alloc.h"
 
 /* instead of Calloc: */
 
-void clear(char *ptr, unsigned int n)
+void clear(char* ptr, unsigned int n)
 {
-	long *q = (long *) ptr;
+	long* q = (long*)ptr;
 
-	while (n >= 8*sizeof (long))	{
-			/* high-speed clear loop */
+	while (n >= 8 * sizeof(long))
+	{
+		/* high-speed clear loop */
 		*q++ = 0;
 		*q++ = 0;
 		*q++ = 0;
@@ -24,13 +25,15 @@ void clear(char *ptr, unsigned int n)
 		*q++ = 0;
 		*q++ = 0;
 		*q++ = 0;
-		n -= 8*sizeof (long);
+		n -= 8 * sizeof(long);
 	}
-	while (n >= sizeof (long))	{
-			/* high-speed clear loop */
+	while (n >= sizeof(long))
+	{
+		/* high-speed clear loop */
 		*q++ = 0;
-		n -= sizeof (long);
+		n -= sizeof(long);
 	}
-	ptr = (char *) q;
-	while (n--) *ptr++ = '\0';
+	ptr = (char*)q;
+	while (n--)
+		*ptr++ = '\0';
 }

modules/src/alloc/st_alloc.c

@@ -4,43 +4,48 @@
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
 /*	st_alloc - get a structure from a free list. If no structures left,
-		create new ones.
-		The counterpart, st_free, is a macro, defined in alloc.h
+        create new ones.
+        The counterpart, st_free, is a macro, defined in alloc.h
 */
 
 #if __STDC__
 #include <stdlib.h>
 #else
-extern char *malloc();
+extern char* malloc();
 #ifndef NULL
 #define NULL 0
 #endif
 #endif
 
-#include	"alloc.h"
+#include "alloc.h"
 
-char *st_alloc(char **phead, unsigned int size, int count)
+char* st_alloc(char** phead, unsigned int size, int count)
 {
-	char *p = NULL;
-	long *q;
-	char *retval;
+	char* p = NULL;
+	long* q;
+	char* retval;
 
-	if (*phead == 0)	{
-		while (count >= 1 && (p = malloc(size * count)) == 0) {
+	if (*phead == 0)
+	{
+		while (count >= 1 && (p = malloc(size * count)) == 0)
+		{
 			count >>= 1;
 		}
-		((_PALLOC_) p)->_A_next = 0;
-		while (--count) {
+		((_PALLOC_)p)->_A_next = 0;
+		while (--count)
+		{
 			p += size;
-			((_PALLOC_) p)->_A_next = (_PALLOC_) (p - size);
+			((_PALLOC_)p)->_A_next = (_PALLOC_)(p - size);
 		}
 		*phead = p;
 	}
-	else	p = *phead;
-	*phead = (char *) (((_PALLOC_)p)->_A_next);
+	else
+		p = *phead;
+	*phead = (char*)(((_PALLOC_)p)->_A_next);
 	retval = p;
-	q = (long *) p;
-	while (size >= 8*sizeof(long)) {
+	q = (long*)p;
+	while (size >= 8 * sizeof(long))
+	{
 		*q++ = 0;
 		*q++ = 0;
 		*q++ = 0;
@@ -49,14 +54,16 @@ char *st_alloc(char **phead, unsigned int size, int count)
 		*q++ = 0;
 		*q++ = 0;
 		*q++ = 0;
-		size -= 8*sizeof(long);
+		size -= 8 * sizeof(long);
 	}
-	while (size >= sizeof(long)) {
+	while (size >= sizeof(long))
+	{
 		*q++ = 0;
 		size -= sizeof(long);
 	}
-	p = (char *) q;
+	p = (char*)q;
 
-	while (size--) *p++ = 0;
+	while (size--)
+		*p++ = 0;
 	return retval;
 }

modules/src/alloc/std_alloc.c

@@ -4,42 +4,47 @@
  * See the copyright notice in the ACK home directory, in the file "Copyright".
  */
 /*	std_alloc - get a structure from a free list. If no structures left,
-		create new ones.
-		The counterpart, st_free, is a macro, defined in alloc.h
-	This is a counting version of st_alloc.
+        create new ones.
+        The counterpart, st_free, is a macro, defined in alloc.h
+    This is a counting version of st_alloc.
 */
 
 #if __STDC__
 #include <stdlib.h>
 #else
-extern char *malloc();
+extern char* malloc();
 #endif
 
-#include	"alloc.h"
+#include "alloc.h"
 
-char *std_alloc(char **phead, unsigned int size, int count, int *pcnt)
+char* std_alloc(char** phead, unsigned int size, int count, int* pcnt)
 {
-	char *p;
-	long *q;
-	char *retval;
+	char* p;
+	long* q;
+	char* retval;
 
-	if (*phead == 0)	{
-		while (count >= 1 && (p = malloc(size * count)) == 0) {
+	if (*phead == 0)
+	{
+		while (count >= 1 && (p = malloc(size * count)) == 0)
+		{
 			count >>= 1;
 		}
 		*pcnt += count;
-		((_PALLOC_) p)->_A_next = 0;
-		while (--count) {
+		((_PALLOC_)p)->_A_next = 0;
+		while (--count)
+		{
 			p += size;
-			((_PALLOC_) p)->_A_next = (_PALLOC_) (p - size);
+			((_PALLOC_)p)->_A_next = (_PALLOC_)(p - size);
 		}
 		*phead = p;
 	}
-	else p = *phead;
-	*phead = (char *) (((_PALLOC_) p)->_A_next);
+	else
+		p = *phead;
+	*phead = (char*)(((_PALLOC_)p)->_A_next);
 	retval = p;
-	q = (long *) p;
-	while (size >= 8*sizeof(long)) {
+	q = (long*)p;
+	while (size >= 8 * sizeof(long))
+	{
 		*q++ = 0;
 		*q++ = 0;
 		*q++ = 0;
@@ -48,14 +53,16 @@ char *std_alloc(char **phead, unsigned int size, int count, int *pcnt)
 		*q++ = 0;
 		*q++ = 0;
 		*q++ = 0;
-		size -= 8*sizeof(long);
+		size -= 8 * sizeof(long);
 	}
-	while (size >= sizeof(long)) {
+	while (size >= sizeof(long))
+	{
 		*q++ = 0;
 		size -= sizeof(long);
 	}
-	p = (char *) q;
+	p = (char*)q;
 
-	while (size--) *p++ = 0;
+	while (size--)
+		*p++ = 0;
 	return retval;
 }