 @@ -1,190 +1,189 @@
-#	$NetBSD: Makefile,v 1.93 2020/08/25 16:39:19 rillig Exp $
+#	$NetBSD: Makefile,v 1.94 2020/08/26 23:00:47 rillig Exp $
 #	@(#)Makefile	5.2 (Berkeley) 12/28/90
 PROG=	make
 SRCS=	arch.c
 SRCS+=  buf.c
 SRCS+=  compat.c
 SRCS+=  cond.c
 SRCS+=  dir.c
 SRCS+=  enum.c
 SRCS+=  for.c
 SRCS+=  hash.c
 SRCS+=  job.c
 SRCS+=  lst.c
 SRCS+=  main.c
 SRCS+=	make.c
 SRCS+=  make_malloc.c
 SRCS+=  metachar.c
 SRCS+=  parse.c
 SRCS+=	str.c
 SRCS+=  strlist.c
 SRCS+=  suff.c
 SRCS+=  targ.c
 SRCS+=  trace.c
 SRCS+=  var.c
 SRCS+=  util.c
 HDRS=   buf.h
 HDRS+=  config.h
 HDRS+=  dir.h
 HDRS+=  enum.h
 HDRS+=  hash.h
 HDRS+=  job.h
 HDRS+=  lst.h
 HDRS+=  make.h
 HDRS+=  make_malloc.h
 HDRS+=  meta.h
 HDRS+=  metachar.h
 HDRS+=  nonints.h
 HDRS+=  pathnames.h
 HDRS+=  sprite.h
 HDRS+=  strlist.h
 HDRS+=  trace.h
 # Whether to generate a coverage report after running the tests.
 USE_COVERAGE?=	no		# works only with gcc; clang9 fails to link
 .if ${USE_COVERAGE} == "yes"
 GCOV?=		gcov
 COPTS+=		--coverage -O0 -ggdb
 LDADD+=		--coverage
 .endif
 CLEANFILES+=	*.gcda *.gcno *.gcov
 # Whether to compile using the Undefined Behavior Sanitizer (GCC, Clang).
 USE_UBSAN?=	no
 .if ${USE_UBSAN} == "yes"
 COPTS+=		-fsanitize=undefined
 LDADD+=		-fsanitize=undefined
 .endif
 # Whether to compile with GCC 10 from pkgsrc, during development.
 USE_GCC10?=	no
 .if ${USE_GCC10} == "yes"
 # CC is set further down in this file
 COPTS+=		-Wno-attributes	# for abs and labs
 COPTS.arch.c+=	-Wno-error=format-truncation
 COPTS.dir.c+=	-Wno-error=format-truncation
 COPTS.main.c+=	-Wno-error=format-truncation
 COPTS.meta.c+=	-Wno-error=format-truncation
 COPTS.parse.c+=	-Wno-error=format-truncation
 .endif
 # Whether to compile with GCC 9 from pkgsrc, during development.
 USE_GCC9?=	no
 .if ${USE_GCC9} == "yes"
 # CC is set further down in this file
 COPTS+=		-Wno-attributes	# for abs and labs
 COPTS.arch.c+=	-Wno-error=format-truncation
 COPTS.dir.c+=	-Wno-error=format-truncation
 COPTS.main.c+=	-Wno-error=format-truncation
 COPTS.meta.c+=	-Wno-error=format-truncation
 COPTS.parse.c+=	-Wno-error=format-truncation
 .endif
 # Whether to compile with GCC 8 from pkgsrc, during development.
 USE_GCC8?=	no
 .if ${USE_GCC8} == "yes"
 # CC is set further down in this file
 COPTS+=		-Wno-attributes	# for abs and labs
 COPTS.arch.c+=	-Wno-error=format-truncation
 COPTS.dir.c+=	-Wno-error=format-truncation
 COPTS.main.c+=	-Wno-error=format-truncation
 COPTS.meta.c+=	-Wno-error=format-truncation
 .endif
 USE_META?=	yes
 .if ${USE_META:tl} != "no"
 SRCS+=		meta.c
 CPPFLAGS+=	-DUSE_META
 USE_FILEMON?=	ktrace
 .  if ${USE_FILEMON:tl} != "no"
 .PATH:	${.CURDIR}/filemon
 SRCS+=		filemon_${USE_FILEMON}.c
 CPPFLAGS+=	-DUSE_FILEMON
 CPPFLAGS+=	-DUSE_FILEMON_${USE_FILEMON:tu}
 .    if ${USE_FILEMON} == "dev"
 FILEMON_H?=	/usr/include/dev/filemon/filemon.h
 .      if exists(${FILEMON_H}) && ${FILEMON_H:T} == "filemon.h"
 COPTS.filemon_dev.c+= \
 		-DHAVE_FILEMON_H -I${FILEMON_H:H}
 .      endif
 .    endif
 .  endif
 .endif
 SUBDIR.roff+=	PSD.doc
 .if make(obj) || make(clean)
 SUBDIR+=	unit-tests
 .endif
 ${SRCS:M*.c:.c=.o}: ${HDRS}
 .include <bsd.prog.mk>
 .include <bsd.subdir.mk>
 CPPFLAGS+=	-DMAKE_NATIVE
 COPTS.job.c+=	-Wno-format-nonliteral
 COPTS.parse.c+=	-Wno-format-nonliteral
 COPTS.var.c+=	-Wno-format-nonliteral
 .if ${USE_GCC10} == "yes"
 GCC9BASE?=	/usr/pkg/gcc10
 CC=		${GCC10BASE}/bin/gcc
 GCOV=		${GCC10BASE}/bin/gcov
 .endif
 .if ${USE_GCC9} == "yes"
 GCC9BASE?=	/usr/pkg/gcc9
 CC=		${GCC9BASE}/bin/gcc
 GCOV=		${GCC9BASE}/bin/gcov
 .endif
 .if ${USE_GCC8} == "yes"
 GCC8BASE?=	/usr/pkg/gcc8
 CC=		${GCC8BASE}/bin/gcc
 GCOV=		${GCC8BASE}/bin/gcov
 .endif
 .if defined(TOOLDIR)
 # This is a native NetBSD build, use libutil rather than the local emalloc etc.
 CPPFLAGS+=	-DUSE_EMALLOC
 LDADD+=		-lutil
 DPADD+=		${LIBUTIL}
 .endif
 COPTS.arch.c+=	${GCC_NO_FORMAT_TRUNCATION}
 COPTS.dir.c+=	${GCC_NO_FORMAT_TRUNCATION}
 COPTS.main.c+=	${GCC_NO_FORMAT_TRUNCATION} ${GCC_NO_STRINGOP_TRUNCATION}
 COPTS.meta.c+=	${GCC_NO_FORMAT_TRUNCATION}
 COPTS.parse.c+=	${GCC_NO_FORMAT_TRUNCATION}
 COPTS+=		-Wdeclaration-after-statement
 # For -DCLEANUP and similar feature toggles.
 CPPFLAGS+=	${USER_CPPFLAGS}
 # For overriding -std=gnu99 or similar options.
 CFLAGS+=	${USER_CFLAGS}
 # A simple unit-test driver to help catch regressions
 TEST_MAKE ?= ${.OBJDIR}/${PROG:T}
 test: .MAKE
 	cd ${.CURDIR}/unit-tests \
 	&& MAKEFLAGS= ${TEST_MAKE} -r -m / TEST_MAKE=${TEST_MAKE} ${TESTS:DTESTS=${TESTS:Q}} ${.TARGET}
 .if ${USE_COVERAGE} == yes
 	${GCOV} ${GCOV_OPTS} ${SRCS}
 	sed -i 's,^\([^:]*\): *[0-9]*:,\1: ,' *.gcov
 .endif
 accept sync-mi: .MAKE
 	cd ${.CURDIR}/unit-tests && ${.MAKE} ${.TARGET}
 retest:
 	${.MAKE} -C ${.CURDIR}/unit-tests cleandir
 .if ${USE_COVERAGE} == yes
 	rm -f *.gcov *.gcda
 .endif
 	${.MAKE} test

 @@ -1,522 +1,520 @@
-/*	$NetBSD: hash.c,v 1.26 2020/08/01 14:47:49 rillig Exp $	*/
+/*	$NetBSD: hash.c,v 1.27 2020/08/26 23:00:47 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: hash.c,v 1.26 2020/08/01 14:47:49 rillig Exp $";
+static char rcsid[] = "$NetBSD: hash.c,v 1.27 2020/08/26 23:00:47 rillig Exp $";
 #else
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)hash.c	8.1 (Berkeley) 6/6/93";
 #else
-__RCSID("$NetBSD: hash.c,v 1.26 2020/08/01 14:47:49 rillig Exp $");
+__RCSID("$NetBSD: hash.c,v 1.27 2020/08/26 23:00:47 rillig Exp $");
 #endif
 #endif /* not lint */
 #endif
 /* hash.c --
+ *
  * 	This module contains routines to manipulate a hash table.
  * 	See hash.h for a definition of the structure of the hash
  * 	table.  Hash tables grow automatically as the amount of
  * 	information increases.
  */
 #include "sprite.h"
 #include "make.h"
 #include "hash.h"
 /*
  * Forward references to local procedures that are used before they're
  * defined:
  */
 static void RebuildTable(Hash_Table *);
 /*
  * The following defines the ratio of # entries to # buckets
  * at which we rebuild the table to make it larger.
  */
 #define rebuildLimit 3
 /* The hash function(s) */
 #ifndef HASH
 /* The default: this one matches Gosling's emacs */
 #define HASH(h, key, p) do { \
 	for (h = 0, p = key; *p;) \
 		h = (h << 5) - h + *p++; \
 	} while (0)
 #endif
 /*
  *---------------------------------------------------------
+ *
  * Hash_InitTable --
+ *
  *	This routine just sets up the hash table.
+ *
  * Input:
  *	t		Structure to to hold table.
  *	numBuckets	How many buckets to create for starters. This
  *			number is rounded up to a power of two.   If
  *			<= 0, a reasonable default is chosen. The
  *			table will grow in size later as needed.
+ *
  * Results:
  *	None.
+ *
  * Side Effects:
  *	Memory is allocated for the initial bucket area.
+ *
  *---------------------------------------------------------
  */
 void
 Hash_InitTable(Hash_Table *t, int numBuckets)
+{
 	int i;
 	struct Hash_Entry **hp;
 	/*
 	 * Round up the size to a power of two.
 	 */
 	if (numBuckets <= 0)
 		i = 16;
 	else {
 		for (i = 2; i < numBuckets; i <<= 1)
 			 continue;
+	}
 	t->numEntries = 0;
 	t->maxchain = 0;
 	t->size = i;
 	t->mask = i - 1;
 	t->bucketPtr = hp = bmake_malloc(sizeof(*hp) * i);
 	while (--i >= 0)
 		*hp++ = NULL;
+}
 /*
  *---------------------------------------------------------
+ *
  * Hash_DeleteTable --
+ *
  *	This routine removes everything from a hash table
  *	and frees up the memory space it occupied (except for
  *	the space in the Hash_Table structure).
+ *
  * Results:
  *	None.
+ *
  * Side Effects:
  *	Lots of memory is freed up.
+ *
  *---------------------------------------------------------
  */
 void
 Hash_DeleteTable(Hash_Table *t)
+{
 	struct Hash_Entry **hp, *h, *nexth = NULL;
 	int i;
 	for (hp = t->bucketPtr, i = t->size; --i >= 0;) {
 		for (h = *hp++; h != NULL; h = nexth) {
 			nexth = h->next;
 			free(h);
+		}
+	}
 	free(t->bucketPtr);
 	/*
 	 * Set up the hash table to cause memory faults on any future access
 	 * attempts until re-initialization.
 	 */
 	t->bucketPtr = NULL;
+}
 /*
  *---------------------------------------------------------
+ *
  * Hash_FindEntry --
+ *
  * 	Searches a hash table for an entry corresponding to key.
+ *
  * Input:
  *	t		Hash table to search.
  *	key		A hash key.
+ *
  * Results:
  *	The return value is a pointer to the entry for key,
  *	if key was present in the table.  If key was not
  *	present, NULL is returned.
+ *
  * Side Effects:
  *	None.
+ *
  *---------------------------------------------------------
  */
 Hash_Entry *
 Hash_FindEntry(Hash_Table *t, const char *key)
+{
 	Hash_Entry *e;
 	unsigned h;
 	const char *p;
 	int chainlen;
 	if (t == NULL || t->bucketPtr == NULL) {
 	    return NULL;
+	}
 	HASH(h, key, p);
 	p = key;
 	chainlen = 0;
 #ifdef DEBUG_HASH_LOOKUP
 	if (DEBUG(HASH))
 		fprintf(debug_file, "%s: %p h=%x key=%s\n", __func__,
 		    t, h, key);
 #endif
 	for (e = t->bucketPtr[h & t->mask]; e != NULL; e = e->next) {
 		chainlen++;
 		if (e->namehash == h && strcmp(e->name, p) == 0)
 			break;
+	}
 	if (chainlen > t->maxchain)
 		t->maxchain = chainlen;
 	return e;
+}
 /*
  *---------------------------------------------------------
+ *
  * Hash_CreateEntry --
+ *
  *	Searches a hash table for an entry corresponding to
  *	key.  If no entry is found, then one is created.
+ *
  * Input:
  *	t		Hash table to search.
  *	key		A hash key.
  *	newPtr		Filled in with TRUE if new entry created,
  *			FALSE otherwise.
+ *
  * Results:
  *	The return value is a pointer to the entry.  If *newPtr
  *	isn't NULL, then *newPtr is filled in with TRUE if a
  *	new entry was created, and FALSE if an entry already existed
  *	with the given key.
+ *
  * Side Effects:
  *	Memory may be allocated, and the hash buckets may be modified.
  *---------------------------------------------------------
  */
 Hash_Entry *
 Hash_CreateEntry(Hash_Table *t, const char *key, Boolean *newPtr)
+{
 	Hash_Entry *e;
 	unsigned h;
 	const char *p;
 	int keylen;
 	int chainlen;
 	struct Hash_Entry **hp;
 	/*
 	 * Hash the key.  As a side effect, save the length (strlen) of the
 	 * key in case we need to create the entry.
 	 */
 	HASH(h, key, p);
 	keylen = p - key;
 	p = key;
 	chainlen = 0;
 #ifdef DEBUG_HASH_LOOKUP
 	if (DEBUG(HASH))
 		fprintf(debug_file, "%s: %p h=%x key=%s\n", __func__,
 		    t, h, key);
 #endif
 	for (e = t->bucketPtr[h & t->mask]; e != NULL; e = e->next) {
 		chainlen++;
 		if (e->namehash == h && strcmp(e->name, p) == 0) {
 			if (newPtr != NULL)
 				*newPtr = FALSE;
 			break;
+		}
+	}
 	if (chainlen > t->maxchain)
 		t->maxchain = chainlen;
 	if (e)
 		return e;
 	/*
 	 * The desired entry isn't there.  Before allocating a new entry,
 	 * expand the table if necessary (and this changes the resulting
 	 * bucket chain).
 	 */
 	if (t->numEntries >= rebuildLimit * t->size)
 		RebuildTable(t);
 	e = bmake_malloc(sizeof(*e) + keylen);
 	hp = &t->bucketPtr[h & t->mask];
 	e->next = *hp;
 	*hp = e;
 	Hash_SetValue(e, NULL);
 	e->namehash = h;
 	(void)strcpy(e->name, p);
 	t->numEntries++;
 	if (newPtr != NULL)
 		*newPtr = TRUE;
 	return e;
+}
 /*
  *---------------------------------------------------------
+ *
  * Hash_DeleteEntry --
+ *
  * 	Delete the given hash table entry and free memory associated with
  *	it.
+ *
  * Results:
  *	None.
+ *
  * Side Effects:
  *	Hash chain that entry lives in is modified and memory is freed.
+ *
  *---------------------------------------------------------
  */
 void
 Hash_DeleteEntry(Hash_Table *t, Hash_Entry *e)
+{
 	Hash_Entry **hp, *p;
 	if (e == NULL)
 		return;
 	for (hp = &t->bucketPtr[e->namehash & t->mask];
 	     (p = *hp) != NULL; hp = &p->next) {
 		if (p == e) {
 			*hp = p->next;
 			free(p);
 			t->numEntries--;
 			return;
+		}
+	}
 	(void)write(2, "bad call to Hash_DeleteEntry\n", 29);
 	abort();
+}
 /*
  *---------------------------------------------------------
+ *
  * Hash_EnumFirst --
  *	This procedure sets things up for a complete search
  *	of all entries recorded in the hash table.
+ *
  * Input:
  *	t		Table to be searched.
  *	searchPtr	Area in which to keep state about search.
+ *
  * Results:
  *	The return value is the address of the first entry in
  *	the hash table, or NULL if the table is empty.
+ *
  * Side Effects:
  *	The information in searchPtr is initialized so that successive
  *	calls to Hash_Next will return successive HashEntry's
  *	from the table.
+ *
  *---------------------------------------------------------
  */
 Hash_Entry *
 Hash_EnumFirst(Hash_Table *t, Hash_Search *searchPtr)
+{
 	searchPtr->tablePtr = t;
 	searchPtr->nextIndex = 0;
 	searchPtr->hashEntryPtr = NULL;
 	return Hash_EnumNext(searchPtr);
+}
 /*
  *---------------------------------------------------------
+ *
  * Hash_EnumNext --
  *    This procedure returns successive entries in the hash table.
+ *
  * Input:
  *	searchPtr	Area used to keep state about search.
+ *
  * Results:
  *    The return value is a pointer to the next HashEntry
  *    in the table, or NULL when the end of the table is
  *    reached.
+ *
  * Side Effects:
  *    The information in searchPtr is modified to advance to the
  *    next entry.
+ *
  *---------------------------------------------------------
  */
 Hash_Entry *
 Hash_EnumNext(Hash_Search *searchPtr)
+{
 	Hash_Entry *e;
 	Hash_Table *t = searchPtr->tablePtr;
 	/*
 	 * The hashEntryPtr field points to the most recently returned
 	 * entry, or is nil if we are starting up.  If not nil, we have
 	 * to start at the next one in the chain.
 	 */
 	e = searchPtr->hashEntryPtr;
 	if (e != NULL)
 		e = e->next;
 	/*
 	 * If the chain ran out, or if we are starting up, we need to
 	 * find the next nonempty chain.
 	 */
 	while (e == NULL) {
 		if (searchPtr->nextIndex >= t->size)
 			return NULL;
 		e = t->bucketPtr[searchPtr->nextIndex++];
+	}
 	searchPtr->hashEntryPtr = e;
 	return e;
+}
 /*
  *---------------------------------------------------------
+ *
  * RebuildTable --
  *	This local routine makes a new hash table that
  *	is larger than the old one.
+ *
  * Results:
  * 	None.
+ *
  * Side Effects:
  *	The entire hash table is moved, so any bucket numbers
  *	from the old table are invalid.
+ *
  *---------------------------------------------------------
  */
 static void
 RebuildTable(Hash_Table *t)
+{
 	Hash_Entry *e, *next = NULL, **hp, **xp;
 	int i, mask;
 	Hash_Entry **oldhp;
 	int oldsize;
 	oldhp = t->bucketPtr;
 	oldsize = i = t->size;
 	i <<= 1;
 	t->size = i;
 	t->mask = mask = i - 1;
 	t->bucketPtr = hp = bmake_malloc(sizeof(*hp) * i);
 	while (--i >= 0)
 		*hp++ = NULL;
 	for (hp = oldhp, i = oldsize; --i >= 0;) {
 		for (e = *hp++; e != NULL; e = next) {
 			next = e->next;
 			xp = &t->bucketPtr[e->namehash & mask];
 			e->next = *xp;
 			*xp = e;
+		}
+	}
 	free(oldhp);
 	if (DEBUG(HASH))
 		fprintf(debug_file, "%s: %p size=%d entries=%d maxchain=%d\n",
 		    __func__, t, t->size, t->numEntries, t->maxchain);
 	t->maxchain = 0;
+}
 void Hash_ForEach(Hash_Table *t, void (*action)(void *, void *), void *data)
+{
 	Hash_Search search;
 	Hash_Entry *e;
 	for (e = Hash_EnumFirst(t, &search);
 	     e != NULL;
 	     e = Hash_EnumNext(&search))
 		action(Hash_GetValue(e), data);
+}
 void
 Hash_DebugStats(Hash_Table *t, const char *name)
+{
     if (DEBUG(HASH))
 	fprintf(debug_file, "Hash_Table %s: size=%d numEntries=%d maxchain=%d\n",
 		name, t->size, t->numEntries, t->maxchain);
+}

 @@ -1,191 +1,189 @@
-/*	$NetBSD: lst.h,v 1.44 2020/08/26 22:55:46 rillig Exp $	*/
+/*	$NetBSD: lst.h,v 1.45 2020/08/26 23:00:47 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.
+ *
  *	from: @(#)lst.h	8.1 (Berkeley) 6/6/93
  */
 /*
  * 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.
+ *
  *	from: @(#)lst.h	8.1 (Berkeley) 6/6/93
  */
 /*-
  * lst.h --
  *	Header for using the list library
  */
 #ifndef MAKE_LST_H
 #define MAKE_LST_H
 #include	<sys/param.h>
 #include	<stdlib.h>
 #include	"sprite.h"
 /*
  * basic typedef. This is what the Lst_ functions handle
  */
 typedef	struct List	*Lst;
 typedef	struct ListNode	*LstNode;
 typedef void *LstCopyProc(void *);
 typedef void LstFreeProc(void *);
 typedef int LstFindProc(const void *, const void *);
 typedef int LstActionProc(void *, void *);
 /*
  * Creation/destruction functions
  */
 /* Create a new list */
 Lst		Lst_Init(void);
 /* Duplicate an existing list */
 Lst		Lst_CopyS(Lst, LstCopyProc);
 /* Destroy an old one */
 void		Lst_FreeS(Lst);
 void		Lst_DestroyS(Lst, LstFreeProc);
 /* True if list is empty */
 Boolean		Lst_IsEmpty(Lst);
 Boolean		Lst_IsEmptyS(Lst);
 /*
  * Functions to modify a list
  */
 /* Insert an element before another */
 void		Lst_InsertBeforeS(Lst, LstNode, void *);
 /* Place an element at the front of a lst. */
 void		Lst_PrependS(Lst, void *);
 /* Place an element at the end of a lst. */
 void		Lst_AppendS(Lst, void *);
 /* Remove an element */
 void		Lst_RemoveS(Lst, LstNode);
 /* Replace a node with a new value */
 void		LstNode_SetS(LstNode, void *);
 void		LstNode_SetNullS(LstNode);
 void		Lst_PrependAllS(Lst, Lst);
 void		Lst_AppendAllS(Lst, Lst);
 void		Lst_MoveAllS(Lst, Lst);
 /*
  * Node-specific functions
  */
 /* Return first element in list */
 LstNode		Lst_First(Lst);
 LstNode		Lst_FirstS(Lst);
 /* Return last element in list */
 LstNode		Lst_Last(Lst);
 LstNode		Lst_LastS(Lst);
 /* Return successor to given element */
 LstNode		Lst_Succ(LstNode);
 LstNode		Lst_SuccS(LstNode);
 /* Return predecessor to given element */
 LstNode		Lst_PrevS(LstNode);
 /* Get datum from LstNode */
 void		*Lst_DatumS(LstNode);
 /*
  * Functions for entire lists
  */
 /* Find an element in a list */
 LstNode		Lst_Find(Lst, LstFindProc, const void *);
 LstNode		Lst_FindS(Lst, LstFindProc, const void *);
 /* Find an element starting from somewhere */
 LstNode		Lst_FindFrom(Lst, LstNode, LstFindProc, const void *);
 LstNode		Lst_FindFromS(Lst, LstNode, LstFindProc, const void *);
 /*
  * See if the given datum is on the list. Returns the LstNode containing
  * the datum
  */
 LstNode		Lst_MemberS(Lst, void *);
 /* Apply a function to all elements of a lst */
 int		Lst_ForEach(Lst, LstActionProc, void *);
 int		Lst_ForEachS(Lst, LstActionProc, void *);
 /* Apply a function to all elements of a lst starting from a certain point. */
 int		Lst_ForEachFrom(Lst, LstNode, LstActionProc, void *);
 int		Lst_ForEachFromS(Lst, LstNode, LstActionProc, void *);
 /*
  * 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().
  */
 /* Open the list */
 ReturnStatus	Lst_Open(Lst);
 void		Lst_OpenS(Lst);
 /* Next element please, or NULL */
 LstNode		Lst_NextS(Lst);
 /* Finish table access */
 void		Lst_CloseS(Lst);
 /*
  * for using the list as a queue
  */
 /* Place an element at tail of queue */
 void		Lst_EnqueueS(Lst, void *);
 /* Remove an element from head of queue */
 void		*Lst_DequeueS(Lst);
 #endif /* MAKE_LST_H */

 @@ -1,551 +1,581 @@
-/*	$NetBSD: make.h,v 1.126 2020/08/24 20:15:51 rillig Exp $	*/
+/*	$NetBSD: make.h,v 1.127 2020/08/26 23:00:47 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.
+ *
  *	from: @(#)make.h	8.3 (Berkeley) 6/13/95
  */
 /*
  * 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.
+ *
  *	from: @(#)make.h	8.3 (Berkeley) 6/13/95
  */
 /*-
  * make.h --
  *	The global definitions for pmake
  */
 #ifndef MAKE_MAKE_H
 #define MAKE_MAKE_H
 #include <sys/types.h>
 #include <sys/param.h>
 #include <assert.h>
 #include <ctype.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #ifdef BSD4_4
 # include <sys/cdefs.h>
 #endif
 #ifndef FD_CLOEXEC
 #define FD_CLOEXEC 1
 #endif
 #if defined(__GNUC__)
 #define	MAKE_GNUC_PREREQ(x, y)						\
 	((__GNUC__ == (x) && __GNUC_MINOR__ >= (y)) ||			\
 	 (__GNUC__ > (x)))
 #else /* defined(__GNUC__) */
 #define	MAKE_GNUC_PREREQ(x, y)	0
 #endif /* defined(__GNUC__) */
 #if MAKE_GNUC_PREREQ(2, 7)
 #define	MAKE_ATTR_UNUSED	__attribute__((__unused__))
 #else
 #define	MAKE_ATTR_UNUSED	/* delete */
 #endif
 #if MAKE_GNUC_PREREQ(2, 5)
 #define	MAKE_ATTR_DEAD		__attribute__((__noreturn__))
 #elif defined(__GNUC__)
 #define	MAKE_ATTR_DEAD		__volatile
 #else
 #define	MAKE_ATTR_DEAD		/* delete */
 #endif
 #if MAKE_GNUC_PREREQ(2, 7)
 #define MAKE_ATTR_PRINTFLIKE(fmtarg, firstvararg)	\
 	    __attribute__((__format__ (__printf__, fmtarg, firstvararg)))
 #else
 #define MAKE_ATTR_PRINTFLIKE(fmtarg, firstvararg)	/* delete */
 #endif
-#include "sprite.h"
+/*
  * A boolean type is defined as an integer, not an enum. This allows a
  * boolean argument to be an expression that isn't strictly 0 or 1 valued.
  */
 typedef int Boolean;
 #ifndef TRUE
 #define TRUE	1
 #endif /* TRUE */
 #ifndef FALSE
 #define FALSE	0
 #endif /* FALSE */
 /*
  * Functions that must return a status can return a ReturnStatus to
  * indicate success or type of failure.
  */
 typedef int  ReturnStatus;
 /*
  * The following statuses overlap with the first 2 generic statuses
  * defined in status.h:
+ *
  * SUCCESS			There was no error.
  * FAILURE			There was a general error.
  */
 #define	SUCCESS			0x00000000
 #define	FAILURE			0x00000001
 #include "lst.h"
 #include "hash.h"
 #include "config.h"
 #include "buf.h"
 #include "make_malloc.h"
 typedef enum  {
     UNMADE,			/* Not examined yet */
     DEFERRED,			/* Examined once (building child) */
     REQUESTED,			/* on toBeMade list */
     BEINGMADE,			/* Target is already being made.
 				 * Indicates a cycle in the graph. */
     MADE,			/* Was out-of-date and has been made */
     UPTODATE,			/* Was already up-to-date */
     ERROR,			/* An error occurred while it was being
 				 * made (used only in compat mode) */
     ABORTED			/* The target was aborted due to an error
 				 * making an inferior (compat). */
 } GNodeMade;
 /* The OP_ constants are used when parsing a dependency line as a way of
  * communicating to other parts of the program the way in which a target
  * should be made.
+ *
  * These constants are bitwise-OR'ed together and placed in the 'type' field
  * of each node. Any node that has a 'type' field which satisfies the OP_NOP
  * function was never never on the left-hand side of an operator, though it
  * may have been on the right-hand side... */
 typedef enum {
     /* Execution of commands depends on children (:) */
     OP_DEPENDS		= 1 << 0,
     /* Always execute commands (!) */
     OP_FORCE		= 1 << 1,
     /* Execution of commands depends on children per line (::) */
     OP_DOUBLEDEP	= 1 << 2,
     OP_OPMASK		= OP_DEPENDS|OP_FORCE|OP_DOUBLEDEP,
     /* Don't care if the target doesn't exist and can't be created */
     OP_OPTIONAL		= 1 << 3,
     /* Use associated commands for parents */
     OP_USE		= 1 << 4,
     /* Target is never out of date, but always execute commands anyway.
      * Its time doesn't matter, so it has none...sort of */
     OP_EXEC	  	= 1 << 5,
     /* Ignore errors when creating the node */
     OP_IGNORE		= 1 << 6,
     /* Don't remove the target when interrupted */
     OP_PRECIOUS		= 1 << 7,
     /* Don't echo commands when executed */
     OP_SILENT		= 1 << 8,
     /* Target is a recursive make so its commands should always be executed
      * when it is out of date, regardless of the state of the -n or -t flags */
     OP_MAKE		= 1 << 9,
     /* Target is out-of-date only if any of its children was out-of-date */
     OP_JOIN		= 1 << 10,
     /* Assume the children of the node have been already made */
     OP_MADE		= 1 << 11,
     /* Special .BEGIN, .END, .INTERRUPT */
     OP_SPECIAL		= 1 << 12,
     /* Like .USE, only prepend commands */
     OP_USEBEFORE	= 1 << 13,
     /* The node is invisible to its parents. I.e. it doesn't show up in the
      * parents' local variables. */
     OP_INVISIBLE	= 1 << 14,
     /* The node is exempt from normal 'main target' processing in parse.c */
     OP_NOTMAIN		= 1 << 15,
     /* Not a file target; run always */
     OP_PHONY		= 1 << 16,
     /* Don't search for file in the path */
     OP_NOPATH		= 1 << 17,
     /* .WAIT phony node */
     OP_WAIT		= 1 << 18,
     /* .NOMETA do not create a .meta file */
     OP_NOMETA		= 1 << 19,
     /* .META we _do_ want a .meta file */
     OP_META		= 1 << 20,
     /* Do not compare commands in .meta file */
     OP_NOMETA_CMP	= 1 << 21,
     /* Possibly a submake node */
     OP_SUBMAKE		= 1 << 22,
     /* Attributes applied by PMake */
     /* The node is a transformation rule */
     OP_TRANSFORM	= 1 << 31,
     /* Target is a member of an archive */
     OP_MEMBER		= 1 << 30,
     /* Target is a library */
     OP_LIB		= 1 << 29,
     /* Target is an archive construct */
     OP_ARCHV		= 1 << 28,
     /* Target has all the commands it should. Used when parsing to catch
      * multiple commands for a target. */
     OP_HAS_COMMANDS	= 1 << 27,
     /* Saving commands on .END (Compat) */
     OP_SAVE_CMDS	= 1 << 26,
     /* Already processed by Suff_FindDeps */
     OP_DEPS_FOUND	= 1 << 25,
     /* Node found while expanding .ALLSRC */
     OP_MARK		= 1 << 24
 } GNodeType;
 typedef enum {
     REMAKE	= 0x0001,	/* this target needs to be (re)made */
     CHILDMADE	= 0x0002,	/* children of this target were made */
     FORCE	= 0x0004,	/* children don't exist, and we pretend made */
     DONE_WAIT	= 0x0008,	/* Set by Make_ProcessWait() */
     DONE_ORDER	= 0x0010,	/* Build requested by .ORDER processing */
     FROM_DEPEND	= 0x0020,	/* Node created from .depend */
     DONE_ALLSRC	= 0x0040,	/* We do it once only */
     CYCLE	= 0x1000,	/* Used by MakePrintStatus */
     DONECYCLE	= 0x2000,	/* Used by MakePrintStatus */
     INTERNAL	= 0x4000	/* Internal use only */
 } GNodeFlags;
 /* A graph node represents a target that can possibly be made, including its
  * relation to other targets and a lot of other details. */
 typedef struct GNode {
     /* The target's name, such as "clean" or "make.c" */
     char *name;
     /* The unexpanded name of a .USE node */
     char *uname;
     /* The full pathname of the file belonging to the target.
      * XXX: What about .PHONY targets? These don't have an associated path. */
     char *path;
     /* The type of operator used to define the sources (see the OP flags below).
      * XXX: This looks like a wild mixture of type and flags. */
     GNodeType type;
     /* whether it is involved in this invocation of make */
     GNodeFlags flags;
     /* The state of processing on this node */
     GNodeMade made;
     int unmade;			/* The number of unmade children */
     time_t mtime;		/* Its modification time */
     struct GNode *cmgn;		/* The youngest child */
     /* Links to parents for which this is an implied source. May be empty.
      * Nodes that depend on this, as gleaned from the transformation rules. */
     Lst iParents;
     /* Other nodes of the same name for the :: operator. */
     Lst cohorts;
     /* The nodes that depend on this one, or in other words, the nodes for
      * which this is a source. */
     Lst parents;
     /* The nodes on which this one depends. */
     Lst children;
     /* .ORDER nodes we need made. The nodes that must be made (if they're
      * made) before this node can be made, but that do not enter into the
      * datedness of this node. */
     Lst order_pred;
     /* .ORDER nodes who need us. The nodes that must be made (if they're made
      * at all) after this node is made, but that do not depend on this node,
      * in the normal sense. */
     Lst order_succ;
     /* #n for this cohort */
     char cohort_num[8];
     /* The number of unmade instances on the cohorts list */
     int unmade_cohorts;
     /* Pointer to the first instance of a :: node; only set when on a cohorts
      * list */
     struct GNode *centurion;
     /* Last time (sequence number) we tried to make this node */
     unsigned int checked;
     /* The "local" variables that are specific to this target and this target
      * only, such as $@, $<, $?. */
     Hash_Table context;
     /* The commands to be given to a shell to create this target. */
     Lst commands;
     /* Suffix for the node (determined by Suff_FindDeps and opaque to everyone
      * but the Suff module) */
     struct Suff *suffix;
     /* filename where the GNode got defined */
     const char *fname;
     /* line number where the GNode got defined */
     int lineno;
 } GNode;
 #define NoExecute(gn) ((gn->type & OP_MAKE) ? noRecursiveExecute : noExecute)
 /*
  * OP_NOP will return TRUE if the node with the given type was not the
  * object of a dependency operator
  */
 #define OP_NOP(t)	(((t) & OP_OPMASK) == 0x00000000)
 #define OP_NOTARGET (OP_NOTMAIN|OP_USE|OP_EXEC|OP_TRANSFORM)
 /*
  * The TARG_ constants are used when calling the Targ_FindNode and
  * Targ_FindList functions in targ.c. They simply tell the functions what to
  * do if the desired node(s) is (are) not found. If the TARG_CREATE constant
  * is given, a new, empty node will be created for the target, placed in the
  * table of all targets and its address returned. If TARG_NOCREATE is given,
  * a NULL pointer will be returned.
  */
 #define TARG_NOCREATE	0x00	  /* don't create it */
 #define TARG_CREATE	0x01	  /* create node if not found */
 #define TARG_NOHASH	0x02	  /* don't look in/add to hash table */
 /*
  * Error levels for parsing. PARSE_FATAL means the process cannot continue
  * once the makefile has been parsed. PARSE_WARNING means it can. Passed
  * as the first argument to Parse_Error.
  */
 #define PARSE_INFO	3
 #define PARSE_WARNING	2
 #define PARSE_FATAL	1
 /*
  * Values returned by Cond_Eval.
  */
 typedef enum {
     COND_PARSE,			/* Parse the next lines */
     COND_SKIP,			/* Skip the next lines */
     COND_INVALID		/* Not a conditional statement */
 } CondEvalResult;
 /*
  * Definitions for the "local" variables. Used only for clarity.
  */
 #define TARGET	  	  "@" 	/* Target of dependency */
 #define OODATE	  	  "?" 	/* All out-of-date sources */
 #define ALLSRC	  	  ">" 	/* All sources */
 #define IMPSRC	  	  "<" 	/* Source implied by transformation */
 #define PREFIX	  	  "*" 	/* Common prefix */
 #define ARCHIVE	  	  "!" 	/* Archive in "archive(member)" syntax */
 #define MEMBER	  	  "%" 	/* Member in "archive(member)" syntax */
 #define FTARGET           "@F"  /* file part of TARGET */
 #define DTARGET           "@D"  /* directory part of TARGET */
 #define FIMPSRC           "<F"  /* file part of IMPSRC */
 #define DIMPSRC           "<D"  /* directory part of IMPSRC */
 #define FPREFIX           "*F"  /* file part of PREFIX */
 #define DPREFIX           "*D"  /* directory part of PREFIX */
 /*
  * Global Variables
  */
 extern Lst  	create;	    	/* The list of target names specified on the
 				 * command line. used to resolve #if
 				 * make(...) statements */
 extern Lst     	dirSearchPath; 	/* The list of directories to search when
 				 * looking for targets */
 extern Boolean	compatMake;	/* True if we are make compatible */
 extern Boolean	ignoreErrors;  	/* True if should ignore all errors */
 extern Boolean  beSilent;    	/* True if should print no commands */
 extern Boolean  noExecute;    	/* True if should execute nothing */
 extern Boolean  noRecursiveExecute;    	/* True if should execute nothing */
 extern Boolean  allPrecious;   	/* True if every target is precious */
 extern Boolean  deleteOnError;	/* True if failed targets should be deleted */
 extern Boolean  keepgoing;    	/* True if should continue on unaffected
 				 * portions of the graph when have an error
 				 * in one portion */
 extern Boolean 	touchFlag;    	/* TRUE if targets should just be 'touched'
 				 * if out of date. Set by the -t flag */
 extern Boolean 	queryFlag;    	/* TRUE if we aren't supposed to really make
 				 * anything, just see if the targets are out-
 				 * of-date */
 extern Boolean	doing_depend;	/* TRUE if processing .depend */
 extern Boolean	checkEnvFirst;	/* TRUE if environment should be searched for
 				 * variables before the global context */
 extern Boolean	parseWarnFatal;	/* TRUE if makefile parsing warnings are
 				 * treated as errors */
 extern Boolean	varNoExportEnv;	/* TRUE if we should not export variables
 				 * set on the command line to the env. */
 extern GNode    *DEFAULT;    	/* .DEFAULT rule */
 extern GNode	*VAR_INTERNAL;	/* Variables defined internally by make
 				 * which should not override those set by
 				 * makefiles.
 				 */
 extern GNode    *VAR_GLOBAL;   	/* Variables defined in a global context, e.g
 				 * in the Makefile itself */
 extern GNode    *VAR_CMD;    	/* Variables defined on the command line */
 extern char    	var_Error[];   	/* Value returned by Var_Parse when an error
 				 * is encountered. It actually points to
 				 * an empty string, so naive callers needn't
 				 * worry about it. */
 extern time_t 	now;	    	/* The time at the start of this whole
 				 * process */
 extern Boolean	oldVars;    	/* Do old-style variable substitution */
 extern Lst	sysIncPath;	/* The system include path. */
 extern Lst	defIncPath;	/* The default include path. */
 extern char	curdir[];	/* Startup directory */
 extern char	*progname;	/* The program name */
 extern char	*makeDependfile; /* .depend */
 extern char	**savedEnv;	 /* if we replaced environ this will be non-NULL */
 extern int	makelevel;
 /*
  * We cannot vfork() in a child of vfork().
  * Most systems do not enforce this but some do.
  */
 #define vFork() ((getpid() == myPid) ? vfork() : fork())
 extern pid_t	myPid;
 #define	MAKEFLAGS	".MAKEFLAGS"
 #define	MAKEOVERRIDES	".MAKEOVERRIDES"
 #define	MAKE_JOB_PREFIX	".MAKE.JOB.PREFIX" /* prefix for job target output */
 #define	MAKE_EXPORTED	".MAKE.EXPORTED"   /* variables we export */
 #define	MAKE_MAKEFILES	".MAKE.MAKEFILES"  /* all the makefiles we read */
 #define	MAKE_LEVEL	".MAKE.LEVEL"	   /* recursion level */
 #define MAKEFILE_PREFERENCE ".MAKE.MAKEFILE_PREFERENCE"
 #define MAKE_DEPENDFILE	".MAKE.DEPENDFILE" /* .depend */
 #define MAKE_MODE	".MAKE.MODE"
 #ifndef MAKE_LEVEL_ENV
 # define MAKE_LEVEL_ENV	"MAKELEVEL"
 #endif
 /*
  * debug control:
  *	There is one bit per module.  It is up to the module what debug
  *	information to print.
  */
 extern FILE *debug_file;	/* Output is written here - default stderr */
 extern int debug;
 #define	DEBUG_ARCH	0x00001
 #define	DEBUG_COND	0x00002
 #define	DEBUG_DIR	0x00004
 #define	DEBUG_GRAPH1	0x00008
 #define	DEBUG_GRAPH2	0x00010
 #define	DEBUG_JOB	0x00020
 #define	DEBUG_MAKE	0x00040
 #define	DEBUG_SUFF	0x00080
 #define	DEBUG_TARG	0x00100
 #define	DEBUG_VAR	0x00200
 #define DEBUG_FOR	0x00400
 #define DEBUG_SHELL	0x00800
 #define DEBUG_ERROR	0x01000
 #define DEBUG_LOUD	0x02000
 #define DEBUG_META	0x04000
 #define DEBUG_HASH	0x08000
 #define DEBUG_GRAPH3	0x10000
 #define DEBUG_SCRIPT	0x20000
 #define DEBUG_PARSE	0x40000
 #define DEBUG_CWD	0x80000
 #define DEBUG_LINT	0x100000
 #define CONCAT(a,b)	a##b
 #define	DEBUG(module)	(debug & CONCAT(DEBUG_,module))
 #include "nonints.h"
 int Make_TimeStamp(GNode *, GNode *);
 Boolean Make_OODate(GNode *);
 void Make_ExpandUse(Lst);
 time_t Make_Recheck(GNode *);
 void Make_HandleUse(GNode *, GNode *);
 void Make_Update(GNode *);
 void Make_DoAllVar(GNode *);
 Boolean Make_Run(Lst);
 int dieQuietly(GNode *, int);
 void PrintOnError(GNode *, const char *);
 void Main_ExportMAKEFLAGS(Boolean);
 Boolean Main_SetObjdir(const char *, ...) MAKE_ATTR_PRINTFLIKE(1, 2);
 int mkTempFile(const char *, char **);
 int str2Lst_Append(Lst, char *, const char *);
 int cached_lstat(const char *, void *);
 int cached_stat(const char *, void *);
 void GNode_FprintDetails(FILE *, const char *, const GNode *, const char *);
 #ifdef __GNUC__
 #define UNCONST(ptr)	({ 		\
     union __unconst {			\
 	const void *__cp;		\
 	void *__p;			\
     } __d;				\
     __d.__cp = ptr, __d.__p; })
 #else
 #define UNCONST(ptr)	(void *)(ptr)
 #endif
 #ifndef MIN
 #define MIN(a, b) ((a < b) ? a : b)
 #endif
 #ifndef MAX
 #define MAX(a, b) ((a > b) ? a : b)
 #endif
 /* At least GNU/Hurd systems lack hardcoded MAXPATHLEN/PATH_MAX */
 #include <limits.h>
 #ifndef MAXPATHLEN
 #define MAXPATHLEN	4096
 #endif
 #ifndef PATH_MAX
 #define PATH_MAX	MAXPATHLEN
 #endif
 #if defined(SYSV)
 #define KILLPG(pid, sig)	kill(-(pid), (sig))
 #else
 #define KILLPG(pid, sig)	killpg((pid), (sig))
 #endif
 #endif /* MAKE_MAKE_H */