Context Navigation

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

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

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

Download in other formats: