Home | History | Annotate | Line # | Download | only in make
parse.c revision 1.722
      1  1.722    rillig /*	$NetBSD: parse.c,v 1.722 2024/04/27 17:33:46 rillig Exp $	*/
      2   1.15  christos 
      3    1.1       cgd /*
      4   1.27  christos  * Copyright (c) 1988, 1989, 1990, 1993
      5   1.27  christos  *	The Regents of the University of California.  All rights reserved.
      6   1.94       agc  *
      7   1.94       agc  * This code is derived from software contributed to Berkeley by
      8   1.94       agc  * Adam de Boor.
      9   1.94       agc  *
     10   1.94       agc  * Redistribution and use in source and binary forms, with or without
     11   1.94       agc  * modification, are permitted provided that the following conditions
     12   1.94       agc  * are met:
     13   1.94       agc  * 1. Redistributions of source code must retain the above copyright
     14   1.94       agc  *    notice, this list of conditions and the following disclaimer.
     15   1.94       agc  * 2. Redistributions in binary form must reproduce the above copyright
     16   1.94       agc  *    notice, this list of conditions and the following disclaimer in the
     17   1.94       agc  *    documentation and/or other materials provided with the distribution.
     18   1.94       agc  * 3. Neither the name of the University nor the names of its contributors
     19   1.94       agc  *    may be used to endorse or promote products derived from this software
     20   1.94       agc  *    without specific prior written permission.
     21   1.94       agc  *
     22   1.94       agc  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     23   1.94       agc  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     24   1.94       agc  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     25   1.94       agc  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     26   1.94       agc  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     27   1.94       agc  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     28   1.94       agc  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     29   1.94       agc  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     30   1.94       agc  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     31   1.94       agc  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     32   1.94       agc  * SUCH DAMAGE.
     33   1.94       agc  */
     34   1.94       agc 
     35   1.94       agc /*
     36    1.1       cgd  * Copyright (c) 1989 by Berkeley Softworks
     37    1.1       cgd  * All rights reserved.
     38    1.1       cgd  *
     39    1.1       cgd  * This code is derived from software contributed to Berkeley by
     40    1.1       cgd  * Adam de Boor.
     41    1.1       cgd  *
     42    1.1       cgd  * Redistribution and use in source and binary forms, with or without
     43    1.1       cgd  * modification, are permitted provided that the following conditions
     44    1.1       cgd  * are met:
     45    1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     46    1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     47    1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     48    1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     49    1.1       cgd  *    documentation and/or other materials provided with the distribution.
     50    1.1       cgd  * 3. All advertising materials mentioning features or use of this software
     51    1.1       cgd  *    must display the following acknowledgement:
     52    1.1       cgd  *	This product includes software developed by the University of
     53    1.1       cgd  *	California, Berkeley and its contributors.
     54    1.1       cgd  * 4. Neither the name of the University nor the names of its contributors
     55    1.1       cgd  *    may be used to endorse or promote products derived from this software
     56    1.1       cgd  *    without specific prior written permission.
     57    1.1       cgd  *
     58    1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     59    1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     60    1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     61    1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     62    1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     63    1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     64    1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     65    1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     66    1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     67    1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     68    1.1       cgd  * SUCH DAMAGE.
     69    1.1       cgd  */
     70    1.1       cgd 
     71  1.402    rillig /*
     72  1.402    rillig  * Parsing of makefiles.
     73  1.402    rillig  *
     74  1.402    rillig  * Parse_File is the main entry point and controls most of the other
     75  1.402    rillig  * functions in this module.
     76    1.1       cgd  *
     77    1.1       cgd  * Interface:
     78  1.402    rillig  *	Parse_Init	Initialize the module
     79  1.338    rillig  *
     80  1.383    rillig  *	Parse_End	Clean up the module
     81  1.338    rillig  *
     82  1.402    rillig  *	Parse_File	Parse a top-level makefile.  Included files are
     83  1.537    rillig  *			handled by IncludeFile instead.
     84  1.402    rillig  *
     85  1.609    rillig  *	Parse_VarAssign
     86  1.609    rillig  *			Try to parse the given line as a variable assignment.
     87  1.609    rillig  *			Used by MainParseArgs to determine if an argument is
     88  1.609    rillig  *			a target or a variable assignment.  Used internally
     89  1.609    rillig  *			for pretty much the same thing.
     90  1.402    rillig  *
     91  1.402    rillig  *	Parse_Error	Report a parse error, a warning or an informational
     92  1.402    rillig  *			message.
     93  1.338    rillig  *
     94  1.697    rillig  *	Parse_MainName	Populate the list of targets to create.
     95    1.1       cgd  */
     96    1.1       cgd 
     97  1.170  dholland #include <sys/types.h>
     98  1.171  dholland #include <sys/stat.h>
     99   1.84       wiz #include <errno.h>
    100    1.5       cgd #include <stdarg.h>
    101   1.84       wiz 
    102    1.1       cgd #include "make.h"
    103    1.5       cgd #include "dir.h"
    104    1.5       cgd #include "job.h"
    105    1.1       cgd #include "pathnames.h"
    106    1.1       cgd 
    107  1.303    rillig /*	"@(#)parse.c	8.3 (Berkeley) 3/19/94"	*/
    108  1.722    rillig MAKE_RCSID("$NetBSD: parse.c,v 1.722 2024/04/27 17:33:46 rillig Exp $");
    109  1.700    rillig 
    110  1.700    rillig /* Detects a multiple-inclusion guard in a makefile. */
    111  1.700    rillig typedef enum {
    112  1.700    rillig 	GS_START,		/* at the beginning of the file */
    113  1.700    rillig 	GS_COND,		/* after the guard condition */
    114  1.700    rillig 	GS_DONE,		/* after the closing .endif */
    115  1.700    rillig 	GS_NO			/* the file is not guarded */
    116  1.700    rillig } GuardState;
    117  1.166  dholland 
    118  1.716    rillig /* A file being parsed. */
    119  1.627    rillig typedef struct IncludedFile {
    120  1.576    rillig 	FStr name;		/* absolute or relative to the cwd */
    121  1.661    rillig 	unsigned lineno;	/* 1-based */
    122  1.661    rillig 	unsigned readLines;	/* the number of physical lines that have
    123  1.639    rillig 				 * been read from the file */
    124  1.661    rillig 	unsigned forHeadLineno;	/* 1-based */
    125  1.661    rillig 	unsigned forBodyReadLines; /* the number of physical lines that have
    126  1.627    rillig 				 * been read from the file above the body of
    127  1.639    rillig 				 * the .for loop */
    128  1.687    rillig 	unsigned int condMinDepth; /* depth of nested 'if' directives, at the
    129  1.687    rillig 				 * beginning of the file */
    130  1.618    rillig 	bool depending;		/* state of doing_depend on EOF */
    131  1.469    rillig 
    132  1.618    rillig 	Buffer buf;		/* the file's content or the body of the .for
    133  1.667    rillig 				 * loop; either empty or ends with '\n' */
    134  1.704    rillig 	char *buf_ptr;		/* next char to be read from buf */
    135  1.571    rillig 	char *buf_end;		/* buf_end[-1] == '\n' */
    136  1.469    rillig 
    137  1.702    rillig 	GuardState guardState;
    138  1.702    rillig 	Guard *guard;
    139  1.700    rillig 
    140  1.616    rillig 	struct ForLoop *forLoop;
    141  1.627    rillig } IncludedFile;
    142    1.1       cgd 
    143  1.628    rillig /* Special attributes for target nodes. */
    144  1.386    rillig typedef enum ParseSpecial {
    145  1.469    rillig 	SP_ATTRIBUTE,	/* Generic attribute */
    146  1.469    rillig 	SP_BEGIN,	/* .BEGIN */
    147  1.469    rillig 	SP_DEFAULT,	/* .DEFAULT */
    148  1.469    rillig 	SP_DELETE_ON_ERROR, /* .DELETE_ON_ERROR */
    149  1.469    rillig 	SP_END,		/* .END */
    150  1.469    rillig 	SP_ERROR,	/* .ERROR */
    151  1.469    rillig 	SP_IGNORE,	/* .IGNORE */
    152  1.469    rillig 	SP_INCLUDES,	/* .INCLUDES; not mentioned in the manual page */
    153  1.469    rillig 	SP_INTERRUPT,	/* .INTERRUPT */
    154  1.469    rillig 	SP_LIBS,	/* .LIBS; not mentioned in the manual page */
    155  1.589    rillig 	SP_MAIN,	/* .MAIN and no user-specified targets to make */
    156  1.469    rillig 	SP_META,	/* .META */
    157  1.469    rillig 	SP_MFLAGS,	/* .MFLAGS or .MAKEFLAGS */
    158  1.469    rillig 	SP_NOMETA,	/* .NOMETA */
    159  1.469    rillig 	SP_NOMETA_CMP,	/* .NOMETA_CMP */
    160  1.469    rillig 	SP_NOPATH,	/* .NOPATH */
    161  1.691       sjg 	SP_NOREADONLY,	/* .NOREADONLY */
    162  1.469    rillig 	SP_NOT,		/* Not special */
    163  1.469    rillig 	SP_NOTPARALLEL,	/* .NOTPARALLEL or .NO_PARALLEL */
    164  1.469    rillig 	SP_NULL,	/* .NULL; not mentioned in the manual page */
    165  1.469    rillig 	SP_OBJDIR,	/* .OBJDIR */
    166  1.469    rillig 	SP_ORDER,	/* .ORDER */
    167  1.469    rillig 	SP_PARALLEL,	/* .PARALLEL; not mentioned in the manual page */
    168  1.469    rillig 	SP_PATH,	/* .PATH or .PATH.suffix */
    169  1.469    rillig 	SP_PHONY,	/* .PHONY */
    170  1.469    rillig 	SP_POSIX,	/* .POSIX; not mentioned in the manual page */
    171  1.469    rillig 	SP_PRECIOUS,	/* .PRECIOUS */
    172  1.691       sjg 	SP_READONLY,	/* .READONLY */
    173  1.469    rillig 	SP_SHELL,	/* .SHELL */
    174  1.469    rillig 	SP_SILENT,	/* .SILENT */
    175  1.469    rillig 	SP_SINGLESHELL,	/* .SINGLESHELL; not mentioned in the manual page */
    176  1.469    rillig 	SP_STALE,	/* .STALE */
    177  1.469    rillig 	SP_SUFFIXES,	/* .SUFFIXES */
    178  1.692       sjg 	SP_SYSPATH,	/* .SYSPATH */
    179  1.469    rillig 	SP_WAIT		/* .WAIT */
    180    1.1       cgd } ParseSpecial;
    181    1.1       cgd 
    182  1.368    rillig typedef List SearchPathList;
    183  1.392    rillig typedef ListNode SearchPathListNode;
    184  1.368    rillig 
    185  1.656       sjg 
    186  1.656       sjg typedef enum VarAssignOp {
    187  1.656       sjg 	VAR_NORMAL,		/* = */
    188  1.656       sjg 	VAR_APPEND,		/* += */
    189  1.656       sjg 	VAR_DEFAULT,		/* ?= */
    190  1.656       sjg 	VAR_SUBST,		/* := */
    191  1.656       sjg 	VAR_SHELL		/* != or :sh= */
    192  1.656       sjg } VarAssignOp;
    193  1.656       sjg 
    194  1.656       sjg typedef struct VarAssign {
    195  1.656       sjg 	char *varname;		/* unexpanded */
    196  1.656       sjg 	VarAssignOp op;
    197  1.656       sjg 	const char *value;	/* unexpanded */
    198  1.656       sjg } VarAssign;
    199  1.656       sjg 
    200  1.656       sjg static bool Parse_IsVar(const char *, VarAssign *);
    201  1.658    rillig static void Parse_Var(VarAssign *, GNode *);
    202  1.656       sjg 
    203  1.166  dholland /*
    204  1.631    rillig  * The target to be made if no targets are specified in the command line.
    205  1.631    rillig  * This is the first target defined in any of the makefiles.
    206  1.166  dholland  */
    207  1.631    rillig GNode *mainNode;
    208  1.166  dholland 
    209  1.524    rillig /*
    210  1.524    rillig  * During parsing, the targets from the left-hand side of the currently
    211  1.415    rillig  * active dependency line, or NULL if the current line does not belong to a
    212  1.415    rillig  * dependency line, for example because it is a variable assignment.
    213  1.318    rillig  *
    214  1.524    rillig  * See unit-tests/deptgt.mk, keyword "parse.c:targets".
    215  1.524    rillig  */
    216  1.322    rillig static GNodeList *targets;
    217  1.166  dholland 
    218  1.166  dholland #ifdef CLEANUP
    219  1.524    rillig /*
    220  1.524    rillig  * All shell commands for all targets, in no particular order and possibly
    221  1.372    rillig  * with duplicates.  Kept in a separate list since the commands from .USE or
    222  1.372    rillig  * .USEBEFORE nodes are shared with other GNodes, thereby giving up the
    223  1.524    rillig  * easily understandable ownership over the allocated strings.
    224  1.524    rillig  */
    225  1.461    rillig static StringList targCmds = LST_INIT;
    226  1.166  dholland #endif
    227  1.166  dholland 
    228  1.166  dholland /*
    229  1.152       dsl  * Predecessor node for handling .ORDER. Initialized to NULL when .ORDER
    230  1.628    rillig  * is seen, then set to each successive source on the line.
    231    1.1       cgd  */
    232  1.407    rillig static GNode *order_pred;
    233    1.1       cgd 
    234  1.709    rillig static int parseErrors;
    235  1.166  dholland 
    236  1.166  dholland /*
    237  1.532    rillig  * The include chain of makefiles.  At index 0 is the top-level makefile from
    238  1.532    rillig  * the command line, followed by the included files or .for loops, up to and
    239  1.532    rillig  * including the current file.
    240  1.532    rillig  *
    241  1.532    rillig  * See PrintStackTrace for how to interpret the data.
    242  1.319    rillig  */
    243  1.627    rillig static Vector /* of IncludedFile */ includes;
    244  1.400    rillig 
    245  1.549    rillig SearchPath *parseIncPath;	/* directories for "..." includes */
    246  1.549    rillig SearchPath *sysIncPath;		/* directories for <...> includes */
    247  1.414    rillig SearchPath *defSysIncPath;	/* default for sysIncPath */
    248  1.166  dholland 
    249    1.1       cgd /*
    250    1.1       cgd  * The parseKeywords table is searched using binary search when deciding
    251  1.697    rillig  * if a target or source is special.
    252    1.1       cgd  */
    253  1.168  dholland static const struct {
    254  1.590    rillig 	const char name[17];
    255  1.590    rillig 	ParseSpecial special;	/* when used as a target */
    256  1.590    rillig 	GNodeType targetAttr;	/* when used as a source */
    257    1.1       cgd } parseKeywords[] = {
    258  1.466    rillig     { ".BEGIN",		SP_BEGIN,	OP_NONE },
    259  1.466    rillig     { ".DEFAULT",	SP_DEFAULT,	OP_NONE },
    260  1.466    rillig     { ".DELETE_ON_ERROR", SP_DELETE_ON_ERROR, OP_NONE },
    261  1.466    rillig     { ".END",		SP_END,		OP_NONE },
    262  1.466    rillig     { ".ERROR",		SP_ERROR,	OP_NONE },
    263  1.404    rillig     { ".EXEC",		SP_ATTRIBUTE,	OP_EXEC },
    264  1.404    rillig     { ".IGNORE",	SP_IGNORE,	OP_IGNORE },
    265  1.466    rillig     { ".INCLUDES",	SP_INCLUDES,	OP_NONE },
    266  1.466    rillig     { ".INTERRUPT",	SP_INTERRUPT,	OP_NONE },
    267  1.404    rillig     { ".INVISIBLE",	SP_ATTRIBUTE,	OP_INVISIBLE },
    268  1.404    rillig     { ".JOIN",		SP_ATTRIBUTE,	OP_JOIN },
    269  1.466    rillig     { ".LIBS",		SP_LIBS,	OP_NONE },
    270  1.404    rillig     { ".MADE",		SP_ATTRIBUTE,	OP_MADE },
    271  1.466    rillig     { ".MAIN",		SP_MAIN,	OP_NONE },
    272  1.404    rillig     { ".MAKE",		SP_ATTRIBUTE,	OP_MAKE },
    273  1.466    rillig     { ".MAKEFLAGS",	SP_MFLAGS,	OP_NONE },
    274  1.404    rillig     { ".META",		SP_META,	OP_META },
    275  1.466    rillig     { ".MFLAGS",	SP_MFLAGS,	OP_NONE },
    276  1.404    rillig     { ".NOMETA",	SP_NOMETA,	OP_NOMETA },
    277  1.404    rillig     { ".NOMETA_CMP",	SP_NOMETA_CMP,	OP_NOMETA_CMP },
    278  1.404    rillig     { ".NOPATH",	SP_NOPATH,	OP_NOPATH },
    279  1.691       sjg     { ".NOREADONLY",	SP_NOREADONLY,	OP_NONE },
    280  1.404    rillig     { ".NOTMAIN",	SP_ATTRIBUTE,	OP_NOTMAIN },
    281  1.466    rillig     { ".NOTPARALLEL",	SP_NOTPARALLEL,	OP_NONE },
    282  1.466    rillig     { ".NO_PARALLEL",	SP_NOTPARALLEL,	OP_NONE },
    283  1.466    rillig     { ".NULL",		SP_NULL,	OP_NONE },
    284  1.466    rillig     { ".OBJDIR",	SP_OBJDIR,	OP_NONE },
    285  1.404    rillig     { ".OPTIONAL",	SP_ATTRIBUTE,	OP_OPTIONAL },
    286  1.466    rillig     { ".ORDER",		SP_ORDER,	OP_NONE },
    287  1.466    rillig     { ".PARALLEL",	SP_PARALLEL,	OP_NONE },
    288  1.466    rillig     { ".PATH",		SP_PATH,	OP_NONE },
    289  1.404    rillig     { ".PHONY",		SP_PHONY,	OP_PHONY },
    290  1.466    rillig     { ".POSIX",		SP_POSIX,	OP_NONE },
    291  1.404    rillig     { ".PRECIOUS",	SP_PRECIOUS,	OP_PRECIOUS },
    292  1.691       sjg     { ".READONLY",	SP_READONLY,	OP_NONE },
    293  1.404    rillig     { ".RECURSIVE",	SP_ATTRIBUTE,	OP_MAKE },
    294  1.466    rillig     { ".SHELL",		SP_SHELL,	OP_NONE },
    295  1.404    rillig     { ".SILENT",	SP_SILENT,	OP_SILENT },
    296  1.466    rillig     { ".SINGLESHELL",	SP_SINGLESHELL,	OP_NONE },
    297  1.466    rillig     { ".STALE",		SP_STALE,	OP_NONE },
    298  1.466    rillig     { ".SUFFIXES",	SP_SUFFIXES,	OP_NONE },
    299  1.692       sjg     { ".SYSPATH",	SP_SYSPATH,	OP_NONE },
    300  1.404    rillig     { ".USE",		SP_ATTRIBUTE,	OP_USE },
    301  1.404    rillig     { ".USEBEFORE",	SP_ATTRIBUTE,	OP_USEBEFORE },
    302  1.466    rillig     { ".WAIT",		SP_WAIT,	OP_NONE },
    303    1.1       cgd };
    304    1.1       cgd 
    305  1.669    rillig enum PosixState posix_state = PS_NOT_YET;
    306  1.170  dholland 
    307  1.702    rillig static HashTable /* full file name -> Guard */ guards;
    308  1.700    rillig 
    309  1.713    rillig 
    310  1.713    rillig static List *
    311  1.713    rillig Lst_New(void)
    312  1.713    rillig {
    313  1.713    rillig 	List *list = bmake_malloc(sizeof *list);
    314  1.713    rillig 	Lst_Init(list);
    315  1.713    rillig 	return list;
    316  1.713    rillig }
    317  1.713    rillig 
    318  1.713    rillig static void
    319  1.713    rillig Lst_Free(List *list)
    320  1.713    rillig {
    321  1.713    rillig 
    322  1.713    rillig 	Lst_Done(list);
    323  1.713    rillig 	free(list);
    324  1.713    rillig }
    325  1.713    rillig 
    326  1.627    rillig static IncludedFile *
    327  1.618    rillig GetInclude(size_t i)
    328  1.618    rillig {
    329  1.686    rillig 	assert(i < includes.len);
    330  1.618    rillig 	return Vector_Get(&includes, i);
    331  1.618    rillig }
    332  1.618    rillig 
    333  1.715    rillig /* The makefile or the body of a .for loop that is currently being read. */
    334  1.627    rillig static IncludedFile *
    335  1.618    rillig CurFile(void)
    336  1.618    rillig {
    337  1.618    rillig 	return GetInclude(includes.len - 1);
    338  1.618    rillig }
    339  1.618    rillig 
    340  1.687    rillig unsigned int
    341  1.687    rillig CurFile_CondMinDepth(void)
    342  1.687    rillig {
    343  1.687    rillig 	return CurFile()->condMinDepth;
    344  1.687    rillig }
    345  1.687    rillig 
    346  1.616    rillig static Buffer
    347  1.675    rillig LoadFile(const char *path, int fd)
    348  1.414    rillig {
    349  1.522    rillig 	ssize_t n;
    350  1.522    rillig 	Buffer buf;
    351  1.612    rillig 	size_t bufSize;
    352  1.612    rillig 	struct stat st;
    353  1.414    rillig 
    354  1.612    rillig 	bufSize = fstat(fd, &st) == 0 && S_ISREG(st.st_mode) &&
    355  1.634    rillig 		  st.st_size > 0 && st.st_size < 1024 * 1024 * 1024
    356  1.612    rillig 	    ? (size_t)st.st_size : 1024;
    357  1.612    rillig 	Buf_InitSize(&buf, bufSize);
    358  1.170  dholland 
    359  1.428    rillig 	for (;;) {
    360  1.522    rillig 		if (buf.len == buf.cap) {
    361  1.634    rillig 			if (buf.cap >= 512 * 1024 * 1024) {
    362  1.221  riastrad 				Error("%s: file too large", path);
    363  1.518    rillig 				exit(2); /* Not 1 so -q can distinguish error */
    364  1.221  riastrad 			}
    365  1.523    rillig 			Buf_Expand(&buf);
    366  1.170  dholland 		}
    367  1.522    rillig 		assert(buf.len < buf.cap);
    368  1.522    rillig 		n = read(fd, buf.data + buf.len, buf.cap - buf.len);
    369  1.522    rillig 		if (n < 0) {
    370  1.170  dholland 			Error("%s: read error: %s", path, strerror(errno));
    371  1.518    rillig 			exit(2);	/* Not 1 so -q can distinguish error */
    372  1.170  dholland 		}
    373  1.522    rillig 		if (n == 0)
    374  1.170  dholland 			break;
    375  1.430    rillig 
    376  1.522    rillig 		buf.len += (size_t)n;
    377  1.170  dholland 	}
    378  1.522    rillig 	assert(buf.len <= buf.cap);
    379  1.170  dholland 
    380  1.714       sjg 	if (buf.len > 0 && !Buf_EndsWith(&buf, '\n'))
    381  1.522    rillig 		Buf_AddByte(&buf, '\n');
    382  1.170  dholland 
    383  1.630    rillig 	return buf;		/* may not be null-terminated */
    384  1.170  dholland }
    385  1.170  dholland 
    386  1.659    rillig /*
    387  1.659    rillig  * Print the current chain of .include and .for directives.  In Parse_Fatal
    388  1.659    rillig  * or other functions that already print the location, includingInnermost
    389  1.659    rillig  * would be redundant, but in other cases like Error or Fatal it needs to be
    390  1.659    rillig  * included.
    391  1.659    rillig  */
    392  1.659    rillig void
    393  1.659    rillig PrintStackTrace(bool includingInnermost)
    394  1.532    rillig {
    395  1.627    rillig 	const IncludedFile *entries;
    396  1.532    rillig 	size_t i, n;
    397  1.532    rillig 
    398  1.532    rillig 	n = includes.len;
    399  1.532    rillig 	if (n == 0)
    400  1.532    rillig 		return;
    401  1.643    rillig 
    402  1.686    rillig 	entries = GetInclude(0);
    403  1.659    rillig 	if (!includingInnermost && entries[n - 1].forLoop == NULL)
    404  1.643    rillig 		n--;		/* already in the diagnostic */
    405  1.532    rillig 
    406  1.532    rillig 	for (i = n; i-- > 0;) {
    407  1.627    rillig 		const IncludedFile *entry = entries + i;
    408  1.576    rillig 		const char *fname = entry->name.str;
    409  1.532    rillig 		char dirbuf[MAXPATHLEN + 1];
    410  1.532    rillig 
    411  1.698    rillig 		if (fname[0] != '/' && strcmp(fname, "(stdin)") != 0) {
    412  1.698    rillig 			const char *realPath = realpath(fname, dirbuf);
    413  1.698    rillig 			if (realPath != NULL)
    414  1.698    rillig 				fname = realPath;
    415  1.698    rillig 		}
    416  1.532    rillig 
    417  1.643    rillig 		if (entry->forLoop != NULL) {
    418  1.644    rillig 			char *details = ForLoop_Details(entry->forLoop);
    419  1.661    rillig 			debug_printf("\tin .for loop from %s:%u with %s\n",
    420  1.644    rillig 			    fname, entry->forHeadLineno, details);
    421  1.644    rillig 			free(details);
    422  1.646    rillig 		} else if (i + 1 < n && entries[i + 1].forLoop != NULL) {
    423  1.646    rillig 			/* entry->lineno is not a useful line number */
    424  1.646    rillig 		} else
    425  1.661    rillig 			debug_printf("\tin %s:%u\n", fname, entry->lineno);
    426  1.532    rillig 	}
    427  1.532    rillig }
    428   1.77  christos 
    429  1.279    rillig /* Check if the current character is escaped on the current line. */
    430  1.553    rillig static bool
    431  1.602    rillig IsEscaped(const char *line, const char *p)
    432   1.77  christos {
    433  1.628    rillig 	bool escaped = false;
    434  1.594    rillig 	while (p > line && *--p == '\\')
    435  1.628    rillig 		escaped = !escaped;
    436  1.628    rillig 	return escaped;
    437   1.77  christos }
    438   1.77  christos 
    439  1.524    rillig /*
    440  1.712    rillig  * Remember the location (filename and lineno) where the last command was
    441  1.712    rillig  * added or where the node was mentioned in a .depend file.
    442  1.524    rillig  */
    443  1.278    rillig static void
    444  1.562    rillig RememberLocation(GNode *gn)
    445  1.278    rillig {
    446  1.627    rillig 	IncludedFile *curFile = CurFile();
    447  1.576    rillig 	gn->fname = Str_Intern(curFile->name.str);
    448  1.639    rillig 	gn->lineno = curFile->lineno;
    449  1.278    rillig }
    450  1.278    rillig 
    451  1.524    rillig /*
    452  1.524    rillig  * Look in the table of keywords for one matching the given string.
    453  1.524    rillig  * Return the index of the keyword, or -1 if it isn't there.
    454  1.524    rillig  */
    455    1.1       cgd static int
    456  1.602    rillig FindKeyword(const char *str)
    457    1.1       cgd {
    458  1.469    rillig 	int start = 0;
    459  1.469    rillig 	int end = sizeof parseKeywords / sizeof parseKeywords[0] - 1;
    460    1.1       cgd 
    461  1.611    rillig 	while (start <= end) {
    462  1.469    rillig 		int curr = start + (end - start) / 2;
    463  1.469    rillig 		int diff = strcmp(str, parseKeywords[curr].name);
    464  1.469    rillig 
    465  1.469    rillig 		if (diff == 0)
    466  1.469    rillig 			return curr;
    467  1.469    rillig 		if (diff < 0)
    468  1.469    rillig 			end = curr - 1;
    469  1.469    rillig 		else
    470  1.469    rillig 			start = curr + 1;
    471  1.611    rillig 	}
    472  1.430    rillig 
    473  1.469    rillig 	return -1;
    474    1.1       cgd }
    475    1.1       cgd 
    476  1.660    rillig void
    477  1.680    rillig PrintLocation(FILE *f, bool useVars, const GNode *gn)
    478  1.291    rillig {
    479  1.469    rillig 	char dirbuf[MAXPATHLEN + 1];
    480  1.505    rillig 	FStr dir, base;
    481  1.680    rillig 	const char *fname;
    482  1.680    rillig 	unsigned lineno;
    483  1.680    rillig 
    484  1.680    rillig 	if (gn != NULL) {
    485  1.680    rillig 		fname = gn->fname;
    486  1.680    rillig 		lineno = gn->lineno;
    487  1.680    rillig 	} else if (includes.len > 0) {
    488  1.680    rillig 		IncludedFile *curFile = CurFile();
    489  1.680    rillig 		fname = curFile->name.str;
    490  1.680    rillig 		lineno = curFile->lineno;
    491  1.680    rillig 	} else
    492  1.680    rillig 		return;
    493  1.291    rillig 
    494  1.653    rillig 	if (!useVars || fname[0] == '/' || strcmp(fname, "(stdin)") == 0) {
    495  1.661    rillig 		(void)fprintf(f, "\"%s\" line %u: ", fname, lineno);
    496  1.299    rillig 		return;
    497  1.299    rillig 	}
    498  1.291    rillig 
    499  1.548    rillig 	dir = Var_Value(SCOPE_GLOBAL, ".PARSEDIR");
    500  1.505    rillig 	if (dir.str == NULL)
    501  1.505    rillig 		dir.str = ".";
    502  1.505    rillig 	if (dir.str[0] != '/')
    503  1.505    rillig 		dir.str = realpath(dir.str, dirbuf);
    504  1.505    rillig 
    505  1.548    rillig 	base = Var_Value(SCOPE_GLOBAL, ".PARSEFILE");
    506  1.505    rillig 	if (base.str == NULL)
    507  1.505    rillig 		base.str = str_basename(fname);
    508  1.505    rillig 
    509  1.661    rillig 	(void)fprintf(f, "\"%s/%s\" line %u: ", dir.str, base.str, lineno);
    510  1.505    rillig 
    511  1.505    rillig 	FStr_Done(&base);
    512  1.505    rillig 	FStr_Done(&dir);
    513  1.291    rillig }
    514  1.291    rillig 
    515  1.680    rillig static void MAKE_ATTR_PRINTFLIKE(5, 0)
    516  1.680    rillig ParseVErrorInternal(FILE *f, bool useVars, const GNode *gn,
    517  1.664    rillig 		    ParseErrorLevel level, const char *fmt, va_list ap)
    518   1.38  christos {
    519  1.553    rillig 	static bool fatal_warning_error_printed = false;
    520   1.56  christos 
    521  1.148       sjg 	(void)fprintf(f, "%s: ", progname);
    522   1.63  christos 
    523  1.680    rillig 	PrintLocation(f, useVars, gn);
    524  1.720    rillig 	fprintf(f, "%s", EvalStack_Details());
    525  1.664    rillig 	if (level == PARSE_WARNING)
    526  1.127       dsl 		(void)fprintf(f, "warning: ");
    527  1.127       dsl 	(void)vfprintf(f, fmt, ap);
    528  1.127       dsl 	(void)fprintf(f, "\n");
    529  1.127       dsl 	(void)fflush(f);
    530  1.300    rillig 
    531  1.664    rillig 	if (level == PARSE_FATAL)
    532  1.621    rillig 		parseErrors++;
    533  1.664    rillig 	if (level == PARSE_WARNING && opts.parseWarnFatal) {
    534  1.621    rillig 		if (!fatal_warning_error_printed) {
    535  1.621    rillig 			Error("parsing warnings being treated as errors");
    536  1.621    rillig 			fatal_warning_error_printed = true;
    537  1.621    rillig 		}
    538  1.621    rillig 		parseErrors++;
    539   1.56  christos 	}
    540  1.532    rillig 
    541  1.642    rillig 	if (DEBUG(PARSE))
    542  1.659    rillig 		PrintStackTrace(false);
    543   1.38  christos }
    544   1.38  christos 
    545  1.680    rillig static void MAKE_ATTR_PRINTFLIKE(3, 4)
    546  1.680    rillig ParseErrorInternal(const GNode *gn,
    547  1.664    rillig 		   ParseErrorLevel level, const char *fmt, ...)
    548  1.203     joerg {
    549  1.203     joerg 	va_list ap;
    550  1.203     joerg 
    551  1.441    rillig 	(void)fflush(stdout);
    552  1.203     joerg 	va_start(ap, fmt);
    553  1.680    rillig 	ParseVErrorInternal(stderr, false, gn, level, fmt, ap);
    554  1.203     joerg 	va_end(ap);
    555  1.203     joerg 
    556  1.622    rillig 	if (opts.debug_file != stdout && opts.debug_file != stderr) {
    557  1.203     joerg 		va_start(ap, fmt);
    558  1.680    rillig 		ParseVErrorInternal(opts.debug_file, false, gn,
    559  1.664    rillig 		    level, fmt, ap);
    560  1.203     joerg 		va_end(ap);
    561  1.203     joerg 	}
    562  1.203     joerg }
    563  1.203     joerg 
    564  1.524    rillig /*
    565  1.708    rillig  * Print a message, including location information.
    566  1.441    rillig  *
    567  1.441    rillig  * If the level is PARSE_FATAL, continue parsing until the end of the
    568  1.441    rillig  * current top-level makefile, then exit (see Parse_File).
    569   1.38  christos  *
    570  1.524    rillig  * Fmt is given without a trailing newline.
    571  1.524    rillig  */
    572    1.1       cgd void
    573  1.664    rillig Parse_Error(ParseErrorLevel level, const char *fmt, ...)
    574    1.1       cgd {
    575    1.1       cgd 	va_list ap;
    576  1.156       dsl 
    577  1.633    rillig 	(void)fflush(stdout);
    578  1.156       dsl 	va_start(ap, fmt);
    579  1.680    rillig 	ParseVErrorInternal(stderr, true, NULL, level, fmt, ap);
    580    1.1       cgd 	va_end(ap);
    581  1.127       dsl 
    582  1.622    rillig 	if (opts.debug_file != stdout && opts.debug_file != stderr) {
    583  1.127       dsl 		va_start(ap, fmt);
    584  1.680    rillig 		ParseVErrorInternal(opts.debug_file, true, NULL,
    585  1.664    rillig 		    level, fmt, ap);
    586  1.127       dsl 		va_end(ap);
    587  1.127       dsl 	}
    588    1.1       cgd }
    589    1.1       cgd 
    590  1.161       sjg 
    591  1.524    rillig /*
    592  1.602    rillig  * Handle an .info, .warning or .error directive.  For an .error directive,
    593  1.602    rillig  * exit immediately.
    594  1.524    rillig  */
    595  1.503    rillig static void
    596  1.602    rillig HandleMessage(ParseErrorLevel level, const char *levelName, const char *umsg)
    597  1.161       sjg {
    598  1.475    rillig 	char *xmsg;
    599  1.469    rillig 
    600  1.503    rillig 	if (umsg[0] == '\0') {
    601  1.503    rillig 		Parse_Error(PARSE_FATAL, "Missing argument for \".%s\"",
    602  1.503    rillig 		    levelName);
    603  1.503    rillig 		return;
    604  1.503    rillig 	}
    605  1.469    rillig 
    606  1.694    rillig 	xmsg = Var_Subst(umsg, SCOPE_CMDLINE, VARE_WANTRES);
    607  1.469    rillig 	/* TODO: handle errors */
    608  1.469    rillig 
    609  1.475    rillig 	Parse_Error(level, "%s", xmsg);
    610  1.475    rillig 	free(xmsg);
    611  1.469    rillig 
    612  1.475    rillig 	if (level == PARSE_FATAL) {
    613  1.655    rillig 		PrintOnError(NULL, "\n");
    614  1.469    rillig 		exit(1);
    615  1.469    rillig 	}
    616  1.161       sjg }
    617  1.161       sjg 
    618  1.524    rillig /*
    619  1.630    rillig  * Add the child to the parent's children, and for non-special targets, vice
    620  1.708    rillig  * versa.
    621  1.524    rillig  */
    622  1.382    rillig static void
    623  1.553    rillig LinkSource(GNode *pgn, GNode *cgn, bool isSpecial)
    624  1.382    rillig {
    625  1.469    rillig 	if ((pgn->type & OP_DOUBLEDEP) && !Lst_IsEmpty(&pgn->cohorts))
    626  1.469    rillig 		pgn = pgn->cohorts.last->datum;
    627  1.316    rillig 
    628  1.469    rillig 	Lst_Append(&pgn->children, cgn);
    629  1.469    rillig 	pgn->unmade++;
    630  1.316    rillig 
    631  1.708    rillig 	/*
    632  1.708    rillig 	 * Special targets like .END do not need to be informed once the child
    633  1.708    rillig 	 * target has been made.
    634  1.708    rillig 	 */
    635  1.469    rillig 	if (!isSpecial)
    636  1.469    rillig 		Lst_Append(&cgn->parents, pgn);
    637  1.469    rillig 
    638  1.469    rillig 	if (DEBUG(PARSE)) {
    639  1.586    rillig 		debug_printf("# LinkSource: added child %s - %s\n",
    640  1.586    rillig 		    pgn->name, cgn->name);
    641  1.469    rillig 		Targ_PrintNode(pgn, 0);
    642  1.469    rillig 		Targ_PrintNode(cgn, 0);
    643  1.469    rillig 	}
    644    1.1       cgd }
    645    1.1       cgd 
    646  1.382    rillig /* Add the node to each target from the current dependency group. */
    647  1.382    rillig static void
    648  1.553    rillig LinkToTargets(GNode *gn, bool isSpecial)
    649  1.382    rillig {
    650  1.469    rillig 	GNodeListNode *ln;
    651  1.469    rillig 
    652  1.469    rillig 	for (ln = targets->first; ln != NULL; ln = ln->next)
    653  1.469    rillig 		LinkSource(ln->datum, gn, isSpecial);
    654  1.382    rillig }
    655  1.382    rillig 
    656  1.553    rillig static bool
    657  1.337    rillig TryApplyDependencyOperator(GNode *gn, GNodeType op)
    658    1.1       cgd {
    659    1.1       cgd 	/*
    660  1.469    rillig 	 * If the node occurred on the left-hand side of a dependency and the
    661  1.469    rillig 	 * operator also defines a dependency, they must match.
    662    1.1       cgd 	 */
    663  1.469    rillig 	if ((op & OP_OPMASK) && (gn->type & OP_OPMASK) &&
    664  1.469    rillig 	    ((op & OP_OPMASK) != (gn->type & OP_OPMASK))) {
    665  1.469    rillig 		Parse_Error(PARSE_FATAL, "Inconsistent operator for %s",
    666  1.469    rillig 		    gn->name);
    667  1.553    rillig 		return false;
    668  1.469    rillig 	}
    669  1.469    rillig 
    670  1.469    rillig 	if (op == OP_DOUBLEDEP && (gn->type & OP_OPMASK) == OP_DOUBLEDEP) {
    671  1.469    rillig 		/*
    672  1.697    rillig 		 * If the node was on the left-hand side of a '::' operator,
    673  1.708    rillig 		 * create a new node for the children and commands on this
    674  1.708    rillig 		 * dependency line, since each of these dependency groups has
    675  1.708    rillig 		 * its own attributes and commands, separate from the others.
    676  1.469    rillig 		 *
    677  1.469    rillig 		 * The new instance is placed on the 'cohorts' list of the
    678  1.469    rillig 		 * initial one (note the initial one is not on its own
    679  1.469    rillig 		 * cohorts list) and the new instance is linked to all
    680  1.469    rillig 		 * parents of the initial instance.
    681  1.469    rillig 		 */
    682  1.469    rillig 		GNode *cohort;
    683   1.27  christos 
    684  1.469    rillig 		/*
    685  1.469    rillig 		 * Propagate copied bits to the initial node.  They'll be
    686  1.469    rillig 		 * propagated back to the rest of the cohorts later.
    687  1.469    rillig 		 */
    688  1.688    rillig 		gn->type |= op & (unsigned)~OP_OPMASK;
    689   1.33   mycroft 
    690  1.469    rillig 		cohort = Targ_NewInternalNode(gn->name);
    691  1.469    rillig 		if (doing_depend)
    692  1.562    rillig 			RememberLocation(cohort);
    693  1.469    rillig 		/*
    694  1.708    rillig 		 * Make the cohort invisible to avoid duplicating it
    695  1.469    rillig 		 * into other variables. True, parents of this target won't
    696  1.469    rillig 		 * tend to do anything with their local variables, but better
    697  1.469    rillig 		 * safe than sorry.
    698  1.469    rillig 		 *
    699  1.469    rillig 		 * (I think this is pointless now, since the relevant list
    700  1.469    rillig 		 * traversals will no longer see this node anyway. -mycroft)
    701  1.469    rillig 		 */
    702  1.469    rillig 		cohort->type = op | OP_INVISIBLE;
    703  1.469    rillig 		Lst_Append(&gn->cohorts, cohort);
    704  1.469    rillig 		cohort->centurion = gn;
    705  1.469    rillig 		gn->unmade_cohorts++;
    706  1.469    rillig 		snprintf(cohort->cohort_num, sizeof cohort->cohort_num, "#%d",
    707  1.469    rillig 		    (unsigned int)gn->unmade_cohorts % 1000000);
    708  1.469    rillig 	} else {
    709  1.708    rillig 		gn->type |= op;	/* preserve any previous flags */
    710  1.469    rillig 	}
    711   1.33   mycroft 
    712  1.553    rillig 	return true;
    713  1.337    rillig }
    714  1.337    rillig 
    715  1.337    rillig static void
    716  1.337    rillig ApplyDependencyOperator(GNodeType op)
    717  1.337    rillig {
    718  1.469    rillig 	GNodeListNode *ln;
    719  1.469    rillig 
    720  1.469    rillig 	for (ln = targets->first; ln != NULL; ln = ln->next)
    721  1.469    rillig 		if (!TryApplyDependencyOperator(ln->datum, op))
    722  1.469    rillig 			break;
    723    1.1       cgd }
    724    1.1       cgd 
    725  1.467    rillig /*
    726  1.708    rillig  * Add a .WAIT node in the dependency list. After any dynamic dependencies
    727  1.467    rillig  * (and filename globbing) have happened, it is given a dependency on each
    728  1.467    rillig  * previous child, back until the previous .WAIT node. The next child won't
    729  1.467    rillig  * be scheduled until the .WAIT node is built.
    730  1.467    rillig  *
    731  1.708    rillig  * Give each .WAIT node a unique name (mainly for diagnostics).
    732  1.467    rillig  */
    733  1.467    rillig static void
    734  1.593    rillig ApplyDependencySourceWait(bool isSpecial)
    735  1.467    rillig {
    736  1.645    rillig 	static unsigned wait_number = 0;
    737  1.671    rillig 	char name[6 + 10 + 1];
    738  1.467    rillig 	GNode *gn;
    739  1.467    rillig 
    740  1.671    rillig 	snprintf(name, sizeof name, ".WAIT_%u", ++wait_number);
    741  1.671    rillig 	gn = Targ_NewInternalNode(name);
    742  1.467    rillig 	if (doing_depend)
    743  1.562    rillig 		RememberLocation(gn);
    744  1.467    rillig 	gn->type = OP_WAIT | OP_PHONY | OP_DEPENDS | OP_NOTMAIN;
    745  1.467    rillig 	LinkToTargets(gn, isSpecial);
    746  1.467    rillig }
    747  1.467    rillig 
    748  1.553    rillig static bool
    749  1.593    rillig ApplyDependencySourceKeyword(const char *src, ParseSpecial special)
    750    1.1       cgd {
    751  1.468    rillig 	int keywd;
    752  1.590    rillig 	GNodeType targetAttr;
    753    1.1       cgd 
    754  1.468    rillig 	if (*src != '.' || !ch_isupper(src[1]))
    755  1.553    rillig 		return false;
    756  1.468    rillig 
    757  1.602    rillig 	keywd = FindKeyword(src);
    758  1.468    rillig 	if (keywd == -1)
    759  1.553    rillig 		return false;
    760  1.468    rillig 
    761  1.590    rillig 	targetAttr = parseKeywords[keywd].targetAttr;
    762  1.590    rillig 	if (targetAttr != OP_NONE) {
    763  1.590    rillig 		ApplyDependencyOperator(targetAttr);
    764  1.553    rillig 		return true;
    765  1.468    rillig 	}
    766  1.590    rillig 	if (parseKeywords[keywd].special == SP_WAIT) {
    767  1.593    rillig 		ApplyDependencySourceWait(special != SP_NOT);
    768  1.553    rillig 		return true;
    769    1.1       cgd 	}
    770  1.553    rillig 	return false;
    771  1.368    rillig }
    772   1.18  christos 
    773  1.630    rillig /*
    774  1.630    rillig  * In a line like ".MAIN: source1 source2", add all sources to the list of
    775  1.630    rillig  * things to create, but only if the user didn't specify a target on the
    776  1.630    rillig  * command line and .MAIN occurs for the first time.
    777  1.630    rillig  *
    778  1.630    rillig  * See HandleDependencyTargetSpecial, branch SP_MAIN.
    779  1.630    rillig  * See unit-tests/cond-func-make-main.mk.
    780  1.630    rillig  */
    781  1.368    rillig static void
    782  1.593    rillig ApplyDependencySourceMain(const char *src)
    783  1.368    rillig {
    784  1.469    rillig 	Lst_Append(&opts.create, bmake_strdup(src));
    785  1.469    rillig 	/*
    786  1.469    rillig 	 * Add the name to the .TARGETS variable as well, so the user can
    787  1.469    rillig 	 * employ that, if desired.
    788  1.469    rillig 	 */
    789  1.542    rillig 	Global_Append(".TARGETS", src);
    790  1.368    rillig }
    791   1.18  christos 
    792  1.665    rillig /*
    793  1.665    rillig  * For the sources of a .ORDER target, create predecessor/successor links
    794  1.665    rillig  * between the previous source and the current one.
    795  1.665    rillig  */
    796  1.368    rillig static void
    797  1.593    rillig ApplyDependencySourceOrder(const char *src)
    798  1.368    rillig {
    799  1.469    rillig 	GNode *gn;
    800  1.665    rillig 
    801  1.469    rillig 	gn = Targ_GetNode(src);
    802  1.469    rillig 	if (doing_depend)
    803  1.562    rillig 		RememberLocation(gn);
    804  1.469    rillig 	if (order_pred != NULL) {
    805  1.469    rillig 		Lst_Append(&order_pred->order_succ, gn);
    806  1.469    rillig 		Lst_Append(&gn->order_pred, order_pred);
    807  1.469    rillig 		if (DEBUG(PARSE)) {
    808  1.586    rillig 			debug_printf(
    809  1.592    rillig 			    "# .ORDER forces '%s' to be made before '%s'\n",
    810  1.586    rillig 			    order_pred->name, gn->name);
    811  1.469    rillig 			Targ_PrintNode(order_pred, 0);
    812  1.469    rillig 			Targ_PrintNode(gn, 0);
    813  1.469    rillig 		}
    814  1.469    rillig 	}
    815  1.708    rillig 	/* The current source now becomes the predecessor for the next one. */
    816  1.469    rillig 	order_pred = gn;
    817  1.368    rillig }
    818  1.368    rillig 
    819  1.630    rillig /* The source is not an attribute, so find/create a node for it. */
    820  1.368    rillig static void
    821  1.593    rillig ApplyDependencySourceOther(const char *src, GNodeType targetAttr,
    822  1.587    rillig 			   ParseSpecial special)
    823  1.368    rillig {
    824  1.469    rillig 	GNode *gn;
    825  1.469    rillig 
    826  1.469    rillig 	gn = Targ_GetNode(src);
    827  1.469    rillig 	if (doing_depend)
    828  1.562    rillig 		RememberLocation(gn);
    829  1.590    rillig 	if (targetAttr != OP_NONE)
    830  1.590    rillig 		gn->type |= targetAttr;
    831  1.469    rillig 	else
    832  1.587    rillig 		LinkToTargets(gn, special != SP_NOT);
    833    1.1       cgd }
    834    1.1       cgd 
    835  1.469    rillig /*
    836  1.469    rillig  * Given the name of a source in a dependency line, figure out if it is an
    837  1.590    rillig  * attribute (such as .SILENT) and if so, apply it to all targets. Otherwise
    838  1.368    rillig  * decide if there is some attribute which should be applied *to* the source
    839  1.368    rillig  * because of some special target (such as .PHONY) and apply it if so.
    840  1.590    rillig  * Otherwise, make the source a child of the targets.
    841  1.368    rillig  */
    842  1.368    rillig static void
    843  1.593    rillig ApplyDependencySource(GNodeType targetAttr, const char *src,
    844  1.590    rillig 		      ParseSpecial special)
    845  1.368    rillig {
    846  1.593    rillig 	if (ApplyDependencySourceKeyword(src, special))
    847  1.469    rillig 		return;
    848  1.368    rillig 
    849  1.587    rillig 	if (special == SP_MAIN)
    850  1.593    rillig 		ApplyDependencySourceMain(src);
    851  1.587    rillig 	else if (special == SP_ORDER)
    852  1.593    rillig 		ApplyDependencySourceOrder(src);
    853  1.469    rillig 	else
    854  1.593    rillig 		ApplyDependencySourceOther(src, targetAttr, special);
    855  1.368    rillig }
    856  1.368    rillig 
    857  1.469    rillig /*
    858  1.469    rillig  * If we have yet to decide on a main target to make, in the absence of any
    859  1.335    rillig  * user input, we want the first target on the first dependency line that is
    860  1.469    rillig  * actually a real target (i.e. isn't a .USE or .EXEC rule) to be made.
    861  1.469    rillig  */
    862  1.335    rillig static void
    863  1.630    rillig MaybeUpdateMainTarget(void)
    864    1.1       cgd {
    865  1.469    rillig 	GNodeListNode *ln;
    866  1.335    rillig 
    867  1.469    rillig 	if (mainNode != NULL)
    868  1.469    rillig 		return;
    869  1.335    rillig 
    870  1.469    rillig 	for (ln = targets->first; ln != NULL; ln = ln->next) {
    871  1.469    rillig 		GNode *gn = ln->datum;
    872  1.589    rillig 		if (GNode_IsMainCandidate(gn)) {
    873  1.709    rillig 			DEBUG1(MAKE, "Setting main node to \"%s\"\n",
    874  1.709    rillig 			    gn->name);
    875  1.469    rillig 			mainNode = gn;
    876  1.469    rillig 			return;
    877  1.469    rillig 		}
    878  1.335    rillig 	}
    879    1.1       cgd }
    880    1.1       cgd 
    881  1.311    rillig static void
    882  1.706    rillig InvalidLineType(const char *line, const char *unexpanded_line)
    883  1.311    rillig {
    884  1.706    rillig 	if (unexpanded_line[0] == '.') {
    885  1.706    rillig 		const char *dirstart = unexpanded_line + 1;
    886  1.469    rillig 		const char *dirend;
    887  1.469    rillig 		cpp_skip_whitespace(&dirstart);
    888  1.469    rillig 		dirend = dirstart;
    889  1.469    rillig 		while (ch_isalnum(*dirend) || *dirend == '-')
    890  1.469    rillig 			dirend++;
    891  1.469    rillig 		Parse_Error(PARSE_FATAL, "Unknown directive \"%.*s\"",
    892  1.311    rillig 		    (int)(dirend - dirstart), dirstart);
    893  1.706    rillig 	} else if (strcmp(line, unexpanded_line) == 0)
    894  1.705    rillig 		Parse_Error(PARSE_FATAL, "Invalid line '%s'", line);
    895  1.706    rillig 	else
    896  1.709    rillig 		Parse_Error(PARSE_FATAL,
    897  1.709    rillig 		    "Invalid line '%s', expanded to '%s'",
    898  1.706    rillig 		    unexpanded_line, line);
    899  1.311    rillig }
    900  1.311    rillig 
    901  1.314    rillig static void
    902  1.599    rillig ParseDependencyTargetWord(char **pp, const char *lstart)
    903  1.314    rillig {
    904  1.709    rillig 	const char *p = *pp;
    905  1.469    rillig 
    906  1.709    rillig 	while (*p != '\0') {
    907  1.709    rillig 		if ((ch_isspace(*p) || *p == '!' || *p == ':' || *p == '(')
    908  1.709    rillig 		    && !IsEscaped(lstart, p))
    909  1.469    rillig 			break;
    910  1.314    rillig 
    911  1.709    rillig 		if (*p == '$') {
    912  1.709    rillig 			FStr val = Var_Parse(&p, SCOPE_CMDLINE,
    913  1.693    rillig 			    VARE_PARSE_ONLY);
    914  1.708    rillig 			/* TODO: handle errors */
    915  1.624    rillig 			FStr_Done(&val);
    916  1.469    rillig 		} else
    917  1.709    rillig 			p++;
    918  1.469    rillig 	}
    919  1.314    rillig 
    920  1.709    rillig 	*pp += p - *pp;
    921  1.314    rillig }
    922  1.314    rillig 
    923  1.559    rillig /*
    924  1.559    rillig  * Handle special targets like .PATH, .DEFAULT, .BEGIN, .ORDER.
    925  1.559    rillig  *
    926  1.559    rillig  * See the tests deptgt-*.mk.
    927  1.559    rillig  */
    928  1.368    rillig static void
    929  1.602    rillig HandleDependencyTargetSpecial(const char *targetName,
    930  1.602    rillig 			      ParseSpecial *inout_special,
    931  1.602    rillig 			      SearchPathList **inout_paths)
    932  1.368    rillig {
    933  1.587    rillig 	switch (*inout_special) {
    934  1.469    rillig 	case SP_PATH:
    935  1.469    rillig 		if (*inout_paths == NULL)
    936  1.469    rillig 			*inout_paths = Lst_New();
    937  1.469    rillig 		Lst_Append(*inout_paths, &dirSearchPath);
    938  1.469    rillig 		break;
    939  1.692       sjg 	case SP_SYSPATH:
    940  1.692       sjg 		if (*inout_paths == NULL)
    941  1.692       sjg 			*inout_paths = Lst_New();
    942  1.692       sjg 		Lst_Append(*inout_paths, sysIncPath);
    943  1.692       sjg 		break;
    944  1.469    rillig 	case SP_MAIN:
    945  1.469    rillig 		/*
    946  1.469    rillig 		 * Allow targets from the command line to override the
    947  1.469    rillig 		 * .MAIN node.
    948  1.469    rillig 		 */
    949  1.469    rillig 		if (!Lst_IsEmpty(&opts.create))
    950  1.587    rillig 			*inout_special = SP_NOT;
    951  1.469    rillig 		break;
    952  1.469    rillig 	case SP_BEGIN:
    953  1.469    rillig 	case SP_END:
    954  1.469    rillig 	case SP_STALE:
    955  1.469    rillig 	case SP_ERROR:
    956  1.469    rillig 	case SP_INTERRUPT: {
    957  1.530    rillig 		GNode *gn = Targ_GetNode(targetName);
    958  1.469    rillig 		if (doing_depend)
    959  1.562    rillig 			RememberLocation(gn);
    960  1.469    rillig 		gn->type |= OP_NOTMAIN | OP_SPECIAL;
    961  1.469    rillig 		Lst_Append(targets, gn);
    962  1.469    rillig 		break;
    963  1.469    rillig 	}
    964  1.469    rillig 	case SP_DEFAULT: {
    965  1.469    rillig 		/*
    966  1.469    rillig 		 * Need to create a node to hang commands on, but we don't
    967  1.469    rillig 		 * want it in the graph, nor do we want it to be the Main
    968  1.469    rillig 		 * Target. We claim the node is a transformation rule to make
    969  1.469    rillig 		 * life easier later, when we'll use Make_HandleUse to
    970  1.469    rillig 		 * actually apply the .DEFAULT commands.
    971  1.469    rillig 		 */
    972  1.469    rillig 		GNode *gn = GNode_New(".DEFAULT");
    973  1.469    rillig 		gn->type |= OP_NOTMAIN | OP_TRANSFORM;
    974  1.469    rillig 		Lst_Append(targets, gn);
    975  1.469    rillig 		defaultNode = gn;
    976  1.469    rillig 		break;
    977  1.469    rillig 	}
    978  1.469    rillig 	case SP_DELETE_ON_ERROR:
    979  1.553    rillig 		deleteOnError = true;
    980  1.469    rillig 		break;
    981  1.469    rillig 	case SP_NOTPARALLEL:
    982  1.469    rillig 		opts.maxJobs = 1;
    983  1.469    rillig 		break;
    984  1.469    rillig 	case SP_SINGLESHELL:
    985  1.553    rillig 		opts.compatMake = true;
    986  1.469    rillig 		break;
    987  1.469    rillig 	case SP_ORDER:
    988  1.469    rillig 		order_pred = NULL;
    989  1.469    rillig 		break;
    990  1.469    rillig 	default:
    991  1.469    rillig 		break;
    992  1.469    rillig 	}
    993  1.368    rillig }
    994  1.368    rillig 
    995  1.553    rillig static bool
    996  1.602    rillig HandleDependencyTargetPath(const char *suffixName,
    997  1.602    rillig 			   SearchPathList **inout_paths)
    998  1.368    rillig {
    999  1.469    rillig 	SearchPath *path;
   1000  1.368    rillig 
   1001  1.530    rillig 	path = Suff_GetPath(suffixName);
   1002  1.469    rillig 	if (path == NULL) {
   1003  1.469    rillig 		Parse_Error(PARSE_FATAL,
   1004  1.530    rillig 		    "Suffix '%s' not defined (yet)", suffixName);
   1005  1.553    rillig 		return false;
   1006  1.469    rillig 	}
   1007  1.430    rillig 
   1008  1.469    rillig 	if (*inout_paths == NULL)
   1009  1.469    rillig 		*inout_paths = Lst_New();
   1010  1.469    rillig 	Lst_Append(*inout_paths, path);
   1011  1.430    rillig 
   1012  1.553    rillig 	return true;
   1013  1.368    rillig }
   1014  1.368    rillig 
   1015  1.628    rillig /* See if it's a special target and if so set inout_special to match it. */
   1016  1.553    rillig static bool
   1017  1.602    rillig HandleDependencyTarget(const char *targetName,
   1018  1.602    rillig 		       ParseSpecial *inout_special,
   1019  1.602    rillig 		       GNodeType *inout_targetAttr,
   1020  1.602    rillig 		       SearchPathList **inout_paths)
   1021  1.364    rillig {
   1022  1.469    rillig 	int keywd;
   1023  1.469    rillig 
   1024  1.530    rillig 	if (!(targetName[0] == '.' && ch_isupper(targetName[1])))
   1025  1.553    rillig 		return true;
   1026  1.469    rillig 
   1027  1.469    rillig 	/*
   1028  1.469    rillig 	 * See if the target is a special target that must have it
   1029  1.469    rillig 	 * or its sources handled specially.
   1030  1.469    rillig 	 */
   1031  1.602    rillig 	keywd = FindKeyword(targetName);
   1032  1.469    rillig 	if (keywd != -1) {
   1033  1.587    rillig 		if (*inout_special == SP_PATH &&
   1034  1.590    rillig 		    parseKeywords[keywd].special != SP_PATH) {
   1035  1.469    rillig 			Parse_Error(PARSE_FATAL, "Mismatched special targets");
   1036  1.553    rillig 			return false;
   1037  1.469    rillig 		}
   1038  1.469    rillig 
   1039  1.590    rillig 		*inout_special = parseKeywords[keywd].special;
   1040  1.590    rillig 		*inout_targetAttr = parseKeywords[keywd].targetAttr;
   1041  1.469    rillig 
   1042  1.602    rillig 		HandleDependencyTargetSpecial(targetName, inout_special,
   1043  1.469    rillig 		    inout_paths);
   1044  1.364    rillig 
   1045  1.530    rillig 	} else if (strncmp(targetName, ".PATH", 5) == 0) {
   1046  1.587    rillig 		*inout_special = SP_PATH;
   1047  1.602    rillig 		if (!HandleDependencyTargetPath(targetName + 5, inout_paths))
   1048  1.553    rillig 			return false;
   1049  1.469    rillig 	}
   1050  1.553    rillig 	return true;
   1051  1.368    rillig }
   1052  1.368    rillig 
   1053  1.368    rillig static void
   1054  1.677    rillig HandleSingleDependencyTargetMundane(const char *name)
   1055  1.677    rillig {
   1056  1.677    rillig 	GNode *gn = Suff_IsTransform(name)
   1057  1.677    rillig 	    ? Suff_AddTransform(name)
   1058  1.677    rillig 	    : Targ_GetNode(name);
   1059  1.677    rillig 	if (doing_depend)
   1060  1.677    rillig 		RememberLocation(gn);
   1061  1.677    rillig 
   1062  1.677    rillig 	Lst_Append(targets, gn);
   1063  1.677    rillig }
   1064  1.677    rillig 
   1065  1.677    rillig static void
   1066  1.678    rillig HandleDependencyTargetMundane(const char *targetName)
   1067  1.368    rillig {
   1068  1.678    rillig 	if (Dir_HasWildcards(targetName)) {
   1069  1.678    rillig 		StringList targetNames = LST_INIT;
   1070  1.595    rillig 
   1071  1.469    rillig 		SearchPath *emptyPath = SearchPath_New();
   1072  1.595    rillig 		SearchPath_Expand(emptyPath, targetName, &targetNames);
   1073  1.469    rillig 		SearchPath_Free(emptyPath);
   1074  1.678    rillig 
   1075  1.678    rillig 		while (!Lst_IsEmpty(&targetNames)) {
   1076  1.678    rillig 			char *targName = Lst_Dequeue(&targetNames);
   1077  1.678    rillig 			HandleSingleDependencyTargetMundane(targName);
   1078  1.679    rillig 			free(targName);
   1079  1.678    rillig 		}
   1080  1.595    rillig 	} else
   1081  1.678    rillig 		HandleSingleDependencyTargetMundane(targetName);
   1082  1.368    rillig }
   1083  1.368    rillig 
   1084  1.368    rillig static void
   1085  1.603    rillig SkipExtraTargets(char **pp, const char *lstart)
   1086  1.368    rillig {
   1087  1.553    rillig 	bool warning = false;
   1088  1.628    rillig 	const char *p = *pp;
   1089  1.368    rillig 
   1090  1.628    rillig 	while (*p != '\0') {
   1091  1.628    rillig 		if (!IsEscaped(lstart, p) && (*p == '!' || *p == ':'))
   1092  1.469    rillig 			break;
   1093  1.628    rillig 		if (IsEscaped(lstart, p) || (*p != ' ' && *p != '\t'))
   1094  1.553    rillig 			warning = true;
   1095  1.628    rillig 		p++;
   1096  1.469    rillig 	}
   1097  1.690    rillig 	if (warning) {
   1098  1.690    rillig 		const char *start = *pp;
   1099  1.690    rillig 		cpp_skip_whitespace(&start);
   1100  1.690    rillig 		Parse_Error(PARSE_WARNING, "Extra target '%.*s' ignored",
   1101  1.690    rillig 		    (int)(p - start), start);
   1102  1.690    rillig 	}
   1103  1.430    rillig 
   1104  1.628    rillig 	*pp += p - *pp;
   1105  1.368    rillig }
   1106  1.368    rillig 
   1107  1.368    rillig static void
   1108  1.628    rillig CheckSpecialMundaneMixture(ParseSpecial special)
   1109  1.368    rillig {
   1110  1.587    rillig 	switch (special) {
   1111  1.469    rillig 	case SP_DEFAULT:
   1112  1.469    rillig 	case SP_STALE:
   1113  1.469    rillig 	case SP_BEGIN:
   1114  1.469    rillig 	case SP_END:
   1115  1.469    rillig 	case SP_ERROR:
   1116  1.469    rillig 	case SP_INTERRUPT:
   1117  1.469    rillig 		/*
   1118  1.469    rillig 		 * These create nodes on which to hang commands, so targets
   1119  1.469    rillig 		 * shouldn't be empty.
   1120  1.469    rillig 		 */
   1121  1.469    rillig 	case SP_NOT:
   1122  1.665    rillig 		/* Nothing special here -- targets may be empty. */
   1123  1.469    rillig 		break;
   1124  1.582    rillig 	default:
   1125  1.582    rillig 		Parse_Error(PARSE_WARNING,
   1126  1.582    rillig 		    "Special and mundane targets don't mix. "
   1127  1.582    rillig 		    "Mundane ones ignored");
   1128  1.582    rillig 		break;
   1129  1.469    rillig 	}
   1130  1.368    rillig }
   1131  1.368    rillig 
   1132  1.560    rillig /*
   1133  1.560    rillig  * In a dependency line like 'targets: sources' or 'targets! sources', parse
   1134  1.560    rillig  * the operator ':', '::' or '!' from between the targets and the sources.
   1135  1.560    rillig  */
   1136  1.578    rillig static GNodeType
   1137  1.578    rillig ParseDependencyOp(char **pp)
   1138  1.368    rillig {
   1139  1.578    rillig 	if (**pp == '!')
   1140  1.578    rillig 		return (*pp)++, OP_FORCE;
   1141  1.681    rillig 	if (**pp == ':' && (*pp)[1] == ':')
   1142  1.630    rillig 		return *pp += 2, OP_DOUBLEDEP;
   1143  1.681    rillig 	else if (**pp == ':')
   1144  1.681    rillig 		return (*pp)++, OP_DEPENDS;
   1145  1.578    rillig 	else
   1146  1.681    rillig 		return OP_NONE;
   1147  1.368    rillig }
   1148  1.364    rillig 
   1149  1.368    rillig static void
   1150  1.692       sjg ClearPaths(ParseSpecial special, SearchPathList *paths)
   1151  1.392    rillig {
   1152  1.469    rillig 	if (paths != NULL) {
   1153  1.469    rillig 		SearchPathListNode *ln;
   1154  1.469    rillig 		for (ln = paths->first; ln != NULL; ln = ln->next)
   1155  1.469    rillig 			SearchPath_Clear(ln->datum);
   1156  1.469    rillig 	}
   1157  1.692       sjg 	if (special == SP_SYSPATH)
   1158  1.692       sjg 		Dir_SetSYSPATH();
   1159  1.692       sjg 	else
   1160  1.692       sjg 		Dir_SetPATH();
   1161  1.392    rillig }
   1162  1.392    rillig 
   1163  1.673    rillig static char *
   1164  1.673    rillig FindInDirOfIncludingFile(const char *file)
   1165  1.673    rillig {
   1166  1.673    rillig 	char *fullname, *incdir, *slash, *newName;
   1167  1.673    rillig 	int i;
   1168  1.673    rillig 
   1169  1.673    rillig 	fullname = NULL;
   1170  1.673    rillig 	incdir = bmake_strdup(CurFile()->name.str);
   1171  1.673    rillig 	slash = strrchr(incdir, '/');
   1172  1.673    rillig 	if (slash != NULL) {
   1173  1.673    rillig 		*slash = '\0';
   1174  1.673    rillig 		/*
   1175  1.673    rillig 		 * Now do lexical processing of leading "../" on the
   1176  1.673    rillig 		 * filename.
   1177  1.673    rillig 		 */
   1178  1.673    rillig 		for (i = 0; strncmp(file + i, "../", 3) == 0; i += 3) {
   1179  1.673    rillig 			slash = strrchr(incdir + 1, '/');
   1180  1.673    rillig 			if (slash == NULL || strcmp(slash, "/..") == 0)
   1181  1.673    rillig 				break;
   1182  1.673    rillig 			*slash = '\0';
   1183  1.673    rillig 		}
   1184  1.673    rillig 		newName = str_concat3(incdir, "/", file + i);
   1185  1.673    rillig 		fullname = Dir_FindFile(newName, parseIncPath);
   1186  1.673    rillig 		if (fullname == NULL)
   1187  1.673    rillig 			fullname = Dir_FindFile(newName, &dirSearchPath);
   1188  1.673    rillig 		free(newName);
   1189  1.673    rillig 	}
   1190  1.673    rillig 	free(incdir);
   1191  1.673    rillig 	return fullname;
   1192  1.673    rillig }
   1193  1.673    rillig 
   1194  1.674    rillig static char *
   1195  1.674    rillig FindInQuotPath(const char *file)
   1196  1.674    rillig {
   1197  1.674    rillig 	const char *suff;
   1198  1.674    rillig 	SearchPath *suffPath;
   1199  1.674    rillig 	char *fullname;
   1200  1.674    rillig 
   1201  1.674    rillig 	fullname = FindInDirOfIncludingFile(file);
   1202  1.674    rillig 	if (fullname == NULL &&
   1203  1.674    rillig 	    (suff = strrchr(file, '.')) != NULL &&
   1204  1.674    rillig 	    (suffPath = Suff_GetPath(suff)) != NULL)
   1205  1.674    rillig 		fullname = Dir_FindFile(file, suffPath);
   1206  1.674    rillig 	if (fullname == NULL)
   1207  1.674    rillig 		fullname = Dir_FindFile(file, parseIncPath);
   1208  1.674    rillig 	if (fullname == NULL)
   1209  1.674    rillig 		fullname = Dir_FindFile(file, &dirSearchPath);
   1210  1.674    rillig 	return fullname;
   1211  1.674    rillig }
   1212  1.674    rillig 
   1213  1.701    rillig static bool
   1214  1.701    rillig SkipGuarded(const char *fullname)
   1215  1.701    rillig {
   1216  1.702    rillig 	Guard *guard = HashTable_FindValue(&guards, fullname);
   1217  1.702    rillig 	if (guard != NULL && guard->kind == GK_VARIABLE
   1218  1.702    rillig 	    && GNode_ValueDirect(SCOPE_GLOBAL, guard->name) != NULL)
   1219  1.702    rillig 		goto skip;
   1220  1.702    rillig 	if (guard != NULL && guard->kind == GK_TARGET
   1221  1.702    rillig 	    && Targ_FindNode(guard->name) != NULL)
   1222  1.702    rillig 		goto skip;
   1223  1.701    rillig 	return false;
   1224  1.702    rillig 
   1225  1.702    rillig skip:
   1226  1.702    rillig 	DEBUG2(PARSE, "Skipping '%s' because '%s' is defined\n",
   1227  1.702    rillig 	    fullname, guard->name);
   1228  1.702    rillig 	return true;
   1229  1.701    rillig }
   1230  1.701    rillig 
   1231  1.668       sjg /*
   1232  1.668       sjg  * Handle one of the .[-ds]include directives by remembering the current file
   1233  1.668       sjg  * and pushing the included file on the stack.  After the included file has
   1234  1.668       sjg  * finished, parsing continues with the including file; see Parse_PushInput
   1235  1.668       sjg  * and ParseEOF.
   1236  1.668       sjg  *
   1237  1.668       sjg  * System includes are looked up in sysIncPath, any other includes are looked
   1238  1.668       sjg  * up in the parsedir and then in the directories specified by the -I command
   1239  1.668       sjg  * line options.
   1240  1.668       sjg  */
   1241  1.668       sjg static void
   1242  1.668       sjg IncludeFile(const char *file, bool isSystem, bool depinc, bool silent)
   1243  1.668       sjg {
   1244  1.668       sjg 	Buffer buf;
   1245  1.668       sjg 	char *fullname;		/* full pathname of file */
   1246  1.668       sjg 	int fd;
   1247  1.668       sjg 
   1248  1.668       sjg 	fullname = file[0] == '/' ? bmake_strdup(file) : NULL;
   1249  1.668       sjg 
   1250  1.674    rillig 	if (fullname == NULL && !isSystem)
   1251  1.674    rillig 		fullname = FindInQuotPath(file);
   1252  1.668       sjg 
   1253  1.668       sjg 	if (fullname == NULL) {
   1254  1.668       sjg 		SearchPath *path = Lst_IsEmpty(&sysIncPath->dirs)
   1255  1.668       sjg 		    ? defSysIncPath : sysIncPath;
   1256  1.668       sjg 		fullname = Dir_FindFile(file, path);
   1257  1.668       sjg 	}
   1258  1.668       sjg 
   1259  1.668       sjg 	if (fullname == NULL) {
   1260  1.668       sjg 		if (!silent)
   1261  1.668       sjg 			Parse_Error(PARSE_FATAL, "Could not find %s", file);
   1262  1.668       sjg 		return;
   1263  1.668       sjg 	}
   1264  1.668       sjg 
   1265  1.701    rillig 	if (SkipGuarded(fullname))
   1266  1.700    rillig 		return;
   1267  1.700    rillig 
   1268  1.674    rillig 	if ((fd = open(fullname, O_RDONLY)) == -1) {
   1269  1.668       sjg 		if (!silent)
   1270  1.668       sjg 			Parse_Error(PARSE_FATAL, "Cannot open %s", fullname);
   1271  1.668       sjg 		free(fullname);
   1272  1.668       sjg 		return;
   1273  1.668       sjg 	}
   1274  1.668       sjg 
   1275  1.675    rillig 	buf = LoadFile(fullname, fd);
   1276  1.668       sjg 	(void)close(fd);
   1277  1.668       sjg 
   1278  1.668       sjg 	Parse_PushInput(fullname, 1, 0, buf, NULL);
   1279  1.668       sjg 	if (depinc)
   1280  1.668       sjg 		doing_depend = depinc;	/* only turn it on */
   1281  1.668       sjg 	free(fullname);
   1282  1.668       sjg }
   1283  1.668       sjg 
   1284  1.630    rillig /* Handle a "dependency" line like '.SPECIAL:' without any sources. */
   1285  1.392    rillig static void
   1286  1.630    rillig HandleDependencySourcesEmpty(ParseSpecial special, SearchPathList *paths)
   1287  1.368    rillig {
   1288  1.587    rillig 	switch (special) {
   1289  1.469    rillig 	case SP_SUFFIXES:
   1290  1.469    rillig 		Suff_ClearSuffixes();
   1291  1.469    rillig 		break;
   1292  1.469    rillig 	case SP_PRECIOUS:
   1293  1.553    rillig 		allPrecious = true;
   1294  1.469    rillig 		break;
   1295  1.469    rillig 	case SP_IGNORE:
   1296  1.553    rillig 		opts.ignoreErrors = true;
   1297  1.469    rillig 		break;
   1298  1.469    rillig 	case SP_SILENT:
   1299  1.584    rillig 		opts.silent = true;
   1300  1.469    rillig 		break;
   1301  1.469    rillig 	case SP_PATH:
   1302  1.692       sjg 	case SP_SYSPATH:
   1303  1.692       sjg 		ClearPaths(special, paths);
   1304  1.469    rillig 		break;
   1305  1.469    rillig 	case SP_POSIX:
   1306  1.669    rillig 		if (posix_state == PS_NOW_OR_NEVER) {
   1307  1.670       sjg 			/*
   1308  1.670       sjg 			 * With '-r', 'posix.mk' (if it exists)
   1309  1.670       sjg 			 * can effectively substitute for 'sys.mk',
   1310  1.670       sjg 			 * otherwise it is an extension.
   1311  1.670       sjg 			 */
   1312  1.669    rillig 			Global_Set("%POSIX", "1003.2");
   1313  1.669    rillig 			IncludeFile("posix.mk", true, false, true);
   1314  1.668       sjg 		}
   1315  1.469    rillig 		break;
   1316  1.469    rillig 	default:
   1317  1.469    rillig 		break;
   1318  1.469    rillig 	}
   1319  1.368    rillig }
   1320  1.364    rillig 
   1321  1.393    rillig static void
   1322  1.393    rillig AddToPaths(const char *dir, SearchPathList *paths)
   1323  1.393    rillig {
   1324  1.469    rillig 	if (paths != NULL) {
   1325  1.469    rillig 		SearchPathListNode *ln;
   1326  1.469    rillig 		for (ln = paths->first; ln != NULL; ln = ln->next)
   1327  1.529    rillig 			(void)SearchPath_Add(ln->datum, dir);
   1328  1.469    rillig 	}
   1329  1.393    rillig }
   1330  1.393    rillig 
   1331  1.368    rillig /*
   1332  1.610    rillig  * If the target was one that doesn't take files as its sources but takes
   1333  1.610    rillig  * something like suffixes, we take each space-separated word on the line as
   1334  1.610    rillig  * a something and deal with it accordingly.
   1335  1.368    rillig  */
   1336  1.368    rillig static void
   1337  1.622    rillig ParseDependencySourceSpecial(ParseSpecial special, const char *word,
   1338  1.556    rillig 			     SearchPathList *paths)
   1339  1.368    rillig {
   1340  1.587    rillig 	switch (special) {
   1341  1.469    rillig 	case SP_SUFFIXES:
   1342  1.632    rillig 		Suff_AddSuffix(word);
   1343  1.469    rillig 		break;
   1344  1.469    rillig 	case SP_PATH:
   1345  1.709    rillig 	case SP_SYSPATH:
   1346  1.469    rillig 		AddToPaths(word, paths);
   1347  1.469    rillig 		break;
   1348  1.469    rillig 	case SP_INCLUDES:
   1349  1.469    rillig 		Suff_AddInclude(word);
   1350  1.469    rillig 		break;
   1351  1.469    rillig 	case SP_LIBS:
   1352  1.469    rillig 		Suff_AddLib(word);
   1353  1.469    rillig 		break;
   1354  1.691       sjg 	case SP_NOREADONLY:
   1355  1.691       sjg 		Var_ReadOnly(word, false);
   1356  1.691       sjg 		break;
   1357  1.469    rillig 	case SP_NULL:
   1358  1.469    rillig 		Suff_SetNull(word);
   1359  1.469    rillig 		break;
   1360  1.469    rillig 	case SP_OBJDIR:
   1361  1.553    rillig 		Main_SetObjdir(false, "%s", word);
   1362  1.469    rillig 		break;
   1363  1.691       sjg 	case SP_READONLY:
   1364  1.691       sjg 		Var_ReadOnly(word, true);
   1365  1.691       sjg 		break;
   1366  1.469    rillig 	default:
   1367  1.469    rillig 		break;
   1368  1.469    rillig 	}
   1369  1.368    rillig }
   1370  1.364    rillig 
   1371  1.553    rillig static bool
   1372  1.601    rillig ApplyDependencyTarget(char *name, char *nameEnd, ParseSpecial *inout_special,
   1373  1.601    rillig 		      GNodeType *inout_targetAttr,
   1374  1.601    rillig 		      SearchPathList **inout_paths)
   1375  1.601    rillig {
   1376  1.709    rillig 	char savedNameEnd = *nameEnd;
   1377  1.601    rillig 	*nameEnd = '\0';
   1378  1.601    rillig 
   1379  1.602    rillig 	if (!HandleDependencyTarget(name, inout_special,
   1380  1.601    rillig 	    inout_targetAttr, inout_paths))
   1381  1.601    rillig 		return false;
   1382  1.601    rillig 
   1383  1.601    rillig 	if (*inout_special == SP_NOT && *name != '\0')
   1384  1.602    rillig 		HandleDependencyTargetMundane(name);
   1385  1.601    rillig 	else if (*inout_special == SP_PATH && *name != '.' && *name != '\0')
   1386  1.601    rillig 		Parse_Error(PARSE_WARNING, "Extra target (%s) ignored", name);
   1387  1.601    rillig 
   1388  1.709    rillig 	*nameEnd = savedNameEnd;
   1389  1.601    rillig 	return true;
   1390  1.601    rillig }
   1391  1.601    rillig 
   1392  1.601    rillig static bool
   1393  1.689    rillig ParseDependencyTargets(char **pp,
   1394  1.556    rillig 		       const char *lstart,
   1395  1.587    rillig 		       ParseSpecial *inout_special,
   1396  1.590    rillig 		       GNodeType *inout_targetAttr,
   1397  1.706    rillig 		       SearchPathList **inout_paths,
   1398  1.706    rillig 		       const char *unexpanded_line)
   1399  1.368    rillig {
   1400  1.689    rillig 	char *p = *pp;
   1401  1.469    rillig 
   1402  1.469    rillig 	for (;;) {
   1403  1.689    rillig 		char *tgt = p;
   1404  1.625    rillig 
   1405  1.689    rillig 		ParseDependencyTargetWord(&p, lstart);
   1406  1.469    rillig 
   1407  1.469    rillig 		/*
   1408  1.469    rillig 		 * If the word is followed by a left parenthesis, it's the
   1409  1.596    rillig 		 * name of one or more files inside an archive.
   1410  1.469    rillig 		 */
   1411  1.689    rillig 		if (!IsEscaped(lstart, p) && *p == '(') {
   1412  1.689    rillig 			p = tgt;
   1413  1.689    rillig 			if (!Arch_ParseArchive(&p, targets, SCOPE_CMDLINE)) {
   1414  1.469    rillig 				Parse_Error(PARSE_FATAL,
   1415  1.469    rillig 				    "Error in archive specification: \"%s\"",
   1416  1.469    rillig 				    tgt);
   1417  1.553    rillig 				return false;
   1418  1.469    rillig 			}
   1419  1.469    rillig 			continue;
   1420  1.469    rillig 		}
   1421  1.444    rillig 
   1422  1.689    rillig 		if (*p == '\0') {
   1423  1.706    rillig 			InvalidLineType(lstart, unexpanded_line);
   1424  1.553    rillig 			return false;
   1425  1.469    rillig 		}
   1426   1.27  christos 
   1427  1.689    rillig 		if (!ApplyDependencyTarget(tgt, p, inout_special,
   1428  1.590    rillig 		    inout_targetAttr, inout_paths))
   1429  1.553    rillig 			return false;
   1430  1.118       dsl 
   1431  1.587    rillig 		if (*inout_special != SP_NOT && *inout_special != SP_PATH)
   1432  1.689    rillig 			SkipExtraTargets(&p, lstart);
   1433  1.469    rillig 		else
   1434  1.689    rillig 			pp_skip_whitespace(&p);
   1435  1.368    rillig 
   1436  1.689    rillig 		if (*p == '\0')
   1437  1.469    rillig 			break;
   1438  1.689    rillig 		if ((*p == '!' || *p == ':') && !IsEscaped(lstart, p))
   1439  1.469    rillig 			break;
   1440  1.469    rillig 	}
   1441  1.430    rillig 
   1442  1.689    rillig 	*pp = p;
   1443  1.553    rillig 	return true;
   1444  1.368    rillig }
   1445   1.27  christos 
   1446  1.368    rillig static void
   1447  1.597    rillig ParseDependencySourcesSpecial(char *start,
   1448  1.587    rillig 			      ParseSpecial special, SearchPathList *paths)
   1449  1.368    rillig {
   1450  1.204  dholland 
   1451  1.469    rillig 	while (*start != '\0') {
   1452  1.709    rillig 		char savedEnd;
   1453  1.597    rillig 		char *end = start;
   1454  1.469    rillig 		while (*end != '\0' && !ch_isspace(*end))
   1455  1.469    rillig 			end++;
   1456  1.709    rillig 		savedEnd = *end;
   1457  1.469    rillig 		*end = '\0';
   1458  1.587    rillig 		ParseDependencySourceSpecial(special, start, paths);
   1459  1.709    rillig 		*end = savedEnd;
   1460  1.709    rillig 		if (savedEnd != '\0')
   1461  1.469    rillig 			end++;
   1462  1.469    rillig 		pp_skip_whitespace(&end);
   1463  1.469    rillig 		start = end;
   1464  1.469    rillig 	}
   1465  1.368    rillig }
   1466  1.368    rillig 
   1467  1.656       sjg static void
   1468  1.656       sjg LinkVarToTargets(VarAssign *var)
   1469  1.656       sjg {
   1470  1.656       sjg 	GNodeListNode *ln;
   1471  1.656       sjg 
   1472  1.656       sjg 	for (ln = targets->first; ln != NULL; ln = ln->next)
   1473  1.658    rillig 		Parse_Var(var, ln->datum);
   1474  1.656       sjg }
   1475  1.656       sjg 
   1476  1.553    rillig static bool
   1477  1.597    rillig ParseDependencySourcesMundane(char *start,
   1478  1.590    rillig 			      ParseSpecial special, GNodeType targetAttr)
   1479  1.368    rillig {
   1480  1.469    rillig 	while (*start != '\0') {
   1481  1.597    rillig 		char *end = start;
   1482  1.656       sjg 		VarAssign var;
   1483  1.656       sjg 
   1484  1.656       sjg 		/*
   1485  1.656       sjg 		 * Check for local variable assignment,
   1486  1.656       sjg 		 * rest of the line is the value.
   1487  1.656       sjg 		 */
   1488  1.656       sjg 		if (Parse_IsVar(start, &var)) {
   1489  1.709    rillig 			bool targetVarsEnabled = GetBooleanExpr(
   1490  1.657    rillig 			    "${.MAKE.TARGET_LOCAL_VARIABLES}", true);
   1491  1.656       sjg 
   1492  1.709    rillig 			if (targetVarsEnabled)
   1493  1.656       sjg 				LinkVarToTargets(&var);
   1494  1.656       sjg 			free(var.varname);
   1495  1.709    rillig 			if (targetVarsEnabled)
   1496  1.656       sjg 				return true;
   1497  1.656       sjg 		}
   1498  1.657    rillig 
   1499  1.367    rillig 		/*
   1500  1.469    rillig 		 * The targets take real sources, so we must beware of archive
   1501  1.469    rillig 		 * specifications (i.e. things with left parentheses in them)
   1502  1.469    rillig 		 * and handle them accordingly.
   1503  1.367    rillig 		 */
   1504  1.469    rillig 		for (; *end != '\0' && !ch_isspace(*end); end++) {
   1505  1.469    rillig 			if (*end == '(' && end > start && end[-1] != '$') {
   1506  1.469    rillig 				/*
   1507  1.469    rillig 				 * Only stop for a left parenthesis if it
   1508  1.469    rillig 				 * isn't at the start of a word (that'll be
   1509  1.469    rillig 				 * for variable changes later) and isn't
   1510  1.469    rillig 				 * preceded by a dollar sign (a dynamic
   1511  1.469    rillig 				 * source).
   1512  1.469    rillig 				 */
   1513  1.469    rillig 				break;
   1514  1.469    rillig 			}
   1515  1.469    rillig 		}
   1516  1.368    rillig 
   1517  1.469    rillig 		if (*end == '(') {
   1518  1.469    rillig 			GNodeList sources = LST_INIT;
   1519  1.545    rillig 			if (!Arch_ParseArchive(&start, &sources,
   1520  1.545    rillig 			    SCOPE_CMDLINE)) {
   1521  1.469    rillig 				Parse_Error(PARSE_FATAL,
   1522  1.469    rillig 				    "Error in source archive spec \"%s\"",
   1523  1.469    rillig 				    start);
   1524  1.553    rillig 				return false;
   1525  1.469    rillig 			}
   1526  1.368    rillig 
   1527  1.469    rillig 			while (!Lst_IsEmpty(&sources)) {
   1528  1.469    rillig 				GNode *gn = Lst_Dequeue(&sources);
   1529  1.593    rillig 				ApplyDependencySource(targetAttr, gn->name,
   1530  1.590    rillig 				    special);
   1531  1.469    rillig 			}
   1532  1.469    rillig 			Lst_Done(&sources);
   1533  1.469    rillig 			end = start;
   1534  1.469    rillig 		} else {
   1535  1.469    rillig 			if (*end != '\0') {
   1536  1.469    rillig 				*end = '\0';
   1537  1.469    rillig 				end++;
   1538  1.469    rillig 			}
   1539  1.368    rillig 
   1540  1.593    rillig 			ApplyDependencySource(targetAttr, start, special);
   1541  1.469    rillig 		}
   1542  1.469    rillig 		pp_skip_whitespace(&end);
   1543  1.469    rillig 		start = end;
   1544  1.368    rillig 	}
   1545  1.553    rillig 	return true;
   1546  1.368    rillig }
   1547    1.1       cgd 
   1548  1.559    rillig /*
   1549  1.626    rillig  * From a dependency line like 'targets: sources', parse the sources.
   1550  1.559    rillig  *
   1551  1.559    rillig  * See the tests depsrc-*.mk.
   1552  1.559    rillig  */
   1553  1.558    rillig static void
   1554  1.597    rillig ParseDependencySources(char *p, GNodeType targetAttr,
   1555  1.587    rillig 		       ParseSpecial special, SearchPathList **inout_paths)
   1556  1.558    rillig {
   1557  1.597    rillig 	if (*p == '\0') {
   1558  1.630    rillig 		HandleDependencySourcesEmpty(special, *inout_paths);
   1559  1.587    rillig 	} else if (special == SP_MFLAGS) {
   1560  1.597    rillig 		Main_ParseArgLine(p);
   1561  1.626    rillig 		return;
   1562  1.587    rillig 	} else if (special == SP_SHELL) {
   1563  1.597    rillig 		if (!Job_ParseShell(p)) {
   1564  1.558    rillig 			Parse_Error(PARSE_FATAL,
   1565  1.558    rillig 			    "improper shell specification");
   1566  1.558    rillig 			return;
   1567  1.558    rillig 		}
   1568  1.626    rillig 		return;
   1569  1.587    rillig 	} else if (special == SP_NOTPARALLEL || special == SP_SINGLESHELL ||
   1570  1.587    rillig 		   special == SP_DELETE_ON_ERROR) {
   1571  1.626    rillig 		return;
   1572  1.558    rillig 	}
   1573  1.558    rillig 
   1574  1.691       sjg 	switch (special) {
   1575  1.691       sjg 	case SP_INCLUDES:
   1576  1.691       sjg 	case SP_LIBS:
   1577  1.691       sjg 	case SP_NOREADONLY:
   1578  1.691       sjg 	case SP_NULL:
   1579  1.691       sjg 	case SP_OBJDIR:
   1580  1.691       sjg 	case SP_PATH:
   1581  1.691       sjg 	case SP_READONLY:
   1582  1.691       sjg 	case SP_SUFFIXES:
   1583  1.692       sjg 	case SP_SYSPATH:
   1584  1.597    rillig 		ParseDependencySourcesSpecial(p, special, *inout_paths);
   1585  1.558    rillig 		if (*inout_paths != NULL) {
   1586  1.558    rillig 			Lst_Free(*inout_paths);
   1587  1.558    rillig 			*inout_paths = NULL;
   1588  1.558    rillig 		}
   1589  1.587    rillig 		if (special == SP_PATH)
   1590  1.558    rillig 			Dir_SetPATH();
   1591  1.692       sjg 		if (special == SP_SYSPATH)
   1592  1.692       sjg 			Dir_SetSYSPATH();
   1593  1.691       sjg 		break;
   1594  1.691       sjg 	default:
   1595  1.558    rillig 		assert(*inout_paths == NULL);
   1596  1.597    rillig 		if (!ParseDependencySourcesMundane(p, special, targetAttr))
   1597  1.558    rillig 			return;
   1598  1.691       sjg 		break;
   1599  1.558    rillig 	}
   1600  1.558    rillig 
   1601  1.630    rillig 	MaybeUpdateMainTarget();
   1602  1.558    rillig }
   1603  1.558    rillig 
   1604  1.524    rillig /*
   1605  1.524    rillig  * Parse a dependency line consisting of targets, followed by a dependency
   1606  1.368    rillig  * operator, optionally followed by sources.
   1607  1.368    rillig  *
   1608  1.368    rillig  * The nodes of the sources are linked as children to the nodes of the
   1609  1.368    rillig  * targets. Nodes are created as necessary.
   1610  1.368    rillig  *
   1611  1.368    rillig  * The operator is applied to each node in the global 'targets' list,
   1612  1.585    rillig  * which is where the nodes found for the targets are kept.
   1613  1.368    rillig  *
   1614  1.368    rillig  * The sources are parsed in much the same way as the targets, except
   1615  1.368    rillig  * that they are expanded using the wildcarding scheme of the C-Shell,
   1616  1.441    rillig  * and a target is created for each expanded word. Each of the resulting
   1617  1.441    rillig  * nodes is then linked to each of the targets as one of its children.
   1618  1.368    rillig  *
   1619  1.368    rillig  * Certain targets and sources such as .PHONY or .PRECIOUS are handled
   1620  1.585    rillig  * specially, see ParseSpecial.
   1621  1.368    rillig  *
   1622  1.585    rillig  * Transformation rules such as '.c.o' are also handled here, see
   1623  1.585    rillig  * Suff_AddTransform.
   1624  1.441    rillig  *
   1625  1.721    rillig  * Upon return, the value of expandedLine is unspecified.
   1626  1.368    rillig  */
   1627  1.368    rillig static void
   1628  1.721    rillig ParseDependency(char *expandedLine, const char *unexpandedLine)
   1629  1.368    rillig {
   1630  1.600    rillig 	char *p;
   1631  1.583    rillig 	SearchPathList *paths;	/* search paths to alter when parsing a list
   1632  1.583    rillig 				 * of .PATH targets */
   1633  1.590    rillig 	GNodeType targetAttr;	/* from special sources */
   1634  1.600    rillig 	ParseSpecial special;	/* in special targets, the children are
   1635  1.600    rillig 				 * linked as children of the parent but not
   1636  1.600    rillig 				 * vice versa */
   1637  1.681    rillig 	GNodeType op;
   1638  1.469    rillig 
   1639  1.721    rillig 	DEBUG1(PARSE, "ParseDependency(%s)\n", expandedLine);
   1640  1.721    rillig 	p = expandedLine;
   1641  1.600    rillig 	paths = NULL;
   1642  1.590    rillig 	targetAttr = OP_NONE;
   1643  1.600    rillig 	special = SP_NOT;
   1644  1.469    rillig 
   1645  1.721    rillig 	if (!ParseDependencyTargets(&p, expandedLine, &special, &targetAttr,
   1646  1.721    rillig 	    &paths, unexpandedLine))
   1647  1.469    rillig 		goto out;
   1648  1.469    rillig 
   1649  1.469    rillig 	if (!Lst_IsEmpty(targets))
   1650  1.628    rillig 		CheckSpecialMundaneMixture(special);
   1651  1.469    rillig 
   1652  1.681    rillig 	op = ParseDependencyOp(&p);
   1653  1.681    rillig 	if (op == OP_NONE) {
   1654  1.721    rillig 		InvalidLineType(expandedLine, unexpandedLine);
   1655  1.681    rillig 		goto out;
   1656  1.681    rillig 	}
   1657  1.681    rillig 	ApplyDependencyOperator(op);
   1658  1.469    rillig 
   1659  1.600    rillig 	pp_skip_whitespace(&p);
   1660  1.469    rillig 
   1661  1.600    rillig 	ParseDependencySources(p, targetAttr, special, &paths);
   1662    1.1       cgd 
   1663  1.112  christos out:
   1664  1.469    rillig 	if (paths != NULL)
   1665  1.469    rillig 		Lst_Free(paths);
   1666    1.1       cgd }
   1667    1.1       cgd 
   1668  1.469    rillig /*
   1669  1.469    rillig  * Determine the assignment operator and adjust the end of the variable
   1670  1.469    rillig  * name accordingly.
   1671  1.469    rillig  */
   1672  1.606    rillig static VarAssign
   1673  1.606    rillig AdjustVarassignOp(const char *name, const char *nameEnd, const char *op,
   1674  1.606    rillig 		  const char *value)
   1675  1.388    rillig {
   1676  1.469    rillig 	VarAssignOp type;
   1677  1.606    rillig 	VarAssign va;
   1678  1.469    rillig 
   1679  1.469    rillig 	if (op > name && op[-1] == '+') {
   1680  1.579    rillig 		op--;
   1681  1.469    rillig 		type = VAR_APPEND;
   1682  1.469    rillig 
   1683  1.469    rillig 	} else if (op > name && op[-1] == '?') {
   1684  1.469    rillig 		op--;
   1685  1.469    rillig 		type = VAR_DEFAULT;
   1686  1.469    rillig 
   1687  1.469    rillig 	} else if (op > name && op[-1] == ':') {
   1688  1.469    rillig 		op--;
   1689  1.469    rillig 		type = VAR_SUBST;
   1690  1.469    rillig 
   1691  1.469    rillig 	} else if (op > name && op[-1] == '!') {
   1692  1.469    rillig 		op--;
   1693  1.469    rillig 		type = VAR_SHELL;
   1694  1.388    rillig 
   1695  1.469    rillig 	} else {
   1696  1.469    rillig 		type = VAR_NORMAL;
   1697  1.469    rillig 		while (op > name && ch_isspace(op[-1]))
   1698  1.469    rillig 			op--;
   1699  1.388    rillig 
   1700  1.608    rillig 		if (op - name >= 3 && memcmp(op - 3, ":sh", 3) == 0) {
   1701  1.579    rillig 			op -= 3;
   1702  1.469    rillig 			type = VAR_SHELL;
   1703  1.469    rillig 		}
   1704  1.388    rillig 	}
   1705  1.388    rillig 
   1706  1.606    rillig 	va.varname = bmake_strsedup(name, nameEnd < op ? nameEnd : op);
   1707  1.606    rillig 	va.op = type;
   1708  1.606    rillig 	va.value = value;
   1709  1.606    rillig 	return va;
   1710  1.388    rillig }
   1711  1.388    rillig 
   1712  1.469    rillig /*
   1713  1.469    rillig  * Parse a variable assignment, consisting of a single-word variable name,
   1714  1.368    rillig  * optional whitespace, an assignment operator, optional whitespace and the
   1715  1.368    rillig  * variable value.
   1716   1.84       wiz  *
   1717  1.410    rillig  * Note: There is a lexical ambiguity with assignment modifier characters
   1718  1.410    rillig  * in variable names. This routine interprets the character before the =
   1719  1.410    rillig  * as a modifier. Therefore, an assignment like
   1720  1.410    rillig  *	C++=/usr/bin/CC
   1721  1.410    rillig  * is interpreted as "C+ +=" instead of "C++ =".
   1722  1.410    rillig  *
   1723  1.469    rillig  * Used for both lines in a file and command line arguments.
   1724  1.469    rillig  */
   1725  1.605    rillig static bool
   1726  1.368    rillig Parse_IsVar(const char *p, VarAssign *out_var)
   1727    1.1       cgd {
   1728  1.652    rillig 	const char *nameStart, *nameEnd, *firstSpace, *eq;
   1729  1.469    rillig 	int level = 0;
   1730  1.469    rillig 
   1731  1.469    rillig 	cpp_skip_hspace(&p);	/* Skip to variable name */
   1732  1.469    rillig 
   1733  1.469    rillig 	/*
   1734  1.665    rillig 	 * During parsing, the '+' of the operator '+=' is initially parsed
   1735  1.469    rillig 	 * as part of the variable name.  It is later corrected, as is the
   1736  1.652    rillig 	 * ':sh' modifier. Of these two (nameEnd and eq), the earlier one
   1737  1.469    rillig 	 * determines the actual end of the variable name.
   1738  1.469    rillig 	 */
   1739  1.652    rillig 
   1740  1.606    rillig 	nameStart = p;
   1741  1.652    rillig 	firstSpace = NULL;
   1742  1.356    rillig 
   1743  1.712    rillig 	/* Scan for one of the assignment operators outside an expression. */
   1744  1.469    rillig 	while (*p != '\0') {
   1745  1.469    rillig 		char ch = *p++;
   1746  1.469    rillig 		if (ch == '(' || ch == '{') {
   1747  1.469    rillig 			level++;
   1748  1.469    rillig 			continue;
   1749  1.469    rillig 		}
   1750  1.469    rillig 		if (ch == ')' || ch == '}') {
   1751  1.469    rillig 			level--;
   1752  1.469    rillig 			continue;
   1753  1.469    rillig 		}
   1754  1.469    rillig 
   1755  1.469    rillig 		if (level != 0)
   1756  1.469    rillig 			continue;
   1757  1.469    rillig 
   1758  1.652    rillig 		if ((ch == ' ' || ch == '\t') && firstSpace == NULL)
   1759  1.652    rillig 			firstSpace = p - 1;
   1760  1.469    rillig 		while (ch == ' ' || ch == '\t')
   1761  1.469    rillig 			ch = *p++;
   1762  1.368    rillig 
   1763  1.662       sjg 		if (ch == '\0')
   1764  1.662       sjg 			return false;
   1765  1.469    rillig 		if (ch == ':' && p[0] == 's' && p[1] == 'h') {
   1766  1.469    rillig 			p += 2;
   1767  1.469    rillig 			continue;
   1768  1.469    rillig 		}
   1769  1.607    rillig 		if (ch == '=')
   1770  1.606    rillig 			eq = p - 1;
   1771  1.607    rillig 		else if (*p == '=' &&
   1772  1.607    rillig 		    (ch == '+' || ch == ':' || ch == '?' || ch == '!'))
   1773  1.606    rillig 			eq = p;
   1774  1.607    rillig 		else if (firstSpace != NULL)
   1775  1.553    rillig 			return false;
   1776  1.607    rillig 		else
   1777  1.607    rillig 			continue;
   1778  1.607    rillig 
   1779  1.607    rillig 		nameEnd = firstSpace != NULL ? firstSpace : eq;
   1780  1.607    rillig 		p = eq + 1;
   1781  1.607    rillig 		cpp_skip_whitespace(&p);
   1782  1.607    rillig 		*out_var = AdjustVarassignOp(nameStart, nameEnd, eq, p);
   1783  1.607    rillig 		return true;
   1784  1.191       sjg 	}
   1785    1.1       cgd 
   1786  1.553    rillig 	return false;
   1787    1.1       cgd }
   1788    1.1       cgd 
   1789  1.469    rillig /*
   1790  1.469    rillig  * Check for syntax errors such as unclosed expressions or unknown modifiers.
   1791  1.469    rillig  */
   1792  1.368    rillig static void
   1793  1.709    rillig VarCheckSyntax(VarAssignOp op, const char *uvalue, GNode *scope)
   1794  1.368    rillig {
   1795  1.515    rillig 	if (opts.strict) {
   1796  1.709    rillig 		if (op != VAR_SUBST && strchr(uvalue, '$') != NULL) {
   1797  1.709    rillig 			char *parsedValue = Var_Subst(uvalue,
   1798  1.694    rillig 			    scope, VARE_PARSE_ONLY);
   1799  1.469    rillig 			/* TODO: handle errors */
   1800  1.709    rillig 			free(parsedValue);
   1801  1.469    rillig 		}
   1802  1.243       sjg 	}
   1803  1.368    rillig }
   1804  1.368    rillig 
   1805  1.630    rillig /* Perform a variable assignment that uses the operator ':='. */
   1806  1.390    rillig static void
   1807  1.548    rillig VarAssign_EvalSubst(GNode *scope, const char *name, const char *uvalue,
   1808  1.506    rillig 		    FStr *out_avalue)
   1809  1.390    rillig {
   1810  1.469    rillig 	char *evalue;
   1811  1.469    rillig 
   1812  1.469    rillig 	/*
   1813  1.708    rillig 	 * Make sure that we set the variable the first time to nothing
   1814  1.538    rillig 	 * so that it gets substituted.
   1815  1.538    rillig 	 *
   1816  1.538    rillig 	 * TODO: Add a test that demonstrates why this code is needed,
   1817  1.538    rillig 	 *  apart from making the debug log longer.
   1818  1.633    rillig 	 *
   1819  1.630    rillig 	 * XXX: The variable name is expanded up to 3 times.
   1820  1.469    rillig 	 */
   1821  1.548    rillig 	if (!Var_ExistsExpand(scope, name))
   1822  1.548    rillig 		Var_SetExpand(scope, name, "");
   1823  1.469    rillig 
   1824  1.694    rillig 	evalue = Var_Subst(uvalue, scope, VARE_KEEP_DOLLAR_UNDEF);
   1825  1.469    rillig 	/* TODO: handle errors */
   1826  1.520    rillig 
   1827  1.548    rillig 	Var_SetExpand(scope, name, evalue);
   1828  1.390    rillig 
   1829  1.536    rillig 	*out_avalue = FStr_InitOwn(evalue);
   1830  1.390    rillig }
   1831  1.390    rillig 
   1832  1.630    rillig /* Perform a variable assignment that uses the operator '!='. */
   1833  1.390    rillig static void
   1834  1.546    rillig VarAssign_EvalShell(const char *name, const char *uvalue, GNode *scope,
   1835  1.506    rillig 		    FStr *out_avalue)
   1836  1.390    rillig {
   1837  1.507    rillig 	FStr cmd;
   1838  1.648    rillig 	char *output, *error;
   1839  1.469    rillig 
   1840  1.507    rillig 	cmd = FStr_InitRefer(uvalue);
   1841  1.650    rillig 	Var_Expand(&cmd, SCOPE_CMDLINE, VARE_UNDEFERR);
   1842  1.469    rillig 
   1843  1.648    rillig 	output = Cmd_Exec(cmd.str, &error);
   1844  1.648    rillig 	Var_SetExpand(scope, name, output);
   1845  1.648    rillig 	*out_avalue = FStr_InitOwn(output);
   1846  1.648    rillig 	if (error != NULL) {
   1847  1.648    rillig 		Parse_Error(PARSE_WARNING, "%s", error);
   1848  1.648    rillig 		free(error);
   1849  1.648    rillig 	}
   1850  1.390    rillig 
   1851  1.507    rillig 	FStr_Done(&cmd);
   1852  1.390    rillig }
   1853  1.390    rillig 
   1854  1.524    rillig /*
   1855  1.524    rillig  * Perform a variable assignment.
   1856  1.391    rillig  *
   1857  1.554    rillig  * The actual value of the variable is returned in *out_true_avalue.
   1858  1.538    rillig  * Especially for VAR_SUBST and VAR_SHELL this can differ from the literal
   1859  1.538    rillig  * value.
   1860  1.538    rillig  *
   1861  1.538    rillig  * Return whether the assignment was actually performed, which is usually
   1862  1.538    rillig  * the case.  It is only skipped if the operator is '?=' and the variable
   1863  1.538    rillig  * already exists.
   1864  1.524    rillig  */
   1865  1.553    rillig static bool
   1866  1.391    rillig VarAssign_Eval(const char *name, VarAssignOp op, const char *uvalue,
   1867  1.554    rillig 	       GNode *scope, FStr *out_true_avalue)
   1868  1.368    rillig {
   1869  1.506    rillig 	FStr avalue = FStr_InitRefer(uvalue);
   1870  1.469    rillig 
   1871  1.469    rillig 	if (op == VAR_APPEND)
   1872  1.548    rillig 		Var_AppendExpand(scope, name, uvalue);
   1873  1.469    rillig 	else if (op == VAR_SUBST)
   1874  1.548    rillig 		VarAssign_EvalSubst(scope, name, uvalue, &avalue);
   1875  1.469    rillig 	else if (op == VAR_SHELL)
   1876  1.546    rillig 		VarAssign_EvalShell(name, uvalue, scope, &avalue);
   1877  1.469    rillig 	else {
   1878  1.630    rillig 		/* XXX: The variable name is expanded up to 2 times. */
   1879  1.548    rillig 		if (op == VAR_DEFAULT && Var_ExistsExpand(scope, name))
   1880  1.553    rillig 			return false;
   1881  1.353    rillig 
   1882  1.469    rillig 		/* Normal assignment -- just do it. */
   1883  1.548    rillig 		Var_SetExpand(scope, name, uvalue);
   1884  1.469    rillig 	}
   1885  1.469    rillig 
   1886  1.554    rillig 	*out_true_avalue = avalue;
   1887  1.553    rillig 	return true;
   1888  1.368    rillig }
   1889  1.368    rillig 
   1890  1.368    rillig static void
   1891  1.368    rillig VarAssignSpecial(const char *name, const char *avalue)
   1892  1.368    rillig {
   1893  1.696    rillig 	if (strcmp(name, ".MAKEOVERRIDES") == 0)
   1894  1.583    rillig 		Main_ExportMAKEFLAGS(false);	/* re-export MAKEFLAGS */
   1895  1.469    rillig 	else if (strcmp(name, ".CURDIR") == 0) {
   1896  1.469    rillig 		/*
   1897  1.469    rillig 		 * Someone is being (too?) clever...
   1898  1.469    rillig 		 * Let's pretend they know what they are doing and
   1899  1.469    rillig 		 * re-initialize the 'cur' CachedDir.
   1900  1.469    rillig 		 */
   1901  1.469    rillig 		Dir_InitCur(avalue);
   1902  1.469    rillig 		Dir_SetPATH();
   1903  1.696    rillig 	} else if (strcmp(name, ".MAKE.JOB.PREFIX") == 0)
   1904  1.469    rillig 		Job_SetPrefix();
   1905  1.695    rillig 	else if (strcmp(name, ".MAKE.EXPORTED") == 0)
   1906  1.473    rillig 		Var_ExportVars(avalue);
   1907  1.368    rillig }
   1908  1.368    rillig 
   1909  1.579    rillig /* Perform the variable assignment in the given scope. */
   1910  1.605    rillig static void
   1911  1.658    rillig Parse_Var(VarAssign *var, GNode *scope)
   1912  1.368    rillig {
   1913  1.583    rillig 	FStr avalue;		/* actual value (maybe expanded) */
   1914  1.368    rillig 
   1915  1.546    rillig 	VarCheckSyntax(var->op, var->value, scope);
   1916  1.546    rillig 	if (VarAssign_Eval(var->varname, var->op, var->value, scope, &avalue)) {
   1917  1.506    rillig 		VarAssignSpecial(var->varname, avalue.str);
   1918  1.506    rillig 		FStr_Done(&avalue);
   1919  1.506    rillig 	}
   1920  1.656       sjg }
   1921  1.657    rillig 
   1922  1.200  christos 
   1923  1.524    rillig /*
   1924  1.710    rillig  * See if the command possibly calls a sub-make by using the
   1925  1.524    rillig  * expressions ${.MAKE}, ${MAKE} or the plain word "make".
   1926  1.524    rillig  */
   1927  1.553    rillig static bool
   1928  1.432    rillig MaybeSubMake(const char *cmd)
   1929  1.195  christos {
   1930  1.469    rillig 	const char *start;
   1931  1.432    rillig 
   1932  1.469    rillig 	for (start = cmd; *start != '\0'; start++) {
   1933  1.469    rillig 		const char *p = start;
   1934  1.469    rillig 		char endc;
   1935  1.469    rillig 
   1936  1.469    rillig 		/* XXX: What if progname != "make"? */
   1937  1.579    rillig 		if (strncmp(p, "make", 4) == 0)
   1938  1.469    rillig 			if (start == cmd || !ch_isalnum(p[-1]))
   1939  1.469    rillig 				if (!ch_isalnum(p[4]))
   1940  1.553    rillig 					return true;
   1941  1.469    rillig 
   1942  1.469    rillig 		if (*p != '$')
   1943  1.469    rillig 			continue;
   1944  1.469    rillig 		p++;
   1945  1.469    rillig 
   1946  1.469    rillig 		if (*p == '{')
   1947  1.469    rillig 			endc = '}';
   1948  1.469    rillig 		else if (*p == '(')
   1949  1.469    rillig 			endc = ')';
   1950  1.469    rillig 		else
   1951  1.469    rillig 			continue;
   1952  1.469    rillig 		p++;
   1953  1.432    rillig 
   1954  1.469    rillig 		if (*p == '.')	/* Accept either ${.MAKE} or ${MAKE}. */
   1955  1.469    rillig 			p++;
   1956  1.432    rillig 
   1957  1.619    rillig 		if (strncmp(p, "MAKE", 4) == 0 && p[4] == endc)
   1958  1.619    rillig 			return true;
   1959  1.469    rillig 	}
   1960  1.553    rillig 	return false;
   1961  1.195  christos }
   1962  1.195  christos 
   1963  1.708    rillig /* Append the command to the target node. */
   1964  1.327    rillig static void
   1965  1.593    rillig GNode_AddCommand(GNode *gn, char *cmd)
   1966    1.9       jtc {
   1967  1.469    rillig 	if ((gn->type & OP_DOUBLEDEP) && gn->cohorts.last != NULL)
   1968  1.469    rillig 		gn = gn->cohorts.last->datum;
   1969  1.469    rillig 
   1970  1.469    rillig 	/* if target already supplied, ignore commands */
   1971  1.469    rillig 	if (!(gn->type & OP_HAS_COMMANDS)) {
   1972  1.469    rillig 		Lst_Append(&gn->commands, cmd);
   1973  1.469    rillig 		if (MaybeSubMake(cmd))
   1974  1.469    rillig 			gn->type |= OP_SUBMAKE;
   1975  1.562    rillig 		RememberLocation(gn);
   1976  1.469    rillig 	} else {
   1977  1.469    rillig 		Parse_Error(PARSE_WARNING,
   1978  1.374    rillig 		    "duplicate script for target \"%s\" ignored",
   1979  1.374    rillig 		    gn->name);
   1980  1.680    rillig 		ParseErrorInternal(gn, PARSE_WARNING,
   1981  1.469    rillig 		    "using previous script for \"%s\" defined here",
   1982  1.469    rillig 		    gn->name);
   1983  1.469    rillig 	}
   1984    1.1       cgd }
   1985    1.1       cgd 
   1986  1.469    rillig /*
   1987  1.566    rillig  * Parse a directive like '.include' or '.-include'.
   1988  1.566    rillig  *
   1989  1.566    rillig  * .include "user-makefile.mk"
   1990  1.566    rillig  * .include <system-makefile.mk>
   1991  1.566    rillig  */
   1992  1.123       dsl static void
   1993  1.556    rillig ParseInclude(char *directive)
   1994  1.123       dsl {
   1995  1.567    rillig 	char endc;		/* '>' or '"' */
   1996  1.567    rillig 	char *p;
   1997  1.553    rillig 	bool silent = directive[0] != 'i';
   1998  1.566    rillig 	FStr file;
   1999  1.123       dsl 
   2000  1.566    rillig 	p = directive + (silent ? 8 : 7);
   2001  1.566    rillig 	pp_skip_hspace(&p);
   2002  1.123       dsl 
   2003  1.566    rillig 	if (*p != '"' && *p != '<') {
   2004  1.469    rillig 		Parse_Error(PARSE_FATAL,
   2005  1.374    rillig 		    ".include filename must be delimited by '\"' or '<'");
   2006  1.469    rillig 		return;
   2007  1.469    rillig 	}
   2008  1.123       dsl 
   2009  1.709    rillig 	endc = *p++ == '<' ? '>' : '"';
   2010  1.566    rillig 	file = FStr_InitRefer(p);
   2011  1.469    rillig 
   2012  1.566    rillig 	while (*p != '\0' && *p != endc)
   2013  1.566    rillig 		p++;
   2014  1.123       dsl 
   2015  1.566    rillig 	if (*p != endc) {
   2016  1.469    rillig 		Parse_Error(PARSE_FATAL,
   2017  1.441    rillig 		    "Unclosed .include filename. '%c' expected", endc);
   2018  1.469    rillig 		return;
   2019  1.469    rillig 	}
   2020  1.430    rillig 
   2021  1.566    rillig 	*p = '\0';
   2022  1.123       dsl 
   2023  1.650    rillig 	Var_Expand(&file, SCOPE_CMDLINE, VARE_WANTRES);
   2024  1.567    rillig 	IncludeFile(file.str, endc == '>', directive[0] == 'd', silent);
   2025  1.567    rillig 	FStr_Done(&file);
   2026    1.1       cgd }
   2027    1.1       cgd 
   2028  1.524    rillig /*
   2029  1.524    rillig  * Split filename into dirname + basename, then assign these to the
   2030  1.524    rillig  * given variables.
   2031  1.524    rillig  */
   2032  1.193  christos static void
   2033  1.281    rillig SetFilenameVars(const char *filename, const char *dirvar, const char *filevar)
   2034  1.193  christos {
   2035  1.550    rillig 	const char *slash, *basename;
   2036  1.550    rillig 	FStr dirname;
   2037  1.469    rillig 
   2038  1.469    rillig 	slash = strrchr(filename, '/');
   2039  1.469    rillig 	if (slash == NULL) {
   2040  1.550    rillig 		dirname = FStr_InitRefer(curdir);
   2041  1.469    rillig 		basename = filename;
   2042  1.469    rillig 	} else {
   2043  1.550    rillig 		dirname = FStr_InitOwn(bmake_strsedup(filename, slash));
   2044  1.469    rillig 		basename = slash + 1;
   2045  1.469    rillig 	}
   2046  1.281    rillig 
   2047  1.568    rillig 	Global_Set(dirvar, dirname.str);
   2048  1.568    rillig 	Global_Set(filevar, basename);
   2049  1.469    rillig 
   2050  1.586    rillig 	DEBUG4(PARSE, "SetFilenameVars: ${%s} = `%s' ${%s} = `%s'\n",
   2051  1.586    rillig 	    dirvar, dirname.str, filevar, basename);
   2052  1.550    rillig 	FStr_Done(&dirname);
   2053  1.281    rillig }
   2054  1.281    rillig 
   2055  1.469    rillig /*
   2056  1.469    rillig  * Return the immediately including file.
   2057  1.281    rillig  *
   2058  1.281    rillig  * This is made complicated since the .for loop is implemented as a special
   2059  1.469    rillig  * kind of .include; see For_Run.
   2060  1.469    rillig  */
   2061  1.281    rillig static const char *
   2062  1.281    rillig GetActuallyIncludingFile(void)
   2063  1.281    rillig {
   2064  1.469    rillig 	size_t i;
   2065  1.627    rillig 	const IncludedFile *incs = GetInclude(0);
   2066  1.193  christos 
   2067  1.469    rillig 	for (i = includes.len; i >= 2; i--)
   2068  1.617    rillig 		if (incs[i - 1].forLoop == NULL)
   2069  1.576    rillig 			return incs[i - 2].name.str;
   2070  1.469    rillig 	return NULL;
   2071  1.193  christos }
   2072  1.281    rillig 
   2073  1.285    rillig /* Set .PARSEDIR, .PARSEFILE, .INCLUDEDFROMDIR and .INCLUDEDFROMFILE. */
   2074   1.44     aidan static void
   2075  1.593    rillig SetParseFile(const char *filename)
   2076   1.44     aidan {
   2077  1.469    rillig 	const char *including;
   2078   1.44     aidan 
   2079  1.469    rillig 	SetFilenameVars(filename, ".PARSEDIR", ".PARSEFILE");
   2080  1.281    rillig 
   2081  1.469    rillig 	including = GetActuallyIncludingFile();
   2082  1.469    rillig 	if (including != NULL) {
   2083  1.469    rillig 		SetFilenameVars(including,
   2084  1.469    rillig 		    ".INCLUDEDFROMDIR", ".INCLUDEDFROMFILE");
   2085  1.469    rillig 	} else {
   2086  1.547    rillig 		Global_Delete(".INCLUDEDFROMDIR");
   2087  1.547    rillig 		Global_Delete(".INCLUDEDFROMFILE");
   2088  1.469    rillig 	}
   2089   1.44     aidan }
   2090   1.44     aidan 
   2091  1.553    rillig static bool
   2092  1.418    rillig StrContainsWord(const char *str, const char *word)
   2093  1.418    rillig {
   2094  1.469    rillig 	size_t strLen = strlen(str);
   2095  1.469    rillig 	size_t wordLen = strlen(word);
   2096  1.588    rillig 	const char *p;
   2097  1.469    rillig 
   2098  1.469    rillig 	if (strLen < wordLen)
   2099  1.585    rillig 		return false;
   2100  1.469    rillig 
   2101  1.469    rillig 	for (p = str; p != NULL; p = strchr(p, ' ')) {
   2102  1.469    rillig 		if (*p == ' ')
   2103  1.469    rillig 			p++;
   2104  1.588    rillig 		if (p > str + strLen - wordLen)
   2105  1.585    rillig 			return false;
   2106  1.469    rillig 
   2107  1.469    rillig 		if (memcmp(p, word, wordLen) == 0 &&
   2108  1.469    rillig 		    (p[wordLen] == '\0' || p[wordLen] == ' '))
   2109  1.553    rillig 			return true;
   2110  1.469    rillig 	}
   2111  1.553    rillig 	return false;
   2112  1.469    rillig }
   2113  1.469    rillig 
   2114  1.469    rillig /*
   2115  1.469    rillig  * XXX: Searching through a set of words with this linear search is
   2116  1.469    rillig  * inefficient for variables that contain thousands of words.
   2117  1.469    rillig  *
   2118  1.469    rillig  * XXX: The paths in this list don't seem to be normalized in any way.
   2119  1.469    rillig  */
   2120  1.553    rillig static bool
   2121  1.418    rillig VarContainsWord(const char *varname, const char *word)
   2122  1.418    rillig {
   2123  1.548    rillig 	FStr val = Var_Value(SCOPE_GLOBAL, varname);
   2124  1.553    rillig 	bool found = val.str != NULL && StrContainsWord(val.str, word);
   2125  1.505    rillig 	FStr_Done(&val);
   2126  1.469    rillig 	return found;
   2127  1.418    rillig }
   2128  1.418    rillig 
   2129  1.524    rillig /*
   2130  1.524    rillig  * Track the makefiles we read - so makefiles can set dependencies on them.
   2131  1.441    rillig  * Avoid adding anything more than once.
   2132  1.441    rillig  *
   2133  1.441    rillig  * Time complexity: O(n) per call, in total O(n^2), where n is the number
   2134  1.524    rillig  * of makefiles that have been loaded.
   2135  1.524    rillig  */
   2136  1.184       sjg static void
   2137  1.593    rillig TrackInput(const char *name)
   2138  1.184       sjg {
   2139  1.696    rillig 	if (!VarContainsWord(".MAKE.MAKEFILES", name))
   2140  1.696    rillig 		Global_Append(".MAKE.MAKEFILES", name);
   2141  1.184       sjg }
   2142  1.137       sjg 
   2143   1.44     aidan 
   2144  1.630    rillig /* Parse from the given buffer, later return to the current file. */
   2145    1.5       cgd void
   2146  1.661    rillig Parse_PushInput(const char *name, unsigned lineno, unsigned readLines,
   2147  1.661    rillig 		Buffer buf, struct ForLoop *forLoop)
   2148    1.5       cgd {
   2149  1.627    rillig 	IncludedFile *curFile;
   2150  1.469    rillig 
   2151  1.617    rillig 	if (forLoop != NULL)
   2152  1.576    rillig 		name = CurFile()->name.str;
   2153  1.469    rillig 	else
   2154  1.593    rillig 		TrackInput(name);
   2155  1.469    rillig 
   2156  1.661    rillig 	DEBUG3(PARSE, "Parse_PushInput: %s %s, line %u\n",
   2157  1.617    rillig 	    forLoop != NULL ? ".for loop in": "file", name, lineno);
   2158    1.5       cgd 
   2159  1.469    rillig 	curFile = Vector_Push(&includes);
   2160  1.576    rillig 	curFile->name = FStr_InitOwn(bmake_strdup(name));
   2161  1.639    rillig 	curFile->lineno = lineno;
   2162  1.639    rillig 	curFile->readLines = readLines;
   2163  1.639    rillig 	curFile->forHeadLineno = lineno;
   2164  1.639    rillig 	curFile->forBodyReadLines = readLines;
   2165  1.616    rillig 	curFile->buf = buf;
   2166  1.469    rillig 	curFile->depending = doing_depend;	/* restore this on EOF */
   2167  1.702    rillig 	curFile->guardState = forLoop == NULL ? GS_START : GS_NO;
   2168  1.702    rillig 	curFile->guard = NULL;
   2169  1.616    rillig 	curFile->forLoop = forLoop;
   2170  1.469    rillig 
   2171  1.616    rillig 	if (forLoop != NULL && !For_NextIteration(forLoop, &curFile->buf))
   2172  1.616    rillig 		abort();	/* see For_Run */
   2173  1.469    rillig 
   2174  1.616    rillig 	curFile->buf_ptr = curFile->buf.data;
   2175  1.616    rillig 	curFile->buf_end = curFile->buf.data + curFile->buf.len;
   2176  1.687    rillig 	curFile->condMinDepth = cond_depth;
   2177  1.593    rillig 	SetParseFile(name);
   2178    1.5       cgd }
   2179    1.5       cgd 
   2180  1.375    rillig /* Check if the directive is an include directive. */
   2181  1.553    rillig static bool
   2182  1.553    rillig IsInclude(const char *dir, bool sysv)
   2183  1.228  christos {
   2184  1.298    rillig 	if (dir[0] == 's' || dir[0] == '-' || (dir[0] == 'd' && !sysv))
   2185  1.298    rillig 		dir++;
   2186  1.228  christos 
   2187  1.298    rillig 	if (strncmp(dir, "include", 7) != 0)
   2188  1.553    rillig 		return false;
   2189  1.228  christos 
   2190  1.248    rillig 	/* Space is not mandatory for BSD .include */
   2191  1.298    rillig 	return !sysv || ch_isspace(dir[7]);
   2192  1.228  christos }
   2193  1.228  christos 
   2194  1.228  christos 
   2195  1.284    rillig /* Check if the line is a SYSV include directive. */
   2196  1.553    rillig static bool
   2197  1.228  christos IsSysVInclude(const char *line)
   2198  1.228  christos {
   2199  1.228  christos 	const char *p;
   2200  1.228  christos 
   2201  1.553    rillig 	if (!IsInclude(line, true))
   2202  1.553    rillig 		return false;
   2203  1.228  christos 
   2204  1.375    rillig 	/* Avoid interpreting a dependency line as an include */
   2205  1.228  christos 	for (p = line; (p = strchr(p, ':')) != NULL;) {
   2206  1.430    rillig 
   2207  1.430    rillig 		/* end of line -> it's a dependency */
   2208  1.430    rillig 		if (*++p == '\0')
   2209  1.553    rillig 			return false;
   2210  1.430    rillig 
   2211  1.430    rillig 		/* '::' operator or ': ' -> it's a dependency */
   2212  1.430    rillig 		if (*p == ':' || ch_isspace(*p))
   2213  1.553    rillig 			return false;
   2214  1.228  christos 	}
   2215  1.553    rillig 	return true;
   2216  1.228  christos }
   2217  1.228  christos 
   2218  1.284    rillig /* Push to another file.  The line points to the word "include". */
   2219    1.5       cgd static void
   2220   1.84       wiz ParseTraditionalInclude(char *line)
   2221    1.5       cgd {
   2222  1.711    rillig 	char *p;		/* current position in file spec */
   2223  1.553    rillig 	bool done = false;
   2224  1.553    rillig 	bool silent = line[0] != 'i';
   2225  1.469    rillig 	char *file = line + (silent ? 8 : 7);
   2226  1.469    rillig 	char *all_files;
   2227  1.469    rillig 
   2228  1.586    rillig 	DEBUG1(PARSE, "ParseTraditionalInclude: %s\n", file);
   2229  1.469    rillig 
   2230  1.469    rillig 	pp_skip_whitespace(&file);
   2231  1.469    rillig 
   2232  1.694    rillig 	all_files = Var_Subst(file, SCOPE_CMDLINE, VARE_WANTRES);
   2233  1.469    rillig 	/* TODO: handle errors */
   2234  1.469    rillig 
   2235  1.711    rillig 	for (file = all_files; !done; file = p + 1) {
   2236  1.469    rillig 		/* Skip to end of line or next whitespace */
   2237  1.711    rillig 		for (p = file; *p != '\0' && !ch_isspace(*p); p++)
   2238  1.469    rillig 			continue;
   2239  1.469    rillig 
   2240  1.711    rillig 		if (*p != '\0')
   2241  1.711    rillig 			*p = '\0';
   2242  1.469    rillig 		else
   2243  1.553    rillig 			done = true;
   2244   1.38  christos 
   2245  1.553    rillig 		IncludeFile(file, false, false, silent);
   2246  1.469    rillig 	}
   2247  1.580    rillig 
   2248  1.469    rillig 	free(all_files);
   2249    1.5       cgd }
   2250    1.5       cgd 
   2251  1.375    rillig /* Parse "export <variable>=<value>", and actually export it. */
   2252  1.182  christos static void
   2253  1.182  christos ParseGmakeExport(char *line)
   2254  1.182  christos {
   2255  1.469    rillig 	char *variable = line + 6;
   2256  1.469    rillig 	char *value;
   2257  1.182  christos 
   2258  1.586    rillig 	DEBUG1(PARSE, "ParseGmakeExport: %s\n", variable);
   2259  1.182  christos 
   2260  1.469    rillig 	pp_skip_whitespace(&variable);
   2261  1.182  christos 
   2262  1.526    rillig 	for (value = variable; *value != '\0' && *value != '='; value++)
   2263  1.469    rillig 		continue;
   2264  1.182  christos 
   2265  1.469    rillig 	if (*value != '=') {
   2266  1.469    rillig 		Parse_Error(PARSE_FATAL,
   2267  1.284    rillig 		    "Variable/Value missing from \"export\"");
   2268  1.469    rillig 		return;
   2269  1.469    rillig 	}
   2270  1.469    rillig 	*value++ = '\0';	/* terminate variable */
   2271  1.323    rillig 
   2272  1.469    rillig 	/*
   2273  1.469    rillig 	 * Expand the value before putting it in the environment.
   2274  1.469    rillig 	 */
   2275  1.694    rillig 	value = Var_Subst(value, SCOPE_CMDLINE, VARE_WANTRES);
   2276  1.469    rillig 	/* TODO: handle errors */
   2277  1.469    rillig 
   2278  1.469    rillig 	setenv(variable, value, 1);
   2279  1.469    rillig 	free(value);
   2280  1.182  christos }
   2281  1.182  christos 
   2282  1.469    rillig /*
   2283  1.708    rillig  * When the end of the current file or .for loop is reached, continue reading
   2284  1.708    rillig  * the previous file at the previous location.
   2285    1.1       cgd  *
   2286    1.1       cgd  * Results:
   2287  1.553    rillig  *	true to continue parsing, i.e. it had only reached the end of an
   2288  1.553    rillig  *	included file, false if the main file has been parsed completely.
   2289    1.1       cgd  */
   2290  1.553    rillig static bool
   2291  1.123       dsl ParseEOF(void)
   2292    1.1       cgd {
   2293  1.627    rillig 	IncludedFile *curFile = CurFile();
   2294  1.469    rillig 
   2295  1.616    rillig 	doing_depend = curFile->depending;
   2296  1.616    rillig 	if (curFile->forLoop != NULL &&
   2297  1.616    rillig 	    For_NextIteration(curFile->forLoop, &curFile->buf)) {
   2298  1.616    rillig 		curFile->buf_ptr = curFile->buf.data;
   2299  1.616    rillig 		curFile->buf_end = curFile->buf.data + curFile->buf.len;
   2300  1.627    rillig 		curFile->readLines = curFile->forBodyReadLines;
   2301  1.616    rillig 		return true;
   2302  1.615    rillig 	}
   2303  1.469    rillig 
   2304  1.687    rillig 	Cond_EndFile();
   2305  1.469    rillig 
   2306  1.702    rillig 	if (curFile->guardState == GS_DONE)
   2307  1.702    rillig 		HashTable_Set(&guards, curFile->name.str, curFile->guard);
   2308  1.702    rillig 	else if (curFile->guard != NULL) {
   2309  1.702    rillig 		free(curFile->guard->name);
   2310  1.702    rillig 		free(curFile->guard);
   2311  1.700    rillig 	}
   2312  1.700    rillig 
   2313  1.576    rillig 	FStr_Done(&curFile->name);
   2314  1.616    rillig 	Buf_Done(&curFile->buf);
   2315  1.647    rillig 	if (curFile->forLoop != NULL)
   2316  1.647    rillig 		ForLoop_Free(curFile->forLoop);
   2317  1.469    rillig 	Vector_Pop(&includes);
   2318  1.155       dsl 
   2319  1.469    rillig 	if (includes.len == 0) {
   2320  1.469    rillig 		/* We've run out of input */
   2321  1.547    rillig 		Global_Delete(".PARSEDIR");
   2322  1.547    rillig 		Global_Delete(".PARSEFILE");
   2323  1.547    rillig 		Global_Delete(".INCLUDEDFROMDIR");
   2324  1.547    rillig 		Global_Delete(".INCLUDEDFROMFILE");
   2325  1.553    rillig 		return false;
   2326  1.469    rillig 	}
   2327  1.170  dholland 
   2328  1.469    rillig 	curFile = CurFile();
   2329  1.661    rillig 	DEBUG2(PARSE, "ParseEOF: returning to file %s, line %u\n",
   2330  1.641    rillig 	    curFile->name.str, curFile->readLines + 1);
   2331    1.1       cgd 
   2332  1.593    rillig 	SetParseFile(curFile->name.str);
   2333  1.553    rillig 	return true;
   2334    1.1       cgd }
   2335    1.1       cgd 
   2336  1.493    rillig typedef enum ParseRawLineResult {
   2337  1.493    rillig 	PRLR_LINE,
   2338  1.493    rillig 	PRLR_EOF,
   2339  1.493    rillig 	PRLR_ERROR
   2340  1.493    rillig } ParseRawLineResult;
   2341  1.493    rillig 
   2342  1.489    rillig /*
   2343  1.492    rillig  * Parse until the end of a line, taking into account lines that end with
   2344  1.571    rillig  * backslash-newline.  The resulting line goes from out_line to out_line_end;
   2345  1.571    rillig  * the line is not null-terminated.
   2346  1.489    rillig  */
   2347  1.493    rillig static ParseRawLineResult
   2348  1.627    rillig ParseRawLine(IncludedFile *curFile, char **out_line, char **out_line_end,
   2349  1.636    rillig 	     char **out_firstBackslash, char **out_commentLineEnd)
   2350  1.489    rillig {
   2351  1.493    rillig 	char *line = curFile->buf_ptr;
   2352  1.570    rillig 	char *buf_end = curFile->buf_end;
   2353  1.492    rillig 	char *p = line;
   2354  1.489    rillig 	char *line_end = line;
   2355  1.492    rillig 	char *firstBackslash = NULL;
   2356  1.636    rillig 	char *commentLineEnd = NULL;
   2357  1.493    rillig 	ParseRawLineResult res = PRLR_LINE;
   2358  1.489    rillig 
   2359  1.627    rillig 	curFile->readLines++;
   2360  1.490    rillig 
   2361  1.489    rillig 	for (;;) {
   2362  1.492    rillig 		char ch;
   2363  1.492    rillig 
   2364  1.570    rillig 		if (p == buf_end) {
   2365  1.493    rillig 			res = PRLR_EOF;
   2366  1.489    rillig 			break;
   2367  1.489    rillig 		}
   2368  1.489    rillig 
   2369  1.492    rillig 		ch = *p;
   2370  1.637    rillig 		if (ch == '\0' || (ch == '\\' && p[1] == '\0')) {
   2371  1.492    rillig 			Parse_Error(PARSE_FATAL, "Zero byte read from file");
   2372  1.718    rillig 			exit(2);
   2373  1.489    rillig 		}
   2374  1.489    rillig 
   2375  1.492    rillig 		/* Treat next character after '\' as literal. */
   2376  1.489    rillig 		if (ch == '\\') {
   2377  1.492    rillig 			if (firstBackslash == NULL)
   2378  1.492    rillig 				firstBackslash = p;
   2379  1.511    rillig 			if (p[1] == '\n') {
   2380  1.627    rillig 				curFile->readLines++;
   2381  1.570    rillig 				if (p + 2 == buf_end) {
   2382  1.511    rillig 					line_end = p;
   2383  1.511    rillig 					*line_end = '\n';
   2384  1.511    rillig 					p += 2;
   2385  1.511    rillig 					continue;
   2386  1.511    rillig 				}
   2387  1.511    rillig 			}
   2388  1.492    rillig 			p += 2;
   2389  1.492    rillig 			line_end = p;
   2390  1.570    rillig 			assert(p <= buf_end);
   2391  1.489    rillig 			continue;
   2392  1.489    rillig 		}
   2393  1.489    rillig 
   2394  1.489    rillig 		/*
   2395  1.492    rillig 		 * Remember the first '#' for comment stripping, unless
   2396  1.492    rillig 		 * the previous char was '[', as in the modifier ':[#]'.
   2397  1.492    rillig 		 */
   2398  1.636    rillig 		if (ch == '#' && commentLineEnd == NULL &&
   2399  1.492    rillig 		    !(p > line && p[-1] == '['))
   2400  1.636    rillig 			commentLineEnd = line_end;
   2401  1.489    rillig 
   2402  1.492    rillig 		p++;
   2403  1.489    rillig 		if (ch == '\n')
   2404  1.489    rillig 			break;
   2405  1.489    rillig 
   2406  1.489    rillig 		/* We are not interested in trailing whitespace. */
   2407  1.489    rillig 		if (!ch_isspace(ch))
   2408  1.492    rillig 			line_end = p;
   2409  1.489    rillig 	}
   2410  1.489    rillig 
   2411  1.635    rillig 	curFile->buf_ptr = p;
   2412  1.490    rillig 	*out_line = line;
   2413  1.489    rillig 	*out_line_end = line_end;
   2414  1.492    rillig 	*out_firstBackslash = firstBackslash;
   2415  1.636    rillig 	*out_commentLineEnd = commentLineEnd;
   2416  1.493    rillig 	return res;
   2417  1.489    rillig }
   2418  1.489    rillig 
   2419  1.491    rillig /*
   2420  1.491    rillig  * Beginning at start, unescape '\#' to '#' and replace backslash-newline
   2421  1.491    rillig  * with a single space.
   2422  1.491    rillig  */
   2423  1.485    rillig static void
   2424  1.508    rillig UnescapeBackslash(char *line, char *start)
   2425  1.487    rillig {
   2426  1.638    rillig 	const char *src = start;
   2427  1.491    rillig 	char *dst = start;
   2428  1.491    rillig 	char *spaceStart = line;
   2429  1.485    rillig 
   2430  1.485    rillig 	for (;;) {
   2431  1.491    rillig 		char ch = *src++;
   2432  1.485    rillig 		if (ch != '\\') {
   2433  1.485    rillig 			if (ch == '\0')
   2434  1.485    rillig 				break;
   2435  1.491    rillig 			*dst++ = ch;
   2436  1.485    rillig 			continue;
   2437  1.485    rillig 		}
   2438  1.485    rillig 
   2439  1.491    rillig 		ch = *src++;
   2440  1.485    rillig 		if (ch == '\0') {
   2441  1.635    rillig 			/* Delete '\\' at the end of the buffer. */
   2442  1.491    rillig 			dst--;
   2443  1.485    rillig 			break;
   2444  1.485    rillig 		}
   2445  1.485    rillig 
   2446  1.635    rillig 		/* Delete '\\' from before '#' on non-command lines. */
   2447  1.635    rillig 		if (ch == '#' && line[0] != '\t')
   2448  1.491    rillig 			*dst++ = ch;
   2449  1.635    rillig 		else if (ch == '\n') {
   2450  1.638    rillig 			cpp_skip_hspace(&src);
   2451  1.635    rillig 			*dst++ = ' ';
   2452  1.635    rillig 		} else {
   2453  1.635    rillig 			/* Leave '\\' in the buffer for later. */
   2454  1.491    rillig 			*dst++ = '\\';
   2455  1.491    rillig 			*dst++ = ch;
   2456  1.635    rillig 			/* Keep an escaped ' ' at the line end. */
   2457  1.635    rillig 			spaceStart = dst;
   2458  1.485    rillig 		}
   2459  1.485    rillig 	}
   2460  1.485    rillig 
   2461  1.487    rillig 	/* Delete any trailing spaces - eg from empty continuations */
   2462  1.491    rillig 	while (dst > spaceStart && ch_isspace(dst[-1]))
   2463  1.491    rillig 		dst--;
   2464  1.491    rillig 	*dst = '\0';
   2465  1.485    rillig }
   2466  1.485    rillig 
   2467  1.593    rillig typedef enum LineKind {
   2468  1.495    rillig 	/*
   2469  1.498    rillig 	 * Return the next line that is neither empty nor a comment.
   2470  1.495    rillig 	 * Backslash line continuations are folded into a single space.
   2471  1.495    rillig 	 * A trailing comment, if any, is discarded.
   2472  1.495    rillig 	 */
   2473  1.593    rillig 	LK_NONEMPTY,
   2474  1.495    rillig 
   2475  1.495    rillig 	/*
   2476  1.498    rillig 	 * Return the next line, even if it is empty or a comment.
   2477  1.499    rillig 	 * Preserve backslash-newline to keep the line numbers correct.
   2478  1.495    rillig 	 *
   2479  1.495    rillig 	 * Used in .for loops to collect the body of the loop while waiting
   2480  1.495    rillig 	 * for the corresponding .endfor.
   2481  1.495    rillig 	 */
   2482  1.593    rillig 	LK_FOR_BODY,
   2483  1.495    rillig 
   2484  1.495    rillig 	/*
   2485  1.499    rillig 	 * Return the next line that starts with a dot.
   2486  1.495    rillig 	 * Backslash line continuations are folded into a single space.
   2487  1.495    rillig 	 * A trailing comment, if any, is discarded.
   2488  1.495    rillig 	 *
   2489  1.495    rillig 	 * Used in .if directives to skip over irrelevant branches while
   2490  1.495    rillig 	 * waiting for the corresponding .endif.
   2491  1.495    rillig 	 */
   2492  1.593    rillig 	LK_DOT
   2493  1.593    rillig } LineKind;
   2494  1.127       dsl 
   2495  1.640    rillig /*
   2496  1.640    rillig  * Return the next "interesting" logical line from the current file.  The
   2497  1.640    rillig  * returned string will be freed at the end of including the file.
   2498  1.640    rillig  */
   2499  1.127       dsl static char *
   2500  1.593    rillig ReadLowLevelLine(LineKind kind)
   2501    1.5       cgd {
   2502  1.627    rillig 	IncludedFile *curFile = CurFile();
   2503  1.639    rillig 	ParseRawLineResult res;
   2504  1.469    rillig 	char *line;
   2505  1.469    rillig 	char *line_end;
   2506  1.492    rillig 	char *firstBackslash;
   2507  1.636    rillig 	char *commentLineEnd;
   2508  1.469    rillig 
   2509  1.127       dsl 	for (;;) {
   2510  1.639    rillig 		curFile->lineno = curFile->readLines + 1;
   2511  1.639    rillig 		res = ParseRawLine(curFile,
   2512  1.636    rillig 		    &line, &line_end, &firstBackslash, &commentLineEnd);
   2513  1.493    rillig 		if (res == PRLR_ERROR)
   2514  1.489    rillig 			return NULL;
   2515   1.27  christos 
   2516  1.636    rillig 		if (line == line_end || line == commentLineEnd) {
   2517  1.493    rillig 			if (res == PRLR_EOF)
   2518  1.469    rillig 				return NULL;
   2519  1.593    rillig 			if (kind != LK_FOR_BODY)
   2520  1.494    rillig 				continue;
   2521  1.469    rillig 		}
   2522    1.5       cgd 
   2523  1.469    rillig 		/* We now have a line of data */
   2524  1.514    rillig 		assert(ch_isspace(*line_end));
   2525  1.469    rillig 		*line_end = '\0';
   2526    1.5       cgd 
   2527  1.593    rillig 		if (kind == LK_FOR_BODY)
   2528  1.499    rillig 			return line;	/* Don't join the physical lines. */
   2529    1.5       cgd 
   2530  1.593    rillig 		if (kind == LK_DOT && line[0] != '.')
   2531  1.499    rillig 			continue;
   2532  1.127       dsl 		break;
   2533  1.127       dsl 	}
   2534    1.5       cgd 
   2535  1.636    rillig 	if (commentLineEnd != NULL && line[0] != '\t')
   2536  1.636    rillig 		*commentLineEnd = '\0';
   2537  1.637    rillig 	if (firstBackslash != NULL)
   2538  1.637    rillig 		UnescapeBackslash(line, firstBackslash);
   2539  1.469    rillig 	return line;
   2540    1.5       cgd }
   2541    1.1       cgd 
   2542  1.553    rillig static bool
   2543  1.593    rillig SkipIrrelevantBranches(void)
   2544  1.501    rillig {
   2545  1.640    rillig 	const char *line;
   2546  1.501    rillig 
   2547  1.708    rillig 	while ((line = ReadLowLevelLine(LK_DOT)) != NULL)
   2548  1.604    rillig 		if (Cond_EvalLine(line) == CR_TRUE)
   2549  1.640    rillig 			return true;
   2550  1.640    rillig 	return false;
   2551  1.501    rillig }
   2552  1.501    rillig 
   2553  1.553    rillig static bool
   2554  1.500    rillig ParseForLoop(const char *line)
   2555  1.500    rillig {
   2556  1.500    rillig 	int rval;
   2557  1.661    rillig 	unsigned forHeadLineno;
   2558  1.661    rillig 	unsigned bodyReadLines;
   2559  1.629    rillig 	int forLevel;
   2560  1.500    rillig 
   2561  1.500    rillig 	rval = For_Eval(line);
   2562  1.500    rillig 	if (rval == 0)
   2563  1.553    rillig 		return false;	/* Not a .for line */
   2564  1.500    rillig 	if (rval < 0)
   2565  1.553    rillig 		return true;	/* Syntax error - error printed, ignore line */
   2566  1.500    rillig 
   2567  1.642    rillig 	forHeadLineno = CurFile()->lineno;
   2568  1.642    rillig 	bodyReadLines = CurFile()->readLines;
   2569  1.642    rillig 
   2570  1.616    rillig 	/* Accumulate the loop body until the matching '.endfor'. */
   2571  1.629    rillig 	forLevel = 1;
   2572  1.500    rillig 	do {
   2573  1.593    rillig 		line = ReadLowLevelLine(LK_FOR_BODY);
   2574  1.500    rillig 		if (line == NULL) {
   2575  1.500    rillig 			Parse_Error(PARSE_FATAL,
   2576  1.572    rillig 			    "Unexpected end of file in .for loop");
   2577  1.500    rillig 			break;
   2578  1.500    rillig 		}
   2579  1.629    rillig 	} while (For_Accum(line, &forLevel));
   2580  1.500    rillig 
   2581  1.639    rillig 	For_Run(forHeadLineno, bodyReadLines);
   2582  1.616    rillig 	return true;
   2583  1.500    rillig }
   2584  1.500    rillig 
   2585  1.469    rillig /*
   2586  1.482    rillig  * Read an entire line from the input file.
   2587  1.482    rillig  *
   2588  1.708    rillig  * Empty lines, .if and .for are handled by this function, while variable
   2589  1.708    rillig  * assignments, other directives, dependency lines and shell commands are
   2590  1.708    rillig  * handled by the caller.
   2591    1.1       cgd  *
   2592  1.638    rillig  * Return a line without trailing whitespace, or NULL for EOF.  The returned
   2593  1.638    rillig  * string will be freed at the end of including the file.
   2594    1.1       cgd  */
   2595    1.1       cgd static char *
   2596  1.593    rillig ReadHighLevelLine(void)
   2597    1.1       cgd {
   2598  1.500    rillig 	char *line;
   2599  1.700    rillig 	CondResult condResult;
   2600  1.469    rillig 
   2601  1.469    rillig 	for (;;) {
   2602  1.700    rillig 		IncludedFile *curFile = CurFile();
   2603  1.593    rillig 		line = ReadLowLevelLine(LK_NONEMPTY);
   2604  1.669    rillig 		if (posix_state == PS_MAYBE_NEXT_LINE)
   2605  1.669    rillig 			posix_state = PS_NOW_OR_NEVER;
   2606  1.669    rillig 		else
   2607  1.669    rillig 			posix_state = PS_TOO_LATE;
   2608  1.469    rillig 		if (line == NULL)
   2609  1.469    rillig 			return NULL;
   2610  1.469    rillig 
   2611  1.719    rillig 		DEBUG2(PARSE, "Parsing line %u: %s\n", curFile->lineno, line);
   2612  1.702    rillig 		if (curFile->guardState != GS_NO
   2613  1.702    rillig 		    && ((curFile->guardState == GS_START && line[0] != '.')
   2614  1.702    rillig 			|| curFile->guardState == GS_DONE))
   2615  1.702    rillig 			curFile->guardState = GS_NO;
   2616  1.469    rillig 		if (line[0] != '.')
   2617  1.469    rillig 			return line;
   2618  1.469    rillig 
   2619  1.700    rillig 		condResult = Cond_EvalLine(line);
   2620  1.702    rillig 		if (curFile->guardState == GS_START) {
   2621  1.702    rillig 			Guard *guard;
   2622  1.703    rillig 			if (condResult != CR_ERROR
   2623  1.702    rillig 			    && (guard = Cond_ExtractGuard(line)) != NULL) {
   2624  1.702    rillig 				curFile->guardState = GS_COND;
   2625  1.702    rillig 				curFile->guard = guard;
   2626  1.700    rillig 			} else
   2627  1.702    rillig 				curFile->guardState = GS_NO;
   2628  1.700    rillig 		}
   2629  1.700    rillig 		switch (condResult) {
   2630  1.604    rillig 		case CR_FALSE:	/* May also mean a syntax error. */
   2631  1.593    rillig 			if (!SkipIrrelevantBranches())
   2632  1.482    rillig 				return NULL;
   2633  1.469    rillig 			continue;
   2634  1.604    rillig 		case CR_TRUE:
   2635  1.469    rillig 			continue;
   2636  1.604    rillig 		case CR_ERROR:	/* Not a conditional line */
   2637  1.500    rillig 			if (ParseForLoop(line))
   2638  1.469    rillig 				continue;
   2639  1.500    rillig 			break;
   2640  1.469    rillig 		}
   2641  1.469    rillig 		return line;
   2642    1.1       cgd 	}
   2643    1.1       cgd }
   2644    1.1       cgd 
   2645  1.331    rillig static void
   2646  1.329    rillig FinishDependencyGroup(void)
   2647    1.1       cgd {
   2648  1.469    rillig 	GNodeListNode *ln;
   2649  1.430    rillig 
   2650  1.469    rillig 	if (targets == NULL)
   2651  1.469    rillig 		return;
   2652  1.371    rillig 
   2653  1.469    rillig 	for (ln = targets->first; ln != NULL; ln = ln->next) {
   2654  1.469    rillig 		GNode *gn = ln->datum;
   2655  1.371    rillig 
   2656  1.469    rillig 		Suff_EndTransform(gn);
   2657  1.371    rillig 
   2658  1.469    rillig 		/*
   2659  1.469    rillig 		 * Mark the target as already having commands if it does, to
   2660  1.469    rillig 		 * keep from having shell commands on multiple dependency
   2661  1.469    rillig 		 * lines.
   2662  1.469    rillig 		 */
   2663  1.469    rillig 		if (!Lst_IsEmpty(&gn->commands))
   2664  1.469    rillig 			gn->type |= OP_HAS_COMMANDS;
   2665  1.469    rillig 	}
   2666  1.430    rillig 
   2667  1.469    rillig 	Lst_Free(targets);
   2668  1.469    rillig 	targets = NULL;
   2669    1.1       cgd }
   2670   1.27  christos 
   2671  1.327    rillig /* Add the command to each target from the current dependency spec. */
   2672  1.326    rillig static void
   2673  1.375    rillig ParseLine_ShellCommand(const char *p)
   2674  1.326    rillig {
   2675  1.469    rillig 	cpp_skip_whitespace(&p);
   2676  1.469    rillig 	if (*p == '\0')
   2677  1.469    rillig 		return;		/* skip empty commands */
   2678  1.327    rillig 
   2679  1.469    rillig 	if (targets == NULL) {
   2680  1.469    rillig 		Parse_Error(PARSE_FATAL,
   2681  1.469    rillig 		    "Unassociated shell command \"%s\"", p);
   2682  1.469    rillig 		return;
   2683  1.469    rillig 	}
   2684  1.327    rillig 
   2685  1.469    rillig 	{
   2686  1.469    rillig 		char *cmd = bmake_strdup(p);
   2687  1.469    rillig 		GNodeListNode *ln;
   2688  1.469    rillig 
   2689  1.469    rillig 		for (ln = targets->first; ln != NULL; ln = ln->next) {
   2690  1.469    rillig 			GNode *gn = ln->datum;
   2691  1.593    rillig 			GNode_AddCommand(gn, cmd);
   2692  1.469    rillig 		}
   2693  1.326    rillig #ifdef CLEANUP
   2694  1.469    rillig 		Lst_Append(&targCmds, cmd);
   2695  1.326    rillig #endif
   2696  1.469    rillig 	}
   2697  1.326    rillig }
   2698    1.1       cgd 
   2699  1.683    rillig static void
   2700  1.699    rillig HandleBreak(const char *arg)
   2701  1.683    rillig {
   2702  1.683    rillig 	IncludedFile *curFile = CurFile();
   2703  1.683    rillig 
   2704  1.699    rillig 	if (arg[0] != '\0')
   2705  1.699    rillig 		Parse_Error(PARSE_FATAL,
   2706  1.699    rillig 		    "The .break directive does not take arguments");
   2707  1.699    rillig 
   2708  1.683    rillig 	if (curFile->forLoop != NULL) {
   2709  1.683    rillig 		/* pretend we reached EOF */
   2710  1.683    rillig 		For_Break(curFile->forLoop);
   2711  1.687    rillig 		cond_depth = CurFile_CondMinDepth();
   2712  1.683    rillig 		ParseEOF();
   2713  1.683    rillig 	} else
   2714  1.683    rillig 		Parse_Error(PARSE_FATAL, "break outside of for loop");
   2715  1.683    rillig }
   2716  1.683    rillig 
   2717  1.474    rillig /*
   2718  1.477    rillig  * See if the line starts with one of the known directives, and if so, handle
   2719  1.477    rillig  * the directive.
   2720  1.474    rillig  */
   2721  1.553    rillig static bool
   2722  1.379    rillig ParseDirective(char *line)
   2723  1.379    rillig {
   2724  1.711    rillig 	char *p = line + 1;
   2725  1.569    rillig 	const char *arg;
   2726  1.569    rillig 	Substring dir;
   2727  1.474    rillig 
   2728  1.711    rillig 	pp_skip_whitespace(&p);
   2729  1.711    rillig 	if (IsInclude(p, false)) {
   2730  1.711    rillig 		ParseInclude(p);
   2731  1.553    rillig 		return true;
   2732  1.474    rillig 	}
   2733  1.379    rillig 
   2734  1.711    rillig 	dir.start = p;
   2735  1.711    rillig 	while (ch_islower(*p) || *p == '-')
   2736  1.711    rillig 		p++;
   2737  1.711    rillig 	dir.end = p;
   2738  1.475    rillig 
   2739  1.711    rillig 	if (*p != '\0' && !ch_isspace(*p))
   2740  1.553    rillig 		return false;
   2741  1.475    rillig 
   2742  1.711    rillig 	pp_skip_whitespace(&p);
   2743  1.711    rillig 	arg = p;
   2744  1.475    rillig 
   2745  1.683    rillig 	if (Substring_Equals(dir, "break"))
   2746  1.699    rillig 		HandleBreak(arg);
   2747  1.683    rillig 	else if (Substring_Equals(dir, "undef"))
   2748  1.569    rillig 		Var_Undef(arg);
   2749  1.581    rillig 	else if (Substring_Equals(dir, "export"))
   2750  1.517    rillig 		Var_Export(VEM_PLAIN, arg);
   2751  1.581    rillig 	else if (Substring_Equals(dir, "export-env"))
   2752  1.517    rillig 		Var_Export(VEM_ENV, arg);
   2753  1.581    rillig 	else if (Substring_Equals(dir, "export-literal"))
   2754  1.476    rillig 		Var_Export(VEM_LITERAL, arg);
   2755  1.581    rillig 	else if (Substring_Equals(dir, "unexport"))
   2756  1.553    rillig 		Var_UnExport(false, arg);
   2757  1.581    rillig 	else if (Substring_Equals(dir, "unexport-env"))
   2758  1.553    rillig 		Var_UnExport(true, arg);
   2759  1.581    rillig 	else if (Substring_Equals(dir, "info"))
   2760  1.602    rillig 		HandleMessage(PARSE_INFO, "info", arg);
   2761  1.581    rillig 	else if (Substring_Equals(dir, "warning"))
   2762  1.602    rillig 		HandleMessage(PARSE_WARNING, "warning", arg);
   2763  1.581    rillig 	else if (Substring_Equals(dir, "error"))
   2764  1.602    rillig 		HandleMessage(PARSE_FATAL, "error", arg);
   2765  1.581    rillig 	else
   2766  1.581    rillig 		return false;
   2767  1.581    rillig 	return true;
   2768  1.379    rillig }
   2769  1.379    rillig 
   2770  1.605    rillig bool
   2771  1.605    rillig Parse_VarAssign(const char *line, bool finishDependencyGroup, GNode *scope)
   2772  1.379    rillig {
   2773  1.469    rillig 	VarAssign var;
   2774  1.430    rillig 
   2775  1.469    rillig 	if (!Parse_IsVar(line, &var))
   2776  1.553    rillig 		return false;
   2777  1.605    rillig 	if (finishDependencyGroup)
   2778  1.605    rillig 		FinishDependencyGroup();
   2779  1.605    rillig 	Parse_Var(&var, scope);
   2780  1.658    rillig 	free(var.varname);
   2781  1.553    rillig 	return true;
   2782  1.379    rillig }
   2783  1.379    rillig 
   2784  1.700    rillig void
   2785  1.700    rillig Parse_GuardElse(void)
   2786  1.700    rillig {
   2787  1.700    rillig 	IncludedFile *curFile = CurFile();
   2788  1.700    rillig 	if (cond_depth == curFile->condMinDepth + 1)
   2789  1.702    rillig 		curFile->guardState = GS_NO;
   2790  1.700    rillig }
   2791  1.700    rillig 
   2792  1.700    rillig void
   2793  1.700    rillig Parse_GuardEndif(void)
   2794  1.700    rillig {
   2795  1.700    rillig 	IncludedFile *curFile = CurFile();
   2796  1.702    rillig 	if (cond_depth == curFile->condMinDepth
   2797  1.702    rillig 	    && curFile->guardState == GS_COND)
   2798  1.702    rillig 		curFile->guardState = GS_DONE;
   2799  1.700    rillig }
   2800  1.700    rillig 
   2801  1.380    rillig static char *
   2802  1.380    rillig FindSemicolon(char *p)
   2803  1.380    rillig {
   2804  1.711    rillig 	int depth = 0;
   2805  1.469    rillig 
   2806  1.469    rillig 	for (; *p != '\0'; p++) {
   2807  1.469    rillig 		if (*p == '\\' && p[1] != '\0') {
   2808  1.469    rillig 			p++;
   2809  1.469    rillig 			continue;
   2810  1.469    rillig 		}
   2811  1.380    rillig 
   2812  1.469    rillig 		if (*p == '$' && (p[1] == '(' || p[1] == '{'))
   2813  1.711    rillig 			depth++;
   2814  1.711    rillig 		else if (depth > 0 && (*p == ')' || *p == '}'))
   2815  1.711    rillig 			depth--;
   2816  1.711    rillig 		else if (depth == 0 && *p == ';')
   2817  1.469    rillig 			break;
   2818  1.469    rillig 	}
   2819  1.469    rillig 	return p;
   2820  1.380    rillig }
   2821  1.380    rillig 
   2822  1.379    rillig static void
   2823  1.555    rillig ParseDependencyLine(char *line)
   2824  1.379    rillig {
   2825  1.557    rillig 	VarEvalMode emode;
   2826  1.469    rillig 	char *expanded_line;
   2827  1.469    rillig 	const char *shellcmd = NULL;
   2828  1.469    rillig 
   2829  1.469    rillig 	{
   2830  1.469    rillig 		char *semicolon = FindSemicolon(line);
   2831  1.469    rillig 		if (*semicolon != '\0') {
   2832  1.469    rillig 			/* Terminate the dependency list at the ';' */
   2833  1.469    rillig 			*semicolon = '\0';
   2834  1.469    rillig 			shellcmd = semicolon + 1;
   2835  1.469    rillig 		}
   2836  1.469    rillig 	}
   2837  1.379    rillig 
   2838  1.469    rillig 	/*
   2839  1.708    rillig 	 * We now know it's a dependency line, so it needs to have all
   2840  1.469    rillig 	 * variables expanded before being parsed.
   2841  1.469    rillig 	 *
   2842  1.469    rillig 	 * XXX: Ideally the dependency line would first be split into
   2843  1.469    rillig 	 * its left-hand side, dependency operator and right-hand side,
   2844  1.469    rillig 	 * and then each side would be expanded on its own.  This would
   2845  1.469    rillig 	 * allow for the left-hand side to allow only defined variables
   2846  1.469    rillig 	 * and to allow variables on the right-hand side to be undefined
   2847  1.469    rillig 	 * as well.
   2848  1.469    rillig 	 *
   2849  1.469    rillig 	 * Parsing the line first would also prevent that targets
   2850  1.710    rillig 	 * generated from expressions are interpreted as the
   2851  1.469    rillig 	 * dependency operator, such as in "target${:U\:} middle: source",
   2852  1.469    rillig 	 * in which the middle is interpreted as a source, not a target.
   2853  1.469    rillig 	 */
   2854  1.469    rillig 
   2855  1.583    rillig 	/*
   2856  1.583    rillig 	 * In lint mode, allow undefined variables to appear in dependency
   2857  1.583    rillig 	 * lines.
   2858  1.469    rillig 	 *
   2859  1.583    rillig 	 * Ideally, only the right-hand side would allow undefined variables
   2860  1.583    rillig 	 * since it is common to have optional dependencies. Having undefined
   2861  1.583    rillig 	 * variables on the left-hand side is more unusual though.  Since
   2862  1.583    rillig 	 * both sides are expanded in a single pass, there is not much choice
   2863  1.583    rillig 	 * what to do here.
   2864  1.469    rillig 	 *
   2865  1.583    rillig 	 * In normal mode, it does not matter whether undefined variables are
   2866  1.583    rillig 	 * allowed or not since as of 2020-09-14, Var_Parse does not print
   2867  1.583    rillig 	 * any parse errors in such a case. It simply returns the special
   2868  1.583    rillig 	 * empty string var_Error, which cannot be detected in the result of
   2869  1.583    rillig 	 * Var_Subst.
   2870  1.583    rillig 	 */
   2871  1.557    rillig 	emode = opts.strict ? VARE_WANTRES : VARE_UNDEFERR;
   2872  1.694    rillig 	expanded_line = Var_Subst(line, SCOPE_CMDLINE, emode);
   2873  1.469    rillig 	/* TODO: handle errors */
   2874  1.469    rillig 
   2875  1.469    rillig 	/* Need a fresh list for the target nodes */
   2876  1.469    rillig 	if (targets != NULL)
   2877  1.469    rillig 		Lst_Free(targets);
   2878  1.469    rillig 	targets = Lst_New();
   2879  1.379    rillig 
   2880  1.706    rillig 	ParseDependency(expanded_line, line);
   2881  1.469    rillig 	free(expanded_line);
   2882  1.380    rillig 
   2883  1.469    rillig 	if (shellcmd != NULL)
   2884  1.469    rillig 		ParseLine_ShellCommand(shellcmd);
   2885  1.379    rillig }
   2886  1.379    rillig 
   2887  1.381    rillig static void
   2888  1.381    rillig ParseLine(char *line)
   2889  1.381    rillig {
   2890  1.474    rillig 	if (line[0] == '.' && ParseDirective(line))
   2891  1.469    rillig 		return;
   2892  1.381    rillig 
   2893  1.478    rillig 	if (line[0] == '\t') {
   2894  1.469    rillig 		ParseLine_ShellCommand(line + 1);
   2895  1.469    rillig 		return;
   2896  1.469    rillig 	}
   2897  1.381    rillig 
   2898  1.469    rillig 	if (IsSysVInclude(line)) {
   2899  1.469    rillig 		ParseTraditionalInclude(line);
   2900  1.469    rillig 		return;
   2901  1.469    rillig 	}
   2902  1.381    rillig 
   2903  1.469    rillig 	if (strncmp(line, "export", 6) == 0 && ch_isspace(line[6]) &&
   2904  1.469    rillig 	    strchr(line, ':') == NULL) {
   2905  1.469    rillig 		ParseGmakeExport(line);
   2906  1.469    rillig 		return;
   2907  1.469    rillig 	}
   2908  1.381    rillig 
   2909  1.605    rillig 	if (Parse_VarAssign(line, true, SCOPE_GLOBAL))
   2910  1.469    rillig 		return;
   2911  1.381    rillig 
   2912  1.469    rillig 	FinishDependencyGroup();
   2913  1.381    rillig 
   2914  1.555    rillig 	ParseDependencyLine(line);
   2915  1.381    rillig }
   2916  1.381    rillig 
   2917  1.708    rillig /* Interpret a top-level makefile. */
   2918    1.1       cgd void
   2919  1.125       dsl Parse_File(const char *name, int fd)
   2920    1.1       cgd {
   2921  1.613    rillig 	char *line;
   2922  1.616    rillig 	Buffer buf;
   2923  1.170  dholland 
   2924  1.675    rillig 	buf = LoadFile(name, fd != -1 ? fd : STDIN_FILENO);
   2925  1.613    rillig 	if (fd != -1)
   2926  1.613    rillig 		(void)close(fd);
   2927    1.1       cgd 
   2928  1.469    rillig 	assert(targets == NULL);
   2929   1.44     aidan 
   2930  1.639    rillig 	Parse_PushInput(name, 1, 0, buf, NULL);
   2931    1.1       cgd 
   2932  1.469    rillig 	do {
   2933  1.593    rillig 		while ((line = ReadHighLevelLine()) != NULL) {
   2934  1.469    rillig 			ParseLine(line);
   2935  1.469    rillig 		}
   2936  1.469    rillig 	} while (ParseEOF());
   2937    1.1       cgd 
   2938  1.469    rillig 	FinishDependencyGroup();
   2939  1.328    rillig 
   2940  1.561    rillig 	if (parseErrors != 0) {
   2941  1.469    rillig 		(void)fflush(stdout);
   2942  1.469    rillig 		(void)fprintf(stderr,
   2943  1.655    rillig 		    "%s: Fatal errors encountered -- cannot continue\n",
   2944  1.469    rillig 		    progname);
   2945  1.655    rillig 		PrintOnError(NULL, "");
   2946  1.469    rillig 		exit(1);
   2947  1.469    rillig 	}
   2948    1.1       cgd }
   2949    1.1       cgd 
   2950  1.383    rillig /* Initialize the parsing module. */
   2951    1.5       cgd void
   2952   1.84       wiz Parse_Init(void)
   2953    1.1       cgd {
   2954  1.469    rillig 	mainNode = NULL;
   2955  1.469    rillig 	parseIncPath = SearchPath_New();
   2956  1.469    rillig 	sysIncPath = SearchPath_New();
   2957  1.469    rillig 	defSysIncPath = SearchPath_New();
   2958  1.627    rillig 	Vector_Init(&includes, sizeof(IncludedFile));
   2959  1.700    rillig 	HashTable_Init(&guards);
   2960    1.1       cgd }
   2961    1.9       jtc 
   2962  1.383    rillig /* Clean up the parsing module. */
   2963    1.9       jtc void
   2964   1.84       wiz Parse_End(void)
   2965    1.9       jtc {
   2966   1.45   mycroft #ifdef CLEANUP
   2967  1.700    rillig 	HashIter hi;
   2968  1.700    rillig 
   2969  1.722    rillig 	Lst_DoneFree(&targCmds);
   2970  1.469    rillig 	assert(targets == NULL);
   2971  1.469    rillig 	SearchPath_Free(defSysIncPath);
   2972  1.469    rillig 	SearchPath_Free(sysIncPath);
   2973  1.469    rillig 	SearchPath_Free(parseIncPath);
   2974  1.469    rillig 	assert(includes.len == 0);
   2975  1.469    rillig 	Vector_Done(&includes);
   2976  1.700    rillig 	HashIter_Init(&hi, &guards);
   2977  1.702    rillig 	while (HashIter_Next(&hi) != NULL) {
   2978  1.702    rillig 		Guard *guard = hi.entry->value;
   2979  1.702    rillig 		free(guard->name);
   2980  1.702    rillig 		free(guard);
   2981  1.702    rillig 	}
   2982  1.700    rillig 	HashTable_Done(&guards);
   2983   1.45   mycroft #endif
   2984    1.9       jtc }
   2985   1.27  christos 
   2986    1.1       cgd 
   2987  1.697    rillig /* Populate the list with the single main target to create, or error out. */
   2988  1.461    rillig void
   2989  1.461    rillig Parse_MainName(GNodeList *mainList)
   2990    1.1       cgd {
   2991  1.469    rillig 	if (mainNode == NULL)
   2992  1.469    rillig 		Punt("no target to make.");
   2993  1.430    rillig 
   2994  1.527    rillig 	Lst_Append(mainList, mainNode);
   2995  1.527    rillig 	if (mainNode->type & OP_DOUBLEDEP)
   2996  1.469    rillig 		Lst_AppendAll(mainList, &mainNode->cohorts);
   2997  1.441    rillig 
   2998  1.542    rillig 	Global_Append(".TARGETS", mainNode->name);
   2999   1.59  christos }
   3000  1.420    rillig 
   3001  1.420    rillig int
   3002  1.561    rillig Parse_NumErrors(void)
   3003  1.420    rillig {
   3004  1.561    rillig 	return parseErrors;
   3005  1.420    rillig }
   3006