usr.bin/make/parse.c

   1 /*
   2  * Copyright (c) 1988, 1989, 1990, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  * Copyright (c) 1989 by Berkeley Softworks
   5  * 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. All advertising materials mentioning features or use of this software
  19  *    must display the following acknowledgement:
  20  *      This product includes software developed by the University of
  21  *      California, Berkeley and its contributors.
  22  * 4. Neither the name of the University nor the names of its contributors
  23  *    may be used to endorse or promote products derived from this software
  24  *    without specific prior written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  36  * SUCH DAMAGE.
  37  *
  38  * @(#)parse.c  8.3 (Berkeley) 3/19/94
  39  * $FreeBSD: src/usr.bin/make/parse.c,v 1.22.2.2 2004/07/10 08:14:42 eik Exp $
  40  * $DragonFly: src/usr.bin/make/parse.c,v 1.37 2005/01/11 05:13:33 okumoto Exp $
  41  */
  42
  43 /*-
  44  * parse.c --
  45  *      Functions to parse a makefile.
  46  *
  47  *      One function, Parse_Init, must be called before any functions
  48  *      in this module are used. After that, the function Parse_File is the
  49  *      main entry point and controls most of the other functions in this
  50  *      module.
  51  *
  52  *      Most important structures are kept in Lsts. Directories for
  53  *      the #include "..." function are kept in the 'parseIncPath' Lst, while
  54  *      those for the #include <...> are kept in the 'sysIncPath' Lst. The
  55  *      targets currently being defined are kept in the 'targets' Lst.
  56  *
  57  *      The variables 'curFile.fname' and 'curFile.lineno' are used to track
  58  *      the name of the current file and the line number in that file so that
  59  *      error messages can be more meaningful.
  60  *
  61  * Interface:
  62  *      Parse_Init                  Initialization function which must be
  63  *                                  called before anything else in this module
  64  *                                  is used.
  65  *
  66  *      Parse_File                  Function used to parse a makefile. It must
  67  *                                  be given the name of the file, which should
  68  *                                  already have been opened, and a function
  69  *                                  to call to read a character from the file.
  70  *
  71  *      Parse_IsVar                 Returns TRUE if the given line is a
  72  *                                  variable assignment. Used by MainParseArgs
  73  *                                  to determine if an argument is a target
  74  *                                  or a variable assignment. Used internally
  75  *                                  for pretty much the same thing...
  76  *
  77  *      Parse_Error                 Function called when an error occurs in
  78  *                                  parsing. Used by the variable and
  79  *                                  conditional modules.
  80  *      Parse_MainName              Returns a Lst of the main target to create.
  81  */
  82
  83 #include <ctype.h>
  84 #include <stdarg.h>
  85 #include <string.h>
  86 #include <stdlib.h>
  87 #include <err.h>
  88
  89 #include "arch.h"
  90 #include "buf.h"
  91 #include "cond.h"
  92 #include "config.h"
  93 #include "dir.h"
  94 #include "for.h"
  95 #include "globals.h"
  96 #include "GNode.h"
  97 #include "job.h"
  98 #include "make.h"
  99 #include "nonints.h"
 100 #include "parse.h"
 101 #include "pathnames.h"
 102 #include "str.h"
 103 #include "suff.h"
 104 #include "targ.h"
 105 #include "util.h"
 106 #include "var.h"
 107
 108 /*
 109  * These values are returned by ParseEOF to tell Parse_File whether to
 110  * CONTINUE parsing, i.e. it had only reached the end of an include file,
 111  * or if it's DONE.
 112  */
 113 #define CONTINUE        1
 114 #define DONE            0
 115
 116 /* targets we're working on */
 117 static Lst targets = Lst_Initializer(targets);
 118
 119 static Boolean      inLine;     /* true if currently in a dependency
 120                                  * line or its commands */
 121 static int          fatals = 0;
 122
 123 static GNode        *mainNode;  /* The main target to create. This is the
 124                                  * first target on the first dependency
 125                                  * line in the first makefile */
 126
 127 IFile           curFile;        /* current makefile */
 128
 129 /* stack of IFiles generated by * #includes */
 130 static Lst includes = Lst_Initializer(includes);
 131
 132 /* list of directories for "..." includes */
 133 Lst parseIncPath = Lst_Initializer(parseIncPath);
 134
 135 /* list of directories for <...> includes */
 136 Lst sysIncPath = Lst_Initializer(sysIncPath);
 137
 138 /*-
 139  * specType contains the SPECial TYPE of the current target. It is
 140  * Not if the target is unspecial. If it *is* special, however, the children
 141  * are linked as children of the parent but not vice versa. This variable is
 142  * set in ParseDoDependency
 143  */
 144 typedef enum {
 145     Begin,          /* .BEGIN */
 146     Default,        /* .DEFAULT */
 147     End,            /* .END */
 148     Ignore,         /* .IGNORE */
 149     Includes,       /* .INCLUDES */
 150     Interrupt,      /* .INTERRUPT */
 151     Libs,           /* .LIBS */
 152     MFlags,         /* .MFLAGS or .MAKEFLAGS */
 153     Main,           /* .MAIN and we don't have anything user-specified to
 154                      * make */
 155     NoExport,       /* .NOEXPORT */
 156     Not,            /* Not special */
 157     NotParallel,    /* .NOTPARALELL */
 158     Null,           /* .NULL */
 159     Order,          /* .ORDER */
 160     Parallel,       /* .PARALLEL */
 161     ExPath,         /* .PATH */
 162     Phony,          /* .PHONY */
 163     Posix,          /* .POSIX */
 164     Precious,       /* .PRECIOUS */
 165     ExShell,        /* .SHELL */
 166     Silent,         /* .SILENT */
 167     SingleShell,    /* .SINGLESHELL */
 168     Suffixes,       /* .SUFFIXES */
 169     Wait,           /* .WAIT */
 170     Attribute       /* Generic attribute */
 171 } ParseSpecial;
 172
 173 static ParseSpecial specType;
 174 static int waiting;
 175
 176 /*
 177  * Predecessor node for handling .ORDER. Initialized to NULL when .ORDER
 178  * seen, then set to each successive source on the line.
 179  */
 180 static GNode    *predecessor;
 181
 182 /*
 183  * The parseKeywords table is searched using binary search when deciding
 184  * if a target or source is special. The 'spec' field is the ParseSpecial
 185  * type of the keyword ("Not" if the keyword isn't special as a target) while
 186  * the 'op' field is the operator to apply to the list of targets if the
 187  * keyword is used as a source ("0" if the keyword isn't special as a source)
 188  */
 189 static struct {
 190         const char      *name;  /* Name of keyword */
 191     ParseSpecial  spec;         /* Type when used as a target */
 192     int           op;           /* Operator when used as a source */
 193 } parseKeywords[] = {
 194 { ".BEGIN",       Begin,        0 },
 195 { ".DEFAULT",     Default,      0 },
 196 { ".END",         End,          0 },
 197 { ".EXEC",        Attribute,    OP_EXEC },
 198 { ".IGNORE",      Ignore,       OP_IGNORE },
 199 { ".INCLUDES",    Includes,     0 },
 200 { ".INTERRUPT",   Interrupt,    0 },
 201 { ".INVISIBLE",   Attribute,    OP_INVISIBLE },
 202 { ".JOIN",        Attribute,    OP_JOIN },
 203 { ".LIBS",        Libs,         0 },
 204 { ".MAIN",        Main,         0 },
 205 { ".MAKE",        Attribute,    OP_MAKE },
 206 { ".MAKEFLAGS",   MFlags,       0 },
 207 { ".MFLAGS",      MFlags,       0 },
 208 { ".NOTMAIN",     Attribute,    OP_NOTMAIN },
 209 { ".NOTPARALLEL", NotParallel,  0 },
 210 { ".NO_PARALLEL", NotParallel,  0 },
 211 { ".NULL",        Null,         0 },
 212 { ".OPTIONAL",    Attribute,    OP_OPTIONAL },
 213 { ".ORDER",       Order,        0 },
 214 { ".PARALLEL",    Parallel,     0 },
 215 { ".PATH",        ExPath,       0 },
 216 { ".PHONY",       Phony,        OP_PHONY },
 217 { ".POSIX",       Posix,        0 },
 218 { ".PRECIOUS",    Precious,     OP_PRECIOUS },
 219 { ".RECURSIVE",   Attribute,    OP_MAKE },
 220 { ".SHELL",       ExShell,      0 },
 221 { ".SILENT",      Silent,       OP_SILENT },
 222 { ".SINGLESHELL", SingleShell,  0 },
 223 { ".SUFFIXES",    Suffixes,     0 },
 224 { ".USE",         Attribute,    OP_USE },
 225 { ".WAIT",        Wait,         0 },
 226 };
 227
 228 static int ParseFindKeyword(char *);
 229 static int ParseLinkSrc(void *, void *);
 230 static int ParseDoOp(void *, void *);
 231 static int ParseAddDep(void *, void *);
 232 static void ParseDoSrc(int, char *, Lst *);
 233 static int ParseFindMain(void *, void *);
 234 static int ParseAddDir(void *, void *);
 235 static int ParseClearPath(void *, void *);
 236 static void ParseDoDependency(char *);
 237 static int ParseAddCmd(void *, void *);
 238 static int ParseReadc(void);
 239 static void ParseUnreadc(int);
 240 static void ParseHasCommands(void *);
 241 static void ParseDoInclude(char *);
 242 static void ParseDoError(char *);
 243 static void ParseDoWarning(char *);
 244 #ifdef SYSVINCLUDE
 245 static void ParseTraditionalInclude(char *);
 246 #endif
 247 static int ParseEOF(int);
 248 static char *ParseReadLine(void);
 249 static char *ParseSkipLine(int, int);
 250 static void ParseFinishLine(void);
 251
 252 /*-
 253  *----------------------------------------------------------------------
 254  * ParseFindKeyword --
 255  *      Look in the table of keywords for one matching the given string.
 256  *
 257  * Results:
 258  *      The index of the keyword, or -1 if it isn't there.
 259  *
 260  * Side Effects:
 261  *      None
 262  *----------------------------------------------------------------------
 263  */
 264 static int
 265 ParseFindKeyword(char *str)
 266 {
 267     int             start,
 268                     end,
 269                     cur;
 270     int             diff;
 271
 272     start = 0;
 273     end = (sizeof(parseKeywords) / sizeof(parseKeywords[0])) - 1;
 274
 275     do {
 276         cur = start + ((end - start) / 2);
 277         diff = strcmp(str, parseKeywords[cur].name);
 278
 279         if (diff == 0) {
 280             return (cur);
 281         } else if (diff < 0) {
 282             end = cur - 1;
 283         } else {
 284             start = cur + 1;
 285         }
 286     } while (start <= end);
 287     return (-1);
 288 }
 289
 290 /*-
 291  * Parse_Error  --
 292  *      Error message abort function for parsing. Prints out the context
 293  *      of the error (line number and file) as well as the message with
 294  *      two optional arguments.
 295  *
 296  * Results:
 297  *      None
 298  *
 299  * Side Effects:
 300  *      "fatals" is incremented if the level is PARSE_FATAL.
 301  */
 302 /* VARARGS */
 303 void
 304 Parse_Error(int type, const char *fmt, ...)
 305 {
 306         va_list ap;
 307
 308         va_start(ap, fmt);
 309         fprintf(stderr, "\"%s\", line %d: ",
 310             curFile.fname, curFile.lineno);
 311         if (type == PARSE_WARNING)
 312                 fprintf(stderr, "warning: ");
 313         vfprintf(stderr, fmt, ap);
 314         va_end(ap);
 315         fprintf(stderr, "\n");
 316         fflush(stderr);
 317         if (type == PARSE_FATAL)
 318                 fatals += 1;
 319 }
 320
 321 /*-
 322  *---------------------------------------------------------------------
 323  * ParseLinkSrc  --
 324  *      Link the parent node to its new child. Used in a Lst_ForEach by
 325  *      ParseDoDependency. If the specType isn't 'Not', the parent
 326  *      isn't linked as a parent of the child.
 327  *
 328  * Results:
 329  *      Always = 0
 330  *
 331  * Side Effects:
 332  *      New elements are added to the parents list of cgn and the
 333  *      children list of cgn. the unmade field of pgn is updated
 334  *      to reflect the additional child.
 335  *---------------------------------------------------------------------
 336  */
 337 static int
 338 ParseLinkSrc(void *pgnp, void *cgnp)
 339 {
 340     GNode *pgn = pgnp;
 341     GNode *cgn = cgnp;
 342
 343     if (Lst_Member(&pgn->children, cgn) == NULL) {
 344         Lst_AtEnd(&pgn->children, cgn);
 345         if (specType == Not) {
 346             Lst_AtEnd(&cgn->parents, pgn);
 347         }
 348         pgn->unmade += 1;
 349     }
 350     return (0);
 351 }
 352
 353 /*-
 354  *---------------------------------------------------------------------
 355  * ParseDoOp  --
 356  *      Apply the parsed operator to the given target node. Used in a
 357  *      Lst_ForEach call by ParseDoDependency once all targets have
 358  *      been found and their operator parsed. If the previous and new
 359  *      operators are incompatible, a major error is taken.
 360  *
 361  * Results:
 362  *      Always 0
 363  *
 364  * Side Effects:
 365  *      The type field of the node is altered to reflect any new bits in
 366  *      the op.
 367  *---------------------------------------------------------------------
 368  */
 369 static int
 370 ParseDoOp(void *gnp, void *opp)
 371 {
 372     GNode *gn = gnp;
 373     int op = *(int *)opp;
 374
 375     /*
 376      * If the dependency mask of the operator and the node don't match and
 377      * the node has actually had an operator applied to it before, and
 378      * the operator actually has some dependency information in it, complain.
 379      */
 380     if (((op & OP_OPMASK) != (gn->type & OP_OPMASK)) &&
 381         !OP_NOP(gn->type) && !OP_NOP(op))
 382     {
 383         Parse_Error(PARSE_FATAL, "Inconsistent operator for %s", gn->name);
 384         return (1);
 385     }
 386
 387     if ((op == OP_DOUBLEDEP) && ((gn->type & OP_OPMASK) == OP_DOUBLEDEP)) {
 388         /*
 389          * If the node was the object of a :: operator, we need to create a
 390          * new instance of it for the children and commands on this dependency
 391          * line. The new instance is placed on the 'cohorts' list of the
 392          * initial one (note the initial one is not on its own cohorts list)
 393          * and the new instance is linked to all parents of the initial
 394          * instance.
 395          */
 396         GNode *cohort;
 397         LstNode *ln;
 398
 399         cohort = Targ_NewGN(gn->name);
 400         /*
 401          * Duplicate links to parents so graph traversal is simple. Perhaps
 402          * some type bits should be duplicated?
 403          *
 404          * Make the cohort invisible as well to avoid duplicating it into
 405          * other variables. True, parents of this target won't tend to do
 406          * anything with their local variables, but better safe than
 407          * sorry.
 408          */
 409         Lst_ForEach(&gn->parents, ParseLinkSrc, cohort);
 410         cohort->type = OP_DOUBLEDEP|OP_INVISIBLE;
 411         Lst_AtEnd(&gn->cohorts, cohort);
 412
 413         /*
 414          * Replace the node in the targets list with the new copy
 415          */
 416         ln = Lst_Member(&targets, gn);
 417         Lst_Replace(ln, cohort);
 418         gn = cohort;
 419     }
 420     /*
 421      * We don't want to nuke any previous flags (whatever they were) so we
 422      * just OR the new operator into the old
 423      */
 424     gn->type |= op;
 425
 426     return (0);
 427 }
 428
 429 /*-
 430  *---------------------------------------------------------------------
 431  * ParseAddDep  --
 432  *      Check if the pair of GNodes given needs to be synchronized.
 433  *      This has to be when two nodes are on different sides of a
 434  *      .WAIT directive.
 435  *
 436  * Results:
 437  *      Returns 1 if the two targets need to be ordered, 0 otherwise.
 438  *      If it returns 1, the search can stop
 439  *
 440  * Side Effects:
 441  *      A dependency can be added between the two nodes.
 442  *
 443  *---------------------------------------------------------------------
 444  */
 445 static int
 446 ParseAddDep(void *pp, void *sp)
 447 {
 448     GNode *p = pp;
 449     GNode *s = sp;
 450
 451     if (p->order < s->order) {
 452         /*
 453          * XXX: This can cause loops, and loops can cause unmade targets,
 454          * but checking is tedious, and the debugging output can show the
 455          * problem
 456          */
 457         Lst_AtEnd(&p->successors, s);
 458         Lst_AtEnd(&s->preds, p);
 459         return (0);
 460     }
 461     else
 462         return (1);
 463 }
 464
 465
 466 /*-
 467  *---------------------------------------------------------------------
 468  * ParseDoSrc  --
 469  *      Given the name of a source, figure out if it is an attribute
 470  *      and apply it to the targets if it is. Else decide if there is
 471  *      some attribute which should be applied *to* the source because
 472  *      of some special target and apply it if so. Otherwise, make the
 473  *      source be a child of the targets in the list 'targets'
 474  *
 475  * Results:
 476  *      None
 477  *
 478  * Side Effects:
 479  *      Operator bits may be added to the list of targets or to the source.
 480  *      The targets may have a new source added to their lists of children.
 481  *---------------------------------------------------------------------
 482  */
 483 static void
 484 ParseDoSrc(int tOp, char *src, Lst *allsrc)
 485 {
 486     GNode       *gn = NULL;
 487
 488     if (*src == '.' && isupper ((unsigned char) src[1])) {
 489         int keywd = ParseFindKeyword(src);
 490         if (keywd != -1) {
 491             int op = parseKeywords[keywd].op;
 492             if (op != 0) {
 493                 Lst_ForEach(&targets, ParseDoOp, &op);
 494                 return;
 495             }
 496             if (parseKeywords[keywd].spec == Wait) {
 497                 waiting++;
 498                 return;
 499             }
 500         }
 501     }
 502
 503     switch (specType) {
 504     case Main:
 505         /*
 506          * If we have noted the existence of a .MAIN, it means we need
 507          * to add the sources of said target to the list of things
 508          * to create. The string 'src' is likely to be free, so we
 509          * must make a new copy of it. Note that this will only be
 510          * invoked if the user didn't specify a target on the command
 511          * line. This is to allow #ifmake's to succeed, or something...
 512          */
 513         Lst_AtEnd(&create, estrdup(src));
 514         /*
 515          * Add the name to the .TARGETS variable as well, so the user cna
 516          * employ that, if desired.
 517          */
 518         Var_Append(".TARGETS", src, VAR_GLOBAL);
 519         return;
 520
 521     case Order:
 522         /*
 523          * Create proper predecessor/successor links between the previous
 524          * source and the current one.
 525          */
 526         gn = Targ_FindNode(src, TARG_CREATE);
 527         if (predecessor != NULL) {
 528             Lst_AtEnd(&predecessor->successors, gn);
 529             Lst_AtEnd(&gn->preds, predecessor);
 530         }
 531         /*
 532          * The current source now becomes the predecessor for the next one.
 533          */
 534         predecessor = gn;
 535         break;
 536
 537     default:
 538         /*
 539          * If the source is not an attribute, we need to find/create
 540          * a node for it. After that we can apply any operator to it
 541          * from a special target or link it to its parents, as
 542          * appropriate.
 543          *
 544          * In the case of a source that was the object of a :: operator,
 545          * the attribute is applied to all of its instances (as kept in
 546          * the 'cohorts' list of the node) or all the cohorts are linked
 547          * to all the targets.
 548          */
 549         gn = Targ_FindNode(src, TARG_CREATE);
 550         if (tOp) {
 551             gn->type |= tOp;
 552         } else {
 553             Lst_ForEach(&targets, ParseLinkSrc, gn);
 554         }
 555         if ((gn->type & OP_OPMASK) == OP_DOUBLEDEP) {
 556             GNode       *cohort;
 557             LstNode     *ln;
 558
 559             for (ln = Lst_First(&gn->cohorts); ln != NULL; ln = Lst_Succ(ln)) {
 560                 cohort = Lst_Datum(ln);
 561                 if (tOp) {
 562                     cohort->type |= tOp;
 563                 } else {
 564                     Lst_ForEach(&targets, ParseLinkSrc, cohort);
 565                 }
 566             }
 567         }
 568         break;
 569     }
 570
 571     gn->order = waiting;
 572     Lst_AtEnd(allsrc, gn);
 573     if (waiting) {
 574         Lst_ForEach(allsrc, ParseAddDep, gn);
 575     }
 576 }
 577
 578 /*-
 579  *-----------------------------------------------------------------------
 580  * ParseFindMain --
 581  *      Find a real target in the list and set it to be the main one.
 582  *      Called by ParseDoDependency when a main target hasn't been found
 583  *      yet.
 584  *
 585  * Results:
 586  *      0 if main not found yet, 1 if it is.
 587  *
 588  * Side Effects:
 589  *      mainNode is changed and Targ_SetMain is called.
 590  *
 591  *-----------------------------------------------------------------------
 592  */
 593 static int
 594 ParseFindMain(void *gnp, void *dummy __unused)
 595 {
 596     GNode *gn = gnp;
 597
 598     if ((gn->type & (OP_NOTMAIN | OP_USE | OP_EXEC | OP_TRANSFORM)) == 0) {
 599         mainNode = gn;
 600         Targ_SetMain(gn);
 601         return (1);
 602     } else {
 603         return (0);
 604     }
 605 }
 606
 607 /*-
 608  *-----------------------------------------------------------------------
 609  * ParseAddDir --
 610  *      Front-end for Dir_AddDir to make sure Lst_ForEach keeps going
 611  *
 612  * Results:
 613  *      === 0
 614  *
 615  * Side Effects:
 616  *      See Dir_AddDir.
 617  *
 618  *-----------------------------------------------------------------------
 619  */
 620 static int
 621 ParseAddDir(void *path, void *name)
 622 {
 623
 624     Dir_AddDir(path, name);
 625     return(0);
 626 }
 627
 628 /*-
 629  *-----------------------------------------------------------------------
 630  * ParseClearPath --
 631  *      Front-end for Dir_ClearPath to make sure Lst_ForEach keeps going
 632  *
 633  * Results:
 634  *      === 0
 635  *
 636  * Side Effects:
 637  *      See Dir_ClearPath
 638  *
 639  *-----------------------------------------------------------------------
 640  */
 641 static int
 642 ParseClearPath(void *path, void *dummy __unused)
 643 {
 644
 645     Dir_ClearPath(path);
 646     return (0);
 647 }
 648
 649 /*-
 650  *---------------------------------------------------------------------
 651  * ParseDoDependency  --
 652  *      Parse the dependency line in line.
 653  *
 654  * Results:
 655  *      None
 656  *
 657  * Side Effects:
 658  *      The nodes of the sources are linked as children to the nodes of the
 659  *      targets. Some nodes may be created.
 660  *
 661  *      We parse a dependency line by first extracting words from the line and
 662  * finding nodes in the list of all targets with that name. This is done
 663  * until a character is encountered which is an operator character. Currently
 664  * these are only ! and :. At this point the operator is parsed and the
 665  * pointer into the line advanced until the first source is encountered.
 666  *      The parsed operator is applied to each node in the 'targets' list,
 667  * which is where the nodes found for the targets are kept, by means of
 668  * the ParseDoOp function.
 669  *      The sources are read in much the same way as the targets were except
 670  * that now they are expanded using the wildcarding scheme of the C-Shell
 671  * and all instances of the resulting words in the list of all targets
 672  * are found. Each of the resulting nodes is then linked to each of the
 673  * targets as one of its children.
 674  *      Certain targets are handled specially. These are the ones detailed
 675  * by the specType variable.
 676  *      The storing of transformation rules is also taken care of here.
 677  * A target is recognized as a transformation rule by calling
 678  * Suff_IsTransform. If it is a transformation rule, its node is gotten
 679  * from the suffix module via Suff_AddTransform rather than the standard
 680  * Targ_FindNode in the target module.
 681  *---------------------------------------------------------------------
 682  */
 683 static void
 684 ParseDoDependency(char *line)
 685 {
 686     char           *cp;         /* our current position */
 687     GNode          *gn;         /* a general purpose temporary node */
 688     int             op;         /* the operator on the line */
 689     char            savec;      /* a place to save a character */
 690     Lst paths;  /* Search paths to alter when parsing a list of .PATH targets */
 691     int             tOp;        /* operator from special target */
 692
 693     tOp = 0;
 694
 695     specType = Not;
 696     waiting = 0;
 697     Lst_Init(&paths);
 698
 699     do {
 700         for (cp = line;
 701             *cp && !isspace((unsigned char)*cp) && *cp != '(';
 702             cp++)
 703         {
 704             if (*cp == '$') {
 705                 /*
 706                  * Must be a dynamic source (would have been expanded
 707                  * otherwise), so call the Var module to parse the puppy
 708                  * so we can safely advance beyond it...There should be
 709                  * no errors in this, as they would have been discovered
 710                  * in the initial Var_Subst and we wouldn't be here.
 711                  */
 712                 size_t length;
 713                 Boolean freeIt;
 714                 char    *result;
 715
 716                 result = Var_Parse(cp, VAR_CMD, TRUE, &length, &freeIt);
 717
 718                 if (freeIt) {
 719                     free(result);
 720                 }
 721                 cp += length - 1;
 722             } else if (*cp == '!' || *cp == ':') {
 723                 /*
 724                  * We don't want to end a word on ':' or '!' if there is a
 725                  * better match later on in the string (greedy matching).
 726                  * This allows the user to have targets like:
 727                  *    fie::fi:fo: fum
 728                  *    foo::bar:
 729                  * where "fie::fi:fo" and "foo::bar" are the targets.  In
 730                  * real life this is used for perl5 library man pages where
 731                  * "::" separates an object from its class.
 732                  * Ie: "File::Spec::Unix".  This behaviour is also consistent
 733                  * with other versions of make.
 734                  */
 735                 char *p = cp + 1;
 736
 737                 if (*cp == ':' && *p == ':')
 738                     p++;
 739
 740                 /* Found the best match already. */
 741                 if (*p == '\0' || isspace(*p))
 742                     break;
 743
 744                 p += strcspn(p, "!:");
 745
 746                 /* No better match later on... */
 747                 if (*p == '\0')
 748                     break;
 749             }
 750             continue;
 751         }
 752         if (*cp == '(') {
 753             /*
 754              * Archives must be handled specially to make sure the OP_ARCHV
 755              * flag is set in their 'type' field, for one thing, and because
 756              * things like "archive(file1.o file2.o file3.o)" are permissible.
 757              * Arch_ParseArchive will set 'line' to be the first non-blank
 758              * after the archive-spec. It creates/finds nodes for the members
 759              * and places them on the given list, returning SUCCESS if all
 760              * went well and FAILURE if there was an error in the
 761              * specification. On error, line should remain untouched.
 762              */
 763             if (Arch_ParseArchive(&line, &targets, VAR_CMD) != SUCCESS) {
 764                 Parse_Error(PARSE_FATAL,
 765                              "Error in archive specification: \"%s\"", line);
 766                 return;
 767             } else {
 768                 continue;
 769             }
 770         }
 771         savec = *cp;
 772
 773         if (!*cp) {
 774             /*
 775              * Ending a dependency line without an operator is a Bozo
 776              * no-no.  As a heuristic, this is also often triggered by
 777              * undetected conflicts from cvs/rcs merges.
 778              */
 779             if ((strncmp(line, "<<<<<<", 6) == 0) ||
 780                 (strncmp(line, "======", 6) == 0) ||
 781                 (strncmp(line, ">>>>>>", 6) == 0))
 782                 Parse_Error(PARSE_FATAL,
 783                     "Makefile appears to contain unresolved cvs/rcs/??? merge conflicts");
 784             else
 785                 Parse_Error(PARSE_FATAL, "Need an operator");
 786             return;
 787         }
 788         *cp = '\0';
 789         /*
 790          * Have a word in line. See if it's a special target and set
 791          * specType to match it.
 792          */
 793         if (*line == '.' && isupper((unsigned char)line[1])) {
 794             /*
 795              * See if the target is a special target that must have it
 796              * or its sources handled specially.
 797              */
 798             int keywd = ParseFindKeyword(line);
 799             if (keywd != -1) {
 800                 if (specType == ExPath && parseKeywords[keywd].spec != ExPath) {
 801                     Parse_Error(PARSE_FATAL, "Mismatched special targets");
 802                     return;
 803                 }
 804
 805                 specType = parseKeywords[keywd].spec;
 806                 tOp = parseKeywords[keywd].op;
 807
 808                 /*
 809                  * Certain special targets have special semantics:
 810                  *      .PATH           Have to set the dirSearchPath
 811                  *                      variable too
 812                  *      .MAIN           Its sources are only used if
 813                  *                      nothing has been specified to
 814                  *                      create.
 815                  *      .DEFAULT        Need to create a node to hang
 816                  *                      commands on, but we don't want
 817                  *                      it in the graph, nor do we want
 818                  *                      it to be the Main Target, so we
 819                  *                      create it, set OP_NOTMAIN and
 820                  *                      add it to the list, setting
 821                  *                      DEFAULT to the new node for
 822                  *                      later use. We claim the node is
 823                  *                      A transformation rule to make
 824                  *                      life easier later, when we'll
 825                  *                      use Make_HandleUse to actually
 826                  *                      apply the .DEFAULT commands.
 827                  *      .PHONY          The list of targets
 828                  *      .BEGIN
 829                  *      .END
 830                  *      .INTERRUPT      Are not to be considered the
 831                  *                      main target.
 832                  *      .NOTPARALLEL    Make only one target at a time.
 833                  *      .SINGLESHELL    Create a shell for each command.
 834                  *      .ORDER          Must set initial predecessor to NULL
 835                  */
 836                 switch (specType) {
 837                     case ExPath:
 838                         Lst_AtEnd(&paths, &dirSearchPath);
 839                         break;
 840                     case Main:
 841                         if (!Lst_IsEmpty(&create)) {
 842                             specType = Not;
 843                         }
 844                         break;
 845                     case Begin:
 846                     case End:
 847                     case Interrupt:
 848                         gn = Targ_FindNode(line, TARG_CREATE);
 849                         gn->type |= OP_NOTMAIN;
 850                         Lst_AtEnd(&targets, gn);
 851                         break;
 852                     case Default:
 853                         gn = Targ_NewGN(".DEFAULT");
 854                         gn->type |= (OP_NOTMAIN|OP_TRANSFORM);
 855                         Lst_AtEnd(&targets, gn);
 856                         DEFAULT = gn;
 857                         break;
 858                     case NotParallel:
 859                     {
 860                         maxJobs = 1;
 861                         break;
 862                     }
 863                     case SingleShell:
 864                         compatMake = 1;
 865                         break;
 866                     case Order:
 867                         predecessor = NULL;
 868                         break;
 869                     default:
 870                         break;
 871                 }
 872             } else if (strncmp(line, ".PATH", 5) == 0) {
 873                 /*
 874                  * .PATH<suffix> has to be handled specially.
 875                  * Call on the suffix module to give us a path to
 876                  * modify.
 877                  */
 878                 Lst *path;
 879
 880                 specType = ExPath;
 881                 path = Suff_GetPath(&line[5]);
 882                 if (path == NULL) {
 883                     Parse_Error(PARSE_FATAL,
 884                                  "Suffix '%s' not defined (yet)",
 885                                  &line[5]);
 886                     return;
 887                 } else
 888                     Lst_AtEnd(&paths, path);
 889             }
 890         }
 891
 892         /*
 893          * Have word in line. Get or create its node and stick it at
 894          * the end of the targets list
 895          */
 896         if ((specType == Not) && (*line != '\0')) {
 897             /* target names to be found and added to targets list */
 898             Lst curTargs = Lst_Initializer(curTargs);
 899
 900             if (Dir_HasWildcards(line)) {
 901                 /*
 902                  * Targets are to be sought only in the current directory,
 903                  * so create an empty path for the thing. Note we need to
 904                  * use Dir_Destroy in the destruction of the path as the
 905                  * Dir module could have added a directory to the path...
 906                  */
 907                 Lst emptyPath = Lst_Initializer(emptyPath);
 908
 909                 Dir_Expand(line, &emptyPath, &curTargs);
 910
 911                 Lst_Destroy(&emptyPath, Dir_Destroy);
 912             } else {
 913                 /*
 914                  * No wildcards, but we want to avoid code duplication,
 915                  * so create a list with the word on it.
 916                  */
 917                 Lst_AtEnd(&curTargs, line);
 918             }
 919
 920             while (!Lst_IsEmpty(&curTargs)) {
 921                 char    *targName = Lst_DeQueue(&curTargs);
 922
 923                 if (!Suff_IsTransform (targName)) {
 924                     gn = Targ_FindNode(targName, TARG_CREATE);
 925                 } else {
 926                     gn = Suff_AddTransform(targName);
 927                 }
 928
 929                 Lst_AtEnd(&targets, gn);
 930             }
 931         } else if (specType == ExPath && *line != '.' && *line != '\0') {
 932             Parse_Error(PARSE_WARNING, "Extra target (%s) ignored", line);
 933         }
 934
 935         *cp = savec;
 936         /*
 937          * If it is a special type and not .PATH, it's the only target we
 938          * allow on this line...
 939          */
 940         if (specType != Not && specType != ExPath) {
 941             Boolean warnFlag = FALSE;
 942
 943             while ((*cp != '!') && (*cp != ':') && *cp) {
 944                 if (*cp != ' ' && *cp != '\t') {
 945                     warnFlag = TRUE;
 946                 }
 947                 cp++;
 948             }
 949             if (warnFlag) {
 950                 Parse_Error(PARSE_WARNING, "Extra target ignored");
 951             }
 952         } else {
 953             while (*cp && isspace((unsigned char)*cp)) {
 954                 cp++;
 955             }
 956         }
 957         line = cp;
 958     } while ((*line != '!') && (*line != ':') && *line);
 959
 960     if (!Lst_IsEmpty(&targets)) {
 961         switch (specType) {
 962             default:
 963                 Parse_Error(PARSE_WARNING, "Special and mundane targets don't mix. Mundane ones ignored");
 964                 break;
 965             case Default:
 966             case Begin:
 967             case End:
 968             case Interrupt:
 969                 /*
 970                  * These four create nodes on which to hang commands, so
 971                  * targets shouldn't be empty...
 972                  */
 973             case Not:
 974                 /*
 975                  * Nothing special here -- targets can be empty if it wants.
 976                  */
 977                 break;
 978         }
 979     }
 980
 981     /*
 982      * Have now parsed all the target names. Must parse the operator next. The
 983      * result is left in  op .
 984      */
 985     if (*cp == '!') {
 986         op = OP_FORCE;
 987     } else if (*cp == ':') {
 988         if (cp[1] == ':') {
 989             op = OP_DOUBLEDEP;
 990             cp++;
 991         } else {
 992             op = OP_DEPENDS;
 993         }
 994     } else {
 995         Parse_Error(PARSE_FATAL, "Missing dependency operator");
 996         return;
 997     }
 998
 999     cp++;                       /* Advance beyond operator */
1000
1001     Lst_ForEach(&targets, ParseDoOp, &op);
1002
1003     /*
1004      * Get to the first source
1005      */
1006     while (*cp && isspace((unsigned char)*cp)) {
1007         cp++;
1008     }
1009     line = cp;
1010
1011     /*
1012      * Several special targets take different actions if present with no
1013      * sources:
1014      *  a .SUFFIXES line with no sources clears out all old suffixes
1015      *  a .PRECIOUS line makes all targets precious
1016      *  a .IGNORE line ignores errors for all targets
1017      *  a .SILENT line creates silence when making all targets
1018      *  a .PATH removes all directories from the search path(s).
1019      */
1020     if (!*line) {
1021         switch (specType) {
1022             case Suffixes:
1023                 Suff_ClearSuffixes();
1024                 break;
1025             case Precious:
1026                 allPrecious = TRUE;
1027                 break;
1028             case Ignore:
1029                 ignoreErrors = TRUE;
1030                 break;
1031             case Silent:
1032                 beSilent = TRUE;
1033                 break;
1034             case ExPath:
1035                 Lst_ForEach(&paths, ParseClearPath, NULL);
1036                 break;
1037             case Posix:
1038                 Var_Set("%POSIX", "1003.2", VAR_GLOBAL);
1039                 break;
1040             default:
1041                 break;
1042         }
1043     } else if (specType == MFlags) {
1044         /*
1045          * Call on functions in main.c to deal with these arguments and
1046          * set the initial character to a null-character so the loop to
1047          * get sources won't get anything
1048          */
1049         Main_ParseArgLine(line);
1050         *line = '\0';
1051     } else if (specType == ExShell) {
1052         if (Job_ParseShell(line) != SUCCESS) {
1053             Parse_Error(PARSE_FATAL, "improper shell specification");
1054             return;
1055         }
1056         *line = '\0';
1057     } else if ((specType == NotParallel) || (specType == SingleShell)) {
1058         *line = '\0';
1059     }
1060
1061     /*
1062      * NOW GO FOR THE SOURCES
1063      */
1064     if ((specType == Suffixes) || (specType == ExPath) ||
1065         (specType == Includes) || (specType == Libs) ||
1066         (specType == Null))
1067     {
1068         while (*line) {
1069             /*
1070              * If the target was one that doesn't take files as its sources
1071              * but takes something like suffixes, we take each
1072              * space-separated word on the line as a something and deal
1073              * with it accordingly.
1074              *
1075              * If the target was .SUFFIXES, we take each source as a
1076              * suffix and add it to the list of suffixes maintained by the
1077              * Suff module.
1078              *
1079              * If the target was a .PATH, we add the source as a directory
1080              * to search on the search path.
1081              *
1082              * If it was .INCLUDES, the source is taken to be the suffix of
1083              * files which will be #included and whose search path should
1084              * be present in the .INCLUDES variable.
1085              *
1086              * If it was .LIBS, the source is taken to be the suffix of
1087              * files which are considered libraries and whose search path
1088              * should be present in the .LIBS variable.
1089              *
1090              * If it was .NULL, the source is the suffix to use when a file
1091              * has no valid suffix.
1092              */
1093             char  savech;
1094             while (*cp && !isspace((unsigned char)*cp)) {
1095                 cp++;
1096             }
1097             savech = *cp;
1098             *cp = '\0';
1099             switch (specType) {
1100                 case Suffixes:
1101                     Suff_AddSuffix(line);
1102                     break;
1103                 case ExPath:
1104                     Lst_ForEach(&paths, ParseAddDir, line);
1105                     break;
1106                 case Includes:
1107                     Suff_AddInclude(line);
1108                     break;
1109                 case Libs:
1110                     Suff_AddLib(line);
1111                     break;
1112                 case Null:
1113                     Suff_SetNull(line);
1114                     break;
1115                 default:
1116                     break;
1117             }
1118             *cp = savech;
1119             if (savech != '\0') {
1120                 cp++;
1121             }
1122             while (*cp && isspace((unsigned char)*cp)) {
1123                 cp++;
1124             }
1125             line = cp;
1126         }
1127         Lst_Destroy(&paths, NOFREE);
1128
1129     } else {
1130         Lst curSrcs = Lst_Initializer(curSrc);  /* list of sources in order */
1131
1132         while (*line) {
1133             /*
1134              * The targets take real sources, so we must beware of archive
1135              * specifications (i.e. things with left parentheses in them)
1136              * and handle them accordingly.
1137              */
1138             while (*cp && !isspace((unsigned char)*cp)) {
1139                 if ((*cp == '(') && (cp > line) && (cp[-1] != '$')) {
1140                     /*
1141                      * Only stop for a left parenthesis if it isn't at the
1142                      * start of a word (that'll be for variable changes
1143                      * later) and isn't preceded by a dollar sign (a dynamic
1144                      * source).
1145                      */
1146                     break;
1147                 } else {
1148                     cp++;
1149                 }
1150             }
1151
1152             if (*cp == '(') {
1153                 GNode     *gnp;
1154                 /* list of archive source names after expansion */
1155                 Lst sources = Lst_Initializer(sources);
1156
1157                 if (Arch_ParseArchive(&line, &sources, VAR_CMD) != SUCCESS) {
1158                     Parse_Error(PARSE_FATAL,
1159                                  "Error in source archive spec \"%s\"", line);
1160                     return;
1161                 }
1162
1163                 while (!Lst_IsEmpty(&sources)) {
1164                     gnp = Lst_DeQueue(&sources);
1165                     ParseDoSrc(tOp, gnp->name, &curSrcs);
1166                 }
1167                 cp = line;
1168             } else {
1169                 if (*cp) {
1170                     *cp = '\0';
1171                     cp += 1;
1172                 }
1173
1174                 ParseDoSrc(tOp, line, &curSrcs);
1175             }
1176             while (*cp && isspace((unsigned char)*cp)) {
1177                 cp++;
1178             }
1179             line = cp;
1180         }
1181         Lst_Destroy(&curSrcs, NOFREE);
1182     }
1183
1184     if (mainNode == NULL) {
1185         /*
1186          * If we have yet to decide on a main target to make, in the
1187          * absence of any user input, we want the first target on
1188          * the first dependency line that is actually a real target
1189          * (i.e. isn't a .USE or .EXEC rule) to be made.
1190          */
1191         Lst_ForEach(&targets, ParseFindMain, NULL);
1192     }
1193 }
1194
1195 /*-
1196  *---------------------------------------------------------------------
1197  * Parse_IsVar  --
1198  *      Return TRUE if the passed line is a variable assignment. A variable
1199  *      assignment consists of a single word followed by optional whitespace
1200  *      followed by either a += or an = operator.
1201  *      This function is used both by the Parse_File function and main when
1202  *      parsing the command-line arguments.
1203  *
1204  * Results:
1205  *      TRUE if it is. FALSE if it ain't
1206  *
1207  * Side Effects:
1208  *      none
1209  *---------------------------------------------------------------------
1210  */
1211 Boolean
1212 Parse_IsVar(char *line)
1213 {
1214     Boolean wasSpace = FALSE;   /* set TRUE if found a space */
1215     Boolean haveName = FALSE;   /* Set TRUE if have a variable name */
1216
1217     int level = 0;
1218 #define ISEQOPERATOR(c) \
1219         (((c) == '+') || ((c) == ':') || ((c) == '?') || ((c) == '!'))
1220
1221     /*
1222      * Skip to variable name
1223      */
1224     for (; (*line == ' ') || (*line == '\t'); line++)
1225         continue;
1226
1227     for (; *line != '=' || level != 0; line++)
1228         switch (*line) {
1229         case '\0':
1230             /*
1231              * end-of-line -- can't be a variable assignment.
1232              */
1233             return (FALSE);
1234
1235         case ' ':
1236         case '\t':
1237             /*
1238              * there can be as much white space as desired so long as there is
1239              * only one word before the operator
1240              */
1241             wasSpace = TRUE;
1242             break;
1243
1244         case '(':
1245         case '{':
1246             level++;
1247             break;
1248
1249         case '}':
1250         case ')':
1251             level--;
1252             break;
1253
1254         default:
1255             if (wasSpace && haveName) {
1256                     if (ISEQOPERATOR(*line)) {
1257                         /*
1258                          * We must have a finished word
1259                          */
1260                         if (level != 0)
1261                             return (FALSE);
1262
1263                         /*
1264                          * When an = operator [+?!:] is found, the next
1265                          * character must be an = or it ain't a valid
1266                          * assignment.
1267                          */
1268                         if (line[1] == '=')
1269                             return (haveName);
1270 #ifdef SUNSHCMD
1271                         /*
1272                          * This is a shell command
1273                          */
1274                         if (strncmp(line, ":sh", 3) == 0)
1275                             return (haveName);
1276 #endif
1277                     }
1278                     /*
1279                      * This is the start of another word, so not assignment.
1280                      */
1281                     return (FALSE);
1282             }
1283             else {
1284                 haveName = TRUE;
1285                 wasSpace = FALSE;
1286             }
1287             break;
1288         }
1289
1290     return (haveName);
1291 }
1292
1293 /*-
1294  *---------------------------------------------------------------------
1295  * Parse_DoVar  --
1296  *      Take the variable assignment in the passed line and do it in the
1297  *      global context.
1298  *
1299  *      Note: There is a lexical ambiguity with assignment modifier characters
1300  *      in variable names. This routine interprets the character before the =
1301  *      as a modifier. Therefore, an assignment like
1302  *          C++=/usr/bin/CC
1303  *      is interpreted as "C+ +=" instead of "C++ =".
1304  *
1305  * Results:
1306  *      none
1307  *
1308  * Side Effects:
1309  *      the variable structure of the given variable name is altered in the
1310  *      global context.
1311  *---------------------------------------------------------------------
1312  */
1313 void
1314 Parse_DoVar(char *line, GNode *ctxt)
1315 {
1316     char           *cp; /* pointer into line */
1317     enum {
1318         VAR_SUBST, VAR_APPEND, VAR_SHELL, VAR_NORMAL
1319     }               type;       /* Type of assignment */
1320     char            *opc;       /* ptr to operator character to
1321                                  * null-terminate the variable name */
1322     /*
1323      * Avoid clobbered variable warnings by forcing the compiler
1324      * to ``unregister'' variables
1325      */
1326 #if __GNUC__
1327     (void)&cp;
1328     (void)&line;
1329 #endif
1330
1331     /*
1332      * Skip to variable name
1333      */
1334     while ((*line == ' ') || (*line == '\t')) {
1335         line++;
1336     }
1337
1338     /*
1339      * Skip to operator character, nulling out whitespace as we go
1340      */
1341     for (cp = line + 1; *cp != '='; cp++) {
1342         if (isspace((unsigned char)*cp)) {
1343             *cp = '\0';
1344         }
1345     }
1346     opc = cp - 1;       /* operator is the previous character */
1347     *cp++ = '\0';       /* nuke the = */
1348
1349     /*
1350      * Check operator type
1351      */
1352     switch (*opc) {
1353         case '+':
1354             type = VAR_APPEND;
1355             *opc = '\0';
1356             break;
1357
1358         case '?':
1359             /*
1360              * If the variable already has a value, we don't do anything.
1361              */
1362             *opc = '\0';
1363             if (Var_Exists(line, ctxt)) {
1364                 return;
1365             } else {
1366                 type = VAR_NORMAL;
1367             }
1368             break;
1369
1370         case ':':
1371             type = VAR_SUBST;
1372             *opc = '\0';
1373             break;
1374
1375         case '!':
1376             type = VAR_SHELL;
1377             *opc = '\0';
1378             break;
1379
1380         default:
1381 #ifdef SUNSHCMD
1382             while (*opc != ':')
1383                 if (opc == line)
1384                     break;
1385                 else
1386                     --opc;
1387
1388             if (strncmp(opc, ":sh", 3) == 0) {
1389                 type = VAR_SHELL;
1390                 *opc = '\0';
1391                 break;
1392             }
1393 #endif
1394             type = VAR_NORMAL;
1395             break;
1396     }
1397
1398     while (isspace((unsigned char)*cp)) {
1399         cp++;
1400     }
1401
1402     if (type == VAR_APPEND) {
1403         Var_Append(line, cp, ctxt);
1404     } else if (type == VAR_SUBST) {
1405         /*
1406          * Allow variables in the old value to be undefined, but leave their
1407          * invocation alone -- this is done by forcing oldVars to be false.
1408          * XXX: This can cause recursive variables, but that's not hard to do,
1409          * and this allows someone to do something like
1410          *
1411          *  CFLAGS = $(.INCLUDES)
1412          *  CFLAGS := -I.. $(CFLAGS)
1413          *
1414          * And not get an error.
1415          */
1416         Boolean   oldOldVars = oldVars;
1417
1418         oldVars = FALSE;
1419
1420         /*
1421          * make sure that we set the variable the first time to nothing
1422          * so that it gets substituted!
1423          */
1424         if (!Var_Exists(line, ctxt))
1425             Var_Set(line, "", ctxt);
1426
1427         cp = Var_Subst(NULL, cp, ctxt, FALSE);
1428         oldVars = oldOldVars;
1429
1430         Var_Set(line, cp, ctxt);
1431         free(cp);
1432     } else if (type == VAR_SHELL) {
1433         Boolean freeCmd = FALSE; /* TRUE if the command needs to be freed, i.e.
1434                                   * if any variable expansion was performed */
1435         char            *res;
1436         const char      *error;
1437
1438         if (strchr(cp, '$') != NULL) {
1439             /*
1440              * There's a dollar sign in the command, so perform variable
1441              * expansion on the whole thing. The resulting string will need
1442              * freeing when we're done, so set freeCmd to TRUE.
1443              */
1444             cp = Var_Subst(NULL, cp, VAR_CMD, TRUE);
1445             freeCmd = TRUE;
1446         }
1447
1448         res = Cmd_Exec(cp, &error);
1449         Var_Set(line, res, ctxt);
1450         free(res);
1451
1452         if (error)
1453             Parse_Error(PARSE_WARNING, error, cp);
1454
1455         if (freeCmd)
1456             free(cp);
1457     } else {
1458         /*
1459          * Normal assignment -- just do it.
1460          */
1461         Var_Set(line, cp, ctxt);
1462     }
1463 }
1464
1465 /*-
1466  * ParseAddCmd  --
1467  *      Lst_ForEach function to add a command line to all targets
1468  *
1469  * Results:
1470  *      Always 0
1471  *
1472  * Side Effects:
1473  *      A new element is added to the commands list of the node.
1474  */
1475 static int
1476 ParseAddCmd(void *gnp, void *cmd)
1477 {
1478     GNode *gn = gnp;
1479
1480     /* if target already supplied, ignore commands */
1481     if (!(gn->type & OP_HAS_COMMANDS))
1482         Lst_AtEnd(&gn->commands, cmd);
1483     else
1484         Parse_Error(PARSE_WARNING,
1485                     "duplicate script for target \"%s\" ignored",
1486                     gn->name);
1487     return (0);
1488 }
1489
1490 /*-
1491  *-----------------------------------------------------------------------
1492  * ParseHasCommands --
1493  *      Callback procedure for Parse_File when destroying the list of
1494  *      targets on the last dependency line. Marks a target as already
1495  *      having commands if it does, to keep from having shell commands
1496  *      on multiple dependency lines.
1497  *
1498  * Results:
1499  *      None
1500  *
1501  * Side Effects:
1502  *      OP_HAS_COMMANDS may be set for the target.
1503  *
1504  *-----------------------------------------------------------------------
1505  */
1506 static void
1507 ParseHasCommands(void *gnp)
1508 {
1509     GNode *gn = gnp;
1510
1511     if (!Lst_IsEmpty(&gn->commands)) {
1512         gn->type |= OP_HAS_COMMANDS;
1513     }
1514 }
1515
1516 /*-
1517  *-----------------------------------------------------------------------
1518  * Parse_AddIncludeDir --
1519  *      Add a directory to the path searched for included makefiles
1520  *      bracketed by double-quotes. Used by functions in main.c
1521  *
1522  * Results:
1523  *      None.
1524  *
1525  * Side Effects:
1526  *      The directory is appended to the list.
1527  *
1528  *-----------------------------------------------------------------------
1529  */
1530 void
1531 Parse_AddIncludeDir(char *dir)
1532 {
1533
1534     Dir_AddDir(&parseIncPath, dir);
1535 }
1536
1537 /*---------------------------------------------------------------------
1538  * ParseDoError  --
1539  *      Handle error directive
1540  *
1541  *      The input is the line minus the ".error".  We substitute variables,
1542  *      print the message and exit(1) or just print a warning if the ".error"
1543  *      directive is malformed.
1544  *
1545  *---------------------------------------------------------------------
1546  */
1547 static void
1548 ParseDoError(char *errmsg)
1549 {
1550
1551         if (!isspace((unsigned char)*errmsg)) {
1552                 Parse_Error(PARSE_WARNING, "invalid syntax: .error%s", errmsg);
1553                 return;
1554         }
1555
1556         while (isspace((unsigned char)*errmsg))
1557                 errmsg++;
1558
1559         errmsg = Var_Subst(NULL, errmsg, VAR_GLOBAL, FALSE);
1560
1561         Parse_Error(PARSE_FATAL, "%s", errmsg);
1562         /* Terminate immediately. */
1563         exit(1);
1564 }
1565
1566 /*---------------------------------------------------------------------
1567  * ParseDoWarning  --
1568  *      Handle warning directive
1569  *
1570  *      The input is the line minus the ".warning".  We substitute variables
1571  *      and print the message or just print a warning if the ".warning"
1572  *      directive is malformed.
1573  *
1574  *---------------------------------------------------------------------
1575  */
1576 static void
1577 ParseDoWarning(char *warnmsg)
1578 {
1579
1580         if (!isspace((unsigned char)*warnmsg)) {
1581                 Parse_Error(PARSE_WARNING, "invalid syntax: .warning%s",
1582                     warnmsg);
1583                 return;
1584         }
1585
1586         while (isspace((unsigned char)*warnmsg))
1587                 warnmsg++;
1588
1589         warnmsg = Var_Subst(NULL, warnmsg, VAR_GLOBAL, FALSE);
1590
1591         Parse_Error(PARSE_WARNING, "%s", warnmsg);
1592 }
1593
1594 /*-
1595  *---------------------------------------------------------------------
1596  * ParseDoInclude  --
1597  *      Push to another file.
1598  *
1599  *      The input is the line minus the #include. A file spec is a string
1600  *      enclosed in <> or "". The former is looked for only in sysIncPath.
1601  *      The latter in . and the directories specified by -I command line
1602  *      options
1603  *
1604  * Results:
1605  *      None
1606  *
1607  * Side Effects:
1608  *      A structure is added to the includes Lst and readProc, curFile.lineno,
1609  *      curFile.fname and curFile.F are altered for the new file
1610  *---------------------------------------------------------------------
1611  */
1612 static void
1613 ParseDoInclude(char *file)
1614 {
1615     char          *fullname;    /* full pathname of file */
1616     IFile         *oldFile;     /* state associated with current file */
1617     char          endc;         /* the character which ends the file spec */
1618     char          *cp;          /* current position in file spec */
1619     Boolean       isSystem;     /* TRUE if makefile is a system makefile */
1620
1621     /*
1622      * Skip to delimiter character so we know where to look
1623      */
1624     while ((*file == ' ') || (*file == '\t')) {
1625         file++;
1626     }
1627
1628     if ((*file != '"') && (*file != '<')) {
1629         Parse_Error(PARSE_FATAL,
1630             ".include filename must be delimited by '\"' or '<'");
1631         return;
1632     }
1633
1634     /*
1635      * Set the search path on which to find the include file based on the
1636      * characters which bracket its name. Angle-brackets imply it's
1637      * a system Makefile while double-quotes imply it's a user makefile
1638      */
1639     if (*file == '<') {
1640         isSystem = TRUE;
1641         endc = '>';
1642     } else {
1643         isSystem = FALSE;
1644         endc = '"';
1645     }
1646
1647     /*
1648      * Skip to matching delimiter
1649      */
1650     for (cp = ++file; *cp && *cp != endc; cp++) {
1651         continue;
1652     }
1653
1654     if (*cp != endc) {
1655         Parse_Error(PARSE_FATAL,
1656                      "Unclosed %cinclude filename. '%c' expected",
1657                      '.', endc);
1658         return;
1659     }
1660     *cp = '\0';
1661
1662     /*
1663      * Substitute for any variables in the file name before trying to
1664      * find the thing.
1665      */
1666     file = Var_Subst(NULL, file, VAR_CMD, FALSE);
1667
1668     /*
1669      * Now we know the file's name and its search path, we attempt to
1670      * find the durn thing. A return of NULL indicates the file don't
1671      * exist.
1672      */
1673     if (!isSystem) {
1674         /*
1675          * Include files contained in double-quotes are first searched for
1676          * relative to the including file's location. We don't want to
1677          * cd there, of course, so we just tack on the old file's
1678          * leading path components and call Dir_FindFile to see if
1679          * we can locate the beast.
1680          */
1681         char      *prefEnd, *Fname;
1682
1683         /* Make a temporary copy of this, to be safe. */
1684         Fname = estrdup(curFile.fname);
1685
1686         prefEnd = strrchr(Fname, '/');
1687         if (prefEnd != (char *)NULL) {
1688             char        *newName;
1689
1690             *prefEnd = '\0';
1691             if (file[0] == '/')
1692                 newName = estrdup(file);
1693             else
1694                 newName = str_concat(Fname, file, STR_ADDSLASH);
1695             fullname = Dir_FindFile(newName, &parseIncPath);
1696             if (fullname == NULL) {
1697                 fullname = Dir_FindFile(newName, &dirSearchPath);
1698             }
1699             free(newName);
1700             *prefEnd = '/';
1701         } else {
1702             fullname = NULL;
1703         }
1704         free(Fname);
1705     } else {
1706         fullname = NULL;
1707     }
1708
1709     if (fullname == NULL) {
1710         /*
1711          * System makefile or makefile wasn't found in same directory as
1712          * included makefile. Search for it first on the -I search path,
1713          * then on the .PATH search path, if not found in a -I directory.
1714          * XXX: Suffix specific?
1715          */
1716         fullname = Dir_FindFile(file, &parseIncPath);
1717         if (fullname == NULL) {
1718             fullname = Dir_FindFile(file, &dirSearchPath);
1719         }
1720     }
1721
1722     if (fullname == NULL) {
1723         /*
1724          * Still haven't found the makefile. Look for it on the system
1725          * path as a last resort.
1726          */
1727         fullname = Dir_FindFile(file, &sysIncPath);
1728     }
1729
1730     if (fullname == NULL) {
1731         *cp = endc;
1732         Parse_Error(PARSE_FATAL, "Could not find %s", file);
1733         return;
1734     }
1735
1736     free(file);
1737
1738     /*
1739      * Once we find the absolute path to the file, we get to save all the
1740      * state from the current file before we can start reading this
1741      * include file. The state is stored in an IFile structure which
1742      * is placed on a list with other IFile structures. The list makes
1743      * a very nice stack to track how we got here...
1744      */
1745     oldFile = emalloc(sizeof(IFile));
1746     memcpy(oldFile, &curFile, sizeof(IFile));
1747
1748     Lst_AtFront(&includes, oldFile);
1749
1750     /*
1751      * Once the previous state has been saved, we can get down to reading
1752      * the new file. We set up the name of the file to be the absolute
1753      * name of the include file so error messages refer to the right
1754      * place. Naturally enough, we start reading at line number 0.
1755      */
1756     curFile.fname = fullname;
1757     curFile.lineno = 0;
1758
1759     curFile.F = fopen(fullname, "r");
1760     curFile.p = NULL;
1761     if (curFile.F == NULL) {
1762         Parse_Error(PARSE_FATAL, "Cannot open %s", fullname);
1763         /*
1764          * Pop to previous file
1765          */
1766         ParseEOF(0);
1767     } else {
1768         Var_Append(".MAKEFILE_LIST", fullname, VAR_GLOBAL);
1769     }
1770 }
1771
1772 /*-
1773  *---------------------------------------------------------------------
1774  * Parse_FromString  --
1775  *      Start Parsing from the given string
1776  *
1777  * Results:
1778  *      None
1779  *
1780  * Side Effects:
1781  *      A structure is added to the includes Lst and readProc, curFile.lineno,
1782  *      curFile.fname and curFile.F are altered for the new file
1783  *---------------------------------------------------------------------
1784  */
1785 void
1786 Parse_FromString(char *str, int lineno)
1787 {
1788     IFile         *oldFile;     /* state associated with this file */
1789
1790     DEBUGF(FOR, ("%s\n---- at line %d\n", str, lineno));
1791
1792     oldFile = emalloc(sizeof(IFile));
1793     memcpy(oldFile, &curFile, sizeof(IFile));
1794
1795     Lst_AtFront(&includes, oldFile);
1796
1797     curFile.F = NULL;
1798     curFile.p = emalloc(sizeof(PTR));
1799     curFile.p->str = curFile.p->ptr = str;
1800     curFile.lineno = lineno;
1801     curFile.fname = estrdup(curFile.fname);
1802 }
1803
1804 #ifdef SYSVINCLUDE
1805 /*-
1806  *---------------------------------------------------------------------
1807  * ParseTraditionalInclude  --
1808  *      Push to another file.
1809  *
1810  *      The input is the line minus the "include".  The file name is
1811  *      the string following the "include".
1812  *
1813  * Results:
1814  *      None
1815  *
1816  * Side Effects:
1817  *      A structure is added to the includes Lst and readProc, curFile.lineno,
1818  *      curFile.fname and curFile.F are altered for the new file
1819  *---------------------------------------------------------------------
1820  */
1821 static void
1822 ParseTraditionalInclude(char *file)
1823 {
1824     char          *fullname;    /* full pathname of file */
1825     IFile         *oldFile;     /* state associated with current file */
1826     char          *cp;          /* current position in file spec */
1827
1828     /*
1829      * Skip over whitespace
1830      */
1831     while ((*file == ' ') || (*file == '\t')) {
1832         file++;
1833     }
1834
1835     if (*file == '\0') {
1836         Parse_Error(PARSE_FATAL,
1837                      "Filename missing from \"include\"");
1838         return;
1839     }
1840
1841     /*
1842      * Skip to end of line or next whitespace
1843      */
1844     for (cp = file; *cp && *cp != '\n' && *cp != '\t' && *cp != ' '; cp++) {
1845         continue;
1846     }
1847
1848     *cp = '\0';
1849
1850     /*
1851      * Substitute for any variables in the file name before trying to
1852      * find the thing.
1853      */
1854     file = Var_Subst(NULL, file, VAR_CMD, FALSE);
1855
1856     /*
1857      * Now we know the file's name, we attempt to find the durn thing.
1858      * Search for it first on the -I search path, then on the .PATH
1859      * search path, if not found in a -I directory.
1860      */
1861     fullname = Dir_FindFile(file, &parseIncPath);
1862     if (fullname == NULL) {
1863         fullname = Dir_FindFile(file, &dirSearchPath);
1864     }
1865
1866     if (fullname == NULL) {
1867         /*
1868          * Still haven't found the makefile. Look for it on the system
1869          * path as a last resort.
1870          */
1871         fullname = Dir_FindFile(file, &sysIncPath);
1872     }
1873
1874     if (fullname == NULL) {
1875         Parse_Error(PARSE_FATAL, "Could not find %s", file);
1876         return;
1877     }
1878
1879     /*
1880      * Once we find the absolute path to the file, we get to save all the
1881      * state from the current file before we can start reading this
1882      * include file. The state is stored in an IFile structure which
1883      * is placed on a list with other IFile structures. The list makes
1884      * a very nice stack to track how we got here...
1885      */
1886     oldFile = emalloc(sizeof(IFile));
1887     memcpy(oldFile, &curFile, sizeof(IFile));
1888
1889     Lst_AtFront(&includes, oldFile);
1890
1891     /*
1892      * Once the previous state has been saved, we can get down to reading
1893      * the new file. We set up the name of the file to be the absolute
1894      * name of the include file so error messages refer to the right
1895      * place. Naturally enough, we start reading at line number 0.
1896      */
1897     curFile.fname = fullname;
1898     curFile.lineno = 0;
1899
1900     curFile.F = fopen(fullname, "r");
1901     curFile.p = NULL;
1902     if (curFile.F == NULL) {
1903         Parse_Error(PARSE_FATAL, "Cannot open %s", fullname);
1904         /*
1905          * Pop to previous file
1906          */
1907         ParseEOF(1);
1908     } else {
1909         Var_Append(".MAKEFILE_LIST", fullname, VAR_GLOBAL);
1910     }
1911 }
1912 #endif
1913
1914 /*-
1915  *---------------------------------------------------------------------
1916  * ParseEOF  --
1917  *      Called when EOF is reached in the current file. If we were reading
1918  *      an include file, the includes stack is popped and things set up
1919  *      to go back to reading the previous file at the previous location.
1920  *
1921  * Results:
1922  *      CONTINUE if there's more to do. DONE if not.
1923  *
1924  * Side Effects:
1925  *      The old curFile.F is closed. The includes list is shortened.
1926  *      curFile.lineno, curFile.F, and curFile.fname are changed if
1927  *      CONTINUE is returned.
1928  *---------------------------------------------------------------------
1929  */
1930 static int
1931 ParseEOF(int opened)
1932 {
1933     IFile     *ifile;   /* the state on the top of the includes stack */
1934
1935     if (Lst_IsEmpty(&includes)) {
1936         Var_Append(".MAKEFILE_LIST", "..", VAR_GLOBAL);
1937         return (DONE);
1938     }
1939
1940     ifile = Lst_DeQueue(&includes);
1941     free(curFile.fname);
1942     if (opened && curFile.F) {
1943         fclose(curFile.F);
1944         Var_Append(".MAKEFILE_LIST", "..", VAR_GLOBAL);
1945     }
1946     if (curFile.p) {
1947         free(curFile.p->str);
1948         free(curFile.p);
1949     }
1950     memcpy(&curFile, ifile, sizeof(IFile));
1951     free(ifile);
1952     return (CONTINUE);
1953 }
1954
1955 /*-
1956  *---------------------------------------------------------------------
1957  * ParseReadc  --
1958  *      Read a character from the current file
1959  *
1960  * Results:
1961  *      The character that was read
1962  *
1963  * Side Effects:
1964  *---------------------------------------------------------------------
1965  */
1966 static int
1967 ParseReadc(void)
1968 {
1969
1970     if (curFile.F)
1971         return (fgetc(curFile.F));
1972
1973     if (curFile.p && *curFile.p->ptr)
1974         return (*curFile.p->ptr++);
1975     return (EOF);
1976 }
1977
1978
1979 /*-
1980  *---------------------------------------------------------------------
1981  * ParseUnreadc  --
1982  *      Put back a character to the current file
1983  *
1984  * Results:
1985  *      None.
1986  *
1987  * Side Effects:
1988  *---------------------------------------------------------------------
1989  */
1990 static void
1991 ParseUnreadc(int c)
1992 {
1993
1994     if (curFile.F) {
1995         ungetc(c, curFile.F);
1996         return;
1997     }
1998     if (curFile.p) {
1999         *--(curFile.p->ptr) = c;
2000         return;
2001     }
2002 }
2003
2004
2005 /* ParseSkipLine():
2006  *      Grab the next line unless it begins with a dot (`.') and we're told to
2007  *      ignore such lines.
2008  */
2009 static char *
2010 ParseSkipLine(int skip, int keep_newline)
2011 {
2012     char *line;
2013     int c, lastc;
2014     Buffer *buf;
2015
2016     buf = Buf_Init(MAKE_BSIZE);
2017
2018     do {
2019         Buf_Clear(buf);
2020         lastc = '\0';
2021
2022         while (((c = ParseReadc()) != '\n' || lastc == '\\')
2023                && c != EOF) {
2024             if (skip && c == '#' && lastc != '\\') {
2025                 /* let a comment be terminated even by an escaped \n.
2026                  * This is consistent to comment handling in ParseReadLine */
2027                 while ((c = ParseReadc()) != '\n' && c != EOF)
2028                     ;
2029                 break;
2030             }
2031             if (c == '\n') {
2032                 if (keep_newline)
2033                     Buf_AddByte(buf, (Byte)c);
2034                 else
2035                     Buf_ReplaceLastByte(buf, (Byte)' ');
2036                 curFile.lineno++;
2037
2038                 while ((c = ParseReadc()) == ' ' || c == '\t')
2039                     continue;
2040
2041                 if (c == EOF)
2042                     break;
2043             }
2044
2045             Buf_AddByte(buf, (Byte)c);
2046             lastc = c;
2047         }
2048
2049         if (c == EOF) {
2050             Parse_Error(PARSE_FATAL, "Unclosed conditional/for loop");
2051             Buf_Destroy(buf, TRUE);
2052             return (NULL);
2053         }
2054
2055         curFile.lineno++;
2056         Buf_AddByte(buf, (Byte)'\0');
2057         line = (char *)Buf_GetAll(buf, NULL);
2058     } while (skip == 1 && line[0] != '.');
2059
2060     Buf_Destroy(buf, FALSE);
2061     return (line);
2062 }
2063
2064
2065 /*-
2066  *---------------------------------------------------------------------
2067  * ParseReadLine --
2068  *      Read an entire line from the input file. Called only by Parse_File.
2069  *      To facilitate escaped newlines and what have you, a character is
2070  *      buffered in 'lastc', which is '\0' when no characters have been
2071  *      read. When we break out of the loop, c holds the terminating
2072  *      character and lastc holds a character that should be added to
2073  *      the line (unless we don't read anything but a terminator).
2074  *
2075  * Results:
2076  *      A line w/o its newline
2077  *
2078  * Side Effects:
2079  *      Only those associated with reading a character
2080  *---------------------------------------------------------------------
2081  */
2082 static char *
2083 ParseReadLine(void)
2084 {
2085     Buffer        *buf;         /* Buffer for current line */
2086     int           c;            /* the current character */
2087     int           lastc;        /* The most-recent character */
2088     Boolean       semiNL;       /* treat semi-colons as newlines */
2089     Boolean       ignDepOp;     /* TRUE if should ignore dependency operators
2090                                  * for the purposes of setting semiNL */
2091     Boolean       ignComment;   /* TRUE if should ignore comments (in a
2092                                  * shell command */
2093     char          *line;        /* Result */
2094     char          *ep;          /* to strip trailing blanks */
2095     int           lineno;       /* Saved line # */
2096
2097     semiNL = FALSE;
2098     ignDepOp = FALSE;
2099     ignComment = FALSE;
2100
2101     /*
2102      * Handle special-characters at the beginning of the line. Either a
2103      * leading tab (shell command) or pound-sign (possible conditional)
2104      * forces us to ignore comments and dependency operators and treat
2105      * semi-colons as semi-colons (by leaving semiNL FALSE). This also
2106      * discards completely blank lines.
2107      */
2108     for (;;) {
2109         c = ParseReadc();
2110
2111         if (c == '\t') {
2112             ignComment = ignDepOp = TRUE;
2113             break;
2114         } else if (c == '\n') {
2115             curFile.lineno++;
2116         } else if (c == '#') {
2117             ParseUnreadc(c);
2118             break;
2119         } else {
2120             /*
2121              * Anything else breaks out without doing anything
2122              */
2123             break;
2124         }
2125     }
2126
2127     if (c != EOF) {
2128         lastc = c;
2129         buf = Buf_Init(MAKE_BSIZE);
2130
2131         while (((c = ParseReadc()) != '\n' || (lastc == '\\')) &&
2132                (c != EOF))
2133         {
2134 test_char:
2135             switch (c) {
2136             case '\n':
2137                 /*
2138                  * Escaped newline: read characters until a non-space or an
2139                  * unescaped newline and replace them all by a single space.
2140                  * This is done by storing the space over the backslash and
2141                  * dropping through with the next nonspace. If it is a
2142                  * semi-colon and semiNL is TRUE, it will be recognized as a
2143                  * newline in the code below this...
2144                  */
2145                 curFile.lineno++;
2146                 lastc = ' ';
2147                 while ((c = ParseReadc()) == ' ' || c == '\t') {
2148                     continue;
2149                 }
2150                 if (c == EOF || c == '\n') {
2151                     goto line_read;
2152                 } else {
2153                     /*
2154                      * Check for comments, semiNL's, etc. -- easier than
2155                      * ParseUnreadc(c); continue;
2156                      */
2157                     goto test_char;
2158                 }
2159                 /*NOTREACHED*/
2160                 break;
2161
2162             case ';':
2163                 /*
2164                  * Semi-colon: Need to see if it should be interpreted as a
2165                  * newline
2166                  */
2167                 if (semiNL) {
2168                     /*
2169                      * To make sure the command that may be following this
2170                      * semi-colon begins with a tab, we push one back into the
2171                      * input stream. This will overwrite the semi-colon in the
2172                      * buffer. If there is no command following, this does no
2173                      * harm, since the newline remains in the buffer and the
2174                      * whole line is ignored.
2175                      */
2176                     ParseUnreadc('\t');
2177                     goto line_read;
2178                 }
2179                 break;
2180             case '=':
2181                 if (!semiNL) {
2182                     /*
2183                      * Haven't seen a dependency operator before this, so this
2184                      * must be a variable assignment -- don't pay attention to
2185                      * dependency operators after this.
2186                      */
2187                     ignDepOp = TRUE;
2188                 } else if (lastc == ':' || lastc == '!') {
2189                     /*
2190                      * Well, we've seen a dependency operator already, but it
2191                      * was the previous character, so this is really just an
2192                      * expanded variable assignment. Revert semi-colons to
2193                      * being just semi-colons again and ignore any more
2194                      * dependency operators.
2195                      *
2196                      * XXX: Note that a line like "foo : a:=b" will blow up,
2197                      * but who'd write a line like that anyway?
2198                      */
2199                     ignDepOp = TRUE;
2200                     semiNL = FALSE;
2201                 }
2202                 break;
2203             case '#':
2204                 if (!ignComment) {
2205                     if (lastc != '\\') {
2206                         /*
2207                          * If the character is a hash mark and it isn't escaped
2208                          * (or we're being compatible), the thing is a comment.
2209                          * Skip to the end of the line.
2210                          */
2211                         do {
2212                             c = ParseReadc();
2213                         } while ((c != '\n') && (c != EOF));
2214                         goto line_read;
2215                     } else {
2216                         /*
2217                          * Don't add the backslash. Just let the # get copied
2218                          * over.
2219                          */
2220                         lastc = c;
2221                         continue;
2222                     }
2223                 }
2224                 break;
2225             case ':':
2226             case '!':
2227                 if (!ignDepOp && (c == ':' || c == '!')) {
2228                     /*
2229                      * A semi-colon is recognized as a newline only on
2230                      * dependency lines. Dependency lines are lines with a
2231                      * colon or an exclamation point. Ergo...
2232                      */
2233                     semiNL = TRUE;
2234                 }
2235                 break;
2236             default:
2237                 break;
2238             }
2239             /*
2240              * Copy in the previous character and save this one in lastc.
2241              */
2242             Buf_AddByte(buf, (Byte)lastc);
2243             lastc = c;
2244
2245         }
2246     line_read:
2247         curFile.lineno++;
2248
2249         if (lastc != '\0') {
2250             Buf_AddByte(buf, (Byte)lastc);
2251         }
2252         Buf_AddByte(buf, (Byte)'\0');
2253         line = (char *)Buf_GetAll(buf, NULL);
2254         Buf_Destroy(buf, FALSE);
2255
2256         /*
2257          * Strip trailing blanks and tabs from the line.
2258          * Do not strip a blank or tab that is preceded by
2259          * a '\'
2260          */
2261         ep = line;
2262         while (*ep)
2263             ++ep;
2264         while (ep > line + 1 && (ep[-1] == ' ' || ep[-1] == '\t')) {
2265             if (ep > line + 1 && ep[-2] == '\\')
2266                 break;
2267             --ep;
2268         }
2269         *ep = 0;
2270
2271         if (line[0] == '.') {
2272             /*
2273              * The line might be a conditional. Ask the conditional module
2274              * about it and act accordingly
2275              */
2276             switch (Cond_Eval(line)) {
2277             case COND_SKIP:
2278                 /*
2279                  * Skip to next conditional that evaluates to COND_PARSE.
2280                  */
2281                 do {
2282                     free(line);
2283                     line = ParseSkipLine(1, 0);
2284                 } while (line && Cond_Eval(line) != COND_PARSE);
2285                 if (line == NULL)
2286                     break;
2287                 /*FALLTHRU*/
2288             case COND_PARSE:
2289                 free(line);
2290                 line = ParseReadLine();
2291                 break;
2292             case COND_INVALID:
2293                 if (For_Eval(line)) {
2294                     int ok;
2295                     free(line);
2296                     lineno = curFile.lineno;
2297                     do {
2298                         /*
2299                          * Skip after the matching end
2300                          */
2301                         line = ParseSkipLine(0, 1);
2302                         if (line == NULL) {
2303                             Parse_Error(PARSE_FATAL,
2304                                      "Unexpected end of file in for loop.\n");
2305                             break;
2306                         }
2307                         ok = For_Eval(line);
2308                         free(line);
2309                     }
2310                     while (ok);
2311                     if (line != NULL)
2312                         For_Run(lineno);
2313                     line = ParseReadLine();
2314                 }
2315                 break;
2316             default:
2317                 break;
2318             }
2319         }
2320         return (line);
2321
2322     } else {
2323         /*
2324          * Hit end-of-file, so return a NULL line to indicate this.
2325          */
2326         return (NULL);
2327     }
2328 }
2329
2330 /*-
2331  *-----------------------------------------------------------------------
2332  * ParseFinishLine --
2333  *      Handle the end of a dependency group.
2334  *
2335  * Results:
2336  *      Nothing.
2337  *
2338  * Side Effects:
2339  *      inLine set FALSE. 'targets' list destroyed.
2340  *
2341  *-----------------------------------------------------------------------
2342  */
2343 static void
2344 ParseFinishLine(void)
2345 {
2346
2347     if (inLine) {
2348         Lst_ForEach(&targets, Suff_EndTransform, NULL);
2349         Lst_Destroy(&targets, ParseHasCommands);
2350         inLine = FALSE;
2351     }
2352 }
2353
2354 static char *
2355 stripvarname(char *cp)
2356 {
2357     char *cp2;
2358
2359     while (isspace((unsigned char)*cp))
2360         ++cp;
2361     cp2 = cp;
2362     while (*cp2 && !isspace((unsigned char)*cp2))
2363         ++cp2;
2364     *cp2 = 0;
2365     return(cp);
2366 }
2367
2368
2369 /*-
2370  *---------------------------------------------------------------------
2371  * Parse_File --
2372  *      Parse a file into its component parts, incorporating it into the
2373  *      current dependency graph. This is the main function and controls
2374  *      almost every other function in this module
2375  *
2376  * Results:
2377  *      None
2378  *
2379  * Side Effects:
2380  *      Loads. Nodes are added to the list of all targets, nodes and links
2381  *      are added to the dependency graph. etc. etc. etc.
2382  *---------------------------------------------------------------------
2383  */
2384 void
2385 Parse_File(const char *name, FILE *stream)
2386 {
2387     char          *cp,          /* pointer into the line */
2388                   *line;        /* the line we're working on */
2389
2390     inLine = FALSE;
2391     curFile.fname = name;
2392     curFile.F = stream;
2393     curFile.lineno = 0;
2394     fatals = 0;
2395
2396     Var_Append(".MAKEFILE_LIST", name, VAR_GLOBAL);
2397
2398     do {
2399         while ((line = ParseReadLine()) != NULL) {
2400             if (*line == '.') {
2401                 /*
2402                  * Lines that begin with the special character are either
2403                  * include or undef directives.
2404                  */
2405                 for (cp = line + 1; isspace((unsigned char)*cp); cp++) {
2406                     continue;
2407                 }
2408                 if (strncmp(cp, "include", 7) == 0) {
2409                     ParseDoInclude(cp + 7);
2410                     goto nextLine;
2411                 } else if (strncmp(cp, "error", 5) == 0) {
2412                     ParseDoError(cp + 5);
2413                     goto nextLine;
2414                 } else if (strncmp(cp, "warning", 7) == 0) {
2415                     ParseDoWarning(cp + 7);
2416                     goto nextLine;
2417                 } else if (strncmp(cp, "undef", 5) == 0) {
2418                     cp = stripvarname(cp + 5);
2419                     cp = Var_Subst(NULL, cp, VAR_CMD, FALSE);
2420                     Var_Delete(cp, VAR_GLOBAL);
2421                     goto nextLine;
2422                 } else if (strncmp(cp, "makeenv", 7) == 0) {
2423                     cp = stripvarname(cp + 7);
2424                     Var_SetEnv(cp, VAR_GLOBAL);
2425                     goto nextLine;
2426                 }
2427             }
2428             if (*line == '#') {
2429                 /* If we're this far, the line must be a comment. */
2430                 goto nextLine;
2431             }
2432
2433             if (*line == '\t') {
2434                 /*
2435                  * If a line starts with a tab, it can only hope to be
2436                  * a creation command.
2437                  */
2438                 for (cp = line + 1; isspace((unsigned char)*cp); cp++) {
2439                     continue;
2440                 }
2441                 if (*cp) {
2442                     if (inLine) {
2443                         /*
2444                          * So long as it's not a blank line and we're actually
2445                          * in a dependency spec, add the command to the list of
2446                          * commands of all targets in the dependency spec
2447                          */
2448                         Lst_ForEach(&targets, ParseAddCmd, cp);
2449                         continue;
2450                     } else {
2451                         Parse_Error(PARSE_FATAL,
2452                                      "Unassociated shell command \"%s\"",
2453                                      cp);
2454                     }
2455                 }
2456 #ifdef SYSVINCLUDE
2457             } else if (strncmp(line, "include", 7) == 0 &&
2458                        isspace((unsigned char)line[7]) &&
2459                        strchr(line, ':') == NULL) {
2460                 /*
2461                  * It's an S3/S5-style "include".
2462                  */
2463                 ParseTraditionalInclude(line + 7);
2464                 goto nextLine;
2465 #endif
2466             } else if (Parse_IsVar(line)) {
2467                 ParseFinishLine();
2468                 Parse_DoVar(line, VAR_GLOBAL);
2469             } else {
2470                 /*
2471                  * We now know it's a dependency line so it needs to have all
2472                  * variables expanded before being parsed. Tell the variable
2473                  * module to complain if some variable is undefined...
2474                  * To make life easier on novices, if the line is indented we
2475                  * first make sure the line has a dependency operator in it.
2476                  * If it doesn't have an operator and we're in a dependency
2477                  * line's script, we assume it's actually a shell command
2478                  * and add it to the current list of targets.
2479                  */
2480                 cp = line;
2481                 if (isspace((unsigned char)line[0])) {
2482                     while ((*cp != '\0') && isspace((unsigned char)*cp)) {
2483                         cp++;
2484                     }
2485                     if (*cp == '\0') {
2486                         goto nextLine;
2487                     }
2488                 }
2489
2490                 ParseFinishLine();
2491
2492                 cp = Var_Subst(NULL, line, VAR_CMD, TRUE);
2493                 free(line);
2494                 line = cp;
2495
2496                 /*
2497                  * Need a non-circular list for the target nodes
2498                  */
2499                 Lst_Destroy(&targets, NOFREE);
2500                 inLine = TRUE;
2501
2502                 ParseDoDependency(line);
2503             }
2504
2505             nextLine:
2506
2507             free(line);
2508         }
2509         /*
2510          * Reached EOF, but it may be just EOF of an include file...
2511          */
2512     } while (ParseEOF(1) == CONTINUE);
2513
2514     /*
2515      * Make sure conditionals are clean
2516      */
2517     Cond_End();
2518
2519     if (fatals)
2520         errx(1, "fatal errors encountered -- cannot continue");
2521 }
2522
2523 /*-
2524  *---------------------------------------------------------------------
2525  * Parse_Init --
2526  *      initialize the parsing module
2527  *
2528  * Results:
2529  *      none
2530  *
2531  * Side Effects:
2532  *      the parseIncPath list is initialized...
2533  *---------------------------------------------------------------------
2534  */
2535 void
2536 Parse_Init(void)
2537 {
2538
2539     mainNode = NULL;
2540 }
2541
2542 /*-
2543  *-----------------------------------------------------------------------
2544  * Parse_MainName --
2545  *      Return a Lst of the main target to create for main()'s sake. If
2546  *      no such target exists, we Punt with an obnoxious error message.
2547  *
2548  * Results:
2549  *      A Lst of the single node to create.
2550  *
2551  * Side Effects:
2552  *      None.
2553  *
2554  *-----------------------------------------------------------------------
2555  */
2556 void
2557 Parse_MainName(Lst *listmain)
2558 {
2559
2560     if (mainNode == NULL) {
2561         Punt("no target to make.");
2562         /*NOTREACHED*/
2563     } else if (mainNode->type & OP_DOUBLEDEP) {
2564         Lst_AtEnd(listmain, mainNode);
2565         Lst_Concat(listmain, &mainNode->cohorts, LST_CONCNEW);
2566     }
2567     else
2568         Lst_AtEnd(listmain, mainNode);
2569 }