Home | History | Annotate | Line # | Download | only in make
parse.c revision 1.324
      1  1.324    rillig /*	$NetBSD: parse.c,v 1.324 2020/09/24 07:11:29 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.1       cgd /*-
     72    1.1       cgd  * parse.c --
     73    1.1       cgd  *	Functions to parse a makefile.
     74    1.1       cgd  *
     75    1.1       cgd  *	One function, Parse_Init, must be called before any functions
     76    1.1       cgd  *	in this module are used. After that, the function Parse_File is the
     77    1.1       cgd  *	main entry point and controls most of the other functions in this
     78    1.1       cgd  *	module.
     79    1.1       cgd  *
     80    1.1       cgd  *	Most important structures are kept in Lsts. Directories for
     81  1.123       dsl  *	the .include "..." function are kept in the 'parseIncPath' Lst, while
     82  1.123       dsl  *	those for the .include <...> are kept in the 'sysIncPath' Lst. The
     83    1.1       cgd  *	targets currently being defined are kept in the 'targets' Lst.
     84    1.1       cgd  *
     85    1.1       cgd  *	The variables 'fname' and 'lineno' are used to track the name
     86    1.1       cgd  *	of the current file and the line number in that file so that error
     87    1.1       cgd  *	messages can be more meaningful.
     88    1.1       cgd  *
     89    1.1       cgd  * Interface:
     90    1.1       cgd  *	Parse_Init	    	    Initialization function which must be
     91    1.1       cgd  *	    	  	    	    called before anything else in this module
     92    1.1       cgd  *	    	  	    	    is used.
     93    1.1       cgd  *
     94    1.9       jtc  *	Parse_End		    Cleanup the module
     95    1.9       jtc  *
     96    1.1       cgd  *	Parse_File	    	    Function used to parse a makefile. It must
     97    1.1       cgd  *	    	  	    	    be given the name of the file, which should
     98    1.1       cgd  *	    	  	    	    already have been opened, and a function
     99    1.1       cgd  *	    	  	    	    to call to read a character from the file.
    100    1.1       cgd  *
    101    1.1       cgd  *	Parse_IsVar	    	    Returns TRUE if the given line is a
    102    1.1       cgd  *	    	  	    	    variable assignment. Used by MainParseArgs
    103    1.1       cgd  *	    	  	    	    to determine if an argument is a target
    104    1.1       cgd  *	    	  	    	    or a variable assignment. Used internally
    105    1.1       cgd  *	    	  	    	    for pretty much the same thing...
    106    1.1       cgd  *
    107    1.1       cgd  *	Parse_Error	    	    Function called when an error occurs in
    108    1.1       cgd  *	    	  	    	    parsing. Used by the variable and
    109    1.1       cgd  *	    	  	    	    conditional modules.
    110    1.1       cgd  *	Parse_MainName	    	    Returns a Lst of the main target to create.
    111    1.1       cgd  */
    112    1.1       cgd 
    113  1.170  dholland #include <sys/types.h>
    114  1.170  dholland #include <sys/mman.h>
    115  1.171  dholland #include <sys/stat.h>
    116   1.84       wiz #include <errno.h>
    117    1.5       cgd #include <stdarg.h>
    118    1.5       cgd #include <stdio.h>
    119  1.225      maya #include <stdint.h>
    120   1.84       wiz 
    121  1.177  nakayama #ifndef MAP_FILE
    122  1.177  nakayama #define MAP_FILE 0
    123  1.177  nakayama #endif
    124  1.170  dholland #ifndef MAP_COPY
    125  1.170  dholland #define MAP_COPY MAP_PRIVATE
    126  1.170  dholland #endif
    127  1.170  dholland 
    128    1.1       cgd #include "make.h"
    129    1.5       cgd #include "dir.h"
    130    1.5       cgd #include "job.h"
    131    1.1       cgd #include "pathnames.h"
    132    1.1       cgd 
    133  1.303    rillig /*	"@(#)parse.c	8.3 (Berkeley) 3/19/94"	*/
    134  1.324    rillig MAKE_RCSID("$NetBSD: parse.c,v 1.324 2020/09/24 07:11:29 rillig Exp $");
    135  1.303    rillig 
    136  1.248    rillig /* types and constants */
    137  1.166  dholland 
    138    1.1       cgd /*
    139  1.166  dholland  * Structure for a file being read ("included file")
    140    1.1       cgd  */
    141    1.1       cgd typedef struct IFile {
    142  1.189       sjg     char      	    *fname;         /* name of file */
    143  1.281    rillig     Boolean         fromForLoop;    /* simulated .include by the .for loop */
    144  1.155       dsl     int             lineno;         /* current line number in file */
    145  1.155       dsl     int             first_lineno;   /* line number of start of text */
    146  1.155       dsl     int             cond_depth;     /* 'if' nesting when file opened */
    147  1.210       sjg     Boolean         depending;      /* state of doing_depend on EOF */
    148  1.123       dsl     char            *P_str;         /* point to base of string buffer */
    149  1.123       dsl     char            *P_ptr;         /* point to next char of string buffer */
    150  1.125       dsl     char            *P_end;         /* point to the end of string buffer */
    151  1.170  dholland     char            *(*nextbuf)(void *, size_t *); /* Function to get more data */
    152  1.155       dsl     void            *nextbuf_arg;   /* Opaque arg for nextbuf() */
    153  1.170  dholland     struct loadedfile *lf;          /* loadedfile object, if any */
    154    1.5       cgd } IFile;
    155    1.1       cgd 
    156   1.82   reinoud 
    157   1.82   reinoud /*
    158  1.166  dholland  * These values are returned by ParseEOF to tell Parse_File whether to
    159  1.166  dholland  * CONTINUE parsing, i.e. it had only reached the end of an include file,
    160  1.166  dholland  * or if it's DONE.
    161   1.82   reinoud  */
    162  1.166  dholland #define CONTINUE	1
    163  1.166  dholland #define DONE		0
    164   1.82   reinoud 
    165  1.166  dholland /*
    166  1.166  dholland  * Tokens for target attributes
    167    1.1       cgd  */
    168    1.1       cgd typedef enum {
    169    1.1       cgd     Begin,  	    /* .BEGIN */
    170    1.1       cgd     Default,	    /* .DEFAULT */
    171  1.215  dholland     DeleteOnError,  /* .DELETE_ON_ERROR */
    172    1.1       cgd     End,    	    /* .END */
    173  1.162       sjg     dotError,	    /* .ERROR */
    174    1.1       cgd     Ignore,	    /* .IGNORE */
    175    1.1       cgd     Includes,	    /* .INCLUDES */
    176    1.1       cgd     Interrupt,	    /* .INTERRUPT */
    177    1.1       cgd     Libs,	    /* .LIBS */
    178  1.165       sjg     Meta,	    /* .META */
    179    1.1       cgd     MFlags,	    /* .MFLAGS or .MAKEFLAGS */
    180    1.1       cgd     Main,	    /* .MAIN and we don't have anything user-specified to
    181    1.1       cgd 		     * make */
    182    1.5       cgd     NoExport,	    /* .NOEXPORT */
    183  1.165       sjg     NoMeta,	    /* .NOMETA */
    184  1.165       sjg     NoMetaCmp,	    /* .NOMETA_CMP */
    185   1.32       gwr     NoPath,	    /* .NOPATH */
    186    1.1       cgd     Not,	    /* Not special */
    187   1.75        tv     NotParallel,    /* .NOTPARALLEL */
    188    1.1       cgd     Null,   	    /* .NULL */
    189   1.75        tv     ExObjdir,	    /* .OBJDIR */
    190    1.1       cgd     Order,  	    /* .ORDER */
    191   1.18  christos     Parallel,	    /* .PARALLEL */
    192    1.5       cgd     ExPath,	    /* .PATH */
    193   1.22  christos     Phony,	    /* .PHONY */
    194   1.48       sjg #ifdef POSIX
    195   1.48       sjg     Posix,	    /* .POSIX */
    196   1.48       sjg #endif
    197    1.1       cgd     Precious,	    /* .PRECIOUS */
    198    1.5       cgd     ExShell,	    /* .SHELL */
    199    1.1       cgd     Silent,	    /* .SILENT */
    200    1.1       cgd     SingleShell,    /* .SINGLESHELL */
    201  1.187  christos     Stale,	    /* .STALE */
    202    1.1       cgd     Suffixes,	    /* .SUFFIXES */
    203   1.18  christos     Wait,	    /* .WAIT */
    204    1.5       cgd     Attribute	    /* Generic attribute */
    205    1.1       cgd } ParseSpecial;
    206    1.1       cgd 
    207  1.248    rillig /* result data */
    208  1.166  dholland 
    209  1.166  dholland /*
    210  1.166  dholland  * The main target to create. This is the first target on the first
    211  1.166  dholland  * dependency line in the first makefile.
    212  1.166  dholland  */
    213  1.166  dholland static GNode *mainNode;
    214  1.166  dholland 
    215  1.248    rillig /* eval state */
    216  1.166  dholland 
    217  1.318    rillig /* During parsing, the targets from the previous dependency line.
    218  1.318    rillig  *
    219  1.318    rillig  * See unit-tests/deptgt.mk, keyword "parse.c:targets". */
    220  1.322    rillig static GNodeList *targets;
    221  1.166  dholland 
    222  1.166  dholland #ifdef CLEANUP
    223  1.166  dholland /* command lines for targets */
    224  1.322    rillig static StringList *targCmds;
    225  1.166  dholland #endif
    226  1.166  dholland 
    227  1.166  dholland /*
    228  1.152       dsl  * Predecessor node for handling .ORDER. Initialized to NULL when .ORDER
    229    1.1       cgd  * seen, then set to each successive source on the line.
    230    1.1       cgd  */
    231    1.1       cgd static GNode	*predecessor;
    232    1.1       cgd 
    233  1.248    rillig /* parser state */
    234  1.166  dholland 
    235  1.166  dholland /* true if currently in a dependency line or its commands */
    236  1.166  dholland static Boolean inLine;
    237  1.166  dholland 
    238  1.166  dholland /* number of fatal errors */
    239  1.166  dholland static int fatals = 0;
    240  1.166  dholland 
    241  1.166  dholland /*
    242  1.166  dholland  * Variables for doing includes
    243  1.166  dholland  */
    244  1.166  dholland 
    245  1.166  dholland /* current file being read */
    246  1.166  dholland static IFile *curFile;
    247  1.166  dholland 
    248  1.319    rillig /* The include chain of makefiles that leads to curFile.  At the bottom of
    249  1.319    rillig  * the stack is the top-level makefile from the command line, and on top of
    250  1.319    rillig  * this file, there are the included files or .for loops, up to but excluding
    251  1.319    rillig  * curFile.
    252  1.319    rillig  *
    253  1.319    rillig  * This data could be used to print stack traces on parse errors.  As of
    254  1.319    rillig  * 2020-09-14, this is not done though.  It seems quite simple to print the
    255  1.319    rillig  * tuples (fname:lineno:fromForLoop), from top to bottom.  This simple idea is
    256  1.319    rillig  * made complicated by the fact that the .for loops also use this stack for
    257  1.319    rillig  * storing information.
    258  1.319    rillig  *
    259  1.319    rillig  * The lineno fields of the IFiles with fromForLoop == TRUE look confusing,
    260  1.319    rillig  * which is demonstrated by the test 'include-main.mk'.  They seem sorted
    261  1.319    rillig  * backwards since they tell the number of completely parsed lines, which for
    262  1.319    rillig  * a .for loop is right after the terminating .endfor.  To compensate for this
    263  1.319    rillig  * confusion, there is another field first_lineno pointing at the start of the
    264  1.319    rillig  * .for loop, 1-based for human consumption.
    265  1.319    rillig  *
    266  1.319    rillig  * To make the stack trace intuitive, the entry below the first .for loop must
    267  1.319    rillig  * be ignored completely since neither its lineno nor its first_lineno is
    268  1.319    rillig  * useful.  Instead, the topmost .for loop needs to be printed twice, once
    269  1.319    rillig  * with its first_lineno and once with its lineno.
    270  1.319    rillig  *
    271  1.319    rillig  * As of 2020-09-15, using the above rules, the stack trace for the .info line
    272  1.319    rillig  * in include-subsub.mk would be:
    273  1.319    rillig  *
    274  1.319    rillig  *	curFile:	include-subsub.mk:4
    275  1.319    rillig  *			(lineno, from an .include)
    276  1.319    rillig  *	includes[4]:	include-sub.mk:32
    277  1.319    rillig  *			(lineno, from a .for loop below an .include)
    278  1.319    rillig  *	includes[4]:	include-sub.mk:31
    279  1.319    rillig  *			(first_lineno, from a .for loop, lineno == 32)
    280  1.319    rillig  *	includes[3]:	include-sub.mk:30
    281  1.319    rillig  *			(first_lineno, from a .for loop, lineno == 33)
    282  1.319    rillig  *	includes[2]:	include-sub.mk:29
    283  1.319    rillig  *			(first_lineno, from a .for loop, lineno == 34)
    284  1.319    rillig  *	includes[1]:	include-sub.mk:35
    285  1.319    rillig  *			(not printed since it is below a .for loop)
    286  1.319    rillig  *	includes[0]:	include-main.mk:27
    287  1.319    rillig  */
    288  1.276    rillig static Stack /* of *IFile */ includes;
    289  1.166  dholland 
    290  1.166  dholland /* include paths (lists of directories) */
    291  1.322    rillig SearchPath *parseIncPath;	/* dirs for "..." includes */
    292  1.322    rillig SearchPath *sysIncPath;		/* dirs for <...> includes */
    293  1.322    rillig SearchPath *defIncPath;		/* default for sysIncPath */
    294  1.166  dholland 
    295  1.248    rillig /* parser tables */
    296  1.166  dholland 
    297    1.1       cgd /*
    298    1.1       cgd  * The parseKeywords table is searched using binary search when deciding
    299    1.1       cgd  * if a target or source is special. The 'spec' field is the ParseSpecial
    300    1.1       cgd  * type of the keyword ("Not" if the keyword isn't special as a target) while
    301    1.1       cgd  * the 'op' field is the operator to apply to the list of targets if the
    302    1.1       cgd  * keyword is used as a source ("0" if the keyword isn't special as a source)
    303    1.1       cgd  */
    304  1.168  dholland static const struct {
    305   1.93  christos     const char   *name;    	/* Name of keyword */
    306    1.1       cgd     ParseSpecial  spec;	    	/* Type when used as a target */
    307  1.312    rillig     GNodeType	  op;	    	/* Operator when used as a source */
    308    1.1       cgd } parseKeywords[] = {
    309    1.1       cgd { ".BEGIN", 	  Begin,    	0 },
    310    1.1       cgd { ".DEFAULT",	  Default,  	0 },
    311  1.215  dholland { ".DELETE_ON_ERROR", DeleteOnError, 0 },
    312    1.1       cgd { ".END",   	  End,	    	0 },
    313  1.162       sjg { ".ERROR",   	  dotError,    	0 },
    314    1.1       cgd { ".EXEC",	  Attribute,   	OP_EXEC },
    315    1.1       cgd { ".IGNORE",	  Ignore,   	OP_IGNORE },
    316    1.1       cgd { ".INCLUDES",	  Includes, 	0 },
    317    1.1       cgd { ".INTERRUPT",	  Interrupt,	0 },
    318    1.1       cgd { ".INVISIBLE",	  Attribute,   	OP_INVISIBLE },
    319    1.1       cgd { ".JOIN",  	  Attribute,   	OP_JOIN },
    320    1.1       cgd { ".LIBS",  	  Libs,	    	0 },
    321   1.29  christos { ".MADE",	  Attribute,	OP_MADE },
    322    1.1       cgd { ".MAIN",	  Main,		0 },
    323    1.1       cgd { ".MAKE",  	  Attribute,   	OP_MAKE },
    324    1.1       cgd { ".MAKEFLAGS",	  MFlags,   	0 },
    325  1.165       sjg { ".META",	  Meta,		OP_META },
    326    1.1       cgd { ".MFLAGS",	  MFlags,   	0 },
    327  1.165       sjg { ".NOMETA",	  NoMeta,	OP_NOMETA },
    328  1.165       sjg { ".NOMETA_CMP",  NoMetaCmp,	OP_NOMETA_CMP },
    329   1.32       gwr { ".NOPATH",	  NoPath,	OP_NOPATH },
    330    1.1       cgd { ".NOTMAIN",	  Attribute,   	OP_NOTMAIN },
    331    1.1       cgd { ".NOTPARALLEL", NotParallel,	0 },
    332   1.18  christos { ".NO_PARALLEL", NotParallel,	0 },
    333    1.1       cgd { ".NULL",  	  Null,	    	0 },
    334   1.75        tv { ".OBJDIR",	  ExObjdir,	0 },
    335   1.14        ws { ".OPTIONAL",	  Attribute,   	OP_OPTIONAL },
    336    1.1       cgd { ".ORDER", 	  Order,    	0 },
    337   1.18  christos { ".PARALLEL",	  Parallel,	0 },
    338    1.5       cgd { ".PATH",	  ExPath,	0 },
    339   1.22  christos { ".PHONY",	  Phony,	OP_PHONY },
    340   1.48       sjg #ifdef POSIX
    341   1.48       sjg { ".POSIX",	  Posix,	0 },
    342   1.48       sjg #endif
    343    1.1       cgd { ".PRECIOUS",	  Precious, 	OP_PRECIOUS },
    344    1.1       cgd { ".RECURSIVE",	  Attribute,	OP_MAKE },
    345    1.5       cgd { ".SHELL", 	  ExShell,    	0 },
    346    1.1       cgd { ".SILENT",	  Silent,   	OP_SILENT },
    347    1.1       cgd { ".SINGLESHELL", SingleShell,	0 },
    348  1.187  christos { ".STALE",	  Stale,	0 },
    349    1.1       cgd { ".SUFFIXES",	  Suffixes, 	0 },
    350    1.1       cgd { ".USE",   	  Attribute,   	OP_USE },
    351   1.71  christos { ".USEBEFORE",   Attribute,   	OP_USEBEFORE },
    352   1.18  christos { ".WAIT",	  Wait, 	0 },
    353    1.1       cgd };
    354    1.1       cgd 
    355  1.248    rillig /* file loader */
    356  1.170  dholland 
    357  1.170  dholland struct loadedfile {
    358  1.170  dholland 	const char *path;		/* name, for error reports */
    359  1.170  dholland 	char *buf;			/* contents buffer */
    360  1.170  dholland 	size_t len;			/* length of contents */
    361  1.170  dholland 	size_t maplen;			/* length of mmap area, or 0 */
    362  1.170  dholland 	Boolean used;			/* XXX: have we used the data yet */
    363  1.170  dholland };
    364  1.170  dholland 
    365  1.170  dholland static struct loadedfile *
    366  1.170  dholland loadedfile_create(const char *path)
    367  1.170  dholland {
    368  1.170  dholland 	struct loadedfile *lf;
    369  1.170  dholland 
    370  1.170  dholland 	lf = bmake_malloc(sizeof(*lf));
    371  1.242    rillig 	lf->path = path == NULL ? "(stdin)" : path;
    372  1.170  dholland 	lf->buf = NULL;
    373  1.170  dholland 	lf->len = 0;
    374  1.170  dholland 	lf->maplen = 0;
    375  1.170  dholland 	lf->used = FALSE;
    376  1.170  dholland 	return lf;
    377  1.170  dholland }
    378  1.170  dholland 
    379  1.170  dholland static void
    380  1.170  dholland loadedfile_destroy(struct loadedfile *lf)
    381  1.170  dholland {
    382  1.170  dholland 	if (lf->buf != NULL) {
    383  1.170  dholland 		if (lf->maplen > 0) {
    384  1.170  dholland 			munmap(lf->buf, lf->maplen);
    385  1.170  dholland 		} else {
    386  1.170  dholland 			free(lf->buf);
    387  1.170  dholland 		}
    388  1.170  dholland 	}
    389  1.170  dholland 	free(lf);
    390  1.170  dholland }
    391  1.170  dholland 
    392  1.170  dholland /*
    393  1.170  dholland  * nextbuf() operation for loadedfile, as needed by the weird and twisted
    394  1.170  dholland  * logic below. Once that's cleaned up, we can get rid of lf->used...
    395  1.170  dholland  */
    396  1.170  dholland static char *
    397  1.170  dholland loadedfile_nextbuf(void *x, size_t *len)
    398  1.170  dholland {
    399  1.170  dholland 	struct loadedfile *lf = x;
    400  1.170  dholland 
    401  1.170  dholland 	if (lf->used) {
    402  1.170  dholland 		return NULL;
    403  1.170  dholland 	}
    404  1.170  dholland 	lf->used = TRUE;
    405  1.170  dholland 	*len = lf->len;
    406  1.170  dholland 	return lf->buf;
    407  1.170  dholland }
    408  1.170  dholland 
    409  1.170  dholland /*
    410  1.170  dholland  * Try to get the size of a file.
    411  1.170  dholland  */
    412  1.272    rillig static Boolean
    413  1.170  dholland load_getsize(int fd, size_t *ret)
    414  1.170  dholland {
    415  1.170  dholland 	struct stat st;
    416  1.170  dholland 
    417  1.170  dholland 	if (fstat(fd, &st) < 0) {
    418  1.272    rillig 		return FALSE;
    419  1.170  dholland 	}
    420  1.170  dholland 
    421  1.170  dholland 	if (!S_ISREG(st.st_mode)) {
    422  1.272    rillig 		return FALSE;
    423  1.170  dholland 	}
    424  1.170  dholland 
    425  1.170  dholland 	/*
    426  1.170  dholland 	 * st_size is an off_t, which is 64 bits signed; *ret is
    427  1.170  dholland 	 * size_t, which might be 32 bits unsigned or 64 bits
    428  1.170  dholland 	 * unsigned. Rather than being elaborate, just punt on
    429  1.170  dholland 	 * files that are more than 2^31 bytes. We should never
    430  1.170  dholland 	 * see a makefile that size in practice...
    431  1.170  dholland 	 *
    432  1.170  dholland 	 * While we're at it reject negative sizes too, just in case.
    433  1.170  dholland 	 */
    434  1.170  dholland 	if (st.st_size < 0 || st.st_size > 0x7fffffff) {
    435  1.272    rillig 		return FALSE;
    436  1.170  dholland 	}
    437  1.170  dholland 
    438  1.170  dholland 	*ret = (size_t) st.st_size;
    439  1.272    rillig 	return TRUE;
    440  1.170  dholland }
    441  1.170  dholland 
    442  1.170  dholland /*
    443  1.170  dholland  * Read in a file.
    444  1.170  dholland  *
    445  1.170  dholland  * Until the path search logic can be moved under here instead of
    446  1.170  dholland  * being in the caller in another source file, we need to have the fd
    447  1.170  dholland  * passed in already open. Bleh.
    448  1.170  dholland  *
    449  1.170  dholland  * If the path is NULL use stdin and (to insure against fd leaks)
    450  1.170  dholland  * assert that the caller passed in -1.
    451  1.170  dholland  */
    452  1.170  dholland static struct loadedfile *
    453  1.170  dholland loadfile(const char *path, int fd)
    454  1.170  dholland {
    455  1.170  dholland 	struct loadedfile *lf;
    456  1.227       sjg 	static long pagesize = 0;
    457  1.170  dholland 	ssize_t result;
    458  1.170  dholland 	size_t bufpos;
    459  1.170  dholland 
    460  1.170  dholland 	lf = loadedfile_create(path);
    461  1.170  dholland 
    462  1.170  dholland 	if (path == NULL) {
    463  1.170  dholland 		assert(fd == -1);
    464  1.170  dholland 		fd = STDIN_FILENO;
    465  1.170  dholland 	} else {
    466  1.170  dholland #if 0 /* notyet */
    467  1.170  dholland 		fd = open(path, O_RDONLY);
    468  1.170  dholland 		if (fd < 0) {
    469  1.170  dholland 			...
    470  1.170  dholland 			Error("%s: %s", path, strerror(errno));
    471  1.170  dholland 			exit(1);
    472  1.170  dholland 		}
    473  1.170  dholland #endif
    474  1.170  dholland 	}
    475  1.170  dholland 
    476  1.272    rillig 	if (load_getsize(fd, &lf->len)) {
    477  1.170  dholland 		/* found a size, try mmap */
    478  1.227       sjg 		if (pagesize == 0)
    479  1.227       sjg 			pagesize = sysconf(_SC_PAGESIZE);
    480  1.170  dholland 		if (pagesize <= 0) {
    481  1.170  dholland 			pagesize = 0x1000;
    482  1.170  dholland 		}
    483  1.170  dholland 		/* round size up to a page */
    484  1.170  dholland 		lf->maplen = pagesize * ((lf->len + pagesize - 1)/pagesize);
    485  1.170  dholland 
    486  1.170  dholland 		/*
    487  1.170  dholland 		 * XXX hack for dealing with empty files; remove when
    488  1.170  dholland 		 * we're no longer limited by interfacing to the old
    489  1.170  dholland 		 * logic elsewhere in this file.
    490  1.170  dholland 		 */
    491  1.170  dholland 		if (lf->maplen == 0) {
    492  1.170  dholland 			lf->maplen = pagesize;
    493  1.170  dholland 		}
    494  1.170  dholland 
    495  1.170  dholland 		/*
    496  1.170  dholland 		 * FUTURE: remove PROT_WRITE when the parser no longer
    497  1.170  dholland 		 * needs to scribble on the input.
    498  1.170  dholland 		 */
    499  1.170  dholland 		lf->buf = mmap(NULL, lf->maplen, PROT_READ|PROT_WRITE,
    500  1.170  dholland 			       MAP_FILE|MAP_COPY, fd, 0);
    501  1.170  dholland 		if (lf->buf != MAP_FAILED) {
    502  1.170  dholland 			/* succeeded */
    503  1.178       dsl 			if (lf->len == lf->maplen && lf->buf[lf->len - 1] != '\n') {
    504  1.220      maya 				char *b = bmake_malloc(lf->len + 1);
    505  1.178       dsl 				b[lf->len] = '\n';
    506  1.178       dsl 				memcpy(b, lf->buf, lf->len++);
    507  1.178       dsl 				munmap(lf->buf, lf->maplen);
    508  1.178       dsl 				lf->maplen = 0;
    509  1.178       dsl 				lf->buf = b;
    510  1.178       dsl 			}
    511  1.170  dholland 			goto done;
    512  1.170  dholland 		}
    513  1.170  dholland 	}
    514  1.170  dholland 
    515  1.170  dholland 	/* cannot mmap; load the traditional way */
    516  1.170  dholland 
    517  1.170  dholland 	lf->maplen = 0;
    518  1.170  dholland 	lf->len = 1024;
    519  1.170  dholland 	lf->buf = bmake_malloc(lf->len);
    520  1.170  dholland 
    521  1.170  dholland 	bufpos = 0;
    522  1.170  dholland 	while (1) {
    523  1.170  dholland 		assert(bufpos <= lf->len);
    524  1.170  dholland 		if (bufpos == lf->len) {
    525  1.221  riastrad 			if (lf->len > SIZE_MAX/2) {
    526  1.221  riastrad 				errno = EFBIG;
    527  1.221  riastrad 				Error("%s: file too large", path);
    528  1.221  riastrad 				exit(1);
    529  1.221  riastrad 			}
    530  1.170  dholland 			lf->len *= 2;
    531  1.170  dholland 			lf->buf = bmake_realloc(lf->buf, lf->len);
    532  1.170  dholland 		}
    533  1.221  riastrad 		assert(bufpos < lf->len);
    534  1.170  dholland 		result = read(fd, lf->buf + bufpos, lf->len - bufpos);
    535  1.170  dholland 		if (result < 0) {
    536  1.170  dholland 			Error("%s: read error: %s", path, strerror(errno));
    537  1.170  dholland 			exit(1);
    538  1.170  dholland 		}
    539  1.170  dholland 		if (result == 0) {
    540  1.170  dholland 			break;
    541  1.170  dholland 		}
    542  1.170  dholland 		bufpos += result;
    543  1.170  dholland 	}
    544  1.170  dholland 	assert(bufpos <= lf->len);
    545  1.173  dholland 	lf->len = bufpos;
    546  1.170  dholland 
    547  1.170  dholland 	/* truncate malloc region to actual length (maybe not useful) */
    548  1.172  dholland 	if (lf->len > 0) {
    549  1.218       sjg 		/* as for mmap case, ensure trailing \n */
    550  1.218       sjg 		if (lf->buf[lf->len - 1] != '\n')
    551  1.218       sjg 			lf->len++;
    552  1.172  dholland 		lf->buf = bmake_realloc(lf->buf, lf->len);
    553  1.218       sjg 		lf->buf[lf->len - 1] = '\n';
    554  1.172  dholland 	}
    555  1.170  dholland 
    556  1.170  dholland done:
    557  1.170  dholland 	if (path != NULL) {
    558  1.170  dholland 		close(fd);
    559  1.170  dholland 	}
    560  1.170  dholland 	return lf;
    561  1.170  dholland }
    562  1.170  dholland 
    563  1.248    rillig /* old code */
    564   1.77  christos 
    565  1.279    rillig /* Check if the current character is escaped on the current line. */
    566  1.279    rillig static Boolean
    567   1.84       wiz ParseIsEscaped(const char *line, const char *c)
    568   1.77  christos {
    569  1.280    rillig     Boolean active = FALSE;
    570   1.77  christos     for (;;) {
    571   1.77  christos 	if (line == c)
    572   1.77  christos 	    return active;
    573   1.77  christos 	if (*--c != '\\')
    574   1.77  christos 	    return active;
    575   1.77  christos 	active = !active;
    576   1.77  christos     }
    577   1.77  christos }
    578   1.77  christos 
    579  1.278    rillig /* Add the filename and lineno to the GNode so that we remember where it
    580  1.278    rillig  * was first defined. */
    581  1.278    rillig static void
    582  1.278    rillig ParseMark(GNode *gn)
    583  1.278    rillig {
    584  1.278    rillig     gn->fname = curFile->fname;
    585  1.278    rillig     gn->lineno = curFile->lineno;
    586  1.278    rillig }
    587  1.278    rillig 
    588    1.1       cgd /*-
    589    1.1       cgd  *----------------------------------------------------------------------
    590    1.1       cgd  * ParseFindKeyword --
    591    1.1       cgd  *	Look in the table of keywords for one matching the given string.
    592    1.1       cgd  *
    593   1.84       wiz  * Input:
    594   1.84       wiz  *	str		String to find
    595   1.84       wiz  *
    596    1.1       cgd  * Results:
    597    1.1       cgd  *	The index of the keyword, or -1 if it isn't there.
    598    1.1       cgd  *
    599    1.1       cgd  * Side Effects:
    600    1.1       cgd  *	None
    601    1.1       cgd  *----------------------------------------------------------------------
    602    1.1       cgd  */
    603    1.1       cgd static int
    604  1.120       dsl ParseFindKeyword(const char *str)
    605    1.1       cgd {
    606   1.84       wiz     int    start, end, cur;
    607   1.84       wiz     int    diff;
    608   1.27  christos 
    609    1.1       cgd     start = 0;
    610    1.1       cgd     end = (sizeof(parseKeywords)/sizeof(parseKeywords[0])) - 1;
    611    1.1       cgd 
    612    1.1       cgd     do {
    613    1.1       cgd 	cur = start + ((end - start) / 2);
    614  1.103  christos 	diff = strcmp(str, parseKeywords[cur].name);
    615    1.1       cgd 
    616    1.1       cgd 	if (diff == 0) {
    617  1.235    rillig 	    return cur;
    618    1.1       cgd 	} else if (diff < 0) {
    619    1.1       cgd 	    end = cur - 1;
    620    1.1       cgd 	} else {
    621    1.1       cgd 	    start = cur + 1;
    622    1.1       cgd 	}
    623    1.1       cgd     } while (start <= end);
    624  1.235    rillig     return -1;
    625    1.1       cgd }
    626    1.1       cgd 
    627  1.291    rillig static void
    628  1.305    rillig PrintLocation(FILE *f, const char *filename, size_t lineno)
    629  1.291    rillig {
    630  1.291    rillig 	char dirbuf[MAXPATHLEN+1];
    631  1.305    rillig 	const char *dir, *base;
    632  1.305    rillig 	char *dir_freeIt, *base_freeIt;
    633  1.291    rillig 
    634  1.305    rillig 	if (*filename == '/' || strcmp(filename, "(stdin)") == 0) {
    635  1.305    rillig 		(void)fprintf(f, "\"%s\" line %zu: ", filename, lineno);
    636  1.299    rillig 		return;
    637  1.299    rillig 	}
    638  1.291    rillig 
    639  1.299    rillig 	/* Find out which makefile is the culprit.
    640  1.299    rillig 	 * We try ${.PARSEDIR} and apply realpath(3) if not absolute. */
    641  1.291    rillig 
    642  1.299    rillig 	dir = Var_Value(".PARSEDIR", VAR_GLOBAL, &dir_freeIt);
    643  1.299    rillig 	if (dir == NULL)
    644  1.299    rillig 		dir = ".";
    645  1.299    rillig 	if (*dir != '/')
    646  1.299    rillig 		dir = realpath(dir, dirbuf);
    647  1.299    rillig 
    648  1.305    rillig 	base = Var_Value(".PARSEFILE", VAR_GLOBAL, &base_freeIt);
    649  1.305    rillig 	if (base == NULL) {
    650  1.305    rillig 		const char *slash = strrchr(filename, '/');
    651  1.305    rillig 		base = slash != NULL ? slash + 1 : filename;
    652  1.299    rillig 	}
    653  1.299    rillig 
    654  1.305    rillig 	(void)fprintf(f, "\"%s/%s\" line %zu: ", dir, base, lineno);
    655  1.305    rillig 	bmake_free(base_freeIt);
    656  1.299    rillig 	bmake_free(dir_freeIt);
    657  1.291    rillig }
    658  1.291    rillig 
    659  1.300    rillig /* Print a parse error message, including location information.
    660    1.1       cgd  *
    661  1.300    rillig  * Increment "fatals" if the level is PARSE_FATAL, and continue parsing
    662  1.300    rillig  * until the end of the current top-level makefile, then exit (see
    663  1.300    rillig  * Parse_File).
    664    1.1       cgd  */
    665   1.38  christos static void
    666  1.127       dsl ParseVErrorInternal(FILE *f, const char *cfname, size_t clineno, int type,
    667  1.122       dsl     const char *fmt, va_list ap)
    668   1.38  christos {
    669   1.56  christos 	static Boolean fatal_warning_error_printed = FALSE;
    670   1.56  christos 
    671  1.148       sjg 	(void)fprintf(f, "%s: ", progname);
    672   1.63  christos 
    673  1.291    rillig 	if (cfname != NULL)
    674  1.291    rillig 		PrintLocation(f, cfname, clineno);
    675   1.38  christos 	if (type == PARSE_WARNING)
    676  1.127       dsl 		(void)fprintf(f, "warning: ");
    677  1.127       dsl 	(void)vfprintf(f, fmt, ap);
    678  1.127       dsl 	(void)fprintf(f, "\n");
    679  1.127       dsl 	(void)fflush(f);
    680  1.300    rillig 
    681  1.226       sjg 	if (type == PARSE_INFO)
    682  1.226       sjg 		return;
    683   1.56  christos 	if (type == PARSE_FATAL || parseWarnFatal)
    684  1.300    rillig 		fatals++;
    685   1.56  christos 	if (parseWarnFatal && !fatal_warning_error_printed) {
    686   1.56  christos 		Error("parsing warnings being treated as errors");
    687   1.56  christos 		fatal_warning_error_printed = TRUE;
    688   1.56  christos 	}
    689   1.38  christos }
    690   1.38  christos 
    691  1.203     joerg static void
    692  1.203     joerg ParseErrorInternal(const char *cfname, size_t clineno, int type,
    693  1.203     joerg     const char *fmt, ...)
    694  1.203     joerg {
    695  1.203     joerg 	va_list ap;
    696  1.203     joerg 
    697  1.203     joerg 	va_start(ap, fmt);
    698  1.203     joerg 	(void)fflush(stdout);
    699  1.203     joerg 	ParseVErrorInternal(stderr, cfname, clineno, type, fmt, ap);
    700  1.203     joerg 	va_end(ap);
    701  1.203     joerg 
    702  1.203     joerg 	if (debug_file != stderr && debug_file != stdout) {
    703  1.203     joerg 		va_start(ap, fmt);
    704  1.203     joerg 		ParseVErrorInternal(debug_file, cfname, clineno, type, fmt, ap);
    705  1.203     joerg 		va_end(ap);
    706  1.203     joerg 	}
    707  1.203     joerg }
    708  1.203     joerg 
    709  1.289    rillig /* External interface to ParseErrorInternal; uses the default filename and
    710  1.289    rillig  * line number.
    711   1.38  christos  *
    712  1.289    rillig  * Fmt is given without a trailing newline. */
    713    1.1       cgd void
    714   1.93  christos Parse_Error(int type, const char *fmt, ...)
    715    1.1       cgd {
    716    1.1       cgd 	va_list ap;
    717  1.156       dsl 	const char *fname;
    718  1.156       dsl 	size_t lineno;
    719   1.84       wiz 
    720  1.152       dsl 	if (curFile == NULL) {
    721  1.156       dsl 		fname = NULL;
    722  1.156       dsl 		lineno = 0;
    723  1.156       dsl 	} else {
    724  1.156       dsl 		fname = curFile->fname;
    725  1.156       dsl 		lineno = curFile->lineno;
    726  1.148       sjg 	}
    727  1.156       dsl 
    728  1.156       dsl 	va_start(ap, fmt);
    729  1.163       sjg 	(void)fflush(stdout);
    730  1.156       dsl 	ParseVErrorInternal(stderr, fname, lineno, type, fmt, ap);
    731    1.1       cgd 	va_end(ap);
    732  1.127       dsl 
    733  1.131       dsl 	if (debug_file != stderr && debug_file != stdout) {
    734  1.127       dsl 		va_start(ap, fmt);
    735  1.156       dsl 		ParseVErrorInternal(debug_file, fname, lineno, type, fmt, ap);
    736  1.127       dsl 		va_end(ap);
    737  1.127       dsl 	}
    738    1.1       cgd }
    739    1.1       cgd 
    740  1.161       sjg 
    741  1.301    rillig /* Parse a .info .warning or .error directive.
    742  1.161       sjg  *
    743  1.301    rillig  * The input is the line minus the ".".  We substitute variables, print the
    744  1.301    rillig  * message and exit(1) (for .error) or just print a warning if the directive
    745  1.301    rillig  * is malformed.
    746  1.161       sjg  */
    747  1.164       sjg static Boolean
    748  1.161       sjg ParseMessage(char *line)
    749  1.161       sjg {
    750  1.161       sjg     int mtype;
    751  1.164       sjg 
    752  1.161       sjg     switch(*line) {
    753  1.161       sjg     case 'i':
    754  1.226       sjg 	mtype = PARSE_INFO;
    755  1.161       sjg 	break;
    756  1.161       sjg     case 'w':
    757  1.161       sjg 	mtype = PARSE_WARNING;
    758  1.161       sjg 	break;
    759  1.161       sjg     case 'e':
    760  1.161       sjg 	mtype = PARSE_FATAL;
    761  1.161       sjg 	break;
    762  1.161       sjg     default:
    763  1.161       sjg 	Parse_Error(PARSE_WARNING, "invalid syntax: \".%s\"", line);
    764  1.164       sjg 	return FALSE;
    765  1.161       sjg     }
    766  1.161       sjg 
    767  1.290    rillig     while (ch_isalpha(*line))
    768  1.161       sjg 	line++;
    769  1.290    rillig     if (!ch_isspace(*line))
    770  1.164       sjg 	return FALSE;			/* not for us */
    771  1.290    rillig     while (ch_isspace(*line))
    772  1.161       sjg 	line++;
    773  1.161       sjg 
    774  1.323    rillig     (void)Var_Subst(line, VAR_CMD, VARE_WANTRES, &line);
    775  1.323    rillig     /* TODO: handle errors */
    776  1.161       sjg     Parse_Error(mtype, "%s", line);
    777  1.161       sjg     free(line);
    778  1.161       sjg 
    779  1.161       sjg     if (mtype == PARSE_FATAL) {
    780  1.161       sjg 	/* Terminate immediately. */
    781  1.161       sjg 	exit(1);
    782  1.161       sjg     }
    783  1.164       sjg     return TRUE;
    784  1.161       sjg }
    785  1.161       sjg 
    786  1.315    rillig struct ParseLinkSrcArgs {
    787  1.315    rillig     GNode *cgn;
    788  1.316    rillig 
    789  1.316    rillig     /* The special target of the current dependency line. */
    790  1.317    rillig     /* Example: for ".END: action", it is 'End'. */
    791  1.315    rillig     ParseSpecial specType;
    792  1.315    rillig };
    793  1.315    rillig 
    794  1.316    rillig /* Add the child to the parent's children.
    795    1.1       cgd  *
    796  1.316    rillig  * Add the parent to the child's parents, but only if the target is not
    797  1.316    rillig  * special.  An example for such a special target is .END, which does not
    798  1.316    rillig  * need to be informed once the child target has been made. */
    799    1.1       cgd static int
    800  1.315    rillig ParseLinkSrc(void *pgnp, void *data)
    801    1.1       cgd {
    802  1.315    rillig     const struct ParseLinkSrcArgs *args = data;
    803  1.316    rillig     GNode *pgn = pgnp;
    804  1.316    rillig     GNode *cgn = args->cgn;
    805   1.52   mycroft 
    806  1.268    rillig     if ((pgn->type & OP_DOUBLEDEP) && !Lst_IsEmpty(pgn->cohorts))
    807  1.274    rillig 	pgn = LstNode_Datum(Lst_Last(pgn->cohorts));
    808  1.316    rillig 
    809  1.268    rillig     Lst_Append(pgn->children, cgn);
    810  1.316    rillig     pgn->unmade += 1;
    811  1.316    rillig 
    812  1.315    rillig     if (args->specType == Not)
    813  1.268    rillig 	Lst_Append(cgn->parents, pgn);
    814  1.316    rillig 
    815  1.109       dsl     if (DEBUG(PARSE)) {
    816  1.316    rillig 	fprintf(debug_file, "# %s: added child %s - %s\n",
    817  1.316    rillig 		__func__, pgn->name, cgn->name);
    818  1.109       dsl 	Targ_PrintNode(pgn, 0);
    819  1.109       dsl 	Targ_PrintNode(cgn, 0);
    820  1.109       dsl     }
    821  1.316    rillig 
    822  1.235    rillig     return 0;
    823    1.1       cgd }
    824    1.1       cgd 
    825    1.1       cgd /*-
    826    1.1       cgd  *---------------------------------------------------------------------
    827    1.1       cgd  * ParseDoOp  --
    828    1.1       cgd  *	Apply the parsed operator to the given target node. Used in a
    829  1.324    rillig  *	Lst_ForEachUntil call by ParseDoDependency once all targets have
    830    1.1       cgd  *	been found and their operator parsed. If the previous and new
    831    1.1       cgd  *	operators are incompatible, a major error is taken.
    832    1.1       cgd  *
    833   1.84       wiz  * Input:
    834   1.84       wiz  *	gnp		The node to which the operator is to be applied
    835   1.84       wiz  *	opp		The operator to apply
    836   1.84       wiz  *
    837    1.1       cgd  * Results:
    838    1.1       cgd  *	Always 0
    839    1.1       cgd  *
    840    1.1       cgd  * Side Effects:
    841    1.1       cgd  *	The type field of the node is altered to reflect any new bits in
    842    1.1       cgd  *	the op.
    843    1.1       cgd  *---------------------------------------------------------------------
    844    1.1       cgd  */
    845    1.1       cgd static int
    846  1.157       dsl ParseDoOp(void *gnp, void *opp)
    847    1.1       cgd {
    848  1.105  christos     GNode          *gn = (GNode *)gnp;
    849  1.105  christos     int             op = *(int *)opp;
    850    1.1       cgd     /*
    851    1.1       cgd      * If the dependency mask of the operator and the node don't match and
    852    1.1       cgd      * the node has actually had an operator applied to it before, and
    853   1.27  christos      * the operator actually has some dependency information in it, complain.
    854    1.1       cgd      */
    855    1.1       cgd     if (((op & OP_OPMASK) != (gn->type & OP_OPMASK)) &&
    856    1.1       cgd 	!OP_NOP(gn->type) && !OP_NOP(op))
    857    1.1       cgd     {
    858   1.97  christos 	Parse_Error(PARSE_FATAL, "Inconsistent operator for %s", gn->name);
    859  1.235    rillig 	return 1;
    860    1.1       cgd     }
    861    1.1       cgd 
    862  1.242    rillig     if (op == OP_DOUBLEDEP && (gn->type & OP_OPMASK) == OP_DOUBLEDEP) {
    863    1.1       cgd 	/*
    864    1.1       cgd 	 * If the node was the object of a :: operator, we need to create a
    865    1.1       cgd 	 * new instance of it for the children and commands on this dependency
    866    1.1       cgd 	 * line. The new instance is placed on the 'cohorts' list of the
    867    1.1       cgd 	 * initial one (note the initial one is not on its own cohorts list)
    868    1.1       cgd 	 * and the new instance is linked to all parents of the initial
    869    1.1       cgd 	 * instance.
    870    1.1       cgd 	 */
    871   1.84       wiz 	GNode	*cohort;
    872   1.27  christos 
    873   1.33   mycroft 	/*
    874   1.46   mycroft 	 * Propagate copied bits to the initial node.  They'll be propagated
    875   1.46   mycroft 	 * back to the rest of the cohorts later.
    876   1.33   mycroft 	 */
    877   1.46   mycroft 	gn->type |= op & ~OP_OPMASK;
    878   1.33   mycroft 
    879  1.120       dsl 	cohort = Targ_FindNode(gn->name, TARG_NOHASH);
    880  1.186  christos 	if (doing_depend)
    881  1.186  christos 	    ParseMark(cohort);
    882    1.1       cgd 	/*
    883    1.1       cgd 	 * Make the cohort invisible as well to avoid duplicating it into
    884    1.1       cgd 	 * other variables. True, parents of this target won't tend to do
    885    1.1       cgd 	 * anything with their local variables, but better safe than
    886   1.46   mycroft 	 * sorry. (I think this is pointless now, since the relevant list
    887   1.46   mycroft 	 * traversals will no longer see this node anyway. -mycroft)
    888    1.1       cgd 	 */
    889   1.46   mycroft 	cohort->type = op | OP_INVISIBLE;
    890  1.268    rillig 	Lst_Append(gn->cohorts, cohort);
    891   1.83        pk 	cohort->centurion = gn;
    892   1.83        pk 	gn->unmade_cohorts += 1;
    893  1.120       dsl 	snprintf(cohort->cohort_num, sizeof cohort->cohort_num, "#%d",
    894  1.120       dsl 		gn->unmade_cohorts);
    895   1.46   mycroft     } else {
    896    1.1       cgd 	/*
    897   1.46   mycroft 	 * We don't want to nuke any previous flags (whatever they were) so we
    898   1.46   mycroft 	 * just OR the new operator into the old
    899    1.1       cgd 	 */
    900   1.46   mycroft 	gn->type |= op;
    901    1.1       cgd     }
    902   1.33   mycroft 
    903  1.235    rillig     return 0;
    904    1.1       cgd }
    905    1.1       cgd 
    906   1.27  christos /*-
    907   1.18  christos  *---------------------------------------------------------------------
    908    1.1       cgd  * ParseDoSrc  --
    909    1.1       cgd  *	Given the name of a source, figure out if it is an attribute
    910    1.1       cgd  *	and apply it to the targets if it is. Else decide if there is
    911    1.1       cgd  *	some attribute which should be applied *to* the source because
    912    1.1       cgd  *	of some special target and apply it if so. Otherwise, make the
    913    1.1       cgd  *	source be a child of the targets in the list 'targets'
    914    1.1       cgd  *
    915   1.84       wiz  * Input:
    916   1.84       wiz  *	tOp		operator (if any) from special targets
    917   1.84       wiz  *	src		name of the source to handle
    918   1.84       wiz  *
    919    1.1       cgd  * Results:
    920    1.1       cgd  *	None
    921    1.1       cgd  *
    922    1.1       cgd  * Side Effects:
    923    1.1       cgd  *	Operator bits may be added to the list of targets or to the source.
    924    1.1       cgd  *	The targets may have a new source added to their lists of children.
    925    1.1       cgd  *---------------------------------------------------------------------
    926    1.1       cgd  */
    927    1.1       cgd static void
    928  1.315    rillig ParseDoSrc(int tOp, const char *src, ParseSpecial specType)
    929    1.1       cgd {
    930   1.18  christos     GNode	*gn = NULL;
    931  1.120       dsl     static int wait_number = 0;
    932  1.120       dsl     char wait_src[16];
    933    1.1       cgd 
    934  1.290    rillig     if (*src == '.' && ch_isupper(src[1])) {
    935    1.1       cgd 	int keywd = ParseFindKeyword(src);
    936    1.1       cgd 	if (keywd != -1) {
    937   1.18  christos 	    int op = parseKeywords[keywd].op;
    938   1.18  christos 	    if (op != 0) {
    939  1.265    rillig 		if (targets != NULL)
    940  1.324    rillig 		    Lst_ForEachUntil(targets, ParseDoOp, &op);
    941   1.18  christos 		return;
    942   1.18  christos 	    }
    943   1.18  christos 	    if (parseKeywords[keywd].spec == Wait) {
    944  1.120       dsl 		/*
    945  1.120       dsl 		 * We add a .WAIT node in the dependency list.
    946  1.120       dsl 		 * After any dynamic dependencies (and filename globbing)
    947  1.120       dsl 		 * have happened, it is given a dependency on the each
    948  1.120       dsl 		 * previous child back to and previous .WAIT node.
    949  1.120       dsl 		 * The next child won't be scheduled until the .WAIT node
    950  1.120       dsl 		 * is built.
    951  1.120       dsl 		 * We give each .WAIT node a unique name (mainly for diag).
    952  1.120       dsl 		 */
    953  1.120       dsl 		snprintf(wait_src, sizeof wait_src, ".WAIT_%u", ++wait_number);
    954  1.120       dsl 		gn = Targ_FindNode(wait_src, TARG_NOHASH);
    955  1.186  christos 		if (doing_depend)
    956  1.186  christos 		    ParseMark(gn);
    957  1.120       dsl 		gn->type = OP_WAIT | OP_PHONY | OP_DEPENDS | OP_NOTMAIN;
    958  1.315    rillig 		if (targets != NULL) {
    959  1.315    rillig 		    struct ParseLinkSrcArgs args = { gn, specType };
    960  1.324    rillig 		    Lst_ForEachUntil(targets, ParseLinkSrc, &args);
    961  1.315    rillig 		}
    962   1.18  christos 		return;
    963   1.18  christos 	    }
    964    1.1       cgd 	}
    965    1.1       cgd     }
    966   1.18  christos 
    967   1.18  christos     switch (specType) {
    968   1.18  christos     case Main:
    969    1.1       cgd 	/*
    970    1.1       cgd 	 * If we have noted the existence of a .MAIN, it means we need
    971    1.1       cgd 	 * to add the sources of said target to the list of things
    972    1.1       cgd 	 * to create. The string 'src' is likely to be free, so we
    973    1.1       cgd 	 * must make a new copy of it. Note that this will only be
    974    1.1       cgd 	 * invoked if the user didn't specify a target on the command
    975    1.1       cgd 	 * line. This is to allow #ifmake's to succeed, or something...
    976    1.1       cgd 	 */
    977  1.268    rillig 	Lst_Append(create, bmake_strdup(src));
    978    1.1       cgd 	/*
    979  1.118       dsl 	 * Add the name to the .TARGETS variable as well, so the user can
    980    1.1       cgd 	 * employ that, if desired.
    981    1.1       cgd 	 */
    982    1.1       cgd 	Var_Append(".TARGETS", src, VAR_GLOBAL);
    983   1.18  christos 	return;
    984   1.18  christos 
    985   1.18  christos     case Order:
    986    1.1       cgd 	/*
    987    1.1       cgd 	 * Create proper predecessor/successor links between the previous
    988    1.1       cgd 	 * source and the current one.
    989    1.1       cgd 	 */
    990    1.1       cgd 	gn = Targ_FindNode(src, TARG_CREATE);
    991  1.186  christos 	if (doing_depend)
    992  1.186  christos 	    ParseMark(gn);
    993  1.152       dsl 	if (predecessor != NULL) {
    994  1.268    rillig 	    Lst_Append(predecessor->order_succ, gn);
    995  1.268    rillig 	    Lst_Append(gn->order_pred, predecessor);
    996  1.109       dsl 	    if (DEBUG(PARSE)) {
    997  1.193  christos 		fprintf(debug_file, "# %s: added Order dependency %s - %s\n",
    998  1.193  christos 		    __func__, predecessor->name, gn->name);
    999  1.109       dsl 		Targ_PrintNode(predecessor, 0);
   1000  1.109       dsl 		Targ_PrintNode(gn, 0);
   1001  1.109       dsl 	    }
   1002    1.1       cgd 	}
   1003    1.1       cgd 	/*
   1004    1.1       cgd 	 * The current source now becomes the predecessor for the next one.
   1005    1.1       cgd 	 */
   1006    1.1       cgd 	predecessor = gn;
   1007   1.18  christos 	break;
   1008   1.18  christos 
   1009   1.18  christos     default:
   1010    1.1       cgd 	/*
   1011    1.1       cgd 	 * If the source is not an attribute, we need to find/create
   1012    1.1       cgd 	 * a node for it. After that we can apply any operator to it
   1013    1.1       cgd 	 * from a special target or link it to its parents, as
   1014    1.1       cgd 	 * appropriate.
   1015    1.1       cgd 	 *
   1016    1.1       cgd 	 * In the case of a source that was the object of a :: operator,
   1017    1.1       cgd 	 * the attribute is applied to all of its instances (as kept in
   1018    1.1       cgd 	 * the 'cohorts' list of the node) or all the cohorts are linked
   1019    1.1       cgd 	 * to all the targets.
   1020    1.1       cgd 	 */
   1021  1.118       dsl 
   1022  1.118       dsl 	/* Find/create the 'src' node and attach to all targets */
   1023   1.97  christos 	gn = Targ_FindNode(src, TARG_CREATE);
   1024  1.186  christos 	if (doing_depend)
   1025  1.186  christos 	    ParseMark(gn);
   1026    1.1       cgd 	if (tOp) {
   1027    1.1       cgd 	    gn->type |= tOp;
   1028    1.1       cgd 	} else {
   1029  1.315    rillig 	    if (targets != NULL) {
   1030  1.315    rillig 	        struct ParseLinkSrcArgs args = { gn, specType };
   1031  1.324    rillig 		Lst_ForEachUntil(targets, ParseLinkSrc, &args);
   1032  1.315    rillig 	    }
   1033    1.1       cgd 	}
   1034   1.18  christos 	break;
   1035   1.18  christos     }
   1036    1.1       cgd }
   1037    1.1       cgd 
   1038    1.1       cgd /*-
   1039    1.1       cgd  *-----------------------------------------------------------------------
   1040    1.1       cgd  * ParseFindMain --
   1041    1.1       cgd  *	Find a real target in the list and set it to be the main one.
   1042    1.1       cgd  *	Called by ParseDoDependency when a main target hasn't been found
   1043    1.1       cgd  *	yet.
   1044    1.1       cgd  *
   1045   1.84       wiz  * Input:
   1046   1.84       wiz  *	gnp		Node to examine
   1047   1.84       wiz  *
   1048    1.1       cgd  * Results:
   1049    1.1       cgd  *	0 if main not found yet, 1 if it is.
   1050    1.1       cgd  *
   1051    1.1       cgd  * Side Effects:
   1052    1.1       cgd  *	mainNode is changed and Targ_SetMain is called.
   1053    1.1       cgd  *
   1054    1.1       cgd  *-----------------------------------------------------------------------
   1055    1.1       cgd  */
   1056    1.1       cgd static int
   1057  1.219  riastrad ParseFindMain(void *gnp, void *dummy MAKE_ATTR_UNUSED)
   1058    1.1       cgd {
   1059  1.105  christos     GNode   	  *gn = (GNode *)gnp;
   1060  1.242    rillig     if (!(gn->type & OP_NOTARGET)) {
   1061    1.1       cgd 	mainNode = gn;
   1062    1.1       cgd 	Targ_SetMain(gn);
   1063  1.219  riastrad 	return 1;
   1064    1.1       cgd     } else {
   1065  1.219  riastrad 	return 0;
   1066    1.1       cgd     }
   1067    1.1       cgd }
   1068    1.1       cgd 
   1069    1.1       cgd /*-
   1070    1.1       cgd  *-----------------------------------------------------------------------
   1071    1.1       cgd  * ParseAddDir --
   1072  1.324    rillig  *	Front-end for Dir_AddDir to make sure Lst_ForEachUntil keeps going
   1073    1.1       cgd  *
   1074    1.1       cgd  * Results:
   1075    1.1       cgd  *	=== 0
   1076    1.1       cgd  *
   1077    1.1       cgd  * Side Effects:
   1078    1.1       cgd  *	See Dir_AddDir.
   1079    1.1       cgd  *
   1080    1.1       cgd  *-----------------------------------------------------------------------
   1081    1.1       cgd  */
   1082    1.1       cgd static int
   1083  1.157       dsl ParseAddDir(void *path, void *name)
   1084    1.1       cgd {
   1085  1.322    rillig     (void)Dir_AddDir(path, name);
   1086  1.235    rillig     return 0;
   1087    1.1       cgd }
   1088    1.1       cgd 
   1089    1.1       cgd /*-
   1090    1.1       cgd  *-----------------------------------------------------------------------
   1091    1.1       cgd  * ParseClearPath --
   1092  1.324    rillig  *	Front-end for Dir_ClearPath to make sure Lst_ForEachUntil keeps going
   1093    1.1       cgd  *
   1094    1.1       cgd  * Results:
   1095    1.1       cgd  *	=== 0
   1096    1.1       cgd  *
   1097    1.1       cgd  * Side Effects:
   1098    1.1       cgd  *	See Dir_ClearPath
   1099    1.1       cgd  *
   1100    1.1       cgd  *-----------------------------------------------------------------------
   1101    1.1       cgd  */
   1102    1.1       cgd static int
   1103  1.219  riastrad ParseClearPath(void *path, void *dummy MAKE_ATTR_UNUSED)
   1104    1.1       cgd {
   1105  1.322    rillig     Dir_ClearPath(path);
   1106  1.219  riastrad     return 0;
   1107    1.1       cgd }
   1108    1.1       cgd 
   1109  1.311    rillig /*
   1110  1.311    rillig  * We got to the end of the line while we were still looking at targets.
   1111  1.311    rillig  *
   1112  1.311    rillig  * Ending a dependency line without an operator is a Bozo no-no.  As a
   1113  1.311    rillig  * heuristic, this is also often triggered by undetected conflicts from
   1114  1.311    rillig  * cvs/rcs merges.
   1115  1.311    rillig  */
   1116  1.311    rillig static void
   1117  1.311    rillig ParseErrorNoDependency(const char *lstart, const char *line)
   1118  1.311    rillig {
   1119  1.311    rillig     if ((strncmp(line, "<<<<<<", 6) == 0) ||
   1120  1.311    rillig 	(strncmp(line, "======", 6) == 0) ||
   1121  1.311    rillig 	(strncmp(line, ">>>>>>", 6) == 0))
   1122  1.311    rillig 	Parse_Error(PARSE_FATAL,
   1123  1.311    rillig 		    "Makefile appears to contain unresolved cvs/rcs/??? merge conflicts");
   1124  1.311    rillig     else if (lstart[0] == '.') {
   1125  1.311    rillig 	const char *dirstart = lstart + 1;
   1126  1.311    rillig 	const char *dirend;
   1127  1.311    rillig 	while (ch_isspace(*dirstart))
   1128  1.311    rillig 	    dirstart++;
   1129  1.311    rillig 	dirend = dirstart;
   1130  1.311    rillig 	while (ch_isalnum(*dirend) || *dirend == '-')
   1131  1.311    rillig 	    dirend++;
   1132  1.311    rillig 	Parse_Error(PARSE_FATAL, "Unknown directive \"%.*s\"",
   1133  1.311    rillig 		    (int)(dirend - dirstart), dirstart);
   1134  1.311    rillig     } else
   1135  1.311    rillig 	Parse_Error(PARSE_FATAL, "Need an operator");
   1136  1.311    rillig }
   1137  1.311    rillig 
   1138  1.314    rillig static void
   1139  1.314    rillig ParseDependencyTargetWord(/*const*/ char **pp, const char *lstart)
   1140  1.314    rillig {
   1141  1.314    rillig     /*const*/ char *cp = *pp;
   1142  1.314    rillig 
   1143  1.314    rillig     while (*cp != '\0') {
   1144  1.314    rillig 	if ((ch_isspace(*cp) || *cp == '!' || *cp == ':' || *cp == '(') &&
   1145  1.314    rillig 	    !ParseIsEscaped(lstart, cp))
   1146  1.314    rillig 	    break;
   1147  1.314    rillig 
   1148  1.314    rillig 	if (*cp == '$') {
   1149  1.314    rillig 	    /*
   1150  1.314    rillig 	     * Must be a dynamic source (would have been expanded
   1151  1.314    rillig 	     * otherwise), so call the Var module to parse the puppy
   1152  1.314    rillig 	     * so we can safely advance beyond it...There should be
   1153  1.314    rillig 	     * no errors in this, as they would have been discovered
   1154  1.314    rillig 	     * in the initial Var_Subst and we wouldn't be here.
   1155  1.314    rillig 	     */
   1156  1.314    rillig 	    const char *nested_p = cp;
   1157  1.314    rillig 	    const char *nested_val;
   1158  1.314    rillig 	    void    *freeIt;
   1159  1.314    rillig 
   1160  1.314    rillig 	    (void)Var_Parse(&nested_p, VAR_CMD, VARE_UNDEFERR|VARE_WANTRES,
   1161  1.314    rillig 			    &nested_val, &freeIt);
   1162  1.314    rillig 	    /* TODO: handle errors */
   1163  1.314    rillig 	    free(freeIt);
   1164  1.314    rillig 	    cp += nested_p - cp;
   1165  1.314    rillig 	} else
   1166  1.314    rillig 	    cp++;
   1167  1.314    rillig     }
   1168  1.314    rillig 
   1169  1.314    rillig     *pp = cp;
   1170  1.314    rillig }
   1171  1.314    rillig 
   1172  1.306    rillig /* Parse a dependency line consisting of targets, followed by a dependency
   1173  1.306    rillig  * operator, optionally followed by sources.
   1174    1.1       cgd  *
   1175  1.306    rillig  * The nodes of the sources are linked as children to the nodes of the
   1176  1.306    rillig  * targets. Nodes are created as necessary.
   1177    1.1       cgd  *
   1178  1.306    rillig  * The operator is applied to each node in the global 'targets' list,
   1179    1.1       cgd  * which is where the nodes found for the targets are kept, by means of
   1180    1.1       cgd  * the ParseDoOp function.
   1181  1.306    rillig  *
   1182  1.306    rillig  * The sources are parsed in much the same way as the targets, except
   1183  1.306    rillig  * that they are expanded using the wildcarding scheme of the C-Shell,
   1184    1.1       cgd  * and all instances of the resulting words in the list of all targets
   1185    1.1       cgd  * are found. Each of the resulting nodes is then linked to each of the
   1186    1.1       cgd  * targets as one of its children.
   1187  1.306    rillig  *
   1188  1.306    rillig  * Certain targets and sources such as .PHONY or .PRECIOUS are handled
   1189  1.306    rillig  * specially. These are the ones detailed by the specType variable.
   1190  1.306    rillig  *
   1191  1.306    rillig  * The storing of transformation rules such as '.c.o' is also taken care of
   1192  1.306    rillig  * here. A target is recognized as a transformation rule by calling
   1193    1.1       cgd  * Suff_IsTransform. If it is a transformation rule, its node is gotten
   1194    1.1       cgd  * from the suffix module via Suff_AddTransform rather than the standard
   1195    1.1       cgd  * Targ_FindNode in the target module.
   1196    1.1       cgd  */
   1197    1.1       cgd static void
   1198   1.84       wiz ParseDoDependency(char *line)
   1199    1.1       cgd {
   1200  1.322    rillig     typedef List SearchPathList;
   1201  1.322    rillig 
   1202    1.9       jtc     char  	   *cp;		/* our current position */
   1203    1.9       jtc     int             op;		/* the operator on the line */
   1204    1.1       cgd     char            savec;	/* a place to save a character */
   1205  1.322    rillig     SearchPathList *paths;	/* search paths to alter when parsing
   1206    1.1       cgd 				 * a list of .PATH targets */
   1207    1.1       cgd     int	    	    tOp;    	/* operator from special target */
   1208  1.322    rillig     GNodeList *sources;		/* archive sources after expansion */
   1209  1.322    rillig     StringList *curTargs;	/* target names to be found and added
   1210    1.1       cgd 				 * to the targets list */
   1211   1.77  christos     char	   *lstart = line;
   1212    1.1       cgd 
   1213  1.315    rillig     /*
   1214  1.315    rillig      * specType contains the SPECial TYPE of the current target. It is Not
   1215  1.315    rillig      * if the target is unspecial. If it *is* special, however, the children
   1216  1.315    rillig      * are linked as children of the parent but not vice versa.
   1217  1.315    rillig      */
   1218  1.315    rillig     ParseSpecial specType = Not;
   1219  1.315    rillig 
   1220  1.120       dsl     if (DEBUG(PARSE))
   1221  1.120       dsl 	fprintf(debug_file, "ParseDoDependency(%s)\n", line);
   1222    1.1       cgd     tOp = 0;
   1223    1.1       cgd 
   1224  1.179    plunky     paths = NULL;
   1225    1.1       cgd 
   1226  1.252    rillig     curTargs = Lst_Init();
   1227   1.27  christos 
   1228  1.204  dholland     /*
   1229  1.204  dholland      * First, grind through the targets.
   1230  1.204  dholland      */
   1231  1.204  dholland 
   1232  1.307    rillig     while (TRUE) {
   1233  1.204  dholland 	/*
   1234  1.204  dholland 	 * Here LINE points to the beginning of the next word, and
   1235  1.204  dholland 	 * LSTART points to the actual beginning of the line.
   1236  1.204  dholland 	 */
   1237  1.204  dholland 
   1238  1.204  dholland 	/* Find the end of the next word. */
   1239  1.314    rillig 	cp = line;
   1240  1.314    rillig 	ParseDependencyTargetWord(&cp, lstart);
   1241  1.121       dsl 
   1242  1.204  dholland 	/*
   1243  1.204  dholland 	 * If the word is followed by a left parenthesis, it's the
   1244  1.204  dholland 	 * name of an object file inside an archive (ar file).
   1245  1.204  dholland 	 */
   1246  1.310    rillig 	if (!ParseIsEscaped(lstart, cp) && *cp == '(') {
   1247    1.1       cgd 	    /*
   1248  1.203     joerg 	     * Archives must be handled specially to make sure the OP_ARCHV
   1249  1.203     joerg 	     * flag is set in their 'type' field, for one thing, and because
   1250  1.203     joerg 	     * things like "archive(file1.o file2.o file3.o)" are permissible.
   1251  1.203     joerg 	     * Arch_ParseArchive will set 'line' to be the first non-blank
   1252  1.203     joerg 	     * after the archive-spec. It creates/finds nodes for the members
   1253  1.272    rillig 	     * and places them on the given list, returning TRUE if all
   1254  1.272    rillig 	     * went well and FALSE if there was an error in the
   1255  1.203     joerg 	     * specification. On error, line should remain untouched.
   1256    1.1       cgd 	     */
   1257  1.264    rillig 	    if (!Arch_ParseArchive(&line, targets, VAR_CMD)) {
   1258   1.97  christos 		Parse_Error(PARSE_FATAL,
   1259  1.203     joerg 			     "Error in archive specification: \"%s\"", line);
   1260  1.112  christos 		goto out;
   1261  1.203     joerg 	    } else {
   1262  1.204  dholland 		/* Done with this word; on to the next. */
   1263  1.213  matthias 		cp = line;
   1264    1.1       cgd 		continue;
   1265  1.203     joerg 	    }
   1266    1.1       cgd 	}
   1267   1.27  christos 
   1268    1.1       cgd 	if (!*cp) {
   1269  1.311    rillig 	    ParseErrorNoDependency(lstart, line);
   1270  1.112  christos 	    goto out;
   1271    1.1       cgd 	}
   1272  1.204  dholland 
   1273  1.204  dholland 	/* Insert a null terminator. */
   1274  1.204  dholland 	savec = *cp;
   1275    1.1       cgd 	*cp = '\0';
   1276  1.118       dsl 
   1277    1.1       cgd 	/*
   1278  1.204  dholland 	 * Got the word. See if it's a special target and if so set
   1279    1.1       cgd 	 * specType to match it.
   1280    1.1       cgd 	 */
   1281  1.290    rillig 	if (*line == '.' && ch_isupper(line[1])) {
   1282    1.1       cgd 	    /*
   1283    1.1       cgd 	     * See if the target is a special target that must have it
   1284   1.27  christos 	     * or its sources handled specially.
   1285    1.1       cgd 	     */
   1286    1.1       cgd 	    int keywd = ParseFindKeyword(line);
   1287    1.1       cgd 	    if (keywd != -1) {
   1288    1.5       cgd 		if (specType == ExPath && parseKeywords[keywd].spec != ExPath) {
   1289    1.1       cgd 		    Parse_Error(PARSE_FATAL, "Mismatched special targets");
   1290  1.112  christos 		    goto out;
   1291    1.1       cgd 		}
   1292   1.27  christos 
   1293    1.1       cgd 		specType = parseKeywords[keywd].spec;
   1294    1.1       cgd 		tOp = parseKeywords[keywd].op;
   1295    1.1       cgd 
   1296    1.1       cgd 		/*
   1297    1.1       cgd 		 * Certain special targets have special semantics:
   1298    1.1       cgd 		 *	.PATH		Have to set the dirSearchPath
   1299    1.1       cgd 		 *			variable too
   1300    1.1       cgd 		 *	.MAIN		Its sources are only used if
   1301    1.1       cgd 		 *			nothing has been specified to
   1302    1.1       cgd 		 *			create.
   1303    1.1       cgd 		 *	.DEFAULT    	Need to create a node to hang
   1304    1.1       cgd 		 *			commands on, but we don't want
   1305    1.1       cgd 		 *			it in the graph, nor do we want
   1306    1.1       cgd 		 *			it to be the Main Target, so we
   1307    1.1       cgd 		 *			create it, set OP_NOTMAIN and
   1308    1.1       cgd 		 *			add it to the list, setting
   1309    1.1       cgd 		 *			DEFAULT to the new node for
   1310    1.1       cgd 		 *			later use. We claim the node is
   1311    1.1       cgd 		 *	    	    	A transformation rule to make
   1312    1.1       cgd 		 *	    	    	life easier later, when we'll
   1313    1.1       cgd 		 *	    	    	use Make_HandleUse to actually
   1314    1.1       cgd 		 *	    	    	apply the .DEFAULT commands.
   1315   1.22  christos 		 *	.PHONY		The list of targets
   1316   1.32       gwr 		 *	.NOPATH		Don't search for file in the path
   1317  1.187  christos 		 *	.STALE
   1318    1.1       cgd 		 *	.BEGIN
   1319    1.1       cgd 		 *	.END
   1320  1.162       sjg 		 *	.ERROR
   1321  1.215  dholland 		 *	.DELETE_ON_ERROR
   1322    1.1       cgd 		 *	.INTERRUPT  	Are not to be considered the
   1323    1.1       cgd 		 *			main target.
   1324    1.1       cgd 		 *  	.NOTPARALLEL	Make only one target at a time.
   1325    1.1       cgd 		 *  	.SINGLESHELL	Create a shell for each command.
   1326  1.152       dsl 		 *  	.ORDER	    	Must set initial predecessor to NULL
   1327    1.1       cgd 		 */
   1328    1.1       cgd 		switch (specType) {
   1329  1.187  christos 		case ExPath:
   1330  1.187  christos 		    if (paths == NULL) {
   1331  1.252    rillig 			paths = Lst_Init();
   1332  1.187  christos 		    }
   1333  1.268    rillig 		    Lst_Append(paths, dirSearchPath);
   1334  1.187  christos 		    break;
   1335  1.187  christos 		case Main:
   1336  1.268    rillig 		    if (!Lst_IsEmpty(create)) {
   1337  1.187  christos 			specType = Not;
   1338  1.187  christos 		    }
   1339  1.187  christos 		    break;
   1340  1.187  christos 		case Begin:
   1341  1.187  christos 		case End:
   1342  1.187  christos 		case Stale:
   1343  1.187  christos 		case dotError:
   1344  1.313    rillig 		case Interrupt: {
   1345  1.313    rillig 		    GNode *gn = Targ_FindNode(line, TARG_CREATE);
   1346  1.187  christos 		    if (doing_depend)
   1347  1.187  christos 			ParseMark(gn);
   1348  1.187  christos 		    gn->type |= OP_NOTMAIN|OP_SPECIAL;
   1349  1.268    rillig 		    Lst_Append(targets, gn);
   1350  1.187  christos 		    break;
   1351  1.313    rillig 		}
   1352  1.313    rillig 		case Default: {
   1353  1.313    rillig 		    GNode *gn = Targ_NewGN(".DEFAULT");
   1354  1.313    rillig 		    gn->type |= OP_NOTMAIN|OP_TRANSFORM;
   1355  1.268    rillig 		    Lst_Append(targets, gn);
   1356  1.187  christos 		    DEFAULT = gn;
   1357  1.187  christos 		    break;
   1358  1.313    rillig 		}
   1359  1.215  dholland 		case DeleteOnError:
   1360  1.215  dholland 		    deleteOnError = TRUE;
   1361  1.215  dholland 		    break;
   1362  1.187  christos 		case NotParallel:
   1363  1.187  christos 		    maxJobs = 1;
   1364  1.187  christos 		    break;
   1365  1.187  christos 		case SingleShell:
   1366  1.187  christos 		    compatMake = TRUE;
   1367  1.187  christos 		    break;
   1368  1.187  christos 		case Order:
   1369  1.187  christos 		    predecessor = NULL;
   1370  1.187  christos 		    break;
   1371  1.187  christos 		default:
   1372  1.187  christos 		    break;
   1373    1.1       cgd 		}
   1374  1.103  christos 	    } else if (strncmp(line, ".PATH", 5) == 0) {
   1375    1.1       cgd 		/*
   1376    1.1       cgd 		 * .PATH<suffix> has to be handled specially.
   1377    1.1       cgd 		 * Call on the suffix module to give us a path to
   1378    1.1       cgd 		 * modify.
   1379    1.1       cgd 		 */
   1380  1.322    rillig 		SearchPath *path;
   1381   1.27  christos 
   1382    1.5       cgd 		specType = ExPath;
   1383   1.97  christos 		path = Suff_GetPath(&line[5]);
   1384  1.152       dsl 		if (path == NULL) {
   1385   1.97  christos 		    Parse_Error(PARSE_FATAL,
   1386    1.1       cgd 				 "Suffix '%s' not defined (yet)",
   1387    1.1       cgd 				 &line[5]);
   1388  1.112  christos 		    goto out;
   1389    1.1       cgd 		} else {
   1390  1.179    plunky 		    if (paths == NULL) {
   1391  1.252    rillig 			paths = Lst_Init();
   1392    1.1       cgd 		    }
   1393  1.268    rillig 		    Lst_Append(paths, path);
   1394    1.1       cgd 		}
   1395    1.1       cgd 	    }
   1396    1.1       cgd 	}
   1397   1.27  christos 
   1398    1.1       cgd 	/*
   1399    1.1       cgd 	 * Have word in line. Get or create its node and stick it at
   1400   1.27  christos 	 * the end of the targets list
   1401    1.1       cgd 	 */
   1402  1.242    rillig 	if (specType == Not && *line != '\0') {
   1403    1.1       cgd 	    if (Dir_HasWildcards(line)) {
   1404    1.1       cgd 		/*
   1405    1.1       cgd 		 * Targets are to be sought only in the current directory,
   1406    1.1       cgd 		 * so create an empty path for the thing. Note we need to
   1407    1.1       cgd 		 * use Dir_Destroy in the destruction of the path as the
   1408    1.1       cgd 		 * Dir module could have added a directory to the path...
   1409    1.1       cgd 		 */
   1410  1.322    rillig 		SearchPath *emptyPath = Lst_Init();
   1411   1.27  christos 
   1412    1.1       cgd 		Dir_Expand(line, emptyPath, curTargs);
   1413   1.27  christos 
   1414  1.268    rillig 		Lst_Destroy(emptyPath, Dir_Destroy);
   1415    1.1       cgd 	    } else {
   1416    1.1       cgd 		/*
   1417    1.1       cgd 		 * No wildcards, but we want to avoid code duplication,
   1418    1.1       cgd 		 * so create a list with the word on it.
   1419    1.1       cgd 		 */
   1420  1.268    rillig 		Lst_Append(curTargs, line);
   1421    1.1       cgd 	    }
   1422   1.27  christos 
   1423  1.204  dholland 	    /* Apply the targets. */
   1424  1.204  dholland 
   1425  1.268    rillig 	    while(!Lst_IsEmpty(curTargs)) {
   1426  1.268    rillig 		char *targName = Lst_Dequeue(curTargs);
   1427  1.313    rillig 		GNode *gn = Suff_IsTransform(targName)
   1428  1.313    rillig 			    ? Suff_AddTransform(targName)
   1429  1.313    rillig 			    : Targ_FindNode(targName, TARG_CREATE);
   1430  1.186  christos 		if (doing_depend)
   1431  1.186  christos 		    ParseMark(gn);
   1432   1.27  christos 
   1433  1.268    rillig 		Lst_Append(targets, gn);
   1434    1.1       cgd 	    }
   1435    1.5       cgd 	} else if (specType == ExPath && *line != '.' && *line != '\0') {
   1436    1.1       cgd 	    Parse_Error(PARSE_WARNING, "Extra target (%s) ignored", line);
   1437    1.1       cgd 	}
   1438   1.27  christos 
   1439  1.204  dholland 	/* Don't need the inserted null terminator any more. */
   1440    1.1       cgd 	*cp = savec;
   1441  1.204  dholland 
   1442    1.1       cgd 	/*
   1443    1.1       cgd 	 * If it is a special type and not .PATH, it's the only target we
   1444    1.1       cgd 	 * allow on this line...
   1445    1.1       cgd 	 */
   1446    1.5       cgd 	if (specType != Not && specType != ExPath) {
   1447  1.115  christos 	    Boolean warning = FALSE;
   1448   1.27  christos 
   1449   1.77  christos 	    while (*cp && (ParseIsEscaped(lstart, cp) ||
   1450  1.242    rillig 		(*cp != '!' && *cp != ':'))) {
   1451   1.77  christos 		if (ParseIsEscaped(lstart, cp) ||
   1452   1.77  christos 		    (*cp != ' ' && *cp != '\t')) {
   1453  1.115  christos 		    warning = TRUE;
   1454    1.1       cgd 		}
   1455    1.1       cgd 		cp++;
   1456    1.1       cgd 	    }
   1457  1.115  christos 	    if (warning) {
   1458    1.1       cgd 		Parse_Error(PARSE_WARNING, "Extra target ignored");
   1459    1.1       cgd 	    }
   1460    1.1       cgd 	} else {
   1461  1.290    rillig 	    while (*cp && ch_isspace(*cp)) {
   1462    1.1       cgd 		cp++;
   1463    1.1       cgd 	    }
   1464    1.1       cgd 	}
   1465  1.203     joerg 	line = cp;
   1466  1.307    rillig 	if (*line == '\0')
   1467  1.307    rillig 	    break;
   1468  1.307    rillig 	if ((*line == '!' || *line == ':') && !ParseIsEscaped(lstart, line))
   1469  1.307    rillig 	    break;
   1470  1.307    rillig     }
   1471    1.1       cgd 
   1472    1.1       cgd     /*
   1473    1.1       cgd      * Don't need the list of target names anymore...
   1474    1.1       cgd      */
   1475  1.268    rillig     Lst_Free(curTargs);
   1476  1.112  christos     curTargs = NULL;
   1477    1.1       cgd 
   1478  1.268    rillig     if (targets != NULL && !Lst_IsEmpty(targets)) {
   1479    1.1       cgd 	switch(specType) {
   1480    1.1       cgd 	    default:
   1481    1.1       cgd 		Parse_Error(PARSE_WARNING, "Special and mundane targets don't mix. Mundane ones ignored");
   1482    1.1       cgd 		break;
   1483    1.1       cgd 	    case Default:
   1484  1.187  christos 	    case Stale:
   1485    1.1       cgd 	    case Begin:
   1486    1.1       cgd 	    case End:
   1487  1.162       sjg 	    case dotError:
   1488    1.1       cgd 	    case Interrupt:
   1489    1.1       cgd 		/*
   1490    1.1       cgd 		 * These four create nodes on which to hang commands, so
   1491    1.1       cgd 		 * targets shouldn't be empty...
   1492    1.1       cgd 		 */
   1493    1.1       cgd 	    case Not:
   1494    1.1       cgd 		/*
   1495    1.1       cgd 		 * Nothing special here -- targets can be empty if it wants.
   1496    1.1       cgd 		 */
   1497    1.1       cgd 		break;
   1498    1.1       cgd 	}
   1499    1.1       cgd     }
   1500    1.1       cgd 
   1501    1.1       cgd     /*
   1502    1.1       cgd      * Have now parsed all the target names. Must parse the operator next. The
   1503    1.1       cgd      * result is left in  op .
   1504    1.1       cgd      */
   1505    1.1       cgd     if (*cp == '!') {
   1506    1.1       cgd 	op = OP_FORCE;
   1507    1.1       cgd     } else if (*cp == ':') {
   1508    1.1       cgd 	if (cp[1] == ':') {
   1509    1.1       cgd 	    op = OP_DOUBLEDEP;
   1510    1.1       cgd 	    cp++;
   1511    1.1       cgd 	} else {
   1512    1.1       cgd 	    op = OP_DEPENDS;
   1513    1.1       cgd 	}
   1514    1.1       cgd     } else {
   1515  1.159       dsl 	Parse_Error(PARSE_FATAL, lstart[0] == '.' ? "Unknown directive"
   1516  1.159       dsl 		    : "Missing dependency operator");
   1517  1.112  christos 	goto out;
   1518    1.1       cgd     }
   1519    1.1       cgd 
   1520  1.204  dholland     /* Advance beyond the operator */
   1521  1.204  dholland     cp++;
   1522    1.1       cgd 
   1523  1.204  dholland     /*
   1524  1.204  dholland      * Apply the operator to the target. This is how we remember which
   1525  1.204  dholland      * operator a target was defined with. It fails if the operator
   1526  1.204  dholland      * used isn't consistent across all references.
   1527  1.204  dholland      */
   1528  1.265    rillig     if (targets != NULL)
   1529  1.324    rillig 	Lst_ForEachUntil(targets, ParseDoOp, &op);
   1530    1.1       cgd 
   1531    1.1       cgd     /*
   1532  1.204  dholland      * Onward to the sources.
   1533  1.204  dholland      *
   1534  1.204  dholland      * LINE will now point to the first source word, if any, or the
   1535  1.204  dholland      * end of the string if not.
   1536    1.1       cgd      */
   1537  1.290    rillig     while (*cp && ch_isspace(*cp)) {
   1538    1.1       cgd 	cp++;
   1539    1.1       cgd     }
   1540    1.1       cgd     line = cp;
   1541    1.1       cgd 
   1542    1.1       cgd     /*
   1543    1.1       cgd      * Several special targets take different actions if present with no
   1544    1.1       cgd      * sources:
   1545    1.1       cgd      *	a .SUFFIXES line with no sources clears out all old suffixes
   1546    1.1       cgd      *	a .PRECIOUS line makes all targets precious
   1547    1.1       cgd      *	a .IGNORE line ignores errors for all targets
   1548    1.1       cgd      *	a .SILENT line creates silence when making all targets
   1549    1.1       cgd      *	a .PATH removes all directories from the search path(s).
   1550    1.1       cgd      */
   1551    1.1       cgd     if (!*line) {
   1552    1.1       cgd 	switch (specType) {
   1553    1.1       cgd 	    case Suffixes:
   1554   1.97  christos 		Suff_ClearSuffixes();
   1555    1.1       cgd 		break;
   1556    1.1       cgd 	    case Precious:
   1557    1.1       cgd 		allPrecious = TRUE;
   1558    1.1       cgd 		break;
   1559    1.1       cgd 	    case Ignore:
   1560    1.1       cgd 		ignoreErrors = TRUE;
   1561    1.1       cgd 		break;
   1562    1.1       cgd 	    case Silent:
   1563    1.1       cgd 		beSilent = TRUE;
   1564    1.1       cgd 		break;
   1565    1.5       cgd 	    case ExPath:
   1566  1.265    rillig 		if (paths != NULL)
   1567  1.324    rillig 		    Lst_ForEachUntil(paths, ParseClearPath, NULL);
   1568   1.85       sjg 		Dir_SetPATH();
   1569    1.1       cgd 		break;
   1570   1.48       sjg #ifdef POSIX
   1571  1.246    rillig 	    case Posix:
   1572  1.246    rillig 		Var_Set("%POSIX", "1003.2", VAR_GLOBAL);
   1573  1.246    rillig 		break;
   1574   1.48       sjg #endif
   1575    1.5       cgd 	    default:
   1576    1.5       cgd 		break;
   1577    1.1       cgd 	}
   1578    1.1       cgd     } else if (specType == MFlags) {
   1579    1.1       cgd 	/*
   1580    1.1       cgd 	 * Call on functions in main.c to deal with these arguments and
   1581    1.1       cgd 	 * set the initial character to a null-character so the loop to
   1582    1.1       cgd 	 * get sources won't get anything
   1583    1.1       cgd 	 */
   1584   1.97  christos 	Main_ParseArgLine(line);
   1585    1.1       cgd 	*line = '\0';
   1586    1.5       cgd     } else if (specType == ExShell) {
   1587  1.272    rillig 	if (!Job_ParseShell(line)) {
   1588   1.97  christos 	    Parse_Error(PARSE_FATAL, "improper shell specification");
   1589  1.112  christos 	    goto out;
   1590    1.1       cgd 	}
   1591    1.1       cgd 	*line = '\0';
   1592  1.242    rillig     } else if (specType == NotParallel || specType == SingleShell ||
   1593  1.242    rillig 	    specType == DeleteOnError) {
   1594    1.1       cgd 	*line = '\0';
   1595    1.1       cgd     }
   1596   1.27  christos 
   1597    1.1       cgd     /*
   1598   1.27  christos      * NOW GO FOR THE SOURCES
   1599    1.1       cgd      */
   1600  1.242    rillig     if (specType == Suffixes || specType == ExPath ||
   1601  1.242    rillig 	specType == Includes || specType == Libs ||
   1602  1.242    rillig 	specType == Null || specType == ExObjdir)
   1603    1.1       cgd     {
   1604  1.203     joerg 	while (*line) {
   1605    1.1       cgd 	    /*
   1606    1.1       cgd 	     * If the target was one that doesn't take files as its sources
   1607    1.1       cgd 	     * but takes something like suffixes, we take each
   1608    1.1       cgd 	     * space-separated word on the line as a something and deal
   1609    1.1       cgd 	     * with it accordingly.
   1610    1.1       cgd 	     *
   1611    1.1       cgd 	     * If the target was .SUFFIXES, we take each source as a
   1612    1.1       cgd 	     * suffix and add it to the list of suffixes maintained by the
   1613  1.203     joerg 	     * Suff module.
   1614    1.1       cgd 	     *
   1615    1.1       cgd 	     * If the target was a .PATH, we add the source as a directory
   1616    1.1       cgd 	     * to search on the search path.
   1617    1.1       cgd 	     *
   1618    1.1       cgd 	     * If it was .INCLUDES, the source is taken to be the suffix of
   1619    1.1       cgd 	     * files which will be #included and whose search path should
   1620    1.1       cgd 	     * be present in the .INCLUDES variable.
   1621    1.1       cgd 	     *
   1622    1.1       cgd 	     * If it was .LIBS, the source is taken to be the suffix of
   1623    1.1       cgd 	     * files which are considered libraries and whose search path
   1624    1.1       cgd 	     * should be present in the .LIBS variable.
   1625    1.1       cgd 	     *
   1626    1.1       cgd 	     * If it was .NULL, the source is the suffix to use when a file
   1627    1.1       cgd 	     * has no valid suffix.
   1628   1.75        tv 	     *
   1629   1.75        tv 	     * If it was .OBJDIR, the source is a new definition for .OBJDIR,
   1630   1.75        tv 	     * and will cause make to do a new chdir to that path.
   1631    1.1       cgd 	     */
   1632  1.290    rillig 	    while (*cp && !ch_isspace(*cp)) {
   1633    1.1       cgd 		cp++;
   1634  1.203     joerg 	    }
   1635    1.1       cgd 	    savec = *cp;
   1636    1.1       cgd 	    *cp = '\0';
   1637    1.1       cgd 	    switch (specType) {
   1638    1.1       cgd 		case Suffixes:
   1639  1.203     joerg 		    Suff_AddSuffix(line, &mainNode);
   1640    1.1       cgd 		    break;
   1641    1.5       cgd 		case ExPath:
   1642  1.265    rillig 		    if (paths != NULL)
   1643  1.324    rillig 			Lst_ForEachUntil(paths, ParseAddDir, line);
   1644    1.1       cgd 		    break;
   1645    1.1       cgd 		case Includes:
   1646   1.97  christos 		    Suff_AddInclude(line);
   1647    1.1       cgd 		    break;
   1648    1.1       cgd 		case Libs:
   1649   1.97  christos 		    Suff_AddLib(line);
   1650    1.1       cgd 		    break;
   1651    1.1       cgd 		case Null:
   1652   1.97  christos 		    Suff_SetNull(line);
   1653   1.75        tv 		    break;
   1654   1.75        tv 		case ExObjdir:
   1655  1.216  christos 		    Main_SetObjdir("%s", line);
   1656    1.1       cgd 		    break;
   1657    1.5       cgd 		default:
   1658    1.5       cgd 		    break;
   1659    1.1       cgd 	    }
   1660    1.1       cgd 	    *cp = savec;
   1661  1.203     joerg 	    if (savec != '\0') {
   1662  1.203     joerg 		cp++;
   1663  1.203     joerg 	    }
   1664  1.290    rillig 	    while (*cp && ch_isspace(*cp)) {
   1665    1.1       cgd 		cp++;
   1666  1.203     joerg 	    }
   1667  1.203     joerg 	    line = cp;
   1668    1.1       cgd 	}
   1669    1.1       cgd 	if (paths) {
   1670  1.268    rillig 	    Lst_Free(paths);
   1671  1.222  riastrad 	    paths = NULL;
   1672    1.1       cgd 	}
   1673   1.85       sjg 	if (specType == ExPath)
   1674   1.85       sjg 	    Dir_SetPATH();
   1675    1.1       cgd     } else {
   1676  1.222  riastrad 	assert(paths == NULL);
   1677    1.1       cgd 	while (*line) {
   1678    1.1       cgd 	    /*
   1679    1.1       cgd 	     * The targets take real sources, so we must beware of archive
   1680    1.1       cgd 	     * specifications (i.e. things with left parentheses in them)
   1681    1.1       cgd 	     * and handle them accordingly.
   1682    1.1       cgd 	     */
   1683  1.290    rillig 	    for (; *cp && !ch_isspace(*cp); cp++) {
   1684  1.310    rillig 		if (*cp == '(' && cp > line && cp[-1] != '$') {
   1685    1.1       cgd 		    /*
   1686    1.1       cgd 		     * Only stop for a left parenthesis if it isn't at the
   1687    1.1       cgd 		     * start of a word (that'll be for variable changes
   1688    1.1       cgd 		     * later) and isn't preceded by a dollar sign (a dynamic
   1689    1.1       cgd 		     * source).
   1690    1.1       cgd 		     */
   1691    1.1       cgd 		    break;
   1692    1.1       cgd 		}
   1693    1.1       cgd 	    }
   1694    1.1       cgd 
   1695  1.310    rillig 	    if (*cp == '(') {
   1696  1.252    rillig 		sources = Lst_Init();
   1697  1.264    rillig 		if (!Arch_ParseArchive(&line, sources, VAR_CMD)) {
   1698   1.97  christos 		    Parse_Error(PARSE_FATAL,
   1699    1.1       cgd 				 "Error in source archive spec \"%s\"", line);
   1700  1.112  christos 		    goto out;
   1701    1.1       cgd 		}
   1702    1.1       cgd 
   1703  1.268    rillig 		while (!Lst_IsEmpty(sources)) {
   1704  1.313    rillig 		    GNode *gn = Lst_Dequeue(sources);
   1705  1.315    rillig 		    ParseDoSrc(tOp, gn->name, specType);
   1706    1.1       cgd 		}
   1707  1.268    rillig 		Lst_Free(sources);
   1708    1.1       cgd 		cp = line;
   1709    1.1       cgd 	    } else {
   1710    1.1       cgd 		if (*cp) {
   1711    1.1       cgd 		    *cp = '\0';
   1712    1.1       cgd 		    cp += 1;
   1713    1.1       cgd 		}
   1714    1.1       cgd 
   1715  1.315    rillig 		ParseDoSrc(tOp, line, specType);
   1716    1.1       cgd 	    }
   1717  1.290    rillig 	    while (*cp && ch_isspace(*cp)) {
   1718    1.1       cgd 		cp++;
   1719    1.1       cgd 	    }
   1720    1.1       cgd 	    line = cp;
   1721    1.1       cgd 	}
   1722    1.1       cgd     }
   1723   1.27  christos 
   1724  1.265    rillig     if (mainNode == NULL && targets != NULL) {
   1725    1.1       cgd 	/*
   1726    1.1       cgd 	 * If we have yet to decide on a main target to make, in the
   1727    1.1       cgd 	 * absence of any user input, we want the first target on
   1728    1.1       cgd 	 * the first dependency line that is actually a real target
   1729    1.1       cgd 	 * (i.e. isn't a .USE or .EXEC rule) to be made.
   1730    1.1       cgd 	 */
   1731  1.324    rillig 	Lst_ForEachUntil(targets, ParseFindMain, NULL);
   1732    1.1       cgd     }
   1733    1.1       cgd 
   1734  1.112  christos out:
   1735  1.263    rillig     if (paths != NULL)
   1736  1.268    rillig 	Lst_Free(paths);
   1737  1.263    rillig     if (curTargs != NULL)
   1738  1.268    rillig 	Lst_Free(curTargs);
   1739    1.1       cgd }
   1740    1.1       cgd 
   1741    1.1       cgd /*-
   1742    1.1       cgd  *---------------------------------------------------------------------
   1743    1.1       cgd  * Parse_IsVar  --
   1744    1.1       cgd  *	Return TRUE if the passed line is a variable assignment. A variable
   1745    1.1       cgd  *	assignment consists of a single word followed by optional whitespace
   1746    1.1       cgd  *	followed by either a += or an = operator.
   1747    1.1       cgd  *	This function is used both by the Parse_File function and main when
   1748    1.1       cgd  *	parsing the command-line arguments.
   1749    1.1       cgd  *
   1750   1.84       wiz  * Input:
   1751   1.84       wiz  *	line		the line to check
   1752   1.84       wiz  *
   1753    1.1       cgd  * Results:
   1754    1.1       cgd  *	TRUE if it is. FALSE if it ain't
   1755    1.1       cgd  *
   1756    1.1       cgd  * Side Effects:
   1757    1.1       cgd  *	none
   1758    1.1       cgd  *---------------------------------------------------------------------
   1759    1.1       cgd  */
   1760    1.1       cgd Boolean
   1761  1.286    rillig Parse_IsVar(const char *line)
   1762    1.1       cgd {
   1763   1.84       wiz     Boolean wasSpace = FALSE;	/* set TRUE if found a space */
   1764  1.154       dsl     char ch;
   1765   1.16  christos     int level = 0;
   1766   1.16  christos #define ISEQOPERATOR(c) \
   1767   1.16  christos 	(((c) == '+') || ((c) == ':') || ((c) == '?') || ((c) == '!'))
   1768    1.1       cgd 
   1769    1.1       cgd     /*
   1770    1.1       cgd      * Skip to variable name
   1771    1.1       cgd      */
   1772  1.242    rillig     while (*line == ' ' || *line == '\t')
   1773  1.242    rillig 	line++;
   1774    1.1       cgd 
   1775  1.154       dsl     /* Scan for one of the assignment operators outside a variable expansion */
   1776  1.154       dsl     while ((ch = *line++) != 0) {
   1777  1.154       dsl 	if (ch == '(' || ch == '{') {
   1778   1.16  christos 	    level++;
   1779  1.154       dsl 	    continue;
   1780  1.154       dsl 	}
   1781  1.154       dsl 	if (ch == ')' || ch == '}') {
   1782   1.16  christos 	    level--;
   1783  1.154       dsl 	    continue;
   1784  1.154       dsl 	}
   1785  1.154       dsl 	if (level != 0)
   1786  1.154       dsl 	    continue;
   1787  1.154       dsl 	while (ch == ' ' || ch == '\t') {
   1788  1.154       dsl 	    ch = *line++;
   1789  1.154       dsl 	    wasSpace = TRUE;
   1790    1.1       cgd 	}
   1791  1.191       sjg #ifdef SUNSHCMD
   1792  1.191       sjg 	if (ch == ':' && strncmp(line, "sh", 2) == 0) {
   1793  1.191       sjg 	    line += 2;
   1794  1.191       sjg 	    continue;
   1795  1.191       sjg 	}
   1796  1.191       sjg #endif
   1797  1.154       dsl 	if (ch == '=')
   1798  1.154       dsl 	    return TRUE;
   1799  1.154       dsl 	if (*line == '=' && ISEQOPERATOR(ch))
   1800  1.154       dsl 	    return TRUE;
   1801  1.154       dsl 	if (wasSpace)
   1802  1.154       dsl 	    return FALSE;
   1803  1.154       dsl     }
   1804    1.1       cgd 
   1805  1.154       dsl     return FALSE;
   1806    1.1       cgd }
   1807    1.1       cgd 
   1808    1.1       cgd /*-
   1809    1.1       cgd  *---------------------------------------------------------------------
   1810    1.1       cgd  * Parse_DoVar  --
   1811    1.1       cgd  *	Take the variable assignment in the passed line and do it in the
   1812    1.1       cgd  *	global context.
   1813    1.1       cgd  *
   1814    1.1       cgd  *	Note: There is a lexical ambiguity with assignment modifier characters
   1815    1.1       cgd  *	in variable names. This routine interprets the character before the =
   1816    1.1       cgd  *	as a modifier. Therefore, an assignment like
   1817    1.1       cgd  *	    C++=/usr/bin/CC
   1818    1.1       cgd  *	is interpreted as "C+ +=" instead of "C++ =".
   1819    1.1       cgd  *
   1820   1.84       wiz  * Input:
   1821   1.84       wiz  *	line		a line guaranteed to be a variable assignment.
   1822   1.84       wiz  *			This reduces error checks
   1823   1.84       wiz  *	ctxt		Context in which to do the assignment
   1824   1.84       wiz  *
   1825    1.1       cgd  * Results:
   1826    1.1       cgd  *	none
   1827    1.1       cgd  *
   1828    1.1       cgd  * Side Effects:
   1829    1.1       cgd  *	the variable structure of the given variable name is altered in the
   1830    1.1       cgd  *	global context.
   1831    1.1       cgd  *---------------------------------------------------------------------
   1832    1.1       cgd  */
   1833    1.1       cgd void
   1834   1.84       wiz Parse_DoVar(char *line, GNode *ctxt)
   1835    1.1       cgd {
   1836    1.7       cgd     char	   *cp;	/* pointer into line */
   1837    1.1       cgd     enum {
   1838    1.1       cgd 	VAR_SUBST, VAR_APPEND, VAR_SHELL, VAR_NORMAL
   1839    1.1       cgd     }	    	    type;   	/* Type of assignment */
   1840   1.27  christos     char            *opc;	/* ptr to operator character to
   1841    1.1       cgd 				 * null-terminate the variable name */
   1842   1.86       sjg     Boolean	   freeCp = FALSE; /* TRUE if cp needs to be freed,
   1843   1.86       sjg 				    * i.e. if any variable expansion was
   1844   1.86       sjg 				    * performed */
   1845  1.153       dsl     int depth;
   1846    1.1       cgd 
   1847    1.1       cgd     /*
   1848    1.1       cgd      * Skip to variable name
   1849    1.1       cgd      */
   1850  1.242    rillig     while (*line == ' ' || *line == '\t')
   1851    1.1       cgd 	line++;
   1852    1.1       cgd 
   1853    1.1       cgd     /*
   1854    1.1       cgd      * Skip to operator character, nulling out whitespace as we go
   1855  1.153       dsl      * XXX Rather than counting () and {} we should look for $ and
   1856  1.153       dsl      * then expand the variable.
   1857    1.1       cgd      */
   1858  1.259    rillig     for (depth = 0, cp = line; depth > 0 || *cp != '='; cp++) {
   1859  1.153       dsl 	if (*cp == '(' || *cp == '{') {
   1860  1.153       dsl 	    depth++;
   1861  1.153       dsl 	    continue;
   1862  1.153       dsl 	}
   1863  1.153       dsl 	if (*cp == ')' || *cp == '}') {
   1864  1.153       dsl 	    depth--;
   1865  1.153       dsl 	    continue;
   1866  1.153       dsl 	}
   1867  1.290    rillig 	if (depth == 0 && ch_isspace(*cp)) {
   1868    1.1       cgd 	    *cp = '\0';
   1869    1.1       cgd 	}
   1870    1.1       cgd     }
   1871    1.1       cgd     opc = cp-1;		/* operator is the previous character */
   1872    1.1       cgd     *cp++ = '\0';	/* nuke the = */
   1873    1.1       cgd 
   1874    1.1       cgd     /*
   1875    1.1       cgd      * Check operator type
   1876    1.1       cgd      */
   1877    1.1       cgd     switch (*opc) {
   1878    1.1       cgd 	case '+':
   1879    1.1       cgd 	    type = VAR_APPEND;
   1880    1.1       cgd 	    *opc = '\0';
   1881    1.1       cgd 	    break;
   1882    1.1       cgd 
   1883    1.1       cgd 	case '?':
   1884    1.1       cgd 	    /*
   1885    1.1       cgd 	     * If the variable already has a value, we don't do anything.
   1886    1.1       cgd 	     */
   1887    1.1       cgd 	    *opc = '\0';
   1888    1.1       cgd 	    if (Var_Exists(line, ctxt)) {
   1889    1.1       cgd 		return;
   1890    1.1       cgd 	    } else {
   1891    1.1       cgd 		type = VAR_NORMAL;
   1892    1.1       cgd 	    }
   1893    1.1       cgd 	    break;
   1894    1.1       cgd 
   1895    1.1       cgd 	case ':':
   1896    1.1       cgd 	    type = VAR_SUBST;
   1897    1.1       cgd 	    *opc = '\0';
   1898    1.1       cgd 	    break;
   1899    1.1       cgd 
   1900    1.1       cgd 	case '!':
   1901    1.1       cgd 	    type = VAR_SHELL;
   1902    1.1       cgd 	    *opc = '\0';
   1903    1.1       cgd 	    break;
   1904    1.1       cgd 
   1905    1.1       cgd 	default:
   1906   1.23  christos #ifdef SUNSHCMD
   1907   1.39  christos 	    while (opc > line && *opc != ':')
   1908   1.39  christos 		opc--;
   1909   1.23  christos 
   1910   1.23  christos 	    if (strncmp(opc, ":sh", 3) == 0) {
   1911   1.23  christos 		type = VAR_SHELL;
   1912   1.23  christos 		*opc = '\0';
   1913   1.23  christos 		break;
   1914   1.23  christos 	    }
   1915   1.23  christos #endif
   1916    1.1       cgd 	    type = VAR_NORMAL;
   1917    1.1       cgd 	    break;
   1918    1.1       cgd     }
   1919    1.1       cgd 
   1920  1.290    rillig     while (ch_isspace(*cp))
   1921    1.1       cgd 	cp++;
   1922    1.1       cgd 
   1923  1.243       sjg     if (DEBUG(LINT)) {
   1924  1.243       sjg 	if (type != VAR_SUBST && strchr(cp, '$') != NULL) {
   1925  1.243       sjg 	    /* sanity check now */
   1926  1.243       sjg 	    char *cp2;
   1927  1.243       sjg 
   1928  1.323    rillig 	    (void)Var_Subst(cp, ctxt, VARE_ASSIGN, &cp2);
   1929  1.323    rillig 	    /* TODO: handle errors */
   1930  1.243       sjg 	    free(cp2);
   1931  1.243       sjg 	}
   1932  1.243       sjg     }
   1933  1.243       sjg 
   1934    1.1       cgd     if (type == VAR_APPEND) {
   1935   1.97  christos 	Var_Append(line, cp, ctxt);
   1936    1.1       cgd     } else if (type == VAR_SUBST) {
   1937    1.1       cgd 	/*
   1938    1.1       cgd 	 * Allow variables in the old value to be undefined, but leave their
   1939  1.295    rillig 	 * expressions alone -- this is done by forcing oldVars to be false.
   1940    1.1       cgd 	 * XXX: This can cause recursive variables, but that's not hard to do,
   1941    1.1       cgd 	 * and this allows someone to do something like
   1942    1.1       cgd 	 *
   1943    1.1       cgd 	 *  CFLAGS = $(.INCLUDES)
   1944    1.1       cgd 	 *  CFLAGS := -I.. $(CFLAGS)
   1945    1.1       cgd 	 *
   1946    1.1       cgd 	 * And not get an error.
   1947    1.1       cgd 	 */
   1948    1.1       cgd 	Boolean	  oldOldVars = oldVars;
   1949    1.1       cgd 
   1950    1.1       cgd 	oldVars = FALSE;
   1951   1.42  christos 
   1952   1.42  christos 	/*
   1953   1.42  christos 	 * make sure that we set the variable the first time to nothing
   1954   1.42  christos 	 * so that it gets substituted!
   1955   1.42  christos 	 */
   1956   1.42  christos 	if (!Var_Exists(line, ctxt))
   1957  1.234    rillig 	    Var_Set(line, "", ctxt);
   1958   1.42  christos 
   1959  1.323    rillig 	(void)Var_Subst(cp, ctxt, VARE_WANTRES|VARE_ASSIGN, &cp);
   1960  1.323    rillig 	/* TODO: handle errors */
   1961    1.1       cgd 	oldVars = oldOldVars;
   1962   1.86       sjg 	freeCp = TRUE;
   1963    1.1       cgd 
   1964  1.234    rillig 	Var_Set(line, cp, ctxt);
   1965    1.1       cgd     } else if (type == VAR_SHELL) {
   1966   1.93  christos 	char *res;
   1967  1.115  christos 	const char *error;
   1968    1.5       cgd 
   1969   1.23  christos 	if (strchr(cp, '$') != NULL) {
   1970    1.1       cgd 	    /*
   1971    1.1       cgd 	     * There's a dollar sign in the command, so perform variable
   1972    1.1       cgd 	     * expansion on the whole thing. The resulting string will need
   1973  1.238    rillig 	     * freeing when we're done.
   1974    1.1       cgd 	     */
   1975  1.323    rillig 	    (void)Var_Subst(cp, VAR_CMD, VARE_UNDEFERR|VARE_WANTRES, &cp);
   1976  1.323    rillig 	    /* TODO: handle errors */
   1977   1.86       sjg 	    freeCp = TRUE;
   1978    1.1       cgd 	}
   1979    1.1       cgd 
   1980  1.115  christos 	res = Cmd_Exec(cp, &error);
   1981  1.234    rillig 	Var_Set(line, res, ctxt);
   1982   1.23  christos 	free(res);
   1983    1.1       cgd 
   1984  1.115  christos 	if (error)
   1985  1.115  christos 	    Parse_Error(PARSE_WARNING, error, cp);
   1986    1.1       cgd     } else {
   1987    1.1       cgd 	/*
   1988    1.1       cgd 	 * Normal assignment -- just do it.
   1989    1.1       cgd 	 */
   1990  1.234    rillig 	Var_Set(line, cp, ctxt);
   1991    1.1       cgd     }
   1992   1.69       sjg     if (strcmp(line, MAKEOVERRIDES) == 0)
   1993   1.74        tv 	Main_ExportMAKEFLAGS(FALSE);	/* re-export MAKEFLAGS */
   1994   1.85       sjg     else if (strcmp(line, ".CURDIR") == 0) {
   1995   1.85       sjg 	/*
   1996  1.321    rillig 	 * Someone is being (too?) clever...
   1997   1.85       sjg 	 * Let's pretend they know what they are doing and
   1998  1.321    rillig 	 * re-initialize the 'cur' CachedDir.
   1999   1.85       sjg 	 */
   2000   1.85       sjg 	Dir_InitCur(cp);
   2001   1.85       sjg 	Dir_SetPATH();
   2002  1.136       sjg     } else if (strcmp(line, MAKE_JOB_PREFIX) == 0) {
   2003  1.135       sjg 	Job_SetPrefix();
   2004  1.136       sjg     } else if (strcmp(line, MAKE_EXPORTED) == 0) {
   2005  1.250    rillig 	Var_Export(cp, FALSE);
   2006   1.85       sjg     }
   2007   1.86       sjg     if (freeCp)
   2008   1.86       sjg 	free(cp);
   2009    1.1       cgd }
   2010   1.23  christos 
   2011  1.200  christos 
   2012  1.203     joerg /*
   2013  1.195  christos  * ParseMaybeSubMake --
   2014  1.195  christos  * 	Scan the command string to see if it a possible submake node
   2015  1.195  christos  * Input:
   2016  1.195  christos  *	cmd		the command to scan
   2017  1.195  christos  * Results:
   2018  1.195  christos  *	TRUE if the command is possibly a submake, FALSE if not.
   2019  1.195  christos  */
   2020  1.195  christos static Boolean
   2021  1.195  christos ParseMaybeSubMake(const char *cmd)
   2022  1.195  christos {
   2023  1.197    justin     size_t i;
   2024  1.195  christos     static struct {
   2025  1.195  christos 	const char *name;
   2026  1.195  christos 	size_t len;
   2027  1.195  christos     } vals[] = {
   2028  1.195  christos #define MKV(A)	{	A, sizeof(A) - 1	}
   2029  1.195  christos 	MKV("${MAKE}"),
   2030  1.195  christos 	MKV("${.MAKE}"),
   2031  1.195  christos 	MKV("$(MAKE)"),
   2032  1.195  christos 	MKV("$(.MAKE)"),
   2033  1.195  christos 	MKV("make"),
   2034  1.195  christos     };
   2035  1.198    justin     for (i = 0; i < sizeof(vals)/sizeof(vals[0]); i++) {
   2036  1.195  christos 	char *ptr;
   2037  1.195  christos 	if ((ptr = strstr(cmd, vals[i].name)) == NULL)
   2038  1.195  christos 	    continue;
   2039  1.290    rillig 	if ((ptr == cmd || !ch_isalnum(ptr[-1]))
   2040  1.290    rillig 	    && !ch_isalnum(ptr[vals[i].len]))
   2041  1.195  christos 	    return TRUE;
   2042  1.195  christos     }
   2043  1.195  christos     return FALSE;
   2044  1.195  christos }
   2045  1.195  christos 
   2046    1.1       cgd /*-
   2047    1.1       cgd  * ParseAddCmd  --
   2048  1.324    rillig  *	Lst_ForEachUntil function to add a command line to all targets
   2049    1.1       cgd  *
   2050   1.84       wiz  * Input:
   2051   1.84       wiz  *	gnp		the node to which the command is to be added
   2052   1.84       wiz  *	cmd		the command to add
   2053   1.84       wiz  *
   2054    1.1       cgd  * Results:
   2055    1.1       cgd  *	Always 0
   2056    1.1       cgd  *
   2057    1.1       cgd  * Side Effects:
   2058  1.195  christos  *	A new element is added to the commands list of the node,
   2059  1.195  christos  *	and the node can be marked as a submake node if the command is
   2060  1.195  christos  *	determined to be that.
   2061    1.1       cgd  */
   2062    1.5       cgd static int
   2063  1.157       dsl ParseAddCmd(void *gnp, void *cmd)
   2064    1.9       jtc {
   2065  1.105  christos     GNode *gn = (GNode *)gnp;
   2066  1.120       dsl 
   2067  1.120       dsl     /* Add to last (ie current) cohort for :: targets */
   2068  1.268    rillig     if ((gn->type & OP_DOUBLEDEP) && !Lst_IsEmpty(gn->cohorts))
   2069  1.274    rillig 	gn = LstNode_Datum(Lst_Last(gn->cohorts));
   2070  1.120       dsl 
   2071  1.203     joerg     /* if target already supplied, ignore commands */
   2072  1.203     joerg     if (!(gn->type & OP_HAS_COMMANDS)) {
   2073  1.268    rillig 	Lst_Append(gn->commands, cmd);
   2074  1.203     joerg 	if (ParseMaybeSubMake(cmd))
   2075  1.203     joerg 	    gn->type |= OP_SUBMAKE;
   2076  1.203     joerg 	ParseMark(gn);
   2077  1.203     joerg     } else {
   2078  1.203     joerg #ifdef notyet
   2079  1.203     joerg 	/* XXX: We cannot do this until we fix the tree */
   2080  1.268    rillig 	Lst_Append(gn->commands, cmd);
   2081  1.203     joerg 	Parse_Error(PARSE_WARNING,
   2082  1.203     joerg 		     "overriding commands for target \"%s\"; "
   2083  1.203     joerg 		     "previous commands defined at %s: %d ignored",
   2084  1.203     joerg 		     gn->name, gn->fname, gn->lineno);
   2085  1.203     joerg #else
   2086  1.203     joerg 	Parse_Error(PARSE_WARNING,
   2087  1.203     joerg 		     "duplicate script for target \"%s\" ignored",
   2088  1.203     joerg 		     gn->name);
   2089  1.203     joerg 	ParseErrorInternal(gn->fname, gn->lineno, PARSE_WARNING,
   2090  1.203     joerg 			    "using previous script for \"%s\" defined here",
   2091  1.203     joerg 			    gn->name);
   2092  1.203     joerg #endif
   2093  1.200  christos     }
   2094  1.235    rillig     return 0;
   2095    1.1       cgd }
   2096    1.1       cgd 
   2097  1.284    rillig /* Callback procedure for Parse_File when destroying the list of targets on
   2098  1.284    rillig  * the last dependency line. Marks a target as already having commands if it
   2099  1.284    rillig  * does, to keep from having shell commands on multiple dependency lines. */
   2100    1.9       jtc static void
   2101  1.157       dsl ParseHasCommands(void *gnp)
   2102    1.1       cgd {
   2103  1.105  christos     GNode *gn = (GNode *)gnp;
   2104  1.268    rillig     if (!Lst_IsEmpty(gn->commands)) {
   2105    1.1       cgd 	gn->type |= OP_HAS_COMMANDS;
   2106    1.1       cgd     }
   2107    1.1       cgd }
   2108    1.1       cgd 
   2109  1.284    rillig /* Add a directory to the path searched for included makefiles bracketed
   2110  1.284    rillig  * by double-quotes. */
   2111    1.1       cgd void
   2112   1.84       wiz Parse_AddIncludeDir(char *dir)
   2113    1.1       cgd {
   2114  1.103  christos     (void)Dir_AddDir(parseIncPath, dir);
   2115    1.1       cgd }
   2116    1.1       cgd 
   2117  1.284    rillig /* Push to another file.
   2118    1.1       cgd  *
   2119  1.284    rillig  * The input is the line minus the '.'. A file spec is a string enclosed in
   2120  1.284    rillig  * <> or "". The <> file is looked for only in sysIncPath. The "" file is
   2121  1.284    rillig  * first searched in the parsedir and then in the directories specified by
   2122  1.284    rillig  * the -I command line options.
   2123    1.1       cgd  */
   2124    1.1       cgd static void
   2125  1.210       sjg Parse_include_file(char *file, Boolean isSystem, Boolean depinc, int silent)
   2126    1.1       cgd {
   2127  1.170  dholland     struct loadedfile *lf;
   2128    1.1       cgd     char          *fullname;	/* full pathname of file */
   2129  1.140       dsl     char          *newName;
   2130  1.140       dsl     char          *prefEnd, *incdir;
   2131  1.125       dsl     int           fd;
   2132  1.140       dsl     int           i;
   2133    1.1       cgd 
   2134    1.1       cgd     /*
   2135    1.1       cgd      * Now we know the file's name and its search path, we attempt to
   2136    1.1       cgd      * find the durn thing. A return of NULL indicates the file don't
   2137    1.1       cgd      * exist.
   2138    1.1       cgd      */
   2139  1.147     joerg     fullname = file[0] == '/' ? bmake_strdup(file) : NULL;
   2140   1.76   reinoud 
   2141  1.140       dsl     if (fullname == NULL && !isSystem) {
   2142    1.1       cgd 	/*
   2143    1.1       cgd 	 * Include files contained in double-quotes are first searched for
   2144    1.1       cgd 	 * relative to the including file's location. We don't want to
   2145    1.1       cgd 	 * cd there, of course, so we just tack on the old file's
   2146    1.1       cgd 	 * leading path components and call Dir_FindFile to see if
   2147    1.1       cgd 	 * we can locate the beast.
   2148    1.1       cgd 	 */
   2149    1.1       cgd 
   2150  1.147     joerg 	incdir = bmake_strdup(curFile->fname);
   2151  1.140       dsl 	prefEnd = strrchr(incdir, '/');
   2152  1.105  christos 	if (prefEnd != NULL) {
   2153    1.1       cgd 	    *prefEnd = '\0';
   2154  1.140       dsl 	    /* Now do lexical processing of leading "../" on the filename */
   2155  1.140       dsl 	    for (i = 0; strncmp(file + i, "../", 3) == 0; i += 3) {
   2156  1.140       dsl 		prefEnd = strrchr(incdir + 1, '/');
   2157  1.140       dsl 		if (prefEnd == NULL || strcmp(prefEnd, "/..") == 0)
   2158  1.140       dsl 		    break;
   2159  1.140       dsl 		*prefEnd = '\0';
   2160  1.140       dsl 	    }
   2161  1.251    rillig 	    newName = str_concat3(incdir, "/", file + i);
   2162   1.97  christos 	    fullname = Dir_FindFile(newName, parseIncPath);
   2163  1.140       dsl 	    if (fullname == NULL)
   2164    1.1       cgd 		fullname = Dir_FindFile(newName, dirSearchPath);
   2165  1.103  christos 	    free(newName);
   2166    1.1       cgd 	}
   2167  1.140       dsl 	free(incdir);
   2168  1.140       dsl 
   2169  1.142       sjg 	if (fullname == NULL) {
   2170   1.76   reinoud 	    /*
   2171  1.246    rillig 	     * Makefile wasn't found in same directory as included makefile.
   2172   1.76   reinoud 	     * Search for it first on the -I search path,
   2173   1.76   reinoud 	     * then on the .PATH search path, if not found in a -I directory.
   2174  1.142       sjg 	     * If we have a suffix specific path we should use that.
   2175   1.76   reinoud 	     */
   2176  1.142       sjg 	    char *suff;
   2177  1.322    rillig 	    SearchPath *suffPath = NULL;
   2178  1.142       sjg 
   2179  1.145  christos 	    if ((suff = strrchr(file, '.'))) {
   2180  1.142       sjg 		suffPath = Suff_GetPath(suff);
   2181  1.152       dsl 		if (suffPath != NULL) {
   2182  1.142       sjg 		    fullname = Dir_FindFile(file, suffPath);
   2183  1.142       sjg 		}
   2184  1.142       sjg 	    }
   2185  1.105  christos 	    if (fullname == NULL) {
   2186  1.142       sjg 		fullname = Dir_FindFile(file, parseIncPath);
   2187  1.142       sjg 		if (fullname == NULL) {
   2188  1.142       sjg 		    fullname = Dir_FindFile(file, dirSearchPath);
   2189  1.142       sjg 		}
   2190   1.76   reinoud 	    }
   2191  1.142       sjg 	}
   2192    1.1       cgd     }
   2193    1.1       cgd 
   2194   1.76   reinoud     /* Looking for a system file or file still not found */
   2195  1.105  christos     if (fullname == NULL) {
   2196    1.1       cgd 	/*
   2197   1.76   reinoud 	 * Look for it on the system path
   2198    1.1       cgd 	 */
   2199  1.123       dsl 	fullname = Dir_FindFile(file,
   2200  1.268    rillig 		    Lst_IsEmpty(sysIncPath) ? defIncPath : sysIncPath);
   2201    1.1       cgd     }
   2202    1.1       cgd 
   2203  1.105  christos     if (fullname == NULL) {
   2204   1.38  christos 	if (!silent)
   2205   1.97  christos 	    Parse_Error(PARSE_FATAL, "Could not find %s", file);
   2206    1.1       cgd 	return;
   2207    1.1       cgd     }
   2208    1.1       cgd 
   2209  1.125       dsl     /* Actually open the file... */
   2210  1.125       dsl     fd = open(fullname, O_RDONLY);
   2211  1.125       dsl     if (fd == -1) {
   2212   1.38  christos 	if (!silent)
   2213   1.97  christos 	    Parse_Error(PARSE_FATAL, "Cannot open %s", fullname);
   2214  1.140       dsl 	free(fullname);
   2215  1.125       dsl 	return;
   2216  1.123       dsl     }
   2217  1.125       dsl 
   2218  1.170  dholland     /* load it */
   2219  1.170  dholland     lf = loadfile(fullname, fd);
   2220  1.170  dholland 
   2221  1.125       dsl     /* Start reading from this file next */
   2222  1.170  dholland     Parse_SetInput(fullname, 0, -1, loadedfile_nextbuf, lf);
   2223  1.170  dholland     curFile->lf = lf;
   2224  1.210       sjg     if (depinc)
   2225  1.210       sjg 	doing_depend = depinc;		/* only turn it on */
   2226  1.123       dsl }
   2227  1.123       dsl 
   2228  1.123       dsl static void
   2229  1.123       dsl ParseDoInclude(char *line)
   2230  1.123       dsl {
   2231  1.123       dsl     char          endc;	    	/* the character which ends the file spec */
   2232  1.123       dsl     char          *cp;		/* current position in file spec */
   2233  1.242    rillig     int		  silent = *line != 'i';
   2234  1.123       dsl     char	  *file = &line[7 + silent];
   2235  1.123       dsl 
   2236  1.123       dsl     /* Skip to delimiter character so we know where to look */
   2237  1.123       dsl     while (*file == ' ' || *file == '\t')
   2238  1.123       dsl 	file++;
   2239  1.123       dsl 
   2240  1.123       dsl     if (*file != '"' && *file != '<') {
   2241  1.123       dsl 	Parse_Error(PARSE_FATAL,
   2242  1.123       dsl 	    ".include filename must be delimited by '\"' or '<'");
   2243  1.123       dsl 	return;
   2244  1.123       dsl     }
   2245  1.123       dsl 
   2246  1.123       dsl     /*
   2247  1.123       dsl      * Set the search path on which to find the include file based on the
   2248  1.123       dsl      * characters which bracket its name. Angle-brackets imply it's
   2249  1.123       dsl      * a system Makefile while double-quotes imply it's a user makefile
   2250  1.123       dsl      */
   2251  1.123       dsl     if (*file == '<') {
   2252  1.123       dsl 	endc = '>';
   2253  1.123       dsl     } else {
   2254  1.123       dsl 	endc = '"';
   2255  1.123       dsl     }
   2256  1.123       dsl 
   2257  1.123       dsl     /* Skip to matching delimiter */
   2258  1.123       dsl     for (cp = ++file; *cp && *cp != endc; cp++)
   2259  1.123       dsl 	continue;
   2260  1.123       dsl 
   2261  1.123       dsl     if (*cp != endc) {
   2262  1.123       dsl 	Parse_Error(PARSE_FATAL,
   2263  1.123       dsl 		     "Unclosed %cinclude filename. '%c' expected",
   2264  1.123       dsl 		     '.', endc);
   2265  1.123       dsl 	return;
   2266    1.1       cgd     }
   2267  1.123       dsl     *cp = '\0';
   2268  1.123       dsl 
   2269  1.123       dsl     /*
   2270  1.123       dsl      * Substitute for any variables in the file name before trying to
   2271  1.123       dsl      * find the thing.
   2272  1.123       dsl      */
   2273  1.323    rillig     (void)Var_Subst(file, VAR_CMD, VARE_WANTRES, &file);
   2274  1.323    rillig     /* TODO: handle errors */
   2275  1.123       dsl 
   2276  1.242    rillig     Parse_include_file(file, endc == '>', *line == 'd', silent);
   2277  1.123       dsl     free(file);
   2278    1.1       cgd }
   2279    1.1       cgd 
   2280  1.281    rillig /* Split filename into dirname + basename, then assign these to the
   2281  1.281    rillig  * given variables. */
   2282  1.193  christos static void
   2283  1.281    rillig SetFilenameVars(const char *filename, const char *dirvar, const char *filevar)
   2284  1.193  christos {
   2285  1.281    rillig     const char *slash, *dirname, *basename;
   2286  1.281    rillig     void *freeIt;
   2287  1.281    rillig 
   2288  1.281    rillig     slash = strrchr(filename, '/');
   2289  1.281    rillig     if (slash == NULL) {
   2290  1.281    rillig 	dirname = curdir;
   2291  1.281    rillig 	basename = filename;
   2292  1.281    rillig 	freeIt = NULL;
   2293  1.281    rillig     } else {
   2294  1.281    rillig 	dirname = freeIt = bmake_strsedup(filename, slash);
   2295  1.281    rillig 	basename = slash + 1;
   2296  1.281    rillig     }
   2297  1.193  christos 
   2298  1.281    rillig     Var_Set(dirvar, dirname, VAR_GLOBAL);
   2299  1.281    rillig     Var_Set(filevar, basename, VAR_GLOBAL);
   2300  1.193  christos 
   2301  1.193  christos     if (DEBUG(PARSE))
   2302  1.281    rillig 	fprintf(debug_file, "%s: ${%s} = `%s' ${%s} = `%s'\n",
   2303  1.281    rillig 		__func__, dirvar, dirname, filevar, basename);
   2304  1.281    rillig     free(freeIt);
   2305  1.281    rillig }
   2306  1.281    rillig 
   2307  1.281    rillig /* Return the immediately including file.
   2308  1.281    rillig  *
   2309  1.281    rillig  * This is made complicated since the .for loop is implemented as a special
   2310  1.281    rillig  * kind of .include; see For_Run. */
   2311  1.281    rillig static const char *
   2312  1.281    rillig GetActuallyIncludingFile(void)
   2313  1.281    rillig {
   2314  1.281    rillig     size_t i;
   2315  1.193  christos 
   2316  1.281    rillig     /* XXX: Stack was supposed to be an opaque data structure. */
   2317  1.282    rillig     for (i = includes.len; i > 0; i--) {
   2318  1.282    rillig 	IFile *parent = includes.items[i - 1];
   2319  1.284    rillig 	IFile *child = i < includes.len ? includes.items[i] : curFile;
   2320  1.281    rillig 	if (!child->fromForLoop)
   2321  1.282    rillig 	    return parent->fname;
   2322  1.281    rillig     }
   2323  1.282    rillig     return NULL;
   2324  1.193  christos }
   2325  1.281    rillig 
   2326  1.285    rillig /* Set .PARSEDIR, .PARSEFILE, .INCLUDEDFROMDIR and .INCLUDEDFROMFILE. */
   2327   1.44     aidan static void
   2328  1.122       dsl ParseSetParseFile(const char *filename)
   2329   1.44     aidan {
   2330  1.281    rillig     const char *including;
   2331   1.44     aidan 
   2332  1.281    rillig     SetFilenameVars(filename, ".PARSEDIR", ".PARSEFILE");
   2333  1.281    rillig 
   2334  1.281    rillig     including = GetActuallyIncludingFile();
   2335  1.281    rillig     if (including != NULL) {
   2336  1.281    rillig 	SetFilenameVars(including,
   2337  1.281    rillig 			".INCLUDEDFROMDIR", ".INCLUDEDFROMFILE");
   2338   1.44     aidan     } else {
   2339  1.281    rillig 	Var_Delete(".INCLUDEDFROMDIR", VAR_GLOBAL);
   2340  1.281    rillig 	Var_Delete(".INCLUDEDFROMFILE", VAR_GLOBAL);
   2341   1.44     aidan     }
   2342   1.44     aidan }
   2343   1.44     aidan 
   2344  1.284    rillig /* Track the makefiles we read - so makefiles can set dependencies on them.
   2345  1.284    rillig  * Avoid adding anything more than once. */
   2346  1.184       sjg static void
   2347  1.184       sjg ParseTrackInput(const char *name)
   2348  1.184       sjg {
   2349  1.184       sjg     char *fp = NULL;
   2350  1.236    rillig 
   2351  1.244    rillig     const char *old = Var_Value(MAKE_MAKEFILES, VAR_GLOBAL, &fp);
   2352  1.184       sjg     if (old) {
   2353  1.244    rillig 	size_t name_len = strlen(name);
   2354  1.244    rillig 	const char *ep = old + strlen(old) - name_len;
   2355  1.184       sjg 	/* does it contain name? */
   2356  1.184       sjg 	for (; old != NULL; old = strchr(old, ' ')) {
   2357  1.184       sjg 	    if (*old == ' ')
   2358  1.184       sjg 		old++;
   2359  1.206       sjg 	    if (old >= ep)
   2360  1.206       sjg 		break;			/* cannot contain name */
   2361  1.184       sjg 	    if (memcmp(old, name, name_len) == 0
   2362  1.184       sjg 		    && (old[name_len] == 0 || old[name_len] == ' '))
   2363  1.184       sjg 		goto cleanup;
   2364  1.184       sjg 	}
   2365  1.184       sjg     }
   2366  1.184       sjg     Var_Append (MAKE_MAKEFILES, name, VAR_GLOBAL);
   2367  1.184       sjg  cleanup:
   2368  1.245    rillig     bmake_free(fp);
   2369  1.184       sjg }
   2370  1.137       sjg 
   2371   1.44     aidan 
   2372  1.276    rillig /* Start Parsing from the given source.
   2373    1.5       cgd  *
   2374  1.276    rillig  * The given file is added to the includes stack. */
   2375    1.5       cgd void
   2376  1.170  dholland Parse_SetInput(const char *name, int line, int fd,
   2377  1.170  dholland 	char *(*nextbuf)(void *, size_t *), void *arg)
   2378    1.5       cgd {
   2379  1.155       dsl     char *buf;
   2380  1.170  dholland     size_t len;
   2381  1.281    rillig     Boolean fromForLoop = name == NULL;
   2382  1.155       dsl 
   2383  1.281    rillig     if (fromForLoop)
   2384  1.127       dsl 	name = curFile->fname;
   2385  1.139       dsl     else
   2386  1.184       sjg 	ParseTrackInput(name);
   2387  1.127       dsl 
   2388  1.127       dsl     if (DEBUG(PARSE))
   2389  1.288    rillig 	fprintf(debug_file, "%s: file %s, line %d, fd %d, nextbuf %s, arg %p\n",
   2390  1.288    rillig 		__func__, name, line, fd,
   2391  1.288    rillig 		nextbuf == loadedfile_nextbuf ? "loadedfile" : "other", arg);
   2392  1.127       dsl 
   2393  1.155       dsl     if (fd == -1 && nextbuf == NULL)
   2394  1.125       dsl 	/* sanity */
   2395  1.125       dsl 	return;
   2396  1.125       dsl 
   2397  1.132       dsl     if (curFile != NULL)
   2398  1.281    rillig 	/* Save existing file info */
   2399  1.276    rillig 	Stack_Push(&includes, curFile);
   2400    1.5       cgd 
   2401  1.125       dsl     /* Allocate and fill in new structure */
   2402  1.147     joerg     curFile = bmake_malloc(sizeof *curFile);
   2403  1.125       dsl 
   2404  1.125       dsl     /*
   2405  1.125       dsl      * Once the previous state has been saved, we can get down to reading
   2406  1.125       dsl      * the new file. We set up the name of the file to be the absolute
   2407  1.125       dsl      * name of the include file so error messages refer to the right
   2408  1.125       dsl      * place.
   2409  1.125       dsl      */
   2410  1.189       sjg     curFile->fname = bmake_strdup(name);
   2411  1.281    rillig     curFile->fromForLoop = fromForLoop;
   2412  1.125       dsl     curFile->lineno = line;
   2413  1.155       dsl     curFile->first_lineno = line;
   2414  1.155       dsl     curFile->nextbuf = nextbuf;
   2415  1.155       dsl     curFile->nextbuf_arg = arg;
   2416  1.170  dholland     curFile->lf = NULL;
   2417  1.212       sjg     curFile->depending = doing_depend;	/* restore this on EOF */
   2418  1.170  dholland 
   2419  1.170  dholland     assert(nextbuf != NULL);
   2420  1.125       dsl 
   2421  1.170  dholland     /* Get first block of input data */
   2422  1.170  dholland     buf = curFile->nextbuf(curFile->nextbuf_arg, &len);
   2423  1.170  dholland     if (buf == NULL) {
   2424  1.246    rillig 	/* Was all a waste of time ... */
   2425  1.189       sjg 	if (curFile->fname)
   2426  1.189       sjg 	    free(curFile->fname);
   2427  1.170  dholland 	free(curFile);
   2428  1.170  dholland 	return;
   2429  1.125       dsl     }
   2430  1.170  dholland     curFile->P_str = buf;
   2431  1.170  dholland     curFile->P_ptr = buf;
   2432  1.170  dholland     curFile->P_end = buf+len;
   2433    1.5       cgd 
   2434  1.155       dsl     curFile->cond_depth = Cond_save_depth();
   2435  1.155       dsl     ParseSetParseFile(name);
   2436    1.5       cgd }
   2437    1.5       cgd 
   2438  1.284    rillig /* Check if the line is an include directive. */
   2439  1.228  christos static Boolean
   2440  1.298    rillig IsInclude(const char *dir, Boolean sysv)
   2441  1.228  christos {
   2442  1.298    rillig 	if (dir[0] == 's' || dir[0] == '-' || (dir[0] == 'd' && !sysv))
   2443  1.298    rillig 		dir++;
   2444  1.228  christos 
   2445  1.298    rillig 	if (strncmp(dir, "include", 7) != 0)
   2446  1.228  christos 		return FALSE;
   2447  1.228  christos 
   2448  1.248    rillig 	/* Space is not mandatory for BSD .include */
   2449  1.298    rillig 	return !sysv || ch_isspace(dir[7]);
   2450  1.228  christos }
   2451  1.228  christos 
   2452  1.228  christos 
   2453    1.5       cgd #ifdef SYSVINCLUDE
   2454  1.284    rillig /* Check if the line is a SYSV include directive. */
   2455  1.228  christos static Boolean
   2456  1.228  christos IsSysVInclude(const char *line)
   2457  1.228  christos {
   2458  1.228  christos 	const char *p;
   2459  1.228  christos 
   2460  1.228  christos 	if (!IsInclude(line, TRUE))
   2461  1.228  christos 		return FALSE;
   2462  1.228  christos 
   2463  1.228  christos 	/* Avoid interpeting a dependency line as an include */
   2464  1.228  christos 	for (p = line; (p = strchr(p, ':')) != NULL;) {
   2465  1.228  christos 		if (*++p == '\0') {
   2466  1.228  christos 			/* end of line -> dependency */
   2467  1.228  christos 			return FALSE;
   2468  1.228  christos 		}
   2469  1.290    rillig 		if (*p == ':' || ch_isspace(*p)) {
   2470  1.228  christos 			/* :: operator or ': ' -> dependency */
   2471  1.228  christos 			return FALSE;
   2472  1.228  christos 		}
   2473  1.228  christos 	}
   2474  1.228  christos 	return TRUE;
   2475  1.228  christos }
   2476  1.228  christos 
   2477  1.284    rillig /* Push to another file.  The line points to the word "include". */
   2478    1.5       cgd static void
   2479   1.84       wiz ParseTraditionalInclude(char *line)
   2480    1.5       cgd {
   2481    1.5       cgd     char          *cp;		/* current position in file spec */
   2482   1.38  christos     int		   done = 0;
   2483  1.242    rillig     int		   silent = line[0] != 'i';
   2484   1.38  christos     char	  *file = &line[silent + 7];
   2485  1.123       dsl     char	  *all_files;
   2486    1.5       cgd 
   2487  1.284    rillig     if (DEBUG(PARSE))
   2488  1.284    rillig 	fprintf(debug_file, "%s: %s\n", __func__, file);
   2489  1.111  ginsbach 
   2490    1.5       cgd     /*
   2491    1.5       cgd      * Skip over whitespace
   2492    1.5       cgd      */
   2493  1.290    rillig     while (ch_isspace(*file))
   2494    1.5       cgd 	file++;
   2495    1.5       cgd 
   2496  1.111  ginsbach     /*
   2497  1.111  ginsbach      * Substitute for any variables in the file name before trying to
   2498  1.111  ginsbach      * find the thing.
   2499  1.111  ginsbach      */
   2500  1.323    rillig     (void)Var_Subst(file, VAR_CMD, VARE_WANTRES, &all_files);
   2501  1.323    rillig     /* TODO: handle errors */
   2502  1.111  ginsbach 
   2503    1.5       cgd     if (*file == '\0') {
   2504   1.97  christos 	Parse_Error(PARSE_FATAL,
   2505    1.5       cgd 		     "Filename missing from \"include\"");
   2506  1.224  riastrad 	goto out;
   2507    1.5       cgd     }
   2508    1.5       cgd 
   2509  1.123       dsl     for (file = all_files; !done; file = cp + 1) {
   2510  1.123       dsl 	/* Skip to end of line or next whitespace */
   2511  1.290    rillig 	for (cp = file; *cp && !ch_isspace(*cp); cp++)
   2512   1.38  christos 	    continue;
   2513   1.38  christos 
   2514   1.38  christos 	if (*cp)
   2515   1.38  christos 	    *cp = '\0';
   2516   1.38  christos 	else
   2517   1.38  christos 	    done = 1;
   2518   1.38  christos 
   2519  1.210       sjg 	Parse_include_file(file, FALSE, FALSE, silent);
   2520    1.5       cgd     }
   2521  1.224  riastrad out:
   2522  1.123       dsl     free(all_files);
   2523    1.5       cgd }
   2524    1.5       cgd #endif
   2525    1.5       cgd 
   2526  1.183       sjg #ifdef GMAKEEXPORT
   2527  1.284    rillig /* Parse export <variable>=<value>, and actually export it. */
   2528  1.182  christos static void
   2529  1.182  christos ParseGmakeExport(char *line)
   2530  1.182  christos {
   2531  1.182  christos     char	  *variable = &line[6];
   2532  1.182  christos     char	  *value;
   2533  1.182  christos 
   2534  1.284    rillig     if (DEBUG(PARSE))
   2535  1.284    rillig 	fprintf(debug_file, "%s: %s\n", __func__, variable);
   2536  1.182  christos 
   2537  1.182  christos     /*
   2538  1.182  christos      * Skip over whitespace
   2539  1.182  christos      */
   2540  1.290    rillig     while (ch_isspace(*variable))
   2541  1.182  christos 	variable++;
   2542  1.182  christos 
   2543  1.182  christos     for (value = variable; *value && *value != '='; value++)
   2544  1.182  christos 	continue;
   2545  1.182  christos 
   2546  1.182  christos     if (*value != '=') {
   2547  1.182  christos 	Parse_Error(PARSE_FATAL,
   2548  1.284    rillig 		    "Variable/Value missing from \"export\"");
   2549  1.182  christos 	return;
   2550  1.182  christos     }
   2551  1.188       sjg     *value++ = '\0';			/* terminate variable */
   2552  1.182  christos 
   2553  1.182  christos     /*
   2554  1.183       sjg      * Expand the value before putting it in the environment.
   2555  1.182  christos      */
   2556  1.323    rillig     (void)Var_Subst(value, VAR_CMD, VARE_WANTRES, &value);
   2557  1.323    rillig     /* TODO: handle errors */
   2558  1.323    rillig 
   2559  1.182  christos     setenv(variable, value, 1);
   2560  1.223  riastrad     free(value);
   2561  1.182  christos }
   2562  1.182  christos #endif
   2563  1.182  christos 
   2564  1.284    rillig /* Called when EOF is reached in the current file. If we were reading an
   2565  1.284    rillig  * include file, the includes stack is popped and things set up to go back
   2566  1.284    rillig  * to reading the previous file at the previous location.
   2567    1.1       cgd  *
   2568    1.1       cgd  * Results:
   2569    1.1       cgd  *	CONTINUE if there's more to do. DONE if not.
   2570    1.1       cgd  */
   2571    1.1       cgd static int
   2572  1.123       dsl ParseEOF(void)
   2573    1.1       cgd {
   2574  1.155       dsl     char *ptr;
   2575  1.170  dholland     size_t len;
   2576  1.170  dholland 
   2577  1.170  dholland     assert(curFile->nextbuf != NULL);
   2578  1.155       dsl 
   2579  1.210       sjg     doing_depend = curFile->depending;	/* restore this */
   2580  1.170  dholland     /* get next input buffer, if any */
   2581  1.170  dholland     ptr = curFile->nextbuf(curFile->nextbuf_arg, &len);
   2582  1.170  dholland     curFile->P_ptr = ptr;
   2583  1.170  dholland     curFile->P_str = ptr;
   2584  1.170  dholland     curFile->P_end = ptr + len;
   2585  1.170  dholland     curFile->lineno = curFile->first_lineno;
   2586  1.170  dholland     if (ptr != NULL) {
   2587  1.170  dholland 	/* Iterate again */
   2588  1.170  dholland 	return CONTINUE;
   2589  1.155       dsl     }
   2590  1.155       dsl 
   2591  1.132       dsl     /* Ensure the makefile (or loop) didn't have mismatched conditionals */
   2592  1.132       dsl     Cond_restore_depth(curFile->cond_depth);
   2593  1.131       dsl 
   2594  1.170  dholland     if (curFile->lf != NULL) {
   2595  1.170  dholland 	    loadedfile_destroy(curFile->lf);
   2596  1.170  dholland 	    curFile->lf = NULL;
   2597  1.170  dholland     }
   2598  1.170  dholland 
   2599  1.125       dsl     /* Dispose of curFile info */
   2600  1.125       dsl     /* Leak curFile->fname because all the gnodes have pointers to it */
   2601  1.125       dsl     free(curFile->P_str);
   2602  1.125       dsl     free(curFile);
   2603  1.125       dsl 
   2604  1.276    rillig     if (Stack_IsEmpty(&includes)) {
   2605  1.258    rillig 	curFile = NULL;
   2606  1.125       dsl 	/* We've run out of input */
   2607   1.44     aidan 	Var_Delete(".PARSEDIR", VAR_GLOBAL);
   2608   1.44     aidan 	Var_Delete(".PARSEFILE", VAR_GLOBAL);
   2609  1.194  christos 	Var_Delete(".INCLUDEDFROMDIR", VAR_GLOBAL);
   2610  1.194  christos 	Var_Delete(".INCLUDEDFROMFILE", VAR_GLOBAL);
   2611  1.125       dsl 	return DONE;
   2612    1.1       cgd     }
   2613    1.1       cgd 
   2614  1.276    rillig     curFile = Stack_Pop(&includes);
   2615  1.127       dsl     if (DEBUG(PARSE))
   2616  1.170  dholland 	fprintf(debug_file, "ParseEOF: returning to file %s, line %d\n",
   2617  1.170  dholland 	    curFile->fname, curFile->lineno);
   2618  1.127       dsl 
   2619  1.125       dsl     ParseSetParseFile(curFile->fname);
   2620  1.235    rillig     return CONTINUE;
   2621    1.1       cgd }
   2622    1.1       cgd 
   2623  1.127       dsl #define PARSE_RAW 1
   2624  1.127       dsl #define PARSE_SKIP 2
   2625  1.127       dsl 
   2626  1.127       dsl static char *
   2627  1.127       dsl ParseGetLine(int flags, int *length)
   2628    1.5       cgd {
   2629  1.125       dsl     IFile *cf = curFile;
   2630  1.127       dsl     char *ptr;
   2631  1.125       dsl     char ch;
   2632  1.127       dsl     char *line;
   2633  1.127       dsl     char *line_end;
   2634  1.127       dsl     char *escaped;
   2635  1.127       dsl     char *comment;
   2636  1.127       dsl     char *tp;
   2637  1.125       dsl 
   2638  1.127       dsl     /* Loop through blank lines and comment lines */
   2639  1.125       dsl     for (;;) {
   2640  1.127       dsl 	cf->lineno++;
   2641  1.127       dsl 	line = cf->P_ptr;
   2642  1.127       dsl 	ptr = line;
   2643  1.127       dsl 	line_end = line;
   2644  1.127       dsl 	escaped = NULL;
   2645  1.127       dsl 	comment = NULL;
   2646  1.127       dsl 	for (;;) {
   2647  1.170  dholland 	    if (cf->P_end != NULL && ptr == cf->P_end) {
   2648  1.170  dholland 		/* end of buffer */
   2649  1.170  dholland 		ch = 0;
   2650  1.170  dholland 		break;
   2651  1.170  dholland 	    }
   2652  1.127       dsl 	    ch = *ptr;
   2653  1.127       dsl 	    if (ch == 0 || (ch == '\\' && ptr[1] == 0)) {
   2654  1.127       dsl 		if (cf->P_end == NULL)
   2655  1.127       dsl 		    /* End of string (aka for loop) data */
   2656  1.127       dsl 		    break;
   2657  1.190       sjg 		/* see if there is more we can parse */
   2658  1.190       sjg 		while (ptr++ < cf->P_end) {
   2659  1.190       sjg 		    if ((ch = *ptr) == '\n') {
   2660  1.190       sjg 			if (ptr > line && ptr[-1] == '\\')
   2661  1.190       sjg 			    continue;
   2662  1.190       sjg 			Parse_Error(PARSE_WARNING,
   2663  1.190       sjg 			    "Zero byte read from file, skipping rest of line.");
   2664  1.190       sjg 			break;
   2665  1.190       sjg 		    }
   2666  1.190       sjg 		}
   2667  1.170  dholland 		if (cf->nextbuf != NULL) {
   2668  1.170  dholland 		    /*
   2669  1.170  dholland 		     * End of this buffer; return EOF and outer logic
   2670  1.170  dholland 		     * will get the next one. (eww)
   2671  1.170  dholland 		     */
   2672  1.127       dsl 		    break;
   2673  1.127       dsl 		}
   2674  1.170  dholland 		Parse_Error(PARSE_FATAL, "Zero byte read from file");
   2675  1.170  dholland 		return NULL;
   2676  1.127       dsl 	    }
   2677  1.127       dsl 
   2678  1.127       dsl 	    if (ch == '\\') {
   2679  1.127       dsl 		/* Don't treat next character as special, remember first one */
   2680  1.127       dsl 		if (escaped == NULL)
   2681  1.127       dsl 		    escaped = ptr;
   2682  1.127       dsl 		if (ptr[1] == '\n')
   2683  1.127       dsl 		    cf->lineno++;
   2684  1.127       dsl 		ptr += 2;
   2685  1.127       dsl 		line_end = ptr;
   2686  1.127       dsl 		continue;
   2687  1.127       dsl 	    }
   2688  1.127       dsl 	    if (ch == '#' && comment == NULL) {
   2689  1.127       dsl 		/* Remember first '#' for comment stripping */
   2690  1.181       sjg 		/* Unless previous char was '[', as in modifier :[#] */
   2691  1.181       sjg 		if (!(ptr > line && ptr[-1] == '['))
   2692  1.181       sjg 		    comment = line_end;
   2693  1.127       dsl 	    }
   2694  1.127       dsl 	    ptr++;
   2695  1.125       dsl 	    if (ch == '\n')
   2696  1.127       dsl 		break;
   2697  1.290    rillig 	    if (!ch_isspace(ch))
   2698  1.127       dsl 		/* We are not interested in trailing whitespace */
   2699  1.127       dsl 		line_end = ptr;
   2700  1.127       dsl 	}
   2701  1.125       dsl 
   2702  1.127       dsl 	/* Save next 'to be processed' location */
   2703  1.127       dsl 	cf->P_ptr = ptr;
   2704  1.127       dsl 
   2705  1.127       dsl 	/* Check we have a non-comment, non-blank line */
   2706  1.127       dsl 	if (line_end == line || comment == line) {
   2707  1.127       dsl 	    if (ch == 0)
   2708  1.127       dsl 		/* At end of file */
   2709  1.127       dsl 		return NULL;
   2710  1.127       dsl 	    /* Parse another line */
   2711  1.125       dsl 	    continue;
   2712  1.127       dsl 	}
   2713  1.125       dsl 
   2714  1.127       dsl 	/* We now have a line of data */
   2715  1.127       dsl 	*line_end = 0;
   2716   1.27  christos 
   2717  1.127       dsl 	if (flags & PARSE_RAW) {
   2718  1.127       dsl 	    /* Leave '\' (etc) in line buffer (eg 'for' lines) */
   2719  1.127       dsl 	    *length = line_end - line;
   2720  1.127       dsl 	    return line;
   2721  1.127       dsl 	}
   2722    1.5       cgd 
   2723  1.127       dsl 	if (flags & PARSE_SKIP) {
   2724  1.127       dsl 	    /* Completely ignore non-directives */
   2725  1.127       dsl 	    if (line[0] != '.')
   2726  1.127       dsl 		continue;
   2727  1.127       dsl 	    /* We could do more of the .else/.elif/.endif checks here */
   2728  1.127       dsl 	}
   2729  1.127       dsl 	break;
   2730  1.127       dsl     }
   2731    1.5       cgd 
   2732  1.127       dsl     /* Brutally ignore anything after a non-escaped '#' in non-commands */
   2733  1.127       dsl     if (comment != NULL && line[0] != '\t') {
   2734  1.127       dsl 	line_end = comment;
   2735  1.127       dsl 	*line_end = 0;
   2736  1.127       dsl     }
   2737    1.5       cgd 
   2738  1.127       dsl     /* If we didn't see a '\\' then the in-situ data is fine */
   2739  1.127       dsl     if (escaped == NULL) {
   2740  1.127       dsl 	*length = line_end - line;
   2741  1.127       dsl 	return line;
   2742  1.127       dsl     }
   2743    1.5       cgd 
   2744  1.127       dsl     /* Remove escapes from '\n' and '#' */
   2745  1.127       dsl     tp = ptr = escaped;
   2746  1.127       dsl     escaped = line;
   2747  1.127       dsl     for (; ; *tp++ = ch) {
   2748  1.127       dsl 	ch = *ptr++;
   2749  1.127       dsl 	if (ch != '\\') {
   2750  1.127       dsl 	    if (ch == 0)
   2751  1.127       dsl 		break;
   2752  1.127       dsl 	    continue;
   2753  1.127       dsl 	}
   2754    1.5       cgd 
   2755  1.127       dsl 	ch = *ptr++;
   2756  1.127       dsl 	if (ch == 0) {
   2757  1.127       dsl 	    /* Delete '\\' at end of buffer */
   2758  1.127       dsl 	    tp--;
   2759  1.127       dsl 	    break;
   2760  1.127       dsl 	}
   2761   1.27  christos 
   2762  1.130       dsl 	if (ch == '#' && line[0] != '\t')
   2763  1.130       dsl 	    /* Delete '\\' from before '#' on non-command lines */
   2764  1.127       dsl 	    continue;
   2765   1.27  christos 
   2766  1.127       dsl 	if (ch != '\n') {
   2767  1.127       dsl 	    /* Leave '\\' in buffer for later */
   2768  1.127       dsl 	    *tp++ = '\\';
   2769  1.127       dsl 	    /* Make sure we don't delete an escaped ' ' from the line end */
   2770  1.127       dsl 	    escaped = tp + 1;
   2771  1.127       dsl 	    continue;
   2772  1.127       dsl 	}
   2773   1.27  christos 
   2774  1.203     joerg 	/* Escaped '\n' replace following whitespace with a single ' ' */
   2775  1.203     joerg 	while (ptr[0] == ' ' || ptr[0] == '\t')
   2776  1.203     joerg 	    ptr++;
   2777  1.203     joerg 	ch = ' ';
   2778  1.127       dsl     }
   2779   1.27  christos 
   2780  1.127       dsl     /* Delete any trailing spaces - eg from empty continuations */
   2781  1.290    rillig     while (tp > escaped && ch_isspace(tp[-1]))
   2782  1.127       dsl 	tp--;
   2783   1.27  christos 
   2784  1.127       dsl     *tp = 0;
   2785  1.127       dsl     *length = tp - line;
   2786    1.5       cgd     return line;
   2787    1.5       cgd }
   2788    1.1       cgd 
   2789  1.284    rillig /* Read an entire line from the input file. Called only by Parse_File.
   2790    1.1       cgd  *
   2791    1.1       cgd  * Results:
   2792  1.284    rillig  *	A line without its newline.
   2793    1.1       cgd  *
   2794    1.1       cgd  * Side Effects:
   2795    1.1       cgd  *	Only those associated with reading a character
   2796    1.1       cgd  */
   2797    1.1       cgd static char *
   2798   1.84       wiz ParseReadLine(void)
   2799    1.1       cgd {
   2800    1.9       jtc     char 	  *line;    	/* Result */
   2801    1.1       cgd     int	    	  lineLength;	/* Length of result */
   2802   1.95     enami     int	    	  lineno;	/* Saved line # */
   2803  1.151       dsl     int	    	  rval;
   2804    1.1       cgd 
   2805    1.5       cgd     for (;;) {
   2806  1.127       dsl 	line = ParseGetLine(0, &lineLength);
   2807  1.127       dsl 	if (line == NULL)
   2808  1.127       dsl 	    return NULL;
   2809    1.1       cgd 
   2810  1.127       dsl 	if (line[0] != '.')
   2811  1.127       dsl 	    return line;
   2812  1.121       dsl 
   2813  1.121       dsl 	/*
   2814  1.127       dsl 	 * The line might be a conditional. Ask the conditional module
   2815  1.127       dsl 	 * about it and act accordingly
   2816  1.121       dsl 	 */
   2817  1.302    rillig 	switch (Cond_EvalLine(line)) {
   2818  1.127       dsl 	case COND_SKIP:
   2819  1.127       dsl 	    /* Skip to next conditional that evaluates to COND_PARSE.  */
   2820  1.127       dsl 	    do {
   2821  1.127       dsl 		line = ParseGetLine(PARSE_SKIP, &lineLength);
   2822  1.302    rillig 	    } while (line && Cond_EvalLine(line) != COND_PARSE);
   2823  1.127       dsl 	    if (line == NULL)
   2824  1.121       dsl 		break;
   2825  1.127       dsl 	    continue;
   2826  1.127       dsl 	case COND_PARSE:
   2827  1.127       dsl 	    continue;
   2828  1.127       dsl 	case COND_INVALID:    /* Not a conditional line */
   2829  1.151       dsl 	    /* Check for .for loops */
   2830  1.151       dsl 	    rval = For_Eval(line);
   2831  1.151       dsl 	    if (rval == 0)
   2832  1.151       dsl 		/* Not a .for line */
   2833    1.1       cgd 		break;
   2834  1.151       dsl 	    if (rval < 0)
   2835  1.151       dsl 		/* Syntax error - error printed, ignore line */
   2836  1.151       dsl 		continue;
   2837  1.151       dsl 	    /* Start of a .for loop */
   2838  1.127       dsl 	    lineno = curFile->lineno;
   2839  1.151       dsl 	    /* Accumulate loop lines until matching .endfor */
   2840  1.121       dsl 	    do {
   2841  1.127       dsl 		line = ParseGetLine(PARSE_RAW, &lineLength);
   2842  1.121       dsl 		if (line == NULL) {
   2843  1.121       dsl 		    Parse_Error(PARSE_FATAL,
   2844  1.174  dholland 			     "Unexpected end of file in for loop.");
   2845    1.5       cgd 		    break;
   2846  1.121       dsl 		}
   2847  1.151       dsl 	    } while (For_Accum(line));
   2848  1.127       dsl 	    /* Stash each iteration as a new 'input file' */
   2849  1.127       dsl 	    For_Run(lineno);
   2850  1.127       dsl 	    /* Read next line from for-loop buffer */
   2851  1.127       dsl 	    continue;
   2852    1.1       cgd 	}
   2853  1.235    rillig 	return line;
   2854    1.1       cgd     }
   2855    1.1       cgd }
   2856    1.1       cgd 
   2857  1.293    rillig static int
   2858  1.293    rillig SuffEndTransform(void *target, void *unused MAKE_ATTR_UNUSED)
   2859  1.293    rillig {
   2860  1.293    rillig     Suff_EndTransform(target);
   2861  1.293    rillig     return 0;
   2862  1.293    rillig }
   2863  1.293    rillig 
   2864    1.1       cgd /*-
   2865    1.1       cgd  *-----------------------------------------------------------------------
   2866    1.1       cgd  * ParseFinishLine --
   2867    1.1       cgd  *	Handle the end of a dependency group.
   2868    1.1       cgd  *
   2869    1.1       cgd  * Results:
   2870    1.1       cgd  *	Nothing.
   2871    1.1       cgd  *
   2872    1.1       cgd  * Side Effects:
   2873    1.1       cgd  *	inLine set FALSE. 'targets' list destroyed.
   2874    1.1       cgd  *
   2875    1.1       cgd  *-----------------------------------------------------------------------
   2876    1.1       cgd  */
   2877    1.1       cgd static void
   2878   1.84       wiz ParseFinishLine(void)
   2879    1.1       cgd {
   2880    1.1       cgd     if (inLine) {
   2881  1.292    rillig 	if (targets != NULL) {
   2882  1.324    rillig 	    Lst_ForEachUntil(targets, SuffEndTransform, NULL);
   2883  1.268    rillig 	    Lst_Destroy(targets, ParseHasCommands);
   2884  1.263    rillig 	}
   2885    1.9       jtc 	targets = NULL;
   2886    1.1       cgd 	inLine = FALSE;
   2887    1.1       cgd     }
   2888    1.1       cgd }
   2889   1.27  christos 
   2890    1.1       cgd 
   2891  1.297    rillig /* Parse a top-level makefile into its component parts, incorporating them
   2892  1.297    rillig  * into the global dependency graph.
   2893    1.1       cgd  *
   2894   1.84       wiz  * Input:
   2895  1.297    rillig  *	name		The name of the file being read
   2896  1.297    rillig  *	fd		The open file to parse; will be closed at the end
   2897    1.1       cgd  */
   2898    1.1       cgd void
   2899  1.125       dsl Parse_File(const char *name, int fd)
   2900    1.1       cgd {
   2901  1.117       dsl     char	  *cp;		/* pointer into the line */
   2902  1.117       dsl     char          *line;	/* the line we're working on */
   2903  1.170  dholland     struct loadedfile *lf;
   2904  1.170  dholland 
   2905  1.170  dholland     lf = loadfile(name, fd);
   2906    1.1       cgd 
   2907    1.1       cgd     inLine = FALSE;
   2908    1.1       cgd     fatals = 0;
   2909   1.44     aidan 
   2910  1.242    rillig     if (name == NULL)
   2911  1.242    rillig 	name = "(stdin)";
   2912  1.170  dholland 
   2913  1.170  dholland     Parse_SetInput(name, 0, -1, loadedfile_nextbuf, lf);
   2914  1.170  dholland     curFile->lf = lf;
   2915    1.1       cgd 
   2916    1.1       cgd     do {
   2917  1.127       dsl 	for (; (line = ParseReadLine()) != NULL; ) {
   2918  1.120       dsl 	    if (DEBUG(PARSE))
   2919  1.145  christos 		fprintf(debug_file, "ParseReadLine (%d): '%s'\n",
   2920  1.145  christos 			curFile->lineno, line);
   2921    1.1       cgd 	    if (*line == '.') {
   2922    1.1       cgd 		/*
   2923  1.159       dsl 		 * Lines that begin with the special character may be
   2924    1.1       cgd 		 * include or undef directives.
   2925  1.159       dsl 		 * On the other hand they can be suffix rules (.c.o: ...)
   2926  1.159       dsl 		 * or just dependencies for filenames that start '.'.
   2927    1.1       cgd 		 */
   2928  1.290    rillig 		for (cp = line + 1; ch_isspace(*cp); cp++) {
   2929    1.1       cgd 		    continue;
   2930    1.1       cgd 		}
   2931  1.228  christos 		if (IsInclude(cp, FALSE)) {
   2932   1.97  christos 		    ParseDoInclude(cp);
   2933  1.117       dsl 		    continue;
   2934  1.117       dsl 		}
   2935  1.117       dsl 		if (strncmp(cp, "undef", 5) == 0) {
   2936    1.1       cgd 		    char *cp2;
   2937  1.290    rillig 		    for (cp += 5; ch_isspace(*cp); cp++)
   2938    1.1       cgd 			continue;
   2939  1.290    rillig 		    for (cp2 = cp; !ch_isspace(*cp2) && *cp2 != '\0'; cp2++)
   2940    1.1       cgd 			continue;
   2941    1.1       cgd 		    *cp2 = '\0';
   2942    1.1       cgd 		    Var_Delete(cp, VAR_GLOBAL);
   2943  1.117       dsl 		    continue;
   2944  1.136       sjg 		} else if (strncmp(cp, "export", 6) == 0) {
   2945  1.290    rillig 		    for (cp += 6; ch_isspace(*cp); cp++)
   2946  1.136       sjg 			continue;
   2947  1.250    rillig 		    Var_Export(cp, TRUE);
   2948  1.136       sjg 		    continue;
   2949  1.160       sjg 		} else if (strncmp(cp, "unexport", 8) == 0) {
   2950  1.160       sjg 		    Var_UnExport(cp);
   2951  1.160       sjg 		    continue;
   2952  1.161       sjg 		} else if (strncmp(cp, "info", 4) == 0 ||
   2953  1.161       sjg 			   strncmp(cp, "error", 5) == 0 ||
   2954  1.161       sjg 			   strncmp(cp, "warning", 7) == 0) {
   2955  1.164       sjg 		    if (ParseMessage(cp))
   2956  1.164       sjg 			continue;
   2957  1.236    rillig 		}
   2958    1.1       cgd 	    }
   2959   1.27  christos 
   2960    1.6       jtc 	    if (*line == '\t') {
   2961    1.1       cgd 		/*
   2962    1.6       jtc 		 * If a line starts with a tab, it can only hope to be
   2963    1.6       jtc 		 * a creation command.
   2964    1.1       cgd 		 */
   2965  1.133       dsl 		cp = line + 1;
   2966  1.127       dsl 	      shellCommand:
   2967  1.290    rillig 		for (; ch_isspace(*cp); cp++) {
   2968    1.1       cgd 		    continue;
   2969    1.1       cgd 		}
   2970    1.1       cgd 		if (*cp) {
   2971  1.117       dsl 		    if (!inLine)
   2972   1.97  christos 			Parse_Error(PARSE_FATAL,
   2973   1.25  christos 				     "Unassociated shell command \"%s\"",
   2974    1.1       cgd 				     cp);
   2975  1.117       dsl 		    /*
   2976  1.117       dsl 		     * So long as it's not a blank line and we're actually
   2977  1.117       dsl 		     * in a dependency spec, add the command to the list of
   2978  1.117       dsl 		     * commands of all targets in the dependency spec
   2979  1.117       dsl 		     */
   2980  1.129  christos 		    if (targets) {
   2981  1.147     joerg 			cp = bmake_strdup(cp);
   2982  1.324    rillig 			Lst_ForEachUntil(targets, ParseAddCmd, cp);
   2983  1.117       dsl #ifdef CLEANUP
   2984  1.268    rillig 			Lst_Append(targCmds, cp);
   2985  1.117       dsl #endif
   2986  1.129  christos 		    }
   2987    1.1       cgd 		}
   2988  1.117       dsl 		continue;
   2989  1.117       dsl 	    }
   2990  1.117       dsl 
   2991    1.5       cgd #ifdef SYSVINCLUDE
   2992  1.228  christos 	    if (IsSysVInclude(line)) {
   2993    1.5       cgd 		/*
   2994    1.5       cgd 		 * It's an S3/S5-style "include".
   2995    1.5       cgd 		 */
   2996   1.97  christos 		ParseTraditionalInclude(line);
   2997  1.117       dsl 		continue;
   2998  1.117       dsl 	    }
   2999    1.5       cgd #endif
   3000  1.182  christos #ifdef GMAKEEXPORT
   3001  1.290    rillig 	    if (strncmp(line, "export", 6) == 0 && ch_isspace(line[6]) &&
   3002  1.182  christos 		strchr(line, ':') == NULL) {
   3003  1.182  christos 		/*
   3004  1.183       sjg 		 * It's a Gmake "export".
   3005  1.182  christos 		 */
   3006  1.182  christos 		ParseGmakeExport(line);
   3007  1.182  christos 		continue;
   3008  1.182  christos 	    }
   3009  1.182  christos #endif
   3010  1.117       dsl 	    if (Parse_IsVar(line)) {
   3011    1.1       cgd 		ParseFinishLine();
   3012   1.97  christos 		Parse_DoVar(line, VAR_GLOBAL);
   3013  1.117       dsl 		continue;
   3014  1.117       dsl 	    }
   3015  1.117       dsl 
   3016  1.127       dsl #ifndef POSIX
   3017  1.117       dsl 	    /*
   3018  1.117       dsl 	     * To make life easier on novices, if the line is indented we
   3019  1.117       dsl 	     * first make sure the line has a dependency operator in it.
   3020  1.117       dsl 	     * If it doesn't have an operator and we're in a dependency
   3021  1.117       dsl 	     * line's script, we assume it's actually a shell command
   3022  1.117       dsl 	     * and add it to the current list of targets.
   3023  1.117       dsl 	     */
   3024  1.117       dsl 	    cp = line;
   3025  1.290    rillig 	    if (ch_isspace(line[0])) {
   3026  1.290    rillig 		while (ch_isspace(*cp))
   3027  1.117       dsl 		    cp++;
   3028  1.117       dsl 		while (*cp && (ParseIsEscaped(line, cp) ||
   3029  1.242    rillig 			*cp != ':' && *cp != '!')) {
   3030  1.117       dsl 		    cp++;
   3031  1.117       dsl 		}
   3032  1.127       dsl 		if (*cp == '\0') {
   3033  1.127       dsl 		    if (inLine) {
   3034  1.127       dsl 			Parse_Error(PARSE_WARNING,
   3035  1.127       dsl 				     "Shell command needs a leading tab");
   3036  1.127       dsl 			goto shellCommand;
   3037  1.127       dsl 		    }
   3038  1.127       dsl 		}
   3039  1.127       dsl 	    }
   3040   1.11   mycroft #endif
   3041  1.127       dsl 	    ParseFinishLine();
   3042   1.27  christos 
   3043  1.127       dsl 	    /*
   3044  1.127       dsl 	     * For some reason - probably to make the parser impossible -
   3045  1.127       dsl 	     * a ';' can be used to separate commands from dependencies.
   3046  1.158       sjg 	     * Attempt to avoid ';' inside substitution patterns.
   3047  1.127       dsl 	     */
   3048  1.158       sjg 	    {
   3049  1.158       sjg 		int level = 0;
   3050  1.158       sjg 
   3051  1.158       sjg 		for (cp = line; *cp != 0; cp++) {
   3052  1.158       sjg 		    if (*cp == '\\' && cp[1] != 0) {
   3053  1.158       sjg 			cp++;
   3054  1.158       sjg 			continue;
   3055  1.158       sjg 		    }
   3056  1.158       sjg 		    if (*cp == '$' &&
   3057  1.158       sjg 			(cp[1] == '(' || cp[1] == '{')) {
   3058  1.158       sjg 			level++;
   3059  1.158       sjg 			continue;
   3060  1.158       sjg 		    }
   3061  1.158       sjg 		    if (level > 0) {
   3062  1.158       sjg 			if (*cp == ')' || *cp == '}') {
   3063  1.158       sjg 			    level--;
   3064  1.158       sjg 			    continue;
   3065  1.158       sjg 			}
   3066  1.158       sjg 		    } else if (*cp == ';') {
   3067  1.158       sjg 			break;
   3068  1.158       sjg 		    }
   3069  1.117       dsl 		}
   3070  1.117       dsl 	    }
   3071  1.127       dsl 	    if (*cp != 0)
   3072  1.127       dsl 		/* Terminate the dependency list at the ';' */
   3073  1.133       dsl 		*cp++ = 0;
   3074  1.127       dsl 	    else
   3075  1.127       dsl 		cp = NULL;
   3076    1.1       cgd 
   3077  1.127       dsl 	    /*
   3078  1.127       dsl 	     * We now know it's a dependency line so it needs to have all
   3079  1.320    rillig 	     * variables expanded before being parsed.
   3080  1.320    rillig 	     *
   3081  1.320    rillig 	     * XXX: Ideally the dependency line would first be split into
   3082  1.320    rillig 	     * its left-hand side, dependency operator and right-hand side,
   3083  1.320    rillig 	     * and then each side would be expanded on its own.  This would
   3084  1.320    rillig 	     * allow for the left-hand side to allow only defined variables
   3085  1.320    rillig 	     * and to allow variables on the right-hand side to be undefined
   3086  1.320    rillig 	     * as well.
   3087  1.320    rillig 	     *
   3088  1.320    rillig 	     * Parsing the line first would also prevent that targets
   3089  1.320    rillig 	     * generated from variable expressions are interpreted as the
   3090  1.320    rillig 	     * dependency operator, such as in "target${:U:} middle: source",
   3091  1.320    rillig 	     * in which the middle is interpreted as a source, not a target.
   3092  1.127       dsl 	     */
   3093  1.320    rillig 	    {
   3094  1.320    rillig 	        /* In lint mode, allow undefined variables to appear in
   3095  1.320    rillig 	         * dependency lines.
   3096  1.320    rillig 	         *
   3097  1.320    rillig 	         * Ideally, only the right-hand side would allow undefined
   3098  1.320    rillig 	         * variables since it is common to have no dependencies.
   3099  1.320    rillig 	         * Having undefined variables on the left-hand side is more
   3100  1.320    rillig 	         * unusual though.  Since both sides are expanded in a single
   3101  1.320    rillig 	         * pass, there is not much choice what to do here.
   3102  1.320    rillig 	         *
   3103  1.320    rillig 	         * In normal mode, it does not matter whether undefined
   3104  1.320    rillig 	         * variables are allowed or not since as of 2020-09-14,
   3105  1.320    rillig 	         * Var_Parse does not print any parse errors in such a case.
   3106  1.320    rillig 	         * It simply returns the special empty string var_Error,
   3107  1.320    rillig 	         * which cannot be detected in the result of Var_Subst. */
   3108  1.320    rillig 		VarEvalFlags eflags = DEBUG(LINT)
   3109  1.320    rillig 				      ? VARE_WANTRES
   3110  1.320    rillig 				      : VARE_UNDEFERR|VARE_WANTRES;
   3111  1.323    rillig 		(void)Var_Subst(line, VAR_CMD, eflags, &line);
   3112  1.323    rillig 		/* TODO: handle errors */
   3113  1.320    rillig 	    }
   3114   1.27  christos 
   3115  1.117       dsl 	    /*
   3116  1.318    rillig 	     * Need a list for the target nodes
   3117  1.117       dsl 	     */
   3118  1.263    rillig 	    if (targets != NULL)
   3119  1.268    rillig 		Lst_Free(targets);
   3120    1.9       jtc 
   3121  1.252    rillig 	    targets = Lst_Init();
   3122  1.117       dsl 	    inLine = TRUE;
   3123   1.27  christos 
   3124  1.117       dsl 	    ParseDoDependency(line);
   3125  1.127       dsl 	    free(line);
   3126  1.127       dsl 
   3127  1.127       dsl 	    /* If there were commands after a ';', add them now */
   3128  1.127       dsl 	    if (cp != NULL) {
   3129  1.127       dsl 		goto shellCommand;
   3130  1.127       dsl 	    }
   3131    1.1       cgd 	}
   3132    1.1       cgd 	/*
   3133   1.27  christos 	 * Reached EOF, but it may be just EOF of an include file...
   3134    1.1       cgd 	 */
   3135  1.123       dsl     } while (ParseEOF() == CONTINUE);
   3136    1.1       cgd 
   3137    1.1       cgd     if (fatals) {
   3138  1.163       sjg 	(void)fflush(stdout);
   3139   1.63  christos 	(void)fprintf(stderr,
   3140  1.175  dholland 	    "%s: Fatal errors encountered -- cannot continue",
   3141   1.63  christos 	    progname);
   3142  1.161       sjg 	PrintOnError(NULL, NULL);
   3143  1.103  christos 	exit(1);
   3144    1.1       cgd     }
   3145    1.1       cgd }
   3146    1.1       cgd 
   3147    1.1       cgd /*-
   3148    1.1       cgd  *---------------------------------------------------------------------
   3149    1.1       cgd  * Parse_Init --
   3150    1.1       cgd  *	initialize the parsing module
   3151    1.1       cgd  *
   3152    1.1       cgd  * Results:
   3153    1.1       cgd  *	none
   3154    1.1       cgd  *
   3155    1.1       cgd  * Side Effects:
   3156    1.1       cgd  *	the parseIncPath list is initialized...
   3157    1.1       cgd  *---------------------------------------------------------------------
   3158    1.1       cgd  */
   3159    1.5       cgd void
   3160   1.84       wiz Parse_Init(void)
   3161    1.1       cgd {
   3162  1.152       dsl     mainNode = NULL;
   3163  1.252    rillig     parseIncPath = Lst_Init();
   3164  1.252    rillig     sysIncPath = Lst_Init();
   3165  1.252    rillig     defIncPath = Lst_Init();
   3166  1.276    rillig     Stack_Init(&includes);
   3167   1.45   mycroft #ifdef CLEANUP
   3168  1.252    rillig     targCmds = Lst_Init();
   3169   1.45   mycroft #endif
   3170    1.1       cgd }
   3171    1.9       jtc 
   3172    1.9       jtc void
   3173   1.84       wiz Parse_End(void)
   3174    1.9       jtc {
   3175   1.45   mycroft #ifdef CLEANUP
   3176  1.268    rillig     Lst_Destroy(targCmds, free);
   3177    1.9       jtc     if (targets)
   3178  1.268    rillig 	Lst_Free(targets);
   3179  1.268    rillig     Lst_Destroy(defIncPath, Dir_Destroy);
   3180  1.268    rillig     Lst_Destroy(sysIncPath, Dir_Destroy);
   3181  1.268    rillig     Lst_Destroy(parseIncPath, Dir_Destroy);
   3182  1.276    rillig     assert(Stack_IsEmpty(&includes));
   3183  1.276    rillig     Stack_Done(&includes);
   3184   1.45   mycroft #endif
   3185    1.9       jtc }
   3186   1.27  christos 
   3187    1.1       cgd 
   3188    1.1       cgd /*-
   3189    1.1       cgd  *-----------------------------------------------------------------------
   3190    1.1       cgd  * Parse_MainName --
   3191    1.1       cgd  *	Return a Lst of the main target to create for main()'s sake. If
   3192    1.1       cgd  *	no such target exists, we Punt with an obnoxious error message.
   3193    1.1       cgd  *
   3194    1.1       cgd  * Results:
   3195    1.1       cgd  *	A Lst of the single node to create.
   3196    1.1       cgd  *
   3197    1.1       cgd  * Side Effects:
   3198    1.1       cgd  *	None.
   3199    1.1       cgd  *
   3200    1.1       cgd  *-----------------------------------------------------------------------
   3201    1.1       cgd  */
   3202  1.322    rillig GNodeList *
   3203   1.84       wiz Parse_MainName(void)
   3204    1.1       cgd {
   3205  1.322    rillig     GNodeList *mainList;
   3206    1.1       cgd 
   3207  1.252    rillig     mainList = Lst_Init();
   3208    1.1       cgd 
   3209  1.152       dsl     if (mainNode == NULL) {
   3210   1.97  christos 	Punt("no target to make.");
   3211  1.246    rillig 	/*NOTREACHED*/
   3212    1.1       cgd     } else if (mainNode->type & OP_DOUBLEDEP) {
   3213  1.268    rillig 	Lst_Append(mainList, mainNode);
   3214  1.268    rillig 	Lst_AppendAll(mainList, mainNode->cohorts);
   3215    1.1       cgd     }
   3216    1.5       cgd     else
   3217  1.268    rillig 	Lst_Append(mainList, mainNode);
   3218   1.81        pk     Var_Append(".TARGETS", mainNode->name, VAR_GLOBAL);
   3219  1.235    rillig     return mainList;
   3220   1.59  christos }
   3221