contrib/bmake/var.c

   1 /*      $NetBSD: var.c,v 1.221 2018/12/21 05:50:19 sjg Exp $    */
   2
   3 /*
   4  * Copyright (c) 1988, 1989, 1990, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This code is derived from software contributed to Berkeley by
   8  * Adam de Boor.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 /*
  36  * Copyright (c) 1989 by Berkeley Softworks
  37  * All rights reserved.
  38  *
  39  * This code is derived from software contributed to Berkeley by
  40  * Adam de Boor.
  41  *
  42  * Redistribution and use in source and binary forms, with or without
  43  * modification, are permitted provided that the following conditions
  44  * are met:
  45  * 1. Redistributions of source code must retain the above copyright
  46  *    notice, this list of conditions and the following disclaimer.
  47  * 2. Redistributions in binary form must reproduce the above copyright
  48  *    notice, this list of conditions and the following disclaimer in the
  49  *    documentation and/or other materials provided with the distribution.
  50  * 3. All advertising materials mentioning features or use of this software
  51  *    must display the following acknowledgement:
  52  *      This product includes software developed by the University of
  53  *      California, Berkeley and its contributors.
  54  * 4. Neither the name of the University nor the names of its contributors
  55  *    may be used to endorse or promote products derived from this software
  56  *    without specific prior written permission.
  57  *
  58  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  59  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  60  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  61  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  62  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  63  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  64  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  65  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  66  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  67  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  68  * SUCH DAMAGE.
  69  */
  70
  71 #ifndef MAKE_NATIVE
  72 static char rcsid[] = "$NetBSD: var.c,v 1.221 2018/12/21 05:50:19 sjg Exp $";
  73 #else
  74 #include <sys/cdefs.h>
  75 #ifndef lint
  76 #if 0
  77 static char sccsid[] = "@(#)var.c       8.3 (Berkeley) 3/19/94";
  78 #else
  79 __RCSID("$NetBSD: var.c,v 1.221 2018/12/21 05:50:19 sjg Exp $");
  80 #endif
  81 #endif /* not lint */
  82 #endif
  83
  84 /*-
  85  * var.c --
  86  *      Variable-handling functions
  87  *
  88  * Interface:
  89  *      Var_Set             Set the value of a variable in the given
  90  *                          context. The variable is created if it doesn't
  91  *                          yet exist. The value and variable name need not
  92  *                          be preserved.
  93  *
  94  *      Var_Append          Append more characters to an existing variable
  95  *                          in the given context. The variable needn't
  96  *                          exist already -- it will be created if it doesn't.
  97  *                          A space is placed between the old value and the
  98  *                          new one.
  99  *
 100  *      Var_Exists          See if a variable exists.
 101  *
 102  *      Var_Value           Return the value of a variable in a context or
 103  *                          NULL if the variable is undefined.
 104  *
 105  *      Var_Subst           Substitute named variable, or all variables if
 106  *                          NULL in a string using
 107  *                          the given context as the top-most one. If the
 108  *                          third argument is non-zero, Parse_Error is
 109  *                          called if any variables are undefined.
 110  *
 111  *      Var_Parse           Parse a variable expansion from a string and
 112  *                          return the result and the number of characters
 113  *                          consumed.
 114  *
 115  *      Var_Delete          Delete a variable in a context.
 116  *
 117  *      Var_Init            Initialize this module.
 118  *
 119  * Debugging:
 120  *      Var_Dump            Print out all variables defined in the given
 121  *                          context.
 122  *
 123  * XXX: There's a lot of duplication in these functions.
 124  */
 125
 126 #include    <sys/stat.h>
 127 #ifndef NO_REGEX
 128 #include    <sys/types.h>
 129 #include    <regex.h>
 130 #endif
 131 #include    <ctype.h>
 132 #include    <stdlib.h>
 133 #include    <limits.h>
 134 #include    <time.h>
 135
 136 #include    "make.h"
 137 #include    "buf.h"
 138 #include    "dir.h"
 139 #include    "job.h"
 140 #include    "metachar.h"
 141
 142 extern int makelevel;
 143 /*
 144  * This lets us tell if we have replaced the original environ
 145  * (which we cannot free).
 146  */
 147 char **savedEnv = NULL;
 148
 149 /*
 150  * This is a harmless return value for Var_Parse that can be used by Var_Subst
 151  * to determine if there was an error in parsing -- easier than returning
 152  * a flag, as things outside this module don't give a hoot.
 153  */
 154 char    var_Error[] = "";
 155
 156 /*
 157  * Similar to var_Error, but returned when the 'VARF_UNDEFERR' flag for
 158  * Var_Parse is not set. Why not just use a constant? Well, gcc likes
 159  * to condense identical string instances...
 160  */
 161 static char     varNoError[] = "";
 162
 163 /*
 164  * Traditionally we consume $$ during := like any other expansion.
 165  * Other make's do not.
 166  * This knob allows controlling the behavior.
 167  * FALSE for old behavior.
 168  * TRUE for new compatible.
 169  */
 170 #define SAVE_DOLLARS ".MAKE.SAVE_DOLLARS"
 171 static Boolean save_dollars = FALSE;
 172
 173 /*
 174  * Internally, variables are contained in four different contexts.
 175  *      1) the environment. They may not be changed. If an environment
 176  *          variable is appended-to, the result is placed in the global
 177  *          context.
 178  *      2) the global context. Variables set in the Makefile are located in
 179  *          the global context. It is the penultimate context searched when
 180  *          substituting.
 181  *      3) the command-line context. All variables set on the command line
 182  *         are placed in this context. They are UNALTERABLE once placed here.
 183  *      4) the local context. Each target has associated with it a context
 184  *         list. On this list are located the structures describing such
 185  *         local variables as $(@) and $(*)
 186  * The four contexts are searched in the reverse order from which they are
 187  * listed.
 188  */
 189 GNode          *VAR_INTERNAL; /* variables from make itself */
 190 GNode          *VAR_GLOBAL;   /* variables from the makefile */
 191 GNode          *VAR_CMD;      /* variables defined on the command-line */
 192
 193 #define FIND_CMD        0x1   /* look in VAR_CMD when searching */
 194 #define FIND_GLOBAL     0x2   /* look in VAR_GLOBAL as well */
 195 #define FIND_ENV        0x4   /* look in the environment also */
 196
 197 typedef struct Var {
 198     char          *name;        /* the variable's name */
 199     Buffer        val;          /* its value */
 200     int           flags;        /* miscellaneous status flags */
 201 #define VAR_IN_USE      1           /* Variable's value currently being used.
 202                                      * Used to avoid recursion */
 203 #define VAR_FROM_ENV    2           /* Variable comes from the environment */
 204 #define VAR_JUNK        4           /* Variable is a junk variable that
 205                                      * should be destroyed when done with
 206                                      * it. Used by Var_Parse for undefined,
 207                                      * modified variables */
 208 #define VAR_KEEP        8           /* Variable is VAR_JUNK, but we found
 209                                      * a use for it in some modifier and
 210                                      * the value is therefore valid */
 211 #define VAR_EXPORTED    16          /* Variable is exported */
 212 #define VAR_REEXPORT    32          /* Indicate if var needs re-export.
 213                                      * This would be true if it contains $'s
 214                                      */
 215 #define VAR_FROM_CMD    64          /* Variable came from command line */
 216 }  Var;
 217
 218 /*
 219  * Exporting vars is expensive so skip it if we can
 220  */
 221 #define VAR_EXPORTED_NONE       0
 222 #define VAR_EXPORTED_YES        1
 223 #define VAR_EXPORTED_ALL        2
 224 static int var_exportedVars = VAR_EXPORTED_NONE;
 225 /*
 226  * We pass this to Var_Export when doing the initial export
 227  * or after updating an exported var.
 228  */
 229 #define VAR_EXPORT_PARENT       1
 230 /*
 231  * We pass this to Var_Export1 to tell it to leave the value alone.
 232  */
 233 #define VAR_EXPORT_LITERAL      2
 234
 235 /* Var*Pattern flags */
 236 #define VAR_SUB_GLOBAL  0x01    /* Apply substitution globally */
 237 #define VAR_SUB_ONE     0x02    /* Apply substitution to one word */
 238 #define VAR_SUB_MATCHED 0x04    /* There was a match */
 239 #define VAR_MATCH_START 0x08    /* Match at start of word */
 240 #define VAR_MATCH_END   0x10    /* Match at end of word */
 241 #define VAR_NOSUBST     0x20    /* don't expand vars in VarGetPattern */
 242
 243 /* Var_Set flags */
 244 #define VAR_NO_EXPORT   0x01    /* do not export */
 245
 246 typedef struct {
 247     /*
 248      * The following fields are set by Var_Parse() when it
 249      * encounters modifiers that need to keep state for use by
 250      * subsequent modifiers within the same variable expansion.
 251      */
 252     Byte        varSpace;       /* Word separator in expansions */
 253     Boolean     oneBigWord;     /* TRUE if we will treat the variable as a
 254                                  * single big word, even if it contains
 255                                  * embedded spaces (as opposed to the
 256                                  * usual behaviour of treating it as
 257                                  * several space-separated words). */
 258 } Var_Parse_State;
 259
 260 /* struct passed as 'void *' to VarSubstitute() for ":S/lhs/rhs/",
 261  * to VarSYSVMatch() for ":lhs=rhs". */
 262 typedef struct {
 263     const char   *lhs;      /* String to match */
 264     int           leftLen; /* Length of string */
 265     const char   *rhs;      /* Replacement string (w/ &'s removed) */
 266     int           rightLen; /* Length of replacement */
 267     int           flags;
 268 } VarPattern;
 269
 270 /* struct passed as 'void *' to VarLoopExpand() for ":@tvar@str@" */
 271 typedef struct {
 272     GNode       *ctxt;          /* variable context */
 273     char        *tvar;          /* name of temp var */
 274     int         tvarLen;
 275     char        *str;           /* string to expand */
 276     int         strLen;
 277     int         errnum;         /* errnum for not defined */
 278 } VarLoop_t;
 279
 280 #ifndef NO_REGEX
 281 /* struct passed as 'void *' to VarRESubstitute() for ":C///" */
 282 typedef struct {
 283     regex_t        re;
 284     int            nsub;
 285     regmatch_t    *matches;
 286     char          *replace;
 287     int            flags;
 288 } VarREPattern;
 289 #endif
 290
 291 /* struct passed to VarSelectWords() for ":[start..end]" */
 292 typedef struct {
 293     int         start;          /* first word to select */
 294     int         end;            /* last word to select */
 295 } VarSelectWords_t;
 296
 297 static Var *VarFind(const char *, GNode *, int);
 298 static void VarAdd(const char *, const char *, GNode *);
 299 static Boolean VarHead(GNode *, Var_Parse_State *,
 300                         char *, Boolean, Buffer *, void *);
 301 static Boolean VarTail(GNode *, Var_Parse_State *,
 302                         char *, Boolean, Buffer *, void *);
 303 static Boolean VarSuffix(GNode *, Var_Parse_State *,
 304                         char *, Boolean, Buffer *, void *);
 305 static Boolean VarRoot(GNode *, Var_Parse_State *,
 306                         char *, Boolean, Buffer *, void *);
 307 static Boolean VarMatch(GNode *, Var_Parse_State *,
 308                         char *, Boolean, Buffer *, void *);
 309 #ifdef SYSVVARSUB
 310 static Boolean VarSYSVMatch(GNode *, Var_Parse_State *,
 311                         char *, Boolean, Buffer *, void *);
 312 #endif
 313 static Boolean VarNoMatch(GNode *, Var_Parse_State *,
 314                         char *, Boolean, Buffer *, void *);
 315 #ifndef NO_REGEX
 316 static void VarREError(int, regex_t *, const char *);
 317 static Boolean VarRESubstitute(GNode *, Var_Parse_State *,
 318                         char *, Boolean, Buffer *, void *);
 319 #endif
 320 static Boolean VarSubstitute(GNode *, Var_Parse_State *,
 321                         char *, Boolean, Buffer *, void *);
 322 static Boolean VarLoopExpand(GNode *, Var_Parse_State *,
 323                         char *, Boolean, Buffer *, void *);
 324 static char *VarGetPattern(GNode *, Var_Parse_State *,
 325                            int, const char **, int, int *, int *,
 326                            VarPattern *);
 327 static char *VarQuote(char *, Boolean);
 328 static char *VarHash(char *);
 329 static char *VarModify(GNode *, Var_Parse_State *,
 330     const char *,
 331     Boolean (*)(GNode *, Var_Parse_State *, char *, Boolean, Buffer *, void *),
 332     void *);
 333 static char *VarOrder(const char *, const char);
 334 static char *VarUniq(const char *);
 335 static int VarWordCompare(const void *, const void *);
 336 static void VarPrintVar(void *);
 337
 338 #define BROPEN  '{'
 339 #define BRCLOSE '}'
 340 #define PROPEN  '('
 341 #define PRCLOSE ')'
 342
 343 /*-
 344  *-----------------------------------------------------------------------
 345  * VarFind --
 346  *      Find the given variable in the given context and any other contexts
 347  *      indicated.
 348  *
 349  * Input:
 350  *      name            name to find
 351  *      ctxt            context in which to find it
 352  *      flags           FIND_GLOBAL set means to look in the
 353  *                      VAR_GLOBAL context as well. FIND_CMD set means
 354  *                      to look in the VAR_CMD context also. FIND_ENV
 355  *                      set means to look in the environment
 356  *
 357  * Results:
 358  *      A pointer to the structure describing the desired variable or
 359  *      NULL if the variable does not exist.
 360  *
 361  * Side Effects:
 362  *      None
 363  *-----------------------------------------------------------------------
 364  */
 365 static Var *
 366 VarFind(const char *name, GNode *ctxt, int flags)
 367 {
 368     Hash_Entry          *var;
 369     Var                 *v;
 370
 371         /*
 372          * If the variable name begins with a '.', it could very well be one of
 373          * the local ones.  We check the name against all the local variables
 374          * and substitute the short version in for 'name' if it matches one of
 375          * them.
 376          */
 377         if (*name == '.' && isupper((unsigned char) name[1]))
 378                 switch (name[1]) {
 379                 case 'A':
 380                         if (!strcmp(name, ".ALLSRC"))
 381                                 name = ALLSRC;
 382                         if (!strcmp(name, ".ARCHIVE"))
 383                                 name = ARCHIVE;
 384                         break;
 385                 case 'I':
 386                         if (!strcmp(name, ".IMPSRC"))
 387                                 name = IMPSRC;
 388                         break;
 389                 case 'M':
 390                         if (!strcmp(name, ".MEMBER"))
 391                                 name = MEMBER;
 392                         break;
 393                 case 'O':
 394                         if (!strcmp(name, ".OODATE"))
 395                                 name = OODATE;
 396                         break;
 397                 case 'P':
 398                         if (!strcmp(name, ".PREFIX"))
 399                                 name = PREFIX;
 400                         break;
 401                 case 'T':
 402                         if (!strcmp(name, ".TARGET"))
 403                                 name = TARGET;
 404                         break;
 405                 }
 406 #ifdef notyet
 407     /* for compatibility with gmake */
 408     if (name[0] == '^' && name[1] == '\0')
 409             name = ALLSRC;
 410 #endif
 411
 412     /*
 413      * First look for the variable in the given context. If it's not there,
 414      * look for it in VAR_CMD, VAR_GLOBAL and the environment, in that order,
 415      * depending on the FIND_* flags in 'flags'
 416      */
 417     var = Hash_FindEntry(&ctxt->context, name);
 418
 419     if ((var == NULL) && (flags & FIND_CMD) && (ctxt != VAR_CMD)) {
 420         var = Hash_FindEntry(&VAR_CMD->context, name);
 421     }
 422     if (!checkEnvFirst && (var == NULL) && (flags & FIND_GLOBAL) &&
 423         (ctxt != VAR_GLOBAL))
 424     {
 425         var = Hash_FindEntry(&VAR_GLOBAL->context, name);
 426         if ((var == NULL) && (ctxt != VAR_INTERNAL)) {
 427             /* VAR_INTERNAL is subordinate to VAR_GLOBAL */
 428             var = Hash_FindEntry(&VAR_INTERNAL->context, name);
 429         }
 430     }
 431     if ((var == NULL) && (flags & FIND_ENV)) {
 432         char *env;
 433
 434         if ((env = getenv(name)) != NULL) {
 435             int         len;
 436
 437             v = bmake_malloc(sizeof(Var));
 438             v->name = bmake_strdup(name);
 439
 440             len = strlen(env);
 441
 442             Buf_Init(&v->val, len + 1);
 443             Buf_AddBytes(&v->val, len, env);
 444
 445             v->flags = VAR_FROM_ENV;
 446             return (v);
 447         } else if (checkEnvFirst && (flags & FIND_GLOBAL) &&
 448                    (ctxt != VAR_GLOBAL))
 449         {
 450             var = Hash_FindEntry(&VAR_GLOBAL->context, name);
 451             if ((var == NULL) && (ctxt != VAR_INTERNAL)) {
 452                 var = Hash_FindEntry(&VAR_INTERNAL->context, name);
 453             }
 454             if (var == NULL) {
 455                 return NULL;
 456             } else {
 457                 return ((Var *)Hash_GetValue(var));
 458             }
 459         } else {
 460             return NULL;
 461         }
 462     } else if (var == NULL) {
 463         return NULL;
 464     } else {
 465         return ((Var *)Hash_GetValue(var));
 466     }
 467 }
 468
 469 /*-
 470  *-----------------------------------------------------------------------
 471  * VarFreeEnv  --
 472  *      If the variable is an environment variable, free it
 473  *
 474  * Input:
 475  *      v               the variable
 476  *      destroy         true if the value buffer should be destroyed.
 477  *
 478  * Results:
 479  *      1 if it is an environment variable 0 ow.
 480  *
 481  * Side Effects:
 482  *      The variable is free'ed if it is an environent variable.
 483  *-----------------------------------------------------------------------
 484  */
 485 static Boolean
 486 VarFreeEnv(Var *v, Boolean destroy)
 487 {
 488     if ((v->flags & VAR_FROM_ENV) == 0)
 489         return FALSE;
 490     free(v->name);
 491     Buf_Destroy(&v->val, destroy);
 492     free(v);
 493     return TRUE;
 494 }
 495
 496 /*-
 497  *-----------------------------------------------------------------------
 498  * VarAdd  --
 499  *      Add a new variable of name name and value val to the given context
 500  *
 501  * Input:
 502  *      name            name of variable to add
 503  *      val             value to set it to
 504  *      ctxt            context in which to set it
 505  *
 506  * Results:
 507  *      None
 508  *
 509  * Side Effects:
 510  *      The new variable is placed at the front of the given context
 511  *      The name and val arguments are duplicated so they may
 512  *      safely be freed.
 513  *-----------------------------------------------------------------------
 514  */
 515 static void
 516 VarAdd(const char *name, const char *val, GNode *ctxt)
 517 {
 518     Var           *v;
 519     int           len;
 520     Hash_Entry    *h;
 521
 522     v = bmake_malloc(sizeof(Var));
 523
 524     len = val ? strlen(val) : 0;
 525     Buf_Init(&v->val, len+1);
 526     Buf_AddBytes(&v->val, len, val);
 527
 528     v->flags = 0;
 529
 530     h = Hash_CreateEntry(&ctxt->context, name, NULL);
 531     Hash_SetValue(h, v);
 532     v->name = h->name;
 533     if (DEBUG(VAR) && (ctxt->flags & INTERNAL) == 0) {
 534         fprintf(debug_file, "%s:%s = %s\n", ctxt->name, name, val);
 535     }
 536 }
 537
 538 /*-
 539  *-----------------------------------------------------------------------
 540  * Var_Delete --
 541  *      Remove a variable from a context.
 542  *
 543  * Results:
 544  *      None.
 545  *
 546  * Side Effects:
 547  *      The Var structure is removed and freed.
 548  *
 549  *-----------------------------------------------------------------------
 550  */
 551 void
 552 Var_Delete(const char *name, GNode *ctxt)
 553 {
 554     Hash_Entry    *ln;
 555     char *cp;
 556
 557     if (strchr(name, '$')) {
 558         cp = Var_Subst(NULL, name, VAR_GLOBAL, VARF_WANTRES);
 559     } else {
 560         cp = (char *)name;
 561     }
 562     ln = Hash_FindEntry(&ctxt->context, cp);
 563     if (DEBUG(VAR)) {
 564         fprintf(debug_file, "%s:delete %s%s\n",
 565             ctxt->name, cp, ln ? "" : " (not found)");
 566     }
 567     if (cp != name) {
 568         free(cp);
 569     }
 570     if (ln != NULL) {
 571         Var       *v;
 572
 573         v = (Var *)Hash_GetValue(ln);
 574         if ((v->flags & VAR_EXPORTED)) {
 575             unsetenv(v->name);
 576         }
 577         if (strcmp(MAKE_EXPORTED, v->name) == 0) {
 578             var_exportedVars = VAR_EXPORTED_NONE;
 579         }
 580         if (v->name != ln->name)
 581                 free(v->name);
 582         Hash_DeleteEntry(&ctxt->context, ln);
 583         Buf_Destroy(&v->val, TRUE);
 584         free(v);
 585     }
 586 }
 587
 588
 589 /*
 590  * Export a var.
 591  * We ignore make internal variables (those which start with '.')
 592  * Also we jump through some hoops to avoid calling setenv
 593  * more than necessary since it can leak.
 594  * We only manipulate flags of vars if 'parent' is set.
 595  */
 596 static int
 597 Var_Export1(const char *name, int flags)
 598 {
 599     char tmp[BUFSIZ];
 600     Var *v;
 601     char *val = NULL;
 602     int n;
 603     int parent = (flags & VAR_EXPORT_PARENT);
 604
 605     if (*name == '.')
 606         return 0;                       /* skip internals */
 607     if (!name[1]) {
 608         /*
 609          * A single char.
 610          * If it is one of the vars that should only appear in
 611          * local context, skip it, else we can get Var_Subst
 612          * into a loop.
 613          */
 614         switch (name[0]) {
 615         case '@':
 616         case '%':
 617         case '*':
 618         case '!':
 619             return 0;
 620         }
 621     }
 622     v = VarFind(name, VAR_GLOBAL, 0);
 623     if (v == NULL) {
 624         return 0;
 625     }
 626     if (!parent &&
 627         (v->flags & (VAR_EXPORTED|VAR_REEXPORT)) == VAR_EXPORTED) {
 628         return 0;                       /* nothing to do */
 629     }
 630     val = Buf_GetAll(&v->val, NULL);
 631     if ((flags & VAR_EXPORT_LITERAL) == 0 && strchr(val, '$')) {
 632         if (parent) {
 633             /*
 634              * Flag this as something we need to re-export.
 635              * No point actually exporting it now though,
 636              * the child can do it at the last minute.
 637              */
 638             v->flags |= (VAR_EXPORTED|VAR_REEXPORT);
 639             return 1;
 640         }
 641         if (v->flags & VAR_IN_USE) {
 642             /*
 643              * We recursed while exporting in a child.
 644              * This isn't going to end well, just skip it.
 645              */
 646             return 0;
 647         }
 648         n = snprintf(tmp, sizeof(tmp), "${%s}", name);
 649         if (n < (int)sizeof(tmp)) {
 650             val = Var_Subst(NULL, tmp, VAR_GLOBAL, VARF_WANTRES);
 651             setenv(name, val, 1);
 652             free(val);
 653         }
 654     } else {
 655         if (parent) {
 656             v->flags &= ~VAR_REEXPORT;  /* once will do */
 657         }
 658         if (parent || !(v->flags & VAR_EXPORTED)) {
 659             setenv(name, val, 1);
 660         }
 661     }
 662     /*
 663      * This is so Var_Set knows to call Var_Export again...
 664      */
 665     if (parent) {
 666         v->flags |= VAR_EXPORTED;
 667     }
 668     return 1;
 669 }
 670
 671 /*
 672  * This gets called from our children.
 673  */
 674 void
 675 Var_ExportVars(void)
 676 {
 677     char tmp[BUFSIZ];
 678     Hash_Entry          *var;
 679     Hash_Search         state;
 680     Var *v;
 681     char *val;
 682     int n;
 683
 684     /*
 685      * Several make's support this sort of mechanism for tracking
 686      * recursion - but each uses a different name.
 687      * We allow the makefiles to update MAKELEVEL and ensure
 688      * children see a correctly incremented value.
 689      */
 690     snprintf(tmp, sizeof(tmp), "%d", makelevel + 1);
 691     setenv(MAKE_LEVEL_ENV, tmp, 1);
 692
 693     if (VAR_EXPORTED_NONE == var_exportedVars)
 694         return;
 695
 696     if (VAR_EXPORTED_ALL == var_exportedVars) {
 697         /*
 698          * Ouch! This is crazy...
 699          */
 700         for (var = Hash_EnumFirst(&VAR_GLOBAL->context, &state);
 701              var != NULL;
 702              var = Hash_EnumNext(&state)) {
 703             v = (Var *)Hash_GetValue(var);
 704             Var_Export1(v->name, 0);
 705         }
 706         return;
 707     }
 708     /*
 709      * We have a number of exported vars,
 710      */
 711     n = snprintf(tmp, sizeof(tmp), "${" MAKE_EXPORTED ":O:u}");
 712     if (n < (int)sizeof(tmp)) {
 713         char **av;
 714         char *as;
 715         int ac;
 716         int i;
 717
 718         val = Var_Subst(NULL, tmp, VAR_GLOBAL, VARF_WANTRES);
 719         if (*val) {
 720             av = brk_string(val, &ac, FALSE, &as);
 721             for (i = 0; i < ac; i++) {
 722                 Var_Export1(av[i], 0);
 723             }
 724             free(as);
 725             free(av);
 726         }
 727         free(val);
 728     }
 729 }
 730
 731 /*
 732  * This is called when .export is seen or
 733  * .MAKE.EXPORTED is modified.
 734  * It is also called when any exported var is modified.
 735  */
 736 void
 737 Var_Export(char *str, int isExport)
 738 {
 739     char *name;
 740     char *val;
 741     char **av;
 742     char *as;
 743     int flags;
 744     int ac;
 745     int i;
 746
 747     if (isExport && (!str || !str[0])) {
 748         var_exportedVars = VAR_EXPORTED_ALL; /* use with caution! */
 749         return;
 750     }
 751
 752     flags = 0;
 753     if (strncmp(str, "-env", 4) == 0) {
 754         str += 4;
 755     } else if (strncmp(str, "-literal", 8) == 0) {
 756         str += 8;
 757         flags |= VAR_EXPORT_LITERAL;
 758     } else {
 759         flags |= VAR_EXPORT_PARENT;
 760     }
 761     val = Var_Subst(NULL, str, VAR_GLOBAL, VARF_WANTRES);
 762     if (*val) {
 763         av = brk_string(val, &ac, FALSE, &as);
 764         for (i = 0; i < ac; i++) {
 765             name = av[i];
 766             if (!name[1]) {
 767                 /*
 768                  * A single char.
 769                  * If it is one of the vars that should only appear in
 770                  * local context, skip it, else we can get Var_Subst
 771                  * into a loop.
 772                  */
 773                 switch (name[0]) {
 774                 case '@':
 775                 case '%':
 776                 case '*':
 777                 case '!':
 778                     continue;
 779                 }
 780             }
 781             if (Var_Export1(name, flags)) {
 782                 if (VAR_EXPORTED_ALL != var_exportedVars)
 783                     var_exportedVars = VAR_EXPORTED_YES;
 784                 if (isExport && (flags & VAR_EXPORT_PARENT)) {
 785                     Var_Append(MAKE_EXPORTED, name, VAR_GLOBAL);
 786                 }
 787             }
 788         }
 789         free(as);
 790         free(av);
 791     }
 792     free(val);
 793 }
 794
 795
 796 /*
 797  * This is called when .unexport[-env] is seen.
 798  */
 799 extern char **environ;
 800
 801 void
 802 Var_UnExport(char *str)
 803 {
 804     char tmp[BUFSIZ];
 805     char *vlist;
 806     char *cp;
 807     Boolean unexport_env;
 808     int n;
 809
 810     if (!str || !str[0]) {
 811         return;                         /* assert? */
 812     }
 813
 814     vlist = NULL;
 815
 816     str += 8;
 817     unexport_env = (strncmp(str, "-env", 4) == 0);
 818     if (unexport_env) {
 819         char **newenv;
 820
 821         cp = getenv(MAKE_LEVEL_ENV);    /* we should preserve this */
 822         if (environ == savedEnv) {
 823             /* we have been here before! */
 824             newenv = bmake_realloc(environ, 2 * sizeof(char *));
 825         } else {
 826             if (savedEnv) {
 827                 free(savedEnv);
 828                 savedEnv = NULL;
 829             }
 830             newenv = bmake_malloc(2 * sizeof(char *));
 831         }
 832         if (!newenv)
 833             return;
 834         /* Note: we cannot safely free() the original environ. */
 835         environ = savedEnv = newenv;
 836         newenv[0] = NULL;
 837         newenv[1] = NULL;
 838         if (cp && *cp)
 839             setenv(MAKE_LEVEL_ENV, cp, 1);
 840     } else {
 841         for (; *str != '\n' && isspace((unsigned char) *str); str++)
 842             continue;
 843         if (str[0] && str[0] != '\n') {
 844             vlist = str;
 845         }
 846     }
 847
 848     if (!vlist) {
 849         /* Using .MAKE.EXPORTED */
 850         n = snprintf(tmp, sizeof(tmp), "${" MAKE_EXPORTED ":O:u}");
 851         if (n < (int)sizeof(tmp)) {
 852             vlist = Var_Subst(NULL, tmp, VAR_GLOBAL, VARF_WANTRES);
 853         }
 854     }
 855     if (vlist) {
 856         Var *v;
 857         char **av;
 858         char *as;
 859         int ac;
 860         int i;
 861
 862         av = brk_string(vlist, &ac, FALSE, &as);
 863         for (i = 0; i < ac; i++) {
 864             v = VarFind(av[i], VAR_GLOBAL, 0);
 865             if (!v)
 866                 continue;
 867             if (!unexport_env &&
 868                 (v->flags & (VAR_EXPORTED|VAR_REEXPORT)) == VAR_EXPORTED) {
 869                 unsetenv(v->name);
 870             }
 871             v->flags &= ~(VAR_EXPORTED|VAR_REEXPORT);
 872             /*
 873              * If we are unexporting a list,
 874              * remove each one from .MAKE.EXPORTED.
 875              * If we are removing them all,
 876              * just delete .MAKE.EXPORTED below.
 877              */
 878             if (vlist == str) {
 879                 n = snprintf(tmp, sizeof(tmp),
 880                              "${" MAKE_EXPORTED ":N%s}", v->name);
 881                 if (n < (int)sizeof(tmp)) {
 882                     cp = Var_Subst(NULL, tmp, VAR_GLOBAL, VARF_WANTRES);
 883                     Var_Set(MAKE_EXPORTED, cp, VAR_GLOBAL, 0);
 884                     free(cp);
 885                 }
 886             }
 887         }
 888         free(as);
 889         free(av);
 890         if (vlist != str) {
 891             Var_Delete(MAKE_EXPORTED, VAR_GLOBAL);
 892             free(vlist);
 893         }
 894     }
 895 }
 896
 897 /*-
 898  *-----------------------------------------------------------------------
 899  * Var_Set --
 900  *      Set the variable name to the value val in the given context.
 901  *
 902  * Input:
 903  *      name            name of variable to set
 904  *      val             value to give to the variable
 905  *      ctxt            context in which to set it
 906  *
 907  * Results:
 908  *      None.
 909  *
 910  * Side Effects:
 911  *      If the variable doesn't yet exist, a new record is created for it.
 912  *      Else the old value is freed and the new one stuck in its place
 913  *
 914  * Notes:
 915  *      The variable is searched for only in its context before being
 916  *      created in that context. I.e. if the context is VAR_GLOBAL,
 917  *      only VAR_GLOBAL->context is searched. Likewise if it is VAR_CMD, only
 918  *      VAR_CMD->context is searched. This is done to avoid the literally
 919  *      thousands of unnecessary strcmp's that used to be done to
 920  *      set, say, $(@) or $(<).
 921  *      If the context is VAR_GLOBAL though, we check if the variable
 922  *      was set in VAR_CMD from the command line and skip it if so.
 923  *-----------------------------------------------------------------------
 924  */
 925 void
 926 Var_Set(const char *name, const char *val, GNode *ctxt, int flags)
 927 {
 928     Var   *v;
 929     char *expanded_name = NULL;
 930
 931     /*
 932      * We only look for a variable in the given context since anything set
 933      * here will override anything in a lower context, so there's not much
 934      * point in searching them all just to save a bit of memory...
 935      */
 936     if (strchr(name, '$') != NULL) {
 937         expanded_name = Var_Subst(NULL, name, ctxt, VARF_WANTRES);
 938         if (expanded_name[0] == 0) {
 939             if (DEBUG(VAR)) {
 940                 fprintf(debug_file, "Var_Set(\"%s\", \"%s\", ...) "
 941                         "name expands to empty string - ignored\n",
 942                         name, val);
 943             }
 944             free(expanded_name);
 945             return;
 946         }
 947         name = expanded_name;
 948     }
 949     if (ctxt == VAR_GLOBAL) {
 950         v = VarFind(name, VAR_CMD, 0);
 951         if (v != NULL) {
 952             if ((v->flags & VAR_FROM_CMD)) {
 953                 if (DEBUG(VAR)) {
 954                     fprintf(debug_file, "%s:%s = %s ignored!\n", ctxt->name, name, val);
 955                 }
 956                 goto out;
 957             }
 958             VarFreeEnv(v, TRUE);
 959         }
 960     }
 961     v = VarFind(name, ctxt, 0);
 962     if (v == NULL) {
 963         if (ctxt == VAR_CMD && (flags & VAR_NO_EXPORT) == 0) {
 964             /*
 965              * This var would normally prevent the same name being added
 966              * to VAR_GLOBAL, so delete it from there if needed.
 967              * Otherwise -V name may show the wrong value.
 968              */
 969             Var_Delete(name, VAR_GLOBAL);
 970         }
 971         VarAdd(name, val, ctxt);
 972     } else {
 973         Buf_Empty(&v->val);
 974         if (val)
 975             Buf_AddBytes(&v->val, strlen(val), val);
 976
 977         if (DEBUG(VAR)) {
 978             fprintf(debug_file, "%s:%s = %s\n", ctxt->name, name, val);
 979         }
 980         if ((v->flags & VAR_EXPORTED)) {
 981             Var_Export1(name, VAR_EXPORT_PARENT);
 982         }
 983     }
 984     /*
 985      * Any variables given on the command line are automatically exported
 986      * to the environment (as per POSIX standard)
 987      */
 988     if (ctxt == VAR_CMD && (flags & VAR_NO_EXPORT) == 0) {
 989         if (v == NULL) {
 990             /* we just added it */
 991             v = VarFind(name, ctxt, 0);
 992         }
 993         if (v != NULL)
 994             v->flags |= VAR_FROM_CMD;
 995         /*
 996          * If requested, don't export these in the environment
 997          * individually.  We still put them in MAKEOVERRIDES so
 998          * that the command-line settings continue to override
 999          * Makefile settings.
1000          */
1001         if (varNoExportEnv != TRUE)
1002             setenv(name, val ? val : "", 1);
1003
1004         Var_Append(MAKEOVERRIDES, name, VAR_GLOBAL);
1005     }
1006     if (*name == '.') {
1007         if (strcmp(name, SAVE_DOLLARS) == 0)
1008             save_dollars = s2Boolean(val, save_dollars);
1009     }
1010
1011  out:
1012     free(expanded_name);
1013     if (v != NULL)
1014         VarFreeEnv(v, TRUE);
1015 }
1016
1017 /*-
1018  *-----------------------------------------------------------------------
1019  * Var_Append --
1020  *      The variable of the given name has the given value appended to it in
1021  *      the given context.
1022  *
1023  * Input:
1024  *      name            name of variable to modify
1025  *      val             String to append to it
1026  *      ctxt            Context in which this should occur
1027  *
1028  * Results:
1029  *      None
1030  *
1031  * Side Effects:
1032  *      If the variable doesn't exist, it is created. Else the strings
1033  *      are concatenated (with a space in between).
1034  *
1035  * Notes:
1036  *      Only if the variable is being sought in the global context is the
1037  *      environment searched.
1038  *      XXX: Knows its calling circumstances in that if called with ctxt
1039  *      an actual target, it will only search that context since only
1040  *      a local variable could be being appended to. This is actually
1041  *      a big win and must be tolerated.
1042  *-----------------------------------------------------------------------
1043  */
1044 void
1045 Var_Append(const char *name, const char *val, GNode *ctxt)
1046 {
1047     Var            *v;
1048     Hash_Entry     *h;
1049     char *expanded_name = NULL;
1050
1051     if (strchr(name, '$') != NULL) {
1052         expanded_name = Var_Subst(NULL, name, ctxt, VARF_WANTRES);
1053         if (expanded_name[0] == 0) {
1054             if (DEBUG(VAR)) {
1055                 fprintf(debug_file, "Var_Append(\"%s\", \"%s\", ...) "
1056                         "name expands to empty string - ignored\n",
1057                         name, val);
1058             }
1059             free(expanded_name);
1060             return;
1061         }
1062         name = expanded_name;
1063     }
1064
1065     v = VarFind(name, ctxt, (ctxt == VAR_GLOBAL) ? (FIND_CMD|FIND_ENV) : 0);
1066
1067     if (v == NULL) {
1068         Var_Set(name, val, ctxt, 0);
1069     } else if (ctxt == VAR_CMD || !(v->flags & VAR_FROM_CMD)) {
1070         Buf_AddByte(&v->val, ' ');
1071         Buf_AddBytes(&v->val, strlen(val), val);
1072
1073         if (DEBUG(VAR)) {
1074             fprintf(debug_file, "%s:%s = %s\n", ctxt->name, name,
1075                    Buf_GetAll(&v->val, NULL));
1076         }
1077
1078         if (v->flags & VAR_FROM_ENV) {
1079             /*
1080              * If the original variable came from the environment, we
1081              * have to install it in the global context (we could place
1082              * it in the environment, but then we should provide a way to
1083              * export other variables...)
1084              */
1085             v->flags &= ~VAR_FROM_ENV;
1086             h = Hash_CreateEntry(&ctxt->context, name, NULL);
1087             Hash_SetValue(h, v);
1088         }
1089     }
1090     free(expanded_name);
1091 }
1092
1093 /*-
1094  *-----------------------------------------------------------------------
1095  * Var_Exists --
1096  *      See if the given variable exists.
1097  *
1098  * Input:
1099  *      name            Variable to find
1100  *      ctxt            Context in which to start search
1101  *
1102  * Results:
1103  *      TRUE if it does, FALSE if it doesn't
1104  *
1105  * Side Effects:
1106  *      None.
1107  *
1108  *-----------------------------------------------------------------------
1109  */
1110 Boolean
1111 Var_Exists(const char *name, GNode *ctxt)
1112 {
1113     Var           *v;
1114     char          *cp;
1115
1116     if ((cp = strchr(name, '$')) != NULL) {
1117         cp = Var_Subst(NULL, name, ctxt, VARF_WANTRES);
1118     }
1119     v = VarFind(cp ? cp : name, ctxt, FIND_CMD|FIND_GLOBAL|FIND_ENV);
1120     free(cp);
1121     if (v == NULL) {
1122         return(FALSE);
1123     } else {
1124         (void)VarFreeEnv(v, TRUE);
1125     }
1126     return(TRUE);
1127 }
1128
1129 /*-
1130  *-----------------------------------------------------------------------
1131  * Var_Value --
1132  *      Return the value of the named variable in the given context
1133  *
1134  * Input:
1135  *      name            name to find
1136  *      ctxt            context in which to search for it
1137  *
1138  * Results:
1139  *      The value if the variable exists, NULL if it doesn't
1140  *
1141  * Side Effects:
1142  *      None
1143  *-----------------------------------------------------------------------
1144  */
1145 char *
1146 Var_Value(const char *name, GNode *ctxt, char **frp)
1147 {
1148     Var            *v;
1149
1150     v = VarFind(name, ctxt, FIND_ENV | FIND_GLOBAL | FIND_CMD);
1151     *frp = NULL;
1152     if (v != NULL) {
1153         char *p = (Buf_GetAll(&v->val, NULL));
1154         if (VarFreeEnv(v, FALSE))
1155             *frp = p;
1156         return p;
1157     } else {
1158         return NULL;
1159     }
1160 }
1161
1162 /*-
1163  *-----------------------------------------------------------------------
1164  * VarHead --
1165  *      Remove the tail of the given word and place the result in the given
1166  *      buffer.
1167  *
1168  * Input:
1169  *      word            Word to trim
1170  *      addSpace        True if need to add a space to the buffer
1171  *                      before sticking in the head
1172  *      buf             Buffer in which to store it
1173  *
1174  * Results:
1175  *      TRUE if characters were added to the buffer (a space needs to be
1176  *      added to the buffer before the next word).
1177  *
1178  * Side Effects:
1179  *      The trimmed word is added to the buffer.
1180  *
1181  *-----------------------------------------------------------------------
1182  */
1183 static Boolean
1184 VarHead(GNode *ctx MAKE_ATTR_UNUSED, Var_Parse_State *vpstate,
1185         char *word, Boolean addSpace, Buffer *buf,
1186         void *dummy MAKE_ATTR_UNUSED)
1187 {
1188     char *slash;
1189
1190     slash = strrchr(word, '/');
1191     if (slash != NULL) {
1192         if (addSpace && vpstate->varSpace) {
1193             Buf_AddByte(buf, vpstate->varSpace);
1194         }
1195         *slash = '\0';
1196         Buf_AddBytes(buf, strlen(word), word);
1197         *slash = '/';
1198         return (TRUE);
1199     } else {
1200         /*
1201          * If no directory part, give . (q.v. the POSIX standard)
1202          */
1203         if (addSpace && vpstate->varSpace)
1204             Buf_AddByte(buf, vpstate->varSpace);
1205         Buf_AddByte(buf, '.');
1206     }
1207     return TRUE;
1208 }
1209
1210 /*-
1211  *-----------------------------------------------------------------------
1212  * VarTail --
1213  *      Remove the head of the given word and place the result in the given
1214  *      buffer.
1215  *
1216  * Input:
1217  *      word            Word to trim
1218  *      addSpace        True if need to add a space to the buffer
1219  *                      before adding the tail
1220  *      buf             Buffer in which to store it
1221  *
1222  * Results:
1223  *      TRUE if characters were added to the buffer (a space needs to be
1224  *      added to the buffer before the next word).
1225  *
1226  * Side Effects:
1227  *      The trimmed word is added to the buffer.
1228  *
1229  *-----------------------------------------------------------------------
1230  */
1231 static Boolean
1232 VarTail(GNode *ctx MAKE_ATTR_UNUSED, Var_Parse_State *vpstate,
1233         char *word, Boolean addSpace, Buffer *buf,
1234         void *dummy MAKE_ATTR_UNUSED)
1235 {
1236     char *slash;
1237
1238     if (addSpace && vpstate->varSpace) {
1239         Buf_AddByte(buf, vpstate->varSpace);
1240     }
1241
1242     slash = strrchr(word, '/');
1243     if (slash != NULL) {
1244         *slash++ = '\0';
1245         Buf_AddBytes(buf, strlen(slash), slash);
1246         slash[-1] = '/';
1247     } else {
1248         Buf_AddBytes(buf, strlen(word), word);
1249     }
1250     return TRUE;
1251 }
1252
1253 /*-
1254  *-----------------------------------------------------------------------
1255  * VarSuffix --
1256  *      Place the suffix of the given word in the given buffer.
1257  *
1258  * Input:
1259  *      word            Word to trim
1260  *      addSpace        TRUE if need to add a space before placing the
1261  *                      suffix in the buffer
1262  *      buf             Buffer in which to store it
1263  *
1264  * Results:
1265  *      TRUE if characters were added to the buffer (a space needs to be
1266  *      added to the buffer before the next word).
1267  *
1268  * Side Effects:
1269  *      The suffix from the word is placed in the buffer.
1270  *
1271  *-----------------------------------------------------------------------
1272  */
1273 static Boolean
1274 VarSuffix(GNode *ctx MAKE_ATTR_UNUSED, Var_Parse_State *vpstate,
1275           char *word, Boolean addSpace, Buffer *buf,
1276           void *dummy MAKE_ATTR_UNUSED)
1277 {
1278     char *dot;
1279
1280     dot = strrchr(word, '.');
1281     if (dot != NULL) {
1282         if (addSpace && vpstate->varSpace) {
1283             Buf_AddByte(buf, vpstate->varSpace);
1284         }
1285         *dot++ = '\0';
1286         Buf_AddBytes(buf, strlen(dot), dot);
1287         dot[-1] = '.';
1288         addSpace = TRUE;
1289     }
1290     return addSpace;
1291 }
1292
1293 /*-
1294  *-----------------------------------------------------------------------
1295  * VarRoot --
1296  *      Remove the suffix of the given word and place the result in the
1297  *      buffer.
1298  *
1299  * Input:
1300  *      word            Word to trim
1301  *      addSpace        TRUE if need to add a space to the buffer
1302  *                      before placing the root in it
1303  *      buf             Buffer in which to store it
1304  *
1305  * Results:
1306  *      TRUE if characters were added to the buffer (a space needs to be
1307  *      added to the buffer before the next word).
1308  *
1309  * Side Effects:
1310  *      The trimmed word is added to the buffer.
1311  *
1312  *-----------------------------------------------------------------------
1313  */
1314 static Boolean
1315 VarRoot(GNode *ctx MAKE_ATTR_UNUSED, Var_Parse_State *vpstate,
1316         char *word, Boolean addSpace, Buffer *buf,
1317         void *dummy MAKE_ATTR_UNUSED)
1318 {
1319     char *dot;
1320
1321     if (addSpace && vpstate->varSpace) {
1322         Buf_AddByte(buf, vpstate->varSpace);
1323     }
1324
1325     dot = strrchr(word, '.');
1326     if (dot != NULL) {
1327         *dot = '\0';
1328         Buf_AddBytes(buf, strlen(word), word);
1329         *dot = '.';
1330     } else {
1331         Buf_AddBytes(buf, strlen(word), word);
1332     }
1333     return TRUE;
1334 }
1335
1336 /*-
1337  *-----------------------------------------------------------------------
1338  * VarMatch --
1339  *      Place the word in the buffer if it matches the given pattern.
1340  *      Callback function for VarModify to implement the :M modifier.
1341  *
1342  * Input:
1343  *      word            Word to examine
1344  *      addSpace        TRUE if need to add a space to the buffer
1345  *                      before adding the word, if it matches
1346  *      buf             Buffer in which to store it
1347  *      pattern         Pattern the word must match
1348  *
1349  * Results:
1350  *      TRUE if a space should be placed in the buffer before the next
1351  *      word.
1352  *
1353  * Side Effects:
1354  *      The word may be copied to the buffer.
1355  *
1356  *-----------------------------------------------------------------------
1357  */
1358 static Boolean
1359 VarMatch(GNode *ctx MAKE_ATTR_UNUSED, Var_Parse_State *vpstate,
1360          char *word, Boolean addSpace, Buffer *buf,
1361          void *pattern)
1362 {
1363     if (DEBUG(VAR))
1364         fprintf(debug_file, "VarMatch [%s] [%s]\n", word, (char *)pattern);
1365     if (Str_Match(word, (char *)pattern)) {
1366         if (addSpace && vpstate->varSpace) {
1367             Buf_AddByte(buf, vpstate->varSpace);
1368         }
1369         addSpace = TRUE;
1370         Buf_AddBytes(buf, strlen(word), word);
1371     }
1372     return(addSpace);
1373 }
1374
1375 #ifdef SYSVVARSUB
1376 /*-
1377  *-----------------------------------------------------------------------
1378  * VarSYSVMatch --
1379  *      Place the word in the buffer if it matches the given pattern.
1380  *      Callback function for VarModify to implement the System V %
1381  *      modifiers.
1382  *
1383  * Input:
1384  *      word            Word to examine
1385  *      addSpace        TRUE if need to add a space to the buffer
1386  *                      before adding the word, if it matches
1387  *      buf             Buffer in which to store it
1388  *      patp            Pattern the word must match
1389  *
1390  * Results:
1391  *      TRUE if a space should be placed in the buffer before the next
1392  *      word.
1393  *
1394  * Side Effects:
1395  *      The word may be copied to the buffer.
1396  *
1397  *-----------------------------------------------------------------------
1398  */
1399 static Boolean
1400 VarSYSVMatch(GNode *ctx, Var_Parse_State *vpstate,
1401              char *word, Boolean addSpace, Buffer *buf,
1402              void *patp)
1403 {
1404     int len;
1405     char *ptr;
1406     VarPattern    *pat = (VarPattern *)patp;
1407     char *varexp;
1408
1409     if (addSpace && vpstate->varSpace)
1410         Buf_AddByte(buf, vpstate->varSpace);
1411
1412     addSpace = TRUE;
1413
1414     if ((ptr = Str_SYSVMatch(word, pat->lhs, &len)) != NULL) {
1415         varexp = Var_Subst(NULL, pat->rhs, ctx, VARF_WANTRES);
1416         Str_SYSVSubst(buf, varexp, ptr, len);
1417         free(varexp);
1418     } else {
1419         Buf_AddBytes(buf, strlen(word), word);
1420     }
1421
1422     return(addSpace);
1423 }
1424 #endif
1425
1426
1427 /*-
1428  *-----------------------------------------------------------------------
1429  * VarNoMatch --
1430  *      Place the word in the buffer if it doesn't match the given pattern.
1431  *      Callback function for VarModify to implement the :N modifier.
1432  *
1433  * Input:
1434  *      word            Word to examine
1435  *      addSpace        TRUE if need to add a space to the buffer
1436  *                      before adding the word, if it matches
1437  *      buf             Buffer in which to store it
1438  *      pattern         Pattern the word must match
1439  *
1440  * Results:
1441  *      TRUE if a space should be placed in the buffer before the next
1442  *      word.
1443  *
1444  * Side Effects:
1445  *      The word may be copied to the buffer.
1446  *
1447  *-----------------------------------------------------------------------
1448  */
1449 static Boolean
1450 VarNoMatch(GNode *ctx MAKE_ATTR_UNUSED, Var_Parse_State *vpstate,
1451            char *word, Boolean addSpace, Buffer *buf,
1452            void *pattern)
1453 {
1454     if (!Str_Match(word, (char *)pattern)) {
1455         if (addSpace && vpstate->varSpace) {
1456             Buf_AddByte(buf, vpstate->varSpace);
1457         }
1458         addSpace = TRUE;
1459         Buf_AddBytes(buf, strlen(word), word);
1460     }
1461     return(addSpace);
1462 }
1463
1464
1465 /*-
1466  *-----------------------------------------------------------------------
1467  * VarSubstitute --
1468  *      Perform a string-substitution on the given word, placing the
1469  *      result in the passed buffer.
1470  *
1471  * Input:
1472  *      word            Word to modify
1473  *      addSpace        True if space should be added before
1474  *                      other characters
1475  *      buf             Buffer for result
1476  *      patternp        Pattern for substitution
1477  *
1478  * Results:
1479  *      TRUE if a space is needed before more characters are added.
1480  *
1481  * Side Effects:
1482  *      None.
1483  *
1484  *-----------------------------------------------------------------------
1485  */
1486 static Boolean
1487 VarSubstitute(GNode *ctx MAKE_ATTR_UNUSED, Var_Parse_State *vpstate,
1488               char *word, Boolean addSpace, Buffer *buf,
1489               void *patternp)
1490 {
1491     int         wordLen;    /* Length of word */
1492     char        *cp;        /* General pointer */
1493     VarPattern  *pattern = (VarPattern *)patternp;
1494
1495     wordLen = strlen(word);
1496     if ((pattern->flags & (VAR_SUB_ONE|VAR_SUB_MATCHED)) !=
1497         (VAR_SUB_ONE|VAR_SUB_MATCHED)) {
1498         /*
1499          * Still substituting -- break it down into simple anchored cases
1500          * and if none of them fits, perform the general substitution case.
1501          */
1502         if ((pattern->flags & VAR_MATCH_START) &&
1503             (strncmp(word, pattern->lhs, pattern->leftLen) == 0)) {
1504                 /*
1505                  * Anchored at start and beginning of word matches pattern
1506                  */
1507                 if ((pattern->flags & VAR_MATCH_END) &&
1508                     (wordLen == pattern->leftLen)) {
1509                         /*
1510                          * Also anchored at end and matches to the end (word
1511                          * is same length as pattern) add space and rhs only
1512                          * if rhs is non-null.
1513                          */
1514                         if (pattern->rightLen != 0) {
1515                             if (addSpace && vpstate->varSpace) {
1516                                 Buf_AddByte(buf, vpstate->varSpace);
1517                             }
1518                             addSpace = TRUE;
1519                             Buf_AddBytes(buf, pattern->rightLen, pattern->rhs);
1520                         }
1521                         pattern->flags |= VAR_SUB_MATCHED;
1522                 } else if (pattern->flags & VAR_MATCH_END) {
1523                     /*
1524                      * Doesn't match to end -- copy word wholesale
1525                      */
1526                     goto nosub;
1527                 } else {
1528                     /*
1529                      * Matches at start but need to copy in trailing characters
1530                      */
1531                     if ((pattern->rightLen + wordLen - pattern->leftLen) != 0){
1532                         if (addSpace && vpstate->varSpace) {
1533                             Buf_AddByte(buf, vpstate->varSpace);
1534                         }
1535                         addSpace = TRUE;
1536                     }
1537                     Buf_AddBytes(buf, pattern->rightLen, pattern->rhs);
1538                     Buf_AddBytes(buf, wordLen - pattern->leftLen,
1539                                  (word + pattern->leftLen));
1540                     pattern->flags |= VAR_SUB_MATCHED;
1541                 }
1542         } else if (pattern->flags & VAR_MATCH_START) {
1543             /*
1544              * Had to match at start of word and didn't -- copy whole word.
1545              */
1546             goto nosub;
1547         } else if (pattern->flags & VAR_MATCH_END) {
1548             /*
1549              * Anchored at end, Find only place match could occur (leftLen
1550              * characters from the end of the word) and see if it does. Note
1551              * that because the $ will be left at the end of the lhs, we have
1552              * to use strncmp.
1553              */
1554             cp = word + (wordLen - pattern->leftLen);
1555             if ((cp >= word) &&
1556                 (strncmp(cp, pattern->lhs, pattern->leftLen) == 0)) {
1557                 /*
1558                  * Match found. If we will place characters in the buffer,
1559                  * add a space before hand as indicated by addSpace, then
1560                  * stuff in the initial, unmatched part of the word followed
1561                  * by the right-hand-side.
1562                  */
1563                 if (((cp - word) + pattern->rightLen) != 0) {
1564                     if (addSpace && vpstate->varSpace) {
1565                         Buf_AddByte(buf, vpstate->varSpace);
1566                     }
1567                     addSpace = TRUE;
1568                 }
1569                 Buf_AddBytes(buf, cp - word, word);
1570                 Buf_AddBytes(buf, pattern->rightLen, pattern->rhs);
1571                 pattern->flags |= VAR_SUB_MATCHED;
1572             } else {
1573                 /*
1574                  * Had to match at end and didn't. Copy entire word.
1575                  */
1576                 goto nosub;
1577             }
1578         } else {
1579             /*
1580              * Pattern is unanchored: search for the pattern in the word using
1581              * String_FindSubstring, copying unmatched portions and the
1582              * right-hand-side for each match found, handling non-global
1583              * substitutions correctly, etc. When the loop is done, any
1584              * remaining part of the word (word and wordLen are adjusted
1585              * accordingly through the loop) is copied straight into the
1586              * buffer.
1587              * addSpace is set FALSE as soon as a space is added to the
1588              * buffer.
1589              */
1590             Boolean done;
1591             int origSize;
1592
1593             done = FALSE;
1594             origSize = Buf_Size(buf);
1595             while (!done) {
1596                 cp = Str_FindSubstring(word, pattern->lhs);
1597                 if (cp != NULL) {
1598                     if (addSpace && (((cp - word) + pattern->rightLen) != 0)){
1599                         Buf_AddByte(buf, vpstate->varSpace);
1600                         addSpace = FALSE;
1601                     }
1602                     Buf_AddBytes(buf, cp-word, word);
1603                     Buf_AddBytes(buf, pattern->rightLen, pattern->rhs);
1604                     wordLen -= (cp - word) + pattern->leftLen;
1605                     word = cp + pattern->leftLen;
1606                     if (wordLen == 0) {
1607                         done = TRUE;
1608                     }
1609                     if ((pattern->flags & VAR_SUB_GLOBAL) == 0) {
1610                         done = TRUE;
1611                     }
1612                     pattern->flags |= VAR_SUB_MATCHED;
1613                 } else {
1614                     done = TRUE;
1615                 }
1616             }
1617             if (wordLen != 0) {
1618                 if (addSpace && vpstate->varSpace) {
1619                     Buf_AddByte(buf, vpstate->varSpace);
1620                 }
1621                 Buf_AddBytes(buf, wordLen, word);
1622             }
1623             /*
1624              * If added characters to the buffer, need to add a space
1625              * before we add any more. If we didn't add any, just return
1626              * the previous value of addSpace.
1627              */
1628             return ((Buf_Size(buf) != origSize) || addSpace);
1629         }
1630         return (addSpace);
1631     }
1632  nosub:
1633     if (addSpace && vpstate->varSpace) {
1634         Buf_AddByte(buf, vpstate->varSpace);
1635     }
1636     Buf_AddBytes(buf, wordLen, word);
1637     return(TRUE);
1638 }
1639
1640 #ifndef NO_REGEX
1641 /*-
1642  *-----------------------------------------------------------------------
1643  * VarREError --
1644  *      Print the error caused by a regcomp or regexec call.
1645  *
1646  * Results:
1647  *      None.
1648  *
1649  * Side Effects:
1650  *      An error gets printed.
1651  *
1652  *-----------------------------------------------------------------------
1653  */
1654 static void
1655 VarREError(int reerr, regex_t *pat, const char *str)
1656 {
1657     char *errbuf;
1658     int errlen;
1659
1660     errlen = regerror(reerr, pat, 0, 0);
1661     errbuf = bmake_malloc(errlen);
1662     regerror(reerr, pat, errbuf, errlen);
1663     Error("%s: %s", str, errbuf);
1664     free(errbuf);
1665 }
1666
1667
1668 /*-
1669  *-----------------------------------------------------------------------
1670  * VarRESubstitute --
1671  *      Perform a regex substitution on the given word, placing the
1672  *      result in the passed buffer.
1673  *
1674  * Results:
1675  *      TRUE if a space is needed before more characters are added.
1676  *
1677  * Side Effects:
1678  *      None.
1679  *
1680  *-----------------------------------------------------------------------
1681  */
1682 static Boolean
1683 VarRESubstitute(GNode *ctx MAKE_ATTR_UNUSED,
1684                 Var_Parse_State *vpstate MAKE_ATTR_UNUSED,
1685                 char *word, Boolean addSpace, Buffer *buf,
1686                 void *patternp)
1687 {
1688     VarREPattern *pat;
1689     int xrv;
1690     char *wp;
1691     char *rp;
1692     int added;
1693     int flags = 0;
1694
1695 #define MAYBE_ADD_SPACE()               \
1696         if (addSpace && !added)         \
1697             Buf_AddByte(buf, ' ');      \
1698         added = 1
1699
1700     added = 0;
1701     wp = word;
1702     pat = patternp;
1703
1704     if ((pat->flags & (VAR_SUB_ONE|VAR_SUB_MATCHED)) ==
1705         (VAR_SUB_ONE|VAR_SUB_MATCHED))
1706         xrv = REG_NOMATCH;
1707     else {
1708     tryagain:
1709         xrv = regexec(&pat->re, wp, pat->nsub, pat->matches, flags);
1710     }
1711
1712     switch (xrv) {
1713     case 0:
1714         pat->flags |= VAR_SUB_MATCHED;
1715         if (pat->matches[0].rm_so > 0) {
1716             MAYBE_ADD_SPACE();
1717             Buf_AddBytes(buf, pat->matches[0].rm_so, wp);
1718         }
1719
1720         for (rp = pat->replace; *rp; rp++) {
1721             if ((*rp == '\\') && ((rp[1] == '&') || (rp[1] == '\\'))) {
1722                 MAYBE_ADD_SPACE();
1723                 Buf_AddByte(buf,rp[1]);
1724                 rp++;
1725             }
1726             else if ((*rp == '&') ||
1727                 ((*rp == '\\') && isdigit((unsigned char)rp[1]))) {
1728                 int n;
1729                 const char *subbuf;
1730                 int sublen;
1731                 char errstr[3];
1732
1733                 if (*rp == '&') {
1734                     n = 0;
1735                     errstr[0] = '&';
1736                     errstr[1] = '\0';
1737                 } else {
1738                     n = rp[1] - '0';
1739                     errstr[0] = '\\';
1740                     errstr[1] = rp[1];
1741                     errstr[2] = '\0';
1742                     rp++;
1743                 }
1744
1745                 if (n > pat->nsub) {
1746                     Error("No subexpression %s", &errstr[0]);
1747                     subbuf = "";
1748                     sublen = 0;
1749                 } else if ((pat->matches[n].rm_so == -1) &&
1750                            (pat->matches[n].rm_eo == -1)) {
1751                     Error("No match for subexpression %s", &errstr[0]);
1752                     subbuf = "";
1753                     sublen = 0;
1754                 } else {
1755                     subbuf = wp + pat->matches[n].rm_so;
1756                     sublen = pat->matches[n].rm_eo - pat->matches[n].rm_so;
1757                 }
1758
1759                 if (sublen > 0) {
1760                     MAYBE_ADD_SPACE();
1761                     Buf_AddBytes(buf, sublen, subbuf);
1762                 }
1763             } else {
1764                 MAYBE_ADD_SPACE();
1765                 Buf_AddByte(buf, *rp);
1766             }
1767         }
1768         wp += pat->matches[0].rm_eo;
1769         if (pat->flags & VAR_SUB_GLOBAL) {
1770             flags |= REG_NOTBOL;
1771             if (pat->matches[0].rm_so == 0 && pat->matches[0].rm_eo == 0) {
1772                 MAYBE_ADD_SPACE();
1773                 Buf_AddByte(buf, *wp);
1774                 wp++;
1775
1776             }
1777             if (*wp)
1778                 goto tryagain;
1779         }
1780         if (*wp) {
1781             MAYBE_ADD_SPACE();
1782             Buf_AddBytes(buf, strlen(wp), wp);
1783         }
1784         break;
1785     default:
1786         VarREError(xrv, &pat->re, "Unexpected regex error");
1787        /* fall through */
1788     case REG_NOMATCH:
1789         if (*wp) {
1790             MAYBE_ADD_SPACE();
1791             Buf_AddBytes(buf,strlen(wp),wp);
1792         }
1793         break;
1794     }
1795     return(addSpace||added);
1796 }
1797 #endif
1798
1799
1800
1801 /*-
1802  *-----------------------------------------------------------------------
1803  * VarLoopExpand --
1804  *      Implements the :@<temp>@<string>@ modifier of ODE make.
1805  *      We set the temp variable named in pattern.lhs to word and expand
1806  *      pattern.rhs storing the result in the passed buffer.
1807  *
1808  * Input:
1809  *      word            Word to modify
1810  *      addSpace        True if space should be added before
1811  *                      other characters
1812  *      buf             Buffer for result
1813  *      pattern         Datafor substitution
1814  *
1815  * Results:
1816  *      TRUE if a space is needed before more characters are added.
1817  *
1818  * Side Effects:
1819  *      None.
1820  *
1821  *-----------------------------------------------------------------------
1822  */
1823 static Boolean
1824 VarLoopExpand(GNode *ctx MAKE_ATTR_UNUSED,
1825               Var_Parse_State *vpstate MAKE_ATTR_UNUSED,
1826               char *word, Boolean addSpace, Buffer *buf,
1827               void *loopp)
1828 {
1829     VarLoop_t   *loop = (VarLoop_t *)loopp;
1830     char *s;
1831     int slen;
1832
1833     if (word && *word) {
1834         Var_Set(loop->tvar, word, loop->ctxt, VAR_NO_EXPORT);
1835         s = Var_Subst(NULL, loop->str, loop->ctxt, loop->errnum | VARF_WANTRES);
1836         if (s != NULL && *s != '\0') {
1837             if (addSpace && *s != '\n')
1838                 Buf_AddByte(buf, ' ');
1839             Buf_AddBytes(buf, (slen = strlen(s)), s);
1840             addSpace = (slen > 0 && s[slen - 1] != '\n');
1841         }
1842         free(s);
1843     }
1844     return addSpace;
1845 }
1846
1847
1848 /*-
1849  *-----------------------------------------------------------------------
1850  * VarSelectWords --
1851  *      Implements the :[start..end] modifier.
1852  *      This is a special case of VarModify since we want to be able
1853  *      to scan the list backwards if start > end.
1854  *
1855  * Input:
1856  *      str             String whose words should be trimmed
1857  *      seldata         words to select
1858  *
1859  * Results:
1860  *      A string of all the words selected.
1861  *
1862  * Side Effects:
1863  *      None.
1864  *
1865  *-----------------------------------------------------------------------
1866  */
1867 static char *
1868 VarSelectWords(GNode *ctx MAKE_ATTR_UNUSED, Var_Parse_State *vpstate,
1869                const char *str, VarSelectWords_t *seldata)
1870 {
1871     Buffer        buf;              /* Buffer for the new string */
1872     Boolean       addSpace;         /* TRUE if need to add a space to the
1873                                      * buffer before adding the trimmed
1874                                      * word */
1875     char **av;                      /* word list */
1876     char *as;                       /* word list memory */
1877     int ac, i;
1878     int start, end, step;
1879
1880     Buf_Init(&buf, 0);
1881     addSpace = FALSE;
1882
1883     if (vpstate->oneBigWord) {
1884         /* fake what brk_string() would do if there were only one word */
1885         ac = 1;
1886         av = bmake_malloc((ac + 1) * sizeof(char *));
1887         as = bmake_strdup(str);
1888         av[0] = as;
1889         av[1] = NULL;
1890     } else {
1891         av = brk_string(str, &ac, FALSE, &as);
1892     }
1893
1894     /*
1895      * Now sanitize seldata.
1896      * If seldata->start or seldata->end are negative, convert them to
1897      * the positive equivalents (-1 gets converted to argc, -2 gets
1898      * converted to (argc-1), etc.).
1899      */
1900     if (seldata->start < 0)
1901         seldata->start = ac + seldata->start + 1;
1902     if (seldata->end < 0)
1903         seldata->end = ac + seldata->end + 1;
1904
1905     /*
1906      * We avoid scanning more of the list than we need to.
1907      */
1908     if (seldata->start > seldata->end) {
1909         start = MIN(ac, seldata->start) - 1;
1910         end = MAX(0, seldata->end - 1);
1911         step = -1;
1912     } else {
1913         start = MAX(0, seldata->start - 1);
1914         end = MIN(ac, seldata->end);
1915         step = 1;
1916     }
1917
1918     for (i = start;
1919          (step < 0 && i >= end) || (step > 0 && i < end);
1920          i += step) {
1921         if (av[i] && *av[i]) {
1922             if (addSpace && vpstate->varSpace) {
1923                 Buf_AddByte(&buf, vpstate->varSpace);
1924             }
1925             Buf_AddBytes(&buf, strlen(av[i]), av[i]);
1926             addSpace = TRUE;
1927         }
1928     }
1929
1930     free(as);
1931     free(av);
1932
1933     return Buf_Destroy(&buf, FALSE);
1934 }
1935
1936
1937 /*-
1938  * VarRealpath --
1939  *      Replace each word with the result of realpath()
1940  *      if successful.
1941  */
1942 static Boolean
1943 VarRealpath(GNode *ctx MAKE_ATTR_UNUSED, Var_Parse_State *vpstate,
1944             char *word, Boolean addSpace, Buffer *buf,
1945             void *patternp MAKE_ATTR_UNUSED)
1946 {
1947         struct stat st;
1948         char rbuf[MAXPATHLEN];
1949         char *rp;
1950
1951         if (addSpace && vpstate->varSpace) {
1952             Buf_AddByte(buf, vpstate->varSpace);
1953         }
1954         addSpace = TRUE;
1955         rp = cached_realpath(word, rbuf);
1956         if (rp && *rp == '/' && stat(rp, &st) == 0)
1957                 word = rp;
1958
1959         Buf_AddBytes(buf, strlen(word), word);
1960         return(addSpace);
1961 }
1962
1963 /*-
1964  *-----------------------------------------------------------------------
1965  * VarModify --
1966  *      Modify each of the words of the passed string using the given
1967  *      function. Used to implement all modifiers.
1968  *
1969  * Input:
1970  *      str             String whose words should be trimmed
1971  *      modProc         Function to use to modify them
1972  *      datum           Datum to pass it
1973  *
1974  * Results:
1975  *      A string of all the words modified appropriately.
1976  *
1977  * Side Effects:
1978  *      None.
1979  *
1980  *-----------------------------------------------------------------------
1981  */
1982 static char *
1983 VarModify(GNode *ctx, Var_Parse_State *vpstate,
1984     const char *str,
1985     Boolean (*modProc)(GNode *, Var_Parse_State *, char *,
1986                        Boolean, Buffer *, void *),
1987     void *datum)
1988 {
1989     Buffer        buf;              /* Buffer for the new string */
1990     Boolean       addSpace;         /* TRUE if need to add a space to the
1991                                      * buffer before adding the trimmed
1992                                      * word */
1993     char **av;                      /* word list */
1994     char *as;                       /* word list memory */
1995     int ac, i;
1996
1997     Buf_Init(&buf, 0);
1998     addSpace = FALSE;
1999
2000     if (vpstate->oneBigWord) {
2001         /* fake what brk_string() would do if there were only one word */
2002         ac = 1;
2003         av = bmake_malloc((ac + 1) * sizeof(char *));
2004         as = bmake_strdup(str);
2005         av[0] = as;
2006         av[1] = NULL;
2007     } else {
2008         av = brk_string(str, &ac, FALSE, &as);
2009     }
2010
2011     for (i = 0; i < ac; i++) {
2012         addSpace = (*modProc)(ctx, vpstate, av[i], addSpace, &buf, datum);
2013     }
2014
2015     free(as);
2016     free(av);
2017
2018     return Buf_Destroy(&buf, FALSE);
2019 }
2020
2021
2022 static int
2023 VarWordCompare(const void *a, const void *b)
2024 {
2025         int r = strcmp(*(const char * const *)a, *(const char * const *)b);
2026         return r;
2027 }
2028
2029 /*-
2030  *-----------------------------------------------------------------------
2031  * VarOrder --
2032  *      Order the words in the string.
2033  *
2034  * Input:
2035  *      str             String whose words should be sorted.
2036  *      otype           How to order: s - sort, x - random.
2037  *
2038  * Results:
2039  *      A string containing the words ordered.
2040  *
2041  * Side Effects:
2042  *      None.
2043  *
2044  *-----------------------------------------------------------------------
2045  */
2046 static char *
2047 VarOrder(const char *str, const char otype)
2048 {
2049     Buffer        buf;              /* Buffer for the new string */
2050     char **av;                      /* word list [first word does not count] */
2051     char *as;                       /* word list memory */
2052     int ac, i;
2053
2054     Buf_Init(&buf, 0);
2055
2056     av = brk_string(str, &ac, FALSE, &as);
2057
2058     if (ac > 0)
2059         switch (otype) {
2060         case 's':       /* sort alphabetically */
2061             qsort(av, ac, sizeof(char *), VarWordCompare);
2062             break;
2063         case 'x':       /* randomize */
2064         {
2065             int rndidx;
2066             char *t;
2067
2068             /*
2069              * We will use [ac..2] range for mod factors. This will produce
2070              * random numbers in [(ac-1)..0] interval, and minimal
2071              * reasonable value for mod factor is 2 (the mod 1 will produce
2072              * 0 with probability 1).
2073              */
2074             for (i = ac-1; i > 0; i--) {
2075                 rndidx = random() % (i + 1);
2076                 if (i != rndidx) {
2077                     t = av[i];
2078                     av[i] = av[rndidx];
2079                     av[rndidx] = t;
2080                 }
2081             }
2082         }
2083         } /* end of switch */
2084
2085     for (i = 0; i < ac; i++) {
2086         Buf_AddBytes(&buf, strlen(av[i]), av[i]);
2087         if (i != ac - 1)
2088             Buf_AddByte(&buf, ' ');
2089     }
2090
2091     free(as);
2092     free(av);
2093
2094     return Buf_Destroy(&buf, FALSE);
2095 }
2096
2097
2098 /*-
2099  *-----------------------------------------------------------------------
2100  * VarUniq --
2101  *      Remove adjacent duplicate words.
2102  *
2103  * Input:
2104  *      str             String whose words should be sorted
2105  *
2106  * Results:
2107  *      A string containing the resulting words.
2108  *
2109  * Side Effects:
2110  *      None.
2111  *
2112  *-----------------------------------------------------------------------
2113  */
2114 static char *
2115 VarUniq(const char *str)
2116 {
2117     Buffer        buf;              /* Buffer for new string */
2118     char        **av;               /* List of words to affect */
2119     char         *as;               /* Word list memory */
2120     int           ac, i, j;
2121
2122     Buf_Init(&buf, 0);
2123     av = brk_string(str, &ac, FALSE, &as);
2124
2125     if (ac > 1) {
2126         for (j = 0, i = 1; i < ac; i++)
2127             if (strcmp(av[i], av[j]) != 0 && (++j != i))
2128                 av[j] = av[i];
2129         ac = j + 1;
2130     }
2131
2132     for (i = 0; i < ac; i++) {
2133         Buf_AddBytes(&buf, strlen(av[i]), av[i]);
2134         if (i != ac - 1)
2135             Buf_AddByte(&buf, ' ');
2136     }
2137
2138     free(as);
2139     free(av);
2140
2141     return Buf_Destroy(&buf, FALSE);
2142 }
2143
2144 /*-
2145  *-----------------------------------------------------------------------
2146  * VarRange --
2147  *      Return an integer sequence
2148  *
2149  * Input:
2150  *      str             String whose words provide default range
2151  *      ac              range length, if 0 use str words
2152  *
2153  * Side Effects:
2154  *      None.
2155  *
2156  *-----------------------------------------------------------------------
2157  */
2158 static char *
2159 VarRange(const char *str, int ac)
2160 {
2161     Buffer        buf;              /* Buffer for new string */
2162     char          tmp[32];          /* each element */
2163     char        **av;               /* List of words to affect */
2164     char         *as;               /* Word list memory */
2165     int           i, n;
2166
2167     Buf_Init(&buf, 0);
2168     if (ac > 0) {
2169         as = NULL;
2170         av = NULL;
2171     } else {
2172         av = brk_string(str, &ac, FALSE, &as);
2173     }
2174     for (i = 0; i < ac; i++) {
2175         n = snprintf(tmp, sizeof(tmp), "%d", 1 + i);
2176         if (n >= (int)sizeof(tmp))
2177             break;
2178         Buf_AddBytes(&buf, n, tmp);
2179         if (i != ac - 1)
2180             Buf_AddByte(&buf, ' ');
2181     }
2182
2183     free(as);
2184     free(av);
2185
2186     return Buf_Destroy(&buf, FALSE);
2187 }
2188
2189
2190 /*-
2191  *-----------------------------------------------------------------------
2192  * VarGetPattern --
2193  *      Pass through the tstr looking for 1) escaped delimiters,
2194  *      '$'s and backslashes (place the escaped character in
2195  *      uninterpreted) and 2) unescaped $'s that aren't before
2196  *      the delimiter (expand the variable substitution unless flags
2197  *      has VAR_NOSUBST set).
2198  *      Return the expanded string or NULL if the delimiter was missing
2199  *      If pattern is specified, handle escaped ampersands, and replace
2200  *      unescaped ampersands with the lhs of the pattern.
2201  *
2202  * Results:
2203  *      A string of all the words modified appropriately.
2204  *      If length is specified, return the string length of the buffer
2205  *      If flags is specified and the last character of the pattern is a
2206  *      $ set the VAR_MATCH_END bit of flags.
2207  *
2208  * Side Effects:
2209  *      None.
2210  *-----------------------------------------------------------------------
2211  */
2212 static char *
2213 VarGetPattern(GNode *ctxt, Var_Parse_State *vpstate MAKE_ATTR_UNUSED,
2214               int flags, const char **tstr, int delim, int *vflags,
2215               int *length, VarPattern *pattern)
2216 {
2217     const char *cp;
2218     char *rstr;
2219     Buffer buf;
2220     int junk;
2221     int errnum = flags & VARF_UNDEFERR;
2222
2223     Buf_Init(&buf, 0);
2224     if (length == NULL)
2225         length = &junk;
2226
2227 #define IS_A_MATCH(cp, delim) \
2228     ((cp[0] == '\\') && ((cp[1] == delim) ||  \
2229      (cp[1] == '\\') || (cp[1] == '$') || (pattern && (cp[1] == '&'))))
2230
2231     /*
2232      * Skim through until the matching delimiter is found;
2233      * pick up variable substitutions on the way. Also allow
2234      * backslashes to quote the delimiter, $, and \, but don't
2235      * touch other backslashes.
2236      */
2237     for (cp = *tstr; *cp && (*cp != delim); cp++) {
2238         if (IS_A_MATCH(cp, delim)) {
2239             Buf_AddByte(&buf, cp[1]);
2240             cp++;
2241         } else if (*cp == '$') {
2242             if (cp[1] == delim) {
2243                 if (vflags == NULL)
2244                     Buf_AddByte(&buf, *cp);
2245                 else
2246                     /*
2247                      * Unescaped $ at end of pattern => anchor
2248                      * pattern at end.
2249                      */
2250                     *vflags |= VAR_MATCH_END;
2251             } else {
2252                 if (vflags == NULL || (*vflags & VAR_NOSUBST) == 0) {
2253                     char   *cp2;
2254                     int     len;
2255                     void   *freeIt;
2256
2257                     /*
2258                      * If unescaped dollar sign not before the
2259                      * delimiter, assume it's a variable
2260                      * substitution and recurse.
2261                      */
2262                     cp2 = Var_Parse(cp, ctxt, errnum | VARF_WANTRES, &len,
2263                         &freeIt);
2264                     Buf_AddBytes(&buf, strlen(cp2), cp2);
2265                     free(freeIt);
2266                     cp += len - 1;
2267                 } else {
2268                     const char *cp2 = &cp[1];
2269
2270                     if (*cp2 == PROPEN || *cp2 == BROPEN) {
2271                         /*
2272                          * Find the end of this variable reference
2273                          * and suck it in without further ado.
2274                          * It will be interperated later.
2275                          */
2276                         int have = *cp2;
2277                         int want = (*cp2 == PROPEN) ? PRCLOSE : BRCLOSE;
2278                         int depth = 1;
2279
2280                         for (++cp2; *cp2 != '\0' && depth > 0; ++cp2) {
2281                             if (cp2[-1] != '\\') {
2282                                 if (*cp2 == have)
2283                                     ++depth;
2284                                 if (*cp2 == want)
2285                                     --depth;
2286                             }
2287                         }
2288                         Buf_AddBytes(&buf, cp2 - cp, cp);
2289                         cp = --cp2;
2290                     } else
2291                         Buf_AddByte(&buf, *cp);
2292                 }
2293             }
2294         }
2295         else if (pattern && *cp == '&')
2296             Buf_AddBytes(&buf, pattern->leftLen, pattern->lhs);
2297         else
2298             Buf_AddByte(&buf, *cp);
2299     }
2300
2301     if (*cp != delim) {
2302         *tstr = cp;
2303         *length = 0;
2304         return NULL;
2305     }
2306
2307     *tstr = ++cp;
2308     *length = Buf_Size(&buf);
2309     rstr = Buf_Destroy(&buf, FALSE);
2310     if (DEBUG(VAR))
2311         fprintf(debug_file, "Modifier pattern: \"%s\"\n", rstr);
2312     return rstr;
2313 }
2314
2315 /*-
2316  *-----------------------------------------------------------------------
2317  * VarQuote --
2318  *      Quote shell meta-characters and space characters in the string
2319  *      if quoteDollar is set, also quote and double any '$' characters.
2320  *
2321  * Results:
2322  *      The quoted string
2323  *
2324  * Side Effects:
2325  *      None.
2326  *
2327  *-----------------------------------------------------------------------
2328  */
2329 static char *
2330 VarQuote(char *str, Boolean quoteDollar)
2331 {
2332
2333     Buffer        buf;
2334     const char  *newline;
2335     size_t nlen;
2336
2337     if ((newline = Shell_GetNewline()) == NULL)
2338             newline = "\\\n";
2339     nlen = strlen(newline);
2340
2341     Buf_Init(&buf, 0);
2342
2343     for (; *str != '\0'; str++) {
2344         if (*str == '\n') {
2345             Buf_AddBytes(&buf, nlen, newline);
2346             continue;
2347         }
2348         if (isspace((unsigned char)*str) || ismeta((unsigned char)*str))
2349             Buf_AddByte(&buf, '\\');
2350         Buf_AddByte(&buf, *str);
2351         if (quoteDollar && *str == '$')
2352             Buf_AddBytes(&buf, 2, "\\$");
2353     }
2354
2355     str = Buf_Destroy(&buf, FALSE);
2356     if (DEBUG(VAR))
2357         fprintf(debug_file, "QuoteMeta: [%s]\n", str);
2358     return str;
2359 }
2360
2361 /*-
2362  *-----------------------------------------------------------------------
2363  * VarHash --
2364  *      Hash the string using the MurmurHash3 algorithm.
2365  *      Output is computed using 32bit Little Endian arithmetic.
2366  *
2367  * Input:
2368  *      str             String to modify
2369  *
2370  * Results:
2371  *      Hash value of str, encoded as 8 hex digits.
2372  *
2373  * Side Effects:
2374  *      None.
2375  *
2376  *-----------------------------------------------------------------------
2377  */
2378 static char *
2379 VarHash(char *str)
2380 {
2381     static const char    hexdigits[16] = "0123456789abcdef";
2382     Buffer         buf;
2383     size_t         len, len2;
2384     unsigned char  *ustr = (unsigned char *)str;
2385     unsigned int   h, k, c1, c2;
2386
2387     h  = 0x971e137bU;
2388     c1 = 0x95543787U;
2389     c2 = 0x2ad7eb25U;
2390     len2 = strlen(str);
2391
2392     for (len = len2; len; ) {
2393         k = 0;
2394         switch (len) {
2395         default:
2396             k = (ustr[3] << 24) | (ustr[2] << 16) | (ustr[1] << 8) | ustr[0];
2397             len -= 4;
2398             ustr += 4;
2399             break;
2400         case 3:
2401             k |= (ustr[2] << 16);
2402         case 2:
2403             k |= (ustr[1] << 8);
2404         case 1:
2405             k |= ustr[0];
2406             len = 0;
2407         }
2408         c1 = c1 * 5 + 0x7b7d159cU;
2409         c2 = c2 * 5 + 0x6bce6396U;
2410         k *= c1;
2411         k = (k << 11) ^ (k >> 21);
2412         k *= c2;
2413         h = (h << 13) ^ (h >> 19);
2414         h = h * 5 + 0x52dce729U;
2415         h ^= k;
2416    }
2417    h ^= len2;
2418    h *= 0x85ebca6b;
2419    h ^= h >> 13;
2420    h *= 0xc2b2ae35;
2421    h ^= h >> 16;
2422
2423    Buf_Init(&buf, 0);
2424    for (len = 0; len < 8; ++len) {
2425        Buf_AddByte(&buf, hexdigits[h & 15]);
2426        h >>= 4;
2427    }
2428
2429    return Buf_Destroy(&buf, FALSE);
2430 }
2431
2432 static char *
2433 VarStrftime(const char *fmt, int zulu, time_t utc)
2434 {
2435     char buf[BUFSIZ];
2436
2437     if (!utc)
2438         time(&utc);
2439     if (!*fmt)
2440         fmt = "%c";
2441     strftime(buf, sizeof(buf), fmt, zulu ? gmtime(&utc) : localtime(&utc));
2442
2443     buf[sizeof(buf) - 1] = '\0';
2444     return bmake_strdup(buf);
2445 }
2446
2447 /*
2448  * Now we need to apply any modifiers the user wants applied.
2449  * These are:
2450  *        :M<pattern>   words which match the given <pattern>.
2451  *                      <pattern> is of the standard file
2452  *                      wildcarding form.
2453  *        :N<pattern>   words which do not match the given <pattern>.
2454  *        :S<d><pat1><d><pat2><d>[1gW]
2455  *                      Substitute <pat2> for <pat1> in the value
2456  *        :C<d><pat1><d><pat2><d>[1gW]
2457  *                      Substitute <pat2> for regex <pat1> in the value
2458  *        :H            Substitute the head of each word
2459  *        :T            Substitute the tail of each word
2460  *        :E            Substitute the extension (minus '.') of
2461  *                      each word
2462  *        :R            Substitute the root of each word
2463  *                      (pathname minus the suffix).
2464  *        :O            ("Order") Alphabeticaly sort words in variable.
2465  *        :Ox           ("intermiX") Randomize words in variable.
2466  *        :u            ("uniq") Remove adjacent duplicate words.
2467  *        :tu           Converts the variable contents to uppercase.
2468  *        :tl           Converts the variable contents to lowercase.
2469  *        :ts[c]        Sets varSpace - the char used to
2470  *                      separate words to 'c'. If 'c' is
2471  *                      omitted then no separation is used.
2472  *        :tW           Treat the variable contents as a single
2473  *                      word, even if it contains spaces.
2474  *                      (Mnemonic: one big 'W'ord.)
2475  *        :tw           Treat the variable contents as multiple
2476  *                      space-separated words.
2477  *                      (Mnemonic: many small 'w'ords.)
2478  *        :[index]      Select a single word from the value.
2479  *        :[start..end] Select multiple words from the value.
2480  *        :[*] or :[0]  Select the entire value, as a single
2481  *                      word.  Equivalent to :tW.
2482  *        :[@]          Select the entire value, as multiple
2483  *                      words.  Undoes the effect of :[*].
2484  *                      Equivalent to :tw.
2485  *        :[#]          Returns the number of words in the value.
2486  *
2487  *        :?<true-value>:<false-value>
2488  *                      If the variable evaluates to true, return
2489  *                      true value, else return the second value.
2490  *        :lhs=rhs      Like :S, but the rhs goes to the end of
2491  *                      the invocation.
2492  *        :sh           Treat the current value as a command
2493  *                      to be run, new value is its output.
2494  * The following added so we can handle ODE makefiles.
2495  *        :@<tmpvar>@<newval>@
2496  *                      Assign a temporary local variable <tmpvar>
2497  *                      to the current value of each word in turn
2498  *                      and replace each word with the result of
2499  *                      evaluating <newval>
2500  *        :D<newval>    Use <newval> as value if variable defined
2501  *        :U<newval>    Use <newval> as value if variable undefined
2502  *        :L            Use the name of the variable as the value.
2503  *        :P            Use the path of the node that has the same
2504  *                      name as the variable as the value.  This
2505  *                      basically includes an implied :L so that
2506  *                      the common method of refering to the path
2507  *                      of your dependent 'x' in a rule is to use
2508  *                      the form '${x:P}'.
2509  *        :!<cmd>!      Run cmd much the same as :sh run's the
2510  *                      current value of the variable.
2511  * The ::= modifiers, actually assign a value to the variable.
2512  * Their main purpose is in supporting modifiers of .for loop
2513  * iterators and other obscure uses.  They always expand to
2514  * nothing.  In a target rule that would otherwise expand to an
2515  * empty line they can be preceded with @: to keep make happy.
2516  * Eg.
2517  *
2518  * foo: .USE
2519  * .for i in ${.TARGET} ${.TARGET:R}.gz
2520  *      @: ${t::=$i}
2521  *      @echo blah ${t:T}
2522  * .endfor
2523  *
2524  *        ::=<str>      Assigns <str> as the new value of variable.
2525  *        ::?=<str>     Assigns <str> as value of variable if
2526  *                      it was not already set.
2527  *        ::+=<str>     Appends <str> to variable.
2528  *        ::!=<cmd>     Assigns output of <cmd> as the new value of
2529  *                      variable.
2530  */
2531
2532 /* we now have some modifiers with long names */
2533 #define STRMOD_MATCH(s, want, n) \
2534     (strncmp(s, want, n) == 0 && (s[n] == endc || s[n] == ':'))
2535 #define STRMOD_MATCHX(s, want, n) \
2536     (strncmp(s, want, n) == 0 && (s[n] == endc || s[n] == ':' || s[n] == '='))
2537 #define CHARMOD_MATCH(c) (c == endc || c == ':')
2538
2539 static char *
2540 ApplyModifiers(char *nstr, const char *tstr,
2541                int startc, int endc,
2542                Var *v, GNode *ctxt, int flags,
2543                int *lengthPtr, void **freePtr)
2544 {
2545     const char     *start;
2546     const char     *cp;         /* Secondary pointer into str (place marker
2547                                  * for tstr) */
2548     char           *newStr;     /* New value to return */
2549     char           *ep;
2550     char            termc;      /* Character which terminated scan */
2551     int             cnt;        /* Used to count brace pairs when variable in
2552                                  * in parens or braces */
2553     char        delim;
2554     int         modifier;       /* that we are processing */
2555     Var_Parse_State parsestate; /* Flags passed to helper functions */
2556     time_t      utc;            /* for VarStrftime */
2557
2558     delim = '\0';
2559     parsestate.oneBigWord = FALSE;
2560     parsestate.varSpace = ' ';  /* word separator */
2561
2562     start = cp = tstr;
2563
2564     while (*tstr && *tstr != endc) {
2565
2566         if (*tstr == '$') {
2567             /*
2568              * We may have some complex modifiers in a variable.
2569              */
2570             void *freeIt;
2571             char *rval;
2572             int rlen;
2573             int c;
2574
2575             rval = Var_Parse(tstr, ctxt, flags, &rlen, &freeIt);
2576
2577             /*
2578              * If we have not parsed up to endc or ':',
2579              * we are not interested.
2580              */
2581             if (rval != NULL && *rval &&
2582                 (c = tstr[rlen]) != '\0' &&
2583                 c != ':' &&
2584                 c != endc) {
2585                 free(freeIt);
2586                 goto apply_mods;
2587             }
2588
2589             if (DEBUG(VAR)) {
2590                 fprintf(debug_file, "Got '%s' from '%.*s'%.*s\n",
2591                        rval, rlen, tstr, rlen, tstr + rlen);
2592             }
2593
2594             tstr += rlen;
2595
2596             if (rval != NULL && *rval) {
2597                 int used;
2598
2599                 nstr = ApplyModifiers(nstr, rval,
2600                                       0, 0, v, ctxt, flags, &used, freePtr);
2601                 if (nstr == var_Error
2602                     || (nstr == varNoError && (flags & VARF_UNDEFERR) == 0)
2603                     || strlen(rval) != (size_t) used) {
2604                     free(freeIt);
2605                     goto out;           /* error already reported */
2606                 }
2607             }
2608             free(freeIt);
2609             if (*tstr == ':')
2610                 tstr++;
2611             else if (!*tstr && endc) {
2612                 Error("Unclosed variable specification after complex modifier (expecting '%c') for %s", endc, v->name);
2613                 goto out;
2614             }
2615             continue;
2616         }
2617     apply_mods:
2618         if (DEBUG(VAR)) {
2619             fprintf(debug_file, "Applying[%s] :%c to \"%s\"\n", v->name,
2620                 *tstr, nstr);
2621         }
2622         newStr = var_Error;
2623         switch ((modifier = *tstr)) {
2624         case ':':
2625             {
2626                 if (tstr[1] == '=' ||
2627                     (tstr[2] == '=' &&
2628                      (tstr[1] == '!' || tstr[1] == '+' || tstr[1] == '?'))) {
2629                     /*
2630                      * "::=", "::!=", "::+=", or "::?="
2631                      */
2632                     GNode *v_ctxt;              /* context where v belongs */
2633                     const char *emsg;
2634                     char *sv_name;
2635                     VarPattern  pattern;
2636                     int how;
2637                     int vflags;
2638
2639                     if (v->name[0] == 0)
2640                         goto bad_modifier;
2641
2642                     v_ctxt = ctxt;
2643                     sv_name = NULL;
2644                     ++tstr;
2645                     if (v->flags & VAR_JUNK) {
2646                         /*
2647                          * We need to bmake_strdup() it incase
2648                          * VarGetPattern() recurses.
2649                          */
2650                         sv_name = v->name;
2651                         v->name = bmake_strdup(v->name);
2652                     } else if (ctxt != VAR_GLOBAL) {
2653                         Var *gv = VarFind(v->name, ctxt, 0);
2654                         if (gv == NULL)
2655                             v_ctxt = VAR_GLOBAL;
2656                         else
2657                             VarFreeEnv(gv, TRUE);
2658                     }
2659
2660                     switch ((how = *tstr)) {
2661                     case '+':
2662                     case '?':
2663                     case '!':
2664                         cp = &tstr[2];
2665                         break;
2666                     default:
2667                         cp = ++tstr;
2668                         break;
2669                     }
2670                     delim = startc == PROPEN ? PRCLOSE : BRCLOSE;
2671                     pattern.flags = 0;
2672
2673                     vflags = (flags & VARF_WANTRES) ? 0 : VAR_NOSUBST;
2674                     pattern.rhs = VarGetPattern(ctxt, &parsestate, flags,
2675                                                 &cp, delim, &vflags,
2676                                                 &pattern.rightLen,
2677                                                 NULL);
2678                     if (v->flags & VAR_JUNK) {
2679                         /* restore original name */
2680                         free(v->name);
2681                         v->name = sv_name;
2682                     }
2683                     if (pattern.rhs == NULL)
2684                         goto cleanup;
2685
2686                     termc = *--cp;
2687                     delim = '\0';
2688
2689                     if (flags & VARF_WANTRES) {
2690                         switch (how) {
2691                         case '+':
2692                             Var_Append(v->name, pattern.rhs, v_ctxt);
2693                             break;
2694                         case '!':
2695                             newStr = Cmd_Exec(pattern.rhs, &emsg);
2696                             if (emsg)
2697                                 Error(emsg, nstr);
2698                             else
2699                                 Var_Set(v->name, newStr,  v_ctxt, 0);
2700                             free(newStr);
2701                             break;
2702                         case '?':
2703                             if ((v->flags & VAR_JUNK) == 0)
2704                                 break;
2705                             /* FALLTHROUGH */
2706                         default:
2707                             Var_Set(v->name, pattern.rhs, v_ctxt, 0);
2708                             break;
2709                         }
2710                     }
2711                     free(UNCONST(pattern.rhs));
2712                     newStr = varNoError;
2713                     break;
2714                 }
2715                 goto default_case; /* "::<unrecognised>" */
2716             }
2717         case '@':
2718             {
2719                 VarLoop_t       loop;
2720                 int vflags = VAR_NOSUBST;
2721
2722                 cp = ++tstr;
2723                 delim = '@';
2724                 if ((loop.tvar = VarGetPattern(ctxt, &parsestate, flags,
2725                                                &cp, delim,
2726                                                &vflags, &loop.tvarLen,
2727                                                NULL)) == NULL)
2728                     goto cleanup;
2729
2730                 if ((loop.str = VarGetPattern(ctxt, &parsestate, flags,
2731                                               &cp, delim,
2732                                               &vflags, &loop.strLen,
2733                                               NULL)) == NULL)
2734                     goto cleanup;
2735
2736                 termc = *cp;
2737                 delim = '\0';
2738
2739                 loop.errnum = flags & VARF_UNDEFERR;
2740                 loop.ctxt = ctxt;
2741                 newStr = VarModify(ctxt, &parsestate, nstr, VarLoopExpand,
2742                                    &loop);
2743                 Var_Delete(loop.tvar, ctxt);
2744                 free(loop.tvar);
2745                 free(loop.str);
2746                 break;
2747             }
2748         case '_':                       /* remember current value */
2749             cp = tstr + 1;      /* make sure it is set */
2750             if (STRMOD_MATCHX(tstr, "_", 1)) {
2751                 if (tstr[1] == '=') {
2752                     char *np;
2753                     int n;
2754
2755                     cp++;
2756                     n = strcspn(cp, ":)}");
2757                     np = bmake_strndup(cp, n+1);
2758                     np[n] = '\0';
2759                     cp = tstr + 2 + n;
2760                     Var_Set(np, nstr, ctxt, 0);
2761                     free(np);
2762                 } else {
2763                     Var_Set("_", nstr, ctxt, 0);
2764                 }
2765                 newStr = nstr;
2766                 termc = *cp;
2767                 break;
2768             }
2769             goto default_case;
2770         case 'D':
2771         case 'U':
2772             {
2773                 Buffer  buf;            /* Buffer for patterns */
2774                 int     nflags;
2775
2776                 if (flags & VARF_WANTRES) {
2777                     int wantres;
2778                     if (*tstr == 'U')
2779                         wantres = ((v->flags & VAR_JUNK) != 0);
2780                     else
2781                         wantres = ((v->flags & VAR_JUNK) == 0);
2782                     nflags = flags & ~VARF_WANTRES;
2783                     if (wantres)
2784                         nflags |= VARF_WANTRES;
2785                 } else
2786                     nflags = flags;
2787                 /*
2788                  * Pass through tstr looking for 1) escaped delimiters,
2789                  * '$'s and backslashes (place the escaped character in
2790                  * uninterpreted) and 2) unescaped $'s that aren't before
2791                  * the delimiter (expand the variable substitution).
2792                  * The result is left in the Buffer buf.
2793                  */
2794                 Buf_Init(&buf, 0);
2795                 for (cp = tstr + 1;
2796                      *cp != endc && *cp != ':' && *cp != '\0';
2797                      cp++) {
2798                     if ((*cp == '\\') &&
2799                         ((cp[1] == ':') ||
2800                          (cp[1] == '$') ||
2801                          (cp[1] == endc) ||
2802                          (cp[1] == '\\')))
2803                         {
2804                             Buf_AddByte(&buf, cp[1]);
2805                             cp++;
2806                         } else if (*cp == '$') {
2807                             /*
2808                              * If unescaped dollar sign, assume it's a
2809                              * variable substitution and recurse.
2810                              */
2811                             char    *cp2;
2812                             int     len;
2813                             void    *freeIt;
2814
2815                             cp2 = Var_Parse(cp, ctxt, nflags, &len, &freeIt);
2816                             Buf_AddBytes(&buf, strlen(cp2), cp2);
2817                             free(freeIt);
2818                             cp += len - 1;
2819                         } else {
2820                             Buf_AddByte(&buf, *cp);
2821                         }
2822                 }
2823
2824                 termc = *cp;
2825
2826                 if ((v->flags & VAR_JUNK) != 0)
2827                     v->flags |= VAR_KEEP;
2828                 if (nflags & VARF_WANTRES) {
2829                     newStr = Buf_Destroy(&buf, FALSE);
2830                 } else {
2831                     newStr = nstr;
2832                     Buf_Destroy(&buf, TRUE);
2833                 }
2834                 break;
2835             }
2836         case 'L':
2837             {
2838                 if ((v->flags & VAR_JUNK) != 0)
2839                     v->flags |= VAR_KEEP;
2840                 newStr = bmake_strdup(v->name);
2841                 cp = ++tstr;
2842                 termc = *tstr;
2843                 break;
2844             }
2845         case 'P':
2846             {
2847                 GNode *gn;
2848
2849                 if ((v->flags & VAR_JUNK) != 0)
2850                     v->flags |= VAR_KEEP;
2851                 gn = Targ_FindNode(v->name, TARG_NOCREATE);
2852                 if (gn == NULL || gn->type & OP_NOPATH) {
2853                     newStr = NULL;
2854                 } else if (gn->path) {
2855                     newStr = bmake_strdup(gn->path);
2856                 } else {
2857                     newStr = Dir_FindFile(v->name, Suff_FindPath(gn));
2858                 }
2859                 if (!newStr) {
2860                     newStr = bmake_strdup(v->name);
2861                 }
2862                 cp = ++tstr;
2863                 termc = *tstr;
2864                 break;
2865             }
2866         case '!':
2867             {
2868                 const char *emsg;
2869                 VarPattern          pattern;
2870                 pattern.flags = 0;
2871
2872                 delim = '!';
2873                 emsg = NULL;
2874                 cp = ++tstr;
2875                 if ((pattern.rhs = VarGetPattern(ctxt, &parsestate, flags,
2876                                                  &cp, delim,
2877                                                  NULL, &pattern.rightLen,
2878                                                  NULL)) == NULL)
2879                     goto cleanup;
2880                 if (flags & VARF_WANTRES)
2881                     newStr = Cmd_Exec(pattern.rhs, &emsg);
2882                 else
2883                     newStr = varNoError;
2884                 free(UNCONST(pattern.rhs));
2885                 if (emsg)
2886                     Error(emsg, nstr);
2887                 termc = *cp;
2888                 delim = '\0';
2889                 if (v->flags & VAR_JUNK) {
2890                     v->flags |= VAR_KEEP;
2891                 }
2892                 break;
2893             }
2894         case '[':
2895             {
2896                 /*
2897                  * Look for the closing ']', recursively
2898                  * expanding any embedded variables.
2899                  *
2900                  * estr is a pointer to the expanded result,
2901                  * which we must free().
2902                  */
2903                 char *estr;
2904
2905                 cp = tstr+1; /* point to char after '[' */
2906                 delim = ']'; /* look for closing ']' */
2907                 estr = VarGetPattern(ctxt, &parsestate,
2908                                      flags, &cp, delim,
2909                                      NULL, NULL, NULL);
2910                 if (estr == NULL)
2911                     goto cleanup; /* report missing ']' */
2912                 /* now cp points just after the closing ']' */
2913                 delim = '\0';
2914                 if (cp[0] != ':' && cp[0] != endc) {
2915                     /* Found junk after ']' */
2916                     free(estr);
2917                     goto bad_modifier;
2918                 }
2919                 if (estr[0] == '\0') {
2920                     /* Found empty square brackets in ":[]". */
2921                     free(estr);
2922                     goto bad_modifier;
2923                 } else if (estr[0] == '#' && estr[1] == '\0') {
2924                     /* Found ":[#]" */
2925
2926                     /*
2927                      * We will need enough space for the decimal
2928                      * representation of an int.  We calculate the
2929                      * space needed for the octal representation,
2930                      * and add enough slop to cope with a '-' sign
2931                      * (which should never be needed) and a '\0'
2932                      * string terminator.
2933                      */
2934                     int newStrSize =
2935                         (sizeof(int) * CHAR_BIT + 2) / 3 + 2;
2936
2937                     newStr = bmake_malloc(newStrSize);
2938                     if (parsestate.oneBigWord) {
2939                         strncpy(newStr, "1", newStrSize);
2940                     } else {
2941                         /* XXX: brk_string() is a rather expensive
2942                          * way of counting words. */
2943                         char **av;
2944                         char *as;
2945                         int ac;
2946
2947                         av = brk_string(nstr, &ac, FALSE, &as);
2948                         snprintf(newStr, newStrSize,  "%d", ac);
2949                         free(as);
2950                         free(av);
2951                     }
2952                     termc = *cp;
2953                     free(estr);
2954                     break;
2955                 } else if (estr[0] == '*' && estr[1] == '\0') {
2956                     /* Found ":[*]" */
2957                     parsestate.oneBigWord = TRUE;
2958                     newStr = nstr;
2959                     termc = *cp;
2960                     free(estr);
2961                     break;
2962                 } else if (estr[0] == '@' && estr[1] == '\0') {
2963                     /* Found ":[@]" */
2964                     parsestate.oneBigWord = FALSE;
2965                     newStr = nstr;
2966                     termc = *cp;
2967                     free(estr);
2968                     break;
2969                 } else {
2970                     /*
2971                      * We expect estr to contain a single
2972                      * integer for :[N], or two integers
2973                      * separated by ".." for :[start..end].
2974                      */
2975                     VarSelectWords_t seldata = { 0, 0 };
2976
2977                     seldata.start = strtol(estr, &ep, 0);
2978                     if (ep == estr) {
2979                         /* Found junk instead of a number */
2980                         free(estr);
2981                         goto bad_modifier;
2982                     } else if (ep[0] == '\0') {
2983                         /* Found only one integer in :[N] */
2984                         seldata.end = seldata.start;
2985                     } else if (ep[0] == '.' && ep[1] == '.' &&
2986                                ep[2] != '\0') {
2987                         /* Expecting another integer after ".." */
2988                         ep += 2;
2989                         seldata.end = strtol(ep, &ep, 0);
2990                         if (ep[0] != '\0') {
2991                             /* Found junk after ".." */
2992                             free(estr);
2993                             goto bad_modifier;
2994                         }
2995                     } else {
2996                         /* Found junk instead of ".." */
2997                         free(estr);
2998                         goto bad_modifier;
2999                     }
3000                     /*
3001                      * Now seldata is properly filled in,
3002                      * but we still have to check for 0 as
3003                      * a special case.
3004                      */
3005                     if (seldata.start == 0 && seldata.end == 0) {
3006                         /* ":[0]" or perhaps ":[0..0]" */
3007                         parsestate.oneBigWord = TRUE;
3008                         newStr = nstr;
3009                         termc = *cp;
3010                         free(estr);
3011                         break;
3012                     } else if (seldata.start == 0 ||
3013                                seldata.end == 0) {
3014                         /* ":[0..N]" or ":[N..0]" */
3015                         free(estr);
3016                         goto bad_modifier;
3017                     }
3018                     /*
3019                      * Normal case: select the words
3020                      * described by seldata.
3021                      */
3022                     newStr = VarSelectWords(ctxt, &parsestate,
3023                                             nstr, &seldata);
3024
3025                     termc = *cp;
3026                     free(estr);
3027                     break;
3028                 }
3029
3030             }
3031         case 'g':
3032             cp = tstr + 1;      /* make sure it is set */
3033             if (STRMOD_MATCHX(tstr, "gmtime", 6)) {
3034                 if (tstr[6] == '=') {
3035                     utc = strtoul(&tstr[7], &ep, 10);
3036                     cp = ep;
3037                 } else {
3038                     utc = 0;
3039                     cp = tstr + 6;
3040                 }
3041                 newStr = VarStrftime(nstr, 1, utc);
3042                 termc = *cp;
3043             } else {
3044                 goto default_case;
3045             }
3046             break;
3047         case 'h':
3048             cp = tstr + 1;      /* make sure it is set */
3049             if (STRMOD_MATCH(tstr, "hash", 4)) {
3050                 newStr = VarHash(nstr);
3051                 cp = tstr + 4;
3052                 termc = *cp;
3053             } else {
3054                 goto default_case;
3055             }
3056             break;
3057         case 'l':
3058             cp = tstr + 1;      /* make sure it is set */
3059             if (STRMOD_MATCHX(tstr, "localtime", 9)) {
3060                 if (tstr[9] == '=') {
3061                     utc = strtoul(&tstr[10], &ep, 10);
3062                     cp = ep;
3063                 } else {
3064                     utc = 0;
3065                     cp = tstr + 9;
3066                 }
3067                 newStr = VarStrftime(nstr, 0, utc);
3068                 termc = *cp;
3069             } else {
3070                 goto default_case;
3071             }
3072             break;
3073         case 't':
3074             {
3075                 cp = tstr + 1;  /* make sure it is set */
3076                 if (tstr[1] != endc && tstr[1] != ':') {
3077                     if (tstr[1] == 's') {
3078                         /*
3079                          * Use the char (if any) at tstr[2]
3080                          * as the word separator.
3081                          */
3082                         VarPattern pattern;
3083
3084                         if (tstr[2] != endc &&
3085                             (tstr[3] == endc || tstr[3] == ':')) {
3086                             /* ":ts<unrecognised><endc>" or
3087                              * ":ts<unrecognised>:" */
3088                             parsestate.varSpace = tstr[2];
3089                             cp = tstr + 3;
3090                         } else if (tstr[2] == endc || tstr[2] == ':') {
3091                             /* ":ts<endc>" or ":ts:" */
3092                             parsestate.varSpace = 0; /* no separator */
3093                             cp = tstr + 2;
3094                         } else if (tstr[2] == '\\') {
3095                             const char *xp = &tstr[3];
3096                             int base = 8; /* assume octal */
3097
3098                             switch (tstr[3]) {
3099                             case 'n':
3100                                 parsestate.varSpace = '\n';
3101                                 cp = tstr + 4;
3102                                 break;
3103                             case 't':
3104                                 parsestate.varSpace = '\t';
3105                                 cp = tstr + 4;
3106                                 break;
3107                             case 'x':
3108                                 base = 16;
3109                                 xp++;
3110                                 goto get_numeric;
3111                             case '0':
3112                                 base = 0;
3113                                 goto get_numeric;
3114                             default:
3115                                 if (isdigit((unsigned char)tstr[3])) {
3116
3117                                 get_numeric:
3118                                     parsestate.varSpace =
3119                                         strtoul(xp, &ep, base);
3120                                     if (*ep != ':' && *ep != endc)
3121                                         goto bad_modifier;
3122                                     cp = ep;
3123                                 } else {
3124                                     /*
3125                                      * ":ts<backslash><unrecognised>".
3126                                      */
3127                                     goto bad_modifier;
3128                                 }
3129                                 break;
3130                             }
3131                         } else {
3132                             /*
3133                              * Found ":ts<unrecognised><unrecognised>".
3134                              */
3135                             goto bad_modifier;
3136                         }
3137
3138                         termc = *cp;
3139
3140                         /*
3141                          * We cannot be certain that VarModify
3142                          * will be used - even if there is a
3143                          * subsequent modifier, so do a no-op
3144                          * VarSubstitute now to for str to be
3145                          * re-expanded without the spaces.
3146                          */
3147                         pattern.flags = VAR_SUB_ONE;
3148                         pattern.lhs = pattern.rhs = "\032";
3149                         pattern.leftLen = pattern.rightLen = 1;
3150
3151                         newStr = VarModify(ctxt, &parsestate, nstr,
3152                                            VarSubstitute,
3153                                            &pattern);
3154                     } else if (tstr[2] == endc || tstr[2] == ':') {
3155                         /*
3156                          * Check for two-character options:
3157                          * ":tu", ":tl"
3158                          */
3159                         if (tstr[1] == 'A') { /* absolute path */
3160                             newStr = VarModify(ctxt, &parsestate, nstr,
3161                                                VarRealpath, NULL);
3162                             cp = tstr + 2;
3163                             termc = *cp;
3164                         } else if (tstr[1] == 'u') {
3165                             char *dp = bmake_strdup(nstr);
3166                             for (newStr = dp; *dp; dp++)
3167                                 *dp = toupper((unsigned char)*dp);
3168                             cp = tstr + 2;
3169                             termc = *cp;
3170                         } else if (tstr[1] == 'l') {
3171                             char *dp = bmake_strdup(nstr);
3172                             for (newStr = dp; *dp; dp++)
3173                                 *dp = tolower((unsigned char)*dp);
3174                             cp = tstr + 2;
3175                             termc = *cp;
3176                         } else if (tstr[1] == 'W' || tstr[1] == 'w') {
3177                             parsestate.oneBigWord = (tstr[1] == 'W');
3178                             newStr = nstr;
3179                             cp = tstr + 2;
3180                             termc = *cp;
3181                         } else {
3182                             /* Found ":t<unrecognised>:" or
3183                              * ":t<unrecognised><endc>". */
3184                             goto bad_modifier;
3185                         }
3186                     } else {
3187                         /*
3188                          * Found ":t<unrecognised><unrecognised>".
3189                          */
3190                         goto bad_modifier;
3191                     }
3192                 } else {
3193                     /*
3194                      * Found ":t<endc>" or ":t:".
3195                      */
3196                     goto bad_modifier;
3197                 }
3198                 break;
3199             }
3200         case 'N':
3201         case 'M':
3202             {
3203                 char    *pattern;
3204                 const char *endpat; /* points just after end of pattern */
3205                 char    *cp2;
3206                 Boolean copy;   /* pattern should be, or has been, copied */
3207                 Boolean needSubst;
3208                 int nest;
3209
3210                 copy = FALSE;
3211                 needSubst = FALSE;
3212                 nest = 1;
3213                 /*
3214                  * In the loop below, ignore ':' unless we are at
3215                  * (or back to) the original brace level.
3216                  * XXX This will likely not work right if $() and ${}
3217                  * are intermixed.
3218                  */
3219                 for (cp = tstr + 1;
3220                      *cp != '\0' && !(*cp == ':' && nest == 1);
3221                      cp++)
3222                     {
3223                         if (*cp == '\\' &&
3224                             (cp[1] == ':' ||
3225                              cp[1] == endc || cp[1] == startc)) {
3226                             if (!needSubst) {
3227                                 copy = TRUE;
3228                             }
3229                             cp++;
3230                             continue;
3231                         }
3232                         if (*cp == '$') {
3233                             needSubst = TRUE;
3234                         }
3235                         if (*cp == '(' || *cp == '{')
3236                             ++nest;
3237                         if (*cp == ')' || *cp == '}') {
3238                             --nest;
3239                             if (nest == 0)
3240                                 break;
3241                         }
3242                     }
3243                 termc = *cp;
3244                 endpat = cp;
3245                 if (copy) {
3246                     /*
3247                      * Need to compress the \:'s out of the pattern, so
3248                      * allocate enough room to hold the uncompressed
3249                      * pattern (note that cp started at tstr+1, so
3250                      * cp - tstr takes the null byte into account) and
3251                      * compress the pattern into the space.
3252                      */
3253                     pattern = bmake_malloc(cp - tstr);
3254                     for (cp2 = pattern, cp = tstr + 1;
3255                          cp < endpat;
3256                          cp++, cp2++)
3257                         {
3258                             if ((*cp == '\\') && (cp+1 < endpat) &&
3259                                 (cp[1] == ':' || cp[1] == endc)) {
3260                                 cp++;
3261                             }
3262                             *cp2 = *cp;
3263                         }
3264                     *cp2 = '\0';
3265                     endpat = cp2;
3266                 } else {
3267                     /*
3268                      * Either Var_Subst or VarModify will need a
3269                      * nul-terminated string soon, so construct one now.
3270                      */
3271                     pattern = bmake_strndup(tstr+1, endpat - (tstr + 1));
3272                 }
3273                 if (needSubst) {
3274                     /*
3275                      * pattern contains embedded '$', so use Var_Subst to
3276                      * expand it.
3277                      */
3278                     cp2 = pattern;
3279                     pattern = Var_Subst(NULL, cp2, ctxt, flags | VARF_WANTRES);
3280                     free(cp2);
3281                 }
3282                 if (DEBUG(VAR))
3283                     fprintf(debug_file, "Pattern[%s] for [%s] is [%s]\n",
3284                         v->name, nstr, pattern);
3285                 if (*tstr == 'M') {
3286                     newStr = VarModify(ctxt, &parsestate, nstr, VarMatch,
3287                                        pattern);
3288                 } else {
3289                     newStr = VarModify(ctxt, &parsestate, nstr, VarNoMatch,
3290                                        pattern);
3291                 }
3292                 free(pattern);
3293                 break;
3294             }
3295         case 'S':
3296             {
3297                 VarPattern          pattern;
3298                 Var_Parse_State tmpparsestate;
3299
3300                 pattern.flags = 0;
3301                 tmpparsestate = parsestate;
3302                 delim = tstr[1];
3303                 tstr += 2;
3304
3305                 /*
3306                  * If pattern begins with '^', it is anchored to the
3307                  * start of the word -- skip over it and flag pattern.
3308                  */
3309                 if (*tstr == '^') {
3310                     pattern.flags |= VAR_MATCH_START;
3311                     tstr += 1;
3312                 }
3313
3314                 cp = tstr;
3315                 if ((pattern.lhs = VarGetPattern(ctxt, &parsestate, flags,
3316                                                  &cp, delim,
3317                                                  &pattern.flags,
3318                                                  &pattern.leftLen,
3319                                                  NULL)) == NULL)
3320                     goto cleanup;
3321
3322                 if ((pattern.rhs = VarGetPattern(ctxt, &parsestate, flags,
3323                                                  &cp, delim, NULL,
3324                                                  &pattern.rightLen,
3325                                                  &pattern)) == NULL)
3326                     goto cleanup;
3327
3328                 /*
3329                  * Check for global substitution. If 'g' after the final
3330                  * delimiter, substitution is global and is marked that
3331                  * way.
3332                  */
3333                 for (;; cp++) {
3334                     switch (*cp) {
3335                     case 'g':
3336                         pattern.flags |= VAR_SUB_GLOBAL;
3337                         continue;
3338                     case '1':
3339                         pattern.flags |= VAR_SUB_ONE;
3340                         continue;
3341                     case 'W':
3342                         tmpparsestate.oneBigWord = TRUE;
3343                         continue;
3344                     }
3345                     break;
3346                 }
3347
3348                 termc = *cp;
3349                 newStr = VarModify(ctxt, &tmpparsestate, nstr,
3350                                    VarSubstitute,
3351                                    &pattern);
3352
3353                 /*
3354                  * Free the two strings.
3355                  */
3356                 free(UNCONST(pattern.lhs));
3357                 free(UNCONST(pattern.rhs));
3358                 delim = '\0';
3359                 break;
3360             }
3361         case '?':
3362             {
3363                 VarPattern      pattern;
3364                 Boolean value;
3365                 int cond_rc;
3366                 int lhs_flags, rhs_flags;
3367
3368                 /* find ':', and then substitute accordingly */
3369                 if (flags & VARF_WANTRES) {
3370                     cond_rc = Cond_EvalExpression(NULL, v->name, &value, 0, FALSE);
3371                     if (cond_rc == COND_INVALID) {
3372                         lhs_flags = rhs_flags = VAR_NOSUBST;
3373                     } else if (value) {
3374                         lhs_flags = 0;
3375                         rhs_flags = VAR_NOSUBST;
3376                     } else {
3377                         lhs_flags = VAR_NOSUBST;
3378                         rhs_flags = 0;
3379                     }
3380                 } else {
3381                     /* we are just consuming and discarding */
3382                     cond_rc = value = 0;
3383                     lhs_flags = rhs_flags = VAR_NOSUBST;
3384                 }
3385                 pattern.flags = 0;
3386
3387                 cp = ++tstr;
3388                 delim = ':';
3389                 if ((pattern.lhs = VarGetPattern(ctxt, &parsestate, flags,
3390                                                  &cp, delim, &lhs_flags,
3391                                                  &pattern.leftLen,
3392                                                  NULL)) == NULL)
3393                     goto cleanup;
3394
3395                 /* BROPEN or PROPEN */
3396                 delim = endc;
3397                 if ((pattern.rhs = VarGetPattern(ctxt, &parsestate, flags,
3398                                                  &cp, delim, &rhs_flags,
3399                                                  &pattern.rightLen,
3400                                                  NULL)) == NULL)
3401                     goto cleanup;
3402
3403                 termc = *--cp;
3404                 delim = '\0';
3405                 if (cond_rc == COND_INVALID) {
3406                     Error("Bad conditional expression `%s' in %s?%s:%s",
3407                           v->name, v->name, pattern.lhs, pattern.rhs);
3408                     goto cleanup;
3409                 }
3410
3411                 if (value) {
3412                     newStr = UNCONST(pattern.lhs);
3413                     free(UNCONST(pattern.rhs));
3414                 } else {
3415                     newStr = UNCONST(pattern.rhs);
3416                     free(UNCONST(pattern.lhs));
3417                 }
3418                 if (v->flags & VAR_JUNK) {
3419                     v->flags |= VAR_KEEP;
3420                 }
3421                 break;
3422             }
3423 #ifndef NO_REGEX
3424         case 'C':
3425             {
3426                 VarREPattern    pattern;
3427                 char           *re;
3428                 int             error;
3429                 Var_Parse_State tmpparsestate;
3430
3431                 pattern.flags = 0;
3432                 tmpparsestate = parsestate;
3433                 delim = tstr[1];
3434                 tstr += 2;
3435
3436                 cp = tstr;
3437
3438                 if ((re = VarGetPattern(ctxt, &parsestate, flags, &cp, delim,
3439                                         NULL, NULL, NULL)) == NULL)
3440                     goto cleanup;
3441
3442                 if ((pattern.replace = VarGetPattern(ctxt, &parsestate,
3443                                                      flags, &cp, delim, NULL,
3444                                                      NULL, NULL)) == NULL){
3445                     free(re);
3446                     goto cleanup;
3447                 }
3448
3449                 for (;; cp++) {
3450                     switch (*cp) {
3451                     case 'g':
3452                         pattern.flags |= VAR_SUB_GLOBAL;
3453                         continue;
3454                     case '1':
3455                         pattern.flags |= VAR_SUB_ONE;
3456                         continue;
3457                     case 'W':
3458                         tmpparsestate.oneBigWord = TRUE;
3459                         continue;
3460                     }
3461                     break;
3462                 }
3463
3464                 termc = *cp;
3465
3466                 error = regcomp(&pattern.re, re, REG_EXTENDED);
3467                 free(re);
3468                 if (error)  {
3469                     *lengthPtr = cp - start + 1;
3470                     VarREError(error, &pattern.re, "RE substitution error");
3471                     free(pattern.replace);
3472                     goto cleanup;
3473                 }
3474
3475                 pattern.nsub = pattern.re.re_nsub + 1;
3476                 if (pattern.nsub < 1)
3477                     pattern.nsub = 1;
3478                 if (pattern.nsub > 10)
3479                     pattern.nsub = 10;
3480                 pattern.matches = bmake_malloc(pattern.nsub *
3481                                           sizeof(regmatch_t));
3482                 newStr = VarModify(ctxt, &tmpparsestate, nstr,
3483                                    VarRESubstitute,
3484                                    &pattern);
3485                 regfree(&pattern.re);
3486                 free(pattern.replace);
3487                 free(pattern.matches);
3488                 delim = '\0';
3489                 break;
3490             }
3491 #endif
3492         case 'q':
3493         case 'Q':
3494             if (tstr[1] == endc || tstr[1] == ':') {
3495                 newStr = VarQuote(nstr, modifier == 'q');
3496                 cp = tstr + 1;
3497                 termc = *cp;
3498                 break;
3499             }
3500             goto default_case;
3501         case 'T':
3502             if (tstr[1] == endc || tstr[1] == ':') {
3503                 newStr = VarModify(ctxt, &parsestate, nstr, VarTail,
3504                                    NULL);
3505                 cp = tstr + 1;
3506                 termc = *cp;
3507                 break;
3508             }
3509             goto default_case;
3510         case 'H':
3511             if (tstr[1] == endc || tstr[1] == ':') {
3512                 newStr = VarModify(ctxt, &parsestate, nstr, VarHead,
3513                                    NULL);
3514                 cp = tstr + 1;
3515                 termc = *cp;
3516                 break;
3517             }
3518             goto default_case;
3519         case 'E':
3520             if (tstr[1] == endc || tstr[1] == ':') {
3521                 newStr = VarModify(ctxt, &parsestate, nstr, VarSuffix,
3522                                    NULL);
3523                 cp = tstr + 1;
3524                 termc = *cp;
3525                 break;
3526             }
3527             goto default_case;
3528         case 'R':
3529             if (tstr[1] == endc || tstr[1] == ':') {
3530                 newStr = VarModify(ctxt, &parsestate, nstr, VarRoot,
3531                                    NULL);
3532                 cp = tstr + 1;
3533                 termc = *cp;
3534                 break;
3535             }
3536             goto default_case;
3537         case 'r':
3538             cp = tstr + 1;      /* make sure it is set */
3539             if (STRMOD_MATCHX(tstr, "range", 5)) {
3540                 int n;
3541
3542                 if (tstr[5] == '=') {
3543                     n = strtoul(&tstr[6], &ep, 10);
3544                     cp = ep;
3545                 } else {
3546                     n = 0;
3547                     cp = tstr + 5;
3548                 }
3549                 newStr = VarRange(nstr, n);
3550                 termc = *cp;
3551                 break;
3552             }
3553             goto default_case;
3554         case 'O':
3555             {
3556                 char otype;
3557
3558                 cp = tstr + 1;  /* skip to the rest in any case */
3559                 if (tstr[1] == endc || tstr[1] == ':') {
3560                     otype = 's';
3561                     termc = *cp;
3562                 } else if ( (tstr[1] == 'x') &&
3563                             (tstr[2] == endc || tstr[2] == ':') ) {
3564                     otype = tstr[1];
3565                     cp = tstr + 2;
3566                     termc = *cp;
3567                 } else {
3568                     goto bad_modifier;
3569                 }
3570                 newStr = VarOrder(nstr, otype);
3571                 break;
3572             }
3573         case 'u':
3574             if (tstr[1] == endc || tstr[1] == ':') {
3575                 newStr = VarUniq(nstr);
3576                 cp = tstr + 1;
3577                 termc = *cp;
3578                 break;
3579             }
3580             goto default_case;
3581 #ifdef SUNSHCMD
3582         case 's':
3583             if (tstr[1] == 'h' && (tstr[2] == endc || tstr[2] == ':')) {
3584                 const char *emsg;
3585                 if (flags & VARF_WANTRES) {
3586                     newStr = Cmd_Exec(nstr, &emsg);
3587                     if (emsg)
3588                         Error(emsg, nstr);
3589                 } else
3590                     newStr = varNoError;
3591                 cp = tstr + 2;
3592                 termc = *cp;
3593                 break;
3594             }
3595             goto default_case;
3596 #endif
3597         default:
3598         default_case:
3599         {
3600 #ifdef SYSVVARSUB
3601             /*
3602              * This can either be a bogus modifier or a System-V
3603              * substitution command.
3604              */
3605             VarPattern      pattern;
3606             Boolean         eqFound;
3607
3608             pattern.flags = 0;
3609             eqFound = FALSE;
3610             /*
3611              * First we make a pass through the string trying
3612              * to verify it is a SYSV-make-style translation:
3613              * it must be: <string1>=<string2>)
3614              */
3615             cp = tstr;
3616             cnt = 1;
3617             while (*cp != '\0' && cnt) {
3618                 if (*cp == '=') {
3619                     eqFound = TRUE;
3620                     /* continue looking for endc */
3621                 }
3622                 else if (*cp == endc)
3623                     cnt--;
3624                 else if (*cp == startc)
3625                     cnt++;
3626                 if (cnt)
3627                     cp++;
3628             }
3629             if (*cp == endc && eqFound) {
3630
3631                 /*
3632                  * Now we break this sucker into the lhs and
3633                  * rhs. We must null terminate them of course.
3634                  */
3635                 delim='=';
3636                 cp = tstr;
3637                 if ((pattern.lhs = VarGetPattern(ctxt, &parsestate,
3638                                                  flags, &cp, delim, &pattern.flags,
3639                                                  &pattern.leftLen, NULL)) == NULL)
3640                     goto cleanup;
3641                 delim = endc;
3642                 if ((pattern.rhs = VarGetPattern(ctxt, &parsestate,
3643                                                  flags, &cp, delim, NULL, &pattern.rightLen,
3644                                                  &pattern)) == NULL)
3645                     goto cleanup;
3646
3647                 /*
3648                  * SYSV modifications happen through the whole
3649                  * string. Note the pattern is anchored at the end.
3650                  */
3651                 termc = *--cp;
3652                 delim = '\0';
3653                 if (pattern.leftLen == 0 && *nstr == '\0') {
3654                     newStr = nstr;      /* special case */
3655                 } else {
3656                     newStr = VarModify(ctxt, &parsestate, nstr,
3657                                        VarSYSVMatch,
3658                                        &pattern);
3659                 }
3660                 free(UNCONST(pattern.lhs));
3661                 free(UNCONST(pattern.rhs));
3662             } else
3663 #endif
3664                 {
3665                     Error("Unknown modifier '%c'", *tstr);
3666                     for (cp = tstr+1;
3667                          *cp != ':' && *cp != endc && *cp != '\0';
3668                          cp++)
3669                         continue;
3670                     termc = *cp;
3671                     newStr = var_Error;
3672                 }
3673             }
3674         }
3675         if (DEBUG(VAR)) {
3676             fprintf(debug_file, "Result[%s] of :%c is \"%s\"\n",
3677                 v->name, modifier, newStr);
3678         }
3679
3680         if (newStr != nstr) {
3681             if (*freePtr) {
3682                 free(nstr);
3683                 *freePtr = NULL;
3684             }
3685             nstr = newStr;
3686             if (nstr != var_Error && nstr != varNoError) {
3687                 *freePtr = nstr;
3688             }
3689         }
3690         if (termc == '\0' && endc != '\0') {
3691             Error("Unclosed variable specification (expecting '%c') for \"%s\" (value \"%s\") modifier %c", endc, v->name, nstr, modifier);
3692         } else if (termc == ':') {
3693             cp++;
3694         }
3695         tstr = cp;
3696     }
3697  out:
3698     *lengthPtr = tstr - start;
3699     return (nstr);
3700
3701  bad_modifier:
3702     /* "{(" */
3703     Error("Bad modifier `:%.*s' for %s", (int)strcspn(tstr, ":)}"), tstr,
3704           v->name);
3705
3706  cleanup:
3707     *lengthPtr = cp - start;
3708     if (delim != '\0')
3709         Error("Unclosed substitution for %s (%c missing)",
3710               v->name, delim);
3711     free(*freePtr);
3712     *freePtr = NULL;
3713     return (var_Error);
3714 }
3715
3716 /*-
3717  *-----------------------------------------------------------------------
3718  * Var_Parse --
3719  *      Given the start of a variable invocation, extract the variable
3720  *      name and find its value, then modify it according to the
3721  *      specification.
3722  *
3723  * Input:
3724  *      str             The string to parse
3725  *      ctxt            The context for the variable
3726  *      flags           VARF_UNDEFERR   if undefineds are an error
3727  *                      VARF_WANTRES    if we actually want the result
3728  *                      VARF_ASSIGN     if we are in a := assignment
3729  *      lengthPtr       OUT: The length of the specification
3730  *      freePtr         OUT: Non-NULL if caller should free *freePtr
3731  *
3732  * Results:
3733  *      The (possibly-modified) value of the variable or var_Error if the
3734  *      specification is invalid. The length of the specification is
3735  *      placed in *lengthPtr (for invalid specifications, this is just
3736  *      2...?).
3737  *      If *freePtr is non-NULL then it's a pointer that the caller
3738  *      should pass to free() to free memory used by the result.
3739  *
3740  * Side Effects:
3741  *      None.
3742  *
3743  *-----------------------------------------------------------------------
3744  */
3745 /* coverity[+alloc : arg-*4] */
3746 char *
3747 Var_Parse(const char *str, GNode *ctxt, int flags,
3748           int *lengthPtr, void **freePtr)
3749 {
3750     const char     *tstr;       /* Pointer into str */
3751     Var            *v;          /* Variable in invocation */
3752     Boolean         haveModifier;/* TRUE if have modifiers for the variable */
3753     char            endc;       /* Ending character when variable in parens
3754                                  * or braces */
3755     char            startc;     /* Starting character when variable in parens
3756                                  * or braces */
3757     int             vlen;       /* Length of variable name */
3758     const char     *start;      /* Points to original start of str */
3759     char           *nstr;       /* New string, used during expansion */
3760     Boolean         dynamic;    /* TRUE if the variable is local and we're
3761                                  * expanding it in a non-local context. This
3762                                  * is done to support dynamic sources. The
3763                                  * result is just the invocation, unaltered */
3764     const char     *extramodifiers; /* extra modifiers to apply first */
3765     char          name[2];
3766
3767     *freePtr = NULL;
3768     extramodifiers = NULL;
3769     dynamic = FALSE;
3770     start = str;
3771
3772     startc = str[1];
3773     if (startc != PROPEN && startc != BROPEN) {
3774         /*
3775          * If it's not bounded by braces of some sort, life is much simpler.
3776          * We just need to check for the first character and return the
3777          * value if it exists.
3778          */
3779
3780         /* Error out some really stupid names */
3781         if (startc == '\0' || strchr(")}:$", startc)) {
3782             *lengthPtr = 1;
3783             return var_Error;
3784         }
3785         name[0] = startc;
3786         name[1] = '\0';
3787
3788         v = VarFind(name, ctxt, FIND_ENV | FIND_GLOBAL | FIND_CMD);
3789         if (v == NULL) {
3790             *lengthPtr = 2;
3791
3792             if ((ctxt == VAR_CMD) || (ctxt == VAR_GLOBAL)) {
3793                 /*
3794                  * If substituting a local variable in a non-local context,
3795                  * assume it's for dynamic source stuff. We have to handle
3796                  * this specially and return the longhand for the variable
3797                  * with the dollar sign escaped so it makes it back to the
3798                  * caller. Only four of the local variables are treated
3799                  * specially as they are the only four that will be set
3800                  * when dynamic sources are expanded.
3801                  */
3802                 switch (str[1]) {
3803                     case '@':
3804                         return UNCONST("$(.TARGET)");
3805                     case '%':
3806                         return UNCONST("$(.MEMBER)");
3807                     case '*':
3808                         return UNCONST("$(.PREFIX)");
3809                     case '!':
3810                         return UNCONST("$(.ARCHIVE)");
3811                 }
3812             }
3813             /*
3814              * Error
3815              */
3816             return (flags & VARF_UNDEFERR) ? var_Error : varNoError;
3817         } else {
3818             haveModifier = FALSE;
3819             tstr = &str[1];
3820             endc = str[1];
3821         }
3822     } else {
3823         Buffer buf;     /* Holds the variable name */
3824         int depth = 1;
3825
3826         endc = startc == PROPEN ? PRCLOSE : BRCLOSE;
3827         Buf_Init(&buf, 0);
3828
3829         /*
3830          * Skip to the end character or a colon, whichever comes first.
3831          */
3832         for (tstr = str + 2; *tstr != '\0'; tstr++)
3833         {
3834             /*
3835              * Track depth so we can spot parse errors.
3836              */
3837             if (*tstr == startc) {
3838                 depth++;
3839             }
3840             if (*tstr == endc) {
3841                 if (--depth == 0)
3842                     break;
3843             }
3844             if (depth == 1 && *tstr == ':') {
3845                 break;
3846             }
3847             /*
3848              * A variable inside a variable, expand
3849              */
3850             if (*tstr == '$') {
3851                 int rlen;
3852                 void *freeIt;
3853                 char *rval = Var_Parse(tstr, ctxt, flags,  &rlen, &freeIt);
3854                 if (rval != NULL) {
3855                     Buf_AddBytes(&buf, strlen(rval), rval);
3856                 }
3857                 free(freeIt);
3858                 tstr += rlen - 1;
3859             }
3860             else
3861                 Buf_AddByte(&buf, *tstr);
3862         }
3863         if (*tstr == ':') {
3864             haveModifier = TRUE;
3865         } else if (*tstr == endc) {
3866             haveModifier = FALSE;
3867         } else {
3868             /*
3869              * If we never did find the end character, return NULL
3870              * right now, setting the length to be the distance to
3871              * the end of the string, since that's what make does.
3872              */
3873             *lengthPtr = tstr - str;
3874             Buf_Destroy(&buf, TRUE);
3875             return (var_Error);
3876         }
3877         str = Buf_GetAll(&buf, &vlen);
3878
3879         /*
3880          * At this point, str points into newly allocated memory from
3881          * buf, containing only the name of the variable.
3882          *
3883          * start and tstr point into the const string that was pointed
3884          * to by the original value of the str parameter.  start points
3885          * to the '$' at the beginning of the string, while tstr points
3886          * to the char just after the end of the variable name -- this
3887          * will be '\0', ':', PRCLOSE, or BRCLOSE.
3888          */
3889
3890         v = VarFind(str, ctxt, FIND_ENV | FIND_GLOBAL | FIND_CMD);
3891         /*
3892          * Check also for bogus D and F forms of local variables since we're
3893          * in a local context and the name is the right length.
3894          */
3895         if ((v == NULL) && (ctxt != VAR_CMD) && (ctxt != VAR_GLOBAL) &&
3896                 (vlen == 2) && (str[1] == 'F' || str[1] == 'D') &&
3897                 strchr("@%?*!<>", str[0]) != NULL) {
3898             /*
3899              * Well, it's local -- go look for it.
3900              */
3901             name[0] = *str;
3902             name[1] = '\0';
3903             v = VarFind(name, ctxt, 0);
3904
3905             if (v != NULL) {
3906                 if (str[1] == 'D') {
3907                         extramodifiers = "H:";
3908                 }
3909                 else { /* F */
3910                         extramodifiers = "T:";
3911                 }
3912             }
3913         }
3914
3915         if (v == NULL) {
3916             if (((vlen == 1) ||
3917                  (((vlen == 2) && (str[1] == 'F' || str[1] == 'D')))) &&
3918                 ((ctxt == VAR_CMD) || (ctxt == VAR_GLOBAL)))
3919             {
3920                 /*
3921                  * If substituting a local variable in a non-local context,
3922                  * assume it's for dynamic source stuff. We have to handle
3923                  * this specially and return the longhand for the variable
3924                  * with the dollar sign escaped so it makes it back to the
3925                  * caller. Only four of the local variables are treated
3926                  * specially as they are the only four that will be set
3927                  * when dynamic sources are expanded.
3928                  */
3929                 switch (*str) {
3930                     case '@':
3931                     case '%':
3932                     case '*':
3933                     case '!':
3934                         dynamic = TRUE;
3935                         break;
3936                 }
3937             } else if ((vlen > 2) && (*str == '.') &&
3938                        isupper((unsigned char) str[1]) &&
3939                        ((ctxt == VAR_CMD) || (ctxt == VAR_GLOBAL)))
3940             {
3941                 int     len;
3942
3943                 len = vlen - 1;
3944                 if ((strncmp(str, ".TARGET", len) == 0) ||
3945                     (strncmp(str, ".ARCHIVE", len) == 0) ||
3946                     (strncmp(str, ".PREFIX", len) == 0) ||
3947                     (strncmp(str, ".MEMBER", len) == 0))
3948                 {
3949                     dynamic = TRUE;
3950                 }
3951             }
3952
3953             if (!haveModifier) {
3954                 /*
3955                  * No modifiers -- have specification length so we can return
3956                  * now.
3957                  */
3958                 *lengthPtr = tstr - start + 1;
3959                 if (dynamic) {
3960                     char *pstr = bmake_strndup(start, *lengthPtr);
3961                     *freePtr = pstr;
3962                     Buf_Destroy(&buf, TRUE);
3963                     return(pstr);
3964                 } else {
3965                     Buf_Destroy(&buf, TRUE);
3966                     return (flags & VARF_UNDEFERR) ? var_Error : varNoError;
3967                 }
3968             } else {
3969                 /*
3970                  * Still need to get to the end of the variable specification,
3971                  * so kludge up a Var structure for the modifications
3972                  */
3973                 v = bmake_malloc(sizeof(Var));
3974                 v->name = UNCONST(str);
3975                 Buf_Init(&v->val, 1);
3976                 v->flags = VAR_JUNK;
3977                 Buf_Destroy(&buf, FALSE);
3978             }
3979         } else
3980             Buf_Destroy(&buf, TRUE);
3981     }
3982
3983     if (v->flags & VAR_IN_USE) {
3984         Fatal("Variable %s is recursive.", v->name);
3985         /*NOTREACHED*/
3986     } else {
3987         v->flags |= VAR_IN_USE;
3988     }
3989     /*
3990      * Before doing any modification, we have to make sure the value
3991      * has been fully expanded. If it looks like recursion might be
3992      * necessary (there's a dollar sign somewhere in the variable's value)
3993      * we just call Var_Subst to do any other substitutions that are
3994      * necessary. Note that the value returned by Var_Subst will have
3995      * been dynamically-allocated, so it will need freeing when we
3996      * return.
3997      */
3998     nstr = Buf_GetAll(&v->val, NULL);
3999     if (strchr(nstr, '$') != NULL) {
4000         nstr = Var_Subst(NULL, nstr, ctxt, flags);
4001         *freePtr = nstr;
4002     }
4003
4004     v->flags &= ~VAR_IN_USE;
4005
4006     if ((nstr != NULL) && (haveModifier || extramodifiers != NULL)) {
4007         void *extraFree;
4008         int used;
4009
4010         extraFree = NULL;
4011         if (extramodifiers != NULL) {
4012                 nstr = ApplyModifiers(nstr, extramodifiers, '(', ')',
4013                                       v, ctxt, flags, &used, &extraFree);
4014         }
4015
4016         if (haveModifier) {
4017                 /* Skip initial colon. */
4018                 tstr++;
4019
4020                 nstr = ApplyModifiers(nstr, tstr, startc, endc,
4021                                       v, ctxt, flags, &used, freePtr);
4022                 tstr += used;
4023                 free(extraFree);
4024         } else {
4025                 *freePtr = extraFree;
4026         }
4027     }
4028     if (*tstr) {
4029         *lengthPtr = tstr - start + 1;
4030     } else {
4031         *lengthPtr = tstr - start;
4032     }
4033
4034     if (v->flags & VAR_FROM_ENV) {
4035         Boolean   destroy = FALSE;
4036
4037         if (nstr != Buf_GetAll(&v->val, NULL)) {
4038             destroy = TRUE;
4039         } else {
4040             /*
4041              * Returning the value unmodified, so tell the caller to free
4042              * the thing.
4043              */
4044             *freePtr = nstr;
4045         }
4046         VarFreeEnv(v, destroy);
4047     } else if (v->flags & VAR_JUNK) {
4048         /*
4049          * Perform any free'ing needed and set *freePtr to NULL so the caller
4050          * doesn't try to free a static pointer.
4051          * If VAR_KEEP is also set then we want to keep str as is.
4052          */
4053         if (!(v->flags & VAR_KEEP)) {
4054             if (*freePtr) {
4055                 free(nstr);
4056                 *freePtr = NULL;
4057             }
4058             if (dynamic) {
4059                 nstr = bmake_strndup(start, *lengthPtr);
4060                 *freePtr = nstr;
4061             } else {
4062                 nstr = (flags & VARF_UNDEFERR) ? var_Error : varNoError;
4063             }
4064         }
4065         if (nstr != Buf_GetAll(&v->val, NULL))
4066             Buf_Destroy(&v->val, TRUE);
4067         free(v->name);
4068         free(v);
4069     }
4070     return (nstr);
4071 }
4072
4073 /*-
4074  *-----------------------------------------------------------------------
4075  * Var_Subst  --
4076  *      Substitute for all variables in the given string in the given context
4077  *      If flags & VARF_UNDEFERR, Parse_Error will be called when an undefined
4078  *      variable is encountered.
4079  *
4080  * Input:
4081  *      var             Named variable || NULL for all
4082  *      str             the string which to substitute
4083  *      ctxt            the context wherein to find variables
4084  *      flags           VARF_UNDEFERR   if undefineds are an error
4085  *                      VARF_WANTRES    if we actually want the result
4086  *                      VARF_ASSIGN     if we are in a := assignment
4087  *
4088  * Results:
4089  *      The resulting string.
4090  *
4091  * Side Effects:
4092  *      None. The old string must be freed by the caller
4093  *-----------------------------------------------------------------------
4094  */
4095 char *
4096 Var_Subst(const char *var, const char *str, GNode *ctxt, int flags)
4097 {
4098     Buffer        buf;              /* Buffer for forming things */
4099     char          *val;             /* Value to substitute for a variable */
4100     int           length;           /* Length of the variable invocation */
4101     Boolean       trailingBslash;   /* variable ends in \ */
4102     void          *freeIt = NULL;    /* Set if it should be freed */
4103     static Boolean errorReported;   /* Set true if an error has already
4104                                      * been reported to prevent a plethora
4105                                      * of messages when recursing */
4106
4107     Buf_Init(&buf, 0);
4108     errorReported = FALSE;
4109     trailingBslash = FALSE;
4110
4111     while (*str) {
4112         if (*str == '\n' && trailingBslash)
4113             Buf_AddByte(&buf, ' ');
4114         if (var == NULL && (*str == '$') && (str[1] == '$')) {
4115             /*
4116              * A dollar sign may be escaped either with another dollar sign.
4117              * In such a case, we skip over the escape character and store the
4118              * dollar sign into the buffer directly.
4119              */
4120             if (save_dollars && (flags & VARF_ASSIGN))
4121                 Buf_AddByte(&buf, *str);
4122             str++;
4123             Buf_AddByte(&buf, *str);
4124             str++;
4125         } else if (*str != '$') {
4126             /*
4127              * Skip as many characters as possible -- either to the end of
4128              * the string or to the next dollar sign (variable invocation).
4129              */
4130             const char  *cp;
4131
4132             for (cp = str++; *str != '$' && *str != '\0'; str++)
4133                 continue;
4134             Buf_AddBytes(&buf, str - cp, cp);
4135         } else {
4136             if (var != NULL) {
4137                 int expand;
4138                 for (;;) {
4139                     if (str[1] == '\0') {
4140                         /* A trailing $ is kind of a special case */
4141                         Buf_AddByte(&buf, str[0]);
4142                         str++;
4143                         expand = FALSE;
4144                     } else if (str[1] != PROPEN && str[1] != BROPEN) {
4145                         if (str[1] != *var || strlen(var) > 1) {
4146                             Buf_AddBytes(&buf, 2, str);
4147                             str += 2;
4148                             expand = FALSE;
4149                         }
4150                         else
4151                             expand = TRUE;
4152                         break;
4153                     }
4154                     else {
4155                         const char *p;
4156
4157                         /*
4158                          * Scan up to the end of the variable name.
4159                          */
4160                         for (p = &str[2]; *p &&
4161                              *p != ':' && *p != PRCLOSE && *p != BRCLOSE; p++)
4162                             if (*p == '$')
4163                                 break;
4164                         /*
4165                          * A variable inside the variable. We cannot expand
4166                          * the external variable yet, so we try again with
4167                          * the nested one
4168                          */
4169                         if (*p == '$') {
4170                             Buf_AddBytes(&buf, p - str, str);
4171                             str = p;
4172                             continue;
4173                         }
4174
4175                         if (strncmp(var, str + 2, p - str - 2) != 0 ||
4176                             var[p - str - 2] != '\0') {
4177                             /*
4178                              * Not the variable we want to expand, scan
4179                              * until the next variable
4180                              */
4181                             for (;*p != '$' && *p != '\0'; p++)
4182                                 continue;
4183                             Buf_AddBytes(&buf, p - str, str);
4184                             str = p;
4185                             expand = FALSE;
4186                         }
4187                         else
4188                             expand = TRUE;
4189                         break;
4190                     }
4191                 }
4192                 if (!expand)
4193                     continue;
4194             }
4195
4196             val = Var_Parse(str, ctxt, flags, &length, &freeIt);
4197
4198             /*
4199              * When we come down here, val should either point to the
4200              * value of this variable, suitably modified, or be NULL.
4201              * Length should be the total length of the potential
4202              * variable invocation (from $ to end character...)
4203              */
4204             if (val == var_Error || val == varNoError) {
4205                 /*
4206                  * If performing old-time variable substitution, skip over
4207                  * the variable and continue with the substitution. Otherwise,
4208                  * store the dollar sign and advance str so we continue with
4209                  * the string...
4210                  */
4211                 if (oldVars) {
4212                     str += length;
4213                 } else if ((flags & VARF_UNDEFERR) || val == var_Error) {
4214                     /*
4215                      * If variable is undefined, complain and skip the
4216                      * variable. The complaint will stop us from doing anything
4217                      * when the file is parsed.
4218                      */
4219                     if (!errorReported) {
4220                         Parse_Error(PARSE_FATAL,
4221                                      "Undefined variable \"%.*s\"",length,str);
4222                     }
4223                     str += length;
4224                     errorReported = TRUE;
4225                 } else {
4226                     Buf_AddByte(&buf, *str);
4227                     str += 1;
4228                 }
4229             } else {
4230                 /*
4231                  * We've now got a variable structure to store in. But first,
4232                  * advance the string pointer.
4233                  */
4234                 str += length;
4235
4236                 /*
4237                  * Copy all the characters from the variable value straight
4238                  * into the new string.
4239                  */
4240                 length = strlen(val);
4241                 Buf_AddBytes(&buf, length, val);
4242                 trailingBslash = length > 0 && val[length - 1] == '\\';
4243             }
4244             free(freeIt);
4245             freeIt = NULL;
4246         }
4247     }
4248
4249     return Buf_DestroyCompact(&buf);
4250 }
4251
4252 /*-
4253  *-----------------------------------------------------------------------
4254  * Var_GetTail --
4255  *      Return the tail from each of a list of words. Used to set the
4256  *      System V local variables.
4257  *
4258  * Input:
4259  *      file            Filename to modify
4260  *
4261  * Results:
4262  *      The resulting string.
4263  *
4264  * Side Effects:
4265  *      None.
4266  *
4267  *-----------------------------------------------------------------------
4268  */
4269 #if 0
4270 char *
4271 Var_GetTail(char *file)
4272 {
4273     return(VarModify(file, VarTail, NULL));
4274 }
4275
4276 /*-
4277  *-----------------------------------------------------------------------
4278  * Var_GetHead --
4279  *      Find the leading components of a (list of) filename(s).
4280  *      XXX: VarHead does not replace foo by ., as (sun) System V make
4281  *      does.
4282  *
4283  * Input:
4284  *      file            Filename to manipulate
4285  *
4286  * Results:
4287  *      The leading components.
4288  *
4289  * Side Effects:
4290  *      None.
4291  *
4292  *-----------------------------------------------------------------------
4293  */
4294 char *
4295 Var_GetHead(char *file)
4296 {
4297     return(VarModify(file, VarHead, NULL));
4298 }
4299 #endif
4300
4301 /*-
4302  *-----------------------------------------------------------------------
4303  * Var_Init --
4304  *      Initialize the module
4305  *
4306  * Results:
4307  *      None
4308  *
4309  * Side Effects:
4310  *      The VAR_CMD and VAR_GLOBAL contexts are created
4311  *-----------------------------------------------------------------------
4312  */
4313 void
4314 Var_Init(void)
4315 {
4316     VAR_INTERNAL = Targ_NewGN("Internal");
4317     VAR_GLOBAL = Targ_NewGN("Global");
4318     VAR_CMD = Targ_NewGN("Command");
4319
4320 }
4321
4322
4323 void
4324 Var_End(void)
4325 {
4326 }
4327
4328
4329 /****************** PRINT DEBUGGING INFO *****************/
4330 static void
4331 VarPrintVar(void *vp)
4332 {
4333     Var    *v = (Var *)vp;
4334     fprintf(debug_file, "%-16s = %s\n", v->name, Buf_GetAll(&v->val, NULL));
4335 }
4336
4337 /*-
4338  *-----------------------------------------------------------------------
4339  * Var_Dump --
4340  *      print all variables in a context
4341  *-----------------------------------------------------------------------
4342  */
4343 void
4344 Var_Dump(GNode *ctxt)
4345 {
4346     Hash_Search search;
4347     Hash_Entry *h;
4348
4349     for (h = Hash_EnumFirst(&ctxt->context, &search);
4350          h != NULL;
4351          h = Hash_EnumNext(&search)) {
4352             VarPrintVar(Hash_GetValue(h));
4353     }
4354 }