Changeset 51 in kBuild

Timestamp:

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

Author:

bird

Message:

kMk and porting to kLib.

Location:

trunk/src

Files:

• kmk/buf.c (modified) (24 diffs)
• kmk/compat.c (modified) (22 diffs)
• kmk/cond.c (modified) (42 diffs)
• kmk/config.h (modified) (7 diffs)
• kmk/dir.c (modified) (38 diffs)
• kmk/for.c (modified) (11 diffs)
• kmk/hash.c (modified) (17 diffs)
• kmk/helpers.c (modified) (6 diffs)
• kmk/job.c (modified) (88 diffs)
• kmk/job.h (modified) (8 diffs)
• kmk/main.c (modified) (24 diffs)
• kmk/make.c (modified) (32 diffs)
• kmk/make.h (modified) (15 diffs)
• kmk/nonints.h (modified) (4 diffs)
• kmk/parse.c (modified) (89 diffs)
• kmk/str.c (modified) (14 diffs)
• kmk/suff.c (modified) (85 diffs)
• kmk/targ.c (modified) (27 diffs)
• kmk/util.c (modified) (12 diffs)
• kmk/var.c (modified) (74 diffs)
• makefile.os2.icc.mk (modified) (7 diffs)

trunk/src/kmk/buf.c

@@ -18 +18 @@
  * 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
@@ -39 +39 @@
 #ifndef lint
 #if 0
-static char sccsid[] = "@(#)buf.c       8.1 (Berkeley) 6/6/93";
+static char sccsid[] = "@(#)buf.c       8.1 (Berkeley) 6/6/93";
 #else
 static const char rcsid[] =
   "$FreeBSD: src/usr.bin/make/buf.c,v 1.11 1999/09/11 13:08:01 hoek Exp $";
 #endif
+#define KLIBFILEDEF rcsid
 #endif /* not lint */
 
 /*-
  * buf.c --
- *      Functions for automatically-expanded buffers.
+ *      Functions for automatically-expanded buffers.
  */
 
@@ -61 +62 @@
 /*
  * BufExpand --
- *      Expand the given buffer to hold the given number of additional
- *      bytes.
- *      Makes sure there's room for an extra NULL byte at the end of the
- *      buffer in case it holds a string.
+ *      Expand the given buffer to hold the given number of additional
+ *      bytes.
+ *      Makes sure there's room for an extra NULL byte at the end of the
+ *      buffer in case it holds a string.
  */
 #define BufExpand(bp,nb) \
-        if (bp->left < (nb)+1) {\
-            int newSize = (bp)->size + max((nb)+1,BUF_ADD_INC); \
-            Byte  *newBuf = (Byte *) erealloc((bp)->buffer, newSize); \
-            \
-            (bp)->inPtr = newBuf + ((bp)->inPtr - (bp)->buffer); \
-            (bp)->outPtr = newBuf + ((bp)->outPtr - (bp)->buffer);\
-            (bp)->buffer = newBuf;\
-            (bp)->size = newSize;\
-            (bp)->left = newSize - ((bp)->inPtr - (bp)->buffer);\
-        }
-
-#define BUF_DEF_SIZE    256     /* Default buffer size */
-#define BUF_ADD_INC     256     /* Expansion increment when Adding */
-#define BUF_UNGET_INC   16      /* Expansion increment when Ungetting */
+        if (bp->left < (nb)+1) {\
+            int newSize = (bp)->size + max((nb)+1,BUF_ADD_INC); \
+            Byte  *newBuf = (Byte *) erealloc((bp)->buffer, newSize); \
+            \
+            (bp)->inPtr = newBuf + ((bp)->inPtr - (bp)->buffer); \
+            (bp)->outPtr = newBuf + ((bp)->outPtr - (bp)->buffer);\
+            (bp)->buffer = newBuf;\
+            (bp)->size = newSize;\
+            (bp)->left = newSize - ((bp)->inPtr - (bp)->buffer);\
+        }
+
+#define BUF_DEF_SIZE    256     /* Default buffer size */
+#define BUF_ADD_INC     256     /* Expansion increment when Adding */
+#define BUF_UNGET_INC   16      /* Expansion increment when Ungetting */
 
 /*-
  *-----------------------------------------------------------------------
  * Buf_OvAddByte --
- *      Add a single byte to the buffer.  left is zero or negative.
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      The buffer may be expanded.
+ *      Add a single byte to the buffer.  left is zero or negative.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      The buffer may be expanded.
  *
  *-----------------------------------------------------------------------
@@ -117 +118 @@
  *-----------------------------------------------------------------------
  * Buf_AddBytes --
- *      Add a number of bytes to the buffer.
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      Guess what?
+ *      Add a number of bytes to the buffer.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      Guess what?
  *
  *-----------------------------------------------------------------------
@@ -130 +131 @@
 Buf_AddBytes (bp, numBytes, bytesPtr)
     register Buffer bp;
-    int     numBytes;
+    int     numBytes;
     const Byte *bytesPtr;
 {
@@ -150 +151 @@
  *-----------------------------------------------------------------------
  * Buf_UngetByte --
- *      Place the byte back at the beginning of the buffer.
- *
- * Results:
- *      SUCCESS if the byte was added ok. FAILURE if not.
- *
- * Side Effects:
- *      The byte is stuffed in the buffer and outPtr is decremented.
+ *      Place the byte back at the beginning of the buffer.
+ *
+ * Results:
+ *      SUCCESS if the byte was added ok. FAILURE if not.
+ *
+ * Side Effects:
+ *      The byte is stuffed in the buffer and outPtr is decremented.
  *
  *-----------------------------------------------------------------------
@@ -167 +168 @@
 
     if (bp->outPtr != bp->buffer) {
-        bp->outPtr--;
-        *bp->outPtr = byte;
+        bp->outPtr--;
+        *bp->outPtr = byte;
     } else if (bp->outPtr == bp->inPtr) {
-        *bp->inPtr = byte;
-        bp->inPtr++;
-        bp->left--;
-        *bp->inPtr = 0;
+        *bp->inPtr = byte;
+        bp->inPtr++;
+        bp->left--;
+        *bp->inPtr = 0;
     } else {
-        /*
-         * Yech. have to expand the buffer to stuff this thing in.
-         * We use a different expansion constant because people don't
-         * usually push back many bytes when they're doing it a byte at
-         * a time...
-         */
-        int       numBytes = bp->inPtr - bp->outPtr;
-        Byte      *newBuf;
-
-        newBuf = (Byte *)emalloc(bp->size + BUF_UNGET_INC);
-        memcpy ((char *)(newBuf+BUF_UNGET_INC), (char *)bp->outPtr, numBytes+1);
-        bp->outPtr = newBuf + BUF_UNGET_INC;
-        bp->inPtr = bp->outPtr + numBytes;
-        efree ((char *)bp->buffer);
-        bp->buffer = newBuf;
-        bp->size += BUF_UNGET_INC;
-        bp->left = bp->size - (bp->inPtr - bp->buffer);
-        bp->outPtr -= 1;
-        *bp->outPtr = byte;
+        /*
+         * Yech. have to expand the buffer to stuff this thing in.
+         * We use a different expansion constant because people don't
+         * usually push back many bytes when they're doing it a byte at
+         * a time...
+         */
+        int       numBytes = bp->inPtr - bp->outPtr;
+        Byte      *newBuf;
+
+        newBuf = (Byte *)emalloc(bp->size + BUF_UNGET_INC);
+        memcpy ((char *)(newBuf+BUF_UNGET_INC), (char *)bp->outPtr, numBytes+1);
+        bp->outPtr = newBuf + BUF_UNGET_INC;
+        bp->inPtr = bp->outPtr + numBytes;
+        efree ((char *)bp->buffer);
+        bp->buffer = newBuf;
+        bp->size += BUF_UNGET_INC;
+        bp->left = bp->size - (bp->inPtr - bp->buffer);
+        bp->outPtr -= 1;
+        *bp->outPtr = byte;
     }
 }
@@ -201 +202 @@
  *-----------------------------------------------------------------------
  * Buf_UngetBytes --
- *      Push back a series of bytes at the beginning of the buffer.
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      outPtr is decremented and the bytes copied into the buffer.
+ *      Push back a series of bytes at the beginning of the buffer.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      outPtr is decremented and the bytes copied into the buffer.
  *
  *-----------------------------------------------------------------------
@@ -214 +215 @@
 Buf_UngetBytes (bp, numBytes, bytesPtr)
     register Buffer bp;
-    int     numBytes;
+    int     numBytes;
     Byte    *bytesPtr;
 {
 
     if (bp->outPtr - bp->buffer >= numBytes) {
-        bp->outPtr -= numBytes;
-        memcpy (bp->outPtr, bytesPtr, numBytes);
+        bp->outPtr -= numBytes;
+        memcpy (bp->outPtr, bytesPtr, numBytes);
     } else if (bp->outPtr == bp->inPtr) {
-        Buf_AddBytes (bp, numBytes, bytesPtr);
+        Buf_AddBytes (bp, numBytes, bytesPtr);
     } else {
-        int       curNumBytes = bp->inPtr - bp->outPtr;
-        Byte      *newBuf;
-        int       newBytes = max(numBytes,BUF_UNGET_INC);
-
-        newBuf = (Byte *)emalloc (bp->size + newBytes);
-        memcpy((char *)(newBuf+newBytes), (char *)bp->outPtr, curNumBytes+1);
-        bp->outPtr = newBuf + newBytes;
-        bp->inPtr = bp->outPtr + curNumBytes;
-        efree ((char *)bp->buffer);
-        bp->buffer = newBuf;
-        bp->size += newBytes;
-        bp->left = bp->size - (bp->inPtr - bp->buffer);
-        bp->outPtr -= numBytes;
-        memcpy ((char *)bp->outPtr, (char *)bytesPtr, numBytes);
+        int       curNumBytes = bp->inPtr - bp->outPtr;
+        Byte      *newBuf;
+        int       newBytes = max(numBytes,BUF_UNGET_INC);
+
+        newBuf = (Byte *)emalloc (bp->size + newBytes);
+        memcpy((char *)(newBuf+newBytes), (char *)bp->outPtr, curNumBytes+1);
+        bp->outPtr = newBuf + newBytes;
+        bp->inPtr = bp->outPtr + curNumBytes;
+        efree ((char *)bp->buffer);
+        bp->buffer = newBuf;
+        bp->size += newBytes;
+        bp->left = bp->size - (bp->inPtr - bp->buffer);
+        bp->outPtr -= numBytes;
+        memcpy ((char *)bp->outPtr, (char *)bytesPtr, numBytes);
     }
 }
@@ -245 +246 @@
  *-----------------------------------------------------------------------
  * Buf_GetByte --
- *      Return the next byte from the buffer. Actually returns an integer.
- *
- * Results:
- *      Returns BUF_ERROR if there's no byte in the buffer, or the byte
- *      itself if there is one.
- *
- * Side Effects:
- *      outPtr is incremented and both outPtr and inPtr will be reset if
- *      the buffer is emptied.
+ *      Return the next byte from the buffer. Actually returns an integer.
+ *
+ * Results:
+ *      Returns BUF_ERROR if there's no byte in the buffer, or the byte
+ *      itself if there is one.
+ *
+ * Side Effects:
+ *      outPtr is incremented and both outPtr and inPtr will be reset if
+ *      the buffer is emptied.
  *
  *-----------------------------------------------------------------------
@@ -261 +262 @@
     register Buffer bp;
 {
-    int     res;
+    int     res;
 
     if (bp->inPtr == bp->outPtr) {
-        return (BUF_ERROR);
+        return (BUF_ERROR);
     } else {
-        res = (int) *bp->outPtr;
-        bp->outPtr += 1;
-        if (bp->outPtr == bp->inPtr) {
-            bp->outPtr = bp->inPtr = bp->buffer;
-            bp->left = bp->size;
-            *bp->inPtr = 0;
-        }
-        return (res);
+        res = (int) *bp->outPtr;
+        bp->outPtr += 1;
+        if (bp->outPtr == bp->inPtr) {
+            bp->outPtr = bp->inPtr = bp->buffer;
+            bp->left = bp->size;
+            *bp->inPtr = 0;
+        }
+        return (res);
     }
 }
@@ -281 +282 @@
  *-----------------------------------------------------------------------
  * Buf_GetBytes --
- *      Extract a number of bytes from the buffer.
- *
- * Results:
- *      The number of bytes gotten.
- *
- * Side Effects:
- *      The passed array is overwritten.
+ *      Extract a number of bytes from the buffer.
+ *
+ * Results:
+ *      The number of bytes gotten.
+ *
+ * Side Effects:
+ *      The passed array is overwritten.
  *
  *-----------------------------------------------------------------------
@@ -294 +295 @@
 Buf_GetBytes (bp, numBytes, bytesPtr)
     register Buffer bp;
-    int     numBytes;
+    int     numBytes;
     Byte    *bytesPtr;
 {
 
     if (bp->inPtr - bp->outPtr < numBytes) {
-        numBytes = bp->inPtr - bp->outPtr;
+        numBytes = bp->inPtr - bp->outPtr;
     }
     memcpy (bytesPtr, bp->outPtr, numBytes);
@@ -305 +306 @@
 
     if (bp->outPtr == bp->inPtr) {
-        bp->outPtr = bp->inPtr = bp->buffer;
-        bp->left = bp->size;
-        *bp->inPtr = 0;
+        bp->outPtr = bp->inPtr = bp->buffer;
+        bp->left = bp->size;
+        *bp->inPtr = 0;
     }
     return (numBytes);
@@ -316 +317 @@
  *-----------------------------------------------------------------------
  * Buf_GetAll --
- *      Get all the available data at once.
- *
- * Results:
- *      A pointer to the data and the number of bytes available.
- *
- * Side Effects:
- *      None.
+ *      Get all the available data at once.
+ *
+ * Results:
+ *      A pointer to the data and the number of bytes available.
+ *
+ * Side Effects:
+ *      None.
  *
  *-----------------------------------------------------------------------
@@ -329 +330 @@
 Buf_GetAll (bp, numBytesPtr)
     register Buffer bp;
-    int     *numBytesPtr;
+    int     *numBytesPtr;
 {
 
     if (numBytesPtr != (int *)NULL) {
-        *numBytesPtr = bp->inPtr - bp->outPtr;
+        *numBytesPtr = bp->inPtr - bp->outPtr;
     }
 
@@ -343 +344 @@
  *-----------------------------------------------------------------------
  * Buf_Discard --
- *      Throw away bytes in a buffer.
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      The bytes are discarded.
+ *      Throw away bytes in a buffer.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      The bytes are discarded.
  *
  *-----------------------------------------------------------------------
@@ -356 +357 @@
 Buf_Discard (bp, numBytes)
     register Buffer bp;
-    int     numBytes;
+    int     numBytes;
 {
 
     if (bp->inPtr - bp->outPtr <= numBytes) {
-        bp->inPtr = bp->outPtr = bp->buffer;
-        bp->left = bp->size;
-        *bp->inPtr = 0;
+        bp->inPtr = bp->outPtr = bp->buffer;
+        bp->left = bp->size;
+        *bp->inPtr = 0;
     } else {
-        bp->outPtr += numBytes;
+        bp->outPtr += numBytes;
     }
 }
@@ -372 +373 @@
  *-----------------------------------------------------------------------
  * Buf_Size --
- *      Returns the number of bytes in the given buffer. Doesn't include
- *      the null-terminating byte.
- *
- * Results:
- *      The number of bytes.
- *
- * Side Effects:
- *      None.
+ *      Returns the number of bytes in the given buffer. Doesn't include
+ *      the null-terminating byte.
+ *
+ * Results:
+ *      The number of bytes.
+ *
+ * Side Effects:
+ *      None.
  *
  *-----------------------------------------------------------------------
@@ -394 +395 @@
  *-----------------------------------------------------------------------
  * Buf_Init --
- *      Initialize a buffer. If no initial size is given, a reasonable
- *      default is used.
- *
- * Results:
- *      A buffer to be given to other functions in this library.
- *
- * Side Effects:
- *      The buffer is created, the space allocated and pointers
- *      initialized.
+ *      Initialize a buffer. If no initial size is given, a reasonable
+ *      default is used.
+ *
+ * Results:
+ *      A buffer to be given to other functions in this library.
+ *
+ * Side Effects:
+ *      The buffer is created, the space allocated and pointers
+ *      initialized.
  *
  *-----------------------------------------------------------------------
@@ -408 +409 @@
 Buffer
 Buf_Init (size)
-    int     size;       /* Initial size for the buffer */
-{
-    Buffer bp;          /* New Buffer */
+    int     size;       /* Initial size for the buffer */
+{
+    Buffer bp;          /* New Buffer */
 
     bp = (Buffer)emalloc(sizeof(*bp));
 
     if (size <= 0) {
-        size = BUF_DEF_SIZE;
+        size = BUF_DEF_SIZE;
     }
     bp->left = bp->size = size;
@@ -429 +430 @@
  *-----------------------------------------------------------------------
  * Buf_Destroy --
- *      Nuke a buffer and all its resources.
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      The buffer is freed.
+ *      Nuke a buffer and all its resources.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      The buffer is freed.
  *
  *-----------------------------------------------------------------------
@@ -441 +442 @@
 void
 Buf_Destroy (buf, freeData)
-    Buffer  buf;        /* Buffer to destroy */
-    Boolean freeData;   /* TRUE if the data should be destroyed as well */
+    Buffer  buf;        /* Buffer to destroy */
+    Boolean freeData;   /* TRUE if the data should be destroyed as well */
 {
 
     if (freeData) {
-        efree ((char *)buf->buffer);
+        efree ((char *)buf->buffer);
     }
     efree ((char *)buf);
@@ -468 +469 @@
 void
 Buf_ReplaceLastByte (buf, byte)
-    Buffer buf; /* buffer to augment */
-    int byte;   /* byte to be written */
+    Buffer buf; /* buffer to augment */
+    int byte;   /* byte to be written */
 {
     if (buf->inPtr == buf->outPtr)

trunk/src/kmk/compat.c

@@ -18 +18 @@
  * 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
@@ -39 +39 @@
 #ifndef lint
 #if 0
-static char sccsid[] = "@(#)compat.c    8.2 (Berkeley) 3/19/94";
+static char sccsid[] = "@(#)compat.c    8.2 (Berkeley) 3/19/94";
 #else
 static const char rcsid[] =
   "$FreeBSD: src/usr.bin/make/compat.c,v 1.16.2.2 2000/07/01 12:24:21 ps Exp $";
 #endif
+#define KLIBFILEDEF rcsid
 #endif /* not lint */
 
 /*-
  * compat.c --
- *      The routines in this file implement the full-compatibility
- *      mode of PMake. Most of the special functionality of PMake
- *      is available in this mode. Things not supported:
- *          - different shells.
- *          - friendly variable substitution.
+ *      The routines in this file implement the full-compatibility
+ *      mode of PMake. Most of the special functionality of PMake
+ *      is available in this mode. Things not supported:
+ *          - different shells.
+ *          - friendly variable substitution.
  *
  * Interface:
- *      Compat_Run          Initialize things for this module and recreate
- *                          thems as need creatin'
+ *      Compat_Run          Initialize things for this module and recreate
+ *                          thems as need creatin'
  */
 
@@ -87 +88 @@
  */
 
-static char         meta[256];
-
-static GNode        *curTarg = NILGNODE;
-static GNode        *ENDNode;
+static char         meta[256];
+
+static GNode        *curTarg = NILGNODE;
+static GNode        *ENDNode;
 static void CompatInterrupt __P((int));
 static int CompatRunCommand __P((ClientData, ClientData));
@@ -96 +97 @@
 
 static char *sh_builtin[] = {
-        "alias", "cd", "eval", "exec", "exit", "read", "set", "ulimit",
-        "unalias", "umask", "unset", "wait", ":", 0};
+        "alias", "cd", "eval", "exec", "exit", "read", "set", "ulimit",
+        "unalias", "umask", "unset", "wait", ":", 0};
 
 /*-
  *-----------------------------------------------------------------------
  * CompatInterrupt --
- *      Interrupt the creation of the current target and remove it if
- *      it ain't precious.
+ *      Interrupt the creation of the current target and remove it if
+ *      it ain't precious.
  *
  * Results:
- *      None.
+ *      None.
  *
  * Side Effects:
- *      The target is removed and the process exits. If .INTERRUPT exists,
- *      its commands are run first WITH INTERRUPTS IGNORED..
+ *      The target is removed and the process exits. If .INTERRUPT exists,
+ *      its commands are run first WITH INTERRUPTS IGNORED..
  *
  *-----------------------------------------------------------------------
@@ -116 +117 @@
 static void
 CompatInterrupt (signo)
-    int     signo;
+    int     signo;
 {
     GNode   *gn;
 
     if ((curTarg != NILGNODE) && !Targ_Precious (curTarg)) {
-        char      *p1;
-        char      *file = Var_Value (TARGET, curTarg, &p1);
-
-        if (!noExecute && eunlink(file) != -1) {
-            printf ("*** %s removed\n", file);
-        }
-        efree(p1);
-
-        /*
-         * Run .INTERRUPT only if hit with interrupt signal
-         */
-        if (signo == SIGINT) {
-            gn = Targ_FindNode(".INTERRUPT", TARG_NOCREATE);
-            if (gn != NILGNODE) {
-                Lst_ForEach(gn->commands, CompatRunCommand, (ClientData)gn);
-            }
-        }
+        char      *p1;
+        char      *file = Var_Value (TARGET, curTarg, &p1);
+
+        if (!noExecute && eunlink(file) != -1) {
+            printf ("*** %s removed\n", file);
+        }
+        efree(p1);
+
+        /*
+         * Run .INTERRUPT only if hit with interrupt signal
+         */
+        if (signo == SIGINT) {
+            gn = Targ_FindNode(".INTERRUPT", TARG_NOCREATE);
+            if (gn != NILGNODE) {
+                Lst_ForEach(gn->commands, CompatRunCommand, (ClientData)gn);
+            }
+        }
 
     }
     #if !(defined(OS2) && defined(__IBMC__))
     if (signo == SIGQUIT)
-        exit(signo);
+        exit(signo);
     #endif
     (void) signal(signo, SIG_DFL);
@@ -152 +153 @@
  *-----------------------------------------------------------------------
  * shellneed --
- *      
+ *
  * Results:
- *      Returns 1 if a specified line must be executed by the shell,
- *      0 if it can be run via execve, and -1 if the command is a no-op.
+ *      Returns 1 if a specified line must be executed by the shell,
+ *      0 if it can be run via execve, and -1 if the command is a no-op.
  *
  * Side Effects:
- *      None.
- *      
+ *      None.
+ *
  *-----------------------------------------------------------------------
  */
 static int
 shellneed (cmd)
-        char *cmd;
+        char *cmd;
 {
-        char **av, **p;
-        int ac;
-
-        av = brk_string(cmd, &ac, TRUE);
-        for(p = sh_builtin; *p != 0; p++)
-                if (strcmp(av[1], *p) == 0)
-                        return (1);
-        return (0);
+        char **av, **p;
+        int ac;
+
+        av = brk_string(cmd, &ac, TRUE);
+        for(p = sh_builtin; *p != 0; p++)
+                if (strcmp(av[1], *p) == 0)
+                        return (1);
+        return (0);
 }
 
@@ -180 +181 @@
  *-----------------------------------------------------------------------
  * CompatRunCommand --
- *      Execute the next command for a target. If the command returns an
- *      error, the node's made field is set to ERROR and creation stops.
+ *      Execute the next command for a target. If the command returns an
+ *      error, the node's made field is set to ERROR and creation stops.
  *
  * Results:
- *      0 if the command succeeded, 1 if an error occurred.
+ *      0 if the command succeeded, 1 if an error occurred.
  *
  * Side Effects:
- *      The node's 'made' field may be set to ERROR.
+ *      The node's 'made' field may be set to ERROR.
  *
  *-----------------------------------------------------------------------
@@ -193 +194 @@
 static int
 CompatRunCommand (cmdp, gnp)
-    ClientData    cmdp;         /* Command to execute */
-    ClientData    gnp;          /* Node from which the command came */
+    ClientData    cmdp;         /* Command to execute */
+    ClientData    gnp;          /* Node from which the command came */
 {
-    char          *cmdStart;    /* Start of expanded command */
+    char          *cmdStart;    /* Start of expanded command */
     register char *cp;
-    Boolean       silent,       /* Don't print command */
-                  errCheck;     /* Check errors */
-    int           reason;       /* Reason for child's death */
-    int           status;       /* Description of child's death */
-    int           cpid;         /* Child actually found */
-    ReturnStatus  stat;         /* Status of fork */
-    LstNode       cmdNode;      /* Node where current command is located */
-    char          **av;         /* Argument vector for thing to exec */
-    int           argc;         /* Number of arguments in av or 0 if not
-                                 * dynamically allocated */
-    Boolean       local;        /* TRUE if command should be executed
-                                 * locally */
-    int           internal;     /* Various values.. */
-    char          *cmd = (char *) cmdp;
-    GNode         *gn = (GNode *) gnp;
+    Boolean       silent,       /* Don't print command */
+                  errCheck;     /* Check errors */
+    int           reason;       /* Reason for child's death */
+    int           status;       /* Description of child's death */
+    int           cpid;         /* Child actually found */
+    ReturnStatus  stat;         /* Status of fork */
+    LstNode       cmdNode;      /* Node where current command is located */
+    char          **av;         /* Argument vector for thing to exec */
+    int           argc;         /* Number of arguments in av or 0 if not
+                                 * dynamically allocated */
+    Boolean       local;        /* TRUE if command should be executed
+                                 * locally */
+    int           internal;     /* Various values.. */
+    char          *cmd = (char *) cmdp;
+    GNode         *gn = (GNode *) gnp;
 
     /*
@@ -236 +237 @@
 
     if (*cmdStart == '\0') {
-        efree(cmdStart);
-        Error("%s expands to empty string", cmd);
-        return(0);
+        efree(cmdStart);
+        Error("%s expands to empty string", cmd);
+        return(0);
     } else {
-        cmd = cmdStart;
+        cmd = cmdStart;
     }
     Lst_Replace (cmdNode, (ClientData)cmdStart);
 
     if ((gn->type & OP_SAVE_CMDS) && (gn != ENDNode)) {
-        (void)Lst_AtEnd(ENDNode->commands, (ClientData)cmdStart);
-        return(0);
+        (void)Lst_AtEnd(ENDNode->commands, (ClientData)cmdStart);
+        return(0);
     } else if (strcmp(cmdStart, "...") == 0) {
-        gn->type |= OP_SAVE_CMDS;
-        return(0);
+        gn->type |= OP_SAVE_CMDS;
+        return(0);
     }
 
     while ((*cmd == '@') || (*cmd == '-')) {
-        if (*cmd == '@') {
-            silent = DEBUG(LOUD) ? FALSE : TRUE;
-        } else {
-            errCheck = FALSE;
-        }
-        cmd++;
+        if (*cmd == '@') {
+            silent = DEBUG(LOUD) ? FALSE : TRUE;
+        } else {
+            errCheck = FALSE;
+        }
+        cmd++;
     }
 
     while (isspace((unsigned char)*cmd))
-        cmd++;
+        cmd++;
 
     /*
@@ -270 +271 @@
      */
     for (cp = cmd; !meta[(unsigned char)*cp]; cp++) {
-        continue;
+        continue;
     }
 
@@ -278 +279 @@
      */
     if (!silent || noExecute) {
-        printf ("%s\n", cmd);
-        fflush(stdout);
+        printf ("%s\n", cmd);
+        fflush(stdout);
     }
 
@@ -287 +288 @@
      */
     if (noExecute) {
-        return (0);
+        return (0);
     }
 
     if (*cp != '\0') {
-        /*
-         * If *cp isn't the null character, we hit a "meta" character and
-         * need to pass the command off to the shell. We give the shell the
-         * -e flag as well as -c if it's supposed to exit when it hits an
-         * error.
-         */
-        static char     *shargv[4] = { "/bin/sh" };
-
-        shargv[1] = (errCheck ? "-ec" : "-c");
-        shargv[2] = cmd;
-        shargv[3] = (char *)NULL;
-        av = shargv;
-        argc = 0;
+        /*
+         * If *cp isn't the null character, we hit a "meta" character and
+         * need to pass the command off to the shell. We give the shell the
+         * -e flag as well as -c if it's supposed to exit when it hits an
+         * error.
+         */
+        static char     *shargv[4] = { "/bin/sh" };
+
+        shargv[1] = (errCheck ? "-ec" : "-c");
+        shargv[2] = cmd;
+        shargv[3] = (char *)NULL;
+        av = shargv;
+        argc = 0;
     } else if ((internal = shellneed(cmd))) {
-        /*
-         * This command must be passed by the shell for other reasons..
-         * or.. possibly not at all.
-         */
-        static char     *shargv[4] = { "/bin/sh" };
-
-        if (internal == -1) {
-                /* Command does not need to be executed */
-                return (0);
-        }
-
-        shargv[1] = (errCheck ? "-ec" : "-c");
-        shargv[2] = cmd;
-        shargv[3] = (char *)NULL;
-        av = shargv;
-        argc = 0;
+        /*
+         * This command must be passed by the shell for other reasons..
+         * or.. possibly not at all.
+         */
+        static char     *shargv[4] = { "/bin/sh" };
+
+        if (internal == -1) {
+                /* Command does not need to be executed */
+                return (0);
+        }
+
+        shargv[1] = (errCheck ? "-ec" : "-c");
+        shargv[2] = cmd;
+        shargv[3] = (char *)NULL;
+        av = shargv;
+        argc = 0;
     } else {
-        /*
-         * No meta-characters, so no need to exec a shell. Break the command
-         * into words to form an argument vector we can execute.
-         * brk_string sticks our name in av[0], so we have to
-         * skip over it...
-         */
-        av = brk_string(cmd, &argc, TRUE);
-        av += 1;
+        /*
+         * No meta-characters, so no need to exec a shell. Break the command
+         * into words to form an argument vector we can execute.
+         * brk_string sticks our name in av[0], so we have to
+         * skip over it...
+         */
+        av = brk_string(cmd, &argc, TRUE);
+        av += 1;
     }
 
@@ -342 +343 @@
     cpid = vfork();
     if (cpid < 0) {
-        Fatal("Could not fork");
+        Fatal("Could not fork");
     }
     if (cpid == 0) {
-        if (local) {
-            execvp(av[0], av);
-            (void) write (2, av[0], strlen (av[0]));
-            (void) write (2, ":", 1);
-            (void) write (2, strerror(errno), strlen(strerror(errno)));
-            (void) write (2, "\n", 1);
-        } else {
-            (void)execv(av[0], av);
-        }
-        exit(1);
+        if (local) {
+            execvp(av[0], av);
+            (void) write (2, av[0], strlen (av[0]));
+            (void) write (2, ":", 1);
+            (void) write (2, strerror(errno), strlen(strerror(errno)));
+            (void) write (2, "\n", 1);
+        } else {
+            (void)execv(av[0], av);
+        }
+        exit(1);
     }
 #endif
@@ -365 +366 @@
      */
     if (!DEBUG(GRAPH2)) {
-        efree(cmdStart);
-        Lst_Replace (cmdNode, cmdp);
+        efree(cmdStart);
+        Lst_Replace (cmdNode, cmdp);
     }
 
@@ -374 +375 @@
     while (1) {
 
-        while ((stat = wait(&reason)) != cpid) {
-            if (stat == -1 && errno != EINTR) {
-                break;
-            }
-        }
-
-        if (stat > -1) {
-            if (WIFSTOPPED(reason)) {
-                status = WSTOPSIG(reason);              /* stopped */
-            } else if (WIFEXITED(reason)) {
-                status = WEXITSTATUS(reason);           /* exited */
-                if (status != 0) {
-                    printf ("*** Error code %d", status);
-                }
-            } else {
-                status = WTERMSIG(reason);              /* signaled */
-                printf ("*** Signal %d", status);
-            }
-
-
-            if (!WIFEXITED(reason) || (status != 0)) {
-                if (errCheck) {
-                    gn->made = ERROR;
-                    if (keepgoing) {
-                        /*
-                         * Abort the current target, but let others
-                         * continue.
-                         */
-                        printf (" (continuing)\n");
-                    }
-                } else {
-                    /*
-                     * Continue executing commands for this target.
-                     * If we return 0, this will happen...
-                     */
-                    printf (" (ignored)\n");
-                    status = 0;
-                }
-            }
-            break;
-        } else {
-            Fatal ("error in wait: %d", stat);
-            /*NOTREACHED*/
-        }
+        while ((stat = wait(&reason)) != cpid) {
+            if (stat == -1 && errno != EINTR) {
+                break;
+            }
+        }
+
+        if (stat > -1) {
+            if (WIFSTOPPED(reason)) {
+                status = WSTOPSIG(reason);              /* stopped */
+            } else if (WIFEXITED(reason)) {
+                status = WEXITSTATUS(reason);           /* exited */
+                if (status != 0) {
+                    printf ("*** Error code %d", status);
+                }
+            } else {
+                status = WTERMSIG(reason);              /* signaled */
+                printf ("*** Signal %d", status);
+            }
+
+
+            if (!WIFEXITED(reason) || (status != 0)) {
+                if (errCheck) {
+                    gn->made = ERROR;
+                    if (keepgoing) {
+                        /*
+                         * Abort the current target, but let others
+                         * continue.
+                         */
+                        printf (" (continuing)\n");
+                    }
+                } else {
+                    /*
+                     * Continue executing commands for this target.
+                     * If we return 0, this will happen...
+                     */
+                    printf (" (ignored)\n");
+                    status = 0;
+                }
+            }
+            break;
+        } else {
+            Fatal ("error in wait: %d", stat);
+            /*NOTREACHED*/
+        }
     }
 
@@ -427 +428 @@
  *-----------------------------------------------------------------------
  * CompatMake --
- *      Make a target.
+ *      Make a target.
  *
  * Results:
- *      0
+ *      0
  *
  * Side Effects:
- *      If an error is detected and not being ignored, the process exits.
+ *      If an error is detected and not being ignored, the process exits.
  *
  *-----------------------------------------------------------------------
@@ -439 +440 @@
 static int
 CompatMake (gnp, pgnp)
-    ClientData  gnp;        /* The node to make */
-    ClientData  pgnp;       /* Parent to abort if necessary */
+    ClientData  gnp;        /* The node to make */
+    ClientData  pgnp;       /* Parent to abort if necessary */
 {
     GNode *gn = (GNode *) gnp;
     GNode *pgn = (GNode *) pgnp;
     if (gn->type & OP_USE) {
-        Make_HandleUse(gn, pgn);
+        Make_HandleUse(gn, pgn);
     } else if (gn->made == UNMADE) {
-        /*
-         * First mark ourselves to be made, then apply whatever transformations
-         * the suffix module thinks are necessary. Once that's done, we can
-         * descend and make all our children. If any of them has an error
-         * but the -k flag was given, our 'make' field will be set FALSE again.
-         * This is our signal to not attempt to do anything but abort our
-         * parent as well.
-         */
-        gn->make = TRUE;
-        gn->made = BEINGMADE;
-        Suff_FindDeps (gn);
-        Lst_ForEach (gn->children, CompatMake, (ClientData)gn);
-        if (!gn->make) {
-            gn->made = ABORTED;
-            pgn->make = FALSE;
-            return (0);
-        }
-
-        if (Lst_Member (gn->iParents, pgn) != NILLNODE) {
-            char *p1;
-            Var_Set (IMPSRC, Var_Value(TARGET, gn, &p1), pgn);
-            efree(p1);
-        }
-
-        /*
-         * All the children were made ok. Now cmtime contains the modification
-         * time of the newest child, we need to find out if we exist and when
-         * we were modified last. The criteria for datedness are defined by the
-         * Make_OODate function.
-         */
-        if (DEBUG(MAKE)) {
-            printf("Examining %s...", gn->name);
-        }
-        if (! Make_OODate(gn)) {
-            gn->made = UPTODATE;
-            if (DEBUG(MAKE)) {
-                printf("up-to-date.\n");
-            }
-            return (0);
-        } else if (DEBUG(MAKE)) {
-            printf("out-of-date.\n");
-        }
-
-        /*
-         * If the user is just seeing if something is out-of-date, exit now
-         * to tell him/her "yes".
-         */
-        if (queryFlag) {
-            exit (-1);
-        }
-
-        /*
-         * We need to be re-made. We also have to make sure we've got a $?
-         * variable. To be nice, we also define the $> variable using
-         * Make_DoAllVar().
-         */
-        Make_DoAllVar(gn);
-
-        /*
-         * Alter our type to tell if errors should be ignored or things
-         * should not be printed so CompatRunCommand knows what to do.
-         */
-        if (Targ_Ignore (gn)) {
-            gn->type |= OP_IGNORE;
-        }
-        if (Targ_Silent (gn)) {
-            gn->type |= OP_SILENT;
-        }
-
-        if (Job_CheckCommands (gn, Fatal)) {
-            /*
-             * Our commands are ok, but we still have to worry about the -t
-             * flag...
-             */
-            if (!touchFlag) {
-                curTarg = gn;
-                Lst_ForEach (gn->commands, CompatRunCommand, (ClientData)gn);
-                curTarg = NILGNODE;
-            } else {
-                Job_Touch (gn, gn->type & OP_SILENT);
-            }
-        } else {
-            gn->made = ERROR;
-        }
-
-        if (gn->made != ERROR) {
-            /*
-             * If the node was made successfully, mark it so, update
-             * its modification time and timestamp all its parents. Note
-             * that for .ZEROTIME targets, the timestamping isn't done.
-             * This is to keep its state from affecting that of its parent.
-             */
-            gn->made = MADE;
+        /*
+         * First mark ourselves to be made, then apply whatever transformations
+         * the suffix module thinks are necessary. Once that's done, we can
+         * descend and make all our children. If any of them has an error
+         * but the -k flag was given, our 'make' field will be set FALSE again.
+         * This is our signal to not attempt to do anything but abort our
+         * parent as well.
+         */
+        gn->make = TRUE;
+        gn->made = BEINGMADE;
+        Suff_FindDeps (gn);
+        Lst_ForEach (gn->children, CompatMake, (ClientData)gn);
+        if (!gn->make) {
+            gn->made = ABORTED;
+            pgn->make = FALSE;
+            return (0);
+        }
+
+        if (Lst_Member (gn->iParents, pgn) != NILLNODE) {
+            char *p1;
+            Var_Set (IMPSRC, Var_Value(TARGET, gn, &p1), pgn);
+            efree(p1);
+        }
+
+        /*
+         * All the children were made ok. Now cmtime contains the modification
+         * time of the newest child, we need to find out if we exist and when
+         * we were modified last. The criteria for datedness are defined by the
+         * Make_OODate function.
+         */
+        if (DEBUG(MAKE)) {
+            printf("Examining %s...", gn->name);
+        }
+        if (! Make_OODate(gn)) {
+            gn->made = UPTODATE;
+            if (DEBUG(MAKE)) {
+                printf("up-to-date.\n");
+            }
+            return (0);
+        } else if (DEBUG(MAKE)) {
+            printf("out-of-date.\n");
+        }
+
+        /*
+         * If the user is just seeing if something is out-of-date, exit now
+         * to tell him/her "yes".
+         */
+        if (queryFlag) {
+            exit (-1);
+        }
+
+        /*
+         * We need to be re-made. We also have to make sure we've got a $?
+         * variable. To be nice, we also define the $> variable using
+         * Make_DoAllVar().
+         */
+        Make_DoAllVar(gn);
+
+        /*
+         * Alter our type to tell if errors should be ignored or things
+         * should not be printed so CompatRunCommand knows what to do.
+         */
+        if (Targ_Ignore (gn)) {
+            gn->type |= OP_IGNORE;
+        }
+        if (Targ_Silent (gn)) {
+            gn->type |= OP_SILENT;
+        }
+
+        if (Job_CheckCommands (gn, Fatal)) {
+            /*
+             * Our commands are ok, but we still have to worry about the -t
+             * flag...
+             */
+            if (!touchFlag) {
+                curTarg = gn;
+                Lst_ForEach (gn->commands, CompatRunCommand, (ClientData)gn);
+                curTarg = NILGNODE;
+            } else {
+                Job_Touch (gn, gn->type & OP_SILENT);
+            }
+        } else {
+            gn->made = ERROR;
+        }
+
+        if (gn->made != ERROR) {
+            /*
+             * If the node was made successfully, mark it so, update
+             * its modification time and timestamp all its parents. Note
+             * that for .ZEROTIME targets, the timestamping isn't done.
+             * This is to keep its state from affecting that of its parent.
+             */
+            gn->made = MADE;
 #ifndef RECHECK
-            /*
-             * We can't re-stat the thing, but we can at least take care of
-             * rules where a target depends on a source that actually creates
-             * the target, but only if it has changed, e.g.
-             *
-             * parse.h : parse.o
-             *
-             * parse.o : parse.y
-             *          yacc -d parse.y
-             *          cc -c y.tab.c
-             *          mv y.tab.o parse.o
-             *          cmp -s y.tab.h parse.h || mv y.tab.h parse.h
-             *
-             * In this case, if the definitions produced by yacc haven't
-             * changed from before, parse.h won't have been updated and
-             * gn->mtime will reflect the current modification time for
-             * parse.h. This is something of a kludge, I admit, but it's a
-             * useful one..
-             *
-             * XXX: People like to use a rule like
-             *
-             * FRC:
-             *
-             * To force things that depend on FRC to be made, so we have to
-             * check for gn->children being empty as well...
-             */
-            if (!Lst_IsEmpty(gn->commands) || Lst_IsEmpty(gn->children)) {
-                gn->mtime = now;
-            }
+            /*
+             * We can't re-stat the thing, but we can at least take care of
+             * rules where a target depends on a source that actually creates
+             * the target, but only if it has changed, e.g.
+             *
+             * parse.h : parse.o
+             *
+             * parse.o : parse.y
+             *          yacc -d parse.y
+             *          cc -c y.tab.c
+             *          mv y.tab.o parse.o
+             *          cmp -s y.tab.h parse.h || mv y.tab.h parse.h
+             *
+             * In this case, if the definitions produced by yacc haven't
+             * changed from before, parse.h won't have been updated and
+             * gn->mtime will reflect the current modification time for
+             * parse.h. This is something of a kludge, I admit, but it's a
+             * useful one..
+             *
+             * XXX: People like to use a rule like
+             *
+             * FRC:
+             *
+             * To force things that depend on FRC to be made, so we have to
+             * check for gn->children being empty as well...
+             */
+            if (!Lst_IsEmpty(gn->commands) || Lst_IsEmpty(gn->children)) {
+                gn->mtime = now;
+            }
 #else
-            /*
-             * This is what Make does and it's actually a good thing, as it
-             * allows rules like
-             *
-             *  cmp -s y.tab.h parse.h || cp y.tab.h parse.h
-             *
-             * to function as intended. Unfortunately, thanks to the stateless
-             * nature of NFS (and the speed of this program), there are times
-             * when the modification time of a file created on a remote
-             * machine will not be modified before the stat() implied by
-             * the Dir_MTime occurs, thus leading us to believe that the file
-             * is unchanged, wreaking havoc with files that depend on this one.
-             *
-             * I have decided it is better to make too much than to make too
-             * little, so this stuff is commented out unless you're sure it's
-             * ok.
-             * -- ardeb 1/12/88
-             */
-            if (noExecute || Dir_MTime(gn) == 0) {
-                gn->mtime = now;
-            }
-            if (gn->cmtime > gn->mtime)
-                gn->mtime = gn->cmtime;
-            if (DEBUG(MAKE)) {
-                printf("update time: %s\n", Targ_FmtTime(gn->mtime));
-            }
+            /*
+             * This is what Make does and it's actually a good thing, as it
+             * allows rules like
+             *
+             *  cmp -s y.tab.h parse.h || cp y.tab.h parse.h
+             *
+             * to function as intended. Unfortunately, thanks to the stateless
+             * nature of NFS (and the speed of this program), there are times
+             * when the modification time of a file created on a remote
+             * machine will not be modified before the stat() implied by
+             * the Dir_MTime occurs, thus leading us to believe that the file
+             * is unchanged, wreaking havoc with files that depend on this one.
+             *
+             * I have decided it is better to make too much than to make too
+             * little, so this stuff is commented out unless you're sure it's
+             * ok.
+             * -- ardeb 1/12/88
+             */
+            if (noExecute || Dir_MTime(gn) == 0) {
+                gn->mtime = now;
+            }
+            if (gn->cmtime > gn->mtime)
+                gn->mtime = gn->cmtime;
+            if (DEBUG(MAKE)) {
+                printf("update time: %s\n", Targ_FmtTime(gn->mtime));
+            }
 #endif
-            if (!(gn->type & OP_EXEC)) {
-                pgn->childMade = TRUE;
-                Make_TimeStamp(pgn, gn);
-            }
-        } else if (keepgoing) {
-            pgn->make = FALSE;
-        } else {
-            char *p1;
-
-            printf ("\n\nStop in %s.\n", Var_Value(".CURDIR", gn, &p1));
-            efree(p1);
-            exit (1);
-        }
+            if (!(gn->type & OP_EXEC)) {
+                pgn->childMade = TRUE;
+                Make_TimeStamp(pgn, gn);
+            }
+        } else if (keepgoing) {
+            pgn->make = FALSE;
+        } else {
+            char *p1;
+
+            printf ("\n\nStop in %s.\n", Var_Value(".CURDIR", gn, &p1));
+            efree(p1);
+            exit (1);
+        }
     } else if (gn->made == ERROR) {
-        /*
-         * Already had an error when making this beastie. Tell the parent
-         * to abort.
-         */
-        pgn->make = FALSE;
+        /*
+         * Already had an error when making this beastie. Tell the parent
+         * to abort.
+         */
+        pgn->make = FALSE;
     } else {
-        if (Lst_Member (gn->iParents, pgn) != NILLNODE) {
-            char *p1;
-            Var_Set (IMPSRC, Var_Value(TARGET, gn, &p1), pgn);
-            efree(p1);
-        }
-        switch(gn->made) {
-            case BEINGMADE:
-                Error("Graph cycles through %s\n", gn->name);
-                gn->made = ERROR;
-                pgn->make = FALSE;
-                break;
-            case MADE:
-                if ((gn->type & OP_EXEC) == 0) {
-                    pgn->childMade = TRUE;
-                    Make_TimeStamp(pgn, gn);
-                }
-                break;
-            case UPTODATE:
-                if ((gn->type & OP_EXEC) == 0) {
-                    Make_TimeStamp(pgn, gn);
-                }
-                break;
-            default:
-                break;
-        }
+        if (Lst_Member (gn->iParents, pgn) != NILLNODE) {
+            char *p1;
+            Var_Set (IMPSRC, Var_Value(TARGET, gn, &p1), pgn);
+            efree(p1);
+        }
+        switch(gn->made) {
+            case BEINGMADE:
+                Error("Graph cycles through %s\n", gn->name);
+                gn->made = ERROR;
+                pgn->make = FALSE;
+                break;
+            case MADE:
+                if ((gn->type & OP_EXEC) == 0) {
+                    pgn->childMade = TRUE;
+                    Make_TimeStamp(pgn, gn);
+                }
+                break;
+            case UPTODATE:
+                if ((gn->type & OP_EXEC) == 0) {
+                    Make_TimeStamp(pgn, gn);
+                }
+                break;
+            default:
+                break;
+        }
     }
 
@@ -652 +653 @@
  *-----------------------------------------------------------------------
  * Compat_Run --
- *      Initialize this mode and start making.
+ *      Initialize this mode and start making.
  *
  * Results:
- *      None.
+ *      None.
  *
  * Side Effects:
- *      Guess what?
+ *      Guess what?
  *
  *-----------------------------------------------------------------------
@@ -664 +665 @@
 void
 Compat_Run(targs)
-    Lst           targs;    /* List of target nodes to re-create */
+    Lst           targs;    /* List of target nodes to re-create */
 {
-    char          *cp;      /* Pointer to string of shell meta-characters */
-    GNode         *gn = NULL;/* Current root target */
-    int           errors;   /* Number of targets not remade due to errors */
+    char          *cp;      /* Pointer to string of shell meta-characters */
+    GNode         *gn = NULL;/* Current root target */
+    int           errors;   /* Number of targets not remade due to errors */
 
     if (signal(SIGINT, SIG_IGN) != SIG_IGN) {
-        signal(SIGINT, CompatInterrupt);
+        signal(SIGINT, CompatInterrupt);
     }
     if (signal(SIGTERM, SIG_IGN) != SIG_IGN) {
-        signal(SIGTERM, CompatInterrupt);
+        signal(SIGTERM, CompatInterrupt);
     }
     #if !(defined(OS2) && defined(__IBMC__))
     if (signal(SIGHUP, SIG_IGN) != SIG_IGN) {
-        signal(SIGHUP, CompatInterrupt);
+        signal(SIGHUP, CompatInterrupt);
     }
     #endif
     #if !(defined(OS2) && defined(__IBMC__))
     if (signal(SIGQUIT, SIG_IGN) != SIG_IGN) {
-        signal(SIGQUIT, CompatInterrupt);
+        signal(SIGQUIT, CompatInterrupt);
     }
     #endif
 
     for (cp = "#=|^(){};&<>*?[]:$`\\\n"; *cp != '\0'; cp++) {
-        meta[(unsigned char) *cp] = 1;
+        meta[(unsigned char) *cp] = 1;
     }
     /*
@@ -701 +702 @@
      */
     if (!queryFlag) {
-        gn = Targ_FindNode(".BEGIN", TARG_NOCREATE);
-        if (gn != NILGNODE) {
-            Lst_ForEach(gn->commands, CompatRunCommand, (ClientData)gn);
+        gn = Targ_FindNode(".BEGIN", TARG_NOCREATE);
+        if (gn != NILGNODE) {
+            Lst_ForEach(gn->commands, CompatRunCommand, (ClientData)gn);
             if (gn->made == ERROR) {
                 printf("\n\nStop.\n");
                 exit(1);
             }
-        }
+        }
     }
 
@@ -715 +716 @@
      * it to create the thing. CompatMake will leave the 'made' field of gn
      * in one of several states:
-     *      UPTODATE        gn was already up-to-date
-     *      MADE            gn was recreated successfully
-     *      ERROR           An error occurred while gn was being created
-     *      ABORTED         gn was not remade because one of its inferiors
-     *                      could not be made due to errors.
+     *      UPTODATE        gn was already up-to-date
+     *      MADE            gn was recreated successfully
+     *      ERROR           An error occurred while gn was being created
+     *      ABORTED         gn was not remade because one of its inferiors
+     *                      could not be made due to errors.
      */
     errors = 0;
     while (!Lst_IsEmpty (targs)) {
-        gn = (GNode *) Lst_DeQueue (targs);
-        CompatMake (gn, gn);
-
-        if (gn->made == UPTODATE) {
-            printf ("`%s' is up to date.\n", gn->name);
-        } else if (gn->made == ABORTED) {
-            printf ("`%s' not remade because of errors.\n", gn->name);
-            errors += 1;
-        }
+        gn = (GNode *) Lst_DeQueue (targs);
+        CompatMake (gn, gn);
+
+        if (gn->made == UPTODATE) {
+            printf ("`%s' is up to date.\n", gn->name);
+        } else if (gn->made == ABORTED) {
+            printf ("`%s' not remade because of errors.\n", gn->name);
+            errors += 1;
+        }
     }
 
@@ -738 +739 @@
      */
     if (errors == 0) {
-        Lst_ForEach(ENDNode->commands, CompatRunCommand, (ClientData)gn);
+        Lst_ForEach(ENDNode->commands, CompatRunCommand, (ClientData)gn);
     }
 }

trunk/src/kmk/cond.c

@@ -18 +18 @@
  * 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
@@ -39 +39 @@
 #ifndef lint
 #if 0
-static char sccsid[] = "@(#)cond.c      8.2 (Berkeley) 1/2/94";
+static char sccsid[] = "@(#)cond.c      8.2 (Berkeley) 1/2/94";
 #else
 static const char rcsid[] =
   "$FreeBSD: src/usr.bin/make/cond.c,v 1.12 1999/09/11 13:08:01 hoek Exp $";
 #endif
+#define KLIBFILEDEF rcsid
 #endif /* not lint */
 
 /*-
  * cond.c --
- *      Functions to handle conditionals in a makefile.
+ *      Functions to handle conditionals in a makefile.
  *
  * Interface:
- *      Cond_Eval       Evaluate the conditional in the passed line.
+ *      Cond_Eval       Evaluate the conditional in the passed line.
  *
  */
@@ -64 +65 @@
 /*
  * The parsing of conditional expressions is based on this grammar:
- *      E -> F || E
- *      E -> F
- *      F -> T && F
- *      F -> T
- *      T -> defined(variable)
- *      T -> make(target)
- *      T -> exists(file)
- *      T -> empty(varspec)
- *      T -> target(name)
- *      T -> symbol
- *      T -> $(varspec) op value
- *      T -> $(varspec) == "string"
- *      T -> $(varspec) != "string"
- *      T -> ( E )
- *      T -> ! T
- *      op -> == | != | > | < | >= | <=
+ *      E -> F || E
+ *      E -> F
+ *      F -> T && F
+ *      F -> T
+ *      T -> defined(variable)
+ *      T -> make(target)
+ *      T -> exists(file)
+ *      T -> empty(varspec)
+ *      T -> target(name)
+ *      T -> symbol
+ *      T -> $(varspec) op value
+ *      T -> $(varspec) == "string"
+ *      T -> $(varspec) != "string"
+ *      T -> ( E )
+ *      T -> ! T
+ *      op -> == | != | > | < | >= | <=
  *
  * 'symbol' is some other symbol to which the default function (condDefProc)
@@ -114 +115 @@
 
 static struct If {
-    char        *form;        /* Form of if */
-    int         formlen;      /* Length of form */
-    Boolean     doNot;        /* TRUE if default function should be negated */
-    Boolean     (*defProc) __P((int, char *)); /* Default function to apply */
+    char        *form;        /* Form of if */
+    int         formlen;      /* Length of form */
+    Boolean     doNot;        /* TRUE if default function should be negated */
+    Boolean     (*defProc) __P((int, char *)); /* Default function to apply */
 } ifs[] = {
-    { "ifdef",    5,      FALSE,  CondDoDefined },
-    { "ifndef",   6,      TRUE,   CondDoDefined },
-    { "ifmake",   6,      FALSE,  CondDoMake },
-    { "ifnmake",  7,      TRUE,   CondDoMake },
-    { "if",       2,      FALSE,  CondDoDefined },
-    { NULL,       0,      FALSE,  NULL }
+    { "ifdef",    5,      FALSE,  CondDoDefined },
+    { "ifndef",   6,      TRUE,   CondDoDefined },
+    { "ifmake",   6,      FALSE,  CondDoMake },
+    { "ifnmake",  7,      TRUE,   CondDoMake },
+    { "if",       2,      FALSE,  CondDoDefined },
+    { NULL,       0,      FALSE,  NULL }
 };
 
-static Boolean    condInvert;           /* Invert the default function */
-static Boolean    (*condDefProc)        /* Default function to apply */
-                    __P((int, char *));
-static char       *condExpr;            /* The expression to parse */
-static Token      condPushBack=None;    /* Single push-back token used in
-                                         * parsing */
-
-#define MAXIF           30        /* greatest depth of #if'ing */
-
-static Boolean    condStack[MAXIF];     /* Stack of conditionals's values */
-static int        condTop = MAXIF;      /* Top-most conditional */
-static int        skipIfLevel=0;        /* Depth of skipped conditionals */
-static Boolean    skipLine = FALSE;     /* Whether the parse module is skipping
-                                         * lines */
+static Boolean    condInvert;           /* Invert the default function */
+static Boolean    (*condDefProc)        /* Default function to apply */
+                    __P((int, char *));
+static char       *condExpr;            /* The expression to parse */
+static Token      condPushBack=None;    /* Single push-back token used in
+                                         * parsing */
+
+#define MAXIF           30        /* greatest depth of #if'ing */
+
+static Boolean    condStack[MAXIF];     /* Stack of conditionals's values */
+static int        condTop = MAXIF;      /* Top-most conditional */
+static int        skipIfLevel=0;        /* Depth of skipped conditionals */
+static Boolean    skipLine = FALSE;     /* Whether the parse module is skipping
+                                         * lines */
 
 /*-
  *-----------------------------------------------------------------------
  * CondPushBack --
- *      Push back the most recent token read. We only need one level of
- *      this, so the thing is just stored in 'condPushback'.
+ *      Push back the most recent token read. We only need one level of
+ *      this, so the thing is just stored in 'condPushback'.
  *
  * Results:
- *      None.
+ *      None.
  *
  * Side Effects:
- *      condPushback is overwritten.
+ *      condPushback is overwritten.
  *
  *-----------------------------------------------------------------------
@@ -158 +159 @@
 static void
 CondPushBack (t)
-    Token         t;    /* Token to push back into the "stream" */
+    Token         t;    /* Token to push back into the "stream" */
 {
     condPushBack = t;
@@ -167 +168 @@
  *-----------------------------------------------------------------------
  * CondGetArg --
- *      Find the argument of a built-in function.
+ *      Find the argument of a built-in function.
  *
  * Results:
- *      The length of the argument and the address of the argument.
+ *      The length of the argument and the address of the argument.
  *
  * Side Effects:
- *      The pointer is set to point to the closing parenthesis of the
- *      function call.
+ *      The pointer is set to point to the closing parenthesis of the
+ *      function call.
  *
  *-----------------------------------------------------------------------
@@ -180 +181 @@
 static int
 CondGetArg (linePtr, argPtr, func, parens)
-    char          **linePtr;
-    char          **argPtr;
-    char          *func;
-    Boolean       parens;       /* TRUE if arg should be bounded by parens */
+    char          **linePtr;
+    char          **argPtr;
+    char          *func;
+    Boolean       parens;       /* TRUE if arg should be bounded by parens */
 {
     register char *cp;
-    int           argLen;
+    int           argLen;
     register Buffer buf;
 
     cp = *linePtr;
     if (parens) {
-        while (*cp != '(' && *cp != '\0') {
-            cp++;
-        }
-        if (*cp == '(') {
-            cp++;
-        }
+        while (*cp != '(' && *cp != '\0') {
+            cp++;
+        }
+        if (*cp == '(') {
+            cp++;
+        }
     }
 
     if (*cp == '\0') {
-        /*
-         * No arguments whatsoever. Because 'make' and 'defined' aren't really
-         * "reserved words", we don't print a message. I think this is better
-         * than hitting the user with a warning message every time s/he uses
-         * the word 'make' or 'defined' at the beginning of a symbol...
-         */
-        *argPtr = cp;
-        return (0);
+        /*
+         * No arguments whatsoever. Because 'make' and 'defined' aren't really
+         * "reserved words", we don't print a message. I think this is better
+         * than hitting the user with a warning message every time s/he uses
+         * the word 'make' or 'defined' at the beginning of a symbol...
+         */
+        *argPtr = cp;
+        return (0);
     }
 
     while (*cp == ' ' || *cp == '\t') {
-        cp++;
+        cp++;
     }
 
@@ -221 +222 @@
 
     while ((strchr(" \t)&|", *cp) == (char *)NULL) && (*cp != '\0')) {
-        if (*cp == '$') {
-            /*
-             * Parse the variable spec and install it as part of the argument
-             * if it's valid. We tell Var_Parse to complain on an undefined
-             * variable, so we don't do it too. Nor do we return an error,
-             * though perhaps we should...
-             */
-            char        *cp2;
-            int         len;
-            Boolean     doFree;
-
-            cp2 = Var_Parse(cp, VAR_CMD, TRUE, &len, &doFree);
-
-            Buf_AddBytes(buf, strlen(cp2), (Byte *)cp2);
-            if (doFree) {
-                efree(cp2);
-            }
-            cp += len;
-        } else {
-            Buf_AddByte(buf, (Byte)*cp);
-            cp++;
-        }
+        if (*cp == '$') {
+            /*
+             * Parse the variable spec and install it as part of the argument
+             * if it's valid. We tell Var_Parse to complain on an undefined
+             * variable, so we don't do it too. Nor do we return an error,
+             * though perhaps we should...
+             */
+            char        *cp2;
+            int         len;
+            Boolean     doFree;
+
+            cp2 = Var_Parse(cp, VAR_CMD, TRUE, &len, &doFree);
+
+            Buf_AddBytes(buf, strlen(cp2), (Byte *)cp2);
+            if (doFree) {
+                efree(cp2);
+            }
+            cp += len;
+        } else {
+            Buf_AddByte(buf, (Byte)*cp);
+            cp++;
+        }
     }
 
@@ -250 +251 @@
 
     while (*cp == ' ' || *cp == '\t') {
-        cp++;
+        cp++;
     }
     if (parens && *cp != ')') {
-        Parse_Error (PARSE_WARNING, "Missing closing parenthesis for %s()",
-                     func);
-        return (0);
+        Parse_Error (PARSE_WARNING, "Missing closing parenthesis for %s()",
+                     func);
+        return (0);
     } else if (parens) {
-        /*
-         * Advance pointer past close parenthesis.
-         */
-        cp++;
+        /*
+         * Advance pointer past close parenthesis.
+         */
+        cp++;
     }
 
@@ -271 +272 @@
  *-----------------------------------------------------------------------
  * CondDoDefined --
- *      Handle the 'defined' function for conditionals.
+ *      Handle the 'defined' function for conditionals.
  *
  * Results:
- *      TRUE if the given variable is defined.
+ *      TRUE if the given variable is defined.
  *
  * Side Effects:
- *      None.
+ *      None.
  *
  *-----------------------------------------------------------------------
@@ -283 +284 @@
 static Boolean
 CondDoDefined (argLen, arg)
-    int     argLen;
+    int     argLen;
     char    *arg;
 {
@@ -292 +293 @@
     arg[argLen] = '\0';
     if (Var_Value (arg, VAR_CMD, &p1) != (char *)NULL) {
-        result = TRUE;
+        result = TRUE;
     } else {
-        result = FALSE;
+        result = FALSE;
     }
     efree(p1);
@@ -305 +306 @@
  *-----------------------------------------------------------------------
  * CondStrMatch --
- *      Front-end for Str_Match so it returns 0 on match and non-zero
- *      on mismatch. Callback function for CondDoMake via Lst_Find
+ *      Front-end for Str_Match so it returns 0 on match and non-zero
+ *      on mismatch. Callback function for CondDoMake via Lst_Find
  *
  * Results:
- *      0 if string matches pattern
+ *      0 if string matches pattern
  *
  * Side Effects:
- *      None
+ *      None
  *
  *-----------------------------------------------------------------------
@@ -328 +329 @@
  *-----------------------------------------------------------------------
  * CondDoMake --
- *      Handle the 'make' function for conditionals.
+ *      Handle the 'make' function for conditionals.
  *
  * Results:
- *      TRUE if the given target is being made.
+ *      TRUE if the given target is being made.
  *
  * Side Effects:
- *      None.
+ *      None.
  *
  *-----------------------------------------------------------------------
@@ -340 +341 @@
 static Boolean
 CondDoMake (argLen, arg)
-    int     argLen;
+    int     argLen;
     char    *arg;
 {
@@ -348 +349 @@
     arg[argLen] = '\0';
     if (Lst_Find (create, (ClientData)arg, CondStrMatch) == NILLNODE) {
-        result = FALSE;
+        result = FALSE;
     } else {
-        result = TRUE;
+        result = TRUE;
     }
     arg[argLen] = savec;
@@ -360 +361 @@
  *-----------------------------------------------------------------------
  * CondDoExists --
- *      See if the given file exists.
+ *      See if the given file exists.
  *
  * Results:
- *      TRUE if the file exists and FALSE if it does not.
+ *      TRUE if the file exists and FALSE if it does not.
  *
  * Side Effects:
- *      None.
+ *      None.
  *
  *-----------------------------------------------------------------------
@@ -372 +373 @@
 static Boolean
 CondDoExists (argLen, arg)
-    int     argLen;
+    int     argLen;
     char    *arg;
 {
@@ -382 +383 @@
     path = Dir_FindFile(arg, dirSearchPath);
     if (path != (char *)NULL) {
-        result = TRUE;
-        efree(path);
+        result = TRUE;
+        efree(path);
     } else {
-        result = FALSE;
+        result = FALSE;
     }
     arg[argLen] = savec;
@@ -395 +396 @@
  *-----------------------------------------------------------------------
  * CondDoTarget --
- *      See if the given node exists and is an actual target.
+ *      See if the given node exists and is an actual target.
  *
  * Results:
- *      TRUE if the node exists as a target and FALSE if it does not.
+ *      TRUE if the node exists as a target and FALSE if it does not.
  *
  * Side Effects:
- *      None.
+ *      None.
  *
  *-----------------------------------------------------------------------
@@ -407 +408 @@
 static Boolean
 CondDoTarget (argLen, arg)
-    int     argLen;
+    int     argLen;
     char    *arg;
 {
@@ -417 +418 @@
     gn = Targ_FindNode(arg, TARG_NOCREATE);
     if ((gn != NILGNODE) && !OP_NOP(gn->type)) {
-        result = TRUE;
+        result = TRUE;
     } else {
-        result = FALSE;
+        result = FALSE;
     }
     arg[argLen] = savec;
@@ -430 +431 @@
  *-----------------------------------------------------------------------
  * CondCvtArg --
- *      Convert the given number into a double. If the number begins
- *      with 0x, it is interpreted as a hexadecimal integer
- *      and converted to a double from there. All other strings just have
- *      strtod called on them.
+ *      Convert the given number into a double. If the number begins
+ *      with 0x, it is interpreted as a hexadecimal integer
+ *      and converted to a double from there. All other strings just have
+ *      strtod called on them.
  *
  * Results:
- *      Sets 'value' to double value of string.
- *      Returns address of the first character after the last valid
- *      character of the converted number.
+ *      Sets 'value' to double value of string.
+ *      Returns address of the first character after the last valid
+ *      character of the converted number.
  *
  * Side Effects:
- *      Can change 'value' even if string is not a valid number.
+ *      Can change 'value' even if string is not a valid number.
  *
  *
@@ -448 +449 @@
 static char *
 CondCvtArg(str, value)
-    register char       *str;
-    double              *value;
+    register char       *str;
+    double              *value;
 {
     if ((*str == '0') && (str[1] == 'x')) {
-        register long i;
-
-        for (str += 2, i = 0; ; str++) {
-            int x;
-            if (isdigit((unsigned char) *str))
-                x  = *str - '0';
-            else if (isxdigit((unsigned char) *str))
-                x = 10 + *str - isupper((unsigned char) *str) ? 'A' : 'a';
-            else {
-                *value = (double) i;
-                return str;
-            }
-            i = (i << 4) + x;
-        }
+        register long i;
+
+        for (str += 2, i = 0; ; str++) {
+            int x;
+            if (isdigit((unsigned char) *str))
+                x  = *str - '0';
+            else if (isxdigit((unsigned char) *str))
+                x = 10 + *str - isupper((unsigned char) *str) ? 'A' : 'a';
+            else {
+                *value = (double) i;
+                return str;
+            }
+            i = (i << 4) + x;
+        }
     }
     else {
-        char *eptr;
-        *value = strtod(str, &eptr);
-        return eptr;
+        char *eptr;
+        *value = strtod(str, &eptr);
+        return eptr;
     }
 }
@@ -478 +479 @@
  *-----------------------------------------------------------------------
  * CondToken --
- *      Return the next token from the input.
+ *      Return the next token from the input.
  *
  * Results:
- *      A Token for the next lexical token in the stream.
+ *      A Token for the next lexical token in the stream.
  *
  * Side Effects:
- *      condPushback will be set back to None if it is used.
+ *      condPushback will be set back to None if it is used.
  *
  *-----------------------------------------------------------------------
@@ -492 +493 @@
     Boolean doEval;
 {
-    Token         t;
+    Token         t;
 
     if (condPushBack == None) {
-        while (*condExpr == ' ' || *condExpr == '\t') {
-            condExpr++;
-        }
-        switch (*condExpr) {
-            case '(':
-                t = LParen;
-                condExpr++;
-                break;
-            case ')':
-                t = RParen;
-                condExpr++;
-                break;
-            case '|':
-                if (condExpr[1] == '|') {
-                    condExpr++;
-                }
-                condExpr++;
-                t = Or;
-                break;
-            case '&':
-                if (condExpr[1] == '&') {
-                    condExpr++;
-                }
-                condExpr++;
-                t = And;
-                break;
-            case '!':
-                t = Not;
-                condExpr++;
-                break;
-            case '\n':
-            case '\0':
-                t = EndOfFile;
-                break;
+        while (*condExpr == ' ' || *condExpr == '\t') {
+            condExpr++;
+        }
+        switch (*condExpr) {
+            case '(':
+                t = LParen;
+                condExpr++;
+                break;
+            case ')':
+                t = RParen;
+                condExpr++;
+                break;
+            case '|':
+                if (condExpr[1] == '|') {
+                    condExpr++;
+                }
+                condExpr++;
+                t = Or;
+                break;
+            case '&':
+                if (condExpr[1] == '&') {
+                    condExpr++;
+                }
+                condExpr++;
+                t = And;
+                break;
+            case '!':
+                t = Not;
+                condExpr++;
+                break;
+            case '\n':
+            case '\0':
+                t = EndOfFile;
+                break;
 
             #ifdef NMAKE
             case '[':
                 /* @todo execute this command!!! */
-                Parse_Error(PARSE_WARNING, "Unsupported NMAKE construct ([])");
+                Parse_Error(PARSE_WARNING, "Unsupported NMAKE construct ([])");
                 t = False;
                 condExpr += strlen(condExpr);
@@ -543 +544 @@
             case '"':
             #endif
-            case '$': {
-                char    *lhs;
-                char    *rhs;
-                char    *op;
-                int     varSpecLen;
-                Boolean doFree;
+            case '$': {
+                char    *lhs;
+                char    *rhs;
+                char    *op;
+                int     varSpecLen;
+                Boolean doFree;
                 #ifdef NMAKE
                 Boolean fQuoted = (*condExpr == '"');
@@ -555 +556 @@
                 #endif
 
-                /*
-                 * Parse the variable spec and skip over it, saving its
-                 * value in lhs.
-                 */
-                t = Err;
-                lhs = Var_Parse(condExpr, VAR_CMD, doEval,&varSpecLen,&doFree);
+                /*
+                 * Parse the variable spec and skip over it, saving its
+                 * value in lhs.
+                 */
+                t = Err;
+                lhs = Var_Parse(condExpr, VAR_CMD, doEval,&varSpecLen,&doFree);
                 #ifdef NMAKE
                 if (lhs == var_Error)
@@ -568 +569 @@
                 }
                 #else
-                if (lhs == var_Error) {
-                    /*
-                     * Even if !doEval, we still report syntax errors, which
-                     * is what getting var_Error back with !doEval means.
-                     */
-                    return(Err);
-                }
+                if (lhs == var_Error) {
+                    /*
+                     * Even if !doEval, we still report syntax errors, which
+                     * is what getting var_Error back with !doEval means.
+                     */
+                    return(Err);
+                }
                 #endif
-                condExpr += varSpecLen;
+                condExpr += varSpecLen;
 
                 #ifdef NMAKE
@@ -583 +584 @@
                     )
                 #else
-                if (!isspace((unsigned char) *condExpr) &&
-                    strchr("!=><", *condExpr) == NULL)
+                if (!isspace((unsigned char) *condExpr) &&
+                    strchr("!=><", *condExpr) == NULL)
                 #endif
                 {
-                    Buffer buf;
-                    char *cp;
-
-                    buf = Buf_Init(0);
-
-                    for (cp = lhs; *cp; cp++)
-                        Buf_AddByte(buf, (Byte)*cp);
-
-                    if (doFree)
-                        efree(lhs);
+                    Buffer buf;
+                    char *cp;
+
+                    buf = Buf_Init(0);
+
+                    for (cp = lhs; *cp; cp++)
+                        Buf_AddByte(buf, (Byte)*cp);
+
+                    if (doFree)
+                        efree(lhs);
 
                     #ifdef NMAKE
                     //@todo entirely support escaped quotes and such nitty pick.
-                    for (;*condExpr && (fQuoted ? *condExpr != '"' : !isspace((unsigned char) *condExpr)); condExpr++)
-                        Buf_AddByte(buf, (Byte)*condExpr);
+                    for (;*condExpr && (fQuoted ? *condExpr != '"' : !isspace((unsigned char) *condExpr)); condExpr++)
+                        Buf_AddByte(buf, (Byte)*condExpr);
                     if (fQuoted && *condExpr == '"')
                         condExpr++;
                     #else
-                    for (;*condExpr && !isspace((unsigned char) *condExpr); condExpr++)
-                        Buf_AddByte(buf, (Byte)*condExpr);
+                    for (;*condExpr && !isspace((unsigned char) *condExpr); condExpr++)
+                        Buf_AddByte(buf, (Byte)*condExpr);
                     #endif
 
-                    Buf_AddByte(buf, (Byte)'\0');
-                    lhs = (char *)Buf_GetAll(buf, &varSpecLen);
-                    Buf_Destroy(buf, FALSE);
-
-                    doFree = TRUE;
-                }
-
-                /*
-                 * Skip whitespace to get to the operator
-                 */
+                    Buf_AddByte(buf, (Byte)'\0');
+                    lhs = (char *)Buf_GetAll(buf, &varSpecLen);
+                    Buf_Destroy(buf, FALSE);
+
+                    doFree = TRUE;
+                }
+
+                /*
+                 * Skip whitespace to get to the operator
+                 */
                 #ifdef NMAKE
                 if (fQuoted && *condExpr == '"')
                     condExpr++;
                 #endif
-                while (isspace((unsigned char) *condExpr))
-                    condExpr++;
-
-                /*
-                 * Make sure the operator is a valid one. If it isn't a
-                 * known relational operator, pretend we got a
-                 * != 0 comparison.
-                 */
-                op = condExpr;
-                switch (*condExpr) {
-                    case '!':
-                    case '=':
-                    case '<':
-                    case '>':
-                        if (condExpr[1] == '=') {
-                            condExpr += 2;
-                        } else {
-                            condExpr += 1;
-                        }
-                        break;
-                    default:
-                        op = "!=";
-                        rhs = "0";
-
-                        goto do_compare;
-                }
-                while (isspace((unsigned char) *condExpr)) {
-                    condExpr++;
-                }
-                if (*condExpr == '\0') {
-                    Parse_Error(PARSE_WARNING,
-                                "Missing right-hand-side of operator");
-                    goto error;
-                }
-                rhs = condExpr;
+                while (isspace((unsigned char) *condExpr))
+                    condExpr++;
+
+                /*
+                 * Make sure the operator is a valid one. If it isn't a
+                 * known relational operator, pretend we got a
+                 * != 0 comparison.
+                 */
+                op = condExpr;
+                switch (*condExpr) {
+                    case '!':
+                    case '=':
+                    case '<':
+                    case '>':
+                        if (condExpr[1] == '=') {
+                            condExpr += 2;
+                        } else {
+                            condExpr += 1;
+                        }
+                        break;
+                    default:
+                        op = "!=";
+                        rhs = "0";
+
+                        goto do_compare;
+                }
+                while (isspace((unsigned char) *condExpr)) {
+                    condExpr++;
+                }
+                if (*condExpr == '\0') {
+                    Parse_Error(PARSE_WARNING,
+                                "Missing right-hand-side of operator");
+                    goto error;
+                }
+                rhs = condExpr;
 do_compare:
-                if (*rhs == '"') {
-                    /*
-                     * Doing a string comparison. Only allow == and != for
-                     * operators.
-                     */
-                    char    *string;
-                    char    *cp, *cp2;
-                    int     qt;
-                    Buffer  buf;
+                if (*rhs == '"') {
+                    /*
+                     * Doing a string comparison. Only allow == and != for
+                     * operators.
+                     */
+                    char    *string;
+                    char    *cp, *cp2;
+                    int     qt;
+                    Buffer  buf;
 
 do_string_compare:
-                    if (((*op != '!') && (*op != '=')) || (op[1] != '=')) {
-                        Parse_Error(PARSE_WARNING,
-                "String comparison operator should be either == or !=");
-                        goto error;
-                    }
-
-                    buf = Buf_Init(0);
-                    qt = *rhs == '"' ? 1 : 0;
-
-                    for (cp = &rhs[qt];
-                         ((qt && (*cp != '"')) ||
-                          (!qt && strchr(" \t)", *cp) == NULL)) &&
-                         (*cp != '\0'); cp++) {
-                        if ((*cp == '\\') && (cp[1] != '\0')) {
-                            /*
-                             * Backslash escapes things -- skip over next
-                             * character, if it exists.
-                             */
-                            cp++;
-                            Buf_AddByte(buf, (Byte)*cp);
-                        } else if (*cp == '$') {
-                            int len;
-                            Boolean freeIt;
-
-                            cp2 = Var_Parse(cp, VAR_CMD, doEval,&len, &freeIt);
-                            if (cp2 != var_Error) {
-                                Buf_AddBytes(buf, strlen(cp2), (Byte *)cp2);
-                                if (freeIt) {
-                                    efree(cp2);
-                                }
-                                cp += len - 1;
-                            } else {
-                                Buf_AddByte(buf, (Byte)*cp);
-                            }
-                        } else {
-                            Buf_AddByte(buf, (Byte)*cp);
-                        }
-                    }
-
-                    Buf_AddByte(buf, (Byte)0);
-
-                    string = (char *)Buf_GetAll(buf, (int *)0);
-                    Buf_Destroy(buf, FALSE);
-
-                    if (DEBUG(COND)) {
-                        printf("lhs = \"%s\", rhs = \"%s\", op = %.2s\n",
-                               lhs, string, op);
-                    }
-                    /*
-                     * Null-terminate rhs and perform the comparison.
-                     * t is set to the result.
-                     */
-                    if (*op == '=') {
-                        t = strcmp(lhs, string) ? False : True;
-                    } else {
-                        t = strcmp(lhs, string) ? True : False;
-                    }
-                    efree(string);
-                    if (rhs == condExpr) {
-                        if (!qt && *cp == ')')
-                            condExpr = cp;
-                        else
-                            condExpr = cp + 1;
-                    }
-                } else {
-                    /*
-                     * rhs is either a float or an integer. Convert both the
-                     * lhs and the rhs to a double and compare the two.
-                     */
-                    double      left, right;
-                    char        *string;
-
-                    if (*CondCvtArg(lhs, &left) != '\0')
-                        goto do_string_compare;
-                    if (*rhs == '$') {
-                        int     len;
-                        Boolean freeIt;
-
-                        string = Var_Parse(rhs, VAR_CMD, doEval,&len,&freeIt);
-                        if (string == var_Error) {
-                            right = 0.0;
-                        } else {
-                            if (*CondCvtArg(string, &right) != '\0') {
-                                if (freeIt)
-                                    efree(string);
-                                goto do_string_compare;
-                            }
-                            if (freeIt)
-                                efree(string);
-                            if (rhs == condExpr)
-                                condExpr += len;
-                        }
-                    } else {
-                        char *c = CondCvtArg(rhs, &right);
-                        if (*c != '\0' && !isspace(*c))
-                            goto do_string_compare;
-                        if (rhs == condExpr) {
-                            /*
-                             * Skip over the right-hand side
-                             */
-                            while(!isspace((unsigned char) *condExpr) &&
-                                  (*condExpr != '\0')) {
-                                condExpr++;
-                            }
-                        }
-                    }
-
-                    if (DEBUG(COND)) {
-                        printf("left = %f, right = %f, op = %.2s\n", left,
-                               right, op);
-                    }
-                    switch(op[0]) {
-                    case '!':
-                        if (op[1] != '=') {
-                            Parse_Error(PARSE_WARNING,
-                                        "Unknown operator");
-                            goto error;
-                        }
-                        t = (left != right ? True : False);
-                        break;
-                    case '=':
-                        if (op[1] != '=') {
-                            Parse_Error(PARSE_WARNING,
-                                        "Unknown operator");
-                            goto error;
-                        }
-                        t = (left == right ? True : False);
-                        break;
-                    case '<':
-                        if (op[1] == '=') {
-                            t = (left <= right ? True : False);
-                        } else {
-                            t = (left < right ? True : False);
-                        }
-                        break;
-                    case '>':
-                        if (op[1] == '=') {
-                            t = (left >= right ? True : False);
-                        } else {
-                            t = (left > right ? True : False);
-                        }
-                        break;
-                    }
-                }
+                    if (((*op != '!') && (*op != '=')) || (op[1] != '=')) {
+                        Parse_Error(PARSE_WARNING,
+                "String comparison operator should be either == or !=");
+                        goto error;
+                    }
+
+                    buf = Buf_Init(0);
+                    qt = *rhs == '"' ? 1 : 0;
+
+                    for (cp = &rhs[qt];
+                         ((qt && (*cp != '"')) ||
+                          (!qt && strchr(" \t)", *cp) == NULL)) &&
+                         (*cp != '\0'); cp++) {
+                        if ((*cp == '\\') && (cp[1] != '\0')) {
+                            /*
+                             * Backslash escapes things -- skip over next
+                             * character, if it exists.
+                             */
+                            cp++;
+                            Buf_AddByte(buf, (Byte)*cp);
+                        } else if (*cp == '$') {
+                            int len;
+                            Boolean freeIt;
+
+                            cp2 = Var_Parse(cp, VAR_CMD, doEval,&len, &freeIt);
+                            if (cp2 != var_Error) {
+                                Buf_AddBytes(buf, strlen(cp2), (Byte *)cp2);
+                                if (freeIt) {
+                                    efree(cp2);
+                                }
+                                cp += len - 1;
+                            } else {
+                                Buf_AddByte(buf, (Byte)*cp);
+                            }
+                        } else {
+                            Buf_AddByte(buf, (Byte)*cp);
+                        }
+                    }
+
+                    Buf_AddByte(buf, (Byte)0);
+
+                    string = (char *)Buf_GetAll(buf, (int *)0);
+                    Buf_Destroy(buf, FALSE);
+
+                    if (DEBUG(COND)) {
+                        printf("lhs = \"%s\", rhs = \"%s\", op = %.2s\n",
+                               lhs, string, op);
+                    }
+                    /*
+                     * Null-terminate rhs and perform the comparison.
+                     * t is set to the result.
+                     */
+                    if (*op == '=') {
+                        t = strcmp(lhs, string) ? False : True;
+                    } else {
+                        t = strcmp(lhs, string) ? True : False;
+                    }
+                    efree(string);
+                    if (rhs == condExpr) {
+                        if (!qt && *cp == ')')
+                            condExpr = cp;
+                        else
+                            condExpr = cp + 1;
+                    }
+                } else {
+                    /*
+                     * rhs is either a float or an integer. Convert both the
+                     * lhs and the rhs to a double and compare the two.
+                     */
+                    double      left, right;
+                    char        *string;
+
+                    if (*CondCvtArg(lhs, &left) != '\0')
+                        goto do_string_compare;
+                    if (*rhs == '$') {
+                        int     len;
+                        Boolean freeIt;
+
+                        string = Var_Parse(rhs, VAR_CMD, doEval,&len,&freeIt);
+                        if (string == var_Error) {
+                            right = 0.0;
+                        } else {
+                            if (*CondCvtArg(string, &right) != '\0') {
+                                if (freeIt)
+                                    efree(string);
+                                goto do_string_compare;
+                            }
+                            if (freeIt)
+                                efree(string);
+                            if (rhs == condExpr)
+                                condExpr += len;
+                        }
+                    } else {
+                        char *c = CondCvtArg(rhs, &right);
+                        if (*c != '\0' && !isspace(*c))
+                            goto do_string_compare;
+                        if (rhs == condExpr) {
+                            /*
+                             * Skip over the right-hand side
+                             */
+                            while(!isspace((unsigned char) *condExpr) &&
+                                  (*condExpr != '\0')) {
+                                condExpr++;
+                            }
+                        }
+                    }
+
+                    if (DEBUG(COND)) {
+                        printf("left = %f, right = %f, op = %.2s\n", left,
+                               right, op);
+                    }
+                    switch(op[0]) {
+                    case '!':
+                        if (op[1] != '=') {
+                            Parse_Error(PARSE_WARNING,
+                                        "Unknown operator");
+                            goto error;
+                        }
+                        t = (left != right ? True : False);
+                        break;
+                    case '=':
+                        if (op[1] != '=') {
+                            Parse_Error(PARSE_WARNING,
+                                        "Unknown operator");
+                            goto error;
+                        }
+                        t = (left == right ? True : False);
+                        break;
+                    case '<':
+                        if (op[1] == '=') {
+                            t = (left <= right ? True : False);
+                        } else {
+                            t = (left < right ? True : False);
+                        }
+                        break;
+                    case '>':
+                        if (op[1] == '=') {
+                            t = (left >= right ? True : False);
+                        } else {
+                            t = (left > right ? True : False);
+                        }
+                        break;
+                    }
+                }
 error:
-                if (doFree)
-                    efree(lhs);
-                break;
-            }
-            default: {
-                Boolean (*evalProc) __P((int, char *));
-                Boolean invert = FALSE;
-                char    *arg;
-                int     arglen;
-
-                if (strncmp (condExpr, "defined", 7) == 0) {
-                    /*
-                     * Use CondDoDefined to evaluate the argument and
-                     * CondGetArg to extract the argument from the 'function
-                     * call'.
-                     */
-                    evalProc = CondDoDefined;
-                    condExpr += 7;
-                    arglen = CondGetArg (&condExpr, &arg, "defined", TRUE);
-                    if (arglen == 0) {
-                        condExpr -= 7;
-                        goto use_default;
-                    }
-                } else if (strncmp (condExpr, "make", 4) == 0) {
-                    /*
-                     * Use CondDoMake to evaluate the argument and
-                     * CondGetArg to extract the argument from the 'function
-                     * call'.
-                     */
-                    evalProc = CondDoMake;
-                    condExpr += 4;
-                    arglen = CondGetArg (&condExpr, &arg, "make", TRUE);
-                    if (arglen == 0) {
-                        condExpr -= 4;
-                        goto use_default;
-                    }
-                } else if (strncmp (condExpr, "exists", 6) == 0) {
-                    /*
-                     * Use CondDoExists to evaluate the argument and
-                     * CondGetArg to extract the argument from the
-                     * 'function call'.
-                     */
-                    evalProc = CondDoExists;
-                    condExpr += 6;
-                    arglen = CondGetArg(&condExpr, &arg, "exists", TRUE);
-                    if (arglen == 0) {
-                        condExpr -= 6;
-                        goto use_default;
-                    }
-                } else if (strncmp(condExpr, "empty", 5) == 0) {
-                    /*
-                     * Use Var_Parse to parse the spec in parens and return
-                     * True if the resulting string is empty.
-                     */
-                    int     length;
-                    Boolean doFree;
-                    char    *val;
-
-                    condExpr += 5;
-
-                    for (arglen = 0;
-                         condExpr[arglen] != '(' && condExpr[arglen] != '\0';
-                         arglen += 1)
-                        continue;
-
-                    if (condExpr[arglen] != '\0') {
-                        val = Var_Parse(&condExpr[arglen - 1], VAR_CMD,
-                                        doEval, &length, &doFree);
-                        if (val == var_Error) {
-                            t = Err;
-                        } else {
-                            /*
-                             * A variable is empty when it just contains
-                             * spaces... 4/15/92, christos
-                             */
-                            char *p;
-                            for (p = val; *p && isspace((unsigned char)*p); p++)
-                                continue;
-                            t = (*p == '\0') ? True : False;
-                        }
-                        if (doFree) {
-                            efree(val);
-                        }
-                        /*
-                         * Advance condExpr to beyond the closing ). Note that
-                         * we subtract one from arglen + length b/c length
-                         * is calculated from condExpr[arglen - 1].
-                         */
-                        condExpr += arglen + length - 1;
-                    } else {
-                        condExpr -= 5;
-                        goto use_default;
-                    }
-                    break;
-                } else if (strncmp (condExpr, "target", 6) == 0) {
-                    /*
-                     * Use CondDoTarget to evaluate the argument and
-                     * CondGetArg to extract the argument from the
-                     * 'function call'.
-                     */
-                    evalProc = CondDoTarget;
-                    condExpr += 6;
-                    arglen = CondGetArg(&condExpr, &arg, "target", TRUE);
-                    if (arglen == 0) {
-                        condExpr -= 6;
-                        goto use_default;
-                    }
-                } else {
-                    /*
-                     * The symbol is itself the argument to the default
-                     * function. We advance condExpr to the end of the symbol
-                     * by hand (the next whitespace, closing paren or
-                     * binary operator) and set to invert the evaluation
-                     * function if condInvert is TRUE.
-                     */
-                use_default:
-                    invert = condInvert;
-                    evalProc = condDefProc;
-                    arglen = CondGetArg(&condExpr, &arg, "", FALSE);
-                }
-
-                /*
-                 * Evaluate the argument using the set function. If invert
-                 * is TRUE, we invert the sense of the function.
-                 */
-                t = (!doEval || (* evalProc) (arglen, arg) ?
-                     (invert ? False : True) :
-                     (invert ? True : False));
-                efree(arg);
-                break;
-            }
-        }
+                if (doFree)
+                    efree(lhs);
+                break;
+            }
+            default: {
+                Boolean (*evalProc) __P((int, char *));
+                Boolean invert = FALSE;
+                char    *arg;
+                int     arglen;
+
+                if (strncmp (condExpr, "defined", 7) == 0) {
+                    /*
+                     * Use CondDoDefined to evaluate the argument and
+                     * CondGetArg to extract the argument from the 'function
+                     * call'.
+                     */
+                    evalProc = CondDoDefined;
+                    condExpr += 7;
+                    arglen = CondGetArg (&condExpr, &arg, "defined", TRUE);
+                    if (arglen == 0) {
+                        condExpr -= 7;
+                        goto use_default;
+                    }
+                } else if (strncmp (condExpr, "make", 4) == 0) {
+                    /*
+                     * Use CondDoMake to evaluate the argument and
+                     * CondGetArg to extract the argument from the 'function
+                     * call'.
+                     */
+                    evalProc = CondDoMake;
+                    condExpr += 4;
+                    arglen = CondGetArg (&condExpr, &arg, "make", TRUE);
+                    if (arglen == 0) {
+                        condExpr -= 4;
+                        goto use_default;
+                    }
+                } else if (strncmp (condExpr, "exists", 6) == 0) {
+                    /*
+                     * Use CondDoExists to evaluate the argument and
+                     * CondGetArg to extract the argument from the
+                     * 'function call'.
+                     */
+                    evalProc = CondDoExists;
+                    condExpr += 6;
+                    arglen = CondGetArg(&condExpr, &arg, "exists", TRUE);
+                    if (arglen == 0) {
+                        condExpr -= 6;
+                        goto use_default;
+                    }
+                } else if (strncmp(condExpr, "empty", 5) == 0) {
+                    /*
+                     * Use Var_Parse to parse the spec in parens and return
+                     * True if the resulting string is empty.
+                     */
+                    int     length;
+                    Boolean doFree;
+                    char    *val;
+
+                    condExpr += 5;
+
+                    for (arglen = 0;
+                         condExpr[arglen] != '(' && condExpr[arglen] != '\0';
+                         arglen += 1)
+                        continue;
+
+                    if (condExpr[arglen] != '\0') {
+                        val = Var_Parse(&condExpr[arglen - 1], VAR_CMD,
+                                        doEval, &length, &doFree);
+                        if (val == var_Error) {
+                            t = Err;
+                        } else {
+                            /*
+                             * A variable is empty when it just contains
+                             * spaces... 4/15/92, christos
+                             */
+                            char *p;
+                            for (p = val; *p && isspace((unsigned char)*p); p++)
+                                continue;
+                            t = (*p == '\0') ? True : False;
+                        }
+                        if (doFree) {
+                            efree(val);
+                        }
+                        /*
+                         * Advance condExpr to beyond the closing ). Note that
+                         * we subtract one from arglen + length b/c length
+                         * is calculated from condExpr[arglen - 1].
+                         */
+                        condExpr += arglen + length - 1;
+                    } else {
+                        condExpr -= 5;
+                        goto use_default;
+                    }
+                    break;
+                } else if (strncmp (condExpr, "target", 6) == 0) {
+                    /*
+                     * Use CondDoTarget to evaluate the argument and
+                     * CondGetArg to extract the argument from the
+                     * 'function call'.
+                     */
+                    evalProc = CondDoTarget;
+                    condExpr += 6;
+                    arglen = CondGetArg(&condExpr, &arg, "target", TRUE);
+                    if (arglen == 0) {
+                        condExpr -= 6;
+                        goto use_default;
+                    }
+                } else {
+                    /*
+                     * The symbol is itself the argument to the default
+                     * function. We advance condExpr to the end of the symbol
+                     * by hand (the next whitespace, closing paren or
+                     * binary operator) and set to invert the evaluation
+                     * function if condInvert is TRUE.
+                     */
+                use_default:
+                    invert = condInvert;
+                    evalProc = condDefProc;
+                    arglen = CondGetArg(&condExpr, &arg, "", FALSE);
+                }
+
+                /*
+                 * Evaluate the argument using the set function. If invert
+                 * is TRUE, we invert the sense of the function.
+                 */
+                t = (!doEval || (* evalProc) (arglen, arg) ?
+                     (invert ? False : True) :
+                     (invert ? True : False));
+                efree(arg);
+                break;
+            }
+        }
     } else {
-        t = condPushBack;
-        condPushBack = None;
+        t = condPushBack;
+        condPushBack = None;
     }
     return (t);
@@ -958 +959 @@
  *-----------------------------------------------------------------------
  * CondT --
- *      Parse a single term in the expression. This consists of a terminal
- *      symbol or Not and a terminal symbol (not including the binary
- *      operators):
- *          T -> defined(variable) | make(target) | exists(file) | symbol
- *          T -> ! T | ( E )
+ *      Parse a single term in the expression. This consists of a terminal
+ *      symbol or Not and a terminal symbol (not including the binary
+ *      operators):
+ *          T -> defined(variable) | make(target) | exists(file) | symbol
+ *          T -> ! T | ( E )
  *
  * Results:
- *      True, False or Err.
+ *      True, False or Err.
  *
  * Side Effects:
- *      Tokens are consumed.
+ *      Tokens are consumed.
  *
  *-----------------------------------------------------------------------
@@ -981 +982 @@
 
     if (t == EndOfFile) {
-        /*
-         * If we reached the end of the expression, the expression
-         * is malformed...
-         */
-        t = Err;
+        /*
+         * If we reached the end of the expression, the expression
+         * is malformed...
+         */
+        t = Err;
     } else if (t == LParen) {
-        /*
-         * T -> ( E )
-         */
-        t = CondE(doEval);
-        if (t != Err) {
-            if (CondToken(doEval) != RParen) {
-                t = Err;
-            }
-        }
+        /*
+         * T -> ( E )
+         */
+        t = CondE(doEval);
+        if (t != Err) {
+            if (CondToken(doEval) != RParen) {
+                t = Err;
+            }
+        }
     } else if (t == Not) {
-        t = CondT(doEval);
-        if (t == True) {
-            t = False;
-        } else if (t == False) {
-            t = True;
-        }
+        t = CondT(doEval);
+        if (t == True) {
+            t = False;
+        } else if (t == False) {
+            t = True;
+        }
     }
     return (t);
@@ -1011 +1012 @@
  *-----------------------------------------------------------------------
  * CondF --
- *      Parse a conjunctive factor (nice name, wot?)
- *          F -> T && F | T
+ *      Parse a conjunctive factor (nice name, wot?)
+ *          F -> T && F | T
  *
  * Results:
- *      True, False or Err
+ *      True, False or Err
  *
  * Side Effects:
- *      Tokens are consumed.
+ *      Tokens are consumed.
  *
  *-----------------------------------------------------------------------
@@ -1030 +1031 @@
     l = CondT(doEval);
     if (l != Err) {
-        o = CondToken(doEval);
-
-        if (o == And) {
-            /*
-             * F -> T && F
-             *
-             * If T is False, the whole thing will be False, but we have to
-             * parse the r.h.s. anyway (to throw it away).
-             * If T is True, the result is the r.h.s., be it an Err or no.
-             */
-            if (l == True) {
-                l = CondF(doEval);
-            } else {
-                (void) CondF(FALSE);
-            }
-        } else {
-            /*
-             * F -> T
-             */
-            CondPushBack (o);
-        }
+        o = CondToken(doEval);
+
+        if (o == And) {
+            /*
+             * F -> T && F
+             *
+             * If T is False, the whole thing will be False, but we have to
+             * parse the r.h.s. anyway (to throw it away).
+             * If T is True, the result is the r.h.s., be it an Err or no.
+             */
+            if (l == True) {
+                l = CondF(doEval);
+            } else {
+                (void) CondF(FALSE);
+            }
+        } else {
+            /*
+             * F -> T
+             */
+            CondPushBack (o);
+        }
     }
     return (l);
@@ -1059 +1060 @@
  *-----------------------------------------------------------------------
  * CondE --
- *      Main expression production.
- *          E -> F || E | F
+ *      Main expression production.
+ *          E -> F || E | F
  *
  * Results:
- *      True, False or Err.
+ *      True, False or Err.
  *
  * Side Effects:
- *      Tokens are, of course, consumed.
+ *      Tokens are, of course, consumed.
  *
  *-----------------------------------------------------------------------
@@ -1078 +1079 @@
     l = CondF(doEval);
     if (l != Err) {
-        o = CondToken(doEval);
-
-        if (o == Or) {
-            /*
-             * E -> F || E
-             *
-             * A similar thing occurs for ||, except that here we make sure
-             * the l.h.s. is False before we bother to evaluate the r.h.s.
-             * Once again, if l is False, the result is the r.h.s. and once
-             * again if l is True, we parse the r.h.s. to throw it away.
-             */
-            if (l == False) {
-                l = CondE(doEval);
-            } else {
-                (void) CondE(FALSE);
-            }
-        } else {
-            /*
-             * E -> F
-             */
-            CondPushBack (o);
-        }
+        o = CondToken(doEval);
+
+        if (o == Or) {
+            /*
+             * E -> F || E
+             *
+             * A similar thing occurs for ||, except that here we make sure
+             * the l.h.s. is False before we bother to evaluate the r.h.s.
+             * Once again, if l is False, the result is the r.h.s. and once
+             * again if l is True, we parse the r.h.s. to throw it away.
+             */
+            if (l == False) {
+                l = CondE(doEval);
+            } else {
+                (void) CondE(FALSE);
+            }
+        } else {
+            /*
+             * E -> F
+             */
+            CondPushBack (o);
+        }
     }
     return (l);
@@ -1108 +1109 @@
  *-----------------------------------------------------------------------
  * Cond_Eval --
- *      Evaluate the conditional in the passed line. The line
- *      looks like this:
- *          #<cond-type> <expr>
- *      where <cond-type> is any of if, ifmake, ifnmake, ifdef,
- *      ifndef, elif, elifmake, elifnmake, elifdef, elifndef
- *      and <expr> consists of &&, ||, !, make(target), defined(variable)
- *      and parenthetical groupings thereof.
+ *      Evaluate the conditional in the passed line. The line
+ *      looks like this:
+ *          #<cond-type> <expr>
+ *      where <cond-type> is any of if, ifmake, ifnmake, ifdef,
+ *      ifndef, elif, elifmake, elifnmake, elifdef, elifndef
+ *      and <expr> consists of &&, ||, !, make(target), defined(variable)
+ *      and parenthetical groupings thereof.
  *
  * Results:
- *      COND_PARSE      if should parse lines after the conditional
- *      COND_SKIP       if should skip lines after the conditional
- *      COND_INVALID    if not a valid conditional.
+ *      COND_PARSE      if should parse lines after the conditional
+ *      COND_SKIP       if should skip lines after the conditional
+ *      COND_INVALID    if not a valid conditional.
  *
  * Side Effects:
- *      None.
+ *      None.
  *
  *-----------------------------------------------------------------------
@@ -1128 +1129 @@
 int
 Cond_Eval (line)
-    char            *line;    /* Line to parse */
+    char            *line;    /* Line to parse */
 {
-    struct If       *ifp;
-    Boolean         isElse;
-    Boolean         value = FALSE;
-    int             level;      /* Level at which to report errors. */
+    struct If       *ifp;
+    Boolean         isElse;
+    Boolean         value = FALSE;
+    int             level;      /* Level at which to report errors. */
 
     level = PARSE_FATAL;
 
     for (line++; *line == ' ' || *line == '\t'; line++) {
-        continue;
+        continue;
     }
 
@@ -1146 +1147 @@
      */
     if (line[0] == 'e' && line[1] == 'l') {
-        line += 2;
-        isElse = TRUE;
+        line += 2;
+        isElse = TRUE;
     } else if (strncmp (line, "endif", 5) == 0) {
-        /*
-         * End of a conditional section. If skipIfLevel is non-zero, that
-         * conditional was skipped, so lines following it should also be
-         * skipped. Hence, we return COND_SKIP. Otherwise, the conditional
-         * was read so succeeding lines should be parsed (think about it...)
-         * so we return COND_PARSE, unless this endif isn't paired with
-         * a decent if.
-         */
-        if (skipIfLevel != 0) {
-            skipIfLevel -= 1;
-            return (COND_SKIP);
-        } else {
-            if (condTop == MAXIF) {
-                Parse_Error (level, "if-less endif");
-                return (COND_INVALID);
-            } else {
-                skipLine = FALSE;
-                condTop += 1;
-                return (COND_PARSE);
-            }
-        }
+        /*
+         * End of a conditional section. If skipIfLevel is non-zero, that
+         * conditional was skipped, so lines following it should also be
+         * skipped. Hence, we return COND_SKIP. Otherwise, the conditional
+         * was read so succeeding lines should be parsed (think about it...)
+         * so we return COND_PARSE, unless this endif isn't paired with
+         * a decent if.
+         */
+        if (skipIfLevel != 0) {
+            skipIfLevel -= 1;
+            return (COND_SKIP);
+        } else {
+            if (condTop == MAXIF) {
+                Parse_Error (level, "if-less endif");
+                return (COND_INVALID);
+            } else {
+                skipLine = FALSE;
+                condTop += 1;
+                return (COND_PARSE);
+            }
+        }
     } else {
-        isElse = FALSE;
+        isElse = FALSE;
     }
 
@@ -1179 +1180 @@
      */
     for (ifp = ifs; ifp->form != (char *)0; ifp++) {
-        if (strncmp (ifp->form, line, ifp->formlen) == 0) {
-            break;
-        }
+        if (strncmp (ifp->form, line, ifp->formlen) == 0) {
+            break;
+        }
     }
 
     if (ifp->form == (char *) 0) {
-        /*
-         * Nothing fit. If the first word on the line is actually
-         * "else", it's a valid conditional whose value is the inverse
-         * of the previous if we parsed.
-         */
-        if (isElse && (line[0] == 's') && (line[1] == 'e')) {
-            if (condTop == MAXIF) {
-                Parse_Error (level, "if-less else");
-                return (COND_INVALID);
-            } else if (skipIfLevel == 0) {
-                value = !condStack[condTop];
-            } else {
-                return (COND_SKIP);
-            }
-        } else {
-            /*
-             * Not a valid conditional type. No error...
-             */
-            return (COND_INVALID);
-        }
+        /*
+         * Nothing fit. If the first word on the line is actually
+         * "else", it's a valid conditional whose value is the inverse
+         * of the previous if we parsed.
+         */
+        if (isElse && (line[0] == 's') && (line[1] == 'e')) {
+            if (condTop == MAXIF) {
+                Parse_Error (level, "if-less else");
+                return (COND_INVALID);
+            } else if (skipIfLevel == 0) {
+                value = !condStack[condTop];
+            } else {
+                return (COND_SKIP);
+            }
+        } else {
+            /*
+             * Not a valid conditional type. No error...
+             */
+            return (COND_INVALID);
+        }
     } else {
-        if (isElse) {
-            if (condTop == MAXIF) {
-                Parse_Error (level, "if-less elif");
-                return (COND_INVALID);
-            } else if (skipIfLevel != 0) {
-                /*
-                 * If skipping this conditional, just ignore the whole thing.
-                 * If we don't, the user might be employing a variable that's
-                 * undefined, for which there's an enclosing ifdef that
-                 * we're skipping...
-                 */
-                return(COND_SKIP);
-            }
-        } else if (skipLine) {
-            /*
-             * Don't even try to evaluate a conditional that's not an else if
-             * we're skipping things...
-             */
-            skipIfLevel += 1;
-            return(COND_SKIP);
-        }
-
-        /*
-         * Initialize file-global variables for parsing
-         */
-        condDefProc = ifp->defProc;
-        condInvert = ifp->doNot;
-
-        line += ifp->formlen;
-
-        while (*line == ' ' || *line == '\t') {
-            line++;
-        }
-
-        condExpr = line;
-        condPushBack = None;
-
-        switch (CondE(TRUE)) {
-            case True:
-                if (CondToken(TRUE) == EndOfFile) {
-                    value = TRUE;
-                    break;
-                }
-                goto err;
-                /*FALLTHRU*/
-            case False:
-                if (CondToken(TRUE) == EndOfFile) {
-                    value = FALSE;
-                    break;
-                }
-                /*FALLTHRU*/
-            case Err:
-            err:
-                Parse_Error (level, "Malformed conditional (%s)",
-                             line);
-                return (COND_INVALID);
-            default:
-                break;
-        }
+        if (isElse) {
+            if (condTop == MAXIF) {
+                Parse_Error (level, "if-less elif");
+                return (COND_INVALID);
+            } else if (skipIfLevel != 0) {
+                /*
+                 * If skipping this conditional, just ignore the whole thing.
+                 * If we don't, the user might be employing a variable that's
+                 * undefined, for which there's an enclosing ifdef that
+                 * we're skipping...
+                 */
+                return(COND_SKIP);
+            }
+        } else if (skipLine) {
+            /*
+             * Don't even try to evaluate a conditional that's not an else if
+             * we're skipping things...
+             */
+            skipIfLevel += 1;
+            return(COND_SKIP);
+        }
+
+        /*
+         * Initialize file-global variables for parsing
+         */
+        condDefProc = ifp->defProc;
+        condInvert = ifp->doNot;
+
+        line += ifp->formlen;
+
+        while (*line == ' ' || *line == '\t') {
+            line++;
+        }
+
+        condExpr = line;
+        condPushBack = None;
+
+        switch (CondE(TRUE)) {
+            case True:
+                if (CondToken(TRUE) == EndOfFile) {
+                    value = TRUE;
+                    break;
+                }
+                goto err;
+                /*FALLTHRU*/
+            case False:
+                if (CondToken(TRUE) == EndOfFile) {
+                    value = FALSE;
+                    break;
+                }
+                /*FALLTHRU*/
+            case Err:
+            err:
+                Parse_Error (level, "Malformed conditional (%s)",
+                             line);
+                return (COND_INVALID);
+            default:
+                break;
+        }
     }
     if (!isElse) {
-        condTop -= 1;
+        condTop -= 1;
     } else if ((skipIfLevel != 0) || condStack[condTop]) {
-        /*
-         * If this is an else-type conditional, it should only take effect
-         * if its corresponding if was evaluated and FALSE. If its if was
-         * TRUE or skipped, we return COND_SKIP (and start skipping in case
-         * we weren't already), leaving the stack unmolested so later elif's
-         * don't screw up...
-         */
-        skipLine = TRUE;
-        return (COND_SKIP);
+        /*
+         * If this is an else-type conditional, it should only take effect
+         * if its corresponding if was evaluated and FALSE. If its if was
+         * TRUE or skipped, we return COND_SKIP (and start skipping in case
+         * we weren't already), leaving the stack unmolested so later elif's
+         * don't screw up...
+         */
+        skipLine = TRUE;
+        return (COND_SKIP);
     }
 
     if (condTop < 0) {
-        /*
-         * This is the one case where we can definitely proclaim a fatal
-         * error. If we don't, we're hosed.
-         */
-        Parse_Error (PARSE_FATAL, "Too many nested if's. %d max.", MAXIF);
-        return (COND_INVALID);
+        /*
+         * This is the one case where we can definitely proclaim a fatal
+         * error. If we don't, we're hosed.
+         */
+        Parse_Error (PARSE_FATAL, "Too many nested if's. %d max.", MAXIF);
+        return (COND_INVALID);
     } else {
-        condStack[condTop] = value;
-        skipLine = !value;
-        return (value ? COND_PARSE : COND_SKIP);
+        condStack[condTop] = value;
+        skipLine = !value;
+        return (value ? COND_PARSE : COND_SKIP);
     }
 }
@@ -1298 +1299 @@
  *-----------------------------------------------------------------------
  * Cond_End --
- *      Make sure everything's clean at the end of a makefile.
+ *      Make sure everything's clean at the end of a makefile.
  *
  * Results:
- *      None.
+ *      None.
  *
  * Side Effects:
- *      Parse_Error will be called if open conditionals are around.
+ *      Parse_Error will be called if open conditionals are around.
  *
  *-----------------------------------------------------------------------
@@ -1312 +1313 @@
 {
     if (condTop != MAXIF) {
-        Parse_Error(PARSE_FATAL, "%d open conditional%s", MAXIF-condTop,
-                    MAXIF-condTop == 1 ? "" : "s");
+        Parse_Error(PARSE_FATAL, "%d open conditional%s", MAXIF-condTop,
+                    MAXIF-condTop == 1 ? "" : "s");
     }
     condTop = MAXIF;

trunk/src/kmk/config.h

@@ -18 +18 @@
  * 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
@@ -36 +36 @@
  * SUCH DAMAGE.
  *
- *      from: @(#)config.h      8.1 (Berkeley) 6/6/93
+ *      from: @(#)config.h      8.1 (Berkeley) 6/6/93
  * $FreeBSD: src/usr.bin/make/config.h,v 1.9 1999/09/10 20:51:59 julian Exp $
  */
 
-#define DEFSHELL        1                       /* Bourne shell */
+#define DEFSHELL        1                       /* Bourne shell */
 
 /*
  * DEFMAXJOBS
  * DEFMAXLOCAL
- *      These control the default concurrency. On no occasion will more
- *      than DEFMAXJOBS targets be created at once (locally or remotely)
- *      DEFMAXLOCAL is the highest number of targets which will be
- *      created on the local machine at once. Note that if you set this
- *      to 0, nothing will ever happen...
+ *      These control the default concurrency. On no occasion will more
+ *      than DEFMAXJOBS targets be created at once (locally or remotely)
+ *      DEFMAXLOCAL is the highest number of targets which will be
+ *      created on the local machine at once. Note that if you set this
+ *      to 0, nothing will ever happen...
  */
-#define DEFMAXJOBS      4
-#define DEFMAXLOCAL     1
+#define DEFMAXJOBS      4
+#define DEFMAXLOCAL     1
 
 /*
  * INCLUDES
  * LIBRARIES
- *      These control the handling of the .INCLUDES and .LIBS variables.
- *      If INCLUDES is defined, the .INCLUDES variable will be filled
- *      from the search paths of those suffixes which are marked by
- *      .INCLUDES dependency lines. Similarly for LIBRARIES and .LIBS
- *      See suff.c for more details.
+ *      These control the handling of the .INCLUDES and .LIBS variables.
+ *      If INCLUDES is defined, the .INCLUDES variable will be filled
+ *      from the search paths of those suffixes which are marked by
+ *      .INCLUDES dependency lines. Similarly for LIBRARIES and .LIBS
+ *      See suff.c for more details.
  */
 #define INCLUDES
@@ -68 +68 @@
 /*
  * LIBSUFF
- *      Is the suffix used to denote libraries and is used by the Suff module
- *      to find the search path on which to seek any -l<xx> targets.
+ *      Is the suffix used to denote libraries and is used by the Suff module
+ *      to find the search path on which to seek any -l<xx> targets.
  *
  * RECHECK
- *      If defined, Make_Update will check a target for its current
- *      modification time after it has been re-made, setting it to the
- *      starting time of the make only if the target still doesn't exist.
- *      Unfortunately, under NFS the modification time often doesn't
- *      get updated in time, so a target will appear to not have been
- *      re-made, causing later targets to appear up-to-date. On systems
- *      that don't have this problem, you should defined this. Under
- *      NFS you probably should not, unless you aren't exporting jobs.
+ *      If defined, Make_Update will check a target for its current
+ *      modification time after it has been re-made, setting it to the
+ *      starting time of the make only if the target still doesn't exist.
+ *      Unfortunately, under NFS the modification time often doesn't
+ *      get updated in time, so a target will appear to not have been
+ *      re-made, causing later targets to appear up-to-date. On systems
+ *      that don't have this problem, you should defined this. Under
+ *      NFS you probably should not, unless you aren't exporting jobs.
  */
-#define LIBSUFF ".a"
-#define RECHECK
+#define LIBSUFF ".a"
+#define RECHECK
 
 /*
  * POSIX
- *      Adhere to the POSIX 1003.2 draft for the make(1) program.
- *      - Use MAKEFLAGS instead of MAKE to pick arguments from the
- *        environment.
- *      - Allow empty command lines if starting with tab.
+ *      Adhere to the POSIX 1003.2 draft for the make(1) program.
+ *      - Use MAKEFLAGS instead of MAKE to pick arguments from the
+ *        environment.
+ *      - Allow empty command lines if starting with tab.
  */
 #define POSIX
@@ -95 +95 @@
 /*
  * SYSVINCLUDE
- *      Recognize system V like include directives [include "filename"]
+ *      Recognize system V like include directives [include "filename"]
  * SYSVVARSUB
- *      Recognize system V like ${VAR:x=y} variable substitutions
+ *      Recognize system V like ${VAR:x=y} variable substitutions
  */
 #define SYSVINCLUDE
@@ -104 +104 @@
 /*
  * SUNSHCMD
- *      Recognize SunOS and Solaris:
- *              VAR :sh= CMD    # Assign VAR to the command substitution of CMD
- *              ${VAR:sh}       # Return the command substitution of the value
- *                              # of ${VAR}
+ *      Recognize SunOS and Solaris:
+ *              VAR :sh= CMD    # Assign VAR to the command substitution of CMD
+ *              ${VAR:sh}       # Return the command substitution of the value
+ *                              # of ${VAR}
  */
 #define SUNSHCMD
@@ -120 +120 @@
 # endif
 #endif
-
-
-
 
 
@@ -159 +156 @@
 
 /*
+ * USE_BASEANDROOT_MODIFIERS
+ *      If defined two extra variable modifiers B and R are added.
+ */
+#if defined(NMAKE) || defined(KMK)
+#define USE_BASEANDROOT_MODIFIERS 1
+#endif
+
+
+/*
  * USE_ISODATES
  *      If defined dates and times will be outputted in ISO format.

trunk/src/kmk/dir.c

@@ -18 +18 @@
  * 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
@@ -39 +39 @@
 #ifndef lint
 #if 0
-static char sccsid[] = "@(#)dir.c       8.2 (Berkeley) 1/2/94";
+static char sccsid[] = "@(#)dir.c       8.2 (Berkeley) 1/2/94";
 #else
 static const char rcsid[] =
   "$FreeBSD: src/usr.bin/make/dir.c,v 1.10.2.1 2001/02/13 03:13:57 will Exp $";
 #endif
+#define KLIBFILEDEF rcsid
 #endif /* not lint */
 
 /*-
  * dir.c --
- *      Directory searching using wildcards and/or normal names...
- *      Used both for source wildcarding in the Makefile and for finding
- *      implicit sources.
+ *      Directory searching using wildcards and/or normal names...
+ *      Used both for source wildcarding in the Makefile and for finding
+ *      implicit sources.
  *
  * The interface for this module is:
- *      Dir_Init            Initialize the module.
- *
- *      Dir_End             Cleanup the module.
- *
- *      Dir_HasWildcards    Returns TRUE if the name given it needs to
- *                          be wildcard-expanded.
- *
- *      Dir_Expand          Given a pattern and a path, return a Lst of names
- *                          which match the pattern on the search path.
- *
- *      Dir_FindFile        Searches for a file on a given search path.
- *                          If it exists, the entire path is returned.
- *                          Otherwise NULL is returned.
- *
- *      Dir_MTime           Return the modification time of a node. The file
- *                          is searched for along the default search path.
- *                          The path and mtime fields of the node are filled
- *                          in.
- *
- *      Dir_AddDir          Add a directory to a search path.
- *
- *      Dir_MakeFlags       Given a search path and a command flag, create
- *                          a string with each of the directories in the path
- *                          preceded by the command flag and all of them
- *                          separated by a space.
- *
- *      Dir_Destroy         Destroy an element of a search path. Frees up all
- *                          things that can be freed for the element as long
- *                          as the element is no longer referenced by any other
- *                          search path.
- *      Dir_ClearPath       Resets a search path to the empty list.
+ *      Dir_Init            Initialize the module.
+ *
+ *      Dir_End             Cleanup the module.
+ *
+ *      Dir_HasWildcards    Returns TRUE if the name given it needs to
+ *                          be wildcard-expanded.
+ *
+ *      Dir_Expand          Given a pattern and a path, return a Lst of names
+ *                          which match the pattern on the search path.
+ *
+ *      Dir_FindFile        Searches for a file on a given search path.
+ *                          If it exists, the entire path is returned.
+ *                          Otherwise NULL is returned.
+ *
+ *      Dir_MTime           Return the modification time of a node. The file
+ *                          is searched for along the default search path.
+ *                          The path and mtime fields of the node are filled
+ *                          in.
+ *
+ *      Dir_AddDir          Add a directory to a search path.
+ *
+ *      Dir_MakeFlags       Given a search path and a command flag, create
+ *                          a string with each of the directories in the path
+ *                          preceded by the command flag and all of them
+ *                          separated by a space.
+ *
+ *      Dir_Destroy         Destroy an element of a search path. Frees up all
+ *                          things that can be freed for the element as long
+ *                          as the element is no longer referenced by any other
+ *                          search path.
+ *      Dir_ClearPath       Resets a search path to the empty list.
  *
  * For debugging:
- *      Dir_PrintDirectories    Print stats about the directory cache.
+ *      Dir_PrintDirectories    Print stats about the directory cache.
  */
 
@@ -98 +99 @@
 
 /*
- *      A search path consists of a Lst of Path structures. A Path structure
- *      has in it the name of the directory and a hash table of all the files
- *      in the directory. This is used to cut down on the number of system
- *      calls necessary to find implicit dependents and their like. Since
- *      these searches are made before any actions are taken, we need not
- *      worry about the directory changing due to creation commands. If this
- *      hampers the style of some makefiles, they must be changed.
- *
- *      A list of all previously-read directories is kept in the
- *      openDirectories Lst. This list is checked first before a directory
- *      is opened.
- *
- *      The need for the caching of whole directories is brought about by
- *      the multi-level transformation code in suff.c, which tends to search
- *      for far more files than regular make does. In the initial
- *      implementation, the amount of time spent performing "stat" calls was
- *      truly astronomical. The problem with hashing at the start is,
- *      of course, that pmake doesn't then detect changes to these directories
- *      during the course of the make. Three possibilities suggest themselves:
- *
- *          1) just use stat to test for a file's existence. As mentioned
- *             above, this is very inefficient due to the number of checks
- *             engendered by the multi-level transformation code.
- *          2) use readdir() and company to search the directories, keeping
- *             them open between checks. I have tried this and while it
- *             didn't slow down the process too much, it could severely
- *             affect the amount of parallelism available as each directory
- *             open would take another file descriptor out of play for
- *             handling I/O for another job. Given that it is only recently
- *             that UNIX OS's have taken to allowing more than 20 or 32
- *             file descriptors for a process, this doesn't seem acceptable
- *             to me.
- *          3) record the mtime of the directory in the Path structure and
- *             verify the directory hasn't changed since the contents were
- *             hashed. This will catch the creation or deletion of files,
- *             but not the updating of files. However, since it is the
- *             creation and deletion that is the problem, this could be
- *             a good thing to do. Unfortunately, if the directory (say ".")
- *             were fairly large and changed fairly frequently, the constant
- *             rehashing could seriously degrade performance. It might be
- *             good in such cases to keep track of the number of rehashes
- *             and if the number goes over a (small) limit, resort to using
- *             stat in its place.
- *
- *      An additional thing to consider is that pmake is used primarily
- *      to create C programs and until recently pcc-based compilers refused
- *      to allow you to specify where the resulting object file should be
- *      placed. This forced all objects to be created in the current
- *      directory. This isn't meant as a full excuse, just an explanation of
- *      some of the reasons for the caching used here.
- *
- *      One more note: the location of a target's file is only performed
- *      on the downward traversal of the graph and then only for terminal
- *      nodes in the graph. This could be construed as wrong in some cases,
- *      but prevents inadvertent modification of files when the "installed"
- *      directory for a file is provided in the search path.
- *
- *      Another data structure maintained by this module is an mtime
- *      cache used when the searching of cached directories fails to find
- *      a file. In the past, Dir_FindFile would simply perform an access()
- *      call in such a case to determine if the file could be found using
- *      just the name given. When this hit, however, all that was gained
- *      was the knowledge that the file existed. Given that an access() is
- *      essentially a stat() without the copyout() call, and that the same
- *      filesystem overhead would have to be incurred in Dir_MTime, it made
- *      sense to replace the access() with a stat() and record the mtime
- *      in a cache for when Dir_MTime was actually called.
- */
-
-Lst          dirSearchPath;     /* main search path */
-
-static Lst   openDirectories;   /* the list of all open directories */
+ *      A search path consists of a Lst of Path structures. A Path structure
+ *      has in it the name of the directory and a hash table of all the files
+ *      in the directory. This is used to cut down on the number of system
+ *      calls necessary to find implicit dependents and their like. Since
+ *      these searches are made before any actions are taken, we need not
+ *      worry about the directory changing due to creation commands. If this
+ *      hampers the style of some makefiles, they must be changed.
+ *
+ *      A list of all previously-read directories is kept in the
+ *      openDirectories Lst. This list is checked first before a directory
+ *      is opened.
+ *
+ *      The need for the caching of whole directories is brought about by
+ *      the multi-level transformation code in suff.c, which tends to search
+ *      for far more files than regular make does. In the initial
+ *      implementation, the amount of time spent performing "stat" calls was
+ *      truly astronomical. The problem with hashing at the start is,
+ *      of course, that pmake doesn't then detect changes to these directories
+ *      during the course of the make. Three possibilities suggest themselves:
+ *
+ *          1) just use stat to test for a file's existence. As mentioned
+ *             above, this is very inefficient due to the number of checks
+ *             engendered by the multi-level transformation code.
+ *          2) use readdir() and company to search the directories, keeping
+ *             them open between checks. I have tried this and while it
+ *             didn't slow down the process too much, it could severely
+ *             affect the amount of parallelism available as each directory
+ *             open would take another file descriptor out of play for
+ *             handling I/O for another job. Given that it is only recently
+ *             that UNIX OS's have taken to allowing more than 20 or 32
+ *             file descriptors for a process, this doesn't seem acceptable
+ *             to me.
+ *          3) record the mtime of the directory in the Path structure and
+ *             verify the directory hasn't changed since the contents were
+ *             hashed. This will catch the creation or deletion of files,
+ *             but not the updating of files. However, since it is the
+ *             creation and deletion that is the problem, this could be
+ *             a good thing to do. Unfortunately, if the directory (say ".")
+ *             were fairly large and changed fairly frequently, the constant
+ *             rehashing could seriously degrade performance. It might be
+ *             good in such cases to keep track of the number of rehashes
+ *             and if the number goes over a (small) limit, resort to using
+ *             stat in its place.
+ *
+ *      An additional thing to consider is that pmake is used primarily
+ *      to create C programs and until recently pcc-based compilers refused
+ *      to allow you to specify where the resulting object file should be
+ *      placed. This forced all objects to be created in the current
+ *      directory. This isn't meant as a full excuse, just an explanation of
+ *      some of the reasons for the caching used here.
+ *
+ *      One more note: the location of a target's file is only performed
+ *      on the downward traversal of the graph and then only for terminal
+ *      nodes in the graph. This could be construed as wrong in some cases,
+ *      but prevents inadvertent modification of files when the "installed"
+ *      directory for a file is provided in the search path.
+ *
+ *      Another data structure maintained by this module is an mtime
+ *      cache used when the searching of cached directories fails to find
+ *      a file. In the past, Dir_FindFile would simply perform an access()
+ *      call in such a case to determine if the file could be found using
+ *      just the name given. When this hit, however, all that was gained
+ *      was the knowledge that the file existed. Given that an access() is
+ *      essentially a stat() without the copyout() call, and that the same
+ *      filesystem overhead would have to be incurred in Dir_MTime, it made
+ *      sense to replace the access() with a stat() and record the mtime
+ *      in a cache for when Dir_MTime was actually called.
+ */
+
+Lst          dirSearchPath;     /* main search path */
+
+static Lst   openDirectories;   /* the list of all open directories */
 
 /*
@@ -175 +176 @@
  * mechanism.
  */
-static int    hits,           /* Found in directory cache */
-              misses,         /* Sad, but not evil misses */
-              nearmisses,     /* Found under search path */
-              bigmisses;      /* Sought by itself */
-
-static Path       *dot;     /* contents of current directory */
+static int    hits,           /* Found in directory cache */
+              misses,         /* Sad, but not evil misses */
+              nearmisses,     /* Found under search path */
+              bigmisses;      /* Sought by itself */
+
+static Path       *dot;     /* contents of current directory */
 static Hash_Table mtimes;   /* Results of doing a last-resort stat in
-                             * Dir_FindFile -- if we have to go to the
-                             * system to find the file, we might as well
-                             * have its mtime on record. XXX: If this is done
-                             * way early, there's a chance other rules will
-                             * have already updated the file, in which case
-                             * we'll update it again. Generally, there won't
-                             * be two rules to update a single file, so this
-                             * should be ok, but... */
+                             * Dir_FindFile -- if we have to go to the
+                             * system to find the file, we might as well
+                             * have its mtime on record. XXX: If this is done
+                             * way early, there's a chance other rules will
+                             * have already updated the file, in which case
+                             * we'll update it again. Generally, there won't
+                             * be two rules to update a single file, so this
+                             * should be ok, but... */
 
 
@@ -202 +203 @@
  *-----------------------------------------------------------------------
  * Dir_Init --
- *      initialize things for this module
- *
- * Results:
- *      none
- *
- * Side Effects:
- *      some directories may be opened.
+ *      initialize things for this module
+ *
+ * Results:
+ *      none
+ *
+ * Side Effects:
+ *      some directories may be opened.
  *-----------------------------------------------------------------------
  */
@@ -227 +228 @@
     dot = (Path *) Lst_DeQueue (openDirectories);
     if (dot == (Path *) NULL)
-        err(1, "cannot open current directory");
+        err(1, "cannot open current directory");
 
     /*
@@ -239 +240 @@
  *-----------------------------------------------------------------------
  * Dir_End --
- *      cleanup things for this module
- *
- * Results:
- *      none
- *
- * Side Effects:
- *      none
+ *      cleanup things for this module
+ *
+ * Results:
+ *      none
+ *
+ * Side Effects:
+ *      none
  *-----------------------------------------------------------------------
  */
@@ -263 +264 @@
  *-----------------------------------------------------------------------
  * DirFindName --
- *      See if the Path structure describes the same directory as the
- *      given one by comparing their names. Called from Dir_AddDir via
- *      Lst_Find when searching the list of open directories.
- *
- * Results:
- *      0 if it is the same. Non-zero otherwise
- *
- * Side Effects:
- *      None
+ *      See if the Path structure describes the same directory as the
+ *      given one by comparing their names. Called from Dir_AddDir via
+ *      Lst_Find when searching the list of open directories.
+ *
+ * Results:
+ *      0 if it is the same. Non-zero otherwise
+ *
+ * Side Effects:
+ *      None
  *-----------------------------------------------------------------------
  */
 static int
 DirFindName (p, dname)
-    ClientData    p;          /* Current name */
-    ClientData    dname;      /* Desired name */
+    ClientData    p;          /* Current name */
+    ClientData    dname;      /* Desired name */
 {
     return (strcmp (((Path *)p)->name, (char *) dname));
@@ -285 +286 @@
  *-----------------------------------------------------------------------
  * Dir_HasWildcards  --
- *      see if the given name has any wildcard characters in it
- *
- * Results:
- *      returns TRUE if the word should be expanded, FALSE otherwise
- *
- * Side Effects:
- *      none
+ *      see if the given name has any wildcard characters in it
+ *
+ * Results:
+ *      returns TRUE if the word should be expanded, FALSE otherwise
+ *
+ * Side Effects:
+ *      none
  *-----------------------------------------------------------------------
  */
 Boolean
 Dir_HasWildcards (name)
-    char          *name;        /* name to check */
+    char          *name;        /* name to check */
 {
     register char *cp;
 
     for (cp = name; *cp; cp++) {
-        switch(*cp) {
-        case '{':
-        case '[':
-        case '?':
-        case '*':
-            return (TRUE);
-        }
+        switch(*cp) {
+        case '{':
+        case '[':
+        case '?':
+        case '*':
+            return (TRUE);
+        }
     }
     return (FALSE);
@@ -315 +316 @@
  *-----------------------------------------------------------------------
  * DirMatchFiles --
- *      Given a pattern and a Path structure, see if any files
- *      match the pattern and add their names to the 'expansions' list if
- *      any do. This is incomplete -- it doesn't take care of patterns like
- *      src / *src / *.c properly (just *.c on any of the directories), but it
- *      will do for now.
- *
- * Results:
- *      Always returns 0
- *
- * Side Effects:
- *      File names are added to the expansions lst. The directory will be
- *      fully hashed when this is done.
+ *      Given a pattern and a Path structure, see if any files
+ *      match the pattern and add their names to the 'expansions' list if
+ *      any do. This is incomplete -- it doesn't take care of patterns like
+ *      src / *src / *.c properly (just *.c on any of the directories), but it
+ *      will do for now.
+ *
+ * Results:
+ *      Always returns 0
+ *
+ * Side Effects:
+ *      File names are added to the expansions lst. The directory will be
+ *      fully hashed when this is done.
  *-----------------------------------------------------------------------
  */
 static int
 DirMatchFiles (pattern, p, expansions)
-    char          *pattern;     /* Pattern to look for */
-    Path          *p;           /* Directory to search */
-    Lst           expansions;   /* Place to store the results */
-{
-    Hash_Search   search;       /* Index into the directory's table */
-    Hash_Entry    *entry;       /* Current entry in the table */
-    Boolean       isDot;        /* TRUE if the directory being searched is . */
+    char          *pattern;     /* Pattern to look for */
+    Path          *p;           /* Directory to search */
+    Lst           expansions;   /* Place to store the results */
+{
+    Hash_Search   search;       /* Index into the directory's table */
+    Hash_Entry    *entry;       /* Current entry in the table */
+    Boolean       isDot;        /* TRUE if the directory being searched is . */
 
     isDot = (*p->name == '.' && p->name[1] == '\0');
 
     for (entry = Hash_EnumFirst(&p->files, &search);
-         entry != (Hash_Entry *)NULL;
-         entry = Hash_EnumNext(&search))
+         entry != (Hash_Entry *)NULL;
+         entry = Hash_EnumNext(&search))
     {
-        /*
-         * See if the file matches the given pattern. Note we follow the UNIX
-         * convention that dot files will only be found if the pattern
-         * begins with a dot (note also that as a side effect of the hashing
-         * scheme, .* won't match . or .. since they aren't hashed).
-         */
-        if (Str_Match(entry->name, pattern) &&
-            ((entry->name[0] != '.') ||
-             (pattern[0] == '.')))
-        {
-            (void)Lst_AtEnd(expansions,
-                            (isDot ? estrdup(entry->name) :
-                             str_concat(p->name, entry->name,
-                                        STR_ADDSLASH)));
-        }
+        /*
+         * See if the file matches the given pattern. Note we follow the UNIX
+         * convention that dot files will only be found if the pattern
+         * begins with a dot (note also that as a side effect of the hashing
+         * scheme, .* won't match . or .. since they aren't hashed).
+         */
+        if (Str_Match(entry->name, pattern) &&
+            ((entry->name[0] != '.') ||
+             (pattern[0] == '.')))
+        {
+            (void)Lst_AtEnd(expansions,
+                            (isDot ? estrdup(entry->name) :
+                             str_concat(p->name, entry->name,
+                                        STR_ADDSLASH)));
+        }
     }
     return (0);
@@ -367 +368 @@
  *-----------------------------------------------------------------------
  * DirExpandCurly --
- *      Expand curly braces like the C shell. Does this recursively.
- *      Note the special case: if after the piece of the curly brace is
- *      done there are no wildcard characters in the result, the result is
- *      placed on the list WITHOUT CHECKING FOR ITS EXISTENCE.
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      The given list is filled with the expansions...
+ *      Expand curly braces like the C shell. Does this recursively.
+ *      Note the special case: if after the piece of the curly brace is
+ *      done there are no wildcard characters in the result, the result is
+ *      placed on the list WITHOUT CHECKING FOR ITS EXISTENCE.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      The given list is filled with the expansions...
  *
  *-----------------------------------------------------------------------
@@ -382 +383 @@
 static void
 DirExpandCurly(word, brace, path, expansions)
-    char          *word;        /* Entire word to expand */
-    char          *brace;       /* First curly brace in it */
-    Lst           path;         /* Search path to use */
-    Lst           expansions;   /* Place to store the expansions */
-{
-    char          *end;         /* Character after the closing brace */
-    char          *cp;          /* Current position in brace clause */
-    char          *start;       /* Start of current piece of brace clause */
-    int           bracelevel;   /* Number of braces we've seen. If we see a
-                                 * right brace when this is 0, we've hit the
-                                 * end of the clause. */
-    char          *file;        /* Current expansion */
-    int           otherLen;     /* The length of the other pieces of the
-                                 * expansion (chars before and after the
-                                 * clause in 'word') */
-    char          *cp2;         /* Pointer for checking for wildcards in
-                                 * expansion before calling Dir_Expand */
+    char          *word;        /* Entire word to expand */
+    char          *brace;       /* First curly brace in it */
+    Lst           path;         /* Search path to use */
+    Lst           expansions;   /* Place to store the expansions */
+{
+    char          *end;         /* Character after the closing brace */
+    char          *cp;          /* Current position in brace clause */
+    char          *start;       /* Start of current piece of brace clause */
+    int           bracelevel;   /* Number of braces we've seen. If we see a
+                                 * right brace when this is 0, we've hit the
+                                 * end of the clause. */
+    char          *file;        /* Current expansion */
+    int           otherLen;     /* The length of the other pieces of the
+                                 * expansion (chars before and after the
+                                 * clause in 'word') */
+    char          *cp2;         /* Pointer for checking for wildcards in
+                                 * expansion before calling Dir_Expand */
 
     start = brace+1;
@@ -407 +408 @@
      */
     for (end = start, bracelevel = 0; *end != '\0'; end++) {
-        if (*end == '{') {
-            bracelevel++;
-        } else if ((*end == '}') && (bracelevel-- == 0)) {
-            break;
-        }
+        if (*end == '{') {
+            bracelevel++;
+        } else if ((*end == '}') && (bracelevel-- == 0)) {
+            break;
+        }
     }
     if (*end == '\0') {
-        Error("Unterminated {} clause \"%s\"", start);
-        return;
+        Error("Unterminated {} clause \"%s\"", start);
+        return;
     } else {
-        end++;
+        end++;
     }
     otherLen = brace - word + strlen(end);
 
     for (cp = start; cp < end; cp++) {
-        /*
-         * Find the end of this piece of the clause.
-         */
-        bracelevel = 0;
-        while (*cp != ',') {
-            if (*cp == '{') {
-                bracelevel++;
-            } else if ((*cp == '}') && (bracelevel-- <= 0)) {
-                break;
-            }
-            cp++;
-        }
-        /*
-         * Allocate room for the combination and install the three pieces.
-         */
-        file = emalloc(otherLen + cp - start + 1);
-        if (brace != word) {
-            strncpy(file, word, brace-word);
-        }
-        if (cp != start) {
-            strncpy(&file[brace-word], start, cp-start);
-        }
-        strcpy(&file[(brace-word)+(cp-start)], end);
-
-        /*
-         * See if the result has any wildcards in it. If we find one, call
-         * Dir_Expand right away, telling it to place the result on our list
-         * of expansions.
-         */
-        for (cp2 = file; *cp2 != '\0'; cp2++) {
-            switch(*cp2) {
-            case '*':
-            case '?':
-            case '{':
-            case '[':
-                Dir_Expand(file, path, expansions);
-                goto next;
-            }
-        }
-        if (*cp2 == '\0') {
-            /*
-             * Hit the end w/o finding any wildcards, so stick the expansion
-             * on the end of the list.
-             */
-            (void)Lst_AtEnd(expansions, file);
-        } else {
-        next:
-            efree(file);
-        }
-        start = cp+1;
+        /*
+         * Find the end of this piece of the clause.
+         */
+        bracelevel = 0;
+        while (*cp != ',') {
+            if (*cp == '{') {
+                bracelevel++;
+            } else if ((*cp == '}') && (bracelevel-- <= 0)) {
+                break;
+            }
+            cp++;
+        }
+        /*
+         * Allocate room for the combination and install the three pieces.
+         */
+        file = emalloc(otherLen + cp - start + 1);
+        if (brace != word) {
+            strncpy(file, word, brace-word);
+        }
+        if (cp != start) {
+            strncpy(&file[brace-word], start, cp-start);
+        }
+        strcpy(&file[(brace-word)+(cp-start)], end);
+
+        /*
+         * See if the result has any wildcards in it. If we find one, call
+         * Dir_Expand right away, telling it to place the result on our list
+         * of expansions.
+         */
+        for (cp2 = file; *cp2 != '\0'; cp2++) {
+            switch(*cp2) {
+            case '*':
+            case '?':
+            case '{':
+            case '[':
+                Dir_Expand(file, path, expansions);
+                goto next;
+            }
+        }
+        if (*cp2 == '\0') {
+            /*
+             * Hit the end w/o finding any wildcards, so stick the expansion
+             * on the end of the list.
+             */
+            (void)Lst_AtEnd(expansions, file);
+        } else {
+        next:
+            efree(file);
+        }
+        start = cp+1;
     }
 }
@@ -479 +480 @@
  *-----------------------------------------------------------------------
  * DirExpandInt --
- *      Internal expand routine. Passes through the directories in the
- *      path one by one, calling DirMatchFiles for each. NOTE: This still
- *      doesn't handle patterns in directories...
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      Things are added to the expansions list.
+ *      Internal expand routine. Passes through the directories in the
+ *      path one by one, calling DirMatchFiles for each. NOTE: This still
+ *      doesn't handle patterns in directories...
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      Things are added to the expansions list.
  *
  *-----------------------------------------------------------------------
@@ -493 +494 @@
 static void
 DirExpandInt(word, path, expansions)
-    char          *word;        /* Word to expand */
-    Lst           path;         /* Path on which to look */
-    Lst           expansions;   /* Place to store the result */
-{
-    LstNode       ln;           /* Current node */
-    Path          *p;           /* Directory in the node */
+    char          *word;        /* Word to expand */
+    Lst           path;         /* Path on which to look */
+    Lst           expansions;   /* Place to store the result */
+{
+    LstNode       ln;           /* Current node */
+    Path          *p;           /* Directory in the node */
 
     if (Lst_Open(path) == SUCCESS) {
-        while ((ln = Lst_Next(path)) != NILLNODE) {
-            p = (Path *)Lst_Datum(ln);
-            DirMatchFiles(word, p, expansions);
-        }
-        Lst_Close(path);
+        while ((ln = Lst_Next(path)) != NILLNODE) {
+            p = (Path *)Lst_Datum(ln);
+            DirMatchFiles(word, p, expansions);
+        }
+        Lst_Close(path);
     }
 }
@@ -512 +513 @@
  *-----------------------------------------------------------------------
  * DirPrintWord --
- *      Print a word in the list of expansions. Callback for Dir_Expand
- *      when DEBUG(DIR), via Lst_ForEach.
- *
- * Results:
- *      === 0
- *
- * Side Effects:
- *      The passed word is printed, followed by a space.
+ *      Print a word in the list of expansions. Callback for Dir_Expand
+ *      when DEBUG(DIR), via Lst_ForEach.
+ *
+ * Results:
+ *      === 0
+ *
+ * Side Effects:
+ *      The passed word is printed, followed by a space.
  *
  *-----------------------------------------------------------------------
@@ -536 +537 @@
  *-----------------------------------------------------------------------
  * Dir_Expand  --
- *      Expand the given word into a list of words by globbing it looking
- *      in the directories on the given search path.
- *
- * Results:
- *      A list of words consisting of the files which exist along the search
- *      path matching the given pattern.
- *
- * Side Effects:
- *      Directories may be opened. Who knows?
+ *      Expand the given word into a list of words by globbing it looking
+ *      in the directories on the given search path.
+ *
+ * Results:
+ *      A list of words consisting of the files which exist along the search
+ *      path matching the given pattern.
+ *
+ * Side Effects:
+ *      Directories may be opened. Who knows?
  *-----------------------------------------------------------------------
  */
@@ -550 +551 @@
 Dir_Expand (word, path, expansions)
     char    *word;      /* the word to expand */
-    Lst     path;       /* the list of directories in which to find
-                         * the resulting files */
-    Lst     expansions; /* the list on which to place the results */
-{
-    char          *cp;
+    Lst     path;       /* the list of directories in which to find
+                         * the resulting files */
+    Lst     expansions; /* the list on which to place the results */
+{
+    char          *cp;
 
     if (DEBUG(DIR)) {
-        printf("expanding \"%s\"...", word);
+        printf("expanding \"%s\"...", word);
     }
 
     cp = strchr(word, '{');
     if (cp) {
-        DirExpandCurly(word, cp, path, expansions);
+        DirExpandCurly(word, cp, path, expansions);
     } else {
-        cp = strchr(word, '/');
-        if (cp) {
-            /*
-             * The thing has a directory component -- find the first wildcard
-             * in the string.
-             */
-            for (cp = word; *cp; cp++) {
-                if (*cp == '?' || *cp == '[' || *cp == '*' || *cp == '{') {
-                    break;
-                }
-            }
-            if (*cp == '{') {
-                /*
-                 * This one will be fun.
-                 */
-                DirExpandCurly(word, cp, path, expansions);
-                return;
-            } else if (*cp != '\0') {
-                /*
-                 * Back up to the start of the component
-                 */
-                char  *dirpath;
-
-                while (cp > word && *cp != '/') {
-                    cp--;
-                }
-                if (cp != word) {
-                    char sc;
-                    /*
-                     * If the glob isn't in the first component, try and find
-                     * all the components up to the one with a wildcard.
-                     */
-                    sc = cp[1];
-                    cp[1] = '\0';
-                    dirpath = Dir_FindFile(word, path);
-                    cp[1] = sc;
-                    /*
-                     * dirpath is null if can't find the leading component
-                     * XXX: Dir_FindFile won't find internal components.
-                     * i.e. if the path contains ../Etc/Object and we're
-                     * looking for Etc, it won't be found. Ah well.
-                     * Probably not important.
-                     */
-                    if (dirpath != (char *)NULL) {
-                        char *dp = &dirpath[strlen(dirpath) - 1];
-                        if (*dp == '/')
-                            *dp = '\0';
-                        path = Lst_Init(FALSE);
-                        Dir_AddDir(path, dirpath);
-                        DirExpandInt(cp+1, path, expansions);
-                        Lst_Destroy(path, NOFREE);
-                    }
-                } else {
-                    /*
-                     * Start the search from the local directory
-                     */
-                    DirExpandInt(word, path, expansions);
-                }
-            } else {
-                /*
-                 * Return the file -- this should never happen.
-                 */
-                DirExpandInt(word, path, expansions);
-            }
-        } else {
-            /*
-             * First the files in dot
-             */
-            DirMatchFiles(word, dot, expansions);
-
-            /*
-             * Then the files in every other directory on the path.
-             */
-            DirExpandInt(word, path, expansions);
-        }
+        cp = strchr(word, '/');
+        if (cp) {
+            /*
+             * The thing has a directory component -- find the first wildcard
+             * in the string.
+             */
+            for (cp = word; *cp; cp++) {
+                if (*cp == '?' || *cp == '[' || *cp == '*' || *cp == '{') {
+                    break;
+                }
+            }
+            if (*cp == '{') {
+                /*
+                 * This one will be fun.
+                 */
+                DirExpandCurly(word, cp, path, expansions);
+                return;
+            } else if (*cp != '\0') {
+                /*
+                 * Back up to the start of the component
+                 */
+                char  *dirpath;
+
+                while (cp > word && *cp != '/') {
+                    cp--;
+                }
+                if (cp != word) {
+                    char sc;
+                    /*
+                     * If the glob isn't in the first component, try and find
+                     * all the components up to the one with a wildcard.
+                     */
+                    sc = cp[1];
+                    cp[1] = '\0';
+                    dirpath = Dir_FindFile(word, path);
+                    cp[1] = sc;
+                    /*
+                     * dirpath is null if can't find the leading component
+                     * XXX: Dir_FindFile won't find internal components.
+                     * i.e. if the path contains ../Etc/Object and we're
+                     * looking for Etc, it won't be found. Ah well.
+                     * Probably not important.
+                     */
+                    if (dirpath != (char *)NULL) {
+                        char *dp = &dirpath[strlen(dirpath) - 1];
+                        if (*dp == '/')
+                            *dp = '\0';
+                        path = Lst_Init(FALSE);
+                        Dir_AddDir(path, dirpath);
+                        DirExpandInt(cp+1, path, expansions);
+                        Lst_Destroy(path, NOFREE);
+                    }
+                } else {
+                    /*
+                     * Start the search from the local directory
+                     */
+                    DirExpandInt(word, path, expansions);
+                }
+            } else {
+                /*
+                 * Return the file -- this should never happen.
+                 */
+                DirExpandInt(word, path, expansions);
+            }
+        } else {
+            /*
+             * First the files in dot
+             */
+            DirMatchFiles(word, dot, expansions);
+
+            /*
+             * Then the files in every other directory on the path.
+             */
+            DirExpandInt(word, path, expansions);
+        }
     }
     if (DEBUG(DIR)) {
-        Lst_ForEach(expansions, DirPrintWord, (ClientData) 0);
-        fputc('\n', stdout);
+        Lst_ForEach(expansions, DirPrintWord, (ClientData) 0);
+        fputc('\n', stdout);
     }
 }
@@ -649 +650 @@
  *-----------------------------------------------------------------------
  * Dir_FindFile  --
- *      Find the file with the given name along the given search path.
- *
- * Results:
- *      The path to the file or NULL. This path is guaranteed to be in a
- *      different part of memory than name and so may be safely efree'd.
- *
- * Side Effects:
- *      If the file is found in a directory which is not on the path
- *      already (either 'name' is absolute or it is a relative path
- *      [ dir1/.../dirn/file ] which exists below one of the directories
- *      already on the search path), its directory is added to the end
- *      of the path on the assumption that there will be more files in
- *      that directory later on. Sometimes this is true. Sometimes not.
+ *      Find the file with the given name along the given search path.
+ *
+ * Results:
+ *      The path to the file or NULL. This path is guaranteed to be in a
+ *      different part of memory than name and so may be safely efree'd.
+ *
+ * Side Effects:
+ *      If the file is found in a directory which is not on the path
+ *      already (either 'name' is absolute or it is a relative path
+ *      [ dir1/.../dirn/file ] which exists below one of the directories
+ *      already on the search path), its directory is added to the end
+ *      of the path on the assumption that there will be more files in
+ *      that directory later on. Sometimes this is true. Sometimes not.
  *-----------------------------------------------------------------------
  */
 char *
 Dir_FindFile (name, path)
-    char          *name;    /* the file to find */
-    Lst           path;     /* the Lst of directories to search */
-{
-    register char *p1;      /* pointer into p->name */
-    register char *p2;      /* pointer into name */
-    LstNode       ln;       /* a list element */
+    char          *name;    /* the file to find */
+    Lst           path;     /* the Lst of directories to search */
+{
+    register char *p1;      /* pointer into p->name */
+    register char *p2;      /* pointer into name */
+    LstNode       ln;       /* a list element */
     register char *file;    /* the current filename to check */
-    register Path *p;       /* current path member */
-    register char *cp;      /* index of first slash, if any */
-    Boolean       hasSlash; /* true if 'name' contains a / */
-    struct stat   stb;      /* Buffer for stat, if necessary */
-    Hash_Entry    *entry;   /* Entry for mtimes table */
+    register Path *p;       /* current path member */
+    register char *cp;      /* index of first slash, if any */
+    Boolean       hasSlash; /* true if 'name' contains a / */
+    struct stat   stb;      /* Buffer for stat, if necessary */
+    Hash_Entry    *entry;   /* Entry for mtimes table */
 
 #ifdef NMAKE
@@ -691 +692 @@
     cp = strrchr (name, '/');
     if (cp) {
-        hasSlash = TRUE;
-        cp += 1;
+        hasSlash = TRUE;
+        cp += 1;
     } else {
-        hasSlash = FALSE;
-        cp = name;
+        hasSlash = FALSE;
+        cp = name;
     }
 
     if (DEBUG(DIR)) {
-        printf("Searching for %s...", name);
+        printf("Searching for %s...", name);
     }
     /*
@@ -708 +709 @@
      */
     if ((!hasSlash || (cp - name == 2 && *name == '.')) &&
-        (Hash_FindEntry (&dot->files, cp) != (Hash_Entry *)NULL)) {
-            if (DEBUG(DIR)) {
-                printf("in '.'\n");
-            }
-            hits += 1;
-            dot->hits += 1;
-            return (estrdup (name));
+        (Hash_FindEntry (&dot->files, cp) != (Hash_Entry *)NULL)) {
+            if (DEBUG(DIR)) {
+                printf("in '.'\n");
+            }
+            hits += 1;
+            dot->hits += 1;
+            return (estrdup (name));
     }
 
     if (Lst_Open (path) == FAILURE) {
-        if (DEBUG(DIR)) {
-            printf("couldn't open path, file not found\n");
-        }
-        misses += 1;
-        return ((char *) NULL);
+        if (DEBUG(DIR)) {
+            printf("couldn't open path, file not found\n");
+        }
+        misses += 1;
+        return ((char *) NULL);
     }
 
@@ -734 +735 @@
      */
     while ((ln = Lst_Next (path)) != NILLNODE) {
-        p = (Path *) Lst_Datum (ln);
-        if (DEBUG(DIR)) {
-            printf("%s...", p->name);
-        }
-        if (Hash_FindEntry (&p->files, cp) != (Hash_Entry *)NULL) {
-            if (DEBUG(DIR)) {
-                printf("here...");
-            }
-            if (hasSlash) {
-                /*
-                 * If the name had a slash, its initial components and p's
-                 * final components must match. This is false if a mismatch
-                 * is encountered before all of the initial components
-                 * have been checked (p2 > name at the end of the loop), or
-                 * we matched only part of one of the components of p
-                 * along with all the rest of them (*p1 != '/').
-                 */
-                p1 = p->name + strlen (p->name) - 1;
-                p2 = cp - 2;
-                while (p2 >= name && p1 >= p->name && *p1 == *p2) {
-                    p1 -= 1; p2 -= 1;
-                }
-                if (p2 >= name || (p1 >= p->name && *p1 != '/')) {
-                    if (DEBUG(DIR)) {
-                        printf("component mismatch -- continuing...");
-                    }
-                    continue;
-                }
-            }
-            file = str_concat (p->name, cp, STR_ADDSLASH);
-            if (DEBUG(DIR)) {
-                printf("returning %s\n", file);
-            }
-            Lst_Close (path);
-            p->hits += 1;
-            hits += 1;
-            return (file);
-        } else if (hasSlash) {
-            /*
-             * If the file has a leading path component and that component
-             * exactly matches the entire name of the current search
-             * directory, we assume the file doesn't exist and return NULL.
-             */
-            for (p1 = p->name, p2 = name; *p1 && *p1 == *p2; p1++, p2++) {
-                continue;
-            }
-            if (*p1 == '\0' && p2 == cp - 1) {
-                if (DEBUG(DIR)) {
-                    printf("must be here but isn't -- returing NULL\n");
-                }
-                Lst_Close (path);
-                return ((char *) NULL);
-            }
-        }
+        p = (Path *) Lst_Datum (ln);
+        if (DEBUG(DIR)) {
+            printf("%s...", p->name);
+        }
+        if (Hash_FindEntry (&p->files, cp) != (Hash_Entry *)NULL) {
+            if (DEBUG(DIR)) {
+                printf("here...");
+            }
+            if (hasSlash) {
+                /*
+                 * If the name had a slash, its initial components and p's
+                 * final components must match. This is false if a mismatch
+                 * is encountered before all of the initial components
+                 * have been checked (p2 > name at the end of the loop), or
+                 * we matched only part of one of the components of p
+                 * along with all the rest of them (*p1 != '/').
+                 */
+                p1 = p->name + strlen (p->name) - 1;
+                p2 = cp - 2;
+                while (p2 >= name && p1 >= p->name && *p1 == *p2) {
+                    p1 -= 1; p2 -= 1;
+                }
+                if (p2 >= name || (p1 >= p->name && *p1 != '/')) {
+                    if (DEBUG(DIR)) {
+                        printf("component mismatch -- continuing...");
+                    }
+                    continue;
+                }
+            }
+            file = str_concat (p->name, cp, STR_ADDSLASH);
+            if (DEBUG(DIR)) {
+                printf("returning %s\n", file);
+            }
+            Lst_Close (path);
+            p->hits += 1;
+            hits += 1;
+            return (file);
+        } else if (hasSlash) {
+            /*
+             * If the file has a leading path component and that component
+             * exactly matches the entire name of the current search
+             * directory, we assume the file doesn't exist and return NULL.
+             */
+            for (p1 = p->name, p2 = name; *p1 && *p1 == *p2; p1++, p2++) {
+                continue;
+            }
+            if (*p1 == '\0' && p2 == cp - 1) {
+                if (DEBUG(DIR)) {
+                    printf("must be here but isn't -- returing NULL\n");
+                }
+                Lst_Close (path);
+                return ((char *) NULL);
+            }
+        }
     }
 
@@ -803 +804 @@
      */
     if (!hasSlash) {
-        if (DEBUG(DIR)) {
-            printf("failed.\n");
-        }
-        misses += 1;
-        return ((char *) NULL);
+        if (DEBUG(DIR)) {
+            printf("failed.\n");
+        }
+        misses += 1;
+        return ((char *) NULL);
     }
 
     if (*name != '/') {
-        Boolean checkedDot = FALSE;
-
-        if (DEBUG(DIR)) {
-            printf("failed. Trying subdirectories...");
-        }
-        (void) Lst_Open (path);
-        while ((ln = Lst_Next (path)) != NILLNODE) {
-            p = (Path *) Lst_Datum (ln);
-            if (p != dot) {
-                file = str_concat (p->name, name, STR_ADDSLASH);
-            } else {
-                /*
-                 * Checking in dot -- DON'T put a leading ./ on the thing.
-                 */
-                file = estrdup(name);
-                checkedDot = TRUE;
-            }
-            if (DEBUG(DIR)) {
-                printf("checking %s...", file);
-            }
-
-
-            if (stat (file, &stb) == 0) {
-                if (DEBUG(DIR)) {
-                    printf("got it.\n");
-                }
-
-                Lst_Close (path);
-
-                /*
-                 * We've found another directory to search. We know there's
-                 * a slash in 'file' because we put one there. We nuke it after
-                 * finding it and call Dir_AddDir to add this new directory
-                 * onto the existing search path. Once that's done, we restore
-                 * the slash and triumphantly return the file name, knowing
-                 * that should a file in this directory every be referenced
-                 * again in such a manner, we will find it without having to do
-                 * numerous numbers of access calls. Hurrah!
-                 */
-                cp = strrchr (file, '/');
-                *cp = '\0';
-                Dir_AddDir (path, file);
-                *cp = '/';
-
-                /*
-                 * Save the modification time so if it's needed, we don't have
-                 * to fetch it again.
-                 */
-                if (DEBUG(DIR)) {
-                    printf("Caching %s for %s\n", Targ_FmtTime(stb.st_mtime),
-                            file);
-                }
-                entry = Hash_CreateEntry(&mtimes, (char *) file,
-                                         (Boolean *)NULL);
-                Hash_SetValue(entry, (long)stb.st_mtime);
-                nearmisses += 1;
-                return (file);
-            } else {
-                efree (file);
-            }
-        }
-
-        if (DEBUG(DIR)) {
-            printf("failed. ");
-        }
-        Lst_Close (path);
-
-        if (checkedDot) {
-            /*
-             * Already checked by the given name, since . was in the path,
-             * so no point in proceeding...
-             */
-            if (DEBUG(DIR)) {
-                printf("Checked . already, returning NULL\n");
-            }
-            return(NULL);
-        }
+        Boolean checkedDot = FALSE;
+
+        if (DEBUG(DIR)) {
+            printf("failed. Trying subdirectories...");
+        }
+        (void) Lst_Open (path);
+        while ((ln = Lst_Next (path)) != NILLNODE) {
+            p = (Path *) Lst_Datum (ln);
+            if (p != dot) {
+                file = str_concat (p->name, name, STR_ADDSLASH);
+            } else {
+                /*
+                 * Checking in dot -- DON'T put a leading ./ on the thing.
+                 */
+                file = estrdup(name);
+                checkedDot = TRUE;
+            }
+            if (DEBUG(DIR)) {
+                printf("checking %s...", file);
+            }
+
+
+            if (stat (file, &stb) == 0) {
+                if (DEBUG(DIR)) {
+                    printf("got it.\n");
+                }
+
+                Lst_Close (path);
+
+                /*
+                 * We've found another directory to search. We know there's
+                 * a slash in 'file' because we put one there. We nuke it after
+                 * finding it and call Dir_AddDir to add this new directory
+                 * onto the existing search path. Once that's done, we restore
+                 * the slash and triumphantly return the file name, knowing
+                 * that should a file in this directory every be referenced
+                 * again in such a manner, we will find it without having to do
+                 * numerous numbers of access calls. Hurrah!
+                 */
+                cp = strrchr (file, '/');
+                *cp = '\0';
+                Dir_AddDir (path, file);
+                *cp = '/';
+
+                /*
+                 * Save the modification time so if it's needed, we don't have
+                 * to fetch it again.
+                 */
+                if (DEBUG(DIR)) {
+                    printf("Caching %s for %s\n", Targ_FmtTime(stb.st_mtime),
+                            file);
+                }
+                entry = Hash_CreateEntry(&mtimes, (char *) file,
+                                         (Boolean *)NULL);
+                Hash_SetValue(entry, (long)stb.st_mtime);
+                nearmisses += 1;
+                return (file);
+            } else {
+                efree (file);
+            }
+        }
+
+        if (DEBUG(DIR)) {
+            printf("failed. ");
+        }
+        Lst_Close (path);
+
+        if (checkedDot) {
+            /*
+             * Already checked by the given name, since . was in the path,
+             * so no point in proceeding...
+             */
+            if (DEBUG(DIR)) {
+                printf("Checked . already, returning NULL\n");
+            }
+            return(NULL);
+        }
     }
 
@@ -915 +916 @@
     ln = Lst_Last (path);
     if (ln == NILLNODE) {
-        return ((char *) NULL);
+        return ((char *) NULL);
     } else {
-        p = (Path *) Lst_Datum (ln);
+        p = (Path *) Lst_Datum (ln);
     }
 
     if (Hash_FindEntry (&p->files, cp) != (Hash_Entry *)NULL) {
-        return (estrdup (name));
+        return (estrdup (name));
     } else {
-        return ((char *) NULL);
+        return ((char *) NULL);
     }
 #else /* !notdef */
     if (DEBUG(DIR)) {
-        printf("Looking for \"%s\"...", name);
+        printf("Looking for \"%s\"...", name);
     }
 
@@ -933 +934 @@
     entry = Hash_FindEntry(&mtimes, name);
     if (entry != (Hash_Entry *)NULL) {
-        if (DEBUG(DIR)) {
-            printf("got it (in mtime cache)\n");
-        }
-        return(estrdup(name));
+        if (DEBUG(DIR)) {
+            printf("got it (in mtime cache)\n");
+        }
+        return(estrdup(name));
     } else if (stat (name, &stb) == 0) {
-        entry = Hash_CreateEntry(&mtimes, name, (Boolean *)NULL);
-        if (DEBUG(DIR)) {
-            printf("Caching %s for %s\n", Targ_FmtTime(stb.st_mtime),
-                    name);
-        }
-        Hash_SetValue(entry, (long)stb.st_mtime);
-        return (estrdup (name));
+        entry = Hash_CreateEntry(&mtimes, name, (Boolean *)NULL);
+        if (DEBUG(DIR)) {
+            printf("Caching %s for %s\n", Targ_FmtTime(stb.st_mtime),
+                    name);
+        }
+        Hash_SetValue(entry, (long)stb.st_mtime);
+        return (estrdup (name));
     } else {
-        if (DEBUG(DIR)) {
-            printf("failed. Returning NULL\n");
-        }
-        return ((char *)NULL);
+        if (DEBUG(DIR)) {
+            printf("failed. Returning NULL\n");
+        }
+        return ((char *)NULL);
     }
 #endif /* notdef */
@@ -957 +958 @@
  *-----------------------------------------------------------------------
  * Dir_MTime  --
- *      Find the modification time of the file described by gn along the
- *      search path dirSearchPath.
- *
- * Results:
- *      The modification time or 0 if it doesn't exist
- *
- * Side Effects:
- *      The modification time is placed in the node's mtime slot.
- *      If the node didn't have a path entry before, and Dir_FindFile
- *      found one for it, the full name is placed in the path slot.
+ *      Find the modification time of the file described by gn along the
+ *      search path dirSearchPath.
+ *
+ * Results:
+ *      The modification time or 0 if it doesn't exist
+ *
+ * Side Effects:
+ *      The modification time is placed in the node's mtime slot.
+ *      If the node didn't have a path entry before, and Dir_FindFile
+ *      found one for it, the full name is placed in the path slot.
  *-----------------------------------------------------------------------
  */
 int
 Dir_MTime (gn)
-    GNode         *gn;        /* the file whose modification time is
-                               * desired */
+    GNode         *gn;        /* the file whose modification time is
+                               * desired */
 {
     char          *fullName;  /* the full pathname of name */
-    struct stat   stb;        /* buffer for finding the mod time */
-    Hash_Entry    *entry;
+    struct stat   stb;        /* buffer for finding the mod time */
+    Hash_Entry    *entry;
 
     #ifdef USE_ARCHIVES
     if (gn->type & OP_ARCHV) {
-        return Arch_MTime (gn);
+        return Arch_MTime (gn);
     } else
     #endif
         if (gn->path == (char *)NULL) {
-        fullName = Dir_FindFile (gn->name, dirSearchPath);
+        fullName = Dir_FindFile (gn->name, dirSearchPath);
     } else {
-        fullName = gn->path;
+        fullName = gn->path;
     }
 
     if (fullName == (char *)NULL) {
-        fullName = estrdup(gn->name);
+        fullName = estrdup(gn->name);
     }
 
     entry = Hash_FindEntry(&mtimes, fullName);
     if (entry != (Hash_Entry *)NULL) {
-        /*
-         * Only do this once -- the second time folks are checking to
-         * see if the file was actually updated, so we need to actually go
-         * to the file system.
-         */
-        if (DEBUG(DIR)) {
-            printf("Using cached time %s for %s\n",
-                    Targ_FmtTime((time_t)(long)Hash_GetValue(entry)), fullName);
-        }
-        stb.st_mtime = (time_t)(long)Hash_GetValue(entry);
-        Hash_DeleteEntry(&mtimes, entry);
+        /*
+         * Only do this once -- the second time folks are checking to
+         * see if the file was actually updated, so we need to actually go
+         * to the file system.
+         */
+        if (DEBUG(DIR)) {
+            printf("Using cached time %s for %s\n",
+                    Targ_FmtTime((time_t)(long)Hash_GetValue(entry)), fullName);
+        }
+        stb.st_mtime = (time_t)(long)Hash_GetValue(entry);
+        Hash_DeleteEntry(&mtimes, entry);
     } else if (stat (fullName, &stb) < 0) {
         #ifdef USE_ARCHIVES
-        if (gn->type & OP_MEMBER) {
-            if (fullName != gn->path)
-                efree(fullName);
-            return Arch_MemMTime (gn);
-        } else
+        if (gn->type & OP_MEMBER) {
+            if (fullName != gn->path)
+                efree(fullName);
+            return Arch_MemMTime (gn);
+        } else
         #endif
-            stb.st_mtime = 0;
+            stb.st_mtime = 0;
     }
     if (fullName && gn->path == (char *)NULL) {
-        gn->path = fullName;
+        gn->path = fullName;
     }
 
@@ -1027 +1028 @@
  *-----------------------------------------------------------------------
  * Dir_AddDir --
- *      Add the given name to the end of the given path. The order of
- *      the arguments is backwards so ParseDoDependency can do a
- *      Lst_ForEach of its list of paths...
- *
- * Results:
- *      none
- *
- * Side Effects:
- *      A structure is added to the list and the directory is
- *      read and hashed.
+ *      Add the given name to the end of the given path. The order of
+ *      the arguments is backwards so ParseDoDependency can do a
+ *      Lst_ForEach of its list of paths...
+ *
+ * Results:
+ *      none
+ *
+ * Side Effects:
+ *      A structure is added to the list and the directory is
+ *      read and hashed.
  *-----------------------------------------------------------------------
  */
 void
 Dir_AddDir (path, name)
-    Lst           path;       /* the path to which the directory should be
-                               * added */
+    Lst           path;       /* the path to which the directory should be
+                               * added */
     char          *name;      /* the name of the directory to add */
 {
-    LstNode       ln;         /* node in case Path structure is found */
-    register Path *p;         /* pointer to new Path structure */
-    DIR           *d;         /* for reading directory */
+    LstNode       ln;         /* node in case Path structure is found */
+    register Path *p;         /* pointer to new Path structure */
+    DIR           *d;         /* for reading directory */
     register struct dirent *dp; /* entry in directory */
 
     ln = Lst_Find (openDirectories, (ClientData)name, DirFindName);
     if (ln != NILLNODE) {
-        p = (Path *)Lst_Datum (ln);
-        if (Lst_Member(path, (ClientData)p) == NILLNODE) {
-            p->refCount += 1;
-            (void)Lst_AtEnd (path, (ClientData)p);
-        }
+        p = (Path *)Lst_Datum (ln);
+        if (Lst_Member(path, (ClientData)p) == NILLNODE) {
+            p->refCount += 1;
+            (void)Lst_AtEnd (path, (ClientData)p);
+        }
     } else {
-        if (DEBUG(DIR)) {
-            printf("Caching %s...", name);
-            fflush(stdout);
-        }
-
-        if ((d = opendir (name)) != (DIR *) NULL) {
-            p = (Path *) emalloc (sizeof (Path));
-            p->name = estrdup (name);
-            p->hits = 0;
-            p->refCount = 1;
-            Hash_InitTable (&p->files, -1);
-
-            while ((dp = readdir (d)) != (struct dirent *) NULL) {
+        if (DEBUG(DIR)) {
+            printf("Caching %s...", name);
+            fflush(stdout);
+        }
+
+        if ((d = opendir (name)) != (DIR *) NULL) {
+            p = (Path *) emalloc (sizeof (Path));
+            p->name = estrdup (name);
+            p->hits = 0;
+            p->refCount = 1;
+            Hash_InitTable (&p->files, -1);
+
+            while ((dp = readdir (d)) != (struct dirent *) NULL) {
 #if defined(sun) && defined(d_ino) /* d_ino is a sunos4 #define for d_fileno */
-                /*
-                 * The sun directory library doesn't check for a 0 inode
-                 * (0-inode slots just take up space), so we have to do
-                 * it ourselves.
-                 */
-                if (dp->d_fileno == 0) {
-                    continue;
-                }
+                /*
+                 * The sun directory library doesn't check for a 0 inode
+                 * (0-inode slots just take up space), so we have to do
+                 * it ourselves.
+                 */
+                if (dp->d_fileno == 0) {
+                    continue;
+                }
 #endif /* sun && d_ino */
 
-                /* Skip the '.' and '..' entries by checking for them
-                 * specifically instead of assuming readdir() reuturns them in
-                 * that order when first going through a directory.  This is
-                 * needed for XFS over NFS filesystems since SGI does not
-                 * guarantee that these are * the first two entries returned
-                 * from readdir().
-                 */
-                if (ISDOT(dp->d_name) || ISDOTDOT(dp->d_name))
-                        continue;
-
-                (void)Hash_CreateEntry(&p->files, dp->d_name, (Boolean *)NULL);
-            }
-            (void) closedir (d);
-            (void)Lst_AtEnd (openDirectories, (ClientData)p);
-            (void)Lst_AtEnd (path, (ClientData)p);
-        }
-        if (DEBUG(DIR)) {
-            printf("done\n");
-        }
+                /* Skip the '.' and '..' entries by checking for them
+                 * specifically instead of assuming readdir() reuturns them in
+                 * that order when first going through a directory.  This is
+                 * needed for XFS over NFS filesystems since SGI does not
+                 * guarantee that these are * the first two entries returned
+                 * from readdir().
+                 */
+                if (ISDOT(dp->d_name) || ISDOTDOT(dp->d_name))
+                        continue;
+
+                (void)Hash_CreateEntry(&p->files, dp->d_name, (Boolean *)NULL);
+            }
+            (void) closedir (d);
+            (void)Lst_AtEnd (openDirectories, (ClientData)p);
+            (void)Lst_AtEnd (path, (ClientData)p);
+        }
+        if (DEBUG(DIR)) {
+            printf("done\n");
+        }
     }
 }
@@ -1107 +1108 @@
  *-----------------------------------------------------------------------
  * Dir_CopyDir --
- *      Callback function for duplicating a search path via Lst_Duplicate.
- *      Ups the reference count for the directory.
- *
- * Results:
- *      Returns the Path it was given.
- *
- * Side Effects:
- *      The refCount of the path is incremented.
+ *      Callback function for duplicating a search path via Lst_Duplicate.
+ *      Ups the reference count for the directory.
+ *
+ * Results:
+ *      Returns the Path it was given.
+ *
+ * Side Effects:
+ *      The refCount of the path is incremented.
  *
  *-----------------------------------------------------------------------
@@ -1130 +1131 @@
  *-----------------------------------------------------------------------
  * Dir_MakeFlags --
- *      Make a string by taking all the directories in the given search
- *      path and preceding them by the given flag. Used by the suffix
- *      module to create variables for compilers based on suffix search
- *      paths.
- *
- * Results:
- *      The string mentioned above. Note that there is no space between
- *      the given flag and each directory. The empty string is returned if
- *      Things don't go well.
- *
- * Side Effects:
- *      None
+ *      Make a string by taking all the directories in the given search
+ *      path and preceding them by the given flag. Used by the suffix
+ *      module to create variables for compilers based on suffix search
+ *      paths.
+ *
+ * Results:
+ *      The string mentioned above. Note that there is no space between
+ *      the given flag and each directory. The empty string is returned if
+ *      Things don't go well.
+ *
+ * Side Effects:
+ *      None
  *-----------------------------------------------------------------------
  */
 char *
 Dir_MakeFlags (flag, path)
-    char          *flag;  /* flag which should precede each directory */
-    Lst           path;   /* list of directories */
-{
-    char          *str;   /* the string which will be returned */
-    char          *tstr;  /* the current directory preceded by 'flag' */
-    LstNode       ln;     /* the node of the current directory */
-    Path          *p;     /* the structure describing the current directory */
+    char          *flag;  /* flag which should precede each directory */
+    Lst           path;   /* list of directories */
+{
+    char          *str;   /* the string which will be returned */
+    char          *tstr;  /* the current directory preceded by 'flag' */
+    LstNode       ln;     /* the node of the current directory */
+    Path          *p;     /* the structure describing the current directory */
 
     str = estrdup ("");
 
     if (Lst_Open (path) == SUCCESS) {
-        while ((ln = Lst_Next (path)) != NILLNODE) {
-            p = (Path *) Lst_Datum (ln);
-            tstr = str_concat (flag, p->name, 0);
-            str = str_concat (str, tstr, STR_ADDSPACE | STR_DOFREE);
-        }
-        Lst_Close (path);
+        while ((ln = Lst_Next (path)) != NILLNODE) {
+            p = (Path *) Lst_Datum (ln);
+            tstr = str_concat (flag, p->name, 0);
+            str = str_concat (str, tstr, STR_ADDSPACE | STR_DOFREE);
+        }
+        Lst_Close (path);
     }
 
@@ -1171 +1172 @@
  *-----------------------------------------------------------------------
  * Dir_Destroy --
- *      Nuke a directory descriptor, if possible. Callback procedure
- *      for the suffixes module when destroying a search path.
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      If no other path references this directory (refCount == 0),
- *      the Path and all its data are freed.
+ *      Nuke a directory descriptor, if possible. Callback procedure
+ *      for the suffixes module when destroying a search path.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      If no other path references this directory (refCount == 0),
+ *      the Path and all its data are freed.
  *
  *-----------------------------------------------------------------------
@@ -1185 +1186 @@
 void
 Dir_Destroy (pp)
-    ClientData    pp;       /* The directory descriptor to nuke */
-{
-    Path          *p = (Path *) pp;
+    ClientData    pp;       /* The directory descriptor to nuke */
+{
+    Path          *p = (Path *) pp;
     p->refCount -= 1;
 
     if (p->refCount == 0) {
-        LstNode ln;
-
-        ln = Lst_Member (openDirectories, (ClientData)p);
-        (void) Lst_Remove (openDirectories, ln);
-
-        Hash_DeleteTable (&p->files);
-        efree((Address)p->name);
-        efree((Address)p);
+        LstNode ln;
+
+        ln = Lst_Member (openDirectories, (ClientData)p);
+        (void) Lst_Remove (openDirectories, ln);
+
+        Hash_DeleteTable (&p->files);
+        efree((Address)p->name);
+        efree((Address)p);
     }
 }
@@ -1205 +1206 @@
  *-----------------------------------------------------------------------
  * Dir_ClearPath --
- *      Clear out all elements of the given search path. This is different
- *      from destroying the list, notice.
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      The path is set to the empty list.
+ *      Clear out all elements of the given search path. This is different
+ *      from destroying the list, notice.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      The path is set to the empty list.
  *
  *-----------------------------------------------------------------------
@@ -1218 +1219 @@
 void
 Dir_ClearPath(path)
-    Lst     path;       /* Path to clear */
+    Lst     path;       /* Path to clear */
 {
     Path    *p;
     while (!Lst_IsEmpty(path)) {
-        p = (Path *)Lst_DeQueue(path);
-        Dir_Destroy((ClientData) p);
+        p = (Path *)Lst_DeQueue(path);
+        Dir_Destroy((ClientData) p);
     }
 }
@@ -1231 +1232 @@
  *-----------------------------------------------------------------------
  * Dir_Concat --
- *      Concatenate two paths, adding the second to the end of the first.
- *      Makes sure to avoid duplicates.
- *
- * Results:
- *      None
- *
- * Side Effects:
- *      Reference counts for added dirs are upped.
+ *      Concatenate two paths, adding the second to the end of the first.
+ *      Makes sure to avoid duplicates.
+ *
+ * Results:
+ *      None
+ *
+ * Side Effects:
+ *      Reference counts for added dirs are upped.
  *
  *-----------------------------------------------------------------------
@@ -1244 +1245 @@
 void
 Dir_Concat(path1, path2)
-    Lst     path1;      /* Dest */
-    Lst     path2;      /* Source */
+    Lst     path1;      /* Dest */
+    Lst     path2;      /* Source */
 {
     LstNode ln;
@@ -1251 +1252 @@
 
     for (ln = Lst_First(path2); ln != NILLNODE; ln = Lst_Succ(ln)) {
-        p = (Path *)Lst_Datum(ln);
-        if (Lst_Member(path1, (ClientData)p) == NILLNODE) {
-            p->refCount += 1;
-            (void)Lst_AtEnd(path1, (ClientData)p);
-        }
+        p = (Path *)Lst_Datum(ln);
+        if (Lst_Member(path1, (ClientData)p) == NILLNODE) {
+            p->refCount += 1;
+            (void)Lst_AtEnd(path1, (ClientData)p);
+        }
     }
 }
@@ -1263 +1264 @@
 Dir_PrintDirectories()
 {
-    LstNode     ln;
-    Path        *p;
+    LstNode     ln;
+    Path        *p;
 
     printf ("#*** Directory Cache:\n");
     printf ("# Stats: %d hits %d misses %d near misses %d losers (%d%%)\n",
-              hits, misses, nearmisses, bigmisses,
-              (hits+bigmisses+nearmisses ?
-               hits * 100 / (hits + bigmisses + nearmisses) : 0));
+              hits, misses, nearmisses, bigmisses,
+              (hits+bigmisses+nearmisses ?
+               hits * 100 / (hits + bigmisses + nearmisses) : 0));
     printf ("# %-20s referenced\thits\n", "directory");
     if (Lst_Open (openDirectories) == SUCCESS) {
-        while ((ln = Lst_Next (openDirectories)) != NILLNODE) {
-            p = (Path *) Lst_Datum (ln);
-            printf ("# %-20s %10d\t%4d\n", p->name, p->refCount, p->hits);
-        }
-        Lst_Close (openDirectories);
+        while ((ln = Lst_Next (openDirectories)) != NILLNODE) {
+            p = (Path *) Lst_Datum (ln);
+            printf ("# %-20s %10d\t%4d\n", p->name, p->refCount, p->hits);
+        }
+        Lst_Close (openDirectories);
     }
 }
 
 static int DirPrintDir (p, dummy)
-    ClientData  p;
-    ClientData  dummy;
+    ClientData  p;
+    ClientData  dummy;
 {
     printf ("%s ", ((Path *) p)->name);
@@ -1291 +1292 @@
 void
 Dir_PrintPath (path)
-    Lst path;
+    Lst path;
 {
     Lst_ForEach (path, DirPrintDir, (ClientData)0);

trunk/src/kmk/for.c

@@ -13 +13 @@
  * 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
@@ -34 +34 @@
 #ifndef lint
 #if 0
-static char sccsid[] = "@(#)for.c       8.1 (Berkeley) 6/6/93";
+static char sccsid[] = "@(#)for.c       8.1 (Berkeley) 6/6/93";
 #else
 static const char rcsid[] =
   "$FreeBSD: src/usr.bin/make/for.c,v 1.10 1999/09/11 13:08:01 hoek Exp $";
 #endif
+#define KLIBFILEDEF rcsid
 #endif /* not lint */
 
 /*-
  * for.c --
- *      Functions to handle loops in a makefile.
+ *      Functions to handle loops in a makefile.
  *
  * Interface:
- *      For_Eval        Evaluate the loop in the passed line.
- *      For_Run         Run accumulated loop
+ *      For_Eval        Evaluate the loop in the passed line.
+ *      For_Run         Run accumulated loop
  *
  */
@@ -71 +72 @@
  */
 
-static int        forLevel = 0;         /* Nesting level        */
-static char      *forVar;               /* Iteration variable   */
-static Buffer     forBuf;               /* Commands in loop     */
-static Lst        forLst;               /* List of items        */
+static int        forLevel = 0;         /* Nesting level        */
+static char      *forVar;               /* Iteration variable   */
+static Buffer     forBuf;               /* Commands in loop     */
+static Lst        forLst;               /* List of items        */
 
 /*
@@ -80 +81 @@
  */
 typedef struct _For {
-    Buffer        buf;                  /* Unexpanded buffer    */
-    char*         var;                  /* Index name           */
-    Lst           lst;                  /* List of variables    */
+    Buffer        buf;                  /* Unexpanded buffer    */
+    char*         var;                  /* Index name           */
+    Lst           lst;                  /* List of variables    */
 } For;
 
-static int ForExec      __P((ClientData, ClientData));
+static int ForExec      __P((ClientData, ClientData));
 
 
@@ -94 +95 @@
  *-----------------------------------------------------------------------
  * For_Eval --
- *      Evaluate the for loop in the passed line. The line
- *      looks like this:
- *          .for <variable> in <varlist>
+ *      Evaluate the for loop in the passed line. The line
+ *      looks like this:
+ *          .for <variable> in <varlist>
  *
  * Results:
- *      TRUE: We found a for loop, or we are inside a for loop
- *      FALSE: We did not find a for loop, or we found the end of the for
- *             for loop.
+ *      TRUE: We found a for loop, or we are inside a for loop
+ *      FALSE: We did not find a for loop, or we found the end of the for
+ *             for loop.
  *
  * Side Effects:
- *      None.
+ *      None.
  *
  *-----------------------------------------------------------------------
@@ -110 +111 @@
 int
 For_Eval (line)
-    char            *line;    /* Line to parse */
+    char            *line;    /* Line to parse */
 {
-    char            *ptr = line, *sub, *wrd;
-    int             level;      /* Level at which to report errors. */
+    char            *ptr = line, *sub, *wrd;
+    int             level;      /* Level at which to report errors. */
 
     level = PARSE_FATAL;
@@ -119 +120 @@
 
     if (forLevel == 0) {
-        Buffer      buf;
-        int         varlen;
-
-        for (ptr++; *ptr && isspace((unsigned char) *ptr); ptr++)
-            continue;
-        /*
-         * If we are not in a for loop quickly determine if the statement is
-         * a for.
-         */
-        if (ptr[0] != 'f' || ptr[1] != 'o' || ptr[2] != 'r' ||
-            !isspace((unsigned char) ptr[3]))
-            return FALSE;
-        ptr += 3;
-
-        /*
-         * we found a for loop, and now we are going to parse it.
-         */
-        while (*ptr && isspace((unsigned char) *ptr))
-            ptr++;
-
-        /*
-         * Grab the variable
-         */
-        buf = Buf_Init(0);
-        for (wrd = ptr; *ptr && !isspace((unsigned char) *ptr); ptr++)
-            continue;
-        Buf_AddBytes(buf, ptr - wrd, (Byte *) wrd);
-
-        forVar = (char *) Buf_GetAll(buf, &varlen);
-        if (varlen == 0) {
-            Parse_Error (level, "missing variable in for");
-            return 0;
-        }
-        Buf_Destroy(buf, FALSE);
-
-        while (*ptr && isspace((unsigned char) *ptr))
-            ptr++;
-
-        /*
-         * Grab the `in'
-         */
-        if (ptr[0] != 'i' || ptr[1] != 'n' ||
-            !isspace((unsigned char) ptr[2])) {
-            Parse_Error (level, "missing `in' in for");
-            printf("%s\n", ptr);
-            return 0;
-        }
-        ptr += 3;
-
-        while (*ptr && isspace((unsigned char) *ptr))
-            ptr++;
-
-        /*
-         * Make a list with the remaining words
-         */
-        forLst = Lst_Init(FALSE);
-        buf = Buf_Init(0);
-        sub = Var_Subst(NULL, ptr, VAR_GLOBAL, FALSE);
+        Buffer      buf;
+        int         varlen;
+
+        for (ptr++; *ptr && isspace((unsigned char) *ptr); ptr++)
+            continue;
+        /*
+         * If we are not in a for loop quickly determine if the statement is
+         * a for.
+         */
+        if (ptr[0] != 'f' || ptr[1] != 'o' || ptr[2] != 'r' ||
+            !isspace((unsigned char) ptr[3]))
+            return FALSE;
+        ptr += 3;
+
+        /*
+         * we found a for loop, and now we are going to parse it.
+         */
+        while (*ptr && isspace((unsigned char) *ptr))
+            ptr++;
+
+        /*
+         * Grab the variable
+         */
+        buf = Buf_Init(0);
+        for (wrd = ptr; *ptr && !isspace((unsigned char) *ptr); ptr++)
+            continue;
+        Buf_AddBytes(buf, ptr - wrd, (Byte *) wrd);
+
+        forVar = (char *) Buf_GetAll(buf, &varlen);
+        if (varlen == 0) {
+            Parse_Error (level, "missing variable in for");
+            return 0;
+        }
+        Buf_Destroy(buf, FALSE);
+
+        while (*ptr && isspace((unsigned char) *ptr))
+            ptr++;
+
+        /*
+         * Grab the `in'
+         */
+        if (ptr[0] != 'i' || ptr[1] != 'n' ||
+            !isspace((unsigned char) ptr[2])) {
+            Parse_Error (level, "missing `in' in for");
+            printf("%s\n", ptr);
+            return 0;
+        }
+        ptr += 3;
+
+        while (*ptr && isspace((unsigned char) *ptr))
+            ptr++;
+
+        /*
+         * Make a list with the remaining words
+         */
+        forLst = Lst_Init(FALSE);
+        buf = Buf_Init(0);
+        sub = Var_Subst(NULL, ptr, VAR_GLOBAL, FALSE);
 
 #define ADDWORD() \
-        Buf_AddBytes(buf, ptr - wrd, (Byte *) wrd), \
-        Buf_AddByte(buf, (Byte) '\0'), \
-        Lst_AtFront(forLst, (ClientData) Buf_GetAll(buf, &varlen)), \
-        Buf_Destroy(buf, FALSE)
-
-        for (ptr = sub; *ptr && isspace((unsigned char) *ptr); ptr++)
-            continue;
-
-        for (wrd = ptr; *ptr; ptr++)
-            if (isspace((unsigned char) *ptr)) {
-                ADDWORD();
-                buf = Buf_Init(0);
-                while (*ptr && isspace((unsigned char) *ptr))
-                    ptr++;
-                wrd = ptr--;
-            }
-        if (DEBUG(FOR))
-            (void) fprintf(stderr, "For: Iterator %s List %s\n", forVar, sub);
-        if (ptr - wrd > 0)
-            ADDWORD();
-        else
-            Buf_Destroy(buf, TRUE);
-        efree((Address) sub);
-
-        forBuf = Buf_Init(0);
-        forLevel++;
-        return 1;
+        Buf_AddBytes(buf, ptr - wrd, (Byte *) wrd), \
+        Buf_AddByte(buf, (Byte) '\0'), \
+        Lst_AtFront(forLst, (ClientData) Buf_GetAll(buf, &varlen)), \
+        Buf_Destroy(buf, FALSE)
+
+        for (ptr = sub; *ptr && isspace((unsigned char) *ptr); ptr++)
+            continue;
+
+        for (wrd = ptr; *ptr; ptr++)
+            if (isspace((unsigned char) *ptr)) {
+                ADDWORD();
+                buf = Buf_Init(0);
+                while (*ptr && isspace((unsigned char) *ptr))
+                    ptr++;
+                wrd = ptr--;
+            }
+        if (DEBUG(FOR))
+            (void) fprintf(stderr, "For: Iterator %s List %s\n", forVar, sub);
+        if (ptr - wrd > 0)
+            ADDWORD();
+        else
+            Buf_Destroy(buf, TRUE);
+        efree((Address) sub);
+
+        forBuf = Buf_Init(0);
+        forLevel++;
+        return 1;
     }
     else if (*ptr == '.') {
 
-        for (ptr++; *ptr && isspace((unsigned char) *ptr); ptr++)
-            continue;
-
-        if (strncmp(ptr, "endfor", 6) == 0 &&
-            (isspace((unsigned char) ptr[6]) || !ptr[6])) {
-            if (DEBUG(FOR))
-                (void) fprintf(stderr, "For: end for %d\n", forLevel);
-            if (--forLevel < 0) {
-                Parse_Error (level, "for-less endfor");
-                return 0;
-            }
-        }
-        else if (strncmp(ptr, "for", 3) == 0 &&
-                 isspace((unsigned char) ptr[3])) {
-            forLevel++;
-            if (DEBUG(FOR))
-                (void) fprintf(stderr, "For: new loop %d\n", forLevel);
-        }
+        for (ptr++; *ptr && isspace((unsigned char) *ptr); ptr++)
+            continue;
+
+        if (strncmp(ptr, "endfor", 6) == 0 &&
+            (isspace((unsigned char) ptr[6]) || !ptr[6])) {
+            if (DEBUG(FOR))
+                (void) fprintf(stderr, "For: end for %d\n", forLevel);
+            if (--forLevel < 0) {
+                Parse_Error (level, "for-less endfor");
+                return 0;
+            }
+        }
+        else if (strncmp(ptr, "for", 3) == 0 &&
+                 isspace((unsigned char) ptr[3])) {
+            forLevel++;
+            if (DEBUG(FOR))
+                (void) fprintf(stderr, "For: new loop %d\n", forLevel);
+        }
     }
 
     if (forLevel != 0) {
-        Buf_AddBytes(forBuf, strlen(line), (Byte *) line);
-        Buf_AddByte(forBuf, (Byte) '\n');
-        return 1;
+        Buf_AddBytes(forBuf, strlen(line), (Byte *) line);
+        Buf_AddByte(forBuf, (Byte) '\n');
+        return 1;
     }
     else {
-        return 0;
+        return 0;
     }
 }
@@ -242 +243 @@
  *-----------------------------------------------------------------------
  * ForExec --
- *      Expand the for loop for this index and push it in the Makefile
+ *      Expand the for loop for this index and push it in the Makefile
  *
  * Results:
- *      None.
+ *      None.
  *
  * Side Effects:
- *      None.
+ *      None.
  *
  *-----------------------------------------------------------------------
@@ -262 +263 @@
     Var_Set(arg->var, name, VAR_GLOBAL);
     if (DEBUG(FOR))
-        (void) fprintf(stderr, "--- %s = %s\n", arg->var, name);
+        (void) fprintf(stderr, "--- %s = %s\n", arg->var, name);
     Parse_FromString(Var_Subst(arg->var, (char *) Buf_GetAll(arg->buf, &len),
-                               VAR_GLOBAL, FALSE));
+                               VAR_GLOBAL, FALSE));
     Var_Delete(arg->var, VAR_GLOBAL);
 
@@ -275 +276 @@
  *-----------------------------------------------------------------------
  * For_Run --
- *      Run the for loop, immitating the actions of an include file
+ *      Run the for loop, immitating the actions of an include file
  *
  * Results:
- *      None.
+ *      None.
  *
  * Side Effects:
- *      None.
+ *      None.
  *
  *-----------------------------------------------------------------------
@@ -291 +292 @@
 
     if (forVar == NULL || forBuf == NULL || forLst == NULL)
-        return;
+        return;
     arg.var = forVar;
     arg.buf = forBuf;

trunk/src/kmk/hash.c

@@ -18 +18 @@
  * 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
@@ -39 +39 @@
 #ifndef lint
 #if 0
-static char sccsid[] = "@(#)hash.c      8.1 (Berkeley) 6/6/93";
+static char sccsid[] = "@(#)hash.c      8.1 (Berkeley) 6/6/93";
 #else
 static const char rcsid[] =
   "$FreeBSD: src/usr.bin/make/hash.c,v 1.9 1999/09/11 13:08:01 hoek Exp $";
 #endif
+#define KLIBFILEDEF rcsid
 #endif /* not lint */
 
 /* hash.c --
  *
- *      This module contains routines to manipulate a hash table.
- *      See hash.h for a definition of the structure of the hash
- *      table.  Hash tables grow automatically as the amount of
- *      information increases.
+ *      This module contains routines to manipulate a hash table.
+ *      See hash.h for a definition of the structure of the hash
+ *      table.  Hash tables grow automatically as the amount of
+ *      information increases.
  */
 #include "sprite.h"
@@ -76 +77 @@
  * Hash_InitTable --
  *
- *      This routine just sets up the hash table.
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      Memory is allocated for the initial bucket area.
+ *      This routine just sets up the hash table.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      Memory is allocated for the initial bucket area.
  *
  *---------------------------------------------------------
@@ -89 +90 @@
 void
 Hash_InitTable(t, numBuckets)
-        register Hash_Table *t; /* Structure to use to hold table. */
-        int numBuckets;         /* How many buckets to create for starters.
-                                 * This number is rounded up to a power of
-                                 * two.   If <= 0, a reasonable default is
-                                 * chosen. The table will grow in size later
-                                 * as needed. */
-{
-        register int i;
-        register struct Hash_Entry **hp;
-
-        /*
-         * Round up the size to a power of two.
-         */
-        if (numBuckets <= 0)
-                i = 16;
-        else {
-                for (i = 2; i < numBuckets; i <<= 1)
-                         continue;
-        }
-        t->numEntries = 0;
-        t->size = i;
-        t->mask = i - 1;
-        t->bucketPtr = hp = (struct Hash_Entry **)emalloc(sizeof(*hp) * i);
-        while (--i >= 0)
-                *hp++ = NULL;
+        register Hash_Table *t; /* Structure to use to hold table. */
+        int numBuckets;         /* How many buckets to create for starters.
+                                 * This number is rounded up to a power of
+                                 * two.   If <= 0, a reasonable default is
+                                 * chosen. The table will grow in size later
+                                 * as needed. */
+{
+        register int i;
+        register struct Hash_Entry **hp;
+
+        /*
+         * Round up the size to a power of two.
+         */
+        if (numBuckets <= 0)
+                i = 16;
+        else {
+                for (i = 2; i < numBuckets; i <<= 1)
+                         continue;
+        }
+        t->numEntries = 0;
+        t->size = i;
+        t->mask = i - 1;
+        t->bucketPtr = hp = (struct Hash_Entry **)emalloc(sizeof(*hp) * i);
+        while (--i >= 0)
+                *hp++ = NULL;
 }
 
@@ -121 +122 @@
  * Hash_DeleteTable --
  *
- *      This routine removes everything from a hash table
- *      and frees up the memory space it occupied (except for
- *      the space in the Hash_Table structure).
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      Lots of memory is freed up.
+ *      This routine removes everything from a hash table
+ *      and frees up the memory space it occupied (except for
+ *      the space in the Hash_Table structure).
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      Lots of memory is freed up.
  *
  *---------------------------------------------------------
@@ -136 +137 @@
 void
 Hash_DeleteTable(t)
-        Hash_Table *t;
-{
-        register struct Hash_Entry **hp, *h, *nexth = NULL;
-        register int i;
-
-        for (hp = t->bucketPtr, i = t->size; --i >= 0;) {
-                for (h = *hp++; h != NULL; h = nexth) {
-                        nexth = h->next;
-                        efree((char *)h);
-                }
-        }
-        efree((char *)t->bucketPtr);
-
-        /*
-         * Set up the hash table to cause memory faults on any future access
-         * attempts until re-initialization.
-         */
-        t->bucketPtr = NULL;
+        Hash_Table *t;
+{
+        register struct Hash_Entry **hp, *h, *nexth = NULL;
+        register int i;
+
+        for (hp = t->bucketPtr, i = t->size; --i >= 0;) {
+                for (h = *hp++; h != NULL; h = nexth) {
+                        nexth = h->next;
+                        efree((char *)h);
+                }
+        }
+        efree((char *)t->bucketPtr);
+
+        /*
+         * Set up the hash table to cause memory faults on any future access
+         * attempts until re-initialization.
+         */
+        t->bucketPtr = NULL;
 }
 
@@ -161 +162 @@
  * Hash_FindEntry --
  *
- *      Searches a hash table for an entry corresponding to key.
- *
- * Results:
- *      The return value is a pointer to the entry for key,
- *      if key was present in the table.  If key was not
- *      present, NULL is returned.
- *
- * Side Effects:
- *      None.
+ *      Searches a hash table for an entry corresponding to key.
+ *
+ * Results:
+ *      The return value is a pointer to the entry for key,
+ *      if key was present in the table.  If key was not
+ *      present, NULL is returned.
+ *
+ * Side Effects:
+ *      None.
  *
  *---------------------------------------------------------
@@ -176 +177 @@
 Hash_Entry *
 Hash_FindEntry(t, key)
-        Hash_Table *t;          /* Hash table to search. */
-        char *key;              /* A hash key. */
-{
-        register Hash_Entry *e;
-        register unsigned h;
-        register char *p;
-
-        for (h = 0, p = key; *p;)
-                h = (h << 5) - h + *p++;
-        p = key;
-        for (e = t->bucketPtr[h & t->mask]; e != NULL; e = e->next)
-                if (e->namehash == h && strcmp(e->name, p) == 0)
-                        return (e);
-        return (NULL);
+        Hash_Table *t;          /* Hash table to search. */
+        char *key;              /* A hash key. */
+{
+        register Hash_Entry *e;
+        register unsigned h;
+        register char *p;
+
+        for (h = 0, p = key; *p;)
+                h = (h << 5) - h + *p++;
+        p = key;
+        for (e = t->bucketPtr[h & t->mask]; e != NULL; e = e->next)
+                if (e->namehash == h && strcmp(e->name, p) == 0)
+                        return (e);
+        return (NULL);
 }
 
@@ -197 +198 @@
  * Hash_CreateEntry --
  *
- *      Searches a hash table for an entry corresponding to
- *      key.  If no entry is found, then one is created.
- *
- * Results:
- *      The return value is a pointer to the entry.  If *newPtr
- *      isn't NULL, then *newPtr is filled in with TRUE if a
- *      new entry was created, and FALSE if an entry already existed
- *      with the given key.
- *
- * Side Effects:
- *      Memory may be allocated, and the hash buckets may be modified.
+ *      Searches a hash table for an entry corresponding to
+ *      key.  If no entry is found, then one is created.
+ *
+ * Results:
+ *      The return value is a pointer to the entry.  If *newPtr
+ *      isn't NULL, then *newPtr is filled in with TRUE if a
+ *      new entry was created, and FALSE if an entry already existed
+ *      with the given key.
+ *
+ * Side Effects:
+ *      Memory may be allocated, and the hash buckets may be modified.
  *---------------------------------------------------------
  */
@@ -213 +214 @@
 Hash_Entry *
 Hash_CreateEntry(t, key, newPtr)
-        register Hash_Table *t; /* Hash table to search. */
-        char *key;              /* A hash key. */
-        Boolean *newPtr;        /* Filled in with TRUE if new entry created,
-                                 * FALSE otherwise. */
-{
-        register Hash_Entry *e;
-        register unsigned h;
-        register char *p;
-        int keylen;
-        struct Hash_Entry **hp;
-
-        /*
-         * Hash the key.  As a side effect, save the length (strlen) of the
-         * key in case we need to create the entry.
-         */
-        for (h = 0, p = key; *p;)
-                h = (h << 5) - h + *p++;
-        keylen = p - key;
-        p = key;
-        for (e = t->bucketPtr[h & t->mask]; e != NULL; e = e->next) {
-                if (e->namehash == h && strcmp(e->name, p) == 0) {
-                        if (newPtr != NULL)
-                                *newPtr = FALSE;
-                        return (e);
-                }
-        }
-
-        /*
-         * The desired entry isn't there.  Before allocating a new entry,
-         * expand the table if necessary (and this changes the resulting
-         * bucket chain).
-         */
-        if (t->numEntries >= rebuildLimit * t->size)
-                RebuildTable(t);
-        e = (Hash_Entry *) emalloc(sizeof(*e) + keylen);
-        hp = &t->bucketPtr[h & t->mask];
-        e->next = *hp;
-        *hp = e;
-        e->clientData = NULL;
-        e->namehash = h;
-        (void) strcpy(e->name, p);
-        t->numEntries++;
-
-        if (newPtr != NULL)
-                *newPtr = TRUE;
-        return (e);
+        register Hash_Table *t; /* Hash table to search. */
+        char *key;              /* A hash key. */
+        Boolean *newPtr;        /* Filled in with TRUE if new entry created,
+                                 * FALSE otherwise. */
+{
+        register Hash_Entry *e;
+        register unsigned h;
+        register char *p;
+        int keylen;
+        struct Hash_Entry **hp;
+
+        /*
+         * Hash the key.  As a side effect, save the length (strlen) of the
+         * key in case we need to create the entry.
+         */
+        for (h = 0, p = key; *p;)
+                h = (h << 5) - h + *p++;
+        keylen = p - key;
+        p = key;
+        for (e = t->bucketPtr[h & t->mask]; e != NULL; e = e->next) {
+                if (e->namehash == h && strcmp(e->name, p) == 0) {
+                        if (newPtr != NULL)
+                                *newPtr = FALSE;
+                        return (e);
+                }
+        }
+
+        /*
+         * The desired entry isn't there.  Before allocating a new entry,
+         * expand the table if necessary (and this changes the resulting
+         * bucket chain).
+         */
+        if (t->numEntries >= rebuildLimit * t->size)
+                RebuildTable(t);
+        e = (Hash_Entry *) emalloc(sizeof(*e) + keylen);
+        hp = &t->bucketPtr[h & t->mask];
+        e->next = *hp;
+        *hp = e;
+        e->clientData = NULL;
+        e->namehash = h;
+        (void) strcpy(e->name, p);
+        t->numEntries++;
+
+        if (newPtr != NULL)
+                *newPtr = TRUE;
+        return (e);
 }
 
@@ -266 +267 @@
  * Hash_DeleteEntry --
  *
- *      Delete the given hash table entry and efree memory associated with
- *      it.
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      Hash chain that entry lives in is modified and memory is freed.
+ *      Delete the given hash table entry and efree memory associated with
+ *      it.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      Hash chain that entry lives in is modified and memory is freed.
  *
  *---------------------------------------------------------
@@ -280 +281 @@
 void
 Hash_DeleteEntry(t, e)
-        Hash_Table *t;
-        Hash_Entry *e;
-{
-        register Hash_Entry **hp, *p;
-
-        if (e == NULL)
-                return;
-        for (hp = &t->bucketPtr[e->namehash & t->mask];
-             (p = *hp) != NULL; hp = &p->next) {
-                if (p == e) {
-                        *hp = p->next;
-                        efree((char *)p);
-                        t->numEntries--;
-                        return;
-                }
-        }
-        (void) write(2, "bad call to Hash_DeleteEntry\n", 29);
-        abort();
+        Hash_Table *t;
+        Hash_Entry *e;
+{
+        register Hash_Entry **hp, *p;
+
+        if (e == NULL)
+                return;
+        for (hp = &t->bucketPtr[e->namehash & t->mask];
+             (p = *hp) != NULL; hp = &p->next) {
+                if (p == e) {
+                        *hp = p->next;
+                        efree((char *)p);
+                        t->numEntries--;
+                        return;
+                }
+        }
+        (void) write(STDERR_FILENO, "bad call to Hash_DeleteEntry\n", 29);
+        abort();
 }
 
@@ -304 +305 @@
  *
  * Hash_EnumFirst --
- *      This procedure sets things up for a complete search
- *      of all entries recorded in the hash table.
- *
- * Results:
- *      The return value is the address of the first entry in
- *      the hash table, or NULL if the table is empty.
- *
- * Side Effects:
- *      The information in searchPtr is initialized so that successive
- *      calls to Hash_Next will return successive HashEntry's
- *      from the table.
+ *      This procedure sets things up for a complete search
+ *      of all entries recorded in the hash table.
+ *
+ * Results:
+ *      The return value is the address of the first entry in
+ *      the hash table, or NULL if the table is empty.
+ *
+ * Side Effects:
+ *      The information in searchPtr is initialized so that successive
+ *      calls to Hash_Next will return successive HashEntry's
+ *      from the table.
  *
  *---------------------------------------------------------
@@ -321 +322 @@
 Hash_Entry *
 Hash_EnumFirst(t, searchPtr)
-        Hash_Table *t;                  /* Table to be searched. */
-        register Hash_Search *searchPtr;/* Area in which to keep state
-                                         * about search.*/
-{
-        searchPtr->tablePtr = t;
-        searchPtr->nextIndex = 0;
-        searchPtr->hashEntryPtr = NULL;
-        return Hash_EnumNext(searchPtr);
+        Hash_Table *t;                  /* Table to be searched. */
+        register Hash_Search *searchPtr;/* Area in which to keep state
+                                         * about search.*/
+{
+        searchPtr->tablePtr = t;
+        searchPtr->nextIndex = 0;
+        searchPtr->hashEntryPtr = NULL;
+        return Hash_EnumNext(searchPtr);
 }
 
@@ -351 +352 @@
 Hash_Entry *
 Hash_EnumNext(searchPtr)
-        register Hash_Search *searchPtr; /* Area used to keep state about
-                                            search. */
-{
-        register Hash_Entry *e;
-        Hash_Table *t = searchPtr->tablePtr;
-
-        /*
-         * The hashEntryPtr field points to the most recently returned
-         * entry, or is nil if we are starting up.  If not nil, we have
-         * to start at the next one in the chain.
-         */
-        e = searchPtr->hashEntryPtr;
-        if (e != NULL)
-                e = e->next;
-        /*
-         * If the chain ran out, or if we are starting up, we need to
-         * find the next nonempty chain.
-         */
-        while (e == NULL) {
-                if (searchPtr->nextIndex >= t->size)
-                        return (NULL);
-                e = t->bucketPtr[searchPtr->nextIndex++];
-        }
-        searchPtr->hashEntryPtr = e;
-        return (e);
+        register Hash_Search *searchPtr; /* Area used to keep state about
+                                            search. */
+{
+        register Hash_Entry *e;
+        Hash_Table *t = searchPtr->tablePtr;
+
+        /*
+         * The hashEntryPtr field points to the most recently returned
+         * entry, or is nil if we are starting up.  If not nil, we have
+         * to start at the next one in the chain.
+         */
+        e = searchPtr->hashEntryPtr;
+        if (e != NULL)
+                e = e->next;
+        /*
+         * If the chain ran out, or if we are starting up, we need to
+         * find the next nonempty chain.
+         */
+        while (e == NULL) {
+                if (searchPtr->nextIndex >= t->size)
+                        return (NULL);
+                e = t->bucketPtr[searchPtr->nextIndex++];
+        }
+        searchPtr->hashEntryPtr = e;
+        return (e);
 }
 
@@ -382 +383 @@
  *
  * RebuildTable --
- *      This local routine makes a new hash table that
- *      is larger than the old one.
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      The entire hash table is moved, so any bucket numbers
- *      from the old table are invalid.
+ *      This local routine makes a new hash table that
+ *      is larger than the old one.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      The entire hash table is moved, so any bucket numbers
+ *      from the old table are invalid.
  *
  *---------------------------------------------------------
@@ -397 +398 @@
 static void
 RebuildTable(t)
-        register Hash_Table *t;
-{
-        register Hash_Entry *e, *next = NULL, **hp, **xp;
-        register int i, mask;
+        register Hash_Table *t;
+{
+        register Hash_Entry *e, *next = NULL, **hp, **xp;
+        register int i, mask;
         register Hash_Entry **oldhp;
-        int oldsize;
-
-        oldhp = t->bucketPtr;
-        oldsize = i = t->size;
-        i <<= 1;
-        t->size = i;
-        t->mask = mask = i - 1;
-        t->bucketPtr = hp = (struct Hash_Entry **) emalloc(sizeof(*hp) * i);
-        while (--i >= 0)
-                *hp++ = NULL;
-        for (hp = oldhp, i = oldsize; --i >= 0;) {
-                for (e = *hp++; e != NULL; e = next) {
-                        next = e->next;
-                        xp = &t->bucketPtr[e->namehash & mask];
-                        e->next = *xp;
-                        *xp = e;
-                }
-        }
-        efree((char *)oldhp);
-}
+        int oldsize;
+
+        oldhp = t->bucketPtr;
+        oldsize = i = t->size;
+        i <<= 1;
+        t->size = i;
+        t->mask = mask = i - 1;
+        t->bucketPtr = hp = (struct Hash_Entry **) emalloc(sizeof(*hp) * i);
+        while (--i >= 0)
+                *hp++ = NULL;
+        for (hp = oldhp, i = oldsize; --i >= 0;) {
+                for (e = *hp++; e != NULL; e = next) {
+                        next = e->next;
+                        xp = &t->bucketPtr[e->namehash & mask];
+                        e->next = *xp;
+                        *xp = e;
+                }
+        }
+        efree((char *)oldhp);
+}

trunk/src/kmk/helpers.c

@@ -18 +18 @@
 #include <sys/stat.h>
 #include <stdarg.h>
+#include <stdio.h>
+#include <err.h>
+
 #ifdef OS2
     #define INCL_BASE
     #include <os2.h>
 #endif
-#include <stdio.h>
-#include <err.h>
 
 
@@ -34 +35 @@
 char *realpath(const char *pszFileName, char *pszResolvedName)
 {
-    #if 0 //def USE_KLIB //@todo
+    #ifdef USE_KLIB
     if (kPathCanonifyEx(pszFileName, NULL, '/', '/', pszResolvedName, KFILE_LENGTH))
         if (kPathExist(pszFileName))
@@ -51 +52 @@
 
 #ifdef OS2
-void    err(int flags, const char *pszFormat, ...)
+void    err(int flags, const char *pszFormat, ...)
 {
     va_list args;
@@ -60 +61 @@
 }
 
-void    errx(int flags, const char *pszFormat, ...)
+void    errx(int flags, const char *pszFormat, ...)
 {
     va_list args;
@@ -69 +70 @@
 }
 
-void    warnx(const char *pszFormat, ...)
+void    warnx(const char *pszFormat, ...)
 {
     va_list args;
@@ -78 +79 @@
 }
 
-void    warn(const char *pszFormat, ...)
+void    warn(const char *pszFormat, ...)
 {
     va_list args;

trunk/src/kmk/job.c

@@ -18 +18 @@
  * 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
@@ -39 +39 @@
 #ifndef lint
 #if 0
-static char sccsid[] = "@(#)job.c       8.2 (Berkeley) 3/19/94";
+static char sccsid[] = "@(#)job.c       8.2 (Berkeley) 3/19/94";
 #else
 static const char rcsid[] =
   "$FreeBSD: src/usr.bin/make/job.c,v 1.17.2.2 2001/02/13 03:13:57 will Exp $";
 #endif
+#define KLIBFILEDEF rcsid
 #endif /* not lint */
 
@@ -56 +57 @@
 /*-
  * job.c --
- *      handle the creation etc. of our child processes.
+ *      handle the creation etc. of our child processes.
  *
  * Interface:
- *      Job_Make                Start the creation of the given target.
- *
- *      Job_CatchChildren       Check for and handle the termination of any
- *                              children. This must be called reasonably
- *                              frequently to keep the whole make going at
- *                              a decent clip, since job table entries aren't
- *                              removed until their process is caught this way.
- *                              Its single argument is TRUE if the function
- *                              should block waiting for a child to terminate.
- *
- *      Job_CatchOutput         Print any output our children have produced.
- *                              Should also be called fairly frequently to
- *                              keep the user informed of what's going on.
- *                              If no output is waiting, it will block for
- *                              a time given by the SEL_* constants, below,
- *                              or until output is ready.
- *
- *      Job_Init                Called to intialize this module. in addition,
- *                              any commands attached to the .BEGIN target
- *                              are executed before this function returns.
- *                              Hence, the makefile must have been parsed
- *                              before this function is called.
- *
- *      Job_Full                Return TRUE if the job table is filled.
- *
- *      Job_Empty               Return TRUE if the job table is completely
- *                              empty.
- *
- *      Job_ParseShell          Given the line following a .SHELL target, parse
- *                              the line as a shell specification. Returns
- *                              FAILURE if the spec was incorrect.
- *
- *      Job_End                 Perform any final processing which needs doing.
- *                              This includes the execution of any commands
- *                              which have been/were attached to the .END
- *                              target. It should only be called when the
- *                              job table is empty.
- *
- *      Job_AbortAll            Abort all currently running jobs. It doesn't
- *                              handle output or do anything for the jobs,
- *                              just kills them. It should only be called in
- *                              an emergency, as it were.
- *
- *      Job_CheckCommands       Verify that the commands for a target are
- *                              ok. Provide them if necessary and possible.
- *
- *      Job_Touch               Update a target without really updating it.
- *
- *      Job_Wait                Wait for all currently-running jobs to finish.
+ *      Job_Make                Start the creation of the given target.
+ *
+ *      Job_CatchChildren       Check for and handle the termination of any
+ *                              children. This must be called reasonably
+ *                              frequently to keep the whole make going at
+ *                              a decent clip, since job table entries aren't
+ *                              removed until their process is caught this way.
+ *                              Its single argument is TRUE if the function
+ *                              should block waiting for a child to terminate.
+ *
+ *      Job_CatchOutput         Print any output our children have produced.
+ *                              Should also be called fairly frequently to
+ *                              keep the user informed of what's going on.
+ *                              If no output is waiting, it will block for
+ *                              a time given by the SEL_* constants, below,
+ *                              or until output is ready.
+ *
+ *      Job_Init                Called to intialize this module. in addition,
+ *                              any commands attached to the .BEGIN target
+ *                              are executed before this function returns.
+ *                              Hence, the makefile must have been parsed
+ *                              before this function is called.
+ *
+ *      Job_Full                Return TRUE if the job table is filled.
+ *
+ *      Job_Empty               Return TRUE if the job table is completely
+ *                              empty.
+ *
+ *      Job_ParseShell          Given the line following a .SHELL target, parse
+ *                              the line as a shell specification. Returns
+ *                              FAILURE if the spec was incorrect.
+ *
+ *      Job_End                 Perform any final processing which needs doing.
+ *                              This includes the execution of any commands
+ *                              which have been/were attached to the .END
+ *                              target. It should only be called when the
+ *                              job table is empty.
+ *
+ *      Job_AbortAll            Abort all currently running jobs. It doesn't
+ *                              handle output or do anything for the jobs,
+ *                              just kills them. It should only be called in
+ *                              an emergency, as it were.
+ *
+ *      Job_CheckCommands       Verify that the commands for a target are
+ *                              ok. Provide them if necessary and possible.
+ *
+ *      Job_Touch               Update a target without really updating it.
+ *
+ *      Job_Wait                Wait for all currently-running jobs to finish.
  */
 
@@ -153 +154 @@
  * error handling variables
  */
-static int      errors = 0;         /* number of errors reported */
-static int      aborting = 0;       /* why is the make aborting? */
-#define ABORT_ERROR     1           /* Because of an error */
-#define ABORT_INTERRUPT 2           /* Because it was interrupted */
-#define ABORT_WAIT      3           /* Waiting for jobs to finish */
+static int      errors = 0;         /* number of errors reported */
+static int      aborting = 0;       /* why is the make aborting? */
+#define ABORT_ERROR     1           /* Because of an error */
+#define ABORT_INTERRUPT 2           /* Because it was interrupted */
+#define ABORT_WAIT      3           /* Waiting for jobs to finish */
 
 /*
@@ -170 +171 @@
  * all the time.
  */
-static GNode      *postCommands;    /* node containing commands to execute when
-                                     * everything else is done */
-static int        numCommands;      /* The number of commands actually printed
-                                     * for a target. Should this number be
-                                     * 0, no shell will be executed. */
+static GNode      *postCommands;    /* node containing commands to execute when
+                                     * everything else is done */
+static int        numCommands;      /* The number of commands actually printed
+                                     * for a target. Should this number be
+                                     * 0, no shell will be executed. */
 
 /*
  * Return values from JobStart.
  */
-#define JOB_RUNNING     0       /* Job is running */
-#define JOB_ERROR       1       /* Error in starting the job */
-#define JOB_FINISHED    2       /* The job is already finished */
-#define JOB_STOPPED     3       /* The job is stopped */
+#define JOB_RUNNING     0       /* Job is running */
+#define JOB_ERROR       1       /* Error in starting the job */
+#define JOB_FINISHED    2       /* The job is already finished */
+#define JOB_STOPPED     3       /* The job is stopped */
 
 /*
@@ -229 +230 @@
 }
 };
-static Shell    *commandShell = &shells[DEFSHELL];/* this is the shell to
-                                                   * which we pass all
-                                                   * commands in the Makefile.
-                                                   * It is set by the
-                                                   * Job_ParseShell function */
-static char     *shellPath = NULL,                /* full pathname of
-                                                   * executable image */
-                *shellName;                       /* last component of shell */
+static Shell    *commandShell = &shells[DEFSHELL];/* this is the shell to
+                                                   * which we pass all
+                                                   * commands in the Makefile.
+                                                   * It is set by the
+                                                   * Job_ParseShell function */
+static char     *shellPath = NULL,                /* full pathname of
+                                                   * executable image */
+                *shellName;                       /* last component of shell */
 #endif /*!KMK*/
 
 
-static int      maxJobs;        /* The most children we can run at once */
-static int      maxLocal;       /* The most local ones we can have */
-STATIC int      nJobs;          /* The number of children currently running */
-STATIC int      nLocal;         /* The number of local children */
-STATIC Lst      jobs;           /* The structures that describe them */
-STATIC Boolean  jobFull;        /* Flag to tell when the job table is full. It
-                                 * is set TRUE when (1) the total number of
-                                 * running jobs equals the maximum allowed or
-                                 * (2) a job can only be run locally, but
-                                 * nLocal equals maxLocal */
+static int      maxJobs;        /* The most children we can run at once */
+static int      maxLocal;       /* The most local ones we can have */
+STATIC int      nJobs;          /* The number of children currently running */
+STATIC int      nLocal;         /* The number of local children */
+STATIC Lst      jobs;           /* The structures that describe them */
+STATIC Boolean  jobFull;        /* Flag to tell when the job table is full. It
+                                 * is set TRUE when (1) the total number of
+                                 * running jobs equals the maximum allowed or
+                                 * (2) a job can only be run locally, but
+                                 * nLocal equals maxLocal */
 #ifndef RMT_WILL_WATCH
-static fd_set   outputs;        /* Set of descriptors of pipes connected to
-                                 * the output channels of children */
-#endif
-
-STATIC GNode    *lastNode;      /* The node for which output was most recently
-                                 * produced. */
-STATIC char     *targFmt;       /* Format string to use to head output from a
-                                 * job when it's not the most-recent job heard
-                                 * from */
+static fd_set   outputs;        /* Set of descriptors of pipes connected to
+                                 * the output channels of children */
+#endif
+
+STATIC GNode    *lastNode;      /* The node for which output was most recently
+                                 * produced. */
+STATIC char     *targFmt;       /* Format string to use to head output from a
+                                 * job when it's not the most-recent job heard
+                                 * from */
 
 #ifdef REMOTE
 # define TARG_FMT  "--- %s at %s ---\n" /* Default format */
 # define MESSAGE(fp, gn) \
-        (void) fprintf(fp, targFmt, gn->name, gn->rem.hname);
+        (void) fprintf(fp, targFmt, gn->name, gn->rem.hname);
 #else
 # define TARG_FMT  "--- %s ---\n" /* Default format */
 # define MESSAGE(fp, gn) \
-        (void) fprintf(fp, targFmt, gn->name);
-#endif
-
+        (void) fprintf(fp, targFmt, gn->name);
+#endif
+
+#ifdef SIGCONT
 /*
  * When JobStart attempts to run a job remotely but can't, and isn't allowed
@@ -277 +279 @@
  * when the next job finishes.
  */
-STATIC Lst      stoppedJobs;    /* Lst of Job structures describing
-                                 * jobs that were stopped due to concurrency
-                                 * limits or migration home */
-
+STATIC Lst      stoppedJobs;    /* Lst of Job structures describing
+                                 * jobs that were stopped due to concurrency
+                                 * limits or migration home */
+#endif /*SIGCONT*/
 
 #if defined(USE_PGRP) && defined(SYSV)
-# define KILL(pid, sig)         killpg(-(pid), (sig))
+# define KILL(pid, sig)         killpg(-(pid), (sig))
 #else
 # if defined(USE_PGRP)
-#  define KILL(pid, sig)        killpg((pid), (sig))
+#  define KILL(pid, sig)        killpg((pid), (sig))
 # else
-#  define KILL(pid, sig)        kill((pid), (sig))
+#  define KILL(pid, sig)        kill((pid), (sig))
 # endif
 #endif
@@ -298 +300 @@
  * really ugly, use dramamine sparingly. You have been warned.
  */
-#define W_SETMASKED(st, val, fun)                               \
-        {                                                       \
-                int sh = (int) ~0;                              \
-                int mask = fun(sh);                             \
-                                                                \
-                for (sh = 0; ((mask >> sh) & 1) == 0; sh++)     \
-                        continue;                               \
-                *(st) = (*(st) & ~mask) | ((val) << sh);        \
-        }
+#define W_SETMASKED(st, val, fun)                               \
+        {                                                       \
+                int sh = (int) ~0;                              \
+                int mask = fun(sh);                             \
+                                                                \
+                for (sh = 0; ((mask >> sh) & 1) == 0; sh++)     \
+                        continue;                               \
+                *(st) = (*(st) & ~mask) | ((val) << sh);        \
+        }
 
 #define W_SETTERMSIG(st, val) W_SETMASKED(st, val, WTERMSIG)
@@ -324 +326 @@
 # endif
 #else
+#ifdef USE_KLIB
+static void JobFinish __P((Job *, KPROCRES *));
+#else
 static void JobFinish __P((Job *, int *));
+#endif
 static void JobExec __P((Job *, char **));
 #endif
-#ifndef KMK
 static void JobMakeArgv __P((Job *, char **));
-#endif
+#ifdef SIGCONT
 static void JobRestart __P((Job *));
+#endif
 static int JobStart __P((GNode *, int, Job *));
 static char *JobOutput __P((Job *, char *, char *, int));
@@ -336 +342 @@
 static Shell *JobMatchShell __P((char *));
 static void JobInterrupt __P((int, int));
+#ifdef SIGCONT
 static void JobRestartJobs __P((void));
+#endif
 
 /*-
  *-----------------------------------------------------------------------
  * JobCondPassSig --
- *      Pass a signal to a job if the job is remote or if USE_PGRP
- *      is defined.
+ *      Pass a signal to a job if the job is remote or if USE_PGRP
+ *      is defined.
  *
  * Results:
- *      === 0
+ *      === 0
  *
  * Side Effects:
- *      None, except the job may bite it.
+ *      None, except the job may bite it.
  *
  *-----------------------------------------------------------------------
@@ -354 +362 @@
 static int
 JobCondPassSig(jobp, signop)
-    ClientData          jobp;       /* Job to biff */
-    ClientData          signop;     /* Signal to send it */
+    ClientData          jobp;       /* Job to biff */
+    ClientData          signop;     /* Signal to send it */
 {
-    Job *job = (Job *) jobp;
-    int signo = *(int *) signop;
+    Job *job = (Job *) jobp;
+    int signo = *(int *) signop;
 #ifdef RMT_WANTS_SIGNALS
     if (job->flags & JOB_REMOTE) {
-        (void) Rmt_Signal(job, signo);
+        (void) Rmt_Signal(job, signo);
     } else {
-        KILL(job->pid, signo);
+        KILL(job->pid, signo);
     }
 #else
@@ -371 +379 @@
      */
     if (DEBUG(JOB)) {
-        (void) fprintf(stdout,
-                       "JobCondPassSig passing signal %d to child %d.\n",
-                       signo, job->pid);
-        (void) fflush(stdout);
-    }
+        (void) fprintf(stdout,
+                       "JobCondPassSig passing signal %d to child %d.\n",
+                       signo, job->pid);
+        (void) fflush(stdout);
+    }
+#if defined(USE_KLIB) && (defined(OS2) || defined(WIN32))
+    switch (signo)
+    {
+        case SIGINT:
+            kProcKill(job->pid, KPROCKILL_FLAGS_TREE | KPROCKILL_FLAGS_TYPE_INT);
+            break;
+        #ifdef SIGKILL
+        case SIGKILL:
+        #endif
+        case SIGTERM:
+            kProcKill(job->pid, KPROCKILL_FLAGS_TREE | KPROCKILL_FLAGS_TYPE_KILL);
+            break;
+    /* default: ignore signal as we don't really support it */
+    }
+#else
     KILL(job->pid, signo);
+#endif
 #endif
     return 0;
@@ -384 +408 @@
  *-----------------------------------------------------------------------
  * JobPassSig --
- *      Pass a signal on to all remote jobs and to all local jobs if
- *      USE_PGRP is defined, then die ourselves.
+ *      Pass a signal on to all remote jobs and to all local jobs if
+ *      USE_PGRP is defined, then die ourselves.
  *
  * Results:
- *      None.
+ *      None.
  *
  * Side Effects:
- *      We die by the same signal.
+ *      We die by the same signal.
  *
  *-----------------------------------------------------------------------
@@ -397 +421 @@
 static void
 JobPassSig(signo)
-    int     signo;      /* The signal number we've received */
+    int     signo;      /* The signal number we've received */
 {
-    sigset_t nmask, omask;
-    struct sigaction act;
+#if defined(USE_KLIB) && (defined(OS2) || defined(WIN32))
 
     if (DEBUG(JOB)) {
-        (void) fprintf(stdout, "JobPassSig(%d) called.\n", signo);
-        (void) fflush(stdout);
+        fprintf(stdout, "JobPassSig(%d) called.\n", signo);
+        fflush(stdout);
     }
     Lst_ForEach(jobs, JobCondPassSig, (ClientData) &signo);
@@ -414 +437 @@
      */
     if (signo == SIGINT) {
-        JobInterrupt(TRUE, signo);
-    } else if ((signo == SIGHUP) || (signo == SIGTERM) || (signo == SIGQUIT)) {
-        JobInterrupt(FALSE, signo);
-    }
-
+        JobInterrupt(TRUE, signo);
+    } else if (signo == SIGTERM) {
+        JobInterrupt(FALSE, signo);
+    }
+
+
+    if (DEBUG(JOB)) {
+        fprintf(stdout,
+                "JobPassSig passing signal to self, mask = %x.\n",
+                ~0 & ~(1 << (signo-1)));
+        fflush(stdout);
+    }
+    signal(signo, SIG_DFL);
+    raise(signo);
+
+#ifdef SIGCONT
+    signo = SIGCONT;
+    Lst_ForEach(jobs, JobCondPassSig, (ClientData) &signo);
+#endif
+
+
+#else /* Not KLIB + OS2/Win32 */
+    sigset_t nmask, omask;
+    struct sigaction act;
+
+
+    if (DEBUG(JOB)) {
+        (void) fprintf(stdout, "JobPassSig(%d) called.\n", signo);
+        (void) fflush(stdout);
+    }
+    Lst_ForEach(jobs, JobCondPassSig, (ClientData) &signo);
+
+    /*
+     * Deal with proper cleanup based on the signal received. We only run
+     * the .INTERRUPT target if the signal was in fact an interrupt. The other
+     * three termination signals are more of a "get out *now*" command.
+     */
+    if (signo == SIGINT) {
+        JobInterrupt(TRUE, signo);
+    } else if ( 0
+#ifdef SIGHUP  /* not all systems supports this signal */
+               || (signo == SIGHUP)
+#endif
+               || (signo == SIGTERM)
+#ifdef SIGQUIT /* not all systems supports this signal */
+               || (signo == SIGQUIT)
+#endif
+               ) {
+        JobInterrupt(FALSE, signo);
+    }
+
+#ifdef SIGQUIT /* not all systems supports this signal */
     /*
      * Leave gracefully if SIGQUIT, rather than core dumping.
      */
     if (signo == SIGQUIT) {
-        signo = SIGINT;
-    }
-
+        signo = SIGINT;
+    }
+#endif
+
+#if !defined(USE_KLIB) || !(defined(OS2) || defined(WIN32))
     /*
      * Send ourselves the signal now we've given the message to everyone else.
@@ -439 +511 @@
     act.sa_flags = 0;
     sigaction(signo, &act, NULL);
+#endif
 
     if (DEBUG(JOB)) {
-        (void) fprintf(stdout,
-                       "JobPassSig passing signal to self, mask = %x.\n",
-                       ~0 & ~(1 << (signo-1)));
-        (void) fflush(stdout);
+        (void) fprintf(stdout,
+                       "JobPassSig passing signal to self, mask = %x.\n",
+                       ~0 & ~(1 << (signo-1)));
+        (void) fflush(stdout);
     }
     (void) signal(signo, SIG_DFL);
@@ -453 +526 @@
     Lst_ForEach(jobs, JobCondPassSig, (ClientData) &signo);
 
+#if !defined(USE_KLIB) || !(defined(OS2) || defined(WIN32))
     (void) sigprocmask(SIG_SETMASK, &omask, NULL);
     sigprocmask(SIG_SETMASK, &omask, NULL);
     act.sa_handler = JobPassSig;
     sigaction(signo, &act, NULL);
+#endif
+#endif /* KLIB + OS2/Win32 */
 }
 
@@ -462 +538 @@
  *-----------------------------------------------------------------------
  * JobCmpPid  --
- *      Compare the pid of the job with the given pid and return 0 if they
- *      are equal. This function is called from Job_CatchChildren via
- *      Lst_Find to find the job descriptor of the finished job.
+ *      Compare the pid of the job with the given pid and return 0 if they
+ *      are equal. This function is called from Job_CatchChildren via
+ *      Lst_Find to find the job descriptor of the finished job.
  *
  * Results:
- *      0 if the pid's match
+ *      0 if the pid's match
  *
  * Side Effects:
- *      None
+ *      None
  *-----------------------------------------------------------------------
  */
 static int
 JobCmpPid(job, pid)
-    ClientData        job;      /* job to examine */
-    ClientData        pid;      /* process id desired */
+    ClientData        job;      /* job to examine */
+    ClientData        pid;      /* process id desired */
 {
     return *(int *) pid - ((Job *) job)->pid;
@@ -485 +561 @@
  *-----------------------------------------------------------------------
  * JobCmpRmtID  --
- *      Compare the rmtID of the job with the given rmtID and return 0 if they
- *      are equal.
+ *      Compare the rmtID of the job with the given rmtID and return 0 if they
+ *      are equal.
  *
  * Results:
- *      0 if the rmtID's match
+ *      0 if the rmtID's match
  *
  * Side Effects:
- *      None.
+ *      None.
  *-----------------------------------------------------------------------
  */
 static int
 JobCmpRmtID(job, rmtID)
-    ClientData      job;        /* job to examine */
-    ClientData      rmtID;      /* remote id desired */
+    ClientData      job;        /* job to examine */
+    ClientData      rmtID;      /* remote id desired */
 {
     return(*(int *) rmtID - *(int *) job->rmtID);
@@ -507 +583 @@
  *-----------------------------------------------------------------------
  * JobPrintCommand  --
- *      Put out another command for the given job. If the command starts
- *      with an @ or a - we process it specially. In the former case,
- *      so long as the -s and -n flags weren't given to make, we stick
- *      a shell-specific echoOff command in the script. In the latter,
- *      we ignore errors for the entire job, unless the shell has error
- *      control.
- *      If the command is just "..." we take all future commands for this
- *      job to be commands to be executed once the entire graph has been
- *      made and return non-zero to signal that the end of the commands
- *      was reached. These commands are later attached to the postCommands
- *      node and executed by Job_End when all things are done.
- *      This function is called from JobStart via Lst_ForEach.
+ *      Put out another command for the given job. If the command starts
+ *      with an @ or a - we process it specially. In the former case,
+ *      so long as the -s and -n flags weren't given to make, we stick
+ *      a shell-specific echoOff command in the script. In the latter,
+ *      we ignore errors for the entire job, unless the shell has error
+ *      control.
+ *      If the command is just "..." we take all future commands for this
+ *      job to be commands to be executed once the entire graph has been
+ *      made and return non-zero to signal that the end of the commands
+ *      was reached. These commands are later attached to the postCommands
+ *      node and executed by Job_End when all things are done.
+ *      This function is called from JobStart via Lst_ForEach.
  *
  * Results:
- *      Always 0, unless the command was "..."
+ *      Always 0, unless the command was "..."
  *
  * Side Effects:
- *      If the command begins with a '-' and the shell has no error control,
- *      the JOB_IGNERR flag is set in the job descriptor.
- *      If the command is "..." and we're not ignoring such things,
- *      tailCmds is set to the successor node of the cmd.
- *      numCommands is incremented if the command is actually printed.
+ *      If the command begins with a '-' and the shell has no error control,
+ *      the JOB_IGNERR flag is set in the job descriptor.
+ *      If the command is "..." and we're not ignoring such things,
+ *      tailCmds is set to the successor node of the cmd.
+ *      numCommands is incremented if the command is actually printed.
  *-----------------------------------------------------------------------
  */
 static int
 JobPrintCommand(cmdp, jobp)
-    ClientData    cmdp;             /* command string to print */
-    ClientData    jobp;             /* job for which to print it */
+    ClientData    cmdp;             /* command string to print */
+    ClientData    jobp;             /* job for which to print it */
 {
-    Boolean       noSpecials;       /* true if we shouldn't worry about
-                                     * inserting special commands into
-                                     * the input stream. */
+    Boolean       noSpecials;       /* true if we shouldn't worry about
+                                     * inserting special commands into
+                                     * the input stream. */
     Boolean       shutUp = FALSE;   /* true if we put a no echo command
-                                     * into the command file */
-    Boolean       errOff = FALSE;   /* true if we turned error checking
-                                     * off before printing the command
-                                     * and need to turn it back on */
-    char          *cmdTemplate;     /* Template to use when printing the
-                                     * command */
-    char          *cmdStart;        /* Start of expanded command */
-    LstNode       cmdNode;          /* Node for replacing the command */
-    char          *cmd = (char *) cmdp;
+                                     * into the command file */
+    Boolean       errOff = FALSE;   /* true if we turned error checking
+                                     * off before printing the command
+                                     * and need to turn it back on */
+    char          *cmdTemplate;     /* Template to use when printing the
+                                     * command */
+    char          *cmdStart;        /* Start of expanded command */
+    LstNode       cmdNode;          /* Node for replacing the command */
+    char          *cmd = (char *) cmdp;
     Job           *job = (Job *) jobp;
 
@@ -554 +630 @@
 
     if (strcmp(cmd, "...") == 0) {
-        job->node->type |= OP_SAVE_CMDS;
-        if ((job->flags & JOB_IGNDOTS) == 0) {
-            job->tailCmds = Lst_Succ(Lst_Member(job->node->commands,
-                                                (ClientData)cmd));
-            return 1;
-        }
-        return 0;
-    }
-
-#define DBPRINTF(fmt, arg) if (DEBUG(JOB)) {    \
-        (void) fprintf(stdout, fmt, arg);       \
-        (void) fflush(stdout);                  \
-    }                                           \
-   (void) fprintf(job->cmdFILE, fmt, arg);      \
+        job->node->type |= OP_SAVE_CMDS;
+        if ((job->flags & JOB_IGNDOTS) == 0) {
+            job->tailCmds = Lst_Succ(Lst_Member(job->node->commands,
+                                                (ClientData)cmd));
+            return 1;
+        }
+        return 0;
+    }
+
+#define DBPRINTF(fmt, arg) if (DEBUG(JOB)) {    \
+        (void) fprintf(stdout, fmt, arg);       \
+        (void) fflush(stdout);                  \
+    }                                           \
+   (void) fprintf(job->cmdFILE, fmt, arg);      \
    (void) fflush(job->cmdFILE);
 
@@ -586 +662 @@
      */
     while (*cmd == '@' || *cmd == '-') {
-        if (*cmd == '@') {
-            shutUp = DEBUG(LOUD) ? FALSE : TRUE;
-        } else {
-            errOff = TRUE;
-        }
-        cmd++;
+        if (*cmd == '@') {
+            shutUp = DEBUG(LOUD) ? FALSE : TRUE;
+        } else {
+            errOff = TRUE;
+        }
+        cmd++;
     }
 
     while (isspace((unsigned char) *cmd))
-        cmd++;
+        cmd++;
 
     #ifndef KMK
     if (shutUp) {
-        if (!(job->flags & JOB_SILENT) && !noSpecials &&
-            commandShell->hasEchoCtl) {
-                DBPRINTF("%s\n", commandShell->echoOff);
-        } else {
-            shutUp = FALSE;
-        }
+        if (!(job->flags & JOB_SILENT) && !noSpecials &&
+            commandShell->hasEchoCtl) {
+                DBPRINTF("%s\n", commandShell->echoOff);
+        } else {
+            shutUp = FALSE;
+        }
     }
     #endif
 
     if (errOff) {
-        if ( !(job->flags & JOB_IGNERR) && !noSpecials) {
+        if ( !(job->flags & JOB_IGNERR) && !noSpecials) {
             #ifdef KMK
             errOff = FALSE;
             #else
-            if (commandShell->hasErrCtl) {
-                /*
-                 * we don't want the error-control commands showing
-                 * up either, so we turn off echoing while executing
-                 * them. We could put another field in the shell
-                 * structure to tell JobDoOutput to look for this
-                 * string too, but why make it any more complex than
-                 * it already is?
-                 */
-                if (!(job->flags & JOB_SILENT) && !shutUp &&
-                    commandShell->hasEchoCtl) {
-                        DBPRINTF("%s\n", commandShell->echoOff);
-                        DBPRINTF("%s\n", commandShell->ignErr);
-                        DBPRINTF("%s\n", commandShell->echoOn);
-                } else {
-                    DBPRINTF("%s\n", commandShell->ignErr);
-                }
-            } else if (commandShell->ignErr &&
-                      (*commandShell->ignErr != '\0'))
-            {
-                /*
-                 * The shell has no error control, so we need to be
-                 * weird to get it to ignore any errors from the command.
-                 * If echoing is turned on, we turn it off and use the
-                 * errCheck template to echo the command. Leave echoing
-                 * off so the user doesn't see the weirdness we go through
-                 * to ignore errors. Set cmdTemplate to use the weirdness
-                 * instead of the simple "%s\n" template.
-                 */
-                if (!(job->flags & JOB_SILENT) && !shutUp &&
-                    commandShell->hasEchoCtl) {
-                        DBPRINTF("%s\n", commandShell->echoOff);
-                        DBPRINTF(commandShell->errCheck, cmd);
-                        shutUp = TRUE;
-                }
-                cmdTemplate = commandShell->ignErr;
-                /*
-                 * The error ignoration (hee hee) is already taken care
-                 * of by the ignErr template, so pretend error checking
-                 * is still on.
-                 */
-                errOff = FALSE;
-            } else {
-                errOff = FALSE;
-            }
+            if (commandShell->hasErrCtl) {
+                /*
+                 * we don't want the error-control commands showing
+                 * up either, so we turn off echoing while executing
+                 * them. We could put another field in the shell
+                 * structure to tell JobDoOutput to look for this
+                 * string too, but why make it any more complex than
+                 * it already is?
+                 */
+                if (!(job->flags & JOB_SILENT) && !shutUp &&
+                    commandShell->hasEchoCtl) {
+                        DBPRINTF("%s\n", commandShell->echoOff);
+                        DBPRINTF("%s\n", commandShell->ignErr);
+                        DBPRINTF("%s\n", commandShell->echoOn);
+                } else {
+                    DBPRINTF("%s\n", commandShell->ignErr);
+                }
+            } else if (commandShell->ignErr &&
+                      (*commandShell->ignErr != '\0'))
+            {
+                /*
+                 * The shell has no error control, so we need to be
+                 * weird to get it to ignore any errors from the command.
+                 * If echoing is turned on, we turn it off and use the
+                 * errCheck template to echo the command. Leave echoing
+                 * off so the user doesn't see the weirdness we go through
+                 * to ignore errors. Set cmdTemplate to use the weirdness
+                 * instead of the simple "%s\n" template.
+                 */
+                if (!(job->flags & JOB_SILENT) && !shutUp &&
+                    commandShell->hasEchoCtl) {
+                        DBPRINTF("%s\n", commandShell->echoOff);
+                        DBPRINTF(commandShell->errCheck, cmd);
+                        shutUp = TRUE;
+                }
+                cmdTemplate = commandShell->ignErr;
+                /*
+                 * The error ignoration (hee hee) is already taken care
+                 * of by the ignErr template, so pretend error checking
+                 * is still on.
+                 */
+                errOff = FALSE;
+            } else {
+                errOff = FALSE;
+            }
             #endif
-        } else {
-            errOff = FALSE;
-        }
+        } else {
+            errOff = FALSE;
+        }
     }
 
@@ -668 +744 @@
     #ifndef KMK /*todo*/
     if (errOff) {
-        /*
-         * If echoing is already off, there's no point in issuing the
-         * echoOff command. Otherwise we issue it and pretend it was on
-         * for the whole command...
-         */
-        if (!shutUp && !(job->flags & JOB_SILENT) && commandShell->hasEchoCtl){
-            DBPRINTF("%s\n", commandShell->echoOff);
-            shutUp = TRUE;
-        }
-        DBPRINTF("%s\n", commandShell->errCheck);
+        /*
+         * If echoing is already off, there's no point in issuing the
+         * echoOff command. Otherwise we issue it and pretend it was on
+         * for the whole command...
+         */
+        if (!shutUp && !(job->flags & JOB_SILENT) && commandShell->hasEchoCtl){
+            DBPRINTF("%s\n", commandShell->echoOff);
+            shutUp = TRUE;
+        }
+        DBPRINTF("%s\n", commandShell->errCheck);
     }
     if (shutUp) {
-        DBPRINTF("%s\n", commandShell->echoOn);
+        DBPRINTF("%s\n", commandShell->echoOn);
     }
     #endif
@@ -689 +765 @@
  *-----------------------------------------------------------------------
  * JobSaveCommand --
- *      Save a command to be executed when everything else is done.
- *      Callback function for JobFinish...
+ *      Save a command to be executed when everything else is done.
+ *      Callback function for JobFinish...
  *
  * Results:
- *      Always returns 0
+ *      Always returns 0
  *
  * Side Effects:
- *      The command is tacked onto the end of postCommands's commands list.
+ *      The command is tacked onto the end of postCommands's commands list.
  *
  *-----------------------------------------------------------------------
@@ -714 +790 @@
  *-----------------------------------------------------------------------
  * JobClose --
- *      Called to close both input and output pipes when a job is finished.
+ *      Called to close both input and output pipes when a job is finished.
  *
  * Results:
- *      Nada
+ *      Nada
  *
  * Side Effects:
- *      The file descriptors associated with the job are closed.
+ *      The file descriptors associated with the job are closed.
  *
  *-----------------------------------------------------------------------
@@ -728 +804 @@
     Job *job;
 {
+#ifdef USE_PIPES
     if (usePipes) {
 #ifdef RMT_WILL_WATCH
-        Rmt_Ignore(job->inPipe);
+        Rmt_Ignore(job->inPipe);
 #else
-        FD_CLR(job->inPipe, &outputs);
-#endif
-        if (job->outPipe != job->inPipe) {
-           (void) close(job->outPipe);
-        }
-        JobDoOutput(job, TRUE);
-        (void) close(job->inPipe);
+        FD_CLR(job->inPipe, &outputs);
+#endif
+        if (job->outPipe != job->inPipe) {
+           (void) close(job->outPipe);
+        }
+        JobDoOutput(job, TRUE);
+        (void) close(job->inPipe);
     } else {
-        (void) close(job->outFd);
-        JobDoOutput(job, TRUE);
-    }
+        (void) close(job->outFd);
+        JobDoOutput(job, TRUE);
+    }
+
+#else  /* Don't use Pipes */
+    close(job->outFd);
+    JobDoOutput(job, TRUE);
+#endif /* USE_PIPES */
 }
 
@@ -748 +830 @@
  *-----------------------------------------------------------------------
  * JobFinish  --
- *      Do final processing for the given job including updating
- *      parents and starting new jobs as available/necessary. Note
- *      that we pay no attention to the JOB_IGNERR flag here.
- *      This is because when we're called because of a noexecute flag
- *      or something, jstat.w_status is 0 and when called from
- *      Job_CatchChildren, the status is zeroed if it s/b ignored.
+ *      Do final processing for the given job including updating
+ *      parents and starting new jobs as available/necessary. Note
+ *      that we pay no attention to the JOB_IGNERR flag here.
+ *      This is because when we're called because of a noexecute flag
+ *      or something, jstat.w_status is 0 and when called from
+ *      Job_CatchChildren, the status is zeroed if it s/b ignored.
  *
  * Results:
- *      None
+ *      None
  *
  * Side Effects:
- *      Some nodes may be put on the toBeMade queue.
- *      Final commands for the job are placed on postCommands.
- *
- *      If we got an error and are aborting (aborting == ABORT_ERROR) and
- *      the job list is now empty, we are done for the day.
- *      If we recognized an error (errors !=0), we set the aborting flag
- *      to ABORT_ERROR so no more jobs will be started.
+ *      Some nodes may be put on the toBeMade queue.
+ *      Final commands for the job are placed on postCommands.
+ *
+ *      If we got an error and are aborting (aborting == ABORT_ERROR) and
+ *      the job list is now empty, we are done for the day.
+ *      If we recognized an error (errors !=0), we set the aborting flag
+ *      to ABORT_ERROR so no more jobs will be started.
  *-----------------------------------------------------------------------
  */
@@ -771 +853 @@
 static void
 JobFinish(job, status)
-    Job         *job;             /* job to finish */
-    int         *status;          /* sub-why job went away */
+    Job         *job;             /* job to finish */
+#ifdef USE_KLIB
+    KPROCRES    *status;          /* sub-why job went away */
+#else
+    int         *status;          /* sub-why job went away */
+#endif
 {
-    Boolean      done;
+#ifdef USE_KLIB
+    Boolean      done;
+
+    if ( ( (status->fFlags & KPROCRES_FLAGS_NORMAL) && status->uExitCode != 0 && !(job->flags & JOB_IGNERR) )
+        || !(status->fFlags & KPROCRES_FLAGS_NORMAL)
+         )
+    {
+        /*
+         * If it exited non-zero and either we're doing things our
+         * way or we're not ignoring errors, the job is finished.
+         * Similarly, if the shell died because of a signal
+         * the job is also finished. In these
+         * cases, finish out the job's output before printing the exit
+         * status...
+         */
+        JobClose(job);
+        if (job->cmdFILE != NULL && job->cmdFILE != stdout) {
+           (void) fclose(job->cmdFILE);
+           job->cmdFILE = NULL;
+        }
+        done = TRUE;
+    } else if (status->fFlags & KPROCRES_FLAGS_NORMAL) {
+        /*
+         * Deal with ignored errors in -B mode. We need to print a message
+         * telling of the ignored error as well as setting status.w_status
+         * to 0 so the next command gets run. To do this, we set done to be
+         * TRUE if in -B mode and the job exited non-zero.
+         */
+        done = status->uExitCode != 0;
+        /*
+         * Old comment said: "Note we don't
+         * want to close down any of the streams until we know we're at the
+         * end."
+         * But we do. Otherwise when are we going to print the rest of the
+         * stuff?
+         */
+        JobClose(job);
+    } else {
+        /*
+         * No need to close things down or anything.
+         */
+        done = FALSE;
+    }
+
+    if (    done
+        || DEBUG(JOB))
+    {
+        FILE      *out = stdout;
+        if (compatMake && !usePipes && (job->flags & JOB_IGNERR))
+        {
+            /*
+             * If output is going to a file and this job is ignoring
+             * errors, arrange to have the exit status sent to the
+             * output file as well.
+             */
+            out = fdopen(job->outFd, "w");
+        }
+
+        if (status->fFlags & KPROCRES_FLAGS_NORMAL)
+        {
+            if (DEBUG(JOB))
+            {
+                fprintf(stdout, "Process %d exited.\n", job->pid);
+                fflush(stdout);
+            }
+            if (status->uExitCode != 0)
+            {
+#ifdef USE_PIPES
+                if (usePipes && job->node != lastNode)
+                {
+                    MESSAGE(out, job->node);
+                    lastNode = job->node;
+                }
+#endif
+                fprintf(out, "*** Error code %d%s\n",
+                        status->uExitCode,
+                        (job->flags & JOB_IGNERR) ? "(ignored)" : "");
+
+                if (job->flags & JOB_IGNERR)
+                    status->uExitCode = 0;
+            }
+            else if (DEBUG(JOB))
+            {
+#ifdef USE_PIPES
+                if (usePipes && job->node != lastNode)
+                {
+                    MESSAGE(out, job->node);
+                    lastNode = job->node;
+                }
+#endif
+                fprintf(out, "*** Completed successfully\n");
+            }
+        }
+        else
+        {
+#ifdef USE_PIPES
+            if (usePipes && job->node != lastNode)
+            {
+                MESSAGE(out, job->node);
+                lastNode = job->node;
+            }
+#endif
+            fprintf(out, "*** Abnormal End\n");
+        }
+
+        fflush(out);
+    }
+
+    /*
+     * Now handle the -B-mode stuff. If the beast still isn't finished,
+     * try and restart the job on the next command. If JobStart says it's
+     * ok, it's ok. If there's an error, this puppy is done.
+     */
+    if (    compatMake
+        && (status->fFlags & KPROCRES_FLAGS_NORMAL)
+        && !Lst_IsAtEnd(job->node->commands)
+        )
+    {
+        switch (JobStart(job->node, job->flags & JOB_IGNDOTS, job))
+        {
+        case JOB_RUNNING:
+            done = FALSE;
+            break;
+        case JOB_ERROR:
+            done = TRUE;
+            status->uExitCode = EXIT_FAILURE;
+            break;
+        case JOB_FINISHED:
+            /*
+             * If we got back a JOB_FINISHED code, JobStart has already
+             * called Make_Update and freed the job descriptor. We set
+             * done to false here to avoid fake cycles and double frees.
+             * JobStart needs to do the update so we can proceed up the
+             * graph when given the -n flag..
+             */
+            done = FALSE;
+            break;
+        }
+    } else {
+        done = TRUE;
+    }
+
+
+    if (   done
+        && aborting != ABORT_ERROR
+        && aborting != ABORT_INTERRUPT
+        && (status->fFlags & KPROCRES_FLAGS_NORMAL)
+        && status->uExitCode == 0
+        )
+    {
+        /*
+         * As long as we aren't aborting and the job didn't return a non-zero
+         * status that we shouldn't ignore, we call Make_Update to update
+         * the parents. In addition, any saved commands for the node are placed
+         * on the .END target.
+         */
+        if (job->tailCmds != NILLNODE) {
+            Lst_ForEachFrom(job->node->commands, job->tailCmds,
+                             JobSaveCommand,
+                            (ClientData)job->node);
+        }
+        job->node->made = MADE;
+        Make_Update(job->node);
+        efree((Address)job);
+    }
+    else if (!(status->fFlags & KPROCRES_FLAGS_NORMAL) || status->uExitCode != 0)
+    {
+        errors += 1;
+        efree((Address)job);
+    }
+
+    /*
+     * Set aborting if any error.
+     */
+    if (errors && !keepgoing && (aborting != ABORT_INTERRUPT))
+    {
+        /*
+         * If we found any errors in this batch of children and the -k flag
+         * wasn't given, we set the aborting flag so no more jobs get
+         * started.
+         */
+        aborting = ABORT_ERROR;
+    }
+
+    if ((aborting == ABORT_ERROR) && Job_Empty())
+    {
+        /*
+         * If we are aborting and the job table is now empty, we finish.
+         */
+        Finish(errors);
+    }
+
+
+#else /* Don't use kLib */
+    Boolean      done;
 
     if ((WIFEXITED(*status) &&
-         (((WEXITSTATUS(*status) != 0) && !(job->flags & JOB_IGNERR)))) ||
-        (WIFSIGNALED(*status) && (WTERMSIG(*status) != SIGCONT)))
+         (((WEXITSTATUS(*status) != 0) && !(job->flags & JOB_IGNERR)))) ||
+        (WIFSIGNALED(*status) && (WTERMSIG(*status) != SIGCONT)))
     {
-        /*
-         * If it exited non-zero and either we're doing things our
-         * way or we're not ignoring errors, the job is finished.
-         * Similarly, if the shell died because of a signal
-         * the job is also finished. In these
-         * cases, finish out the job's output before printing the exit
-         * status...
-         */
+        /*
+         * If it exited non-zero and either we're doing things our
+         * way or we're not ignoring errors, the job is finished.
+         * Similarly, if the shell died because of a signal
+         * the job is also finished. In these
+         * cases, finish out the job's output before printing the exit
+         * status...
+         */
 #ifdef REMOTE
-        KILL(job->pid, SIGCONT);
-#endif
-        JobClose(job);
-        if (job->cmdFILE != NULL && job->cmdFILE != stdout) {
-           (void) fclose(job->cmdFILE);
-        }
-        done = TRUE;
+        KILL(job->pid, SIGCONT);
+#endif
+        JobClose(job);
+        if (job->cmdFILE != NULL && job->cmdFILE != stdout) {
+           (void) fclose(job->cmdFILE);
+        }
+        done = TRUE;
 #ifdef REMOTE
-        if (job->flags & JOB_REMOTE)
-            Rmt_Done(job->rmtID, job->node);
+        if (job->flags & JOB_REMOTE)
+            Rmt_Done(job->rmtID, job->node);
 #endif
     } else if (WIFEXITED(*status)) {
-        /*
-         * Deal with ignored errors in -B mode. We need to print a message
-         * telling of the ignored error as well as setting status.w_status
-         * to 0 so the next command gets run. To do this, we set done to be
-         * TRUE if in -B mode and the job exited non-zero.
-         */
-        done = WEXITSTATUS(*status) != 0;
-        /*
-         * Old comment said: "Note we don't
-         * want to close down any of the streams until we know we're at the
-         * end."
-         * But we do. Otherwise when are we going to print the rest of the
-         * stuff?
-         */
-        JobClose(job);
+        /*
+         * Deal with ignored errors in -B mode. We need to print a message
+         * telling of the ignored error as well as setting status.w_status
+         * to 0 so the next command gets run. To do this, we set done to be
+         * TRUE if in -B mode and the job exited non-zero.
+         */
+        done = WEXITSTATUS(*status) != 0;
+        /*
+         * Old comment said: "Note we don't
+         * want to close down any of the streams until we know we're at the
+         * end."
+         * But we do. Otherwise when are we going to print the rest of the
+         * stuff?
+         */
+        JobClose(job);
 #ifdef REMOTE
-        if (job->flags & JOB_REMOTE)
-            Rmt_Done(job->rmtID, job->node);
+        if (job->flags & JOB_REMOTE)
+            Rmt_Done(job->rmtID, job->node);
 #endif /* REMOTE */
     } else {
-        /*
-         * No need to close things down or anything.
-         */
-        done = FALSE;
+        /*
+         * No need to close things down or anything.
+         */
+        done = FALSE;
     }
 
     if (done ||
-        WIFSTOPPED(*status) ||
-        (WIFSIGNALED(*status) && (WTERMSIG(*status) == SIGCONT)) ||
-        DEBUG(JOB))
+        WIFSTOPPED(*status) ||
+        (WIFSIGNALED(*status) && (WTERMSIG(*status) == SIGCONT)) ||
+        DEBUG(JOB))
     {
-        FILE      *out;
-
-        if (compatMake && !usePipes && (job->flags & JOB_IGNERR)) {
-            /*
-             * If output is going to a file and this job is ignoring
-             * errors, arrange to have the exit status sent to the
-             * output file as well.
-             */
-            out = fdopen(job->outFd, "w");
-        } else {
-            out = stdout;
-        }
-
-        if (WIFEXITED(*status)) {
-            if (DEBUG(JOB)) {
-                (void) fprintf(stdout, "Process %d exited.\n", job->pid);
-                (void) fflush(stdout);
-            }
-            if (WEXITSTATUS(*status) != 0) {
-                if (usePipes && job->node != lastNode) {
-                    MESSAGE(out, job->node);
-                    lastNode = job->node;
-                }
-                (void) fprintf(out, "*** Error code %d%s\n",
-                               WEXITSTATUS(*status),
-                               (job->flags & JOB_IGNERR) ? "(ignored)" : "");
-
-                if (job->flags & JOB_IGNERR) {
-                    *status = 0;
-                }
-            } else if (DEBUG(JOB)) {
-                if (usePipes && job->node != lastNode) {
-                    MESSAGE(out, job->node);
-                    lastNode = job->node;
-                }
-                (void) fprintf(out, "*** Completed successfully\n");
-            }
-        } else if (WIFSTOPPED(*status)) {
-            if (DEBUG(JOB)) {
-                (void) fprintf(stdout, "Process %d stopped.\n", job->pid);
-                (void) fflush(stdout);
-            }
-            if (usePipes && job->node != lastNode) {
-                MESSAGE(out, job->node);
-                lastNode = job->node;
-            }
-            if (!(job->flags & JOB_REMIGRATE)) {
-                (void) fprintf(out, "*** Stopped -- signal %d\n",
-                    WSTOPSIG(*status));
-            }
-            job->flags |= JOB_RESUME;
-            (void)Lst_AtEnd(stoppedJobs, (ClientData)job);
-#ifdef REMOTE
-            if (job->flags & JOB_REMIGRATE)
-                JobRestart(job);
-#endif
-            (void) fflush(out);
-            return;
-        } else if (WTERMSIG(*status) == SIGCONT) {
-            /*
-             * If the beastie has continued, shift the Job from the stopped
-             * list to the running one (or re-stop it if concurrency is
-             * exceeded) and go and get another child.
-             */
-            if (job->flags & (JOB_RESUME|JOB_REMIGRATE|JOB_RESTART)) {
-                if (usePipes && job->node != lastNode) {
-                    MESSAGE(out, job->node);
-                    lastNode = job->node;
-                }
-                (void) fprintf(out, "*** Continued\n");
-            }
-            if (!(job->flags & JOB_CONTINUING)) {
-                if (DEBUG(JOB)) {
-                    (void) fprintf(stdout,
-                                   "Warning: process %d was not continuing.\n",
-                                   job->pid);
-                    (void) fflush(stdout);
-                }
+        FILE      *out;
+
+        if (compatMake && !usePipes && (job->flags & JOB_IGNERR)) {
+            /*
+             * If output is going to a file and this job is ignoring
+             * errors, arrange to have the exit status sent to the
+             * output file as well.
+             */
+            out = fdopen(job->outFd, "w");
+        } else {
+            out = stdout;
+        }
+
+        if (WIFEXITED(*status)) {
+            if (DEBUG(JOB)) {
+                (void) fprintf(stdout, "Process %d exited.\n", job->pid);
+                (void) fflush(stdout);
+            }
+            if (WEXITSTATUS(*status) != 0) {
+#ifdef USE_PIPES
+                if (usePipes && job->node != lastNode) {
+                    MESSAGE(out, job->node);
+                    lastNode = job->node;
+                }
+#endif
+                (void) fprintf(out, "*** Error code %d%s\n",
+                               WEXITSTATUS(*status),
+                               (job->flags & JOB_IGNERR) ? "(ignored)" : "");
+
+                if (job->flags & JOB_IGNERR) {
+                    *status = 0;
+                }
+            } else if (DEBUG(JOB)) {
+#ifdef USE_PIPES
+                if (usePipes && job->node != lastNode) {
+                    MESSAGE(out, job->node);
+                    lastNode = job->node;
+                }
+#endif
+                (void) fprintf(out, "*** Completed successfully\n");
+            }
+        } else if (WIFSTOPPED(*status)) {
+            if (DEBUG(JOB)) {
+                (void) fprintf(stdout, "Process %d stopped.\n", job->pid);
+                (void) fflush(stdout);
+            }
+#ifdef USE_PIPES
+            if (usePipes && job->node != lastNode) {
+                MESSAGE(out, job->node);
+                lastNode = job->node;
+            }
+#endif
+            if (!(job->flags & JOB_REMIGRATE)) {
+                (void) fprintf(out, "*** Stopped -- signal %d\n",
+                    WSTOPSIG(*status));
+            }
+            job->flags |= JOB_RESUME;
+            (void)Lst_AtEnd(stoppedJobs, (ClientData)job);
+#if defined(REMOTE) && defined(SIGCONT)
+            if (job->flags & JOB_REMIGRATE)
+                JobRestart(job);
+#endif
+            (void) fflush(out);
+            return;
+        } else if (WTERMSIG(*status) == SIGCONT) {
+            /*
+             * If the beastie has continued, shift the Job from the stopped
+             * list to the running one (or re-stop it if concurrency is
+             * exceeded) and go and get another child.
+             */
+            if (job->flags & (JOB_RESUME|JOB_REMIGRATE|JOB_RESTART)) {
+#ifdef USE_PIPES
+                if (usePipes && job->node != lastNode) {
+                    MESSAGE(out, job->node);
+                    lastNode = job->node;
+                }
+#endif
+                (void) fprintf(out, "*** Continued\n");
+            }
+            if (!(job->flags & JOB_CONTINUING)) {
+                if (DEBUG(JOB)) {
+                    (void) fprintf(stdout,
+                                   "Warning: process %d was not continuing.\n",
+                                   job->pid);
+                    (void) fflush(stdout);
+                }
+#ifdef SIGCONT
 #ifdef notdef
-                /*
-                 * We don't really want to restart a job from scratch just
-                 * because it continued, especially not without killing the
-                 * continuing process!  That's why this is ifdef'ed out.
-                 * FD - 9/17/90
-                 */
-                JobRestart(job);
-#endif
-            }
-            job->flags &= ~JOB_CONTINUING;
-            Lst_AtEnd(jobs, (ClientData)job);
-            nJobs += 1;
-            if (!(job->flags & JOB_REMOTE)) {
-                if (DEBUG(JOB)) {
-                    (void) fprintf(stdout,
-                                   "Process %d is continuing locally.\n",
-                                   job->pid);
-                    (void) fflush(stdout);
-                }
-                nLocal += 1;
-            }
-            if (nJobs == maxJobs) {
-                jobFull = TRUE;
-                if (DEBUG(JOB)) {
-                    (void) fprintf(stdout, "Job queue is full.\n");
-                    (void) fflush(stdout);
-                }
-            }
-            (void) fflush(out);
-            return;
-        } else {
-            if (usePipes && job->node != lastNode) {
-                MESSAGE(out, job->node);
-                lastNode = job->node;
-            }
-            (void) fprintf(out, "*** Signal %d\n", WTERMSIG(*status));
-        }
-
-        (void) fflush(out);
+                /*
+                 * We don't really want to restart a job from scratch just
+                 * because it continued, especially not without killing the
+                 * continuing process!  That's why this is ifdef'ed out.
+                 * FD - 9/17/90
+                 */
+                JobRestart(job);
+#endif
+#endif
+            }
+            job->flags &= ~JOB_CONTINUING;
+            Lst_AtEnd(jobs, (ClientData)job);
+            nJobs += 1;
+            if (!(job->flags & JOB_REMOTE)) {
+                if (DEBUG(JOB)) {
+                    (void) fprintf(stdout,
+                                   "Process %d is continuing locally.\n",
+                                   job->pid);
+                    (void) fflush(stdout);
+                }
+                nLocal += 1;
+            }
+            if (nJobs == maxJobs) {
+                jobFull = TRUE;
+                if (DEBUG(JOB)) {
+                    (void) fprintf(stdout, "Job queue is full.\n");
+                    (void) fflush(stdout);
+                }
+            }
+            (void) fflush(out);
+            return;
+        } else {
+#ifdef USE_PIPES
+            if (usePipes && job->node != lastNode) {
+                MESSAGE(out, job->node);
+                lastNode = job->node;
+            }
+#endif
+            (void) fprintf(out, "*** Signal %d\n", WTERMSIG(*status));
+        }
+
+        (void) fflush(out);
     }
 
@@ -958 +1250 @@
      */
     if (compatMake && (WIFEXITED(*status) &&
-        !Lst_IsAtEnd(job->node->commands))) {
-        switch (JobStart(job->node, job->flags & JOB_IGNDOTS, job)) {
-        case JOB_RUNNING:
-            done = FALSE;
-            break;
-        case JOB_ERROR:
-            done = TRUE;
-            W_SETEXITSTATUS(status, 1);
-            break;
-        case JOB_FINISHED:
-            /*
-             * If we got back a JOB_FINISHED code, JobStart has already
-             * called Make_Update and freed the job descriptor. We set
-             * done to false here to avoid fake cycles and double frees.
-             * JobStart needs to do the update so we can proceed up the
-             * graph when given the -n flag..
-             */
-            done = FALSE;
-            break;
-        }
+        !Lst_IsAtEnd(job->node->commands))) {
+        switch (JobStart(job->node, job->flags & JOB_IGNDOTS, job)) {
+        case JOB_RUNNING:
+            done = FALSE;
+            break;
+        case JOB_ERROR:
+            done = TRUE;
+            W_SETEXITSTATUS(status, 1);
+            break;
+        case JOB_FINISHED:
+            /*
+             * If we got back a JOB_FINISHED code, JobStart has already
+             * called Make_Update and freed the job descriptor. We set
+             * done to false here to avoid fake cycles and double frees.
+             * JobStart needs to do the update so we can proceed up the
+             * graph when given the -n flag..
+             */
+            done = FALSE;
+            break;
+        }
     } else {
-        done = TRUE;
+        done = TRUE;
     }
 
 
     if (done &&
-        (aborting != ABORT_ERROR) &&
-        (aborting != ABORT_INTERRUPT) &&
-        (*status == 0))
+        (aborting != ABORT_ERROR) &&
+        (aborting != ABORT_INTERRUPT) &&
+        (*status == 0))
     {
-        /*
-         * As long as we aren't aborting and the job didn't return a non-zero
-         * status that we shouldn't ignore, we call Make_Update to update
-         * the parents. In addition, any saved commands for the node are placed
-         * on the .END target.
-         */
-        if (job->tailCmds != NILLNODE) {
-            Lst_ForEachFrom(job->node->commands, job->tailCmds,
-                             JobSaveCommand,
-                            (ClientData)job->node);
-        }
-        job->node->made = MADE;
-        Make_Update(job->node);
-        efree((Address)job);
+        /*
+         * As long as we aren't aborting and the job didn't return a non-zero
+         * status that we shouldn't ignore, we call Make_Update to update
+         * the parents. In addition, any saved commands for the node are placed
+         * on the .END target.
+         */
+        if (job->tailCmds != NILLNODE) {
+            Lst_ForEachFrom(job->node->commands, job->tailCmds,
+                             JobSaveCommand,
+                            (ClientData)job->node);
+        }
+        job->node->made = MADE;
+        Make_Update(job->node);
+        efree((Address)job);
     } else if (*status != 0) {
-        errors += 1;
-        efree((Address)job);
-    }
-
+        errors += 1;
+        efree((Address)job);
+    }
+
+#ifdef SIGCONT
     JobRestartJobs();
+#endif
 
     /*
@@ -1013 +1307 @@
      */
     if (errors && !keepgoing && (aborting != ABORT_INTERRUPT)) {
-        /*
-         * If we found any errors in this batch of children and the -k flag
-         * wasn't given, we set the aborting flag so no more jobs get
-         * started.
-         */
-        aborting = ABORT_ERROR;
+        /*
+         * If we found any errors in this batch of children and the -k flag
+         * wasn't given, we set the aborting flag so no more jobs get
+         * started.
+         */
+        aborting = ABORT_ERROR;
     }
 
     if ((aborting == ABORT_ERROR) && Job_Empty())
-        /*
-         * If we are aborting and the job table is now empty, we finish.
-         */
-        Finish(errors);
+        /*
+         * If we are aborting and the job table is now empty, we finish.
+         */
+        Finish(errors);
+#endif /* USE_KLIB */
 }
 
@@ -1031 +1326 @@
  *-----------------------------------------------------------------------
  * Job_Touch --
- *      Touch the given target. Called by JobStart when the -t flag was
- *      given
+ *      Touch the given target. Called by JobStart when the -t flag was
+ *      given
  *
  * Results:
- *      None
+ *      None
  *
  * Side Effects:
- *      The data modification of the file is changed. In addition, if the
- *      file did not exist, it is created.
+ *      The data modification of the file is changed. In addition, if the
+ *      file did not exist, it is created.
  *-----------------------------------------------------------------------
  */
 void
 Job_Touch(gn, silent)
-    GNode         *gn;          /* the node of the file to touch */
-    Boolean       silent;       /* TRUE if should not print messages */
+    GNode         *gn;          /* the node of the file to touch */
+    Boolean       silent;       /* TRUE if should not print messages */
 {
-    int           streamID;     /* ID of stream opened to do the touch */
-    struct utimbuf times;       /* Times for utime() call */
+    int           streamID;     /* ID of stream opened to do the touch */
+    struct utimbuf times;       /* Times for utime() call */
 
     if (gn->type & (OP_JOIN|OP_USE|OP_EXEC|OP_OPTIONAL)) {
-        /*
-         * .JOIN, .USE, .ZEROTIME and .OPTIONAL targets are "virtual" targets
-         * and, as such, shouldn't really be created.
-         */
-        return;
+        /*
+         * .JOIN, .USE, .ZEROTIME and .OPTIONAL targets are "virtual" targets
+         * and, as such, shouldn't really be created.
+         */
+        return;
     }
 
     if (!silent) {
-        (void) fprintf(stdout, "touch %s\n", gn->name);
-        (void) fflush(stdout);
+        (void) fprintf(stdout, "touch %s\n", gn->name);
+        (void) fflush(stdout);
     }
 
     if (noExecute) {
-        return;
+        return;
     }
 
 #ifdef USE_ARCHIVES
     if (gn->type & OP_ARCHV) {
-        Arch_Touch(gn);
+        Arch_Touch(gn);
     } else if (gn->type & OP_LIB) {
-        Arch_TouchLib(gn);
+        Arch_TouchLib(gn);
     } else {
 #else
@@ -1077 +1372 @@
 #endif
 
-        char    *file = gn->path ? gn->path : gn->name;
-
-        times.actime = times.modtime = now;
-        if (utime(file, &times) < 0){
-            streamID = open(file, O_RDWR | O_CREAT, 0666);
-
-            if (streamID >= 0) {
-                char    c;
-
-                /*
-                 * Read and write a byte to the file to change the
-                 * modification time, then close the file.
-                 */
-                if (read(streamID, &c, 1) == 1) {
-                    (void) lseek(streamID, 0L, SEEK_SET);
-                    (void) write(streamID, &c, 1);
-                }
-
-                (void) close(streamID);
-            } else {
-                (void) fprintf(stdout, "*** couldn't touch %s: %s",
-                               file, strerror(errno));
-                (void) fflush(stdout);
-            }
-        }
+        char    *file = gn->path ? gn->path : gn->name;
+
+        times.actime = times.modtime = now;
+        if (utime(file, &times) < 0){
+            streamID = open(file, O_RDWR | O_CREAT, 0666);
+
+            if (streamID >= 0) {
+                char    c;
+
+                /*
+                 * Read and write a byte to the file to change the
+                 * modification time, then close the file.
+                 */
+                if (read(streamID, &c, 1) == 1) {
+                    (void) lseek(streamID, 0L, SEEK_SET);
+                    (void) write(streamID, &c, 1);
+                }
+
+                (void) close(streamID);
+            } else {
+                (void) fprintf(stdout, "*** couldn't touch %s: %s",
+                               file, strerror(errno));
+                (void) fflush(stdout);
+            }
+        }
     }
 }
@@ -1108 +1403 @@
  *-----------------------------------------------------------------------
  * Job_CheckCommands --
- *      Make sure the given node has all the commands it needs.
+ *      Make sure the given node has all the commands it needs.
  *
  * Results:
- *      TRUE if the commands list is/was ok.
+ *      TRUE if the commands list is/was ok.
  *
  * Side Effects:
- *      The node will have commands from the .DEFAULT rule added to it
- *      if it needs them.
+ *      The node will have commands from the .DEFAULT rule added to it
+ *      if it needs them.
  *-----------------------------------------------------------------------
  */
 Boolean
 Job_CheckCommands(gn, abortProc)
-    GNode          *gn;             /* The target whose commands need
-                                     * verifying */
-    void         (*abortProc) __P((char *, ...));
-                        /* Function to abort with message */
+    GNode          *gn;             /* The target whose commands need
+                                     * verifying */
+    void         (*abortProc) __P((char *, ...));
+                        /* Function to abort with message */
 {
     if (OP_NOP(gn->type) && Lst_IsEmpty(gn->commands)
@@ -1131 +1426 @@
         )
     {
-        /*
-         * No commands. Look for .DEFAULT rule from which we might infer
-         * commands
-         */
-        if ((DEFAULT != NILGNODE) && !Lst_IsEmpty(DEFAULT->commands)) {
-            char *p1;
-            /*
-             * Make only looks for a .DEFAULT if the node was never the
-             * target of an operator, so that's what we do too. If
-             * a .DEFAULT was given, we substitute its commands for gn's
-             * commands and set the IMPSRC variable to be the target's name
-             * The DEFAULT node acts like a transformation rule, in that
-             * gn also inherits any attributes or sources attached to
-             * .DEFAULT itself.
-             */
-            Make_HandleUse(DEFAULT, gn);
-            Var_Set(IMPSRC, Var_Value(TARGET, gn, &p1), gn);
-            efree(p1);
-        } else if (Dir_MTime(gn) == 0) {
-            /*
-             * The node wasn't the target of an operator we have no .DEFAULT
-             * rule to go on and the target doesn't already exist. There's
-             * nothing more we can do for this branch. If the -k flag wasn't
-             * given, we stop in our tracks, otherwise we just don't update
-             * this node's parents so they never get examined.
-             */
-            static const char msg[] = MAKE_NAME ": don't know how to make";
-
-            if (gn->type & OP_OPTIONAL) {
-                (void) fprintf(stdout, "%s %s(ignored)\n", msg, gn->name);
-                (void) fflush(stdout);
-            } else if (keepgoing) {
-                (void) fprintf(stdout, "%s %s(continuing)\n", msg, gn->name);
-                (void) fflush(stdout);
-                return FALSE;
-            } else {
+        /*
+         * No commands. Look for .DEFAULT rule from which we might infer
+         * commands
+         */
+        if ((DEFAULT != NILGNODE) && !Lst_IsEmpty(DEFAULT->commands)) {
+            char *p1;
+            /*
+             * Make only looks for a .DEFAULT if the node was never the
+             * target of an operator, so that's what we do too. If
+             * a .DEFAULT was given, we substitute its commands for gn's
+             * commands and set the IMPSRC variable to be the target's name
+             * The DEFAULT node acts like a transformation rule, in that
+             * gn also inherits any attributes or sources attached to
+             * .DEFAULT itself.
+             */
+            Make_HandleUse(DEFAULT, gn);
+            Var_Set(IMPSRC, Var_Value(TARGET, gn, &p1), gn);
+            efree(p1);
+        } else if (Dir_MTime(gn) == 0) {
+            /*
+             * The node wasn't the target of an operator we have no .DEFAULT
+             * rule to go on and the target doesn't already exist. There's
+             * nothing more we can do for this branch. If the -k flag wasn't
+             * given, we stop in our tracks, otherwise we just don't update
+             * this node's parents so they never get examined.
+             */
+            static const char msg[] = MAKE_NAME ": don't know how to make";
+
+            if (gn->type & OP_OPTIONAL) {
+                (void) fprintf(stdout, "%s %s(ignored)\n", msg, gn->name);
+                (void) fflush(stdout);
+            } else if (keepgoing) {
+                (void) fprintf(stdout, "%s %s(continuing)\n", msg, gn->name);
+                (void) fflush(stdout);
+                return FALSE;
+            } else {
 #if OLD_JOKE
-                if (strcmp(gn->name,"love") == 0)
-                    (*abortProc)("Not war.");
+                if (strcmp(gn->name,"love") == 0)
+                    (*abortProc)("Not war.");
 #if defined(NMAKE) || defined(KMK)
                 else if (strcmp(gn->name,"fire") == 0)
-                    (*abortProc)("No match.");
+                    (*abortProc)("No match.");
 #endif
                 else
 #endif
-                    (*abortProc)("%s %s. Stop", msg, gn->name);
-                return FALSE;
-            }
-        }
+                    (*abortProc)("%s %s. Stop", msg, gn->name);
+                return FALSE;
+            }
+        }
     }
     return TRUE;
@@ -1187 +1482 @@
  *-----------------------------------------------------------------------
  * JobLocalInput --
- *      Handle a pipe becoming readable. Callback function for Rmt_Watch
+ *      Handle a pipe becoming readable. Callback function for Rmt_Watch
  *
  * Results:
- *      None
+ *      None
  *
  * Side Effects:
- *      JobDoOutput is called.
+ *      JobDoOutput is called.
  *
  *-----------------------------------------------------------------------
@@ -1200 +1495 @@
 static void
 JobLocalInput(stream, job)
-    int     stream;     /* Stream that's ready (ignored) */
-    Job     *job;       /* Job to which the stream belongs */
+    int     stream;     /* Stream that's ready (ignored) */
+    Job     *job;       /* Job to which the stream belongs */
 {
     JobDoOutput(job, FALSE);
@@ -1210 +1505 @@
  *-----------------------------------------------------------------------
  * JobExec --
- *      Execute the shell for the given job. Called from JobStart and
- *      JobRestart.
+ *      Execute the shell for the given job. Called from JobStart and
+ *      JobRestart.
  *
  * Results:
- *      None.
+ *      None.
  *
  * Side Effects:
- *      A shell is executed, outputs is altered and the Job structure added
- *      to the job table.
+ *      A shell is executed, outputs is altered and the Job structure added
+ *      to the job table.
  *
  *-----------------------------------------------------------------------
@@ -1224 +1519 @@
 static void
 JobExec(job, argv)
-    Job           *job;         /* Job to execute */
-    char          **argv;
+    Job           *job;         /* Job to execute */
+    char          **argv;
 {
-    int           cpid;         /* ID of new child */
+#ifdef USE_KLIB
+    int           cpid;         /* ID of new child */
+    int           rc;
+
+    if (DEBUG(JOB))
+    {
+        int       i;
+        fprintf(stdout, "Running %s %sly\n", job->node->name,
+                job->flags&JOB_REMOTE?"remote":"local");
+        fprintf(stdout, "\tCommand: ");
+        for (i = 0; argv[i] != NULL; i++)
+            fprintf(stdout, "%s ", argv[i]);
+        fprintf(stdout, "\n");
+        fflush(stdout);
+    }
+
+    /*
+     * Some jobs produce no output and it's disconcerting to have
+     * no feedback of their running (since they produce no output, the
+     * banner with their name in it never appears). This is an attempt to
+     * provide that feedback, even if nothing follows it.
+     */
+    if (    lastNode != job->node
+        &&  (job->flags & JOB_FIRST)
+        && !(job->flags & JOB_SILENT)
+         )
+    {
+        MESSAGE(stdout, job->node);
+        lastNode = job->node;
+    }
+
+    /*
+     * Create process with assigned output+stderr pipe.
+     */
+    if (job->cmdFILE)
+        fseek(job->cmdFILE, 0, SEEK_SET);
+    rc = kProcCreate(argv,
+                     NULL,
+                     NULL,
+                     NULL,
+                     KPROCCREATE_FLAGS_SPAWN,
+                     job->cmdFILE ? FILENO(job->cmdFILE) : KFILE_NULL,
+                     usePipes ? job->outPipe : job->outFd, /* stdout */
+                     usePipes ? job->outPipe : job->outFd, /* stderr */
+                     &cpid,
+                     NULL);
+    if (!rc)
+    {
+        job->pid = cpid;
+
+#ifdef USE_PIPES
+        if (usePipes && (job->flags & JOB_FIRST) )
+        {
+            /*
+             * The first time a job is run for a node, we set the current
+             * position in the buffer to the beginning and mark another
+             * stream to watch in the outputs mask
+             */
+            job->curPos = 0;
+            FD_SET(job->inPipe, &outputs);
+        }
+#endif /* USE_PIPES */
+
+        if (job->flags & JOB_REMOTE) {
+            job->rmtID = 0;
+        } else {
+            nLocal += 1;
+            /*
+             * XXX: Used to not happen if REMOTE. Why?
+             */
+            if (job->cmdFILE != NULL && job->cmdFILE != stdout) {
+                fclose(job->cmdFILE);
+                job->cmdFILE = NULL;
+            }
+        }
+
+        /*
+         * Now the job is actually running, add it to the table.
+         */
+        nJobs += 1;
+        (void) Lst_AtEnd(jobs, (ClientData)job);
+        if (nJobs == maxJobs)
+        {
+            jobFull = TRUE;
+        }
+    }
+    else
+        Punt("Cannot start child (%d)", rc);
+
+
+
+#else /* Don't use kLib */
+    int           cpid;         /* ID of new child */
 
     if (DEBUG(JOB)) {
-        int       i;
-
-        (void) fprintf(stdout, "Running %s %sly\n", job->node->name,
-                       job->flags&JOB_REMOTE?"remote":"local");
-        (void) fprintf(stdout, "\tCommand: ");
-        for (i = 0; argv[i] != NULL; i++) {
-            (void) fprintf(stdout, "%s ", argv[i]);
-        }
-        (void) fprintf(stdout, "\n");
-        (void) fflush(stdout);
+        int       i;
+
+        (void) fprintf(stdout, "Running %s %sly\n", job->node->name,
+                       job->flags&JOB_REMOTE?"remote":"local");
+        (void) fprintf(stdout, "\tCommand: ");
+        for (i = 0; argv[i] != NULL; i++) {
+            (void) fprintf(stdout, "%s ", argv[i]);
+        }
+        (void) fprintf(stdout, "\n");
+        (void) fflush(stdout);
     }
 
@@ -1249 +1636 @@
      */
     if ((lastNode != job->node) && (job->flags & JOB_FIRST) &&
-        !(job->flags & JOB_SILENT)) {
-        MESSAGE(stdout, job->node);
-        lastNode = job->node;
+        !(job->flags & JOB_SILENT)) {
+        MESSAGE(stdout, job->node);
+        lastNode = job->node;
     }
 
 #ifdef RMT_NO_EXEC
     if (job->flags & JOB_REMOTE) {
-        goto jobExecFinish;
+        goto jobExecFinish;
     }
 #endif /* RMT_NO_EXEC */
@@ -1265 +1652 @@
     if ((cpid = vfork()) == -1) {
 #endif
-        Punt("Cannot fork");
+        Punt("Cannot fork");
     } else if (cpid == 0) {
 
-        /*
-         * Must duplicate the input stream down to the child's input and
-         * reset it to the beginning (again). Since the stream was marked
-         * close-on-exec, we must clear that bit in the new input.
-         */
-        if (dup2(FILENO(job->cmdFILE), 0) == -1)
-            Punt("Cannot dup2: %s", strerror(errno));
-        (void) fcntl(0, F_SETFD, 0);
-        (void) lseek(0, 0, SEEK_SET);
-
-        if (usePipes) {
-            /*
-             * Set up the child's output to be routed through the pipe
-             * we've created for it.
-             */
-            if (dup2(job->outPipe, 1) == -1)
-                Punt("Cannot dup2: %s", strerror(errno));
-        } else {
-            /*
-             * We're capturing output in a file, so we duplicate the
-             * descriptor to the temporary file into the standard
-             * output.
-             */
-            if (dup2(job->outFd, 1) == -1)
-                Punt("Cannot dup2: %s", strerror(errno));
-        }
-        /*
-         * The output channels are marked close on exec. This bit was
-         * duplicated by the dup2 (on some systems), so we have to clear
-         * it before routing the shell's error output to the same place as
-         * its standard output.
-         */
-        (void) fcntl(1, F_SETFD, 0);
-        if (dup2(1, 2) == -1)
-            Punt("Cannot dup2: %s", strerror(errno));
+        /*
+         * Must duplicate the input stream down to the child's input and
+         * reset it to the beginning (again). Since the stream was marked
+         * close-on-exec, we must clear that bit in the new input.
+         */
+        if (dup2(FILENO(job->cmdFILE), 0) == -1)
+            Punt("Cannot dup2: %s", strerror(errno));
+        (void) fcntl(0, F_SETFD, 0);
+        (void) lseek(0, 0, SEEK_SET);
+
+        if (usePipes) {
+            /*
+             * Set up the child's output to be routed through the pipe
+             * we've created for it.
+             */
+            if (dup2(job->outPipe, STDOUT_FILENO) == -1)
+                Punt("Cannot dup2: %s", strerror(errno));
+        } else {
+            /*
+             * We're capturing output in a file, so we duplicate the
+             * descriptor to the temporary file into the standard
+             * output.
+             */
+            if (dup2(job->outFd, STDOUT_FILENO) == -1)
+                Punt("Cannot dup2: %s", strerror(errno));
+        }
+        /*
+         * The output channels are marked close on exec. This bit was
+         * duplicated by the dup2 (on some systems), so we have to clear
+         * it before routing the shell's error output to the same place as
+         * its standard output.
+         */
+        (void) fcntl(1, F_SETFD, 0);
+        if (dup2(STDOUT_FILENO, STDERR_FILENO) == -1)
+            Punt("Cannot dup2: %s", strerror(errno));
 
 #ifdef USE_PGRP
-        /*
-         * We want to switch the child into a different process family so
-         * we can kill it and all its descendants in one fell swoop,
-         * by killing its process family, but not commit suicide.
-         */
+        /*
+         * We want to switch the child into a different process family so
+         * we can kill it and all its descendants in one fell swoop,
+         * by killing its process family, but not commit suicide.
+         */
 # if defined(SYSV)
-        (void) setsid();
+        (void) setsid();
 # else
-        (void) setpgid(0, getpid());
+        (void) setpgid(0, getpid());
 # endif
 #endif /* USE_PGRP */
 
 #ifdef REMOTE
-        if (job->flags & JOB_REMOTE) {
-            Rmt_Exec(shellPath, argv, FALSE);
-        } else
+        if (job->flags & JOB_REMOTE) {
+            Rmt_Exec(shellPath, argv, FALSE);
+        } else
 #endif /* REMOTE */
 #ifdef KMK
-           (void) execv(argv[0], argv);
+           (void) execv(argv[0], argv);
 #else
-           (void) execv(shellPath, argv);
-#endif
-
-        (void) write(2, "Could not execute shell\n",
-                     sizeof("Could not execute shell"));
-        _exit(1);
+           (void) execv(shellPath, argv);
+#endif
+
+        (void) write(2, "Could not execute shell\n",
+                     sizeof("Could not execute shell"));
+        _exit(1);
     } else {
 #ifdef REMOTE
-        long omask = sigblock(sigmask(SIGCHLD));
-#endif
-        job->pid = cpid;
-
-        if (usePipes && (job->flags & JOB_FIRST) ) {
-            /*
-             * The first time a job is run for a node, we set the current
-             * position in the buffer to the beginning and mark another
-             * stream to watch in the outputs mask
-             */
-            job->curPos = 0;
+        long omask = sigblock(sigmask(SIGCHLD));
+#endif
+        job->pid = cpid;
+
+#ifdef USE_PIPES
+        if (usePipes && (job->flags & JOB_FIRST) ) {
+            /*
+             * The first time a job is run for a node, we set the current
+             * position in the buffer to the beginning and mark another
+             * stream to watch in the outputs mask
+             */
+            job->curPos = 0;
 
 #ifdef RMT_WILL_WATCH
-            Rmt_Watch(job->inPipe, JobLocalInput, job);
+            Rmt_Watch(job->inPipe, JobLocalInput, job);
 #else
-            FD_SET(job->inPipe, &outputs);
+            FD_SET(job->inPipe, &outputs);
 #endif /* RMT_WILL_WATCH */
-        }
-
-        if (job->flags & JOB_REMOTE) {
+        }
+#endif /* USE_PIPES */
+
+        if (job->flags & JOB_REMOTE) {
 #ifndef REMOTE
-            job->rmtID = 0;
+            job->rmtID = 0;
 #else
-            job->rmtID = Rmt_LastID(job->pid);
+            job->rmtID = Rmt_LastID(job->pid);
 #endif /* REMOTE */
-        } else {
-            nLocal += 1;
-            /*
-             * XXX: Used to not happen if REMOTE. Why?
-             */
-            if (job->cmdFILE != NULL && job->cmdFILE != stdout) {
-                (void) fclose(job->cmdFILE);
-                job->cmdFILE = NULL;
-            }
-        }
+        } else {
+            nLocal += 1;
+            /*
+             * XXX: Used to not happen if REMOTE. Why?
+             */
+            if (job->cmdFILE != NULL && job->cmdFILE != stdout) {
+                (void) fclose(job->cmdFILE);
+                job->cmdFILE = NULL;
+            }
+        }
 #ifdef REMOTE
-        (void) sigsetmask(omask);
+        (void) sigsetmask(omask);
 #endif
     }
@@ -1382 +1771 @@
     (void) Lst_AtEnd(jobs, (ClientData)job);
     if (nJobs == maxJobs) {
-        jobFull = TRUE;
-    }
+        jobFull = TRUE;
+    }
+#endif /* USE_KLIB */
 }
 
@@ -1390 +1780 @@
  *-----------------------------------------------------------------------
  * JobMakeArgv --
- *      Create the argv needed to execute the shell for a given job.
+ *      Create the argv needed to execute the shell for a given job.
  *
  *
@@ -1401 +1791 @@
 static void
 JobMakeArgv(job, argv)
-    Job           *job;
-    char          **argv;
+    Job           *job;
+    char          **argv;
 {
-    int           argc;
-    static char   args[10];     /* For merged arguments */
-
-#ifndef _PATH_DEFSHELLDIR
-    /* @todo! */
-    argv[0] = "c:\\os2\\cmd.exe";
-    argc = 1;
-#else
+#ifdef KMK
+    int           argc;
+
+    argv[0] = argv0;
+    argv[1] = "--kShell";
+    argc = 2;
+    if (!(job->flags & JOB_IGNERR))
+        argv[argc++] = "-e";
+    if (!(job->flags & JOB_SILENT))
+        argv[argc++] = "-v";
+    argv[argc] = NULL;
+
+#else /* not kMk */
+    int           argc;
+    static char   args[10];     /* For merged arguments */
+
     argv[0] = shellName;
     argc = 1;
 
     if ((commandShell->exit && (*commandShell->exit != '-')) ||
-        (commandShell->echo && (*commandShell->echo != '-')))
+        (commandShell->echo && (*commandShell->echo != '-')))
     {
-        /*
-         * At least one of the flags doesn't have a minus before it, so
-         * merge them together. Have to do this because the *(&(@*#*&#$#
-         * Bourne shell thinks its second argument is a file to source.
-         * Grrrr. Note the ten-character limitation on the combined arguments.
-         */
-        (void)sprintf(args, "-%s%s",
-                      ((job->flags & JOB_IGNERR) ? "" :
-                       (commandShell->exit ? commandShell->exit : "")),
-                      ((job->flags & JOB_SILENT) ? "" :
-                       (commandShell->echo ? commandShell->echo : "")));
-
-        if (args[1]) {
-            argv[argc] = args;
-            argc++;
-        }
+        /*
+         * At least one of the flags doesn't have a minus before it, so
+         * merge them together. Have to do this because the *(&(@*#*&#$#
+         * Bourne shell thinks its second argument is a file to source.
+         * Grrrr. Note the ten-character limitation on the combined arguments.
+         */
+        (void)sprintf(args, "-%s%s",
+                      ((job->flags & JOB_IGNERR) ? "" :
+                       (commandShell->exit ? commandShell->exit : "")),
+                      ((job->flags & JOB_SILENT) ? "" :
+                       (commandShell->echo ? commandShell->echo : "")));
+
+        if (args[1]) {
+            argv[argc] = args;
+            argc++;
+        }
     } else {
-        if (!(job->flags & JOB_IGNERR) && commandShell->exit) {
-            argv[argc] = commandShell->exit;
-            argc++;
-        }
-        if (!(job->flags & JOB_SILENT) && commandShell->echo) {
-            argv[argc] = commandShell->echo;
-            argc++;
-        }
+        if (!(job->flags & JOB_IGNERR) && commandShell->exit) {
+            argv[argc] = commandShell->exit;
+            argc++;
+        }
+        if (!(job->flags & JOB_SILENT) && commandShell->echo) {
+            argv[argc] = commandShell->echo;
+            argc++;
+        }
     }
     argv[argc] = NULL;
-#endif
+#endif /* KMK */
 }
 
 
+#ifdef SIGCONT
 /*-
  *-----------------------------------------------------------------------
  * JobRestart --
- *      Restart a job that stopped for some reason.
+ *      Restart a job that stopped for some reason.
  *
  * Results:
- *      None.
+ *      None.
  *
  * Side Effects:
- *      jobFull will be set if the job couldn't be run.
+ *      jobFull will be set if the job couldn't be run.
  *
  *-----------------------------------------------------------------------
@@ -1464 +1863 @@
 static void
 JobRestart(job)
-    Job           *job;         /* Job to restart */
+    Job           *job;         /* Job to restart */
 {
 #ifdef REMOTE
@@ -1471 +1870 @@
 
     if (job->flags & JOB_REMIGRATE) {
-        if (
+        if (
 #ifdef REMOTE
-            verboseRemigrates ||
-#endif
-            DEBUG(JOB)) {
-           (void) fprintf(stdout, "*** remigrating %x(%s)\n",
-                           job->pid, job->node->name);
-           (void) fflush(stdout);
-        }
+            verboseRemigrates ||
+#endif
+            DEBUG(JOB)) {
+           (void) fprintf(stdout, "*** remigrating %x(%s)\n",
+                           job->pid, job->node->name);
+           (void) fflush(stdout);
+        }
 
 #ifdef REMOTE
-        if (!Rmt_ReExport(job->pid, job->node, &host)) {
-            if (verboseRemigrates || DEBUG(JOB)) {
-                (void) fprintf(stdout, "*** couldn't migrate...\n");
-                (void) fflush(stdout);
-            }
-#endif
-            if (nLocal != maxLocal) {
-                /*
-                 * Job cannot be remigrated, but there's room on the local
-                 * machine, so resume the job and note that another
-                 * local job has started.
-                 */
-                if (
+        if (!Rmt_ReExport(job->pid, job->node, &host)) {
+            if (verboseRemigrates || DEBUG(JOB)) {
+                (void) fprintf(stdout, "*** couldn't migrate...\n");
+                (void) fflush(stdout);
+            }
+#endif
+            if (nLocal != maxLocal) {
+                /*
+                 * Job cannot be remigrated, but there's room on the local
+                 * machine, so resume the job and note that another
+                 * local job has started.
+                 */
+                if (
 #ifdef REMOTE
-                    verboseRemigrates ||
-#endif
-                    DEBUG(JOB)) {
-                    (void) fprintf(stdout, "*** resuming on local machine\n");
-                    (void) fflush(stdout);
-                }
-                KILL(job->pid, SIGCONT);
-                nLocal +=1;
+                    verboseRemigrates ||
+#endif
+                    DEBUG(JOB)) {
+                    (void) fprintf(stdout, "*** resuming on local machine\n");
+                    (void) fflush(stdout);
+                }
+                KILL(job->pid, SIGCONT);
+                nLocal +=1;
 #ifdef REMOTE
-                job->flags &= ~(JOB_REMIGRATE|JOB_RESUME|JOB_REMOTE);
-                job->flags |= JOB_CONTINUING;
+                job->flags &= ~(JOB_REMIGRATE|JOB_RESUME|JOB_REMOTE);
+                job->flags |= JOB_CONTINUING;
 #else
-                job->flags &= ~(JOB_REMIGRATE|JOB_RESUME);
-#endif
-        } else {
-                /*
-                 * Job cannot be restarted. Mark the table as full and
-                 * place the job back on the list of stopped jobs.
-                 */
-                if (
+                job->flags &= ~(JOB_REMIGRATE|JOB_RESUME);
+#endif
+        } else {
+                /*
+                 * Job cannot be restarted. Mark the table as full and
+                 * place the job back on the list of stopped jobs.
+                 */
+                if (
 #ifdef REMOTE
-                    verboseRemigrates ||
-#endif
-                    DEBUG(JOB)) {
-                   (void) fprintf(stdout, "*** holding\n");
-                   (void) fflush(stdout);
-                }
-                (void)Lst_AtFront(stoppedJobs, (ClientData)job);
-                jobFull = TRUE;
-                if (DEBUG(JOB)) {
-                   (void) fprintf(stdout, "Job queue is full.\n");
-                   (void) fflush(stdout);
-                }
-                return;
-            }
+                    verboseRemigrates ||
+#endif
+                    DEBUG(JOB)) {
+                   (void) fprintf(stdout, "*** holding\n");
+                   (void) fflush(stdout);
+                }
+                (void)Lst_AtFront(stoppedJobs, (ClientData)job);
+                jobFull = TRUE;
+                if (DEBUG(JOB)) {
+                   (void) fprintf(stdout, "Job queue is full.\n");
+                   (void) fflush(stdout);
+                }
+                return;
+            }
 #ifdef REMOTE
-        } else {
-            /*
-             * Clear out the remigrate and resume flags. Set the continuing
-             * flag so we know later on that the process isn't exiting just
-             * because of a signal.
-             */
-            job->flags &= ~(JOB_REMIGRATE|JOB_RESUME);
-            job->flags |= JOB_CONTINUING;
-            job->rmtID = host;
-        }
-#endif
-
-        (void)Lst_AtEnd(jobs, (ClientData)job);
-        nJobs += 1;
-        if (nJobs == maxJobs) {
-            jobFull = TRUE;
-            if (DEBUG(JOB)) {
-                (void) fprintf(stdout, "Job queue is full.\n");
-                (void) fflush(stdout);
-            }
-        }
+        } else {
+            /*
+             * Clear out the remigrate and resume flags. Set the continuing
+             * flag so we know later on that the process isn't exiting just
+             * because of a signal.
+             */
+            job->flags &= ~(JOB_REMIGRATE|JOB_RESUME);
+            job->flags |= JOB_CONTINUING;
+            job->rmtID = host;
+        }
+#endif
+
+        (void)Lst_AtEnd(jobs, (ClientData)job);
+        nJobs += 1;
+        if (nJobs == maxJobs) {
+            jobFull = TRUE;
+            if (DEBUG(JOB)) {
+                (void) fprintf(stdout, "Job queue is full.\n");
+                (void) fflush(stdout);
+            }
+        }
     } else if (job->flags & JOB_RESTART) {
-        /*
-         * Set up the control arguments to the shell. This is based on the
-         * flags set earlier for this job. If the JOB_IGNERR flag is clear,
-         * the 'exit' flag of the commandShell is used to cause it to exit
-         * upon receiving an error. If the JOB_SILENT flag is clear, the
-         * 'echo' flag of the commandShell is used to get it to start echoing
-         * as soon as it starts processing commands.
-         */
-        char      *argv[4];
-
-        JobMakeArgv(job, argv);
-
-        if (DEBUG(JOB)) {
-            (void) fprintf(stdout, "Restarting %s...", job->node->name);
-            (void) fflush(stdout);
-        }
+        /*
+         * Set up the control arguments to the shell. This is based on the
+         * flags set earlier for this job. If the JOB_IGNERR flag is clear,
+         * the 'exit' flag of the commandShell is used to cause it to exit
+         * upon receiving an error. If the JOB_SILENT flag is clear, the
+         * 'echo' flag of the commandShell is used to get it to start echoing
+         * as soon as it starts processing commands.
+         */
+        char      *argv[4];
+
+        JobMakeArgv(job, argv);
+
+        if (DEBUG(JOB)) {
+            (void) fprintf(stdout, "Restarting %s...", job->node->name);
+            (void) fflush(stdout);
+        }
 #ifdef REMOTE
-        if ((job->node->type&OP_NOEXPORT) ||
-            (nLocal < maxLocal && runLocalFirst)
+        if ((job->node->type&OP_NOEXPORT) ||
+            (nLocal < maxLocal && runLocalFirst)
 # ifdef RMT_NO_EXEC
-            || !Rmt_Export(shellPath, argv, job)
+            || !Rmt_Export(shellPath, argv, job)
 # else
-            || !Rmt_Begin(shellPath, argv, job->node)
+            || !Rmt_Begin(shellPath, argv, job->node)
 # endif
 #endif
-        {
-            if (((nLocal >= maxLocal) && !(job->flags & JOB_SPECIAL))) {
-                /*
-                 * Can't be exported and not allowed to run locally -- put it
-                 * back on the hold queue and mark the table full
-                 */
-                if (DEBUG(JOB)) {
-                    (void) fprintf(stdout, "holding\n");
-                    (void) fflush(stdout);
-                }
-                (void)Lst_AtFront(stoppedJobs, (ClientData)job);
-                jobFull = TRUE;
-                if (DEBUG(JOB)) {
-                    (void) fprintf(stdout, "Job queue is full.\n");
-                    (void) fflush(stdout);
-                }
-                return;
-            } else {
-                /*
-                 * Job may be run locally.
-                 */
-                if (DEBUG(JOB)) {
-                    (void) fprintf(stdout, "running locally\n");
-                    (void) fflush(stdout);
-                }
-                job->flags &= ~JOB_REMOTE;
-            }
-        }
+        {
+            if (((nLocal >= maxLocal) && !(job->flags & JOB_SPECIAL))) {
+                /*
+                 * Can't be exported and not allowed to run locally -- put it
+                 * back on the hold queue and mark the table full
+                 */
+                if (DEBUG(JOB)) {
+                    (void) fprintf(stdout, "holding\n");
+                    (void) fflush(stdout);
+                }
+                (void)Lst_AtFront(stoppedJobs, (ClientData)job);
+                jobFull = TRUE;
+                if (DEBUG(JOB)) {
+                    (void) fprintf(stdout, "Job queue is full.\n");
+                    (void) fflush(stdout);
+                }
+                return;
+            } else {
+                /*
+                 * Job may be run locally.
+                 */
+                if (DEBUG(JOB)) {
+                    (void) fprintf(stdout, "running locally\n");
+                    (void) fflush(stdout);
+                }
+                job->flags &= ~JOB_REMOTE;
+            }
+        }
 #ifdef REMOTE
-        else {
-            /*
-             * Can be exported. Hooray!
-             */
-            if (DEBUG(JOB)) {
-                (void) fprintf(stdout, "exporting\n");
-                (void) fflush(stdout);
-            }
-            job->flags |= JOB_REMOTE;
-        }
-#endif
-        JobExec(job, argv);
+        else {
+            /*
+             * Can be exported. Hooray!
+             */
+            if (DEBUG(JOB)) {
+                (void) fprintf(stdout, "exporting\n");
+                (void) fflush(stdout);
+            }
+            job->flags |= JOB_REMOTE;
+        }
+#endif
+        JobExec(job, argv);
     } else {
-        /*
-         * The job has stopped and needs to be restarted. Why it stopped,
-         * we don't know...
-         */
-        if (DEBUG(JOB)) {
-           (void) fprintf(stdout, "Resuming %s...", job->node->name);
-           (void) fflush(stdout);
-        }
-        if (((job->flags & JOB_REMOTE) ||
-            (nLocal < maxLocal) ||
+        /*
+         * The job has stopped and needs to be restarted. Why it stopped,
+         * we don't know...
+         */
+        if (DEBUG(JOB)) {
+           (void) fprintf(stdout, "Resuming %s...", job->node->name);
+           (void) fflush(stdout);
+        }
+        if (((job->flags & JOB_REMOTE) ||
+            (nLocal < maxLocal) ||
 #ifdef REMOTE
-            (((job->flags & JOB_SPECIAL) &&
-              (job->node->type & OP_NOEXPORT)) &&
-             (maxLocal == 0))) &&
+            (((job->flags & JOB_SPECIAL) &&
+              (job->node->type & OP_NOEXPORT)) &&
+             (maxLocal == 0))) &&
 #else
-            ((job->flags & JOB_SPECIAL) &&
-             (maxLocal == 0))) &&
-#endif
-           (nJobs != maxJobs))
-        {
-            /*
-             * If the job is remote, it's ok to resume it as long as the
-             * maximum concurrency won't be exceeded. If it's local and
-             * we haven't reached the local concurrency limit already (or the
-             * job must be run locally and maxLocal is 0), it's also ok to
-             * resume it.
-             */
-            Boolean error;
-            int status;
+            ((job->flags & JOB_SPECIAL) &&
+             (maxLocal == 0))) &&
+#endif
+           (nJobs != maxJobs))
+        {
+            /*
+             * If the job is remote, it's ok to resume it as long as the
+             * maximum concurrency won't be exceeded. If it's local and
+             * we haven't reached the local concurrency limit already (or the
+             * job must be run locally and maxLocal is 0), it's also ok to
+             * resume it.
+             */
+            Boolean error;
+            int status;
 
 #ifdef RMT_WANTS_SIGNALS
-            if (job->flags & JOB_REMOTE) {
-                error = !Rmt_Signal(job, SIGCONT);
-            } else
-#endif  /* RMT_WANTS_SIGNALS */
-                error = (KILL(job->pid, SIGCONT) != 0);
-
-            if (!error) {
-                /*
-                 * Make sure the user knows we've continued the beast and
-                 * actually put the thing in the job table.
-                 */
-                job->flags |= JOB_CONTINUING;
-                W_SETTERMSIG(&status, SIGCONT);
-                JobFinish(job, &status);
-
-                job->flags &= ~(JOB_RESUME|JOB_CONTINUING);
-                if (DEBUG(JOB)) {
-                   (void) fprintf(stdout, "done\n");
-                   (void) fflush(stdout);
-                }
-            } else {
-                Error("couldn't resume %s: %s",
-                    job->node->name, strerror(errno));
-                status = 0;
-                W_SETEXITSTATUS(&status, 1);
-                JobFinish(job, &status);
-            }
-        } else {
-            /*
-             * Job cannot be restarted. Mark the table as full and
-             * place the job back on the list of stopped jobs.
-             */
-            if (DEBUG(JOB)) {
-                (void) fprintf(stdout, "table full\n");
-                (void) fflush(stdout);
-            }
-            (void) Lst_AtFront(stoppedJobs, (ClientData)job);
-            jobFull = TRUE;
-            if (DEBUG(JOB)) {
-                (void) fprintf(stdout, "Job queue is full.\n");
-                (void) fflush(stdout);
-            }
-        }
+            if (job->flags & JOB_REMOTE) {
+                error = !Rmt_Signal(job, SIGCONT);
+            } else
+#endif  /* RMT_WANTS_SIGNALS */
+                error = (KILL(job->pid, SIGCONT) != 0);
+
+            if (!error) {
+                /*
+                 * Make sure the user knows we've continued the beast and
+                 * actually put the thing in the job table.
+                 */
+                job->flags |= JOB_CONTINUING;
+                W_SETTERMSIG(&status, SIGCONT);
+                JobFinish(job, &status);
+
+                job->flags &= ~(JOB_RESUME|JOB_CONTINUING);
+                if (DEBUG(JOB)) {
+                   (void) fprintf(stdout, "done\n");
+                   (void) fflush(stdout);
+                }
+            } else {
+                Error("couldn't resume %s: %s",
+                    job->node->name, strerror(errno));
+                status = 0;
+                W_SETEXITSTATUS(&status, 1);
+                JobFinish(job, &status);
+            }
+        } else {
+            /*
+             * Job cannot be restarted. Mark the table as full and
+             * place the job back on the list of stopped jobs.
+             */
+            if (DEBUG(JOB)) {
+                (void) fprintf(stdout, "table full\n");
+                (void) fflush(stdout);
+            }
+            (void) Lst_AtFront(stoppedJobs, (ClientData)job);
+            jobFull = TRUE;
+            if (DEBUG(JOB)) {
+                (void) fprintf(stdout, "Job queue is full.\n");
+                (void) fflush(stdout);
+            }
+        }
     }
 }
+#endif
 
 /*-
  *-----------------------------------------------------------------------
  * JobStart  --
- *      Start a target-creation process going for the target described
- *      by the graph node gn.
+ *      Start a target-creation process going for the target described
+ *      by the graph node gn.
  *
  * Results:
- *      JOB_ERROR if there was an error in the commands, JOB_FINISHED
- *      if there isn't actually anything left to do for the job and
- *      JOB_RUNNING if the job has been started.
+ *      JOB_ERROR if there was an error in the commands, JOB_FINISHED
+ *      if there isn't actually anything left to do for the job and
+ *      JOB_RUNNING if the job has been started.
  *
  * Side Effects:
- *      A new Job node is created and added to the list of running
- *      jobs. PMake is forked and a child shell created.
+ *      A new Job node is created and added to the list of running
+ *      jobs. PMake is forked and a child shell created.
  *-----------------------------------------------------------------------
  */
 static int
 JobStart(gn, flags, previous)
-    GNode         *gn;        /* target to create */
-    int            flags;      /* flags for the job to override normal ones.
-                               * e.g. JOB_SPECIAL or JOB_IGNDOTS */
-    Job           *previous;  /* The previous Job structure for this node,
-                               * if any. */
+    GNode         *gn;        /* target to create */
+    int            flags;      /* flags for the job to override normal ones.
+                               * e.g. JOB_SPECIAL or JOB_IGNDOTS */
+    Job           *previous;  /* The previous Job structure for this node,
+                               * if any. */
 {
     register Job  *job;       /* new job descriptor */
-    char          *argv[4];   /* Argument vector to shell */
-    Boolean       cmdsOK;     /* true if the nodes commands were all right */
-    Boolean       local;      /* Set true if the job was run locally */
-    Boolean       noExec;     /* Set true if we decide not to run the job */
-    int           tfd;        /* File descriptor for temp file */
+    char          *argv[4];   /* Argument vector to shell */
+    Boolean       cmdsOK;     /* true if the nodes commands were all right */
+    Boolean       local;      /* Set true if the job was run locally */
+    Boolean       noExec;     /* Set true if we decide not to run the job */
+    int           tfd;        /* File descriptor for temp file */
 
     if (previous != NULL) {
-        previous->flags &= ~(JOB_FIRST|JOB_IGNERR|JOB_SILENT|JOB_REMOTE);
-        job = previous;
+        previous->flags &= ~(JOB_FIRST|JOB_IGNERR|JOB_SILENT|JOB_REMOTE);
+        job = previous;
     } else {
-        job = (Job *) emalloc(sizeof(Job));
-        if (job == NULL) {
-            Punt("JobStart out of memory");
-        }
-        flags |= JOB_FIRST;
+        job = (Job *) emalloc(sizeof(Job));
+        if (job == NULL) {
+            Punt("JobStart out of memory");
+        }
+        flags |= JOB_FIRST;
     }
 
@@ -1750 +2150 @@
     job->flags = 0;
     if (Targ_Ignore(gn)) {
-        job->flags |= JOB_IGNERR;
+        job->flags |= JOB_IGNERR;
     }
     if (Targ_Silent(gn)) {
-        job->flags |= JOB_SILENT;
+        job->flags |= JOB_SILENT;
     }
     job->flags |= flags;
@@ -1762 +2162 @@
      */
     if (!compatMake && job->flags & JOB_FIRST) {
-        cmdsOK = Job_CheckCommands(gn, Error);
+        cmdsOK = Job_CheckCommands(gn, Error);
     } else {
-        cmdsOK = TRUE;
+        cmdsOK = TRUE;
     }
 
@@ -1774 +2174 @@
      */
     if ((gn->type & OP_MAKE) || (!noExecute && !touchFlag)) {
-        /*
-         * We're serious here, but if the commands were bogus, we're
-         * also dead...
-         */
-        if (!cmdsOK) {
-            DieHorribly();
-        }
-
-        (void) strcpy(tfile, TMPPAT);
-        if ((tfd = mkstemp(tfile)) == -1)
-            Punt("Cannot create temp file: %s", strerror(errno));
-        job->cmdFILE = fdopen(tfd, "w+");
-        eunlink(tfile);
-        if (job->cmdFILE == NULL) {
-            close(tfd);
-            Punt("Could not open %s", tfile);
-        }
-        (void) fcntl(FILENO(job->cmdFILE), F_SETFD, 1);
-        /*
-         * Send the commands to the command file, flush all its buffers then
-         * rewind and remove the thing.
-         */
-        noExec = FALSE;
-
-        /*
-         * used to be backwards; replace when start doing multiple commands
-         * per shell.
-         */
-        if (compatMake) {
-            /*
-             * Be compatible: If this is the first time for this node,
-             * verify its commands are ok and open the commands list for
-             * sequential access by later invocations of JobStart.
-             * Once that is done, we take the next command off the list
-             * and print it to the command file. If the command was an
-             * ellipsis, note that there's nothing more to execute.
-             */
-            if ((job->flags&JOB_FIRST) && (Lst_Open(gn->commands) != SUCCESS)){
-                cmdsOK = FALSE;
-            } else {
-                LstNode ln = Lst_Next(gn->commands);
-
-                if ((ln == NILLNODE) ||
-                    JobPrintCommand((ClientData) Lst_Datum(ln),
-                                    (ClientData) job))
-                {
-                    noExec = TRUE;
-                    Lst_Close(gn->commands);
-                }
-                if (noExec && !(job->flags & JOB_FIRST)) {
-                    /*
-                     * If we're not going to execute anything, the job
-                     * is done and we need to close down the various
-                     * file descriptors we've opened for output, then
-                     * call JobDoOutput to catch the final characters or
-                     * send the file to the screen... Note that the i/o streams
-                     * are only open if this isn't the first job.
-                     * Note also that this could not be done in
-                     * Job_CatchChildren b/c it wasn't clear if there were
-                     * more commands to execute or not...
-                     */
-                    JobClose(job);
-                }
-            }
-        } else {
-            /*
-             * We can do all the commands at once. hooray for sanity
-             */
-            numCommands = 0;
-            Lst_ForEach(gn->commands, JobPrintCommand, (ClientData)job);
-
-            /*
-             * If we didn't print out any commands to the shell script,
-             * there's not much point in executing the shell, is there?
-             */
-            if (numCommands == 0) {
-                noExec = TRUE;
-            }
-        }
+        /*
+         * We're serious here, but if the commands were bogus, we're
+         * also dead...
+         */
+        if (!cmdsOK) {
+            DieHorribly();
+        }
+
+        (void) strcpy(tfile, TMPPAT);
+        if ((tfd = mkstemp(tfile)) == -1)
+            Punt("Cannot create temp file: %s", strerror(errno));
+        job->cmdFILE = fdopen(tfd, "w+");
+        eunlink(tfile);
+        if (job->cmdFILE == NULL) {
+            close(tfd);
+            Punt("Could not open %s", tfile);
+        }
+        (void) fcntl(FILENO(job->cmdFILE), F_SETFD, 1);
+        /*
+         * Send the commands to the command file, flush all its buffers then
+         * rewind and remove the thing.
+         */
+        noExec = FALSE;
+
+        /*
+         * used to be backwards; replace when start doing multiple commands
+         * per shell.
+         */
+        if (compatMake) {
+            /*
+             * Be compatible: If this is the first time for this node,
+             * verify its commands are ok and open the commands list for
+             * sequential access by later invocations of JobStart.
+             * Once that is done, we take the next command off the list
+             * and print it to the command file. If the command was an
+             * ellipsis, note that there's nothing more to execute.
+             */
+            if ((job->flags&JOB_FIRST) && (Lst_Open(gn->commands) != SUCCESS)){
+                cmdsOK = FALSE;
+            } else {
+                LstNode ln = Lst_Next(gn->commands);
+
+                if ((ln == NILLNODE) ||
+                    JobPrintCommand((ClientData) Lst_Datum(ln),
+                                    (ClientData) job))
+                {
+                    noExec = TRUE;
+                    Lst_Close(gn->commands);
+                }
+                if (noExec && !(job->flags & JOB_FIRST)) {
+                    /*
+                     * If we're not going to execute anything, the job
+                     * is done and we need to close down the various
+                     * file descriptors we've opened for output, then
+                     * call JobDoOutput to catch the final characters or
+                     * send the file to the screen... Note that the i/o streams
+                     * are only open if this isn't the first job.
+                     * Note also that this could not be done in
+                     * Job_CatchChildren b/c it wasn't clear if there were
+                     * more commands to execute or not...
+                     */
+                    JobClose(job);
+                }
+            }
+        } else {
+            /*
+             * We can do all the commands at once. hooray for sanity
+             */
+            numCommands = 0;
+            Lst_ForEach(gn->commands, JobPrintCommand, (ClientData)job);
+
+            /*
+             * If we didn't print out any commands to the shell script,
+             * there's not much point in executing the shell, is there?
+             */
+            if (numCommands == 0) {
+                noExec = TRUE;
+            }
+        }
     } else if (noExecute) {
-        /*
-         * Not executing anything -- just print all the commands to stdout
-         * in one fell swoop. This will still set up job->tailCmds correctly.
-         */
-        if (lastNode != gn) {
-            MESSAGE(stdout, gn);
-            lastNode = gn;
-        }
-        job->cmdFILE = stdout;
-        /*
-         * Only print the commands if they're ok, but don't die if they're
-         * not -- just let the user know they're bad and keep going. It
-         * doesn't do any harm in this case and may do some good.
-         */
-        if (cmdsOK) {
-            Lst_ForEach(gn->commands, JobPrintCommand, (ClientData)job);
-        }
-        /*
-         * Don't execute the shell, thank you.
-         */
-        noExec = TRUE;
+        /*
+         * Not executing anything -- just print all the commands to stdout
+         * in one fell swoop. This will still set up job->tailCmds correctly.
+         */
+        if (lastNode != gn) {
+            MESSAGE(stdout, gn);
+            lastNode = gn;
+        }
+        job->cmdFILE = stdout;
+        /*
+         * Only print the commands if they're ok, but don't die if they're
+         * not -- just let the user know they're bad and keep going. It
+         * doesn't do any harm in this case and may do some good.
+         */
+        if (cmdsOK) {
+            Lst_ForEach(gn->commands, JobPrintCommand, (ClientData)job);
+        }
+        /*
+         * Don't execute the shell, thank you.
+         */
+        noExec = TRUE;
     } else {
-        /*
-         * Just touch the target and note that no shell should be executed.
-         * Set cmdFILE to stdout to make life easier. Check the commands, too,
-         * but don't die if they're no good -- it does no harm to keep working
-         * up the graph.
-         */
-        job->cmdFILE = stdout;
-        Job_Touch(gn, job->flags&JOB_SILENT);
-        noExec = TRUE;
+        /*
+         * Just touch the target and note that no shell should be executed.
+         * Set cmdFILE to stdout to make life easier. Check the commands, too,
+         * but don't die if they're no good -- it does no harm to keep working
+         * up the graph.
+         */
+        job->cmdFILE = stdout;
+        Job_Touch(gn, job->flags&JOB_SILENT);
+        noExec = TRUE;
     }
 
@@ -1891 +2291 @@
      */
     if (noExec) {
-        /*
-         * Unlink and close the command file if we opened one
-         */
-        if (job->cmdFILE != stdout) {
-            if (job->cmdFILE != NULL)
-                (void) fclose(job->cmdFILE);
-        } else {
-             (void) fflush(stdout);
-        }
-
-        /*
-         * We only want to work our way up the graph if we aren't here because
-         * the commands for the job were no good.
-         */
-        if (cmdsOK) {
-            if (aborting == 0) {
-                if (job->tailCmds != NILLNODE) {
-                    Lst_ForEachFrom(job->node->commands, job->tailCmds,
-                                    JobSaveCommand,
-                                   (ClientData)job->node);
-                }
-                job->node->made = MADE;
-                Make_Update(job->node);
-            }
-            efree((Address)job);
-            return(JOB_FINISHED);
-        } else {
-            efree((Address)job);
-            return(JOB_ERROR);
-        }
+        /*
+         * Unlink and close the command file if we opened one
+         */
+        if (job->cmdFILE != stdout) {
+            if (job->cmdFILE != NULL)
+                (void) fclose(job->cmdFILE);
+        } else {
+             (void) fflush(stdout);
+        }
+
+        /*
+         * We only want to work our way up the graph if we aren't here because
+         * the commands for the job were no good.
+         */
+        if (cmdsOK) {
+            if (aborting == 0) {
+                if (job->tailCmds != NILLNODE) {
+                    Lst_ForEachFrom(job->node->commands, job->tailCmds,
+                                    JobSaveCommand,
+                                   (ClientData)job->node);
+                }
+                job->node->made = MADE;
+                Make_Update(job->node);
+            }
+            efree((Address)job);
+            return(JOB_FINISHED);
+        } else {
+            efree((Address)job);
+            return(JOB_ERROR);
+        }
     } else {
-        (void) fflush(job->cmdFILE);
+        (void) fflush(job->cmdFILE);
     }
 
@@ -1937 +2337 @@
      */
     if (!compatMake || (job->flags & JOB_FIRST)) {
-        if (usePipes) {
-            int fd[2];
-            if (pipe(fd) == -1)
-                Punt("Cannot create pipe: %s", strerror(errno));
-            job->inPipe = fd[0];
-            job->outPipe = fd[1];
-            (void) fcntl(job->inPipe, F_SETFD, 1);
-            (void) fcntl(job->outPipe, F_SETFD, 1);
-        } else {
-            (void) fprintf(stdout, "Remaking `%s'\n", gn->name);
-            (void) fflush(stdout);
-            (void) strcpy(job->outFile, TMPPAT);
-            if ((job->outFd = mkstemp(job->outFile)) == -1)
-                Punt("cannot create temp file: %s", strerror(errno));
-            (void) fcntl(job->outFd, F_SETFD, 1);
-        }
+#ifdef USE_PIPES
+        if (usePipes) {
+            int fd[2];
+            if (pipe(fd) == -1)
+                Punt("Cannot create pipe: %s", strerror(errno));
+            job->inPipe = fd[0];
+            job->outPipe = fd[1];
+            (void) fcntl(job->inPipe, F_SETFD, 1);
+            (void) fcntl(job->outPipe, F_SETFD, 1);
+        }
+        else
+#endif /* USE_PIPES */
+        {
+            (void) fprintf(stdout, "Remaking `%s'\n", gn->name);
+            (void) fflush(stdout);
+            (void) strcpy(job->outFile, TMPPAT);
+            if ((job->outFd = mkstemp(job->outFile)) == -1)
+                Punt("cannot create temp file: %s", strerror(errno));
+            (void) fcntl(job->outFd, F_SETFD, 1);
+        }
     }
 
@@ -1958 +2362 @@
     if (!(gn->type & OP_NOEXPORT) && !(runLocalFirst && nLocal < maxLocal)) {
 #ifdef RMT_NO_EXEC
-        local = !Rmt_Export(shellPath, argv, job);
+        local = !Rmt_Export(shellPath, argv, job);
 #else
-        local = !Rmt_Begin(shellPath, argv, job->node);
+        local = !Rmt_Begin(shellPath, argv, job->node);
 #endif /* RMT_NO_EXEC */
-        if (!local) {
-            job->flags |= JOB_REMOTE;
-        }
+        if (!local) {
+            job->flags |= JOB_REMOTE;
+        }
     } else
 #endif
-        local = TRUE;
+        local = TRUE;
 
     if (local && (((nLocal >= maxLocal) &&
-        !(job->flags & JOB_SPECIAL) &&
+        !(job->flags & JOB_SPECIAL) &&
 #ifdef REMOTE
-        (!(gn->type & OP_NOEXPORT) || (maxLocal != 0))
+        (!(gn->type & OP_NOEXPORT) || (maxLocal != 0))
 #else
-        (maxLocal != 0)
-#endif
-        )))
+        (maxLocal != 0)
+#endif
+        )))
     {
-        /*
-         * The job can only be run locally, but we've hit the limit of
-         * local concurrency, so put the job on hold until some other job
-         * finishes. Note that the special jobs (.BEGIN, .INTERRUPT and .END)
-         * may be run locally even when the local limit has been reached
-         * (e.g. when maxLocal == 0), though they will be exported if at
-         * all possible. In addition, any target marked with .NOEXPORT will
-         * be run locally if maxLocal is 0.
-         */
-        jobFull = TRUE;
-
-        if (DEBUG(JOB)) {
-           (void) fprintf(stdout, "Can only run job locally.\n");
-           (void) fflush(stdout);
-        }
-        job->flags |= JOB_RESTART;
-        (void) Lst_AtEnd(stoppedJobs, (ClientData)job);
+        /*
+         * The job can only be run locally, but we've hit the limit of
+         * local concurrency, so put the job on hold until some other job
+         * finishes. Note that the special jobs (.BEGIN, .INTERRUPT and .END)
+         * may be run locally even when the local limit has been reached
+         * (e.g. when maxLocal == 0), though they will be exported if at
+         * all possible. In addition, any target marked with .NOEXPORT will
+         * be run locally if maxLocal is 0.
+         */
+        jobFull = TRUE;
+
+        if (DEBUG(JOB)) {
+           (void) fprintf(stdout, "Can only run job locally.\n");
+           (void) fflush(stdout);
+        }
+        job->flags |= JOB_RESTART;
+        (void) Lst_AtEnd(stoppedJobs, (ClientData)job);
     } else {
-        if ((nLocal >= maxLocal) && local) {
-            /*
-             * If we're running this job locally as a special case (see above),
-             * at least say the table is full.
-             */
-            jobFull = TRUE;
-            if (DEBUG(JOB)) {
-                (void) fprintf(stdout, "Local job queue is full.\n");
-                (void) fflush(stdout);
-            }
-        }
-        JobExec(job, argv);
+        if ((nLocal >= maxLocal) && local) {
+            /*
+             * If we're running this job locally as a special case (see above),
+             * at least say the table is full.
+             */
+            jobFull = TRUE;
+            if (DEBUG(JOB)) {
+                (void) fprintf(stdout, "Local job queue is full.\n");
+                (void) fflush(stdout);
+            }
+        }
+        JobExec(job, argv);
     }
     return(JOB_RUNNING);
@@ -2022 +2426 @@
     #ifndef KMK /* @Todo */
     if (commandShell->noPrint) {
-        ecp = Str_FindSubstring(cp, commandShell->noPrint);
-        while (ecp != NULL) {
-            if (cp != ecp) {
-                *ecp = '\0';
-                if (msg && job->node != lastNode) {
-                    MESSAGE(stdout, job->node);
-                    lastNode = job->node;
-                }
-                /*
-                 * The only way there wouldn't be a newline after
-                 * this line is if it were the last in the buffer.
-                 * however, since the non-printable comes after it,
-                 * there must be a newline, so we don't print one.
-                 */
-                (void) fprintf(stdout, "%s", cp);
-                (void) fflush(stdout);
-            }
-            cp = ecp + commandShell->noPLen;
-            if (cp != endp) {
-                /*
-                 * Still more to print, look again after skipping
-                 * the whitespace following the non-printable
-                 * command....
-                 */
-                cp++;
-                while (*cp == ' ' || *cp == '\t' || *cp == '\n') {
-                    cp++;
-                }
-                ecp = Str_FindSubstring(cp, commandShell->noPrint);
-            } else {
-                return cp;
-            }
-        }
+        ecp = Str_FindSubstring(cp, commandShell->noPrint);
+        while (ecp != NULL) {
+            if (cp != ecp) {
+                *ecp = '\0';
+                if (msg && job->node != lastNode) {
+                    MESSAGE(stdout, job->node);
+                    lastNode = job->node;
+                }
+                /*
+                 * The only way there wouldn't be a newline after
+                 * this line is if it were the last in the buffer.
+                 * however, since the non-printable comes after it,
+                 * there must be a newline, so we don't print one.
+                 */
+                (void) fprintf(stdout, "%s", cp);
+                (void) fflush(stdout);
+            }
+            cp = ecp + commandShell->noPLen;
+            if (cp != endp) {
+                /*
+                 * Still more to print, look again after skipping
+                 * the whitespace following the non-printable
+                 * command....
+                 */
+                cp++;
+                while (*cp == ' ' || *cp == '\t' || *cp == '\n') {
+                    cp++;
+                }
+                ecp = Str_FindSubstring(cp, commandShell->noPrint);
+            } else {
+                return cp;
+            }
+        }
     }
     #endif /*!KMK*/
@@ -2063 +2467 @@
  *-----------------------------------------------------------------------
  * JobDoOutput  --
- *      This function is called at different times depending on
- *      whether the user has specified that output is to be collected
- *      via pipes or temporary files. In the former case, we are called
- *      whenever there is something to read on the pipe. We collect more
- *      output from the given job and store it in the job's outBuf. If
- *      this makes up a line, we print it tagged by the job's identifier,
- *      as necessary.
- *      If output has been collected in a temporary file, we open the
- *      file and read it line by line, transfering it to our own
- *      output channel until the file is empty. At which point we
- *      remove the temporary file.
- *      In both cases, however, we keep our figurative eye out for the
- *      'noPrint' line for the shell from which the output came. If
- *      we recognize a line, we don't print it. If the command is not
- *      alone on the line (the character after it is not \0 or \n), we
- *      do print whatever follows it.
+ *      This function is called at different times depending on
+ *      whether the user has specified that output is to be collected
+ *      via pipes or temporary files. In the former case, we are called
+ *      whenever there is something to read on the pipe. We collect more
+ *      output from the given job and store it in the job's outBuf. If
+ *      this makes up a line, we print it tagged by the job's identifier,
+ *      as necessary.
+ *      If output has been collected in a temporary file, we open the
+ *      file and read it line by line, transfering it to our own
+ *      output channel until the file is empty. At which point we
+ *      remove the temporary file.
+ *      In both cases, however, we keep our figurative eye out for the
+ *      'noPrint' line for the shell from which the output came. If
+ *      we recognize a line, we don't print it. If the command is not
+ *      alone on the line (the character after it is not \0 or \n), we
+ *      do print whatever follows it.
  *
  * Results:
- *      None
+ *      None
  *
  * Side Effects:
- *      curPos may be shifted as may the contents of outBuf.
+ *      curPos may be shifted as may the contents of outBuf.
  *-----------------------------------------------------------------------
  */
 STATIC void
 JobDoOutput(job, finish)
-    register Job   *job;          /* the job whose output needs printing */
-    Boolean        finish;        /* TRUE if this is the last time we'll be
-                                   * called for this job */
+    register Job   *job;          /* the job whose output needs printing */
+    Boolean        finish;        /* TRUE if this is the last time we'll be
+                                   * called for this job */
 {
     Boolean       gotNL = FALSE;  /* true if got a newline */
-    Boolean       fbuf;           /* true if our buffer filled up */
-    register int  nr;             /* number of bytes read */
-    register int  i;              /* auxiliary index into outBuf */
-    register int  max;            /* limit for i (end of current data) */
-    int           nRead;          /* (Temporary) number of bytes read */
-
-    FILE          *oFILE;         /* Stream pointer to shell's output file */
+    Boolean       fbuf;           /* true if our buffer filled up */
+    register int  nr;             /* number of bytes read */
+    register int  i;              /* auxiliary index into outBuf */
+    register int  max;            /* limit for i (end of current data) */
+    int           nRead;          /* (Temporary) number of bytes read */
+
+    FILE          *oFILE;         /* Stream pointer to shell's output file */
     char          inLine[132];
 
 
+#ifdef USE_PIPES
     if (usePipes) {
-        /*
-         * Read as many bytes as will fit in the buffer.
-         */
+        /*
+         * Read as many bytes as will fit in the buffer.
+         */
 end_loop:
-        gotNL = FALSE;
-        fbuf = FALSE;
-
-        nRead = read(job->inPipe, &job->outBuf[job->curPos],
-                         JOB_BUFSIZE - job->curPos);
-        if (nRead < 0) {
-            if (DEBUG(JOB)) {
-                perror("JobDoOutput(piperead)");
-            }
-            nr = 0;
-        } else {
-            nr = nRead;
-        }
-
-        /*
-         * If we hit the end-of-file (the job is dead), we must flush its
-         * remaining output, so pretend we read a newline if there's any
-         * output remaining in the buffer.
-         * Also clear the 'finish' flag so we stop looping.
-         */
-        if ((nr == 0) && (job->curPos != 0)) {
-            job->outBuf[job->curPos] = '\n';
-            nr = 1;
-            finish = FALSE;
-        } else if (nr == 0) {
-            finish = FALSE;
-        }
-
-        /*
-         * Look for the last newline in the bytes we just got. If there is
-         * one, break out of the loop with 'i' as its index and gotNL set
-         * TRUE.
-         */
-        max = job->curPos + nr;
-        for (i = job->curPos + nr - 1; i >= job->curPos; i--) {
-            if (job->outBuf[i] == '\n') {
-                gotNL = TRUE;
-                break;
-            } else if (job->outBuf[i] == '\0') {
-                /*
-                 * Why?
-                 */
-                job->outBuf[i] = ' ';
-            }
-        }
-
-        if (!gotNL) {
-            job->curPos += nr;
-            if (job->curPos == JOB_BUFSIZE) {
-                /*
-                 * If we've run out of buffer space, we have no choice
-                 * but to print the stuff. sigh.
-                 */
-                fbuf = TRUE;
-                i = job->curPos;
-            }
-        }
-        if (gotNL || fbuf) {
-            /*
-             * Need to send the output to the screen. Null terminate it
-             * first, overwriting the newline character if there was one.
-             * So long as the line isn't one we should filter (according
-             * to the shell description), we print the line, preceeded
-             * by a target banner if this target isn't the same as the
-             * one for which we last printed something.
-             * The rest of the data in the buffer are then shifted down
-             * to the start of the buffer and curPos is set accordingly.
-             */
-            job->outBuf[i] = '\0';
-            if (i >= job->curPos) {
-                char *cp;
-
-                cp = JobOutput(job, job->outBuf, &job->outBuf[i], FALSE);
-
-                /*
-                 * There's still more in that thar buffer. This time, though,
-                 * we know there's no newline at the end, so we add one of
-                 * our own efree will.
-                 */
-                if (*cp != '\0') {
-                    if (job->node != lastNode) {
-                        MESSAGE(stdout, job->node);
-                        lastNode = job->node;
-                    }
-                    (void) fprintf(stdout, "%s%s", cp, gotNL ? "\n" : "");
-                    (void) fflush(stdout);
-                }
-            }
-            if (i < max - 1) {
-                /* shift the remaining characters down */
-                (void) memcpy(job->outBuf, &job->outBuf[i + 1], max - (i + 1));
-                job->curPos = max - (i + 1);
-
-            } else {
-                /*
-                 * We have written everything out, so we just start over
-                 * from the start of the buffer. No copying. No nothing.
-                 */
-                job->curPos = 0;
-            }
-        }
-        if (finish) {
-            /*
-             * If the finish flag is true, we must loop until we hit
-             * end-of-file on the pipe. This is guaranteed to happen
-             * eventually since the other end of the pipe is now closed
-             * (we closed it explicitly and the child has exited). When
-             * we do get an EOF, finish will be set FALSE and we'll fall
-             * through and out.
-             */
-            goto end_loop;
-        }
-    } else {
-        /*
-         * We've been called to retrieve the output of the job from the
-         * temporary file where it's been squirreled away. This consists of
-         * opening the file, reading the output line by line, being sure not
-         * to print the noPrint line for the shell we used, then close and
-         * remove the temporary file. Very simple.
-         *
-         * Change to read in blocks and do FindSubString type things as for
-         * pipes? That would allow for "@echo -n..."
-         */
-        oFILE = fopen(job->outFile, "r");
-        if (oFILE != NULL) {
-            (void) fprintf(stdout, "Results of making %s:\n", job->node->name);
-            (void) fflush(stdout);
-            while (fgets(inLine, sizeof(inLine), oFILE) != NULL) {
-                register char   *cp, *endp, *oendp;
-
-                cp = inLine;
-                oendp = endp = inLine + strlen(inLine);
-                if (endp[-1] == '\n') {
-                    *--endp = '\0';
-                }
-                cp = JobOutput(job, inLine, endp, FALSE);
-
-                /*
-                 * There's still more in that thar buffer. This time, though,
-                 * we know there's no newline at the end, so we add one of
-                 * our own efree will.
-                 */
-                (void) fprintf(stdout, "%s", cp);
-                (void) fflush(stdout);
-                if (endp != oendp) {
-                    (void) fprintf(stdout, "\n");
-                    (void) fflush(stdout);
-                }
-            }
-            (void) fclose(oFILE);
-            (void) eunlink(job->outFile);
-        }
+        gotNL = FALSE;
+        fbuf = FALSE;
+
+        nRead = read(job->inPipe, &job->outBuf[job->curPos],
+                         JOB_BUFSIZE - job->curPos);
+        if (nRead < 0) {
+            if (DEBUG(JOB)) {
+                perror("JobDoOutput(piperead)");
+            }
+            nr = 0;
+        } else {
+            nr = nRead;
+        }
+
+        /*
+         * If we hit the end-of-file (the job is dead), we must flush its
+         * remaining output, so pretend we read a newline if there's any
+         * output remaining in the buffer.
+         * Also clear the 'finish' flag so we stop looping.
+         */
+        if ((nr == 0) && (job->curPos != 0)) {
+            job->outBuf[job->curPos] = '\n';
+            nr = 1;
+            finish = FALSE;
+        } else if (nr == 0) {
+            finish = FALSE;
+        }
+
+        /*
+         * Look for the last newline in the bytes we just got. If there is
+         * one, break out of the loop with 'i' as its index and gotNL set
+         * TRUE.
+         */
+        max = job->curPos + nr;
+        for (i = job->curPos + nr - 1; i >= job->curPos; i--) {
+            if (job->outBuf[i] == '\n') {
+                gotNL = TRUE;
+                break;
+            } else if (job->outBuf[i] == '\0') {
+                /*
+                 * Why?
+                 */
+                job->outBuf[i] = ' ';
+            }
+        }
+
+        if (!gotNL) {
+            job->curPos += nr;
+            if (job->curPos == JOB_BUFSIZE) {
+                /*
+                 * If we've run out of buffer space, we have no choice
+                 * but to print the stuff. sigh.
+                 */
+                fbuf = TRUE;
+                i = job->curPos;
+            }
+        }
+        if (gotNL || fbuf) {
+            /*
+             * Need to send the output to the screen. Null terminate it
+             * first, overwriting the newline character if there was one.
+             * So long as the line isn't one we should filter (according
+             * to the shell description), we print the line, preceeded
+             * by a target banner if this target isn't the same as the
+             * one for which we last printed something.
+             * The rest of the data in the buffer are then shifted down
+             * to the start of the buffer and curPos is set accordingly.
+             */
+            job->outBuf[i] = '\0';
+            if (i >= job->curPos) {
+                char *cp;
+
+                cp = JobOutput(job, job->outBuf, &job->outBuf[i], FALSE);
+
+                /*
+                 * There's still more in that thar buffer. This time, though,
+                 * we know there's no newline at the end, so we add one of
+                 * our own efree will.
+                 */
+                if (*cp != '\0') {
+                    if (job->node != lastNode) {
+                        MESSAGE(stdout, job->node);
+                        lastNode = job->node;
+                    }
+                    (void) fprintf(stdout, "%s%s", cp, gotNL ? "\n" : "");
+                    (void) fflush(stdout);
+                }
+            }
+            if (i < max - 1) {
+                /* shift the remaining characters down */
+                (void) memcpy(job->outBuf, &job->outBuf[i + 1], max - (i + 1));
+                job->curPos = max - (i + 1);
+
+            } else {
+                /*
+                 * We have written everything out, so we just start over
+                 * from the start of the buffer. No copying. No nothing.
+                 */
+                job->curPos = 0;
+            }
+        }
+        if (finish) {
+            /*
+             * If the finish flag is true, we must loop until we hit
+             * end-of-file on the pipe. This is guaranteed to happen
+             * eventually since the other end of the pipe is now closed
+             * (we closed it explicitly and the child has exited). When
+             * we do get an EOF, finish will be set FALSE and we'll fall
+             * through and out.
+             */
+            goto end_loop;
+        }
+    }
+    else
+#endif /* USE_PIPES */
+    {
+        /*
+         * We've been called to retrieve the output of the job from the
+         * temporary file where it's been squirreled away. This consists of
+         * opening the file, reading the output line by line, being sure not
+         * to print the noPrint line for the shell we used, then close and
+         * remove the temporary file. Very simple.
+         *
+         * Change to read in blocks and do FindSubString type things as for
+         * pipes? That would allow for "@echo -n..."
+         */
+        oFILE = fopen(job->outFile, "r");
+        if (oFILE != NULL) {
+            (void) fprintf(stdout, "Results of making %s:\n", job->node->name);
+            (void) fflush(stdout);
+            while (fgets(inLine, sizeof(inLine), oFILE) != NULL) {
+                register char   *cp, *endp, *oendp;
+
+                cp = inLine;
+                oendp = endp = inLine + strlen(inLine);
+                if (endp[-1] == '\n') {
+                    *--endp = '\0';
+                }
+                cp = JobOutput(job, inLine, endp, FALSE);
+
+                /*
+                 * There's still more in that thar buffer. This time, though,
+                 * we know there's no newline at the end, so we add one of
+                 * our own efree will.
+                 */
+                (void) fprintf(stdout, "%s", cp);
+                (void) fflush(stdout);
+                if (endp != oendp) {
+                    (void) fprintf(stdout, "\n");
+                    (void) fflush(stdout);
+                }
+            }
+            (void) fclose(oFILE);
+            (void) eunlink(job->outFile);
+        }
     }
 }
@@ -2267 +2675 @@
  *-----------------------------------------------------------------------
  * Job_CatchChildren --
- *      Handle the exit of a child. Called from Make_Make.
+ *      Handle the exit of a child. Called from Make_Make.
  *
  * Results:
- *      none.
+ *      none.
  *
  * Side Effects:
- *      The job descriptor is removed from the list of children.
+ *      The job descriptor is removed from the list of children.
  *
  * Notes:
- *      We do waits, blocking or not, according to the wisdom of our
- *      caller, until there are no more children to report. For each
- *      job, call JobFinish to finish things off. This will take care of
- *      putting jobs on the stoppedJobs queue.
+ *      We do waits, blocking or not, according to the wisdom of our
+ *      caller, until there are no more children to report. For each
+ *      job, call JobFinish to finish things off. This will take care of
+ *      putting jobs on the stoppedJobs queue.
  *
  *-----------------------------------------------------------------------
@@ -2285 +2693 @@
 void
 Job_CatchChildren(block)
-    Boolean       block;        /* TRUE if should block on the wait. */
+    Boolean       block;        /* TRUE if should block on the wait. */
 {
-    int           pid;          /* pid of dead child */
-    register Job  *job;         /* job descriptor for dead child */
-    LstNode       jnode;        /* list element for finding job */
-    int           status;       /* Exit/termination status */
+#ifdef USE_KLIB
+    int           pid;          /* pid of dead child */
+    register Job *job;          /* job descriptor for dead child */
+    LstNode       jnode;        /* list element for finding job */
+    KPROCRES      status;       /* Exit/termination status */
 
     /*
@@ -2296 +2705 @@
      */
     if (nLocal == 0) {
-        return;
+        return;
+    }
+
+    while (!kProcWait(KPID_NULL, KPROCWAIT_FLAGS_NOWAIT, &status, &pid))
+    {
+        if (DEBUG(JOB)) {
+            (void) fprintf(stdout, "Process %d exited or stopped.\n", pid);
+            (void) fflush(stdout);
+        }
+
+        jnode = Lst_Find(jobs, (ClientData)&pid, JobCmpPid);
+        if (jnode == NILLNODE) {
+            Error("Child (%d) not in table?", pid);
+            continue;
+        } else {
+            job = (Job *) Lst_Datum(jnode);
+            (void) Lst_Remove(jobs, jnode);
+            nJobs -= 1;
+            if (jobFull && DEBUG(JOB)) {
+                (void) fprintf(stdout, "Job queue is no longer full.\n");
+                (void) fflush(stdout);
+            }
+            jobFull = FALSE;
+            nLocal -= 1;
+        }
+        JobFinish(job, &status);
+    }
+
+#else /* Don't Use kLib */
+    int           pid;          /* pid of dead child */
+    register Job  *job;         /* job descriptor for dead child */
+    LstNode       jnode;        /* list element for finding job */
+    int           status;       /* Exit/termination status */
+
+    /*
+     * Don't even bother if we know there's no one around.
+     */
+    if (nLocal == 0) {
+        return;
     }
 
     while ((pid = waitpid((pid_t) -1, &status,
-                          (block?0:WNOHANG)|WUNTRACED)) > 0)
+                          (block?0:WNOHANG)|WUNTRACED)) > 0)
     {
-        if (DEBUG(JOB)) {
-            (void) fprintf(stdout, "Process %d exited or stopped.\n", pid);
-            (void) fflush(stdout);
-        }
-
-
-        jnode = Lst_Find(jobs, (ClientData)&pid, JobCmpPid);
-
-        if (jnode == NILLNODE) {
-            if (WIFSIGNALED(status) && (WTERMSIG(status) == SIGCONT)) {
-                jnode = Lst_Find(stoppedJobs, (ClientData) &pid, JobCmpPid);
-                if (jnode == NILLNODE) {
-                    Error("Resumed child (%d) not in table", pid);
-                    continue;
-                }
-                job = (Job *)Lst_Datum(jnode);
-                (void) Lst_Remove(stoppedJobs, jnode);
-            } else {
-                Error("Child (%d) not in table?", pid);
-                continue;
-            }
-        } else {
-            job = (Job *) Lst_Datum(jnode);
-            (void) Lst_Remove(jobs, jnode);
-            nJobs -= 1;
-            if (jobFull && DEBUG(JOB)) {
-                (void) fprintf(stdout, "Job queue is no longer full.\n");
-                (void) fflush(stdout);
-            }
-            jobFull = FALSE;
+        if (DEBUG(JOB)) {
+            (void) fprintf(stdout, "Process %d exited or stopped.\n", pid);
+            (void) fflush(stdout);
+        }
+
+
+        jnode = Lst_Find(jobs, (ClientData)&pid, JobCmpPid);
+
+        if (jnode == NILLNODE) {
+            if (WIFSIGNALED(status) && (WTERMSIG(status) == SIGCONT)) {
+                jnode = Lst_Find(stoppedJobs, (ClientData) &pid, JobCmpPid);
+                if (jnode == NILLNODE) {
+                    Error("Resumed child (%d) not in table", pid);
+                    continue;
+                }
+                job = (Job *)Lst_Datum(jnode);
+                (void) Lst_Remove(stoppedJobs, jnode);
+            } else {
+                Error("Child (%d) not in table?", pid);
+                continue;
+            }
+        } else {
+            job = (Job *) Lst_Datum(jnode);
+            (void) Lst_Remove(jobs, jnode);
+            nJobs -= 1;
+            if (jobFull && DEBUG(JOB)) {
+                (void) fprintf(stdout, "Job queue is no longer full.\n");
+                (void) fflush(stdout);
+            }
+            jobFull = FALSE;
 #ifdef REMOTE
-            if (!(job->flags & JOB_REMOTE)) {
-                if (DEBUG(JOB)) {
-                    (void) fprintf(stdout,
-                                   "Job queue has one fewer local process.\n");
-                    (void) fflush(stdout);
-                }
-                nLocal -= 1;
-            }
+            if (!(job->flags & JOB_REMOTE)) {
+                if (DEBUG(JOB)) {
+                    (void) fprintf(stdout,
+                                   "Job queue has one fewer local process.\n");
+                    (void) fflush(stdout);
+                }
+                nLocal -= 1;
+            }
 #else
-            nLocal -= 1;
-#endif
-        }
-
-        JobFinish(job, &status);
-    }
+            nLocal -= 1;
+#endif
+        }
+
+        JobFinish(job, &status);
+    }
+#endif /* USE_KLIB */
 }
 
@@ -2353 +2801 @@
  *-----------------------------------------------------------------------
  * Job_CatchOutput --
- *      Catch the output from our children, if we're using
- *      pipes do so. Otherwise just block time until we get a
- *      signal (most likely a SIGCHLD) since there's no point in
- *      just spinning when there's nothing to do and the reaping
- *      of a child can wait for a while.
+ *      Catch the output from our children, if we're using
+ *      pipes do so. Otherwise just block time until we get a
+ *      signal (most likely a SIGCHLD) since there's no point in
+ *      just spinning when there's nothing to do and the reaping
+ *      of a child can wait for a while.
  *
  * Results:
- *      None
+ *      None
  *
  * Side Effects:
- *      Output is read from pipes if we're piping.
+ *      Output is read from pipes if we're piping.
  * -----------------------------------------------------------------------
  */
@@ -2369 +2817 @@
 Job_CatchOutput()
 {
-    int                   nfds;
-    struct timeval        timeout;
-    fd_set                readfds;
-    register LstNode      ln;
-    register Job          *job;
+    int                   nfds;
+    struct timeval        timeout;
+    fd_set                readfds;
+    register LstNode      ln;
+    register Job          *job;
 #ifdef RMT_WILL_WATCH
-    int                   pnJobs;       /* Previous nJobs */
+    int                   pnJobs;       /* Previous nJobs */
 #endif
 
@@ -2399 +2847 @@
      */
     while (nJobs != 0 && pnJobs == nJobs) {
-        Rmt_Wait();
+        Rmt_Wait();
     }
 #else
+#ifdef USE_PIPES
     if (usePipes) {
-        readfds = outputs;
-        timeout.tv_sec = SEL_SEC;
-        timeout.tv_usec = SEL_USEC;
-
-        if ((nfds = select(FD_SETSIZE, &readfds, (fd_set *) 0,
-                           (fd_set *) 0, &timeout)) <= 0)
-            return;
-        else {
-            if (Lst_Open(jobs) == FAILURE) {
-                Punt("Cannot open job table");
-            }
-            while (nfds && (ln = Lst_Next(jobs)) != NILLNODE) {
-                job = (Job *) Lst_Datum(ln);
-                if (FD_ISSET(job->inPipe, &readfds)) {
-                    JobDoOutput(job, FALSE);
-                    nfds -= 1;
-                }
-            }
-            Lst_Close(jobs);
-        }
-    }
+        readfds = outputs;
+        timeout.tv_sec = SEL_SEC;
+        timeout.tv_usec = SEL_USEC;
+
+        if ((nfds = select(FD_SETSIZE, &readfds, (fd_set *) 0,
+                           (fd_set *) 0, &timeout)) <= 0)
+            return;
+        else {
+            if (Lst_Open(jobs) == FAILURE) {
+                Punt("Cannot open job table");
+            }
+            while (nfds && (ln = Lst_Next(jobs)) != NILLNODE) {
+                job = (Job *) Lst_Datum(ln);
+                if (FD_ISSET(job->inPipe, &readfds)) {
+                    JobDoOutput(job, FALSE);
+                    nfds -= 1;
+                }
+            }
+            Lst_Close(jobs);
+        }
+    }
+#endif /* USE_PIPES */
 #endif /* RMT_WILL_WATCH */
 }
@@ -2430 +2880 @@
  *-----------------------------------------------------------------------
  * Job_Make --
- *      Start the creation of a target. Basically a front-end for
- *      JobStart used by the Make module.
+ *      Start the creation of a target. Basically a front-end for
+ *      JobStart used by the Make module.
  *
  * Results:
- *      None.
+ *      None.
  *
  * Side Effects:
- *      Another job is started.
+ *      Another job is started.
  *
  *-----------------------------------------------------------------------
@@ -2451 +2901 @@
  *-----------------------------------------------------------------------
  * Job_Init --
- *      Initialize the process module
+ *      Initialize the process module
  *
  * Results:
- *      none
+ *      none
  *
  * Side Effects:
- *      lists and counters are initialized
+ *      lists and counters are initialized
  *-----------------------------------------------------------------------
  */
@@ -2463 +2913 @@
 Job_Init(maxproc, maxlocal)
     int           maxproc;  /* the greatest number of jobs which may be
-                             * running at one time */
-    int           maxlocal; /* the greatest number of local jobs which may
-                             * be running at once. */
+                             * running at one time */
+    int           maxlocal; /* the greatest number of local jobs which may
+                             * be running at once. */
 {
     GNode         *begin;     /* node for commands to do at the very start */
 
-    jobs =        Lst_Init(FALSE);
+    jobs =        Lst_Init(FALSE);
+#ifdef SIGCONT
     stoppedJobs = Lst_Init(FALSE);
-    maxJobs =     maxproc;
-    maxLocal =    maxlocal;
-    nJobs =       0;
-    nLocal =      0;
-    jobFull =     FALSE;
-
-    aborting =    0;
-    errors =      0;
-
-    lastNode =    NILGNODE;
+#endif
+    maxJobs =     maxproc;
+    maxLocal =    maxlocal;
+    nJobs =       0;
+    nLocal =      0;
+    jobFull =     FALSE;
+
+    aborting =    0;
+    errors =      0;
+
+    lastNode =    NILGNODE;
 
     if (maxJobs == 1 || beVerbose == 0
 #ifdef REMOTE
-        || noMessages
-#endif
-                     ) {
-        /*
-         * If only one job can run at a time, there's no need for a banner,
-         * no is there?
-         */
-        targFmt = "";
+        || noMessages
+#endif
+                     ) {
+        /*
+         * If only one job can run at a time, there's no need for a banner,
+         * no is there?
+         */
+        targFmt = "";
     } else {
-        targFmt = TARG_FMT;
+        targFmt = TARG_FMT;
     }
 
 #ifndef KMK
     if (shellPath == NULL) {
-        /*
-         * The user didn't specify a shell to use, so we are using the
-         * default one... Both the absolute path and the last component
-         * must be set. The last component is taken from the 'name' field
-         * of the default shell description pointed-to by commandShell.
-         * All default shells are located in _PATH_DEFSHELLDIR.
-         */
-        shellName = commandShell->name;
-        shellPath = str_concat(_PATH_DEFSHELLDIR, shellName, STR_ADDSLASH);
+        /*
+         * The user didn't specify a shell to use, so we are using the
+         * default one... Both the absolute path and the last component
+         * must be set. The last component is taken from the 'name' field
+         * of the default shell description pointed-to by commandShell.
+         * All default shells are located in _PATH_DEFSHELLDIR.
+         */
+        shellName = commandShell->name;
+        shellPath = str_concat(_PATH_DEFSHELLDIR, shellName, STR_ADDSLASH);
     }
 
     if (commandShell->exit == NULL) {
-        commandShell->exit = "";
+        commandShell->exit = "";
     }
     if (commandShell->echo == NULL) {
-        commandShell->echo = "";
+        commandShell->echo = "";
     }
 #endif
@@ -2522 +2974 @@
      */
     if (signal(SIGINT, SIG_IGN) != SIG_IGN) {
-        (void) signal(SIGINT, JobPassSig);
-    }
+        (void) signal(SIGINT, JobPassSig);
+    }
+#ifdef SIGHUP  /* not all systems supports this signal */
     if (signal(SIGHUP, SIG_IGN) != SIG_IGN) {
-        (void) signal(SIGHUP, JobPassSig);
-    }
+        (void) signal(SIGHUP, JobPassSig);
+    }
+#endif
+#ifdef SIGQUIT /* not all systems supports this signal */
     if (signal(SIGQUIT, SIG_IGN) != SIG_IGN) {
-        (void) signal(SIGQUIT, JobPassSig);
-    }
+        (void) signal(SIGQUIT, JobPassSig);
+    }
+#endif
     if (signal(SIGTERM, SIG_IGN) != SIG_IGN) {
-        (void) signal(SIGTERM, JobPassSig);
+        (void) signal(SIGTERM, JobPassSig);
     }
     /*
@@ -2541 +2997 @@
 #if defined(RMT_WANTS_SIGNALS) || defined(USE_PGRP)
     if (signal(SIGTSTP, SIG_IGN) != SIG_IGN) {
-        (void) signal(SIGTSTP, JobPassSig);
+        (void) signal(SIGTSTP, JobPassSig);
     }
     if (signal(SIGTTOU, SIG_IGN) != SIG_IGN) {
-        (void) signal(SIGTTOU, JobPassSig);
+        (void) signal(SIGTTOU, JobPassSig);
     }
     if (signal(SIGTTIN, SIG_IGN) != SIG_IGN) {
-        (void) signal(SIGTTIN, JobPassSig);
+        (void) signal(SIGTTIN, JobPassSig);
     }
     if (signal(SIGWINCH, SIG_IGN) != SIG_IGN) {
-        (void) signal(SIGWINCH, JobPassSig);
+        (void) signal(SIGWINCH, JobPassSig);
     }
 #endif
@@ -2557 +3013 @@
 
     if (begin != NILGNODE) {
-        JobStart(begin, JOB_SPECIAL, (Job *)0);
-        while (nJobs) {
-            Job_CatchOutput();
+        JobStart(begin, JOB_SPECIAL, (Job *)0);
+        while (nJobs) {
+            Job_CatchOutput();
 #ifndef RMT_WILL_WATCH
-            Job_CatchChildren(!usePipes);
+            Job_CatchChildren(!usePipes);
 #endif /* RMT_WILL_WATCH */
-        }
+        }
     }
     postCommands = Targ_FindNode(".END", TARG_CREATE);
@@ -2571 +3027 @@
  *-----------------------------------------------------------------------
  * Job_Full --
- *      See if the job table is full. It is considered full if it is OR
- *      if we are in the process of aborting OR if we have
- *      reached/exceeded our local quota. This prevents any more jobs
- *      from starting up.
+ *      See if the job table is full. It is considered full if it is OR
+ *      if we are in the process of aborting OR if we have
+ *      reached/exceeded our local quota. This prevents any more jobs
+ *      from starting up.
  *
  * Results:
- *      TRUE if the job table is full, FALSE otherwise
+ *      TRUE if the job table is full, FALSE otherwise
  * Side Effects:
- *      None.
+ *      None.
  *-----------------------------------------------------------------------
  */
@@ -2591 +3047 @@
  *-----------------------------------------------------------------------
  * Job_Empty --
- *      See if the job table is empty.  Because the local concurrency may
- *      be set to 0, it is possible for the job table to become empty,
- *      while the list of stoppedJobs remains non-empty. In such a case,
- *      we want to restart as many jobs as we can.
+ *      See if the job table is empty.  Because the local concurrency may
+ *      be set to 0, it is possible for the job table to become empty,
+ *      while the list of stoppedJobs remains non-empty. In such a case,
+ *      we want to restart as many jobs as we can.
  *
  * Results:
- *      TRUE if it is. FALSE if it ain't.
+ *      TRUE if it is. FALSE if it ain't.
  *
  * Side Effects:
- *      None.
+ *      None.
  *
  * -----------------------------------------------------------------------
@@ -2608 +3064 @@
 {
     if (nJobs == 0) {
-        if (!Lst_IsEmpty(stoppedJobs) && !aborting) {
-            /*
-             * The job table is obviously not full if it has no jobs in
-             * it...Try and restart the stopped jobs.
-             */
-            jobFull = FALSE;
-            JobRestartJobs();
-            return(FALSE);
-        } else {
-            return(TRUE);
-        }
+#ifdef SIGCONT
+        if (!Lst_IsEmpty(stoppedJobs) && !aborting) {
+            /*
+             * The job table is obviously not full if it has no jobs in
+             * it...Try and restart the stopped jobs.
+             */
+            jobFull = FALSE;
+            JobRestartJobs();
+            return(FALSE);
+        }
+#else
+        return(TRUE);
+#endif
     } else {
-        return(FALSE);
+        return(FALSE);
     }
 }
@@ -2628 +3086 @@
  *-----------------------------------------------------------------------
  * JobMatchShell --
- *      Find a matching shell in 'shells' given its final component.
+ *      Find a matching shell in 'shells' given its final component.
  *
  * Results:
- *      A pointer to the Shell structure.
+ *      A pointer to the Shell structure.
  *
  * Side Effects:
- *      None.
+ *      None.
  *
  *-----------------------------------------------------------------------
@@ -2640 +3098 @@
 static Shell *
 JobMatchShell(name)
-    char          *name;      /* Final component of shell path */
+    char          *name;      /* Final component of shell path */
 {
-    register Shell *sh;       /* Pointer into shells table */
-    Shell          *match;    /* Longest-matching shell */
+    register Shell *sh;       /* Pointer into shells table */
+    Shell          *match;    /* Longest-matching shell */
     register char *cp1,
-                  *cp2;
-    char          *eoname;
+                  *cp2;
+    char          *eoname;
 
     eoname = name + strlen(name);
@@ -2653 +3111 @@
 
     for (sh = shells; sh->name != NULL; sh++) {
-        for (cp1 = eoname - strlen(sh->name), cp2 = sh->name;
-             *cp1 != '\0' && *cp1 == *cp2;
-             cp1++, cp2++) {
-                 continue;
-        }
-        if (*cp1 != *cp2) {
-            continue;
-        } else if (match == NULL || strlen(match->name) < strlen(sh->name)) {
-           match = sh;
-        }
+        for (cp1 = eoname - strlen(sh->name), cp2 = sh->name;
+             *cp1 != '\0' && *cp1 == *cp2;
+             cp1++, cp2++) {
+                 continue;
+        }
+        if (*cp1 != *cp2) {
+            continue;
+        } else if (match == NULL || strlen(match->name) < strlen(sh->name)) {
+           match = sh;
+        }
     }
     return(match == NULL ? sh : match);
@@ -2672 +3130 @@
  *-----------------------------------------------------------------------
  * Job_ParseShell --
- *      Parse a shell specification and set up commandShell, shellPath
- *      and shellName appropriately.
+ *      Parse a shell specification and set up commandShell, shellPath
+ *      and shellName appropriately.
  *
  * Results:
- *      FAILURE if the specification was incorrect.
+ *      FAILURE if the specification was incorrect.
  *
  * Side Effects:
- *      commandShell points to a Shell structure (either predefined or
- *      created from the shell spec), shellPath is the full path of the
- *      shell described by commandShell, while shellName is just the
- *      final component of shellPath.
+ *      commandShell points to a Shell structure (either predefined or
+ *      created from the shell spec), shellPath is the full path of the
+ *      shell described by commandShell, while shellName is just the
+ *      final component of shellPath.
  *
  * Notes:
- *      A shell specification consists of a .SHELL target, with dependency
- *      operator, followed by a series of blank-separated words. Double
- *      quotes can be used to use blanks in words. A backslash escapes
- *      anything (most notably a double-quote and a space) and
- *      provides the functionality it does in C. Each word consists of
- *      keyword and value separated by an equal sign. There should be no
- *      unnecessary spaces in the word. The keywords are as follows:
- *          name            Name of shell.
- *          path            Location of shell. Overrides "name" if given
- *          quiet           Command to turn off echoing.
- *          echo            Command to turn echoing on
- *          filter          Result of turning off echoing that shouldn't be
- *                          printed.
- *          echoFlag        Flag to turn echoing on at the start
- *          errFlag         Flag to turn error checking on at the start
- *          hasErrCtl       True if shell has error checking control
- *          check           Command to turn on error checking if hasErrCtl
- *                          is TRUE or template of command to echo a command
- *                          for which error checking is off if hasErrCtl is
- *                          FALSE.
- *          ignore          Command to turn off error checking if hasErrCtl
- *                          is TRUE or template of command to execute a
- *                          command so as to ignore any errors it returns if
- *                          hasErrCtl is FALSE.
+ *      A shell specification consists of a .SHELL target, with dependency
+ *      operator, followed by a series of blank-separated words. Double
+ *      quotes can be used to use blanks in words. A backslash escapes
+ *      anything (most notably a double-quote and a space) and
+ *      provides the functionality it does in C. Each word consists of
+ *      keyword and value separated by an equal sign. There should be no
+ *      unnecessary spaces in the word. The keywords are as follows:
+ *          name            Name of shell.
+ *          path            Location of shell. Overrides "name" if given
+ *          quiet           Command to turn off echoing.
+ *          echo            Command to turn echoing on
+ *          filter          Result of turning off echoing that shouldn't be
+ *                          printed.
+ *          echoFlag        Flag to turn echoing on at the start
+ *          errFlag         Flag to turn error checking on at the start
+ *          hasErrCtl       True if shell has error checking control
+ *          check           Command to turn on error checking if hasErrCtl
+ *                          is TRUE or template of command to echo a command
+ *                          for which error checking is off if hasErrCtl is
+ *                          FALSE.
+ *          ignore          Command to turn off error checking if hasErrCtl
+ *                          is TRUE or template of command to execute a
+ *                          command so as to ignore any errors it returns if
+ *                          hasErrCtl is FALSE.
  *
  *-----------------------------------------------------------------------
@@ -2714 +3172 @@
 ReturnStatus
 Job_ParseShell(line)
-    char          *line;  /* The shell spec */
+    char          *line;  /* The shell spec */
 {
-    char          **words;
-    int           wordCount;
+    char          **words;
+    int           wordCount;
     register char **argv;
     register int  argc;
-    char          *path;
-    Shell         newShell;
-    Boolean       fullSpec = FALSE;
+    char          *path;
+    Shell         newShell;
+    Boolean       fullSpec = FALSE;
 
     while (isspace(*line)) {
-        line++;
+        line++;
     }
     words = brk_string(line, &wordCount, TRUE);
@@ -2735 +3193 @@
      */
     for (path = NULL, argc = wordCount - 1, argv = words + 1;
-         argc != 0;
-         argc--, argv++) {
-             if (strncmp(*argv, "path=", 5) == 0) {
-                 path = &argv[0][5];
-             } else if (strncmp(*argv, "name=", 5) == 0) {
-                 newShell.name = &argv[0][5];
-             } else {
-                 if (strncmp(*argv, "quiet=", 6) == 0) {
-                     newShell.echoOff = &argv[0][6];
-                 } else if (strncmp(*argv, "echo=", 5) == 0) {
-                     newShell.echoOn = &argv[0][5];
-                 } else if (strncmp(*argv, "filter=", 7) == 0) {
-                     newShell.noPrint = &argv[0][7];
-                     newShell.noPLen = strlen(newShell.noPrint);
-                 } else if (strncmp(*argv, "echoFlag=", 9) == 0) {
-                     newShell.echo = &argv[0][9];
-                 } else if (strncmp(*argv, "errFlag=", 8) == 0) {
-                     newShell.exit = &argv[0][8];
-                 } else if (strncmp(*argv, "hasErrCtl=", 10) == 0) {
-                     char c = argv[0][10];
-                     newShell.hasErrCtl = !((c != 'Y') && (c != 'y') &&
-                                           (c != 'T') && (c != 't'));
-                 } else if (strncmp(*argv, "check=", 6) == 0) {
-                     newShell.errCheck = &argv[0][6];
-                 } else if (strncmp(*argv, "ignore=", 7) == 0) {
-                     newShell.ignErr = &argv[0][7];
-                 } else {
-                     Parse_Error(PARSE_FATAL, "Unknown keyword \"%s\"",
-                                  *argv);
-                     return(FAILURE);
-                 }
-                 fullSpec = TRUE;
-             }
+         argc != 0;
+         argc--, argv++) {
+             if (strncmp(*argv, "path=", 5) == 0) {
+                 path = &argv[0][5];
+             } else if (strncmp(*argv, "name=", 5) == 0) {
+                 newShell.name = &argv[0][5];
+             } else {
+                 if (strncmp(*argv, "quiet=", 6) == 0) {
+                     newShell.echoOff = &argv[0][6];
+                 } else if (strncmp(*argv, "echo=", 5) == 0) {
+                     newShell.echoOn = &argv[0][5];
+                 } else if (strncmp(*argv, "filter=", 7) == 0) {
+                     newShell.noPrint = &argv[0][7];
+                     newShell.noPLen = strlen(newShell.noPrint);
+                 } else if (strncmp(*argv, "echoFlag=", 9) == 0) {
+                     newShell.echo = &argv[0][9];
+                 } else if (strncmp(*argv, "errFlag=", 8) == 0) {
+                     newShell.exit = &argv[0][8];
+                 } else if (strncmp(*argv, "hasErrCtl=", 10) == 0) {
+                     char c = argv[0][10];
+                     newShell.hasErrCtl = !((c != 'Y') && (c != 'y') &&
+                                           (c != 'T') && (c != 't'));
+                 } else if (strncmp(*argv, "check=", 6) == 0) {
+                     newShell.errCheck = &argv[0][6];
+                 } else if (strncmp(*argv, "ignore=", 7) == 0) {
+                     newShell.ignErr = &argv[0][7];
+                 } else {
+                     Parse_Error(PARSE_FATAL, "Unknown keyword \"%s\"",
+                                  *argv);
+                     return(FAILURE);
+                 }
+                 fullSpec = TRUE;
+             }
     }
 
     if (path == NULL) {
-        /*
-         * If no path was given, the user wants one of the pre-defined shells,
-         * yes? So we find the one s/he wants with the help of JobMatchShell
-         * and set things up the right way. shellPath will be set up by
-         * Job_Init.
-         */
-        if (newShell.name == NULL) {
-            Parse_Error(PARSE_FATAL, "Neither path nor name specified");
-            return(FAILURE);
-        } else {
-            commandShell = JobMatchShell(newShell.name);
-            shellName = newShell.name;
-        }
+        /*
+         * If no path was given, the user wants one of the pre-defined shells,
+         * yes? So we find the one s/he wants with the help of JobMatchShell
+         * and set things up the right way. shellPath will be set up by
+         * Job_Init.
+         */
+        if (newShell.name == NULL) {
+            Parse_Error(PARSE_FATAL, "Neither path nor name specified");
+            return(FAILURE);
+        } else {
+            commandShell = JobMatchShell(newShell.name);
+            shellName = newShell.name;
+        }
     } else {
-        /*
-         * The user provided a path. If s/he gave nothing else (fullSpec is
-         * FALSE), try and find a matching shell in the ones we know of.
-         * Else we just take the specification at its word and copy it
-         * to a new location. In either case, we need to record the
-         * path the user gave for the shell.
-         */
-        shellPath = path;
-        path = strrchr(path, '/');
-        if (path == NULL) {
-            path = shellPath;
-        } else {
-            path += 1;
-        }
-        if (newShell.name != NULL) {
-            shellName = newShell.name;
-        } else {
-            shellName = path;
-        }
-        if (!fullSpec) {
-            commandShell = JobMatchShell(shellName);
-        } else {
-            commandShell = (Shell *) emalloc(sizeof(Shell));
-            *commandShell = newShell;
-        }
+        /*
+         * The user provided a path. If s/he gave nothing else (fullSpec is
+         * FALSE), try and find a matching shell in the ones we know of.
+         * Else we just take the specification at its word and copy it
+         * to a new location. In either case, we need to record the
+         * path the user gave for the shell.
+         */
+        shellPath = path;
+        path = strrchr(path, '/');
+        if (path == NULL) {
+            path = shellPath;
+        } else {
+            path += 1;
+        }
+        if (newShell.name != NULL) {
+            shellName = newShell.name;
+        } else {
+            shellName = path;
+        }
+        if (!fullSpec) {
+            commandShell = JobMatchShell(shellName);
+        } else {
+            commandShell = (Shell *) emalloc(sizeof(Shell));
+            *commandShell = newShell;
+        }
     }
 
     if (commandShell->echoOn && commandShell->echoOff) {
-        commandShell->hasEchoCtl = TRUE;
+        commandShell->hasEchoCtl = TRUE;
     }
 
     if (!commandShell->hasErrCtl) {
-        if (commandShell->errCheck == NULL) {
-            commandShell->errCheck = "";
-        }
-        if (commandShell->ignErr == NULL) {
-            commandShell->ignErr = "%s\n";
-        }
+        if (commandShell->errCheck == NULL) {
+            commandShell->errCheck = "";
+        }
+        if (commandShell->ignErr == NULL) {
+            commandShell->ignErr = "%s\n";
+        }
     }
 
@@ -2837 +3295 @@
  *-----------------------------------------------------------------------
  * JobInterrupt --
- *      Handle the receipt of an interrupt.
+ *      Handle the receipt of an interrupt.
  *
  * Results:
- *      None
+ *      None
  *
  * Side Effects:
- *      All children are killed. Another job will be started if the
- *      .INTERRUPT target was given.
+ *      All children are killed. Another job will be started if the
+ *      .INTERRUPT target was given.
  *-----------------------------------------------------------------------
  */
 static void
 JobInterrupt(runINTERRUPT, signo)
-    int     runINTERRUPT;       /* Non-zero if commands for the .INTERRUPT
-                                 * target should be executed */
-    int     signo;              /* signal received */
+    int     runINTERRUPT;       /* Non-zero if commands for the .INTERRUPT
+                                 * target should be executed */
+    int     signo;              /* signal received */
 {
-    LstNode       ln;           /* element in job table */
-    Job           *job = NULL;  /* job descriptor in that element */
-    GNode         *interrupt;   /* the node describing the .INTERRUPT target */
+    LstNode       ln;           /* element in job table */
+    Job           *job = NULL;  /* job descriptor in that element */
+    GNode         *interrupt;   /* the node describing the .INTERRUPT target */
 
     aborting = ABORT_INTERRUPT;
@@ -2861 +3319 @@
    (void) Lst_Open(jobs);
     while ((ln = Lst_Next(jobs)) != NILLNODE) {
-        job = (Job *) Lst_Datum(ln);
-
-        if (!Targ_Precious(job->node)) {
-            char        *file = (job->node->path == NULL ?
-                                 job->node->name :
-                                 job->node->path);
-            if (!noExecute && eunlink(file) != -1) {
-                Error("*** %s removed", file);
-            }
-        }
+        job = (Job *) Lst_Datum(ln);
+
+        if (!Targ_Precious(job->node)) {
+            char        *file = (job->node->path == NULL ?
+                                 job->node->name :
+                                 job->node->path);
+            if (!noExecute && eunlink(file) != -1) {
+                Error("*** %s removed", file);
+            }
+        }
 #ifdef RMT_WANTS_SIGNALS
-        if (job->flags & JOB_REMOTE) {
-            /*
-             * If job is remote, let the Rmt module do the killing.
-             */
-            if (!Rmt_Signal(job, signo)) {
-                /*
-                 * If couldn't kill the thing, finish it out now with an
-                 * error code, since no exit report will come in likely.
-                 */
-                int status;
-
-                status.w_status = 0;
-                status.w_retcode = 1;
-                JobFinish(job, &status);
-            }
-        } else if (job->pid) {
-            KILL(job->pid, signo);
-        }
+        if (job->flags & JOB_REMOTE) {
+            /*
+             * If job is remote, let the Rmt module do the killing.
+             */
+            if (!Rmt_Signal(job, signo)) {
+                /*
+                 * If couldn't kill the thing, finish it out now with an
+                 * error code, since no exit report will come in likely.
+                 */
+                int status;
+
+                status.w_status = 0;
+                status.w_retcode = 1;
+                JobFinish(job, &status);
+            }
+        } else if (job->pid) {
+            KILL(job->pid, signo);
+        }
 #else
-        if (job->pid) {
-            if (DEBUG(JOB)) {
-                (void) fprintf(stdout,
-                               "JobInterrupt passing signal to child %d.\n",
-                               job->pid);
-                (void) fflush(stdout);
-            }
-            KILL(job->pid, signo);
-        }
+        if (job->pid) {
+            if (DEBUG(JOB)) {
+                (void) fprintf(stdout,
+                               "JobInterrupt passing signal to child %d.\n",
+                               job->pid);
+                (void) fflush(stdout);
+            }
+            KILL(job->pid, signo);
+        }
 #endif /* RMT_WANTS_SIGNALS */
     }
@@ -2906 +3364 @@
    (void)Lst_Open(stoppedJobs);
     while ((ln = Lst_Next(stoppedJobs)) != NILLNODE) {
-        job = (Job *) Lst_Datum(ln);
-
-        if (job->flags & JOB_RESTART) {
-            if (DEBUG(JOB)) {
-                (void) fprintf(stdout, "%s%s",
-                               "JobInterrupt skipping job on stopped queue",
-                               "-- it was waiting to be restarted.\n");
-                (void) fflush(stdout);
-            }
-            continue;
-        }
-        if (!Targ_Precious(job->node)) {
-            char        *file = (job->node->path == NULL ?
-                                 job->node->name :
-                                 job->node->path);
-            if (eunlink(file) == 0) {
-                Error("*** %s removed", file);
-            }
-        }
-        /*
-         * Resume the thing so it will take the signal.
-         */
-        if (DEBUG(JOB)) {
-            (void) fprintf(stdout,
-                           "JobInterrupt passing CONT to stopped child %d.\n",
-                           job->pid);
-            (void) fflush(stdout);
-        }
-        KILL(job->pid, SIGCONT);
+        job = (Job *) Lst_Datum(ln);
+
+        if (job->flags & JOB_RESTART) {
+            if (DEBUG(JOB)) {
+                (void) fprintf(stdout, "%s%s",
+                               "JobInterrupt skipping job on stopped queue",
+                               "-- it was waiting to be restarted.\n");
+                (void) fflush(stdout);
+            }
+            continue;
+        }
+        if (!Targ_Precious(job->node)) {
+            char        *file = (job->node->path == NULL ?
+                                 job->node->name :
+                                 job->node->path);
+            if (eunlink(file) == 0) {
+                Error("*** %s removed", file);
+            }
+        }
+        /*
+         * Resume the thing so it will take the signal.
+         */
+        if (DEBUG(JOB)) {
+            (void) fprintf(stdout,
+                           "JobInterrupt passing CONT to stopped child %d.\n",
+                           job->pid);
+            (void) fflush(stdout);
+        }
+        KILL(job->pid, SIGCONT);
 #ifdef RMT_WANTS_SIGNALS
-        if (job->flags & JOB_REMOTE) {
-            /*
-             * If job is remote, let the Rmt module do the killing.
-             */
-            if (!Rmt_Signal(job, SIGINT)) {
-                /*
-                 * If couldn't kill the thing, finish it out now with an
-                 * error code, since no exit report will come in likely.
-                 */
-                int status;
-                status.w_status = 0;
-                status.w_retcode = 1;
-                JobFinish(job, &status);
-            }
-        } else if (job->pid) {
-            if (DEBUG(JOB)) {
-                (void) fprintf(stdout,
-                       "JobInterrupt passing interrupt to stopped child %d.\n",
-                               job->pid);
-                (void) fflush(stdout);
-            }
-            KILL(job->pid, SIGINT);
-        }
+        if (job->flags & JOB_REMOTE) {
+            /*
+             * If job is remote, let the Rmt module do the killing.
+             */
+            if (!Rmt_Signal(job, SIGINT)) {
+                /*
+                 * If couldn't kill the thing, finish it out now with an
+                 * error code, since no exit report will come in likely.
+                 */
+                int status;
+                status.w_status = 0;
+                status.w_retcode = 1;
+                JobFinish(job, &status);
+            }
+        } else if (job->pid) {
+            if (DEBUG(JOB)) {
+                (void) fprintf(stdout,
+                       "JobInterrupt passing interrupt to stopped child %d.\n",
+                               job->pid);
+                (void) fflush(stdout);
+            }
+            KILL(job->pid, SIGINT);
+        }
 #endif /* RMT_WANTS_SIGNALS */
     }
-#endif
     Lst_Close(stoppedJobs);
+#endif
 
     if (runINTERRUPT && !touchFlag) {
-        interrupt = Targ_FindNode(".INTERRUPT", TARG_NOCREATE);
-        if (interrupt != NILGNODE) {
-            ignoreErrors = FALSE;
-
-            JobStart(interrupt, JOB_IGNDOTS, (Job *)0);
-            while (nJobs) {
-                Job_CatchOutput();
+        interrupt = Targ_FindNode(".INTERRUPT", TARG_NOCREATE);
+        if (interrupt != NILGNODE) {
+            ignoreErrors = FALSE;
+
+            JobStart(interrupt, JOB_IGNDOTS, (Job *)0);
+            while (nJobs) {
+                Job_CatchOutput();
 #ifndef RMT_WILL_WATCH
-                Job_CatchChildren(!usePipes);
+                Job_CatchChildren(!usePipes);
 #endif /* RMT_WILL_WATCH */
-            }
-        }
+            }
+        }
     }
 }
@@ -2983 +3441 @@
  *-----------------------------------------------------------------------
  * Job_End --
- *      Do final processing such as the running of the commands
- *      attached to the .END target.
+ *      Do final processing such as the running of the commands
+ *      attached to the .END target.
  *
  * Results:
- *      Number of errors reported.
+ *      Number of errors reported.
  *-----------------------------------------------------------------------
  */
@@ -2994 +3452 @@
 {
     if (postCommands != NILGNODE && !Lst_IsEmpty(postCommands->commands)) {
-        if (errors) {
-            Error("Errors reported so .END ignored");
-        } else {
-            JobStart(postCommands, JOB_SPECIAL | JOB_IGNDOTS, NULL);
-
-            while (nJobs) {
-                Job_CatchOutput();
+        if (errors) {
+            Error("Errors reported so .END ignored");
+        } else {
+            JobStart(postCommands, JOB_SPECIAL | JOB_IGNDOTS, NULL);
+
+            while (nJobs) {
+                Job_CatchOutput();
 #ifndef RMT_WILL_WATCH
-                Job_CatchChildren(!usePipes);
+                Job_CatchChildren(!usePipes);
 #endif /* RMT_WILL_WATCH */
-            }
-        }
+            }
+        }
     }
     return(errors);
@@ -3013 +3471 @@
  *-----------------------------------------------------------------------
  * Job_Wait --
- *      Waits for all running jobs to finish and returns. Sets 'aborting'
- *      to ABORT_WAIT to prevent other jobs from starting.
+ *      Waits for all running jobs to finish and returns. Sets 'aborting'
+ *      to ABORT_WAIT to prevent other jobs from starting.
  *
  * Results:
- *      None.
+ *      None.
  *
  * Side Effects:
- *      Currently running jobs finish.
+ *      Currently running jobs finish.
  *
  *-----------------------------------------------------------------------
@@ -3029 +3487 @@
     aborting = ABORT_WAIT;
     while (nJobs != 0) {
-        Job_CatchOutput();
+        Job_CatchOutput();
 #ifndef RMT_WILL_WATCH
-        Job_CatchChildren(!usePipes);
+        Job_CatchChildren(!usePipes);
 #endif /* RMT_WILL_WATCH */
     }
@@ -3040 +3498 @@
  *-----------------------------------------------------------------------
  * Job_AbortAll --
- *      Abort all currently running jobs without handling output or anything.
- *      This function is to be called only in the event of a major
- *      error. Most definitely NOT to be called from JobInterrupt.
+ *      Abort all currently running jobs without handling output or anything.
+ *      This function is to be called only in the event of a major
+ *      error. Most definitely NOT to be called from JobInterrupt.
  *
  * Results:
- *      None
+ *      None
  *
  * Side Effects:
- *      All children are killed, not just the firstborn
+ *      All children are killed, not just the firstborn
  *-----------------------------------------------------------------------
  */
@@ -3054 +3512 @@
 Job_AbortAll()
 {
-    LstNode             ln;     /* element in job table */
-    Job                 *job;   /* the job descriptor in that element */
-    int                 foo;
+#ifdef USE_KLIB
+    LstNode             ln;     /* element in job table */
+    Job                *job;    /* the job descriptor in that element */
+    KPROCRES            res;
 
     aborting = ABORT_ERROR;
 
+    if (nJobs)
+    {
+        Lst_Open(jobs);
+        while ((ln = Lst_Next(jobs)) != NILLNODE)
+        {
+            job = (Job *) Lst_Datum(ln);
+
+            /*
+             * kill the child process with increasingly drastic signals to make
+             * darn sure it's dead.
+             */
+            kProcKill(job->pid, KPROCKILL_FLAGS_TREE | KPROCKILL_FLAGS_TYPE_INT);
+            kProcKill(job->pid, KPROCKILL_FLAGS_TREE | KPROCKILL_FLAGS_TYPE_KILL);
+        }
+    }
+
+    /*
+     * Catch as many children as want to report in at first, then give up
+     */
+    do
+    {
+        kThrdYield();
+    } while (!kProcWait(KPID_NULL, KPROCWAIT_FLAGS_NOWAIT, &res, NULL)); /** @todo checkout this call */
+
+#else /* Don't use kLib */
+    LstNode             ln;     /* element in job table */
+    Job                 *job;   /* the job descriptor in that element */
+    int                 foo;
+
+    aborting = ABORT_ERROR;
+
     if (nJobs) {
 
-        (void) Lst_Open(jobs);
-        while ((ln = Lst_Next(jobs)) != NILLNODE) {
-            job = (Job *) Lst_Datum(ln);
-
-            /*
-             * kill the child process with increasingly drastic signals to make
-             * darn sure it's dead.
-             */
+        (void) Lst_Open(jobs);
+        while ((ln = Lst_Next(jobs)) != NILLNODE) {
+            job = (Job *) Lst_Datum(ln);
+
+            /*
+             * kill the child process with increasingly drastic signals to make
+             * darn sure it's dead.
+             */
 #ifdef RMT_WANTS_SIGNALS
-            if (job->flags & JOB_REMOTE) {
-                Rmt_Signal(job, SIGINT);
-                Rmt_Signal(job, SIGKILL);
-            } else {
-                KILL(job->pid, SIGINT);
-                KILL(job->pid, SIGKILL);
-            }
+            if (job->flags & JOB_REMOTE) {
+                Rmt_Signal(job, SIGINT);
+                Rmt_Signal(job, SIGKILL);
+            } else {
+                KILL(job->pid, SIGINT);
+                KILL(job->pid, SIGKILL);
+            }
 #else
-            KILL(job->pid, SIGINT);
-            KILL(job->pid, SIGKILL);
+            KILL(job->pid, SIGINT);
+            KILL(job->pid, SIGKILL);
 #endif /* RMT_WANTS_SIGNALS */
-        }
+        }
     }
 
@@ -3089 +3579 @@
      */
     while (waitpid((pid_t) -1, &foo, WNOHANG) > 0)
-        continue;
+        continue;
+#endif /* USE_KLIB */
 }
 
@@ -3096 +3587 @@
  *-----------------------------------------------------------------------
  * JobFlagForMigration --
- *      Handle the eviction of a child. Called from RmtStatusChange.
- *      Flags the child as remigratable and then suspends it.
+ *      Handle the eviction of a child. Called from RmtStatusChange.
+ *      Flags the child as remigratable and then suspends it.
  *
  * Results:
- *      none.
+ *      none.
  *
  * Side Effects:
- *      The job descriptor is flagged for remigration.
+ *      The job descriptor is flagged for remigration.
  *
  *-----------------------------------------------------------------------
@@ -3109 +3600 @@
 void
 JobFlagForMigration(hostID)
-    int           hostID;       /* ID of host we used, for matching children. */
+    int           hostID;       /* ID of host we used, for matching children. */
 {
-    register Job  *job;         /* job descriptor for dead child */
-    LstNode       jnode;        /* list element for finding job */
+    register Job  *job;         /* job descriptor for dead child */
+    LstNode       jnode;        /* list element for finding job */
 
     if (DEBUG(JOB)) {
-        (void) fprintf(stdout, "JobFlagForMigration(%d) called.\n", hostID);
-        (void) fflush(stdout);
+        (void) fprintf(stdout, "JobFlagForMigration(%d) called.\n", hostID);
+        (void) fflush(stdout);
     }
     jnode = Lst_Find(jobs, (ClientData)hostID, JobCmpRmtID);
 
     if (jnode == NILLNODE) {
-        jnode = Lst_Find(stoppedJobs, (ClientData)hostID, JobCmpRmtID);
-                if (jnode == NILLNODE) {
-                    if (DEBUG(JOB)) {
-                        Error("Evicting host(%d) not in table", hostID);
-                    }
-                    return;
-                }
+        jnode = Lst_Find(stoppedJobs, (ClientData)hostID, JobCmpRmtID);
+                if (jnode == NILLNODE) {
+                    if (DEBUG(JOB)) {
+                        Error("Evicting host(%d) not in table", hostID);
+                    }
+                    return;
+                }
     }
     job = (Job *) Lst_Datum(jnode);
 
     if (DEBUG(JOB)) {
-        (void) fprintf(stdout,
-                       "JobFlagForMigration(%d) found job '%s'.\n", hostID,
-                       job->node->name);
-        (void) fflush(stdout);
+        (void) fprintf(stdout,
+                       "JobFlagForMigration(%d) found job '%s'.\n", hostID,
+                       job->node->name);
+        (void) fflush(stdout);
     }
 
@@ -3146 +3637 @@
 
 
+#ifdef SIGCONT
 /*-
  *-----------------------------------------------------------------------
  * JobRestartJobs --
- *      Tries to restart stopped jobs if there are slots available.
- *      Note that this tries to restart them regardless of pending errors.
- *      It's not good to leave stopped jobs lying around!
+ *      Tries to restart stopped jobs if there are slots available.
+ *      Note that this tries to restart them regardless of pending errors.
+ *      It's not good to leave stopped jobs lying around!
  *
  * Results:
- *      None.
+ *      None.
  *
  * Side Effects:
- *      Resumes(and possibly migrates) jobs.
+ *      Resumes(and possibly migrates) jobs.
  *
  *-----------------------------------------------------------------------
@@ -3165 +3657 @@
 {
     while (!jobFull && !Lst_IsEmpty(stoppedJobs)) {
-        if (DEBUG(JOB)) {
-            (void) fprintf(stdout,
-                       "Job queue is not full. Restarting a stopped job.\n");
-            (void) fflush(stdout);
-        }
-        JobRestart((Job *)Lst_DeQueue(stoppedJobs));
+        if (DEBUG(JOB)) {
+            (void) fprintf(stdout,
+                       "Job queue is not full. Restarting a stopped job.\n");
+            (void) fflush(stdout);
+        }
+        JobRestart((Job *)Lst_DeQueue(stoppedJobs));
     }
 }
+#endif

trunk/src/kmk/job.h

@@ -18 +18 @@
  * 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
@@ -36 +36 @@
  * SUCH DAMAGE.
  *
- *      from: @(#)job.h 8.1 (Berkeley) 6/6/93
+ *      from: @(#)job.h 8.1 (Berkeley) 6/6/93
  * $FreeBSD: src/usr.bin/make/job.h,v 1.11 2000/01/17 06:43:41 kris Exp $
  */
@@ -42 +42 @@
 /*-
  * job.h --
- *      Definitions pertaining to the running of jobs in parallel mode.
- *      Exported from job.c for the use of remote-execution modules.
+ *      Definitions pertaining to the running of jobs in parallel mode.
+ *      Exported from job.c for the use of remote-execution modules.
  */
 #ifndef _JOB_H_
 #define _JOB_H_
 
-#define TMPPAT  "/tmp/makeXXXXXXXXXX"
+#define TMPPAT  "/tmp/makeXXXXXXXXXX"
 
 /*
@@ -55 +55 @@
  * seconds and SEL_USEC is the number of micro-seconds
  */
-#define SEL_SEC         0
-#define SEL_USEC        100000
+#define SEL_SEC         0
+#define SEL_USEC        100000
 
 
@@ -64 +64 @@
  *
  * Each job has several things associated with it:
- *      1) The process id of the child shell
- *      2) The graph node describing the target being made by this job
- *      3) A LstNode for the first command to be saved after the job
- *         completes. This is NILLNODE if there was no "..." in the job's
- *         commands.
- *      4) An FILE* for writing out the commands. This is only
- *         used before the job is actually started.
- *      5) A union of things used for handling the shell's output. Different
- *         parts of the union are used based on the value of the usePipes
- *         flag. If it is true, the output is being caught via a pipe and
- *         the descriptors of our pipe, an array in which output is line
- *         buffered and the current position in that buffer are all
- *         maintained for each job. If, on the other hand, usePipes is false,
- *         the output is routed to a temporary file and all that is kept
- *         is the name of the file and the descriptor open to the file.
- *      6) An identifier provided by and for the exclusive use of the
- *         Rmt module.
- *      7) A word of flags which determine how the module handles errors,
- *         echoing, etc. for the job
+ *      1) The process id of the child shell
+ *      2) The graph node describing the target being made by this job
+ *      3) A LstNode for the first command to be saved after the job
+ *         completes. This is NILLNODE if there was no "..." in the job's
+ *         commands.
+ *      4) An FILE* for writing out the commands. This is only
+ *         used before the job is actually started.
+ *      5) A union of things used for handling the shell's output. Different
+ *         parts of the union are used based on the value of the usePipes
+ *         flag. If it is true, the output is being caught via a pipe and
+ *         the descriptors of our pipe, an array in which output is line
+ *         buffered and the current position in that buffer are all
+ *         maintained for each job. If, on the other hand, usePipes is false,
+ *         the output is routed to a temporary file and all that is kept
+ *         is the name of the file and the descriptor open to the file.
+ *      6) An identifier provided by and for the exclusive use of the
+ *         Rmt module.
+ *      7) A word of flags which determine how the module handles errors,
+ *         echoing, etc. for the job
  *
  * The job "table" is kept as a linked Lst in 'jobs', with the number of
@@ -92 +92 @@
  * traversal of the dependency graph.
  */
-#define JOB_BUFSIZE     1024
+#define JOB_BUFSIZE         1024
+#define JOB_TMPFILESIZE     128
 typedef struct Job {
-    int         pid;        /* The child's process ID */
-    char        tfile[sizeof(TMPPAT)];
-                            /* Temporary file to use for job */
-    GNode       *node;      /* The target the child is making */
-    LstNode     tailCmds;   /* The node of the first command to be
-                             * saved when the job has been run */
-    FILE        *cmdFILE;   /* When creating the shell script, this is
-                             * where the commands go */
-    int         rmtID;     /* ID returned from Rmt module */
-    short       flags;      /* Flags to control treatment of job */
-#define JOB_IGNERR      0x001   /* Ignore non-zero exits */
-#define JOB_SILENT      0x002   /* no output */
-#define JOB_SPECIAL     0x004   /* Target is a special one. i.e. run it locally
-                                 * if we can't export it and maxLocal is 0 */
-#define JOB_IGNDOTS     0x008   /* Ignore "..." lines when processing
-                                 * commands */
-#define JOB_REMOTE      0x010   /* Job is running remotely */
-#define JOB_FIRST       0x020   /* Job is first job for the node */
-#define JOB_REMIGRATE   0x040   /* Job needs to be remigrated */
-#define JOB_RESTART     0x080   /* Job needs to be completely restarted */
-#define JOB_RESUME      0x100   /* Job needs to be resumed b/c it stopped,
-                                 * for some reason */
-#define JOB_CONTINUING  0x200   /* We are in the process of resuming this job.
-                                 * Used to avoid infinite recursion between
-                                 * JobFinish and JobRestart */
+    int         pid;        /* The child's process ID */
+    char        tfile[JOB_TMPFILESIZE];
+                            /* Temporary file to use for job */
+    GNode       *node;      /* The target the child is making */
+    LstNode     tailCmds;   /* The node of the first command to be
+                             * saved when the job has been run */
+    FILE        *cmdFILE;   /* When creating the shell script, this is
+                             * where the commands go */
+    int         rmtID;     /* ID returned from Rmt module */
+    short       flags;      /* Flags to control treatment of job */
+#define JOB_IGNERR      0x001   /* Ignore non-zero exits */
+#define JOB_SILENT      0x002   /* no output */
+#define JOB_SPECIAL     0x004   /* Target is a special one. i.e. run it locally
+                                 * if we can't export it and maxLocal is 0 */
+#define JOB_IGNDOTS     0x008   /* Ignore "..." lines when processing
+                                 * commands */
+#define JOB_REMOTE      0x010   /* Job is running remotely */
+#define JOB_FIRST       0x020   /* Job is first job for the node */
+#define JOB_REMIGRATE   0x040   /* Job needs to be remigrated */
+#define JOB_RESTART     0x080   /* Job needs to be completely restarted */
+#define JOB_RESUME      0x100   /* Job needs to be resumed b/c it stopped,
+                                 * for some reason */
+#define JOB_CONTINUING  0x200   /* We are in the process of resuming this job.
+                                 * Used to avoid infinite recursion between
+                                 * JobFinish and JobRestart */
     union {
-        struct {
-            int         op_inPipe;      /* Input side of pipe associated
-                                         * with job's output channel */
-            int         op_outPipe;     /* Output side of pipe associated with
-                                         * job's output channel */
-            char        op_outBuf[JOB_BUFSIZE + 1];
-                                        /* Buffer for storing the output of the
-                                         * job, line by line */
-            int         op_curPos;      /* Current position in op_outBuf */
-        }           o_pipe;         /* data used when catching the output via
-                                     * a pipe */
-        struct {
-            char        of_outFile[sizeof(TMPPAT)];
-                                        /* Name of file to which shell output
-                                         * was rerouted */
-            int         of_outFd;       /* Stream open to the output
-                                         * file. Used to funnel all
-                                         * from a single job to one file
-                                         * while still allowing
-                                         * multiple shell invocations */
-        }           o_file;         /* Data used when catching the output in
-                                     * a temporary file */
-    }           output;     /* Data for tracking a shell's output */
+        struct {
+            int         op_inPipe;      /* Input side of pipe associated
+                                         * with job's output channel */
+            int         op_outPipe;     /* Output side of pipe associated with
+                                         * job's output channel */
+            char        op_outBuf[JOB_BUFSIZE + 1];
+                                        /* Buffer for storing the output of the
+                                         * job, line by line */
+            int         op_curPos;      /* Current position in op_outBuf */
+        }           o_pipe;         /* data used when catching the output via
+                                     * a pipe */
+        struct {
+            char        of_outFile[JOB_TMPFILESIZE];
+                                        /* Name of file to which shell output
+                                         * was rerouted */
+            int         of_outFd;       /* Stream open to the output
+                                         * file. Used to funnel all
+                                         * from a single job to one file
+                                         * while still allowing
+                                         * multiple shell invocations */
+        }           o_file;         /* Data used when catching the output in
+                                     * a temporary file */
+    }           output;     /* Data for tracking a shell's output */
 } Job;
 
-#define outPipe         output.o_pipe.op_outPipe
-#define inPipe          output.o_pipe.op_inPipe
-#define outBuf          output.o_pipe.op_outBuf
-#define curPos          output.o_pipe.op_curPos
-#define outFile         output.o_file.of_outFile
-#define outFd           output.o_file.of_outFd
+#define outPipe         output.o_pipe.op_outPipe
+#define inPipe          output.o_pipe.op_inPipe
+#define outBuf          output.o_pipe.op_outBuf
+#define curPos          output.o_pipe.op_curPos
+#define outFile         output.o_file.of_outFile
+#define outFd           output.o_file.of_outFd
 
 
@@ -157 +158 @@
  * Shell Specifications:
  * Each shell type has associated with it the following information:
- *      1) The string which must match the last character of the shell name
- *         for the shell to be considered of this type. The longest match
- *         wins.
- *      2) A command to issue to turn off echoing of command lines
- *      3) A command to issue to turn echoing back on again
- *      4) What the shell prints, and its length, when given the echo-off
- *         command. This line will not be printed when received from the shell
- *      5) A boolean to tell if the shell has the ability to control
- *         error checking for individual commands.
- *      6) The string to turn this checking on.
- *      7) The string to turn it off.
- *      8) The command-flag to give to cause the shell to start echoing
- *         commands right away.
- *      9) The command-flag to cause the shell to Lib_Exit when an error is
- *         detected in one of the commands.
+ *      1) The string which must match the last character of the shell name
+ *         for the shell to be considered of this type. The longest match
+ *         wins.
+ *      2) A command to issue to turn off echoing of command lines
+ *      3) A command to issue to turn echoing back on again
+ *      4) What the shell prints, and its length, when given the echo-off
+ *         command. This line will not be printed when received from the shell
+ *      5) A boolean to tell if the shell has the ability to control
+ *         error checking for individual commands.
+ *      6) The string to turn this checking on.
+ *      7) The string to turn it off.
+ *      8) The command-flag to give to cause the shell to start echoing
+ *         commands right away.
+ *      9) The command-flag to cause the shell to Lib_Exit when an error is
+ *         detected in one of the commands.
  *
  * Some special stuff goes on if a shell doesn't have error control. In such
@@ -181 +182 @@
  */
 typedef struct Shell {
-    char          *name;        /* the name of the shell. For Bourne and C
-                                 * shells, this is used only to find the
-                                 * shell description when used as the single
-                                 * source of a .SHELL target. For user-defined
-                                 * shells, this is the full path of the shell.
-                                 */
-    Boolean       hasEchoCtl;   /* True if both echoOff and echoOn defined */
-    char          *echoOff;     /* command to turn off echo */
-    char          *echoOn;      /* command to turn it back on again */
-    char          *noPrint;     /* command to skip when printing output from
-                                 * shell. This is usually the command which
-                                 * was executed to turn off echoing */
-    int           noPLen;       /* length of noPrint command */
-    Boolean       hasErrCtl;    /* set if can control error checking for
-                                 * individual commands */
-    char          *errCheck;    /* string to turn error checking on */
-    char          *ignErr;      /* string to turn off error checking */
+    char          *name;        /* the name of the shell. For Bourne and C
+                                 * shells, this is used only to find the
+                                 * shell description when used as the single
+                                 * source of a .SHELL target. For user-defined
+                                 * shells, this is the full path of the shell.
+                                 */
+    Boolean       hasEchoCtl;   /* True if both echoOff and echoOn defined */
+    char          *echoOff;     /* command to turn off echo */
+    char          *echoOn;      /* command to turn it back on again */
+    char          *noPrint;     /* command to skip when printing output from
+                                 * shell. This is usually the command which
+                                 * was executed to turn off echoing */
+    int           noPLen;       /* length of noPrint command */
+    Boolean       hasErrCtl;    /* set if can control error checking for
+                                 * individual commands */
+    char          *errCheck;    /* string to turn error checking on */
+    char          *ignErr;      /* string to turn off error checking */
     /*
      * command-line flags
      */
-    char          *echo;        /* echo commands */
-    char          *exit;        /* exit on error */
+    char          *echo;        /* echo commands */
+    char          *exit;        /* exit on error */
 }               Shell;
 
 
-extern char     *targFmt;       /* Format string for banner that separates
-                                 * output from multiple jobs. Contains a
-                                 * single %s where the name of the node being
-                                 * made should be put. */
-extern GNode    *lastNode;      /* Last node for which a banner was printed.
-                                 * If Rmt module finds it necessary to print
-                                 * a banner, it should set this to the node
-                                 * for which the banner was printed */
-extern int      nJobs;          /* Number of jobs running (local and remote) */
-extern int      nLocal;         /* Number of jobs running locally */
-extern Lst      jobs;           /* List of active job descriptors */
-extern Lst      stoppedJobs;    /* List of jobs that are stopped or didn't
-                                 * quite get started */
-extern Boolean  jobFull;        /* Non-zero if no more jobs should/will start*/
+extern char     *targFmt;       /* Format string for banner that separates
+                                 * output from multiple jobs. Contains a
+                                 * single %s where the name of the node being
+                                 * made should be put. */
+extern GNode    *lastNode;      /* Last node for which a banner was printed.
+                                 * If Rmt module finds it necessary to print
+                                 * a banner, it should set this to the node
+                                 * for which the banner was printed */
+extern int      nJobs;          /* Number of jobs running (local and remote) */
+extern int      nLocal;         /* Number of jobs running locally */
+extern Lst      jobs;           /* List of active job descriptors */
+extern Lst      stoppedJobs;    /* List of jobs that are stopped or didn't
+                                 * quite get started */
+extern Boolean  jobFull;        /* Non-zero if no more jobs should/will start*/
 
 

trunk/src/kmk/main.c

@@ -1 +1 @@
 /*
  * 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.
@@ -18 +18 @@
  * 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
@@ -40 +40 @@
 static const char copyright[] =
 "@(#) Copyright (c) 1988, 1989, 1990, 1993\n\
-        The Regents of the University of California.  All rights reserved.\n";
+        The Regents of the University of California.  All rights reserved.\n";
 #endif /* not lint */
 
 #ifndef lint
 #if 0
-static char sccsid[] = "@(#)main.c      8.3 (Berkeley) 3/19/94";
+static char sccsid[] = "@(#)main.c      8.3 (Berkeley) 3/19/94";
 #else
 static const char rcsid[] =
   "$FreeBSD: src/usr.bin/make/main.c,v 1.35.2.6 2002/07/24 16:50:18 ru Exp $";
 #endif
+#define KLIBFILEDEF rcsid
 #endif /* not lint */
 
 /*-
  * main.c --
- *      The main file for this entire program. Exit routines etc
- *      reside here.
+ *      The main file for this entire program. Exit routines etc
+ *      reside here.
  *
  * Utility functions defined in this file:
- *      Main_ParseArgLine       Takes a line of arguments, breaks them and
- *                              treats them as if they were given when first
- *                              invoked. Used by the parse module to implement
- *                              the .MFLAGS target.
- *
- *      Error                   Print a tagged error message. The global
- *                              MAKE variable must have been defined. This
- *                              takes a format string and two optional
- *                              arguments for it.
- *
- *      Fatal                   Print an error message and exit. Also takes
- *                              a format string and two arguments.
- *
- *      Punt                    Aborts all jobs and exits with a message. Also
- *                              takes a format string and two arguments.
- *
- *      Finish                  Finish things up by printing the number of
- *                              errors which occured, as passed to it, and
- *                              exiting.
- */
-
-#if defined(USE_KLIB) //|| defined(KMK)
+ *      Main_ParseArgLine       Takes a line of arguments, breaks them and
+ *                              treats them as if they were given when first
+ *                              invoked. Used by the parse module to implement
+ *                              the .MFLAGS target.
+ *
+ *      Error                   Print a tagged error message. The global
+ *                              MAKE variable must have been defined. This
+ *                              takes a format string and two optional
+ *                              arguments for it.
+ *
+ *      Fatal                   Print an error message and exit. Also takes
+ *                              a format string and two arguments.
+ *
+ *      Punt                    Aborts all jobs and exits with a message. Also
+ *                              takes a format string and two arguments.
+ *
+ *      Finish                  Finish things up by printing the number of
+ *                              errors which occured, as passed to it, and
+ *                              exiting.
+ */
+
+#if defined(USE_KLIB)
     #define KLIB_INSTRICT
     #include <kLib/kLib.h>
@@ -96 +97 @@
 #endif
 #ifndef MACHINE
-# if !defined(__IBMC__)
 #  include <sys/utsname.h>
-# endif
-#endif
-#if !defined(__IBMC__)
+#endif
+#ifndef USE_KLIB
 #include <sys/wait.h>
+#endif
 #include <err.h>
-#endif
 #include <stdlib.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
-#if !defined(__IBMC__) && !defined(__EMX__)
+#if defined(__EMX__)
 #include <sysexits.h>
 #endif
-#if defined(__STDC__) || defined(__IBMC__)
+#if defined(__STDC__)
 #include <stdarg.h>
 #else
@@ -129 +128 @@
   #define S_ISDIR(mode)  (((mode) & S_IFMT) == S_IFDIR)
  #endif
-#endif
+ char *realpath(const char *pszFileName, char *pszResolvedName);
+ #define snprintf kStrNFormat
+#endif
+#include <getopt.h>
 #include "make.h"
 #include "hash.h"
@@ -136 +138 @@
 #include "pathnames.h"
 
-#ifndef DEFMAXLOCAL
-#define DEFMAXLOCAL DEFMAXJOBS
-#endif  /* DEFMAXLOCAL */
-
-#define MAKEFLAGS       ".MAKEFLAGS"
-
-Lst                     create;         /* Targets to be made */
-time_t                  now;            /* Time at start of make */
-GNode                   *DEFAULT;       /* .DEFAULT node */
-Boolean                 allPrecious;    /* .PRECIOUS given on line by itself */
-
-static Boolean          noBuiltins;     /* -r flag */
-static Lst              makefiles;      /* ordered list of makefiles to read */
-static Boolean          printVars;      /* print value of one or more vars */
-static Boolean          expandVars;     /* fully expand printed variables */
-static Lst              variables;      /* list of variables to print */
-int                     maxJobs;        /* -j argument */
+#ifndef DEFMAXLOCAL
+#define DEFMAXLOCAL DEFMAXJOBS
+#endif  /* DEFMAXLOCAL */
+
+#define MAKEFLAGS       ".MAKEFLAGS"
+
+Lst                     create;         /* Targets to be made */
+time_t                  now;            /* Time at start of make */
+GNode                   *DEFAULT;       /* .DEFAULT node */
+Boolean                 allPrecious;    /* .PRECIOUS given on line by itself */
+
+static Boolean          noBuiltins;     /* -r flag */
+static Lst              makefiles;      /* ordered list of makefiles to read */
+static Boolean          printVars;      /* print value of one or more vars */
+static Boolean          expandVars;     /* fully expand printed variables */
+static Lst              variables;      /* list of variables to print */
+int                     maxJobs;        /* -j argument */
 static Boolean          forceJobs;      /* -j argument given */
-static int              maxLocal;       /* -L argument */
-Boolean                 compatMake;     /* -B argument */
-Boolean                 debug;          /* -d flag */
-Boolean                 noExecute;      /* -n flag */
-Boolean                 keepgoing;      /* -k flag */
-Boolean                 queryFlag;      /* -q flag */
-Boolean                 touchFlag;      /* -t flag */
-Boolean                 usePipes;       /* !-P flag */
-Boolean                 ignoreErrors;   /* -i flag */
-Boolean                 beSilent;       /* -s flag */
-Boolean                 beVerbose;      /* -v flag */
-Boolean                 oldVars;        /* variable substitution style */
-Boolean                 checkEnvFirst;  /* -e flag */
-Lst                     envFirstVars;   /* (-E) vars to override from env */
-static Boolean          jobsRunning;    /* TRUE if the jobs might be running */
+static int              maxLocal;       /* -L argument */
+Boolean                 compatMake;     /* -B argument */
+Boolean                 debug;          /* -d flag */
+Boolean                 noExecute;      /* -n flag */
+Boolean                 keepgoing;      /* -k flag */
+Boolean                 queryFlag;      /* -q flag */
+Boolean                 touchFlag;      /* -t flag */
+Boolean                 usePipes;       /* !-P flag */
+Boolean                 ignoreErrors;   /* -i flag */
+Boolean                 beSilent;       /* -s flag */
+Boolean                 beVerbose;      /* -v flag */
+Boolean                 oldVars;        /* variable substitution style */
+Boolean                 checkEnvFirst;  /* -e flag */
+Lst                     envFirstVars;   /* (-E) vars to override from env */
+static Boolean          jobsRunning;    /* TRUE if the jobs might be running */
 #ifdef NMAKE
 static Boolean          go_to_objdir;   /* ! -o flag */
 #endif
-static void             MainParseArgs __P((int, char **));
-char *                  chdir_verify_path __P((char *, char *));
-static int              ReadMakefile __P((ClientData, ClientData));
-static void             usage __P((void));
-
-static char *curdir;                    /* startup directory */
-static char *objdir;                    /* where we chdir'ed to */
+static void             MainParseArgs __P((int, char **));
+char *                  chdir_verify_path __P((char *, char *));
+static int              ReadMakefile __P((ClientData, ClientData));
+static void             usage __P((void));
+
+static char *curdir;                    /* startup directory */
+static char *objdir;                    /* where we chdir'ed to */
+#ifdef KMK
+char *                  argv0 = NULL;
+#endif
 
 /*-
  * MainParseArgs --
- *      Parse a given argument vector. Called from main() and from
- *      Main_ParseArgLine() when the .MAKEFLAGS target is used.
- *
- *      XXX: Deal with command line overriding .MAKEFLAGS in makefile
+ *      Parse a given argument vector. Called from main() and from
+ *      Main_ParseArgLine() when the .MAKEFLAGS target is used.
+ *
+ *      XXX: Deal with command line overriding .MAKEFLAGS in makefile
  *
  * Results:
- *      None
+ *      None
  *
  * Side Effects:
- *      Various global and local flags will be set depending on the flags
- *      given
+ *      Various global and local flags will be set depending on the flags
+ *      given
  */
 static void
 MainParseArgs(argc, argv)
-        int argc;
-        char **argv;
-{
-        extern int optind;
-        extern char *optarg;
-        char *p;
-        int c;
-
-        optind = 1;     /* since we're called more than once */
+        int argc;
+        char **argv;
+{
+        extern int optind;
+        extern char *optarg;
+        char *p;
+        int c;
+
+        optind = 1;     /* since we're called more than once */
 #ifdef REMOTE
 # ifdef NMAKE
@@ -218 +223 @@
 # endif
 #endif
-rearg:  while((c = getopt(argc, argv, OPTFLAGS)) != -1) {
-                switch(c) {
-                case 'D':
-                        Var_Set(optarg, "1", VAR_GLOBAL);
-                        Var_Append(MAKEFLAGS, "-D", VAR_GLOBAL);
-                        Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
-                        break;
-                case 'I':
-                        Parse_AddIncludeDir(optarg);
-                        Var_Append(MAKEFLAGS, "-I", VAR_GLOBAL);
-                        Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
-                        break;
-                case 'V':
-                        printVars = TRUE;
-                        (void)Lst_AtEnd(variables, (ClientData)optarg);
-                        Var_Append(MAKEFLAGS, "-V", VAR_GLOBAL);
-                        Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
-                        break;
-                case 'X':
-                        expandVars = FALSE;
-                        break;
-                case 'B':
-                        compatMake = TRUE;
-                        Var_Append(MAKEFLAGS, "-B", VAR_GLOBAL);
-                        break;
+rearg:  while((c = getopt(argc, argv, OPTFLAGS)) != -1) {
+                switch(c) {
+                case 'D':
+                        Var_Set(optarg, "1", VAR_GLOBAL);
+                        Var_Append(MAKEFLAGS, "-D", VAR_GLOBAL);
+                        Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
+                        break;
+                case 'I':
+                        Parse_AddIncludeDir(optarg);
+                        Var_Append(MAKEFLAGS, "-I", VAR_GLOBAL);
+                        Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
+                        break;
+                case 'V':
+                        printVars = TRUE;
+                        (void)Lst_AtEnd(variables, (ClientData)optarg);
+                        Var_Append(MAKEFLAGS, "-V", VAR_GLOBAL);
+                        Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
+                        break;
+                case 'X':
+                        expandVars = FALSE;
+                        break;
+                case 'B':
+                        compatMake = TRUE;
+                        Var_Append(MAKEFLAGS, "-B", VAR_GLOBAL);
+                        break;
 #ifdef REMOTE
-                case 'L': {
-                        char *endptr;
-
-                        maxLocal = strtol(optarg, &endptr, 10);
-                        if (maxLocal < 0 || *endptr != '\0') {
-                                warnx("illegal number, -L argument -- %s",
-                                    optarg);
-                                usage();
-                        }
-                        Var_Append(MAKEFLAGS, "-L", VAR_GLOBAL);
-                        Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
-                        break;
-                }
-#endif
-                case 'P':
-                        usePipes = FALSE;
-                        Var_Append(MAKEFLAGS, "-P", VAR_GLOBAL);
-                        break;
-                case 'S':
-                        keepgoing = FALSE;
-                        Var_Append(MAKEFLAGS, "-S", VAR_GLOBAL);
-                        break;
-                case 'd': {
-                        char *modules = optarg;
-
-                        for (; *modules; ++modules)
-                                switch (*modules) {
-                                case 'A':
-                                        debug = ~0;
-                                        break;
-                                case 'a':
+                case 'L': {
+                        char *endptr;
+
+                        maxLocal = strtol(optarg, &endptr, 10);
+                        if (maxLocal < 0 || *endptr != '\0') {
+                                warnx("illegal number, -L argument -- %s",
+                                    optarg);
+                                usage();
+                        }
+                        Var_Append(MAKEFLAGS, "-L", VAR_GLOBAL);
+                        Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
+                        break;
+                }
+#endif
+                case 'P':
+                        usePipes = FALSE;
+                        Var_Append(MAKEFLAGS, "-P", VAR_GLOBAL);
+                        break;
+                case 'S':
+                        keepgoing = FALSE;
+                        Var_Append(MAKEFLAGS, "-S", VAR_GLOBAL);
+                        break;
+                case 'd': {
+                        char *modules = optarg;
+
+                        for (; *modules; ++modules)
+                                switch (*modules) {
+                                case 'A':
+                                        debug = ~0;
+                                        break;
+                                case 'a':
 #ifdef USE_ARCHIVES
-                                        debug |= DEBUG_ARCH;
+                                        debug |= DEBUG_ARCH;
 #endif /* else ignore */
-                                        break;
-                                case 'c':
-                                        debug |= DEBUG_COND;
-                                        break;
-                                case 'd':
-                                        debug |= DEBUG_DIR;
-                                        break;
-                                case 'f':
-                                        debug |= DEBUG_FOR;
-                                        break;
-                                case 'g':
-                                        if (modules[1] == '1') {
-                                                debug |= DEBUG_GRAPH1;
-                                                ++modules;
-                                        }
-                                        else if (modules[1] == '2') {
-                                                debug |= DEBUG_GRAPH2;
-                                                ++modules;
-                                        }
-                                        break;
-                                case 'j':
-                                        debug |= DEBUG_JOB;
-                                        break;
-                                case 'l':
-                                        debug |= DEBUG_LOUD;
-                                        break;
-                                case 'm':
-                                        debug |= DEBUG_MAKE;
-                                        break;
+                                        break;
+                                case 'c':
+                                        debug |= DEBUG_COND;
+                                        break;
+                                case 'd':
+                                        debug |= DEBUG_DIR;
+                                        break;
+                                case 'f':
+                                        debug |= DEBUG_FOR;
+                                        break;
+                                case 'g':
+                                        if (modules[1] == '1') {
+                                                debug |= DEBUG_GRAPH1;
+                                                ++modules;
+                                        }
+                                        else if (modules[1] == '2') {
+                                                debug |= DEBUG_GRAPH2;
+                                                ++modules;
+                                        }
+                                        break;
+                                case 'j':
+                                        debug |= DEBUG_JOB;
+                                        break;
+                                case 'l':
+                                        debug |= DEBUG_LOUD;
+                                        break;
+                                case 'm':
+                                        debug |= DEBUG_MAKE;
+                                        break;
                                 case 'p':     /*kso*/
-                                        debug |= DEBUG_PARSE;
+                                        debug |= DEBUG_PARSE;
                                         break;
                                 case 's':
-                                        debug |= DEBUG_SUFF;
-                                        break;
-                                case 't':
-                                        debug |= DEBUG_TARG;
-                                        break;
-                                case 'v':
-                                        debug |= DEBUG_VAR;
-                                        break;
-                                default:
-                                        warnx("illegal argument to d option -- %c", *modules);
-                                        usage();
-                                }
-                        Var_Append(MAKEFLAGS, "-d", VAR_GLOBAL);
-                        Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
-                        break;
-                }
-                case 'E':
-                        p = emalloc(strlen(optarg) + 1);
-                        (void)strcpy(p, optarg);
-                        (void)Lst_AtEnd(envFirstVars, (ClientData)p);
-                        Var_Append(MAKEFLAGS, "-E", VAR_GLOBAL);
-                        Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
-                        break;
-                case 'e':
-                        checkEnvFirst = TRUE;
-                        Var_Append(MAKEFLAGS, "-e", VAR_GLOBAL);
-                        break;
-                case 'f':
-                        (void)Lst_AtEnd(makefiles, (ClientData)optarg);
-                        break;
-                case 'i':
-                        ignoreErrors = TRUE;
-                        Var_Append(MAKEFLAGS, "-i", VAR_GLOBAL);
-                        break;
-                case 'j': {
-                        char *endptr;
-
-                        forceJobs = TRUE;
-                        maxJobs = strtol(optarg, &endptr, 10);
-                        if (maxJobs <= 0 || *endptr != '\0') {
-                                warnx("illegal number, -j argument -- %s",
-                                    optarg);
-                                usage();
-                        }
+                                        debug |= DEBUG_SUFF;
+                                        break;
+                                case 't':
+                                        debug |= DEBUG_TARG;
+                                        break;
+                                case 'v':
+                                        debug |= DEBUG_VAR;
+                                        break;
+                                default:
+                                        warnx("illegal argument to d option -- %c", *modules);
+                                        usage();
+                                }
+                        Var_Append(MAKEFLAGS, "-d", VAR_GLOBAL);
+                        Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
+                        break;
+                }
+                case 'E':
+                        p = emalloc(strlen(optarg) + 1);
+                        (void)strcpy(p, optarg);
+                        (void)Lst_AtEnd(envFirstVars, (ClientData)p);
+                        Var_Append(MAKEFLAGS, "-E", VAR_GLOBAL);
+                        Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
+                        break;
+                case 'e':
+                        checkEnvFirst = TRUE;
+                        Var_Append(MAKEFLAGS, "-e", VAR_GLOBAL);
+                        break;
+                case 'f':
+                        (void)Lst_AtEnd(makefiles, (ClientData)optarg);
+                        break;
+                case 'i':
+                        ignoreErrors = TRUE;
+                        Var_Append(MAKEFLAGS, "-i", VAR_GLOBAL);
+                        break;
+                case 'j': {
+                        char *endptr;
+
+                        forceJobs = TRUE;
+                        maxJobs = strtol(optarg, &endptr, 10);
+                        if (maxJobs <= 0 || *endptr != '\0') {
+                                warnx("illegal number, -j argument -- %s",
+                                    optarg);
+                                usage();
+                        }
 #ifndef REMOTE
-                        maxLocal = maxJobs;
-#endif
-                        Var_Append(MAKEFLAGS, "-j", VAR_GLOBAL);
-                        Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
-                        break;
-                }
-                case 'k':
-                        keepgoing = TRUE;
-                        Var_Append(MAKEFLAGS, "-k", VAR_GLOBAL);
-                        break;
-                case 'm':
-                        Dir_AddDir(sysIncPath, optarg);
-                        Var_Append(MAKEFLAGS, "-m", VAR_GLOBAL);
-                        Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
-                        break;
-                case 'n':
-                        noExecute = TRUE;
-                        Var_Append(MAKEFLAGS, "-n", VAR_GLOBAL);
-                        break;
+                        maxLocal = maxJobs;
+#endif
+                        Var_Append(MAKEFLAGS, "-j", VAR_GLOBAL);
+                        Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
+                        break;
+                }
+                case 'k':
+                        keepgoing = TRUE;
+                        Var_Append(MAKEFLAGS, "-k", VAR_GLOBAL);
+                        break;
+                case 'm':
+                        Dir_AddDir(sysIncPath, optarg);
+                        Var_Append(MAKEFLAGS, "-m", VAR_GLOBAL);
+                        Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
+                        break;
+                case 'n':
+                        noExecute = TRUE;
+                        Var_Append(MAKEFLAGS, "-n", VAR_GLOBAL);
+                        break;
 #ifdef NMAKE
                 case 'o':
                         go_to_objdir = TRUE;
-                        Var_Append(MAKEFLAGS, "-o", VAR_GLOBAL);
-                        break;
-#endif
-                case 'q':
-                        queryFlag = TRUE;
-                        /* Kind of nonsensical, wot? */
-                        Var_Append(MAKEFLAGS, "-q", VAR_GLOBAL);
-                        break;
-                case 'r':
-                        noBuiltins = TRUE;
-                        Var_Append(MAKEFLAGS, "-r", VAR_GLOBAL);
-                        break;
-                case 's':
-                        beSilent = TRUE;
-                        Var_Append(MAKEFLAGS, "-s", VAR_GLOBAL);
-                        break;
-                case 't':
-                        touchFlag = TRUE;
-                        Var_Append(MAKEFLAGS, "-t", VAR_GLOBAL);
-                        break;
-                case 'v':
-                        beVerbose = TRUE;
-                        Var_Append(MAKEFLAGS, "-v", VAR_GLOBAL);
-                        break;
-                default:
-                case '?':
-                        usage();
-                }
-        }
-
-        oldVars = TRUE;
-
-        /*
-         * See if the rest of the arguments are variable assignments and
-         * perform them if so. Else take them to be targets and stuff them
-         * on the end of the "create" list.
-         */
-        for (argv += optind, argc -= optind; *argv; ++argv, --argc)
-                if (Parse_IsVar(*argv))
-                        Parse_DoVar(*argv, VAR_CMD);
-                else {
-                        if (!**argv)
-                                Punt("illegal (null) argument.");
-                        if (**argv == '-') {
-                                if ((*argv)[1])
-                                        optind = 0;     /* -flag... */
-                                else
-                                        optind = 1;     /* - */
-                                goto rearg;
-                        }
-                        (void)Lst_AtEnd(create, (ClientData)estrdup(*argv));
-                }
+                        Var_Append(MAKEFLAGS, "-o", VAR_GLOBAL);
+                        break;
+#endif
+                case 'q':
+                        queryFlag = TRUE;
+                        /* Kind of nonsensical, wot? */
+                        Var_Append(MAKEFLAGS, "-q", VAR_GLOBAL);
+                        break;
+                case 'r':
+                        noBuiltins = TRUE;
+                        Var_Append(MAKEFLAGS, "-r", VAR_GLOBAL);
+                        break;
+                case 's':
+                        beSilent = TRUE;
+                        Var_Append(MAKEFLAGS, "-s", VAR_GLOBAL);
+                        break;
+                case 't':
+                        touchFlag = TRUE;
+                        Var_Append(MAKEFLAGS, "-t", VAR_GLOBAL);
+                        break;
+                case 'v':
+                        beVerbose = TRUE;
+                        Var_Append(MAKEFLAGS, "-v", VAR_GLOBAL);
+                        break;
+                default:
+                case '?':
+                        usage();
+                }
+        }
+
+        oldVars = TRUE;
+
+        /*
+         * See if the rest of the arguments are variable assignments and
+         * perform them if so. Else take them to be targets and stuff them
+         * on the end of the "create" list.
+         */
+        for (argv += optind, argc -= optind; *argv; ++argv, --argc)
+                if (Parse_IsVar(*argv))
+                        Parse_DoVar(*argv, VAR_CMD);
+                else {
+                        if (!**argv)
+                                Punt("illegal (null) argument.");
+                        if (**argv == '-') {
+                                if ((*argv)[1])
+                                        optind = 0;     /* -flag... */
+                                else
+                                        optind = 1;     /* - */
+                                goto rearg;
+                        }
+                        (void)Lst_AtEnd(create, (ClientData)estrdup(*argv));
+                }
 }
 
 /*-
  * Main_ParseArgLine --
- *      Used by the parse module when a .MFLAGS or .MAKEFLAGS target
- *      is encountered and by main() when reading the .MAKEFLAGS envariable.
- *      Takes a line of arguments and breaks it into its
- *      component words and passes those words and the number of them to the
- *      MainParseArgs function.
- *      The line should have all its leading whitespace removed.
+ *      Used by the parse module when a .MFLAGS or .MAKEFLAGS target
+ *      is encountered and by main() when reading the .MAKEFLAGS envariable.
+ *      Takes a line of arguments and breaks it into its
+ *      component words and passes those words and the number of them to the
+ *      MainParseArgs function.
+ *      The line should have all its leading whitespace removed.
  *
  * Results:
- *      None
+ *      None
  *
  * Side Effects:
- *      Only those that come from the various arguments.
+ *      Only those that come from the various arguments.
  */
 void
 Main_ParseArgLine(line)
-        char *line;                     /* Line to fracture */
-{
-        char **argv;                    /* Manufactured argument vector */
-        int argc;                       /* Number of arguments in argv */
-
-        if (line == NULL)
-                return;
-        for (; *line == ' '; ++line)
-                continue;
-        if (!*line)
-                return;
-
-        argv = brk_string(line, &argc, TRUE);
-        MainParseArgs(argc, argv);
+        char *line;                     /* Line to fracture */
+{
+        char **argv;                    /* Manufactured argument vector */
+        int argc;                       /* Number of arguments in argv */
+
+        if (line == NULL)
+                return;
+        for (; *line == ' '; ++line)
+                continue;
+        if (!*line)
+                return;
+
+        argv = brk_string(line, &argc, TRUE);
+        MainParseArgs(argc, argv);
 }
 
 char *
 chdir_verify_path(path, obpath)
-        char *path;
-        char *obpath;
+        char *path;
+        char *obpath;
 {
         struct stat sb;
@@ -476 +481 @@
 #endif
 
-        if (stat(path, &sb) == 0 && S_ISDIR(sb.st_mode)) {
-                if (chdir(path)) {
-                        warn("warning: %s", path);
-                        return 0;
-                }
-                else {
-                        if (path[0] != '/') {
-                                (void) snprintf(obpath, MAXPATHLEN, "%s/%s",
-                                                curdir, path);
-                                return obpath;
-                        }
-                        else
-                                return path;
-                }
-        }
-
-        return 0;
+        if (stat(path, &sb) == 0 && S_ISDIR(sb.st_mode)) {
+                if (chdir(path)) {
+                        warn("warning: %s", path);
+                        return 0;
+                }
+                else {
+                        if (path[0] != '/') {
+                                (void) snprintf(obpath, MAXPATHLEN, "%s/%s",
+                                                curdir, path);
+                                return obpath;
+                        }
+                        else
+                                return path;
+                }
+        }
+
+        return 0;
 }
 
@@ -498 +503 @@
 /*-
  * main --
- *      The main function, for obvious reasons. Initializes variables
- *      and a few modules, then parses the arguments give it in the
- *      environment and on the command line. Reads the system makefile
- *      followed by either Makefile, makefile or the file given by the
- *      -f argument. Sets the .MAKEFLAGS PMake variable based on all the
- *      flags it has received by then uses either the Make or the Compat
- *      module to create the initial list of targets.
+ *      The main function, for obvious reasons. Initializes variables
+ *      and a few modules, then parses the arguments give it in the
+ *      environment and on the command line. Reads the system makefile
+ *      followed by either Makefile, makefile or the file given by the
+ *      -f argument. Sets the .MAKEFLAGS PMake variable based on all the
+ *      flags it has received by then uses either the Make or the Compat
+ *      module to create the initial list of targets.
  *
  * Results:
- *      If -q was given, exits -1 if anything was out-of-date. Else it exits
- *      0.
+ *      If -q was given, exits -1 if anything was out-of-date. Else it exits
+ *      0.
  *
  * Side Effects:
- *      The program exits when done. Targets are created. etc. etc. etc.
+ *      The program exits when done. Targets are created. etc. etc. etc.
  */
 int
@@ -519 +524 @@
 main(argc, argv)
 #endif
-        int argc;
-        char **argv;
-{
-        Lst targs;      /* target nodes to create -- passed to Make_Init */
-        Boolean outOfDate = TRUE;       /* FALSE if all targets up to date */
-        struct stat sa;
-        char *p, *p1, *path, *pathp;
+        int argc;
+        char **argv;
+{
+        Lst targs;      /* target nodes to create -- passed to Make_Init */
+        Boolean outOfDate = TRUE;       /* FALSE if all targets up to date */
+        struct stat sa;
+        char *p, *p1, *path, *pathp;
 #ifdef WANT_ENV_PWD
-        struct stat sb;
-        char *pwd;
-#endif
-        char mdpath[MAXPATHLEN + 1];
-        char obpath[MAXPATHLEN + 1];
-        char cdpath[MAXPATHLEN + 1];
-        char *machine = getenv("MACHINE");
-        char *machine_arch = getenv("MACHINE_ARCH");
-        char *machine_cpu = getenv("MACHINE_CPU");
-        Lst sysMkPath;                  /* Path of sys.mk */
-        char *cp = NULL, *start;
-                                        /* avoid faults on read-only strings */
+        struct stat sb;
+        char *pwd;
+#endif
+        char mdpath[MAXPATHLEN + 1];
+        char obpath[MAXPATHLEN + 1];
+        char cdpath[MAXPATHLEN + 1];
+        char *machine = getenv("MACHINE");
+        char *machine_arch = getenv("MACHINE_ARCH");
+        char *machine_cpu = getenv("MACHINE_CPU");
+        Lst sysMkPath;                  /* Path of sys.mk */
+        char *cp = NULL, *start;
+                                        /* avoid faults on read-only strings */
         #ifndef KMK
-        static char syspath[] = _PATH_DEFSYSPATH;
+        static char syspath[] = _PATH_DEFSYSPATH;
         #endif
 
+        #ifdef KMK
+        /*
+         * Save ourselfs.
+         */
+        argv0 = argv[0];
+        #endif
+
 #ifdef RLIMIT_NOFILE
-        /*
-         * get rid of resource limit on file descriptors
-         */
-        {
-                struct rlimit rl;
-                if (getrlimit(RLIMIT_NOFILE, &rl) != -1 &&
-                    rl.rlim_cur != rl.rlim_max) {
-                        rl.rlim_cur = rl.rlim_max;
-                        (void) setrlimit(RLIMIT_NOFILE, &rl);
-                }
-        }
-#endif
-        /*
-         * Find where we are and take care of PWD for the automounter...
-         * All this code is so that we know where we are when we start up
-         * on a different machine with pmake.
-         */
-        curdir = cdpath;
-        if (getcwd(curdir, MAXPATHLEN) == NULL)
-                err(2, NULL);
-
-        if (stat(curdir, &sa) == -1)
-            err(2, "%s", curdir);
+        /*
+         * get rid of resource limit on file descriptors
+         */
+        {
+                struct rlimit rl;
+                if (getrlimit(RLIMIT_NOFILE, &rl) != -1 &&
+                    rl.rlim_cur != rl.rlim_max) {
+                        rl.rlim_cur = rl.rlim_max;
+                        (void) setrlimit(RLIMIT_NOFILE, &rl);
+                }
+        }
+#endif
+        /*
+         * Find where we are and take care of PWD for the automounter...
+         * All this code is so that we know where we are when we start up
+         * on a different machine with pmake.
+         */
+        curdir = cdpath;
+        if (getcwd(curdir, MAXPATHLEN) == NULL)
+                err(2, NULL);
+
+        if (stat(curdir, &sa) == -1)
+            err(2, "%s", curdir);
 
 #ifdef WANT_ENV_PWD
-        if ((pwd = getenv("PWD")) != NULL) {
-            if (stat(pwd, &sb) == 0 && sa.st_ino == sb.st_ino &&
-                sa.st_dev == sb.st_dev)
-                (void) strcpy(curdir, pwd);
-        }
+        if ((pwd = getenv("PWD")) != NULL) {
+            if (stat(pwd, &sb) == 0 && sa.st_ino == sb.st_ino &&
+                sa.st_dev == sb.st_dev)
+                (void) strcpy(curdir, pwd);
+        }
 #endif
 
 #if defined(__i386__) && defined(__FreeBSD_version) && \
     __FreeBSD_version > 300003
-        /*
-         * PC-98 kernel sets the `i386' string to the utsname.machine and
-         * it cannot be distinguished from IBM-PC by uname(3).  Therefore,
-         * we check machine.ispc98 and adjust the machine variable before
-         * using usname(3) below.
-         * NOTE: machdep.ispc98 was defined on 1998/8/31. At that time,
-         * __FreeBSD_version was defined as 300003. So, this check can
-         * safely be done with any kernel with version > 300003.
-         */
-        if (!machine) {
-                int     ispc98;
-                size_t  len;
-
-                len = sizeof(ispc98);
-                if (!sysctlbyname("machdep.ispc98", &ispc98, &len, NULL, 0)) {
-                        if (ispc98)
-                                machine = "pc98";
-                }
-        }
-#endif
-
-        /*
-         * Get the name of this type of MACHINE from utsname
-         * so we can share an executable for similar machines.
-         * (i.e. m68k: amiga hp300, mac68k, sun3, ...)
-         *
-         * Note that while MACHINE is decided at run-time,
-         * MACHINE_ARCH is always known at compile time.
-         */
-        if (!machine) {
+        /*
+         * PC-98 kernel sets the `i386' string to the utsname.machine and
+         * it cannot be distinguished from IBM-PC by uname(3).  Therefore,
+         * we check machine.ispc98 and adjust the machine variable before
+         * using usname(3) below.
+         * NOTE: machdep.ispc98 was defined on 1998/8/31. At that time,
+         * __FreeBSD_version was defined as 300003. So, this check can
+         * safely be done with any kernel with version > 300003.
+         */
+        if (!machine) {
+                int     ispc98;
+                size_t  len;
+
+                len = sizeof(ispc98);
+                if (!sysctlbyname("machdep.ispc98", &ispc98, &len, NULL, 0)) {
+                        if (ispc98)
+                                machine = "pc98";
+                }
+        }
+#endif
+
+        /*
+         * Get the name of this type of MACHINE from utsname
+         * so we can share an executable for similar machines.
+         * (i.e. m68k: amiga hp300, mac68k, sun3, ...)
+         *
+         * Note that while MACHINE is decided at run-time,
+         * MACHINE_ARCH is always known at compile time.
+         */
+        if (!machine) {
 #ifndef MACHINE
-            struct utsname utsname;
-
-            if (uname(&utsname) == -1) {
-                    perror(MAKE_NAME ": uname");
-                    exit(2);
-            }
-            machine = utsname.machine;
-#else
-            machine = MACHINE;
-#endif
-        }
-
-        if (!machine_arch) {
+            struct utsname utsname;
+
+            if (uname(&utsname) == -1) {
+                    perror(MAKE_NAME ": uname");
+                    exit(2);
+            }
+            machine = utsname.machine;
+#else
+            machine = MACHINE;
+#endif
+        }
+
+        if (!machine_arch) {
 #ifndef MACHINE_ARCH
-                machine_arch = "unknown";
-#else
-                machine_arch = MACHINE_ARCH;
-#endif
-        }
-
-        /*
-         * Set machine_cpu to the minumum supported CPU revision based
-         * on the target architecture, if not already set.
-         */
-        if (!machine_cpu) {
-                if (!strcmp(machine_arch, "i386"))
-                        machine_cpu = "i386";
-                else if (!strcmp(machine_arch, "alpha"))
-                        machine_cpu = "ev4";
-                else
-                        machine_cpu = "unknown";
-        }
-        
+                machine_arch = "unknown";
+#else
+                machine_arch = MACHINE_ARCH;
+#endif
+        }
+
+        /*
+         * Set machine_cpu to the minumum supported CPU revision based
+         * on the target architecture, if not already set.
+         */
+        if (!machine_cpu) {
+                if (!strcmp(machine_arch, "i386"))
+                        machine_cpu = "i386";
+                else if (!strcmp(machine_arch, "alpha"))
+                        machine_cpu = "ev4";
+                else
+                        machine_cpu = "unknown";
+        }
+
         #ifdef KMK
         /* @todo figure out how to set object directory! */
         #else
-        /*
-         * The object directory location is determined using the
-         * following order of preference:
-         *
-         *      1. MAKEOBJDIRPREFIX`cwd`
-         *      2. MAKEOBJDIR
-         *      3. _PATH_OBJDIR.${MACHINE}
-         *      4. _PATH_OBJDIR
-         *      5. _PATH_OBJDIRPREFIX`cwd`
-         *
-         * If one of the first two fails, use the current directory.
-         * If the remaining three all fail, use the current directory.
-         *
-         * Once things are initted,
-         * have to add the original directory to the search path,
-         * and modify the paths for the Makefiles apropriately.  The
-         * current directory is also placed as a variable for make scripts.
-         */
-        if (!(pathp = getenv("MAKEOBJDIRPREFIX"))) {
-                if (!(path = getenv("MAKEOBJDIR"))) {
-                        path = _PATH_OBJDIR;
-                        pathp = _PATH_OBJDIRPREFIX;
-                        (void) snprintf(mdpath, MAXPATHLEN, "%s.%s",
-                                        path, machine);
-                        if (!(objdir = chdir_verify_path(mdpath, obpath)))
-                                if (!(objdir=chdir_verify_path(path, obpath))) {
-                                        (void) snprintf(mdpath, MAXPATHLEN,
-                                                        "%s%s", pathp, curdir);
-                                        if (!(objdir=chdir_verify_path(mdpath,
-                                                                       obpath)))
-                                                objdir = curdir;
-                                }
-                }
-                else if (!(objdir = chdir_verify_path(path, obpath)))
-                        objdir = curdir;
-        }
-        else {
-                (void) snprintf(mdpath, MAXPATHLEN, "%s%s", pathp, curdir);
-                if (!(objdir = chdir_verify_path(mdpath, obpath)))
-                        objdir = curdir;
-        }
+        /*
+         * The object directory location is determined using the
+         * following order of preference:
+         *
+         *      1. MAKEOBJDIRPREFIX`cwd`
+         *      2. MAKEOBJDIR
+         *      3. _PATH_OBJDIR.${MACHINE}
+         *      4. _PATH_OBJDIR
+         *      5. _PATH_OBJDIRPREFIX`cwd`
+         *
+         * If one of the first two fails, use the current directory.
+         * If the remaining three all fail, use the current directory.
+         *
+         * Once things are initted,
+         * have to add the original directory to the search path,
+         * and modify the paths for the Makefiles apropriately.  The
+         * current directory is also placed as a variable for make scripts.
+         */
+        if (!(pathp = getenv("MAKEOBJDIRPREFIX"))) {
+                if (!(path = getenv("MAKEOBJDIR"))) {
+                        path = _PATH_OBJDIR;
+                        pathp = _PATH_OBJDIRPREFIX;
+                        (void) snprintf(mdpath, MAXPATHLEN, "%s.%s",
+                                        path, machine);
+                        if (!(objdir = chdir_verify_path(mdpath, obpath)))
+                                if (!(objdir=chdir_verify_path(path, obpath))) {
+                                        (void) snprintf(mdpath, MAXPATHLEN,
+                                                        "%s%s", pathp, curdir);
+                                        if (!(objdir=chdir_verify_path(mdpath,
+                                                                       obpath)))
+                                                objdir = curdir;
+                                }
+                }
+                else if (!(objdir = chdir_verify_path(path, obpath)))
+                        objdir = curdir;
+        }
+        else {
+                (void) snprintf(mdpath, MAXPATHLEN, "%s%s", pathp, curdir);
+                if (!(objdir = chdir_verify_path(mdpath, obpath)))
+                        objdir = curdir;
+        }
         #endif
 
 #ifdef WANT_ENV_PWD
         #ifdef USE_KLIB
-        kEnvSet("PWD", objdir);
+        kEnvSet("PWD", objdir);
         #else
-        setenv("PWD", objdir, 1);
+        setenv("PWD", objdir, 1);
         #endif
 #endif
 
-        create = Lst_Init(FALSE);
-        makefiles = Lst_Init(FALSE);
-        envFirstVars = Lst_Init(FALSE);
-        printVars = FALSE;
-        expandVars = TRUE;
-        variables = Lst_Init(FALSE);
-        beSilent = FALSE;               /* Print commands as executed */
-        ignoreErrors = FALSE;           /* Pay attention to non-zero returns */
-        noExecute = FALSE;              /* Execute all commands */
-        keepgoing = FALSE;              /* Stop on error */
-        allPrecious = FALSE;            /* Remove targets when interrupted */
-        queryFlag = FALSE;              /* This is not just a check-run */
-        noBuiltins = FALSE;             /* Read the built-in rules */
-        touchFlag = FALSE;              /* Actually update targets */
-        usePipes = TRUE;                /* Catch child output in pipes */
-        debug = 0;                      /* No debug verbosity, please. */
-        jobsRunning = FALSE;
+        create = Lst_Init(FALSE);
+        makefiles = Lst_Init(FALSE);
+        envFirstVars = Lst_Init(FALSE);
+        printVars = FALSE;
+        expandVars = TRUE;
+        variables = Lst_Init(FALSE);
+        beSilent = FALSE;               /* Print commands as executed */
+        ignoreErrors = FALSE;           /* Pay attention to non-zero returns */
+        noExecute = FALSE;              /* Execute all commands */
+        keepgoing = FALSE;              /* Stop on error */
+        allPrecious = FALSE;            /* Remove targets when interrupted */
+        queryFlag = FALSE;              /* This is not just a check-run */
+        noBuiltins = FALSE;             /* Read the built-in rules */
+        touchFlag = FALSE;              /* Actually update targets */
+#ifdef USE_PIPES
+        usePipes = TRUE;                /* Catch child output in pipes */
+#else
+        usePipes = FALSE;               /* Don't catch child output in pipes if multiple wait isn't supported */
+#endif
+        debug = 0;                      /* No debug verbosity, please. */
+        jobsRunning = FALSE;
 #ifdef NMAKE
-        go_to_objdir = FALSE;
-#endif
-
-        maxLocal = DEFMAXLOCAL;         /* Set default local max concurrency */
+        go_to_objdir = FALSE;
+#endif
+
+        maxLocal = DEFMAXLOCAL;         /* Set default local max concurrency */
 #ifdef REMOTE
-        maxJobs = DEFMAXJOBS;           /* Set default max concurrency */
-#else
-        maxJobs = maxLocal;
-#endif
-        forceJobs = FALSE;              /* No -j flag */
-        compatMake = FALSE;             /* No compat mode */
-
-
-        /*
-         * Initialize the parsing, directory and variable modules to prepare
-         * for the reading of inclusion paths and variable settings on the
-         * command line
-         */
-        Dir_Init();             /* Initialize directory structures so -I flags
-                                 * can be processed correctly */
-        Parse_Init();           /* Need to initialize the paths of #include
-                                 * directories */
-        Var_Init();             /* As well as the lists of variables for
-                                 * parsing arguments */
+        maxJobs = DEFMAXJOBS;           /* Set default max concurrency */
+#else
+        maxJobs = maxLocal;
+#endif
+        forceJobs = FALSE;              /* No -j flag */
+        compatMake = FALSE;             /* No compat mode */
+
+
+        /*
+         * Initialize the parsing, directory and variable modules to prepare
+         * for the reading of inclusion paths and variable settings on the
+         * command line
+         */
+        Dir_Init();             /* Initialize directory structures so -I flags
+                                 * can be processed correctly */
+        Parse_Init();           /* Need to initialize the paths of #include
+                                 * directories */
+        Var_Init();             /* As well as the lists of variables for
+                                 * parsing arguments */
         str_init();
-        if (objdir != curdir)
-                Dir_AddDir(dirSearchPath, curdir);
-        Var_Set(".CURDIR", curdir, VAR_GLOBAL);
-        Var_Set(".OBJDIR", objdir, VAR_GLOBAL);
-
-        /*
-         * Initialize various variables.
-         *      MAKE also gets this name, for compatibility
-         *      .MAKEFLAGS gets set to the empty string just in case.
-         *      MFLAGS also gets initialized empty, for compatibility.
-         */
-        Var_Set("MAKE", argv[0], VAR_GLOBAL);
-        Var_Set(MAKEFLAGS, "", VAR_GLOBAL);
-        Var_Set("MFLAGS", "", VAR_GLOBAL);
-        Var_Set("MACHINE", machine, VAR_GLOBAL);
-        Var_Set("MACHINE_ARCH", machine_arch, VAR_GLOBAL);
-        Var_Set("MACHINE_CPU", machine_cpu, VAR_GLOBAL);
-
-        /*
-         * First snag any flags out of the MAKE environment variable.
-         * (Note this is *not* MAKEFLAGS since /bin/make uses that and it's
-         * in a different format).
-         */
+        if (objdir != curdir)
+                Dir_AddDir(dirSearchPath, curdir);
+        Var_Set(".CURDIR", curdir, VAR_GLOBAL);
+        Var_Set(".OBJDIR", objdir, VAR_GLOBAL);
+
+        /*
+         * Initialize various variables.
+         *      MAKE also gets this name, for compatibility
+         *      .MAKEFLAGS gets set to the empty string just in case.
+         *      MFLAGS also gets initialized empty, for compatibility.
+         */
+        Var_Set("MAKE", argv[0], VAR_GLOBAL);
+        Var_Set(MAKEFLAGS, "", VAR_GLOBAL);
+        Var_Set("MFLAGS", "", VAR_GLOBAL);
+        Var_Set("MACHINE", machine, VAR_GLOBAL);
+        Var_Set("MACHINE_ARCH", machine_arch, VAR_GLOBAL);
+        Var_Set("MACHINE_CPU", machine_cpu, VAR_GLOBAL);
+
+        /*
+         * First snag any flags out of the MAKE environment variable.
+         * (Note this is *not* MAKEFLAGS since /bin/make uses that and it's
+         * in a different format).
+         */
 #ifdef POSIX
-        Main_ParseArgLine(getenv("MAKEFLAGS"));
-#else
-        Main_ParseArgLine(getenv("MAKE"));
-#endif
-
-        MainParseArgs(argc, argv);
-
-        /*
-         * Be compatible if user did not specify -j and did not explicitly
-         * turned compatibility on
-         */
-        if (!compatMake && !forceJobs)
-                compatMake = TRUE;
-
-        /*
-         * Initialize archive, target and suffix modules in preparation for
-         * parsing the makefile(s)
-         */
+        Main_ParseArgLine(getenv("MAKEFLAGS"));
+#else
+        Main_ParseArgLine(getenv("MAKE"));
+#endif
+
+#ifdef KMK
+        /*
+         * Completely ignore the tool argument.
+         */
+        if (argc > 1 && !kStrCmp(argv[1], "--kMk"))
+        {
+            argc--;
+            argv++;
+        }
+#endif
+        MainParseArgs(argc, argv);
+
+        /*
+         * Be compatible if user did not specify -j and did not explicitly
+         * turned compatibility on
+         */
+        if (!compatMake && !forceJobs)
+                compatMake = TRUE;
+
+        /*
+         * Initialize archive, target and suffix modules in preparation for
+         * parsing the makefile(s)
+         */
 #ifdef USE_ARCHIVES
-        Arch_Init();
-#endif
-        Targ_Init();
-        Suff_Init();
-
-        DEFAULT = NILGNODE;
-        (void)time(&now);
-
-        /*
-         * Set up the .TARGETS variable to contain the list of targets to be
-         * created. If none specified, make the variable empty -- the parser
-         * will fill the thing in with the default or .MAIN target.
-         */
-        if (!Lst_IsEmpty(create)) {
-                LstNode ln;
-
-                for (ln = Lst_First(create); ln != NILLNODE;
-                    ln = Lst_Succ(ln)) {
-                        char *name = (char *)Lst_Datum(ln);
-
-                        Var_Append(".TARGETS", name, VAR_GLOBAL);
-                }
-        } else
-                Var_Set(".TARGETS", "", VAR_GLOBAL);
+        Arch_Init();
+#endif
+        Targ_Init();
+        Suff_Init();
+
+        DEFAULT = NILGNODE;
+        (void)time(&now);
+
+        /*
+         * Set up the .TARGETS variable to contain the list of targets to be
+         * created. If none specified, make the variable empty -- the parser
+         * will fill the thing in with the default or .MAIN target.
+         */
+        if (!Lst_IsEmpty(create)) {
+                LstNode ln;
+
+                for (ln = Lst_First(create); ln != NILLNODE;
+                    ln = Lst_Succ(ln)) {
+                        char *name = (char *)Lst_Datum(ln);
+
+                        Var_Append(".TARGETS", name, VAR_GLOBAL);
+                }
+        } else
+                Var_Set(".TARGETS", "", VAR_GLOBAL);
 
 
         #ifdef KMK
-        /*
-         * Add current directory tree to system include path all levels up to the root.
+        /*
+         * Add current directory tree to system include path all levels up to the root.
          * ASSUMES that curdir is absolute.
-         */
+         */
         {
             char *  psz = estrdup(curdir);
@@ -834 +860 @@
 
         #else
-        /*
-         * If no user-supplied system path was given (through the -m option)
-         * add the directories from the DEFSYSPATH (more than one may be given
-         * as dir1:...:dirn) to the system include path.
-         */
-        if (Lst_IsEmpty(sysIncPath)) {
-                for (start = syspath; *start != '\0'; start = cp) {
-                        for (cp = start; *cp != '\0' && *cp != ':'; cp++)
-                                continue;
-                        if (*cp == '\0') {
-                                Dir_AddDir(sysIncPath, start);
-                        } else {
-                                *cp++ = '\0';
-                                Dir_AddDir(sysIncPath, start);
-                        }
-                }
-        }
+        /*
+         * If no user-supplied system path was given (through the -m option)
+         * add the directories from the DEFSYSPATH (more than one may be given
+         * as dir1:...:dirn) to the system include path.
+         */
+        if (Lst_IsEmpty(sysIncPath)) {
+                for (start = syspath; *start != '\0'; start = cp) {
+                        for (cp = start; *cp != '\0' && *cp != ':'; cp++)
+                                continue;
+                        if (*cp == '\0') {
+                                Dir_AddDir(sysIncPath, start);
+                        } else {
+                                *cp++ = '\0';
+                                Dir_AddDir(sysIncPath, start);
+                        }
+                }
+        }
         #endif
 
-        /*
-         * Read in the built-in rules first, followed by the specified
-         * makefile, if it was (makefile != (char *) NULL), or the default
-         * Makefile and makefile, in that order, if it wasn't.
-         */
-        if (!noBuiltins) {
-                LstNode ln;
-
-                sysMkPath = Lst_Init (FALSE);
-                Dir_Expand (_PATH_DEFSYSMK, sysIncPath, sysMkPath);
+        /*
+         * Read in the built-in rules first, followed by the specified
+         * makefile, if it was (makefile != (char *) NULL), or the default
+         * Makefile and makefile, in that order, if it wasn't.
+         */
+        if (!noBuiltins) {
+                LstNode ln;
+
+                sysMkPath = Lst_Init (FALSE);
+                Dir_Expand (_PATH_DEFSYSMK, sysIncPath, sysMkPath);
 #ifdef NMAKE
-                if (!Lst_IsEmpty(sysMkPath))
+                if (!Lst_IsEmpty(sysMkPath))
                 {
                     ln = Lst_Find(sysMkPath, (ClientData)NULL, ReadMakefile);
@@ -872 +898 @@
 
 #elif defined(KMK)
-                if (!Lst_IsEmpty(sysMkPath))
+                if (!Lst_IsEmpty(sysMkPath))
                 {
                     ln = Lst_Find(sysMkPath, (ClientData)NULL, ReadMakefile);
@@ -879 +905 @@
 
                 }
-                Error(MAKE_NAME ": no config rules (%s).", _PATH_DEFSYSMK);
-#else
-                if (Lst_IsEmpty(sysMkPath))
-                        Fatal(MAKE_NAME ": no system rules (%s).", _PATH_DEFSYSMK);
-                ln = Lst_Find(sysMkPath, (ClientData)NULL, ReadMakefile);
-                if (ln != NILLNODE)
-                        Fatal(MAKE_NAME ": cannot open %s.", (char *)Lst_Datum(ln));
-#endif
-        }
-
-        if (!Lst_IsEmpty(makefiles)) {
-                LstNode ln;
-
-                ln = Lst_Find(makefiles, (ClientData)NULL, ReadMakefile);
-                if (ln != NILLNODE)
-                        Fatal(MAKE_NAME ": cannot open %s.", (char *)Lst_Datum(ln));
-        } else
+                Error(MAKE_NAME ": no config rules (%s).", _PATH_DEFSYSMK);
+#else
+                if (Lst_IsEmpty(sysMkPath))
+                        Fatal(MAKE_NAME ": no system rules (%s).", _PATH_DEFSYSMK);
+                ln = Lst_Find(sysMkPath, (ClientData)NULL, ReadMakefile);
+                if (ln != NILLNODE)
+                        Fatal(MAKE_NAME ": cannot open %s.", (char *)Lst_Datum(ln));
+#endif
+        }
+
+        if (!Lst_IsEmpty(makefiles)) {
+                LstNode ln;
+
+                ln = Lst_Find(makefiles, (ClientData)NULL, ReadMakefile);
+                if (ln != NILLNODE)
+                        Fatal(MAKE_NAME ": cannot open %s.", (char *)Lst_Datum(ln));
+        } else
             #ifdef KMK
             if (    !ReadMakefile("Makefile.kMk", NULL)
@@ -911 +937 @@
             #endif
 
-        (void)ReadMakefile(".depend", NULL);
-
-        Var_Append("MFLAGS", Var_Value(MAKEFLAGS, VAR_GLOBAL, &p1), VAR_GLOBAL);
-        efree(p1);
-
-        /* Install all the flags into the MAKE envariable. */
-        if (((p = Var_Value(MAKEFLAGS, VAR_GLOBAL, &p1)) != NULL) && *p)
+        (void)ReadMakefile(".depend", NULL);
+
+        Var_Append("MFLAGS", Var_Value(MAKEFLAGS, VAR_GLOBAL, &p1), VAR_GLOBAL);
+        efree(p1);
+
+        /* Install all the flags into the MAKE envariable. */
+        if (((p = Var_Value(MAKEFLAGS, VAR_GLOBAL, &p1)) != NULL) && *p)
 #ifdef POSIX
                 #ifdef USE_KLIB
                 kEnvSet("MAKEFLAGS", p, TRUE);
                 #else
-                setenv("MAKEFLAGS", p, 1);
+                setenv("MAKEFLAGS", p, 1);
                 #endif
 #else
                 #ifdef USE_KLIB
-                kEnvSet("MAKE", p, TRUE);
+                kEnvSet("MAKE", p, TRUE);
                 #else
-                setenv("MAKE", p, 1);
+                setenv("MAKE", p, 1);
                 #endif
 #endif
-        efree(p1);
-
-        /*
-         * For compatibility, look at the directories in the VPATH variable
-         * and add them to the search path, if the variable is defined. The
-         * variable's value is in the same format as the PATH envariable, i.e.
-         * <directory>:<directory>:<directory>...
-         */
-        if (Var_Exists("VPATH", VAR_CMD)) {
-                char *vpath, *path, *cp, savec;
-                /*
-                 * GCC stores string constants in read-only memory, but
-                 * Var_Subst will want to write this thing, so store it
-                 * in an array
-                 */
-                static char VPATH[] = "${VPATH}";
-
-                vpath = Var_Subst(NULL, VPATH, VAR_CMD, FALSE);
-                path = vpath;
-                do {
-                        /* skip to end of directory */
-                        for (cp = path; *cp != ':' && *cp != '\0'; cp++)
-                                continue;
-                        /* Save terminator character so know when to stop */
-                        savec = *cp;
-                        *cp = '\0';
-                        /* Add directory to search path */
-                        Dir_AddDir(dirSearchPath, path);
-                        *cp = savec;
-                        path = cp + 1;
-                } while (savec == ':');
-                (void)efree((Address)vpath);
-        }
-
-        /*
-         * Now that all search paths have been read for suffixes et al, it's
-         * time to add the default search path to their lists...
-         */
-        Suff_DoPaths();
-
-        /* print the initial graph, if the user requested it */
-        if (DEBUG(GRAPH1))
-                Targ_PrintGraph(1);
-
-        /* print the values of any variables requested by the user */
-        if (printVars) {
-                LstNode ln;
-
-                for (ln = Lst_First(variables); ln != NILLNODE;
-                    ln = Lst_Succ(ln)) {
-                        char *value;
-                        if (expandVars) {
-                                p1 = emalloc(strlen((char *)Lst_Datum(ln)) + 1 + 3);
-                                /* This sprintf is safe, because of the malloc above */
-                                (void)sprintf(p1, "${%s}", (char *)Lst_Datum(ln));
-                                value = Var_Subst(NULL, p1, VAR_GLOBAL, FALSE);
-                        } else {
-                                value = Var_Value((char *)Lst_Datum(ln),
-                                                  VAR_GLOBAL, &p1);
-                        }
-                        printf("%s\n", value ? value : "");
-                        if (p1)
-                                efree(p1);
-                }
-        }
-
-        /*
-         * Have now read the entire graph and need to make a list of targets
-         * to create. If none was given on the command line, we consult the
-         * parsing module to find the main target(s) to create.
-         */
-        if (Lst_IsEmpty(create))
-                targs = Parse_MainName();
-        else
-                targs = Targ_FindList(create, TARG_CREATE);
-
-        if (!compatMake && !printVars) {
-                /*
-                 * Initialize job module before traversing the graph, now that
-                 * any .BEGIN and .END targets have been read.  This is done
-                 * only if the -q flag wasn't given (to prevent the .BEGIN from
-                 * being executed should it exist).
-                 */
-                if (!queryFlag) {
-                        if (maxLocal == -1)
-                                maxLocal = maxJobs;
-                        Job_Init(maxJobs, maxLocal);
-                        jobsRunning = TRUE;
-                }
-
-                /* Traverse the graph, checking on all the targets */
-                outOfDate = Make_Run(targs);
-        } else if (!printVars) {
-                /*
-                 * Compat_Init will take care of creating all the targets as
-                 * well as initializing the module.
-                 */
-                Compat_Run(targs);
-        }
-
-        Lst_Destroy(targs, NOFREE);
-        Lst_Destroy(variables, NOFREE);
-        Lst_Destroy(makefiles, NOFREE);
-        Lst_Destroy(create, (void (*) __P((ClientData))) efree);
-
-        /* print the graph now it's been processed if the user requested it */
-        if (DEBUG(GRAPH2))
-                Targ_PrintGraph(2);
-
-        Suff_End();
+        efree(p1);
+
+        /*
+         * For compatibility, look at the directories in the VPATH variable
+         * and add them to the search path, if the variable is defined. The
+         * variable's value is in the same format as the PATH envariable, i.e.
+         * <directory>:<directory>:<directory>...
+         */
+        if (Var_Exists("VPATH", VAR_CMD)) {
+                char *vpath, *path, *cp, savec;
+                /*
+                 * GCC stores string constants in read-only memory, but
+                 * Var_Subst will want to write this thing, so store it
+                 * in an array
+                 */
+                static char VPATH[] = "${VPATH}";
+
+                vpath = Var_Subst(NULL, VPATH, VAR_CMD, FALSE);
+                path = vpath;
+                do {
+                        /* skip to end of directory */
+                        for (cp = path; *cp != ':' && *cp != '\0'; cp++)
+                                continue;
+                        /* Save terminator character so know when to stop */
+                        savec = *cp;
+                        *cp = '\0';
+                        /* Add directory to search path */
+                        Dir_AddDir(dirSearchPath, path);
+                        *cp = savec;
+                        path = cp + 1;
+                } while (savec == ':');
+                (void)efree((Address)vpath);
+        }
+
+        /*
+         * Now that all search paths have been read for suffixes et al, it's
+         * time to add the default search path to their lists...
+         */
+        Suff_DoPaths();
+
+        /* print the initial graph, if the user requested it */
+        if (DEBUG(GRAPH1))
+                Targ_PrintGraph(1);
+
+        /* print the values of any variables requested by the user */
+        if (printVars) {
+                LstNode ln;
+
+                for (ln = Lst_First(variables); ln != NILLNODE;
+                    ln = Lst_Succ(ln)) {
+                        char *value;
+                        if (expandVars) {
+                                p1 = emalloc(strlen((char *)Lst_Datum(ln)) + 1 + 3);
+                                /* This sprintf is safe, because of the malloc above */
+                                (void)sprintf(p1, "${%s}", (char *)Lst_Datum(ln));
+                                value = Var_Subst(NULL, p1, VAR_GLOBAL, FALSE);
+                        } else {
+                                value = Var_Value((char *)Lst_Datum(ln),
+                                                  VAR_GLOBAL, &p1);
+                        }
+                        printf("%s\n", value ? value : "");
+                        if (p1)
+                                efree(p1);
+                }
+        }
+
+        /*
+         * Have now read the entire graph and need to make a list of targets
+         * to create. If none was given on the command line, we consult the
+         * parsing module to find the main target(s) to create.
+         */
+        if (Lst_IsEmpty(create))
+                targs = Parse_MainName();
+        else
+                targs = Targ_FindList(create, TARG_CREATE);
+
+        if (!compatMake && !printVars) {
+                /*
+                 * Initialize job module before traversing the graph, now that
+                 * any .BEGIN and .END targets have been read.  This is done
+                 * only if the -q flag wasn't given (to prevent the .BEGIN from
+                 * being executed should it exist).
+                 */
+                if (!queryFlag) {
+                        if (maxLocal == -1)
+                                maxLocal = maxJobs;
+                        Job_Init(maxJobs, maxLocal);
+                        jobsRunning = TRUE;
+                }
+
+                /* Traverse the graph, checking on all the targets */
+                outOfDate = Make_Run(targs);
+        } else if (!printVars) {
+                /*
+                 * Compat_Init will take care of creating all the targets as
+                 * well as initializing the module.
+                 */
+                Compat_Run(targs);
+        }
+
+        Lst_Destroy(targs, NOFREE);
+        Lst_Destroy(variables, NOFREE);
+        Lst_Destroy(makefiles, NOFREE);
+        Lst_Destroy(create, (void (*) __P((ClientData))) efree);
+
+        /* print the graph now it's been processed if the user requested it */
+        if (DEBUG(GRAPH2))
+                Targ_PrintGraph(2);
+
+        Suff_End();
         Targ_End();
 #ifdef USE_ARCHIVES
-        Arch_End();
-#endif
-        str_end();
-        Var_End();
-        Parse_End();
-        Dir_End();
-
-        if (queryFlag && outOfDate)
-                return(1);
-        else
-                return(0);
+        Arch_End();
+#endif
+        str_end();
+        Var_End();
+        Parse_End();
+        Dir_End();
+
+        if (queryFlag && outOfDate)
+                return(1);
+        else
+                return(0);
 }
 
 /*-
  * ReadMakefile  --
- *      Open and parse the given makefile.
+ *      Open and parse the given makefile.
  *
  * Results:
- *      TRUE if ok. FALSE if couldn't open file.
+ *      TRUE if ok. FALSE if couldn't open file.
  *
  * Side Effects:
- *      lots
+ *      lots
  */
 static Boolean
 ReadMakefile(p, q)
-        ClientData p, q;
-{
-        char *fname = p;                /* makefile to read */
-        extern Lst parseIncPath;
-        FILE *stream;
-        char *name, path[MAXPATHLEN + 1];
-        char *MAKEFILE;
-        int setMAKEFILE;
-
-        if (!strcmp(fname, "-")) {
-                Parse_File("(stdin)", stdin);
-                Var_Set("MAKEFILE", "", VAR_GLOBAL);
-        } else {
-                setMAKEFILE = strcmp(fname, ".depend");
-
-                /* if we've chdir'd, rebuild the path name */
-                if (curdir != objdir && *fname != '/') {
-                        (void)snprintf(path, MAXPATHLEN, "%s/%s", curdir, fname);
-                        if (realpath(path, path) != NULL &&
-                            (stream = fopen(path, "r")) != NULL) {
-                                MAKEFILE = fname;
-                                fname = path;
-                                goto found;
-                        }
-                } else if (realpath(fname, path) != NULL) {
-                        MAKEFILE = fname;
-                        fname = path;
-                        if ((stream = fopen(fname, "r")) != NULL)
-                                goto found;
-                }
-                /* look in -I and system include directories. */
-                name = Dir_FindFile(fname, parseIncPath);
-                if (!name)
-                        name = Dir_FindFile(fname, sysIncPath);
-                if (!name || !(stream = fopen(name, "r")))
-                        return(FALSE);
-                MAKEFILE = fname = name;
-                /*
-                 * set the MAKEFILE variable desired by System V fans -- the
-                 * placement of the setting here means it gets set to the last
-                 * makefile specified, as it is set by SysV make.
-                 */
+        ClientData p, q;
+{
+        char *fname = p;                /* makefile to read */
+        extern Lst parseIncPath;
+        FILE *stream;
+        char *name, path[MAXPATHLEN + 1];
+        char *MAKEFILE;
+        int setMAKEFILE;
+
+        if (!strcmp(fname, "-")) {
+                Parse_File("(stdin)", stdin);
+                Var_Set("MAKEFILE", "", VAR_GLOBAL);
+        } else {
+                setMAKEFILE = strcmp(fname, ".depend");
+
+                /* if we've chdir'd, rebuild the path name */
+                if (curdir != objdir && *fname != '/') {
+                        (void)snprintf(path, MAXPATHLEN, "%s/%s", curdir, fname);
+                        if (realpath(path, path) != NULL &&
+                            (stream = fopen(path, "r")) != NULL) {
+                                MAKEFILE = fname;
+                                fname = path;
+                                goto found;
+                        }
+                } else if (realpath(fname, path) != NULL) {
+                        MAKEFILE = fname;
+                        fname = path;
+                        if ((stream = fopen(fname, "r")) != NULL)
+                                goto found;
+                }
+                /* look in -I and system include directories. */
+                name = Dir_FindFile(fname, parseIncPath);
+                if (!name)
+                        name = Dir_FindFile(fname, sysIncPath);
+                if (!name || !(stream = fopen(name, "r")))
+                        return(FALSE);
+                MAKEFILE = fname = name;
+                /*
+                 * set the MAKEFILE variable desired by System V fans -- the
+                 * placement of the setting here means it gets set to the last
+                 * makefile specified, as it is set by SysV make.
+                 */
 found:
-                if (setMAKEFILE)
-                        Var_Set("MAKEFILE", MAKEFILE, VAR_GLOBAL);
-                Parse_File(fname, stream);
-                (void)fclose(stream);
-        }
-        return(TRUE);
+                if (setMAKEFILE)
+                        Var_Set("MAKEFILE", MAKEFILE, VAR_GLOBAL);
+                Parse_File(fname, stream);
+                (void)fclose(stream);
+        }
+        return(TRUE);
 }
 
 /*-
  * Cmd_Exec --
- *      Execute the command in cmd, and return the output of that command
- *      in a string.
+ *      Execute the command in cmd, and return the output of that command
+ *      in a string.
  *
  * Results:
- *      A string containing the output of the command, or the empty string
- *      If err is not NULL, it contains the reason for the command failure
+ *      A string containing the output of the command, or the empty string
+ *      If err is not NULL, it contains the reason for the command failure
  *
  * Side Effects:
- *      The string must be freed by the caller.
+ *      The string must be freed by the caller.
  */
 char *
@@ -1136 +1162 @@
     char **err;
 {
-    char        *args[4];       /* Args for invoking the shell */
-    int         fds[2];         /* Pipe streams */
-    int         cpid;           /* Child PID */
-    int         pid;            /* PID from wait() */
-    char        *res;           /* result */
-    int         status;         /* command exit status */
-    Buffer      buf;            /* buffer to store the result */
-    char        *cp;
-    int         cc;
+#ifdef KMK
+    /** @todo this can be executed directly in the shell!!!
+     */
+    int         rc;
+    char *      args[4];                /* Args for invoking the shell */
+    KFILE       fhPipe;                 /* Pipe handle. */
+    KPID        cpid;                   /* Child PID */
+    KPROCRES    status;                 /* Child exit status. */
+    char *      res;                    /* result */
+    Buffer      buf;                    /* buffer to store the result */
+    char *      cp;
+    int         cc;
+
+
+    *err = NULL;
+
+    /*
+     * Set up arguments for shell
+     */
+    args[0] = argv0;
+    args[1] = "--kShell";
+    args[2] = cmd;
+    args[3] = NULL;
+
+
+    /*
+     * Execute command in pipe.
+     */
+    rc = kProcPiped(&args[0],
+                    KPROCPIPED_FLAGS_STDOUT,
+                    &cpid,
+                    &fhPipe);
+    if (!rc)
+    {
+        FILE *phPipe;
+        buf = Buf_Init (MAKE_BSIZE);
+
+        /*
+         * Read the output using a file stream for automatic '\n' newline conv.
+         */
+        phPipe = fdopen(fhPipe, "r");
+        cc = -1;
+        if (phPipe)
+        {
+            do {
+                char   result[BUFSIZ];
+                cc = fread(result, 1, sizeof(result), phPipe);
+                if (cc > 0)
+                    Buf_AddBytes(buf, cc, (Byte *) result);
+            }
+            while (cc > 0 || (cc == -1 && errno == EINTR));
+            fclose(phPipe);
+        }
+
+        /*
+         * Close the input side of the pipe and wait for the child to exit.
+         */
+        kFileClose(fhPipe);
+        rc = kProcWait(cpid, KPROCWAIT_FLAGS_WAIT, &status, NULL);
+
+        /*
+         * Check for errors, get buffered bits.
+         */
+        if (cc == -1)
+            *err = "Error reading shell's output for \"%s\"";
+
+        res = (char *)Buf_GetAll (buf, &cc);
+        Buf_Destroy (buf, FALSE);
+
+        if (status.uExitCode || status.fFlags != KPROCRES_FLAGS_NORMAL)
+            *err = "\"%s\" returned non-zero status";
+
+        /*
+         * Null-terminate the result, convert newlines to spaces and
+         * install it in the variable. Final newline is removed.
+         */
+        res[cc] = '\0';
+        cp = &res[cc] - 1;
+        if (*cp == '\n')
+            *cp-- = '\0';
+
+        while (cp >= res)
+        {
+            if (*cp == '\n')
+                *cp = ' ';
+            cp--;
+        }
+
+        return res;
+    }
+    else
+        *err = "Couldn't exec \"%s\"";
+
+    res = emalloc(1);
+    *res = '\0';
+    return res;
+
+#else  /* not KMK */
+
+    char        *args[4];       /* Args for invoking the shell */
+    int         fds[2];         /* Pipe streams */
+    int         cpid;           /* Child PID */
+    int         pid;            /* PID from wait() */
+    char        *res;           /* result */
+    int         status;         /* command exit status */
+    Buffer      buf;            /* buffer to store the result */
+    char        *cp;
+    int         cc;
 
 
@@ -1161 +1286 @@
      */
     if (pipe(fds) == -1) {
-        *err = "Couldn't create pipe for \"%s\"";
-        goto bad;
+        *err = "Couldn't create pipe for \"%s\"";
+        goto bad;
     }
 
@@ -1169 +1294 @@
      */
 #ifdef __EMX__
-    switch (cpid = fork()) {
-#else
-    switch (cpid = vfork()) {
-#endif
+    switch (cpid = fork())
+#else
+    switch (cpid = vfork())
+#endif
+    {
     case 0:
-        /*
-         * Close input side of pipe
-         */
-        (void) close(fds[0]);
-
-        /*
-         * Duplicate the output stream to the shell's output, then
-         * shut the extra thing down. Note we don't fetch the error
-         * stream...why not? Why?
-         */
-        (void) dup2(fds[1], 1);
-        (void) close(fds[1]);
+        /*
+         * Close input side of pipe
+         */
+        (void) close(fds[0]);
+
+        /*
+         * Duplicate the output stream to the shell's output, then
+         * shut the extra thing down. Note we don't fetch the error
+         * stream...why not? Why?
+         */
+        (void) dup2(fds[1], 1);
+        (void) close(fds[1]);
 
         #ifdef OS2
@@ -1194 +1320 @@
             if (!psz)
                 psz = "c:\\os2\\cmd.exe";
-            (void) execv(psz, args);
+            (void) execv(psz, args);
         }
         #else
-        (void) execv("/bin/sh", args);
+        (void) execv("/bin/sh", args);
         #endif
-        _exit(1);
-        /*NOTREACHED*/
+        _exit(1);
+        /*NOTREACHED*/
 
     case -1:
-        *err = "Couldn't exec \"%s\"";
-        goto bad;
+        *err = "Couldn't exec \"%s\"";
+        goto bad;
 
     default:
-        /*
-         * No need for the writing half
-         */
-        (void) close(fds[1]);
-
-        buf = Buf_Init (MAKE_BSIZE);
-
-        do {
-            char   result[BUFSIZ];
-            cc = read(fds[0], result, sizeof(result));
-            if (cc > 0)
-                Buf_AddBytes(buf, cc, (Byte *) result);
-        }
-        while (cc > 0 || (cc == -1 && errno == EINTR));
-
-        /*
-         * Close the input side of the pipe.
-         */
-        (void) close(fds[0]);
-
-        /*
-         * Wait for the process to exit.
-         */
-        while(((pid = wait(&status)) != cpid) && (pid >= 0))
-            continue;
-
-        if (cc == -1)
-            *err = "Error reading shell's output for \"%s\"";
-
-        res = (char *)Buf_GetAll (buf, &cc);
-        Buf_Destroy (buf, FALSE);
-
-        if (status)
-            *err = "\"%s\" returned non-zero status";
-
-        /*
-         * Null-terminate the result, convert newlines to spaces and
-         * install it in the variable.
-         */
-        res[cc] = '\0';
-        cp = &res[cc] - 1;
-
-        if (*cp == '\n') {
-            /*
-             * A final newline is just stripped
-             */
-            *cp-- = '\0';
-        }
-        while (cp >= res) {
-            if (*cp == '\n') {
-                *cp = ' ';
-            }
-            cp--;
-        }
-        break;
+        /*
+         * No need for the writing half
+         */
+        (void) close(fds[1]);
+
+        buf = Buf_Init (MAKE_BSIZE);
+
+        do {
+            char   result[BUFSIZ];
+            cc = read(fds[0], result, sizeof(result));
+            if (cc > 0)
+                Buf_AddBytes(buf, cc, (Byte *) result);
+        }
+        while (cc > 0 || (cc == -1 && errno == EINTR));
+
+        /*
+         * Close the input side of the pipe.
+         */
+        (void) close(fds[0]);
+
+        /*
+         * Wait for the process to exit.
+         */
+        while(((pid = wait(&status)) != cpid) && (pid >= 0))
+            continue;
+
+        if (cc == -1)
+            *err = "Error reading shell's output for \"%s\"";
+
+        res = (char *)Buf_GetAll (buf, &cc);
+        Buf_Destroy (buf, FALSE);
+
+        if (status)
+            *err = "\"%s\" returned non-zero status";
+
+        /*
+         * Null-terminate the result, convert newlines to spaces and
+         * install it in the variable.
+         */
+        res[cc] = '\0';
+        cp = &res[cc] - 1;
+
+        if (*cp == '\n') {
+            /*
+             * A final newline is just stripped
+             */
+            *cp-- = '\0';
+        }
+        while (cp >= res) {
+            if (*cp == '\n') {
+                *cp = ' ';
+            }
+            cp--;
+        }
+        break;
     }
     return res;
@@ -1268 +1394 @@
     *res = '\0';
     return res;
+#endif /* KMK */
 }
 
 /*-
  * Error --
- *      Print an error message given its format.
+ *      Print an error message given its format.
  *
  * Results:
- *      None.
+ *      None.
  *
  * Side Effects:
- *      The message is printed.
+ *      The message is printed.
  */
 /* VARARGS */
@@ -1286 +1413 @@
 #else
 Error(va_alist)
-        va_dcl
-#endif
-{
-        va_list ap;
+        va_dcl
+#endif
+{
+        va_list ap;
 #if defined(__STDC__) || defined(__IBMC__)
-        va_start(ap, fmt);
-#else
-        char *fmt;
-
-        va_start(ap);
-        fmt = va_arg(ap, char *);
-#endif
-        (void)vfprintf(stderr, fmt, ap);
-        va_end(ap);
-        (void)fprintf(stderr, "\n");
-        (void)fflush(stderr);
+        va_start(ap, fmt);
+#else
+        char *fmt;
+
+        va_start(ap);
+        fmt = va_arg(ap, char *);
+#endif
+        (void)vfprintf(stderr, fmt, ap);
+        va_end(ap);
+        (void)fprintf(stderr, "\n");
+        (void)fflush(stderr);
 }
 
 /*-
  * Fatal --
- *      Produce a Fatal error message. If jobs are running, waits for them
- *      to finish.
+ *      Produce a Fatal error message. If jobs are running, waits for them
+ *      to finish.
  *
  * Results:
- *      None
+ *      None
  *
  * Side Effects:
- *      The program exits
+ *      The program exits
  */
 /* VARARGS */
@@ -1321 +1448 @@
 #else
 Fatal(va_alist)
-        va_dcl
-#endif
-{
-        va_list ap;
+        va_dcl
+#endif
+{
+        va_list ap;
 #if defined(__STDC__) || defined(__IBMC__)
-        va_start(ap, fmt);
-#else
-        char *fmt;
-
-        va_start(ap);
-        fmt = va_arg(ap, char *);
-#endif
-        if (jobsRunning)
-                Job_Wait();
-
-        (void)vfprintf(stderr, fmt, ap);
-        va_end(ap);
-        (void)fprintf(stderr, "\n");
-        (void)fflush(stderr);
-
-        if (DEBUG(GRAPH2))
-                Targ_PrintGraph(2);
-        exit(2);                /* Not 1 so -q can distinguish error */
+        va_start(ap, fmt);
+#else
+        char *fmt;
+
+        va_start(ap);
+        fmt = va_arg(ap, char *);
+#endif
+        if (jobsRunning)
+                Job_Wait();
+
+        (void)vfprintf(stderr, fmt, ap);
+        va_end(ap);
+        (void)fprintf(stderr, "\n");
+        (void)fflush(stderr);
+
+        if (DEBUG(GRAPH2))
+                Targ_PrintGraph(2);
+        exit(2);                /* Not 1 so -q can distinguish error */
 }
 
 /*
  * Punt --
- *      Major exception once jobs are being created. Kills all jobs, prints
- *      a message and exits.
+ *      Major exception once jobs are being created. Kills all jobs, prints
+ *      a message and exits.
  *
  * Results:
- *      None
+ *      None
  *
  * Side Effects:
- *      All children are killed indiscriminately and the program Lib_Exits
+ *      All children are killed indiscriminately and the program Lib_Exits
  */
 /* VARARGS */
@@ -1363 +1490 @@
 #else
 Punt(va_alist)
-        va_dcl
-#endif
-{
-        va_list ap;
+        va_dcl
+#endif
+{
+        va_list ap;
 #if defined(__STDC__) || defined(__IBMC__)
-        va_start(ap, fmt);
-#else
-        char *fmt;
-
-        va_start(ap);
-        fmt = va_arg(ap, char *);
-#endif
-
-        (void)fprintf(stderr, MAKE_NAME ": ");
-        (void)vfprintf(stderr, fmt, ap);
-        va_end(ap);
-        (void)fprintf(stderr, "\n");
-        (void)fflush(stderr);
-
-        DieHorribly();
+        va_start(ap, fmt);
+#else
+        char *fmt;
+
+        va_start(ap);
+        fmt = va_arg(ap, char *);
+#endif
+
+        (void)fprintf(stderr, MAKE_NAME ": ");
+        (void)vfprintf(stderr, fmt, ap);
+        va_end(ap);
+        (void)fprintf(stderr, "\n");
+        (void)fflush(stderr);
+
+        DieHorribly();
 }
 
 /*-
  * DieHorribly --
- *      Exit without giving a message.
+ *      Exit without giving a message.
  *
  * Results:
- *      None
+ *      None
  *
  * Side Effects:
- *      A big one...
+ *      A big one...
  */
 void
 DieHorribly()
 {
-        if (jobsRunning)
-                Job_AbortAll();
-        if (DEBUG(GRAPH2))
-                Targ_PrintGraph(2);
-        exit(2);                /* Not 1, so -q can distinguish error */
+        if (jobsRunning)
+                Job_AbortAll();
+        if (DEBUG(GRAPH2))
+                Targ_PrintGraph(2);
+        exit(2);                /* Not 1, so -q can distinguish error */
 }
 
 /*
  * Finish --
- *      Called when aborting due to errors in child shell to signal
- *      abnormal exit.
+ *      Called when aborting due to errors in child shell to signal
+ *      abnormal exit.
  *
  * Results:
- *      None
+ *      None
  *
  * Side Effects:
- *      The program exits
+ *      The program exits
  */
 void
 Finish(errors)
-        int errors;     /* number of errors encountered in Make_Make */
-{
-        Fatal("%d error%s", errors, errors == 1 ? "" : "s");
+        int errors;     /* number of errors encountered in Make_Make */
+{
+        Fatal("%d error%s", errors, errors == 1 ? "" : "s");
 }
 
 /*
  * emalloc --
- *      malloc, but die on error.
+ *      malloc, but die on error.
  */
 void *
 emalloc(len)
-        size_t len;
-{
-        void *p;
-
-        if ((p = malloc(len)) == NULL)
-                enomem();
-        return(p);
+        size_t len;
+{
+        void *p;
+
+        if ((p = malloc(len)) == NULL)
+                enomem();
+        return(p);
 }
 
 /*
  * estrdup --
- *      strdup, but die on error.
+ *      strdup, but die on error.
  */
 char *
 estrdup(str)
-        const char *str;
-{
-        char *p;
-
-        if ((p = strdup(str)) == NULL)
-                enomem();
-        return(p);
+        const char *str;
+{
+        char *p;
+
+        if ((p = strdup(str)) == NULL)
+                enomem();
+        return(p);
 }
 
 /*
  * erealloc --
- *      realloc, but die on error.
+ *      realloc, but die on error.
  */
 void *
 erealloc(ptr, size)
-        void *ptr;
-        size_t size;
-{
-        if ((ptr = realloc(ptr, size)) == NULL)
-                enomem();
-        return(ptr);
+        void *ptr;
+        size_t size;
+{
+        if ((ptr = realloc(ptr, size)) == NULL)
+                enomem();
+        return(ptr);
 }
 
@@ -1481 +1608 @@
 /*
  * enomem --
- *      die when out of memory.
+ *      die when out of memory.
  */
 void
 enomem()
 {
-        err(2, NULL);
+        err(2, NULL);
 }
 
 /*
  * enunlink --
- *      Remove a file carefully, avoiding directories.
+ *      Remove a file carefully, avoiding directories.
  */
 int
 eunlink(file)
-        const char *file;
-{
-        struct stat st;
-
-#ifdef __EMX__
-        if (stat(file, &st) == -1)
-#else
-        if (lstat(file, &st) == -1)
-#endif
-                return -1;
-
-        if (S_ISDIR(st.st_mode)) {
-                errno = EISDIR;
-                return -1;
-        }
-        return unlink(file);
+        const char *file;
+{
+        struct stat st;
+
+#if defined(OS2)
+        if (stat(file, &st) == -1)
+#else
+        if (lstat(file, &st) == -1)
+#endif
+                return -1;
+
+        if (S_ISDIR(st.st_mode)) {
+                errno = EISDIR;
+                return -1;
+        }
+        return unlink(file);
 }
 
 /*
  * usage --
- *      exit with usage message
+ *      exit with usage message
  */
 static void
 usage()
 {
-        (void)fprintf(stderr, "%s\n%s\n%s\n"
+        (void)fprintf(stderr, "%s\n%s\n%s\n"
 #ifdef NMAKE
 "%s\n"
@@ -1538 +1665 @@
 #endif
 );
-        exit(2);
+        exit(2);
 }
 

trunk/src/kmk/make.c

@@ -1 +1 @@
 /*
  * 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.
@@ -18 +18 @@
  * 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
@@ -39 +39 @@
 #ifndef lint
 #if 0
-static char sccsid[] = "@(#)make.c      8.1 (Berkeley) 6/6/93";
+static char sccsid[] = "@(#)make.c      8.1 (Berkeley) 6/6/93";
 #else
 static const char rcsid[] =
   "$FreeBSD: src/usr.bin/make/make.c,v 1.11 1999/09/11 13:08:01 hoek Exp $";
 #endif
+#define KLIBFILEDEF rcsid
 #endif /* not lint */
 
 /*-
  * make.c --
- *      The functions which perform the examination of targets and
- *      their suitability for creation
+ *      The functions which perform the examination of targets and
+ *      their suitability for creation
  *
  * Interface:
- *      Make_Run                Initialize things for the module and recreate
- *                              whatever needs recreating. Returns TRUE if
- *                              work was (or would have been) done and FALSE
- *                              otherwise.
- *
- *      Make_Update             Update all parents of a given child. Performs
- *                              various bookkeeping chores like the updating
- *                              of the cmtime field of the parent, filling
- *                              of the IMPSRC context variable, etc. It will
- *                              place the parent on the toBeMade queue if it
- *                              should be.
- *
- *      Make_TimeStamp          Function to set the parent's cmtime field
- *                              based on a child's modification time.
- *
- *      Make_DoAllVar           Set up the various local variables for a
- *                              target, including the .ALLSRC variable, making
- *                              sure that any variable that needs to exist
- *                              at the very least has the empty value.
- *
- *      Make_OODate             Determine if a target is out-of-date.
- *
- *      Make_HandleUse          See if a child is a .USE node for a parent
- *                              and perform the .USE actions if so.
+ *      Make_Run                Initialize things for the module and recreate
+ *                              whatever needs recreating. Returns TRUE if
+ *                              work was (or would have been) done and FALSE
+ *                              otherwise.
+ *
+ *      Make_Update             Update all parents of a given child. Performs
+ *                              various bookkeeping chores like the updating
+ *                              of the cmtime field of the parent, filling
+ *                              of the IMPSRC context variable, etc. It will
+ *                              place the parent on the toBeMade queue if it
+ *                              should be.
+ *
+ *      Make_TimeStamp          Function to set the parent's cmtime field
+ *                              based on a child's modification time.
+ *
+ *      Make_DoAllVar           Set up the various local variables for a
+ *                              target, including the .ALLSRC variable, making
+ *                              sure that any variable that needs to exist
+ *                              at the very least has the empty value.
+ *
+ *      Make_OODate             Determine if a target is out-of-date.
+ *
+ *      Make_HandleUse          See if a child is a .USE node for a parent
+ *                              and perform the .USE actions if so.
  */
 
@@ -83 +84 @@
 #include    "job.h"
 
-static Lst      toBeMade;       /* The current fringe of the graph. These
-                                 * are nodes which await examination by
-                                 * MakeOODate. It is added to by
-                                 * Make_Update and subtracted from by
-                                 * MakeStartJobs */
-static int      numNodes;       /* Number of nodes to be processed. If this
-                                 * is non-zero when Job_Empty() returns
-                                 * TRUE, there's a cycle in the graph */
+static Lst      toBeMade;       /* The current fringe of the graph. These
+                                 * are nodes which await examination by
+                                 * MakeOODate. It is added to by
+                                 * Make_Update and subtracted from by
+                                 * MakeStartJobs */
+static int      numNodes;       /* Number of nodes to be processed. If this
+                                 * is non-zero when Job_Empty() returns
+                                 * TRUE, there's a cycle in the graph */
 
 static int MakeAddChild __P((ClientData, ClientData));
@@ -101 +102 @@
  *-----------------------------------------------------------------------
  * Make_TimeStamp --
- *      Set the cmtime field of a parent node based on the mtime stamp in its
- *      child. Called from MakeOODate via Lst_ForEach.
- *
- * Results:
- *      Always returns 0.
- *
- * Side Effects:
- *      The cmtime of the parent node will be changed if the mtime
- *      field of the child is greater than it.
+ *      Set the cmtime field of a parent node based on the mtime stamp in its
+ *      child. Called from MakeOODate via Lst_ForEach.
+ *
+ * Results:
+ *      Always returns 0.
+ *
+ * Side Effects:
+ *      The cmtime of the parent node will be changed if the mtime
+ *      field of the child is greater than it.
  *-----------------------------------------------------------------------
  */
 int
 Make_TimeStamp (pgn, cgn)
-    GNode *pgn; /* the current parent */
-    GNode *cgn; /* the child we've just examined */
+    GNode *pgn; /* the current parent */
+    GNode *cgn; /* the child we've just examined */
 {
     if (cgn->mtime > pgn->cmtime) {
-        pgn->cmtime = cgn->mtime;
+        pgn->cmtime = cgn->mtime;
     }
     return (0);
@@ -125 +126 @@
 static int
 MakeTimeStamp (pgn, cgn)
-    ClientData pgn;     /* the current parent */
-    ClientData cgn;     /* the child we've just examined */
+    ClientData pgn;     /* the current parent */
+    ClientData cgn;     /* the child we've just examined */
 {
     return Make_TimeStamp((GNode *) pgn, (GNode *) cgn);
@@ -135 +136 @@
  *-----------------------------------------------------------------------
  * Make_OODate --
- *      See if a given node is out of date with respect to its sources.
- *      Used by Make_Run when deciding which nodes to place on the
- *      toBeMade queue initially and by Make_Update to screen out USE and
- *      EXEC nodes. In the latter case, however, any other sort of node
- *      must be considered out-of-date since at least one of its children
- *      will have been recreated.
- *
- * Results:
- *      TRUE if the node is out of date. FALSE otherwise.
- *
- * Side Effects:
- *      The mtime field of the node and the cmtime field of its parents
- *      will/may be changed.
+ *      See if a given node is out of date with respect to its sources.
+ *      Used by Make_Run when deciding which nodes to place on the
+ *      toBeMade queue initially and by Make_Update to screen out USE and
+ *      EXEC nodes. In the latter case, however, any other sort of node
+ *      must be considered out-of-date since at least one of its children
+ *      will have been recreated.
+ *
+ * Results:
+ *      TRUE if the node is out of date. FALSE otherwise.
+ *
+ * Side Effects:
+ *      The mtime field of the node and the cmtime field of its parents
+ *      will/may be changed.
  *-----------------------------------------------------------------------
  */
 Boolean
 Make_OODate (gn)
-    register GNode *gn;       /* the node to check */
+    register GNode *gn;       /* the node to check */
 {
     Boolean         oodate;
@@ -161 +162 @@
      */
     if ((gn->type & (OP_JOIN|OP_USE|OP_EXEC)) == 0) {
-        (void) Dir_MTime (gn);
-        if (DEBUG(MAKE)) {
-            if (gn->mtime != 0) {
-                printf ("modified %s...", Targ_FmtTime(gn->mtime));
-            } else {
-                printf ("non-existent...");
-            }
-        }
+        (void) Dir_MTime (gn);
+        if (DEBUG(MAKE)) {
+            if (gn->mtime != 0) {
+                printf ("modified %s...", Targ_FmtTime(gn->mtime));
+            } else {
+                printf ("non-existent...");
+            }
+        }
     }
 
     /*
      * A target is remade in one of the following circumstances:
-     *  its modification time is smaller than that of its youngest child
-     *      and it would actually be run (has commands or type OP_NOP)
-     *  it's the object of a force operator
-     *  it has no children, was on the lhs of an operator and doesn't exist
-     *      already.
+     *  its modification time is smaller than that of its youngest child
+     *      and it would actually be run (has commands or type OP_NOP)
+     *  it's the object of a force operator
+     *  it has no children, was on the lhs of an operator and doesn't exist
+     *      already.
      *
      * Libraries are only considered out-of-date if the archive module says
@@ -186 +187 @@
      */
     if (gn->type & OP_USE) {
-        /*
-         * If the node is a USE node it is *never* out of date
-         * no matter *what*.
-         */
-        if (DEBUG(MAKE)) {
-            printf(".USE node...");
-        }
-        oodate = FALSE;
+        /*
+         * If the node is a USE node it is *never* out of date
+         * no matter *what*.
+         */
+        if (DEBUG(MAKE)) {
+            printf(".USE node...");
+        }
+        oodate = FALSE;
 #ifdef USE_ARCHIVES
     } else if (gn->type & OP_LIB) {
-        if (DEBUG(MAKE)) {
-            printf("library...");
-        }
-
-        /*
-         * always out of date if no children and :: target
-         */
-
-        oodate = Arch_LibOODate (gn) ||
-            ((gn->cmtime == 0) && (gn->type & OP_DOUBLEDEP));
+        if (DEBUG(MAKE)) {
+            printf("library...");
+        }
+
+        /*
+         * always out of date if no children and :: target
+         */
+
+        oodate = Arch_LibOODate (gn) ||
+            ((gn->cmtime == 0) && (gn->type & OP_DOUBLEDEP));
 #endif
     } else if (gn->type & OP_JOIN) {
-        /*
-         * A target with the .JOIN attribute is only considered
-         * out-of-date if any of its children was out-of-date.
-         */
-        if (DEBUG(MAKE)) {
-            printf(".JOIN node...");
-        }
-        oodate = gn->childMade;
+        /*
+         * A target with the .JOIN attribute is only considered
+         * out-of-date if any of its children was out-of-date.
+         */
+        if (DEBUG(MAKE)) {
+            printf(".JOIN node...");
+        }
+        oodate = gn->childMade;
     } else if (gn->type & (OP_FORCE|OP_EXEC|OP_PHONY)) {
-        /*
-         * A node which is the object of the force (!) operator or which has
-         * the .EXEC attribute is always considered out-of-date.
-         */
-        if (DEBUG(MAKE)) {
-            if (gn->type & OP_FORCE) {
-                printf("! operator...");
-            } else if (gn->type & OP_PHONY) {
-                printf(".PHONY node...");
-            } else {
-                printf(".EXEC node...");
-            }
-        }
-        oodate = TRUE;
+        /*
+         * A node which is the object of the force (!) operator or which has
+         * the .EXEC attribute is always considered out-of-date.
+         */
+        if (DEBUG(MAKE)) {
+            if (gn->type & OP_FORCE) {
+                printf("! operator...");
+            } else if (gn->type & OP_PHONY) {
+                printf(".PHONY node...");
+            } else {
+                printf(".EXEC node...");
+            }
+        }
+        oodate = TRUE;
     } else if ((gn->mtime < gn->cmtime) ||
-               ((gn->cmtime == 0) &&
-                ((gn->mtime==0) || (gn->type & OP_DOUBLEDEP))))
+               ((gn->cmtime == 0) &&
+                ((gn->mtime==0) || (gn->type & OP_DOUBLEDEP))))
     {
-        /*
-         * A node whose modification time is less than that of its
-         * youngest child or that has no children (cmtime == 0) and
-         * either doesn't exist (mtime == 0) or was the object of a
-         * :: operator is out-of-date. Why? Because that's the way Make does
-         * it.
-         */
-        if (DEBUG(MAKE)) {
-            if (gn->mtime < gn->cmtime) {
-                printf("modified before source...");
-            } else if (gn->mtime == 0) {
-                printf("non-existent and no sources...");
-            } else {
-                printf(":: operator and no sources...");
-            }
-        }
-        oodate = TRUE;
+        /*
+         * A node whose modification time is less than that of its
+         * youngest child or that has no children (cmtime == 0) and
+         * either doesn't exist (mtime == 0) or was the object of a
+         * :: operator is out-of-date. Why? Because that's the way Make does
+         * it.
+         */
+        if (DEBUG(MAKE)) {
+            if (gn->mtime < gn->cmtime) {
+                printf("modified before source...");
+            } else if (gn->mtime == 0) {
+                printf("non-existent and no sources...");
+            } else {
+                printf(":: operator and no sources...");
+            }
+        }
+        oodate = TRUE;
     } else {
 #if 0
-        /* WHY? */
-        if (DEBUG(MAKE)) {
-            printf("source %smade...", gn->childMade ? "" : "not ");
-        }
-        oodate = gn->childMade;
+        /* WHY? */
+        if (DEBUG(MAKE)) {
+            printf("source %smade...", gn->childMade ? "" : "not ");
+        }
+        oodate = gn->childMade;
 #else
-        oodate = FALSE;
+        oodate = FALSE;
 #endif /* 0 */
     }
@@ -272 +273 @@
      */
     if (!oodate) {
-        Lst_ForEach (gn->parents, MakeTimeStamp, (ClientData)gn);
+        Lst_ForEach (gn->parents, MakeTimeStamp, (ClientData)gn);
     }
 
@@ -282 +283 @@
  *-----------------------------------------------------------------------
  * MakeAddChild  --
- *      Function used by Make_Run to add a child to the list l.
- *      It will only add the child if its make field is FALSE.
- *
- * Results:
- *      Always returns 0
- *
- * Side Effects:
- *      The given list is extended
+ *      Function used by Make_Run to add a child to the list l.
+ *      It will only add the child if its make field is FALSE.
+ *
+ * Results:
+ *      Always returns 0
+ *
+ * Side Effects:
+ *      The given list is extended
  *-----------------------------------------------------------------------
  */
 static int
 MakeAddChild (gnp, lp)
-    ClientData     gnp;         /* the node to add */
-    ClientData     lp;          /* the list to which to add it */
+    ClientData     gnp;         /* the node to add */
+    ClientData     lp;          /* the list to which to add it */
 {
     GNode          *gn = (GNode *) gnp;
@@ -301 +302 @@
 
     if (!gn->make && !(gn->type & OP_USE)) {
-        (void)Lst_EnQueue (l, (ClientData)gn);
+        (void)Lst_EnQueue (l, (ClientData)gn);
     }
     return (0);
@@ -310 +311 @@
  *-----------------------------------------------------------------------
  * Make_HandleUse --
- *      Function called by Make_Run and SuffApplyTransform on the downward
- *      pass to handle .USE and transformation nodes. A callback function
- *      for Lst_ForEach, it implements the .USE and transformation
- *      functionality by copying the node's commands, type flags
- *      and children to the parent node. Should be called before the
- *      children are enqueued to be looked at by MakeAddChild.
- *
- *      A .USE node is much like an explicit transformation rule, except
- *      its commands are always added to the target node, even if the
- *      target already has commands.
- *
- * Results:
- *      returns 0.
- *
- * Side Effects:
- *      Children and commands may be added to the parent and the parent's
- *      type may be changed.
+ *      Function called by Make_Run and SuffApplyTransform on the downward
+ *      pass to handle .USE and transformation nodes. A callback function
+ *      for Lst_ForEach, it implements the .USE and transformation
+ *      functionality by copying the node's commands, type flags
+ *      and children to the parent node. Should be called before the
+ *      children are enqueued to be looked at by MakeAddChild.
+ *
+ *      A .USE node is much like an explicit transformation rule, except
+ *      its commands are always added to the target node, even if the
+ *      target already has commands.
+ *
+ * Results:
+ *      returns 0.
+ *
+ * Side Effects:
+ *      Children and commands may be added to the parent and the parent's
+ *      type may be changed.
  *
  *-----------------------------------------------------------------------
@@ -332 +333 @@
 int
 Make_HandleUse (cgn, pgn)
-    register GNode      *cgn;   /* The .USE node */
-    register GNode      *pgn;   /* The target of the .USE node */
-{
-    register GNode      *gn;    /* A child of the .USE node */
-    register LstNode    ln;     /* An element in the children list */
+    register GNode      *cgn;   /* The .USE node */
+    register GNode      *pgn;   /* The target of the .USE node */
+{
+    register GNode      *gn;    /* A child of the .USE node */
+    register LstNode    ln;     /* An element in the children list */
 
     if (cgn->type & (OP_USE|OP_TRANSFORM)) {
-        if ((cgn->type & OP_USE) || Lst_IsEmpty(pgn->commands)) {
-            /*
-             * .USE or transformation and target has no commands -- append
-             * the child's commands to the parent.
-             */
-            (void) Lst_Concat (pgn->commands, cgn->commands, LST_CONCNEW);
-        }
-
-        if (Lst_Open (cgn->children) == SUCCESS) {
-            while ((ln = Lst_Next (cgn->children)) != NILLNODE) {
-                gn = (GNode *)Lst_Datum (ln);
-
-                if (Lst_Member (pgn->children, gn) == NILLNODE) {
-                    (void) Lst_AtEnd (pgn->children, gn);
-                    (void) Lst_AtEnd (gn->parents, pgn);
-                    pgn->unmade += 1;
-                }
-            }
-            Lst_Close (cgn->children);
-        }
-
-        pgn->type |= cgn->type & ~(OP_OPMASK|OP_USE|OP_TRANSFORM);
-
-        /*
-         * This child node is now "made", so we decrement the count of
-         * unmade children in the parent... We also remove the child
-         * from the parent's list to accurately reflect the number of decent
-         * children the parent has. This is used by Make_Run to decide
-         * whether to queue the parent or examine its children...
-         */
-        if (cgn->type & OP_USE) {
-            pgn->unmade--;
-        }
+        if ((cgn->type & OP_USE) || Lst_IsEmpty(pgn->commands)) {
+            /*
+             * .USE or transformation and target has no commands -- append
+             * the child's commands to the parent.
+             */
+            (void) Lst_Concat (pgn->commands, cgn->commands, LST_CONCNEW);
+        }
+
+        if (Lst_Open (cgn->children) == SUCCESS) {
+            while ((ln = Lst_Next (cgn->children)) != NILLNODE) {
+                gn = (GNode *)Lst_Datum (ln);
+
+                if (Lst_Member (pgn->children, gn) == NILLNODE) {
+                    (void) Lst_AtEnd (pgn->children, gn);
+                    (void) Lst_AtEnd (gn->parents, pgn);
+                    pgn->unmade += 1;
+                }
+            }
+            Lst_Close (cgn->children);
+        }
+
+        pgn->type |= cgn->type & ~(OP_OPMASK|OP_USE|OP_TRANSFORM);
+
+        /*
+         * This child node is now "made", so we decrement the count of
+         * unmade children in the parent... We also remove the child
+         * from the parent's list to accurately reflect the number of decent
+         * children the parent has. This is used by Make_Run to decide
+         * whether to queue the parent or examine its children...
+         */
+        if (cgn->type & OP_USE) {
+            pgn->unmade--;
+        }
     }
     return (0);
@@ -377 +378 @@
 static int
 MakeHandleUse (pgn, cgn)
-    ClientData pgn;     /* the current parent */
-    ClientData cgn;     /* the child we've just examined */
+    ClientData pgn;     /* the current parent */
+    ClientData cgn;     /* the child we've just examined */
 {
     return Make_HandleUse((GNode *) pgn, (GNode *) cgn);
@@ -387 +388 @@
  *-----------------------------------------------------------------------
  * Make_Update  --
- *      Perform update on the parents of a node. Used by JobFinish once
- *      a node has been dealt with and by MakeStartJobs if it finds an
- *      up-to-date node.
- *
- * Results:
- *      Always returns 0
- *
- * Side Effects:
- *      The unmade field of pgn is decremented and pgn may be placed on
- *      the toBeMade queue if this field becomes 0.
- *
- *      If the child was made, the parent's childMade field will be set true
- *      and its cmtime set to now.
- *
- *      If the child wasn't made, the cmtime field of the parent will be
- *      altered if the child's mtime is big enough.
- *
- *      Finally, if the child is the implied source for the parent, the
- *      parent's IMPSRC variable is set appropriately.
+ *      Perform update on the parents of a node. Used by JobFinish once
+ *      a node has been dealt with and by MakeStartJobs if it finds an
+ *      up-to-date node.
+ *
+ * Results:
+ *      Always returns 0
+ *
+ * Side Effects:
+ *      The unmade field of pgn is decremented and pgn may be placed on
+ *      the toBeMade queue if this field becomes 0.
+ *
+ *      If the child was made, the parent's childMade field will be set true
+ *      and its cmtime set to now.
+ *
+ *      If the child wasn't made, the cmtime field of the parent will be
+ *      altered if the child's mtime is big enough.
+ *
+ *      Finally, if the child is the implied source for the parent, the
+ *      parent's IMPSRC variable is set appropriately.
  *
  *-----------------------------------------------------------------------
@@ -411 +412 @@
 void
 Make_Update (cgn)
-    register GNode *cgn;        /* the child node */
-{
-    register GNode      *pgn;   /* the parent node */
-    register char       *cname; /* the child's name */
-    register LstNode    ln;     /* Element in parents and iParents lists */
+    register GNode *cgn;        /* the child node */
+{
+    register GNode      *pgn;   /* the parent node */
+    register char       *cname; /* the child's name */
+    register LstNode    ln;     /* Element in parents and iParents lists */
     char *p1;
 
@@ -428 +429 @@
     if (cgn->made != UPTODATE) {
 #ifndef RECHECK
-        /*
-         * We can't re-stat the thing, but we can at least take care of rules
-         * where a target depends on a source that actually creates the
-         * target, but only if it has changed, e.g.
-         *
-         * parse.h : parse.o
-         *
-         * parse.o : parse.y
-         *      yacc -d parse.y
-         *      cc -c y.tab.c
-         *      mv y.tab.o parse.o
-         *      cmp -s y.tab.h parse.h || mv y.tab.h parse.h
-         *
-         * In this case, if the definitions produced by yacc haven't changed
-         * from before, parse.h won't have been updated and cgn->mtime will
-         * reflect the current modification time for parse.h. This is
-         * something of a kludge, I admit, but it's a useful one..
-         * XXX: People like to use a rule like
-         *
-         * FRC:
-         *
-         * To force things that depend on FRC to be made, so we have to
-         * check for gn->children being empty as well...
-         */
-        if (!Lst_IsEmpty(cgn->commands) || Lst_IsEmpty(cgn->children)) {
-            cgn->mtime = now;
-        }
+        /*
+         * We can't re-stat the thing, but we can at least take care of rules
+         * where a target depends on a source that actually creates the
+         * target, but only if it has changed, e.g.
+         *
+         * parse.h : parse.o
+         *
+         * parse.o : parse.y
+         *      yacc -d parse.y
+         *      cc -c y.tab.c
+         *      mv y.tab.o parse.o
+         *      cmp -s y.tab.h parse.h || mv y.tab.h parse.h
+         *
+         * In this case, if the definitions produced by yacc haven't changed
+         * from before, parse.h won't have been updated and cgn->mtime will
+         * reflect the current modification time for parse.h. This is
+         * something of a kludge, I admit, but it's a useful one..
+         * XXX: People like to use a rule like
+         *
+         * FRC:
+         *
+         * To force things that depend on FRC to be made, so we have to
+         * check for gn->children being empty as well...
+         */
+        if (!Lst_IsEmpty(cgn->commands) || Lst_IsEmpty(cgn->children)) {
+            cgn->mtime = now;
+        }
 #else
-        /*
-         * This is what Make does and it's actually a good thing, as it
-         * allows rules like
-         *
-         *      cmp -s y.tab.h parse.h || cp y.tab.h parse.h
-         *
-         * to function as intended. Unfortunately, thanks to the stateless
-         * nature of NFS (by which I mean the loose coupling of two clients
-         * using the same file from a common server), there are times
-         * when the modification time of a file created on a remote
-         * machine will not be modified before the local stat() implied by
-         * the Dir_MTime occurs, thus leading us to believe that the file
-         * is unchanged, wreaking havoc with files that depend on this one.
-         *
-         * I have decided it is better to make too much than to make too
-         * little, so this stuff is commented out unless you're sure it's ok.
-         * -- ardeb 1/12/88
-         */
-        /*
-         * Christos, 4/9/92: If we are  saving commands pretend that
-         * the target is made now. Otherwise archives with ... rules
-         * don't work!
-         */
-        if (noExecute || (cgn->type & OP_SAVE_CMDS) || Dir_MTime(cgn) == 0) {
-            cgn->mtime = now;
-        }
-        if (DEBUG(MAKE)) {
-            printf("update time: %s\n", Targ_FmtTime(cgn->mtime));
-        }
+        /*
+         * This is what Make does and it's actually a good thing, as it
+         * allows rules like
+         *
+         *      cmp -s y.tab.h parse.h || cp y.tab.h parse.h
+         *
+         * to function as intended. Unfortunately, thanks to the stateless
+         * nature of NFS (by which I mean the loose coupling of two clients
+         * using the same file from a common server), there are times
+         * when the modification time of a file created on a remote
+         * machine will not be modified before the local stat() implied by
+         * the Dir_MTime occurs, thus leading us to believe that the file
+         * is unchanged, wreaking havoc with files that depend on this one.
+         *
+         * I have decided it is better to make too much than to make too
+         * little, so this stuff is commented out unless you're sure it's ok.
+         * -- ardeb 1/12/88
+         */
+        /*
+         * Christos, 4/9/92: If we are  saving commands pretend that
+         * the target is made now. Otherwise archives with ... rules
+         * don't work!
+         */
+        if (noExecute || (cgn->type & OP_SAVE_CMDS) || Dir_MTime(cgn) == 0) {
+            cgn->mtime = now;
+        }
+        if (DEBUG(MAKE)) {
+            printf("update time: %s\n", Targ_FmtTime(cgn->mtime));
+        }
 #endif
     }
 
     if (Lst_Open (cgn->parents) == SUCCESS) {
-        while ((ln = Lst_Next (cgn->parents)) != NILLNODE) {
-            pgn = (GNode *)Lst_Datum (ln);
-            if (pgn->make) {
-                pgn->unmade -= 1;
-
-                if ( ! (cgn->type & (OP_EXEC|OP_USE))) {
-                    if (cgn->made == MADE) {
-                        pgn->childMade = TRUE;
-                        if (pgn->cmtime < cgn->mtime) {
-                            pgn->cmtime = cgn->mtime;
-                        }
-                    } else {
-                        (void)Make_TimeStamp (pgn, cgn);
-                    }
-                }
-                if (pgn->unmade == 0) {
-                    /*
-                     * Queue the node up -- any unmade predecessors will
-                     * be dealt with in MakeStartJobs.
-                     */
-                    (void)Lst_EnQueue (toBeMade, (ClientData)pgn);
-                } else if (pgn->unmade < 0) {
-                    Error ("Graph cycles through %s", pgn->name);
-                }
-            }
-        }
-        Lst_Close (cgn->parents);
+        while ((ln = Lst_Next (cgn->parents)) != NILLNODE) {
+            pgn = (GNode *)Lst_Datum (ln);
+            if (pgn->make) {
+                pgn->unmade -= 1;
+
+                if ( ! (cgn->type & (OP_EXEC|OP_USE))) {
+                    if (cgn->made == MADE) {
+                        pgn->childMade = TRUE;
+                        if (pgn->cmtime < cgn->mtime) {
+                            pgn->cmtime = cgn->mtime;
+                        }
+                    } else {
+                        (void)Make_TimeStamp (pgn, cgn);
+                    }
+                }
+                if (pgn->unmade == 0) {
+                    /*
+                     * Queue the node up -- any unmade predecessors will
+                     * be dealt with in MakeStartJobs.
+                     */
+                    (void)Lst_EnQueue (toBeMade, (ClientData)pgn);
+                } else if (pgn->unmade < 0) {
+                    Error ("Graph cycles through %s", pgn->name);
+                }
+            }
+        }
+        Lst_Close (cgn->parents);
     }
     /*
@@ -524 +525 @@
      */
     for (ln = Lst_First(cgn->successors); ln != NILLNODE; ln = Lst_Succ(ln)) {
-        GNode   *succ = (GNode *)Lst_Datum(ln);
-
-        if (succ->make && succ->unmade == 0 && succ->made == UNMADE &&
-            Lst_Member(toBeMade, (ClientData)succ) == NILLNODE)
-        {
-            (void)Lst_EnQueue(toBeMade, (ClientData)succ);
-        }
+        GNode   *succ = (GNode *)Lst_Datum(ln);
+
+        if (succ->make && succ->unmade == 0 && succ->made == UNMADE &&
+            Lst_Member(toBeMade, (ClientData)succ) == NILLNODE)
+        {
+            (void)Lst_EnQueue(toBeMade, (ClientData)succ);
+        }
     }
 
@@ -538 +539 @@
      */
     if (Lst_Open (cgn->iParents) == SUCCESS) {
-        char    *p1;
-        char    *cpref = Var_Value(PREFIX, cgn, &p1);
-
-        while ((ln = Lst_Next (cgn->iParents)) != NILLNODE) {
-            pgn = (GNode *)Lst_Datum (ln);
-            if (pgn->make) {
-                Var_Set (IMPSRC, cname, pgn);
-                Var_Set (PREFIX, cpref, pgn);
-            }
-        }
-        efree(p1);
-        Lst_Close (cgn->iParents);
+        char    *p1;
+        char    *cpref = Var_Value(PREFIX, cgn, &p1);
+
+        while ((ln = Lst_Next (cgn->iParents)) != NILLNODE) {
+            pgn = (GNode *)Lst_Datum (ln);
+            if (pgn->make) {
+                Var_Set (IMPSRC, cname, pgn);
+                Var_Set (PREFIX, cpref, pgn);
+            }
+        }
+        efree(p1);
+        Lst_Close (cgn->iParents);
     }
 }
@@ -557 +558 @@
  *-----------------------------------------------------------------------
  * MakeAddAllSrc --
- *      Add a child's name to the ALLSRC and OODATE variables of the given
- *      node. Called from Make_DoAllVar via Lst_ForEach. A child is added only
- *      if it has not been given the .EXEC, .USE or .INVISIBLE attributes.
- *      .EXEC and .USE children are very rarely going to be files, so...
- *      A child is added to the OODATE variable if its modification time is
- *      later than that of its parent, as defined by Make, except if the
- *      parent is a .JOIN node. In that case, it is only added to the OODATE
- *      variable if it was actually made (since .JOIN nodes don't have
- *      modification times, the comparison is rather unfair...)..
- *
- * Results:
- *      Always returns 0
- *
- * Side Effects:
- *      The ALLSRC variable for the given node is extended.
+ *      Add a child's name to the ALLSRC and OODATE variables of the given
+ *      node. Called from Make_DoAllVar via Lst_ForEach. A child is added only
+ *      if it has not been given the .EXEC, .USE or .INVISIBLE attributes.
+ *      .EXEC and .USE children are very rarely going to be files, so...
+ *      A child is added to the OODATE variable if its modification time is
+ *      later than that of its parent, as defined by Make, except if the
+ *      parent is a .JOIN node. In that case, it is only added to the OODATE
+ *      variable if it was actually made (since .JOIN nodes don't have
+ *      modification times, the comparison is rather unfair...)..
+ *
+ * Results:
+ *      Always returns 0
+ *
+ * Side Effects:
+ *      The ALLSRC variable for the given node is extended.
  *-----------------------------------------------------------------------
  */
 static int
 MakeAddAllSrc (cgnp, pgnp)
-    ClientData  cgnp;   /* The child to add */
-    ClientData  pgnp;   /* The parent to whose ALLSRC variable it should be */
-                        /* added */
-{
-    GNode       *cgn = (GNode *) cgnp;
-    GNode       *pgn = (GNode *) pgnp;
+    ClientData  cgnp;   /* The child to add */
+    ClientData  pgnp;   /* The parent to whose ALLSRC variable it should be */
+                        /* added */
+{
+    GNode       *cgn = (GNode *) cgnp;
+    GNode       *pgn = (GNode *) pgnp;
     if ((cgn->type & (OP_EXEC|OP_USE|OP_INVISIBLE)) == 0) {
-        char *child;
-        char *p1 = NULL;
-
-        if (OP_NOP(cgn->type)) {
-            /*
-             * this node is only source; use the specific pathname for it
-             */
-            child = cgn->path ? cgn->path : cgn->name;
-        }
-        else
-            child = Var_Value(TARGET, cgn, &p1);
-        Var_Append (ALLSRC, child, pgn);
-        if (pgn->type & OP_JOIN) {
-            if (cgn->made == MADE) {
-                Var_Append(OODATE, child, pgn);
-            }
-        } else if ((pgn->mtime < cgn->mtime) ||
-                   (cgn->mtime >= now && cgn->made == MADE))
-        {
-            /*
-             * It goes in the OODATE variable if the parent is younger than the
-             * child or if the child has been modified more recently than
-             * the start of the make. This is to keep pmake from getting
-             * confused if something else updates the parent after the
-             * make starts (shouldn't happen, I know, but sometimes it
-             * does). In such a case, if we've updated the kid, the parent
-             * is likely to have a modification time later than that of
-             * the kid and anything that relies on the OODATE variable will
-             * be hosed.
-             *
-             * XXX: This will cause all made children to go in the OODATE
-             * variable, even if they're not touched, if RECHECK isn't defined,
-             * since cgn->mtime is set to now in Make_Update. According to
-             * some people, this is good...
-             */
-            Var_Append(OODATE, child, pgn);
-        }
-        efree(p1);
+        char *child;
+        char *p1 = NULL;
+
+        if (OP_NOP(cgn->type)) {
+            /*
+             * this node is only source; use the specific pathname for it
+             */
+            child = cgn->path ? cgn->path : cgn->name;
+        }
+        else
+            child = Var_Value(TARGET, cgn, &p1);
+        Var_Append (ALLSRC, child, pgn);
+        if (pgn->type & OP_JOIN) {
+            if (cgn->made == MADE) {
+                Var_Append(OODATE, child, pgn);
+            }
+        } else if ((pgn->mtime < cgn->mtime) ||
+                   (cgn->mtime >= now && cgn->made == MADE))
+        {
+            /*
+             * It goes in the OODATE variable if the parent is younger than the
+             * child or if the child has been modified more recently than
+             * the start of the make. This is to keep pmake from getting
+             * confused if something else updates the parent after the
+             * make starts (shouldn't happen, I know, but sometimes it
+             * does). In such a case, if we've updated the kid, the parent
+             * is likely to have a modification time later than that of
+             * the kid and anything that relies on the OODATE variable will
+             * be hosed.
+             *
+             * XXX: This will cause all made children to go in the OODATE
+             * variable, even if they're not touched, if RECHECK isn't defined,
+             * since cgn->mtime is set to now in Make_Update. According to
+             * some people, this is good...
+             */
+            Var_Append(OODATE, child, pgn);
+        }
+        efree(p1);
     }
     return (0);
@@ -632 +633 @@
  *
  * Results:
- *      Always returns 0
- *
- * Side Effects:
- *      The PARENTS variable for the given node is extended.
+ *      Always returns 0
+ *
+ * Side Effects:
+ *      The PARENTS variable for the given node is extended.
  *-----------------------------------------------------------------------
  */
 static int
 MakeAddParents (pgnp, cgnp)
-    ClientData  pgnp;   /* The parent to add to add */
-    ClientData  cgnp;   /* The child to whose PARENTS variable it should be */
-{
-    GNode       *pgn = (GNode *) pgnp;
-    GNode       *cgn = (GNode *) cgnp;
+    ClientData  pgnp;   /* The parent to add to add */
+    ClientData  cgnp;   /* The child to whose PARENTS variable it should be */
+{
+    GNode       *pgn = (GNode *) pgnp;
+    GNode       *cgn = (GNode *) cgnp;
     if ((pgn->type & (OP_EXEC|OP_USE|OP_INVISIBLE)) == 0) {
-        char *parent;
-        char *p1 = NULL;
-
-
-        if (OP_NOP(pgn->type) || !(parent = Var_Value(TARGET, pgn, &p1))) {
-            /* this node is only source; use the specific pathname for it */
-            parent = pgn->path ? pgn->path : pgn->name;
-        }
-        Var_Append(PARENTS, parent, cgn);
-        efree(p1);
+        char *parent;
+        char *p1 = NULL;
+
+
+        if (OP_NOP(pgn->type) || !(parent = Var_Value(TARGET, pgn, &p1))) {
+            /* this node is only source; use the specific pathname for it */
+            parent = pgn->path ? pgn->path : pgn->name;
+        }
+        Var_Append(PARENTS, parent, cgn);
+        efree(p1);
     }
     return (0);
@@ -665 +666 @@
  *-----------------------------------------------------------------------
  * Make_DoAllVar --
- *      Set up the ALLSRC and OODATE variables. Sad to say, it must be
- *      done separately, rather than while traversing the graph. This is
- *      because Make defined OODATE to contain all sources whose modification
- *      times were later than that of the target, *not* those sources that
- *      were out-of-date. Since in both compatibility and native modes,
- *      the modification time of the parent isn't found until the child
- *      has been dealt with, we have to wait until now to fill in the
- *      variable. As for ALLSRC, the ordering is important and not
- *      guaranteed when in native mode, so it must be set here, too.
- *
- * Results:
- *      None
- *
- * Side Effects:
- *      The ALLSRC and OODATE variables of the given node is filled in.
- *      If the node is a .JOIN node, its TARGET variable will be set to
- *      match its ALLSRC variable.
+ *      Set up the ALLSRC and OODATE variables. Sad to say, it must be
+ *      done separately, rather than while traversing the graph. This is
+ *      because Make defined OODATE to contain all sources whose modification
+ *      times were later than that of the target, *not* those sources that
+ *      were out-of-date. Since in both compatibility and native modes,
+ *      the modification time of the parent isn't found until the child
+ *      has been dealt with, we have to wait until now to fill in the
+ *      variable. As for ALLSRC, the ordering is important and not
+ *      guaranteed when in native mode, so it must be set here, too.
+ *
+ * Results:
+ *      None
+ *
+ * Side Effects:
+ *      The ALLSRC and OODATE variables of the given node is filled in.
+ *      If the node is a .JOIN node, its TARGET variable will be set to
+ *      match its ALLSRC variable.
  *-----------------------------------------------------------------------
  */
 void
 Make_DoAllVar (gn)
-    GNode       *gn;
+    GNode       *gn;
 {
     Lst_ForEach (gn->children, MakeAddAllSrc, (ClientData) gn);
@@ -694 +695 @@
 
     if (!Var_Exists (OODATE, gn)) {
-        Var_Set (OODATE, "", gn);
+        Var_Set (OODATE, "", gn);
     }
     if (!Var_Exists (ALLSRC, gn)) {
-        Var_Set (ALLSRC, "", gn);
+        Var_Set (ALLSRC, "", gn);
     }
 
     if (gn->type & OP_JOIN) {
-        char *p1;
-        Var_Set (TARGET, Var_Value (ALLSRC, gn, &p1), gn);
-        efree(p1);
+        char *p1;
+        Var_Set (TARGET, Var_Value (ALLSRC, gn, &p1), gn);
+        efree(p1);
     }
 }
@@ -711 +712 @@
  *-----------------------------------------------------------------------
  * MakeStartJobs --
- *      Start as many jobs as possible.
- *
- * Results:
- *      If the query flag was given to pmake, no job will be started,
- *      but as soon as an out-of-date target is found, this function
- *      returns TRUE. At all other times, this function returns FALSE.
- *
- * Side Effects:
- *      Nodes are removed from the toBeMade queue and job table slots
- *      are filled.
+ *      Start as many jobs as possible.
+ *
+ * Results:
+ *      If the query flag was given to pmake, no job will be started,
+ *      but as soon as an out-of-date target is found, this function
+ *      returns TRUE. At all other times, this function returns FALSE.
+ *
+ * Side Effects:
+ *      Nodes are removed from the toBeMade queue and job table slots
+ *      are filled.
  *
  *-----------------------------------------------------------------------
@@ -727 +728 @@
 MakeStartJobs ()
 {
-    register GNode      *gn;
+    register GNode      *gn;
 
     while (!Job_Full() && !Lst_IsEmpty (toBeMade)) {
-        gn = (GNode *) Lst_DeQueue (toBeMade);
-        if (DEBUG(MAKE)) {
-            printf ("Examining %s...", gn->name);
-        }
-        /*
-         * Make sure any and all predecessors that are going to be made,
-         * have been.
-         */
-        if (!Lst_IsEmpty(gn->preds)) {
-            LstNode ln;
-
-            for (ln = Lst_First(gn->preds); ln != NILLNODE; ln = Lst_Succ(ln)){
-                GNode   *pgn = (GNode *)Lst_Datum(ln);
-
-                if (pgn->make && pgn->made == UNMADE) {
-                    if (DEBUG(MAKE)) {
-                        printf("predecessor %s not made yet.\n", pgn->name);
-                    }
-                    break;
-                }
-            }
-            /*
-             * If ln isn't nil, there's a predecessor as yet unmade, so we
-             * just drop this node on the floor. When the node in question
-             * has been made, it will notice this node as being ready to
-             * make but as yet unmade and will place the node on the queue.
-             */
-            if (ln != NILLNODE) {
-                continue;
-            }
-        }
-
-        numNodes--;
-        if (Make_OODate (gn)) {
-            if (DEBUG(MAKE)) {
-                printf ("out-of-date\n");
-            }
-            if (queryFlag) {
-                return (TRUE);
-            }
-            Make_DoAllVar (gn);
-            Job_Make (gn);
-        } else {
-            if (DEBUG(MAKE)) {
-                printf ("up-to-date\n");
-            }
-            gn->made = UPTODATE;
-            if (gn->type & OP_JOIN) {
-                /*
-                 * Even for an up-to-date .JOIN node, we need it to have its
-                 * context variables so references to it get the correct
-                 * value for .TARGET when building up the context variables
-                 * of its parent(s)...
-                 */
-                Make_DoAllVar (gn);
-            }
-
-            Make_Update (gn);
-        }
+        gn = (GNode *) Lst_DeQueue (toBeMade);
+        if (DEBUG(MAKE)) {
+            printf ("Examining %s...", gn->name);
+        }
+        /*
+         * Make sure any and all predecessors that are going to be made,
+         * have been.
+         */
+        if (!Lst_IsEmpty(gn->preds)) {
+            LstNode ln;
+
+            for (ln = Lst_First(gn->preds); ln != NILLNODE; ln = Lst_Succ(ln)){
+                GNode   *pgn = (GNode *)Lst_Datum(ln);
+
+                if (pgn->make && pgn->made == UNMADE) {
+                    if (DEBUG(MAKE)) {
+                        printf("predecessor %s not made yet.\n", pgn->name);
+                    }
+                    break;
+                }
+            }
+            /*
+             * If ln isn't nil, there's a predecessor as yet unmade, so we
+             * just drop this node on the floor. When the node in question
+             * has been made, it will notice this node as being ready to
+             * make but as yet unmade and will place the node on the queue.
+             */
+            if (ln != NILLNODE) {
+                continue;
+            }
+        }
+
+        numNodes--;
+        if (Make_OODate (gn)) {
+            if (DEBUG(MAKE)) {
+                printf ("out-of-date\n");
+            }
+            if (queryFlag) {
+                return (TRUE);
+            }
+            Make_DoAllVar (gn);
+            Job_Make (gn);
+        } else {
+            if (DEBUG(MAKE)) {
+                printf ("up-to-date\n");
+            }
+            gn->made = UPTODATE;
+            if (gn->type & OP_JOIN) {
+                /*
+                 * Even for an up-to-date .JOIN node, we need it to have its
+                 * context variables so references to it get the correct
+                 * value for .TARGET when building up the context variables
+                 * of its parent(s)...
+                 */
+                Make_DoAllVar (gn);
+            }
+
+            Make_Update (gn);
+        }
     }
     return (FALSE);
@@ -797 +798 @@
  *-----------------------------------------------------------------------
  * MakePrintStatus --
- *      Print the status of a top-level node, viz. it being up-to-date
- *      already or not created due to an error in a lower level.
- *      Callback function for Make_Run via Lst_ForEach.
- *
- * Results:
- *      Always returns 0.
- *
- * Side Effects:
- *      A message may be printed.
+ *      Print the status of a top-level node, viz. it being up-to-date
+ *      already or not created due to an error in a lower level.
+ *      Callback function for Make_Run via Lst_ForEach.
+ *
+ * Results:
+ *      Always returns 0.
+ *
+ * Side Effects:
+ *      A message may be printed.
  *
  *-----------------------------------------------------------------------
@@ -811 +812 @@
 static int
 MakePrintStatus(gnp, cyclep)
-    ClientData  gnp;        /* Node to examine */
-    ClientData  cyclep;     /* True if gn->unmade being non-zero implies
-                             * a cycle in the graph, not an error in an
-                             * inferior */
-{
-    GNode       *gn = (GNode *) gnp;
-    Boolean     cycle = *(Boolean *) cyclep;
+    ClientData  gnp;        /* Node to examine */
+    ClientData  cyclep;     /* True if gn->unmade being non-zero implies
+                             * a cycle in the graph, not an error in an
+                             * inferior */
+{
+    GNode       *gn = (GNode *) gnp;
+    Boolean     cycle = *(Boolean *) cyclep;
     if (gn->made == UPTODATE) {
-        printf ("`%s' is up to date.\n", gn->name);
+        printf ("`%s' is up to date.\n", gn->name);
     } else if (gn->unmade != 0) {
-        if (cycle) {
-            Boolean t = TRUE;
-            /*
-             * If printing cycles and came to one that has unmade children,
-             * print out the cycle by recursing on its children. Note a
-             * cycle like:
-             *  a : b
-             *  b : c
-             *  c : b
-             * will cause this to erroneously complain about a being in
-             * the cycle, but this is a good approximation.
-             */
-            if (gn->made == CYCLE) {
-                Error("Graph cycles through `%s'", gn->name);
-                gn->made = ENDCYCLE;
-                Lst_ForEach(gn->children, MakePrintStatus, (ClientData) &t);
-                gn->made = UNMADE;
-            } else if (gn->made != ENDCYCLE) {
-                gn->made = CYCLE;
-                Lst_ForEach(gn->children, MakePrintStatus, (ClientData) &t);
-            }
-        } else {
-            printf ("`%s' not remade because of errors.\n", gn->name);
-        }
+        if (cycle) {
+            Boolean t = TRUE;
+            /*
+             * If printing cycles and came to one that has unmade children,
+             * print out the cycle by recursing on its children. Note a
+             * cycle like:
+             *  a : b
+             *  b : c
+             *  c : b
+             * will cause this to erroneously complain about a being in
+             * the cycle, but this is a good approximation.
+             */
+            if (gn->made == CYCLE) {
+                Error("Graph cycles through `%s'", gn->name);
+                gn->made = ENDCYCLE;
+                Lst_ForEach(gn->children, MakePrintStatus, (ClientData) &t);
+                gn->made = UNMADE;
+            } else if (gn->made != ENDCYCLE) {
+                gn->made = CYCLE;
+                Lst_ForEach(gn->children, MakePrintStatus, (ClientData) &t);
+            }
+        } else {
+            printf ("`%s' not remade because of errors.\n", gn->name);
+        }
     }
     return (0);
@@ -853 +854 @@
  *-----------------------------------------------------------------------
  * Make_Run --
- *      Initialize the nodes to remake and the list of nodes which are
- *      ready to be made by doing a breadth-first traversal of the graph
- *      starting from the nodes in the given list. Once this traversal
- *      is finished, all the 'leaves' of the graph are in the toBeMade
- *      queue.
- *      Using this queue and the Job module, work back up the graph,
- *      calling on MakeStartJobs to keep the job table as full as
- *      possible.
- *
- * Results:
- *      TRUE if work was done. FALSE otherwise.
- *
- * Side Effects:
- *      The make field of all nodes involved in the creation of the given
- *      targets is set to 1. The toBeMade list is set to contain all the
- *      'leaves' of these subgraphs.
+ *      Initialize the nodes to remake and the list of nodes which are
+ *      ready to be made by doing a breadth-first traversal of the graph
+ *      starting from the nodes in the given list. Once this traversal
+ *      is finished, all the 'leaves' of the graph are in the toBeMade
+ *      queue.
+ *      Using this queue and the Job module, work back up the graph,
+ *      calling on MakeStartJobs to keep the job table as full as
+ *      possible.
+ *
+ * Results:
+ *      TRUE if work was done. FALSE otherwise.
+ *
+ * Side Effects:
+ *      The make field of all nodes involved in the creation of the given
+ *      targets is set to 1. The toBeMade list is set to contain all the
+ *      'leaves' of these subgraphs.
  *-----------------------------------------------------------------------
  */
 Boolean
 Make_Run (targs)
-    Lst             targs;      /* the initial list of targets */
-{
-    register GNode  *gn;        /* a temporary pointer */
-    register Lst    examine;    /* List of targets to examine */
-    int             errors;     /* Number of errors the Job module reports */
+    Lst             targs;      /* the initial list of targets */
+{
+    register GNode  *gn;        /* a temporary pointer */
+    register Lst    examine;    /* List of targets to examine */
+    int             errors;     /* Number of errors the Job module reports */
 
     toBeMade = Lst_Init (FALSE);
@@ -893 +894 @@
      */
     while (!Lst_IsEmpty (examine)) {
-        gn = (GNode *) Lst_DeQueue (examine);
-
-        if (!gn->make) {
-            gn->make = TRUE;
-            numNodes++;
-
-            /*
-             * Apply any .USE rules before looking for implicit dependencies
-             * to make sure everything has commands that should...
-             */
-            Lst_ForEach (gn->children, MakeHandleUse, (ClientData)gn);
-            Suff_FindDeps (gn);
-
-            if (gn->unmade != 0) {
-                Lst_ForEach (gn->children, MakeAddChild, (ClientData)examine);
-            } else {
-                (void)Lst_EnQueue (toBeMade, (ClientData)gn);
-            }
-        }
+        gn = (GNode *) Lst_DeQueue (examine);
+
+        if (!gn->make) {
+            gn->make = TRUE;
+            numNodes++;
+
+            /*
+             * Apply any .USE rules before looking for implicit dependencies
+             * to make sure everything has commands that should...
+             */
+            Lst_ForEach (gn->children, MakeHandleUse, (ClientData)gn);
+            Suff_FindDeps (gn);
+
+            if (gn->unmade != 0) {
+                Lst_ForEach (gn->children, MakeAddChild, (ClientData)examine);
+            } else {
+                (void)Lst_EnQueue (toBeMade, (ClientData)gn);
+            }
+        }
     }
 
@@ -917 +918 @@
 
     if (queryFlag) {
-        /*
-         * We wouldn't do any work unless we could start some jobs in the
-         * next loop... (we won't actually start any, of course, this is just
-         * to see if any of the targets was out of date)
-         */
-        return (MakeStartJobs());
+        /*
+         * We wouldn't do any work unless we could start some jobs in the
+         * next loop... (we won't actually start any, of course, this is just
+         * to see if any of the targets was out of date)
+         */
+        return (MakeStartJobs());
     } else {
-        /*
-         * Initialization. At the moment, no jobs are running and until some
-         * get started, nothing will happen since the remaining upward
-         * traversal of the graph is performed by the routines in job.c upon
-         * the finishing of a job. So we fill the Job table as much as we can
-         * before going into our loop.
-         */
-        (void) MakeStartJobs();
+        /*
+         * Initialization. At the moment, no jobs are running and until some
+         * get started, nothing will happen since the remaining upward
+         * traversal of the graph is performed by the routines in job.c upon
+         * the finishing of a job. So we fill the Job table as much as we can
+         * before going into our loop.
+         */
+        (void) MakeStartJobs();
     }
 
@@ -945 +946 @@
      */
     while (!Job_Empty ()) {
-        Job_CatchOutput ();
-        Job_CatchChildren (!usePipes);
-        (void)MakeStartJobs();
+        Job_CatchOutput ();
+        Job_CatchChildren (!usePipes);
+        (void)MakeStartJobs();
     }
 

trunk/src/kmk/make.h

@@ -1 +1 @@
 /*
  * 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.
@@ -18 +18 @@
  * 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
@@ -36 +36 @@
  * SUCH DAMAGE.
  *
- *      from: @(#)make.h        8.3 (Berkeley) 6/13/95
+ *      from: @(#)make.h        8.3 (Berkeley) 6/13/95
  * $FreeBSD: src/usr.bin/make/make.h,v 1.12.2.2 2001/02/13 03:13:58 will Exp $
  */
@@ -42 +42 @@
 /*-
  * make.h --
- *      The global definitions for pmake
+ *      The global definitions for pmake
  */
 
@@ -60 +60 @@
 /*kso: #  if defined(__STDC__) || defined(__cplusplus) */
 #  if defined(__STDC__) || defined(__cplusplus) || defined(__IBMC__)
-#   define      __P(protos)     protos          /* full-blown ANSI C */
+#   define      __P(protos)     protos          /* full-blown ANSI C */
 #  else
-#   define      __P(protos)     ()              /* traditional C preprocessor */
+#   define      __P(protos)     ()              /* traditional C preprocessor */
 #  endif
 # endif
@@ -76 +76 @@
 #endif
 
-#if defined(__IBMC__)
-#include <stdlib.h>
-#include <time.h>
-/*#ifdef __STDC__*/
-#elif defined(__STDC__)
+#if defined(__STDC__) || defined(__IBMC__)
 #include <stdlib.h>
 #include <unistd.h>
@@ -93 +89 @@
  * The structure for an individual graph node. Each node has several
  * pieces of data associated with it.
- *      1) the name of the target it describes
- *      2) the location of the target file in the file system.
- *      3) the type of operator used to define its sources (qv. parse.c)
- *      4) whether it is involved in this invocation of make
- *      5) whether the target has been remade
- *      6) whether any of its children has been remade
- *      7) the number of its children that are, as yet, unmade
- *      8) its modification time
- *      9) the modification time of its youngest child (qv. make.c)
- *      10) a list of nodes for which this is a source
- *      11) a list of nodes on which this depends
- *      12) a list of nodes that depend on this, as gleaned from the
- *          transformation rules.
- *      13) a list of nodes of the same name created by the :: operator
- *      14) a list of nodes that must be made (if they're made) before
- *          this node can be, but that do no enter into the datedness of
- *          this node.
- *      15) a list of nodes that must be made (if they're made) after
- *          this node is, but that do not depend on this node, in the
- *          normal sense.
- *      16) a Lst of ``local'' variables that are specific to this target
- *         and this target only (qv. var.c [$@ $< $?, etc.])
- *      17) a Lst of strings that are commands to be given to a shell
- *         to create this target.
+ *      1) the name of the target it describes
+ *      2) the location of the target file in the file system.
+ *      3) the type of operator used to define its sources (qv. parse.c)
+ *      4) whether it is involved in this invocation of make
+ *      5) whether the target has been remade
+ *      6) whether any of its children has been remade
+ *      7) the number of its children that are, as yet, unmade
+ *      8) its modification time
+ *      9) the modification time of its youngest child (qv. make.c)
+ *      10) a list of nodes for which this is a source
+ *      11) a list of nodes on which this depends
+ *      12) a list of nodes that depend on this, as gleaned from the
+ *          transformation rules.
+ *      13) a list of nodes of the same name created by the :: operator
+ *      14) a list of nodes that must be made (if they're made) before
+ *          this node can be, but that do no enter into the datedness of
+ *          this node.
+ *      15) a list of nodes that must be made (if they're made) after
+ *          this node is, but that do not depend on this node, in the
+ *          normal sense.
+ *      16) a Lst of ``local'' variables that are specific to this target
+ *         and this target only (qv. var.c [$@ $< $?, etc.])
+ *      17) a Lst of strings that are commands to be given to a shell
+ *         to create this target.
  */
 typedef struct GNode {
-    char            *name;      /* The target's name */
-    char            *path;      /* The full pathname of the file */
-    int             type;       /* Its type (see the OP flags, below) */
-    int             order;      /* Its wait weight */
-
-    Boolean         make;       /* TRUE if this target needs to be remade */
+    char            *name;      /* The target's name */
+    char            *path;      /* The full pathname of the file */
+    int             type;       /* Its type (see the OP flags, below) */
+    int             order;      /* Its wait weight */
+
+    Boolean         make;       /* TRUE if this target needs to be remade */
     enum {
-        UNMADE, BEINGMADE, MADE, UPTODATE, ERROR, ABORTED,
-        CYCLE, ENDCYCLE
-    }               made;       /* Set to reflect the state of processing
-                                 * on this node:
-                                 *  UNMADE - Not examined yet
-                                 *  BEINGMADE - Target is already being made.
-                                 *      Indicates a cycle in the graph. (compat
-                                 *      mode only)
-                                 *  MADE - Was out-of-date and has been made
-                                 *  UPTODATE - Was already up-to-date
-                                 *  ERROR - An error occured while it was being
-                                 *      made (used only in compat mode)
-                                 *  ABORTED - The target was aborted due to
-                                 *      an error making an inferior (compat).
-                                 *  CYCLE - Marked as potentially being part of
-                                 *      a graph cycle. If we come back to a
-                                 *      node marked this way, it is printed
-                                 *      and 'made' is changed to ENDCYCLE.
-                                 *  ENDCYCLE - the cycle has been completely
-                                 *      printed. Go back and unmark all its
-                                 *      members.
-                                 */
-    Boolean         childMade;  /* TRUE if one of this target's children was
-                                 * made */
-    int             unmade;     /* The number of unmade children */
-
-    int             mtime;      /* Its modification time */
-    int             cmtime;     /* The modification time of its youngest
-                                 * child */
-
-    Lst             iParents;   /* Links to parents for which this is an
-                                 * implied source, if any */
-    Lst             cohorts;    /* Other nodes for the :: operator */
-    Lst             parents;    /* Nodes that depend on this one */
-    Lst             children;   /* Nodes on which this one depends */
-    Lst             successors; /* Nodes that must be made after this one */
-    Lst             preds;      /* Nodes that must be made before this one */
-
-    Lst             context;    /* The local variables */
-    Lst             commands;   /* Creation commands */
-
-    struct _Suff    *suffix;    /* Suffix for the node (determined by
-                                 * Suff_FindDeps and opaque to everyone
-                                 * but the Suff module) */
+        UNMADE, BEINGMADE, MADE, UPTODATE, ERROR, ABORTED,
+        CYCLE, ENDCYCLE
+    }               made;       /* Set to reflect the state of processing
+                                 * on this node:
+                                 *  UNMADE - Not examined yet
+                                 *  BEINGMADE - Target is already being made.
+                                 *      Indicates a cycle in the graph. (compat
+                                 *      mode only)
+                                 *  MADE - Was out-of-date and has been made
+                                 *  UPTODATE - Was already up-to-date
+                                 *  ERROR - An error occured while it was being
+                                 *      made (used only in compat mode)
+                                 *  ABORTED - The target was aborted due to
+                                 *      an error making an inferior (compat).
+                                 *  CYCLE - Marked as potentially being part of
+                                 *      a graph cycle. If we come back to a
+                                 *      node marked this way, it is printed
+                                 *      and 'made' is changed to ENDCYCLE.
+                                 *  ENDCYCLE - the cycle has been completely
+                                 *      printed. Go back and unmark all its
+                                 *      members.
+                                 */
+    Boolean         childMade;  /* TRUE if one of this target's children was
+                                 * made */
+    int             unmade;     /* The number of unmade children */
+
+    int             mtime;      /* Its modification time */
+    int             cmtime;     /* The modification time of its youngest
+                                 * child */
+
+    Lst             iParents;   /* Links to parents for which this is an
+                                 * implied source, if any */
+    Lst             cohorts;    /* Other nodes for the :: operator */
+    Lst             parents;    /* Nodes that depend on this one */
+    Lst             children;   /* Nodes on which this one depends */
+    Lst             successors; /* Nodes that must be made after this one */
+    Lst             preds;      /* Nodes that must be made before this one */
+
+    Lst             context;    /* The local variables */
+    Lst             commands;   /* Creation commands */
+
+    struct _Suff    *suffix;    /* Suffix for the node (determined by
+                                 * Suff_FindDeps and opaque to everyone
+                                 * but the Suff module) */
 } GNode;
 
@@ -175 +171 @@
  * Manifest constants
  */
-#define NILGNODE        ((GNode *) NIL)
+#define NILGNODE        ((GNode *) NIL)
 
 /*
@@ -186 +182 @@
  * righthand side...
  */
-#define OP_DEPENDS      0x00000001  /* Execution of commands depends on
-                                     * kids (:) */
-#define OP_FORCE        0x00000002  /* Always execute commands (!) */
-#define OP_DOUBLEDEP    0x00000004  /* Execution of commands depends on kids
-                                     * per line (::) */
-#define OP_OPMASK       (OP_DEPENDS|OP_FORCE|OP_DOUBLEDEP)
-
-#define OP_OPTIONAL     0x00000008  /* Don't care if the target doesn't
-                                     * exist and can't be created */
-#define OP_USE          0x00000010  /* Use associated commands for parents */
-#define OP_EXEC         0x00000020  /* Target is never out of date, but always
-                                     * execute commands anyway. Its time
-                                     * doesn't matter, so it has none...sort
-                                     * of */
-#define OP_IGNORE       0x00000040  /* Ignore errors when creating the node */
-#define OP_PRECIOUS     0x00000080  /* Don't remove the target when
-                                     * interrupted */
-#define OP_SILENT       0x00000100  /* Don't echo commands when executed */
-#define OP_MAKE         0x00000200  /* Target is a recurrsive make so its
-                                     * commands should always be executed when
-                                     * it is out of date, regardless of the
-                                     * state of the -n or -t flags */
-#define OP_JOIN         0x00000400  /* Target is out-of-date only if any of its
-                                     * children was out-of-date */
-#define OP_INVISIBLE    0x00004000  /* The node is invisible to its parents.
-                                     * I.e. it doesn't show up in the parents's
-                                     * local variables. */
-#define OP_NOTMAIN      0x00008000  /* The node is exempt from normal 'main
-                                     * target' processing in parse.c */
-#define OP_PHONY        0x00010000  /* Not a file target; run always */
+#define OP_DEPENDS      0x00000001  /* Execution of commands depends on
+                                     * kids (:) */
+#define OP_FORCE        0x00000002  /* Always execute commands (!) */
+#define OP_DOUBLEDEP    0x00000004  /* Execution of commands depends on kids
+                                     * per line (::) */
+#define OP_OPMASK       (OP_DEPENDS|OP_FORCE|OP_DOUBLEDEP)
+
+#define OP_OPTIONAL     0x00000008  /* Don't care if the target doesn't
+                                     * exist and can't be created */
+#define OP_USE          0x00000010  /* Use associated commands for parents */
+#define OP_EXEC         0x00000020  /* Target is never out of date, but always
+                                     * execute commands anyway. Its time
+                                     * doesn't matter, so it has none...sort
+                                     * of */
+#define OP_IGNORE       0x00000040  /* Ignore errors when creating the node */
+#define OP_PRECIOUS     0x00000080  /* Don't remove the target when
+                                     * interrupted */
+#define OP_SILENT       0x00000100  /* Don't echo commands when executed */
+#define OP_MAKE         0x00000200  /* Target is a recurrsive make so its
+                                     * commands should always be executed when
+                                     * it is out of date, regardless of the
+                                     * state of the -n or -t flags */
+#define OP_JOIN         0x00000400  /* Target is out-of-date only if any of its
+                                     * children was out-of-date */
+#define OP_INVISIBLE    0x00004000  /* The node is invisible to its parents.
+                                     * I.e. it doesn't show up in the parents's
+                                     * local variables. */
+#define OP_NOTMAIN      0x00008000  /* The node is exempt from normal 'main
+                                     * target' processing in parse.c */
+#define OP_PHONY        0x00010000  /* Not a file target; run always */
 /* Attributes applied by PMake */
-#define OP_TRANSFORM    0x80000000  /* The node is a transformation rule */
+#define OP_TRANSFORM    0x80000000  /* The node is a transformation rule */
 #ifdef USE_ARCHIVES
-#define OP_MEMBER       0x40000000  /* Target is a member of an archive */
-#define OP_LIB          0x20000000  /* Target is a library */
-#define OP_ARCHV        0x10000000  /* Target is an archive construct */
-#endif
-#define OP_HAS_COMMANDS 0x08000000  /* Target has all the commands it should.
-                                     * Used when parsing to catch multiple
-                                     * commands for a target */
-#define OP_SAVE_CMDS    0x04000000  /* Saving commands on .END (Compat) */
-#define OP_DEPS_FOUND   0x02000000  /* Already processed by Suff_FindDeps */
+#define OP_MEMBER       0x40000000  /* Target is a member of an archive */
+#define OP_LIB          0x20000000  /* Target is a library */
+#define OP_ARCHV        0x10000000  /* Target is an archive construct */
+#endif
+#define OP_HAS_COMMANDS 0x08000000  /* Target has all the commands it should.
+                                     * Used when parsing to catch multiple
+                                     * commands for a target */
+#define OP_SAVE_CMDS    0x04000000  /* Saving commands on .END (Compat) */
+#define OP_DEPS_FOUND   0x02000000  /* Already processed by Suff_FindDeps */
 
 /*
@@ -233 +229 @@
  * object of a dependency operator
  */
-#define OP_NOP(t)       (((t) & OP_OPMASK) == 0x00000000)
+#define OP_NOP(t)       (((t) & OP_OPMASK) == 0x00000000)
 
 /*
@@ -243 +239 @@
  * a NIL pointer will be returned.
  */
-#define TARG_CREATE     0x01      /* create node if not found */
-#define TARG_NOCREATE   0x00      /* don't create it */
+#define TARG_CREATE     0x01      /* create node if not found */
+#define TARG_NOCREATE   0x00      /* don't create it */
 
 /*
@@ -255 +251 @@
  * schemes allocate in powers of two.
  */
-#define MAKE_BSIZE              256     /* starting size for expandable buffers */
+#define MAKE_BSIZE              256     /* starting size for expandable buffers */
 
 /*
@@ -266 +262 @@
  * Str_Concat returns.
  */
-#define STR_ADDSPACE    0x01    /* add a space when Str_Concat'ing */
-#define STR_DOFREE      0x02    /* free source strings after concatenation */
-#define STR_ADDSLASH    0x04    /* add a slash when Str_Concat'ing */
+#define STR_ADDSPACE    0x01    /* add a space when Str_Concat'ing */
+#define STR_DOFREE      0x02    /* free source strings after concatenation */
+#define STR_ADDSLASH    0x04    /* add a slash when Str_Concat'ing */
 
 /*
@@ -275 +271 @@
  * as the first argument to Parse_Error.
  */
-#define PARSE_WARNING   2
-#define PARSE_FATAL     1
+#define PARSE_WARNING   2
+#define PARSE_FATAL     1
 
 /*
  * Values returned by Cond_Eval.
  */
-#define COND_PARSE      0       /* Parse the next lines */
-#define COND_SKIP       1       /* Skip the next lines */
-#define COND_INVALID    2       /* Not a conditional statement */
+#define COND_PARSE      0       /* Parse the next lines */
+#define COND_SKIP       1       /* Skip the next lines */
+#define COND_INVALID    2       /* Not a conditional statement */
 
 /*
  * Definitions for the "local" variables. Used only for clarity.
  */
-#define TARGET            "@"   /* Target of dependency */
-#define OODATE            "?"   /* All out-of-date sources */
-#define ALLSRC            ">"   /* All sources */
-#define IMPSRC            "<"   /* Source implied by transformation */
-#define PREFIX            "*"   /* Common prefix */
+#define TARGET            "@"   /* Target of dependency */
+#define OODATE            "?"   /* All out-of-date sources */
+#define ALLSRC            ">"   /* All sources */
+#define IMPSRC            "<"   /* Source implied by transformation */
+#define PREFIX            "*"   /* Common prefix */
 #ifdef KMK
 #define PARENTS           "^"   /* Parent of this target (if any) (long name .PARENTS) */
 #endif
 #ifdef USE_ARCHIVES
-#define ARCHIVE           "!"   /* Archive in "archive(member)" syntax */
-#define MEMBER            "%"   /* Member in "archive(member)" syntax */
+#define ARCHIVE           "!"   /* Archive in "archive(member)" syntax */
+#define MEMBER            "%"   /* Member in "archive(member)" syntax */
 #endif
 
@@ -311 +307 @@
  * Global Variables
  */
-extern Lst      create;         /* The list of target names specified on the
-                                 * command line. used to resolve #if
-                                 * make(...) statements */
-extern Lst      dirSearchPath;  /* The list of directories to search when
-                                 * looking for targets */
-
-extern Boolean  compatMake;     /* True if we are make compatible */
-extern Boolean  ignoreErrors;   /* True if should ignore all errors */
-extern Boolean  beSilent;       /* True if should print no commands */
-extern Boolean  beVerbose;      /* True if should print extra cruft */
-extern Boolean  noExecute;      /* True if should execute nothing */
-extern Boolean  allPrecious;    /* True if every target is precious */
-extern Boolean  keepgoing;      /* True if should continue on unaffected
-                                 * portions of the graph when have an error
-                                 * in one portion */
-extern Boolean  touchFlag;      /* TRUE if targets should just be 'touched'
-                                 * if out of date. Set by the -t flag */
-extern Boolean  usePipes;       /* TRUE if should capture the output of
-                                 * subshells by means of pipes. Otherwise it
-                                 * is routed to temporary files from which it
-                                 * is retrieved when the shell exits */
-extern Boolean  queryFlag;      /* TRUE if we aren't supposed to really make
-                                 * anything, just see if the targets are out-
-                                 * of-date */
-
-extern Boolean  checkEnvFirst;  /* TRUE if environment should be searched for
-                                 * all variables before the global context */
-extern Lst      envFirstVars;   /* List of specific variables for which the
-                                 * environment should be searched before the
-                                 * global context */
-
-extern GNode    *DEFAULT;       /* .DEFAULT rule */
-
-extern GNode    *VAR_GLOBAL;    /* Variables defined in a global context, e.g
-                                 * in the Makefile itself */
-extern GNode    *VAR_CMD;       /* Variables defined on the command line */
-extern char     var_Error[];    /* Value returned by Var_Parse when an error
-                                 * is encountered. It actually points to
-                                 * an empty string, so naive callers needn't
-                                 * worry about it. */
-
-extern time_t   now;            /* The time at the start of this whole
-                                 * process */
-
-extern Boolean  oldVars;        /* Do old-style variable substitution */
-
-extern Lst      sysIncPath;     /* The system include path. */
+extern Lst      create;         /* The list of target names specified on the
+                                 * command line. used to resolve #if
+                                 * make(...) statements */
+extern Lst      dirSearchPath;  /* The list of directories to search when
+                                 * looking for targets */
+
+extern Boolean  compatMake;     /* True if we are make compatible */
+extern Boolean  ignoreErrors;   /* True if should ignore all errors */
+extern Boolean  beSilent;       /* True if should print no commands */
+extern Boolean  beVerbose;      /* True if should print extra cruft */
+extern Boolean  noExecute;      /* True if should execute nothing */
+extern Boolean  allPrecious;    /* True if every target is precious */
+extern Boolean  keepgoing;      /* True if should continue on unaffected
+                                 * portions of the graph when have an error
+                                 * in one portion */
+extern Boolean  touchFlag;      /* TRUE if targets should just be 'touched'
+                                 * if out of date. Set by the -t flag */
+extern Boolean  usePipes;       /* TRUE if should capture the output of
+                                 * subshells by means of pipes. Otherwise it
+                                 * is routed to temporary files from which it
+                                 * is retrieved when the shell exits */
+extern Boolean  queryFlag;      /* TRUE if we aren't supposed to really make
+                                 * anything, just see if the targets are out-
+                                 * of-date */
+
+extern Boolean  checkEnvFirst;  /* TRUE if environment should be searched for
+                                 * all variables before the global context */
+extern Lst      envFirstVars;   /* List of specific variables for which the
+                                 * environment should be searched before the
+                                 * global context */
+
+extern GNode    *DEFAULT;       /* .DEFAULT rule */
+
+extern GNode    *VAR_GLOBAL;    /* Variables defined in a global context, e.g
+                                 * in the Makefile itself */
+extern GNode    *VAR_CMD;       /* Variables defined on the command line */
+extern char     var_Error[];    /* Value returned by Var_Parse when an error
+                                 * is encountered. It actually points to
+                                 * an empty string, so naive callers needn't
+                                 * worry about it. */
+
+extern time_t   now;            /* The time at the start of this whole
+                                 * process */
+
+extern Boolean  oldVars;        /* Do old-style variable substitution */
+
+extern Lst      sysIncPath;     /* The system include path. */
 
 /*
  * debug control:
- *      There is one bit per module.  It is up to the module what debug
- *      information to print.
+ *      There is one bit per module.  It is up to the module what debug
+ *      information to print.
  */
 extern int debug;
 #ifdef USE_ARCHIVES
-#define DEBUG_ARCH      0x0001
-#endif
-#define DEBUG_COND      0x0002
-#define DEBUG_DIR       0x0004
-#define DEBUG_GRAPH1    0x0008
-#define DEBUG_GRAPH2    0x0010
-#define DEBUG_JOB       0x0020
-#define DEBUG_MAKE      0x0040
-#define DEBUG_SUFF      0x0080
-#define DEBUG_TARG      0x0100
-#define DEBUG_VAR       0x0200
-#define DEBUG_FOR       0x0400
-#define DEBUG_LOUD      0x0800
+#define DEBUG_ARCH      0x0001
+#endif
+#define DEBUG_COND      0x0002
+#define DEBUG_DIR       0x0004
+#define DEBUG_GRAPH1    0x0008
+#define DEBUG_GRAPH2    0x0010
+#define DEBUG_JOB       0x0020
+#define DEBUG_MAKE      0x0040
+#define DEBUG_SUFF      0x0080
+#define DEBUG_TARG      0x0100
+#define DEBUG_VAR       0x0200
+#define DEBUG_FOR       0x0400
+#define DEBUG_LOUD      0x0800
 #define DEBUG_PARSE     0x8000 /*kso*/
 
 /*#ifdef __STDC__*/
 #if defined(__STDC__) || defined(__IBMC__)
-#define CONCAT(a,b)     a##b
+#define CONCAT(a,b)     a##b
 #else
-#define I(a)            a
-#define CONCAT(a,b)     I(a)b
+#define I(a)            a
+#define CONCAT(a,b)     I(a)b
 #endif /* __STDC__ */
 
 
 
-#define DEBUG(module)   (debug & CONCAT(DEBUG_,module))
+#define DEBUG(module)   (debug & CONCAT(DEBUG_,module))
 #define ISDOT(c) ((c)[0] == '.' && (((c)[1] == '\0') || ((c)[1] == '/')))
 #define ISDOTDOT(c) ((c)[0] == '.' && ISDOT(&((c)[1])))

trunk/src/kmk/nonints.h

@@ -1 +1 @@
 /*-
  * 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.
@@ -18 +18 @@
  * 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
@@ -36 +36 @@
  * SUCH DAMAGE.
  *
- *      from: @(#)nonints.h     8.3 (Berkeley) 3/19/94
+ *      from: @(#)nonints.h     8.3 (Berkeley) 3/19/94
  * $FreeBSD: src/usr.bin/make/nonints.h,v 1.8 1999/08/28 01:03:35 peter Exp $
  */
+
+#ifndef __nonints_h__
+#define __nonints_h__
 
 /* arch.c */
@@ -149 +152 @@
 void Var_End __P((void));
 void Var_Dump __P((GNode *));
+
+#endif

trunk/src/kmk/parse.c

@@ -1 +1 @@
 /*
  * 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.
@@ -18 +18 @@
  * 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
@@ -39 +39 @@
 #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
@@ -109 +110 @@
  * 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.*/
@@ -123 +124 @@
 } 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 */
 
 /*-
@@ -156 +157 @@
  */
 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;
 
@@ -195 +196 @@
  * seen, then set to each successive source on the line.
  */
-static GNode    *predecessor;
+static GNode    *predecessor;
 
 /*
@@ -205 +206 @@
  */
 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 },
 };
 
@@ -277 +278 @@
  *----------------------------------------------------------------------
  * 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;
 
@@ -299 +300 @@
 
     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);
@@ -315 +316 @@
 /*-
  * 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 */
@@ -331 +332 @@
 #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;
 }
 
@@ -360 +361 @@
  *---------------------------------------------------------------------
  * 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);
@@ -393 +394 @@
  *---------------------------------------------------------------------
  * 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;
@@ -420 +421 @@
      */
     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;
     }
     /*
@@ -471 +472 @@
  *---------------------------------------------------------------------
  * 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.
  *
  *---------------------------------------------------------------------
@@ -493 +494 @@
 
     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;
 }
 
@@ -510 +511 @@
  *---------------------------------------------------------------------
  * 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;
     }
 
@@ -618 +619 @@
     (void)Lst_AtEnd(allsrc, (ClientData)gn);
     if (waiting) {
-        Lst_ForEach(allsrc, ParseAddDep, (ClientData)gn);
+        Lst_ForEach(allsrc, ParseAddDep, (ClientData)gn);
     }
 }
@@ -625 +626 @@
  *-----------------------------------------------------------------------
  * 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.
  *
  *-----------------------------------------------------------------------
@@ -639 +640 @@
 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);
     }
 }
@@ -655 +656 @@
  *-----------------------------------------------------------------------
  * 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.
  *
  *-----------------------------------------------------------------------
@@ -667 +668 @@
 static int
 ParseAddDir(path, name)
-    ClientData    path;
+    ClientData    path;
     ClientData    name;
 {
@@ -677 +678 @@
  *-----------------------------------------------------------------------
  * 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
  *
  *-----------------------------------------------------------------------
@@ -699 +700 @@
  *---------------------------------------------------------------------
  * 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
@@ -732 +733 @@
 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;
@@ -759 +760 @@
 
     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);
 
@@ -1002 +1003 @@
 
     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;
+        }
     }
 
@@ -1027 +1028 @@
      */
     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);
@@ -1048 +1049 @@
      */
     while (*cp && isspace (*cp)) {
-        cp++;
+        cp++;
     }
     line = cp;
@@ -1055 +1056 @@
      * 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
@@ -1099 +1100 @@
         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';
     }
 
@@ -1113 +1114 @@
      */
     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);
     }
 
@@ -1259 +1260 @@
  *---------------------------------------------------------------------
  * 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) == '!'))
 
     /*
@@ -1286 +1287 @@
      */
     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;
@@ -1357 +1358 @@
  *---------------------------------------------------------------------
  * 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
@@ -1399 +1400 @@
      */
     while ((*line == ' ') || (*line == '\t')) {
-        line++;
+        line++;
     }
 
@@ -1406 +1407 @@
      */
     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 = */
 
     /*
@@ -1417 +1418 @@
      */
     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);
     }
 }
@@ -1523 +1524 @@
 /*-
  * 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);
 }
@@ -1548 +1549 @@
 /*-
  * 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;
@@ -1585 +1586 @@
  *
  * 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.
  *
  *-----------------------------------------------------------------------
@@ -1641 +1642 @@
  *-----------------------------------------------------------------------
  * 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.
  *
  *-----------------------------------------------------------------------
@@ -1656 +1657 @@
 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;
     }
 }
@@ -1667 +1668 @@
  *-----------------------------------------------------------------------
  * 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.
  *
  *-----------------------------------------------------------------------
@@ -1680 +1681 @@
 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);
@@ -1687 +1688 @@
 /*---------------------------------------------------------------------
  * 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.
  *
  *---------------------------------------------------------------------
@@ -1697 +1698 @@
 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);
 }
 
@@ -1717 +1718 @@
  *---------------------------------------------------------------------
  * 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 */
 
     /*
@@ -1747 +1748 @@
      */
     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
@@ -1764 +1765 @@
      */
     if (*file == '<') {
-        isSystem = TRUE;
-        endc = '>';
+        isSystem = TRUE;
+        endc = '>';
     } else {
-        isSystem = FALSE;
+        isSystem = FALSE;
         #ifdef NMAKE
         if (*file == '"')
-            endc = '"';
+            endc = '"';
         else
         {
@@ -1777 +1778 @@
         }
         #else
-        endc = '"';
+        endc = '"';
         #endif
     }
@@ -1785 +1786 @@
      */
     for (cp = ++file; *cp && *cp != endc; cp++) {
-        continue;
+        continue;
     }
 
@@ -1793 +1794 @@
     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';
@@ -1812 +1813 @@
      */
     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;
     }
 
@@ -1904 +1905 @@
     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);
     }
 }
@@ -1917 +1918 @@
  *---------------------------------------------------------------------
  * 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
  *---------------------------------------------------------------------
  */
@@ -1931 +1932 @@
     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));
@@ -1956 +1957 @@
  *---------------------------------------------------------------------
  * 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;
 
     /*
@@ -1982 +1983 @@
      */
     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;
     }
 
@@ -1995 +1996 @@
      */
     for (cp = file; *cp && *cp != '\n' && *cp != '\t' && *cp != ' '; cp++) {
-        continue;
+        continue;
     }
 
@@ -2019 +2020 @@
     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;
     }
 
@@ -2087 +2088 @@
     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);
     }
 }
@@ -2099 +2100 @@
  *---------------------------------------------------------------------
  * 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.
  *---------------------------------------------------------------------
  */
@@ -2115 +2116 @@
     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);
     }
 
@@ -2126 +2127 @@
     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;
@@ -2140 +2141 @@
  *---------------------------------------------------------------------
  * 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:
@@ -2152 +2153 @@
 {
     if (curFILE)
-        return fgetc(curFILE);
+        return fgetc(curFILE);
 
     if (curPTR && *curPTR->ptr)
-        return *curPTR->ptr++;
+        return *curPTR->ptr++;
     return EOF;
 }
@@ -2163 +2164 @@
  *---------------------------------------------------------------------
  * ParseUnreadc  --
- *      Put back a character to the current file
+ *      Put back a character to the current file
  *
  * Results:
- *      None.
+ *      None.
  *
  * Side Effects:
@@ -2176 +2177 @@
 {
     if (curFILE) {
-        ungetc(c, curFILE);
-        return;
+        ungetc(c, curFILE);
+        return;
     }
     if (curPTR) {
-        *--(curPTR->ptr) = c;
-        return;
+        *--(curPTR->ptr) = c;
+        return;
     }
 }
@@ -2187 +2188 @@
 
 /* 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;
@@ -2242 +2243 @@
  *---------------------------------------------------------------------
  * 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
  *---------------------------------------------------------------------
  */
@@ -2259 +2260 @@
 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;
@@ -2287 +2288 @@
      */
     for (;;) {
-        c = ParseReadc();
+        c = ParseReadc();
         #ifdef USE_INLINEFILES
         if (inInlineFile)
@@ -2293 +2294 @@
         #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. */
@@ -2336 +2337 @@
                 }
                 #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)
@@ -2411 +2412 @@
                 #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
       }
@@ -2513 +2514 @@
 
 #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);
     }
 }
@@ -2575 +2576 @@
  *-----------------------------------------------------------------------
  * 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.
  *
  *-----------------------------------------------------------------------
@@ -2589 +2590 @@
 {
     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;
     }
 }
@@ -2600 +2601 @@
  *---------------------------------------------------------------------
  * 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;
@@ -2630 +2631 @@
 
     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
@@ -2705 +2706 @@
                     /*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, "<<"))
@@ -2736 +2737 @@
                         }
                         #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);
 
@@ -2843 +2844 @@
 
     if (fatals)
-        errx(1, "fatal errors encountered -- cannot continue");
+        errx(1, "fatal errors encountered -- cannot continue");
 }
 
@@ -2849 +2850 @@
  *---------------------------------------------------------------------
  * 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...
  *---------------------------------------------------------------------
  */
@@ -2873 +2874 @@
     /*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 */
 }
 
@@ -2883 +2884 @@
  *-----------------------------------------------------------------------
  * 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.
  *
  *-----------------------------------------------------------------------
@@ -2897 +2898 @@
 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);
 }

trunk/src/kmk/str.c

@@ -1 +1 @@
 /*-
  * 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.
@@ -18 +18 @@
  * 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
@@ -39 +39 @@
 #ifndef lint
 #if 0
-static char sccsid[] = "@(#)str.c       5.8 (Berkeley) 6/1/90";
+static char sccsid[] = "@(#)str.c       5.8 (Berkeley) 6/1/90";
 #else
 static const char rcsid[] =
   "$FreeBSD: src/usr.bin/make/str.c,v 1.12.2.1 2002/06/17 04:30:48 jmallett Exp $";
 #endif
+#define KLIBFILEDEF rcsid
 #endif /* not lint */
 
@@ -53 +54 @@
 /*
  * str_init --
- *      Initialize the strings package
+ *      Initialize the strings package
  *
  */
@@ -67 +68 @@
 /*
  * str_end --
- *      Cleanup the strings package
+ *      Cleanup the strings package
  *
  */
@@ -74 +75 @@
 {
     if (argv) {
-        if (argv[0])
-            efree(argv[0]);
-        efree((Address) argv);
+        if (argv[0])
+            efree(argv[0]);
+        efree((Address) argv);
     }
     if (buffer)
-        efree(buffer);
+        efree(buffer);
 }
 
 /*-
  * str_concat --
- *      concatenate the two strings, inserting a space or slash between them,
- *      freeing them if requested.
+ *      concatenate the two strings, inserting a space or slash between them,
+ *      freeing them if requested.
  *
  * returns --
- *      the resulting string in allocated space.
+ *      the resulting string in allocated space.
  */
 char *
 str_concat(s1, s2, flags)
-        char *s1, *s2;
-        int flags;
-{
-        register int len1, len2;
-        register char *result;
-
-        /* get the length of both strings */
-        len1 = strlen(s1);
-        len2 = strlen(s2);
-
-        /* allocate length plus separator plus EOS */
-        result = emalloc((u_int)(len1 + len2 + 2));
-
-        /* copy first string into place */
-        memcpy(result, s1, len1);
-
-        /* add separator character */
-        if (flags & STR_ADDSPACE) {
-                result[len1] = ' ';
-                ++len1;
-        } else if (flags & STR_ADDSLASH) {
-                result[len1] = '/';
-                ++len1;
-        }
-
-        /* copy second string plus EOS into place */
-        memcpy(result + len1, s2, len2 + 1);
-
-        /* efree original strings */
-        if (flags & STR_DOFREE) {
-                (void)efree(s1);
-                (void)efree(s2);
-        }
-        return(result);
+        char *s1, *s2;
+        int flags;
+{
+        register int len1, len2;
+        register char *result;
+
+        /* get the length of both strings */
+        len1 = strlen(s1);
+        len2 = strlen(s2);
+
+        /* allocate length plus separator plus EOS */
+        result = emalloc((u_int)(len1 + len2 + 2));
+
+        /* copy first string into place */
+        memcpy(result, s1, len1);
+
+        /* add separator character */
+        if (flags & STR_ADDSPACE) {
+                result[len1] = ' ';
+                ++len1;
+        } else if (flags & STR_ADDSLASH) {
+                result[len1] = '/';
+                ++len1;
+        }
+
+        /* copy second string plus EOS into place */
+        memcpy(result + len1, s2, len2 + 1);
+
+        /* efree original strings */
+        if (flags & STR_DOFREE) {
+                (void)efree(s1);
+                (void)efree(s2);
+        }
+        return(result);
 }
 
 /*-
  * brk_string --
- *      Fracture a string into an array of words (as delineated by tabs or
- *      spaces) taking quotation marks into account.  Leading tabs/spaces
- *      are ignored.
+ *      Fracture a string into an array of words (as delineated by tabs or
+ *      spaces) taking quotation marks into account.  Leading tabs/spaces
+ *      are ignored.
  *
  * returns --
- *      Pointer to the array of pointers to the words.  To make life easier,
- *      the first word is always the value of the .MAKE variable.
+ *      Pointer to the array of pointers to the words.  To make life easier,
+ *      the first word is always the value of the .MAKE variable.
  */
 char **
 brk_string(str, store_argc, expand)
-        register char *str;
-        int *store_argc;
-        Boolean expand;
-{
-        register int argc, ch;
-        register char inquote, *p, *start, *t;
-        int len;
-
-        /* skip leading space chars. */
-        for (; *str == ' ' || *str == '\t'; ++str)
-                continue;
-
-        /* allocate room for a copy of the string */
-        if ((len = strlen(str) + 1) > curlen) {
-                if (buffer)
-                    efree(buffer);
-                buffer = emalloc(curlen = len);
-        }
-
-        /*
-         * copy the string; at the same time, parse backslashes,
-         * quotes and build the argument list.
-         */
-        argc = 1;
-        inquote = '\0';
-        for (p = str, start = t = buffer;; ++p) {
-                switch(ch = *p) {
-                case '"':
-                case '\'':
-                        if (inquote) {
-                                if (inquote == ch)
-                                        inquote = '\0';
-                                else
-                                        break;
-                        } else {
-                                inquote = (char) ch;
-                                /* Don't miss "" or '' */
-                                if (start == NULL && p[1] == inquote) {
-                                        start = t + 1;
-                                        break;
-                                }
-                        }
-                        if (!expand) {
-                                if (!start)
-                                        start = t;
-                                *t++ = ch;
-                        }
-                        continue;
-                case ' ':
-                case '\t':
-                case '\n':
-                        if (inquote)
-                                break;
-                        if (!start)
-                                continue;
-                        /* FALLTHROUGH */
-                case '\0':
-                        /*
-                         * end of a token -- make sure there's enough argv
-                         * space and save off a pointer.
-                         */
-                        if (!start)
-                            goto done;
-
-                        *t++ = '\0';
-                        if (argc == argmax) {
-                                argmax *= 2;            /* ramp up fast */
-                                argv = (char **)erealloc(argv,
-                                    (argmax + 1) * sizeof(char *));
-                        }
-                        argv[argc++] = start;
-                        start = (char *)NULL;
-                        if (ch == '\n' || ch == '\0')
-                                goto done;
-                        continue;
-                case '\\':
-                        if (!expand) {
-                                if (!start)
-                                        start = t;
-                                *t++ = '\\';
-                                ch = *++p;
-                                break;
-                        }
-
-                        switch (ch = *++p) {
-                        case '\0':
-                        case '\n':
-                                /* hmmm; fix it up as best we can */
-                                ch = '\\';
-                                --p;
-                                break;
-                        case 'b':
-                                ch = '\b';
-                                break;
-                        case 'f':
-                                ch = '\f';
-                                break;
-                        case 'n':
-                                ch = '\n';
-                                break;
-                        case 'r':
-                                ch = '\r';
-                                break;
-                        case 't':
-                                ch = '\t';
-                                break;
-                        }
-                        break;
-                }
-                if (!start)
-                        start = t;
-                *t++ = (char) ch;
-        }
-done:   argv[argc] = (char *)NULL;
-        *store_argc = argc;
-        return(argv);
+        register char *str;
+        int *store_argc;
+        Boolean expand;
+{
+        register int argc, ch;
+        register char inquote, *p, *start, *t;
+        int len;
+
+        /* skip leading space chars. */
+        for (; *str == ' ' || *str == '\t'; ++str)
+                continue;
+
+        /* allocate room for a copy of the string */
+        if ((len = strlen(str) + 1) > curlen) {
+                if (buffer)
+                    efree(buffer);
+                buffer = emalloc(curlen = len);
+        }
+
+        /*
+         * copy the string; at the same time, parse backslashes,
+         * quotes and build the argument list.
+         */
+        argc = 1;
+        inquote = '\0';
+        for (p = str, start = t = buffer;; ++p) {
+                switch(ch = *p) {
+                case '"':
+                case '\'':
+                        if (inquote) {
+                                if (inquote == ch)
+                                        inquote = '\0';
+                                else
+                                        break;
+                        } else {
+                                inquote = (char) ch;
+                                /* Don't miss "" or '' */
+                                if (start == NULL && p[1] == inquote) {
+                                        start = t + 1;
+                                        break;
+                                }
+                        }
+                        if (!expand) {
+                                if (!start)
+                                        start = t;
+                                *t++ = ch;
+                        }
+                        continue;
+                case ' ':
+                case '\t':
+                case '\n':
+                        if (inquote)
+                                break;
+                        if (!start)
+                                continue;
+                        /* FALLTHROUGH */
+                case '\0':
+                        /*
+                         * end of a token -- make sure there's enough argv
+                         * space and save off a pointer.
+                         */
+                        if (!start)
+                            goto done;
+
+                        *t++ = '\0';
+                        if (argc == argmax) {
+                                argmax *= 2;            /* ramp up fast */
+                                argv = (char **)erealloc(argv,
+                                    (argmax + 1) * sizeof(char *));
+                        }
+                        argv[argc++] = start;
+                        start = (char *)NULL;
+                        if (ch == '\n' || ch == '\0')
+                                goto done;
+                        continue;
+                case '\\':
+                        if (!expand) {
+                                if (!start)
+                                        start = t;
+                                *t++ = '\\';
+                                ch = *++p;
+                                break;
+                        }
+
+                        switch (ch = *++p) {
+                        case '\0':
+                        case '\n':
+                                /* hmmm; fix it up as best we can */
+                                ch = '\\';
+                                --p;
+                                break;
+                        case 'b':
+                                ch = '\b';
+                                break;
+                        case 'f':
+                                ch = '\f';
+                                break;
+                        case 'n':
+                                ch = '\n';
+                                break;
+                        case 'r':
+                                ch = '\r';
+                                break;
+                        case 't':
+                                ch = '\t';
+                                break;
+                        }
+                        break;
+                }
+                if (!start)
+                        start = t;
+                *t++ = (char) ch;
+        }
+done:   argv[argc] = (char *)NULL;
+        *store_argc = argc;
+        return(argv);
 }
 
@@ -270 +271 @@
 char *
 Str_FindSubstring(string, substring)
-        register char *string;          /* String to search. */
-        char *substring;                /* Substring to find in string */
-{
-        register char *a, *b;
-
-        /*
-         * First scan quickly through the two strings looking for a single-
-         * character match.  When it's found, then compare the rest of the
-         * substring.
-         */
-
-        for (b = substring; *string != 0; string += 1) {
-                if (*string != *b)
-                        continue;
-                a = string;
-                for (;;) {
-                        if (*b == 0)
-                                return(string);
-                        if (*a++ != *b++)
-                                break;
-                }
-                b = substring;
-        }
-        return((char *) NULL);
+        register char *string;          /* String to search. */
+        char *substring;                /* Substring to find in string */
+{
+        register char *a, *b;
+
+        /*
+         * First scan quickly through the two strings looking for a single-
+         * character match.  When it's found, then compare the rest of the
+         * substring.
+         */
+
+        for (b = substring; *string != 0; string += 1) {
+                if (*string != *b)
+                        continue;
+                a = string;
+                for (;;) {
+                        if (*b == 0)
+                                return(string);
+                        if (*a++ != *b++)
+                                break;
+                }
+                b = substring;
+        }
+        return((char *) NULL);
 }
 
@@ -309 +310 @@
 int
 Str_Match(string, pattern)
-        register char *string;          /* String */
-        register char *pattern;         /* Pattern */
-{
-        char c2;
-
-        for (;;) {
-                /*
-                 * See if we're at the end of both the pattern and the
-                 * string. If, we succeeded.  If we're at the end of the
-                 * pattern but not at the end of the string, we failed.
-                 */
-                if (*pattern == 0)
-                        return(!*string);
-                if (*string == 0 && *pattern != '*')
-                        return(0);
-                /*
-                 * Check for a "*" as the next pattern character.  It matches
-                 * any substring.  We handle this by calling ourselves
-                 * recursively for each postfix of string, until either we
-                 * match or we reach the end of the string.
-                 */
-                if (*pattern == '*') {
-                        pattern += 1;
-                        if (*pattern == 0)
-                                return(1);
-                        while (*string != 0) {
-                                if (Str_Match(string, pattern))
-                                        return(1);
-                                ++string;
-                        }
-                        return(0);
-                }
-                /*
-                 * Check for a "?" as the next pattern character.  It matches
-                 * any single character.
-                 */
-                if (*pattern == '?')
-                        goto thisCharOK;
-                /*
-                 * Check for a "[" as the next pattern character.  It is
-                 * followed by a list of characters that are acceptable, or
-                 * by a range (two characters separated by "-").
-                 */
-                if (*pattern == '[') {
-                        ++pattern;
-                        for (;;) {
-                                if ((*pattern == ']') || (*pattern == 0))
-                                        return(0);
-                                if (*pattern == *string)
-                                        break;
-                                if (pattern[1] == '-') {
-                                        c2 = pattern[2];
-                                        if (c2 == 0)
-                                                return(0);
-                                        if ((*pattern <= *string) &&
-                                            (c2 >= *string))
-                                                break;
-                                        if ((*pattern >= *string) &&
-                                            (c2 <= *string))
-                                                break;
-                                        pattern += 2;
-                                }
-                                ++pattern;
-                        }
-                        while ((*pattern != ']') && (*pattern != 0))
-                                ++pattern;
-                        goto thisCharOK;
-                }
-                /*
-                 * If the next pattern character is '/', just strip off the
-                 * '/' so we do exact matching on the character that follows.
-                 */
-                if (*pattern == '\\') {
-                        ++pattern;
-                        if (*pattern == 0)
-                                return(0);
-                }
-                /*
-                 * There's no special character.  Just make sure that the
-                 * next characters of each string match.
-                 */
-                if (*pattern != *string)
-                        return(0);
-thisCharOK:     ++pattern;
-                ++string;
-        }
+        register char *string;          /* String */
+        register char *pattern;         /* Pattern */
+{
+        char c2;
+
+        for (;;) {
+                /*
+                 * See if we're at the end of both the pattern and the
+                 * string. If, we succeeded.  If we're at the end of the
+                 * pattern but not at the end of the string, we failed.
+                 */
+                if (*pattern == 0)
+                        return(!*string);
+                if (*string == 0 && *pattern != '*')
+                        return(0);
+                /*
+                 * Check for a "*" as the next pattern character.  It matches
+                 * any substring.  We handle this by calling ourselves
+                 * recursively for each postfix of string, until either we
+                 * match or we reach the end of the string.
+                 */
+                if (*pattern == '*') {
+                        pattern += 1;
+                        if (*pattern == 0)
+                                return(1);
+                        while (*string != 0) {
+                                if (Str_Match(string, pattern))
+                                        return(1);
+                                ++string;
+                        }
+                        return(0);
+                }
+                /*
+                 * Check for a "?" as the next pattern character.  It matches
+                 * any single character.
+                 */
+                if (*pattern == '?')
+                        goto thisCharOK;
+                /*
+                 * Check for a "[" as the next pattern character.  It is
+                 * followed by a list of characters that are acceptable, or
+                 * by a range (two characters separated by "-").
+                 */
+                if (*pattern == '[') {
+                        ++pattern;
+                        for (;;) {
+                                if ((*pattern == ']') || (*pattern == 0))
+                                        return(0);
+                                if (*pattern == *string)
+                                        break;
+                                if (pattern[1] == '-') {
+                                        c2 = pattern[2];
+                                        if (c2 == 0)
+                                                return(0);
+                                        if ((*pattern <= *string) &&
+                                            (c2 >= *string))
+                                                break;
+                                        if ((*pattern >= *string) &&
+                                            (c2 <= *string))
+                                                break;
+                                        pattern += 2;
+                                }
+                                ++pattern;
+                        }
+                        while ((*pattern != ']') && (*pattern != 0))
+                                ++pattern;
+                        goto thisCharOK;
+                }
+                /*
+                 * If the next pattern character is '/', just strip off the
+                 * '/' so we do exact matching on the character that follows.
+                 */
+                if (*pattern == '\\') {
+                        ++pattern;
+                        if (*pattern == 0)
+                                return(0);
+                }
+                /*
+                 * There's no special character.  Just make sure that the
+                 * next characters of each string match.
+                 */
+                if (*pattern != *string)
+                        return(0);
+thisCharOK:     ++pattern;
+                ++string;
+        }
 }
 
@@ -401 +402 @@
  *-----------------------------------------------------------------------
  * Str_SYSVMatch --
- *      Check word against pattern for a match (% is wild),
+ *      Check word against pattern for a match (% is wild),
  *
  * Results:
- *      Returns the beginning position of a match or null. The number
- *      of characters matched is returned in len.
+ *      Returns the beginning position of a match or null. The number
+ *      of characters matched is returned in len.
  *
  * Side Effects:
- *      None
+ *      None
  *
  *-----------------------------------------------------------------------
@@ -414 +415 @@
 char *
 Str_SYSVMatch(word, pattern, len)
-    char        *word;          /* Word to examine */
-    char        *pattern;       /* Pattern to examine against */
-    int         *len;           /* Number of characters to substitute */
+    char        *word;          /* Word to examine */
+    char        *pattern;       /* Pattern to examine against */
+    int         *len;           /* Number of characters to substitute */
 {
     char *p = pattern;
@@ -423 +424 @@
 
     if (*w == '\0') {
-        /* Zero-length word cannot be matched against */
-        *len = 0;
-        return NULL;
+        /* Zero-length word cannot be matched against */
+        *len = 0;
+        return NULL;
     }
 
     if (*p == '\0') {
-        /* Null pattern is the whole string */
-        *len = strlen(w);
-        return w;
+        /* Null pattern is the whole string */
+        *len = strlen(w);
+        return w;
     }
 
     if ((m = strchr(p, '%')) != NULL) {
-        /* check that the prefix matches */
-        for (; p != m && *w && *w == *p; w++, p++)
-             continue;
-
-        if (p != m)
-            return NULL;        /* No match */
-
-        if (*++p == '\0') {
-            /* No more pattern, return the rest of the string */
-            *len = strlen(w);
-            return w;
-        }
+        /* check that the prefix matches */
+        for (; p != m && *w && *w == *p; w++, p++)
+             continue;
+
+        if (p != m)
+            return NULL;        /* No match */
+
+        if (*++p == '\0') {
+            /* No more pattern, return the rest of the string */
+            *len = strlen(w);
+            return w;
+        }
     }
 
@@ -453 +454 @@
     /* Find a matching tail */
     do
-        if (strcmp(p, w) == 0) {
-            *len = w - m;
-            return m;
-        }
+        if (strcmp(p, w) == 0) {
+            *len = w - m;
+            return m;
+        }
     while (*w++ != '\0');
 
@@ -466 +467 @@
  *-----------------------------------------------------------------------
  * Str_SYSVSubst --
- *      Substitute '%' on the pattern with len characters from src.
- *      If the pattern does not contain a '%' prepend len characters
- *      from src.
+ *      Substitute '%' on the pattern with len characters from src.
+ *      If the pattern does not contain a '%' prepend len characters
+ *      from src.
  *
  * Results:
- *      None
+ *      None
  *
  * Side Effects:
- *      Places result on buf
+ *      Places result on buf
  *
  *-----------------------------------------------------------------------
@@ -488 +489 @@
 
     if ((m = strchr(pat, '%')) != NULL) {
-        /* Copy the prefix */
-        Buf_AddBytes(buf, m - pat, (Byte *) pat);
-        /* skip the % */
-        pat = m + 1;
+        /* Copy the prefix */
+        Buf_AddBytes(buf, m - pat, (Byte *) pat);
+        /* skip the % */
+        pat = m + 1;
     }
 

trunk/src/kmk/suff.c

@@ -1 +1 @@
 /*
  * 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.
@@ -18 +18 @@
  * 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
@@ -39 +39 @@
 #ifndef lint
 #if 0
-static char sccsid[] = "@(#)suff.c      8.4 (Berkeley) 3/21/94";
+static char sccsid[] = "@(#)suff.c      8.4 (Berkeley) 3/21/94";
 #else
 static const char rcsid[] =
   "$FreeBSD: src/usr.bin/make/suff.c,v 1.12.2.1 2001/03/09 01:13:24 tmm Exp $";
 #endif
+#define KLIBFILEDEF rcsid
 #endif /* not lint */
 
 /*-
  * suff.c --
- *      Functions to maintain suffix lists and find implicit dependents
- *      using suffix transformation rules
+ *      Functions to maintain suffix lists and find implicit dependents
+ *      using suffix transformation rules
  *
  * Interface:
- *      Suff_Init               Initialize all things to do with suffixes.
- *
- *      Suff_End                Cleanup the module
- *
- *      Suff_DoPaths            This function is used to make life easier
- *                              when searching for a file according to its
- *                              suffix. It takes the global search path,
- *                              as defined using the .PATH: target, and appends
- *                              its directories to the path of each of the
- *                              defined suffixes, as specified using
- *                              .PATH<suffix>: targets. In addition, all
- *                              directories given for suffixes labeled as
- *                              include files or libraries, using the .INCLUDES
- *                              or .LIBS targets, are played with using
- *                              Dir_MakeFlags to create the .INCLUDES and
- *                              .LIBS global variables.
- *
- *      Suff_ClearSuffixes      Clear out all the suffixes and defined
- *                              transformations.
- *
- *      Suff_IsTransform        Return TRUE if the passed string is the lhs
- *                              of a transformation rule.
- *
- *      Suff_AddSuffix          Add the passed string as another known suffix.
- *
- *      Suff_GetPath            Return the search path for the given suffix.
- *
- *      Suff_AddInclude         Mark the given suffix as denoting an include
- *                              file.
- *
- *      Suff_AddLib             Mark the given suffix as denoting a library.
- *
- *      Suff_AddTransform       Add another transformation to the suffix
- *                              graph. Returns  GNode suitable for framing, I
- *                              mean, tacking commands, attributes, etc. on.
- *
- *      Suff_SetNull            Define the suffix to consider the suffix of
- *                              any file that doesn't have a known one.
- *
- *      Suff_FindDeps           Find implicit sources for and the location of
- *                              a target based on its suffix. Returns the
- *                              bottom-most node added to the graph or NILGNODE
- *                              if the target had no implicit sources.
- */
-
-#include          <stdio.h>
-#include          "make.h"
-#include          "hash.h"
-#include          "dir.h"
-
-static Lst       sufflist;      /* Lst of suffixes */
-static Lst       suffClean;     /* Lst of suffixes to be cleaned */
-static Lst       srclist;       /* Lst of sources */
-static Lst       transforms;    /* Lst of transformation rules */
-
-static int        sNum = 0;     /* Counter for assigning suffix numbers */
+ *      Suff_Init               Initialize all things to do with suffixes.
+ *
+ *      Suff_End                Cleanup the module
+ *
+ *      Suff_DoPaths            This function is used to make life easier
+ *                              when searching for a file according to its
+ *                              suffix. It takes the global search path,
+ *                              as defined using the .PATH: target, and appends
+ *                              its directories to the path of each of the
+ *                              defined suffixes, as specified using
+ *                              .PATH<suffix>: targets. In addition, all
+ *                              directories given for suffixes labeled as
+ *                              include files or libraries, using the .INCLUDES
+ *                              or .LIBS targets, are played with using
+ *                              Dir_MakeFlags to create the .INCLUDES and
+ *                              .LIBS global variables.
+ *
+ *      Suff_ClearSuffixes      Clear out all the suffixes and defined
+ *                              transformations.
+ *
+ *      Suff_IsTransform        Return TRUE if the passed string is the lhs
+ *                              of a transformation rule.
+ *
+ *      Suff_AddSuffix          Add the passed string as another known suffix.
+ *
+ *      Suff_GetPath            Return the search path for the given suffix.
+ *
+ *      Suff_AddInclude         Mark the given suffix as denoting an include
+ *                              file.
+ *
+ *      Suff_AddLib             Mark the given suffix as denoting a library.
+ *
+ *      Suff_AddTransform       Add another transformation to the suffix
+ *                              graph. Returns  GNode suitable for framing, I
+ *                              mean, tacking commands, attributes, etc. on.
+ *
+ *      Suff_SetNull            Define the suffix to consider the suffix of
+ *                              any file that doesn't have a known one.
+ *
+ *      Suff_FindDeps           Find implicit sources for and the location of
+ *                              a target based on its suffix. Returns the
+ *                              bottom-most node added to the graph or NILGNODE
+ *                              if the target had no implicit sources.
+ */
+
+#include          <stdio.h>
+#include          <strings.h>
+#include          "make.h"
+#include          "hash.h"
+#include          "dir.h"
+
+static Lst       sufflist;      /* Lst of suffixes */
+static Lst       suffClean;     /* Lst of suffixes to be cleaned */
+static Lst       srclist;       /* Lst of sources */
+static Lst       transforms;    /* Lst of transformation rules */
+
+static int        sNum = 0;     /* Counter for assigning suffix numbers */
 
 /*
@@ -113 +115 @@
  */
 typedef struct _Suff {
-    char         *name;         /* The suffix itself */
-    int          nameLen;       /* Length of the suffix */
-    short        flags;         /* Type of suffix */
-#define SUFF_INCLUDE      0x01      /* One which is #include'd */
+    char         *name;         /* The suffix itself */
+    int          nameLen;       /* Length of the suffix */
+    short        flags;         /* Type of suffix */
+#define SUFF_INCLUDE      0x01      /* One which is #include'd */
 #ifdef USE_ARCHIVES
-#define SUFF_LIBRARY      0x02      /* One which contains a library */
+#define SUFF_LIBRARY      0x02      /* One which contains a library */
 #endif
-#define SUFF_NULL         0x04      /* The empty suffix */
-    Lst          searchPath;    /* The path along which files of this suffix
-                                 * may be found */
-    int          sNum;          /* The suffix number */
-    int          refCount;      /* Reference count of list membership */
-    Lst          parents;       /* Suffixes we have a transformation to */
-    Lst          children;      /* Suffixes we have a transformation from */
-    Lst          ref;           /* List of lists this suffix is referenced */
+#define SUFF_NULL         0x04      /* The empty suffix */
+    Lst          searchPath;    /* The path along which files of this suffix
+                                 * may be found */
+    int          sNum;          /* The suffix number */
+    int          refCount;      /* Reference count of list membership */
+    Lst          parents;       /* Suffixes we have a transformation to */
+    Lst          children;      /* Suffixes we have a transformation from */
+    Lst          ref;           /* List of lists this suffix is referenced */
 } Suff;
 
@@ -134 +136 @@
  */
 typedef struct _Src {
-    char            *file;      /* The file to look for */
-    char            *pref;      /* Prefix from which file was formed */
-    Suff            *suff;      /* The suffix on the file */
-    struct _Src     *parent;    /* The Src for which this is a source */
-    GNode           *node;      /* The node describing the file */
-    int             children;   /* Count of existing children (so we don't efree
-                                 * this thing too early or never nuke it) */
+    char            *file;      /* The file to look for */
+    char            *pref;      /* Prefix from which file was formed */
+    Suff            *suff;      /* The suffix on the file */
+    struct _Src     *parent;    /* The Src for which this is a source */
+    GNode           *node;      /* The node describing the file */
+    int             children;   /* Count of existing children (so we don't efree
+                                 * this thing too early or never nuke it) */
 #ifdef DEBUG_SRC
-    Lst             cp;         /* Debug; children list */
+    Lst             cp;         /* Debug; children list */
 #endif
 } Src;
@@ -155 +157 @@
 } LstSrc;
 
-static Suff         *suffNull;  /* The NULL suffix for this run */
-static Suff         *emptySuff; /* The empty suffix required for POSIX
-                                 * single-suffix transformation rules */
+static Suff         *suffNull;  /* The NULL suffix for this run */
+static Suff         *emptySuff; /* The empty suffix required for POSIX
+                                 * single-suffix transformation rules */
 
 
@@ -187 +189 @@
 static int SuffPrintTrans __P((ClientData, ClientData));
 
-        /*************** Lst Predicates ****************/
+        /*************** Lst Predicates ****************/
 /*-
  *-----------------------------------------------------------------------
  * SuffStrIsPrefix  --
- *      See if pref is a prefix of str.
- *
- * Results:
- *      NULL if it ain't, pointer to character in str after prefix if so
- *
- * Side Effects:
- *      None
+ *      See if pref is a prefix of str.
+ *
+ * Results:
+ *      NULL if it ain't, pointer to character in str after prefix if so
+ *
+ * Side Effects:
+ *      None
  *-----------------------------------------------------------------------
  */
 static char    *
 SuffStrIsPrefix (pref, str)
-    register char  *pref;       /* possible prefix */
-    register char  *str;        /* string to check */
+    register char  *pref;       /* possible prefix */
+    register char  *str;        /* string to check */
 {
     while (*str && *pref == *str) {
-        pref++;
-        str++;
+        pref++;
+        str++;
     }
 
@@ -216 +218 @@
  *-----------------------------------------------------------------------
  * SuffSuffIsSuffix  --
- *      See if suff is a suffix of str. Str should point to THE END of the
- *      string to check. (THE END == the null byte)
- *
- * Results:
- *      NULL if it ain't, pointer to character in str before suffix if
- *      it is.
- *
- * Side Effects:
- *      None
+ *      See if suff is a suffix of str. Str should point to THE END of the
+ *      string to check. (THE END == the null byte)
+ *
+ * Results:
+ *      NULL if it ain't, pointer to character in str before suffix if
+ *      it is.
+ *
+ * Side Effects:
+ *      None
  *-----------------------------------------------------------------------
  */
 static char *
 SuffSuffIsSuffix (s, str)
-    register Suff  *s;          /* possible suffix */
-    char           *str;        /* string to examine */
-{
-    register char  *p1;         /* Pointer into suffix name */
-    register char  *p2;         /* Pointer into string being examined */
+    register Suff  *s;          /* possible suffix */
+    char           *str;        /* string to examine */
+{
+    register char  *p1;         /* Pointer into suffix name */
+    register char  *p2;         /* Pointer into string being examined */
 
     p1 = s->name + s->nameLen;
@@ -239 +241 @@
 
     while (p1 >= s->name && *p1 == *p2) {
-        p1--;
-        p2--;
+        p1--;
+        p2--;
     }
 
@@ -249 +251 @@
  *-----------------------------------------------------------------------
  * SuffSuffIsSuffixP --
- *      Predicate form of SuffSuffIsSuffix. Passed as the callback function
- *      to Lst_Find.
- *
- * Results:
- *      0 if the suffix is the one desired, non-zero if not.
- *
- * Side Effects:
- *      None.
+ *      Predicate form of SuffSuffIsSuffix. Passed as the callback function
+ *      to Lst_Find.
+ *
+ * Results:
+ *      0 if the suffix is the one desired, non-zero if not.
+ *
+ * Side Effects:
+ *      None.
  *
  *-----------------------------------------------------------------------
@@ -271 +273 @@
  *-----------------------------------------------------------------------
  * SuffSuffHasNameP --
- *      Callback procedure for finding a suffix based on its name. Used by
- *      Suff_GetPath.
- *
- * Results:
- *      0 if the suffix is of the given name. non-zero otherwise.
- *
- * Side Effects:
- *      None
+ *      Callback procedure for finding a suffix based on its name. Used by
+ *      Suff_GetPath.
+ *
+ * Results:
+ *      0 if the suffix is of the given name. non-zero otherwise.
+ *
+ * Side Effects:
+ *      None
  *-----------------------------------------------------------------------
  */
 static int
 SuffSuffHasNameP (s, sname)
-    ClientData    s;                /* Suffix to check */
-    ClientData    sname;            /* Desired name */
+    ClientData    s;                /* Suffix to check */
+    ClientData    sname;            /* Desired name */
 {
     return (strcmp ((char *) sname, ((Suff *) s)->name));
@@ -292 +294 @@
  *-----------------------------------------------------------------------
  * SuffSuffIsPrefix  --
- *      See if the suffix described by s is a prefix of the string. Care
- *      must be taken when using this to search for transformations and
- *      what-not, since there could well be two suffixes, one of which
- *      is a prefix of the other...
- *
- * Results:
- *      0 if s is a prefix of str. non-zero otherwise
- *
- * Side Effects:
- *      None
+ *      See if the suffix described by s is a prefix of the string. Care
+ *      must be taken when using this to search for transformations and
+ *      what-not, since there could well be two suffixes, one of which
+ *      is a prefix of the other...
+ *
+ * Results:
+ *      0 if s is a prefix of str. non-zero otherwise
+ *
+ * Side Effects:
+ *      None
  *-----------------------------------------------------------------------
  */
 static int
 SuffSuffIsPrefix (s, str)
-    ClientData   s;             /* suffix to compare */
-    ClientData   str;   /* string to examine */
+    ClientData   s;             /* suffix to compare */
+    ClientData   str;   /* string to examine */
 {
     return (SuffStrIsPrefix (((Suff *) s)->name, (char *) str) == NULL ? 1 : 0);
@@ -315 +317 @@
  *-----------------------------------------------------------------------
  * SuffGNHasNameP  --
- *      See if the graph node has the desired name
- *
- * Results:
- *      0 if it does. non-zero if it doesn't
- *
- * Side Effects:
- *      None
+ *      See if the graph node has the desired name
+ *
+ * Results:
+ *      0 if it does. non-zero if it doesn't
+ *
+ * Side Effects:
+ *      None
  *-----------------------------------------------------------------------
  */
 static int
 SuffGNHasNameP (gn, name)
-    ClientData      gn;         /* current node we're looking at */
-    ClientData      name;       /* name we're looking for */
+    ClientData      gn;         /* current node we're looking at */
+    ClientData      name;       /* name we're looking for */
 {
     return (strcmp ((char *) name, ((GNode *) gn)->name));
 }
 
-            /*********** Maintenance Functions ************/
+            /*********** Maintenance Functions ************/
 
 /*-
  *-----------------------------------------------------------------------
  * SuffFree  --
- *      Free up all memory associated with the given suffix structure.
- *
- * Results:
- *      none
- *
- * Side Effects:
- *      the suffix entry is detroyed
+ *      Free up all memory associated with the given suffix structure.
+ *
+ * Results:
+ *      none
+ *
+ * Side Effects:
+ *      the suffix entry is detroyed
  *-----------------------------------------------------------------------
  */
@@ -353 +355 @@
 
     if (s == suffNull)
-        suffNull = NULL;
+        suffNull = NULL;
 
     if (s == emptySuff)
-        emptySuff = NULL;
+        emptySuff = NULL;
 
     Lst_Destroy (s->ref, NOFREE);
@@ -370 +372 @@
  *-----------------------------------------------------------------------
  * SuffRemove  --
- *      Remove the suffix into the list
- *
- * Results:
- *      None
- *
- * Side Effects:
- *      The reference count for the suffix is decremented
+ *      Remove the suffix into the list
+ *
+ * Results:
+ *      None
+ *
+ * Side Effects:
+ *      The reference count for the suffix is decremented
  *-----------------------------------------------------------------------
  */
@@ -386 +388 @@
     LstNode ln = Lst_Member(l, (ClientData)s);
     if (ln != NILLNODE) {
-        Lst_Remove(l, ln);
-        s->refCount--;
+        Lst_Remove(l, ln);
+        s->refCount--;
     }
 }
@@ -395 +397 @@
  *-----------------------------------------------------------------------
  * SuffInsert  --
- *      Insert the suffix into the list keeping the list ordered by suffix
- *      numbers.
- *
- * Results:
- *      None
- *
- * Side Effects:
- *      The reference count of the suffix is incremented
+ *      Insert the suffix into the list keeping the list ordered by suffix
+ *      numbers.
+ *
+ * Results:
+ *      None
+ *
+ * Side Effects:
+ *      The reference count of the suffix is incremented
  *-----------------------------------------------------------------------
  */
 static void
 SuffInsert (l, s)
-    Lst           l;            /* the list where in s should be inserted */
-    Suff          *s;           /* the suffix to insert */
-{
-    LstNode       ln;           /* current element in l we're examining */
-    Suff          *s2 = NULL;   /* the suffix descriptor in this element */
+    Lst           l;            /* the list where in s should be inserted */
+    Suff          *s;           /* the suffix to insert */
+{
+    LstNode       ln;           /* current element in l we're examining */
+    Suff          *s2 = NULL;   /* the suffix descriptor in this element */
 
     if (Lst_Open (l) == FAILURE) {
-        return;
+        return;
     }
     while ((ln = Lst_Next (l)) != NILLNODE) {
-        s2 = (Suff *) Lst_Datum (ln);
-        if (s2->sNum >= s->sNum) {
-            break;
-        }
+        s2 = (Suff *) Lst_Datum (ln);
+        if (s2->sNum >= s->sNum) {
+            break;
+        }
     }
 
     Lst_Close (l);
     if (DEBUG(SUFF)) {
-        printf("inserting %s(%d)...", s->name, s->sNum);
+        printf("inserting %s(%d)...", s->name, s->sNum);
     }
     if (ln == NILLNODE) {
-        if (DEBUG(SUFF)) {
-            printf("at end of list\n");
-        }
-        (void)Lst_AtEnd (l, (ClientData)s);
-        s->refCount++;
-        (void)Lst_AtEnd(s->ref, (ClientData) l);
+        if (DEBUG(SUFF)) {
+            printf("at end of list\n");
+        }
+        (void)Lst_AtEnd (l, (ClientData)s);
+        s->refCount++;
+        (void)Lst_AtEnd(s->ref, (ClientData) l);
     } else if (s2->sNum != s->sNum) {
-        if (DEBUG(SUFF)) {
-            printf("before %s(%d)\n", s2->name, s2->sNum);
-        }
-        (void)Lst_Insert (l, ln, (ClientData)s);
-        s->refCount++;
-        (void)Lst_AtEnd(s->ref, (ClientData) l);
+        if (DEBUG(SUFF)) {
+            printf("before %s(%d)\n", s2->name, s2->sNum);
+        }
+        (void)Lst_Insert (l, ln, (ClientData)s);
+        s->refCount++;
+        (void)Lst_AtEnd(s->ref, (ClientData) l);
     } else if (DEBUG(SUFF)) {
-        printf("already there\n");
+        printf("already there\n");
     }
 }
@@ -449 +451 @@
  *-----------------------------------------------------------------------
  * Suff_ClearSuffixes --
- *      This is gross. Nuke the list of suffixes but keep all transformation
- *      rules around. The transformation graph is destroyed in this process,
- *      but we leave the list of rules so when a new graph is formed the rules
- *      will remain.
- *      This function is called from the parse module when a
- *      .SUFFIXES:\n line is encountered.
- *
- * Results:
- *      none
- *
- * Side Effects:
- *      the sufflist and its graph nodes are destroyed
+ *      This is gross. Nuke the list of suffixes but keep all transformation
+ *      rules around. The transformation graph is destroyed in this process,
+ *      but we leave the list of rules so when a new graph is formed the rules
+ *      will remain.
+ *      This function is called from the parse module when a
+ *      .SUFFIXES:\n line is encountered.
+ *
+ * Results:
+ *      none
+ *
+ * Side Effects:
+ *      the sufflist and its graph nodes are destroyed
  *-----------------------------------------------------------------------
  */
@@ -483 +485 @@
  *-----------------------------------------------------------------------
  * SuffParseTransform --
- *      Parse a transformation string to find its two component suffixes.
- *
- * Results:
- *      TRUE if the string is a valid transformation and FALSE otherwise.
- *
- * Side Effects:
- *      The passed pointers are overwritten.
+ *      Parse a transformation string to find its two component suffixes.
+ *
+ * Results:
+ *      TRUE if the string is a valid transformation and FALSE otherwise.
+ *
+ * Side Effects:
+ *      The passed pointers are overwritten.
  *
  *-----------------------------------------------------------------------
@@ -495 +497 @@
 static Boolean
 SuffParseTransform(str, srcPtr, targPtr)
-    char                *str;           /* String being parsed */
-    Suff                **srcPtr;       /* Place to store source of trans. */
-    Suff                **targPtr;      /* Place to store target of trans. */
-{
-    register LstNode    srcLn;      /* element in suffix list of trans source*/
-    register Suff       *src;       /* Source of transformation */
-    register LstNode    targLn;     /* element in suffix list of trans target*/
-    register char       *str2;      /* Extra pointer (maybe target suffix) */
-    LstNode             singleLn;   /* element in suffix list of any suffix
-                                     * that exactly matches str */
-    Suff                *single = NULL;/* Source of possible transformation to
-                                     * null suffix */
+    char                *str;           /* String being parsed */
+    Suff                **srcPtr;       /* Place to store source of trans. */
+    Suff                **targPtr;      /* Place to store target of trans. */
+{
+    register LstNode    srcLn;      /* element in suffix list of trans source*/
+    register Suff       *src;       /* Source of transformation */
+    register LstNode    targLn;     /* element in suffix list of trans target*/
+    register char       *str2;      /* Extra pointer (maybe target suffix) */
+    LstNode             singleLn;   /* element in suffix list of any suffix
+                                     * that exactly matches str */
+    Suff                *single = NULL;/* Source of possible transformation to
+                                     * null suffix */
 
     srcLn = NILLNODE;
@@ -518 +520 @@
      */
     for (;;) {
-        if (srcLn == NILLNODE) {
-            srcLn = Lst_Find(sufflist, (ClientData)str, SuffSuffIsPrefix);
-        } else {
-            srcLn = Lst_FindFrom (sufflist, Lst_Succ(srcLn), (ClientData)str,
-                                  SuffSuffIsPrefix);
-        }
-        if (srcLn == NILLNODE) {
-            /*
-             * Ran out of source suffixes -- no such rule
-             */
-            if (singleLn != NILLNODE) {
-                /*
-                 * Not so fast Mr. Smith! There was a suffix that encompassed
-                 * the entire string, so we assume it was a transformation
-                 * to the null suffix (thank you POSIX). We still prefer to
-                 * find a double rule over a singleton, hence we leave this
-                 * check until the end.
-                 *
-                 * XXX: Use emptySuff over suffNull?
-                 */
-                *srcPtr = single;
-                *targPtr = suffNull;
-                return(TRUE);
-            }
-            return (FALSE);
-        }
-        src = (Suff *) Lst_Datum (srcLn);
-        str2 = str + src->nameLen;
-        if (*str2 == '\0') {
-            single = src;
-            singleLn = srcLn;
-        } else {
-            targLn = Lst_Find(sufflist, (ClientData)str2, SuffSuffHasNameP);
-            if (targLn != NILLNODE) {
-                *srcPtr = src;
-                *targPtr = (Suff *)Lst_Datum(targLn);
-                return (TRUE);
-            }
-        }
+        if (srcLn == NILLNODE) {
+            srcLn = Lst_Find(sufflist, (ClientData)str, SuffSuffIsPrefix);
+        } else {
+            srcLn = Lst_FindFrom (sufflist, Lst_Succ(srcLn), (ClientData)str,
+                                  SuffSuffIsPrefix);
+        }
+        if (srcLn == NILLNODE) {
+            /*
+             * Ran out of source suffixes -- no such rule
+             */
+            if (singleLn != NILLNODE) {
+                /*
+                 * Not so fast Mr. Smith! There was a suffix that encompassed
+                 * the entire string, so we assume it was a transformation
+                 * to the null suffix (thank you POSIX). We still prefer to
+                 * find a double rule over a singleton, hence we leave this
+                 * check until the end.
+                 *
+                 * XXX: Use emptySuff over suffNull?
+                 */
+                *srcPtr = single;
+                *targPtr = suffNull;
+                return(TRUE);
+            }
+            return (FALSE);
+        }
+        src = (Suff *) Lst_Datum (srcLn);
+        str2 = str + src->nameLen;
+        if (*str2 == '\0') {
+            single = src;
+            singleLn = srcLn;
+        } else {
+            targLn = Lst_Find(sufflist, (ClientData)str2, SuffSuffHasNameP);
+            if (targLn != NILLNODE) {
+                *srcPtr = src;
+                *targPtr = (Suff *)Lst_Datum(targLn);
+                return (TRUE);
+            }
+        }
     }
 }
@@ -563 +565 @@
  *-----------------------------------------------------------------------
  * Suff_IsTransform  --
- *      Return TRUE if the given string is a transformation rule
- *
- *
- * Results:
- *      TRUE if the string is a concatenation of two known suffixes.
- *      FALSE otherwise
- *
- * Side Effects:
- *      None
+ *      Return TRUE if the given string is a transformation rule
+ *
+ *
+ * Results:
+ *      TRUE if the string is a concatenation of two known suffixes.
+ *      FALSE otherwise
+ *
+ * Side Effects:
+ *      None
  *-----------------------------------------------------------------------
  */
 Boolean
 Suff_IsTransform (str)
-    char          *str;         /* string to check */
-{
-    Suff          *src, *targ;
+    char          *str;         /* string to check */
+{
+    Suff          *src, *targ;
 
     return (SuffParseTransform(str, &src, &targ));
@@ -586 +588 @@
  *-----------------------------------------------------------------------
  * Suff_AddTransform --
- *      Add the transformation rule described by the line to the
- *      list of rules and place the transformation itself in the graph
- *
- * Results:
- *      The node created for the transformation in the transforms list
- *
- * Side Effects:
- *      The node is placed on the end of the transforms Lst and links are
- *      made between the two suffixes mentioned in the target name
+ *      Add the transformation rule described by the line to the
+ *      list of rules and place the transformation itself in the graph
+ *
+ * Results:
+ *      The node created for the transformation in the transforms list
+ *
+ * Side Effects:
+ *      The node is placed on the end of the transforms Lst and links are
+ *      made between the two suffixes mentioned in the target name
  *-----------------------------------------------------------------------
  */
 GNode *
 Suff_AddTransform (line)
-    char          *line;        /* name of transformation to add */
-{
-    GNode         *gn;          /* GNode of transformation rule */
-    Suff          *s,           /* source suffix */
-                  *t;           /* target suffix */
-    LstNode       ln;           /* Node for existing transformation */
+    char          *line;        /* name of transformation to add */
+{
+    GNode         *gn;          /* GNode of transformation rule */
+    Suff          *s,           /* source suffix */
+                  *t;           /* target suffix */
+    LstNode       ln;           /* Node for existing transformation */
 
     ln = Lst_Find (transforms, (ClientData)line, SuffGNHasNameP);
     if (ln == NILLNODE) {
-        /*
-         * Make a new graph node for the transformation. It will be filled in
-         * by the Parse module.
-         */
-        gn = Targ_NewGN (line);
-        (void)Lst_AtEnd (transforms, (ClientData)gn);
+        /*
+         * Make a new graph node for the transformation. It will be filled in
+         * by the Parse module.
+         */
+        gn = Targ_NewGN (line);
+        (void)Lst_AtEnd (transforms, (ClientData)gn);
     } else {
-        /*
-         * New specification for transformation rule. Just nuke the old list
-         * of commands so they can be filled in again... We don't actually
-         * efree the commands themselves, because a given command can be
-         * attached to several different transformations.
-         */
-        gn = (GNode *) Lst_Datum (ln);
-        Lst_Destroy (gn->commands, NOFREE);
-        Lst_Destroy (gn->children, NOFREE);
-        gn->commands = Lst_Init (FALSE);
-        gn->children = Lst_Init (FALSE);
+        /*
+         * New specification for transformation rule. Just nuke the old list
+         * of commands so they can be filled in again... We don't actually
+         * efree the commands themselves, because a given command can be
+         * attached to several different transformations.
+         */
+        gn = (GNode *) Lst_Datum (ln);
+        Lst_Destroy (gn->commands, NOFREE);
+        Lst_Destroy (gn->children, NOFREE);
+        gn->commands = Lst_Init (FALSE);
+        gn->children = Lst_Init (FALSE);
     }
 
@@ -636 +638 @@
      */
     if (DEBUG(SUFF)) {
-        printf("defining transformation from `%s' to `%s'\n",
-                s->name, t->name);
+        printf("defining transformation from `%s' to `%s'\n",
+                s->name, t->name);
     }
     SuffInsert (t->children, s);
@@ -648 +650 @@
  *-----------------------------------------------------------------------
  * Suff_EndTransform --
- *      Handle the finish of a transformation definition, removing the
- *      transformation from the graph if it has neither commands nor
- *      sources. This is a callback procedure for the Parse module via
- *      Lst_ForEach
- *
- * Results:
- *      === 0
- *
- * Side Effects:
- *      If the node has no commands or children, the children and parents
- *      lists of the affected suffices are altered.
+ *      Handle the finish of a transformation definition, removing the
+ *      transformation from the graph if it has neither commands nor
+ *      sources. This is a callback procedure for the Parse module via
+ *      Lst_ForEach
+ *
+ * Results:
+ *      === 0
+ *
+ * Side Effects:
+ *      If the node has no commands or children, the children and parents
+ *      lists of the affected suffices are altered.
  *
  *-----------------------------------------------------------------------
@@ -664 +666 @@
 int
 Suff_EndTransform(gnp, dummy)
-    ClientData   gnp;           /* Node for transformation */
-    ClientData   dummy;         /* Node for transformation */
+    ClientData   gnp;           /* Node for transformation */
+    ClientData   dummy;         /* Node for transformation */
 {
     GNode *gn = (GNode *) gnp;
 
     if ((gn->type & OP_TRANSFORM) && Lst_IsEmpty(gn->commands) &&
-        Lst_IsEmpty(gn->children))
+        Lst_IsEmpty(gn->children))
     {
-        Suff    *s, *t;
-
-        (void)SuffParseTransform(gn->name, &s, &t);
-
-        if (DEBUG(SUFF)) {
-            printf("deleting transformation from `%s' to `%s'\n",
-                    s->name, t->name);
-        }
-
-        /*
-         * Remove the source from the target's children list. We check for a
-         * nil return to handle a beanhead saying something like
-         *  .c.o .c.o:
-         *
-         * We'll be called twice when the next target is seen, but .c and .o
-         * are only linked once...
-         */
-        SuffRemove(t->children, s);
-
-        /*
-         * Remove the target from the source's parents list
-         */
-        SuffRemove(s->parents, t);
+        Suff    *s, *t;
+
+        (void)SuffParseTransform(gn->name, &s, &t);
+
+        if (DEBUG(SUFF)) {
+            printf("deleting transformation from `%s' to `%s'\n",
+                    s->name, t->name);
+        }
+
+        /*
+         * Remove the source from the target's children list. We check for a
+         * nil return to handle a beanhead saying something like
+         *  .c.o .c.o:
+         *
+         * We'll be called twice when the next target is seen, but .c and .o
+         * are only linked once...
+         */
+        SuffRemove(t->children, s);
+
+        /*
+         * Remove the target from the source's parents list
+         */
+        SuffRemove(s->parents, t);
     } else if ((gn->type & OP_TRANSFORM) && DEBUG(SUFF)) {
-        printf("transformation %s complete\n", gn->name);
+        printf("transformation %s complete\n", gn->name);
     }
 
@@ -705 +707 @@
  *-----------------------------------------------------------------------
  * SuffRebuildGraph --
- *      Called from Suff_AddSuffix via Lst_ForEach to search through the
- *      list of existing transformation rules and rebuild the transformation
- *      graph when it has been destroyed by Suff_ClearSuffixes. If the
- *      given rule is a transformation involving this suffix and another,
- *      existing suffix, the proper relationship is established between
- *      the two.
- *
- * Results:
- *      Always 0.
- *
- * Side Effects:
- *      The appropriate links will be made between this suffix and
- *      others if transformation rules exist for it.
+ *      Called from Suff_AddSuffix via Lst_ForEach to search through the
+ *      list of existing transformation rules and rebuild the transformation
+ *      graph when it has been destroyed by Suff_ClearSuffixes. If the
+ *      given rule is a transformation involving this suffix and another,
+ *      existing suffix, the proper relationship is established between
+ *      the two.
+ *
+ * Results:
+ *      Always 0.
+ *
+ * Side Effects:
+ *      The appropriate links will be made between this suffix and
+ *      others if transformation rules exist for it.
  *
  *-----------------------------------------------------------------------
@@ -724 +726 @@
 SuffRebuildGraph(transformp, sp)
     ClientData  transformp; /* Transformation to test */
-    ClientData  sp;         /* Suffix to rebuild */
-{
-    GNode       *transform = (GNode *) transformp;
-    Suff        *s = (Suff *) sp;
-    char        *cp;
-    LstNode     ln;
-    Suff        *s2 = NULL;
+    ClientData  sp;         /* Suffix to rebuild */
+{
+    GNode       *transform = (GNode *) transformp;
+    Suff        *s = (Suff *) sp;
+    char        *cp;
+    LstNode     ln;
+    Suff        *s2 = NULL;
 
     /*
@@ -737 +739 @@
     cp = SuffStrIsPrefix(s->name, transform->name);
     if (cp != (char *)NULL) {
-        if (cp[0] == '\0')  /* null rule */
-            s2 = suffNull;
-        else {
-            ln = Lst_Find(sufflist, (ClientData)cp, SuffSuffHasNameP);
-            if (ln != NILLNODE)
-                s2 = (Suff *)Lst_Datum(ln);
-        }
-        if (s2 != NULL) {
-            /*
-             * Found target. Link in and return, since it can't be anything
-             * else.
-             */
-            SuffInsert(s2->children, s);
-            SuffInsert(s->parents, s2);
-            return(0);
-        }
+        if (cp[0] == '\0')  /* null rule */
+            s2 = suffNull;
+        else {
+            ln = Lst_Find(sufflist, (ClientData)cp, SuffSuffHasNameP);
+            if (ln != NILLNODE)
+                s2 = (Suff *)Lst_Datum(ln);
+        }
+        if (s2 != NULL) {
+            /*
+             * Found target. Link in and return, since it can't be anything
+             * else.
+             */
+            SuffInsert(s2->children, s);
+            SuffInsert(s->parents, s2);
+            return(0);
+        }
     }
 
@@ -760 +762 @@
     cp = SuffSuffIsSuffix(s, transform->name + strlen(transform->name));
     if (cp != (char *)NULL) {
-        /*
-         * Null-terminate the source suffix in order to find it.
-         */
-        cp[1] = '\0';
-        ln = Lst_Find(sufflist, (ClientData)transform->name, SuffSuffHasNameP);
-        /*
-         * Replace the start of the target suffix
-         */
-        cp[1] = s->name[0];
-        if (ln != NILLNODE) {
-            /*
-             * Found it -- establish the proper relationship
-             */
-            s2 = (Suff *)Lst_Datum(ln);
-            SuffInsert(s->children, s2);
-            SuffInsert(s2->parents, s);
-        }
+        /*
+         * Null-terminate the source suffix in order to find it.
+         */
+        cp[1] = '\0';
+        ln = Lst_Find(sufflist, (ClientData)transform->name, SuffSuffHasNameP);
+        /*
+         * Replace the start of the target suffix
+         */
+        cp[1] = s->name[0];
+        if (ln != NILLNODE) {
+            /*
+             * Found it -- establish the proper relationship
+             */
+            s2 = (Suff *)Lst_Datum(ln);
+            SuffInsert(s->children, s2);
+            SuffInsert(s2->parents, s);
+        }
     }
     return(0);
@@ -784 +786 @@
  *-----------------------------------------------------------------------
  * Suff_AddSuffix --
- *      Add the suffix in string to the end of the list of known suffixes.
- *      Should we restructure the suffix graph? Make doesn't...
- *
- * Results:
- *      None
- *
- * Side Effects:
- *      A GNode is created for the suffix and a Suff structure is created and
- *      added to the suffixes list unless the suffix was already known.
+ *      Add the suffix in string to the end of the list of known suffixes.
+ *      Should we restructure the suffix graph? Make doesn't...
+ *
+ * Results:
+ *      None
+ *
+ * Side Effects:
+ *      A GNode is created for the suffix and a Suff structure is created and
+ *      added to the suffixes list unless the suffix was already known.
  *-----------------------------------------------------------------------
  */
 void
 Suff_AddSuffix (str)
-    char          *str;     /* the name of the suffix to add */
-{
-    Suff          *s;       /* new suffix descriptor */
-    LstNode       ln;
+    char          *str;     /* the name of the suffix to add */
+{
+    Suff          *s;       /* new suffix descriptor */
+    LstNode       ln;
 
     ln = Lst_Find (sufflist, (ClientData)str, SuffSuffHasNameP);
     if (ln == NILLNODE) {
-        s = (Suff *) emalloc (sizeof (Suff));
-
-        s->name =       estrdup (str);
-        s->nameLen =    strlen (s->name);
-        s->searchPath = Lst_Init (FALSE);
-        s->children =   Lst_Init (FALSE);
-        s->parents =    Lst_Init (FALSE);
-        s->ref =        Lst_Init (FALSE);
-        s->sNum =       sNum++;
-        s->flags =      0;
-        s->refCount =   0;
-
-        (void)Lst_AtEnd (sufflist, (ClientData)s);
-        /*
-         * Look for any existing transformations from or to this suffix.
-         * XXX: Only do this after a Suff_ClearSuffixes?
-         */
-        Lst_ForEach (transforms, SuffRebuildGraph, (ClientData)s);
+        s = (Suff *) emalloc (sizeof (Suff));
+
+        s->name =       estrdup (str);
+        s->nameLen =    strlen (s->name);
+        s->searchPath = Lst_Init (FALSE);
+        s->children =   Lst_Init (FALSE);
+        s->parents =    Lst_Init (FALSE);
+        s->ref =        Lst_Init (FALSE);
+        s->sNum =       sNum++;
+        s->flags =      0;
+        s->refCount =   0;
+
+        (void)Lst_AtEnd (sufflist, (ClientData)s);
+        /*
+         * Look for any existing transformations from or to this suffix.
+         * XXX: Only do this after a Suff_ClearSuffixes?
+         */
+        Lst_ForEach (transforms, SuffRebuildGraph, (ClientData)s);
     }
 }
@@ -828 +830 @@
  *-----------------------------------------------------------------------
  * Suff_GetPath --
- *      Return the search path for the given suffix, if it's defined.
- *
- * Results:
- *      The searchPath for the desired suffix or NILLST if the suffix isn't
- *      defined.
- *
- * Side Effects:
- *      None
+ *      Return the search path for the given suffix, if it's defined.
+ *
+ * Results:
+ *      The searchPath for the desired suffix or NILLST if the suffix isn't
+ *      defined.
+ *
+ * Side Effects:
+ *      None
  *-----------------------------------------------------------------------
  */
 Lst
 Suff_GetPath (sname)
-    char          *sname;
-{
-    LstNode       ln;
-    Suff          *s;
+    char          *sname;
+{
+    LstNode       ln;
+    Suff          *s;
 
     ln = Lst_Find (sufflist, (ClientData)sname, SuffSuffHasNameP);
     if (ln == NILLNODE) {
-        return (NILLST);
+        return (NILLST);
     } else {
-        s = (Suff *) Lst_Datum (ln);
-        return (s->searchPath);
+        s = (Suff *) Lst_Datum (ln);
+        return (s->searchPath);
     }
 }
@@ -857 +859 @@
  *-----------------------------------------------------------------------
  * Suff_DoPaths --
- *      Extend the search paths for all suffixes to include the default
- *      search path.
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      The searchPath field of all the suffixes is extended by the
- *      directories in dirSearchPath. If paths were specified for the
- *      ".h" suffix, the directories are stuffed into a global variable
- *      called ".INCLUDES" with each directory preceeded by a -I. The same
- *      is done for the ".a" suffix, except the variable is called
- *      ".LIBS" and the flag is -L.
+ *      Extend the search paths for all suffixes to include the default
+ *      search path.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      The searchPath field of all the suffixes is extended by the
+ *      directories in dirSearchPath. If paths were specified for the
+ *      ".h" suffix, the directories are stuffed into a global variable
+ *      called ".INCLUDES" with each directory preceeded by a -I. The same
+ *      is done for the ".a" suffix, except the variable is called
+ *      ".LIBS" and the flag is -L.
  *-----------------------------------------------------------------------
  */
@@ -875 +877 @@
 Suff_DoPaths()
 {
-    register Suff       *s;
-    register LstNode    ln;
-    char                *ptr;
-    Lst                 inIncludes; /* Cumulative .INCLUDES path */
-    Lst                 inLibs;     /* Cumulative .LIBS path */
+    register Suff       *s;
+    register LstNode    ln;
+    char                *ptr;
+    Lst                 inIncludes; /* Cumulative .INCLUDES path */
+    Lst                 inLibs;     /* Cumulative .LIBS path */
 
     if (Lst_Open (sufflist) == FAILURE) {
-        return;
+        return;
     }
 
@@ -889 +891 @@
 
     while ((ln = Lst_Next (sufflist)) != NILLNODE) {
-        s = (Suff *) Lst_Datum (ln);
-        if (!Lst_IsEmpty (s->searchPath)) {
+        s = (Suff *) Lst_Datum (ln);
+        if (!Lst_IsEmpty (s->searchPath)) {
 #ifdef INCLUDES
-            if (s->flags & SUFF_INCLUDE) {
-                Dir_Concat(inIncludes, s->searchPath);
-            }
+            if (s->flags & SUFF_INCLUDE) {
+                Dir_Concat(inIncludes, s->searchPath);
+            }
 #endif /* INCLUDES */
 #ifdef USE_ARCHIVES
 #ifdef LIBRARIES
-            if (s->flags & SUFF_LIBRARY) {
-                Dir_Concat(inLibs, s->searchPath);
-            }
+            if (s->flags & SUFF_LIBRARY) {
+                Dir_Concat(inLibs, s->searchPath);
+            }
 #endif /* LIBRARIES */
 #endif
-            Dir_Concat(s->searchPath, dirSearchPath);
-        } else {
-            Lst_Destroy (s->searchPath, Dir_Destroy);
-            s->searchPath = Lst_Duplicate(dirSearchPath, Dir_CopyDir);
-        }
+            Dir_Concat(s->searchPath, dirSearchPath);
+        } else {
+            Lst_Destroy (s->searchPath, Dir_Destroy);
+            s->searchPath = Lst_Duplicate(dirSearchPath, Dir_CopyDir);
+        }
     }
 
@@ -924 +926 @@
  *-----------------------------------------------------------------------
  * Suff_AddInclude --
- *      Add the given suffix as a type of file which gets included.
- *      Called from the parse module when a .INCLUDES line is parsed.
- *      The suffix must have already been defined.
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      The SUFF_INCLUDE bit is set in the suffix's flags field
+ *      Add the given suffix as a type of file which gets included.
+ *      Called from the parse module when a .INCLUDES line is parsed.
+ *      The suffix must have already been defined.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      The SUFF_INCLUDE bit is set in the suffix's flags field
  *
  *-----------------------------------------------------------------------
@@ -938 +940 @@
 void
 Suff_AddInclude (sname)
-    char          *sname;     /* Name of suffix to mark */
-{
-    LstNode       ln;
-    Suff          *s;
+    char          *sname;     /* Name of suffix to mark */
+{
+    LstNode       ln;
+    Suff          *s;
 
     ln = Lst_Find (sufflist, (ClientData)sname, SuffSuffHasNameP);
     if (ln != NILLNODE) {
-        s = (Suff *) Lst_Datum (ln);
-        s->flags |= SUFF_INCLUDE;
+        s = (Suff *) Lst_Datum (ln);
+        s->flags |= SUFF_INCLUDE;
     }
 }
@@ -954 +956 @@
  *-----------------------------------------------------------------------
  * Suff_AddLib --
- *      Add the given suffix as a type of file which is a library.
- *      Called from the parse module when parsing a .LIBS line. The
- *      suffix must have been defined via .SUFFIXES before this is
- *      called.
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      The SUFF_LIBRARY bit is set in the suffix's flags field
+ *      Add the given suffix as a type of file which is a library.
+ *      Called from the parse module when parsing a .LIBS line. The
+ *      suffix must have been defined via .SUFFIXES before this is
+ *      called.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      The SUFF_LIBRARY bit is set in the suffix's flags field
  *
  *-----------------------------------------------------------------------
@@ -969 +971 @@
 void
 Suff_AddLib (sname)
-    char          *sname;     /* Name of suffix to mark */
-{
-    LstNode       ln;
-    Suff          *s;
+    char          *sname;     /* Name of suffix to mark */
+{
+    LstNode       ln;
+    Suff          *s;
 
     ln = Lst_Find (sufflist, (ClientData)sname, SuffSuffHasNameP);
     if (ln != NILLNODE) {
-        s = (Suff *) Lst_Datum (ln);
-        s->flags |= SUFF_LIBRARY;
+        s = (Suff *) Lst_Datum (ln);
+        s->flags |= SUFF_LIBRARY;
     }
 }
 #endif /* USE_ARCHIVES */
 
-          /********** Implicit Source Search Functions *********/
+          /********** Implicit Source Search Functions *********/
 
 /*-
  *-----------------------------------------------------------------------
  * SuffAddSrc  --
- *      Add a suffix as a Src structure to the given list with its parent
- *      being the given Src structure. If the suffix is the null suffix,
- *      the prefix is used unaltered as the file name in the Src structure.
- *
- * Results:
- *      always returns 0
- *
- * Side Effects:
- *      A Src structure is created and tacked onto the end of the list
+ *      Add a suffix as a Src structure to the given list with its parent
+ *      being the given Src structure. If the suffix is the null suffix,
+ *      the prefix is used unaltered as the file name in the Src structure.
+ *
+ * Results:
+ *      always returns 0
+ *
+ * Side Effects:
+ *      A Src structure is created and tacked onto the end of the list
  *-----------------------------------------------------------------------
  */
 static int
 SuffAddSrc (sp, lsp)
-    ClientData  sp;         /* suffix for which to create a Src structure */
-    ClientData  lsp;        /* list and parent for the new Src */
-{
-    Suff        *s = (Suff *) sp;
+    ClientData  sp;         /* suffix for which to create a Src structure */
+    ClientData  lsp;        /* list and parent for the new Src */
+{
+    Suff        *s = (Suff *) sp;
     LstSrc      *ls = (LstSrc *) lsp;
-    Src         *s2;        /* new Src structure */
-    Src         *targ;      /* Target structure */
+    Src         *s2;        /* new Src structure */
+    Src         *targ;      /* Target structure */
 
     targ = ls->s;
 
     if ((s->flags & SUFF_NULL) && (*s->name != '\0')) {
-        /*
-         * If the suffix has been marked as the NULL suffix, also create a Src
-         * structure for a file with no suffix attached. Two birds, and all
-         * that...
-         */
-        s2 = (Src *) emalloc (sizeof (Src));
-        s2->file =      estrdup(targ->pref);
-        s2->pref =      targ->pref;
-        s2->parent =    targ;
-        s2->node =      NILGNODE;
-        s2->suff =      s;
-        s->refCount++;
-        s2->children =  0;
-        targ->children += 1;
-        (void)Lst_AtEnd (ls->l, (ClientData)s2);
+        /*
+         * If the suffix has been marked as the NULL suffix, also create a Src
+         * structure for a file with no suffix attached. Two birds, and all
+         * that...
+         */
+        s2 = (Src *) emalloc (sizeof (Src));
+        s2->file =      estrdup(targ->pref);
+        s2->pref =      targ->pref;
+        s2->parent =    targ;
+        s2->node =      NILGNODE;
+        s2->suff =      s;
+        s->refCount++;
+        s2->children =  0;
+        targ->children += 1;
+        (void)Lst_AtEnd (ls->l, (ClientData)s2);
 #ifdef DEBUG_SRC
-        s2->cp = Lst_Init(FALSE);
-        Lst_AtEnd(targ->cp, (ClientData) s2);
-        printf("1 add %x %x to %x:", targ, s2, ls->l);
-        Lst_ForEach(ls->l, PrintAddr, (ClientData) 0);
-        printf("\n");
+        s2->cp = Lst_Init(FALSE);
+        Lst_AtEnd(targ->cp, (ClientData) s2);
+        printf("1 add %x %x to %x:", targ, s2, ls->l);
+        Lst_ForEach(ls->l, PrintAddr, (ClientData) 0);
+        printf("\n");
 #endif
     }
     s2 = (Src *) emalloc (sizeof (Src));
-    s2->file =      str_concat (targ->pref, s->name, 0);
-    s2->pref =      targ->pref;
+    s2->file =      str_concat (targ->pref, s->name, 0);
+    s2->pref =      targ->pref;
     s2->parent =    targ;
-    s2->node =      NILGNODE;
-    s2->suff =      s;
+    s2->node =      NILGNODE;
+    s2->suff =      s;
     s->refCount++;
     s2->children =  0;
@@ -1058 +1060 @@
  *-----------------------------------------------------------------------
  * SuffAddLevel  --
- *      Add all the children of targ as Src structures to the given list
- *
- * Results:
- *      None
- *
- * Side Effects:
- *      Lots of structures are created and added to the list
+ *      Add all the children of targ as Src structures to the given list
+ *
+ * Results:
+ *      None
+ *
+ * Side Effects:
+ *      Lots of structures are created and added to the list
  *-----------------------------------------------------------------------
  */
 static void
 SuffAddLevel (l, targ)
-    Lst            l;           /* list to which to add the new level */
-    Src            *targ;       /* Src structure to use as the parent */
+    Lst            l;           /* list to which to add the new level */
+    Src            *targ;       /* Src structure to use as the parent */
 {
     LstSrc         ls;
@@ -1083 +1085 @@
  *----------------------------------------------------------------------
  * SuffRemoveSrc --
- *      Free all src structures in list that don't have a reference count
- *
- * Results:
- *      Ture if an src was removed
- *
- * Side Effects:
- *      The memory is efree'd.
+ *      Free all src structures in list that don't have a reference count
+ *
+ * Results:
+ *      Ture if an src was removed
+ *
+ * Side Effects:
+ *      The memory is efree'd.
  *----------------------------------------------------------------------
  */
@@ -1101 +1103 @@
 
     if (Lst_Open (l) == FAILURE) {
-        return 0;
+        return 0;
     }
 #ifdef DEBUG_SRC
@@ -1111 +1113 @@
 
     while ((ln = Lst_Next (l)) != NILLNODE) {
-        s = (Src *) Lst_Datum (ln);
-        if (s->children == 0) {
-            efree ((Address)s->file);
-            if (!s->parent)
-                efree((Address)s->pref);
-            else {
+        s = (Src *) Lst_Datum (ln);
+        if (s->children == 0) {
+            efree ((Address)s->file);
+            if (!s->parent)
+                efree((Address)s->pref);
+            else {
 #ifdef DEBUG_SRC
-                LstNode ln = Lst_Member(s->parent->cp, (ClientData)s);
-                if (ln != NILLNODE)
-                    Lst_Remove(s->parent->cp, ln);
+                LstNode ln = Lst_Member(s->parent->cp, (ClientData)s);
+                if (ln != NILLNODE)
+                    Lst_Remove(s->parent->cp, ln);
 #endif
-                --s->parent->children;
-            }
+                --s->parent->children;
+            }
 #ifdef DEBUG_SRC
-            printf("efree: [l=%x] p=%x %d\n", l, s, s->children);
-            Lst_Destroy(s->cp, NOFREE);
+            printf("efree: [l=%x] p=%x %d\n", l, s, s->children);
+            Lst_Destroy(s->cp, NOFREE);
 #endif
-            Lst_Remove(l, ln);
-            efree ((Address)s);
-            t |= 1;
-            Lst_Close(l);
-            return TRUE;
-        }
+            Lst_Remove(l, ln);
+            efree ((Address)s);
+            t |= 1;
+            Lst_Close(l);
+            return TRUE;
+        }
 #ifdef DEBUG_SRC
-        else {
-            printf("keep: [l=%x] p=%x %d: ", l, s, s->children);
-            Lst_ForEach(s->cp, PrintAddr, (ClientData) 0);
-            printf("\n");
-        }
+        else {
+            printf("keep: [l=%x] p=%x %d: ", l, s, s->children);
+            Lst_ForEach(s->cp, PrintAddr, (ClientData) 0);
+            printf("\n");
+        }
 #endif
     }
@@ -1151 +1153 @@
  *-----------------------------------------------------------------------
  * SuffFindThem --
- *      Find the first existing file/target in the list srcs
- *
- * Results:
- *      The lowest structure in the chain of transformations
- *
- * Side Effects:
- *      None
+ *      Find the first existing file/target in the list srcs
+ *
+ * Results:
+ *      The lowest structure in the chain of transformations
+ *
+ * Side Effects:
+ *      None
  *-----------------------------------------------------------------------
  */
 static Src *
 SuffFindThem (srcs, slst)
-    Lst            srcs;        /* list of Src structures to search through */
-    Lst            slst;
-{
-    Src            *s;          /* current Src */
-    Src            *rs;         /* returned Src */
-    char           *ptr;
+    Lst            srcs;        /* list of Src structures to search through */
+    Lst            slst;
+{
+    Src            *s;          /* current Src */
+    Src            *rs;         /* returned Src */
+    char           *ptr;
 
     rs = (Src *) NULL;
 
     while (!Lst_IsEmpty (srcs)) {
-        s = (Src *) Lst_DeQueue (srcs);
-
-        if (DEBUG(SUFF)) {
-            printf ("\ttrying %s...", s->file);
-        }
-
-        /*
-         * A file is considered to exist if either a node exists in the
-         * graph for it or the file actually exists.
-         */
-        if (Targ_FindNode(s->file, TARG_NOCREATE) != NILGNODE) {
+        s = (Src *) Lst_DeQueue (srcs);
+
+        if (DEBUG(SUFF)) {
+            printf ("\ttrying %s...", s->file);
+        }
+
+        /*
+         * A file is considered to exist if either a node exists in the
+         * graph for it or the file actually exists.
+         */
+        if (Targ_FindNode(s->file, TARG_NOCREATE) != NILGNODE) {
 #ifdef DEBUG_SRC
-            printf("remove %x from %x\n", s, srcs);
+            printf("remove %x from %x\n", s, srcs);
 #endif
-            rs = s;
-            break;
-        }
-
-        if ((ptr = Dir_FindFile (s->file, s->suff->searchPath)) != NULL) {
-            rs = s;
+            rs = s;
+            break;
+        }
+
+        if ((ptr = Dir_FindFile (s->file, s->suff->searchPath)) != NULL) {
+            rs = s;
 #ifdef DEBUG_SRC
-            printf("remove %x from %x\n", s, srcs);
+            printf("remove %x from %x\n", s, srcs);
 #endif
-            efree(ptr);
-            break;
-        }
-
-        if (DEBUG(SUFF)) {
-            printf ("not there\n");
-        }
-
-        SuffAddLevel (srcs, s);
-        Lst_AtEnd(slst, (ClientData) s);
+            efree(ptr);
+            break;
+        }
+
+        if (DEBUG(SUFF)) {
+            printf ("not there\n");
+        }
+
+        SuffAddLevel (srcs, s);
+        Lst_AtEnd(slst, (ClientData) s);
     }
 
     if (DEBUG(SUFF) && rs) {
-        printf ("got it\n");
+        printf ("got it\n");
     }
     return (rs);
@@ -1216 +1218 @@
  *-----------------------------------------------------------------------
  * SuffFindCmds --
- *      See if any of the children of the target in the Src structure is
- *      one from which the target can be transformed. If there is one,
- *      a Src structure is put together for it and returned.
- *
- * Results:
- *      The Src structure of the "winning" child, or NIL if no such beast.
- *
- * Side Effects:
- *      A Src structure may be allocated.
+ *      See if any of the children of the target in the Src structure is
+ *      one from which the target can be transformed. If there is one,
+ *      a Src structure is put together for it and returned.
+ *
+ * Results:
+ *      The Src structure of the "winning" child, or NIL if no such beast.
+ *
+ * Side Effects:
+ *      A Src structure may be allocated.
  *
  *-----------------------------------------------------------------------
@@ -1230 +1232 @@
 static Src *
 SuffFindCmds (targ, slst)
-    Src         *targ;  /* Src structure to play with */
-    Lst         slst;
-{
-    LstNode             ln;     /* General-purpose list node */
-    register GNode      *t,     /* Target GNode */
-                        *s;     /* Source GNode */
-    int                 prefLen;/* The length of the defined prefix */
-    Suff                *suff;  /* Suffix on matching beastie */
-    Src                 *ret;   /* Return value */
-    char                *cp;
+    Src         *targ;  /* Src structure to play with */
+    Lst         slst;
+{
+    LstNode             ln;     /* General-purpose list node */
+    register GNode      *t,     /* Target GNode */
+                        *s;     /* Source GNode */
+    int                 prefLen;/* The length of the defined prefix */
+    Suff                *suff;  /* Suffix on matching beastie */
+    Src                 *ret;   /* Return value */
+    char                *cp;
 
     t = targ->node;
@@ -1246 +1248 @@
 
     while ((ln = Lst_Next (t->children)) != NILLNODE) {
-        s = (GNode *)Lst_Datum (ln);
-
-        cp = strrchr (s->name, '/');
-        if (cp == (char *)NULL) {
-            cp = s->name;
-        } else {
-            cp++;
-        }
-        if (strncmp (cp, targ->pref, prefLen) == 0) {
-            /*
-             * The node matches the prefix ok, see if it has a known
-             * suffix.
-             */
-            ln = Lst_Find (sufflist, (ClientData)&cp[prefLen],
-                           SuffSuffHasNameP);
-            if (ln != NILLNODE) {
-                /*
-                 * It even has a known suffix, see if there's a transformation
-                 * defined between the node's suffix and the target's suffix.
-                 *
-                 * XXX: Handle multi-stage transformations here, too.
-                 */
-                suff = (Suff *)Lst_Datum (ln);
-
-                if (Lst_Member (suff->parents,
-                                (ClientData)targ->suff) != NILLNODE)
-                {
-                    /*
-                     * Hot Damn! Create a new Src structure to describe
-                     * this transformation (making sure to duplicate the
-                     * source node's name so Suff_FindDeps can efree it
-                     * again (ick)), and return the new structure.
-                     */
-                    ret = (Src *)emalloc (sizeof (Src));
-                    ret->file = estrdup(s->name);
-                    ret->pref = targ->pref;
-                    ret->suff = suff;
-                    suff->refCount++;
-                    ret->parent = targ;
-                    ret->node = s;
-                    ret->children = 0;
-                    targ->children += 1;
+        s = (GNode *)Lst_Datum (ln);
+
+        cp = strrchr (s->name, '/');
+        if (cp == (char *)NULL) {
+            cp = s->name;
+        } else {
+            cp++;
+        }
+        if (strncmp (cp, targ->pref, prefLen) == 0) {
+            /*
+             * The node matches the prefix ok, see if it has a known
+             * suffix.
+             */
+            ln = Lst_Find (sufflist, (ClientData)&cp[prefLen],
+                           SuffSuffHasNameP);
+            if (ln != NILLNODE) {
+                /*
+                 * It even has a known suffix, see if there's a transformation
+                 * defined between the node's suffix and the target's suffix.
+                 *
+                 * XXX: Handle multi-stage transformations here, too.
+                 */
+                suff = (Suff *)Lst_Datum (ln);
+
+                if (Lst_Member (suff->parents,
+                                (ClientData)targ->suff) != NILLNODE)
+                {
+                    /*
+                     * Hot Damn! Create a new Src structure to describe
+                     * this transformation (making sure to duplicate the
+                     * source node's name so Suff_FindDeps can efree it
+                     * again (ick)), and return the new structure.
+                     */
+                    ret = (Src *)emalloc (sizeof (Src));
+                    ret->file = estrdup(s->name);
+                    ret->pref = targ->pref;
+                    ret->suff = suff;
+                    suff->refCount++;
+                    ret->parent = targ;
+                    ret->node = s;
+                    ret->children = 0;
+                    targ->children += 1;
 #ifdef DEBUG_SRC
-                    ret->cp = Lst_Init(FALSE);
-                    printf("3 add %x %x\n", targ, ret);
-                    Lst_AtEnd(targ->cp, (ClientData) ret);
+                    ret->cp = Lst_Init(FALSE);
+                    printf("3 add %x %x\n", targ, ret);
+                    Lst_AtEnd(targ->cp, (ClientData) ret);
 #endif
-                    Lst_AtEnd(slst, (ClientData) ret);
-                    if (DEBUG(SUFF)) {
-                        printf ("\tusing existing source %s\n", s->name);
-                    }
-                    return (ret);
-                }
-            }
-        }
+                    Lst_AtEnd(slst, (ClientData) ret);
+                    if (DEBUG(SUFF)) {
+                        printf ("\tusing existing source %s\n", s->name);
+                    }
+                    return (ret);
+                }
+            }
+        }
     }
     Lst_Close (t->children);
@@ -1309 +1311 @@
  *-----------------------------------------------------------------------
  * SuffExpandChildren --
- *      Expand the names of any children of a given node that contain
- *      variable invocations or file wildcards into actual targets.
- *
- * Results:
- *      === 0 (continue)
- *
- * Side Effects:
- *      The expanded node is removed from the parent's list of children,
- *      and the parent's unmade counter is decremented, but other nodes
- *      may be added.
+ *      Expand the names of any children of a given node that contain
+ *      variable invocations or file wildcards into actual targets.
+ *
+ * Results:
+ *      === 0 (continue)
+ *
+ * Side Effects:
+ *      The expanded node is removed from the parent's list of children,
+ *      and the parent's unmade counter is decremented, but other nodes
+ *      may be added.
  *
  *-----------------------------------------------------------------------
@@ -1324 +1326 @@
 static int
 SuffExpandChildren(cgnp, pgnp)
-    ClientData  cgnp;       /* Child to examine */
-    ClientData  pgnp;       /* Parent node being processed */
-{
-    GNode       *cgn = (GNode *) cgnp;
-    GNode       *pgn = (GNode *) pgnp;
-    GNode       *gn;        /* New source 8) */
-    LstNode     prevLN;    /* Node after which new source should be put */
-    LstNode     ln;         /* List element for old source */
-    char        *cp;        /* Expanded value */
+    ClientData  cgnp;       /* Child to examine */
+    ClientData  pgnp;       /* Parent node being processed */
+{
+    GNode       *cgn = (GNode *) cgnp;
+    GNode       *pgn = (GNode *) pgnp;
+    GNode       *gn;        /* New source 8) */
+    LstNode     prevLN;    /* Node after which new source should be put */
+    LstNode     ln;         /* List element for old source */
+    char        *cp;        /* Expanded value */
 
     /*
@@ -1347 +1349 @@
      */
     if (strchr(cgn->name, '$') != (char *)NULL) {
-        if (DEBUG(SUFF)) {
-            printf("Expanding \"%s\"...", cgn->name);
-        }
-        cp = Var_Subst(NULL, cgn->name, pgn, TRUE);
-
-        if (cp != (char *)NULL) {
-            Lst     members = Lst_Init(FALSE);
+        if (DEBUG(SUFF)) {
+            printf("Expanding \"%s\"...", cgn->name);
+        }
+        cp = Var_Subst(NULL, cgn->name, pgn, TRUE);
+
+        if (cp != (char *)NULL) {
+            Lst     members = Lst_Init(FALSE);
 
 #ifdef USE_ARCHIVES
-            if (cgn->type & OP_ARCHV) {
-                /*
-                 * Node was an archive(member) target, so we want to call
-                 * on the Arch module to find the nodes for us, expanding
-                 * variables in the parent's context.
-                 */
-                char    *sacrifice = cp;
-
-                (void)Arch_ParseArchive(&sacrifice, members, pgn);
-            } else
+            if (cgn->type & OP_ARCHV) {
+                /*
+                 * Node was an archive(member) target, so we want to call
+                 * on the Arch module to find the nodes for us, expanding
+                 * variables in the parent's context.
+                 */
+                char    *sacrifice = cp;
+
+                (void)Arch_ParseArchive(&sacrifice, members, pgn);
+            } else
 #endif
             {
-                /*
-                 * Break the result into a vector of strings whose nodes
-                 * we can find, then add those nodes to the members list.
-                 * Unfortunately, we can't use brk_string b/c it
-                 * doesn't understand about variable specifications with
-                 * spaces in them...
-                 */
-                char        *start;
-                char        *initcp = cp;   /* For freeing... */
-
-                for (start = cp; *start == ' ' || *start == '\t'; start++)
-                    continue;
-                for (cp = start; *cp != '\0'; cp++) {
-                    if (*cp == ' ' || *cp == '\t') {
-                        /*
-                         * White-space -- terminate element, find the node,
-                         * add it, skip any further spaces.
-                         */
-                        *cp++ = '\0';
-                        gn = Targ_FindNode(start, TARG_CREATE);
-                        (void)Lst_AtEnd(members, (ClientData)gn);
-                        while (*cp == ' ' || *cp == '\t') {
-                            cp++;
-                        }
-                        /*
-                         * Adjust cp for increment at start of loop, but
-                         * set start to first non-space.
-                         */
-                        start = cp--;
-                    } else if (*cp == '$') {
-                        /*
-                         * Start of a variable spec -- contact variable module
-                         * to find the end so we can skip over it.
-                         */
-                        char    *junk;
-                        int     len;
-                        Boolean doFree;
-
-                        junk = Var_Parse(cp, pgn, TRUE, &len, &doFree);
-                        if (junk != var_Error) {
-                            cp += len - 1;
-                        }
-
-                        if (doFree) {
-                            efree(junk);
-                        }
-                    } else if (*cp == '\\' && *cp != '\0') {
-                        /*
-                         * Escaped something -- skip over it
-                         */
-                        cp++;
-                    }
-                }
-
-                if (cp != start) {
-                    /*
-                     * Stuff left over -- add it to the list too
-                     */
-                    gn = Targ_FindNode(start, TARG_CREATE);
-                    (void)Lst_AtEnd(members, (ClientData)gn);
-                }
-                /*
-                 * Point cp back at the beginning again so the variable value
-                 * can be freed.
-                 */
-                cp = initcp;
-            }
-            /*
-             * Add all elements of the members list to the parent node.
-             */
-            while(!Lst_IsEmpty(members)) {
-                gn = (GNode *)Lst_DeQueue(members);
-
-                if (DEBUG(SUFF)) {
-                    printf("%s...", gn->name);
-                }
-                if (Lst_Member(pgn->children, (ClientData)gn) == NILLNODE) {
-                    (void)Lst_Append(pgn->children, prevLN, (ClientData)gn);
-                    prevLN = Lst_Succ(prevLN);
-                    (void)Lst_AtEnd(gn->parents, (ClientData)pgn);
-                    pgn->unmade++;
-                }
-            }
-            Lst_Destroy(members, NOFREE);
-            /*
-             * Free the result
-             */
-            efree((char *)cp);
-        }
-        /*
-         * Now the source is expanded, remove it from the list of children to
-         * keep it from being processed.
-         */
-        ln = Lst_Member(pgn->children, (ClientData)cgn);
-        pgn->unmade--;
-        Lst_Remove(pgn->children, ln);
-        if (DEBUG(SUFF)) {
-            printf("\n");
-        }
+                /*
+                 * Break the result into a vector of strings whose nodes
+                 * we can find, then add those nodes to the members list.
+                 * Unfortunately, we can't use brk_string b/c it
+                 * doesn't understand about variable specifications with
+                 * spaces in them...
+                 */
+                char        *start;
+                char        *initcp = cp;   /* For freeing... */
+
+                for (start = cp; *start == ' ' || *start == '\t'; start++)
+                    continue;
+                for (cp = start; *cp != '\0'; cp++) {
+                    if (*cp == ' ' || *cp == '\t') {
+                        /*
+                         * White-space -- terminate element, find the node,
+                         * add it, skip any further spaces.
+                         */
+                        *cp++ = '\0';
+                        gn = Targ_FindNode(start, TARG_CREATE);
+                        (void)Lst_AtEnd(members, (ClientData)gn);
+                        while (*cp == ' ' || *cp == '\t') {
+                            cp++;
+                        }
+                        /*
+                         * Adjust cp for increment at start of loop, but
+                         * set start to first non-space.
+                         */
+                        start = cp--;
+                    } else if (*cp == '$') {
+                        /*
+                         * Start of a variable spec -- contact variable module
+                         * to find the end so we can skip over it.
+                         */
+                        char    *junk;
+                        int     len;
+                        Boolean doFree;
+
+                        junk = Var_Parse(cp, pgn, TRUE, &len, &doFree);
+                        if (junk != var_Error) {
+                            cp += len - 1;
+                        }
+
+                        if (doFree) {
+                            efree(junk);
+                        }
+                    } else if (*cp == '\\' && *cp != '\0') {
+                        /*
+                         * Escaped something -- skip over it
+                         */
+                        cp++;
+                    }
+                }
+
+                if (cp != start) {
+                    /*
+                     * Stuff left over -- add it to the list too
+                     */
+                    gn = Targ_FindNode(start, TARG_CREATE);
+                    (void)Lst_AtEnd(members, (ClientData)gn);
+                }
+                /*
+                 * Point cp back at the beginning again so the variable value
+                 * can be freed.
+                 */
+                cp = initcp;
+            }
+            /*
+             * Add all elements of the members list to the parent node.
+             */
+            while(!Lst_IsEmpty(members)) {
+                gn = (GNode *)Lst_DeQueue(members);
+
+                if (DEBUG(SUFF)) {
+                    printf("%s...", gn->name);
+                }
+                if (Lst_Member(pgn->children, (ClientData)gn) == NILLNODE) {
+                    (void)Lst_Append(pgn->children, prevLN, (ClientData)gn);
+                    prevLN = Lst_Succ(prevLN);
+                    (void)Lst_AtEnd(gn->parents, (ClientData)pgn);
+                    pgn->unmade++;
+                }
+            }
+            Lst_Destroy(members, NOFREE);
+            /*
+             * Free the result
+             */
+            efree((char *)cp);
+        }
+        /*
+         * Now the source is expanded, remove it from the list of children to
+         * keep it from being processed.
+         */
+        ln = Lst_Member(pgn->children, (ClientData)cgn);
+        pgn->unmade--;
+        Lst_Remove(pgn->children, ln);
+        if (DEBUG(SUFF)) {
+            printf("\n");
+        }
     } else if (Dir_HasWildcards(cgn->name)) {
-        Lst     exp;        /* List of expansions */
-        Lst     path;       /* Search path along which to expand */
-
-        /*
-         * Find a path along which to expand the word.
-         *
-         * If the word has a known suffix, use that path.
-         * If it has no known suffix and we're allowed to use the null
-         *   suffix, use its path.
-         * Else use the default system search path.
-         */
-        cp = cgn->name + strlen(cgn->name);
-        ln = Lst_Find(sufflist, (ClientData)cp, SuffSuffIsSuffixP);
-
-        if (DEBUG(SUFF)) {
-            printf("Wildcard expanding \"%s\"...", cgn->name);
-        }
-
-        if (ln != NILLNODE) {
-            Suff    *s = (Suff *)Lst_Datum(ln);
-
-            if (DEBUG(SUFF)) {
-                printf("suffix is \"%s\"...", s->name);
-            }
-            path = s->searchPath;
-        } else {
-            /*
-             * Use default search path
-             */
-            path = dirSearchPath;
-        }
-
-        /*
-         * Expand the word along the chosen path
-         */
-        exp = Lst_Init(FALSE);
-        Dir_Expand(cgn->name, path, exp);
-
-        while (!Lst_IsEmpty(exp)) {
-            /*
-             * Fetch next expansion off the list and find its GNode
-             */
-            cp = (char *)Lst_DeQueue(exp);
-
-            if (DEBUG(SUFF)) {
-                printf("%s...", cp);
-            }
-            gn = Targ_FindNode(cp, TARG_CREATE);
-
-            /*
-             * If gn isn't already a child of the parent, make it so and
-             * up the parent's count of unmade children.
-             */
-            if (Lst_Member(pgn->children, (ClientData)gn) == NILLNODE) {
-                (void)Lst_Append(pgn->children, prevLN, (ClientData)gn);
-                prevLN = Lst_Succ(prevLN);
-                (void)Lst_AtEnd(gn->parents, (ClientData)pgn);
-                pgn->unmade++;
-            }
-        }
-
-        /*
-         * Nuke what's left of the list
-         */
-        Lst_Destroy(exp, NOFREE);
-
-        /*
-         * Now the source is expanded, remove it from the list of children to
-         * keep it from being processed.
-         */
-        ln = Lst_Member(pgn->children, (ClientData)cgn);
-        pgn->unmade--;
-        Lst_Remove(pgn->children, ln);
-        if (DEBUG(SUFF)) {
-            printf("\n");
-        }
+        Lst     exp;        /* List of expansions */
+        Lst     path;       /* Search path along which to expand */
+
+        /*
+         * Find a path along which to expand the word.
+         *
+         * If the word has a known suffix, use that path.
+         * If it has no known suffix and we're allowed to use the null
+         *   suffix, use its path.
+         * Else use the default system search path.
+         */
+        cp = cgn->name + strlen(cgn->name);
+        ln = Lst_Find(sufflist, (ClientData)cp, SuffSuffIsSuffixP);
+
+        if (DEBUG(SUFF)) {
+            printf("Wildcard expanding \"%s\"...", cgn->name);
+        }
+
+        if (ln != NILLNODE) {
+            Suff    *s = (Suff *)Lst_Datum(ln);
+
+            if (DEBUG(SUFF)) {
+                printf("suffix is \"%s\"...", s->name);
+            }
+            path = s->searchPath;
+        } else {
+            /*
+             * Use default search path
+             */
+            path = dirSearchPath;
+        }
+
+        /*
+         * Expand the word along the chosen path
+         */
+        exp = Lst_Init(FALSE);
+        Dir_Expand(cgn->name, path, exp);
+
+        while (!Lst_IsEmpty(exp)) {
+            /*
+             * Fetch next expansion off the list and find its GNode
+             */
+            cp = (char *)Lst_DeQueue(exp);
+
+            if (DEBUG(SUFF)) {
+                printf("%s...", cp);
+            }
+            gn = Targ_FindNode(cp, TARG_CREATE);
+
+            /*
+             * If gn isn't already a child of the parent, make it so and
+             * up the parent's count of unmade children.
+             */
+            if (Lst_Member(pgn->children, (ClientData)gn) == NILLNODE) {
+                (void)Lst_Append(pgn->children, prevLN, (ClientData)gn);
+                prevLN = Lst_Succ(prevLN);
+                (void)Lst_AtEnd(gn->parents, (ClientData)pgn);
+                pgn->unmade++;
+            }
+        }
+
+        /*
+         * Nuke what's left of the list
+         */
+        Lst_Destroy(exp, NOFREE);
+
+        /*
+         * Now the source is expanded, remove it from the list of children to
+         * keep it from being processed.
+         */
+        ln = Lst_Member(pgn->children, (ClientData)cgn);
+        pgn->unmade--;
+        Lst_Remove(pgn->children, ln);
+        if (DEBUG(SUFF)) {
+            printf("\n");
+        }
     }
 
@@ -1552 +1554 @@
  *-----------------------------------------------------------------------
  * SuffApplyTransform --
- *      Apply a transformation rule, given the source and target nodes
- *      and suffixes.
- *
- * Results:
- *      TRUE if successful, FALSE if not.
- *
- * Side Effects:
- *      The source and target are linked and the commands from the
- *      transformation are added to the target node's commands list.
- *      All attributes but OP_DEPMASK and OP_TRANSFORM are applied
- *      to the target. The target also inherits all the sources for
- *      the transformation rule.
+ *      Apply a transformation rule, given the source and target nodes
+ *      and suffixes.
+ *
+ * Results:
+ *      TRUE if successful, FALSE if not.
+ *
+ * Side Effects:
+ *      The source and target are linked and the commands from the
+ *      transformation are added to the target node's commands list.
+ *      All attributes but OP_DEPMASK and OP_TRANSFORM are applied
+ *      to the target. The target also inherits all the sources for
+ *      the transformation rule.
  *
  *-----------------------------------------------------------------------
@@ -1569 +1571 @@
 static Boolean
 SuffApplyTransform(tGn, sGn, t, s)
-    GNode       *tGn;       /* Target node */
-    GNode       *sGn;       /* Source node */
-    Suff        *t;         /* Target suffix */
-    Suff        *s;         /* Source suffix */
-{
-    LstNode     ln;         /* General node */
-    char        *tname;     /* Name of transformation rule */
-    GNode       *gn;        /* Node for same */
+    GNode       *tGn;       /* Target node */
+    GNode       *sGn;       /* Source node */
+    Suff        *t;         /* Target suffix */
+    Suff        *s;         /* Source suffix */
+{
+    LstNode     ln;         /* General node */
+    char        *tname;     /* Name of transformation rule */
+    GNode       *gn;        /* Node for same */
 
     if (Lst_Member(tGn->children, (ClientData)sGn) == NILLNODE) {
-        /*
-         * Not already linked, so form the proper links between the
-         * target and source.
-         */
-        (void)Lst_AtEnd(tGn->children, (ClientData)sGn);
-        (void)Lst_AtEnd(sGn->parents, (ClientData)tGn);
-        tGn->unmade += 1;
+        /*
+         * Not already linked, so form the proper links between the
+         * target and source.
+         */
+        (void)Lst_AtEnd(tGn->children, (ClientData)sGn);
+        (void)Lst_AtEnd(sGn->parents, (ClientData)tGn);
+        tGn->unmade += 1;
     }
 
     if ((sGn->type & OP_OPMASK) == OP_DOUBLEDEP) {
-        /*
-         * When a :: node is used as the implied source of a node, we have
-         * to link all its cohorts in as sources as well. Only the initial
-         * sGn gets the target in its iParents list, however, as that
-         * will be sufficient to get the .IMPSRC variable set for tGn
-         */
-        for (ln=Lst_First(sGn->cohorts); ln != NILLNODE; ln=Lst_Succ(ln)) {
-            gn = (GNode *)Lst_Datum(ln);
-
-            if (Lst_Member(tGn->children, (ClientData)gn) == NILLNODE) {
-                /*
-                 * Not already linked, so form the proper links between the
-                 * target and source.
-                 */
-                (void)Lst_AtEnd(tGn->children, (ClientData)gn);
-                (void)Lst_AtEnd(gn->parents, (ClientData)tGn);
-                tGn->unmade += 1;
-            }
-        }
+        /*
+         * When a :: node is used as the implied source of a node, we have
+         * to link all its cohorts in as sources as well. Only the initial
+         * sGn gets the target in its iParents list, however, as that
+         * will be sufficient to get the .IMPSRC variable set for tGn
+         */
+        for (ln=Lst_First(sGn->cohorts); ln != NILLNODE; ln=Lst_Succ(ln)) {
+            gn = (GNode *)Lst_Datum(ln);
+
+            if (Lst_Member(tGn->children, (ClientData)gn) == NILLNODE) {
+                /*
+                 * Not already linked, so form the proper links between the
+                 * target and source.
+                 */
+                (void)Lst_AtEnd(tGn->children, (ClientData)gn);
+                (void)Lst_AtEnd(gn->parents, (ClientData)tGn);
+                tGn->unmade += 1;
+            }
+        }
     }
     /*
@@ -1617 +1619 @@
 
     if (ln == NILLNODE) {
-        /*
-         * Not really such a transformation rule (can happen when we're
-         * called to link an OP_MEMBER and OP_ARCHV node), so return
-         * FALSE.
-         */
-        return(FALSE);
+        /*
+         * Not really such a transformation rule (can happen when we're
+         * called to link an OP_MEMBER and OP_ARCHV node), so return
+         * FALSE.
+         */
+        return(FALSE);
     }
 
@@ -1628 +1630 @@
 
     if (DEBUG(SUFF)) {
-        printf("\tapplying %s -> %s to \"%s\"\n", s->name, t->name, tGn->name);
+        printf("\tapplying %s -> %s to \"%s\"\n", s->name, t->name, tGn->name);
     }
 
@@ -1646 +1648 @@
     ln = Lst_Succ(ln);
     if (ln != NILLNODE) {
-        Lst_ForEachFrom(tGn->children, ln,
-                        SuffExpandChildren, (ClientData)tGn);
+        Lst_ForEachFrom(tGn->children, ln,
+                        SuffExpandChildren, (ClientData)tGn);
     }
 
@@ -1664 +1666 @@
  *-----------------------------------------------------------------------
  * SuffFindArchiveDeps --
- *      Locate dependencies for an OP_ARCHV node.
- *
- * Results:
- *      None
- *
- * Side Effects:
- *      Same as Suff_FindDeps
+ *      Locate dependencies for an OP_ARCHV node.
+ *
+ * Results:
+ *      None
+ *
+ * Side Effects:
+ *      Same as Suff_FindDeps
  *
  *-----------------------------------------------------------------------
@@ -1676 +1678 @@
 static void
 SuffFindArchiveDeps(gn, slst)
-    GNode       *gn;        /* Node for which to locate dependencies */
-    Lst         slst;
-{
-    char        *eoarch;    /* End of archive portion */
-    char        *eoname;    /* End of member portion */
-    GNode       *mem;       /* Node for member */
-    static char *copy[] = { /* Variables to be copied from the member node */
-        TARGET,             /* Must be first */
-        PREFIX,             /* Must be second */
+    GNode       *gn;        /* Node for which to locate dependencies */
+    Lst         slst;
+{
+    char        *eoarch;    /* End of archive portion */
+    char        *eoname;    /* End of member portion */
+    GNode       *mem;       /* Node for member */
+    static char *copy[] = { /* Variables to be copied from the member node */
+        TARGET,             /* Must be first */
+        PREFIX,             /* Must be second */
     };
-    int         i;          /* Index into copy and vals */
-    Suff        *ms;        /* Suffix descriptor for member */
-    char        *name;      /* Start of member's name */
+    int         i;          /* Index into copy and vals */
+    Suff        *ms;        /* Suffix descriptor for member */
+    char        *name;      /* Start of member's name */
 
     /*
@@ -1697 +1699 @@
     eoname = strchr (eoarch, ')');
 
-    *eoname = '\0';       /* Nuke parentheses during suffix search */
-    *eoarch = '\0';       /* So a suffix can be found */
+    *eoname = '\0';       /* Nuke parentheses during suffix search */
+    *eoarch = '\0';       /* So a suffix can be found */
 
     name = eoarch + 1;
@@ -1716 +1718 @@
      */
     if (Lst_Member(gn->children, (ClientData)mem) == NILLNODE) {
-        (void)Lst_AtEnd(gn->children, (ClientData)mem);
-        (void)Lst_AtEnd(mem->parents, (ClientData)gn);
-        gn->unmade += 1;
+        (void)Lst_AtEnd(gn->children, (ClientData)mem);
+        (void)Lst_AtEnd(mem->parents, (ClientData)gn);
+        gn->unmade += 1;
     }
 
@@ -1725 +1727 @@
      */
     for (i = (sizeof(copy)/sizeof(copy[0]))-1; i >= 0; i--) {
-        char *p1;
-        Var_Set(copy[i], Var_Value(copy[i], mem, &p1), gn);
-        efree(p1);
+        char *p1;
+        Var_Set(copy[i], Var_Value(copy[i], mem, &p1), gn);
+        efree(p1);
 
     }
@@ -1733 +1735 @@
     ms = mem->suffix;
     if (ms == NULL) {
-        /*
-         * Didn't know what it was -- use .NULL suffix if not in make mode
-         */
-        if (DEBUG(SUFF)) {
-            printf("using null suffix\n");
-        }
-        ms = suffNull;
+        /*
+         * Didn't know what it was -- use .NULL suffix if not in make mode
+         */
+        if (DEBUG(SUFF)) {
+            printf("using null suffix\n");
+        }
+        ms = suffNull;
     }
 
@@ -1750 +1752 @@
 
     if (ms != NULL) {
-        /*
-         * Member has a known suffix, so look for a transformation rule from
-         * it to a possible suffix of the archive. Rather than searching
-         * through the entire list, we just look at suffixes to which the
-         * member's suffix may be transformed...
-         */
-        LstNode     ln;
-
-        /*
-         * Use first matching suffix...
-         */
-        ln = Lst_Find(ms->parents, eoarch, SuffSuffIsSuffixP);
-
-        if (ln != NILLNODE) {
-            /*
-             * Got one -- apply it
-             */
-            if (!SuffApplyTransform(gn, mem, (Suff *)Lst_Datum(ln), ms) &&
-                DEBUG(SUFF))
-            {
-                printf("\tNo transformation from %s -> %s\n",
-                       ms->name, ((Suff *)Lst_Datum(ln))->name);
-            }
-        }
+        /*
+         * Member has a known suffix, so look for a transformation rule from
+         * it to a possible suffix of the archive. Rather than searching
+         * through the entire list, we just look at suffixes to which the
+         * member's suffix may be transformed...
+         */
+        LstNode     ln;
+
+        /*
+         * Use first matching suffix...
+         */
+        ln = Lst_Find(ms->parents, eoarch, SuffSuffIsSuffixP);
+
+        if (ln != NILLNODE) {
+            /*
+             * Got one -- apply it
+             */
+            if (!SuffApplyTransform(gn, mem, (Suff *)Lst_Datum(ln), ms) &&
+                DEBUG(SUFF))
+            {
+                printf("\tNo transformation from %s -> %s\n",
+                       ms->name, ((Suff *)Lst_Datum(ln))->name);
+            }
+        }
     }
 
@@ -1788 +1790 @@
      */
     if (OP_NOP(gn->type)) {
-        gn->type |= OP_DEPENDS;
+        gn->type |= OP_DEPENDS;
     }
 
@@ -1802 +1804 @@
  *-----------------------------------------------------------------------
  * SuffFindNormalDeps --
- *      Locate implicit dependencies for regular targets.
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      Same as Suff_FindDeps...
+ *      Locate implicit dependencies for regular targets.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      Same as Suff_FindDeps...
  *
  *-----------------------------------------------------------------------
@@ -1814 +1816 @@
 static void
 SuffFindNormalDeps(gn, slst)
-    GNode       *gn;        /* Node for which to find sources */
-    Lst         slst;
-{
-    char        *eoname;    /* End of name */
-    char        *sopref;    /* Start of prefix */
-    LstNode     ln;         /* Next suffix node to check */
-    Lst         srcs;       /* List of sources at which to look */
-    Lst         targs;      /* List of targets to which things can be
-                             * transformed. They all have the same file,
-                             * but different suff and pref fields */
-    Src         *bottom;    /* Start of found transformation path */
-    Src         *src;       /* General Src pointer */
-    char        *pref;      /* Prefix to use */
-    Src         *targ;      /* General Src target pointer */
+    GNode       *gn;        /* Node for which to find sources */
+    Lst         slst;
+{
+    char        *eoname;    /* End of name */
+    char        *sopref;    /* Start of prefix */
+    LstNode     ln;         /* Next suffix node to check */
+    Lst         srcs;       /* List of sources at which to look */
+    Lst         targs;      /* List of targets to which things can be
+                             * transformed. They all have the same file,
+                             * but different suff and pref fields */
+    Src         *bottom;    /* Start of found transformation path */
+    Src         *src;       /* General Src pointer */
+    char        *pref;      /* Prefix to use */
+    Src         *targ;      /* General Src target pointer */
 
 
@@ -1861 +1863 @@
 
     while (ln != NILLNODE) {
-        /*
-         * Look for next possible suffix...
-         */
-        ln = Lst_FindFrom(sufflist, ln, eoname, SuffSuffIsSuffixP);
-
-        if (ln != NILLNODE) {
-            int     prefLen;        /* Length of the prefix */
-            Src     *targ;
-
-            /*
-             * Allocate a Src structure to which things can be transformed
-             */
-            targ = (Src *)emalloc(sizeof (Src));
-            targ->file = estrdup(gn->name);
-            targ->suff = (Suff *)Lst_Datum(ln);
-            targ->suff->refCount++;
-            targ->node = gn;
-            targ->parent = (Src *)NULL;
-            targ->children = 0;
+        /*
+         * Look for next possible suffix...
+         */
+        ln = Lst_FindFrom(sufflist, ln, eoname, SuffSuffIsSuffixP);
+
+        if (ln != NILLNODE) {
+            int     prefLen;        /* Length of the prefix */
+            Src     *targ;
+
+            /*
+             * Allocate a Src structure to which things can be transformed
+             */
+            targ = (Src *)emalloc(sizeof (Src));
+            targ->file = estrdup(gn->name);
+            targ->suff = (Suff *)Lst_Datum(ln);
+            targ->suff->refCount++;
+            targ->node = gn;
+            targ->parent = (Src *)NULL;
+            targ->children = 0;
 #ifdef DEBUG_SRC
-            targ->cp = Lst_Init(FALSE);
+            targ->cp = Lst_Init(FALSE);
 #endif
 
-            /*
-             * Allocate room for the prefix, whose end is found by subtracting
-             * the length of the suffix from the end of the name.
-             */
-            prefLen = (eoname - targ->suff->nameLen) - sopref;
-            targ->pref = emalloc(prefLen + 1);
-            memcpy(targ->pref, sopref, prefLen);
-            targ->pref[prefLen] = '\0';
-
-            /*
-             * Add nodes from which the target can be made
-             */
-            SuffAddLevel(srcs, targ);
-
-            /*
-             * Record the target so we can nuke it
-             */
-            (void)Lst_AtEnd(targs, (ClientData)targ);
-
-            /*
-             * Search from this suffix's successor...
-             */
-            ln = Lst_Succ(ln);
-        }
+            /*
+             * Allocate room for the prefix, whose end is found by subtracting
+             * the length of the suffix from the end of the name.
+             */
+            prefLen = (eoname - targ->suff->nameLen) - sopref;
+            targ->pref = emalloc(prefLen + 1);
+            memcpy(targ->pref, sopref, prefLen);
+            targ->pref[prefLen] = '\0';
+
+            /*
+             * Add nodes from which the target can be made
+             */
+            SuffAddLevel(srcs, targ);
+
+            /*
+             * Record the target so we can nuke it
+             */
+            (void)Lst_AtEnd(targs, (ClientData)targ);
+
+            /*
+             * Search from this suffix's successor...
+             */
+            ln = Lst_Succ(ln);
+        }
     }
 
@@ -1914 +1916 @@
      */
     if (Lst_IsEmpty(targs) && suffNull != NULL) {
-        if (DEBUG(SUFF)) {
-            printf("\tNo known suffix on %s. Using .NULL suffix\n", gn->name);
-        }
-
-        targ = (Src *)emalloc(sizeof (Src));
-        targ->file = estrdup(gn->name);
-        targ->suff = suffNull;
-        targ->suff->refCount++;
-        targ->node = gn;
-        targ->parent = (Src *)NULL;
-        targ->children = 0;
-        targ->pref = estrdup(sopref);
+        if (DEBUG(SUFF)) {
+            printf("\tNo known suffix on %s. Using .NULL suffix\n", gn->name);
+        }
+
+        targ = (Src *)emalloc(sizeof (Src));
+        targ->file = estrdup(gn->name);
+        targ->suff = suffNull;
+        targ->suff->refCount++;
+        targ->node = gn;
+        targ->parent = (Src *)NULL;
+        targ->children = 0;
+        targ->pref = estrdup(sopref);
 #ifdef DEBUG_SRC
-        targ->cp = Lst_Init(FALSE);
+        targ->cp = Lst_Init(FALSE);
 #endif
 
-        /*
-         * Only use the default suffix rules if we don't have commands
-         * or dependencies defined for this gnode
-         */
-        if (Lst_IsEmpty(gn->commands) && Lst_IsEmpty(gn->children))
-            SuffAddLevel(srcs, targ);
-        else {
-            if (DEBUG(SUFF))
-                printf("not ");
-        }
-
-        if (DEBUG(SUFF))
-            printf("adding suffix rules\n");
-
-        (void)Lst_AtEnd(targs, (ClientData)targ);
+        /*
+         * Only use the default suffix rules if we don't have commands
+         * or dependencies defined for this gnode
+         */
+        if (Lst_IsEmpty(gn->commands) && Lst_IsEmpty(gn->children))
+            SuffAddLevel(srcs, targ);
+        else {
+            if (DEBUG(SUFF))
+                printf("not ");
+        }
+
+        if (DEBUG(SUFF))
+            printf("adding suffix rules\n");
+
+        (void)Lst_AtEnd(targs, (ClientData)targ);
     }
 
@@ -1954 +1956 @@
 
     if (bottom == (Src *)NULL) {
-        /*
-         * No known transformations -- use the first suffix found for setting
-         * the local variables.
-         */
-        if (!Lst_IsEmpty(targs)) {
-            targ = (Src *)Lst_Datum(Lst_First(targs));
-        } else {
-            targ = (Src *)NULL;
-        }
+        /*
+         * No known transformations -- use the first suffix found for setting
+         * the local variables.
+         */
+        if (!Lst_IsEmpty(targs)) {
+            targ = (Src *)Lst_Datum(Lst_First(targs));
+        } else {
+            targ = (Src *)NULL;
+        }
     } else {
-        /*
-         * Work up the transformation path to find the suffix of the
-         * target to which the transformation was made.
-         */
-        for (targ = bottom; targ->parent != NULL; targ = targ->parent)
-            continue;
+        /*
+         * Work up the transformation path to find the suffix of the
+         * target to which the transformation was made.
+         */
+        for (targ = bottom; targ->parent != NULL; targ = targ->parent)
+            continue;
     }
 
@@ -1990 +1992 @@
 
     if (targ == NULL) {
-        if (DEBUG(SUFF)) {
-            printf("\tNo valid suffix on %s\n", gn->name);
-        }
+        if (DEBUG(SUFF)) {
+            printf("\tNo valid suffix on %s\n", gn->name);
+        }
 
 sfnd_abort:
-        /*
-         * Deal with finding the thing on the default search path if the
-         * node is only a source (not on the lhs of a dependency operator
-         * or [XXX] it has neither children or commands).
-         */
-        if (OP_NOP(gn->type) ||
-            (Lst_IsEmpty(gn->children) && Lst_IsEmpty(gn->commands)))
-        {
-            gn->path = Dir_FindFile(gn->name,
-                                    (targ == NULL ? dirSearchPath :
-                                     targ->suff->searchPath));
-            if (gn->path != NULL) {
-                char *ptr;
-                Var_Set(TARGET, gn->path, gn);
-
-                if (targ != NULL) {
-                    /*
-                     * Suffix known for the thing -- trim the suffix off
-                     * the path to form the proper .PREFIX variable.
-                     */
-                    int         savep = strlen(gn->path) - targ->suff->nameLen;
-                    char        savec;
-
-                    if (gn->suffix)
-                        gn->suffix->refCount--;
-                    gn->suffix = targ->suff;
-                    gn->suffix->refCount++;
-
-                    savec = gn->path[savep];
-                    gn->path[savep] = '\0';
-
-                    if ((ptr = strrchr(gn->path, '/')) != NULL)
-                        ptr++;
-                    else
-                        ptr = gn->path;
-
-                    Var_Set(PREFIX, ptr, gn);
-
-                    gn->path[savep] = savec;
-                } else {
-                    /*
-                     * The .PREFIX gets the full path if the target has
-                     * no known suffix.
-                     */
-                    if (gn->suffix)
-                        gn->suffix->refCount--;
-                    gn->suffix = NULL;
-
-                    if ((ptr = strrchr(gn->path, '/')) != NULL)
-                        ptr++;
-                    else
-                        ptr = gn->path;
-
-                    Var_Set(PREFIX, ptr, gn);
-                }
-            }
-        } else {
-            /*
-             * Not appropriate to search for the thing -- set the
-             * path to be the name so Dir_MTime won't go grovelling for
-             * it.
-             */
-            if (gn->suffix)
-                gn->suffix->refCount--;
-            gn->suffix = (targ == NULL) ? NULL : targ->suff;
-            if (gn->suffix)
-                gn->suffix->refCount++;
-            efree(gn->path);
-            gn->path = estrdup(gn->name);
-        }
-
-        goto sfnd_return;
+        /*
+         * Deal with finding the thing on the default search path if the
+         * node is only a source (not on the lhs of a dependency operator
+         * or [XXX] it has neither children or commands).
+         */
+        if (OP_NOP(gn->type) ||
+            (Lst_IsEmpty(gn->children) && Lst_IsEmpty(gn->commands)))
+        {
+            gn->path = Dir_FindFile(gn->name,
+                                    (targ == NULL ? dirSearchPath :
+                                     targ->suff->searchPath));
+            if (gn->path != NULL) {
+                char *ptr;
+                Var_Set(TARGET, gn->path, gn);
+
+                if (targ != NULL) {
+                    /*
+                     * Suffix known for the thing -- trim the suffix off
+                     * the path to form the proper .PREFIX variable.
+                     */
+                    int         savep = strlen(gn->path) - targ->suff->nameLen;
+                    char        savec;
+
+                    if (gn->suffix)
+                        gn->suffix->refCount--;
+                    gn->suffix = targ->suff;
+                    gn->suffix->refCount++;
+
+                    savec = gn->path[savep];
+                    gn->path[savep] = '\0';
+
+                    if ((ptr = strrchr(gn->path, '/')) != NULL)
+                        ptr++;
+                    else
+                        ptr = gn->path;
+
+                    Var_Set(PREFIX, ptr, gn);
+
+                    gn->path[savep] = savec;
+                } else {
+                    /*
+                     * The .PREFIX gets the full path if the target has
+                     * no known suffix.
+                     */
+                    if (gn->suffix)
+                        gn->suffix->refCount--;
+                    gn->suffix = NULL;
+
+                    if ((ptr = strrchr(gn->path, '/')) != NULL)
+                        ptr++;
+                    else
+                        ptr = gn->path;
+
+                    Var_Set(PREFIX, ptr, gn);
+                }
+            }
+        } else {
+            /*
+             * Not appropriate to search for the thing -- set the
+             * path to be the name so Dir_MTime won't go grovelling for
+             * it.
+             */
+            if (gn->suffix)
+                gn->suffix->refCount--;
+            gn->suffix = (targ == NULL) ? NULL : targ->suff;
+            if (gn->suffix)
+                gn->suffix->refCount++;
+            efree(gn->path);
+            gn->path = estrdup(gn->name);
+        }
+
+        goto sfnd_return;
     }
 
@@ -2075 +2077 @@
      */
     if (targ->suff->flags & SUFF_LIBRARY) {
-        gn->type |= OP_LIB;
+        gn->type |= OP_LIB;
     }
 #endif
@@ -2083 +2085 @@
      */
     if (!Lst_IsEmpty(gn->children)) {
-        src = SuffFindCmds(targ, slst);
-
-        if (src != (Src *)NULL) {
-            /*
-             * Free up all the Src structures in the transformation path
-             * up to, but not including, the parent node.
-             */
-            while (bottom && bottom->parent != NULL) {
-                if (Lst_Member(slst, (ClientData) bottom) == NILLNODE) {
-                    Lst_AtEnd(slst, (ClientData) bottom);
-                }
-                bottom = bottom->parent;
-            }
-            bottom = src;
-        }
+        src = SuffFindCmds(targ, slst);
+
+        if (src != (Src *)NULL) {
+            /*
+             * Free up all the Src structures in the transformation path
+             * up to, but not including, the parent node.
+             */
+            while (bottom && bottom->parent != NULL) {
+                if (Lst_Member(slst, (ClientData) bottom) == NILLNODE) {
+                    Lst_AtEnd(slst, (ClientData) bottom);
+                }
+                bottom = bottom->parent;
+            }
+            bottom = src;
+        }
     }
 
     if (bottom == NULL) {
-        /*
-         * No idea from where it can come -- return now.
-         */
-        goto sfnd_abort;
+        /*
+         * No idea from where it can come -- return now.
+         */
+        goto sfnd_abort;
     }
 
@@ -2120 +2122 @@
      */
     if (bottom->node == NILGNODE) {
-        bottom->node = Targ_FindNode(bottom->file, TARG_CREATE);
+        bottom->node = Targ_FindNode(bottom->file, TARG_CREATE);
     }
 
     for (src = bottom; src->parent != (Src *)NULL; src = src->parent) {
-        targ = src->parent;
-
-        if (src->node->suffix)
-            src->node->suffix->refCount--;
-        src->node->suffix = src->suff;
-        src->node->suffix->refCount++;
-
-        if (targ->node == NILGNODE) {
-            targ->node = Targ_FindNode(targ->file, TARG_CREATE);
-        }
-
-        SuffApplyTransform(targ->node, src->node,
-                           targ->suff, src->suff);
-
-        if (targ->node != gn) {
-            /*
-             * Finish off the dependency-search process for any nodes
-             * between bottom and gn (no point in questing around the
-             * filesystem for their implicit source when it's already
-             * known). Note that the node can't have any sources that
-             * need expanding, since SuffFindThem will stop on an existing
-             * node, so all we need to do is set the standard and System V
-             * variables.
-             */
-            targ->node->type |= OP_DEPS_FOUND;
-
-            Var_Set(PREFIX, targ->pref, targ->node);
-
-            Var_Set(TARGET, targ->node->name, targ->node);
-        }
+        targ = src->parent;
+
+        if (src->node->suffix)
+            src->node->suffix->refCount--;
+        src->node->suffix = src->suff;
+        src->node->suffix->refCount++;
+
+        if (targ->node == NILGNODE) {
+            targ->node = Targ_FindNode(targ->file, TARG_CREATE);
+        }
+
+        SuffApplyTransform(targ->node, src->node,
+                           targ->suff, src->suff);
+
+        if (targ->node != gn) {
+            /*
+             * Finish off the dependency-search process for any nodes
+             * between bottom and gn (no point in questing around the
+             * filesystem for their implicit source when it's already
+             * known). Note that the node can't have any sources that
+             * need expanding, since SuffFindThem will stop on an existing
+             * node, so all we need to do is set the standard and System V
+             * variables.
+             */
+            targ->node->type |= OP_DEPS_FOUND;
+
+            Var_Set(PREFIX, targ->pref, targ->node);
+
+            Var_Set(TARGET, targ->node->name, targ->node);
+        }
     }
 
     if (gn->suffix)
-        gn->suffix->refCount--;
+        gn->suffix->refCount--;
     gn->suffix = src->suff;
     gn->suffix->refCount++;
@@ -2173 +2175 @@
 sfnd_return:
     if (bottom)
-        if (Lst_Member(slst, (ClientData) bottom) == NILLNODE)
-            Lst_AtEnd(slst, (ClientData) bottom);
+        if (Lst_Member(slst, (ClientData) bottom) == NILLNODE)
+            Lst_AtEnd(slst, (ClientData) bottom);
 
     while (SuffRemoveSrc(srcs) || SuffRemoveSrc(targs))
-        continue;
+        continue;
 
     Lst_Concat(slst, srcs, LST_CONCLINK);
@@ -2187 +2189 @@
  *-----------------------------------------------------------------------
  * Suff_FindDeps  --
- *      Find implicit sources for the target described by the graph node
- *      gn
- *
- * Results:
- *      Nothing.
- *
- * Side Effects:
- *      Nodes are added to the graph below the passed-in node. The nodes
- *      are marked to have their IMPSRC variable filled in. The
- *      PREFIX variable is set for the given node and all its
- *      implied children.
+ *      Find implicit sources for the target described by the graph node
+ *      gn
+ *
+ * Results:
+ *      Nothing.
+ *
+ * Side Effects:
+ *      Nodes are added to the graph below the passed-in node. The nodes
+ *      are marked to have their IMPSRC variable filled in. The
+ *      PREFIX variable is set for the given node and all its
+ *      implied children.
  *
  * Notes:
- *      The path found by this target is the shortest path in the
- *      transformation graph, which may pass through non-existent targets,
- *      to an existing target. The search continues on all paths from the
- *      root suffix until a file is found. I.e. if there's a path
- *      .o -> .c -> .l -> .l,v from the root and the .l,v file exists but
- *      the .c and .l files don't, the search will branch out in
- *      all directions from .o and again from all the nodes on the
- *      next level until the .l,v node is encountered.
+ *      The path found by this target is the shortest path in the
+ *      transformation graph, which may pass through non-existent targets,
+ *      to an existing target. The search continues on all paths from the
+ *      root suffix until a file is found. I.e. if there's a path
+ *      .o -> .c -> .l -> .l,v from the root and the .l,v file exists but
+ *      the .c and .l files don't, the search will branch out in
+ *      all directions from .o and again from all the nodes on the
+ *      next level until the .l,v node is encountered.
  *
  *-----------------------------------------------------------------------
@@ -2219 +2221 @@
     SuffFindDeps(gn, srclist);
     while (SuffRemoveSrc(srclist))
-        continue;
+        continue;
 }
 
@@ -2225 +2227 @@
 static void
 SuffFindDeps (gn, slst)
-    GNode         *gn;          /* node we're dealing with */
-    Lst           slst;
+    GNode         *gn;          /* node we're dealing with */
+    Lst           slst;
 {
     if (gn->type & OP_DEPS_FOUND) {
-        /*
-         * If dependencies already found, no need to do it again...
-         */
-        return;
+        /*
+         * If dependencies already found, no need to do it again...
+         */
+        return;
     } else {
-        gn->type |= OP_DEPS_FOUND;
+        gn->type |= OP_DEPS_FOUND;
     }
 
     if (DEBUG(SUFF)) {
-        printf ("SuffFindDeps (%s)\n", gn->name);
+        printf ("SuffFindDeps (%s)\n", gn->name);
     }
 
 #ifdef USE_ARCHIVES
     if (gn->type & OP_ARCHV) {
-        SuffFindArchiveDeps(gn, slst);
+        SuffFindArchiveDeps(gn, slst);
     } else if (gn->type & OP_LIB) {
-        /*
-         * If the node is a library, it is the arch module's job to find it
-         * and set the TARGET variable accordingly. We merely provide the
-         * search path, assuming all libraries end in ".a" (if the suffix
-         * hasn't been defined, there's nothing we can do for it, so we just
-         * set the TARGET variable to the node's name in order to give it a
-         * value).
-         */
-        LstNode ln;
-        Suff    *s;
-
-        ln = Lst_Find (sufflist, (ClientData)LIBSUFF, SuffSuffHasNameP);
-        if (gn->suffix)
-            gn->suffix->refCount--;
-        if (ln != NILLNODE) {
-            gn->suffix = s = (Suff *) Lst_Datum (ln);
-            gn->suffix->refCount++;
-            Arch_FindLib (gn, s->searchPath);
-        } else {
-            gn->suffix = NULL;
-            Var_Set (TARGET, gn->name, gn);
-        }
-        /*
-         * Because a library (-lfoo) target doesn't follow the standard
-         * filesystem conventions, we don't set the regular variables for
-         * the thing. .PREFIX is simply made empty...
-         */
-        Var_Set(PREFIX, "", gn);
+        /*
+         * If the node is a library, it is the arch module's job to find it
+         * and set the TARGET variable accordingly. We merely provide the
+         * search path, assuming all libraries end in ".a" (if the suffix
+         * hasn't been defined, there's nothing we can do for it, so we just
+         * set the TARGET variable to the node's name in order to give it a
+         * value).
+         */
+        LstNode ln;
+        Suff    *s;
+
+        ln = Lst_Find (sufflist, (ClientData)LIBSUFF, SuffSuffHasNameP);
+        if (gn->suffix)
+            gn->suffix->refCount--;
+        if (ln != NILLNODE) {
+            gn->suffix = s = (Suff *) Lst_Datum (ln);
+            gn->suffix->refCount++;
+            Arch_FindLib (gn, s->searchPath);
+        } else {
+            gn->suffix = NULL;
+            Var_Set (TARGET, gn->name, gn);
+        }
+        /*
+         * Because a library (-lfoo) target doesn't follow the standard
+         * filesystem conventions, we don't set the regular variables for
+         * the thing. .PREFIX is simply made empty...
+         */
+        Var_Set(PREFIX, "", gn);
     } else
 #endif /* USE_ARCHIVES */
-        SuffFindNormalDeps(gn, slst);
+        SuffFindNormalDeps(gn, slst);
 }
 
@@ -2281 +2283 @@
  *-----------------------------------------------------------------------
  * Suff_SetNull --
- *      Define which suffix is the null suffix.
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      'suffNull' is altered.
+ *      Define which suffix is the null suffix.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      'suffNull' is altered.
  *
  * Notes:
- *      Need to handle the changing of the null suffix gracefully so the
- *      old transformation rules don't just go away.
+ *      Need to handle the changing of the null suffix gracefully so the
+ *      old transformation rules don't just go away.
  *
  *-----------------------------------------------------------------------
@@ -2297 +2299 @@
 void
 Suff_SetNull(name)
-    char    *name;          /* Name of null suffix */
+    char    *name;          /* Name of null suffix */
 {
     Suff    *s;
@@ -2304 +2306 @@
     ln = Lst_Find(sufflist, (ClientData)name, SuffSuffHasNameP);
     if (ln != NILLNODE) {
-        s = (Suff *)Lst_Datum(ln);
-        if (suffNull != (Suff *)NULL) {
-            suffNull->flags &= ~SUFF_NULL;
-        }
-        s->flags |= SUFF_NULL;
-        /*
-         * XXX: Here's where the transformation mangling would take place
-         */
-        suffNull = s;
+        s = (Suff *)Lst_Datum(ln);
+        if (suffNull != (Suff *)NULL) {
+            suffNull->flags &= ~SUFF_NULL;
+        }
+        s->flags |= SUFF_NULL;
+        /*
+         * XXX: Here's where the transformation mangling would take place
+         */
+        suffNull = s;
     } else {
-        Parse_Error (PARSE_WARNING, "Desired null suffix %s not defined.",
-                     name);
+        Parse_Error (PARSE_WARNING, "Desired null suffix %s not defined.",
+                     name);
     }
 }
@@ -2322 +2324 @@
  *-----------------------------------------------------------------------
  * Suff_Init --
- *      Initialize suffixes module
- *
- * Results:
- *      None
- *
- * Side Effects:
- *      Many
+ *      Initialize suffixes module
+ *
+ * Results:
+ *      None
+ *
+ * Side Effects:
+ *      Many
  *-----------------------------------------------------------------------
  */
@@ -2347 +2349 @@
     emptySuff = suffNull = (Suff *) emalloc (sizeof (Suff));
 
-    suffNull->name =        estrdup ("");
+    suffNull->name =        estrdup ("");
     suffNull->nameLen =     0;
     suffNull->searchPath =  Lst_Init (FALSE);
     Dir_Concat(suffNull->searchPath, dirSearchPath);
     suffNull->children =    Lst_Init (FALSE);
-    suffNull->parents =     Lst_Init (FALSE);
-    suffNull->ref =         Lst_Init (FALSE);
-    suffNull->sNum =        sNum++;
-    suffNull->flags =       SUFF_NULL;
+    suffNull->parents =     Lst_Init (FALSE);
+    suffNull->ref =         Lst_Init (FALSE);
+    suffNull->sNum =        sNum++;
+    suffNull->flags =       SUFF_NULL;
     suffNull->refCount =    1;
 
@@ -2364 +2366 @@
  *----------------------------------------------------------------------
  * Suff_End --
- *      Cleanup the this module
- *
- * Results:
- *      None
- *
- * Side Effects:
- *      The memory is efree'd.
+ *      Cleanup the this module
+ *
+ * Results:
+ *      None
+ *
+ * Side Effects:
+ *      The memory is efree'd.
  *----------------------------------------------------------------------
  */
@@ -2380 +2382 @@
     Lst_Destroy(suffClean, SuffFree);
     if (suffNull)
-        SuffFree(suffNull);
+        SuffFree(suffNull);
     Lst_Destroy(srclist, NOFREE);
     Lst_Destroy(transforms, NOFREE);
@@ -2402 +2404 @@
 {
     Suff    *s = (Suff *) sp;
-    int     flags;
-    int     flag;
+    int     flags;
+    int     flag;
 
     printf ("# `%s' [%d] ", s->name, s->refCount);
@@ -2409 +2411 @@
     flags = s->flags;
     if (flags) {
-        fputs (" (", stdout);
-        while (flags) {
-            flag = 1 << (ffs(flags) - 1);
-            flags &= ~flag;
-            switch (flag) {
-                case SUFF_NULL:
-                    printf ("NULL");
-                    break;
-                case SUFF_INCLUDE:
-                    printf ("INCLUDE");
-                    break;
+        fputs (" (", stdout);
+        while (flags) {
+            flag = 1 << (ffs(flags) - 1);
+            flags &= ~flag;
+            switch (flag) {
+                case SUFF_NULL:
+                    printf ("NULL");
+                    break;
+                case SUFF_INCLUDE:
+                    printf ("INCLUDE");
+                    break;
 #ifdef USE_ARCHIVES
-                case SUFF_LIBRARY:
-                    printf ("LIBRARY");
-                    break;
+                case SUFF_LIBRARY:
+                    printf ("LIBRARY");
+                    break;
 #endif
-            }
-            fputc(flags ? '|' : ')', stdout);
-        }
+            }
+            fputc(flags ? '|' : ')', stdout);
+        }
     }
     fputc ('\n', stdout);

trunk/src/kmk/targ.c

@@ -1 +1 @@
 /*
  * 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.
@@ -18 +18 @@
  * 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
@@ -39 +39 @@
 #ifndef lint
 #if 0
-static char sccsid[] = "@(#)targ.c      8.2 (Berkeley) 3/19/94";
+static char sccsid[] = "@(#)targ.c      8.2 (Berkeley) 3/19/94";
 #else
 static const char rcsid[] =
   "$FreeBSD: src/usr.bin/make/targ.c,v 1.10 1999/09/11 13:08:02 hoek Exp $";
 #endif
+#define KLIBFILEDEF rcsid
 #endif /* not lint */
 
 /*-
  * targ.c --
- *      Functions for maintaining the Lst allTargets. Target nodes are
+ *      Functions for maintaining the Lst allTargets. Target nodes are
  * kept in two structures: a Lst, maintained by the list library, and a
  * hash table, maintained by the hash library.
  *
  * Interface:
- *      Targ_Init               Initialization procedure.
- *
- *      Targ_End                Cleanup the module
- *
- *      Targ_NewGN              Create a new GNode for the passed target
- *                              (string). The node is *not* placed in the
- *                              hash table, though all its fields are
- *                              initialized.
- *
- *      Targ_FindNode           Find the node for a given target, creating
- *                              and storing it if it doesn't exist and the
- *                              flags are right (TARG_CREATE)
- *
- *      Targ_FindList           Given a list of names, find nodes for all
- *                              of them. If a name doesn't exist and the
- *                              TARG_NOCREATE flag was given, an error message
- *                              is printed. Else, if a name doesn't exist,
- *                              its node is created.
- *
- *      Targ_Ignore             Return TRUE if errors should be ignored when
- *                              creating the given target.
- *
- *      Targ_Silent             Return TRUE if we should be silent when
- *                              creating the given target.
- *
- *      Targ_Precious           Return TRUE if the target is precious and
- *                              should not be removed if we are interrupted.
+ *      Targ_Init               Initialization procedure.
+ *
+ *      Targ_End                Cleanup the module
+ *
+ *      Targ_NewGN              Create a new GNode for the passed target
+ *                              (string). The node is *not* placed in the
+ *                              hash table, though all its fields are
+ *                              initialized.
+ *
+ *      Targ_FindNode           Find the node for a given target, creating
+ *                              and storing it if it doesn't exist and the
+ *                              flags are right (TARG_CREATE)
+ *
+ *      Targ_FindList           Given a list of names, find nodes for all
+ *                              of them. If a name doesn't exist and the
+ *                              TARG_NOCREATE flag was given, an error message
+ *                              is printed. Else, if a name doesn't exist,
+ *                              its node is created.
+ *
+ *      Targ_Ignore             Return TRUE if errors should be ignored when
+ *                              creating the given target.
+ *
+ *      Targ_Silent             Return TRUE if we should be silent when
+ *                              creating the given target.
+ *
+ *      Targ_Precious           Return TRUE if the target is precious and
+ *                              should not be removed if we are interrupted.
  *
  * Debugging:
- *      Targ_PrintGraph         Print out the entire graphm all variables
- *                              and statistics for the directory cache. Should
- *                              print something for suffixes, too, but...
- */
-
-#include          <stdio.h>
-#include          <time.h>
-#include          "make.h"
-#include          "hash.h"
-#include          "dir.h"
-
-static Lst        allTargets;   /* the list of all targets found so far */
-static Lst        allGNs;       /* List of all the GNodes */
-static Hash_Table targets;      /* a hash table of same */
-
-#define HTSIZE  191             /* initial size of hash table */
+ *      Targ_PrintGraph         Print out the entire graphm all variables
+ *                              and statistics for the directory cache. Should
+ *                              print something for suffixes, too, but...
+ */
+
+#include          <stdio.h>
+#include          <time.h>
+#include          <strings.h>
+#include          "make.h"
+#include          "hash.h"
+#include          "dir.h"
+
+static Lst        allTargets;   /* the list of all targets found so far */
+static Lst        allGNs;       /* List of all the GNodes */
+static Hash_Table targets;      /* a hash table of same */
+
+#define HTSIZE  191             /* initial size of hash table */
 
 static int TargPrintOnlySrc __P((ClientData, ClientData));
@@ -107 +109 @@
  *-----------------------------------------------------------------------
  * Targ_Init --
- *      Initialize this module
- *
- * Results:
- *      None
- *
- * Side Effects:
- *      The allTargets list and the targets hash table are initialized
+ *      Initialize this module
+ *
+ * Results:
+ *      None
+ *
+ * Side Effects:
+ *      The allTargets list and the targets hash table are initialized
  *-----------------------------------------------------------------------
  */
@@ -126 +128 @@
  *-----------------------------------------------------------------------
  * Targ_End --
- *      Finalize this module
- *
- * Results:
- *      None
- *
- * Side Effects:
- *      All lists and gnodes are cleared
+ *      Finalize this module
+ *
+ * Results:
+ *      None
+ *
+ * Side Effects:
+ *      All lists and gnodes are cleared
  *-----------------------------------------------------------------------
  */
@@ -140 +142 @@
     Lst_Destroy(allTargets, NOFREE);
     if (allGNs)
-        Lst_Destroy(allGNs, TargFreeGN);
+        Lst_Destroy(allGNs, TargFreeGN);
     Hash_DeleteTable(&targets);
 }
@@ -147 +149 @@
  *-----------------------------------------------------------------------
  * Targ_NewGN  --
- *      Create and initialize a new graph node
- *
- * Results:
- *      An initialized graph node with the name field filled with a copy
- *      of the passed name
- *
- * Side Effects:
- *      The gnode is added to the list of all gnodes.
+ *      Create and initialize a new graph node
+ *
+ * Results:
+ *      An initialized graph node with the name field filled with a copy
+ *      of the passed name
+ *
+ * Side Effects:
+ *      The gnode is added to the list of all gnodes.
  *-----------------------------------------------------------------------
  */
 GNode *
 Targ_NewGN (name)
-    char           *name;       /* the name to stick in the new node */
+    char           *name;       /* the name to stick in the new node */
 {
     register GNode *gn;
@@ -168 +170 @@
 #ifdef USE_ARCHIVES
     if (name[0] == '-' && name[1] == 'l') {
-        gn->type = OP_LIB;
+        gn->type = OP_LIB;
     } else {
-        gn->type = 0;
+        gn->type = 0;
     }
 #else
     gn->type = 0;
 #endif
-    gn->unmade =        0;
-    gn->make =          FALSE;
-    gn->made =          UNMADE;
-    gn->childMade =     FALSE;
-    gn->order =         0;
+    gn->unmade =        0;
+    gn->make =          FALSE;
+    gn->made =          UNMADE;
+    gn->childMade =     FALSE;
+    gn->order =         0;
     gn->mtime = gn->cmtime = 0;
-    gn->iParents =      Lst_Init (FALSE);
-    gn->cohorts =       Lst_Init (FALSE);
-    gn->parents =       Lst_Init (FALSE);
-    gn->children =      Lst_Init (FALSE);
-    gn->successors =    Lst_Init (FALSE);
-    gn->preds =         Lst_Init (FALSE);
-    gn->context =       Lst_Init (FALSE);
-    gn->commands =      Lst_Init (FALSE);
-    gn->suffix =        NULL;
+    gn->iParents =      Lst_Init (FALSE);
+    gn->cohorts =       Lst_Init (FALSE);
+    gn->parents =       Lst_Init (FALSE);
+    gn->children =      Lst_Init (FALSE);
+    gn->successors =    Lst_Init (FALSE);
+    gn->preds =         Lst_Init (FALSE);
+    gn->context =       Lst_Init (FALSE);
+    gn->commands =      Lst_Init (FALSE);
+    gn->suffix =        NULL;
 
     if (allGNs == NULL)
-        allGNs = Lst_Init(FALSE);
+        allGNs = Lst_Init(FALSE);
     Lst_AtEnd(allGNs, (ClientData) gn);
 
@@ -201 +203 @@
  *-----------------------------------------------------------------------
  * TargFreeGN  --
- *      Destroy a GNode
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      None.
+ *      Destroy a GNode
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      None.
  *-----------------------------------------------------------------------
  */
@@ -235 +237 @@
  *-----------------------------------------------------------------------
  * Targ_FindNode  --
- *      Find a node in the list using the given name for matching
- *
- * Results:
- *      The node in the list if it was. If it wasn't, return NILGNODE of
- *      flags was TARG_NOCREATE or the newly created and initialized node
- *      if it was TARG_CREATE
- *
- * Side Effects:
- *      Sometimes a node is created and added to the list
+ *      Find a node in the list using the given name for matching
+ *
+ * Results:
+ *      The node in the list if it was. If it wasn't, return NILGNODE of
+ *      flags was TARG_NOCREATE or the newly created and initialized node
+ *      if it was TARG_CREATE
+ *
+ * Side Effects:
+ *      Sometimes a node is created and added to the list
  *-----------------------------------------------------------------------
  */
 GNode *
 Targ_FindNode (name, flags)
-    char           *name;       /* the name to find */
-    int             flags;      /* flags governing events when target not
-                                 * found */
-{
-    GNode         *gn;        /* node in that element */
-    Hash_Entry    *he;        /* New or used hash entry for node */
-    Boolean       isNew;      /* Set TRUE if Hash_CreateEntry had to create */
-                              /* an entry for the node */
+    char           *name;       /* the name to find */
+    int             flags;      /* flags governing events when target not
+                                 * found */
+{
+    GNode         *gn;        /* node in that element */
+    Hash_Entry    *he;        /* New or used hash entry for node */
+    Boolean       isNew;      /* Set TRUE if Hash_CreateEntry had to create */
+                              /* an entry for the node */
 
 
     if (flags & TARG_CREATE) {
-        he = Hash_CreateEntry (&targets, name, &isNew);
-        if (isNew) {
-            gn = Targ_NewGN (name);
-            Hash_SetValue (he, gn);
-            (void) Lst_AtEnd (allTargets, (ClientData)gn);
-        }
+        he = Hash_CreateEntry (&targets, name, &isNew);
+        if (isNew) {
+            gn = Targ_NewGN (name);
+            Hash_SetValue (he, gn);
+            (void) Lst_AtEnd (allTargets, (ClientData)gn);
+        }
     } else {
-        he = Hash_FindEntry (&targets, name);
+        he = Hash_FindEntry (&targets, name);
     }
 
     if (he == (Hash_Entry *) NULL) {
-        return (NILGNODE);
+        return (NILGNODE);
     } else {
-        return ((GNode *) Hash_GetValue (he));
+        return ((GNode *) Hash_GetValue (he));
     }
 }
@@ -279 +281 @@
  *-----------------------------------------------------------------------
  * Targ_FindList --
- *      Make a complete list of GNodes from the given list of names
- *
- * Results:
- *      A complete list of graph nodes corresponding to all instances of all
- *      the names in names.
- *
- * Side Effects:
- *      If flags is TARG_CREATE, nodes will be created for all names in
- *      names which do not yet have graph nodes. If flags is TARG_NOCREATE,
- *      an error message will be printed for each name which can't be found.
+ *      Make a complete list of GNodes from the given list of names
+ *
+ * Results:
+ *      A complete list of graph nodes corresponding to all instances of all
+ *      the names in names.
+ *
+ * Side Effects:
+ *      If flags is TARG_CREATE, nodes will be created for all names in
+ *      names which do not yet have graph nodes. If flags is TARG_NOCREATE,
+ *      an error message will be printed for each name which can't be found.
  * -----------------------------------------------------------------------
  */
 Lst
 Targ_FindList (names, flags)
-    Lst            names;       /* list of names to find */
-    int            flags;       /* flags used if no node is found for a given
-                                 * name */
-{
-    Lst            nodes;       /* result list */
-    register LstNode  ln;               /* name list element */
-    register GNode *gn;         /* node in tLn */
-    char          *name;
+    Lst            names;       /* list of names to find */
+    int            flags;       /* flags used if no node is found for a given
+                                 * name */
+{
+    Lst            nodes;       /* result list */
+    register LstNode  ln;               /* name list element */
+    register GNode *gn;         /* node in tLn */
+    char          *name;
 
     nodes = Lst_Init (FALSE);
 
     if (Lst_Open (names) == FAILURE) {
-        return (nodes);
+        return (nodes);
     }
     while ((ln = Lst_Next (names)) != NILLNODE) {
-        name = (char *)Lst_Datum(ln);
-        gn = Targ_FindNode (name, flags);
-        if (gn != NILGNODE) {
-            /*
-             * Note: Lst_AtEnd must come before the Lst_Concat so the nodes
-             * are added to the list in the order in which they were
-             * encountered in the makefile.
-             */
-            (void) Lst_AtEnd (nodes, (ClientData)gn);
-            if (gn->type & OP_DOUBLEDEP) {
-                (void)Lst_Concat (nodes, gn->cohorts, LST_CONCNEW);
-            }
-        } else if (flags == TARG_NOCREATE) {
-            Error ("\"%s\" -- target unknown.", name);
-        }
+        name = (char *)Lst_Datum(ln);
+        gn = Targ_FindNode (name, flags);
+        if (gn != NILGNODE) {
+            /*
+             * Note: Lst_AtEnd must come before the Lst_Concat so the nodes
+             * are added to the list in the order in which they were
+             * encountered in the makefile.
+             */
+            (void) Lst_AtEnd (nodes, (ClientData)gn);
+            if (gn->type & OP_DOUBLEDEP) {
+                (void)Lst_Concat (nodes, gn->cohorts, LST_CONCNEW);
+            }
+        } else if (flags == TARG_NOCREATE) {
+            Error ("\"%s\" -- target unknown.", name);
+        }
     }
     Lst_Close (names);
@@ -331 +333 @@
  *-----------------------------------------------------------------------
  * Targ_Ignore  --
- *      Return true if should ignore errors when creating gn
- *
- * Results:
- *      TRUE if should ignore errors
- *
- * Side Effects:
- *      None
+ *      Return true if should ignore errors when creating gn
+ *
+ * Results:
+ *      TRUE if should ignore errors
+ *
+ * Side Effects:
+ *      None
  *-----------------------------------------------------------------------
  */
 Boolean
 Targ_Ignore (gn)
-    GNode          *gn;         /* node to check for */
+    GNode          *gn;         /* node to check for */
 {
     if (ignoreErrors || gn->type & OP_IGNORE) {
-        return (TRUE);
+        return (TRUE);
     } else {
-        return (FALSE);
+        return (FALSE);
     }
 }
@@ -354 +356 @@
  *-----------------------------------------------------------------------
  * Targ_Silent  --
- *      Return true if be silent when creating gn
- *
- * Results:
- *      TRUE if should be silent
- *
- * Side Effects:
- *      None
+ *      Return true if be silent when creating gn
+ *
+ * Results:
+ *      TRUE if should be silent
+ *
+ * Side Effects:
+ *      None
  *-----------------------------------------------------------------------
  */
 Boolean
 Targ_Silent (gn)
-    GNode          *gn;         /* node to check for */
+    GNode          *gn;         /* node to check for */
 {
     if (beSilent || gn->type & OP_SILENT) {
-        return (TRUE);
+        return (TRUE);
     } else {
-        return (FALSE);
+        return (FALSE);
     }
 }
@@ -377 +379 @@
  *-----------------------------------------------------------------------
  * Targ_Precious --
- *      See if the given target is precious
- *
- * Results:
- *      TRUE if it is precious. FALSE otherwise
- *
- * Side Effects:
- *      None
+ *      See if the given target is precious
+ *
+ * Results:
+ *      TRUE if it is precious. FALSE otherwise
+ *
+ * Side Effects:
+ *      None
  *-----------------------------------------------------------------------
  */
 Boolean
 Targ_Precious (gn)
-    GNode          *gn;         /* the node to check */
+    GNode          *gn;         /* the node to check */
 {
     if (allPrecious || (gn->type & (OP_PRECIOUS|OP_DOUBLEDEP))) {
-        return (TRUE);
+        return (TRUE);
     } else {
-        return (FALSE);
+        return (FALSE);
     }
 }
@@ -399 +401 @@
 /******************* DEBUG INFO PRINTING ****************/
 
-static GNode      *mainTarg;    /* the main target, as set by Targ_SetMain */
+static GNode      *mainTarg;    /* the main target, as set by Targ_SetMain */
 /*-
  *-----------------------------------------------------------------------
  * Targ_SetMain --
- *      Set our idea of the main target we'll be creating. Used for
- *      debugging output.
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      "mainTarg" is set to the main target's node.
+ *      Set our idea of the main target we'll be creating. Used for
+ *      debugging output.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      "mainTarg" is set to the main target's node.
  *-----------------------------------------------------------------------
  */
 void
 Targ_SetMain (gn)
-    GNode   *gn;        /* The main target we'll create */
+    GNode   *gn;        /* The main target we'll create */
 {
     mainTarg = gn;
@@ -423 +425 @@
 TargPrintName (gnp, ppath)
     ClientData     gnp;
-    ClientData      ppath;
+    ClientData      ppath;
 {
     GNode *gn = (GNode *) gnp;
@@ -429 +431 @@
 #ifdef notdef
     if (ppath) {
-        if (gn->path) {
-            printf ("[%s]  ", gn->path);
-        }
-        if (gn == mainTarg) {
-            printf ("(MAIN NAME)  ");
-        }
+        if (gn->path) {
+            printf ("[%s]  ", gn->path);
+        }
+        if (gn == mainTarg) {
+            printf ("(MAIN NAME)  ");
+        }
     }
 #endif /* notdef */
@@ -453 +455 @@
  *-----------------------------------------------------------------------
  * Targ_FmtTime --
- *      Format a modification time in some reasonable way and return it.
- *
- * Results:
- *      The time reformatted.
- *
- * Side Effects:
- *      The time is placed in a static area, so it is overwritten
- *      with each call.
+ *      Format a modification time in some reasonable way and return it.
+ *
+ * Results:
+ *      The time reformatted.
+ *
+ * Side Effects:
+ *      The time is placed in a static area, so it is overwritten
+ *      with each call.
  *
  *-----------------------------------------------------------------------
@@ -468 +470 @@
     time_t    time;
 {
-    struct tm           *parts;
-    static char         buf[128];
+    struct tm           *parts;
+    static char         buf[128];
 
     parts = localtime(&time);
@@ -487 +489 @@
  *-----------------------------------------------------------------------
  * Targ_PrintType --
- *      Print out a type field giving only those attributes the user can
- *      set.
+ *      Print out a type field giving only those attributes the user can
+ *      set.
  *
  * Results:
@@ -502 +504 @@
     register int    tbit;
 
-#ifdef __STDC__
-#define PRINTBIT(attr)  case CONCAT(OP_,attr): printf("." #attr " "); break
+#if defined(__STDC__) || defined(__IBMC__)
+#define PRINTBIT(attr)  case CONCAT(OP_,attr): printf("." #attr " "); break
 #define PRINTDBIT(attr) case CONCAT(OP_,attr): if (DEBUG(TARG)) printf("." #attr " "); break
 #else
-#define PRINTBIT(attr)  case CONCAT(OP_,attr): printf(".attr "); break
-#define PRINTDBIT(attr) case CONCAT(OP_,attr): if (DEBUG(TARG)) printf(".attr "); break
+#define PRINTBIT(attr)  case CONCAT(OP_,attr): printf(".attr "); break
+#define PRINTDBIT(attr) case CONCAT(OP_,attr): if (DEBUG(TARG)) printf(".attr "); break
 #endif /* __STDC__ */
 
@@ -513 +515 @@
 
     while (type) {
-        tbit = 1 << (ffs(type) - 1);
-        type &= ~tbit;
-
-        switch(tbit) {
-            PRINTBIT(OPTIONAL);
-            PRINTBIT(USE);
-            PRINTBIT(EXEC);
-            PRINTBIT(IGNORE);
-            PRINTBIT(PRECIOUS);
-            PRINTBIT(SILENT);
-            PRINTBIT(MAKE);
-            PRINTBIT(JOIN);
-            PRINTBIT(INVISIBLE);
-            PRINTBIT(NOTMAIN);
+        tbit = 1 << (ffs(type) - 1);
+        type &= ~tbit;
+
+        switch(tbit) {
+            PRINTBIT(OPTIONAL);
+            PRINTBIT(USE);
+            PRINTBIT(EXEC);
+            PRINTBIT(IGNORE);
+            PRINTBIT(PRECIOUS);
+            PRINTBIT(SILENT);
+            PRINTBIT(MAKE);
+            PRINTBIT(JOIN);
+            PRINTBIT(INVISIBLE);
+            PRINTBIT(NOTMAIN);
 #ifdef USE_ARCHIVES
-            PRINTDBIT(LIB);
+            PRINTDBIT(LIB);
             /*XXX: MEMBER is defined, so CONCAT(OP_,MEMBER) gives OP_"%" */
-            case OP_MEMBER: if (DEBUG(TARG)) printf(".MEMBER "); break;
-            PRINTDBIT(ARCHV);
+            case OP_MEMBER: if (DEBUG(TARG)) printf(".MEMBER "); break;
+            PRINTDBIT(ARCHV);
 #endif
-        }
+        }
     }
 }
@@ -540 +542 @@
  *-----------------------------------------------------------------------
  * TargPrintNode --
- *      print the contents of a node
+ *      print the contents of a node
  *-----------------------------------------------------------------------
  */
@@ -546 +548 @@
 TargPrintNode (gnp, passp)
     ClientData   gnp;
-    ClientData   passp;
+    ClientData   passp;
 {
     GNode         *gn = (GNode *) gnp;
-    int           pass = *(int *) passp;
+    int           pass = *(int *) passp;
     if (!OP_NOP(gn->type)) {
-        printf("#\n");
-        if (gn == mainTarg) {
-            printf("# *** MAIN TARGET ***\n");
-        }
-        if (pass == 2) {
-            if (gn->unmade) {
-                printf("# %d unmade children\n", gn->unmade);
-            } else {
-                printf("# No unmade children\n");
-            }
-            if (! (gn->type & (OP_JOIN|OP_USE|OP_EXEC))) {
-                if (gn->mtime != 0) {
-                    printf("# last modified %s: %s\n",
-                              Targ_FmtTime(gn->mtime),
-                              (gn->made == UNMADE ? "unmade" :
-                               (gn->made == MADE ? "made" :
-                                (gn->made == UPTODATE ? "up-to-date" :
-                                 "error when made"))));
-                } else if (gn->made != UNMADE) {
-                    printf("# non-existent (maybe): %s\n",
-                              (gn->made == MADE ? "made" :
-                               (gn->made == UPTODATE ? "up-to-date" :
-                                (gn->made == ERROR ? "error when made" :
-                                 "aborted"))));
-                } else {
-                    printf("# unmade\n");
-                }
-            }
-            if (!Lst_IsEmpty (gn->iParents)) {
-                printf("# implicit parents: ");
-                Lst_ForEach (gn->iParents, TargPrintName, (ClientData)0);
-                fputc ('\n', stdout);
-            }
-        }
-        if (!Lst_IsEmpty (gn->parents)) {
-            printf("# parents: ");
-            Lst_ForEach (gn->parents, TargPrintName, (ClientData)0);
-            fputc ('\n', stdout);
-        }
-
-        printf("%-16s", gn->name);
-        switch (gn->type & OP_OPMASK) {
-            case OP_DEPENDS:
-                printf(": "); break;
-            case OP_FORCE:
-                printf("! "); break;
-            case OP_DOUBLEDEP:
-                printf(":: "); break;
-        }
-        Targ_PrintType (gn->type);
-        Lst_ForEach (gn->children, TargPrintName, (ClientData)0);
-        fputc ('\n', stdout);
-        Lst_ForEach (gn->commands, Targ_PrintCmd, (ClientData)0);
-        printf("\n\n");
-        if (gn->type & OP_DOUBLEDEP) {
-            Lst_ForEach (gn->cohorts, TargPrintNode, (ClientData)&pass);
-        }
+        printf("#\n");
+        if (gn == mainTarg) {
+            printf("# *** MAIN TARGET ***\n");
+        }
+        if (pass == 2) {
+            if (gn->unmade) {
+                printf("# %d unmade children\n", gn->unmade);
+            } else {
+                printf("# No unmade children\n");
+            }
+            if (! (gn->type & (OP_JOIN|OP_USE|OP_EXEC))) {
+                if (gn->mtime != 0) {
+                    printf("# last modified %s: %s\n",
+                              Targ_FmtTime(gn->mtime),
+                              (gn->made == UNMADE ? "unmade" :
+                               (gn->made == MADE ? "made" :
+                                (gn->made == UPTODATE ? "up-to-date" :
+                                 "error when made"))));
+                } else if (gn->made != UNMADE) {
+                    printf("# non-existent (maybe): %s\n",
+                              (gn->made == MADE ? "made" :
+                               (gn->made == UPTODATE ? "up-to-date" :
+                                (gn->made == ERROR ? "error when made" :
+                                 "aborted"))));
+                } else {
+                    printf("# unmade\n");
+                }
+            }
+            if (!Lst_IsEmpty (gn->iParents)) {
+                printf("# implicit parents: ");
+                Lst_ForEach (gn->iParents, TargPrintName, (ClientData)0);
+                fputc ('\n', stdout);
+            }
+        }
+        if (!Lst_IsEmpty (gn->parents)) {
+            printf("# parents: ");
+            Lst_ForEach (gn->parents, TargPrintName, (ClientData)0);
+            fputc ('\n', stdout);
+        }
+
+        printf("%-16s", gn->name);
+        switch (gn->type & OP_OPMASK) {
+            case OP_DEPENDS:
+                printf(": "); break;
+            case OP_FORCE:
+                printf("! "); break;
+            case OP_DOUBLEDEP:
+                printf(":: "); break;
+        }
+        Targ_PrintType (gn->type);
+        Lst_ForEach (gn->children, TargPrintName, (ClientData)0);
+        fputc ('\n', stdout);
+        Lst_ForEach (gn->commands, Targ_PrintCmd, (ClientData)0);
+        printf("\n\n");
+        if (gn->type & OP_DOUBLEDEP) {
+            Lst_ForEach (gn->cohorts, TargPrintNode, (ClientData)&pass);
+        }
     }
     return (0);
@@ -615 +617 @@
  *-----------------------------------------------------------------------
  * TargPrintOnlySrc --
- *      Print only those targets that are just a source.
- *
- * Results:
- *      0.
- *
- * Side Effects:
- *      The name of each file is printed preceeded by #\t
+ *      Print only those targets that are just a source.
+ *
+ * Results:
+ *      0.
+ *
+ * Side Effects:
+ *      The name of each file is printed preceeded by #\t
  *
  *-----------------------------------------------------------------------
@@ -627 +629 @@
 static int
 TargPrintOnlySrc(gnp, dummy)
-    ClientData    gnp;
-    ClientData    dummy;
-{
-    GNode         *gn = (GNode *) gnp;
+    ClientData    gnp;
+    ClientData    dummy;
+{
+    GNode         *gn = (GNode *) gnp;
     if (OP_NOP(gn->type))
-        printf("#\t%s [%s]\n", gn->name, gn->path ? gn->path : gn->name);
+        printf("#\t%s [%s]\n", gn->name, gn->path ? gn->path : gn->name);
 
     return (dummy ? 0 : 0);
@@ -640 +642 @@
  *-----------------------------------------------------------------------
  * Targ_PrintGraph --
- *      print the entire graph. heh heh
- *
- * Results:
- *      none
- *
- * Side Effects:
- *      lots o' output
+ *      print the entire graph. heh heh
+ *
+ * Results:
+ *      none
+ *
+ * Side Effects:
+ *      lots o' output
  *-----------------------------------------------------------------------
  */
 void
 Targ_PrintGraph (pass)
-    int     pass;       /* Which pass this is. 1 => no processing
-                         * 2 => processing done */
+    int     pass;       /* Which pass this is. 1 => no processing
+                         * 2 => processing done */
 {
     printf("#*** Input graph:\n");

trunk/src/kmk/util.c

@@ -5 +5 @@
 #ifndef lint
 static char rcsid[] = "$FreeBSD: src/usr.bin/make/util.c,v 1.5.2.2 2001/02/13 03:13:58 will Exp $";
+#define KLIBFILEDEF rcsid
 #endif
 
@@ -27 +28 @@
     static char buf[100];
     if (e < 0 || e >= sys_nerr) {
-        sprintf(buf, "Unknown error %d", e);
-        return buf;
+        sprintf(buf, "Unknown error %d", e);
+        return buf;
     }
     else
-        return sys_errlist[e];
+        return sys_errlist[e];
 }
 #endif
@@ -50 +51 @@
 
     if (str == NULL)
-        return NULL;
+        return NULL;
     len = strlen(str) + 1;
     if ((p = emalloc(len)) == NULL)
-        return NULL;
+        return NULL;
 
     return memcpy(p, str, len);
@@ -60 +61 @@
 #endif
 
-#if defined(sun) || defined(__hpux) || defined(__sgi) || defined(__EMX__) || (defined(OS2) && defined(__IBMC__))
+#ifndef USE_KLIB
+#if defined(sun) || defined(__hpux) || defined(__sgi) || defined(__EMX__)
 
 int
@@ -75 +77 @@
 
     if (ptr == NULL)
-        return -1;
+        return -1;
 
     p = ptr;
 
     while (*name)
-        *p++ = *name++;
+        *p++ = *name++;
 
     *p++ = '=';
 
     while (*value)
-        *p++ = *value++;
+        *p++ = *value++;
 
     *p = '\0';
@@ -93 +95 @@
     return len;
 }
+#endif
 #endif
 
@@ -157 +160 @@
 
 /* strrcpy():
- *      Like strcpy, going backwards and returning the new pointer
+ *      Like strcpy, going backwards and returning the new pointer
  */
 static char *
@@ -166 +169 @@
 
     while (len)
-        *--ptr = str[--len];
+        *--ptr = str[--len];
 
     return (ptr);
@@ -185 +188 @@
     /* find the inode of root */
     if (stat("/", &st_root) == -1) {
-        (void) sprintf(pathname,
-                        "getwd: Cannot stat \"/\" (%s)", strerror(errno));
-        return (NULL);
+        (void) sprintf(pathname,
+                        "getwd: Cannot stat \"/\" (%s)", strerror(errno));
+        return (NULL);
     }
     pathbuf[MAXPATHLEN - 1] = '\0';
@@ -196 +199 @@
     /* find the inode of the current directory */
     if (lstat(".", &st_cur) == -1) {
-        (void) sprintf(pathname,
-                        "getwd: Cannot stat \".\" (%s)", strerror(errno));
-        return (NULL);
+        (void) sprintf(pathname,
+                        "getwd: Cannot stat \".\" (%s)", strerror(errno));
+        return (NULL);
     }
     nextpathptr = strrcpy(nextpathptr, "../");
@@ -205 +208 @@
     for (;;) {
 
-        /* look if we found root yet */
-        if (st_cur.st_ino == st_root.st_ino &&
-            DEV_DEV_COMPARE(st_cur.st_dev, st_root.st_dev)) {
-            (void) strcpy(pathname, *pathptr != '/' ? "/" : pathptr);
-            return (pathname);
-        }
-
-        /* open the parent directory */
-        if (stat(nextpathptr, &st_dotdot) == -1) {
-            snprintf(pathname, sizeof(pathname),
-                            "getwd: Cannot stat directory \"%s\" (%s)",
-                            nextpathptr, strerror(errno));
-            return (NULL);
-        }
-        if ((dp = opendir(nextpathptr)) == NULL) {
-             snprintf(pathname, sizeof(pathname),
-                            "getwd: Cannot open directory \"%s\" (%s)",
-                            nextpathptr, strerror(errno));
-            return (NULL);
-        }
-
-        /* look in the parent for the entry with the same inode */
-        if (DEV_DEV_COMPARE(st_dotdot.st_dev, st_cur.st_dev)) {
-            /* Parent has same device. No need to stat every member */
-            for (d = readdir(dp); d != NULL; d = readdir(dp))
-                if (d->d_fileno == st_cur.st_ino)
-                    break;
-        }
-        else {
-            /*
-             * Parent has a different device. This is a mount point so we
-             * need to stat every member
-             */
-            for (d = readdir(dp); d != NULL; d = readdir(dp)) {
-                if (ISDOT(d->d_name) || ISDOTDOT(d->d_name))
-                    continue;
-                (void) strcpy(cur_name_add, d->d_name);
-                if (lstat(nextpathptr, &st_next) == -1) {
-                    snprintf(pathname, sizeof(pathname), "getwd: Cannot stat \"%s\" (%s)",
-                                    d->d_name, strerror(errno));
-                    (void) closedir(dp);
-                    return (NULL);
-                }
-                /* check if we found it yet */
-                if (st_next.st_ino == st_cur.st_ino &&
-                    DEV_DEV_COMPARE(st_next.st_dev, st_cur.st_dev))
-                    break;
-            }
-        }
-        if (d == NULL) {
-            (void) sprintf(pathname, "getwd: Cannot find \".\" in \"..\"");
-            (void) closedir(dp);
-            return (NULL);
-        }
-        st_cur = st_dotdot;
-        pathptr = strrcpy(pathptr, d->d_name);
-        pathptr = strrcpy(pathptr, "/");
-        nextpathptr = strrcpy(nextpathptr, "../");
-        (void) closedir(dp);
-        *cur_name_add = '\0';
+        /* look if we found root yet */
+        if (st_cur.st_ino == st_root.st_ino &&
+            DEV_DEV_COMPARE(st_cur.st_dev, st_root.st_dev)) {
+            (void) strcpy(pathname, *pathptr != '/' ? "/" : pathptr);
+            return (pathname);
+        }
+
+        /* open the parent directory */
+        if (stat(nextpathptr, &st_dotdot) == -1) {
+            snprintf(pathname, sizeof(pathname),
+                            "getwd: Cannot stat directory \"%s\" (%s)",
+                            nextpathptr, strerror(errno));
+            return (NULL);
+        }
+        if ((dp = opendir(nextpathptr)) == NULL) {
+             snprintf(pathname, sizeof(pathname),
+                            "getwd: Cannot open directory \"%s\" (%s)",
+                            nextpathptr, strerror(errno));
+            return (NULL);
+        }
+
+        /* look in the parent for the entry with the same inode */
+        if (DEV_DEV_COMPARE(st_dotdot.st_dev, st_cur.st_dev)) {
+            /* Parent has same device. No need to stat every member */
+            for (d = readdir(dp); d != NULL; d = readdir(dp))
+                if (d->d_fileno == st_cur.st_ino)
+                    break;
+        }
+        else {
+            /*
+             * Parent has a different device. This is a mount point so we
+             * need to stat every member
+             */
+            for (d = readdir(dp); d != NULL; d = readdir(dp)) {
+                if (ISDOT(d->d_name) || ISDOTDOT(d->d_name))
+                    continue;
+                (void) strcpy(cur_name_add, d->d_name);
+                if (lstat(nextpathptr, &st_next) == -1) {
+                    snprintf(pathname, sizeof(pathname), "getwd: Cannot stat \"%s\" (%s)",
+                                    d->d_name, strerror(errno));
+                    (void) closedir(dp);
+                    return (NULL);
+                }
+                /* check if we found it yet */
+                if (st_next.st_ino == st_cur.st_ino &&
+                    DEV_DEV_COMPARE(st_next.st_dev, st_cur.st_dev))
+                    break;
+            }
+        }
+        if (d == NULL) {
+            (void) sprintf(pathname, "getwd: Cannot find \".\" in \"..\"");
+            (void) closedir(dp);
+            return (NULL);
+        }
+        st_cur = st_dotdot;
+        pathptr = strrcpy(pathptr, d->d_name);
+        pathptr = strrcpy(pathptr, "/");
+        nextpathptr = strrcpy(nextpathptr, "../");
+        (void) closedir(dp);
+        *cur_name_add = '\0';
     }
 } /* end getwd */
@@ -336 +339 @@
 
     if (sigaction(s, &sa, &osa) == -1)
-        return SIG_ERR;
+        return SIG_ERR;
     else
-        return osa.sa_handler;
-}
-
-#endif
+        return osa.sa_handler;
+}
+
+#endif

trunk/src/kmk/var.c

@@ -1 +1 @@
 /*
  * 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.
@@ -18 +18 @@
  * 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
@@ -39 +39 @@
 #ifndef lint
 #if 0
-static char sccsid[] = "@(#)var.c       8.3 (Berkeley) 3/19/94";
+static char sccsid[] = "@(#)var.c       8.3 (Berkeley) 3/19/94";
 #else
 static const char rcsid[] =
   "$FreeBSD: src/usr.bin/make/var.c,v 1.16.2.3 2002/02/27 14:18:57 cjc Exp $";
 #endif
+#define KLIBFILEDEF rcsid
 #endif /* not lint */
 
 /*-
  * var.c --
- *      Variable-handling functions
+ *      Variable-handling functions
  *
  * Interface:
- *      Var_Set             Set the value of a variable in the given
- *                          context. The variable is created if it doesn't
- *                          yet exist. The value and variable name need not
- *                          be preserved.
- *
- *      Var_Append          Append more characters to an existing variable
- *                          in the given context. The variable needn't
- *                          exist already -- it will be created if it doesn't.
- *                          A space is placed between the old value and the
- *                          new one.
- *
- *      Var_Exists          See if a variable exists.
- *
- *      Var_Value           Return the value of a variable in a context or
- *                          NULL if the variable is undefined.
- *
- *      Var_Subst           Substitute named variable, or all variables if
- *                          NULL in a string using
- *                          the given context as the top-most one. If the
- *                          third argument is non-zero, Parse_Error is
- *                          called if any variables are undefined.
- *
- *      Var_Parse           Parse a variable expansion from a string and
- *                          return the result and the number of characters
- *                          consumed.
- *
- *      Var_Delete          Delete a variable in a context.
- *
- *      Var_Init            Initialize this module.
+ *      Var_Set             Set the value of a variable in the given
+ *                          context. The variable is created if it doesn't
+ *                          yet exist. The value and variable name need not
+ *                          be preserved.
+ *
+ *      Var_Append          Append more characters to an existing variable
+ *                          in the given context. The variable needn't
+ *                          exist already -- it will be created if it doesn't.
+ *                          A space is placed between the old value and the
+ *                          new one.
+ *
+ *      Var_Exists          See if a variable exists.
+ *
+ *      Var_Value           Return the value of a variable in a context or
+ *                          NULL if the variable is undefined.
+ *
+ *      Var_Subst           Substitute named variable, or all variables if
+ *                          NULL in a string using
+ *                          the given context as the top-most one. If the
+ *                          third argument is non-zero, Parse_Error is
+ *                          called if any variables are undefined.
+ *
+ *      Var_Parse           Parse a variable expansion from a string and
+ *                          return the result and the number of characters
+ *                          consumed.
+ *
+ *      Var_Delete          Delete a variable in a context.
+ *
+ *      Var_Init            Initialize this module.
  *
  * Debugging:
- *      Var_Dump            Print out all variables defined in the given
- *                          context.
+ *      Var_Dump            Print out all variables defined in the given
+ *                          context.
  *
  * XXX: There's a lot of duplication in these functions.
@@ -106 +107 @@
  * a flag, as things outside this module don't give a hoot.
  */
-char    var_Error[] = "";
+char    var_Error[] = "";
 
 /*
@@ -113 +114 @@
  * identical string instances...
  */
-static char     varNoError[] = "";
+static char     varNoError[] = "";
 
 /*
  * Internally, variables are contained in four different contexts.
- *      1) the environment. They may not be changed. If an environment
- *          variable is appended-to, the result is placed in the global
- *          context.
- *      2) the global context. Variables set in the Makefile are located in
- *          the global context. It is the penultimate context searched when
- *          substituting.
- *      3) the command-line context. All variables set on the command line
- *         are placed in this context. They are UNALTERABLE once placed here.
- *      4) the local context. Each target has associated with it a context
- *         list. On this list are located the structures describing such
- *         local variables as $(@) and $(*)
+ *      1) the environment. They may not be changed. If an environment
+ *          variable is appended-to, the result is placed in the global
+ *          context.
+ *      2) the global context. Variables set in the Makefile are located in
+ *          the global context. It is the penultimate context searched when
+ *          substituting.
+ *      3) the command-line context. All variables set on the command line
+ *         are placed in this context. They are UNALTERABLE once placed here.
+ *      4) the local context. Each target has associated with it a context
+ *         list. On this list are located the structures describing such
+ *         local variables as $(@) and $(*)
  * The four contexts are searched in the reverse order from which they are
  * listed.
@@ -134 +135 @@
 GNode          *VAR_CMD;      /* variables defined on the command-line */
 
-static Lst      allVars;      /* List of all variables */
-
-#define FIND_CMD        0x1   /* look in VAR_CMD when searching */
-#define FIND_GLOBAL     0x2   /* look in VAR_GLOBAL as well */
-#define FIND_ENV        0x4   /* look in the environment also */
+static Lst      allVars;      /* List of all variables */
+
+#define FIND_CMD        0x1   /* look in VAR_CMD when searching */
+#define FIND_GLOBAL     0x2   /* look in VAR_GLOBAL as well */
+#define FIND_ENV        0x4   /* look in the environment also */
 
 typedef struct Var {
-    char          *name;        /* the variable's name */
-    Buffer        val;          /* its value */
-    int           flags;        /* miscellaneous status flags */
-#define VAR_IN_USE      1           /* Variable's value currently being used.
-                                     * Used to avoid recursion */
-#define VAR_FROM_ENV    2           /* Variable comes from the environment */
-#define VAR_JUNK        4           /* Variable is a junk variable that
-                                     * should be destroyed when done with
-                                     * it. Used by Var_Parse for undefined,
-                                     * modified variables */
+    char          *name;        /* the variable's name */
+    Buffer        val;          /* its value */
+    int           flags;        /* miscellaneous status flags */
+#define VAR_IN_USE      1           /* Variable's value currently being used.
+                                     * Used to avoid recursion */
+#define VAR_FROM_ENV    2           /* Variable comes from the environment */
+#define VAR_JUNK        4           /* Variable is a junk variable that
+                                     * should be destroyed when done with
+                                     * it. Used by Var_Parse for undefined,
+                                     * modified variables */
 }  Var;
 
 /* Var*Pattern flags */
-#define VAR_SUB_GLOBAL  0x01    /* Apply substitution globally */
-#define VAR_SUB_ONE     0x02    /* Apply substitution to one word */
-#define VAR_SUB_MATCHED 0x04    /* There was a match */
-#define VAR_MATCH_START 0x08    /* Match at start of word */
-#define VAR_MATCH_END   0x10    /* Match at end of word */
-#define VAR_NOSUBST     0x20    /* don't expand vars in VarGetPattern */
+#define VAR_SUB_GLOBAL  0x01    /* Apply substitution globally */
+#define VAR_SUB_ONE     0x02    /* Apply substitution to one word */
+#define VAR_SUB_MATCHED 0x04    /* There was a match */
+#define VAR_MATCH_START 0x08    /* Match at start of word */
+#define VAR_MATCH_END   0x10    /* Match at end of word */
+#define VAR_NOSUBST     0x20    /* don't expand vars in VarGetPattern */
 
 typedef struct {
-    char          *lhs;     /* String to match */
-    int           leftLen;  /* Length of string */
-    char          *rhs;     /* Replacement string (w/ &'s removed) */
-    int           rightLen; /* Length of replacement */
-    int           flags;
+    char          *lhs;     /* String to match */
+    int           leftLen;  /* Length of string */
+    char          *rhs;     /* Replacement string (w/ &'s removed) */
+    int           rightLen; /* Length of replacement */
+    int           flags;
 } VarPattern;
 
 typedef struct {
-    regex_t        re;
-    int            nsub;
-    regmatch_t    *matches;
-    char          *replace;
-    int            flags;
+    regex_t        re;
+    int            nsub;
+    regmatch_t    *matches;
+    char          *replace;
+    int            flags;
 } VarREPattern;
 
@@ -185 +186 @@
 static Boolean VarSuffix __P((char *, Boolean, Buffer, ClientData));
 static Boolean VarRoot __P((char *, Boolean, Buffer, ClientData));
-#if defined(NMAKE) || defined(KMK)
+#ifdef USE_BASEANDROOT_MODIFIERS
 static Boolean VarBase __P((char *, Boolean, Buffer, ClientData));
 #endif
@@ -197 +198 @@
 static Boolean VarSubstitute __P((char *, Boolean, Buffer, ClientData));
 static char *VarGetPattern __P((GNode *, int, char **, int, int *, int *,
-                                VarPattern *));
+                                VarPattern *));
 static char *VarQuote __P((char *));
 static char *VarModify __P((char *, Boolean (*)(char *, Boolean, Buffer,
-                                                ClientData),
-                            ClientData));
+                                                ClientData),
+                            ClientData));
 static int VarPrintVar __P((ClientData, ClientData));
 
@@ -207 +208 @@
  *-----------------------------------------------------------------------
  * VarCmp  --
- *      See if the given variable matches the named one. Called from
- *      Lst_Find when searching for a variable of a given name.
- *
- * Results:
- *      0 if they match. non-zero otherwise.
- *
- * Side Effects:
- *      none
+ *      See if the given variable matches the named one. Called from
+ *      Lst_Find when searching for a variable of a given name.
+ *
+ * Results:
+ *      0 if they match. non-zero otherwise.
+ *
+ * Side Effects:
+ *      none
  *-----------------------------------------------------------------------
  */
 static int
 VarCmp (v, name)
-    ClientData     v;           /* VAR structure to compare */
-    ClientData     name;        /* name to look for */
+    ClientData     v;           /* VAR structure to compare */
+    ClientData     name;        /* name to look for */
 {
     return (strcmp ((char *) name, ((Var *) v)->name));
@@ -228 +229 @@
  *-----------------------------------------------------------------------
  * StrCmp  --
- *      See if the given strings matches. Called from
- *      Lst_Find when searching for a environment-variable-overrided var.
- *
- * Results:
- *      0 if they match. non-zero otherwise.
- *
- * Side Effects:
- *      none
+ *      See if the given strings matches. Called from
+ *      Lst_Find when searching for a environment-variable-overrided var.
+ *
+ * Results:
+ *      0 if they match. non-zero otherwise.
+ *
+ * Side Effects:
+ *      none
  *-----------------------------------------------------------------------
  */
@@ -251 +252 @@
  *-----------------------------------------------------------------------
  * VarFind --
- *      Find the given variable in the given context and any other contexts
- *      indicated.
- *
- * Results:
- *      A pointer to the structure describing the desired variable or
- *      NIL if the variable does not exist.
- *
- * Side Effects:
- *      None
+ *      Find the given variable in the given context and any other contexts
+ *      indicated.
+ *
+ * Results:
+ *      A pointer to the structure describing the desired variable or
+ *      NIL if the variable does not exist.
+ *
+ * Side Effects:
+ *      None
  *-----------------------------------------------------------------------
  */
 static Var *
 VarFind (name, ctxt, flags)
-    char                *name;  /* name to find */
-    GNode               *ctxt;  /* context in which to find it */
-    int                 flags;  /* FIND_GLOBAL set means to look in the
-                                 * VAR_GLOBAL context as well.
-                                 * FIND_CMD set means to look in the VAR_CMD
-                                 * context also.
-                                 * FIND_ENV set means to look in the
-                                 * environment */
-{
-    Boolean             localCheckEnvFirst;
-    LstNode             var;
-    Var                 *v;
-
-        /*
-         * If the variable name begins with a '.', it could very well be one of
-         * the local ones.  We check the name against all the local variables
-         * and substitute the short version in for 'name' if it matches one of
-         * them.
-         */
-        if (*name == '.' && isupper((unsigned char) name[1]))
-                switch (name[1]) {
-                case 'A':
-                        if (!strcmp(name, ".ALLSRC"))
-                                name = ALLSRC;
+    char                *name;  /* name to find */
+    GNode               *ctxt;  /* context in which to find it */
+    int                 flags;  /* FIND_GLOBAL set means to look in the
+                                 * VAR_GLOBAL context as well.
+                                 * FIND_CMD set means to look in the VAR_CMD
+                                 * context also.
+                                 * FIND_ENV set means to look in the
+                                 * environment */
+{
+    Boolean             localCheckEnvFirst;
+    LstNode             var;
+    Var                 *v;
+
+        /*
+         * If the variable name begins with a '.', it could very well be one of
+         * the local ones.  We check the name against all the local variables
+         * and substitute the short version in for 'name' if it matches one of
+         * them.
+         */
+        if (*name == '.' && isupper((unsigned char) name[1]))
+                switch (name[1]) {
+                case 'A':
+                        if (!strcmp(name, ".ALLSRC"))
+                                name = ALLSRC;
 #ifdef USE_ARCHIVES
-                        if (!strcmp(name, ".ARCHIVE"))
-                                name = ARCHIVE;
+                        if (!strcmp(name, ".ARCHIVE"))
+                                name = ARCHIVE;
 #endif
-                        break;
-                case 'I':
-                        if (!strcmp(name, ".IMPSRC"))
-                                name = IMPSRC;
-                        break;
+                        break;
+                case 'I':
+                        if (!strcmp(name, ".IMPSRC"))
+                                name = IMPSRC;
+                        break;
 #ifdef USE_ARCHIVES
-                case 'M':
-                        if (!strcmp(name, ".MEMBER"))
-                                name = MEMBER;
-                        break;
+                case 'M':
+                        if (!strcmp(name, ".MEMBER"))
+                                name = MEMBER;
+                        break;
 #endif
-                case 'O':
-                        if (!strcmp(name, ".OODATE"))
-                                name = OODATE;
-                        break;
-                case 'P':
-                        if (!strcmp(name, ".PREFIX"))
-                                name = PREFIX;
+                case 'O':
+                        if (!strcmp(name, ".OODATE"))
+                                name = OODATE;
+                        break;
+                case 'P':
+                        if (!strcmp(name, ".PREFIX"))
+                                name = PREFIX;
                         #ifdef USE_PARENTS
                         else if (!strcmp(name, ".PARENTS"))
                                 name = PARENTS;
                         #endif
-                        break;
-                case 'T':
-                        if (!strcmp(name, ".TARGET"))
-                                name = TARGET;
-                        break;
-                }
+                        break;
+                case 'T':
+                        if (!strcmp(name, ".TARGET"))
+                                name = TARGET;
+                        break;
+                }
 
     /*
@@ -326 +327 @@
      */
     if (Lst_Find (envFirstVars, (ClientData)name,
-                  (int (*)(ClientData, ClientData)) VarStrCmp) != NILLNODE)
+                  (int (*)(ClientData, ClientData)) VarStrCmp) != NILLNODE)
     {
-        localCheckEnvFirst = TRUE;
+        localCheckEnvFirst = TRUE;
     } else {
-        localCheckEnvFirst = FALSE;
+        localCheckEnvFirst = FALSE;
     }
 
@@ -341 +342 @@
 
     if ((var == NILLNODE) && (flags & FIND_CMD) && (ctxt != VAR_CMD)) {
-        var = Lst_Find (VAR_CMD->context, (ClientData)name, VarCmp);
+        var = Lst_Find (VAR_CMD->context, (ClientData)name, VarCmp);
     }
     if ((var == NILLNODE) && (flags & FIND_GLOBAL) && (ctxt != VAR_GLOBAL) &&
-        !checkEnvFirst && !localCheckEnvFirst)
+        !checkEnvFirst && !localCheckEnvFirst)
     {
-        var = Lst_Find (VAR_GLOBAL->context, (ClientData)name, VarCmp);
+        var = Lst_Find (VAR_GLOBAL->context, (ClientData)name, VarCmp);
     }
     if ((var == NILLNODE) && (flags & FIND_ENV)) {
         #ifdef USE_KLIB
-        const char *env;
-        if ((env = kEnvGet (name)) != NULL) {
+        const char *env;
+        if ((env = kEnvGet (name)) != NULL) {
         #else
         char *env;
-        if ((env = getenv (name)) != NULL) {
+        if ((env = getenv (name)) != NULL) {
         #endif
-            int         len;
-
-            v = (Var *) emalloc(sizeof(Var));
-            v->name = estrdup(name);
-
-            len = strlen(env);
-
-            v->val = Buf_Init(len);
-            Buf_AddBytes(v->val, len, (Byte *)env);
-
-            v->flags = VAR_FROM_ENV;
-            return (v);
-        } else if ((checkEnvFirst || localCheckEnvFirst) &&
-                   (flags & FIND_GLOBAL) && (ctxt != VAR_GLOBAL))
-        {
-            var = Lst_Find (VAR_GLOBAL->context, (ClientData)name, VarCmp);
-            if (var == NILLNODE) {
-                return ((Var *) NIL);
-            } else {
-                return ((Var *)Lst_Datum(var));
-            }
-        } else {
-            return((Var *)NIL);
-        }
+            int         len;
+
+            v = (Var *) emalloc(sizeof(Var));
+            v->name = estrdup(name);
+
+            len = strlen(env);
+
+            v->val = Buf_Init(len);
+            Buf_AddBytes(v->val, len, (Byte *)env);
+
+            v->flags = VAR_FROM_ENV;
+            return (v);
+        } else if ((checkEnvFirst || localCheckEnvFirst) &&
+                   (flags & FIND_GLOBAL) && (ctxt != VAR_GLOBAL))
+        {
+            var = Lst_Find (VAR_GLOBAL->context, (ClientData)name, VarCmp);
+            if (var == NILLNODE) {
+                return ((Var *) NIL);
+            } else {
+                return ((Var *)Lst_Datum(var));
+            }
+        } else {
+            return((Var *)NIL);
+        }
     } else if (var == NILLNODE) {
-        return ((Var *) NIL);
+        return ((Var *) NIL);
     } else {
-        return ((Var *) Lst_Datum (var));
+        return ((Var *) Lst_Datum (var));
     }
 }
@@ -390 +391 @@
  *-----------------------------------------------------------------------
  * VarAdd  --
- *      Add a new variable of name name and value val to the given context
- *
- * Results:
- *      None
- *
- * Side Effects:
- *      The new variable is placed at the front of the given context
- *      The name and val arguments are duplicated so they may
- *      safely be freed.
+ *      Add a new variable of name name and value val to the given context
+ *
+ * Results:
+ *      None
+ *
+ * Side Effects:
+ *      The new variable is placed at the front of the given context
+ *      The name and val arguments are duplicated so they may
+ *      safely be freed.
  *-----------------------------------------------------------------------
  */
 static void
 VarAdd (name, val, ctxt)
-    char           *name;       /* name of variable to add */
-    char           *val;        /* value to set it to */
-    GNode          *ctxt;       /* context in which to set it */
+    char           *name;       /* name of variable to add */
+    char           *val;        /* value to set it to */
+    GNode          *ctxt;       /* context in which to set it */
 {
     register Var   *v;
-    int           len;
+    int           len;
 
     v = (Var *) emalloc (sizeof (Var));
@@ -423 +424 @@
     (void) Lst_AtEnd (allVars, (ClientData) v);
     if (DEBUG(VAR)) {
-        printf("%s:%s = %s\n", ctxt->name, name, val);
+        printf("%s:%s = %s\n", ctxt->name, name, val);
     }
 }
@@ -431 +432 @@
  *-----------------------------------------------------------------------
  * VarDelete  --
- *      Delete a variable and all the space associated with it.
- *
- * Results:
- *      None
- *
- * Side Effects:
- *      None
+ *      Delete a variable and all the space associated with it.
+ *
+ * Results:
+ *      None
+ *
+ * Side Effects:
+ *      None
  *-----------------------------------------------------------------------
  */
@@ -455 +456 @@
  *-----------------------------------------------------------------------
  * Var_Delete --
- *      Remove a variable from a context.
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      The Var structure is removed and freed.
+ *      Remove a variable from a context.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      The Var structure is removed and freed.
  *
  *-----------------------------------------------------------------------
@@ -467 +468 @@
 void
 Var_Delete(name, ctxt)
-    char          *name;
-    GNode         *ctxt;
-{
-    LstNode       ln;
+    char          *name;
+    GNode         *ctxt;
+{
+    LstNode       ln;
 
     if (DEBUG(VAR)) {
-        printf("%s:delete %s\n", ctxt->name, name);
+        printf("%s:delete %s\n", ctxt->name, name);
     }
     ln = Lst_Find(ctxt->context, (ClientData)name, VarCmp);
     if (ln != NILLNODE) {
-        register Var      *v;
-
-        v = (Var *)Lst_Datum(ln);
-        Lst_Remove(ctxt->context, ln);
-        ln = Lst_Member(allVars, v);
-        Lst_Remove(allVars, ln);
-        VarDelete((ClientData) v);
+        register Var      *v;
+
+        v = (Var *)Lst_Datum(ln);
+        Lst_Remove(ctxt->context, ln);
+        ln = Lst_Member(allVars, v);
+        Lst_Remove(allVars, ln);
+        VarDelete((ClientData) v);
     }
 }
@@ -490 +491 @@
  *-----------------------------------------------------------------------
  * Var_Set --
- *      Set the variable name to the value val in the given context.
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      If the variable doesn't yet exist, a new record is created for it.
- *      Else the old value is freed and the new one stuck in its place
+ *      Set the variable name to the value val in the given context.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      If the variable doesn't yet exist, a new record is created for it.
+ *      Else the old value is freed and the new one stuck in its place
  *
  * Notes:
- *      The variable is searched for only in its context before being
- *      created in that context. I.e. if the context is VAR_GLOBAL,
- *      only VAR_GLOBAL->context is searched. Likewise if it is VAR_CMD, only
- *      VAR_CMD->context is searched. This is done to avoid the literally
- *      thousands of unnecessary strcmp's that used to be done to
- *      set, say, $(@) or $(<).
+ *      The variable is searched for only in its context before being
+ *      created in that context. I.e. if the context is VAR_GLOBAL,
+ *      only VAR_GLOBAL->context is searched. Likewise if it is VAR_CMD, only
+ *      VAR_CMD->context is searched. This is done to avoid the literally
+ *      thousands of unnecessary strcmp's that used to be done to
+ *      set, say, $(@) or $(<).
  *-----------------------------------------------------------------------
  */
 void
 Var_Set (name, val, ctxt)
-    char           *name;       /* name of variable to set */
-    char           *val;        /* value to give to the variable */
-    GNode          *ctxt;       /* context in which to set it */
+    char           *name;       /* name of variable to set */
+    char           *val;        /* value to give to the variable */
+    GNode          *ctxt;       /* context in which to set it */
 {
     register Var   *v;
@@ -523 +524 @@
     v = VarFind (name, ctxt, 0);
     if (v == (Var *) NIL) {
-        VarAdd (name, val, ctxt);
+        VarAdd (name, val, ctxt);
     } else {
-        Buf_Discard(v->val, Buf_Size(v->val));
-        Buf_AddBytes(v->val, strlen(val), (Byte *)val);
-
-        if (DEBUG(VAR)) {
-            printf("%s:%s = %s\n", ctxt->name, name, val);
-        }
+        Buf_Discard(v->val, Buf_Size(v->val));
+        Buf_AddBytes(v->val, strlen(val), (Byte *)val);
+
+        if (DEBUG(VAR)) {
+            printf("%s:%s = %s\n", ctxt->name, name, val);
+        }
     }
     /*
@@ -540 +541 @@
         kEnvSet(name, val, TRUE);
         #else
-        setenv(name, val, 1);
+        setenv(name, val, 1);
         #endif
     }
@@ -548 +549 @@
  *-----------------------------------------------------------------------
  * Var_Append --
- *      The variable of the given name has the given value appended to it in
- *      the given context.
- *
- * Results:
- *      None
- *
- * Side Effects:
- *      If the variable doesn't exist, it is created. Else the strings
- *      are concatenated (with a space in between).
+ *      The variable of the given name has the given value appended to it in
+ *      the given context.
+ *
+ * Results:
+ *      None
+ *
+ * Side Effects:
+ *      If the variable doesn't exist, it is created. Else the strings
+ *      are concatenated (with a space in between).
  *
  * Notes:
- *      Only if the variable is being sought in the global context is the
- *      environment searched.
- *      XXX: Knows its calling circumstances in that if called with ctxt
- *      an actual target, it will only search that context since only
- *      a local variable could be being appended to. This is actually
- *      a big win and must be tolerated.
+ *      Only if the variable is being sought in the global context is the
+ *      environment searched.
+ *      XXX: Knows its calling circumstances in that if called with ctxt
+ *      an actual target, it will only search that context since only
+ *      a local variable could be being appended to. This is actually
+ *      a big win and must be tolerated.
  *-----------------------------------------------------------------------
  */
 void
 Var_Append (name, val, ctxt)
-    char           *name;       /* Name of variable to modify */
-    char           *val;        /* String to append to it */
-    GNode          *ctxt;       /* Context in which this should occur */
+    char           *name;       /* Name of variable to modify */
+    char           *val;        /* String to append to it */
+    GNode          *ctxt;       /* Context in which this should occur */
 {
     register Var   *v;
@@ -578 +579 @@
 
     if (v == (Var *) NIL) {
-        VarAdd (name, val, ctxt);
+        VarAdd (name, val, ctxt);
     } else {
-        Buf_AddByte(v->val, (Byte)' ');
-        Buf_AddBytes(v->val, strlen(val), (Byte *)val);
-
-        if (DEBUG(VAR)) {
-            printf("%s:%s = %s\n", ctxt->name, name,
-                   (char *) Buf_GetAll(v->val, (int *)NULL));
-        }
-
-        if (v->flags & VAR_FROM_ENV) {
-            /*
-             * If the original variable came from the environment, we
-             * have to install it in the global context (we could place
-             * it in the environment, but then we should provide a way to
-             * export other variables...)
-             */
-            v->flags &= ~VAR_FROM_ENV;
-            Lst_AtFront(ctxt->context, (ClientData)v);
-        }
+        Buf_AddByte(v->val, (Byte)' ');
+        Buf_AddBytes(v->val, strlen(val), (Byte *)val);
+
+        if (DEBUG(VAR)) {
+            printf("%s:%s = %s\n", ctxt->name, name,
+                   (char *) Buf_GetAll(v->val, (int *)NULL));
+        }
+
+        if (v->flags & VAR_FROM_ENV) {
+            /*
+             * If the original variable came from the environment, we
+             * have to install it in the global context (we could place
+             * it in the environment, but then we should provide a way to
+             * export other variables...)
+             */
+            v->flags &= ~VAR_FROM_ENV;
+            Lst_AtFront(ctxt->context, (ClientData)v);
+        }
     }
 }
@@ -604 +605 @@
  *-----------------------------------------------------------------------
  * Var_Exists --
- *      See if the given variable exists.
- *
- * Results:
- *      TRUE if it does, FALSE if it doesn't
- *
- * Side Effects:
- *      None.
+ *      See if the given variable exists.
+ *
+ * Results:
+ *      TRUE if it does, FALSE if it doesn't
+ *
+ * Side Effects:
+ *      None.
  *
  *-----------------------------------------------------------------------
@@ -616 +617 @@
 Boolean
 Var_Exists(name, ctxt)
-    char          *name;        /* Variable to find */
-    GNode         *ctxt;        /* Context in which to start search */
-{
-    Var           *v;
+    char          *name;        /* Variable to find */
+    GNode         *ctxt;        /* Context in which to start search */
+{
+    Var           *v;
 
     v = VarFind(name, ctxt, FIND_CMD|FIND_GLOBAL|FIND_ENV);
 
     if (v == (Var *)NIL) {
-        return(FALSE);
+        return(FALSE);
     } else if (v->flags & VAR_FROM_ENV) {
-        efree(v->name);
-        Buf_Destroy(v->val, TRUE);
-        efree((char *)v);
+        efree(v->name);
+        Buf_Destroy(v->val, TRUE);
+        efree((char *)v);
     }
     return(TRUE);
@@ -636 +637 @@
  *-----------------------------------------------------------------------
  * Var_Value --
- *      Return the value of the named variable in the given context
- *
- * Results:
- *      The value if the variable exists, NULL if it doesn't
- *
- * Side Effects:
- *      None
+ *      Return the value of the named variable in the given context
+ *
+ * Results:
+ *      The value if the variable exists, NULL if it doesn't
+ *
+ * Side Effects:
+ *      None
  *-----------------------------------------------------------------------
  */
 char *
 Var_Value (name, ctxt, frp)
-    char           *name;       /* name to find */
-    GNode          *ctxt;       /* context in which to search for it */
-    char           **frp;
+    char           *name;       /* name to find */
+    GNode          *ctxt;       /* context in which to search for it */
+    char           **frp;
 {
     Var            *v;
@@ -656 +657 @@
     *frp = NULL;
     if (v != (Var *) NIL) {
-        char *p = ((char *)Buf_GetAll(v->val, (int *)NULL));
-        if (v->flags & VAR_FROM_ENV) {
-            Buf_Destroy(v->val, FALSE);
-            efree((Address) v);
-            *frp = p;
-        }
-        return p;
+        char *p = ((char *)Buf_GetAll(v->val, (int *)NULL));
+        if (v->flags & VAR_FROM_ENV) {
+            Buf_Destroy(v->val, FALSE);
+            efree((Address) v);
+            *frp = p;
+        }
+        return p;
     } else {
-        return ((char *) NULL);
+        return ((char *) NULL);
     }
 }
@@ -671 +672 @@
  *-----------------------------------------------------------------------
  * VarHead --
- *      Remove the tail of the given word and place the result in the given
- *      buffer.
- *
- * Results:
- *      TRUE if characters were added to the buffer (a space needs to be
- *      added to the buffer before the next word).
- *
- * Side Effects:
- *      The trimmed word is added to the buffer.
+ *      Remove the tail of the given word and place the result in the given
+ *      buffer.
+ *
+ * Results:
+ *      TRUE if characters were added to the buffer (a space needs to be
+ *      added to the buffer before the next word).
+ *
+ * Side Effects:
+ *      The trimmed word is added to the buffer.
  *
  *-----------------------------------------------------------------------
@@ -685 +686 @@
 static Boolean
 VarHead (word, addSpace, buf, dummy)
-    char          *word;        /* Word to trim */
-    Boolean       addSpace;     /* True if need to add a space to the buffer
-                                 * before sticking in the head */
-    Buffer        buf;          /* Buffer in which to store it */
-    ClientData    dummy;
+    char          *word;        /* Word to trim */
+    Boolean       addSpace;     /* True if need to add a space to the buffer
+                                 * before sticking in the head */
+    Buffer        buf;          /* Buffer in which to store it */
+    ClientData    dummy;
 {
     register char *slash;
@@ -695 +696 @@
     slash = strrchr (word, '/');
     if (slash != (char *)NULL) {
-        if (addSpace) {
-            Buf_AddByte (buf, (Byte)' ');
-        }
-        *slash = '\0';
-        Buf_AddBytes (buf, strlen (word), (Byte *)word);
-        *slash = '/';
-        return (TRUE);
+        if (addSpace) {
+            Buf_AddByte (buf, (Byte)' ');
+        }
+        *slash = '\0';
+        Buf_AddBytes (buf, strlen (word), (Byte *)word);
+        *slash = '/';
+        return (TRUE);
     } else {
-        /*
-         * If no directory part, give . (q.v. the POSIX standard)
-         */
-        if (addSpace) {
-            Buf_AddBytes(buf, 2, (Byte *)" .");
-        } else {
-            Buf_AddByte(buf, (Byte)'.');
-        }
+        /*
+         * If no directory part, give . (q.v. the POSIX standard)
+         */
+        if (addSpace) {
+            Buf_AddBytes(buf, 2, (Byte *)" .");
+        } else {
+            Buf_AddByte(buf, (Byte)'.');
+        }
     }
     return(dummy ? TRUE : TRUE);
@@ -718 +719 @@
  *-----------------------------------------------------------------------
  * VarTail --
- *      Remove the head of the given word and place the result in the given
- *      buffer.
- *
- * Results:
- *      TRUE if characters were added to the buffer (a space needs to be
- *      added to the buffer before the next word).
- *
- * Side Effects:
- *      The trimmed word is added to the buffer.
+ *      Remove the head of the given word and place the result in the given
+ *      buffer.
+ *
+ * Results:
+ *      TRUE if characters were added to the buffer (a space needs to be
+ *      added to the buffer before the next word).
+ *
+ * Side Effects:
+ *      The trimmed word is added to the buffer.
  *
  *-----------------------------------------------------------------------
@@ -732 +733 @@
 static Boolean
 VarTail (word, addSpace, buf, dummy)
-    char          *word;        /* Word to trim */
-    Boolean       addSpace;     /* TRUE if need to stick a space in the
-                                 * buffer before adding the tail */
-    Buffer        buf;          /* Buffer in which to store it */
-    ClientData    dummy;
+    char          *word;        /* Word to trim */
+    Boolean       addSpace;     /* TRUE if need to stick a space in the
+                                 * buffer before adding the tail */
+    Buffer        buf;          /* Buffer in which to store it */
+    ClientData    dummy;
 {
     register char *slash;
 
     if (addSpace) {
-        Buf_AddByte (buf, (Byte)' ');
+        Buf_AddByte (buf, (Byte)' ');
     }
 
     slash = strrchr (word, '/');
     if (slash != (char *)NULL) {
-        *slash++ = '\0';
-        Buf_AddBytes (buf, strlen(slash), (Byte *)slash);
-        slash[-1] = '/';
+        *slash++ = '\0';
+        Buf_AddBytes (buf, strlen(slash), (Byte *)slash);
+        slash[-1] = '/';
     } else {
-        Buf_AddBytes (buf, strlen(word), (Byte *)word);
+        Buf_AddBytes (buf, strlen(word), (Byte *)word);
     }
     return (dummy ? TRUE : TRUE);
@@ -758 +759 @@
  *-----------------------------------------------------------------------
  * VarSuffix --
- *      Place the suffix of the given word in the given buffer.
- *
- * Results:
- *      TRUE if characters were added to the buffer (a space needs to be
- *      added to the buffer before the next word).
- *
- * Side Effects:
- *      The suffix from the word is placed in the buffer.
+ *      Place the suffix of the given word in the given buffer.
+ *
+ * Results:
+ *      TRUE if characters were added to the buffer (a space needs to be
+ *      added to the buffer before the next word).
+ *
+ * Side Effects:
+ *      The suffix from the word is placed in the buffer.
  *
  *-----------------------------------------------------------------------
@@ -771 +772 @@
 static Boolean
 VarSuffix (word, addSpace, buf, dummy)
-    char          *word;        /* Word to trim */
-    Boolean       addSpace;     /* TRUE if need to add a space before placing
-                                 * the suffix in the buffer */
-    Buffer        buf;          /* Buffer in which to store it */
-    ClientData    dummy;
+    char          *word;        /* Word to trim */
+    Boolean       addSpace;     /* TRUE if need to add a space before placing
+                                 * the suffix in the buffer */
+    Buffer        buf;          /* Buffer in which to store it */
+    ClientData    dummy;
 {
     register char *dot;
@@ -781 +782 @@
     dot = strrchr (word, '.');
     if (dot != (char *)NULL) {
-        if (addSpace) {
-            Buf_AddByte (buf, (Byte)' ');
-        }
-        *dot++ = '\0';
-        Buf_AddBytes (buf, strlen (dot), (Byte *)dot);
-        dot[-1] = '.';
-        addSpace = TRUE;
+        if (addSpace) {
+            Buf_AddByte (buf, (Byte)' ');
+        }
+        *dot++ = '\0';
+        Buf_AddBytes (buf, strlen (dot), (Byte *)dot);
+        dot[-1] = '.';
+        addSpace = TRUE;
     }
     return (dummy ? addSpace : addSpace);
@@ -795 +796 @@
  *-----------------------------------------------------------------------
  * VarRoot --
- *      Remove the suffix of the given word and place the result in the
- *      buffer.
- *
- * Results:
- *      TRUE if characters were added to the buffer (a space needs to be
- *      added to the buffer before the next word).
- *
- * Side Effects:
- *      The trimmed word is added to the buffer.
+ *      Remove the suffix of the given word and place the result in the
+ *      buffer.
+ *
+ * Results:
+ *      TRUE if characters were added to the buffer (a space needs to be
+ *      added to the buffer before the next word).
+ *
+ * Side Effects:
+ *      The trimmed word is added to the buffer.
  *
  *-----------------------------------------------------------------------
@@ -809 +810 @@
 static Boolean
 VarRoot (word, addSpace, buf, dummy)
-    char          *word;        /* Word to trim */
-    Boolean       addSpace;     /* TRUE if need to add a space to the buffer
-                                 * before placing the root in it */
-    Buffer        buf;          /* Buffer in which to store it */
-    ClientData    dummy;
+    char          *word;        /* Word to trim */
+    Boolean       addSpace;     /* TRUE if need to add a space to the buffer
+                                 * before placing the root in it */
+    Buffer        buf;          /* Buffer in which to store it */
+    ClientData    dummy;
 {
     register char *dot;
 
     if (addSpace) {
-        Buf_AddByte (buf, (Byte)' ');
+        Buf_AddByte (buf, (Byte)' ');
     }
 
     dot = strrchr (word, '.');
     if (dot != (char *)NULL) {
-        *dot = '\0';
-        Buf_AddBytes (buf, strlen (word), (Byte *)word);
-        *dot = '.';
+        *dot = '\0';
+        Buf_AddBytes (buf, strlen (word), (Byte *)word);
+        *dot = '.';
     } else {
-        Buf_AddBytes (buf, strlen(word), (Byte *)word);
+        Buf_AddBytes (buf, strlen(word), (Byte *)word);
     }
     return (dummy ? TRUE : TRUE);
 }
 
-#if defined(NMAKE) || defined(KMK)
+#ifdef USE_BASEANDROOT_MODIFIERS
 /*-
  *-----------------------------------------------------------------------
  * VarBase --
- *      Remove the head and suffix of the given word and place the result
- *      in the given buffer.
- *
- * Results:
- *      TRUE if characters were added to the buffer (a space needs to be
- *      added to the buffer before the next word).
- *
- * Side Effects:
- *      The trimmed word is added to the buffer.
+ *      Remove the head and suffix of the given word and place the result
+ *      in the given buffer.
+ *
+ * Results:
+ *      TRUE if characters were added to the buffer (a space needs to be
+ *      added to the buffer before the next word).
+ *
+ * Side Effects:
+ *      The trimmed word is added to the buffer.
  *
  *-----------------------------------------------------------------------
@@ -850 +851 @@
 static Boolean
 VarBase (word, addSpace, buf, dummy)
-    char          *word;        /* Word to trim */
-    Boolean       addSpace;     /* TRUE if need to stick a space in the
-                                 * buffer before adding the tail */
-    Buffer        buf;          /* Buffer in which to store it */
-    ClientData    dummy;
+    char          *word;        /* Word to trim */
+    Boolean       addSpace;     /* TRUE if need to stick a space in the
+                                 * buffer before adding the tail */
+    Buffer        buf;          /* Buffer in which to store it */
+    ClientData    dummy;
 {
     register char *slash;
 
     if (addSpace) {
-        Buf_AddByte (buf, (Byte)' ');
+        Buf_AddByte (buf, (Byte)' ');
     }
 
     slash = strrchr (word, '/');
     if (slash != (char *)NULL) {
-        register char *dot;
+        register char *dot;
         *slash++ = '\0';
         dot = strrchr (slash, '.');
@@ -875 +876 @@
         else
             Buf_AddBytes (buf, strlen(slash), (Byte *)slash);
-        slash[-1] = '/';
+        slash[-1] = '/';
     } else {
-        register char *dot;
+        register char *dot;
         dot = strrchr (slash, '.');
         if (dot)
@@ -896 +897 @@
  *-----------------------------------------------------------------------
  * VarMatch --
- *      Place the word in the buffer if it matches the given pattern.
- *      Callback function for VarModify to implement the :M modifier.
- *
- * Results:
- *      TRUE if a space should be placed in the buffer before the next
- *      word.
- *
- * Side Effects:
- *      The word may be copied to the buffer.
+ *      Place the word in the buffer if it matches the given pattern.
+ *      Callback function for VarModify to implement the :M modifier.
+ *
+ * Results:
+ *      TRUE if a space should be placed in the buffer before the next
+ *      word.
+ *
+ * Side Effects:
+ *      The word may be copied to the buffer.
  *
  *-----------------------------------------------------------------------
@@ -910 +911 @@
 static Boolean
 VarMatch (word, addSpace, buf, pattern)
-    char          *word;        /* Word to examine */
-    Boolean       addSpace;     /* TRUE if need to add a space to the
-                                 * buffer before adding the word, if it
-                                 * matches */
-    Buffer        buf;          /* Buffer in which to store it */
-    ClientData    pattern;      /* Pattern the word must match */
+    char          *word;        /* Word to examine */
+    Boolean       addSpace;     /* TRUE if need to add a space to the
+                                 * buffer before adding the word, if it
+                                 * matches */
+    Buffer        buf;          /* Buffer in which to store it */
+    ClientData    pattern;      /* Pattern the word must match */
 {
     if (Str_Match(word, (char *) pattern)) {
-        if (addSpace) {
-            Buf_AddByte(buf, (Byte)' ');
-        }
-        addSpace = TRUE;
-        Buf_AddBytes(buf, strlen(word), (Byte *)word);
+        if (addSpace) {
+            Buf_AddByte(buf, (Byte)' ');
+        }
+        addSpace = TRUE;
+        Buf_AddBytes(buf, strlen(word), (Byte *)word);
     }
     return(addSpace);
@@ -931 +932 @@
  *-----------------------------------------------------------------------
  * VarSYSVMatch --
- *      Place the word in the buffer if it matches the given pattern.
- *      Callback function for VarModify to implement the System V %
- *      modifiers.
- *
- * Results:
- *      TRUE if a space should be placed in the buffer before the next
- *      word.
- *
- * Side Effects:
- *      The word may be copied to the buffer.
+ *      Place the word in the buffer if it matches the given pattern.
+ *      Callback function for VarModify to implement the System V %
+ *      modifiers.
+ *
+ * Results:
+ *      TRUE if a space should be placed in the buffer before the next
+ *      word.
+ *
+ * Side Effects:
+ *      The word may be copied to the buffer.
  *
  *-----------------------------------------------------------------------
@@ -946 +947 @@
 static Boolean
 VarSYSVMatch (word, addSpace, buf, patp)
-    char          *word;        /* Word to examine */
-    Boolean       addSpace;     /* TRUE if need to add a space to the
-                                 * buffer before adding the word, if it
-                                 * matches */
-    Buffer        buf;          /* Buffer in which to store it */
-    ClientData    patp;         /* Pattern the word must match */
+    char          *word;        /* Word to examine */
+    Boolean       addSpace;     /* TRUE if need to add a space to the
+                                 * buffer before adding the word, if it
+                                 * matches */
+    Buffer        buf;          /* Buffer in which to store it */
+    ClientData    patp;         /* Pattern the word must match */
 {
     int len;
     char *ptr;
-    VarPattern    *pat = (VarPattern *) patp;
+    VarPattern    *pat = (VarPattern *) patp;
 
     if (addSpace)
-        Buf_AddByte(buf, (Byte)' ');
+        Buf_AddByte(buf, (Byte)' ');
 
     addSpace = TRUE;
 
     if ((ptr = Str_SYSVMatch(word, pat->lhs, &len)) != NULL)
-        Str_SYSVSubst(buf, pat->rhs, ptr, len);
+        Str_SYSVSubst(buf, pat->rhs, ptr, len);
     else
-        Buf_AddBytes(buf, strlen(word), (Byte *) word);
+        Buf_AddBytes(buf, strlen(word), (Byte *) word);
 
     return(addSpace);
@@ -975 +976 @@
  *-----------------------------------------------------------------------
  * VarNoMatch --
- *      Place the word in the buffer if it doesn't match the given pattern.
- *      Callback function for VarModify to implement the :N modifier.
- *
- * Results:
- *      TRUE if a space should be placed in the buffer before the next
- *      word.
- *
- * Side Effects:
- *      The word may be copied to the buffer.
+ *      Place the word in the buffer if it doesn't match the given pattern.
+ *      Callback function for VarModify to implement the :N modifier.
+ *
+ * Results:
+ *      TRUE if a space should be placed in the buffer before the next
+ *      word.
+ *
+ * Side Effects:
+ *      The word may be copied to the buffer.
  *
  *-----------------------------------------------------------------------
@@ -989 +990 @@
 static Boolean
 VarNoMatch (word, addSpace, buf, pattern)
-    char          *word;        /* Word to examine */
-    Boolean       addSpace;     /* TRUE if need to add a space to the
-                                 * buffer before adding the word, if it
-                                 * matches */
-    Buffer        buf;          /* Buffer in which to store it */
-    ClientData    pattern;      /* Pattern the word must match */
+    char          *word;        /* Word to examine */
+    Boolean       addSpace;     /* TRUE if need to add a space to the
+                                 * buffer before adding the word, if it
+                                 * matches */
+    Buffer        buf;          /* Buffer in which to store it */
+    ClientData    pattern;      /* Pattern the word must match */
 {
     if (!Str_Match(word, (char *) pattern)) {
-        if (addSpace) {
-            Buf_AddByte(buf, (Byte)' ');
-        }
-        addSpace = TRUE;
-        Buf_AddBytes(buf, strlen(word), (Byte *)word);
+        if (addSpace) {
+            Buf_AddByte(buf, (Byte)' ');
+        }
+        addSpace = TRUE;
+        Buf_AddBytes(buf, strlen(word), (Byte *)word);
     }
     return(addSpace);
@@ -1010 +1011 @@
  *-----------------------------------------------------------------------
  * VarSubstitute --
- *      Perform a string-substitution on the given word, placing the
- *      result in the passed buffer.
- *
- * Results:
- *      TRUE if a space is needed before more characters are added.
- *
- * Side Effects:
- *      None.
+ *      Perform a string-substitution on the given word, placing the
+ *      result in the passed buffer.
+ *
+ * Results:
+ *      TRUE if a space is needed before more characters are added.
+ *
+ * Side Effects:
+ *      None.
  *
  *-----------------------------------------------------------------------
@@ -1023 +1024 @@
 static Boolean
 VarSubstitute (word, addSpace, buf, patternp)
-    char                *word;      /* Word to modify */
-    Boolean             addSpace;   /* True if space should be added before
-                                     * other characters */
-    Buffer              buf;        /* Buffer for result */
-    ClientData          patternp;   /* Pattern for substitution */
-{
-    register int        wordLen;    /* Length of word */
-    register char       *cp;        /* General pointer */
-    VarPattern  *pattern = (VarPattern *) patternp;
+    char                *word;      /* Word to modify */
+    Boolean             addSpace;   /* True if space should be added before
+                                     * other characters */
+    Buffer              buf;        /* Buffer for result */
+    ClientData          patternp;   /* Pattern for substitution */
+{
+    register int        wordLen;    /* Length of word */
+    register char       *cp;        /* General pointer */
+    VarPattern  *pattern = (VarPattern *) patternp;
 
     wordLen = strlen(word);
     if (1) { /* substitute in each word of the variable */
-        /*
-         * Break substitution down into simple anchored cases
-         * and if none of them fits, perform the general substitution case.
-         */
-        if ((pattern->flags & VAR_MATCH_START) &&
-            (strncmp(word, pattern->lhs, pattern->leftLen) == 0)) {
-                /*
-                 * Anchored at start and beginning of word matches pattern
-                 */
-                if ((pattern->flags & VAR_MATCH_END) &&
-                    (wordLen == pattern->leftLen)) {
-                        /*
-                         * Also anchored at end and matches to the end (word
-                         * is same length as pattern) add space and rhs only
-                         * if rhs is non-null.
-                         */
-                        if (pattern->rightLen != 0) {
-                            if (addSpace) {
-                                Buf_AddByte(buf, (Byte)' ');
-                            }
-                            addSpace = TRUE;
-                            Buf_AddBytes(buf, pattern->rightLen,
-                                         (Byte *)pattern->rhs);
-                        }
-                } else if (pattern->flags & VAR_MATCH_END) {
-                    /*
-                     * Doesn't match to end -- copy word wholesale
-                     */
-                    goto nosub;
-                } else {
-                    /*
-                     * Matches at start but need to copy in trailing characters
-                     */
-                    if ((pattern->rightLen + wordLen - pattern->leftLen) != 0){
-                        if (addSpace) {
-                            Buf_AddByte(buf, (Byte)' ');
-                        }
-                        addSpace = TRUE;
-                    }
-                    Buf_AddBytes(buf, pattern->rightLen, (Byte *)pattern->rhs);
-                    Buf_AddBytes(buf, wordLen - pattern->leftLen,
-                                 (Byte *)(word + pattern->leftLen));
-                }
-        } else if (pattern->flags & VAR_MATCH_START) {
-            /*
-             * Had to match at start of word and didn't -- copy whole word.
-             */
-            goto nosub;
-        } else if (pattern->flags & VAR_MATCH_END) {
-            /*
-             * Anchored at end, Find only place match could occur (leftLen
-             * characters from the end of the word) and see if it does. Note
-             * that because the $ will be left at the end of the lhs, we have
-             * to use strncmp.
-             */
-            cp = word + (wordLen - pattern->leftLen);
-            if ((cp >= word) &&
-                (strncmp(cp, pattern->lhs, pattern->leftLen) == 0)) {
-                /*
-                 * Match found. If we will place characters in the buffer,
-                 * add a space before hand as indicated by addSpace, then
-                 * stuff in the initial, unmatched part of the word followed
-                 * by the right-hand-side.
-                 */
-                if (((cp - word) + pattern->rightLen) != 0) {
-                    if (addSpace) {
-                        Buf_AddByte(buf, (Byte)' ');
-                    }
-                    addSpace = TRUE;
-                }
-                Buf_AddBytes(buf, cp - word, (Byte *)word);
-                Buf_AddBytes(buf, pattern->rightLen, (Byte *)pattern->rhs);
-            } else {
-                /*
-                 * Had to match at end and didn't. Copy entire word.
-                 */
-                goto nosub;
-            }
-        } else {
-            /*
-             * Pattern is unanchored: search for the pattern in the word using
-             * String_FindSubstring, copying unmatched portions and the
-             * right-hand-side for each match found, handling non-global
-             * substitutions correctly, etc. When the loop is done, any
-             * remaining part of the word (word and wordLen are adjusted
-             * accordingly through the loop) is copied straight into the
-             * buffer.
-             * addSpace is set FALSE as soon as a space is added to the
-             * buffer.
-             */
-            register Boolean done;
-            int origSize;
-
-            done = FALSE;
-            origSize = Buf_Size(buf);
-            while (!done) {
-                cp = Str_FindSubstring(word, pattern->lhs);
-                if (cp != (char *)NULL) {
-                    if (addSpace && (((cp - word) + pattern->rightLen) != 0)){
-                        Buf_AddByte(buf, (Byte)' ');
-                        addSpace = FALSE;
-                    }
-                    Buf_AddBytes(buf, cp-word, (Byte *)word);
-                    Buf_AddBytes(buf, pattern->rightLen, (Byte *)pattern->rhs);
-                    wordLen -= (cp - word) + pattern->leftLen;
-                    word = cp + pattern->leftLen;
-                    if (wordLen == 0 || (pattern->flags & VAR_SUB_GLOBAL) == 0){
-                        done = TRUE;
-                    }
-                } else {
-                    done = TRUE;
-                }
-            }
-            if (wordLen != 0) {
-                if (addSpace) {
-                    Buf_AddByte(buf, (Byte)' ');
-                }
-                Buf_AddBytes(buf, wordLen, (Byte *)word);
-            }
-            /*
-             * If added characters to the buffer, need to add a space
-             * before we add any more. If we didn't add any, just return
-             * the previous value of addSpace.
-             */
-            return ((Buf_Size(buf) != origSize) || addSpace);
-        }
-        /*
-         * Common code for anchored substitutions:
-         * addSpace was set TRUE if characters were added to the buffer.
-         */
-        return (addSpace);
+        /*
+         * Break substitution down into simple anchored cases
+         * and if none of them fits, perform the general substitution case.
+         */
+        if ((pattern->flags & VAR_MATCH_START) &&
+            (strncmp(word, pattern->lhs, pattern->leftLen) == 0)) {
+                /*
+                 * Anchored at start and beginning of word matches pattern
+                 */
+                if ((pattern->flags & VAR_MATCH_END) &&
+                    (wordLen == pattern->leftLen)) {
+                        /*
+                         * Also anchored at end and matches to the end (word
+                         * is same length as pattern) add space and rhs only
+                         * if rhs is non-null.
+                         */
+                        if (pattern->rightLen != 0) {
+                            if (addSpace) {
+                                Buf_AddByte(buf, (Byte)' ');
+                            }
+                            addSpace = TRUE;
+                            Buf_AddBytes(buf, pattern->rightLen,
+                                         (Byte *)pattern->rhs);
+                        }
+                } else if (pattern->flags & VAR_MATCH_END) {
+                    /*
+                     * Doesn't match to end -- copy word wholesale
+                     */
+                    goto nosub;
+                } else {
+                    /*
+                     * Matches at start but need to copy in trailing characters
+                     */
+                    if ((pattern->rightLen + wordLen - pattern->leftLen) != 0){
+                        if (addSpace) {
+                            Buf_AddByte(buf, (Byte)' ');
+                        }
+                        addSpace = TRUE;
+                    }
+                    Buf_AddBytes(buf, pattern->rightLen, (Byte *)pattern->rhs);
+                    Buf_AddBytes(buf, wordLen - pattern->leftLen,
+                                 (Byte *)(word + pattern->leftLen));
+                }
+        } else if (pattern->flags & VAR_MATCH_START) {
+            /*
+             * Had to match at start of word and didn't -- copy whole word.
+             */
+            goto nosub;
+        } else if (pattern->flags & VAR_MATCH_END) {
+            /*
+             * Anchored at end, Find only place match could occur (leftLen
+             * characters from the end of the word) and see if it does. Note
+             * that because the $ will be left at the end of the lhs, we have
+             * to use strncmp.
+             */
+            cp = word + (wordLen - pattern->leftLen);
+            if ((cp >= word) &&
+                (strncmp(cp, pattern->lhs, pattern->leftLen) == 0)) {
+                /*
+                 * Match found. If we will place characters in the buffer,
+                 * add a space before hand as indicated by addSpace, then
+                 * stuff in the initial, unmatched part of the word followed
+                 * by the right-hand-side.
+                 */
+                if (((cp - word) + pattern->rightLen) != 0) {
+                    if (addSpace) {
+                        Buf_AddByte(buf, (Byte)' ');
+                    }
+                    addSpace = TRUE;
+                }
+                Buf_AddBytes(buf, cp - word, (Byte *)word);
+                Buf_AddBytes(buf, pattern->rightLen, (Byte *)pattern->rhs);
+            } else {
+                /*
+                 * Had to match at end and didn't. Copy entire word.
+                 */
+                goto nosub;
+            }
+        } else {
+            /*
+             * Pattern is unanchored: search for the pattern in the word using
+             * String_FindSubstring, copying unmatched portions and the
+             * right-hand-side for each match found, handling non-global
+             * substitutions correctly, etc. When the loop is done, any
+             * remaining part of the word (word and wordLen are adjusted
+             * accordingly through the loop) is copied straight into the
+             * buffer.
+             * addSpace is set FALSE as soon as a space is added to the
+             * buffer.
+             */
+            register Boolean done;
+            int origSize;
+
+            done = FALSE;
+            origSize = Buf_Size(buf);
+            while (!done) {
+                cp = Str_FindSubstring(word, pattern->lhs);
+                if (cp != (char *)NULL) {
+                    if (addSpace && (((cp - word) + pattern->rightLen) != 0)){
+                        Buf_AddByte(buf, (Byte)' ');
+                        addSpace = FALSE;
+                    }
+                    Buf_AddBytes(buf, cp-word, (Byte *)word);
+                    Buf_AddBytes(buf, pattern->rightLen, (Byte *)pattern->rhs);
+                    wordLen -= (cp - word) + pattern->leftLen;
+                    word = cp + pattern->leftLen;
+                    if (wordLen == 0 || (pattern->flags & VAR_SUB_GLOBAL) == 0){
+                        done = TRUE;
+                    }
+                } else {
+                    done = TRUE;
+                }
+            }
+            if (wordLen != 0) {
+                if (addSpace) {
+                    Buf_AddByte(buf, (Byte)' ');
+                }
+                Buf_AddBytes(buf, wordLen, (Byte *)word);
+            }
+            /*
+             * If added characters to the buffer, need to add a space
+             * before we add any more. If we didn't add any, just return
+             * the previous value of addSpace.
+             */
+            return ((Buf_Size(buf) != origSize) || addSpace);
+        }
+        /*
+         * Common code for anchored substitutions:
+         * addSpace was set TRUE if characters were added to the buffer.
+         */
+        return (addSpace);
     }
  nosub:
     if (addSpace) {
-        Buf_AddByte(buf, (Byte)' ');
+        Buf_AddByte(buf, (Byte)' ');
     }
     Buf_AddBytes(buf, wordLen, (Byte *)word);
@@ -1178 +1179 @@
  *-----------------------------------------------------------------------
  * VarREError --
- *      Print the error caused by a regcomp or regexec call.
- *
- * Results:
- *      None.
- *
- * Side Effects:
- *      An error gets printed.
+ *      Print the error caused by a regcomp or regexec call.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      An error gets printed.
  *
  *-----------------------------------------------------------------------
@@ -1208 +1209 @@
  *-----------------------------------------------------------------------
  * VarRESubstitute --
- *      Perform a regex substitution on the given word, placing the
- *      result in the passed buffer.
- *
- * Results:
- *      TRUE if a space is needed before more characters are added.
- *
- * Side Effects:
- *      None.
+ *      Perform a regex substitution on the given word, placing the
+ *      result in the passed buffer.
+ *
+ * Results:
+ *      TRUE if a space is needed before more characters are added.
+ *
+ * Side Effects:
+ *      None.
  *
  *-----------------------------------------------------------------------
@@ -1233 +1234 @@
     int flags = 0;
 
-#define MAYBE_ADD_SPACE()               \
-        if (addSpace && !added)         \
-            Buf_AddByte(buf, ' ');      \
-        added = 1
+#define MAYBE_ADD_SPACE()               \
+        if (addSpace && !added)         \
+            Buf_AddByte(buf, ' ');      \
+        added = 1
 
     added = 0;
@@ -1243 +1244 @@
 
     if ((pat->flags & (VAR_SUB_ONE|VAR_SUB_MATCHED)) ==
-        (VAR_SUB_ONE|VAR_SUB_MATCHED))
-        xrv = REG_NOMATCH;
+        (VAR_SUB_ONE|VAR_SUB_MATCHED))
+        xrv = REG_NOMATCH;
     else {
     tryagain:
-        xrv = regexec(&pat->re, wp, pat->nsub, pat->matches, flags);
+        xrv = regexec(&pat->re, wp, pat->nsub, pat->matches, flags);
     }
 
     switch (xrv) {
     case 0:
-        pat->flags |= VAR_SUB_MATCHED;
-        if (pat->matches[0].rm_so > 0) {
-            MAYBE_ADD_SPACE();
-            Buf_AddBytes(buf, pat->matches[0].rm_so, wp);
-        }
-
-        for (rp = pat->replace; *rp; rp++) {
-            if ((*rp == '\\') && ((rp[1] == '&') || (rp[1] == '\\'))) {
-                MAYBE_ADD_SPACE();
-                Buf_AddByte(buf,rp[1]);
-                rp++;
-            }
-            else if ((*rp == '&') ||
-                ((*rp == '\\') && isdigit((unsigned char)rp[1]))) {
-                int n;
-                char *subbuf;
-                int sublen;
-                char errstr[3];
-
-                if (*rp == '&') {
-                    n = 0;
-                    errstr[0] = '&';
-                    errstr[1] = '\0';
-                } else {
-                    n = rp[1] - '0';
-                    errstr[0] = '\\';
-                    errstr[1] = rp[1];
-                    errstr[2] = '\0';
-                    rp++;
-                }
-
-                if (n > pat->nsub) {
-                    Error("No subexpression %s", &errstr[0]);
-                    subbuf = "";
-                    sublen = 0;
-                } else if ((pat->matches[n].rm_so == -1) &&
-                           (pat->matches[n].rm_eo == -1)) {
-                    Error("No match for subexpression %s", &errstr[0]);
-                    subbuf = "";
-                    sublen = 0;
-                } else {
-                    subbuf = wp + pat->matches[n].rm_so;
-                    sublen = pat->matches[n].rm_eo - pat->matches[n].rm_so;
-                }
-
-                if (sublen > 0) {
-                    MAYBE_ADD_SPACE();
-                    Buf_AddBytes(buf, sublen, subbuf);
-                }
-            } else {
-                MAYBE_ADD_SPACE();
-                Buf_AddByte(buf, *rp);
-            }
-        }
-        wp += pat->matches[0].rm_eo;
-        if (pat->flags & VAR_SUB_GLOBAL) {
-            flags |= REG_NOTBOL;
-            if (pat->matches[0].rm_so == 0 && pat->matches[0].rm_eo == 0) {
-                MAYBE_ADD_SPACE();
-                Buf_AddByte(buf, *wp);
-                wp++;
-
-            }
-            if (*wp)
-                goto tryagain;
-        }
-        if (*wp) {
-            MAYBE_ADD_SPACE();
-            Buf_AddBytes(buf, strlen(wp), wp);
-        }
-        break;
+        pat->flags |= VAR_SUB_MATCHED;
+        if (pat->matches[0].rm_so > 0) {
+            MAYBE_ADD_SPACE();
+            Buf_AddBytes(buf, pat->matches[0].rm_so, wp);
+        }
+
+        for (rp = pat->replace; *rp; rp++) {
+            if ((*rp == '\\') && ((rp[1] == '&') || (rp[1] == '\\'))) {
+                MAYBE_ADD_SPACE();
+                Buf_AddByte(buf,rp[1]);
+                rp++;
+            }
+            else if ((*rp == '&') ||
+                ((*rp == '\\') && isdigit((unsigned char)rp[1]))) {
+                int n;
+                char *subbuf;
+                int sublen;
+                char errstr[3];
+
+                if (*rp == '&') {
+                    n = 0;
+                    errstr[0] = '&';
+                    errstr[1] = '\0';
+                } else {
+                    n = rp[1] - '0';
+                    errstr[0] = '\\';
+                    errstr[1] = rp[1];
+                    errstr[2] = '\0';
+                    rp++;
+                }
+
+                if (n > pat->nsub) {
+                    Error("No subexpression %s", &errstr[0]);
+                    subbuf = "";
+                    sublen = 0;
+                } else if ((pat->matches[n].rm_so == -1) &&
+                           (pat->matches[n].rm_eo == -1)) {
+                    Error("No match for subexpression %s", &errstr[0]);
+                    subbuf = "";
+                    sublen = 0;
+                } else {
+                    subbuf = wp + pat->matches[n].rm_so;
+                    sublen = pat->matches[n].rm_eo - pat->matches[n].rm_so;
+                }
+
+                if (sublen > 0) {
+                    MAYBE_ADD_SPACE();
+                    Buf_AddBytes(buf, sublen, subbuf);
+                }
+            } else {
+                MAYBE_ADD_SPACE();
+                Buf_AddByte(buf, *rp);
+            }
+        }
+        wp += pat->matches[0].rm_eo;
+        if (pat->flags & VAR_SUB_GLOBAL) {
+            flags |= REG_NOTBOL;
+            if (pat->matches[0].rm_so == 0 && pat->matches[0].rm_eo == 0) {
+                MAYBE_ADD_SPACE();
+                Buf_AddByte(buf, *wp);
+                wp++;
+
+            }
+            if (*wp)
+                goto tryagain;
+        }
+        if (*wp) {
+            MAYBE_ADD_SPACE();
+            Buf_AddBytes(buf, strlen(wp), wp);
+        }
+        break;
     default:
-        VarREError(xrv, &pat->re, "Unexpected regex error");
+        VarREError(xrv, &pat->re, "Unexpected regex error");
        /* fall through */
     case REG_NOMATCH:
-        if (*wp) {
-            MAYBE_ADD_SPACE();
-            Buf_AddBytes(buf,strlen(wp),wp);
-        }
-        break;
+        if (*wp) {
+            MAYBE_ADD_SPACE();
+            Buf_AddBytes(buf,strlen(wp),wp);
+        }
+        break;
     }
     return(addSpace||added);
@@ -1340 +1341 @@
  *-----------------------------------------------------------------------
  * VarModify --
- *      Modify each of the words of the passed string using the given
- *      function. Used to implement all modifiers.
- *
- * Results:
- *      A string of all the words modified appropriately.
- *
- * Side Effects:
- *      None.
+ *      Modify each of the words of the passed string using the given
+ *      function. Used to implement all modifiers.
+ *
+ * Results:
+ *      A string of all the words modified appropriately.
+ *
+ * Side Effects:
+ *      None.
  *
  *-----------------------------------------------------------------------
@@ -1353 +1354 @@
 static char *
 VarModify (str, modProc, datum)
-    char          *str;             /* String whose words should be trimmed */
-                                    /* Function to use to modify them */
-    Boolean       (*modProc) __P((char *, Boolean, Buffer, ClientData));
-    ClientData    datum;            /* Datum to pass it */
-{
-    Buffer        buf;              /* Buffer for the new string */
-    Boolean       addSpace;         /* TRUE if need to add a space to the
-                                     * buffer before adding the trimmed
-                                     * word */
-    char **av;                      /* word list [first word does not count] */
+    char          *str;             /* String whose words should be trimmed */
+                                    /* Function to use to modify them */
+    Boolean       (*modProc) __P((char *, Boolean, Buffer, ClientData));
+    ClientData    datum;            /* Datum to pass it */
+{
+    Buffer        buf;              /* Buffer for the new string */
+    Boolean       addSpace;         /* TRUE if need to add a space to the
+                                     * buffer before adding the trimmed
+                                     * word */
+    char **av;                      /* word list [first word does not count] */
     int ac, i;
 
@@ -1371 +1372 @@
 
     for (i = 1; i < ac; i++)
-        addSpace = (*modProc)(av[i], addSpace, buf, datum);
+        addSpace = (*modProc)(av[i], addSpace, buf, datum);
 
     Buf_AddByte (buf, '\0');
@@ -1382 +1383 @@
  *-----------------------------------------------------------------------
  * VarGetPattern --
- *      Pass through the tstr looking for 1) escaped delimiters,
- *      '$'s and backslashes (place the escaped character in
- *      uninterpreted) and 2) unescaped $'s that aren't before
- *      the delimiter (expand the variable substitution unless flags
- *      has VAR_NOSUBST set).
- *      Return the expanded string or NULL if the delimiter was missing
- *      If pattern is specified, handle escaped ampersands, and replace
- *      unescaped ampersands with the lhs of the pattern.
- *
- * Results:
- *      A string of all the words modified appropriately.
- *      If length is specified, return the string length of the buffer
- *      If flags is specified and the last character of the pattern is a
- *      $ set the VAR_MATCH_END bit of flags.
- *
- * Side Effects:
- *      None.
+ *      Pass through the tstr looking for 1) escaped delimiters,
+ *      '$'s and backslashes (place the escaped character in
+ *      uninterpreted) and 2) unescaped $'s that aren't before
+ *      the delimiter (expand the variable substitution unless flags
+ *      has VAR_NOSUBST set).
+ *      Return the expanded string or NULL if the delimiter was missing
+ *      If pattern is specified, handle escaped ampersands, and replace
+ *      unescaped ampersands with the lhs of the pattern.
+ *
+ * Results:
+ *      A string of all the words modified appropriately.
+ *      If length is specified, return the string length of the buffer
+ *      If flags is specified and the last character of the pattern is a
+ *      $ set the VAR_MATCH_END bit of flags.
+ *
+ * Side Effects:
+ *      None.
  *-----------------------------------------------------------------------
  */
@@ -1415 +1416 @@
     int junk;
     if (length == NULL)
-        length = &junk;
+        length = &junk;
 
 #define IS_A_MATCH(cp, delim) \
@@ -1428 +1429 @@
      */
     for (cp = *tstr; *cp && (*cp != delim); cp++) {
-        if (IS_A_MATCH(cp, delim)) {
-            Buf_AddByte(buf, (Byte) cp[1]);
-            cp++;
-        } else if (*cp == '$') {
-            if (cp[1] == delim) {
-                if (flags == NULL)
-                    Buf_AddByte(buf, (Byte) *cp);
-                else
-                    /*
-                     * Unescaped $ at end of pattern => anchor
-                     * pattern at end.
-                     */
-                    *flags |= VAR_MATCH_END;
-            } else {
-                if (flags == NULL || (*flags & VAR_NOSUBST) == 0) {
-                    char   *cp2;
-                    int     len;
-                    Boolean freeIt;
-
-                    /*
-                     * If unescaped dollar sign not before the
-                     * delimiter, assume it's a variable
-                     * substitution and recurse.
-                     */
-                    cp2 = Var_Parse(cp, ctxt, err, &len, &freeIt);
-                    Buf_AddBytes(buf, strlen(cp2), (Byte *) cp2);
-                    if (freeIt)
-                        efree(cp2);
-                    cp += len - 1;
-                } else {
-                    char *cp2 = &cp[1];
-
-                    if (*cp2 == '(' || *cp2 == '{') {
-                        /*
-                         * Find the end of this variable reference
-                         * and suck it in without further ado.
-                         * It will be interperated later.
-                         */
-                        int have = *cp2;
-                        int want = (*cp2 == '(') ? ')' : '}';
-                        int depth = 1;
-
-                        for (++cp2; *cp2 != '\0' && depth > 0; ++cp2) {
-                            if (cp2[-1] != '\\') {
-                                if (*cp2 == have)
-                                    ++depth;
-                                if (*cp2 == want)
-                                    --depth;
-                            }
-                        }
-                        Buf_AddBytes(buf, cp2 - cp, (Byte *)cp);
-                        cp = --cp2;
-                    } else
-                        Buf_AddByte(buf, (Byte) *cp);
-                }
-            }
-        }
-        else if (pattern && *cp == '&')
-            Buf_AddBytes(buf, pattern->leftLen, (Byte *)pattern->lhs);
-        else
-            Buf_AddByte(buf, (Byte) *cp);
+        if (IS_A_MATCH(cp, delim)) {
+            Buf_AddByte(buf, (Byte) cp[1]);
+            cp++;
+        } else if (*cp == '$') {
+            if (cp[1] == delim) {
+                if (flags == NULL)
+                    Buf_AddByte(buf, (Byte) *cp);
+                else
+                    /*
+                     * Unescaped $ at end of pattern => anchor
+                     * pattern at end.
+                     */
+                    *flags |= VAR_MATCH_END;
+            } else {
+                if (flags == NULL || (*flags & VAR_NOSUBST) == 0) {
+                    char   *cp2;
+                    int     len;
+                    Boolean freeIt;
+
+                    /*
+                     * If unescaped dollar sign not before the
+                     * delimiter, assume it's a variable
+                     * substitution and recurse.
+                     */
+                    cp2 = Var_Parse(cp, ctxt, err, &len, &freeIt);
+                    Buf_AddBytes(buf, strlen(cp2), (Byte *) cp2);
+                    if (freeIt)
+                        efree(cp2);
+                    cp += len - 1;
+                } else {
+                    char *cp2 = &cp[1];
+
+                    if (*cp2 == '(' || *cp2 == '{') {
+                        /*
+                         * Find the end of this variable reference
+                         * and suck it in without further ado.
+                         * It will be interperated later.
+                         */
+                        int have = *cp2;
+                        int want = (*cp2 == '(') ? ')' : '}';
+                        int depth = 1;
+
+                        for (++cp2; *cp2 != '\0' && depth > 0; ++cp2) {
+                            if (cp2[-1] != '\\') {
+                                if (*cp2 == have)
+                                    ++depth;
+                                if (*cp2 == want)
+                                    --depth;
+                            }
+                        }
+                        Buf_AddBytes(buf, cp2 - cp, (Byte *)cp);
+                        cp = --cp2;
+                    } else
+                        Buf_AddByte(buf, (Byte) *cp);
+                }
+            }
+        }
+        else if (pattern && *cp == '&')
+            Buf_AddBytes(buf, pattern->leftLen, (Byte *)pattern->lhs);
+        else
+            Buf_AddByte(buf, (Byte) *cp);
     }
 
@@ -1494 +1495 @@
 
     if (*cp != delim) {
-        *tstr = cp;
-        *length = 0;
-        return NULL;
+        *tstr = cp;
+        *length = 0;
+        return NULL;
     }
     else {
-        *tstr = ++cp;
-        cp = (char *) Buf_GetAll(buf, length);
-        *length -= 1;   /* Don't count the NULL */
-        Buf_Destroy(buf, FALSE);
-        return cp;
+        *tstr = ++cp;
+        cp = (char *) Buf_GetAll(buf, length);
+        *length -= 1;   /* Don't count the NULL */
+        Buf_Destroy(buf, FALSE);
+        return cp;
     }
 }
@@ -1511 +1512 @@
  *-----------------------------------------------------------------------
  * VarQuote --
- *      Quote shell meta-characters in the string
- *
- * Results:
- *      The quoted string
- *
- * Side Effects:
- *      None.
+ *      Quote shell meta-characters in the string
+ *
+ * Results:
+ *      The quoted string
+ *
+ * Side Effects:
+ *      None.
  *
  *-----------------------------------------------------------------------
@@ -1523 +1524 @@
 static char *
 VarQuote(str)
-        char *str;
-{
-
-    Buffer        buf;
+        char *str;
+{
+
+    Buffer        buf;
     /* This should cover most shells :-( */
     static char meta[] = "\n \t'`\";&<>()|*?{}[]\\$!#^~";
@@ -1532 +1533 @@
     buf = Buf_Init (MAKE_BSIZE);
     for (; *str; str++) {
-        if (strchr(meta, *str) != NULL)
-            Buf_AddByte(buf, (Byte)'\\');
-        Buf_AddByte(buf, (Byte)*str);
+        if (strchr(meta, *str) != NULL)
+            Buf_AddByte(buf, (Byte)'\\');
+        Buf_AddByte(buf, (Byte)*str);
     }
     Buf_AddByte(buf, (Byte) '\0');
@@ -1545 +1546 @@
  *-----------------------------------------------------------------------
  * Var_Parse --
- *      Given the start of a variable invocation, extract the variable
- *      name and find its value, then modify it according to the
- *      specification.
- *
- * Results:
- *      The (possibly-modified) value of the variable or var_Error if the
- *      specification is invalid. The length of the specification is
- *      placed in *lengthPtr (for invalid specifications, this is just
- *      2...?).
- *      A Boolean in *freePtr telling whether the returned string should
- *      be freed by the caller.
- *
- * Side Effects:
- *      None.
+ *      Given the start of a variable invocation, extract the variable
+ *      name and find its value, then modify it according to the
+ *      specification.
+ *
+ * Results:
+ *      The (possibly-modified) value of the variable or var_Error if the
+ *      specification is invalid. The length of the specification is
+ *      placed in *lengthPtr (for invalid specifications, this is just
+ *      2...?).
+ *      A Boolean in *freePtr telling whether the returned string should
+ *      be freed by the caller.
+ *
+ * Side Effects:
+ *      None.
  *
  *-----------------------------------------------------------------------
@@ -1564 +1565 @@
 char *
 Var_Parse (str, ctxt, err, lengthPtr, freePtr)
-    char          *str;         /* The string to parse */
-    GNode         *ctxt;        /* The context for the variable */
-    Boolean         err;        /* TRUE if undefined variables are an error */
-    int             *lengthPtr; /* OUT: The length of the specification */
-    Boolean         *freePtr;   /* OUT: TRUE if caller should efree result */
-{
-    register char   *tstr;      /* Pointer into str */
-    Var             *v;         /* Variable in invocation */
-    char            *cp;        /* Secondary pointer into str (place marker
-                                 * for tstr) */
-    Boolean         haveModifier;/* TRUE if have modifiers for the variable */
-    register char   endc;       /* Ending character when variable in parens
-                                 * or braces */
-    register char   startc=0;   /* Starting character when variable in parens
-                                 * or braces */
-    int             cnt;        /* Used to count brace pairs when variable in
-                                 * in parens or braces */
-    char            *start;
-    char             delim;
-    Boolean         dynamic;    /* TRUE if the variable is local and we're
-                                 * expanding it in a non-local context. This
-                                 * is done to support dynamic sources. The
-                                 * result is just the invocation, unaltered */
-    int         vlen;           /* length of variable name, after embedded variable
-                                 * expansion */
+    char          *str;         /* The string to parse */
+    GNode         *ctxt;        /* The context for the variable */
+    Boolean         err;        /* TRUE if undefined variables are an error */
+    int             *lengthPtr; /* OUT: The length of the specification */
+    Boolean         *freePtr;   /* OUT: TRUE if caller should efree result */
+{
+    register char   *tstr;      /* Pointer into str */
+    Var             *v;         /* Variable in invocation */
+    char            *cp;        /* Secondary pointer into str (place marker
+                                 * for tstr) */
+    Boolean         haveModifier;/* TRUE if have modifiers for the variable */
+    register char   endc;       /* Ending character when variable in parens
+                                 * or braces */
+    register char   startc=0;   /* Starting character when variable in parens
+                                 * or braces */
+    int             cnt;        /* Used to count brace pairs when variable in
+                                 * in parens or braces */
+    char            *start;
+    char             delim;
+    Boolean         dynamic;    /* TRUE if the variable is local and we're
+                                 * expanding it in a non-local context. This
+                                 * is done to support dynamic sources. The
+                                 * result is just the invocation, unaltered */
+    int         vlen;           /* length of variable name, after embedded variable
+                                 * expansion */
 
     *freePtr = FALSE;
     dynamic = FALSE;
     start = str;
-//debugkso: fprintf(stderr, "var: str=%s\n", str);
 
     if (str[1] != '(' && str[1] != '{') {
-        /*
-         * If it's not bounded by braces of some sort, life is much simpler.
-         * We just need to check for the first character and return the
-         * value if it exists.
-         */
-        char      name[2];
-
-        name[0] = str[1];
-        name[1] = '\0';
-
-        v = VarFind (name, ctxt, FIND_ENV | FIND_GLOBAL | FIND_CMD);
-        if (v == (Var *)NIL) {
-            *lengthPtr = 2;
-
-            if ((ctxt == VAR_CMD) || (ctxt == VAR_GLOBAL)) {
-                /*
-                 * If substituting a local variable in a non-local context,
-                 * assume it's for dynamic source stuff. We have to handle
-                 * this specially and return the longhand for the variable
-                 * with the dollar sign escaped so it makes it back to the
-                 * caller. Only four of the local variables are treated
-                 * specially as they are the only four that will be set
-                 * when dynamic sources are expanded.
-                 */
-                /* XXX: It looks like $% and $! are reversed here */
-                switch (str[1]) {
-                    case '@':
-                        return("$(.TARGET)");
-                    case '%':
-                        return("$(.ARCHIVE)");
-                    case '*':
-                        return("$(.PREFIX)");
-                    case '!':
-                        return("$(.MEMBER)");
+        /*
+         * If it's not bounded by braces of some sort, life is much simpler.
+         * We just need to check for the first character and return the
+         * value if it exists.
+         */
+        char      name[2];
+
+        name[0] = str[1];
+        name[1] = '\0';
+
+        v = VarFind (name, ctxt, FIND_ENV | FIND_GLOBAL | FIND_CMD);
+        if (v == (Var *)NIL) {
+            *lengthPtr = 2;
+
+            if ((ctxt == VAR_CMD) || (ctxt == VAR_GLOBAL)) {
+                /*
+                 * If substituting a local variable in a non-local context,
+                 * assume it's for dynamic source stuff. We have to handle
+                 * this specially and return the longhand for the variable
+                 * with the dollar sign escaped so it makes it back to the
+                 * caller. Only four of the local variables are treated
+                 * specially as they are the only four that will be set
+                 * when dynamic sources are expanded.
+                 */
+                /* XXX: It looks like $% and $! are reversed here */
+                switch (str[1]) {
+                    case '@':
+                        return("$(.TARGET)");
+                    case '%':
+                        return("$(.ARCHIVE)");
+                    case '*':
+                        return("$(.PREFIX)");
+                    case '!':
+                        return("$(.MEMBER)");
                     #ifdef USE_PARENTS
-                    case '^':
-                        return("$(.PARENTS)");
+                    case '^':
+                        return("$(.PARENTS)");
                     #endif
-                }
-            }
-            /*
-             * Error
-             */
-            return (err ? var_Error : varNoError);
-        } else {
-            haveModifier = FALSE;
-            tstr = &str[1];
-            endc = str[1];
-        }
+                }
+            }
+            /*
+             * Error
+             */
+            return (err ? var_Error : varNoError);
+        } else {
+            haveModifier = FALSE;
+            tstr = &str[1];
+            endc = str[1];
+        }
     } else {
-        /* build up expanded variable name in this buffer */
-        Buffer  buf = Buf_Init(MAKE_BSIZE);
-
-        startc = str[1];
-        endc = startc == '(' ? ')' : '}';
-
-        /*
-         * Skip to the end character or a colon, whichever comes first,
-         * replacing embedded variables as we go.
-         */
-        for (tstr = str + 2; *tstr != '\0' && *tstr != endc && *tstr != ':'; tstr++)
-                if (*tstr == '$') {
-                        int     rlen;
-                        Boolean rfree;
-                        char*   rval = Var_Parse(tstr, ctxt, err, &rlen, &rfree);
-
-                        if (rval == var_Error) {
-                                Fatal("Error expanding embedded variable.");
-                        } else if (rval != NULL) {
-                                Buf_AddBytes(buf, strlen(rval), (Byte *) rval);
-                                if (rfree)
-                                        efree(rval);
-                        }
-                        tstr += rlen - 1;
-                } else
-                        Buf_AddByte(buf, (Byte) *tstr);
-        
-        if (*tstr == '\0') {
-            /*
-             * If we never did find the end character, return NULL
-             * right now, setting the length to be the distance to
-             * the end of the string, since that's what make does.
-             */
-            *lengthPtr = tstr - str;
-            return (var_Error);
-        }
-        
-        haveModifier = (*tstr == ':');
-        *tstr = '\0';
-
-        Buf_AddByte(buf, (Byte) '\0');
-        str = Buf_GetAll(buf, NULL);
-        vlen = strlen(str);
-
-        v = VarFind (str, ctxt, FIND_ENV | FIND_GLOBAL | FIND_CMD);
-        if ((v == (Var *)NIL) && (ctxt != VAR_CMD) && (ctxt != VAR_GLOBAL) &&
-#if defined(NMAKE) || defined(KMK)
-            (vlen == 2) && (str[1] == 'F' || str[1] == 'D' || str[1] == 'B' || str[1] == 'R'))
+        /* build up expanded variable name in this buffer */
+        Buffer  buf = Buf_Init(MAKE_BSIZE);
+
+        startc = str[1];
+        endc = startc == '(' ? ')' : '}';
+
+        /*
+         * Skip to the end character or a colon, whichever comes first,
+         * replacing embedded variables as we go.
+         */
+        for (tstr = str + 2; *tstr != '\0' && *tstr != endc && *tstr != ':'; tstr++)
+                if (*tstr == '$') {
+                        int     rlen;
+                        Boolean rfree;
+                        char*   rval = Var_Parse(tstr, ctxt, err, &rlen, &rfree);
+
+                        if (rval == var_Error) {
+                                Fatal("Error expanding embedded variable.");
+                        } else if (rval != NULL) {
+                                Buf_AddBytes(buf, strlen(rval), (Byte *) rval);
+                                if (rfree)
+                                        efree(rval);
+                        }
+                        tstr += rlen - 1;
+                } else
+                        Buf_AddByte(buf, (Byte) *tstr);
+
+        if (*tstr == '\0') {
+            /*
+             * If we never did find the end character, return NULL
+             * right now, setting the length to be the distance to
+             * the end of the string, since that's what make does.
+             */
+            *lengthPtr = tstr - str;
+            return (var_Error);
+        }
+
+        haveModifier = (*tstr == ':');
+        *tstr = '\0';
+
+        Buf_AddByte(buf, (Byte) '\0');
+        str = Buf_GetAll(buf, NULL);
+        vlen = strlen(str);
+
+        v = VarFind (str, ctxt, FIND_ENV | FIND_GLOBAL | FIND_CMD);
+        if ((v == (Var *)NIL) && (ctxt != VAR_CMD) && (ctxt != VAR_GLOBAL) &&
+#ifdef USE_BASEANDROOT_MODIFIERS
+            (vlen == 2) && (str[1] == 'F' || str[1] == 'D' || str[1] == 'B' || str[1] == 'R'))
 #else
-            (vlen == 2) && (str[1] == 'F' || str[1] == 'D'))
+            (vlen == 2) && (str[1] == 'F' || str[1] == 'D'))
 #endif
-        {
-            /*
-             * Check for bogus D and F forms of local variables since we're
-             * in a local context and the name is the right length.
-             */
-            switch(str[0]) {
-                case '@':
-                case '%':
-                case '*':
-                case '!':
-                case '>':
-                case '<':
-                {
-                    char    vname[2];
-                    char    *val;
-
-                    /*
-                     * Well, it's local -- go look for it.
-                     */
-                    vname[0] = str[0];
-                    vname[1] = '\0';
-                    v = VarFind(vname, ctxt, 0);
-
-                    if (v != (Var *)NIL && !haveModifier) {
-                        /*
-                         * No need for nested expansion or anything, as we're
-                         * the only one who sets these things and we sure don't
-                         * put nested invocations in them...
-                         */
-                        val = (char *)Buf_GetAll(v->val, (int *)NULL);
-
-#if defined(NMAKE) || defined(KMK)
-                        switch (str[1])
+        {
+            /*
+             * Check for bogus D and F forms of local variables since we're
+             * in a local context and the name is the right length.
+             */
+            switch(str[0]) {
+                case '@':
+                case '%':
+                case '*':
+                case '!':
+                case '>':
+                case '<':
+                {
+                    char    vname[2];
+                    char    *val;
+
+                    /*
+                     * Well, it's local -- go look for it.
+                     */
+                    vname[0] = str[0];
+                    vname[1] = '\0';
+                    v = VarFind(vname, ctxt, 0);
+
+                    if (v != (Var *)NIL && !haveModifier) {
+                        /*
+                         * No need for nested expansion or anything, as we're
+                         * the only one who sets these things and we sure don't
+                         * put nested invocations in them...
+                         */
+                        val = (char *)Buf_GetAll(v->val, (int *)NULL);
+
+#ifdef USE_BASEANDROOT_MODIFIERS
+                        switch (str[1])
                         {
                         case 'D': val = VarModify(val, VarHead, (ClientData)0); break;
@@ -1735 +1735 @@
                         case 'R': val = VarModify(val, VarRoot, (ClientData)0); break;
                         default:  val = VarModify(val, VarTail, (ClientData)0); break;
-                        }
+                        }
 #else
-                        if (str[1] == 'D') {
-                            val = VarModify(val, VarHead, (ClientData)0);
-                        } else {
-                            val = VarModify(val, VarTail, (ClientData)0);
-                        }
+                        if (str[1] == 'D') {
+                            val = VarModify(val, VarHead, (ClientData)0);
+                        } else {
+                            val = VarModify(val, VarTail, (ClientData)0);
+                        }
 #endif
-                        /*
-                         * Resulting string is dynamically allocated, so
-                         * tell caller to efree it.
-                         */
-                        *freePtr = TRUE;
-                        *lengthPtr = tstr-start+1;
-                        *tstr = endc;
-                        Buf_Destroy(buf, TRUE);
-                        return(val);
-                    }
-                    break;
-                }
-            }
-        }
-
-        if (v == (Var *)NIL) {
-//debugkso: fprintf(stderr, "\tv == (Var *)NIL vlen=%d str=%s\n", vlen, str);
-
-            if (((vlen == 1) ||
-                 (((vlen == 2) && (str[1] == 'F' ||
-#if defined(NMAKE) || defined(KMK)
+                        /*
+                         * Resulting string is dynamically allocated, so
+                         * tell caller to efree it.
+                         */
+                        *freePtr = TRUE;
+                        *lengthPtr = tstr-start+1;
+                        *tstr = endc;
+                        Buf_Destroy(buf, TRUE);
+                        return(val);
+                    }
+                    break;
+                }
+            }
+        }
+
+        if (v == (Var *)NIL) {
+
+            if (((vlen == 1) ||
+                 (((vlen == 2) && (str[1] == 'F' ||
+#ifdef USE_BASEANDROOT_MODIFIERS
                                          str[1] == 'D' || str[1] == 'B' || str[1] == 'R')))) &&
 #else
-                                         str[1] == 'D')))) &&
+                                         str[1] == 'D')))) &&
 #endif
-                ((ctxt == VAR_CMD) || (ctxt == VAR_GLOBAL)))
-            {
-                /*
-                 * If substituting a local variable in a non-local context,
-                 * assume it's for dynamic source stuff. We have to handle
-                 * this specially and return the longhand for the variable
-                 * with the dollar sign escaped so it makes it back to the
-                 * caller. Only four of the local variables are treated
-                 * specially as they are the only four that will be set
-                 * when dynamic sources are expanded.
-                 */
-                switch (str[0]) {
-                    case '@':
-                    case '%':
-                    case '*':
-                    case '!':
+                ((ctxt == VAR_CMD) || (ctxt == VAR_GLOBAL)))
+            {
+                /*
+                 * If substituting a local variable in a non-local context,
+                 * assume it's for dynamic source stuff. We have to handle
+                 * this specially and return the longhand for the variable
+                 * with the dollar sign escaped so it makes it back to the
+                 * caller. Only four of the local variables are treated
+                 * specially as they are the only four that will be set
+                 * when dynamic sources are expanded.
+                 */
+                switch (str[0]) {
+                    case '@':
+                    case '%':
+                    case '*':
+                    case '!':
                     #ifdef USE_PARENTS
-                    case '^':
+                    case '^':
                     #endif
-                        dynamic = TRUE;
-                        break;
-                }
-            } else if ((vlen > 2) && (str[0] == '.') &&
-                       isupper((unsigned char) str[1]) &&
-                       ((ctxt == VAR_CMD) || (ctxt == VAR_GLOBAL)))
-            {
-                int     len;
-
-                len = vlen - 1;
-                if ((strncmp(str, ".TARGET", len) == 0) ||
-                    (strncmp(str, ".ARCHIVE", len) == 0) ||
-                    (strncmp(str, ".PREFIX", len) == 0) ||
+                        dynamic = TRUE;
+                        break;
+                }
+            } else if ((vlen > 2) && (str[0] == '.') &&
+                       isupper((unsigned char) str[1]) &&
+                       ((ctxt == VAR_CMD) || (ctxt == VAR_GLOBAL)))
+            {
+                int     len;
+
+                len = vlen - 1;
+                if ((strncmp(str, ".TARGET", len) == 0) ||
+                    (strncmp(str, ".ARCHIVE", len) == 0) ||
+                    (strncmp(str, ".PREFIX", len) == 0) ||
                     #ifdef USE_PARENTS
-                    (strncmp(str, ".PARENTS", len) == 0) ||
+                    (strncmp(str, ".PARENTS", len) == 0) ||
                     #endif
-                    (strncmp(str, ".MEMBER", len) == 0))
-                {
-                    dynamic = TRUE;
-                }
-            }
-
-            if (!haveModifier) {
-                /*
-                 * No modifiers -- have specification length so we can return
-                 * now.
-                 */
-                *lengthPtr = tstr - start + 1;
-                *tstr = endc;
-                if (dynamic) {
-                    str = emalloc(*lengthPtr + 1);
-                    strncpy(str, start, *lengthPtr);
-                    str[*lengthPtr] = '\0';
-                    *freePtr = TRUE;
-                    Buf_Destroy(buf, TRUE);
-                    return(str);
-                } else {
-                    Buf_Destroy(buf, TRUE);
-                    return (err ? var_Error : varNoError);
-                }
-            } else {
-                /*
-                 * Still need to get to the end of the variable specification,
-                 * so kludge up a Var structure for the modifications
-                 */
-                v = (Var *) emalloc(sizeof(Var));
-                v->name = &str[1];
-                v->val = Buf_Init(1);
-                v->flags = VAR_JUNK;
-            }
-        }
-        Buf_Destroy(buf, TRUE);
+                    (strncmp(str, ".MEMBER", len) == 0))
+                {
+                    dynamic = TRUE;
+                }
+            }
+
+            if (!haveModifier) {
+                /*
+                 * No modifiers -- have specification length so we can return
+                 * now.
+                 */
+                *lengthPtr = tstr - start + 1;
+                *tstr = endc;
+                if (dynamic) {
+                    str = emalloc(*lengthPtr + 1);
+                    strncpy(str, start, *lengthPtr);
+                    str[*lengthPtr] = '\0';
+                    *freePtr = TRUE;
+                    Buf_Destroy(buf, TRUE);
+                    return(str);
+                } else {
+                    Buf_Destroy(buf, TRUE);
+                    return (err ? var_Error : varNoError);
+                }
+            } else {
+                /*
+                 * Still need to get to the end of the variable specification,
+                 * so kludge up a Var structure for the modifications
+                 */
+                v = (Var *) emalloc(sizeof(Var));
+                v->name = &str[1];
+                v->val = Buf_Init(1);
+                v->flags = VAR_JUNK;
+            }
+        }
+        Buf_Destroy(buf, TRUE);
     }
 
     if (v->flags & VAR_IN_USE) {
-        Fatal("Variable %s is recursive.", v->name);
-        /*NOTREACHED*/
+        Fatal("Variable %s is recursive.", v->name);
+        /*NOTREACHED*/
     } else {
-        v->flags |= VAR_IN_USE;
+        v->flags |= VAR_IN_USE;
     }
     /*
@@ -1858 +1857 @@
     str = (char *)Buf_GetAll(v->val, (int *)NULL);
     if (strchr (str, '$') != (char *)NULL) {
-        str = Var_Subst(NULL, str, ctxt, err);
-        *freePtr = TRUE;
+        str = Var_Subst(NULL, str, ctxt, err);
+        *freePtr = TRUE;
     }
 
@@ -1867 +1866 @@
      * Now we need to apply any modifiers the user wants applied.
      * These are:
-     *            :M<pattern>   words which match the given <pattern>.
-     *                          <pattern> is of the standard file
-     *                          wildcarding form.
-     *            :S<d><pat1><d><pat2><d>[g]
-     *                          Substitute <pat2> for <pat1> in the value
-     *            :C<d><pat1><d><pat2><d>[g]
-     *                          Substitute <pat2> for regex <pat1> in the value
-     *            :H            Substitute the head of each word
-     *            :T            Substitute the tail of each word
-     *            :E            Substitute the extension (minus '.') of
-     *                          each word
-     *            :R            Substitute the root of each word
-     *                          (pathname minus the suffix).
-     *            :lhs=rhs      Like :S, but the rhs goes to the end of
-     *                          the invocation.
-     *            :U            Converts variable to upper-case.
-     *            :L            Converts variable to lower-case.
+     *            :M<pattern>   words which match the given <pattern>.
+     *                          <pattern> is of the standard file
+     *                          wildcarding form.
+     *            :S<d><pat1><d><pat2><d>[g]
+     *                          Substitute <pat2> for <pat1> in the value
+     *            :C<d><pat1><d><pat2><d>[g]
+     *                          Substitute <pat2> for regex <pat1> in the value
+     *            :H            Substitute the head of each word
+     *            :T            Substitute the tail of each word
+     *            :E            Substitute the extension (minus '.') of
+     *                          each word
+     *            :R            Substitute the root of each word
+     *                          (pathname minus the suffix).
+     *            :lhs=rhs      Like :S, but the rhs goes to the end of
+     *                          the invocation.
+     *            :U            Converts variable to upper-case.
+     *            :L            Converts variable to lower-case.
      */
     if ((str != (char *)NULL) && haveModifier) {
-        /*
-         * Skip initial colon while putting it back.
-         */
-        *tstr++ = ':';
-        while (*tstr != endc) {
-            char        *newStr;    /* New value to return */
-            char        termc;      /* Character which terminated scan */
-
-            if (DEBUG(VAR)) {
-                printf("Applying :%c to \"%s\"\n", *tstr, str);
-            }
-            switch (*tstr) {
-                case 'U':
-                        if (tstr[1] == endc || tstr[1] == ':') {
-                                Buffer buf;
-                                buf = Buf_Init(MAKE_BSIZE);
-                                for (cp = str; *cp ; cp++)
-                                        Buf_AddByte(buf, (Byte) toupper(*cp));
-
-                                Buf_AddByte(buf, (Byte) '\0');
-                                newStr = (char *) Buf_GetAll(buf, (int *) NULL);
-                                Buf_Destroy(buf, FALSE);
-
-                                cp = tstr + 1;
-                                termc = *cp;
-                                break;
-                        }
-                        /* FALLTHROUGH */
-                case 'L':
-                        if (tstr[1] == endc || tstr[1] == ':') {
-                                Buffer buf;
-                                buf = Buf_Init(MAKE_BSIZE);
-                                for (cp = str; *cp ; cp++)
-                                        Buf_AddByte(buf, (Byte) tolower(*cp));
-
-                                Buf_AddByte(buf, (Byte) '\0');
-                                newStr = (char *) Buf_GetAll(buf, (int *) NULL);
-                                Buf_Destroy(buf, FALSE);
-
-                                cp = tstr + 1;
-                                termc = *cp;
-                                break;
-                        }
-                        /* FALLTHROUGH */
-                case 'N':
-                case 'M':
-                {
-                    char    *pattern;
-                    char    *cp2;
-                    Boolean copy;
-
-                    copy = FALSE;
-                    for (cp = tstr + 1;
-                         *cp != '\0' && *cp != ':' && *cp != endc;
-                         cp++)
-                    {
-                        if (*cp == '\\' && (cp[1] == ':' || cp[1] == endc)){
-                            copy = TRUE;
-                            cp++;
-                        }
-                    }
-                    termc = *cp;
-                    *cp = '\0';
-                    if (copy) {
-                        /*
-                         * Need to compress the \:'s out of the pattern, so
-                         * allocate enough room to hold the uncompressed
-                         * pattern (note that cp started at tstr+1, so
-                         * cp - tstr takes the null byte into account) and
-                         * compress the pattern into the space.
-                         */
-                        pattern = emalloc(cp - tstr);
-                        for (cp2 = pattern, cp = tstr + 1;
-                             *cp != '\0';
-                             cp++, cp2++)
-                        {
-                            if ((*cp == '\\') &&
-                                (cp[1] == ':' || cp[1] == endc)) {
-                                    cp++;
-                            }
-                            *cp2 = *cp;
-                        }
-                        *cp2 = '\0';
-                    } else {
-                        pattern = &tstr[1];
-                    }
-                    if (*tstr == 'M' || *tstr == 'm') {
-                        newStr = VarModify(str, VarMatch, (ClientData)pattern);
-                    } else {
-                        newStr = VarModify(str, VarNoMatch,
-                                           (ClientData)pattern);
-                    }
-                    if (copy) {
-                        efree(pattern);
-                    }
-                    break;
-                }
-                case 'S':
-                {
-                    VarPattern      pattern;
-                    register char   delim;
-                    Buffer          buf;        /* Buffer for patterns */
-
-                    pattern.flags = 0;
-                    delim = tstr[1];
-                    tstr += 2;
-
-                    /*
-                     * If pattern begins with '^', it is anchored to the
-                     * start of the word -- skip over it and flag pattern.
-                     */
-                    if (*tstr == '^') {
-                        pattern.flags |= VAR_MATCH_START;
-                        tstr += 1;
-                    }
-
-                    buf = Buf_Init(0);
-
-                    /*
-                     * Pass through the lhs looking for 1) escaped delimiters,
-                     * '$'s and backslashes (place the escaped character in
-                     * uninterpreted) and 2) unescaped $'s that aren't before
-                     * the delimiter (expand the variable substitution).
-                     * The result is left in the Buffer buf.
-                     */
-                    for (cp = tstr; *cp != '\0' && *cp != delim; cp++) {
-                        if ((*cp == '\\') &&
-                            ((cp[1] == delim) ||
-                             (cp[1] == '$') ||
-                             (cp[1] == '\\')))
-                        {
-                            Buf_AddByte(buf, (Byte)cp[1]);
-                            cp++;
-                        } else if (*cp == '$') {
-                            if (cp[1] != delim) {
-                                /*
-                                 * If unescaped dollar sign not before the
-                                 * delimiter, assume it's a variable
-                                 * substitution and recurse.
-                                 */
-                                char        *cp2;
-                                int         len;
-                                Boolean     freeIt;
-
-                                cp2 = Var_Parse(cp, ctxt, err, &len, &freeIt);
-                                Buf_AddBytes(buf, strlen(cp2), (Byte *)cp2);
-                                if (freeIt) {
-                                    efree(cp2);
-                                }
-                                cp += len - 1;
-                            } else {
-                                /*
-                                 * Unescaped $ at end of pattern => anchor
-                                 * pattern at end.
-                                 */
-                                pattern.flags |= VAR_MATCH_END;
-                            }
-                        } else {
-                            Buf_AddByte(buf, (Byte)*cp);
-                        }
-                    }
-
-                    Buf_AddByte(buf, (Byte)'\0');
-
-                    /*
-                     * If lhs didn't end with the delimiter, complain and
-                     * return NULL
-                     */
-                    if (*cp != delim) {
-                        *lengthPtr = cp - start + 1;
-                        if (*freePtr) {
-                            efree(str);
-                        }
-                        Buf_Destroy(buf, TRUE);
-                        Error("Unclosed substitution for %s (%c missing)",
-                              v->name, delim);
-                        return (var_Error);
-                    }
-
-                    /*
-                     * Fetch pattern and destroy buffer, but preserve the data
-                     * in it, since that's our lhs. Note that Buf_GetAll
-                     * will return the actual number of bytes, which includes
-                     * the null byte, so we have to decrement the length by
-                     * one.
-                     */
-                    pattern.lhs = (char *)Buf_GetAll(buf, &pattern.leftLen);
-                    pattern.leftLen--;
-                    Buf_Destroy(buf, FALSE);
-
-                    /*
-                     * Now comes the replacement string. Three things need to
-                     * be done here: 1) need to compress escaped delimiters and
-                     * ampersands and 2) need to replace unescaped ampersands
-                     * with the l.h.s. (since this isn't regexp, we can do
-                     * it right here) and 3) expand any variable substitutions.
-                     */
-                    buf = Buf_Init(0);
-
-                    tstr = cp + 1;
-                    for (cp = tstr; *cp != '\0' && *cp != delim; cp++) {
-                        if ((*cp == '\\') &&
-                            ((cp[1] == delim) ||
-                             (cp[1] == '&') ||
-                             (cp[1] == '\\') ||
-                             (cp[1] == '$')))
-                        {
-                            Buf_AddByte(buf, (Byte)cp[1]);
-                            cp++;
-                        } else if ((*cp == '$') && (cp[1] != delim)) {
-                            char    *cp2;
-                            int     len;
-                            Boolean freeIt;
-
-                            cp2 = Var_Parse(cp, ctxt, err, &len, &freeIt);
-                            Buf_AddBytes(buf, strlen(cp2), (Byte *)cp2);
-                            cp += len - 1;
-                            if (freeIt) {
-                                efree(cp2);
-                            }
-                        } else if (*cp == '&') {
-                            Buf_AddBytes(buf, pattern.leftLen,
-                                         (Byte *)pattern.lhs);
-                        } else {
-                            Buf_AddByte(buf, (Byte)*cp);
-                        }
-                    }
-
-                    Buf_AddByte(buf, (Byte)'\0');
-
-                    /*
-                     * If didn't end in delimiter character, complain
-                     */
-                    if (*cp != delim) {
-                        *lengthPtr = cp - start + 1;
-                        if (*freePtr) {
-                            efree(str);
-                        }
-                        Buf_Destroy(buf, TRUE);
-                        Error("Unclosed substitution for %s (%c missing)",
-                              v->name, delim);
-                        return (var_Error);
-                    }
-
-                    pattern.rhs = (char *)Buf_GetAll(buf, &pattern.rightLen);
-                    pattern.rightLen--;
-                    Buf_Destroy(buf, FALSE);
-
-                    /*
-                     * Check for global substitution. If 'g' after the final
-                     * delimiter, substitution is global and is marked that
-                     * way.
-                     */
-                    cp++;
-                    if (*cp == 'g') {
-                        pattern.flags |= VAR_SUB_GLOBAL;
-                        cp++;
-                    }
-
-                    termc = *cp;
-                    newStr = VarModify(str, VarSubstitute,
-                                       (ClientData)&pattern);
-                    /*
-                     * Free the two strings.
-                     */
-                    efree(pattern.lhs);
-                    efree(pattern.rhs);
-                    break;
-                }
-                case 'C':
-                {
-                    VarREPattern    pattern;
-                    char           *re;
-                    int             error;
-
-                    pattern.flags = 0;
-                    delim = tstr[1];
-                    tstr += 2;
-
-                    cp = tstr;
-
-                    if ((re = VarGetPattern(ctxt, err, &cp, delim, NULL,
-                        NULL, NULL)) == NULL) {
-                        /* was: goto cleanup */
-                        *lengthPtr = cp - start + 1;
-                        if (*freePtr)
-                            efree(str);
-                        if (delim != '\0')
-                            Error("Unclosed substitution for %s (%c missing)",
-                                  v->name, delim);
-                        return (var_Error);
-                    }
-
-                    if ((pattern.replace = VarGetPattern(ctxt, err, &cp,
-                        delim, NULL, NULL, NULL)) == NULL){
-                        efree(re);
-
-                        /* was: goto cleanup */
-                        *lengthPtr = cp - start + 1;
-                        if (*freePtr)
-                            efree(str);
-                        if (delim != '\0')
-                            Error("Unclosed substitution for %s (%c missing)",
-                                  v->name, delim);
-                        return (var_Error);
-                    }
-
-                    for (;; cp++) {
-                        switch (*cp) {
-                        case 'g':
-                            pattern.flags |= VAR_SUB_GLOBAL;
-                            continue;
-                        case '1':
-                            pattern.flags |= VAR_SUB_ONE;
-                            continue;
-                        }
-                        break;
-                    }
-
-                    termc = *cp;
-
-                    error = regcomp(&pattern.re, re, REG_EXTENDED);
-                    efree(re);
-                    if (error)  {
-                        *lengthPtr = cp - start + 1;
-                        VarREError(error, &pattern.re, "RE substitution error");
-                        efree(pattern.replace);
-                        return (var_Error);
-                    }
-
-                    pattern.nsub = pattern.re.re_nsub + 1;
-                    if (pattern.nsub < 1)
-                        pattern.nsub = 1;
-                    if (pattern.nsub > 10)
-                        pattern.nsub = 10;
-                    pattern.matches = emalloc(pattern.nsub *
-                                              sizeof(regmatch_t));
-                    newStr = VarModify(str, VarRESubstitute,
-                                       (ClientData) &pattern);
-                    regfree(&pattern.re);
-                    efree(pattern.replace);
-                    efree(pattern.matches);
-                    break;
-                }
-                case 'Q':
-                    if (tstr[1] == endc || tstr[1] == ':') {
-                        newStr = VarQuote (str);
-                        cp = tstr + 1;
-                        termc = *cp;
-                        break;
-                    }
-                    /*FALLTHRU*/
-                case 'T':
-                    if (tstr[1] == endc || tstr[1] == ':') {
-                        newStr = VarModify (str, VarTail, (ClientData)0);
-                        cp = tstr + 1;
-                        termc = *cp;
-                        break;
-                    }
-                    /*FALLTHRU*/
-                case 'H':
-                    if (tstr[1] == endc || tstr[1] == ':') {
-                        newStr = VarModify (str, VarHead, (ClientData)0);
-                        cp = tstr + 1;
-                        termc = *cp;
-                        break;
-                    }
-                    /*FALLTHRU*/
-                case 'E':
-                    if (tstr[1] == endc || tstr[1] == ':') {
-                        newStr = VarModify (str, VarSuffix, (ClientData)0);
-                        cp = tstr + 1;
-                        termc = *cp;
-                        break;
-                    }
-                    /*FALLTHRU*/
-                case 'R':
-                    if (tstr[1] == endc || tstr[1] == ':') {
-                        newStr = VarModify (str, VarRoot, (ClientData)0);
-                        cp = tstr + 1;
-                        termc = *cp;
-                        break;
-                    }
-                    /*FALLTHRU*/
+        /*
+         * Skip initial colon while putting it back.
+         */
+        *tstr++ = ':';
+        while (*tstr != endc) {
+            char        *newStr;    /* New value to return */
+            char        termc;      /* Character which terminated scan */
+
+            if (DEBUG(VAR)) {
+                printf("Applying :%c to \"%s\"\n", *tstr, str);
+            }
+            switch (*tstr) {
+                case 'U':
+                        if (tstr[1] == endc || tstr[1] == ':') {
+                                Buffer buf;
+                                buf = Buf_Init(MAKE_BSIZE);
+                                for (cp = str; *cp ; cp++)
+                                        Buf_AddByte(buf, (Byte) toupper(*cp));
+
+                                Buf_AddByte(buf, (Byte) '\0');
+                                newStr = (char *) Buf_GetAll(buf, (int *) NULL);
+                                Buf_Destroy(buf, FALSE);
+
+                                cp = tstr + 1;
+                                termc = *cp;
+                                break;
+                        }
+                        /* FALLTHROUGH */
+                case 'L':
+                        if (tstr[1] == endc || tstr[1] == ':') {
+                                Buffer buf;
+                                buf = Buf_Init(MAKE_BSIZE);
+                                for (cp = str; *cp ; cp++)
+                                        Buf_AddByte(buf, (Byte) tolower(*cp));
+
+                                Buf_AddByte(buf, (Byte) '\0');
+                                newStr = (char *) Buf_GetAll(buf, (int *) NULL);
+                                Buf_Destroy(buf, FALSE);
+
+                                cp = tstr + 1;
+                                termc = *cp;
+                                break;
+                        }
+                        /* FALLTHROUGH */
+                case 'N':
+                case 'M':
+                {
+                    char    *pattern;
+                    char    *cp2;
+                    Boolean copy;
+
+                    copy = FALSE;
+                    for (cp = tstr + 1;
+                         *cp != '\0' && *cp != ':' && *cp != endc;
+                         cp++)
+                    {
+                        if (*cp == '\\' && (cp[1] == ':' || cp[1] == endc)){
+                            copy = TRUE;
+                            cp++;
+                        }
+                    }
+                    termc = *cp;
+                    *cp = '\0';
+                    if (copy) {
+                        /*
+                         * Need to compress the \:'s out of the pattern, so
+                         * allocate enough room to hold the uncompressed
+                         * pattern (note that cp started at tstr+1, so
+                         * cp - tstr takes the null byte into account) and
+                         * compress the pattern into the space.
+                         */
+                        pattern = emalloc(cp - tstr);
+                        for (cp2 = pattern, cp = tstr + 1;
+                             *cp != '\0';
+                             cp++, cp2++)
+                        {
+                            if ((*cp == '\\') &&
+                                (cp[1] == ':' || cp[1] == endc)) {
+                                    cp++;
+                            }
+                            *cp2 = *cp;
+                        }
+                        *cp2 = '\0';
+                    } else {
+                        pattern = &tstr[1];
+                    }
+                    if (*tstr == 'M' || *tstr == 'm') {
+                        newStr = VarModify(str, VarMatch, (ClientData)pattern);
+                    } else {
+                        newStr = VarModify(str, VarNoMatch,
+                                           (ClientData)pattern);
+                    }
+                    if (copy) {
+                        efree(pattern);
+                    }
+                    break;
+                }
+                case 'S':
+                {
+                    VarPattern      pattern;
+                    register char   delim;
+                    Buffer          buf;        /* Buffer for patterns */
+
+                    pattern.flags = 0;
+                    delim = tstr[1];
+                    tstr += 2;
+
+                    /*
+                     * If pattern begins with '^', it is anchored to the
+                     * start of the word -- skip over it and flag pattern.
+                     */
+                    if (*tstr == '^') {
+                        pattern.flags |= VAR_MATCH_START;
+                        tstr += 1;
+                    }
+
+                    buf = Buf_Init(0);
+
+                    /*
+                     * Pass through the lhs looking for 1) escaped delimiters,
+                     * '$'s and backslashes (place the escaped character in
+                     * uninterpreted) and 2) unescaped $'s that aren't before
+                     * the delimiter (expand the variable substitution).
+                     * The result is left in the Buffer buf.
+                     */
+                    for (cp = tstr; *cp != '\0' && *cp != delim; cp++) {
+                        if ((*cp == '\\') &&
+                            ((cp[1] == delim) ||
+                             (cp[1] == '$') ||
+                             (cp[1] == '\\')))
+                        {
+                            Buf_AddByte(buf, (Byte)cp[1]);
+                            cp++;
+                        } else if (*cp == '$') {
+                            if (cp[1] != delim) {
+                                /*
+                                 * If unescaped dollar sign not before the
+                                 * delimiter, assume it's a variable
+                                 * substitution and recurse.
+                                 */
+                                char        *cp2;
+                                int         len;
+                                Boolean     freeIt;
+
+                                cp2 = Var_Parse(cp, ctxt, err, &len, &freeIt);
+                                Buf_AddBytes(buf, strlen(cp2), (Byte *)cp2);
+                                if (freeIt) {
+                                    efree(cp2);
+                                }
+                                cp += len - 1;
+                            } else {
+                                /*
+                                 * Unescaped $ at end of pattern => anchor
+                                 * pattern at end.
+                                 */
+                                pattern.flags |= VAR_MATCH_END;
+                            }
+                        } else {
+                            Buf_AddByte(buf, (Byte)*cp);
+                        }
+                    }
+
+                    Buf_AddByte(buf, (Byte)'\0');
+
+                    /*
+                     * If lhs didn't end with the delimiter, complain and
+                     * return NULL
+                     */
+                    if (*cp != delim) {
+                        *lengthPtr = cp - start + 1;
+                        if (*freePtr) {
+                            efree(str);
+                        }
+                        Buf_Destroy(buf, TRUE);
+                        Error("Unclosed substitution for %s (%c missing)",
+                              v->name, delim);
+                        return (var_Error);
+                    }
+
+                    /*
+                     * Fetch pattern and destroy buffer, but preserve the data
+                     * in it, since that's our lhs. Note that Buf_GetAll
+                     * will return the actual number of bytes, which includes
+                     * the null byte, so we have to decrement the length by
+                     * one.
+                     */
+                    pattern.lhs = (char *)Buf_GetAll(buf, &pattern.leftLen);
+                    pattern.leftLen--;
+                    Buf_Destroy(buf, FALSE);
+
+                    /*
+                     * Now comes the replacement string. Three things need to
+                     * be done here: 1) need to compress escaped delimiters and
+                     * ampersands and 2) need to replace unescaped ampersands
+                     * with the l.h.s. (since this isn't regexp, we can do
+                     * it right here) and 3) expand any variable substitutions.
+                     */
+                    buf = Buf_Init(0);
+
+                    tstr = cp + 1;
+                    for (cp = tstr; *cp != '\0' && *cp != delim; cp++) {
+                        if ((*cp == '\\') &&
+                            ((cp[1] == delim) ||
+                             (cp[1] == '&') ||
+                             (cp[1] == '\\') ||
+                             (cp[1] == '$')))
+                        {
+                            Buf_AddByte(buf, (Byte)cp[1]);
+                            cp++;
+                        } else if ((*cp == '$') && (cp[1] != delim)) {
+                            char    *cp2;
+                            int     len;
+                            Boolean freeIt;
+
+                            cp2 = Var_Parse(cp, ctxt, err, &len, &freeIt);
+                            Buf_AddBytes(buf, strlen(cp2), (Byte *)cp2);
+                            cp += len - 1;
+                            if (freeIt) {
+                                efree(cp2);
+                            }
+                        } else if (*cp == '&') {
+                            Buf_AddBytes(buf, pattern.leftLen,
+                                         (Byte *)pattern.lhs);
+                        } else {
+                            Buf_AddByte(buf, (Byte)*cp);
+                        }
+                    }
+
+                    Buf_AddByte(buf, (Byte)'\0');
+
+                    /*
+                     * If didn't end in delimiter character, complain
+                     */
+                    if (*cp != delim) {
+                        *lengthPtr = cp - start + 1;
+                        if (*freePtr) {
+                            efree(str);
+                        }
+                        Buf_Destroy(buf, TRUE);
+                        Error("Unclosed substitution for %s (%c missing)",
+                              v->name, delim);
+                        return (var_Error);
+                    }
+
+                    pattern.rhs = (char *)Buf_GetAll(buf, &pattern.rightLen);
+                    pattern.rightLen--;
+                    Buf_Destroy(buf, FALSE);
+
+                    /*
+                     * Check for global substitution. If 'g' after the final
+                     * delimiter, substitution is global and is marked that
+                     * way.
+                     */
+                    cp++;
+                    if (*cp == 'g') {
+                        pattern.flags |= VAR_SUB_GLOBAL;
+                        cp++;
+                    }
+
+                    termc = *cp;
+                    newStr = VarModify(str, VarSubstitute,
+                                       (ClientData)&pattern);
+                    /*
+                     * Free the two strings.
+                     */
+                    efree(pattern.lhs);
+                    efree(pattern.rhs);
+                    break;
+                }
+                case 'C':
+                {
+                    VarREPattern    pattern;
+                    char           *re;
+                    int             error;
+
+                    pattern.flags = 0;
+                    delim = tstr[1];
+                    tstr += 2;
+
+                    cp = tstr;
+
+                    if ((re = VarGetPattern(ctxt, err, &cp, delim, NULL,
+                        NULL, NULL)) == NULL) {
+                        /* was: goto cleanup */
+                        *lengthPtr = cp - start + 1;
+                        if (*freePtr)
+                            efree(str);
+                        if (delim != '\0')
+                            Error("Unclosed substitution for %s (%c missing)",
+                                  v->name, delim);
+                        return (var_Error);
+                    }
+
+                    if ((pattern.replace = VarGetPattern(ctxt, err, &cp,
+                        delim, NULL, NULL, NULL)) == NULL){
+                        efree(re);
+
+                        /* was: goto cleanup */
+                        *lengthPtr = cp - start + 1;
+                        if (*freePtr)
+                            efree(str);
+                        if (delim != '\0')
+                            Error("Unclosed substitution for %s (%c missing)",
+                                  v->name, delim);
+                        return (var_Error);
+                    }
+
+                    for (;; cp++) {
+                        switch (*cp) {
+                        case 'g':
+                            pattern.flags |= VAR_SUB_GLOBAL;
+                            continue;
+                        case '1':
+                            pattern.flags |= VAR_SUB_ONE;
+                            continue;
+                        }
+                        break;
+                    }
+
+                    termc = *cp;
+
+                    error = regcomp(&pattern.re, re, REG_EXTENDED);
+                    efree(re);
+                    if (error)  {
+                        *lengthPtr = cp - start + 1;
+                        VarREError(error, &pattern.re, "RE substitution error");
+                        efree(pattern.replace);
+                        return (var_Error);
+                    }
+
+                    pattern.nsub = pattern.re.re_nsub + 1;
+                    if (pattern.nsub < 1)
+                        pattern.nsub = 1;
+                    if (pattern.nsub > 10)
+                        pattern.nsub = 10;
+                    pattern.matches = emalloc(pattern.nsub *
+                                              sizeof(regmatch_t));
+                    newStr = VarModify(str, VarRESubstitute,
+                                       (ClientData) &pattern);
+                    regfree(&pattern.re);
+                    efree(pattern.replace);
+                    efree(pattern.matches);
+                    break;
+                }
+                case 'Q':
+                    if (tstr[1] == endc || tstr[1] == ':') {
+                        newStr = VarQuote (str);
+                        cp = tstr + 1;
+                        termc = *cp;
+                        break;
+                    }
+                    /*FALLTHRU*/
+                case 'T':
+                    if (tstr[1] == endc || tstr[1] == ':') {
+                        newStr = VarModify (str, VarTail, (ClientData)0);
+                        cp = tstr + 1;
+                        termc = *cp;
+                        break;
+                    }
+                    /*FALLTHRU*/
+                case 'H':
+                    if (tstr[1] == endc || tstr[1] == ':') {
+                        newStr = VarModify (str, VarHead, (ClientData)0);
+                        cp = tstr + 1;
+                        termc = *cp;
+                        break;
+                    }
+                    /*FALLTHRU*/
+                case 'E':
+                    if (tstr[1] == endc || tstr[1] == ':') {
+                        newStr = VarModify (str, VarSuffix, (ClientData)0);
+                        cp = tstr + 1;
+                        termc = *cp;
+                        break;
+                    }
+                    /*FALLTHRU*/
+                case 'R':
+                    if (tstr[1] == endc || tstr[1] == ':') {
+                        newStr = VarModify (str, VarRoot, (ClientData)0);
+                        cp = tstr + 1;
+                        termc = *cp;
+                        break;
+                    }
+                    /*FALLTHRU*/
 #ifdef SUNSHCMD
-                case 's':
-                    if (tstr[1] == 'h' && (tstr[2] == endc || tstr[2] == ':')) {
-                        char *err;
-                        newStr = Cmd_Exec (str, &err);
-                        if (err)
-                            Error (err, str);
-                        cp = tstr + 2;
-                        termc = *cp;
-                        break;
-                    }
-                    /*FALLTHRU*/
+                case 's':
+                    if (tstr[1] == 'h' && (tstr[2] == endc || tstr[2] == ':')) {
+                        char *err;
+                        newStr = Cmd_Exec (str, &err);
+                        if (err)
+                            Error (err, str);
+                        cp = tstr + 2;
+                        termc = *cp;
+                        break;
+                    }
+                    /*FALLTHRU*/
 #endif
-                default:
-                {
+                default:
+                {
 #if defined(SYSVVARSUB) || defined(NMAKE)
-                    /*
-                     * This can either be a bogus modifier or a System-V
-                     * substitution command.
-                     */
-                    VarPattern      pattern;
-                    Boolean         eqFound;
-
-                    pattern.flags = 0;
-                    eqFound = FALSE;
-                    /*
-                     * First we make a pass through the string trying
-                     * to verify it is a SYSV-make-style translation:
-                     * it must be: <string1>=<string2>)
-                     */
-                    cp = tstr;
-                    cnt = 1;
-                    while (*cp != '\0' && cnt) {
-                        if (*cp == '=') {
-                            eqFound = TRUE;
-                            /* continue looking for endc */
-                        }
-                        else if (*cp == endc)
-                            cnt--;
-                        else if (*cp == startc)
-                            cnt++;
-                        if (cnt)
-                            cp++;
-                    }
+                    /*
+                     * This can either be a bogus modifier or a System-V
+                     * substitution command.
+                     */
+                    VarPattern      pattern;
+                    Boolean         eqFound;
+
+                    pattern.flags = 0;
+                    eqFound = FALSE;
+                    /*
+                     * First we make a pass through the string trying
+                     * to verify it is a SYSV-make-style translation:
+                     * it must be: <string1>=<string2>)
+                     */
+                    cp = tstr;
+                    cnt = 1;
+                    while (*cp != '\0' && cnt) {
+                        if (*cp == '=') {
+                            eqFound = TRUE;
+                            /* continue looking for endc */
+                        }
+                        else if (*cp == endc)
+                            cnt--;
+                        else if (*cp == startc)
+                            cnt++;
+                        if (cnt)
+                            cp++;
+                    }
 fprintf(stderr, "debug: cp=\"%s\" endc=%c eqFound=%d tstr=\"%s\"\n", cp, endc, eqFound, tstr);
-                    if (*cp == endc && eqFound) {
-
-                        /*
-                         * Now we break this sucker into the lhs and
-                         * rhs. We must null terminate them of course.
-                         */
-                        for (cp = tstr; *cp != '='; cp++)
-                            continue;
-                        pattern.lhs = tstr;
-                        pattern.leftLen = cp - tstr;
-                        *cp++ = '\0';
-
-                        pattern.rhs = cp;
-                        cnt = 1;
-                        while (cnt) {
-                            if (*cp == endc)
-                                cnt--;
-                            else if (*cp == startc)
-                                cnt++;
-                            if (cnt)
-                                cp++;
-                        }
-                        pattern.rightLen = cp - pattern.rhs;
-                        *cp = '\0';
-
-                        /*
-                         * SYSV modifications happen through the whole
-                         * string. Note the pattern is anchored at the end.
-                         */
-                        newStr = VarModify(str, VarSYSVMatch,
-                                           (ClientData)&pattern);
-
-                        /*
-                         * Restore the nulled characters
-                         */
-                        pattern.lhs[pattern.leftLen] = '=';
-                        pattern.rhs[pattern.rightLen] = endc;
-                        termc = endc;
-                    } else
+                    if (*cp == endc && eqFound) {
+
+                        /*
+                         * Now we break this sucker into the lhs and
+                         * rhs. We must null terminate them of course.
+                         */
+                        for (cp = tstr; *cp != '='; cp++)
+                            continue;
+                        pattern.lhs = tstr;
+                        pattern.leftLen = cp - tstr;
+                        *cp++ = '\0';
+
+                        pattern.rhs = cp;
+                        cnt = 1;
+                        while (cnt) {
+                            if (*cp == endc)
+                                cnt--;
+                            else if (*cp == startc)
+                                cnt++;
+                            if (cnt)
+                                cp++;
+                        }
+                        pattern.rightLen = cp - pattern.rhs;
+                        *cp = '\0';
+
+                        /*
+                         * SYSV modifications happen through the whole
+                         * string. Note the pattern is anchored at the end.
+                         */
+                        newStr = VarModify(str, VarSYSVMatch,
+                                           (ClientData)&pattern);
+
+                        /*
+                         * Restore the nulled characters
+                         */
+                        pattern.lhs[pattern.leftLen] = '=';
+                        pattern.rhs[pattern.rightLen] = endc;
+                        termc = endc;
+                    } else
 #endif
-                    {
-                        Error ("Unknown modifier '%c'\n", *tstr);
-                        for (cp = tstr+1;
-                             *cp != ':' && *cp != endc && *cp != '\0';
-                             cp++)
-                                 continue;
-                        termc = *cp;
-                        newStr = var_Error;
-                    }
-                }
-            }
-            if (DEBUG(VAR)) {
-                printf("Result is \"%s\"\n", newStr);
-            }
-
-            if (*freePtr) {
-                efree (str);
-            }
-            str = newStr;
-            if (str != var_Error) {
-                *freePtr = TRUE;
-            } else {
-                *freePtr = FALSE;
-            }
-            if (termc == '\0') {
-                Error("Unclosed variable specification for %s", v->name);
-            } else if (termc == ':') {
-                *cp++ = termc;
-            } else {
-                *cp = termc;
-            }
-            tstr = cp;
-        }
-        *lengthPtr = tstr - start + 1;
+                    {
+                        Error ("Unknown modifier '%c'\n", *tstr);
+                        for (cp = tstr+1;
+                             *cp != ':' && *cp != endc && *cp != '\0';
+                             cp++)
+                                 continue;
+                        termc = *cp;
+                        newStr = var_Error;
+                    }
+                }
+            }
+            if (DEBUG(VAR)) {
+                printf("Result is \"%s\"\n", newStr);
+            }
+
+            if (*freePtr) {
+                efree (str);
+            }
+            str = newStr;
+            if (str != var_Error) {
+                *freePtr = TRUE;
+            } else {
+                *freePtr = FALSE;
+            }
+            if (termc == '\0') {
+                Error("Unclosed variable specification for %s", v->name);
+            } else if (termc == ':') {
+                *cp++ = termc;
+            } else {
+                *cp = termc;
+            }
+            tstr = cp;
+        }
+        *lengthPtr = tstr - start + 1;
     } else {
-        *lengthPtr = tstr - start + 1;
-        *tstr = endc;
+        *lengthPtr = tstr - start + 1;
+        *tstr = endc;
     }
 
     if (v->flags & VAR_FROM_ENV) {
-        Boolean   destroy = FALSE;
-
-        if (str != (char *)Buf_GetAll(v->val, (int *)NULL)) {
-            destroy = TRUE;
-        } else {
-            /*
-             * Returning the value unmodified, so tell the caller to efree
-             * the thing.
-             */
-            *freePtr = TRUE;
-        }
-        Buf_Destroy(v->val, destroy);
-        efree((Address)v);
+        Boolean   destroy = FALSE;
+
+        if (str != (char *)Buf_GetAll(v->val, (int *)NULL)) {
+            destroy = TRUE;
+        } else {
+            /*
+             * Returning the value unmodified, so tell the caller to efree
+             * the thing.
+             */
+            *freePtr = TRUE;
+        }
+        Buf_Destroy(v->val, destroy);
+        efree((Address)v);
     } else if (v->flags & VAR_JUNK) {
-        /*
-         * Perform any efree'ing needed and set *freePtr to FALSE so the caller
-         * doesn't try to efree a static pointer.
-         */
-        if (*freePtr) {
-            efree(str);
-        }
-        *freePtr = FALSE;
-        Buf_Destroy(v->val, TRUE);
-        efree((Address)v);
-        if (dynamic) {
-            str = emalloc(*lengthPtr + 1);
-            strncpy(str, start, *lengthPtr);
-            str[*lengthPtr] = '\0';
-            *freePtr = TRUE;
-        } else {
-            str = err ? var_Error : varNoError;
-        }
+        /*
+         * Perform any efree'ing needed and set *freePtr to FALSE so the caller
+         * doesn't try to efree a static pointer.
+         */
+        if (*freePtr) {
+            efree(str);
+        }
+        *freePtr = FALSE;
+        Buf_Destroy(v->val, TRUE);
+        efree((Address)v);
+        if (dynamic) {
+            str = emalloc(*lengthPtr + 1);
+            strncpy(str, start, *lengthPtr);
+            str[*lengthPtr] = '\0';
+            *freePtr = TRUE;
+        } else {
+            str = err ? var_Error : varNoError;
+        }
     }
     return (str);
@@ -2434 +2433 @@
  *-----------------------------------------------------------------------
  * Var_Subst  --
- *      Substitute for all variables in the given string in the given context
- *      If undefErr is TRUE, Parse_Error will be called when an undefined
- *      variable is encountered.
- *
- * Results:
- *      The resulting string.
- *
- * Side Effects:
- *      None. The old string must be freed by the caller
+ *      Substitute for all variables in the given string in the given context
+ *      If undefErr is TRUE, Parse_Error will be called when an undefined
+ *      variable is encountered.
+ *
+ * Results:
+ *      The resulting string.
+ *
+ * Side Effects:
+ *      None. The old string must be freed by the caller
  *-----------------------------------------------------------------------
  */
 char *
 Var_Subst (var, str, ctxt, undefErr)
-    char          *var;             /* Named variable || NULL for all */
-    char          *str;             /* the string in which to substitute */
-    GNode         *ctxt;            /* the context wherein to find variables */
-    Boolean       undefErr;         /* TRUE if undefineds are an error */
-{
-    Buffer        buf;              /* Buffer for forming things */
-    char          *val;             /* Value to substitute for a variable */
-    int           length;           /* Length of the variable invocation */
-    Boolean       doFree;           /* Set true if val should be freed */
+    char          *var;             /* Named variable || NULL for all */
+    char          *str;             /* the string in which to substitute */
+    GNode         *ctxt;            /* the context wherein to find variables */
+    Boolean       undefErr;         /* TRUE if undefineds are an error */
+{
+    Buffer        buf;              /* Buffer for forming things */
+    char          *val;             /* Value to substitute for a variable */
+    int           length;           /* Length of the variable invocation */
+    Boolean       doFree;           /* Set true if val should be freed */
     static Boolean errorReported;   /* Set true if an error has already
-                                     * been reported to prevent a plethora
-                                     * of messages when recursing */
+                                     * been reported to prevent a plethora
+                                     * of messages when recursing */
 
     buf = Buf_Init (MAKE_BSIZE);
@@ -2464 +2463 @@
 
     while (*str) {
-        if (var == NULL && (*str == '$') && (str[1] == '$')) {
-            /*
-             * A dollar sign may be escaped either with another dollar sign.
-             * In such a case, we skip over the escape character and store the
-             * dollar sign into the buffer directly.
-             */
-            str++;
-            Buf_AddByte(buf, (Byte)*str);
-            str++;
-        } else if (*str != '$') {
-            /*
-             * Skip as many characters as possible -- either to the end of
-             * the string or to the next dollar sign (variable invocation).
-             */
-            char  *cp;
-
-            for (cp = str++; *str != '$' && *str != '\0'; str++)
-                continue;
-            Buf_AddBytes(buf, str - cp, (Byte *)cp);
-        } else {
-            if (var != NULL) {
-                int expand;
-                for (;;) {
-                    if (str[1] != '(' && str[1] != '{') {
-                        if (str[1] != *var) {
-                            Buf_AddBytes(buf, 2, (Byte *) str);
-                            str += 2;
-                            expand = FALSE;
-                        }
-                        else
-                            expand = TRUE;
-                        break;
-                    }
-                    else {
-                        char *p;
-
-                        /*
-                         * Scan up to the end of the variable name.
-                         */
-                        for (p = &str[2]; *p &&
-                             *p != ':' && *p != ')' && *p != '}'; p++)
-                            if (*p == '$')
-                                break;
-                        /*
-                         * A variable inside the variable. We cannot expand
-                         * the external variable yet, so we try again with
-                         * the nested one
-                         */
-                        if (*p == '$') {
-                            Buf_AddBytes(buf, p - str, (Byte *) str);
-                            str = p;
-                            continue;
-                        }
-
-                        if (strncmp(var, str + 2, p - str - 2) != 0 ||
-                            var[p - str - 2] != '\0') {
-                            /*
-                             * Not the variable we want to expand, scan
-                             * until the next variable
-                             */
-                            for (;*p != '$' && *p != '\0'; p++)
-                                continue;
-                            Buf_AddBytes(buf, p - str, (Byte *) str);
-                            str = p;
-                            expand = FALSE;
-                        }
-                        else
-                            expand = TRUE;
-                        break;
-                    }
-                }
-                if (!expand)
-                    continue;
-            }
-
-            val = Var_Parse (str, ctxt, undefErr, &length, &doFree);
-
-            /*
-             * When we come down here, val should either point to the
-             * value of this variable, suitably modified, or be NULL.
-             * Length should be the total length of the potential
-             * variable invocation (from $ to end character...)
-             */
-            if (val == var_Error || val == varNoError) {
-                /*
-                 * If performing old-time variable substitution, skip over
-                 * the variable and continue with the substitution. Otherwise,
-                 * store the dollar sign and advance str so we continue with
-                 * the string...
-                 */
-                if (oldVars) {
-                    str += length;
-                } else if (undefErr) {
-                    /*
-                     * If variable is undefined, complain and skip the
-                     * variable. The complaint will stop us from doing anything
-                     * when the file is parsed.
-                     */
-                    if (!errorReported) {
-                        Parse_Error (PARSE_FATAL,
-                                     "Undefined variable \"%.*s\"",length,str);
-                    }
-                    str += length;
-                    errorReported = TRUE;
-                } else {
-                    Buf_AddByte (buf, (Byte)*str);
-                    str += 1;
-                }
-            } else {
-                /*
-                 * We've now got a variable structure to store in. But first,
-                 * advance the string pointer.
-                 */
-                str += length;
-
-                /*
-                 * Copy all the characters from the variable value straight
-                 * into the new string.
-                 */
-                Buf_AddBytes (buf, strlen (val), (Byte *)val);
-                if (doFree) {
-                    efree ((Address)val);
-                }
-            }
-        }
+        if (var == NULL && (*str == '$') && (str[1] == '$')) {
+            /*
+             * A dollar sign may be escaped either with another dollar sign.
+             * In such a case, we skip over the escape character and store the
+             * dollar sign into the buffer directly.
+             */
+            str++;
+            Buf_AddByte(buf, (Byte)*str);
+            str++;
+        } else if (*str != '$') {
+            /*
+             * Skip as many characters as possible -- either to the end of
+             * the string or to the next dollar sign (variable invocation).
+             */
+            char  *cp;
+
+            for (cp = str++; *str != '$' && *str != '\0'; str++)
+                continue;
+            Buf_AddBytes(buf, str - cp, (Byte *)cp);
+        } else {
+            if (var != NULL) {
+                int expand;
+                for (;;) {
+                    if (str[1] != '(' && str[1] != '{') {
+                        if (str[1] != *var) {
+                            Buf_AddBytes(buf, 2, (Byte *) str);
+                            str += 2;
+                            expand = FALSE;
+                        }
+                        else
+                            expand = TRUE;
+                        break;
+                    }
+                    else {
+                        char *p;
+
+                        /*
+                         * Scan up to the end of the variable name.
+                         */
+                        for (p = &str[2]; *p &&
+                             *p != ':' && *p != ')' && *p != '}'; p++)
+                            if (*p == '$')
+                                break;
+                        /*
+                         * A variable inside the variable. We cannot expand
+                         * the external variable yet, so we try again with
+                         * the nested one
+                         */
+                        if (*p == '$') {
+                            Buf_AddBytes(buf, p - str, (Byte *) str);
+                            str = p;
+                            continue;
+                        }
+
+                        if (strncmp(var, str + 2, p - str - 2) != 0 ||
+                            var[p - str - 2] != '\0') {
+                            /*
+                             * Not the variable we want to expand, scan
+                             * until the next variable
+                             */
+                            for (;*p != '$' && *p != '\0'; p++)
+                                continue;
+                            Buf_AddBytes(buf, p - str, (Byte *) str);
+                            str = p;
+                            expand = FALSE;
+                        }
+                        else
+                            expand = TRUE;
+                        break;
+                    }
+                }
+                if (!expand)
+                    continue;
+            }
+
+            val = Var_Parse (str, ctxt, undefErr, &length, &doFree);
+
+            /*
+             * When we come down here, val should either point to the
+             * value of this variable, suitably modified, or be NULL.
+             * Length should be the total length of the potential
+             * variable invocation (from $ to end character...)
+             */
+            if (val == var_Error || val == varNoError) {
+                /*
+                 * If performing old-time variable substitution, skip over
+                 * the variable and continue with the substitution. Otherwise,
+                 * store the dollar sign and advance str so we continue with
+                 * the string...
+                 */
+                if (oldVars) {
+                    str += length;
+                } else if (undefErr) {
+                    /*
+                     * If variable is undefined, complain and skip the
+                     * variable. The complaint will stop us from doing anything
+                     * when the file is parsed.
+                     */
+                    if (!errorReported) {
+                        Parse_Error (PARSE_FATAL,
+                                     "Undefined variable \"%.*s\"",length,str);
+                    }
+                    str += length;
+                    errorReported = TRUE;
+                } else {
+                    Buf_AddByte (buf, (Byte)*str);
+                    str += 1;
+                }
+            } else {
+                /*
+                 * We've now got a variable structure to store in. But first,
+                 * advance the string pointer.
+                 */
+                str += length;
+
+                /*
+                 * Copy all the characters from the variable value straight
+                 * into the new string.
+                 */
+                Buf_AddBytes (buf, strlen (val), (Byte *)val);
+                if (doFree) {
+                    efree ((Address)val);
+                }
+            }
+        }
     }
 
@@ -2600 +2599 @@
  *-----------------------------------------------------------------------
  * Var_GetTail --
- *      Return the tail from each of a list of words. Used to set the
- *      System V local variables.
- *
- * Results:
- *      The resulting string.
- *
- * Side Effects:
- *      None.
+ *      Return the tail from each of a list of words. Used to set the
+ *      System V local variables.
+ *
+ * Results:
+ *      The resulting string.
+ *
+ * Side Effects:
+ *      None.
  *
  *-----------------------------------------------------------------------
@@ -2613 +2612 @@
 char *
 Var_GetTail(file)
-    char        *file;      /* Filename to modify */
+    char        *file;      /* Filename to modify */
 {
     return(VarModify(file, VarTail, (ClientData)0));
@@ -2621 +2620 @@
  *-----------------------------------------------------------------------
  * Var_GetHead --
- *      Find the leading components of a (list of) filename(s).
- *      XXX: VarHead does not replace foo by ., as (sun) System V make
- *      does.
- *
- * Results:
- *      The leading components.
- *
- * Side Effects:
- *      None.
+ *      Find the leading components of a (list of) filename(s).
+ *      XXX: VarHead does not replace foo by ., as (sun) System V make
+ *      does.
+ *
+ * Results:
+ *      The leading components.
+ *
+ * Side Effects:
+ *      None.
  *
  *-----------------------------------------------------------------------
@@ -2635 +2634 @@
 char *
 Var_GetHead(file)
-    char        *file;      /* Filename to manipulate */
+    char        *file;      /* Filename to manipulate */
 {
     return(VarModify(file, VarHead, (ClientData)0));
@@ -2643 +2642 @@
  *-----------------------------------------------------------------------
  * Var_Init --
- *      Initialize the module
- *
- * Results:
- *      None
- *
- * Side Effects:
- *      The VAR_CMD and VAR_GLOBAL contexts are created
+ *      Initialize the module
+ *
+ * Results:
+ *      None
+ *
+ * Side Effects:
+ *      The VAR_CMD and VAR_GLOBAL contexts are created
  *-----------------------------------------------------------------------
  */
@@ -2683 +2682 @@
  *-----------------------------------------------------------------------
  * Var_Dump --
- *      print all variables in a context
+ *      print all variables in a context
  *-----------------------------------------------------------------------
  */

trunk/src/makefile.os2.icc.mk

@@ -33 +33 @@
 POSTFIX     = .prf
 !endif
-OBJDIR      = ..\obj\os2-icc-kmk.$(POSTFIX)
+OBJDIR      = ..\obj\os2-icc-kmk$(POSTFIX)
 
 # paths
@@ -40 +40 @@
 
 # compiler setup
+CC          = icc.exe
 !ifdef DEBUG
 CFLAGS_1    = /O- -DDEBUG
@@ -46 +47 @@
 CFLAGS_1    = /O+ /Gh
 !endif
-CFLAGS      = /Q /Ti+ /Gm /Ge /Gl -DOS2 -D__i386__ -DKMK -I$(PATH_KLIB)\Generic\include -I$(PATH_TOOLKIT)\h -I$(PATH_VAC308)\include $(CFLAGS_1)
-CFLAGS_KMK  = /IkMk\include $(CFLAGS)
+CFLAGS      = /Q /Ti+ /Gm /Ge /Gl /W3 -DOS2 -D__i386__ -DKMK \
+              -I$(PATH_KLIB)\Generic\include \
+              -I$(PATH_KLIB)\Generic\include\kLibCRT \
+              -I$(PATH_TOOLKIT)\h \
+              -I$(PATH_VAC308)\include \
+              $(CFLAGS_1)
+CFLAGS_KMK  = -IkMk\include -IkMk -DUSE_KLIB $(CFLAGS) -UDEBUG  -DMACHINE=\"ibmos2\" -DMACHINE_ARCH=\"x86\" -DMACHINE_CPU=\"386\" \
 
 # linker setup
+LD          = ilink.exe
+STRIP       =
 !ifdef DEBUG
 LDFLAGS_1   = /NOEXEPACK
@@ -57 +65 @@
 !endif
 !ifndef LDFLAGS_1 #releas
-LDFLAGS_1   = /EXEPACK:2 /Packcode /Packdata
+LDFLAGS_1   = /Packcode /Packdata
+STRIP       = lxlite.exe
 !endif
 LDFLAGS     = /NoLogo /NoExtDictionary /Optfunc /Base:0x10000 /Map /Linenumbers /Debug /PmType:vio $(LDFLAGS_1)
@@ -73 +82 @@
 
 {.\kMk\lst.lib}.c{$(OBJDIR)}.obj:
-    $(CC) -c $(CFLAGS_KMK) -Fo$(OBJDIR)\$(@F) $(MAKEDIR)\kMk\lst.lib$(<F)
+    $(CC) -c $(CFLAGS_KMK) -Fo$(OBJDIR)\$(@F) $(MAKEDIR)\kMk\lst.lib\$(<F)
 
 
@@ -143 +152 @@
 !endif
 !endif
-$(PATH_TOOLKIT)\os2386.lib \
-$(VAC308_TOOLKIT)\cppom30.lib \
-                    
-                
-# the rules             
+$(PATH_TOOLKIT)\lib\os2386.lib \
+$(PATH_VAC308)\lib\cppom30.lib \
+
+
+# the rules
 all: $(OBJDIR) $(OBJDIR)\kMk.exe
 
 
 $(OBJDIR):
-    -mkdir ..\obj
-    -mkdir $(OBJDIR)
+    -if not exist ..\obj    mkdir ..\obj
+    -if not exist $(OBJDIR) mkdir $(OBJDIR)
 
 $(OBJDIR)\kMk.exe: $(OBJS)
@@ -162 +171 @@
 $(LIBS)
 <<KEEP
+!if "$(STRIP)" != ""
+    copy $(OBJDIR)\kMk.exe $(OBJDIR)\kMk.dbg
+    $(STRIP) $(OBJDIR)\kMk.exe
+!endif
 
+
+clean:
+!if "$(OBJDIR)" != "" && "$(OBJDIR)" != "\"
+!if "$(COMSPEC:CMD.EXE=sure)" != "$(COMSPEC)"
+    -del /N $(OBJDIR)\*
+!else # assume 4os2
+    -del /Y /E $(OBJDIR)\*
+!endif
+!endif