diff --git a/modules/src/idf/idf_pkg.body b/modules/src/idf/idf_pkg.body
index 4b71bfaaa..8f970aef7 100644
--- a/modules/src/idf/idf_pkg.body
+++ b/modules/src/idf/idf_pkg.body
@@ -1,15 +1,15 @@
 /*	SYMBOL TABLE HANDLING	*/
 
-#include	<alloc.h>
+#include <alloc.h>
 
-#define	IDF_HASHSIZE	307	/* size of hashtable, must be odd */
+#define IDF_HASHSIZE 307 /* size of hashtable, must be odd */
 
-#define	IDF_STARTHASH(hs)	(hs = 0)
-#define	IDF_ENHASH(hs,ch)	(hs = (hs << 2) + ch)
-#define	IDF_STOPHASH(hs)	(hs = hs % IDF_HASHSIZE)
+#define IDF_STARTHASH(hs) (hs = 0)
+#define IDF_ENHASH(hs, ch) (hs = (hs << 2) + ch)
+#define IDF_STOPHASH(hs) (hs = hs % IDF_HASHSIZE)
 
-static struct idf *IDF_hashtable[IDF_HASHSIZE];
-	/*	All identifiers can in principle be reached through
+static struct idf* IDF_hashtable[IDF_HASHSIZE];
+/*	All identifiers can in principle be reached through
 		IDF_hashtable; IDF_hashtable[hc] is the start of a chain of
 		idf's whose tags all hash to hc.
 		Any identifier is entered into this
@@ -17,69 +17,71 @@ static struct idf *IDF_hashtable[IDF_HASHSIZE];
 		(variable, selector, structure tag, etc.).
 	*/
 
-_PROTOTYPE(static struct idf *IDF_new, (char *, int, int));
+static struct idf* IDF_new(char* tg, int size, int cpy);
 
-void
-init_idf()
+void init_idf()
 {
 }
 
