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