Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: trunk/src/kmk/var.c@ 14

Last change on this file since 14 was 9, checked in by bird, 23 years ago
Initial revision
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 64.3 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: