parse.c

Timestamp:

Apr 7, 2003 1:30:32 AM (22 years ago)

Author:

bird

Message:

kMk and porting to kLib.

File:

: 1 edited

trunk/src/kmk/parse.c (modified) (89 diffs)

Legend:

: Unmodified
: Added
: Removed

trunk/src/kmk/parse.c

-              r46
+              r51
 /*
  * Copyright (c) 1988, 1989, 1990, 1993
  *      The Regents of the University of California.  All rights reserved.
+ *      The Regents of the University of California.  All rights reserved.
  * Copyright (c) 1989 by Berkeley Softworks
  * All rights reserved.
 …
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *      This product includes software developed by the University of
  *      California, Berkeley and its contributors.
+ *      This product includes software developed by the University of
+ *      California, Berkeley and its contributors.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
 …
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)parse.c     8.3 (Berkeley) 3/19/94";
+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
+#define KLIBFILEDEF rcsid
 #endif /* not lint */
 /*-
  * parse.c --
  *      Functions to parse a makefile.
+ *
  *      One function, Parse_Init, must be called before any functions
  *      in this module are used. After that, the function Parse_File is the
  *      main entry point and controls most of the other functions in this
  *      module.
+ *
  *      Most important structures are kept in Lsts. Directories for
  *      the #include "..." function are kept in the 'parseIncPath' Lst, while
  *      those for the #include <...> are kept in the 'sysIncPath' Lst. The
  *      targets currently being defined are kept in the 'targets' Lst.
+ *
  *      The variables 'fname' and 'lineno' are used to track the name
  *      of the current file and the line number in that file so that error
  *      messages can be more meaningful.
+ *      Functions to parse a makefile.
+ *
+ *      One function, Parse_Init, must be called before any functions
+ *      in this module are used. After that, the function Parse_File is the
+ *      main entry point and controls most of the other functions in this
+ *      module.
+ *
+ *      Most important structures are kept in Lsts. Directories for
+ *      the #include "..." function are kept in the 'parseIncPath' Lst, while
+ *      those for the #include <...> are kept in the 'sysIncPath' Lst. The
+ *      targets currently being defined are kept in the 'targets' Lst.
+ *
+ *      The variables 'fname' and 'lineno' are used to track the name
+ *      of the current file and the line number in that file so that error
+ *      messages can be more meaningful.
+ *
  * Interface:
  *      Parse_Init                  Initialization function which must be
  *                                  called before anything else in this module
  *                                  is used.
+ *
  *      Parse_End                   Cleanup the module
+ *
  *      Parse_File                  Function used to parse a makefile. It must
  *                                  be given the name of the file, which should
  *                                  already have been opened, and a function
  *                                  to call to read a character from the file.
+ *
  *      Parse_IsVar                 Returns TRUE if the given line is a
  *                                  variable assignment. Used by MainParseArgs
  *                                  to determine if an argument is a target
  *                                  or a variable assignment. Used internally
  *                                  for pretty much the same thing...
+ *
  *      Parse_Error                 Function called when an error occurs in
  *                                  parsing. Used by the variable and
  *                                  conditional modules.
  *      Parse_MainName              Returns a Lst of the main target to create.
  */
 #if defined(__STDC__) || defined(__IBMC__)
+ *      Parse_Init                  Initialization function which must be
+ *                                  called before anything else in this module
+ *                                  is used.
+ *
+ *      Parse_End                   Cleanup the module
+ *
+ *      Parse_File                  Function used to parse a makefile. It must
+ *                                  be given the name of the file, which should
+ *                                  already have been opened, and a function
+ *                                  to call to read a character from the file.
+ *
+ *      Parse_IsVar                 Returns TRUE if the given line is a
+ *                                  variable assignment. Used by MainParseArgs
+ *                                  to determine if an argument is a target
+ *                                  or a variable assignment. Used internally
+ *                                  for pretty much the same thing...
+ *
+ *      Parse_Error                 Function called when an error occurs in
+ *                                  parsing. Used by the variable and
+ *                                  conditional modules.
+ *      Parse_MainName              Returns a Lst of the main target to create.
+ */
+#ifdef __STDC__
 #include <stdarg.h>
 #else
 …
  * or if it's DONE.
  */
 #define CONTINUE        1
 #define DONE            0
 static Lst          targets;    /* targets we're working on */
 /*static Lst                targCmds; */        /* command lines for targets */
 static Boolean      inLine;     /* true if currently in a dependency
                                  * line or its commands */
+#define CONTINUE        1
+#define DONE            0
+static Lst          targets;    /* targets we're working on */
+/*static Lst                targCmds; */        /* command lines for targets */
+static Boolean      inLine;     /* true if currently in a dependency
+                                 * line or its commands */
 #if defined(USE_INLINEFILES)
 static Boolean      inInlineFile; /* true if currently in a inline file.*/
 …
 } PTR;
 static char         *fname;     /* name of current file (for errors) */
 static int          lineno;     /* line number in current file */
 static FILE         *curFILE = NULL;    /* current makefile */
 static PTR          *curPTR = NULL;     /* current makefile */
 static int          fatals = 0;
 static GNode        *mainNode;  /* The main target to create. This is the
                                  * first target on the first dependency
                                  * line in the first makefile */
+static char         *fname;     /* name of current file (for errors) */
+static int          lineno;     /* line number in current file */
+static FILE         *curFILE = NULL;    /* current makefile */
+static PTR          *curPTR = NULL;     /* current makefile */
+static int          fatals = 0;
+static GNode        *mainNode;  /* The main target to create. This is the
+                                 * first target on the first dependency
+                                 * line in the first makefile */
 /*
  * Definitions for handling #include specifications
  */
 typedef struct IFile {
     char           *fname;          /* name of previous file */
     int             lineno;         /* saved line number */
     FILE *          F;              /* the open stream */
     PTR *           p;              /* the char pointer */
+    char           *fname;          /* name of previous file */
+    int             lineno;         /* saved line number */
+    FILE *          F;              /* the open stream */
+    PTR *           p;              /* the char pointer */
 } IFile;
 static Lst      includes;       /* stack of IFiles generated by
                                  * #includes */
 Lst             parseIncPath;   /* list of directories for "..." includes */
 Lst             sysIncPath;     /* list of directories for <...> includes */
+static Lst      includes;       /* stack of IFiles generated by
+                                 * #includes */
+Lst             parseIncPath;   /* list of directories for "..." includes */
+Lst             sysIncPath;     /* list of directories for <...> includes */
 /*-
 …
  */
 typedef enum {
     Begin,          /* .BEGIN */
     Default,        /* .DEFAULT */
     End,            /* .END */
     Ignore,         /* .IGNORE */
     Includes,       /* .INCLUDES */
     Interrupt,      /* .INTERRUPT */
+    Begin,          /* .BEGIN */
+    Default,        /* .DEFAULT */
+    End,            /* .END */
+    Ignore,         /* .IGNORE */
+    Includes,       /* .INCLUDES */
+    Interrupt,      /* .INTERRUPT */
 #ifdef USE_ARCHIVES
     Libs,           /* .LIBS */
 #endif
     MFlags,         /* .MFLAGS or .MAKEFLAGS */
     Main,           /* .MAIN and we don't have anything user-specified to
                      * make */
     NoExport,       /* .NOEXPORT */
     Not,            /* Not special */
+    Libs,           /* .LIBS */
+#endif
+    MFlags,         /* .MFLAGS or .MAKEFLAGS */
+    Main,           /* .MAIN and we don't have anything user-specified to
+                     * make */
+    NoExport,       /* .NOEXPORT */
+    Not,            /* Not special */
     NotParallel,    /* .NOTPARALELL */
     Null,           /* .NULL */
     Order,          /* .ORDER */
     Parallel,       /* .PARALLEL */
     ExPath,         /* .PATH */
     Phony,          /* .PHONY */
+    Null,           /* .NULL */
+    Order,          /* .ORDER */
+    Parallel,       /* .PARALLEL */
+    ExPath,         /* .PATH */
+    Phony,          /* .PHONY */
 #ifdef POSIX
     Posix,          /* .POSIX */
 #endif
     Precious,       /* .PRECIOUS */
     ExShell,        /* .SHELL */
     Silent,         /* .SILENT */
+    Posix,          /* .POSIX */
+#endif
+    Precious,       /* .PRECIOUS */
+    ExShell,        /* .SHELL */
+    Silent,         /* .SILENT */
     SingleShell,    /* .SINGLESHELL */
     Suffixes,       /* .SUFFIXES */
     Wait,           /* .WAIT */
     Attribute       /* Generic attribute */
+    Suffixes,       /* .SUFFIXES */
+    Wait,           /* .WAIT */
+    Attribute       /* Generic attribute */
 } ParseSpecial;
 …
  * seen, then set to each successive source on the line.
  */
 static GNode    *predecessor;
+static GNode    *predecessor;
 /*
 …
  */
 static struct {
     char          *name;        /* Name of keyword */
     ParseSpecial  spec;         /* Type when used as a target */
     int           op;           /* Operator when used as a source */
+    char          *name;        /* Name of keyword */
+    ParseSpecial  spec;         /* Type when used as a target */
+    int           op;           /* Operator when used as a source */
 } parseKeywords[] = {
 { ".BEGIN",       Begin,        0 },
 { ".DEFAULT",     Default,      0 },
 { ".END",         End,          0 },
 { ".EXEC",        Attribute,    OP_EXEC },
 { ".IGNORE",      Ignore,       OP_IGNORE },
 { ".INCLUDES",    Includes,     0 },
 { ".INTERRUPT",   Interrupt,    0 },
 { ".INVISIBLE",   Attribute,    OP_INVISIBLE },
 { ".JOIN",        Attribute,    OP_JOIN },
+{ ".BEGIN",       Begin,        0 },
+{ ".DEFAULT",     Default,      0 },
+{ ".END",         End,          0 },
+{ ".EXEC",        Attribute,    OP_EXEC },
+{ ".IGNORE",      Ignore,       OP_IGNORE },
+{ ".INCLUDES",    Includes,     0 },
+{ ".INTERRUPT",   Interrupt,    0 },
+{ ".INVISIBLE",   Attribute,    OP_INVISIBLE },
+{ ".JOIN",        Attribute,    OP_JOIN },
 #ifdef USE_ARCHIVES
 { ".LIBS",        Libs,         0 },
 #endif
 { ".MAIN",        Main,         0 },
 { ".MAKE",        Attribute,    OP_MAKE },
 { ".MAKEFLAGS",   MFlags,       0 },
 { ".MFLAGS",      MFlags,       0 },
 { ".NOTMAIN",     Attribute,    OP_NOTMAIN },
 { ".NOTPARALLEL", NotParallel,  0 },
 { ".NO_PARALLEL", NotParallel,  0 },
 { ".NULL",        Null,         0 },
 { ".OPTIONAL",    Attribute,    OP_OPTIONAL },
 { ".ORDER",       Order,        0 },
 { ".PARALLEL",    Parallel,     0 },
 { ".PATH",        ExPath,       0 },
 { ".PHONY",       Phony,        OP_PHONY },
+{ ".LIBS",        Libs,         0 },
+#endif
+{ ".MAIN",        Main,         0 },
+{ ".MAKE",        Attribute,    OP_MAKE },
+{ ".MAKEFLAGS",   MFlags,       0 },
+{ ".MFLAGS",      MFlags,       0 },
+{ ".NOTMAIN",     Attribute,    OP_NOTMAIN },
+{ ".NOTPARALLEL", NotParallel,  0 },
+{ ".NO_PARALLEL", NotParallel,  0 },
+{ ".NULL",        Null,         0 },
+{ ".OPTIONAL",    Attribute,    OP_OPTIONAL },
+{ ".ORDER",       Order,        0 },
+{ ".PARALLEL",    Parallel,     0 },
+{ ".PATH",        ExPath,       0 },
+{ ".PHONY",       Phony,        OP_PHONY },
 #ifdef POSIX
 { ".POSIX",       Posix,        0 },
 #endif
 { ".PRECIOUS",    Precious,     OP_PRECIOUS },
 { ".RECURSIVE",   Attribute,    OP_MAKE },
 { ".SHELL",       ExShell,      0 },
 { ".SILENT",      Silent,       OP_SILENT },
 { ".SINGLESHELL", SingleShell,  0 },
 { ".SUFFIXES",    Suffixes,     0 },
 { ".USE",         Attribute,    OP_USE },
 { ".WAIT",        Wait,         0 },
+{ ".POSIX",       Posix,        0 },
+#endif
+{ ".PRECIOUS",    Precious,     OP_PRECIOUS },
+{ ".RECURSIVE",   Attribute,    OP_MAKE },
+{ ".SHELL",       ExShell,      0 },
+{ ".SILENT",      Silent,       OP_SILENT },
+{ ".SINGLESHELL", SingleShell,  0 },
+{ ".SUFFIXES",    Suffixes,     0 },
+{ ".USE",         Attribute,    OP_USE },
+{ ".WAIT",        Wait,         0 },
 };
 …
  *----------------------------------------------------------------------
  * ParseFindKeyword --
  *      Look in the table of keywords for one matching the given string.
+ *      Look in the table of keywords for one matching the given string.
+ *
  * Results:
  *      The index of the keyword, or -1 if it isn't there.
+ *      The index of the keyword, or -1 if it isn't there.
+ *
  * Side Effects:
  *      None
+ *      None
  *----------------------------------------------------------------------
  */
 static int
 ParseFindKeyword (str)
     char            *str;               /* String to find */
+    char            *str;               /* String to find */
+{
     register int    start,
                     end,
                     cur;
+                    end,
+                    cur;
     register int    diff;
 …
     do {
         cur = start + ((end - start) / 2);
         diff = strcmp (str, parseKeywords[cur].name);
         if (diff == 0) {
             return (cur);
         } else if (diff < 0) {
             end = cur - 1;
         } else {
             start = cur + 1;
+        }
+        cur = start + ((end - start) / 2);
+        diff = strcmp (str, parseKeywords[cur].name);
+        if (diff == 0) {
+            return (cur);
+        } else if (diff < 0) {
+            end = cur - 1;
+        } else {
+            start = cur + 1;
+        }
     } while (start <= end);
     return (-1);
 …
 /*-
  * Parse_Error  --
  *      Error message abort function for parsing. Prints out the context
  *      of the error (line number and file) as well as the message with
  *      two optional arguments.
+ *      Error message abort function for parsing. Prints out the context
+ *      of the error (line number and file) as well as the message with
+ *      two optional arguments.
+ *
  * Results:
  *      None
+ *      None
+ *
  * Side Effects:
  *      "fatals" is incremented if the level is PARSE_FATAL.
+ *      "fatals" is incremented if the level is PARSE_FATAL.
  */
 /* VARARGS */
 …
 #else
 Parse_Error(va_alist)
         va_dcl
 #endif
+{
         va_list ap;
+        va_dcl
+#endif
+{
+        va_list ap;
 #if defined(__STDC__) || defined(__IBMC__)
         va_start(ap, fmt);
+        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)
                 (void)fprintf(stderr, "warning: ");
         (void)vfprintf(stderr, fmt, ap);
         va_end(ap);
         (void)fprintf(stderr, "\n");
         (void)fflush(stderr);
         if (type == PARSE_FATAL)
                 fatals += 1;
+        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)
+                (void)fprintf(stderr, "warning: ");
+        (void)vfprintf(stderr, fmt, ap);
+        va_end(ap);
+        (void)fprintf(stderr, "\n");
+        (void)fflush(stderr);
+        if (type == PARSE_FATAL)
+                fatals += 1;
+}
 …
  *---------------------------------------------------------------------
  * ParseLinkSrc  --
  *      Link the parent node to its new child. Used in a Lst_ForEach by
  *      ParseDoDependency. If the specType isn't 'Not', the parent
  *      isn't linked as a parent of the child.
