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