Changeset 24 for branches/FREEBSD/src/kmk/parse.c

Timestamp:

Nov 26, 2002, 10:24:54 PM (23 years ago)

Author:

bird

Message:

Import of RELENG_4_7_0_RELEASE

File:

• branches/FREEBSD/src/kmk/parse.c (modified) (86 diffs)

branches/FREEBSD/src/kmk/parse.c

@@ -35 +35 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
- *
- * @(#)parse.c  8.3 (Berkeley) 3/19/94
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/usr.bin/make/parse.c,v 1.48 2002/10/09 03:42:10 jmallett Exp $");
+ */
+
+#ifndef lint
+#if 0
+static char sccsid[] = "@(#)parse.c     8.3 (Berkeley) 3/19/94";
+#else
+static const char rcsid[] =
+  "$FreeBSD: src/usr.bin/make/parse.c,v 1.22 1999/08/28 01:03:35 peter Exp $";
+#endif
+#endif /* not lint */
 
 /*-
@@ -84 +88 @@
  */
 
+#ifdef __STDC__
 #include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
 #include <ctype.h>
 #include <err.h>
@@ -178 +186 @@
 
 /*
- * Predecessor node for handling .ORDER. Initialized to NULL when .ORDER
+ * Predecessor node for handling .ORDER. Initialized to NILGNODE when .ORDER
  * seen, then set to each successive source on the line.
  */
@@ -231 +239 @@
 };
 
-static int ParseFindKeyword(char *);
-static int ParseLinkSrc(void *, void *);
-static int ParseDoOp(void *, void *);
-static int ParseAddDep(void *, void *);
-static void ParseDoSrc(int, char *, Lst);
-static int ParseFindMain(void *, void *);
-static int ParseAddDir(void *, void *);
-static int ParseClearPath(void *, void *);
-static void ParseDoDependency(char *);
-static int ParseAddCmd(void *, void *);
-static int ParseReadc(void);
-static void ParseUnreadc(int);
-static void ParseHasCommands(void *);
-static void ParseDoInclude(char *);
-static void ParseDoError(char *);
+static int ParseFindKeyword __P((char *));
+static int ParseLinkSrc __P((ClientData, ClientData));
+static int ParseDoOp __P((ClientData, ClientData));
+static int ParseAddDep __P((ClientData, ClientData));
+static void ParseDoSrc __P((int, char *, Lst));
+static int ParseFindMain __P((ClientData, ClientData));
+static int ParseAddDir __P((ClientData, ClientData));
+static int ParseClearPath __P((ClientData, ClientData));
+static void ParseDoDependency __P((char *));
+static int ParseAddCmd __P((ClientData, ClientData));
+static int ParseReadc __P((void));
+static void ParseUnreadc __P((int));
+static void ParseHasCommands __P((ClientData));
+static void ParseDoInclude __P((char *));
+static void ParseDoError __P((char *));
 #ifdef SYSVINCLUDE
-static void ParseTraditionalInclude(char *);
+static void ParseTraditionalInclude __P((char *));
 #endif
-static int ParseEOF(int);
-static char *ParseReadLine(void);
-static char *ParseSkipLine(int);
-static void ParseFinishLine(void);
+static int ParseEOF __P((int));
+static char *ParseReadLine __P((void));
+static char *ParseSkipLine __P((int));
+static void ParseFinishLine __P((void));
 
 /*-
@@ -267 +275 @@
  */
 static int
