contrib/bmake/var.c

   1 /*      $NetBSD: var.c,v 1.641 2020/11/01 23:17:40 rillig 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 /*
  72  * Handling of variables and the expressions formed from them.
  73  *
  74  * Variables are set using lines of the form VAR=value.  Both the variable
  75  * name and the value can contain references to other variables, by using
  76  * expressions like ${VAR}, ${VAR:Modifiers}, ${${VARNAME}} or ${VAR:${MODS}}.
  77  *
  78  * Interface:
  79  *      Var_Init        Initialize this module.
  80  *
  81  *      Var_End         Clean up the module.
  82  *
  83  *      Var_Set         Set the value of the variable, creating it if
  84  *                      necessary.
  85  *
  86  *      Var_Append      Append more characters to the variable, creating it if
  87  *                      necessary. A space is placed between the old value and
  88  *                      the new one.
  89  *
  90  *      Var_Exists      See if a variable exists.
  91  *
  92  *      Var_Value       Return the unexpanded value of a variable, or NULL if
  93  *                      the variable is undefined.
  94  *
  95  *      Var_Subst       Substitute all variable expressions in a string.
  96  *
  97  *      Var_Parse       Parse a variable expression such as ${VAR:Mpattern}.
  98  *
  99  *      Var_Delete      Delete a variable.
 100  *
 101  *      Var_ExportVars  Export some or even all variables to the environment
 102  *                      of this process and its child processes.
 103  *
 104  *      Var_Export      Export the variable to the environment of this process
 105  *                      and its child processes.
 106  *
 107  *      Var_UnExport    Don't export the variable anymore.
 108  *
 109  * Debugging:
 110  *      Var_Stats       Print out hashing statistics if in -dh mode.
 111  *
 112  *      Var_Dump        Print out all variables defined in the given context.
 113  *
 114  * XXX: There's a lot of duplication in these functions.
 115  */
 116
 117 #include <sys/stat.h>
 118 #include <sys/types.h>
 119 #ifndef NO_REGEX
 120 #include <regex.h>
 121 #endif
 122
 123 #include "make.h"
 124
 125 #include <errno.h>
 126 #ifdef HAVE_INTTYPES_H
 127 #include <inttypes.h>
 128 #elif defined(HAVE_STDINT_H)
 129 #include <stdint.h>
 130 #endif
 131 #ifdef HAVE_LIMITS_H
 132 #include <limits.h>
 133 #endif
 134 #include <time.h>
 135
 136 #include "dir.h"
 137 #include "job.h"
 138 #include "metachar.h"
 139
 140 /*      "@(#)var.c      8.3 (Berkeley) 3/19/94" */
 141 MAKE_RCSID("$NetBSD: var.c,v 1.641 2020/11/01 23:17:40 rillig Exp $");
 142
 143 #define VAR_DEBUG1(fmt, arg1) DEBUG1(VAR, fmt, arg1)
 144 #define VAR_DEBUG2(fmt, arg1, arg2) DEBUG2(VAR, fmt, arg1, arg2)
 145 #define VAR_DEBUG3(fmt, arg1, arg2, arg3) DEBUG3(VAR, fmt, arg1, arg2, arg3)
 146 #define VAR_DEBUG4(fmt, arg1, arg2, arg3, arg4) DEBUG4(VAR, fmt, arg1, arg2, arg3, arg4)
 147
 148 ENUM_FLAGS_RTTI_3(VarEvalFlags,
 149                   VARE_UNDEFERR, VARE_WANTRES, VARE_ASSIGN);
 150
 151 /*
 152  * This lets us tell if we have replaced the original environ
 153  * (which we cannot free).
 154  */
 155 char **savedEnv = NULL;
 156
 157 /* Special return value for Var_Parse, indicating a parse error.  It may be
 158  * caused by an undefined variable, a syntax error in a modifier or
 159  * something entirely different. */
 160 char var_Error[] = "";
 161
 162 /* Special return value for Var_Parse, indicating an undefined variable in
 163  * a case where VARE_UNDEFERR is not set.  This undefined variable is
 164  * typically a dynamic variable such as ${.TARGET}, whose expansion needs to
 165  * be deferred until it is defined in an actual target. */
 166 static char varUndefined[] = "";
 167
 168 /* Special return value for Var_Parse, just to avoid allocating empty strings.
 169  * In contrast to var_Error and varUndefined, this is not an error marker but
 170  * just an ordinary successful return value. */
 171 static char emptyString[] = "";
 172
 173 /*
 174  * Traditionally this make consumed $$ during := like any other expansion.
 175  * Other make's do not, and this make follows straight since 2016-01-09.
 176  *
 177  * This knob allows controlling the behavior.
 178  * FALSE to consume $$ during := assignment.
 179  * TRUE to preserve $$ during := assignment.
 180  */
 181 #define MAKE_SAVE_DOLLARS ".MAKE.SAVE_DOLLARS"
 182 static Boolean save_dollars = FALSE;
 183
 184 /*
 185  * Internally, variables are contained in four different contexts.
 186  *      1) the environment. They cannot be changed. If an environment
 187  *         variable is appended to, the result is placed in the global
 188  *         context.
 189  *      2) the global context. Variables set in the makefiles are located
 190  *         here.
 191  *      3) the command-line context. All variables set on the command line
 192  *         are placed in this context.
 193  *      4) the local context. Each target has associated with it a context
 194  *         list. On this list are located the structures describing such
 195  *         local variables as $(@) and $(*)
 196  * The four contexts are searched in the reverse order from which they are
 197  * listed (but see opts.checkEnvFirst).
 198  */
 199 GNode          *VAR_INTERNAL;   /* variables from make itself */
 200 GNode          *VAR_GLOBAL;     /* variables from the makefile */
 201 GNode          *VAR_CMDLINE;    /* variables defined on the command-line */
 202
 203 typedef enum VarFlags {
 204
 205     /* The variable's value is currently being used by Var_Parse or Var_Subst.
 206      * This marker is used to avoid endless recursion. */
 207     VAR_IN_USE = 0x01,
 208
 209     /* The variable comes from the environment.
 210      * These variables are not registered in any GNode, therefore they must
 211      * be freed as soon as they are not used anymore. */
 212     VAR_FROM_ENV = 0x02,
 213
 214     /* The variable is exported to the environment, to be used by child
 215      * processes. */
 216     VAR_EXPORTED = 0x10,
 217
 218     /* At the point where this variable was exported, it contained an
 219      * unresolved reference to another variable.  Before any child process is
 220      * started, it needs to be exported again, in the hope that the referenced
 221      * variable can then be resolved. */
 222     VAR_REEXPORT = 0x20,
 223
 224     /* The variable came from the command line. */
 225     VAR_FROM_CMD = 0x40,
 226
 227     /* The variable value cannot be changed anymore, and the variable cannot
 228      * be deleted.  Any attempts to do so are ignored. */
 229     VAR_READONLY = 0x80
 230 } VarFlags;
 231
 232 ENUM_FLAGS_RTTI_6(VarFlags,
 233                   VAR_IN_USE, VAR_FROM_ENV,
 234                   VAR_EXPORTED, VAR_REEXPORT, VAR_FROM_CMD, VAR_READONLY);
 235
 236 /* Variables are defined using one of the VAR=value assignments.  Their
 237  * value can be queried by expressions such as $V, ${VAR}, or with modifiers
 238  * such as ${VAR:S,from,to,g:Q}.
 239  *
 240  * There are 3 kinds of variables: context variables, environment variables,
 241  * undefined variables.
 242  *
 243  * Context variables are stored in a GNode.context.  The only way to undefine
 244  * a context variable is using the .undef directive.  In particular, it must
 245  * not be possible to undefine a variable during the evaluation of an
 246  * expression, or Var.name might point nowhere.
 247  *
 248  * Environment variables are temporary.  They are returned by VarFind, and
 249  * after using them, they must be freed using VarFreeEnv.
 250  *
 251  * Undefined variables occur during evaluation of variable expressions such
 252  * as ${UNDEF:Ufallback} in Var_Parse and ApplyModifiers.
 253  */
 254 typedef struct Var {
 255     /* The name of the variable, once set, doesn't change anymore.
 256      * For context variables, it aliases the corresponding HashEntry name.
 257      * For environment and undefined variables, it is allocated. */
 258     const char *name;
 259     void *name_freeIt;
 260
 261     Buffer        val;          /* its value */
 262     VarFlags      flags;        /* miscellaneous status flags */
 263 } Var;
 264
 265 /*
 266  * Exporting vars is expensive so skip it if we can
 267  */
 268 typedef enum VarExportedMode {
 269     VAR_EXPORTED_NONE,
 270     VAR_EXPORTED_SOME,
 271     VAR_EXPORTED_ALL
 272 } VarExportedMode;
 273
 274 static VarExportedMode var_exportedVars = VAR_EXPORTED_NONE;
 275
 276 typedef enum VarExportFlags {
 277     /*
 278      * We pass this to Var_Export when doing the initial export
 279      * or after updating an exported var.
 280      */
 281     VAR_EXPORT_PARENT   = 0x01,
 282     /*
 283      * We pass this to Var_Export1 to tell it to leave the value alone.
 284      */
 285     VAR_EXPORT_LITERAL  = 0x02
 286 } VarExportFlags;
 287
 288 /* Flags for pattern matching in the :S and :C modifiers */
 289 typedef enum VarPatternFlags {
 290     VARP_SUB_GLOBAL     = 0x01, /* Replace as often as possible ('g') */
 291     VARP_SUB_ONE        = 0x02, /* Replace only once ('1') */
 292     VARP_ANCHOR_START   = 0x04, /* Match at start of word ('^') */
 293     VARP_ANCHOR_END     = 0x08  /* Match at end of word ('$') */
 294 } VarPatternFlags;
 295
 296 static Var *
 297 VarNew(const char *name, void *name_freeIt, const char *value, VarFlags flags)
 298 {
 299     size_t value_len = strlen(value);
 300     Var *var = bmake_malloc(sizeof *var);
 301     var->name = name;
 302     var->name_freeIt = name_freeIt;
 303     Buf_Init(&var->val, value_len + 1);
 304     Buf_AddBytes(&var->val, value, value_len);
 305     var->flags = flags;
 306     return var;
 307 }
 308
 309 static const char *
 310 CanonicalVarname(const char *name)
 311 {
 312     if (*name == '.' && ch_isupper(name[1])) {
 313         switch (name[1]) {
 314         case 'A':
 315             if (strcmp(name, ".ALLSRC") == 0)
 316                 name = ALLSRC;
 317             if (strcmp(name, ".ARCHIVE") == 0)
 318                 name = ARCHIVE;
 319             break;
 320         case 'I':
 321             if (strcmp(name, ".IMPSRC") == 0)
 322                 name = IMPSRC;
 323             break;
 324         case 'M':
 325             if (strcmp(name, ".MEMBER") == 0)
 326                 name = MEMBER;
 327             break;
 328         case 'O':
 329             if (strcmp(name, ".OODATE") == 0)
 330                 name = OODATE;
 331             break;
 332         case 'P':
 333             if (strcmp(name, ".PREFIX") == 0)
 334                 name = PREFIX;
 335             break;
 336         case 'S':
 337             if (strcmp(name, ".SHELL") == 0) {
 338                 if (!shellPath)
 339                     Shell_Init();
 340             }
 341             break;
 342         case 'T':
 343             if (strcmp(name, ".TARGET") == 0)
 344                 name = TARGET;
 345             break;
 346         }
 347     }
 348
 349     /* GNU make has an additional alias $^ == ${.ALLSRC}. */
 350
 351     return name;
 352 }
 353
 354 static Var *
 355 GNode_FindVar(GNode *ctxt, const char *varname, unsigned int hash)
 356 {
 357     return HashTable_FindValueHash(&ctxt->context, varname, hash);
 358 }
 359
 360 /* Find the variable in the context, and maybe in other contexts as well.
 361  *
 362  * Input:
 363  *      name            name to find, is not expanded any further
 364  *      ctxt            context in which to look first
 365  *      elsewhere       TRUE to look in other contexts as well
 366  *
 367  * Results:
 368  *      The found variable, or NULL if the variable does not exist.
 369  *      If the variable is an environment variable, it must be freed using
 370  *      VarFreeEnv after use.
 371  */
 372 static Var *
 373 VarFind(const char *name, GNode *ctxt, Boolean elsewhere)
 374 {
 375     Var *var;
 376     unsigned int nameHash;
 377
 378     /*
 379      * If the variable name begins with a '.', it could very well be one of
 380      * the local ones.  We check the name against all the local variables
 381      * and substitute the short version in for 'name' if it matches one of
 382      * them.
 383      */
 384     name = CanonicalVarname(name);
 385     nameHash = Hash_Hash(name);
 386
 387     /* First look for the variable in the given context. */
 388     var = GNode_FindVar(ctxt, name, nameHash);
 389     if (!elsewhere)
 390         return var;
 391
 392     /* The variable was not found in the given context.  Now look for it in
 393      * the other contexts as well. */
 394     if (var == NULL && ctxt != VAR_CMDLINE)
 395         var = GNode_FindVar(VAR_CMDLINE, name, nameHash);
 396
 397     if (!opts.checkEnvFirst && var == NULL && ctxt != VAR_GLOBAL) {
 398         var = GNode_FindVar(VAR_GLOBAL, name, nameHash);
 399         if (var == NULL && ctxt != VAR_INTERNAL) {
 400             /* VAR_INTERNAL is subordinate to VAR_GLOBAL */
 401             var = GNode_FindVar(VAR_INTERNAL, name, nameHash);
 402         }
 403     }
 404
 405     if (var == NULL) {
 406         char *env;
 407
 408         if ((env = getenv(name)) != NULL) {
 409             char *varname = bmake_strdup(name);
 410             return VarNew(varname, varname, env, VAR_FROM_ENV);
 411         }
 412
 413         if (opts.checkEnvFirst && ctxt != VAR_GLOBAL) {
 414             var = GNode_FindVar(VAR_GLOBAL, name, nameHash);
 415             if (var == NULL && ctxt != VAR_INTERNAL)
 416                 var = GNode_FindVar(VAR_INTERNAL, name, nameHash);
 417             return var;
 418         }
 419
 420         return NULL;
 421     }
 422
 423     return var;
 424 }
 425
 426 /* If the variable is an environment variable, free it.
 427  *
 428  * Input:
 429  *      v               the variable
 430  *      freeValue       true if the variable value should be freed as well
 431  *
 432  * Results:
 433  *      TRUE if it is an environment variable, FALSE otherwise.
 434  */
 435 static Boolean
 436 VarFreeEnv(Var *v, Boolean freeValue)
 437 {
 438     if (!(v->flags & VAR_FROM_ENV))
 439         return FALSE;
 440
 441     free(v->name_freeIt);
 442     Buf_Destroy(&v->val, freeValue);
 443     free(v);
 444     return TRUE;
 445 }
 446
 447 /* Add a new variable of the given name and value to the given context.
 448  * The name and val arguments are duplicated so they may safely be freed. */
 449 static void
 450 VarAdd(const char *name, const char *val, GNode *ctxt, VarSet_Flags flags)
 451 {
 452     HashEntry *he = HashTable_CreateEntry(&ctxt->context, name, NULL);
 453     Var *v = VarNew(he->key /* aliased */, NULL, val,
 454                     flags & VAR_SET_READONLY ? VAR_READONLY : 0);
 455     HashEntry_Set(he, v);
 456     if (!(ctxt->flags & INTERNAL)) {
 457         VAR_DEBUG3("%s:%s = %s\n", ctxt->name, name, val);
 458     }
 459 }
 460
 461 /* Remove a variable from a context, freeing all related memory as well.
 462  * The variable name is expanded once. */
 463 void
 464 Var_Delete(const char *name, GNode *ctxt)
 465 {
 466     char *name_freeIt = NULL;
 467     HashEntry *he;
 468
 469     if (strchr(name, '$') != NULL) {
 470         (void)Var_Subst(name, VAR_GLOBAL, VARE_WANTRES, &name_freeIt);
 471         /* TODO: handle errors */
 472         name = name_freeIt;
 473     }
 474     he = HashTable_FindEntry(&ctxt->context, name);
 475     VAR_DEBUG3("%s:delete %s%s\n",
 476                ctxt->name, name, he != NULL ? "" : " (not found)");
 477     free(name_freeIt);
 478
 479     if (he != NULL) {
 480         Var *v = HashEntry_Get(he);
 481         if (v->flags & VAR_EXPORTED)
 482             unsetenv(v->name);
 483         if (strcmp(v->name, MAKE_EXPORTED) == 0)
 484             var_exportedVars = VAR_EXPORTED_NONE;
 485         assert(v->name_freeIt == NULL);
 486         HashTable_DeleteEntry(&ctxt->context, he);
 487         Buf_Destroy(&v->val, TRUE);
 488         free(v);
 489     }
 490 }
 491
 492 static Boolean
 493 MayExport(const char *name)
 494 {
 495     if (name[0] == '.')
 496         return FALSE;           /* skip internals */
 497     if (name[0] == '-')
 498         return FALSE;           /* skip misnamed variables */
 499     if (name[1] == '\0') {
 500         /*
 501          * A single char.
 502          * If it is one of the vars that should only appear in
 503          * local context, skip it, else we can get Var_Subst
 504          * into a loop.
 505          */
 506         switch (name[0]) {
 507         case '@':
 508         case '%':
 509         case '*':
 510         case '!':
 511             return FALSE;
 512         }
 513     }
 514     return TRUE;
 515 }
 516
 517 /*
 518  * Export a single variable.
 519  * We ignore make internal variables (those which start with '.').
 520  * Also we jump through some hoops to avoid calling setenv
 521  * more than necessary since it can leak.
 522  * We only manipulate flags of vars if 'parent' is set.
 523  */
 524 static Boolean
 525 Var_Export1(const char *name, VarExportFlags flags)
 526 {
 527     VarExportFlags parent = flags & VAR_EXPORT_PARENT;
 528     Var *v;
 529     char *val;
 530
 531     if (!MayExport(name))
 532         return FALSE;
 533
 534     v = VarFind(name, VAR_GLOBAL, 0);
 535     if (v == NULL)
 536         return FALSE;
 537
 538     if (!parent && (v->flags & VAR_EXPORTED) && !(v->flags & VAR_REEXPORT))
 539         return FALSE;           /* nothing to do */
 540
 541     val = Buf_GetAll(&v->val, NULL);
 542     if (!(flags & VAR_EXPORT_LITERAL) && strchr(val, '$') != NULL) {
 543         char *expr;
 544
 545         if (parent) {
 546             /*
 547              * Flag the variable as something we need to re-export.
 548              * No point actually exporting it now though,
 549              * the child process can do it at the last minute.
 550              */
 551             v->flags |= VAR_EXPORTED | VAR_REEXPORT;
 552             return TRUE;
 553         }
 554         if (v->flags & VAR_IN_USE) {
 555             /*
 556              * We recursed while exporting in a child.
 557              * This isn't going to end well, just skip it.
 558              */
 559             return FALSE;
 560         }
 561
 562         /* XXX: name is injected without escaping it */
 563         expr = str_concat3("${", name, "}");
 564         (void)Var_Subst(expr, VAR_GLOBAL, VARE_WANTRES, &val);
 565         /* TODO: handle errors */
 566         setenv(name, val, 1);
 567         free(val);
 568         free(expr);
 569     } else {
 570         if (parent)
 571             v->flags &= ~(unsigned)VAR_REEXPORT;        /* once will do */
 572         if (parent || !(v->flags & VAR_EXPORTED))
 573             setenv(name, val, 1);
 574     }
 575
 576     /*
 577      * This is so Var_Set knows to call Var_Export again...
 578      */
 579     if (parent) {
 580         v->flags |= VAR_EXPORTED;
 581     }
 582     return TRUE;
 583 }
 584
 585 /*
 586  * This gets called from our child processes.
 587  */
 588 void
 589 Var_ExportVars(void)
 590 {
 591     char *val;
 592
 593     /*
 594      * Several make's support this sort of mechanism for tracking
 595      * recursion - but each uses a different name.
 596      * We allow the makefiles to update MAKELEVEL and ensure
 597      * children see a correctly incremented value.
 598      */
 599     char tmp[BUFSIZ];
 600     snprintf(tmp, sizeof(tmp), "%d", makelevel + 1);
 601     setenv(MAKE_LEVEL_ENV, tmp, 1);
 602
 603     if (var_exportedVars == VAR_EXPORTED_NONE)
 604         return;
 605
 606     if (var_exportedVars == VAR_EXPORTED_ALL) {
 607         HashIter hi;
 608
 609         /* Ouch! Exporting all variables at once is crazy... */
 610         HashIter_Init(&hi, &VAR_GLOBAL->context);
 611         while (HashIter_Next(&hi) != NULL) {
 612             Var *var = hi.entry->value;
 613             Var_Export1(var->name, 0);
 614         }
 615         return;
 616     }
 617
 618     (void)Var_Subst("${" MAKE_EXPORTED ":O:u}", VAR_GLOBAL, VARE_WANTRES, &val);
 619     /* TODO: handle errors */
 620     if (*val) {
 621         Words words = Str_Words(val, FALSE);
 622         size_t i;
 623
 624         for (i = 0; i < words.len; i++)
 625             Var_Export1(words.words[i], 0);
 626         Words_Free(words);
 627     }
 628     free(val);
 629 }
 630
 631 /*
 632  * This is called when .export is seen or .MAKE.EXPORTED is modified.
 633  *
 634  * It is also called when any exported variable is modified.
 635  * XXX: Is it really?
 636  *
 637  * str has the format "[-env|-literal] varname...".
 638  */
 639 void
 640 Var_Export(const char *str, Boolean isExport)
 641 {
 642     VarExportFlags flags;
 643     char *val;
 644
 645     if (isExport && str[0] == '\0') {
 646         var_exportedVars = VAR_EXPORTED_ALL; /* use with caution! */
 647         return;
 648     }
 649
 650     if (isExport && strncmp(str, "-env", 4) == 0) {
 651         str += 4;
 652         flags = 0;
 653     } else if (isExport && strncmp(str, "-literal", 8) == 0) {
 654         str += 8;
 655         flags = VAR_EXPORT_LITERAL;
 656     } else {
 657         flags = VAR_EXPORT_PARENT;
 658     }
 659
 660     (void)Var_Subst(str, VAR_GLOBAL, VARE_WANTRES, &val);
 661     /* TODO: handle errors */
 662     if (val[0] != '\0') {
 663         Words words = Str_Words(val, FALSE);
 664
 665         size_t i;
 666         for (i = 0; i < words.len; i++) {
 667             const char *name = words.words[i];
 668             if (Var_Export1(name, flags)) {
 669                 if (var_exportedVars == VAR_EXPORTED_NONE)
 670                     var_exportedVars = VAR_EXPORTED_SOME;
 671                 if (isExport && (flags & VAR_EXPORT_PARENT)) {
 672                     Var_Append(MAKE_EXPORTED, name, VAR_GLOBAL);
 673                 }
 674             }
 675         }
 676         Words_Free(words);
 677     }
 678     free(val);
 679 }
 680
 681
 682 extern char **environ;
 683
 684 /*
 685  * This is called when .unexport[-env] is seen.
 686  *
 687  * str must have the form "unexport[-env] varname...".
 688  */
 689 void
 690 Var_UnExport(const char *str)
 691 {
 692     const char *varnames;
 693     char *varnames_freeIt;
 694     Boolean unexport_env;
 695
 696     varnames = NULL;
 697     varnames_freeIt = NULL;
 698
 699     str += strlen("unexport");
 700     unexport_env = strncmp(str, "-env", 4) == 0;
 701     if (unexport_env) {
 702         const char *cp;
 703         char **newenv;
 704
 705         cp = getenv(MAKE_LEVEL_ENV);    /* we should preserve this */
 706         if (environ == savedEnv) {
 707             /* we have been here before! */
 708             newenv = bmake_realloc(environ, 2 * sizeof(char *));
 709         } else {
 710             if (savedEnv) {
 711                 free(savedEnv);
 712                 savedEnv = NULL;
 713             }
 714             newenv = bmake_malloc(2 * sizeof(char *));
 715         }
 716
 717         /* Note: we cannot safely free() the original environ. */
 718         environ = savedEnv = newenv;
 719         newenv[0] = NULL;
 720         newenv[1] = NULL;
 721         if (cp && *cp)
 722             setenv(MAKE_LEVEL_ENV, cp, 1);
 723     } else {
 724         cpp_skip_whitespace(&str);
 725         if (str[0] != '\0')
 726             varnames = str;
 727     }
 728
 729     if (varnames == NULL) {
 730         /* Using .MAKE.EXPORTED */
 731         (void)Var_Subst("${" MAKE_EXPORTED ":O:u}", VAR_GLOBAL, VARE_WANTRES,
 732                         &varnames_freeIt);
 733         /* TODO: handle errors */
 734         varnames = varnames_freeIt;
 735     }
 736
 737     {
 738         Var *v;
 739         size_t i;
 740
 741         Words words = Str_Words(varnames, FALSE);
 742         for (i = 0; i < words.len; i++) {
 743             const char *varname = words.words[i];
 744             v = VarFind(varname, VAR_GLOBAL, 0);
 745             if (v == NULL) {
 746                 VAR_DEBUG1("Not unexporting \"%s\" (not found)\n", varname);
 747                 continue;
 748             }
 749
 750             VAR_DEBUG1("Unexporting \"%s\"\n", varname);
 751             if (!unexport_env && (v->flags & VAR_EXPORTED) &&
 752                 !(v->flags & VAR_REEXPORT))
 753                 unsetenv(v->name);
 754             v->flags &= ~(unsigned)(VAR_EXPORTED | VAR_REEXPORT);
 755
 756             /*
 757              * If we are unexporting a list,
 758              * remove each one from .MAKE.EXPORTED.
 759              * If we are removing them all,
 760              * just delete .MAKE.EXPORTED below.
 761              */
 762             if (varnames == str) {
 763                 /* XXX: v->name is injected without escaping it */
 764                 char *expr = str_concat3("${" MAKE_EXPORTED ":N", v->name, "}");
 765                 char *cp;
 766                 (void)Var_Subst(expr, VAR_GLOBAL, VARE_WANTRES, &cp);
 767                 /* TODO: handle errors */
 768                 Var_Set(MAKE_EXPORTED, cp, VAR_GLOBAL);
 769                 free(cp);
 770                 free(expr);
 771             }
 772         }
 773         Words_Free(words);
 774         if (varnames != str) {
 775             Var_Delete(MAKE_EXPORTED, VAR_GLOBAL);
 776             free(varnames_freeIt);
 777         }
 778     }
 779 }
 780
 781 /* See Var_Set for documentation. */
 782 void
 783 Var_Set_with_flags(const char *name, const char *val, GNode *ctxt,
 784                    VarSet_Flags flags)
 785 {
 786     const char *unexpanded_name = name;
 787     char *name_freeIt = NULL;
 788     Var *v;
 789
 790     assert(val != NULL);
 791
 792     if (strchr(name, '$') != NULL) {
 793         (void)Var_Subst(name, ctxt, VARE_WANTRES, &name_freeIt);
 794         /* TODO: handle errors */
 795         name = name_freeIt;
 796     }
 797
 798     if (name[0] == '\0') {
 799         VAR_DEBUG2("Var_Set(\"%s\", \"%s\", ...) "
 800                    "name expands to empty string - ignored\n",
 801                    unexpanded_name, val);
 802         free(name_freeIt);
 803         return;
 804     }
 805
 806     if (ctxt == VAR_GLOBAL) {
 807         v = VarFind(name, VAR_CMDLINE, 0);
 808         if (v != NULL) {
 809             if (v->flags & VAR_FROM_CMD) {
 810                 VAR_DEBUG3("%s:%s = %s ignored!\n", ctxt->name, name, val);
 811                 goto out;
 812             }
 813             VarFreeEnv(v, TRUE);
 814         }
 815     }
 816
 817     /*
 818      * We only look for a variable in the given context since anything set
 819      * here will override anything in a lower context, so there's not much
 820      * point in searching them all just to save a bit of memory...
 821      */
 822     v = VarFind(name, ctxt, 0);
 823     if (v == NULL) {
 824         if (ctxt == VAR_CMDLINE && !(flags & VAR_NO_EXPORT)) {
 825             /*
 826              * This var would normally prevent the same name being added
 827              * to VAR_GLOBAL, so delete it from there if needed.
 828              * Otherwise -V name may show the wrong value.
 829              */
 830             /* XXX: name is expanded for the second time */
 831             Var_Delete(name, VAR_GLOBAL);
 832         }
 833         VarAdd(name, val, ctxt, flags);
 834     } else {
 835         if ((v->flags & VAR_READONLY) && !(flags & VAR_SET_READONLY)) {
 836             VAR_DEBUG3("%s:%s = %s ignored (read-only)\n",
 837                        ctxt->name, name, val);
 838             goto out;
 839         }
 840         Buf_Empty(&v->val);
 841         Buf_AddStr(&v->val, val);
 842
 843         VAR_DEBUG3("%s:%s = %s\n", ctxt->name, name, val);
 844         if (v->flags & VAR_EXPORTED) {
 845             Var_Export1(name, VAR_EXPORT_PARENT);
 846         }
 847     }
 848     /*
 849      * Any variables given on the command line are automatically exported
 850      * to the environment (as per POSIX standard)
 851      * Other than internals.
 852      */
 853     if (ctxt == VAR_CMDLINE && !(flags & VAR_NO_EXPORT) && name[0] != '.') {
 854         if (v == NULL)
 855             v = VarFind(name, ctxt, 0); /* we just added it */
 856         v->flags |= VAR_FROM_CMD;
 857
 858         /*
 859          * If requested, don't export these in the environment
 860          * individually.  We still put them in MAKEOVERRIDES so
 861          * that the command-line settings continue to override
 862          * Makefile settings.
 863          */
 864         if (!opts.varNoExportEnv)
 865             setenv(name, val, 1);
 866
 867         Var_Append(MAKEOVERRIDES, name, VAR_GLOBAL);
 868     }
 869     if (name[0] == '.' && strcmp(name, MAKE_SAVE_DOLLARS) == 0)
 870         save_dollars = s2Boolean(val, save_dollars);
 871
 872 out:
 873     free(name_freeIt);
 874     if (v != NULL)
 875         VarFreeEnv(v, TRUE);
 876 }
 877
 878 /*-
 879  *-----------------------------------------------------------------------
 880  * Var_Set --
 881  *      Set the variable name to the value val in the given context.
 882  *
 883  *      If the variable doesn't yet exist, it is created.
 884  *      Otherwise the new value overwrites and replaces the old value.
 885  *
 886  * Input:
 887  *      name            name of the variable to set, is expanded once
 888  *      val             value to give to the variable
 889  *      ctxt            context in which to set it
 890  *
 891  * Notes:
 892  *      The variable is searched for only in its context before being
 893  *      created in that context. I.e. if the context is VAR_GLOBAL,
 894  *      only VAR_GLOBAL->context is searched. Likewise if it is VAR_CMDLINE,
 895  *      only VAR_CMDLINE->context is searched. This is done to avoid the
 896  *      literally thousands of unnecessary strcmp's that used to be done to
 897  *      set, say, $(@) or $(<).
 898  *      If the context is VAR_GLOBAL though, we check if the variable
 899  *      was set in VAR_CMDLINE from the command line and skip it if so.
 900  *-----------------------------------------------------------------------
 901  */
 902 void
 903 Var_Set(const char *name, const char *val, GNode *ctxt)
 904 {
 905     Var_Set_with_flags(name, val, ctxt, 0);
 906 }
 907
 908 /*-
 909  *-----------------------------------------------------------------------
 910  * Var_Append --
 911  *      The variable of the given name has the given value appended to it in
 912  *      the given context.
 913  *
 914  *      If the variable doesn't exist, it is created. Otherwise the strings
 915  *      are concatenated, with a space in between.
 916  *
 917  * Input:
 918  *      name            name of the variable to modify, is expanded once
 919  *      val             string to append to it
 920  *      ctxt            context in which this should occur
 921  *
 922  * Notes:
 923  *      Only if the variable is being sought in the global context is the
 924  *      environment searched.
 925  *      XXX: Knows its calling circumstances in that if called with ctxt
 926  *      an actual target, it will only search that context since only
 927  *      a local variable could be being appended to. This is actually
 928  *      a big win and must be tolerated.
 929  *-----------------------------------------------------------------------
 930  */
 931 void
 932 Var_Append(const char *name, const char *val, GNode *ctxt)
 933 {
 934     char *name_freeIt = NULL;
 935     Var *v;
 936
 937     assert(val != NULL);
 938
 939     if (strchr(name, '$') != NULL) {
 940         const char *unexpanded_name = name;
 941         (void)Var_Subst(name, ctxt, VARE_WANTRES, &name_freeIt);
 942         /* TODO: handle errors */
 943         name = name_freeIt;
 944         if (name[0] == '\0') {
 945             VAR_DEBUG2("Var_Append(\"%s\", \"%s\", ...) "
 946                        "name expands to empty string - ignored\n",
 947                        unexpanded_name, val);
 948             free(name_freeIt);
 949             return;
 950         }
 951     }
 952
 953     v = VarFind(name, ctxt, ctxt == VAR_GLOBAL);
 954
 955     if (v == NULL) {
 956         /* XXX: name is expanded for the second time */
 957         Var_Set(name, val, ctxt);
 958     } else if (v->flags & VAR_READONLY) {
 959         VAR_DEBUG1("Ignoring append to %s since it is read-only\n", name);
 960     } else if (ctxt == VAR_CMDLINE || !(v->flags & VAR_FROM_CMD)) {
 961         Buf_AddByte(&v->val, ' ');
 962         Buf_AddStr(&v->val, val);
 963
 964         VAR_DEBUG3("%s:%s = %s\n",
 965                    ctxt->name, name, Buf_GetAll(&v->val, NULL));
 966
 967         if (v->flags & VAR_FROM_ENV) {
 968             HashEntry *h;
 969
 970             /*
 971              * If the original variable came from the environment, we
 972              * have to install it in the global context (we could place
 973              * it in the environment, but then we should provide a way to
 974              * export other variables...)
 975              */
 976             v->flags &= ~(unsigned)VAR_FROM_ENV;
 977             h = HashTable_CreateEntry(&ctxt->context, name, NULL);
 978             HashEntry_Set(h, v);
 979         }
 980     }
 981     free(name_freeIt);
 982 }
 983
 984 /* See if the given variable exists, in the given context or in other
 985  * fallback contexts.
 986  *
 987  * Input:
 988  *      name            Variable to find, is expanded once
 989  *      ctxt            Context in which to start search
 990  */
 991 Boolean
 992 Var_Exists(const char *name, GNode *ctxt)
 993 {
 994     char *name_freeIt = NULL;
 995     Var *v;
 996
 997     if (strchr(name, '$') != NULL) {
 998         (void)Var_Subst(name, ctxt, VARE_WANTRES, &name_freeIt);
 999         /* TODO: handle errors */
1000         name = name_freeIt;
1001     }
1002
1003     v = VarFind(name, ctxt, TRUE);
1004     free(name_freeIt);
1005     if (v == NULL)
1006         return FALSE;
1007
1008     (void)VarFreeEnv(v, TRUE);
1009     return TRUE;
1010 }
1011
1012 /*-
1013  *-----------------------------------------------------------------------
1014  * Var_Value --
1015  *      Return the unexpanded value of the given variable in the given
1016  *      context, or the usual contexts.
1017  *
1018  * Input:
1019  *      name            name to find, is not expanded any further
1020  *      ctxt            context in which to search for it
1021  *
1022  * Results:
1023  *      The value if the variable exists, NULL if it doesn't.
1024  *      If the returned value is not NULL, the caller must free
1025  *      out_freeIt when the returned value is no longer needed.
1026  *-----------------------------------------------------------------------
1027  */
1028 const char *
1029 Var_Value(const char *name, GNode *ctxt, void **out_freeIt)
1030 {
1031     Var *v = VarFind(name, ctxt, TRUE);
1032     char *value;
1033
1034     *out_freeIt = NULL;
1035     if (v == NULL)
1036         return NULL;
1037
1038     value = Buf_GetAll(&v->val, NULL);
1039     if (VarFreeEnv(v, FALSE))
1040         *out_freeIt = value;
1041     return value;
1042 }
1043
1044 /* Return the unexpanded variable value from this node, without trying to look
1045  * up the variable in any other context. */
1046 const char *
1047 Var_ValueDirect(const char *name, GNode *ctxt)
1048 {
1049     Var *v = VarFind(name, ctxt, FALSE);
1050     return v != NULL ? Buf_GetAll(&v->val, NULL) : NULL;
1051 }
1052
1053
1054 /* SepBuf is a string being built from words, interleaved with separators. */
1055 typedef struct SepBuf {
1056     Buffer buf;
1057     Boolean needSep;
1058     char sep;                   /* usually ' ', but see the :ts modifier */
1059 } SepBuf;
1060
1061 static void
1062 SepBuf_Init(SepBuf *buf, char sep)
1063 {
1064     Buf_Init(&buf->buf, 32 /* bytes */);
1065     buf->needSep = FALSE;
1066     buf->sep = sep;
1067 }
1068
1069 static void
1070 SepBuf_Sep(SepBuf *buf)
1071 {
1072     buf->needSep = TRUE;
1073 }
1074
1075 static void
1076 SepBuf_AddBytes(SepBuf *buf, const char *mem, size_t mem_size)
1077 {
1078     if (mem_size == 0)
1079         return;
1080     if (buf->needSep && buf->sep != '\0') {
1081         Buf_AddByte(&buf->buf, buf->sep);
1082         buf->needSep = FALSE;
1083     }
1084     Buf_AddBytes(&buf->buf, mem, mem_size);
1085 }
1086
1087 static void
1088 SepBuf_AddBytesBetween(SepBuf *buf, const char *start, const char *end)
1089 {
1090     SepBuf_AddBytes(buf, start, (size_t)(end - start));
1091 }
1092
1093 static void
1094 SepBuf_AddStr(SepBuf *buf, const char *str)
1095 {
1096     SepBuf_AddBytes(buf, str, strlen(str));
1097 }
1098
1099 static char *
1100 SepBuf_Destroy(SepBuf *buf, Boolean free_buf)
1101 {
1102     return Buf_Destroy(&buf->buf, free_buf);
1103 }
1104
1105
1106 /* This callback for ModifyWords gets a single word from a variable expression
1107  * and typically adds a modification of this word to the buffer. It may also
1108  * do nothing or add several words.
1109  *
1110  * For example, in ${:Ua b c:M*2}, the callback is called 3 times, once for
1111  * each word of "a b c". */
1112 typedef void (*ModifyWordsCallback)(const char *word, SepBuf *buf, void *data);
1113
1114
1115 /* Callback for ModifyWords to implement the :H modifier.
1116  * Add the dirname of the given word to the buffer. */
1117 static void
1118 ModifyWord_Head(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
1119 {
1120     const char *slash = strrchr(word, '/');
1121     if (slash != NULL)
1122         SepBuf_AddBytesBetween(buf, word, slash);
1123     else
1124         SepBuf_AddStr(buf, ".");
1125 }
1126
1127 /* Callback for ModifyWords to implement the :T modifier.
1128  * Add the basename of the given word to the buffer. */
1129 static void
1130 ModifyWord_Tail(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
1131 {
1132     const char *slash = strrchr(word, '/');
1133     const char *base = slash != NULL ? slash + 1 : word;
1134     SepBuf_AddStr(buf, base);
1135 }
1136
1137 /* Callback for ModifyWords to implement the :E modifier.
1138  * Add the filename suffix of the given word to the buffer, if it exists. */
1139 static void
1140 ModifyWord_Suffix(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
1141 {
1142     const char *dot = strrchr(word, '.');
1143     if (dot != NULL)
1144         SepBuf_AddStr(buf, dot + 1);
1145 }
1146
1147 /* Callback for ModifyWords to implement the :R modifier.
1148  * Add the basename of the given word to the buffer. */
1149 static void
1150 ModifyWord_Root(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
1151 {
1152     const char *dot = strrchr(word, '.');
1153     size_t len = dot != NULL ? (size_t)(dot - word) : strlen(word);
1154     SepBuf_AddBytes(buf, word, len);
1155 }
1156
1157 /* Callback for ModifyWords to implement the :M modifier.
1158  * Place the word in the buffer if it matches the given pattern. */
1159 static void
1160 ModifyWord_Match(const char *word, SepBuf *buf, void *data)
1161 {
1162     const char *pattern = data;
1163     VAR_DEBUG2("VarMatch [%s] [%s]\n", word, pattern);
1164     if (Str_Match(word, pattern))
1165         SepBuf_AddStr(buf, word);
1166 }
1167
1168 /* Callback for ModifyWords to implement the :N modifier.
1169  * Place the word in the buffer if it doesn't match the given pattern. */
1170 static void
1171 ModifyWord_NoMatch(const char *word, SepBuf *buf, void *data)
1172 {
1173     const char *pattern = data;
1174     if (!Str_Match(word, pattern))
1175         SepBuf_AddStr(buf, word);
1176 }
1177
1178 #ifdef SYSVVARSUB
1179 /* Check word against pattern for a match (% is a wildcard).
1180  *
1181  * Input:
1182  *      word            Word to examine
1183  *      pattern         Pattern to examine against
1184  *
1185  * Results:
1186  *      Returns the start of the match, or NULL.
1187  *      out_match_len returns the length of the match, if any.
1188  *      out_hasPercent returns whether the pattern contains a percent.
1189  */
1190 static const char *
1191 SysVMatch(const char *word, const char *pattern,
1192               size_t *out_match_len, Boolean *out_hasPercent)
1193 {
1194     const char *p = pattern;
1195     const char *w = word;
1196     const char *percent;
1197     size_t w_len;
1198     size_t p_len;
1199     const char *w_tail;
1200
1201     *out_hasPercent = FALSE;
1202     percent = strchr(p, '%');
1203     if (percent != NULL) {      /* ${VAR:...%...=...} */
1204         *out_hasPercent = TRUE;
1205         if (*w == '\0')
1206             return NULL;        /* empty word does not match pattern */
1207
1208         /* check that the prefix matches */
1209         for (; p != percent && *w != '\0' && *w == *p; w++, p++)
1210             continue;
1211         if (p != percent)
1212             return NULL;        /* No match */
1213
1214         p++;                    /* Skip the percent */
1215         if (*p == '\0') {
1216             /* No more pattern, return the rest of the string */
1217             *out_match_len = strlen(w);
1218             return w;
1219         }
1220     }
1221
1222     /* Test whether the tail matches */
1223     w_len = strlen(w);
1224     p_len = strlen(p);
1225     if (w_len < p_len)
1226         return NULL;
1227
1228     w_tail = w + w_len - p_len;
1229     if (memcmp(p, w_tail, p_len) != 0)
1230         return NULL;
1231
1232     *out_match_len = (size_t)(w_tail - w);
1233     return w;
1234 }
1235
1236 struct ModifyWord_SYSVSubstArgs {
1237     GNode *ctx;
1238     const char *lhs;
1239     const char *rhs;
1240 };
1241
1242 /* Callback for ModifyWords to implement the :%.from=%.to modifier. */
1243 static void
1244 ModifyWord_SYSVSubst(const char *word, SepBuf *buf, void *data)
1245 {
1246     const struct ModifyWord_SYSVSubstArgs *args = data;
1247     char *rhs_expanded;
1248     const char *rhs;
1249     const char *percent;
1250
1251     size_t match_len;
1252     Boolean lhsPercent;
1253     const char *match = SysVMatch(word, args->lhs, &match_len, &lhsPercent);
1254     if (match == NULL) {
1255         SepBuf_AddStr(buf, word);
1256         return;
1257     }
1258
1259     /* Append rhs to the buffer, substituting the first '%' with the
1260      * match, but only if the lhs had a '%' as well. */
1261
1262     (void)Var_Subst(args->rhs, args->ctx, VARE_WANTRES, &rhs_expanded);
1263     /* TODO: handle errors */
1264
1265     rhs = rhs_expanded;
1266     percent = strchr(rhs, '%');
1267
1268     if (percent != NULL && lhsPercent) {
1269         /* Copy the prefix of the replacement pattern */
1270         SepBuf_AddBytesBetween(buf, rhs, percent);
1271         rhs = percent + 1;
1272     }
1273     if (percent != NULL || !lhsPercent)
1274         SepBuf_AddBytes(buf, match, match_len);
1275
1276     /* Append the suffix of the replacement pattern */
1277     SepBuf_AddStr(buf, rhs);
1278
1279     free(rhs_expanded);
1280 }
1281 #endif
1282
1283
1284 struct ModifyWord_SubstArgs {
1285     const char  *lhs;
1286     size_t      lhsLen;
1287     const char  *rhs;
1288     size_t      rhsLen;
1289     VarPatternFlags pflags;
1290     Boolean     matched;
1291 };
1292
1293 /* Callback for ModifyWords to implement the :S,from,to, modifier.
1294  * Perform a string substitution on the given word. */
1295 static void
1296 ModifyWord_Subst(const char *word, SepBuf *buf, void *data)
1297 {
1298     size_t wordLen = strlen(word);
1299     struct ModifyWord_SubstArgs *args = data;
1300     const char *match;
1301
1302     if ((args->pflags & VARP_SUB_ONE) && args->matched)
1303         goto nosub;
1304
1305     if (args->pflags & VARP_ANCHOR_START) {
1306         if (wordLen < args->lhsLen ||
1307             memcmp(word, args->lhs, args->lhsLen) != 0)
1308             goto nosub;
1309
1310         if ((args->pflags & VARP_ANCHOR_END) && wordLen != args->lhsLen)
1311             goto nosub;
1312
1313         /* :S,^prefix,replacement, or :S,^whole$,replacement, */
1314         SepBuf_AddBytes(buf, args->rhs, args->rhsLen);
1315         SepBuf_AddBytes(buf, word + args->lhsLen, wordLen - args->lhsLen);
1316         args->matched = TRUE;
1317         return;
1318     }
1319
1320     if (args->pflags & VARP_ANCHOR_END) {
1321         const char *start;
1322
1323         if (wordLen < args->lhsLen)
1324             goto nosub;
1325
1326         start = word + (wordLen - args->lhsLen);
1327         if (memcmp(start, args->lhs, args->lhsLen) != 0)
1328             goto nosub;
1329
1330         /* :S,suffix$,replacement, */
1331         SepBuf_AddBytesBetween(buf, word, start);
1332         SepBuf_AddBytes(buf, args->rhs, args->rhsLen);
1333         args->matched = TRUE;
1334         return;
1335     }
1336
1337     if (args->lhs[0] == '\0')
1338         goto nosub;
1339
1340     /* unanchored case, may match more than once */
1341     while ((match = strstr(word, args->lhs)) != NULL) {
1342         SepBuf_AddBytesBetween(buf, word, match);
1343         SepBuf_AddBytes(buf, args->rhs, args->rhsLen);
1344         args->matched = TRUE;
1345         wordLen -= (size_t)(match - word) + args->lhsLen;
1346         word += (size_t)(match - word) + args->lhsLen;
1347         if (wordLen == 0 || !(args->pflags & VARP_SUB_GLOBAL))
1348             break;
1349     }
1350 nosub:
1351     SepBuf_AddBytes(buf, word, wordLen);
1352 }
1353
1354 #ifndef NO_REGEX
1355 /* Print the error caused by a regcomp or regexec call. */
1356 static void
1357 VarREError(int reerr, regex_t *pat, const char *str)
1358 {
1359     size_t errlen = regerror(reerr, pat, 0, 0);
1360     char *errbuf = bmake_malloc(errlen);
1361     regerror(reerr, pat, errbuf, errlen);
1362     Error("%s: %s", str, errbuf);
1363     free(errbuf);
1364 }
1365
1366 struct ModifyWord_SubstRegexArgs {
1367     regex_t re;
1368     size_t nsub;
1369     char *replace;
1370     VarPatternFlags pflags;
1371     Boolean matched;
1372 };
1373
1374 /* Callback for ModifyWords to implement the :C/from/to/ modifier.
1375  * Perform a regex substitution on the given word. */
1376 static void
1377 ModifyWord_SubstRegex(const char *word, SepBuf *buf, void *data)
1378 {
1379     struct ModifyWord_SubstRegexArgs *args = data;
1380     int xrv;
1381     const char *wp = word;
1382     char *rp;
1383     int flags = 0;
1384     regmatch_t m[10];
1385
1386     if ((args->pflags & VARP_SUB_ONE) && args->matched)
1387         goto nosub;
1388
1389 tryagain:
1390     xrv = regexec(&args->re, wp, args->nsub, m, flags);
1391
1392     switch (xrv) {
1393     case 0:
1394         args->matched = TRUE;
1395         SepBuf_AddBytes(buf, wp, (size_t)m[0].rm_so);
1396
1397         for (rp = args->replace; *rp; rp++) {
1398             if (*rp == '\\' && (rp[1] == '&' || rp[1] == '\\')) {
1399                 SepBuf_AddBytes(buf, rp + 1, 1);
1400                 rp++;
1401                 continue;
1402             }
1403
1404             if (*rp == '&') {
1405                 SepBuf_AddBytesBetween(buf, wp + m[0].rm_so, wp + m[0].rm_eo);
1406                 continue;
1407             }
1408
1409             if (*rp != '\\' || !ch_isdigit(rp[1])) {
1410                 SepBuf_AddBytes(buf, rp, 1);
1411                 continue;
1412             }
1413
1414             {                   /* \0 to \9 backreference */
1415                 size_t n = (size_t)(rp[1] - '0');
1416                 rp++;
1417
1418                 if (n >= args->nsub) {
1419                     Error("No subexpression \\%zu", n);
1420                 } else if (m[n].rm_so == -1) {
1421                     Error("No match for subexpression \\%zu", n);
1422                 } else {
1423                     SepBuf_AddBytesBetween(buf, wp + m[n].rm_so,
1424                                            wp + m[n].rm_eo);
1425                 }
1426             }
1427         }
1428
1429         wp += m[0].rm_eo;
1430         if (args->pflags & VARP_SUB_GLOBAL) {
1431             flags |= REG_NOTBOL;
1432             if (m[0].rm_so == 0 && m[0].rm_eo == 0) {
1433                 SepBuf_AddBytes(buf, wp, 1);
1434                 wp++;
1435             }
1436             if (*wp)
1437                 goto tryagain;
1438         }
1439         if (*wp) {
1440             SepBuf_AddStr(buf, wp);
1441         }
1442         break;
1443     default:
1444         VarREError(xrv, &args->re, "Unexpected regex error");
1445         /* FALLTHROUGH */
1446     case REG_NOMATCH:
1447     nosub:
1448         SepBuf_AddStr(buf, wp);
1449         break;
1450     }
1451 }
1452 #endif
1453
1454
1455 struct ModifyWord_LoopArgs {
1456     GNode       *ctx;
1457     char        *tvar;          /* name of temporary variable */
1458     char        *str;           /* string to expand */
1459     VarEvalFlags eflags;
1460 };
1461
1462 /* Callback for ModifyWords to implement the :@var@...@ modifier of ODE make. */
1463 static void
1464 ModifyWord_Loop(const char *word, SepBuf *buf, void *data)
1465 {
1466     const struct ModifyWord_LoopArgs *args;
1467     char *s;
1468
1469     if (word[0] == '\0')
1470         return;
1471
1472     args = data;
1473     Var_Set_with_flags(args->tvar, word, args->ctx, VAR_NO_EXPORT);
1474     (void)Var_Subst(args->str, args->ctx, args->eflags, &s);
1475     /* TODO: handle errors */
1476
1477     VAR_DEBUG4("ModifyWord_Loop: "
1478                "in \"%s\", replace \"%s\" with \"%s\" to \"%s\"\n",
1479                word, args->tvar, args->str, s);
1480
1481     if (s[0] == '\n' || Buf_EndsWith(&buf->buf, '\n'))
1482         buf->needSep = FALSE;
1483     SepBuf_AddStr(buf, s);
1484     free(s);
1485 }
1486
1487
1488 /* The :[first..last] modifier selects words from the expression.
1489  * It can also reverse the words. */
1490 static char *
1491 VarSelectWords(char sep, Boolean oneBigWord, const char *str, int first,
1492                int last)
1493 {
1494     Words words;
1495     int len, start, end, step;
1496     int i;
1497
1498     SepBuf buf;
1499     SepBuf_Init(&buf, sep);
1500
1501     if (oneBigWord) {
1502         /* fake what Str_Words() would do if there were only one word */
1503         words.len = 1;
1504         words.words = bmake_malloc((words.len + 1) * sizeof(char *));
1505         words.freeIt = bmake_strdup(str);
1506         words.words[0] = words.freeIt;
1507         words.words[1] = NULL;
1508     } else {
1509         words = Str_Words(str, FALSE);
1510     }
1511
1512     /*
1513      * Now sanitize the given range.
1514      * If first or last are negative, convert them to the positive equivalents
1515      * (-1 gets converted to ac, -2 gets converted to (ac - 1), etc.).
1516      */
1517     len = (int)words.len;
1518     if (first < 0)
1519         first += len + 1;
1520     if (last < 0)
1521         last += len + 1;
1522
1523     /*
1524      * We avoid scanning more of the list than we need to.
1525      */
1526     if (first > last) {
1527         start = (first > len ? len : first) - 1;
1528         end = last < 1 ? 0 : last - 1;
1529         step = -1;
1530     } else {
1531         start = first < 1 ? 0 : first - 1;
1532         end = last > len ? len : last;
1533         step = 1;
1534     }
1535
1536     for (i = start; (step < 0) == (i >= end); i += step) {
1537         SepBuf_AddStr(&buf, words.words[i]);
1538         SepBuf_Sep(&buf);
1539     }
1540
1541     Words_Free(words);
1542
1543     return SepBuf_Destroy(&buf, FALSE);
1544 }
1545
1546
1547 /* Callback for ModifyWords to implement the :tA modifier.
1548  * Replace each word with the result of realpath() if successful. */
1549 static void
1550 ModifyWord_Realpath(const char *word, SepBuf *buf, void *data MAKE_ATTR_UNUSED)
1551 {
1552     struct stat st;
1553     char rbuf[MAXPATHLEN];
1554
1555     const char *rp = cached_realpath(word, rbuf);
1556     if (rp != NULL && *rp == '/' && stat(rp, &st) == 0)
1557         word = rp;
1558
1559     SepBuf_AddStr(buf, word);
1560 }
1561
1562 /* Modify each of the words of the passed string using the given function.
1563  *
1564  * Input:
1565  *      str             String whose words should be modified
1566  *      modifyWord      Function that modifies a single word
1567  *      modifyWord_args Custom arguments for modifyWord
1568  *
1569  * Results:
1570  *      A string of all the words modified appropriately.
1571  *-----------------------------------------------------------------------
1572  */
1573 static char *
1574 ModifyWords(const char *str,
1575             ModifyWordsCallback modifyWord, void *modifyWord_args,
1576             Boolean oneBigWord, char sep)
1577 {
1578     SepBuf result;
1579     Words words;
1580     size_t i;
1581
1582     if (oneBigWord) {
1583         SepBuf_Init(&result, sep);
1584         modifyWord(str, &result, modifyWord_args);
1585         return SepBuf_Destroy(&result, FALSE);
1586     }
1587
1588     SepBuf_Init(&result, sep);
1589
1590     words = Str_Words(str, FALSE);
1591
1592     VAR_DEBUG2("ModifyWords: split \"%s\" into %zu words\n", str, words.len);
1593
1594     for (i = 0; i < words.len; i++) {
1595         modifyWord(words.words[i], &result, modifyWord_args);
1596         if (Buf_Len(&result.buf) > 0)
1597             SepBuf_Sep(&result);
1598     }
1599
1600     Words_Free(words);
1601
1602     return SepBuf_Destroy(&result, FALSE);
1603 }
1604
1605
1606 static char *
1607 Words_JoinFree(Words words)
1608 {
1609     Buffer buf;
1610     size_t i;
1611
1612     Buf_Init(&buf, 0);
1613
1614     for (i = 0; i < words.len; i++) {
1615         if (i != 0)
1616             Buf_AddByte(&buf, ' ');     /* XXX: st->sep, for consistency */
1617         Buf_AddStr(&buf, words.words[i]);
1618     }
1619
1620     Words_Free(words);
1621
1622     return Buf_Destroy(&buf, FALSE);
1623 }
1624
1625 /* Remove adjacent duplicate words. */
1626 static char *
1627 VarUniq(const char *str)
1628 {
1629     Words words = Str_Words(str, FALSE);
1630
1631     if (words.len > 1) {
1632         size_t i, j;
1633         for (j = 0, i = 1; i < words.len; i++)
1634             if (strcmp(words.words[i], words.words[j]) != 0 && (++j != i))
1635                 words.words[j] = words.words[i];
1636         words.len = j + 1;
1637     }
1638
1639     return Words_JoinFree(words);
1640 }
1641
1642
1643 /* Quote shell meta-characters and space characters in the string.
1644  * If quoteDollar is set, also quote and double any '$' characters. */
1645 static char *
1646 VarQuote(const char *str, Boolean quoteDollar)
1647 {
1648     Buffer buf;
1649     Buf_Init(&buf, 0);
1650
1651     for (; *str != '\0'; str++) {
1652         if (*str == '\n') {
1653             const char *newline = Shell_GetNewline();
1654             if (newline == NULL)
1655                 newline = "\\\n";
1656             Buf_AddStr(&buf, newline);
1657             continue;
1658         }
1659         if (ch_isspace(*str) || is_shell_metachar((unsigned char)*str))
1660             Buf_AddByte(&buf, '\\');
1661         Buf_AddByte(&buf, *str);
1662         if (quoteDollar && *str == '$')
1663             Buf_AddStr(&buf, "\\$");
1664     }
1665
1666     return Buf_Destroy(&buf, FALSE);
1667 }
1668
1669 /* Compute the 32-bit hash of the given string, using the MurmurHash3
1670  * algorithm. Output is encoded as 8 hex digits, in Little Endian order. */
1671 static char *
1672 VarHash(const char *str)
1673 {
1674     static const char    hexdigits[16] = "0123456789abcdef";
1675     const unsigned char *ustr = (const unsigned char *)str;
1676
1677     uint32_t h  = 0x971e137bU;
1678     uint32_t c1 = 0x95543787U;
1679     uint32_t c2 = 0x2ad7eb25U;
1680     size_t len2 = strlen(str);
1681
1682     char *buf;
1683     size_t i;
1684
1685     size_t len;
1686     for (len = len2; len; ) {
1687         uint32_t k = 0;
1688         switch (len) {
1689         default:
1690             k = ((uint32_t)ustr[3] << 24) |
1691                 ((uint32_t)ustr[2] << 16) |
1692                 ((uint32_t)ustr[1] << 8) |
1693                 (uint32_t)ustr[0];
1694             len -= 4;
1695             ustr += 4;
1696             break;
1697         case 3:
1698             k |= (uint32_t)ustr[2] << 16;
1699             /* FALLTHROUGH */
1700         case 2:
1701             k |= (uint32_t)ustr[1] << 8;
1702             /* FALLTHROUGH */
1703         case 1:
1704             k |= (uint32_t)ustr[0];
1705             len = 0;
1706         }
1707         c1 = c1 * 5 + 0x7b7d159cU;
1708         c2 = c2 * 5 + 0x6bce6396U;
1709         k *= c1;
1710         k = (k << 11) ^ (k >> 21);
1711         k *= c2;
1712         h = (h << 13) ^ (h >> 19);
1713         h = h * 5 + 0x52dce729U;
1714         h ^= k;
1715     }
1716     h ^= (uint32_t)len2;
1717     h *= 0x85ebca6b;
1718     h ^= h >> 13;
1719     h *= 0xc2b2ae35;
1720     h ^= h >> 16;
1721
1722     buf = bmake_malloc(9);
1723     for (i = 0; i < 8; i++) {
1724         buf[i] = hexdigits[h & 0x0f];
1725         h >>= 4;
1726     }
1727     buf[8] = '\0';
1728     return buf;
1729 }
1730
1731 static char *
1732 VarStrftime(const char *fmt, Boolean zulu, time_t tim)
1733 {
1734     char buf[BUFSIZ];
1735
1736     if (!tim)
1737         time(&tim);
1738     if (!*fmt)
1739         fmt = "%c";
1740     strftime(buf, sizeof(buf), fmt, zulu ? gmtime(&tim) : localtime(&tim));
1741
1742     buf[sizeof(buf) - 1] = '\0';
1743     return bmake_strdup(buf);
1744 }
1745
1746 /* The ApplyModifier functions all work in the same way.  They get the
1747  * current parsing position (pp) and parse the modifier from there.  The
1748  * modifier typically lasts until the next ':', or a closing '}' or ')'
1749  * (taken from st->endc), or the end of the string (parse error).
1750  *
1751  * The high-level behavior of these functions is:
1752  *
1753  * 1. parse the modifier
1754  * 2. evaluate the modifier
1755  * 3. housekeeping
1756  *
1757  * Parsing the modifier
1758  *
1759  * If parsing succeeds, the parsing position *pp is updated to point to the
1760  * first character following the modifier, which typically is either ':' or
1761  * st->endc.
1762  *
1763  * If parsing fails because of a missing delimiter (as in the :S, :C or :@
1764  * modifiers), return AMR_CLEANUP.
1765  *
1766  * If parsing fails because the modifier is unknown, return AMR_UNKNOWN to
1767  * try the SysV modifier ${VAR:from=to} as fallback.  This should only be
1768  * done as long as there have been no side effects from evaluating nested
1769  * variables, to avoid evaluating them more than once.  In this case, the
1770  * parsing position must not be updated.  (XXX: Why not? The original parsing
1771  * position is well-known in ApplyModifiers.)
1772  *
1773  * If parsing fails and the SysV modifier ${VAR:from=to} should not be used
1774  * as a fallback, either issue an error message using Error or Parse_Error
1775  * and then return AMR_CLEANUP, or return AMR_BAD for the default error
1776  * message.  Both of these return values will stop processing the variable
1777  * expression.  (XXX: As of 2020-08-23, evaluation of the whole string
1778  * continues nevertheless after skipping a few bytes, which essentially is
1779  * undefined behavior.  Not in the sense of C, but still it's impossible to
1780  * predict what happens in the parser.)
1781  *
1782  * Evaluating the modifier
1783  *
1784  * After parsing, the modifier is evaluated.  The side effects from evaluating
1785  * nested variable expressions in the modifier text often already happen
1786  * during parsing though.
1787  *
1788  * Evaluating the modifier usually takes the current value of the variable
1789  * expression from st->val, or the variable name from st->v->name and stores
1790  * the result in st->newVal.
1791  *
1792  * If evaluating fails (as of 2020-08-23), an error message is printed using
1793  * Error.  This function has no side-effects, it really just prints the error
1794  * message.  Processing the expression continues as if everything were ok.
1795  * XXX: This should be fixed by adding proper error handling to Var_Subst,
1796  * Var_Parse, ApplyModifiers and ModifyWords.
1797  *
1798  * Housekeeping
1799  *
1800  * Some modifiers such as :D and :U turn undefined expressions into defined
1801  * expressions (see VEF_UNDEF, VEF_DEF).
1802  *
1803  * Some modifiers need to free some memory.
1804  */
1805
1806 typedef enum VarExprFlags {
1807     /* The variable expression is based on an undefined variable. */
1808     VEF_UNDEF = 0x01,
1809     /* The variable expression started as an undefined expression, but one
1810      * of the modifiers (such as :D or :U) has turned the expression from
1811      * undefined to defined. */
1812     VEF_DEF = 0x02
1813 } VarExprFlags;
1814
1815 ENUM_FLAGS_RTTI_2(VarExprFlags,
1816                   VEF_UNDEF, VEF_DEF);
1817
1818
1819 typedef struct ApplyModifiersState {
1820     const char startc;          /* '\0' or '{' or '(' */
1821     const char endc;            /* '\0' or '}' or ')' */
1822     Var * const v;
1823     GNode * const ctxt;
1824     const VarEvalFlags eflags;
1825
1826     char *val;                  /* The old value of the expression,
1827                                  * before applying the modifier, never NULL */
1828     char *newVal;               /* The new value of the expression,
1829                                  * after applying the modifier, never NULL */
1830     char sep;                   /* Word separator in expansions
1831                                  * (see the :ts modifier) */
1832     Boolean oneBigWord;         /* TRUE if some modifiers that otherwise split
1833                                  * the variable value into words, like :S and
1834                                  * :C, treat the variable value as a single big
1835                                  * word, possibly containing spaces. */
1836     VarExprFlags exprFlags;
1837 } ApplyModifiersState;
1838
1839 static void
1840 ApplyModifiersState_Define(ApplyModifiersState *st)
1841 {
1842     if (st->exprFlags & VEF_UNDEF)
1843         st->exprFlags |= VEF_DEF;
1844 }
1845
1846 typedef enum ApplyModifierResult {
1847     AMR_OK,                     /* Continue parsing */
1848     AMR_UNKNOWN,                /* Not a match, try other modifiers as well */
1849     AMR_BAD,                    /* Error out with "Bad modifier" message */
1850     AMR_CLEANUP                 /* Error out without error message */
1851 } ApplyModifierResult;
1852
1853 /* Allow backslashes to escape the delimiter, $, and \, but don't touch other
1854  * backslashes. */
1855 static Boolean
1856 IsEscapedModifierPart(const char *p, char delim,
1857                       struct ModifyWord_SubstArgs *subst)
1858 {
1859     if (p[0] != '\\')
1860         return FALSE;
1861     if (p[1] == delim || p[1] == '\\' || p[1] == '$')
1862         return TRUE;
1863     return p[1] == '&' && subst != NULL;
1864 }
1865
1866 /*
1867  * Parse a part of a modifier such as the "from" and "to" in :S/from/to/ or
1868  * the "var" or "replacement ${var}" in :@var@replacement ${var}@, up to and
1869  * including the next unescaped delimiter.  The delimiter, as well as the
1870  * backslash or the dollar, can be escaped with a backslash.
1871  *
1872  * Return the parsed (and possibly expanded) string, or NULL if no delimiter
1873  * was found.  On successful return, the parsing position pp points right
1874  * after the delimiter.  The delimiter is not included in the returned
1875  * value though.
1876  */
1877 static VarParseResult
1878 ParseModifierPart(
1879     const char **pp,            /* The parsing position, updated upon return */
1880     char delim,                 /* Parsing stops at this delimiter */
1881     VarEvalFlags eflags,        /* Flags for evaluating nested variables;
1882                                  * if VARE_WANTRES is not set, the text is
1883                                  * only parsed */
1884     ApplyModifiersState *st,
1885     char **out_part,
1886     size_t *out_length,         /* Optionally stores the length of the returned
1887                                  * string, just to save another strlen call. */
1888     VarPatternFlags *out_pflags,/* For the first part of the :S modifier,
1889                                  * sets the VARP_ANCHOR_END flag if the last
1890                                  * character of the pattern is a $. */
1891     struct ModifyWord_SubstArgs *subst
1892                                 /* For the second part of the :S modifier,
1893                                  * allow ampersands to be escaped and replace
1894                                  * unescaped ampersands with subst->lhs. */
1895 ) {
1896     Buffer buf;
1897     const char *p;
1898
1899     Buf_Init(&buf, 0);
1900
1901     /*
1902      * Skim through until the matching delimiter is found; pick up variable
1903      * expressions on the way.
1904      */
1905     p = *pp;
1906     while (*p != '\0' && *p != delim) {
1907         const char *varstart;
1908
1909         if (IsEscapedModifierPart(p, delim, subst)) {
1910             Buf_AddByte(&buf, p[1]);
1911             p += 2;
1912             continue;
1913         }
1914
1915         if (*p != '$') {        /* Unescaped, simple text */
1916             if (subst != NULL && *p == '&')
1917                 Buf_AddBytes(&buf, subst->lhs, subst->lhsLen);
1918             else
1919                 Buf_AddByte(&buf, *p);
1920             p++;
1921             continue;
1922         }
1923
1924         if (p[1] == delim) {    /* Unescaped $ at end of pattern */
1925             if (out_pflags != NULL)
1926                 *out_pflags |= VARP_ANCHOR_END;
1927             else
1928                 Buf_AddByte(&buf, *p);
1929             p++;
1930             continue;
1931         }
1932
1933         if (eflags & VARE_WANTRES) {    /* Nested variable, evaluated */
1934             const char *nested_p = p;
1935             const char *nested_val;
1936             void *nested_val_freeIt;
1937             VarEvalFlags nested_eflags = eflags & ~(unsigned)VARE_ASSIGN;
1938
1939             (void)Var_Parse(&nested_p, st->ctxt, nested_eflags,
1940                             &nested_val, &nested_val_freeIt);
1941             /* TODO: handle errors */
1942             Buf_AddStr(&buf, nested_val);
1943             free(nested_val_freeIt);
1944             p += nested_p - p;
1945             continue;
1946         }
1947
1948         /* XXX: This whole block is very similar to Var_Parse without
1949          * VARE_WANTRES.  There may be subtle edge cases though that are
1950          * not yet covered in the unit tests and that are parsed differently,
1951          * depending on whether they are evaluated or not.
1952          *
1953          * This subtle difference is not documented in the manual page,
1954          * neither is the difference between parsing :D and :M documented.
1955          * No code should ever depend on these details, but who knows. */
1956
1957         varstart = p;           /* Nested variable, only parsed */
1958         if (p[1] == '(' || p[1] == '{') {
1959             /*
1960              * Find the end of this variable reference
1961              * and suck it in without further ado.
1962              * It will be interpreted later.
1963              */
1964             char startc = p[1];
1965             int endc = startc == '(' ? ')' : '}';
1966             int depth = 1;
1967
1968             for (p += 2; *p != '\0' && depth > 0; p++) {
1969                 if (p[-1] != '\\') {
1970                     if (*p == startc)
1971                         depth++;
1972                     if (*p == endc)
1973                         depth--;
1974                 }
1975             }
1976             Buf_AddBytesBetween(&buf, varstart, p);
1977         } else {
1978             Buf_AddByte(&buf, *varstart);
1979             p++;
1980         }
1981     }
1982
1983     if (*p != delim) {
1984         *pp = p;
1985         Error("Unfinished modifier for %s ('%c' missing)", st->v->name, delim);
1986         *out_part = NULL;
1987         return VPR_PARSE_MSG;
1988     }
1989
1990     *pp = ++p;
1991     if (out_length != NULL)
1992         *out_length = Buf_Len(&buf);
1993
1994     *out_part = Buf_Destroy(&buf, FALSE);
1995     VAR_DEBUG1("Modifier part: \"%s\"\n", *out_part);
1996     return VPR_OK;
1997 }
1998
1999 /* Test whether mod starts with modname, followed by a delimiter. */
2000 static Boolean
2001 ModMatch(const char *mod, const char *modname, char endc)
2002 {
2003     size_t n = strlen(modname);
2004     return strncmp(mod, modname, n) == 0 &&
2005            (mod[n] == endc || mod[n] == ':');
2006 }
2007
2008 /* Test whether mod starts with modname, followed by a delimiter or '='. */
2009 static inline Boolean
2010 ModMatchEq(const char *mod, const char *modname, char endc)
2011 {
2012     size_t n = strlen(modname);
2013     return strncmp(mod, modname, n) == 0 &&
2014            (mod[n] == endc || mod[n] == ':' || mod[n] == '=');
2015 }
2016
2017 static Boolean
2018 TryParseIntBase0(const char **pp, int *out_num)
2019 {
2020     char *end;
2021     long n;
2022
2023     errno = 0;
2024     n = strtol(*pp, &end, 0);
2025     if ((n == LONG_MIN || n == LONG_MAX) && errno == ERANGE)
2026         return FALSE;
2027     if (n < INT_MIN || n > INT_MAX)
2028         return FALSE;
2029
2030     *pp = end;
2031     *out_num = (int)n;
2032     return TRUE;
2033 }
2034
2035 static Boolean
2036 TryParseSize(const char **pp, size_t *out_num)
2037 {
2038     char *end;
2039     unsigned long n;
2040
2041     if (!ch_isdigit(**pp))
2042         return FALSE;
2043
2044     errno = 0;
2045     n = strtoul(*pp, &end, 10);
2046     if (n == ULONG_MAX && errno == ERANGE)
2047         return FALSE;
2048     if (n > SIZE_MAX)
2049         return FALSE;
2050
2051     *pp = end;
2052     *out_num = (size_t)n;
2053     return TRUE;
2054 }
2055
2056 static Boolean
2057 TryParseChar(const char **pp, int base, char *out_ch)
2058 {
2059     char *end;
2060     unsigned long n;
2061
2062     if (!ch_isalnum(**pp))
2063         return FALSE;
2064
2065     errno = 0;
2066     n = strtoul(*pp, &end, base);
2067     if (n == ULONG_MAX && errno == ERANGE)
2068         return FALSE;
2069     if (n > UCHAR_MAX)
2070         return FALSE;
2071
2072     *pp = end;
2073     *out_ch = (char)n;
2074     return TRUE;
2075 }
2076
2077 /* :@var@...${var}...@ */
2078 static ApplyModifierResult
2079 ApplyModifier_Loop(const char **pp, ApplyModifiersState *st)
2080 {
2081     struct ModifyWord_LoopArgs args;
2082     char prev_sep;
2083     VarEvalFlags eflags = st->eflags & ~(unsigned)VARE_WANTRES;
2084     VarParseResult res;
2085
2086     args.ctx = st->ctxt;
2087
2088     (*pp)++;                    /* Skip the first '@' */
2089     res = ParseModifierPart(pp, '@', eflags, st,
2090                             &args.tvar, NULL, NULL, NULL);
2091     if (res != VPR_OK)
2092         return AMR_CLEANUP;
2093     if (DEBUG(LINT) && strchr(args.tvar, '$') != NULL) {
2094         Parse_Error(PARSE_FATAL,
2095                     "In the :@ modifier of \"%s\", the variable name \"%s\" "
2096                     "must not contain a dollar.",
2097                     st->v->name, args.tvar);
2098         return AMR_CLEANUP;
2099     }
2100
2101     res = ParseModifierPart(pp, '@', eflags, st,
2102                             &args.str, NULL, NULL, NULL);
2103     if (res != VPR_OK)
2104         return AMR_CLEANUP;
2105
2106     args.eflags = st->eflags & (VARE_UNDEFERR | VARE_WANTRES);
2107     prev_sep = st->sep;
2108     st->sep = ' ';              /* XXX: should be st->sep for consistency */
2109     st->newVal = ModifyWords(st->val, ModifyWord_Loop, &args,
2110                              st->oneBigWord, st->sep);
2111     st->sep = prev_sep;
2112     Var_Delete(args.tvar, st->ctxt);
2113     free(args.tvar);
2114     free(args.str);
2115     return AMR_OK;
2116 }
2117
2118 /* :Ddefined or :Uundefined */
2119 static ApplyModifierResult
2120 ApplyModifier_Defined(const char **pp, ApplyModifiersState *st)
2121 {
2122     Buffer buf;
2123     const char *p;
2124
2125     VarEvalFlags eflags = st->eflags & ~(unsigned)VARE_WANTRES;
2126     if (st->eflags & VARE_WANTRES) {
2127         if ((**pp == 'D') == !(st->exprFlags & VEF_UNDEF))
2128             eflags |= VARE_WANTRES;
2129     }
2130
2131     Buf_Init(&buf, 0);
2132     p = *pp + 1;
2133     while (*p != st->endc && *p != ':' && *p != '\0') {
2134
2135         /* Escaped delimiter or other special character */
2136         if (*p == '\\') {
2137             char c = p[1];
2138             if (c == st->endc || c == ':' || c == '$' || c == '\\') {
2139                 Buf_AddByte(&buf, c);
2140                 p += 2;
2141                 continue;
2142             }
2143         }
2144
2145         /* Nested variable expression */
2146         if (*p == '$') {
2147             const char *nested_val;
2148             void *nested_val_freeIt;
2149
2150             (void)Var_Parse(&p, st->ctxt, eflags,
2151                             &nested_val, &nested_val_freeIt);
2152             /* TODO: handle errors */
2153             Buf_AddStr(&buf, nested_val);
2154             free(nested_val_freeIt);
2155             continue;
2156         }
2157
2158         /* Ordinary text */
2159         Buf_AddByte(&buf, *p);
2160         p++;
2161     }
2162     *pp = p;
2163
2164     ApplyModifiersState_Define(st);
2165
2166     if (eflags & VARE_WANTRES) {
2167         st->newVal = Buf_Destroy(&buf, FALSE);
2168     } else {
2169         st->newVal = st->val;
2170         Buf_Destroy(&buf, TRUE);
2171     }
2172     return AMR_OK;
2173 }
2174
2175 /* :L */
2176 static ApplyModifierResult
2177 ApplyModifier_Literal(const char **pp, ApplyModifiersState *st)
2178 {
2179     ApplyModifiersState_Define(st);
2180     st->newVal = bmake_strdup(st->v->name);
2181     (*pp)++;
2182     return AMR_OK;
2183 }
2184
2185 static Boolean
2186 TryParseTime(const char **pp, time_t *out_time)
2187 {
2188     char *end;
2189     unsigned long n;
2190
2191     if (!ch_isdigit(**pp))
2192         return FALSE;
2193
2194     errno = 0;
2195     n = strtoul(*pp, &end, 10);
2196     if (n == ULONG_MAX && errno == ERANGE)
2197         return FALSE;
2198
2199     *pp = end;
2200     *out_time = (time_t)n;      /* ignore possible truncation for now */
2201     return TRUE;
2202 }
2203
2204 /* :gmtime */
2205 static ApplyModifierResult
2206 ApplyModifier_Gmtime(const char **pp, ApplyModifiersState *st)
2207 {
2208     time_t utc;
2209
2210     const char *mod = *pp;
2211     if (!ModMatchEq(mod, "gmtime", st->endc))
2212         return AMR_UNKNOWN;
2213
2214     if (mod[6] == '=') {
2215         const char *arg = mod + 7;
2216         if (!TryParseTime(&arg, &utc)) {
2217             Parse_Error(PARSE_FATAL, "Invalid time value: %s\n", mod + 7);
2218             return AMR_CLEANUP;
2219         }
2220         *pp = arg;
2221     } else {
2222         utc = 0;
2223         *pp = mod + 6;
2224     }
2225     st->newVal = VarStrftime(st->val, TRUE, utc);
2226     return AMR_OK;
2227 }
2228
2229 /* :localtime */
2230 static ApplyModifierResult
2231 ApplyModifier_Localtime(const char **pp, ApplyModifiersState *st)
2232 {
2233     time_t utc;
2234
2235     const char *mod = *pp;
2236     if (!ModMatchEq(mod, "localtime", st->endc))
2237         return AMR_UNKNOWN;
2238
2239     if (mod[9] == '=') {
2240         const char *arg = mod + 10;
2241         if (!TryParseTime(&arg, &utc)) {
2242             Parse_Error(PARSE_FATAL, "Invalid time value: %s\n", mod + 10);
2243             return AMR_CLEANUP;
2244         }
2245         *pp = arg;
2246     } else {
2247         utc = 0;
2248         *pp = mod + 9;
2249     }
2250     st->newVal = VarStrftime(st->val, FALSE, utc);
2251     return AMR_OK;
2252 }
2253
2254 /* :hash */
2255 static ApplyModifierResult
2256 ApplyModifier_Hash(const char **pp, ApplyModifiersState *st)
2257 {
2258     if (!ModMatch(*pp, "hash", st->endc))
2259         return AMR_UNKNOWN;
2260
2261     st->newVal = VarHash(st->val);
2262     *pp += 4;
2263     return AMR_OK;
2264 }
2265
2266 /* :P */
2267 static ApplyModifierResult
2268 ApplyModifier_Path(const char **pp, ApplyModifiersState *st)
2269 {
2270     GNode *gn;
2271     char *path;
2272
2273     ApplyModifiersState_Define(st);
2274
2275     gn = Targ_FindNode(st->v->name);
2276     if (gn == NULL || gn->type & OP_NOPATH) {
2277         path = NULL;
2278     } else if (gn->path != NULL) {
2279         path = bmake_strdup(gn->path);
2280     } else {
2281         SearchPath *searchPath = Suff_FindPath(gn);
2282         path = Dir_FindFile(st->v->name, searchPath);
2283     }
2284     if (path == NULL)
2285         path = bmake_strdup(st->v->name);
2286     st->newVal = path;
2287
2288     (*pp)++;
2289     return AMR_OK;
2290 }
2291
2292 /* :!cmd! */
2293 static ApplyModifierResult
2294 ApplyModifier_ShellCommand(const char **pp, ApplyModifiersState *st)
2295 {
2296     char *cmd;
2297     const char *errfmt;
2298     VarParseResult res;
2299
2300     (*pp)++;
2301     res = ParseModifierPart(pp, '!', st->eflags, st,
2302                             &cmd, NULL, NULL, NULL);
2303     if (res != VPR_OK)
2304         return AMR_CLEANUP;
2305
2306     errfmt = NULL;
2307     if (st->eflags & VARE_WANTRES)
2308         st->newVal = Cmd_Exec(cmd, &errfmt);
2309     else
2310         st->newVal = emptyString;
2311     free(cmd);
2312
2313     if (errfmt != NULL)
2314         Error(errfmt, st->val); /* XXX: why still return AMR_OK? */
2315
2316     ApplyModifiersState_Define(st);
2317     return AMR_OK;
2318 }
2319
2320 /* The :range modifier generates an integer sequence as long as the words.
2321  * The :range=7 modifier generates an integer sequence from 1 to 7. */
2322 static ApplyModifierResult
2323 ApplyModifier_Range(const char **pp, ApplyModifiersState *st)
2324 {
2325     size_t n;
2326     Buffer buf;
2327     size_t i;
2328
2329     const char *mod = *pp;
2330     if (!ModMatchEq(mod, "range", st->endc))
2331         return AMR_UNKNOWN;
2332
2333     if (mod[5] == '=') {
2334         const char *p = mod + 6;
2335         if (!TryParseSize(&p, &n)) {
2336             Parse_Error(PARSE_FATAL, "Invalid number: %s\n", mod + 6);
2337             return AMR_CLEANUP;
2338         }
2339         *pp = p;
2340     } else {
2341         n = 0;
2342         *pp = mod + 5;
2343     }
2344
2345     if (n == 0) {
2346         Words words = Str_Words(st->val, FALSE);
2347         n = words.len;
2348         Words_Free(words);
2349     }
2350
2351     Buf_Init(&buf, 0);
2352
2353     for (i = 0; i < n; i++) {
2354         if (i != 0)
2355             Buf_AddByte(&buf, ' ');     /* XXX: st->sep, for consistency */
2356         Buf_AddInt(&buf, 1 + (int)i);
2357     }
2358
2359     st->newVal = Buf_Destroy(&buf, FALSE);
2360     return AMR_OK;
2361 }
2362
2363 /* :Mpattern or :Npattern */
2364 static ApplyModifierResult
2365 ApplyModifier_Match(const char **pp, ApplyModifiersState *st)
2366 {
2367     const char *mod = *pp;
2368     Boolean copy = FALSE;       /* pattern should be, or has been, copied */
2369     Boolean needSubst = FALSE;
2370     const char *endpat;
2371     char *pattern;
2372     ModifyWordsCallback callback;
2373
2374     /*
2375      * In the loop below, ignore ':' unless we are at (or back to) the
2376      * original brace level.
2377      * XXX This will likely not work right if $() and ${} are intermixed.
2378      */
2379     int nest = 0;
2380     const char *p;
2381     for (p = mod + 1; *p != '\0' && !(*p == ':' && nest == 0); p++) {
2382         if (*p == '\\' &&
2383             (p[1] == ':' || p[1] == st->endc || p[1] == st->startc)) {
2384             if (!needSubst)
2385                 copy = TRUE;
2386             p++;
2387             continue;
2388         }
2389         if (*p == '$')
2390             needSubst = TRUE;
2391         if (*p == '(' || *p == '{')
2392             nest++;
2393         if (*p == ')' || *p == '}') {
2394             nest--;
2395             if (nest < 0)
2396                 break;
2397         }
2398     }
2399     *pp = p;
2400     endpat = p;
2401
2402     if (copy) {
2403         char *dst;
2404         const char *src;
2405
2406         /* Compress the \:'s out of the pattern. */
2407         pattern = bmake_malloc((size_t)(endpat - (mod + 1)) + 1);
2408         dst = pattern;
2409         src = mod + 1;
2410         for (; src < endpat; src++, dst++) {
2411             if (src[0] == '\\' && src + 1 < endpat &&
2412                 /* XXX: st->startc is missing here; see above */
2413                 (src[1] == ':' || src[1] == st->endc))
2414                 src++;
2415             *dst = *src;
2416         }
2417         *dst = '\0';
2418         endpat = dst;
2419     } else {
2420         pattern = bmake_strsedup(mod + 1, endpat);
2421     }
2422
2423     if (needSubst) {
2424         /* pattern contains embedded '$', so use Var_Subst to expand it. */
2425         char *old_pattern = pattern;
2426         (void)Var_Subst(pattern, st->ctxt, st->eflags, &pattern);
2427         /* TODO: handle errors */
2428         free(old_pattern);
2429     }
2430
2431     VAR_DEBUG3("Pattern[%s] for [%s] is [%s]\n", st->v->name, st->val, pattern);
2432
2433     callback = mod[0] == 'M' ? ModifyWord_Match : ModifyWord_NoMatch;
2434     st->newVal = ModifyWords(st->val, callback, pattern,
2435                              st->oneBigWord, st->sep);
2436     free(pattern);
2437     return AMR_OK;
2438 }
2439
2440 /* :S,from,to, */
2441 static ApplyModifierResult
2442 ApplyModifier_Subst(const char **pp, ApplyModifiersState *st)
2443 {
2444     struct ModifyWord_SubstArgs args;
2445     char *lhs, *rhs;
2446     Boolean oneBigWord;
2447     VarParseResult res;
2448
2449     char delim = (*pp)[1];
2450     if (delim == '\0') {
2451         Error("Missing delimiter for :S modifier");
2452         (*pp)++;
2453         return AMR_CLEANUP;
2454     }
2455
2456     *pp += 2;
2457
2458     args.pflags = 0;
2459     args.matched = FALSE;
2460
2461     /*
2462      * If pattern begins with '^', it is anchored to the
2463      * start of the word -- skip over it and flag pattern.
2464      */
2465     if (**pp == '^') {
2466         args.pflags |= VARP_ANCHOR_START;
2467         (*pp)++;
2468     }
2469
2470     res = ParseModifierPart(pp, delim, st->eflags, st,
2471                             &lhs, &args.lhsLen, &args.pflags, NULL);
2472     if (res != VPR_OK)
2473         return AMR_CLEANUP;
2474     args.lhs = lhs;
2475
2476     res = ParseModifierPart(pp, delim, st->eflags, st,
2477                             &rhs, &args.rhsLen, NULL, &args);
2478     if (res != VPR_OK)
2479         return AMR_CLEANUP;
2480     args.rhs = rhs;
2481
2482     oneBigWord = st->oneBigWord;
2483     for (;; (*pp)++) {
2484         switch (**pp) {
2485         case 'g':
2486             args.pflags |= VARP_SUB_GLOBAL;
2487             continue;
2488         case '1':
2489             args.pflags |= VARP_SUB_ONE;
2490             continue;
2491         case 'W':
2492             oneBigWord = TRUE;
2493             continue;
2494         }
2495         break;
2496     }
2497
2498     st->newVal = ModifyWords(st->val, ModifyWord_Subst, &args,
2499                              oneBigWord, st->sep);
2500
2501     free(lhs);
2502     free(rhs);
2503     return AMR_OK;
2504 }
2505
2506 #ifndef NO_REGEX
2507
2508 /* :C,from,to, */
2509 static ApplyModifierResult
2510 ApplyModifier_Regex(const char **pp, ApplyModifiersState *st)
2511 {
2512     char *re;
2513     struct ModifyWord_SubstRegexArgs args;
2514     Boolean oneBigWord;
2515     int error;
2516     VarParseResult res;
2517
2518     char delim = (*pp)[1];
2519     if (delim == '\0') {
2520         Error("Missing delimiter for :C modifier");
2521         (*pp)++;
2522         return AMR_CLEANUP;
2523     }
2524
2525     *pp += 2;
2526
2527     res = ParseModifierPart(pp, delim, st->eflags, st,
2528                             &re, NULL, NULL, NULL);
2529     if (res != VPR_OK)
2530         return AMR_CLEANUP;
2531
2532     res = ParseModifierPart(pp, delim, st->eflags, st,
2533                             &args.replace, NULL, NULL, NULL);
2534     if (args.replace == NULL) {
2535         free(re);
2536         return AMR_CLEANUP;
2537     }
2538
2539     args.pflags = 0;
2540     args.matched = FALSE;
2541     oneBigWord = st->oneBigWord;
2542     for (;; (*pp)++) {
2543         switch (**pp) {
2544         case 'g':
2545             args.pflags |= VARP_SUB_GLOBAL;
2546             continue;
2547         case '1':
2548             args.pflags |= VARP_SUB_ONE;
2549             continue;
2550         case 'W':
2551             oneBigWord = TRUE;
2552             continue;
2553         }
2554         break;
2555     }
2556
2557     error = regcomp(&args.re, re, REG_EXTENDED);
2558     free(re);
2559     if (error) {
2560         VarREError(error, &args.re, "Regex compilation error");
2561         free(args.replace);
2562         return AMR_CLEANUP;
2563     }
2564
2565     args.nsub = args.re.re_nsub + 1;
2566     if (args.nsub > 10)
2567         args.nsub = 10;
2568     st->newVal = ModifyWords(st->val, ModifyWord_SubstRegex, &args,
2569                              oneBigWord, st->sep);
2570     regfree(&args.re);
2571     free(args.replace);
2572     return AMR_OK;
2573 }
2574 #endif
2575
2576 /* :Q, :q */
2577 static ApplyModifierResult
2578 ApplyModifier_Quote(const char **pp, ApplyModifiersState *st)
2579 {
2580     if ((*pp)[1] == st->endc || (*pp)[1] == ':') {
2581         st->newVal = VarQuote(st->val, **pp == 'q');
2582         (*pp)++;
2583         return AMR_OK;
2584     } else
2585         return AMR_UNKNOWN;
2586 }
2587
2588 static void
2589 ModifyWord_Copy(const char *word, SepBuf *buf, void *data MAKE_ATTR_UNUSED)
2590 {
2591     SepBuf_AddStr(buf, word);
2592 }
2593
2594 /* :ts<separator> */
2595 static ApplyModifierResult
2596 ApplyModifier_ToSep(const char **pp, ApplyModifiersState *st)
2597 {
2598     const char *sep = *pp + 2;
2599
2600     /* ":ts<any><endc>" or ":ts<any>:" */
2601     if (sep[0] != st->endc && (sep[1] == st->endc || sep[1] == ':')) {
2602         st->sep = sep[0];
2603         *pp = sep + 1;
2604         goto ok;
2605     }
2606
2607     /* ":ts<endc>" or ":ts:" */
2608     if (sep[0] == st->endc || sep[0] == ':') {
2609         st->sep = '\0';         /* no separator */
2610         *pp = sep;
2611         goto ok;
2612     }
2613
2614     /* ":ts<unrecognised><unrecognised>". */
2615     if (sep[0] != '\\') {
2616         (*pp)++;                /* just for backwards compatibility */
2617         return AMR_BAD;
2618     }
2619
2620     /* ":ts\n" */
2621     if (sep[1] == 'n') {
2622         st->sep = '\n';
2623         *pp = sep + 2;
2624         goto ok;
2625     }
2626
2627     /* ":ts\t" */
2628     if (sep[1] == 't') {
2629         st->sep = '\t';
2630         *pp = sep + 2;
2631         goto ok;
2632     }
2633
2634     /* ":ts\x40" or ":ts\100" */
2635     {
2636         const char *p = sep + 1;
2637         int base = 8;           /* assume octal */
2638
2639         if (sep[1] == 'x') {
2640             base = 16;
2641             p++;
2642         } else if (!ch_isdigit(sep[1])) {
2643             (*pp)++;            /* just for backwards compatibility */
2644             return AMR_BAD;     /* ":ts<backslash><unrecognised>". */
2645         }
2646
2647         if (!TryParseChar(&p, base, &st->sep)) {
2648             Parse_Error(PARSE_FATAL, "Invalid character number: %s\n", p);
2649             return AMR_CLEANUP;
2650         }
2651         if (*p != ':' && *p != st->endc) {
2652             (*pp)++;            /* just for backwards compatibility */
2653             return AMR_BAD;
2654         }
2655
2656         *pp = p;
2657     }
2658
2659 ok:
2660     st->newVal = ModifyWords(st->val, ModifyWord_Copy, NULL,
2661                              st->oneBigWord, st->sep);
2662     return AMR_OK;
2663 }
2664
2665 /* :tA, :tu, :tl, :ts<separator>, etc. */
2666 static ApplyModifierResult
2667 ApplyModifier_To(const char **pp, ApplyModifiersState *st)
2668 {
2669     const char *mod = *pp;
2670     assert(mod[0] == 't');
2671
2672     if (mod[1] == st->endc || mod[1] == ':' || mod[1] == '\0') {
2673         *pp = mod + 1;
2674         return AMR_BAD;         /* Found ":t<endc>" or ":t:". */
2675     }
2676
2677     if (mod[1] == 's')
2678         return ApplyModifier_ToSep(pp, st);
2679
2680     if (mod[2] != st->endc && mod[2] != ':') {
2681         *pp = mod + 1;
2682         return AMR_BAD;         /* Found ":t<unrecognised><unrecognised>". */
2683     }
2684
2685     /* Check for two-character options: ":tu", ":tl" */
2686     if (mod[1] == 'A') {        /* absolute path */
2687         st->newVal = ModifyWords(st->val, ModifyWord_Realpath, NULL,
2688                                  st->oneBigWord, st->sep);
2689         *pp = mod + 2;
2690         return AMR_OK;
2691     }
2692
2693     if (mod[1] == 'u') {        /* :tu */
2694         size_t i;
2695         size_t len = strlen(st->val);
2696         st->newVal = bmake_malloc(len + 1);
2697         for (i = 0; i < len + 1; i++)
2698             st->newVal[i] = ch_toupper(st->val[i]);
2699         *pp = mod + 2;
2700         return AMR_OK;
2701     }
2702
2703     if (mod[1] == 'l') {        /* :tl */
2704         size_t i;
2705         size_t len = strlen(st->val);
2706         st->newVal = bmake_malloc(len + 1);
2707         for (i = 0; i < len + 1; i++)
2708             st->newVal[i] = ch_tolower(st->val[i]);
2709         *pp = mod + 2;
2710         return AMR_OK;
2711     }
2712
2713     if (mod[1] == 'W' || mod[1] == 'w') { /* :tW, :tw */
2714         st->oneBigWord = mod[1] == 'W';
2715         st->newVal = st->val;
2716         *pp = mod + 2;
2717         return AMR_OK;
2718     }
2719
2720     /* Found ":t<unrecognised>:" or ":t<unrecognised><endc>". */
2721     *pp = mod + 1;
2722     return AMR_BAD;
2723 }
2724
2725 /* :[#], :[1], :[-1..1], etc. */
2726 static ApplyModifierResult
2727 ApplyModifier_Words(const char **pp, ApplyModifiersState *st)
2728 {
2729     char *estr;
2730     int first, last;
2731     VarParseResult res;
2732     const char *p;
2733
2734     (*pp)++;                    /* skip the '[' */
2735     res = ParseModifierPart(pp, ']', st->eflags, st,
2736                             &estr, NULL, NULL, NULL);
2737     if (res != VPR_OK)
2738         return AMR_CLEANUP;
2739
2740     /* now *pp points just after the closing ']' */
2741     if (**pp != ':' && **pp != st->endc)
2742         goto bad_modifier;      /* Found junk after ']' */
2743
2744     if (estr[0] == '\0')
2745         goto bad_modifier;      /* empty square brackets in ":[]". */
2746
2747     if (estr[0] == '#' && estr[1] == '\0') { /* Found ":[#]" */
2748         if (st->oneBigWord) {
2749             st->newVal = bmake_strdup("1");
2750         } else {
2751             Buffer buf;
2752
2753             Words words = Str_Words(st->val, FALSE);
2754             size_t ac = words.len;
2755             Words_Free(words);
2756
2757             Buf_Init(&buf, 4);  /* 3 digits + '\0' is usually enough */
2758             Buf_AddInt(&buf, (int)ac);
2759             st->newVal = Buf_Destroy(&buf, FALSE);
2760         }
2761         goto ok;
2762     }
2763
2764     if (estr[0] == '*' && estr[1] == '\0') {
2765         /* Found ":[*]" */
2766         st->oneBigWord = TRUE;
2767         st->newVal = st->val;
2768         goto ok;
2769     }
2770
2771     if (estr[0] == '@' && estr[1] == '\0') {
2772         /* Found ":[@]" */
2773         st->oneBigWord = FALSE;
2774         st->newVal = st->val;
2775         goto ok;
2776     }
2777
2778     /*
2779      * We expect estr to contain a single integer for :[N], or two integers
2780      * separated by ".." for :[start..end].
2781      */
2782     p = estr;
2783     if (!TryParseIntBase0(&p, &first))
2784         goto bad_modifier;      /* Found junk instead of a number */
2785
2786     if (p[0] == '\0') { /* Found only one integer in :[N] */
2787         last = first;
2788     } else if (p[0] == '.' && p[1] == '.' && p[2] != '\0') {
2789         /* Expecting another integer after ".." */
2790         p += 2;
2791         if (!TryParseIntBase0(&p, &last) || *p != '\0')
2792             goto bad_modifier;  /* Found junk after ".." */
2793     } else
2794         goto bad_modifier;      /* Found junk instead of ".." */
2795
2796     /*
2797      * Now first and last are properly filled in, but we still have to check
2798      * for 0 as a special case.
2799      */
2800     if (first == 0 && last == 0) {
2801         /* ":[0]" or perhaps ":[0..0]" */
2802         st->oneBigWord = TRUE;
2803         st->newVal = st->val;
2804         goto ok;
2805     }
2806
2807     /* ":[0..N]" or ":[N..0]" */
2808     if (first == 0 || last == 0)
2809         goto bad_modifier;
2810
2811     /* Normal case: select the words described by first and last. */
2812     st->newVal = VarSelectWords(st->sep, st->oneBigWord, st->val, first, last);
2813
2814 ok:
2815     free(estr);
2816     return AMR_OK;
2817
2818 bad_modifier:
2819     free(estr);
2820     return AMR_BAD;
2821 }
2822
2823 static int
2824 str_cmp_asc(const void *a, const void *b)
2825 {
2826     return strcmp(*(const char * const *)a, *(const char * const *)b);
2827 }
2828
2829 static int
2830 str_cmp_desc(const void *a, const void *b)
2831 {
2832     return strcmp(*(const char * const *)b, *(const char * const *)a);
2833 }
2834
2835 /* :O (order ascending) or :Or (order descending) or :Ox (shuffle) */
2836 static ApplyModifierResult
2837 ApplyModifier_Order(const char **pp, ApplyModifiersState *st)
2838 {
2839     const char *mod = (*pp)++;  /* skip past the 'O' in any case */
2840
2841     Words words = Str_Words(st->val, FALSE);
2842
2843     if (mod[1] == st->endc || mod[1] == ':') {
2844         /* :O sorts ascending */
2845         qsort(words.words, words.len, sizeof(char *), str_cmp_asc);
2846
2847     } else if ((mod[1] == 'r' || mod[1] == 'x') &&
2848                (mod[2] == st->endc || mod[2] == ':')) {
2849         (*pp)++;
2850
2851         if (mod[1] == 'r') {
2852             /* :Or sorts descending */
2853             qsort(words.words, words.len, sizeof(char *), str_cmp_desc);
2854
2855         } else {
2856             /* :Ox shuffles
2857              *
2858              * We will use [ac..2] range for mod factors. This will produce
2859              * random numbers in [(ac-1)..0] interval, and minimal
2860              * reasonable value for mod factor is 2 (the mod 1 will produce
2861              * 0 with probability 1).
2862              */
2863             size_t i;
2864             for (i = words.len - 1; i > 0; i--) {
2865                 size_t rndidx = (size_t)random() % (i + 1);
2866                 char *t = words.words[i];
2867                 words.words[i] = words.words[rndidx];
2868                 words.words[rndidx] = t;
2869             }
2870         }
2871     } else {
2872         Words_Free(words);
2873         return AMR_BAD;
2874     }
2875
2876     st->newVal = Words_JoinFree(words);
2877     return AMR_OK;
2878 }
2879
2880 /* :? then : else */
2881 static ApplyModifierResult
2882 ApplyModifier_IfElse(const char **pp, ApplyModifiersState *st)
2883 {
2884     char *then_expr, *else_expr;
2885     VarParseResult res;
2886
2887     Boolean value = FALSE;
2888     VarEvalFlags then_eflags = st->eflags & ~(unsigned)VARE_WANTRES;
2889     VarEvalFlags else_eflags = st->eflags & ~(unsigned)VARE_WANTRES;
2890
2891     int cond_rc = COND_PARSE;   /* anything other than COND_INVALID */
2892     if (st->eflags & VARE_WANTRES) {
2893         cond_rc = Cond_EvalCondition(st->v->name, &value);
2894         if (cond_rc != COND_INVALID && value)
2895             then_eflags |= VARE_WANTRES;
2896         if (cond_rc != COND_INVALID && !value)
2897             else_eflags |= VARE_WANTRES;
2898     }
2899
2900     (*pp)++;                    /* skip past the '?' */
2901     res = ParseModifierPart(pp, ':', then_eflags, st,
2902                             &then_expr, NULL, NULL, NULL);
2903     if (res != VPR_OK)
2904         return AMR_CLEANUP;
2905
2906     res = ParseModifierPart(pp, st->endc, else_eflags, st,
2907                             &else_expr, NULL, NULL, NULL);
2908     if (res != VPR_OK)
2909         return AMR_CLEANUP;
2910
2911     (*pp)--;
2912     if (cond_rc == COND_INVALID) {
2913         Error("Bad conditional expression `%s' in %s?%s:%s",
2914               st->v->name, st->v->name, then_expr, else_expr);
2915         return AMR_CLEANUP;
2916     }
2917
2918     if (value) {
2919         st->newVal = then_expr;
2920         free(else_expr);
2921     } else {
2922         st->newVal = else_expr;
2923         free(then_expr);
2924     }
2925     ApplyModifiersState_Define(st);
2926     return AMR_OK;
2927 }
2928
2929 /*
2930  * The ::= modifiers actually assign a value to the variable.
2931  * Their main purpose is in supporting modifiers of .for loop
2932  * iterators and other obscure uses.  They always expand to
2933  * nothing.  In a target rule that would otherwise expand to an
2934  * empty line they can be preceded with @: to keep make happy.
2935  * Eg.
2936  *
2937  * foo: .USE
2938  * .for i in ${.TARGET} ${.TARGET:R}.gz
2939  *      @: ${t::=$i}
2940  *      @echo blah ${t:T}
2941  * .endfor
2942  *
2943  *        ::=<str>      Assigns <str> as the new value of variable.
2944  *        ::?=<str>     Assigns <str> as value of variable if
2945  *                      it was not already set.
2946  *        ::+=<str>     Appends <str> to variable.
2947  *        ::!=<cmd>     Assigns output of <cmd> as the new value of
2948  *                      variable.
2949  */
2950 static ApplyModifierResult
2951 ApplyModifier_Assign(const char **pp, ApplyModifiersState *st)
2952 {
2953     GNode *v_ctxt;
2954     char delim;
2955     char *val;
2956     VarParseResult res;
2957
2958     const char *mod = *pp;
2959     const char *op = mod + 1;
2960
2961     if (op[0] == '=')
2962         goto ok;
2963     if ((op[0] == '!' || op[0] == '+' || op[0] == '?') && op[1] == '=')
2964         goto ok;
2965     return AMR_UNKNOWN;         /* "::<unrecognised>" */
2966 ok:
2967
2968     if (st->v->name[0] == '\0') {
2969         *pp = mod + 1;
2970         return AMR_BAD;
2971     }
2972
2973     v_ctxt = st->ctxt;          /* context where v belongs */
2974     if (!(st->exprFlags & VEF_UNDEF) && st->ctxt != VAR_GLOBAL) {
2975         Var *gv = VarFind(st->v->name, st->ctxt, 0);
2976         if (gv == NULL)
2977             v_ctxt = VAR_GLOBAL;
2978         else
2979             VarFreeEnv(gv, TRUE);
2980     }
2981
2982     switch (op[0]) {
2983     case '+':
2984     case '?':
2985     case '!':
2986         *pp = mod + 3;
2987         break;
2988     default:
2989         *pp = mod + 2;
2990         break;
2991     }
2992
2993     delim = st->startc == '(' ? ')' : '}';
2994     res = ParseModifierPart(pp, delim, st->eflags, st, &val, NULL, NULL, NULL);
2995     if (res != VPR_OK)
2996         return AMR_CLEANUP;
2997
2998     (*pp)--;
2999
3000     if (st->eflags & VARE_WANTRES) {
3001         switch (op[0]) {
3002         case '+':
3003             Var_Append(st->v->name, val, v_ctxt);
3004             break;
3005         case '!': {
3006             const char *errfmt;
3007             char *cmd_output = Cmd_Exec(val, &errfmt);
3008             if (errfmt)
3009                 Error(errfmt, val);
3010             else
3011                 Var_Set(st->v->name, cmd_output, v_ctxt);
3012             free(cmd_output);
3013             break;
3014         }
3015         case '?':
3016             if (!(st->exprFlags & VEF_UNDEF))
3017                 break;
3018             /* FALLTHROUGH */
3019         default:
3020             Var_Set(st->v->name, val, v_ctxt);
3021             break;
3022         }
3023     }
3024     free(val);
3025     st->newVal = emptyString;
3026     return AMR_OK;
3027 }
3028
3029 /* :_=...
3030  * remember current value */
3031 static ApplyModifierResult
3032 ApplyModifier_Remember(const char **pp, ApplyModifiersState *st)
3033 {
3034     const char *mod = *pp;
3035     if (!ModMatchEq(mod, "_", st->endc))
3036         return AMR_UNKNOWN;
3037
3038     if (mod[1] == '=') {
3039         size_t n = strcspn(mod + 2, ":)}");
3040         char *name = bmake_strldup(mod + 2, n);
3041         Var_Set(name, st->val, st->ctxt);
3042         free(name);
3043         *pp = mod + 2 + n;
3044     } else {
3045         Var_Set("_", st->val, st->ctxt);
3046         *pp = mod + 1;
3047     }
3048     st->newVal = st->val;
3049     return AMR_OK;
3050 }
3051
3052 /* Apply the given function to each word of the variable value,
3053  * for a single-letter modifier such as :H, :T. */
3054 static ApplyModifierResult
3055 ApplyModifier_WordFunc(const char **pp, ApplyModifiersState *st,
3056                        ModifyWordsCallback modifyWord)
3057 {
3058     char delim = (*pp)[1];
3059     if (delim != st->endc && delim != ':')
3060         return AMR_UNKNOWN;
3061
3062     st->newVal = ModifyWords(st->val, modifyWord, NULL,
3063                              st->oneBigWord, st->sep);
3064     (*pp)++;
3065     return AMR_OK;
3066 }
3067
3068 static ApplyModifierResult
3069 ApplyModifier_Unique(const char **pp, ApplyModifiersState *st)
3070 {
3071     if ((*pp)[1] == st->endc || (*pp)[1] == ':') {
3072         st->newVal = VarUniq(st->val);
3073         (*pp)++;
3074         return AMR_OK;
3075     } else
3076         return AMR_UNKNOWN;
3077 }
3078
3079 #ifdef SYSVVARSUB
3080 /* :from=to */
3081 static ApplyModifierResult
3082 ApplyModifier_SysV(const char **pp, ApplyModifiersState *st)
3083 {
3084     char *lhs, *rhs;
3085     VarParseResult res;
3086
3087     const char *mod = *pp;
3088     Boolean eqFound = FALSE;
3089
3090     /*
3091      * First we make a pass through the string trying to verify it is a
3092      * SysV-make-style translation. It must be: <lhs>=<rhs>
3093      */
3094     int depth = 1;
3095     const char *p = mod;
3096     while (*p != '\0' && depth > 0) {
3097         if (*p == '=') {        /* XXX: should also test depth == 1 */
3098             eqFound = TRUE;
3099             /* continue looking for st->endc */
3100         } else if (*p == st->endc)
3101             depth--;
3102         else if (*p == st->startc)
3103             depth++;
3104         if (depth > 0)
3105             p++;
3106     }
3107     if (*p != st->endc || !eqFound)
3108         return AMR_UNKNOWN;
3109
3110     *pp = mod;
3111     res = ParseModifierPart(pp, '=', st->eflags, st,
3112                             &lhs, NULL, NULL, NULL);
3113     if (res != VPR_OK)
3114         return AMR_CLEANUP;
3115
3116     /* The SysV modifier lasts until the end of the variable expression. */
3117     res = ParseModifierPart(pp, st->endc, st->eflags, st,
3118                             &rhs, NULL, NULL, NULL);
3119     if (res != VPR_OK)
3120         return AMR_CLEANUP;
3121
3122     (*pp)--;
3123     if (lhs[0] == '\0' && st->val[0] == '\0') {
3124         st->newVal = st->val;   /* special case */
3125     } else {
3126         struct ModifyWord_SYSVSubstArgs args = {st->ctxt, lhs, rhs};
3127         st->newVal = ModifyWords(st->val, ModifyWord_SYSVSubst, &args,
3128                                  st->oneBigWord, st->sep);
3129     }
3130     free(lhs);
3131     free(rhs);
3132     return AMR_OK;
3133 }
3134 #endif
3135
3136 #ifdef SUNSHCMD
3137 /* :sh */
3138 static ApplyModifierResult
3139 ApplyModifier_SunShell(const char **pp, ApplyModifiersState *st)
3140 {
3141     const char *p = *pp;
3142     if (p[1] == 'h' && (p[2] == st->endc || p[2] == ':')) {
3143         if (st->eflags & VARE_WANTRES) {
3144             const char *errfmt;
3145             st->newVal = Cmd_Exec(st->val, &errfmt);
3146             if (errfmt)
3147                 Error(errfmt, st->val);
3148         } else
3149             st->newVal = emptyString;
3150         *pp = p + 2;
3151         return AMR_OK;
3152     } else
3153         return AMR_UNKNOWN;
3154 }
3155 #endif
3156
3157 static void
3158 LogBeforeApply(const ApplyModifiersState *st, const char *mod, const char endc)
3159 {
3160     char eflags_str[VarEvalFlags_ToStringSize];
3161     char vflags_str[VarFlags_ToStringSize];
3162     char exprflags_str[VarExprFlags_ToStringSize];
3163     Boolean is_single_char = mod[0] != '\0' &&
3164                              (mod[1] == endc || mod[1] == ':');
3165
3166     /* At this point, only the first character of the modifier can
3167      * be used since the end of the modifier is not yet known. */
3168     debug_printf("Applying ${%s:%c%s} to \"%s\" (%s, %s, %s)\n",
3169                  st->v->name, mod[0], is_single_char ? "" : "...", st->val,
3170                  Enum_FlagsToString(eflags_str, sizeof eflags_str,
3171                                     st->eflags, VarEvalFlags_ToStringSpecs),
3172                  Enum_FlagsToString(vflags_str, sizeof vflags_str,
3173                                     st->v->flags, VarFlags_ToStringSpecs),
3174                  Enum_FlagsToString(exprflags_str, sizeof exprflags_str,
3175                                     st->exprFlags,
3176                                     VarExprFlags_ToStringSpecs));
3177 }
3178
3179 static void
3180 LogAfterApply(ApplyModifiersState *st, const char *p, const char *mod)
3181 {
3182     char eflags_str[VarEvalFlags_ToStringSize];
3183     char vflags_str[VarFlags_ToStringSize];
3184     char exprflags_str[VarExprFlags_ToStringSize];
3185     const char *quot = st->newVal == var_Error ? "" : "\"";
3186     const char *newVal = st->newVal == var_Error ? "error" : st->newVal;
3187
3188     debug_printf("Result of ${%s:%.*s} is %s%s%s (%s, %s, %s)\n",
3189                  st->v->name, (int)(p - mod), mod, quot, newVal, quot,
3190                  Enum_FlagsToString(eflags_str, sizeof eflags_str,
3191                                     st->eflags, VarEvalFlags_ToStringSpecs),
3192                  Enum_FlagsToString(vflags_str, sizeof vflags_str,
3193                                     st->v->flags, VarFlags_ToStringSpecs),
3194                  Enum_FlagsToString(exprflags_str, sizeof exprflags_str,
3195                                     st->exprFlags,
3196                                     VarExprFlags_ToStringSpecs));
3197 }
3198
3199 static ApplyModifierResult
3200 ApplyModifier(const char **pp, ApplyModifiersState *st)
3201 {
3202     switch (**pp) {
3203     case ':':
3204         return ApplyModifier_Assign(pp, st);
3205     case '@':
3206         return ApplyModifier_Loop(pp, st);
3207     case '_':
3208         return ApplyModifier_Remember(pp, st);
3209     case 'D':
3210     case 'U':
3211         return ApplyModifier_Defined(pp, st);
3212     case 'L':
3213         return ApplyModifier_Literal(pp, st);
3214     case 'P':
3215         return ApplyModifier_Path(pp, st);
3216     case '!':
3217         return ApplyModifier_ShellCommand(pp, st);
3218     case '[':
3219         return ApplyModifier_Words(pp, st);
3220     case 'g':
3221         return ApplyModifier_Gmtime(pp, st);
3222     case 'h':
3223         return ApplyModifier_Hash(pp, st);
3224     case 'l':
3225         return ApplyModifier_Localtime(pp, st);
3226     case 't':
3227         return ApplyModifier_To(pp, st);
3228     case 'N':
3229     case 'M':
3230         return ApplyModifier_Match(pp, st);
3231     case 'S':
3232         return ApplyModifier_Subst(pp, st);
3233     case '?':
3234         return ApplyModifier_IfElse(pp, st);
3235 #ifndef NO_REGEX
3236     case 'C':
3237         return ApplyModifier_Regex(pp, st);
3238 #endif
3239     case 'q':
3240     case 'Q':
3241         return ApplyModifier_Quote(pp, st);
3242     case 'T':
3243         return ApplyModifier_WordFunc(pp, st, ModifyWord_Tail);
3244     case 'H':
3245         return ApplyModifier_WordFunc(pp, st, ModifyWord_Head);
3246     case 'E':
3247         return ApplyModifier_WordFunc(pp, st, ModifyWord_Suffix);
3248     case 'R':
3249         return ApplyModifier_WordFunc(pp, st, ModifyWord_Root);
3250     case 'r':
3251         return ApplyModifier_Range(pp, st);
3252     case 'O':
3253         return ApplyModifier_Order(pp, st);
3254     case 'u':
3255         return ApplyModifier_Unique(pp, st);
3256 #ifdef SUNSHCMD
3257     case 's':
3258         return ApplyModifier_SunShell(pp, st);
3259 #endif
3260     default:
3261         return AMR_UNKNOWN;
3262     }
3263 }
3264
3265 static char *ApplyModifiers(const char **, char *, char, char, Var *,
3266                             VarExprFlags *, GNode *, VarEvalFlags, void **);
3267
3268 typedef enum ApplyModifiersIndirectResult {
3269     AMIR_CONTINUE,
3270     AMIR_APPLY_MODS,
3271     AMIR_OUT
3272 } ApplyModifiersIndirectResult;
3273
3274 /* While expanding a variable expression, expand and apply indirect
3275  * modifiers. */
3276 static ApplyModifiersIndirectResult
3277 ApplyModifiersIndirect(
3278         ApplyModifiersState *const st,
3279         const char **inout_p,
3280         void **const out_freeIt
3281 ) {
3282     const char *p = *inout_p;
3283     const char *nested_p = p;
3284     void *freeIt;
3285     const char *rval;
3286     char c;
3287
3288     (void)Var_Parse(&nested_p, st->ctxt, st->eflags, &rval, &freeIt);
3289     /* TODO: handle errors */
3290
3291     /*
3292      * If we have not parsed up to st->endc or ':', we are not
3293      * interested.  This means the expression ${VAR:${M_1}${M_2}}
3294      * is not accepted, but ${VAR:${M_1}:${M_2}} is.
3295      */
3296     if (rval[0] != '\0' &&
3297         (c = *nested_p) != '\0' && c != ':' && c != st->endc) {
3298         if (DEBUG(LINT))
3299             Parse_Error(PARSE_FATAL,
3300                         "Missing delimiter ':' after indirect modifier \"%.*s\"",
3301                         (int)(nested_p - p), p);
3302
3303         free(freeIt);
3304         /* XXX: apply_mods doesn't sound like "not interested". */
3305         /* XXX: Why is the indirect modifier parsed again by
3306          * apply_mods?  If any, p should be advanced to nested_p. */
3307         return AMIR_APPLY_MODS;
3308     }
3309
3310     VAR_DEBUG3("Indirect modifier \"%s\" from \"%.*s\"\n",
3311                rval, (int)(size_t)(nested_p - p), p);
3312
3313     p = nested_p;
3314
3315     if (rval[0] != '\0') {
3316         const char *rval_pp = rval;
3317         st->val = ApplyModifiers(&rval_pp, st->val, '\0', '\0', st->v,
3318                                 &st->exprFlags, st->ctxt, st->eflags, out_freeIt);
3319         if (st->val == var_Error
3320             || (st->val == varUndefined && !(st->eflags & VARE_UNDEFERR))
3321             || *rval_pp != '\0') {
3322             free(freeIt);
3323             *inout_p = p;
3324             return AMIR_OUT;    /* error already reported */
3325         }
3326     }
3327     free(freeIt);
3328
3329     if (*p == ':')
3330         p++;
3331     else if (*p == '\0' && st->endc != '\0') {
3332         Error("Unclosed variable specification after complex "
3333               "modifier (expecting '%c') for %s", st->endc, st->v->name);
3334         *inout_p = p;
3335         return AMIR_OUT;
3336     }
3337
3338     *inout_p = p;
3339     return AMIR_CONTINUE;
3340 }
3341
3342 /* Apply any modifiers (such as :Mpattern or :@var@loop@ or :Q or ::=value). */
3343 static char *
3344 ApplyModifiers(
3345     const char **pp,            /* the parsing position, updated upon return */
3346     char *const val,            /* the current value of the expression */
3347     char const startc,          /* '(' or '{', or '\0' for indirect modifiers */
3348     char const endc,            /* ')' or '}', or '\0' for indirect modifiers */
3349     Var * const v,
3350     VarExprFlags *exprFlags,
3351     GNode * const ctxt,         /* for looking up and modifying variables */
3352     VarEvalFlags const eflags,
3353     void ** const out_freeIt    /* free this after using the return value */
3354 ) {
3355     ApplyModifiersState st = {
3356         startc, endc, v, ctxt, eflags,
3357         val,                    /* .val */
3358         var_Error,              /* .newVal */
3359         ' ',                    /* .sep */
3360         FALSE,                  /* .oneBigWord */
3361         *exprFlags              /* .exprFlags */
3362     };
3363     const char *p;
3364     const char *mod;
3365     ApplyModifierResult res;
3366
3367     assert(startc == '(' || startc == '{' || startc == '\0');
3368     assert(endc == ')' || endc == '}' || endc == '\0');
3369     assert(val != NULL);
3370
3371     p = *pp;
3372     while (*p != '\0' && *p != endc) {
3373
3374         if (*p == '$') {
3375             ApplyModifiersIndirectResult amir;
3376             amir = ApplyModifiersIndirect(&st, &p, out_freeIt);
3377             if (amir == AMIR_CONTINUE)
3378                 continue;
3379             if (amir == AMIR_OUT)
3380                 goto out;
3381         }
3382         st.newVal = var_Error;  /* default value, in case of errors */
3383         mod = p;
3384
3385         if (DEBUG(VAR))
3386             LogBeforeApply(&st, mod, endc);
3387
3388         res = ApplyModifier(&p, &st);
3389
3390 #ifdef SYSVVARSUB
3391         if (res == AMR_UNKNOWN) {
3392             assert(p == mod);
3393             res = ApplyModifier_SysV(&p, &st);
3394         }
3395 #endif
3396
3397         if (res == AMR_UNKNOWN) {
3398             Error("Unknown modifier '%c'", *mod);
3399             for (p++; *p != ':' && *p != st.endc && *p != '\0'; p++)
3400                 continue;
3401             st.newVal = var_Error;
3402         }
3403         if (res == AMR_CLEANUP)
3404             goto cleanup;
3405         if (res == AMR_BAD)
3406             goto bad_modifier;
3407
3408         if (DEBUG(VAR))
3409             LogAfterApply(&st, p, mod);
3410
3411         if (st.newVal != st.val) {
3412             if (*out_freeIt) {
3413                 free(st.val);
3414                 *out_freeIt = NULL;
3415             }
3416             st.val = st.newVal;
3417             if (st.val != var_Error && st.val != varUndefined &&
3418                 st.val != emptyString) {
3419                 *out_freeIt = st.val;
3420             }
3421         }
3422         if (*p == '\0' && st.endc != '\0') {
3423             Error("Unclosed variable specification (expecting '%c') "
3424                   "for \"%s\" (value \"%s\") modifier %c",
3425                   st.endc, st.v->name, st.val, *mod);
3426         } else if (*p == ':') {
3427             p++;
3428         } else if (DEBUG(LINT) && *p != '\0' && *p != endc) {
3429             Parse_Error(PARSE_FATAL,
3430                         "Missing delimiter ':' after modifier \"%.*s\"",
3431                         (int)(p - mod), mod);
3432         }
3433     }
3434 out:
3435     *pp = p;
3436     assert(st.val != NULL);     /* Use var_Error or varUndefined instead. */
3437     *exprFlags = st.exprFlags;
3438     return st.val;
3439
3440 bad_modifier:
3441     Error("Bad modifier `:%.*s' for %s",
3442           (int)strcspn(mod, ":)}"), mod, st.v->name);
3443
3444 cleanup:
3445     *pp = p;
3446     free(*out_freeIt);
3447     *out_freeIt = NULL;
3448     *exprFlags = st.exprFlags;
3449     return var_Error;
3450 }
3451
3452 /* Only four of the local variables are treated specially as they are the
3453  * only four that will be set when dynamic sources are expanded. */
3454 static Boolean
3455 VarnameIsDynamic(const char *name, size_t len)
3456 {
3457     if (len == 1 || (len == 2 && (name[1] == 'F' || name[1] == 'D'))) {
3458         switch (name[0]) {
3459         case '@':
3460         case '%':
3461         case '*':
3462         case '!':
3463             return TRUE;
3464         }
3465         return FALSE;
3466     }
3467
3468     if ((len == 7 || len == 8) && name[0] == '.' && ch_isupper(name[1])) {
3469         return strcmp(name, ".TARGET") == 0 ||
3470                strcmp(name, ".ARCHIVE") == 0 ||
3471                strcmp(name, ".PREFIX") == 0 ||
3472                strcmp(name, ".MEMBER") == 0;
3473     }
3474
3475     return FALSE;
3476 }
3477
3478 static const char *
3479 UndefinedShortVarValue(char varname, const GNode *ctxt, VarEvalFlags eflags)
3480 {
3481     if (ctxt == VAR_CMDLINE || ctxt == VAR_GLOBAL) {
3482         /*
3483          * If substituting a local variable in a non-local context,
3484          * assume it's for dynamic source stuff. We have to handle
3485          * this specially and return the longhand for the variable
3486          * with the dollar sign escaped so it makes it back to the
3487          * caller. Only four of the local variables are treated
3488          * specially as they are the only four that will be set
3489          * when dynamic sources are expanded.
3490          */
3491         switch (varname) {
3492         case '@':
3493             return "$(.TARGET)";
3494         case '%':
3495             return "$(.MEMBER)";
3496         case '*':
3497             return "$(.PREFIX)";
3498         case '!':
3499             return "$(.ARCHIVE)";
3500         }
3501     }
3502     return eflags & VARE_UNDEFERR ? var_Error : varUndefined;
3503 }
3504
3505 /* Parse a variable name, until the end character or a colon, whichever
3506  * comes first. */
3507 static char *
3508 ParseVarname(const char **pp, char startc, char endc,
3509              GNode *ctxt, VarEvalFlags eflags,
3510              size_t *out_varname_len)
3511 {
3512     Buffer buf;
3513     const char *p = *pp;
3514     int depth = 1;
3515
3516     Buf_Init(&buf, 0);
3517
3518     while (*p != '\0') {
3519         /* Track depth so we can spot parse errors. */
3520         if (*p == startc)
3521             depth++;
3522         if (*p == endc) {
3523             if (--depth == 0)
3524                 break;
3525         }
3526         if (*p == ':' && depth == 1)
3527             break;
3528
3529         /* A variable inside a variable, expand. */
3530         if (*p == '$') {
3531             void *freeIt;
3532             const char *rval;
3533             (void)Var_Parse(&p, ctxt, eflags, &rval, &freeIt);
3534             /* TODO: handle errors */
3535             Buf_AddStr(&buf, rval);
3536             free(freeIt);
3537         } else {
3538             Buf_AddByte(&buf, *p);
3539             p++;
3540         }
3541     }
3542     *pp = p;
3543     *out_varname_len = Buf_Len(&buf);
3544     return Buf_Destroy(&buf, FALSE);
3545 }
3546
3547 static Boolean
3548 ValidShortVarname(char varname, const char *start)
3549 {
3550     switch (varname) {
3551     case '\0':
3552     case ')':
3553     case '}':
3554     case ':':
3555     case '$':
3556         break;                  /* and continue below */
3557     default:
3558         return TRUE;
3559     }
3560
3561     if (!DEBUG(LINT))
3562         return FALSE;
3563
3564     if (varname == '$')
3565         Parse_Error(PARSE_FATAL,
3566                     "To escape a dollar, use \\$, not $$, at \"%s\"", start);
3567     else if (varname == '\0')
3568         Parse_Error(PARSE_FATAL, "Dollar followed by nothing");
3569     else
3570         Parse_Error(PARSE_FATAL,
3571                     "Invalid variable name '%c', at \"%s\"", varname, start);
3572
3573     return FALSE;
3574 }
3575
3576 /* Parse a single-character variable name such as $V or $@.
3577  * Return whether to continue parsing. */
3578 static Boolean
3579 ParseVarnameShort(
3580         char startc,
3581         const char **pp,
3582         GNode *ctxt,
3583         VarEvalFlags eflags,
3584         VarParseResult *out_FALSE_res,
3585         const char **out_FALSE_val,
3586         Var **out_TRUE_var
3587 ) {
3588     char name[2];
3589     Var *v;
3590
3591     /*
3592      * If it's not bounded by braces of some sort, life is much simpler.
3593      * We just need to check for the first character and return the
3594      * value if it exists.
3595      */
3596
3597     if (!ValidShortVarname(startc, *pp)) {
3598         (*pp)++;
3599         *out_FALSE_val = var_Error;
3600         *out_FALSE_res = VPR_PARSE_MSG;
3601         return FALSE;
3602     }
3603
3604     name[0] = startc;
3605     name[1] = '\0';
3606     v = VarFind(name, ctxt, TRUE);
3607     if (v == NULL) {
3608         *pp += 2;
3609
3610         *out_FALSE_val = UndefinedShortVarValue(startc, ctxt, eflags);
3611         if (DEBUG(LINT) && *out_FALSE_val == var_Error) {
3612             Parse_Error(PARSE_FATAL, "Variable \"%s\" is undefined", name);
3613             *out_FALSE_res = VPR_UNDEF_MSG;
3614             return FALSE;
3615         }
3616         *out_FALSE_res = eflags & VARE_UNDEFERR ? VPR_UNDEF_SILENT : VPR_OK;
3617         return FALSE;
3618     }
3619
3620     *out_TRUE_var = v;
3621     return TRUE;
3622 }
3623
3624 /* Parse a long variable name enclosed in braces or parentheses such as $(VAR)
3625  * or ${VAR}, up to the closing brace or parenthesis, or in the case of
3626  * ${VAR:Modifiers}, up to the ':' that starts the modifiers.
3627  * Return whether to continue parsing. */
3628 static Boolean
3629 ParseVarnameLong(
3630         const char **pp,
3631         char startc,
3632         GNode *ctxt,
3633         VarEvalFlags eflags,
3634
3635         VarParseResult *out_FALSE_res,
3636         const char **out_FALSE_val,
3637         void **out_FALSE_freePtr,
3638
3639         char *out_TRUE_endc,
3640         const char **out_TRUE_p,
3641         Var **out_TRUE_v,
3642         Boolean *out_TRUE_haveModifier,
3643         const char **out_TRUE_extraModifiers,
3644         Boolean *out_TRUE_dynamic,
3645         VarExprFlags *out_TRUE_exprFlags
3646 ) {
3647     size_t namelen;
3648     char *varname;
3649     Var *v;
3650     Boolean haveModifier;
3651     Boolean dynamic = FALSE;
3652
3653     const char *const start = *pp;
3654     char endc = startc == '(' ? ')' : '}';
3655
3656     const char *p = start + 2;
3657     varname = ParseVarname(&p, startc, endc, ctxt, eflags, &namelen);
3658
3659     if (*p == ':') {
3660         haveModifier = TRUE;
3661     } else if (*p == endc) {
3662         haveModifier = FALSE;
3663     } else {
3664         Parse_Error(PARSE_FATAL, "Unclosed variable \"%s\"", varname);
3665         *pp = p;
3666         free(varname);
3667         *out_FALSE_val = var_Error;
3668         *out_FALSE_res = VPR_PARSE_MSG;
3669         return FALSE;
3670     }
3671
3672     v = VarFind(varname, ctxt, TRUE);
3673
3674     /* At this point, p points just after the variable name,
3675      * either at ':' or at endc. */
3676
3677     /*
3678      * Check also for bogus D and F forms of local variables since we're
3679      * in a local context and the name is the right length.
3680      */
3681     if (v == NULL && ctxt != VAR_CMDLINE && ctxt != VAR_GLOBAL &&
3682         namelen == 2 && (varname[1] == 'F' || varname[1] == 'D') &&
3683         strchr("@%?*!<>", varname[0]) != NULL)
3684     {
3685         /*
3686          * Well, it's local -- go look for it.
3687          */
3688         char name[] = { varname[0], '\0' };
3689         v = VarFind(name, ctxt, 0);
3690
3691         if (v != NULL) {
3692             if (varname[1] == 'D') {
3693                 *out_TRUE_extraModifiers = "H:";
3694             } else { /* F */
3695                 *out_TRUE_extraModifiers = "T:";
3696             }
3697         }
3698     }
3699
3700     if (v == NULL) {
3701         /* Defer expansion of dynamic variables if they appear in non-local
3702          * context since they are not defined there. */
3703         dynamic = VarnameIsDynamic(varname, namelen) &&
3704                   (ctxt == VAR_CMDLINE || ctxt == VAR_GLOBAL);
3705
3706         if (!haveModifier) {
3707             p++;                /* skip endc */
3708             *pp = p;
3709             if (dynamic) {
3710                 char *pstr = bmake_strsedup(start, p);
3711                 free(varname);
3712                 *out_FALSE_res = VPR_OK;
3713                 *out_FALSE_freePtr = pstr;
3714                 *out_FALSE_val = pstr;
3715                 return FALSE;
3716             }
3717
3718             if ((eflags & VARE_UNDEFERR) && (eflags & VARE_WANTRES) &&
3719                 DEBUG(LINT))
3720             {
3721                 Parse_Error(PARSE_FATAL, "Variable \"%s\" is undefined",
3722                             varname);
3723                 free(varname);
3724                 *out_FALSE_res = VPR_UNDEF_MSG;
3725                 *out_FALSE_val = var_Error;
3726                 return FALSE;
3727             }
3728
3729             if (eflags & VARE_UNDEFERR) {
3730                 free(varname);
3731                 *out_FALSE_res = VPR_UNDEF_SILENT;
3732                 *out_FALSE_val = var_Error;
3733                 return FALSE;
3734             }
3735
3736             free(varname);
3737             *out_FALSE_res = VPR_OK;
3738             *out_FALSE_val = varUndefined;
3739             return FALSE;
3740         }
3741
3742         /* The variable expression is based on an undefined variable.
3743          * Nevertheless it needs a Var, for modifiers that access the
3744          * variable name, such as :L or :?.
3745          *
3746          * Most modifiers leave this expression in the "undefined" state
3747          * (VEF_UNDEF), only a few modifiers like :D, :U, :L, :P turn this
3748          * undefined expression into a defined expression (VEF_DEF).
3749          *
3750          * At the end, after applying all modifiers, if the expression
3751          * is still undefined, Var_Parse will return an empty string
3752          * instead of the actually computed value. */
3753         v = VarNew(varname, varname, "", 0);
3754         *out_TRUE_exprFlags = VEF_UNDEF;
3755     } else
3756         free(varname);
3757
3758     *out_TRUE_endc = endc;
3759     *out_TRUE_p = p;
3760     *out_TRUE_v = v;
3761     *out_TRUE_haveModifier = haveModifier;
3762     *out_TRUE_dynamic = dynamic;
3763     return TRUE;
3764 }
3765
3766 /*-
3767  *-----------------------------------------------------------------------
3768  * Var_Parse --
3769  *      Given the start of a variable expression (such as $v, $(VAR),
3770  *      ${VAR:Mpattern}), extract the variable name, possibly some
3771  *      modifiers and find its value by applying the modifiers to the
3772  *      original value.
3773  *
3774  *      When parsing a condition in ParseEmptyArg, pp may also point to
3775  *      the "y" of "empty(VARNAME:Modifiers)", which is syntactically
3776  *      identical.
3777  *
3778  * Input:
3779  *      str             The string to parse
3780  *      ctxt            The context for the variable
3781  *      flags           Select the exact details of parsing
3782  *      out_val_freeIt  Must be freed by the caller after using out_val
3783  *
3784  * Results:
3785  *      Returns the value of the variable expression, never NULL.
3786  *      Returns var_Error if there was a parse error and VARE_UNDEFERR was
3787  *      set.
3788  *      Returns varUndefined if there was an undefined variable and
3789  *      VARE_UNDEFERR was not set.
3790  *
3791  *      Parsing should continue at *pp.
3792  *      TODO: Document the value of *pp on parse errors.  It might be advanced
3793  *      by 0, or +1, or the index of the parse error, or the guessed end of the
3794  *      variable expression.
3795  *
3796  *      If var_Error is returned, a diagnostic may or may not have been
3797  *      printed. XXX: This is inconsistent.
3798  *
3799  *      If varUndefined is returned, a diagnostic may or may not have been
3800  *      printed. XXX: This is inconsistent.
3801  *
3802  *      After using the returned value, *out_val_freeIt must be freed,
3803  *      preferably using bmake_free since it is NULL in most cases.
3804  *
3805  * Side Effects:
3806  *      Any effects from the modifiers, such as :!cmd! or ::=value.
3807  *-----------------------------------------------------------------------
3808  */
3809 /* coverity[+alloc : arg-*4] */
3810 VarParseResult
3811 Var_Parse(const char **pp, GNode *ctxt, VarEvalFlags eflags,
3812           const char **out_val, void **out_val_freeIt)
3813 {
3814     const char *const start = *pp;
3815     const char *p;
3816     Boolean haveModifier;       /* TRUE if have modifiers for the variable */
3817     char startc;                /* Starting character if variable in parens
3818                                  * or braces */
3819     char endc;                  /* Ending character if variable in parens
3820                                  * or braces */
3821     Boolean dynamic;            /* TRUE if the variable is local and we're
3822                                  * expanding it in a non-local context. This
3823                                  * is done to support dynamic sources. The
3824                                  * result is just the expression, unaltered */
3825     const char *extramodifiers;
3826     Var *v;
3827     char *nstr;
3828     char eflags_str[VarEvalFlags_ToStringSize];
3829     VarExprFlags exprFlags = 0;
3830
3831     VAR_DEBUG2("Var_Parse: %s with %s\n", start,
3832                Enum_FlagsToString(eflags_str, sizeof eflags_str, eflags,
3833                                   VarEvalFlags_ToStringSpecs));
3834
3835     *out_val_freeIt = NULL;
3836     extramodifiers = NULL;      /* extra modifiers to apply first */
3837     dynamic = FALSE;
3838
3839     /* Appease GCC, which thinks that the variable might not be
3840      * initialized. */
3841     endc = '\0';
3842
3843     startc = start[1];
3844     if (startc != '(' && startc != '{') {
3845         VarParseResult res;
3846         if (!ParseVarnameShort(startc, pp, ctxt, eflags, &res, out_val, &v))
3847             return res;
3848         haveModifier = FALSE;
3849         p = start + 1;
3850     } else {
3851         VarParseResult res;
3852         if (!ParseVarnameLong(pp, startc, ctxt, eflags,
3853                               &res, out_val, out_val_freeIt,
3854                               &endc, &p, &v, &haveModifier, &extramodifiers,
3855                               &dynamic, &exprFlags))
3856             return res;
3857     }
3858
3859     if (v->flags & VAR_IN_USE)
3860         Fatal("Variable %s is recursive.", v->name);
3861
3862     /*
3863      * Before doing any modification, we have to make sure the value
3864      * has been fully expanded. If it looks like recursion might be
3865      * necessary (there's a dollar sign somewhere in the variable's value)
3866      * we just call Var_Subst to do any other substitutions that are
3867      * necessary. Note that the value returned by Var_Subst will have
3868      * been dynamically-allocated, so it will need freeing when we
3869      * return.
3870      */
3871     nstr = Buf_GetAll(&v->val, NULL);
3872     if (strchr(nstr, '$') != NULL && (eflags & VARE_WANTRES)) {
3873         VarEvalFlags nested_eflags = eflags;
3874         if (DEBUG(LINT))
3875             nested_eflags &= ~(unsigned)VARE_UNDEFERR;
3876         v->flags |= VAR_IN_USE;
3877         (void)Var_Subst(nstr, ctxt, nested_eflags, &nstr);
3878         v->flags &= ~(unsigned)VAR_IN_USE;
3879         /* TODO: handle errors */
3880         *out_val_freeIt = nstr;
3881     }
3882
3883     if (haveModifier || extramodifiers != NULL) {
3884         void *extraFree;
3885
3886         extraFree = NULL;
3887         if (extramodifiers != NULL) {
3888             const char *em = extramodifiers;
3889             nstr = ApplyModifiers(&em, nstr, '(', ')',
3890                                   v, &exprFlags, ctxt, eflags, &extraFree);
3891         }
3892
3893         if (haveModifier) {
3894             /* Skip initial colon. */
3895             p++;
3896
3897             nstr = ApplyModifiers(&p, nstr, startc, endc,
3898                                   v, &exprFlags, ctxt, eflags, out_val_freeIt);
3899             free(extraFree);
3900         } else {
3901             *out_val_freeIt = extraFree;
3902         }
3903     }
3904
3905     if (*p != '\0')             /* Skip past endc if possible. */
3906         p++;
3907
3908     *pp = p;
3909
3910     if (v->flags & VAR_FROM_ENV) {
3911         /* Free the environment variable now since we own it,
3912          * but don't free the variable value if it will be returned. */
3913         Boolean keepValue = nstr == Buf_GetAll(&v->val, NULL);
3914         if (keepValue)
3915             *out_val_freeIt = nstr;
3916         (void)VarFreeEnv(v, !keepValue);
3917
3918     } else if (exprFlags & VEF_UNDEF) {
3919         if (!(exprFlags & VEF_DEF)) {
3920             if (*out_val_freeIt != NULL) {
3921                 free(*out_val_freeIt);
3922                 *out_val_freeIt = NULL;
3923             }
3924             if (dynamic) {
3925                 nstr = bmake_strsedup(start, p);
3926                 *out_val_freeIt = nstr;
3927             } else {
3928                 /* The expression is still undefined, therefore discard the
3929                  * actual value and return an error marker instead. */
3930                 nstr = (eflags & VARE_UNDEFERR) ? var_Error : varUndefined;
3931             }
3932         }
3933         if (nstr != Buf_GetAll(&v->val, NULL))
3934             Buf_Destroy(&v->val, TRUE);
3935         free(v->name_freeIt);
3936         free(v);
3937     }
3938     *out_val = nstr;
3939     return VPR_UNKNOWN;
3940 }
3941
3942 /* Substitute for all variables in the given string in the given context.
3943  *
3944  * If eflags & VARE_UNDEFERR, Parse_Error will be called when an undefined
3945  * variable is encountered.
3946  *
3947  * If eflags & VARE_WANTRES, any effects from the modifiers, such as ::=,
3948  * :sh or !cmd! take place.
3949  *
3950  * Input:
3951  *      str             the string which to substitute
3952  *      ctxt            the context wherein to find variables
3953  *      eflags          VARE_UNDEFERR   if undefineds are an error
3954  *                      VARE_WANTRES    if we actually want the result
3955  *                      VARE_ASSIGN     if we are in a := assignment
3956  *
3957  * Results:
3958  *      The resulting string.
3959  */
3960 VarParseResult
3961 Var_Subst(const char *str, GNode *ctxt, VarEvalFlags eflags, char **out_res)
3962 {
3963     const char *p = str;
3964     Buffer buf;                 /* Buffer for forming things */
3965
3966     /* Set true if an error has already been reported,
3967      * to prevent a plethora of messages when recursing */
3968     static Boolean errorReported;
3969
3970     Buf_Init(&buf, 0);
3971     errorReported = FALSE;
3972
3973     while (*p != '\0') {
3974         if (p[0] == '$' && p[1] == '$') {
3975             /* A dollar sign may be escaped with another dollar sign. */
3976             if (save_dollars && (eflags & VARE_ASSIGN))
3977                 Buf_AddByte(&buf, '$');
3978             Buf_AddByte(&buf, '$');
3979             p += 2;
3980         } else if (*p != '$') {
3981             /*
3982              * Skip as many characters as possible -- either to the end of
3983              * the string or to the next dollar sign (variable expression).
3984              */
3985             const char *plainStart = p;
3986
3987             for (p++; *p != '$' && *p != '\0'; p++)
3988                 continue;
3989             Buf_AddBytesBetween(&buf, plainStart, p);
3990         } else {
3991             const char *nested_p = p;
3992             void *freeIt;
3993             const char *val;
3994             (void)Var_Parse(&nested_p, ctxt, eflags, &val, &freeIt);
3995             /* TODO: handle errors */
3996
3997             if (val == var_Error || val == varUndefined) {
3998                 /*
3999                  * If performing old-time variable substitution, skip over
4000                  * the variable and continue with the substitution. Otherwise,
4001                  * store the dollar sign and advance str so we continue with
4002                  * the string...
4003                  */
4004                 if (oldVars) {
4005                     p = nested_p;
4006                 } else if ((eflags & VARE_UNDEFERR) || val == var_Error) {
4007                     /*
4008                      * If variable is undefined, complain and skip the
4009                      * variable. The complaint will stop us from doing anything
4010                      * when the file is parsed.
4011                      */
4012                     if (!errorReported) {
4013                         Parse_Error(PARSE_FATAL, "Undefined variable \"%.*s\"",
4014                                     (int)(size_t)(nested_p - p), p);
4015                     }
4016                     p = nested_p;
4017                     errorReported = TRUE;
4018                 } else {
4019                     /* Copy the initial '$' of the undefined expression,
4020                      * thereby deferring expansion of the expression, but
4021                      * expand nested expressions if already possible.
4022                      * See unit-tests/varparse-undef-partial.mk. */
4023                     Buf_AddByte(&buf, *p);
4024                     p++;
4025                 }
4026             } else {
4027                 p = nested_p;
4028                 Buf_AddStr(&buf, val);
4029             }
4030             free(freeIt);
4031             freeIt = NULL;
4032         }
4033     }
4034
4035     *out_res = Buf_DestroyCompact(&buf);
4036     return VPR_OK;
4037 }
4038
4039 /* Initialize the variables module. */
4040 void
4041 Var_Init(void)
4042 {
4043     VAR_INTERNAL = Targ_NewGN("Internal");
4044     VAR_GLOBAL = Targ_NewGN("Global");
4045     VAR_CMDLINE = Targ_NewGN("Command");
4046 }
4047
4048 /* Clean up the variables module. */
4049 void
4050 Var_End(void)
4051 {
4052     Var_Stats();
4053 }
4054
4055 void
4056 Var_Stats(void)
4057 {
4058     HashTable_DebugStats(&VAR_GLOBAL->context, "VAR_GLOBAL");
4059 }
4060
4061 /* Print all variables in a context, sorted by name. */
4062 void
4063 Var_Dump(GNode *ctxt)
4064 {
4065     Vector /* of const char * */ vec;
4066     HashIter hi;
4067     size_t i;
4068     const char **varnames;
4069
4070     Vector_Init(&vec, sizeof(const char *));
4071
4072     HashIter_Init(&hi, &ctxt->context);
4073     while (HashIter_Next(&hi) != NULL)
4074         *(const char **)Vector_Push(&vec) = hi.entry->key;
4075     varnames = vec.items;
4076
4077     qsort(varnames, vec.len, sizeof varnames[0], str_cmp_asc);
4078
4079     for (i = 0; i < vec.len; i++) {
4080         const char *varname = varnames[i];
4081         Var *var = HashTable_FindValue(&ctxt->context, varname);
4082         debug_printf("%-16s = %s\n", varname, Buf_GetAll(&var->val, NULL));
4083     }
4084
4085     Vector_Done(&vec);
4086 }