1 /* $OpenBSD: parse.c,v 1.116 2016/05/13 12:18:11 espie Exp $ */ 2 /* $NetBSD: parse.c,v 1.29 1997/03/10 21:20:04 christos Exp $ */ 3 4 /* 5 * Copyright (c) 1999 Marc Espie. 6 * 7 * Extensive code changes for the OpenBSD project. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE OPENBSD PROJECT AND CONTRIBUTORS 19 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBSD 22 * PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 */ 30 /* 31 * Copyright (c) 1988, 1989, 1990, 1993 32 * The Regents of the University of California. All rights reserved. 33 * Copyright (c) 1989 by Berkeley Softworks 34 * All rights reserved. 35 * 36 * This code is derived from software contributed to Berkeley by 37 * Adam de Boor. 38 * 39 * Redistribution and use in source and binary forms, with or without 40 * modification, are permitted provided that the following conditions 41 * are met: 42 * 1. Redistributions of source code must retain the above copyright 43 * notice, this list of conditions and the following disclaimer. 44 * 2. Redistributions in binary form must reproduce the above copyright 45 * notice, this list of conditions and the following disclaimer in the 46 * documentation and/or other materials provided with the distribution. 47 * 3. Neither the name of the University nor the names of its contributors 48 * may be used to endorse or promote products derived from this software 49 * without specific prior written permission. 50 * 51 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 52 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 53 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 54 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 55 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 56 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 57 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 58 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 59 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 60 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 61 * SUCH DAMAGE. 62 */ 63 64 #include <assert.h> 65 #include <ctype.h> 66 #include <stddef.h> 67 #include <stdio.h> 68 #include <stdlib.h> 69 #include <string.h> 70 #include <ohash.h> 71 #include "config.h" 72 #include "defines.h" 73 #include "dir.h" 74 #include "direxpand.h" 75 #include "job.h" 76 #include "buf.h" 77 #include "for.h" 78 #include "lowparse.h" 79 #include "arch.h" 80 #include "cond.h" 81 #include "suff.h" 82 #include "parse.h" 83 #include "var.h" 84 #include "targ.h" 85 #include "error.h" 86 #include "str.h" 87 #include "main.h" 88 #include "gnode.h" 89 #include "memory.h" 90 #include "extern.h" 91 #include "lst.h" 92 #include "parsevar.h" 93 #include "stats.h" 94 #include "garray.h" 95 #include "node_int.h" 96 #include "nodehashconsts.h" 97 98 99 /* gsources and gtargets should be local to some functions, but they're 100 * set as persistent arrays for performance reasons. 101 */ 102 static struct growableArray gsources, gtargets; 103 static struct ohash htargets; 104 static bool htargets_setup = false; 105 #define SOURCES_SIZE 128 106 #define TARGETS_SIZE 32 107 108 static LIST theUserIncPath;/* list of directories for "..." includes */ 109 static LIST theSysIncPath; /* list of directories for <...> includes */ 110 Lst systemIncludePath = &theSysIncPath; 111 Lst userIncludePath = &theUserIncPath; 112 113 static GNode *mainNode; /* The main target to create. This is the 114 * first target on the first dependency 115 * line in the first makefile */ 116 /*- 117 * specType contains the special TYPE of the current target. It is 118 * SPECIAL_NONE if the target is unspecial. If it *is* special, however, 119 * the children are linked as children of the parent but not vice versa. 120 * This variable is set in ParseDoDependency 121 */ 122 123 static unsigned int specType; 124 static int waiting; 125 126 /* 127 * Predecessor node for handling .ORDER. Initialized to NULL when .ORDER 128 * seen, then set to each successive source on the line. 129 */ 130 static GNode *predecessor; 131 132 static void ParseLinkSrc(GNode *, GNode *); 133 static int ParseDoOp(GNode **, unsigned int); 134 static int ParseAddDep(GNode *, GNode *); 135 static void ParseDoSrc(struct growableArray *, struct growableArray *, int, 136 const char *, const char *); 137 static int ParseFindMain(void *, void *); 138 static void ParseClearPath(void *); 139 140 static void add_target_node(const char *, const char *); 141 static void add_target_nodes(const char *, const char *); 142 static void apply_op(struct growableArray *, unsigned int, GNode *); 143 static void ParseDoDependency(const char *); 144 static void ParseAddCmd(void *, void *); 145 static void ParseHasCommands(void *); 146 static bool handle_poison(const char *); 147 static bool handle_for_loop(Buffer, const char *); 148 static bool handle_undef(const char *); 149 #define ParseReadLoopLine(linebuf) Parse_ReadUnparsedLine(linebuf, "for loop") 150 static bool handle_bsd_command(Buffer, Buffer, const char *); 151 static char *strip_comments(Buffer, const char *); 152 static char *resolve_include_filename(const char *, const char *, bool); 153 static void handle_include_file(const char *, const char *, bool, bool); 154 static bool lookup_bsd_include(const char *); 155 static void lookup_sysv_style_include(const char *, const char *, bool); 156 static void lookup_sysv_include(const char *, const char *); 157 static void lookup_conditional_include(const char *, const char *); 158 static bool parse_as_special_line(Buffer, Buffer, const char *); 159 static unsigned int parse_operator(const char **); 160 161 static const char *parse_do_targets(Lst, unsigned int *, const char *); 162 static void parse_target_line(struct growableArray *, const char *, 163 const char *, bool *); 164 165 static void finish_commands(struct growableArray *); 166 static void parse_commands(struct growableArray *, const char *); 167 static void create_special_nodes(void); 168 static bool found_delimiter(const char *); 169 static unsigned int handle_special_targets(Lst); 170 static void dump_targets(void); 171 static void dedup_targets(struct growableArray *); 172 static void build_target_group(struct growableArray *, struct ohash *t); 173 static void reset_target_hash(void); 174 175 176 #define P(k) k, sizeof(k), K_##k 177 178 static struct { 179 const char *keyword; 180 size_t sz; 181 uint32_t hv; 182 unsigned int type; 183 unsigned int special_op; 184 } specials[] = { 185 { P(NODE_EXEC), SPECIAL_EXEC | SPECIAL_TARGETSOURCE, OP_EXEC, }, 186 { P(NODE_IGNORE), SPECIAL_IGNORE | SPECIAL_TARGETSOURCE, OP_IGNORE, }, 187 { P(NODE_INCLUDES), SPECIAL_NOTHING | SPECIAL_TARGET, 0, }, 188 { P(NODE_INVISIBLE),SPECIAL_INVISIBLE | SPECIAL_TARGETSOURCE,OP_INVISIBLE, }, 189 { P(NODE_JOIN), SPECIAL_JOIN | SPECIAL_TARGETSOURCE, OP_JOIN, }, 190 { P(NODE_LIBS), SPECIAL_NOTHING | SPECIAL_TARGET, 0, }, 191 { P(NODE_MADE), SPECIAL_MADE | SPECIAL_TARGETSOURCE, OP_MADE, }, 192 { P(NODE_MAIN), SPECIAL_MAIN | SPECIAL_TARGET, 0, }, 193 { P(NODE_MAKE), SPECIAL_MAKE | SPECIAL_TARGETSOURCE, OP_MAKE, }, 194 { P(NODE_MAKEFLAGS), SPECIAL_MFLAGS | SPECIAL_TARGET, 0, }, 195 { P(NODE_MFLAGS), SPECIAL_MFLAGS | SPECIAL_TARGET, 0, }, 196 { P(NODE_NOTMAIN), SPECIAL_NOTMAIN | SPECIAL_TARGETSOURCE, OP_NOTMAIN, }, 197 { P(NODE_NOTPARALLEL),SPECIAL_NOTPARALLEL | SPECIAL_TARGET, 0, }, 198 { P(NODE_NO_PARALLEL),SPECIAL_NOTPARALLEL | SPECIAL_TARGET, 0, }, 199 { P(NODE_NULL), SPECIAL_NOTHING | SPECIAL_TARGET, 0, }, 200 { P(NODE_OPTIONAL), SPECIAL_OPTIONAL | SPECIAL_TARGETSOURCE,OP_OPTIONAL, }, 201 { P(NODE_ORDER), SPECIAL_ORDER | SPECIAL_TARGET, 0, }, 202 { P(NODE_PARALLEL), SPECIAL_PARALLEL | SPECIAL_TARGET, 0, }, 203 { P(NODE_PATH), SPECIAL_PATH | SPECIAL_TARGET, 0, }, 204 { P(NODE_PHONY), SPECIAL_PHONY | SPECIAL_TARGETSOURCE, OP_PHONY, }, 205 { P(NODE_PRECIOUS), SPECIAL_PRECIOUS | SPECIAL_TARGETSOURCE,OP_PRECIOUS, }, 206 { P(NODE_RECURSIVE),SPECIAL_MAKE | SPECIAL_TARGETSOURCE, OP_MAKE, }, 207 { P(NODE_SILENT), SPECIAL_SILENT | SPECIAL_TARGETSOURCE, OP_SILENT, }, 208 { P(NODE_SINGLESHELL),SPECIAL_NOTHING | SPECIAL_TARGET, 0, }, 209 { P(NODE_SUFFIXES), SPECIAL_SUFFIXES | SPECIAL_TARGET, 0, }, 210 { P(NODE_USE), SPECIAL_USE | SPECIAL_TARGETSOURCE, OP_USE, }, 211 { P(NODE_WAIT), SPECIAL_WAIT | SPECIAL_TARGETSOURCE, 0 }, 212 { P(NODE_CHEAP), SPECIAL_CHEAP | SPECIAL_TARGETSOURCE, OP_CHEAP, }, 213 { P(NODE_EXPENSIVE),SPECIAL_EXPENSIVE | SPECIAL_TARGETSOURCE,OP_EXPENSIVE, }, 214 { P(NODE_POSIX), SPECIAL_NOTHING | SPECIAL_TARGET, 0 }, 215 { P(NODE_SCCS_GET), SPECIAL_NOTHING | SPECIAL_TARGET, 0 }, 216 }; 217 218 #undef P 219 220 static void 221 create_special_nodes() 222 { 223 unsigned int i; 224 225 for (i = 0; i < sizeof(specials)/sizeof(specials[0]); i++) { 226 GNode *gn = Targ_FindNodeh(specials[i].keyword, 227 specials[i].sz, specials[i].hv, TARG_CREATE); 228 gn->special = specials[i].type; 229 gn->special_op = specials[i].special_op; 230 } 231 } 232 233 /*- 234 *--------------------------------------------------------------------- 235 * ParseLinkSrc -- 236 * Link the parent node to its new child. Used by 237 * ParseDoDependency. If the specType isn't 'Not', the parent 238 * isn't linked as a parent of the child. 239 * 240 * Side Effects: 241 * New elements are added to the parents list of cgn and the 242 * children list of cgn. the unmade field of pgn is updated 243 * to reflect the additional child. 244 *--------------------------------------------------------------------- 245 */ 246 static void 247 ParseLinkSrc(GNode *pgn, GNode *cgn) 248 { 249 if (Lst_AddNew(&pgn->children, cgn)) { 250 if (specType == SPECIAL_NONE) 251 Lst_AtEnd(&cgn->parents, pgn); 252 pgn->unmade++; 253 } 254 } 255 256 static char * 257 operator_string(int op) 258 { 259 /* XXX we don't bother freeing this, it's used for a fatal error 260 * anyways 261 */ 262 char *result = emalloc(5); 263 char *t = result; 264 if (op & OP_DEPENDS) { 265 *t++ = ':'; 266 } 267 if (op & OP_FORCE) { 268 *t++ = '!'; 269 } 270 if (op & OP_DOUBLEDEP) { 271 *t++ = ':'; 272 *t++ = ':'; 273 } 274 *t = 0; 275 return result; 276 } 277 278 /*- 279 *--------------------------------------------------------------------- 280 * ParseDoOp -- 281 * Apply the parsed operator to the given target node. Used in a 282 * Array_Find call by ParseDoDependency once all targets have 283 * been found and their operator parsed. If the previous and new 284 * operators are incompatible, a major error is taken. 285 * 286 * Side Effects: 287 * The type field of the node is altered to reflect any new bits in 288 * the op. 289 *--------------------------------------------------------------------- 290 */ 291 static int 292 ParseDoOp(GNode **gnp, unsigned int op) 293 { 294 GNode *gn = *gnp; 295 /* 296 * If the dependency mask of the operator and the node don't match and 297 * the node has actually had an operator applied to it before, and the 298 * operator actually has some dependency information in it, complain. 299 */ 300 if (((op & OP_OPMASK) != (gn->type & OP_OPMASK)) && 301 !OP_NOP(gn->type) && !OP_NOP(op)) { 302 Parse_Error(PARSE_FATAL, 303 "Inconsistent dependency operator for target %s\n" 304 "\t(was %s%s, now %s%s)", 305 gn->name, gn->name, operator_string(gn->type), 306 gn->name, operator_string(op)); 307 return 0; 308 } 309 310 if (op == OP_DOUBLEDEP && ((gn->type & OP_OPMASK) == OP_DOUBLEDEP)) { 311 /* If the node was the object of a :: operator, we need to 312 * create a new instance of it for the children and commands on 313 * this dependency line. The new instance is placed on the 314 * 'cohorts' list of the initial one (note the initial one is 315 * not on its own cohorts list) and the new instance is linked 316 * to all parents of the initial instance. */ 317 GNode *cohort; 318 LstNode ln; 319 320 cohort = Targ_NewGN(gn->name); 321 /* Duplicate links to parents so graph traversal is simple. 322 * Perhaps some type bits should be duplicated? 323 * 324 * Make the cohort invisible as well to avoid duplicating it 325 * into other variables. True, parents of this target won't 326 * tend to do anything with their local variables, but better 327 * safe than sorry. */ 328 for (ln = Lst_First(&gn->parents); ln != NULL; ln = Lst_Adv(ln)) 329 ParseLinkSrc((GNode *)Lst_Datum(ln), cohort); 330 cohort->type = OP_DOUBLEDEP|OP_INVISIBLE; 331 Lst_AtEnd(&gn->cohorts, cohort); 332 333 /* Replace the node in the targets list with the new copy */ 334 *gnp = cohort; 335 gn = cohort; 336 } 337 /* We don't want to nuke any previous flags (whatever they were) so we 338 * just OR the new operator into the old. */ 339 gn->type |= op; 340 return 1; 341 } 342 343 /*- 344 *--------------------------------------------------------------------- 345 * ParseAddDep -- 346 * Check if the pair of GNodes given needs to be synchronized. 347 * This has to be when two nodes are on different sides of a 348 * .WAIT directive. 349 * 350 * Results: 351 * Returns 0 if the two targets need to be ordered, 1 otherwise. 352 * If it returns 0, the search can stop. 353 * 354 * Side Effects: 355 * A dependency can be added between the two nodes. 356 * 357 *--------------------------------------------------------------------- 358 */ 359 static int 360 ParseAddDep(GNode *p, GNode *s) 361 { 362 if (p->order < s->order) { 363 /* XXX: This can cause loops, and loops can cause unmade 364 * targets, but checking is tedious, and the debugging output 365 * can show the problem. */ 366 Lst_AtEnd(&p->successors, s); 367 Lst_AtEnd(&s->preds, p); 368 return 1; 369 } else 370 return 0; 371 } 372 373 static void 374 apply_op(struct growableArray *targets, unsigned int op, GNode *gn) 375 { 376 if (op) 377 gn->type |= op; 378 else 379 Array_ForEach(targets, ParseLinkSrc, gn); 380 } 381 382 /*- 383 *--------------------------------------------------------------------- 384 * ParseDoSrc -- 385 * Given the name of a source, figure out if it is an attribute 386 * and apply it to the targets if it is. Else decide if there is 387 * some attribute which should be applied *to* the source because 388 * of some special target and apply it if so. Otherwise, make the 389 * source be a child of the targets in the list 'targets' 390 * 391 * Side Effects: 392 * Operator bits may be added to the list of targets or to the source. 393 * The targets may have a new source added to their lists of children. 394 *--------------------------------------------------------------------- 395 */ 396 static void 397 ParseDoSrc( 398 struct growableArray *targets, 399 struct growableArray *sources, 400 int tOp, /* operator (if any) from special targets */ 401 const char *src, /* name of the source to handle */ 402 const char *esrc) 403 { 404 GNode *gn = Targ_FindNodei(src, esrc, TARG_CREATE); 405 if ((gn->special & SPECIAL_SOURCE) != 0) { 406 if (gn->special_op) { 407 Array_FindP(targets, ParseDoOp, gn->special_op); 408 return; 409 } else { 410 assert((gn->special & SPECIAL_MASK) == SPECIAL_WAIT); 411 waiting++; 412 return; 413 } 414 } 415 416 switch (specType) { 417 case SPECIAL_MAIN: 418 /* 419 * If we have noted the existence of a .MAIN, it means we need 420 * to add the sources of said target to the list of things 421 * to create. Note that this will only be invoked if the user 422 * didn't specify a target on the command line. This is to 423 * allow #ifmake's to succeed, or something... 424 */ 425 Lst_AtEnd(create, gn->name); 426 /* 427 * Add the name to the .TARGETS variable as well, so the user 428 * can employ that, if desired. 429 */ 430 Var_Append(".TARGETS", gn->name); 431 return; 432 433 case SPECIAL_ORDER: 434 /* 435 * Create proper predecessor/successor links between the 436 * previous source and the current one. 437 */ 438 if (predecessor != NULL) { 439 Lst_AtEnd(&predecessor->successors, gn); 440 Lst_AtEnd(&gn->preds, predecessor); 441 } 442 predecessor = gn; 443 break; 444 445 default: 446 /* 447 * In the case of a source that was the object of a :: operator, 448 * the attribute is applied to all of its instances (as kept in 449 * the 'cohorts' list of the node) or all the cohorts are linked 450 * to all the targets. 451 */ 452 apply_op(targets, tOp, gn); 453 if ((gn->type & OP_OPMASK) == OP_DOUBLEDEP) { 454 LstNode ln; 455 456 for (ln=Lst_First(&gn->cohorts); ln != NULL; 457 ln = Lst_Adv(ln)){ 458 apply_op(targets, tOp, 459 (GNode *)Lst_Datum(ln)); 460 } 461 } 462 break; 463 } 464 465 gn->order = waiting; 466 Array_AtEnd(sources, gn); 467 if (waiting) 468 Array_Find(sources, ParseAddDep, gn); 469 } 470 471 /*- 472 *----------------------------------------------------------------------- 473 * ParseFindMain -- 474 * Find a real target in the list and set it to be the main one. 475 * Called by ParseDoDependency when a main target hasn't been found 476 * yet. 477 * 478 * Results: 479 * 1 if main not found yet, 0 if it is. 480 * 481 * Side Effects: 482 * mainNode is changed and. 483 *----------------------------------------------------------------------- 484 */ 485 static int 486 ParseFindMain(void *gnp, void *dummy UNUSED) 487 { 488 GNode *gn = gnp; 489 490 if ((gn->type & OP_NOTARGET) == 0 && gn->special == SPECIAL_NONE) { 491 mainNode = gn; 492 return 0; 493 } else { 494 return 1; 495 } 496 } 497 498 /*- 499 *----------------------------------------------------------------------- 500 * ParseClearPath -- 501 * Reinit path to an empty path 502 *----------------------------------------------------------------------- 503 */ 504 static void 505 ParseClearPath(void *p) 506 { 507 Lst path = p; 508 509 Lst_Destroy(path, Dir_Destroy); 510 Lst_Init(path); 511 } 512 513 static void 514 add_target_node(const char *line, const char *end) 515 { 516 GNode *gn; 517 518 gn = Suff_ParseAsTransform(line, end); 519 520 if (gn == NULL) { 521 gn = Targ_FindNodei(line, end, TARG_CREATE); 522 gn->type &= ~OP_DUMMY; 523 } 524 525 Array_AtEnd(>argets, gn); 526 } 527 528 static void 529 add_target_nodes(const char *line, const char *end) 530 { 531 532 if (Dir_HasWildcardsi(line, end)) { 533 /* 534 * Targets are to be sought only in the current directory, 535 * so create an empty path for the thing. Note we need to 536 * use Dir_Destroy in the destruction of the path as the 537 * Dir module could have added a directory to the path... 538 */ 539 char *targName; 540 LIST emptyPath; 541 LIST curTargs; 542 543 Lst_Init(&emptyPath); 544 Lst_Init(&curTargs); 545 Dir_Expandi(line, end, &emptyPath, &curTargs); 546 Lst_Destroy(&emptyPath, Dir_Destroy); 547 while ((targName = (char *)Lst_DeQueue(&curTargs)) != NULL) { 548 add_target_node(targName, targName + strlen(targName)); 549 } 550 Lst_Destroy(&curTargs, NOFREE); 551 } else { 552 add_target_node(line, end); 553 } 554 } 555 556 /* special target line check: a proper delimiter is a ':' or '!', but 557 * we don't want to end a target on such a character if there is a better 558 * match later on. 559 * By "better" I mean one that is followed by whitespace. This allows the 560 * user to have targets like: 561 * fie::fi:fo: fum 562 * where "fie::fi:fo" is the target. In real life this is used for perl5 563 * library man pages where "::" separates an object from its class. Ie: 564 * "File::Spec::Unix". 565 * This behaviour is also consistent with other versions of make. 566 */ 567 static bool 568 found_delimiter(const char *s) 569 { 570 if (*s == '!' || *s == ':') { 571 const char *p = s + 1; 572 573 if (*s == ':' && *p == ':') 574 p++; 575 576 /* Found the best match already. */ 577 if (ISSPACE(*p) || *p == '\0') 578 return true; 579 580 do { 581 p += strcspn(p, "!:"); 582 if (*p == '\0') 583 break; 584 p++; 585 } while (!ISSPACE(*p)); 586 587 /* No better match later on... */ 588 if (*p == '\0') 589 return true; 590 } 591 return false; 592 } 593 594 static const char * 595 parse_do_targets(Lst paths, unsigned int *op, const char *line) 596 { 597 const char *cp; 598 599 do { 600 for (cp = line; *cp && !ISSPACE(*cp) && *cp != '(';) { 601 if (*cp == '$') 602 /* Must be a dynamic source (would have been 603 * expanded otherwise), so call the Var module 604 * to parse the puppy so we can safely advance 605 * beyond it...There should be no errors in 606 * this, as they would have been discovered in 607 * the initial Var_Subst and we wouldn't be 608 * here. */ 609 Var_ParseSkip(&cp, NULL); 610 else { 611 if (found_delimiter(cp)) 612 break; 613 cp++; 614 } 615 } 616 617 if (*cp == '(') { 618 LIST temp; 619 Lst_Init(&temp); 620 /* Archives must be handled specially to make sure the 621 * OP_ARCHV flag is set in their 'type' field, for one 622 * thing, and because things like "archive(file1.o 623 * file2.o file3.o)" are permissible. 624 * Arch_ParseArchive will set 'line' to be the first 625 * non-blank after the archive-spec. It creates/finds 626 * nodes for the members and places them on the given 627 * list, returning true if all went well and false if 628 * there was an error in the specification. On error, 629 * line should remain untouched. */ 630 if (!Arch_ParseArchive(&line, &temp, NULL)) { 631 Parse_Error(PARSE_FATAL, 632 "Error in archive specification: \"%s\"", 633 line); 634 return NULL; 635 } else { 636 AppendList2Array(&temp, >argets); 637 Lst_Destroy(&temp, NOFREE); 638 cp = line; 639 continue; 640 } 641 } 642 if (*cp == '\0') { 643 /* Ending a dependency line without an operator is a 644 * Bozo no-no */ 645 /* Deeper check for cvs conflicts */ 646 if (gtargets.n > 0 && 647 (strcmp(gtargets.a[0]->name, "<<<<<<<") == 0 || 648 strcmp(gtargets.a[0]->name, ">>>>>>>") == 0)) { 649 Parse_Error(PARSE_FATAL, 650 "Need an operator (likely from a cvs update conflict)"); 651 } else { 652 Parse_Error(PARSE_FATAL, 653 "Need an operator in '%s'", line); 654 } 655 return NULL; 656 } 657 /* 658 * Have word in line. Get or create its nodes and stick it at 659 * the end of the targets list 660 */ 661 if (*line != '\0') 662 add_target_nodes(line, cp); 663 664 while (ISSPACE(*cp)) 665 cp++; 666 line = cp; 667 } while (*line != '!' && *line != ':' && *line); 668 *op = handle_special_targets(paths); 669 return cp; 670 } 671 672 static void 673 dump_targets() 674 { 675 size_t i; 676 for (i = 0; i < gtargets.n; i++) 677 fprintf(stderr, "%s", gtargets.a[i]->name); 678 fprintf(stderr, "\n"); 679 } 680 681 static unsigned int 682 handle_special_targets(Lst paths) 683 { 684 size_t i; 685 int seen_path = 0; 686 int seen_special = 0; 687 int seen_normal = 0; 688 int type; 689 690 for (i = 0; i < gtargets.n; i++) { 691 type = gtargets.a[i]->special; 692 if ((type & SPECIAL_MASK) == SPECIAL_PATH) { 693 seen_path++; 694 Lst_AtEnd(paths, find_suffix_path(gtargets.a[i])); 695 } else if ((type & SPECIAL_TARGET) != 0) 696 seen_special++; 697 else 698 seen_normal++; 699 } 700 if ((seen_path != 0) + (seen_special != 0) + (seen_normal != 0) > 1) { 701 Parse_Error(PARSE_FATAL, "Wrong mix of special targets"); 702 dump_targets(); 703 specType = SPECIAL_ERROR; 704 return 0; 705 } 706 if (seen_normal != 0) { 707 specType = SPECIAL_NONE; 708 return 0; 709 } else if (seen_path != 0) { 710 specType = SPECIAL_PATH; 711 return 0; 712 } else if (seen_special == 0) { 713 specType = SPECIAL_NONE; 714 return 0; 715 } else if (seen_special != 1) { 716 Parse_Error(PARSE_FATAL, 717 "Mixing special targets is not allowed"); 718 dump_targets(); 719 return 0; 720 } else if (seen_special == 1) { 721 specType = gtargets.a[0]->special & SPECIAL_MASK; 722 switch (specType) { 723 case SPECIAL_MAIN: 724 if (!Lst_IsEmpty(create)) { 725 specType = SPECIAL_NONE; 726 } 727 break; 728 case SPECIAL_NOTPARALLEL: 729 { 730 extern int maxJobs; 731 732 maxJobs = 1; 733 compatMake = 1; 734 break; 735 } 736 case SPECIAL_ORDER: 737 predecessor = NULL; 738 break; 739 default: 740 break; 741 } 742 return gtargets.a[0]->special_op; 743 } else { 744 /* we're allowed to have 0 target */ 745 specType = SPECIAL_NONE; 746 return 0; 747 } 748 } 749 750 static unsigned int 751 parse_operator(const char **pos) 752 { 753 const char *cp = *pos; 754 unsigned int op = OP_ERROR; 755 756 if (*cp == '!') { 757 op = OP_FORCE; 758 } else if (*cp == ':') { 759 if (cp[1] == ':') { 760 op = OP_DOUBLEDEP; 761 cp++; 762 } else { 763 op = OP_DEPENDS; 764 } 765 } else { 766 Parse_Error(PARSE_FATAL, "Missing dependency operator"); 767 return OP_ERROR; 768 } 769 770 cp++; /* Advance beyond operator */ 771 772 /* Get to the first source */ 773 while (ISSPACE(*cp)) 774 cp++; 775 *pos = cp; 776 return op; 777 } 778 779 /*- 780 *--------------------------------------------------------------------- 781 * ParseDoDependency -- 782 * Parse the dependency line in line. 783 * 784 * Side Effects: 785 * The nodes of the sources are linked as children to the nodes of the 786 * targets. Some nodes may be created. 787 * 788 * We parse a dependency line by first extracting words from the line and 789 * finding nodes in the list of all targets with that name. This is done 790 * until a character is encountered which is an operator character. Currently 791 * these are only ! and :. At this point the operator is parsed and the 792 * pointer into the line advanced until the first source is encountered. 793 * The parsed operator is applied to each node in the 'targets' list, 794 * which is where the nodes found for the targets are kept, by means of 795 * the ParseDoOp function. 796 * The sources are read in much the same way as the targets were except 797 * that now they are expanded using the wildcarding scheme of the C-Shell 798 * and all instances of the resulting words in the list of all targets 799 * are found. Each of the resulting nodes is then linked to each of the 800 * targets as one of its children. 801 * Certain targets are handled specially. These are the ones detailed 802 * by the specType variable. 803 * The storing of transformation rules is also taken care of here. 804 * A target is recognized as a transformation rule by calling 805 * Suff_IsTransform. If it is a transformation rule, its node is gotten 806 * from the suffix module via Suff_AddTransform rather than the standard 807 * Targ_FindNode in the target module. 808 *--------------------------------------------------------------------- 809 */ 810 static void 811 ParseDoDependency(const char *line) /* the line to parse */ 812 { 813 const char *cp; /* our current position */ 814 unsigned int op; /* the operator on the line */ 815 LIST paths; /* List of search paths to alter when parsing 816 * a list of .PATH targets */ 817 unsigned int tOp; /* operator from special target */ 818 819 waiting = 0; 820 Lst_Init(&paths); 821 822 Array_Reset(&gsources); 823 824 cp = parse_do_targets(&paths, &tOp, line); 825 if (cp == NULL || specType == SPECIAL_ERROR) { 826 /* invalidate targets for further processing */ 827 Array_Reset(>argets); 828 return; 829 } 830 831 op = parse_operator(&cp); 832 if (op == OP_ERROR) { 833 /* invalidate targets for further processing */ 834 Array_Reset(>argets); 835 return; 836 } 837 838 Array_FindP(>argets, ParseDoOp, op); 839 dedup_targets(>argets); 840 841 line = cp; 842 843 /* 844 * Several special targets take different actions if present with no 845 * sources: 846 * a .SUFFIXES line with no sources clears out all old suffixes 847 * a .PRECIOUS line makes all targets precious 848 * a .IGNORE line ignores errors for all targets 849 * a .SILENT line creates silence when making all targets 850 * a .PATH removes all directories from the search path(s). 851 */ 852 if (!*line) { 853 switch (specType) { 854 case SPECIAL_SUFFIXES: 855 Suff_ClearSuffixes(); 856 break; 857 case SPECIAL_PRECIOUS: 858 allPrecious = true; 859 break; 860 case SPECIAL_IGNORE: 861 ignoreErrors = true; 862 break; 863 case SPECIAL_SILENT: 864 beSilent = true; 865 break; 866 case SPECIAL_PATH: 867 Lst_Every(&paths, ParseClearPath); 868 break; 869 default: 870 break; 871 } 872 } else if (specType == SPECIAL_MFLAGS) { 873 /* Call on functions in main.c to deal with these arguments */ 874 Main_ParseArgLine(line); 875 return; 876 } else if (specType == SPECIAL_NOTPARALLEL) { 877 return; 878 } 879 880 /* 881 * NOW GO FOR THE SOURCES 882 */ 883 if (specType == SPECIAL_SUFFIXES || specType == SPECIAL_PATH || 884 specType == SPECIAL_NOTHING) { 885 while (*line) { 886 /* 887 * If the target was one that doesn't take files as its 888 * sources but takes something like suffixes, we take each 889 * space-separated word on the line as a something and deal 890 * with it accordingly. 891 * 892 * If the target was .SUFFIXES, we take each source as a 893 * suffix and add it to the list of suffixes maintained by 894 * the Suff module. 895 * 896 * If the target was a .PATH, we add the source as a 897 * directory to search on the search path. 898 * 899 * If it was .INCLUDES, the source is taken to be the 900 * suffix of files which will be #included and whose search 901 * path should be present in the .INCLUDES variable. 902 * 903 * If it was .LIBS, the source is taken to be the suffix of 904 * files which are considered libraries and whose search 905 * path should be present in the .LIBS variable. 906 * 907 * If it was .NULL, the source is the suffix to use when a 908 * file has no valid suffix. 909 */ 910 while (*cp && !ISSPACE(*cp)) 911 cp++; 912 switch (specType) { 913 case SPECIAL_SUFFIXES: 914 Suff_AddSuffixi(line, cp); 915 break; 916 case SPECIAL_PATH: 917 { 918 LstNode ln; 919 920 for (ln = Lst_First(&paths); ln != NULL; 921 ln = Lst_Adv(ln)) 922 Dir_AddDiri((Lst)Lst_Datum(ln), line, cp); 923 break; 924 } 925 default: 926 break; 927 } 928 if (*cp != '\0') 929 cp++; 930 while (ISSPACE(*cp)) 931 cp++; 932 line = cp; 933 } 934 Lst_Destroy(&paths, NOFREE); 935 } else { 936 while (*line) { 937 /* 938 * The targets take real sources, so we must beware of 939 * archive specifications (i.e. things with left 940 * parentheses in them) and handle them accordingly. 941 */ 942 while (*cp && !ISSPACE(*cp)) { 943 if (*cp == '(' && cp > line && cp[-1] != '$') { 944 /* 945 * Only stop for a left parenthesis if 946 * it isn't at the start of a word 947 * (that'll be for variable changes 948 * later) and isn't preceded by a 949 * dollar sign (a dynamic source). 950 */ 951 break; 952 } else { 953 cp++; 954 } 955 } 956 957 if (*cp == '(') { 958 GNode *gn; 959 LIST sources; /* list of archive source 960 * names after expansion */ 961 962 Lst_Init(&sources); 963 if (!Arch_ParseArchive(&line, &sources, NULL)) { 964 Parse_Error(PARSE_FATAL, 965 "Error in source archive spec \"%s\"", 966 line); 967 return; 968 } 969 970 while ((gn = (GNode *)Lst_DeQueue(&sources)) != 971 NULL) 972 ParseDoSrc(>argets, &gsources, tOp, 973 gn->name, NULL); 974 cp = line; 975 } else { 976 const char *endSrc = cp; 977 978 ParseDoSrc(>argets, &gsources, tOp, line, 979 endSrc); 980 if (*cp) 981 cp++; 982 } 983 while (ISSPACE(*cp)) 984 cp++; 985 line = cp; 986 } 987 } 988 989 if (mainNode == NULL) { 990 /* If we have yet to decide on a main target to make, in the 991 * absence of any user input, we want the first target on 992 * the first dependency line that is actually a real target 993 * (i.e. isn't a .USE or .EXEC rule) to be made. */ 994 Array_Find(>argets, ParseFindMain, NULL); 995 } 996 } 997 998 /*- 999 * ParseAddCmd -- 1000 * Lst_ForEach function to add a command line to all targets 1001 * 1002 * The new command may be added to the commands list of the node. 1003 * 1004 * If the target already had commands, we ignore the new ones, but 1005 * we note that we got double commands (in case we actually get to run 1006 * that ambiguous target). 1007 * 1008 * Note this does not apply to :: dependency lines, since those 1009 * will generate fresh cloned nodes and add them to the cohorts 1010 * field of the main node. 1011 */ 1012 static void 1013 ParseAddCmd(void *gnp, void *cmd) 1014 { 1015 GNode *gn = gnp; 1016 1017 if (!(gn->type & OP_HAS_COMMANDS)) 1018 Lst_AtEnd(&gn->commands, cmd); 1019 else 1020 gn->type |= OP_DOUBLE; 1021 } 1022 1023 /*- 1024 *----------------------------------------------------------------------- 1025 * ParseHasCommands -- 1026 * Record that the target gained commands through OP_HAS_COMMANDS, 1027 * so that double command lists may be ignored. 1028 *----------------------------------------------------------------------- 1029 */ 1030 static void 1031 ParseHasCommands(void *gnp) 1032 { 1033 GNode *gn = gnp; 1034 gn->type |= OP_HAS_COMMANDS; 1035 1036 } 1037 1038 1039 /* Strip comments from line. Build a copy in buffer if necessary, */ 1040 static char * 1041 strip_comments(Buffer copy, const char *line) 1042 { 1043 const char *comment; 1044 const char *p; 1045 1046 comment = strchr(line, '#'); 1047 assert(comment != line); 1048 if (comment == NULL) 1049 return (char *)line; 1050 else { 1051 Buf_Reset(copy); 1052 1053 for (p = line; *p != '\0'; p++) { 1054 if (*p == '\\') { 1055 if (p[1] == '#') { 1056 Buf_Addi(copy, line, p); 1057 Buf_AddChar(copy, '#'); 1058 line = p+2; 1059 } 1060 if (p[1] != '\0') 1061 p++; 1062 } else if (*p == '#') 1063 break; 1064 } 1065 Buf_Addi(copy, line, p); 1066 return Buf_Retrieve(copy); 1067 } 1068 } 1069 1070 1071 1072 /*** 1073 *** Support for various include constructs 1074 ***/ 1075 1076 1077 void 1078 Parse_AddIncludeDir(const char *dir) 1079 { 1080 Dir_AddDir(userIncludePath, dir); 1081 } 1082 1083 static char * 1084 resolve_include_filename(const char *file, const char *efile, bool isSystem) 1085 { 1086 char *fullname; 1087 1088 /* Look up system files on the system path first */ 1089 if (isSystem) { 1090 fullname = Dir_FindFileNoDoti(file, efile, systemIncludePath); 1091 if (fullname) 1092 return fullname; 1093 } 1094 1095 /* Handle non-system non-absolute files... */ 1096 if (!isSystem && file[0] != '/') { 1097 /* ... by looking first under the same directory as the 1098 * current file */ 1099 char *slash = NULL; 1100 const char *fname; 1101 1102 fname = Parse_Getfilename(); 1103 1104 if (fname != NULL) 1105 slash = strrchr(fname, '/'); 1106 1107 if (slash != NULL) { 1108 char *newName; 1109 1110 newName = Str_concati(fname, slash, file, efile, '/'); 1111 fullname = Dir_FindFile(newName, userIncludePath); 1112 if (fullname == NULL) 1113 fullname = Dir_FindFile(newName, defaultPath); 1114 free(newName); 1115 if (fullname) 1116 return fullname; 1117 } 1118 } 1119 1120 /* Now look first on the -I search path, then on the .PATH 1121 * search path, if not found in a -I directory. 1122 * XXX: Suffix specific? */ 1123 fullname = Dir_FindFilei(file, efile, userIncludePath); 1124 if (fullname) 1125 return fullname; 1126 fullname = Dir_FindFilei(file, efile, defaultPath); 1127 if (fullname) 1128 return fullname; 1129 1130 /* Still haven't found the makefile. Look for it on the system 1131 * path as a last resort (if we haven't already). */ 1132 if (isSystem) 1133 return NULL; 1134 else 1135 return Dir_FindFilei(file, efile, systemIncludePath); 1136 } 1137 1138 static void 1139 handle_include_file(const char *file, const char *efile, bool isSystem, 1140 bool errIfNotFound) 1141 { 1142 char *fullname; 1143 1144 fullname = resolve_include_filename(file, efile, isSystem); 1145 if (fullname == NULL && errIfNotFound) 1146 Parse_Error(PARSE_FATAL, "Could not find %.*s", 1147 (int)(efile - file), file); 1148 1149 if (fullname != NULL) { 1150 FILE *f; 1151 1152 f = fopen(fullname, "r"); 1153 if (f == NULL && errIfNotFound) 1154 Parse_Error(PARSE_FATAL, "Cannot open %s", fullname); 1155 else 1156 Parse_FromFile(fullname, f); 1157 } 1158 } 1159 1160 /* .include <file> (system) or .include "file" (normal) */ 1161 static bool 1162 lookup_bsd_include(const char *file) 1163 { 1164 char endc; 1165 const char *efile; 1166 char *file2; 1167 bool isSystem; 1168 1169 /* find starting delimiter */ 1170 while (ISSPACE(*file)) 1171 file++; 1172 1173 /* determine type of file */ 1174 if (*file == '<') { 1175 isSystem = true; 1176 endc = '>'; 1177 } else if (*file == '"') { 1178 isSystem = false; 1179 endc = '"'; 1180 } else { 1181 Parse_Error(PARSE_WARNING, 1182 ".include filename must be delimited by '\"' or '<'"); 1183 return false; 1184 } 1185 1186 /* delimit file name between file and efile */ 1187 for (efile = ++file; *efile != endc; efile++) { 1188 if (*efile == '\0') { 1189 Parse_Error(PARSE_WARNING, 1190 "Unclosed .include filename. '%c' expected", endc); 1191 return false; 1192 } 1193 } 1194 /* Substitute for any variables in the file name before trying to 1195 * find the thing. */ 1196 file2 = Var_Substi(file, efile, NULL, false); 1197 handle_include_file(file2, strchr(file2, '\0'), isSystem, true); 1198 free(file2); 1199 return true; 1200 } 1201 1202 1203 static void 1204 lookup_sysv_style_include(const char *line, const char *directive, 1205 bool errIfMissing) 1206 { 1207 char *file; 1208 char *name; 1209 char *ename; 1210 bool okay = false; 1211 1212 /* Substitute for any variables in the file name before trying to 1213 * find the thing. */ 1214 file = Var_Subst(line, NULL, false); 1215 1216 /* sys5 allows for list of files separated by spaces */ 1217 name = file; 1218 while (1) { 1219 /* find beginning of name */ 1220 while (ISSPACE(*name)) 1221 name++; 1222 if (*name == '\0') 1223 break; 1224 for (ename = name; *ename != '\0' && !ISSPACE(*ename);) 1225 ename++; 1226 handle_include_file(name, ename, true, errIfMissing); 1227 okay = true; 1228 name = ename; 1229 } 1230 1231 free(file); 1232 if (!okay) { 1233 Parse_Error(PARSE_FATAL, "Filename missing from \"%s\"", 1234 directive); 1235 } 1236 } 1237 1238 1239 /* system V construct: include file */ 1240 static void 1241 lookup_sysv_include(const char *file, const char *directive) 1242 { 1243 lookup_sysv_style_include(file, directive, true); 1244 } 1245 1246 1247 /* sinclude file and -include file */ 1248 static void 1249 lookup_conditional_include(const char *file, const char *directive) 1250 { 1251 lookup_sysv_style_include(file, directive, false); 1252 } 1253 1254 1255 /*** 1256 *** BSD-specific . constructs 1257 *** They all follow the same pattern: 1258 *** if the syntax matches BSD stuff, then we're committed to handle 1259 *** them and report fatal errors (like, include file not existing) 1260 *** otherwise, we return false, and hope somebody else will handle it. 1261 ***/ 1262 1263 static bool 1264 handle_poison(const char *line) 1265 { 1266 const char *p = line; 1267 int type = POISON_NORMAL; 1268 bool not = false; 1269 bool paren_to_match = false; 1270 const char *name, *ename; 1271 1272 while (ISSPACE(*p)) 1273 p++; 1274 if (*p == '!') { 1275 not = true; 1276 p++; 1277 } 1278 while (ISSPACE(*p)) 1279 p++; 1280 if (strncmp(p, "defined", 7) == 0) { 1281 type = POISON_DEFINED; 1282 p += 7; 1283 } else if (strncmp(p, "empty", 5) == 0) { 1284 type = POISON_EMPTY; 1285 p += 5; 1286 } 1287 while (ISSPACE(*p)) 1288 p++; 1289 if (*p == '(') { 1290 paren_to_match = true; 1291 p++; 1292 } 1293 while (ISSPACE(*p)) 1294 p++; 1295 name = ename = p; 1296 while (*p != '\0' && !ISSPACE(*p)) { 1297 if (*p == ')' && paren_to_match) { 1298 paren_to_match = false; 1299 p++; 1300 break; 1301 } 1302 p++; 1303 ename = p; 1304 } 1305 while (ISSPACE(*p)) 1306 p++; 1307 switch(type) { 1308 case POISON_NORMAL: 1309 case POISON_EMPTY: 1310 if (not) 1311 type = POISON_INVALID; 1312 break; 1313 case POISON_DEFINED: 1314 if (not) 1315 type = POISON_NOT_DEFINED; 1316 else 1317 type = POISON_INVALID; 1318 break; 1319 } 1320 if ((*p != '\0' && *p != '#') || type == POISON_INVALID) { 1321 Parse_Error(PARSE_WARNING, "Invalid syntax for .poison: %s", 1322 line); 1323 return false; 1324 } else { 1325 Var_MarkPoisoned(name, ename, type); 1326 return true; 1327 } 1328 } 1329 1330 1331 static bool 1332 handle_for_loop(Buffer linebuf, const char *line) 1333 { 1334 For *loop; 1335 1336 loop = For_Eval(line); 1337 if (loop != NULL) { 1338 bool ok; 1339 do { 1340 /* Find the matching endfor. */ 1341 line = ParseReadLoopLine(linebuf); 1342 if (line == NULL) { 1343 Parse_Error(PARSE_FATAL, 1344 "Unexpected end of file in for loop.\n"); 1345 return false; 1346 } 1347 ok = For_Accumulate(loop, line); 1348 } while (ok); 1349 For_Run(loop); 1350 return true; 1351 } else 1352 return false; 1353 } 1354 1355 static bool 1356 handle_undef(const char *line) 1357 { 1358 const char *eline; 1359 1360 while (ISSPACE(*line)) 1361 line++; 1362 for (eline = line; !ISSPACE(*eline) && *eline != '\0';) 1363 eline++; 1364 Var_Deletei(line, eline); 1365 return true; 1366 } 1367 1368 /* global hub for the construct */ 1369 static bool 1370 handle_bsd_command(Buffer linebuf, Buffer copy, const char *line) 1371 { 1372 char *stripped; 1373 1374 while (ISSPACE(*line)) 1375 line++; 1376 1377 /* delegate basic classification to the conditional module */ 1378 switch (Cond_Eval(line)) { 1379 case COND_SKIP: 1380 /* Skip to next conditional that evaluates to COND_PARSE. */ 1381 do { 1382 line = Parse_ReadNextConditionalLine(linebuf); 1383 if (line != NULL) { 1384 while (ISSPACE(*line)) 1385 line++; 1386 stripped = strip_comments(copy, line); 1387 } 1388 } while (line != NULL && Cond_Eval(stripped) != COND_PARSE); 1389 /* FALLTHROUGH */ 1390 case COND_PARSE: 1391 return true; 1392 case COND_ISFOR: 1393 return handle_for_loop(linebuf, line + 3); 1394 case COND_ISINCLUDE: 1395 return lookup_bsd_include(line + 7); 1396 case COND_ISPOISON: 1397 return handle_poison(line + 6); 1398 case COND_ISUNDEF: 1399 return handle_undef(line + 5); 1400 default: 1401 break; 1402 } 1403 1404 return false; 1405 } 1406 1407 /* postprocess group of targets prior to linking stuff with them */ 1408 bool 1409 register_target(GNode *gn, struct ohash *t) 1410 { 1411 unsigned int slot; 1412 uint32_t hv; 1413 const char *ename = NULL; 1414 GNode *gn2; 1415 1416 hv = ohash_interval(gn->name, &ename); 1417 1418 slot = ohash_lookup_interval(t, gn->name, ename, hv); 1419 gn2 = ohash_find(t, slot); 1420 1421 if (gn2 == NULL) { 1422 ohash_insert(t, slot, gn); 1423 return true; 1424 } else 1425 return false; 1426 } 1427 1428 static void 1429 build_target_group(struct growableArray *targets, struct ohash *t) 1430 { 1431 LstNode ln; 1432 bool seen_target = false; 1433 unsigned int i; 1434 1435 /* may be 0 if wildcard expansion resulted in zero match */ 1436 if (targets->n <= 1) 1437 return; 1438 1439 /* Perform checks to see if we must tie targets together */ 1440 /* XXX */ 1441 if (targets->a[0]->type & OP_TRANSFORM) 1442 return; 1443 1444 for (ln = Lst_First(&targets->a[0]->commands); ln != NULL; 1445 ln = Lst_Adv(ln)) { 1446 struct command *cmd = Lst_Datum(ln); 1447 if (Var_Check_for_target(cmd->string)) { 1448 seen_target = true; 1449 break; 1450 } 1451 } 1452 if (DEBUG(TARGGROUP)) { 1453 fprintf(stderr, 1454 seen_target ? "No target group at %lu: ": 1455 "Target group at %lu:", Parse_Getlineno()); 1456 for (i = 0; i < targets->n; i++) 1457 fprintf(stderr, " %s", targets->a[i]->name); 1458 fprintf(stderr, "\n"); 1459 } 1460 if (seen_target) 1461 return; 1462 1463 GNode *gn, *gn2; 1464 /* targets may already participate in groupling lists, 1465 * so rebuild the circular list "from scratch" 1466 */ 1467 1468 for (i = 0; i < targets->n; i++) { 1469 gn = targets->a[i]; 1470 for (gn2 = gn->groupling; gn2 != gn; gn2 = gn2->groupling) { 1471 if (!gn2) 1472 break; 1473 register_target(gn2, t); 1474 } 1475 } 1476 1477 for (gn = ohash_first(t, &i); gn != NULL; gn = ohash_next(t, &i)) { 1478 gn->groupling = gn2; 1479 gn2 = gn; 1480 } 1481 gn = ohash_first(t, &i); 1482 gn->groupling = gn2; 1483 } 1484 1485 static void 1486 reset_target_hash() 1487 { 1488 if (htargets_setup) 1489 ohash_delete(&htargets); 1490 ohash_init(&htargets, 5, &gnode_info); 1491 htargets_setup = true; 1492 } 1493 1494 void 1495 Parse_End() 1496 { 1497 if (htargets_setup) 1498 ohash_delete(&htargets); 1499 } 1500 1501 static void 1502 dedup_targets(struct growableArray *targets) 1503 { 1504 unsigned int i, j; 1505 1506 if (targets->n <= 1) 1507 return; 1508 1509 reset_target_hash(); 1510 /* first let's de-dup the list */ 1511 for (i = 0, j = 0; i < targets->n; i++) { 1512 GNode *gn = targets->a[i]; 1513 if (register_target(gn, &htargets)) 1514 targets->a[j++] = targets->a[i]; 1515 } 1516 targets->n = j; 1517 } 1518 1519 1520 /*** 1521 *** handle a group of commands 1522 ***/ 1523 1524 static void 1525 finish_commands(struct growableArray *targets) 1526 { 1527 build_target_group(targets, &htargets); 1528 Array_Every(targets, ParseHasCommands); 1529 } 1530 1531 static void 1532 parse_commands(struct growableArray *targets, const char *line) 1533 { 1534 /* add the command to the list of 1535 * commands of all targets in the dependency spec */ 1536 1537 struct command *cmd; 1538 size_t len = strlen(line); 1539 1540 cmd = emalloc(sizeof(struct command) + len); 1541 memcpy(&cmd->string, line, len+1); 1542 Parse_FillLocation(&cmd->location); 1543 1544 Array_ForEach(targets, ParseAddCmd, cmd); 1545 } 1546 1547 static bool 1548 parse_as_special_line(Buffer buf, Buffer copy, const char *line) 1549 { 1550 if (*line == '.' && handle_bsd_command(buf, copy, line+1)) 1551 return true; 1552 if (FEATURES(FEATURE_SYSVINCLUDE) && 1553 strncmp(line, "include", 7) == 0 && 1554 ISSPACE(line[7]) && 1555 strchr(line, ':') == NULL) { 1556 /* It's an S3/S5-style "include". */ 1557 lookup_sysv_include(line + 7, "include"); 1558 return true; 1559 } 1560 if (FEATURES(FEATURE_CONDINCLUDE) && 1561 strncmp(line, "sinclude", 8) == 0 && 1562 ISSPACE(line[8]) && 1563 strchr(line, ':') == NULL) { 1564 lookup_conditional_include(line+8, "sinclude"); 1565 return true; 1566 } 1567 if (FEATURES(FEATURE_CONDINCLUDE) && 1568 strncmp(line, "-include", 8) == 0 && 1569 ISSPACE(line[8]) && 1570 strchr(line, ':') == NULL) { 1571 lookup_conditional_include(line+8, "-include"); 1572 return true; 1573 } 1574 return false; 1575 } 1576 1577 static void 1578 parse_target_line(struct growableArray *targets, const char *line, 1579 const char *stripped, bool *pcommands_seen) 1580 { 1581 size_t pos; 1582 char *end; 1583 char *cp; 1584 char *cmd; 1585 1586 /* let's start a new set of commands */ 1587 Array_Reset(targets); 1588 1589 /* XXX this is a dirty heuristic to handle target: dep ; commands */ 1590 cmd = NULL; 1591 /* First we need to find eventual dependencies */ 1592 pos = strcspn(stripped, ":!"); 1593 /* go over :!, and find ; */ 1594 if (stripped[pos] != '\0' && 1595 (end = strchr(stripped+pos+1, ';')) != NULL) { 1596 if (line != stripped) 1597 /* find matching ; in original... The 1598 * original might be slightly longer. */ 1599 cmd = strchr(line+(end-stripped), ';'); 1600 else 1601 cmd = end; 1602 /* kill end of line. */ 1603 *end = '\0'; 1604 } 1605 /* We now know it's a dependency line so it needs to 1606 * have all variables expanded before being parsed. 1607 */ 1608 cp = Var_Subst(stripped, NULL, false); 1609 ParseDoDependency(cp); 1610 free(cp); 1611 1612 /* Parse command if it's not empty. */ 1613 if (cmd != NULL) { 1614 do { 1615 cmd++; 1616 } while (ISSPACE(*cmd)); 1617 if (*cmd != '\0') { 1618 parse_commands(targets, cmd); 1619 *pcommands_seen = true; 1620 } 1621 } 1622 } 1623 1624 void 1625 Parse_File(const char *filename, FILE *stream) 1626 { 1627 char *line; 1628 bool expectingCommands = false; 1629 bool commands_seen = false; 1630 1631 /* somewhat permanent spaces to shave time */ 1632 BUFFER buf; 1633 BUFFER copy; 1634 1635 Buf_Init(&buf, MAKE_BSIZE); 1636 Buf_Init(©, MAKE_BSIZE); 1637 1638 Parse_FromFile(filename, stream); 1639 do { 1640 while ((line = Parse_ReadNormalLine(&buf)) != NULL) { 1641 if (*line == '\t') { 1642 if (expectingCommands) { 1643 commands_seen = true; 1644 parse_commands(>argets, line+1); 1645 } else 1646 Parse_Error(PARSE_FATAL, 1647 "Unassociated shell command \"%s\"", 1648 line); 1649 } else { 1650 const char *stripped = strip_comments(©, 1651 line); 1652 if (!parse_as_special_line(&buf, ©, 1653 stripped)) { 1654 if (commands_seen) 1655 finish_commands(>argets); 1656 commands_seen = false; 1657 if (Parse_As_Var_Assignment(stripped)) 1658 expectingCommands = false; 1659 else { 1660 parse_target_line(>argets, 1661 line, stripped, 1662 &commands_seen); 1663 expectingCommands = true; 1664 } 1665 } 1666 } 1667 } 1668 } while (Parse_NextFile()); 1669 1670 if (commands_seen) 1671 finish_commands(>argets); 1672 /* Make sure conditionals are clean. */ 1673 Cond_End(); 1674 1675 Parse_ReportErrors(); 1676 Buf_Destroy(&buf); 1677 Buf_Destroy(©); 1678 } 1679 1680 void 1681 Parse_Init(void) 1682 { 1683 mainNode = NULL; 1684 Static_Lst_Init(userIncludePath); 1685 Static_Lst_Init(systemIncludePath); 1686 Array_Init(>argets, TARGETS_SIZE); 1687 Array_Init(&gsources, SOURCES_SIZE); 1688 create_special_nodes(); 1689 } 1690 1691 void 1692 Parse_MainName(Lst listmain) /* result list */ 1693 { 1694 if (mainNode == NULL) { 1695 Punt("no target to make."); 1696 /*NOTREACHED*/ 1697 } else if (mainNode->type & OP_DOUBLEDEP) { 1698 Lst_AtEnd(listmain, mainNode); 1699 Lst_Concat(listmain, &mainNode->cohorts); 1700 } 1701 else 1702 Lst_AtEnd(listmain, mainNode); 1703 } 1704