var.c@ 51

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

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

source: kBuild/trunk/src/kmk/var.c@ 51

Download in other formats: