 @@ -1,1798 +1,1798 @@
-/*	$NetBSD: dir.c,v 1.122 2020/08/29 10:12:06 rillig Exp $	*/
+/*	$NetBSD: dir.c,v 1.123 2020/08/29 10:41:12 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 /*
  * Copyright (c) 1988, 1989 by Adam de Boor
  * Copyright (c) 1989 by Berkeley Softworks
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 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.
  * 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
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #ifndef MAKE_NATIVE
-static char rcsid[] = "$NetBSD: dir.c,v 1.122 2020/08/29 10:12:06 rillig Exp $";
+static char rcsid[] = "$NetBSD: dir.c,v 1.123 2020/08/29 10:41:12 rillig Exp $";
 #else
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)dir.c	8.2 (Berkeley) 1/2/94";
 #else
-__RCSID("$NetBSD: dir.c,v 1.122 2020/08/29 10:12:06 rillig Exp $");
+__RCSID("$NetBSD: dir.c,v 1.123 2020/08/29 10:41:12 rillig Exp $");
 #endif
 #endif /* not lint */
 #endif
 /*-
  * dir.c --
  *	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_InitCur	    Set the cur Path.
+ *
  *	Dir_InitDot	    Set the dot Path.
+ *
  *	Dir_End  	    Cleanup the module.
+ *
  *	Dir_SetPATH	    Set ${.PATH} to reflect state of dirSearchPath.
+ *
  *	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_FindHereOrAbove Search for a path in the current directory and
  *			    then all the directories above it in turn until
  *			    the path is found or we reach the root ("/").
+ *
  *	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.
  */
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <dirent.h>
 #include <errno.h>
 #include <stdio.h>
 #include "make.h"
 #include "dir.h"
 #include "job.h"
 #define DIR_DEBUG0(fmt) \
     if (!DEBUG(DIR)) (void) 0; else fprintf(debug_file, fmt)
 #define DIR_DEBUG1(fmt, arg1) \
     if (!DEBUG(DIR)) (void) 0; else fprintf(debug_file, fmt, arg1)
 #define DIR_DEBUG2(fmt, arg1, arg2) \
     if (!DEBUG(DIR)) (void) 0; else fprintf(debug_file, fmt, arg1, arg2)
 /*
  *	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 */
 /*
  * Variables for gathering statistics on the efficiency of the hashing
  * mechanism.
  */
 static int hits;		/* Found in directory cache */
 static int misses;		/* Sad, but not evil misses */
 static int nearmisses;		/* Found under search path */
 static int bigmisses;		/* Sought by itself */
 static Path *dot;		/* contents of current directory */
 static Path *cur;		/* contents of current directory, if not dot */
 static Path *dotLast;		/* a fake path entry indicating we need to
 				 * look for . last */
 /* 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... */
 static Hash_Table mtimes;
 static Hash_Table lmtimes;	/* same as mtimes but for lstat */
 static void DirExpandCurly(const char *, const char *, Lst, Lst);
 static void DirExpandInt(const char *, Lst, Lst);
 static int DirPrintWord(void *, void *);
 static int DirPrintDir(void *, void *);
 static char *DirLookup(Path *, const char *, const char *, Boolean);
 static char *DirLookupSubdir(Path *, const char *);
 static char *DirFindDot(Boolean, const char *, const char *);
 static char *DirLookupAbs(Path *, const char *, const char *);
 /*
  * We use stat(2) a lot, cache the results.
  * mtime and mode are all we care about.
  */
 struct cache_st {
     time_t lmtime;		/* lstat */
     time_t mtime;		/* stat */
     mode_t mode;
 };
 /* minimize changes below */
 typedef enum {
     CST_LSTAT = 0x01,		/* call lstat(2) instead of stat(2) */
     CST_UPDATE = 0x02		/* ignore existing cached entry */
 } CachedStatsFlags;
 /* Returns 0 and the result of stat(2) or lstat(2) in *st, or -1 on error.
  * Only st->st_mode and st->st_mtime are filled. */
 static int
 cached_stats(Hash_Table *htp, const char *pathname, struct stat *st,
 	     CachedStatsFlags flags)
+{
     Hash_Entry *entry;
     struct cache_st *cst;
     int rc;
     if (!pathname || !pathname[0])
 	return -1;
     entry = Hash_FindEntry(htp, pathname);
     if (entry && !(flags & CST_UPDATE)) {
 	cst = entry->clientPtr;
 	memset(st, 0, sizeof(*st));
 	st->st_mode = cst->mode;
 	st->st_mtime = (flags & CST_LSTAT) ? cst->lmtime : cst->mtime;
 	if (st->st_mtime) {
 	    DIR_DEBUG2("Using cached time %s for %s\n",
 		       Targ_FmtTime(st->st_mtime), pathname);
 	    return 0;
+	}
+    }
     rc = (flags & CST_LSTAT) ? lstat(pathname, st) : stat(pathname, st);
     if (rc == -1)
 	return -1;
     if (st->st_mtime == 0)
 	st->st_mtime = 1;	/* avoid confusion with missing file */
     if (!entry)
 	entry = Hash_CreateEntry(htp, pathname, NULL);
     if (!entry->clientPtr) {
 	entry->clientPtr = bmake_malloc(sizeof(*cst));
 	memset(entry->clientPtr, 0, sizeof(*cst));
+    }
     cst = entry->clientPtr;
     if (flags & CST_LSTAT) {
 	cst->lmtime = st->st_mtime;
     } else {
 	cst->mtime = st->st_mtime;
+    }
     cst->mode = st->st_mode;
     DIR_DEBUG2("   Caching %s for %s\n",
 	       Targ_FmtTime(st->st_mtime), pathname);
     return 0;
+}
 int
 cached_stat(const char *pathname, void *st)
+{
     return cached_stats(&mtimes, pathname, st, 0);
+}
 int
 cached_lstat(const char *pathname, void *st)
+{
     return cached_stats(&lmtimes, pathname, st, CST_LSTAT);
+}
 /* Initialize things for this module. */
 void
 Dir_Init(void)
+{
     dirSearchPath = Lst_Init();
     openDirectories = Lst_Init();
     Hash_InitTable(&mtimes, 0);
     Hash_InitTable(&lmtimes, 0);
+}
 void
 Dir_InitDir(const char *cdname)
+{
     Dir_InitCur(cdname);
     dotLast = bmake_malloc(sizeof(Path));
     dotLast->refCount = 1;
     dotLast->hits = 0;
     dotLast->name = bmake_strdup(".DOTLAST");
     Hash_InitTable(&dotLast->files, -1);
+}
 /*
  * Called by Dir_InitDir and whenever .CURDIR is assigned to.
  */
 void
 Dir_InitCur(const char *cdname)
+{
     Path *p;
     if (cdname != NULL) {
 	/*
 	 * Our build directory is not the same as our source directory.
 	 * Keep this one around too.
 	 */
 	if ((p = Dir_AddDir(NULL, cdname))) {
 	    p->refCount += 1;
 	    if (cur && cur != p) {
 		/*
 		 * We've been here before, cleanup.
 		 */
 		cur->refCount -= 1;
 		Dir_Destroy(cur);
+	    }
 	    cur = p;
+	}
+    }
+}
 /*-
  *-----------------------------------------------------------------------
  * Dir_InitDot --
  *	(re)initialize "dot" (current/object directory) path hash
+ *
  * Results:
  *	none
+ *
  * Side Effects:
  *	some directories may be opened.
  *-----------------------------------------------------------------------
  */
 void
 Dir_InitDot(void)
+{
     if (dot != NULL) {
 	LstNode ln;
 	/* Remove old entry from openDirectories, but do not destroy. */
 	ln = Lst_Member(openDirectories, dot);
 	Lst_Remove(openDirectories, ln);
+    }
     dot = Dir_AddDir(NULL, ".");
     if (dot == NULL) {
 	Error("Cannot open `.' (%s)", strerror(errno));
 	exit(1);
+    }
     /*
      * We always need to have dot around, so we increment its reference count
      * to make sure it's not destroyed.
      */
     dot->refCount += 1;
     Dir_SetPATH();		/* initialize */
+}
 /*-
  *-----------------------------------------------------------------------
  * Dir_End --
  *	cleanup things for this module
+ *
  * Results:
  *	none
+ *
  * Side Effects:
  *	none
  *-----------------------------------------------------------------------
  */
 void
 Dir_End(void)
+{
 #ifdef CLEANUP
     if (cur) {
 	cur->refCount -= 1;
 	Dir_Destroy(cur);
+    }
     dot->refCount -= 1;
     dotLast->refCount -= 1;
     Dir_Destroy(dotLast);
     Dir_Destroy(dot);
     Dir_ClearPath(dirSearchPath);
     Lst_Free(dirSearchPath);
     Dir_ClearPath(openDirectories);
     Lst_Free(openDirectories);
     Hash_DeleteTable(&mtimes);
 #endif
+}
 /*
  * We want ${.PATH} to indicate the order in which we will actually
  * search, so we rebuild it after any .PATH: target.
  * This is the simplest way to deal with the effect of .DOTLAST.
  */
 void
 Dir_SetPATH(void)
+{
     LstNode ln;			/* a list element */
     Path *p;
     Boolean hasLastDot = FALSE;	/* true if we should search dot last */
     Var_Delete(".PATH", VAR_GLOBAL);
     Lst_Open(dirSearchPath);
     if ((ln = Lst_First(dirSearchPath)) != NULL) {
 	p = Lst_Datum(ln);
 	if (p == dotLast) {
 	    hasLastDot = TRUE;
 	    Var_Append(".PATH", dotLast->name, VAR_GLOBAL);
+	}
+    }
     if (!hasLastDot) {
 	if (dot)
 	    Var_Append(".PATH", dot->name, VAR_GLOBAL);
 	if (cur)
 	    Var_Append(".PATH", cur->name, VAR_GLOBAL);
+    }
     while ((ln = Lst_Next(dirSearchPath)) != NULL) {
 	p = Lst_Datum(ln);
 	if (p == dotLast)
 	    continue;
 	if (p == dot && hasLastDot)
 	    continue;
 	Var_Append(".PATH", p->name, VAR_GLOBAL);
+    }
     if (hasLastDot) {
 	if (dot)
 	    Var_Append(".PATH", dot->name, VAR_GLOBAL);
 	if (cur)
 	    Var_Append(".PATH", cur->name, VAR_GLOBAL);
+    }
     Lst_Close(dirSearchPath);
+}
 /* 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. */
 static Boolean
 DirFindName(const void *p, const void *desiredName)
+{
     return strcmp(((const Path *)p)->name, desiredName) == 0;
+}
 /*-
  *-----------------------------------------------------------------------
  * Dir_HasWildcards  --
  *	see if the given name has any wildcard characters in it
  *	be careful not to expand unmatching brackets or braces.
  *	XXX: This code is not 100% correct. ([^]] fails etc.)
  *	I really don't think that make(1) should be expanding
  *	patterns, because then you have to set a mechanism for
  *	escaping the expansion!
+ *
  * Input:
  *	name		name to check
+ *
  * Results:
  *	returns TRUE if the word should be expanded, FALSE otherwise
+ *
  * Side Effects:
  *	none
  *-----------------------------------------------------------------------
  */
 Boolean
 Dir_HasWildcards(char *name)
+{
     char *cp;
     int wild = 0, brace = 0, bracket = 0;
     for (cp = name; *cp; cp++) {
 	switch (*cp) {
 	case '{':
 	    brace++;
 	    wild = 1;
 	    break;
 	case '}':
 	    brace--;
 	    break;
 	case '[':
 	    bracket++;
 	    wild = 1;
 	    break;
 	case ']':
 	    bracket--;
 	    break;
 	case '?':
 	case '*':
 	    wild = 1;
 	    break;
 	default:
 	    break;
+	}
+    }
     return wild && bracket == 0 && brace == 0;
+}
 /*-
  *-----------------------------------------------------------------------
  * 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.
+ *
  * Input:
  *	pattern		Pattern to look for
  *	p		Directory to search
  *	expansion	Place to store the results
+ *
  * Side Effects:
  *	File names are added to the expansions lst. The directory will be
  *	fully hashed when this is done.
  *-----------------------------------------------------------------------
  */
 static void
 DirMatchFiles(const char *pattern, Path *p, Lst expansions)
+{
     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 != 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] == '.')))
+	{
 	    Lst_Append(expansions,
 			(isDot ? bmake_strdup(entry->name) :
 			 str_concat3(p->name, "/", entry->name)));
+	}
+    }
+}
 /* Find the next closing brace in the string, taking nested braces into
  * account. */
 static const char *
 closing_brace(const char *p)
+{
     int nest = 0;
     while (*p != '\0') {
 	if (*p == '}' && nest == 0)
 	    break;
 	if (*p == '{')
 	    nest++;
 	if (*p == '}')
 	    nest--;
 	p++;
+    }
     return p;
+}
 /* Find the next closing brace or comma in the string, taking nested braces
  * into account. */
 static const char *
 separator_comma(const char *p)
+{
     int nest = 0;
     while (*p != '\0') {
 	if ((*p == '}' || *p == ',') && nest == 0)
 	    break;
 	if (*p == '{')
 	    nest++;
 	if (*p == '}')
 	    nest--;
 	p++;
+    }
     return p;
+}
 static Boolean
 contains_wildcard(const char *p)
+{
     for (; *p != '\0'; p++) {
 	switch (*p) {
 	case '*':
 	case '?':
 	case '{':
 	case '[':
 	    return TRUE;
+	}
+    }
     return FALSE;
+}
 static char *
 concat3(const char *a, size_t a_len, const char *b, size_t b_len,
 	const char *c, size_t c_len)
+{
     size_t s_len = a_len + b_len + c_len;
     char *s = bmake_malloc(s_len + 1);
     memcpy(s, a, a_len);
     memcpy(s + a_len, b, b_len);
     memcpy(s + a_len + b_len, c, c_len);
     s[s_len] = '\0';
     return s;
+}
 /*-
  *-----------------------------------------------------------------------
  * 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.
+ *
  * Input:
  *	word		Entire word to expand
  *	brace		First curly brace in it
  *	path		Search path to use
  *	expansions	Place to store the expansions
+ *
  * Results:
  *	None.
+ *
  * Side Effects:
  *	The given list is filled with the expansions...
+ *
  *-----------------------------------------------------------------------
  */
 static void
 DirExpandCurly(const char *word, const char *brace, Lst path, Lst expansions)
+{
     const char *prefix, *middle, *piece, *middle_end, *suffix;
     size_t prefix_len, suffix_len;
     /* Split the word into prefix '{' middle '}' suffix. */
     middle = brace + 1;
     middle_end = closing_brace(middle);
     if (*middle_end == '\0') {
 	Error("Unterminated {} clause \"%s\"", middle);
 	return;
+    }
     prefix = word;
     prefix_len = (size_t)(brace - prefix);
     suffix = middle_end + 1;
     suffix_len = strlen(suffix);
     /* Split the middle into pieces, separated by commas. */
     piece = middle;
     while (piece < middle_end + 1) {
 	const char *piece_end = separator_comma(piece);
 	size_t piece_len = (size_t)(piece_end - piece);
 	char *file = concat3(prefix, prefix_len, piece, piece_len,
 			     suffix, suffix_len);
 	if (contains_wildcard(file)) {
 	    Dir_Expand(file, path, expansions);
 	    free(file);
 	} else {
 	    Lst_Append(expansions, file);
+	}
 	piece = piece_end + 1;	/* skip over the comma or closing brace */
+    }
+}
 /*-
  *-----------------------------------------------------------------------
  * 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...
+ *
  * Input:
  *	word		Word to expand
  *	path		Path on which to look
  *	expansions	Place to store the result
+ *
  * Results:
  *	None.
+ *
  * Side Effects:
  *	Things are added to the expansions list.
+ *
  *-----------------------------------------------------------------------
  */
 static void
 DirExpandInt(const char *word, Lst path, Lst expansions)
+{
     LstNode ln;			/* Current node */
     Lst_Open(path);
     while ((ln = Lst_Next(path)) != NULL) {
 	Path *p = Lst_Datum(ln);
 	DirMatchFiles(word, p, expansions);
+    }
     Lst_Close(path);
+}
 /* Print a word in the list of expansions.
  * Callback for Dir_Expand when DEBUG(DIR), via Lst_ForEach. */
 static int
 DirPrintWord(void *word, void *dummy MAKE_ATTR_UNUSED)
+{
     fprintf(debug_file, "%s ", (char *)word);
     return 0;
+}
 /*-
  *-----------------------------------------------------------------------
  * Dir_Expand  --
  *	Expand the given word into a list of words by globbing it looking
  *	in the directories on the given search path.
+ *
  * Input:
  *	word		the word to expand
  *	path		the list of directories in which to find the
  *			resulting files
  *	expansions	the list on which to place the results
+ *
  * 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?
  *	Undefined behavior if the word is really in read-only memory.
  *-----------------------------------------------------------------------
  */
 void
 Dir_Expand(const char *word, Lst path, Lst expansions)
+{
     const char *cp;
     assert(path != NULL);
     assert(expansions != NULL);
     DIR_DEBUG1("Expanding \"%s\"... ", word);
     cp = strchr(word, '{');
     if (cp) {
 	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
 		 */
 		while (cp > word && *cp != '/') {
 		    cp--;
+		}
 		if (cp != word) {
 		    char sc;
 		    char *dirpath;
 		    /*
 		     * 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];
 		    ((char *)UNCONST(cp))[1] = '\0';
 		    dirpath = Dir_FindFile(word, path);
 		    ((char *)UNCONST(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 != NULL) {
 			char *dp = &dirpath[strlen(dirpath) - 1];
 			if (*dp == '/')
 			    *dp = '\0';
 			path = Lst_Init();
 			(void)Dir_AddDir(path, dirpath);
 			DirExpandInt(cp + 1, path, expansions);
 			Lst_Free(path);
+		    }
 		} 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, NULL);
 	fprintf(debug_file, "\n");
+    }
+}
 /*-
  *-----------------------------------------------------------------------
  * DirLookup  --
  *	Find if the file with the given name exists in the given 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 free'd.
+ *
  * Side Effects:
  *	None.
  *-----------------------------------------------------------------------
  */
 static char *
 DirLookup(Path *p, const char *name MAKE_ATTR_UNUSED, const char *cp,
 	  Boolean hasSlash MAKE_ATTR_UNUSED)
+{
     char *file;			/* the current filename to check */
     DIR_DEBUG1("   %s ...\n", p->name);
     if (Hash_FindEntry(&p->files, cp) == NULL)
 	return NULL;
     file = str_concat3(p->name, "/", cp);
     DIR_DEBUG1("   returning %s\n", file);
     p->hits += 1;
     hits += 1;
     return file;
+}
 /*-
  *-----------------------------------------------------------------------
  * DirLookupSubdir  --
  *	Find if the file with the given name exists in the given 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 free'd.
+ *
  * Side Effects:
  *	If the file is found, it is added in the modification times hash
  *	table.
  *-----------------------------------------------------------------------
  */
 static char *
 DirLookupSubdir(Path *p, const char *name)
+{
     struct stat stb;		/* Buffer for stat, if necessary */
     char *file;			/* the current filename to check */
     if (p != dot) {
 	file = str_concat3(p->name, "/", name);
     } else {
 	/*
 	 * Checking in dot -- DON'T put a leading ./ on the thing.
 	 */
 	file = bmake_strdup(name);
+    }
     DIR_DEBUG1("checking %s ...\n", file);
     if (cached_stat(file, &stb) == 0) {
 	nearmisses += 1;
 	return file;
+    }
     free(file);
     return NULL;
+}
 /*-
  *-----------------------------------------------------------------------
  * DirLookupAbs  --
  *	Find if the file with the given name exists in the given path.
+ *
  * Results:
  *	The path to the file, the empty string or NULL. If the file is
  *	the empty string, the search should be terminated.
  *	This path is guaranteed to be in a different part of memory
  *	than name and so may be safely free'd.
+ *
  * Side Effects:
  *	None.
  *-----------------------------------------------------------------------
  */
 static char *
 DirLookupAbs(Path *p, const char *name, const char *cp)
+{
     char *p1;			/* pointer into p->name */
     const char *p2;		/* pointer into name */
     DIR_DEBUG1("   %s ...\n", p->name);
     /*
      * If the file has a leading path component and that component
      * exactly matches the entire name of the current search
      * directory, we can attempt another cache lookup. And if we don't
      * have a hit, we can safely assume the file does not exist at all.
      */
     for (p1 = p->name, p2 = name; *p1 && *p1 == *p2; p1++, p2++) {
 	continue;
+    }
     if (*p1 != '\0' || p2 != cp - 1) {
 	return NULL;
+    }
     if (Hash_FindEntry(&p->files, cp) == NULL) {
 	DIR_DEBUG0("   must be here but isn't -- returning\n");
 	/* Return empty string: terminates search */
 	return bmake_strdup("");
+    }
     p->hits += 1;
     hits += 1;
     DIR_DEBUG1("   returning %s\n", name);
     return bmake_strdup(name);
+}
 /*-
  *-----------------------------------------------------------------------
  * DirFindDot  --
  *	Find the file given on "." or curdir
+ *
  * 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 free'd.
+ *
  * Side Effects:
  *	Hit counts change
  *-----------------------------------------------------------------------
  */
 static char *
 DirFindDot(Boolean hasSlash MAKE_ATTR_UNUSED, const char *name, const char *cp)
+{
     if (Hash_FindEntry(&dot->files, cp) != NULL) {
 	DIR_DEBUG0("   in '.'\n");
 	hits += 1;
 	dot->hits += 1;
 	return bmake_strdup(name);
+    }
     if (cur && Hash_FindEntry(&cur->files, cp) != NULL) {
 	DIR_DEBUG1("   in ${.CURDIR} = %s\n", cur->name);
 	hits += 1;
 	cur->hits += 1;
 	return str_concat3(cur->name, "/", cp);
+    }
     return NULL;
+}
 /*-
  *-----------------------------------------------------------------------
  * Dir_FindFile  --
  *	Find the file with the given name along the given search path.
+ *
  * Input:
  *	name		the file to find
  *	path		the Lst of directories to search
+ *
  * 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 free'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(const char *name, Lst path)
+{
     LstNode ln;			/* a list element */
     char *file;			/* the current filename to check */
     Path *p;			/* current path member */
     const char *cp;		/* Terminal name of file */
     Boolean hasLastDot = FALSE;	/* true we should search dot last */
     Boolean hasSlash;		/* true if 'name' contains a / */
     struct stat stb;		/* Buffer for stat, if necessary */
     const char *trailing_dot = ".";
     /*
      * Find the final component of the name and note whether it has a
      * slash in it (the name, I mean)
      */
     cp = strrchr(name, '/');
     if (cp) {
 	hasSlash = TRUE;
 	cp += 1;
     } else {
 	hasSlash = FALSE;
 	cp = name;
+    }
     DIR_DEBUG1("Searching for %s ...", name);
     if (path == NULL) {
 	DIR_DEBUG0("couldn't open path, file not found\n");
 	misses += 1;
 	return NULL;
+    }
     Lst_Open(path);
     if ((ln = Lst_First(path)) != NULL) {
 	p = Lst_Datum(ln);
 	if (p == dotLast) {
 	    hasLastDot = TRUE;
 	    DIR_DEBUG0("[dot last]...");
+	}
+    }
     DIR_DEBUG0("\n");
     /*
      * If there's no leading directory components or if the leading
      * directory component is exactly `./', consult the cached contents
      * of each of the directories on the search path.
      */
     if (!hasSlash || (cp - name == 2 && *name == '.')) {
 	/*
 	 * We look through all the directories on the path seeking one which
 	 * contains the final component of the given name.  If such a beast
 	 * is found, we concatenate the directory name and the final
 	 * component and return the resulting string. If we don't find any
 	 * such thing, we go on to phase two...
+	 *
 	 * No matter what, we always look for the file in the current
 	 * directory before anywhere else (unless we found the magic
 	 * DOTLAST path, in which case we search it last) and we *do not*
 	 * add the ./ to it if it exists.
 	 * This is so there are no conflicts between what the user
 	 * specifies (fish.c) and what pmake finds (./fish.c).
 	 */
 	if (!hasLastDot && (file = DirFindDot(hasSlash, name, cp)) != NULL) {
 	    Lst_Close(path);
 	    return file;
+	}
 	while ((ln = Lst_Next(path)) != NULL) {
 	    p = Lst_Datum(ln);
 	    if (p == dotLast)
 		continue;
 	    if ((file = DirLookup(p, name, cp, hasSlash)) != NULL) {
 		Lst_Close(path);
 		return file;
+	    }
+	}
 	if (hasLastDot && (file = DirFindDot(hasSlash, name, cp)) != NULL) {
 	    Lst_Close(path);
 	    return file;
+	}
+    }
     Lst_Close(path);
     /*
      * We didn't find the file on any directory in the search path.
      * If the name doesn't contain a slash, that means it doesn't exist.
      * If it *does* contain a slash, however, there is still hope: it
      * could be in a subdirectory of one of the members of the search
      * path. (eg. /usr/include and sys/types.h. The above search would
      * fail to turn up types.h in /usr/include, but it *is* in
      * /usr/include/sys/types.h).
      * [ This no longer applies: If we find such a beast, we assume there
      * will be more (what else can we assume?) and add all but the last
      * component of the resulting name onto the search path (at the
      * end).]
      * This phase is only performed if the file is *not* absolute.
      */
     if (!hasSlash) {
 	DIR_DEBUG0("   failed.\n");
 	misses += 1;
 	return NULL;
+    }
     if (*cp == '\0') {
 	/* we were given a trailing "/" */
 	cp = trailing_dot;
+    }
     if (name[0] != '/') {
 	Boolean checkedDot = FALSE;
 	DIR_DEBUG0("   Trying subdirectories...\n");
 	if (!hasLastDot) {
 	    if (dot) {
 		checkedDot = TRUE;
 		if ((file = DirLookupSubdir(dot, name)) != NULL)
 		    return file;
+	    }
 	    if (cur && (file = DirLookupSubdir(cur, name)) != NULL)
 		return file;
+	}
 	Lst_Open(path);
 	while ((ln = Lst_Next(path)) != NULL) {
 	    p = Lst_Datum(ln);
 	    if (p == dotLast)
 		continue;
 	    if (p == dot) {
 		if (checkedDot)
 		    continue;
 		checkedDot = TRUE;
+	    }
 	    if ((file = DirLookupSubdir(p, name)) != NULL) {
 		Lst_Close(path);
 		return file;
+	    }
+	}
 	Lst_Close(path);
 	if (hasLastDot) {
 	    if (dot && !checkedDot) {
 		checkedDot = TRUE;
 		if ((file = DirLookupSubdir(dot, name)) != NULL)
 		    return file;
+	    }
 	    if (cur && (file = DirLookupSubdir(cur, name)) != NULL)
 		return file;
+	}
 	if (checkedDot) {
 	    /*
 	     * Already checked by the given name, since . was in the path,
 	     * so no point in proceeding...
 	     */
 	    DIR_DEBUG0("   Checked . already, returning NULL\n");
 	    return NULL;
+	}
     } else { /* name[0] == '/' */
 	/*
 	 * For absolute names, compare directory path prefix against the
 	 * the directory path of each member on the search path for an exact
 	 * match. If we have an exact match on any member of the search path,
 	 * use the cached contents of that member to lookup the final file
 	 * component. If that lookup fails we can safely assume that the
 	 * file does not exist at all.  This is signified by DirLookupAbs()
 	 * returning an empty string.
 	 */
 	DIR_DEBUG0("   Trying exact path matches...\n");
 	if (!hasLastDot && cur &&
 	    ((file = DirLookupAbs(cur, name, cp)) != NULL)) {
 	    if (file[0] == '\0') {
 		free(file);
 		return NULL;
+	    }
 	    return file;
+	}
 	Lst_Open(path);
 	while ((ln = Lst_Next(path)) != NULL) {
 	    p = Lst_Datum(ln);
 	    if (p == dotLast)
 		continue;
 	    if ((file = DirLookupAbs(p, name, cp)) != NULL) {
 		Lst_Close(path);
 		if (file[0] == '\0') {
 		    free(file);
 		    return NULL;
+		}
 		return file;
+	    }
+	}
 	Lst_Close(path);
 	if (hasLastDot && cur &&
 	    ((file = DirLookupAbs(cur, name, cp)) != NULL)) {
 	    if (file[0] == '\0') {
 		free(file);
 		return NULL;
+	    }
 	    return file;
+	}
+    }
     /*
      * Didn't find it that way, either. Sigh. Phase 3. Add its directory
      * onto the search path in any case, just in case, then look for the
      * thing in the hash table. If we find it, grand. We return a new
      * copy of the name. Otherwise we sadly return a NULL pointer. Sigh.
      * Note that if the directory holding the file doesn't exist, this will
      * do an extra search of the final directory on the path. Unless something
      * weird happens, this search won't succeed and life will be groovy.
+     *
      * Sigh. We cannot add the directory onto the search path because
      * of this amusing case:
      * $(INSTALLDIR)/$(FILE): $(FILE)
+     *
      * $(FILE) exists in $(INSTALLDIR) but not in the current one.
      * When searching for $(FILE), we will find it in $(INSTALLDIR)
      * b/c we added it here. This is not good...
      */
 #ifdef notdef
     if (cp == traling_dot) {
 	cp = strrchr(name, '/');
 	cp += 1;
+    }
     cp[-1] = '\0';
     (void)Dir_AddDir(path, name);
     cp[-1] = '/';
     bigmisses += 1;
     ln = Lst_Last(path);
     if (ln == NULL) {
 	return NULL;
     } else {
 	p = Lst_Datum(ln);
+    }
     if (Hash_FindEntry(&p->files, cp) != NULL) {
 	return bmake_strdup(name);
     } else {
 	return NULL;
+    }
 #else /* !notdef */
     DIR_DEBUG1("   Looking for \"%s\" ...\n", name);
     bigmisses += 1;
     if (cached_stat(name, &stb) == 0) {
 	return bmake_strdup(name);
+    }
     DIR_DEBUG0("   failed. Returning NULL\n");
     return NULL;
 #endif /* notdef */
+}
 /*-
  *-----------------------------------------------------------------------
  * Dir_FindHereOrAbove  --
  *	search for a path starting at a given directory and then working
  *	our way up towards the root.
+ *
  * Input:
  *	here		starting directory
  *	search_path	the path we are looking for
  *	result		the result of a successful search is placed here
  *	rlen		the length of the result buffer
  *			(typically MAXPATHLEN + 1)
+ *
  * Results:
  *	0 on failure, 1 on success [in which case the found path is put
  *	in the result buffer].
+ *
  * Side Effects:
  *-----------------------------------------------------------------------
  */
 int
 Dir_FindHereOrAbove(char *here, char *search_path, char *result, int rlen)
+{
     struct stat st;
     char dirbase[MAXPATHLEN + 1], *db_end;
     char try[MAXPATHLEN + 1], *try_end;
     /* copy out our starting point */
     snprintf(dirbase, sizeof(dirbase), "%s", here);
     db_end = dirbase + strlen(dirbase);
     /* loop until we determine a result */
     while (1) {
 	/* try and stat(2) it ... */
 	snprintf(try, sizeof(try), "%s/%s", dirbase, search_path);
 	if (cached_stat(try, &st) != -1) {
 	    /*
 	     * success!  if we found a file, chop off
 	     * the filename so we return a directory.
 	     */
 	    if ((st.st_mode & S_IFMT) != S_IFDIR) {
 		try_end = try + strlen(try);
 		while (try_end > try && *try_end != '/')
 		    try_end--;
 		if (try_end > try)
 		    *try_end = 0;	/* chop! */
+	    }
 	    /*
 	     * done!
 	     */
 	    snprintf(result, rlen, "%s", try);
 	    return 1;
+	}
 	/*
 	 * nope, we didn't find it.  if we used up dirbase we've
 	 * reached the root and failed.
 	 */
 	if (db_end == dirbase)
 	    break;		/* failed! */
 	/*
 	 * truncate dirbase from the end to move up a dir
 	 */
 	while (db_end > dirbase && *db_end != '/')
 	    db_end--;
 	*db_end = 0;		/* chop! */
     } /* while (1) */
     /*
      * we failed...
      */
     return 0;
+}
 /*-
  *-----------------------------------------------------------------------
  * Dir_MTime  --
  *	Find the modification time of the file described by gn along the
  *	search path dirSearchPath.
+ *
  * Input:
  *	gn		the file whose modification time is desired
+ *
  * 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(GNode *gn, Boolean recheck)
+{
     char *fullName;		/* the full pathname of name */
     struct stat stb;		/* buffer for finding the mod time */
     if (gn->type & OP_ARCHV) {
 	return Arch_MTime(gn);
     } else if (gn->type & OP_PHONY) {
 	gn->mtime = 0;
 	return 0;
     } else if (gn->path == NULL) {
 	if (gn->type & OP_NOPATH)
 	    fullName = NULL;
 	else {
 	    fullName = Dir_FindFile(gn->name, Suff_FindPath(gn));
 	    if (fullName == NULL && gn->flags & FROM_DEPEND &&
 		!Lst_IsEmpty(gn->iParents)) {
 		char *cp;
 		cp = strrchr(gn->name, '/');
 		if (cp) {
 		    /*
 		     * This is an implied source, and it may have moved,
 		     * see if we can find it via the current .PATH
 		     */
 		    cp++;
 		    fullName = Dir_FindFile(cp, Suff_FindPath(gn));
 		    if (fullName) {
 			/*
 			 * Put the found file in gn->path
 			 * so that we give that to the compiler.
 			 */
 			gn->path = bmake_strdup(fullName);
 			if (!Job_RunTarget(".STALE", gn->fname))
 			    fprintf(stdout,
 				    "%s: %s, %d: ignoring stale %s for %s, "
 				    "found %s\n", progname, gn->fname,
 				    gn->lineno,
 				    makeDependfile, gn->name, fullName);
+		    }
+		}
+	    }
 	    DIR_DEBUG2("Found '%s' as '%s'\n",
 		       gn->name, fullName ? fullName : "(not found)");
+	}
     } else {
 	fullName = gn->path;
+    }
     if (fullName == NULL) {
 	fullName = bmake_strdup(gn->name);
+    }
     if (cached_stats(&mtimes, fullName, &stb, recheck ? CST_UPDATE : 0) < 0) {
 	if (gn->type & OP_MEMBER) {
 	    if (fullName != gn->path)
 		free(fullName);
 	    return Arch_MemMTime(gn);
 	} else {
 	    stb.st_mtime = 0;
+	}
+    }
     if (fullName && gn->path == NULL) {
 	gn->path = fullName;
+    }
     gn->mtime = stb.st_mtime;
     return gn->mtime;
+}
 /*-
  *-----------------------------------------------------------------------
  * 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...
+ *
  * Input:
  *	path		the path to which the directory should be
  *			added
  *			XXX: Why would this ever be NULL, and what does
  *			that mean?
  *	name		the name of the directory to add
+ *
  * Results:
  *	none
+ *
  * Side Effects:
  *	A structure is added to the list and the directory is
  *	read and hashed.
  *-----------------------------------------------------------------------
  */
 Path *
 Dir_AddDir(Lst path, const char *name)
+{
     LstNode ln = NULL;		/* node in case Path structure is found */
     Path *p = NULL;		/* pointer to new Path structure */
     DIR *d;			/* for reading directory */
     struct dirent *dp;		/* entry in directory */
     if (path != NULL && strcmp(name, ".DOTLAST") == 0) {
 	ln = Lst_Find(path, DirFindName, name);
 	if (ln != NULL)
 	    return Lst_Datum(ln);
 	dotLast->refCount++;
 	Lst_Prepend(path, dotLast);
+    }
     if (path != NULL)
 	ln = Lst_Find(openDirectories, DirFindName, name);
     if (ln != NULL) {
 	p = Lst_Datum(ln);
 	if (Lst_Member(path, p) == NULL) {
 	    p->refCount += 1;
 	    Lst_Append(path, p);
+	}
 	return p;
+    }
     DIR_DEBUG1("Caching %s ...", name);
     if ((d = opendir(name)) != NULL) {
 	p = bmake_malloc(sizeof(Path));
 	p->name = bmake_strdup(name);
 	p->hits = 0;
 	p->refCount = 1;
 	Hash_InitTable(&p->files, -1);
 	while ((dp = readdir(d)) != 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;
+	    }
 #endif /* sun && d_ino */
 	    (void)Hash_CreateEntry(&p->files, dp->d_name, NULL);
+	}
 	(void)closedir(d);
 	Lst_Append(openDirectories, p);
 	if (path != NULL)
 	    Lst_Append(path, p);
+    }
     DIR_DEBUG0("done\n");
     return p;
+}
 /*-
  *-----------------------------------------------------------------------
  * Dir_CopyDir --
  *	Callback function for duplicating a search path via Lst_Copy.
  *	Ups the reference count for the directory.
+ *
  * Results:
  *	Returns the Path it was given.
  *-----------------------------------------------------------------------
  */
 void *
 Dir_CopyDir(void *p)
+{
     ((Path *)p)->refCount += 1;
     return p;
+}
 /*-
  *-----------------------------------------------------------------------
  * 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.
+ *
  * Input:
  *	flag		flag which should precede each directory
  *	path		list of directories
+ *
  * 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(const char *flag, Lst path)
+{
     Buffer buf;
     LstNode ln;			/* the node of the current directory */
     Buf_Init(&buf, 0);
     if (path != NULL) {
 	Lst_Open(path);
 	while ((ln = Lst_Next(path)) != NULL) {
 	    Path *p = Lst_Datum(ln);
 	    Buf_AddStr(&buf, " ");
 	    Buf_AddStr(&buf, flag);
 	    Buf_AddStr(&buf, p->name);
+	}
 	Lst_Close(path);
+    }
     return Buf_Destroy(&buf, FALSE);
+}
 /*-
  *-----------------------------------------------------------------------
  * Dir_Destroy --
  *	Nuke a directory descriptor, if possible. Callback procedure
  *	for the suffixes module when destroying a search path.
+ *
  * Input:
  *	pp		The directory descriptor to nuke
+ *
  * Results:
  *	None.
+ *
  * Side Effects:
  *	If no other path references this directory (refCount == 0),
  *	the Path and all its data are freed.
+ *
  *-----------------------------------------------------------------------
  */
 void
 Dir_Destroy(void *pp)
+{
     Path *p = (Path *)pp;
     p->refCount -= 1;
     if (p->refCount == 0) {
 	LstNode ln;
 	ln = Lst_Member(openDirectories, p);
 	Lst_Remove(openDirectories, ln);
 	Hash_DeleteTable(&p->files);
 	free(p->name);
 	free(p);
+    }
+}
 /*-
  *-----------------------------------------------------------------------
  * Dir_ClearPath --
  *	Clear out all elements of the given search path. This is different
  *	from destroying the list, notice.
+ *
  * Input:
  *	path		Path to clear
+ *
  * Results:
  *	None.
+ *
  * Side Effects:
  *	The path is set to the empty list.
+ *
  *-----------------------------------------------------------------------
  */
 void
 Dir_ClearPath(Lst path)
+{
     while (!Lst_IsEmpty(path)) {
 	Path *p = Lst_Dequeue(path);
 	Dir_Destroy(p);
+    }
+}
 /*-
  *-----------------------------------------------------------------------
  * Dir_Concat --
  *	Concatenate two paths, adding the second to the end of the first.
  *	Makes sure to avoid duplicates.
+ *
  * Input:
  *	path1		Dest
  *	path2		Source
+ *
  * Results:
  *	None
+ *
  * Side Effects:
  *	Reference counts for added dirs are upped.
+ *
  *-----------------------------------------------------------------------
  */
 void
 Dir_Concat(Lst path1, Lst path2)
+{
     LstNode ln;
     Path *p;
-    for (ln = Lst_First(path2); ln != NULL; ln = Lst_Succ(ln)) {
+    for (ln = Lst_First(path2); ln != NULL; ln = LstNode_Next(ln)) {
 	p = Lst_Datum(ln);
 	if (Lst_Member(path1, p) == NULL) {
 	    p->refCount += 1;
 	    Lst_Append(path1, p);
+	}
+    }
+}
 static int
 percentage(int num, int den)
+{
     return den != 0 ? num * 100 / den : 0;
+}
 /********** DEBUG INFO **********/
 void
 Dir_PrintDirectories(void)
+{
     LstNode ln;
     fprintf(debug_file, "#*** Directory Cache:\n");
     fprintf(debug_file,
 	    "# Stats: %d hits %d misses %d near misses %d losers (%d%%)\n",
 	    hits, misses, nearmisses, bigmisses,
 	    percentage(hits, hits + bigmisses + nearmisses));
     fprintf(debug_file, "# %-20s referenced\thits\n", "directory");
     Lst_Open(openDirectories);
     while ((ln = Lst_Next(openDirectories)) != NULL) {
 	Path *p = Lst_Datum(ln);
 	fprintf(debug_file, "# %-20s %10d\t%4d\n", p->name, p->refCount,
 		p->hits);
+    }
     Lst_Close(openDirectories);
+}
 static int
 DirPrintDir(void *p, void *dummy MAKE_ATTR_UNUSED)
+{
     fprintf(debug_file, "%s ", ((Path *)p)->name);
     return 0;
+}
 void
 Dir_PrintPath(Lst path)
+{
     Lst_ForEach(path, DirPrintDir, NULL);
+}

 @@ -1,1711 +1,1711 @@
-/*	$NetBSD: job.c,v 1.222 2020/08/29 10:35:03 rillig Exp $	*/
+/*	$NetBSD: job.c,v 1.223 2020/08/29 10:41:12 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 /*
  * Copyright (c) 1988, 1989 by Adam de Boor
  * Copyright (c) 1989 by Berkeley Softworks
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 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.
  * 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
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #ifndef MAKE_NATIVE
-static char rcsid[] = "$NetBSD: job.c,v 1.222 2020/08/29 10:35:03 rillig Exp $";
+static char rcsid[] = "$NetBSD: job.c,v 1.223 2020/08/29 10:41:12 rillig Exp $";
 #else
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)job.c	8.2 (Berkeley) 3/19/94";
 #else
-__RCSID("$NetBSD: job.c,v 1.222 2020/08/29 10:35:03 rillig Exp $");
+__RCSID("$NetBSD: job.c,v 1.223 2020/08/29 10:41:12 rillig Exp $");
 #endif
 #endif /* not lint */
 #endif
 /*-
  * job.c --
  *	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.
+ *
  *	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 initialize 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_End  	    	Cleanup any memory used.
+ *
  *	Job_ParseShell	    	Given the line following a .SHELL target, parse
  *	    	  	    	the line as a shell specification. Returns
  *	    	  	    	FAILURE if the spec was incorrect.
+ *
  *	Job_Finish	    	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.
  */
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/file.h>
 #include <sys/time.h>
 #include <sys/wait.h>
 #include <errno.h>
 #ifndef USE_SELECT
 #include <poll.h>
 #endif
 #include <signal.h>
 #include <utime.h>
 #include "make.h"
 #include "dir.h"
 #include "job.h"
 #include "pathnames.h"
 #include "trace.h"
 # define STATIC static
 /*
  * 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 */
 #define JOB_TOKENS	"+EI+"	    /* Token to requeue for each abort state */
 /*
  * this tracks the number of tokens currently "out" to build jobs.
  */
 int jobTokensRunning = 0;
 /*
  * XXX: Avoid SunOS bug... FILENO() is fp->_file, and file
  * is a char! So when we go above 127 we turn negative!
  */
 #define FILENO(a) ((unsigned) fileno(a))
 /*
  * post-make command processing. The node postCommands is really just the
  * .END target but we keep it around to avoid having to search for it
  * all the time.
  */
 static GNode   	  *postCommands = NULL;
 				    /* 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 */
 /*
  * Descriptions for various shells.
+ *
  * The build environment may set DEFSHELL_INDEX to one of
  * DEFSHELL_INDEX_SH, DEFSHELL_INDEX_KSH, or DEFSHELL_INDEX_CSH, to
  * select one of the prefedined shells as the default shell.
+ *
  * Alternatively, the build environment may set DEFSHELL_CUSTOM to the
  * name or the full path of a sh-compatible shell, which will be used as
  * the default shell.
+ *
  * ".SHELL" lines in Makefiles can choose the default shell from the
  # set defined here, or add additional shells.
  */
 #ifdef DEFSHELL_CUSTOM
 #define DEFSHELL_INDEX_CUSTOM 0
 #define DEFSHELL_INDEX_SH     1
 #define DEFSHELL_INDEX_KSH    2
 #define DEFSHELL_INDEX_CSH    3
 #else /* !DEFSHELL_CUSTOM */
 #define DEFSHELL_INDEX_SH     0
 #define DEFSHELL_INDEX_KSH    1
 #define DEFSHELL_INDEX_CSH    2
 #endif /* !DEFSHELL_CUSTOM */
 #ifndef DEFSHELL_INDEX
 #define DEFSHELL_INDEX 0	/* DEFSHELL_INDEX_CUSTOM or DEFSHELL_INDEX_SH */
 #endif /* !DEFSHELL_INDEX */
 static Shell    shells[] = {
 #ifdef DEFSHELL_CUSTOM
     /*
      * An sh-compatible shell with a non-standard name.
+     *
      * Keep this in sync with the "sh" description below, but avoid
      * non-portable features that might not be supplied by all
      * sh-compatible shells.
      */
+{
     DEFSHELL_CUSTOM,
     FALSE, "", "", "", 0,
     FALSE, "echo \"%s\"\n", "%s\n", "{ %s \n} || exit $?\n", "'\n'", '#',
     "",
     "",
 },
 #endif /* DEFSHELL_CUSTOM */
     /*
      * SH description. Echo control is also possible and, under
      * sun UNIX anyway, one can even control error checking.
      */
+{
     "sh",
     FALSE, "", "", "", 0,
     FALSE, "echo \"%s\"\n", "%s\n", "{ %s \n} || exit $?\n", "'\n'", '#',
 #if defined(MAKE_NATIVE) && defined(__NetBSD__)
     "q",
 #else
     "",
 #endif
     "",
 },
     /*
      * KSH description.
      */
+{
     "ksh",
     TRUE, "set +v", "set -v", "set +v", 6,
     FALSE, "echo \"%s\"\n", "%s\n", "{ %s \n} || exit $?\n", "'\n'", '#',
     "v",
     "",
 },
     /*
      * CSH description. The csh can do echo control by playing
      * with the setting of the 'echo' shell variable. Sadly,
      * however, it is unable to do error control nicely.
      */
+{
     "csh",
     TRUE, "unset verbose", "set verbose", "unset verbose", 10,
     FALSE, "echo \"%s\"\n", "csh -c \"%s || exit 0\"\n", "", "'\\\n'", '#',
     "v", "e",
 },
     /*
      * UNKNOWN.
      */
+{
     NULL,
     FALSE, NULL, NULL, NULL, 0,
     FALSE, NULL, NULL, NULL, NULL, 0,
     NULL, NULL,
+}
 };
 static Shell *commandShell = &shells[DEFSHELL_INDEX]; /* this is the shell to
 						   * which we pass all
 						   * commands in the Makefile.
 						   * It is set by the
 						   * Job_ParseShell function */
 const char *shellPath = NULL,		  	  /* full pathname of
 						   * executable image */
 	   *shellName = NULL;		      	  /* last component of shell */
 char *shellErrFlag = NULL;
 static char *shellArgv = NULL;	/* Custom shell args */
 STATIC Job	*job_table;	/* The structures that describe them */
 STATIC Job	*job_table_end;	/* job_table + maxJobs */
 static int	wantToken;	/* we want a token */
 static int lurking_children = 0;
 static int make_suspended = 0;	/* non-zero if we've seen a SIGTSTP (etc) */
 /*
  * Set of descriptors of pipes connected to
  * the output channels of children
  */
 static struct pollfd *fds = NULL;
 static Job **jobfds = NULL;
 static int nfds = 0;
 static void watchfd(Job *);
 static void clearfd(Job *);
 static int readyfd(Job *);
 STATIC GNode   	*lastNode;	/* The node for which output was most recently
 				 * produced. */
 static char *targPrefix = NULL; /* What we print at the start of TARG_FMT */
 static Job tokenWaitJob;	/* token wait pseudo-job */
 static Job childExitJob;	/* child exit pseudo-job */
 #define	CHILD_EXIT	"."
 #define	DO_JOB_RESUME	"R"
 static const int npseudojobs = 2; /* number of pseudo-jobs */
 #define TARG_FMT  "%s %s ---\n" /* Default format */
 #define MESSAGE(fp, gn) \
 	if (maxJobs != 1 && targPrefix && *targPrefix) \
 	    (void)fprintf(fp, TARG_FMT, targPrefix, gn->name)
 static sigset_t caught_signals;	/* Set of signals we handle */
 static void JobChildSig(int);
 static void JobContinueSig(int);
 static Job *JobFindPid(int, int, Boolean);
 static int JobPrintCommand(void *, void *);
 static int JobSaveCommand(void *, void *);
 static void JobClose(Job *);
 static void JobExec(Job *, char **);
 static void JobMakeArgv(Job *, char **);
 static int JobStart(GNode *, int);
 static char *JobOutput(Job *, char *, char *, int);
 static void JobDoOutput(Job *, Boolean);
 static Shell *JobMatchShell(const char *);
 static void JobInterrupt(int, int) MAKE_ATTR_DEAD;
 static void JobRestartJobs(void);
 static void JobTokenAdd(void);
 static void JobSigLock(sigset_t *);
 static void JobSigUnlock(sigset_t *);
 static void JobSigReset(void);
 const char *malloc_options MAKE_ATTR_UNUSED = "A"; /* see jemalloc(3) */
 static unsigned
 nfds_per_job(void)
+{
 #if defined(USE_FILEMON) && !defined(USE_FILEMON_DEV)
     if (useMeta)
 	return 2;
 #endif
     return 1;
+}
 static void
 job_table_dump(const char *where)
+{
     Job *job;
     fprintf(debug_file, "job table @ %s\n", where);
     for (job = job_table; job < job_table_end; job++) {
 	fprintf(debug_file, "job %d, status %d, flags %d, pid %d\n",
 	    (int)(job - job_table), job->job_state, job->flags, job->pid);
+    }
+}
 /*
  * Delete the target of a failed, interrupted, or otherwise
  * unsuccessful job unless inhibited by .PRECIOUS.
  */
 static void
 JobDeleteTarget(GNode *gn)
+{
 	if ((gn->type & (OP_JOIN|OP_PHONY)) == 0 && !Targ_Precious(gn)) {
 	    char *file = (gn->path == NULL ? gn->name : gn->path);
 	    if (!noExecute && eunlink(file) != -1) {
 		Error("*** %s removed", file);
+	    }
+	}
+}
 /*
  * JobSigLock/JobSigUnlock
+ *
  * Signal lock routines to get exclusive access. Currently used to
  * protect `jobs' and `stoppedJobs' list manipulations.
  */
 static void JobSigLock(sigset_t *omaskp)
+{
 	if (sigprocmask(SIG_BLOCK, &caught_signals, omaskp) != 0) {
 		Punt("JobSigLock: sigprocmask: %s", strerror(errno));
 		sigemptyset(omaskp);
+	}
+}
 static void JobSigUnlock(sigset_t *omaskp)
+{
 	(void)sigprocmask(SIG_SETMASK, omaskp, NULL);
+}
 static void
 JobCreatePipe(Job *job, int minfd)
+{
     int i, fd, flags;
     if (pipe(job->jobPipe) == -1)
 	Punt("Cannot create pipe: %s", strerror(errno));
     for (i = 0; i < 2; i++) {
        /* Avoid using low numbered fds */
        fd = fcntl(job->jobPipe[i], F_DUPFD, minfd);
        if (fd != -1) {
 	   close(job->jobPipe[i]);
 	   job->jobPipe[i] = fd;
+       }
+    }
     /* Set close-on-exec flag for both */
     if (fcntl(job->jobPipe[0], F_SETFD, FD_CLOEXEC) == -1)
 	Punt("Cannot set close-on-exec: %s", strerror(errno));
     if (fcntl(job->jobPipe[1], F_SETFD, FD_CLOEXEC) == -1)
 	Punt("Cannot set close-on-exec: %s", strerror(errno));
     /*
      * We mark the input side of the pipe non-blocking; we poll(2) the
      * pipe when we're waiting for a job token, but we might lose the
      * race for the token when a new one becomes available, so the read
      * from the pipe should not block.
      */
     flags = fcntl(job->jobPipe[0], F_GETFL, 0);
     if (flags == -1)
 	Punt("Cannot get flags: %s", strerror(errno));
     flags |= O_NONBLOCK;
     if (fcntl(job->jobPipe[0], F_SETFL, flags) == -1)
 	Punt("Cannot set flags: %s", strerror(errno));
+}
 /*-
  *-----------------------------------------------------------------------
  * JobCondPassSig --
  *	Pass a signal to a job
+ *
  * Input:
  *	signop		Signal to send it
+ *
  * Side Effects:
  *	None, except the job may bite it.
+ *
  *-----------------------------------------------------------------------
  */
 static void
 JobCondPassSig(int signo)
+{
     Job *job;
     if (DEBUG(JOB)) {
 	(void)fprintf(debug_file, "JobCondPassSig(%d) called.\n", signo);
+    }
     for (job = job_table; job < job_table_end; job++) {
 	if (job->job_state != JOB_ST_RUNNING)
 	    continue;
 	if (DEBUG(JOB)) {
 	    (void)fprintf(debug_file,
 			   "JobCondPassSig passing signal %d to child %d.\n",
 			   signo, job->pid);
+	}
 	KILLPG(job->pid, signo);
+    }
+}
 /*-
  *-----------------------------------------------------------------------
  * JobChldSig --
  *	SIGCHLD handler.
+ *
  * Input:
  *	signo		The signal number we've received
+ *
  * Results:
  *	None.
+ *
  * Side Effects:
  *	Sends a token on the child exit pipe to wake us up from
  *	select()/poll().
+ *
  *-----------------------------------------------------------------------
  */
 static void
 JobChildSig(int signo MAKE_ATTR_UNUSED)
+{
     while (write(childExitJob.outPipe, CHILD_EXIT, 1) == -1 && errno == EAGAIN)
 	continue;
+}
 /*-
  *-----------------------------------------------------------------------
  * JobContinueSig --
  *	Resume all stopped jobs.
+ *
  * Input:
  *	signo		The signal number we've received
+ *
  * Results:
  *	None.
+ *
  * Side Effects:
  *	Jobs start running again.
+ *
  *-----------------------------------------------------------------------
  */
 static void
 JobContinueSig(int signo MAKE_ATTR_UNUSED)
+{
     /*
      * Defer sending to SIGCONT to our stopped children until we return
      * from the signal handler.
      */
     while (write(childExitJob.outPipe, DO_JOB_RESUME, 1) == -1 &&
 	errno == EAGAIN)
 	continue;
+}
 /*-
  *-----------------------------------------------------------------------
  * JobPassSig --
  *	Pass a signal on to all jobs, then resend to ourselves.
+ *
  * Input:
  *	signo		The signal number we've received
+ *
  * Results:
  *	None.
+ *
  * Side Effects:
  *	We die by the same signal.
+ *
  *-----------------------------------------------------------------------
  */
 MAKE_ATTR_DEAD static void
 JobPassSig_int(int signo)
+{
     /* Run .INTERRUPT target then exit */
     JobInterrupt(TRUE, signo);
+}
 MAKE_ATTR_DEAD static void
 JobPassSig_term(int signo)
+{
     /* Dont run .INTERRUPT target then exit */
     JobInterrupt(FALSE, signo);
+}
 static void
 JobPassSig_suspend(int signo)
+{
     sigset_t nmask, omask;
     struct sigaction act;
     /* Suppress job started/continued messages */
     make_suspended = 1;
     /* Pass the signal onto every job */
     JobCondPassSig(signo);
     /*
      * Send ourselves the signal now we've given the message to everyone else.
      * Note we block everything else possible while we're getting the signal.
      * This ensures that all our jobs get continued when we wake up before
      * we take any other signal.
      */
     sigfillset(&nmask);
     sigdelset(&nmask, signo);
     (void)sigprocmask(SIG_SETMASK, &nmask, &omask);
     act.sa_handler = SIG_DFL;
     sigemptyset(&act.sa_mask);
     act.sa_flags = 0;
     (void)sigaction(signo, &act, NULL);
     if (DEBUG(JOB)) {
 	(void)fprintf(debug_file,
 		       "JobPassSig passing signal %d to self.\n", signo);
+    }
     (void)kill(getpid(), signo);
     /*
      * We've been continued.
+     *
      * A whole host of signals continue to happen!
      * SIGCHLD for any processes that actually suspended themselves.
      * SIGCHLD for any processes that exited while we were alseep.
      * The SIGCONT that actually caused us to wakeup.
+     *
      * Since we defer passing the SIGCONT on to our children until
      * the main processing loop, we can be sure that all the SIGCHLD
      * events will have happened by then - and that the waitpid() will
      * collect the child 'suspended' events.
      * For correct sequencing we just need to ensure we process the
      * waitpid() before passign on the SIGCONT.
+     *
      * In any case nothing else is needed here.
      */
     /* Restore handler and signal mask */
     act.sa_handler = JobPassSig_suspend;
     (void)sigaction(signo, &act, NULL);
     (void)sigprocmask(SIG_SETMASK, &omask, NULL);
+}
 /*-
  *-----------------------------------------------------------------------
  * JobFindPid  --
  *	Compare the pid of the job with the given pid and return 0 if they
  *	are equal. This function is called from Job_CatchChildren
  *	to find the job descriptor of the finished job.
+ *
  * Input:
  *	job		job to examine
  *	pid		process id desired
+ *
  * Results:
  *	Job with matching pid
+ *
  * Side Effects:
  *	None
  *-----------------------------------------------------------------------
  */
 static Job *
 JobFindPid(int pid, int status, Boolean isJobs)
+{
     Job *job;
     for (job = job_table; job < job_table_end; job++) {
 	if ((job->job_state == status) && job->pid == pid)
 	    return job;
+    }
     if (DEBUG(JOB) && isJobs)
 	job_table_dump("no pid");
     return NULL;
+}
 /*-
  *-----------------------------------------------------------------------
  * 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.
+ *
  * Input:
  *	cmdp		command string to print
  *	jobp		job for which to print it
+ *
  * Results:
  *	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.
  *-----------------------------------------------------------------------
  */
 static int
 JobPrintCommand(void *cmdp, void *jobp)
+{
     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 */
     const char    *cmdTemplate;	    /* Template to use when printing the
 				     * command */
     char    	  *cmdStart;	    /* Start of expanded command */
     char	  *escCmd = NULL;    /* Command with quotes/backticks escaped */
     char     	  *cmd = (char *)cmdp;
     Job           *job = (Job *)jobp;
     noSpecials = NoExecute(job->node);
     if (strcmp(cmd, "...") == 0) {
 	job->node->type |= OP_SAVE_CMDS;
 	if ((job->flags & JOB_IGNDOTS) == 0) {
 	    LstNode dotsNode = Lst_Member(job->node->commands, cmd);
-	    job->tailCmds = dotsNode != NULL ? Lst_Succ(dotsNode) : NULL;
+	    job->tailCmds = dotsNode != NULL ? LstNode_Next(dotsNode) : NULL;
 	    return 1;
+	}
 	return 0;
+    }
 #define DBPRINTF(fmt, arg) if (DEBUG(JOB)) {	\
 	(void)fprintf(debug_file, fmt, arg); 	\
     }						\
    (void)fprintf(job->cmdFILE, fmt, arg);	\
    (void)fflush(job->cmdFILE);
     numCommands += 1;
     cmdStart = cmd = Var_Subst(cmd, job->node, VARE_WANTRES);
     cmdTemplate = "%s\n";
     /*
      * Check for leading @' and -'s to control echoing and error checking.
      */
     while (*cmd == '@' || *cmd == '-' || (*cmd == '+')) {
 	switch (*cmd) {
 	case '@':
 	    shutUp = DEBUG(LOUD) ? FALSE : TRUE;
 	    break;
 	case '-':
 	    errOff = TRUE;
 	    break;
 	case '+':
 	    if (noSpecials) {
 		/*
 		 * We're not actually executing anything...
 		 * but this one needs to be - use compat mode just for it.
 		 */
 		CompatRunCommand(cmdp, job->node);
 		free(cmdStart);
 		return 0;
+	    }
 	    break;
+	}
 	cmd++;
+    }
     while (isspace((unsigned char) *cmd))
 	cmd++;
     /*
      * If the shell doesn't have error control the alternate echo'ing will
      * be done (to avoid showing additional error checking code)
      * and this will need the characters '$ ` \ "' escaped
      */
     if (!commandShell->hasErrCtl) {
 	int i, j;
 	/* Worst that could happen is every char needs escaping. */
 	escCmd = bmake_malloc((strlen(cmd) * 2) + 1);
 	for (i = 0, j = 0; cmd[i] != '\0'; i++, j++) {
 	    if (cmd[i] == '$' || cmd[i] == '`' || cmd[i] == '\\' ||
 		cmd[i] == '"')
 		escCmd[j++] = '\\';
 	    escCmd[j] = cmd[i];
+	}
 	escCmd[j] = '\0';
+    }
     if (shutUp) {
 	if (!(job->flags & JOB_SILENT) && !noSpecials &&
 	    commandShell->hasEchoCtl) {
 		DBPRINTF("%s\n", commandShell->echoOff);
 	} else {
 	    if (commandShell->hasErrCtl)
 		shutUp = FALSE;
+	}
+    }
     if (errOff) {
 	if (!noSpecials) {
 	    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.
 		 */
 		job->flags |= JOB_IGNERR;
 		if (!(job->flags & JOB_SILENT) && !shutUp) {
 			if (commandShell->hasEchoCtl) {
 				DBPRINTF("%s\n", commandShell->echoOff);
+			}
 			DBPRINTF(commandShell->errCheck, escCmd);
 			shutUp = TRUE;
 		} else {
 			if (!shutUp) {
 				DBPRINTF(commandShell->errCheck, escCmd);
+			}
+		}
 		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;
+	    }
 	} else {
 	    errOff = FALSE;
+	}
     } else {
 	/*
 	 * If errors are being checked and the shell doesn't have error control
 	 * but does supply an errOut template, then setup commands to run
 	 * through it.
 	 */
 	if (!commandShell->hasErrCtl && commandShell->errOut &&
 	    (*commandShell->errOut != '\0')) {
 		if (!(job->flags & JOB_SILENT) && !shutUp) {
 			if (commandShell->hasEchoCtl) {
 				DBPRINTF("%s\n", commandShell->echoOff);
+			}
 			DBPRINTF(commandShell->errCheck, escCmd);
 			shutUp = TRUE;
+		}
 		/* If it's a comment line or blank, treat as an ignored error */
 		if ((escCmd[0] == commandShell->commentChar) ||
 		    (escCmd[0] == 0))
 			cmdTemplate = commandShell->ignErr;
 		else
 			cmdTemplate = commandShell->errOut;
 		errOff = FALSE;
+	}
+    }
     if (DEBUG(SHELL) && strcmp(shellName, "sh") == 0 &&
 	(job->flags & JOB_TRACED) == 0) {
 	    DBPRINTF("set -%s\n", "x");
 	    job->flags |= JOB_TRACED;
+    }
     DBPRINTF(cmdTemplate, cmd);
     free(cmdStart);
     free(escCmd);
     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 (shutUp && commandShell->hasEchoCtl) {
 	DBPRINTF("%s\n", commandShell->echoOn);
+    }
     return 0;
+}
 /*-
  *-----------------------------------------------------------------------
  * JobSaveCommand --
  *	Save a command to be executed when everything else is done.
  *	Callback function for JobFinish...
+ *
  * Results:
  *	Always returns 0
+ *
  * Side Effects:
  *	The command is tacked onto the end of postCommands' commands list.
+ *
  *-----------------------------------------------------------------------
  */
 static int
 JobSaveCommand(void *cmd, void *gn)
+{
     cmd = Var_Subst((char *)cmd, (GNode *)gn, VARE_WANTRES);
     Lst_Append(postCommands->commands, cmd);
     return 0;
+}
 /*-
  *-----------------------------------------------------------------------
  * JobClose --
  *	Called to close both input and output pipes when a job is finished.
+ *
  * Results:
  *	Nada
+ *
  * Side Effects:
  *	The file descriptors associated with the job are closed.
+ *
  *-----------------------------------------------------------------------
  */
 static void
 JobClose(Job *job)
+{
     clearfd(job);
     (void)close(job->outPipe);
     job->outPipe = -1;
     JobDoOutput(job, TRUE);
     (void)close(job->inPipe);
     job->inPipe = -1;
+}
 /*-
  *-----------------------------------------------------------------------
  * 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.
+ *
  * Input:
  *	job		job to finish
  *	status		sub-why job went away
+ *
  * Results:
  *	None
+ *
  * Side Effects:
  *	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.
  *-----------------------------------------------------------------------
  */
 /*ARGSUSED*/
 static void
 JobFinish(Job *job, int status)
+{
     Boolean 	 done, return_job_token;
     if (DEBUG(JOB)) {
 	fprintf(debug_file, "Jobfinish: %d [%s], status %d\n",
 				job->pid, job->node->name, status);
+    }
     if ((WIFEXITED(status) &&
 	 (((WEXITSTATUS(status) != 0) && !(job->flags & JOB_IGNERR)))) ||
 	WIFSIGNALED(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...
 	 */
 	JobClose(job);
 	if (job->cmdFILE != NULL && job->cmdFILE != stdout) {
 	   (void)fclose(job->cmdFILE);
 	   job->cmdFILE = NULL;
+	}
 	done = TRUE;
     } 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);
     } else {
 	/*
 	 * No need to close things down or anything.
 	 */
 	done = FALSE;
+    }
     if (done) {
 	if (WIFEXITED(status)) {
 	    if (DEBUG(JOB)) {
 		(void)fprintf(debug_file, "Process %d [%s] exited.\n",
 				job->pid, job->node->name);
+	    }
 	    if (WEXITSTATUS(status) != 0) {
 		if (job->node != lastNode) {
 		    MESSAGE(stdout, job->node);
 		    lastNode = job->node;
+		}
 #ifdef USE_META
 		if (useMeta) {
 		    meta_job_error(job, job->node, job->flags, WEXITSTATUS(status));
+		}
 #endif
 		if (!dieQuietly(job->node, -1))
 		    (void)printf("*** [%s] Error code %d%s\n",
 				 job->node->name,
 				 WEXITSTATUS(status),
 				 (job->flags & JOB_IGNERR) ? " (ignored)" : "");
 		if (job->flags & JOB_IGNERR) {
 		    status = 0;
 		} else {
 		    if (deleteOnError) {
 			JobDeleteTarget(job->node);
+		    }
 		    PrintOnError(job->node, NULL);
+		}
 	    } else if (DEBUG(JOB)) {
 		if (job->node != lastNode) {
 		    MESSAGE(stdout, job->node);
 		    lastNode = job->node;
+		}
 		(void)printf("*** [%s] Completed successfully\n",
 				job->node->name);
+	    }
 	} else {
 	    if (job->node != lastNode) {
 		MESSAGE(stdout, job->node);
 		lastNode = job->node;
+	    }
 	    (void)printf("*** [%s] Signal %d\n",
 			job->node->name, WTERMSIG(status));
 	    if (deleteOnError) {
 		JobDeleteTarget(job->node);
+	    }
+	}
 	(void)fflush(stdout);
+    }
 #ifdef USE_META
     if (useMeta) {
 	int x;
 	if ((x = meta_job_finish(job)) != 0 && status == 0) {
 	    status = x;
+	}
+    }
 #endif
     return_job_token = FALSE;
     Trace_Log(JOBEND, job);
     if (!(job->flags & JOB_SPECIAL)) {
 	if ((status != 0) ||
 		(aborting == ABORT_ERROR) ||
 		(aborting == ABORT_INTERRUPT))
 	    return_job_token = TRUE;
+    }
     if ((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 != NULL) {
 	    Lst_ForEachFrom(job->node->commands, job->tailCmds,
 			     JobSaveCommand,
 			     job->node);
+	}
 	job->node->made = MADE;
 	if (!(job->flags & JOB_SPECIAL))
 	    return_job_token = TRUE;
 	Make_Update(job->node);
 	job->job_state = JOB_ST_FREE;
     } else if (status != 0) {
 	errors += 1;
 	job->job_state = JOB_ST_FREE;
+    }
     /*
      * 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 (return_job_token)
 	Job_TokenReturn();
     if (aborting == ABORT_ERROR && jobTokensRunning == 0) {
 	/*
 	 * If we are aborting and the job table is now empty, we finish.
 	 */
 	Finish(errors);
+    }
+}
 /*-
  *-----------------------------------------------------------------------
  * Job_Touch --
  *	Touch the given target. Called by JobStart when the -t flag was
  *	given
+ *
  * Input:
  *	gn		the node of the file to touch
  *	silent		TRUE if should not print message
+ *
  * Results:
  *	None
+ *
  * Side Effects:
  *	The data modification of the file is changed. In addition, if the
  *	file did not exist, it is created.
  *-----------------------------------------------------------------------
  */
 void
 Job_Touch(GNode *gn, Boolean silent)
+{
     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_USEBEFORE|OP_EXEC|OP_OPTIONAL|
 	OP_SPECIAL|OP_PHONY)) {
 	/*
 	 * .JOIN, .USE, .ZEROTIME and .OPTIONAL targets are "virtual" targets
 	 * and, as such, shouldn't really be created.
 	 */
 	return;
+    }
     if (!silent || NoExecute(gn)) {
 	(void)fprintf(stdout, "touch %s\n", gn->name);
 	(void)fflush(stdout);
+    }
     if (NoExecute(gn)) {
 	return;
+    }
     if (gn->type & OP_ARCHV) {
 	Arch_Touch(gn);
     } else if (gn->type & OP_LIB) {
 	Arch_TouchLib(gn);
     } else {
 	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, (off_t)0, SEEK_SET);
 		    while (write(streamID, &c, 1) == -1 && errno == EAGAIN)
 			continue;
+		}
 		(void)close(streamID);
 	    } else {
 		(void)fprintf(stdout, "*** couldn't touch %s: %s",
 			       file, strerror(errno));
 		(void)fflush(stdout);
+	    }
+	}
+    }
+}
 /*-
  *-----------------------------------------------------------------------
  * Job_CheckCommands --
  *	Make sure the given node has all the commands it needs.
+ *
  * Input:
  *	gn		The target whose commands need verifying
  *	abortProc	Function to abort with message
+ *
  * Results:
  *	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.
  *-----------------------------------------------------------------------
  */
 Boolean
 Job_CheckCommands(GNode *gn, void (*abortProc)(const char *, ...))
+{
     if (OP_NOP(gn->type) && Lst_IsEmpty(gn->commands) &&
 	((gn->type & OP_LIB) == 0 || Lst_IsEmpty(gn->children))) {
 	/*
 	 * No commands. Look for .DEFAULT rule from which we might infer
 	 * commands
 	 */
 	if ((DEFAULT != NULL) && !Lst_IsEmpty(DEFAULT->commands) &&
 		(gn->type & OP_SPECIAL) == 0) {
 	    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);
 	    bmake_free(p1);
 	} else if (Dir_MTime(gn, 0) == 0 && (gn->type & OP_SPECIAL) == 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[] = ": don't know how to make";
 	    if (gn->flags & FROM_DEPEND) {
 		if (!Job_RunTarget(".STALE", gn->fname))
 		    fprintf(stdout, "%s: %s, %d: ignoring stale %s for %s\n",
 			progname, gn->fname, gn->lineno, makeDependfile,
 			gn->name);
 		return TRUE;
+	    }
 	    if (gn->type & OP_OPTIONAL) {
 		(void)fprintf(stdout, "%s%s %s (ignored)\n", progname,
 		    msg, gn->name);
 		(void)fflush(stdout);
 	    } else if (keepgoing) {
 		(void)fprintf(stdout, "%s%s %s (continuing)\n", progname,
 		    msg, gn->name);
 		(void)fflush(stdout);
 		return FALSE;
 	    } else {
 		(*abortProc)("%s%s %s. Stop", progname, msg, gn->name);
 		return FALSE;
+	    }
+	}
+    }
     return TRUE;
+}
 /*-
  *-----------------------------------------------------------------------
  * JobExec --
  *	Execute the shell for the given job. Called from JobStart
+ *
  * Input:
  *	job		Job to execute
+ *
  * Results:
  *	None.
+ *
  * Side Effects:
  *	A shell is executed, outputs is altered and the Job structure added
  *	to the job table.
+ *
  *-----------------------------------------------------------------------
  */
 static void
 JobExec(Job *job, char **argv)
+{
     int	    	  cpid;	    	/* ID of new child */
     sigset_t	  mask;
     job->flags &= ~JOB_TRACED;
     if (DEBUG(JOB)) {
 	int 	  i;
 	(void)fprintf(debug_file, "Running %s %sly\n", job->node->name, "local");
 	(void)fprintf(debug_file, "\tCommand: ");
 	for (i = 0; argv[i] != NULL; i++) {
 	    (void)fprintf(debug_file, "%s ", argv[i]);
+	}
 	(void)fprintf(debug_file, "\n");
+    }
     /*
      * 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_SILENT)) {
 	MESSAGE(stdout, job->node);
 	lastNode = job->node;
+    }
     /* No interruptions until this job is on the `jobs' list */
     JobSigLock(&mask);
     /* Pre-emptively mark job running, pid still zero though */
     job->job_state = JOB_ST_RUNNING;
     cpid = vFork();
     if (cpid == -1)
 	Punt("Cannot vfork: %s", strerror(errno));
     if (cpid == 0) {
 	/* Child */
 	sigset_t tmask;
 #ifdef USE_META
 	if (useMeta) {
 	    meta_job_child(job);
+	}
 #endif
 	/*
 	 * Reset all signal handlers; this is necessary because we also
 	 * need to unblock signals before we exec(2).
 	 */
 	JobSigReset();
 	/* Now unblock signals */
 	sigemptyset(&tmask);
 	JobSigUnlock(&tmask);
 	/*
 	 * 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) {
 	    execError("dup2", "job->cmdFILE");
 	    _exit(1);
+	}
 	if (fcntl(0, F_SETFD, 0) == -1) {
 	    execError("fcntl clear close-on-exec", "stdin");
 	    _exit(1);
+	}
 	if (lseek(0, (off_t)0, SEEK_SET) == -1) {
 	    execError("lseek to 0", "stdin");
 	    _exit(1);
+	}
 	if (job->node->type & (OP_MAKE | OP_SUBMAKE)) {
 		/*
 		 * Pass job token pipe to submakes.
 		 */
 		if (fcntl(tokenWaitJob.inPipe, F_SETFD, 0) == -1) {
 		    execError("clear close-on-exec", "tokenWaitJob.inPipe");
 		    _exit(1);
+		}
 		if (fcntl(tokenWaitJob.outPipe, F_SETFD, 0) == -1) {
 		    execError("clear close-on-exec", "tokenWaitJob.outPipe");
 		    _exit(1);
+		}
+	}
 	/*
 	 * Set up the child's output to be routed through the pipe
 	 * we've created for it.
 	 */
 	if (dup2(job->outPipe, 1) == -1) {
 	    execError("dup2", "job->outPipe");
 	    _exit(1);
+	}
 	/*
 	 * 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.
 	 */
 	if (fcntl(1, F_SETFD, 0) == -1) {
 	    execError("clear close-on-exec", "stdout");
 	    _exit(1);
+	}
 	if (dup2(1, 2) == -1) {
 	    execError("dup2", "1, 2");
 	    _exit(1);
+	}
 	/*
 	 * 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(MAKE_NATIVE) || defined(HAVE_SETPGID)
 #if defined(SYSV)
 	/* XXX: dsl - I'm sure this should be setpgrp()... */
 	(void)setsid();
 #else
 	(void)setpgid(0, getpid());
 #endif
 #endif
 	Var_ExportVars();
 	(void)execv(shellPath, argv);
 	execError("exec", shellPath);
 	_exit(1);
+    }
     /* Parent, continuing after the child exec */
     job->pid = cpid;
     Trace_Log(JOBSTART, job);
 #ifdef USE_META
     if (useMeta) {
 	meta_job_parent(job, cpid);
+    }
 #endif
     /*
      * Set the current position in the buffer to the beginning
      * and mark another stream to watch in the outputs mask
      */
     job->curPos = 0;
     watchfd(job);
     if (job->cmdFILE != NULL && job->cmdFILE != stdout) {
 	(void)fclose(job->cmdFILE);
 	job->cmdFILE = NULL;
+    }
     /*
      * Now the job is actually running, add it to the table.
      */
     if (DEBUG(JOB)) {
 	fprintf(debug_file, "JobExec(%s): pid %d added to jobs table\n",
 		job->node->name, job->pid);
 	job_table_dump("job started");
+    }
     JobSigUnlock(&mask);
+}
 /*-
  *-----------------------------------------------------------------------
  * JobMakeArgv --
  *	Create the argv needed to execute the shell for a given job.
+ *
+ *
  * Results:
+ *
  * Side Effects:
+ *
  *-----------------------------------------------------------------------
  */
 static void
 JobMakeArgv(Job *job, char **argv)
+{
     int	    	  argc;
     static char args[10]; 	/* For merged arguments */
     argv[0] = UNCONST(shellName);
     argc = 1;
     if ((commandShell->exit && (*commandShell->exit != '-')) ||
 	(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)snprintf(args, sizeof(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] = UNCONST(commandShell->exit);
 	    argc++;
+	}
 	if (!(job->flags & JOB_SILENT) && commandShell->echo) {
 	    argv[argc] = UNCONST(commandShell->echo);
 	    argc++;
+	}
+    }
     argv[argc] = NULL;
+}
 /*-
  *-----------------------------------------------------------------------
  * JobStart  --
  *	Start a target-creation process going for the target described
  *	by the graph node gn.
+ *
  * Input:
  *	gn		target to create
  *	flags		flags for the job to override normal ones.
  *			e.g. JOB_SPECIAL or JOB_IGNDOTS
  *	previous	The previous Job structure for this node, if any.
+ *
  * 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.
+ *
  * Side Effects:
  *	A new Job node is created and added to the list of running
  *	jobs. PMake is forked and a child shell created.
+ *
  * NB: I'm fairly sure that this code is never called with JOB_SPECIAL set
  *     JOB_IGNDOTS is never set (dsl)
  *     Also the return value is ignored by everyone.
  *-----------------------------------------------------------------------
  */
 static int
 JobStart(GNode *gn, int flags)
