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