1 /* $NetBSD: parse.c,v 1.550 2021/02/22 23:21:33 rillig Exp $ */ 2 3 /* 4 * Copyright (c) 1988, 1989, 1990, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * This code is derived from software contributed to Berkeley by 8 * Adam de Boor. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 35 /* 36 * Copyright (c) 1989 by Berkeley Softworks 37 * All rights reserved. 38 * 39 * This code is derived from software contributed to Berkeley by 40 * Adam de Boor. 41 * 42 * Redistribution and use in source and binary forms, with or without 43 * modification, are permitted provided that the following conditions 44 * are met: 45 * 1. Redistributions of source code must retain the above copyright 46 * notice, this list of conditions and the following disclaimer. 47 * 2. Redistributions in binary form must reproduce the above copyright 48 * notice, this list of conditions and the following disclaimer in the 49 * documentation and/or other materials provided with the distribution. 50 * 3. All advertising materials mentioning features or use of this software 51 * must display the following acknowledgement: 52 * This product includes software developed by the University of 53 * California, Berkeley and its contributors. 54 * 4. Neither the name of the University nor the names of its contributors 55 * may be used to endorse or promote products derived from this software 56 * without specific prior written permission. 57 * 58 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 59 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 60 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 61 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 62 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 63 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 64 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 65 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 66 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 67 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 68 * SUCH DAMAGE. 69 */ 70 71 /* 72 * Parsing of makefiles. 73 * 74 * Parse_File is the main entry point and controls most of the other 75 * functions in this module. 76 * 77 * The directories for the .include "..." directive are kept in 78 * 'parseIncPath', while those for .include <...> are kept in 'sysIncPath'. 79 * The targets currently being defined are kept in 'targets'. 80 * 81 * Interface: 82 * Parse_Init Initialize the module 83 * 84 * Parse_End Clean up the module 85 * 86 * Parse_File Parse a top-level makefile. Included files are 87 * handled by IncludeFile instead. 88 * 89 * Parse_IsVar Return TRUE if the given line is a variable 90 * assignment. Used by MainParseArgs to determine if 91 * an argument is a target or a variable assignment. 92 * Used internally for pretty much the same thing. 93 * 94 * Parse_Error Report a parse error, a warning or an informational 95 * message. 96 * 97 * Parse_MainName Returns a list of the main target to create. 98 */ 99 100 #include <sys/types.h> 101 #include <sys/stat.h> 102 #include <errno.h> 103 #include <stdarg.h> 104 105 #include "make.h" 106 107 #ifdef HAVE_STDINT_H 108 #include <stdint.h> 109 #endif 110 111 #ifdef HAVE_MMAP 112 #include <sys/mman.h> 113 114 #ifndef MAP_COPY 115 #define MAP_COPY MAP_PRIVATE 116 #endif 117 #ifndef MAP_FILE 118 #define MAP_FILE 0 119 #endif 120 #endif 121 122 #include "dir.h" 123 #include "job.h" 124 #include "pathnames.h" 125 126 /* "@(#)parse.c 8.3 (Berkeley) 3/19/94" */ 127 MAKE_RCSID("$NetBSD: parse.c,v 1.550 2021/02/22 23:21:33 rillig Exp $"); 128 129 /* types and constants */ 130 131 /* 132 * Structure for a file being read ("included file") 133 */ 134 typedef struct IFile { 135 char *fname; /* name of file (relative? absolute?) */ 136 Boolean fromForLoop; /* simulated .include by the .for loop */ 137 int lineno; /* current line number in file */ 138 int first_lineno; /* line number of start of text */ 139 unsigned int cond_depth; /* 'if' nesting when file opened */ 140 Boolean depending; /* state of doing_depend on EOF */ 141 142 /* The buffer from which the file's content is read. */ 143 char *buf_freeIt; 144 char *buf_ptr; /* next char to be read */ 145 char *buf_end; 146 147 /* Function to read more data, with a single opaque argument. */ 148 ReadMoreProc readMore; 149 void *readMoreArg; 150 151 struct loadedfile *lf; /* loadedfile object, if any */ 152 } IFile; 153 154 /* 155 * Tokens for target attributes 156 */ 157 typedef enum ParseSpecial { 158 SP_ATTRIBUTE, /* Generic attribute */ 159 SP_BEGIN, /* .BEGIN */ 160 SP_DEFAULT, /* .DEFAULT */ 161 SP_DELETE_ON_ERROR, /* .DELETE_ON_ERROR */ 162 SP_END, /* .END */ 163 SP_ERROR, /* .ERROR */ 164 SP_IGNORE, /* .IGNORE */ 165 SP_INCLUDES, /* .INCLUDES; not mentioned in the manual page */ 166 SP_INTERRUPT, /* .INTERRUPT */ 167 SP_LIBS, /* .LIBS; not mentioned in the manual page */ 168 /* .MAIN and we don't have anything user-specified to make */ 169 SP_MAIN, 170 SP_META, /* .META */ 171 SP_MFLAGS, /* .MFLAGS or .MAKEFLAGS */ 172 SP_NOMETA, /* .NOMETA */ 173 SP_NOMETA_CMP, /* .NOMETA_CMP */ 174 SP_NOPATH, /* .NOPATH */ 175 SP_NOT, /* Not special */ 176 SP_NOTPARALLEL, /* .NOTPARALLEL or .NO_PARALLEL */ 177 SP_NULL, /* .NULL; not mentioned in the manual page */ 178 SP_OBJDIR, /* .OBJDIR */ 179 SP_ORDER, /* .ORDER */ 180 SP_PARALLEL, /* .PARALLEL; not mentioned in the manual page */ 181 SP_PATH, /* .PATH or .PATH.suffix */ 182 SP_PHONY, /* .PHONY */ 183 #ifdef POSIX 184 SP_POSIX, /* .POSIX; not mentioned in the manual page */ 185 #endif 186 SP_PRECIOUS, /* .PRECIOUS */ 187 SP_SHELL, /* .SHELL */ 188 SP_SILENT, /* .SILENT */ 189 SP_SINGLESHELL, /* .SINGLESHELL; not mentioned in the manual page */ 190 SP_STALE, /* .STALE */ 191 SP_SUFFIXES, /* .SUFFIXES */ 192 SP_WAIT /* .WAIT */ 193 } ParseSpecial; 194 195 typedef List SearchPathList; 196 typedef ListNode SearchPathListNode; 197 198 /* result data */ 199 200 /* 201 * The main target to create. This is the first target on the first 202 * dependency line in the first makefile. 203 */ 204 static GNode *mainNode; 205 206 /* eval state */ 207 208 /* 209 * During parsing, the targets from the left-hand side of the currently 210 * active dependency line, or NULL if the current line does not belong to a 211 * dependency line, for example because it is a variable assignment. 212 * 213 * See unit-tests/deptgt.mk, keyword "parse.c:targets". 214 */ 215 static GNodeList *targets; 216 217 #ifdef CLEANUP 218 /* 219 * All shell commands for all targets, in no particular order and possibly 220 * with duplicates. Kept in a separate list since the commands from .USE or 221 * .USEBEFORE nodes are shared with other GNodes, thereby giving up the 222 * easily understandable ownership over the allocated strings. 223 */ 224 static StringList targCmds = LST_INIT; 225 #endif 226 227 /* 228 * Predecessor node for handling .ORDER. Initialized to NULL when .ORDER 229 * seen, then set to each successive source on the line. 230 */ 231 static GNode *order_pred; 232 233 /* parser state */ 234 235 /* number of fatal errors */ 236 static int fatals = 0; 237 238 /* 239 * Variables for doing includes 240 */ 241 242 /* 243 * The include chain of makefiles. At index 0 is the top-level makefile from 244 * the command line, followed by the included files or .for loops, up to and 245 * including the current file. 246 * 247 * See PrintStackTrace for how to interpret the data. 248 */ 249 static Vector /* of IFile */ includes; 250 251 static IFile * 252 GetInclude(size_t i) 253 { 254 return Vector_Get(&includes, i); 255 } 256 257 /* The file that is currently being read. */ 258 static IFile * 259 CurFile(void) 260 { 261 return GetInclude(includes.len - 1); 262 } 263 264 /* include paths */ 265 SearchPath *parseIncPath; /* directories for "..." includes */ 266 SearchPath *sysIncPath; /* directories for <...> includes */ 267 SearchPath *defSysIncPath; /* default for sysIncPath */ 268 269 /* parser tables */ 270 271 /* 272 * The parseKeywords table is searched using binary search when deciding 273 * if a target or source is special. The 'spec' field is the ParseSpecial 274 * type of the keyword (SP_NOT if the keyword isn't special as a target) while 275 * the 'op' field is the operator to apply to the list of targets if the 276 * keyword is used as a source ("0" if the keyword isn't special as a source) 277 */ 278 static const struct { 279 const char *name; /* Name of keyword */ 280 ParseSpecial spec; /* Type when used as a target */ 281 GNodeType op; /* Operator when used as a source */ 282 } parseKeywords[] = { 283 { ".BEGIN", SP_BEGIN, OP_NONE }, 284 { ".DEFAULT", SP_DEFAULT, OP_NONE }, 285 { ".DELETE_ON_ERROR", SP_DELETE_ON_ERROR, OP_NONE }, 286 { ".END", SP_END, OP_NONE }, 287 { ".ERROR", SP_ERROR, OP_NONE }, 288 { ".EXEC", SP_ATTRIBUTE, OP_EXEC }, 289 { ".IGNORE", SP_IGNORE, OP_IGNORE }, 290 { ".INCLUDES", SP_INCLUDES, OP_NONE }, 291 { ".INTERRUPT", SP_INTERRUPT, OP_NONE }, 292 { ".INVISIBLE", SP_ATTRIBUTE, OP_INVISIBLE }, 293 { ".JOIN", SP_ATTRIBUTE, OP_JOIN }, 294 { ".LIBS", SP_LIBS, OP_NONE }, 295 { ".MADE", SP_ATTRIBUTE, OP_MADE }, 296 { ".MAIN", SP_MAIN, OP_NONE }, 297 { ".MAKE", SP_ATTRIBUTE, OP_MAKE }, 298 { ".MAKEFLAGS", SP_MFLAGS, OP_NONE }, 299 { ".META", SP_META, OP_META }, 300 { ".MFLAGS", SP_MFLAGS, OP_NONE }, 301 { ".NOMETA", SP_NOMETA, OP_NOMETA }, 302 { ".NOMETA_CMP", SP_NOMETA_CMP, OP_NOMETA_CMP }, 303 { ".NOPATH", SP_NOPATH, OP_NOPATH }, 304 { ".NOTMAIN", SP_ATTRIBUTE, OP_NOTMAIN }, 305 { ".NOTPARALLEL", SP_NOTPARALLEL, OP_NONE }, 306 { ".NO_PARALLEL", SP_NOTPARALLEL, OP_NONE }, 307 { ".NULL", SP_NULL, OP_NONE }, 308 { ".OBJDIR", SP_OBJDIR, OP_NONE }, 309 { ".OPTIONAL", SP_ATTRIBUTE, OP_OPTIONAL }, 310 { ".ORDER", SP_ORDER, OP_NONE }, 311 { ".PARALLEL", SP_PARALLEL, OP_NONE }, 312 { ".PATH", SP_PATH, OP_NONE }, 313 { ".PHONY", SP_PHONY, OP_PHONY }, 314 #ifdef POSIX 315 { ".POSIX", SP_POSIX, OP_NONE }, 316 #endif 317 { ".PRECIOUS", SP_PRECIOUS, OP_PRECIOUS }, 318 { ".RECURSIVE", SP_ATTRIBUTE, OP_MAKE }, 319 { ".SHELL", SP_SHELL, OP_NONE }, 320 { ".SILENT", SP_SILENT, OP_SILENT }, 321 { ".SINGLESHELL", SP_SINGLESHELL, OP_NONE }, 322 { ".STALE", SP_STALE, OP_NONE }, 323 { ".SUFFIXES", SP_SUFFIXES, OP_NONE }, 324 { ".USE", SP_ATTRIBUTE, OP_USE }, 325 { ".USEBEFORE", SP_ATTRIBUTE, OP_USEBEFORE }, 326 { ".WAIT", SP_WAIT, OP_NONE }, 327 }; 328 329 /* file loader */ 330 331 struct loadedfile { 332 /* XXX: What is the lifetime of this path? Who manages the memory? */ 333 const char *path; /* name, for error reports */ 334 char *buf; /* contents buffer */ 335 size_t len; /* length of contents */ 336 Boolean used; /* XXX: have we used the data yet */ 337 }; 338 339 /* XXX: What is the lifetime of the path? Who manages the memory? */ 340 static struct loadedfile * 341 loadedfile_create(const char *path, char *buf, size_t buflen) 342 { 343 struct loadedfile *lf; 344 345 lf = bmake_malloc(sizeof *lf); 346 lf->path = path == NULL ? "(stdin)" : path; 347 lf->buf = buf; 348 lf->len = buflen; 349 lf->used = FALSE; 350 return lf; 351 } 352 353 static void 354 loadedfile_destroy(struct loadedfile *lf) 355 { 356 free(lf->buf); 357 free(lf); 358 } 359 360 /* 361 * readMore() operation for loadedfile, as needed by the weird and twisted 362 * logic below. Once that's cleaned up, we can get rid of lf->used. 363 */ 364 static char * 365 loadedfile_readMore(void *x, size_t *len) 366 { 367 struct loadedfile *lf = x; 368 369 if (lf->used) 370 return NULL; 371 372 lf->used = TRUE; 373 *len = lf->len; 374 return lf->buf; 375 } 376 377 /* 378 * Try to get the size of a file. 379 */ 380 static Boolean 381 load_getsize(int fd, size_t *ret) 382 { 383 struct stat st; 384 385 if (fstat(fd, &st) < 0) 386 return FALSE; 387 388 if (!S_ISREG(st.st_mode)) 389 return FALSE; 390 391 /* 392 * st_size is an off_t, which is 64 bits signed; *ret is 393 * size_t, which might be 32 bits unsigned or 64 bits 394 * unsigned. Rather than being elaborate, just punt on 395 * files that are more than 1 GiB. We should never 396 * see a makefile that size in practice. 397 * 398 * While we're at it reject negative sizes too, just in case. 399 */ 400 if (st.st_size < 0 || st.st_size > 0x3fffffff) 401 return FALSE; 402 403 *ret = (size_t)st.st_size; 404 return TRUE; 405 } 406 407 /* 408 * Read in a file. 409 * 410 * Until the path search logic can be moved under here instead of 411 * being in the caller in another source file, we need to have the fd 412 * passed in already open. Bleh. 413 * 414 * If the path is NULL, use stdin. 415 */ 416 static struct loadedfile * 417 loadfile(const char *path, int fd) 418 { 419 ssize_t n; 420 Buffer buf; 421 size_t filesize; 422 423 424 if (path == NULL) { 425 assert(fd == -1); 426 fd = STDIN_FILENO; 427 } 428 429 if (load_getsize(fd, &filesize)) { 430 /* 431 * Avoid resizing the buffer later for no reason. 432 * 433 * At the same time leave space for adding a final '\n', 434 * just in case it is missing in the file. 435 */ 436 filesize++; 437 } else 438 filesize = 1024; 439 Buf_InitSize(&buf, filesize); 440 441 for (;;) { 442 assert(buf.len <= buf.cap); 443 if (buf.len == buf.cap) { 444 if (buf.cap > 0x1fffffff) { 445 errno = EFBIG; 446 Error("%s: file too large", path); 447 exit(2); /* Not 1 so -q can distinguish error */ 448 } 449 Buf_Expand(&buf); 450 } 451 assert(buf.len < buf.cap); 452 n = read(fd, buf.data + buf.len, buf.cap - buf.len); 453 if (n < 0) { 454 Error("%s: read error: %s", path, strerror(errno)); 455 exit(2); /* Not 1 so -q can distinguish error */ 456 } 457 if (n == 0) 458 break; 459 460 buf.len += (size_t)n; 461 } 462 assert(buf.len <= buf.cap); 463 464 if (!Buf_EndsWith(&buf, '\n')) 465 Buf_AddByte(&buf, '\n'); 466 467 if (path != NULL) 468 close(fd); 469 470 { 471 struct loadedfile *lf = loadedfile_create(path, 472 buf.data, buf.len); 473 Buf_DoneData(&buf); 474 return lf; 475 } 476 } 477 478 static void 479 PrintStackTrace(void) 480 { 481 const IFile *entries; 482 size_t i, n; 483 484 if (!(DEBUG(PARSE))) 485 return; 486 487 entries = GetInclude(0); 488 n = includes.len; 489 if (n == 0) 490 return; 491 n--; /* This entry is already in the diagnostic. */ 492 493 /* 494 * For the IFiles with fromForLoop, lineno seems to be sorted 495 * backwards. This is because lineno is the number of completely 496 * parsed lines, which for a .for loop is right after the 497 * corresponding .endfor. The intuitive line number comes from 498 * first_lineno instead, which points at the start of the .for loop. 499 * 500 * To make the stack trace intuitive, the entry below each chain of 501 * .for loop entries must be ignored completely since neither its 502 * lineno nor its first_lineno is useful. Instead, the topmost of 503 * each chain of .for loop entries needs to be printed twice, once 504 * with its first_lineno and once with its lineno. 505 */ 506 507 for (i = n; i-- > 0;) { 508 const IFile *entry = entries + i; 509 const char *fname = entry->fname; 510 Boolean printLineno; 511 char dirbuf[MAXPATHLEN + 1]; 512 513 if (fname[0] != '/' && strcmp(fname, "(stdin)") != 0) 514 fname = realpath(fname, dirbuf); 515 516 printLineno = !entry->fromForLoop; 517 if (i + 1 < n && entries[i + 1].fromForLoop == printLineno) 518 printLineno = entry->fromForLoop; 519 520 if (printLineno) 521 debug_printf("\tin .include from %s:%d\n", 522 fname, entry->lineno); 523 if (entry->fromForLoop) 524 debug_printf("\tin .for loop from %s:%d\n", 525 fname, entry->first_lineno); 526 } 527 } 528 529 /* Check if the current character is escaped on the current line. */ 530 static Boolean 531 ParseIsEscaped(const char *line, const char *c) 532 { 533 Boolean active = FALSE; 534 for (;;) { 535 if (line == c) 536 return active; 537 if (*--c != '\\') 538 return active; 539 active = !active; 540 } 541 } 542 543 /* 544 * Add the filename and lineno to the GNode so that we remember where it 545 * was first defined. 546 */ 547 static void 548 ParseMark(GNode *gn) 549 { 550 IFile *curFile = CurFile(); 551 gn->fname = curFile->fname; 552 gn->lineno = curFile->lineno; 553 } 554 555 /* 556 * Look in the table of keywords for one matching the given string. 557 * Return the index of the keyword, or -1 if it isn't there. 558 */ 559 static int 560 ParseFindKeyword(const char *str) 561 { 562 int start = 0; 563 int end = sizeof parseKeywords / sizeof parseKeywords[0] - 1; 564 565 do { 566 int curr = start + (end - start) / 2; 567 int diff = strcmp(str, parseKeywords[curr].name); 568 569 if (diff == 0) 570 return curr; 571 if (diff < 0) 572 end = curr - 1; 573 else 574 start = curr + 1; 575 } while (start <= end); 576 577 return -1; 578 } 579 580 static void 581 PrintLocation(FILE *f, const char *fname, size_t lineno) 582 { 583 char dirbuf[MAXPATHLEN + 1]; 584 FStr dir, base; 585 586 if (*fname == '/' || strcmp(fname, "(stdin)") == 0) { 587 (void)fprintf(f, "\"%s\" line %u: ", fname, (unsigned)lineno); 588 return; 589 } 590 591 /* Find out which makefile is the culprit. 592 * We try ${.PARSEDIR} and apply realpath(3) if not absolute. */ 593 594 dir = Var_Value(SCOPE_GLOBAL, ".PARSEDIR"); 595 if (dir.str == NULL) 596 dir.str = "."; 597 if (dir.str[0] != '/') 598 dir.str = realpath(dir.str, dirbuf); 599 600 base = Var_Value(SCOPE_GLOBAL, ".PARSEFILE"); 601 if (base.str == NULL) 602 base.str = str_basename(fname); 603 604 (void)fprintf(f, "\"%s/%s\" line %u: ", 605 dir.str, base.str, (unsigned)lineno); 606 607 FStr_Done(&base); 608 FStr_Done(&dir); 609 } 610 611 static void 612 ParseVErrorInternal(FILE *f, const char *fname, size_t lineno, 613 ParseErrorLevel type, const char *fmt, va_list ap) 614 { 615 static Boolean fatal_warning_error_printed = FALSE; 616 617 (void)fprintf(f, "%s: ", progname); 618 619 if (fname != NULL) 620 PrintLocation(f, fname, lineno); 621 if (type == PARSE_WARNING) 622 (void)fprintf(f, "warning: "); 623 (void)vfprintf(f, fmt, ap); 624 (void)fprintf(f, "\n"); 625 (void)fflush(f); 626 627 if (type == PARSE_INFO) 628 goto print_stack_trace; 629 if (type == PARSE_WARNING && !opts.parseWarnFatal) 630 goto print_stack_trace; 631 fatals++; 632 if (type == PARSE_WARNING && !fatal_warning_error_printed) { 633 Error("parsing warnings being treated as errors"); 634 fatal_warning_error_printed = TRUE; 635 } 636 637 print_stack_trace: 638 PrintStackTrace(); 639 } 640 641 static void 642 ParseErrorInternal(const char *fname, size_t lineno, 643 ParseErrorLevel type, const char *fmt, ...) 644 { 645 va_list ap; 646 647 (void)fflush(stdout); 648 va_start(ap, fmt); 649 ParseVErrorInternal(stderr, fname, lineno, type, fmt, ap); 650 va_end(ap); 651 652 if (opts.debug_file != stderr && opts.debug_file != stdout) { 653 va_start(ap, fmt); 654 ParseVErrorInternal(opts.debug_file, fname, lineno, type, 655 fmt, ap); 656 va_end(ap); 657 } 658 } 659 660 /* 661 * Print a parse error message, including location information. 662 * 663 * If the level is PARSE_FATAL, continue parsing until the end of the 664 * current top-level makefile, then exit (see Parse_File). 665 * 666 * Fmt is given without a trailing newline. 667 */ 668 void 669 Parse_Error(ParseErrorLevel type, const char *fmt, ...) 670 { 671 va_list ap; 672 const char *fname; 673 size_t lineno; 674 675 if (includes.len == 0) { 676 fname = NULL; 677 lineno = 0; 678 } else { 679 IFile *curFile = CurFile(); 680 fname = curFile->fname; 681 lineno = (size_t)curFile->lineno; 682 } 683 684 va_start(ap, fmt); 685 (void)fflush(stdout); 686 ParseVErrorInternal(stderr, fname, lineno, type, fmt, ap); 687 va_end(ap); 688 689 if (opts.debug_file != stderr && opts.debug_file != stdout) { 690 va_start(ap, fmt); 691 ParseVErrorInternal(opts.debug_file, fname, lineno, type, 692 fmt, ap); 693 va_end(ap); 694 } 695 } 696 697 698 /* 699 * Parse and handle an .info, .warning or .error directive. 700 * For an .error directive, immediately exit. 701 */ 702 static void 703 ParseMessage(ParseErrorLevel level, const char *levelName, const char *umsg) 704 { 705 char *xmsg; 706 707 if (umsg[0] == '\0') { 708 Parse_Error(PARSE_FATAL, "Missing argument for \".%s\"", 709 levelName); 710 return; 711 } 712 713 (void)Var_Subst(umsg, SCOPE_CMDLINE, VARE_WANTRES, &xmsg); 714 /* TODO: handle errors */ 715 716 Parse_Error(level, "%s", xmsg); 717 free(xmsg); 718 719 if (level == PARSE_FATAL) { 720 PrintOnError(NULL, NULL); 721 exit(1); 722 } 723 } 724 725 /* 726 * Add the child to the parent's children. 727 * 728 * Additionally, add the parent to the child's parents, but only if the 729 * target is not special. An example for such a special target is .END, 730 * which does not need to be informed once the child target has been made. 731 */ 732 static void 733 LinkSource(GNode *pgn, GNode *cgn, Boolean isSpecial) 734 { 735 if ((pgn->type & OP_DOUBLEDEP) && !Lst_IsEmpty(&pgn->cohorts)) 736 pgn = pgn->cohorts.last->datum; 737 738 Lst_Append(&pgn->children, cgn); 739 pgn->unmade++; 740 741 /* Special targets like .END don't need any children. */ 742 if (!isSpecial) 743 Lst_Append(&cgn->parents, pgn); 744 745 if (DEBUG(PARSE)) { 746 debug_printf("# %s: added child %s - %s\n", 747 __func__, pgn->name, cgn->name); 748 Targ_PrintNode(pgn, 0); 749 Targ_PrintNode(cgn, 0); 750 } 751 } 752 753 /* Add the node to each target from the current dependency group. */ 754 static void 755 LinkToTargets(GNode *gn, Boolean isSpecial) 756 { 757 GNodeListNode *ln; 758 759 for (ln = targets->first; ln != NULL; ln = ln->next) 760 LinkSource(ln->datum, gn, isSpecial); 761 } 762 763 static Boolean 764 TryApplyDependencyOperator(GNode *gn, GNodeType op) 765 { 766 /* 767 * If the node occurred on the left-hand side of a dependency and the 768 * operator also defines a dependency, they must match. 769 */ 770 if ((op & OP_OPMASK) && (gn->type & OP_OPMASK) && 771 ((op & OP_OPMASK) != (gn->type & OP_OPMASK))) { 772 Parse_Error(PARSE_FATAL, "Inconsistent operator for %s", 773 gn->name); 774 return FALSE; 775 } 776 777 if (op == OP_DOUBLEDEP && (gn->type & OP_OPMASK) == OP_DOUBLEDEP) { 778 /* 779 * If the node was of the left-hand side of a '::' operator, 780 * we need to create a new instance of it for the children 781 * and commands on this dependency line since each of these 782 * dependency groups has its own attributes and commands, 783 * separate from the others. 784 * 785 * The new instance is placed on the 'cohorts' list of the 786 * initial one (note the initial one is not on its own 787 * cohorts list) and the new instance is linked to all 788 * parents of the initial instance. 789 */ 790 GNode *cohort; 791 792 /* 793 * Propagate copied bits to the initial node. They'll be 794 * propagated back to the rest of the cohorts later. 795 */ 796 gn->type |= op & ~OP_OPMASK; 797 798 cohort = Targ_NewInternalNode(gn->name); 799 if (doing_depend) 800 ParseMark(cohort); 801 /* 802 * Make the cohort invisible as well to avoid duplicating it 803 * into other variables. True, parents of this target won't 804 * tend to do anything with their local variables, but better 805 * safe than sorry. 806 * 807 * (I think this is pointless now, since the relevant list 808 * traversals will no longer see this node anyway. -mycroft) 809 */ 810 cohort->type = op | OP_INVISIBLE; 811 Lst_Append(&gn->cohorts, cohort); 812 cohort->centurion = gn; 813 gn->unmade_cohorts++; 814 snprintf(cohort->cohort_num, sizeof cohort->cohort_num, "#%d", 815 (unsigned int)gn->unmade_cohorts % 1000000); 816 } else { 817 /* 818 * We don't want to nuke any previous flags (whatever they 819 * were) so we just OR the new operator into the old. 820 */ 821 gn->type |= op; 822 } 823 824 return TRUE; 825 } 826 827 static void 828 ApplyDependencyOperator(GNodeType op) 829 { 830 GNodeListNode *ln; 831 832 for (ln = targets->first; ln != NULL; ln = ln->next) 833 if (!TryApplyDependencyOperator(ln->datum, op)) 834 break; 835 } 836 837 /* 838 * We add a .WAIT node in the dependency list. After any dynamic dependencies 839 * (and filename globbing) have happened, it is given a dependency on each 840 * previous child, back until the previous .WAIT node. The next child won't 841 * be scheduled until the .WAIT node is built. 842 * 843 * We give each .WAIT node a unique name (mainly for diagnostics). 844 */ 845 static void 846 ParseDependencySourceWait(Boolean isSpecial) 847 { 848 static int wait_number = 0; 849 char wait_src[16]; 850 GNode *gn; 851 852 snprintf(wait_src, sizeof wait_src, ".WAIT_%u", ++wait_number); 853 gn = Targ_NewInternalNode(wait_src); 854 if (doing_depend) 855 ParseMark(gn); 856 gn->type = OP_WAIT | OP_PHONY | OP_DEPENDS | OP_NOTMAIN; 857 LinkToTargets(gn, isSpecial); 858 859 } 860 861 static Boolean 862 ParseDependencySourceKeyword(const char *src, ParseSpecial specType) 863 { 864 int keywd; 865 GNodeType op; 866 867 if (*src != '.' || !ch_isupper(src[1])) 868 return FALSE; 869 870 keywd = ParseFindKeyword(src); 871 if (keywd == -1) 872 return FALSE; 873 874 op = parseKeywords[keywd].op; 875 if (op != OP_NONE) { 876 ApplyDependencyOperator(op); 877 return TRUE; 878 } 879 if (parseKeywords[keywd].spec == SP_WAIT) { 880 ParseDependencySourceWait(specType != SP_NOT); 881 return TRUE; 882 } 883 return FALSE; 884 } 885 886 static void 887 ParseDependencySourceMain(const char *src) 888 { 889 /* 890 * In a line like ".MAIN: source1 source2", add all sources to the 891 * list of things to create, but only if the user didn't specify a 892 * target on the command line and .MAIN occurs for the first time. 893 * 894 * See ParseDoDependencyTargetSpecial, branch SP_MAIN. 895 * See unit-tests/cond-func-make-main.mk. 896 */ 897 Lst_Append(&opts.create, bmake_strdup(src)); 898 /* 899 * Add the name to the .TARGETS variable as well, so the user can 900 * employ that, if desired. 901 */ 902 Global_Append(".TARGETS", src); 903 } 904 905 static void 906 ParseDependencySourceOrder(const char *src) 907 { 908 GNode *gn; 909 /* 910 * Create proper predecessor/successor links between the previous 911 * source and the current one. 912 */ 913 gn = Targ_GetNode(src); 914 if (doing_depend) 915 ParseMark(gn); 916 if (order_pred != NULL) { 917 Lst_Append(&order_pred->order_succ, gn); 918 Lst_Append(&gn->order_pred, order_pred); 919 if (DEBUG(PARSE)) { 920 debug_printf("# %s: added Order dependency %s - %s\n", 921 __func__, order_pred->name, gn->name); 922 Targ_PrintNode(order_pred, 0); 923 Targ_PrintNode(gn, 0); 924 } 925 } 926 /* 927 * The current source now becomes the predecessor for the next one. 928 */ 929 order_pred = gn; 930 } 931 932 static void 933 ParseDependencySourceOther(const char *src, GNodeType tOp, 934 ParseSpecial specType) 935 { 936 GNode *gn; 937 938 /* 939 * The source is not an attribute, so find/create a node for it. 940 * After that, apply any operator to it from a special target or 941 * link it to its parents, as appropriate. 942 * 943 * In the case of a source that was the object of a '::' operator, 944 * the attribute is applied to all of its instances (as kept in 945 * the 'cohorts' list of the node) or all the cohorts are linked 946 * to all the targets. 947 */ 948 949 /* Find/create the 'src' node and attach to all targets */ 950 gn = Targ_GetNode(src); 951 if (doing_depend) 952 ParseMark(gn); 953 if (tOp != OP_NONE) 954 gn->type |= tOp; 955 else 956 LinkToTargets(gn, specType != SP_NOT); 957 } 958 959 /* 960 * Given the name of a source in a dependency line, figure out if it is an 961 * attribute (such as .SILENT) and apply it to the targets if it is. Else 962 * decide if there is some attribute which should be applied *to* the source 963 * because of some special target (such as .PHONY) and apply it if so. 964 * Otherwise, make the source a child of the targets in the list 'targets'. 965 * 966 * Input: 967 * tOp operator (if any) from special targets 968 * src name of the source to handle 969 */ 970 static void 971 ParseDependencySource(GNodeType tOp, const char *src, ParseSpecial specType) 972 { 973 if (ParseDependencySourceKeyword(src, specType)) 974 return; 975 976 if (specType == SP_MAIN) 977 ParseDependencySourceMain(src); 978 else if (specType == SP_ORDER) 979 ParseDependencySourceOrder(src); 980 else 981 ParseDependencySourceOther(src, tOp, specType); 982 } 983 984 /* 985 * If we have yet to decide on a main target to make, in the absence of any 986 * user input, we want the first target on the first dependency line that is 987 * actually a real target (i.e. isn't a .USE or .EXEC rule) to be made. 988 */ 989 static void 990 FindMainTarget(void) 991 { 992 GNodeListNode *ln; 993 994 if (mainNode != NULL) 995 return; 996 997 for (ln = targets->first; ln != NULL; ln = ln->next) { 998 GNode *gn = ln->datum; 999 if (!(gn->type & OP_NOTARGET)) { 1000 DEBUG1(MAKE, "Setting main node to \"%s\"\n", gn->name); 1001 mainNode = gn; 1002 Targ_SetMain(gn); 1003 return; 1004 } 1005 } 1006 } 1007 1008 /* 1009 * We got to the end of the line while we were still looking at targets. 1010 * 1011 * Ending a dependency line without an operator is a Bozo no-no. As a 1012 * heuristic, this is also often triggered by undetected conflicts from 1013 * cvs/rcs merges. 1014 */ 1015 static void 1016 ParseErrorNoDependency(const char *lstart) 1017 { 1018 if ((strncmp(lstart, "<<<<<<", 6) == 0) || 1019 (strncmp(lstart, "======", 6) == 0) || 1020 (strncmp(lstart, ">>>>>>", 6) == 0)) 1021 Parse_Error(PARSE_FATAL, 1022 "Makefile appears to contain unresolved cvs/rcs/??? merge conflicts"); 1023 else if (lstart[0] == '.') { 1024 const char *dirstart = lstart + 1; 1025 const char *dirend; 1026 cpp_skip_whitespace(&dirstart); 1027 dirend = dirstart; 1028 while (ch_isalnum(*dirend) || *dirend == '-') 1029 dirend++; 1030 Parse_Error(PARSE_FATAL, "Unknown directive \"%.*s\"", 1031 (int)(dirend - dirstart), dirstart); 1032 } else 1033 Parse_Error(PARSE_FATAL, "Invalid line type"); 1034 } 1035 1036 static void 1037 ParseDependencyTargetWord(const char **pp, const char *lstart) 1038 { 1039 const char *cp = *pp; 1040 1041 while (*cp != '\0') { 1042 if ((ch_isspace(*cp) || *cp == '!' || *cp == ':' || 1043 *cp == '(') && 1044 !ParseIsEscaped(lstart, cp)) 1045 break; 1046 1047 if (*cp == '$') { 1048 /* 1049 * Must be a dynamic source (would have been expanded 1050 * otherwise), so call the Var module to parse the 1051 * puppy so we can safely advance beyond it. 1052 * 1053 * There should be no errors in this, as they would 1054 * have been discovered in the initial Var_Subst and 1055 * we wouldn't be here. 1056 */ 1057 const char *nested_p = cp; 1058 FStr nested_val; 1059 1060 (void)Var_Parse(&nested_p, SCOPE_CMDLINE, VARE_NONE, 1061 &nested_val); 1062 /* TODO: handle errors */ 1063 FStr_Done(&nested_val); 1064 cp += nested_p - cp; 1065 } else 1066 cp++; 1067 } 1068 1069 *pp = cp; 1070 } 1071 1072 /* Handle special targets like .PATH, .DEFAULT, .BEGIN, .ORDER. */ 1073 static void 1074 ParseDoDependencyTargetSpecial(ParseSpecial *inout_specType, 1075 const char *targetName, 1076 SearchPathList **inout_paths) 1077 { 1078 switch (*inout_specType) { 1079 case SP_PATH: 1080 if (*inout_paths == NULL) 1081 *inout_paths = Lst_New(); 1082 Lst_Append(*inout_paths, &dirSearchPath); 1083 break; 1084 case SP_MAIN: 1085 /* 1086 * Allow targets from the command line to override the 1087 * .MAIN node. 1088 */ 1089 if (!Lst_IsEmpty(&opts.create)) 1090 *inout_specType = SP_NOT; 1091 break; 1092 case SP_BEGIN: 1093 case SP_END: 1094 case SP_STALE: 1095 case SP_ERROR: 1096 case SP_INTERRUPT: { 1097 GNode *gn = Targ_GetNode(targetName); 1098 if (doing_depend) 1099 ParseMark(gn); 1100 gn->type |= OP_NOTMAIN | OP_SPECIAL; 1101 Lst_Append(targets, gn); 1102 break; 1103 } 1104 case SP_DEFAULT: { 1105 /* 1106 * Need to create a node to hang commands on, but we don't 1107 * want it in the graph, nor do we want it to be the Main 1108 * Target. We claim the node is a transformation rule to make 1109 * life easier later, when we'll use Make_HandleUse to 1110 * actually apply the .DEFAULT commands. 1111 */ 1112 GNode *gn = GNode_New(".DEFAULT"); 1113 gn->type |= OP_NOTMAIN | OP_TRANSFORM; 1114 Lst_Append(targets, gn); 1115 defaultNode = gn; 1116 break; 1117 } 1118 case SP_DELETE_ON_ERROR: 1119 deleteOnError = TRUE; 1120 break; 1121 case SP_NOTPARALLEL: 1122 opts.maxJobs = 1; 1123 break; 1124 case SP_SINGLESHELL: 1125 opts.compatMake = TRUE; 1126 break; 1127 case SP_ORDER: 1128 order_pred = NULL; 1129 break; 1130 default: 1131 break; 1132 } 1133 } 1134 1135 /* 1136 * .PATH<suffix> has to be handled specially. 1137 * Call on the suffix module to give us a path to modify. 1138 */ 1139 static Boolean 1140 ParseDoDependencyTargetPath(const char *suffixName, 1141 SearchPathList **inout_paths) 1142 { 1143 SearchPath *path; 1144 1145 path = Suff_GetPath(suffixName); 1146 if (path == NULL) { 1147 Parse_Error(PARSE_FATAL, 1148 "Suffix '%s' not defined (yet)", suffixName); 1149 return FALSE; 1150 } 1151 1152 if (*inout_paths == NULL) 1153 *inout_paths = Lst_New(); 1154 Lst_Append(*inout_paths, path); 1155 1156 return TRUE; 1157 } 1158 1159 /* 1160 * See if it's a special target and if so set specType to match it. 1161 */ 1162 static Boolean 1163 ParseDoDependencyTarget(const char *targetName, 1164 ParseSpecial *inout_specType, 1165 GNodeType *out_tOp, SearchPathList **inout_paths) 1166 { 1167 int keywd; 1168 1169 if (!(targetName[0] == '.' && ch_isupper(targetName[1]))) 1170 return TRUE; 1171 1172 /* 1173 * See if the target is a special target that must have it 1174 * or its sources handled specially. 1175 */ 1176 keywd = ParseFindKeyword(targetName); 1177 if (keywd != -1) { 1178 if (*inout_specType == SP_PATH && 1179 parseKeywords[keywd].spec != SP_PATH) { 1180 Parse_Error(PARSE_FATAL, "Mismatched special targets"); 1181 return FALSE; 1182 } 1183 1184 *inout_specType = parseKeywords[keywd].spec; 1185 *out_tOp = parseKeywords[keywd].op; 1186 1187 ParseDoDependencyTargetSpecial(inout_specType, targetName, 1188 inout_paths); 1189 1190 } else if (strncmp(targetName, ".PATH", 5) == 0) { 1191 *inout_specType = SP_PATH; 1192 if (!ParseDoDependencyTargetPath(targetName + 5, inout_paths)) 1193 return FALSE; 1194 } 1195 return TRUE; 1196 } 1197 1198 static void 1199 ParseDoDependencyTargetMundane(char *targetName, StringList *curTargs) 1200 { 1201 if (Dir_HasWildcards(targetName)) { 1202 /* 1203 * Targets are to be sought only in the current directory, 1204 * so create an empty path for the thing. Note we need to 1205 * use Dir_Destroy in the destruction of the path as the 1206 * Dir module could have added a directory to the path... 1207 */ 1208 SearchPath *emptyPath = SearchPath_New(); 1209 1210 SearchPath_Expand(emptyPath, targetName, curTargs); 1211 1212 SearchPath_Free(emptyPath); 1213 } else { 1214 /* 1215 * No wildcards, but we want to avoid code duplication, 1216 * so create a list with the word on it. 1217 */ 1218 Lst_Append(curTargs, targetName); 1219 } 1220 1221 /* Apply the targets. */ 1222 1223 while (!Lst_IsEmpty(curTargs)) { 1224 char *targName = Lst_Dequeue(curTargs); 1225 GNode *gn = Suff_IsTransform(targName) 1226 ? Suff_AddTransform(targName) 1227 : Targ_GetNode(targName); 1228 if (doing_depend) 1229 ParseMark(gn); 1230 1231 Lst_Append(targets, gn); 1232 } 1233 } 1234 1235 static void 1236 ParseDoDependencyTargetExtraWarn(char **pp, const char *lstart) 1237 { 1238 Boolean warning = FALSE; 1239 char *cp = *pp; 1240 1241 while (*cp != '\0') { 1242 if (!ParseIsEscaped(lstart, cp) && (*cp == '!' || *cp == ':')) 1243 break; 1244 if (ParseIsEscaped(lstart, cp) || (*cp != ' ' && *cp != '\t')) 1245 warning = TRUE; 1246 cp++; 1247 } 1248 if (warning) 1249 Parse_Error(PARSE_WARNING, "Extra target ignored"); 1250 1251 *pp = cp; 1252 } 1253 1254 static void 1255 ParseDoDependencyCheckSpec(ParseSpecial specType) 1256 { 1257 switch (specType) { 1258 default: 1259 Parse_Error(PARSE_WARNING, 1260 "Special and mundane targets don't mix. " 1261 "Mundane ones ignored"); 1262 break; 1263 case SP_DEFAULT: 1264 case SP_STALE: 1265 case SP_BEGIN: 1266 case SP_END: 1267 case SP_ERROR: 1268 case SP_INTERRUPT: 1269 /* 1270 * These create nodes on which to hang commands, so targets 1271 * shouldn't be empty. 1272 */ 1273 case SP_NOT: 1274 /* Nothing special here -- targets can be empty if it wants. */ 1275 break; 1276 } 1277 } 1278 1279 static Boolean 1280 ParseDoDependencyParseOp(char **pp, const char *lstart, GNodeType *out_op) 1281 { 1282 const char *cp = *pp; 1283 1284 if (*cp == '!') { 1285 *out_op = OP_FORCE; 1286 (*pp)++; 1287 return TRUE; 1288 } 1289 1290 if (*cp == ':') { 1291 if (cp[1] == ':') { 1292 *out_op = OP_DOUBLEDEP; 1293 (*pp) += 2; 1294 } else { 1295 *out_op = OP_DEPENDS; 1296 (*pp)++; 1297 } 1298 return TRUE; 1299 } 1300 1301 { 1302 const char *msg = lstart[0] == '.' 1303 ? "Unknown directive" : "Missing dependency operator"; 1304 Parse_Error(PARSE_FATAL, "%s", msg); 1305 return FALSE; 1306 } 1307 } 1308 1309 static void 1310 ClearPaths(SearchPathList *paths) 1311 { 1312 if (paths != NULL) { 1313 SearchPathListNode *ln; 1314 for (ln = paths->first; ln != NULL; ln = ln->next) 1315 SearchPath_Clear(ln->datum); 1316 } 1317 1318 Dir_SetPATH(); 1319 } 1320 1321 static void 1322 ParseDoDependencySourcesEmpty(ParseSpecial specType, SearchPathList *paths) 1323 { 1324 switch (specType) { 1325 case SP_SUFFIXES: 1326 Suff_ClearSuffixes(); 1327 break; 1328 case SP_PRECIOUS: 1329 allPrecious = TRUE; 1330 break; 1331 case SP_IGNORE: 1332 opts.ignoreErrors = TRUE; 1333 break; 1334 case SP_SILENT: 1335 opts.beSilent = TRUE; 1336 break; 1337 case SP_PATH: 1338 ClearPaths(paths); 1339 break; 1340 #ifdef POSIX 1341 case SP_POSIX: 1342 Global_Set("%POSIX", "1003.2"); 1343 break; 1344 #endif 1345 default: 1346 break; 1347 } 1348 } 1349 1350 static void 1351 AddToPaths(const char *dir, SearchPathList *paths) 1352 { 1353 if (paths != NULL) { 1354 SearchPathListNode *ln; 1355 for (ln = paths->first; ln != NULL; ln = ln->next) 1356 (void)SearchPath_Add(ln->datum, dir); 1357 } 1358 } 1359 1360 /* 1361 * If the target was one that doesn't take files as its sources 1362 * but takes something like suffixes, we take each 1363 * space-separated word on the line as a something and deal 1364 * with it accordingly. 1365 * 1366 * If the target was .SUFFIXES, we take each source as a 1367 * suffix and add it to the list of suffixes maintained by the 1368 * Suff module. 1369 * 1370 * If the target was a .PATH, we add the source as a directory 1371 * to search on the search path. 1372 * 1373 * If it was .INCLUDES, the source is taken to be the suffix of 1374 * files which will be #included and whose search path should 1375 * be present in the .INCLUDES variable. 1376 * 1377 * If it was .LIBS, the source is taken to be the suffix of 1378 * files which are considered libraries and whose search path 1379 * should be present in the .LIBS variable. 1380 * 1381 * If it was .NULL, the source is the suffix to use when a file 1382 * has no valid suffix. 1383 * 1384 * If it was .OBJDIR, the source is a new definition for .OBJDIR, 1385 * and will cause make to do a new chdir to that path. 1386 */ 1387 static void 1388 ParseDoDependencySourceSpecial(ParseSpecial specType, char *word, 1389 SearchPathList *paths) 1390 { 1391 switch (specType) { 1392 case SP_SUFFIXES: 1393 Suff_AddSuffix(word, &mainNode); 1394 break; 1395 case SP_PATH: 1396 AddToPaths(word, paths); 1397 break; 1398 case SP_INCLUDES: 1399 Suff_AddInclude(word); 1400 break; 1401 case SP_LIBS: 1402 Suff_AddLib(word); 1403 break; 1404 case SP_NULL: 1405 Suff_SetNull(word); 1406 break; 1407 case SP_OBJDIR: 1408 Main_SetObjdir(FALSE, "%s", word); 1409 break; 1410 default: 1411 break; 1412 } 1413 } 1414 1415 static Boolean 1416 ParseDoDependencyTargets(char **inout_cp, 1417 char **inout_line, 1418 const char *lstart, 1419 ParseSpecial *inout_specType, 1420 GNodeType *inout_tOp, 1421 SearchPathList **inout_paths, 1422 StringList *curTargs) 1423 { 1424 char *cp; 1425 char *tgt = *inout_line; 1426 char savec; 1427 const char *p; 1428 1429 for (;;) { 1430 /* 1431 * Here LINE points to the beginning of the next word, and 1432 * LSTART points to the actual beginning of the line. 1433 */ 1434 1435 /* Find the end of the next word. */ 1436 cp = tgt; 1437 p = cp; 1438 ParseDependencyTargetWord(&p, lstart); 1439 cp += p - cp; 1440 1441 /* 1442 * If the word is followed by a left parenthesis, it's the 1443 * name of an object file inside an archive (ar file). 1444 */ 1445 if (!ParseIsEscaped(lstart, cp) && *cp == '(') { 1446 /* 1447 * Archives must be handled specially to make sure the 1448 * OP_ARCHV flag is set in their 'type' field, for one 1449 * thing, and because things like "archive(file1.o 1450 * file2.o file3.o)" are permissible. 1451 * 1452 * Arch_ParseArchive will set 'line' to be the first 1453 * non-blank after the archive-spec. It creates/finds 1454 * nodes for the members and places them on the given 1455 * list, returning TRUE if all went well and FALSE if 1456 * there was an error in the specification. On error, 1457 * line should remain untouched. 1458 */ 1459 if (!Arch_ParseArchive(&tgt, targets, SCOPE_CMDLINE)) { 1460 Parse_Error(PARSE_FATAL, 1461 "Error in archive specification: \"%s\"", 1462 tgt); 1463 return FALSE; 1464 } 1465 1466 cp = tgt; 1467 continue; 1468 } 1469 1470 if (*cp == '\0') { 1471 ParseErrorNoDependency(lstart); 1472 return FALSE; 1473 } 1474 1475 /* Insert a null terminator. */ 1476 savec = *cp; 1477 *cp = '\0'; 1478 1479 if (!ParseDoDependencyTarget(tgt, inout_specType, inout_tOp, 1480 inout_paths)) 1481 return FALSE; 1482 1483 /* 1484 * Have word in line. Get or create its node and stick it at 1485 * the end of the targets list 1486 */ 1487 if (*inout_specType == SP_NOT && *tgt != '\0') 1488 ParseDoDependencyTargetMundane(tgt, curTargs); 1489 else if (*inout_specType == SP_PATH && *tgt != '.' && 1490 *tgt != '\0') 1491 Parse_Error(PARSE_WARNING, "Extra target (%s) ignored", 1492 tgt); 1493 1494 /* Don't need the inserted null terminator any more. */ 1495 *cp = savec; 1496 1497 /* 1498 * If it is a special type and not .PATH, it's the only target 1499 * we allow on this line. 1500 */ 1501 if (*inout_specType != SP_NOT && *inout_specType != SP_PATH) 1502 ParseDoDependencyTargetExtraWarn(&cp, lstart); 1503 else 1504 pp_skip_whitespace(&cp); 1505 1506 tgt = cp; 1507 if (*tgt == '\0') 1508 break; 1509 if ((*tgt == '!' || *tgt == ':') && 1510 !ParseIsEscaped(lstart, tgt)) 1511 break; 1512 } 1513 1514 *inout_cp = cp; 1515 *inout_line = tgt; 1516 return TRUE; 1517 } 1518 1519 static void 1520 ParseDoDependencySourcesSpecial(char *start, char *end, 1521 ParseSpecial specType, SearchPathList *paths) 1522 { 1523 char savec; 1524 1525 while (*start != '\0') { 1526 while (*end != '\0' && !ch_isspace(*end)) 1527 end++; 1528 savec = *end; 1529 *end = '\0'; 1530 ParseDoDependencySourceSpecial(specType, start, paths); 1531 *end = savec; 1532 if (savec != '\0') 1533 end++; 1534 pp_skip_whitespace(&end); 1535 start = end; 1536 } 1537 } 1538 1539 static Boolean 1540 ParseDoDependencySourcesMundane(char *start, char *end, 1541 ParseSpecial specType, GNodeType tOp) 1542 { 1543 while (*start != '\0') { 1544 /* 1545 * The targets take real sources, so we must beware of archive 1546 * specifications (i.e. things with left parentheses in them) 1547 * and handle them accordingly. 1548 */ 1549 for (; *end != '\0' && !ch_isspace(*end); end++) { 1550 if (*end == '(' && end > start && end[-1] != '$') { 1551 /* 1552 * Only stop for a left parenthesis if it 1553 * isn't at the start of a word (that'll be 1554 * for variable changes later) and isn't 1555 * preceded by a dollar sign (a dynamic 1556 * source). 1557 */ 1558 break; 1559 } 1560 } 1561 1562 if (*end == '(') { 1563 GNodeList sources = LST_INIT; 1564 if (!Arch_ParseArchive(&start, &sources, 1565 SCOPE_CMDLINE)) { 1566 Parse_Error(PARSE_FATAL, 1567 "Error in source archive spec \"%s\"", 1568 start); 1569 return FALSE; 1570 } 1571 1572 while (!Lst_IsEmpty(&sources)) { 1573 GNode *gn = Lst_Dequeue(&sources); 1574 ParseDependencySource(tOp, gn->name, specType); 1575 } 1576 Lst_Done(&sources); 1577 end = start; 1578 } else { 1579 if (*end != '\0') { 1580 *end = '\0'; 1581 end++; 1582 } 1583 1584 ParseDependencySource(tOp, start, specType); 1585 } 1586 pp_skip_whitespace(&end); 1587 start = end; 1588 } 1589 return TRUE; 1590 } 1591 1592 /* 1593 * Parse a dependency line consisting of targets, followed by a dependency 1594 * operator, optionally followed by sources. 1595 * 1596 * The nodes of the sources are linked as children to the nodes of the 1597 * targets. Nodes are created as necessary. 1598 * 1599 * The operator is applied to each node in the global 'targets' list, 1600 * which is where the nodes found for the targets are kept, by means of 1601 * the ParseDoOp function. 1602 * 1603 * The sources are parsed in much the same way as the targets, except 1604 * that they are expanded using the wildcarding scheme of the C-Shell, 1605 * and a target is created for each expanded word. Each of the resulting 1606 * nodes is then linked to each of the targets as one of its children. 1607 * 1608 * Certain targets and sources such as .PHONY or .PRECIOUS are handled 1609 * specially. These are the ones detailed by the specType variable. 1610 * 1611 * The storing of transformation rules such as '.c.o' is also taken care of 1612 * here. A target is recognized as a transformation rule by calling 1613 * Suff_IsTransform. If it is a transformation rule, its node is gotten 1614 * from the suffix module via Suff_AddTransform rather than the standard 1615 * Targ_FindNode in the target module. 1616 * 1617 * Upon return, the value of the line is unspecified. 1618 */ 1619 static void 1620 ParseDoDependency(char *line) 1621 { 1622 char *cp; /* our current position */ 1623 GNodeType op; /* the operator on the line */ 1624 SearchPathList *paths; /* search paths to alter when parsing 1625 * a list of .PATH targets */ 1626 GNodeType tOp; /* operator from special target */ 1627 /* target names to be found and added to the targets list */ 1628 StringList curTargs = LST_INIT; 1629 char *lstart = line; 1630 1631 /* 1632 * specType contains the SPECial TYPE of the current target. It is 1633 * SP_NOT if the target is unspecial. If it *is* special, however, the 1634 * children are linked as children of the parent but not vice versa. 1635 */ 1636 ParseSpecial specType = SP_NOT; 1637 1638 DEBUG1(PARSE, "ParseDoDependency(%s)\n", line); 1639 tOp = OP_NONE; 1640 1641 paths = NULL; 1642 1643 /* 1644 * First, grind through the targets. 1645 */ 1646 /* XXX: don't use line as an iterator variable */ 1647 if (!ParseDoDependencyTargets(&cp, &line, lstart, &specType, &tOp, 1648 &paths, &curTargs)) 1649 goto out; 1650 1651 /* 1652 * Don't need the list of target names anymore. 1653 * The targets themselves are now in the global variable 'targets'. 1654 */ 1655 Lst_Done(&curTargs); 1656 Lst_Init(&curTargs); 1657 1658 if (!Lst_IsEmpty(targets)) 1659 ParseDoDependencyCheckSpec(specType); 1660 1661 /* 1662 * Have now parsed all the target names. Must parse the operator next. 1663 */ 1664 if (!ParseDoDependencyParseOp(&cp, lstart, &op)) 1665 goto out; 1666 1667 /* 1668 * Apply the operator to the target. This is how we remember which 1669 * operator a target was defined with. It fails if the operator 1670 * used isn't consistent across all references. 1671 */ 1672 ApplyDependencyOperator(op); 1673 1674 /* 1675 * Onward to the sources. 1676 * 1677 * LINE will now point to the first source word, if any, or the 1678 * end of the string if not. 1679 */ 1680 pp_skip_whitespace(&cp); 1681 line = cp; /* XXX: 'line' is an inappropriate name */ 1682 1683 /* 1684 * Several special targets take different actions if present with no 1685 * sources: 1686 * a .SUFFIXES line with no sources clears out all old suffixes 1687 * a .PRECIOUS line makes all targets precious 1688 * a .IGNORE line ignores errors for all targets 1689 * a .SILENT line creates silence when making all targets 1690 * a .PATH removes all directories from the search path(s). 1691 */ 1692 if (line[0] == '\0') { 1693 ParseDoDependencySourcesEmpty(specType, paths); 1694 } else if (specType == SP_MFLAGS) { 1695 /* 1696 * Call on functions in main.c to deal with these arguments and 1697 * set the initial character to a null-character so the loop to 1698 * get sources won't get anything 1699 */ 1700 Main_ParseArgLine(line); 1701 *line = '\0'; 1702 } else if (specType == SP_SHELL) { 1703 if (!Job_ParseShell(line)) { 1704 Parse_Error(PARSE_FATAL, 1705 "improper shell specification"); 1706 goto out; 1707 } 1708 *line = '\0'; 1709 } else if (specType == SP_NOTPARALLEL || specType == SP_SINGLESHELL || 1710 specType == SP_DELETE_ON_ERROR) { 1711 *line = '\0'; 1712 } 1713 1714 /* Now go for the sources. */ 1715 if (specType == SP_SUFFIXES || specType == SP_PATH || 1716 specType == SP_INCLUDES || specType == SP_LIBS || 1717 specType == SP_NULL || specType == SP_OBJDIR) { 1718 ParseDoDependencySourcesSpecial(line, cp, specType, paths); 1719 if (paths != NULL) { 1720 Lst_Free(paths); 1721 paths = NULL; 1722 } 1723 if (specType == SP_PATH) 1724 Dir_SetPATH(); 1725 } else { 1726 assert(paths == NULL); 1727 if (!ParseDoDependencySourcesMundane(line, cp, specType, tOp)) 1728 goto out; 1729 } 1730 1731 FindMainTarget(); 1732 1733 out: 1734 if (paths != NULL) 1735 Lst_Free(paths); 1736 Lst_Done(&curTargs); 1737 } 1738 1739 typedef struct VarAssignParsed { 1740 const char *nameStart; /* unexpanded */ 1741 const char *nameEnd; /* before operator adjustment */ 1742 const char *eq; /* the '=' of the assignment operator */ 1743 } VarAssignParsed; 1744 1745 /* 1746 * Determine the assignment operator and adjust the end of the variable 1747 * name accordingly. 1748 */ 1749 static void 1750 AdjustVarassignOp(const VarAssignParsed *pvar, const char *value, 1751 VarAssign *out_var) 1752 { 1753 const char *op = pvar->eq; 1754 const char *const name = pvar->nameStart; 1755 VarAssignOp type; 1756 1757 if (op > name && op[-1] == '+') { 1758 type = VAR_APPEND; 1759 op--; 1760 1761 } else if (op > name && op[-1] == '?') { 1762 op--; 1763 type = VAR_DEFAULT; 1764 1765 } else if (op > name && op[-1] == ':') { 1766 op--; 1767 type = VAR_SUBST; 1768 1769 } else if (op > name && op[-1] == '!') { 1770 op--; 1771 type = VAR_SHELL; 1772 1773 } else { 1774 type = VAR_NORMAL; 1775 #ifdef SUNSHCMD 1776 while (op > name && ch_isspace(op[-1])) 1777 op--; 1778 1779 if (op >= name + 3 && op[-3] == ':' && op[-2] == 's' && 1780 op[-1] == 'h') { 1781 type = VAR_SHELL; 1782 op -= 3; 1783 } 1784 #endif 1785 } 1786 1787 { 1788 const char *nameEnd = pvar->nameEnd < op ? pvar->nameEnd : op; 1789 out_var->varname = bmake_strsedup(pvar->nameStart, nameEnd); 1790 out_var->op = type; 1791 out_var->value = value; 1792 } 1793 } 1794 1795 /* 1796 * Parse a variable assignment, consisting of a single-word variable name, 1797 * optional whitespace, an assignment operator, optional whitespace and the 1798 * variable value. 1799 * 1800 * Note: There is a lexical ambiguity with assignment modifier characters 1801 * in variable names. This routine interprets the character before the = 1802 * as a modifier. Therefore, an assignment like 1803 * C++=/usr/bin/CC 1804 * is interpreted as "C+ +=" instead of "C++ =". 1805 * 1806 * Used for both lines in a file and command line arguments. 1807 */ 1808 Boolean 1809 Parse_IsVar(const char *p, VarAssign *out_var) 1810 { 1811 VarAssignParsed pvar; 1812 const char *firstSpace = NULL; 1813 int level = 0; 1814 1815 cpp_skip_hspace(&p); /* Skip to variable name */ 1816 1817 /* 1818 * During parsing, the '+' of the '+=' operator is initially parsed 1819 * as part of the variable name. It is later corrected, as is the 1820 * ':sh' modifier. Of these two (nameEnd and op), the earlier one 1821 * determines the actual end of the variable name. 1822 */ 1823 pvar.nameStart = p; 1824 #ifdef CLEANUP 1825 pvar.nameEnd = NULL; 1826 pvar.eq = NULL; 1827 #endif 1828 1829 /* 1830 * Scan for one of the assignment operators outside a variable 1831 * expansion. 1832 */ 1833 while (*p != '\0') { 1834 char ch = *p++; 1835 if (ch == '(' || ch == '{') { 1836 level++; 1837 continue; 1838 } 1839 if (ch == ')' || ch == '}') { 1840 level--; 1841 continue; 1842 } 1843 1844 if (level != 0) 1845 continue; 1846 1847 if (ch == ' ' || ch == '\t') 1848 if (firstSpace == NULL) 1849 firstSpace = p - 1; 1850 while (ch == ' ' || ch == '\t') 1851 ch = *p++; 1852 1853 #ifdef SUNSHCMD 1854 if (ch == ':' && p[0] == 's' && p[1] == 'h') { 1855 p += 2; 1856 continue; 1857 } 1858 #endif 1859 if (ch == '=') { 1860 pvar.eq = p - 1; 1861 pvar.nameEnd = firstSpace != NULL ? firstSpace : p - 1; 1862 cpp_skip_whitespace(&p); 1863 AdjustVarassignOp(&pvar, p, out_var); 1864 return TRUE; 1865 } 1866 if (*p == '=' && 1867 (ch == '+' || ch == ':' || ch == '?' || ch == '!')) { 1868 pvar.eq = p; 1869 pvar.nameEnd = firstSpace != NULL ? firstSpace : p; 1870 p++; 1871 cpp_skip_whitespace(&p); 1872 AdjustVarassignOp(&pvar, p, out_var); 1873 return TRUE; 1874 } 1875 if (firstSpace != NULL) 1876 return FALSE; 1877 } 1878 1879 return FALSE; 1880 } 1881 1882 /* 1883 * Check for syntax errors such as unclosed expressions or unknown modifiers. 1884 */ 1885 static void 1886 VarCheckSyntax(VarAssignOp type, const char *uvalue, GNode *scope) 1887 { 1888 if (opts.strict) { 1889 if (type != VAR_SUBST && strchr(uvalue, '$') != NULL) { 1890 char *expandedValue; 1891 1892 (void)Var_Subst(uvalue, scope, VARE_NONE, 1893 &expandedValue); 1894 /* TODO: handle errors */ 1895 free(expandedValue); 1896 } 1897 } 1898 } 1899 1900 static void 1901 VarAssign_EvalSubst(GNode *scope, const char *name, const char *uvalue, 1902 FStr *out_avalue) 1903 { 1904 char *evalue; 1905 1906 /* 1907 * make sure that we set the variable the first time to nothing 1908 * so that it gets substituted. 1909 * 1910 * TODO: Add a test that demonstrates why this code is needed, 1911 * apart from making the debug log longer. 1912 */ 1913 if (!Var_ExistsExpand(scope, name)) 1914 Var_SetExpand(scope, name, ""); 1915 1916 (void)Var_Subst(uvalue, scope, 1917 VARE_WANTRES | VARE_KEEP_DOLLAR | VARE_KEEP_UNDEF, &evalue); 1918 /* TODO: handle errors */ 1919 1920 Var_SetExpand(scope, name, evalue); 1921 1922 *out_avalue = FStr_InitOwn(evalue); 1923 } 1924 1925 static void 1926 VarAssign_EvalShell(const char *name, const char *uvalue, GNode *scope, 1927 FStr *out_avalue) 1928 { 1929 FStr cmd; 1930 const char *errfmt; 1931 char *cmdOut; 1932 1933 cmd = FStr_InitRefer(uvalue); 1934 if (strchr(cmd.str, '$') != NULL) { 1935 char *expanded; 1936 (void)Var_Subst(cmd.str, SCOPE_CMDLINE, 1937 VARE_WANTRES | VARE_UNDEFERR, &expanded); 1938 /* TODO: handle errors */ 1939 cmd = FStr_InitOwn(expanded); 1940 } 1941 1942 cmdOut = Cmd_Exec(cmd.str, &errfmt); 1943 Var_SetExpand(scope, name, cmdOut); 1944 *out_avalue = FStr_InitOwn(cmdOut); 1945 1946 if (errfmt != NULL) 1947 Parse_Error(PARSE_WARNING, errfmt, cmd.str); 1948 1949 FStr_Done(&cmd); 1950 } 1951 1952 /* 1953 * Perform a variable assignment. 1954 * 1955 * The actual value of the variable is returned in *out_TRUE_avalue. 1956 * Especially for VAR_SUBST and VAR_SHELL this can differ from the literal 1957 * value. 1958 * 1959 * Return whether the assignment was actually performed, which is usually 1960 * the case. It is only skipped if the operator is '?=' and the variable 1961 * already exists. 1962 */ 1963 static Boolean 1964 VarAssign_Eval(const char *name, VarAssignOp op, const char *uvalue, 1965 GNode *scope, FStr *out_TRUE_avalue) 1966 { 1967 FStr avalue = FStr_InitRefer(uvalue); 1968 1969 if (op == VAR_APPEND) 1970 Var_AppendExpand(scope, name, uvalue); 1971 else if (op == VAR_SUBST) 1972 VarAssign_EvalSubst(scope, name, uvalue, &avalue); 1973 else if (op == VAR_SHELL) 1974 VarAssign_EvalShell(name, uvalue, scope, &avalue); 1975 else { 1976 if (op == VAR_DEFAULT && Var_ExistsExpand(scope, name)) 1977 return FALSE; 1978 1979 /* Normal assignment -- just do it. */ 1980 Var_SetExpand(scope, name, uvalue); 1981 } 1982 1983 *out_TRUE_avalue = avalue; 1984 return TRUE; 1985 } 1986 1987 static void 1988 VarAssignSpecial(const char *name, const char *avalue) 1989 { 1990 if (strcmp(name, MAKEOVERRIDES) == 0) 1991 Main_ExportMAKEFLAGS(FALSE); /* re-export MAKEFLAGS */ 1992 else if (strcmp(name, ".CURDIR") == 0) { 1993 /* 1994 * Someone is being (too?) clever... 1995 * Let's pretend they know what they are doing and 1996 * re-initialize the 'cur' CachedDir. 1997 */ 1998 Dir_InitCur(avalue); 1999 Dir_SetPATH(); 2000 } else if (strcmp(name, MAKE_JOB_PREFIX) == 0) 2001 Job_SetPrefix(); 2002 else if (strcmp(name, MAKE_EXPORTED) == 0) 2003 Var_ExportVars(avalue); 2004 } 2005 2006 /* Perform the variable variable assignment in the given scope. */ 2007 void 2008 Parse_DoVar(VarAssign *var, GNode *scope) 2009 { 2010 FStr avalue; /* actual value (maybe expanded) */ 2011 2012 VarCheckSyntax(var->op, var->value, scope); 2013 if (VarAssign_Eval(var->varname, var->op, var->value, scope, &avalue)) { 2014 VarAssignSpecial(var->varname, avalue.str); 2015 FStr_Done(&avalue); 2016 } 2017 2018 free(var->varname); 2019 } 2020 2021 2022 /* 2023 * See if the command possibly calls a sub-make by using the variable 2024 * expressions ${.MAKE}, ${MAKE} or the plain word "make". 2025 */ 2026 static Boolean 2027 MaybeSubMake(const char *cmd) 2028 { 2029 const char *start; 2030 2031 for (start = cmd; *start != '\0'; start++) { 2032 const char *p = start; 2033 char endc; 2034 2035 /* XXX: What if progname != "make"? */ 2036 if (p[0] == 'm' && p[1] == 'a' && p[2] == 'k' && p[3] == 'e') 2037 if (start == cmd || !ch_isalnum(p[-1])) 2038 if (!ch_isalnum(p[4])) 2039 return TRUE; 2040 2041 if (*p != '$') 2042 continue; 2043 p++; 2044 2045 if (*p == '{') 2046 endc = '}'; 2047 else if (*p == '(') 2048 endc = ')'; 2049 else 2050 continue; 2051 p++; 2052 2053 if (*p == '.') /* Accept either ${.MAKE} or ${MAKE}. */ 2054 p++; 2055 2056 if (p[0] == 'M' && p[1] == 'A' && p[2] == 'K' && p[3] == 'E') 2057 if (p[4] == endc) 2058 return TRUE; 2059 } 2060 return FALSE; 2061 } 2062 2063 /* 2064 * Append the command to the target node. 2065 * 2066 * The node may be marked as a submake node if the command is determined to 2067 * be that. 2068 */ 2069 static void 2070 ParseAddCmd(GNode *gn, char *cmd) 2071 { 2072 /* Add to last (ie current) cohort for :: targets */ 2073 if ((gn->type & OP_DOUBLEDEP) && gn->cohorts.last != NULL) 2074 gn = gn->cohorts.last->datum; 2075 2076 /* if target already supplied, ignore commands */ 2077 if (!(gn->type & OP_HAS_COMMANDS)) { 2078 Lst_Append(&gn->commands, cmd); 2079 if (MaybeSubMake(cmd)) 2080 gn->type |= OP_SUBMAKE; 2081 ParseMark(gn); 2082 } else { 2083 #if 0 2084 /* XXX: We cannot do this until we fix the tree */ 2085 Lst_Append(&gn->commands, cmd); 2086 Parse_Error(PARSE_WARNING, 2087 "overriding commands for target \"%s\"; " 2088 "previous commands defined at %s: %d ignored", 2089 gn->name, gn->fname, gn->lineno); 2090 #else 2091 Parse_Error(PARSE_WARNING, 2092 "duplicate script for target \"%s\" ignored", 2093 gn->name); 2094 ParseErrorInternal(gn->fname, (size_t)gn->lineno, PARSE_WARNING, 2095 "using previous script for \"%s\" defined here", 2096 gn->name); 2097 #endif 2098 } 2099 } 2100 2101 /* 2102 * Add a directory to the path searched for included makefiles bracketed 2103 * by double-quotes. 2104 */ 2105 void 2106 Parse_AddIncludeDir(const char *dir) 2107 { 2108 (void)SearchPath_Add(parseIncPath, dir); 2109 } 2110 2111 /* 2112 * Handle one of the .[-ds]include directives by remembering the current file 2113 * and pushing the included file on the stack. After the included file has 2114 * finished, parsing continues with the including file; see Parse_SetInput 2115 * and ParseEOF. 2116 * 2117 * System includes are looked up in sysIncPath, any other includes are looked 2118 * up in the parsedir and then in the directories specified by the -I command 2119 * line options. 2120 */ 2121 static void 2122 IncludeFile(char *file, Boolean isSystem, Boolean depinc, Boolean silent) 2123 { 2124 struct loadedfile *lf; 2125 char *fullname; /* full pathname of file */ 2126 char *newName; 2127 char *slash, *incdir; 2128 int fd; 2129 int i; 2130 2131 fullname = file[0] == '/' ? bmake_strdup(file) : NULL; 2132 2133 if (fullname == NULL && !isSystem) { 2134 /* 2135 * Include files contained in double-quotes are first searched 2136 * relative to the including file's location. We don't want to 2137 * cd there, of course, so we just tack on the old file's 2138 * leading path components and call Dir_FindFile to see if 2139 * we can locate the file. 2140 */ 2141 2142 incdir = bmake_strdup(CurFile()->fname); 2143 slash = strrchr(incdir, '/'); 2144 if (slash != NULL) { 2145 *slash = '\0'; 2146 /* 2147 * Now do lexical processing of leading "../" on the 2148 * filename. 2149 */ 2150 for (i = 0; strncmp(file + i, "../", 3) == 0; i += 3) { 2151 slash = strrchr(incdir + 1, '/'); 2152 if (slash == NULL || strcmp(slash, "/..") == 0) 2153 break; 2154 *slash = '\0'; 2155 } 2156 newName = str_concat3(incdir, "/", file + i); 2157 fullname = Dir_FindFile(newName, parseIncPath); 2158 if (fullname == NULL) 2159 fullname = Dir_FindFile(newName, 2160 &dirSearchPath); 2161 free(newName); 2162 } 2163 free(incdir); 2164 2165 if (fullname == NULL) { 2166 /* 2167 * Makefile wasn't found in same directory as included 2168 * makefile. 2169 * 2170 * Search for it first on the -I search path, then on 2171 * the .PATH search path, if not found in a -I 2172 * directory. If we have a suffix-specific path, we 2173 * should use that. 2174 */ 2175 const char *suff; 2176 SearchPath *suffPath = NULL; 2177 2178 if ((suff = strrchr(file, '.')) != NULL) { 2179 suffPath = Suff_GetPath(suff); 2180 if (suffPath != NULL) 2181 fullname = Dir_FindFile(file, suffPath); 2182 } 2183 if (fullname == NULL) { 2184 fullname = Dir_FindFile(file, parseIncPath); 2185 if (fullname == NULL) 2186 fullname = Dir_FindFile(file, 2187 &dirSearchPath); 2188 } 2189 } 2190 } 2191 2192 /* Looking for a system file or file still not found */ 2193 if (fullname == NULL) { 2194 /* 2195 * Look for it on the system path 2196 */ 2197 SearchPath *path = Lst_IsEmpty(&sysIncPath->dirs) 2198 ? defSysIncPath : sysIncPath; 2199 fullname = Dir_FindFile(file, path); 2200 } 2201 2202 if (fullname == NULL) { 2203 if (!silent) 2204 Parse_Error(PARSE_FATAL, "Could not find %s", file); 2205 return; 2206 } 2207 2208 /* Actually open the file... */ 2209 fd = open(fullname, O_RDONLY); 2210 if (fd == -1) { 2211 if (!silent) 2212 Parse_Error(PARSE_FATAL, "Cannot open %s", fullname); 2213 free(fullname); 2214 return; 2215 } 2216 2217 /* load it */ 2218 lf = loadfile(fullname, fd); 2219 2220 /* Start reading from this file next */ 2221 Parse_SetInput(fullname, 0, -1, loadedfile_readMore, lf); 2222 CurFile()->lf = lf; 2223 if (depinc) 2224 doing_depend = depinc; /* only turn it on */ 2225 } 2226 2227 static void 2228 ParseDoInclude(char *directive) 2229 { 2230 char endc; /* the character which ends the file spec */ 2231 char *cp; /* current position in file spec */ 2232 Boolean silent = directive[0] != 'i'; 2233 char *file = directive + (silent ? 8 : 7); 2234 2235 /* Skip to delimiter character so we know where to look */ 2236 pp_skip_hspace(&file); 2237 2238 if (*file != '"' && *file != '<') { 2239 Parse_Error(PARSE_FATAL, 2240 ".include filename must be delimited by '\"' or '<'"); 2241 return; 2242 } 2243 2244 /* 2245 * Set the search path on which to find the include file based on the 2246 * characters which bracket its name. Angle-brackets imply it's 2247 * a system Makefile while double-quotes imply it's a user makefile 2248 */ 2249 if (*file == '<') 2250 endc = '>'; 2251 else 2252 endc = '"'; 2253 2254 /* Skip to matching delimiter */ 2255 for (cp = ++file; *cp != '\0' && *cp != endc; cp++) 2256 continue; 2257 2258 if (*cp != endc) { 2259 Parse_Error(PARSE_FATAL, 2260 "Unclosed .include filename. '%c' expected", endc); 2261 return; 2262 } 2263 2264 *cp = '\0'; 2265 2266 /* 2267 * Substitute for any variables in the filename before trying to 2268 * find the file. 2269 */ 2270 (void)Var_Subst(file, SCOPE_CMDLINE, VARE_WANTRES, &file); 2271 /* TODO: handle errors */ 2272 2273 IncludeFile(file, endc == '>', directive[0] == 'd', silent); 2274 free(file); 2275 } 2276 2277 /* 2278 * Split filename into dirname + basename, then assign these to the 2279 * given variables. 2280 */ 2281 static void 2282 SetFilenameVars(const char *filename, const char *dirvar, const char *filevar) 2283 { 2284 const char *slash, *basename; 2285 FStr dirname; 2286 2287 slash = strrchr(filename, '/'); 2288 if (slash == NULL) { 2289 dirname = FStr_InitRefer(curdir); 2290 basename = filename; 2291 } else { 2292 dirname = FStr_InitOwn(bmake_strsedup(filename, slash)); 2293 basename = slash + 1; 2294 } 2295 2296 Global_SetExpand(dirvar, dirname.str); 2297 Global_SetExpand(filevar, basename); 2298 2299 DEBUG5(PARSE, "%s: ${%s} = `%s' ${%s} = `%s'\n", 2300 __func__, dirvar, dirname.str, filevar, basename); 2301 FStr_Done(&dirname); 2302 } 2303 2304 /* 2305 * Return the immediately including file. 2306 * 2307 * This is made complicated since the .for loop is implemented as a special 2308 * kind of .include; see For_Run. 2309 */ 2310 static const char * 2311 GetActuallyIncludingFile(void) 2312 { 2313 size_t i; 2314 const IFile *incs = GetInclude(0); 2315 2316 for (i = includes.len; i >= 2; i--) 2317 if (!incs[i - 1].fromForLoop) 2318 return incs[i - 2].fname; 2319 return NULL; 2320 } 2321 2322 /* Set .PARSEDIR, .PARSEFILE, .INCLUDEDFROMDIR and .INCLUDEDFROMFILE. */ 2323 static void 2324 ParseSetParseFile(const char *filename) 2325 { 2326 const char *including; 2327 2328 SetFilenameVars(filename, ".PARSEDIR", ".PARSEFILE"); 2329 2330 including = GetActuallyIncludingFile(); 2331 if (including != NULL) { 2332 SetFilenameVars(including, 2333 ".INCLUDEDFROMDIR", ".INCLUDEDFROMFILE"); 2334 } else { 2335 Global_Delete(".INCLUDEDFROMDIR"); 2336 Global_Delete(".INCLUDEDFROMFILE"); 2337 } 2338 } 2339 2340 static Boolean 2341 StrContainsWord(const char *str, const char *word) 2342 { 2343 size_t strLen = strlen(str); 2344 size_t wordLen = strlen(word); 2345 const char *p, *end; 2346 2347 if (strLen < wordLen) 2348 return FALSE; /* str is too short to contain word */ 2349 2350 end = str + strLen - wordLen; 2351 for (p = str; p != NULL; p = strchr(p, ' ')) { 2352 if (*p == ' ') 2353 p++; 2354 if (p > end) 2355 return FALSE; /* cannot contain word */ 2356 2357 if (memcmp(p, word, wordLen) == 0 && 2358 (p[wordLen] == '\0' || p[wordLen] == ' ')) 2359 return TRUE; 2360 } 2361 return FALSE; 2362 } 2363 2364 /* 2365 * XXX: Searching through a set of words with this linear search is 2366 * inefficient for variables that contain thousands of words. 2367 * 2368 * XXX: The paths in this list don't seem to be normalized in any way. 2369 */ 2370 static Boolean 2371 VarContainsWord(const char *varname, const char *word) 2372 { 2373 FStr val = Var_Value(SCOPE_GLOBAL, varname); 2374 Boolean found = val.str != NULL && StrContainsWord(val.str, word); 2375 FStr_Done(&val); 2376 return found; 2377 } 2378 2379 /* 2380 * Track the makefiles we read - so makefiles can set dependencies on them. 2381 * Avoid adding anything more than once. 2382 * 2383 * Time complexity: O(n) per call, in total O(n^2), where n is the number 2384 * of makefiles that have been loaded. 2385 */ 2386 static void 2387 ParseTrackInput(const char *name) 2388 { 2389 if (!VarContainsWord(MAKE_MAKEFILES, name)) 2390 Global_Append(MAKE_MAKEFILES, name); 2391 } 2392 2393 2394 /* 2395 * Start parsing from the given source. 2396 * 2397 * The given file is added to the includes stack. 2398 */ 2399 void 2400 Parse_SetInput(const char *name, int lineno, int fd, 2401 ReadMoreProc readMore, void *readMoreArg) 2402 { 2403 IFile *curFile; 2404 char *buf; 2405 size_t len; 2406 Boolean fromForLoop = name == NULL; 2407 2408 if (fromForLoop) 2409 name = CurFile()->fname; 2410 else 2411 ParseTrackInput(name); 2412 2413 DEBUG3(PARSE, "Parse_SetInput: %s %s, line %d\n", 2414 readMore == loadedfile_readMore ? "file" : ".for loop in", 2415 name, lineno); 2416 2417 if (fd == -1 && readMore == NULL) 2418 /* sanity */ 2419 return; 2420 2421 curFile = Vector_Push(&includes); 2422 curFile->fname = bmake_strdup(name); 2423 curFile->fromForLoop = fromForLoop; 2424 curFile->lineno = lineno; 2425 curFile->first_lineno = lineno; 2426 curFile->readMore = readMore; 2427 curFile->readMoreArg = readMoreArg; 2428 curFile->lf = NULL; 2429 curFile->depending = doing_depend; /* restore this on EOF */ 2430 2431 assert(readMore != NULL); 2432 2433 /* Get first block of input data */ 2434 buf = curFile->readMore(curFile->readMoreArg, &len); 2435 if (buf == NULL) { 2436 /* Was all a waste of time ... */ 2437 if (curFile->fname != NULL) 2438 free(curFile->fname); 2439 free(curFile); 2440 return; 2441 } 2442 curFile->buf_freeIt = buf; 2443 curFile->buf_ptr = buf; 2444 curFile->buf_end = buf + len; 2445 2446 curFile->cond_depth = Cond_save_depth(); 2447 ParseSetParseFile(name); 2448 } 2449 2450 /* Check if the directive is an include directive. */ 2451 static Boolean 2452 IsInclude(const char *dir, Boolean sysv) 2453 { 2454 if (dir[0] == 's' || dir[0] == '-' || (dir[0] == 'd' && !sysv)) 2455 dir++; 2456 2457 if (strncmp(dir, "include", 7) != 0) 2458 return FALSE; 2459 2460 /* Space is not mandatory for BSD .include */ 2461 return !sysv || ch_isspace(dir[7]); 2462 } 2463 2464 2465 #ifdef SYSVINCLUDE 2466 /* Check if the line is a SYSV include directive. */ 2467 static Boolean 2468 IsSysVInclude(const char *line) 2469 { 2470 const char *p; 2471 2472 if (!IsInclude(line, TRUE)) 2473 return FALSE; 2474 2475 /* Avoid interpreting a dependency line as an include */ 2476 for (p = line; (p = strchr(p, ':')) != NULL;) { 2477 2478 /* end of line -> it's a dependency */ 2479 if (*++p == '\0') 2480 return FALSE; 2481 2482 /* '::' operator or ': ' -> it's a dependency */ 2483 if (*p == ':' || ch_isspace(*p)) 2484 return FALSE; 2485 } 2486 return TRUE; 2487 } 2488 2489 /* Push to another file. The line points to the word "include". */ 2490 static void 2491 ParseTraditionalInclude(char *line) 2492 { 2493 char *cp; /* current position in file spec */ 2494 Boolean done = FALSE; 2495 Boolean silent = line[0] != 'i'; 2496 char *file = line + (silent ? 8 : 7); 2497 char *all_files; 2498 2499 DEBUG2(PARSE, "%s: %s\n", __func__, file); 2500 2501 pp_skip_whitespace(&file); 2502 2503 /* 2504 * Substitute for any variables in the file name before trying to 2505 * find the thing. 2506 */ 2507 (void)Var_Subst(file, SCOPE_CMDLINE, VARE_WANTRES, &all_files); 2508 /* TODO: handle errors */ 2509 2510 if (*file == '\0') { 2511 Parse_Error(PARSE_FATAL, "Filename missing from \"include\""); 2512 goto out; 2513 } 2514 2515 for (file = all_files; !done; file = cp + 1) { 2516 /* Skip to end of line or next whitespace */ 2517 for (cp = file; *cp != '\0' && !ch_isspace(*cp); cp++) 2518 continue; 2519 2520 if (*cp != '\0') 2521 *cp = '\0'; 2522 else 2523 done = TRUE; 2524 2525 IncludeFile(file, FALSE, FALSE, silent); 2526 } 2527 out: 2528 free(all_files); 2529 } 2530 #endif 2531 2532 #ifdef GMAKEEXPORT 2533 /* Parse "export <variable>=<value>", and actually export it. */ 2534 static void 2535 ParseGmakeExport(char *line) 2536 { 2537 char *variable = line + 6; 2538 char *value; 2539 2540 DEBUG2(PARSE, "%s: %s\n", __func__, variable); 2541 2542 pp_skip_whitespace(&variable); 2543 2544 for (value = variable; *value != '\0' && *value != '='; value++) 2545 continue; 2546 2547 if (*value != '=') { 2548 Parse_Error(PARSE_FATAL, 2549 "Variable/Value missing from \"export\""); 2550 return; 2551 } 2552 *value++ = '\0'; /* terminate variable */ 2553 2554 /* 2555 * Expand the value before putting it in the environment. 2556 */ 2557 (void)Var_Subst(value, SCOPE_CMDLINE, VARE_WANTRES, &value); 2558 /* TODO: handle errors */ 2559 2560 setenv(variable, value, 1); 2561 free(value); 2562 } 2563 #endif 2564 2565 /* 2566 * Called when EOF is reached in the current file. If we were reading an 2567 * include file or a .for loop, the includes stack is popped and things set 2568 * up to go back to reading the previous file at the previous location. 2569 * 2570 * Results: 2571 * TRUE to continue parsing, i.e. it had only reached the end of an 2572 * included file, FALSE if the main file has been parsed completely. 2573 */ 2574 static Boolean 2575 ParseEOF(void) 2576 { 2577 char *ptr; 2578 size_t len; 2579 IFile *curFile = CurFile(); 2580 2581 assert(curFile->readMore != NULL); 2582 2583 doing_depend = curFile->depending; /* restore this */ 2584 /* get next input buffer, if any */ 2585 ptr = curFile->readMore(curFile->readMoreArg, &len); 2586 curFile->buf_ptr = ptr; 2587 curFile->buf_freeIt = ptr; 2588 curFile->buf_end = ptr == NULL ? NULL : ptr + len; 2589 curFile->lineno = curFile->first_lineno; 2590 if (ptr != NULL) 2591 return TRUE; /* Iterate again */ 2592 2593 /* Ensure the makefile (or loop) didn't have mismatched conditionals */ 2594 Cond_restore_depth(curFile->cond_depth); 2595 2596 if (curFile->lf != NULL) { 2597 loadedfile_destroy(curFile->lf); 2598 curFile->lf = NULL; 2599 } 2600 2601 /* Dispose of curFile info */ 2602 /* Leak curFile->fname because all the GNodes have pointers to it. */ 2603 free(curFile->buf_freeIt); 2604 Vector_Pop(&includes); 2605 2606 if (includes.len == 0) { 2607 /* We've run out of input */ 2608 Global_Delete(".PARSEDIR"); 2609 Global_Delete(".PARSEFILE"); 2610 Global_Delete(".INCLUDEDFROMDIR"); 2611 Global_Delete(".INCLUDEDFROMFILE"); 2612 return FALSE; 2613 } 2614 2615 curFile = CurFile(); 2616 DEBUG2(PARSE, "ParseEOF: returning to file %s, line %d\n", 2617 curFile->fname, curFile->lineno); 2618 2619 ParseSetParseFile(curFile->fname); 2620 return TRUE; 2621 } 2622 2623 typedef enum ParseRawLineResult { 2624 PRLR_LINE, 2625 PRLR_EOF, 2626 PRLR_ERROR 2627 } ParseRawLineResult; 2628 2629 /* 2630 * Parse until the end of a line, taking into account lines that end with 2631 * backslash-newline. 2632 */ 2633 static ParseRawLineResult 2634 ParseRawLine(IFile *curFile, char **out_line, char **out_line_end, 2635 char **out_firstBackslash, char **out_firstComment) 2636 { 2637 char *line = curFile->buf_ptr; 2638 char *p = line; 2639 char *line_end = line; 2640 char *firstBackslash = NULL; 2641 char *firstComment = NULL; 2642 ParseRawLineResult res = PRLR_LINE; 2643 2644 curFile->lineno++; 2645 2646 for (;;) { 2647 char ch; 2648 2649 if (p == curFile->buf_end) { 2650 res = PRLR_EOF; 2651 break; 2652 } 2653 2654 ch = *p; 2655 if (ch == '\0' || 2656 (ch == '\\' && p + 1 < curFile->buf_end && p[1] == '\0')) { 2657 Parse_Error(PARSE_FATAL, "Zero byte read from file"); 2658 return PRLR_ERROR; 2659 } 2660 2661 /* Treat next character after '\' as literal. */ 2662 if (ch == '\\') { 2663 if (firstBackslash == NULL) 2664 firstBackslash = p; 2665 if (p[1] == '\n') { 2666 curFile->lineno++; 2667 if (p + 2 == curFile->buf_end) { 2668 line_end = p; 2669 *line_end = '\n'; 2670 p += 2; 2671 continue; 2672 } 2673 } 2674 p += 2; 2675 line_end = p; 2676 assert(p <= curFile->buf_end); 2677 continue; 2678 } 2679 2680 /* 2681 * Remember the first '#' for comment stripping, unless 2682 * the previous char was '[', as in the modifier ':[#]'. 2683 */ 2684 if (ch == '#' && firstComment == NULL && 2685 !(p > line && p[-1] == '[')) 2686 firstComment = line_end; 2687 2688 p++; 2689 if (ch == '\n') 2690 break; 2691 2692 /* We are not interested in trailing whitespace. */ 2693 if (!ch_isspace(ch)) 2694 line_end = p; 2695 } 2696 2697 *out_line = line; 2698 curFile->buf_ptr = p; 2699 *out_line_end = line_end; 2700 *out_firstBackslash = firstBackslash; 2701 *out_firstComment = firstComment; 2702 return res; 2703 } 2704 2705 /* 2706 * Beginning at start, unescape '\#' to '#' and replace backslash-newline 2707 * with a single space. 2708 */ 2709 static void 2710 UnescapeBackslash(char *line, char *start) 2711 { 2712 char *src = start; 2713 char *dst = start; 2714 char *spaceStart = line; 2715 2716 for (;;) { 2717 char ch = *src++; 2718 if (ch != '\\') { 2719 if (ch == '\0') 2720 break; 2721 *dst++ = ch; 2722 continue; 2723 } 2724 2725 ch = *src++; 2726 if (ch == '\0') { 2727 /* Delete '\\' at end of buffer */ 2728 dst--; 2729 break; 2730 } 2731 2732 /* Delete '\\' from before '#' on non-command lines */ 2733 if (ch == '#' && line[0] != '\t') { 2734 *dst++ = ch; 2735 continue; 2736 } 2737 2738 if (ch != '\n') { 2739 /* Leave '\\' in buffer for later */ 2740 *dst++ = '\\'; 2741 /* 2742 * Make sure we don't delete an escaped ' ' from the 2743 * line end. 2744 */ 2745 spaceStart = dst + 1; 2746 *dst++ = ch; 2747 continue; 2748 } 2749 2750 /* 2751 * Escaped '\n' -- replace following whitespace with a single 2752 * ' '. 2753 */ 2754 pp_skip_hspace(&src); 2755 *dst++ = ' '; 2756 } 2757 2758 /* Delete any trailing spaces - eg from empty continuations */ 2759 while (dst > spaceStart && ch_isspace(dst[-1])) 2760 dst--; 2761 *dst = '\0'; 2762 } 2763 2764 typedef enum GetLineMode { 2765 /* 2766 * Return the next line that is neither empty nor a comment. 2767 * Backslash line continuations are folded into a single space. 2768 * A trailing comment, if any, is discarded. 2769 */ 2770 GLM_NONEMPTY, 2771 2772 /* 2773 * Return the next line, even if it is empty or a comment. 2774 * Preserve backslash-newline to keep the line numbers correct. 2775 * 2776 * Used in .for loops to collect the body of the loop while waiting 2777 * for the corresponding .endfor. 2778 */ 2779 GLM_FOR_BODY, 2780 2781 /* 2782 * Return the next line that starts with a dot. 2783 * Backslash line continuations are folded into a single space. 2784 * A trailing comment, if any, is discarded. 2785 * 2786 * Used in .if directives to skip over irrelevant branches while 2787 * waiting for the corresponding .endif. 2788 */ 2789 GLM_DOT 2790 } GetLineMode; 2791 2792 /* Return the next "interesting" logical line from the current file. */ 2793 static char * 2794 ParseGetLine(GetLineMode mode) 2795 { 2796 IFile *curFile = CurFile(); 2797 char *line; 2798 char *line_end; 2799 char *firstBackslash; 2800 char *firstComment; 2801 2802 for (;;) { 2803 ParseRawLineResult res = ParseRawLine(curFile, 2804 &line, &line_end, &firstBackslash, &firstComment); 2805 if (res == PRLR_ERROR) 2806 return NULL; 2807 2808 if (line_end == line || firstComment == line) { 2809 if (res == PRLR_EOF) 2810 return NULL; 2811 if (mode != GLM_FOR_BODY) 2812 continue; 2813 } 2814 2815 /* We now have a line of data */ 2816 assert(ch_isspace(*line_end)); 2817 *line_end = '\0'; 2818 2819 if (mode == GLM_FOR_BODY) 2820 return line; /* Don't join the physical lines. */ 2821 2822 if (mode == GLM_DOT && line[0] != '.') 2823 continue; 2824 break; 2825 } 2826 2827 /* Brutally ignore anything after a non-escaped '#' in non-commands. */ 2828 if (firstComment != NULL && line[0] != '\t') 2829 *firstComment = '\0'; 2830 2831 /* If we didn't see a '\\' then the in-situ data is fine. */ 2832 if (firstBackslash == NULL) 2833 return line; 2834 2835 /* Remove escapes from '\n' and '#' */ 2836 UnescapeBackslash(line, firstBackslash); 2837 2838 return line; 2839 } 2840 2841 static Boolean 2842 ParseSkippedBranches(void) 2843 { 2844 char *line; 2845 2846 while ((line = ParseGetLine(GLM_DOT)) != NULL) { 2847 if (Cond_EvalLine(line) == COND_PARSE) 2848 break; 2849 /* 2850 * TODO: Check for typos in .elif directives 2851 * such as .elsif or .elseif. 2852 * 2853 * This check will probably duplicate some of 2854 * the code in ParseLine. Most of the code 2855 * there cannot apply, only ParseVarassign and 2856 * ParseDependency can, and to prevent code 2857 * duplication, these would need to be called 2858 * with a flag called onlyCheckSyntax. 2859 * 2860 * See directive-elif.mk for details. 2861 */ 2862 } 2863 2864 return line != NULL; 2865 } 2866 2867 static Boolean 2868 ParseForLoop(const char *line) 2869 { 2870 int rval; 2871 int firstLineno; 2872 2873 rval = For_Eval(line); 2874 if (rval == 0) 2875 return FALSE; /* Not a .for line */ 2876 if (rval < 0) 2877 return TRUE; /* Syntax error - error printed, ignore line */ 2878 2879 firstLineno = CurFile()->lineno; 2880 2881 /* Accumulate loop lines until matching .endfor */ 2882 do { 2883 line = ParseGetLine(GLM_FOR_BODY); 2884 if (line == NULL) { 2885 Parse_Error(PARSE_FATAL, 2886 "Unexpected end of file in for loop."); 2887 break; 2888 } 2889 } while (For_Accum(line)); 2890 2891 For_Run(firstLineno); /* Stash each iteration as a new 'input file' */ 2892 2893 return TRUE; /* Read next line from for-loop buffer */ 2894 } 2895 2896 /* 2897 * Read an entire line from the input file. 2898 * 2899 * Empty lines, .if and .for are completely handled by this function, 2900 * leaving only variable assignments, other directives, dependency lines 2901 * and shell commands to the caller. 2902 * 2903 * Results: 2904 * A line without its newline and without any trailing whitespace, 2905 * or NULL. 2906 */ 2907 static char * 2908 ParseReadLine(void) 2909 { 2910 char *line; 2911 2912 for (;;) { 2913 line = ParseGetLine(GLM_NONEMPTY); 2914 if (line == NULL) 2915 return NULL; 2916 2917 if (line[0] != '.') 2918 return line; 2919 2920 /* 2921 * The line might be a conditional. Ask the conditional module 2922 * about it and act accordingly 2923 */ 2924 switch (Cond_EvalLine(line)) { 2925 case COND_SKIP: 2926 if (!ParseSkippedBranches()) 2927 return NULL; 2928 continue; 2929 case COND_PARSE: 2930 continue; 2931 case COND_INVALID: /* Not a conditional line */ 2932 if (ParseForLoop(line)) 2933 continue; 2934 break; 2935 } 2936 return line; 2937 } 2938 } 2939 2940 static void 2941 FinishDependencyGroup(void) 2942 { 2943 GNodeListNode *ln; 2944 2945 if (targets == NULL) 2946 return; 2947 2948 for (ln = targets->first; ln != NULL; ln = ln->next) { 2949 GNode *gn = ln->datum; 2950 2951 Suff_EndTransform(gn); 2952 2953 /* 2954 * Mark the target as already having commands if it does, to 2955 * keep from having shell commands on multiple dependency 2956 * lines. 2957 */ 2958 if (!Lst_IsEmpty(&gn->commands)) 2959 gn->type |= OP_HAS_COMMANDS; 2960 } 2961 2962 Lst_Free(targets); 2963 targets = NULL; 2964 } 2965 2966 /* Add the command to each target from the current dependency spec. */ 2967 static void 2968 ParseLine_ShellCommand(const char *p) 2969 { 2970 cpp_skip_whitespace(&p); 2971 if (*p == '\0') 2972 return; /* skip empty commands */ 2973 2974 if (targets == NULL) { 2975 Parse_Error(PARSE_FATAL, 2976 "Unassociated shell command \"%s\"", p); 2977 return; 2978 } 2979 2980 { 2981 char *cmd = bmake_strdup(p); 2982 GNodeListNode *ln; 2983 2984 for (ln = targets->first; ln != NULL; ln = ln->next) { 2985 GNode *gn = ln->datum; 2986 ParseAddCmd(gn, cmd); 2987 } 2988 #ifdef CLEANUP 2989 Lst_Append(&targCmds, cmd); 2990 #endif 2991 } 2992 } 2993 2994 MAKE_INLINE Boolean 2995 IsDirective(const char *dir, size_t dirlen, const char *name) 2996 { 2997 return dirlen == strlen(name) && memcmp(dir, name, dirlen) == 0; 2998 } 2999 3000 /* 3001 * See if the line starts with one of the known directives, and if so, handle 3002 * the directive. 3003 */ 3004 static Boolean 3005 ParseDirective(char *line) 3006 { 3007 char *cp = line + 1; 3008 const char *dir, *arg; 3009 size_t dirlen; 3010 3011 pp_skip_whitespace(&cp); 3012 if (IsInclude(cp, FALSE)) { 3013 ParseDoInclude(cp); 3014 return TRUE; 3015 } 3016 3017 dir = cp; 3018 while (ch_isalpha(*cp) || *cp == '-') 3019 cp++; 3020 dirlen = (size_t)(cp - dir); 3021 3022 if (*cp != '\0' && !ch_isspace(*cp)) 3023 return FALSE; 3024 3025 pp_skip_whitespace(&cp); 3026 arg = cp; 3027 3028 if (IsDirective(dir, dirlen, "undef")) { 3029 Var_Undef(cp); 3030 return TRUE; 3031 } else if (IsDirective(dir, dirlen, "export")) { 3032 Var_Export(VEM_PLAIN, arg); 3033 return TRUE; 3034 } else if (IsDirective(dir, dirlen, "export-env")) { 3035 Var_Export(VEM_ENV, arg); 3036 return TRUE; 3037 } else if (IsDirective(dir, dirlen, "export-literal")) { 3038 Var_Export(VEM_LITERAL, arg); 3039 return TRUE; 3040 } else if (IsDirective(dir, dirlen, "unexport")) { 3041 Var_UnExport(FALSE, arg); 3042 return TRUE; 3043 } else if (IsDirective(dir, dirlen, "unexport-env")) { 3044 Var_UnExport(TRUE, arg); 3045 return TRUE; 3046 } else if (IsDirective(dir, dirlen, "info")) { 3047 ParseMessage(PARSE_INFO, "info", arg); 3048 return TRUE; 3049 } else if (IsDirective(dir, dirlen, "warning")) { 3050 ParseMessage(PARSE_WARNING, "warning", arg); 3051 return TRUE; 3052 } else if (IsDirective(dir, dirlen, "error")) { 3053 ParseMessage(PARSE_FATAL, "error", arg); 3054 return TRUE; 3055 } 3056 return FALSE; 3057 } 3058 3059 static Boolean 3060 ParseVarassign(const char *line) 3061 { 3062 VarAssign var; 3063 3064 if (!Parse_IsVar(line, &var)) 3065 return FALSE; 3066 3067 FinishDependencyGroup(); 3068 Parse_DoVar(&var, SCOPE_GLOBAL); 3069 return TRUE; 3070 } 3071 3072 static char * 3073 FindSemicolon(char *p) 3074 { 3075 int level = 0; 3076 3077 for (; *p != '\0'; p++) { 3078 if (*p == '\\' && p[1] != '\0') { 3079 p++; 3080 continue; 3081 } 3082 3083 if (*p == '$' && (p[1] == '(' || p[1] == '{')) 3084 level++; 3085 else if (level > 0 && (*p == ')' || *p == '}')) 3086 level--; 3087 else if (level == 0 && *p == ';') 3088 break; 3089 } 3090 return p; 3091 } 3092 3093 /* 3094 * dependency -> target... op [source...] 3095 * op -> ':' | '::' | '!' 3096 */ 3097 static void 3098 ParseDependency(char *line) 3099 { 3100 VarEvalFlags eflags; 3101 char *expanded_line; 3102 const char *shellcmd = NULL; 3103 3104 /* 3105 * For some reason - probably to make the parser impossible - 3106 * a ';' can be used to separate commands from dependencies. 3107 * Attempt to avoid ';' inside substitution patterns. 3108 */ 3109 { 3110 char *semicolon = FindSemicolon(line); 3111 if (*semicolon != '\0') { 3112 /* Terminate the dependency list at the ';' */ 3113 *semicolon = '\0'; 3114 shellcmd = semicolon + 1; 3115 } 3116 } 3117 3118 /* 3119 * We now know it's a dependency line so it needs to have all 3120 * variables expanded before being parsed. 3121 * 3122 * XXX: Ideally the dependency line would first be split into 3123 * its left-hand side, dependency operator and right-hand side, 3124 * and then each side would be expanded on its own. This would 3125 * allow for the left-hand side to allow only defined variables 3126 * and to allow variables on the right-hand side to be undefined 3127 * as well. 3128 * 3129 * Parsing the line first would also prevent that targets 3130 * generated from variable expressions are interpreted as the 3131 * dependency operator, such as in "target${:U\:} middle: source", 3132 * in which the middle is interpreted as a source, not a target. 3133 */ 3134 3135 /* In lint mode, allow undefined variables to appear in 3136 * dependency lines. 3137 * 3138 * Ideally, only the right-hand side would allow undefined 3139 * variables since it is common to have optional dependencies. 3140 * Having undefined variables on the left-hand side is more 3141 * unusual though. Since both sides are expanded in a single 3142 * pass, there is not much choice what to do here. 3143 * 3144 * In normal mode, it does not matter whether undefined 3145 * variables are allowed or not since as of 2020-09-14, 3146 * Var_Parse does not print any parse errors in such a case. 3147 * It simply returns the special empty string var_Error, 3148 * which cannot be detected in the result of Var_Subst. */ 3149 eflags = opts.strict ? VARE_WANTRES : VARE_WANTRES | VARE_UNDEFERR; 3150 (void)Var_Subst(line, SCOPE_CMDLINE, eflags, &expanded_line); 3151 /* TODO: handle errors */ 3152 3153 /* Need a fresh list for the target nodes */ 3154 if (targets != NULL) 3155 Lst_Free(targets); 3156 targets = Lst_New(); 3157 3158 ParseDoDependency(expanded_line); 3159 free(expanded_line); 3160 3161 if (shellcmd != NULL) 3162 ParseLine_ShellCommand(shellcmd); 3163 } 3164 3165 static void 3166 ParseLine(char *line) 3167 { 3168 /* 3169 * Lines that begin with '.' can be pretty much anything: 3170 * - directives like '.include' or '.if', 3171 * - suffix rules like '.c.o:', 3172 * - dependencies for filenames that start with '.', 3173 * - variable assignments like '.tmp=value'. 3174 */ 3175 if (line[0] == '.' && ParseDirective(line)) 3176 return; 3177 3178 if (line[0] == '\t') { 3179 ParseLine_ShellCommand(line + 1); 3180 return; 3181 } 3182 3183 #ifdef SYSVINCLUDE 3184 if (IsSysVInclude(line)) { 3185 /* 3186 * It's an S3/S5-style "include". 3187 */ 3188 ParseTraditionalInclude(line); 3189 return; 3190 } 3191 #endif 3192 3193 #ifdef GMAKEEXPORT 3194 if (strncmp(line, "export", 6) == 0 && ch_isspace(line[6]) && 3195 strchr(line, ':') == NULL) { 3196 /* 3197 * It's a Gmake "export". 3198 */ 3199 ParseGmakeExport(line); 3200 return; 3201 } 3202 #endif 3203 3204 if (ParseVarassign(line)) 3205 return; 3206 3207 FinishDependencyGroup(); 3208 3209 ParseDependency(line); 3210 } 3211 3212 /* 3213 * Parse a top-level makefile, incorporating its content into the global 3214 * dependency graph. 3215 * 3216 * Input: 3217 * name The name of the file being read 3218 * fd The open file to parse; will be closed at the end 3219 */ 3220 void 3221 Parse_File(const char *name, int fd) 3222 { 3223 char *line; /* the line we're working on */ 3224 struct loadedfile *lf; 3225 3226 lf = loadfile(name, fd); 3227 3228 assert(targets == NULL); 3229 3230 if (name == NULL) 3231 name = "(stdin)"; 3232 3233 Parse_SetInput(name, 0, -1, loadedfile_readMore, lf); 3234 CurFile()->lf = lf; 3235 3236 do { 3237 while ((line = ParseReadLine()) != NULL) { 3238 DEBUG2(PARSE, "ParseReadLine (%d): '%s'\n", 3239 CurFile()->lineno, line); 3240 ParseLine(line); 3241 } 3242 /* Reached EOF, but it may be just EOF of an include file. */ 3243 } while (ParseEOF()); 3244 3245 FinishDependencyGroup(); 3246 3247 if (fatals != 0) { 3248 (void)fflush(stdout); 3249 (void)fprintf(stderr, 3250 "%s: Fatal errors encountered -- cannot continue", 3251 progname); 3252 PrintOnError(NULL, NULL); 3253 exit(1); 3254 } 3255 } 3256 3257 /* Initialize the parsing module. */ 3258 void 3259 Parse_Init(void) 3260 { 3261 mainNode = NULL; 3262 parseIncPath = SearchPath_New(); 3263 sysIncPath = SearchPath_New(); 3264 defSysIncPath = SearchPath_New(); 3265 Vector_Init(&includes, sizeof(IFile)); 3266 } 3267 3268 /* Clean up the parsing module. */ 3269 void 3270 Parse_End(void) 3271 { 3272 #ifdef CLEANUP 3273 Lst_DoneCall(&targCmds, free); 3274 assert(targets == NULL); 3275 SearchPath_Free(defSysIncPath); 3276 SearchPath_Free(sysIncPath); 3277 SearchPath_Free(parseIncPath); 3278 assert(includes.len == 0); 3279 Vector_Done(&includes); 3280 #endif 3281 } 3282 3283 3284 /* 3285 * Return a list containing the single main target to create. 3286 * If no such target exists, we Punt with an obnoxious error message. 3287 */ 3288 void 3289 Parse_MainName(GNodeList *mainList) 3290 { 3291 if (mainNode == NULL) 3292 Punt("no target to make."); 3293 3294 Lst_Append(mainList, mainNode); 3295 if (mainNode->type & OP_DOUBLEDEP) 3296 Lst_AppendAll(mainList, &mainNode->cohorts); 3297 3298 Global_Append(".TARGETS", mainNode->name); 3299 } 3300 3301 int 3302 Parse_GetFatals(void) 3303 { 3304 return fatals; 3305 } 3306