Module Name: src
Committed By: rillig
Date: Mon Oct 5 16:45:03 UTC 2020
Modified Files:
src/usr.bin/make: parse.c
Log Message:
make(1): extract the target parsing from ParseDoDependency
To generate a diff of this commit:
cvs rdiff -u -r1.364 -r1.365 src/usr.bin/make/parse.c
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
Modified files:
Index: src/usr.bin/make/parse.c
diff -u src/usr.bin/make/parse.c:1.364 src/usr.bin/make/parse.c:1.365
--- src/usr.bin/make/parse.c:1.364 Mon Oct 5 16:33:20 2020
+++ src/usr.bin/make/parse.c Mon Oct 5 16:45:03 2020
@@ -1,4 +1,4 @@
-/* $NetBSD: parse.c,v 1.364 2020/10/05 16:33:20 rillig Exp $ */
+/* $NetBSD: parse.c,v 1.365 2020/10/05 16:45:03 rillig Exp $ */
/*
* Copyright (c) 1988, 1989, 1990, 1993
@@ -131,7 +131,7 @@
#include "pathnames.h"
/* "@(#)parse.c 8.3 (Berkeley) 3/19/94" */
-MAKE_RCSID("$NetBSD: parse.c,v 1.364 2020/10/05 16:33:20 rillig Exp $");
+MAKE_RCSID("$NetBSD: parse.c,v 1.365 2020/10/05 16:45:03 rillig Exp $");
/* types and constants */
@@ -1463,62 +1463,18 @@ ParseDoDependencySourceSpecial(ParseSpec
}
}
-/* Parse a dependency line consisting of targets, followed by a dependency
- * operator, optionally followed by sources.
- *
- * The nodes of the sources are linked as children to the nodes of the
- * targets. Nodes are created as necessary.
- *
- * The operator is applied to each node in the global 'targets' list,
- * which is where the nodes found for the targets are kept, by means of
- * the ParseDoOp function.
- *
- * The sources are parsed in much the same way as the targets, except
- * that they are expanded using the wildcarding scheme of the C-Shell,
- * and all instances of the resulting words in the list of all targets
- * are found. Each of the resulting nodes is then linked to each of the
- * targets as one of its children.
- *
- * Certain targets and sources such as .PHONY or .PRECIOUS are handled
- * specially. These are the ones detailed by the specType variable.
- *
- * The storing of transformation rules such as '.c.o' is also taken care of
- * here. A target is recognized as a transformation rule by calling
- * Suff_IsTransform. If it is a transformation rule, its node is gotten
- * from the suffix module via Suff_AddTransform rather than the standard
- * Targ_FindNode in the target module.
- */
-static void
-ParseDoDependency(char *line)
-{
- char *cp; /* our current position */
- GNodeType op; /* the operator on the line */
- char savec; /* a place to save a character */
- SearchPathList *paths; /* search paths to alter when parsing
- * a list of .PATH targets */
- int tOp; /* operator from special target */
- GNodeList *sources; /* archive sources after expansion */
- StringList *curTargs; /* target names to be found and added
- * to the targets list */
- char *lstart = line;
-
- /*
- * specType contains the SPECial TYPE of the current target. It is Not
- * if the target is unspecial. If it *is* special, however, the children
- * are linked as children of the parent but not vice versa.
- */
- ParseSpecial specType = Not;
-
- DEBUG1(PARSE, "ParseDoDependency(%s)\n", line);
- tOp = 0;
-
- paths = NULL;
-
- curTargs = Lst_Init();
-
- /*
- * First, grind through the targets.
- */
+static Boolean
+ParseDoDependencyTargets(char **const inout_cp,
+ char **const inout_line,
+ const char *const lstart,
+ ParseSpecial *const inout_specType,
+ GNodeType *const inout_tOp,
+ SearchPathList **const inout_paths,
+ StringList *const curTargs)
+{
+ char *cp = *inout_cp;
+ char *line = *inout_line;
+ char savec;
for (;;) {
/*
@@ -1547,8 +1503,8 @@ ParseDoDependency(char *line)
*/
if (!Arch_ParseArchive(&line, targets, VAR_CMD)) {
Parse_Error(PARSE_FATAL,
- "Error in archive specification: \"%s\"", line);
- goto out;
+ "Error in archive specification: \"%s\"", line);
+ return FALSE;
} else {
/* Done with this word; on to the next. */
cp = line;
@@ -1558,23 +1514,24 @@ ParseDoDependency(char *line)
if (!*cp) {
ParseErrorNoDependency(lstart, line);
- goto out;
+ return FALSE;
}
/* Insert a null terminator. */
savec = *cp;
*cp = '\0';
- if (!ParseDoDependencyTarget(line, &specType, &tOp, &paths))
- goto out;
+ if (!ParseDoDependencyTarget(line, inout_specType, inout_tOp,
+ inout_paths))
+ return FALSE;
/*
* Have word in line. Get or create its node and stick it at
* the end of the targets list
*/
- if (specType == Not && *line != '\0') {
+ if (*inout_specType == Not && *line != '\0') {
ParseDoDependencyTargetMundane(line, curTargs);
- } else if (specType == ExPath && *line != '.' && *line != '\0') {
+ } else if (*inout_specType == ExPath && *line != '.' && *line != '\0') {
Parse_Error(PARSE_WARNING, "Extra target (%s) ignored", line);
}
@@ -1585,7 +1542,7 @@ ParseDoDependency(char *line)
* If it is a special type and not .PATH, it's the only target we
* allow on this line...
*/
- if (specType != Not && specType != ExPath) {
+ if (*inout_specType != Not && *inout_specType != ExPath) {
ParseDoDependencyTargetExtraWarn(&cp, lstart);
} else {
pp_skip_whitespace(&cp);
@@ -1597,6 +1554,71 @@ ParseDoDependency(char *line)
break;
}
+ *inout_cp = cp;
+ *inout_line = line;
+ return TRUE;
+}
+
+/* Parse a dependency line consisting of targets, followed by a dependency
+ * operator, optionally followed by sources.
+ *
+ * The nodes of the sources are linked as children to the nodes of the
+ * targets. Nodes are created as necessary.
+ *
+ * The operator is applied to each node in the global 'targets' list,
+ * which is where the nodes found for the targets are kept, by means of
+ * the ParseDoOp function.
+ *
+ * The sources are parsed in much the same way as the targets, except
+ * that they are expanded using the wildcarding scheme of the C-Shell,
+ * and all instances of the resulting words in the list of all targets
+ * are found. Each of the resulting nodes is then linked to each of the
+ * targets as one of its children.
+ *
+ * Certain targets and sources such as .PHONY or .PRECIOUS are handled
+ * specially. These are the ones detailed by the specType variable.
+ *
+ * The storing of transformation rules such as '.c.o' is also taken care of
+ * here. A target is recognized as a transformation rule by calling
+ * Suff_IsTransform. If it is a transformation rule, its node is gotten
+ * from the suffix module via Suff_AddTransform rather than the standard
+ * Targ_FindNode in the target module.
+ */
+static void
+ParseDoDependency(char *line)
+{
+ char *cp; /* our current position */
+ GNodeType op; /* the operator on the line */
+ char savec; /* a place to save a character */
+ SearchPathList *paths; /* search paths to alter when parsing
+ * a list of .PATH targets */
+ int tOp; /* operator from special target */
+ GNodeList *sources; /* archive sources after expansion */
+ StringList *curTargs; /* target names to be found and added
+ * to the targets list */
+ char *lstart = line;
+
+ /*
+ * specType contains the SPECial TYPE of the current target. It is Not
+ * if the target is unspecial. If it *is* special, however, the children
+ * are linked as children of the parent but not vice versa.
+ */
+ ParseSpecial specType = Not;
+
+ DEBUG1(PARSE, "ParseDoDependency(%s)\n", line);
+ tOp = 0;
+
+ paths = NULL;
+
+ curTargs = Lst_Init();
+
+ /*
+ * First, grind through the targets.
+ */
+ if (!ParseDoDependencyTargets(&cp, &line, lstart, &specType, &tOp, &paths,
+ curTargs))
+ goto out;
+
/*
* Don't need the list of target names anymore...
*/
