var.c revision 1.86 1 1.86 dsl /* $NetBSD: var.c,v 1.86 2004/01/24 19:58:54 dsl 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.23 lukem #ifdef MAKE_BOOTSTRAP
72 1.86 dsl static char rcsid[] = "$NetBSD: var.c,v 1.86 2004/01/24 19:58:54 dsl 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.86 dsl __RCSID("$NetBSD: var.c,v 1.86 2004/01/24 19:58:54 dsl 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.1 cgd * Var_Set Set the value of a variable in the given
90 1.1 cgd * context. The variable is created if it doesn't
91 1.1 cgd * yet exist. The value and variable name need not
92 1.1 cgd * be preserved.
93 1.1 cgd *
94 1.1 cgd * Var_Append Append more characters to an existing variable
95 1.1 cgd * in the given context. The variable needn't
96 1.1 cgd * exist already -- it will be created if it doesn't.
97 1.1 cgd * A space is placed between the old value and the
98 1.1 cgd * new one.
99 1.1 cgd *
100 1.1 cgd * Var_Exists See if a variable exists.
101 1.1 cgd *
102 1.1 cgd * Var_Value Return the value of a variable in a context or
103 1.1 cgd * NULL if the variable is undefined.
104 1.1 cgd *
105 1.5 cgd * Var_Subst Substitute named variable, or all variables if
106 1.5 cgd * NULL in a string using
107 1.1 cgd * the given context as the top-most one. If the
108 1.1 cgd * third argument is non-zero, Parse_Error is
109 1.1 cgd * called if any variables are undefined.
110 1.1 cgd *
111 1.1 cgd * Var_Parse Parse a variable expansion from a string and
112 1.1 cgd * return the result and the number of characters
113 1.1 cgd * consumed.
114 1.1 cgd *
115 1.1 cgd * Var_Delete Delete a variable in a context.
116 1.1 cgd *
117 1.1 cgd * Var_Init Initialize this module.
118 1.1 cgd *
119 1.1 cgd * Debugging:
120 1.1 cgd * Var_Dump Print out all variables defined in the given
121 1.1 cgd * context.
122 1.1 cgd *
123 1.1 cgd * XXX: There's a lot of duplication in these functions.
124 1.1 cgd */
125 1.1 cgd
126 1.31 gwr #ifndef NO_REGEX
127 1.28 wsanchez #include <sys/types.h>
128 1.16 christos #include <regex.h>
129 1.17 christos #endif
130 1.70 wiz #include <ctype.h>
131 1.17 christos #include <stdlib.h>
132 1.82 jmc #include <limits.h>
133 1.70 wiz
134 1.1 cgd #include "make.h"
135 1.1 cgd #include "buf.h"
136 1.1 cgd
137 1.1 cgd /*
138 1.1 cgd * This is a harmless return value for Var_Parse that can be used by Var_Subst
139 1.1 cgd * to determine if there was an error in parsing -- easier than returning
140 1.1 cgd * a flag, as things outside this module don't give a hoot.
141 1.1 cgd */
142 1.1 cgd char var_Error[] = "";
143 1.1 cgd
144 1.1 cgd /*
145 1.1 cgd * Similar to var_Error, but returned when the 'err' flag for Var_Parse is
146 1.1 cgd * set false. Why not just use a constant? Well, gcc likes to condense
147 1.1 cgd * identical string instances...
148 1.1 cgd */
149 1.5 cgd static char varNoError[] = "";
150 1.1 cgd
151 1.1 cgd /*
152 1.1 cgd * Internally, variables are contained in four different contexts.
153 1.1 cgd * 1) the environment. They may not be changed. If an environment
154 1.1 cgd * variable is appended-to, the result is placed in the global
155 1.1 cgd * context.
156 1.1 cgd * 2) the global context. Variables set in the Makefile are located in
157 1.1 cgd * the global context. It is the penultimate context searched when
158 1.1 cgd * substituting.
159 1.1 cgd * 3) the command-line context. All variables set on the command line
160 1.1 cgd * are placed in this context. They are UNALTERABLE once placed here.
161 1.1 cgd * 4) the local context. Each target has associated with it a context
162 1.1 cgd * list. On this list are located the structures describing such
163 1.1 cgd * local variables as $(@) and $(*)
164 1.1 cgd * The four contexts are searched in the reverse order from which they are
165 1.1 cgd * listed.
166 1.1 cgd */
167 1.1 cgd GNode *VAR_GLOBAL; /* variables from the makefile */
168 1.1 cgd GNode *VAR_CMD; /* variables defined on the command-line */
169 1.1 cgd
170 1.1 cgd #define FIND_CMD 0x1 /* look in VAR_CMD when searching */
171 1.1 cgd #define FIND_GLOBAL 0x2 /* look in VAR_GLOBAL as well */
172 1.1 cgd #define FIND_ENV 0x4 /* look in the environment also */
173 1.1 cgd
174 1.1 cgd typedef struct Var {
175 1.1 cgd char *name; /* the variable's name */
176 1.1 cgd Buffer val; /* its value */
177 1.1 cgd int flags; /* miscellaneous status flags */
178 1.1 cgd #define VAR_IN_USE 1 /* Variable's value currently being used.
179 1.1 cgd * Used to avoid recursion */
180 1.1 cgd #define VAR_FROM_ENV 2 /* Variable comes from the environment */
181 1.1 cgd #define VAR_JUNK 4 /* Variable is a junk variable that
182 1.1 cgd * should be destroyed when done with
183 1.1 cgd * it. Used by Var_Parse for undefined,
184 1.1 cgd * modified variables */
185 1.40 sjg #define VAR_KEEP 8 /* Variable is VAR_JUNK, but we found
186 1.40 sjg * a use for it in some modifier and
187 1.40 sjg * the value is therefore valid */
188 1.1 cgd } Var;
189 1.1 cgd
190 1.16 christos
191 1.16 christos /* Var*Pattern flags */
192 1.16 christos #define VAR_SUB_GLOBAL 0x01 /* Apply substitution globally */
193 1.16 christos #define VAR_SUB_ONE 0x02 /* Apply substitution to one word */
194 1.16 christos #define VAR_SUB_MATCHED 0x04 /* There was a match */
195 1.16 christos #define VAR_MATCH_START 0x08 /* Match at start of word */
196 1.16 christos #define VAR_MATCH_END 0x10 /* Match at end of word */
197 1.40 sjg #define VAR_NOSUBST 0x20 /* don't expand vars in VarGetPattern */
198 1.16 christos
199 1.65 sjg /* Var_Set flags */
200 1.65 sjg #define VAR_NO_EXPORT 0x01 /* do not export */
201 1.65 sjg
202 1.5 cgd typedef struct {
203 1.81 sjg /*
204 1.81 sjg * The following fields are set by Var_Parse() when it
205 1.81 sjg * encounters modifiers that need to keep state for use by
206 1.81 sjg * subsequent modifiers within the same variable expansion.
207 1.81 sjg */
208 1.81 sjg Byte varSpace; /* Word separator in expansions */
209 1.81 sjg Boolean oneBigWord; /* TRUE if we will treat the variable as a
210 1.81 sjg * single big word, even if it contains
211 1.81 sjg * embedded spaces (as opposed to the
212 1.81 sjg * usual behaviour of treating it as
213 1.81 sjg * several space-separated words). */
214 1.81 sjg } Var_Parse_State;
215 1.81 sjg
216 1.81 sjg /* struct passed as ClientData to VarSubstitute() for ":S/lhs/rhs/",
217 1.81 sjg * to VarSYSVMatch() for ":lhs=rhs". */
218 1.81 sjg typedef struct {
219 1.73 christos const char *lhs; /* String to match */
220 1.73 christos int leftLen; /* Length of string */
221 1.73 christos const char *rhs; /* Replacement string (w/ &'s removed) */
222 1.5 cgd int rightLen; /* Length of replacement */
223 1.5 cgd int flags;
224 1.5 cgd } VarPattern;
225 1.5 cgd
226 1.81 sjg /* struct passed as ClientData to VarLoopExpand() for ":@tvar@str@" */
227 1.41 sjg typedef struct {
228 1.41 sjg GNode *ctxt; /* variable context */
229 1.41 sjg char *tvar; /* name of temp var */
230 1.41 sjg int tvarLen;
231 1.41 sjg char *str; /* string to expand */
232 1.41 sjg int strLen;
233 1.41 sjg int err; /* err for not defined */
234 1.41 sjg } VarLoop_t;
235 1.41 sjg
236 1.31 gwr #ifndef NO_REGEX
237 1.81 sjg /* struct passed as ClientData to VarRESubstitute() for ":C///" */
238 1.16 christos typedef struct {
239 1.16 christos regex_t re;
240 1.16 christos int nsub;
241 1.16 christos regmatch_t *matches;
242 1.16 christos char *replace;
243 1.16 christos int flags;
244 1.16 christos } VarREPattern;
245 1.17 christos #endif
246 1.16 christos
247 1.81 sjg /* struct passed to VarSelectWords() for ":[start..end]" */
248 1.81 sjg typedef struct {
249 1.81 sjg int start; /* first word to select */
250 1.81 sjg int end; /* last word to select */
251 1.81 sjg } VarSelectWords_t;
252 1.81 sjg
253 1.73 christos static Var *VarFind(const char *, GNode *, int);
254 1.73 christos static void VarAdd(const char *, const char *, GNode *);
255 1.81 sjg static Boolean VarHead(GNode *, Var_Parse_State *,
256 1.81 sjg char *, Boolean, Buffer, ClientData);
257 1.81 sjg static Boolean VarTail(GNode *, Var_Parse_State *,
258 1.81 sjg char *, Boolean, Buffer, ClientData);
259 1.81 sjg static Boolean VarSuffix(GNode *, Var_Parse_State *,
260 1.81 sjg char *, Boolean, Buffer, ClientData);
261 1.81 sjg static Boolean VarRoot(GNode *, Var_Parse_State *,
262 1.81 sjg char *, Boolean, Buffer, ClientData);
263 1.81 sjg static Boolean VarMatch(GNode *, Var_Parse_State *,
264 1.81 sjg char *, Boolean, Buffer, ClientData);
265 1.13 christos #ifdef SYSVVARSUB
266 1.81 sjg static Boolean VarSYSVMatch(GNode *, Var_Parse_State *,
267 1.81 sjg char *, Boolean, Buffer, ClientData);
268 1.13 christos #endif
269 1.81 sjg static Boolean VarNoMatch(GNode *, Var_Parse_State *,
270 1.81 sjg char *, Boolean, Buffer, ClientData);
271 1.31 gwr #ifndef NO_REGEX
272 1.70 wiz static void VarREError(int, regex_t *, const char *);
273 1.81 sjg static Boolean VarRESubstitute(GNode *, Var_Parse_State *,
274 1.81 sjg char *, Boolean, Buffer, ClientData);
275 1.17 christos #endif
276 1.81 sjg static Boolean VarSubstitute(GNode *, Var_Parse_State *,
277 1.81 sjg char *, Boolean, Buffer, ClientData);
278 1.81 sjg static Boolean VarLoopExpand(GNode *, Var_Parse_State *,
279 1.81 sjg char *, Boolean, Buffer, ClientData);
280 1.81 sjg static char *VarGetPattern(GNode *, Var_Parse_State *,
281 1.81 sjg int, const char **, int, int *, int *,
282 1.70 wiz VarPattern *);
283 1.70 wiz static char *VarQuote(char *);
284 1.70 wiz static char *VarChangeCase(char *, int);
285 1.81 sjg static char *VarModify(GNode *, Var_Parse_State *,
286 1.81 sjg const char *,
287 1.81 sjg Boolean (*)(GNode *, Var_Parse_State *, char *, Boolean, Buffer, ClientData),
288 1.73 christos ClientData);
289 1.73 christos static char *VarSort(const char *);
290 1.73 christos static char *VarUniq(const char *);
291 1.70 wiz static int VarWordCompare(const void *, const void *);
292 1.70 wiz static void VarPrintVar(ClientData);
293 1.1 cgd
294 1.73 christos #define WR(a) ((char *)UNCONST(a))
295 1.73 christos
296 1.1 cgd /*-
297 1.1 cgd *-----------------------------------------------------------------------
298 1.1 cgd * VarFind --
299 1.1 cgd * Find the given variable in the given context and any other contexts
300 1.1 cgd * indicated.
301 1.1 cgd *
302 1.70 wiz * Input:
303 1.70 wiz * name name to find
304 1.70 wiz * ctxt context in which to find it
305 1.70 wiz * flags FIND_GLOBAL set means to look in the
306 1.70 wiz * VAR_GLOBAL context as well. FIND_CMD set means
307 1.70 wiz * to look in the VAR_CMD context also. FIND_ENV
308 1.70 wiz * set means to look in the environment
309 1.70 wiz *
310 1.1 cgd * Results:
311 1.1 cgd * A pointer to the structure describing the desired variable or
312 1.1 cgd * NIL if the variable does not exist.
313 1.1 cgd *
314 1.1 cgd * Side Effects:
315 1.1 cgd * None
316 1.1 cgd *-----------------------------------------------------------------------
317 1.1 cgd */
318 1.1 cgd static Var *
319 1.73 christos VarFind(const char *name, GNode *ctxt, int flags)
320 1.1 cgd {
321 1.36 mycroft Hash_Entry *var;
322 1.1 cgd Var *v;
323 1.1 cgd
324 1.1 cgd /*
325 1.1 cgd * If the variable name begins with a '.', it could very well be one of
326 1.1 cgd * the local ones. We check the name against all the local variables
327 1.1 cgd * and substitute the short version in for 'name' if it matches one of
328 1.1 cgd * them.
329 1.1 cgd */
330 1.6 jtc if (*name == '.' && isupper((unsigned char) name[1]))
331 1.1 cgd switch (name[1]) {
332 1.1 cgd case 'A':
333 1.1 cgd if (!strcmp(name, ".ALLSRC"))
334 1.1 cgd name = ALLSRC;
335 1.1 cgd if (!strcmp(name, ".ARCHIVE"))
336 1.1 cgd name = ARCHIVE;
337 1.1 cgd break;
338 1.1 cgd case 'I':
339 1.1 cgd if (!strcmp(name, ".IMPSRC"))
340 1.1 cgd name = IMPSRC;
341 1.1 cgd break;
342 1.1 cgd case 'M':
343 1.1 cgd if (!strcmp(name, ".MEMBER"))
344 1.1 cgd name = MEMBER;
345 1.1 cgd break;
346 1.1 cgd case 'O':
347 1.1 cgd if (!strcmp(name, ".OODATE"))
348 1.1 cgd name = OODATE;
349 1.1 cgd break;
350 1.1 cgd case 'P':
351 1.1 cgd if (!strcmp(name, ".PREFIX"))
352 1.1 cgd name = PREFIX;
353 1.1 cgd break;
354 1.1 cgd case 'T':
355 1.1 cgd if (!strcmp(name, ".TARGET"))
356 1.1 cgd name = TARGET;
357 1.1 cgd break;
358 1.1 cgd }
359 1.1 cgd /*
360 1.1 cgd * First look for the variable in the given context. If it's not there,
361 1.1 cgd * look for it in VAR_CMD, VAR_GLOBAL and the environment, in that order,
362 1.1 cgd * depending on the FIND_* flags in 'flags'
363 1.1 cgd */
364 1.36 mycroft var = Hash_FindEntry (&ctxt->context, name);
365 1.1 cgd
366 1.36 mycroft if ((var == NULL) && (flags & FIND_CMD) && (ctxt != VAR_CMD)) {
367 1.36 mycroft var = Hash_FindEntry (&VAR_CMD->context, name);
368 1.1 cgd }
369 1.36 mycroft if (!checkEnvFirst && (var == NULL) && (flags & FIND_GLOBAL) &&
370 1.1 cgd (ctxt != VAR_GLOBAL))
371 1.1 cgd {
372 1.36 mycroft var = Hash_FindEntry (&VAR_GLOBAL->context, name);
373 1.1 cgd }
374 1.36 mycroft if ((var == NULL) && (flags & FIND_ENV)) {
375 1.1 cgd char *env;
376 1.1 cgd
377 1.1 cgd if ((env = getenv (name)) != NULL) {
378 1.1 cgd int len;
379 1.15 christos
380 1.1 cgd v = (Var *) emalloc(sizeof(Var));
381 1.14 christos v->name = estrdup(name);
382 1.1 cgd
383 1.1 cgd len = strlen(env);
384 1.15 christos
385 1.1 cgd v->val = Buf_Init(len);
386 1.1 cgd Buf_AddBytes(v->val, len, (Byte *)env);
387 1.15 christos
388 1.1 cgd v->flags = VAR_FROM_ENV;
389 1.1 cgd return (v);
390 1.1 cgd } else if (checkEnvFirst && (flags & FIND_GLOBAL) &&
391 1.1 cgd (ctxt != VAR_GLOBAL))
392 1.1 cgd {
393 1.36 mycroft var = Hash_FindEntry (&VAR_GLOBAL->context, name);
394 1.36 mycroft if (var == NULL) {
395 1.1 cgd return ((Var *) NIL);
396 1.1 cgd } else {
397 1.36 mycroft return ((Var *)Hash_GetValue(var));
398 1.1 cgd }
399 1.1 cgd } else {
400 1.1 cgd return((Var *)NIL);
401 1.1 cgd }
402 1.36 mycroft } else if (var == NULL) {
403 1.1 cgd return ((Var *) NIL);
404 1.1 cgd } else {
405 1.36 mycroft return ((Var *) Hash_GetValue(var));
406 1.1 cgd }
407 1.1 cgd }
408 1.1 cgd
409 1.1 cgd /*-
410 1.1 cgd *-----------------------------------------------------------------------
411 1.1 cgd * VarAdd --
412 1.1 cgd * Add a new variable of name name and value val to the given context
413 1.1 cgd *
414 1.70 wiz * Input:
415 1.70 wiz * name name of variable to add
416 1.70 wiz * val value to set it to
417 1.70 wiz * ctxt context in which to set it
418 1.70 wiz *
419 1.1 cgd * Results:
420 1.1 cgd * None
421 1.1 cgd *
422 1.1 cgd * Side Effects:
423 1.1 cgd * The new variable is placed at the front of the given context
424 1.1 cgd * The name and val arguments are duplicated so they may
425 1.1 cgd * safely be freed.
426 1.1 cgd *-----------------------------------------------------------------------
427 1.1 cgd */
428 1.5 cgd static void
429 1.73 christos VarAdd(const char *name, const char *val, GNode *ctxt)
430 1.1 cgd {
431 1.70 wiz Var *v;
432 1.1 cgd int len;
433 1.70 wiz Hash_Entry *h;
434 1.1 cgd
435 1.1 cgd v = (Var *) emalloc (sizeof (Var));
436 1.1 cgd
437 1.5 cgd len = val ? strlen(val) : 0;
438 1.1 cgd v->val = Buf_Init(len+1);
439 1.73 christos Buf_AddBytes(v->val, len, (const Byte *)val);
440 1.1 cgd
441 1.1 cgd v->flags = 0;
442 1.1 cgd
443 1.36 mycroft h = Hash_CreateEntry (&ctxt->context, name, NULL);
444 1.36 mycroft Hash_SetValue(h, v);
445 1.37 sommerfe v->name = h->name;
446 1.1 cgd if (DEBUG(VAR)) {
447 1.1 cgd printf("%s:%s = %s\n", ctxt->name, name, val);
448 1.1 cgd }
449 1.1 cgd }
450 1.1 cgd
451 1.1 cgd /*-
452 1.1 cgd *-----------------------------------------------------------------------
453 1.1 cgd * Var_Delete --
454 1.1 cgd * Remove a variable from a context.
455 1.1 cgd *
456 1.1 cgd * Results:
457 1.1 cgd * None.
458 1.1 cgd *
459 1.1 cgd * Side Effects:
460 1.1 cgd * The Var structure is removed and freed.
461 1.1 cgd *
462 1.1 cgd *-----------------------------------------------------------------------
463 1.1 cgd */
464 1.1 cgd void
465 1.73 christos Var_Delete(const char *name, GNode *ctxt)
466 1.1 cgd {
467 1.36 mycroft Hash_Entry *ln;
468 1.1 cgd
469 1.1 cgd if (DEBUG(VAR)) {
470 1.1 cgd printf("%s:delete %s\n", ctxt->name, name);
471 1.1 cgd }
472 1.36 mycroft ln = Hash_FindEntry(&ctxt->context, name);
473 1.36 mycroft if (ln != NULL) {
474 1.70 wiz Var *v;
475 1.1 cgd
476 1.36 mycroft v = (Var *)Hash_GetValue(ln);
477 1.37 sommerfe if (v->name != ln->name)
478 1.37 sommerfe free(v->name);
479 1.36 mycroft Hash_DeleteEntry(&ctxt->context, ln);
480 1.37 sommerfe Buf_Destroy(v->val, TRUE);
481 1.37 sommerfe free((Address) v);
482 1.1 cgd }
483 1.1 cgd }
484 1.1 cgd
485 1.1 cgd /*-
486 1.1 cgd *-----------------------------------------------------------------------
487 1.1 cgd * Var_Set --
488 1.1 cgd * Set the variable name to the value val in the given context.
489 1.1 cgd *
490 1.70 wiz * Input:
491 1.70 wiz * name name of variable to set
492 1.70 wiz * val value to give to the variable
493 1.70 wiz * ctxt context in which to set it
494 1.70 wiz *
495 1.1 cgd * Results:
496 1.1 cgd * None.
497 1.1 cgd *
498 1.1 cgd * Side Effects:
499 1.1 cgd * If the variable doesn't yet exist, a new record is created for it.
500 1.1 cgd * Else the old value is freed and the new one stuck in its place
501 1.1 cgd *
502 1.1 cgd * Notes:
503 1.1 cgd * The variable is searched for only in its context before being
504 1.1 cgd * created in that context. I.e. if the context is VAR_GLOBAL,
505 1.1 cgd * only VAR_GLOBAL->context is searched. Likewise if it is VAR_CMD, only
506 1.1 cgd * VAR_CMD->context is searched. This is done to avoid the literally
507 1.1 cgd * thousands of unnecessary strcmp's that used to be done to
508 1.1 cgd * set, say, $(@) or $(<).
509 1.1 cgd *-----------------------------------------------------------------------
510 1.1 cgd */
511 1.1 cgd void
512 1.73 christos Var_Set(const char *name, const char *val, GNode *ctxt, int flags)
513 1.1 cgd {
514 1.70 wiz Var *v;
515 1.73 christos const char *cp = name;
516 1.42 sjg
517 1.1 cgd /*
518 1.1 cgd * We only look for a variable in the given context since anything set
519 1.1 cgd * here will override anything in a lower context, so there's not much
520 1.1 cgd * point in searching them all just to save a bit of memory...
521 1.1 cgd */
522 1.42 sjg if ((name = strchr(cp, '$'))) {
523 1.42 sjg name = Var_Subst(NULL, cp, ctxt, 0);
524 1.42 sjg } else
525 1.42 sjg name = cp;
526 1.1 cgd v = VarFind (name, ctxt, 0);
527 1.1 cgd if (v == (Var *) NIL) {
528 1.1 cgd VarAdd (name, val, ctxt);
529 1.1 cgd } else {
530 1.1 cgd Buf_Discard(v->val, Buf_Size(v->val));
531 1.73 christos Buf_AddBytes(v->val, strlen(val), (const Byte *)val);
532 1.1 cgd
533 1.1 cgd if (DEBUG(VAR)) {
534 1.1 cgd printf("%s:%s = %s\n", ctxt->name, name, val);
535 1.1 cgd }
536 1.1 cgd }
537 1.1 cgd /*
538 1.1 cgd * Any variables given on the command line are automatically exported
539 1.1 cgd * to the environment (as per POSIX standard)
540 1.1 cgd */
541 1.65 sjg if (ctxt == VAR_CMD && (flags & VAR_NO_EXPORT) == 0) {
542 1.64 sjg
543 1.71 thorpej /*
544 1.71 thorpej * If requested, don't export these in the environment
545 1.71 thorpej * individually. We still put them in MAKEOVERRIDES so
546 1.71 thorpej * that the command-line settings continue to override
547 1.71 thorpej * Makefile settings.
548 1.71 thorpej */
549 1.71 thorpej if (varNoExportEnv != TRUE)
550 1.71 thorpej setenv(name, val, 1);
551 1.62 sjg
552 1.64 sjg Var_Append(MAKEOVERRIDES, name, VAR_GLOBAL);
553 1.1 cgd }
554 1.42 sjg if (name != cp)
555 1.73 christos free(UNCONST(name));
556 1.1 cgd }
557 1.1 cgd
558 1.1 cgd /*-
559 1.1 cgd *-----------------------------------------------------------------------
560 1.1 cgd * Var_Append --
561 1.1 cgd * The variable of the given name has the given value appended to it in
562 1.1 cgd * the given context.
563 1.1 cgd *
564 1.70 wiz * Input:
565 1.70 wiz * name name of variable to modify
566 1.70 wiz * val String to append to it
567 1.70 wiz * ctxt Context in which this should occur
568 1.70 wiz *
569 1.1 cgd * Results:
570 1.1 cgd * None
571 1.1 cgd *
572 1.1 cgd * Side Effects:
573 1.1 cgd * If the variable doesn't exist, it is created. Else the strings
574 1.1 cgd * are concatenated (with a space in between).
575 1.1 cgd *
576 1.1 cgd * Notes:
577 1.1 cgd * Only if the variable is being sought in the global context is the
578 1.1 cgd * environment searched.
579 1.1 cgd * XXX: Knows its calling circumstances in that if called with ctxt
580 1.1 cgd * an actual target, it will only search that context since only
581 1.1 cgd * a local variable could be being appended to. This is actually
582 1.1 cgd * a big win and must be tolerated.
583 1.1 cgd *-----------------------------------------------------------------------
584 1.1 cgd */
585 1.1 cgd void
586 1.73 christos Var_Append(const char *name, const char *val, GNode *ctxt)
587 1.1 cgd {
588 1.70 wiz Var *v;
589 1.36 mycroft Hash_Entry *h;
590 1.73 christos const char *cp = name;
591 1.1 cgd
592 1.42 sjg if ((name = strchr(cp, '$'))) {
593 1.42 sjg name = Var_Subst(NULL, cp, ctxt, 0);
594 1.42 sjg } else
595 1.42 sjg name = cp;
596 1.42 sjg
597 1.1 cgd v = VarFind (name, ctxt, (ctxt == VAR_GLOBAL) ? FIND_ENV : 0);
598 1.1 cgd
599 1.1 cgd if (v == (Var *) NIL) {
600 1.1 cgd VarAdd (name, val, ctxt);
601 1.1 cgd } else {
602 1.1 cgd Buf_AddByte(v->val, (Byte)' ');
603 1.73 christos Buf_AddBytes(v->val, strlen(val), (const Byte *)val);
604 1.1 cgd
605 1.1 cgd if (DEBUG(VAR)) {
606 1.1 cgd printf("%s:%s = %s\n", ctxt->name, name,
607 1.5 cgd (char *) Buf_GetAll(v->val, (int *)NULL));
608 1.1 cgd }
609 1.1 cgd
610 1.1 cgd if (v->flags & VAR_FROM_ENV) {
611 1.1 cgd /*
612 1.1 cgd * If the original variable came from the environment, we
613 1.1 cgd * have to install it in the global context (we could place
614 1.1 cgd * it in the environment, but then we should provide a way to
615 1.1 cgd * export other variables...)
616 1.1 cgd */
617 1.1 cgd v->flags &= ~VAR_FROM_ENV;
618 1.36 mycroft h = Hash_CreateEntry (&ctxt->context, name, NULL);
619 1.36 mycroft Hash_SetValue(h, v);
620 1.1 cgd }
621 1.1 cgd }
622 1.42 sjg if (name != cp)
623 1.73 christos free(UNCONST(name));
624 1.1 cgd }
625 1.1 cgd
626 1.1 cgd /*-
627 1.1 cgd *-----------------------------------------------------------------------
628 1.1 cgd * Var_Exists --
629 1.1 cgd * See if the given variable exists.
630 1.1 cgd *
631 1.70 wiz * Input:
632 1.70 wiz * name Variable to find
633 1.70 wiz * ctxt Context in which to start search
634 1.70 wiz *
635 1.1 cgd * Results:
636 1.1 cgd * TRUE if it does, FALSE if it doesn't
637 1.1 cgd *
638 1.1 cgd * Side Effects:
639 1.1 cgd * None.
640 1.1 cgd *
641 1.1 cgd *-----------------------------------------------------------------------
642 1.1 cgd */
643 1.1 cgd Boolean
644 1.73 christos Var_Exists(const char *name, GNode *ctxt)
645 1.1 cgd {
646 1.1 cgd Var *v;
647 1.1 cgd
648 1.1 cgd v = VarFind(name, ctxt, FIND_CMD|FIND_GLOBAL|FIND_ENV);
649 1.1 cgd
650 1.1 cgd if (v == (Var *)NIL) {
651 1.1 cgd return(FALSE);
652 1.1 cgd } else if (v->flags & VAR_FROM_ENV) {
653 1.10 christos free(v->name);
654 1.1 cgd Buf_Destroy(v->val, TRUE);
655 1.1 cgd free((char *)v);
656 1.1 cgd }
657 1.1 cgd return(TRUE);
658 1.1 cgd }
659 1.1 cgd
660 1.1 cgd /*-
661 1.1 cgd *-----------------------------------------------------------------------
662 1.1 cgd * Var_Value --
663 1.1 cgd * Return the value of the named variable in the given context
664 1.1 cgd *
665 1.70 wiz * Input:
666 1.70 wiz * name name to find
667 1.70 wiz * ctxt context in which to search for it
668 1.70 wiz *
669 1.1 cgd * Results:
670 1.1 cgd * The value if the variable exists, NULL if it doesn't
671 1.1 cgd *
672 1.1 cgd * Side Effects:
673 1.1 cgd * None
674 1.1 cgd *-----------------------------------------------------------------------
675 1.1 cgd */
676 1.1 cgd char *
677 1.73 christos Var_Value(const char *name, GNode *ctxt, char **frp)
678 1.1 cgd {
679 1.1 cgd Var *v;
680 1.1 cgd
681 1.1 cgd v = VarFind (name, ctxt, FIND_ENV | FIND_GLOBAL | FIND_CMD);
682 1.6 jtc *frp = NULL;
683 1.1 cgd if (v != (Var *) NIL) {
684 1.6 jtc char *p = ((char *)Buf_GetAll(v->val, (int *)NULL));
685 1.6 jtc if (v->flags & VAR_FROM_ENV) {
686 1.29 itohy free(v->name);
687 1.6 jtc Buf_Destroy(v->val, FALSE);
688 1.6 jtc free((Address) v);
689 1.6 jtc *frp = p;
690 1.6 jtc }
691 1.6 jtc return p;
692 1.1 cgd } else {
693 1.1 cgd return ((char *) NULL);
694 1.1 cgd }
695 1.1 cgd }
696 1.1 cgd
697 1.1 cgd /*-
698 1.1 cgd *-----------------------------------------------------------------------
699 1.1 cgd * VarHead --
700 1.1 cgd * Remove the tail of the given word and place the result in the given
701 1.1 cgd * buffer.
702 1.1 cgd *
703 1.70 wiz * Input:
704 1.70 wiz * word Word to trim
705 1.70 wiz * addSpace True if need to add a space to the buffer
706 1.70 wiz * before sticking in the head
707 1.70 wiz * buf Buffer in which to store it
708 1.70 wiz *
709 1.1 cgd * Results:
710 1.1 cgd * TRUE if characters were added to the buffer (a space needs to be
711 1.1 cgd * added to the buffer before the next word).
712 1.1 cgd *
713 1.1 cgd * Side Effects:
714 1.1 cgd * The trimmed word is added to the buffer.
715 1.1 cgd *
716 1.1 cgd *-----------------------------------------------------------------------
717 1.1 cgd */
718 1.1 cgd static Boolean
719 1.81 sjg VarHead(GNode *ctx, Var_Parse_State *vpstate,
720 1.81 sjg char *word, Boolean addSpace, Buffer buf,
721 1.70 wiz ClientData dummy)
722 1.1 cgd {
723 1.70 wiz char *slash;
724 1.1 cgd
725 1.5 cgd slash = strrchr (word, '/');
726 1.1 cgd if (slash != (char *)NULL) {
727 1.81 sjg if (addSpace && vpstate->varSpace) {
728 1.81 sjg Buf_AddByte (buf, vpstate->varSpace);
729 1.1 cgd }
730 1.1 cgd *slash = '\0';
731 1.1 cgd Buf_AddBytes (buf, strlen (word), (Byte *)word);
732 1.1 cgd *slash = '/';
733 1.1 cgd return (TRUE);
734 1.1 cgd } else {
735 1.1 cgd /*
736 1.1 cgd * If no directory part, give . (q.v. the POSIX standard)
737 1.1 cgd */
738 1.81 sjg if (addSpace && vpstate->varSpace)
739 1.81 sjg Buf_AddByte(buf, vpstate->varSpace);
740 1.74 sjg Buf_AddByte(buf, (Byte)'.');
741 1.1 cgd }
742 1.6 jtc return(dummy ? TRUE : TRUE);
743 1.1 cgd }
744 1.1 cgd
745 1.1 cgd /*-
746 1.1 cgd *-----------------------------------------------------------------------
747 1.1 cgd * VarTail --
748 1.1 cgd * Remove the head of the given word and place the result in the given
749 1.1 cgd * buffer.
750 1.1 cgd *
751 1.70 wiz * Input:
752 1.70 wiz * word Word to trim
753 1.70 wiz * addSpace True if need to add a space to the buffer
754 1.70 wiz * before adding the tail
755 1.70 wiz * buf Buffer in which to store it
756 1.70 wiz *
757 1.1 cgd * Results:
758 1.1 cgd * TRUE if characters were added to the buffer (a space needs to be
759 1.1 cgd * added to the buffer before the next word).
760 1.1 cgd *
761 1.1 cgd * Side Effects:
762 1.1 cgd * The trimmed word is added to the buffer.
763 1.1 cgd *
764 1.1 cgd *-----------------------------------------------------------------------
765 1.1 cgd */
766 1.1 cgd static Boolean
767 1.81 sjg VarTail(GNode *ctx, Var_Parse_State *vpstate,
768 1.81 sjg char *word, Boolean addSpace, Buffer buf,
769 1.70 wiz ClientData dummy)
770 1.1 cgd {
771 1.70 wiz char *slash;
772 1.1 cgd
773 1.81 sjg if (addSpace && vpstate->varSpace) {
774 1.81 sjg Buf_AddByte (buf, vpstate->varSpace);
775 1.1 cgd }
776 1.1 cgd
777 1.5 cgd slash = strrchr (word, '/');
778 1.1 cgd if (slash != (char *)NULL) {
779 1.1 cgd *slash++ = '\0';
780 1.1 cgd Buf_AddBytes (buf, strlen(slash), (Byte *)slash);
781 1.1 cgd slash[-1] = '/';
782 1.1 cgd } else {
783 1.1 cgd Buf_AddBytes (buf, strlen(word), (Byte *)word);
784 1.1 cgd }
785 1.6 jtc return (dummy ? TRUE : TRUE);
786 1.1 cgd }
787 1.1 cgd
788 1.1 cgd /*-
789 1.1 cgd *-----------------------------------------------------------------------
790 1.1 cgd * VarSuffix --
791 1.1 cgd * Place the suffix of the given word in the given buffer.
792 1.1 cgd *
793 1.70 wiz * Input:
794 1.70 wiz * word Word to trim
795 1.70 wiz * addSpace TRUE if need to add a space before placing the
796 1.70 wiz * suffix in the buffer
797 1.70 wiz * buf Buffer in which to store it
798 1.70 wiz *
799 1.1 cgd * Results:
800 1.1 cgd * TRUE if characters were added to the buffer (a space needs to be
801 1.1 cgd * added to the buffer before the next word).
802 1.1 cgd *
803 1.1 cgd * Side Effects:
804 1.1 cgd * The suffix from the word is placed in the buffer.
805 1.1 cgd *
806 1.1 cgd *-----------------------------------------------------------------------
807 1.1 cgd */
808 1.1 cgd static Boolean
809 1.81 sjg VarSuffix(GNode *ctx, Var_Parse_State *vpstate,
810 1.81 sjg char *word, Boolean addSpace, Buffer buf,
811 1.70 wiz ClientData dummy)
812 1.1 cgd {
813 1.70 wiz char *dot;
814 1.1 cgd
815 1.5 cgd dot = strrchr (word, '.');
816 1.1 cgd if (dot != (char *)NULL) {
817 1.81 sjg if (addSpace && vpstate->varSpace) {
818 1.81 sjg Buf_AddByte (buf, vpstate->varSpace);
819 1.1 cgd }
820 1.1 cgd *dot++ = '\0';
821 1.1 cgd Buf_AddBytes (buf, strlen (dot), (Byte *)dot);
822 1.1 cgd dot[-1] = '.';
823 1.6 jtc addSpace = TRUE;
824 1.1 cgd }
825 1.6 jtc return (dummy ? addSpace : addSpace);
826 1.1 cgd }
827 1.1 cgd
828 1.1 cgd /*-
829 1.1 cgd *-----------------------------------------------------------------------
830 1.1 cgd * VarRoot --
831 1.1 cgd * Remove the suffix of the given word and place the result in the
832 1.1 cgd * buffer.
833 1.1 cgd *
834 1.70 wiz * Input:
835 1.70 wiz * word Word to trim
836 1.70 wiz * addSpace TRUE if need to add a space to the buffer
837 1.70 wiz * before placing the root in it
838 1.70 wiz * buf Buffer in which to store it
839 1.70 wiz *
840 1.1 cgd * Results:
841 1.1 cgd * TRUE if characters were added to the buffer (a space needs to be
842 1.1 cgd * added to the buffer before the next word).
843 1.1 cgd *
844 1.1 cgd * Side Effects:
845 1.1 cgd * The trimmed word is added to the buffer.
846 1.1 cgd *
847 1.1 cgd *-----------------------------------------------------------------------
848 1.1 cgd */
849 1.1 cgd static Boolean
850 1.81 sjg VarRoot(GNode *ctx, Var_Parse_State *vpstate,
851 1.81 sjg char *word, Boolean addSpace, Buffer buf,
852 1.70 wiz ClientData dummy)
853 1.1 cgd {
854 1.70 wiz char *dot;
855 1.1 cgd
856 1.81 sjg if (addSpace && vpstate->varSpace) {
857 1.81 sjg Buf_AddByte (buf, vpstate->varSpace);
858 1.1 cgd }
859 1.1 cgd
860 1.5 cgd dot = strrchr (word, '.');
861 1.1 cgd if (dot != (char *)NULL) {
862 1.1 cgd *dot = '\0';
863 1.1 cgd Buf_AddBytes (buf, strlen (word), (Byte *)word);
864 1.1 cgd *dot = '.';
865 1.1 cgd } else {
866 1.1 cgd Buf_AddBytes (buf, strlen(word), (Byte *)word);
867 1.1 cgd }
868 1.6 jtc return (dummy ? TRUE : TRUE);
869 1.1 cgd }
870 1.1 cgd
871 1.1 cgd /*-
872 1.1 cgd *-----------------------------------------------------------------------
873 1.1 cgd * VarMatch --
874 1.1 cgd * Place the word in the buffer if it matches the given pattern.
875 1.1 cgd * Callback function for VarModify to implement the :M modifier.
876 1.15 christos *
877 1.70 wiz * Input:
878 1.70 wiz * word Word to examine
879 1.70 wiz * addSpace TRUE if need to add a space to the buffer
880 1.70 wiz * before adding the word, if it matches
881 1.70 wiz * buf Buffer in which to store it
882 1.70 wiz * pattern Pattern the word must match
883 1.70 wiz *
884 1.1 cgd * Results:
885 1.1 cgd * TRUE if a space should be placed in the buffer before the next
886 1.1 cgd * word.
887 1.1 cgd *
888 1.1 cgd * Side Effects:
889 1.1 cgd * The word may be copied to the buffer.
890 1.1 cgd *
891 1.1 cgd *-----------------------------------------------------------------------
892 1.1 cgd */
893 1.1 cgd static Boolean
894 1.81 sjg VarMatch(GNode *ctx, Var_Parse_State *vpstate,
895 1.81 sjg char *word, Boolean addSpace, Buffer buf,
896 1.70 wiz ClientData pattern)
897 1.1 cgd {
898 1.6 jtc if (Str_Match(word, (char *) pattern)) {
899 1.81 sjg if (addSpace && vpstate->varSpace) {
900 1.81 sjg Buf_AddByte(buf, vpstate->varSpace);
901 1.1 cgd }
902 1.1 cgd addSpace = TRUE;
903 1.1 cgd Buf_AddBytes(buf, strlen(word), (Byte *)word);
904 1.1 cgd }
905 1.1 cgd return(addSpace);
906 1.1 cgd }
907 1.1 cgd
908 1.13 christos #ifdef SYSVVARSUB
909 1.5 cgd /*-
910 1.5 cgd *-----------------------------------------------------------------------
911 1.5 cgd * VarSYSVMatch --
912 1.5 cgd * Place the word in the buffer if it matches the given pattern.
913 1.5 cgd * Callback function for VarModify to implement the System V %
914 1.5 cgd * modifiers.
915 1.15 christos *
916 1.70 wiz * Input:
917 1.70 wiz * word Word to examine
918 1.70 wiz * addSpace TRUE if need to add a space to the buffer
919 1.70 wiz * before adding the word, if it matches
920 1.70 wiz * buf Buffer in which to store it
921 1.70 wiz * patp Pattern the word must match
922 1.70 wiz *
923 1.5 cgd * Results:
924 1.5 cgd * TRUE if a space should be placed in the buffer before the next
925 1.5 cgd * word.
926 1.5 cgd *
927 1.5 cgd * Side Effects:
928 1.5 cgd * The word may be copied to the buffer.
929 1.5 cgd *
930 1.5 cgd *-----------------------------------------------------------------------
931 1.5 cgd */
932 1.5 cgd static Boolean
933 1.81 sjg VarSYSVMatch(GNode *ctx, Var_Parse_State *vpstate,
934 1.81 sjg char *word, Boolean addSpace, Buffer buf,
935 1.70 wiz ClientData patp)
936 1.5 cgd {
937 1.5 cgd int len;
938 1.5 cgd char *ptr;
939 1.6 jtc VarPattern *pat = (VarPattern *) patp;
940 1.61 explorer char *varexp;
941 1.5 cgd
942 1.81 sjg if (addSpace && vpstate->varSpace)
943 1.81 sjg Buf_AddByte(buf, vpstate->varSpace);
944 1.5 cgd
945 1.5 cgd addSpace = TRUE;
946 1.5 cgd
947 1.61 explorer if ((ptr = Str_SYSVMatch(word, pat->lhs, &len)) != NULL) {
948 1.61 explorer varexp = Var_Subst(NULL, pat->rhs, ctx, 0);
949 1.61 explorer Str_SYSVSubst(buf, varexp, ptr, len);
950 1.61 explorer free(varexp);
951 1.61 explorer } else {
952 1.5 cgd Buf_AddBytes(buf, strlen(word), (Byte *) word);
953 1.61 explorer }
954 1.5 cgd
955 1.5 cgd return(addSpace);
956 1.5 cgd }
957 1.13 christos #endif
958 1.5 cgd
959 1.5 cgd
960 1.1 cgd /*-
961 1.1 cgd *-----------------------------------------------------------------------
962 1.1 cgd * VarNoMatch --
963 1.1 cgd * Place the word in the buffer if it doesn't match the given pattern.
964 1.1 cgd * Callback function for VarModify to implement the :N modifier.
965 1.15 christos *
966 1.70 wiz * Input:
967 1.70 wiz * word Word to examine
968 1.70 wiz * addSpace TRUE if need to add a space to the buffer
969 1.70 wiz * before adding the word, if it matches
970 1.70 wiz * buf Buffer in which to store it
971 1.70 wiz * pattern Pattern the word must match
972 1.70 wiz *
973 1.1 cgd * Results:
974 1.1 cgd * TRUE if a space should be placed in the buffer before the next
975 1.1 cgd * word.
976 1.1 cgd *
977 1.1 cgd * Side Effects:
978 1.1 cgd * The word may be copied to the buffer.
979 1.1 cgd *
980 1.1 cgd *-----------------------------------------------------------------------
981 1.1 cgd */
982 1.1 cgd static Boolean
983 1.81 sjg VarNoMatch(GNode *ctx, Var_Parse_State *vpstate,
984 1.81 sjg char *word, Boolean addSpace, Buffer buf,
985 1.70 wiz ClientData pattern)
986 1.1 cgd {
987 1.6 jtc if (!Str_Match(word, (char *) pattern)) {
988 1.81 sjg if (addSpace && vpstate->varSpace) {
989 1.81 sjg Buf_AddByte(buf, vpstate->varSpace);
990 1.1 cgd }
991 1.1 cgd addSpace = TRUE;
992 1.1 cgd Buf_AddBytes(buf, strlen(word), (Byte *)word);
993 1.1 cgd }
994 1.1 cgd return(addSpace);
995 1.1 cgd }
996 1.1 cgd
997 1.1 cgd
998 1.1 cgd /*-
999 1.1 cgd *-----------------------------------------------------------------------
1000 1.1 cgd * VarSubstitute --
1001 1.1 cgd * Perform a string-substitution on the given word, placing the
1002 1.1 cgd * result in the passed buffer.
1003 1.1 cgd *
1004 1.70 wiz * Input:
1005 1.70 wiz * word Word to modify
1006 1.70 wiz * addSpace True if space should be added before
1007 1.70 wiz * other characters
1008 1.70 wiz * buf Buffer for result
1009 1.70 wiz * patternp Pattern for substitution
1010 1.70 wiz *
1011 1.1 cgd * Results:
1012 1.1 cgd * TRUE if a space is needed before more characters are added.
1013 1.1 cgd *
1014 1.1 cgd * Side Effects:
1015 1.1 cgd * None.
1016 1.1 cgd *
1017 1.1 cgd *-----------------------------------------------------------------------
1018 1.1 cgd */
1019 1.1 cgd static Boolean
1020 1.81 sjg VarSubstitute(GNode *ctx, Var_Parse_State *vpstate,
1021 1.81 sjg char *word, Boolean addSpace, Buffer buf,
1022 1.70 wiz ClientData patternp)
1023 1.1 cgd {
1024 1.70 wiz int wordLen; /* Length of word */
1025 1.70 wiz char *cp; /* General pointer */
1026 1.6 jtc VarPattern *pattern = (VarPattern *) patternp;
1027 1.1 cgd
1028 1.1 cgd wordLen = strlen(word);
1029 1.16 christos if ((pattern->flags & (VAR_SUB_ONE|VAR_SUB_MATCHED)) !=
1030 1.16 christos (VAR_SUB_ONE|VAR_SUB_MATCHED)) {
1031 1.1 cgd /*
1032 1.16 christos * Still substituting -- break it down into simple anchored cases
1033 1.1 cgd * and if none of them fits, perform the general substitution case.
1034 1.1 cgd */
1035 1.1 cgd if ((pattern->flags & VAR_MATCH_START) &&
1036 1.1 cgd (strncmp(word, pattern->lhs, pattern->leftLen) == 0)) {
1037 1.1 cgd /*
1038 1.1 cgd * Anchored at start and beginning of word matches pattern
1039 1.1 cgd */
1040 1.1 cgd if ((pattern->flags & VAR_MATCH_END) &&
1041 1.1 cgd (wordLen == pattern->leftLen)) {
1042 1.1 cgd /*
1043 1.1 cgd * Also anchored at end and matches to the end (word
1044 1.1 cgd * is same length as pattern) add space and rhs only
1045 1.1 cgd * if rhs is non-null.
1046 1.1 cgd */
1047 1.1 cgd if (pattern->rightLen != 0) {
1048 1.81 sjg if (addSpace && vpstate->varSpace) {
1049 1.81 sjg Buf_AddByte(buf, vpstate->varSpace);
1050 1.1 cgd }
1051 1.1 cgd addSpace = TRUE;
1052 1.1 cgd Buf_AddBytes(buf, pattern->rightLen,
1053 1.73 christos (const Byte *)pattern->rhs);
1054 1.1 cgd }
1055 1.16 christos pattern->flags |= VAR_SUB_MATCHED;
1056 1.1 cgd } else if (pattern->flags & VAR_MATCH_END) {
1057 1.1 cgd /*
1058 1.1 cgd * Doesn't match to end -- copy word wholesale
1059 1.1 cgd */
1060 1.1 cgd goto nosub;
1061 1.1 cgd } else {
1062 1.1 cgd /*
1063 1.1 cgd * Matches at start but need to copy in trailing characters
1064 1.1 cgd */
1065 1.1 cgd if ((pattern->rightLen + wordLen - pattern->leftLen) != 0){
1066 1.81 sjg if (addSpace && vpstate->varSpace) {
1067 1.81 sjg Buf_AddByte(buf, vpstate->varSpace);
1068 1.1 cgd }
1069 1.1 cgd addSpace = TRUE;
1070 1.1 cgd }
1071 1.73 christos Buf_AddBytes(buf, pattern->rightLen,
1072 1.73 christos (const Byte *)pattern->rhs);
1073 1.1 cgd Buf_AddBytes(buf, wordLen - pattern->leftLen,
1074 1.1 cgd (Byte *)(word + pattern->leftLen));
1075 1.16 christos pattern->flags |= VAR_SUB_MATCHED;
1076 1.1 cgd }
1077 1.1 cgd } else if (pattern->flags & VAR_MATCH_START) {
1078 1.1 cgd /*
1079 1.1 cgd * Had to match at start of word and didn't -- copy whole word.
1080 1.1 cgd */
1081 1.1 cgd goto nosub;
1082 1.1 cgd } else if (pattern->flags & VAR_MATCH_END) {
1083 1.1 cgd /*
1084 1.1 cgd * Anchored at end, Find only place match could occur (leftLen
1085 1.1 cgd * characters from the end of the word) and see if it does. Note
1086 1.1 cgd * that because the $ will be left at the end of the lhs, we have
1087 1.1 cgd * to use strncmp.
1088 1.1 cgd */
1089 1.1 cgd cp = word + (wordLen - pattern->leftLen);
1090 1.1 cgd if ((cp >= word) &&
1091 1.1 cgd (strncmp(cp, pattern->lhs, pattern->leftLen) == 0)) {
1092 1.1 cgd /*
1093 1.1 cgd * Match found. If we will place characters in the buffer,
1094 1.1 cgd * add a space before hand as indicated by addSpace, then
1095 1.1 cgd * stuff in the initial, unmatched part of the word followed
1096 1.1 cgd * by the right-hand-side.
1097 1.1 cgd */
1098 1.1 cgd if (((cp - word) + pattern->rightLen) != 0) {
1099 1.81 sjg if (addSpace && vpstate->varSpace) {
1100 1.81 sjg Buf_AddByte(buf, vpstate->varSpace);
1101 1.1 cgd }
1102 1.1 cgd addSpace = TRUE;
1103 1.1 cgd }
1104 1.73 christos Buf_AddBytes(buf, cp - word, (const Byte *)word);
1105 1.73 christos Buf_AddBytes(buf, pattern->rightLen,
1106 1.73 christos (const Byte *)pattern->rhs);
1107 1.16 christos pattern->flags |= VAR_SUB_MATCHED;
1108 1.1 cgd } else {
1109 1.1 cgd /*
1110 1.1 cgd * Had to match at end and didn't. Copy entire word.
1111 1.1 cgd */
1112 1.1 cgd goto nosub;
1113 1.1 cgd }
1114 1.1 cgd } else {
1115 1.1 cgd /*
1116 1.1 cgd * Pattern is unanchored: search for the pattern in the word using
1117 1.1 cgd * String_FindSubstring, copying unmatched portions and the
1118 1.1 cgd * right-hand-side for each match found, handling non-global
1119 1.15 christos * substitutions correctly, etc. When the loop is done, any
1120 1.1 cgd * remaining part of the word (word and wordLen are adjusted
1121 1.1 cgd * accordingly through the loop) is copied straight into the
1122 1.1 cgd * buffer.
1123 1.1 cgd * addSpace is set FALSE as soon as a space is added to the
1124 1.1 cgd * buffer.
1125 1.1 cgd */
1126 1.70 wiz Boolean done;
1127 1.1 cgd int origSize;
1128 1.1 cgd
1129 1.1 cgd done = FALSE;
1130 1.1 cgd origSize = Buf_Size(buf);
1131 1.1 cgd while (!done) {
1132 1.1 cgd cp = Str_FindSubstring(word, pattern->lhs);
1133 1.1 cgd if (cp != (char *)NULL) {
1134 1.1 cgd if (addSpace && (((cp - word) + pattern->rightLen) != 0)){
1135 1.81 sjg Buf_AddByte(buf, vpstate->varSpace);
1136 1.1 cgd addSpace = FALSE;
1137 1.1 cgd }
1138 1.73 christos Buf_AddBytes(buf, cp-word, (const Byte *)word);
1139 1.73 christos Buf_AddBytes(buf, pattern->rightLen,
1140 1.73 christos (const Byte *)pattern->rhs);
1141 1.1 cgd wordLen -= (cp - word) + pattern->leftLen;
1142 1.1 cgd word = cp + pattern->leftLen;
1143 1.16 christos if (wordLen == 0) {
1144 1.16 christos done = TRUE;
1145 1.16 christos }
1146 1.16 christos if ((pattern->flags & VAR_SUB_GLOBAL) == 0) {
1147 1.1 cgd done = TRUE;
1148 1.1 cgd }
1149 1.16 christos pattern->flags |= VAR_SUB_MATCHED;
1150 1.1 cgd } else {
1151 1.1 cgd done = TRUE;
1152 1.1 cgd }
1153 1.1 cgd }
1154 1.1 cgd if (wordLen != 0) {
1155 1.81 sjg if (addSpace && vpstate->varSpace) {
1156 1.81 sjg Buf_AddByte(buf, vpstate->varSpace);
1157 1.1 cgd }
1158 1.1 cgd Buf_AddBytes(buf, wordLen, (Byte *)word);
1159 1.1 cgd }
1160 1.1 cgd /*
1161 1.1 cgd * If added characters to the buffer, need to add a space
1162 1.1 cgd * before we add any more. If we didn't add any, just return
1163 1.1 cgd * the previous value of addSpace.
1164 1.1 cgd */
1165 1.1 cgd return ((Buf_Size(buf) != origSize) || addSpace);
1166 1.1 cgd }
1167 1.1 cgd return (addSpace);
1168 1.1 cgd }
1169 1.1 cgd nosub:
1170 1.81 sjg if (addSpace && vpstate->varSpace) {
1171 1.81 sjg Buf_AddByte(buf, vpstate->varSpace);
1172 1.1 cgd }
1173 1.1 cgd Buf_AddBytes(buf, wordLen, (Byte *)word);
1174 1.1 cgd return(TRUE);
1175 1.1 cgd }
1176 1.1 cgd
1177 1.31 gwr #ifndef NO_REGEX
1178 1.16 christos /*-
1179 1.16 christos *-----------------------------------------------------------------------
1180 1.16 christos * VarREError --
1181 1.16 christos * Print the error caused by a regcomp or regexec call.
1182 1.16 christos *
1183 1.16 christos * Results:
1184 1.16 christos * None.
1185 1.16 christos *
1186 1.16 christos * Side Effects:
1187 1.16 christos * An error gets printed.
1188 1.16 christos *
1189 1.16 christos *-----------------------------------------------------------------------
1190 1.16 christos */
1191 1.16 christos static void
1192 1.70 wiz VarREError(int err, regex_t *pat, const char *str)
1193 1.16 christos {
1194 1.16 christos char *errbuf;
1195 1.16 christos int errlen;
1196 1.16 christos
1197 1.16 christos errlen = regerror(err, pat, 0, 0);
1198 1.16 christos errbuf = emalloc(errlen);
1199 1.16 christos regerror(err, pat, errbuf, errlen);
1200 1.16 christos Error("%s: %s", str, errbuf);
1201 1.16 christos free(errbuf);
1202 1.16 christos }
1203 1.16 christos
1204 1.16 christos
1205 1.16 christos /*-
1206 1.16 christos *-----------------------------------------------------------------------
1207 1.16 christos * VarRESubstitute --
1208 1.16 christos * Perform a regex substitution on the given word, placing the
1209 1.16 christos * result in the passed buffer.
1210 1.16 christos *
1211 1.16 christos * Results:
1212 1.16 christos * TRUE if a space is needed before more characters are added.
1213 1.16 christos *
1214 1.16 christos * Side Effects:
1215 1.16 christos * None.
1216 1.16 christos *
1217 1.16 christos *-----------------------------------------------------------------------
1218 1.16 christos */
1219 1.16 christos static Boolean
1220 1.81 sjg VarRESubstitute(GNode *ctx, Var_Parse_State *vpstate,
1221 1.81 sjg char *word, Boolean addSpace, Buffer buf,
1222 1.70 wiz ClientData patternp)
1223 1.16 christos {
1224 1.16 christos VarREPattern *pat;
1225 1.16 christos int xrv;
1226 1.16 christos char *wp;
1227 1.16 christos char *rp;
1228 1.16 christos int added;
1229 1.20 christos int flags = 0;
1230 1.16 christos
1231 1.16 christos #define MAYBE_ADD_SPACE() \
1232 1.16 christos if (addSpace && !added) \
1233 1.16 christos Buf_AddByte(buf, ' '); \
1234 1.16 christos added = 1
1235 1.16 christos
1236 1.16 christos added = 0;
1237 1.16 christos wp = word;
1238 1.16 christos pat = patternp;
1239 1.16 christos
1240 1.16 christos if ((pat->flags & (VAR_SUB_ONE|VAR_SUB_MATCHED)) ==
1241 1.16 christos (VAR_SUB_ONE|VAR_SUB_MATCHED))
1242 1.16 christos xrv = REG_NOMATCH;
1243 1.16 christos else {
1244 1.16 christos tryagain:
1245 1.21 christos xrv = regexec(&pat->re, wp, pat->nsub, pat->matches, flags);
1246 1.16 christos }
1247 1.16 christos
1248 1.16 christos switch (xrv) {
1249 1.16 christos case 0:
1250 1.16 christos pat->flags |= VAR_SUB_MATCHED;
1251 1.16 christos if (pat->matches[0].rm_so > 0) {
1252 1.16 christos MAYBE_ADD_SPACE();
1253 1.16 christos Buf_AddBytes(buf, pat->matches[0].rm_so, wp);
1254 1.16 christos }
1255 1.16 christos
1256 1.16 christos for (rp = pat->replace; *rp; rp++) {
1257 1.16 christos if ((*rp == '\\') && ((rp[1] == '&') || (rp[1] == '\\'))) {
1258 1.16 christos MAYBE_ADD_SPACE();
1259 1.16 christos Buf_AddByte(buf,rp[1]);
1260 1.16 christos rp++;
1261 1.16 christos }
1262 1.30 christos else if ((*rp == '&') ||
1263 1.30 christos ((*rp == '\\') && isdigit((unsigned char)rp[1]))) {
1264 1.16 christos int n;
1265 1.73 christos const char *subbuf;
1266 1.16 christos int sublen;
1267 1.16 christos char errstr[3];
1268 1.16 christos
1269 1.16 christos if (*rp == '&') {
1270 1.16 christos n = 0;
1271 1.16 christos errstr[0] = '&';
1272 1.16 christos errstr[1] = '\0';
1273 1.16 christos } else {
1274 1.16 christos n = rp[1] - '0';
1275 1.16 christos errstr[0] = '\\';
1276 1.16 christos errstr[1] = rp[1];
1277 1.16 christos errstr[2] = '\0';
1278 1.16 christos rp++;
1279 1.16 christos }
1280 1.16 christos
1281 1.16 christos if (n > pat->nsub) {
1282 1.16 christos Error("No subexpression %s", &errstr[0]);
1283 1.16 christos subbuf = "";
1284 1.16 christos sublen = 0;
1285 1.16 christos } else if ((pat->matches[n].rm_so == -1) &&
1286 1.16 christos (pat->matches[n].rm_eo == -1)) {
1287 1.16 christos Error("No match for subexpression %s", &errstr[0]);
1288 1.16 christos subbuf = "";
1289 1.16 christos sublen = 0;
1290 1.16 christos } else {
1291 1.16 christos subbuf = wp + pat->matches[n].rm_so;
1292 1.16 christos sublen = pat->matches[n].rm_eo - pat->matches[n].rm_so;
1293 1.16 christos }
1294 1.16 christos
1295 1.16 christos if (sublen > 0) {
1296 1.16 christos MAYBE_ADD_SPACE();
1297 1.16 christos Buf_AddBytes(buf, sublen, subbuf);
1298 1.16 christos }
1299 1.16 christos } else {
1300 1.16 christos MAYBE_ADD_SPACE();
1301 1.16 christos Buf_AddByte(buf, *rp);
1302 1.16 christos }
1303 1.16 christos }
1304 1.16 christos wp += pat->matches[0].rm_eo;
1305 1.20 christos if (pat->flags & VAR_SUB_GLOBAL) {
1306 1.20 christos flags |= REG_NOTBOL;
1307 1.20 christos if (pat->matches[0].rm_so == 0 && pat->matches[0].rm_eo == 0) {
1308 1.20 christos MAYBE_ADD_SPACE();
1309 1.20 christos Buf_AddByte(buf, *wp);
1310 1.20 christos wp++;
1311 1.20 christos
1312 1.20 christos }
1313 1.20 christos if (*wp)
1314 1.20 christos goto tryagain;
1315 1.20 christos }
1316 1.16 christos if (*wp) {
1317 1.16 christos MAYBE_ADD_SPACE();
1318 1.16 christos Buf_AddBytes(buf, strlen(wp), wp);
1319 1.16 christos }
1320 1.16 christos break;
1321 1.16 christos default:
1322 1.16 christos VarREError(xrv, &pat->re, "Unexpected regex error");
1323 1.16 christos /* fall through */
1324 1.16 christos case REG_NOMATCH:
1325 1.16 christos if (*wp) {
1326 1.16 christos MAYBE_ADD_SPACE();
1327 1.16 christos Buf_AddBytes(buf,strlen(wp),wp);
1328 1.16 christos }
1329 1.16 christos break;
1330 1.16 christos }
1331 1.16 christos return(addSpace||added);
1332 1.16 christos }
1333 1.17 christos #endif
1334 1.16 christos
1335 1.16 christos
1336 1.40 sjg
1337 1.40 sjg /*-
1338 1.40 sjg *-----------------------------------------------------------------------
1339 1.40 sjg * VarLoopExpand --
1340 1.40 sjg * Implements the :@<temp>@<string>@ modifier of ODE make.
1341 1.40 sjg * We set the temp variable named in pattern.lhs to word and expand
1342 1.40 sjg * pattern.rhs storing the result in the passed buffer.
1343 1.40 sjg *
1344 1.70 wiz * Input:
1345 1.70 wiz * word Word to modify
1346 1.70 wiz * addSpace True if space should be added before
1347 1.70 wiz * other characters
1348 1.70 wiz * buf Buffer for result
1349 1.70 wiz * pattern Datafor substitution
1350 1.70 wiz *
1351 1.40 sjg * Results:
1352 1.40 sjg * TRUE if a space is needed before more characters are added.
1353 1.40 sjg *
1354 1.40 sjg * Side Effects:
1355 1.40 sjg * None.
1356 1.40 sjg *
1357 1.40 sjg *-----------------------------------------------------------------------
1358 1.40 sjg */
1359 1.40 sjg static Boolean
1360 1.81 sjg VarLoopExpand(GNode *ctx, Var_Parse_State *vpstate,
1361 1.81 sjg char *word, Boolean addSpace, Buffer buf,
1362 1.70 wiz ClientData loopp)
1363 1.40 sjg {
1364 1.41 sjg VarLoop_t *loop = (VarLoop_t *) loopp;
1365 1.40 sjg char *s;
1366 1.60 sjg int slen;
1367 1.64 sjg
1368 1.64 sjg if (word && *word) {
1369 1.65 sjg Var_Set(loop->tvar, word, loop->ctxt, VAR_NO_EXPORT);
1370 1.64 sjg s = Var_Subst(NULL, loop->str, loop->ctxt, loop->err);
1371 1.64 sjg if (s != NULL && *s != '\0') {
1372 1.64 sjg if (addSpace && *s != '\n')
1373 1.64 sjg Buf_AddByte(buf, ' ');
1374 1.64 sjg Buf_AddBytes(buf, (slen = strlen(s)), (Byte *)s);
1375 1.64 sjg addSpace = (slen > 0 && s[slen - 1] != '\n');
1376 1.64 sjg free(s);
1377 1.64 sjg }
1378 1.40 sjg }
1379 1.40 sjg return addSpace;
1380 1.40 sjg }
1381 1.40 sjg
1382 1.81 sjg
1383 1.81 sjg /*-
1384 1.81 sjg *-----------------------------------------------------------------------
1385 1.81 sjg * VarSelectWords --
1386 1.81 sjg * Implements the :[start..end] modifier.
1387 1.81 sjg * This is a special case of VarModify since we want to be able
1388 1.81 sjg * to scan the list backwards if start > end.
1389 1.81 sjg *
1390 1.81 sjg * Input:
1391 1.81 sjg * str String whose words should be trimmed
1392 1.81 sjg * seldata words to select
1393 1.81 sjg *
1394 1.81 sjg * Results:
1395 1.81 sjg * A string of all the words selected.
1396 1.81 sjg *
1397 1.81 sjg * Side Effects:
1398 1.81 sjg * None.
1399 1.81 sjg *
1400 1.81 sjg *-----------------------------------------------------------------------
1401 1.81 sjg */
1402 1.81 sjg static char *
1403 1.81 sjg VarSelectWords(GNode *ctx, Var_Parse_State *vpstate,
1404 1.81 sjg const char *str, VarSelectWords_t *seldata)
1405 1.81 sjg {
1406 1.81 sjg Buffer buf; /* Buffer for the new string */
1407 1.81 sjg Boolean addSpace; /* TRUE if need to add a space to the
1408 1.81 sjg * buffer before adding the trimmed
1409 1.81 sjg * word */
1410 1.81 sjg char **av; /* word list */
1411 1.81 sjg char *as; /* word list memory */
1412 1.81 sjg int ac, i;
1413 1.81 sjg int start, end, step;
1414 1.81 sjg
1415 1.81 sjg buf = Buf_Init (0);
1416 1.81 sjg addSpace = FALSE;
1417 1.81 sjg
1418 1.81 sjg if (vpstate->oneBigWord) {
1419 1.81 sjg /* fake what brk_string() would do if there were only one word */
1420 1.81 sjg ac = 1;
1421 1.81 sjg av = (char **)emalloc((ac + 1) * sizeof(char *));
1422 1.81 sjg as = strdup(str);
1423 1.81 sjg av[0] = as;
1424 1.81 sjg av[1] = NULL;
1425 1.81 sjg } else {
1426 1.81 sjg av = brk_string(str, &ac, FALSE, &as);
1427 1.81 sjg }
1428 1.81 sjg
1429 1.81 sjg /*
1430 1.81 sjg * Now sanitize seldata.
1431 1.81 sjg * If seldata->start or seldata->end are negative, convert them to
1432 1.81 sjg * the positive equivalents (-1 gets converted to argc, -2 gets
1433 1.81 sjg * converted to (argc-1), etc.).
1434 1.81 sjg */
1435 1.81 sjg if (seldata->start < 0)
1436 1.81 sjg seldata->start = ac + seldata->start + 1;
1437 1.81 sjg if (seldata->end < 0)
1438 1.81 sjg seldata->end = ac + seldata->end + 1;
1439 1.81 sjg
1440 1.81 sjg /*
1441 1.81 sjg * We avoid scanning more of the list than we need to.
1442 1.81 sjg */
1443 1.81 sjg if (seldata->start > seldata->end) {
1444 1.81 sjg start = MIN(ac, seldata->start) - 1;
1445 1.81 sjg end = MAX(0, seldata->end - 1);
1446 1.81 sjg step = -1;
1447 1.81 sjg } else {
1448 1.81 sjg start = MAX(0, seldata->start - 1);
1449 1.81 sjg end = MIN(ac, seldata->end);
1450 1.81 sjg step = 1;
1451 1.81 sjg }
1452 1.81 sjg
1453 1.81 sjg for (i = start;
1454 1.81 sjg (step < 0 && i >= end) || (step > 0 && i < end);
1455 1.81 sjg i += step) {
1456 1.81 sjg if (av[i] && *av[i]) {
1457 1.81 sjg if (addSpace && vpstate->varSpace) {
1458 1.81 sjg Buf_AddByte(buf, vpstate->varSpace);
1459 1.81 sjg }
1460 1.81 sjg Buf_AddBytes(buf, strlen(av[i]), (Byte *)av[i]);
1461 1.81 sjg addSpace = TRUE;
1462 1.81 sjg }
1463 1.81 sjg }
1464 1.81 sjg
1465 1.81 sjg free(as);
1466 1.81 sjg free(av);
1467 1.81 sjg
1468 1.81 sjg Buf_AddByte (buf, '\0');
1469 1.81 sjg as = (char *)Buf_GetAll (buf, (int *)NULL);
1470 1.81 sjg Buf_Destroy (buf, FALSE);
1471 1.81 sjg return (as);
1472 1.81 sjg }
1473 1.81 sjg
1474 1.1 cgd /*-
1475 1.1 cgd *-----------------------------------------------------------------------
1476 1.1 cgd * VarModify --
1477 1.1 cgd * Modify each of the words of the passed string using the given
1478 1.1 cgd * function. Used to implement all modifiers.
1479 1.1 cgd *
1480 1.70 wiz * Input:
1481 1.70 wiz * str String whose words should be trimmed
1482 1.70 wiz * modProc Function to use to modify them
1483 1.70 wiz * datum Datum to pass it
1484 1.70 wiz *
1485 1.1 cgd * Results:
1486 1.1 cgd * A string of all the words modified appropriately.
1487 1.1 cgd *
1488 1.1 cgd * Side Effects:
1489 1.1 cgd * None.
1490 1.1 cgd *
1491 1.1 cgd *-----------------------------------------------------------------------
1492 1.1 cgd */
1493 1.1 cgd static char *
1494 1.81 sjg VarModify(GNode *ctx, Var_Parse_State *vpstate,
1495 1.81 sjg const char *str,
1496 1.81 sjg Boolean (*modProc)(GNode *, Var_Parse_State *, char *,
1497 1.81 sjg Boolean, Buffer, ClientData),
1498 1.73 christos ClientData datum)
1499 1.1 cgd {
1500 1.1 cgd Buffer buf; /* Buffer for the new string */
1501 1.1 cgd Boolean addSpace; /* TRUE if need to add a space to the
1502 1.1 cgd * buffer before adding the trimmed
1503 1.1 cgd * word */
1504 1.81 sjg char **av; /* word list */
1505 1.24 christos char *as; /* word list memory */
1506 1.7 jtc int ac, i;
1507 1.7 jtc
1508 1.1 cgd buf = Buf_Init (0);
1509 1.1 cgd addSpace = FALSE;
1510 1.1 cgd
1511 1.81 sjg if (vpstate->oneBigWord) {
1512 1.81 sjg /* fake what brk_string() would do if there were only one word */
1513 1.81 sjg ac = 1;
1514 1.81 sjg av = (char **)emalloc((ac + 1) * sizeof(char *));
1515 1.81 sjg as = strdup(str);
1516 1.81 sjg av[0] = as;
1517 1.81 sjg av[1] = NULL;
1518 1.81 sjg } else {
1519 1.81 sjg av = brk_string(str, &ac, FALSE, &as);
1520 1.81 sjg }
1521 1.1 cgd
1522 1.81 sjg for (i = 0; i < ac; i++) {
1523 1.81 sjg addSpace = (*modProc)(ctx, vpstate, av[i], addSpace, buf, datum);
1524 1.81 sjg }
1525 1.24 christos
1526 1.24 christos free(as);
1527 1.24 christos free(av);
1528 1.15 christos
1529 1.7 jtc Buf_AddByte (buf, '\0');
1530 1.73 christos as = (char *)Buf_GetAll (buf, (int *)NULL);
1531 1.7 jtc Buf_Destroy (buf, FALSE);
1532 1.73 christos return (as);
1533 1.1 cgd }
1534 1.1 cgd
1535 1.35 christos
1536 1.35 christos static int
1537 1.70 wiz VarWordCompare(const void *a, const void *b)
1538 1.35 christos {
1539 1.79 scw int r = strcmp(*(const char * const *)a, *(const char * const *)b);
1540 1.35 christos return r;
1541 1.35 christos }
1542 1.35 christos
1543 1.35 christos /*-
1544 1.35 christos *-----------------------------------------------------------------------
1545 1.35 christos * VarSort --
1546 1.35 christos * Sort the words in the string.
1547 1.35 christos *
1548 1.70 wiz * Input:
1549 1.70 wiz * str String whose words should be sorted
1550 1.70 wiz *
1551 1.35 christos * Results:
1552 1.35 christos * A string containing the words sorted
1553 1.35 christos *
1554 1.35 christos * Side Effects:
1555 1.35 christos * None.
1556 1.35 christos *
1557 1.35 christos *-----------------------------------------------------------------------
1558 1.35 christos */
1559 1.35 christos static char *
1560 1.73 christos VarSort(const char *str)
1561 1.35 christos {
1562 1.35 christos Buffer buf; /* Buffer for the new string */
1563 1.35 christos char **av; /* word list [first word does not count] */
1564 1.35 christos char *as; /* word list memory */
1565 1.35 christos int ac, i;
1566 1.35 christos
1567 1.35 christos buf = Buf_Init (0);
1568 1.35 christos
1569 1.35 christos av = brk_string(str, &ac, FALSE, &as);
1570 1.35 christos
1571 1.35 christos if (ac > 0)
1572 1.35 christos qsort(av, ac, sizeof(char *), VarWordCompare);
1573 1.35 christos
1574 1.35 christos for (i = 0; i < ac; i++) {
1575 1.35 christos Buf_AddBytes(buf, strlen(av[i]), (Byte *) av[i]);
1576 1.35 christos if (i != ac - 1)
1577 1.35 christos Buf_AddByte (buf, ' ');
1578 1.35 christos }
1579 1.35 christos
1580 1.35 christos free(as);
1581 1.35 christos free(av);
1582 1.35 christos
1583 1.35 christos Buf_AddByte (buf, '\0');
1584 1.73 christos as = (char *)Buf_GetAll (buf, (int *)NULL);
1585 1.35 christos Buf_Destroy (buf, FALSE);
1586 1.73 christos return (as);
1587 1.35 christos }
1588 1.35 christos
1589 1.35 christos
1590 1.1 cgd /*-
1591 1.1 cgd *-----------------------------------------------------------------------
1592 1.55 christos * VarUniq --
1593 1.55 christos * Remove adjacent duplicate words.
1594 1.55 christos *
1595 1.70 wiz * Input:
1596 1.70 wiz * str String whose words should be sorted
1597 1.70 wiz *
1598 1.55 christos * Results:
1599 1.55 christos * A string containing the resulting words.
1600 1.55 christos *
1601 1.55 christos * Side Effects:
1602 1.55 christos * None.
1603 1.55 christos *
1604 1.55 christos *-----------------------------------------------------------------------
1605 1.55 christos */
1606 1.55 christos static char *
1607 1.73 christos VarUniq(const char *str)
1608 1.55 christos {
1609 1.55 christos Buffer buf; /* Buffer for new string */
1610 1.55 christos char **av; /* List of words to affect */
1611 1.55 christos char *as; /* Word list memory */
1612 1.55 christos int ac, i, j;
1613 1.55 christos
1614 1.55 christos buf = Buf_Init(0);
1615 1.55 christos av = brk_string(str, &ac, FALSE, &as);
1616 1.55 christos
1617 1.55 christos if (ac > 1) {
1618 1.55 christos for (j = 0, i = 1; i < ac; i++)
1619 1.55 christos if (strcmp(av[i], av[j]) != 0 && (++j != i))
1620 1.55 christos av[j] = av[i];
1621 1.55 christos ac = j + 1;
1622 1.55 christos }
1623 1.55 christos
1624 1.55 christos for (i = 0; i < ac; i++) {
1625 1.55 christos Buf_AddBytes(buf, strlen(av[i]), (Byte *)av[i]);
1626 1.55 christos if (i != ac - 1)
1627 1.55 christos Buf_AddByte(buf, ' ');
1628 1.55 christos }
1629 1.55 christos
1630 1.55 christos free(as);
1631 1.55 christos free(av);
1632 1.55 christos
1633 1.55 christos Buf_AddByte(buf, '\0');
1634 1.73 christos as = (char *)Buf_GetAll(buf, (int *)NULL);
1635 1.55 christos Buf_Destroy(buf, FALSE);
1636 1.73 christos return as;
1637 1.55 christos }
1638 1.55 christos
1639 1.55 christos
1640 1.55 christos /*-
1641 1.55 christos *-----------------------------------------------------------------------
1642 1.16 christos * VarGetPattern --
1643 1.16 christos * Pass through the tstr looking for 1) escaped delimiters,
1644 1.16 christos * '$'s and backslashes (place the escaped character in
1645 1.16 christos * uninterpreted) and 2) unescaped $'s that aren't before
1646 1.40 sjg * the delimiter (expand the variable substitution unless flags
1647 1.40 sjg * has VAR_NOSUBST set).
1648 1.16 christos * Return the expanded string or NULL if the delimiter was missing
1649 1.25 christos * If pattern is specified, handle escaped ampersands, and replace
1650 1.16 christos * unescaped ampersands with the lhs of the pattern.
1651 1.16 christos *
1652 1.16 christos * Results:
1653 1.16 christos * A string of all the words modified appropriately.
1654 1.16 christos * If length is specified, return the string length of the buffer
1655 1.16 christos * If flags is specified and the last character of the pattern is a
1656 1.16 christos * $ set the VAR_MATCH_END bit of flags.
1657 1.16 christos *
1658 1.16 christos * Side Effects:
1659 1.16 christos * None.
1660 1.16 christos *-----------------------------------------------------------------------
1661 1.16 christos */
1662 1.16 christos static char *
1663 1.81 sjg VarGetPattern(GNode *ctxt, Var_Parse_State *vpstate,
1664 1.81 sjg int err, const char **tstr, int delim, int *flags,
1665 1.70 wiz int *length, VarPattern *pattern)
1666 1.16 christos {
1667 1.73 christos const char *cp;
1668 1.16 christos Buffer buf = Buf_Init(0);
1669 1.16 christos int junk;
1670 1.16 christos if (length == NULL)
1671 1.16 christos length = &junk;
1672 1.16 christos
1673 1.16 christos #define IS_A_MATCH(cp, delim) \
1674 1.16 christos ((cp[0] == '\\') && ((cp[1] == delim) || \
1675 1.16 christos (cp[1] == '\\') || (cp[1] == '$') || (pattern && (cp[1] == '&'))))
1676 1.16 christos
1677 1.16 christos /*
1678 1.16 christos * Skim through until the matching delimiter is found;
1679 1.16 christos * pick up variable substitutions on the way. Also allow
1680 1.16 christos * backslashes to quote the delimiter, $, and \, but don't
1681 1.16 christos * touch other backslashes.
1682 1.16 christos */
1683 1.16 christos for (cp = *tstr; *cp && (*cp != delim); cp++) {
1684 1.16 christos if (IS_A_MATCH(cp, delim)) {
1685 1.16 christos Buf_AddByte(buf, (Byte) cp[1]);
1686 1.16 christos cp++;
1687 1.16 christos } else if (*cp == '$') {
1688 1.16 christos if (cp[1] == delim) {
1689 1.16 christos if (flags == NULL)
1690 1.16 christos Buf_AddByte(buf, (Byte) *cp);
1691 1.16 christos else
1692 1.16 christos /*
1693 1.16 christos * Unescaped $ at end of pattern => anchor
1694 1.16 christos * pattern at end.
1695 1.16 christos */
1696 1.16 christos *flags |= VAR_MATCH_END;
1697 1.40 sjg } else {
1698 1.40 sjg if (flags == NULL || (*flags & VAR_NOSUBST) == 0) {
1699 1.40 sjg char *cp2;
1700 1.40 sjg int len;
1701 1.40 sjg Boolean freeIt;
1702 1.40 sjg
1703 1.40 sjg /*
1704 1.40 sjg * If unescaped dollar sign not before the
1705 1.40 sjg * delimiter, assume it's a variable
1706 1.40 sjg * substitution and recurse.
1707 1.40 sjg */
1708 1.40 sjg cp2 = Var_Parse(cp, ctxt, err, &len, &freeIt);
1709 1.40 sjg Buf_AddBytes(buf, strlen(cp2), (Byte *) cp2);
1710 1.40 sjg if (freeIt)
1711 1.40 sjg free(cp2);
1712 1.40 sjg cp += len - 1;
1713 1.40 sjg } else {
1714 1.73 christos const char *cp2 = &cp[1];
1715 1.16 christos
1716 1.40 sjg if (*cp2 == '(' || *cp2 == '{') {
1717 1.40 sjg /*
1718 1.40 sjg * Find the end of this variable reference
1719 1.40 sjg * and suck it in without further ado.
1720 1.40 sjg * It will be interperated later.
1721 1.40 sjg */
1722 1.40 sjg int have = *cp2;
1723 1.40 sjg int want = (*cp2 == '(') ? ')' : '}';
1724 1.40 sjg int depth = 1;
1725 1.40 sjg
1726 1.40 sjg for (++cp2; *cp2 != '\0' && depth > 0; ++cp2) {
1727 1.40 sjg if (cp2[-1] != '\\') {
1728 1.40 sjg if (*cp2 == have)
1729 1.40 sjg ++depth;
1730 1.40 sjg if (*cp2 == want)
1731 1.40 sjg --depth;
1732 1.40 sjg }
1733 1.40 sjg }
1734 1.73 christos Buf_AddBytes(buf, cp2 - cp, (const Byte *)cp);
1735 1.40 sjg cp = --cp2;
1736 1.40 sjg } else
1737 1.40 sjg Buf_AddByte(buf, (Byte) *cp);
1738 1.40 sjg }
1739 1.16 christos }
1740 1.16 christos }
1741 1.16 christos else if (pattern && *cp == '&')
1742 1.73 christos Buf_AddBytes(buf, pattern->leftLen, (const Byte *)pattern->lhs);
1743 1.16 christos else
1744 1.16 christos Buf_AddByte(buf, (Byte) *cp);
1745 1.16 christos }
1746 1.16 christos
1747 1.16 christos Buf_AddByte(buf, (Byte) '\0');
1748 1.16 christos
1749 1.16 christos if (*cp != delim) {
1750 1.16 christos *tstr = cp;
1751 1.16 christos *length = 0;
1752 1.16 christos return NULL;
1753 1.16 christos }
1754 1.16 christos else {
1755 1.73 christos char *rstr;
1756 1.16 christos *tstr = ++cp;
1757 1.73 christos rstr = (char *) Buf_GetAll(buf, length);
1758 1.16 christos *length -= 1; /* Don't count the NULL */
1759 1.16 christos Buf_Destroy(buf, FALSE);
1760 1.73 christos return rstr;
1761 1.16 christos }
1762 1.16 christos }
1763 1.16 christos
1764 1.16 christos /*-
1765 1.16 christos *-----------------------------------------------------------------------
1766 1.16 christos * VarQuote --
1767 1.16 christos * Quote shell meta-characters in the string
1768 1.16 christos *
1769 1.16 christos * Results:
1770 1.16 christos * The quoted string
1771 1.16 christos *
1772 1.16 christos * Side Effects:
1773 1.16 christos * None.
1774 1.16 christos *
1775 1.16 christos *-----------------------------------------------------------------------
1776 1.16 christos */
1777 1.16 christos static char *
1778 1.70 wiz VarQuote(char *str)
1779 1.16 christos {
1780 1.16 christos
1781 1.16 christos Buffer buf;
1782 1.16 christos /* This should cover most shells :-( */
1783 1.16 christos static char meta[] = "\n \t'`\";&<>()|*?{}[]\\$!#^~";
1784 1.16 christos
1785 1.16 christos buf = Buf_Init (MAKE_BSIZE);
1786 1.16 christos for (; *str; str++) {
1787 1.16 christos if (strchr(meta, *str) != NULL)
1788 1.16 christos Buf_AddByte(buf, (Byte)'\\');
1789 1.16 christos Buf_AddByte(buf, (Byte)*str);
1790 1.16 christos }
1791 1.16 christos Buf_AddByte(buf, (Byte) '\0');
1792 1.16 christos str = (char *)Buf_GetAll (buf, (int *)NULL);
1793 1.16 christos Buf_Destroy (buf, FALSE);
1794 1.16 christos return str;
1795 1.16 christos }
1796 1.16 christos
1797 1.68 pk /*-
1798 1.68 pk *-----------------------------------------------------------------------
1799 1.68 pk * VarChangeCase --
1800 1.68 pk * Change the string to all uppercase or all lowercase
1801 1.68 pk *
1802 1.70 wiz * Input:
1803 1.70 wiz * str String to modify
1804 1.70 wiz * upper TRUE -> uppercase, else lowercase
1805 1.70 wiz *
1806 1.68 pk * Results:
1807 1.68 pk * The string with case changed
1808 1.68 pk *
1809 1.68 pk * Side Effects:
1810 1.68 pk * None.
1811 1.68 pk *
1812 1.68 pk *-----------------------------------------------------------------------
1813 1.68 pk */
1814 1.68 pk static char *
1815 1.70 wiz VarChangeCase(char *str, int upper)
1816 1.68 pk {
1817 1.68 pk Buffer buf;
1818 1.70 wiz int (*modProc)(int);
1819 1.68 pk
1820 1.68 pk modProc = (upper ? toupper : tolower);
1821 1.68 pk buf = Buf_Init (MAKE_BSIZE);
1822 1.68 pk for (; *str ; str++) {
1823 1.68 pk Buf_AddByte(buf, (Byte) modProc(*str));
1824 1.68 pk }
1825 1.68 pk Buf_AddByte(buf, (Byte) '\0');
1826 1.68 pk str = (char *) Buf_GetAll (buf, (int *) NULL);
1827 1.68 pk Buf_Destroy (buf, FALSE);
1828 1.68 pk return str;
1829 1.68 pk }
1830 1.16 christos
1831 1.16 christos /*-
1832 1.16 christos *-----------------------------------------------------------------------
1833 1.1 cgd * Var_Parse --
1834 1.1 cgd * Given the start of a variable invocation, extract the variable
1835 1.1 cgd * name and find its value, then modify it according to the
1836 1.1 cgd * specification.
1837 1.1 cgd *
1838 1.70 wiz * Input:
1839 1.70 wiz * str The string to parse
1840 1.70 wiz * ctxt The context for the variable
1841 1.70 wiz * err TRUE if undefined variables are an error
1842 1.70 wiz * lengthPtr OUT: The length of the specification
1843 1.70 wiz * freePtr OUT: TRUE if caller should free result
1844 1.70 wiz *
1845 1.1 cgd * Results:
1846 1.1 cgd * The (possibly-modified) value of the variable or var_Error if the
1847 1.1 cgd * specification is invalid. The length of the specification is
1848 1.1 cgd * placed in *lengthPtr (for invalid specifications, this is just
1849 1.1 cgd * 2...?).
1850 1.1 cgd * A Boolean in *freePtr telling whether the returned string should
1851 1.1 cgd * be freed by the caller.
1852 1.1 cgd *
1853 1.1 cgd * Side Effects:
1854 1.1 cgd * None.
1855 1.1 cgd *
1856 1.1 cgd *-----------------------------------------------------------------------
1857 1.1 cgd */
1858 1.1 cgd char *
1859 1.73 christos Var_Parse(const char *str, GNode *ctxt, Boolean err, int *lengthPtr,
1860 1.70 wiz Boolean *freePtr)
1861 1.1 cgd {
1862 1.73 christos const char *tstr; /* Pointer into str */
1863 1.73 christos Var *v; /* Variable in invocation */
1864 1.73 christos const char *cp; /* Secondary pointer into str (place marker
1865 1.1 cgd * for tstr) */
1866 1.1 cgd Boolean haveModifier;/* TRUE if have modifiers for the variable */
1867 1.70 wiz char endc; /* Ending character when variable in parens
1868 1.1 cgd * or braces */
1869 1.70 wiz char startc=0; /* Starting character when variable in parens
1870 1.9 christos * or braces */
1871 1.9 christos int cnt; /* Used to count brace pairs when variable in
1872 1.9 christos * in parens or braces */
1873 1.22 christos int vlen; /* Length of variable name */
1874 1.73 christos const char *start;
1875 1.73 christos char delim;
1876 1.73 christos char *nstr;
1877 1.1 cgd Boolean dynamic; /* TRUE if the variable is local and we're
1878 1.1 cgd * expanding it in a non-local context. This
1879 1.1 cgd * is done to support dynamic sources. The
1880 1.1 cgd * result is just the invocation, unaltered */
1881 1.81 sjg Var_Parse_State parsestate = {0}; /* Flags passed to helper functions */
1882 1.15 christos
1883 1.1 cgd *freePtr = FALSE;
1884 1.1 cgd dynamic = FALSE;
1885 1.1 cgd start = str;
1886 1.81 sjg parsestate.oneBigWord = FALSE;
1887 1.81 sjg parsestate.varSpace = ' '; /* word separator */
1888 1.15 christos
1889 1.1 cgd if (str[1] != '(' && str[1] != '{') {
1890 1.1 cgd /*
1891 1.1 cgd * If it's not bounded by braces of some sort, life is much simpler.
1892 1.1 cgd * We just need to check for the first character and return the
1893 1.1 cgd * value if it exists.
1894 1.1 cgd */
1895 1.1 cgd char name[2];
1896 1.1 cgd
1897 1.1 cgd name[0] = str[1];
1898 1.1 cgd name[1] = '\0';
1899 1.1 cgd
1900 1.48 mycroft v = VarFind (name, ctxt, FIND_ENV | FIND_GLOBAL | FIND_CMD);
1901 1.1 cgd if (v == (Var *)NIL) {
1902 1.1 cgd *lengthPtr = 2;
1903 1.15 christos
1904 1.48 mycroft if ((ctxt == VAR_CMD) || (ctxt == VAR_GLOBAL)) {
1905 1.1 cgd /*
1906 1.1 cgd * If substituting a local variable in a non-local context,
1907 1.1 cgd * assume it's for dynamic source stuff. We have to handle
1908 1.1 cgd * this specially and return the longhand for the variable
1909 1.1 cgd * with the dollar sign escaped so it makes it back to the
1910 1.1 cgd * caller. Only four of the local variables are treated
1911 1.1 cgd * specially as they are the only four that will be set
1912 1.1 cgd * when dynamic sources are expanded.
1913 1.1 cgd */
1914 1.1 cgd switch (str[1]) {
1915 1.1 cgd case '@':
1916 1.73 christos return UNCONST("$(.TARGET)");
1917 1.1 cgd case '%':
1918 1.73 christos return UNCONST("$(.ARCHIVE)");
1919 1.1 cgd case '*':
1920 1.73 christos return UNCONST("$(.PREFIX)");
1921 1.1 cgd case '!':
1922 1.73 christos return UNCONST("$(.MEMBER)");
1923 1.1 cgd }
1924 1.1 cgd }
1925 1.1 cgd /*
1926 1.1 cgd * Error
1927 1.1 cgd */
1928 1.1 cgd return (err ? var_Error : varNoError);
1929 1.1 cgd } else {
1930 1.1 cgd haveModifier = FALSE;
1931 1.1 cgd tstr = &str[1];
1932 1.1 cgd endc = str[1];
1933 1.1 cgd }
1934 1.1 cgd } else {
1935 1.22 christos Buffer buf; /* Holds the variable name */
1936 1.22 christos
1937 1.9 christos startc = str[1];
1938 1.9 christos endc = startc == '(' ? ')' : '}';
1939 1.22 christos buf = Buf_Init (MAKE_BSIZE);
1940 1.1 cgd
1941 1.1 cgd /*
1942 1.1 cgd * Skip to the end character or a colon, whichever comes first.
1943 1.1 cgd */
1944 1.1 cgd for (tstr = str + 2;
1945 1.1 cgd *tstr != '\0' && *tstr != endc && *tstr != ':';
1946 1.1 cgd tstr++)
1947 1.1 cgd {
1948 1.22 christos /*
1949 1.22 christos * A variable inside a variable, expand
1950 1.22 christos */
1951 1.22 christos if (*tstr == '$') {
1952 1.22 christos int rlen;
1953 1.22 christos Boolean rfree;
1954 1.22 christos char *rval = Var_Parse(tstr, ctxt, err, &rlen, &rfree);
1955 1.22 christos if (rval != NULL) {
1956 1.22 christos Buf_AddBytes(buf, strlen(rval), (Byte *) rval);
1957 1.22 christos if (rfree)
1958 1.22 christos free(rval);
1959 1.22 christos }
1960 1.22 christos tstr += rlen - 1;
1961 1.22 christos }
1962 1.22 christos else
1963 1.22 christos Buf_AddByte(buf, (Byte) *tstr);
1964 1.1 cgd }
1965 1.1 cgd if (*tstr == ':') {
1966 1.1 cgd haveModifier = TRUE;
1967 1.1 cgd } else if (*tstr != '\0') {
1968 1.1 cgd haveModifier = FALSE;
1969 1.1 cgd } else {
1970 1.1 cgd /*
1971 1.1 cgd * If we never did find the end character, return NULL
1972 1.1 cgd * right now, setting the length to be the distance to
1973 1.1 cgd * the end of the string, since that's what make does.
1974 1.1 cgd */
1975 1.1 cgd *lengthPtr = tstr - str;
1976 1.1 cgd return (var_Error);
1977 1.1 cgd }
1978 1.73 christos *WR(tstr) = '\0';
1979 1.22 christos Buf_AddByte(buf, (Byte) '\0');
1980 1.22 christos str = Buf_GetAll(buf, (int *) NULL);
1981 1.22 christos vlen = strlen(str);
1982 1.15 christos
1983 1.48 mycroft v = VarFind (str, ctxt, FIND_ENV | FIND_GLOBAL | FIND_CMD);
1984 1.48 mycroft if ((v == (Var *)NIL) && (ctxt != VAR_CMD) && (ctxt != VAR_GLOBAL) &&
1985 1.22 christos (vlen == 2) && (str[1] == 'F' || str[1] == 'D'))
1986 1.1 cgd {
1987 1.1 cgd /*
1988 1.1 cgd * Check for bogus D and F forms of local variables since we're
1989 1.1 cgd * in a local context and the name is the right length.
1990 1.1 cgd */
1991 1.22 christos switch(*str) {
1992 1.1 cgd case '@':
1993 1.1 cgd case '%':
1994 1.1 cgd case '*':
1995 1.1 cgd case '!':
1996 1.1 cgd case '>':
1997 1.1 cgd case '<':
1998 1.1 cgd {
1999 1.1 cgd char vname[2];
2000 1.1 cgd char *val;
2001 1.1 cgd
2002 1.1 cgd /*
2003 1.1 cgd * Well, it's local -- go look for it.
2004 1.1 cgd */
2005 1.22 christos vname[0] = *str;
2006 1.1 cgd vname[1] = '\0';
2007 1.1 cgd v = VarFind(vname, ctxt, 0);
2008 1.15 christos
2009 1.1 cgd if (v != (Var *)NIL) {
2010 1.1 cgd /*
2011 1.1 cgd * No need for nested expansion or anything, as we're
2012 1.1 cgd * the only one who sets these things and we sure don't
2013 1.1 cgd * but nested invocations in them...
2014 1.1 cgd */
2015 1.1 cgd val = (char *)Buf_GetAll(v->val, (int *)NULL);
2016 1.15 christos
2017 1.22 christos if (str[1] == 'D') {
2018 1.81 sjg val = VarModify(ctxt, &parsestate, val, VarHead,
2019 1.81 sjg (ClientData)0);
2020 1.1 cgd } else {
2021 1.81 sjg val = VarModify(ctxt, &parsestate, val, VarTail,
2022 1.81 sjg (ClientData)0);
2023 1.1 cgd }
2024 1.1 cgd /*
2025 1.1 cgd * Resulting string is dynamically allocated, so
2026 1.1 cgd * tell caller to free it.
2027 1.1 cgd */
2028 1.1 cgd *freePtr = TRUE;
2029 1.1 cgd *lengthPtr = tstr-start+1;
2030 1.73 christos *WR(tstr) = endc;
2031 1.22 christos Buf_Destroy (buf, TRUE);
2032 1.1 cgd return(val);
2033 1.1 cgd }
2034 1.1 cgd break;
2035 1.1 cgd }
2036 1.1 cgd }
2037 1.1 cgd }
2038 1.15 christos
2039 1.1 cgd if (v == (Var *)NIL) {
2040 1.22 christos if (((vlen == 1) ||
2041 1.22 christos (((vlen == 2) && (str[1] == 'F' ||
2042 1.22 christos str[1] == 'D')))) &&
2043 1.48 mycroft ((ctxt == VAR_CMD) || (ctxt == VAR_GLOBAL)))
2044 1.1 cgd {
2045 1.1 cgd /*
2046 1.1 cgd * If substituting a local variable in a non-local context,
2047 1.1 cgd * assume it's for dynamic source stuff. We have to handle
2048 1.1 cgd * this specially and return the longhand for the variable
2049 1.1 cgd * with the dollar sign escaped so it makes it back to the
2050 1.1 cgd * caller. Only four of the local variables are treated
2051 1.1 cgd * specially as they are the only four that will be set
2052 1.1 cgd * when dynamic sources are expanded.
2053 1.1 cgd */
2054 1.22 christos switch (*str) {
2055 1.1 cgd case '@':
2056 1.1 cgd case '%':
2057 1.1 cgd case '*':
2058 1.1 cgd case '!':
2059 1.1 cgd dynamic = TRUE;
2060 1.1 cgd break;
2061 1.1 cgd }
2062 1.22 christos } else if ((vlen > 2) && (*str == '.') &&
2063 1.22 christos isupper((unsigned char) str[1]) &&
2064 1.48 mycroft ((ctxt == VAR_CMD) || (ctxt == VAR_GLOBAL)))
2065 1.1 cgd {
2066 1.1 cgd int len;
2067 1.15 christos
2068 1.22 christos len = vlen - 1;
2069 1.22 christos if ((strncmp(str, ".TARGET", len) == 0) ||
2070 1.22 christos (strncmp(str, ".ARCHIVE", len) == 0) ||
2071 1.22 christos (strncmp(str, ".PREFIX", len) == 0) ||
2072 1.22 christos (strncmp(str, ".MEMBER", len) == 0))
2073 1.1 cgd {
2074 1.1 cgd dynamic = TRUE;
2075 1.1 cgd }
2076 1.1 cgd }
2077 1.15 christos
2078 1.1 cgd if (!haveModifier) {
2079 1.1 cgd /*
2080 1.1 cgd * No modifiers -- have specification length so we can return
2081 1.1 cgd * now.
2082 1.1 cgd */
2083 1.1 cgd *lengthPtr = tstr - start + 1;
2084 1.73 christos *WR(tstr) = endc;
2085 1.1 cgd if (dynamic) {
2086 1.73 christos char *pstr = emalloc(*lengthPtr + 1);
2087 1.73 christos strncpy(pstr, start, *lengthPtr);
2088 1.73 christos pstr[*lengthPtr] = '\0';
2089 1.1 cgd *freePtr = TRUE;
2090 1.22 christos Buf_Destroy (buf, TRUE);
2091 1.73 christos return(pstr);
2092 1.1 cgd } else {
2093 1.22 christos Buf_Destroy (buf, TRUE);
2094 1.1 cgd return (err ? var_Error : varNoError);
2095 1.1 cgd }
2096 1.1 cgd } else {
2097 1.1 cgd /*
2098 1.1 cgd * Still need to get to the end of the variable specification,
2099 1.1 cgd * so kludge up a Var structure for the modifications
2100 1.1 cgd */
2101 1.1 cgd v = (Var *) emalloc(sizeof(Var));
2102 1.73 christos v->name = UNCONST(str);
2103 1.1 cgd v->val = Buf_Init(1);
2104 1.1 cgd v->flags = VAR_JUNK;
2105 1.52 mycroft Buf_Destroy (buf, FALSE);
2106 1.1 cgd }
2107 1.52 mycroft } else
2108 1.52 mycroft Buf_Destroy (buf, TRUE);
2109 1.1 cgd }
2110 1.22 christos
2111 1.1 cgd
2112 1.1 cgd if (v->flags & VAR_IN_USE) {
2113 1.1 cgd Fatal("Variable %s is recursive.", v->name);
2114 1.1 cgd /*NOTREACHED*/
2115 1.1 cgd } else {
2116 1.1 cgd v->flags |= VAR_IN_USE;
2117 1.1 cgd }
2118 1.1 cgd /*
2119 1.1 cgd * Before doing any modification, we have to make sure the value
2120 1.1 cgd * has been fully expanded. If it looks like recursion might be
2121 1.1 cgd * necessary (there's a dollar sign somewhere in the variable's value)
2122 1.1 cgd * we just call Var_Subst to do any other substitutions that are
2123 1.1 cgd * necessary. Note that the value returned by Var_Subst will have
2124 1.1 cgd * been dynamically-allocated, so it will need freeing when we
2125 1.1 cgd * return.
2126 1.1 cgd */
2127 1.73 christos nstr = (char *)Buf_GetAll(v->val, (int *)NULL);
2128 1.73 christos if (strchr (nstr, '$') != (char *)NULL) {
2129 1.73 christos nstr = Var_Subst(NULL, nstr, ctxt, err);
2130 1.1 cgd *freePtr = TRUE;
2131 1.1 cgd }
2132 1.15 christos
2133 1.1 cgd v->flags &= ~VAR_IN_USE;
2134 1.15 christos
2135 1.1 cgd /*
2136 1.1 cgd * Now we need to apply any modifiers the user wants applied.
2137 1.1 cgd * These are:
2138 1.1 cgd * :M<pattern> words which match the given <pattern>.
2139 1.1 cgd * <pattern> is of the standard file
2140 1.1 cgd * wildcarding form.
2141 1.40 sjg * :N<pattern> words which do not match the given <pattern>.
2142 1.81 sjg * :S<d><pat1><d><pat2><d>[1gW]
2143 1.1 cgd * Substitute <pat2> for <pat1> in the value
2144 1.81 sjg * :C<d><pat1><d><pat2><d>[1gW]
2145 1.16 christos * Substitute <pat2> for regex <pat1> in the value
2146 1.1 cgd * :H Substitute the head of each word
2147 1.1 cgd * :T Substitute the tail of each word
2148 1.1 cgd * :E Substitute the extension (minus '.') of
2149 1.1 cgd * each word
2150 1.1 cgd * :R Substitute the root of each word
2151 1.1 cgd * (pathname minus the suffix).
2152 1.55 christos * :O ("Order") Sort words in variable.
2153 1.56 christos * :u ("uniq") Remove adjacent duplicate words.
2154 1.68 pk * :tu Converts the variable contents to uppercase.
2155 1.68 pk * :tl Converts the variable contents to lowercase.
2156 1.74 sjg * :ts[c] Sets varSpace - the char used to
2157 1.74 sjg * separate words to 'c'. If 'c' is
2158 1.74 sjg * omitted then no separation is used.
2159 1.81 sjg * :tW Treat the variable contents as a single
2160 1.81 sjg * word, even if it contains spaces.
2161 1.81 sjg * (Mnemonic: one big 'W'ord.)
2162 1.81 sjg * :tw Treat the variable contents as multiple
2163 1.81 sjg * space-separated words.
2164 1.81 sjg * (Mnemonic: many small 'w'ords.)
2165 1.81 sjg * :[index] Select a single word from the value.
2166 1.81 sjg * :[start..end] Select multiple words from the value.
2167 1.81 sjg * :[*] or :[0] Select the entire value, as a single
2168 1.81 sjg * word. Equivalent to :tW.
2169 1.81 sjg * :[@] Select the entire value, as multiple
2170 1.81 sjg * words. Undoes the effect of :[*].
2171 1.81 sjg * Equivalent to :tw.
2172 1.81 sjg * :[#] Returns the number of words in the value.
2173 1.74 sjg *
2174 1.25 christos * :?<true-value>:<false-value>
2175 1.25 christos * If the variable evaluates to true, return
2176 1.25 christos * true value, else return the second value.
2177 1.1 cgd * :lhs=rhs Like :S, but the rhs goes to the end of
2178 1.1 cgd * the invocation.
2179 1.40 sjg * :sh Treat the current value as a command
2180 1.40 sjg * to be run, new value is its output.
2181 1.40 sjg * The following added so we can handle ODE makefiles.
2182 1.40 sjg * :@<tmpvar>@<newval>@
2183 1.40 sjg * Assign a temporary local variable <tmpvar>
2184 1.40 sjg * to the current value of each word in turn
2185 1.40 sjg * and replace each word with the result of
2186 1.40 sjg * evaluating <newval>
2187 1.40 sjg * :D<newval> Use <newval> as value if variable defined
2188 1.40 sjg * :U<newval> Use <newval> as value if variable undefined
2189 1.40 sjg * :L Use the name of the variable as the value.
2190 1.40 sjg * :P Use the path of the node that has the same
2191 1.40 sjg * name as the variable as the value. This
2192 1.40 sjg * basically includes an implied :L so that
2193 1.40 sjg * the common method of refering to the path
2194 1.40 sjg * of your dependent 'x' in a rule is to use
2195 1.40 sjg * the form '${x:P}'.
2196 1.40 sjg * :!<cmd>! Run cmd much the same as :sh run's the
2197 1.40 sjg * current value of the variable.
2198 1.45 sjg * The ::= modifiers, actually assign a value to the variable.
2199 1.44 sjg * Their main purpose is in supporting modifiers of .for loop
2200 1.44 sjg * iterators and other obscure uses. They always expand to
2201 1.44 sjg * nothing. In a target rule that would otherwise expand to an
2202 1.44 sjg * empty line they can be preceded with @: to keep make happy.
2203 1.44 sjg * Eg.
2204 1.44 sjg *
2205 1.44 sjg * foo: .USE
2206 1.44 sjg * .for i in ${.TARGET} ${.TARGET:R}.gz
2207 1.45 sjg * @: ${t::=$i}
2208 1.44 sjg * @echo blah ${t:T}
2209 1.44 sjg * .endfor
2210 1.44 sjg *
2211 1.45 sjg * ::=<str> Assigns <str> as the new value of variable.
2212 1.45 sjg * ::?=<str> Assigns <str> as value of variable if
2213 1.44 sjg * it was not already set.
2214 1.45 sjg * ::+=<str> Appends <str> to variable.
2215 1.45 sjg * ::!=<cmd> Assigns output of <cmd> as the new value of
2216 1.44 sjg * variable.
2217 1.1 cgd */
2218 1.73 christos if ((nstr != (char *)NULL) && haveModifier) {
2219 1.1 cgd /*
2220 1.1 cgd * Skip initial colon while putting it back.
2221 1.1 cgd */
2222 1.73 christos *WR(tstr) = ':';
2223 1.73 christos tstr++;
2224 1.77 sjg delim = '\0';
2225 1.77 sjg
2226 1.72 christos while (*tstr && *tstr != endc) {
2227 1.1 cgd char *newStr; /* New value to return */
2228 1.1 cgd char termc; /* Character which terminated scan */
2229 1.15 christos
2230 1.1 cgd if (DEBUG(VAR)) {
2231 1.73 christos printf("Applying :%c to \"%s\"\n", *tstr, nstr);
2232 1.1 cgd }
2233 1.74 sjg newStr = var_Error;
2234 1.1 cgd switch (*tstr) {
2235 1.45 sjg case ':':
2236 1.81 sjg {
2237 1.45 sjg if (tstr[1] == '=' ||
2238 1.45 sjg (tstr[2] == '=' &&
2239 1.45 sjg (tstr[1] == '!' || tstr[1] == '+' || tstr[1] == '?'))) {
2240 1.81 sjg /*
2241 1.81 sjg * "::=", "::!=", "::+=", or "::?="
2242 1.81 sjg */
2243 1.44 sjg GNode *v_ctxt; /* context where v belongs */
2244 1.73 christos const char *emsg;
2245 1.86 dsl char *sv_name;
2246 1.44 sjg VarPattern pattern;
2247 1.44 sjg int how;
2248 1.45 sjg
2249 1.45 sjg ++tstr;
2250 1.44 sjg if (v->flags & VAR_JUNK) {
2251 1.44 sjg /*
2252 1.44 sjg * We need to strdup() it incase
2253 1.44 sjg * VarGetPattern() recurses.
2254 1.44 sjg */
2255 1.86 dsl sv_name = v->name;
2256 1.44 sjg v->name = strdup(v->name);
2257 1.44 sjg v_ctxt = ctxt;
2258 1.44 sjg } else if (ctxt != VAR_GLOBAL) {
2259 1.44 sjg if (VarFind(v->name, ctxt, 0) == (Var *)NIL)
2260 1.44 sjg v_ctxt = VAR_GLOBAL;
2261 1.44 sjg else
2262 1.44 sjg v_ctxt = ctxt;
2263 1.44 sjg }
2264 1.44 sjg
2265 1.45 sjg switch ((how = *tstr)) {
2266 1.44 sjg case '+':
2267 1.44 sjg case '?':
2268 1.44 sjg case '!':
2269 1.44 sjg cp = &tstr[2];
2270 1.44 sjg break;
2271 1.44 sjg default:
2272 1.44 sjg cp = ++tstr;
2273 1.44 sjg break;
2274 1.44 sjg }
2275 1.66 lukem /* '{' */
2276 1.44 sjg delim = '}';
2277 1.44 sjg pattern.flags = 0;
2278 1.44 sjg
2279 1.86 dsl pattern.rhs = VarGetPattern(ctxt, &parsestate, err,
2280 1.81 sjg &cp, delim, NULL,
2281 1.81 sjg &pattern.rightLen,
2282 1.86 dsl NULL);
2283 1.86 dsl if (v->flags & VAR_JUNK) {
2284 1.86 dsl /* restore original name */
2285 1.86 dsl free(v->name);
2286 1.86 dsl v->name = sv_name;
2287 1.86 dsl }
2288 1.86 dsl if (pattern.rhs == NULL)
2289 1.44 sjg goto cleanup;
2290 1.86 dsl
2291 1.44 sjg termc = *--cp;
2292 1.44 sjg delim = '\0';
2293 1.44 sjg
2294 1.48 mycroft switch (how) {
2295 1.48 mycroft case '+':
2296 1.48 mycroft Var_Append(v->name, pattern.rhs, v_ctxt);
2297 1.48 mycroft break;
2298 1.48 mycroft case '!':
2299 1.48 mycroft newStr = Cmd_Exec (pattern.rhs, &emsg);
2300 1.48 mycroft if (emsg)
2301 1.73 christos Error (emsg, nstr);
2302 1.48 mycroft else
2303 1.65 sjg Var_Set(v->name, newStr, v_ctxt, 0);
2304 1.48 mycroft if (newStr)
2305 1.48 mycroft free(newStr);
2306 1.48 mycroft break;
2307 1.48 mycroft case '?':
2308 1.48 mycroft if ((v->flags & VAR_JUNK) == 0)
2309 1.47 sjg break;
2310 1.48 mycroft /* FALLTHROUGH */
2311 1.48 mycroft default:
2312 1.65 sjg Var_Set(v->name, pattern.rhs, v_ctxt, 0);
2313 1.48 mycroft break;
2314 1.44 sjg }
2315 1.73 christos free(UNCONST(pattern.rhs));
2316 1.44 sjg newStr = var_Error;
2317 1.44 sjg break;
2318 1.44 sjg }
2319 1.81 sjg goto default_case; /* "::<unrecognised>" */
2320 1.81 sjg }
2321 1.40 sjg case '@':
2322 1.40 sjg {
2323 1.41 sjg VarLoop_t loop;
2324 1.40 sjg int flags = VAR_NOSUBST;
2325 1.40 sjg
2326 1.40 sjg cp = ++tstr;
2327 1.40 sjg delim = '@';
2328 1.81 sjg if ((loop.tvar = VarGetPattern(ctxt, &parsestate, err,
2329 1.81 sjg &cp, delim,
2330 1.41 sjg &flags, &loop.tvarLen,
2331 1.41 sjg NULL)) == NULL)
2332 1.40 sjg goto cleanup;
2333 1.40 sjg
2334 1.81 sjg if ((loop.str = VarGetPattern(ctxt, &parsestate, err,
2335 1.81 sjg &cp, delim,
2336 1.41 sjg &flags, &loop.strLen,
2337 1.41 sjg NULL)) == NULL)
2338 1.40 sjg goto cleanup;
2339 1.40 sjg
2340 1.40 sjg termc = *cp;
2341 1.40 sjg delim = '\0';
2342 1.40 sjg
2343 1.41 sjg loop.err = err;
2344 1.41 sjg loop.ctxt = ctxt;
2345 1.81 sjg newStr = VarModify(ctxt, &parsestate, nstr, VarLoopExpand,
2346 1.41 sjg (ClientData)&loop);
2347 1.41 sjg free(loop.tvar);
2348 1.41 sjg free(loop.str);
2349 1.40 sjg break;
2350 1.40 sjg }
2351 1.40 sjg case 'D':
2352 1.40 sjg case 'U':
2353 1.40 sjg {
2354 1.49 mycroft Buffer buf; /* Buffer for patterns */
2355 1.49 mycroft int wantit; /* want data in buffer */
2356 1.49 mycroft
2357 1.49 mycroft /*
2358 1.49 mycroft * Pass through tstr looking for 1) escaped delimiters,
2359 1.49 mycroft * '$'s and backslashes (place the escaped character in
2360 1.49 mycroft * uninterpreted) and 2) unescaped $'s that aren't before
2361 1.49 mycroft * the delimiter (expand the variable substitution).
2362 1.49 mycroft * The result is left in the Buffer buf.
2363 1.49 mycroft */
2364 1.49 mycroft buf = Buf_Init(0);
2365 1.49 mycroft for (cp = tstr + 1;
2366 1.49 mycroft *cp != endc && *cp != ':' && *cp != '\0';
2367 1.49 mycroft cp++) {
2368 1.49 mycroft if ((*cp == '\\') &&
2369 1.49 mycroft ((cp[1] == ':') ||
2370 1.49 mycroft (cp[1] == '$') ||
2371 1.49 mycroft (cp[1] == endc) ||
2372 1.49 mycroft (cp[1] == '\\')))
2373 1.49 mycroft {
2374 1.49 mycroft Buf_AddByte(buf, (Byte) cp[1]);
2375 1.49 mycroft cp++;
2376 1.49 mycroft } else if (*cp == '$') {
2377 1.49 mycroft /*
2378 1.49 mycroft * If unescaped dollar sign, assume it's a
2379 1.49 mycroft * variable substitution and recurse.
2380 1.49 mycroft */
2381 1.49 mycroft char *cp2;
2382 1.49 mycroft int len;
2383 1.49 mycroft Boolean freeIt;
2384 1.49 mycroft
2385 1.49 mycroft cp2 = Var_Parse(cp, ctxt, err, &len, &freeIt);
2386 1.49 mycroft Buf_AddBytes(buf, strlen(cp2), (Byte *) cp2);
2387 1.49 mycroft if (freeIt)
2388 1.49 mycroft free(cp2);
2389 1.49 mycroft cp += len - 1;
2390 1.49 mycroft } else {
2391 1.49 mycroft Buf_AddByte(buf, (Byte) *cp);
2392 1.49 mycroft }
2393 1.49 mycroft }
2394 1.49 mycroft Buf_AddByte(buf, (Byte) '\0');
2395 1.40 sjg
2396 1.49 mycroft termc = *cp;
2397 1.40 sjg
2398 1.49 mycroft if (*tstr == 'U')
2399 1.49 mycroft wantit = ((v->flags & VAR_JUNK) != 0);
2400 1.49 mycroft else
2401 1.49 mycroft wantit = ((v->flags & VAR_JUNK) == 0);
2402 1.50 mycroft if ((v->flags & VAR_JUNK) != 0)
2403 1.50 mycroft v->flags |= VAR_KEEP;
2404 1.49 mycroft if (wantit) {
2405 1.49 mycroft newStr = (char *)Buf_GetAll(buf, (int *)NULL);
2406 1.49 mycroft Buf_Destroy(buf, FALSE);
2407 1.49 mycroft } else {
2408 1.73 christos newStr = nstr;
2409 1.49 mycroft Buf_Destroy(buf, TRUE);
2410 1.40 sjg }
2411 1.40 sjg break;
2412 1.40 sjg }
2413 1.40 sjg case 'L':
2414 1.40 sjg {
2415 1.52 mycroft if ((v->flags & VAR_JUNK) != 0)
2416 1.40 sjg v->flags |= VAR_KEEP;
2417 1.52 mycroft newStr = strdup(v->name);
2418 1.40 sjg cp = ++tstr;
2419 1.40 sjg termc = *tstr;
2420 1.40 sjg break;
2421 1.40 sjg }
2422 1.40 sjg case 'P':
2423 1.40 sjg {
2424 1.40 sjg GNode *gn;
2425 1.40 sjg
2426 1.52 mycroft if ((v->flags & VAR_JUNK) != 0)
2427 1.40 sjg v->flags |= VAR_KEEP;
2428 1.52 mycroft gn = Targ_FindNode(v->name, TARG_NOCREATE);
2429 1.59 sjg if (gn == NILGNODE || gn->path == NULL)
2430 1.52 mycroft newStr = strdup(v->name);
2431 1.52 mycroft else
2432 1.52 mycroft newStr = strdup(gn->path);
2433 1.40 sjg cp = ++tstr;
2434 1.40 sjg termc = *tstr;
2435 1.40 sjg break;
2436 1.40 sjg }
2437 1.40 sjg case '!':
2438 1.40 sjg {
2439 1.73 christos const char *emsg;
2440 1.40 sjg VarPattern pattern;
2441 1.40 sjg pattern.flags = 0;
2442 1.40 sjg
2443 1.40 sjg delim = '!';
2444 1.40 sjg
2445 1.40 sjg cp = ++tstr;
2446 1.81 sjg if ((pattern.rhs = VarGetPattern(ctxt, &parsestate, err,
2447 1.81 sjg &cp, delim,
2448 1.81 sjg NULL, &pattern.rightLen,
2449 1.81 sjg NULL)) == NULL)
2450 1.40 sjg goto cleanup;
2451 1.40 sjg newStr = Cmd_Exec (pattern.rhs, &emsg);
2452 1.73 christos free(UNCONST(pattern.rhs));
2453 1.40 sjg if (emsg)
2454 1.73 christos Error (emsg, nstr);
2455 1.40 sjg termc = *cp;
2456 1.40 sjg delim = '\0';
2457 1.40 sjg if (v->flags & VAR_JUNK) {
2458 1.40 sjg v->flags |= VAR_KEEP;
2459 1.68 pk }
2460 1.68 pk break;
2461 1.68 pk }
2462 1.81 sjg case '[':
2463 1.81 sjg {
2464 1.81 sjg /*
2465 1.81 sjg * Look for the closing ']', recursively
2466 1.81 sjg * expanding any embedded variables.
2467 1.81 sjg *
2468 1.81 sjg * estr is a pointer to the expanded result,
2469 1.81 sjg * which we must free().
2470 1.81 sjg */
2471 1.81 sjg char *estr;
2472 1.81 sjg
2473 1.81 sjg cp = tstr+1; /* point to char after '[' */
2474 1.81 sjg delim = ']'; /* look for closing ']' */
2475 1.81 sjg estr = VarGetPattern(ctxt, &parsestate,
2476 1.81 sjg err, &cp, delim,
2477 1.81 sjg NULL, NULL, NULL);
2478 1.81 sjg if (estr == NULL)
2479 1.81 sjg goto cleanup; /* report missing ']' */
2480 1.81 sjg /* now cp points just after the closing ']' */
2481 1.81 sjg delim = '\0';
2482 1.81 sjg if (cp[0] != ':' && cp[0] != endc) {
2483 1.81 sjg /* Found junk after ']' */
2484 1.81 sjg free(estr);
2485 1.81 sjg goto bad_modifier;
2486 1.81 sjg }
2487 1.81 sjg if (estr[0] == '\0') {
2488 1.81 sjg /* Found empty square brackets in ":[]". */
2489 1.81 sjg free(estr);
2490 1.81 sjg goto bad_modifier;
2491 1.81 sjg } else if (estr[0] == '#' && estr[1] == '\0') {
2492 1.81 sjg /* Found ":[#]" */
2493 1.82 jmc
2494 1.82 jmc /*
2495 1.82 jmc * We will need enough space for the decimal
2496 1.82 jmc * representation of an int. We calculate the
2497 1.82 jmc * space needed for the octal representation,
2498 1.82 jmc * and add enough slop to cope with a '-' sign
2499 1.82 jmc * (which should never be needed) and a '\0'
2500 1.82 jmc * string terminator.
2501 1.82 jmc */
2502 1.82 jmc int newStrSize =
2503 1.82 jmc (sizeof(int) * CHAR_BIT + 2) / 3 + 2;
2504 1.82 jmc
2505 1.82 jmc newStr = emalloc(newStrSize);
2506 1.82 jmc if (parsestate.oneBigWord) {
2507 1.82 jmc strncpy(newStr, "1", newStrSize);
2508 1.82 jmc } else {
2509 1.81 sjg /* XXX: brk_string() is a rather expensive
2510 1.81 sjg * way of counting words. */
2511 1.81 sjg char **av;
2512 1.81 sjg char *as;
2513 1.81 sjg int ac;
2514 1.81 sjg
2515 1.81 sjg av = brk_string(nstr, &ac, FALSE, &as);
2516 1.82 jmc snprintf(newStr, newStrSize, "%d", ac);
2517 1.81 sjg free(as);
2518 1.81 sjg free(av);
2519 1.81 sjg }
2520 1.81 sjg termc = *cp;
2521 1.81 sjg free(estr);
2522 1.81 sjg break;
2523 1.81 sjg } else if (estr[0] == '*' && estr[1] == '\0') {
2524 1.81 sjg /* Found ":[*]" */
2525 1.81 sjg parsestate.oneBigWord = TRUE;
2526 1.81 sjg newStr = nstr;
2527 1.81 sjg termc = *cp;
2528 1.81 sjg free(estr);
2529 1.81 sjg break;
2530 1.81 sjg } else if (estr[0] == '@' && estr[1] == '\0') {
2531 1.81 sjg /* Found ":[@]" */
2532 1.81 sjg parsestate.oneBigWord = FALSE;
2533 1.81 sjg newStr = nstr;
2534 1.81 sjg termc = *cp;
2535 1.81 sjg free(estr);
2536 1.81 sjg break;
2537 1.81 sjg } else {
2538 1.81 sjg /*
2539 1.81 sjg * We expect estr to contain a single
2540 1.81 sjg * integer for :[N], or two integers
2541 1.81 sjg * separated by ".." for :[start..end].
2542 1.81 sjg */
2543 1.81 sjg char *ep;
2544 1.81 sjg
2545 1.81 sjg VarSelectWords_t seldata = { 0, 0 };
2546 1.81 sjg
2547 1.81 sjg seldata.start = strtol(estr, &ep, 0);
2548 1.81 sjg if (ep == estr) {
2549 1.81 sjg /* Found junk instead of a number */
2550 1.81 sjg free(estr);
2551 1.81 sjg goto bad_modifier;
2552 1.81 sjg } else if (ep[0] == '\0') {
2553 1.81 sjg /* Found only one integer in :[N] */
2554 1.81 sjg seldata.end = seldata.start;
2555 1.81 sjg } else if (ep[0] == '.' && ep[1] == '.' &&
2556 1.81 sjg ep[2] != '\0') {
2557 1.81 sjg /* Expecting another integer after ".." */
2558 1.81 sjg ep += 2;
2559 1.81 sjg seldata.end = strtol(ep, &ep, 0);
2560 1.81 sjg if (ep[0] != '\0') {
2561 1.81 sjg /* Found junk after ".." */
2562 1.81 sjg free(estr);
2563 1.81 sjg goto bad_modifier;
2564 1.81 sjg }
2565 1.81 sjg } else {
2566 1.81 sjg /* Found junk instead of ".." */
2567 1.81 sjg free(estr);
2568 1.81 sjg goto bad_modifier;
2569 1.81 sjg }
2570 1.81 sjg /*
2571 1.81 sjg * Now seldata is properly filled in,
2572 1.81 sjg * but we still have to check for 0 as
2573 1.81 sjg * a special case.
2574 1.81 sjg */
2575 1.81 sjg if (seldata.start == 0 && seldata.end == 0) {
2576 1.81 sjg /* ":[0]" or perhaps ":[0..0]" */
2577 1.81 sjg parsestate.oneBigWord = TRUE;
2578 1.81 sjg newStr = nstr;
2579 1.81 sjg termc = *cp;
2580 1.81 sjg free(estr);
2581 1.81 sjg break;
2582 1.81 sjg } else if (seldata.start == 0 ||
2583 1.81 sjg seldata.end == 0) {
2584 1.81 sjg /* ":[0..N]" or ":[N..0]" */
2585 1.81 sjg free(estr);
2586 1.81 sjg goto bad_modifier;
2587 1.81 sjg }
2588 1.81 sjg /*
2589 1.81 sjg * Normal case: select the words
2590 1.81 sjg * described by seldata.
2591 1.81 sjg */
2592 1.81 sjg newStr = VarSelectWords(ctxt, &parsestate,
2593 1.81 sjg nstr, &seldata);
2594 1.81 sjg
2595 1.81 sjg termc = *cp;
2596 1.81 sjg free(estr);
2597 1.81 sjg break;
2598 1.81 sjg }
2599 1.81 sjg
2600 1.81 sjg }
2601 1.68 pk case 't':
2602 1.68 pk {
2603 1.74 sjg cp = tstr + 1; /* make sure it is set */
2604 1.68 pk if (tstr[1] != endc && tstr[1] != ':') {
2605 1.74 sjg if (tstr[1] == 's') {
2606 1.74 sjg /*
2607 1.74 sjg * Use the char (if any) at tstr[2]
2608 1.74 sjg * as the word separator.
2609 1.74 sjg */
2610 1.74 sjg VarPattern pattern;
2611 1.74 sjg
2612 1.76 sjg if (tstr[2] != endc &&
2613 1.76 sjg (tstr[3] == endc || tstr[3] == ':')) {
2614 1.81 sjg /* ":ts<unrecognised><endc>" or
2615 1.81 sjg * ":ts<unrecognised>:" */
2616 1.81 sjg parsestate.varSpace = tstr[2];
2617 1.74 sjg cp = tstr + 3;
2618 1.74 sjg } else if (tstr[2] == endc || tstr[2] == ':') {
2619 1.81 sjg /* ":ts<endc>" or ":ts:" */
2620 1.81 sjg parsestate.varSpace = 0; /* no separator */
2621 1.74 sjg cp = tstr + 2;
2622 1.74 sjg } else if (tstr[2] == '\\') {
2623 1.74 sjg switch (tstr[3]) {
2624 1.74 sjg case 'n':
2625 1.81 sjg parsestate.varSpace = '\n';
2626 1.74 sjg cp = tstr + 4;
2627 1.74 sjg break;
2628 1.74 sjg case 't':
2629 1.81 sjg parsestate.varSpace = '\t';
2630 1.74 sjg cp = tstr + 4;
2631 1.74 sjg break;
2632 1.74 sjg default:
2633 1.74 sjg if (isdigit(tstr[3])) {
2634 1.74 sjg char *ep;
2635 1.74 sjg
2636 1.81 sjg parsestate.varSpace =
2637 1.81 sjg strtoul(&tstr[3], &ep, 0);
2638 1.81 sjg if (*ep != ':' && *ep != endc)
2639 1.81 sjg goto bad_modifier;
2640 1.74 sjg cp = ep;
2641 1.74 sjg } else {
2642 1.81 sjg /*
2643 1.81 sjg * ":ts<backslash><unrecognised>".
2644 1.81 sjg */
2645 1.74 sjg goto bad_modifier;
2646 1.74 sjg }
2647 1.74 sjg break;
2648 1.74 sjg }
2649 1.81 sjg } else {
2650 1.81 sjg /*
2651 1.81 sjg * Found ":ts<unrecognised><unrecognised>".
2652 1.81 sjg */
2653 1.74 sjg break; /* not us */
2654 1.81 sjg }
2655 1.74 sjg
2656 1.74 sjg termc = *cp;
2657 1.74 sjg
2658 1.74 sjg /*
2659 1.74 sjg * We cannot be certain that VarModify
2660 1.74 sjg * will be used - even if there is a
2661 1.74 sjg * subsequent modifier, so do a no-op
2662 1.74 sjg * VarSubstitute now to for str to be
2663 1.74 sjg * re-expanded without the spaces.
2664 1.74 sjg */
2665 1.74 sjg pattern.flags = VAR_SUB_ONE;
2666 1.74 sjg pattern.lhs = pattern.rhs = "\032";
2667 1.74 sjg pattern.leftLen = pattern.rightLen = 1;
2668 1.74 sjg
2669 1.81 sjg newStr = VarModify(ctxt, &parsestate, nstr,
2670 1.81 sjg VarSubstitute,
2671 1.74 sjg (ClientData)&pattern);
2672 1.74 sjg } else if (tstr[2] == endc || tstr[2] == ':') {
2673 1.81 sjg /*
2674 1.81 sjg * Check for two-character options:
2675 1.81 sjg * ":tu", ":tl"
2676 1.81 sjg */
2677 1.68 pk if (tstr[1] == 'u' || tstr[1] == 'l') {
2678 1.73 christos newStr = VarChangeCase (nstr, (tstr[1] == 'u'));
2679 1.68 pk cp = tstr + 2;
2680 1.68 pk termc = *cp;
2681 1.81 sjg } else if (tstr[1] == 'W' || tstr[1] == 'w') {
2682 1.81 sjg parsestate.oneBigWord = (tstr[1] == 'W');
2683 1.81 sjg newStr = nstr;
2684 1.81 sjg cp = tstr + 2;
2685 1.81 sjg termc = *cp;
2686 1.74 sjg } else {
2687 1.81 sjg /* Found ":t<unrecognised>:" or
2688 1.81 sjg * ":t<unrecognised><endc>". */
2689 1.74 sjg goto bad_modifier;
2690 1.74 sjg }
2691 1.81 sjg } else {
2692 1.81 sjg /*
2693 1.81 sjg * Found ":t<unrecognised><unrecognised>".
2694 1.81 sjg * Should this be an error?
2695 1.81 sjg */
2696 1.74 sjg }
2697 1.81 sjg } else {
2698 1.81 sjg /*
2699 1.81 sjg * Found ":t<endc>" or ":t:".
2700 1.81 sjg * Should this be an error?
2701 1.81 sjg */
2702 1.40 sjg }
2703 1.40 sjg break;
2704 1.40 sjg }
2705 1.1 cgd case 'N':
2706 1.1 cgd case 'M':
2707 1.1 cgd {
2708 1.1 cgd char *pattern;
2709 1.1 cgd char *cp2;
2710 1.1 cgd Boolean copy;
2711 1.43 sjg int nest;
2712 1.1 cgd
2713 1.1 cgd copy = FALSE;
2714 1.43 sjg nest = 1;
2715 1.1 cgd for (cp = tstr + 1;
2716 1.43 sjg *cp != '\0' && *cp != ':';
2717 1.1 cgd cp++)
2718 1.1 cgd {
2719 1.43 sjg if (*cp == '\\' &&
2720 1.43 sjg (cp[1] == ':' ||
2721 1.43 sjg cp[1] == endc || cp[1] == startc)) {
2722 1.1 cgd copy = TRUE;
2723 1.1 cgd cp++;
2724 1.43 sjg continue;
2725 1.43 sjg }
2726 1.43 sjg if (*cp == startc)
2727 1.43 sjg ++nest;
2728 1.43 sjg if (*cp == endc) {
2729 1.43 sjg --nest;
2730 1.43 sjg if (nest == 0)
2731 1.43 sjg break;
2732 1.1 cgd }
2733 1.1 cgd }
2734 1.1 cgd termc = *cp;
2735 1.73 christos *WR(cp) = '\0';
2736 1.1 cgd if (copy) {
2737 1.1 cgd /*
2738 1.1 cgd * Need to compress the \:'s out of the pattern, so
2739 1.1 cgd * allocate enough room to hold the uncompressed
2740 1.1 cgd * pattern (note that cp started at tstr+1, so
2741 1.1 cgd * cp - tstr takes the null byte into account) and
2742 1.1 cgd * compress the pattern into the space.
2743 1.1 cgd */
2744 1.1 cgd pattern = emalloc(cp - tstr);
2745 1.1 cgd for (cp2 = pattern, cp = tstr + 1;
2746 1.1 cgd *cp != '\0';
2747 1.1 cgd cp++, cp2++)
2748 1.1 cgd {
2749 1.1 cgd if ((*cp == '\\') &&
2750 1.1 cgd (cp[1] == ':' || cp[1] == endc)) {
2751 1.1 cgd cp++;
2752 1.1 cgd }
2753 1.1 cgd *cp2 = *cp;
2754 1.1 cgd }
2755 1.1 cgd *cp2 = '\0';
2756 1.1 cgd } else {
2757 1.73 christos pattern = UNCONST(&tstr[1]);
2758 1.43 sjg }
2759 1.43 sjg if ((cp2 = strchr(pattern, '$'))) {
2760 1.43 sjg cp2 = pattern;
2761 1.43 sjg pattern = Var_Subst(NULL, cp2, ctxt, err);
2762 1.43 sjg if (copy)
2763 1.43 sjg free(cp2);
2764 1.43 sjg copy = TRUE;
2765 1.1 cgd }
2766 1.1 cgd if (*tstr == 'M' || *tstr == 'm') {
2767 1.81 sjg newStr = VarModify(ctxt, &parsestate, nstr, VarMatch,
2768 1.81 sjg (ClientData)pattern);
2769 1.1 cgd } else {
2770 1.81 sjg newStr = VarModify(ctxt, &parsestate, nstr, VarNoMatch,
2771 1.1 cgd (ClientData)pattern);
2772 1.1 cgd }
2773 1.1 cgd if (copy) {
2774 1.1 cgd free(pattern);
2775 1.1 cgd }
2776 1.1 cgd break;
2777 1.1 cgd }
2778 1.1 cgd case 'S':
2779 1.1 cgd {
2780 1.1 cgd VarPattern pattern;
2781 1.81 sjg Var_Parse_State tmpparsestate;
2782 1.1 cgd
2783 1.1 cgd pattern.flags = 0;
2784 1.81 sjg tmpparsestate = parsestate;
2785 1.1 cgd delim = tstr[1];
2786 1.1 cgd tstr += 2;
2787 1.16 christos
2788 1.1 cgd /*
2789 1.1 cgd * If pattern begins with '^', it is anchored to the
2790 1.1 cgd * start of the word -- skip over it and flag pattern.
2791 1.1 cgd */
2792 1.1 cgd if (*tstr == '^') {
2793 1.1 cgd pattern.flags |= VAR_MATCH_START;
2794 1.1 cgd tstr += 1;
2795 1.1 cgd }
2796 1.1 cgd
2797 1.16 christos cp = tstr;
2798 1.81 sjg if ((pattern.lhs = VarGetPattern(ctxt, &parsestate, err,
2799 1.81 sjg &cp, delim,
2800 1.81 sjg &pattern.flags,
2801 1.81 sjg &pattern.leftLen,
2802 1.81 sjg NULL)) == NULL)
2803 1.16 christos goto cleanup;
2804 1.16 christos
2805 1.81 sjg if ((pattern.rhs = VarGetPattern(ctxt, &parsestate, err,
2806 1.81 sjg &cp, delim, NULL,
2807 1.81 sjg &pattern.rightLen,
2808 1.81 sjg &pattern)) == NULL)
2809 1.16 christos goto cleanup;
2810 1.15 christos
2811 1.1 cgd /*
2812 1.16 christos * Check for global substitution. If 'g' after the final
2813 1.16 christos * delimiter, substitution is global and is marked that
2814 1.16 christos * way.
2815 1.1 cgd */
2816 1.16 christos for (;; cp++) {
2817 1.16 christos switch (*cp) {
2818 1.16 christos case 'g':
2819 1.16 christos pattern.flags |= VAR_SUB_GLOBAL;
2820 1.16 christos continue;
2821 1.16 christos case '1':
2822 1.16 christos pattern.flags |= VAR_SUB_ONE;
2823 1.16 christos continue;
2824 1.81 sjg case 'W':
2825 1.81 sjg tmpparsestate.oneBigWord = TRUE;
2826 1.81 sjg continue;
2827 1.1 cgd }
2828 1.16 christos break;
2829 1.1 cgd }
2830 1.1 cgd
2831 1.16 christos termc = *cp;
2832 1.81 sjg newStr = VarModify(ctxt, &tmpparsestate, nstr,
2833 1.81 sjg VarSubstitute,
2834 1.16 christos (ClientData)&pattern);
2835 1.15 christos
2836 1.1 cgd /*
2837 1.16 christos * Free the two strings.
2838 1.1 cgd */
2839 1.73 christos free(UNCONST(pattern.lhs));
2840 1.73 christos free(UNCONST(pattern.rhs));
2841 1.78 sjg delim = '\0';
2842 1.25 christos break;
2843 1.25 christos }
2844 1.25 christos case '?':
2845 1.25 christos {
2846 1.25 christos VarPattern pattern;
2847 1.25 christos Boolean value;
2848 1.25 christos
2849 1.25 christos /* find ':', and then substitute accordingly */
2850 1.25 christos
2851 1.25 christos pattern.flags = 0;
2852 1.25 christos
2853 1.25 christos cp = ++tstr;
2854 1.26 cgd delim = ':';
2855 1.81 sjg if ((pattern.lhs = VarGetPattern(ctxt, &parsestate, err,
2856 1.81 sjg &cp, delim, NULL,
2857 1.81 sjg &pattern.leftLen,
2858 1.81 sjg NULL)) == NULL)
2859 1.25 christos goto cleanup;
2860 1.25 christos
2861 1.83 jmc /* '{' or '(' */
2862 1.83 jmc delim = endc;
2863 1.81 sjg if ((pattern.rhs = VarGetPattern(ctxt, &parsestate, err,
2864 1.81 sjg &cp, delim, NULL,
2865 1.81 sjg &pattern.rightLen,
2866 1.81 sjg NULL)) == NULL)
2867 1.25 christos goto cleanup;
2868 1.25 christos
2869 1.25 christos termc = *--cp;
2870 1.27 christos delim = '\0';
2871 1.66 lukem if (Cond_EvalExpression(1, v->name, &value, 0)
2872 1.66 lukem == COND_INVALID) {
2873 1.27 christos Error("Bad conditional expression `%s' in %s?%s:%s",
2874 1.66 lukem v->name, v->name, pattern.lhs, pattern.rhs);
2875 1.25 christos goto cleanup;
2876 1.27 christos }
2877 1.25 christos
2878 1.25 christos if (value) {
2879 1.73 christos newStr = UNCONST(pattern.lhs);
2880 1.73 christos free(UNCONST(pattern.rhs));
2881 1.25 christos } else {
2882 1.73 christos newStr = UNCONST(pattern.rhs);
2883 1.73 christos free(UNCONST(pattern.lhs));
2884 1.25 christos }
2885 1.85 sjg if (v->flags & VAR_JUNK) {
2886 1.85 sjg v->flags |= VAR_KEEP;
2887 1.85 sjg }
2888 1.16 christos break;
2889 1.16 christos }
2890 1.31 gwr #ifndef NO_REGEX
2891 1.16 christos case 'C':
2892 1.16 christos {
2893 1.16 christos VarREPattern pattern;
2894 1.16 christos char *re;
2895 1.16 christos int error;
2896 1.81 sjg Var_Parse_State tmpparsestate;
2897 1.1 cgd
2898 1.16 christos pattern.flags = 0;
2899 1.81 sjg tmpparsestate = parsestate;
2900 1.16 christos delim = tstr[1];
2901 1.16 christos tstr += 2;
2902 1.1 cgd
2903 1.16 christos cp = tstr;
2904 1.15 christos
2905 1.81 sjg if ((re = VarGetPattern(ctxt, &parsestate, err, &cp, delim,
2906 1.81 sjg NULL, NULL, NULL)) == NULL)
2907 1.16 christos goto cleanup;
2908 1.16 christos
2909 1.81 sjg if ((pattern.replace = VarGetPattern(ctxt, &parsestate,
2910 1.81 sjg err, &cp, delim, NULL,
2911 1.81 sjg NULL, NULL)) == NULL){
2912 1.16 christos free(re);
2913 1.16 christos goto cleanup;
2914 1.1 cgd }
2915 1.1 cgd
2916 1.16 christos for (;; cp++) {
2917 1.16 christos switch (*cp) {
2918 1.16 christos case 'g':
2919 1.16 christos pattern.flags |= VAR_SUB_GLOBAL;
2920 1.16 christos continue;
2921 1.16 christos case '1':
2922 1.16 christos pattern.flags |= VAR_SUB_ONE;
2923 1.16 christos continue;
2924 1.81 sjg case 'W':
2925 1.81 sjg tmpparsestate.oneBigWord = TRUE;
2926 1.81 sjg continue;
2927 1.1 cgd }
2928 1.16 christos break;
2929 1.1 cgd }
2930 1.1 cgd
2931 1.16 christos termc = *cp;
2932 1.1 cgd
2933 1.16 christos error = regcomp(&pattern.re, re, REG_EXTENDED);
2934 1.16 christos free(re);
2935 1.18 christos if (error) {
2936 1.18 christos *lengthPtr = cp - start + 1;
2937 1.16 christos VarREError(error, &pattern.re, "RE substitution error");
2938 1.16 christos free(pattern.replace);
2939 1.16 christos return (var_Error);
2940 1.1 cgd }
2941 1.1 cgd
2942 1.16 christos pattern.nsub = pattern.re.re_nsub + 1;
2943 1.16 christos if (pattern.nsub < 1)
2944 1.16 christos pattern.nsub = 1;
2945 1.16 christos if (pattern.nsub > 10)
2946 1.16 christos pattern.nsub = 10;
2947 1.16 christos pattern.matches = emalloc(pattern.nsub *
2948 1.16 christos sizeof(regmatch_t));
2949 1.81 sjg newStr = VarModify(ctxt, &tmpparsestate, nstr,
2950 1.81 sjg VarRESubstitute,
2951 1.16 christos (ClientData) &pattern);
2952 1.16 christos regfree(&pattern.re);
2953 1.16 christos free(pattern.replace);
2954 1.16 christos free(pattern.matches);
2955 1.78 sjg delim = '\0';
2956 1.1 cgd break;
2957 1.1 cgd }
2958 1.17 christos #endif
2959 1.16 christos case 'Q':
2960 1.16 christos if (tstr[1] == endc || tstr[1] == ':') {
2961 1.73 christos newStr = VarQuote (nstr);
2962 1.16 christos cp = tstr + 1;
2963 1.16 christos termc = *cp;
2964 1.16 christos break;
2965 1.16 christos }
2966 1.16 christos /*FALLTHRU*/
2967 1.1 cgd case 'T':
2968 1.1 cgd if (tstr[1] == endc || tstr[1] == ':') {
2969 1.81 sjg newStr = VarModify(ctxt, &parsestate, nstr, VarTail,
2970 1.81 sjg (ClientData)0);
2971 1.1 cgd cp = tstr + 1;
2972 1.1 cgd termc = *cp;
2973 1.1 cgd break;
2974 1.1 cgd }
2975 1.1 cgd /*FALLTHRU*/
2976 1.1 cgd case 'H':
2977 1.1 cgd if (tstr[1] == endc || tstr[1] == ':') {
2978 1.81 sjg newStr = VarModify(ctxt, &parsestate, nstr, VarHead,
2979 1.81 sjg (ClientData)0);
2980 1.1 cgd cp = tstr + 1;
2981 1.1 cgd termc = *cp;
2982 1.1 cgd break;
2983 1.1 cgd }
2984 1.1 cgd /*FALLTHRU*/
2985 1.1 cgd case 'E':
2986 1.1 cgd if (tstr[1] == endc || tstr[1] == ':') {
2987 1.81 sjg newStr = VarModify(ctxt, &parsestate, nstr, VarSuffix,
2988 1.81 sjg (ClientData)0);
2989 1.1 cgd cp = tstr + 1;
2990 1.1 cgd termc = *cp;
2991 1.1 cgd break;
2992 1.1 cgd }
2993 1.1 cgd /*FALLTHRU*/
2994 1.1 cgd case 'R':
2995 1.1 cgd if (tstr[1] == endc || tstr[1] == ':') {
2996 1.81 sjg newStr = VarModify(ctxt, &parsestate, nstr, VarRoot,
2997 1.81 sjg (ClientData)0);
2998 1.1 cgd cp = tstr + 1;
2999 1.1 cgd termc = *cp;
3000 1.1 cgd break;
3001 1.1 cgd }
3002 1.1 cgd /*FALLTHRU*/
3003 1.35 christos case 'O':
3004 1.35 christos if (tstr[1] == endc || tstr[1] == ':') {
3005 1.73 christos newStr = VarSort (nstr);
3006 1.35 christos cp = tstr + 1;
3007 1.35 christos termc = *cp;
3008 1.35 christos break;
3009 1.35 christos }
3010 1.55 christos /*FALLTHRU*/
3011 1.55 christos case 'u':
3012 1.55 christos if (tstr[1] == endc || tstr[1] == ':') {
3013 1.73 christos newStr = VarUniq (nstr);
3014 1.55 christos cp = tstr + 1;
3015 1.55 christos termc = *cp;
3016 1.55 christos break;
3017 1.55 christos }
3018 1.55 christos /*FALLTHRU*/
3019 1.13 christos #ifdef SUNSHCMD
3020 1.13 christos case 's':
3021 1.13 christos if (tstr[1] == 'h' && (tstr[2] == endc || tstr[2] == ':')) {
3022 1.73 christos const char *emsg;
3023 1.73 christos newStr = Cmd_Exec (nstr, &emsg);
3024 1.73 christos if (emsg)
3025 1.73 christos Error (emsg, nstr);
3026 1.13 christos cp = tstr + 2;
3027 1.13 christos termc = *cp;
3028 1.13 christos break;
3029 1.13 christos }
3030 1.13 christos /*FALLTHRU*/
3031 1.13 christos #endif
3032 1.40 sjg default:
3033 1.45 sjg default_case:
3034 1.13 christos {
3035 1.13 christos #ifdef SYSVVARSUB
3036 1.1 cgd /*
3037 1.1 cgd * This can either be a bogus modifier or a System-V
3038 1.1 cgd * substitution command.
3039 1.1 cgd */
3040 1.1 cgd VarPattern pattern;
3041 1.1 cgd Boolean eqFound;
3042 1.15 christos
3043 1.1 cgd pattern.flags = 0;
3044 1.1 cgd eqFound = FALSE;
3045 1.1 cgd /*
3046 1.1 cgd * First we make a pass through the string trying
3047 1.1 cgd * to verify it is a SYSV-make-style translation:
3048 1.1 cgd * it must be: <string1>=<string2>)
3049 1.1 cgd */
3050 1.9 christos cp = tstr;
3051 1.9 christos cnt = 1;
3052 1.9 christos while (*cp != '\0' && cnt) {
3053 1.1 cgd if (*cp == '=') {
3054 1.1 cgd eqFound = TRUE;
3055 1.1 cgd /* continue looking for endc */
3056 1.1 cgd }
3057 1.9 christos else if (*cp == endc)
3058 1.9 christos cnt--;
3059 1.9 christos else if (*cp == startc)
3060 1.9 christos cnt++;
3061 1.9 christos if (cnt)
3062 1.9 christos cp++;
3063 1.1 cgd }
3064 1.1 cgd if (*cp == endc && eqFound) {
3065 1.15 christos
3066 1.1 cgd /*
3067 1.1 cgd * Now we break this sucker into the lhs and
3068 1.1 cgd * rhs. We must null terminate them of course.
3069 1.1 cgd */
3070 1.84 jmc delim='=';
3071 1.84 jmc cp = tstr;
3072 1.84 jmc if ((pattern.lhs = VarGetPattern(ctxt, &parsestate,
3073 1.84 jmc err, &cp, delim, &pattern.flags,
3074 1.84 jmc &pattern.leftLen, NULL)) == NULL)
3075 1.84 jmc goto cleanup;
3076 1.84 jmc delim = endc;
3077 1.84 jmc if ((pattern.rhs = VarGetPattern(ctxt, &parsestate,
3078 1.84 jmc err, &cp, delim, NULL, &pattern.rightLen,
3079 1.84 jmc &pattern)) == NULL)
3080 1.84 jmc goto cleanup;
3081 1.15 christos
3082 1.1 cgd /*
3083 1.1 cgd * SYSV modifications happen through the whole
3084 1.1 cgd * string. Note the pattern is anchored at the end.
3085 1.1 cgd */
3086 1.84 jmc termc = *--cp;
3087 1.84 jmc delim = '\0';
3088 1.81 sjg newStr = VarModify(ctxt, &parsestate, nstr,
3089 1.81 sjg VarSYSVMatch,
3090 1.1 cgd (ClientData)&pattern);
3091 1.84 jmc free(UNCONST(pattern.lhs));
3092 1.84 jmc free(UNCONST(pattern.rhs));
3093 1.13 christos } else
3094 1.13 christos #endif
3095 1.13 christos {
3096 1.69 christos Error ("Unknown modifier '%c'", *tstr);
3097 1.1 cgd for (cp = tstr+1;
3098 1.1 cgd *cp != ':' && *cp != endc && *cp != '\0';
3099 1.15 christos cp++)
3100 1.5 cgd continue;
3101 1.1 cgd termc = *cp;
3102 1.1 cgd newStr = var_Error;
3103 1.1 cgd }
3104 1.1 cgd }
3105 1.1 cgd }
3106 1.1 cgd if (DEBUG(VAR)) {
3107 1.1 cgd printf("Result is \"%s\"\n", newStr);
3108 1.1 cgd }
3109 1.15 christos
3110 1.73 christos if (newStr != nstr) {
3111 1.40 sjg if (*freePtr) {
3112 1.73 christos free (nstr);
3113 1.40 sjg }
3114 1.73 christos nstr = newStr;
3115 1.73 christos if (nstr != var_Error && nstr != varNoError) {
3116 1.40 sjg *freePtr = TRUE;
3117 1.40 sjg } else {
3118 1.40 sjg *freePtr = FALSE;
3119 1.40 sjg }
3120 1.1 cgd }
3121 1.1 cgd if (termc == '\0') {
3122 1.1 cgd Error("Unclosed variable specification for %s", v->name);
3123 1.1 cgd } else if (termc == ':') {
3124 1.73 christos *WR(cp) = termc;
3125 1.73 christos cp++;
3126 1.1 cgd } else {
3127 1.73 christos *WR(cp) = termc;
3128 1.1 cgd }
3129 1.1 cgd tstr = cp;
3130 1.1 cgd }
3131 1.1 cgd *lengthPtr = tstr - start + 1;
3132 1.1 cgd } else {
3133 1.1 cgd *lengthPtr = tstr - start + 1;
3134 1.73 christos *WR(tstr) = endc;
3135 1.1 cgd }
3136 1.15 christos
3137 1.1 cgd if (v->flags & VAR_FROM_ENV) {
3138 1.1 cgd Boolean destroy = FALSE;
3139 1.15 christos
3140 1.73 christos if (nstr != (char *)Buf_GetAll(v->val, (int *)NULL)) {
3141 1.1 cgd destroy = TRUE;
3142 1.1 cgd } else {
3143 1.1 cgd /*
3144 1.1 cgd * Returning the value unmodified, so tell the caller to free
3145 1.1 cgd * the thing.
3146 1.1 cgd */
3147 1.1 cgd *freePtr = TRUE;
3148 1.1 cgd }
3149 1.73 christos if (nstr != (char *)Buf_GetAll(v->val, (int *)NULL))
3150 1.58 itojun Buf_Destroy(v->val, destroy);
3151 1.52 mycroft free((Address)v->name);
3152 1.1 cgd free((Address)v);
3153 1.1 cgd } else if (v->flags & VAR_JUNK) {
3154 1.1 cgd /*
3155 1.1 cgd * Perform any free'ing needed and set *freePtr to FALSE so the caller
3156 1.1 cgd * doesn't try to free a static pointer.
3157 1.40 sjg * If VAR_KEEP is also set then we want to keep str as is.
3158 1.1 cgd */
3159 1.58 itojun if (!(v->flags & VAR_KEEP)) {
3160 1.40 sjg if (*freePtr) {
3161 1.73 christos free(nstr);
3162 1.40 sjg }
3163 1.40 sjg *freePtr = FALSE;
3164 1.40 sjg if (dynamic) {
3165 1.73 christos nstr = emalloc(*lengthPtr + 1);
3166 1.73 christos strncpy(nstr, start, *lengthPtr);
3167 1.73 christos nstr[*lengthPtr] = '\0';
3168 1.40 sjg *freePtr = TRUE;
3169 1.40 sjg } else {
3170 1.73 christos nstr = var_Error;
3171 1.40 sjg }
3172 1.34 christos }
3173 1.73 christos if (nstr != (char *)Buf_GetAll(v->val, (int *)NULL))
3174 1.58 itojun Buf_Destroy(v->val, TRUE);
3175 1.52 mycroft free((Address)v->name);
3176 1.51 sjg free((Address)v);
3177 1.1 cgd }
3178 1.73 christos return (nstr);
3179 1.16 christos
3180 1.74 sjg bad_modifier:
3181 1.81 sjg /* "{(" */
3182 1.74 sjg Error("Bad modifier `:%.*s' for %s", (int)strcspn(tstr, ":)}"), tstr,
3183 1.74 sjg v->name);
3184 1.74 sjg
3185 1.16 christos cleanup:
3186 1.16 christos *lengthPtr = cp - start + 1;
3187 1.16 christos if (*freePtr)
3188 1.73 christos free(nstr);
3189 1.27 christos if (delim != '\0')
3190 1.27 christos Error("Unclosed substitution for %s (%c missing)",
3191 1.27 christos v->name, delim);
3192 1.16 christos return (var_Error);
3193 1.1 cgd }
3194 1.1 cgd
3195 1.1 cgd /*-
3196 1.1 cgd *-----------------------------------------------------------------------
3197 1.1 cgd * Var_Subst --
3198 1.1 cgd * Substitute for all variables in the given string in the given context
3199 1.1 cgd * If undefErr is TRUE, Parse_Error will be called when an undefined
3200 1.1 cgd * variable is encountered.
3201 1.1 cgd *
3202 1.70 wiz * Input:
3203 1.70 wiz * var Named variable || NULL for all
3204 1.70 wiz * str the string which to substitute
3205 1.70 wiz * ctxt the context wherein to find variables
3206 1.70 wiz * undefErr TRUE if undefineds are an error
3207 1.70 wiz *
3208 1.1 cgd * Results:
3209 1.1 cgd * The resulting string.
3210 1.1 cgd *
3211 1.1 cgd * Side Effects:
3212 1.1 cgd * None. The old string must be freed by the caller
3213 1.1 cgd *-----------------------------------------------------------------------
3214 1.1 cgd */
3215 1.1 cgd char *
3216 1.73 christos Var_Subst(const char *var, const char *str, GNode *ctxt, Boolean undefErr)
3217 1.1 cgd {
3218 1.1 cgd Buffer buf; /* Buffer for forming things */
3219 1.1 cgd char *val; /* Value to substitute for a variable */
3220 1.1 cgd int length; /* Length of the variable invocation */
3221 1.1 cgd Boolean doFree; /* Set true if val should be freed */
3222 1.1 cgd static Boolean errorReported; /* Set true if an error has already
3223 1.1 cgd * been reported to prevent a plethora
3224 1.1 cgd * of messages when recursing */
3225 1.1 cgd
3226 1.5 cgd buf = Buf_Init (MAKE_BSIZE);
3227 1.1 cgd errorReported = FALSE;
3228 1.1 cgd
3229 1.1 cgd while (*str) {
3230 1.48 mycroft if (var == NULL && (*str == '$') && (str[1] == '$')) {
3231 1.1 cgd /*
3232 1.1 cgd * A dollar sign may be escaped either with another dollar sign.
3233 1.1 cgd * In such a case, we skip over the escape character and store the
3234 1.1 cgd * dollar sign into the buffer directly.
3235 1.1 cgd */
3236 1.1 cgd str++;
3237 1.1 cgd Buf_AddByte(buf, (Byte)*str);
3238 1.1 cgd str++;
3239 1.1 cgd } else if (*str != '$') {
3240 1.1 cgd /*
3241 1.1 cgd * Skip as many characters as possible -- either to the end of
3242 1.1 cgd * the string or to the next dollar sign (variable invocation).
3243 1.1 cgd */
3244 1.73 christos const char *cp;
3245 1.1 cgd
3246 1.5 cgd for (cp = str++; *str != '$' && *str != '\0'; str++)
3247 1.5 cgd continue;
3248 1.73 christos Buf_AddBytes(buf, str - cp, (const Byte *)cp);
3249 1.1 cgd } else {
3250 1.48 mycroft if (var != NULL) {
3251 1.48 mycroft int expand;
3252 1.48 mycroft for (;;) {
3253 1.48 mycroft if (str[1] != '(' && str[1] != '{') {
3254 1.48 mycroft if (str[1] != *var || strlen(var) > 1) {
3255 1.73 christos Buf_AddBytes(buf, 2, (const Byte *)str);
3256 1.48 mycroft str += 2;
3257 1.48 mycroft expand = FALSE;
3258 1.48 mycroft }
3259 1.48 mycroft else
3260 1.48 mycroft expand = TRUE;
3261 1.48 mycroft break;
3262 1.48 mycroft }
3263 1.48 mycroft else {
3264 1.73 christos const char *p;
3265 1.48 mycroft
3266 1.48 mycroft /*
3267 1.48 mycroft * Scan up to the end of the variable name.
3268 1.48 mycroft */
3269 1.48 mycroft for (p = &str[2]; *p &&
3270 1.48 mycroft *p != ':' && *p != ')' && *p != '}'; p++)
3271 1.48 mycroft if (*p == '$')
3272 1.48 mycroft break;
3273 1.48 mycroft /*
3274 1.48 mycroft * A variable inside the variable. We cannot expand
3275 1.48 mycroft * the external variable yet, so we try again with
3276 1.48 mycroft * the nested one
3277 1.48 mycroft */
3278 1.48 mycroft if (*p == '$') {
3279 1.73 christos Buf_AddBytes(buf, p - str, (const Byte *)str);
3280 1.48 mycroft str = p;
3281 1.48 mycroft continue;
3282 1.48 mycroft }
3283 1.48 mycroft
3284 1.48 mycroft if (strncmp(var, str + 2, p - str - 2) != 0 ||
3285 1.48 mycroft var[p - str - 2] != '\0') {
3286 1.48 mycroft /*
3287 1.48 mycroft * Not the variable we want to expand, scan
3288 1.48 mycroft * until the next variable
3289 1.48 mycroft */
3290 1.48 mycroft for (;*p != '$' && *p != '\0'; p++)
3291 1.48 mycroft continue;
3292 1.73 christos Buf_AddBytes(buf, p - str, (const Byte *)str);
3293 1.48 mycroft str = p;
3294 1.48 mycroft expand = FALSE;
3295 1.48 mycroft }
3296 1.48 mycroft else
3297 1.48 mycroft expand = TRUE;
3298 1.48 mycroft break;
3299 1.48 mycroft }
3300 1.48 mycroft }
3301 1.48 mycroft if (!expand)
3302 1.48 mycroft continue;
3303 1.48 mycroft }
3304 1.48 mycroft
3305 1.1 cgd val = Var_Parse (str, ctxt, undefErr, &length, &doFree);
3306 1.1 cgd
3307 1.1 cgd /*
3308 1.1 cgd * When we come down here, val should either point to the
3309 1.1 cgd * value of this variable, suitably modified, or be NULL.
3310 1.1 cgd * Length should be the total length of the potential
3311 1.1 cgd * variable invocation (from $ to end character...)
3312 1.1 cgd */
3313 1.1 cgd if (val == var_Error || val == varNoError) {
3314 1.1 cgd /*
3315 1.1 cgd * If performing old-time variable substitution, skip over
3316 1.1 cgd * the variable and continue with the substitution. Otherwise,
3317 1.1 cgd * store the dollar sign and advance str so we continue with
3318 1.1 cgd * the string...
3319 1.1 cgd */
3320 1.1 cgd if (oldVars) {
3321 1.1 cgd str += length;
3322 1.1 cgd } else if (undefErr) {
3323 1.1 cgd /*
3324 1.1 cgd * If variable is undefined, complain and skip the
3325 1.1 cgd * variable. The complaint will stop us from doing anything
3326 1.1 cgd * when the file is parsed.
3327 1.1 cgd */
3328 1.1 cgd if (!errorReported) {
3329 1.1 cgd Parse_Error (PARSE_FATAL,
3330 1.1 cgd "Undefined variable \"%.*s\"",length,str);
3331 1.1 cgd }
3332 1.1 cgd str += length;
3333 1.1 cgd errorReported = TRUE;
3334 1.1 cgd } else {
3335 1.1 cgd Buf_AddByte (buf, (Byte)*str);
3336 1.1 cgd str += 1;
3337 1.1 cgd }
3338 1.1 cgd } else {
3339 1.1 cgd /*
3340 1.1 cgd * We've now got a variable structure to store in. But first,
3341 1.1 cgd * advance the string pointer.
3342 1.1 cgd */
3343 1.1 cgd str += length;
3344 1.15 christos
3345 1.1 cgd /*
3346 1.1 cgd * Copy all the characters from the variable value straight
3347 1.1 cgd * into the new string.
3348 1.1 cgd */
3349 1.1 cgd Buf_AddBytes (buf, strlen (val), (Byte *)val);
3350 1.1 cgd if (doFree) {
3351 1.1 cgd free ((Address)val);
3352 1.1 cgd }
3353 1.1 cgd }
3354 1.1 cgd }
3355 1.1 cgd }
3356 1.15 christos
3357 1.1 cgd Buf_AddByte (buf, '\0');
3358 1.73 christos val = (char *)Buf_GetAll (buf, (int *)NULL);
3359 1.1 cgd Buf_Destroy (buf, FALSE);
3360 1.73 christos return (val);
3361 1.1 cgd }
3362 1.1 cgd
3363 1.1 cgd /*-
3364 1.1 cgd *-----------------------------------------------------------------------
3365 1.1 cgd * Var_GetTail --
3366 1.1 cgd * Return the tail from each of a list of words. Used to set the
3367 1.1 cgd * System V local variables.
3368 1.1 cgd *
3369 1.70 wiz * Input:
3370 1.70 wiz * file Filename to modify
3371 1.70 wiz *
3372 1.1 cgd * Results:
3373 1.1 cgd * The resulting string.
3374 1.1 cgd *
3375 1.1 cgd * Side Effects:
3376 1.1 cgd * None.
3377 1.1 cgd *
3378 1.1 cgd *-----------------------------------------------------------------------
3379 1.1 cgd */
3380 1.61 explorer #if 0
3381 1.1 cgd char *
3382 1.70 wiz Var_GetTail(char *file)
3383 1.1 cgd {
3384 1.1 cgd return(VarModify(file, VarTail, (ClientData)0));
3385 1.1 cgd }
3386 1.1 cgd
3387 1.1 cgd /*-
3388 1.1 cgd *-----------------------------------------------------------------------
3389 1.1 cgd * Var_GetHead --
3390 1.1 cgd * Find the leading components of a (list of) filename(s).
3391 1.1 cgd * XXX: VarHead does not replace foo by ., as (sun) System V make
3392 1.1 cgd * does.
3393 1.1 cgd *
3394 1.70 wiz * Input:
3395 1.70 wiz * file Filename to manipulate
3396 1.70 wiz *
3397 1.1 cgd * Results:
3398 1.1 cgd * The leading components.
3399 1.1 cgd *
3400 1.1 cgd * Side Effects:
3401 1.1 cgd * None.
3402 1.1 cgd *
3403 1.1 cgd *-----------------------------------------------------------------------
3404 1.1 cgd */
3405 1.1 cgd char *
3406 1.70 wiz Var_GetHead(char *file)
3407 1.1 cgd {
3408 1.1 cgd return(VarModify(file, VarHead, (ClientData)0));
3409 1.1 cgd }
3410 1.61 explorer #endif
3411 1.1 cgd
3412 1.1 cgd /*-
3413 1.1 cgd *-----------------------------------------------------------------------
3414 1.1 cgd * Var_Init --
3415 1.1 cgd * Initialize the module
3416 1.1 cgd *
3417 1.1 cgd * Results:
3418 1.1 cgd * None
3419 1.1 cgd *
3420 1.1 cgd * Side Effects:
3421 1.15 christos * The VAR_CMD and VAR_GLOBAL contexts are created
3422 1.1 cgd *-----------------------------------------------------------------------
3423 1.1 cgd */
3424 1.1 cgd void
3425 1.70 wiz Var_Init(void)
3426 1.1 cgd {
3427 1.1 cgd VAR_GLOBAL = Targ_NewGN ("Global");
3428 1.1 cgd VAR_CMD = Targ_NewGN ("Command");
3429 1.6 jtc
3430 1.6 jtc }
3431 1.6 jtc
3432 1.1 cgd
3433 1.6 jtc void
3434 1.70 wiz Var_End(void)
3435 1.6 jtc {
3436 1.1 cgd }
3437 1.15 christos
3438 1.1 cgd
3439 1.1 cgd /****************** PRINT DEBUGGING INFO *****************/
3440 1.36 mycroft static void
3441 1.70 wiz VarPrintVar(ClientData vp)
3442 1.1 cgd {
3443 1.6 jtc Var *v = (Var *) vp;
3444 1.5 cgd printf ("%-16s = %s\n", v->name, (char *) Buf_GetAll(v->val, (int *)NULL));
3445 1.1 cgd }
3446 1.1 cgd
3447 1.1 cgd /*-
3448 1.1 cgd *-----------------------------------------------------------------------
3449 1.1 cgd * Var_Dump --
3450 1.1 cgd * print all variables in a context
3451 1.1 cgd *-----------------------------------------------------------------------
3452 1.1 cgd */
3453 1.5 cgd void
3454 1.70 wiz Var_Dump(GNode *ctxt)
3455 1.1 cgd {
3456 1.36 mycroft Hash_Search search;
3457 1.36 mycroft Hash_Entry *h;
3458 1.36 mycroft
3459 1.36 mycroft for (h = Hash_EnumFirst(&ctxt->context, &search);
3460 1.36 mycroft h != NULL;
3461 1.36 mycroft h = Hash_EnumNext(&search)) {
3462 1.36 mycroft VarPrintVar(Hash_GetValue(h));
3463 1.36 mycroft }
3464 1.1 cgd }
3465