+{
     Job		  *job;       /* new job descriptor */
     char	  *argv[10];  /* Argument vector to shell */
     Boolean	  cmdsOK;     /* true if the nodes commands were all right */
     Boolean 	  noExec;     /* Set true if we decide not to run the job */
     int		  tfd;	      /* File descriptor to the temp file */
     for (job = job_table; job < job_table_end; job++) {
 	if (job->job_state == JOB_ST_FREE)
 	    break;
+    }
     if (job >= job_table_end)
 	Punt("JobStart no job slots vacant");
     memset(job, 0, sizeof *job);
     job->job_state = JOB_ST_SETUP;
     if (gn->type & OP_SPECIAL)
 	flags |= JOB_SPECIAL;
     job->node = gn;
     job->tailCmds = NULL;
     /*
      * Set the initial value of the flags for this job based on the global
      * ones and the node's attributes... Any flags supplied by the caller
      * are also added to the field.
      */
     job->flags = 0;
     if (Targ_Ignore(gn)) {
 	job->flags |= JOB_IGNERR;
+    }
     if (Targ_Silent(gn)) {
 	job->flags |= JOB_SILENT;
+    }
     job->flags |= flags;
     /*
      * Check the commands now so any attributes from .DEFAULT have a chance
      * to migrate to the node
      */
     cmdsOK = Job_CheckCommands(gn, Error);
     job->inPollfd = NULL;
     /*
      * If the -n flag wasn't given, we open up OUR (not the child's)
      * temporary file to stuff commands in it. The thing is rd/wr so we don't
      * need to reopen it to feed it to the shell. If the -n flag *was* given,
      * we just set the file to be stdout. Cute, huh?
      */
     if (((gn->type & OP_MAKE) && !(noRecursiveExecute)) ||
 	    (!noExecute && !touchFlag)) {
 	/*
 	 * tfile is the name of a file into which all shell commands are
 	 * put. It is removed before the child shell is executed, unless
 	 * DEBUG(SCRIPT) is set.
 	 */
 	char *tfile;
 	sigset_t mask;
 	/*
 	 * We're serious here, but if the commands were bogus, we're
 	 * also dead...
 	 */
 	if (!cmdsOK) {
 	    PrintOnError(gn, NULL);	/* provide some clue */
 	    DieHorribly();
+	}
 	JobSigLock(&mask);
 	tfd = mkTempFile(TMPPAT, &tfile);
 	if (!DEBUG(SCRIPT))
 		(void)eunlink(tfile);
 	JobSigUnlock(&mask);
 	job->cmdFILE = fdopen(tfd, "w+");
 	if (job->cmdFILE == NULL) {
 	    Punt("Could not fdopen %s", tfile);
+	}
 	(void)fcntl(FILENO(job->cmdFILE), F_SETFD, FD_CLOEXEC);
 	/*
 	 * Send the commands to the command file, flush all its buffers then
 	 * rewind and remove the thing.
 	 */
 	noExec = FALSE;
 #ifdef USE_META
 	if (useMeta) {
 	    meta_job_start(job, gn);
 	    if (Targ_Silent(gn)) {	/* might have changed */
 		job->flags |= JOB_SILENT;
+	    }
+	}
 #endif
 	/*
 	 * We can do all the commands at once. hooray for sanity
 	 */
 	numCommands = 0;
 	Lst_ForEach(gn->commands, JobPrintCommand, 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;
+	}
 	free(tfile);
     } else if (NoExecute(gn)) {
 	/*
 	 * 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, 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 in case it isn't already... */
     (void)fflush(job->cmdFILE);
     /*
      * If we're not supposed to execute a shell, don't.
      */
     if (noExec) {
 	if (!(job->flags & JOB_SPECIAL))
 	    Job_TokenReturn();
 	/*

 @@ -1,638 +1,638 @@
-/* $NetBSD: lst.c,v 1.55 2020/08/29 10:12:06 rillig Exp $ */
+/* $NetBSD: lst.c,v 1.56 2020/08/29 10:41:12 rillig Exp $ */
 /*
  * Copyright (c) 1988, 1989, 1990, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <stdint.h>
 #include "make.h"
 #ifndef MAKE_NATIVE
-static char rcsid[] = "$NetBSD: lst.c,v 1.55 2020/08/29 10:12:06 rillig Exp $";
+static char rcsid[] = "$NetBSD: lst.c,v 1.56 2020/08/29 10:41:12 rillig Exp $";
 #else
 #include <sys/cdefs.h>
 #ifndef lint
-__RCSID("$NetBSD: lst.c,v 1.55 2020/08/29 10:12:06 rillig Exp $");
+__RCSID("$NetBSD: lst.c,v 1.56 2020/08/29 10:41:12 rillig Exp $");
 #endif /* not lint */
 #endif
 struct ListNode {
     struct ListNode *prev;	/* previous element in list */
     struct ListNode *next;	/* next in list */
     uint8_t useCount;		/* Count of functions using the node.
 				 * node may not be deleted until count
 				 * goes to 0 */
     Boolean deleted;		/* List node should be removed when done */
     union {
 	void *datum;		/* datum associated with this element */
 	const GNode *gnode;	/* alias, just for debugging */
 	const char *str;	/* alias, just for debugging */
     };
 };
 typedef enum {
     Head, Middle, Tail, Unknown
 } Where;
 struct List {
     LstNode first;		/* first node in list */
     LstNode last;		/* last node in list */
     /* fields for sequential access */
     Boolean isOpen;		/* true if list has been Lst_Open'ed */
     Where lastAccess;		/* Where in the list the last access was */
     LstNode curr;		/* current node, if open. NULL if
 				 * *just* opened */
     LstNode prev;		/* Previous node, if open. Used by Lst_Remove */
 };
 /* Allocate and initialize a list node.
+ *
  * The fields 'prev' and 'next' must be initialized by the caller.
  */
 static LstNode
 LstNodeNew(void *datum)
+{
     LstNode node = bmake_malloc(sizeof *node);
     node->useCount = 0;
     node->deleted = FALSE;
     node->datum = datum;
     return node;
+}
 static Boolean
 LstIsEmpty(Lst list)
+{
     return list->first == NULL;
+}
 /* Create and initialize a new, empty list. */
 Lst
 Lst_Init(void)
+{
     Lst list = bmake_malloc(sizeof *list);
     list->first = NULL;
     list->last = NULL;
     list->isOpen = FALSE;
     list->lastAccess = Unknown;
     return list;
+}
 /* Duplicate an entire list, usually by copying the datum pointers.
  * If copyProc is given, that function is used to create the new datum from the
  * old datum, usually by creating a copy of it. */
 Lst
 Lst_Copy(Lst list, LstCopyProc copyProc)
+{
     Lst newList;
     LstNode node;
     assert(list != NULL);
     newList = Lst_Init();
     for (node = list->first; node != NULL; node = node->next) {
 	void *datum = copyProc != NULL ? copyProc(node->datum) : node->datum;
 	Lst_Append(newList, datum);
+    }
     return newList;
+}
 /* Free a list and all its nodes. The list data itself are not freed though. */
 void
 Lst_Free(Lst list)
+{
     LstNode node;
     LstNode next;
     assert(list != NULL);
     for (node = list->first; node != NULL; node = next) {
 	next = node->next;
 	free(node);
+    }
     free(list);
+}
 /* Destroy a list and free all its resources. If the freeProc is given, it is
  * called with the datum from each node in turn before the node is freed. */
 void
 Lst_Destroy(Lst list, LstFreeProc freeProc)
+{
     LstNode node;
     LstNode next;
     assert(list != NULL);
     assert(freeProc != NULL);
     for (node = list->first; node != NULL; node = next) {
 	next = node->next;
 	freeProc(node->datum);
 	free(node);
+    }
     free(list);
+}
 /*
  * Functions to modify a list
  */
 /* Insert a new node with the given piece of data before the given node in the
  * given list. */
 void
 Lst_InsertBefore(Lst list, LstNode node, void *datum)
+{
     LstNode newNode;
     assert(list != NULL);
     assert(!LstIsEmpty(list));
     assert(node != NULL);
     assert(datum != NULL);
     newNode = LstNodeNew(datum);
     newNode->prev = node->prev;
     newNode->next = node;
     if (node->prev != NULL) {
 	node->prev->next = newNode;
+    }
     node->prev = newNode;
     if (node == list->first) {
 	list->first = newNode;
+    }
+}
 /* Add a piece of data at the start of the given list. */
 void
 Lst_Prepend(Lst list, void *datum)
+{
     LstNode node;
     assert(list != NULL);
     assert(datum != NULL);
     node = LstNodeNew(datum);
     node->prev = NULL;
     node->next = list->first;
     if (list->first == NULL) {
 	list->first = node;
 	list->last = node;
     } else {
 	list->first->prev = node;
 	list->first = node;
+    }
+}
 /* Add a piece of data at the end of the given list. */
 void
 Lst_Append(Lst list, void *datum)
+{
     LstNode node;
     assert(list != NULL);
     assert(datum != NULL);
     node = LstNodeNew(datum);
     node->prev = list->last;
     node->next = NULL;
     if (list->last == NULL) {
 	list->first = node;
 	list->last = node;
     } else {
 	list->last->next = node;
 	list->last = node;
+    }
+}
 /* Remove the given node from the given list.
  * The datum stored in the node must be freed by the caller, if necessary. */
 void
 Lst_Remove(Lst list, LstNode node)
+{
     assert(list != NULL);
     assert(node != NULL);
     /*
      * unlink it from the list
      */
     if (node->next != NULL) {
 	node->next->prev = node->prev;
+    }
     if (node->prev != NULL) {
 	node->prev->next = node->next;
+    }
     /*
      * if either the first or last of the list point to this node,
      * adjust them accordingly
      */
     if (list->first == node) {
 	list->first = node->next;
+    }
     if (list->last == node) {
 	list->last = node->prev;
+    }
     /*
      * Sequential access stuff. If the node we're removing is the current
      * node in the list, reset the current node to the previous one. If the
      * previous one was non-existent (prev == NULL), we set the
      * end to be Unknown, since it is.
      */
     if (list->isOpen && list->curr == node) {
 	list->curr = list->prev;
 	if (list->curr == NULL) {
 	    list->lastAccess = Unknown;
+	}
+    }
     /*
      * note that the datum is unmolested. The caller must free it as
      * necessary and as expected.
      */
     if (node->useCount == 0) {
 	free(node);
     } else {
 	node->deleted = TRUE;
+    }
+}
 /* Replace the datum in the given node with the new datum. */
 void
 LstNode_Set(LstNode node, void *datum)
+{
     assert(node != NULL);
     assert(datum != NULL);
     node->datum = datum;
+}
 /* Replace the datum in the given node to NULL. */
 void
 LstNode_SetNull(LstNode node)
+{
     assert(node != NULL);
     node->datum = NULL;
+}
 /*
  * Node-specific functions
  */
 /* Return the first node from the given list, or NULL if the list is empty. */
 LstNode
 Lst_First(Lst list)
+{
     assert(list != NULL);
     return list->first;
+}
 /* Return the last node from the given list, or NULL if the list is empty. */
 LstNode
 Lst_Last(Lst list)
+{
     assert(list != NULL);
     return list->last;
+}
 /* Return the successor to the given node on its list, or NULL. */
 LstNode
-Lst_Succ(LstNode node)
+LstNode_Next(LstNode node)
+{
     assert(node != NULL);
     return node->next;
+}
 /* Return the predecessor to the given node on its list, or NULL. */
 LstNode
-Lst_Prev(LstNode node)
+LstNode_Prev(LstNode node)
+{
     assert(node != NULL);
     return node->prev;
+}
 /* Return the datum stored in the given node. */
 void *
 Lst_Datum(LstNode node)
+{
     assert(node != NULL);
     return node->datum;
+}
 /*
  * Functions for entire lists
  */
 /* Return TRUE if the given list is empty. */
 Boolean
 Lst_IsEmpty(Lst list)
+{
     assert(list != NULL);
     return LstIsEmpty(list);
+}
 /* Return the first node from the list for which the match function returns
  * TRUE, or NULL if none of the nodes matched. */
 LstNode
 Lst_Find(Lst list, LstFindProc match, const void *matchArgs)
+{
     return Lst_FindFrom(list, Lst_First(list), match, matchArgs);
+}
 /* Return the first node from the list, starting at the given node, for which
  * the match function returns TRUE, or NULL if none of the nodes matches.
+ *
  * The start node may be NULL, in which case nothing is found. This allows
- * for passing Lst_First or Lst_Succ as the start node. */
+ * for passing Lst_First or LstNode_Next as the start node. */
 LstNode
 Lst_FindFrom(Lst list, LstNode node, LstFindProc match, const void *matchArgs)
+{
     LstNode tln;
     assert(list != NULL);
     assert(match != NULL);
     for (tln = node; tln != NULL; tln = tln->next) {
 	if (match(tln->datum, matchArgs))
 	    return tln;
+    }
     return NULL;
+}
 /* Return the first node that contains the given datum, or NULL. */
 LstNode
 Lst_Member(Lst list, void *datum)
+{
     LstNode node;
     assert(list != NULL);
     assert(datum != NULL);
     for (node = list->first; node != NULL; node = node->next) {
 	if (node->datum == datum) {
 	    return node;
+	}
+    }
     return NULL;
+}
 /* Apply the given function to each element of the given list. The function
  * should return 0 if traversal should continue and non-zero if it should
  * abort. */
 int
 Lst_ForEach(Lst list, LstActionProc proc, void *procData)
+{
     if (LstIsEmpty(list))
 	return 0;		/* XXX: Document what this value means. */
     return Lst_ForEachFrom(list, Lst_First(list), proc, procData);
+}
 /* Apply the given function to each element of the given list, starting from
  * the given node. The function should return 0 if traversal should continue,
  * and non-zero if it should abort. */
 int
 Lst_ForEachFrom(Lst list, LstNode node,
 		 LstActionProc proc, void *procData)
+{
     LstNode tln = node;
     LstNode next;
     Boolean done;
     int result;
     assert(list != NULL);
     assert(node != NULL);
     assert(proc != NULL);
     do {
 	/*
 	 * Take care of having the current element deleted out from under
 	 * us.
 	 */
 	next = tln->next;
 	/*
 	 * We're done with the traversal if
 	 *  - the next node to examine doesn't exist and
 	 *  - nothing's been added after the current node (check this
 	 *    after proc() has been called).
 	 */
 	done = next == NULL;
 	tln->useCount++;
 	result = (*proc)(tln->datum, procData);
 	tln->useCount--;
 	/*
 	 * Now check whether a node has been added.
 	 * Note: this doesn't work if this node was deleted before
 	 *       the new node was added.
 	 */
 	if (next != tln->next) {
 	    next = tln->next;
 	    done = 0;
+	}
 	if (tln->deleted) {
 	    free((char *)tln);
+	}
 	tln = next;
     } while (!result && !LstIsEmpty(list) && !done);
     return result;
+}
 /* Move all nodes from list2 to the end of list1.
  * List2 is destroyed and freed. */
 void
 Lst_MoveAll(Lst list1, Lst list2)
+{
     assert(list1 != NULL);
     assert(list2 != NULL);
     if (list2->first != NULL) {
 	list2->first->prev = list1->last;
 	if (list1->last != NULL) {
 	    list1->last->next = list2->first;
 	} else {
 	    list1->first = list2->first;
+	}
 	list1->last = list2->last;
+    }
     free(list2);
+}
 /* Copy the element data from src to the start of dst. */
 void
 Lst_PrependAll(Lst dst, Lst src)
+{
     LstNode node;
     for (node = src->last; node != NULL; node = node->prev)
 	Lst_Prepend(dst, node->datum);
+}
 /* Copy the element data from src to the end of dst. */
 void
 Lst_AppendAll(Lst dst, Lst src)
+{
     LstNode node;
     for (node = src->first; node != NULL; node = node->next)
 	Lst_Append(dst, node->datum);
+}
 /*
  * these functions are for dealing with a list as a table, of sorts.
  * An idea of the "current element" is kept and used by all the functions
  * between Lst_Open() and Lst_Close().
+ *
  * The sequential functions access the list in a slightly different way.
  * CurPtr points to their idea of the current node in the list and they
  * access the list based on it.
  */
 /* Open a list for sequential access. A list can still be searched, etc.,
  * without confusing these functions. */
 void
 Lst_Open(Lst list)
+{
     assert(list != NULL);
     /* XXX: This assertion fails for NetBSD's "build.sh -j1 tools", somewhere
      * between "dependall ===> compat" and "dependall ===> binstall".
      * Building without the "-j1" succeeds though. */
     if (DEBUG(LINT) && list->isOpen)
 	Parse_Error(PARSE_WARNING, "Internal inconsistency: list opened twice");
     list->isOpen = TRUE;
     list->lastAccess = LstIsEmpty(list) ? Head : Unknown;
     list->curr = NULL;
+}
 /* Return the next node for the given list, or NULL if the end has been
  * reached. */
 LstNode
 Lst_Next(Lst list)
+{
     LstNode node;
     assert(list != NULL);
     assert(list->isOpen);
     list->prev = list->curr;
     if (list->curr == NULL) {
 	if (list->lastAccess == Unknown) {
 	    /*
 	     * If we're just starting out, lastAccess will be Unknown.
 	     * Then we want to start this thing off in the right
 	     * direction -- at the start with lastAccess being Middle.
 	     */
 	    list->curr = node = list->first;
 	    list->lastAccess = Middle;
 	} else {
 	    node = NULL;
 	    list->lastAccess = Tail;
+	}
     } else {
 	node = list->curr->next;
 	list->curr = node;
 	if (node == list->first || node == NULL) {
 	    /*
 	     * If back at the front, then we've hit the end...
 	     */
 	    list->lastAccess = Tail;
 	} else {
 	    /*
 	     * Reset to Middle if gone past first.
 	     */
 	    list->lastAccess = Middle;
+	}
+    }
     return node;
+}
 /* Close a list which was opened for sequential access. */
 void
 Lst_Close(Lst list)
+{
     assert(list != NULL);
     assert(list->isOpen);
     list->isOpen = FALSE;
     list->lastAccess = Unknown;
+}
 /*
  * for using the list as a queue
  */
 /* Add the datum to the tail of the given list. */
 void
 Lst_Enqueue(Lst list, void *datum)
+{
     Lst_Append(list, datum);
+}
 /* Remove and return the datum at the head of the given list. */
 void *
 Lst_Dequeue(Lst list)
+{
     void *datum;
     assert(list != NULL);
     assert(!LstIsEmpty(list));
     datum = list->first->datum;
     Lst_Remove(list, list->first);
     assert(datum != NULL);
     return datum;
+}

 @@ -1,2200 +1,2200 @@
-/*	$NetBSD: main.c,v 1.326 2020/08/29 10:12:06 rillig Exp $	*/
+/*	$NetBSD: main.c,v 1.327 2020/08/29 10:41:12 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 /*
  * Copyright (c) 1989 by Berkeley Softworks
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 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.
  * 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
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #ifndef MAKE_NATIVE
-static char rcsid[] = "$NetBSD: main.c,v 1.326 2020/08/29 10:12:06 rillig Exp $";
+static char rcsid[] = "$NetBSD: main.c,v 1.327 2020/08/29 10:41:12 rillig Exp $";
 #else
 #include <sys/cdefs.h>
 #ifndef lint
 __COPYRIGHT("@(#) Copyright (c) 1988, 1989, 1990, 1993\
  The Regents of the University of California.  All rights reserved.");
 #endif /* not lint */
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)main.c	8.3 (Berkeley) 3/19/94";
 #else
-__RCSID("$NetBSD: main.c,v 1.326 2020/08/29 10:12:06 rillig Exp $");
+__RCSID("$NetBSD: main.c,v 1.327 2020/08/29 10:41:12 rillig Exp $");
 #endif
 #endif /* not lint */
 #endif
 /*-
  * main.c --
  *	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 optional arguments
  *				for it.
+ *
  *	Fatal			Print an error message and exit. Also takes
  *				a format string and arguments for it.
+ *
  *	Punt			Aborts all jobs and exits with a message. Also
  *				takes a format string and arguments for it.
+ *
  *	Finish			Finish things up by printing the number of
  *				errors which occurred, as passed to it, and
  *				exiting.
  */
 #include <sys/types.h>
 #include <sys/time.h>
 #include <sys/param.h>
 #include <sys/resource.h>
 #include <sys/stat.h>
 #ifdef MAKE_NATIVE
 #include <sys/sysctl.h>
 #endif
 #include <sys/utsname.h>
 #include <sys/wait.h>
 #include <ctype.h>
 #include <errno.h>
 #include <signal.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
 #include "make.h"
 #include "hash.h"
 #include "dir.h"
 #include "job.h"
 #include "pathnames.h"
 #include "trace.h"
 #ifdef USE_IOVEC
 #include <sys/uio.h>
 #endif
 #ifndef	DEFMAXLOCAL
 #define	DEFMAXLOCAL DEFMAXJOBS
 #endif	/* DEFMAXLOCAL */
 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 */
 Boolean			deleteOnError;	/* .DELETE_ON_ERROR: set */
 static Boolean		noBuiltins;	/* -r flag */
 static Lst		makefiles;	/* ordered list of makefiles to read */
 static int		printVars;	/* -[vV] argument */
 #define COMPAT_VARS 1
 #define EXPAND_VARS 2
 static Lst		variables;	/* list of variables to print
 					 * (for -v and -V) */
 int			maxJobs;	/* -j argument */
 static int		maxJobTokens;	/* -j argument */
 Boolean			compatMake;	/* -B argument */
 int			debug;		/* -d argument */
 Boolean			debugVflag;	/* -dV */
 Boolean			noExecute;	/* -n flag */
 Boolean			noRecursiveExecute;	/* -N flag */
 Boolean			keepgoing;	/* -k flag */
 Boolean			queryFlag;	/* -q flag */
 Boolean			touchFlag;	/* -t flag */
 Boolean			enterFlag;	/* -w flag */
 Boolean			enterFlagObj;	/* -w and objdir != srcdir */
 Boolean			ignoreErrors;	/* -i flag */
 Boolean			beSilent;	/* -s flag */
 Boolean			oldVars;	/* variable substitution style */
 Boolean			checkEnvFirst;	/* -e flag */
 Boolean			parseWarnFatal;	/* -W flag */
 static int jp_0 = -1, jp_1 = -1;	/* ends of parent job pipe */
 Boolean			varNoExportEnv;	/* -X flag */
 Boolean			doing_depend;	/* Set while reading .depend */
 static Boolean		jobsRunning;	/* TRUE if the jobs might be running */
 static const char *	tracefile;
 static void		MainParseArgs(int, char **);
 static int		ReadMakefile(const char *);
 static void		usage(void) MAKE_ATTR_DEAD;
 static void		purge_cached_realpaths(void);
 static Boolean		ignorePWD;	/* if we use -C, PWD is meaningless */
 static char objdir[MAXPATHLEN + 1];	/* where we chdir'ed to */
 char curdir[MAXPATHLEN + 1];		/* Startup directory */
 char *progname;				/* the program name */
 char *makeDependfile;
 pid_t myPid;
 int makelevel;
 FILE *debug_file;
 Boolean forceJobs = FALSE;
 extern Lst parseIncPath;
 /*
  * For compatibility with the POSIX version of MAKEFLAGS that includes
  * all the options with out -, convert flags to -f -l -a -g -s.
  */
 static char *
 explode(const char *flags)
+{
     size_t len;
     char *nf, *st;
     const char *f;
     if (flags == NULL)
 	return NULL;
     for (f = flags; *f; f++)
 	if (!isalpha((unsigned char)*f))
 	    break;
     if (*f)
 	return bmake_strdup(flags);
     len = strlen(flags);
     st = nf = bmake_malloc(len * 3 + 1);
     while (*flags) {
 	*nf++ = '-';
 	*nf++ = *flags++;
 	*nf++ = ' ';
+    }
     *nf = '\0';
     return st;
+}
 static void
 parse_debug_options(const char *argvalue)
+{
 	const char *modules;
 	const char *mode;
 	char *fname;
 	int len;
 	for (modules = argvalue; *modules; ++modules) {
 		switch (*modules) {
 		case 'A':
 			debug = ~(0|DEBUG_LINT);
 			break;
 		case 'a':
 			debug |= DEBUG_ARCH;
 			break;
 		case 'C':
 			debug |= DEBUG_CWD;
 			break;
 		case 'c':
 			debug |= DEBUG_COND;
 			break;
 		case 'd':
 			debug |= DEBUG_DIR;
 			break;
 		case 'e':
 			debug |= DEBUG_ERROR;
 			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;
+			}
 			else if (modules[1] == '3') {
 				debug |= DEBUG_GRAPH3;
 				++modules;
+			}
 			break;
 		case 'h':
 			debug |= DEBUG_HASH;
 			break;
 		case 'j':
 			debug |= DEBUG_JOB;
 			break;
 		case 'L':
 			debug |= DEBUG_LINT;
 			break;
 		case 'l':
 			debug |= DEBUG_LOUD;
 			break;
 		case 'M':
 			debug |= DEBUG_META;
 			break;
 		case 'm':
 			debug |= DEBUG_MAKE;
 			break;
 		case 'n':
 			debug |= DEBUG_SCRIPT;
 			break;
 		case 'p':
 			debug |= DEBUG_PARSE;
 			break;
 		case 's':
 			debug |= DEBUG_SUFF;
 			break;
 		case 't':
 			debug |= DEBUG_TARG;
 			break;
 		case 'V':
 			debugVflag = TRUE;
 			break;
 		case 'v':
 			debug |= DEBUG_VAR;
 			break;
 		case 'x':
 			debug |= DEBUG_SHELL;
 			break;
 		case 'F':
 			if (debug_file != stdout && debug_file != stderr)
 				fclose(debug_file);
 			if (*++modules == '+') {
 				modules++;
 				mode = "a";
 			} else
 				mode = "w";
 			if (strcmp(modules, "stdout") == 0) {
 				debug_file = stdout;
 				goto debug_setbuf;
+			}
 			if (strcmp(modules, "stderr") == 0) {
 				debug_file = stderr;
 				goto debug_setbuf;
+			}
 			len = strlen(modules);
 			fname = bmake_malloc(len + 20);
 			memcpy(fname, modules, len + 1);
 			/* Let the filename be modified by the pid */
 			if (strcmp(fname + len - 3, ".%d") == 0)
 				snprintf(fname + len - 2, 20, "%d", getpid());
 			debug_file = fopen(fname, mode);
 			if (!debug_file) {
 				fprintf(stderr, "Cannot open debug file %s\n",
 				    fname);
 				usage();
+			}
 			free(fname);
 			goto debug_setbuf;
 		default:
 			(void)fprintf(stderr,
 			    "%s: illegal argument to d option -- %c\n",
 			    progname, *modules);
 			usage();
+		}
+	}
 debug_setbuf:
 	/*
 	 * Make the debug_file unbuffered, and make
 	 * stdout line buffered (unless debugfile == stdout).
 	 */
 	setvbuf(debug_file, NULL, _IONBF, 0);
 	if (debug_file != stdout) {
 		setvbuf(stdout, NULL, _IOLBF, 0);
+	}
+}
 /*
  * does path contain any relative components
  */
 static Boolean
 is_relpath(const char *path)
+{
 	const char *cp;
 	if (path[0] != '/')
 		return TRUE;
 	cp = path;
 	while ((cp = strstr(cp, "/.")) != NULL) {
 		cp += 2;
 		if (cp[0] == '/' || cp[0] == '\0')
 			return TRUE;
 		else if (cp[0] == '.') {
 			if (cp[1] == '/' || cp[1] == '\0')
 				return TRUE;
+		}
+	}
 	return FALSE;
+}
 /*-
  * 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
+ *
  * Results:
  *	None
+ *
  * Side Effects:
  *	Various global and local flags will be set depending on the flags
  *	given
  */
 static void
 MainParseArgs(int argc, char **argv)
+{
 	char *p;
 	char c = '?';
 	int arginc;
 	char *argvalue;
 	const char *getopt_def;
 	struct stat sa, sb;
 	char *optscan;
 	Boolean inOption, dashDash = FALSE;
 	char found_path[MAXPATHLEN + 1];	/* for searching for sys.mk */
 #define OPTFLAGS "BC:D:I:J:NST:V:WXd:ef:ij:km:nqrstv:w"
 /* Can't actually use getopt(3) because rescanning is not portable */
 	getopt_def = OPTFLAGS;
 rearg:
 	inOption = FALSE;
 	optscan = NULL;
 	while(argc > 1) {
 		char *getopt_spec;
 		if(!inOption)
 			optscan = argv[1];
 		c = *optscan++;
 		arginc = 0;
 		if(inOption) {
 			if(c == '\0') {
 				++argv;
 				--argc;
 				inOption = FALSE;
 				continue;
+			}
 		} else {
 			if (c != '-' || dashDash)
 				break;
 			inOption = TRUE;
 			c = *optscan++;
+		}
 		/* '-' found at some earlier point */
 		getopt_spec = strchr(getopt_def, c);
 		if(c != '\0' && getopt_spec != NULL && getopt_spec[1] == ':') {
 			/* -<something> found, and <something> should have an arg */
 			inOption = FALSE;
 			arginc = 1;
 			argvalue = optscan;
 			if(*argvalue == '\0') {
 				if (argc < 3)
 					goto noarg;
 				argvalue = argv[2];
 				arginc = 2;
+			}
 		} else {
 			argvalue = NULL;
+		}
 		switch(c) {
 		case '\0':
 			arginc = 1;
 			inOption = FALSE;
 			break;
 		case 'B':
 			compatMake = TRUE;
 			Var_Append(MAKEFLAGS, "-B", VAR_GLOBAL);
 			Var_Set(MAKE_MODE, "compat", VAR_GLOBAL);
 			break;
 		case 'C':
 			if (chdir(argvalue) == -1) {
 				(void)fprintf(stderr,
 					      "%s: chdir %s: %s\n",
 					      progname, argvalue,
 					      strerror(errno));
 				exit(1);
+			}
 			if (getcwd(curdir, MAXPATHLEN) == NULL) {
 				(void)fprintf(stderr, "%s: %s.\n", progname, strerror(errno));
 				exit(2);
+			}
 			if (!is_relpath(argvalue) &&
 			    stat(argvalue, &sa) != -1 &&
 			    stat(curdir, &sb) != -1 &&
 			    sa.st_ino == sb.st_ino &&
 			    sa.st_dev == sb.st_dev)
 				strncpy(curdir, argvalue, MAXPATHLEN);
 			ignorePWD = TRUE;
 			break;
 		case 'D':
 			if (argvalue == NULL || argvalue[0] == 0) goto noarg;
 			Var_Set(argvalue, "1", VAR_GLOBAL);
 			Var_Append(MAKEFLAGS, "-D", VAR_GLOBAL);
 			Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
 			break;
 		case 'I':
 			if (argvalue == NULL) goto noarg;
 			Parse_AddIncludeDir(argvalue);
 			Var_Append(MAKEFLAGS, "-I", VAR_GLOBAL);
 			Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
 			break;
 		case 'J':
 			if (argvalue == NULL) goto noarg;
 			if (sscanf(argvalue, "%d,%d", &jp_0, &jp_1) != 2) {
 			    (void)fprintf(stderr,
 				"%s: internal error -- J option malformed (%s)\n",
 				progname, argvalue);
 				usage();
+			}
 			if ((fcntl(jp_0, F_GETFD, 0) < 0) ||
 			    (fcntl(jp_1, F_GETFD, 0) < 0)) {
 #if 0
 			    (void)fprintf(stderr,
 				"%s: ###### warning -- J descriptors were closed!\n",
 				progname);
 			    exit(2);
 #endif
 			    jp_0 = -1;
 			    jp_1 = -1;
 			    compatMake = TRUE;
 			} else {
 			    Var_Append(MAKEFLAGS, "-J", VAR_GLOBAL);
 			    Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
+			}
 			break;
 		case 'N':
 			noExecute = TRUE;
 			noRecursiveExecute = TRUE;
 			Var_Append(MAKEFLAGS, "-N", VAR_GLOBAL);
 			break;
 		case 'S':
 			keepgoing = FALSE;
 			Var_Append(MAKEFLAGS, "-S", VAR_GLOBAL);
 			break;
 		case 'T':
 			if (argvalue == NULL) goto noarg;
 			tracefile = bmake_strdup(argvalue);
 			Var_Append(MAKEFLAGS, "-T", VAR_GLOBAL);
 			Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
 			break;
 		case 'V':
 		case 'v':
 			if (argvalue == NULL) goto noarg;
 			printVars = c == 'v' ? EXPAND_VARS : COMPAT_VARS;
 			Lst_Append(variables, argvalue);
 			Var_Append(MAKEFLAGS, "-V", VAR_GLOBAL);
 			Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
 			break;
 		case 'W':
 			parseWarnFatal = TRUE;
 			break;
 		case 'X':
 			varNoExportEnv = TRUE;
 			Var_Append(MAKEFLAGS, "-X", VAR_GLOBAL);
 			break;
 		case 'd':
 			if (argvalue == NULL) goto noarg;
 			/* If '-d-opts' don't pass to children */
 			if (argvalue[0] == '-')
 			    argvalue++;
 			else {
 			    Var_Append(MAKEFLAGS, "-d", VAR_GLOBAL);
 			    Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
+			}
 			parse_debug_options(argvalue);
 			break;
 		case 'e':
 			checkEnvFirst = TRUE;
 			Var_Append(MAKEFLAGS, "-e", VAR_GLOBAL);
 			break;
 		case 'f':
 			if (argvalue == NULL) goto noarg;
 			Lst_Append(makefiles, argvalue);
 			break;
 		case 'i':
 			ignoreErrors = TRUE;
 			Var_Append(MAKEFLAGS, "-i", VAR_GLOBAL);
 			break;
 		case 'j':
 			if (argvalue == NULL) goto noarg;
 			forceJobs = TRUE;
 			maxJobs = strtol(argvalue, &p, 0);
 			if (*p != '\0' || maxJobs < 1) {
 				(void)fprintf(stderr, "%s: illegal argument to -j -- must be positive integer!\n",
 				    progname);
 				exit(1);
+			}
 			Var_Append(MAKEFLAGS, "-j", VAR_GLOBAL);
 			Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
 			Var_Set(".MAKE.JOBS", argvalue, VAR_GLOBAL);
 			maxJobTokens = maxJobs;
 			break;
 		case 'k':
 			keepgoing = TRUE;
 			Var_Append(MAKEFLAGS, "-k", VAR_GLOBAL);
 			break;
 		case 'm':
 			if (argvalue == NULL) goto noarg;
 			/* look for magic parent directory search string */
 			if (strncmp(".../", argvalue, 4) == 0) {
 				if (!Dir_FindHereOrAbove(curdir, argvalue+4,
 				    found_path, sizeof(found_path)))
 					break;		/* nothing doing */
 				(void)Dir_AddDir(sysIncPath, found_path);
 			} else {
 				(void)Dir_AddDir(sysIncPath, argvalue);
+			}
 			Var_Append(MAKEFLAGS, "-m", VAR_GLOBAL);
 			Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
 			break;
 		case 'n':
 			noExecute = TRUE;
 			Var_Append(MAKEFLAGS, "-n", VAR_GLOBAL);
 			break;
 		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 'w':
 			enterFlag = TRUE;
 			Var_Append(MAKEFLAGS, "-w", VAR_GLOBAL);
 			break;
 		case '-':
 			dashDash = TRUE;
 			break;
 		default:
 		case '?':
 			usage();
+		}
 		argv += arginc;
 		argc -= arginc;
+	}
 	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 (; argc > 1; ++argv, --argc)
 		if (Parse_IsVar(argv[1])) {
 			Parse_DoVar(argv[1], VAR_CMD);
 		} else {
 			if (!*argv[1])
 				Punt("illegal (null) argument.");
 			if (*argv[1] == '-' && !dashDash)
 				goto rearg;
 			Lst_Append(create, bmake_strdup(argv[1]));
+		}
 	return;
 noarg:
 	(void)fprintf(stderr, "%s: option requires an argument -- %c\n",
 	    progname, c);
 	usage();
+}
 /*-
  * 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.
+ *
  * Input:
  *	line		Line to fracture
+ *
  * Results:
  *	None
+ *
  * Side Effects:
  *	Only those that come from the various arguments.
  */
 void
 Main_ParseArgLine(const char *line)
+{
 	char **argv;			/* Manufactured argument vector */
 	size_t argc;			/* Number of arguments in argv */
 	char *args;			/* Space used by the args */
 	char *p1;
 	const char *argv0 = Var_Value(".MAKE", VAR_GLOBAL, &p1);
 	char *buf;
 	if (line == NULL)
 		return;
 	for (; *line == ' '; ++line)
 		continue;
 	if (!*line)
 		return;
 	buf = str_concat3(argv0, " ", line);
 	free(p1);
 	argv = brk_string(buf, TRUE, &argc, &args);
 	if (argv == NULL) {
 		Error("Unterminated quoted string [%s]", buf);
 		free(buf);
 		return;
+	}
 	free(buf);
 	MainParseArgs((int)argc, argv);
 	free(args);
 	free(argv);
+}
 Boolean
 Main_SetObjdir(const char *fmt, ...)
+{
 	struct stat sb;
 	char *path;
 	char buf[MAXPATHLEN + 1];
 	char buf2[MAXPATHLEN + 1];
 	Boolean rc = FALSE;
 	va_list ap;
 	va_start(ap, fmt);
 	vsnprintf(path = buf, MAXPATHLEN, fmt, ap);
 	va_end(ap);
 	if (path[0] != '/') {
 		snprintf(buf2, MAXPATHLEN, "%s/%s", curdir, path);
 		path = buf2;
+	}
 	/* look for the directory and try to chdir there */
 	if (stat(path, &sb) == 0 && S_ISDIR(sb.st_mode)) {
 		if (chdir(path)) {
 			(void)fprintf(stderr, "make warning: %s: %s.\n",
 				      path, strerror(errno));
 		} else {
 			snprintf(objdir, sizeof objdir, "%s", path);
 			Var_Set(".OBJDIR", objdir, VAR_GLOBAL);
 			setenv("PWD", objdir, 1);
 			Dir_InitDot();
 			purge_cached_realpaths();
 			rc = TRUE;
 			if (enterFlag && strcmp(objdir, curdir) != 0)
 				enterFlagObj = TRUE;
+		}
+	}
 	return rc;
+}
 static Boolean
 Main_SetVarObjdir(const char *var, const char *suffix)
+{
 	char *path_freeIt;
 	const char *path = Var_Value(var, VAR_CMD, &path_freeIt);
 	const char *xpath;
 	char *xpath_freeIt;
 	if (path == NULL || path[0] == '\0') {
 		bmake_free(path_freeIt);
 		return FALSE;
+	}
 	/* expand variable substitutions */
 	xpath = path;
 	xpath_freeIt = NULL;
 	if (strchr(path, '$') != 0)
 		xpath = xpath_freeIt = Var_Subst(path, VAR_GLOBAL,
 						 VARE_WANTRES);
 	(void)Main_SetObjdir("%s%s", xpath, suffix);
 	bmake_free(xpath_freeIt);
 	bmake_free(path_freeIt);
 	return TRUE;
+}
 /* Read and parse the makefile.
  * Return TRUE if reading the makefile succeeded, for Lst_Find. */
 static Boolean
 ReadMakefileSucceeded(const void *fname, const void *unused)
+{
 	return ReadMakefile(fname) == 0;
+}
 /* Read and parse the makefile.
  * Return TRUE if reading the makefile failed, for Lst_Find. */
 static Boolean
 ReadMakefileFailed(const void *fname, const void *unused)
+{
 	return ReadMakefile(fname) != 0;
+}
 int
 str2Lst_Append(Lst lp, char *str, const char *sep)
+{
     char *cp;
     int n;
     if (!sep)
 	sep = " \t";
     for (n = 0, cp = strtok(str, sep); cp; cp = strtok(NULL, sep)) {
 	Lst_Append(lp, cp);
 	n++;
+    }
     return n;
+}
 #ifdef SIGINFO
 /*ARGSUSED*/
 static void
 siginfo(int signo MAKE_ATTR_UNUSED)
+{
 	char dir[MAXPATHLEN];
 	char str[2 * MAXPATHLEN];
 	int len;
 	if (getcwd(dir, sizeof(dir)) == NULL)
 		return;
 	len = snprintf(str, sizeof(str), "%s: Working in: %s\n", progname, dir);
 	if (len > 0)
 		(void)write(STDERR_FILENO, str, (size_t)len);
+}
 #endif
 /*
  * Allow makefiles some control over the mode we run in.
  */
 void
 MakeMode(const char *mode)
+{
     char *mode_freeIt = NULL;
     if (mode == NULL)
 	mode = mode_freeIt = Var_Subst("${" MAKE_MODE ":tl}",
 				       VAR_GLOBAL, VARE_WANTRES);
     if (mode[0] != '\0') {
 	if (strstr(mode, "compat")) {
 	    compatMake = TRUE;
 	    forceJobs = FALSE;
+	}
 #if USE_META
 	if (strstr(mode, "meta"))
 	    meta_mode_init(mode);
 #endif
+    }
     free(mode_freeIt);
+}
 static void
 doPrintVars(void)
+{
 	LstNode ln;
 	Boolean expandVars;
 	if (printVars == EXPAND_VARS)
 		expandVars = TRUE;
 	else if (debugVflag)
 		expandVars = FALSE;
 	else
 		expandVars = getBoolean(".MAKE.EXPAND_VARIABLES", FALSE);
-	for (ln = Lst_First(variables); ln != NULL; ln = Lst_Succ(ln)) {
+	for (ln = Lst_First(variables); ln != NULL; ln = LstNode_Next(ln)) {
 		char *var = Lst_Datum(ln);
 		const char *value;
 		char *p1;
 		if (strchr(var, '$')) {
 			value = p1 = Var_Subst(var, VAR_GLOBAL, VARE_WANTRES);
 		} else if (expandVars) {
 			char tmp[128];
 			int len = snprintf(tmp, sizeof(tmp), "${%s}", var);
 			if (len >= (int)sizeof(tmp))
 				Fatal("%s: variable name too big: %s",
 				    progname, var);
 			value = p1 = Var_Subst(tmp, VAR_GLOBAL, VARE_WANTRES);
 		} else {
 			value = Var_Value(var, VAR_GLOBAL, &p1);
+		}
 		printf("%s\n", value ? value : "");
 		bmake_free(p1);
+	}
+}
 static Boolean
 runTargets(void)
+{
 	Lst targs;	/* target nodes to create -- passed to Make_Init */
 	Boolean outOfDate; 	/* FALSE if all targets up to date */
 	/*
 	 * 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) {
 		/*
 		 * 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) {
 			Job_Init();
 			jobsRunning = TRUE;
+		}
 		/* Traverse the graph, checking on all the targets */
 		outOfDate = Make_Run(targs);
 	} else {
 		/*
 		 * Compat_Init will take care of creating all the
 		 * targets as well as initializing the module.
 		 */
 		Compat_Run(targs);
 		outOfDate = FALSE;
+	}
 	Lst_Free(targs);
 	return outOfDate;
+}
 /*-
  * 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.
+ *
  * Results:
  *	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.
  */
 int
 main(int argc, char **argv)
+{
 	Boolean outOfDate; 	/* FALSE if all targets up to date */
 	struct stat sb, sa;
 	char *p1, *path;
 	char mdpath[MAXPATHLEN];
 	const char *machine = getenv("MACHINE");
 	const char *machine_arch = getenv("MACHINE_ARCH");
 	char *syspath = getenv("MAKESYSPATH");
 	Lst sysMkPath;			/* Path of sys.mk */
 	char *cp = NULL, *start;
 					/* avoid faults on read-only strings */
 	static char defsyspath[] = _PATH_DEFSYSPATH;
 	char found_path[MAXPATHLEN + 1];	/* for searching for sys.mk */
 	struct timeval rightnow;		/* to initialize random seed */
 	struct utsname utsname;
 	/* default to writing debug to stderr */
 	debug_file = stderr;
 #ifdef SIGINFO
 	(void)bmake_signal(SIGINFO, siginfo);
 #endif
 	/*
 	 * Set the seed to produce a different random sequence
 	 * on each program execution.
 	 */
 	gettimeofday(&rightnow, NULL);
 	srandom(rightnow.tv_sec + rightnow.tv_usec);
 	if ((progname = strrchr(argv[0], '/')) != NULL)
 		progname++;
 	else
 		progname = argv[0];
 #if defined(MAKE_NATIVE) || (defined(HAVE_SETRLIMIT) && defined(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
 	if (uname(&utsname) == -1) {
 	    (void)fprintf(stderr, "%s: uname failed (%s).\n", progname,
 		strerror(errno));
 	    exit(2);
+	}
 	/*
 	 * 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 both MACHINE and MACHINE_ARCH are decided at
 	 * run-time.
 	 */
 	if (!machine) {
 #ifdef MAKE_NATIVE
 	    machine = utsname.machine;
 #else
 #ifdef MAKE_MACHINE
 	    machine = MAKE_MACHINE;
 #else
 	    machine = "unknown";
 #endif
 #endif
+	}
 	if (!machine_arch) {
 #ifdef MAKE_NATIVE
 	    static char machine_arch_buf[sizeof(utsname.machine)];
 	    const int mib[2] = { CTL_HW, HW_MACHINE_ARCH };
 	    size_t len = sizeof(machine_arch_buf);
 	    if (sysctl(mib, __arraycount(mib), machine_arch_buf,
 		    &len, NULL, 0) < 0) {
 		(void)fprintf(stderr, "%s: sysctl failed (%s).\n", progname,
 		    strerror(errno));
 		exit(2);
+	    }
 	    machine_arch = machine_arch_buf;
 #else
 #ifndef MACHINE_ARCH
 #ifdef MAKE_MACHINE_ARCH
 	    machine_arch = MAKE_MACHINE_ARCH;
 #else
 	    machine_arch = "unknown";
 #endif
 #else
 	    machine_arch = MACHINE_ARCH;
 #endif
 #endif
+	}
 	myPid = getpid();		/* remember this for vFork() */
 	/*
 	 * Just in case MAKEOBJDIR wants us to do something tricky.
 	 */
 	Var_Init();		/* Initialize the lists of variables for
 				 * parsing arguments */
 	Var_Set(".MAKE.OS", utsname.sysname, VAR_GLOBAL);
 	Var_Set("MACHINE", machine, VAR_GLOBAL);
 	Var_Set("MACHINE_ARCH", machine_arch, VAR_GLOBAL);
 #ifdef MAKE_VERSION
 	Var_Set("MAKE_VERSION", MAKE_VERSION, VAR_GLOBAL);
 #endif
 	Var_Set(".newline", "\n", VAR_GLOBAL); /* handy for :@ loops */
 	/*
 	 * This is the traditional preference for makefiles.
 	 */
 #ifndef MAKEFILE_PREFERENCE_LIST
 # define MAKEFILE_PREFERENCE_LIST "makefile Makefile"
 #endif
 	Var_Set(MAKEFILE_PREFERENCE, MAKEFILE_PREFERENCE_LIST,
 		VAR_GLOBAL);
 	Var_Set(MAKE_DEPENDFILE, ".depend", VAR_GLOBAL);
 	create = Lst_Init();
 	makefiles = Lst_Init();
 	printVars = 0;
 	debugVflag = FALSE;
 	variables = Lst_Init();
 	beSilent = FALSE;		/* Print commands as executed */
 	ignoreErrors = FALSE;		/* Pay attention to non-zero returns */
 	noExecute = FALSE;		/* Execute all commands */
 	noRecursiveExecute = FALSE;	/* Execute all .MAKE targets */
 	keepgoing = FALSE;		/* Stop on error */
 	allPrecious = FALSE;		/* Remove targets when interrupted */
 	deleteOnError = FALSE;		/* Historical default behavior */
 	queryFlag = FALSE;		/* This is not just a check-run */
 	noBuiltins = FALSE;		/* Read the built-in rules */
 	touchFlag = FALSE;		/* Actually update targets */
 	debug = 0;			/* No debug verbosity, please. */
 	jobsRunning = FALSE;
 	maxJobs = DEFMAXLOCAL;		/* Set default local max concurrency */
 	maxJobTokens = maxJobs;
 	compatMake = FALSE;		/* No compat mode */
 	ignorePWD = FALSE;
 	/*
 	 * Initialize the parsing, directory and variable modules to prepare
 	 * for the reading of inclusion paths and variable settings on the
 	 * command line
 	 */
 	/*
 	 * 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.
 	 */
 	Parse_Init();
 	if (argv[0][0] == '/' || strchr(argv[0], '/') == NULL) {
 	    /*
 	     * Leave alone if it is an absolute path, or if it does
 	     * not contain a '/' in which case we need to find it in
 	     * the path, like execvp(3) and the shells do.
 	     */
 	    p1 = argv[0];
 	} else {
 	    /*
 	     * A relative path, canonicalize it.
 	     */
 	    p1 = cached_realpath(argv[0], mdpath);
 	    if (!p1 || *p1 != '/' || stat(p1, &sb) < 0) {
 		p1 = argv[0];		/* realpath failed */
+	    }
+	}
 	Var_Set("MAKE", p1, VAR_GLOBAL);
 	Var_Set(".MAKE", p1, VAR_GLOBAL);
 	Var_Set(MAKEFLAGS, "", VAR_GLOBAL);
 	Var_Set(MAKEOVERRIDES, "", VAR_GLOBAL);
 	Var_Set("MFLAGS", "", VAR_GLOBAL);
 	Var_Set(".ALLTARGETS", "", VAR_GLOBAL);
 	/* some makefiles need to know this */
 	Var_Set(MAKE_LEVEL ".ENV", MAKE_LEVEL_ENV, VAR_CMD);
 	/*
 	 * Set some other useful macros
 	 */
+	{
 	    char tmp[64], *ep;
 	    makelevel = ((ep = getenv(MAKE_LEVEL_ENV)) && *ep) ? atoi(ep) : 0;
 	    if (makelevel < 0)
 		makelevel = 0;
 	    snprintf(tmp, sizeof(tmp), "%d", makelevel);
 	    Var_Set(MAKE_LEVEL, tmp, VAR_GLOBAL);
 	    snprintf(tmp, sizeof(tmp), "%u", myPid);
 	    Var_Set(".MAKE.PID", tmp, VAR_GLOBAL);
 	    snprintf(tmp, sizeof(tmp), "%u", getppid());
 	    Var_Set(".MAKE.PPID", tmp, VAR_GLOBAL);
+	}
 	if (makelevel > 0) {
 		char pn[1024];
 		snprintf(pn, sizeof(pn), "%s[%d]", progname, makelevel);
 		progname = bmake_strdup(pn);
+	}
 #ifdef USE_META
 	meta_init();
 #endif
 	Dir_Init();
 	/*
 	 * 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
 	p1 = explode(getenv("MAKEFLAGS"));
 	Main_ParseArgLine(p1);
 	free(p1);
 #else
 	Main_ParseArgLine(getenv("MAKE"));
 #endif
 	/*
 	 * Find where we are (now).
 	 * We take care of PWD for the automounter below...
 	 */
 	if (getcwd(curdir, MAXPATHLEN) == NULL) {
 		(void)fprintf(stderr, "%s: getcwd: %s.\n",
 		    progname, strerror(errno));
 		exit(2);
+	}
 	MainParseArgs(argc, argv);
 	if (enterFlag)
 		printf("%s: Entering directory `%s'\n", progname, curdir);
 	/*
 	 * Verify that cwd is sane.
 	 */
 	if (stat(curdir, &sa) == -1) {
 	    (void)fprintf(stderr, "%s: %s: %s.\n",
 		 progname, curdir, strerror(errno));
 	    exit(2);
+	}
 	/*
 	 * All this code is so that we know where we are when we start up
 	 * on a different machine with pmake.
 	 * Overriding getcwd() with $PWD totally breaks MAKEOBJDIRPREFIX
 	 * since the value of curdir can vary depending on how we got
 	 * here.  Ie sitting at a shell prompt (shell that provides $PWD)
 	 * or via subdir.mk in which case its likely a shell which does
 	 * not provide it.
 	 * So, to stop it breaking this case only, we ignore PWD if
 	 * MAKEOBJDIRPREFIX is set or MAKEOBJDIR contains a transform.
 	 */
 #ifndef NO_PWD_OVERRIDE
 	if (!ignorePWD) {
 		char *pwd, *ptmp1 = NULL, *ptmp2 = NULL;
 		if ((pwd = getenv("PWD")) != NULL &&
 		    Var_Value("MAKEOBJDIRPREFIX", VAR_CMD, &ptmp1) == NULL) {
 			const char *makeobjdir = Var_Value("MAKEOBJDIR",
 			    VAR_CMD, &ptmp2);
 			if (makeobjdir == NULL || !strchr(makeobjdir, '$')) {
 				if (stat(pwd, &sb) == 0 &&
 				    sa.st_ino == sb.st_ino &&
 				    sa.st_dev == sb.st_dev)
 					(void)strncpy(curdir, pwd, MAXPATHLEN);
+			}
+		}
 		bmake_free(ptmp1);
 		bmake_free(ptmp2);
+	}
 #endif
 	Var_Set(".CURDIR", curdir, VAR_GLOBAL);
 	/*
 	 * Find the .OBJDIR.  If MAKEOBJDIRPREFIX, or failing that,
 	 * MAKEOBJDIR is set in the environment, try only that value
 	 * and fall back to .CURDIR if it does not exist.
+	 *
 	 * Otherwise, try _PATH_OBJDIR.MACHINE-MACHINE_ARCH, _PATH_OBJDIR.MACHINE,
 	 * and * finally _PATH_OBJDIRPREFIX`pwd`, in that order.  If none
 	 * of these paths exist, just use .CURDIR.
 	 */
 	Dir_InitDir(curdir);
 	(void)Main_SetObjdir("%s", curdir);
 	if (!Main_SetVarObjdir("MAKEOBJDIRPREFIX", curdir) &&
 	    !Main_SetVarObjdir("MAKEOBJDIR", "") &&
 	    !Main_SetObjdir("%s.%s-%s", _PATH_OBJDIR, machine, machine_arch) &&
 	    !Main_SetObjdir("%s.%s", _PATH_OBJDIR, machine) &&
 	    !Main_SetObjdir("%s", _PATH_OBJDIR))
 		(void)Main_SetObjdir("%s%s", _PATH_OBJDIRPREFIX, curdir);
 	/*
 	 * Initialize archive, target and suffix modules in preparation for
 	 * parsing the makefile(s)
 	 */
 	Arch_Init();
 	Targ_Init();
 	Suff_Init();
 	Trace_Init(tracefile);
 	DEFAULT = NULL;
 	(void)time(&now);
 	Trace_Log(MAKESTART, NULL);
 	/*
 	 * 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 != NULL; ln = Lst_Succ(ln)) {
+		for (ln = Lst_First(create); ln != NULL; ln = LstNode_Next(ln)) {
 			char *name = Lst_Datum(ln);
 			Var_Append(".TARGETS", name, VAR_GLOBAL);
+		}
 	} else
 		Var_Set(".TARGETS", "", VAR_GLOBAL);
 	/*
 	 * 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.
 	 */
 	/* XXX: mismatch: the -m option sets sysIncPath, not syspath */
 	if (syspath == NULL || syspath[0] == '\0')
 		syspath = defsyspath;
 	else
 		syspath = bmake_strdup(syspath);
 	for (start = syspath; *start != '\0'; start = cp) {
 		for (cp = start; *cp != '\0' && *cp != ':'; cp++)
 			continue;
 		if (*cp == ':') {
 			*cp++ = '\0';
+		}
 		/* look for magic parent directory search string */
 		if (strncmp(".../", start, 4) != 0) {
 			(void)Dir_AddDir(defIncPath, start);
 		} else {
 			if (Dir_FindHereOrAbove(curdir, start+4,
 			    found_path, sizeof(found_path))) {
 				(void)Dir_AddDir(defIncPath, found_path);
+			}
+		}
+	}
 	if (syspath != defsyspath)
 		free(syspath);
 	/*
 	 * Read in the built-in rules first, followed by the specified
 	 * makefiles, or the default makefile and Makefile, in that order,
 	 * if no makefiles were given on the command line.
 	 */
 	if (!noBuiltins) {
 		LstNode ln;
 		sysMkPath = Lst_Init();
 		Dir_Expand(_PATH_DEFSYSMK,
 			   Lst_IsEmpty(sysIncPath) ? defIncPath : sysIncPath,
 			   sysMkPath);
 		if (Lst_IsEmpty(sysMkPath))
 			Fatal("%s: no system rules (%s).", progname,
 			    _PATH_DEFSYSMK);
 		ln = Lst_Find(sysMkPath, ReadMakefileSucceeded, NULL);
 		if (ln == NULL)
 			Fatal("%s: cannot open %s.", progname,
 			    (char *)Lst_Datum(Lst_First(sysMkPath)));
+	}
 	if (!Lst_IsEmpty(makefiles)) {
 		LstNode ln;
 		ln = Lst_Find(makefiles, ReadMakefileFailed, NULL);
 		if (ln != NULL)
 			Fatal("%s: cannot open %s.", progname,
 			    (char *)Lst_Datum(ln));
 	} else {
 	    p1 = Var_Subst("${" MAKEFILE_PREFERENCE "}",
 		VAR_CMD, VARE_WANTRES);
 	    if (p1) {
 		(void)str2Lst_Append(makefiles, p1, NULL);
 		(void)Lst_Find(makefiles, ReadMakefileSucceeded, NULL);
 		free(p1);
+	    }
+	}
 	/* In particular suppress .depend for '-r -V .OBJDIR -f /dev/null' */
 	if (!noBuiltins || !printVars) {
 	    makeDependfile = Var_Subst("${.MAKE.DEPENDFILE:T}",
 		VAR_CMD, VARE_WANTRES);
 	    doing_depend = TRUE;
 	    (void)ReadMakefile(makeDependfile);
 	    doing_depend = FALSE;
+	}
 	if (enterFlagObj)
 		printf("%s: Entering directory `%s'\n", progname, objdir);
 	MakeMode(NULL);
 	Var_Append("MFLAGS", Var_Value(MAKEFLAGS, VAR_GLOBAL, &p1), VAR_GLOBAL);
 	bmake_free(p1);
 	if (!forceJobs && !compatMake &&
 	    Var_Exists(".MAKE.JOBS", VAR_GLOBAL)) {
 	    char *value;
 	    int n;
 	    value = Var_Subst("${.MAKE.JOBS}", VAR_GLOBAL, VARE_WANTRES);
 	    n = strtol(value, NULL, 0);
 	    if (n < 1) {
 		(void)fprintf(stderr, "%s: illegal value for .MAKE.JOBS -- must be positive integer!\n",
 		    progname);
 		exit(1);
+	    }
 	    if (n != maxJobs) {
 		Var_Append(MAKEFLAGS, "-j", VAR_GLOBAL);
 		Var_Append(MAKEFLAGS, value, VAR_GLOBAL);
+	    }
 	    maxJobs = n;
 	    maxJobTokens = maxJobs;
 	    forceJobs = TRUE;
 	    free(value);
+	}
 	/*
 	 * Be compatible if user did not specify -j and did not explicitly
 	 * turned compatibility on
 	 */
 	if (!compatMake && !forceJobs) {
 	    compatMake = TRUE;
+	}
 	if (!compatMake)
 	    Job_ServerStart(maxJobTokens, jp_0, jp_1);
 	if (DEBUG(JOB))
 	    fprintf(debug_file,
 		    "job_pipe %d %d, maxjobs %d, tokens %d, compat %d\n",
 		    jp_0, jp_1, maxJobs, maxJobTokens, compatMake ? 1 : 0);
 	if (!printVars)
 	    Main_ExportMAKEFLAGS(TRUE);	/* initial export */
 	/*
 	 * 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, 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(VPATH, VAR_CMD, VARE_WANTRES);
 		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 */
 			(void)Dir_AddDir(dirSearchPath, path);
 			*cp = savec;
 			path = cp + 1;
 		} while (savec == ':');
 		free(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();
 	/*
 	 * Propagate attributes through :: dependency lists.
 	 */
 	Targ_Propagate();
 	/* 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) {
 		doPrintVars();
 		outOfDate = FALSE;
 	} else {
 		outOfDate = runTargets();
+	}
 #ifdef CLEANUP
 	Lst_Free(variables);
 	Lst_Free(makefiles);
 	Lst_Destroy(create, free);
 #endif
 	/* print the graph now it's been processed if the user requested it */
 	if (DEBUG(GRAPH2))
 		Targ_PrintGraph(2);
 	Trace_Log(MAKEEND, 0);
 	if (enterFlagObj)
 		printf("%s: Leaving directory `%s'\n", progname, objdir);
 	if (enterFlag)
 		printf("%s: Leaving directory `%s'\n", progname, curdir);
 #ifdef USE_META
 	meta_finish();
 #endif
 	Suff_End();
 	Targ_End();
 	Arch_End();
 	Var_End();
 	Parse_End();
 	Dir_End();
 	Job_End();
 	Trace_End();
 	return outOfDate ? 1 : 0;
+}
 /* Open and parse the given makefile, with all its side effects.
+ *
  * Results:
  *	0 if ok. -1 if couldn't open file.
  */
 static int
 ReadMakefile(const char *fname)
+{
 	int fd;
 	char *name, *path = NULL;
 	if (!strcmp(fname, "-")) {
 		Parse_File(NULL /*stdin*/, -1);
 		Var_Set("MAKEFILE", "", VAR_INTERNAL);
 	} else {
 		/* if we've chdir'd, rebuild the path name */
 		if (strcmp(curdir, objdir) && *fname != '/') {
 			path = str_concat3(curdir, "/", fname);
 			fd = open(path, O_RDONLY);
 			if (fd != -1) {
 				fname = path;
 				goto found;
+			}
 			free(path);
 			/* If curdir failed, try objdir (ala .depend) */
 			path = str_concat3(objdir, "/", fname);
 			fd = open(path, O_RDONLY);
 			if (fd != -1) {
 				fname = path;
 				goto found;
+			}
 		} else {
 			fd = open(fname, O_RDONLY);
 			if (fd != -1)
 				goto found;
+		}
 		/* look in -I and system include directories. */
 		name = Dir_FindFile(fname, parseIncPath);
 		if (!name)
 			name = Dir_FindFile(fname,
 				Lst_IsEmpty(sysIncPath) ? defIncPath : sysIncPath);
 		if (!name || (fd = open(name, O_RDONLY)) == -1) {
 			free(name);
 			free(path);
 			return -1;
+		}
 		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 (!doing_depend)
 			Var_Set("MAKEFILE", fname, VAR_INTERNAL);
 		Parse_File(fname, fd);
+	}
 	free(path);
 	return 0;
+}
 /*-
  * Cmd_Exec --
  *	Execute the command in cmd, and return the output of that command
  *	in a string.  In the output, newlines are replaced with spaces.
+ *
  * Results:
  *	A string containing the output of the command, or the empty string.
  *	*errfmt returns a format string describing the command failure,
  *	if any, using a single %s conversion specification.
+ *
  * Side Effects:
  *	The string must be freed by the caller.
  */
 char *
 Cmd_Exec(const char *cmd, const char **errfmt)
+{
     const char	*args[4];   	/* Args for invoking the shell */
     int 	fds[2];	    	/* Pipe streams */
     int 	cpid;	    	/* Child PID */
     int 	pid;	    	/* PID from wait() */
     int		status;		/* command exit status */
     Buffer	buf;		/* buffer to store the result */
     ssize_t	bytes_read;
     char	*res;		/* result */
     size_t	res_len;
     char	*cp;
     int		savederr;	/* saved errno */
     *errfmt = NULL;
     if (!shellName)
 	Shell_Init();
     /*
      * Set up arguments for shell
      */
     args[0] = shellName;
     args[1] = "-c";
     args[2] = cmd;
     args[3] = NULL;
     /*
      * Open a pipe for fetching its output
      */
     if (pipe(fds) == -1) {
 	*errfmt = "Couldn't create pipe for \"%s\"";
 	goto bad;
+    }
     /*
      * Fork
      */
     switch (cpid = vFork()) {
     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]);
 	Var_ExportVars();
 	(void)execv(shellPath, UNCONST(args));
 	_exit(1);
 	/*NOTREACHED*/
     case -1:
 	*errfmt = "Couldn't exec \"%s\"";
 	goto bad;
     default:
 	/*
 	 * No need for the writing half
 	 */
 	(void)close(fds[1]);
 	savederr = 0;
 	Buf_Init(&buf, 0);
 	do {
 	    char   result[BUFSIZ];
 	    bytes_read = read(fds[0], result, sizeof(result));
 	    if (bytes_read > 0)
 		Buf_AddBytes(&buf, result, (size_t)bytes_read);
+	}
 	while (bytes_read > 0 || (bytes_read == -1 && errno == EINTR));
 	if (bytes_read == -1)
 	    savederr = errno;
 	/*
 	 * Close the input side of the pipe.
 	 */
 	(void)close(fds[0]);
 	/*
 	 * Wait for the process to exit.
 	 */
 	while(((pid = waitpid(cpid, &status, 0)) != cpid) && (pid >= 0)) {
 	    JobReapChild(pid, status, FALSE);
 	    continue;
+	}
 	res_len = Buf_Size(&buf);
 	res = Buf_Destroy(&buf, FALSE);
 	if (savederr != 0)
 	    *errfmt = "Couldn't read shell's output for \"%s\"";
 	if (WIFSIGNALED(status))
 	    *errfmt = "\"%s\" exited on a signal";
 	else if (WEXITSTATUS(status) != 0)
 	    *errfmt = "\"%s\" returned non-zero status";
 	/* Convert newlines to spaces.  A final newline is just stripped */
 	if (res_len > 0 && res[res_len - 1] == '\n')
 	    res[res_len - 1] = '\0';
 	for (cp = res; *cp != '\0'; cp++)
 	    if (*cp == '\n')
 		*cp = ' ';
 	break;
+    }
     return res;
 bad:
     return bmake_strdup("");
+}
 /*-
  * Error --
  *	Print an error message given its format.
+ *
  * Results:
  *	None.
+ *
  * Side Effects:
  *	The message is printed.
  */
 /* VARARGS */
 void
 Error(const char *fmt, ...)
+{
 	va_list ap;
 	FILE *err_file;
 	err_file = debug_file;
 	if (err_file == stdout)
 		err_file = stderr;
 	(void)fflush(stdout);
 	for (;;) {
 		va_start(ap, fmt);
 		fprintf(err_file, "%s: ", progname);
 		(void)vfprintf(err_file, fmt, ap);
 		va_end(ap);
 		(void)fprintf(err_file, "\n");
 		(void)fflush(err_file);
 		if (err_file == stderr)
 			break;
 		err_file = stderr;
+	}
+}
 /*-
  * Fatal --
  *	Produce a Fatal error message. If jobs are running, waits for them
  *	to finish.
+ *
  * Results:
  *	None
+ *
  * Side Effects:
  *	The program exits
  */
 /* VARARGS */
 void
 Fatal(const char *fmt, ...)
+{
 	va_list ap;
 	va_start(ap, fmt);
 	if (jobsRunning)
 		Job_Wait();
 	(void)fflush(stdout);
 	(void)vfprintf(stderr, fmt, ap);
 	va_end(ap);
 	(void)fprintf(stderr, "\n");
 	(void)fflush(stderr);
 	PrintOnError(NULL, NULL);
 	if (DEBUG(GRAPH2) || DEBUG(GRAPH3))
 		Targ_PrintGraph(2);
 	Trace_Log(MAKEERROR, 0);
 	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.
+ *
  * Results:
  *	None
+ *
  * Side Effects:
  *	All children are killed indiscriminately and the program Lib_Exits
  */
 /* VARARGS */
 void
 Punt(const char *fmt, ...)
+{
 	va_list ap;
 	va_start(ap, fmt);
 	(void)fflush(stdout);
 	(void)fprintf(stderr, "%s: ", progname);
 	(void)vfprintf(stderr, fmt, ap);
 	va_end(ap);
 	(void)fprintf(stderr, "\n");
 	(void)fflush(stderr);
 	PrintOnError(NULL, NULL);
 	DieHorribly();
+}
 /*-
  * DieHorribly --
  *	Exit without giving a message.
+ *
  * Results:
  *	None
+ *
  * Side Effects:
  *	A big one...
  */
 void
 DieHorribly(void)
+{
 	if (jobsRunning)
 		Job_AbortAll();
 	if (DEBUG(GRAPH2))
 		Targ_PrintGraph(2);
 	Trace_Log(MAKEERROR, 0);
 	exit(2);		/* Not 1, so -q can distinguish error */
+}
 /*
  * Finish --
  *	Called when aborting due to errors in child shell to signal
  *	abnormal exit.
+ *
  * Results:
  *	None
+ *
  * Side Effects:
  *	The program exits
  */
 void
 Finish(int errors)
 			/* number of errors encountered in Make_Make */
+{
 	if (dieQuietly(NULL, -1))
 		exit(2);
 	Fatal("%d error%s", errors, errors == 1 ? "" : "s");
+}
 /*
  * eunlink --
  *	Remove a file carefully, avoiding directories.
  */
 int
 eunlink(const char *file)
+{
 	struct stat st;
 	if (lstat(file, &st) == -1)
 		return -1;
 	if (S_ISDIR(st.st_mode)) {
 		errno = EISDIR;
 		return -1;
+	}
 	return unlink(file);
+}
 /*
  * execError --
  *	Print why exec failed, avoiding stdio.
  */
 void
 execError(const char *af, const char *av)
+{
 #ifdef USE_IOVEC
 	int i = 0;
 	struct iovec iov[8];
 #define IOADD(s) \
 	(void)(iov[i].iov_base = UNCONST(s), \
 	    iov[i].iov_len = strlen(iov[i].iov_base), \
 	    i++)
 #else
 #define	IOADD(void)write(2, s, strlen(s))
 #endif
 	IOADD(progname);
 	IOADD(": ");
 	IOADD(af);
 	IOADD("(");
 	IOADD(av);
 	IOADD(") failed (");
 	IOADD(strerror(errno));
 	IOADD(")\n");
 #ifdef USE_IOVEC
 	while (writev(2, iov, 8) == -1 && errno == EAGAIN)
 	    continue;
 #endif
+}
 /*
  * usage --
  *	exit with usage message
  */
 static void
 usage(void)
+{
 	char *p;
 	if ((p = strchr(progname, '[')) != NULL)
 		*p = '\0';
 	(void)fprintf(stderr,
 "usage: %s [-BeikNnqrstWwX] \n"
 "            [-C directory] [-D variable] [-d flags] [-f makefile]\n"
 "            [-I directory] [-J private] [-j max_jobs] [-m directory] [-T file]\n"
 "            [-V variable] [-v variable] [variable=value] [target ...]\n",
 	    progname);
 	exit(2);
+}
 /*
  * realpath(3) can get expensive, cache results...
  */
 static GNode *cached_realpaths = NULL;
 static GNode *
 get_cached_realpaths(void)
+{
     if (!cached_realpaths) {
 	cached_realpaths = Targ_NewGN("Realpath");
 #ifndef DEBUG_REALPATH_CACHE
 	cached_realpaths->flags = INTERNAL;
 #endif
+    }
     return cached_realpaths;
+}
 /* purge any relative paths */
 static void
 purge_cached_realpaths(void)
+{
     GNode *cache = get_cached_realpaths();
     Hash_Entry *he, *nhe;
     Hash_Search hs;
     he = Hash_EnumFirst(&cache->context, &hs);
     while (he) {
 	nhe = Hash_EnumNext(&hs);
 	if (he->name[0] != '/') {
 	    if (DEBUG(DIR))
 		fprintf(stderr, "cached_realpath: purging %s\n", he->name);
 	    Hash_DeleteEntry(&cache->context, he);
+	}
 	he = nhe;
+    }
+}
 char *
 cached_realpath(const char *pathname, char *resolved)
+{
     GNode *cache;
     const char *rp;
     char *cp;
     if (!pathname || !pathname[0])
 	return NULL;
     cache = get_cached_realpaths();
     if ((rp = Var_Value(pathname, cache, &cp)) != NULL) {
 	/* a hit */
 	strncpy(resolved, rp, MAXPATHLEN);
 	resolved[MAXPATHLEN - 1] = '\0';
     } else if ((rp = realpath(pathname, resolved)) != NULL) {
 	Var_Set(pathname, rp, cache);
     } /* else should we negative-cache? */
     bmake_free(cp);
     return rp ? resolved : NULL;
+}
 int
 PrintAddr(void *a, void *b)
+{
     printf("%lx ", (unsigned long) a);
     return b ? 0 : 0;
+}
 static int
 addErrorCMD(void *cmdp, void *gnp)
+{
     if (cmdp == NULL)
 	return 1;			/* stop */
     Var_Append(".ERROR_CMD", cmdp, VAR_GLOBAL);
     return 0;
+}
 /*
  * Return true if we should die without noise.
  * For example our failing child was a sub-make
  * or failure happend elsewhere.
  */
 int
 dieQuietly(GNode *gn, int bf)
+{
     static int quietly = -1;
     if (quietly < 0) {
 	if (DEBUG(JOB) || getBoolean(".MAKE.DIE_QUIETLY", 1) == 0)
 	    quietly = 0;
 	else if (bf >= 0)
 	    quietly = bf;
 	else
 	    quietly = (gn) ? ((gn->type  & (OP_MAKE)) != 0) : 0;
+    }
     return quietly;
+}
 void
 PrintOnError(GNode *gn, const char *s)
+{
     static GNode *en = NULL;
     const char *expr;
     char *cp;
     if (DEBUG(HASH)) {
 	Targ_Stats();
 	Var_Stats();
+    }
     /* we generally want to keep quiet if a sub-make died */
     if (dieQuietly(gn, -1))
 	return;
     if (s)
 	printf("%s", s);
     printf("\n%s: stopped in %s\n", progname, curdir);
     if (en)
 	return;				/* we've been here! */
     if (gn) {
 	/*
 	 * We can print this even if there is no .ERROR target.
 	 */
 	Var_Set(".ERROR_TARGET", gn->name, VAR_GLOBAL);
 	Var_Delete(".ERROR_CMD", VAR_GLOBAL);
 	Lst_ForEach(gn->commands, addErrorCMD, gn);
+    }
     expr = "${MAKE_PRINT_VAR_ON_ERROR:@v@$v='${$v}'\n@}";
     cp = Var_Subst(expr, VAR_GLOBAL, VARE_WANTRES);
     if (cp) {
 	if (*cp)
 	    printf("%s", cp);
 	free(cp);
+    }
     fflush(stdout);
     /*
      * Finally, see if there is a .ERROR target, and run it if so.
      */
     en = Targ_FindNode(".ERROR", TARG_NOCREATE);
     if (en) {
 	en->type |= OP_SPECIAL;
 	Compat_Make(en, en);
+    }
+}
 void
 Main_ExportMAKEFLAGS(Boolean first)
+{
     static Boolean once = TRUE;
     const char *expr;
     char *s;
     if (once != first)
 	return;
     once = FALSE;
     expr = "${.MAKEFLAGS} ${.MAKEOVERRIDES:O:u:@v@$v=${$v:Q}@}";
     s = Var_Subst(expr, VAR_CMD, VARE_WANTRES);
     if (s[0] != '\0') {
 #ifdef POSIX
 	setenv("MAKEFLAGS", s, 1);
 #else
 	setenv("MAKE", s, 1);
 #endif
+    }
+}
 char *
 getTmpdir(void)
+{
     static char *tmpdir = NULL;
     if (!tmpdir) {
 	struct stat st;
 	/*
 	 * Honor $TMPDIR but only if it is valid.
 	 * Ensure it ends with /.
 	 */
 	tmpdir = Var_Subst("${TMPDIR:tA:U" _PATH_TMP "}/", VAR_GLOBAL,
 			   VARE_WANTRES);
 	if (stat(tmpdir, &st) < 0 || !S_ISDIR(st.st_mode)) {
 	    free(tmpdir);
 	    tmpdir = bmake_strdup(_PATH_TMP);
+	}
+    }
     return tmpdir;
+}
 /*
  * Create and open a temp file using "pattern".
  * If "fnamep" is provided set it to a copy of the filename created.
  * Otherwise unlink the file once open.
  */
 int
 mkTempFile(const char *pattern, char **fnamep)
+{
     static char *tmpdir = NULL;
     char tfile[MAXPATHLEN];
     int fd;
     if (!pattern)
 	pattern = TMPPAT;
     if (!tmpdir)
 	tmpdir = getTmpdir();
     if (pattern[0] == '/') {
 	snprintf(tfile, sizeof(tfile), "%s", pattern);
     } else {
 	snprintf(tfile, sizeof(tfile), "%s%s", tmpdir, pattern);
+    }
     if ((fd = mkstemp(tfile)) < 0)
 	Punt("Could not create temporary file %s: %s", tfile, strerror(errno));
     if (fnamep) {
 	*fnamep = bmake_strdup(tfile);
     } else {
 	unlink(tfile);			/* we just want the descriptor */
+    }
     return fd;
+}
 /*
  * Convert a string representation of a boolean.
  * Anything that looks like "No", "False", "Off", "0" etc,
  * is FALSE, otherwise TRUE.
  */
 Boolean
 s2Boolean(const char *s, Boolean bf)
+{
     if (s) {
 	switch(*s) {
 	case '\0':			/* not set - the default wins */
 	    break;
 	case '0':
 	case 'F':
 	case 'f':
 	case 'N':
 	case 'n':
 	    bf = FALSE;
 	    break;
 	case 'O':
 	case 'o':
 	    switch (s[1]) {
 	    case 'F':
 	    case 'f':
 		bf = FALSE;
 		break;
 	    default:
 		bf = TRUE;
 		break;
+	    }
 	    break;
 	default:
 	    bf = TRUE;
 	    break;
+	}
+    }
     return bf;
+}
 /*
  * Return a Boolean based on setting of a knob.
+ *
  * If the knob is not set, the supplied default is the return value.
  * If set, anything that looks or smells like "No", "False", "Off", "0" etc,
  * is FALSE, otherwise TRUE.
  */
 Boolean
 getBoolean(const char *name, Boolean bf)
+{
     char tmp[64];
     char *cp;
     if (snprintf(tmp, sizeof(tmp), "${%s:U:tl}", name) < (int)(sizeof(tmp))) {
 	cp = Var_Subst(tmp, VAR_GLOBAL, VARE_WANTRES);
 	if (cp) {
 	    bf = s2Boolean(cp, bf);
 	    free(cp);
+	}
+    }
     return bf;
+}

 @@ -1,1728 +1,1729 @@
-/*      $NetBSD: meta.c,v 1.109 2020/08/29 10:12:06 rillig Exp $ */
+/*      $NetBSD: meta.c,v 1.110 2020/08/29 10:41:12 rillig Exp $ */
 /*
  * Implement 'meta' mode.
  * Adapted from John Birrell's patches to FreeBSD make.
  * --sjg
  */
 /*
  * Copyright (c) 2009-2016, Juniper Networks, Inc.
  * Portions Copyright (c) 2009, John Birrell.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if defined(USE_META)
 #ifdef HAVE_CONFIG_H
 # include "config.h"
 #endif
 #include <sys/stat.h>
 #include <libgen.h>
 #include <errno.h>
 #if !defined(HAVE_CONFIG_H) || defined(HAVE_ERR_H)
 #include <err.h>
 #endif
 #include "make.h"
 #include "job.h"
 #ifdef USE_FILEMON
 #include "filemon/filemon.h"
 #endif
 static BuildMon Mybm;			/* for compat */
 static Lst metaBailiwick;		/* our scope of control */
 static char *metaBailiwickStr;		/* string storage for the list */
 static Lst metaIgnorePaths;		/* paths we deliberately ignore */
 static char *metaIgnorePathsStr;	/* string storage for the list */
 #ifndef MAKE_META_IGNORE_PATHS
 #define MAKE_META_IGNORE_PATHS ".MAKE.META.IGNORE_PATHS"
 #endif
 #ifndef MAKE_META_IGNORE_PATTERNS
 #define MAKE_META_IGNORE_PATTERNS ".MAKE.META.IGNORE_PATTERNS"
 #endif
 #ifndef MAKE_META_IGNORE_FILTER
 #define MAKE_META_IGNORE_FILTER ".MAKE.META.IGNORE_FILTER"
 #endif
 Boolean useMeta = FALSE;
 static Boolean useFilemon = FALSE;
 static Boolean writeMeta = FALSE;
 static Boolean metaMissing = FALSE;	/* oodate if missing */
 static Boolean filemonMissing = FALSE;	/* oodate if missing */
 static Boolean metaEnv = FALSE;		/* don't save env unless asked */
 static Boolean metaVerbose = FALSE;
 static Boolean metaIgnoreCMDs = FALSE;	/* ignore CMDs in .meta files */
 static Boolean metaIgnorePatterns = FALSE; /* do we need to do pattern matches */
 static Boolean metaIgnoreFilter = FALSE;   /* do we have more complex filtering? */
 static Boolean metaCurdirOk = FALSE;	/* write .meta in .CURDIR Ok? */
 static Boolean metaSilent = FALSE;	/* if we have a .meta be SILENT */
 extern Boolean forceJobs;
 extern Boolean comatMake;
 extern char    **environ;
 #define	MAKE_META_PREFIX	".MAKE.META.PREFIX"
 #ifndef N2U
 # define N2U(n, u)   (((n) + ((u) - 1)) / (u))
 #endif
 #ifndef ROUNDUP
 # define ROUNDUP(n, u)   (N2U((n), (u)) * (u))
 #endif
 #if !defined(HAVE_STRSEP)
 # define strsep(s, d) stresep((s), (d), 0)
 #endif
 /*
  * Filemon is a kernel module which snoops certain syscalls.
+ *
  * C chdir
  * E exec
  * F [v]fork
  * L [sym]link
  * M rename
  * R read
  * W write
  * S stat
+ *
  * See meta_oodate below - we mainly care about 'E' and 'R'.
+ *
  * We can still use meta mode without filemon, but
  * the benefits are more limited.
  */
 #ifdef USE_FILEMON
 /*
  * Open the filemon device.
  */
 static void
 meta_open_filemon(BuildMon *pbm)
+{
     int dupfd;
     pbm->mon_fd = -1;
     pbm->filemon = NULL;
     if (!useFilemon || !pbm->mfp)
 	return;
     pbm->filemon = filemon_open();
     if (pbm->filemon == NULL) {
 	useFilemon = FALSE;
 	warn("Could not open filemon %s", filemon_path());
 	return;
+    }
     /*
      * We use a file outside of '.'
      * to avoid a FreeBSD kernel bug where unlink invalidates
      * cwd causing getcwd to do a lot more work.
      * We only care about the descriptor.
      */
     pbm->mon_fd = mkTempFile("filemon.XXXXXX", NULL);
     if ((dupfd = dup(pbm->mon_fd)) == -1) {
 	err(1, "Could not dup filemon output!");
+    }
     (void)fcntl(dupfd, F_SETFD, FD_CLOEXEC);
     if (filemon_setfd(pbm->filemon, dupfd) == -1) {
 	err(1, "Could not set filemon file descriptor!");
+    }
     /* we don't need these once we exec */
     (void)fcntl(pbm->mon_fd, F_SETFD, FD_CLOEXEC);
+}
 /*
  * Read the build monitor output file and write records to the target's
  * metadata file.
  */
 static int
 filemon_read(FILE *mfp, int fd)
+{
     char buf[BUFSIZ];
     int n;
     int error;
     /* Check if we're not writing to a meta data file.*/
     if (mfp == NULL) {
 	if (fd >= 0)
 	    close(fd);			/* not interested */
 	return 0;
+    }
     /* rewind */
     if (lseek(fd, (off_t)0, SEEK_SET) < 0) {
 	error = errno;
 	warn("Could not rewind filemon");
 	fprintf(mfp, "\n");
     } else {
 	error = 0;
 	fprintf(mfp, "\n-- filemon acquired metadata --\n");
 	while ((n = read(fd, buf, sizeof(buf))) > 0) {
 	    if ((int)fwrite(buf, 1, n, mfp) < n)
 		error = EIO;
+	}
+    }
     fflush(mfp);
     if (close(fd) < 0)
 	error = errno;
     return error;
+}
 #endif
 /*
  * when realpath() fails,
  * we use this, to clean up ./ and ../
  */
 static void
 eat_dots(char *buf, size_t bufsz, int dots)
+{
     char *cp;
     char *cp2;
     const char *eat;
     size_t eatlen;
     switch (dots) {
     case 1:
 	eat = "/./";
 	eatlen = 2;
 	break;
     case 2:
 	eat = "/../";
 	eatlen = 3;
 	break;
     default:
 	return;
+    }
     do {
 	cp = strstr(buf, eat);
 	if (cp) {
 	    cp2 = cp + eatlen;
 	    if (dots == 2 && cp > buf) {
 		do {
 		    cp--;
 		} while (cp > buf && *cp != '/');
+	    }
 	    if (*cp == '/') {
 		strlcpy(cp, cp2, bufsz - (cp - buf));
 	    } else {
 		return;			/* can't happen? */
+	    }
+	}
     } while (cp);
+}
 static char *
 meta_name(struct GNode *gn, char *mname, size_t mnamelen,
 	  const char *dname,
 	  const char *tname,
 	  const char *cwd)
+{
     char buf[MAXPATHLEN];
     char *rp;
     char *cp;
     char *tp;
     char *dtp;
     size_t ldname;
     /*
      * Weed out relative paths from the target file name.
      * We have to be careful though since if target is a
      * symlink, the result will be unstable.
      * So we use realpath() just to get the dirname, and leave the
      * basename as given to us.
      */
     if ((cp = strrchr(tname, '/'))) {
 	if (cached_realpath(tname, buf)) {
 	    if ((rp = strrchr(buf, '/'))) {
 		rp++;
 		cp++;
 		if (strcmp(cp, rp) != 0)
 		    strlcpy(rp, cp, sizeof(buf) - (rp - buf));
+	    }
 	    tname = buf;
 	} else {
 	    /*
 	     * We likely have a directory which is about to be made.
 	     * We pretend realpath() succeeded, to have a chance
 	     * of generating the same meta file name that we will
 	     * next time through.
 	     */
 	    if (tname[0] == '/') {
 		strlcpy(buf, tname, sizeof(buf));
 	    } else {
 		snprintf(buf, sizeof(buf), "%s/%s", cwd, tname);
+	    }
 	    eat_dots(buf, sizeof(buf), 1);	/* ./ */
 	    eat_dots(buf, sizeof(buf), 2);	/* ../ */
 	    tname = buf;
+	}
+    }
     /* on some systems dirname may modify its arg */
     tp = bmake_strdup(tname);
     dtp = dirname(tp);
     if (strcmp(dname, dtp) == 0)
 	snprintf(mname, mnamelen, "%s.meta", tname);
     else {
 	ldname = strlen(dname);
 	if (strncmp(dname, dtp, ldname) == 0 && dtp[ldname] == '/')
 	    snprintf(mname, mnamelen, "%s/%s.meta", dname, &tname[ldname+1]);
 	else
 	    snprintf(mname, mnamelen, "%s/%s.meta", dname, tname);
 	/*
 	 * Replace path separators in the file name after the
 	 * current object directory path.
 	 */
 	cp = mname + strlen(dname) + 1;
 	while (*cp != '\0') {
 	    if (*cp == '/')
 		*cp = '_';
 	    cp++;
+	}
+    }
     free(tp);
     return mname;
+}
 /*
  * Return true if running ${.MAKE}
  * Bypassed if target is flagged .MAKE
  */
 static int
 is_submake(void *cmdp, void *gnp)
+{
     static const char *p_make = NULL;
     static int p_len;
     char  *cmd = cmdp;
     GNode *gn = gnp;
     char *mp = NULL;
     char *cp;
     char *cp2;
     int rc = 0;				/* keep looking */
     if (!p_make) {
 	p_make = Var_Value(".MAKE", gn, &cp);
 	p_len = strlen(p_make);
+    }
     cp = strchr(cmd, '$');
     if ((cp)) {
 	mp = Var_Subst(cmd, gn, VARE_WANTRES);
 	cmd = mp;
+    }
     cp2 = strstr(cmd, p_make);
     if ((cp2)) {
 	switch (cp2[p_len]) {
 	case '\0':
 	case ' ':
 	case '\t':
 	case '\n':
 	    rc = 1;
 	    break;
+	}
 	if (cp2 > cmd && rc > 0) {
 	    switch (cp2[-1]) {
 	    case ' ':
 	    case '\t':
 	    case '\n':
 		break;
 	    default:
 		rc = 0;			/* no match */
 		break;
+	    }
+	}
+    }
     free(mp);
     return rc;
+}
 typedef struct meta_file_s {
     FILE *fp;
     GNode *gn;
 } meta_file_t;
 static int
 printCMD(void *cmdp, void *mfpp)
+{
     meta_file_t *mfp = mfpp;
     char *cmd = cmdp;
     char *cp = NULL;
     if (strchr(cmd, '$')) {
 	cmd = cp = Var_Subst(cmd, mfp->gn, VARE_WANTRES);
+    }
     fprintf(mfp->fp, "CMD %s\n", cmd);
     free(cp);
     return 0;
+}
 /*
  * Certain node types never get a .meta file
  */
 #define SKIP_META_TYPE(_type) do { \
     if ((gn->type & __CONCAT(OP_, _type))) {	\
 	if (verbose) { \
 	    fprintf(debug_file, "Skipping meta for %s: .%s\n", \
 		    gn->name, __STRING(_type));		       \
 	} \
 	return FALSE; \
     } \
 } while (0)
 /*
  * Do we need/want a .meta file ?
  */
 static Boolean
 meta_needed(GNode *gn, const char *dname, const char *tname,
 	     char *objdir, int verbose)
+{
     struct stat fs;
     if (verbose)
 	verbose = DEBUG(META);
     /* This may be a phony node which we don't want meta data for... */
     /* Skip .meta for .BEGIN, .END, .ERROR etc as well. */
     /* Or it may be explicitly flagged as .NOMETA */
     SKIP_META_TYPE(NOMETA);
     /* Unless it is explicitly flagged as .META */
     if (!(gn->type & OP_META)) {
 	SKIP_META_TYPE(PHONY);
 	SKIP_META_TYPE(SPECIAL);
 	SKIP_META_TYPE(MAKE);
+    }
     /* Check if there are no commands to execute. */
     if (Lst_IsEmpty(gn->commands)) {
 	if (verbose)
 	    fprintf(debug_file, "Skipping meta for %s: no commands\n",
 		    gn->name);
 	return FALSE;
+    }
     if ((gn->type & (OP_META|OP_SUBMAKE)) == OP_SUBMAKE) {
 	/* OP_SUBMAKE is a bit too aggressive */
 	if (Lst_ForEach(gn->commands, is_submake, gn)) {
 	    if (DEBUG(META))
 		fprintf(debug_file, "Skipping meta for %s: .SUBMAKE\n",
 			gn->name);
 	    return FALSE;
+	}
+    }
     /* The object directory may not exist. Check it.. */
     if (cached_stat(dname, &fs) != 0) {
 	if (verbose)
 	    fprintf(debug_file, "Skipping meta for %s: no .OBJDIR\n",
 		    gn->name);
 	return FALSE;
+    }
     /* make sure these are canonical */
     if (cached_realpath(dname, objdir))
 	dname = objdir;
     /* If we aren't in the object directory, don't create a meta file. */
     if (!metaCurdirOk && strcmp(curdir, dname) == 0) {
 	if (verbose)
 	    fprintf(debug_file, "Skipping meta for %s: .OBJDIR == .CURDIR\n",
 		    gn->name);
 	return FALSE;
+    }
     return TRUE;
+}
 static FILE *
 meta_create(BuildMon *pbm, GNode *gn)
+{
     meta_file_t mf;
     char buf[MAXPATHLEN];
     char objdir[MAXPATHLEN];
     char **ptr;
     const char *dname;
     const char *tname;
     char *fname;
     const char *cp;
     char *p[5];				/* >= possible uses */
     int i;
     mf.fp = NULL;
     i = 0;
     dname = Var_Value(".OBJDIR", gn, &p[i++]);
     tname = Var_Value(TARGET, gn, &p[i++]);
     /* if this succeeds objdir is realpath of dname */
     if (!meta_needed(gn, dname, tname, objdir, TRUE))
 	goto out;
     dname = objdir;
     if (metaVerbose) {
 	char *mp;
 	/* Describe the target we are building */
 	mp = Var_Subst("${" MAKE_META_PREFIX "}", gn, VARE_WANTRES);
 	if (*mp)
 	    fprintf(stdout, "%s\n", mp);
 	free(mp);
+    }
     /* Get the basename of the target */
     if ((cp = strrchr(tname, '/')) == NULL) {
 	cp = tname;
     } else {
 	cp++;
+    }
     fflush(stdout);
     if (!writeMeta)
 	/* Don't create meta data. */
 	goto out;
     fname = meta_name(gn, pbm->meta_fname, sizeof(pbm->meta_fname),
 		      dname, tname, objdir);
 #ifdef DEBUG_META_MODE
     if (DEBUG(META))
 	fprintf(debug_file, "meta_create: %s\n", fname);
 #endif
     if ((mf.fp = fopen(fname, "w")) == NULL)
 	err(1, "Could not open meta file '%s'", fname);
     fprintf(mf.fp, "# Meta data file %s\n", fname);
     mf.gn = gn;
     Lst_ForEach(gn->commands, printCMD, &mf);
     fprintf(mf.fp, "CWD %s\n", getcwd(buf, sizeof(buf)));
     fprintf(mf.fp, "TARGET %s\n", tname);
     cp = Var_Value(".OODATE", gn, &p[i++]);
     if (cp && *cp) {
 	    fprintf(mf.fp, "OODATE %s\n", cp);
+    }
     if (metaEnv) {
 	for (ptr = environ; *ptr != NULL; ptr++)
 	    fprintf(mf.fp, "ENV %s\n", *ptr);
+    }
     fprintf(mf.fp, "-- command output --\n");
     fflush(mf.fp);
     Var_Append(".MAKE.META.FILES", fname, VAR_GLOBAL);
     Var_Append(".MAKE.META.CREATED", fname, VAR_GLOBAL);
     gn->type |= OP_META;		/* in case anyone wants to know */
     if (metaSilent) {
 	    gn->type |= OP_SILENT;
+    }
  out:
     for (i--; i >= 0; i--) {
 	bmake_free(p[i]);
+    }
     return mf.fp;
+}
 static Boolean
 boolValue(char *s)
+{
     switch(*s) {
     case '0':
     case 'N':
     case 'n':
     case 'F':
     case 'f':
 	return FALSE;
+    }
     return TRUE;
+}
 /*
  * Initialization we need before reading makefiles.
  */
 void
 meta_init(void)
+{
 #ifdef USE_FILEMON
 	/* this allows makefiles to test if we have filemon support */
 	Var_Set(".MAKE.PATH_FILEMON", filemon_path(), VAR_GLOBAL);
 #endif
+}
 #define get_mode_bf(bf, token) \
     if ((cp = strstr(make_mode, token))) \
 	bf = boolValue(&cp[sizeof(token) - 1])
 /*
  * Initialization we need after reading makefiles.
  */
 void
 meta_mode_init(const char *make_mode)
+{
     static int once = 0;
     char *cp;
     useMeta = TRUE;
     useFilemon = TRUE;
     writeMeta = TRUE;
     if (make_mode) {
 	if (strstr(make_mode, "env"))
 	    metaEnv = TRUE;
 	if (strstr(make_mode, "verb"))
 	    metaVerbose = TRUE;
 	if (strstr(make_mode, "read"))
 	    writeMeta = FALSE;
 	if (strstr(make_mode, "nofilemon"))
 	    useFilemon = FALSE;
 	if (strstr(make_mode, "ignore-cmd"))
 	    metaIgnoreCMDs = TRUE;
 	if (useFilemon)
 	    get_mode_bf(filemonMissing, "missing-filemon=");
 	get_mode_bf(metaCurdirOk, "curdirok=");
 	get_mode_bf(metaMissing, "missing-meta=");
 	get_mode_bf(metaSilent, "silent=");
+    }
     if (metaVerbose && !Var_Exists(MAKE_META_PREFIX, VAR_GLOBAL)) {
 	/*
 	 * The default value for MAKE_META_PREFIX
 	 * prints the absolute path of the target.
 	 * This works be cause :H will generate '.' if there is no /
 	 * and :tA will resolve that to cwd.
 	 */
 	Var_Set(MAKE_META_PREFIX, "Building ${.TARGET:H:tA}/${.TARGET:T}", VAR_GLOBAL);
+    }
     if (once)
 	return;
     once = 1;
     memset(&Mybm, 0, sizeof(Mybm));
     /*
      * We consider ourselves master of all within ${.MAKE.META.BAILIWICK}
      */
     metaBailiwick = Lst_Init();
     metaBailiwickStr = Var_Subst("${.MAKE.META.BAILIWICK:O:u:tA}",
 	VAR_GLOBAL, VARE_WANTRES);
     if (metaBailiwickStr) {
 	str2Lst_Append(metaBailiwick, metaBailiwickStr, NULL);
+    }
     /*
      * We ignore any paths that start with ${.MAKE.META.IGNORE_PATHS}
      */
     metaIgnorePaths = Lst_Init();
     Var_Append(MAKE_META_IGNORE_PATHS,
 	       "/dev /etc /proc /tmp /var/run /var/tmp ${TMPDIR}", VAR_GLOBAL);
     metaIgnorePathsStr = Var_Subst("${" MAKE_META_IGNORE_PATHS ":O:u:tA}",
 				   VAR_GLOBAL, VARE_WANTRES);
     if (metaIgnorePathsStr) {
 	str2Lst_Append(metaIgnorePaths, metaIgnorePathsStr, NULL);
+    }
     /*
      * We ignore any paths that match ${.MAKE.META.IGNORE_PATTERNS}
      */
     cp = NULL;
     if (Var_Value(MAKE_META_IGNORE_PATTERNS, VAR_GLOBAL, &cp)) {
 	metaIgnorePatterns = TRUE;
 	bmake_free(cp);
+    }
     cp = NULL;
     if (Var_Value(MAKE_META_IGNORE_FILTER, VAR_GLOBAL, &cp)) {
 	metaIgnoreFilter = TRUE;
 	bmake_free(cp);
+    }
+}
 /*
  * In each case below we allow for job==NULL
  */
 void
 meta_job_start(Job *job, GNode *gn)
+{
     BuildMon *pbm;
     if (job != NULL) {
 	pbm = &job->bm;
     } else {
 	pbm = &Mybm;
+    }
     pbm->mfp = meta_create(pbm, gn);
 #ifdef USE_FILEMON_ONCE
     /* compat mode we open the filemon dev once per command */
     if (job == NULL)
 	return;
 #endif
 #ifdef USE_FILEMON
     if (pbm->mfp != NULL && useFilemon) {
 	meta_open_filemon(pbm);
     } else {
 	pbm->mon_fd = -1;
 	pbm->filemon = NULL;
+    }
 #endif
+}
 /*
  * The child calls this before doing anything.
  * It does not disturb our state.
  */
 void
 meta_job_child(Job *job)
+{
 #ifdef USE_FILEMON
     BuildMon *pbm;
     if (job != NULL) {
 	pbm = &job->bm;
     } else {
 	pbm = &Mybm;
+    }
     if (pbm->mfp != NULL) {
 	close(fileno(pbm->mfp));
 	if (useFilemon && pbm->filemon) {
 	    pid_t pid;
 	    pid = getpid();
 	    if (filemon_setpid_child(pbm->filemon, pid) == -1) {
 		err(1, "Could not set filemon pid!");
+	    }
+	}
+    }
 #endif
+}
 void
 meta_job_parent(Job *job, pid_t pid)
+{
 #if defined(USE_FILEMON) && !defined(USE_FILEMON_DEV)
     BuildMon *pbm;
     if (job != NULL) {
 	pbm = &job->bm;
     } else {
 	pbm = &Mybm;
+    }
     if (useFilemon && pbm->filemon) {
 	filemon_setpid_parent(pbm->filemon, pid);
+    }
 #endif
+}
 int
 meta_job_fd(Job *job)
+{
 #if defined(USE_FILEMON) && !defined(USE_FILEMON_DEV)
     BuildMon *pbm;
     if (job != NULL) {
 	pbm = &job->bm;
     } else {
 	pbm = &Mybm;
+    }
     if (useFilemon && pbm->filemon) {
 	return filemon_readfd(pbm->filemon);
+    }
 #endif
     return -1;
+}
 int
 meta_job_event(Job *job)
+{
 #if defined(USE_FILEMON) && !defined(USE_FILEMON_DEV)
     BuildMon *pbm;
     if (job != NULL) {
 	pbm = &job->bm;
     } else {
 	pbm = &Mybm;
+    }
     if (useFilemon && pbm->filemon) {
 	return filemon_process(pbm->filemon);
+    }
 #endif
     return 0;
+}
 void
 meta_job_error(Job *job, GNode *gn, int flags, int status)
+{
     char cwd[MAXPATHLEN];
     BuildMon *pbm;
     if (job != NULL) {
 	pbm = &job->bm;
 	if (!gn)
 	    gn = job->node;
     } else {
 	pbm = &Mybm;
+    }
     if (pbm->mfp != NULL) {
 	fprintf(pbm->mfp, "\n*** Error code %d%s\n",
 		status,
 		(flags & JOB_IGNERR) ?
 		"(ignored)" : "");
+    }
     if (gn) {
 	Var_Set(".ERROR_TARGET", gn->path ? gn->path : gn->name, VAR_GLOBAL);
+    }
     getcwd(cwd, sizeof(cwd));
     Var_Set(".ERROR_CWD", cwd, VAR_GLOBAL);
     if (pbm->meta_fname[0]) {
 	Var_Set(".ERROR_META_FILE", pbm->meta_fname, VAR_GLOBAL);
+    }
     meta_job_finish(job);
+}
 void
 meta_job_output(Job *job, char *cp, const char *nl)
+{
     BuildMon *pbm;
     if (job != NULL) {
 	pbm = &job->bm;
     } else {
 	pbm = &Mybm;
+    }
     if (pbm->mfp != NULL) {
 	if (metaVerbose) {
 	    static char *meta_prefix = NULL;
 	    static int meta_prefix_len;
 	    if (!meta_prefix) {
 		char *cp2;
 		meta_prefix = Var_Subst("${" MAKE_META_PREFIX "}",
 					VAR_GLOBAL, VARE_WANTRES);
 		if ((cp2 = strchr(meta_prefix, '$')))
 		    meta_prefix_len = cp2 - meta_prefix;
 		else
 		    meta_prefix_len = strlen(meta_prefix);
+	    }
 	    if (strncmp(cp, meta_prefix, meta_prefix_len) == 0) {
 		cp = strchr(cp+1, '\n');
 		if (!cp++)
 		    return;
+	    }
+	}
 	fprintf(pbm->mfp, "%s%s", cp, nl);
+    }
+}
 int
 meta_cmd_finish(void *pbmp)
+{
     int error = 0;
     BuildMon *pbm = pbmp;
 #ifdef USE_FILEMON
     int x;
 #endif
     if (!pbm)
 	pbm = &Mybm;
 #ifdef USE_FILEMON
     if (pbm->filemon) {
 	while (filemon_process(pbm->filemon) > 0)
 	    continue;
 	if (filemon_close(pbm->filemon) == -1)
 	    error = errno;
 	x = filemon_read(pbm->mfp, pbm->mon_fd);
 	if (error == 0 && x != 0)
 	    error = x;
 	pbm->mon_fd = -1;
 	pbm->filemon = NULL;
     } else
 #endif
 	fprintf(pbm->mfp, "\n");	/* ensure end with newline */
     return error;
+}
 int
 meta_job_finish(Job *job)
+{
     BuildMon *pbm;
     int error = 0;
     int x;
     if (job != NULL) {
 	pbm = &job->bm;
     } else {
 	pbm = &Mybm;
+    }
     if (pbm->mfp != NULL) {
 	error = meta_cmd_finish(pbm);
 	x = fclose(pbm->mfp);
 	if (error == 0 && x != 0)
 	    error = errno;
 	pbm->mfp = NULL;
 	pbm->meta_fname[0] = '\0';
+    }
     return error;
+}
 void
 meta_finish(void)
+{
     if (metaBailiwick != NULL)
 	Lst_Free(metaBailiwick);
     free(metaBailiwickStr);
     if (metaIgnorePaths != NULL)
 	Lst_Free(metaIgnorePaths);
     free(metaIgnorePathsStr);
+}
 /*
  * Fetch a full line from fp - growing bufp if needed
  * Return length in bufp.
  */
 static int
 fgetLine(char **bufp, size_t *szp, int o, FILE *fp)
+{
     char *buf = *bufp;
     size_t bufsz = *szp;
     struct stat fs;
     int x;
     if (fgets(&buf[o], bufsz - o, fp) != NULL) {
     check_newline:
 	x = o + strlen(&buf[o]);
 	if (buf[x - 1] == '\n')
 	    return x;
 	/*
 	 * We need to grow the buffer.
 	 * The meta file can give us a clue.
 	 */
 	if (fstat(fileno(fp), &fs) == 0) {
 	    size_t newsz;
 	    char *p;
 	    newsz = ROUNDUP((fs.st_size / 2), BUFSIZ);
 	    if (newsz <= bufsz)
 		newsz = ROUNDUP(fs.st_size, BUFSIZ);
 	    if (newsz <= bufsz)
 		return x;		/* truncated */
 	    if (DEBUG(META))
 		fprintf(debug_file, "growing buffer %zu -> %zu\n",
 			bufsz, newsz);
 	    p = bmake_realloc(buf, newsz);
 	    if (p) {
 		*bufp = buf = p;
 		*szp = bufsz = newsz;
 		/* fetch the rest */
 		if (!fgets(&buf[x], bufsz - x, fp))
 		    return x;		/* truncated! */
 		goto check_newline;
+	    }
+	}
+    }
     return 0;
+}
 /* Lst_ForEach wants 1 to stop search */
 static int
 prefix_match(void *p, void *q)
+{
     const char *prefix = p;
     const char *path = q;
     size_t n = strlen(prefix);
     return strncmp(path, prefix, n) == 0;
+}
 /* See if the path equals prefix or starts with "prefix/". */
 static Boolean
 path_match(const void *p, const void *q)
+{
     const char *path = p;
     const char *prefix = q;
     size_t n = strlen(prefix);
     if (strncmp(path, prefix, n) != 0)
         return FALSE;
     return path[n] == '\0' || path[n] == '/';
+}
 static Boolean
 string_match(const void *p, const void *q)
+{
     return strcmp(p, q) == 0;
+}
 static int
 meta_ignore(GNode *gn, const char *p)
+{
     char fname[MAXPATHLEN];
     if (p == NULL)
 	return TRUE;
     if (*p == '/') {
 	cached_realpath(p, fname); /* clean it up */
 	if (Lst_ForEach(metaIgnorePaths, prefix_match, fname)) {
 #ifdef DEBUG_META_MODE
 	    if (DEBUG(META))
 		fprintf(debug_file, "meta_oodate: ignoring path: %s\n",
 			p);
 #endif
 	    return TRUE;
+	}
+    }
     if (metaIgnorePatterns) {
 	const char *expr;
 	char *pm;
 	Var_Set(".p.", p, gn);
 	expr = "${" MAKE_META_IGNORE_PATTERNS ":@m@${.p.:M$m}@}";
 	pm = Var_Subst(expr, gn, VARE_WANTRES);
 	if (*pm) {
 #ifdef DEBUG_META_MODE
 	    if (DEBUG(META))
 		fprintf(debug_file, "meta_oodate: ignoring pattern: %s\n",
 			p);
 #endif
 	    free(pm);
 	    return TRUE;
+	}
 	free(pm);
+    }
     if (metaIgnoreFilter) {
 	char *fm;
 	/* skip if filter result is empty */
 	snprintf(fname, sizeof(fname),
 		 "${%s:L:${%s:ts:}}",
 		 p, MAKE_META_IGNORE_FILTER);
 	fm = Var_Subst(fname, gn, VARE_WANTRES);
 	if (*fm == '\0') {
 #ifdef DEBUG_META_MODE
 	    if (DEBUG(META))
 		fprintf(debug_file, "meta_oodate: ignoring filtered: %s\n",
 			p);
 #endif
 	    free(fm);
 	    return TRUE;
+	}
 	free(fm);
+    }
     return FALSE;
+}
 /*
  * When running with 'meta' functionality, a target can be out-of-date
  * if any of the references in its meta data file is more recent.
  * We have to track the latestdir on a per-process basis.
  */
 #define LCWD_VNAME_FMT ".meta.%d.lcwd"
 #define LDIR_VNAME_FMT ".meta.%d.ldir"
 /*
  * It is possible that a .meta file is corrupted,
  * if we detect this we want to reproduce it.
  * Setting oodate TRUE will have that effect.
  */
 #define CHECK_VALID_META(p) if (!(p && *p)) { \
     warnx("%s: %d: malformed", fname, lineno); \
     oodate = TRUE; \
     continue; \
+    }
 #define DEQUOTE(p) if (*p == '\'') {	\
     char *ep; \
     p++; \
     if ((ep = strchr(p, '\''))) \
 	*ep = '\0'; \
+    }
 Boolean
 meta_oodate(GNode *gn, Boolean oodate)
+{
     static char *tmpdir = NULL;
     static char cwd[MAXPATHLEN];
     char lcwd_vname[64];
     char ldir_vname[64];
     char lcwd[MAXPATHLEN];
     char latestdir[MAXPATHLEN];
     char fname[MAXPATHLEN];
     char fname1[MAXPATHLEN];
     char fname2[MAXPATHLEN];
     char fname3[MAXPATHLEN];
     const char *dname;
     const char *tname;
     char *p;
     char *cp;
     char *link_src;
     char *move_target;
     static size_t cwdlen = 0;
     static size_t tmplen = 0;
     FILE *fp;
     Boolean needOODATE = FALSE;
     Lst missingFiles;
     char *pa[4];			/* >= possible uses */
     int i;
     int have_filemon = FALSE;
     if (oodate)
 	return oodate;		/* we're done */
     i = 0;
     dname = Var_Value(".OBJDIR", gn, &pa[i++]);
     tname = Var_Value(TARGET, gn, &pa[i++]);
     /* if this succeeds fname3 is realpath of dname */
     if (!meta_needed(gn, dname, tname, fname3, FALSE))
 	goto oodate_out;
     dname = fname3;
     missingFiles = Lst_Init();
     /*
      * We need to check if the target is out-of-date. This includes
      * checking if the expanded command has changed. This in turn
      * requires that all variables are set in the same way that they
      * would be if the target needs to be re-built.
      */
     Make_DoAllVar(gn);
     meta_name(gn, fname, sizeof(fname), dname, tname, dname);
 #ifdef DEBUG_META_MODE
     if (DEBUG(META))
 	fprintf(debug_file, "meta_oodate: %s\n", fname);
 #endif
     if ((fp = fopen(fname, "r")) != NULL) {
 	static char *buf = NULL;
 	static size_t bufsz;
 	int lineno = 0;
 	int lastpid = 0;
 	int pid;
 	int x;
 	LstNode ln;
 	struct stat fs;
 	if (!buf) {
 	    bufsz = 8 * BUFSIZ;
 	    buf = bmake_malloc(bufsz);
+	}
 	if (!cwdlen) {
 	    if (getcwd(cwd, sizeof(cwd)) == NULL)
 		err(1, "Could not get current working directory");
 	    cwdlen = strlen(cwd);
+	}
 	strlcpy(lcwd, cwd, sizeof(lcwd));
 	strlcpy(latestdir, cwd, sizeof(latestdir));
 	if (!tmpdir) {
 	    tmpdir = getTmpdir();
 	    tmplen = strlen(tmpdir);
+	}
 	/* we want to track all the .meta we read */
 	Var_Append(".MAKE.META.FILES", fname, VAR_GLOBAL);
 	ln = Lst_First(gn->commands);
 	while (!oodate && (x = fgetLine(&buf, &bufsz, 0, fp)) > 0) {
 	    lineno++;
 	    if (buf[x - 1] == '\n')
 		buf[x - 1] = '\0';
 	    else {
 		warnx("%s: %d: line truncated at %u", fname, lineno, x);
 		oodate = TRUE;
 		break;
+	    }
 	    link_src = NULL;
 	    move_target = NULL;
 	    /* Find the start of the build monitor section. */
 	    if (!have_filemon) {
 		if (strncmp(buf, "-- filemon", 10) == 0) {
 		    have_filemon = TRUE;
 		    continue;
+		}
 		if (strncmp(buf, "# buildmon", 10) == 0) {
 		    have_filemon = TRUE;
 		    continue;
+		}
+	    }
 	    /* Delimit the record type. */
 	    p = buf;
 #ifdef DEBUG_META_MODE
 	    if (DEBUG(META))
 		fprintf(debug_file, "%s: %d: %s\n", fname, lineno, buf);
 #endif
 	    strsep(&p, " ");
 	    if (have_filemon) {
 		/*
 		 * We are in the 'filemon' output section.
 		 * Each record from filemon follows the general form:
+		 *
 		 * <key> <pid> <data>
+		 *
 		 * Where:
 		 * <key> is a single letter, denoting the syscall.
 		 * <pid> is the process that made the syscall.
 		 * <data> is the arguments (of interest).
 		 */
 		switch(buf[0]) {
 		case '#':		/* comment */
 		case 'V':		/* version */
 		    break;
 		default:
 		    /*
 		     * We need to track pathnames per-process.
+		     *
 		     * Each process run by make, starts off in the 'CWD'
 		     * recorded in the .meta file, if it chdirs ('C')
 		     * elsewhere we need to track that - but only for
 		     * that process.  If it forks ('F'), we initialize
 		     * the child to have the same cwd as its parent.
+		     *
 		     * We also need to track the 'latestdir' of
 		     * interest.  This is usually the same as cwd, but
 		     * not if a process is reading directories.
+		     *
 		     * Each time we spot a different process ('pid')
 		     * we save the current value of 'latestdir' in a
 		     * variable qualified by 'lastpid', and
 		     * re-initialize 'latestdir' to any pre-saved
 		     * value for the current 'pid' and 'CWD' if none.
 		     */
 		    CHECK_VALID_META(p);
 		    pid = atoi(p);
 		    if (pid > 0 && pid != lastpid) {
 			const char *ldir;
 			char *tp;
 			if (lastpid > 0) {
 			    /* We need to remember these. */
 			    Var_Set(lcwd_vname, lcwd, VAR_GLOBAL);
 			    Var_Set(ldir_vname, latestdir, VAR_GLOBAL);
+			}
 			snprintf(lcwd_vname, sizeof(lcwd_vname), LCWD_VNAME_FMT, pid);
 			snprintf(ldir_vname, sizeof(ldir_vname), LDIR_VNAME_FMT, pid);
 			lastpid = pid;
 			ldir = Var_Value(ldir_vname, VAR_GLOBAL, &tp);
 			if (ldir) {
 			    strlcpy(latestdir, ldir, sizeof(latestdir));
 			    bmake_free(tp);
+			}
 			ldir = Var_Value(lcwd_vname, VAR_GLOBAL, &tp);
 			if (ldir) {
 			    strlcpy(lcwd, ldir, sizeof(lcwd));
 			    bmake_free(tp);
+			}
+		    }
 		    /* Skip past the pid. */
 		    if (strsep(&p, " ") == NULL)
 			continue;
 #ifdef DEBUG_META_MODE
 		    if (DEBUG(META))
 			    fprintf(debug_file, "%s: %d: %d: %c: cwd=%s lcwd=%s ldir=%s\n",
 				    fname, lineno,
 				    pid, buf[0], cwd, lcwd, latestdir);
 #endif
 		    break;
+		}
 		CHECK_VALID_META(p);
 		/* Process according to record type. */
 		switch (buf[0]) {
 		case 'X':		/* eXit */
 		    Var_Delete(lcwd_vname, VAR_GLOBAL);
 		    Var_Delete(ldir_vname, VAR_GLOBAL);
 		    lastpid = 0;	/* no need to save ldir_vname */
 		    break;
 		case 'F':		/* [v]Fork */
+		    {
 			char cldir[64];
 			int child;
 			child = atoi(p);
 			if (child > 0) {
 			    snprintf(cldir, sizeof(cldir), LCWD_VNAME_FMT, child);
 			    Var_Set(cldir, lcwd, VAR_GLOBAL);
 			    snprintf(cldir, sizeof(cldir), LDIR_VNAME_FMT, child);
 			    Var_Set(cldir, latestdir, VAR_GLOBAL);
 #ifdef DEBUG_META_MODE
 			    if (DEBUG(META))
 				    fprintf(debug_file, "%s: %d: %d: cwd=%s lcwd=%s ldir=%s\n",
 					    fname, lineno,
 					    child, cwd, lcwd, latestdir);
 #endif
+			}
+		    }
 		    break;
 		case 'C':		/* Chdir */
 		    /* Update lcwd and latest directory. */
 		    strlcpy(latestdir, p, sizeof(latestdir));
 		    strlcpy(lcwd, p, sizeof(lcwd));
 		    Var_Set(lcwd_vname, lcwd, VAR_GLOBAL);
 		    Var_Set(ldir_vname, lcwd, VAR_GLOBAL);
 #ifdef DEBUG_META_MODE
 		    if (DEBUG(META))
 			fprintf(debug_file, "%s: %d: cwd=%s ldir=%s\n", fname, lineno, cwd, lcwd);
 #endif
 		    break;
 		case 'M':		/* renaMe */
 		    /*
 		     * For 'M'oves we want to check
 		     * the src as for 'R'ead
 		     * and the target as for 'W'rite.
 		     */
 		    cp = p;		/* save this for a second */
 		    /* now get target */
 		    if (strsep(&p, " ") == NULL)
 			continue;
 		    CHECK_VALID_META(p);
 		    move_target = p;
 		    p = cp;
 		    /* 'L' and 'M' put single quotes around the args */
 		    DEQUOTE(p);
 		    DEQUOTE(move_target);
 		    /* FALLTHROUGH */
 		case 'D':		/* unlink */
 		    if (*p == '/' && !Lst_IsEmpty(missingFiles)) {
 			/* remove any missingFiles entries that match p */
 			ln = Lst_Find(missingFiles, path_match, p);
 			if (ln != NULL) {
 			    LstNode nln;
 			    char *tp;
 			    do {
-				nln = Lst_FindFrom(missingFiles, Lst_Succ(ln),
+				nln = Lst_FindFrom(missingFiles,
-						    path_match, p);
+						   LstNode_Next(ln),
 						   path_match, p);
 				tp = Lst_Datum(ln);
 				Lst_Remove(missingFiles, ln);
 				free(tp);
 			    } while ((ln = nln) != NULL);
+			}
+		    }
 		    if (buf[0] == 'M') {
 			/* the target of the mv is a file 'W'ritten */
 #ifdef DEBUG_META_MODE
 			if (DEBUG(META))
 			    fprintf(debug_file, "meta_oodate: M %s -> %s\n",
 				    p, move_target);
 #endif
 			p = move_target;
 			goto check_write;
+		    }
 		    break;
 		case 'L':		/* Link */
 		    /*
 		     * For 'L'inks check
 		     * the src as for 'R'ead
 		     * and the target as for 'W'rite.
 		     */
 		    link_src = p;
 		    /* now get target */
 		    if (strsep(&p, " ") == NULL)
 			continue;
 		    CHECK_VALID_META(p);
 		    /* 'L' and 'M' put single quotes around the args */
 		    DEQUOTE(p);
 		    DEQUOTE(link_src);
 #ifdef DEBUG_META_MODE
 		    if (DEBUG(META))
 			fprintf(debug_file, "meta_oodate: L %s -> %s\n",
 				link_src, p);
 #endif
 		    /* FALLTHROUGH */
 		case 'W':		/* Write */
 		check_write:
 		    /*
 		     * If a file we generated within our bailiwick
 		     * but outside of .OBJDIR is missing,
 		     * we need to do it again.
 		     */
 		    /* ignore non-absolute paths */
 		    if (*p != '/')
 			break;
 		    if (Lst_IsEmpty(metaBailiwick))
 			break;
 		    /* ignore cwd - normal dependencies handle those */
 		    if (strncmp(p, cwd, cwdlen) == 0)
 			break;
 		    if (!Lst_ForEach(metaBailiwick, prefix_match, p))
 			break;
 		    /* tmpdir might be within */
 		    if (tmplen > 0 && strncmp(p, tmpdir, tmplen) == 0)
 			break;
 		    /* ignore anything containing the string "tmp" */
 		    if ((strstr("tmp", p)))
 			break;
 		    if ((link_src != NULL && cached_lstat(p, &fs) < 0) ||
 			(link_src == NULL && cached_stat(p, &fs) < 0)) {
 			if (!meta_ignore(gn, p)) {
 			    if (Lst_Find(missingFiles, string_match, p) == NULL)
 				Lst_Append(missingFiles, bmake_strdup(p));
+			}
+		    }
 		    break;
 		check_link_src:
 		    p = link_src;
 		    link_src = NULL;
 #ifdef DEBUG_META_MODE
 		    if (DEBUG(META))
 			fprintf(debug_file, "meta_oodate: L src %s\n", p);
 #endif
 		    /* FALLTHROUGH */
 		case 'R':		/* Read */
 		case 'E':		/* Exec */
 		    /*
 		     * Check for runtime files that can't
 		     * be part of the dependencies because
 		     * they are _expected_ to change.
 		     */
 		    if (meta_ignore(gn, p))
 			break;
 		    /*
 		     * The rest of the record is the file name.
 		     * Check if it's not an absolute path.
 		     */
+		    {
 			char *sdirs[4];
 			char **sdp;
 			int sdx = 0;
 			int found = 0;
 			if (*p == '/') {
 			    sdirs[sdx++] = p; /* done */
 			} else {
 			    if (strcmp(".", p) == 0)
 				continue;  /* no point */
 			    /* Check vs latestdir */
 			    snprintf(fname1, sizeof(fname1), "%s/%s", latestdir, p);
 			    sdirs[sdx++] = fname1;
 			    if (strcmp(latestdir, lcwd) != 0) {
 				/* Check vs lcwd */
 				snprintf(fname2, sizeof(fname2), "%s/%s", lcwd, p);
 				sdirs[sdx++] = fname2;
+			    }
 			    if (strcmp(lcwd, cwd) != 0) {
 				/* Check vs cwd */
 				snprintf(fname3, sizeof(fname3), "%s/%s", cwd, p);
 				sdirs[sdx++] = fname3;
+			    }
+			}
 			sdirs[sdx++] = NULL;
 			for (sdp = sdirs; *sdp && !found; sdp++) {
 #ifdef DEBUG_META_MODE
 			    if (DEBUG(META))
 				fprintf(debug_file, "%s: %d: looking for: %s\n", fname, lineno, *sdp);
 #endif
 			    if (cached_stat(*sdp, &fs) == 0) {
 				found = 1;
 				p = *sdp;
+			    }
+			}
 			if (found) {
 #ifdef DEBUG_META_MODE
 			    if (DEBUG(META))
 				fprintf(debug_file, "%s: %d: found: %s\n", fname, lineno, p);
 #endif
 			    if (!S_ISDIR(fs.st_mode) &&
 				fs.st_mtime > gn->mtime) {
 				if (DEBUG(META))
 				    fprintf(debug_file, "%s: %d: file '%s' is newer than the target...\n", fname, lineno, p);
 				oodate = TRUE;
 			    } else if (S_ISDIR(fs.st_mode)) {
 				/* Update the latest directory. */
 				cached_realpath(p, latestdir);
+			    }
 			} else if (errno == ENOENT && *p == '/' &&
 				   strncmp(p, cwd, cwdlen) != 0) {
 			    /*
 			     * A referenced file outside of CWD is missing.
 			     * We cannot catch every eventuality here...
 			     */
 			    if (Lst_Find(missingFiles, string_match, p) == NULL)
 				Lst_Append(missingFiles, bmake_strdup(p));
+			}
+		    }
 		    if (buf[0] == 'E') {
 			/* previous latestdir is no longer relevant */
 			strlcpy(latestdir, lcwd, sizeof(latestdir));
+		    }
 		    break;
 		default:
 		    break;
+		}
 		if (!oodate && buf[0] == 'L' && link_src != NULL)
 		    goto check_link_src;
 	    } else if (strcmp(buf, "CMD") == 0) {
 		/*
 		 * Compare the current command with the one in the
 		 * meta data file.
 		 */
 		if (ln == NULL) {
 		    if (DEBUG(META))
 			fprintf(debug_file, "%s: %d: there were more build commands in the meta data file than there are now...\n", fname, lineno);
 		    oodate = TRUE;
 		} else {
 		    char *cmd = Lst_Datum(ln);
 		    Boolean hasOODATE = FALSE;
 		    if (strstr(cmd, "$?"))
 			hasOODATE = TRUE;
 		    else if ((cp = strstr(cmd, ".OODATE"))) {
 			/* check for $[{(].OODATE[:)}] */
 			if (cp > cmd + 2 && cp[-2] == '$')
 			    hasOODATE = TRUE;
+		    }
 		    if (hasOODATE) {
 			needOODATE = TRUE;
 			if (DEBUG(META))
 			    fprintf(debug_file, "%s: %d: cannot compare command using .OODATE\n", fname, lineno);
+		    }
 		    cmd = Var_Subst(cmd, gn, VARE_WANTRES|VARE_UNDEFERR);
 		    if ((cp = strchr(cmd, '\n'))) {
 			int n;
 			/*
 			 * This command contains newlines, we need to
 			 * fetch more from the .meta file before we
 			 * attempt a comparison.
 			 */
 			/* first put the newline back at buf[x - 1] */
 			buf[x - 1] = '\n';
 			do {
 			    /* now fetch the next line */
 			    if ((n = fgetLine(&buf, &bufsz, x, fp)) <= 0)
 				break;
 			    x = n;
 			    lineno++;
 			    if (buf[x - 1] != '\n') {
 				warnx("%s: %d: line truncated at %u", fname, lineno, x);
 				break;
+			    }
 			    cp = strchr(++cp, '\n');
 			} while (cp);
 			if (buf[x - 1] == '\n')
 			    buf[x - 1] = '\0';
+		    }
 		    if (p &&
 			!hasOODATE &&
 			!(gn->type & OP_NOMETA_CMP) &&
 			strcmp(p, cmd) != 0) {
 			if (DEBUG(META))
 			    fprintf(debug_file, "%s: %d: a build command has changed\n%s\nvs\n%s\n", fname, lineno, p, cmd);
 			if (!metaIgnoreCMDs)
 			    oodate = TRUE;
+		    }
 		    free(cmd);
-		    ln = Lst_Succ(ln);
+		    ln = LstNode_Next(ln);
+		}
 	    } else if (strcmp(buf, "CWD") == 0) {
 		/*
 		 * Check if there are extra commands now
 		 * that weren't in the meta data file.
 		 */
 		if (!oodate && ln != NULL) {
 		    if (DEBUG(META))
 			fprintf(debug_file, "%s: %d: there are extra build commands now that weren't in the meta data file\n", fname, lineno);
 		    oodate = TRUE;
+		}
 		CHECK_VALID_META(p);
 		if (strcmp(p, cwd) != 0) {
 		    if (DEBUG(META))
 			fprintf(debug_file, "%s: %d: the current working directory has changed from '%s' to '%s'\n", fname, lineno, p, curdir);
 		    oodate = TRUE;
+		}
+	    }
+	}
 	fclose(fp);
 	if (!Lst_IsEmpty(missingFiles)) {
 	    if (DEBUG(META))
 		fprintf(debug_file, "%s: missing files: %s...\n",
 			fname, (char *)Lst_Datum(Lst_First(missingFiles)));
 	    oodate = TRUE;
+	}
 	if (!oodate && !have_filemon && filemonMissing) {
 	    if (DEBUG(META))
 		fprintf(debug_file, "%s: missing filemon data\n", fname);
 	    oodate = TRUE;
+	}
     } else {
 	if (writeMeta && (metaMissing || (gn->type & OP_META))) {
 	    cp = NULL;
 	    /* if target is in .CURDIR we do not need a meta file */
 	    if (gn->path && (cp = strrchr(gn->path, '/')) && cp > gn->path) {
 		if (strncmp(curdir, gn->path, (cp - gn->path)) != 0) {
 		    cp = NULL;		/* not in .CURDIR */
+		}
+	    }
 	    if (!cp) {
 		if (DEBUG(META))
 		    fprintf(debug_file, "%s: required but missing\n", fname);
 		oodate = TRUE;
 		needOODATE = TRUE;	/* assume the worst */
+	    }
+	}
+    }
     Lst_Destroy(missingFiles, free);
     if (oodate && needOODATE) {
 	/*
 	 * Target uses .OODATE which is empty; or we wouldn't be here.
 	 * We have decided it is oodate, so .OODATE needs to be set.
 	 * All we can sanely do is set it to .ALLSRC.
 	 */
 	Var_Delete(OODATE, gn);
 	Var_Set(OODATE, Var_Value(ALLSRC, gn, &cp), gn);
 	bmake_free(cp);
+    }
  oodate_out:
     for (i--; i >= 0; i--) {
 	bmake_free(pa[i]);
+    }
     return oodate;
+}
 /* support for compat mode */
 static int childPipe[2];
 void
 meta_compat_start(void)
+{
 #ifdef USE_FILEMON_ONCE
     /*
      * We need to re-open filemon for each cmd.
      */
     BuildMon *pbm = &Mybm;
     if (pbm->mfp != NULL && useFilemon) {
 	meta_open_filemon(pbm);
     } else {
 	pbm->mon_fd = -1;
 	pbm->filemon = NULL;
+    }
 #endif
     if (pipe(childPipe) < 0)
 	Punt("Cannot create pipe: %s", strerror(errno));
     /* Set close-on-exec flag for both */
     (void)fcntl(childPipe[0], F_SETFD, FD_CLOEXEC);
     (void)fcntl(childPipe[1], F_SETFD, FD_CLOEXEC);
+}
 void
 meta_compat_child(void)
+{
     meta_job_child(NULL);
     if (dup2(childPipe[1], 1) < 0 ||
 	dup2(1, 2) < 0) {
 	execError("dup2", "pipe");
 	_exit(1);
+    }
+}
 void
 meta_compat_parent(pid_t child)
+{
     int outfd, metafd, maxfd, nfds;
     char buf[BUFSIZ+1];
     fd_set readfds;
     meta_job_parent(NULL, child);
     close(childPipe[1]);			/* child side */
     outfd = childPipe[0];
 #ifdef USE_FILEMON
     metafd = Mybm.filemon ? filemon_readfd(Mybm.filemon) : -1;
 #else
     metafd = -1;
 #endif
     maxfd = -1;
     if (outfd > maxfd)
 	    maxfd = outfd;
     if (metafd > maxfd)
 	    maxfd = metafd;
     while (outfd != -1 || metafd != -1) {
 	FD_ZERO(&readfds);
 	if (outfd != -1) {
 	    FD_SET(outfd, &readfds);
+	}
 	if (metafd != -1) {
 	    FD_SET(metafd, &readfds);
+	}
 	nfds = select(maxfd + 1, &readfds, NULL, NULL, NULL);
 	if (nfds == -1) {
 	    if (errno == EINTR)
 		continue;
 	    err(1, "select");
+	}
 	if (outfd != -1 && FD_ISSET(outfd, &readfds)) do {
 	    /* XXX this is not line-buffered */
 	    ssize_t nread = read(outfd, buf, sizeof(buf) - 1);
 	    if (nread == -1)
 		err(1, "read");
 	    if (nread == 0) {
 		close(outfd);
 		outfd = -1;
 		break;
+	    }
 	    fwrite(buf, 1, (size_t)nread, stdout);
 	    fflush(stdout);
 	    buf[nread] = '\0';
 	    meta_job_output(NULL, buf, "");
 	} while (0);
 	if (metafd != -1 && FD_ISSET(metafd, &readfds)) {
 	    if (meta_job_event(NULL) <= 0)
 		metafd = -1;
+	}
+    }
+}
 #endif	/* USE_META */

 @@ -1,2541 +1,2541 @@
-/*	$NetBSD: suff.c,v 1.130 2020/08/29 10:12:06 rillig Exp $	*/
+/*	$NetBSD: suff.c,v 1.131 2020/08/29 10:41:12 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 /*
  * Copyright (c) 1989 by Berkeley Softworks
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 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.
  * 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
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #ifndef MAKE_NATIVE
-static char rcsid[] = "$NetBSD: suff.c,v 1.130 2020/08/29 10:12:06 rillig Exp $";
+static char rcsid[] = "$NetBSD: suff.c,v 1.131 2020/08/29 10:41:12 rillig Exp $";
 #else
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)suff.c	8.4 (Berkeley) 3/21/94";
 #else
-__RCSID("$NetBSD: suff.c,v 1.130 2020/08/29 10:12:06 rillig Exp $");
+__RCSID("$NetBSD: suff.c,v 1.131 2020/08/29 10:41:12 rillig Exp $");
 #endif
 #endif /* not lint */
 #endif
 /*-
  * suff.c --
  *	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 NULL
  *	    	  	    	if the target had no implicit sources.
+ *
  *	Suff_FindPath	    	Return the appropriate path to search in
  *				order to find the node.
  */
 #include	  "make.h"
 #include	  "dir.h"
 static Lst       sufflist;	/* Lst of suffixes */
 #ifdef CLEANUP
 static Lst	 suffClean;	/* Lst of suffixes to be cleaned */
 #endif
 static Lst	 srclist;	/* Lst of sources */
 static Lst       transforms;	/* Lst of transformation rules */
 static int        sNum = 0;	/* Counter for assigning suffix numbers */
 typedef enum {
     SUFF_INCLUDE	= 0x01,	/* One which is #include'd */
     SUFF_LIBRARY	= 0x02,	/* One which contains a library */
     SUFF_NULL		= 0x04	/* The empty suffix */
     /* XXX: Why is SUFF_NULL needed? Wouldn't nameLen == 0 mean the same? */
 } SuffFlags;
 ENUM_FLAGS_RTTI_3(SuffFlags,
 		  SUFF_INCLUDE, SUFF_LIBRARY, SUFF_NULL);
 /*
  * Structure describing an individual suffix.
  */
 typedef struct Suff {
     char         *name;	    	/* The suffix itself, such as ".c" */
     int		 nameLen;	/* Length of the name, to avoid strlen calls */
     SuffFlags	 flags;      	/* Type of 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;
 /*
  * Structure used in the search for implied sources.
  */
 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 free
 				 * this thing too early or never nuke it) */
 #ifdef DEBUG_SRC
     Lst		    cp;		/* Debug; children list */
 #endif
 } Src;
 /*
  * A structure for passing more than one argument to the Lst-library-invoked
  * function...
  */
 typedef struct {
     Lst            l;
     Src            *s;
 } LstSrc;
 typedef struct {
     GNode	  **gn;
     Suff	   *s;
     Boolean	    r;
 } GNodeSuff;
 static Suff 	    *suffNull;	/* The NULL suffix for this run */
 static Suff 	    *emptySuff;	/* The empty suffix required for POSIX
 				 * single-suffix transformation rules */
 static void SuffUnRef(void *, void *);
 static void SuffFree(void *);
 static void SuffInsert(Lst, Suff *);
 static void SuffRemove(Lst, Suff *);
 static Boolean SuffParseTransform(char *, Suff **, Suff **);
 static int SuffRebuildGraph(void *, void *);
 static int SuffScanTargets(void *, void *);
 static int SuffAddSrc(void *, void *);
 static int SuffRemoveSrc(Lst);
 static void SuffAddLevel(Lst, Src *);
 static Src *SuffFindCmds(Src *, Lst);
 static void SuffExpandChildren(LstNode, GNode *);
 static void SuffExpandWildcards(LstNode, GNode *);
 static Boolean SuffApplyTransform(GNode *, GNode *, Suff *, Suff *);
 static void SuffFindDeps(GNode *, Lst);
 static void SuffFindArchiveDeps(GNode *, Lst);
 static void SuffFindNormalDeps(GNode *, Lst);
 static int SuffPrintName(void *, void *);
 static int SuffPrintSuff(void *, void *);
 static int SuffPrintTrans(void *, void *);
 	/*************** Lst Predicates ****************/
 /*-
  *-----------------------------------------------------------------------
  * SuffStrIsPrefix  --
  *	See if pref is a prefix of str.
+ *
  * Input:
  *	pref		possible prefix
  *	str		string to check
+ *
  * Results:
  *	NULL if it ain't, pointer to character in str after prefix if so
+ *
  * Side Effects:
  *	None
  *-----------------------------------------------------------------------
  */
 static const char *
 SuffStrIsPrefix(const char *pref, const char *str)
+{
     while (*str && *pref == *str) {
 	pref++;
 	str++;
+    }
     return *pref ? NULL : str;
+}
 typedef struct {
     char	*ename;		/* The end of the name */
     int		 len;		/* Length of the name */
 } SuffSuffGetSuffixArgs;
 /* See if suff is a suffix of str. str->ename should point to THE END
  * of the string to check. (THE END == the null byte)
+ *
  * Input:
  *	s		possible suffix
  *	str		string to examine
+ *
  * Results:
  *	NULL if it ain't, pointer to character in str before suffix if
  *	it is.
  */
 static char *
 SuffSuffGetSuffix(const Suff *s, const SuffSuffGetSuffixArgs *str)
+{
     char  *p1;	    	/* Pointer into suffix name */
     char  *p2;	    	/* Pointer into string being examined */
     if (str->len < s->nameLen)
 	return NULL;		/* this string is shorter than the suffix */
     p1 = s->name + s->nameLen;
     p2 = str->ename;
     while (p1 >= s->name && *p1 == *p2) {
 	p1--;
 	p2--;
+    }
     return p1 == s->name - 1 ? p2 : NULL;
+}
 /* Predicate form of SuffSuffGetSuffix, for Lst_Find. */
 static Boolean
 SuffSuffIsSuffix(const void *s, const void *sd)
+{
     return SuffSuffGetSuffix(s, sd) != NULL;
+}
 /* See if the suffix has the desired name. */
 static Boolean
 SuffSuffHasName(const void *s, const void *desiredName)
+{
     return strcmp(((const Suff *)s)->name, desiredName) == 0;
+}
 /* See if the suffix name 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... */
 static Boolean
 SuffSuffIsPrefix(const void *s, const void *str)
+{
     return SuffStrIsPrefix(((const Suff *)s)->name, str) != NULL;
+}
 /* See if the graph node has the desired name. */
 static Boolean
 SuffGNHasName(const void *gn, const void *desiredName)
+{
     return strcmp(((const GNode *)gn)->name, desiredName) == 0;
+}
 	    /*********** Maintenance Functions ************/
 static void
 SuffUnRef(void *lp, void *sp)
+{
     Lst l = (Lst) lp;
     LstNode ln = Lst_Member(l, sp);
     if (ln != NULL) {
 	Lst_Remove(l, ln);
 	((Suff *)sp)->refCount--;
+    }
+}
 /*-
  *-----------------------------------------------------------------------
  * SuffFree  --
  *	Free up all memory associated with the given suffix structure.
+ *
  * Results:
  *	none
+ *
  * Side Effects:
  *	the suffix entry is detroyed
  *-----------------------------------------------------------------------
  */
 static void
 SuffFree(void *sp)
+{
     Suff           *s = (Suff *)sp;
     if (s == suffNull)
 	suffNull = NULL;
     if (s == emptySuff)
 	emptySuff = NULL;
 #ifdef notdef
     /* We don't delete suffixes in order, so we cannot use this */
     if (s->refCount)
 	Punt("Internal error deleting suffix `%s' with refcount = %d", s->name,
 	    s->refCount);
 #endif
     Lst_Free(s->ref);
     Lst_Free(s->children);
     Lst_Free(s->parents);
     Lst_Destroy(s->searchPath, Dir_Destroy);
     free(s->name);
     free(s);
+}
 /*-
  *-----------------------------------------------------------------------
  * SuffRemove  --
  *	Remove the suffix into the list
+ *
  * Results:
  *	None
+ *
  * Side Effects:
  *	The reference count for the suffix is decremented and the
  *	suffix is possibly freed
  *-----------------------------------------------------------------------
  */
 static void
 SuffRemove(Lst l, Suff *s)
+{
     SuffUnRef(l, s);
     if (s->refCount == 0) {
 	SuffUnRef(sufflist, s);
 	SuffFree(s);
+    }
+}
 /*-
  *-----------------------------------------------------------------------
  * SuffInsert  --
  *	Insert the suffix into the list keeping the list ordered by suffix
  *	numbers.
+ *
  * Input:
  *	l		the list where in s should be inserted
  *	s		the suffix to insert
+ *
  * Results:
  *	None
+ *
  * Side Effects:
  *	The reference count of the suffix is incremented
  *-----------------------------------------------------------------------
  */
 static void
 SuffInsert(Lst l, Suff *s)
+{
     LstNode 	  ln;		/* current element in l we're examining */
     Suff          *s2 = NULL;	/* the suffix descriptor in this element */
     Lst_Open(l);
     while ((ln = Lst_Next(l)) != NULL) {
 	s2 = Lst_Datum(ln);
 	if (s2->sNum >= s->sNum) {
 	    break;
+	}
+    }
     Lst_Close(l);
     if (DEBUG(SUFF)) {
 	fprintf(debug_file, "inserting %s(%d)...", s->name, s->sNum);
+    }
     if (ln == NULL) {
 	if (DEBUG(SUFF)) {
 	    fprintf(debug_file, "at end of list\n");
+	}
 	Lst_Append(l, s);
 	s->refCount++;
 	Lst_Append(s->ref, l);
     } else if (s2->sNum != s->sNum) {
 	if (DEBUG(SUFF)) {
 	    fprintf(debug_file, "before %s(%d)\n", s2->name, s2->sNum);
+	}
 	Lst_InsertBefore(l, ln, s);
 	s->refCount++;
 	Lst_Append(s->ref, l);
     } else if (DEBUG(SUFF)) {
 	fprintf(debug_file, "already there\n");
+    }
+}
 static Suff *
 SuffNew(const char *name)
+{
     Suff *s = bmake_malloc(sizeof(Suff));
     s->name =   	bmake_strdup(name);
     s->nameLen = 	strlen(s->name);
     s->searchPath = Lst_Init();
     s->children = 	Lst_Init();
     s->parents = 	Lst_Init();
     s->ref = 	Lst_Init();
     s->sNum =   	sNum++;
     s->flags =  	0;
     s->refCount =	1;
     return s;
+}
 /*-
  *-----------------------------------------------------------------------
  * 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
  *-----------------------------------------------------------------------
  */
 void
 Suff_ClearSuffixes(void)
+{
 #ifdef CLEANUP
     Lst_MoveAll(suffClean, sufflist);
 #endif
     sufflist = Lst_Init();
     sNum = 0;
     if (suffNull)
 	SuffFree(suffNull);
     emptySuff = suffNull = SuffNew("");
     Dir_Concat(suffNull->searchPath, dirSearchPath);
     suffNull->flags =  	    SUFF_NULL;
+}
 /*-
  *-----------------------------------------------------------------------
  * SuffParseTransform --
  *	Parse a transformation string to find its two component suffixes.
+ *
  * Input:
  *	str		String being parsed
  *	srcPtr		Place to store source of trans.
  *	targPtr		Place to store target of trans.
+ *
  * Results:
  *	TRUE if the string is a valid transformation and FALSE otherwise.
+ *
  * Side Effects:
  *	The passed pointers are overwritten.
+ *
  *-----------------------------------------------------------------------
  */
 static Boolean
 SuffParseTransform(char *str, Suff **srcPtr, Suff **targPtr)
