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