Convert make(1) to use ANSI style function declarations. Variable

documentation already adequatedly existed in the description in most
cases.  Where it did not, it was added.  If no documentation existed
beforehand, then none was added.  Some unused dummies for use in the
traversal functions were marked as __unused during the conversion.
Occasionally, local style fixes were applied to lines already being
modified or influenced.

Now make(1) should always build with WARNS=3.

1 files changed, 43 insertions, 101 deletions

diff --git a/usr.bin/make/suff.c b/usr.bin/make/suff.c
index 7cc1bbfa6f60..688f320aaea2 100644
--- a/usr.bin/make/suff.c
+++ b/usr.bin/make/suff.c
@@ -192,9 +192,7 @@ static int SuffPrintTrans(void *, void *);
  *-----------------------------------------------------------------------
  */
 static char    *
-SuffStrIsPrefix (pref, str)
-    char  *pref;		/* possible prefix */
-    char  *str;			/* string to check */
+SuffStrIsPrefix (char *pref, char *str)
 {
     while (*str && *pref == *str) {
 	pref++;
@@ -219,9 +217,7 @@ SuffStrIsPrefix (pref, str)
  *-----------------------------------------------------------------------
  */
 static char *
-SuffSuffIsSuffix (s, str)
-    Suff	   *s;		/* possible suffix */
-    char           *str;	/* string to examine */
+SuffSuffIsSuffix (Suff *s, char *str)
 {
     char	   *p1;	    	/* Pointer into suffix name */
     char	   *p2;	    	/* Pointer into string being examined */
@@ -252,9 +248,7 @@ SuffSuffIsSuffix (s, str)
  *-----------------------------------------------------------------------
  */
 static int
-SuffSuffIsSuffixP(s, str)
-    void *   s;
-    void *   str;
+SuffSuffIsSuffixP(void *s, void *str)
 {
     return(!SuffSuffIsSuffix((Suff *) s, (char *) str));
 }
@@ -273,9 +267,7 @@ SuffSuffIsSuffixP(s, str)
  *-----------------------------------------------------------------------
  */
 static int
-SuffSuffHasNameP (s, sname)
-    void *    s;	    	    /* Suffix to check */
-    void *    sname; 	    /* Desired name */
+SuffSuffHasNameP (void *s, void *sname)
 {
     return (strcmp ((char *) sname, ((Suff *) s)->name));
 }
@@ -296,9 +288,7 @@ SuffSuffHasNameP (s, sname)
  *-----------------------------------------------------------------------
  */
 static int
-SuffSuffIsPrefix (s, str)
-    void *   s;		/* suffix to compare */
-    void *   str;	/* string to examine */
+SuffSuffIsPrefix (void *s, void *str)
 {
     return (SuffStrIsPrefix (((Suff *) s)->name, (char *) str) == NULL ? 1 : 0);
 }
@@ -316,9 +306,7 @@ SuffSuffIsPrefix (s, str)
  *-----------------------------------------------------------------------
  */
 static int
-SuffGNHasNameP (gn, name)
-    void *      gn;		/* current node we're looking at */
-    void *      name;	/* name we're looking for */
+SuffGNHasNameP (void *gn, void *name)
 {
     return (strcmp ((char *) name, ((GNode *) gn)->name));
 }
@@ -338,8 +326,7 @@ SuffGNHasNameP (gn, name)
  *-----------------------------------------------------------------------
  */
 static void
-SuffFree (sp)
-    void * sp;
+SuffFree (void *sp)
 {
     Suff           *s = (Suff *) sp;
 
@@ -371,9 +358,7 @@ SuffFree (sp)
  *-----------------------------------------------------------------------
  */
 static void
-SuffRemove(l, s)
-    Lst l;
-    Suff *s;
+SuffRemove(Lst l, Suff *s)
 {
     LstNode ln = Lst_Member(l, (void *)s);
     if (ln != NULL) {
@@ -396,9 +381,7 @@ SuffRemove(l, s)
  *-----------------------------------------------------------------------
  */
 static void
-SuffInsert (l, s)
-    Lst           l;		/* the list where in s should be inserted */
-    Suff          *s;		/* the suffix to insert */
+SuffInsert (Lst l, Suff *s)
 {
     LstNode 	  ln;		/* current element in l we're examining */
     Suff          *s2 = NULL;	/* the suffix descriptor in this element */
@@ -451,7 +434,7 @@ SuffInsert (l, s)
  *-----------------------------------------------------------------------
  */
 void
-Suff_ClearSuffixes ()
+Suff_ClearSuffixes (void)
 {
     Lst_Concat (suffClean, sufflist, LST_CONCLINK);
     sufflist = Lst_Init(FALSE);
@@ -481,10 +464,7 @@ Suff_ClearSuffixes ()
  *-----------------------------------------------------------------------
  */
 static Boolean
-SuffParseTransform(str, srcPtr, targPtr)
-    char    	  	*str;	    	/* String being parsed */
-    Suff    	  	**srcPtr;   	/* Place to store source of trans. */
-    Suff    	  	**targPtr;  	/* Place to store target of trans. */
+SuffParseTransform(char *str, Suff **srcPtr, Suff **targPtr)
 {
     LstNode		srcLn;	    /* element in suffix list of trans source*/
     Suff	    	*src;	    /* Source of transformation */
@@ -562,8 +542,7 @@ SuffParseTransform(str, srcPtr, targPtr)
  *-----------------------------------------------------------------------
  */
 Boolean
-Suff_IsTransform (str)
-    char          *str;	    	/* string to check */
+Suff_IsTransform (char *str)
 {
     Suff    	  *src, *targ;
 
@@ -585,8 +564,7 @@ Suff_IsTransform (str)
  *-----------------------------------------------------------------------
  */
 GNode *
-Suff_AddTransform (line)
-    char          *line;	/* name of transformation to add */
+Suff_AddTransform (char *line)
 {
     GNode         *gn;		/* GNode of transformation rule */
     Suff          *s,		/* source suffix */
@@ -648,9 +626,7 @@ Suff_AddTransform (line)
  *-----------------------------------------------------------------------
  */
 int
-Suff_EndTransform(gnp, dummy)
-    void *   gnp;    	/* Node for transformation */
-    void *   dummy;    	/* Node for transformation */
+Suff_EndTransform(void *gnp, void *dummy __unused)
 {
     GNode *gn = (GNode *) gnp;
 
@@ -682,7 +658,7 @@ Suff_EndTransform(gnp, dummy)
 	DEBUGF(SUFF, ("transformation %s complete\n", gn->name));
     }
 
-    return(dummy ? 0 : 0);
+    return (0);
 }
 
 /*-
@@ -705,9 +681,7 @@ Suff_EndTransform(gnp, dummy)
  *-----------------------------------------------------------------------
  */
 static int
-SuffRebuildGraph(transformp, sp)
-    void *  transformp; /* Transformation to test */
-    void *  sp;	    /* Suffix to rebuild */
+SuffRebuildGraph(void *transformp, void *sp)
 {
     GNode   	*transform = (GNode *) transformp;
     Suff    	*s = (Suff *) sp;
@@ -779,8 +753,7 @@ SuffRebuildGraph(transformp, sp)
  *-----------------------------------------------------------------------
  */
 void
-Suff_AddSuffix (str)
-    char          *str;	    /* the name of the suffix to add */
+Suff_AddSuffix (char *str)
 {
     Suff          *s;	    /* new suffix descriptor */
     LstNode 	  ln;
@@ -822,8 +795,7 @@ Suff_AddSuffix (str)
  *-----------------------------------------------------------------------
  */
 Lst
-Suff_GetPath (sname)
-    char    	  *sname;
+Suff_GetPath (char *sname)
 {
     LstNode   	  ln;
     Suff    	  *s;
@@ -856,7 +828,7 @@ Suff_GetPath (sname)
  *-----------------------------------------------------------------------
  */
 void
-Suff_DoPaths()
+Suff_DoPaths(void)
 {
     Suff	   	*s;
     LstNode	  	ln;
@@ -918,8 +890,7 @@ Suff_DoPaths()
  *-----------------------------------------------------------------------
  */
 void
-Suff_AddInclude (sname)
-    char	  *sname;     /* Name of suffix to mark */
+Suff_AddInclude (char *sname)
 {
     LstNode	  ln;
     Suff	  *s;
@@ -948,8 +919,7 @@ Suff_AddInclude (sname)
  *-----------------------------------------------------------------------
  */
 void
-Suff_AddLib (sname)
-    char	  *sname;     /* Name of suffix to mark */
+Suff_AddLib (char *sname)
 {
     LstNode	  ln;
     Suff	  *s;
@@ -978,9 +948,7 @@ Suff_AddLib (sname)
  *-----------------------------------------------------------------------
  */
 static int
-SuffAddSrc (sp, lsp)
-    void *	sp;	    /* suffix for which to create a Src structure */
-    void *  lsp;	    /* list and parent for the new Src */
+SuffAddSrc (void *sp, void *lsp)
 {
     Suff	*s = (Suff *) sp;
     LstSrc      *ls = (LstSrc *) lsp;
@@ -1047,9 +1015,7 @@ SuffAddSrc (sp, lsp)
  *-----------------------------------------------------------------------
  */
 static void
-SuffAddLevel (l, targ)
-    Lst            l;		/* list to which to add the new level */
-    Src            *targ;	/* Src structure to use as the parent */
+SuffAddLevel (Lst l, Src *targ)
 {
     LstSrc         ls;
 
@@ -1072,8 +1038,7 @@ SuffAddLevel (l, targ)
  *----------------------------------------------------------------------
  */
 static int
-SuffRemoveSrc (l)
-    Lst l;
+SuffRemoveSrc (Lst l)
 {
     LstNode ln;
     Src *s;
@@ -1140,9 +1105,7 @@ SuffRemoveSrc (l)
  *-----------------------------------------------------------------------
  */
 static Src *
-SuffFindThem (srcs, slst)
-    Lst            srcs;	/* list of Src structures to search through */
-    Lst		   slst;
+SuffFindThem (Lst srcs, Lst slst)
 {
     Src            *s;		/* current Src */
     Src		   *rs;		/* returned Src */
@@ -1204,9 +1167,7 @@ SuffFindThem (srcs, slst)
  *-----------------------------------------------------------------------
  */
 static Src *
-SuffFindCmds (targ, slst)
-    Src	    	*targ;	/* Src structure to play with */
-    Lst		slst;
+SuffFindCmds (Src *targ, Lst slst)
 {
     LstNode 	  	ln; 	/* General-purpose list node */
     GNode		*t, 	/* Target GNode */
@@ -1296,9 +1257,7 @@ SuffFindCmds (targ, slst)
  *-----------------------------------------------------------------------
  */
 static int
-SuffExpandChildren(cgnp, pgnp)
-    void *  cgnp;	    /* Child to examine */
-    void *  pgnp;	    /* Parent node being processed */
+SuffExpandChildren(void *cgnp, void *pgnp)
 {
     GNode   	*cgn = (GNode *) cgnp;
     GNode   	*pgn = (GNode *) pgnp;
@@ -1524,11 +1483,7 @@ SuffExpandChildren(cgnp, pgnp)
  *-----------------------------------------------------------------------
  */
 static Boolean
-SuffApplyTransform(tGn, sGn, t, s)
-    GNode   	*tGn;	    /* Target node */
-    GNode   	*sGn;	    /* Source node */
-    Suff    	*t; 	    /* Target suffix */
-    Suff    	*s; 	    /* Source suffix */
+SuffApplyTransform(GNode *tGn, GNode *sGn, Suff *t, Suff *s)
 {
     LstNode 	ln; 	    /* General node */
     char    	*tname;	    /* Name of transformation rule */
@@ -1628,9 +1583,7 @@ SuffApplyTransform(tGn, sGn, t, s)
  *-----------------------------------------------------------------------
  */
 static void
-SuffFindArchiveDeps(gn, slst)
-    GNode   	*gn;	    /* Node for which to locate dependencies */
-    Lst		slst;
+SuffFindArchiveDeps(GNode *gn, Lst slst)
 {
     char    	*eoarch;    /* End of archive portion */
     char    	*eoname;    /* End of member portion */
@@ -1761,9 +1714,7 @@ SuffFindArchiveDeps(gn, slst)
  *-----------------------------------------------------------------------
  */
 static void
-SuffFindNormalDeps(gn, slst)
-    GNode   	*gn;	    /* Node for which to find sources */
-    Lst		slst;
+SuffFindNormalDeps(GNode *gn, Lst slst)
 {
     char    	*eoname;    /* End of name */
     char    	*sopref;    /* Start of prefix */
@@ -2153,8 +2104,7 @@ sfnd_return:
  */
 
 void
-Suff_FindDeps(gn)
-    GNode *gn;
+Suff_FindDeps(GNode *gn)
 {
 
     SuffFindDeps(gn, srclist);
@@ -2164,9 +2114,7 @@ Suff_FindDeps(gn)
 
 
 static void
-SuffFindDeps (gn, slst)
-    GNode         *gn;	      	/* node we're dealing with */
-    Lst		  slst;
+SuffFindDeps (GNode *gn, Lst slst)
 {
     if (gn->type & OP_DEPS_FOUND) {
 	/*
@@ -2233,8 +2181,7 @@ SuffFindDeps (gn, slst)
  *-----------------------------------------------------------------------
  */
 void
-Suff_SetNull(name)
-    char    *name;	    /* Name of null suffix */
+Suff_SetNull(char *name)
 {
     Suff    *s;
     LstNode ln;
@@ -2269,7 +2216,7 @@ Suff_SetNull(name)
  *-----------------------------------------------------------------------
  */
 void
-Suff_Init ()
+Suff_Init (void)
 {
     sufflist = Lst_Init (FALSE);
     suffClean = Lst_Init(FALSE);
@@ -2312,7 +2259,7 @@ Suff_Init ()
  */
 
 void
-Suff_End()
+Suff_End(void)
 {
     Lst_Destroy(sufflist, SuffFree);
     Lst_Destroy(suffClean, SuffFree);
@@ -2325,18 +2272,15 @@ Suff_End()
 
 /********************* DEBUGGING FUNCTIONS **********************/
 
-static int SuffPrintName(s, dummy)
-    void * s;
-    void * dummy;
+static int
+SuffPrintName(void *s, void *dummy __unused)
 {
     printf ("`%s' ", ((Suff *) s)->name);
-    return (dummy ? 0 : 0);
+    return (0);
 }
 
 static int
-SuffPrintSuff (sp, dummy)
-    void * sp;
-    void * dummy;
+SuffPrintSuff (void *sp, void *dummy __unused)
 {
     Suff    *s = (Suff *) sp;
     int	    flags;
@@ -2376,13 +2320,11 @@ SuffPrintSuff (sp, dummy)
     printf ("#\tSearch Path: ");
     Dir_PrintPath (s->searchPath);
     fputc ('\n', stdout);
-    return (dummy ? 0 : 0);
+    return (0);
 }
 
 static int
-SuffPrintTrans (tp, dummy)
-    void * tp;
-    void * dummy;
+SuffPrintTrans (void *tp, void *dummy __unused)
 {
     GNode   *t = (GNode *) tp;
 
@@ -2391,11 +2333,11 @@ SuffPrintTrans (tp, dummy)
     fputc ('\n', stdout);
     Lst_ForEach (t->commands, Targ_PrintCmd, (void *)0);
     fputc ('\n', stdout);
-    return(dummy ? 0 : 0);
+    return (0);
 }
 
 void
-Suff_PrintAll()
+Suff_PrintAll(void)
 {
     printf ("#*** Suffixes:\n");
     Lst_ForEach (sufflist, SuffPrintSuff, (void *)0);