+ *      Link the parent node to its new child. Used in a Lst_ForEach by
+ *      ParseDoDependency. If the specType isn't 'Not', the parent
+ *      isn't linked as a parent of the child.
+ *
  * Results:
  *      Always = 0
+ *      Always = 0
+ *
  * Side Effects:
  *      New elements are added to the parents list of cgn and the
  *      children list of cgn. the unmade field of pgn is updated
  *      to reflect the additional child.
+ *      New elements are added to the parents list of cgn and the
+ *      children list of cgn. the unmade field of pgn is updated
+ *      to reflect the additional child.
  *---------------------------------------------------------------------
  */
 static int
 ParseLinkSrc (pgnp, cgnp)
     ClientData     pgnp;        /* The parent node */
     ClientData     cgnp;        /* The child node */
+    ClientData     pgnp;        /* The parent node */
+    ClientData     cgnp;        /* The child node */
+{
     GNode          *pgn = (GNode *) pgnp;
     GNode          *cgn = (GNode *) cgnp;
     if (Lst_Member (pgn->children, (ClientData)cgn) == NILLNODE) {
         (void)Lst_AtEnd (pgn->children, (ClientData)cgn);
         if (specType == Not) {
             (void)Lst_AtEnd (cgn->parents, (ClientData)pgn);
+        }
         pgn->unmade += 1;
+        (void)Lst_AtEnd (pgn->children, (ClientData)cgn);
+        if (specType == Not) {
+            (void)Lst_AtEnd (cgn->parents, (ClientData)pgn);
+        }
+        pgn->unmade += 1;
+    }
     return (0);
 …
  *---------------------------------------------------------------------
  * ParseDoOp  --
  *      Apply the parsed operator to the given target node. Used in a
  *      Lst_ForEach call by ParseDoDependency once all targets have
  *      been found and their operator parsed. If the previous and new
  *      operators are incompatible, a major error is taken.
+ *      Apply the parsed operator to the given target node. Used in a
+ *      Lst_ForEach call by ParseDoDependency once all targets have
+ *      been found and their operator parsed. If the previous and new
+ *      operators are incompatible, a major error is taken.
+ *
  * Results:
  *      Always 0
+ *      Always 0
+ *
  * Side Effects:
  *      The type field of the node is altered to reflect any new bits in
  *      the op.
+ *      The type field of the node is altered to reflect any new bits in
+ *      the op.
  *---------------------------------------------------------------------
  */
 static int
 ParseDoOp (gnp, opp)
     ClientData     gnp;         /* The node to which the operator is to be
                                  * applied */
     ClientData     opp;         /* The operator to apply */
+    ClientData     gnp;         /* The node to which the operator is to be
+                                 * applied */
+    ClientData     opp;         /* The operator to apply */
+{
     GNode          *gn = (GNode *) gnp;
 …
      */
     if (((op & OP_OPMASK) != (gn->type & OP_OPMASK)) &&
         !OP_NOP(gn->type) && !OP_NOP(op))
+        !OP_NOP(gn->type) && !OP_NOP(op))
+    {
         Parse_Error (PARSE_FATAL, "Inconsistent operator for %s", gn->name);
         return (1);
+        Parse_Error (PARSE_FATAL, "Inconsistent operator for %s", gn->name);
+        return (1);
+    }
     if ((op == OP_DOUBLEDEP) && ((gn->type & OP_OPMASK) == OP_DOUBLEDEP)) {
         /*
          * If the node was the object of a :: operator, we need to create a
          * new instance of it for the children and commands on this dependency
          * line. The new instance is placed on the 'cohorts' list of the
          * initial one (note the initial one is not on its own cohorts list)
          * and the new instance is linked to all parents of the initial
          * instance.
          */
         register GNode  *cohort;
         LstNode         ln;
         cohort = Targ_NewGN(gn->name);
         /*
          * Duplicate links to parents so graph traversal is simple. Perhaps
          * some type bits should be duplicated?
+         *
          * Make the cohort invisible as well to avoid duplicating it into
          * other variables. True, parents of this target won't tend to do
          * anything with their local variables, but better safe than
          * sorry.
          */
         Lst_ForEach(gn->parents, ParseLinkSrc, (ClientData)cohort);
         cohort->type = OP_DOUBLEDEP|OP_INVISIBLE;
         (void)Lst_AtEnd(gn->cohorts, (ClientData)cohort);
         /*
          * Replace the node in the targets list with the new copy
          */
         ln = Lst_Member(targets, (ClientData)gn);
         Lst_Replace(ln, (ClientData)cohort);
         gn = cohort;
+        /*
+         * If the node was the object of a :: operator, we need to create a
+         * new instance of it for the children and commands on this dependency
+         * line. The new instance is placed on the 'cohorts' list of the
+         * initial one (note the initial one is not on its own cohorts list)
+         * and the new instance is linked to all parents of the initial
+         * instance.
+         */
+        register GNode  *cohort;
+        LstNode         ln;
+        cohort = Targ_NewGN(gn->name);
+        /*
+         * Duplicate links to parents so graph traversal is simple. Perhaps
+         * some type bits should be duplicated?
+         *
+         * Make the cohort invisible as well to avoid duplicating it into
+         * other variables. True, parents of this target won't tend to do
+         * anything with their local variables, but better safe than
+         * sorry.
+         */
+        Lst_ForEach(gn->parents, ParseLinkSrc, (ClientData)cohort);
+        cohort->type = OP_DOUBLEDEP|OP_INVISIBLE;
+        (void)Lst_AtEnd(gn->cohorts, (ClientData)cohort);
+        /*
+         * Replace the node in the targets list with the new copy
+         */
+        ln = Lst_Member(targets, (ClientData)gn);
+        Lst_Replace(ln, (ClientData)cohort);
+        gn = cohort;
+    }
     /*
 …
  *---------------------------------------------------------------------
  * ParseAddDep  --
  *      Check if the pair of GNodes given needs to be synchronized.
  *      This has to be when two nodes are on different sides of a
  *      .WAIT directive.
+ *      Check if the pair of GNodes given needs to be synchronized.
+ *      This has to be when two nodes are on different sides of a
+ *      .WAIT directive.
+ *
  * Results:
  *      Returns 1 if the two targets need to be ordered, 0 otherwise.
  *      If it returns 1, the search can stop
+ *      Returns 1 if the two targets need to be ordered, 0 otherwise.
+ *      If it returns 1, the search can stop
+ *
  * Side Effects:
  *      A dependency can be added between the two nodes.
+ *      A dependency can be added between the two nodes.
+ *
  *---------------------------------------------------------------------
 …
     if (p->order < s->order) {
         /*
          * XXX: This can cause loops, and loops can cause unmade targets,
          * but checking is tedious, and the debugging output can show the
          * problem
          */
         (void)Lst_AtEnd(p->successors, (ClientData)s);
         (void)Lst_AtEnd(s->preds, (ClientData)p);
         return 0;
+        /*
+         * XXX: This can cause loops, and loops can cause unmade targets,
+         * but checking is tedious, and the debugging output can show the
+         * problem
+         */
+        (void)Lst_AtEnd(p->successors, (ClientData)s);
+        (void)Lst_AtEnd(s->preds, (ClientData)p);
+        return 0;
+    }
     else
         return 1;
+        return 1;
+}
 …
  *---------------------------------------------------------------------
  * ParseDoSrc  --
  *      Given the name of a source, figure out if it is an attribute
  *      and apply it to the targets if it is. Else decide if there is
  *      some attribute which should be applied *to* the source because
  *      of some special target and apply it if so. Otherwise, make the
  *      source be a child of the targets in the list 'targets'
+ *      Given the name of a source, figure out if it is an attribute
+ *      and apply it to the targets if it is. Else decide if there is
+ *      some attribute which should be applied *to* the source because
+ *      of some special target and apply it if so. Otherwise, make the
+ *      source be a child of the targets in the list 'targets'
+ *
  * Results:
  *      None
+ *      None
+ *
  * Side Effects:
  *      Operator bits may be added to the list of targets or to the source.
  *      The targets may have a new source added to their lists of children.
+ *      Operator bits may be added to the list of targets or to the source.
+ *      The targets may have a new source added to their lists of children.
  *---------------------------------------------------------------------
  */
 static void
 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;
+    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 (src[1])) {
         int keywd = ParseFindKeyword(src);
         if (keywd != -1) {
             int op = parseKeywords[keywd].op;
             if (op != 0) {
                 Lst_ForEach (targets, ParseDoOp, (ClientData)&op);
                 return;
+            }
             if (parseKeywords[keywd].spec == Wait) {
                 waiting++;
                 return;
+            }
+        }
+        int keywd = ParseFindKeyword(src);
+        if (keywd != -1) {
+            int op = parseKeywords[keywd].op;
+            if (op != 0) {
+                Lst_ForEach (targets, ParseDoOp, (ClientData)&op);
+                return;
+            }
+            if (parseKeywords[keywd].spec == Wait) {
+                waiting++;
+                return;
+            }
+        }
+    }
     switch (specType) {
     case Main:
         /*
          * If we have noted the existence of a .MAIN, it means we need
          * to add the sources of said target to the list of things
          * to create. The string 'src' is likely to be efree, so we
          * must make a new copy of it. Note that this will only be
          * invoked if the user didn't specify a target on the command
          * line. This is to allow #ifmake's to succeed, or something...
          */
         (void) Lst_AtEnd (create, (ClientData)estrdup(src));
         /*
          * Add the name to the .TARGETS variable as well, so the user cna
          * employ that, if desired.
          */
         Var_Append(".TARGETS", src, VAR_GLOBAL);
         return;
+        /*
+         * If we have noted the existence of a .MAIN, it means we need
+         * to add the sources of said target to the list of things
+         * to create. The string 'src' is likely to be efree, so we
+         * must make a new copy of it. Note that this will only be
+         * invoked if the user didn't specify a target on the command
+         * line. This is to allow #ifmake's to succeed, or something...
+         */
+        (void) Lst_AtEnd (create, (ClientData)estrdup(src));
+        /*
+         * Add the name to the .TARGETS variable as well, so the user cna
+         * employ that, if desired.
+         */
+        Var_Append(".TARGETS", src, VAR_GLOBAL);
+        return;
     case Order:
         /*
          * Create proper predecessor/successor links between the previous
          * source and the current one.
          */
         gn = Targ_FindNode(src, TARG_CREATE);
         if (predecessor != NILGNODE) {
             (void)Lst_AtEnd(predecessor->successors, (ClientData)gn);
             (void)Lst_AtEnd(gn->preds, (ClientData)predecessor);
+        }
         /*
          * The current source now becomes the predecessor for the next one.
          */
         predecessor = gn;
         break;
+        /*
+         * Create proper predecessor/successor links between the previous
+         * source and the current one.
+         */
+        gn = Targ_FindNode(src, TARG_CREATE);
+        if (predecessor != NILGNODE) {
+            (void)Lst_AtEnd(predecessor->successors, (ClientData)gn);
+            (void)Lst_AtEnd(gn->preds, (ClientData)predecessor);
+        }
+        /*
+         * The current source now becomes the predecessor for the next one.
+         */
+        predecessor = gn;
+        break;
     default:
         /*
          * If the source is not an attribute, we need to find/create
          * a node for it. After that we can apply any operator to it
          * from a special target or link it to its parents, as
          * appropriate.
+         *
          * In the case of a source that was the object of a :: operator,
          * the attribute is applied to all of its instances (as kept in
          * the 'cohorts' list of the node) or all the cohorts are linked
          * to all the targets.
          */
         gn = Targ_FindNode (src, TARG_CREATE);
         if (tOp) {
             gn->type |= tOp;
         } else {
             Lst_ForEach (targets, ParseLinkSrc, (ClientData)gn);
+        }
         if ((gn->type & OP_OPMASK) == OP_DOUBLEDEP) {
             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, (ClientData)cohort);
+                }
+            }
+        }
         break;
+        /*
+         * If the source is not an attribute, we need to find/create
+         * a node for it. After that we can apply any operator to it
+         * from a special target or link it to its parents, as
+         * appropriate.
+         *
+         * In the case of a source that was the object of a :: operator,
+         * the attribute is applied to all of its instances (as kept in
+         * the 'cohorts' list of the node) or all the cohorts are linked
+         * to all the targets.
+         */
+        gn = Targ_FindNode (src, TARG_CREATE);
+        if (tOp) {
+            gn->type |= tOp;
+        } else {
+            Lst_ForEach (targets, ParseLinkSrc, (ClientData)gn);
+        }
+        if ((gn->type & OP_OPMASK) == OP_DOUBLEDEP) {
+            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, (ClientData)cohort);
+                }
+            }
+        }
+        break;
+    }
 …
     (void)Lst_AtEnd(allsrc, (ClientData)gn);
     if (waiting) {
         Lst_ForEach(allsrc, ParseAddDep, (ClientData)gn);
+        Lst_ForEach(allsrc, ParseAddDep, (ClientData)gn);
+    }
+}
 …
  *-----------------------------------------------------------------------
  * ParseFindMain --
  *      Find a real target in the list and set it to be the main one.
  *      Called by ParseDoDependency when a main target hasn't been found
  *      yet.
+ *      Find a real target in the list and set it to be the main one.
+ *      Called by ParseDoDependency when a main target hasn't been found
+ *      yet.
+ *
  * Results:
  *      0 if main not found yet, 1 if it is.
+ *      0 if main not found yet, 1 if it is.
+ *
  * Side Effects:
  *      mainNode is changed and Targ_SetMain is called.
+ *      mainNode is changed and Targ_SetMain is called.
+ *
  *-----------------------------------------------------------------------
 …
 static int
 ParseFindMain(gnp, dummy)
     ClientData    gnp;      /* Node to examine */
+    ClientData    gnp;      /* Node to examine */
     ClientData    dummy;
+{
     GNode         *gn = (GNode *) gnp;
+    GNode         *gn = (GNode *) gnp;
     if ((gn->type & (OP_NOTMAIN|OP_USE|OP_EXEC|OP_TRANSFORM)) == 0) {
         mainNode = gn;
         Targ_SetMain(gn);
         return (dummy ? 1 : 1);
+        mainNode = gn;
+        Targ_SetMain(gn);
+        return (dummy ? 1 : 1);
     } else {
         return (dummy ? 0 : 0);
+        return (dummy ? 0 : 0);
+    }
+}
 …
  *-----------------------------------------------------------------------
  * ParseAddDir --
  *      Front-end for Dir_AddDir to make sure Lst_ForEach keeps going
