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