-ParseFindKeyword (char *str)
-{
-    int             start,
+ParseFindKeyword (str)
+    char            *str;               /* String to find */
+{
+    register int    start,
                     end,
                     cur;
-    int             diff;
+    register int    diff;
 
     start = 0;
@@ -306 +315 @@
 /* VARARGS */
 void
-Parse_Error(int type, const char *fmt, ...)
+#ifdef __STDC__
+Parse_Error(int type, char *fmt, ...)
+#else
+Parse_Error(va_alist)
+        va_dcl
+#endif
 {
         va_list ap;
-
+#ifdef __STDC__
         va_start(ap, fmt);
+#else
+        int type;               /* Error type (PARSE_WARNING, PARSE_FATAL) */
+        char *fmt;
+
+        va_start(ap);
+        type = va_arg(ap, int);
+        fmt = va_arg(ap, char *);
+#endif
+
         (void)fprintf(stderr, "\"%s\", line %d: ", fname, lineno);
         if (type == PARSE_WARNING)
@@ -339 +362 @@
  */
 static int
-ParseLinkSrc (void *pgnp, void *cgnp)
+ParseLinkSrc (pgnp, cgnp)
+    ClientData     pgnp;        /* The parent node */
+    ClientData     cgnp;        /* The child node */
 {
     GNode          *pgn = (GNode *) pgnp;
     GNode          *cgn = (GNode *) cgnp;
-    if (Lst_Member (pgn->children, (void *)cgn) == NULL) {
-        (void)Lst_AtEnd (pgn->children, (void *)cgn);
+    if (Lst_Member (pgn->children, (ClientData)cgn) == NILLNODE) {
+        (void)Lst_AtEnd (pgn->children, (ClientData)cgn);
         if (specType == Not) {
-            (void)Lst_AtEnd (cgn->parents, (void *)pgn);
+            (void)Lst_AtEnd (cgn->parents, (ClientData)pgn);
         }
         pgn->unmade += 1;
@@ -370 +395 @@
  */
 static int
-ParseDoOp (void *gnp, void *opp)
+ParseDoOp (gnp, opp)
+    ClientData     gnp;         /* The node to which the operator is to be
+                                 * applied */
+    ClientData     opp;         /* The operator to apply */
 {
     GNode          *gn = (GNode *) gnp;
@@ -395 +423 @@
          * instance.
          */
-        GNode           *cohort;
+        register GNode  *cohort;
         LstNode         ln;
 
@@ -408 +436 @@
          * sorry.
          */
-        Lst_ForEach(gn->parents, ParseLinkSrc, (void *)cohort);
+        Lst_ForEach(gn->parents, ParseLinkSrc, (ClientData)cohort);
         cohort->type = OP_DOUBLEDEP|OP_INVISIBLE;
-        (void)Lst_AtEnd(gn->cohorts, (void *)cohort);
+        (void)Lst_AtEnd(gn->cohorts, (ClientData)cohort);
 
         /*
          * Replace the node in the targets list with the new copy
          */
-        ln = Lst_Member(targets, (void *)gn);
-        Lst_Replace(ln, (void *)cohort);
+        ln = Lst_Member(targets, (ClientData)gn);
+        Lst_Replace(ln, (ClientData)cohort);
         gn = cohort;
     }
@@ -445 +473 @@
  */
 static int
-ParseAddDep(void *pp, void *sp)
+ParseAddDep(pp, sp)
+    ClientData pp;
+    ClientData sp;
 {
     GNode *p = (GNode *) pp;
@@ -456 +486 @@
          * problem
          */
-        (void)Lst_AtEnd(p->successors, (void *)s);
-        (void)Lst_AtEnd(s->preds, (void *)p);
+        (void)Lst_AtEnd(p->successors, (ClientData)s);
+        (void)Lst_AtEnd(s->preds, (ClientData)p);
         return 0;
     }
@@ -483 +513 @@
  */
 static void
-ParseDoSrc (int tOp, char *src, Lst allsrc)
+ParseDoSrc (tOp, src, allsrc)
+    int         tOp;    /* operator (if any) from special targets */
+    char        *src;   /* name of the source to handle */
+    Lst         allsrc; /* List of all sources to wait for */
 {
     GNode       *gn = NULL;
 
-    if (*src == '.' && isupper ((unsigned char) src[1])) {
+    if (*src == '.' && isupper (src[1])) {
         int keywd = ParseFindKeyword(src);
         if (keywd != -1) {
             int op = parseKeywords[keywd].op;
             if (op != 0) {
-                Lst_ForEach (targets, ParseDoOp, (void *)&op);
+                Lst_ForEach (targets, ParseDoOp, (ClientData)&op);
                 return;
             }
@@ -512 +545 @@
          * line. This is to allow #ifmake's to succeed, or something...
          */
-        (void) Lst_AtEnd (create, (void *)estrdup(src));
+        (void) Lst_AtEnd (create, (ClientData)estrdup(src));
         /*
          * Add the name to the .TARGETS variable as well, so the user cna
@@ -526 +559 @@
          */
         gn = Targ_FindNode(src, TARG_CREATE);
-        if (predecessor != NULL) {
-            (void)Lst_AtEnd(predecessor->successors, (void *)gn);
-            (void)Lst_AtEnd(gn->preds, (void *)predecessor);
+        if (predecessor != NILGNODE) {
+            (void)Lst_AtEnd(predecessor->successors, (ClientData)gn);
+            (void)Lst_AtEnd(gn->preds, (ClientData)predecessor);
         }
         /*
@@ -552 +585 @@
             gn->type |= tOp;
         } else {
-            Lst_ForEach (targets, ParseLinkSrc, (void *)gn);
+            Lst_ForEach (targets, ParseLinkSrc, (ClientData)gn);
         }
         if ((gn->type & OP_OPMASK) == OP_DOUBLEDEP) {
-            GNode       *cohort;
-            LstNode     ln;
-
-            for (ln=Lst_First(gn->cohorts); ln != NULL; ln = Lst_Succ(ln)){
+            register GNode      *cohort;
+            register LstNode    ln;
+
+            for (ln=Lst_First(gn->cohorts); ln != NILLNODE; ln = Lst_Succ(ln)){
                 cohort = (GNode *)Lst_Datum(ln);
                 if (tOp) {
                     cohort->type |= tOp;
                 } else {
-                    Lst_ForEach(targets, ParseLinkSrc, (void *)cohort);
+                    Lst_ForEach(targets, ParseLinkSrc, (ClientData)cohort);
                 }
             }
@@ -571 +604 @@
 
     gn->order = waiting;
-    (void)Lst_AtEnd(allsrc, (void *)gn);
+    (void)Lst_AtEnd(allsrc, (ClientData)gn);
     if (waiting) {
-        Lst_ForEach(allsrc, ParseAddDep, (void *)gn);
+        Lst_ForEach(allsrc, ParseAddDep, (ClientData)gn);
     }
 }
@@ -593 +626 @@
  */
 static int
-ParseFindMain(void *gnp, void *dummy __unused)
+ParseFindMain(gnp, dummy)
+    ClientData    gnp;      /* Node to examine */
+    ClientData    dummy;
 {
     GNode         *gn = (GNode *) gnp;
@@ -599 +634 @@
         mainNode = gn;
         Targ_SetMain(gn);
-        return (1);
+        return (dummy ? 1 : 1);
     } else {
-        return (0);
+        return (dummy ? 0 : 0);
     }
 }
@@ -619 +654 @@
  */
 static int
-ParseAddDir(void *path, void *name)
+ParseAddDir(path, name)
+    ClientData    path;
+    ClientData    name;
 {
     Dir_AddDir((Lst) path, (char *) name);
@@ -639 +676 @@
  */
 static int
-ParseClearPath(void *path, void *dummy __unused)
+ParseClearPath(path, dummy)
+    ClientData path;
+    ClientData dummy;
 {
     Dir_ClearPath((Lst) path);
-    return (0);
+    return(dummy ? 0 : 0);
 }
 
@@ -680 +719 @@
  */
 static void
-ParseDoDependency (char *line)
+ParseDoDependency (line)
+    char           *line;       /* the line to parse */
 {
     char           *cp;         /* our current position */
@@ -706 +746 @@
     do {
         for (cp = line;
-             *cp && !isspace ((unsigned char) *cp) && *cp != '(';
+             *cp && !isspace (*cp) &&
+             (*cp != '!') && (*cp != ':') && (*cp != '(');
              cp++)
         {
@@ -727 +768 @@
                 }
                 cp += length-1;
-            } else if (*cp == '!' || *cp == ':') {
-                /*
-                 * We don't want to end a word on ':' or '!' if there is a
-                 * better match later on in the string.  By "better" I mean
-                 * one that is followed by whitespace.  This allows the user
-                 * to have targets like:
-                 *    fie::fi:fo: fum
-                 * where "fie::fi:fo" is the target.  In real life this is used
-                 * for perl5 library man pages where "::" separates an object
-                 * from its class.  Ie: "File::Spec::Unix".  This behaviour
-                 * is also consistent with other versions of make.
-                 */
-                char *p = cp + 1;
-
-                if (*cp == ':' && *p == ':')
-                    p++;
-
-                /* Found the best match already. */
-                if (*p == '\0' || isspace(*p))
-                    break;
-
-                do {
-                    p += strcspn(p, "!:");
-                    if (*p == '\0')
-                        break;
-                } while (!isspace(*++p));
-
-                /* No better match later on... */
-                if (*p == '\0')
-                    break;
             }
             continue;
@@ -784 +795 @@
             /*
              * Ending a dependency line without an operator is a Bozo
-             * no-no.  As a heuristic, this is also often triggered by
-             * undetected conflicts from cvs/rcs merges.
+             * no-no
              */
-            if ((strncmp(line, "<<<<<<", 6) == 0) ||
-                (strncmp(line, "======", 6) == 0) ||
-                (strncmp(line, ">>>>>>", 6) == 0))
-                Parse_Error (PARSE_FATAL,
-                    "Makefile appears to contain unresolved cvs/rcs/??? merge conflicts");
-            else
-                Parse_Error (PARSE_FATAL, "Need an operator");
+            Parse_Error (PARSE_FATAL, "Need an operator");
             return;
         }
@@ -801 +805 @@
          * specType to match it.
          */
-        if (*line == '.' && isupper ((unsigned char) line[1])) {
+        if (*line == '.' && isupper (line[1])) {
             /*
              * See if the target is a special target that must have it
@@ -842 +846 @@
                  *      .NOTPARALLEL    Make only one target at a time.
                  *      .SINGLESHELL    Create a shell for each command.
-                 *      .ORDER          Must set initial predecessor to NULL
+                 *      .ORDER          Must set initial predecessor to NIL
                  */
                 switch (specType) {
@@ -849 +853 @@
                             paths = Lst_Init(FALSE);
                         }
-                        (void)Lst_AtEnd(paths, (void *)dirSearchPath);
+                        (void)Lst_AtEnd(paths, (ClientData)dirSearchPath);
                         break;
                     case Main:
@@ -861 +865 @@
                         gn = Targ_FindNode(line, TARG_CREATE);
                         gn->type |= OP_NOTMAIN;
-                        (void)Lst_AtEnd(targets, (void *)gn);
+                        (void)Lst_AtEnd(targets, (ClientData)gn);
                         break;
                     case Default:
                         gn = Targ_NewGN(".DEFAULT");
                         gn->type |= (OP_NOTMAIN|OP_TRANSFORM);
-                        (void)Lst_AtEnd(targets, (void *)gn);
+                        (void)Lst_AtEnd(targets, (ClientData)gn);
                         DEFAULT = gn;
                         break;
                     case NotParallel:
                     {
+                        extern int  maxJobs;
+
                         maxJobs = 1;
                         break;
@@ -878 +884 @@
                         break;
                     case Order:
-                        predecessor = NULL;
+                        predecessor = NILGNODE;
                         break;
                     default:
@@ -893 +899 @@
                 specType = ExPath;
                 path = Suff_GetPath (&line[5]);
-                if (path == NULL) {
+                if (path == NILLST) {
                     Parse_Error (PARSE_FATAL,
                                  "Suffix '%s' not defined (yet)",
@@ -902 +908 @@
                         paths = Lst_Init(FALSE);
                     }
-                    (void)Lst_AtEnd(paths, (void *)path);
+                    (void)Lst_AtEnd(paths, (ClientData)path);
                 }
             }
@@ -929 +935 @@
                  * so create a list with the word on it.
                  */
-                (void)Lst_AtEnd(curTargs, (void *)line);
+                (void)Lst_AtEnd(curTargs, (ClientData)line);
             }
 
@@ -941 +947 @@
                 }
 
-                (void)Lst_AtEnd (targets, (void *)gn);
+                (void)Lst_AtEnd (targets, (ClientData)gn);
             }
         } else if (specType == ExPath && *line != '.' && *line != '\0') {
@@ -965 +971 @@
             }
         } else {
-            while (*cp && isspace ((unsigned char) *cp)) {
+            while (*cp && isspace (*cp)) {
                 cp++;
             }
@@ -1018 +1024 @@
     cp++;                       /* Advance beyond operator */
 
-    Lst_ForEach (targets, ParseDoOp, (void *)&op);
+    Lst_ForEach (targets, ParseDoOp, (ClientData)&op);
 
     /*
      * Get to the first source
      */
-    while (*cp && isspace ((unsigned char) *cp)) {
+    while (*cp && isspace (*cp)) {
         cp++;
     }
@@ -1052 +1058 @@
                 break;
             case ExPath:
-                Lst_ForEach(paths, ParseClearPath, (void *)NULL);
+                Lst_ForEach(paths, ParseClearPath, (ClientData)NULL);
                 break;
 #ifdef POSIX
@@ -1112 +1118 @@
              * has no valid suffix.
              */
-            char  savech;
-            while (*cp && !isspace ((unsigned char) *cp)) {
+            char  savec;
+            while (*cp && !isspace (*cp)) {
                 cp++;
             }
-            savech = *cp;
+            savec = *cp;
             *cp = '\0';
             switch (specType) {
@@ -1123 +1129 @@
                     break;
                 case ExPath:
-                    Lst_ForEach(paths, ParseAddDir, (void *)line);
+                    Lst_ForEach(paths, ParseAddDir, (ClientData)line);
                     break;
                 case Includes:
@@ -1137 +1143 @@
                     break;
             }
-            *cp = savech;
-            if (savech != '\0') {
+            *cp = savec;
+            if (savec != '\0') {
                 cp++;
             }
-            while (*cp && isspace ((unsigned char) *cp)) {
+            while (*cp && isspace (*cp)) {
                 cp++;
             }
@@ -1156 +1162 @@
              * and handle them accordingly.
              */
-            while (*cp && !isspace ((unsigned char) *cp)) {
+            while (*cp && !isspace (*cp)) {
                 if ((*cp == '(') && (cp > line) && (cp[-1] != '$')) {
                     /*
@@ -1171 +1177 @@
 
             if (*cp == '(') {
-                GNode     *gnp;
+                GNode     *gn;
 
                 sources = Lst_Init (FALSE);
@@ -1181 +1187 @@
 
                 while (!Lst_IsEmpty (sources)) {
-                    gnp = (GNode *) Lst_DeQueue (sources);
-                    ParseDoSrc (tOp, gnp->name, curSrcs);
+                    gn = (GNode *) Lst_DeQueue (sources);
+                    ParseDoSrc (tOp, gn->name, curSrcs);
                 }
                 Lst_Destroy (sources, NOFREE);
@@ -1194 +1200 @@
                 ParseDoSrc (tOp, line, curSrcs);
             }
-            while (*cp && isspace ((unsigned char) *cp)) {
+            while (*cp && isspace (*cp)) {
                 cp++;
             }
@@ -1201 +1207 @@
     }
 
-    if (mainNode == NULL) {
+    if (mainNode == NILGNODE) {
         /*
          * If we have yet to decide on a main target to make, in the
@@ -1208 +1214 @@
          * (i.e. isn't a .USE or .EXEC rule) to be made.
          */
-        Lst_ForEach (targets, ParseFindMain, (void *)0);
+        Lst_ForEach (targets, ParseFindMain, (ClientData)0);
     }
 
@@ -1234 +1240 @@
  */
 Boolean
-Parse_IsVar (char *line)
-{
-    Boolean wasSpace = FALSE;   /* set TRUE if found a space */
-    Boolean haveName = FALSE;   /* Set TRUE if have a variable name */
+Parse_IsVar (line)
+    register char  *line;       /* the line to check */
+{
+    register Boolean wasSpace = FALSE;  /* set TRUE if found a space */
+    register Boolean haveName = FALSE;  /* Set TRUE if have a variable name */
     int level = 0;
-#define ISEQOPERATOR(c) \
+#define ISEQOPERATOR(c) \
         (((c) == '+') || ((c) == ':') || ((c) == '?') || ((c) == '!'))
 
@@ -1335 +1342 @@
  */
 void
-Parse_DoVar (char *line, GNode *ctxt)
+Parse_DoVar (line, ctxt)
+    char            *line;      /* a line guaranteed to be a variable
+                                 * assignment. This reduces error checks */
+    GNode           *ctxt;      /* Context in which to do the assignment */
 {
     char           *cp; /* pointer into line */
@@ -1363 +1373 @@
      */
     for (cp = line + 1; *cp != '='; cp++) {
-        if (isspace ((unsigned char) *cp)) {
+        if (isspace (*cp)) {
             *cp = '\0';
         }
@@ -1419 +1429 @@
     }
 
-    while (isspace ((unsigned char) *cp)) {
+    while (isspace (*cp)) {
         cp++;
     }
@@ -1440 +1450 @@
 
         oldVars = FALSE;
-
-        /*
-         * make sure that we set the variable the first time to nothing
-         * so that it gets substituted!
-         */
-        if (!Var_Exists(line, ctxt))
-            Var_Set(line, "", ctxt);
-
         cp = Var_Subst(NULL, cp, ctxt, FALSE);
         oldVars = oldOldVars;
@@ -1456 +1458 @@
         Boolean freeCmd = FALSE; /* TRUE if the command needs to be freed, i.e.
                                   * if any variable expansion was performed */
-        char *res, *error;
+        char *res, *err;
 
         if (strchr(cp, '$') != NULL) {
@@ -1468 +1470 @@
         }
 
-        res = Cmd_Exec(cp, &error);
+        res = Cmd_Exec(cp, &err);
         Var_Set(line, res, ctxt);
         free(res);
 
-        if (error)
-            Parse_Error(PARSE_WARNING, error, cp);
+        if (err)
+            Parse_Error(PARSE_WARNING, err, cp);
 
         if (freeCmd)
@@ -1497 +1499 @@
  */
 static int
-ParseAddCmd(void *gnp, void *cmd)
+ParseAddCmd(gnp, cmd)
+    ClientData gnp;     /* the node to which the command is to be added */
+    ClientData cmd;     /* the command to add */
 {
     GNode *gn = (GNode *) gnp;
@@ -1503 +1507 @@
     if (!(gn->type & OP_HAS_COMMANDS))
         (void)Lst_AtEnd(gn->commands, cmd);
-    else
-        Parse_Error(PARSE_WARNING,
-                    "duplicate script for target \"%s\" ignored",
-                    gn->name);
     return(0);
 }
@@ -1527 +1527 @@
  */
 static void
-ParseHasCommands(void *gnp)
+ParseHasCommands(gnp)
+    ClientData    gnp;      /* Node to examine */
 {
     GNode *gn = (GNode *) gnp;
@@ -1550 +1551 @@
  */
 void
-Parse_AddIncludeDir (char *dir)
+Parse_AddIncludeDir (dir)
+    char          *dir;     /* The name of the directory to add */
 {
     Dir_AddDir (parseIncPath, dir);
@@ -1566 +1568 @@
  */
 static void
-ParseDoError(char *errmsg)
-{
-        if (!isspace((unsigned char) *errmsg)) {
+ParseDoError(errmsg)
+    char          *errmsg;      /* error message */
+{
+        if (!isspace(*errmsg)) {
                 Parse_Error(PARSE_WARNING, "invalid syntax: .error%s", errmsg);
                 return;
         }
         
-        while (isspace((unsigned char) *errmsg))
+        while (isspace(*errmsg))
                 errmsg++;
         
@@ -1602 +1605 @@
  */
 static void
-ParseDoInclude (char *file)
+ParseDoInclude (file)
+    char          *file;        /* file specification */
 {
     char          *fullname;    /* full pathname of file */
@@ -1741 +1745 @@
     oldFile->lineno = lineno;
 
-    (void) Lst_AtFront (includes, (void *)oldFile);
+    (void) Lst_AtFront (includes, (ClientData)oldFile);
 
     /*
@@ -1779 +1783 @@
  */
 void
-Parse_FromString(char *str)
+Parse_FromString(str)
+    char *str;
 {
     IFile         *oldFile;     /* state associated with this file */
 
-    DEBUGF(FOR, ("%s\n----\n", str));
+    if (DEBUG(FOR))
+        (void) fprintf(stderr, "%s\n----\n", str);
 
     oldFile = (IFile *) emalloc (sizeof (IFile));
@@ -1791 +1797 @@
     oldFile->p = curPTR;
 
-    (void) Lst_AtFront (includes, (void *)oldFile);
+    (void) Lst_AtFront (includes, (ClientData)oldFile);
 
     curFILE = NULL;
@@ -1819 +1825 @@
  */
 static void
-ParseTraditionalInclude (char *file)
+ParseTraditionalInclude (file)
+    char          *file;        /* file specification */
 {
     char          *fullname;    /* full pathname of file */
@@ -1921 +1928 @@
     oldFile->lineno = lineno;
 
-    (void) Lst_AtFront (includes, (void *)oldFile);
+    (void) Lst_AtFront (includes, (ClientData)oldFile);
 
     /*
@@ -1960 +1967 @@
  */
 static int
-ParseEOF (int opened)
+ParseEOF (opened)
+    int opened;
 {
     IFile     *ifile;   /* the state on the top of the includes stack */
@@ -1969 +1977 @@
 
     ifile = (IFile *) Lst_DeQueue (includes);
-    free (fname);
+    free ((Address) fname);
     fname = ifile->fname;
     lineno = ifile->lineno;
@@ -1975 +1983 @@
         (void) fclose (curFILE);
     if (curPTR) {
-        free(curPTR->str);
-        free(curPTR);
+        free((Address) curPTR->str);
+        free((Address) curPTR);
     }
     curFILE = ifile->F;
     curPTR = ifile->p;
-    free (ifile);
+    free ((Address)ifile);
     return (CONTINUE);
 }
@@ -1996 +2004 @@
  */
 static int
-ParseReadc(void)
+ParseReadc()
 {
     if (curFILE)
@@ -2019 +2027 @@
  */
 static void
-ParseUnreadc(int c)
+ParseUnreadc(c)
+    int c;
 {
     if (curFILE) {
@@ -2033 +2042 @@
 
 /* ParseSkipLine():
- *      Grab the next line unless it begins with a dot (`.') and we're told to
- *      ignore such lines.
+ *      Grab the next line
  */
 static char *
-ParseSkipLine(int skip)
+ParseSkipLine(skip)
+    int skip;           /* Skip lines that don't start with . */
 {
     char *line;
@@ -2055 +2064 @@
                 lineno++;
 
-                while ((c = ParseReadc()) == ' ' || c == '\t')
-                    continue;
+                while ((c = ParseReadc()) == ' ' || c == '\t');
 
                 if (c == EOF)
@@ -2100 +2108 @@
  */
 static char *
-ParseReadLine (void)
+ParseReadLine ()
 {
     Buffer        buf;          /* Buffer for current line */
-    int           c;            /* the current character */
-    int           lastc;        /* The most-recent character */
+    register int  c;            /* the current character */
+    register int  lastc;        /* The most-recent character */
     Boolean       semiNL;       /* treat semi-colons as newlines */
     Boolean       ignDepOp;     /* TRUE if should ignore dependency operators
@@ -2221 +2229 @@
             case '#':
                 if (!ignComment) {
-                    if (lastc != '\\') {
+                    if (
+#if 0
+                    compatMake &&
+#endif
+                    (lastc != '\\')) {
                         /*
                          * If the character is a hash mark and it isn't escaped
@@ -2252 +2264 @@
                 }
                 break;
-            default:
-                break;
             }
             /*
@@ -2274 +2284 @@
         /*
          * Strip trailing blanks and tabs from the line.
-         * Do not strip a blank or tab that is preceded by
+         * Do not strip a blank or tab that is preceeded by
          * a '\'
          */
@@ -2305 +2315 @@
                 /*FALLTHRU*/
             case COND_PARSE:
-                free (line);
+                free ((Address) line);
                 line = ParseReadLine();
                 break;
@@ -2331 +2341 @@
                 }
                 break;
-            default:
-                break;
             }
         }
@@ -2359 +2367 @@
  */
 static void
-ParseFinishLine(void)
+ParseFinishLine()
 {
     if (inLine) {
-        Lst_ForEach(targets, Suff_EndTransform, (void *)NULL);
+        Lst_ForEach(targets, Suff_EndTransform, (ClientData)NULL);
         Lst_Destroy (targets, ParseHasCommands);
         targets = NULL;
@@ -2386 +2394 @@
  */
 void
-Parse_File(char *name, FILE *stream)
-{
-    char          *cp,          /* pointer into the line */
+Parse_File(name, stream)
+    char          *name;        /* the name of the file being read */
+    FILE *        stream;       /* Stream open to makefile to parse */
+{
+    register char *cp,          /* pointer into the line */
                   *line;        /* the line we're working on */
 
@@ -2404 +2414 @@
                  * include or undef directives.
                  */
-                for (cp = line + 1; isspace ((unsigned char) *cp); cp++) {
+                for (cp = line + 1; isspace (*cp); cp++) {
                     continue;
                 }
@@ -2443 +2453 @@
             shellCommand:
 #endif
-                for (cp = line + 1; isspace ((unsigned char) *cp); cp++) {
+                for (cp = line + 1; isspace (*cp); cp++) {
                     continue;
                 }
@@ -2454 +2464 @@
                          */
                         Lst_ForEach (targets, ParseAddCmd, cp);
-                        Lst_AtEnd(targCmds, (void *) line);
+                        Lst_AtEnd(targCmds, (ClientData) line);
                         continue;
                     } else {
@@ -2569 +2579 @@
  */
 void
-Parse_Init (void)
-{
-    mainNode = NULL;
+Parse_Init ()
+{
+    mainNode = NILGNODE;
     parseIncPath = Lst_Init (FALSE);
     sysIncPath = Lst_Init (FALSE);
@@ -2579 +2589 @@
 
 void
-Parse_End (void)
-{
-    Lst_Destroy(targCmds, (void (*)(void *)) free);
+Parse_End()
+{
+    Lst_Destroy(targCmds, (void (*) __P((ClientData))) free);
     if (targets)
         Lst_Destroy(targets, NOFREE);
@@ -2605 +2615 @@
  */
 Lst
-Parse_MainName(void)
+Parse_MainName()
 {
     Lst           listmain;     /* result list */
@@ -2611 +2621 @@
     listmain = Lst_Init (FALSE);
 
-    if (mainNode == NULL) {
+    if (mainNode == NILGNODE) {
         Punt ("no target to make.");
         /*NOTREACHED*/
     } else if (mainNode->type & OP_DOUBLEDEP) {
-        (void) Lst_AtEnd (listmain, (void *)mainNode);
+        (void) Lst_AtEnd (listmain, (ClientData)mainNode);
         Lst_Concat(listmain, mainNode->cohorts, LST_CONCNEW);
     }
     else
-        (void) Lst_AtEnd (listmain, (void *)mainNode);
+        (void) Lst_AtEnd (listmain, (ClientData)mainNode);
     return (listmain);
 }