xref: /freebsd/contrib/bmake/var.c (revision bc96366c864c07ef352edb92017357917c75b36c)
1 /*	$NetBSD: var.c,v 1.186 2014/06/20 06:13:45 sjg 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 #ifndef MAKE_NATIVE
72 static char rcsid[] = "$NetBSD: var.c,v 1.186 2014/06/20 06:13:45 sjg Exp $";
73 #else
74 #include <sys/cdefs.h>
75 #ifndef lint
76 #if 0
77 static char sccsid[] = "@(#)var.c	8.3 (Berkeley) 3/19/94";
78 #else
79 __RCSID("$NetBSD: var.c,v 1.186 2014/06/20 06:13:45 sjg Exp $");
80 #endif
81 #endif /* not lint */
82 #endif
83 
84 /*-
85  * var.c --
86  *	Variable-handling functions
87  *
88  * Interface:
89  *	Var_Set		    Set the value of a variable in the given
90  *			    context. The variable is created if it doesn't
91  *			    yet exist. The value and variable name need not
92  *			    be preserved.
93  *
94  *	Var_Append	    Append more characters to an existing variable
95  *			    in the given context. The variable needn't
96  *			    exist already -- it will be created if it doesn't.
97  *			    A space is placed between the old value and the
98  *			    new one.
99  *
100  *	Var_Exists	    See if a variable exists.
101  *
102  *	Var_Value 	    Return the value of a variable in a context or
103  *			    NULL if the variable is undefined.
104  *
105  *	Var_Subst 	    Substitute named variable, or all variables if
106  *			    NULL in a string using
107  *			    the given context as the top-most one. If the
108  *			    third argument is non-zero, Parse_Error is
109  *			    called if any variables are undefined.
110  *
111  *	Var_Parse 	    Parse a variable expansion from a string and
112  *			    return the result and the number of characters
113  *			    consumed.
114  *
115  *	Var_Delete	    Delete a variable in a context.
116  *
117  *	Var_Init  	    Initialize this module.
118  *
119  * Debugging:
120  *	Var_Dump  	    Print out all variables defined in the given
121  *			    context.
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    <ctype.h>
132 #include    <inttypes.h>
133 #include    <stdlib.h>
134 #include    <limits.h>
135 #include    <time.h>
136 
137 #include    "make.h"
138 #include    "buf.h"
139 #include    "dir.h"
140 #include    "job.h"
141 
142 extern int makelevel;
143 /*
144  * This lets us tell if we have replaced the original environ
145  * (which we cannot free).
146  */
147 char **savedEnv = NULL;
148 
149 /*
150  * This is a harmless return value for Var_Parse that can be used by Var_Subst
151  * to determine if there was an error in parsing -- easier than returning
152  * a flag, as things outside this module don't give a hoot.
153  */
154 char 	var_Error[] = "";
155 
156 /*
157  * Similar to var_Error, but returned when the 'errnum' flag for Var_Parse is
158  * set false. Why not just use a constant? Well, gcc likes to condense
159  * identical string instances...
160  */
161 static char	varNoError[] = "";
162 
163 /*
164  * Internally, variables are contained in four different contexts.
165  *	1) the environment. They may not be changed. If an environment
166  *	    variable is appended-to, the result is placed in the global
167  *	    context.
168  *	2) the global context. Variables set in the Makefile are located in
169  *	    the global context. It is the penultimate context searched when
170  *	    substituting.
171  *	3) the command-line context. All variables set on the command line
172  *	   are placed in this context. They are UNALTERABLE once placed here.
173  *	4) the local context. Each target has associated with it a context
174  *	   list. On this list are located the structures describing such
175  *	   local variables as $(@) and $(*)
176  * The four contexts are searched in the reverse order from which they are
177  * listed.
178  */
179 GNode          *VAR_INTERNAL; /* variables from make itself */
180 GNode          *VAR_GLOBAL;   /* variables from the makefile */
181 GNode          *VAR_CMD;      /* variables defined on the command-line */
182 
183 #define FIND_CMD	0x1   /* look in VAR_CMD when searching */
184 #define FIND_GLOBAL	0x2   /* look in VAR_GLOBAL as well */
185 #define FIND_ENV  	0x4   /* look in the environment also */
186 
187 typedef struct Var {
188     char          *name;	/* the variable's name */
189     Buffer	  val;		/* its value */
190     int		  flags;    	/* miscellaneous status flags */
191 #define VAR_IN_USE	1   	    /* Variable's value currently being used.
192 				     * Used to avoid recursion */
193 #define VAR_FROM_ENV	2   	    /* Variable comes from the environment */
194 #define VAR_JUNK  	4   	    /* Variable is a junk variable that
195 				     * should be destroyed when done with
196 				     * it. Used by Var_Parse for undefined,
197 				     * modified variables */
198 #define VAR_KEEP	8	    /* Variable is VAR_JUNK, but we found
199 				     * a use for it in some modifier and
200 				     * the value is therefore valid */
201 #define VAR_EXPORTED	16 	    /* Variable is exported */
202 #define VAR_REEXPORT	32	    /* Indicate if var needs re-export.
203 				     * This would be true if it contains $'s
204 				     */
205 #define VAR_FROM_CMD	64 	    /* Variable came from command line */
206 }  Var;
207 
208 /*
209  * Exporting vars is expensive so skip it if we can
210  */
211 #define VAR_EXPORTED_NONE	0
212 #define VAR_EXPORTED_YES	1
213 #define VAR_EXPORTED_ALL	2
214 static int var_exportedVars = VAR_EXPORTED_NONE;
215 /*
216  * We pass this to Var_Export when doing the initial export
217  * or after updating an exported var.
218  */
219 #define VAR_EXPORT_PARENT 1
220 
221 /* Var*Pattern flags */
222 #define VAR_SUB_GLOBAL	0x01	/* Apply substitution globally */
223 #define VAR_SUB_ONE	0x02	/* Apply substitution to one word */
224 #define VAR_SUB_MATCHED	0x04	/* There was a match */
225 #define VAR_MATCH_START	0x08	/* Match at start of word */
226 #define VAR_MATCH_END	0x10	/* Match at end of word */
227 #define VAR_NOSUBST	0x20	/* don't expand vars in VarGetPattern */
228 
229 /* Var_Set flags */
230 #define VAR_NO_EXPORT	0x01	/* do not export */
231 
232 typedef struct {
233     /*
234      * The following fields are set by Var_Parse() when it
235      * encounters modifiers that need to keep state for use by
236      * subsequent modifiers within the same variable expansion.
237      */
238     Byte	varSpace;	/* Word separator in expansions */
239     Boolean	oneBigWord;	/* TRUE if we will treat the variable as a
240 				 * single big word, even if it contains
241 				 * embedded spaces (as opposed to the
242 				 * usual behaviour of treating it as
243 				 * several space-separated words). */
244 } Var_Parse_State;
245 
246 /* struct passed as 'void *' to VarSubstitute() for ":S/lhs/rhs/",
247  * to VarSYSVMatch() for ":lhs=rhs". */
248 typedef struct {
249     const char   *lhs;	    /* String to match */
250     int		  leftLen; /* Length of string */
251     const char   *rhs;	    /* Replacement string (w/ &'s removed) */
252     int		  rightLen; /* Length of replacement */
253     int		  flags;
254 } VarPattern;
255 
256 /* struct passed as 'void *' to VarLoopExpand() for ":@tvar@str@" */
257 typedef struct {
258     GNode	*ctxt;		/* variable context */
259     char	*tvar;		/* name of temp var */
260     int		tvarLen;
261     char	*str;		/* string to expand */
262     int		strLen;
263     int		errnum;		/* errnum for not defined */
264 } VarLoop_t;
265 
266 #ifndef NO_REGEX
267 /* struct passed as 'void *' to VarRESubstitute() for ":C///" */
268 typedef struct {
269     regex_t	   re;
270     int		   nsub;
271     regmatch_t 	  *matches;
272     char 	  *replace;
273     int		   flags;
274 } VarREPattern;
275 #endif
276 
277 /* struct passed to VarSelectWords() for ":[start..end]" */
278 typedef struct {
279     int		start;		/* first word to select */
280     int		end;		/* last word to select */
281 } VarSelectWords_t;
282 
283 static Var *VarFind(const char *, GNode *, int);
284 static void VarAdd(const char *, const char *, GNode *);
285 static Boolean VarHead(GNode *, Var_Parse_State *,
286 			char *, Boolean, Buffer *, void *);
287 static Boolean VarTail(GNode *, Var_Parse_State *,
288 			char *, Boolean, Buffer *, void *);
289 static Boolean VarSuffix(GNode *, Var_Parse_State *,
290 			char *, Boolean, Buffer *, void *);
291 static Boolean VarRoot(GNode *, Var_Parse_State *,
292 			char *, Boolean, Buffer *, void *);
293 static Boolean VarMatch(GNode *, Var_Parse_State *,
294 			char *, Boolean, Buffer *, void *);
295 #ifdef SYSVVARSUB
296 static Boolean VarSYSVMatch(GNode *, Var_Parse_State *,
297 			char *, Boolean, Buffer *, void *);
298 #endif
299 static Boolean VarNoMatch(GNode *, Var_Parse_State *,
300 			char *, Boolean, Buffer *, void *);
301 #ifndef NO_REGEX
302 static void VarREError(int, regex_t *, const char *);
303 static Boolean VarRESubstitute(GNode *, Var_Parse_State *,
304 			char *, Boolean, Buffer *, void *);
305 #endif
306 static Boolean VarSubstitute(GNode *, Var_Parse_State *,
307 			char *, Boolean, Buffer *, void *);
308 static Boolean VarLoopExpand(GNode *, Var_Parse_State *,
309 			char *, Boolean, Buffer *, void *);
310 static char *VarGetPattern(GNode *, Var_Parse_State *,
311 			   int, const char **, int, int *, int *,
312 			   VarPattern *);
313 static char *VarQuote(char *);
314 static char *VarHash(char *);
315 static char *VarModify(GNode *, Var_Parse_State *,
316     const char *,
317     Boolean (*)(GNode *, Var_Parse_State *, char *, Boolean, Buffer *, void *),
318     void *);
319 static char *VarOrder(const char *, const char);
320 static char *VarUniq(const char *);
321 static int VarWordCompare(const void *, const void *);
322 static void VarPrintVar(void *);
323 
324 #define BROPEN	'{'
325 #define BRCLOSE	'}'
326 #define PROPEN	'('
327 #define PRCLOSE	')'
328 
329 /*-
330  *-----------------------------------------------------------------------
331  * VarFind --
332  *	Find the given variable in the given context and any other contexts
333  *	indicated.
334  *
335  * Input:
336  *	name		name to find
337  *	ctxt		context in which to find it
338  *	flags		FIND_GLOBAL set means to look in the
339  *			VAR_GLOBAL context as well. FIND_CMD set means
340  *			to look in the VAR_CMD context also. FIND_ENV
341  *			set means to look in the environment
342  *
343  * Results:
344  *	A pointer to the structure describing the desired variable or
345  *	NULL if the variable does not exist.
346  *
347  * Side Effects:
348  *	None
349  *-----------------------------------------------------------------------
350  */
351 static Var *
352 VarFind(const char *name, GNode *ctxt, int flags)
353 {
354     Hash_Entry         	*var;
355     Var			*v;
356 
357 	/*
358 	 * If the variable name begins with a '.', it could very well be one of
359 	 * the local ones.  We check the name against all the local variables
360 	 * and substitute the short version in for 'name' if it matches one of
361 	 * them.
362 	 */
363 	if (*name == '.' && isupper((unsigned char) name[1]))
364 		switch (name[1]) {
365 		case 'A':
366 			if (!strcmp(name, ".ALLSRC"))
367 				name = ALLSRC;
368 			if (!strcmp(name, ".ARCHIVE"))
369 				name = ARCHIVE;
370 			break;
371 		case 'I':
372 			if (!strcmp(name, ".IMPSRC"))
373 				name = IMPSRC;
374 			break;
375 		case 'M':
376 			if (!strcmp(name, ".MEMBER"))
377 				name = MEMBER;
378 			break;
379 		case 'O':
380 			if (!strcmp(name, ".OODATE"))
381 				name = OODATE;
382 			break;
383 		case 'P':
384 			if (!strcmp(name, ".PREFIX"))
385 				name = PREFIX;
386 			break;
387 		case 'T':
388 			if (!strcmp(name, ".TARGET"))
389 				name = TARGET;
390 			break;
391 		}
392 #ifdef notyet
393     /* for compatibility with gmake */
394     if (name[0] == '^' && name[1] == '\0')
395 	    name = ALLSRC;
396 #endif
397 
398     /*
399      * First look for the variable in the given context. If it's not there,
400      * look for it in VAR_CMD, VAR_GLOBAL and the environment, in that order,
401      * depending on the FIND_* flags in 'flags'
402      */
403     var = Hash_FindEntry(&ctxt->context, name);
404 
405     if ((var == NULL) && (flags & FIND_CMD) && (ctxt != VAR_CMD)) {
406 	var = Hash_FindEntry(&VAR_CMD->context, name);
407     }
408     if (!checkEnvFirst && (var == NULL) && (flags & FIND_GLOBAL) &&
409 	(ctxt != VAR_GLOBAL))
410     {
411 	var = Hash_FindEntry(&VAR_GLOBAL->context, name);
412 	if ((var == NULL) && (ctxt != VAR_INTERNAL)) {
413 	    /* VAR_INTERNAL is subordinate to VAR_GLOBAL */
414 	    var = Hash_FindEntry(&VAR_INTERNAL->context, name);
415 	}
416     }
417     if ((var == NULL) && (flags & FIND_ENV)) {
418 	char *env;
419 
420 	if ((env = getenv(name)) != NULL) {
421 	    int		len;
422 
423 	    v = bmake_malloc(sizeof(Var));
424 	    v->name = bmake_strdup(name);
425 
426 	    len = strlen(env);
427 
428 	    Buf_Init(&v->val, len + 1);
429 	    Buf_AddBytes(&v->val, len, env);
430 
431 	    v->flags = VAR_FROM_ENV;
432 	    return (v);
433 	} else if (checkEnvFirst && (flags & FIND_GLOBAL) &&
434 		   (ctxt != VAR_GLOBAL))
435 	{
436 	    var = Hash_FindEntry(&VAR_GLOBAL->context, name);
437 	    if ((var == NULL) && (ctxt != VAR_INTERNAL)) {
438 		var = Hash_FindEntry(&VAR_INTERNAL->context, name);
439 	    }
440 	    if (var == NULL) {
441 		return NULL;
442 	    } else {
443 		return ((Var *)Hash_GetValue(var));
444 	    }
445 	} else {
446 	    return NULL;
447 	}
448     } else if (var == NULL) {
449 	return NULL;
450     } else {
451 	return ((Var *)Hash_GetValue(var));
452     }
453 }
454 
455 /*-
456  *-----------------------------------------------------------------------
457  * VarFreeEnv  --
458  *	If the variable is an environment variable, free it
459  *
460  * Input:
461  *	v		the variable
462  *	destroy		true if the value buffer should be destroyed.
463  *
464  * Results:
465  *	1 if it is an environment variable 0 ow.
466  *
467  * Side Effects:
468  *	The variable is free'ed if it is an environent variable.
469  *-----------------------------------------------------------------------
470  */
471 static Boolean
472 VarFreeEnv(Var *v, Boolean destroy)
473 {
474     if ((v->flags & VAR_FROM_ENV) == 0)
475 	return FALSE;
476     free(v->name);
477     Buf_Destroy(&v->val, destroy);
478     free(v);
479     return TRUE;
480 }
481 
482 /*-
483  *-----------------------------------------------------------------------
484  * VarAdd  --
485  *	Add a new variable of name name and value val to the given context
486  *
487  * Input:
488  *	name		name of variable to add
489  *	val		value to set it to
490  *	ctxt		context in which to set it
491  *
492  * Results:
493  *	None
494  *
495  * Side Effects:
496  *	The new variable is placed at the front of the given context
497  *	The name and val arguments are duplicated so they may
498  *	safely be freed.
499  *-----------------------------------------------------------------------
500  */
501 static void
502 VarAdd(const char *name, const char *val, GNode *ctxt)
503 {
504     Var   	  *v;
505     int		  len;
506     Hash_Entry    *h;
507 
508     v = bmake_malloc(sizeof(Var));
509 
510     len = val ? strlen(val) : 0;
511     Buf_Init(&v->val, len+1);
512     Buf_AddBytes(&v->val, len, val);
513 
514     v->flags = 0;
515 
516     h = Hash_CreateEntry(&ctxt->context, name, NULL);
517     Hash_SetValue(h, v);
518     v->name = h->name;
519     if (DEBUG(VAR)) {
520 	fprintf(debug_file, "%s:%s = %s\n", ctxt->name, name, val);
521     }
522 }
523 
524 /*-
525  *-----------------------------------------------------------------------
526  * Var_Delete --
527  *	Remove a variable from a context.
528  *
529  * Results:
530  *	None.
531  *
532  * Side Effects:
533  *	The Var structure is removed and freed.
534  *
535  *-----------------------------------------------------------------------
536  */
537 void
538 Var_Delete(const char *name, GNode *ctxt)
539 {
540     Hash_Entry 	  *ln;
541     char *cp;
542 
543     if (strchr(name, '$')) {
544 	cp = Var_Subst(NULL, name, VAR_GLOBAL, 0);
545     } else {
546 	cp = (char *)name;
547     }
548     ln = Hash_FindEntry(&ctxt->context, cp);
549     if (DEBUG(VAR)) {
550 	fprintf(debug_file, "%s:delete %s%s\n",
551 	    ctxt->name, cp, ln ? "" : " (not found)");
552     }
553     if (cp != name) {
554 	free(cp);
555     }
556     if (ln != NULL) {
557 	Var 	  *v;
558 
559 	v = (Var *)Hash_GetValue(ln);
560 	if ((v->flags & VAR_EXPORTED)) {
561 	    unsetenv(v->name);
562 	}
563 	if (strcmp(MAKE_EXPORTED, v->name) == 0) {
564 	    var_exportedVars = VAR_EXPORTED_NONE;
565 	}
566 	if (v->name != ln->name)
567 		free(v->name);
568 	Hash_DeleteEntry(&ctxt->context, ln);
569 	Buf_Destroy(&v->val, TRUE);
570 	free(v);
571     }
572 }
573 
574 
575 /*
576  * Export a var.
577  * We ignore make internal variables (those which start with '.')
578  * Also we jump through some hoops to avoid calling setenv
579  * more than necessary since it can leak.
580  * We only manipulate flags of vars if 'parent' is set.
581  */
582 static int
583 Var_Export1(const char *name, int parent)
584 {
585     char tmp[BUFSIZ];
586     Var *v;
587     char *val = NULL;
588     int n;
589 
590     if (*name == '.')
591 	return 0;			/* skip internals */
592     if (!name[1]) {
593 	/*
594 	 * A single char.
595 	 * If it is one of the vars that should only appear in
596 	 * local context, skip it, else we can get Var_Subst
597 	 * into a loop.
598 	 */
599 	switch (name[0]) {
600 	case '@':
601 	case '%':
602 	case '*':
603 	case '!':
604 	    return 0;
605 	}
606     }
607     v = VarFind(name, VAR_GLOBAL, 0);
608     if (v == NULL) {
609 	return 0;
610     }
611     if (!parent &&
612 	(v->flags & (VAR_EXPORTED|VAR_REEXPORT)) == VAR_EXPORTED) {
613 	return 0;			/* nothing to do */
614     }
615     val = Buf_GetAll(&v->val, NULL);
616     if (strchr(val, '$')) {
617 	if (parent) {
618 	    /*
619 	     * Flag this as something we need to re-export.
620 	     * No point actually exporting it now though,
621 	     * the child can do it at the last minute.
622 	     */
623 	    v->flags |= (VAR_EXPORTED|VAR_REEXPORT);
624 	    return 1;
625 	}
626 	if (v->flags & VAR_IN_USE) {
627 	    /*
628 	     * We recursed while exporting in a child.
629 	     * This isn't going to end well, just skip it.
630 	     */
631 	    return 0;
632 	}
633 	n = snprintf(tmp, sizeof(tmp), "${%s}", name);
634 	if (n < (int)sizeof(tmp)) {
635 	    val = Var_Subst(NULL, tmp, VAR_GLOBAL, 0);
636 	    setenv(name, val, 1);
637 	    free(val);
638 	}
639     } else {
640 	if (parent) {
641 	    v->flags &= ~VAR_REEXPORT;	/* once will do */
642 	}
643 	if (parent || !(v->flags & VAR_EXPORTED)) {
644 	    setenv(name, val, 1);
645 	}
646     }
647     /*
648      * This is so Var_Set knows to call Var_Export again...
649      */
650     if (parent) {
651 	v->flags |= VAR_EXPORTED;
652     }
653     return 1;
654 }
655 
656 /*
657  * This gets called from our children.
658  */
659 void
660 Var_ExportVars(void)
661 {
662     char tmp[BUFSIZ];
663     Hash_Entry         	*var;
664     Hash_Search 	state;
665     Var *v;
666     char *val;
667     int n;
668 
669     /*
670      * Several make's support this sort of mechanism for tracking
671      * recursion - but each uses a different name.
672      * We allow the makefiles to update MAKELEVEL and ensure
673      * children see a correctly incremented value.
674      */
675     snprintf(tmp, sizeof(tmp), "%d", makelevel + 1);
676     setenv(MAKE_LEVEL_ENV, tmp, 1);
677 
678     if (VAR_EXPORTED_NONE == var_exportedVars)
679 	return;
680 
681     if (VAR_EXPORTED_ALL == var_exportedVars) {
682 	/*
683 	 * Ouch! This is crazy...
684 	 */
685 	for (var = Hash_EnumFirst(&VAR_GLOBAL->context, &state);
686 	     var != NULL;
687 	     var = Hash_EnumNext(&state)) {
688 	    v = (Var *)Hash_GetValue(var);
689 	    Var_Export1(v->name, 0);
690 	}
691 	return;
692     }
693     /*
694      * We have a number of exported vars,
695      */
696     n = snprintf(tmp, sizeof(tmp), "${" MAKE_EXPORTED ":O:u}");
697     if (n < (int)sizeof(tmp)) {
698 	char **av;
699 	char *as;
700 	int ac;
701 	int i;
702 
703 	val = Var_Subst(NULL, tmp, VAR_GLOBAL, 0);
704 	av = brk_string(val, &ac, FALSE, &as);
705 	for (i = 0; i < ac; i++) {
706 	    Var_Export1(av[i], 0);
707 	}
708 	free(val);
709 	free(as);
710 	free(av);
711     }
712 }
713 
714 /*
715  * This is called when .export is seen or
716  * .MAKE.EXPORTED is modified.
717  * It is also called when any exported var is modified.
718  */
719 void
720 Var_Export(char *str, int isExport)
721 {
722     char *name;
723     char *val;
724     char **av;
725     char *as;
726     int track;
727     int ac;
728     int i;
729 
730     if (isExport && (!str || !str[0])) {
731 	var_exportedVars = VAR_EXPORTED_ALL; /* use with caution! */
732 	return;
733     }
734 
735     if (strncmp(str, "-env", 4) == 0) {
736 	track = 0;
737 	str += 4;
738     } else {
739 	track = VAR_EXPORT_PARENT;
740     }
741     val = Var_Subst(NULL, str, VAR_GLOBAL, 0);
742     av = brk_string(val, &ac, FALSE, &as);
743     for (i = 0; i < ac; i++) {
744 	name = av[i];
745 	if (!name[1]) {
746 	    /*
747 	     * A single char.
748 	     * If it is one of the vars that should only appear in
749 	     * local context, skip it, else we can get Var_Subst
750 	     * into a loop.
751 	     */
752 	    switch (name[0]) {
753 	    case '@':
754 	    case '%':
755 	    case '*':
756 	    case '!':
757 		continue;
758 	    }
759 	}
760 	if (Var_Export1(name, track)) {
761 	    if (VAR_EXPORTED_ALL != var_exportedVars)
762 		var_exportedVars = VAR_EXPORTED_YES;
763 	    if (isExport && track) {
764 		Var_Append(MAKE_EXPORTED, name, VAR_GLOBAL);
765 	    }
766 	}
767     }
768     free(val);
769     free(as);
770     free(av);
771 }
772 
773 
774 /*
775  * This is called when .unexport[-env] is seen.
776  */
777 extern char **environ;
778 
779 void
780 Var_UnExport(char *str)
781 {
782     char tmp[BUFSIZ];
783     char *vlist;
784     char *cp;
785     Boolean unexport_env;
786     int n;
787 
788     if (!str || !str[0]) {
789 	return; 			/* assert? */
790     }
791 
792     vlist = NULL;
793 
794     str += 8;
795     unexport_env = (strncmp(str, "-env", 4) == 0);
796     if (unexport_env) {
797 	char **newenv;
798 
799 	cp = getenv(MAKE_LEVEL_ENV);	/* we should preserve this */
800 	if (environ == savedEnv) {
801 	    /* we have been here before! */
802 	    newenv = bmake_realloc(environ, 2 * sizeof(char *));
803 	} else {
804 	    if (savedEnv) {
805 		free(savedEnv);
806 		savedEnv = NULL;
807 	    }
808 	    newenv = bmake_malloc(2 * sizeof(char *));
809 	}
810 	if (!newenv)
811 	    return;
812 	/* Note: we cannot safely free() the original environ. */
813 	environ = savedEnv = newenv;
814 	newenv[0] = NULL;
815 	newenv[1] = NULL;
816 	setenv(MAKE_LEVEL_ENV, cp, 1);
817     } else {
818 	for (; *str != '\n' && isspace((unsigned char) *str); str++)
819 	    continue;
820 	if (str[0] && str[0] != '\n') {
821 	    vlist = str;
822 	}
823     }
824 
825     if (!vlist) {
826 	/* Using .MAKE.EXPORTED */
827 	n = snprintf(tmp, sizeof(tmp), "${" MAKE_EXPORTED ":O:u}");
828 	if (n < (int)sizeof(tmp)) {
829 	    vlist = Var_Subst(NULL, tmp, VAR_GLOBAL, 0);
830 	}
831     }
832     if (vlist) {
833 	Var *v;
834 	char **av;
835 	char *as;
836 	int ac;
837 	int i;
838 
839 	av = brk_string(vlist, &ac, FALSE, &as);
840 	for (i = 0; i < ac; i++) {
841 	    v = VarFind(av[i], VAR_GLOBAL, 0);
842 	    if (!v)
843 		continue;
844 	    if (!unexport_env &&
845 		(v->flags & (VAR_EXPORTED|VAR_REEXPORT)) == VAR_EXPORTED) {
846 		unsetenv(v->name);
847 	    }
848 	    v->flags &= ~(VAR_EXPORTED|VAR_REEXPORT);
849 	    /*
850 	     * If we are unexporting a list,
851 	     * remove each one from .MAKE.EXPORTED.
852 	     * If we are removing them all,
853 	     * just delete .MAKE.EXPORTED below.
854 	     */
855 	    if (vlist == str) {
856 		n = snprintf(tmp, sizeof(tmp),
857 			     "${" MAKE_EXPORTED ":N%s}", v->name);
858 		if (n < (int)sizeof(tmp)) {
859 		    cp = Var_Subst(NULL, tmp, VAR_GLOBAL, 0);
860 		    Var_Set(MAKE_EXPORTED, cp, VAR_GLOBAL, 0);
861 		    free(cp);
862 		}
863 	    }
864 	}
865 	free(as);
866 	free(av);
867 	if (vlist != str) {
868 	    Var_Delete(MAKE_EXPORTED, VAR_GLOBAL);
869 	    free(vlist);
870 	}
871     }
872 }
873 
874 /*-
875  *-----------------------------------------------------------------------
876  * Var_Set --
877  *	Set the variable name to the value val in the given context.
878  *
879  * Input:
880  *	name		name of variable to set
881  *	val		value to give to the variable
882  *	ctxt		context in which to set it
883  *
884  * Results:
885  *	None.
886  *
887  * Side Effects:
888  *	If the variable doesn't yet exist, a new record is created for it.
889  *	Else the old value is freed and the new one stuck in its place
890  *
891  * Notes:
892  *	The variable is searched for only in its context before being
893  *	created in that context. I.e. if the context is VAR_GLOBAL,
894  *	only VAR_GLOBAL->context is searched. Likewise if it is VAR_CMD, only
895  *	VAR_CMD->context is searched. This is done to avoid the literally
896  *	thousands of unnecessary strcmp's that used to be done to
897  *	set, say, $(@) or $(<).
898  *	If the context is VAR_GLOBAL though, we check if the variable
899  *	was set in VAR_CMD from the command line and skip it if so.
900  *-----------------------------------------------------------------------
901  */
902 void
903 Var_Set(const char *name, const char *val, GNode *ctxt, int flags)
904 {
905     Var   *v;
906     char *expanded_name = NULL;
907 
908     /*
909      * We only look for a variable in the given context since anything set
910      * here will override anything in a lower context, so there's not much
911      * point in searching them all just to save a bit of memory...
912      */
913     if (strchr(name, '$') != NULL) {
914 	expanded_name = Var_Subst(NULL, name, ctxt, 0);
915 	if (expanded_name[0] == 0) {
916 	    if (DEBUG(VAR)) {
917 		fprintf(debug_file, "Var_Set(\"%s\", \"%s\", ...) "
918 			"name expands to empty string - ignored\n",
919 			name, val);
920 	    }
921 	    free(expanded_name);
922 	    return;
923 	}
924 	name = expanded_name;
925     }
926     if (ctxt == VAR_GLOBAL) {
927 	v = VarFind(name, VAR_CMD, 0);
928 	if (v != NULL) {
929 	    if ((v->flags & VAR_FROM_CMD)) {
930 		if (DEBUG(VAR)) {
931 		    fprintf(debug_file, "%s:%s = %s ignored!\n", ctxt->name, name, val);
932 		}
933 		goto out;
934 	    }
935 	    VarFreeEnv(v, TRUE);
936 	}
937     }
938     v = VarFind(name, ctxt, 0);
939     if (v == NULL) {
940 	if (ctxt == VAR_CMD && (flags & VAR_NO_EXPORT) == 0) {
941 	    /*
942 	     * This var would normally prevent the same name being added
943 	     * to VAR_GLOBAL, so delete it from there if needed.
944 	     * Otherwise -V name may show the wrong value.
945 	     */
946 	    Var_Delete(name, VAR_GLOBAL);
947 	}
948 	VarAdd(name, val, ctxt);
949     } else {
950 	Buf_Empty(&v->val);
951 	Buf_AddBytes(&v->val, strlen(val), val);
952 
953 	if (DEBUG(VAR)) {
954 	    fprintf(debug_file, "%s:%s = %s\n", ctxt->name, name, val);
955 	}
956 	if ((v->flags & VAR_EXPORTED)) {
957 	    Var_Export1(name, VAR_EXPORT_PARENT);
958 	}
959     }
960     /*
961      * Any variables given on the command line are automatically exported
962      * to the environment (as per POSIX standard)
963      */
964     if (ctxt == VAR_CMD && (flags & VAR_NO_EXPORT) == 0) {
965 	if (v == NULL) {
966 	    /* we just added it */
967 	    v = VarFind(name, ctxt, 0);
968 	}
969 	if (v != NULL)
970 	    v->flags |= VAR_FROM_CMD;
971 	/*
972 	 * If requested, don't export these in the environment
973 	 * individually.  We still put them in MAKEOVERRIDES so
974 	 * that the command-line settings continue to override
975 	 * Makefile settings.
976 	 */
977 	if (varNoExportEnv != TRUE)
978 	    setenv(name, val, 1);
979 
980 	Var_Append(MAKEOVERRIDES, name, VAR_GLOBAL);
981     }
982 
983 
984  out:
985     if (expanded_name != NULL)
986 	free(expanded_name);
987     if (v != NULL)
988 	VarFreeEnv(v, TRUE);
989 }
990 
991 /*-
992  *-----------------------------------------------------------------------
993  * Var_Append --
994  *	The variable of the given name has the given value appended to it in
995  *	the given context.
996  *
997  * Input:
998  *	name		name of variable to modify
999  *	val		String to append to it
1000  *	ctxt		Context in which this should occur
1001  *
1002  * Results:
1003  *	None
1004  *
1005  * Side Effects:
1006  *	If the variable doesn't exist, it is created. Else the strings
1007  *	are concatenated (with a space in between).
1008  *
1009  * Notes:
1010  *	Only if the variable is being sought in the global context is the
1011  *	environment searched.
1012  *	XXX: Knows its calling circumstances in that if called with ctxt
1013  *	an actual target, it will only search that context since only
1014  *	a local variable could be being appended to. This is actually
1015  *	a big win and must be tolerated.
1016  *-----------------------------------------------------------------------
1017  */
1018 void
1019 Var_Append(const char *name, const char *val, GNode *ctxt)
1020 {
1021     Var		   *v;
1022     Hash_Entry	   *h;
1023     char *expanded_name = NULL;
1024 
1025     if (strchr(name, '$') != NULL) {
1026 	expanded_name = Var_Subst(NULL, name, ctxt, 0);
1027 	if (expanded_name[0] == 0) {
1028 	    if (DEBUG(VAR)) {
1029 		fprintf(debug_file, "Var_Append(\"%s\", \"%s\", ...) "
1030 			"name expands to empty string - ignored\n",
1031 			name, val);
1032 	    }
1033 	    free(expanded_name);
1034 	    return;
1035 	}
1036 	name = expanded_name;
1037     }
1038 
1039     v = VarFind(name, ctxt, (ctxt == VAR_GLOBAL) ? FIND_ENV : 0);
1040 
1041     if (v == NULL) {
1042 	VarAdd(name, val, ctxt);
1043     } else {
1044 	Buf_AddByte(&v->val, ' ');
1045 	Buf_AddBytes(&v->val, strlen(val), val);
1046 
1047 	if (DEBUG(VAR)) {
1048 	    fprintf(debug_file, "%s:%s = %s\n", ctxt->name, name,
1049 		   Buf_GetAll(&v->val, NULL));
1050 	}
1051 
1052 	if (v->flags & VAR_FROM_ENV) {
1053 	    /*
1054 	     * If the original variable came from the environment, we
1055 	     * have to install it in the global context (we could place
1056 	     * it in the environment, but then we should provide a way to
1057 	     * export other variables...)
1058 	     */
1059 	    v->flags &= ~VAR_FROM_ENV;
1060 	    h = Hash_CreateEntry(&ctxt->context, name, NULL);
1061 	    Hash_SetValue(h, v);
1062 	}
1063     }
1064     if (expanded_name != NULL)
1065 	free(expanded_name);
1066 }
1067 
1068 /*-
1069  *-----------------------------------------------------------------------
1070  * Var_Exists --
1071  *	See if the given variable exists.
1072  *
1073  * Input:
1074  *	name		Variable to find
1075  *	ctxt		Context in which to start search
1076  *
1077  * Results:
1078  *	TRUE if it does, FALSE if it doesn't
1079  *
1080  * Side Effects:
1081  *	None.
1082  *
1083  *-----------------------------------------------------------------------
1084  */
1085 Boolean
1086 Var_Exists(const char *name, GNode *ctxt)
1087 {
1088     Var		  *v;
1089     char          *cp;
1090 
1091     if ((cp = strchr(name, '$')) != NULL) {
1092 	cp = Var_Subst(NULL, name, ctxt, FALSE);
1093     }
1094     v = VarFind(cp ? cp : name, ctxt, FIND_CMD|FIND_GLOBAL|FIND_ENV);
1095     if (cp != NULL) {
1096 	free(cp);
1097     }
1098     if (v == NULL) {
1099 	return(FALSE);
1100     } else {
1101 	(void)VarFreeEnv(v, TRUE);
1102     }
1103     return(TRUE);
1104 }
1105 
1106 /*-
1107  *-----------------------------------------------------------------------
1108  * Var_Value --
1109  *	Return the value of the named variable in the given context
1110  *
1111  * Input:
1112  *	name		name to find
1113  *	ctxt		context in which to search for it
1114  *
1115  * Results:
1116  *	The value if the variable exists, NULL if it doesn't
1117  *
1118  * Side Effects:
1119  *	None
1120  *-----------------------------------------------------------------------
1121  */
1122 char *
1123 Var_Value(const char *name, GNode *ctxt, char **frp)
1124 {
1125     Var            *v;
1126 
1127     v = VarFind(name, ctxt, FIND_ENV | FIND_GLOBAL | FIND_CMD);
1128     *frp = NULL;
1129     if (v != NULL) {
1130 	char *p = (Buf_GetAll(&v->val, NULL));
1131 	if (VarFreeEnv(v, FALSE))
1132 	    *frp = p;
1133 	return p;
1134     } else {
1135 	return NULL;
1136     }
1137 }
1138 
1139 /*-
1140  *-----------------------------------------------------------------------
1141  * VarHead --
1142  *	Remove the tail of the given word and place the result in the given
1143  *	buffer.
1144  *
1145  * Input:
1146  *	word		Word to trim
1147  *	addSpace	True if need to add a space to the buffer
1148  *			before sticking in the head
1149  *	buf		Buffer in which to store it
1150  *
1151  * Results:
1152  *	TRUE if characters were added to the buffer (a space needs to be
1153  *	added to the buffer before the next word).
1154  *
1155  * Side Effects:
1156  *	The trimmed word is added to the buffer.
1157  *
1158  *-----------------------------------------------------------------------
1159  */
1160 static Boolean
1161 VarHead(GNode *ctx MAKE_ATTR_UNUSED, Var_Parse_State *vpstate,
1162 	char *word, Boolean addSpace, Buffer *buf,
1163 	void *dummy)
1164 {
1165     char *slash;
1166 
1167     slash = strrchr(word, '/');
1168     if (slash != NULL) {
1169 	if (addSpace && vpstate->varSpace) {
1170 	    Buf_AddByte(buf, vpstate->varSpace);
1171 	}
1172 	*slash = '\0';
1173 	Buf_AddBytes(buf, strlen(word), word);
1174 	*slash = '/';
1175 	return (TRUE);
1176     } else {
1177 	/*
1178 	 * If no directory part, give . (q.v. the POSIX standard)
1179 	 */
1180 	if (addSpace && vpstate->varSpace)
1181 	    Buf_AddByte(buf, vpstate->varSpace);
1182 	Buf_AddByte(buf, '.');
1183     }
1184     return(dummy ? TRUE : TRUE);
1185 }
1186 
1187 /*-
1188  *-----------------------------------------------------------------------
1189  * VarTail --
1190  *	Remove the head of the given word and place the result in the given
1191  *	buffer.
1192  *
1193  * Input:
1194  *	word		Word to trim
1195  *	addSpace	True if need to add a space to the buffer
1196  *			before adding the tail
1197  *	buf		Buffer in which to store it
1198  *
1199  * Results:
1200  *	TRUE if characters were added to the buffer (a space needs to be
1201  *	added to the buffer before the next word).
1202  *
1203  * Side Effects:
1204  *	The trimmed word is added to the buffer.
1205  *
1206  *-----------------------------------------------------------------------
1207  */
1208 static Boolean
1209 VarTail(GNode *ctx MAKE_ATTR_UNUSED, Var_Parse_State *vpstate,
1210 	char *word, Boolean addSpace, Buffer *buf,
1211 	void *dummy)
1212 {
1213     char *slash;
1214 
1215     if (addSpace && vpstate->varSpace) {
1216 	Buf_AddByte(buf, vpstate->varSpace);
1217     }
1218 
1219     slash = strrchr(word, '/');
1220     if (slash != NULL) {
1221 	*slash++ = '\0';
1222 	Buf_AddBytes(buf, strlen(slash), slash);
1223 	slash[-1] = '/';
1224     } else {
1225 	Buf_AddBytes(buf, strlen(word), word);
1226     }
1227     return (dummy ? TRUE : TRUE);
1228 }
1229 
1230 /*-
1231  *-----------------------------------------------------------------------
1232  * VarSuffix --
1233  *	Place the suffix of the given word in the given buffer.
1234  *
1235  * Input:
1236  *	word		Word to trim
1237  *	addSpace	TRUE if need to add a space before placing the
1238  *			suffix in the buffer
1239  *	buf		Buffer in which to store it
1240  *
1241  * Results:
1242  *	TRUE if characters were added to the buffer (a space needs to be
1243  *	added to the buffer before the next word).
1244  *
1245  * Side Effects:
1246  *	The suffix from the word is placed in the buffer.
1247  *
1248  *-----------------------------------------------------------------------
1249  */
1250 static Boolean
1251 VarSuffix(GNode *ctx MAKE_ATTR_UNUSED, Var_Parse_State *vpstate,
1252 	  char *word, Boolean addSpace, Buffer *buf,
1253 	  void *dummy)
1254 {
1255     char *dot;
1256 
1257     dot = strrchr(word, '.');
1258     if (dot != NULL) {
1259 	if (addSpace && vpstate->varSpace) {
1260 	    Buf_AddByte(buf, vpstate->varSpace);
1261 	}
1262 	*dot++ = '\0';
1263 	Buf_AddBytes(buf, strlen(dot), dot);
1264 	dot[-1] = '.';
1265 	addSpace = TRUE;
1266     }
1267     return (dummy ? addSpace : addSpace);
1268 }
1269 
1270 /*-
1271  *-----------------------------------------------------------------------
1272  * VarRoot --
1273  *	Remove the suffix of the given word and place the result in the
1274  *	buffer.
1275  *
1276  * Input:
1277  *	word		Word to trim
1278  *	addSpace	TRUE if need to add a space to the buffer
1279  *			before placing the root in it
1280  *	buf		Buffer in which to store it
1281  *
1282  * Results:
1283  *	TRUE if characters were added to the buffer (a space needs to be
1284  *	added to the buffer before the next word).
1285  *
1286  * Side Effects:
1287  *	The trimmed word is added to the buffer.
1288  *
1289  *-----------------------------------------------------------------------
1290  */
1291 static Boolean
1292 VarRoot(GNode *ctx MAKE_ATTR_UNUSED, Var_Parse_State *vpstate,
1293 	char *word, Boolean addSpace, Buffer *buf,
1294 	void *dummy)
1295 {
1296     char *dot;
1297 
1298     if (addSpace && vpstate->varSpace) {
1299 	Buf_AddByte(buf, vpstate->varSpace);
1300     }
1301 
1302     dot = strrchr(word, '.');
1303     if (dot != NULL) {
1304 	*dot = '\0';
1305 	Buf_AddBytes(buf, strlen(word), word);
1306 	*dot = '.';
1307     } else {
1308 	Buf_AddBytes(buf, strlen(word), word);
1309     }
1310     return (dummy ? TRUE : TRUE);
1311 }
1312 
1313 /*-
1314  *-----------------------------------------------------------------------
1315  * VarMatch --
1316  *	Place the word in the buffer if it matches the given pattern.
1317  *	Callback function for VarModify to implement the :M modifier.
1318  *
1319  * Input:
1320  *	word		Word to examine
1321  *	addSpace	TRUE if need to add a space to the buffer
1322  *			before adding the word, if it matches
1323  *	buf		Buffer in which to store it
1324  *	pattern		Pattern the word must match
1325  *
1326  * Results:
1327  *	TRUE if a space should be placed in the buffer before the next
1328  *	word.
1329  *
1330  * Side Effects:
1331  *	The word may be copied to the buffer.
1332  *
1333  *-----------------------------------------------------------------------
1334  */
1335 static Boolean
1336 VarMatch(GNode *ctx MAKE_ATTR_UNUSED, Var_Parse_State *vpstate,
1337 	 char *word, Boolean addSpace, Buffer *buf,
1338 	 void *pattern)
1339 {
1340     if (DEBUG(VAR))
1341 	fprintf(debug_file, "VarMatch [%s] [%s]\n", word, (char *)pattern);
1342     if (Str_Match(word, (char *)pattern)) {
1343 	if (addSpace && vpstate->varSpace) {
1344 	    Buf_AddByte(buf, vpstate->varSpace);
1345 	}
1346 	addSpace = TRUE;
1347 	Buf_AddBytes(buf, strlen(word), word);
1348     }
1349     return(addSpace);
1350 }
1351 
1352 #ifdef SYSVVARSUB
1353 /*-
1354  *-----------------------------------------------------------------------
1355  * VarSYSVMatch --
1356  *	Place the word in the buffer if it matches the given pattern.
1357  *	Callback function for VarModify to implement the System V %
1358  *	modifiers.
1359  *
1360  * Input:
1361  *	word		Word to examine
1362  *	addSpace	TRUE if need to add a space to the buffer
1363  *			before adding the word, if it matches
1364  *	buf		Buffer in which to store it
1365  *	patp		Pattern the word must match
1366  *
1367  * Results:
1368  *	TRUE if a space should be placed in the buffer before the next
1369  *	word.
1370  *
1371  * Side Effects:
1372  *	The word may be copied to the buffer.
1373  *
1374  *-----------------------------------------------------------------------
1375  */
1376 static Boolean
1377 VarSYSVMatch(GNode *ctx, Var_Parse_State *vpstate,
1378 	     char *word, Boolean addSpace, Buffer *buf,
1379 	     void *patp)
1380 {
1381     int len;
1382     char *ptr;
1383     VarPattern 	  *pat = (VarPattern *)patp;
1384     char *varexp;
1385 
1386     if (addSpace && vpstate->varSpace)
1387 	Buf_AddByte(buf, vpstate->varSpace);
1388 
1389     addSpace = TRUE;
1390 
1391     if ((ptr = Str_SYSVMatch(word, pat->lhs, &len)) != NULL) {
1392         varexp = Var_Subst(NULL, pat->rhs, ctx, 0);
1393 	Str_SYSVSubst(buf, varexp, ptr, len);
1394 	free(varexp);
1395     } else {
1396 	Buf_AddBytes(buf, strlen(word), word);
1397     }
1398 
1399     return(addSpace);
1400 }
1401 #endif
1402 
1403 
1404 /*-
1405  *-----------------------------------------------------------------------
1406  * VarNoMatch --
1407  *	Place the word in the buffer if it doesn't match the given pattern.
1408  *	Callback function for VarModify to implement the :N modifier.
1409  *
1410  * Input:
1411  *	word		Word to examine
1412  *	addSpace	TRUE if need to add a space to the buffer
1413  *			before adding the word, if it matches
1414  *	buf		Buffer in which to store it
1415  *	pattern		Pattern the word must match
1416  *
1417  * Results:
1418  *	TRUE if a space should be placed in the buffer before the next
1419  *	word.
1420  *
1421  * Side Effects:
1422  *	The word may be copied to the buffer.
1423  *
1424  *-----------------------------------------------------------------------
1425  */
1426 static Boolean
1427 VarNoMatch(GNode *ctx MAKE_ATTR_UNUSED, Var_Parse_State *vpstate,
1428 	   char *word, Boolean addSpace, Buffer *buf,
1429 	   void *pattern)
1430 {
1431     if (!Str_Match(word, (char *)pattern)) {
1432 	if (addSpace && vpstate->varSpace) {
1433 	    Buf_AddByte(buf, vpstate->varSpace);
1434 	}
1435 	addSpace = TRUE;
1436 	Buf_AddBytes(buf, strlen(word), word);
1437     }
1438     return(addSpace);
1439 }
1440 
1441 
1442 /*-
1443  *-----------------------------------------------------------------------
1444  * VarSubstitute --
1445  *	Perform a string-substitution on the given word, placing the
1446  *	result in the passed buffer.
1447  *
1448  * Input:
1449  *	word		Word to modify
1450  *	addSpace	True if space should be added before
1451  *			other characters
1452  *	buf		Buffer for result
1453  *	patternp	Pattern for substitution
1454  *
1455  * Results:
1456  *	TRUE if a space is needed before more characters are added.
1457  *
1458  * Side Effects:
1459  *	None.
1460  *
1461  *-----------------------------------------------------------------------
1462  */
1463 static Boolean
1464 VarSubstitute(GNode *ctx MAKE_ATTR_UNUSED, Var_Parse_State *vpstate,
1465 	      char *word, Boolean addSpace, Buffer *buf,
1466 	      void *patternp)
1467 {
1468     int  	wordLen;    /* Length of word */
1469     char 	*cp;	    /* General pointer */
1470     VarPattern	*pattern = (VarPattern *)patternp;
1471 
1472     wordLen = strlen(word);
1473     if ((pattern->flags & (VAR_SUB_ONE|VAR_SUB_MATCHED)) !=
1474 	(VAR_SUB_ONE|VAR_SUB_MATCHED)) {
1475 	/*
1476 	 * Still substituting -- break it down into simple anchored cases
1477 	 * and if none of them fits, perform the general substitution case.
1478 	 */
1479 	if ((pattern->flags & VAR_MATCH_START) &&
1480 	    (strncmp(word, pattern->lhs, pattern->leftLen) == 0)) {
1481 		/*
1482 		 * Anchored at start and beginning of word matches pattern
1483 		 */
1484 		if ((pattern->flags & VAR_MATCH_END) &&
1485 		    (wordLen == pattern->leftLen)) {
1486 			/*
1487 			 * Also anchored at end and matches to the end (word
1488 			 * is same length as pattern) add space and rhs only
1489 			 * if rhs is non-null.
1490 			 */
1491 			if (pattern->rightLen != 0) {
1492 			    if (addSpace && vpstate->varSpace) {
1493 				Buf_AddByte(buf, vpstate->varSpace);
1494 			    }
1495 			    addSpace = TRUE;
1496 			    Buf_AddBytes(buf, pattern->rightLen, pattern->rhs);
1497 			}
1498 			pattern->flags |= VAR_SUB_MATCHED;
1499 		} else if (pattern->flags & VAR_MATCH_END) {
1500 		    /*
1501 		     * Doesn't match to end -- copy word wholesale
1502 		     */
1503 		    goto nosub;
1504 		} else {
1505 		    /*
1506 		     * Matches at start but need to copy in trailing characters
1507 		     */
1508 		    if ((pattern->rightLen + wordLen - pattern->leftLen) != 0){
1509 			if (addSpace && vpstate->varSpace) {
1510 			    Buf_AddByte(buf, vpstate->varSpace);
1511 			}
1512 			addSpace = TRUE;
1513 		    }
1514 		    Buf_AddBytes(buf, pattern->rightLen, pattern->rhs);
1515 		    Buf_AddBytes(buf, wordLen - pattern->leftLen,
1516 				 (word + pattern->leftLen));
1517 		    pattern->flags |= VAR_SUB_MATCHED;
1518 		}
1519 	} else if (pattern->flags & VAR_MATCH_START) {
1520 	    /*
1521 	     * Had to match at start of word and didn't -- copy whole word.
1522 	     */
1523 	    goto nosub;
1524 	} else if (pattern->flags & VAR_MATCH_END) {
1525 	    /*
1526 	     * Anchored at end, Find only place match could occur (leftLen
1527 	     * characters from the end of the word) and see if it does. Note
1528 	     * that because the $ will be left at the end of the lhs, we have
1529 	     * to use strncmp.
1530 	     */
1531 	    cp = word + (wordLen - pattern->leftLen);
1532 	    if ((cp >= word) &&
1533 		(strncmp(cp, pattern->lhs, pattern->leftLen) == 0)) {
1534 		/*
1535 		 * Match found. If we will place characters in the buffer,
1536 		 * add a space before hand as indicated by addSpace, then
1537 		 * stuff in the initial, unmatched part of the word followed
1538 		 * by the right-hand-side.
1539 		 */
1540 		if (((cp - word) + pattern->rightLen) != 0) {
1541 		    if (addSpace && vpstate->varSpace) {
1542 			Buf_AddByte(buf, vpstate->varSpace);
1543 		    }
1544 		    addSpace = TRUE;
1545 		}
1546 		Buf_AddBytes(buf, cp - word, word);
1547 		Buf_AddBytes(buf, pattern->rightLen, pattern->rhs);
1548 		pattern->flags |= VAR_SUB_MATCHED;
1549 	    } else {
1550 		/*
1551 		 * Had to match at end and didn't. Copy entire word.
1552 		 */
1553 		goto nosub;
1554 	    }
1555 	} else {
1556 	    /*
1557 	     * Pattern is unanchored: search for the pattern in the word using
1558 	     * String_FindSubstring, copying unmatched portions and the
1559 	     * right-hand-side for each match found, handling non-global
1560 	     * substitutions correctly, etc. When the loop is done, any
1561 	     * remaining part of the word (word and wordLen are adjusted
1562 	     * accordingly through the loop) is copied straight into the
1563 	     * buffer.
1564 	     * addSpace is set FALSE as soon as a space is added to the
1565 	     * buffer.
1566 	     */
1567 	    Boolean done;
1568 	    int origSize;
1569 
1570 	    done = FALSE;
1571 	    origSize = Buf_Size(buf);
1572 	    while (!done) {
1573 		cp = Str_FindSubstring(word, pattern->lhs);
1574 		if (cp != NULL) {
1575 		    if (addSpace && (((cp - word) + pattern->rightLen) != 0)){
1576 			Buf_AddByte(buf, vpstate->varSpace);
1577 			addSpace = FALSE;
1578 		    }
1579 		    Buf_AddBytes(buf, cp-word, word);
1580 		    Buf_AddBytes(buf, pattern->rightLen, pattern->rhs);
1581 		    wordLen -= (cp - word) + pattern->leftLen;
1582 		    word = cp + pattern->leftLen;
1583 		    if (wordLen == 0) {
1584 			done = TRUE;
1585 		    }
1586 		    if ((pattern->flags & VAR_SUB_GLOBAL) == 0) {
1587 			done = TRUE;
1588 		    }
1589 		    pattern->flags |= VAR_SUB_MATCHED;
1590 		} else {
1591 		    done = TRUE;
1592 		}
1593 	    }
1594 	    if (wordLen != 0) {
1595 		if (addSpace && vpstate->varSpace) {
1596 		    Buf_AddByte(buf, vpstate->varSpace);
1597 		}
1598 		Buf_AddBytes(buf, wordLen, word);
1599 	    }
1600 	    /*
1601 	     * If added characters to the buffer, need to add a space
1602 	     * before we add any more. If we didn't add any, just return
1603 	     * the previous value of addSpace.
1604 	     */
1605 	    return ((Buf_Size(buf) != origSize) || addSpace);
1606 	}
1607 	return (addSpace);
1608     }
1609  nosub:
1610     if (addSpace && vpstate->varSpace) {
1611 	Buf_AddByte(buf, vpstate->varSpace);
1612     }
1613     Buf_AddBytes(buf, wordLen, word);
1614     return(TRUE);
1615 }
1616 
1617 #ifndef NO_REGEX
1618 /*-
1619  *-----------------------------------------------------------------------
1620  * VarREError --
1621  *	Print the error caused by a regcomp or regexec call.
1622  *
1623  * Results:
1624  *	None.
1625  *
1626  * Side Effects:
1627  *	An error gets printed.
1628  *
1629  *-----------------------------------------------------------------------
1630  */
1631 static void
1632 VarREError(int errnum, regex_t *pat, const char *str)
1633 {
1634     char *errbuf;
1635     int errlen;
1636 
1637     errlen = regerror(errnum, pat, 0, 0);
1638     errbuf = bmake_malloc(errlen);
1639     regerror(errnum, pat, errbuf, errlen);
1640     Error("%s: %s", str, errbuf);
1641     free(errbuf);
1642 }
1643 
1644 
1645 /*-
1646  *-----------------------------------------------------------------------
1647  * VarRESubstitute --
1648  *	Perform a regex substitution on the given word, placing the
1649  *	result in the passed buffer.
1650  *
1651  * Results:
1652  *	TRUE if a space is needed before more characters are added.
1653  *
1654  * Side Effects:
1655  *	None.
1656  *
1657  *-----------------------------------------------------------------------
1658  */
1659 static Boolean
1660 VarRESubstitute(GNode *ctx MAKE_ATTR_UNUSED,
1661 		Var_Parse_State *vpstate MAKE_ATTR_UNUSED,
1662 		char *word, Boolean addSpace, Buffer *buf,
1663 		void *patternp)
1664 {
1665     VarREPattern *pat;
1666     int xrv;
1667     char *wp;
1668     char *rp;
1669     int added;
1670     int flags = 0;
1671 
1672 #define MAYBE_ADD_SPACE()		\
1673 	if (addSpace && !added)		\
1674 	    Buf_AddByte(buf, ' ');	\
1675 	added = 1
1676 
1677     added = 0;
1678     wp = word;
1679     pat = patternp;
1680 
1681     if ((pat->flags & (VAR_SUB_ONE|VAR_SUB_MATCHED)) ==
1682 	(VAR_SUB_ONE|VAR_SUB_MATCHED))
1683 	xrv = REG_NOMATCH;
1684     else {
1685     tryagain:
1686 	xrv = regexec(&pat->re, wp, pat->nsub, pat->matches, flags);
1687     }
1688 
1689     switch (xrv) {
1690     case 0:
1691 	pat->flags |= VAR_SUB_MATCHED;
1692 	if (pat->matches[0].rm_so > 0) {
1693 	    MAYBE_ADD_SPACE();
1694 	    Buf_AddBytes(buf, pat->matches[0].rm_so, wp);
1695 	}
1696 
1697 	for (rp = pat->replace; *rp; rp++) {
1698 	    if ((*rp == '\\') && ((rp[1] == '&') || (rp[1] == '\\'))) {
1699 		MAYBE_ADD_SPACE();
1700 		Buf_AddByte(buf,rp[1]);
1701 		rp++;
1702 	    }
1703 	    else if ((*rp == '&') ||
1704 		((*rp == '\\') && isdigit((unsigned char)rp[1]))) {
1705 		int n;
1706 		const char *subbuf;
1707 		int sublen;
1708 		char errstr[3];
1709 
1710 		if (*rp == '&') {
1711 		    n = 0;
1712 		    errstr[0] = '&';
1713 		    errstr[1] = '\0';
1714 		} else {
1715 		    n = rp[1] - '0';
1716 		    errstr[0] = '\\';
1717 		    errstr[1] = rp[1];
1718 		    errstr[2] = '\0';
1719 		    rp++;
1720 		}
1721 
1722 		if (n > pat->nsub) {
1723 		    Error("No subexpression %s", &errstr[0]);
1724 		    subbuf = "";
1725 		    sublen = 0;
1726 		} else if ((pat->matches[n].rm_so == -1) &&
1727 			   (pat->matches[n].rm_eo == -1)) {
1728 		    Error("No match for subexpression %s", &errstr[0]);
1729 		    subbuf = "";
1730 		    sublen = 0;
1731 	        } else {
1732 		    subbuf = wp + pat->matches[n].rm_so;
1733 		    sublen = pat->matches[n].rm_eo - pat->matches[n].rm_so;
1734 		}
1735 
1736 		if (sublen > 0) {
1737 		    MAYBE_ADD_SPACE();
1738 		    Buf_AddBytes(buf, sublen, subbuf);
1739 		}
1740 	    } else {
1741 		MAYBE_ADD_SPACE();
1742 		Buf_AddByte(buf, *rp);
1743 	    }
1744 	}
1745 	wp += pat->matches[0].rm_eo;
1746 	if (pat->flags & VAR_SUB_GLOBAL) {
1747 	    flags |= REG_NOTBOL;
1748 	    if (pat->matches[0].rm_so == 0 && pat->matches[0].rm_eo == 0) {
1749 		MAYBE_ADD_SPACE();
1750 		Buf_AddByte(buf, *wp);
1751 		wp++;
1752 
1753 	    }
1754 	    if (*wp)
1755 		goto tryagain;
1756 	}
1757 	if (*wp) {
1758 	    MAYBE_ADD_SPACE();
1759 	    Buf_AddBytes(buf, strlen(wp), wp);
1760 	}
1761 	break;
1762     default:
1763 	VarREError(xrv, &pat->re, "Unexpected regex error");
1764        /* fall through */
1765     case REG_NOMATCH:
1766 	if (*wp) {
1767 	    MAYBE_ADD_SPACE();
1768 	    Buf_AddBytes(buf,strlen(wp),wp);
1769 	}
1770 	break;
1771     }
1772     return(addSpace||added);
1773 }
1774 #endif
1775 
1776 
1777 
1778 /*-
1779  *-----------------------------------------------------------------------
1780  * VarLoopExpand --
1781  *	Implements the :@<temp>@<string>@ modifier of ODE make.
1782  *	We set the temp variable named in pattern.lhs to word and expand
1783  *	pattern.rhs storing the result in the passed buffer.
1784  *
1785  * Input:
1786  *	word		Word to modify
1787  *	addSpace	True if space should be added before
1788  *			other characters
1789  *	buf		Buffer for result
1790  *	pattern		Datafor substitution
1791  *
1792  * Results:
1793  *	TRUE if a space is needed before more characters are added.
1794  *
1795  * Side Effects:
1796  *	None.
1797  *
1798  *-----------------------------------------------------------------------
1799  */
1800 static Boolean
1801 VarLoopExpand(GNode *ctx MAKE_ATTR_UNUSED,
1802 	      Var_Parse_State *vpstate MAKE_ATTR_UNUSED,
1803 	      char *word, Boolean addSpace, Buffer *buf,
1804 	      void *loopp)
1805 {
1806     VarLoop_t	*loop = (VarLoop_t *)loopp;
1807     char *s;
1808     int slen;
1809 
1810     if (word && *word) {
1811         Var_Set(loop->tvar, word, loop->ctxt, VAR_NO_EXPORT);
1812         s = Var_Subst(NULL, loop->str, loop->ctxt, loop->errnum);
1813         if (s != NULL && *s != '\0') {
1814             if (addSpace && *s != '\n')
1815                 Buf_AddByte(buf, ' ');
1816             Buf_AddBytes(buf, (slen = strlen(s)), s);
1817             addSpace = (slen > 0 && s[slen - 1] != '\n');
1818             free(s);
1819         }
1820     }
1821     return addSpace;
1822 }
1823 
1824 
1825 /*-
1826  *-----------------------------------------------------------------------
1827  * VarSelectWords --
1828  *	Implements the :[start..end] modifier.
1829  *	This is a special case of VarModify since we want to be able
1830  *	to scan the list backwards if start > end.
1831  *
1832  * Input:
1833  *	str		String whose words should be trimmed
1834  *	seldata		words to select
1835  *
1836  * Results:
1837  *	A string of all the words selected.
1838  *
1839  * Side Effects:
1840  *	None.
1841  *
1842  *-----------------------------------------------------------------------
1843  */
1844 static char *
1845 VarSelectWords(GNode *ctx MAKE_ATTR_UNUSED, Var_Parse_State *vpstate,
1846 	       const char *str, VarSelectWords_t *seldata)
1847 {
1848     Buffer  	  buf;		    /* Buffer for the new string */
1849     Boolean 	  addSpace; 	    /* TRUE if need to add a space to the
1850 				     * buffer before adding the trimmed
1851 				     * word */
1852     char **av;			    /* word list */
1853     char *as;			    /* word list memory */
1854     int ac, i;
1855     int start, end, step;
1856 
1857     Buf_Init(&buf, 0);
1858     addSpace = FALSE;
1859 
1860     if (vpstate->oneBigWord) {
1861 	/* fake what brk_string() would do if there were only one word */
1862 	ac = 1;
1863     	av = bmake_malloc((ac + 1) * sizeof(char *));
1864 	as = bmake_strdup(str);
1865 	av[0] = as;
1866 	av[1] = NULL;
1867     } else {
1868 	av = brk_string(str, &ac, FALSE, &as);
1869     }
1870 
1871     /*
1872      * Now sanitize seldata.
1873      * If seldata->start or seldata->end are negative, convert them to
1874      * the positive equivalents (-1 gets converted to argc, -2 gets
1875      * converted to (argc-1), etc.).
1876      */
1877     if (seldata->start < 0)
1878 	seldata->start = ac + seldata->start + 1;
1879     if (seldata->end < 0)
1880 	seldata->end = ac + seldata->end + 1;
1881 
1882     /*
1883      * We avoid scanning more of the list than we need to.
1884      */
1885     if (seldata->start > seldata->end) {
1886 	start = MIN(ac, seldata->start) - 1;
1887 	end = MAX(0, seldata->end - 1);
1888 	step = -1;
1889     } else {
1890 	start = MAX(0, seldata->start - 1);
1891 	end = MIN(ac, seldata->end);
1892 	step = 1;
1893     }
1894 
1895     for (i = start;
1896 	 (step < 0 && i >= end) || (step > 0 && i < end);
1897 	 i += step) {
1898 	if (av[i] && *av[i]) {
1899 	    if (addSpace && vpstate->varSpace) {
1900 		Buf_AddByte(&buf, vpstate->varSpace);
1901 	    }
1902 	    Buf_AddBytes(&buf, strlen(av[i]), av[i]);
1903 	    addSpace = TRUE;
1904 	}
1905     }
1906 
1907     free(as);
1908     free(av);
1909 
1910     return Buf_Destroy(&buf, FALSE);
1911 }
1912 
1913 
1914 /*-
1915  * VarRealpath --
1916  *	Replace each word with the result of realpath()
1917  *	if successful.
1918  */
1919 static Boolean
1920 VarRealpath(GNode *ctx MAKE_ATTR_UNUSED, Var_Parse_State *vpstate,
1921 	    char *word, Boolean addSpace, Buffer *buf,
1922 	    void *patternp MAKE_ATTR_UNUSED)
1923 {
1924 	struct stat st;
1925 	char rbuf[MAXPATHLEN];
1926 	char *rp;
1927 
1928 	if (addSpace && vpstate->varSpace) {
1929 	    Buf_AddByte(buf, vpstate->varSpace);
1930 	}
1931 	addSpace = TRUE;
1932 	rp = realpath(word, rbuf);
1933 	if (rp && *rp == '/' && stat(rp, &st) == 0)
1934 		word = rp;
1935 
1936 	Buf_AddBytes(buf, strlen(word), word);
1937 	return(addSpace);
1938 }
1939 
1940 /*-
1941  *-----------------------------------------------------------------------
1942  * VarModify --
1943  *	Modify each of the words of the passed string using the given
1944  *	function. Used to implement all modifiers.
1945  *
1946  * Input:
1947  *	str		String whose words should be trimmed
1948  *	modProc		Function to use to modify them
1949  *	datum		Datum to pass it
1950  *
1951  * Results:
1952  *	A string of all the words modified appropriately.
1953  *
1954  * Side Effects:
1955  *	None.
1956  *
1957  *-----------------------------------------------------------------------
1958  */
1959 static char *
1960 VarModify(GNode *ctx, Var_Parse_State *vpstate,
1961     const char *str,
1962     Boolean (*modProc)(GNode *, Var_Parse_State *, char *,
1963 		       Boolean, Buffer *, void *),
1964     void *datum)
1965 {
1966     Buffer  	  buf;		    /* Buffer for the new string */
1967     Boolean 	  addSpace; 	    /* TRUE if need to add a space to the
1968 				     * buffer before adding the trimmed
1969 				     * word */
1970     char **av;			    /* word list */
1971     char *as;			    /* word list memory */
1972     int ac, i;
1973 
1974     Buf_Init(&buf, 0);
1975     addSpace = FALSE;
1976 
1977     if (vpstate->oneBigWord) {
1978 	/* fake what brk_string() would do if there were only one word */
1979 	ac = 1;
1980     	av = bmake_malloc((ac + 1) * sizeof(char *));
1981 	as = bmake_strdup(str);
1982 	av[0] = as;
1983 	av[1] = NULL;
1984     } else {
1985 	av = brk_string(str, &ac, FALSE, &as);
1986     }
1987 
1988     for (i = 0; i < ac; i++) {
1989 	addSpace = (*modProc)(ctx, vpstate, av[i], addSpace, &buf, datum);
1990     }
1991 
1992     free(as);
1993     free(av);
1994 
1995     return Buf_Destroy(&buf, FALSE);
1996 }
1997 
1998 
1999 static int
2000 VarWordCompare(const void *a, const void *b)
2001 {
2002 	int r = strcmp(*(const char * const *)a, *(const char * const *)b);
2003 	return r;
2004 }
2005 
2006 /*-
2007  *-----------------------------------------------------------------------
2008  * VarOrder --
2009  *	Order the words in the string.
2010  *
2011  * Input:
2012  *	str		String whose words should be sorted.
2013  *	otype		How to order: s - sort, x - random.
2014  *
2015  * Results:
2016  *	A string containing the words ordered.
2017  *
2018  * Side Effects:
2019  *	None.
2020  *
2021  *-----------------------------------------------------------------------
2022  */
2023 static char *
2024 VarOrder(const char *str, const char otype)
2025 {
2026     Buffer  	  buf;		    /* Buffer for the new string */
2027     char **av;			    /* word list [first word does not count] */
2028     char *as;			    /* word list memory */
2029     int ac, i;
2030 
2031     Buf_Init(&buf, 0);
2032 
2033     av = brk_string(str, &ac, FALSE, &as);
2034 
2035     if (ac > 0)
2036 	switch (otype) {
2037 	case 's':	/* sort alphabetically */
2038 	    qsort(av, ac, sizeof(char *), VarWordCompare);
2039 	    break;
2040 	case 'x':	/* randomize */
2041 	{
2042 	    int rndidx;
2043 	    char *t;
2044 
2045 	    /*
2046 	     * We will use [ac..2] range for mod factors. This will produce
2047 	     * random numbers in [(ac-1)..0] interval, and minimal
2048 	     * reasonable value for mod factor is 2 (the mod 1 will produce
2049 	     * 0 with probability 1).
2050 	     */
2051 	    for (i = ac-1; i > 0; i--) {
2052 		rndidx = random() % (i + 1);
2053 		if (i != rndidx) {
2054 		    t = av[i];
2055 		    av[i] = av[rndidx];
2056 		    av[rndidx] = t;
2057 		}
2058 	    }
2059 	}
2060 	} /* end of switch */
2061 
2062     for (i = 0; i < ac; i++) {
2063 	Buf_AddBytes(&buf, strlen(av[i]), av[i]);
2064 	if (i != ac - 1)
2065 	    Buf_AddByte(&buf, ' ');
2066     }
2067 
2068     free(as);
2069     free(av);
2070 
2071     return Buf_Destroy(&buf, FALSE);
2072 }
2073 
2074 
2075 /*-
2076  *-----------------------------------------------------------------------
2077  * VarUniq --
2078  *	Remove adjacent duplicate words.
2079  *
2080  * Input:
2081  *	str		String whose words should be sorted
2082  *
2083  * Results:
2084  *	A string containing the resulting words.
2085  *
2086  * Side Effects:
2087  *	None.
2088  *
2089  *-----------------------------------------------------------------------
2090  */
2091 static char *
2092 VarUniq(const char *str)
2093 {
2094     Buffer	  buf;		    /* Buffer for new string */
2095     char 	**av;		    /* List of words to affect */
2096     char 	 *as;		    /* Word list memory */
2097     int 	  ac, i, j;
2098 
2099     Buf_Init(&buf, 0);
2100     av = brk_string(str, &ac, FALSE, &as);
2101 
2102     if (ac > 1) {
2103 	for (j = 0, i = 1; i < ac; i++)
2104 	    if (strcmp(av[i], av[j]) != 0 && (++j != i))
2105 		av[j] = av[i];
2106 	ac = j + 1;
2107     }
2108 
2109     for (i = 0; i < ac; i++) {
2110 	Buf_AddBytes(&buf, strlen(av[i]), av[i]);
2111 	if (i != ac - 1)
2112 	    Buf_AddByte(&buf, ' ');
2113     }
2114 
2115     free(as);
2116     free(av);
2117 
2118     return Buf_Destroy(&buf, FALSE);
2119 }
2120 
2121 
2122 /*-
2123  *-----------------------------------------------------------------------
2124  * VarGetPattern --
2125  *	Pass through the tstr looking for 1) escaped delimiters,
2126  *	'$'s and backslashes (place the escaped character in
2127  *	uninterpreted) and 2) unescaped $'s that aren't before
2128  *	the delimiter (expand the variable substitution unless flags
2129  *	has VAR_NOSUBST set).
2130  *	Return the expanded string or NULL if the delimiter was missing
2131  *	If pattern is specified, handle escaped ampersands, and replace
2132  *	unescaped ampersands with the lhs of the pattern.
2133  *
2134  * Results:
2135  *	A string of all the words modified appropriately.
2136  *	If length is specified, return the string length of the buffer
2137  *	If flags is specified and the last character of the pattern is a
2138  *	$ set the VAR_MATCH_END bit of flags.
2139  *
2140  * Side Effects:
2141  *	None.
2142  *-----------------------------------------------------------------------
2143  */
2144 static char *
2145 VarGetPattern(GNode *ctxt, Var_Parse_State *vpstate MAKE_ATTR_UNUSED,
2146 	      int errnum, const char **tstr, int delim, int *flags,
2147 	      int *length, VarPattern *pattern)
2148 {
2149     const char *cp;
2150     char *rstr;
2151     Buffer buf;
2152     int junk;
2153 
2154     Buf_Init(&buf, 0);
2155     if (length == NULL)
2156 	length = &junk;
2157 
2158 #define IS_A_MATCH(cp, delim) \
2159     ((cp[0] == '\\') && ((cp[1] == delim) ||  \
2160      (cp[1] == '\\') || (cp[1] == '$') || (pattern && (cp[1] == '&'))))
2161 
2162     /*
2163      * Skim through until the matching delimiter is found;
2164      * pick up variable substitutions on the way. Also allow
2165      * backslashes to quote the delimiter, $, and \, but don't
2166      * touch other backslashes.
2167      */
2168     for (cp = *tstr; *cp && (*cp != delim); cp++) {
2169 	if (IS_A_MATCH(cp, delim)) {
2170 	    Buf_AddByte(&buf, cp[1]);
2171 	    cp++;
2172 	} else if (*cp == '$') {
2173 	    if (cp[1] == delim) {
2174 		if (flags == NULL)
2175 		    Buf_AddByte(&buf, *cp);
2176 		else
2177 		    /*
2178 		     * Unescaped $ at end of pattern => anchor
2179 		     * pattern at end.
2180 		     */
2181 		    *flags |= VAR_MATCH_END;
2182 	    } else {
2183 		if (flags == NULL || (*flags & VAR_NOSUBST) == 0) {
2184 		    char   *cp2;
2185 		    int     len;
2186 		    void   *freeIt;
2187 
2188 		    /*
2189 		     * If unescaped dollar sign not before the
2190 		     * delimiter, assume it's a variable
2191 		     * substitution and recurse.
2192 		     */
2193 		    cp2 = Var_Parse(cp, ctxt, errnum, &len, &freeIt);
2194 		    Buf_AddBytes(&buf, strlen(cp2), cp2);
2195 		    if (freeIt)
2196 			free(freeIt);
2197 		    cp += len - 1;
2198 		} else {
2199 		    const char *cp2 = &cp[1];
2200 
2201 		    if (*cp2 == PROPEN || *cp2 == BROPEN) {
2202 			/*
2203 			 * Find the end of this variable reference
2204 			 * and suck it in without further ado.
2205 			 * It will be interperated later.
2206 			 */
2207 			int have = *cp2;
2208 			int want = (*cp2 == PROPEN) ? PRCLOSE : BRCLOSE;
2209 			int depth = 1;
2210 
2211 			for (++cp2; *cp2 != '\0' && depth > 0; ++cp2) {
2212 			    if (cp2[-1] != '\\') {
2213 				if (*cp2 == have)
2214 				    ++depth;
2215 				if (*cp2 == want)
2216 				    --depth;
2217 			    }
2218 			}
2219 			Buf_AddBytes(&buf, cp2 - cp, cp);
2220 			cp = --cp2;
2221 		    } else
2222 			Buf_AddByte(&buf, *cp);
2223 		}
2224 	    }
2225 	}
2226 	else if (pattern && *cp == '&')
2227 	    Buf_AddBytes(&buf, pattern->leftLen, pattern->lhs);
2228 	else
2229 	    Buf_AddByte(&buf, *cp);
2230     }
2231 
2232     if (*cp != delim) {
2233 	*tstr = cp;
2234 	*length = 0;
2235 	return NULL;
2236     }
2237 
2238     *tstr = ++cp;
2239     *length = Buf_Size(&buf);
2240     rstr = Buf_Destroy(&buf, FALSE);
2241     if (DEBUG(VAR))
2242 	fprintf(debug_file, "Modifier pattern: \"%s\"\n", rstr);
2243     return rstr;
2244 }
2245 
2246 /*-
2247  *-----------------------------------------------------------------------
2248  * VarQuote --
2249  *	Quote shell meta-characters in the string
2250  *
2251  * Results:
2252  *	The quoted string
2253  *
2254  * Side Effects:
2255  *	None.
2256  *
2257  *-----------------------------------------------------------------------
2258  */
2259 static char *
2260 VarQuote(char *str)
2261 {
2262 
2263     Buffer  	  buf;
2264     /* This should cover most shells :-( */
2265     static const char meta[] = "\n \t'`\";&<>()|*?{}[]\\$!#^~";
2266     const char	*newline;
2267     size_t len, nlen;
2268 
2269     if ((newline = Shell_GetNewline()) == NULL)
2270 	    newline = "\\\n";
2271     nlen = strlen(newline);
2272 
2273     Buf_Init(&buf, 0);
2274     while (*str != '\0') {
2275 	if ((len = strcspn(str, meta)) != 0) {
2276 	    Buf_AddBytes(&buf, len, str);
2277 	    str += len;
2278 	} else if (*str == '\n') {
2279 	    Buf_AddBytes(&buf, nlen, newline);
2280 	    ++str;
2281 	} else {
2282 	    Buf_AddByte(&buf, '\\');
2283 	    Buf_AddByte(&buf, *str);
2284 	    ++str;
2285 	}
2286     }
2287     str = Buf_Destroy(&buf, FALSE);
2288     if (DEBUG(VAR))
2289 	fprintf(debug_file, "QuoteMeta: [%s]\n", str);
2290     return str;
2291 }
2292 
2293 /*-
2294  *-----------------------------------------------------------------------
2295  * VarHash --
2296  *      Hash the string using the MurmurHash3 algorithm.
2297  *      Output is computed using 32bit Little Endian arithmetic.
2298  *
2299  * Input:
2300  *	str		String to modify
2301  *
2302  * Results:
2303  *      Hash value of str, encoded as 8 hex digits.
2304  *
2305  * Side Effects:
2306  *      None.
2307  *
2308  *-----------------------------------------------------------------------
2309  */
2310 static char *
2311 VarHash(char *str)
2312 {
2313     static const char    hexdigits[16] = "0123456789abcdef";
2314     Buffer         buf;
2315     size_t         len, len2;
2316     unsigned char  *ustr = (unsigned char *)str;
2317     uint32_t       h, k, c1, c2;
2318 
2319     h  = 0x971e137bU;
2320     c1 = 0x95543787U;
2321     c2 = 0x2ad7eb25U;
2322     len2 = strlen(str);
2323 
2324     for (len = len2; len; ) {
2325 	k = 0;
2326 	switch (len) {
2327 	default:
2328 	    k = (ustr[3] << 24) | (ustr[2] << 16) | (ustr[1] << 8) | ustr[0];
2329 	    len -= 4;
2330 	    ustr += 4;
2331 	    break;
2332 	case 3:
2333 	    k |= (ustr[2] << 16);
2334 	case 2:
2335 	    k |= (ustr[1] << 8);
2336 	case 1:
2337 	    k |= ustr[0];
2338 	    len = 0;
2339 	}
2340 	c1 = c1 * 5 + 0x7b7d159cU;
2341 	c2 = c2 * 5 + 0x6bce6396U;
2342 	k *= c1;
2343 	k = (k << 11) ^ (k >> 21);
2344 	k *= c2;
2345 	h = (h << 13) ^ (h >> 19);
2346 	h = h * 5 + 0x52dce729U;
2347 	h ^= k;
2348    }
2349    h ^= len2;
2350    h *= 0x85ebca6b;
2351    h ^= h >> 13;
2352    h *= 0xc2b2ae35;
2353    h ^= h >> 16;
2354 
2355    Buf_Init(&buf, 0);
2356    for (len = 0; len < 8; ++len) {
2357        Buf_AddByte(&buf, hexdigits[h & 15]);
2358        h >>= 4;
2359    }
2360 
2361    return Buf_Destroy(&buf, FALSE);
2362 }
2363 
2364 static char *
2365 VarStrftime(const char *fmt, int zulu)
2366 {
2367     char buf[BUFSIZ];
2368     time_t utc;
2369 
2370     time(&utc);
2371     if (!*fmt)
2372 	fmt = "%c";
2373     strftime(buf, sizeof(buf), fmt, zulu ? gmtime(&utc) : localtime(&utc));
2374 
2375     buf[sizeof(buf) - 1] = '\0';
2376     return bmake_strdup(buf);
2377 }
2378 
2379 /*
2380  * Now we need to apply any modifiers the user wants applied.
2381  * These are:
2382  *  	  :M<pattern>	words which match the given <pattern>.
2383  *  			<pattern> is of the standard file
2384  *  			wildcarding form.
2385  *  	  :N<pattern>	words which do not match the given <pattern>.
2386  *  	  :S<d><pat1><d><pat2><d>[1gW]
2387  *  			Substitute <pat2> for <pat1> in the value
2388  *  	  :C<d><pat1><d><pat2><d>[1gW]
2389  *  			Substitute <pat2> for regex <pat1> in the value
2390  *  	  :H		Substitute the head of each word
2391  *  	  :T		Substitute the tail of each word
2392  *  	  :E		Substitute the extension (minus '.') of
2393  *  			each word
2394  *  	  :R		Substitute the root of each word
2395  *  			(pathname minus the suffix).
2396  *	  :O		("Order") Alphabeticaly sort words in variable.
2397  *	  :Ox		("intermiX") Randomize words in variable.
2398  *	  :u		("uniq") Remove adjacent duplicate words.
2399  *	  :tu		Converts the variable contents to uppercase.
2400  *	  :tl		Converts the variable contents to lowercase.
2401  *	  :ts[c]	Sets varSpace - the char used to
2402  *			separate words to 'c'. If 'c' is
2403  *			omitted then no separation is used.
2404  *	  :tW		Treat the variable contents as a single
2405  *			word, even if it contains spaces.
2406  *			(Mnemonic: one big 'W'ord.)
2407  *	  :tw		Treat the variable contents as multiple
2408  *			space-separated words.
2409  *			(Mnemonic: many small 'w'ords.)
2410  *	  :[index]	Select a single word from the value.
2411  *	  :[start..end]	Select multiple words from the value.
2412  *	  :[*] or :[0]	Select the entire value, as a single
2413  *			word.  Equivalent to :tW.
2414  *	  :[@]		Select the entire value, as multiple
2415  *			words.	Undoes the effect of :[*].
2416  *			Equivalent to :tw.
2417  *	  :[#]		Returns the number of words in the value.
2418  *
2419  *	  :?<true-value>:<false-value>
2420  *			If the variable evaluates to true, return
2421  *			true value, else return the second value.
2422  *    	  :lhs=rhs  	Like :S, but the rhs goes to the end of
2423  *    			the invocation.
2424  *	  :sh		Treat the current value as a command
2425  *			to be run, new value is its output.
2426  * The following added so we can handle ODE makefiles.
2427  *	  :@<tmpvar>@<newval>@
2428  *			Assign a temporary local variable <tmpvar>
2429  *			to the current value of each word in turn
2430  *			and replace each word with the result of
2431  *			evaluating <newval>
2432  *	  :D<newval>	Use <newval> as value if variable defined
2433  *	  :U<newval>	Use <newval> as value if variable undefined
2434  *	  :L		Use the name of the variable as the value.
2435  *	  :P		Use the path of the node that has the same
2436  *			name as the variable as the value.  This
2437  *			basically includes an implied :L so that
2438  *			the common method of refering to the path
2439  *			of your dependent 'x' in a rule is to use
2440  *			the form '${x:P}'.
2441  *	  :!<cmd>!	Run cmd much the same as :sh run's the
2442  *			current value of the variable.
2443  * The ::= modifiers, actually assign a value to the variable.
2444  * Their main purpose is in supporting modifiers of .for loop
2445  * iterators and other obscure uses.  They always expand to
2446  * nothing.  In a target rule that would otherwise expand to an
2447  * empty line they can be preceded with @: to keep make happy.
2448  * Eg.
2449  *
2450  * foo:	.USE
2451  * .for i in ${.TARGET} ${.TARGET:R}.gz
2452  * 	@: ${t::=$i}
2453  *	@echo blah ${t:T}
2454  * .endfor
2455  *
2456  *	  ::=<str>	Assigns <str> as the new value of variable.
2457  *	  ::?=<str>	Assigns <str> as value of variable if
2458  *			it was not already set.
2459  *	  ::+=<str>	Appends <str> to variable.
2460  *	  ::!=<cmd>	Assigns output of <cmd> as the new value of
2461  *			variable.
2462  */
2463 
2464 /* we now have some modifiers with long names */
2465 #define STRMOD_MATCH(s, want, n) \
2466     (strncmp(s, want, n) == 0 && (s[n] == endc || s[n] == ':'))
2467 
2468 static char *
2469 ApplyModifiers(char *nstr, const char *tstr,
2470 	       int startc, int endc,
2471 	       Var *v, GNode *ctxt, Boolean errnum,
2472 	       int *lengthPtr, void **freePtr)
2473 {
2474     const char 	   *start;
2475     const char     *cp;    	/* Secondary pointer into str (place marker
2476 				 * for tstr) */
2477     char	   *newStr;	/* New value to return */
2478     char	    termc;	/* Character which terminated scan */
2479     int             cnt;	/* Used to count brace pairs when variable in
2480 				 * in parens or braces */
2481     char	delim;
2482     int		modifier;	/* that we are processing */
2483     Var_Parse_State parsestate; /* Flags passed to helper functions */
2484 
2485     delim = '\0';
2486     parsestate.oneBigWord = FALSE;
2487     parsestate.varSpace = ' ';	/* word separator */
2488 
2489     start = cp = tstr;
2490 
2491     while (*tstr && *tstr != endc) {
2492 
2493 	if (*tstr == '$') {
2494 	    /*
2495 	     * We may have some complex modifiers in a variable.
2496 	     */
2497 	    void *freeIt;
2498 	    char *rval;
2499 	    int rlen;
2500 	    int c;
2501 
2502 	    rval = Var_Parse(tstr, ctxt, errnum, &rlen, &freeIt);
2503 
2504 	    /*
2505 	     * If we have not parsed up to endc or ':',
2506 	     * we are not interested.
2507 	     */
2508 	    if (rval != NULL && *rval &&
2509 		(c = tstr[rlen]) != '\0' &&
2510 		c != ':' &&
2511 		c != endc) {
2512 		if (freeIt)
2513 		    free(freeIt);
2514 		goto apply_mods;
2515 	    }
2516 
2517 	    if (DEBUG(VAR)) {
2518 		fprintf(debug_file, "Got '%s' from '%.*s'%.*s\n",
2519 		       rval, rlen, tstr, rlen, tstr + rlen);
2520 	    }
2521 
2522 	    tstr += rlen;
2523 
2524 	    if (rval != NULL && *rval) {
2525 		int used;
2526 
2527 		nstr = ApplyModifiers(nstr, rval,
2528 				      0, 0,
2529 				      v, ctxt, errnum, &used, freePtr);
2530 		if (nstr == var_Error
2531 		    || (nstr == varNoError && errnum == 0)
2532 		    || strlen(rval) != (size_t) used) {
2533 		    if (freeIt)
2534 			free(freeIt);
2535 		    goto out;		/* error already reported */
2536 		}
2537 	    }
2538 	    if (freeIt)
2539 		free(freeIt);
2540 	    if (*tstr == ':')
2541 		tstr++;
2542 	    else if (!*tstr && endc) {
2543 		Error("Unclosed variable specification after complex modifier (expecting '%c') for %s", endc, v->name);
2544 		goto out;
2545 	    }
2546 	    continue;
2547 	}
2548     apply_mods:
2549 	if (DEBUG(VAR)) {
2550 	    fprintf(debug_file, "Applying[%s] :%c to \"%s\"\n", v->name,
2551 		*tstr, nstr);
2552 	}
2553 	newStr = var_Error;
2554 	switch ((modifier = *tstr)) {
2555 	case ':':
2556 	    {
2557 		if (tstr[1] == '=' ||
2558 		    (tstr[2] == '=' &&
2559 		     (tstr[1] == '!' || tstr[1] == '+' || tstr[1] == '?'))) {
2560 		    /*
2561 		     * "::=", "::!=", "::+=", or "::?="
2562 		     */
2563 		    GNode *v_ctxt;		/* context where v belongs */
2564 		    const char *emsg;
2565 		    char *sv_name;
2566 		    VarPattern	pattern;
2567 		    int	how;
2568 
2569 		    if (v->name[0] == 0)
2570 			goto bad_modifier;
2571 
2572 		    v_ctxt = ctxt;
2573 		    sv_name = NULL;
2574 		    ++tstr;
2575 		    if (v->flags & VAR_JUNK) {
2576 			/*
2577 			 * We need to bmake_strdup() it incase
2578 			 * VarGetPattern() recurses.
2579 			 */
2580 			sv_name = v->name;
2581 			v->name = bmake_strdup(v->name);
2582 		    } else if (ctxt != VAR_GLOBAL) {
2583 			Var *gv = VarFind(v->name, ctxt, 0);
2584 			if (gv == NULL)
2585 			    v_ctxt = VAR_GLOBAL;
2586 			else
2587 			    VarFreeEnv(gv, TRUE);
2588 		    }
2589 
2590 		    switch ((how = *tstr)) {
2591 		    case '+':
2592 		    case '?':
2593 		    case '!':
2594 			cp = &tstr[2];
2595 			break;
2596 		    default:
2597 			cp = ++tstr;
2598 			break;
2599 		    }
2600 		    delim = startc == PROPEN ? PRCLOSE : BRCLOSE;
2601 		    pattern.flags = 0;
2602 
2603 		    pattern.rhs = VarGetPattern(ctxt, &parsestate, errnum,
2604 						&cp, delim, NULL,
2605 						&pattern.rightLen,
2606 						NULL);
2607 		    if (v->flags & VAR_JUNK) {
2608 			/* restore original name */
2609 			free(v->name);
2610 			v->name = sv_name;
2611 		    }
2612 		    if (pattern.rhs == NULL)
2613 			goto cleanup;
2614 
2615 		    termc = *--cp;
2616 		    delim = '\0';
2617 
2618 		    switch (how) {
2619 		    case '+':
2620 			Var_Append(v->name, pattern.rhs, v_ctxt);
2621 			break;
2622 		    case '!':
2623 			newStr = Cmd_Exec(pattern.rhs, &emsg);
2624 			if (emsg)
2625 			    Error(emsg, nstr);
2626 			else
2627 			    Var_Set(v->name, newStr,  v_ctxt, 0);
2628 			if (newStr)
2629 			    free(newStr);
2630 			break;
2631 		    case '?':
2632 			if ((v->flags & VAR_JUNK) == 0)
2633 			    break;
2634 			/* FALLTHROUGH */
2635 		    default:
2636 			Var_Set(v->name, pattern.rhs, v_ctxt, 0);
2637 			break;
2638 		    }
2639 		    free(UNCONST(pattern.rhs));
2640 		    newStr = varNoError;
2641 		    break;
2642 		}
2643 		goto default_case; /* "::<unrecognised>" */
2644 	    }
2645 	case '@':
2646 	    {
2647 		VarLoop_t	loop;
2648 		int flags = VAR_NOSUBST;
2649 
2650 		cp = ++tstr;
2651 		delim = '@';
2652 		if ((loop.tvar = VarGetPattern(ctxt, &parsestate, errnum,
2653 					       &cp, delim,
2654 					       &flags, &loop.tvarLen,
2655 					       NULL)) == NULL)
2656 		    goto cleanup;
2657 
2658 		if ((loop.str = VarGetPattern(ctxt, &parsestate, errnum,
2659 					      &cp, delim,
2660 					      &flags, &loop.strLen,
2661 					      NULL)) == NULL)
2662 		    goto cleanup;
2663 
2664 		termc = *cp;
2665 		delim = '\0';
2666 
2667 		loop.errnum = errnum;
2668 		loop.ctxt = ctxt;
2669 		newStr = VarModify(ctxt, &parsestate, nstr, VarLoopExpand,
2670 				   &loop);
2671 		free(loop.tvar);
2672 		free(loop.str);
2673 		break;
2674 	    }
2675 	case 'D':
2676 	case 'U':
2677 	    {
2678 		Buffer  buf;    	/* Buffer for patterns */
2679 		int	    wantit;	/* want data in buffer */
2680 
2681 		/*
2682 		 * Pass through tstr looking for 1) escaped delimiters,
2683 		 * '$'s and backslashes (place the escaped character in
2684 		 * uninterpreted) and 2) unescaped $'s that aren't before
2685 		 * the delimiter (expand the variable substitution).
2686 		 * The result is left in the Buffer buf.
2687 		 */
2688 		Buf_Init(&buf, 0);
2689 		for (cp = tstr + 1;
2690 		     *cp != endc && *cp != ':' && *cp != '\0';
2691 		     cp++) {
2692 		    if ((*cp == '\\') &&
2693 			((cp[1] == ':') ||
2694 			 (cp[1] == '$') ||
2695 			 (cp[1] == endc) ||
2696 			 (cp[1] == '\\')))
2697 			{
2698 			    Buf_AddByte(&buf, cp[1]);
2699 			    cp++;
2700 			} else if (*cp == '$') {
2701 			    /*
2702 			     * If unescaped dollar sign, assume it's a
2703 			     * variable substitution and recurse.
2704 			     */
2705 			    char    *cp2;
2706 			    int	    len;
2707 			    void    *freeIt;
2708 
2709 			    cp2 = Var_Parse(cp, ctxt, errnum, &len, &freeIt);
2710 			    Buf_AddBytes(&buf, strlen(cp2), cp2);
2711 			    if (freeIt)
2712 				free(freeIt);
2713 			    cp += len - 1;
2714 			} else {
2715 			    Buf_AddByte(&buf, *cp);
2716 			}
2717 		}
2718 
2719 		termc = *cp;
2720 
2721 		if (*tstr == 'U')
2722 		    wantit = ((v->flags & VAR_JUNK) != 0);
2723 		else
2724 		    wantit = ((v->flags & VAR_JUNK) == 0);
2725 		if ((v->flags & VAR_JUNK) != 0)
2726 		    v->flags |= VAR_KEEP;
2727 		if (wantit) {
2728 		    newStr = Buf_Destroy(&buf, FALSE);
2729 		} else {
2730 		    newStr = nstr;
2731 		    Buf_Destroy(&buf, TRUE);
2732 		}
2733 		break;
2734 	    }
2735 	case 'L':
2736 	    {
2737 		if ((v->flags & VAR_JUNK) != 0)
2738 		    v->flags |= VAR_KEEP;
2739 		newStr = bmake_strdup(v->name);
2740 		cp = ++tstr;
2741 		termc = *tstr;
2742 		break;
2743 	    }
2744 	case 'P':
2745 	    {
2746 		GNode *gn;
2747 
2748 		if ((v->flags & VAR_JUNK) != 0)
2749 		    v->flags |= VAR_KEEP;
2750 		gn = Targ_FindNode(v->name, TARG_NOCREATE);
2751 		if (gn == NULL || gn->type & OP_NOPATH) {
2752 		    newStr = NULL;
2753 		} else if (gn->path) {
2754 		    newStr = bmake_strdup(gn->path);
2755 		} else {
2756 		    newStr = Dir_FindFile(v->name, Suff_FindPath(gn));
2757 		}
2758 		if (!newStr) {
2759 		    newStr = bmake_strdup(v->name);
2760 		}
2761 		cp = ++tstr;
2762 		termc = *tstr;
2763 		break;
2764 	    }
2765 	case '!':
2766 	    {
2767 		const char *emsg;
2768 		VarPattern 	    pattern;
2769 		pattern.flags = 0;
2770 
2771 		delim = '!';
2772 
2773 		cp = ++tstr;
2774 		if ((pattern.rhs = VarGetPattern(ctxt, &parsestate, errnum,
2775 						 &cp, delim,
2776 						 NULL, &pattern.rightLen,
2777 						 NULL)) == NULL)
2778 		    goto cleanup;
2779 		newStr = Cmd_Exec(pattern.rhs, &emsg);
2780 		free(UNCONST(pattern.rhs));
2781 		if (emsg)
2782 		    Error(emsg, nstr);
2783 		termc = *cp;
2784 		delim = '\0';
2785 		if (v->flags & VAR_JUNK) {
2786 		    v->flags |= VAR_KEEP;
2787 		}
2788 		break;
2789 	    }
2790 	case '[':
2791 	    {
2792 		/*
2793 		 * Look for the closing ']', recursively
2794 		 * expanding any embedded variables.
2795 		 *
2796 		 * estr is a pointer to the expanded result,
2797 		 * which we must free().
2798 		 */
2799 		char *estr;
2800 
2801 		cp = tstr+1; /* point to char after '[' */
2802 		delim = ']'; /* look for closing ']' */
2803 		estr = VarGetPattern(ctxt, &parsestate,
2804 				     errnum, &cp, delim,
2805 				     NULL, NULL, NULL);
2806 		if (estr == NULL)
2807 		    goto cleanup; /* report missing ']' */
2808 		/* now cp points just after the closing ']' */
2809 		delim = '\0';
2810 		if (cp[0] != ':' && cp[0] != endc) {
2811 		    /* Found junk after ']' */
2812 		    free(estr);
2813 		    goto bad_modifier;
2814 		}
2815 		if (estr[0] == '\0') {
2816 		    /* Found empty square brackets in ":[]". */
2817 		    free(estr);
2818 		    goto bad_modifier;
2819 		} else if (estr[0] == '#' && estr[1] == '\0') {
2820 		    /* Found ":[#]" */
2821 
2822 		    /*
2823 		     * We will need enough space for the decimal
2824 		     * representation of an int.  We calculate the
2825 		     * space needed for the octal representation,
2826 		     * and add enough slop to cope with a '-' sign
2827 		     * (which should never be needed) and a '\0'
2828 		     * string terminator.
2829 		     */
2830 		    int newStrSize =
2831 			(sizeof(int) * CHAR_BIT + 2) / 3 + 2;
2832 
2833 		    newStr = bmake_malloc(newStrSize);
2834 		    if (parsestate.oneBigWord) {
2835 			strncpy(newStr, "1", newStrSize);
2836 		    } else {
2837 			/* XXX: brk_string() is a rather expensive
2838 			 * way of counting words. */
2839 			char **av;
2840 			char *as;
2841 			int ac;
2842 
2843 			av = brk_string(nstr, &ac, FALSE, &as);
2844 			snprintf(newStr, newStrSize,  "%d", ac);
2845 			free(as);
2846 			free(av);
2847 		    }
2848 		    termc = *cp;
2849 		    free(estr);
2850 		    break;
2851 		} else if (estr[0] == '*' && estr[1] == '\0') {
2852 		    /* Found ":[*]" */
2853 		    parsestate.oneBigWord = TRUE;
2854 		    newStr = nstr;
2855 		    termc = *cp;
2856 		    free(estr);
2857 		    break;
2858 		} else if (estr[0] == '@' && estr[1] == '\0') {
2859 		    /* Found ":[@]" */
2860 		    parsestate.oneBigWord = FALSE;
2861 		    newStr = nstr;
2862 		    termc = *cp;
2863 		    free(estr);
2864 		    break;
2865 		} else {
2866 		    /*
2867 		     * We expect estr to contain a single
2868 		     * integer for :[N], or two integers
2869 		     * separated by ".." for :[start..end].
2870 		     */
2871 		    char *ep;
2872 
2873 		    VarSelectWords_t seldata = { 0, 0 };
2874 
2875 		    seldata.start = strtol(estr, &ep, 0);
2876 		    if (ep == estr) {
2877 			/* Found junk instead of a number */
2878 			free(estr);
2879 			goto bad_modifier;
2880 		    } else if (ep[0] == '\0') {
2881 			/* Found only one integer in :[N] */
2882 			seldata.end = seldata.start;
2883 		    } else if (ep[0] == '.' && ep[1] == '.' &&
2884 			       ep[2] != '\0') {
2885 			/* Expecting another integer after ".." */
2886 			ep += 2;
2887 			seldata.end = strtol(ep, &ep, 0);
2888 			if (ep[0] != '\0') {
2889 			    /* Found junk after ".." */
2890 			    free(estr);
2891 			    goto bad_modifier;
2892 			}
2893 		    } else {
2894 			/* Found junk instead of ".." */
2895 			free(estr);
2896 			goto bad_modifier;
2897 		    }
2898 		    /*
2899 		     * Now seldata is properly filled in,
2900 		     * but we still have to check for 0 as
2901 		     * a special case.
2902 		     */
2903 		    if (seldata.start == 0 && seldata.end == 0) {
2904 			/* ":[0]" or perhaps ":[0..0]" */
2905 			parsestate.oneBigWord = TRUE;
2906 			newStr = nstr;
2907 			termc = *cp;
2908 			free(estr);
2909 			break;
2910 		    } else if (seldata.start == 0 ||
2911 			       seldata.end == 0) {
2912 			/* ":[0..N]" or ":[N..0]" */
2913 			free(estr);
2914 			goto bad_modifier;
2915 		    }
2916 		    /*
2917 		     * Normal case: select the words
2918 		     * described by seldata.
2919 		     */
2920 		    newStr = VarSelectWords(ctxt, &parsestate,
2921 					    nstr, &seldata);
2922 
2923 		    termc = *cp;
2924 		    free(estr);
2925 		    break;
2926 		}
2927 
2928 	    }
2929 	case 'g':
2930 	    cp = tstr + 1;	/* make sure it is set */
2931 	    if (STRMOD_MATCH(tstr, "gmtime", 6)) {
2932 		newStr = VarStrftime(nstr, 1);
2933 		cp = tstr + 6;
2934 		termc = *cp;
2935 	    } else {
2936 		goto default_case;
2937 	    }
2938 	    break;
2939 	case 'h':
2940 	    cp = tstr + 1;	/* make sure it is set */
2941 	    if (STRMOD_MATCH(tstr, "hash", 4)) {
2942 		newStr = VarHash(nstr);
2943 		cp = tstr + 4;
2944 		termc = *cp;
2945 	    } else {
2946 		goto default_case;
2947 	    }
2948 	    break;
2949 	case 'l':
2950 	    cp = tstr + 1;	/* make sure it is set */
2951 	    if (STRMOD_MATCH(tstr, "localtime", 9)) {
2952 		newStr = VarStrftime(nstr, 0);
2953 		cp = tstr + 9;
2954 		termc = *cp;
2955 	    } else {
2956 		goto default_case;
2957 	    }
2958 	    break;
2959 	case 't':
2960 	    {
2961 		cp = tstr + 1;	/* make sure it is set */
2962 		if (tstr[1] != endc && tstr[1] != ':') {
2963 		    if (tstr[1] == 's') {
2964 			/*
2965 			 * Use the char (if any) at tstr[2]
2966 			 * as the word separator.
2967 			 */
2968 			VarPattern pattern;
2969 
2970 			if (tstr[2] != endc &&
2971 			    (tstr[3] == endc || tstr[3] == ':')) {
2972 			    /* ":ts<unrecognised><endc>" or
2973 			     * ":ts<unrecognised>:" */
2974 			    parsestate.varSpace = tstr[2];
2975 			    cp = tstr + 3;
2976 			} else if (tstr[2] == endc || tstr[2] == ':') {
2977 			    /* ":ts<endc>" or ":ts:" */
2978 			    parsestate.varSpace = 0; /* no separator */
2979 			    cp = tstr + 2;
2980 			} else if (tstr[2] == '\\') {
2981 			    switch (tstr[3]) {
2982 			    case 'n':
2983 				parsestate.varSpace = '\n';
2984 				cp = tstr + 4;
2985 				break;
2986 			    case 't':
2987 				parsestate.varSpace = '\t';
2988 				cp = tstr + 4;
2989 				break;
2990 			    default:
2991 				if (isdigit((unsigned char)tstr[3])) {
2992 				    char *ep;
2993 
2994 				    parsestate.varSpace =
2995 					strtoul(&tstr[3], &ep, 0);
2996 				    if (*ep != ':' && *ep != endc)
2997 					goto bad_modifier;
2998 				    cp = ep;
2999 				} else {
3000 				    /*
3001 				     * ":ts<backslash><unrecognised>".
3002 				     */
3003 				    goto bad_modifier;
3004 				}
3005 				break;
3006 			    }
3007 			} else {
3008 			    /*
3009 			     * Found ":ts<unrecognised><unrecognised>".
3010 			     */
3011 			    goto bad_modifier;
3012 			}
3013 
3014 			termc = *cp;
3015 
3016 			/*
3017 			 * We cannot be certain that VarModify
3018 			 * will be used - even if there is a
3019 			 * subsequent modifier, so do a no-op
3020 			 * VarSubstitute now to for str to be
3021 			 * re-expanded without the spaces.
3022 			 */
3023 			pattern.flags = VAR_SUB_ONE;
3024 			pattern.lhs = pattern.rhs = "\032";
3025 			pattern.leftLen = pattern.rightLen = 1;
3026 
3027 			newStr = VarModify(ctxt, &parsestate, nstr,
3028 					   VarSubstitute,
3029 					   &pattern);
3030 		    } else if (tstr[2] == endc || tstr[2] == ':') {
3031 			/*
3032 			 * Check for two-character options:
3033 			 * ":tu", ":tl"
3034 			 */
3035 			if (tstr[1] == 'A') { /* absolute path */
3036 			    newStr = VarModify(ctxt, &parsestate, nstr,
3037 					       VarRealpath, NULL);
3038 			    cp = tstr + 2;
3039 			    termc = *cp;
3040 			} else if (tstr[1] == 'u') {
3041 			    char *dp = bmake_strdup(nstr);
3042 			    for (newStr = dp; *dp; dp++)
3043 				*dp = toupper((unsigned char)*dp);
3044 			    cp = tstr + 2;
3045 			    termc = *cp;
3046 			} else if (tstr[1] == 'l') {
3047 			    char *dp = bmake_strdup(nstr);
3048 			    for (newStr = dp; *dp; dp++)
3049 				*dp = tolower((unsigned char)*dp);
3050 			    cp = tstr + 2;
3051 			    termc = *cp;
3052 			} else if (tstr[1] == 'W' || tstr[1] == 'w') {
3053 			    parsestate.oneBigWord = (tstr[1] == 'W');
3054 			    newStr = nstr;
3055 			    cp = tstr + 2;
3056 			    termc = *cp;
3057 			} else {
3058 			    /* Found ":t<unrecognised>:" or
3059 			     * ":t<unrecognised><endc>". */
3060 			    goto bad_modifier;
3061 			}
3062 		    } else {
3063 			/*
3064 			 * Found ":t<unrecognised><unrecognised>".
3065 			 */
3066 			goto bad_modifier;
3067 		    }
3068 		} else {
3069 		    /*
3070 		     * Found ":t<endc>" or ":t:".
3071 		     */
3072 		    goto bad_modifier;
3073 		}
3074 		break;
3075 	    }
3076 	case 'N':
3077 	case 'M':
3078 	    {
3079 		char    *pattern;
3080 		const char *endpat; /* points just after end of pattern */
3081 		char    *cp2;
3082 		Boolean copy;	/* pattern should be, or has been, copied */
3083 		Boolean needSubst;
3084 		int nest;
3085 
3086 		copy = FALSE;
3087 		needSubst = FALSE;
3088 		nest = 1;
3089 		/*
3090 		 * In the loop below, ignore ':' unless we are at
3091 		 * (or back to) the original brace level.
3092 		 * XXX This will likely not work right if $() and ${}
3093 		 * are intermixed.
3094 		 */
3095 		for (cp = tstr + 1;
3096 		     *cp != '\0' && !(*cp == ':' && nest == 1);
3097 		     cp++)
3098 		    {
3099 			if (*cp == '\\' &&
3100 			    (cp[1] == ':' ||
3101 			     cp[1] == endc || cp[1] == startc)) {
3102 			    if (!needSubst) {
3103 				copy = TRUE;
3104 			    }
3105 			    cp++;
3106 			    continue;
3107 			}
3108 			if (*cp == '$') {
3109 			    needSubst = TRUE;
3110 			}
3111 			if (*cp == '(' || *cp == '{')
3112 			    ++nest;
3113 			if (*cp == ')' || *cp == '}') {
3114 			    --nest;
3115 			    if (nest == 0)
3116 				break;
3117 			}
3118 		    }
3119 		termc = *cp;
3120 		endpat = cp;
3121 		if (copy) {
3122 		    /*
3123 		     * Need to compress the \:'s out of the pattern, so
3124 		     * allocate enough room to hold the uncompressed
3125 		     * pattern (note that cp started at tstr+1, so
3126 		     * cp - tstr takes the null byte into account) and
3127 		     * compress the pattern into the space.
3128 		     */
3129 		    pattern = bmake_malloc(cp - tstr);
3130 		    for (cp2 = pattern, cp = tstr + 1;
3131 			 cp < endpat;
3132 			 cp++, cp2++)
3133 			{
3134 			    if ((*cp == '\\') && (cp+1 < endpat) &&
3135 				(cp[1] == ':' || cp[1] == endc)) {
3136 				cp++;
3137 			    }
3138 			    *cp2 = *cp;
3139 			}
3140 		    *cp2 = '\0';
3141 		    endpat = cp2;
3142 		} else {
3143 		    /*
3144 		     * Either Var_Subst or VarModify will need a
3145 		     * nul-terminated string soon, so construct one now.
3146 		     */
3147 		    pattern = bmake_strndup(tstr+1, endpat - (tstr + 1));
3148 		}
3149 		if (needSubst) {
3150 		    /*
3151 		     * pattern contains embedded '$', so use Var_Subst to
3152 		     * expand it.
3153 		     */
3154 		    cp2 = pattern;
3155 		    pattern = Var_Subst(NULL, cp2, ctxt, errnum);
3156 		    free(cp2);
3157 		}
3158 		if (DEBUG(VAR))
3159 		    fprintf(debug_file, "Pattern[%s] for [%s] is [%s]\n",
3160 			v->name, nstr, pattern);
3161 		if (*tstr == 'M') {
3162 		    newStr = VarModify(ctxt, &parsestate, nstr, VarMatch,
3163 				       pattern);
3164 		} else {
3165 		    newStr = VarModify(ctxt, &parsestate, nstr, VarNoMatch,
3166 				       pattern);
3167 		}
3168 		free(pattern);
3169 		break;
3170 	    }
3171 	case 'S':
3172 	    {
3173 		VarPattern 	    pattern;
3174 		Var_Parse_State tmpparsestate;
3175 
3176 		pattern.flags = 0;
3177 		tmpparsestate = parsestate;
3178 		delim = tstr[1];
3179 		tstr += 2;
3180 
3181 		/*
3182 		 * If pattern begins with '^', it is anchored to the
3183 		 * start of the word -- skip over it and flag pattern.
3184 		 */
3185 		if (*tstr == '^') {
3186 		    pattern.flags |= VAR_MATCH_START;
3187 		    tstr += 1;
3188 		}
3189 
3190 		cp = tstr;
3191 		if ((pattern.lhs = VarGetPattern(ctxt, &parsestate, errnum,
3192 						 &cp, delim,
3193 						 &pattern.flags,
3194 						 &pattern.leftLen,
3195 						 NULL)) == NULL)
3196 		    goto cleanup;
3197 
3198 		if ((pattern.rhs = VarGetPattern(ctxt, &parsestate, errnum,
3199 						 &cp, delim, NULL,
3200 						 &pattern.rightLen,
3201 						 &pattern)) == NULL)
3202 		    goto cleanup;
3203 
3204 		/*
3205 		 * Check for global substitution. If 'g' after the final
3206 		 * delimiter, substitution is global and is marked that
3207 		 * way.
3208 		 */
3209 		for (;; cp++) {
3210 		    switch (*cp) {
3211 		    case 'g':
3212 			pattern.flags |= VAR_SUB_GLOBAL;
3213 			continue;
3214 		    case '1':
3215 			pattern.flags |= VAR_SUB_ONE;
3216 			continue;
3217 		    case 'W':
3218 			tmpparsestate.oneBigWord = TRUE;
3219 			continue;
3220 		    }
3221 		    break;
3222 		}
3223 
3224 		termc = *cp;
3225 		newStr = VarModify(ctxt, &tmpparsestate, nstr,
3226 				   VarSubstitute,
3227 				   &pattern);
3228 
3229 		/*
3230 		 * Free the two strings.
3231 		 */
3232 		free(UNCONST(pattern.lhs));
3233 		free(UNCONST(pattern.rhs));
3234 		delim = '\0';
3235 		break;
3236 	    }
3237 	case '?':
3238 	    {
3239 		VarPattern 	pattern;
3240 		Boolean	value;
3241 
3242 		/* find ':', and then substitute accordingly */
3243 
3244 		pattern.flags = 0;
3245 
3246 		cp = ++tstr;
3247 		delim = ':';
3248 		if ((pattern.lhs = VarGetPattern(ctxt, &parsestate, errnum,
3249 						 &cp, delim, NULL,
3250 						 &pattern.leftLen,
3251 						 NULL)) == NULL)
3252 		    goto cleanup;
3253 
3254 		/* BROPEN or PROPEN */
3255 		delim = endc;
3256 		if ((pattern.rhs = VarGetPattern(ctxt, &parsestate, errnum,
3257 						 &cp, delim, NULL,
3258 						 &pattern.rightLen,
3259 						 NULL)) == NULL)
3260 		    goto cleanup;
3261 
3262 		termc = *--cp;
3263 		delim = '\0';
3264 		if (Cond_EvalExpression(NULL, v->name, &value, 0)
3265 		    == COND_INVALID) {
3266 		    Error("Bad conditional expression `%s' in %s?%s:%s",
3267 			  v->name, v->name, pattern.lhs, pattern.rhs);
3268 		    goto cleanup;
3269 		}
3270 
3271 		if (value) {
3272 		    newStr = UNCONST(pattern.lhs);
3273 		    free(UNCONST(pattern.rhs));
3274 		} else {
3275 		    newStr = UNCONST(pattern.rhs);
3276 		    free(UNCONST(pattern.lhs));
3277 		}
3278 		if (v->flags & VAR_JUNK) {
3279 		    v->flags |= VAR_KEEP;
3280 		}
3281 		break;
3282 	    }
3283 #ifndef NO_REGEX
3284 	case 'C':
3285 	    {
3286 		VarREPattern    pattern;
3287 		char           *re;
3288 		int             error;
3289 		Var_Parse_State tmpparsestate;
3290 
3291 		pattern.flags = 0;
3292 		tmpparsestate = parsestate;
3293 		delim = tstr[1];
3294 		tstr += 2;
3295 
3296 		cp = tstr;
3297 
3298 		if ((re = VarGetPattern(ctxt, &parsestate, errnum, &cp, delim,
3299 					NULL, NULL, NULL)) == NULL)
3300 		    goto cleanup;
3301 
3302 		if ((pattern.replace = VarGetPattern(ctxt, &parsestate,
3303 						     errnum, &cp, delim, NULL,
3304 						     NULL, NULL)) == NULL){
3305 		    free(re);
3306 		    goto cleanup;
3307 		}
3308 
3309 		for (;; cp++) {
3310 		    switch (*cp) {
3311 		    case 'g':
3312 			pattern.flags |= VAR_SUB_GLOBAL;
3313 			continue;
3314 		    case '1':
3315 			pattern.flags |= VAR_SUB_ONE;
3316 			continue;
3317 		    case 'W':
3318 			tmpparsestate.oneBigWord = TRUE;
3319 			continue;
3320 		    }
3321 		    break;
3322 		}
3323 
3324 		termc = *cp;
3325 
3326 		error = regcomp(&pattern.re, re, REG_EXTENDED);
3327 		free(re);
3328 		if (error)  {
3329 		    *lengthPtr = cp - start + 1;
3330 		    VarREError(error, &pattern.re, "RE substitution error");
3331 		    free(pattern.replace);
3332 		    goto cleanup;
3333 		}
3334 
3335 		pattern.nsub = pattern.re.re_nsub + 1;
3336 		if (pattern.nsub < 1)
3337 		    pattern.nsub = 1;
3338 		if (pattern.nsub > 10)
3339 		    pattern.nsub = 10;
3340 		pattern.matches = bmake_malloc(pattern.nsub *
3341 					  sizeof(regmatch_t));
3342 		newStr = VarModify(ctxt, &tmpparsestate, nstr,
3343 				   VarRESubstitute,
3344 				   &pattern);
3345 		regfree(&pattern.re);
3346 		free(pattern.replace);
3347 		free(pattern.matches);
3348 		delim = '\0';
3349 		break;
3350 	    }
3351 #endif
3352 	case 'Q':
3353 	    if (tstr[1] == endc || tstr[1] == ':') {
3354 		newStr = VarQuote(nstr);
3355 		cp = tstr + 1;
3356 		termc = *cp;
3357 		break;
3358 	    }
3359 	    goto default_case;
3360 	case 'T':
3361 	    if (tstr[1] == endc || tstr[1] == ':') {
3362 		newStr = VarModify(ctxt, &parsestate, nstr, VarTail,
3363 				   NULL);
3364 		cp = tstr + 1;
3365 		termc = *cp;
3366 		break;
3367 	    }
3368 	    goto default_case;
3369 	case 'H':
3370 	    if (tstr[1] == endc || tstr[1] == ':') {
3371 		newStr = VarModify(ctxt, &parsestate, nstr, VarHead,
3372 				   NULL);
3373 		cp = tstr + 1;
3374 		termc = *cp;
3375 		break;
3376 	    }
3377 	    goto default_case;
3378 	case 'E':
3379 	    if (tstr[1] == endc || tstr[1] == ':') {
3380 		newStr = VarModify(ctxt, &parsestate, nstr, VarSuffix,
3381 				   NULL);
3382 		cp = tstr + 1;
3383 		termc = *cp;
3384 		break;
3385 	    }
3386 	    goto default_case;
3387 	case 'R':
3388 	    if (tstr[1] == endc || tstr[1] == ':') {
3389 		newStr = VarModify(ctxt, &parsestate, nstr, VarRoot,
3390 				   NULL);
3391 		cp = tstr + 1;
3392 		termc = *cp;
3393 		break;
3394 	    }
3395 	    goto default_case;
3396 	case 'O':
3397 	    {
3398 		char otype;
3399 
3400 		cp = tstr + 1;	/* skip to the rest in any case */
3401 		if (tstr[1] == endc || tstr[1] == ':') {
3402 		    otype = 's';
3403 		    termc = *cp;
3404 		} else if ( (tstr[1] == 'x') &&
3405 			    (tstr[2] == endc || tstr[2] == ':') ) {
3406 		    otype = tstr[1];
3407 		    cp = tstr + 2;
3408 		    termc = *cp;
3409 		} else {
3410 		    goto bad_modifier;
3411 		}
3412 		newStr = VarOrder(nstr, otype);
3413 		break;
3414 	    }
3415 	case 'u':
3416 	    if (tstr[1] == endc || tstr[1] == ':') {
3417 		newStr = VarUniq(nstr);
3418 		cp = tstr + 1;
3419 		termc = *cp;
3420 		break;
3421 	    }
3422 	    goto default_case;
3423 #ifdef SUNSHCMD
3424 	case 's':
3425 	    if (tstr[1] == 'h' && (tstr[2] == endc || tstr[2] == ':')) {
3426 		const char *emsg;
3427 		newStr = Cmd_Exec(nstr, &emsg);
3428 		if (emsg)
3429 		    Error(emsg, nstr);
3430 		cp = tstr + 2;
3431 		termc = *cp;
3432 		break;
3433 	    }
3434 	    goto default_case;
3435 #endif
3436 	default:
3437 	default_case:
3438 	{
3439 #ifdef SYSVVARSUB
3440 	    /*
3441 	     * This can either be a bogus modifier or a System-V
3442 	     * substitution command.
3443 	     */
3444 	    VarPattern      pattern;
3445 	    Boolean         eqFound;
3446 
3447 	    pattern.flags = 0;
3448 	    eqFound = FALSE;
3449 	    /*
3450 	     * First we make a pass through the string trying
3451 	     * to verify it is a SYSV-make-style translation:
3452 	     * it must be: <string1>=<string2>)
3453 	     */
3454 	    cp = tstr;
3455 	    cnt = 1;
3456 	    while (*cp != '\0' && cnt) {
3457 		if (*cp == '=') {
3458 		    eqFound = TRUE;
3459 		    /* continue looking for endc */
3460 		}
3461 		else if (*cp == endc)
3462 		    cnt--;
3463 		else if (*cp == startc)
3464 		    cnt++;
3465 		if (cnt)
3466 		    cp++;
3467 	    }
3468 	    if (*cp == endc && eqFound) {
3469 
3470 		/*
3471 		 * Now we break this sucker into the lhs and
3472 		 * rhs. We must null terminate them of course.
3473 		 */
3474 		delim='=';
3475 		cp = tstr;
3476 		if ((pattern.lhs = VarGetPattern(ctxt, &parsestate,
3477 						 errnum, &cp, delim, &pattern.flags,
3478 						 &pattern.leftLen, NULL)) == NULL)
3479 		    goto cleanup;
3480 		delim = endc;
3481 		if ((pattern.rhs = VarGetPattern(ctxt, &parsestate,
3482 						 errnum, &cp, delim, NULL, &pattern.rightLen,
3483 						 &pattern)) == NULL)
3484 		    goto cleanup;
3485 
3486 		/*
3487 		 * SYSV modifications happen through the whole
3488 		 * string. Note the pattern is anchored at the end.
3489 		 */
3490 		termc = *--cp;
3491 		delim = '\0';
3492 		if (pattern.leftLen == 0 && *nstr == '\0') {
3493 		    newStr = nstr;	/* special case */
3494 		} else {
3495 		    newStr = VarModify(ctxt, &parsestate, nstr,
3496 				       VarSYSVMatch,
3497 				       &pattern);
3498 		}
3499 		free(UNCONST(pattern.lhs));
3500 		free(UNCONST(pattern.rhs));
3501 	    } else
3502 #endif
3503 		{
3504 		    Error("Unknown modifier '%c'", *tstr);
3505 		    for (cp = tstr+1;
3506 			 *cp != ':' && *cp != endc && *cp != '\0';
3507 			 cp++)
3508 			continue;
3509 		    termc = *cp;
3510 		    newStr = var_Error;
3511 		}
3512 	    }
3513 	}
3514 	if (DEBUG(VAR)) {
3515 	    fprintf(debug_file, "Result[%s] of :%c is \"%s\"\n",
3516 		v->name, modifier, newStr);
3517 	}
3518 
3519 	if (newStr != nstr) {
3520 	    if (*freePtr) {
3521 		free(nstr);
3522 		*freePtr = NULL;
3523 	    }
3524 	    nstr = newStr;
3525 	    if (nstr != var_Error && nstr != varNoError) {
3526 		*freePtr = nstr;
3527 	    }
3528 	}
3529 	if (termc == '\0' && endc != '\0') {
3530 	    Error("Unclosed variable specification (expecting '%c') for \"%s\" (value \"%s\") modifier %c", endc, v->name, nstr, modifier);
3531 	} else if (termc == ':') {
3532 	    cp++;
3533 	}
3534 	tstr = cp;
3535     }
3536  out:
3537     *lengthPtr = tstr - start;
3538     return (nstr);
3539 
3540  bad_modifier:
3541     /* "{(" */
3542     Error("Bad modifier `:%.*s' for %s", (int)strcspn(tstr, ":)}"), tstr,
3543 	  v->name);
3544 
3545  cleanup:
3546     *lengthPtr = cp - start;
3547     if (delim != '\0')
3548 	Error("Unclosed substitution for %s (%c missing)",
3549 	      v->name, delim);
3550     if (*freePtr) {
3551 	free(*freePtr);
3552 	*freePtr = NULL;
3553     }
3554     return (var_Error);
3555 }
3556 
3557 /*-
3558  *-----------------------------------------------------------------------
3559  * Var_Parse --
3560  *	Given the start of a variable invocation, extract the variable
3561  *	name and find its value, then modify it according to the
3562  *	specification.
3563  *
3564  * Input:
3565  *	str		The string to parse
3566  *	ctxt		The context for the variable
3567  *	errnum		TRUE if undefined variables are an error
3568  *	lengthPtr	OUT: The length of the specification
3569  *	freePtr		OUT: Non-NULL if caller should free *freePtr
3570  *
3571  * Results:
3572  *	The (possibly-modified) value of the variable or var_Error if the
3573  *	specification is invalid. The length of the specification is
3574  *	placed in *lengthPtr (for invalid specifications, this is just
3575  *	2...?).
3576  *	If *freePtr is non-NULL then it's a pointer that the caller
3577  *	should pass to free() to free memory used by the result.
3578  *
3579  * Side Effects:
3580  *	None.
3581  *
3582  *-----------------------------------------------------------------------
3583  */
3584 /* coverity[+alloc : arg-*4] */
3585 char *
3586 Var_Parse(const char *str, GNode *ctxt, Boolean errnum, int *lengthPtr,
3587 	  void **freePtr)
3588 {
3589     const char	   *tstr;    	/* Pointer into str */
3590     Var		   *v;		/* Variable in invocation */
3591     Boolean 	    haveModifier;/* TRUE if have modifiers for the variable */
3592     char	    endc;    	/* Ending character when variable in parens
3593 				 * or braces */
3594     char	    startc;	/* Starting character when variable in parens
3595 				 * or braces */
3596     int		    vlen;	/* Length of variable name */
3597     const char 	   *start;	/* Points to original start of str */
3598     char	   *nstr;	/* New string, used during expansion */
3599     Boolean 	    dynamic;	/* TRUE if the variable is local and we're
3600 				 * expanding it in a non-local context. This
3601 				 * is done to support dynamic sources. The
3602 				 * result is just the invocation, unaltered */
3603     Var_Parse_State parsestate; /* Flags passed to helper functions */
3604     char	  name[2];
3605 
3606     *freePtr = NULL;
3607     dynamic = FALSE;
3608     start = str;
3609     parsestate.oneBigWord = FALSE;
3610     parsestate.varSpace = ' ';	/* word separator */
3611 
3612     startc = str[1];
3613     if (startc != PROPEN && startc != BROPEN) {
3614 	/*
3615 	 * If it's not bounded by braces of some sort, life is much simpler.
3616 	 * We just need to check for the first character and return the
3617 	 * value if it exists.
3618 	 */
3619 
3620 	/* Error out some really stupid names */
3621 	if (startc == '\0' || strchr(")}:$", startc)) {
3622 	    *lengthPtr = 1;
3623 	    return var_Error;
3624 	}
3625 	name[0] = startc;
3626 	name[1] = '\0';
3627 
3628 	v = VarFind(name, ctxt, FIND_ENV | FIND_GLOBAL | FIND_CMD);
3629 	if (v == NULL) {
3630 	    *lengthPtr = 2;
3631 
3632 	    if ((ctxt == VAR_CMD) || (ctxt == VAR_GLOBAL)) {
3633 		/*
3634 		 * If substituting a local variable in a non-local context,
3635 		 * assume it's for dynamic source stuff. We have to handle
3636 		 * this specially and return the longhand for the variable
3637 		 * with the dollar sign escaped so it makes it back to the
3638 		 * caller. Only four of the local variables are treated
3639 		 * specially as they are the only four that will be set
3640 		 * when dynamic sources are expanded.
3641 		 */
3642 		switch (str[1]) {
3643 		    case '@':
3644 			return UNCONST("$(.TARGET)");
3645 		    case '%':
3646 			return UNCONST("$(.ARCHIVE)");
3647 		    case '*':
3648 			return UNCONST("$(.PREFIX)");
3649 		    case '!':
3650 			return UNCONST("$(.MEMBER)");
3651 		}
3652 	    }
3653 	    /*
3654 	     * Error
3655 	     */
3656 	    return (errnum ? var_Error : varNoError);
3657 	} else {
3658 	    haveModifier = FALSE;
3659 	    tstr = &str[1];
3660 	    endc = str[1];
3661 	}
3662     } else {
3663 	Buffer buf;	/* Holds the variable name */
3664 	int depth = 1;
3665 
3666 	endc = startc == PROPEN ? PRCLOSE : BRCLOSE;
3667 	Buf_Init(&buf, 0);
3668 
3669 	/*
3670 	 * Skip to the end character or a colon, whichever comes first.
3671 	 */
3672 	for (tstr = str + 2; *tstr != '\0'; tstr++)
3673 	{
3674 	    /*
3675 	     * Track depth so we can spot parse errors.
3676 	     */
3677 	    if (*tstr == startc) {
3678 		depth++;
3679 	    }
3680 	    if (*tstr == endc) {
3681 		if (--depth == 0)
3682 		    break;
3683 	    }
3684 	    if (depth == 1 && *tstr == ':') {
3685 		break;
3686 	    }
3687 	    /*
3688 	     * A variable inside a variable, expand
3689 	     */
3690 	    if (*tstr == '$') {
3691 		int rlen;
3692 		void *freeIt;
3693 		char *rval = Var_Parse(tstr, ctxt, errnum, &rlen, &freeIt);
3694 		if (rval != NULL) {
3695 		    Buf_AddBytes(&buf, strlen(rval), rval);
3696 		}
3697 		if (freeIt)
3698 		    free(freeIt);
3699 		tstr += rlen - 1;
3700 	    }
3701 	    else
3702 		Buf_AddByte(&buf, *tstr);
3703 	}
3704 	if (*tstr == ':') {
3705 	    haveModifier = TRUE;
3706 	} else if (*tstr == endc) {
3707 	    haveModifier = FALSE;
3708 	} else {
3709 	    /*
3710 	     * If we never did find the end character, return NULL
3711 	     * right now, setting the length to be the distance to
3712 	     * the end of the string, since that's what make does.
3713 	     */
3714 	    *lengthPtr = tstr - str;
3715 	    Buf_Destroy(&buf, TRUE);
3716 	    return (var_Error);
3717 	}
3718 	str = Buf_GetAll(&buf, &vlen);
3719 
3720 	/*
3721 	 * At this point, str points into newly allocated memory from
3722 	 * buf, containing only the name of the variable.
3723 	 *
3724 	 * start and tstr point into the const string that was pointed
3725 	 * to by the original value of the str parameter.  start points
3726 	 * to the '$' at the beginning of the string, while tstr points
3727 	 * to the char just after the end of the variable name -- this
3728 	 * will be '\0', ':', PRCLOSE, or BRCLOSE.
3729 	 */
3730 
3731 	v = VarFind(str, ctxt, FIND_ENV | FIND_GLOBAL | FIND_CMD);
3732 	/*
3733 	 * Check also for bogus D and F forms of local variables since we're
3734 	 * in a local context and the name is the right length.
3735 	 */
3736 	if ((v == NULL) && (ctxt != VAR_CMD) && (ctxt != VAR_GLOBAL) &&
3737 		(vlen == 2) && (str[1] == 'F' || str[1] == 'D') &&
3738 		strchr("@%*!<>", str[0]) != NULL) {
3739 	    /*
3740 	     * Well, it's local -- go look for it.
3741 	     */
3742 	    name[0] = *str;
3743 	    name[1] = '\0';
3744 	    v = VarFind(name, ctxt, 0);
3745 
3746 	    if (v != NULL) {
3747 		/*
3748 		 * No need for nested expansion or anything, as we're
3749 		 * the only one who sets these things and we sure don't
3750 		 * but nested invocations in them...
3751 		 */
3752 		nstr = Buf_GetAll(&v->val, NULL);
3753 
3754 		if (str[1] == 'D') {
3755 		    nstr = VarModify(ctxt, &parsestate, nstr, VarHead,
3756 				    NULL);
3757 		} else {
3758 		    nstr = VarModify(ctxt, &parsestate, nstr, VarTail,
3759 				    NULL);
3760 		}
3761 		/*
3762 		 * Resulting string is dynamically allocated, so
3763 		 * tell caller to free it.
3764 		 */
3765 		*freePtr = nstr;
3766 		*lengthPtr = tstr-start+1;
3767 		Buf_Destroy(&buf, TRUE);
3768 		VarFreeEnv(v, TRUE);
3769 		return nstr;
3770 	    }
3771 	}
3772 
3773 	if (v == NULL) {
3774 	    if (((vlen == 1) ||
3775 		 (((vlen == 2) && (str[1] == 'F' || str[1] == 'D')))) &&
3776 		((ctxt == VAR_CMD) || (ctxt == VAR_GLOBAL)))
3777 	    {
3778 		/*
3779 		 * If substituting a local variable in a non-local context,
3780 		 * assume it's for dynamic source stuff. We have to handle
3781 		 * this specially and return the longhand for the variable
3782 		 * with the dollar sign escaped so it makes it back to the
3783 		 * caller. Only four of the local variables are treated
3784 		 * specially as they are the only four that will be set
3785 		 * when dynamic sources are expanded.
3786 		 */
3787 		switch (*str) {
3788 		    case '@':
3789 		    case '%':
3790 		    case '*':
3791 		    case '!':
3792 			dynamic = TRUE;
3793 			break;
3794 		}
3795 	    } else if ((vlen > 2) && (*str == '.') &&
3796 		       isupper((unsigned char) str[1]) &&
3797 		       ((ctxt == VAR_CMD) || (ctxt == VAR_GLOBAL)))
3798 	    {
3799 		int	len;
3800 
3801 		len = vlen - 1;
3802 		if ((strncmp(str, ".TARGET", len) == 0) ||
3803 		    (strncmp(str, ".ARCHIVE", len) == 0) ||
3804 		    (strncmp(str, ".PREFIX", len) == 0) ||
3805 		    (strncmp(str, ".MEMBER", len) == 0))
3806 		{
3807 		    dynamic = TRUE;
3808 		}
3809 	    }
3810 
3811 	    if (!haveModifier) {
3812 		/*
3813 		 * No modifiers -- have specification length so we can return
3814 		 * now.
3815 		 */
3816 		*lengthPtr = tstr - start + 1;
3817 		if (dynamic) {
3818 		    char *pstr = bmake_strndup(start, *lengthPtr);
3819 		    *freePtr = pstr;
3820 		    Buf_Destroy(&buf, TRUE);
3821 		    return(pstr);
3822 		} else {
3823 		    Buf_Destroy(&buf, TRUE);
3824 		    return (errnum ? var_Error : varNoError);
3825 		}
3826 	    } else {
3827 		/*
3828 		 * Still need to get to the end of the variable specification,
3829 		 * so kludge up a Var structure for the modifications
3830 		 */
3831 		v = bmake_malloc(sizeof(Var));
3832 		v->name = UNCONST(str);
3833 		Buf_Init(&v->val, 1);
3834 		v->flags = VAR_JUNK;
3835 		Buf_Destroy(&buf, FALSE);
3836 	    }
3837 	} else
3838 	    Buf_Destroy(&buf, TRUE);
3839     }
3840 
3841     if (v->flags & VAR_IN_USE) {
3842 	Fatal("Variable %s is recursive.", v->name);
3843 	/*NOTREACHED*/
3844     } else {
3845 	v->flags |= VAR_IN_USE;
3846     }
3847     /*
3848      * Before doing any modification, we have to make sure the value
3849      * has been fully expanded. If it looks like recursion might be
3850      * necessary (there's a dollar sign somewhere in the variable's value)
3851      * we just call Var_Subst to do any other substitutions that are
3852      * necessary. Note that the value returned by Var_Subst will have
3853      * been dynamically-allocated, so it will need freeing when we
3854      * return.
3855      */
3856     nstr = Buf_GetAll(&v->val, NULL);
3857     if (strchr(nstr, '$') != NULL) {
3858 	nstr = Var_Subst(NULL, nstr, ctxt, errnum);
3859 	*freePtr = nstr;
3860     }
3861 
3862     v->flags &= ~VAR_IN_USE;
3863 
3864     if ((nstr != NULL) && haveModifier) {
3865 	int used;
3866 	/*
3867 	 * Skip initial colon.
3868 	 */
3869 	tstr++;
3870 
3871 	nstr = ApplyModifiers(nstr, tstr, startc, endc,
3872 			      v, ctxt, errnum, &used, freePtr);
3873 	tstr += used;
3874     }
3875     if (*tstr) {
3876 	*lengthPtr = tstr - start + 1;
3877     } else {
3878 	*lengthPtr = tstr - start;
3879     }
3880 
3881     if (v->flags & VAR_FROM_ENV) {
3882 	Boolean	  destroy = FALSE;
3883 
3884 	if (nstr != Buf_GetAll(&v->val, NULL)) {
3885 	    destroy = TRUE;
3886 	} else {
3887 	    /*
3888 	     * Returning the value unmodified, so tell the caller to free
3889 	     * the thing.
3890 	     */
3891 	    *freePtr = nstr;
3892 	}
3893 	VarFreeEnv(v, destroy);
3894     } else if (v->flags & VAR_JUNK) {
3895 	/*
3896 	 * Perform any free'ing needed and set *freePtr to NULL so the caller
3897 	 * doesn't try to free a static pointer.
3898 	 * If VAR_KEEP is also set then we want to keep str as is.
3899 	 */
3900 	if (!(v->flags & VAR_KEEP)) {
3901 	    if (*freePtr) {
3902 		free(nstr);
3903 		*freePtr = NULL;
3904 	    }
3905 	    if (dynamic) {
3906 		nstr = bmake_strndup(start, *lengthPtr);
3907 		*freePtr = nstr;
3908 	    } else {
3909 		nstr = errnum ? var_Error : varNoError;
3910 	    }
3911 	}
3912 	if (nstr != Buf_GetAll(&v->val, NULL))
3913 	    Buf_Destroy(&v->val, TRUE);
3914 	free(v->name);
3915 	free(v);
3916     }
3917     return (nstr);
3918 }
3919 
3920 /*-
3921  *-----------------------------------------------------------------------
3922  * Var_Subst  --
3923  *	Substitute for all variables in the given string in the given context
3924  *	If undefErr is TRUE, Parse_Error will be called when an undefined
3925  *	variable is encountered.
3926  *
3927  * Input:
3928  *	var		Named variable || NULL for all
3929  *	str		the string which to substitute
3930  *	ctxt		the context wherein to find variables
3931  *	undefErr	TRUE if undefineds are an error
3932  *
3933  * Results:
3934  *	The resulting string.
3935  *
3936  * Side Effects:
3937  *	None. The old string must be freed by the caller
3938  *-----------------------------------------------------------------------
3939  */
3940 char *
3941 Var_Subst(const char *var, const char *str, GNode *ctxt, Boolean undefErr)
3942 {
3943     Buffer  	  buf;		    /* Buffer for forming things */
3944     char    	  *val;		    /* Value to substitute for a variable */
3945     int		  length;   	    /* Length of the variable invocation */
3946     Boolean	  trailingBslash;   /* variable ends in \ */
3947     void 	  *freeIt = NULL;    /* Set if it should be freed */
3948     static Boolean errorReported;   /* Set true if an error has already
3949 				     * been reported to prevent a plethora
3950 				     * of messages when recursing */
3951 
3952     Buf_Init(&buf, 0);
3953     errorReported = FALSE;
3954     trailingBslash = FALSE;
3955 
3956     while (*str) {
3957 	if (*str == '\n' && trailingBslash)
3958 	    Buf_AddByte(&buf, ' ');
3959 	if (var == NULL && (*str == '$') && (str[1] == '$')) {
3960 	    /*
3961 	     * A dollar sign may be escaped either with another dollar sign.
3962 	     * In such a case, we skip over the escape character and store the
3963 	     * dollar sign into the buffer directly.
3964 	     */
3965 	    str++;
3966 	    Buf_AddByte(&buf, *str);
3967 	    str++;
3968 	} else if (*str != '$') {
3969 	    /*
3970 	     * Skip as many characters as possible -- either to the end of
3971 	     * the string or to the next dollar sign (variable invocation).
3972 	     */
3973 	    const char  *cp;
3974 
3975 	    for (cp = str++; *str != '$' && *str != '\0'; str++)
3976 		continue;
3977 	    Buf_AddBytes(&buf, str - cp, cp);
3978 	} else {
3979 	    if (var != NULL) {
3980 		int expand;
3981 		for (;;) {
3982 		    if (str[1] == '\0') {
3983 			/* A trailing $ is kind of a special case */
3984 			Buf_AddByte(&buf, str[0]);
3985 			str++;
3986 			expand = FALSE;
3987 		    } else if (str[1] != PROPEN && str[1] != BROPEN) {
3988 			if (str[1] != *var || strlen(var) > 1) {
3989 			    Buf_AddBytes(&buf, 2, str);
3990 			    str += 2;
3991 			    expand = FALSE;
3992 			}
3993 			else
3994 			    expand = TRUE;
3995 			break;
3996 		    }
3997 		    else {
3998 			const char *p;
3999 
4000 			/*
4001 			 * Scan up to the end of the variable name.
4002 			 */
4003 			for (p = &str[2]; *p &&
4004 			     *p != ':' && *p != PRCLOSE && *p != BRCLOSE; p++)
4005 			    if (*p == '$')
4006 				break;
4007 			/*
4008 			 * A variable inside the variable. We cannot expand
4009 			 * the external variable yet, so we try again with
4010 			 * the nested one
4011 			 */
4012 			if (*p == '$') {
4013 			    Buf_AddBytes(&buf, p - str, str);
4014 			    str = p;
4015 			    continue;
4016 			}
4017 
4018 			if (strncmp(var, str + 2, p - str - 2) != 0 ||
4019 			    var[p - str - 2] != '\0') {
4020 			    /*
4021 			     * Not the variable we want to expand, scan
4022 			     * until the next variable
4023 			     */
4024 			    for (;*p != '$' && *p != '\0'; p++)
4025 				continue;
4026 			    Buf_AddBytes(&buf, p - str, str);
4027 			    str = p;
4028 			    expand = FALSE;
4029 			}
4030 			else
4031 			    expand = TRUE;
4032 			break;
4033 		    }
4034 		}
4035 		if (!expand)
4036 		    continue;
4037 	    }
4038 
4039 	    val = Var_Parse(str, ctxt, undefErr, &length, &freeIt);
4040 
4041 	    /*
4042 	     * When we come down here, val should either point to the
4043 	     * value of this variable, suitably modified, or be NULL.
4044 	     * Length should be the total length of the potential
4045 	     * variable invocation (from $ to end character...)
4046 	     */
4047 	    if (val == var_Error || val == varNoError) {
4048 		/*
4049 		 * If performing old-time variable substitution, skip over
4050 		 * the variable and continue with the substitution. Otherwise,
4051 		 * store the dollar sign and advance str so we continue with
4052 		 * the string...
4053 		 */
4054 		if (oldVars) {
4055 		    str += length;
4056 		} else if (undefErr || val == var_Error) {
4057 		    /*
4058 		     * If variable is undefined, complain and skip the
4059 		     * variable. The complaint will stop us from doing anything
4060 		     * when the file is parsed.
4061 		     */
4062 		    if (!errorReported) {
4063 			Parse_Error(PARSE_FATAL,
4064 				     "Undefined variable \"%.*s\"",length,str);
4065 		    }
4066 		    str += length;
4067 		    errorReported = TRUE;
4068 		} else {
4069 		    Buf_AddByte(&buf, *str);
4070 		    str += 1;
4071 		}
4072 	    } else {
4073 		/*
4074 		 * We've now got a variable structure to store in. But first,
4075 		 * advance the string pointer.
4076 		 */
4077 		str += length;
4078 
4079 		/*
4080 		 * Copy all the characters from the variable value straight
4081 		 * into the new string.
4082 		 */
4083 		length = strlen(val);
4084 		Buf_AddBytes(&buf, length, val);
4085 		trailingBslash = length > 0 && val[length - 1] == '\\';
4086 	    }
4087 	    if (freeIt) {
4088 		free(freeIt);
4089 		freeIt = NULL;
4090 	    }
4091 	}
4092     }
4093 
4094     return Buf_DestroyCompact(&buf);
4095 }
4096 
4097 /*-
4098  *-----------------------------------------------------------------------
4099  * Var_GetTail --
4100  *	Return the tail from each of a list of words. Used to set the
4101  *	System V local variables.
4102  *
4103  * Input:
4104  *	file		Filename to modify
4105  *
4106  * Results:
4107  *	The resulting string.
4108  *
4109  * Side Effects:
4110  *	None.
4111  *
4112  *-----------------------------------------------------------------------
4113  */
4114 #if 0
4115 char *
4116 Var_GetTail(char *file)
4117 {
4118     return(VarModify(file, VarTail, NULL));
4119 }
4120 
4121 /*-
4122  *-----------------------------------------------------------------------
4123  * Var_GetHead --
4124  *	Find the leading components of a (list of) filename(s).
4125  *	XXX: VarHead does not replace foo by ., as (sun) System V make
4126  *	does.
4127  *
4128  * Input:
4129  *	file		Filename to manipulate
4130  *
4131  * Results:
4132  *	The leading components.
4133  *
4134  * Side Effects:
4135  *	None.
4136  *
4137  *-----------------------------------------------------------------------
4138  */
4139 char *
4140 Var_GetHead(char *file)
4141 {
4142     return(VarModify(file, VarHead, NULL));
4143 }
4144 #endif
4145 
4146 /*-
4147  *-----------------------------------------------------------------------
4148  * Var_Init --
4149  *	Initialize the module
4150  *
4151  * Results:
4152  *	None
4153  *
4154  * Side Effects:
4155  *	The VAR_CMD and VAR_GLOBAL contexts are created
4156  *-----------------------------------------------------------------------
4157  */
4158 void
4159 Var_Init(void)
4160 {
4161     VAR_INTERNAL = Targ_NewGN("Internal");
4162     VAR_GLOBAL = Targ_NewGN("Global");
4163     VAR_CMD = Targ_NewGN("Command");
4164 
4165 }
4166 
4167 
4168 void
4169 Var_End(void)
4170 {
4171 }
4172 
4173 
4174 /****************** PRINT DEBUGGING INFO *****************/
4175 static void
4176 VarPrintVar(void *vp)
4177 {
4178     Var    *v = (Var *)vp;
4179     fprintf(debug_file, "%-16s = %s\n", v->name, Buf_GetAll(&v->val, NULL));
4180 }
4181 
4182 /*-
4183  *-----------------------------------------------------------------------
4184  * Var_Dump --
4185  *	print all variables in a context
4186  *-----------------------------------------------------------------------
4187  */
4188 void
4189 Var_Dump(GNode *ctxt)
4190 {
4191     Hash_Search search;
4192     Hash_Entry *h;
4193 
4194     for (h = Hash_EnumFirst(&ctxt->context, &search);
4195 	 h != NULL;
4196 	 h = Hash_EnumNext(&search)) {
4197 	    VarPrintVar(Hash_GetValue(h));
4198     }
4199 }
4200