var.c revision 1.433 1 1.433 rillig /* $NetBSD: var.c,v 1.433 2020/08/08 18:54:04 rillig Exp $ */
2 1.11 christos
3 1.1 cgd /*
4 1.15 christos * Copyright (c) 1988, 1989, 1990, 1993
5 1.15 christos * The Regents of the University of California. All rights reserved.
6 1.80 agc *
7 1.80 agc * This code is derived from software contributed to Berkeley by
8 1.80 agc * Adam de Boor.
9 1.80 agc *
10 1.80 agc * Redistribution and use in source and binary forms, with or without
11 1.80 agc * modification, are permitted provided that the following conditions
12 1.80 agc * are met:
13 1.80 agc * 1. Redistributions of source code must retain the above copyright
14 1.80 agc * notice, this list of conditions and the following disclaimer.
15 1.80 agc * 2. Redistributions in binary form must reproduce the above copyright
16 1.80 agc * notice, this list of conditions and the following disclaimer in the
17 1.80 agc * documentation and/or other materials provided with the distribution.
18 1.80 agc * 3. Neither the name of the University nor the names of its contributors
19 1.80 agc * may be used to endorse or promote products derived from this software
20 1.80 agc * without specific prior written permission.
21 1.80 agc *
22 1.80 agc * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 1.80 agc * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 1.80 agc * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 1.80 agc * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 1.80 agc * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 1.80 agc * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 1.80 agc * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 1.80 agc * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 1.80 agc * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 1.80 agc * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 1.80 agc * SUCH DAMAGE.
33 1.80 agc */
34 1.80 agc
35 1.80 agc /*
36 1.1 cgd * Copyright (c) 1989 by Berkeley Softworks
37 1.1 cgd * All rights reserved.
38 1.1 cgd *
39 1.1 cgd * This code is derived from software contributed to Berkeley by
40 1.1 cgd * Adam de Boor.
41 1.1 cgd *
42 1.1 cgd * Redistribution and use in source and binary forms, with or without
43 1.1 cgd * modification, are permitted provided that the following conditions
44 1.1 cgd * are met:
45 1.1 cgd * 1. Redistributions of source code must retain the above copyright
46 1.1 cgd * notice, this list of conditions and the following disclaimer.
47 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
48 1.1 cgd * notice, this list of conditions and the following disclaimer in the
49 1.1 cgd * documentation and/or other materials provided with the distribution.
50 1.1 cgd * 3. All advertising materials mentioning features or use of this software
51 1.1 cgd * must display the following acknowledgement:
52 1.1 cgd * This product includes software developed by the University of
53 1.1 cgd * California, Berkeley and its contributors.
54 1.1 cgd * 4. Neither the name of the University nor the names of its contributors
55 1.1 cgd * may be used to endorse or promote products derived from this software
56 1.1 cgd * without specific prior written permission.
57 1.1 cgd *
58 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
59 1.1 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
60 1.1 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
61 1.1 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
62 1.1 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
63 1.1 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
64 1.1 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
65 1.1 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
66 1.1 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
67 1.1 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
68 1.1 cgd * SUCH DAMAGE.
69 1.1 cgd */
70 1.1 cgd
71 1.88 ross #ifndef MAKE_NATIVE
72 1.433 rillig static char rcsid[] = "$NetBSD: var.c,v 1.433 2020/08/08 18:54:04 rillig Exp $";
73 1.23 lukem #else
74 1.19 christos #include <sys/cdefs.h>
75 1.1 cgd #ifndef lint
76 1.11 christos #if 0
77 1.15 christos static char sccsid[] = "@(#)var.c 8.3 (Berkeley) 3/19/94";
78 1.11 christos #else
79 1.433 rillig __RCSID("$NetBSD: var.c,v 1.433 2020/08/08 18:54:04 rillig Exp $");
80 1.11 christos #endif
81 1.1 cgd #endif /* not lint */
82 1.23 lukem #endif
83 1.1 cgd
84 1.1 cgd /*-
85 1.1 cgd * var.c --
86 1.1 cgd * Variable-handling functions
87 1.1 cgd *
88 1.1 cgd * Interface:
89 1.138 dsl * Var_Set Set the value of a variable in the given
90 1.138 dsl * context. The variable is created if it doesn't
91 1.292 rillig * yet exist.
92 1.1 cgd *
93 1.1 cgd * Var_Append Append more characters to an existing variable
94 1.138 dsl * in the given context. The variable needn't
95 1.138 dsl * exist already -- it will be created if it doesn't.
96 1.138 dsl * A space is placed between the old value and the
97 1.138 dsl * new one.
98 1.1 cgd *
99 1.1 cgd * Var_Exists See if a variable exists.
100 1.1 cgd *
101 1.337 rillig * Var_Value Return the unexpanded value of a variable in a
102 1.337 rillig * context or NULL if the variable is undefined.
103 1.1 cgd *
104 1.250 rillig * Var_Subst Substitute either a single variable or all
105 1.292 rillig * variables in a string, using the given context.
106 1.1 cgd *
107 1.1 cgd * Var_Parse Parse a variable expansion from a string and
108 1.138 dsl * return the result and the number of characters
109 1.138 dsl * consumed.
110 1.1 cgd *
111 1.1 cgd * Var_Delete Delete a variable in a context.
112 1.1 cgd *
113 1.1 cgd * Var_Init Initialize this module.
114 1.1 cgd *
115 1.1 cgd * Debugging:
116 1.1 cgd * Var_Dump Print out all variables defined in the given
117 1.138 dsl * context.
118 1.1 cgd *
119 1.1 cgd * XXX: There's a lot of duplication in these functions.
120 1.1 cgd */
121 1.1 cgd
122 1.157 sjg #include <sys/stat.h>
123 1.31 gwr #ifndef NO_REGEX
124 1.28 wsanchez #include <sys/types.h>
125 1.16 christos #include <regex.h>
126 1.17 christos #endif
127 1.357 rillig #include <assert.h>
128 1.70 wiz #include <ctype.h>
129 1.163 joerg #include <inttypes.h>
130 1.292 rillig #include <limits.h>
131 1.17 christos #include <stdlib.h>
132 1.166 tsutsui #include <time.h>
133 1.70 wiz
134 1.430 rillig #include "enum.h"
135 1.1 cgd #include "make.h"
136 1.1 cgd #include "buf.h"
137 1.103 sjg #include "dir.h"
138 1.111 rillig #include "job.h"
139 1.193 christos #include "metachar.h"
140 1.1 cgd
141 1.411 rillig #define VAR_DEBUG_IF(cond, fmt, ...) \
142 1.411 rillig if (!(DEBUG(VAR) && (cond))) \
143 1.411 rillig (void) 0; \
144 1.411 rillig else \
145 1.334 rillig fprintf(debug_file, fmt, __VA_ARGS__)
146 1.334 rillig
147 1.411 rillig #define VAR_DEBUG(fmt, ...) VAR_DEBUG_IF(TRUE, fmt, __VA_ARGS__)
148 1.411 rillig
149 1.430 rillig ENUM_RTTI_3(VarEvalFlags,
150 1.430 rillig VARE_UNDEFERR,
151 1.430 rillig VARE_WANTRES,
152 1.430 rillig VARE_ASSIGN);
153 1.430 rillig
154 1.1 cgd /*
155 1.170 sjg * This lets us tell if we have replaced the original environ
156 1.170 sjg * (which we cannot free).
157 1.170 sjg */
158 1.170 sjg char **savedEnv = NULL;
159 1.170 sjg
160 1.170 sjg /*
161 1.1 cgd * This is a harmless return value for Var_Parse that can be used by Var_Subst
162 1.1 cgd * to determine if there was an error in parsing -- easier than returning
163 1.1 cgd * a flag, as things outside this module don't give a hoot.
164 1.1 cgd */
165 1.249 rillig char var_Error[] = "";
166 1.1 cgd
167 1.1 cgd /*
168 1.259 rillig * Similar to var_Error, but returned when the 'VARE_UNDEFERR' flag for
169 1.292 rillig * Var_Parse is not set. Why not just use a constant? Well, GCC likes
170 1.202 christos * to condense identical string instances...
171 1.1 cgd */
172 1.249 rillig static char varNoError[] = "";
173 1.1 cgd
174 1.1 cgd /*
175 1.205 sjg * Traditionally we consume $$ during := like any other expansion.
176 1.205 sjg * Other make's do not.
177 1.205 sjg * This knob allows controlling the behavior.
178 1.292 rillig * FALSE to consume $$ during := assignment.
179 1.292 rillig * TRUE to preserve $$ during := assignment.
180 1.205 sjg */
181 1.205 sjg #define SAVE_DOLLARS ".MAKE.SAVE_DOLLARS"
182 1.205 sjg static Boolean save_dollars = TRUE;
183 1.205 sjg
184 1.205 sjg /*
185 1.1 cgd * Internally, variables are contained in four different contexts.
186 1.292 rillig * 1) the environment. They cannot be changed. If an environment
187 1.292 rillig * variable is appended to, the result is placed in the global
188 1.1 cgd * context.
189 1.1 cgd * 2) the global context. Variables set in the Makefile are located in
190 1.292 rillig * the global context.
191 1.1 cgd * 3) the command-line context. All variables set on the command line
192 1.1 cgd * are placed in this context. They are UNALTERABLE once placed here.
193 1.1 cgd * 4) the local context. Each target has associated with it a context
194 1.1 cgd * list. On this list are located the structures describing such
195 1.1 cgd * local variables as $(@) and $(*)
196 1.1 cgd * The four contexts are searched in the reverse order from which they are
197 1.292 rillig * listed (but see checkEnvFirst).
198 1.1 cgd */
199 1.240 rillig GNode *VAR_INTERNAL; /* variables from make itself */
200 1.240 rillig GNode *VAR_GLOBAL; /* variables from the makefile */
201 1.240 rillig GNode *VAR_CMD; /* variables defined on the command-line */
202 1.240 rillig
203 1.260 rillig typedef enum {
204 1.260 rillig FIND_CMD = 0x01, /* look in VAR_CMD when searching */
205 1.260 rillig FIND_GLOBAL = 0x02, /* look in VAR_GLOBAL as well */
206 1.260 rillig FIND_ENV = 0x04 /* look in the environment also */
207 1.260 rillig } VarFindFlags;
208 1.1 cgd
209 1.228 rillig typedef enum {
210 1.292 rillig VAR_IN_USE = 0x01, /* Variable's value is currently being used
211 1.292 rillig * by Var_Parse or Var_Subst.
212 1.228 rillig * Used to avoid endless recursion */
213 1.240 rillig VAR_FROM_ENV = 0x02, /* Variable comes from the environment */
214 1.240 rillig VAR_JUNK = 0x04, /* Variable is a junk variable that
215 1.228 rillig * should be destroyed when done with
216 1.228 rillig * it. Used by Var_Parse for undefined,
217 1.228 rillig * modified variables */
218 1.240 rillig VAR_KEEP = 0x08, /* Variable is VAR_JUNK, but we found
219 1.228 rillig * a use for it in some modifier and
220 1.228 rillig * the value is therefore valid */
221 1.240 rillig VAR_EXPORTED = 0x10, /* Variable is exported */
222 1.240 rillig VAR_REEXPORT = 0x20, /* Indicate if var needs re-export.
223 1.228 rillig * This would be true if it contains $'s */
224 1.240 rillig VAR_FROM_CMD = 0x40 /* Variable came from command line */
225 1.414 rillig } VarFlags;
226 1.228 rillig
227 1.430 rillig ENUM_RTTI_7(VarFlags,
228 1.430 rillig VAR_IN_USE,
229 1.430 rillig VAR_FROM_ENV,
230 1.430 rillig VAR_JUNK,
231 1.430 rillig VAR_KEEP,
232 1.430 rillig VAR_EXPORTED,
233 1.430 rillig VAR_REEXPORT,
234 1.430 rillig VAR_FROM_CMD);
235 1.430 rillig
236 1.1 cgd typedef struct Var {
237 1.414 rillig char *name; /* the variable's name; it is allocated for
238 1.414 rillig * environment variables and aliased to the
239 1.414 rillig * Hash_Entry name for all other variables,
240 1.414 rillig * and thus must not be modified */
241 1.138 dsl Buffer val; /* its value */
242 1.414 rillig VarFlags flags; /* miscellaneous status flags */
243 1.417 rillig } Var;
244 1.1 cgd
245 1.118 sjg /*
246 1.118 sjg * Exporting vars is expensive so skip it if we can
247 1.118 sjg */
248 1.292 rillig typedef enum {
249 1.292 rillig VAR_EXPORTED_NONE,
250 1.292 rillig VAR_EXPORTED_YES,
251 1.292 rillig VAR_EXPORTED_ALL
252 1.292 rillig } VarExportedMode;
253 1.421 rillig
254 1.292 rillig static VarExportedMode var_exportedVars = VAR_EXPORTED_NONE;
255 1.292 rillig
256 1.292 rillig typedef enum {
257 1.292 rillig /*
258 1.292 rillig * We pass this to Var_Export when doing the initial export
259 1.292 rillig * or after updating an exported var.
260 1.292 rillig */
261 1.292 rillig VAR_EXPORT_PARENT = 0x01,
262 1.292 rillig /*
263 1.292 rillig * We pass this to Var_Export1 to tell it to leave the value alone.
264 1.292 rillig */
265 1.292 rillig VAR_EXPORT_LITERAL = 0x02
266 1.292 rillig } VarExportFlags;
267 1.16 christos
268 1.261 rillig /* Flags for pattern matching in the :S and :C modifiers */
269 1.229 rillig typedef enum {
270 1.261 rillig VARP_SUB_GLOBAL = 0x01, /* Apply substitution globally */
271 1.261 rillig VARP_SUB_ONE = 0x02, /* Apply substitution to one word */
272 1.261 rillig VARP_SUB_MATCHED = 0x04, /* There was a match */
273 1.288 rillig VARP_ANCHOR_START = 0x08, /* Match at start of word */
274 1.288 rillig VARP_ANCHOR_END = 0x10 /* Match at end of word */
275 1.261 rillig } VarPatternFlags;
276 1.16 christos
277 1.230 rillig typedef enum {
278 1.292 rillig VAR_NO_EXPORT = 0x01 /* do not export */
279 1.230 rillig } VarSet_Flags;
280 1.65 sjg
281 1.100 christos #define BROPEN '{'
282 1.100 christos #define BRCLOSE '}'
283 1.100 christos #define PROPEN '('
284 1.100 christos #define PRCLOSE ')'
285 1.100 christos
286 1.1 cgd /*-
287 1.1 cgd *-----------------------------------------------------------------------
288 1.1 cgd * VarFind --
289 1.1 cgd * Find the given variable in the given context and any other contexts
290 1.1 cgd * indicated.
291 1.1 cgd *
292 1.70 wiz * Input:
293 1.70 wiz * name name to find
294 1.70 wiz * ctxt context in which to find it
295 1.260 rillig * flags FIND_GLOBAL look in VAR_GLOBAL as well
296 1.260 rillig * FIND_CMD look in VAR_CMD as well
297 1.260 rillig * FIND_ENV look in the environment as well
298 1.70 wiz *
299 1.1 cgd * Results:
300 1.1 cgd * A pointer to the structure describing the desired variable or
301 1.136 dsl * NULL if the variable does not exist.
302 1.1 cgd *
303 1.1 cgd * Side Effects:
304 1.1 cgd * None
305 1.1 cgd *-----------------------------------------------------------------------
306 1.1 cgd */
307 1.1 cgd static Var *
308 1.260 rillig VarFind(const char *name, GNode *ctxt, VarFindFlags flags)
309 1.1 cgd {
310 1.412 rillig Hash_Entry *var;
311 1.412 rillig
312 1.242 rillig /*
313 1.242 rillig * If the variable name begins with a '.', it could very well be one of
314 1.242 rillig * the local ones. We check the name against all the local variables
315 1.242 rillig * and substitute the short version in for 'name' if it matches one of
316 1.242 rillig * them.
317 1.242 rillig */
318 1.417 rillig if (*name == '.' && isupper((unsigned char)name[1])) {
319 1.242 rillig switch (name[1]) {
320 1.242 rillig case 'A':
321 1.257 rillig if (strcmp(name, ".ALLSRC") == 0)
322 1.242 rillig name = ALLSRC;
323 1.257 rillig if (strcmp(name, ".ARCHIVE") == 0)
324 1.242 rillig name = ARCHIVE;
325 1.242 rillig break;
326 1.242 rillig case 'I':
327 1.257 rillig if (strcmp(name, ".IMPSRC") == 0)
328 1.242 rillig name = IMPSRC;
329 1.242 rillig break;
330 1.242 rillig case 'M':
331 1.257 rillig if (strcmp(name, ".MEMBER") == 0)
332 1.242 rillig name = MEMBER;
333 1.242 rillig break;
334 1.242 rillig case 'O':
335 1.257 rillig if (strcmp(name, ".OODATE") == 0)
336 1.242 rillig name = OODATE;
337 1.242 rillig break;
338 1.242 rillig case 'P':
339 1.257 rillig if (strcmp(name, ".PREFIX") == 0)
340 1.242 rillig name = PREFIX;
341 1.242 rillig break;
342 1.242 rillig case 'T':
343 1.257 rillig if (strcmp(name, ".TARGET") == 0)
344 1.242 rillig name = TARGET;
345 1.242 rillig break;
346 1.242 rillig }
347 1.242 rillig }
348 1.242 rillig
349 1.160 christos #ifdef notyet
350 1.160 christos /* for compatibility with gmake */
351 1.160 christos if (name[0] == '^' && name[1] == '\0')
352 1.242 rillig name = ALLSRC;
353 1.160 christos #endif
354 1.160 christos
355 1.1 cgd /*
356 1.1 cgd * First look for the variable in the given context. If it's not there,
357 1.1 cgd * look for it in VAR_CMD, VAR_GLOBAL and the environment, in that order,
358 1.1 cgd * depending on the FIND_* flags in 'flags'
359 1.1 cgd */
360 1.412 rillig var = Hash_FindEntry(&ctxt->context, name);
361 1.1 cgd
362 1.399 rillig if (var == NULL && (flags & FIND_CMD) && ctxt != VAR_CMD)
363 1.92 christos var = Hash_FindEntry(&VAR_CMD->context, name);
364 1.399 rillig
365 1.231 rillig if (!checkEnvFirst && var == NULL && (flags & FIND_GLOBAL) &&
366 1.231 rillig ctxt != VAR_GLOBAL)
367 1.1 cgd {
368 1.92 christos var = Hash_FindEntry(&VAR_GLOBAL->context, name);
369 1.231 rillig if (var == NULL && ctxt != VAR_INTERNAL) {
370 1.184 sjg /* VAR_INTERNAL is subordinate to VAR_GLOBAL */
371 1.184 sjg var = Hash_FindEntry(&VAR_INTERNAL->context, name);
372 1.184 sjg }
373 1.1 cgd }
374 1.399 rillig
375 1.231 rillig if (var == NULL && (flags & FIND_ENV)) {
376 1.1 cgd char *env;
377 1.1 cgd
378 1.97 christos if ((env = getenv(name)) != NULL) {
379 1.313 rillig Var *v = bmake_malloc(sizeof(Var));
380 1.412 rillig size_t len;
381 1.134 joerg v->name = bmake_strdup(name);
382 1.1 cgd
383 1.412 rillig len = strlen(env);
384 1.433 rillig Buf_Init(&v->val, len + 1);
385 1.433 rillig Buf_AddBytes(&v->val, env, len);
386 1.15 christos
387 1.1 cgd v->flags = VAR_FROM_ENV;
388 1.231 rillig return v;
389 1.399 rillig }
390 1.399 rillig
391 1.399 rillig if (checkEnvFirst && (flags & FIND_GLOBAL) && ctxt != VAR_GLOBAL) {
392 1.92 christos var = Hash_FindEntry(&VAR_GLOBAL->context, name);
393 1.399 rillig if (var == NULL && ctxt != VAR_INTERNAL)
394 1.184 sjg var = Hash_FindEntry(&VAR_INTERNAL->context, name);
395 1.399 rillig if (var == NULL)
396 1.136 dsl return NULL;
397 1.399 rillig else
398 1.231 rillig return (Var *)Hash_GetValue(var);
399 1.1 cgd }
400 1.399 rillig
401 1.399 rillig return NULL;
402 1.399 rillig }
403 1.399 rillig
404 1.399 rillig if (var == NULL)
405 1.136 dsl return NULL;
406 1.399 rillig else
407 1.231 rillig return (Var *)Hash_GetValue(var);
408 1.1 cgd }
409 1.1 cgd
410 1.1 cgd /*-
411 1.1 cgd *-----------------------------------------------------------------------
412 1.105 christos * VarFreeEnv --
413 1.105 christos * If the variable is an environment variable, free it
414 1.105 christos *
415 1.105 christos * Input:
416 1.105 christos * v the variable
417 1.105 christos * destroy true if the value buffer should be destroyed.
418 1.105 christos *
419 1.105 christos * Results:
420 1.400 rillig * TRUE if it is an environment variable, FALSE otherwise.
421 1.105 christos *-----------------------------------------------------------------------
422 1.105 christos */
423 1.105 christos static Boolean
424 1.105 christos VarFreeEnv(Var *v, Boolean destroy)
425 1.105 christos {
426 1.257 rillig if (!(v->flags & VAR_FROM_ENV))
427 1.105 christos return FALSE;
428 1.105 christos free(v->name);
429 1.146 dsl Buf_Destroy(&v->val, destroy);
430 1.105 christos free(v);
431 1.105 christos return TRUE;
432 1.105 christos }
433 1.105 christos
434 1.400 rillig /* Add a new variable of the given name and value to the given context.
435 1.400 rillig * The name and val arguments are duplicated so they may safely be freed. */
436 1.5 cgd static void
437 1.73 christos VarAdd(const char *name, const char *val, GNode *ctxt)
438 1.1 cgd {
439 1.313 rillig Var *v = bmake_malloc(sizeof(Var));
440 1.1 cgd
441 1.388 rillig size_t len = val != NULL ? strlen(val) : 0;
442 1.414 rillig Hash_Entry *he;
443 1.412 rillig
444 1.433 rillig Buf_Init(&v->val, len + 1);
445 1.433 rillig Buf_AddBytes(&v->val, val, len);
446 1.1 cgd
447 1.1 cgd v->flags = 0;
448 1.1 cgd
449 1.414 rillig he = Hash_CreateEntry(&ctxt->context, name, NULL);
450 1.414 rillig Hash_SetValue(he, v);
451 1.414 rillig v->name = he->name;
452 1.411 rillig VAR_DEBUG_IF(!(ctxt->flags & INTERNAL),
453 1.411 rillig "%s:%s = %s\n", ctxt->name, name, val);
454 1.1 cgd }
455 1.1 cgd
456 1.400 rillig /* Remove a variable from a context, freeing the Var structure as well. */
457 1.1 cgd void
458 1.73 christos Var_Delete(const char *name, GNode *ctxt)
459 1.1 cgd {
460 1.397 rillig char *name_freeIt = NULL;
461 1.414 rillig Hash_Entry *he;
462 1.412 rillig
463 1.397 rillig if (strchr(name, '$') != NULL)
464 1.397 rillig name = name_freeIt = Var_Subst(name, VAR_GLOBAL, VARE_WANTRES);
465 1.414 rillig he = Hash_FindEntry(&ctxt->context, name);
466 1.411 rillig VAR_DEBUG("%s:delete %s%s\n",
467 1.414 rillig ctxt->name, name, he != NULL ? "" : " (not found)");
468 1.397 rillig free(name_freeIt);
469 1.397 rillig
470 1.414 rillig if (he != NULL) {
471 1.414 rillig Var *v = (Var *)Hash_GetValue(he);
472 1.292 rillig if (v->flags & VAR_EXPORTED)
473 1.118 sjg unsetenv(v->name);
474 1.420 rillig if (strcmp(v->name, MAKE_EXPORTED) == 0)
475 1.155 sjg var_exportedVars = VAR_EXPORTED_NONE;
476 1.414 rillig if (v->name != he->name)
477 1.242 rillig free(v->name);
478 1.414 rillig Hash_DeleteEntry(&ctxt->context, he);
479 1.146 dsl Buf_Destroy(&v->val, TRUE);
480 1.98 christos free(v);
481 1.1 cgd }
482 1.1 cgd }
483 1.1 cgd
484 1.118 sjg
485 1.118 sjg /*
486 1.421 rillig * Export a single variable.
487 1.422 rillig * We ignore make internal variables (those which start with '.').
488 1.118 sjg * Also we jump through some hoops to avoid calling setenv
489 1.118 sjg * more than necessary since it can leak.
490 1.152 sjg * We only manipulate flags of vars if 'parent' is set.
491 1.118 sjg */
492 1.421 rillig static Boolean
493 1.292 rillig Var_Export1(const char *name, VarExportFlags flags)
494 1.118 sjg {
495 1.118 sjg char tmp[BUFSIZ];
496 1.292 rillig VarExportFlags parent = flags & VAR_EXPORT_PARENT;
497 1.412 rillig Var *v;
498 1.412 rillig char *val;
499 1.118 sjg
500 1.422 rillig if (name[0] == '.')
501 1.421 rillig return FALSE; /* skip internals */
502 1.422 rillig if (name[1] == '\0') {
503 1.118 sjg /*
504 1.118 sjg * A single char.
505 1.118 sjg * If it is one of the vars that should only appear in
506 1.118 sjg * local context, skip it, else we can get Var_Subst
507 1.118 sjg * into a loop.
508 1.118 sjg */
509 1.118 sjg switch (name[0]) {
510 1.118 sjg case '@':
511 1.118 sjg case '%':
512 1.118 sjg case '*':
513 1.118 sjg case '!':
514 1.421 rillig return FALSE;
515 1.118 sjg }
516 1.118 sjg }
517 1.401 rillig
518 1.412 rillig v = VarFind(name, VAR_GLOBAL, 0);
519 1.257 rillig if (v == NULL)
520 1.421 rillig return FALSE;
521 1.401 rillig
522 1.372 rillig if (!parent && (v->flags & VAR_EXPORTED) && !(v->flags & VAR_REEXPORT))
523 1.421 rillig return FALSE; /* nothing to do */
524 1.401 rillig
525 1.433 rillig val = Buf_GetAll(&v->val, NULL);
526 1.422 rillig if (!(flags & VAR_EXPORT_LITERAL) && strchr(val, '$') != NULL) {
527 1.412 rillig int n;
528 1.412 rillig
529 1.152 sjg if (parent) {
530 1.118 sjg /*
531 1.152 sjg * Flag this as something we need to re-export.
532 1.118 sjg * No point actually exporting it now though,
533 1.118 sjg * the child can do it at the last minute.
534 1.118 sjg */
535 1.365 rillig v->flags |= VAR_EXPORTED | VAR_REEXPORT;
536 1.421 rillig return TRUE;
537 1.118 sjg }
538 1.158 sjg if (v->flags & VAR_IN_USE) {
539 1.158 sjg /*
540 1.158 sjg * We recursed while exporting in a child.
541 1.158 sjg * This isn't going to end well, just skip it.
542 1.158 sjg */
543 1.421 rillig return FALSE;
544 1.158 sjg }
545 1.412 rillig n = snprintf(tmp, sizeof(tmp), "${%s}", name);
546 1.147 lukem if (n < (int)sizeof(tmp)) {
547 1.352 rillig val = Var_Subst(tmp, VAR_GLOBAL, VARE_WANTRES);
548 1.118 sjg setenv(name, val, 1);
549 1.118 sjg free(val);
550 1.118 sjg }
551 1.118 sjg } else {
552 1.292 rillig if (parent)
553 1.152 sjg v->flags &= ~VAR_REEXPORT; /* once will do */
554 1.292 rillig if (parent || !(v->flags & VAR_EXPORTED))
555 1.118 sjg setenv(name, val, 1);
556 1.118 sjg }
557 1.118 sjg /*
558 1.118 sjg * This is so Var_Set knows to call Var_Export again...
559 1.118 sjg */
560 1.152 sjg if (parent) {
561 1.152 sjg v->flags |= VAR_EXPORTED;
562 1.152 sjg }
563 1.421 rillig return TRUE;
564 1.118 sjg }
565 1.118 sjg
566 1.241 rillig static void
567 1.241 rillig Var_ExportVars_callback(void *entry, void *unused MAKE_ATTR_UNUSED)
568 1.241 rillig {
569 1.242 rillig Var *var = entry;
570 1.242 rillig Var_Export1(var->name, 0);
571 1.241 rillig }
572 1.241 rillig
573 1.118 sjg /*
574 1.118 sjg * This gets called from our children.
575 1.118 sjg */
576 1.118 sjg void
577 1.118 sjg Var_ExportVars(void)
578 1.118 sjg {
579 1.412 rillig char *val;
580 1.412 rillig
581 1.182 christos /*
582 1.182 christos * Several make's support this sort of mechanism for tracking
583 1.182 christos * recursion - but each uses a different name.
584 1.182 christos * We allow the makefiles to update MAKELEVEL and ensure
585 1.182 christos * children see a correctly incremented value.
586 1.182 christos */
587 1.401 rillig char tmp[BUFSIZ];
588 1.182 christos snprintf(tmp, sizeof(tmp), "%d", makelevel + 1);
589 1.182 christos setenv(MAKE_LEVEL_ENV, tmp, 1);
590 1.182 christos
591 1.420 rillig if (var_exportedVars == VAR_EXPORTED_NONE)
592 1.118 sjg return;
593 1.118 sjg
594 1.420 rillig if (var_exportedVars == VAR_EXPORTED_ALL) {
595 1.241 rillig /* Ouch! This is crazy... */
596 1.241 rillig Hash_ForEach(&VAR_GLOBAL->context, Var_ExportVars_callback, NULL);
597 1.118 sjg return;
598 1.118 sjg }
599 1.369 rillig
600 1.412 rillig val = Var_Subst("${" MAKE_EXPORTED ":O:u}", VAR_GLOBAL, VARE_WANTRES);
601 1.369 rillig if (*val) {
602 1.118 sjg char **av;
603 1.118 sjg char *as;
604 1.127 christos int ac;
605 1.118 sjg int i;
606 1.142 dsl
607 1.369 rillig av = brk_string(val, &ac, FALSE, &as);
608 1.369 rillig for (i = 0; i < ac; i++)
609 1.369 rillig Var_Export1(av[i], 0);
610 1.369 rillig free(as);
611 1.369 rillig free(av);
612 1.118 sjg }
613 1.369 rillig free(val);
614 1.118 sjg }
615 1.118 sjg
616 1.118 sjg /*
617 1.400 rillig * This is called when .export is seen or .MAKE.EXPORTED is modified.
618 1.400 rillig * It is also called when any exported variable is modified.
619 1.118 sjg */
620 1.118 sjg void
621 1.423 rillig Var_Export(const char *str, int isExport)
622 1.118 sjg {
623 1.412 rillig VarExportFlags flags;
624 1.412 rillig char *val;
625 1.412 rillig
626 1.422 rillig if (isExport && str[0] == '\0') {
627 1.118 sjg var_exportedVars = VAR_EXPORTED_ALL; /* use with caution! */
628 1.118 sjg return;
629 1.118 sjg }
630 1.118 sjg
631 1.412 rillig flags = 0;
632 1.159 sjg if (strncmp(str, "-env", 4) == 0) {
633 1.159 sjg str += 4;
634 1.203 sjg } else if (strncmp(str, "-literal", 8) == 0) {
635 1.203 sjg str += 8;
636 1.203 sjg flags |= VAR_EXPORT_LITERAL;
637 1.159 sjg } else {
638 1.203 sjg flags |= VAR_EXPORT_PARENT;
639 1.159 sjg }
640 1.302 rillig
641 1.412 rillig val = Var_Subst(str, VAR_GLOBAL, VARE_WANTRES);
642 1.422 rillig if (val[0] != '\0') {
643 1.401 rillig char *as;
644 1.401 rillig int ac;
645 1.401 rillig char **av = brk_string(val, &ac, FALSE, &as);
646 1.401 rillig
647 1.401 rillig int i;
648 1.200 sjg for (i = 0; i < ac; i++) {
649 1.302 rillig const char *name = av[i];
650 1.203 sjg if (Var_Export1(name, flags)) {
651 1.421 rillig if (var_exportedVars != VAR_EXPORTED_ALL)
652 1.200 sjg var_exportedVars = VAR_EXPORTED_YES;
653 1.203 sjg if (isExport && (flags & VAR_EXPORT_PARENT)) {
654 1.200 sjg Var_Append(MAKE_EXPORTED, name, VAR_GLOBAL);
655 1.200 sjg }
656 1.118 sjg }
657 1.118 sjg }
658 1.200 sjg free(as);
659 1.200 sjg free(av);
660 1.118 sjg }
661 1.118 sjg free(val);
662 1.118 sjg }
663 1.118 sjg
664 1.155 sjg
665 1.257 rillig extern char **environ;
666 1.257 rillig
667 1.155 sjg /*
668 1.155 sjg * This is called when .unexport[-env] is seen.
669 1.338 rillig *
670 1.338 rillig * str must have the form "unexport[-env] varname...".
671 1.155 sjg */
672 1.155 sjg void
673 1.423 rillig Var_UnExport(const char *str)
674 1.155 sjg {
675 1.155 sjg char tmp[BUFSIZ];
676 1.423 rillig const char *varnames;
677 1.423 rillig char *varnames_freeIt;
678 1.155 sjg int n;
679 1.412 rillig Boolean unexport_env;
680 1.155 sjg
681 1.423 rillig varnames = NULL;
682 1.423 rillig varnames_freeIt = NULL;
683 1.155 sjg
684 1.338 rillig str += strlen("unexport");
685 1.412 rillig unexport_env = strncmp(str, "-env", 4) == 0;
686 1.155 sjg if (unexport_env) {
687 1.423 rillig const char *cp;
688 1.155 sjg char **newenv;
689 1.155 sjg
690 1.179 sjg cp = getenv(MAKE_LEVEL_ENV); /* we should preserve this */
691 1.170 sjg if (environ == savedEnv) {
692 1.155 sjg /* we have been here before! */
693 1.155 sjg newenv = bmake_realloc(environ, 2 * sizeof(char *));
694 1.155 sjg } else {
695 1.170 sjg if (savedEnv) {
696 1.170 sjg free(savedEnv);
697 1.170 sjg savedEnv = NULL;
698 1.155 sjg }
699 1.155 sjg newenv = bmake_malloc(2 * sizeof(char *));
700 1.155 sjg }
701 1.423 rillig
702 1.155 sjg /* Note: we cannot safely free() the original environ. */
703 1.170 sjg environ = savedEnv = newenv;
704 1.155 sjg newenv[0] = NULL;
705 1.155 sjg newenv[1] = NULL;
706 1.221 sjg if (cp && *cp)
707 1.221 sjg setenv(MAKE_LEVEL_ENV, cp, 1);
708 1.155 sjg } else {
709 1.423 rillig for (; isspace((unsigned char)*str); str++)
710 1.155 sjg continue;
711 1.423 rillig if (str[0] != '\0')
712 1.423 rillig varnames = str;
713 1.155 sjg }
714 1.155 sjg
715 1.423 rillig if (varnames == NULL) {
716 1.155 sjg /* Using .MAKE.EXPORTED */
717 1.423 rillig varnames = varnames_freeIt = Var_Subst("${" MAKE_EXPORTED ":O:u}",
718 1.423 rillig VAR_GLOBAL, VARE_WANTRES);
719 1.155 sjg }
720 1.423 rillig
721 1.423 rillig if (TRUE) {
722 1.155 sjg Var *v;
723 1.155 sjg char **av;
724 1.155 sjg char *as;
725 1.155 sjg int ac;
726 1.155 sjg int i;
727 1.155 sjg
728 1.423 rillig av = brk_string(varnames, &ac, FALSE, &as);
729 1.155 sjg for (i = 0; i < ac; i++) {
730 1.155 sjg v = VarFind(av[i], VAR_GLOBAL, 0);
731 1.423 rillig if (v == NULL) {
732 1.423 rillig VAR_DEBUG("Not unexporting \"%s\" (not found)\n", av[i]);
733 1.155 sjg continue;
734 1.423 rillig }
735 1.423 rillig
736 1.423 rillig VAR_DEBUG("Unexporting \"%s\"\n", av[i]);
737 1.423 rillig if (!unexport_env && (v->flags & VAR_EXPORTED) &&
738 1.423 rillig !(v->flags & VAR_REEXPORT))
739 1.155 sjg unsetenv(v->name);
740 1.292 rillig v->flags &= ~(VAR_EXPORTED | VAR_REEXPORT);
741 1.423 rillig
742 1.155 sjg /*
743 1.155 sjg * If we are unexporting a list,
744 1.155 sjg * remove each one from .MAKE.EXPORTED.
745 1.155 sjg * If we are removing them all,
746 1.155 sjg * just delete .MAKE.EXPORTED below.
747 1.155 sjg */
748 1.423 rillig if (varnames == str) {
749 1.155 sjg n = snprintf(tmp, sizeof(tmp),
750 1.155 sjg "${" MAKE_EXPORTED ":N%s}", v->name);
751 1.155 sjg if (n < (int)sizeof(tmp)) {
752 1.423 rillig char *cp = Var_Subst(tmp, VAR_GLOBAL, VARE_WANTRES);
753 1.230 rillig Var_Set(MAKE_EXPORTED, cp, VAR_GLOBAL);
754 1.155 sjg free(cp);
755 1.155 sjg }
756 1.155 sjg }
757 1.155 sjg }
758 1.155 sjg free(as);
759 1.155 sjg free(av);
760 1.423 rillig if (varnames != str) {
761 1.155 sjg Var_Delete(MAKE_EXPORTED, VAR_GLOBAL);
762 1.423 rillig free(varnames_freeIt);
763 1.155 sjg }
764 1.155 sjg }
765 1.155 sjg }
766 1.155 sjg
767 1.400 rillig /* See Var_Set for documentation. */
768 1.230 rillig static void
769 1.242 rillig Var_Set_with_flags(const char *name, const char *val, GNode *ctxt,
770 1.242 rillig VarSet_Flags flags)
771 1.1 cgd {
772 1.370 rillig char *name_freeIt = NULL;
773 1.412 rillig Var *v;
774 1.142 dsl
775 1.1 cgd /*
776 1.1 cgd * We only look for a variable in the given context since anything set
777 1.1 cgd * here will override anything in a lower context, so there's not much
778 1.1 cgd * point in searching them all just to save a bit of memory...
779 1.1 cgd */
780 1.139 dsl if (strchr(name, '$') != NULL) {
781 1.380 rillig const char *unexpanded_name = name;
782 1.370 rillig name = name_freeIt = Var_Subst(name, ctxt, VARE_WANTRES);
783 1.370 rillig if (name[0] == '\0') {
784 1.411 rillig VAR_DEBUG("Var_Set(\"%s\", \"%s\", ...) "
785 1.411 rillig "name expands to empty string - ignored\n",
786 1.411 rillig unexpanded_name, val);
787 1.370 rillig free(name_freeIt);
788 1.139 dsl return;
789 1.139 dsl }
790 1.139 dsl }
791 1.400 rillig
792 1.129 sjg if (ctxt == VAR_GLOBAL) {
793 1.129 sjg v = VarFind(name, VAR_CMD, 0);
794 1.136 dsl if (v != NULL) {
795 1.371 rillig if (v->flags & VAR_FROM_CMD) {
796 1.411 rillig VAR_DEBUG("%s:%s = %s ignored!\n", ctxt->name, name, val);
797 1.131 sjg goto out;
798 1.131 sjg }
799 1.131 sjg VarFreeEnv(v, TRUE);
800 1.129 sjg }
801 1.129 sjg }
802 1.400 rillig
803 1.92 christos v = VarFind(name, ctxt, 0);
804 1.136 dsl if (v == NULL) {
805 1.371 rillig if (ctxt == VAR_CMD && !(flags & VAR_NO_EXPORT)) {
806 1.183 sjg /*
807 1.183 sjg * This var would normally prevent the same name being added
808 1.183 sjg * to VAR_GLOBAL, so delete it from there if needed.
809 1.183 sjg * Otherwise -V name may show the wrong value.
810 1.183 sjg */
811 1.183 sjg Var_Delete(name, VAR_GLOBAL);
812 1.183 sjg }
813 1.92 christos VarAdd(name, val, ctxt);
814 1.1 cgd } else {
815 1.146 dsl Buf_Empty(&v->val);
816 1.218 sjg if (val)
817 1.313 rillig Buf_AddStr(&v->val, val);
818 1.1 cgd
819 1.411 rillig VAR_DEBUG("%s:%s = %s\n", ctxt->name, name, val);
820 1.371 rillig if (v->flags & VAR_EXPORTED) {
821 1.152 sjg Var_Export1(name, VAR_EXPORT_PARENT);
822 1.118 sjg }
823 1.1 cgd }
824 1.1 cgd /*
825 1.1 cgd * Any variables given on the command line are automatically exported
826 1.1 cgd * to the environment (as per POSIX standard)
827 1.1 cgd */
828 1.371 rillig if (ctxt == VAR_CMD && !(flags & VAR_NO_EXPORT)) {
829 1.136 dsl if (v == NULL) {
830 1.131 sjg /* we just added it */
831 1.131 sjg v = VarFind(name, ctxt, 0);
832 1.131 sjg }
833 1.151 christos if (v != NULL)
834 1.150 christos v->flags |= VAR_FROM_CMD;
835 1.71 thorpej /*
836 1.71 thorpej * If requested, don't export these in the environment
837 1.71 thorpej * individually. We still put them in MAKEOVERRIDES so
838 1.71 thorpej * that the command-line settings continue to override
839 1.71 thorpej * Makefile settings.
840 1.71 thorpej */
841 1.427 rillig if (!varNoExportEnv)
842 1.218 sjg setenv(name, val ? val : "", 1);
843 1.62 sjg
844 1.64 sjg Var_Append(MAKEOVERRIDES, name, VAR_GLOBAL);
845 1.1 cgd }
846 1.292 rillig if (name[0] == '.' && strcmp(name, SAVE_DOLLARS) == 0)
847 1.292 rillig save_dollars = s2Boolean(val, save_dollars);
848 1.205 sjg
849 1.242 rillig out:
850 1.370 rillig free(name_freeIt);
851 1.136 dsl if (v != NULL)
852 1.107 christos VarFreeEnv(v, TRUE);
853 1.1 cgd }
854 1.1 cgd
855 1.1 cgd /*-
856 1.1 cgd *-----------------------------------------------------------------------
857 1.230 rillig * Var_Set --
858 1.230 rillig * Set the variable name to the value val in the given context.
859 1.230 rillig *
860 1.230 rillig * Input:
861 1.230 rillig * name name of variable to set
862 1.230 rillig * val value to give to the variable
863 1.230 rillig * ctxt context in which to set it
864 1.230 rillig *
865 1.230 rillig * Side Effects:
866 1.400 rillig * If the variable doesn't yet exist, it is created.
867 1.400 rillig * Otherwise the new value overwrites and replaces the old value.
868 1.230 rillig *
869 1.230 rillig * Notes:
870 1.230 rillig * The variable is searched for only in its context before being
871 1.230 rillig * created in that context. I.e. if the context is VAR_GLOBAL,
872 1.230 rillig * only VAR_GLOBAL->context is searched. Likewise if it is VAR_CMD, only
873 1.230 rillig * VAR_CMD->context is searched. This is done to avoid the literally
874 1.230 rillig * thousands of unnecessary strcmp's that used to be done to
875 1.230 rillig * set, say, $(@) or $(<).
876 1.230 rillig * If the context is VAR_GLOBAL though, we check if the variable
877 1.230 rillig * was set in VAR_CMD from the command line and skip it if so.
878 1.230 rillig *-----------------------------------------------------------------------
879 1.230 rillig */
880 1.230 rillig void
881 1.230 rillig Var_Set(const char *name, const char *val, GNode *ctxt)
882 1.230 rillig {
883 1.242 rillig Var_Set_with_flags(name, val, ctxt, 0);
884 1.230 rillig }
885 1.230 rillig
886 1.230 rillig /*-
887 1.230 rillig *-----------------------------------------------------------------------
888 1.1 cgd * Var_Append --
889 1.1 cgd * The variable of the given name has the given value appended to it in
890 1.1 cgd * the given context.
891 1.1 cgd *
892 1.70 wiz * Input:
893 1.70 wiz * name name of variable to modify
894 1.400 rillig * val string to append to it
895 1.400 rillig * ctxt context in which this should occur
896 1.70 wiz *
897 1.1 cgd * Side Effects:
898 1.400 rillig * If the variable doesn't exist, it is created. Otherwise the strings
899 1.400 rillig * are concatenated, with a space in between.
900 1.1 cgd *
901 1.1 cgd * Notes:
902 1.1 cgd * Only if the variable is being sought in the global context is the
903 1.1 cgd * environment searched.
904 1.1 cgd * XXX: Knows its calling circumstances in that if called with ctxt
905 1.1 cgd * an actual target, it will only search that context since only
906 1.1 cgd * a local variable could be being appended to. This is actually
907 1.1 cgd * a big win and must be tolerated.
908 1.1 cgd *-----------------------------------------------------------------------
909 1.1 cgd */
910 1.1 cgd void
911 1.73 christos Var_Append(const char *name, const char *val, GNode *ctxt)
912 1.1 cgd {
913 1.427 rillig char *name_freeIt = NULL;
914 1.412 rillig Var *v;
915 1.1 cgd
916 1.139 dsl if (strchr(name, '$') != NULL) {
917 1.427 rillig const char *unexpanded_name = name;
918 1.427 rillig name = name_freeIt = Var_Subst(name, ctxt, VARE_WANTRES);
919 1.427 rillig if (name[0] == '\0') {
920 1.411 rillig VAR_DEBUG("Var_Append(\"%s\", \"%s\", ...) "
921 1.411 rillig "name expands to empty string - ignored\n",
922 1.427 rillig unexpanded_name, val);
923 1.427 rillig free(name_freeIt);
924 1.139 dsl return;
925 1.139 dsl }
926 1.139 dsl }
927 1.142 dsl
928 1.412 rillig v = VarFind(name, ctxt, ctxt == VAR_GLOBAL ? (FIND_CMD | FIND_ENV) : 0);
929 1.1 cgd
930 1.136 dsl if (v == NULL) {
931 1.230 rillig Var_Set(name, val, ctxt);
932 1.217 sjg } else if (ctxt == VAR_CMD || !(v->flags & VAR_FROM_CMD)) {
933 1.146 dsl Buf_AddByte(&v->val, ' ');
934 1.313 rillig Buf_AddStr(&v->val, val);
935 1.1 cgd
936 1.411 rillig VAR_DEBUG("%s:%s = %s\n", ctxt->name, name,
937 1.433 rillig Buf_GetAll(&v->val, NULL));
938 1.1 cgd
939 1.1 cgd if (v->flags & VAR_FROM_ENV) {
940 1.412 rillig Hash_Entry *h;
941 1.412 rillig
942 1.1 cgd /*
943 1.1 cgd * If the original variable came from the environment, we
944 1.1 cgd * have to install it in the global context (we could place
945 1.1 cgd * it in the environment, but then we should provide a way to
946 1.1 cgd * export other variables...)
947 1.1 cgd */
948 1.1 cgd v->flags &= ~VAR_FROM_ENV;
949 1.412 rillig h = Hash_CreateEntry(&ctxt->context, name, NULL);
950 1.36 mycroft Hash_SetValue(h, v);
951 1.1 cgd }
952 1.1 cgd }
953 1.427 rillig free(name_freeIt);
954 1.1 cgd }
955 1.1 cgd
956 1.1 cgd /*-
957 1.1 cgd *-----------------------------------------------------------------------
958 1.1 cgd * Var_Exists --
959 1.1 cgd * See if the given variable exists.
960 1.1 cgd *
961 1.70 wiz * Input:
962 1.70 wiz * name Variable to find
963 1.70 wiz * ctxt Context in which to start search
964 1.70 wiz *
965 1.1 cgd * Results:
966 1.1 cgd * TRUE if it does, FALSE if it doesn't
967 1.1 cgd *
968 1.1 cgd * Side Effects:
969 1.1 cgd * None.
970 1.1 cgd *
971 1.1 cgd *-----------------------------------------------------------------------
972 1.1 cgd */
973 1.1 cgd Boolean
974 1.73 christos Var_Exists(const char *name, GNode *ctxt)
975 1.1 cgd {
976 1.373 rillig char *name_freeIt = NULL;
977 1.412 rillig Var *v;
978 1.412 rillig
979 1.373 rillig if (strchr(name, '$') != NULL)
980 1.373 rillig name = name_freeIt = Var_Subst(name, ctxt, VARE_WANTRES);
981 1.1 cgd
982 1.412 rillig v = VarFind(name, ctxt, FIND_CMD | FIND_GLOBAL | FIND_ENV);
983 1.373 rillig free(name_freeIt);
984 1.257 rillig if (v == NULL)
985 1.231 rillig return FALSE;
986 1.231 rillig
987 1.231 rillig (void)VarFreeEnv(v, TRUE);
988 1.231 rillig return TRUE;
989 1.1 cgd }
990 1.1 cgd
991 1.1 cgd /*-
992 1.1 cgd *-----------------------------------------------------------------------
993 1.1 cgd * Var_Value --
994 1.337 rillig * Return the unexpanded value of the given variable in the given
995 1.374 rillig * context, or the usual contexts.
996 1.1 cgd *
997 1.70 wiz * Input:
998 1.70 wiz * name name to find
999 1.70 wiz * ctxt context in which to search for it
1000 1.70 wiz *
1001 1.1 cgd * Results:
1002 1.337 rillig * The value if the variable exists, NULL if it doesn't.
1003 1.337 rillig * If the returned value is not NULL, the caller must free *freeIt
1004 1.337 rillig * as soon as the returned value is no longer needed.
1005 1.1 cgd *-----------------------------------------------------------------------
1006 1.1 cgd */
1007 1.375 rillig const char *
1008 1.337 rillig Var_Value(const char *name, GNode *ctxt, char **freeIt)
1009 1.1 cgd {
1010 1.257 rillig Var *v = VarFind(name, ctxt, FIND_ENV | FIND_GLOBAL | FIND_CMD);
1011 1.412 rillig char *p;
1012 1.412 rillig
1013 1.337 rillig *freeIt = NULL;
1014 1.231 rillig if (v == NULL)
1015 1.136 dsl return NULL;
1016 1.231 rillig
1017 1.433 rillig p = Buf_GetAll(&v->val, NULL);
1018 1.231 rillig if (VarFreeEnv(v, FALSE))
1019 1.337 rillig *freeIt = p;
1020 1.231 rillig return p;
1021 1.1 cgd }
1022 1.1 cgd
1023 1.244 rillig
1024 1.278 rillig /* SepBuf is a string being built from "words", interleaved with separators. */
1025 1.278 rillig typedef struct {
1026 1.278 rillig Buffer buf;
1027 1.278 rillig Boolean needSep;
1028 1.278 rillig char sep;
1029 1.278 rillig } SepBuf;
1030 1.278 rillig
1031 1.278 rillig static void
1032 1.278 rillig SepBuf_Init(SepBuf *buf, char sep)
1033 1.278 rillig {
1034 1.433 rillig Buf_Init(&buf->buf, 32 /* bytes */);
1035 1.278 rillig buf->needSep = FALSE;
1036 1.278 rillig buf->sep = sep;
1037 1.278 rillig }
1038 1.278 rillig
1039 1.278 rillig static void
1040 1.278 rillig SepBuf_Sep(SepBuf *buf)
1041 1.278 rillig {
1042 1.278 rillig buf->needSep = TRUE;
1043 1.278 rillig }
1044 1.278 rillig
1045 1.278 rillig static void
1046 1.314 rillig SepBuf_AddBytes(SepBuf *buf, const char *mem, size_t mem_size)
1047 1.278 rillig {
1048 1.278 rillig if (mem_size == 0)
1049 1.278 rillig return;
1050 1.278 rillig if (buf->needSep && buf->sep != '\0') {
1051 1.278 rillig Buf_AddByte(&buf->buf, buf->sep);
1052 1.278 rillig buf->needSep = FALSE;
1053 1.278 rillig }
1054 1.433 rillig Buf_AddBytes(&buf->buf, mem, mem_size);
1055 1.278 rillig }
1056 1.278 rillig
1057 1.314 rillig static void
1058 1.314 rillig SepBuf_AddBytesBetween(SepBuf *buf, const char *start, const char *end)
1059 1.314 rillig {
1060 1.314 rillig SepBuf_AddBytes(buf, start, (size_t)(end - start));
1061 1.314 rillig }
1062 1.314 rillig
1063 1.314 rillig static void
1064 1.314 rillig SepBuf_AddStr(SepBuf *buf, const char *str)
1065 1.314 rillig {
1066 1.314 rillig SepBuf_AddBytes(buf, str, strlen(str));
1067 1.314 rillig }
1068 1.314 rillig
1069 1.278 rillig static char *
1070 1.278 rillig SepBuf_Destroy(SepBuf *buf, Boolean free_buf)
1071 1.278 rillig {
1072 1.278 rillig return Buf_Destroy(&buf->buf, free_buf);
1073 1.278 rillig }
1074 1.278 rillig
1075 1.278 rillig
1076 1.291 rillig /* This callback for ModifyWords gets a single word from an expression and
1077 1.244 rillig * typically adds a modification of this word to the buffer. It may also do
1078 1.278 rillig * nothing or add several words. */
1079 1.295 rillig typedef void (*ModifyWordsCallback)(const char *word, SepBuf *buf, void *data);
1080 1.244 rillig
1081 1.244 rillig
1082 1.291 rillig /* Callback for ModifyWords to implement the :H modifier.
1083 1.244 rillig * Add the dirname of the given word to the buffer. */
1084 1.278 rillig static void
1085 1.295 rillig ModifyWord_Head(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
1086 1.1 cgd {
1087 1.238 rillig const char *slash = strrchr(word, '/');
1088 1.238 rillig if (slash != NULL)
1089 1.314 rillig SepBuf_AddBytesBetween(buf, word, slash);
1090 1.238 rillig else
1091 1.314 rillig SepBuf_AddStr(buf, ".");
1092 1.1 cgd }
1093 1.1 cgd
1094 1.291 rillig /* Callback for ModifyWords to implement the :T modifier.
1095 1.244 rillig * Add the basename of the given word to the buffer. */
1096 1.278 rillig static void
1097 1.295 rillig ModifyWord_Tail(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
1098 1.1 cgd {
1099 1.238 rillig const char *slash = strrchr(word, '/');
1100 1.238 rillig const char *base = slash != NULL ? slash + 1 : word;
1101 1.314 rillig SepBuf_AddStr(buf, base);
1102 1.1 cgd }
1103 1.1 cgd
1104 1.291 rillig /* Callback for ModifyWords to implement the :E modifier.
1105 1.244 rillig * Add the filename suffix of the given word to the buffer, if it exists. */
1106 1.278 rillig static void
1107 1.295 rillig ModifyWord_Suffix(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
1108 1.1 cgd {
1109 1.239 rillig const char *dot = strrchr(word, '.');
1110 1.278 rillig if (dot != NULL)
1111 1.314 rillig SepBuf_AddStr(buf, dot + 1);
1112 1.1 cgd }
1113 1.1 cgd
1114 1.291 rillig /* Callback for ModifyWords to implement the :R modifier.
1115 1.291 rillig * Add the basename of the given word to the buffer. */
1116 1.278 rillig static void
1117 1.295 rillig ModifyWord_Root(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
1118 1.1 cgd {
1119 1.314 rillig const char *dot = strrchr(word, '.');
1120 1.247 lukem size_t len = dot != NULL ? (size_t)(dot - word) : strlen(word);
1121 1.278 rillig SepBuf_AddBytes(buf, word, len);
1122 1.1 cgd }
1123 1.1 cgd
1124 1.291 rillig /* Callback for ModifyWords to implement the :M modifier.
1125 1.244 rillig * Place the word in the buffer if it matches the given pattern. */
1126 1.278 rillig static void
1127 1.295 rillig ModifyWord_Match(const char *word, SepBuf *buf, void *data)
1128 1.1 cgd {
1129 1.244 rillig const char *pattern = data;
1130 1.411 rillig VAR_DEBUG("VarMatch [%s] [%s]\n", word, pattern);
1131 1.278 rillig if (Str_Match(word, pattern))
1132 1.314 rillig SepBuf_AddStr(buf, word);
1133 1.1 cgd }
1134 1.1 cgd
1135 1.291 rillig /* Callback for ModifyWords to implement the :N modifier.
1136 1.291 rillig * Place the word in the buffer if it doesn't match the given pattern. */
1137 1.291 rillig static void
1138 1.295 rillig ModifyWord_NoMatch(const char *word, SepBuf *buf, void *data)
1139 1.291 rillig {
1140 1.291 rillig const char *pattern = data;
1141 1.291 rillig if (!Str_Match(word, pattern))
1142 1.314 rillig SepBuf_AddStr(buf, word);
1143 1.291 rillig }
1144 1.291 rillig
1145 1.13 christos #ifdef SYSVVARSUB
1146 1.256 rillig /*-
1147 1.256 rillig *-----------------------------------------------------------------------
1148 1.256 rillig * Str_SYSVMatch --
1149 1.256 rillig * Check word against pattern for a match (% is wild),
1150 1.256 rillig *
1151 1.256 rillig * Input:
1152 1.256 rillig * word Word to examine
1153 1.256 rillig * pattern Pattern to examine against
1154 1.256 rillig *
1155 1.256 rillig * Results:
1156 1.377 rillig * Returns the start of the match, or NULL.
1157 1.377 rillig * *match_len returns the length of the match, if any.
1158 1.377 rillig * *hasPercent returns whether the pattern contains a percent.
1159 1.256 rillig *-----------------------------------------------------------------------
1160 1.256 rillig */
1161 1.277 rillig static const char *
1162 1.377 rillig Str_SYSVMatch(const char *word, const char *pattern, size_t *match_len,
1163 1.417 rillig Boolean *hasPercent)
1164 1.256 rillig {
1165 1.256 rillig const char *p = pattern;
1166 1.256 rillig const char *w = word;
1167 1.412 rillig const char *percent;
1168 1.412 rillig size_t w_len;
1169 1.412 rillig size_t p_len;
1170 1.412 rillig const char *w_tail;
1171 1.256 rillig
1172 1.256 rillig *hasPercent = FALSE;
1173 1.377 rillig if (*p == '\0') { /* ${VAR:=suffix} */
1174 1.377 rillig *match_len = strlen(w); /* Null pattern is the whole string */
1175 1.277 rillig return w;
1176 1.256 rillig }
1177 1.256 rillig
1178 1.412 rillig percent = strchr(p, '%');
1179 1.377 rillig if (percent != NULL) { /* ${VAR:...%...=...} */
1180 1.256 rillig *hasPercent = TRUE;
1181 1.377 rillig if (*w == '\0')
1182 1.377 rillig return NULL; /* empty word does not match pattern */
1183 1.377 rillig
1184 1.256 rillig /* check that the prefix matches */
1185 1.377 rillig for (; p != percent && *w != '\0' && *w == *p; w++, p++)
1186 1.417 rillig continue;
1187 1.377 rillig if (p != percent)
1188 1.256 rillig return NULL; /* No match */
1189 1.256 rillig
1190 1.377 rillig p++; /* Skip the percent */
1191 1.377 rillig if (*p == '\0') {
1192 1.256 rillig /* No more pattern, return the rest of the string */
1193 1.377 rillig *match_len = strlen(w);
1194 1.277 rillig return w;
1195 1.256 rillig }
1196 1.256 rillig }
1197 1.256 rillig
1198 1.378 rillig /* Test whether the tail matches */
1199 1.412 rillig w_len = strlen(w);
1200 1.412 rillig p_len = strlen(p);
1201 1.378 rillig if (w_len < p_len)
1202 1.378 rillig return NULL;
1203 1.256 rillig
1204 1.412 rillig w_tail = w + w_len - p_len;
1205 1.378 rillig if (memcmp(p, w_tail, p_len) != 0)
1206 1.380 rillig return NULL;
1207 1.256 rillig
1208 1.378 rillig *match_len = w_tail - w;
1209 1.378 rillig return w;
1210 1.256 rillig }
1211 1.256 rillig
1212 1.276 rillig typedef struct {
1213 1.295 rillig GNode *ctx;
1214 1.276 rillig const char *lhs;
1215 1.276 rillig const char *rhs;
1216 1.291 rillig } ModifyWord_SYSVSubstArgs;
1217 1.276 rillig
1218 1.291 rillig /* Callback for ModifyWords to implement the :%.from=%.to modifier. */
1219 1.278 rillig static void
1220 1.295 rillig ModifyWord_SYSVSubst(const char *word, SepBuf *buf, void *data)
1221 1.5 cgd {
1222 1.291 rillig const ModifyWord_SYSVSubstArgs *args = data;
1223 1.412 rillig char *rhs_expanded;
1224 1.412 rillig const char *rhs;
1225 1.412 rillig const char *percent;
1226 1.5 cgd
1227 1.377 rillig size_t match_len;
1228 1.377 rillig Boolean lhsPercent;
1229 1.377 rillig const char *match = Str_SYSVMatch(word, args->lhs, &match_len, &lhsPercent);
1230 1.379 rillig if (match == NULL) {
1231 1.314 rillig SepBuf_AddStr(buf, word);
1232 1.379 rillig return;
1233 1.379 rillig }
1234 1.379 rillig
1235 1.379 rillig /* Append rhs to the buffer, substituting the first '%' with the
1236 1.379 rillig * match, but only if the lhs had a '%' as well. */
1237 1.379 rillig
1238 1.412 rillig rhs_expanded = Var_Subst(args->rhs, args->ctx, VARE_WANTRES);
1239 1.379 rillig
1240 1.412 rillig rhs = rhs_expanded;
1241 1.412 rillig percent = strchr(rhs, '%');
1242 1.379 rillig
1243 1.379 rillig if (percent != NULL && lhsPercent) {
1244 1.379 rillig /* Copy the prefix of the replacement pattern */
1245 1.379 rillig SepBuf_AddBytesBetween(buf, rhs, percent);
1246 1.379 rillig rhs = percent + 1;
1247 1.61 explorer }
1248 1.379 rillig if (percent != NULL || !lhsPercent)
1249 1.379 rillig SepBuf_AddBytes(buf, match, match_len);
1250 1.379 rillig
1251 1.379 rillig /* Append the suffix of the replacement pattern */
1252 1.379 rillig SepBuf_AddStr(buf, rhs);
1253 1.379 rillig
1254 1.379 rillig free(rhs_expanded);
1255 1.5 cgd }
1256 1.13 christos #endif
1257 1.5 cgd
1258 1.1 cgd
1259 1.291 rillig typedef struct {
1260 1.291 rillig const char *lhs;
1261 1.291 rillig size_t lhsLen;
1262 1.291 rillig const char *rhs;
1263 1.291 rillig size_t rhsLen;
1264 1.291 rillig VarPatternFlags pflags;
1265 1.291 rillig } ModifyWord_SubstArgs;
1266 1.291 rillig
1267 1.291 rillig /* Callback for ModifyWords to implement the :S,from,to, modifier.
1268 1.244 rillig * Perform a string substitution on the given word. */
1269 1.278 rillig static void
1270 1.295 rillig ModifyWord_Subst(const char *word, SepBuf *buf, void *data)
1271 1.1 cgd {
1272 1.279 rillig size_t wordLen = strlen(word);
1273 1.291 rillig ModifyWord_SubstArgs *args = data;
1274 1.281 rillig const VarPatternFlags pflags = args->pflags;
1275 1.412 rillig const char *match;
1276 1.1 cgd
1277 1.311 rillig if ((pflags & VARP_SUB_ONE) && (pflags & VARP_SUB_MATCHED))
1278 1.279 rillig goto nosub;
1279 1.279 rillig
1280 1.288 rillig if (args->pflags & VARP_ANCHOR_START) {
1281 1.282 rillig if (wordLen < args->lhsLen ||
1282 1.282 rillig memcmp(word, args->lhs, args->lhsLen) != 0)
1283 1.1 cgd goto nosub;
1284 1.279 rillig
1285 1.288 rillig if (args->pflags & VARP_ANCHOR_END) {
1286 1.281 rillig if (wordLen != args->lhsLen)
1287 1.1 cgd goto nosub;
1288 1.279 rillig
1289 1.281 rillig SepBuf_AddBytes(buf, args->rhs, args->rhsLen);
1290 1.281 rillig args->pflags |= VARP_SUB_MATCHED;
1291 1.1 cgd } else {
1292 1.281 rillig SepBuf_AddBytes(buf, args->rhs, args->rhsLen);
1293 1.281 rillig SepBuf_AddBytes(buf, word + args->lhsLen, wordLen - args->lhsLen);
1294 1.281 rillig args->pflags |= VARP_SUB_MATCHED;
1295 1.1 cgd }
1296 1.278 rillig return;
1297 1.1 cgd }
1298 1.279 rillig
1299 1.288 rillig if (args->pflags & VARP_ANCHOR_END) {
1300 1.417 rillig const char *start;
1301 1.412 rillig
1302 1.281 rillig if (wordLen < args->lhsLen)
1303 1.280 rillig goto nosub;
1304 1.315 rillig
1305 1.412 rillig start = word + (wordLen - args->lhsLen);
1306 1.281 rillig if (memcmp(start, args->lhs, args->lhsLen) != 0)
1307 1.279 rillig goto nosub;
1308 1.279 rillig
1309 1.314 rillig SepBuf_AddBytesBetween(buf, word, start);
1310 1.281 rillig SepBuf_AddBytes(buf, args->rhs, args->rhsLen);
1311 1.281 rillig args->pflags |= VARP_SUB_MATCHED;
1312 1.279 rillig return;
1313 1.279 rillig }
1314 1.279 rillig
1315 1.424 rillig /* unanchored case, may match more than once */
1316 1.315 rillig while ((match = Str_FindSubstring(word, args->lhs)) != NULL) {
1317 1.315 rillig SepBuf_AddBytesBetween(buf, word, match);
1318 1.281 rillig SepBuf_AddBytes(buf, args->rhs, args->rhsLen);
1319 1.310 rillig args->pflags |= VARP_SUB_MATCHED;
1320 1.315 rillig wordLen -= (match - word) + args->lhsLen;
1321 1.315 rillig word += (match - word) + args->lhsLen;
1322 1.281 rillig if (wordLen == 0 || !(args->pflags & VARP_SUB_GLOBAL))
1323 1.279 rillig break;
1324 1.279 rillig }
1325 1.242 rillig nosub:
1326 1.278 rillig SepBuf_AddBytes(buf, word, wordLen);
1327 1.1 cgd }
1328 1.1 cgd
1329 1.31 gwr #ifndef NO_REGEX
1330 1.400 rillig /* Print the error caused by a regcomp or regexec call. */
1331 1.16 christos static void
1332 1.202 christos VarREError(int reerr, regex_t *pat, const char *str)
1333 1.16 christos {
1334 1.401 rillig int errlen = regerror(reerr, pat, 0, 0);
1335 1.401 rillig char *errbuf = bmake_malloc(errlen);
1336 1.202 christos regerror(reerr, pat, errbuf, errlen);
1337 1.16 christos Error("%s: %s", str, errbuf);
1338 1.16 christos free(errbuf);
1339 1.16 christos }
1340 1.16 christos
1341 1.291 rillig typedef struct {
1342 1.291 rillig regex_t re;
1343 1.291 rillig int nsub;
1344 1.291 rillig char *replace;
1345 1.291 rillig VarPatternFlags pflags;
1346 1.291 rillig } ModifyWord_SubstRegexArgs;
1347 1.291 rillig
1348 1.291 rillig /* Callback for ModifyWords to implement the :C/from/to/ modifier.
1349 1.244 rillig * Perform a regex substitution on the given word. */
1350 1.278 rillig static void
1351 1.295 rillig ModifyWord_SubstRegex(const char *word, SepBuf *buf, void *data)
1352 1.16 christos {
1353 1.304 rillig ModifyWord_SubstRegexArgs *args = data;
1354 1.16 christos int xrv;
1355 1.253 rillig const char *wp = word;
1356 1.16 christos char *rp;
1357 1.20 christos int flags = 0;
1358 1.305 rillig regmatch_t m[10];
1359 1.16 christos
1360 1.306 rillig if ((args->pflags & VARP_SUB_ONE) && (args->pflags & VARP_SUB_MATCHED))
1361 1.307 rillig goto nosub;
1362 1.307 rillig
1363 1.307 rillig tryagain:
1364 1.307 rillig xrv = regexec(&args->re, wp, args->nsub, m, flags);
1365 1.16 christos
1366 1.16 christos switch (xrv) {
1367 1.16 christos case 0:
1368 1.304 rillig args->pflags |= VARP_SUB_MATCHED;
1369 1.305 rillig SepBuf_AddBytes(buf, wp, m[0].rm_so);
1370 1.16 christos
1371 1.304 rillig for (rp = args->replace; *rp; rp++) {
1372 1.278 rillig if (*rp == '\\' && (rp[1] == '&' || rp[1] == '\\')) {
1373 1.278 rillig SepBuf_AddBytes(buf, rp + 1, 1);
1374 1.16 christos rp++;
1375 1.278 rillig } else if (*rp == '&' ||
1376 1.417 rillig (*rp == '\\' && isdigit((unsigned char)rp[1]))) {
1377 1.16 christos int n;
1378 1.16 christos char errstr[3];
1379 1.16 christos
1380 1.16 christos if (*rp == '&') {
1381 1.16 christos n = 0;
1382 1.16 christos errstr[0] = '&';
1383 1.16 christos errstr[1] = '\0';
1384 1.16 christos } else {
1385 1.16 christos n = rp[1] - '0';
1386 1.16 christos errstr[0] = '\\';
1387 1.16 christos errstr[1] = rp[1];
1388 1.16 christos errstr[2] = '\0';
1389 1.16 christos rp++;
1390 1.16 christos }
1391 1.16 christos
1392 1.304 rillig if (n >= args->nsub) {
1393 1.294 rillig Error("No subexpression %s", errstr);
1394 1.305 rillig } else if (m[n].rm_so == -1 && m[n].rm_eo == -1) {
1395 1.294 rillig Error("No match for subexpression %s", errstr);
1396 1.242 rillig } else {
1397 1.314 rillig SepBuf_AddBytesBetween(buf, wp + m[n].rm_so,
1398 1.314 rillig wp + m[n].rm_eo);
1399 1.16 christos }
1400 1.16 christos
1401 1.16 christos } else {
1402 1.278 rillig SepBuf_AddBytes(buf, rp, 1);
1403 1.16 christos }
1404 1.16 christos }
1405 1.305 rillig wp += m[0].rm_eo;
1406 1.304 rillig if (args->pflags & VARP_SUB_GLOBAL) {
1407 1.20 christos flags |= REG_NOTBOL;
1408 1.305 rillig if (m[0].rm_so == 0 && m[0].rm_eo == 0) {
1409 1.278 rillig SepBuf_AddBytes(buf, wp, 1);
1410 1.20 christos wp++;
1411 1.20 christos }
1412 1.20 christos if (*wp)
1413 1.20 christos goto tryagain;
1414 1.20 christos }
1415 1.16 christos if (*wp) {
1416 1.314 rillig SepBuf_AddStr(buf, wp);
1417 1.16 christos }
1418 1.16 christos break;
1419 1.16 christos default:
1420 1.304 rillig VarREError(xrv, &args->re, "Unexpected regex error");
1421 1.242 rillig /* fall through */
1422 1.16 christos case REG_NOMATCH:
1423 1.307 rillig nosub:
1424 1.314 rillig SepBuf_AddStr(buf, wp);
1425 1.16 christos break;
1426 1.16 christos }
1427 1.16 christos }
1428 1.17 christos #endif
1429 1.16 christos
1430 1.16 christos
1431 1.291 rillig typedef struct {
1432 1.295 rillig GNode *ctx;
1433 1.291 rillig char *tvar; /* name of temporary variable */
1434 1.291 rillig char *str; /* string to expand */
1435 1.291 rillig VarEvalFlags eflags;
1436 1.291 rillig } ModifyWord_LoopArgs;
1437 1.291 rillig
1438 1.291 rillig /* Callback for ModifyWords to implement the :@var (at) ...@ modifier of ODE make. */
1439 1.278 rillig static void
1440 1.295 rillig ModifyWord_Loop(const char *word, SepBuf *buf, void *data)
1441 1.40 sjg {
1442 1.412 rillig const ModifyWord_LoopArgs *args;
1443 1.412 rillig char *s;
1444 1.412 rillig
1445 1.278 rillig if (word[0] == '\0')
1446 1.278 rillig return;
1447 1.278 rillig
1448 1.412 rillig args = data;
1449 1.295 rillig Var_Set_with_flags(args->tvar, word, args->ctx, VAR_NO_EXPORT);
1450 1.412 rillig s = Var_Subst(args->str, args->ctx, args->eflags);
1451 1.411 rillig
1452 1.411 rillig VAR_DEBUG("ModifyWord_Loop: in \"%s\", replace \"%s\" with \"%s\" "
1453 1.411 rillig "to \"%s\"\n",
1454 1.411 rillig word, args->tvar, args->str, s ? s : "(null)");
1455 1.64 sjg
1456 1.278 rillig if (s != NULL && s[0] != '\0') {
1457 1.278 rillig if (s[0] == '\n' || (buf->buf.count > 0 &&
1458 1.417 rillig buf->buf.buffer[buf->buf.count - 1] == '\n'))
1459 1.278 rillig buf->needSep = FALSE;
1460 1.314 rillig SepBuf_AddStr(buf, s);
1461 1.40 sjg }
1462 1.278 rillig free(s);
1463 1.40 sjg }
1464 1.40 sjg
1465 1.81 sjg
1466 1.81 sjg /*-
1467 1.291 rillig * Implements the :[first..last] modifier.
1468 1.292 rillig * This is a special case of ModifyWords since we want to be able
1469 1.291 rillig * to scan the list backwards if first > last.
1470 1.81 sjg */
1471 1.81 sjg static char *
1472 1.301 rillig VarSelectWords(Byte sep, Boolean oneBigWord, const char *str, int first,
1473 1.301 rillig int last)
1474 1.81 sjg {
1475 1.412 rillig char **av; /* word list */
1476 1.412 rillig char *as; /* word list memory */
1477 1.412 rillig int ac;
1478 1.412 rillig int start, end, step;
1479 1.412 rillig int i;
1480 1.412 rillig
1481 1.278 rillig SepBuf buf;
1482 1.401 rillig SepBuf_Init(&buf, sep);
1483 1.401 rillig
1484 1.301 rillig if (oneBigWord) {
1485 1.81 sjg /* fake what brk_string() would do if there were only one word */
1486 1.81 sjg ac = 1;
1487 1.242 rillig av = bmake_malloc((ac + 1) * sizeof(char *));
1488 1.134 joerg as = bmake_strdup(str);
1489 1.81 sjg av[0] = as;
1490 1.81 sjg av[1] = NULL;
1491 1.81 sjg } else {
1492 1.81 sjg av = brk_string(str, &ac, FALSE, &as);
1493 1.81 sjg }
1494 1.81 sjg
1495 1.81 sjg /*
1496 1.400 rillig * Now sanitize the given range.
1497 1.400 rillig * If first or last are negative, convert them to the positive equivalents
1498 1.400 rillig * (-1 gets converted to ac, -2 gets converted to (ac - 1), etc.).
1499 1.81 sjg */
1500 1.290 rillig if (first < 0)
1501 1.290 rillig first += ac + 1;
1502 1.290 rillig if (last < 0)
1503 1.290 rillig last += ac + 1;
1504 1.81 sjg
1505 1.81 sjg /*
1506 1.81 sjg * We avoid scanning more of the list than we need to.
1507 1.81 sjg */
1508 1.290 rillig if (first > last) {
1509 1.290 rillig start = MIN(ac, first) - 1;
1510 1.290 rillig end = MAX(0, last - 1);
1511 1.81 sjg step = -1;
1512 1.81 sjg } else {
1513 1.290 rillig start = MAX(0, first - 1);
1514 1.290 rillig end = MIN(ac, last);
1515 1.81 sjg step = 1;
1516 1.81 sjg }
1517 1.81 sjg
1518 1.296 rillig for (i = start; (step < 0) == (i >= end); i += step) {
1519 1.314 rillig SepBuf_AddStr(&buf, av[i]);
1520 1.308 rillig SepBuf_Sep(&buf);
1521 1.81 sjg }
1522 1.81 sjg
1523 1.81 sjg free(as);
1524 1.81 sjg free(av);
1525 1.81 sjg
1526 1.278 rillig return SepBuf_Destroy(&buf, FALSE);
1527 1.81 sjg }
1528 1.81 sjg
1529 1.156 sjg
1530 1.291 rillig /* Callback for ModifyWords to implement the :tA modifier.
1531 1.244 rillig * Replace each word with the result of realpath() if successful. */
1532 1.278 rillig static void
1533 1.295 rillig ModifyWord_Realpath(const char *word, SepBuf *buf, void *data MAKE_ATTR_UNUSED)
1534 1.156 sjg {
1535 1.242 rillig struct stat st;
1536 1.242 rillig char rbuf[MAXPATHLEN];
1537 1.231 rillig
1538 1.314 rillig const char *rp = cached_realpath(word, rbuf);
1539 1.257 rillig if (rp != NULL && *rp == '/' && stat(rp, &st) == 0)
1540 1.242 rillig word = rp;
1541 1.231 rillig
1542 1.314 rillig SepBuf_AddStr(buf, word);
1543 1.156 sjg }
1544 1.156 sjg
1545 1.1 cgd /*-
1546 1.1 cgd *-----------------------------------------------------------------------
1547 1.244 rillig * Modify each of the words of the passed string using the given function.
1548 1.1 cgd *
1549 1.70 wiz * Input:
1550 1.278 rillig * str String whose words should be modified
1551 1.291 rillig * modifyWord Function that modifies a single word
1552 1.291 rillig * data Custom data for modifyWord
1553 1.70 wiz *
1554 1.1 cgd * Results:
1555 1.1 cgd * A string of all the words modified appropriately.
1556 1.1 cgd *-----------------------------------------------------------------------
1557 1.1 cgd */
1558 1.1 cgd static char *
1559 1.301 rillig ModifyWords(GNode *ctx, Byte sep, Boolean oneBigWord,
1560 1.291 rillig const char *str, ModifyWordsCallback modifyWord, void *data)
1561 1.1 cgd {
1562 1.412 rillig SepBuf result;
1563 1.412 rillig char **av; /* word list */
1564 1.412 rillig char *as; /* word list memory */
1565 1.412 rillig int ac;
1566 1.412 rillig int i;
1567 1.412 rillig
1568 1.316 rillig if (oneBigWord) {
1569 1.316 rillig SepBuf_Init(&result, sep);
1570 1.316 rillig modifyWord(str, &result, data);
1571 1.316 rillig return SepBuf_Destroy(&result, FALSE);
1572 1.316 rillig }
1573 1.316 rillig
1574 1.401 rillig SepBuf_Init(&result, sep);
1575 1.401 rillig
1576 1.316 rillig av = brk_string(str, &ac, FALSE, &as);
1577 1.1 cgd
1578 1.411 rillig VAR_DEBUG("ModifyWords: split \"%s\" into %d words\n", str, ac);
1579 1.255 rillig
1580 1.278 rillig for (i = 0; i < ac; i++) {
1581 1.295 rillig modifyWord(av[i], &result, data);
1582 1.382 rillig if (result.buf.count > 0)
1583 1.278 rillig SepBuf_Sep(&result);
1584 1.278 rillig }
1585 1.24 christos
1586 1.24 christos free(as);
1587 1.24 christos free(av);
1588 1.15 christos
1589 1.278 rillig return SepBuf_Destroy(&result, FALSE);
1590 1.1 cgd }
1591 1.1 cgd
1592 1.35 christos
1593 1.403 rillig static char *
1594 1.403 rillig WordList_JoinFree(char **av, int ac, char *as)
1595 1.403 rillig {
1596 1.403 rillig Buffer buf;
1597 1.412 rillig int i;
1598 1.412 rillig
1599 1.433 rillig Buf_Init(&buf, 0);
1600 1.403 rillig
1601 1.403 rillig for (i = 0; i < ac; i++) {
1602 1.403 rillig if (i != 0)
1603 1.403 rillig Buf_AddByte(&buf, ' ');
1604 1.403 rillig Buf_AddStr(&buf, av[i]);
1605 1.403 rillig }
1606 1.403 rillig
1607 1.403 rillig free(av);
1608 1.403 rillig free(as);
1609 1.403 rillig
1610 1.403 rillig return Buf_Destroy(&buf, FALSE);
1611 1.403 rillig }
1612 1.403 rillig
1613 1.319 rillig /* Remove adjacent duplicate words. */
1614 1.55 christos static char *
1615 1.73 christos VarUniq(const char *str)
1616 1.55 christos {
1617 1.401 rillig char *as; /* Word list memory */
1618 1.401 rillig int ac;
1619 1.401 rillig char **av = brk_string(str, &ac, FALSE, &as);
1620 1.55 christos
1621 1.55 christos if (ac > 1) {
1622 1.401 rillig int i, j;
1623 1.55 christos for (j = 0, i = 1; i < ac; i++)
1624 1.55 christos if (strcmp(av[i], av[j]) != 0 && (++j != i))
1625 1.55 christos av[j] = av[i];
1626 1.55 christos ac = j + 1;
1627 1.55 christos }
1628 1.55 christos
1629 1.403 rillig return WordList_JoinFree(av, ac, as);
1630 1.55 christos }
1631 1.55 christos
1632 1.55 christos
1633 1.55 christos /*-
1634 1.265 rillig * Parse a text part of a modifier such as the "from" and "to" in :S/from/to/
1635 1.324 rillig * or the :@ modifier, until the next unescaped delimiter. The delimiter, as
1636 1.324 rillig * well as the backslash or the dollar, can be escaped with a backslash.
1637 1.265 rillig *
1638 1.324 rillig * Return the parsed (and possibly expanded) string, or NULL if no delimiter
1639 1.409 rillig * was found. On successful return, the parsing position pp points right
1640 1.409 rillig * after the delimiter. The delimiter is not included in the returned
1641 1.409 rillig * value though.
1642 1.16 christos */
1643 1.16 christos static char *
1644 1.390 rillig ParseModifierPart(
1645 1.392 rillig const char **pp, /* The parsing position, updated upon return */
1646 1.390 rillig int delim, /* Parsing stops at this delimiter */
1647 1.390 rillig VarEvalFlags eflags, /* Flags for evaluating nested variables;
1648 1.390 rillig * if VARE_WANTRES is not set, the text is
1649 1.390 rillig * only parsed */
1650 1.390 rillig GNode *ctxt, /* For looking up nested variables */
1651 1.390 rillig size_t *out_length, /* Optionally stores the length of the returned
1652 1.390 rillig * string, just to save another strlen call. */
1653 1.390 rillig VarPatternFlags *out_pflags,/* For the first part of the :S modifier,
1654 1.390 rillig * sets the VARP_ANCHOR_END flag if the last
1655 1.390 rillig * character of the pattern is a $. */
1656 1.390 rillig ModifyWord_SubstArgs *subst /* For the second part of the :S modifier,
1657 1.390 rillig * allow ampersands to be escaped and replace
1658 1.390 rillig * unescaped ampersands with subst->lhs. */
1659 1.390 rillig ) {
1660 1.146 dsl Buffer buf;
1661 1.412 rillig const char *p;
1662 1.412 rillig char *rstr;
1663 1.412 rillig
1664 1.433 rillig Buf_Init(&buf, 0);
1665 1.16 christos
1666 1.16 christos /*
1667 1.16 christos * Skim through until the matching delimiter is found;
1668 1.16 christos * pick up variable substitutions on the way. Also allow
1669 1.16 christos * backslashes to quote the delimiter, $, and \, but don't
1670 1.16 christos * touch other backslashes.
1671 1.16 christos */
1672 1.412 rillig p = *pp;
1673 1.394 rillig while (*p != '\0' && *p != delim) {
1674 1.412 rillig const char *varstart;
1675 1.412 rillig
1676 1.392 rillig Boolean is_escaped = p[0] == '\\' && (
1677 1.392 rillig p[1] == delim || p[1] == '\\' || p[1] == '$' ||
1678 1.392 rillig (p[1] == '&' && subst != NULL));
1679 1.263 rillig if (is_escaped) {
1680 1.392 rillig Buf_AddByte(&buf, p[1]);
1681 1.394 rillig p += 2;
1682 1.391 rillig continue;
1683 1.391 rillig }
1684 1.391 rillig
1685 1.392 rillig if (*p != '$') { /* Unescaped, simple text */
1686 1.392 rillig if (subst != NULL && *p == '&')
1687 1.433 rillig Buf_AddBytes(&buf, subst->lhs, subst->lhsLen);
1688 1.391 rillig else
1689 1.392 rillig Buf_AddByte(&buf, *p);
1690 1.394 rillig p++;
1691 1.391 rillig continue;
1692 1.391 rillig }
1693 1.391 rillig
1694 1.392 rillig if (p[1] == delim) { /* Unescaped $ at end of pattern */
1695 1.391 rillig if (out_pflags != NULL)
1696 1.391 rillig *out_pflags |= VARP_ANCHOR_END;
1697 1.391 rillig else
1698 1.392 rillig Buf_AddByte(&buf, *p);
1699 1.394 rillig p++;
1700 1.391 rillig continue;
1701 1.391 rillig }
1702 1.391 rillig
1703 1.391 rillig if (eflags & VARE_WANTRES) { /* Nested variable, evaluated */
1704 1.391 rillig const char *cp2;
1705 1.417 rillig int len;
1706 1.417 rillig void *freeIt;
1707 1.40 sjg
1708 1.395 rillig cp2 = Var_Parse(p, ctxt, eflags & ~VARE_ASSIGN, &len, &freeIt);
1709 1.391 rillig Buf_AddStr(&buf, cp2);
1710 1.391 rillig free(freeIt);
1711 1.394 rillig p += len;
1712 1.391 rillig continue;
1713 1.391 rillig }
1714 1.16 christos
1715 1.396 rillig /* XXX: This whole block is very similar to Var_Parse without
1716 1.396 rillig * VARE_WANTRES. There may be subtle edge cases though that are
1717 1.396 rillig * not yet covered in the unit tests and that are parsed differently,
1718 1.396 rillig * depending on whether they are evaluated or not.
1719 1.396 rillig *
1720 1.396 rillig * This subtle difference is not documented in the manual page,
1721 1.396 rillig * neither is the difference between parsing :D and :M documented.
1722 1.396 rillig * No code should ever depend on these details, but who knows. */
1723 1.396 rillig
1724 1.412 rillig varstart = p; /* Nested variable, only parsed */
1725 1.393 rillig if (p[1] == PROPEN || p[1] == BROPEN) {
1726 1.391 rillig /*
1727 1.391 rillig * Find the end of this variable reference
1728 1.391 rillig * and suck it in without further ado.
1729 1.391 rillig * It will be interpreted later.
1730 1.391 rillig */
1731 1.393 rillig int have = p[1];
1732 1.393 rillig int want = have == PROPEN ? PRCLOSE : BRCLOSE;
1733 1.391 rillig int depth = 1;
1734 1.391 rillig
1735 1.426 rillig for (p += 2; *p != '\0' && depth > 0; p++) {
1736 1.393 rillig if (p[-1] != '\\') {
1737 1.393 rillig if (*p == have)
1738 1.426 rillig depth++;
1739 1.393 rillig if (*p == want)
1740 1.426 rillig depth--;
1741 1.40 sjg }
1742 1.16 christos }
1743 1.393 rillig Buf_AddBytesBetween(&buf, varstart, p);
1744 1.394 rillig } else {
1745 1.393 rillig Buf_AddByte(&buf, *varstart);
1746 1.394 rillig p++;
1747 1.394 rillig }
1748 1.16 christos }
1749 1.16 christos
1750 1.392 rillig if (*p != delim) {
1751 1.392 rillig *pp = p;
1752 1.16 christos return NULL;
1753 1.16 christos }
1754 1.146 dsl
1755 1.392 rillig *pp = ++p;
1756 1.320 rillig if (out_length != NULL)
1757 1.320 rillig *out_length = Buf_Size(&buf);
1758 1.396 rillig
1759 1.412 rillig rstr = Buf_Destroy(&buf, FALSE);
1760 1.411 rillig VAR_DEBUG("Modifier part: \"%s\"\n", rstr);
1761 1.146 dsl return rstr;
1762 1.16 christos }
1763 1.16 christos
1764 1.16 christos /*-
1765 1.16 christos *-----------------------------------------------------------------------
1766 1.16 christos * VarQuote --
1767 1.194 mlelstv * Quote shell meta-characters and space characters in the string
1768 1.220 christos * if quoteDollar is set, also quote and double any '$' characters.
1769 1.16 christos *
1770 1.16 christos * Results:
1771 1.16 christos * The quoted string
1772 1.16 christos *
1773 1.16 christos * Side Effects:
1774 1.16 christos * None.
1775 1.16 christos *
1776 1.16 christos *-----------------------------------------------------------------------
1777 1.16 christos */
1778 1.16 christos static char *
1779 1.220 christos VarQuote(char *str, Boolean quoteDollar)
1780 1.16 christos {
1781 1.293 rillig Buffer buf;
1782 1.433 rillig Buf_Init(&buf, 0);
1783 1.193 christos
1784 1.193 christos for (; *str != '\0'; str++) {
1785 1.193 christos if (*str == '\n') {
1786 1.293 rillig const char *newline = Shell_GetNewline();
1787 1.293 rillig if (newline == NULL)
1788 1.293 rillig newline = "\\\n";
1789 1.313 rillig Buf_AddStr(&buf, newline);
1790 1.193 christos continue;
1791 1.193 christos }
1792 1.195 christos if (isspace((unsigned char)*str) || ismeta((unsigned char)*str))
1793 1.146 dsl Buf_AddByte(&buf, '\\');
1794 1.193 christos Buf_AddByte(&buf, *str);
1795 1.220 christos if (quoteDollar && *str == '$')
1796 1.313 rillig Buf_AddStr(&buf, "\\$");
1797 1.16 christos }
1798 1.193 christos
1799 1.146 dsl str = Buf_Destroy(&buf, FALSE);
1800 1.411 rillig VAR_DEBUG("QuoteMeta: [%s]\n", str);
1801 1.16 christos return str;
1802 1.16 christos }
1803 1.16 christos
1804 1.400 rillig /* Compute the 32-bit hash of the given string, using the MurmurHash3
1805 1.400 rillig * algorithm. Output is encoded as 8 hex digits, in Little Endian order. */
1806 1.163 joerg static char *
1807 1.252 rillig VarHash(const char *str)
1808 1.163 joerg {
1809 1.163 joerg static const char hexdigits[16] = "0123456789abcdef";
1810 1.252 rillig const unsigned char *ustr = (const unsigned char *)str;
1811 1.163 joerg
1812 1.401 rillig uint32_t h = 0x971e137bU;
1813 1.401 rillig uint32_t c1 = 0x95543787U;
1814 1.401 rillig uint32_t c2 = 0x2ad7eb25U;
1815 1.401 rillig size_t len2 = strlen(str);
1816 1.163 joerg
1817 1.412 rillig char *buf;
1818 1.412 rillig size_t i;
1819 1.412 rillig
1820 1.401 rillig size_t len;
1821 1.163 joerg for (len = len2; len; ) {
1822 1.401 rillig uint32_t k = 0;
1823 1.163 joerg switch (len) {
1824 1.163 joerg default:
1825 1.252 rillig k = ((uint32_t)ustr[3] << 24) |
1826 1.252 rillig ((uint32_t)ustr[2] << 16) |
1827 1.252 rillig ((uint32_t)ustr[1] << 8) |
1828 1.252 rillig (uint32_t)ustr[0];
1829 1.163 joerg len -= 4;
1830 1.163 joerg ustr += 4;
1831 1.163 joerg break;
1832 1.163 joerg case 3:
1833 1.252 rillig k |= (uint32_t)ustr[2] << 16;
1834 1.222 mrg /* FALLTHROUGH */
1835 1.163 joerg case 2:
1836 1.252 rillig k |= (uint32_t)ustr[1] << 8;
1837 1.222 mrg /* FALLTHROUGH */
1838 1.163 joerg case 1:
1839 1.252 rillig k |= (uint32_t)ustr[0];
1840 1.163 joerg len = 0;
1841 1.163 joerg }
1842 1.163 joerg c1 = c1 * 5 + 0x7b7d159cU;
1843 1.163 joerg c2 = c2 * 5 + 0x6bce6396U;
1844 1.163 joerg k *= c1;
1845 1.163 joerg k = (k << 11) ^ (k >> 21);
1846 1.163 joerg k *= c2;
1847 1.163 joerg h = (h << 13) ^ (h >> 19);
1848 1.163 joerg h = h * 5 + 0x52dce729U;
1849 1.163 joerg h ^= k;
1850 1.242 rillig }
1851 1.242 rillig h ^= len2;
1852 1.242 rillig h *= 0x85ebca6b;
1853 1.242 rillig h ^= h >> 13;
1854 1.242 rillig h *= 0xc2b2ae35;
1855 1.242 rillig h ^= h >> 16;
1856 1.242 rillig
1857 1.412 rillig buf = bmake_malloc(9);
1858 1.405 rillig for (i = 0; i < 8; i++) {
1859 1.405 rillig buf[i] = hexdigits[h & 0x0f];
1860 1.242 rillig h >>= 4;
1861 1.249 rillig }
1862 1.405 rillig buf[8] = '\0';
1863 1.405 rillig return buf;
1864 1.163 joerg }
1865 1.163 joerg
1866 1.164 sjg static char *
1867 1.425 rillig VarStrftime(const char *fmt, Boolean zulu, time_t tim)
1868 1.164 sjg {
1869 1.164 sjg char buf[BUFSIZ];
1870 1.164 sjg
1871 1.425 rillig if (!tim)
1872 1.425 rillig time(&tim);
1873 1.164 sjg if (!*fmt)
1874 1.164 sjg fmt = "%c";
1875 1.425 rillig strftime(buf, sizeof(buf), fmt, zulu ? gmtime(&tim) : localtime(&tim));
1876 1.235 rillig
1877 1.164 sjg buf[sizeof(buf) - 1] = '\0';
1878 1.164 sjg return bmake_strdup(buf);
1879 1.164 sjg }
1880 1.164 sjg
1881 1.409 rillig /* The ApplyModifier functions all work in the same way. They get the
1882 1.409 rillig * current parsing position (pp) and parse the modifier from there. The
1883 1.409 rillig * modifier typically lasts until the next ':', or a closing '}', ')'
1884 1.409 rillig * (taken from st->endc), or the end of the string (parse error).
1885 1.409 rillig *
1886 1.409 rillig * After parsing, no matter whether successful or not, they set the parsing
1887 1.409 rillig * position to the character after the modifier, or in case of parse errors,
1888 1.409 rillig * just increment the parsing position. (That's how it is right now, it
1889 1.409 rillig * shouldn't hurt to keep the parsing position as-is in case of parse errors.)
1890 1.409 rillig *
1891 1.409 rillig * On success, an ApplyModifier function:
1892 1.409 rillig * * sets the parsing position *pp to the first character following the
1893 1.409 rillig * current modifier
1894 1.409 rillig * * processes the current variable value from st->val to produce the
1895 1.409 rillig * modified variable value and stores it in st->newVal
1896 1.409 rillig * * returns AMR_OK
1897 1.409 rillig *
1898 1.409 rillig * On parse errors, an ApplyModifier function:
1899 1.409 rillig * * either issues a custom error message and then returns AMR_CLEANUP
1900 1.409 rillig * * or returns AMR_BAD to issue the standard "Bad modifier" error message
1901 1.409 rillig * In both of these cases, it updates the parsing position.
1902 1.409 rillig * Modifiers that use ParseModifierPart typically set st->missing_delim
1903 1.409 rillig * and then return AMR_CLEANUP to issue the standard error message.
1904 1.409 rillig *
1905 1.409 rillig * If the expected modifier was not found, several modifiers return AMR_UNKNOWN
1906 1.409 rillig * to fall back to the SysV modifier ${VAR:from=to}. This is especially
1907 1.409 rillig * useful for newly added long-name modifiers, to avoid breaking any existing
1908 1.409 rillig * code. In such a case the parsing position must not be changed.
1909 1.350 rillig */
1910 1.409 rillig
1911 1.236 rillig typedef struct {
1912 1.368 rillig const int startc; /* '\0' or '{' or '(' */
1913 1.368 rillig const int endc;
1914 1.368 rillig Var * const v;
1915 1.368 rillig GNode * const ctxt;
1916 1.368 rillig const VarEvalFlags eflags;
1917 1.236 rillig
1918 1.350 rillig char *val; /* The value of the expression before the
1919 1.350 rillig * modifier is applied */
1920 1.350 rillig char *newVal; /* The new value after applying the modifier
1921 1.350 rillig * to the expression */
1922 1.298 rillig char missing_delim; /* For error reporting */
1923 1.301 rillig
1924 1.400 rillig Byte sep; /* Word separator in expansions */
1925 1.400 rillig Boolean oneBigWord; /* TRUE if the variable value is treated as a
1926 1.301 rillig * single big word, even if it contains
1927 1.301 rillig * embedded spaces (as opposed to the
1928 1.301 rillig * usual behaviour of treating it as
1929 1.301 rillig * several space-separated words). */
1930 1.236 rillig } ApplyModifiersState;
1931 1.236 rillig
1932 1.356 rillig typedef enum {
1933 1.356 rillig AMR_OK, /* Continue parsing */
1934 1.400 rillig AMR_UNKNOWN, /* Not a match, try other modifiers as well */
1935 1.400 rillig AMR_BAD, /* Error out with "Bad modifier" message */
1936 1.428 rillig AMR_CLEANUP /* Error out, with "Unfinished modifier"
1937 1.356 rillig * if st->missing_delim is set. */
1938 1.356 rillig } ApplyModifierResult;
1939 1.356 rillig
1940 1.400 rillig /* Test whether mod starts with modname, followed by a delimiter. */
1941 1.340 rillig static Boolean
1942 1.340 rillig ModMatch(const char *mod, const char *modname, char endc)
1943 1.340 rillig {
1944 1.340 rillig size_t n = strlen(modname);
1945 1.340 rillig return strncmp(mod, modname, n) == 0 &&
1946 1.340 rillig (mod[n] == endc || mod[n] == ':');
1947 1.340 rillig }
1948 1.340 rillig
1949 1.400 rillig /* Test whether mod starts with modname, followed by a delimiter or '='. */
1950 1.340 rillig static inline Boolean
1951 1.340 rillig ModMatchEq(const char *mod, const char *modname, char endc)
1952 1.340 rillig {
1953 1.340 rillig size_t n = strlen(modname);
1954 1.340 rillig return strncmp(mod, modname, n) == 0 &&
1955 1.340 rillig (mod[n] == endc || mod[n] == ':' || mod[n] == '=');
1956 1.340 rillig }
1957 1.236 rillig
1958 1.236 rillig /* :@var (at) ...${var}...@ */
1959 1.356 rillig static ApplyModifierResult
1960 1.417 rillig ApplyModifier_Loop(const char **pp, ApplyModifiersState *st)
1961 1.417 rillig {
1962 1.291 rillig ModifyWord_LoopArgs args;
1963 1.412 rillig char delim;
1964 1.412 rillig int prev_sep;
1965 1.236 rillig
1966 1.295 rillig args.ctx = st->ctxt;
1967 1.409 rillig
1968 1.409 rillig (*pp)++; /* Skip the first '@' */
1969 1.412 rillig delim = '@';
1970 1.409 rillig args.tvar = ParseModifierPart(pp, delim, st->eflags & ~VARE_WANTRES,
1971 1.324 rillig st->ctxt, NULL, NULL, NULL);
1972 1.298 rillig if (args.tvar == NULL) {
1973 1.298 rillig st->missing_delim = delim;
1974 1.356 rillig return AMR_CLEANUP;
1975 1.298 rillig }
1976 1.410 rillig if (DEBUG(LINT) && strchr(args.tvar, '$') != NULL) {
1977 1.410 rillig Parse_Error(PARSE_FATAL,
1978 1.410 rillig "In the :@ modifier of \"%s\", the variable name \"%s\" "
1979 1.410 rillig "must not contain a dollar.",
1980 1.410 rillig st->v->name, args.tvar);
1981 1.417 rillig return AMR_CLEANUP;
1982 1.410 rillig }
1983 1.236 rillig
1984 1.409 rillig args.str = ParseModifierPart(pp, delim, st->eflags & ~VARE_WANTRES,
1985 1.324 rillig st->ctxt, NULL, NULL, NULL);
1986 1.298 rillig if (args.str == NULL) {
1987 1.298 rillig st->missing_delim = delim;
1988 1.356 rillig return AMR_CLEANUP;
1989 1.298 rillig }
1990 1.236 rillig
1991 1.291 rillig args.eflags = st->eflags & (VARE_UNDEFERR | VARE_WANTRES);
1992 1.412 rillig prev_sep = st->sep;
1993 1.409 rillig st->sep = ' '; /* XXX: should be st->sep for consistency */
1994 1.349 rillig st->newVal = ModifyWords(st->ctxt, st->sep, st->oneBigWord, st->val,
1995 1.291 rillig ModifyWord_Loop, &args);
1996 1.301 rillig st->sep = prev_sep;
1997 1.291 rillig Var_Delete(args.tvar, st->ctxt);
1998 1.291 rillig free(args.tvar);
1999 1.291 rillig free(args.str);
2000 1.356 rillig return AMR_OK;
2001 1.236 rillig }
2002 1.236 rillig
2003 1.236 rillig /* :Ddefined or :Uundefined */
2004 1.356 rillig static ApplyModifierResult
2005 1.409 rillig ApplyModifier_Defined(const char **pp, ApplyModifiersState *st)
2006 1.236 rillig {
2007 1.412 rillig Buffer buf; /* Buffer for patterns */
2008 1.412 rillig const char *p;
2009 1.412 rillig
2010 1.415 rillig VarEvalFlags eflags = st->eflags & ~VARE_WANTRES;
2011 1.268 rillig if (st->eflags & VARE_WANTRES) {
2012 1.415 rillig if ((**pp == 'D') == !(st->v->flags & VAR_JUNK))
2013 1.415 rillig eflags |= VARE_WANTRES;
2014 1.415 rillig }
2015 1.236 rillig
2016 1.236 rillig /*
2017 1.302 rillig * Pass through mod looking for 1) escaped delimiters,
2018 1.236 rillig * '$'s and backslashes (place the escaped character in
2019 1.236 rillig * uninterpreted) and 2) unescaped $'s that aren't before
2020 1.236 rillig * the delimiter (expand the variable substitution).
2021 1.236 rillig * The result is left in the Buffer buf.
2022 1.236 rillig */
2023 1.433 rillig Buf_Init(&buf, 0);
2024 1.412 rillig p = *pp + 1;
2025 1.339 rillig while (*p != st->endc && *p != ':' && *p != '\0') {
2026 1.339 rillig if (*p == '\\' &&
2027 1.339 rillig (p[1] == ':' || p[1] == '$' || p[1] == st->endc || p[1] == '\\')) {
2028 1.339 rillig Buf_AddByte(&buf, p[1]);
2029 1.339 rillig p += 2;
2030 1.339 rillig } else if (*p == '$') {
2031 1.236 rillig /*
2032 1.236 rillig * If unescaped dollar sign, assume it's a
2033 1.236 rillig * variable substitution and recurse.
2034 1.236 rillig */
2035 1.331 rillig const char *cp2;
2036 1.417 rillig int len;
2037 1.417 rillig void *freeIt;
2038 1.236 rillig
2039 1.415 rillig cp2 = Var_Parse(p, st->ctxt, eflags, &len, &freeIt);
2040 1.313 rillig Buf_AddStr(&buf, cp2);
2041 1.236 rillig free(freeIt);
2042 1.339 rillig p += len;
2043 1.236 rillig } else {
2044 1.339 rillig Buf_AddByte(&buf, *p);
2045 1.339 rillig p++;
2046 1.236 rillig }
2047 1.236 rillig }
2048 1.409 rillig *pp = p;
2049 1.236 rillig
2050 1.257 rillig if (st->v->flags & VAR_JUNK)
2051 1.236 rillig st->v->flags |= VAR_KEEP;
2052 1.415 rillig if (eflags & VARE_WANTRES) {
2053 1.349 rillig st->newVal = Buf_Destroy(&buf, FALSE);
2054 1.236 rillig } else {
2055 1.349 rillig st->newVal = st->val;
2056 1.236 rillig Buf_Destroy(&buf, TRUE);
2057 1.236 rillig }
2058 1.356 rillig return AMR_OK;
2059 1.236 rillig }
2060 1.236 rillig
2061 1.236 rillig /* :gmtime */
2062 1.356 rillig static ApplyModifierResult
2063 1.409 rillig ApplyModifier_Gmtime(const char **pp, ApplyModifiersState *st)
2064 1.236 rillig {
2065 1.412 rillig time_t utc;
2066 1.412 rillig
2067 1.409 rillig const char *mod = *pp;
2068 1.358 rillig if (!ModMatchEq(mod, "gmtime", st->endc))
2069 1.356 rillig return AMR_UNKNOWN;
2070 1.340 rillig
2071 1.299 rillig if (mod[6] == '=') {
2072 1.340 rillig char *ep;
2073 1.299 rillig utc = strtoul(mod + 7, &ep, 10);
2074 1.409 rillig *pp = ep;
2075 1.236 rillig } else {
2076 1.236 rillig utc = 0;
2077 1.409 rillig *pp = mod + 6;
2078 1.236 rillig }
2079 1.425 rillig st->newVal = VarStrftime(st->val, TRUE, utc);
2080 1.356 rillig return AMR_OK;
2081 1.236 rillig }
2082 1.236 rillig
2083 1.236 rillig /* :localtime */
2084 1.236 rillig static Boolean
2085 1.409 rillig ApplyModifier_Localtime(const char **pp, ApplyModifiersState *st)
2086 1.236 rillig {
2087 1.412 rillig time_t utc;
2088 1.412 rillig
2089 1.409 rillig const char *mod = *pp;
2090 1.358 rillig if (!ModMatchEq(mod, "localtime", st->endc))
2091 1.356 rillig return AMR_UNKNOWN;
2092 1.236 rillig
2093 1.299 rillig if (mod[9] == '=') {
2094 1.340 rillig char *ep;
2095 1.299 rillig utc = strtoul(mod + 10, &ep, 10);
2096 1.409 rillig *pp = ep;
2097 1.236 rillig } else {
2098 1.236 rillig utc = 0;
2099 1.409 rillig *pp = mod + 9;
2100 1.236 rillig }
2101 1.425 rillig st->newVal = VarStrftime(st->val, FALSE, utc);
2102 1.356 rillig return AMR_OK;
2103 1.236 rillig }
2104 1.236 rillig
2105 1.236 rillig /* :hash */
2106 1.356 rillig static ApplyModifierResult
2107 1.409 rillig ApplyModifier_Hash(const char **pp, ApplyModifiersState *st)
2108 1.236 rillig {
2109 1.409 rillig if (!ModMatch(*pp, "hash", st->endc))
2110 1.356 rillig return AMR_UNKNOWN;
2111 1.340 rillig
2112 1.349 rillig st->newVal = VarHash(st->val);
2113 1.409 rillig *pp += 4;
2114 1.356 rillig return AMR_OK;
2115 1.236 rillig }
2116 1.236 rillig
2117 1.236 rillig /* :P */
2118 1.356 rillig static ApplyModifierResult
2119 1.409 rillig ApplyModifier_Path(const char **pp, ApplyModifiersState *st)
2120 1.236 rillig {
2121 1.412 rillig GNode *gn;
2122 1.412 rillig
2123 1.333 rillig if (st->v->flags & VAR_JUNK)
2124 1.236 rillig st->v->flags |= VAR_KEEP;
2125 1.409 rillig
2126 1.412 rillig gn = Targ_FindNode(st->v->name, TARG_NOCREATE);
2127 1.236 rillig if (gn == NULL || gn->type & OP_NOPATH) {
2128 1.349 rillig st->newVal = NULL;
2129 1.236 rillig } else if (gn->path) {
2130 1.349 rillig st->newVal = bmake_strdup(gn->path);
2131 1.236 rillig } else {
2132 1.349 rillig st->newVal = Dir_FindFile(st->v->name, Suff_FindPath(gn));
2133 1.236 rillig }
2134 1.406 rillig if (st->newVal == NULL)
2135 1.349 rillig st->newVal = bmake_strdup(st->v->name);
2136 1.409 rillig
2137 1.409 rillig (*pp)++;
2138 1.356 rillig return AMR_OK;
2139 1.236 rillig }
2140 1.236 rillig
2141 1.236 rillig /* :!cmd! */
2142 1.356 rillig static ApplyModifierResult
2143 1.409 rillig ApplyModifier_Exclam(const char **pp, ApplyModifiersState *st)
2144 1.236 rillig {
2145 1.412 rillig char delim;
2146 1.412 rillig char *cmd;
2147 1.416 rillig const char *errfmt;
2148 1.412 rillig
2149 1.409 rillig (*pp)++;
2150 1.412 rillig delim = '!';
2151 1.412 rillig cmd = ParseModifierPart(pp, delim, st->eflags, st->ctxt,
2152 1.412 rillig NULL, NULL, NULL);
2153 1.298 rillig if (cmd == NULL) {
2154 1.298 rillig st->missing_delim = delim;
2155 1.356 rillig return AMR_CLEANUP;
2156 1.298 rillig }
2157 1.274 rillig
2158 1.416 rillig errfmt = NULL;
2159 1.268 rillig if (st->eflags & VARE_WANTRES)
2160 1.416 rillig st->newVal = Cmd_Exec(cmd, &errfmt);
2161 1.236 rillig else
2162 1.349 rillig st->newVal = varNoError;
2163 1.274 rillig free(cmd);
2164 1.274 rillig
2165 1.416 rillig if (errfmt != NULL)
2166 1.416 rillig Error(errfmt, st->val); /* XXX: why still return AMR_OK? */
2167 1.274 rillig
2168 1.236 rillig if (st->v->flags & VAR_JUNK)
2169 1.236 rillig st->v->flags |= VAR_KEEP;
2170 1.356 rillig return AMR_OK;
2171 1.236 rillig }
2172 1.236 rillig
2173 1.386 rillig /* The :range modifier generates an integer sequence as long as the words.
2174 1.386 rillig * The :range=7 modifier generates an integer sequence from 1 to 7. */
2175 1.356 rillig static ApplyModifierResult
2176 1.409 rillig ApplyModifier_Range(const char **pp, ApplyModifiersState *st)
2177 1.236 rillig {
2178 1.412 rillig int n;
2179 1.412 rillig Buffer buf;
2180 1.412 rillig int i;
2181 1.412 rillig
2182 1.409 rillig const char *mod = *pp;
2183 1.358 rillig if (!ModMatchEq(mod, "range", st->endc))
2184 1.356 rillig return AMR_UNKNOWN;
2185 1.236 rillig
2186 1.299 rillig if (mod[5] == '=') {
2187 1.340 rillig char *ep;
2188 1.299 rillig n = strtoul(mod + 6, &ep, 10);
2189 1.409 rillig *pp = ep;
2190 1.236 rillig } else {
2191 1.236 rillig n = 0;
2192 1.409 rillig *pp = mod + 5;
2193 1.236 rillig }
2194 1.386 rillig
2195 1.386 rillig if (n == 0) {
2196 1.386 rillig char *as;
2197 1.386 rillig char **av = brk_string(st->val, &n, FALSE, &as);
2198 1.386 rillig free(as);
2199 1.386 rillig free(av);
2200 1.386 rillig }
2201 1.386 rillig
2202 1.433 rillig Buf_Init(&buf, 0);
2203 1.386 rillig
2204 1.386 rillig for (i = 0; i < n; i++) {
2205 1.386 rillig if (i != 0)
2206 1.386 rillig Buf_AddByte(&buf, ' ');
2207 1.386 rillig Buf_AddInt(&buf, 1 + i);
2208 1.386 rillig }
2209 1.386 rillig
2210 1.386 rillig st->newVal = Buf_Destroy(&buf, FALSE);
2211 1.356 rillig return AMR_OK;
2212 1.236 rillig }
2213 1.236 rillig
2214 1.236 rillig /* :Mpattern or :Npattern */
2215 1.356 rillig static ApplyModifierResult
2216 1.409 rillig ApplyModifier_Match(const char **pp, ApplyModifiersState *st)
2217 1.236 rillig {
2218 1.409 rillig const char *mod = *pp;
2219 1.288 rillig Boolean copy = FALSE; /* pattern should be, or has been, copied */
2220 1.288 rillig Boolean needSubst = FALSE;
2221 1.412 rillig const char *endpat;
2222 1.412 rillig char *pattern;
2223 1.412 rillig ModifyWordsCallback callback;
2224 1.412 rillig
2225 1.236 rillig /*
2226 1.288 rillig * In the loop below, ignore ':' unless we are at (or back to) the
2227 1.288 rillig * original brace level.
2228 1.288 rillig * XXX This will likely not work right if $() and ${} are intermixed.
2229 1.236 rillig */
2230 1.387 rillig int nest = 0;
2231 1.347 rillig const char *p;
2232 1.387 rillig for (p = mod + 1; *p != '\0' && !(*p == ':' && nest == 0); p++) {
2233 1.347 rillig if (*p == '\\' &&
2234 1.347 rillig (p[1] == ':' || p[1] == st->endc || p[1] == st->startc)) {
2235 1.236 rillig if (!needSubst)
2236 1.236 rillig copy = TRUE;
2237 1.347 rillig p++;
2238 1.236 rillig continue;
2239 1.236 rillig }
2240 1.347 rillig if (*p == '$')
2241 1.236 rillig needSubst = TRUE;
2242 1.347 rillig if (*p == '(' || *p == '{')
2243 1.426 rillig nest++;
2244 1.347 rillig if (*p == ')' || *p == '}') {
2245 1.426 rillig nest--;
2246 1.387 rillig if (nest < 0)
2247 1.236 rillig break;
2248 1.236 rillig }
2249 1.236 rillig }
2250 1.409 rillig *pp = p;
2251 1.412 rillig endpat = p;
2252 1.288 rillig
2253 1.236 rillig if (copy) {
2254 1.417 rillig char *dst;
2255 1.417 rillig const char *src;
2256 1.412 rillig
2257 1.345 rillig /* Compress the \:'s out of the pattern. */
2258 1.347 rillig pattern = bmake_malloc(endpat - (mod + 1) + 1);
2259 1.412 rillig dst = pattern;
2260 1.412 rillig src = mod + 1;
2261 1.346 rillig for (; src < endpat; src++, dst++) {
2262 1.346 rillig if (src[0] == '\\' && src + 1 < endpat &&
2263 1.345 rillig /* XXX: st->startc is missing here; see above */
2264 1.346 rillig (src[1] == ':' || src[1] == st->endc))
2265 1.346 rillig src++;
2266 1.346 rillig *dst = *src;
2267 1.236 rillig }
2268 1.346 rillig *dst = '\0';
2269 1.346 rillig endpat = dst;
2270 1.236 rillig } else {
2271 1.236 rillig /*
2272 1.292 rillig * Either Var_Subst or ModifyWords will need a
2273 1.236 rillig * nul-terminated string soon, so construct one now.
2274 1.236 rillig */
2275 1.299 rillig pattern = bmake_strndup(mod + 1, endpat - (mod + 1));
2276 1.236 rillig }
2277 1.346 rillig
2278 1.236 rillig if (needSubst) {
2279 1.236 rillig /* pattern contains embedded '$', so use Var_Subst to expand it. */
2280 1.288 rillig char *old_pattern = pattern;
2281 1.352 rillig pattern = Var_Subst(pattern, st->ctxt, st->eflags);
2282 1.288 rillig free(old_pattern);
2283 1.236 rillig }
2284 1.346 rillig
2285 1.411 rillig VAR_DEBUG("Pattern[%s] for [%s] is [%s]\n", st->v->name, st->val, pattern);
2286 1.346 rillig
2287 1.412 rillig callback = mod[0] == 'M' ? ModifyWord_Match : ModifyWord_NoMatch;
2288 1.349 rillig st->newVal = ModifyWords(st->ctxt, st->sep, st->oneBigWord, st->val,
2289 1.291 rillig callback, pattern);
2290 1.236 rillig free(pattern);
2291 1.356 rillig return AMR_OK;
2292 1.236 rillig }
2293 1.236 rillig
2294 1.236 rillig /* :S,from,to, */
2295 1.356 rillig static ApplyModifierResult
2296 1.409 rillig ApplyModifier_Subst(const char **pp, ApplyModifiersState *st)
2297 1.236 rillig {
2298 1.412 rillig ModifyWord_SubstArgs args;
2299 1.412 rillig char *lhs, *rhs;
2300 1.412 rillig Boolean oneBigWord;
2301 1.412 rillig
2302 1.409 rillig char delim = (*pp)[1];
2303 1.359 rillig if (delim == '\0') {
2304 1.359 rillig Error("Missing delimiter for :S modifier");
2305 1.409 rillig (*pp)++;
2306 1.359 rillig return AMR_CLEANUP;
2307 1.359 rillig }
2308 1.299 rillig
2309 1.409 rillig *pp += 2;
2310 1.236 rillig
2311 1.362 rillig args.pflags = 0;
2312 1.362 rillig
2313 1.236 rillig /*
2314 1.236 rillig * If pattern begins with '^', it is anchored to the
2315 1.236 rillig * start of the word -- skip over it and flag pattern.
2316 1.236 rillig */
2317 1.409 rillig if (**pp == '^') {
2318 1.288 rillig args.pflags |= VARP_ANCHOR_START;
2319 1.409 rillig (*pp)++;
2320 1.236 rillig }
2321 1.236 rillig
2322 1.412 rillig lhs = ParseModifierPart(pp, delim, st->eflags, st->ctxt,
2323 1.412 rillig &args.lhsLen, &args.pflags, NULL);
2324 1.298 rillig if (lhs == NULL) {
2325 1.298 rillig st->missing_delim = delim;
2326 1.356 rillig return AMR_CLEANUP;
2327 1.298 rillig }
2328 1.281 rillig args.lhs = lhs;
2329 1.236 rillig
2330 1.412 rillig rhs = ParseModifierPart(pp, delim, st->eflags, st->ctxt,
2331 1.412 rillig &args.rhsLen, NULL, &args);
2332 1.298 rillig if (rhs == NULL) {
2333 1.298 rillig st->missing_delim = delim;
2334 1.356 rillig return AMR_CLEANUP;
2335 1.298 rillig }
2336 1.281 rillig args.rhs = rhs;
2337 1.236 rillig
2338 1.412 rillig oneBigWord = st->oneBigWord;
2339 1.409 rillig for (;; (*pp)++) {
2340 1.409 rillig switch (**pp) {
2341 1.236 rillig case 'g':
2342 1.281 rillig args.pflags |= VARP_SUB_GLOBAL;
2343 1.236 rillig continue;
2344 1.236 rillig case '1':
2345 1.281 rillig args.pflags |= VARP_SUB_ONE;
2346 1.236 rillig continue;
2347 1.236 rillig case 'W':
2348 1.301 rillig oneBigWord = TRUE;
2349 1.236 rillig continue;
2350 1.236 rillig }
2351 1.236 rillig break;
2352 1.236 rillig }
2353 1.236 rillig
2354 1.349 rillig st->newVal = ModifyWords(st->ctxt, st->sep, oneBigWord, st->val,
2355 1.291 rillig ModifyWord_Subst, &args);
2356 1.236 rillig
2357 1.281 rillig free(lhs);
2358 1.281 rillig free(rhs);
2359 1.356 rillig return AMR_OK;
2360 1.236 rillig }
2361 1.236 rillig
2362 1.236 rillig #ifndef NO_REGEX
2363 1.291 rillig
2364 1.236 rillig /* :C,from,to, */
2365 1.356 rillig static ApplyModifierResult
2366 1.409 rillig ApplyModifier_Regex(const char **pp, ApplyModifiersState *st)
2367 1.236 rillig {
2368 1.412 rillig char *re;
2369 1.412 rillig ModifyWord_SubstRegexArgs args;
2370 1.412 rillig Boolean oneBigWord;
2371 1.412 rillig int error;
2372 1.412 rillig
2373 1.409 rillig char delim = (*pp)[1];
2374 1.360 rillig if (delim == '\0') {
2375 1.360 rillig Error("Missing delimiter for :C modifier");
2376 1.409 rillig (*pp)++;
2377 1.360 rillig return AMR_CLEANUP;
2378 1.360 rillig }
2379 1.236 rillig
2380 1.409 rillig *pp += 2;
2381 1.236 rillig
2382 1.412 rillig re = ParseModifierPart(pp, delim, st->eflags, st->ctxt, NULL, NULL, NULL);
2383 1.297 rillig if (re == NULL) {
2384 1.298 rillig st->missing_delim = delim;
2385 1.356 rillig return AMR_CLEANUP;
2386 1.297 rillig }
2387 1.236 rillig
2388 1.409 rillig args.replace = ParseModifierPart(pp, delim, st->eflags, st->ctxt,
2389 1.324 rillig NULL, NULL, NULL);
2390 1.291 rillig if (args.replace == NULL) {
2391 1.236 rillig free(re);
2392 1.298 rillig st->missing_delim = delim;
2393 1.356 rillig return AMR_CLEANUP;
2394 1.236 rillig }
2395 1.236 rillig
2396 1.361 rillig args.pflags = 0;
2397 1.412 rillig oneBigWord = st->oneBigWord;
2398 1.409 rillig for (;; (*pp)++) {
2399 1.409 rillig switch (**pp) {
2400 1.236 rillig case 'g':
2401 1.291 rillig args.pflags |= VARP_SUB_GLOBAL;
2402 1.236 rillig continue;
2403 1.236 rillig case '1':
2404 1.291 rillig args.pflags |= VARP_SUB_ONE;
2405 1.236 rillig continue;
2406 1.236 rillig case 'W':
2407 1.301 rillig oneBigWord = TRUE;
2408 1.236 rillig continue;
2409 1.236 rillig }
2410 1.236 rillig break;
2411 1.236 rillig }
2412 1.236 rillig
2413 1.412 rillig error = regcomp(&args.re, re, REG_EXTENDED);
2414 1.236 rillig free(re);
2415 1.242 rillig if (error) {
2416 1.385 rillig VarREError(error, &args.re, "Regex compilation error");
2417 1.291 rillig free(args.replace);
2418 1.356 rillig return AMR_CLEANUP;
2419 1.236 rillig }
2420 1.236 rillig
2421 1.291 rillig args.nsub = args.re.re_nsub + 1;
2422 1.291 rillig if (args.nsub < 1)
2423 1.291 rillig args.nsub = 1;
2424 1.291 rillig if (args.nsub > 10)
2425 1.291 rillig args.nsub = 10;
2426 1.349 rillig st->newVal = ModifyWords(st->ctxt, st->sep, oneBigWord, st->val,
2427 1.291 rillig ModifyWord_SubstRegex, &args);
2428 1.291 rillig regfree(&args.re);
2429 1.291 rillig free(args.replace);
2430 1.356 rillig return AMR_OK;
2431 1.236 rillig }
2432 1.236 rillig #endif
2433 1.236 rillig
2434 1.278 rillig static void
2435 1.295 rillig ModifyWord_Copy(const char *word, SepBuf *buf, void *data MAKE_ATTR_UNUSED)
2436 1.278 rillig {
2437 1.314 rillig SepBuf_AddStr(buf, word);
2438 1.275 rillig }
2439 1.275 rillig
2440 1.289 rillig /* :ts<separator> */
2441 1.356 rillig static ApplyModifierResult
2442 1.409 rillig ApplyModifier_ToSep(const char **pp, ApplyModifiersState *st)
2443 1.289 rillig {
2444 1.409 rillig /* XXX: pp points to the 's', for historic reasons only.
2445 1.409 rillig * Changing this will influence the error messages. */
2446 1.409 rillig const char *sep = *pp + 1;
2447 1.289 rillig if (sep[0] != st->endc && (sep[1] == st->endc || sep[1] == ':')) {
2448 1.354 rillig /* ":ts<any><endc>" or ":ts<any>:" */
2449 1.301 rillig st->sep = sep[0];
2450 1.409 rillig *pp = sep + 1;
2451 1.289 rillig } else if (sep[0] == st->endc || sep[0] == ':') {
2452 1.289 rillig /* ":ts<endc>" or ":ts:" */
2453 1.301 rillig st->sep = '\0'; /* no separator */
2454 1.409 rillig *pp = sep;
2455 1.289 rillig } else if (sep[0] == '\\') {
2456 1.289 rillig const char *xp = sep + 1;
2457 1.289 rillig int base = 8; /* assume octal */
2458 1.289 rillig
2459 1.289 rillig switch (sep[1]) {
2460 1.289 rillig case 'n':
2461 1.301 rillig st->sep = '\n';
2462 1.409 rillig *pp = sep + 2;
2463 1.289 rillig break;
2464 1.289 rillig case 't':
2465 1.301 rillig st->sep = '\t';
2466 1.409 rillig *pp = sep + 2;
2467 1.289 rillig break;
2468 1.289 rillig case 'x':
2469 1.289 rillig base = 16;
2470 1.289 rillig xp++;
2471 1.289 rillig goto get_numeric;
2472 1.289 rillig case '0':
2473 1.289 rillig base = 0;
2474 1.289 rillig goto get_numeric;
2475 1.289 rillig default:
2476 1.289 rillig if (!isdigit((unsigned char)sep[1]))
2477 1.356 rillig return AMR_BAD; /* ":ts<backslash><unrecognised>". */
2478 1.289 rillig
2479 1.289 rillig get_numeric:
2480 1.412 rillig {
2481 1.412 rillig char *end;
2482 1.412 rillig st->sep = strtoul(xp, &end, base);
2483 1.412 rillig if (*end != ':' && *end != st->endc)
2484 1.412 rillig return AMR_BAD;
2485 1.412 rillig *pp = end;
2486 1.412 rillig }
2487 1.289 rillig break;
2488 1.289 rillig }
2489 1.289 rillig } else {
2490 1.356 rillig return AMR_BAD; /* Found ":ts<unrecognised><unrecognised>". */
2491 1.289 rillig }
2492 1.289 rillig
2493 1.349 rillig st->newVal = ModifyWords(st->ctxt, st->sep, st->oneBigWord, st->val,
2494 1.292 rillig ModifyWord_Copy, NULL);
2495 1.356 rillig return AMR_OK;
2496 1.289 rillig }
2497 1.289 rillig
2498 1.289 rillig /* :tA, :tu, :tl, :ts<separator>, etc. */
2499 1.356 rillig static ApplyModifierResult
2500 1.409 rillig ApplyModifier_To(const char **pp, ApplyModifiersState *st)
2501 1.236 rillig {
2502 1.409 rillig const char *mod = *pp;
2503 1.363 rillig assert(mod[0] == 't');
2504 1.363 rillig
2505 1.409 rillig *pp = mod + 1; /* make sure it is set */
2506 1.363 rillig if (mod[1] == st->endc || mod[1] == ':' || mod[1] == '\0')
2507 1.356 rillig return AMR_BAD; /* Found ":t<endc>" or ":t:". */
2508 1.289 rillig
2509 1.299 rillig if (mod[1] == 's')
2510 1.409 rillig return ApplyModifier_ToSep(pp, st);
2511 1.289 rillig
2512 1.299 rillig if (mod[2] != st->endc && mod[2] != ':')
2513 1.356 rillig return AMR_BAD; /* Found ":t<unrecognised><unrecognised>". */
2514 1.236 rillig
2515 1.289 rillig /* Check for two-character options: ":tu", ":tl" */
2516 1.299 rillig if (mod[1] == 'A') { /* absolute path */
2517 1.349 rillig st->newVal = ModifyWords(st->ctxt, st->sep, st->oneBigWord, st->val,
2518 1.291 rillig ModifyWord_Realpath, NULL);
2519 1.409 rillig *pp = mod + 2;
2520 1.299 rillig } else if (mod[1] == 'u') {
2521 1.412 rillig size_t i;
2522 1.364 rillig size_t len = strlen(st->val);
2523 1.364 rillig st->newVal = bmake_malloc(len + 1);
2524 1.364 rillig for (i = 0; i < len + 1; i++)
2525 1.364 rillig st->newVal[i] = toupper((unsigned char)st->val[i]);
2526 1.409 rillig *pp = mod + 2;
2527 1.299 rillig } else if (mod[1] == 'l') {
2528 1.412 rillig size_t i;
2529 1.364 rillig size_t len = strlen(st->val);
2530 1.364 rillig st->newVal = bmake_malloc(len + 1);
2531 1.364 rillig for (i = 0; i < len + 1; i++)
2532 1.364 rillig st->newVal[i] = tolower((unsigned char)st->val[i]);
2533 1.409 rillig *pp = mod + 2;
2534 1.299 rillig } else if (mod[1] == 'W' || mod[1] == 'w') {
2535 1.301 rillig st->oneBigWord = mod[1] == 'W';
2536 1.349 rillig st->newVal = st->val;
2537 1.409 rillig *pp = mod + 2;
2538 1.236 rillig } else {
2539 1.289 rillig /* Found ":t<unrecognised>:" or ":t<unrecognised><endc>". */
2540 1.356 rillig return AMR_BAD;
2541 1.236 rillig }
2542 1.356 rillig return AMR_OK;
2543 1.236 rillig }
2544 1.236 rillig
2545 1.236 rillig /* :[#], :[1], etc. */
2546 1.356 rillig static ApplyModifierResult
2547 1.409 rillig ApplyModifier_Words(const char **pp, ApplyModifiersState *st)
2548 1.236 rillig {
2549 1.412 rillig char delim;
2550 1.412 rillig char *estr;
2551 1.412 rillig char *ep;
2552 1.412 rillig int first, last;
2553 1.412 rillig
2554 1.409 rillig (*pp)++; /* skip the '[' */
2555 1.412 rillig delim = ']'; /* look for closing ']' */
2556 1.412 rillig estr = ParseModifierPart(pp, delim, st->eflags, st->ctxt,
2557 1.417 rillig NULL, NULL, NULL);
2558 1.298 rillig if (estr == NULL) {
2559 1.298 rillig st->missing_delim = delim;
2560 1.356 rillig return AMR_CLEANUP;
2561 1.298 rillig }
2562 1.288 rillig
2563 1.409 rillig /* now *pp points just after the closing ']' */
2564 1.409 rillig if (**pp != ':' && **pp != st->endc)
2565 1.288 rillig goto bad_modifier; /* Found junk after ']' */
2566 1.288 rillig
2567 1.288 rillig if (estr[0] == '\0')
2568 1.288 rillig goto bad_modifier; /* empty square brackets in ":[]". */
2569 1.236 rillig
2570 1.288 rillig if (estr[0] == '#' && estr[1] == '\0') { /* Found ":[#]" */
2571 1.301 rillig if (st->oneBigWord) {
2572 1.349 rillig st->newVal = bmake_strdup("1");
2573 1.236 rillig } else {
2574 1.412 rillig Buffer buf;
2575 1.412 rillig
2576 1.236 rillig /* XXX: brk_string() is a rather expensive
2577 1.236 rillig * way of counting words. */
2578 1.236 rillig char *as;
2579 1.236 rillig int ac;
2580 1.349 rillig char **av = brk_string(st->val, &ac, FALSE, &as);
2581 1.236 rillig free(as);
2582 1.236 rillig free(av);
2583 1.312 rillig
2584 1.433 rillig Buf_Init(&buf, 4); /* 3 digits + '\0' */
2585 1.312 rillig Buf_AddInt(&buf, ac);
2586 1.349 rillig st->newVal = Buf_Destroy(&buf, FALSE);
2587 1.236 rillig }
2588 1.288 rillig goto ok;
2589 1.288 rillig }
2590 1.288 rillig
2591 1.288 rillig if (estr[0] == '*' && estr[1] == '\0') {
2592 1.236 rillig /* Found ":[*]" */
2593 1.301 rillig st->oneBigWord = TRUE;
2594 1.349 rillig st->newVal = st->val;
2595 1.288 rillig goto ok;
2596 1.288 rillig }
2597 1.288 rillig
2598 1.288 rillig if (estr[0] == '@' && estr[1] == '\0') {
2599 1.236 rillig /* Found ":[@]" */
2600 1.301 rillig st->oneBigWord = FALSE;
2601 1.349 rillig st->newVal = st->val;
2602 1.288 rillig goto ok;
2603 1.288 rillig }
2604 1.288 rillig
2605 1.288 rillig /*
2606 1.288 rillig * We expect estr to contain a single integer for :[N], or two integers
2607 1.288 rillig * separated by ".." for :[start..end].
2608 1.288 rillig */
2609 1.412 rillig first = strtol(estr, &ep, 0);
2610 1.288 rillig if (ep == estr) /* Found junk instead of a number */
2611 1.288 rillig goto bad_modifier;
2612 1.288 rillig
2613 1.288 rillig if (ep[0] == '\0') { /* Found only one integer in :[N] */
2614 1.290 rillig last = first;
2615 1.288 rillig } else if (ep[0] == '.' && ep[1] == '.' && ep[2] != '\0') {
2616 1.288 rillig /* Expecting another integer after ".." */
2617 1.288 rillig ep += 2;
2618 1.290 rillig last = strtol(ep, &ep, 0);
2619 1.288 rillig if (ep[0] != '\0') /* Found junk after ".." */
2620 1.288 rillig goto bad_modifier;
2621 1.288 rillig } else
2622 1.288 rillig goto bad_modifier; /* Found junk instead of ".." */
2623 1.236 rillig
2624 1.288 rillig /*
2625 1.288 rillig * Now seldata is properly filled in, but we still have to check for 0 as
2626 1.288 rillig * a special case.
2627 1.288 rillig */
2628 1.290 rillig if (first == 0 && last == 0) {
2629 1.288 rillig /* ":[0]" or perhaps ":[0..0]" */
2630 1.301 rillig st->oneBigWord = TRUE;
2631 1.349 rillig st->newVal = st->val;
2632 1.288 rillig goto ok;
2633 1.236 rillig }
2634 1.288 rillig
2635 1.288 rillig /* ":[0..N]" or ":[N..0]" */
2636 1.290 rillig if (first == 0 || last == 0)
2637 1.288 rillig goto bad_modifier;
2638 1.288 rillig
2639 1.288 rillig /* Normal case: select the words described by seldata. */
2640 1.349 rillig st->newVal = VarSelectWords(st->sep, st->oneBigWord, st->val, first, last);
2641 1.288 rillig
2642 1.288 rillig ok:
2643 1.288 rillig free(estr);
2644 1.356 rillig return AMR_OK;
2645 1.288 rillig
2646 1.288 rillig bad_modifier:
2647 1.288 rillig free(estr);
2648 1.356 rillig return AMR_BAD;
2649 1.236 rillig }
2650 1.236 rillig
2651 1.404 rillig static int
2652 1.404 rillig str_cmp_asc(const void *a, const void *b)
2653 1.404 rillig {
2654 1.404 rillig return strcmp(*(const char * const *)a, *(const char * const *)b);
2655 1.404 rillig }
2656 1.404 rillig
2657 1.404 rillig static int
2658 1.404 rillig str_cmp_desc(const void *a, const void *b)
2659 1.404 rillig {
2660 1.404 rillig return strcmp(*(const char * const *)b, *(const char * const *)a);
2661 1.404 rillig }
2662 1.404 rillig
2663 1.402 rillig /* :O (order ascending) or :Or (order descending) or :Ox (shuffle) */
2664 1.356 rillig static ApplyModifierResult
2665 1.409 rillig ApplyModifier_Order(const char **pp, ApplyModifiersState *st)
2666 1.236 rillig {
2667 1.409 rillig const char *mod = (*pp)++; /* skip past the 'O' in any case */
2668 1.402 rillig
2669 1.402 rillig char *as; /* word list memory */
2670 1.402 rillig int ac;
2671 1.402 rillig char **av = brk_string(st->val, &ac, FALSE, &as);
2672 1.401 rillig
2673 1.299 rillig if (mod[1] == st->endc || mod[1] == ':') {
2674 1.417 rillig /* :O sorts ascending */
2675 1.404 rillig qsort(av, ac, sizeof(char *), str_cmp_asc);
2676 1.402 rillig
2677 1.299 rillig } else if ((mod[1] == 'r' || mod[1] == 'x') &&
2678 1.299 rillig (mod[2] == st->endc || mod[2] == ':')) {
2679 1.409 rillig (*pp)++;
2680 1.402 rillig
2681 1.402 rillig if (mod[1] == 'r') {
2682 1.402 rillig /* :Or sorts descending */
2683 1.404 rillig qsort(av, ac, sizeof(char *), str_cmp_desc);
2684 1.402 rillig
2685 1.402 rillig } else {
2686 1.402 rillig /* :Ox shuffles
2687 1.402 rillig *
2688 1.402 rillig * We will use [ac..2] range for mod factors. This will produce
2689 1.402 rillig * random numbers in [(ac-1)..0] interval, and minimal
2690 1.402 rillig * reasonable value for mod factor is 2 (the mod 1 will produce
2691 1.402 rillig * 0 with probability 1).
2692 1.402 rillig */
2693 1.402 rillig int i;
2694 1.402 rillig for (i = ac - 1; i > 0; i--) {
2695 1.402 rillig int rndidx = random() % (i + 1);
2696 1.402 rillig char *t = av[i];
2697 1.402 rillig av[i] = av[rndidx];
2698 1.402 rillig av[rndidx] = t;
2699 1.402 rillig }
2700 1.402 rillig }
2701 1.236 rillig } else {
2702 1.402 rillig free(as);
2703 1.402 rillig free(av);
2704 1.356 rillig return AMR_BAD;
2705 1.236 rillig }
2706 1.402 rillig
2707 1.403 rillig st->newVal = WordList_JoinFree(av, ac, as);
2708 1.356 rillig return AMR_OK;
2709 1.236 rillig }
2710 1.236 rillig
2711 1.236 rillig /* :? then : else */
2712 1.356 rillig static ApplyModifierResult
2713 1.409 rillig ApplyModifier_IfElse(const char **pp, ApplyModifiersState *st)
2714 1.236 rillig {
2715 1.412 rillig char delim;
2716 1.412 rillig char *then_expr, *else_expr;
2717 1.412 rillig
2718 1.285 rillig Boolean value = FALSE;
2719 1.285 rillig VarEvalFlags then_eflags = st->eflags & ~VARE_WANTRES;
2720 1.285 rillig VarEvalFlags else_eflags = st->eflags & ~VARE_WANTRES;
2721 1.236 rillig
2722 1.384 rillig int cond_rc = COND_PARSE; /* anything other than COND_INVALID */
2723 1.268 rillig if (st->eflags & VARE_WANTRES) {
2724 1.236 rillig cond_rc = Cond_EvalExpression(NULL, st->v->name, &value, 0, FALSE);
2725 1.285 rillig if (cond_rc != COND_INVALID && value)
2726 1.285 rillig then_eflags |= VARE_WANTRES;
2727 1.285 rillig if (cond_rc != COND_INVALID && !value)
2728 1.285 rillig else_eflags |= VARE_WANTRES;
2729 1.236 rillig }
2730 1.236 rillig
2731 1.409 rillig (*pp)++; /* skip past the '?' */
2732 1.412 rillig delim = ':';
2733 1.412 rillig then_expr = ParseModifierPart(pp, delim, then_eflags, st->ctxt,
2734 1.412 rillig NULL, NULL, NULL);
2735 1.298 rillig if (then_expr == NULL) {
2736 1.298 rillig st->missing_delim = delim;
2737 1.356 rillig return AMR_CLEANUP;
2738 1.298 rillig }
2739 1.236 rillig
2740 1.298 rillig delim = st->endc; /* BRCLOSE or PRCLOSE */
2741 1.412 rillig else_expr = ParseModifierPart(pp, delim, else_eflags, st->ctxt,
2742 1.412 rillig NULL, NULL, NULL);
2743 1.298 rillig if (else_expr == NULL) {
2744 1.298 rillig st->missing_delim = delim;
2745 1.356 rillig return AMR_CLEANUP;
2746 1.298 rillig }
2747 1.236 rillig
2748 1.409 rillig (*pp)--;
2749 1.236 rillig if (cond_rc == COND_INVALID) {
2750 1.236 rillig Error("Bad conditional expression `%s' in %s?%s:%s",
2751 1.417 rillig st->v->name, st->v->name, then_expr, else_expr);
2752 1.356 rillig return AMR_CLEANUP;
2753 1.236 rillig }
2754 1.236 rillig
2755 1.236 rillig if (value) {
2756 1.349 rillig st->newVal = then_expr;
2757 1.258 rillig free(else_expr);
2758 1.236 rillig } else {
2759 1.349 rillig st->newVal = else_expr;
2760 1.270 rillig free(then_expr);
2761 1.236 rillig }
2762 1.236 rillig if (st->v->flags & VAR_JUNK)
2763 1.236 rillig st->v->flags |= VAR_KEEP;
2764 1.356 rillig return AMR_OK;
2765 1.236 rillig }
2766 1.236 rillig
2767 1.283 rillig /*
2768 1.283 rillig * The ::= modifiers actually assign a value to the variable.
2769 1.283 rillig * Their main purpose is in supporting modifiers of .for loop
2770 1.283 rillig * iterators and other obscure uses. They always expand to
2771 1.283 rillig * nothing. In a target rule that would otherwise expand to an
2772 1.283 rillig * empty line they can be preceded with @: to keep make happy.
2773 1.283 rillig * Eg.
2774 1.283 rillig *
2775 1.283 rillig * foo: .USE
2776 1.283 rillig * .for i in ${.TARGET} ${.TARGET:R}.gz
2777 1.283 rillig * @: ${t::=$i}
2778 1.283 rillig * @echo blah ${t:T}
2779 1.283 rillig * .endfor
2780 1.283 rillig *
2781 1.283 rillig * ::=<str> Assigns <str> as the new value of variable.
2782 1.283 rillig * ::?=<str> Assigns <str> as value of variable if
2783 1.283 rillig * it was not already set.
2784 1.283 rillig * ::+=<str> Appends <str> to variable.
2785 1.283 rillig * ::!=<cmd> Assigns output of <cmd> as the new value of
2786 1.283 rillig * variable.
2787 1.283 rillig */
2788 1.356 rillig static ApplyModifierResult
2789 1.409 rillig ApplyModifier_Assign(const char **pp, ApplyModifiersState *st)
2790 1.236 rillig {
2791 1.412 rillig GNode *v_ctxt;
2792 1.412 rillig char *sv_name;
2793 1.412 rillig char delim;
2794 1.412 rillig char *val;
2795 1.412 rillig
2796 1.409 rillig const char *mod = *pp;
2797 1.299 rillig const char *op = mod + 1;
2798 1.272 rillig if (!(op[0] == '=' ||
2799 1.417 rillig (op[1] == '=' &&
2800 1.417 rillig (op[0] == '!' || op[0] == '+' || op[0] == '?'))))
2801 1.356 rillig return AMR_UNKNOWN; /* "::<unrecognised>" */
2802 1.236 rillig
2803 1.272 rillig
2804 1.355 rillig if (st->v->name[0] == 0) {
2805 1.409 rillig *pp = mod + 1;
2806 1.356 rillig return AMR_BAD;
2807 1.355 rillig }
2808 1.272 rillig
2809 1.412 rillig v_ctxt = st->ctxt; /* context where v belongs */
2810 1.412 rillig sv_name = NULL;
2811 1.272 rillig if (st->v->flags & VAR_JUNK) {
2812 1.272 rillig /*
2813 1.384 rillig * We need to bmake_strdup() it in case ParseModifierPart() recurses.
2814 1.272 rillig */
2815 1.272 rillig sv_name = st->v->name;
2816 1.272 rillig st->v->name = bmake_strdup(st->v->name);
2817 1.272 rillig } else if (st->ctxt != VAR_GLOBAL) {
2818 1.272 rillig Var *gv = VarFind(st->v->name, st->ctxt, 0);
2819 1.272 rillig if (gv == NULL)
2820 1.272 rillig v_ctxt = VAR_GLOBAL;
2821 1.272 rillig else
2822 1.272 rillig VarFreeEnv(gv, TRUE);
2823 1.272 rillig }
2824 1.272 rillig
2825 1.273 rillig switch (op[0]) {
2826 1.272 rillig case '+':
2827 1.272 rillig case '?':
2828 1.272 rillig case '!':
2829 1.409 rillig *pp = mod + 3;
2830 1.272 rillig break;
2831 1.272 rillig default:
2832 1.409 rillig *pp = mod + 2;
2833 1.272 rillig break;
2834 1.272 rillig }
2835 1.272 rillig
2836 1.412 rillig delim = st->startc == PROPEN ? PRCLOSE : BRCLOSE;
2837 1.412 rillig val = ParseModifierPart(pp, delim, st->eflags, st->ctxt, NULL, NULL, NULL);
2838 1.272 rillig if (st->v->flags & VAR_JUNK) {
2839 1.272 rillig /* restore original name */
2840 1.272 rillig free(st->v->name);
2841 1.272 rillig st->v->name = sv_name;
2842 1.272 rillig }
2843 1.298 rillig if (val == NULL) {
2844 1.298 rillig st->missing_delim = delim;
2845 1.356 rillig return AMR_CLEANUP;
2846 1.298 rillig }
2847 1.236 rillig
2848 1.409 rillig (*pp)--;
2849 1.236 rillig
2850 1.272 rillig if (st->eflags & VARE_WANTRES) {
2851 1.273 rillig switch (op[0]) {
2852 1.236 rillig case '+':
2853 1.273 rillig Var_Append(st->v->name, val, v_ctxt);
2854 1.272 rillig break;
2855 1.273 rillig case '!': {
2856 1.416 rillig const char *errfmt;
2857 1.416 rillig char *cmd_output = Cmd_Exec(val, &errfmt);
2858 1.416 rillig if (errfmt)
2859 1.416 rillig Error(errfmt, st->val);
2860 1.272 rillig else
2861 1.406 rillig Var_Set(st->v->name, cmd_output, v_ctxt);
2862 1.406 rillig free(cmd_output);
2863 1.236 rillig break;
2864 1.273 rillig }
2865 1.272 rillig case '?':
2866 1.333 rillig if (!(st->v->flags & VAR_JUNK))
2867 1.272 rillig break;
2868 1.272 rillig /* FALLTHROUGH */
2869 1.236 rillig default:
2870 1.273 rillig Var_Set(st->v->name, val, v_ctxt);
2871 1.236 rillig break;
2872 1.236 rillig }
2873 1.236 rillig }
2874 1.273 rillig free(val);
2875 1.349 rillig st->newVal = varNoError;
2876 1.356 rillig return AMR_OK;
2877 1.236 rillig }
2878 1.236 rillig
2879 1.236 rillig /* remember current value */
2880 1.356 rillig static ApplyModifierResult
2881 1.409 rillig ApplyModifier_Remember(const char **pp, ApplyModifiersState *st)
2882 1.236 rillig {
2883 1.409 rillig const char *mod = *pp;
2884 1.358 rillig if (!ModMatchEq(mod, "_", st->endc))
2885 1.356 rillig return AMR_UNKNOWN;
2886 1.236 rillig
2887 1.299 rillig if (mod[1] == '=') {
2888 1.340 rillig size_t n = strcspn(mod + 2, ":)}");
2889 1.340 rillig char *name = bmake_strndup(mod + 2, n);
2890 1.349 rillig Var_Set(name, st->val, st->ctxt);
2891 1.340 rillig free(name);
2892 1.409 rillig *pp = mod + 2 + n;
2893 1.236 rillig } else {
2894 1.349 rillig Var_Set("_", st->val, st->ctxt);
2895 1.409 rillig *pp = mod + 1;
2896 1.236 rillig }
2897 1.349 rillig st->newVal = st->val;
2898 1.356 rillig return AMR_OK;
2899 1.236 rillig }
2900 1.236 rillig
2901 1.236 rillig #ifdef SYSVVARSUB
2902 1.236 rillig /* :from=to */
2903 1.356 rillig static ApplyModifierResult
2904 1.409 rillig ApplyModifier_SysV(const char **pp, ApplyModifiersState *st)
2905 1.236 rillig {
2906 1.412 rillig char delim;
2907 1.412 rillig char *lhs, *rhs;
2908 1.412 rillig
2909 1.409 rillig const char *mod = *pp;
2910 1.276 rillig Boolean eqFound = FALSE;
2911 1.245 rillig
2912 1.236 rillig /*
2913 1.236 rillig * First we make a pass through the string trying
2914 1.236 rillig * to verify it is a SYSV-make-style translation:
2915 1.236 rillig * it must be: <string1>=<string2>)
2916 1.236 rillig */
2917 1.262 rillig int nest = 1;
2918 1.408 rillig const char *next = mod;
2919 1.408 rillig while (*next != '\0' && nest > 0) {
2920 1.408 rillig if (*next == '=') {
2921 1.236 rillig eqFound = TRUE;
2922 1.236 rillig /* continue looking for st->endc */
2923 1.408 rillig } else if (*next == st->endc)
2924 1.262 rillig nest--;
2925 1.408 rillig else if (*next == st->startc)
2926 1.262 rillig nest++;
2927 1.262 rillig if (nest > 0)
2928 1.409 rillig next++;
2929 1.236 rillig }
2930 1.408 rillig if (*next != st->endc || !eqFound)
2931 1.356 rillig return AMR_UNKNOWN;
2932 1.236 rillig
2933 1.412 rillig delim = '=';
2934 1.409 rillig *pp = mod;
2935 1.412 rillig lhs = ParseModifierPart(pp, delim, st->eflags, st->ctxt, NULL, NULL, NULL);
2936 1.298 rillig if (lhs == NULL) {
2937 1.298 rillig st->missing_delim = delim;
2938 1.356 rillig return AMR_CLEANUP;
2939 1.298 rillig }
2940 1.245 rillig
2941 1.298 rillig delim = st->endc;
2942 1.412 rillig rhs = ParseModifierPart(pp, delim, st->eflags, st->ctxt, NULL, NULL, NULL);
2943 1.298 rillig if (rhs == NULL) {
2944 1.298 rillig st->missing_delim = delim;
2945 1.356 rillig return AMR_CLEANUP;
2946 1.298 rillig }
2947 1.236 rillig
2948 1.245 rillig /*
2949 1.245 rillig * SYSV modifications happen through the whole
2950 1.245 rillig * string. Note the pattern is anchored at the end.
2951 1.245 rillig */
2952 1.409 rillig (*pp)--;
2953 1.349 rillig if (lhs[0] == '\0' && *st->val == '\0') {
2954 1.349 rillig st->newVal = st->val; /* special case */
2955 1.245 rillig } else {
2956 1.417 rillig ModifyWord_SYSVSubstArgs args = {st->ctxt, lhs, rhs};
2957 1.349 rillig st->newVal = ModifyWords(st->ctxt, st->sep, st->oneBigWord, st->val,
2958 1.291 rillig ModifyWord_SYSVSubst, &args);
2959 1.245 rillig }
2960 1.276 rillig free(lhs);
2961 1.276 rillig free(rhs);
2962 1.356 rillig return AMR_OK;
2963 1.236 rillig }
2964 1.236 rillig #endif
2965 1.236 rillig
2966 1.419 rillig /* Apply any modifiers (such as :Mpattern or :@var@loop@ or :Q or ::=value). */
2967 1.108 sjg static char *
2968 1.357 rillig ApplyModifiers(
2969 1.367 rillig const char **pp, /* the parsing position, updated upon return */
2970 1.357 rillig char *val, /* the current value of the variable */
2971 1.357 rillig int const startc, /* '(' or '{' or '\0' */
2972 1.357 rillig int const endc, /* ')' or '}' or '\0' */
2973 1.357 rillig Var * const v, /* the variable may have its flags changed */
2974 1.357 rillig GNode * const ctxt, /* for looking up and modifying variables */
2975 1.357 rillig VarEvalFlags const eflags,
2976 1.357 rillig void ** const freePtr /* free this after using the return value */
2977 1.357 rillig ) {
2978 1.236 rillig ApplyModifiersState st = {
2979 1.344 rillig startc, endc, v, ctxt, eflags,
2980 1.409 rillig val, NULL, '\0', ' ', FALSE
2981 1.236 rillig };
2982 1.412 rillig const char *p;
2983 1.412 rillig const char *mod;
2984 1.412 rillig ApplyModifierResult res;
2985 1.412 rillig
2986 1.412 rillig assert(startc == '(' || startc == '{' || startc == '\0');
2987 1.413 rillig assert(endc == ')' || endc == '}' || endc == '\0');
2988 1.15 christos
2989 1.412 rillig p = *pp;
2990 1.299 rillig while (*p != '\0' && *p != endc) {
2991 1.142 dsl
2992 1.299 rillig if (*p == '$') {
2993 1.142 dsl /*
2994 1.167 sjg * We may have some complex modifiers in a variable.
2995 1.1 cgd */
2996 1.401 rillig int rlen;
2997 1.108 sjg void *freeIt;
2998 1.401 rillig const char *rval = Var_Parse(p, st.ctxt, st.eflags, &rlen, &freeIt);
2999 1.1 cgd
3000 1.167 sjg /*
3001 1.236 rillig * If we have not parsed up to st.endc or ':',
3002 1.167 sjg * we are not interested.
3003 1.167 sjg */
3004 1.401 rillig int c;
3005 1.167 sjg if (rval != NULL && *rval &&
3006 1.357 rillig (c = p[rlen]) != '\0' && c != ':' && c != st.endc) {
3007 1.196 christos free(freeIt);
3008 1.167 sjg goto apply_mods;
3009 1.167 sjg }
3010 1.167 sjg
3011 1.418 rillig VAR_DEBUG("Indirect modifier \"%s\" from \"%.*s\"\n", rval, rlen, p);
3012 1.1 cgd
3013 1.299 rillig p += rlen;
3014 1.15 christos
3015 1.108 sjg if (rval != NULL && *rval) {
3016 1.367 rillig const char *rval_pp = rval;
3017 1.367 rillig st.val = ApplyModifiers(&rval_pp, st.val, 0, 0, v,
3018 1.367 rillig ctxt, eflags, freePtr);
3019 1.349 rillig if (st.val == var_Error
3020 1.371 rillig || (st.val == varNoError && !(st.eflags & VARE_UNDEFERR))
3021 1.367 rillig || *rval_pp != '\0') {
3022 1.196 christos free(freeIt);
3023 1.240 rillig goto out; /* error already reported */
3024 1.1 cgd }
3025 1.1 cgd }
3026 1.196 christos free(freeIt);
3027 1.299 rillig if (*p == ':')
3028 1.299 rillig p++;
3029 1.299 rillig else if (*p == '\0' && endc != '\0') {
3030 1.246 rillig Error("Unclosed variable specification after complex "
3031 1.417 rillig "modifier (expecting '%c') for %s", st.endc, st.v->name);
3032 1.119 sjg goto out;
3033 1.119 sjg }
3034 1.108 sjg continue;
3035 1.108 sjg }
3036 1.167 sjg apply_mods:
3037 1.417 rillig st.newVal = var_Error; /* default value, in case of errors */
3038 1.417 rillig res = AMR_BAD; /* just a safe fallback */
3039 1.409 rillig mod = p;
3040 1.430 rillig
3041 1.430 rillig if (DEBUG(VAR)) {
3042 1.430 rillig char vflags_str[VarFlags_ToStringSize];
3043 1.430 rillig char eflags_str[VarEvalFlags_ToStringSize];
3044 1.430 rillig Boolean is_single_char = mod[0] != '\0' &&
3045 1.430 rillig (mod[1] == endc || mod[1] == ':');
3046 1.430 rillig
3047 1.430 rillig /* At this point, only the first character of the modifier can
3048 1.430 rillig * be used since the end of the modifier is not yet known. */
3049 1.430 rillig VAR_DEBUG("Applying ${%s:%c%s} to \"%s\" "
3050 1.430 rillig "(eflags = %s, vflags = %s)\n",
3051 1.430 rillig st.v->name, mod[0], is_single_char ? "" : "...", st.val,
3052 1.430 rillig Enum_ToString(eflags_str, sizeof eflags_str, st.eflags,
3053 1.430 rillig VarEvalFlags_ToStringSpecs),
3054 1.430 rillig Enum_ToString(vflags_str, sizeof vflags_str, st.v->flags,
3055 1.430 rillig VarFlags_ToStringSpecs));
3056 1.430 rillig }
3057 1.430 rillig
3058 1.409 rillig switch (*mod) {
3059 1.108 sjg case ':':
3060 1.409 rillig res = ApplyModifier_Assign(&p, &st);
3061 1.356 rillig break;
3062 1.236 rillig case '@':
3063 1.409 rillig res = ApplyModifier_Loop(&p, &st);
3064 1.236 rillig break;
3065 1.236 rillig case '_':
3066 1.409 rillig res = ApplyModifier_Remember(&p, &st);
3067 1.236 rillig break;
3068 1.108 sjg case 'D':
3069 1.108 sjg case 'U':
3070 1.409 rillig res = ApplyModifier_Defined(&p, &st);
3071 1.236 rillig break;
3072 1.108 sjg case 'L':
3073 1.356 rillig if (st.v->flags & VAR_JUNK)
3074 1.356 rillig st.v->flags |= VAR_KEEP;
3075 1.356 rillig st.newVal = bmake_strdup(st.v->name);
3076 1.409 rillig p++;
3077 1.356 rillig res = AMR_OK;
3078 1.356 rillig break;
3079 1.108 sjg case 'P':
3080 1.409 rillig res = ApplyModifier_Path(&p, &st);
3081 1.236 rillig break;
3082 1.108 sjg case '!':
3083 1.409 rillig res = ApplyModifier_Exclam(&p, &st);
3084 1.236 rillig break;
3085 1.236 rillig case '[':
3086 1.409 rillig res = ApplyModifier_Words(&p, &st);
3087 1.356 rillig break;
3088 1.164 sjg case 'g':
3089 1.409 rillig res = ApplyModifier_Gmtime(&p, &st);
3090 1.164 sjg break;
3091 1.163 joerg case 'h':
3092 1.409 rillig res = ApplyModifier_Hash(&p, &st);
3093 1.163 joerg break;
3094 1.164 sjg case 'l':
3095 1.409 rillig res = ApplyModifier_Localtime(&p, &st);
3096 1.164 sjg break;
3097 1.108 sjg case 't':
3098 1.409 rillig res = ApplyModifier_To(&p, &st);
3099 1.236 rillig break;
3100 1.108 sjg case 'N':
3101 1.108 sjg case 'M':
3102 1.409 rillig res = ApplyModifier_Match(&p, &st);
3103 1.236 rillig break;
3104 1.108 sjg case 'S':
3105 1.409 rillig res = ApplyModifier_Subst(&p, &st);
3106 1.236 rillig break;
3107 1.108 sjg case '?':
3108 1.409 rillig res = ApplyModifier_IfElse(&p, &st);
3109 1.236 rillig break;
3110 1.108 sjg #ifndef NO_REGEX
3111 1.108 sjg case 'C':
3112 1.409 rillig res = ApplyModifier_Regex(&p, &st);
3113 1.236 rillig break;
3114 1.108 sjg #endif
3115 1.220 christos case 'q':
3116 1.108 sjg case 'Q':
3117 1.299 rillig if (p[1] == st.endc || p[1] == ':') {
3118 1.409 rillig st.newVal = VarQuote(st.val, *mod == 'q');
3119 1.409 rillig p++;
3120 1.356 rillig res = AMR_OK;
3121 1.356 rillig } else
3122 1.356 rillig res = AMR_UNKNOWN;
3123 1.356 rillig break;
3124 1.108 sjg case 'T':
3125 1.299 rillig if (p[1] == st.endc || p[1] == ':') {
3126 1.349 rillig st.newVal = ModifyWords(st.ctxt, st.sep, st.oneBigWord,
3127 1.349 rillig st.val, ModifyWord_Tail, NULL);
3128 1.409 rillig p++;
3129 1.356 rillig res = AMR_OK;
3130 1.356 rillig } else
3131 1.356 rillig res = AMR_UNKNOWN;
3132 1.356 rillig break;
3133 1.108 sjg case 'H':
3134 1.299 rillig if (p[1] == st.endc || p[1] == ':') {
3135 1.349 rillig st.newVal = ModifyWords(st.ctxt, st.sep, st.oneBigWord,
3136 1.349 rillig st.val, ModifyWord_Head, NULL);
3137 1.409 rillig p++;
3138 1.356 rillig res = AMR_OK;
3139 1.356 rillig } else
3140 1.356 rillig res = AMR_UNKNOWN;
3141 1.356 rillig break;
3142 1.108 sjg case 'E':
3143 1.299 rillig if (p[1] == st.endc || p[1] == ':') {
3144 1.349 rillig st.newVal = ModifyWords(st.ctxt, st.sep, st.oneBigWord,
3145 1.349 rillig st.val, ModifyWord_Suffix, NULL);
3146 1.409 rillig p++;
3147 1.356 rillig res = AMR_OK;
3148 1.356 rillig } else
3149 1.356 rillig res = AMR_UNKNOWN;
3150 1.356 rillig break;
3151 1.108 sjg case 'R':
3152 1.299 rillig if (p[1] == st.endc || p[1] == ':') {
3153 1.349 rillig st.newVal = ModifyWords(st.ctxt, st.sep, st.oneBigWord,
3154 1.349 rillig st.val, ModifyWord_Root, NULL);
3155 1.409 rillig p++;
3156 1.356 rillig res = AMR_OK;
3157 1.356 rillig } else
3158 1.356 rillig res = AMR_UNKNOWN;
3159 1.356 rillig break;
3160 1.210 sjg case 'r':
3161 1.409 rillig res = ApplyModifier_Range(&p, &st);
3162 1.236 rillig break;
3163 1.108 sjg case 'O':
3164 1.409 rillig res = ApplyModifier_Order(&p, &st);
3165 1.236 rillig break;
3166 1.108 sjg case 'u':
3167 1.299 rillig if (p[1] == st.endc || p[1] == ':') {
3168 1.349 rillig st.newVal = VarUniq(st.val);
3169 1.409 rillig p++;
3170 1.356 rillig res = AMR_OK;
3171 1.356 rillig } else
3172 1.356 rillig res = AMR_UNKNOWN;
3173 1.356 rillig break;
3174 1.108 sjg #ifdef SUNSHCMD
3175 1.108 sjg case 's':
3176 1.299 rillig if (p[1] == 'h' && (p[2] == st.endc || p[2] == ':')) {
3177 1.268 rillig if (st.eflags & VARE_WANTRES) {
3178 1.416 rillig const char *errfmt;
3179 1.416 rillig st.newVal = Cmd_Exec(st.val, &errfmt);
3180 1.416 rillig if (errfmt)
3181 1.416 rillig Error(errfmt, st.val);
3182 1.197 sjg } else
3183 1.349 rillig st.newVal = varNoError;
3184 1.409 rillig p += 2;
3185 1.356 rillig res = AMR_OK;
3186 1.356 rillig } else
3187 1.356 rillig res = AMR_UNKNOWN;
3188 1.356 rillig break;
3189 1.108 sjg #endif
3190 1.108 sjg default:
3191 1.356 rillig res = AMR_UNKNOWN;
3192 1.356 rillig }
3193 1.356 rillig
3194 1.108 sjg #ifdef SYSVVARSUB
3195 1.409 rillig if (res == AMR_UNKNOWN) {
3196 1.409 rillig assert(p == mod);
3197 1.409 rillig res = ApplyModifier_SysV(&p, &st);
3198 1.409 rillig }
3199 1.108 sjg #endif
3200 1.356 rillig
3201 1.356 rillig if (res == AMR_UNKNOWN) {
3202 1.409 rillig Error("Unknown modifier '%c'", *mod);
3203 1.409 rillig for (p++; *p != ':' && *p != st.endc && *p != '\0'; p++)
3204 1.409 rillig continue;
3205 1.356 rillig st.newVal = var_Error;
3206 1.356 rillig }
3207 1.356 rillig if (res == AMR_CLEANUP)
3208 1.356 rillig goto cleanup;
3209 1.356 rillig if (res == AMR_BAD)
3210 1.356 rillig goto bad_modifier;
3211 1.356 rillig
3212 1.430 rillig if (DEBUG(VAR)) {
3213 1.430 rillig char eflags_str[VarEvalFlags_ToStringSize];
3214 1.430 rillig char vflags_str[VarFlags_ToStringSize];
3215 1.431 rillig const char *q = st.newVal == var_Error ? "" : "\"";
3216 1.431 rillig const char *newVal = st.newVal == var_Error ? "error" : st.newVal;
3217 1.430 rillig
3218 1.431 rillig VAR_DEBUG("Result of ${%s:%.*s} is %s%s%s "
3219 1.430 rillig "(eflags = %s, vflags = %s)\n",
3220 1.431 rillig st.v->name, (int)(p - mod), mod, q, newVal, q,
3221 1.430 rillig Enum_ToString(eflags_str, sizeof eflags_str, st.eflags,
3222 1.430 rillig VarEvalFlags_ToStringSpecs),
3223 1.430 rillig Enum_ToString(vflags_str, sizeof vflags_str, st.v->flags,
3224 1.430 rillig VarFlags_ToStringSpecs));
3225 1.430 rillig }
3226 1.25 christos
3227 1.349 rillig if (st.newVal != st.val) {
3228 1.344 rillig if (*freePtr) {
3229 1.349 rillig free(st.val);
3230 1.344 rillig *freePtr = NULL;
3231 1.108 sjg }
3232 1.349 rillig st.val = st.newVal;
3233 1.349 rillig if (st.val != var_Error && st.val != varNoError) {
3234 1.349 rillig *freePtr = st.val;
3235 1.108 sjg }
3236 1.108 sjg }
3237 1.409 rillig if (*p == '\0' && st.endc != '\0') {
3238 1.246 rillig Error("Unclosed variable specification (expecting '%c') "
3239 1.417 rillig "for \"%s\" (value \"%s\") modifier %c",
3240 1.417 rillig st.endc, st.v->name, st.val, *mod);
3241 1.409 rillig } else if (*p == ':') {
3242 1.409 rillig p++;
3243 1.108 sjg }
3244 1.409 rillig mod = p;
3245 1.108 sjg }
3246 1.240 rillig out:
3247 1.367 rillig *pp = p;
3248 1.349 rillig return st.val;
3249 1.25 christos
3250 1.240 rillig bad_modifier:
3251 1.299 rillig Error("Bad modifier `:%.*s' for %s",
3252 1.409 rillig (int)strcspn(mod, ":)}"), mod, st.v->name);
3253 1.25 christos
3254 1.240 rillig cleanup:
3255 1.409 rillig *pp = p;
3256 1.298 rillig if (st.missing_delim != '\0')
3257 1.428 rillig Error("Unfinished modifier for %s ('%c' missing)",
3258 1.298 rillig st.v->name, st.missing_delim);
3259 1.344 rillig free(*freePtr);
3260 1.344 rillig *freePtr = NULL;
3261 1.231 rillig return var_Error;
3262 1.108 sjg }
3263 1.25 christos
3264 1.335 rillig static Boolean
3265 1.335 rillig VarIsDynamic(GNode *ctxt, const char *varname, size_t namelen)
3266 1.335 rillig {
3267 1.335 rillig if ((namelen == 1 ||
3268 1.335 rillig (namelen == 2 && (varname[1] == 'F' || varname[1] == 'D'))) &&
3269 1.335 rillig (ctxt == VAR_CMD || ctxt == VAR_GLOBAL))
3270 1.335 rillig {
3271 1.335 rillig /*
3272 1.335 rillig * If substituting a local variable in a non-local context,
3273 1.335 rillig * assume it's for dynamic source stuff. We have to handle
3274 1.335 rillig * this specially and return the longhand for the variable
3275 1.335 rillig * with the dollar sign escaped so it makes it back to the
3276 1.335 rillig * caller. Only four of the local variables are treated
3277 1.335 rillig * specially as they are the only four that will be set
3278 1.335 rillig * when dynamic sources are expanded.
3279 1.335 rillig */
3280 1.335 rillig switch (varname[0]) {
3281 1.335 rillig case '@':
3282 1.335 rillig case '%':
3283 1.335 rillig case '*':
3284 1.335 rillig case '!':
3285 1.335 rillig return TRUE;
3286 1.335 rillig }
3287 1.335 rillig return FALSE;
3288 1.335 rillig }
3289 1.335 rillig
3290 1.336 rillig if ((namelen == 7 || namelen == 8) && varname[0] == '.' &&
3291 1.417 rillig isupper((unsigned char)varname[1]) &&
3292 1.335 rillig (ctxt == VAR_CMD || ctxt == VAR_GLOBAL))
3293 1.335 rillig {
3294 1.335 rillig return strcmp(varname, ".TARGET") == 0 ||
3295 1.417 rillig strcmp(varname, ".ARCHIVE") == 0 ||
3296 1.417 rillig strcmp(varname, ".PREFIX") == 0 ||
3297 1.417 rillig strcmp(varname, ".MEMBER") == 0;
3298 1.335 rillig }
3299 1.335 rillig
3300 1.335 rillig return FALSE;
3301 1.335 rillig }
3302 1.335 rillig
3303 1.108 sjg /*-
3304 1.108 sjg *-----------------------------------------------------------------------
3305 1.108 sjg * Var_Parse --
3306 1.328 rillig * Given the start of a variable invocation (such as $v, $(VAR),
3307 1.328 rillig * ${VAR:Mpattern}), extract the variable name, possibly some
3308 1.328 rillig * modifiers and find its value by applying the modifiers to the
3309 1.328 rillig * original value.
3310 1.108 sjg *
3311 1.108 sjg * Input:
3312 1.108 sjg * str The string to parse
3313 1.108 sjg * ctxt The context for the variable
3314 1.259 rillig * flags VARE_UNDEFERR if undefineds are an error
3315 1.259 rillig * VARE_WANTRES if we actually want the result
3316 1.259 rillig * VARE_ASSIGN if we are in a := assignment
3317 1.108 sjg * lengthPtr OUT: The length of the specification
3318 1.121 apb * freePtr OUT: Non-NULL if caller should free *freePtr
3319 1.108 sjg *
3320 1.108 sjg * Results:
3321 1.429 rillig * The value of the variable expression or var_Error if the
3322 1.108 sjg * specification is invalid. The length of the specification is
3323 1.108 sjg * placed in *lengthPtr (for invalid specifications, this is just
3324 1.108 sjg * 2...?).
3325 1.121 apb * If *freePtr is non-NULL then it's a pointer that the caller
3326 1.121 apb * should pass to free() to free memory used by the result.
3327 1.108 sjg *
3328 1.108 sjg * Side Effects:
3329 1.429 rillig * Any effects from the modifiers, such as :!cmd! or ::=value.
3330 1.108 sjg *-----------------------------------------------------------------------
3331 1.108 sjg */
3332 1.108 sjg /* coverity[+alloc : arg-*4] */
3333 1.331 rillig const char *
3334 1.333 rillig Var_Parse(const char * const str, GNode *ctxt, VarEvalFlags eflags,
3335 1.202 christos int *lengthPtr, void **freePtr)
3336 1.108 sjg {
3337 1.240 rillig const char *tstr; /* Pointer into str */
3338 1.240 rillig Boolean haveModifier; /* TRUE if have modifiers for the variable */
3339 1.429 rillig char startc; /* Starting character if variable in parens
3340 1.401 rillig * or braces */
3341 1.429 rillig char endc; /* Ending character if variable in parens
3342 1.108 sjg * or braces */
3343 1.240 rillig Boolean dynamic; /* TRUE if the variable is local and we're
3344 1.108 sjg * expanding it in a non-local context. This
3345 1.108 sjg * is done to support dynamic sources. The
3346 1.108 sjg * result is just the invocation, unaltered */
3347 1.412 rillig const char *extramodifiers;
3348 1.412 rillig Var *v;
3349 1.412 rillig char *nstr;
3350 1.432 rillig char eflags_str[VarEvalFlags_ToStringSize];
3351 1.432 rillig
3352 1.432 rillig VAR_DEBUG("%s: %s with %s\n", __func__, str,
3353 1.432 rillig Enum_ToString(eflags_str, sizeof eflags_str, eflags,
3354 1.432 rillig VarEvalFlags_ToStringSpecs));
3355 1.1 cgd
3356 1.108 sjg *freePtr = NULL;
3357 1.412 rillig extramodifiers = NULL; /* extra modifiers to apply first */
3358 1.108 sjg dynamic = FALSE;
3359 1.1 cgd
3360 1.141 dsl startc = str[1];
3361 1.141 dsl if (startc != PROPEN && startc != BROPEN) {
3362 1.417 rillig char name[2];
3363 1.412 rillig
3364 1.108 sjg /*
3365 1.108 sjg * If it's not bounded by braces of some sort, life is much simpler.
3366 1.108 sjg * We just need to check for the first character and return the
3367 1.108 sjg * value if it exists.
3368 1.108 sjg */
3369 1.15 christos
3370 1.141 dsl /* Error out some really stupid names */
3371 1.141 dsl if (startc == '\0' || strchr(")}:$", startc)) {
3372 1.141 dsl *lengthPtr = 1;
3373 1.141 dsl return var_Error;
3374 1.141 dsl }
3375 1.16 christos
3376 1.412 rillig name[0] = startc;
3377 1.412 rillig name[1] = '\0';
3378 1.108 sjg v = VarFind(name, ctxt, FIND_ENV | FIND_GLOBAL | FIND_CMD);
3379 1.136 dsl if (v == NULL) {
3380 1.108 sjg *lengthPtr = 2;
3381 1.1 cgd
3382 1.381 rillig if (ctxt == VAR_CMD || ctxt == VAR_GLOBAL) {
3383 1.108 sjg /*
3384 1.108 sjg * If substituting a local variable in a non-local context,
3385 1.108 sjg * assume it's for dynamic source stuff. We have to handle
3386 1.108 sjg * this specially and return the longhand for the variable
3387 1.108 sjg * with the dollar sign escaped so it makes it back to the
3388 1.108 sjg * caller. Only four of the local variables are treated
3389 1.108 sjg * specially as they are the only four that will be set
3390 1.108 sjg * when dynamic sources are expanded.
3391 1.108 sjg */
3392 1.108 sjg switch (str[1]) {
3393 1.242 rillig case '@':
3394 1.331 rillig return "$(.TARGET)";
3395 1.242 rillig case '%':
3396 1.331 rillig return "$(.MEMBER)";
3397 1.242 rillig case '*':
3398 1.331 rillig return "$(.PREFIX)";
3399 1.242 rillig case '!':
3400 1.331 rillig return "$(.ARCHIVE)";
3401 1.108 sjg }
3402 1.108 sjg }
3403 1.333 rillig return (eflags & VARE_UNDEFERR) ? var_Error : varNoError;
3404 1.108 sjg } else {
3405 1.108 sjg haveModifier = FALSE;
3406 1.325 rillig tstr = str + 1;
3407 1.108 sjg }
3408 1.123 apb } else {
3409 1.412 rillig Buffer namebuf; /* Holds the variable name */
3410 1.412 rillig int depth;
3411 1.412 rillig size_t namelen;
3412 1.412 rillig char *varname;
3413 1.412 rillig
3414 1.388 rillig endc = startc == PROPEN ? PRCLOSE : BRCLOSE;
3415 1.388 rillig
3416 1.433 rillig Buf_Init(&namebuf, 0);
3417 1.1 cgd
3418 1.108 sjg /*
3419 1.108 sjg * Skip to the end character or a colon, whichever comes first.
3420 1.108 sjg */
3421 1.412 rillig depth = 1;
3422 1.249 rillig for (tstr = str + 2; *tstr != '\0'; tstr++) {
3423 1.240 rillig /* Track depth so we can spot parse errors. */
3424 1.240 rillig if (*tstr == startc)
3425 1.185 sjg depth++;
3426 1.185 sjg if (*tstr == endc) {
3427 1.185 sjg if (--depth == 0)
3428 1.185 sjg break;
3429 1.185 sjg }
3430 1.429 rillig if (*tstr == ':' && depth == 1)
3431 1.185 sjg break;
3432 1.240 rillig /* A variable inside a variable, expand. */
3433 1.108 sjg if (*tstr == '$') {
3434 1.127 christos int rlen;
3435 1.108 sjg void *freeIt;
3436 1.417 rillig const char *rval = Var_Parse(tstr, ctxt, eflags, &rlen,
3437 1.417 rillig &freeIt);
3438 1.240 rillig if (rval != NULL)
3439 1.332 rillig Buf_AddStr(&namebuf, rval);
3440 1.196 christos free(freeIt);
3441 1.108 sjg tstr += rlen - 1;
3442 1.242 rillig } else
3443 1.332 rillig Buf_AddByte(&namebuf, *tstr);
3444 1.108 sjg }
3445 1.108 sjg if (*tstr == ':') {
3446 1.108 sjg haveModifier = TRUE;
3447 1.185 sjg } else if (*tstr == endc) {
3448 1.108 sjg haveModifier = FALSE;
3449 1.108 sjg } else {
3450 1.353 rillig Parse_Error(PARSE_FATAL, "Unclosed variable \"%s\"",
3451 1.433 rillig Buf_GetAll(&namebuf, NULL));
3452 1.108 sjg /*
3453 1.108 sjg * If we never did find the end character, return NULL
3454 1.108 sjg * right now, setting the length to be the distance to
3455 1.108 sjg * the end of the string, since that's what make does.
3456 1.108 sjg */
3457 1.108 sjg *lengthPtr = tstr - str;
3458 1.332 rillig Buf_Destroy(&namebuf, TRUE);
3459 1.231 rillig return var_Error;
3460 1.108 sjg }
3461 1.325 rillig
3462 1.433 rillig varname = Buf_GetAll(&namebuf, &namelen);
3463 1.93 sjg
3464 1.123 apb /*
3465 1.325 rillig * At this point, varname points into newly allocated memory from
3466 1.332 rillig * namebuf, containing only the name of the variable.
3467 1.123 apb *
3468 1.123 apb * start and tstr point into the const string that was pointed
3469 1.123 apb * to by the original value of the str parameter. start points
3470 1.123 apb * to the '$' at the beginning of the string, while tstr points
3471 1.123 apb * to the char just after the end of the variable name -- this
3472 1.123 apb * will be '\0', ':', PRCLOSE, or BRCLOSE.
3473 1.123 apb */
3474 1.123 apb
3475 1.325 rillig v = VarFind(varname, ctxt, FIND_ENV | FIND_GLOBAL | FIND_CMD);
3476 1.141 dsl /*
3477 1.141 dsl * Check also for bogus D and F forms of local variables since we're
3478 1.141 dsl * in a local context and the name is the right length.
3479 1.141 dsl */
3480 1.325 rillig if (v == NULL && ctxt != VAR_CMD && ctxt != VAR_GLOBAL &&
3481 1.417 rillig namelen == 2 && (varname[1] == 'F' || varname[1] == 'D') &&
3482 1.417 rillig strchr("@%?*!<>", varname[0]) != NULL)
3483 1.417 rillig {
3484 1.108 sjg /*
3485 1.141 dsl * Well, it's local -- go look for it.
3486 1.108 sjg */
3487 1.417 rillig char name[] = { varname[0], '\0' };
3488 1.141 dsl v = VarFind(name, ctxt, 0);
3489 1.15 christos
3490 1.141 dsl if (v != NULL) {
3491 1.325 rillig if (varname[1] == 'D') {
3492 1.240 rillig extramodifiers = "H:";
3493 1.242 rillig } else { /* F */
3494 1.240 rillig extramodifiers = "T:";
3495 1.1 cgd }
3496 1.1 cgd }
3497 1.108 sjg }
3498 1.108 sjg
3499 1.136 dsl if (v == NULL) {
3500 1.335 rillig dynamic = VarIsDynamic(ctxt, varname, namelen);
3501 1.15 christos
3502 1.108 sjg if (!haveModifier) {
3503 1.108 sjg /*
3504 1.108 sjg * No modifiers -- have specification length so we can return
3505 1.108 sjg * now.
3506 1.108 sjg */
3507 1.327 rillig *lengthPtr = tstr - str + 1;
3508 1.108 sjg if (dynamic) {
3509 1.327 rillig char *pstr = bmake_strndup(str, *lengthPtr);
3510 1.108 sjg *freePtr = pstr;
3511 1.332 rillig Buf_Destroy(&namebuf, TRUE);
3512 1.231 rillig return pstr;
3513 1.40 sjg } else {
3514 1.332 rillig Buf_Destroy(&namebuf, TRUE);
3515 1.333 rillig return (eflags & VARE_UNDEFERR) ? var_Error : varNoError;
3516 1.40 sjg }
3517 1.1 cgd } else {
3518 1.108 sjg /*
3519 1.108 sjg * Still need to get to the end of the variable specification,
3520 1.108 sjg * so kludge up a Var structure for the modifications
3521 1.108 sjg */
3522 1.134 joerg v = bmake_malloc(sizeof(Var));
3523 1.325 rillig v->name = varname;
3524 1.433 rillig Buf_Init(&v->val, 1);
3525 1.108 sjg v->flags = VAR_JUNK;
3526 1.332 rillig Buf_Destroy(&namebuf, FALSE);
3527 1.1 cgd }
3528 1.108 sjg } else
3529 1.332 rillig Buf_Destroy(&namebuf, TRUE);
3530 1.108 sjg }
3531 1.108 sjg
3532 1.188 joerg if (v->flags & VAR_IN_USE) {
3533 1.188 joerg Fatal("Variable %s is recursive.", v->name);
3534 1.188 joerg /*NOTREACHED*/
3535 1.188 joerg } else {
3536 1.188 joerg v->flags |= VAR_IN_USE;
3537 1.188 joerg }
3538 1.401 rillig
3539 1.188 joerg /*
3540 1.188 joerg * Before doing any modification, we have to make sure the value
3541 1.188 joerg * has been fully expanded. If it looks like recursion might be
3542 1.188 joerg * necessary (there's a dollar sign somewhere in the variable's value)
3543 1.188 joerg * we just call Var_Subst to do any other substitutions that are
3544 1.188 joerg * necessary. Note that the value returned by Var_Subst will have
3545 1.188 joerg * been dynamically-allocated, so it will need freeing when we
3546 1.188 joerg * return.
3547 1.188 joerg */
3548 1.433 rillig nstr = Buf_GetAll(&v->val, NULL);
3549 1.333 rillig if (strchr(nstr, '$') != NULL && (eflags & VARE_WANTRES) != 0) {
3550 1.352 rillig nstr = Var_Subst(nstr, ctxt, eflags);
3551 1.188 joerg *freePtr = nstr;
3552 1.188 joerg }
3553 1.187 christos
3554 1.188 joerg v->flags &= ~VAR_IN_USE;
3555 1.108 sjg
3556 1.240 rillig if (nstr != NULL && (haveModifier || extramodifiers != NULL)) {
3557 1.191 dholland void *extraFree;
3558 1.108 sjg
3559 1.191 dholland extraFree = NULL;
3560 1.191 dholland if (extramodifiers != NULL) {
3561 1.367 rillig const char *em = extramodifiers;
3562 1.367 rillig nstr = ApplyModifiers(&em, nstr, '(', ')',
3563 1.367 rillig v, ctxt, eflags, &extraFree);
3564 1.191 dholland }
3565 1.191 dholland
3566 1.191 dholland if (haveModifier) {
3567 1.240 rillig /* Skip initial colon. */
3568 1.240 rillig tstr++;
3569 1.191 dholland
3570 1.367 rillig nstr = ApplyModifiers(&tstr, nstr, startc, endc,
3571 1.367 rillig v, ctxt, eflags, freePtr);
3572 1.240 rillig free(extraFree);
3573 1.191 dholland } else {
3574 1.240 rillig *freePtr = extraFree;
3575 1.191 dholland }
3576 1.119 sjg }
3577 1.327 rillig *lengthPtr = tstr - str + (*tstr ? 1 : 0);
3578 1.15 christos
3579 1.1 cgd if (v->flags & VAR_FROM_ENV) {
3580 1.433 rillig Boolean destroy = nstr != Buf_GetAll(&v->val, NULL);
3581 1.366 rillig if (!destroy) {
3582 1.1 cgd /*
3583 1.1 cgd * Returning the value unmodified, so tell the caller to free
3584 1.1 cgd * the thing.
3585 1.1 cgd */
3586 1.104 christos *freePtr = nstr;
3587 1.1 cgd }
3588 1.366 rillig (void)VarFreeEnv(v, destroy);
3589 1.1 cgd } else if (v->flags & VAR_JUNK) {
3590 1.1 cgd /*
3591 1.121 apb * Perform any free'ing needed and set *freePtr to NULL so the caller
3592 1.1 cgd * doesn't try to free a static pointer.
3593 1.325 rillig * If VAR_KEEP is also set then we want to keep str(?) as is.
3594 1.1 cgd */
3595 1.58 itojun if (!(v->flags & VAR_KEEP)) {
3596 1.366 rillig if (*freePtr != NULL) {
3597 1.366 rillig free(*freePtr);
3598 1.108 sjg *freePtr = NULL;
3599 1.40 sjg }
3600 1.40 sjg if (dynamic) {
3601 1.327 rillig nstr = bmake_strndup(str, *lengthPtr);
3602 1.104 christos *freePtr = nstr;
3603 1.40 sjg } else {
3604 1.333 rillig nstr = (eflags & VARE_UNDEFERR) ? var_Error : varNoError;
3605 1.40 sjg }
3606 1.34 christos }
3607 1.433 rillig if (nstr != Buf_GetAll(&v->val, NULL))
3608 1.146 dsl Buf_Destroy(&v->val, TRUE);
3609 1.98 christos free(v->name);
3610 1.98 christos free(v);
3611 1.1 cgd }
3612 1.231 rillig return nstr;
3613 1.1 cgd }
3614 1.1 cgd
3615 1.1 cgd /*-
3616 1.1 cgd *-----------------------------------------------------------------------
3617 1.1 cgd * Var_Subst --
3618 1.250 rillig * Substitute for all variables in the given string in the given context.
3619 1.333 rillig * If eflags & VARE_UNDEFERR, Parse_Error will be called when an undefined
3620 1.1 cgd * variable is encountered.
3621 1.1 cgd *
3622 1.70 wiz * Input:
3623 1.70 wiz * var Named variable || NULL for all
3624 1.70 wiz * str the string which to substitute
3625 1.70 wiz * ctxt the context wherein to find variables
3626 1.333 rillig * eflags VARE_UNDEFERR if undefineds are an error
3627 1.259 rillig * VARE_WANTRES if we actually want the result
3628 1.259 rillig * VARE_ASSIGN if we are in a := assignment
3629 1.70 wiz *
3630 1.1 cgd * Results:
3631 1.1 cgd * The resulting string.
3632 1.1 cgd *
3633 1.1 cgd * Side Effects:
3634 1.400 rillig * Any effects from the modifiers, such as ::=, :sh or !cmd!,
3635 1.400 rillig * if eflags contains VARE_WANTRES.
3636 1.1 cgd *-----------------------------------------------------------------------
3637 1.1 cgd */
3638 1.1 cgd char *
3639 1.352 rillig Var_Subst(const char *str, GNode *ctxt, VarEvalFlags eflags)
3640 1.1 cgd {
3641 1.401 rillig Buffer buf; /* Buffer for forming things */
3642 1.412 rillig Boolean trailingBslash;
3643 1.1 cgd
3644 1.401 rillig /* Set true if an error has already been reported,
3645 1.401 rillig * to prevent a plethora of messages when recursing */
3646 1.401 rillig static Boolean errorReported;
3647 1.412 rillig
3648 1.433 rillig Buf_Init(&buf, 0);
3649 1.1 cgd errorReported = FALSE;
3650 1.412 rillig trailingBslash = FALSE; /* variable ends in \ */
3651 1.1 cgd
3652 1.1 cgd while (*str) {
3653 1.96 christos if (*str == '\n' && trailingBslash)
3654 1.146 dsl Buf_AddByte(&buf, ' ');
3655 1.381 rillig if (*str == '$' && str[1] == '$') {
3656 1.1 cgd /*
3657 1.381 rillig * A dollar sign may be escaped with another dollar sign.
3658 1.1 cgd * In such a case, we skip over the escape character and store the
3659 1.1 cgd * dollar sign into the buffer directly.
3660 1.1 cgd */
3661 1.333 rillig if (save_dollars && (eflags & VARE_ASSIGN))
3662 1.381 rillig Buf_AddByte(&buf, '$');
3663 1.381 rillig Buf_AddByte(&buf, '$');
3664 1.381 rillig str += 2;
3665 1.1 cgd } else if (*str != '$') {
3666 1.1 cgd /*
3667 1.1 cgd * Skip as many characters as possible -- either to the end of
3668 1.1 cgd * the string or to the next dollar sign (variable invocation).
3669 1.1 cgd */
3670 1.249 rillig const char *cp;
3671 1.1 cgd
3672 1.5 cgd for (cp = str++; *str != '$' && *str != '\0'; str++)
3673 1.5 cgd continue;
3674 1.313 rillig Buf_AddBytesBetween(&buf, cp, str);
3675 1.1 cgd } else {
3676 1.401 rillig int length;
3677 1.406 rillig void *freeIt;
3678 1.401 rillig const char *val = Var_Parse(str, ctxt, eflags, &length, &freeIt);
3679 1.1 cgd
3680 1.1 cgd /*
3681 1.1 cgd * When we come down here, val should either point to the
3682 1.1 cgd * value of this variable, suitably modified, or be NULL.
3683 1.1 cgd * Length should be the total length of the potential
3684 1.1 cgd * variable invocation (from $ to end character...)
3685 1.1 cgd */
3686 1.1 cgd if (val == var_Error || val == varNoError) {
3687 1.1 cgd /*
3688 1.1 cgd * If performing old-time variable substitution, skip over
3689 1.1 cgd * the variable and continue with the substitution. Otherwise,
3690 1.1 cgd * store the dollar sign and advance str so we continue with
3691 1.1 cgd * the string...
3692 1.1 cgd */
3693 1.1 cgd if (oldVars) {
3694 1.1 cgd str += length;
3695 1.333 rillig } else if ((eflags & VARE_UNDEFERR) || val == var_Error) {
3696 1.1 cgd /*
3697 1.1 cgd * If variable is undefined, complain and skip the
3698 1.1 cgd * variable. The complaint will stop us from doing anything
3699 1.1 cgd * when the file is parsed.
3700 1.1 cgd */
3701 1.1 cgd if (!errorReported) {
3702 1.231 rillig Parse_Error(PARSE_FATAL, "Undefined variable \"%.*s\"",
3703 1.231 rillig length, str);
3704 1.1 cgd }
3705 1.1 cgd str += length;
3706 1.1 cgd errorReported = TRUE;
3707 1.1 cgd } else {
3708 1.146 dsl Buf_AddByte(&buf, *str);
3709 1.1 cgd str += 1;
3710 1.1 cgd }
3711 1.1 cgd } else {
3712 1.412 rillig size_t val_len;
3713 1.412 rillig
3714 1.1 cgd str += length;
3715 1.15 christos
3716 1.412 rillig val_len = strlen(val);
3717 1.433 rillig Buf_AddBytes(&buf, val, val_len);
3718 1.388 rillig trailingBslash = val_len > 0 && val[val_len - 1] == '\\';
3719 1.104 christos }
3720 1.196 christos free(freeIt);
3721 1.196 christos freeIt = NULL;
3722 1.1 cgd }
3723 1.1 cgd }
3724 1.15 christos
3725 1.168 sjg return Buf_DestroyCompact(&buf);
3726 1.1 cgd }
3727 1.1 cgd
3728 1.250 rillig /* Initialize the module. */
3729 1.1 cgd void
3730 1.70 wiz Var_Init(void)
3731 1.1 cgd {
3732 1.184 sjg VAR_INTERNAL = Targ_NewGN("Internal");
3733 1.92 christos VAR_GLOBAL = Targ_NewGN("Global");
3734 1.92 christos VAR_CMD = Targ_NewGN("Command");
3735 1.6 jtc }
3736 1.6 jtc
3737 1.1 cgd
3738 1.6 jtc void
3739 1.70 wiz Var_End(void)
3740 1.6 jtc {
3741 1.286 sjg Var_Stats();
3742 1.286 sjg }
3743 1.286 sjg
3744 1.286 sjg void
3745 1.286 sjg Var_Stats(void)
3746 1.286 sjg {
3747 1.286 sjg Hash_DebugStats(&VAR_GLOBAL->context, "VAR_GLOBAL");
3748 1.1 cgd }
3749 1.15 christos
3750 1.1 cgd
3751 1.1 cgd /****************** PRINT DEBUGGING INFO *****************/
3752 1.36 mycroft static void
3753 1.241 rillig VarPrintVar(void *vp, void *data MAKE_ATTR_UNUSED)
3754 1.1 cgd {
3755 1.242 rillig Var *v = (Var *)vp;
3756 1.433 rillig fprintf(debug_file, "%-16s = %s\n", v->name, Buf_GetAll(&v->val, NULL));
3757 1.1 cgd }
3758 1.1 cgd
3759 1.400 rillig /* Print all variables in a context, unordered. */
3760 1.5 cgd void
3761 1.70 wiz Var_Dump(GNode *ctxt)
3762 1.1 cgd {
3763 1.241 rillig Hash_ForEach(&ctxt->context, VarPrintVar, NULL);
3764 1.1 cgd }
3765