Home | History | Annotate | Line # | Download | only in make
var.c revision 1.812
      1 /*	$NetBSD: var.c,v 1.812 2021/02/14 13:46:01 rillig Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1988, 1989, 1990, 1993
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * This code is derived from software contributed to Berkeley by
      8  * Adam de Boor.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  * 3. Neither the name of the University nor the names of its contributors
     19  *    may be used to endorse or promote products derived from this software
     20  *    without specific prior written permission.
     21  *
     22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     32  * SUCH DAMAGE.
     33  */
     34 
     35 /*
     36  * Copyright (c) 1989 by Berkeley Softworks
     37  * All rights reserved.
     38  *
     39  * This code is derived from software contributed to Berkeley by
     40  * Adam de Boor.
     41  *
     42  * Redistribution and use in source and binary forms, with or without
     43  * modification, are permitted provided that the following conditions
     44  * are met:
     45  * 1. Redistributions of source code must retain the above copyright
     46  *    notice, this list of conditions and the following disclaimer.
     47  * 2. Redistributions in binary form must reproduce the above copyright
     48  *    notice, this list of conditions and the following disclaimer in the
     49  *    documentation and/or other materials provided with the distribution.
     50  * 3. All advertising materials mentioning features or use of this software
     51  *    must display the following acknowledgement:
     52  *	This product includes software developed by the University of
     53  *	California, Berkeley and its contributors.
     54  * 4. Neither the name of the University nor the names of its contributors
     55  *    may be used to endorse or promote products derived from this software
     56  *    without specific prior written permission.
     57  *
     58  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     59  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     60  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     61  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     62  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     63  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     64  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     65  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     66  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     67  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     68  * SUCH DAMAGE.
     69  */
     70 
     71 /*
     72  * Handling of variables and the expressions formed from them.
     73  *
     74  * Variables are set using lines of the form VAR=value.  Both the variable
     75  * name and the value can contain references to other variables, by using
     76  * expressions like ${VAR}, ${VAR:Modifiers}, ${${VARNAME}} or ${VAR:${MODS}}.
     77  *
     78  * Interface:
     79  *	Var_Init	Initialize this module.
     80  *
     81  *	Var_End		Clean up the module.
     82  *
     83  *	Var_Set
     84  *	Var_SetExpand
     85  *			Set the value of the variable, creating it if
     86  *			necessary.
     87  *
     88  *	Var_Append
     89  *	Var_AppendExpand
     90  *			Append more characters to the variable, creating it if
     91  *			necessary. A space is placed between the old value and
     92  *			the new one.
     93  *
     94  *	Var_Exists
     95  *	Var_ExistsExpand
     96  *			See if a variable exists.
     97  *
     98  *	Var_Value	Return the unexpanded value of a variable, or NULL if
     99  *			the variable is undefined.
    100  *
    101  *	Var_Subst	Substitute all variable expressions in a string.
    102  *
    103  *	Var_Parse	Parse a variable expression such as ${VAR:Mpattern}.
    104  *
    105  *	Var_Delete
    106  *	Var_DeleteExpand
    107  *			Delete a variable.
    108  *
    109  *	Var_ReexportVars
    110  *			Export some or even all variables to the environment
    111  *			of this process and its child processes.
    112  *
    113  *	Var_Export	Export the variable to the environment of this process
    114  *			and its child processes.
    115  *
    116  *	Var_UnExport	Don't export the variable anymore.
    117  *
    118  * Debugging:
    119  *	Var_Stats	Print out hashing statistics if in -dh mode.
    120  *
    121  *	Var_Dump	Print out all variables defined in the given scope.
    122  *
    123  * XXX: There's a lot of duplication in these functions.
    124  */
    125 
    126 #include <sys/stat.h>
    127 #ifndef NO_REGEX
    128 #include <sys/types.h>
    129 #include <regex.h>
    130 #endif
    131 #include <errno.h>
    132 #include <inttypes.h>
    133 #include <limits.h>
    134 #include <time.h>
    135 
    136 #include "make.h"
    137 #include "dir.h"
    138 #include "job.h"
    139 #include "metachar.h"
    140 
    141 /*	"@(#)var.c	8.3 (Berkeley) 3/19/94" */
    142 MAKE_RCSID("$NetBSD: var.c,v 1.812 2021/02/14 13:46:01 rillig Exp $");
    143 
    144 typedef enum VarFlags {
    145 	VAR_NONE	= 0,
    146 
    147 	/*
    148 	 * The variable's value is currently being used by Var_Parse or
    149 	 * Var_Subst.  This marker is used to avoid endless recursion.
    150 	 */
    151 	VAR_IN_USE = 0x01,
    152 
    153 	/*
    154 	 * The variable comes from the environment.
    155 	 * These variables are not registered in any GNode, therefore they
    156 	 * must be freed as soon as they are not used anymore.
    157 	 */
    158 	VAR_FROM_ENV = 0x02,
    159 
    160 	/*
    161 	 * The variable is exported to the environment, to be used by child
    162 	 * processes.
    163 	 */
    164 	VAR_EXPORTED = 0x10,
    165 
    166 	/*
    167 	 * At the point where this variable was exported, it contained an
    168 	 * unresolved reference to another variable.  Before any child
    169 	 * process is started, it needs to be exported again, in the hope
    170 	 * that the referenced variable can then be resolved.
    171 	 */
    172 	VAR_REEXPORT = 0x20,
    173 
    174 	/* The variable came from the command line. */
    175 	VAR_FROM_CMD = 0x40,
    176 
    177 	/*
    178 	 * The variable value cannot be changed anymore, and the variable
    179 	 * cannot be deleted.  Any attempts to do so are silently ignored,
    180 	 * they are logged with -dv though.
    181 	 */
    182 	VAR_READONLY = 0x80
    183 } VarFlags;
    184 
    185 /*
    186  * Variables are defined using one of the VAR=value assignments.  Their
    187  * value can be queried by expressions such as $V, ${VAR}, or with modifiers
    188  * such as ${VAR:S,from,to,g:Q}.
    189  *
    190  * There are 3 kinds of variables: scope variables, environment variables,
    191  * undefined variables.
    192  *
    193  * Scope variables are stored in a GNode.scope.  The only way to undefine
    194  * a scope variable is using the .undef directive.  In particular, it must
    195  * not be possible to undefine a variable during the evaluation of an
    196  * expression, or Var.name might point nowhere.
    197  *
    198  * Environment variables are temporary.  They are returned by VarFind, and
    199  * after using them, they must be freed using VarFreeEnv.
    200  *
    201  * Undefined variables occur during evaluation of variable expressions such
    202  * as ${UNDEF:Ufallback} in Var_Parse and ApplyModifiers.
    203  */
    204 typedef struct Var {
    205 	/*
    206 	 * The name of the variable, once set, doesn't change anymore.
    207 	 * For scope variables, it aliases the corresponding HashEntry name.
    208 	 * For environment and undefined variables, it is allocated.
    209 	 */
    210 	FStr name;
    211 
    212 	/* The unexpanded value of the variable. */
    213 	Buffer val;
    214 	/* Miscellaneous status flags. */
    215 	VarFlags flags;
    216 } Var;
    217 
    218 /*
    219  * Exporting vars is expensive so skip it if we can
    220  */
    221 typedef enum VarExportedMode {
    222 	VAR_EXPORTED_NONE,
    223 	VAR_EXPORTED_SOME,
    224 	VAR_EXPORTED_ALL
    225 } VarExportedMode;
    226 
    227 typedef enum UnexportWhat {
    228 	UNEXPORT_NAMED,
    229 	UNEXPORT_ALL,
    230 	UNEXPORT_ENV
    231 } UnexportWhat;
    232 
    233 /* Flags for pattern matching in the :S and :C modifiers */
    234 typedef struct VarPatternFlags {
    235 
    236 	/* Replace as often as possible ('g') */
    237 	Boolean subGlobal: 1;
    238 	/* Replace only once ('1') */
    239 	Boolean subOnce: 1;
    240 	/* Match at start of word ('^') */
    241 	Boolean anchorStart: 1;
    242 	/* Match at end of word ('$') */
    243 	Boolean anchorEnd: 1;
    244 } VarPatternFlags;
    245 
    246 /* SepBuf is a string being built from words, interleaved with separators. */
    247 typedef struct SepBuf {
    248 	Buffer buf;
    249 	Boolean needSep;
    250 	/* Usually ' ', but see the ':ts' modifier. */
    251 	char sep;
    252 } SepBuf;
    253 
    254 
    255 ENUM_FLAGS_RTTI_4(VarEvalFlags,
    256 		  VARE_UNDEFERR, VARE_WANTRES, VARE_KEEP_DOLLAR,
    257 		  VARE_KEEP_UNDEF);
    258 
    259 /*
    260  * This lets us tell if we have replaced the original environ
    261  * (which we cannot free).
    262  */
    263 char **savedEnv = NULL;
    264 
    265 /*
    266  * Special return value for Var_Parse, indicating a parse error.  It may be
    267  * caused by an undefined variable, a syntax error in a modifier or
    268  * something entirely different.
    269  */
    270 char var_Error[] = "";
    271 
    272 /*
    273  * Special return value for Var_Parse, indicating an undefined variable in
    274  * a case where VARE_UNDEFERR is not set.  This undefined variable is
    275  * typically a dynamic variable such as ${.TARGET}, whose expansion needs to
    276  * be deferred until it is defined in an actual target.
    277  */
    278 static char varUndefined[] = "";
    279 
    280 /*
    281  * Traditionally this make consumed $$ during := like any other expansion.
    282  * Other make's do not, and this make follows straight since 2016-01-09.
    283  *
    284  * This knob allows controlling the behavior.
    285  * FALSE to consume $$ during := assignment.
    286  * TRUE to preserve $$ during := assignment.
    287  */
    288 #define MAKE_SAVE_DOLLARS ".MAKE.SAVE_DOLLARS"
    289 static Boolean save_dollars = TRUE;
    290 
    291 /*
    292  * A scope collects variable names and their values.
    293  *
    294  * The main scope is SCOPE_GLOBAL, which contains the variables that are set
    295  * in the makefiles.  SCOPE_INTERNAL acts as a fallback for SCOPE_GLOBAL and
    296  * contains some internal make variables.  These internal variables can thus
    297  * be overridden, they can also be restored by undefining the overriding
    298  * variable.
    299  *
    300  * SCOPE_CMDLINE contains variables from the command line arguments.  These
    301  * override variables from SCOPE_GLOBAL.
    302  *
    303  * There is no scope for environment variables, these are generated on-the-fly
    304  * whenever they are referenced.  If there were such a scope, each change to
    305  * environment variables would have to be reflected in that scope, which may
    306  * be simpler or more complex than the current implementation.
    307  *
    308  * Each target has its own scope, containing the 7 target-local variables
    309  * .TARGET, .ALLSRC, etc.  No other variables are in these scopes.
    310  */
    311 
    312 GNode *SCOPE_CMDLINE;
    313 GNode *SCOPE_GLOBAL;
    314 GNode *SCOPE_INTERNAL;
    315 
    316 ENUM_FLAGS_RTTI_6(VarFlags,
    317 		  VAR_IN_USE, VAR_FROM_ENV,
    318 		  VAR_EXPORTED, VAR_REEXPORT, VAR_FROM_CMD, VAR_READONLY);
    319 
    320 static VarExportedMode var_exportedVars = VAR_EXPORTED_NONE;
    321 
    322 
    323 static Var *
    324 VarNew(FStr name, const char *value, VarFlags flags)
    325 {
    326 	size_t value_len = strlen(value);
    327 	Var *var = bmake_malloc(sizeof *var);
    328 	var->name = name;
    329 	Buf_InitSize(&var->val, value_len + 1);
    330 	Buf_AddBytes(&var->val, value, value_len);
    331 	var->flags = flags;
    332 	return var;
    333 }
    334 
    335 static const char *
    336 CanonicalVarname(const char *name)
    337 {
    338 	if (*name == '.' && ch_isupper(name[1])) {
    339 		switch (name[1]) {
    340 		case 'A':
    341 			if (strcmp(name, ".ALLSRC") == 0)
    342 				name = ALLSRC;
    343 			if (strcmp(name, ".ARCHIVE") == 0)
    344 				name = ARCHIVE;
    345 			break;
    346 		case 'I':
    347 			if (strcmp(name, ".IMPSRC") == 0)
    348 				name = IMPSRC;
    349 			break;
    350 		case 'M':
    351 			if (strcmp(name, ".MEMBER") == 0)
    352 				name = MEMBER;
    353 			break;
    354 		case 'O':
    355 			if (strcmp(name, ".OODATE") == 0)
    356 				name = OODATE;
    357 			break;
    358 		case 'P':
    359 			if (strcmp(name, ".PREFIX") == 0)
    360 				name = PREFIX;
    361 			break;
    362 		case 'S':
    363 			if (strcmp(name, ".SHELL") == 0) {
    364 				if (shellPath == NULL)
    365 					Shell_Init();
    366 			}
    367 			break;
    368 		case 'T':
    369 			if (strcmp(name, ".TARGET") == 0)
    370 				name = TARGET;
    371 			break;
    372 		}
    373 	}
    374 
    375 	/* GNU make has an additional alias $^ == ${.ALLSRC}. */
    376 
    377 	return name;
    378 }
    379 
    380 static Var *
    381 GNode_FindVar(GNode *scope, const char *varname, unsigned int hash)
    382 {
    383 	return HashTable_FindValueHash(&scope->vars, varname, hash);
    384 }
    385 
    386 /*
    387  * Find the variable in the scope, and maybe in other scopes as well.
    388  *
    389  * Input:
    390  *	name		name to find, is not expanded any further
    391  *	scope		scope in which to look first
    392  *	elsewhere	TRUE to look in other scopes as well
    393  *
    394  * Results:
    395  *	The found variable, or NULL if the variable does not exist.
    396  *	If the variable is an environment variable, it must be freed using
    397  *	VarFreeEnv after use.
    398  */
    399 static Var *
    400 VarFind(const char *name, GNode *scope, Boolean elsewhere)
    401 {
    402 	Var *var;
    403 	unsigned int nameHash;
    404 
    405 	/*
    406 	 * If the variable name begins with a '.', it could very well be
    407 	 * one of the local ones.  We check the name against all the local
    408 	 * variables and substitute the short version in for 'name' if it
    409 	 * matches one of them.
    410 	 */
    411 	name = CanonicalVarname(name);
    412 	nameHash = Hash_Hash(name);
    413 
    414 	/* First look for the variable in the given scope. */
    415 	var = GNode_FindVar(scope, name, nameHash);
    416 	if (!elsewhere)
    417 		return var;
    418 
    419 	/*
    420 	 * The variable was not found in the given scope.
    421 	 * Now look for it in the other scopes as well.
    422 	 */
    423 	if (var == NULL && scope != SCOPE_CMDLINE)
    424 		var = GNode_FindVar(SCOPE_CMDLINE, name, nameHash);
    425 
    426 	if (!opts.checkEnvFirst && var == NULL && scope != SCOPE_GLOBAL) {
    427 		var = GNode_FindVar(SCOPE_GLOBAL, name, nameHash);
    428 		if (var == NULL && scope != SCOPE_INTERNAL) {
    429 			/* SCOPE_INTERNAL is subordinate to SCOPE_GLOBAL */
    430 			var = GNode_FindVar(SCOPE_INTERNAL, name, nameHash);
    431 		}
    432 	}
    433 
    434 	if (var == NULL) {
    435 		char *env;
    436 
    437 		if ((env = getenv(name)) != NULL) {
    438 			char *varname = bmake_strdup(name);
    439 			return VarNew(FStr_InitOwn(varname), env, VAR_FROM_ENV);
    440 		}
    441 
    442 		if (opts.checkEnvFirst && scope != SCOPE_GLOBAL) {
    443 			var = GNode_FindVar(SCOPE_GLOBAL, name, nameHash);
    444 			if (var == NULL && scope != SCOPE_INTERNAL)
    445 				var = GNode_FindVar(SCOPE_INTERNAL, name,
    446 				    nameHash);
    447 			return var;
    448 		}
    449 
    450 		return NULL;
    451 	}
    452 
    453 	return var;
    454 }
    455 
    456 /*
    457  * If the variable is an environment variable, free it.
    458  *
    459  * Input:
    460  *	v		the variable
    461  *	freeValue	true if the variable value should be freed as well
    462  *
    463  * Results:
    464  *	TRUE if it is an environment variable, FALSE otherwise.
    465  */
    466 static Boolean
    467 VarFreeEnv(Var *v, Boolean freeValue)
    468 {
    469 	if (!(v->flags & VAR_FROM_ENV))
    470 		return FALSE;
    471 
    472 	FStr_Done(&v->name);
    473 	if (freeValue)
    474 		Buf_Done(&v->val);
    475 	else
    476 		Buf_DoneData(&v->val);
    477 	free(v);
    478 	return TRUE;
    479 }
    480 
    481 /*
    482  * Add a new variable of the given name and value to the given scope.
    483  * The name and val arguments are duplicated so they may safely be freed.
    484  */
    485 static void
    486 VarAdd(const char *name, const char *val, GNode *scope, VarSetFlags flags)
    487 {
    488 	HashEntry *he = HashTable_CreateEntry(&scope->vars, name, NULL);
    489 	Var *v = VarNew(FStr_InitRefer(/* aliased to */ he->key), val,
    490 	    flags & VAR_SET_READONLY ? VAR_READONLY : VAR_NONE);
    491 	HashEntry_Set(he, v);
    492 	DEBUG3(VAR, "%s:%s = %s\n", scope->name, name, val);
    493 }
    494 
    495 /*
    496  * Remove a variable from a scope, freeing all related memory as well.
    497  * The variable name is kept as-is, it is not expanded.
    498  */
    499 void
    500 Var_Delete(GNode *scope, const char *varname)
    501 {
    502 	HashEntry *he = HashTable_FindEntry(&scope->vars, varname);
    503 	Var *v;
    504 
    505 	if (he == NULL) {
    506 		DEBUG2(VAR, "%s:delete %s (not found)\n", scope->name, varname);
    507 		return;
    508 	}
    509 
    510 	DEBUG2(VAR, "%s:delete %s\n", scope->name, varname);
    511 	v = HashEntry_Get(he);
    512 	if (v->flags & VAR_EXPORTED)
    513 		unsetenv(v->name.str);
    514 	if (strcmp(v->name.str, MAKE_EXPORTED) == 0)
    515 		var_exportedVars = VAR_EXPORTED_NONE;
    516 	assert(v->name.freeIt == NULL);
    517 	HashTable_DeleteEntry(&scope->vars, he);
    518 	Buf_Done(&v->val);
    519 	free(v);
    520 }
    521 
    522 /*
    523  * Remove a variable from a scope, freeing all related memory as well.
    524  * The variable name is expanded once.
    525  */
    526 void
    527 Var_DeleteExpand(GNode *scope, const char *name)
    528 {
    529 	FStr varname = FStr_InitRefer(name);
    530 
    531 	if (strchr(varname.str, '$') != NULL) {
    532 		char *expanded;
    533 		(void)Var_Subst(varname.str, SCOPE_GLOBAL, VARE_WANTRES,
    534 		    &expanded);
    535 		/* TODO: handle errors */
    536 		varname = FStr_InitOwn(expanded);
    537 	}
    538 
    539 	Var_Delete(scope, varname.str);
    540 	FStr_Done(&varname);
    541 }
    542 
    543 /*
    544  * Undefine one or more variables from the global scope.
    545  * The argument is expanded exactly once and then split into words.
    546  */
    547 void
    548 Var_Undef(const char *arg)
    549 {
    550 	VarParseResult vpr;
    551 	char *expanded;
    552 	Words varnames;
    553 	size_t i;
    554 
    555 	if (arg[0] == '\0') {
    556 		Parse_Error(PARSE_FATAL,
    557 		    "The .undef directive requires an argument");
    558 		return;
    559 	}
    560 
    561 	vpr = Var_Subst(arg, SCOPE_GLOBAL, VARE_WANTRES, &expanded);
    562 	if (vpr != VPR_OK) {
    563 		Parse_Error(PARSE_FATAL,
    564 		    "Error in variable names to be undefined");
    565 		return;
    566 	}
    567 
    568 	varnames = Str_Words(expanded, FALSE);
    569 	if (varnames.len == 1 && varnames.words[0][0] == '\0')
    570 		varnames.len = 0;
    571 
    572 	for (i = 0; i < varnames.len; i++) {
    573 		const char *varname = varnames.words[i];
    574 		Global_Delete(varname);
    575 	}
    576 
    577 	Words_Free(varnames);
    578 	free(expanded);
    579 }
    580 
    581 static Boolean
    582 MayExport(const char *name)
    583 {
    584 	if (name[0] == '.')
    585 		return FALSE;	/* skip internals */
    586 	if (name[0] == '-')
    587 		return FALSE;	/* skip misnamed variables */
    588 	if (name[1] == '\0') {
    589 		/*
    590 		 * A single char.
    591 		 * If it is one of the variables that should only appear in
    592 		 * local scope, skip it, else we can get Var_Subst
    593 		 * into a loop.
    594 		 */
    595 		switch (name[0]) {
    596 		case '@':
    597 		case '%':
    598 		case '*':
    599 		case '!':
    600 			return FALSE;
    601 		}
    602 	}
    603 	return TRUE;
    604 }
    605 
    606 static Boolean
    607 ExportVarEnv(Var *v)
    608 {
    609 	const char *name = v->name.str;
    610 	char *val = v->val.data;
    611 	char *expr;
    612 
    613 	if ((v->flags & VAR_EXPORTED) && !(v->flags & VAR_REEXPORT))
    614 		return FALSE;	/* nothing to do */
    615 
    616 	if (strchr(val, '$') == NULL) {
    617 		if (!(v->flags & VAR_EXPORTED))
    618 			setenv(name, val, 1);
    619 		return TRUE;
    620 	}
    621 
    622 	if (v->flags & VAR_IN_USE) {
    623 		/*
    624 		 * We recursed while exporting in a child.
    625 		 * This isn't going to end well, just skip it.
    626 		 */
    627 		return FALSE;
    628 	}
    629 
    630 	/* XXX: name is injected without escaping it */
    631 	expr = str_concat3("${", name, "}");
    632 	(void)Var_Subst(expr, SCOPE_GLOBAL, VARE_WANTRES, &val);
    633 	/* TODO: handle errors */
    634 	setenv(name, val, 1);
    635 	free(val);
    636 	free(expr);
    637 	return TRUE;
    638 }
    639 
    640 static Boolean
    641 ExportVarPlain(Var *v)
    642 {
    643 	if (strchr(v->val.data, '$') == NULL) {
    644 		setenv(v->name.str, v->val.data, 1);
    645 		v->flags |= VAR_EXPORTED;
    646 		v->flags &= ~(unsigned)VAR_REEXPORT;
    647 		return TRUE;
    648 	}
    649 
    650 	/*
    651 	 * Flag the variable as something we need to re-export.
    652 	 * No point actually exporting it now though,
    653 	 * the child process can do it at the last minute.
    654 	 */
    655 	v->flags |= VAR_EXPORTED | VAR_REEXPORT;
    656 	return TRUE;
    657 }
    658 
    659 static Boolean
    660 ExportVarLiteral(Var *v)
    661 {
    662 	if ((v->flags & VAR_EXPORTED) && !(v->flags & VAR_REEXPORT))
    663 		return FALSE;
    664 
    665 	if (!(v->flags & VAR_EXPORTED))
    666 		setenv(v->name.str, v->val.data, 1);
    667 
    668 	return TRUE;
    669 }
    670 
    671 /*
    672  * Export a single variable.
    673  *
    674  * We ignore make internal variables (those which start with '.').
    675  * Also we jump through some hoops to avoid calling setenv
    676  * more than necessary since it can leak.
    677  * We only manipulate flags of vars if 'parent' is set.
    678  */
    679 static Boolean
    680 ExportVar(const char *name, VarExportMode mode)
    681 {
    682 	Var *v;
    683 
    684 	if (!MayExport(name))
    685 		return FALSE;
    686 
    687 	v = VarFind(name, SCOPE_GLOBAL, FALSE);
    688 	if (v == NULL)
    689 		return FALSE;
    690 
    691 	if (mode == VEM_ENV)
    692 		return ExportVarEnv(v);
    693 	else if (mode == VEM_PLAIN)
    694 		return ExportVarPlain(v);
    695 	else
    696 		return ExportVarLiteral(v);
    697 }
    698 
    699 /*
    700  * Actually export the variables that have been marked as needing to be
    701  * re-exported.
    702  */
    703 void
    704 Var_ReexportVars(void)
    705 {
    706 	char *xvarnames;
    707 
    708 	/*
    709 	 * Several make implementations support this sort of mechanism for
    710 	 * tracking recursion - but each uses a different name.
    711 	 * We allow the makefiles to update MAKELEVEL and ensure
    712 	 * children see a correctly incremented value.
    713 	 */
    714 	char tmp[BUFSIZ];
    715 	snprintf(tmp, sizeof tmp, "%d", makelevel + 1);
    716 	setenv(MAKE_LEVEL_ENV, tmp, 1);
    717 
    718 	if (var_exportedVars == VAR_EXPORTED_NONE)
    719 		return;
    720 
    721 	if (var_exportedVars == VAR_EXPORTED_ALL) {
    722 		HashIter hi;
    723 
    724 		/* Ouch! Exporting all variables at once is crazy... */
    725 		HashIter_Init(&hi, &SCOPE_GLOBAL->vars);
    726 		while (HashIter_Next(&hi) != NULL) {
    727 			Var *var = hi.entry->value;
    728 			ExportVar(var->name.str, VEM_ENV);
    729 		}
    730 		return;
    731 	}
    732 
    733 	(void)Var_Subst("${" MAKE_EXPORTED ":O:u}", SCOPE_GLOBAL, VARE_WANTRES,
    734 	    &xvarnames);
    735 	/* TODO: handle errors */
    736 	if (xvarnames[0] != '\0') {
    737 		Words varnames = Str_Words(xvarnames, FALSE);
    738 		size_t i;
    739 
    740 		for (i = 0; i < varnames.len; i++)
    741 			ExportVar(varnames.words[i], VEM_ENV);
    742 		Words_Free(varnames);
    743 	}
    744 	free(xvarnames);
    745 }
    746 
    747 static void
    748 ExportVars(const char *varnames, Boolean isExport, VarExportMode mode)
    749 {
    750 	Words words = Str_Words(varnames, FALSE);
    751 	size_t i;
    752 
    753 	if (words.len == 1 && words.words[0][0] == '\0')
    754 		words.len = 0;
    755 
    756 	for (i = 0; i < words.len; i++) {
    757 		const char *varname = words.words[i];
    758 		if (!ExportVar(varname, mode))
    759 			continue;
    760 
    761 		if (var_exportedVars == VAR_EXPORTED_NONE)
    762 			var_exportedVars = VAR_EXPORTED_SOME;
    763 
    764 		if (isExport && mode == VEM_PLAIN)
    765 			Global_Append(MAKE_EXPORTED, varname);
    766 	}
    767 	Words_Free(words);
    768 }
    769 
    770 static void
    771 ExportVarsExpand(const char *uvarnames, Boolean isExport, VarExportMode mode)
    772 {
    773 	char *xvarnames;
    774 
    775 	(void)Var_Subst(uvarnames, SCOPE_GLOBAL, VARE_WANTRES, &xvarnames);
    776 	/* TODO: handle errors */
    777 	ExportVars(xvarnames, isExport, mode);
    778 	free(xvarnames);
    779 }
    780 
    781 /* Export the named variables, or all variables. */
    782 void
    783 Var_Export(VarExportMode mode, const char *varnames)
    784 {
    785 	if (mode == VEM_PLAIN && varnames[0] == '\0') {
    786 		var_exportedVars = VAR_EXPORTED_ALL; /* use with caution! */
    787 		return;
    788 	}
    789 
    790 	ExportVarsExpand(varnames, TRUE, mode);
    791 }
    792 
    793 void
    794 Var_ExportVars(const char *varnames)
    795 {
    796 	ExportVarsExpand(varnames, FALSE, VEM_PLAIN);
    797 }
    798 
    799 
    800 extern char **environ;
    801 
    802 static void
    803 ClearEnv(void)
    804 {
    805 	const char *cp;
    806 	char **newenv;
    807 
    808 	cp = getenv(MAKE_LEVEL_ENV);	/* we should preserve this */
    809 	if (environ == savedEnv) {
    810 		/* we have been here before! */
    811 		newenv = bmake_realloc(environ, 2 * sizeof(char *));
    812 	} else {
    813 		if (savedEnv != NULL) {
    814 			free(savedEnv);
    815 			savedEnv = NULL;
    816 		}
    817 		newenv = bmake_malloc(2 * sizeof(char *));
    818 	}
    819 
    820 	/* Note: we cannot safely free() the original environ. */
    821 	environ = savedEnv = newenv;
    822 	newenv[0] = NULL;
    823 	newenv[1] = NULL;
    824 	if (cp != NULL && *cp != '\0')
    825 		setenv(MAKE_LEVEL_ENV, cp, 1);
    826 }
    827 
    828 static void
    829 GetVarnamesToUnexport(Boolean isEnv, const char *arg,
    830 		      FStr *out_varnames, UnexportWhat *out_what)
    831 {
    832 	UnexportWhat what;
    833 	FStr varnames = FStr_InitRefer("");
    834 
    835 	if (isEnv) {
    836 		if (arg[0] != '\0') {
    837 			Parse_Error(PARSE_FATAL,
    838 			    "The directive .unexport-env does not take "
    839 			    "arguments");
    840 		}
    841 		what = UNEXPORT_ENV;
    842 
    843 	} else {
    844 		what = arg[0] != '\0' ? UNEXPORT_NAMED : UNEXPORT_ALL;
    845 		if (what == UNEXPORT_NAMED)
    846 			varnames = FStr_InitRefer(arg);
    847 	}
    848 
    849 	if (what != UNEXPORT_NAMED) {
    850 		char *expanded;
    851 		/* Using .MAKE.EXPORTED */
    852 		(void)Var_Subst("${" MAKE_EXPORTED ":O:u}", SCOPE_GLOBAL,
    853 		    VARE_WANTRES, &expanded);
    854 		/* TODO: handle errors */
    855 		varnames = FStr_InitOwn(expanded);
    856 	}
    857 
    858 	*out_varnames = varnames;
    859 	*out_what = what;
    860 }
    861 
    862 static void
    863 UnexportVar(const char *varname, UnexportWhat what)
    864 {
    865 	Var *v = VarFind(varname, SCOPE_GLOBAL, FALSE);
    866 	if (v == NULL) {
    867 		DEBUG1(VAR, "Not unexporting \"%s\" (not found)\n", varname);
    868 		return;
    869 	}
    870 
    871 	DEBUG1(VAR, "Unexporting \"%s\"\n", varname);
    872 	if (what != UNEXPORT_ENV &&
    873 	    (v->flags & VAR_EXPORTED) && !(v->flags & VAR_REEXPORT))
    874 		unsetenv(v->name.str);
    875 	v->flags &= ~(unsigned)(VAR_EXPORTED | VAR_REEXPORT);
    876 
    877 	if (what == UNEXPORT_NAMED) {
    878 		/* Remove the variable names from .MAKE.EXPORTED. */
    879 		/* XXX: v->name is injected without escaping it */
    880 		char *expr = str_concat3("${" MAKE_EXPORTED ":N",
    881 		    v->name.str, "}");
    882 		char *cp;
    883 		(void)Var_Subst(expr, SCOPE_GLOBAL, VARE_WANTRES, &cp);
    884 		/* TODO: handle errors */
    885 		Global_Set(MAKE_EXPORTED, cp);
    886 		free(cp);
    887 		free(expr);
    888 	}
    889 }
    890 
    891 static void
    892 UnexportVars(FStr *varnames, UnexportWhat what)
    893 {
    894 	size_t i;
    895 	Words words;
    896 
    897 	if (what == UNEXPORT_ENV)
    898 		ClearEnv();
    899 
    900 	words = Str_Words(varnames->str, FALSE);
    901 	for (i = 0; i < words.len; i++) {
    902 		const char *varname = words.words[i];
    903 		UnexportVar(varname, what);
    904 	}
    905 	Words_Free(words);
    906 
    907 	if (what != UNEXPORT_NAMED)
    908 		Global_Delete(MAKE_EXPORTED);
    909 }
    910 
    911 /*
    912  * This is called when .unexport[-env] is seen.
    913  *
    914  * str must have the form "unexport[-env] varname...".
    915  */
    916 void
    917 Var_UnExport(Boolean isEnv, const char *arg)
    918 {
    919 	UnexportWhat what;
    920 	FStr varnames;
    921 
    922 	GetVarnamesToUnexport(isEnv, arg, &varnames, &what);
    923 	UnexportVars(&varnames, what);
    924 	FStr_Done(&varnames);
    925 }
    926 
    927 /* Set the variable to the value; the name is not expanded. */
    928 void
    929 Var_SetWithFlags(GNode *scope, const char *name, const char *val,
    930 		 VarSetFlags flags)
    931 {
    932 	Var *v;
    933 
    934 	assert(val != NULL);
    935 	if (name[0] == '\0') {
    936 		DEBUG0(VAR, "SetVar: variable name is empty - ignored\n");
    937 		return;
    938 	}
    939 
    940 	if (scope == SCOPE_GLOBAL) {
    941 		v = VarFind(name, SCOPE_CMDLINE, FALSE);
    942 		if (v != NULL) {
    943 			if (v->flags & VAR_FROM_CMD) {
    944 				DEBUG3(VAR, "%s:%s = %s ignored!\n",
    945 				    scope->name, name, val);
    946 				return;
    947 			}
    948 			VarFreeEnv(v, TRUE);
    949 		}
    950 	}
    951 
    952 	/*
    953 	 * Only look for a variable in the given scope since anything set
    954 	 * here will override anything in a lower scope, so there's not much
    955 	 * point in searching them all just to save a bit of memory...
    956 	 */
    957 	v = VarFind(name, scope, FALSE);
    958 	if (v == NULL) {
    959 		if (scope == SCOPE_CMDLINE && !(flags & VAR_SET_NO_EXPORT)) {
    960 			/*
    961 			 * This var would normally prevent the same name being
    962 			 * added to SCOPE_GLOBAL, so delete it from there if
    963 			 * needed. Otherwise -V name may show the wrong value.
    964 			 */
    965 			/* XXX: name is expanded for the second time */
    966 			Var_DeleteExpand(SCOPE_GLOBAL, name);
    967 		}
    968 		VarAdd(name, val, scope, flags);
    969 	} else {
    970 		if ((v->flags & VAR_READONLY) && !(flags & VAR_SET_READONLY)) {
    971 			DEBUG3(VAR, "%s:%s = %s ignored (read-only)\n",
    972 			    scope->name, name, val);
    973 			return;
    974 		}
    975 		Buf_Empty(&v->val);
    976 		Buf_AddStr(&v->val, val);
    977 
    978 		DEBUG3(VAR, "%s:%s = %s\n", scope->name, name, val);
    979 		if (v->flags & VAR_EXPORTED)
    980 			ExportVar(name, VEM_PLAIN);
    981 	}
    982 	/*
    983 	 * Any variables given on the command line are automatically exported
    984 	 * to the environment (as per POSIX standard)
    985 	 * Other than internals.
    986 	 */
    987 	if (scope == SCOPE_CMDLINE && !(flags & VAR_SET_NO_EXPORT) &&
    988 	    name[0] != '.') {
    989 		if (v == NULL)
    990 			v = VarFind(name, scope, FALSE); /* we just added it */
    991 		v->flags |= VAR_FROM_CMD;
    992 
    993 		/*
    994 		 * If requested, don't export these in the environment
    995 		 * individually.  We still put them in MAKEOVERRIDES so
    996 		 * that the command-line settings continue to override
    997 		 * Makefile settings.
    998 		 */
    999 		if (!opts.varNoExportEnv)
   1000 			setenv(name, val, 1);
   1001 
   1002 		Global_Append(MAKEOVERRIDES, name);
   1003 	}
   1004 	if (name[0] == '.' && strcmp(name, MAKE_SAVE_DOLLARS) == 0)
   1005 		save_dollars = ParseBoolean(val, save_dollars);
   1006 
   1007 	if (v != NULL)
   1008 		VarFreeEnv(v, TRUE);
   1009 }
   1010 
   1011 /* See Var_Set for documentation. */
   1012 void
   1013 Var_SetExpandWithFlags(GNode *scope, const char *name, const char *val,
   1014 		       VarSetFlags flags)
   1015 {
   1016 	const char *unexpanded_name = name;
   1017 	FStr varname = FStr_InitRefer(name);
   1018 
   1019 	assert(val != NULL);
   1020 
   1021 	if (strchr(varname.str, '$') != NULL) {
   1022 		char *expanded;
   1023 		(void)Var_Subst(varname.str, scope, VARE_WANTRES, &expanded);
   1024 		/* TODO: handle errors */
   1025 		varname = FStr_InitOwn(expanded);
   1026 	}
   1027 
   1028 	if (varname.str[0] == '\0') {
   1029 		DEBUG2(VAR, "Var_Set(\"%s\", \"%s\", ...) "
   1030 			    "name expands to empty string - ignored\n",
   1031 		    unexpanded_name, val);
   1032 	} else
   1033 		Var_SetWithFlags(scope, varname.str, val, flags);
   1034 
   1035 	FStr_Done(&varname);
   1036 }
   1037 
   1038 void
   1039 Var_Set(GNode *scope, const char *name, const char *val)
   1040 {
   1041 	Var_SetWithFlags(scope, name, val, VAR_SET_NONE);
   1042 }
   1043 
   1044 /*
   1045  * Set the variable name to the value val in the given scope.
   1046  *
   1047  * If the variable doesn't yet exist, it is created.
   1048  * Otherwise the new value overwrites and replaces the old value.
   1049  *
   1050  * Input:
   1051  *	name		name of the variable to set, is expanded once
   1052  *	val		value to give to the variable
   1053  *	scope		scope in which to set it
   1054  */
   1055 void
   1056 Var_SetExpand(GNode *scope, const char *name, const char *val)
   1057 {
   1058 	Var_SetExpandWithFlags(scope, name, val, VAR_SET_NONE);
   1059 }
   1060 
   1061 void
   1062 Global_Set(const char *name, const char *value)
   1063 {
   1064 	Var_Set(SCOPE_GLOBAL, name, value);
   1065 }
   1066 
   1067 void
   1068 Global_SetExpand(const char *name, const char *value)
   1069 {
   1070 	Var_SetExpand(SCOPE_GLOBAL, name, value);
   1071 }
   1072 
   1073 void
   1074 Global_Delete(const char *name)
   1075 {
   1076 	Var_Delete(SCOPE_GLOBAL, name);
   1077 }
   1078 
   1079 /*
   1080  * Append the value to the named variable.
   1081  *
   1082  * If the variable doesn't exist, it is created.  Otherwise a single space
   1083  * and the given value are appended.
   1084  */
   1085 void
   1086 Var_Append(GNode *scope, const char *name, const char *val)
   1087 {
   1088 	Var *v;
   1089 
   1090 	v = VarFind(name, scope, scope == SCOPE_GLOBAL);
   1091 
   1092 	if (v == NULL) {
   1093 		Var_SetWithFlags(scope, name, val, VAR_SET_NONE);
   1094 	} else if (v->flags & VAR_READONLY) {
   1095 		DEBUG1(VAR, "Ignoring append to %s since it is read-only\n",
   1096 		    name);
   1097 	} else if (scope == SCOPE_CMDLINE || !(v->flags & VAR_FROM_CMD)) {
   1098 		Buf_AddByte(&v->val, ' ');
   1099 		Buf_AddStr(&v->val, val);
   1100 
   1101 		DEBUG3(VAR, "%s:%s = %s\n", scope->name, name, v->val.data);
   1102 
   1103 		if (v->flags & VAR_FROM_ENV) {
   1104 			/*
   1105 			 * If the original variable came from the environment,
   1106 			 * we have to install it in the global scope (we
   1107 			 * could place it in the environment, but then we
   1108 			 * should provide a way to export other variables...)
   1109 			 */
   1110 			v->flags &= ~(unsigned)VAR_FROM_ENV;
   1111 			/*
   1112 			 * This is the only place where a variable is
   1113 			 * created whose v->name is not the same as
   1114 			 * scope->vars->key.
   1115 			 */
   1116 			HashTable_Set(&scope->vars, name, v);
   1117 		}
   1118 	}
   1119 }
   1120 
   1121 /*
   1122  * The variable of the given name has the given value appended to it in the
   1123  * given scope.
   1124  *
   1125  * If the variable doesn't exist, it is created. Otherwise the strings are
   1126  * concatenated, with a space in between.
   1127  *
   1128  * Input:
   1129  *	name		name of the variable to modify, is expanded once
   1130  *	val		string to append to it
   1131  *	scope		scope in which this should occur
   1132  *
   1133  * Notes:
   1134  *	Only if the variable is being sought in the global scope is the
   1135  *	environment searched.
   1136  *	XXX: Knows its calling circumstances in that if called with scope
   1137  *	an actual target, it will only search that scope since only
   1138  *	a local variable could be being appended to. This is actually
   1139  *	a big win and must be tolerated.
   1140  */
   1141 void
   1142 Var_AppendExpand(GNode *scope, const char *name, const char *val)
   1143 {
   1144 	char *name_freeIt = NULL;
   1145 
   1146 	assert(val != NULL);
   1147 
   1148 	if (strchr(name, '$') != NULL) {
   1149 		const char *unexpanded_name = name;
   1150 		(void)Var_Subst(name, scope, VARE_WANTRES, &name_freeIt);
   1151 		/* TODO: handle errors */
   1152 		name = name_freeIt;
   1153 		if (name[0] == '\0') {
   1154 			/* TODO: update function name in the debug message */
   1155 			DEBUG2(VAR, "Var_Append(\"%s\", \"%s\", ...) "
   1156 				    "name expands to empty string - ignored\n",
   1157 			    unexpanded_name, val);
   1158 			free(name_freeIt);
   1159 			return;
   1160 		}
   1161 	}
   1162 
   1163 	Var_Append(scope, name, val);
   1164 
   1165 	free(name_freeIt);
   1166 }
   1167 
   1168 void
   1169 Global_Append(const char *name, const char *value)
   1170 {
   1171 	Var_Append(SCOPE_GLOBAL, name, value);
   1172 }
   1173 
   1174 Boolean
   1175 Var_Exists(GNode *scope, const char *name)
   1176 {
   1177 	Var *v = VarFind(name, scope, TRUE);
   1178 	if (v == NULL)
   1179 		return FALSE;
   1180 
   1181 	(void)VarFreeEnv(v, TRUE);
   1182 	return TRUE;
   1183 }
   1184 
   1185 /*
   1186  * See if the given variable exists, in the given scope or in other
   1187  * fallback scopes.
   1188  *
   1189  * Input:
   1190  *	name		Variable to find, is expanded once
   1191  *	scope		Scope in which to start search
   1192  */
   1193 Boolean
   1194 Var_ExistsExpand(GNode *scope, const char *name)
   1195 {
   1196 	FStr varname = FStr_InitRefer(name);
   1197 	Boolean exists;
   1198 
   1199 	if (strchr(varname.str, '$') != NULL) {
   1200 		char *expanded;
   1201 		(void)Var_Subst(varname.str, scope, VARE_WANTRES, &expanded);
   1202 		/* TODO: handle errors */
   1203 		varname = FStr_InitOwn(expanded);
   1204 	}
   1205 
   1206 	exists = Var_Exists(scope, varname.str);
   1207 	FStr_Done(&varname);
   1208 	return exists;
   1209 }
   1210 
   1211 /*
   1212  * Return the unexpanded value of the given variable in the given scope,
   1213  * or the usual scopes.
   1214  *
   1215  * Input:
   1216  *	name		name to find, is not expanded any further
   1217  *	scope		scope in which to search for it
   1218  *
   1219  * Results:
   1220  *	The value if the variable exists, NULL if it doesn't.
   1221  *	If the returned value is not NULL, the caller must free
   1222  *	out_freeIt when the returned value is no longer needed.
   1223  */
   1224 FStr
   1225 Var_Value(GNode *scope, const char *name)
   1226 {
   1227 	Var *v = VarFind(name, scope, TRUE);
   1228 	char *value;
   1229 
   1230 	if (v == NULL)
   1231 		return FStr_InitRefer(NULL);
   1232 
   1233 	value = v->val.data;
   1234 	return VarFreeEnv(v, FALSE)
   1235 	    ? FStr_InitOwn(value)
   1236 	    : FStr_InitRefer(value);
   1237 }
   1238 
   1239 /*
   1240  * Return the unexpanded variable value from this node, without trying to look
   1241  * up the variable in any other scope.
   1242  */
   1243 const char *
   1244 GNode_ValueDirect(GNode *gn, const char *name)
   1245 {
   1246 	Var *v = VarFind(name, gn, FALSE);
   1247 	return v != NULL ? v->val.data : NULL;
   1248 }
   1249 
   1250 
   1251 static void
   1252 SepBuf_Init(SepBuf *buf, char sep)
   1253 {
   1254 	Buf_InitSize(&buf->buf, 32);
   1255 	buf->needSep = FALSE;
   1256 	buf->sep = sep;
   1257 }
   1258 
   1259 static void
   1260 SepBuf_Sep(SepBuf *buf)
   1261 {
   1262 	buf->needSep = TRUE;
   1263 }
   1264 
   1265 static void
   1266 SepBuf_AddBytes(SepBuf *buf, const char *mem, size_t mem_size)
   1267 {
   1268 	if (mem_size == 0)
   1269 		return;
   1270 	if (buf->needSep && buf->sep != '\0') {
   1271 		Buf_AddByte(&buf->buf, buf->sep);
   1272 		buf->needSep = FALSE;
   1273 	}
   1274 	Buf_AddBytes(&buf->buf, mem, mem_size);
   1275 }
   1276 
   1277 static void
   1278 SepBuf_AddBytesBetween(SepBuf *buf, const char *start, const char *end)
   1279 {
   1280 	SepBuf_AddBytes(buf, start, (size_t)(end - start));
   1281 }
   1282 
   1283 static void
   1284 SepBuf_AddStr(SepBuf *buf, const char *str)
   1285 {
   1286 	SepBuf_AddBytes(buf, str, strlen(str));
   1287 }
   1288 
   1289 static char *
   1290 SepBuf_DoneData(SepBuf *buf)
   1291 {
   1292 	return Buf_DoneData(&buf->buf);
   1293 }
   1294 
   1295 
   1296 /*
   1297  * This callback for ModifyWords gets a single word from a variable expression
   1298  * and typically adds a modification of this word to the buffer. It may also
   1299  * do nothing or add several words.
   1300  *
   1301  * For example, in ${:Ua b c:M*2}, the callback is called 3 times, once for
   1302  * each word of "a b c".
   1303  */
   1304 typedef void (*ModifyWordsCallback)(const char *word, SepBuf *buf, void *data);
   1305 
   1306 
   1307 /*
   1308  * Callback for ModifyWords to implement the :H modifier.
   1309  * Add the dirname of the given word to the buffer.
   1310  */
   1311 /*ARGSUSED*/
   1312 static void
   1313 ModifyWord_Head(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
   1314 {
   1315 	const char *slash = strrchr(word, '/');
   1316 	if (slash != NULL)
   1317 		SepBuf_AddBytesBetween(buf, word, slash);
   1318 	else
   1319 		SepBuf_AddStr(buf, ".");
   1320 }
   1321 
   1322 /*
   1323  * Callback for ModifyWords to implement the :T modifier.
   1324  * Add the basename of the given word to the buffer.
   1325  */
   1326 /*ARGSUSED*/
   1327 static void
   1328 ModifyWord_Tail(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
   1329 {
   1330 	SepBuf_AddStr(buf, str_basename(word));
   1331 }
   1332 
   1333 /*
   1334  * Callback for ModifyWords to implement the :E modifier.
   1335  * Add the filename suffix of the given word to the buffer, if it exists.
   1336  */
   1337 /*ARGSUSED*/
   1338 static void
   1339 ModifyWord_Suffix(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
   1340 {
   1341 	const char *lastDot = strrchr(word, '.');
   1342 	if (lastDot != NULL)
   1343 		SepBuf_AddStr(buf, lastDot + 1);
   1344 }
   1345 
   1346 /*
   1347  * Callback for ModifyWords to implement the :R modifier.
   1348  * Add the basename of the given word to the buffer.
   1349  */
   1350 /*ARGSUSED*/
   1351 static void
   1352 ModifyWord_Root(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
   1353 {
   1354 	const char *lastDot = strrchr(word, '.');
   1355 	size_t len = lastDot != NULL ? (size_t)(lastDot - word) : strlen(word);
   1356 	SepBuf_AddBytes(buf, word, len);
   1357 }
   1358 
   1359 /*
   1360  * Callback for ModifyWords to implement the :M modifier.
   1361  * Place the word in the buffer if it matches the given pattern.
   1362  */
   1363 static void
   1364 ModifyWord_Match(const char *word, SepBuf *buf, void *data)
   1365 {
   1366 	const char *pattern = data;
   1367 	DEBUG2(VAR, "VarMatch [%s] [%s]\n", word, pattern);
   1368 	if (Str_Match(word, pattern))
   1369 		SepBuf_AddStr(buf, word);
   1370 }
   1371 
   1372 /*
   1373  * Callback for ModifyWords to implement the :N modifier.
   1374  * Place the word in the buffer if it doesn't match the given pattern.
   1375  */
   1376 static void
   1377 ModifyWord_NoMatch(const char *word, SepBuf *buf, void *data)
   1378 {
   1379 	const char *pattern = data;
   1380 	if (!Str_Match(word, pattern))
   1381 		SepBuf_AddStr(buf, word);
   1382 }
   1383 
   1384 #ifdef SYSVVARSUB
   1385 
   1386 /*
   1387  * Check word against pattern for a match (% is a wildcard).
   1388  *
   1389  * Input:
   1390  *	word		Word to examine
   1391  *	pattern		Pattern to examine against
   1392  *
   1393  * Results:
   1394  *	Returns the start of the match, or NULL.
   1395  *	out_match_len returns the length of the match, if any.
   1396  *	out_hasPercent returns whether the pattern contains a percent.
   1397  */
   1398 static const char *
   1399 SysVMatch(const char *word, const char *pattern,
   1400 	  size_t *out_match_len, Boolean *out_hasPercent)
   1401 {
   1402 	const char *p = pattern;
   1403 	const char *w = word;
   1404 	const char *percent;
   1405 	size_t w_len;
   1406 	size_t p_len;
   1407 	const char *w_tail;
   1408 
   1409 	*out_hasPercent = FALSE;
   1410 	percent = strchr(p, '%');
   1411 	if (percent != NULL) {	/* ${VAR:...%...=...} */
   1412 		*out_hasPercent = TRUE;
   1413 		if (w[0] == '\0')
   1414 			return NULL;	/* empty word does not match pattern */
   1415 
   1416 		/* check that the prefix matches */
   1417 		for (; p != percent && *w != '\0' && *w == *p; w++, p++)
   1418 			continue;
   1419 		if (p != percent)
   1420 			return NULL;	/* No match */
   1421 
   1422 		p++;		/* Skip the percent */
   1423 		if (*p == '\0') {
   1424 			/* No more pattern, return the rest of the string */
   1425 			*out_match_len = strlen(w);
   1426 			return w;
   1427 		}
   1428 	}
   1429 
   1430 	/* Test whether the tail matches */
   1431 	w_len = strlen(w);
   1432 	p_len = strlen(p);
   1433 	if (w_len < p_len)
   1434 		return NULL;
   1435 
   1436 	w_tail = w + w_len - p_len;
   1437 	if (memcmp(p, w_tail, p_len) != 0)
   1438 		return NULL;
   1439 
   1440 	*out_match_len = (size_t)(w_tail - w);
   1441 	return w;
   1442 }
   1443 
   1444 struct ModifyWord_SYSVSubstArgs {
   1445 	GNode *scope;
   1446 	const char *lhs;
   1447 	const char *rhs;
   1448 };
   1449 
   1450 /* Callback for ModifyWords to implement the :%.from=%.to modifier. */
   1451 static void
   1452 ModifyWord_SYSVSubst(const char *word, SepBuf *buf, void *data)
   1453 {
   1454 	const struct ModifyWord_SYSVSubstArgs *args = data;
   1455 	char *rhs_expanded;
   1456 	const char *rhs;
   1457 	const char *percent;
   1458 
   1459 	size_t match_len;
   1460 	Boolean lhsPercent;
   1461 	const char *match = SysVMatch(word, args->lhs, &match_len, &lhsPercent);
   1462 	if (match == NULL) {
   1463 		SepBuf_AddStr(buf, word);
   1464 		return;
   1465 	}
   1466 
   1467 	/*
   1468 	 * Append rhs to the buffer, substituting the first '%' with the
   1469 	 * match, but only if the lhs had a '%' as well.
   1470 	 */
   1471 
   1472 	(void)Var_Subst(args->rhs, args->scope, VARE_WANTRES, &rhs_expanded);
   1473 	/* TODO: handle errors */
   1474 
   1475 	rhs = rhs_expanded;
   1476 	percent = strchr(rhs, '%');
   1477 
   1478 	if (percent != NULL && lhsPercent) {
   1479 		/* Copy the prefix of the replacement pattern */
   1480 		SepBuf_AddBytesBetween(buf, rhs, percent);
   1481 		rhs = percent + 1;
   1482 	}
   1483 	if (percent != NULL || !lhsPercent)
   1484 		SepBuf_AddBytes(buf, match, match_len);
   1485 
   1486 	/* Append the suffix of the replacement pattern */
   1487 	SepBuf_AddStr(buf, rhs);
   1488 
   1489 	free(rhs_expanded);
   1490 }
   1491 #endif
   1492 
   1493 
   1494 struct ModifyWord_SubstArgs {
   1495 	const char *lhs;
   1496 	size_t lhsLen;
   1497 	const char *rhs;
   1498 	size_t rhsLen;
   1499 	VarPatternFlags pflags;
   1500 	Boolean matched;
   1501 };
   1502 
   1503 /*
   1504  * Callback for ModifyWords to implement the :S,from,to, modifier.
   1505  * Perform a string substitution on the given word.
   1506  */
   1507 static void
   1508 ModifyWord_Subst(const char *word, SepBuf *buf, void *data)
   1509 {
   1510 	size_t wordLen = strlen(word);
   1511 	struct ModifyWord_SubstArgs *args = data;
   1512 	const char *match;
   1513 
   1514 	if (args->pflags.subOnce && args->matched)
   1515 		goto nosub;
   1516 
   1517 	if (args->pflags.anchorStart) {
   1518 		if (wordLen < args->lhsLen ||
   1519 		    memcmp(word, args->lhs, args->lhsLen) != 0)
   1520 			goto nosub;
   1521 
   1522 		if ((args->pflags.anchorEnd) && wordLen != args->lhsLen)
   1523 			goto nosub;
   1524 
   1525 		/* :S,^prefix,replacement, or :S,^whole$,replacement, */
   1526 		SepBuf_AddBytes(buf, args->rhs, args->rhsLen);
   1527 		SepBuf_AddBytes(buf, word + args->lhsLen,
   1528 		    wordLen - args->lhsLen);
   1529 		args->matched = TRUE;
   1530 		return;
   1531 	}
   1532 
   1533 	if (args->pflags.anchorEnd) {
   1534 		const char *start;
   1535 
   1536 		if (wordLen < args->lhsLen)
   1537 			goto nosub;
   1538 
   1539 		start = word + (wordLen - args->lhsLen);
   1540 		if (memcmp(start, args->lhs, args->lhsLen) != 0)
   1541 			goto nosub;
   1542 
   1543 		/* :S,suffix$,replacement, */
   1544 		SepBuf_AddBytesBetween(buf, word, start);
   1545 		SepBuf_AddBytes(buf, args->rhs, args->rhsLen);
   1546 		args->matched = TRUE;
   1547 		return;
   1548 	}
   1549 
   1550 	if (args->lhs[0] == '\0')
   1551 		goto nosub;
   1552 
   1553 	/* unanchored case, may match more than once */
   1554 	while ((match = strstr(word, args->lhs)) != NULL) {
   1555 		SepBuf_AddBytesBetween(buf, word, match);
   1556 		SepBuf_AddBytes(buf, args->rhs, args->rhsLen);
   1557 		args->matched = TRUE;
   1558 		wordLen -= (size_t)(match - word) + args->lhsLen;
   1559 		word += (size_t)(match - word) + args->lhsLen;
   1560 		if (wordLen == 0 || !args->pflags.subGlobal)
   1561 			break;
   1562 	}
   1563 nosub:
   1564 	SepBuf_AddBytes(buf, word, wordLen);
   1565 }
   1566 
   1567 #ifndef NO_REGEX
   1568 /* Print the error caused by a regcomp or regexec call. */
   1569 static void
   1570 VarREError(int reerr, const regex_t *pat, const char *str)
   1571 {
   1572 	size_t errlen = regerror(reerr, pat, NULL, 0);
   1573 	char *errbuf = bmake_malloc(errlen);
   1574 	regerror(reerr, pat, errbuf, errlen);
   1575 	Error("%s: %s", str, errbuf);
   1576 	free(errbuf);
   1577 }
   1578 
   1579 struct ModifyWord_SubstRegexArgs {
   1580 	regex_t re;
   1581 	size_t nsub;
   1582 	char *replace;
   1583 	VarPatternFlags pflags;
   1584 	Boolean matched;
   1585 };
   1586 
   1587 /*
   1588  * Callback for ModifyWords to implement the :C/from/to/ modifier.
   1589  * Perform a regex substitution on the given word.
   1590  */
   1591 static void
   1592 ModifyWord_SubstRegex(const char *word, SepBuf *buf, void *data)
   1593 {
   1594 	struct ModifyWord_SubstRegexArgs *args = data;
   1595 	int xrv;
   1596 	const char *wp = word;
   1597 	char *rp;
   1598 	int flags = 0;
   1599 	regmatch_t m[10];
   1600 
   1601 	if (args->pflags.subOnce && args->matched)
   1602 		goto nosub;
   1603 
   1604 tryagain:
   1605 	xrv = regexec(&args->re, wp, args->nsub, m, flags);
   1606 
   1607 	switch (xrv) {
   1608 	case 0:
   1609 		args->matched = TRUE;
   1610 		SepBuf_AddBytes(buf, wp, (size_t)m[0].rm_so);
   1611 
   1612 		for (rp = args->replace; *rp != '\0'; rp++) {
   1613 			if (*rp == '\\' && (rp[1] == '&' || rp[1] == '\\')) {
   1614 				SepBuf_AddBytes(buf, rp + 1, 1);
   1615 				rp++;
   1616 				continue;
   1617 			}
   1618 
   1619 			if (*rp == '&') {
   1620 				SepBuf_AddBytesBetween(buf,
   1621 				    wp + m[0].rm_so, wp + m[0].rm_eo);
   1622 				continue;
   1623 			}
   1624 
   1625 			if (*rp != '\\' || !ch_isdigit(rp[1])) {
   1626 				SepBuf_AddBytes(buf, rp, 1);
   1627 				continue;
   1628 			}
   1629 
   1630 			{	/* \0 to \9 backreference */
   1631 				size_t n = (size_t)(rp[1] - '0');
   1632 				rp++;
   1633 
   1634 				if (n >= args->nsub) {
   1635 					Error("No subexpression \\%u",
   1636 					    (unsigned)n);
   1637 				} else if (m[n].rm_so == -1) {
   1638 					Error(
   1639 					    "No match for subexpression \\%u",
   1640 					    (unsigned)n);
   1641 				} else {
   1642 					SepBuf_AddBytesBetween(buf,
   1643 					    wp + m[n].rm_so, wp + m[n].rm_eo);
   1644 				}
   1645 			}
   1646 		}
   1647 
   1648 		wp += m[0].rm_eo;
   1649 		if (args->pflags.subGlobal) {
   1650 			flags |= REG_NOTBOL;
   1651 			if (m[0].rm_so == 0 && m[0].rm_eo == 0) {
   1652 				SepBuf_AddBytes(buf, wp, 1);
   1653 				wp++;
   1654 			}
   1655 			if (*wp != '\0')
   1656 				goto tryagain;
   1657 		}
   1658 		if (*wp != '\0')
   1659 			SepBuf_AddStr(buf, wp);
   1660 		break;
   1661 	default:
   1662 		VarREError(xrv, &args->re, "Unexpected regex error");
   1663 		/* FALLTHROUGH */
   1664 	case REG_NOMATCH:
   1665 	nosub:
   1666 		SepBuf_AddStr(buf, wp);
   1667 		break;
   1668 	}
   1669 }
   1670 #endif
   1671 
   1672 
   1673 struct ModifyWord_LoopArgs {
   1674 	GNode *scope;
   1675 	char *tvar;		/* name of temporary variable */
   1676 	char *str;		/* string to expand */
   1677 	VarEvalFlags eflags;
   1678 };
   1679 
   1680 /* Callback for ModifyWords to implement the :@var (at) ...@ modifier of ODE make. */
   1681 static void
   1682 ModifyWord_Loop(const char *word, SepBuf *buf, void *data)
   1683 {
   1684 	const struct ModifyWord_LoopArgs *args;
   1685 	char *s;
   1686 
   1687 	if (word[0] == '\0')
   1688 		return;
   1689 
   1690 	args = data;
   1691 	/* XXX: The variable name should not be expanded here. */
   1692 	Var_SetExpandWithFlags(args->scope, args->tvar, word,
   1693 	    VAR_SET_NO_EXPORT);
   1694 	(void)Var_Subst(args->str, args->scope, args->eflags, &s);
   1695 	/* TODO: handle errors */
   1696 
   1697 	DEBUG4(VAR, "ModifyWord_Loop: "
   1698 		    "in \"%s\", replace \"%s\" with \"%s\" to \"%s\"\n",
   1699 	    word, args->tvar, args->str, s);
   1700 
   1701 	if (s[0] == '\n' || Buf_EndsWith(&buf->buf, '\n'))
   1702 		buf->needSep = FALSE;
   1703 	SepBuf_AddStr(buf, s);
   1704 	free(s);
   1705 }
   1706 
   1707 
   1708 /*
   1709  * The :[first..last] modifier selects words from the expression.
   1710  * It can also reverse the words.
   1711  */
   1712 static char *
   1713 VarSelectWords(char sep, Boolean oneBigWord, const char *str, int first,
   1714 	       int last)
   1715 {
   1716 	Words words;
   1717 	int len, start, end, step;
   1718 	int i;
   1719 
   1720 	SepBuf buf;
   1721 	SepBuf_Init(&buf, sep);
   1722 
   1723 	if (oneBigWord) {
   1724 		/* fake what Str_Words() would do if there were only one word */
   1725 		words.len = 1;
   1726 		words.words = bmake_malloc(
   1727 		    (words.len + 1) * sizeof(words.words[0]));
   1728 		words.freeIt = bmake_strdup(str);
   1729 		words.words[0] = words.freeIt;
   1730 		words.words[1] = NULL;
   1731 	} else {
   1732 		words = Str_Words(str, FALSE);
   1733 	}
   1734 
   1735 	/*
   1736 	 * Now sanitize the given range.  If first or last are negative,
   1737 	 * convert them to the positive equivalents (-1 gets converted to len,
   1738 	 * -2 gets converted to (len - 1), etc.).
   1739 	 */
   1740 	len = (int)words.len;
   1741 	if (first < 0)
   1742 		first += len + 1;
   1743 	if (last < 0)
   1744 		last += len + 1;
   1745 
   1746 	/* We avoid scanning more of the list than we need to. */
   1747 	if (first > last) {
   1748 		start = (first > len ? len : first) - 1;
   1749 		end = last < 1 ? 0 : last - 1;
   1750 		step = -1;
   1751 	} else {
   1752 		start = first < 1 ? 0 : first - 1;
   1753 		end = last > len ? len : last;
   1754 		step = 1;
   1755 	}
   1756 
   1757 	for (i = start; (step < 0) == (i >= end); i += step) {
   1758 		SepBuf_AddStr(&buf, words.words[i]);
   1759 		SepBuf_Sep(&buf);
   1760 	}
   1761 
   1762 	Words_Free(words);
   1763 
   1764 	return SepBuf_DoneData(&buf);
   1765 }
   1766 
   1767 
   1768 /*
   1769  * Callback for ModifyWords to implement the :tA modifier.
   1770  * Replace each word with the result of realpath() if successful.
   1771  */
   1772 /*ARGSUSED*/
   1773 static void
   1774 ModifyWord_Realpath(const char *word, SepBuf *buf, void *data MAKE_ATTR_UNUSED)
   1775 {
   1776 	struct stat st;
   1777 	char rbuf[MAXPATHLEN];
   1778 
   1779 	const char *rp = cached_realpath(word, rbuf);
   1780 	if (rp != NULL && *rp == '/' && stat(rp, &st) == 0)
   1781 		word = rp;
   1782 
   1783 	SepBuf_AddStr(buf, word);
   1784 }
   1785 
   1786 /*
   1787  * Modify each of the words of the passed string using the given function.
   1788  *
   1789  * Input:
   1790  *	str		String whose words should be modified
   1791  *	modifyWord	Function that modifies a single word
   1792  *	modifyWord_args Custom arguments for modifyWord
   1793  *
   1794  * Results:
   1795  *	A string of all the words modified appropriately.
   1796  */
   1797 static char *
   1798 ModifyWords(const char *str,
   1799 	    ModifyWordsCallback modifyWord, void *modifyWord_args,
   1800 	    Boolean oneBigWord, char sep)
   1801 {
   1802 	SepBuf result;
   1803 	Words words;
   1804 	size_t i;
   1805 
   1806 	if (oneBigWord) {
   1807 		SepBuf_Init(&result, sep);
   1808 		modifyWord(str, &result, modifyWord_args);
   1809 		return SepBuf_DoneData(&result);
   1810 	}
   1811 
   1812 	SepBuf_Init(&result, sep);
   1813 
   1814 	words = Str_Words(str, FALSE);
   1815 
   1816 	DEBUG2(VAR, "ModifyWords: split \"%s\" into %u words\n",
   1817 	    str, (unsigned)words.len);
   1818 
   1819 	for (i = 0; i < words.len; i++) {
   1820 		modifyWord(words.words[i], &result, modifyWord_args);
   1821 		if (result.buf.len > 0)
   1822 			SepBuf_Sep(&result);
   1823 	}
   1824 
   1825 	Words_Free(words);
   1826 
   1827 	return SepBuf_DoneData(&result);
   1828 }
   1829 
   1830 
   1831 static char *
   1832 Words_JoinFree(Words words)
   1833 {
   1834 	Buffer buf;
   1835 	size_t i;
   1836 
   1837 	Buf_Init(&buf);
   1838 
   1839 	for (i = 0; i < words.len; i++) {
   1840 		if (i != 0) {
   1841 			/* XXX: Use st->sep instead of ' ', for consistency. */
   1842 			Buf_AddByte(&buf, ' ');
   1843 		}
   1844 		Buf_AddStr(&buf, words.words[i]);
   1845 	}
   1846 
   1847 	Words_Free(words);
   1848 
   1849 	return Buf_DoneData(&buf);
   1850 }
   1851 
   1852 /* Remove adjacent duplicate words. */
   1853 static char *
   1854 VarUniq(const char *str)
   1855 {
   1856 	Words words = Str_Words(str, FALSE);
   1857 
   1858 	if (words.len > 1) {
   1859 		size_t i, j;
   1860 		for (j = 0, i = 1; i < words.len; i++)
   1861 			if (strcmp(words.words[i], words.words[j]) != 0 &&
   1862 			    (++j != i))
   1863 				words.words[j] = words.words[i];
   1864 		words.len = j + 1;
   1865 	}
   1866 
   1867 	return Words_JoinFree(words);
   1868 }
   1869 
   1870 
   1871 /*
   1872  * Quote shell meta-characters and space characters in the string.
   1873  * If quoteDollar is set, also quote and double any '$' characters.
   1874  */
   1875 static char *
   1876 VarQuote(const char *str, Boolean quoteDollar)
   1877 {
   1878 	Buffer buf;
   1879 	Buf_Init(&buf);
   1880 
   1881 	for (; *str != '\0'; str++) {
   1882 		if (*str == '\n') {
   1883 			const char *newline = Shell_GetNewline();
   1884 			if (newline == NULL)
   1885 				newline = "\\\n";
   1886 			Buf_AddStr(&buf, newline);
   1887 			continue;
   1888 		}
   1889 		if (ch_isspace(*str) || is_shell_metachar((unsigned char)*str))
   1890 			Buf_AddByte(&buf, '\\');
   1891 		Buf_AddByte(&buf, *str);
   1892 		if (quoteDollar && *str == '$')
   1893 			Buf_AddStr(&buf, "\\$");
   1894 	}
   1895 
   1896 	return Buf_DoneData(&buf);
   1897 }
   1898 
   1899 /*
   1900  * Compute the 32-bit hash of the given string, using the MurmurHash3
   1901  * algorithm. Output is encoded as 8 hex digits, in Little Endian order.
   1902  */
   1903 static char *
   1904 VarHash(const char *str)
   1905 {
   1906 	static const char hexdigits[16] = "0123456789abcdef";
   1907 	const unsigned char *ustr = (const unsigned char *)str;
   1908 
   1909 	uint32_t h = 0x971e137bU;
   1910 	uint32_t c1 = 0x95543787U;
   1911 	uint32_t c2 = 0x2ad7eb25U;
   1912 	size_t len2 = strlen(str);
   1913 
   1914 	char *buf;
   1915 	size_t i;
   1916 
   1917 	size_t len;
   1918 	for (len = len2; len != 0;) {
   1919 		uint32_t k = 0;
   1920 		switch (len) {
   1921 		default:
   1922 			k = ((uint32_t)ustr[3] << 24) |
   1923 			    ((uint32_t)ustr[2] << 16) |
   1924 			    ((uint32_t)ustr[1] << 8) |
   1925 			    (uint32_t)ustr[0];
   1926 			len -= 4;
   1927 			ustr += 4;
   1928 			break;
   1929 		case 3:
   1930 			k |= (uint32_t)ustr[2] << 16;
   1931 			/* FALLTHROUGH */
   1932 		case 2:
   1933 			k |= (uint32_t)ustr[1] << 8;
   1934 			/* FALLTHROUGH */
   1935 		case 1:
   1936 			k |= (uint32_t)ustr[0];
   1937 			len = 0;
   1938 		}
   1939 		c1 = c1 * 5 + 0x7b7d159cU;
   1940 		c2 = c2 * 5 + 0x6bce6396U;
   1941 		k *= c1;
   1942 		k = (k << 11) ^ (k >> 21);
   1943 		k *= c2;
   1944 		h = (h << 13) ^ (h >> 19);
   1945 		h = h * 5 + 0x52dce729U;
   1946 		h ^= k;
   1947 	}
   1948 	h ^= (uint32_t)len2;
   1949 	h *= 0x85ebca6b;
   1950 	h ^= h >> 13;
   1951 	h *= 0xc2b2ae35;
   1952 	h ^= h >> 16;
   1953 
   1954 	buf = bmake_malloc(9);
   1955 	for (i = 0; i < 8; i++) {
   1956 		buf[i] = hexdigits[h & 0x0f];
   1957 		h >>= 4;
   1958 	}
   1959 	buf[8] = '\0';
   1960 	return buf;
   1961 }
   1962 
   1963 static char *
   1964 VarStrftime(const char *fmt, Boolean zulu, time_t tim)
   1965 {
   1966 	char buf[BUFSIZ];
   1967 
   1968 	if (tim == 0)
   1969 		time(&tim);
   1970 	if (*fmt == '\0')
   1971 		fmt = "%c";
   1972 	strftime(buf, sizeof buf, fmt, zulu ? gmtime(&tim) : localtime(&tim));
   1973 
   1974 	buf[sizeof buf - 1] = '\0';
   1975 	return bmake_strdup(buf);
   1976 }
   1977 
   1978 /*
   1979  * The ApplyModifier functions take an expression that is being evaluated.
   1980  * Their task is to apply a single modifier to the expression.
   1981  * To do this, they parse the modifier and its parameters from pp and apply
   1982  * the parsed modifier to the current value of the expression, generating a
   1983  * new value from it.
   1984  *
   1985  * The modifier typically lasts until the next ':', or a closing '}' or ')'
   1986  * (taken from st->endc), or the end of the string (parse error).
   1987  *
   1988  * The high-level behavior of these functions is:
   1989  *
   1990  * 1. parse the modifier
   1991  * 2. evaluate the modifier
   1992  * 3. housekeeping
   1993  *
   1994  * Parsing the modifier
   1995  *
   1996  * If parsing succeeds, the parsing position *pp is updated to point to the
   1997  * first character following the modifier, which typically is either ':' or
   1998  * st->endc.  The modifier doesn't have to check for this delimiter character,
   1999  * this is done by ApplyModifiers.
   2000  *
   2001  * XXX: As of 2020-11-15, some modifiers such as :S, :C, :P, :L do not
   2002  * need to be followed by a ':' or endc; this was an unintended mistake.
   2003  *
   2004  * If parsing fails because of a missing delimiter (as in the :S, :C or :@
   2005  * modifiers), return AMR_CLEANUP.
   2006  *
   2007  * If parsing fails because the modifier is unknown, return AMR_UNKNOWN to
   2008  * try the SysV modifier ${VAR:from=to} as fallback.  This should only be
   2009  * done as long as there have been no side effects from evaluating nested
   2010  * variables, to avoid evaluating them more than once.  In this case, the
   2011  * parsing position may or may not be updated.  (XXX: Why not? The original
   2012  * parsing position is well-known in ApplyModifiers.)
   2013  *
   2014  * If parsing fails and the SysV modifier ${VAR:from=to} should not be used
   2015  * as a fallback, either issue an error message using Error or Parse_Error
   2016  * and then return AMR_CLEANUP, or return AMR_BAD for the default error
   2017  * message.  Both of these return values will stop processing the variable
   2018  * expression.  (XXX: As of 2020-08-23, evaluation of the whole string
   2019  * continues nevertheless after skipping a few bytes, which essentially is
   2020  * undefined behavior.  Not in the sense of C, but still it's impossible to
   2021  * predict what happens in the parser.)
   2022  *
   2023  * Evaluating the modifier
   2024  *
   2025  * After parsing, the modifier is evaluated.  The side effects from evaluating
   2026  * nested variable expressions in the modifier text often already happen
   2027  * during parsing though.
   2028  *
   2029  * Evaluating the modifier usually takes the current value of the variable
   2030  * expression from st->val, or the variable name from st->var->name and stores
   2031  * the result in st->newVal.
   2032  *
   2033  * If evaluating fails (as of 2020-08-23), an error message is printed using
   2034  * Error.  This function has no side-effects, it really just prints the error
   2035  * message.  Processing the expression continues as if everything were ok.
   2036  * XXX: This should be fixed by adding proper error handling to Var_Subst,
   2037  * Var_Parse, ApplyModifiers and ModifyWords.
   2038  *
   2039  * Housekeeping
   2040  *
   2041  * Some modifiers such as :D and :U turn undefined expressions into defined
   2042  * expressions (see VEF_UNDEF, VEF_DEF).
   2043  *
   2044  * Some modifiers need to free some memory.
   2045  */
   2046 
   2047 typedef enum VarExprStatus {
   2048 	/* The variable expression is based in a regular, defined variable. */
   2049 	VES_NONE,
   2050 	/* The variable expression is based on an undefined variable. */
   2051 	VES_UNDEF,
   2052 	/*
   2053 	 * The variable expression started as an undefined expression, but one
   2054 	 * of the modifiers (such as :D or :U) has turned the expression from
   2055 	 * undefined to defined.
   2056 	 */
   2057 	VES_DEF
   2058 } VarExprStatus;
   2059 
   2060 static const char * const VarExprStatus_Name[] = {
   2061 	    "none",
   2062 	    "VES_UNDEF",
   2063 	    "VES_DEF"
   2064 };
   2065 
   2066 typedef struct ApplyModifiersState {
   2067 	/* '\0' or '{' or '(' */
   2068 	const char startc;
   2069 	/* '\0' or '}' or ')' */
   2070 	const char endc;
   2071 	Var *const var;
   2072 	GNode *const scope;
   2073 	const VarEvalFlags eflags;
   2074 	/*
   2075 	 * The new value of the expression, after applying the modifier,
   2076 	 * never NULL.
   2077 	 */
   2078 	FStr newVal;
   2079 	/* Word separator in expansions (see the :ts modifier). */
   2080 	char sep;
   2081 	/*
   2082 	 * TRUE if some modifiers that otherwise split the variable value
   2083 	 * into words, like :S and :C, treat the variable value as a single
   2084 	 * big word, possibly containing spaces.
   2085 	 */
   2086 	Boolean oneBigWord;
   2087 	VarExprStatus exprStatus;
   2088 } ApplyModifiersState;
   2089 
   2090 typedef ApplyModifiersState Expr;
   2091 
   2092 static void
   2093 Expr_Define(Expr *expr)
   2094 {
   2095 	if (expr->exprStatus == VES_UNDEF)
   2096 		expr->exprStatus = VES_DEF;
   2097 }
   2098 
   2099 typedef enum ApplyModifierResult {
   2100 	/* Continue parsing */
   2101 	AMR_OK,
   2102 	/* Not a match, try other modifiers as well */
   2103 	AMR_UNKNOWN,
   2104 	/* Error out with "Bad modifier" message */
   2105 	AMR_BAD,
   2106 	/* Error out without error message */
   2107 	AMR_CLEANUP
   2108 } ApplyModifierResult;
   2109 
   2110 /*
   2111  * Allow backslashes to escape the delimiter, $, and \, but don't touch other
   2112  * backslashes.
   2113  */
   2114 static Boolean
   2115 IsEscapedModifierPart(const char *p, char delim,
   2116 		      struct ModifyWord_SubstArgs *subst)
   2117 {
   2118 	if (p[0] != '\\')
   2119 		return FALSE;
   2120 	if (p[1] == delim || p[1] == '\\' || p[1] == '$')
   2121 		return TRUE;
   2122 	return p[1] == '&' && subst != NULL;
   2123 }
   2124 
   2125 /* See ParseModifierPart */
   2126 static VarParseResult
   2127 ParseModifierPartSubst(
   2128     const char **pp,
   2129     char delim,
   2130     VarEvalFlags eflags,
   2131     ApplyModifiersState *st,
   2132     char **out_part,
   2133     /* Optionally stores the length of the returned string, just to save
   2134      * another strlen call. */
   2135     size_t *out_length,
   2136     /* For the first part of the :S modifier, sets the VARP_ANCHOR_END flag
   2137      * if the last character of the pattern is a $. */
   2138     VarPatternFlags *out_pflags,
   2139     /* For the second part of the :S modifier, allow ampersands to be
   2140      * escaped and replace unescaped ampersands with subst->lhs. */
   2141     struct ModifyWord_SubstArgs *subst
   2142 )
   2143 {
   2144 	Buffer buf;
   2145 	const char *p;
   2146 
   2147 	Buf_Init(&buf);
   2148 
   2149 	/*
   2150 	 * Skim through until the matching delimiter is found; pick up
   2151 	 * variable expressions on the way.
   2152 	 */
   2153 	p = *pp;
   2154 	while (*p != '\0' && *p != delim) {
   2155 		const char *varstart;
   2156 
   2157 		if (IsEscapedModifierPart(p, delim, subst)) {
   2158 			Buf_AddByte(&buf, p[1]);
   2159 			p += 2;
   2160 			continue;
   2161 		}
   2162 
   2163 		if (*p != '$') {	/* Unescaped, simple text */
   2164 			if (subst != NULL && *p == '&')
   2165 				Buf_AddBytes(&buf, subst->lhs, subst->lhsLen);
   2166 			else
   2167 				Buf_AddByte(&buf, *p);
   2168 			p++;
   2169 			continue;
   2170 		}
   2171 
   2172 		if (p[1] == delim) {	/* Unescaped $ at end of pattern */
   2173 			if (out_pflags != NULL)
   2174 				out_pflags->anchorEnd = TRUE;
   2175 			else
   2176 				Buf_AddByte(&buf, *p);
   2177 			p++;
   2178 			continue;
   2179 		}
   2180 
   2181 		if (eflags & VARE_WANTRES) { /* Nested variable, evaluated */
   2182 			const char *nested_p = p;
   2183 			FStr nested_val;
   2184 			VarEvalFlags nested_eflags =
   2185 			    eflags & ~(unsigned)VARE_KEEP_DOLLAR;
   2186 
   2187 			(void)Var_Parse(&nested_p, st->scope, nested_eflags,
   2188 			    &nested_val);
   2189 			/* TODO: handle errors */
   2190 			Buf_AddStr(&buf, nested_val.str);
   2191 			FStr_Done(&nested_val);
   2192 			p += nested_p - p;
   2193 			continue;
   2194 		}
   2195 
   2196 		/*
   2197 		 * XXX: This whole block is very similar to Var_Parse without
   2198 		 * VARE_WANTRES.  There may be subtle edge cases though that
   2199 		 * are not yet covered in the unit tests and that are parsed
   2200 		 * differently, depending on whether they are evaluated or
   2201 		 * not.
   2202 		 *
   2203 		 * This subtle difference is not documented in the manual
   2204 		 * page, neither is the difference between parsing :D and
   2205 		 * :M documented. No code should ever depend on these
   2206 		 * details, but who knows.
   2207 		 */
   2208 
   2209 		varstart = p;	/* Nested variable, only parsed */
   2210 		if (p[1] == '(' || p[1] == '{') {
   2211 			/*
   2212 			 * Find the end of this variable reference
   2213 			 * and suck it in without further ado.
   2214 			 * It will be interpreted later.
   2215 			 */
   2216 			char startc = p[1];
   2217 			int endc = startc == '(' ? ')' : '}';
   2218 			int depth = 1;
   2219 
   2220 			for (p += 2; *p != '\0' && depth > 0; p++) {
   2221 				if (p[-1] != '\\') {
   2222 					if (*p == startc)
   2223 						depth++;
   2224 					if (*p == endc)
   2225 						depth--;
   2226 				}
   2227 			}
   2228 			Buf_AddBytesBetween(&buf, varstart, p);
   2229 		} else {
   2230 			Buf_AddByte(&buf, *varstart);
   2231 			p++;
   2232 		}
   2233 	}
   2234 
   2235 	if (*p != delim) {
   2236 		*pp = p;
   2237 		Error("Unfinished modifier for %s ('%c' missing)",
   2238 		    st->var->name.str, delim);
   2239 		*out_part = NULL;
   2240 		return VPR_ERR;
   2241 	}
   2242 
   2243 	*pp = p + 1;
   2244 	if (out_length != NULL)
   2245 		*out_length = buf.len;
   2246 
   2247 	*out_part = Buf_DoneData(&buf);
   2248 	DEBUG1(VAR, "Modifier part: \"%s\"\n", *out_part);
   2249 	return VPR_OK;
   2250 }
   2251 
   2252 /*
   2253  * Parse a part of a modifier such as the "from" and "to" in :S/from/to/ or
   2254  * the "var" or "replacement ${var}" in :@var@replacement ${var}@, up to and
   2255  * including the next unescaped delimiter.  The delimiter, as well as the
   2256  * backslash or the dollar, can be escaped with a backslash.
   2257  *
   2258  * Return the parsed (and possibly expanded) string, or NULL if no delimiter
   2259  * was found.  On successful return, the parsing position pp points right
   2260  * after the delimiter.  The delimiter is not included in the returned
   2261  * value though.
   2262  */
   2263 static VarParseResult
   2264 ParseModifierPart(
   2265     /* The parsing position, updated upon return */
   2266     const char **pp,
   2267     /* Parsing stops at this delimiter */
   2268     char delim,
   2269     /* Flags for evaluating nested variables; if VARE_WANTRES is not set,
   2270      * the text is only parsed. */
   2271     VarEvalFlags eflags,
   2272     ApplyModifiersState *st,
   2273     char **out_part
   2274 )
   2275 {
   2276 	return ParseModifierPartSubst(pp, delim, eflags, st, out_part,
   2277 	    NULL, NULL, NULL);
   2278 }
   2279 
   2280 /* Test whether mod starts with modname, followed by a delimiter. */
   2281 MAKE_INLINE Boolean
   2282 ModMatch(const char *mod, const char *modname, char endc)
   2283 {
   2284 	size_t n = strlen(modname);
   2285 	return strncmp(mod, modname, n) == 0 &&
   2286 	       (mod[n] == endc || mod[n] == ':');
   2287 }
   2288 
   2289 /* Test whether mod starts with modname, followed by a delimiter or '='. */
   2290 MAKE_INLINE Boolean
   2291 ModMatchEq(const char *mod, const char *modname, char endc)
   2292 {
   2293 	size_t n = strlen(modname);
   2294 	return strncmp(mod, modname, n) == 0 &&
   2295 	       (mod[n] == endc || mod[n] == ':' || mod[n] == '=');
   2296 }
   2297 
   2298 static Boolean
   2299 TryParseIntBase0(const char **pp, int *out_num)
   2300 {
   2301 	char *end;
   2302 	long n;
   2303 
   2304 	errno = 0;
   2305 	n = strtol(*pp, &end, 0);
   2306 	if ((n == LONG_MIN || n == LONG_MAX) && errno == ERANGE)
   2307 		return FALSE;
   2308 	if (n < INT_MIN || n > INT_MAX)
   2309 		return FALSE;
   2310 
   2311 	*pp = end;
   2312 	*out_num = (int)n;
   2313 	return TRUE;
   2314 }
   2315 
   2316 static Boolean
   2317 TryParseSize(const char **pp, size_t *out_num)
   2318 {
   2319 	char *end;
   2320 	unsigned long n;
   2321 
   2322 	if (!ch_isdigit(**pp))
   2323 		return FALSE;
   2324 
   2325 	errno = 0;
   2326 	n = strtoul(*pp, &end, 10);
   2327 	if (n == ULONG_MAX && errno == ERANGE)
   2328 		return FALSE;
   2329 	if (n > SIZE_MAX)
   2330 		return FALSE;
   2331 
   2332 	*pp = end;
   2333 	*out_num = (size_t)n;
   2334 	return TRUE;
   2335 }
   2336 
   2337 static Boolean
   2338 TryParseChar(const char **pp, int base, char *out_ch)
   2339 {
   2340 	char *end;
   2341 	unsigned long n;
   2342 
   2343 	if (!ch_isalnum(**pp))
   2344 		return FALSE;
   2345 
   2346 	errno = 0;
   2347 	n = strtoul(*pp, &end, base);
   2348 	if (n == ULONG_MAX && errno == ERANGE)
   2349 		return FALSE;
   2350 	if (n > UCHAR_MAX)
   2351 		return FALSE;
   2352 
   2353 	*pp = end;
   2354 	*out_ch = (char)n;
   2355 	return TRUE;
   2356 }
   2357 
   2358 /* :@var (at) ...${var}...@ */
   2359 static ApplyModifierResult
   2360 ApplyModifier_Loop(const char **pp, const char *val, ApplyModifiersState *st)
   2361 {
   2362 	struct ModifyWord_LoopArgs args;
   2363 	char prev_sep;
   2364 	VarParseResult res;
   2365 
   2366 	args.scope = st->scope;
   2367 
   2368 	(*pp)++;		/* Skip the first '@' */
   2369 	res = ParseModifierPart(pp, '@', VARE_NONE, st, &args.tvar);
   2370 	if (res != VPR_OK)
   2371 		return AMR_CLEANUP;
   2372 	if (opts.strict && strchr(args.tvar, '$') != NULL) {
   2373 		Parse_Error(PARSE_FATAL,
   2374 		    "In the :@ modifier of \"%s\", the variable name \"%s\" "
   2375 		    "must not contain a dollar.",
   2376 		    st->var->name.str, args.tvar);
   2377 		return AMR_CLEANUP;
   2378 	}
   2379 
   2380 	res = ParseModifierPart(pp, '@', VARE_NONE, st, &args.str);
   2381 	if (res != VPR_OK)
   2382 		return AMR_CLEANUP;
   2383 
   2384 	args.eflags = st->eflags & ~(unsigned)VARE_KEEP_DOLLAR;
   2385 	prev_sep = st->sep;
   2386 	st->sep = ' ';		/* XXX: should be st->sep for consistency */
   2387 	st->newVal = FStr_InitOwn(
   2388 	    ModifyWords(val, ModifyWord_Loop, &args, st->oneBigWord, st->sep));
   2389 	st->sep = prev_sep;
   2390 	/* XXX: Consider restoring the previous variable instead of deleting. */
   2391 	/*
   2392 	 * XXX: The variable name should not be expanded here, see
   2393 	 * ModifyWord_Loop.
   2394 	 */
   2395 	Var_DeleteExpand(st->scope, args.tvar);
   2396 	free(args.tvar);
   2397 	free(args.str);
   2398 	return AMR_OK;
   2399 }
   2400 
   2401 /* :Ddefined or :Uundefined */
   2402 static ApplyModifierResult
   2403 ApplyModifier_Defined(const char **pp, const char *val, ApplyModifiersState *st)
   2404 {
   2405 	Buffer buf;
   2406 	const char *p;
   2407 
   2408 	VarEvalFlags eflags = VARE_NONE;
   2409 	if (st->eflags & VARE_WANTRES)
   2410 		if ((**pp == 'D') == (st->exprStatus == VES_NONE))
   2411 			eflags = st->eflags;
   2412 
   2413 	Buf_Init(&buf);
   2414 	p = *pp + 1;
   2415 	while (*p != st->endc && *p != ':' && *p != '\0') {
   2416 
   2417 		/* XXX: This code is similar to the one in Var_Parse.
   2418 		 * See if the code can be merged.
   2419 		 * See also ApplyModifier_Match. */
   2420 
   2421 		/* Escaped delimiter or other special character */
   2422 		if (*p == '\\') {
   2423 			char c = p[1];
   2424 			if (c == st->endc || c == ':' || c == '$' ||
   2425 			    c == '\\') {
   2426 				Buf_AddByte(&buf, c);
   2427 				p += 2;
   2428 				continue;
   2429 			}
   2430 		}
   2431 
   2432 		/* Nested variable expression */
   2433 		if (*p == '$') {
   2434 			FStr nested_val;
   2435 
   2436 			(void)Var_Parse(&p, st->scope, eflags, &nested_val);
   2437 			/* TODO: handle errors */
   2438 			Buf_AddStr(&buf, nested_val.str);
   2439 			FStr_Done(&nested_val);
   2440 			continue;
   2441 		}
   2442 
   2443 		/* Ordinary text */
   2444 		Buf_AddByte(&buf, *p);
   2445 		p++;
   2446 	}
   2447 	*pp = p;
   2448 
   2449 	Expr_Define(st);
   2450 
   2451 	if (eflags & VARE_WANTRES) {
   2452 		st->newVal = FStr_InitOwn(Buf_DoneData(&buf));
   2453 	} else {
   2454 		st->newVal = FStr_InitRefer(val);
   2455 		Buf_Done(&buf);
   2456 	}
   2457 	return AMR_OK;
   2458 }
   2459 
   2460 /* :L */
   2461 static ApplyModifierResult
   2462 ApplyModifier_Literal(const char **pp, ApplyModifiersState *st)
   2463 {
   2464 	Expr_Define(st);
   2465 	st->newVal = FStr_InitOwn(bmake_strdup(st->var->name.str));
   2466 	(*pp)++;
   2467 	return AMR_OK;
   2468 }
   2469 
   2470 static Boolean
   2471 TryParseTime(const char **pp, time_t *out_time)
   2472 {
   2473 	char *end;
   2474 	unsigned long n;
   2475 
   2476 	if (!ch_isdigit(**pp))
   2477 		return FALSE;
   2478 
   2479 	errno = 0;
   2480 	n = strtoul(*pp, &end, 10);
   2481 	if (n == ULONG_MAX && errno == ERANGE)
   2482 		return FALSE;
   2483 
   2484 	*pp = end;
   2485 	*out_time = (time_t)n;	/* ignore possible truncation for now */
   2486 	return TRUE;
   2487 }
   2488 
   2489 /* :gmtime */
   2490 static ApplyModifierResult
   2491 ApplyModifier_Gmtime(const char **pp, const char *val, ApplyModifiersState *st)
   2492 {
   2493 	time_t utc;
   2494 
   2495 	const char *mod = *pp;
   2496 	if (!ModMatchEq(mod, "gmtime", st->endc))
   2497 		return AMR_UNKNOWN;
   2498 
   2499 	if (mod[6] == '=') {
   2500 		const char *arg = mod + 7;
   2501 		if (!TryParseTime(&arg, &utc)) {
   2502 			Parse_Error(PARSE_FATAL,
   2503 			    "Invalid time value: %s", mod + 7);
   2504 			return AMR_CLEANUP;
   2505 		}
   2506 		*pp = arg;
   2507 	} else {
   2508 		utc = 0;
   2509 		*pp = mod + 6;
   2510 	}
   2511 	st->newVal = FStr_InitOwn(VarStrftime(val, TRUE, utc));
   2512 	return AMR_OK;
   2513 }
   2514 
   2515 /* :localtime */
   2516 static ApplyModifierResult
   2517 ApplyModifier_Localtime(const char **pp, const char *val,
   2518 			ApplyModifiersState *st)
   2519 {
   2520 	time_t utc;
   2521 
   2522 	const char *mod = *pp;
   2523 	if (!ModMatchEq(mod, "localtime", st->endc))
   2524 		return AMR_UNKNOWN;
   2525 
   2526 	if (mod[9] == '=') {
   2527 		const char *arg = mod + 10;
   2528 		if (!TryParseTime(&arg, &utc)) {
   2529 			Parse_Error(PARSE_FATAL,
   2530 			    "Invalid time value: %s", mod + 10);
   2531 			return AMR_CLEANUP;
   2532 		}
   2533 		*pp = arg;
   2534 	} else {
   2535 		utc = 0;
   2536 		*pp = mod + 9;
   2537 	}
   2538 	st->newVal = FStr_InitOwn(VarStrftime(val, FALSE, utc));
   2539 	return AMR_OK;
   2540 }
   2541 
   2542 /* :hash */
   2543 static ApplyModifierResult
   2544 ApplyModifier_Hash(const char **pp, const char *val, ApplyModifiersState *st)
   2545 {
   2546 	if (!ModMatch(*pp, "hash", st->endc))
   2547 		return AMR_UNKNOWN;
   2548 
   2549 	st->newVal = FStr_InitOwn(VarHash(val));
   2550 	*pp += 4;
   2551 	return AMR_OK;
   2552 }
   2553 
   2554 /* :P */
   2555 static ApplyModifierResult
   2556 ApplyModifier_Path(const char **pp, ApplyModifiersState *st)
   2557 {
   2558 	GNode *gn;
   2559 	char *path;
   2560 
   2561 	Expr_Define(st);
   2562 
   2563 	gn = Targ_FindNode(st->var->name.str);
   2564 	if (gn == NULL || gn->type & OP_NOPATH) {
   2565 		path = NULL;
   2566 	} else if (gn->path != NULL) {
   2567 		path = bmake_strdup(gn->path);
   2568 	} else {
   2569 		SearchPath *searchPath = Suff_FindPath(gn);
   2570 		path = Dir_FindFile(st->var->name.str, searchPath);
   2571 	}
   2572 	if (path == NULL)
   2573 		path = bmake_strdup(st->var->name.str);
   2574 	st->newVal = FStr_InitOwn(path);
   2575 
   2576 	(*pp)++;
   2577 	return AMR_OK;
   2578 }
   2579 
   2580 /* :!cmd! */
   2581 static ApplyModifierResult
   2582 ApplyModifier_ShellCommand(const char **pp, ApplyModifiersState *st)
   2583 {
   2584 	char *cmd;
   2585 	const char *errfmt;
   2586 	VarParseResult res;
   2587 
   2588 	(*pp)++;
   2589 	res = ParseModifierPart(pp, '!', st->eflags, st, &cmd);
   2590 	if (res != VPR_OK)
   2591 		return AMR_CLEANUP;
   2592 
   2593 	errfmt = NULL;
   2594 	if (st->eflags & VARE_WANTRES)
   2595 		st->newVal = FStr_InitOwn(Cmd_Exec(cmd, &errfmt));
   2596 	else
   2597 		st->newVal = FStr_InitRefer("");
   2598 	if (errfmt != NULL)
   2599 		Error(errfmt, cmd);	/* XXX: why still return AMR_OK? */
   2600 	free(cmd);
   2601 
   2602 	Expr_Define(st);
   2603 	return AMR_OK;
   2604 }
   2605 
   2606 /*
   2607  * The :range modifier generates an integer sequence as long as the words.
   2608  * The :range=7 modifier generates an integer sequence from 1 to 7.
   2609  */
   2610 static ApplyModifierResult
   2611 ApplyModifier_Range(const char **pp, const char *val, ApplyModifiersState *st)
   2612 {
   2613 	size_t n;
   2614 	Buffer buf;
   2615 	size_t i;
   2616 
   2617 	const char *mod = *pp;
   2618 	if (!ModMatchEq(mod, "range", st->endc))
   2619 		return AMR_UNKNOWN;
   2620 
   2621 	if (mod[5] == '=') {
   2622 		const char *p = mod + 6;
   2623 		if (!TryParseSize(&p, &n)) {
   2624 			Parse_Error(PARSE_FATAL,
   2625 			    "Invalid number: %s", mod + 6);
   2626 			return AMR_CLEANUP;
   2627 		}
   2628 		*pp = p;
   2629 	} else {
   2630 		n = 0;
   2631 		*pp = mod + 5;
   2632 	}
   2633 
   2634 	if (n == 0) {
   2635 		Words words = Str_Words(val, FALSE);
   2636 		n = words.len;
   2637 		Words_Free(words);
   2638 	}
   2639 
   2640 	Buf_Init(&buf);
   2641 
   2642 	for (i = 0; i < n; i++) {
   2643 		if (i != 0) {
   2644 			/* XXX: Use st->sep instead of ' ', for consistency. */
   2645 			Buf_AddByte(&buf, ' ');
   2646 		}
   2647 		Buf_AddInt(&buf, 1 + (int)i);
   2648 	}
   2649 
   2650 	st->newVal = FStr_InitOwn(Buf_DoneData(&buf));
   2651 	return AMR_OK;
   2652 }
   2653 
   2654 /* :Mpattern or :Npattern */
   2655 static ApplyModifierResult
   2656 ApplyModifier_Match(const char **pp, const char *val, ApplyModifiersState *st)
   2657 {
   2658 	const char *mod = *pp;
   2659 	Boolean copy = FALSE;	/* pattern should be, or has been, copied */
   2660 	Boolean needSubst = FALSE;
   2661 	const char *endpat;
   2662 	char *pattern;
   2663 	ModifyWordsCallback callback;
   2664 
   2665 	/*
   2666 	 * In the loop below, ignore ':' unless we are at (or back to) the
   2667 	 * original brace level.
   2668 	 * XXX: This will likely not work right if $() and ${} are intermixed.
   2669 	 */
   2670 	/* XXX: This code is similar to the one in Var_Parse.
   2671 	 * See if the code can be merged.
   2672 	 * See also ApplyModifier_Defined. */
   2673 	int nest = 0;
   2674 	const char *p;
   2675 	for (p = mod + 1; *p != '\0' && !(*p == ':' && nest == 0); p++) {
   2676 		if (*p == '\\' &&
   2677 		    (p[1] == ':' || p[1] == st->endc || p[1] == st->startc)) {
   2678 			if (!needSubst)
   2679 				copy = TRUE;
   2680 			p++;
   2681 			continue;
   2682 		}
   2683 		if (*p == '$')
   2684 			needSubst = TRUE;
   2685 		if (*p == '(' || *p == '{')
   2686 			nest++;
   2687 		if (*p == ')' || *p == '}') {
   2688 			nest--;
   2689 			if (nest < 0)
   2690 				break;
   2691 		}
   2692 	}
   2693 	*pp = p;
   2694 	endpat = p;
   2695 
   2696 	if (copy) {
   2697 		char *dst;
   2698 		const char *src;
   2699 
   2700 		/* Compress the \:'s out of the pattern. */
   2701 		pattern = bmake_malloc((size_t)(endpat - (mod + 1)) + 1);
   2702 		dst = pattern;
   2703 		src = mod + 1;
   2704 		for (; src < endpat; src++, dst++) {
   2705 			if (src[0] == '\\' && src + 1 < endpat &&
   2706 			    /* XXX: st->startc is missing here; see above */
   2707 			    (src[1] == ':' || src[1] == st->endc))
   2708 				src++;
   2709 			*dst = *src;
   2710 		}
   2711 		*dst = '\0';
   2712 	} else {
   2713 		pattern = bmake_strsedup(mod + 1, endpat);
   2714 	}
   2715 
   2716 	if (needSubst) {
   2717 		char *old_pattern = pattern;
   2718 		(void)Var_Subst(pattern, st->scope, st->eflags, &pattern);
   2719 		/* TODO: handle errors */
   2720 		free(old_pattern);
   2721 	}
   2722 
   2723 	DEBUG3(VAR, "Pattern[%s] for [%s] is [%s]\n",
   2724 	    st->var->name.str, val, pattern);
   2725 
   2726 	callback = mod[0] == 'M' ? ModifyWord_Match : ModifyWord_NoMatch;
   2727 	st->newVal = FStr_InitOwn(ModifyWords(val, callback, pattern,
   2728 	    st->oneBigWord, st->sep));
   2729 	free(pattern);
   2730 	return AMR_OK;
   2731 }
   2732 
   2733 /* :S,from,to, */
   2734 static ApplyModifierResult
   2735 ApplyModifier_Subst(const char **pp, const char *val, ApplyModifiersState *st)
   2736 {
   2737 	struct ModifyWord_SubstArgs args;
   2738 	char *lhs, *rhs;
   2739 	Boolean oneBigWord;
   2740 	VarParseResult res;
   2741 
   2742 	char delim = (*pp)[1];
   2743 	if (delim == '\0') {
   2744 		Error("Missing delimiter for :S modifier");
   2745 		(*pp)++;
   2746 		return AMR_CLEANUP;
   2747 	}
   2748 
   2749 	*pp += 2;
   2750 
   2751 	args.pflags = (VarPatternFlags){ FALSE, FALSE, FALSE, FALSE };
   2752 	args.matched = FALSE;
   2753 
   2754 	/*
   2755 	 * If pattern begins with '^', it is anchored to the
   2756 	 * start of the word -- skip over it and flag pattern.
   2757 	 */
   2758 	if (**pp == '^') {
   2759 		args.pflags.anchorStart = TRUE;
   2760 		(*pp)++;
   2761 	}
   2762 
   2763 	res = ParseModifierPartSubst(pp, delim, st->eflags, st, &lhs,
   2764 	    &args.lhsLen, &args.pflags, NULL);
   2765 	if (res != VPR_OK)
   2766 		return AMR_CLEANUP;
   2767 	args.lhs = lhs;
   2768 
   2769 	res = ParseModifierPartSubst(pp, delim, st->eflags, st, &rhs,
   2770 	    &args.rhsLen, NULL, &args);
   2771 	if (res != VPR_OK)
   2772 		return AMR_CLEANUP;
   2773 	args.rhs = rhs;
   2774 
   2775 	oneBigWord = st->oneBigWord;
   2776 	for (;; (*pp)++) {
   2777 		if (**pp == 'g')
   2778 			args.pflags.subGlobal = TRUE;
   2779 		else if (**pp == '1')
   2780 			args.pflags.subOnce = TRUE;
   2781 		else if (**pp == 'W')
   2782 			oneBigWord = TRUE;
   2783 		else
   2784 			break;
   2785 	}
   2786 
   2787 	st->newVal = FStr_InitOwn(ModifyWords(val, ModifyWord_Subst, &args,
   2788 	    oneBigWord, st->sep));
   2789 
   2790 	free(lhs);
   2791 	free(rhs);
   2792 	return AMR_OK;
   2793 }
   2794 
   2795 #ifndef NO_REGEX
   2796 
   2797 /* :C,from,to, */
   2798 static ApplyModifierResult
   2799 ApplyModifier_Regex(const char **pp, const char *val, ApplyModifiersState *st)
   2800 {
   2801 	char *re;
   2802 	struct ModifyWord_SubstRegexArgs args;
   2803 	Boolean oneBigWord;
   2804 	int error;
   2805 	VarParseResult res;
   2806 
   2807 	char delim = (*pp)[1];
   2808 	if (delim == '\0') {
   2809 		Error("Missing delimiter for :C modifier");
   2810 		(*pp)++;
   2811 		return AMR_CLEANUP;
   2812 	}
   2813 
   2814 	*pp += 2;
   2815 
   2816 	res = ParseModifierPart(pp, delim, st->eflags, st, &re);
   2817 	if (res != VPR_OK)
   2818 		return AMR_CLEANUP;
   2819 
   2820 	res = ParseModifierPart(pp, delim, st->eflags, st, &args.replace);
   2821 	if (args.replace == NULL) {
   2822 		free(re);
   2823 		return AMR_CLEANUP;
   2824 	}
   2825 
   2826 	args.pflags = (VarPatternFlags){ FALSE, FALSE, FALSE, FALSE };
   2827 	args.matched = FALSE;
   2828 	oneBigWord = st->oneBigWord;
   2829 	for (;; (*pp)++) {
   2830 		if (**pp == 'g')
   2831 			args.pflags.subGlobal = TRUE;
   2832 		else if (**pp == '1')
   2833 			args.pflags.subOnce = TRUE;
   2834 		else if (**pp == 'W')
   2835 			oneBigWord = TRUE;
   2836 		else
   2837 			break;
   2838 	}
   2839 
   2840 	error = regcomp(&args.re, re, REG_EXTENDED);
   2841 	free(re);
   2842 	if (error != 0) {
   2843 		VarREError(error, &args.re, "Regex compilation error");
   2844 		free(args.replace);
   2845 		return AMR_CLEANUP;
   2846 	}
   2847 
   2848 	args.nsub = args.re.re_nsub + 1;
   2849 	if (args.nsub > 10)
   2850 		args.nsub = 10;
   2851 	st->newVal = FStr_InitOwn(
   2852 	    ModifyWords(val, ModifyWord_SubstRegex, &args,
   2853 		oneBigWord, st->sep));
   2854 	regfree(&args.re);
   2855 	free(args.replace);
   2856 	return AMR_OK;
   2857 }
   2858 
   2859 #endif
   2860 
   2861 /* :Q, :q */
   2862 static ApplyModifierResult
   2863 ApplyModifier_Quote(const char **pp, const char *val, ApplyModifiersState *st)
   2864 {
   2865 	if ((*pp)[1] == st->endc || (*pp)[1] == ':') {
   2866 		st->newVal = FStr_InitOwn(VarQuote(val, **pp == 'q'));
   2867 		(*pp)++;
   2868 		return AMR_OK;
   2869 	} else
   2870 		return AMR_UNKNOWN;
   2871 }
   2872 
   2873 /*ARGSUSED*/
   2874 static void
   2875 ModifyWord_Copy(const char *word, SepBuf *buf, void *data MAKE_ATTR_UNUSED)
   2876 {
   2877 	SepBuf_AddStr(buf, word);
   2878 }
   2879 
   2880 /* :ts<separator> */
   2881 static ApplyModifierResult
   2882 ApplyModifier_ToSep(const char **pp, const char *val, ApplyModifiersState *st)
   2883 {
   2884 	const char *sep = *pp + 2;
   2885 
   2886 	/* ":ts<any><endc>" or ":ts<any>:" */
   2887 	if (sep[0] != st->endc && (sep[1] == st->endc || sep[1] == ':')) {
   2888 		st->sep = sep[0];
   2889 		*pp = sep + 1;
   2890 		goto ok;
   2891 	}
   2892 
   2893 	/* ":ts<endc>" or ":ts:" */
   2894 	if (sep[0] == st->endc || sep[0] == ':') {
   2895 		st->sep = '\0';	/* no separator */
   2896 		*pp = sep;
   2897 		goto ok;
   2898 	}
   2899 
   2900 	/* ":ts<unrecognised><unrecognised>". */
   2901 	if (sep[0] != '\\') {
   2902 		(*pp)++;	/* just for backwards compatibility */
   2903 		return AMR_BAD;
   2904 	}
   2905 
   2906 	/* ":ts\n" */
   2907 	if (sep[1] == 'n') {
   2908 		st->sep = '\n';
   2909 		*pp = sep + 2;
   2910 		goto ok;
   2911 	}
   2912 
   2913 	/* ":ts\t" */
   2914 	if (sep[1] == 't') {
   2915 		st->sep = '\t';
   2916 		*pp = sep + 2;
   2917 		goto ok;
   2918 	}
   2919 
   2920 	/* ":ts\x40" or ":ts\100" */
   2921 	{
   2922 		const char *p = sep + 1;
   2923 		int base = 8;	/* assume octal */
   2924 
   2925 		if (sep[1] == 'x') {
   2926 			base = 16;
   2927 			p++;
   2928 		} else if (!ch_isdigit(sep[1])) {
   2929 			(*pp)++;	/* just for backwards compatibility */
   2930 			return AMR_BAD;	/* ":ts<backslash><unrecognised>". */
   2931 		}
   2932 
   2933 		if (!TryParseChar(&p, base, &st->sep)) {
   2934 			Parse_Error(PARSE_FATAL,
   2935 			    "Invalid character number: %s", p);
   2936 			return AMR_CLEANUP;
   2937 		}
   2938 		if (*p != ':' && *p != st->endc) {
   2939 			(*pp)++;	/* just for backwards compatibility */
   2940 			return AMR_BAD;
   2941 		}
   2942 
   2943 		*pp = p;
   2944 	}
   2945 
   2946 ok:
   2947 	st->newVal = FStr_InitOwn(
   2948 	    ModifyWords(val, ModifyWord_Copy, NULL, st->oneBigWord, st->sep));
   2949 	return AMR_OK;
   2950 }
   2951 
   2952 static char *
   2953 str_toupper(const char *str)
   2954 {
   2955 	char *res;
   2956 	size_t i, len;
   2957 
   2958 	len = strlen(str);
   2959 	res = bmake_malloc(len + 1);
   2960 	for (i = 0; i < len + 1; i++)
   2961 		res[i] = ch_toupper(str[i]);
   2962 
   2963 	return res;
   2964 }
   2965 
   2966 static char *
   2967 str_tolower(const char *str)
   2968 {
   2969 	char *res;
   2970 	size_t i, len;
   2971 
   2972 	len = strlen(str);
   2973 	res = bmake_malloc(len + 1);
   2974 	for (i = 0; i < len + 1; i++)
   2975 		res[i] = ch_tolower(str[i]);
   2976 
   2977 	return res;
   2978 }
   2979 
   2980 /* :tA, :tu, :tl, :ts<separator>, etc. */
   2981 static ApplyModifierResult
   2982 ApplyModifier_To(const char **pp, const char *val, ApplyModifiersState *st)
   2983 {
   2984 	const char *mod = *pp;
   2985 	assert(mod[0] == 't');
   2986 
   2987 	if (mod[1] == st->endc || mod[1] == ':' || mod[1] == '\0') {
   2988 		*pp = mod + 1;
   2989 		return AMR_BAD;	/* Found ":t<endc>" or ":t:". */
   2990 	}
   2991 
   2992 	if (mod[1] == 's')
   2993 		return ApplyModifier_ToSep(pp, val, st);
   2994 
   2995 	if (mod[2] != st->endc && mod[2] != ':') {	/* :t<unrecognized> */
   2996 		*pp = mod + 1;
   2997 		return AMR_BAD;
   2998 	}
   2999 
   3000 	if (mod[1] == 'A') {				/* :tA */
   3001 		st->newVal = FStr_InitOwn(
   3002 		    ModifyWords(val, ModifyWord_Realpath, NULL,
   3003 		        st->oneBigWord, st->sep));
   3004 		*pp = mod + 2;
   3005 		return AMR_OK;
   3006 	}
   3007 
   3008 	if (mod[1] == 'u') {				/* :tu */
   3009 		st->newVal = FStr_InitOwn(str_toupper(val));
   3010 		*pp = mod + 2;
   3011 		return AMR_OK;
   3012 	}
   3013 
   3014 	if (mod[1] == 'l') {				/* :tl */
   3015 		st->newVal = FStr_InitOwn(str_tolower(val));
   3016 		*pp = mod + 2;
   3017 		return AMR_OK;
   3018 	}
   3019 
   3020 	if (mod[1] == 'W' || mod[1] == 'w') {		/* :tW, :tw */
   3021 		st->oneBigWord = mod[1] == 'W';
   3022 		st->newVal = FStr_InitRefer(val);
   3023 		*pp = mod + 2;
   3024 		return AMR_OK;
   3025 	}
   3026 
   3027 	/* Found ":t<unrecognised>:" or ":t<unrecognised><endc>". */
   3028 	*pp = mod + 1;
   3029 	return AMR_BAD;
   3030 }
   3031 
   3032 /* :[#], :[1], :[-1..1], etc. */
   3033 static ApplyModifierResult
   3034 ApplyModifier_Words(const char **pp, const char *val, ApplyModifiersState *st)
   3035 {
   3036 	char *estr;
   3037 	int first, last;
   3038 	VarParseResult res;
   3039 	const char *p;
   3040 
   3041 	(*pp)++;		/* skip the '[' */
   3042 	res = ParseModifierPart(pp, ']', st->eflags, st, &estr);
   3043 	if (res != VPR_OK)
   3044 		return AMR_CLEANUP;
   3045 
   3046 	if (**pp != ':' && **pp != st->endc)
   3047 		goto bad_modifier;		/* Found junk after ']' */
   3048 
   3049 	if (estr[0] == '\0')
   3050 		goto bad_modifier;			/* Found ":[]". */
   3051 
   3052 	if (estr[0] == '#' && estr[1] == '\0') {	/* Found ":[#]" */
   3053 		if (st->oneBigWord) {
   3054 			st->newVal = FStr_InitRefer("1");
   3055 		} else {
   3056 			Buffer buf;
   3057 
   3058 			Words words = Str_Words(val, FALSE);
   3059 			size_t ac = words.len;
   3060 			Words_Free(words);
   3061 
   3062 			/* 3 digits + '\0' is usually enough */
   3063 			Buf_InitSize(&buf, 4);
   3064 			Buf_AddInt(&buf, (int)ac);
   3065 			st->newVal = FStr_InitOwn(Buf_DoneData(&buf));
   3066 		}
   3067 		goto ok;
   3068 	}
   3069 
   3070 	if (estr[0] == '*' && estr[1] == '\0') {	/* Found ":[*]" */
   3071 		st->oneBigWord = TRUE;
   3072 		st->newVal = FStr_InitRefer(val);
   3073 		goto ok;
   3074 	}
   3075 
   3076 	if (estr[0] == '@' && estr[1] == '\0') {	/* Found ":[@]" */
   3077 		st->oneBigWord = FALSE;
   3078 		st->newVal = FStr_InitRefer(val);
   3079 		goto ok;
   3080 	}
   3081 
   3082 	/*
   3083 	 * We expect estr to contain a single integer for :[N], or two
   3084 	 * integers separated by ".." for :[start..end].
   3085 	 */
   3086 	p = estr;
   3087 	if (!TryParseIntBase0(&p, &first))
   3088 		goto bad_modifier;	/* Found junk instead of a number */
   3089 
   3090 	if (p[0] == '\0') {		/* Found only one integer in :[N] */
   3091 		last = first;
   3092 	} else if (p[0] == '.' && p[1] == '.' && p[2] != '\0') {
   3093 		/* Expecting another integer after ".." */
   3094 		p += 2;
   3095 		if (!TryParseIntBase0(&p, &last) || *p != '\0')
   3096 			goto bad_modifier; /* Found junk after ".." */
   3097 	} else
   3098 		goto bad_modifier;	/* Found junk instead of ".." */
   3099 
   3100 	/*
   3101 	 * Now first and last are properly filled in, but we still have to
   3102 	 * check for 0 as a special case.
   3103 	 */
   3104 	if (first == 0 && last == 0) {
   3105 		/* ":[0]" or perhaps ":[0..0]" */
   3106 		st->oneBigWord = TRUE;
   3107 		st->newVal = FStr_InitRefer(val);
   3108 		goto ok;
   3109 	}
   3110 
   3111 	/* ":[0..N]" or ":[N..0]" */
   3112 	if (first == 0 || last == 0)
   3113 		goto bad_modifier;
   3114 
   3115 	/* Normal case: select the words described by first and last. */
   3116 	st->newVal = FStr_InitOwn(
   3117 	    VarSelectWords(st->sep, st->oneBigWord, val, first, last));
   3118 
   3119 ok:
   3120 	free(estr);
   3121 	return AMR_OK;
   3122 
   3123 bad_modifier:
   3124 	free(estr);
   3125 	return AMR_BAD;
   3126 }
   3127 
   3128 static int
   3129 str_cmp_asc(const void *a, const void *b)
   3130 {
   3131 	return strcmp(*(const char *const *)a, *(const char *const *)b);
   3132 }
   3133 
   3134 static int
   3135 str_cmp_desc(const void *a, const void *b)
   3136 {
   3137 	return strcmp(*(const char *const *)b, *(const char *const *)a);
   3138 }
   3139 
   3140 static void
   3141 ShuffleStrings(char **strs, size_t n)
   3142 {
   3143 	size_t i;
   3144 
   3145 	for (i = n - 1; i > 0; i--) {
   3146 		size_t rndidx = (size_t)random() % (i + 1);
   3147 		char *t = strs[i];
   3148 		strs[i] = strs[rndidx];
   3149 		strs[rndidx] = t;
   3150 	}
   3151 }
   3152 
   3153 /* :O (order ascending) or :Or (order descending) or :Ox (shuffle) */
   3154 static ApplyModifierResult
   3155 ApplyModifier_Order(const char **pp, const char *val, ApplyModifiersState *st)
   3156 {
   3157 	const char *mod = (*pp)++;	/* skip past the 'O' in any case */
   3158 
   3159 	Words words = Str_Words(val, FALSE);
   3160 
   3161 	if (mod[1] == st->endc || mod[1] == ':') {
   3162 		/* :O sorts ascending */
   3163 		qsort(words.words, words.len, sizeof words.words[0],
   3164 		    str_cmp_asc);
   3165 
   3166 	} else if ((mod[1] == 'r' || mod[1] == 'x') &&
   3167 		   (mod[2] == st->endc || mod[2] == ':')) {
   3168 		(*pp)++;
   3169 
   3170 		if (mod[1] == 'r') {	/* :Or sorts descending */
   3171 			qsort(words.words, words.len, sizeof words.words[0],
   3172 			    str_cmp_desc);
   3173 		} else
   3174 			ShuffleStrings(words.words, words.len);
   3175 	} else {
   3176 		Words_Free(words);
   3177 		return AMR_BAD;
   3178 	}
   3179 
   3180 	st->newVal = FStr_InitOwn(Words_JoinFree(words));
   3181 	return AMR_OK;
   3182 }
   3183 
   3184 /* :? then : else */
   3185 static ApplyModifierResult
   3186 ApplyModifier_IfElse(const char **pp, ApplyModifiersState *st)
   3187 {
   3188 	char *then_expr, *else_expr;
   3189 	VarParseResult res;
   3190 
   3191 	Boolean value = FALSE;
   3192 	VarEvalFlags then_eflags = VARE_NONE;
   3193 	VarEvalFlags else_eflags = VARE_NONE;
   3194 
   3195 	int cond_rc = COND_PARSE;	/* anything other than COND_INVALID */
   3196 	if (st->eflags & VARE_WANTRES) {
   3197 		cond_rc = Cond_EvalCondition(st->var->name.str, &value);
   3198 		if (cond_rc != COND_INVALID && value)
   3199 			then_eflags = st->eflags;
   3200 		if (cond_rc != COND_INVALID && !value)
   3201 			else_eflags = st->eflags;
   3202 	}
   3203 
   3204 	(*pp)++;			/* skip past the '?' */
   3205 	res = ParseModifierPart(pp, ':', then_eflags, st, &then_expr);
   3206 	if (res != VPR_OK)
   3207 		return AMR_CLEANUP;
   3208 
   3209 	res = ParseModifierPart(pp, st->endc, else_eflags, st, &else_expr);
   3210 	if (res != VPR_OK)
   3211 		return AMR_CLEANUP;
   3212 
   3213 	(*pp)--;		/* Go back to the st->endc. */
   3214 
   3215 	if (cond_rc == COND_INVALID) {
   3216 		Error("Bad conditional expression `%s' in %s?%s:%s",
   3217 		    st->var->name.str, st->var->name.str, then_expr, else_expr);
   3218 		return AMR_CLEANUP;
   3219 	}
   3220 
   3221 	if (value) {
   3222 		st->newVal = FStr_InitOwn(then_expr);
   3223 		free(else_expr);
   3224 	} else {
   3225 		st->newVal = FStr_InitOwn(else_expr);
   3226 		free(then_expr);
   3227 	}
   3228 	Expr_Define(st);
   3229 	return AMR_OK;
   3230 }
   3231 
   3232 /*
   3233  * The ::= modifiers are special in that they do not read the variable value
   3234  * but instead assign to that variable.  They always expand to an empty
   3235  * string.
   3236  *
   3237  * Their main purpose is in supporting .for loops that generate shell commands
   3238  * since an ordinary variable assignment at that point would terminate the
   3239  * dependency group for these targets.  For example:
   3240  *
   3241  * list-targets: .USE
   3242  * .for i in ${.TARGET} ${.TARGET:R}.gz
   3243  *	@${t::=$i}
   3244  *	@echo 'The target is ${t:T}.'
   3245  * .endfor
   3246  *
   3247  *	  ::=<str>	Assigns <str> as the new value of variable.
   3248  *	  ::?=<str>	Assigns <str> as value of variable if
   3249  *			it was not already set.
   3250  *	  ::+=<str>	Appends <str> to variable.
   3251  *	  ::!=<cmd>	Assigns output of <cmd> as the new value of
   3252  *			variable.
   3253  */
   3254 static ApplyModifierResult
   3255 ApplyModifier_Assign(const char **pp, ApplyModifiersState *st)
   3256 {
   3257 	GNode *scope;
   3258 	char *val;
   3259 	VarParseResult res;
   3260 
   3261 	const char *mod = *pp;
   3262 	const char *op = mod + 1;
   3263 
   3264 	if (op[0] == '=')
   3265 		goto ok;
   3266 	if ((op[0] == '!' || op[0] == '+' || op[0] == '?') && op[1] == '=')
   3267 		goto ok;
   3268 	return AMR_UNKNOWN;	/* "::<unrecognised>" */
   3269 ok:
   3270 
   3271 	if (st->var->name.str[0] == '\0') {
   3272 		*pp = mod + 1;
   3273 		return AMR_BAD;
   3274 	}
   3275 
   3276 	scope = st->scope;	/* scope where v belongs */
   3277 	if (st->exprStatus == VES_NONE && st->scope != SCOPE_GLOBAL) {
   3278 		Var *gv = VarFind(st->var->name.str, st->scope, FALSE);
   3279 		if (gv == NULL)
   3280 			scope = SCOPE_GLOBAL;
   3281 		else
   3282 			VarFreeEnv(gv, TRUE);
   3283 	}
   3284 
   3285 	switch (op[0]) {
   3286 	case '+':
   3287 	case '?':
   3288 	case '!':
   3289 		*pp = mod + 3;
   3290 		break;
   3291 	default:
   3292 		*pp = mod + 2;
   3293 		break;
   3294 	}
   3295 
   3296 	res = ParseModifierPart(pp, st->endc, st->eflags, st, &val);
   3297 	if (res != VPR_OK)
   3298 		return AMR_CLEANUP;
   3299 
   3300 	(*pp)--;		/* Go back to the st->endc. */
   3301 
   3302 	/* XXX: Expanding the variable name at this point sounds wrong. */
   3303 	if (st->eflags & VARE_WANTRES) {
   3304 		switch (op[0]) {
   3305 		case '+':
   3306 			Var_AppendExpand(scope, st->var->name.str, val);
   3307 			break;
   3308 		case '!': {
   3309 			const char *errfmt;
   3310 			char *cmd_output = Cmd_Exec(val, &errfmt);
   3311 			if (errfmt != NULL)
   3312 				Error(errfmt, val);
   3313 			else
   3314 				Var_SetExpand(scope,
   3315 				    st->var->name.str, cmd_output);
   3316 			free(cmd_output);
   3317 			break;
   3318 		}
   3319 		case '?':
   3320 			if (st->exprStatus == VES_NONE)
   3321 				break;
   3322 			/* FALLTHROUGH */
   3323 		default:
   3324 			Var_SetExpand(scope, st->var->name.str, val);
   3325 			break;
   3326 		}
   3327 	}
   3328 	free(val);
   3329 	st->newVal = FStr_InitRefer("");
   3330 	return AMR_OK;
   3331 }
   3332 
   3333 /*
   3334  * :_=...
   3335  * remember current value
   3336  */
   3337 static ApplyModifierResult
   3338 ApplyModifier_Remember(const char **pp, const char *val,
   3339 		       ApplyModifiersState *st)
   3340 {
   3341 	const char *mod = *pp;
   3342 	if (!ModMatchEq(mod, "_", st->endc))
   3343 		return AMR_UNKNOWN;
   3344 
   3345 	if (mod[1] == '=') {
   3346 		size_t n = strcspn(mod + 2, ":)}");
   3347 		char *name = bmake_strldup(mod + 2, n);
   3348 		Var_SetExpand(st->scope, name, val);
   3349 		free(name);
   3350 		*pp = mod + 2 + n;
   3351 	} else {
   3352 		Var_Set(st->scope, "_", val);
   3353 		*pp = mod + 1;
   3354 	}
   3355 	st->newVal = FStr_InitRefer(val);
   3356 	return AMR_OK;
   3357 }
   3358 
   3359 /*
   3360  * Apply the given function to each word of the variable value,
   3361  * for a single-letter modifier such as :H, :T.
   3362  */
   3363 static ApplyModifierResult
   3364 ApplyModifier_WordFunc(const char **pp, const char *val,
   3365 		       ApplyModifiersState *st, ModifyWordsCallback modifyWord)
   3366 {
   3367 	char delim = (*pp)[1];
   3368 	if (delim != st->endc && delim != ':')
   3369 		return AMR_UNKNOWN;
   3370 
   3371 	st->newVal = FStr_InitOwn(ModifyWords(val, modifyWord, NULL,
   3372 	    st->oneBigWord, st->sep));
   3373 	(*pp)++;
   3374 	return AMR_OK;
   3375 }
   3376 
   3377 static ApplyModifierResult
   3378 ApplyModifier_Unique(const char **pp, const char *val, ApplyModifiersState *st)
   3379 {
   3380 	if ((*pp)[1] == st->endc || (*pp)[1] == ':') {
   3381 		st->newVal = FStr_InitOwn(VarUniq(val));
   3382 		(*pp)++;
   3383 		return AMR_OK;
   3384 	} else
   3385 		return AMR_UNKNOWN;
   3386 }
   3387 
   3388 #ifdef SYSVVARSUB
   3389 /* :from=to */
   3390 static ApplyModifierResult
   3391 ApplyModifier_SysV(const char **pp, const char *val, ApplyModifiersState *st)
   3392 {
   3393 	char *lhs, *rhs;
   3394 	VarParseResult res;
   3395 
   3396 	const char *mod = *pp;
   3397 	Boolean eqFound = FALSE;
   3398 
   3399 	/*
   3400 	 * First we make a pass through the string trying to verify it is a
   3401 	 * SysV-make-style translation. It must be: <lhs>=<rhs>
   3402 	 */
   3403 	int depth = 1;
   3404 	const char *p = mod;
   3405 	while (*p != '\0' && depth > 0) {
   3406 		if (*p == '=') {	/* XXX: should also test depth == 1 */
   3407 			eqFound = TRUE;
   3408 			/* continue looking for st->endc */
   3409 		} else if (*p == st->endc)
   3410 			depth--;
   3411 		else if (*p == st->startc)
   3412 			depth++;
   3413 		if (depth > 0)
   3414 			p++;
   3415 	}
   3416 	if (*p != st->endc || !eqFound)
   3417 		return AMR_UNKNOWN;
   3418 
   3419 	res = ParseModifierPart(pp, '=', st->eflags, st, &lhs);
   3420 	if (res != VPR_OK)
   3421 		return AMR_CLEANUP;
   3422 
   3423 	/* The SysV modifier lasts until the end of the variable expression. */
   3424 	res = ParseModifierPart(pp, st->endc, st->eflags, st, &rhs);
   3425 	if (res != VPR_OK)
   3426 		return AMR_CLEANUP;
   3427 
   3428 	(*pp)--;		/* Go back to the st->endc. */
   3429 
   3430 	if (lhs[0] == '\0' && val[0] == '\0') {
   3431 		st->newVal = FStr_InitRefer(val); /* special case */
   3432 	} else {
   3433 		struct ModifyWord_SYSVSubstArgs args = { st->scope, lhs, rhs };
   3434 		st->newVal = FStr_InitOwn(
   3435 		    ModifyWords(val, ModifyWord_SYSVSubst, &args,
   3436 			st->oneBigWord, st->sep));
   3437 	}
   3438 	free(lhs);
   3439 	free(rhs);
   3440 	return AMR_OK;
   3441 }
   3442 #endif
   3443 
   3444 #ifdef SUNSHCMD
   3445 /* :sh */
   3446 static ApplyModifierResult
   3447 ApplyModifier_SunShell(const char **pp, const char *val,
   3448 		       ApplyModifiersState *st)
   3449 {
   3450 	const char *p = *pp;
   3451 	if (p[1] == 'h' && (p[2] == st->endc || p[2] == ':')) {
   3452 		if (st->eflags & VARE_WANTRES) {
   3453 			const char *errfmt;
   3454 			st->newVal = FStr_InitOwn(Cmd_Exec(val, &errfmt));
   3455 			if (errfmt != NULL)
   3456 				Error(errfmt, val);
   3457 		} else
   3458 			st->newVal = FStr_InitRefer("");
   3459 		*pp = p + 2;
   3460 		return AMR_OK;
   3461 	} else
   3462 		return AMR_UNKNOWN;
   3463 }
   3464 #endif
   3465 
   3466 static void
   3467 LogBeforeApply(const ApplyModifiersState *st, const char *mod, char endc,
   3468 	       const char *val)
   3469 {
   3470 	char eflags_str[VarEvalFlags_ToStringSize];
   3471 	char vflags_str[VarFlags_ToStringSize];
   3472 	Boolean is_single_char = mod[0] != '\0' &&
   3473 				 (mod[1] == endc || mod[1] == ':');
   3474 
   3475 	/* At this point, only the first character of the modifier can
   3476 	 * be used since the end of the modifier is not yet known. */
   3477 	debug_printf("Applying ${%s:%c%s} to \"%s\" (%s, %s, %s)\n",
   3478 	    st->var->name.str, mod[0], is_single_char ? "" : "...", val,
   3479 	    VarEvalFlags_ToString(eflags_str, st->eflags),
   3480 	    VarFlags_ToString(vflags_str, st->var->flags),
   3481 	    VarExprStatus_Name[st->exprStatus]);
   3482 }
   3483 
   3484 static void
   3485 LogAfterApply(ApplyModifiersState *st, const char *p, const char *mod)
   3486 {
   3487 	char eflags_str[VarEvalFlags_ToStringSize];
   3488 	char vflags_str[VarFlags_ToStringSize];
   3489 	const char *quot = st->newVal.str == var_Error ? "" : "\"";
   3490 	const char *newVal =
   3491 	    st->newVal.str == var_Error ? "error" : st->newVal.str;
   3492 
   3493 	debug_printf("Result of ${%s:%.*s} is %s%s%s (%s, %s, %s)\n",
   3494 	    st->var->name.str, (int)(p - mod), mod, quot, newVal, quot,
   3495 	    VarEvalFlags_ToString(eflags_str, st->eflags),
   3496 	    VarFlags_ToString(vflags_str, st->var->flags),
   3497 	    VarExprStatus_Name[st->exprStatus]);
   3498 }
   3499 
   3500 static ApplyModifierResult
   3501 ApplyModifier(const char **pp, const char *val, ApplyModifiersState *st)
   3502 {
   3503 	switch (**pp) {
   3504 	case ':':
   3505 		return ApplyModifier_Assign(pp, st);
   3506 	case '@':
   3507 		return ApplyModifier_Loop(pp, val, st);
   3508 	case '_':
   3509 		return ApplyModifier_Remember(pp, val, st);
   3510 	case 'D':
   3511 	case 'U':
   3512 		return ApplyModifier_Defined(pp, val, st);
   3513 	case 'L':
   3514 		return ApplyModifier_Literal(pp, st);
   3515 	case 'P':
   3516 		return ApplyModifier_Path(pp, st);
   3517 	case '!':
   3518 		return ApplyModifier_ShellCommand(pp, st);
   3519 	case '[':
   3520 		return ApplyModifier_Words(pp, val, st);
   3521 	case 'g':
   3522 		return ApplyModifier_Gmtime(pp, val, st);
   3523 	case 'h':
   3524 		return ApplyModifier_Hash(pp, val, st);
   3525 	case 'l':
   3526 		return ApplyModifier_Localtime(pp, val, st);
   3527 	case 't':
   3528 		return ApplyModifier_To(pp, val, st);
   3529 	case 'N':
   3530 	case 'M':
   3531 		return ApplyModifier_Match(pp, val, st);
   3532 	case 'S':
   3533 		return ApplyModifier_Subst(pp, val, st);
   3534 	case '?':
   3535 		return ApplyModifier_IfElse(pp, st);
   3536 #ifndef NO_REGEX
   3537 	case 'C':
   3538 		return ApplyModifier_Regex(pp, val, st);
   3539 #endif
   3540 	case 'q':
   3541 	case 'Q':
   3542 		return ApplyModifier_Quote(pp, val, st);
   3543 	case 'T':
   3544 		return ApplyModifier_WordFunc(pp, val, st, ModifyWord_Tail);
   3545 	case 'H':
   3546 		return ApplyModifier_WordFunc(pp, val, st, ModifyWord_Head);
   3547 	case 'E':
   3548 		return ApplyModifier_WordFunc(pp, val, st, ModifyWord_Suffix);
   3549 	case 'R':
   3550 		return ApplyModifier_WordFunc(pp, val, st, ModifyWord_Root);
   3551 	case 'r':
   3552 		return ApplyModifier_Range(pp, val, st);
   3553 	case 'O':
   3554 		return ApplyModifier_Order(pp, val, st);
   3555 	case 'u':
   3556 		return ApplyModifier_Unique(pp, val, st);
   3557 #ifdef SUNSHCMD
   3558 	case 's':
   3559 		return ApplyModifier_SunShell(pp, val, st);
   3560 #endif
   3561 	default:
   3562 		return AMR_UNKNOWN;
   3563 	}
   3564 }
   3565 
   3566 static FStr ApplyModifiers(const char **, FStr, char, char, Var *,
   3567 			    VarExprStatus *, GNode *, VarEvalFlags);
   3568 
   3569 typedef enum ApplyModifiersIndirectResult {
   3570 	/* The indirect modifiers have been applied successfully. */
   3571 	AMIR_CONTINUE,
   3572 	/* Fall back to the SysV modifier. */
   3573 	AMIR_APPLY_MODS,
   3574 	/* Error out. */
   3575 	AMIR_OUT
   3576 } ApplyModifiersIndirectResult;
   3577 
   3578 /*
   3579  * While expanding a variable expression, expand and apply indirect modifiers,
   3580  * such as in ${VAR:${M_indirect}}.
   3581  *
   3582  * All indirect modifiers of a group must come from a single variable
   3583  * expression.  ${VAR:${M1}} is valid but ${VAR:${M1}${M2}} is not.
   3584  *
   3585  * Multiple groups of indirect modifiers can be chained by separating them
   3586  * with colons.  ${VAR:${M1}:${M2}} contains 2 indirect modifiers.
   3587  *
   3588  * If the variable expression is not followed by st->endc or ':', fall
   3589  * back to trying the SysV modifier, such as in ${VAR:${FROM}=${TO}}.
   3590  *
   3591  * The expression ${VAR:${M1}${M2}} is not treated as an indirect
   3592  * modifier, and it is neither a SysV modifier but a parse error.
   3593  */
   3594 static ApplyModifiersIndirectResult
   3595 ApplyModifiersIndirect(ApplyModifiersState *st, const char **pp,
   3596 		       FStr *inout_value)
   3597 {
   3598 	const char *p = *pp;
   3599 	FStr mods;
   3600 
   3601 	(void)Var_Parse(&p, st->scope, st->eflags, &mods);
   3602 	/* TODO: handle errors */
   3603 
   3604 	if (mods.str[0] != '\0' && *p != '\0' && *p != ':' && *p != st->endc) {
   3605 		FStr_Done(&mods);
   3606 		return AMIR_APPLY_MODS;
   3607 	}
   3608 
   3609 	DEBUG3(VAR, "Indirect modifier \"%s\" from \"%.*s\"\n",
   3610 	    mods.str, (int)(p - *pp), *pp);
   3611 
   3612 	if (mods.str[0] != '\0') {
   3613 		const char *modsp = mods.str;
   3614 		FStr newVal = ApplyModifiers(&modsp, *inout_value, '\0', '\0',
   3615 		    st->var, &st->exprStatus, st->scope, st->eflags);
   3616 		*inout_value = newVal;
   3617 		if (newVal.str == var_Error || *modsp != '\0') {
   3618 			FStr_Done(&mods);
   3619 			*pp = p;
   3620 			return AMIR_OUT;	/* error already reported */
   3621 		}
   3622 	}
   3623 	FStr_Done(&mods);
   3624 
   3625 	if (*p == ':')
   3626 		p++;
   3627 	else if (*p == '\0' && st->endc != '\0') {
   3628 		Error("Unclosed variable specification after complex "
   3629 		      "modifier (expecting '%c') for %s",
   3630 		    st->endc, st->var->name.str);
   3631 		*pp = p;
   3632 		return AMIR_OUT;
   3633 	}
   3634 
   3635 	*pp = p;
   3636 	return AMIR_CONTINUE;
   3637 }
   3638 
   3639 static ApplyModifierResult
   3640 ApplySingleModifier(ApplyModifiersState *st, const char *mod, char endc,
   3641 		    const char **pp, FStr *inout_value)
   3642 {
   3643 	ApplyModifierResult res;
   3644 	const char *p = *pp;
   3645 	const char *const val = inout_value->str;
   3646 
   3647 	if (DEBUG(VAR))
   3648 		LogBeforeApply(st, mod, endc, val);
   3649 
   3650 	res = ApplyModifier(&p, val, st);
   3651 
   3652 #ifdef SYSVVARSUB
   3653 	if (res == AMR_UNKNOWN) {
   3654 		assert(p == mod);
   3655 		res = ApplyModifier_SysV(&p, val, st);
   3656 	}
   3657 #endif
   3658 
   3659 	if (res == AMR_UNKNOWN) {
   3660 		Parse_Error(PARSE_FATAL, "Unknown modifier '%c'", *mod);
   3661 		/*
   3662 		 * Guess the end of the current modifier.
   3663 		 * XXX: Skipping the rest of the modifier hides
   3664 		 * errors and leads to wrong results.
   3665 		 * Parsing should rather stop here.
   3666 		 */
   3667 		for (p++; *p != ':' && *p != st->endc && *p != '\0'; p++)
   3668 			continue;
   3669 		st->newVal = FStr_InitRefer(var_Error);
   3670 	}
   3671 	if (res == AMR_CLEANUP || res == AMR_BAD) {
   3672 		*pp = p;
   3673 		return res;
   3674 	}
   3675 
   3676 	if (DEBUG(VAR))
   3677 		LogAfterApply(st, p, mod);
   3678 
   3679 	if (st->newVal.str != val) {
   3680 		FStr_Done(inout_value);
   3681 		*inout_value = st->newVal;
   3682 	}
   3683 	if (*p == '\0' && st->endc != '\0') {
   3684 		Error(
   3685 		    "Unclosed variable specification (expecting '%c') "
   3686 		    "for \"%s\" (value \"%s\") modifier %c",
   3687 		    st->endc, st->var->name.str, inout_value->str, *mod);
   3688 	} else if (*p == ':') {
   3689 		p++;
   3690 	} else if (opts.strict && *p != '\0' && *p != endc) {
   3691 		Parse_Error(PARSE_FATAL,
   3692 		    "Missing delimiter ':' after modifier \"%.*s\"",
   3693 		    (int)(p - mod), mod);
   3694 		/*
   3695 		 * TODO: propagate parse error to the enclosing
   3696 		 * expression
   3697 		 */
   3698 	}
   3699 	*pp = p;
   3700 	return AMR_OK;
   3701 }
   3702 
   3703 /* Apply any modifiers (such as :Mpattern or :@var@loop@ or :Q or ::=value). */
   3704 static FStr
   3705 ApplyModifiers(
   3706     const char **pp,		/* the parsing position, updated upon return */
   3707     FStr value,			/* the current value of the expression */
   3708     char startc,		/* '(' or '{', or '\0' for indirect modifiers */
   3709     char endc,			/* ')' or '}', or '\0' for indirect modifiers */
   3710     Var *v,
   3711     VarExprStatus *exprStatus,
   3712     GNode *scope,		/* for looking up and modifying variables */
   3713     VarEvalFlags eflags
   3714 )
   3715 {
   3716 	ApplyModifiersState st = {
   3717 	    startc, endc, v, scope, eflags,
   3718 #if defined(lint)
   3719 	    /* lint cannot parse C99 struct initializers yet. */
   3720 	    { var_Error, NULL },
   3721 #else
   3722 	    FStr_InitRefer(var_Error), /* .newVal */
   3723 #endif
   3724 	    ' ',		/* .sep */
   3725 	    FALSE,		/* .oneBigWord */
   3726 	    *exprStatus		/* .exprStatus */
   3727 	};
   3728 	const char *p;
   3729 	const char *mod;
   3730 
   3731 	assert(startc == '(' || startc == '{' || startc == '\0');
   3732 	assert(endc == ')' || endc == '}' || endc == '\0');
   3733 	assert(value.str != NULL);
   3734 
   3735 	p = *pp;
   3736 
   3737 	if (*p == '\0' && endc != '\0') {
   3738 		Error(
   3739 		    "Unclosed variable expression (expecting '%c') for \"%s\"",
   3740 		    st.endc, st.var->name.str);
   3741 		goto cleanup;
   3742 	}
   3743 
   3744 	while (*p != '\0' && *p != endc) {
   3745 		ApplyModifierResult res;
   3746 
   3747 		if (*p == '$') {
   3748 			ApplyModifiersIndirectResult amir;
   3749 			amir = ApplyModifiersIndirect(&st, &p, &value);
   3750 			if (amir == AMIR_CONTINUE)
   3751 				continue;
   3752 			if (amir == AMIR_OUT)
   3753 				break;
   3754 		}
   3755 
   3756 		/* default value, in case of errors */
   3757 		st.newVal = FStr_InitRefer(var_Error);
   3758 		mod = p;
   3759 
   3760 		res = ApplySingleModifier(&st, mod, endc, &p, &value);
   3761 		if (res == AMR_CLEANUP)
   3762 			goto cleanup;
   3763 		if (res == AMR_BAD)
   3764 			goto bad_modifier;
   3765 	}
   3766 
   3767 	*pp = p;
   3768 	assert(value.str != NULL); /* Use var_Error or varUndefined instead. */
   3769 	*exprStatus = st.exprStatus;
   3770 	return value;
   3771 
   3772 bad_modifier:
   3773 	/* XXX: The modifier end is only guessed. */
   3774 	Error("Bad modifier `:%.*s' for %s",
   3775 	    (int)strcspn(mod, ":)}"), mod, st.var->name.str);
   3776 
   3777 cleanup:
   3778 	*pp = p;
   3779 	FStr_Done(&value);
   3780 	*exprStatus = st.exprStatus;
   3781 	return FStr_InitRefer(var_Error);
   3782 }
   3783 
   3784 /*
   3785  * Only four of the local variables are treated specially as they are the
   3786  * only four that will be set when dynamic sources are expanded.
   3787  */
   3788 static Boolean
   3789 VarnameIsDynamic(const char *name, size_t len)
   3790 {
   3791 	if (len == 1 || (len == 2 && (name[1] == 'F' || name[1] == 'D'))) {
   3792 		switch (name[0]) {
   3793 		case '@':
   3794 		case '%':
   3795 		case '*':
   3796 		case '!':
   3797 			return TRUE;
   3798 		}
   3799 		return FALSE;
   3800 	}
   3801 
   3802 	if ((len == 7 || len == 8) && name[0] == '.' && ch_isupper(name[1])) {
   3803 		return strcmp(name, ".TARGET") == 0 ||
   3804 		       strcmp(name, ".ARCHIVE") == 0 ||
   3805 		       strcmp(name, ".PREFIX") == 0 ||
   3806 		       strcmp(name, ".MEMBER") == 0;
   3807 	}
   3808 
   3809 	return FALSE;
   3810 }
   3811 
   3812 static const char *
   3813 UndefinedShortVarValue(char varname, const GNode *scope)
   3814 {
   3815 	if (scope == SCOPE_CMDLINE || scope == SCOPE_GLOBAL) {
   3816 		/*
   3817 		 * If substituting a local variable in a non-local scope,
   3818 		 * assume it's for dynamic source stuff. We have to handle
   3819 		 * this specially and return the longhand for the variable
   3820 		 * with the dollar sign escaped so it makes it back to the
   3821 		 * caller. Only four of the local variables are treated
   3822 		 * specially as they are the only four that will be set
   3823 		 * when dynamic sources are expanded.
   3824 		 */
   3825 		switch (varname) {
   3826 		case '@':
   3827 			return "$(.TARGET)";
   3828 		case '%':
   3829 			return "$(.MEMBER)";
   3830 		case '*':
   3831 			return "$(.PREFIX)";
   3832 		case '!':
   3833 			return "$(.ARCHIVE)";
   3834 		}
   3835 	}
   3836 	return NULL;
   3837 }
   3838 
   3839 /*
   3840  * Parse a variable name, until the end character or a colon, whichever
   3841  * comes first.
   3842  */
   3843 static char *
   3844 ParseVarname(const char **pp, char startc, char endc,
   3845 	     GNode *scope, VarEvalFlags eflags,
   3846 	     size_t *out_varname_len)
   3847 {
   3848 	Buffer buf;
   3849 	const char *p = *pp;
   3850 	int depth = 1;
   3851 
   3852 	Buf_Init(&buf);
   3853 
   3854 	while (*p != '\0') {
   3855 		/* Track depth so we can spot parse errors. */
   3856 		if (*p == startc)
   3857 			depth++;
   3858 		if (*p == endc) {
   3859 			if (--depth == 0)
   3860 				break;
   3861 		}
   3862 		if (*p == ':' && depth == 1)
   3863 			break;
   3864 
   3865 		/* A variable inside a variable, expand. */
   3866 		if (*p == '$') {
   3867 			FStr nested_val;
   3868 			(void)Var_Parse(&p, scope, eflags, &nested_val);
   3869 			/* TODO: handle errors */
   3870 			Buf_AddStr(&buf, nested_val.str);
   3871 			FStr_Done(&nested_val);
   3872 		} else {
   3873 			Buf_AddByte(&buf, *p);
   3874 			p++;
   3875 		}
   3876 	}
   3877 	*pp = p;
   3878 	*out_varname_len = buf.len;
   3879 	return Buf_DoneData(&buf);
   3880 }
   3881 
   3882 static VarParseResult
   3883 ValidShortVarname(char varname, const char *start)
   3884 {
   3885 	switch (varname) {
   3886 	case '\0':
   3887 	case ')':
   3888 	case '}':
   3889 	case ':':
   3890 	case '$':
   3891 		break;		/* and continue below */
   3892 	default:
   3893 		return VPR_OK;
   3894 	}
   3895 
   3896 	if (!opts.strict)
   3897 		return VPR_ERR;	/* XXX: Missing error message */
   3898 
   3899 	if (varname == '$')
   3900 		Parse_Error(PARSE_FATAL,
   3901 		    "To escape a dollar, use \\$, not $$, at \"%s\"", start);
   3902 	else if (varname == '\0')
   3903 		Parse_Error(PARSE_FATAL, "Dollar followed by nothing");
   3904 	else
   3905 		Parse_Error(PARSE_FATAL,
   3906 		    "Invalid variable name '%c', at \"%s\"", varname, start);
   3907 
   3908 	return VPR_ERR;
   3909 }
   3910 
   3911 /*
   3912  * Parse a single-character variable name such as $V or $@.
   3913  * Return whether to continue parsing.
   3914  */
   3915 static Boolean
   3916 ParseVarnameShort(char startc, const char **pp, GNode *scope,
   3917 		  VarEvalFlags eflags,
   3918 		  VarParseResult *out_FALSE_res, const char **out_FALSE_val,
   3919 		  Var **out_TRUE_var)
   3920 {
   3921 	char name[2];
   3922 	Var *v;
   3923 	VarParseResult vpr;
   3924 
   3925 	/*
   3926 	 * If it's not bounded by braces of some sort, life is much simpler.
   3927 	 * We just need to check for the first character and return the
   3928 	 * value if it exists.
   3929 	 */
   3930 
   3931 	vpr = ValidShortVarname(startc, *pp);
   3932 	if (vpr != VPR_OK) {
   3933 		(*pp)++;
   3934 		*out_FALSE_val = var_Error;
   3935 		*out_FALSE_res = vpr;
   3936 		return FALSE;
   3937 	}
   3938 
   3939 	name[0] = startc;
   3940 	name[1] = '\0';
   3941 	v = VarFind(name, scope, TRUE);
   3942 	if (v == NULL) {
   3943 		const char *val;
   3944 		*pp += 2;
   3945 
   3946 		val = UndefinedShortVarValue(startc, scope);
   3947 		if (val == NULL)
   3948 			val = eflags & VARE_UNDEFERR ? var_Error : varUndefined;
   3949 
   3950 		if (opts.strict && val == var_Error) {
   3951 			Parse_Error(PARSE_FATAL,
   3952 			    "Variable \"%s\" is undefined", name);
   3953 			*out_FALSE_res = VPR_ERR;
   3954 			*out_FALSE_val = val;
   3955 			return FALSE;
   3956 		}
   3957 
   3958 		/*
   3959 		 * XXX: This looks completely wrong.
   3960 		 *
   3961 		 * If undefined expressions are not allowed, this should
   3962 		 * rather be VPR_ERR instead of VPR_UNDEF, together with an
   3963 		 * error message.
   3964 		 *
   3965 		 * If undefined expressions are allowed, this should rather
   3966 		 * be VPR_UNDEF instead of VPR_OK.
   3967 		 */
   3968 		*out_FALSE_res = eflags & VARE_UNDEFERR ? VPR_UNDEF : VPR_OK;
   3969 		*out_FALSE_val = val;
   3970 		return FALSE;
   3971 	}
   3972 
   3973 	*out_TRUE_var = v;
   3974 	return TRUE;
   3975 }
   3976 
   3977 /* Find variables like @F or <D. */
   3978 static Var *
   3979 FindLocalLegacyVar(const char *varname, size_t namelen, GNode *scope,
   3980 		   const char **out_extraModifiers)
   3981 {
   3982 	/* Only resolve these variables if scope is a "real" target. */
   3983 	if (scope == SCOPE_CMDLINE || scope == SCOPE_GLOBAL)
   3984 		return NULL;
   3985 
   3986 	if (namelen != 2)
   3987 		return NULL;
   3988 	if (varname[1] != 'F' && varname[1] != 'D')
   3989 		return NULL;
   3990 	if (strchr("@%?*!<>", varname[0]) == NULL)
   3991 		return NULL;
   3992 
   3993 	{
   3994 		char name[] = { varname[0], '\0' };
   3995 		Var *v = VarFind(name, scope, FALSE);
   3996 
   3997 		if (v != NULL) {
   3998 			if (varname[1] == 'D') {
   3999 				*out_extraModifiers = "H:";
   4000 			} else { /* F */
   4001 				*out_extraModifiers = "T:";
   4002 			}
   4003 		}
   4004 		return v;
   4005 	}
   4006 }
   4007 
   4008 static VarParseResult
   4009 EvalUndefined(Boolean dynamic, const char *start, const char *p, char *varname,
   4010 	      VarEvalFlags eflags,
   4011 	      FStr *out_val)
   4012 {
   4013 	if (dynamic) {
   4014 		*out_val = FStr_InitOwn(bmake_strsedup(start, p));
   4015 		free(varname);
   4016 		return VPR_OK;
   4017 	}
   4018 
   4019 	if ((eflags & VARE_UNDEFERR) && opts.strict) {
   4020 		Parse_Error(PARSE_FATAL,
   4021 		    "Variable \"%s\" is undefined", varname);
   4022 		free(varname);
   4023 		*out_val = FStr_InitRefer(var_Error);
   4024 		return VPR_ERR;
   4025 	}
   4026 
   4027 	if (eflags & VARE_UNDEFERR) {
   4028 		free(varname);
   4029 		*out_val = FStr_InitRefer(var_Error);
   4030 		return VPR_UNDEF;	/* XXX: Should be VPR_ERR instead. */
   4031 	}
   4032 
   4033 	free(varname);
   4034 	*out_val = FStr_InitRefer(varUndefined);
   4035 	return VPR_OK;
   4036 }
   4037 
   4038 /*
   4039  * Parse a long variable name enclosed in braces or parentheses such as $(VAR)
   4040  * or ${VAR}, up to the closing brace or parenthesis, or in the case of
   4041  * ${VAR:Modifiers}, up to the ':' that starts the modifiers.
   4042  * Return whether to continue parsing.
   4043  */
   4044 static Boolean
   4045 ParseVarnameLong(
   4046 	const char *p,
   4047 	char startc,
   4048 	GNode *scope,
   4049 	VarEvalFlags eflags,
   4050 
   4051 	const char **out_FALSE_pp,
   4052 	VarParseResult *out_FALSE_res,
   4053 	FStr *out_FALSE_val,
   4054 
   4055 	char *out_TRUE_endc,
   4056 	const char **out_TRUE_p,
   4057 	Var **out_TRUE_v,
   4058 	Boolean *out_TRUE_haveModifier,
   4059 	const char **out_TRUE_extraModifiers,
   4060 	Boolean *out_TRUE_dynamic,
   4061 	VarExprStatus *out_TRUE_exprStatus
   4062 )
   4063 {
   4064 	size_t namelen;
   4065 	char *varname;
   4066 	Var *v;
   4067 	Boolean haveModifier;
   4068 	Boolean dynamic = FALSE;
   4069 
   4070 	const char *const start = p;
   4071 	char endc = startc == '(' ? ')' : '}';
   4072 
   4073 	p += 2;			/* skip "${" or "$(" or "y(" */
   4074 	varname = ParseVarname(&p, startc, endc, scope, eflags, &namelen);
   4075 
   4076 	if (*p == ':') {
   4077 		haveModifier = TRUE;
   4078 	} else if (*p == endc) {
   4079 		haveModifier = FALSE;
   4080 	} else {
   4081 		Parse_Error(PARSE_FATAL, "Unclosed variable \"%s\"", varname);
   4082 		free(varname);
   4083 		*out_FALSE_pp = p;
   4084 		*out_FALSE_val = FStr_InitRefer(var_Error);
   4085 		*out_FALSE_res = VPR_ERR;
   4086 		return FALSE;
   4087 	}
   4088 
   4089 	v = VarFind(varname, scope, TRUE);
   4090 
   4091 	/* At this point, p points just after the variable name,
   4092 	 * either at ':' or at endc. */
   4093 
   4094 	if (v == NULL) {
   4095 		v = FindLocalLegacyVar(varname, namelen, scope,
   4096 		    out_TRUE_extraModifiers);
   4097 	}
   4098 
   4099 	if (v == NULL) {
   4100 		/*
   4101 		 * Defer expansion of dynamic variables if they appear in
   4102 		 * non-local scope since they are not defined there.
   4103 		 */
   4104 		dynamic = VarnameIsDynamic(varname, namelen) &&
   4105 			  (scope == SCOPE_CMDLINE || scope == SCOPE_GLOBAL);
   4106 
   4107 		if (!haveModifier) {
   4108 			p++;	/* skip endc */
   4109 			*out_FALSE_pp = p;
   4110 			*out_FALSE_res = EvalUndefined(dynamic, start, p,
   4111 			    varname, eflags, out_FALSE_val);
   4112 			return FALSE;
   4113 		}
   4114 
   4115 		/*
   4116 		 * The variable expression is based on an undefined variable.
   4117 		 * Nevertheless it needs a Var, for modifiers that access the
   4118 		 * variable name, such as :L or :?.
   4119 		 *
   4120 		 * Most modifiers leave this expression in the "undefined"
   4121 		 * state (VEF_UNDEF), only a few modifiers like :D, :U, :L,
   4122 		 * :P turn this undefined expression into a defined
   4123 		 * expression (VEF_DEF).
   4124 		 *
   4125 		 * At the end, after applying all modifiers, if the expression
   4126 		 * is still undefined, Var_Parse will return an empty string
   4127 		 * instead of the actually computed value.
   4128 		 */
   4129 		v = VarNew(FStr_InitOwn(varname), "", VAR_NONE);
   4130 		*out_TRUE_exprStatus = VES_UNDEF;
   4131 	} else
   4132 		free(varname);
   4133 
   4134 	*out_TRUE_endc = endc;
   4135 	*out_TRUE_p = p;
   4136 	*out_TRUE_v = v;
   4137 	*out_TRUE_haveModifier = haveModifier;
   4138 	*out_TRUE_dynamic = dynamic;
   4139 	return TRUE;
   4140 }
   4141 
   4142 /* Free the environment variable now since we own it. */
   4143 static void
   4144 FreeEnvVar(void **out_val_freeIt, Var *v, const char *value)
   4145 {
   4146 	char *varValue = Buf_DoneData(&v->val);
   4147 	if (value == varValue)
   4148 		*out_val_freeIt = varValue;
   4149 	else
   4150 		free(varValue);
   4151 
   4152 	FStr_Done(&v->name);
   4153 	free(v);
   4154 }
   4155 
   4156 /*
   4157  * Given the start of a variable expression (such as $v, $(VAR),
   4158  * ${VAR:Mpattern}), extract the variable name and value, and the modifiers,
   4159  * if any.  While doing that, apply the modifiers to the value of the
   4160  * expression, forming its final value.  A few of the modifiers such as :!cmd!
   4161  * or ::= have side effects.
   4162  *
   4163  * Input:
   4164  *	*pp		The string to parse.
   4165  *			When parsing a condition in ParseEmptyArg, it may also
   4166  *			point to the "y" of "empty(VARNAME:Modifiers)", which
   4167  *			is syntactically the same.
   4168  *	scope		The scope for finding variables
   4169  *	eflags		Control the exact details of parsing
   4170  *
   4171  * Output:
   4172  *	*pp		The position where to continue parsing.
   4173  *			TODO: After a parse error, the value of *pp is
   4174  *			unspecified.  It may not have been updated at all,
   4175  *			point to some random character in the string, to the
   4176  *			location of the parse error, or at the end of the
   4177  *			string.
   4178  *	*out_val	The value of the variable expression, never NULL.
   4179  *	*out_val	var_Error if there was a parse error.
   4180  *	*out_val	var_Error if the base variable of the expression was
   4181  *			undefined, eflags contains VARE_UNDEFERR, and none of
   4182  *			the modifiers turned the undefined expression into a
   4183  *			defined expression.
   4184  *			XXX: It is not guaranteed that an error message has
   4185  *			been printed.
   4186  *	*out_val	varUndefined if the base variable of the expression
   4187  *			was undefined, eflags did not contain VARE_UNDEFERR,
   4188  *			and none of the modifiers turned the undefined
   4189  *			expression into a defined expression.
   4190  *			XXX: It is not guaranteed that an error message has
   4191  *			been printed.
   4192  *	*out_val_freeIt	Must be freed by the caller after using *out_val.
   4193  */
   4194 /* coverity[+alloc : arg-*4] */
   4195 VarParseResult
   4196 Var_Parse(const char **pp, GNode *scope, VarEvalFlags eflags, FStr *out_val)
   4197 {
   4198 	const char *p = *pp;
   4199 	const char *const start = p;
   4200 	/* TRUE if have modifiers for the variable. */
   4201 	Boolean haveModifier;
   4202 	/* Starting character if variable in parens or braces. */
   4203 	char startc;
   4204 	/* Ending character if variable in parens or braces. */
   4205 	char endc;
   4206 	/*
   4207 	 * TRUE if the variable is local and we're expanding it in a
   4208 	 * non-local scope. This is done to support dynamic sources.
   4209 	 * The result is just the expression, unaltered.
   4210 	 */
   4211 	Boolean dynamic;
   4212 	const char *extramodifiers;
   4213 	Var *v;
   4214 	FStr value;
   4215 	char eflags_str[VarEvalFlags_ToStringSize];
   4216 	VarExprStatus exprStatus = VES_NONE;
   4217 
   4218 	DEBUG2(VAR, "Var_Parse: %s with %s\n", start,
   4219 	    VarEvalFlags_ToString(eflags_str, eflags));
   4220 
   4221 	*out_val = FStr_InitRefer(NULL);
   4222 	extramodifiers = NULL;	/* extra modifiers to apply first */
   4223 	dynamic = FALSE;
   4224 
   4225 	/*
   4226 	 * Appease GCC, which thinks that the variable might not be
   4227 	 * initialized.
   4228 	 */
   4229 	endc = '\0';
   4230 
   4231 	startc = p[1];
   4232 	if (startc != '(' && startc != '{') {
   4233 		VarParseResult res;
   4234 		if (!ParseVarnameShort(startc, pp, scope, eflags, &res,
   4235 		    &out_val->str, &v))
   4236 			return res;
   4237 		haveModifier = FALSE;
   4238 		p++;
   4239 	} else {
   4240 		VarParseResult res;
   4241 		if (!ParseVarnameLong(p, startc, scope, eflags,
   4242 		    pp, &res, out_val,
   4243 		    &endc, &p, &v, &haveModifier, &extramodifiers,
   4244 		    &dynamic, &exprStatus))
   4245 			return res;
   4246 	}
   4247 
   4248 	if (v->flags & VAR_IN_USE)
   4249 		Fatal("Variable %s is recursive.", v->name.str);
   4250 
   4251 	/*
   4252 	 * XXX: This assignment creates an alias to the current value of the
   4253 	 * variable.  This means that as long as the value of the expression
   4254 	 * stays the same, the value of the variable must not change.
   4255 	 * Using the '::=' modifier, it could be possible to do exactly this.
   4256 	 * At the bottom of this function, the resulting value is compared to
   4257 	 * the then-current value of the variable.  This might also invoke
   4258 	 * undefined behavior.
   4259 	 */
   4260 	value = FStr_InitRefer(v->val.data);
   4261 
   4262 	/*
   4263 	 * Before applying any modifiers, expand any nested expressions from
   4264 	 * the variable value.
   4265 	 */
   4266 	if (strchr(value.str, '$') != NULL && (eflags & VARE_WANTRES)) {
   4267 		char *expanded;
   4268 		VarEvalFlags nested_eflags = eflags;
   4269 		if (opts.strict)
   4270 			nested_eflags &= ~(unsigned)VARE_UNDEFERR;
   4271 		v->flags |= VAR_IN_USE;
   4272 		(void)Var_Subst(value.str, scope, nested_eflags, &expanded);
   4273 		v->flags &= ~(unsigned)VAR_IN_USE;
   4274 		/* TODO: handle errors */
   4275 		value = FStr_InitOwn(expanded);
   4276 	}
   4277 
   4278 	if (haveModifier || extramodifiers != NULL) {
   4279 		if (extramodifiers != NULL) {
   4280 			const char *em = extramodifiers;
   4281 			value = ApplyModifiers(&em, value, '\0', '\0',
   4282 			    v, &exprStatus, scope, eflags);
   4283 		}
   4284 
   4285 		if (haveModifier) {
   4286 			p++;	/* Skip initial colon. */
   4287 
   4288 			value = ApplyModifiers(&p, value, startc, endc,
   4289 			    v, &exprStatus, scope, eflags);
   4290 		}
   4291 	}
   4292 
   4293 	if (*p != '\0')		/* Skip past endc if possible. */
   4294 		p++;
   4295 
   4296 	*pp = p;
   4297 
   4298 	if (v->flags & VAR_FROM_ENV) {
   4299 		FreeEnvVar(&value.freeIt, v, value.str);
   4300 
   4301 	} else if (exprStatus != VES_NONE) {
   4302 		if (exprStatus != VES_DEF) {
   4303 			FStr_Done(&value);
   4304 			if (dynamic) {
   4305 				value = FStr_InitOwn(bmake_strsedup(start, p));
   4306 			} else {
   4307 				/*
   4308 				 * The expression is still undefined,
   4309 				 * therefore discard the actual value and
   4310 				 * return an error marker instead.
   4311 				 */
   4312 				value = FStr_InitRefer(eflags & VARE_UNDEFERR
   4313 				    ? var_Error : varUndefined);
   4314 			}
   4315 		}
   4316 		if (value.str != v->val.data)
   4317 			Buf_Done(&v->val);
   4318 		FStr_Done(&v->name);
   4319 		free(v);
   4320 	}
   4321 	*out_val = (FStr){ value.str, value.freeIt };
   4322 	return VPR_OK;		/* XXX: Is not correct in all cases */
   4323 }
   4324 
   4325 static void
   4326 VarSubstDollarDollar(const char **pp, Buffer *res, VarEvalFlags eflags)
   4327 {
   4328 	/*
   4329 	 * A dollar sign may be escaped with another dollar
   4330 	 * sign.
   4331 	 */
   4332 	if (save_dollars && (eflags & VARE_KEEP_DOLLAR))
   4333 		Buf_AddByte(res, '$');
   4334 	Buf_AddByte(res, '$');
   4335 	*pp += 2;
   4336 }
   4337 
   4338 static void
   4339 VarSubstExpr(const char **pp, Buffer *buf, GNode *scope,
   4340 	     VarEvalFlags eflags, Boolean *inout_errorReported)
   4341 {
   4342 	const char *p = *pp;
   4343 	const char *nested_p = p;
   4344 	FStr val;
   4345 
   4346 	(void)Var_Parse(&nested_p, scope, eflags, &val);
   4347 	/* TODO: handle errors */
   4348 
   4349 	if (val.str == var_Error || val.str == varUndefined) {
   4350 		if (!(eflags & VARE_KEEP_UNDEF)) {
   4351 			p = nested_p;
   4352 		} else if ((eflags & VARE_UNDEFERR) || val.str == var_Error) {
   4353 
   4354 			/*
   4355 			 * XXX: This condition is wrong.  If val == var_Error,
   4356 			 * this doesn't necessarily mean there was an undefined
   4357 			 * variable.  It could equally well be a parse error;
   4358 			 * see unit-tests/varmod-order.exp.
   4359 			 */
   4360 
   4361 			/*
   4362 			 * If variable is undefined, complain and skip the
   4363 			 * variable. The complaint will stop us from doing
   4364 			 * anything when the file is parsed.
   4365 			 */
   4366 			if (!*inout_errorReported) {
   4367 				Parse_Error(PARSE_FATAL,
   4368 				    "Undefined variable \"%.*s\"",
   4369 				    (int)(size_t)(nested_p - p), p);
   4370 			}
   4371 			p = nested_p;
   4372 			*inout_errorReported = TRUE;
   4373 		} else {
   4374 			/* Copy the initial '$' of the undefined expression,
   4375 			 * thereby deferring expansion of the expression, but
   4376 			 * expand nested expressions if already possible.
   4377 			 * See unit-tests/varparse-undef-partial.mk. */
   4378 			Buf_AddByte(buf, *p);
   4379 			p++;
   4380 		}
   4381 	} else {
   4382 		p = nested_p;
   4383 		Buf_AddStr(buf, val.str);
   4384 	}
   4385 
   4386 	FStr_Done(&val);
   4387 
   4388 	*pp = p;
   4389 }
   4390 
   4391 /*
   4392  * Skip as many characters as possible -- either to the end of the string
   4393  * or to the next dollar sign (variable expression).
   4394  */
   4395 static void
   4396 VarSubstPlain(const char **pp, Buffer *res)
   4397 {
   4398 	const char *p = *pp;
   4399 	const char *start = p;
   4400 
   4401 	for (p++; *p != '$' && *p != '\0'; p++)
   4402 		continue;
   4403 	Buf_AddBytesBetween(res, start, p);
   4404 	*pp = p;
   4405 }
   4406 
   4407 /*
   4408  * Expand all variable expressions like $V, ${VAR}, $(VAR:Modifiers) in the
   4409  * given string.
   4410  *
   4411  * Input:
   4412  *	str		The string in which the variable expressions are
   4413  *			expanded.
   4414  *	scope		The scope in which to start searching for
   4415  *			variables.  The other scopes are searched as well.
   4416  *	eflags		Special effects during expansion.
   4417  */
   4418 VarParseResult
   4419 Var_Subst(const char *str, GNode *scope, VarEvalFlags eflags, char **out_res)
   4420 {
   4421 	const char *p = str;
   4422 	Buffer res;
   4423 
   4424 	/* Set true if an error has already been reported,
   4425 	 * to prevent a plethora of messages when recursing */
   4426 	/* XXX: Why is the 'static' necessary here? */
   4427 	static Boolean errorReported;
   4428 
   4429 	Buf_Init(&res);
   4430 	errorReported = FALSE;
   4431 
   4432 	while (*p != '\0') {
   4433 		if (p[0] == '$' && p[1] == '$')
   4434 			VarSubstDollarDollar(&p, &res, eflags);
   4435 		else if (p[0] == '$')
   4436 			VarSubstExpr(&p, &res, scope, eflags, &errorReported);
   4437 		else
   4438 			VarSubstPlain(&p, &res);
   4439 	}
   4440 
   4441 	*out_res = Buf_DoneDataCompact(&res);
   4442 	return VPR_OK;
   4443 }
   4444 
   4445 /* Initialize the variables module. */
   4446 void
   4447 Var_Init(void)
   4448 {
   4449 	SCOPE_INTERNAL = GNode_New("Internal");
   4450 	SCOPE_GLOBAL = GNode_New("Global");
   4451 	SCOPE_CMDLINE = GNode_New("Command");
   4452 }
   4453 
   4454 /* Clean up the variables module. */
   4455 void
   4456 Var_End(void)
   4457 {
   4458 	Var_Stats();
   4459 }
   4460 
   4461 void
   4462 Var_Stats(void)
   4463 {
   4464 	HashTable_DebugStats(&SCOPE_GLOBAL->vars, "Global variables");
   4465 }
   4466 
   4467 /* Print all variables in a scope, sorted by name. */
   4468 void
   4469 Var_Dump(GNode *scope)
   4470 {
   4471 	Vector /* of const char * */ vec;
   4472 	HashIter hi;
   4473 	size_t i;
   4474 	const char **varnames;
   4475 
   4476 	Vector_Init(&vec, sizeof(const char *));
   4477 
   4478 	HashIter_Init(&hi, &scope->vars);
   4479 	while (HashIter_Next(&hi) != NULL)
   4480 		*(const char **)Vector_Push(&vec) = hi.entry->key;
   4481 	varnames = vec.items;
   4482 
   4483 	qsort(varnames, vec.len, sizeof varnames[0], str_cmp_asc);
   4484 
   4485 	for (i = 0; i < vec.len; i++) {
   4486 		const char *varname = varnames[i];
   4487 		Var *var = HashTable_FindValue(&scope->vars, varname);
   4488 		debug_printf("%-16s = %s\n", varname, var->val.data);
   4489 	}
   4490 
   4491 	Vector_Done(&vec);
   4492 }
   4493