+ *      Front-end for Dir_AddDir to make sure Lst_ForEach keeps going
+ *
  * Results:
  *      === 0
+ *      === 0
+ *
  * Side Effects:
  *      See Dir_AddDir.
+ *      See Dir_AddDir.
+ *
  *-----------------------------------------------------------------------
 …
 static int
 ParseAddDir(path, name)
     ClientData    path;
+    ClientData    path;
     ClientData    name;
+{
 …
  *-----------------------------------------------------------------------
  * ParseClearPath --
  *      Front-end for Dir_ClearPath to make sure Lst_ForEach keeps going
+ *      Front-end for Dir_ClearPath to make sure Lst_ForEach keeps going
+ *
  * Results:
  *      === 0
+ *      === 0
+ *
  * Side Effects:
  *      See Dir_ClearPath
+ *      See Dir_ClearPath
+ *
  *-----------------------------------------------------------------------
 …
  *---------------------------------------------------------------------
  * ParseDoDependency  --
  *      Parse the dependency line in line.
+ *      Parse the dependency line in line.
+ *
  * Results:
  *      None
+ *      None
+ *
  * Side Effects:
  *      The nodes of the sources are linked as children to the nodes of the
  *      targets. Some nodes may be created.
+ *
  *      We parse a dependency line by first extracting words from the line and
+ *      The nodes of the sources are linked as children to the nodes of the
+ *      targets. Some nodes may be created.
+ *
+ *      We parse a dependency line by first extracting words from the line and
  * finding nodes in the list of all targets with that name. This is done
  * until a character is encountered which is an operator character. Currently
  * these are only ! and :. At this point the operator is parsed and the
  * pointer into the line advanced until the first source is encountered.
  *      The parsed operator is applied to each node in the 'targets' list,
+ *      The parsed operator is applied to each node in the 'targets' list,
  * which is where the nodes found for the targets are kept, by means of
  * the ParseDoOp function.
  *      The sources are read in much the same way as the targets were except
+ *      The sources are read in much the same way as the targets were except
  * that now they are expanded using the wildcarding scheme of the C-Shell
  * and all instances of the resulting words in the list of all targets
  * are found. Each of the resulting nodes is then linked to each of the
  * targets as one of its children.
  *      Certain targets are handled specially. These are the ones detailed
+ *      Certain targets are handled specially. These are the ones detailed
  * by the specType variable.
  *      The storing of transformation rules is also taken care of here.
+ *      The storing of transformation rules is also taken care of here.
  * A target is recognized as a transformation rule by calling
  * Suff_IsTransform. If it is a transformation rule, its node is gotten
 …
 static void
 ParseDoDependency (line)
     char           *line;       /* the line to parse */
+{
     char           *cp;         /* our current position */
     GNode          *gn;         /* a general purpose temporary node */
     int             op;         /* the operator on the line */
     char            savec;      /* a place to save a character */
     Lst             paths;      /* List of search paths to alter when parsing
                                  * a list of .PATH targets */
     int             tOp;        /* operator from special target */
+    char           *line;       /* the line to parse */
+{
+    char           *cp;         /* our current position */
+    GNode          *gn;         /* a general purpose temporary node */
+    int             op;         /* the operator on the line */
+    char            savec;      /* a place to save a character */
+    Lst             paths;      /* List of search paths to alter when parsing
+                                 * a list of .PATH targets */
+    int             tOp;        /* operator from special target */
 #ifdef USE_ARCHIVES
     Lst             sources;    /* list of archive source names after
                                  * expansion */
 #endif
     Lst             curTargs;   /* list of target names to be found and added
                                  * to the targets list */
     Lst             curSrcs;    /* list of sources in order */
+    Lst             sources;    /* list of archive source names after
+                                 * expansion */
+#endif
+    Lst             curTargs;   /* list of target names to be found and added
+                                 * to the targets list */
+    Lst             curSrcs;    /* list of sources in order */
     tOp = 0;
 …
     do {
         for (cp = line;
              *cp && !isspace (*cp) &&
              (*cp != '!') && (*cp != ':') && (*cp != '(');
              cp++)
+        {
             if (*cp == '$') {
                 /*
                  * Must be a dynamic source (would have been expanded
                  * otherwise), so call the Var module to parse the puppy
                  * so we can safely advance beyond it...There should be
                  * no errors in this, as they would have been discovered
                  * in the initial Var_Subst and we wouldn't be here.
                  */
                 int     length;
                 Boolean freeIt;
                 char    *result;
                 result=Var_Parse(cp, VAR_CMD, TRUE, &length, &freeIt);
                 if (freeIt) {
                     efree(result);
+                }
                 cp += length-1;
+            }
             continue;
+        }
         if (*cp == '(') {
+        for (cp = line;
+             *cp && !isspace (*cp) &&
+             (*cp != '!') && (*cp != ':') && (*cp != '(');
+             cp++)
+        {
+            if (*cp == '$') {
+                /*
+                 * Must be a dynamic source (would have been expanded
+                 * otherwise), so call the Var module to parse the puppy
+                 * so we can safely advance beyond it...There should be
+                 * no errors in this, as they would have been discovered
+                 * in the initial Var_Subst and we wouldn't be here.
+                 */
+                int     length;
+                Boolean freeIt;
+                char    *result;
+                result=Var_Parse(cp, VAR_CMD, TRUE, &length, &freeIt);
+                if (freeIt) {
+                    efree(result);
+                }
+                cp += length-1;
+            }
+            continue;
+        }
+        if (*cp == '(') {
 #ifdef USE_ARCHIVES
             /*
              * Archives must be handled specially to make sure the OP_ARCHV
              * flag is set in their 'type' field, for one thing, and because
              * things like "archive(file1.o file2.o file3.o)" are permissible.
              * Arch_ParseArchive will set 'line' to be the first non-blank
              * after the archive-spec. It creates/finds nodes for the members
              * and places them on the given list, returning SUCCESS if all
              * went well and FAILURE if there was an error in the
              * specification. On error, line should remain untouched.
              */
             if (Arch_ParseArchive (&line, targets, VAR_CMD) != SUCCESS) {
                 Parse_Error (PARSE_FATAL,
                              "Error in archive specification: \"%s\"", line);
                 return;
             } else
                 continue;
+            /*
+             * Archives must be handled specially to make sure the OP_ARCHV
+             * flag is set in their 'type' field, for one thing, and because
+             * things like "archive(file1.o file2.o file3.o)" are permissible.
+             * Arch_ParseArchive will set 'line' to be the first non-blank
+             * after the archive-spec. It creates/finds nodes for the members
+             * and places them on the given list, returning SUCCESS if all
+             * went well and FAILURE if there was an error in the
+             * specification. On error, line should remain untouched.
+             */
+            if (Arch_ParseArchive (&line, targets, VAR_CMD) != SUCCESS) {
+                Parse_Error (PARSE_FATAL,
+                             "Error in archive specification: \"%s\"", line);
+                return;
+            } else
+                continue;
 #else
             Parse_Error(PARSE_FATAL, "Archives are not supported!", line);
             return;
 #endif /* USE_ARCHIVES */
+        }
         savec = *cp;
         if (!*cp) {
             /*
              * Ending a dependency line without an operator is a Bozo
              * no-no
              */
             Parse_Error (PARSE_FATAL, "Need an operator");
             return;
+        }
         *cp = '\0';
         /*
          * Have a word in line. See if it's a special target and set
          * specType to match it.
          */
         if (*line == '.' && isupper (line[1])) {
             /*
              * See if the target is a special target that must have it
              * or its sources handled specially.
              */
             int keywd = ParseFindKeyword(line);
             if (keywd != -1) {
                 if (specType == ExPath && parseKeywords[keywd].spec != ExPath) {
                     Parse_Error(PARSE_FATAL, "Mismatched special targets");
                     return;
+                }
                 specType = parseKeywords[keywd].spec;
                 tOp = parseKeywords[keywd].op;
                 /*
                  * Certain special targets have special semantics:
                  *      .PATH           Have to set the dirSearchPath
                  *                      variable too
                  *      .MAIN           Its sources are only used if
                  *                      nothing has been specified to
                  *                      create.
                  *      .DEFAULT        Need to create a node to hang
                  *                      commands on, but we don't want
                  *                      it in the graph, nor do we want
                  *                      it to be the Main Target, so we
                  *                      create it, set OP_NOTMAIN and
                  *                      add it to the list, setting
                  *                      DEFAULT to the new node for
                  *                      later use. We claim the node is
                  *                      A transformation rule to make
                  *                      life easier later, when we'll
                  *                      use Make_HandleUse to actually
                  *                      apply the .DEFAULT commands.
                  *      .PHONY          The list of targets
                  *      .BEGIN
                  *      .END
                  *      .INTERRUPT      Are not to be considered the
                  *                      main target.
                  *      .NOTPARALLEL    Make only one target at a time.
                  *      .SINGLESHELL    Create a shell for each command.
                  *      .ORDER          Must set initial predecessor to NIL
                  */
                 switch (specType) {
                     case ExPath:
                         if (paths == NULL) {
                             paths = Lst_Init(FALSE);
+                        }
                         (void)Lst_AtEnd(paths, (ClientData)dirSearchPath);
                         break;
                     case Main:
                         if (!Lst_IsEmpty(create)) {
                             specType = Not;
+                        }
                         break;
                     case Begin:
                     case End:
                     case Interrupt:
                         gn = Targ_FindNode(line, TARG_CREATE);
                         gn->type |= OP_NOTMAIN;
                         (void)Lst_AtEnd(targets, (ClientData)gn);
                         break;
                     case Default:
                         gn = Targ_NewGN(".DEFAULT");
                         gn->type |= (OP_NOTMAIN|OP_TRANSFORM);
                         (void)Lst_AtEnd(targets, (ClientData)gn);
                         DEFAULT = gn;
                         break;
                     case NotParallel:
+                    {
                         extern int  maxJobs;
                         maxJobs = 1;
                         break;
+                    }
                     case SingleShell:
                         compatMake = 1;
                         break;
                     case Order:
                         predecessor = NILGNODE;
                         break;
                     default:
                         break;
+                }
             } else if (strncmp (line, ".PATH", 5) == 0) {
                 /*
                  * .PATH<suffix> has to be handled specially.
                  * Call on the suffix module to give us a path to
                  * modify.
                  */
                 Lst     path;
                 specType = ExPath;
                 path = Suff_GetPath (&line[5]);
                 if (path == NILLST) {
                     Parse_Error (PARSE_FATAL,
                                  "Suffix '%s' not defined (yet)",
                                  &line[5]);
                     return;
                 } else {
                     if (paths == (Lst)NULL) {
                         paths = Lst_Init(FALSE);
+                    }
                     (void)Lst_AtEnd(paths, (ClientData)path);
+                }
+            }
+        }
         /*
          * Have word in line. Get or create its node and stick it at
          * the end of the targets list
          */
         if ((specType == Not) && (*line != '\0')) {
             if (Dir_HasWildcards(line)) {
                 /*
                  * Targets are to be sought only in the current directory,
                  * so create an empty path for the thing. Note we need to
                  * use Dir_Destroy in the destruction of the path as the
                  * Dir module could have added a directory to the path...
                  */
                 Lst         emptyPath = Lst_Init(FALSE);
                 Dir_Expand(line, emptyPath, curTargs);
                 Lst_Destroy(emptyPath, Dir_Destroy);
             } else {
                 /*
                  * No wildcards, but we want to avoid code duplication,
                  * so create a list with the word on it.
                  */
                 (void)Lst_AtEnd(curTargs, (ClientData)line);
+            }
             while(!Lst_IsEmpty(curTargs)) {
                 char    *targName = (char *)Lst_DeQueue(curTargs);
                 if (!Suff_IsTransform (targName)) {
                     gn = Targ_FindNode (targName, TARG_CREATE);
                 } else {
                     gn = Suff_AddTransform (targName);
+                }
                 (void)Lst_AtEnd (targets, (ClientData)gn);
+            }
         } else if (specType == ExPath && *line != '.' && *line != '\0') {
             Parse_Error(PARSE_WARNING, "Extra target (%s) ignored", line);
+        }
         *cp = savec;
         /*
          * If it is a special type and not .PATH, it's the only target we
          * allow on this line...
          */
         if (specType != Not && specType != ExPath) {
             Boolean warn = FALSE;
             while ((*cp != '!') && (*cp != ':') && *cp) {
                 if (*cp != ' ' && *cp != '\t') {
                     warn = TRUE;
+                }
                 cp++;
+            }
             if (warn) {
                 Parse_Error(PARSE_WARNING, "Extra target ignored");
+            }
         } else {
             while (*cp && isspace (*cp)) {
                 cp++;
+            }
+        }
         line = cp;
+        }
+        savec = *cp;
+        if (!*cp) {
+            /*
+             * Ending a dependency line without an operator is a Bozo
+             * no-no
+             */
+            Parse_Error (PARSE_FATAL, "Need an operator");
+            return;
+        }
+        *cp = '\0';
+        /*
+         * Have a word in line. See if it's a special target and set
+         * specType to match it.
+         */
+        if (*line == '.' && isupper (line[1])) {
+            /*
+             * See if the target is a special target that must have it
+             * or its sources handled specially.
+             */
+            int keywd = ParseFindKeyword(line);
+            if (keywd != -1) {
+                if (specType == ExPath && parseKeywords[keywd].spec != ExPath) {
+                    Parse_Error(PARSE_FATAL, "Mismatched special targets");
+                    return;
+                }
+                specType = parseKeywords[keywd].spec;
+                tOp = parseKeywords[keywd].op;
+                /*
+                 * Certain special targets have special semantics:
+                 *      .PATH           Have to set the dirSearchPath
+                 *                      variable too
+                 *      .MAIN           Its sources are only used if
+                 *                      nothing has been specified to
+                 *                      create.
+                 *      .DEFAULT        Need to create a node to hang
+                 *                      commands on, but we don't want
+                 *                      it in the graph, nor do we want
+                 *                      it to be the Main Target, so we
+                 *                      create it, set OP_NOTMAIN and
+                 *                      add it to the list, setting
+                 *                      DEFAULT to the new node for
+                 *                      later use. We claim the node is
+                 *                      A transformation rule to make
+                 *                      life easier later, when we'll
+                 *                      use Make_HandleUse to actually
+                 *                      apply the .DEFAULT commands.
+                 *      .PHONY          The list of targets
+                 *      .BEGIN
+                 *      .END
+                 *      .INTERRUPT      Are not to be considered the
+                 *                      main target.
+                 *      .NOTPARALLEL    Make only one target at a time.
+                 *      .SINGLESHELL    Create a shell for each command.
+                 *      .ORDER          Must set initial predecessor to NIL
+                 */
+                switch (specType) {
+                    case ExPath:
+                        if (paths == NULL) {
+                            paths = Lst_Init(FALSE);
+                        }
+                        (void)Lst_AtEnd(paths, (ClientData)dirSearchPath);
+                        break;
+                    case Main:
+                        if (!Lst_IsEmpty(create)) {
+                            specType = Not;
+                        }
+                        break;
+                    case Begin:
+                    case End:
+                    case Interrupt:
+                        gn = Targ_FindNode(line, TARG_CREATE);
+                        gn->type |= OP_NOTMAIN;
+                        (void)Lst_AtEnd(targets, (ClientData)gn);
+                        break;
+                    case Default:
+                        gn = Targ_NewGN(".DEFAULT");
+                        gn->type |= (OP_NOTMAIN|OP_TRANSFORM);
+                        (void)Lst_AtEnd(targets, (ClientData)gn);
+                        DEFAULT = gn;
+                        break;
+                    case NotParallel:
+                    {
+                        extern int  maxJobs;
+                        maxJobs = 1;
+                        break;
+                    }
+                    case SingleShell:
+                        compatMake = 1;
+                        break;
+                    case Order:
+                        predecessor = NILGNODE;
+                        break;
+                    default:
+                        break;
+                }
+            } else if (strncmp (line, ".PATH", 5) == 0) {
+                /*
+                 * .PATH<suffix> has to be handled specially.
+                 * Call on the suffix module to give us a path to
+                 * modify.
+                 */
+                Lst     path;
+                specType = ExPath;
+                path = Suff_GetPath (&line[5]);
+                if (path == NILLST) {
+                    Parse_Error (PARSE_FATAL,
+                                 "Suffix '%s' not defined (yet)",
+                                 &line[5]);
+                    return;
+                } else {
+                    if (paths == (Lst)NULL) {
+                        paths = Lst_Init(FALSE);
+                    }
+                    (void)Lst_AtEnd(paths, (ClientData)path);
+                }
+            }
+        }
+        /*
+         * Have word in line. Get or create its node and stick it at
+         * the end of the targets list
+         */
+        if ((specType == Not) && (*line != '\0')) {
+            if (Dir_HasWildcards(line)) {
+                /*
+                 * Targets are to be sought only in the current directory,
+                 * so create an empty path for the thing. Note we need to
+                 * use Dir_Destroy in the destruction of the path as the
+                 * Dir module could have added a directory to the path...
+                 */
+                Lst         emptyPath = Lst_Init(FALSE);
+                Dir_Expand(line, emptyPath, curTargs);
+                Lst_Destroy(emptyPath, Dir_Destroy);
+            } else {
+                /*
+                 * No wildcards, but we want to avoid code duplication,
+                 * so create a list with the word on it.
+                 */
+                (void)Lst_AtEnd(curTargs, (ClientData)line);
+            }
+            while(!Lst_IsEmpty(curTargs)) {
+                char    *targName = (char *)Lst_DeQueue(curTargs);
+                if (!Suff_IsTransform (targName)) {
+                    gn = Targ_FindNode (targName, TARG_CREATE);
+                } else {
+                    gn = Suff_AddTransform (targName);
+                }
+                (void)Lst_AtEnd (targets, (ClientData)gn);
+            }
+        } else if (specType == ExPath && *line != '.' && *line != '\0') {
+            Parse_Error(PARSE_WARNING, "Extra target (%s) ignored", line);
+        }
+        *cp = savec;
+        /*
+         * If it is a special type and not .PATH, it's the only target we
+         * allow on this line...
+         */
+        if (specType != Not && specType != ExPath) {
+            Boolean warn = FALSE;
+            while ((*cp != '!') && (*cp != ':') && *cp) {
+                if (*cp != ' ' && *cp != '\t') {
+                    warn = TRUE;
+                }
+                cp++;
+            }
+            if (warn) {
+                Parse_Error(PARSE_WARNING, "Extra target ignored");
+            }
+        } else {
+            while (*cp && isspace (*cp)) {
+                cp++;
+            }
+        }
+        line = cp;
     } while ((*line != '!') && (*line != ':') && *line);
 …
     if (!Lst_IsEmpty(targets)) {
         switch(specType) {
             default:
                 Parse_Error(PARSE_WARNING, "Special and mundane targets don't mix. Mundane ones ignored");
                 break;
             case Default:
             case Begin:
             case End:
             case Interrupt:
                 /*
                  * These four create nodes on which to hang commands, so
                  * targets shouldn't be empty...
                  */
             case Not:
                 /*
                  * Nothing special here -- targets can be empty if it wants.
                  */
                 break;
+        }
+        switch(specType) {
+            default:
+                Parse_Error(PARSE_WARNING, "Special and mundane targets don't mix. Mundane ones ignored");
+                break;
+            case Default:
+            case Begin:
+            case End:
+            case Interrupt:
+                /*
+                 * These four create nodes on which to hang commands, so
+                 * targets shouldn't be empty...
+                 */
+            case Not:
+                /*
+                 * Nothing special here -- targets can be empty if it wants.
+                 */
+                break;
+        }
+    }
 …
      */
     if (*cp == '!') {
         op = OP_FORCE;
+        op = OP_FORCE;
     } else if (*cp == ':') {
         if (cp[1] == ':') {
             op = OP_DOUBLEDEP;
             cp++;
         } else {
             op = OP_DEPENDS;
+        }
+        if (cp[1] == ':') {
+            op = OP_DOUBLEDEP;
+            cp++;
+        } else {
+            op = OP_DEPENDS;
+        }
     } else {
         Parse_Error (PARSE_FATAL, "Missing dependency operator");
         return;
+    }
     cp++;                       /* Advance beyond operator */
+        Parse_Error (PARSE_FATAL, "Missing dependency operator");
+        return;
+    }
+    cp++;                       /* Advance beyond operator */
     Lst_ForEach (targets, ParseDoOp, (ClientData)&op);
 …
      */
     while (*cp && isspace (*cp)) {
         cp++;
+        cp++;
+    }
     line = cp;
 …
      * Several special targets take different actions if present with no
      * sources:
      *  a .SUFFIXES line with no sources clears out all old suffixes
      *  a .PRECIOUS line makes all targets precious
      *  a .IGNORE line ignores errors for all targets
      *  a .SILENT line creates silence when making all targets
      *  a .PATH removes all directories from the search path(s).
+     *  a .SUFFIXES line with no sources clears out all old suffixes
+     *  a .PRECIOUS line makes all targets precious
+     *  a .IGNORE line ignores errors for all targets
+     *  a .SILENT line creates silence when making all targets
+     *  a .PATH removes all directories from the search path(s).
      */
     if (!*line) {
         switch (specType) {
             case Suffixes:
                 Suff_ClearSuffixes ();
                 break;
             case Precious:
                 allPrecious = TRUE;
                 break;
             case Ignore:
                 ignoreErrors = TRUE;
                 break;
             case Silent:
                 beSilent = TRUE;
                 break;
             case ExPath:
                 Lst_ForEach(paths, ParseClearPath, (ClientData)NULL);
                 break;
+        switch (specType) {
+            case Suffixes:
+                Suff_ClearSuffixes ();
+                break;
+            case Precious:
+                allPrecious = TRUE;
+                break;
+            case Ignore:
+                ignoreErrors = TRUE;
+                break;
+            case Silent:
+                beSilent = TRUE;
+                break;
+            case ExPath:
+                Lst_ForEach(paths, ParseClearPath, (ClientData)NULL);
+                break;
 #ifdef POSIX
             case Posix:
                 Var_Set("%POSIX", "1003.2", VAR_GLOBAL);
                 break;
 #endif
             default:
                 break;
+        }
+            case Posix:
+                Var_Set("%POSIX", "1003.2", VAR_GLOBAL);
+                break;
+#endif
+            default:
+                break;
+        }
     } else if (specType == MFlags) {
         /*
          * Call on functions in main.c to deal with these arguments and
          * set the initial character to a null-character so the loop to
          * get sources won't get anything
          */
         Main_ParseArgLine (line);
         *line = '\0';
+        /*
+         * Call on functions in main.c to deal with these arguments and
+         * set the initial character to a null-character so the loop to
+         * get sources won't get anything
+         */
+        Main_ParseArgLine (line);
+        *line = '\0';
     } else if (specType == ExShell) {
     #ifdef KMK
 …
         return;
     #else
         if (Job_ParseShell (line) != SUCCESS) {
             Parse_Error (PARSE_FATAL, "improper shell specification");
             return;
+        }
+        if (Job_ParseShell (line) != SUCCESS) {
+            Parse_Error (PARSE_FATAL, "improper shell specification");
+            return;
+        }
     #endif
         *line = '\0';
+        *line = '\0';
     } else if ((specType == NotParallel) || (specType == SingleShell)) {
         *line = '\0';
+        *line = '\0';
+    }
 …
      */
     if ((specType == Suffixes) || (specType == ExPath) ||
         (specType == Includes) ||
+        (specType == Includes) ||
 #ifdef USE_ARCHIVES
         (specType == Libs) ||
 #endif
         (specType == Null))
+        (specType == Null))
+    {
         while (*line) {
             /*
              * If the target was one that doesn't take files as its sources
              * but takes something like suffixes, we take each
              * space-separated word on the line as a something and deal
              * with it accordingly.
+             *
              * If the target was .SUFFIXES, we take each source as a
              * suffix and add it to the list of suffixes maintained by the
              * Suff module.
+             *
              * If the target was a .PATH, we add the source as a directory
              * to search on the search path.
+             *
              * If it was .INCLUDES, the source is taken to be the suffix of
              * files which will be #included and whose search path should
              * be present in the .INCLUDES variable.
+             *
              * If it was .LIBS, the source is taken to be the suffix of
              * files which are considered libraries and whose search path
              * should be present in the .LIBS variable.
+             *
              * If it was .NULL, the source is the suffix to use when a file
              * has no valid suffix.
              */
             char  savec;
             while (*cp && !isspace (*cp)) {
                 cp++;
+            }
             savec = *cp;
             *cp = '\0';
             switch (specType) {
                 case Suffixes:
                     Suff_AddSuffix (line);
                     break;
                 case ExPath:
                     Lst_ForEach(paths, ParseAddDir, (ClientData)line);
                     break;
                 case Includes:
                     Suff_AddInclude (line);
                     break;
+        while (*line) {
+            /*
+             * If the target was one that doesn't take files as its sources
+             * but takes something like suffixes, we take each
+             * space-separated word on the line as a something and deal
+             * with it accordingly.
+             *
+             * If the target was .SUFFIXES, we take each source as a
+             * suffix and add it to the list of suffixes maintained by the
+             * Suff module.
+             *
+             * If the target was a .PATH, we add the source as a directory
+             * to search on the search path.
+             *
+             * If it was .INCLUDES, the source is taken to be the suffix of
+             * files which will be #included and whose search path should
+             * be present in the .INCLUDES variable.
+             *
+             * If it was .LIBS, the source is taken to be the suffix of
+             * files which are considered libraries and whose search path
+             * should be present in the .LIBS variable.
+             *
+             * If it was .NULL, the source is the suffix to use when a file
+             * has no valid suffix.
+             */
+            char  savec;
+            while (*cp && !isspace (*cp)) {
+                cp++;
+            }
+            savec = *cp;
+            *cp = '\0';
+            switch (specType) {
+                case Suffixes:
+                    Suff_AddSuffix (line);
+                    break;
+                case ExPath:
+                    Lst_ForEach(paths, ParseAddDir, (ClientData)line);
+                    break;
+                case Includes:
+                    Suff_AddInclude (line);
+                    break;
 #ifdef USE_ARCHIVES
                 case Libs:
                     Suff_AddLib (line);
                     break;
 #endif
                 case Null:
                     Suff_SetNull (line);
                     break;
                 default:
                     break;
+            }
             *cp = savec;
             if (savec != '\0') {
                 cp++;
+            }
             while (*cp && isspace (*cp)) {
                 cp++;
+            }
             line = cp;
+        }
         if (paths) {
             Lst_Destroy(paths, NOFREE);
+        }
+                case Libs:
+                    Suff_AddLib (line);
+                    break;
+#endif
+                case Null:
+                    Suff_SetNull (line);
+                    break;
+                default:
+                    break;
+            }
+            *cp = savec;
+            if (savec != '\0') {
+                cp++;
+            }
+            while (*cp && isspace (*cp)) {
+                cp++;
+            }
+            line = cp;
+        }
+        if (paths) {
+            Lst_Destroy(paths, NOFREE);
+        }
     } else {
         while (*line) {
             /*
              * The targets take real sources, so we must beware of archive
              * specifications (i.e. things with left parentheses in them)
              * and handle them accordingly.
              */
             while (*cp && !isspace (*cp)) {
                 if ((*cp == '(') && (cp > line) && (cp[-1] != '$')) {
                     /*
                      * Only stop for a left parenthesis if it isn't at the
                      * start of a word (that'll be for variable changes
                      * later) and isn't preceded by a dollar sign (a dynamic
                      * source).
                      */
                     break;
                 } else {
                     cp++;
+                }
+            }
             if (*cp == '(') {
+        while (*line) {
+            /*
+             * The targets take real sources, so we must beware of archive
+             * specifications (i.e. things with left parentheses in them)
+             * and handle them accordingly.
+             */
+            while (*cp && !isspace (*cp)) {
+                if ((*cp == '(') && (cp > line) && (cp[-1] != '$')) {
+                    /*
+                     * Only stop for a left parenthesis if it isn't at the
+                     * start of a word (that'll be for variable changes
+                     * later) and isn't preceded by a dollar sign (a dynamic
+                     * source).
+                     */
+                    break;
+                } else {
+                    cp++;
+                }
+            }
+            if (*cp == '(') {
 #ifdef USE_ARCHIVES
                 GNode     *gn;
                 sources = Lst_Init (FALSE);
                 if (Arch_ParseArchive (&line, sources, VAR_CMD) != SUCCESS) {
                     Parse_Error (PARSE_FATAL,
                                  "Error in source archive spec \"%s\"", line);
                     return;
+                }
                 while (!Lst_IsEmpty (sources)) {
                     gn = (GNode *) Lst_DeQueue (sources);
                     ParseDoSrc (tOp, gn->name, curSrcs);
+                }
                 Lst_Destroy (sources, NOFREE);
                 cp = line;
+                GNode     *gn;
+                sources = Lst_Init (FALSE);
+                if (Arch_ParseArchive (&line, sources, VAR_CMD) != SUCCESS) {
+                    Parse_Error (PARSE_FATAL,
+                                 "Error in source archive spec \"%s\"", line);
+                    return;
+                }
+                while (!Lst_IsEmpty (sources)) {
+                    gn = (GNode *) Lst_DeQueue (sources);
+                    ParseDoSrc (tOp, gn->name, curSrcs);
+                }
+                Lst_Destroy (sources, NOFREE);
+                cp = line;
 #else
                 Parse_Error(PARSE_FATAL, "Archives are not supported!", line);
                 return;
 #endif /* USE_ARCHIVES */
             } else {
                 if (*cp) {
                     *cp = '\0';
                     cp += 1;
+                }
                 ParseDoSrc (tOp, line, curSrcs);
+            }
             while (*cp && isspace (*cp)) {
                 cp++;
+            }
             line = cp;
+        }
+            } else {
+                if (*cp) {
+                    *cp = '\0';
+                    cp += 1;
+                }
+                ParseDoSrc (tOp, line, curSrcs);
+            }
+            while (*cp && isspace (*cp)) {
+                cp++;
+            }
+            line = cp;
+        }
+    }
     if (mainNode == NILGNODE) {
         /*
          * If we have yet to decide on a main target to make, in the
          * absence of any user input, we want the first target on
          * the first dependency line that is actually a real target
          * (i.e. isn't a .USE or .EXEC rule) to be made.
          */
         Lst_ForEach (targets, ParseFindMain, (ClientData)0);
+        /*
+         * If we have yet to decide on a main target to make, in the
+         * absence of any user input, we want the first target on
+         * the first dependency line that is actually a real target
+         * (i.e. isn't a .USE or .EXEC rule) to be made.
+         */
+        Lst_ForEach (targets, ParseFindMain, (ClientData)0);
+    }
 …
  *---------------------------------------------------------------------
  * Parse_IsVar  --
  *      Return TRUE if the passed line is a variable assignment. A variable
  *      assignment consists of a single word followed by optional whitespace
  *      followed by either a += or an = operator.
  *      This function is used both by the Parse_File function and main when
  *      parsing the command-line arguments.
+ *      Return TRUE if the passed line is a variable assignment. A variable
+ *      assignment consists of a single word followed by optional whitespace
+ *      followed by either a += or an = operator.
+ *      This function is used both by the Parse_File function and main when
+ *      parsing the command-line arguments.
+ *
  * Results:
  *      TRUE if it is. FALSE if it ain't
+ *      TRUE if it is. FALSE if it ain't
+ *
  * Side Effects:
  *      none
+ *      none
  *---------------------------------------------------------------------
  */
 Boolean
 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 */
+    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) \
         (((c) == '+') || ((c) == ':') || ((c) == '?') || ((c) == '!'))
+        (((c) == '+') || ((c) == ':') || ((c) == '?') || ((c) == '!'))
     /*
 …
      */
     for (;(*line == ' ') || (*line == '\t'); line++)
         continue;
+        continue;
     for (; *line != '=' || level != 0; line++)
         switch (*line) {
         case '\0':
             /*
              * end-of-line -- can't be a variable assignment.
              */
             return FALSE;
         case ' ':
         case '\t':
             /*
              * there can be as much white space as desired so long as there is
              * only one word before the operator
              */
             wasSpace = TRUE;
             break;
         case '(':
         case '{':
             level++;
             break;
         case '}':
         case ')':
             level--;
             break;
         default:
             if (wasSpace && haveName) {
                     if (ISEQOPERATOR(*line)) {
                         /*
                          * We must have a finished word
                          */
                         if (level != 0)
                             return FALSE;
                         /*
                          * When an = operator [+?!:] is found, the next
                          * character must be an = or it ain't a valid
                          * assignment.
                          */
                         if (line[1] == '=')
                             return haveName;
+        switch (*line) {
+        case '\0':
+            /*
+             * end-of-line -- can't be a variable assignment.
+             */
+            return FALSE;
+        case ' ':
+        case '\t':
+            /*
+             * there can be as much white space as desired so long as there is
+             * only one word before the operator
+             */
+            wasSpace = TRUE;
+            break;
+        case '(':
+        case '{':
+            level++;
+            break;
+        case '}':
+        case ')':
+            level--;
+            break;
+        default:
+            if (wasSpace && haveName) {
+                    if (ISEQOPERATOR(*line)) {
+                        /*
+                         * We must have a finished word
+                         */
+                        if (level != 0)
+                            return FALSE;
+                        /*
+                         * When an = operator [+?!:] is found, the next
+                         * character must be an = or it ain't a valid
+                         * assignment.
+                         */
+                        if (line[1] == '=')
+                            return haveName;
 #ifdef SUNSHCMD
                         /*
                          * This is a shell command
                          */
                         if (strncmp(line, ":sh", 3) == 0)
                             return haveName;
 #endif
+                    }
                     /*
                      * This is the start of another word, so not assignment.
                      */
                     return FALSE;
+            }
             else {
                 haveName = TRUE;
                 wasSpace = FALSE;
+            }
             break;
+        }
+                        /*
+                         * This is a shell command
+                         */
+                        if (strncmp(line, ":sh", 3) == 0)
+                            return haveName;
+#endif
+                    }
+                    /*
+                     * This is the start of another word, so not assignment.
+                     */
+                    return FALSE;
+            }
+            else {
+                haveName = TRUE;
+                wasSpace = FALSE;
+            }
+            break;
+        }
     return haveName;
 …
  *---------------------------------------------------------------------
  * Parse_DoVar  --
  *      Take the variable assignment in the passed line and do it in the
  *      global context.
