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