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