+ *
  *      Note: There is a lexical ambiguity with assignment modifier characters
  *      in variable names. This routine interprets the character before the =
  *      as a modifier. Therefore, an assignment like
  *          C++=/usr/bin/CC
  *      is interpreted as "C+ +=" instead of "C++ =".
+ *      Take the variable assignment in the passed line and do it in the
+ *      global context.
+ *
+ *      Note: There is a lexical ambiguity with assignment modifier characters
+ *      in variable names. This routine interprets the character before the =
+ *      as a modifier. Therefore, an assignment like
+ *          C++=/usr/bin/CC
+ *      is interpreted as "C+ +=" instead of "C++ =".
+ *
  * Results:
  *      none
+ *      none
+ *
  * Side Effects:
  *      the variable structure of the given variable name is altered in the
  *      global context.
+ *      the variable structure of the given variable name is altered in the
+ *      global context.
  *---------------------------------------------------------------------
  */
 void
 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 */
+    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 */
     enum {
         VAR_SUBST, VAR_APPEND, VAR_SHELL, VAR_NORMAL
     }               type;       /* Type of assignment */
     char            *opc;       /* ptr to operator character to
                                  * null-terminate the variable name */
+        VAR_SUBST, VAR_APPEND, VAR_SHELL, VAR_NORMAL
+    }               type;       /* Type of assignment */
+    char            *opc;       /* ptr to operator character to
+                                 * null-terminate the variable name */
     /*
      * Avoid clobbered variable warnings by forcing the compiler
 …
      */
     while ((*line == ' ') || (*line == '\t')) {
         line++;
+        line++;
+    }
 …
      */
     for (cp = line + 1; *cp != '='; cp++) {
         if (isspace (*cp)) {
             *cp = '\0';
+        }
+    }
     opc = cp-1;         /* operator is the previous character */
     *cp++ = '\0';       /* nuke the = */
+        if (isspace (*cp)) {
+            *cp = '\0';
+        }
+    }
+    opc = cp-1;         /* operator is the previous character */
+    *cp++ = '\0';       /* nuke the = */
     /*
 …
      */
     switch (*opc) {
         case '+':
             type = VAR_APPEND;
             *opc = '\0';
             break;
         case '?':
             /*
              * If the variable already has a value, we don't do anything.
              */
             *opc = '\0';
             if (Var_Exists(line, ctxt)) {
                 return;
             } else {
                 type = VAR_NORMAL;
+            }
             break;
         case ':':
             type = VAR_SUBST;
             *opc = '\0';
             break;
         case '!':
             type = VAR_SHELL;
             *opc = '\0';
             break;
         default:
+        case '+':
+            type = VAR_APPEND;
+            *opc = '\0';
+            break;
+        case '?':
+            /*
+             * If the variable already has a value, we don't do anything.
+             */
+            *opc = '\0';
+            if (Var_Exists(line, ctxt)) {
+                return;
+            } else {
+                type = VAR_NORMAL;
+            }
+            break;
+        case ':':
+            type = VAR_SUBST;
+            *opc = '\0';
+            break;
+        case '!':
+            type = VAR_SHELL;
+            *opc = '\0';
+            break;
+        default:
 #ifdef SUNSHCMD
             while (*opc != ':')
                 if (opc == line)
                     break;
                 else
                     --opc;
             if (strncmp(opc, ":sh", 3) == 0) {
                 type = VAR_SHELL;
                 *opc = '\0';
                 break;
+            }
 #endif
             type = VAR_NORMAL;
             break;
+            while (*opc != ':')
+                if (opc == line)
+                    break;
+                else
+                    --opc;
+            if (strncmp(opc, ":sh", 3) == 0) {
+                type = VAR_SHELL;
+                *opc = '\0';
+                break;
+            }
+#endif
+            type = VAR_NORMAL;
+            break;
+    }
     while (isspace (*cp)) {
         cp++;
+        cp++;
+    }
     if (type == VAR_APPEND) {
         Var_Append (line, cp, ctxt);
+        Var_Append (line, cp, ctxt);
     } else if (type == VAR_SUBST) {
         /*
          * Allow variables in the old value to be undefined, but leave their
          * invocation alone -- this is done by forcing oldVars to be false.
          * XXX: This can cause recursive variables, but that's not hard to do,
          * and this allows someone to do something like
+         *
          *  CFLAGS = $(.INCLUDES)
          *  CFLAGS := -I.. $(CFLAGS)
+         *
          * And not get an error.
          */
         Boolean   oldOldVars = oldVars;
         oldVars = FALSE;
         cp = Var_Subst(NULL, cp, ctxt, FALSE);
         oldVars = oldOldVars;
         Var_Set(line, cp, ctxt);
         efree(cp);
+        /*
+         * Allow variables in the old value to be undefined, but leave their
+         * invocation alone -- this is done by forcing oldVars to be false.
+         * XXX: This can cause recursive variables, but that's not hard to do,
+         * and this allows someone to do something like
+         *
+         *  CFLAGS = $(.INCLUDES)
+         *  CFLAGS := -I.. $(CFLAGS)
+         *
+         * And not get an error.
+         */
+        Boolean   oldOldVars = oldVars;
+        oldVars = FALSE;
+        cp = Var_Subst(NULL, cp, ctxt, FALSE);
+        oldVars = oldOldVars;
+        Var_Set(line, cp, ctxt);
+        efree(cp);
     } else if (type == VAR_SHELL) {
         Boolean freeCmd = FALSE; /* TRUE if the command needs to be freed, i.e.
                                   * if any variable expansion was performed */
         char *res, *err;
         if (strchr(cp, '$') != NULL) {
             /*
              * There's a dollar sign in the command, so perform variable
              * expansion on the whole thing. The resulting string will need
              * freeing when we're done, so set freeCmd to TRUE.
              */
             cp = Var_Subst(NULL, cp, VAR_CMD, TRUE);
             freeCmd = TRUE;
+        }
         res = Cmd_Exec(cp, &err);
         Var_Set(line, res, ctxt);
         efree(res);
         if (err)
             Parse_Error(PARSE_WARNING, err, cp);
         if (freeCmd)
             efree(cp);
+        Boolean freeCmd = FALSE; /* TRUE if the command needs to be freed, i.e.
+                                  * if any variable expansion was performed */
+        char *res, *err;
+        if (strchr(cp, '$') != NULL) {
+            /*
+             * There's a dollar sign in the command, so perform variable
+             * expansion on the whole thing. The resulting string will need
+             * freeing when we're done, so set freeCmd to TRUE.
+             */
+            cp = Var_Subst(NULL, cp, VAR_CMD, TRUE);
+            freeCmd = TRUE;
+        }
+        res = Cmd_Exec(cp, &err);
+        Var_Set(line, res, ctxt);
+        efree(res);
+        if (err)
+            Parse_Error(PARSE_WARNING, err, cp);
+        if (freeCmd)
+            efree(cp);
     } else {
         /*
          * Normal assignment -- just do it.
          */
         Var_Set(line, cp, ctxt);
+        /*
+         * Normal assignment -- just do it.
+         */
+        Var_Set(line, cp, ctxt);
+    }
+}
 …
 /*-
  * ParseAddCmd  --
  *      Lst_ForEach function to add a command line to all targets
+ *      Lst_ForEach function to add a command line to all targets
+ *
  * Results:
  *      Always 0
+ *      Always 0
+ *
  * Side Effects:
  *      A new element is added to the commands list of the node.
+ *      A new element is added to the commands list of the node.
  */
 static int
 ParseAddCmd(gnp, cmd)
     ClientData gnp;     /* the node to which the command is to be added */
     ClientData cmd;     /* the command to add */
+    ClientData gnp;     /* the node to which the command is to be added */
+    ClientData cmd;     /* the command to add */
+{
     GNode *gn = (GNode *) gnp;
     /* if target already supplied, ignore commands */
     if (!(gn->type & OP_HAS_COMMANDS))
         (void)Lst_AtEnd(gn->commands, cmd);
+        (void)Lst_AtEnd(gn->commands, cmd);
     return(0);
+}
 …
 /*-
  * ParseAppendInline  --
  *      Lst_ForEach function to append the line to the last command
+ *      Lst_ForEach function to append the line to the last command
+ *
  * Results:
  *      Always 0
+ *      Always 0
+ *
  * Side Effects:
  *      A new element is added to the last commands list of the node.
+ *      A new element is added to the last commands list of the node.
  */
 static int
 ParseAppendInline(gnp, line)
     ClientData gnp;     /* the node to which the command is to be added */
     ClientData line;    /* the command to add */
