 @@ -1,14 +1,14 @@
-/*	$NetBSD: suff.c,v 1.281 2020/11/21 23:51:28 rillig Exp $	*/
+/*	$NetBSD: suff.c,v 1.282 2020/11/22 09:30:22 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.
 @@ -104,37 +104,37 @@
  *	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"
 /*	"@(#)suff.c	8.4 (Berkeley) 3/21/94"	*/
-MAKE_RCSID("$NetBSD: suff.c,v 1.281 2020/11/21 23:51:28 rillig Exp $");
+MAKE_RCSID("$NetBSD: suff.c,v 1.282 2020/11/22 09:30:22 rillig Exp $");
 #define SUFF_DEBUG0(text) DEBUG0(SUFF, text)
 #define SUFF_DEBUG1(fmt, arg1) DEBUG1(SUFF, fmt, arg1)
 #define SUFF_DEBUG2(fmt, arg1, arg2) DEBUG2(SUFF, fmt, arg1, arg2)
 typedef List SuffixList;
 typedef ListNode SuffixListNode;
-typedef List SrcList;
+typedef List SrcList;		/* XXX: rename to CandidateList */
-typedef ListNode SrcListNode;
+typedef ListNode SrcListNode;	/* XXX: rename to CandidateListNode */
 static SuffixList *sufflist;	/* List of suffixes */
 #ifdef CLEANUP
 static SuffixList *suffClean;	/* List of suffixes to be cleaned */
 #endif
 /* List of transformation rules, such as ".c.o" */
 static GNodeList *transforms;
 static int sNum = 0;		/* Counter for assigning suffix numbers */
 typedef enum SuffixFlags {
     SUFF_INCLUDE	= 0x01,	/* One which is #include'd */
 @@ -174,40 +174,40 @@ typedef struct Suffix {
      * XXX: These lists are used nowhere, they are just appended to, for no
      * apparent reason.  They do have the side effect of increasing refCount
      * though. */
     SuffixListList *ref;
 } Suffix;
 /*
  * A candidate when searching for implied sources.
+ *
  * For example, when "src.o" is to be made, a typical candidate is "src.c"
  * via the transformation rule ".c.o".  If that doesn't exist, maybe there is
  * another transformation rule ".pas.c" that would make "src.pas" an indirect
  * candidate as well.  The first such chain that leads to an existing file or
- * node is finally made.
+ * node is finally chosen to be made.
  */
-typedef struct Src {
+typedef struct Candidate {
     char *file;			/* The file to look for */
     char *pref;			/* Prefix from which file was formed */
     Suffix *suff;		/* The suffix on the file */
-    struct Src *parent;		/* The Src for which this is a source */
+    struct Candidate *parent;	/* The candidate for which this is a source */
     GNode *node;		/* The node describing the file */
     int numChildren;		/* Count of existing children (so we don't free
 				 * this thing too early or never nuke it) */
 #ifdef DEBUG_SRC
     SrcList *childrenList;
 #endif
-} Src;
+} Candidate;
 /* TODO: Document the difference between nullSuff and emptySuff. */
 /* The NULL suffix for this run */
 static Suffix *nullSuff;
 /* The empty suffix required for POSIX single-suffix transformation rules */
 static Suffix *emptySuff;
 static Suffix *
 Suffix_Ref(Suffix *suff)
+{
     suff->refCount++;
 @@ -857,107 +857,102 @@ Suff_AddLib(const char *sname)
 	  /********** Implicit Source Search Functions *********/
 #ifdef DEBUG_SRC
 static void
 SrcList_PrintAddrs(SrcList *srcList)
+{
     SrcListNode *ln;
     for (ln = srcList->first; ln != NULL; ln = ln->next)
 	debug_printf(" %p", ln->datum);
     debug_printf("\n");
+}
 #endif
-static Src *
+static Candidate *
-SrcNew(char *name, char *pref, Suffix *suff, Src *parent, GNode *gn)
+Candidate_New(char *name, char *pref, Suffix *suff, Candidate *parent,
 	      GNode *gn)
     Src *src = bmake_malloc(sizeof *src);
     Candidate *cand = bmake_malloc(sizeof *cand);
     src->file = name;
-    src->pref = pref;
+    cand->file = name;
-    src->suff = Suffix_Ref(suff);
+    cand->pref = pref;
-    src->parent = parent;
+    cand->suff = Suffix_Ref(suff);
-    src->node = gn;
+    cand->parent = parent;
-    src->numChildren = 0;
+    cand->node = gn;
     cand->numChildren = 0;
 #ifdef DEBUG_SRC
-    src->childrenList = Lst_New();
+    cand->childrenList = Lst_New();
 #endif
-    return src;
+    return cand;
+}
 static void
-SrcList_Add(SrcList *srcList, char *srcName, Src *targ, Suffix *suff,
+SrcList_Add(SrcList *srcList, char *srcName, Candidate *targ, Suffix *suff,
 	    const char *debug_tag)
+{
-    Src *src = SrcNew(srcName, targ->pref, suff, targ, NULL);
+    Candidate *src = Candidate_New(srcName, targ->pref, suff, targ, NULL);
     targ->numChildren++;
     Lst_Append(srcList, src);
 #ifdef DEBUG_SRC
     Lst_Append(targ->childrenList, src);
     debug_printf("%s add suff %p src %p to list %p:",
 		 debug_tag, targ, src, srcList);
     SrcList_PrintAddrs(srcList);
 #endif
+}
-/* 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,
+ * Add a new candidate to the list, formed from the candidate's prefix and
- * the prefix is used unaltered as the filename in the Src structure.
+ * the suffix.
  * Input:
  *	suff		suffix for which to create a Src structure
  *	srcList		list for the new Src
  *	targ		parent for the new Src
  */
 static void
-AddSources(Suffix *suff, SrcList *srcList, Src *targ)
+AddSources(Suffix *suff, SrcList *srcList, Candidate *targ)
+{
     if ((suff->flags & SUFF_NULL) && suff->name[0] != '\0') {
 	/*
-	 * If the suffix has been marked as the NULL suffix, also create a Src
+	 * If the suffix has been marked as the NULL suffix, also create a
-	 * structure for a file with no suffix attached. Two birds, and all
+	 * candidate for a file with no suffix attached.
 	 * that...
 	 */
 	SrcList_Add(srcList, bmake_strdup(targ->pref), targ, suff, "1");
+    }
     SrcList_Add(srcList, str_concat2(targ->pref, suff->name), targ, suff, "2");
+}
 /* Add all the children of targ to the list. */
 static void
-AddLevel(SrcList *srcs, Src *targ)
+AddLevel(SrcList *srcs, Candidate *targ)
+{
     SrcListNode *ln;
     for (ln = targ->suff->children->first; ln != NULL; ln = ln->next) {
 	Suffix *childSuff = ln->datum;
 	AddSources(childSuff, srcs, targ);
+    }
+}
-/* Free the first Src in the list that is not referenced anymore.
+/* Free the first candidate in the list that is not referenced anymore.
- * Return whether a Src was removed. */
+ * Return whether a candidate was removed. */
 static Boolean
 RemoveSrc(SrcList *srcs)
+{
     SrcListNode *ln;
 #ifdef DEBUG_SRC
     debug_printf("cleaning list %p:", srcs);
     SrcList_PrintAddrs(srcs);
 #endif
     for (ln = srcs->first; ln != NULL; ln = ln->next) {
-	Src *src = ln->datum;
+	Candidate *src = ln->datum;
 	if (src->numChildren == 0) {
 	    free(src->file);
 	    if (src->parent == NULL)
 		free(src->pref);
 	    else {
 #ifdef DEBUG_SRC
 		SrcListNode *ln2 = Lst_FindDatum(src->parent->childrenList, src);
 		if (ln2 != NULL)
 		    Lst_Remove(src->parent->childrenList, ln2);
 #endif
 		src->parent->numChildren--;
+	    }
 @@ -973,33 +968,33 @@ RemoveSrc(SrcList *srcs)
 #ifdef DEBUG_SRC
 	else {
 	    debug_printf("keep: list %p src %p children %d:",
 			 srcs, src, src->numChildren);
 	    SrcList_PrintAddrs(src->childrenList);
+	}
 #endif
+    }
     return FALSE;
+}
 /* Find the first existing file/target in srcs. */
-static Src *
+static Candidate *
 FindThem(SrcList *srcs, SrcList *slst)
+{
-    Src *retsrc = NULL;
+    Candidate *retsrc = NULL;
     while (!Lst_IsEmpty(srcs)) {
-	Src *src = Lst_Dequeue(srcs);
+	Candidate *src = Lst_Dequeue(srcs);
 	SUFF_DEBUG1("\ttrying %s...", src->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(src->file) != NULL) {
 #ifdef DEBUG_SRC
 	    debug_printf("remove from list %p src %p\n", srcs, src);
 #endif
 	    retsrc = src;
 	    break;
 @@ -1019,45 +1014,40 @@ FindThem(SrcList *srcs, SrcList *slst)
 	SUFF_DEBUG0("not there\n");
 	AddLevel(srcs, src);
 	Lst_Append(slst, src);
+    }
     if (retsrc) {
 	SUFF_DEBUG0("got it\n");
+    }
     return retsrc;
+}
-/* 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
+ * See if any of the children of the candidate's GNode is one from which the
- * put together for it and returned.
+ * target can be transformed. If there is one, a candidate is put together
  * for it and returned.
  * Input:
  *	targ		Src to play with
  * Results:
  *	The Src of the "winning" child, or NULL.
  */
-static Src *
+static Candidate *
-FindCmds(Src *targ, SrcList *slst)
+FindCmds(Candidate *targ, SrcList *slst)
+{
     GNodeListNode *gln;
     GNode *tgn;			/* Target GNode */
     GNode *sgn;			/* Source GNode */
     size_t prefLen;		/* The length of the defined prefix */
     Suffix *suff;		/* Suffix on matching beastie */
-    Src *ret;			/* Return value */
+    Candidate *ret;		/* Return value */
     char *cp;
     tgn = targ->node;
     prefLen = strlen(targ->pref);
     for (gln = tgn->children->first; gln != NULL; gln = gln->next) {
 	sgn = gln->datum;
 	if (sgn->type & OP_OPTIONAL && Lst_IsEmpty(tgn->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
 @@ -1084,33 +1074,27 @@ FindCmds(Src *targ, SrcList *slst)
 	 * 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.
 	 */
 	if (Lst_FindDatum(suff->parents, targ->suff) != NULL)
 	    break;
+    }
     if (gln == NULL)
 	return NULL;
-    /*
+    ret = Candidate_New(bmake_strdup(sgn->name), targ->pref, suff, targ, sgn);
      * 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 = SrcNew(bmake_strdup(sgn->name), targ->pref, suff, targ, sgn);
     targ->numChildren++;
 #ifdef DEBUG_SRC
     debug_printf("3 add targ %p ret %p\n", targ, ret);
     Lst_Append(targ->childrenList, ret);
 #endif
     Lst_Append(slst, ret);
     SUFF_DEBUG1("\tusing existing source %s\n", sgn->name);
     return ret;
+}
 static void
 ExpandWildcards(GNodeListNode *cln, GNode *pgn)
+{
 @@ -1545,88 +1529,88 @@ FindDepsArchive(GNode *gn, SrcList *slst
     /*
      * 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;
+}
 static void
 FindDepsRegularKnown(const char *name, size_t nameLen, GNode *gn,
 		     SrcList *srcs, SrcList *targs)
+{
     SuffixListNode *ln;
-    Src *targ;
+    Candidate *targ;
     char *pref;
     for (ln = sufflist->first; ln != NULL; ln = ln->next) {
 	Suffix *suff = ln->datum;
 	if (!Suffix_IsSuffix(suff, nameLen, name + nameLen))
 	    continue;
 	pref = bmake_strldup(name, (size_t)(nameLen - suff->nameLen));
-	targ = SrcNew(bmake_strdup(gn->name), pref, suff, NULL, gn);
+	targ = Candidate_New(bmake_strdup(gn->name), pref, suff, NULL, gn);
 	/*
 	 * Add nodes from which the target can be made
 	 */
 	AddLevel(srcs, targ);
 	/*
 	 * Record the target so we can nuke it
 	 */
 	Lst_Append(targs, targ);
+    }
+}
 static void
 FindDepsRegularUnknown(GNode *gn, const char *sopref,
 		       SrcList *srcs, SrcList *targs)
+{
-    Src *targ;
+    Candidate *targ;
     if (!Lst_IsEmpty(targs) || nullSuff == NULL)
 	return;
     SUFF_DEBUG1("\tNo known suffix on %s. Using .NULL suffix\n", gn->name);
-    targ = SrcNew(bmake_strdup(gn->name), bmake_strdup(sopref),
+    targ = Candidate_New(bmake_strdup(gn->name), bmake_strdup(sopref),
 		  nullSuff, NULL, gn);
     /*
      * 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))
 	AddLevel(srcs, targ);
     else {
 	SUFF_DEBUG0("not ");
+    }
     SUFF_DEBUG0("adding suffix rules\n");
     Lst_Append(targs, targ);
+}
 /*
  * 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.
  */
 static void
-FindDepsRegularPath(GNode *gn, Src *targ)
+FindDepsRegularPath(GNode *gn, Candidate *targ)
+{
     if (gn->type & (OP_PHONY | OP_NOPATH))
 	return;
     free(gn->path);
     gn->path = Dir_FindFile(gn->name,
 			    (targ == NULL ? dirSearchPath :
 			     targ->suff->searchPath));
     if (gn->path == NULL)
 	return;
     Var_Set(TARGET, gn->path, gn);
 @@ -1672,30 +1656,30 @@ FindDepsRegularPath(GNode *gn, Src *targ
  * Input:
  *	gn		Node for which to find sources
+ *
  * Side Effects:
  *	Same as Suff_FindDeps
  */
 static void
 FindDepsRegular(GNode *gn, SrcList *slst)
+{
     SrcList *srcs;		/* List of sources at which to look */
     SrcList *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 */
+    Candidate *bottom;		/* Start of found transformation path */
-    Src *src;			/* General Src pointer */
+    Candidate *src;
     char *pref;			/* Prefix to use */
-    Src *targ;			/* General Src target pointer */
+    Candidate *targ;
     const char *name = gn->name;
     size_t nameLen = strlen(name);
     /*
      * Begin at the beginning...
      */
     srcs = Lst_New();
     targs = Lst_New();
     /*
      * 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
 @@ -1779,56 +1763,56 @@ sfnd_abort:
      * 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 = FindCmds(targ, slst);
 	if (src != NULL) {
 	    /*
-	     * Free up all the Src structures in the transformation path
+	     * Free up all the candidates in the transformation path,
-	     * up to, but not including, the parent node.
+	     * up to but not including the parent node.
 	     */
 	    while (bottom != NULL && bottom->parent != NULL) {
 		if (Lst_FindDatum(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
+     * We now have a list of candidates 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
+     * and set the necessary local variables in each target.
      * commands for each target are set from the commands of the
      * 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
+     * node, gn, to be replaced with the commands of the final
-     * transformation rule. Also, the unmade field of gn is incremented.
+     * transformation rule.
      * Etc.
      */
     if (bottom->node == NULL)
 	bottom->node = Targ_GetNode(bottom->file);
     for (src = bottom; src->parent != NULL; src = src->parent) {
 	targ = src->parent;
 	Suffix_Reassign(&src->node->suffix, src->suff);
 	if (targ->node == NULL)
 	    targ->node = Targ_GetNode(targ->file);
 	ApplyTransform(targ->node, src->node,
 @@ -1842,27 +1826,27 @@ sfnd_abort:
 	     * 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 variables.
 	     */
 	    targ->node->type |= OP_DEPS_FOUND;
 	    Var_Set(PREFIX, targ->pref, targ->node);
 	    Var_Set(TARGET, targ->node->name, targ->node);
+	}
+    }
     Suffix_Reassign(&gn->suffix, src->suff);
     /*
-     * Nuke the transformation path and the Src structures left over in the
+     * Nuke the transformation path and the candidates left over in the
      * two lists.
      */
 sfnd_return:
     if (bottom != NULL && Lst_FindDatum(slst, bottom) == NULL)
 	Lst_Append(slst, bottom);
     while (RemoveSrc(srcs) || RemoveSrc(targs))
 	continue;
     Lst_MoveAll(slst, srcs);
     Lst_MoveAll(slst, targs);
+}