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