+    ClientData gnp;     /* the node to which the command is to be added */
+    ClientData line;    /* the command to add */
+{
     GNode *gn = (GNode *)gnp;
 …
+ *
  * Results:
  *      returns TRUE if it is, FALSE if not.
+ *      returns TRUE if it is, FALSE if not.
+ *
  * Side Effects:
  *      OP_HAS_COMMANDS may be set for the target.
+ *      OP_HAS_COMMANDS may be set for the target.
+ *
  *-----------------------------------------------------------------------
 …
  *-----------------------------------------------------------------------
  * ParseHasCommands --
  *      Callback procedure for Parse_File when destroying the list of
  *      targets on the last dependency line. Marks a target as already
  *      having commands if it does, to keep from having shell commands
  *      on multiple dependency lines.
+ *      Callback procedure for Parse_File when destroying the list of
+ *      targets on the last dependency line. Marks a target as already
+ *      having commands if it does, to keep from having shell commands
+ *      on multiple dependency lines.
+ *
  * Results:
  *      None
+ *      None
+ *
  * Side Effects:
  *      OP_HAS_COMMANDS may be set for the target.
+ *      OP_HAS_COMMANDS may be set for the target.
+ *
  *-----------------------------------------------------------------------
 …
 static void
 ParseHasCommands(gnp)
     ClientData    gnp;      /* Node to examine */
+    ClientData    gnp;      /* Node to examine */
+{
     GNode *gn = (GNode *) gnp;
     if (!Lst_IsEmpty(gn->commands)) {
         gn->type |= OP_HAS_COMMANDS;
+        gn->type |= OP_HAS_COMMANDS;
+    }
+}
 …
  *-----------------------------------------------------------------------
  * Parse_AddIncludeDir --
  *      Add a directory to the path searched for included makefiles
  *      bracketed by double-quotes. Used by functions in main.c
+ *      Add a directory to the path searched for included makefiles
+ *      bracketed by double-quotes. Used by functions in main.c
+ *
  * Results:
  *      None.
+ *      None.
+ *
  * Side Effects:
  *      The directory is appended to the list.
+ *      The directory is appended to the list.
+ *
  *-----------------------------------------------------------------------
 …
 void
 Parse_AddIncludeDir (dir)
     char          *dir;     /* The name of the directory to add */
+    char          *dir;     /* The name of the directory to add */
+{
     Dir_AddDir (parseIncPath, dir);
 …
 /*---------------------------------------------------------------------
  * ParseDoError  --
  *      Handle error directive
+ *
  *      The input is the line minus the ".error".  We substitute variables,
  *      print the message and exit(1) or just print a warning if the ".error"
  *      directive is malformed.
+ *      Handle error directive
+ *
+ *      The input is the line minus the ".error".  We substitute variables,
+ *      print the message and exit(1) or just print a warning if the ".error"
+ *      directive is malformed.
+ *
  *---------------------------------------------------------------------
 …
 static void
 ParseDoError(errmsg)
     char          *errmsg;      /* error message */
+{
         if (!isspace(*errmsg)) {
                 Parse_Error(PARSE_WARNING, "invalid syntax: .error%s", errmsg);
                 return;
+        }
         while (isspace(*errmsg))
                 errmsg++;
         errmsg = Var_Subst(NULL, errmsg, VAR_GLOBAL, FALSE);
         /* use fprintf/exit instead of Parse_Error to terminate immediately */
         fprintf(stderr, "\"%s\", line %d: %s\n", fname, lineno, errmsg);
         exit(1);
+    char          *errmsg;      /* error message */
+{
+        if (!isspace(*errmsg)) {
+                Parse_Error(PARSE_WARNING, "invalid syntax: .error%s", errmsg);
+                return;
+        }
+        while (isspace(*errmsg))
+                errmsg++;
+        errmsg = Var_Subst(NULL, errmsg, VAR_GLOBAL, FALSE);
+        /* use fprintf/exit instead of Parse_Error to terminate immediately */
+        fprintf(stderr, "\"%s\", line %d: %s\n", fname, lineno, errmsg);
+        exit(1);
+}
 …
  *---------------------------------------------------------------------
  * ParseDoInclude  --
  *      Push to another file.
+ *
  *      The input is the line minus the #include. A file spec is a string
  *      enclosed in <> or "". The former is looked for only in sysIncPath.
  *      The latter in . and the directories specified by -I command line
  *      options
+ *      Push to another file.
+ *
+ *      The input is the line minus the #include. A file spec is a string
+ *      enclosed in <> or "". The former is looked for only in sysIncPath.
+ *      The latter in . and the directories specified by -I command line
+ *      options
+ *
  * Results:
  *      None
+ *      None
+ *
  * Side Effects:
  *      A structure is added to the includes Lst and readProc, lineno,
  *      fname and curFILE are altered for the new file
+ *      A structure is added to the includes Lst and readProc, lineno,
+ *      fname and curFILE are altered for the new file
  *---------------------------------------------------------------------
  */
 static void
 ParseDoInclude (file, chPre)
     char          *file;        /* file specification */
+    char          *file;        /* file specification */
     char           chPre;       /* Preprocessor char */
+{
     char          *fullname;    /* full pathname of file */
     IFile         *oldFile;     /* state associated with current file */
     char          endc;         /* the character which ends the file spec */
     char          *cp;          /* current position in file spec */
     Boolean       isSystem;     /* TRUE if makefile is a system makefile */
+    char          *fullname;    /* full pathname of file */
+    IFile         *oldFile;     /* state associated with current file */
+    char          endc;         /* the character which ends the file spec */
+    char          *cp;          /* current position in file spec */
+    Boolean       isSystem;     /* TRUE if makefile is a system makefile */
     /*
 …
      */
     while ((*file == ' ') || (*file == '\t')) {
         file++;
+        file++;
+    }
     #ifndef NMAKE
     if ((*file != '"') && (*file != '<')) {
         Parse_Error (PARSE_FATAL,
             "%cinclude filename must be delimited by '\"' or '<'", chPre);
         return;
+        Parse_Error (PARSE_FATAL,
+            "%cinclude filename must be delimited by '\"' or '<'", chPre);
+        return;
+    }
     #endif
 …
      */
     if (*file == '<') {
         isSystem = TRUE;
         endc = '>';
+        isSystem = TRUE;
+        endc = '>';
     } else {
         isSystem = FALSE;
+        isSystem = FALSE;
         #ifdef NMAKE
         if (*file == '"')
             endc = '"';
+            endc = '"';
         else
+        {
 …
+        }
         #else
         endc = '"';
+        endc = '"';
         #endif
+    }
 …
      */
     for (cp = ++file; *cp && *cp != endc; cp++) {
         continue;
+        continue;
+    }
 …
     if (*cp != endc) {
     #endif
         Parse_Error (PARSE_FATAL,
                      "Unclosed %cinclude filename. '%c' expected",
                      chPre, endc);
         return;
+        Parse_Error (PARSE_FATAL,
+                     "Unclosed %cinclude filename. '%c' expected",
+                     chPre, endc);
+        return;
+    }
     *cp = '\0';
 …
      */
     if (!isSystem) {
         /*
          * Include files contained in double-quotes are first searched for
          * relative to the including file's location. We don't want to
          * cd there, of course, so we just tack on the old file's
          * leading path components and call Dir_FindFile to see if
          * we can locate the beast.
          */
         char      *prefEnd, *Fname;
         /* Make a temporary copy of this, to be safe. */
         Fname = estrdup(fname);
         prefEnd = strrchr (Fname, '/');
         if (prefEnd != (char *)NULL) {
             char        *newName;
             *prefEnd = '\0';
             if (file[0] == '/')
                 newName = estrdup(file);
             else
                 newName = str_concat (Fname, file, STR_ADDSLASH);
             fullname = Dir_FindFile (newName, parseIncPath);
             if (fullname == (char *)NULL) {
                 fullname = Dir_FindFile(newName, dirSearchPath);
+            }
             efree (newName);
             *prefEnd = '/';
         } else {
             fullname = (char *)NULL;
+        }
         efree (Fname);
+        /*
+         * Include files contained in double-quotes are first searched for
+         * relative to the including file's location. We don't want to
+         * cd there, of course, so we just tack on the old file's
+         * leading path components and call Dir_FindFile to see if
+         * we can locate the beast.
+         */
+        char      *prefEnd, *Fname;
+        /* Make a temporary copy of this, to be safe. */
+        Fname = estrdup(fname);
+        prefEnd = strrchr (Fname, '/');
+        if (prefEnd != (char *)NULL) {
+            char        *newName;
+            *prefEnd = '\0';
+            if (file[0] == '/')
+                newName = estrdup(file);
+            else
+                newName = str_concat (Fname, file, STR_ADDSLASH);
+            fullname = Dir_FindFile (newName, parseIncPath);
+            if (fullname == (char *)NULL) {
+                fullname = Dir_FindFile(newName, dirSearchPath);
+            }
+            efree (newName);
+            *prefEnd = '/';
+        } else {
+            fullname = (char *)NULL;
+        }
+        efree (Fname);
     } else {
         fullname = (char *)NULL;
+        fullname = (char *)NULL;
+    }
     if (fullname == (char *)NULL) {
         /*
          * System makefile or makefile wasn't found in same directory as
          * included makefile. Search for it first on the -I search path,
          * then on the .PATH search path, if not found in a -I directory.
          * XXX: Suffix specific?
          */
         fullname = Dir_FindFile (file, parseIncPath);
         if (fullname == (char *)NULL) {
             fullname = Dir_FindFile(file, dirSearchPath);
+        }
+        /*
+         * System makefile or makefile wasn't found in same directory as
+         * included makefile. Search for it first on the -I search path,
+         * then on the .PATH search path, if not found in a -I directory.
+         * XXX: Suffix specific?
+         */
+        fullname = Dir_FindFile (file, parseIncPath);
+        if (fullname == (char *)NULL) {
+            fullname = Dir_FindFile(file, dirSearchPath);
+        }
+    }
     if (fullname == (char *)NULL) {
         /*
          * Still haven't found the makefile. Look for it on the system
          * path as a last resort.
          */
         fullname = Dir_FindFile(file, sysIncPath);
+        /*
+         * Still haven't found the makefile. Look for it on the system
+         * path as a last resort.
+         */
+        fullname = Dir_FindFile(file, sysIncPath);
+    }
     if (fullname == (char *) NULL) {
         *cp = endc;
         Parse_Error (PARSE_FATAL, "Could not find '%s'", file);
         return;
+        *cp = endc;
+        Parse_Error (PARSE_FATAL, "Could not find '%s'", file);
+        return;
+    }
 …
     curPTR = NULL;
     if (curFILE == (FILE * ) NULL) {
         Parse_Error (PARSE_FATAL, "Cannot open %s", fullname);
         /*
          * Pop to previous file
          */
         (void) ParseEOF(0);
+        Parse_Error (PARSE_FATAL, "Cannot open %s", fullname);
+        /*
+         * Pop to previous file
+         */
+        (void) ParseEOF(0);
+    }
+}
 …
  *---------------------------------------------------------------------
  * Parse_FromString  --
  *      Start Parsing from the given string
+ *      Start Parsing from the given string
+ *
  * Results:
  *      None
+ *      None
+ *
  * Side Effects:
  *      A structure is added to the includes Lst and readProc, lineno,
  *      fname and curFILE are altered for the new file
+ *      A structure is added to the includes Lst and readProc, lineno,
+ *      fname and curFILE are altered for the new file
  *---------------------------------------------------------------------
  */
 …
     char *str;
+{
     IFile         *oldFile;     /* state associated with this file */
+    IFile         *oldFile;     /* state associated with this file */
     if (DEBUG(FOR))
         (void) fprintf(stderr, "%s\n----\n", str);
+        (void) fprintf(stderr, "%s\n----\n", str);
     oldFile = (IFile *) emalloc (sizeof (IFile));
 …
  *---------------------------------------------------------------------
  * ParseTraditionalInclude  --
  *      Push to another file.
+ *
  *      The input is the line minus the "include".  The file name is
  *      the string following the "include".
+ *      Push to another file.
+ *
+ *      The input is the line minus the "include".  The file name is
+ *      the string following the "include".
+ *
  * Results:
  *      None
+ *      None
+ *
  * Side Effects:
  *      A structure is added to the includes Lst and readProc, lineno,
  *      fname and curFILE are altered for the new file
+ *      A structure is added to the includes Lst and readProc, lineno,
+ *      fname and curFILE are altered for the new file
  *---------------------------------------------------------------------
  */
 static void
 ParseTraditionalInclude (file)
     char          *file;        /* file specification */
+{
     char          *fullname;    /* full pathname of file */
     IFile         *oldFile;     /* state associated with current file */
     char          *cp;          /* current position in file spec */
     char          *prefEnd;
+    char          *file;        /* file specification */
+{
+    char          *fullname;    /* full pathname of file */
+    IFile         *oldFile;     /* state associated with current file */
+    char          *cp;          /* current position in file spec */
+    char          *prefEnd;
     /*
 …
      */
     while ((*file == ' ') || (*file == '\t')) {
         file++;
+        file++;
+    }
     if (*file == '\0') {
         Parse_Error (PARSE_FATAL,
                      "Filename missing from \"include\"");
         return;
+        Parse_Error (PARSE_FATAL,
+                     "Filename missing from \"include\"");
+        return;
+    }
 …
      */
     for (cp = file; *cp && *cp != '\n' && *cp != '\t' && *cp != ' '; cp++) {
         continue;
+        continue;
+    }
 …
     prefEnd = strrchr (fname, '/');
     if (prefEnd != (char *)NULL) {
         char    *newName;
         *prefEnd = '\0';
         newName = str_concat (fname, file, STR_ADDSLASH);
         fullname = Dir_FindFile (newName, parseIncPath);
         if (fullname == (char *)NULL) {
             fullname = Dir_FindFile(newName, dirSearchPath);
+        }
         efree (newName);
         *prefEnd = '/';
+        char    *newName;
+        *prefEnd = '\0';
+        newName = str_concat (fname, file, STR_ADDSLASH);
+        fullname = Dir_FindFile (newName, parseIncPath);
+        if (fullname == (char *)NULL) {
+            fullname = Dir_FindFile(newName, dirSearchPath);
+        }
+        efree (newName);
+        *prefEnd = '/';
     } else {
         fullname = (char *)NULL;
+        fullname = (char *)NULL;
+    }
     if (fullname == (char *)NULL) {
         /*
          * System makefile or makefile wasn't found in same directory as
          * included makefile. Search for it first on the -I search path,
          * then on the .PATH search path, if not found in a -I directory.
          * XXX: Suffix specific?
          */
         fullname = Dir_FindFile (file, parseIncPath);
         if (fullname == (char *)NULL) {
             fullname = Dir_FindFile(file, dirSearchPath);
+        }
+        /*
+         * System makefile or makefile wasn't found in same directory as
+         * included makefile. Search for it first on the -I search path,
+         * then on the .PATH search path, if not found in a -I directory.
+         * XXX: Suffix specific?
+         */
+        fullname = Dir_FindFile (file, parseIncPath);
+        if (fullname == (char *)NULL) {
+            fullname = Dir_FindFile(file, dirSearchPath);
+        }
+    }
     if (fullname == (char *)NULL) {
         /*
          * Still haven't found the makefile. Look for it on the system
          * path as a last resort.
          */
         fullname = Dir_FindFile(file, sysIncPath);
+        /*
+         * Still haven't found the makefile. Look for it on the system
+         * path as a last resort.
+         */
+        fullname = Dir_FindFile(file, sysIncPath);
+    }
     if (fullname == (char *) NULL) {
         Parse_Error (PARSE_FATAL, "Could not find %s", file);
         return;
+        Parse_Error (PARSE_FATAL, "Could not find %s", file);
+        return;
+    }
 …
     curPTR = NULL;
     if (curFILE == (FILE * ) NULL) {
         Parse_Error (PARSE_FATAL, "Cannot open %s", fullname);
         /*
          * Pop to previous file
          */
         (void) ParseEOF(1);
+        Parse_Error (PARSE_FATAL, "Cannot open %s", fullname);
+        /*
+         * Pop to previous file
+         */
+        (void) ParseEOF(1);
+    }
+}
 …
  *---------------------------------------------------------------------
  * ParseEOF  --
  *      Called when EOF is reached in the current file. If we were reading
  *      an include file, the includes stack is popped and things set up
  *      to go back to reading the previous file at the previous location.
+ *      Called when EOF is reached in the current file. If we were reading
+ *      an include file, the includes stack is popped and things set up
+ *      to go back to reading the previous file at the previous location.
+ *
  * Results:
  *      CONTINUE if there's more to do. DONE if not.
+ *      CONTINUE if there's more to do. DONE if not.
+ *
  * Side Effects:
  *      The old curFILE, is closed. The includes list is shortened.
  *      lineno, curFILE, and fname are changed if CONTINUE is returned.
+ *      The old curFILE, is closed. The includes list is shortened.
+ *      lineno, curFILE, and fname are changed if CONTINUE is returned.
  *---------------------------------------------------------------------
  */
 …
     int opened;
+{
     IFile     *ifile;   /* the state on the top of the includes stack */
+    IFile     *ifile;   /* the state on the top of the includes stack */
     if (Lst_IsEmpty (includes)) {
         return (DONE);
+        return (DONE);
+    }
 …
     lineno = ifile->lineno;
     if (opened && curFILE)
         (void) fclose (curFILE);
+        (void) fclose (curFILE);
     if (curPTR) {
         efree((Address) curPTR->str);
         efree((Address) curPTR);
+        efree((Address) curPTR->str);
+        efree((Address) curPTR);
+    }
     curFILE = ifile->F;
 …
  *---------------------------------------------------------------------
  * ParseReadc  --
  *      Read a character from the current file
+ *      Read a character from the current file
+ *
  * Results:
  *      The character that was read
+ *      The character that was read
+ *
  * Side Effects:
 …
+{
     if (curFILE)
         return fgetc(curFILE);
+        return fgetc(curFILE);
     if (curPTR && *curPTR->ptr)
         return *curPTR->ptr++;
+        return *curPTR->ptr++;
     return EOF;
+}
 …
  *---------------------------------------------------------------------
  * ParseUnreadc  --
  *      Put back a character to the current file
+ *      Put back a character to the current file
+ *
  * Results:
  *      None.
+ *      None.
+ *
  * Side Effects:
 …
+{
     if (curFILE) {
         ungetc(c, curFILE);
         return;
+        ungetc(c, curFILE);
+        return;
+    }
     if (curPTR) {
         *--(curPTR->ptr) = c;
         return;
+        *--(curPTR->ptr) = c;
+        return;
+    }
+}
 …
 /* ParseSkipLine():
  *      Grab the next line
+ *      Grab the next line
  */
 static char *
 ParseSkipLine(skip)
     int skip;           /* Skip lines that don't start with . */
+    int skip;           /* Skip lines that don't start with . */
+{
     char *line;
 …
  *---------------------------------------------------------------------
  * ParseReadLine --
  *      Read an entire line from the input file. Called only by Parse_File.
  *      To facilitate escaped newlines and what have you, a character is
  *      buffered in 'lastc', which is '\0' when no characters have been
  *      read. When we break out of the loop, c holds the terminating
  *      character and lastc holds a character that should be added to
  *      the line (unless we don't read anything but a terminator).
+ *      Read an entire line from the input file. Called only by Parse_File.
+ *      To facilitate escaped newlines and what have you, a character is
+ *      buffered in 'lastc', which is '\0' when no characters have been
+ *      read. When we break out of the loop, c holds the terminating
+ *      character and lastc holds a character that should be added to
+ *      the line (unless we don't read anything but a terminator).
+ *
  * Results:
  *      A line w/o its newline
+ *      A line w/o its newline
+ *
  * Side Effects:
  *      Only those associated with reading a character
+ *      Only those associated with reading a character
  *---------------------------------------------------------------------
  */
 …
 ParseReadLine ()
+{
     Buffer        buf;          /* Buffer for current line */
     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
                                  * for the purposes of setting semiNL */
     Boolean       ignComment;   /* TRUE if should ignore comments (in a
                                  * shell command */
     char          *line;        /* Result */
     char          *ep;          /* to strip trailing blanks */
     int           lineLength;   /* Length of result */
+    Buffer        buf;          /* Buffer for current line */
+    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
+                                 * for the purposes of setting semiNL */
+    Boolean       ignComment;   /* TRUE if should ignore comments (in a
+                                 * shell command */
+    char          *line;        /* Result */
+    char          *ep;          /* to strip trailing blanks */
+    int           lineLength;   /* Length of result */
     semiNL = FALSE;
 …
      */
     for (;;) {
         c = ParseReadc();
+        c = ParseReadc();
         #ifdef USE_INLINEFILES
         if (inInlineFile)
 …
         #endif
         if (c == '\t') {
             ignComment = ignDepOp = TRUE;
             break;
         } else if (c == '\n') {
             lineno++;
         } else if (c == '#') {
             ParseUnreadc(c);
             break;
         } else {
             /*
              * Anything else breaks out without doing anything
              */
             break;
+        }
+        if (c == '\t') {
+            ignComment = ignDepOp = TRUE;
+            break;
+        } else if (c == '\n') {
+            lineno++;
+        } else if (c == '#') {
+            ParseUnreadc(c);
+            break;
+        } else {
+            /*
+             * Anything else breaks out without doing anything
+             */
+            break;
+        }
+    }
     if (c != EOF) {
         lastc = c;
         buf = Buf_Init(MAKE_BSIZE);
+        lastc = c;
+        buf = Buf_Init(MAKE_BSIZE);
         /* @todo any inline changes here? */
         #ifdef NMAKE
         while (((c = ParseReadc ()) != '\n' || (lastc == '\\') || (lastc == '^')) && (c != EOF))
+        while (((c = ParseReadc ()) != '\n' || (lastc == '\\') || (lastc == '^')) && (c != EOF))
         #else
         while (((c = ParseReadc ()) != '\n' || (lastc == '\\')) && (c != EOF))
+        while (((c = ParseReadc ()) != '\n' || (lastc == '\\')) && (c != EOF))
         #endif
+        {
+        {
 test_char:
             switch(c) {
             case '\n':
+            switch(c) {
+            case '\n':
                 #ifdef USE_INLINEFILES
                 /* No newline escaping in inline files, unless it's a directive. */
 …
+                }
                 #endif
                 /*
                  * Escaped newline: read characters until a non-space or an
                  * unescaped newline and replace them all by a single space.
                  * This is done by storing the space over the backslash and
                  * dropping through with the next nonspace. If it is a
                  * semi-colon and semiNL is TRUE, it will be recognized as a
                  * newline in the code below this...
                  */
                 lineno++;
                 lastc = ' ';
+                 * Escaped newline: read characters until a non-space or an
+                 * unescaped newline and replace them all by a single space.
+                 * This is done by storing the space over the backslash and
+                 * dropping through with the next nonspace. If it is a
+                 * semi-colon and semiNL is TRUE, it will be recognized as a
+                 * newline in the code below this...
+                 */
+                lineno++;
+                lastc = ' ';
 #ifdef NMAKE
                 if (lastc == '^')
                     lastc = '\n';
+                    lastc = '\n';
                 do {
                         while ((c = ParseReadc ()) == ' ' || c == '\t') {
                             continue;
+                        }
+                            continue;
+                        }
                         if (c != '#')
                             break;
                         /* comment - skip line */
                         while ((c = ParseReadc ()) != '\n' && c != EOF) {
                             continue;
+                        }
+                            continue;
+                        }
                         if (c == EOF)
                             break;
                 } while (1);
 #else
                 while ((c = ParseReadc ()) == ' ' || c == '\t') {
                     continue;
+                }
 #endif
                 if (c == EOF || c == '\n') {
                     goto line_read;
                 } else {
                     /*
                      * Check for comments, semiNL's, etc. -- easier than
                      * ParseUnreadc(c); continue;
                      */
                     goto test_char;
+                }
                 /*NOTREACHED*/
                 break;
+                while ((c = ParseReadc ()) == ' ' || c == '\t') {
+                    continue;
+                }
+#endif
+                if (c == EOF || c == '\n') {
+                    goto line_read;
+                } else {
+                    /*
+                     * Check for comments, semiNL's, etc. -- easier than
+                     * ParseUnreadc(c); continue;
+                     */
+                    goto test_char;
+                }
+                /*NOTREACHED*/
+                break;
 /* We don't need this, and don't want it! */
 #ifndef KMK
             case ';':
+            case ';':
                 #ifdef USE_INLINEFILES
                 if (inInlineFile)
                     break;
                 #endif
                 /*
                  * Semi-colon: Need to see if it should be interpreted as a
                  * newline
                  */
                 if (semiNL) {
                     /*
                      * To make sure the command that may be following this
                      * semi-colon begins with a tab, we push one back into the
                      * input stream. This will overwrite the semi-colon in the
                      * buffer. If there is no command following, this does no
                      * harm, since the newline remains in the buffer and the
                      * whole line is ignored.
                      */
                     ParseUnreadc('\t');
                     goto line_read;
+                }
                 break;
             case '=':
+                /*
+                 * Semi-colon: Need to see if it should be interpreted as a
+                 * newline
+                 */
+                if (semiNL) {
+                    /*
+                     * To make sure the command that may be following this
+                     * semi-colon begins with a tab, we push one back into the
+                     * input stream. This will overwrite the semi-colon in the
+                     * buffer. If there is no command following, this does no
+                     * harm, since the newline remains in the buffer and the
+                     * whole line is ignored.
+                     */
+                    ParseUnreadc('\t');
+                    goto line_read;
+                }
+                break;
+            case '=':
                 #ifdef USE_INLINEFILES
                 if (inInlineFile)
 …
                 #endif
                 if (!semiNL) {
                     /*
                      * Haven't seen a dependency operator before this, so this
                      * must be a variable assignment -- don't pay attention to
                      * dependency operators after this.
                      */
                     ignDepOp = TRUE;
                 } else if (lastc == ':' || lastc == '!') {
                     /*
                      * Well, we've seen a dependency operator already, but it
                      * was the previous character, so this is really just an
                      * expanded variable assignment. Revert semi-colons to
                      * being just semi-colons again and ignore any more
                      * dependency operators.
+                     *
                      * XXX: Note that a line like "foo : a:=b" will blow up,
                      * but who'd write a line like that anyway?
                      */
                     ignDepOp = TRUE; semiNL = FALSE;
+                }
                 break;
             case '#':
                 if (!ignComment) {
                     if (
+                    /*
+                     * Haven't seen a dependency operator before this, so this
+                     * must be a variable assignment -- don't pay attention to
+                     * dependency operators after this.
+                     */
+                    ignDepOp = TRUE;
+                } else if (lastc == ':' || lastc == '!') {
+                    /*
+                     * Well, we've seen a dependency operator already, but it
+                     * was the previous character, so this is really just an
+                     * expanded variable assignment. Revert semi-colons to
+                     * being just semi-colons again and ignore any more
+                     * dependency operators.
+                     *
+                     * XXX: Note that a line like "foo : a:=b" will blow up,
+                     * but who'd write a line like that anyway?
+                     */
+                    ignDepOp = TRUE; semiNL = FALSE;
+                }
+                break;
+            case '#':
+                if (!ignComment) {
+                    if (
 #if 0
                     compatMake &&
 #endif
                     (lastc != '\\')) {
                         /*
                          * If the character is a hash mark and it isn't escaped
                          * (or we're being compatible), the thing is a comment.
                          * Skip to the end of the line.
                          */
                         do {
                             c = ParseReadc();
                         } while ((c != '\n') && (c != EOF));
                         goto line_read;
                     } else {
                         /*
                          * Don't add the backslash. Just let the # get copied
                          * over.
                          */
                         lastc = c;
                         continue;
+                    }
+                }
                 break;
             case ':':
             case '!':
+                    compatMake &&
+#endif
+                    (lastc != '\\')) {
+                        /*
+                         * If the character is a hash mark and it isn't escaped
+                         * (or we're being compatible), the thing is a comment.
+                         * Skip to the end of the line.
+                         */
+                        do {
+                            c = ParseReadc();
+                        } while ((c != '\n') && (c != EOF));
+                        goto line_read;
+                    } else {
+                        /*
+                         * Don't add the backslash. Just let the # get copied
+                         * over.
+                         */
+                        lastc = c;
+                        continue;
+                    }
+                }
+                break;
+            case ':':
+            case '!':
                 #ifdef USE_INLINEFILES
                 if (inInlineFile)
                     break;
                 #endif
                 if (!ignDepOp && (c == ':' || c == '!')) {
                     /*
                      * A semi-colon is recognized as a newline only on
                      * dependency lines. Dependency lines are lines with a
                      * colon or an exclamation point. Ergo...
                      */
                     semiNL = TRUE;
+                }
                 break;
+                if (!ignDepOp && (c == ':' || c == '!')) {
+                    /*
+                     * A semi-colon is recognized as a newline only on
+                     * dependency lines. Dependency lines are lines with a
+                     * colon or an exclamation point. Ergo...
+                     */
+                    semiNL = TRUE;
+                }
+                break;
 #endif /* !KMK */
+            }
             /*
              * Copy in the previous character and save this one in lastc.
              */
             Buf_AddByte (buf, (Byte)lastc);
             lastc = c;
+        }
+            }
+            /*
+             * Copy in the previous character and save this one in lastc.
+             */
+            Buf_AddByte (buf, (Byte)lastc);
+            lastc = c;
+        }
     line_read:
         lineno++;
         if (lastc != '\0') {
             Buf_AddByte (buf, (Byte)lastc);
+        }
         Buf_AddByte (buf, (Byte)'\0');
         line = (char *)Buf_GetAll (buf, &lineLength);
         Buf_Destroy (buf, FALSE);
         /*
          * Strip trailing blanks and tabs from the line.
          * Do not strip a blank or tab that is preceeded by
          * a '\'
          */
+        lineno++;
+        if (lastc != '\0') {
+            Buf_AddByte (buf, (Byte)lastc);
+        }
+        Buf_AddByte (buf, (Byte)'\0');
+        line = (char *)Buf_GetAll (buf, &lineLength);
+        Buf_Destroy (buf, FALSE);
+        /*
+         * Strip trailing blanks and tabs from the line.
+         * Do not strip a blank or tab that is preceeded by
+         * a '\'
+         */
 #ifdef USE_INLINEFILES
       if (!inInlineFile) {
 #endif
         ep = line;
         while (*ep)
             ++ep;
         while (ep > line + 1 && (ep[-1] == ' ' || ep[-1] == '\t')) {
             if (ep > line + 1 && ep[-2] == '\\')
                 break;
             --ep;
+        }
         *ep = 0;
+        ep = line;
+        while (*ep)
+            ++ep;
+        while (ep > line + 1 && (ep[-1] == ' ' || ep[-1] == '\t')) {
+            if (ep > line + 1 && ep[-2] == '\\')
+                break;
+            --ep;
+        }
+        *ep = 0;
 #ifdef USE_INLINEFILES
+      }
 …
 #ifdef NMAKE
         if (line[0] == '.' || line[0] == '!') {
+        if (line[0] == '.' || line[0] == '!') {
 #else
         if (line[0] == '.') {
 #endif
             /*
              * The line might be a conditional. Ask the conditional module
              * about it and act accordingly
              */
             switch (Cond_Eval (line)) {
             case COND_SKIP:
                 /*
                  * Skip to next conditional that evaluates to COND_PARSE.
                  */
                 do {
                     efree (line);
                     line = ParseSkipLine(1);
                 } while (line && Cond_Eval(line) != COND_PARSE);
                 if (line == NULL)
                     break;
                 /*FALLTHRU*/
             case COND_PARSE:
                 efree ((Address) line);
                 line = ParseReadLine();
                 break;
             case COND_INVALID:
                 if (For_Eval(line)) {
                     int ok;
                     efree(line);
                     do {
                         /*
                          * Skip after the matching end
                          */
                         line = ParseSkipLine(0);
                         if (line == NULL) {
                             Parse_Error (PARSE_FATAL,
                                      "Unexpected end of file in for loop.\n");
                             break;
+                        }
                         ok = For_Eval(line);
                         efree(line);
+                    }
                     while (ok);
                     if (line != NULL)
                         For_Run();
                     line = ParseReadLine();
+                }
                 break;
+            }
+        }
         return (line);
+        if (line[0] == '.') {
+#endif
+            /*
+             * The line might be a conditional. Ask the conditional module
+             * about it and act accordingly
+             */
+            switch (Cond_Eval (line)) {
+            case COND_SKIP:
+                /*
+                 * Skip to next conditional that evaluates to COND_PARSE.
+                 */
+                do {
+                    efree (line);
+                    line = ParseSkipLine(1);
+                } while (line && Cond_Eval(line) != COND_PARSE);
+                if (line == NULL)
+                    break;
+                /*FALLTHRU*/
+            case COND_PARSE:
+                efree ((Address) line);
+                line = ParseReadLine();
+                break;
+            case COND_INVALID:
+                if (For_Eval(line)) {
+                    int ok;
+                    efree(line);
+                    do {
+                        /*
+                         * Skip after the matching end
+                         */
+                        line = ParseSkipLine(0);
+                        if (line == NULL) {
+                            Parse_Error (PARSE_FATAL,
+                                     "Unexpected end of file in for loop.\n");
+                            break;
+                        }
+                        ok = For_Eval(line);
+                        efree(line);
+                    }
+                    while (ok);
+                    if (line != NULL)
+                        For_Run();
+                    line = ParseReadLine();
+                }
+                break;
+            }
+        }
+        return (line);
     } else {
         /*
          * Hit end-of-file, so return a NULL line to indicate this.
          */
         return((char *)NULL);
+        /*
+         * Hit end-of-file, so return a NULL line to indicate this.
+         */
+        return((char *)NULL);
+    }
+}
 …
  *-----------------------------------------------------------------------
  * ParseFinishLine --
  *      Handle the end of a dependency group.
+ *      Handle the end of a dependency group.
+ *
  * Results:
  *      Nothing.
+ *      Nothing.
+ *
  * Side Effects:
  *      inLine set FALSE. 'targets' list destroyed.
+ *      inLine set FALSE. 'targets' list destroyed.
+ *
  *-----------------------------------------------------------------------
 …
+{
     if (inLine) {
         Lst_ForEach(targets, Suff_EndTransform, (ClientData)NULL);
         Lst_Destroy (targets, ParseHasCommands);
         targets = NULL;
         inLine = FALSE;
+        Lst_ForEach(targets, Suff_EndTransform, (ClientData)NULL);
+        Lst_Destroy (targets, ParseHasCommands);
+        targets = NULL;
+        inLine = FALSE;
+    }
+}
 …
  *---------------------------------------------------------------------
  * Parse_File --
  *      Parse a file into its component parts, incorporating it into the
  *      current dependency graph. This is the main function and controls
  *      almost every other function in this module
+ *      Parse a file into its component parts, incorporating it into the
+ *      current dependency graph. This is the main function and controls
+ *      almost every other function in this module
+ *
  * Results:
  *      None
+ *      None
+ *
  * Side Effects:
  *      Loads. Nodes are added to the list of all targets, nodes and links
  *      are added to the dependency graph. etc. etc. etc.
+ *      Loads. Nodes are added to the list of all targets, nodes and links
+ *      are added to the dependency graph. etc. etc. etc.
  *---------------------------------------------------------------------
  */
 void
 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 */
+    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 */
     inLine = FALSE;
 …
     do {
         while ((line = ParseReadLine ()) != NULL) {
+        while ((line = ParseReadLine ()) != NULL) {
             if (DEBUG(PARSE))
                 printf("%s(%d): inLine=%d inInlineFile=%d\n%s\n", fname, lineno, inLine, inInlineFile, line);
             #ifdef NMAKE
             if (*line == '.' || *line == '!') {
+            if (*line == '.' || *line == '!') {
             #else
             if (*line == '.') {
+            if (*line == '.') {
             #endif
                 /*
                  * Lines that begin with the special character are either
                  * include or undef directives.
                  */
                 for (cp = line + 1; isspace (*cp); cp++) {
                     continue;
+                }
                 if (strncmp (cp, "include", 7) == 0) {
                     ParseDoInclude (cp + 7, *line);
                     goto nextLine;
                 } else if (strncmp (cp, "error", 5) == 0) {
                     ParseDoError(cp + 5);
+                    goto nextLine;
                 } else if (strncmp(cp, "undef", 5) == 0) {
                     char *cp2;
                     for (cp += 5; isspace((unsigned char) *cp); cp++) {
                         continue;
+                    }
                     for (cp2 = cp; !isspace((unsigned char) *cp2) &&
                                    (*cp2 != '\0'); cp2++) {
                         continue;
+                    }
                     *cp2 = '\0';
                     Var_Delete(cp, VAR_GLOBAL);
                     goto nextLine;
+                }
+            }
+                /*
+                 * Lines that begin with the special character are either
+                 * include or undef directives.
+                 */
+                for (cp = line + 1; isspace (*cp); cp++) {
+                    continue;
+                }
+                if (strncmp (cp, "include", 7) == 0) {
+                    ParseDoInclude (cp + 7, *line);
+                    goto nextLine;
+                } else if (strncmp (cp, "error", 5) == 0) {
+                    ParseDoError(cp + 5);
+                    goto nextLine;
+                } else if (strncmp(cp, "undef", 5) == 0) {
+                    char *cp2;
+                    for (cp += 5; isspace((unsigned char) *cp); cp++) {
+                        continue;
+                    }
+                    for (cp2 = cp; !isspace((unsigned char) *cp2) &&
+                                   (*cp2 != '\0'); cp2++) {
+                        continue;
+                    }
+                    *cp2 = '\0';
+                    Var_Delete(cp, VAR_GLOBAL);
+                    goto nextLine;
+                }
+            }
             #ifdef USE_INLINEFILES
 …
                     /*Lst_AtEnd(targCmds, (ClientData) line); */
+                }
                 goto nextLine;
+                goto nextLine;
+            }
             #endif
             if (*line == '#') {
                 /* If we're this far, the line must be a comment. */
                 goto nextLine;
+            }
             if (*line == '\t') {
                 /*
                  * If a line starts with a tab, it can only hope to be
                  * a creation command.
                  */
+            if (*line == '#') {
+                /* If we're this far, the line must be a comment. */
+                goto nextLine;
+            }
+            if (*line == '\t') {
+                /*
+                 * If a line starts with a tab, it can only hope to be
+                 * a creation command.
+                 */
 #if !defined(POSIX) || defined(USE_NO_STUPID_TABS)
             shellCommand:
 #endif
                 for (cp = line + 1; isspace (*cp); cp++) {
                     continue;
+                }
                 if (*cp) {
                     if (inLine) {
+            shellCommand:
+#endif
+                for (cp = line + 1; isspace (*cp); cp++) {
+                    continue;
+                }
+                if (*cp) {
+                    if (inLine) {
                         #ifdef USE_INLINEFILES
                         if (ParseCmdIsComponent(cp, "<<"))
 …
+                        }
                         #endif
                         /*
                          * So long as it's not a blank line and we're actually
                          * in a dependency spec, add the command to the list of
                          * commands of all targets in the dependency spec
                          */
                         Lst_ForEach (targets, ParseAddCmd, cp);
                         /*Lst_AtEnd(targCmds, (ClientData) line);*/
                         continue;
                     } else {
                         Parse_Error (PARSE_FATAL,
                                      "Unassociated shell command \"%s\"",
                                      cp);
+                    }
+                }
+                        /*
+                         * So long as it's not a blank line and we're actually
+                         * in a dependency spec, add the command to the list of
+                         * commands of all targets in the dependency spec
+                         */
+                        Lst_ForEach (targets, ParseAddCmd, cp);
+                        /*Lst_AtEnd(targCmds, (ClientData) line);*/
+                        continue;
+                    } else {
+                        Parse_Error (PARSE_FATAL,
+                                     "Unassociated shell command \"%s\"",
+                                     cp);
+                    }
+                }
 #ifdef SYSVINCLUDE
             } else if (strncmp (line, "include", 7) == 0 &&
                        isspace((unsigned char) line[7]) &&
                        strchr(line, ':') == NULL) {
                 /*
                  * It's an S3/S5-style "include".
                  */
                 ParseTraditionalInclude (line + 7);
                 goto nextLine;
 #endif
             } else if (Parse_IsVar (line)) {
                 ParseFinishLine();
                 Parse_DoVar (line, VAR_GLOBAL);
             } else {
                 /*
                  * We now know it's a dependency line so it needs to have all
                  * variables expanded before being parsed. Tell the variable
                  * module to complain if some variable is undefined...
                  * To make life easier on novices, if the line is indented we
                  * first make sure the line has a dependency operator in it.
                  * If it doesn't have an operator and we're in a dependency
                  * line's script, we assume it's actually a shell command
                  * and add it to the current list of targets.
                  */
+            } else if (strncmp (line, "include", 7) == 0 &&
+                       isspace((unsigned char) line[7]) &&
+                       strchr(line, ':') == NULL) {
+                /*
+                 * It's an S3/S5-style "include".
+                 */
+                ParseTraditionalInclude (line + 7);
+                goto nextLine;
+#endif
+            } else if (Parse_IsVar (line)) {
+                ParseFinishLine();
+                Parse_DoVar (line, VAR_GLOBAL);
+            } else {
+                /*
+                 * We now know it's a dependency line so it needs to have all
+                 * variables expanded before being parsed. Tell the variable
+                 * module to complain if some variable is undefined...
+                 * To make life easier on novices, if the line is indented we
+                 * first make sure the line has a dependency operator in it.
+                 * If it doesn't have an operator and we're in a dependency
+                 * line's script, we assume it's actually a shell command
+                 * and add it to the current list of targets.
+                 */
 #if !defined(POSIX) || defined(USE_NO_STUPID_TABS)
                 Boolean nonSpace = FALSE;
 #endif
                 cp = line;
                 if (isspace((unsigned char) line[0])) {
                     while ((*cp != '\0') && isspace((unsigned char) *cp)) {
                         cp++;
+                    }
                     if (*cp == '\0') {
                         goto nextLine;
+                    }
+                Boolean nonSpace = FALSE;
+#endif
+                cp = line;
+                if (isspace((unsigned char) line[0])) {
+                    while ((*cp != '\0') && isspace((unsigned char) *cp)) {
+                        cp++;
+                    }
+                    if (*cp == '\0') {
+                        goto nextLine;
+                    }
 #if !defined(POSIX) || defined(USE_NO_STUPID_TABS)
                     while ((*cp != ':') && (*cp != '!') && (*cp != '\0')) {
                         nonSpace = TRUE;
                         cp++;
+                    }
 #endif
+                }
+                    while ((*cp != ':') && (*cp != '!') && (*cp != '\0')) {
+                        nonSpace = TRUE;
+                        cp++;
+                    }
+#endif
+                }
 #if !defined(POSIX) || defined(USE_NO_STUPID_TABS)
                 if (*cp == '\0') {
                     if (inLine) {
+                if (*cp == '\0') {
+                    if (inLine) {
 #if !defined(USE_NO_STUPID_TABS)
                         Parse_Error (PARSE_WARNING,
                                      "Shell command needs a leading tab");
 #endif
                         goto shellCommand;
                     } else if (nonSpace) {
                         Parse_Error (PARSE_FATAL, "Missing operator");
+                    }
                 } else {
 #endif
                     ParseFinishLine();
                     cp = Var_Subst (NULL, line, VAR_CMD, TRUE);
                     efree (line);
                     line = cp;
                     /*
                      * Need a non-circular list for the target nodes
                      */
                     if (targets)
                         Lst_Destroy(targets, NOFREE);
                     targets = Lst_Init (FALSE);
                     inLine = TRUE;
                     ParseDoDependency (line);
+                        Parse_Error (PARSE_WARNING,
+                                     "Shell command needs a leading tab");
+#endif
+                        goto shellCommand;
+                    } else if (nonSpace) {
+                        Parse_Error (PARSE_FATAL, "Missing operator");
+                    }
+                } else {
+#endif
+                    ParseFinishLine();
+                    cp = Var_Subst (NULL, line, VAR_CMD, TRUE);
+                    efree (line);
+                    line = cp;
+                    /*
+                     * Need a non-circular list for the target nodes
+                     */
+                    if (targets)
+                        Lst_Destroy(targets, NOFREE);
+                    targets = Lst_Init (FALSE);
+                    inLine = TRUE;
+                    ParseDoDependency (line);
 #if !defined(POSIX) || defined(USE_NO_STUPID_TABS)
+                }
 #endif
+            }
             nextLine:
             efree (line);
+        }
         /*
          * Reached EOF, but it may be just EOF of an include file...
          */
+                }
+#endif
+            }
+            nextLine:
+            efree (line);
+        }
+        /*
+         * Reached EOF, but it may be just EOF of an include file...
+         */
     } while (ParseEOF(1) == CONTINUE);
 …
     if (fatals)
         errx(1, "fatal errors encountered -- cannot continue");
+        errx(1, "fatal errors encountered -- cannot continue");
+}
 …
  *---------------------------------------------------------------------
  * Parse_Init --
  *      initialize the parsing module
+ *      initialize the parsing module
+ *
  * Results:
  *      none
+ *      none
+ *
  * Side Effects:
  *      the parseIncPath list is initialized...
+ *      the parseIncPath list is initialized...
  *---------------------------------------------------------------------
  */
 …
     /*Lst_Destroy(targCmds, (void (*) __P((ClientData))) efree);*/
     if (targets)
         Lst_Destroy(targets, NOFREE);
+        Lst_Destroy(targets, NOFREE);
     Lst_Destroy(sysIncPath, Dir_Destroy);
     Lst_Destroy(parseIncPath, Dir_Destroy);
     Lst_Destroy(includes, NOFREE);      /* Should be empty now */
+    Lst_Destroy(includes, NOFREE);      /* Should be empty now */
+}
 …
  *-----------------------------------------------------------------------
  * Parse_MainName --
  *      Return a Lst of the main target to create for main()'s sake. If
  *      no such target exists, we Punt with an obnoxious error message.
+ *      Return a Lst of the main target to create for main()'s sake. If
+ *      no such target exists, we Punt with an obnoxious error message.
+ *
  * Results:
  *      A Lst of the single node to create.
+ *      A Lst of the single node to create.
+ *
  * Side Effects:
  *      None.
+ *      None.
+ *
  *-----------------------------------------------------------------------
 …
 Parse_MainName()
+{
     Lst           listmain;     /* result list */
+    Lst           listmain;     /* result list */
     listmain = Lst_Init (FALSE);
     if (mainNode == NILGNODE) {
         Punt ("no target to make.");
         /*NOTREACHED*/
+        Punt ("no target to make.");
+        /*NOTREACHED*/
     } else if (mainNode->type & OP_DOUBLEDEP) {
         (void) Lst_AtEnd (listmain, (ClientData)mainNode);
         Lst_Concat(listmain, mainNode->cohorts, LST_CONCNEW);
+        (void) Lst_AtEnd (listmain, (ClientData)mainNode);
+        Lst_Concat(listmain, mainNode->cohorts, LST_CONCNEW);
+    }
     else
         (void) Lst_AtEnd (listmain, (ClientData)mainNode);
+        (void) Lst_AtEnd (listmain, (ClientData)mainNode);
     return (listmain);
+}

Note: See TracChangeset for help on using the changeset viewer.

Changeset 51 in kBuild for trunk/src/kmk/parse.c

Legend:

trunk/src/kmk/parse.c

Download in other formats: