var.c revision 1.21 1 1.21 christos /* $NetBSD: var.c,v 1.21 1997/07/10 00:54:44 christos 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.1 cgd * Copyright (c) 1989 by Berkeley Softworks
7 1.1 cgd * All rights reserved.
8 1.1 cgd *
9 1.1 cgd * This code is derived from software contributed to Berkeley by
10 1.1 cgd * Adam de Boor.
11 1.1 cgd *
12 1.1 cgd * Redistribution and use in source and binary forms, with or without
13 1.1 cgd * modification, are permitted provided that the following conditions
14 1.1 cgd * are met:
15 1.1 cgd * 1. Redistributions of source code must retain the above copyright
16 1.1 cgd * notice, this list of conditions and the following disclaimer.
17 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
18 1.1 cgd * notice, this list of conditions and the following disclaimer in the
19 1.1 cgd * documentation and/or other materials provided with the distribution.
20 1.1 cgd * 3. All advertising materials mentioning features or use of this software
21 1.1 cgd * must display the following acknowledgement:
22 1.1 cgd * This product includes software developed by the University of
23 1.1 cgd * California, Berkeley and its contributors.
24 1.1 cgd * 4. Neither the name of the University nor the names of its contributors
25 1.1 cgd * may be used to endorse or promote products derived from this software
26 1.1 cgd * without specific prior written permission.
27 1.1 cgd *
28 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
29 1.1 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
30 1.1 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
31 1.1 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
32 1.1 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33 1.1 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
34 1.1 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
35 1.1 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
36 1.1 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
37 1.1 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38 1.1 cgd * SUCH DAMAGE.
39 1.1 cgd */
40 1.1 cgd
41 1.19 christos #include <sys/cdefs.h>
42 1.1 cgd #ifndef lint
43 1.11 christos #if 0
44 1.15 christos static char sccsid[] = "@(#)var.c 8.3 (Berkeley) 3/19/94";
45 1.11 christos #else
46 1.21 christos __RCSID("$NetBSD: var.c,v 1.21 1997/07/10 00:54:44 christos Exp $");
47 1.11 christos #endif
48 1.1 cgd #endif /* not lint */
49 1.1 cgd
50 1.1 cgd /*-
51 1.1 cgd * var.c --
52 1.1 cgd * Variable-handling functions
53 1.1 cgd *
54 1.1 cgd * Interface:
55 1.1 cgd * Var_Set Set the value of a variable in the given
56 1.1 cgd * context. The variable is created if it doesn't
57 1.1 cgd * yet exist. The value and variable name need not
58 1.1 cgd * be preserved.
59 1.1 cgd *
60 1.1 cgd * Var_Append Append more characters to an existing variable
61 1.1 cgd * in the given context. The variable needn't
62 1.1 cgd * exist already -- it will be created if it doesn't.
63 1.1 cgd * A space is placed between the old value and the
64 1.1 cgd * new one.
65 1.1 cgd *
66 1.1 cgd * Var_Exists See if a variable exists.
67 1.1 cgd *
68 1.1 cgd * Var_Value Return the value of a variable in a context or
69 1.1 cgd * NULL if the variable is undefined.
70 1.1 cgd *
71 1.5 cgd * Var_Subst Substitute named variable, or all variables if
72 1.5 cgd * NULL in a string using
73 1.1 cgd * the given context as the top-most one. If the
74 1.1 cgd * third argument is non-zero, Parse_Error is
75 1.1 cgd * called if any variables are undefined.
76 1.1 cgd *
77 1.1 cgd * Var_Parse Parse a variable expansion from a string and
78 1.1 cgd * return the result and the number of characters
79 1.1 cgd * consumed.
80 1.1 cgd *
81 1.1 cgd * Var_Delete Delete a variable in a context.
82 1.1 cgd *
83 1.1 cgd * Var_Init Initialize this module.
84 1.1 cgd *
85 1.1 cgd * Debugging:
86 1.1 cgd * Var_Dump Print out all variables defined in the given
87 1.1 cgd * context.
88 1.1 cgd *
89 1.1 cgd * XXX: There's a lot of duplication in these functions.
90 1.1 cgd */
91 1.1 cgd
92 1.1 cgd #include <ctype.h>
93 1.17 christos #ifndef MAKE_BOOTSTRAP
94 1.16 christos #include <regex.h>
95 1.17 christos #endif
96 1.17 christos #include <stdlib.h>
97 1.1 cgd #include "make.h"
98 1.1 cgd #include "buf.h"
99 1.1 cgd
100 1.1 cgd /*
101 1.1 cgd * This is a harmless return value for Var_Parse that can be used by Var_Subst
102 1.1 cgd * to determine if there was an error in parsing -- easier than returning
103 1.1 cgd * a flag, as things outside this module don't give a hoot.
104 1.1 cgd */
105 1.1 cgd char var_Error[] = "";
106 1.1 cgd
107 1.1 cgd /*
108 1.1 cgd * Similar to var_Error, but returned when the 'err' flag for Var_Parse is
109 1.1 cgd * set false. Why not just use a constant? Well, gcc likes to condense
110 1.1 cgd * identical string instances...
111 1.1 cgd */
112 1.5 cgd static char varNoError[] = "";
113 1.1 cgd
114 1.1 cgd /*
115 1.1 cgd * Internally, variables are contained in four different contexts.
116 1.1 cgd * 1) the environment. They may not be changed. If an environment
117 1.1 cgd * variable is appended-to, the result is placed in the global
118 1.1 cgd * context.
119 1.1 cgd * 2) the global context. Variables set in the Makefile are located in
120 1.1 cgd * the global context. It is the penultimate context searched when
121 1.1 cgd * substituting.
122 1.1 cgd * 3) the command-line context. All variables set on the command line
123 1.1 cgd * are placed in this context. They are UNALTERABLE once placed here.
124 1.1 cgd * 4) the local context. Each target has associated with it a context
125 1.1 cgd * list. On this list are located the structures describing such
126 1.1 cgd * local variables as $(@) and $(*)
127 1.1 cgd * The four contexts are searched in the reverse order from which they are
128 1.1 cgd * listed.
129 1.1 cgd */
130 1.1 cgd GNode *VAR_GLOBAL; /* variables from the makefile */
131 1.1 cgd GNode *VAR_CMD; /* variables defined on the command-line */
132 1.1 cgd
133 1.6 jtc static Lst allVars; /* List of all variables */
134 1.6 jtc
135 1.1 cgd #define FIND_CMD 0x1 /* look in VAR_CMD when searching */
136 1.1 cgd #define FIND_GLOBAL 0x2 /* look in VAR_GLOBAL as well */
137 1.1 cgd #define FIND_ENV 0x4 /* look in the environment also */
138 1.1 cgd
139 1.1 cgd typedef struct Var {
140 1.1 cgd char *name; /* the variable's name */
141 1.1 cgd Buffer val; /* its value */
142 1.1 cgd int flags; /* miscellaneous status flags */
143 1.1 cgd #define VAR_IN_USE 1 /* Variable's value currently being used.
144 1.1 cgd * Used to avoid recursion */
145 1.1 cgd #define VAR_FROM_ENV 2 /* Variable comes from the environment */
146 1.1 cgd #define VAR_JUNK 4 /* Variable is a junk variable that
147 1.1 cgd * should be destroyed when done with
148 1.1 cgd * it. Used by Var_Parse for undefined,
149 1.1 cgd * modified variables */
150 1.1 cgd } Var;
151 1.1 cgd
152 1.16 christos
153 1.16 christos /* Var*Pattern flags */
154 1.16 christos #define VAR_SUB_GLOBAL 0x01 /* Apply substitution globally */
155 1.16 christos #define VAR_SUB_ONE 0x02 /* Apply substitution to one word */
156 1.16 christos #define VAR_SUB_MATCHED 0x04 /* There was a match */
157 1.16 christos #define VAR_MATCH_START 0x08 /* Match at start of word */
158 1.16 christos #define VAR_MATCH_END 0x10 /* Match at end of word */
159 1.16 christos
160 1.5 cgd typedef struct {
161 1.5 cgd char *lhs; /* String to match */
162 1.16 christos int leftLen; /* Length of string */
163 1.5 cgd char *rhs; /* Replacement string (w/ &'s removed) */
164 1.5 cgd int rightLen; /* Length of replacement */
165 1.5 cgd int flags;
166 1.5 cgd } VarPattern;
167 1.5 cgd
168 1.17 christos #ifndef MAKE_BOOTSTRAP
169 1.16 christos typedef struct {
170 1.16 christos regex_t re;
171 1.16 christos int nsub;
172 1.16 christos regmatch_t *matches;
173 1.16 christos char *replace;
174 1.16 christos int flags;
175 1.16 christos } VarREPattern;
176 1.17 christos #endif
177 1.16 christos
178 1.6 jtc static int VarCmp __P((ClientData, ClientData));
179 1.5 cgd static Var *VarFind __P((char *, GNode *, int));
180 1.5 cgd static void VarAdd __P((char *, char *, GNode *));
181 1.6 jtc static void VarDelete __P((ClientData));
182 1.6 jtc static Boolean VarHead __P((char *, Boolean, Buffer, ClientData));
183 1.6 jtc static Boolean VarTail __P((char *, Boolean, Buffer, ClientData));
184 1.6 jtc static Boolean VarSuffix __P((char *, Boolean, Buffer, ClientData));
185 1.6 jtc static Boolean VarRoot __P((char *, Boolean, Buffer, ClientData));
186 1.6 jtc static Boolean VarMatch __P((char *, Boolean, Buffer, ClientData));
187 1.13 christos #ifdef SYSVVARSUB
188 1.6 jtc static Boolean VarSYSVMatch __P((char *, Boolean, Buffer, ClientData));
189 1.13 christos #endif
190 1.6 jtc static Boolean VarNoMatch __P((char *, Boolean, Buffer, ClientData));
191 1.17 christos #ifndef MAKE_BOOTSTRAP
192 1.16 christos static void VarREError __P((int, regex_t *, const char *));
193 1.16 christos static Boolean VarRESubstitute __P((char *, Boolean, Buffer, ClientData));
194 1.17 christos #endif
195 1.6 jtc static Boolean VarSubstitute __P((char *, Boolean, Buffer, ClientData));
196 1.16 christos static char *VarGetPattern __P((GNode *, int, char **, int, int *, int *,
197 1.16 christos VarPattern *));
198 1.16 christos static char *VarQuote __P((char *));
199 1.6 jtc static char *VarModify __P((char *, Boolean (*)(char *, Boolean, Buffer,
200 1.6 jtc ClientData),
201 1.6 jtc ClientData));
202 1.6 jtc static int VarPrintVar __P((ClientData, ClientData));
203 1.5 cgd
204 1.1 cgd /*-
205 1.1 cgd *-----------------------------------------------------------------------
206 1.1 cgd * VarCmp --
207 1.1 cgd * See if the given variable matches the named one. Called from
208 1.1 cgd * Lst_Find when searching for a variable of a given name.
209 1.1 cgd *
210 1.1 cgd * Results:
211 1.1 cgd * 0 if they match. non-zero otherwise.
212 1.1 cgd *
213 1.1 cgd * Side Effects:
214 1.1 cgd * none
215 1.1 cgd *-----------------------------------------------------------------------
216 1.1 cgd */
217 1.1 cgd static int
218 1.1 cgd VarCmp (v, name)
219 1.6 jtc ClientData v; /* VAR structure to compare */
220 1.6 jtc ClientData name; /* name to look for */
221 1.1 cgd {
222 1.6 jtc return (strcmp ((char *) name, ((Var *) v)->name));
223 1.1 cgd }
224 1.1 cgd
225 1.1 cgd /*-
226 1.1 cgd *-----------------------------------------------------------------------
227 1.1 cgd * VarFind --
228 1.1 cgd * Find the given variable in the given context and any other contexts
229 1.1 cgd * indicated.
230 1.1 cgd *
231 1.1 cgd * Results:
232 1.1 cgd * A pointer to the structure describing the desired variable or
233 1.1 cgd * NIL if the variable does not exist.
234 1.1 cgd *
235 1.1 cgd * Side Effects:
236 1.1 cgd * None
237 1.1 cgd *-----------------------------------------------------------------------
238 1.1 cgd */
239 1.1 cgd static Var *
240 1.1 cgd VarFind (name, ctxt, flags)
241 1.1 cgd char *name; /* name to find */
242 1.1 cgd GNode *ctxt; /* context in which to find it */
243 1.1 cgd int flags; /* FIND_GLOBAL set means to look in the
244 1.1 cgd * VAR_GLOBAL context as well.
245 1.1 cgd * FIND_CMD set means to look in the VAR_CMD
246 1.1 cgd * context also.
247 1.1 cgd * FIND_ENV set means to look in the
248 1.1 cgd * environment */
249 1.1 cgd {
250 1.1 cgd LstNode var;
251 1.1 cgd Var *v;
252 1.1 cgd
253 1.1 cgd /*
254 1.1 cgd * If the variable name begins with a '.', it could very well be one of
255 1.1 cgd * the local ones. We check the name against all the local variables
256 1.1 cgd * and substitute the short version in for 'name' if it matches one of
257 1.1 cgd * them.
258 1.1 cgd */
259 1.6 jtc if (*name == '.' && isupper((unsigned char) name[1]))
260 1.1 cgd switch (name[1]) {
261 1.1 cgd case 'A':
262 1.1 cgd if (!strcmp(name, ".ALLSRC"))
263 1.1 cgd name = ALLSRC;
264 1.1 cgd if (!strcmp(name, ".ARCHIVE"))
265 1.1 cgd name = ARCHIVE;
266 1.1 cgd break;
267 1.1 cgd case 'I':
268 1.1 cgd if (!strcmp(name, ".IMPSRC"))
269 1.1 cgd name = IMPSRC;
270 1.1 cgd break;
271 1.1 cgd case 'M':
272 1.1 cgd if (!strcmp(name, ".MEMBER"))
273 1.1 cgd name = MEMBER;
274 1.1 cgd break;
275 1.1 cgd case 'O':
276 1.1 cgd if (!strcmp(name, ".OODATE"))
277 1.1 cgd name = OODATE;
278 1.1 cgd break;
279 1.1 cgd case 'P':
280 1.1 cgd if (!strcmp(name, ".PREFIX"))
281 1.1 cgd name = PREFIX;
282 1.1 cgd break;
283 1.1 cgd case 'T':
284 1.1 cgd if (!strcmp(name, ".TARGET"))
285 1.1 cgd name = TARGET;
286 1.1 cgd break;
287 1.1 cgd }
288 1.1 cgd /*
289 1.1 cgd * First look for the variable in the given context. If it's not there,
290 1.1 cgd * look for it in VAR_CMD, VAR_GLOBAL and the environment, in that order,
291 1.1 cgd * depending on the FIND_* flags in 'flags'
292 1.1 cgd */
293 1.1 cgd var = Lst_Find (ctxt->context, (ClientData)name, VarCmp);
294 1.1 cgd
295 1.1 cgd if ((var == NILLNODE) && (flags & FIND_CMD) && (ctxt != VAR_CMD)) {
296 1.1 cgd var = Lst_Find (VAR_CMD->context, (ClientData)name, VarCmp);
297 1.1 cgd }
298 1.1 cgd if (!checkEnvFirst && (var == NILLNODE) && (flags & FIND_GLOBAL) &&
299 1.1 cgd (ctxt != VAR_GLOBAL))
300 1.1 cgd {
301 1.1 cgd var = Lst_Find (VAR_GLOBAL->context, (ClientData)name, VarCmp);
302 1.1 cgd }
303 1.1 cgd if ((var == NILLNODE) && (flags & FIND_ENV)) {
304 1.1 cgd char *env;
305 1.1 cgd
306 1.1 cgd if ((env = getenv (name)) != NULL) {
307 1.1 cgd int len;
308 1.15 christos
309 1.1 cgd v = (Var *) emalloc(sizeof(Var));
310 1.14 christos v->name = estrdup(name);
311 1.1 cgd
312 1.1 cgd len = strlen(env);
313 1.15 christos
314 1.1 cgd v->val = Buf_Init(len);
315 1.1 cgd Buf_AddBytes(v->val, len, (Byte *)env);
316 1.15 christos
317 1.1 cgd v->flags = VAR_FROM_ENV;
318 1.1 cgd return (v);
319 1.1 cgd } else if (checkEnvFirst && (flags & FIND_GLOBAL) &&
320 1.1 cgd (ctxt != VAR_GLOBAL))
321 1.1 cgd {
322 1.1 cgd var = Lst_Find (VAR_GLOBAL->context, (ClientData)name, VarCmp);
323 1.1 cgd if (var == NILLNODE) {
324 1.1 cgd return ((Var *) NIL);
325 1.1 cgd } else {
326 1.1 cgd return ((Var *)Lst_Datum(var));
327 1.1 cgd }
328 1.1 cgd } else {
329 1.1 cgd return((Var *)NIL);
330 1.1 cgd }
331 1.1 cgd } else if (var == NILLNODE) {
332 1.1 cgd return ((Var *) NIL);
333 1.1 cgd } else {
334 1.1 cgd return ((Var *) Lst_Datum (var));
335 1.1 cgd }
336 1.1 cgd }
337 1.1 cgd
338 1.1 cgd /*-
339 1.1 cgd *-----------------------------------------------------------------------
340 1.1 cgd * VarAdd --
341 1.1 cgd * Add a new variable of name name and value val to the given context
342 1.1 cgd *
343 1.1 cgd * Results:
344 1.1 cgd * None
345 1.1 cgd *
346 1.1 cgd * Side Effects:
347 1.1 cgd * The new variable is placed at the front of the given context
348 1.1 cgd * The name and val arguments are duplicated so they may
349 1.1 cgd * safely be freed.
350 1.1 cgd *-----------------------------------------------------------------------
351 1.1 cgd */
352 1.5 cgd static void
353 1.1 cgd VarAdd (name, val, ctxt)
354 1.1 cgd char *name; /* name of variable to add */
355 1.1 cgd char *val; /* value to set it to */
356 1.1 cgd GNode *ctxt; /* context in which to set it */
357 1.1 cgd {
358 1.1 cgd register Var *v;
359 1.1 cgd int len;
360 1.1 cgd
361 1.1 cgd v = (Var *) emalloc (sizeof (Var));
362 1.1 cgd
363 1.14 christos v->name = estrdup (name);
364 1.1 cgd
365 1.5 cgd len = val ? strlen(val) : 0;
366 1.1 cgd v->val = Buf_Init(len+1);
367 1.1 cgd Buf_AddBytes(v->val, len, (Byte *)val);
368 1.1 cgd
369 1.1 cgd v->flags = 0;
370 1.1 cgd
371 1.1 cgd (void) Lst_AtFront (ctxt->context, (ClientData)v);
372 1.6 jtc (void) Lst_AtEnd (allVars, (ClientData) v);
373 1.1 cgd if (DEBUG(VAR)) {
374 1.1 cgd printf("%s:%s = %s\n", ctxt->name, name, val);
375 1.1 cgd }
376 1.1 cgd }
377 1.1 cgd
378 1.6 jtc
379 1.6 jtc /*-
380 1.6 jtc *-----------------------------------------------------------------------
381 1.6 jtc * VarDelete --
382 1.6 jtc * Delete a variable and all the space associated with it.
383 1.6 jtc *
384 1.6 jtc * Results:
385 1.6 jtc * None
386 1.6 jtc *
387 1.6 jtc * Side Effects:
388 1.6 jtc * None
389 1.6 jtc *-----------------------------------------------------------------------
390 1.6 jtc */
391 1.6 jtc static void
392 1.6 jtc VarDelete(vp)
393 1.6 jtc ClientData vp;
394 1.6 jtc {
395 1.6 jtc Var *v = (Var *) vp;
396 1.6 jtc free(v->name);
397 1.6 jtc Buf_Destroy(v->val, TRUE);
398 1.6 jtc free((Address) v);
399 1.6 jtc }
400 1.6 jtc
401 1.6 jtc
402 1.6 jtc
403 1.1 cgd /*-
404 1.1 cgd *-----------------------------------------------------------------------
405 1.1 cgd * Var_Delete --
406 1.1 cgd * Remove a variable from a context.
407 1.1 cgd *
408 1.1 cgd * Results:
409 1.1 cgd * None.
410 1.1 cgd *
411 1.1 cgd * Side Effects:
412 1.1 cgd * The Var structure is removed and freed.
413 1.1 cgd *
414 1.1 cgd *-----------------------------------------------------------------------
415 1.1 cgd */
416 1.1 cgd void
417 1.1 cgd Var_Delete(name, ctxt)
418 1.1 cgd char *name;
419 1.1 cgd GNode *ctxt;
420 1.1 cgd {
421 1.1 cgd LstNode ln;
422 1.1 cgd
423 1.1 cgd if (DEBUG(VAR)) {
424 1.1 cgd printf("%s:delete %s\n", ctxt->name, name);
425 1.1 cgd }
426 1.1 cgd ln = Lst_Find(ctxt->context, (ClientData)name, VarCmp);
427 1.1 cgd if (ln != NILLNODE) {
428 1.1 cgd register Var *v;
429 1.1 cgd
430 1.1 cgd v = (Var *)Lst_Datum(ln);
431 1.1 cgd Lst_Remove(ctxt->context, ln);
432 1.6 jtc ln = Lst_Member(allVars, v);
433 1.6 jtc Lst_Remove(allVars, ln);
434 1.6 jtc VarDelete((ClientData) v);
435 1.1 cgd }
436 1.1 cgd }
437 1.1 cgd
438 1.1 cgd /*-
439 1.1 cgd *-----------------------------------------------------------------------
440 1.1 cgd * Var_Set --
441 1.1 cgd * Set the variable name to the value val in the given context.
442 1.1 cgd *
443 1.1 cgd * Results:
444 1.1 cgd * None.
445 1.1 cgd *
446 1.1 cgd * Side Effects:
447 1.1 cgd * If the variable doesn't yet exist, a new record is created for it.
448 1.1 cgd * Else the old value is freed and the new one stuck in its place
449 1.1 cgd *
450 1.1 cgd * Notes:
451 1.1 cgd * The variable is searched for only in its context before being
452 1.1 cgd * created in that context. I.e. if the context is VAR_GLOBAL,
453 1.1 cgd * only VAR_GLOBAL->context is searched. Likewise if it is VAR_CMD, only
454 1.1 cgd * VAR_CMD->context is searched. This is done to avoid the literally
455 1.1 cgd * thousands of unnecessary strcmp's that used to be done to
456 1.1 cgd * set, say, $(@) or $(<).
457 1.1 cgd *-----------------------------------------------------------------------
458 1.1 cgd */
459 1.1 cgd void
460 1.1 cgd Var_Set (name, val, ctxt)
461 1.1 cgd char *name; /* name of variable to set */
462 1.1 cgd char *val; /* value to give to the variable */
463 1.1 cgd GNode *ctxt; /* context in which to set it */
464 1.1 cgd {
465 1.1 cgd register Var *v;
466 1.1 cgd
467 1.1 cgd /*
468 1.1 cgd * We only look for a variable in the given context since anything set
469 1.1 cgd * here will override anything in a lower context, so there's not much
470 1.1 cgd * point in searching them all just to save a bit of memory...
471 1.1 cgd */
472 1.1 cgd v = VarFind (name, ctxt, 0);
473 1.1 cgd if (v == (Var *) NIL) {
474 1.1 cgd VarAdd (name, val, ctxt);
475 1.1 cgd } else {
476 1.1 cgd Buf_Discard(v->val, Buf_Size(v->val));
477 1.1 cgd Buf_AddBytes(v->val, strlen(val), (Byte *)val);
478 1.1 cgd
479 1.1 cgd if (DEBUG(VAR)) {
480 1.1 cgd printf("%s:%s = %s\n", ctxt->name, name, val);
481 1.1 cgd }
482 1.1 cgd }
483 1.1 cgd /*
484 1.1 cgd * Any variables given on the command line are automatically exported
485 1.1 cgd * to the environment (as per POSIX standard)
486 1.1 cgd */
487 1.1 cgd if (ctxt == VAR_CMD) {
488 1.3 cgd setenv(name, val, 1);
489 1.1 cgd }
490 1.1 cgd }
491 1.1 cgd
492 1.1 cgd /*-
493 1.1 cgd *-----------------------------------------------------------------------
494 1.1 cgd * Var_Append --
495 1.1 cgd * The variable of the given name has the given value appended to it in
496 1.1 cgd * the given context.
497 1.1 cgd *
498 1.1 cgd * Results:
499 1.1 cgd * None
500 1.1 cgd *
501 1.1 cgd * Side Effects:
502 1.1 cgd * If the variable doesn't exist, it is created. Else the strings
503 1.1 cgd * are concatenated (with a space in between).
504 1.1 cgd *
505 1.1 cgd * Notes:
506 1.1 cgd * Only if the variable is being sought in the global context is the
507 1.1 cgd * environment searched.
508 1.1 cgd * XXX: Knows its calling circumstances in that if called with ctxt
509 1.1 cgd * an actual target, it will only search that context since only
510 1.1 cgd * a local variable could be being appended to. This is actually
511 1.1 cgd * a big win and must be tolerated.
512 1.1 cgd *-----------------------------------------------------------------------
513 1.1 cgd */
514 1.1 cgd void
515 1.1 cgd Var_Append (name, val, ctxt)
516 1.1 cgd char *name; /* Name of variable to modify */
517 1.1 cgd char *val; /* String to append to it */
518 1.1 cgd GNode *ctxt; /* Context in which this should occur */
519 1.1 cgd {
520 1.1 cgd register Var *v;
521 1.1 cgd
522 1.1 cgd v = VarFind (name, ctxt, (ctxt == VAR_GLOBAL) ? FIND_ENV : 0);
523 1.1 cgd
524 1.1 cgd if (v == (Var *) NIL) {
525 1.1 cgd VarAdd (name, val, ctxt);
526 1.1 cgd } else {
527 1.1 cgd Buf_AddByte(v->val, (Byte)' ');
528 1.1 cgd Buf_AddBytes(v->val, strlen(val), (Byte *)val);
529 1.1 cgd
530 1.1 cgd if (DEBUG(VAR)) {
531 1.1 cgd printf("%s:%s = %s\n", ctxt->name, name,
532 1.5 cgd (char *) Buf_GetAll(v->val, (int *)NULL));
533 1.1 cgd }
534 1.1 cgd
535 1.1 cgd if (v->flags & VAR_FROM_ENV) {
536 1.1 cgd /*
537 1.1 cgd * If the original variable came from the environment, we
538 1.1 cgd * have to install it in the global context (we could place
539 1.1 cgd * it in the environment, but then we should provide a way to
540 1.1 cgd * export other variables...)
541 1.1 cgd */
542 1.1 cgd v->flags &= ~VAR_FROM_ENV;
543 1.1 cgd Lst_AtFront(ctxt->context, (ClientData)v);
544 1.1 cgd }
545 1.1 cgd }
546 1.1 cgd }
547 1.1 cgd
548 1.1 cgd /*-
549 1.1 cgd *-----------------------------------------------------------------------
550 1.1 cgd * Var_Exists --
551 1.1 cgd * See if the given variable exists.
552 1.1 cgd *
553 1.1 cgd * Results:
554 1.1 cgd * TRUE if it does, FALSE if it doesn't
555 1.1 cgd *
556 1.1 cgd * Side Effects:
557 1.1 cgd * None.
558 1.1 cgd *
559 1.1 cgd *-----------------------------------------------------------------------
560 1.1 cgd */
561 1.1 cgd Boolean
562 1.1 cgd Var_Exists(name, ctxt)
563 1.1 cgd char *name; /* Variable to find */
564 1.1 cgd GNode *ctxt; /* Context in which to start search */
565 1.1 cgd {
566 1.1 cgd Var *v;
567 1.1 cgd
568 1.1 cgd v = VarFind(name, ctxt, FIND_CMD|FIND_GLOBAL|FIND_ENV);
569 1.1 cgd
570 1.1 cgd if (v == (Var *)NIL) {
571 1.1 cgd return(FALSE);
572 1.1 cgd } else if (v->flags & VAR_FROM_ENV) {
573 1.10 christos free(v->name);
574 1.1 cgd Buf_Destroy(v->val, TRUE);
575 1.1 cgd free((char *)v);
576 1.1 cgd }
577 1.1 cgd return(TRUE);
578 1.1 cgd }
579 1.1 cgd
580 1.1 cgd /*-
581 1.1 cgd *-----------------------------------------------------------------------
582 1.1 cgd * Var_Value --
583 1.1 cgd * Return the value of the named variable in the given context
584 1.1 cgd *
585 1.1 cgd * Results:
586 1.1 cgd * The value if the variable exists, NULL if it doesn't
587 1.1 cgd *
588 1.1 cgd * Side Effects:
589 1.1 cgd * None
590 1.1 cgd *-----------------------------------------------------------------------
591 1.1 cgd */
592 1.1 cgd char *
593 1.6 jtc Var_Value (name, ctxt, frp)
594 1.1 cgd char *name; /* name to find */
595 1.1 cgd GNode *ctxt; /* context in which to search for it */
596 1.6 jtc char **frp;
597 1.1 cgd {
598 1.1 cgd Var *v;
599 1.1 cgd
600 1.1 cgd v = VarFind (name, ctxt, FIND_ENV | FIND_GLOBAL | FIND_CMD);
601 1.6 jtc *frp = NULL;
602 1.1 cgd if (v != (Var *) NIL) {
603 1.6 jtc char *p = ((char *)Buf_GetAll(v->val, (int *)NULL));
604 1.6 jtc if (v->flags & VAR_FROM_ENV) {
605 1.6 jtc Buf_Destroy(v->val, FALSE);
606 1.6 jtc free((Address) v);
607 1.6 jtc *frp = p;
608 1.6 jtc }
609 1.6 jtc return p;
610 1.1 cgd } else {
611 1.1 cgd return ((char *) NULL);
612 1.1 cgd }
613 1.1 cgd }
614 1.1 cgd
615 1.1 cgd /*-
616 1.1 cgd *-----------------------------------------------------------------------
617 1.1 cgd * VarHead --
618 1.1 cgd * Remove the tail of the given word and place the result in the given
619 1.1 cgd * buffer.
620 1.1 cgd *
621 1.1 cgd * Results:
622 1.1 cgd * TRUE if characters were added to the buffer (a space needs to be
623 1.1 cgd * added to the buffer before the next word).
624 1.1 cgd *
625 1.1 cgd * Side Effects:
626 1.1 cgd * The trimmed word is added to the buffer.
627 1.1 cgd *
628 1.1 cgd *-----------------------------------------------------------------------
629 1.1 cgd */
630 1.1 cgd static Boolean
631 1.6 jtc VarHead (word, addSpace, buf, dummy)
632 1.1 cgd char *word; /* Word to trim */
633 1.1 cgd Boolean addSpace; /* True if need to add a space to the buffer
634 1.1 cgd * before sticking in the head */
635 1.1 cgd Buffer buf; /* Buffer in which to store it */
636 1.6 jtc ClientData dummy;
637 1.1 cgd {
638 1.1 cgd register char *slash;
639 1.1 cgd
640 1.5 cgd slash = strrchr (word, '/');
641 1.1 cgd if (slash != (char *)NULL) {
642 1.1 cgd if (addSpace) {
643 1.1 cgd Buf_AddByte (buf, (Byte)' ');
644 1.1 cgd }
645 1.1 cgd *slash = '\0';
646 1.1 cgd Buf_AddBytes (buf, strlen (word), (Byte *)word);
647 1.1 cgd *slash = '/';
648 1.1 cgd return (TRUE);
649 1.1 cgd } else {
650 1.1 cgd /*
651 1.1 cgd * If no directory part, give . (q.v. the POSIX standard)
652 1.1 cgd */
653 1.1 cgd if (addSpace) {
654 1.1 cgd Buf_AddBytes(buf, 2, (Byte *)" .");
655 1.1 cgd } else {
656 1.1 cgd Buf_AddByte(buf, (Byte)'.');
657 1.1 cgd }
658 1.1 cgd }
659 1.6 jtc return(dummy ? TRUE : TRUE);
660 1.1 cgd }
661 1.1 cgd
662 1.1 cgd /*-
663 1.1 cgd *-----------------------------------------------------------------------
664 1.1 cgd * VarTail --
665 1.1 cgd * Remove the head of the given word and place the result in the given
666 1.1 cgd * buffer.
667 1.1 cgd *
668 1.1 cgd * Results:
669 1.1 cgd * TRUE if characters were added to the buffer (a space needs to be
670 1.1 cgd * added to the buffer before the next word).
671 1.1 cgd *
672 1.1 cgd * Side Effects:
673 1.1 cgd * The trimmed word is added to the buffer.
674 1.1 cgd *
675 1.1 cgd *-----------------------------------------------------------------------
676 1.1 cgd */
677 1.1 cgd static Boolean
678 1.6 jtc VarTail (word, addSpace, buf, dummy)
679 1.1 cgd char *word; /* Word to trim */
680 1.1 cgd Boolean addSpace; /* TRUE if need to stick a space in the
681 1.1 cgd * buffer before adding the tail */
682 1.1 cgd Buffer buf; /* Buffer in which to store it */
683 1.6 jtc ClientData dummy;
684 1.1 cgd {
685 1.1 cgd register char *slash;
686 1.1 cgd
687 1.1 cgd if (addSpace) {
688 1.1 cgd Buf_AddByte (buf, (Byte)' ');
689 1.1 cgd }
690 1.1 cgd
691 1.5 cgd slash = strrchr (word, '/');
692 1.1 cgd if (slash != (char *)NULL) {
693 1.1 cgd *slash++ = '\0';
694 1.1 cgd Buf_AddBytes (buf, strlen(slash), (Byte *)slash);
695 1.1 cgd slash[-1] = '/';
696 1.1 cgd } else {
697 1.1 cgd Buf_AddBytes (buf, strlen(word), (Byte *)word);
698 1.1 cgd }
699 1.6 jtc return (dummy ? TRUE : TRUE);
700 1.1 cgd }
701 1.1 cgd
702 1.1 cgd /*-
703 1.1 cgd *-----------------------------------------------------------------------
704 1.1 cgd * VarSuffix --
705 1.1 cgd * Place the suffix of the given word in the given buffer.
706 1.1 cgd *
707 1.1 cgd * Results:
708 1.1 cgd * TRUE if characters were added to the buffer (a space needs to be
709 1.1 cgd * added to the buffer before the next word).
710 1.1 cgd *
711 1.1 cgd * Side Effects:
712 1.1 cgd * The suffix from the word is placed in the buffer.
713 1.1 cgd *
714 1.1 cgd *-----------------------------------------------------------------------
715 1.1 cgd */
716 1.1 cgd static Boolean
717 1.6 jtc VarSuffix (word, addSpace, buf, dummy)
718 1.1 cgd char *word; /* Word to trim */
719 1.1 cgd Boolean addSpace; /* TRUE if need to add a space before placing
720 1.1 cgd * the suffix in the buffer */
721 1.1 cgd Buffer buf; /* Buffer in which to store it */
722 1.6 jtc ClientData dummy;
723 1.1 cgd {
724 1.1 cgd register char *dot;
725 1.1 cgd
726 1.5 cgd dot = strrchr (word, '.');
727 1.1 cgd if (dot != (char *)NULL) {
728 1.1 cgd if (addSpace) {
729 1.1 cgd Buf_AddByte (buf, (Byte)' ');
730 1.1 cgd }
731 1.1 cgd *dot++ = '\0';
732 1.1 cgd Buf_AddBytes (buf, strlen (dot), (Byte *)dot);
733 1.1 cgd dot[-1] = '.';
734 1.6 jtc addSpace = TRUE;
735 1.1 cgd }
736 1.6 jtc return (dummy ? addSpace : addSpace);
737 1.1 cgd }
738 1.1 cgd
739 1.1 cgd /*-
740 1.1 cgd *-----------------------------------------------------------------------
741 1.1 cgd * VarRoot --
742 1.1 cgd * Remove the suffix of the given word and place the result in the
743 1.1 cgd * buffer.
744 1.1 cgd *
745 1.1 cgd * Results:
746 1.1 cgd * TRUE if characters were added to the buffer (a space needs to be
747 1.1 cgd * added to the buffer before the next word).
748 1.1 cgd *
749 1.1 cgd * Side Effects:
750 1.1 cgd * The trimmed word is added to the buffer.
751 1.1 cgd *
752 1.1 cgd *-----------------------------------------------------------------------
753 1.1 cgd */
754 1.1 cgd static Boolean
755 1.6 jtc VarRoot (word, addSpace, buf, dummy)
756 1.1 cgd char *word; /* Word to trim */
757 1.1 cgd Boolean addSpace; /* TRUE if need to add a space to the buffer
758 1.1 cgd * before placing the root in it */
759 1.1 cgd Buffer buf; /* Buffer in which to store it */
760 1.6 jtc ClientData dummy;
761 1.1 cgd {
762 1.1 cgd register char *dot;
763 1.1 cgd
764 1.1 cgd if (addSpace) {
765 1.1 cgd Buf_AddByte (buf, (Byte)' ');
766 1.1 cgd }
767 1.1 cgd
768 1.5 cgd dot = strrchr (word, '.');
769 1.1 cgd if (dot != (char *)NULL) {
770 1.1 cgd *dot = '\0';
771 1.1 cgd Buf_AddBytes (buf, strlen (word), (Byte *)word);
772 1.1 cgd *dot = '.';
773 1.1 cgd } else {
774 1.1 cgd Buf_AddBytes (buf, strlen(word), (Byte *)word);
775 1.1 cgd }
776 1.6 jtc return (dummy ? TRUE : TRUE);
777 1.1 cgd }
778 1.1 cgd
779 1.1 cgd /*-
780 1.1 cgd *-----------------------------------------------------------------------
781 1.1 cgd * VarMatch --
782 1.1 cgd * Place the word in the buffer if it matches the given pattern.
783 1.1 cgd * Callback function for VarModify to implement the :M modifier.
784 1.15 christos *
785 1.1 cgd * Results:
786 1.1 cgd * TRUE if a space should be placed in the buffer before the next
787 1.1 cgd * word.
788 1.1 cgd *
789 1.1 cgd * Side Effects:
790 1.1 cgd * The word may be copied to the buffer.
791 1.1 cgd *
792 1.1 cgd *-----------------------------------------------------------------------
793 1.1 cgd */
794 1.1 cgd static Boolean
795 1.1 cgd VarMatch (word, addSpace, buf, pattern)
796 1.1 cgd char *word; /* Word to examine */
797 1.1 cgd Boolean addSpace; /* TRUE if need to add a space to the
798 1.1 cgd * buffer before adding the word, if it
799 1.1 cgd * matches */
800 1.1 cgd Buffer buf; /* Buffer in which to store it */
801 1.6 jtc ClientData pattern; /* Pattern the word must match */
802 1.1 cgd {
803 1.6 jtc if (Str_Match(word, (char *) pattern)) {
804 1.1 cgd if (addSpace) {
805 1.1 cgd Buf_AddByte(buf, (Byte)' ');
806 1.1 cgd }
807 1.1 cgd addSpace = TRUE;
808 1.1 cgd Buf_AddBytes(buf, strlen(word), (Byte *)word);
809 1.1 cgd }
810 1.1 cgd return(addSpace);
811 1.1 cgd }
812 1.1 cgd
813 1.13 christos #ifdef SYSVVARSUB
814 1.5 cgd /*-
815 1.5 cgd *-----------------------------------------------------------------------
816 1.5 cgd * VarSYSVMatch --
817 1.5 cgd * Place the word in the buffer if it matches the given pattern.
818 1.5 cgd * Callback function for VarModify to implement the System V %
819 1.5 cgd * modifiers.
820 1.15 christos *
821 1.5 cgd * Results:
822 1.5 cgd * TRUE if a space should be placed in the buffer before the next
823 1.5 cgd * word.
824 1.5 cgd *
825 1.5 cgd * Side Effects:
826 1.5 cgd * The word may be copied to the buffer.
827 1.5 cgd *
828 1.5 cgd *-----------------------------------------------------------------------
829 1.5 cgd */
830 1.5 cgd static Boolean
831 1.6 jtc VarSYSVMatch (word, addSpace, buf, patp)
832 1.5 cgd char *word; /* Word to examine */
833 1.5 cgd Boolean addSpace; /* TRUE if need to add a space to the
834 1.5 cgd * buffer before adding the word, if it
835 1.5 cgd * matches */
836 1.5 cgd Buffer buf; /* Buffer in which to store it */
837 1.6 jtc ClientData patp; /* Pattern the word must match */
838 1.5 cgd {
839 1.5 cgd int len;
840 1.5 cgd char *ptr;
841 1.6 jtc VarPattern *pat = (VarPattern *) patp;
842 1.5 cgd
843 1.5 cgd if (addSpace)
844 1.5 cgd Buf_AddByte(buf, (Byte)' ');
845 1.5 cgd
846 1.5 cgd addSpace = TRUE;
847 1.5 cgd
848 1.5 cgd if ((ptr = Str_SYSVMatch(word, pat->lhs, &len)) != NULL)
849 1.5 cgd Str_SYSVSubst(buf, pat->rhs, ptr, len);
850 1.5 cgd else
851 1.5 cgd Buf_AddBytes(buf, strlen(word), (Byte *) word);
852 1.5 cgd
853 1.5 cgd return(addSpace);
854 1.5 cgd }
855 1.13 christos #endif
856 1.5 cgd
857 1.5 cgd
858 1.1 cgd /*-
859 1.1 cgd *-----------------------------------------------------------------------
860 1.1 cgd * VarNoMatch --
861 1.1 cgd * Place the word in the buffer if it doesn't match the given pattern.
862 1.1 cgd * Callback function for VarModify to implement the :N modifier.
863 1.15 christos *
864 1.1 cgd * Results:
865 1.1 cgd * TRUE if a space should be placed in the buffer before the next
866 1.1 cgd * word.
867 1.1 cgd *
868 1.1 cgd * Side Effects:
869 1.1 cgd * The word may be copied to the buffer.
870 1.1 cgd *
871 1.1 cgd *-----------------------------------------------------------------------
872 1.1 cgd */
873 1.1 cgd static Boolean
874 1.1 cgd VarNoMatch (word, addSpace, buf, pattern)
875 1.1 cgd char *word; /* Word to examine */
876 1.1 cgd Boolean addSpace; /* TRUE if need to add a space to the
877 1.1 cgd * buffer before adding the word, if it
878 1.1 cgd * matches */
879 1.1 cgd Buffer buf; /* Buffer in which to store it */
880 1.6 jtc ClientData pattern; /* Pattern the word must match */
881 1.1 cgd {
882 1.6 jtc if (!Str_Match(word, (char *) pattern)) {
883 1.1 cgd if (addSpace) {
884 1.1 cgd Buf_AddByte(buf, (Byte)' ');
885 1.1 cgd }
886 1.1 cgd addSpace = TRUE;
887 1.1 cgd Buf_AddBytes(buf, strlen(word), (Byte *)word);
888 1.1 cgd }
889 1.1 cgd return(addSpace);
890 1.1 cgd }
891 1.1 cgd
892 1.1 cgd
893 1.1 cgd /*-
894 1.1 cgd *-----------------------------------------------------------------------
895 1.1 cgd * VarSubstitute --
896 1.1 cgd * Perform a string-substitution on the given word, placing the
897 1.1 cgd * result in the passed buffer.
898 1.1 cgd *
899 1.1 cgd * Results:
900 1.1 cgd * TRUE if a space is needed before more characters are added.
901 1.1 cgd *
902 1.1 cgd * Side Effects:
903 1.1 cgd * None.
904 1.1 cgd *
905 1.1 cgd *-----------------------------------------------------------------------
906 1.1 cgd */
907 1.1 cgd static Boolean
908 1.6 jtc VarSubstitute (word, addSpace, buf, patternp)
909 1.1 cgd char *word; /* Word to modify */
910 1.1 cgd Boolean addSpace; /* True if space should be added before
911 1.1 cgd * other characters */
912 1.1 cgd Buffer buf; /* Buffer for result */
913 1.6 jtc ClientData patternp; /* Pattern for substitution */
914 1.1 cgd {
915 1.1 cgd register int wordLen; /* Length of word */
916 1.1 cgd register char *cp; /* General pointer */
917 1.6 jtc VarPattern *pattern = (VarPattern *) patternp;
918 1.1 cgd
919 1.1 cgd wordLen = strlen(word);
920 1.16 christos if ((pattern->flags & (VAR_SUB_ONE|VAR_SUB_MATCHED)) !=
921 1.16 christos (VAR_SUB_ONE|VAR_SUB_MATCHED)) {
922 1.1 cgd /*
923 1.16 christos * Still substituting -- break it down into simple anchored cases
924 1.1 cgd * and if none of them fits, perform the general substitution case.
925 1.1 cgd */
926 1.1 cgd if ((pattern->flags & VAR_MATCH_START) &&
927 1.1 cgd (strncmp(word, pattern->lhs, pattern->leftLen) == 0)) {
928 1.1 cgd /*
929 1.1 cgd * Anchored at start and beginning of word matches pattern
930 1.1 cgd */
931 1.1 cgd if ((pattern->flags & VAR_MATCH_END) &&
932 1.1 cgd (wordLen == pattern->leftLen)) {
933 1.1 cgd /*
934 1.1 cgd * Also anchored at end and matches to the end (word
935 1.1 cgd * is same length as pattern) add space and rhs only
936 1.1 cgd * if rhs is non-null.
937 1.1 cgd */
938 1.1 cgd if (pattern->rightLen != 0) {
939 1.1 cgd if (addSpace) {
940 1.1 cgd Buf_AddByte(buf, (Byte)' ');
941 1.1 cgd }
942 1.1 cgd addSpace = TRUE;
943 1.1 cgd Buf_AddBytes(buf, pattern->rightLen,
944 1.1 cgd (Byte *)pattern->rhs);
945 1.1 cgd }
946 1.16 christos pattern->flags |= VAR_SUB_MATCHED;
947 1.1 cgd } else if (pattern->flags & VAR_MATCH_END) {
948 1.1 cgd /*
949 1.1 cgd * Doesn't match to end -- copy word wholesale
950 1.1 cgd */
951 1.1 cgd goto nosub;
952 1.1 cgd } else {
953 1.1 cgd /*
954 1.1 cgd * Matches at start but need to copy in trailing characters
955 1.1 cgd */
956 1.1 cgd if ((pattern->rightLen + wordLen - pattern->leftLen) != 0){
957 1.1 cgd if (addSpace) {
958 1.1 cgd Buf_AddByte(buf, (Byte)' ');
959 1.1 cgd }
960 1.1 cgd addSpace = TRUE;
961 1.1 cgd }
962 1.1 cgd Buf_AddBytes(buf, pattern->rightLen, (Byte *)pattern->rhs);
963 1.1 cgd Buf_AddBytes(buf, wordLen - pattern->leftLen,
964 1.1 cgd (Byte *)(word + pattern->leftLen));
965 1.16 christos pattern->flags |= VAR_SUB_MATCHED;
966 1.1 cgd }
967 1.1 cgd } else if (pattern->flags & VAR_MATCH_START) {
968 1.1 cgd /*
969 1.1 cgd * Had to match at start of word and didn't -- copy whole word.
970 1.1 cgd */
971 1.1 cgd goto nosub;
972 1.1 cgd } else if (pattern->flags & VAR_MATCH_END) {
973 1.1 cgd /*
974 1.1 cgd * Anchored at end, Find only place match could occur (leftLen
975 1.1 cgd * characters from the end of the word) and see if it does. Note
976 1.1 cgd * that because the $ will be left at the end of the lhs, we have
977 1.1 cgd * to use strncmp.
978 1.1 cgd */
979 1.1 cgd cp = word + (wordLen - pattern->leftLen);
980 1.1 cgd if ((cp >= word) &&
981 1.1 cgd (strncmp(cp, pattern->lhs, pattern->leftLen) == 0)) {
982 1.1 cgd /*
983 1.1 cgd * Match found. If we will place characters in the buffer,
984 1.1 cgd * add a space before hand as indicated by addSpace, then
985 1.1 cgd * stuff in the initial, unmatched part of the word followed
986 1.1 cgd * by the right-hand-side.
987 1.1 cgd */
988 1.1 cgd if (((cp - word) + pattern->rightLen) != 0) {
989 1.1 cgd if (addSpace) {
990 1.1 cgd Buf_AddByte(buf, (Byte)' ');
991 1.1 cgd }
992 1.1 cgd addSpace = TRUE;
993 1.1 cgd }
994 1.1 cgd Buf_AddBytes(buf, cp - word, (Byte *)word);
995 1.1 cgd Buf_AddBytes(buf, pattern->rightLen, (Byte *)pattern->rhs);
996 1.16 christos pattern->flags |= VAR_SUB_MATCHED;
997 1.1 cgd } else {
998 1.1 cgd /*
999 1.1 cgd * Had to match at end and didn't. Copy entire word.
1000 1.1 cgd */
1001 1.1 cgd goto nosub;
1002 1.1 cgd }
1003 1.1 cgd } else {
1004 1.1 cgd /*
1005 1.1 cgd * Pattern is unanchored: search for the pattern in the word using
1006 1.1 cgd * String_FindSubstring, copying unmatched portions and the
1007 1.1 cgd * right-hand-side for each match found, handling non-global
1008 1.15 christos * substitutions correctly, etc. When the loop is done, any
1009 1.1 cgd * remaining part of the word (word and wordLen are adjusted
1010 1.1 cgd * accordingly through the loop) is copied straight into the
1011 1.1 cgd * buffer.
1012 1.1 cgd * addSpace is set FALSE as soon as a space is added to the
1013 1.1 cgd * buffer.
1014 1.1 cgd */
1015 1.1 cgd register Boolean done;
1016 1.1 cgd int origSize;
1017 1.1 cgd
1018 1.1 cgd done = FALSE;
1019 1.1 cgd origSize = Buf_Size(buf);
1020 1.1 cgd while (!done) {
1021 1.1 cgd cp = Str_FindSubstring(word, pattern->lhs);
1022 1.1 cgd if (cp != (char *)NULL) {
1023 1.1 cgd if (addSpace && (((cp - word) + pattern->rightLen) != 0)){
1024 1.1 cgd Buf_AddByte(buf, (Byte)' ');
1025 1.1 cgd addSpace = FALSE;
1026 1.1 cgd }
1027 1.1 cgd Buf_AddBytes(buf, cp-word, (Byte *)word);
1028 1.1 cgd Buf_AddBytes(buf, pattern->rightLen, (Byte *)pattern->rhs);
1029 1.1 cgd wordLen -= (cp - word) + pattern->leftLen;
1030 1.1 cgd word = cp + pattern->leftLen;
1031 1.16 christos if (wordLen == 0) {
1032 1.16 christos done = TRUE;
1033 1.16 christos }
1034 1.16 christos if ((pattern->flags & VAR_SUB_GLOBAL) == 0) {
1035 1.1 cgd done = TRUE;
1036 1.1 cgd }
1037 1.16 christos pattern->flags |= VAR_SUB_MATCHED;
1038 1.1 cgd } else {
1039 1.1 cgd done = TRUE;
1040 1.1 cgd }
1041 1.1 cgd }
1042 1.1 cgd if (wordLen != 0) {
1043 1.1 cgd if (addSpace) {
1044 1.1 cgd Buf_AddByte(buf, (Byte)' ');
1045 1.1 cgd }
1046 1.1 cgd Buf_AddBytes(buf, wordLen, (Byte *)word);
1047 1.1 cgd }
1048 1.1 cgd /*
1049 1.1 cgd * If added characters to the buffer, need to add a space
1050 1.1 cgd * before we add any more. If we didn't add any, just return
1051 1.1 cgd * the previous value of addSpace.
1052 1.1 cgd */
1053 1.1 cgd return ((Buf_Size(buf) != origSize) || addSpace);
1054 1.1 cgd }
1055 1.1 cgd return (addSpace);
1056 1.1 cgd }
1057 1.1 cgd nosub:
1058 1.1 cgd if (addSpace) {
1059 1.1 cgd Buf_AddByte(buf, (Byte)' ');
1060 1.1 cgd }
1061 1.1 cgd Buf_AddBytes(buf, wordLen, (Byte *)word);
1062 1.1 cgd return(TRUE);
1063 1.1 cgd }
1064 1.1 cgd
1065 1.17 christos #ifndef MAKE_BOOTSTRAP
1066 1.16 christos /*-
1067 1.16 christos *-----------------------------------------------------------------------
1068 1.16 christos * VarREError --
1069 1.16 christos * Print the error caused by a regcomp or regexec call.
1070 1.16 christos *
1071 1.16 christos * Results:
1072 1.16 christos * None.
1073 1.16 christos *
1074 1.16 christos * Side Effects:
1075 1.16 christos * An error gets printed.
1076 1.16 christos *
1077 1.16 christos *-----------------------------------------------------------------------
1078 1.16 christos */
1079 1.16 christos static void
1080 1.16 christos VarREError(err, pat, str)
1081 1.16 christos int err;
1082 1.16 christos regex_t *pat;
1083 1.16 christos const char *str;
1084 1.16 christos {
1085 1.16 christos char *errbuf;
1086 1.16 christos int errlen;
1087 1.16 christos
1088 1.16 christos errlen = regerror(err, pat, 0, 0);
1089 1.16 christos errbuf = emalloc(errlen);
1090 1.16 christos regerror(err, pat, errbuf, errlen);
1091 1.16 christos Error("%s: %s", str, errbuf);
1092 1.16 christos free(errbuf);
1093 1.16 christos }
1094 1.16 christos
1095 1.16 christos
1096 1.16 christos /*-
1097 1.16 christos *-----------------------------------------------------------------------
1098 1.16 christos * VarRESubstitute --
1099 1.16 christos * Perform a regex substitution on the given word, placing the
1100 1.16 christos * result in the passed buffer.
1101 1.16 christos *
1102 1.16 christos * Results:
1103 1.16 christos * TRUE if a space is needed before more characters are added.
1104 1.16 christos *
1105 1.16 christos * Side Effects:
1106 1.16 christos * None.
1107 1.16 christos *
1108 1.16 christos *-----------------------------------------------------------------------
1109 1.16 christos */
1110 1.16 christos static Boolean
1111 1.16 christos VarRESubstitute(word, addSpace, buf, patternp)
1112 1.16 christos char *word;
1113 1.16 christos Boolean addSpace;
1114 1.16 christos Buffer buf;
1115 1.16 christos ClientData patternp;
1116 1.16 christos {
1117 1.16 christos VarREPattern *pat;
1118 1.16 christos int xrv;
1119 1.16 christos char *wp;
1120 1.16 christos char *rp;
1121 1.16 christos int added;
1122 1.20 christos int flags = 0;
1123 1.16 christos
1124 1.16 christos #define MAYBE_ADD_SPACE() \
1125 1.16 christos if (addSpace && !added) \
1126 1.16 christos Buf_AddByte(buf, ' '); \
1127 1.16 christos added = 1
1128 1.16 christos
1129 1.16 christos added = 0;
1130 1.16 christos wp = word;
1131 1.16 christos pat = patternp;
1132 1.16 christos
1133 1.16 christos if ((pat->flags & (VAR_SUB_ONE|VAR_SUB_MATCHED)) ==
1134 1.16 christos (VAR_SUB_ONE|VAR_SUB_MATCHED))
1135 1.16 christos xrv = REG_NOMATCH;
1136 1.16 christos else {
1137 1.16 christos tryagain:
1138 1.21 christos xrv = regexec(&pat->re, wp, pat->nsub, pat->matches, flags);
1139 1.16 christos }
1140 1.16 christos
1141 1.16 christos switch (xrv) {
1142 1.16 christos case 0:
1143 1.16 christos pat->flags |= VAR_SUB_MATCHED;
1144 1.16 christos if (pat->matches[0].rm_so > 0) {
1145 1.16 christos MAYBE_ADD_SPACE();
1146 1.16 christos Buf_AddBytes(buf, pat->matches[0].rm_so, wp);
1147 1.16 christos }
1148 1.16 christos
1149 1.16 christos for (rp = pat->replace; *rp; rp++) {
1150 1.16 christos if ((*rp == '\\') && ((rp[1] == '&') || (rp[1] == '\\'))) {
1151 1.16 christos MAYBE_ADD_SPACE();
1152 1.16 christos Buf_AddByte(buf,rp[1]);
1153 1.16 christos rp++;
1154 1.16 christos }
1155 1.16 christos else if ((*rp == '&') || ((*rp == '\\') && isdigit(rp[1]))) {
1156 1.16 christos int n;
1157 1.16 christos char *subbuf;
1158 1.16 christos int sublen;
1159 1.16 christos char errstr[3];
1160 1.16 christos
1161 1.16 christos if (*rp == '&') {
1162 1.16 christos n = 0;
1163 1.16 christos errstr[0] = '&';
1164 1.16 christos errstr[1] = '\0';
1165 1.16 christos } else {
1166 1.16 christos n = rp[1] - '0';
1167 1.16 christos errstr[0] = '\\';
1168 1.16 christos errstr[1] = rp[1];
1169 1.16 christos errstr[2] = '\0';
1170 1.16 christos rp++;
1171 1.16 christos }
1172 1.16 christos
1173 1.16 christos if (n > pat->nsub) {
1174 1.16 christos Error("No subexpression %s", &errstr[0]);
1175 1.16 christos subbuf = "";
1176 1.16 christos sublen = 0;
1177 1.16 christos } else if ((pat->matches[n].rm_so == -1) &&
1178 1.16 christos (pat->matches[n].rm_eo == -1)) {
1179 1.16 christos Error("No match for subexpression %s", &errstr[0]);
1180 1.16 christos subbuf = "";
1181 1.16 christos sublen = 0;
1182 1.16 christos } else {
1183 1.16 christos subbuf = wp + pat->matches[n].rm_so;
1184 1.16 christos sublen = pat->matches[n].rm_eo - pat->matches[n].rm_so;
1185 1.16 christos }
1186 1.16 christos
1187 1.16 christos if (sublen > 0) {
1188 1.16 christos MAYBE_ADD_SPACE();
1189 1.16 christos Buf_AddBytes(buf, sublen, subbuf);
1190 1.16 christos }
1191 1.16 christos } else {
1192 1.16 christos MAYBE_ADD_SPACE();
1193 1.16 christos Buf_AddByte(buf, *rp);
1194 1.16 christos }
1195 1.16 christos }
1196 1.16 christos wp += pat->matches[0].rm_eo;
1197 1.20 christos if (pat->flags & VAR_SUB_GLOBAL) {
1198 1.20 christos flags |= REG_NOTBOL;
1199 1.20 christos if (pat->matches[0].rm_so == 0 && pat->matches[0].rm_eo == 0) {
1200 1.20 christos MAYBE_ADD_SPACE();
1201 1.20 christos Buf_AddByte(buf, *wp);
1202 1.20 christos wp++;
1203 1.20 christos
1204 1.20 christos }
1205 1.20 christos if (*wp)
1206 1.20 christos goto tryagain;
1207 1.20 christos }
1208 1.16 christos if (*wp) {
1209 1.16 christos MAYBE_ADD_SPACE();
1210 1.16 christos Buf_AddBytes(buf, strlen(wp), wp);
1211 1.16 christos }
1212 1.16 christos break;
1213 1.16 christos default:
1214 1.16 christos VarREError(xrv, &pat->re, "Unexpected regex error");
1215 1.16 christos /* fall through */
1216 1.16 christos case REG_NOMATCH:
1217 1.16 christos if (*wp) {
1218 1.16 christos MAYBE_ADD_SPACE();
1219 1.16 christos Buf_AddBytes(buf,strlen(wp),wp);
1220 1.16 christos }
1221 1.16 christos break;
1222 1.16 christos }
1223 1.16 christos return(addSpace||added);
1224 1.16 christos }
1225 1.17 christos #endif
1226 1.16 christos
1227 1.16 christos
1228 1.1 cgd /*-
1229 1.1 cgd *-----------------------------------------------------------------------
1230 1.1 cgd * VarModify --
1231 1.1 cgd * Modify each of the words of the passed string using the given
1232 1.1 cgd * function. Used to implement all modifiers.
1233 1.1 cgd *
1234 1.1 cgd * Results:
1235 1.1 cgd * A string of all the words modified appropriately.
1236 1.1 cgd *
1237 1.1 cgd * Side Effects:
1238 1.1 cgd * None.
1239 1.1 cgd *
1240 1.1 cgd *-----------------------------------------------------------------------
1241 1.1 cgd */
1242 1.1 cgd static char *
1243 1.1 cgd VarModify (str, modProc, datum)
1244 1.1 cgd char *str; /* String whose words should be trimmed */
1245 1.6 jtc /* Function to use to modify them */
1246 1.6 jtc Boolean (*modProc) __P((char *, Boolean, Buffer, ClientData));
1247 1.1 cgd ClientData datum; /* Datum to pass it */
1248 1.1 cgd {
1249 1.1 cgd Buffer buf; /* Buffer for the new string */
1250 1.1 cgd Boolean addSpace; /* TRUE if need to add a space to the
1251 1.1 cgd * buffer before adding the trimmed
1252 1.1 cgd * word */
1253 1.7 jtc char **av; /* word list [first word does not count] */
1254 1.7 jtc int ac, i;
1255 1.7 jtc
1256 1.1 cgd buf = Buf_Init (0);
1257 1.1 cgd addSpace = FALSE;
1258 1.1 cgd
1259 1.7 jtc av = brk_string(str, &ac, FALSE);
1260 1.1 cgd
1261 1.7 jtc for (i = 1; i < ac; i++)
1262 1.7 jtc addSpace = (*modProc)(av[i], addSpace, buf, datum);
1263 1.15 christos
1264 1.7 jtc Buf_AddByte (buf, '\0');
1265 1.7 jtc str = (char *)Buf_GetAll (buf, (int *)NULL);
1266 1.7 jtc Buf_Destroy (buf, FALSE);
1267 1.7 jtc return (str);
1268 1.1 cgd }
1269 1.1 cgd
1270 1.1 cgd /*-
1271 1.1 cgd *-----------------------------------------------------------------------
1272 1.16 christos * VarGetPattern --
1273 1.16 christos * Pass through the tstr looking for 1) escaped delimiters,
1274 1.16 christos * '$'s and backslashes (place the escaped character in
1275 1.16 christos * uninterpreted) and 2) unescaped $'s that aren't before
1276 1.16 christos * the delimiter (expand the variable substitution).
1277 1.16 christos * Return the expanded string or NULL if the delimiter was missing
1278 1.16 christos * If pattern is specified, handle escaped ampersants, and replace
1279 1.16 christos * unescaped ampersands with the lhs of the pattern.
1280 1.16 christos *
1281 1.16 christos * Results:
1282 1.16 christos * A string of all the words modified appropriately.
1283 1.16 christos * If length is specified, return the string length of the buffer
1284 1.16 christos * If flags is specified and the last character of the pattern is a
1285 1.16 christos * $ set the VAR_MATCH_END bit of flags.
1286 1.16 christos *
1287 1.16 christos * Side Effects:
1288 1.16 christos * None.
1289 1.16 christos *-----------------------------------------------------------------------
1290 1.16 christos */
1291 1.16 christos static char *
1292 1.16 christos VarGetPattern(ctxt, err, tstr, delim, flags, length, pattern)
1293 1.16 christos GNode *ctxt;
1294 1.16 christos int err;
1295 1.16 christos char **tstr;
1296 1.16 christos int delim;
1297 1.16 christos int *flags;
1298 1.16 christos int *length;
1299 1.16 christos VarPattern *pattern;
1300 1.16 christos {
1301 1.16 christos char *cp;
1302 1.16 christos Buffer buf = Buf_Init(0);
1303 1.16 christos int junk;
1304 1.16 christos if (length == NULL)
1305 1.16 christos length = &junk;
1306 1.16 christos
1307 1.16 christos #define IS_A_MATCH(cp, delim) \
1308 1.16 christos ((cp[0] == '\\') && ((cp[1] == delim) || \
1309 1.16 christos (cp[1] == '\\') || (cp[1] == '$') || (pattern && (cp[1] == '&'))))
1310 1.16 christos
1311 1.16 christos /*
1312 1.16 christos * Skim through until the matching delimiter is found;
1313 1.16 christos * pick up variable substitutions on the way. Also allow
1314 1.16 christos * backslashes to quote the delimiter, $, and \, but don't
1315 1.16 christos * touch other backslashes.
1316 1.16 christos */
1317 1.16 christos for (cp = *tstr; *cp && (*cp != delim); cp++) {
1318 1.16 christos if (IS_A_MATCH(cp, delim)) {
1319 1.16 christos Buf_AddByte(buf, (Byte) cp[1]);
1320 1.16 christos cp++;
1321 1.16 christos } else if (*cp == '$') {
1322 1.16 christos if (cp[1] == delim) {
1323 1.16 christos if (flags == NULL)
1324 1.16 christos Buf_AddByte(buf, (Byte) *cp);
1325 1.16 christos else
1326 1.16 christos /*
1327 1.16 christos * Unescaped $ at end of pattern => anchor
1328 1.16 christos * pattern at end.
1329 1.16 christos */
1330 1.16 christos *flags |= VAR_MATCH_END;
1331 1.16 christos }
1332 1.16 christos else {
1333 1.16 christos char *cp2;
1334 1.16 christos int len;
1335 1.16 christos Boolean freeIt;
1336 1.16 christos
1337 1.16 christos /*
1338 1.16 christos * If unescaped dollar sign not before the
1339 1.16 christos * delimiter, assume it's a variable
1340 1.16 christos * substitution and recurse.
1341 1.16 christos */
1342 1.16 christos cp2 = Var_Parse(cp, ctxt, err, &len, &freeIt);
1343 1.16 christos Buf_AddBytes(buf, strlen(cp2), (Byte *) cp2);
1344 1.16 christos if (freeIt)
1345 1.16 christos free(cp2);
1346 1.16 christos cp += len - 1;
1347 1.16 christos }
1348 1.16 christos }
1349 1.16 christos else if (pattern && *cp == '&')
1350 1.16 christos Buf_AddBytes(buf, pattern->leftLen, (Byte *)pattern->lhs);
1351 1.16 christos else
1352 1.16 christos Buf_AddByte(buf, (Byte) *cp);
1353 1.16 christos }
1354 1.16 christos
1355 1.16 christos Buf_AddByte(buf, (Byte) '\0');
1356 1.16 christos
1357 1.16 christos if (*cp != delim) {
1358 1.16 christos *tstr = cp;
1359 1.16 christos *length = 0;
1360 1.16 christos return NULL;
1361 1.16 christos }
1362 1.16 christos else {
1363 1.16 christos *tstr = ++cp;
1364 1.16 christos cp = (char *) Buf_GetAll(buf, length);
1365 1.16 christos *length -= 1; /* Don't count the NULL */
1366 1.16 christos Buf_Destroy(buf, FALSE);
1367 1.16 christos return cp;
1368 1.16 christos }
1369 1.16 christos }
1370 1.16 christos
1371 1.16 christos /*-
1372 1.16 christos *-----------------------------------------------------------------------
1373 1.16 christos * VarQuote --
1374 1.16 christos * Quote shell meta-characters in the string
1375 1.16 christos *
1376 1.16 christos * Results:
1377 1.16 christos * The quoted string
1378 1.16 christos *
1379 1.16 christos * Side Effects:
1380 1.16 christos * None.
1381 1.16 christos *
1382 1.16 christos *-----------------------------------------------------------------------
1383 1.16 christos */
1384 1.16 christos static char *
1385 1.16 christos VarQuote(str)
1386 1.16 christos char *str;
1387 1.16 christos {
1388 1.16 christos
1389 1.16 christos Buffer buf;
1390 1.16 christos /* This should cover most shells :-( */
1391 1.16 christos static char meta[] = "\n \t'`\";&<>()|*?{}[]\\$!#^~";
1392 1.16 christos
1393 1.16 christos buf = Buf_Init (MAKE_BSIZE);
1394 1.16 christos for (; *str; str++) {
1395 1.16 christos if (strchr(meta, *str) != NULL)
1396 1.16 christos Buf_AddByte(buf, (Byte)'\\');
1397 1.16 christos Buf_AddByte(buf, (Byte)*str);
1398 1.16 christos }
1399 1.16 christos Buf_AddByte(buf, (Byte) '\0');
1400 1.16 christos str = (char *)Buf_GetAll (buf, (int *)NULL);
1401 1.16 christos Buf_Destroy (buf, FALSE);
1402 1.16 christos return str;
1403 1.16 christos }
1404 1.16 christos
1405 1.16 christos
1406 1.16 christos /*-
1407 1.16 christos *-----------------------------------------------------------------------
1408 1.1 cgd * Var_Parse --
1409 1.1 cgd * Given the start of a variable invocation, extract the variable
1410 1.1 cgd * name and find its value, then modify it according to the
1411 1.1 cgd * specification.
1412 1.1 cgd *
1413 1.1 cgd * Results:
1414 1.1 cgd * The (possibly-modified) value of the variable or var_Error if the
1415 1.1 cgd * specification is invalid. The length of the specification is
1416 1.1 cgd * placed in *lengthPtr (for invalid specifications, this is just
1417 1.1 cgd * 2...?).
1418 1.1 cgd * A Boolean in *freePtr telling whether the returned string should
1419 1.1 cgd * be freed by the caller.
1420 1.1 cgd *
1421 1.1 cgd * Side Effects:
1422 1.1 cgd * None.
1423 1.1 cgd *
1424 1.1 cgd *-----------------------------------------------------------------------
1425 1.1 cgd */
1426 1.1 cgd char *
1427 1.1 cgd Var_Parse (str, ctxt, err, lengthPtr, freePtr)
1428 1.1 cgd char *str; /* The string to parse */
1429 1.1 cgd GNode *ctxt; /* The context for the variable */
1430 1.1 cgd Boolean err; /* TRUE if undefined variables are an error */
1431 1.1 cgd int *lengthPtr; /* OUT: The length of the specification */
1432 1.1 cgd Boolean *freePtr; /* OUT: TRUE if caller should free result */
1433 1.1 cgd {
1434 1.1 cgd register char *tstr; /* Pointer into str */
1435 1.1 cgd Var *v; /* Variable in invocation */
1436 1.16 christos char *cp; /* Secondary pointer into str (place marker
1437 1.1 cgd * for tstr) */
1438 1.1 cgd Boolean haveModifier;/* TRUE if have modifiers for the variable */
1439 1.1 cgd register char endc; /* Ending character when variable in parens
1440 1.1 cgd * or braces */
1441 1.12 christos register char startc=0; /* Starting character when variable in parens
1442 1.9 christos * or braces */
1443 1.9 christos int cnt; /* Used to count brace pairs when variable in
1444 1.9 christos * in parens or braces */
1445 1.1 cgd char *start;
1446 1.16 christos char delim;
1447 1.1 cgd Boolean dynamic; /* TRUE if the variable is local and we're
1448 1.1 cgd * expanding it in a non-local context. This
1449 1.1 cgd * is done to support dynamic sources. The
1450 1.1 cgd * result is just the invocation, unaltered */
1451 1.15 christos
1452 1.1 cgd *freePtr = FALSE;
1453 1.1 cgd dynamic = FALSE;
1454 1.1 cgd start = str;
1455 1.15 christos
1456 1.1 cgd if (str[1] != '(' && str[1] != '{') {
1457 1.1 cgd /*
1458 1.1 cgd * If it's not bounded by braces of some sort, life is much simpler.
1459 1.1 cgd * We just need to check for the first character and return the
1460 1.1 cgd * value if it exists.
1461 1.1 cgd */
1462 1.1 cgd char name[2];
1463 1.1 cgd
1464 1.1 cgd name[0] = str[1];
1465 1.1 cgd name[1] = '\0';
1466 1.1 cgd
1467 1.1 cgd v = VarFind (name, ctxt, FIND_ENV | FIND_GLOBAL | FIND_CMD);
1468 1.1 cgd if (v == (Var *)NIL) {
1469 1.1 cgd *lengthPtr = 2;
1470 1.15 christos
1471 1.1 cgd if ((ctxt == VAR_CMD) || (ctxt == VAR_GLOBAL)) {
1472 1.1 cgd /*
1473 1.1 cgd * If substituting a local variable in a non-local context,
1474 1.1 cgd * assume it's for dynamic source stuff. We have to handle
1475 1.1 cgd * this specially and return the longhand for the variable
1476 1.1 cgd * with the dollar sign escaped so it makes it back to the
1477 1.1 cgd * caller. Only four of the local variables are treated
1478 1.1 cgd * specially as they are the only four that will be set
1479 1.1 cgd * when dynamic sources are expanded.
1480 1.1 cgd */
1481 1.1 cgd switch (str[1]) {
1482 1.1 cgd case '@':
1483 1.1 cgd return("$(.TARGET)");
1484 1.1 cgd case '%':
1485 1.1 cgd return("$(.ARCHIVE)");
1486 1.1 cgd case '*':
1487 1.1 cgd return("$(.PREFIX)");
1488 1.1 cgd case '!':
1489 1.1 cgd return("$(.MEMBER)");
1490 1.1 cgd }
1491 1.1 cgd }
1492 1.1 cgd /*
1493 1.1 cgd * Error
1494 1.1 cgd */
1495 1.1 cgd return (err ? var_Error : varNoError);
1496 1.1 cgd } else {
1497 1.1 cgd haveModifier = FALSE;
1498 1.1 cgd tstr = &str[1];
1499 1.1 cgd endc = str[1];
1500 1.1 cgd }
1501 1.1 cgd } else {
1502 1.9 christos startc = str[1];
1503 1.9 christos endc = startc == '(' ? ')' : '}';
1504 1.1 cgd
1505 1.1 cgd /*
1506 1.1 cgd * Skip to the end character or a colon, whichever comes first.
1507 1.1 cgd */
1508 1.1 cgd for (tstr = str + 2;
1509 1.1 cgd *tstr != '\0' && *tstr != endc && *tstr != ':';
1510 1.1 cgd tstr++)
1511 1.1 cgd {
1512 1.1 cgd continue;
1513 1.1 cgd }
1514 1.1 cgd if (*tstr == ':') {
1515 1.1 cgd haveModifier = TRUE;
1516 1.1 cgd } else if (*tstr != '\0') {
1517 1.1 cgd haveModifier = FALSE;
1518 1.1 cgd } else {
1519 1.1 cgd /*
1520 1.1 cgd * If we never did find the end character, return NULL
1521 1.1 cgd * right now, setting the length to be the distance to
1522 1.1 cgd * the end of the string, since that's what make does.
1523 1.1 cgd */
1524 1.1 cgd *lengthPtr = tstr - str;
1525 1.1 cgd return (var_Error);
1526 1.1 cgd }
1527 1.1 cgd *tstr = '\0';
1528 1.15 christos
1529 1.1 cgd v = VarFind (str + 2, ctxt, FIND_ENV | FIND_GLOBAL | FIND_CMD);
1530 1.1 cgd if ((v == (Var *)NIL) && (ctxt != VAR_CMD) && (ctxt != VAR_GLOBAL) &&
1531 1.1 cgd ((tstr-str) == 4) && (str[3] == 'F' || str[3] == 'D'))
1532 1.1 cgd {
1533 1.1 cgd /*
1534 1.1 cgd * Check for bogus D and F forms of local variables since we're
1535 1.1 cgd * in a local context and the name is the right length.
1536 1.1 cgd */
1537 1.1 cgd switch(str[2]) {
1538 1.1 cgd case '@':
1539 1.1 cgd case '%':
1540 1.1 cgd case '*':
1541 1.1 cgd case '!':
1542 1.1 cgd case '>':
1543 1.1 cgd case '<':
1544 1.1 cgd {
1545 1.1 cgd char vname[2];
1546 1.1 cgd char *val;
1547 1.1 cgd
1548 1.1 cgd /*
1549 1.1 cgd * Well, it's local -- go look for it.
1550 1.1 cgd */
1551 1.1 cgd vname[0] = str[2];
1552 1.1 cgd vname[1] = '\0';
1553 1.1 cgd v = VarFind(vname, ctxt, 0);
1554 1.15 christos
1555 1.1 cgd if (v != (Var *)NIL) {
1556 1.1 cgd /*
1557 1.1 cgd * No need for nested expansion or anything, as we're
1558 1.1 cgd * the only one who sets these things and we sure don't
1559 1.1 cgd * but nested invocations in them...
1560 1.1 cgd */
1561 1.1 cgd val = (char *)Buf_GetAll(v->val, (int *)NULL);
1562 1.15 christos
1563 1.1 cgd if (str[3] == 'D') {
1564 1.1 cgd val = VarModify(val, VarHead, (ClientData)0);
1565 1.1 cgd } else {
1566 1.1 cgd val = VarModify(val, VarTail, (ClientData)0);
1567 1.1 cgd }
1568 1.1 cgd /*
1569 1.1 cgd * Resulting string is dynamically allocated, so
1570 1.1 cgd * tell caller to free it.
1571 1.1 cgd */
1572 1.1 cgd *freePtr = TRUE;
1573 1.1 cgd *lengthPtr = tstr-start+1;
1574 1.1 cgd *tstr = endc;
1575 1.1 cgd return(val);
1576 1.1 cgd }
1577 1.1 cgd break;
1578 1.1 cgd }
1579 1.1 cgd }
1580 1.1 cgd }
1581 1.15 christos
1582 1.1 cgd if (v == (Var *)NIL) {
1583 1.1 cgd if ((((tstr-str) == 3) ||
1584 1.1 cgd ((((tstr-str) == 4) && (str[3] == 'F' ||
1585 1.1 cgd str[3] == 'D')))) &&
1586 1.1 cgd ((ctxt == VAR_CMD) || (ctxt == VAR_GLOBAL)))
1587 1.1 cgd {
1588 1.1 cgd /*
1589 1.1 cgd * If substituting a local variable in a non-local context,
1590 1.1 cgd * assume it's for dynamic source stuff. We have to handle
1591 1.1 cgd * this specially and return the longhand for the variable
1592 1.1 cgd * with the dollar sign escaped so it makes it back to the
1593 1.1 cgd * caller. Only four of the local variables are treated
1594 1.1 cgd * specially as they are the only four that will be set
1595 1.1 cgd * when dynamic sources are expanded.
1596 1.1 cgd */
1597 1.1 cgd switch (str[2]) {
1598 1.1 cgd case '@':
1599 1.1 cgd case '%':
1600 1.1 cgd case '*':
1601 1.1 cgd case '!':
1602 1.1 cgd dynamic = TRUE;
1603 1.1 cgd break;
1604 1.1 cgd }
1605 1.1 cgd } else if (((tstr-str) > 4) && (str[2] == '.') &&
1606 1.6 jtc isupper((unsigned char) str[3]) &&
1607 1.1 cgd ((ctxt == VAR_CMD) || (ctxt == VAR_GLOBAL)))
1608 1.1 cgd {
1609 1.1 cgd int len;
1610 1.15 christos
1611 1.1 cgd len = (tstr-str) - 3;
1612 1.1 cgd if ((strncmp(str+2, ".TARGET", len) == 0) ||
1613 1.1 cgd (strncmp(str+2, ".ARCHIVE", len) == 0) ||
1614 1.1 cgd (strncmp(str+2, ".PREFIX", len) == 0) ||
1615 1.1 cgd (strncmp(str+2, ".MEMBER", len) == 0))
1616 1.1 cgd {
1617 1.1 cgd dynamic = TRUE;
1618 1.1 cgd }
1619 1.1 cgd }
1620 1.15 christos
1621 1.1 cgd if (!haveModifier) {
1622 1.1 cgd /*
1623 1.1 cgd * No modifiers -- have specification length so we can return
1624 1.1 cgd * now.
1625 1.1 cgd */
1626 1.1 cgd *lengthPtr = tstr - start + 1;
1627 1.1 cgd *tstr = endc;
1628 1.1 cgd if (dynamic) {
1629 1.1 cgd str = emalloc(*lengthPtr + 1);
1630 1.1 cgd strncpy(str, start, *lengthPtr);
1631 1.1 cgd str[*lengthPtr] = '\0';
1632 1.1 cgd *freePtr = TRUE;
1633 1.1 cgd return(str);
1634 1.1 cgd } else {
1635 1.1 cgd return (err ? var_Error : varNoError);
1636 1.1 cgd }
1637 1.1 cgd } else {
1638 1.1 cgd /*
1639 1.1 cgd * Still need to get to the end of the variable specification,
1640 1.1 cgd * so kludge up a Var structure for the modifications
1641 1.1 cgd */
1642 1.1 cgd v = (Var *) emalloc(sizeof(Var));
1643 1.1 cgd v->name = &str[1];
1644 1.1 cgd v->val = Buf_Init(1);
1645 1.1 cgd v->flags = VAR_JUNK;
1646 1.1 cgd }
1647 1.1 cgd }
1648 1.1 cgd }
1649 1.1 cgd
1650 1.1 cgd if (v->flags & VAR_IN_USE) {
1651 1.1 cgd Fatal("Variable %s is recursive.", v->name);
1652 1.1 cgd /*NOTREACHED*/
1653 1.1 cgd } else {
1654 1.1 cgd v->flags |= VAR_IN_USE;
1655 1.1 cgd }
1656 1.1 cgd /*
1657 1.1 cgd * Before doing any modification, we have to make sure the value
1658 1.1 cgd * has been fully expanded. If it looks like recursion might be
1659 1.1 cgd * necessary (there's a dollar sign somewhere in the variable's value)
1660 1.1 cgd * we just call Var_Subst to do any other substitutions that are
1661 1.1 cgd * necessary. Note that the value returned by Var_Subst will have
1662 1.1 cgd * been dynamically-allocated, so it will need freeing when we
1663 1.1 cgd * return.
1664 1.1 cgd */
1665 1.1 cgd str = (char *)Buf_GetAll(v->val, (int *)NULL);
1666 1.5 cgd if (strchr (str, '$') != (char *)NULL) {
1667 1.5 cgd str = Var_Subst(NULL, str, ctxt, err);
1668 1.1 cgd *freePtr = TRUE;
1669 1.1 cgd }
1670 1.15 christos
1671 1.1 cgd v->flags &= ~VAR_IN_USE;
1672 1.15 christos
1673 1.1 cgd /*
1674 1.1 cgd * Now we need to apply any modifiers the user wants applied.
1675 1.1 cgd * These are:
1676 1.1 cgd * :M<pattern> words which match the given <pattern>.
1677 1.1 cgd * <pattern> is of the standard file
1678 1.1 cgd * wildcarding form.
1679 1.1 cgd * :S<d><pat1><d><pat2><d>[g]
1680 1.1 cgd * Substitute <pat2> for <pat1> in the value
1681 1.16 christos * :C<d><pat1><d><pat2><d>[g]
1682 1.16 christos * Substitute <pat2> for regex <pat1> in the value
1683 1.1 cgd * :H Substitute the head of each word
1684 1.1 cgd * :T Substitute the tail of each word
1685 1.1 cgd * :E Substitute the extension (minus '.') of
1686 1.1 cgd * each word
1687 1.1 cgd * :R Substitute the root of each word
1688 1.1 cgd * (pathname minus the suffix).
1689 1.1 cgd * :lhs=rhs Like :S, but the rhs goes to the end of
1690 1.1 cgd * the invocation.
1691 1.1 cgd */
1692 1.1 cgd if ((str != (char *)NULL) && haveModifier) {
1693 1.1 cgd /*
1694 1.1 cgd * Skip initial colon while putting it back.
1695 1.1 cgd */
1696 1.1 cgd *tstr++ = ':';
1697 1.1 cgd while (*tstr != endc) {
1698 1.1 cgd char *newStr; /* New value to return */
1699 1.1 cgd char termc; /* Character which terminated scan */
1700 1.15 christos
1701 1.1 cgd if (DEBUG(VAR)) {
1702 1.1 cgd printf("Applying :%c to \"%s\"\n", *tstr, str);
1703 1.1 cgd }
1704 1.1 cgd switch (*tstr) {
1705 1.1 cgd case 'N':
1706 1.1 cgd case 'M':
1707 1.1 cgd {
1708 1.1 cgd char *pattern;
1709 1.1 cgd char *cp2;
1710 1.1 cgd Boolean copy;
1711 1.1 cgd
1712 1.1 cgd copy = FALSE;
1713 1.1 cgd for (cp = tstr + 1;
1714 1.1 cgd *cp != '\0' && *cp != ':' && *cp != endc;
1715 1.1 cgd cp++)
1716 1.1 cgd {
1717 1.1 cgd if (*cp == '\\' && (cp[1] == ':' || cp[1] == endc)){
1718 1.1 cgd copy = TRUE;
1719 1.1 cgd cp++;
1720 1.1 cgd }
1721 1.1 cgd }
1722 1.1 cgd termc = *cp;
1723 1.1 cgd *cp = '\0';
1724 1.1 cgd if (copy) {
1725 1.1 cgd /*
1726 1.1 cgd * Need to compress the \:'s out of the pattern, so
1727 1.1 cgd * allocate enough room to hold the uncompressed
1728 1.1 cgd * pattern (note that cp started at tstr+1, so
1729 1.1 cgd * cp - tstr takes the null byte into account) and
1730 1.1 cgd * compress the pattern into the space.
1731 1.1 cgd */
1732 1.1 cgd pattern = emalloc(cp - tstr);
1733 1.1 cgd for (cp2 = pattern, cp = tstr + 1;
1734 1.1 cgd *cp != '\0';
1735 1.1 cgd cp++, cp2++)
1736 1.1 cgd {
1737 1.1 cgd if ((*cp == '\\') &&
1738 1.1 cgd (cp[1] == ':' || cp[1] == endc)) {
1739 1.1 cgd cp++;
1740 1.1 cgd }
1741 1.1 cgd *cp2 = *cp;
1742 1.1 cgd }
1743 1.1 cgd *cp2 = '\0';
1744 1.1 cgd } else {
1745 1.1 cgd pattern = &tstr[1];
1746 1.1 cgd }
1747 1.1 cgd if (*tstr == 'M' || *tstr == 'm') {
1748 1.1 cgd newStr = VarModify(str, VarMatch, (ClientData)pattern);
1749 1.1 cgd } else {
1750 1.1 cgd newStr = VarModify(str, VarNoMatch,
1751 1.1 cgd (ClientData)pattern);
1752 1.1 cgd }
1753 1.1 cgd if (copy) {
1754 1.1 cgd free(pattern);
1755 1.1 cgd }
1756 1.1 cgd break;
1757 1.1 cgd }
1758 1.1 cgd case 'S':
1759 1.1 cgd {
1760 1.1 cgd VarPattern pattern;
1761 1.1 cgd
1762 1.1 cgd pattern.flags = 0;
1763 1.1 cgd delim = tstr[1];
1764 1.1 cgd tstr += 2;
1765 1.16 christos
1766 1.1 cgd /*
1767 1.1 cgd * If pattern begins with '^', it is anchored to the
1768 1.1 cgd * start of the word -- skip over it and flag pattern.
1769 1.1 cgd */
1770 1.1 cgd if (*tstr == '^') {
1771 1.1 cgd pattern.flags |= VAR_MATCH_START;
1772 1.1 cgd tstr += 1;
1773 1.1 cgd }
1774 1.1 cgd
1775 1.16 christos cp = tstr;
1776 1.16 christos if ((pattern.lhs = VarGetPattern(ctxt, err, &cp, delim,
1777 1.16 christos &pattern.flags, &pattern.leftLen, NULL)) == NULL)
1778 1.16 christos goto cleanup;
1779 1.16 christos
1780 1.16 christos if ((pattern.rhs = VarGetPattern(ctxt, err, &cp, delim,
1781 1.16 christos NULL, &pattern.rightLen, &pattern)) == NULL)
1782 1.16 christos goto cleanup;
1783 1.15 christos
1784 1.1 cgd /*
1785 1.16 christos * Check for global substitution. If 'g' after the final
1786 1.16 christos * delimiter, substitution is global and is marked that
1787 1.16 christos * way.
1788 1.1 cgd */
1789 1.16 christos for (;; cp++) {
1790 1.16 christos switch (*cp) {
1791 1.16 christos case 'g':
1792 1.16 christos pattern.flags |= VAR_SUB_GLOBAL;
1793 1.16 christos continue;
1794 1.16 christos case '1':
1795 1.16 christos pattern.flags |= VAR_SUB_ONE;
1796 1.16 christos continue;
1797 1.1 cgd }
1798 1.16 christos break;
1799 1.1 cgd }
1800 1.1 cgd
1801 1.16 christos termc = *cp;
1802 1.16 christos newStr = VarModify(str, VarSubstitute,
1803 1.16 christos (ClientData)&pattern);
1804 1.15 christos
1805 1.1 cgd /*
1806 1.16 christos * Free the two strings.
1807 1.1 cgd */
1808 1.16 christos free(pattern.lhs);
1809 1.16 christos free(pattern.rhs);
1810 1.16 christos break;
1811 1.16 christos }
1812 1.17 christos #ifndef MAKE_BOOTSTRAP
1813 1.16 christos case 'C':
1814 1.16 christos {
1815 1.16 christos VarREPattern pattern;
1816 1.16 christos char *re;
1817 1.16 christos int error;
1818 1.1 cgd
1819 1.16 christos pattern.flags = 0;
1820 1.16 christos delim = tstr[1];
1821 1.16 christos tstr += 2;
1822 1.1 cgd
1823 1.16 christos cp = tstr;
1824 1.15 christos
1825 1.16 christos if ((re = VarGetPattern(ctxt, err, &cp, delim, NULL,
1826 1.16 christos NULL, NULL)) == NULL)
1827 1.16 christos goto cleanup;
1828 1.16 christos
1829 1.16 christos if ((pattern.replace = VarGetPattern(ctxt, err, &cp,
1830 1.16 christos delim, NULL, NULL, NULL)) == NULL){
1831 1.16 christos free(re);
1832 1.16 christos goto cleanup;
1833 1.1 cgd }
1834 1.1 cgd
1835 1.16 christos for (;; cp++) {
1836 1.16 christos switch (*cp) {
1837 1.16 christos case 'g':
1838 1.16 christos pattern.flags |= VAR_SUB_GLOBAL;
1839 1.16 christos continue;
1840 1.16 christos case '1':
1841 1.16 christos pattern.flags |= VAR_SUB_ONE;
1842 1.16 christos continue;
1843 1.1 cgd }
1844 1.16 christos break;
1845 1.1 cgd }
1846 1.1 cgd
1847 1.16 christos termc = *cp;
1848 1.1 cgd
1849 1.16 christos error = regcomp(&pattern.re, re, REG_EXTENDED);
1850 1.16 christos free(re);
1851 1.18 christos if (error) {
1852 1.18 christos *lengthPtr = cp - start + 1;
1853 1.16 christos VarREError(error, &pattern.re, "RE substitution error");
1854 1.16 christos free(pattern.replace);
1855 1.16 christos return (var_Error);
1856 1.1 cgd }
1857 1.1 cgd
1858 1.16 christos pattern.nsub = pattern.re.re_nsub + 1;
1859 1.16 christos if (pattern.nsub < 1)
1860 1.16 christos pattern.nsub = 1;
1861 1.16 christos if (pattern.nsub > 10)
1862 1.16 christos pattern.nsub = 10;
1863 1.16 christos pattern.matches = emalloc(pattern.nsub *
1864 1.16 christos sizeof(regmatch_t));
1865 1.16 christos newStr = VarModify(str, VarRESubstitute,
1866 1.16 christos (ClientData) &pattern);
1867 1.16 christos regfree(&pattern.re);
1868 1.16 christos free(pattern.replace);
1869 1.16 christos free(pattern.matches);
1870 1.1 cgd break;
1871 1.1 cgd }
1872 1.17 christos #endif
1873 1.16 christos case 'Q':
1874 1.16 christos if (tstr[1] == endc || tstr[1] == ':') {
1875 1.16 christos newStr = VarQuote (str);
1876 1.16 christos cp = tstr + 1;
1877 1.16 christos termc = *cp;
1878 1.16 christos break;
1879 1.16 christos }
1880 1.16 christos /*FALLTHRU*/
1881 1.1 cgd case 'T':
1882 1.1 cgd if (tstr[1] == endc || tstr[1] == ':') {
1883 1.1 cgd newStr = VarModify (str, VarTail, (ClientData)0);
1884 1.1 cgd cp = tstr + 1;
1885 1.1 cgd termc = *cp;
1886 1.1 cgd break;
1887 1.1 cgd }
1888 1.1 cgd /*FALLTHRU*/
1889 1.1 cgd case 'H':
1890 1.1 cgd if (tstr[1] == endc || tstr[1] == ':') {
1891 1.1 cgd newStr = VarModify (str, VarHead, (ClientData)0);
1892 1.1 cgd cp = tstr + 1;
1893 1.1 cgd termc = *cp;
1894 1.1 cgd break;
1895 1.1 cgd }
1896 1.1 cgd /*FALLTHRU*/
1897 1.1 cgd case 'E':
1898 1.1 cgd if (tstr[1] == endc || tstr[1] == ':') {
1899 1.1 cgd newStr = VarModify (str, VarSuffix, (ClientData)0);
1900 1.1 cgd cp = tstr + 1;
1901 1.1 cgd termc = *cp;
1902 1.1 cgd break;
1903 1.1 cgd }
1904 1.1 cgd /*FALLTHRU*/
1905 1.1 cgd case 'R':
1906 1.1 cgd if (tstr[1] == endc || tstr[1] == ':') {
1907 1.1 cgd newStr = VarModify (str, VarRoot, (ClientData)0);
1908 1.1 cgd cp = tstr + 1;
1909 1.1 cgd termc = *cp;
1910 1.1 cgd break;
1911 1.1 cgd }
1912 1.1 cgd /*FALLTHRU*/
1913 1.13 christos #ifdef SUNSHCMD
1914 1.13 christos case 's':
1915 1.13 christos if (tstr[1] == 'h' && (tstr[2] == endc || tstr[2] == ':')) {
1916 1.13 christos char *err;
1917 1.13 christos newStr = Cmd_Exec (str, &err);
1918 1.13 christos if (err)
1919 1.13 christos Error (err, str);
1920 1.13 christos cp = tstr + 2;
1921 1.13 christos termc = *cp;
1922 1.13 christos break;
1923 1.13 christos }
1924 1.13 christos /*FALLTHRU*/
1925 1.13 christos #endif
1926 1.13 christos default:
1927 1.13 christos {
1928 1.13 christos #ifdef SYSVVARSUB
1929 1.1 cgd /*
1930 1.1 cgd * This can either be a bogus modifier or a System-V
1931 1.1 cgd * substitution command.
1932 1.1 cgd */
1933 1.1 cgd VarPattern pattern;
1934 1.1 cgd Boolean eqFound;
1935 1.15 christos
1936 1.1 cgd pattern.flags = 0;
1937 1.1 cgd eqFound = FALSE;
1938 1.1 cgd /*
1939 1.1 cgd * First we make a pass through the string trying
1940 1.1 cgd * to verify it is a SYSV-make-style translation:
1941 1.1 cgd * it must be: <string1>=<string2>)
1942 1.1 cgd */
1943 1.9 christos cp = tstr;
1944 1.9 christos cnt = 1;
1945 1.9 christos while (*cp != '\0' && cnt) {
1946 1.1 cgd if (*cp == '=') {
1947 1.1 cgd eqFound = TRUE;
1948 1.1 cgd /* continue looking for endc */
1949 1.1 cgd }
1950 1.9 christos else if (*cp == endc)
1951 1.9 christos cnt--;
1952 1.9 christos else if (*cp == startc)
1953 1.9 christos cnt++;
1954 1.9 christos if (cnt)
1955 1.9 christos cp++;
1956 1.1 cgd }
1957 1.1 cgd if (*cp == endc && eqFound) {
1958 1.15 christos
1959 1.1 cgd /*
1960 1.1 cgd * Now we break this sucker into the lhs and
1961 1.1 cgd * rhs. We must null terminate them of course.
1962 1.1 cgd */
1963 1.5 cgd for (cp = tstr; *cp != '='; cp++)
1964 1.5 cgd continue;
1965 1.1 cgd pattern.lhs = tstr;
1966 1.1 cgd pattern.leftLen = cp - tstr;
1967 1.1 cgd *cp++ = '\0';
1968 1.15 christos
1969 1.1 cgd pattern.rhs = cp;
1970 1.9 christos cnt = 1;
1971 1.9 christos while (cnt) {
1972 1.9 christos if (*cp == endc)
1973 1.9 christos cnt--;
1974 1.9 christos else if (*cp == startc)
1975 1.9 christos cnt++;
1976 1.9 christos if (cnt)
1977 1.9 christos cp++;
1978 1.1 cgd }
1979 1.1 cgd pattern.rightLen = cp - pattern.rhs;
1980 1.1 cgd *cp = '\0';
1981 1.15 christos
1982 1.1 cgd /*
1983 1.1 cgd * SYSV modifications happen through the whole
1984 1.1 cgd * string. Note the pattern is anchored at the end.
1985 1.1 cgd */
1986 1.5 cgd newStr = VarModify(str, VarSYSVMatch,
1987 1.1 cgd (ClientData)&pattern);
1988 1.1 cgd
1989 1.1 cgd /*
1990 1.1 cgd * Restore the nulled characters
1991 1.1 cgd */
1992 1.1 cgd pattern.lhs[pattern.leftLen] = '=';
1993 1.1 cgd pattern.rhs[pattern.rightLen] = endc;
1994 1.1 cgd termc = endc;
1995 1.13 christos } else
1996 1.13 christos #endif
1997 1.13 christos {
1998 1.1 cgd Error ("Unknown modifier '%c'\n", *tstr);
1999 1.1 cgd for (cp = tstr+1;
2000 1.1 cgd *cp != ':' && *cp != endc && *cp != '\0';
2001 1.15 christos cp++)
2002 1.5 cgd continue;
2003 1.1 cgd termc = *cp;
2004 1.1 cgd newStr = var_Error;
2005 1.1 cgd }
2006 1.1 cgd }
2007 1.1 cgd }
2008 1.1 cgd if (DEBUG(VAR)) {
2009 1.1 cgd printf("Result is \"%s\"\n", newStr);
2010 1.1 cgd }
2011 1.15 christos
2012 1.1 cgd if (*freePtr) {
2013 1.1 cgd free (str);
2014 1.1 cgd }
2015 1.1 cgd str = newStr;
2016 1.1 cgd if (str != var_Error) {
2017 1.1 cgd *freePtr = TRUE;
2018 1.1 cgd } else {
2019 1.1 cgd *freePtr = FALSE;
2020 1.1 cgd }
2021 1.1 cgd if (termc == '\0') {
2022 1.1 cgd Error("Unclosed variable specification for %s", v->name);
2023 1.1 cgd } else if (termc == ':') {
2024 1.1 cgd *cp++ = termc;
2025 1.1 cgd } else {
2026 1.1 cgd *cp = termc;
2027 1.1 cgd }
2028 1.1 cgd tstr = cp;
2029 1.1 cgd }
2030 1.1 cgd *lengthPtr = tstr - start + 1;
2031 1.1 cgd } else {
2032 1.1 cgd *lengthPtr = tstr - start + 1;
2033 1.1 cgd *tstr = endc;
2034 1.1 cgd }
2035 1.15 christos
2036 1.1 cgd if (v->flags & VAR_FROM_ENV) {
2037 1.1 cgd Boolean destroy = FALSE;
2038 1.15 christos
2039 1.1 cgd if (str != (char *)Buf_GetAll(v->val, (int *)NULL)) {
2040 1.1 cgd destroy = TRUE;
2041 1.1 cgd } else {
2042 1.1 cgd /*
2043 1.1 cgd * Returning the value unmodified, so tell the caller to free
2044 1.1 cgd * the thing.
2045 1.1 cgd */
2046 1.1 cgd *freePtr = TRUE;
2047 1.1 cgd }
2048 1.1 cgd Buf_Destroy(v->val, destroy);
2049 1.1 cgd free((Address)v);
2050 1.1 cgd } else if (v->flags & VAR_JUNK) {
2051 1.1 cgd /*
2052 1.1 cgd * Perform any free'ing needed and set *freePtr to FALSE so the caller
2053 1.1 cgd * doesn't try to free a static pointer.
2054 1.1 cgd */
2055 1.1 cgd if (*freePtr) {
2056 1.1 cgd free(str);
2057 1.1 cgd }
2058 1.1 cgd *freePtr = FALSE;
2059 1.6 jtc Buf_Destroy(v->val, TRUE);
2060 1.1 cgd free((Address)v);
2061 1.1 cgd if (dynamic) {
2062 1.1 cgd str = emalloc(*lengthPtr + 1);
2063 1.1 cgd strncpy(str, start, *lengthPtr);
2064 1.1 cgd str[*lengthPtr] = '\0';
2065 1.1 cgd *freePtr = TRUE;
2066 1.1 cgd } else {
2067 1.1 cgd str = var_Error;
2068 1.1 cgd }
2069 1.1 cgd }
2070 1.1 cgd return (str);
2071 1.16 christos
2072 1.16 christos cleanup:
2073 1.16 christos *lengthPtr = cp - start + 1;
2074 1.16 christos if (*freePtr)
2075 1.16 christos free(str);
2076 1.16 christos Error("Unclosed substitution for %s (%c missing)",
2077 1.16 christos v->name, delim);
2078 1.16 christos return (var_Error);
2079 1.1 cgd }
2080 1.1 cgd
2081 1.1 cgd /*-
2082 1.1 cgd *-----------------------------------------------------------------------
2083 1.1 cgd * Var_Subst --
2084 1.1 cgd * Substitute for all variables in the given string in the given context
2085 1.1 cgd * If undefErr is TRUE, Parse_Error will be called when an undefined
2086 1.1 cgd * variable is encountered.
2087 1.1 cgd *
2088 1.1 cgd * Results:
2089 1.1 cgd * The resulting string.
2090 1.1 cgd *
2091 1.1 cgd * Side Effects:
2092 1.1 cgd * None. The old string must be freed by the caller
2093 1.1 cgd *-----------------------------------------------------------------------
2094 1.1 cgd */
2095 1.1 cgd char *
2096 1.5 cgd Var_Subst (var, str, ctxt, undefErr)
2097 1.5 cgd char *var; /* Named variable || NULL for all */
2098 1.5 cgd char *str; /* the string in which to substitute */
2099 1.1 cgd GNode *ctxt; /* the context wherein to find variables */
2100 1.1 cgd Boolean undefErr; /* TRUE if undefineds are an error */
2101 1.1 cgd {
2102 1.1 cgd Buffer buf; /* Buffer for forming things */
2103 1.1 cgd char *val; /* Value to substitute for a variable */
2104 1.1 cgd int length; /* Length of the variable invocation */
2105 1.1 cgd Boolean doFree; /* Set true if val should be freed */
2106 1.1 cgd static Boolean errorReported; /* Set true if an error has already
2107 1.1 cgd * been reported to prevent a plethora
2108 1.1 cgd * of messages when recursing */
2109 1.1 cgd
2110 1.5 cgd buf = Buf_Init (MAKE_BSIZE);
2111 1.1 cgd errorReported = FALSE;
2112 1.1 cgd
2113 1.1 cgd while (*str) {
2114 1.5 cgd if (var == NULL && (*str == '$') && (str[1] == '$')) {
2115 1.1 cgd /*
2116 1.1 cgd * A dollar sign may be escaped either with another dollar sign.
2117 1.1 cgd * In such a case, we skip over the escape character and store the
2118 1.1 cgd * dollar sign into the buffer directly.
2119 1.1 cgd */
2120 1.1 cgd str++;
2121 1.1 cgd Buf_AddByte(buf, (Byte)*str);
2122 1.1 cgd str++;
2123 1.1 cgd } else if (*str != '$') {
2124 1.1 cgd /*
2125 1.1 cgd * Skip as many characters as possible -- either to the end of
2126 1.1 cgd * the string or to the next dollar sign (variable invocation).
2127 1.1 cgd */
2128 1.1 cgd char *cp;
2129 1.1 cgd
2130 1.5 cgd for (cp = str++; *str != '$' && *str != '\0'; str++)
2131 1.5 cgd continue;
2132 1.1 cgd Buf_AddBytes(buf, str - cp, (Byte *)cp);
2133 1.1 cgd } else {
2134 1.5 cgd if (var != NULL) {
2135 1.5 cgd int expand;
2136 1.5 cgd for (;;) {
2137 1.5 cgd if (str[1] != '(' && str[1] != '{') {
2138 1.5 cgd if (str[1] != *var) {
2139 1.5 cgd Buf_AddBytes(buf, 2, (Byte *) str);
2140 1.5 cgd str += 2;
2141 1.5 cgd expand = FALSE;
2142 1.5 cgd }
2143 1.5 cgd else
2144 1.5 cgd expand = TRUE;
2145 1.5 cgd break;
2146 1.5 cgd }
2147 1.5 cgd else {
2148 1.5 cgd char *p;
2149 1.5 cgd
2150 1.5 cgd /*
2151 1.5 cgd * Scan up to the end of the variable name.
2152 1.5 cgd */
2153 1.15 christos for (p = &str[2]; *p &&
2154 1.5 cgd *p != ':' && *p != ')' && *p != '}'; p++)
2155 1.15 christos if (*p == '$')
2156 1.5 cgd break;
2157 1.5 cgd /*
2158 1.5 cgd * A variable inside the variable. We cannot expand
2159 1.5 cgd * the external variable yet, so we try again with
2160 1.5 cgd * the nested one
2161 1.5 cgd */
2162 1.5 cgd if (*p == '$') {
2163 1.5 cgd Buf_AddBytes(buf, p - str, (Byte *) str);
2164 1.5 cgd str = p;
2165 1.5 cgd continue;
2166 1.5 cgd }
2167 1.15 christos
2168 1.15 christos if (strncmp(var, str + 2, p - str - 2) != 0 ||
2169 1.5 cgd var[p - str - 2] != '\0') {
2170 1.5 cgd /*
2171 1.5 cgd * Not the variable we want to expand, scan
2172 1.5 cgd * until the next variable
2173 1.5 cgd */
2174 1.15 christos for (;*p != '$' && *p != '\0'; p++)
2175 1.5 cgd continue;
2176 1.5 cgd Buf_AddBytes(buf, p - str, (Byte *) str);
2177 1.5 cgd str = p;
2178 1.5 cgd expand = FALSE;
2179 1.5 cgd }
2180 1.5 cgd else
2181 1.5 cgd expand = TRUE;
2182 1.5 cgd break;
2183 1.5 cgd }
2184 1.5 cgd }
2185 1.5 cgd if (!expand)
2186 1.5 cgd continue;
2187 1.5 cgd }
2188 1.15 christos
2189 1.1 cgd val = Var_Parse (str, ctxt, undefErr, &length, &doFree);
2190 1.1 cgd
2191 1.1 cgd /*
2192 1.1 cgd * When we come down here, val should either point to the
2193 1.1 cgd * value of this variable, suitably modified, or be NULL.
2194 1.1 cgd * Length should be the total length of the potential
2195 1.1 cgd * variable invocation (from $ to end character...)
2196 1.1 cgd */
2197 1.1 cgd if (val == var_Error || val == varNoError) {
2198 1.1 cgd /*
2199 1.1 cgd * If performing old-time variable substitution, skip over
2200 1.1 cgd * the variable and continue with the substitution. Otherwise,
2201 1.1 cgd * store the dollar sign and advance str so we continue with
2202 1.1 cgd * the string...
2203 1.1 cgd */
2204 1.1 cgd if (oldVars) {
2205 1.1 cgd str += length;
2206 1.1 cgd } else if (undefErr) {
2207 1.1 cgd /*
2208 1.1 cgd * If variable is undefined, complain and skip the
2209 1.1 cgd * variable. The complaint will stop us from doing anything
2210 1.1 cgd * when the file is parsed.
2211 1.1 cgd */
2212 1.1 cgd if (!errorReported) {
2213 1.1 cgd Parse_Error (PARSE_FATAL,
2214 1.1 cgd "Undefined variable \"%.*s\"",length,str);
2215 1.1 cgd }
2216 1.1 cgd str += length;
2217 1.1 cgd errorReported = TRUE;
2218 1.1 cgd } else {
2219 1.1 cgd Buf_AddByte (buf, (Byte)*str);
2220 1.1 cgd str += 1;
2221 1.1 cgd }
2222 1.1 cgd } else {
2223 1.1 cgd /*
2224 1.1 cgd * We've now got a variable structure to store in. But first,
2225 1.1 cgd * advance the string pointer.
2226 1.1 cgd */
2227 1.1 cgd str += length;
2228 1.15 christos
2229 1.1 cgd /*
2230 1.1 cgd * Copy all the characters from the variable value straight
2231 1.1 cgd * into the new string.
2232 1.1 cgd */
2233 1.1 cgd Buf_AddBytes (buf, strlen (val), (Byte *)val);
2234 1.1 cgd if (doFree) {
2235 1.1 cgd free ((Address)val);
2236 1.1 cgd }
2237 1.1 cgd }
2238 1.1 cgd }
2239 1.1 cgd }
2240 1.15 christos
2241 1.1 cgd Buf_AddByte (buf, '\0');
2242 1.1 cgd str = (char *)Buf_GetAll (buf, (int *)NULL);
2243 1.1 cgd Buf_Destroy (buf, FALSE);
2244 1.1 cgd return (str);
2245 1.1 cgd }
2246 1.1 cgd
2247 1.1 cgd /*-
2248 1.1 cgd *-----------------------------------------------------------------------
2249 1.1 cgd * Var_GetTail --
2250 1.1 cgd * Return the tail from each of a list of words. Used to set the
2251 1.1 cgd * System V local variables.
2252 1.1 cgd *
2253 1.1 cgd * Results:
2254 1.1 cgd * The resulting string.
2255 1.1 cgd *
2256 1.1 cgd * Side Effects:
2257 1.1 cgd * None.
2258 1.1 cgd *
2259 1.1 cgd *-----------------------------------------------------------------------
2260 1.1 cgd */
2261 1.1 cgd char *
2262 1.1 cgd Var_GetTail(file)
2263 1.1 cgd char *file; /* Filename to modify */
2264 1.1 cgd {
2265 1.1 cgd return(VarModify(file, VarTail, (ClientData)0));
2266 1.1 cgd }
2267 1.1 cgd
2268 1.1 cgd /*-
2269 1.1 cgd *-----------------------------------------------------------------------
2270 1.1 cgd * Var_GetHead --
2271 1.1 cgd * Find the leading components of a (list of) filename(s).
2272 1.1 cgd * XXX: VarHead does not replace foo by ., as (sun) System V make
2273 1.1 cgd * does.
2274 1.1 cgd *
2275 1.1 cgd * Results:
2276 1.1 cgd * The leading components.
2277 1.1 cgd *
2278 1.1 cgd * Side Effects:
2279 1.1 cgd * None.
2280 1.1 cgd *
2281 1.1 cgd *-----------------------------------------------------------------------
2282 1.1 cgd */
2283 1.1 cgd char *
2284 1.1 cgd Var_GetHead(file)
2285 1.1 cgd char *file; /* Filename to manipulate */
2286 1.1 cgd {
2287 1.1 cgd return(VarModify(file, VarHead, (ClientData)0));
2288 1.1 cgd }
2289 1.1 cgd
2290 1.1 cgd /*-
2291 1.1 cgd *-----------------------------------------------------------------------
2292 1.1 cgd * Var_Init --
2293 1.1 cgd * Initialize the module
2294 1.1 cgd *
2295 1.1 cgd * Results:
2296 1.1 cgd * None
2297 1.1 cgd *
2298 1.1 cgd * Side Effects:
2299 1.15 christos * The VAR_CMD and VAR_GLOBAL contexts are created
2300 1.1 cgd *-----------------------------------------------------------------------
2301 1.1 cgd */
2302 1.1 cgd void
2303 1.1 cgd Var_Init ()
2304 1.1 cgd {
2305 1.1 cgd VAR_GLOBAL = Targ_NewGN ("Global");
2306 1.1 cgd VAR_CMD = Targ_NewGN ("Command");
2307 1.6 jtc allVars = Lst_Init(FALSE);
2308 1.6 jtc
2309 1.6 jtc }
2310 1.6 jtc
2311 1.1 cgd
2312 1.6 jtc void
2313 1.6 jtc Var_End ()
2314 1.6 jtc {
2315 1.6 jtc Lst_Destroy(allVars, VarDelete);
2316 1.1 cgd }
2317 1.15 christos
2318 1.1 cgd
2319 1.1 cgd /****************** PRINT DEBUGGING INFO *****************/
2320 1.5 cgd static int
2321 1.6 jtc VarPrintVar (vp, dummy)
2322 1.6 jtc ClientData vp;
2323 1.6 jtc ClientData dummy;
2324 1.1 cgd {
2325 1.6 jtc Var *v = (Var *) vp;
2326 1.5 cgd printf ("%-16s = %s\n", v->name, (char *) Buf_GetAll(v->val, (int *)NULL));
2327 1.6 jtc return (dummy ? 0 : 0);
2328 1.1 cgd }
2329 1.1 cgd
2330 1.1 cgd /*-
2331 1.1 cgd *-----------------------------------------------------------------------
2332 1.1 cgd * Var_Dump --
2333 1.1 cgd * print all variables in a context
2334 1.1 cgd *-----------------------------------------------------------------------
2335 1.1 cgd */
2336 1.5 cgd void
2337 1.1 cgd Var_Dump (ctxt)
2338 1.1 cgd GNode *ctxt;
2339 1.1 cgd {
2340 1.6 jtc Lst_ForEach (ctxt->context, VarPrintVar, (ClientData) 0);
2341 1.1 cgd }
2342