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