-static struct idf *
-IDF_new(tg, size, cpy)
-	register char *tg;
-	register int size;
+static struct idf* IDF_new(char* tg, int size, int cpy)
 {
 	static int nidf;
-	static struct idf *pidf;
+	static struct idf* pidf;
 	static struct idf null_idf;
-	register struct idf *id;
+	register struct idf* id;
 #define NIDS 50
-#define IBUFSIZ	2048
+#define IBUFSIZ 2048
 	static unsigned int icnt;
-	static char *ip;
-	register char *p;
+	static char* ip;
+	register char* p;
 
-
-	if (! nidf--) {
+	if (!nidf--)
+	{
 		nidf += NIDS;
-		pidf = (struct idf *) Malloc(NIDS * sizeof (struct idf));
+		pidf = (struct idf*)Malloc(NIDS * sizeof(struct idf));
 	}
 
 	id = pidf;
 	pidf++;
 	*id = null_idf;
 
-	if (cpy) {
-		if (size > icnt) {
-			icnt =  size > IBUFSIZ ? size : IBUFSIZ;
+	if (cpy)
+	{
+		if (size > icnt)
+		{
+			icnt = size > IBUFSIZ ? size : IBUFSIZ;
 			p = Malloc(icnt);
 		}
-		else p = ip;
+		else
+			p = ip;
 		icnt -= size;
 		id->id_text = p;
-		while (size--) {
+		while (size--)
+		{
 			*p++ = *tg++;
 		}
 		ip = p;
 	}
-	else	id->id_text = tg;
+	else
+		id->id_text = tg;
 	return id;
 }
 
-#ifdef	IDF_DEBUG
-void
-hash_stat()
+#ifdef IDF_DEBUG
+void hash_stat(void)
 {
 	register int i;
 	int total_count = 0;
 
 	print("Hash table tally:\n");
-	for (i = 0; i < IDF_HASHSIZE; i++)	{
-		register struct idf *notch = IDF_hashtable[i];
+	for (i = 0; i < IDF_HASHSIZE; i++)
+	{
+		register struct idf* notch = IDF_hashtable[i];
 		register int cnt = 0;
 
-		print ("%d ", i);
-		while (notch)	{
+		print("%d ", i);
+		while (notch)
+		{
 			cnt++;
 			print("'%s' ", notch->id_text);
 			notch = notch->id_next;
@@ -91,40 +93,38 @@ hash_stat()
 	print("End hash table tally\n");
 }
 
-void
-idfappfun(fun, opt)
-	int	(*fun)();
-	int	opt;
+void idfappfun(int (*fun)(), int opt)
 {
-	register int	i;
+	register int i;
 
-	for (i = 0; i < IDF_HASHSIZE; i++) {
-		register struct idf *notch = IDF_hashtable[i];
+	for (i = 0; i < IDF_HASHSIZE; i++)
+	{
+		register struct idf* notch = IDF_hashtable[i];
 
-		while (notch) {
+		while (notch)
+		{
 			(*fun)(notch, opt);
 			notch = notch->id_next;
 		}
 	}
 }
-#endif	/* IDF_DEBUG */
+#endif /* IDF_DEBUG */
 
-struct idf *
-str2idf(tg, cpy)
-	char tg[];
+struct idf* str2idf(char tg[], int cpy)
 {
 	/*	str2idf() returns an entry in the symbol table for the
 		identifier tg.  If necessary, an entry is created.
 	*/
-	register char *cp = tg;
-	struct idf **hook;
-	register struct idf *notch;
+	register char* cp = tg;
+	struct idf** hook;
+	register struct idf* notch;
 	register unsigned int hash;
 	register int c;
 	int size;
 
 	IDF_STARTHASH(hash);
-	while (c = *cp++) {
+	while (c = *cp++)
+	{
 		IDF_ENHASH(hash, c);
 	}
 	IDF_STOPHASH(hash);
@@ -137,25 +137,31 @@ str2idf(tg, cpy)
 	*/
 	hook = &IDF_hashtable[hash];
 
-	while ((notch = *hook))	{
-		register char *s1 = tg;
+	while ((notch = *hook))
+	{
+		register char* s1 = tg;
 
 		cp = notch->id_text;
 
-		while (!(c = (*s1 - *cp++))) {
-			if (*s1++ == '\0') {
+		while (!(c = (*s1 - *cp++)))
+		{
+			if (*s1++ == '\0')
+			{
 				break;
 			}
 		}
 
-		if (c == 0) return notch;
-		if (c < 0) break;
+		if (c == 0)
+			return notch;
+		if (c < 0)
+			break;
 		hook = &notch->id_next;
 	}
 	/* a new struct idf must be inserted at the hook */
-	if (cpy < 0) return 0;
+	if (cpy < 0)
+		return 0;
 	notch = IDF_new(tg, size, cpy);
 	notch->id_next = *hook;
-	*hook = notch;		/* hooked in */
+	*hook = notch; /* hooked in */
 	return notch;
 }
diff --git a/modules/src/idf/idf_pkg.spec b/modules/src/idf/idf_pkg.spec
index 42d65d25f..3db6b9d5f 100644
--- a/modules/src/idf/idf_pkg.spec
+++ b/modules/src/idf/idf_pkg.spec
@@ -27,7 +27,7 @@ struct idf	{
 
 	Initializes the namelist.
 */
-_PROTOTYPE(void init_idf, (void));
+extern void init_idf(void);
 
 /*	struct idf * str2idf(tg, cp)
 		char *tg;
@@ -40,6 +40,6 @@ _PROTOTYPE(void init_idf, (void));
 	If cp < 0, the string is not entered, but only looked for.
 */
 
-_PROTOTYPE(struct idf *str2idf, (char *, int));
+struct idf *str2idf(char* tg, int cp);
 
 #define	findidf(tg)	str2idf(tg, -1)