contrib/bmake/var.c

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