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