+{
     LstNode		srcLn;	    /* element in suffix list of trans source*/
     Suff		*src;	    /* Source of transformation */
     LstNode		targLn;	    /* element in suffix list of trans target*/
     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 = NULL;
     singleLn = NULL;
     /*
      * Loop looking first for a suffix that matches the start of the
      * string and then for one that exactly matches the rest of it. If
      * we can find two that meet these criteria, we've successfully
      * parsed the string.
      */
     for (;;) {
 	if (srcLn == NULL) {
 	    srcLn = Lst_Find(sufflist, SuffSuffIsPrefix, str);
 	} else {
-	    srcLn = Lst_FindFrom(sufflist, Lst_Succ(srcLn),
+	    srcLn = Lst_FindFrom(sufflist, LstNode_Next(srcLn),
 				  SuffSuffIsPrefix, str);
+	}
 	if (srcLn == NULL) {
 	    /*
 	     * Ran out of source suffixes -- no such rule
 	     */
 	    if (singleLn != NULL) {
 		/*
 		 * 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 = Lst_Datum(srcLn);
 	str2 = str + src->nameLen;
 	if (*str2 == '\0') {
 	    single = src;
 	    singleLn = srcLn;
 	} else {
 	    targLn = Lst_Find(sufflist, SuffSuffHasName, str2);
 	    if (targLn != NULL) {
 		*srcPtr = src;
 		*targPtr = Lst_Datum(targLn);
 		return TRUE;
+	    }
+	}
+    }
+}
 /*-
  *-----------------------------------------------------------------------
  * Suff_IsTransform  --
  *	Return TRUE if the given string is a transformation rule
+ *
+ *
  * Input:
  *	str		string to check
+ *
  * Results:
  *	TRUE if the string is a concatenation of two known suffixes.
  *	FALSE otherwise
+ *
  * Side Effects:
  *	None
  *-----------------------------------------------------------------------
  */
 Boolean
 Suff_IsTransform(char *str)
+{
     Suff    	  *src, *targ;
     return SuffParseTransform(str, &src, &targ);
+}
 /*-
  *-----------------------------------------------------------------------
  * Suff_AddTransform --
  *	Add the transformation rule described by the line to the
  *	list of rules and place the transformation itself in the graph
+ *
  * Input:
  *	line		name of transformation to add
+ *
  * 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(char *line)
+{
     GNode         *gn;		/* GNode of transformation rule */
     Suff          *s,		/* source suffix */
 		  *t;		/* target suffix */
     LstNode 	  ln;	    	/* Node for existing transformation */
     ln = Lst_Find(transforms, SuffGNHasName, line);
     if (ln == NULL) {
 	/*
 	 * Make a new graph node for the transformation. It will be filled in
 	 * by the Parse module.
 	 */
 	gn = Targ_NewGN(line);
 	Lst_Append(transforms, 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
 	 * free the commands themselves, because a given command can be
 	 * attached to several different transformations.
 	 */
 	gn = Lst_Datum(ln);
 	Lst_Free(gn->commands);
 	Lst_Free(gn->children);
 	gn->commands = Lst_Init();
 	gn->children = Lst_Init();
+    }
     gn->type = OP_TRANSFORM;
     (void)SuffParseTransform(line, &s, &t);
     /*
      * link the two together in the proper relationship and order
      */
     if (DEBUG(SUFF)) {
 	fprintf(debug_file, "defining transformation from `%s' to `%s'\n",
 		s->name, t->name);
+    }
     SuffInsert(t->children, s);
     SuffInsert(s->parents, t);
     return gn;
+}
 /*-
  *-----------------------------------------------------------------------
  * 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
+ *
  * Input:
  *	gnp		Node for transformation
  *	dummy		Node for transformation
+ *
  * Results:
  *	=== 0
+ *
  * Side Effects:
  *	If the node has no commands or children, the children and parents
  *	lists of the affected suffixes are altered.
+ *
  *-----------------------------------------------------------------------
  */
 int
 Suff_EndTransform(void *gnp, void *dummy MAKE_ATTR_UNUSED)
+{
     GNode *gn = (GNode *)gnp;
     if ((gn->type & OP_DOUBLEDEP) && !Lst_IsEmpty(gn->cohorts))
 	gn = Lst_Datum(Lst_Last(gn->cohorts));
     if ((gn->type & OP_TRANSFORM) && Lst_IsEmpty(gn->commands) &&
 	Lst_IsEmpty(gn->children))
+    {
 	Suff	*s, *t;
 	/*
 	 * SuffParseTransform() may fail for special rules which are not
 	 * actual transformation rules. (e.g. .DEFAULT)
 	 */
 	if (SuffParseTransform(gn->name, &s, &t)) {
 	    Lst	 p;
 	    if (DEBUG(SUFF)) {
 		fprintf(debug_file, "deleting transformation from `%s' to `%s'\n",
 		s->name, t->name);
+	    }
 	    /*
 	     * Store s->parents because s could be deleted in SuffRemove
 	     */
 	    p = s->parents;
 	    /*
 	     * 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(p, t);
+	}
     } else if ((gn->type & OP_TRANSFORM) && DEBUG(SUFF)) {
 	fprintf(debug_file, "transformation %s complete\n", gn->name);
+    }
     return 0;
+}
 /*-
  *-----------------------------------------------------------------------
  * 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.
+ *
  * Input:
  *	transformp	Transformation to test
  *	sp		Suffix to rebuild
+ *
  * Results:
  *	Always 0.
+ *
  * Side Effects:
  *	The appropriate links will be made between this suffix and
  *	others if transformation rules exist for it.
+ *
  *-----------------------------------------------------------------------
  */
 static int
 SuffRebuildGraph(void *transformp, void *sp)
+{
     GNode   	*transform = (GNode *)transformp;
     Suff    	*s = (Suff *)sp;
     char 	*cp;
     LstNode	ln;
     Suff  	*s2;
     SuffSuffGetSuffixArgs sd;
     /*
      * First see if it is a transformation from this suffix.
      */
     cp = UNCONST(SuffStrIsPrefix(s->name, transform->name));
     if (cp != NULL) {
 	ln = Lst_Find(sufflist, SuffSuffHasName, cp);
 	if (ln != NULL) {
 	    /*
 	     * Found target. Link in and return, since it can't be anything
 	     * else.
 	     */
 	    s2 = Lst_Datum(ln);
 	    SuffInsert(s2->children, s);
 	    SuffInsert(s->parents, s2);
 	    return 0;
+	}
+    }
     /*
      * Not from, maybe to?
      */
     sd.len = strlen(transform->name);
     sd.ename = transform->name + sd.len;
     cp = SuffSuffGetSuffix(s, &sd);
     if (cp != NULL) {
 	/*
 	 * Null-terminate the source suffix in order to find it.
 	 */
 	cp[1] = '\0';
 	ln = Lst_Find(sufflist, SuffSuffHasName, transform->name);
 	/*
 	 * Replace the start of the target suffix
 	 */
 	cp[1] = s->name[0];
 	if (ln != NULL) {
 	    /*
 	     * Found it -- establish the proper relationship
 	     */
 	    s2 = Lst_Datum(ln);
 	    SuffInsert(s->children, s2);
 	    SuffInsert(s2->parents, s);
+	}
+    }
     return 0;
+}
 /*-
  *-----------------------------------------------------------------------
  * SuffScanTargets --
  *	Called from Suff_AddSuffix via Lst_ForEach to search through the
  *	list of existing targets and find if any of the existing targets
  *	can be turned into a transformation rule.
+ *
  * Results:
  *	1 if a new main target has been selected, 0 otherwise.
+ *
  * Side Effects:
  *	If such a target is found and the target is the current main
  *	target, the main target is set to NULL and the next target
  *	examined (if that exists) becomes the main target.
+ *
  *-----------------------------------------------------------------------
  */
 static int
 SuffScanTargets(void *targetp, void *gsp)
+{
     GNode   	*target = (GNode *)targetp;
     GNodeSuff	*gs = (GNodeSuff *)gsp;
     Suff	*s, *t;
     char 	*ptr;
     if (*gs->gn == NULL && gs->r && (target->type & OP_NOTARGET) == 0) {
 	*gs->gn = target;
 	Targ_SetMain(target);
 	return 1;
+    }
     if (target->type == OP_TRANSFORM)
 	return 0;
     if ((ptr = strstr(target->name, gs->s->name)) == NULL ||
 	ptr == target->name)
 	return 0;
     if (SuffParseTransform(target->name, &s, &t)) {
 	if (*gs->gn == target) {
 	    gs->r = TRUE;
 	    *gs->gn = NULL;
 	    Targ_SetMain(NULL);
+	}
 	Lst_Free(target->children);
 	target->children = Lst_Init();
 	target->type = OP_TRANSFORM;
 	/*
 	 * link the two together in the proper relationship and order
 	 */
 	if (DEBUG(SUFF)) {
 	    fprintf(debug_file, "defining transformation from `%s' to `%s'\n",
 		s->name, t->name);
+	}
 	SuffInsert(t->children, s);
 	SuffInsert(s->parents, t);
+    }
     return 0;
+}
 /*-
  *-----------------------------------------------------------------------
  * 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...
+ *
  * Input:
  *	str		the name of the suffix to add
+ *
  * 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.
  *	The mainNode passed can be modified if a target mutated into a
  *	transform and that target happened to be the main target.
  *-----------------------------------------------------------------------
  */
 void
 Suff_AddSuffix(char *str, GNode **gn)
+{
     Suff          *s;	    /* new suffix descriptor */
     LstNode 	  ln;
     GNodeSuff	  gs;
     ln = Lst_Find(sufflist, SuffSuffHasName, str);
     if (ln == NULL) {
         s = SuffNew(str);
 	Lst_Append(sufflist, s);
 	/*
 	 * We also look at our existing targets list to see if adding
 	 * this suffix will make one of our current targets mutate into
 	 * a suffix rule. This is ugly, but other makes treat all targets
 	 * that start with a . as suffix rules.
 	 */
 	gs.gn = gn;
 	gs.s  = s;
 	gs.r  = FALSE;
 	Lst_ForEach(Targ_List(), SuffScanTargets, &gs);
 	/*
 	 * Look for any existing transformations from or to this suffix.
 	 * XXX: Only do this after a Suff_ClearSuffixes?
 	 */
 	Lst_ForEach(transforms, SuffRebuildGraph, s);
+    }
+}
 /*-
  *-----------------------------------------------------------------------
  * Suff_GetPath --
  *	Return the search path for the given suffix, if it's defined.
+ *
  * Results:
  *	The searchPath for the desired suffix or NULL if the suffix isn't
  *	defined.
+ *
  * Side Effects:
  *	None
  *-----------------------------------------------------------------------
  */
 Lst
 Suff_GetPath(char *sname)
+{
     LstNode   	  ln;
     Suff    	  *s;
     ln = Lst_Find(sufflist, SuffSuffHasName, sname);
     if (ln == NULL) {
 	return NULL;
     } else {
 	s = Lst_Datum(ln);
 	return s->searchPath;
+    }
+}
 /*-
  *-----------------------------------------------------------------------
  * 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 preceded by a -I. The same
  *	is done for the ".a" suffix, except the variable is called
  *	".LIBS" and the flag is -L.
  *-----------------------------------------------------------------------
  */
 void
 Suff_DoPaths(void)
+{
     Suff	   	*s;
     LstNode  		ln;
     char		*ptr;
     Lst	    	    	inIncludes; /* Cumulative .INCLUDES path */
     Lst	    	    	inLibs;	    /* Cumulative .LIBS path */
     inIncludes = Lst_Init();
     inLibs = Lst_Init();
     Lst_Open(sufflist);
     while ((ln = Lst_Next(sufflist)) != NULL) {
 	s = Lst_Datum(ln);
 	if (!Lst_IsEmpty(s->searchPath)) {
 #ifdef INCLUDES
 	    if (s->flags & SUFF_INCLUDE) {
 		Dir_Concat(inIncludes, s->searchPath);
+	    }
 #endif /* INCLUDES */
 #ifdef LIBRARIES
 	    if (s->flags & SUFF_LIBRARY) {
 		Dir_Concat(inLibs, s->searchPath);
+	    }
 #endif /* LIBRARIES */
 	    Dir_Concat(s->searchPath, dirSearchPath);
 	} else {
 	    Lst_Destroy(s->searchPath, Dir_Destroy);
 	    s->searchPath = Lst_Copy(dirSearchPath, Dir_CopyDir);
+	}
+    }
     Lst_Close(sufflist);
     Var_Set(".INCLUDES", ptr = Dir_MakeFlags("-I", inIncludes), VAR_GLOBAL);
     free(ptr);
     Var_Set(".LIBS", ptr = Dir_MakeFlags("-L", inLibs), VAR_GLOBAL);
     free(ptr);
     Lst_Destroy(inIncludes, Dir_Destroy);
     Lst_Destroy(inLibs, Dir_Destroy);
+}
 /*-
  *-----------------------------------------------------------------------
  * 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.
+ *
  * Input:
  *	sname		Name of the suffix to mark
+ *
  * Results:
  *	None.
+ *
  * Side Effects:
  *	The SUFF_INCLUDE bit is set in the suffix's flags field
+ *
  *-----------------------------------------------------------------------
  */
 void
 Suff_AddInclude(char *sname)
+{
     LstNode	  ln;
     Suff	  *s;
     ln = Lst_Find(sufflist, SuffSuffHasName, sname);
     if (ln != NULL) {
 	s = Lst_Datum(ln);
 	s->flags |= SUFF_INCLUDE;
+    }
+}
 /*-
  *-----------------------------------------------------------------------
  * 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.
+ *
  * Input:
  *	sname		Name of the suffix to mark
+ *
  * Results:
  *	None.
+ *
  * Side Effects:
  *	The SUFF_LIBRARY bit is set in the suffix's flags field
+ *
  *-----------------------------------------------------------------------
  */
 void
 Suff_AddLib(char *sname)
+{
     LstNode	  ln;
     Suff	  *s;
     ln = Lst_Find(sufflist, SuffSuffHasName, sname);
     if (ln != NULL) {
 	s = Lst_Datum(ln);
 	s->flags |= SUFF_LIBRARY;
+    }
+}
 	  /********** 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.
+ *
  * Input:
  *	sp		suffix for which to create a Src structure
  *	lsp		list and parent for the new Src
+ *
  * Results:
  *	always returns 0
+ *
  * Side Effects:
  *	A Src structure is created and tacked onto the end of the list
  *-----------------------------------------------------------------------
  */
 static int
 SuffAddSrc(void *sp, void *lsp)
+{
     Suff	*s = (Suff *)sp;
     LstSrc      *ls = (LstSrc *)lsp;
     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 = bmake_malloc(sizeof(Src));
 	s2->file =  	bmake_strdup(targ->pref);
 	s2->pref =  	targ->pref;
 	s2->parent = 	targ;
 	s2->node =  	NULL;
 	s2->suff =  	s;
 	s->refCount++;
 	s2->children =	0;
 	targ->children += 1;
 	Lst_Append(ls->l, s2);
 #ifdef DEBUG_SRC
 	s2->cp = Lst_Init();
 	Lst_Append(targ->cp, s2);
 	fprintf(debug_file, "1 add %p %p to %p:", targ, s2, ls->l);
 	Lst_ForEach(ls->l, PrintAddr, NULL);
 	fprintf(debug_file, "\n");
 #endif
+    }
     s2 = bmake_malloc(sizeof(Src));
     s2->file = 	    str_concat2(targ->pref, s->name);
     s2->pref =	    targ->pref;
     s2->parent =    targ;
     s2->node = 	    NULL;
     s2->suff = 	    s;
     s->refCount++;
     s2->children =  0;
     targ->children += 1;
     Lst_Append(ls->l, s2);
 #ifdef DEBUG_SRC
     s2->cp = Lst_Init();
     Lst_Append(targ->cp, s2);
     fprintf(debug_file, "2 add %p %p to %p:", targ, s2, ls->l);
     Lst_ForEach(ls->l, PrintAddr, NULL);
     fprintf(debug_file, "\n");
 #endif
     return 0;
+}
 /*-
  *-----------------------------------------------------------------------
  * SuffAddLevel  --
  *	Add all the children of targ as Src structures to the given list
+ *
  * Input:
  *	l		list to which to add the new level
  *	targ		Src structure to use as the parent
+ *
  * Results:
  *	None
+ *
  * Side Effects:
  * 	Lots of structures are created and added to the list
  *-----------------------------------------------------------------------
  */
 static void
 SuffAddLevel(Lst l, Src *targ)
+{
     LstSrc         ls;
     ls.s = targ;
     ls.l = l;
     Lst_ForEach(targ->suff->children, SuffAddSrc, &ls);
+}
 /*-
  *----------------------------------------------------------------------
  * 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 free'd.
  *----------------------------------------------------------------------
  */
 static int
 SuffRemoveSrc(Lst l)
+{
     LstNode ln;
     Src *s;
     int t = 0;
     Lst_Open(l);
 #ifdef DEBUG_SRC
     fprintf(debug_file, "cleaning %lx: ", (unsigned long) l);
     Lst_ForEach(l, PrintAddr, NULL);
     fprintf(debug_file, "\n");
 #endif
     while ((ln = Lst_Next(l)) != NULL) {
 	s = Lst_Datum(ln);
 	if (s->children == 0) {
 	    free(s->file);
 	    if (!s->parent)
 		free(s->pref);
 	    else {
 #ifdef DEBUG_SRC
 		LstNode ln2 = Lst_Member(s->parent->cp, s);
 		if (ln2 != NULL)
 		    Lst_Remove(s->parent->cp, ln2);
 #endif
 		--s->parent->children;
+	    }
 #ifdef DEBUG_SRC
 	    fprintf(debug_file, "free: [l=%p] p=%p %d\n", l, s, s->children);
 	    Lst_Free(s->cp);
 #endif
 	    Lst_Remove(l, ln);
 	    free(s);
 	    t |= 1;
 	    Lst_Close(l);
 	    return TRUE;
+	}
 #ifdef DEBUG_SRC
 	else {
 	    fprintf(debug_file, "keep: [l=%p] p=%p %d: ", l, s, s->children);
 	    Lst_ForEach(s->cp, PrintAddr, NULL);
 	    fprintf(debug_file, "\n");
+	}
 #endif
+    }
     Lst_Close(l);
     return t;
+}
 /*-
  *-----------------------------------------------------------------------
  * SuffFindThem --
  *	Find the first existing file/target in the list srcs
+ *
  * Input:
  *	srcs		list of Src structures to search through
+ *
  * Results:
  *	The lowest structure in the chain of transformations
+ *
  * Side Effects:
  *	None
  *-----------------------------------------------------------------------
  */
 static Src *
 SuffFindThem(Lst srcs, Lst slst)
+{
     Src            *s;		/* current Src */
     Src		   *rs;		/* returned Src */
     char	   *ptr;
     rs = NULL;
     while (!Lst_IsEmpty(srcs)) {
 	s = Lst_Dequeue(srcs);
 	if (DEBUG(SUFF)) {
 	    fprintf(debug_file, "\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) != NULL) {
 #ifdef DEBUG_SRC
 	    fprintf(debug_file, "remove %p from %p\n", s, srcs);
 #endif
 	    rs = s;
 	    break;
+	}
 	if ((ptr = Dir_FindFile(s->file, s->suff->searchPath)) != NULL) {
 	    rs = s;
 #ifdef DEBUG_SRC
 	    fprintf(debug_file, "remove %p from %p\n", s, srcs);
 #endif
 	    free(ptr);
 	    break;
+	}
 	if (DEBUG(SUFF)) {
 	    fprintf(debug_file, "not there\n");
+	}
 	SuffAddLevel(srcs, s);
 	Lst_Append(slst, s);
+    }
     if (DEBUG(SUFF) && rs) {
 	fprintf(debug_file, "got it\n");
+    }
     return rs;
+}
 /*-
  *-----------------------------------------------------------------------
  * 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.
+ *
  * Input:
  *	targ		Src structure to play with
+ *
  * Results:
  *	The Src structure of the "winning" child, or NULL if no such beast.
+ *
  * Side Effects:
  *	A Src structure may be allocated.
+ *
  *-----------------------------------------------------------------------
  */
 static Src *
 SuffFindCmds(Src *targ, Lst slst)
+{
     LstNode 	  	ln; 	/* General-purpose list node */
     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;
     Lst_Open(t->children);
     prefLen = strlen(targ->pref);
     for (;;) {
 	ln = Lst_Next(t->children);
 	if (ln == NULL) {
 	    Lst_Close(t->children);
 	    return NULL;
+	}
 	s = Lst_Datum(ln);
 	if (s->type & OP_OPTIONAL && Lst_IsEmpty(t->commands)) {
 	    /*
 	     * We haven't looked to see if .OPTIONAL files exist yet, so
 	     * don't use one as the implicit source.
 	     * This allows us to use .OPTIONAL in .depend files so make won't
 	     * complain "don't know how to make xxx.h' when a dependent file
 	     * has been moved/deleted.
 	     */
 	    continue;
+	}
 	cp = strrchr(s->name, '/');
 	if (cp == NULL) {
 	    cp = s->name;
 	} else {
 	    cp++;
+	}
 	if (strncmp(cp, targ->pref, prefLen) != 0)
 	    continue;
 	/*
 	 * The node matches the prefix ok, see if it has a known
 	 * suffix.
 	 */
 	ln = Lst_Find(sufflist, SuffSuffHasName, &cp[prefLen]);
 	if (ln == NULL)
 	    continue;
 	/*
 	 * 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 = Lst_Datum(ln);
 	/* XXX: Can targ->suff be NULL here? */
 	if (targ->suff != NULL &&
 	    Lst_Member(suff->parents, targ->suff) != NULL)
 	    break;
+    }
     /*
      * Hot Damn! Create a new Src structure to describe
      * this transformation (making sure to duplicate the
      * source node's name so Suff_FindDeps can free it
      * again (ick)), and return the new structure.
      */
     ret = bmake_malloc(sizeof(Src));
     ret->file = bmake_strdup(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();
     fprintf(debug_file, "3 add %p %p\n", targ, ret);
     Lst_Append(targ->cp, ret);
 #endif
     Lst_Append(slst, ret);
     if (DEBUG(SUFF)) {
 	fprintf(debug_file, "\tusing existing source %s\n", s->name);
+    }
     return ret;
+}
 /*-
  *-----------------------------------------------------------------------
  * SuffExpandChildren --
  *	Expand the names of any children of a given node that contain
  *	variable invocations or file wildcards into actual targets.
+ *
  * Input:
  *	cln		Child to examine
  *	pgn		Parent node being processed
+ *
  * 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.
+ *
  *-----------------------------------------------------------------------
  */
 static void
 SuffExpandChildren(LstNode cln, GNode *pgn)
+{
     GNode   	*cgn = Lst_Datum(cln);
     GNode	*gn;	    /* New source 8) */
     char	*cp;	    /* Expanded value */
     if (!Lst_IsEmpty(cgn->order_pred) || !Lst_IsEmpty(cgn->order_succ))
 	/* It is all too hard to process the result of .ORDER */
 	return;
     if (cgn->type & OP_WAIT)
 	/* Ignore these (& OP_PHONY ?) */
 	return;
     /*
      * First do variable expansion -- this takes precedence over
      * wildcard expansion. If the result contains wildcards, they'll be gotten
      * to later since the resulting words are tacked on to the end of
      * the children list.
      */
     if (strchr(cgn->name, '$') == NULL) {
 	SuffExpandWildcards(cln, pgn);
 	return;
+    }
     if (DEBUG(SUFF)) {
 	fprintf(debug_file, "Expanding \"%s\"...", cgn->name);
+    }
     cp = Var_Subst(cgn->name, pgn, VARE_UNDEFERR|VARE_WANTRES);
     if (cp != NULL) {
 	Lst	    members = Lst_Init();
 	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 {
 	    /*
 	     * 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);
 		    Lst_Append(members, 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.
 		     */
 		    const char	*junk;
 		    int 	len;
 		    void	*freeIt;
 		    junk = Var_Parse(cp, pgn, VARE_UNDEFERR|VARE_WANTRES,
 			&len, &freeIt);
 		    if (junk != var_Error) {
 			cp += len - 1;
+		    }
 		    free(freeIt);
 		} else if (*cp == '\\' && cp[1] != '\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);
 		Lst_Append(members, 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 = Lst_Dequeue(members);
 	    if (DEBUG(SUFF)) {
 		fprintf(debug_file, "%s...", gn->name);
+	    }
 	    /* Add gn to the parents child list before the original child */
 	    Lst_InsertBefore(pgn->children, cln, gn);
 	    Lst_Append(gn->parents, pgn);
 	    pgn->unmade++;
 	    /* Expand wildcards on new node */
-	    SuffExpandWildcards(Lst_Prev(cln), pgn);
+	    SuffExpandWildcards(LstNode_Prev(cln), pgn);
+	}
 	Lst_Free(members);
 	/*
 	 * Free the result
 	 */
 	free(cp);
+    }
     if (DEBUG(SUFF)) {
 	fprintf(debug_file, "\n");
+    }
     /*
      * Now the source is expanded, remove it from the list of children to
      * keep it from being processed.
      */
     pgn->unmade--;
     Lst_Remove(pgn->children, cln);
     Lst_Remove(cgn->parents, Lst_Member(cgn->parents, pgn));
+}
 static void
 SuffExpandWildcards(LstNode cln, GNode *pgn)
+{
     GNode   	*cgn = Lst_Datum(cln);
     GNode	*gn;	    /* New source 8) */
     char	*cp;	    /* Expanded value */
     Lst 	explist;    /* List of expansions */
     if (!Dir_HasWildcards(cgn->name))
 	return;
     /*
      * Expand the word along the chosen path
      */
     explist = Lst_Init();
     Dir_Expand(cgn->name, Suff_FindPath(cgn), explist);
     while (!Lst_IsEmpty(explist)) {
 	/*
 	 * Fetch next expansion off the list and find its GNode
 	 */
 	cp = Lst_Dequeue(explist);
 	if (DEBUG(SUFF)) {
 	    fprintf(debug_file, "%s...", cp);
+	}
 	gn = Targ_FindNode(cp, TARG_CREATE);
 	/* Add gn to the parents child list before the original child */
 	Lst_InsertBefore(pgn->children, cln, gn);
 	Lst_Append(gn->parents, pgn);
 	pgn->unmade++;
+    }
     Lst_Free(explist);
     if (DEBUG(SUFF)) {
 	fprintf(debug_file, "\n");
+    }
     /*
      * Now the source is expanded, remove it from the list of children to
      * keep it from being processed.
      */
     pgn->unmade--;
     Lst_Remove(pgn->children, cln);
     Lst_Remove(cgn->parents, Lst_Member(cgn->parents, pgn));
+}
 /*-
  *-----------------------------------------------------------------------
  * Suff_FindPath --
  *	Find a path along which to expand the node.
+ *
  *	If the word has a known suffix, use that path.
  *	If it has no known suffix, use the default system search path.
+ *
  * Input:
  *	gn		Node being examined
+ *
  * Results:
  *	The appropriate path to search for the GNode.
+ *
  * Side Effects:
  *	XXX: We could set the suffix here so that we don't have to scan
  *	again.
+ *
  *-----------------------------------------------------------------------
  */
 Lst
 Suff_FindPath(GNode* gn)
+{
     Suff *suff = gn->suffix;
     if (suff == NULL) {
 	SuffSuffGetSuffixArgs sd;   /* Search string data */
 	LstNode ln;
 	sd.len = strlen(gn->name);
 	sd.ename = gn->name + sd.len;
 	ln = Lst_Find(sufflist, SuffSuffIsSuffix, &sd);
 	if (DEBUG(SUFF)) {
 	    fprintf(debug_file, "Wildcard expanding \"%s\"...", gn->name);
+	}
 	if (ln != NULL)
 	    suff = Lst_Datum(ln);
 	/* XXX: Here we can save the suffix so we don't have to do this again */
+    }
     if (suff != NULL) {
 	if (DEBUG(SUFF)) {
 	    fprintf(debug_file, "suffix is \"%s\"...", suff->name);
+	}
 	return suff->searchPath;
     } else {
 	/*
 	 * Use default search path
 	 */
 	return dirSearchPath;
+    }
+}
 /*-
  *-----------------------------------------------------------------------
  * SuffApplyTransform --
  *	Apply a transformation rule, given the source and target nodes
  *	and suffixes.
+ *
  * Input:
  *	tGn		Target node
  *	sGn		Source node
  *	t		Target suffix
  *	s		Source suffix
+ *
  * 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.
+ *
  *-----------------------------------------------------------------------
  */
 static Boolean
 SuffApplyTransform(GNode *tGn, GNode *sGn, Suff *t, Suff *s)
+{
     LstNode 	ln, nln;    /* General node */
     char    	*tname;	    /* Name of transformation rule */
     GNode   	*gn;	    /* Node for same */
     /*
      * Form the proper links between the target and source.
      */
     Lst_Append(tGn->children, sGn);
     Lst_Append(sGn->parents, tGn);
     tGn->unmade += 1;
     /*
      * Locate the transformation rule itself
      */
     tname = str_concat2(s->name, t->name);
     ln = Lst_Find(transforms, SuffGNHasName, tname);
     free(tname);
     if (ln == NULL) {
 	/*
 	 * 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;
+    }
     gn = Lst_Datum(ln);
     if (DEBUG(SUFF)) {
 	fprintf(debug_file, "\tapplying %s -> %s to \"%s\"\n", s->name, t->name, tGn->name);
+    }
     /*
      * Record last child for expansion purposes
      */
     ln = Lst_Last(tGn->children);
     /*
      * Pass the buck to Make_HandleUse to apply the rule
      */
     (void)Make_HandleUse(gn, tGn);
     /*
      * Deal with wildcards and variables in any acquired sources
      */
-    for (ln = ln != NULL ? Lst_Succ(ln) : NULL; ln != NULL; ln = nln) {
+    for (ln = ln != NULL ? LstNode_Next(ln) : NULL; ln != NULL; ln = nln) {
-	nln = Lst_Succ(ln);
+	nln = LstNode_Next(ln);
 	SuffExpandChildren(ln, tGn);
+    }
     /*
      * Keep track of another parent to which this beast is transformed so
      * the .IMPSRC variable can be set correctly for the parent.
      */
     Lst_Append(sGn->iParents, tGn);
     return TRUE;
+}
 /*-
  *-----------------------------------------------------------------------
  * SuffFindArchiveDeps --
  *	Locate dependencies for an OP_ARCHV node.
+ *
  * Input:
  *	gn		Node for which to locate dependencies
+ *
  * Results:
  *	None
+ *
  * Side Effects:
  *	Same as Suff_FindDeps
+ *
  *-----------------------------------------------------------------------
  */
 static void
 SuffFindArchiveDeps(GNode *gn, Lst slst)
+{
     char    	*eoarch;    /* End of archive portion */
     char    	*eoname;    /* End of member portion */
     GNode   	*mem;	    /* Node for member */
     LstNode 	ln, nln;    /* Next suffix node to check */
     Suff    	*ms;	    /* Suffix descriptor for member */
     char    	*name;	    /* Start of member's name */
     /*
      * The node is an archive(member) pair. so we must find a
      * suffix for both of them.
      */
     eoarch = strchr(gn->name, '(');
     eoname = strchr(eoarch, ')');
     /*
      * Caller guarantees the format `libname(member)', via
      * Arch_ParseArchive.
      */
     assert(eoarch != NULL);
     assert(eoname != NULL);
     *eoname = '\0';	  /* Nuke parentheses during suffix search */
     *eoarch = '\0';	  /* So a suffix can be found */
     name = eoarch + 1;
     /*
      * To simplify things, call Suff_FindDeps recursively on the member now,
      * so we can simply compare the member's .PREFIX and .TARGET variables
      * to locate its suffix. This allows us to figure out the suffix to
      * use for the archive without having to do a quadratic search over the
      * suffix list, backtracking for each one...
      */
     mem = Targ_FindNode(name, TARG_CREATE);
     SuffFindDeps(mem, slst);
     /*
      * Create the link between the two nodes right off
      */
     Lst_Append(gn->children, mem);
     Lst_Append(mem->parents, gn);
     gn->unmade += 1;
     /*
      * Copy in the variables from the member node to this one.
      */
+    {
 	char *freeIt;
 	Var_Set(PREFIX, Var_Value(PREFIX, mem, &freeIt), gn);
 	bmake_free(freeIt);
 	Var_Set(TARGET, Var_Value(TARGET, mem, &freeIt), gn);
 	bmake_free(freeIt);
+    }
     ms = mem->suffix;
     if (ms == NULL) {
 	/*
 	 * Didn't know what it was -- use .NULL suffix if not in make mode
 	 */
 	if (DEBUG(SUFF)) {
 	    fprintf(debug_file, "using null suffix\n");
+	}
 	ms = suffNull;
+    }
     /*
      * Set the other two local variables required for this target.
      */
     Var_Set(MEMBER, name, gn);
     Var_Set(ARCHIVE, gn->name, gn);
     /*
      * Set $@ for compatibility with other makes
      */
     Var_Set(TARGET, gn->name, gn);
     /*
      * Now we've got the important local variables set, expand any sources
      * that still contain variables or wildcards in their names.
      */
     for (ln = Lst_First(gn->children); ln != NULL; ln = nln) {
-	nln = Lst_Succ(ln);
+	nln = LstNode_Next(ln);
 	SuffExpandChildren(ln, gn);
+    }
     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...
 	 */
 	SuffSuffGetSuffixArgs sd;	/* Search string data */
 	/*
 	 * Use first matching suffix...
 	 */
 	sd.len = eoarch - gn->name;
 	sd.ename = eoarch;
 	ln = Lst_Find(ms->parents, SuffSuffIsSuffix, &sd);
 	if (ln != NULL) {
 	    /*
 	     * Got one -- apply it
 	     */
 	    if (!SuffApplyTransform(gn, mem, (Suff *)Lst_Datum(ln), ms) &&
 		DEBUG(SUFF))
+	    {
 		fprintf(debug_file, "\tNo transformation from %s -> %s\n",
 		       ms->name, ((Suff *)Lst_Datum(ln))->name);
+	    }
+	}
+    }
     /*
      * Replace the opening and closing parens now we've no need of the separate
      * pieces.
      */
     *eoarch = '('; *eoname = ')';
     /*
      * Pretend gn appeared to the left of a dependency operator so
      * the user needn't provide a transformation from the member to the
      * archive.
      */
     if (OP_NOP(gn->type)) {
 	gn->type |= OP_DEPENDS;
+    }
     /*
      * Flag the member as such so we remember to look in the archive for
      * its modification time. The OP_JOIN | OP_MADE is needed because this
      * target should never get made.
      */
     mem->type |= OP_MEMBER | OP_JOIN | OP_MADE;
+}
 /*-
  *-----------------------------------------------------------------------
  * SuffFindNormalDeps --
  *	Locate implicit dependencies for regular targets.
+ *
  * Input:
  *	gn		Node for which to find sources
+ *
  * Results:
  *	None.
+ *
  * Side Effects:
  *	Same as Suff_FindDeps...
+ *
  *-----------------------------------------------------------------------
  */
 static void
 SuffFindNormalDeps(GNode *gn, Lst slst)
+{
     char    	*eoname;    /* End of name */
     char    	*sopref;    /* Start of prefix */
     LstNode 	ln, nln;    /* 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 */
     SuffSuffGetSuffixArgs sd; /* Search string data */
     sd.len = strlen(gn->name);
     sd.ename = eoname = gn->name + sd.len;
     sopref = gn->name;
     /*
      * Begin at the beginning...
      */
     ln = Lst_First(sufflist);
     srcs = Lst_Init();
     targs = Lst_Init();
     /*
      * We're caught in a catch-22 here. On the one hand, we want to use any
      * transformation implied by the target's sources, but we can't examine
      * the sources until we've expanded any variables/wildcards they may hold,
      * and we can't do that until we've set up the target's local variables
      * and we can't do that until we know what the proper suffix for the
      * target is (in case there are two suffixes one of which is a suffix of
      * the other) and we can't know that until we've found its implied
      * source, which we may not want to use if there's an existing source
      * that implies a different transformation.
+     *
      * In an attempt to get around this, which may not work all the time,
      * but should work most of the time, we look for implied sources first,
      * checking transformations to all possible suffixes of the target,
      * use what we find to set the target's local variables, expand the
      * children, then look for any overriding transformations they imply.
      * Should we find one, we discard the one we found before.
      */
     bottom = NULL;
     targ = NULL;
     if (!(gn->type & OP_PHONY)) {
 	while (ln != NULL) {
 	    /*
 	     * Look for next possible suffix...
 	     */
 	    ln = Lst_FindFrom(sufflist, ln, SuffSuffIsSuffix, &sd);
 	    if (ln != NULL) {
 		int	    prefLen;	    /* Length of the prefix */
 		/*
 		 * Allocate a Src structure to which things can be transformed
 		 */
 		targ = bmake_malloc(sizeof(Src));
 		targ->file = bmake_strdup(gn->name);
 		targ->suff = Lst_Datum(ln);
 		targ->suff->refCount++;
 		targ->node = gn;
 		targ->parent = NULL;
 		targ->children = 0;
 #ifdef DEBUG_SRC
 		targ->cp = Lst_Init();
 #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 = bmake_malloc(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
 		 */
 		Lst_Append(targs, targ);
 		/*
 		 * Search from this suffix's successor...
 		 */
-		ln = Lst_Succ(ln);
+		ln = LstNode_Next(ln);
+	    }
+	}
 	/*
 	 * Handle target of unknown suffix...
 	 */
 	if (Lst_IsEmpty(targs) && suffNull != NULL) {
 	    if (DEBUG(SUFF)) {
 		fprintf(debug_file, "\tNo known suffix on %s. Using .NULL suffix\n", gn->name);
+	    }
 	    targ = bmake_malloc(sizeof(Src));
 	    targ->file = bmake_strdup(gn->name);
 	    targ->suff = suffNull;
 	    targ->suff->refCount++;
 	    targ->node = gn;
 	    targ->parent = NULL;
 	    targ->children = 0;
 	    targ->pref = bmake_strdup(sopref);
 #ifdef DEBUG_SRC
 	    targ->cp = Lst_Init();
 #endif
 	    /*
 	     * Only use the default suffix rules if we don't have commands
 	     * defined for this gnode; traditional make programs used to
 	     * not define suffix rules if the gnode had children but we
 	     * don't do this anymore.
 	     */
 	    if (Lst_IsEmpty(gn->commands))
 		SuffAddLevel(srcs, targ);
 	    else {
 		if (DEBUG(SUFF))
 		    fprintf(debug_file, "not ");
+	    }
 	    if (DEBUG(SUFF))
 		fprintf(debug_file, "adding suffix rules\n");
 	    Lst_Append(targs, targ);
+	}
 	/*
 	 * Using the list of possible sources built up from the target
 	 * suffix(es), try and find an existing file/target that matches.
 	 */
 	bottom = SuffFindThem(srcs, slst);
 	if (bottom == NULL) {
 	    /*
 	     * No known transformations -- use the first suffix found
 	     * for setting the local variables.
 	     */
 	    if (!Lst_IsEmpty(targs)) {
 		targ = Lst_Datum(Lst_First(targs));
 	    } else {
 		targ = 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;
+	}
+    }
     Var_Set(TARGET, gn->path ? gn->path : gn->name, gn);
     pref = (targ != NULL) ? targ->pref : gn->name;
     Var_Set(PREFIX, pref, gn);
     /*
      * Now we've got the important local variables set, expand any sources
      * that still contain variables or wildcards in their names.
      */
     for (ln = Lst_First(gn->children); ln != NULL; ln = nln) {
-	nln = Lst_Succ(ln);
+	nln = LstNode_Next(ln);
 	SuffExpandChildren(ln, gn);
+    }
     if (targ == NULL) {
 	if (DEBUG(SUFF)) {
 	    fprintf(debug_file, "\tNo valid suffix on %s\n", gn->name);
+	}
 sfnd_abort:
 	/*
 	 * Deal with finding the thing on the default search path. We
 	 * always do that, not only if the node is only a source (not
 	 * on the lhs of a dependency operator or [XXX] it has neither
 	 * children or commands) as the old pmake did.
 	 */
 	if ((gn->type & (OP_PHONY|OP_NOPATH)) == 0) {
 	    free(gn->path);
 	    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);
+		}
+	    }
+	}
 	goto sfnd_return;
+    }
     /*
      * If the suffix indicates that the target is a library, mark that in
      * the node's type field.
      */
     if (targ->suff->flags & SUFF_LIBRARY) {
 	gn->type |= OP_LIB;
+    }
     /*
      * Check for overriding transformation rule implied by sources
      */
     if (!Lst_IsEmpty(gn->children)) {
 	src = SuffFindCmds(targ, slst);
 	if (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, bottom) == NULL) {
 		    Lst_Append(slst, bottom);
+		}
 		bottom = bottom->parent;
+	    }
 	    bottom = src;
+	}
+    }
     if (bottom == NULL) {
 	/*
 	 * No idea from where it can come -- return now.
 	 */
 	goto sfnd_abort;
+    }
     /*
      * We now have a list of Src structures headed by 'bottom' and linked via
      * their 'parent' pointers. What we do next is create links between
      * source and target nodes (which may or may not have been created)
      * and set the necessary local variables in each target. The
      * commands for each target are set from the commands of the
      * transformation rule used to get from the src suffix to the targ
      * suffix. Note that this causes the commands list of the original
      * node, gn, to be replaced by the commands of the final
      * transformation rule. Also, the unmade field of gn is incremented.
      * Etc.
      */
     if (bottom->node == NULL) {
 	bottom->node = Targ_FindNode(bottom->file, TARG_CREATE);
+    }
     for (src = bottom; src->parent != 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 == NULL) {
 	    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 = src->suff;
     gn->suffix->refCount++;
     /*
      * Nuke the transformation path and the Src structures left over in the
      * two lists.
      */
 sfnd_return:
     if (bottom)
 	if (Lst_Member(slst, bottom) == NULL)
 	    Lst_Append(slst, bottom);
     while (SuffRemoveSrc(srcs) || SuffRemoveSrc(targs))
 	continue;
     Lst_MoveAll(slst, srcs);
     Lst_MoveAll(slst, targs);
+}
 /*-
  *-----------------------------------------------------------------------
  * 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.
+ *
  * 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.
+ *
  *-----------------------------------------------------------------------
  */
 void
 Suff_FindDeps(GNode *gn)
+{
     SuffFindDeps(gn, srclist);
     while (SuffRemoveSrc(srclist))
 	continue;
+}
 static void
 SuffFindDeps(GNode *gn, Lst slst)
+{
     if (gn->type & OP_DEPS_FOUND)
 	return;
     gn->type |= OP_DEPS_FOUND;
     /*
      * Make sure we have these set, may get revised below.
      */
     Var_Set(TARGET, gn->path ? gn->path : gn->name, gn);
     Var_Set(PREFIX, gn->name, gn);
     if (DEBUG(SUFF)) {
 	fprintf(debug_file, "SuffFindDeps (%s)\n", gn->name);
+    }
     if (gn->type & OP_ARCHV) {
 	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, SuffSuffHasName, LIBSUFF);
 	if (gn->suffix)
 	    gn->suffix->refCount--;
 	if (ln != NULL) {
 	    gn->suffix = s = 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 {
 	SuffFindNormalDeps(gn, slst);
+    }
+}
 /*-
  *-----------------------------------------------------------------------
  * Suff_SetNull --
  *	Define which suffix is the null suffix.
+ *
  * Input:
  *	name		Name of null suffix
+ *
  * 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.
  *-----------------------------------------------------------------------
  */
 void
 Suff_SetNull(char *name)
+{
     Suff    *s;
     LstNode ln;
     ln = Lst_Find(sufflist, SuffSuffHasName, name);
     if (ln != NULL) {
 	s = Lst_Datum(ln);
 	if (suffNull != 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);
+    }
+}
 /* Initialize the suffixes module. */
 void
 Suff_Init(void)
+{
 #ifdef CLEANUP
     suffClean = Lst_Init();
     sufflist = Lst_Init();
 #endif
     srclist = Lst_Init();
     transforms = Lst_Init();
     /*
      * Create null suffix for single-suffix rules (POSIX). The thing doesn't
      * actually go on the suffix list or everyone will think that's its
      * suffix.
      */
     Suff_ClearSuffixes();
+}
 /* Clean up the suffixes module. */
 void
 Suff_End(void)
+{
 #ifdef CLEANUP
     Lst_Destroy(sufflist, SuffFree);
     Lst_Destroy(suffClean, SuffFree);
     if (suffNull)
 	SuffFree(suffNull);
     Lst_Free(srclist);
     Lst_Free(transforms);
 #endif
+}
 /********************* DEBUGGING FUNCTIONS **********************/
 static int SuffPrintName(void *s, void *dummy MAKE_ATTR_UNUSED)
+{
     fprintf(debug_file, "%s ", ((Suff *)s)->name);
     return 0;
+}
 static int
 SuffPrintSuff(void *sp, void *dummy MAKE_ATTR_UNUSED)
+{
     Suff    *s = (Suff *)sp;
     fprintf(debug_file, "# `%s' [%d] ", s->name, s->refCount);
     if (s->flags != 0) {
 	char flags_buf[SuffFlags_ToStringSize];
 	fprintf(debug_file, " (%s)",
 		Enum_FlagsToString(flags_buf, sizeof flags_buf,
 				   s->flags, SuffFlags_ToStringSpecs));
+    }
     fputc('\n', debug_file);
     fprintf(debug_file, "#\tTo: ");
     Lst_ForEach(s->parents, SuffPrintName, NULL);
     fputc('\n', debug_file);
     fprintf(debug_file, "#\tFrom: ");
     Lst_ForEach(s->children, SuffPrintName, NULL);
     fputc('\n', debug_file);
     fprintf(debug_file, "#\tSearch Path: ");
     Dir_PrintPath(s->searchPath);
     fputc('\n', debug_file);
     return 0;
+}
 static int
 SuffPrintTrans(void *tp, void *dummy MAKE_ATTR_UNUSED)
+{
     GNode   *t = (GNode *)tp;
     fprintf(debug_file, "%-16s: ", t->name);
     Targ_PrintType(t->type);
     fputc('\n', debug_file);
     Lst_ForEach(t->commands, Targ_PrintCmd, NULL);
     fputc('\n', debug_file);
     return 0;
+}
 void
 Suff_PrintAll(void)
+{
     fprintf(debug_file, "#*** Suffixes:\n");
     Lst_ForEach(sufflist, SuffPrintSuff, NULL);
     fprintf(debug_file, "#*** Transformations:\n");
     Lst_ForEach(transforms, SuffPrintTrans, NULL);
+}