read.c

   1 /* Reading and parsing of makefiles for GNU Make.
   2 Copyright (C) 1988, 89, 90, 91, 92, 93, 94 Free Software Foundation, Inc.
   3 This file is part of GNU Make.
   4
   5 GNU Make is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2, or (at your option)
   8 any later version.
   9
  10 GNU Make is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with GNU Make; see the file COPYING.  If not, write to
  17 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  18
  19 #include "make.h"
  20 #include "commands.h"
  21 #include "dep.h"
  22 #include "file.h"
  23 #include "variable.h"
  24
  25 /* This is POSIX.2, but most systems using -DPOSIX probably don't have it.  */
  26 #ifdef  HAVE_GLOB_H
  27 #include <glob.h>
  28 #else
  29 #include "glob/glob.h"
  30 #endif
  31
  32 #include <pwd.h>
  33 struct passwd *getpwnam ();
  34
  35
  36 static int read_makefile ();
  37 static unsigned int readline (), do_define ();
  38 static int conditional_line ();
  39 static void record_files ();
  40 static char *find_semicolon ();
  41
  42
  43 /* A `struct linebuffer' is a structure which holds a line of text.
  44    `readline' reads a line from a stream into a linebuffer
  45    and works regardless of the length of the line.  */
  46
  47 struct linebuffer
  48   {
  49     /* Note:  This is the number of bytes malloc'ed for `buffer'
  50        It does not indicate `buffer's real length.
  51        Instead, a null char indicates end-of-string.  */
  52     unsigned int size;
  53     char *buffer;
  54   };
  55
  56 #define initbuffer(lb) (lb)->buffer = (char *) xmalloc ((lb)->size = 200)
  57 #define freebuffer(lb) free ((lb)->buffer)
  58
  59
  60 /* A `struct conditionals' contains the information describing
  61    all the active conditionals in a makefile.
  62
  63    The global variable `conditionals' contains the conditionals
  64    information for the current makefile.  It is initialized from
  65    the static structure `toplevel_conditionals' and is later changed
  66    to new structures for included makefiles.  */
  67
  68 struct conditionals
  69   {
  70     unsigned int if_cmds;       /* Depth of conditional nesting.  */
  71     unsigned int allocated;     /* Elts allocated in following arrays.  */
  72     char *ignoring;             /* Are we ignoring or interepreting?  */
  73     char *seen_else;            /* Have we already seen an `else'?  */
  74   };
  75
  76 static struct conditionals toplevel_conditionals;
  77 static struct conditionals *conditionals = &toplevel_conditionals;
  78
  79
  80 /* Default directories to search for include files in  */
  81
  82 static char *default_include_directories[] =
  83   {
  84     INCLUDEDIR,
  85     "/usr/gnu/include",
  86     "/usr/local/include",
  87     "/usr/include",
  88     0
  89   };
  90
  91 /* List of directories to search for include files in  */
  92
  93 static char **include_directories;
  94
  95 /* Maximum length of an element of the above.  */
  96
  97 static unsigned int max_incl_len;
  98
  99 /* The filename and pointer to line number of the
 100    makefile currently being read in.  */
 101
 102 char *reading_filename;
 103 unsigned int *reading_lineno_ptr;
 104
 105 /* The chain of makefiles read by read_makefile.  */
 106
 107 static struct dep *read_makefiles = 0;
 108 \f
 109 /* Read in all the makefiles and return the chain of their names.  */
 110
 111 struct dep *
 112 read_all_makefiles (makefiles)
 113      char **makefiles;
 114 {
 115   unsigned int num_makefiles = 0;
 116
 117   if (debug_flag)
 118     puts ("Reading makefiles...");
 119
 120   /* If there's a non-null variable MAKEFILES, its value is a list of
 121      files to read first thing.  But don't let it prevent reading the
 122      default makefiles and don't let the default goal come from there.  */
 123
 124   {
 125     char *value;
 126     char *name, *p;
 127     unsigned int length;
 128
 129     {
 130       /* Turn off --warn-undefined-variables while we expand MAKEFILES.  */
 131       int save = warn_undefined_variables_flag;
 132       warn_undefined_variables_flag = 0;
 133
 134       value = allocated_variable_expand ("$(MAKEFILES)");
 135
 136       warn_undefined_variables_flag = save;
 137     }
 138
 139     /* Set NAME to the start of next token and LENGTH to its length.
 140        MAKEFILES is updated for finding remaining tokens.  */
 141     p = value;
 142     while ((name = find_next_token (&p, &length)) != 0)
 143       {
 144         if (*p != '\0')
 145           *p++ = '\0';
 146         (void) read_makefile (name,
 147                               RM_NO_DEFAULT_GOAL | RM_INCLUDED | RM_DONTCARE);
 148       }
 149
 150     free (value);
 151   }
 152
 153   /* Read makefiles specified with -f switches.  */
 154
 155   if (makefiles != 0)
 156     while (*makefiles != 0)
 157       {
 158         struct dep *tail = read_makefiles;
 159         register struct dep *d;
 160
 161         if (! read_makefile (*makefiles, 0))
 162           perror_with_name ("", *makefiles);
 163
 164         /* Find the right element of read_makefiles.  */
 165         d = read_makefiles;
 166         while (d->next != tail)
 167           d = d->next;
 168
 169         /* Use the storage read_makefile allocates.  */
 170         *makefiles = dep_name (d);
 171         ++num_makefiles;
 172         ++makefiles;
 173       }
 174
 175   /* If there were no -f switches, try the default names.  */
 176
 177   if (num_makefiles == 0)
 178     {
 179       static char *default_makefiles[] =
 180         { "GNUmakefile", "makefile", "Makefile", 0 };
 181       register char **p = default_makefiles;
 182       while (*p != 0 && !file_exists_p (*p))
 183         ++p;
 184
 185       if (*p != 0)
 186         {
 187           if (! read_makefile (*p, 0))
 188             perror_with_name ("", *p);
 189         }
 190       else
 191         {
 192           /* No default makefile was found.  Add the default makefiles to the
 193              `read_makefiles' chain so they will be updated if possible.  */
 194           struct dep *tail = read_makefiles;
 195           for (p = default_makefiles; *p != 0; ++p)
 196             {
 197               struct dep *d = (struct dep *) xmalloc (sizeof (struct dep));
 198               d->name = 0;
 199               d->file = enter_file (*p);
 200               d->file->dontcare = 1;
 201               /* Tell update_goal_chain to bail out as soon as this file is
 202                  made, and main not to die if we can't make this file.  */
 203               d->changed = RM_DONTCARE;
 204               if (tail == 0)
 205                 read_makefiles = d;
 206               else
 207                 tail->next = d;
 208               tail = d;
 209             }
 210           if (tail != 0)
 211             tail->next = 0;
 212         }
 213     }
 214
 215   return read_makefiles;
 216 }
 217 \f
 218 /* Read file FILENAME as a makefile and add its contents to the data base.
 219
 220    FLAGS contains bits as above.
 221
 222    FILENAME is added to the `read_makefiles' chain.
 223
 224    Returns 1 if a file was found and read, 0 if not.  */
 225
 226 static int
 227 read_makefile (filename, flags)
 228      char *filename;
 229      int flags;
 230 {
 231   static char *collapsed = 0;
 232   static unsigned int collapsed_length = 0;
 233   register FILE *infile;
 234   struct linebuffer lb;
 235   unsigned int commands_len = 200;
 236   char *commands = (char *) xmalloc (200);
 237   unsigned int commands_idx = 0;
 238   unsigned int commands_started;
 239   register char *p;
 240   char *p2;
 241   int ignoring = 0, in_ignored_define = 0;
 242   int no_targets = 0;           /* Set when reading a rule without targets.  */
 243
 244   struct nameseq *filenames = 0;
 245   struct dep *deps;
 246   unsigned int lineno = 1;
 247   unsigned int nlines = 0;
 248   int two_colon;
 249   char *pattern = 0, *pattern_percent;
 250
 251   int makefile_errno;
 252
 253 #define record_waiting_files()                                                \
 254   do                                                                          \
 255     {                                                                         \
 256       if (filenames != 0)                                                     \
 257         record_files (filenames, pattern, pattern_percent, deps,              \
 258                       commands_started, commands, commands_idx,               \
 259                       two_colon, filename, lineno,                            \
 260                       !(flags & RM_NO_DEFAULT_GOAL));                         \
 261       filenames = 0;                                                          \
 262       commands_idx = 0;                                                       \
 263       pattern = 0;                                                            \
 264     } while (0)
 265
 266 #ifdef  lint    /* Suppress `used before set' messages.  */
 267   two_colon = 0;
 268 #endif
 269
 270   if (debug_flag)
 271     {
 272       printf ("Reading makefile `%s'", filename);
 273       if (flags & RM_NO_DEFAULT_GOAL)
 274         printf (" (no default goal)");
 275       if (flags & RM_INCLUDED)
 276         printf (" (search path)");
 277       if (flags & RM_DONTCARE)
 278         printf (" (don't care)");
 279       if (flags & RM_NO_TILDE)
 280         printf (" (no ~ expansion)");
 281       puts ("...");
 282     }
 283
 284   /* First, get a stream to read.  */
 285
 286   /* Expand ~ in FILENAME unless it came from `include',
 287      in which case it was already done.  */
 288   if (!(flags & RM_NO_TILDE) && filename[0] == '~')
 289     {
 290       char *expanded = tilde_expand (filename);
 291       /* This is a possible memory leak, but I don't care.  */
 292       if (expanded != 0)
 293         filename = expanded;
 294     }
 295
 296   infile = fopen (filename, "r");
 297   /* Save the error code so we print the right message later.  */
 298   makefile_errno = errno;
 299
 300   /* If the makefile wasn't found and it's either a makefile from
 301      the `MAKEFILES' variable or an included makefile,
 302      search the included makefile search path for this makefile.  */
 303
 304   if (infile == 0 && (flags & RM_INCLUDED) && *filename != '/')
 305     {
 306       register unsigned int i;
 307       for (i = 0; include_directories[i] != 0; ++i)
 308         {
 309           char *name = concat (include_directories[i], "/", filename);
 310           infile = fopen (name, "r");
 311           if (infile == 0)
 312             free (name);
 313           else
 314             {
 315               filename = name;
 316               break;
 317             }
 318         }
 319     }
 320
 321   /* Add FILENAME to the chain of read makefiles.  */
 322   deps = (struct dep *) xmalloc (sizeof (struct dep));
 323   deps->next = read_makefiles;
 324   read_makefiles = deps;
 325   deps->name = 0;
 326   deps->file = lookup_file (filename);
 327   if (deps->file == 0)
 328     {
 329       deps->file = enter_file (savestring (filename, strlen (filename)));
 330       if (flags & RM_DONTCARE)
 331         deps->file->dontcare = 1;
 332     }
 333   filename = deps->file->name;
 334   deps->changed = flags;
 335   deps = 0;
 336
 337   /* If the makefile can't be found at all, give up entirely.  */
 338
 339   if (infile == 0)
 340     {
 341       /* If we did some searching, errno has the error from the last
 342          attempt, rather from FILENAME itself.  Restore it in case the
 343          caller wants to use it in a message.  */
 344       errno = makefile_errno;
 345       return 0;
 346     }
 347
 348   reading_filename = filename;
 349   reading_lineno_ptr = &lineno;
 350
 351   /* Loop over lines in the file.
 352      The strategy is to accumulate target names in FILENAMES, dependencies
 353      in DEPS and commands in COMMANDS.  These are used to define a rule
 354      when the start of the next rule (or eof) is encountered.  */
 355
 356   initbuffer (&lb);
 357
 358   while (!feof (infile))
 359     {
 360       lineno += nlines;
 361       nlines = readline (&lb, infile, filename, lineno);
 362
 363       if (collapsed_length < lb.size)
 364         {
 365           collapsed_length = lb.size;
 366           if (collapsed != 0)
 367             free (collapsed);
 368           collapsed = (char *) xmalloc (collapsed_length);
 369         }
 370       strcpy (collapsed, lb.buffer);
 371       /* Collapse continuation lines.  */
 372       collapse_continuations (collapsed);
 373       remove_comments (collapsed);
 374
 375       p = collapsed;
 376       while (isspace (*p) && *p != '\t')
 377         ++p;
 378       /* We cannot consider a line containing just a tab to be empty
 379          because it might constitute an empty command for a target.  */
 380       if (*p == '\0' && lb.buffer[0] != '\t')
 381         continue;
 382
 383       /* strncmp is first to avoid dereferencing out into space.  */
 384 #define word1eq(s, l)   (!strncmp (s, p, l) \
 385                          && (p[l] == '\0' || isblank (p[l])))
 386       if (!in_ignored_define
 387           && (word1eq ("ifdef", 5) || word1eq ("ifndef", 6)
 388               || word1eq ("ifeq", 4) || word1eq ("ifneq", 5)
 389               || word1eq ("else", 4) || word1eq ("endif", 5)))
 390         {
 391           int i = conditional_line (p, filename, lineno);
 392           if (i >= 0)
 393             ignoring = i;
 394           else
 395             makefile_fatal (filename, lineno,
 396                             "invalid syntax in conditional");
 397           continue;
 398         }
 399       else if (word1eq ("endef", 5))
 400         {
 401           if (in_ignored_define)
 402             in_ignored_define = 0;
 403           else
 404             makefile_fatal (filename, lineno, "extraneous `endef'");
 405           continue;
 406         }
 407       else if (word1eq ("define", 6))
 408         {
 409           if (ignoring)
 410             in_ignored_define = 1;
 411           else
 412             {
 413               p2 = next_token (p + 6);
 414               /* Let the variable name be the whole rest of the line,
 415                  with trailing blanks stripped (comments have already been
 416                  removed), so it could be a complex variable/function
 417                  reference that might contain blanks.  */
 418               p = index (p2, '\0');
 419               while (isblank (p[-1]))
 420                 --p;
 421               lineno = do_define (p2, p - p2, o_file,
 422                                   lineno, infile, filename);
 423             }
 424           continue;
 425         }
 426       else if (word1eq ("override", 8))
 427         {
 428           p2 = next_token (p + 8);
 429           if (p2 == 0)
 430             makefile_error (filename, lineno, "empty `override' directive");
 431           if (!strncmp (p2, "define", 6) && (isblank (p2[6]) || p2[6] == '\0'))
 432             {
 433               if (ignoring)
 434                 in_ignored_define = 1;
 435               else
 436                 {
 437                   p2 = next_token (p2 + 6);
 438                   /* Let the variable name be the whole rest of the line,
 439                      with trailing blanks stripped (comments have already been
 440                      removed), so it could be a complex variable/function
 441                      reference that might contain blanks.  */
 442                   p = index (p2, '\0');
 443                   while (isblank (p[-1]))
 444                     --p;
 445                   lineno = do_define (p2, p - p2, o_override,
 446                                       lineno, infile, filename);
 447                 }
 448             }
 449           else if (!ignoring
 450                    && !try_variable_definition (filename, lineno,
 451                                                 p2, o_override))
 452             makefile_error (filename, lineno, "empty `override' directive");
 453
 454           continue;
 455         }
 456
 457       if (ignoring)
 458         /* Ignore the line.  We continue here so conditionals
 459            can appear in the middle of a rule.  */
 460         continue;
 461       else if (lb.buffer[0] == '\t')
 462         {
 463           /* This line is a shell command.  */
 464           unsigned int len;
 465
 466           if (no_targets)
 467             /* Ignore the commands in a rule with no targets.  */
 468             continue;
 469
 470           /* If there is no preceding rule line, don't treat this line
 471              as a command, even though it begins with a tab character.
 472              SunOS 4 make appears to behave this way.  */
 473
 474           if (filenames != 0)
 475             {
 476               /* Append this command line to the line being accumulated.  */
 477               p = lb.buffer;
 478               if (commands_idx == 0)
 479                 commands_started = lineno;
 480               len = strlen (p);
 481               if (len + 1 + commands_idx > commands_len)
 482                 {
 483                   commands_len = (len + 1 + commands_idx) * 2;
 484                   commands = (char *) xrealloc (commands, commands_len);
 485                 }
 486               bcopy (p, &commands[commands_idx], len);
 487               commands_idx += len;
 488               commands[commands_idx++] = '\n';
 489
 490               continue;
 491             }
 492         }
 493
 494       if (word1eq ("export", 6))
 495         {
 496           struct variable *v;
 497           p2 = next_token (p + 6);
 498           if (*p2 == '\0')
 499             export_all_variables = 1;
 500           v = try_variable_definition (filename, lineno, p2, o_file);
 501           if (v != 0)
 502             v->export = v_export;
 503           else
 504             {
 505               unsigned int len;
 506               for (p = find_next_token (&p2, &len); p != 0;
 507                    p = find_next_token (&p2, &len))
 508                 {
 509                   v = lookup_variable (p, len);
 510                   if (v == 0)
 511                     v = define_variable (p, len, "", o_file, 0);
 512                   v->export = v_export;
 513                 }
 514             }
 515         }
 516       else if (word1eq ("unexport", 8))
 517         {
 518           unsigned int len;
 519           struct variable *v;
 520           p2 = next_token (p + 8);
 521           if (*p2 == '\0')
 522             export_all_variables = 0;
 523           for (p = find_next_token (&p2, &len); p != 0;
 524                p = find_next_token (&p2, &len))
 525             {
 526               v = lookup_variable (p, len);
 527               if (v == 0)
 528                 v = define_variable (p, len, "", o_file, 0);
 529               v->export = v_noexport;
 530             }
 531         }
 532       else if (word1eq ("include", 7) || word1eq ("-include", 8))
 533         {
 534           /* We have found an `include' line specifying a nested
 535              makefile to be read at this point.  */
 536           struct conditionals *save, new_conditionals;
 537           struct nameseq *files;
 538           /* "-include" (vs "include") says no
 539              error if the file does not exist.  */
 540           int noerror = p[0] == '-';
 541
 542           p = allocated_variable_expand (next_token (p + (noerror ? 9 : 8)));
 543           if (*p == '\0')
 544             {
 545               makefile_error (filename, lineno,
 546                               "no file name for `%sinclude'",
 547                               noerror ? "-" : "");
 548               continue;
 549             }
 550
 551           /* Parse the list of file names.  */
 552           p2 = p;
 553           files = multi_glob (parse_file_seq (&p2, '\0',
 554                                               sizeof (struct nameseq),
 555                                               1),
 556                               sizeof (struct nameseq));
 557           free (p);
 558
 559           /* Save the state of conditionals and start
 560              the included makefile with a clean slate.  */
 561           save = conditionals;
 562           bzero ((char *) &new_conditionals, sizeof new_conditionals);
 563           conditionals = &new_conditionals;
 564
 565           /* Record the rules that are waiting so they will determine
 566              the default goal before those in the included makefile.  */
 567           record_waiting_files ();
 568
 569           /* Read each included makefile.  */
 570           while (files != 0)
 571             {
 572               struct nameseq *next = files->next;
 573               char *name = files->name;
 574               free (files);
 575               files = next;
 576
 577               if (! read_makefile (name, (RM_INCLUDED | RM_NO_TILDE
 578                                           | (noerror ? RM_DONTCARE : 0)))
 579                   && ! noerror)
 580                 makefile_error (filename, lineno,
 581                                 "%s: %s", name, strerror (errno));
 582             }
 583
 584           /* Free any space allocated by conditional_line.  */
 585           if (conditionals->ignoring)
 586             free (conditionals->ignoring);
 587           if (conditionals->seen_else)
 588             free (conditionals->seen_else);
 589
 590           /* Restore state.  */
 591           conditionals = save;
 592           reading_filename = filename;
 593           reading_lineno_ptr = &lineno;
 594         }
 595       else if (word1eq ("vpath", 5))
 596         {
 597           char *pattern;
 598           unsigned int len;
 599           p2 = variable_expand (p + 5);
 600           p = find_next_token (&p2, &len);
 601           if (p != 0)
 602             {
 603               pattern = savestring (p, len);
 604               p = find_next_token (&p2, &len);
 605               /* No searchpath means remove all previous
 606                  selective VPATH's with the same pattern.  */
 607             }
 608           else
 609             /* No pattern means remove all previous selective VPATH's.  */
 610             pattern = 0;
 611           construct_vpath_list (pattern, p);
 612           if (pattern != 0)
 613             free (pattern);
 614         }
 615 #undef  word1eq
 616       else if (try_variable_definition (filename, lineno, p, o_file))
 617         /* This line has been dealt with.  */
 618         ;
 619       else if (lb.buffer[0] == '\t')
 620         {
 621           p = lb.buffer;
 622           while (isblank (*p))
 623             ++p;
 624           if (*p == '\0')
 625             /* The line is completely blank; that is harmless.  */
 626             continue;
 627           /* This line starts with a tab but was not caught above
 628              because there was no preceding target, and the line
 629              might have been usable as a variable definition.
 630              But now it is definitely lossage.  */
 631           makefile_fatal (filename, lineno,
 632                           "commands commence before first target");
 633         }
 634       else
 635         {
 636           /* This line describes some target files.  */
 637
 638           char *cmdleft;
 639
 640           /* Record the previous rule.  */
 641
 642           record_waiting_files ();
 643
 644           /* Look for a semicolon in the unexpanded line.  */
 645           cmdleft = find_semicolon (lb.buffer);
 646           if (cmdleft != 0)
 647             /* Found one.  Cut the line short there before expanding it.  */
 648             *cmdleft = '\0';
 649
 650           collapse_continuations (lb.buffer);
 651
 652           /* Expand variable and function references before doing anything
 653              else so that special characters can be inside variables.  */
 654           p = variable_expand (lb.buffer);
 655
 656           if (cmdleft == 0)
 657             /* Look for a semicolon in the expanded line.  */
 658             cmdleft = find_semicolon (p);
 659
 660           if (cmdleft != 0)
 661             /* Cut the line short at the semicolon.  */
 662             *cmdleft = '\0';
 663
 664           /* Remove comments from the line.  */
 665           remove_comments (p);
 666
 667           p2 = next_token (p);
 668           if (*p2 == '\0')
 669             {
 670               if (cmdleft != 0)
 671                 makefile_fatal (filename, lineno,
 672                                 "missing rule before commands");
 673               else
 674                 /* This line contained a variable reference that
 675                    expanded to nothing but whitespace.  */
 676                 continue;
 677             }
 678           else if (*p2 == ':')
 679             {
 680               /* We accept and ignore rules without targets for
 681                  compatibility with SunOS 4 make.  */
 682               no_targets = 1;
 683               continue;
 684             }
 685
 686           filenames = multi_glob (parse_file_seq (&p2, ':',
 687                                                   sizeof (struct nameseq),
 688                                                   1),
 689                                   sizeof (struct nameseq));
 690           if (*p2++ == '\0')
 691             makefile_fatal (filename, lineno, "missing separator");
 692           /* Is this a one-colon or two-colon entry?  */
 693           two_colon = *p2 == ':';
 694           if (two_colon)
 695             p2++;
 696
 697           /* We have some targets, so don't ignore the following commands.  */
 698           no_targets = 0;
 699
 700           /* Is this a static pattern rule: `target: %targ: %dep; ...'?  */
 701           p = index (p2, ':');
 702           while (p != 0 && p[-1] == '\\')
 703             {
 704               register char *q = &p[-1];
 705               register int backslash = 0;
 706               while (*q-- == '\\')
 707                 backslash = !backslash;
 708               if (backslash)
 709                 p = index (p + 1, ':');
 710               else
 711                 break;
 712             }
 713           if (p != 0)
 714             {
 715               struct nameseq *target;
 716               target = parse_file_seq (&p2, ':', sizeof (struct nameseq), 1);
 717               ++p2;
 718               if (target == 0)
 719                 makefile_fatal (filename, lineno, "missing target pattern");
 720               else if (target->next != 0)
 721                 makefile_fatal (filename, lineno, "multiple target patterns");
 722               pattern = target->name;
 723               pattern_percent = find_percent (pattern);
 724               if (pattern_percent == 0)
 725                 makefile_fatal (filename, lineno,
 726                                 "target pattern contains no `%%'");
 727             }
 728           else
 729             pattern = 0;
 730
 731           /* Parse the dependencies.  */
 732           deps = (struct dep *)
 733             multi_glob (parse_file_seq (&p2, '\0', sizeof (struct dep), 1),
 734                         sizeof (struct dep));
 735
 736           commands_idx = 0;
 737           if (cmdleft != 0)
 738             {
 739               /* Semicolon means rest of line is a command.  */
 740               unsigned int len = strlen (cmdleft + 1);
 741
 742               commands_started = lineno;
 743
 744               /* Add this command line to the buffer.  */
 745               if (len + 2 > commands_len)
 746                 {
 747                   commands_len = (len + 2) * 2;
 748                   commands = (char *) xrealloc (commands, commands_len);
 749                 }
 750               bcopy (cmdleft + 1, commands, len);
 751               commands_idx += len;
 752               commands[commands_idx++] = '\n';
 753             }
 754
 755           continue;
 756         }
 757
 758       /* We get here except in the case that we just read a rule line.
 759          Record now the last rule we read, so following spurious
 760          commands are properly diagnosed.  */
 761       record_waiting_files ();
 762       no_targets = 0;
 763     }
 764
 765   if (conditionals->if_cmds)
 766     makefile_fatal (filename, lineno, "missing `endif'");
 767
 768   /* At eof, record the last rule.  */
 769   record_waiting_files ();
 770
 771   freebuffer (&lb);
 772   free ((char *) commands);
 773   fclose (infile);
 774
 775   reading_filename = 0;
 776   reading_lineno_ptr = 0;
 777
 778   return 1;
 779 }
 780 \f
 781 /* Execute a `define' directive.
 782    The first line has already been read, and NAME is the name of
 783    the variable to be defined.  The following lines remain to be read.
 784    LINENO, INFILE and FILENAME refer to the makefile being read.
 785    The value returned is LINENO, updated for lines read here.  */
 786
 787 static unsigned int
 788 do_define (name, namelen, origin, lineno, infile, filename)
 789      char *name;
 790      unsigned int namelen;
 791      enum variable_origin origin;
 792      unsigned int lineno;
 793      FILE *infile;
 794      char *filename;
 795 {
 796   struct linebuffer lb;
 797   unsigned int nlines = 0;
 798   unsigned int length = 100;
 799   char *definition = (char *) xmalloc (100);
 800   register unsigned int idx = 0;
 801   register char *p;
 802
 803   /* Expand the variable name.  */
 804   char *var = (char *) alloca (namelen + 1);
 805   bcopy (name, var, namelen);
 806   var[namelen] = '\0';
 807   var = variable_expand (var);
 808
 809   initbuffer (&lb);
 810   while (!feof (infile))
 811     {
 812       lineno += nlines;
 813       nlines = readline (&lb, infile, filename, lineno);
 814
 815       collapse_continuations (lb.buffer);
 816
 817       p = next_token (lb.buffer);
 818       if ((p[5] == '\0' || isblank (p[5])) && !strncmp (p, "endef", 5))
 819         {
 820           p += 5;
 821           remove_comments (p);
 822           if (*next_token (p) != '\0')
 823             makefile_error (filename, lineno,
 824                             "Extraneous text after `endef' directive");
 825           /* Define the variable.  */
 826           if (idx == 0)
 827             definition[0] = '\0';
 828           else
 829             definition[idx - 1] = '\0';
 830           (void) define_variable (var, strlen (var), definition, origin, 1);
 831           free (definition);
 832           freebuffer (&lb);
 833           return lineno;
 834         }
 835       else
 836         {
 837           unsigned int len = strlen (lb.buffer);
 838
 839           /* Increase the buffer size if necessary.  */
 840           if (idx + len + 1 > length)
 841             {
 842               length = (idx + len) * 2;
 843               definition = (char *) xrealloc (definition, length + 1);
 844             }
 845
 846           bcopy (lb.buffer, &definition[idx], len);
 847           idx += len;
 848           /* Separate lines with a newline.  */
 849           definition[idx++] = '\n';
 850         }
 851     }
 852
 853   /* No `endef'!!  */
 854   makefile_fatal (filename, lineno, "missing `endef', unterminated `define'");
 855
 856   /* NOTREACHED */
 857   return 0;
 858 }
 859 \f
 860 /* Interpret conditional commands "ifdef", "ifndef", "ifeq",
 861    "ifneq", "else" and "endif".
 862    LINE is the input line, with the command as its first word.
 863
 864    FILENAME and LINENO are the filename and line number in the
 865    current makefile.  They are used for error messages.
 866
 867    Value is -1 if the line is invalid,
 868    0 if following text should be interpreted,
 869    1 if following text should be ignored.  */
 870
 871 static int
 872 conditional_line (line, filename, lineno)
 873      char *line;
 874      char *filename;
 875      unsigned int lineno;
 876 {
 877   int notdef;
 878   char *cmdname;
 879   register unsigned int i;
 880
 881   if (*line == 'i')
 882     {
 883       /* It's an "if..." command.  */
 884       notdef = line[2] == 'n';
 885       if (notdef)
 886         {
 887           cmdname = line[3] == 'd' ? "ifndef" : "ifneq";
 888           line += cmdname[3] == 'd' ? 7 : 6;
 889         }
 890       else
 891         {
 892           cmdname = line[2] == 'd' ? "ifdef" : "ifeq";
 893           line += cmdname[2] == 'd' ? 6 : 5;
 894         }
 895     }
 896   else
 897     {
 898       /* It's an "else" or "endif" command.  */
 899       notdef = line[1] == 'n';
 900       cmdname = notdef ? "endif" : "else";
 901       line += notdef ? 5 : 4;
 902     }
 903
 904   line = next_token (line);
 905
 906   if (*cmdname == 'e')
 907     {
 908       if (*line != '\0')
 909         makefile_error (filename, lineno,
 910                         "Extraneous text after `%s' directive",
 911                         cmdname);
 912       /* "Else" or "endif".  */
 913       if (conditionals->if_cmds == 0)
 914         makefile_fatal (filename, lineno, "extraneous `%s'", cmdname);
 915       /* NOTDEF indicates an `endif' command.  */
 916       if (notdef)
 917         --conditionals->if_cmds;
 918       else if (conditionals->seen_else[conditionals->if_cmds - 1])
 919         makefile_fatal (filename, lineno, "only one `else' per conditional");
 920       else
 921         {
 922           /* Toggle the state of ignorance.  */
 923           conditionals->ignoring[conditionals->if_cmds - 1]
 924             = !conditionals->ignoring[conditionals->if_cmds - 1];
 925           /* Record that we have seen an `else' in this conditional.
 926              A second `else' will be erroneous.  */
 927           conditionals->seen_else[conditionals->if_cmds - 1] = 1;
 928         }
 929       for (i = 0; i < conditionals->if_cmds; ++i)
 930         if (conditionals->ignoring[i])
 931           return 1;
 932       return 0;
 933     }
 934
 935   if (conditionals->allocated == 0)
 936     {
 937       conditionals->allocated = 5;
 938       conditionals->ignoring = (char *) xmalloc (conditionals->allocated);
 939       conditionals->seen_else = (char *) xmalloc (conditionals->allocated);
 940     }
 941
 942   ++conditionals->if_cmds;
 943   if (conditionals->if_cmds > conditionals->allocated)
 944     {
 945       conditionals->allocated += 5;
 946       conditionals->ignoring = (char *)
 947         xrealloc (conditionals->ignoring, conditionals->allocated);
 948       conditionals->seen_else = (char *)
 949         xrealloc (conditionals->seen_else, conditionals->allocated);
 950     }
 951
 952   /* Record that we have seen an `if...' but no `else' so far.  */
 953   conditionals->seen_else[conditionals->if_cmds - 1] = 0;
 954
 955   /* Search through the stack to see if we're already ignoring.  */
 956   for (i = 0; i < conditionals->if_cmds - 1; ++i)
 957     if (conditionals->ignoring[i])
 958       {
 959         /* We are already ignoring, so just push a level
 960            to match the next "else" or "endif", and keep ignoring.
 961            We don't want to expand variables in the condition.  */
 962         conditionals->ignoring[conditionals->if_cmds - 1] = 1;
 963         return 1;
 964       }
 965
 966   if (cmdname[notdef ? 3 : 2] == 'd')
 967     {
 968       /* "Ifdef" or "ifndef".  */
 969       struct variable *v;
 970       register char *p = end_of_token (line);
 971       i = p - line;
 972       p = next_token (p);
 973       if (*p != '\0')
 974         return -1;
 975       v = lookup_variable (line, i);
 976       conditionals->ignoring[conditionals->if_cmds - 1]
 977         = (v != 0 && *v->value != '\0') == notdef;
 978     }
 979   else
 980     {
 981       /* "Ifeq" or "ifneq".  */
 982       char *s1, *s2;
 983       unsigned int len;
 984       char termin = *line == '(' ? ',' : *line;
 985
 986       if (termin != ',' && termin != '"' && termin != '\'')
 987         return -1;
 988
 989       s1 = ++line;
 990       /* Find the end of the first string.  */
 991       if (termin == ',')
 992         {
 993           register int count = 0;
 994           for (; *line != '\0'; ++line)
 995             if (*line == '(')
 996               ++count;
 997             else if (*line == ')')
 998               --count;
 999             else if (*line == ',' && count <= 0)
1000               break;
1001         }
1002       else
1003         while (*line != '\0' && *line != termin)
1004           ++line;
1005
1006       if (*line == '\0')
1007         return -1;
1008
1009       *line++ = '\0';
1010
1011       s2 = variable_expand (s1);
1012       /* We must allocate a new copy of the expanded string because
1013          variable_expand re-uses the same buffer.  */
1014       len = strlen (s2);
1015       s1 = (char *) alloca (len + 1);
1016       bcopy (s2, s1, len + 1);
1017
1018       if (termin != ',')
1019         /* Find the start of the second string.  */
1020         line = next_token (line);
1021
1022       termin = termin == ',' ? ')' : *line;
1023       if (termin != ')' && termin != '"' && termin != '\'')
1024         return -1;
1025
1026       /* Find the end of the second string.  */
1027       if (termin == ')')
1028         {
1029           register int count = 0;
1030           s2 = next_token (line);
1031           for (line = s2; *line != '\0'; ++line)
1032             {
1033               if (*line == '(')
1034                 ++count;
1035               else if (*line == ')')
1036                 if (count <= 0)
1037                   break;
1038                 else
1039                   --count;
1040             }
1041         }
1042       else
1043         {
1044           ++line;
1045           s2 = line;
1046           while (*line != '\0' && *line != termin)
1047             ++line;
1048         }
1049
1050       if (*line == '\0')
1051         return -1;
1052
1053       *line = '\0';
1054       line = next_token (++line);
1055       if (*line != '\0')
1056         makefile_error (filename, lineno,
1057                         "Extraneous text after `%s' directive",
1058                         cmdname);
1059
1060       s2 = variable_expand (s2);
1061       conditionals->ignoring[conditionals->if_cmds - 1]
1062         = streq (s1, s2) == notdef;
1063     }
1064
1065   /* Search through the stack to see if we're ignoring.  */
1066   for (i = 0; i < conditionals->if_cmds; ++i)
1067     if (conditionals->ignoring[i])
1068       return 1;
1069   return 0;
1070 }
1071 \f
1072 /* Remove duplicate dependencies in CHAIN.  */
1073
1074 void
1075 uniquize_deps (chain)
1076      struct dep *chain;
1077 {
1078   register struct dep *d;
1079
1080   /* Make sure that no dependencies are repeated.  This does not
1081      really matter for the purpose of updating targets, but it
1082      might make some names be listed twice for $^ and $?.  */
1083
1084   for (d = chain; d != 0; d = d->next)
1085     {
1086       struct dep *last, *next;
1087
1088       last = d;
1089       next = d->next;
1090       while (next != 0)
1091         if (streq (dep_name (d), dep_name (next)))
1092           {
1093             struct dep *n = next->next;
1094             last->next = n;
1095             if (next->name != 0 && next->name != d->name)
1096               free (next->name);
1097             if (next != d)
1098               free ((char *) next);
1099             next = n;
1100           }
1101         else
1102           {
1103             last = next;
1104             next = next->next;
1105           }
1106     }
1107 }
1108 \f
1109 /* Record a description line for files FILENAMES,
1110    with dependencies DEPS, commands to execute described
1111    by COMMANDS and COMMANDS_IDX, coming from FILENAME:COMMANDS_STARTED.
1112    TWO_COLON is nonzero if a double colon was used.
1113    If not nil, PATTERN is the `%' pattern to make this
1114    a static pattern rule, and PATTERN_PERCENT is a pointer
1115    to the `%' within it.
1116
1117    The links of FILENAMES are freed, and so are any names in it
1118    that are not incorporated into other data structures.  */
1119
1120 static void
1121 record_files (filenames, pattern, pattern_percent, deps, commands_started,
1122               commands, commands_idx, two_colon, filename, lineno, set_default)
1123      struct nameseq *filenames;
1124      char *pattern, *pattern_percent;
1125      struct dep *deps;
1126      unsigned int commands_started;
1127      char *commands;
1128      unsigned int commands_idx;
1129      int two_colon;
1130      char *filename;
1131      unsigned int lineno;
1132      int set_default;
1133 {
1134   struct nameseq *nextf;
1135   int implicit = 0;
1136   unsigned int max_targets, target_idx;
1137   char **targets = 0, **target_percents = 0;
1138   struct commands *cmds;
1139
1140   if (commands_idx > 0)
1141     {
1142       cmds = (struct commands *) xmalloc (sizeof (struct commands));
1143       cmds->filename = filename;
1144       cmds->lineno = commands_started;
1145       cmds->commands = savestring (commands, commands_idx);
1146       cmds->command_lines = 0;
1147     }
1148   else
1149     cmds = 0;
1150
1151   for (; filenames != 0; filenames = nextf)
1152     {
1153       register char *name = filenames->name;
1154       register struct file *f;
1155       register struct dep *d;
1156       struct dep *this;
1157       char *implicit_percent;
1158
1159       nextf = filenames->next;
1160       free ((char *) filenames);
1161
1162       implicit_percent = find_percent (name);
1163       implicit |= implicit_percent != 0;
1164
1165       if (implicit && pattern != 0)
1166         makefile_fatal (filename, lineno,
1167                         "mixed implicit and static pattern rules");
1168
1169       if (implicit && implicit_percent == 0)
1170         makefile_fatal (filename, lineno, "mixed implicit and normal rules");
1171
1172       if (implicit)
1173         {
1174           if (targets == 0)
1175             {
1176               max_targets = 5;
1177               targets = (char **) xmalloc (5 * sizeof (char *));
1178               target_percents = (char **) xmalloc (5 * sizeof (char *));
1179               target_idx = 0;
1180             }
1181           else if (target_idx == max_targets - 1)
1182             {
1183               max_targets += 5;
1184               targets = (char **) xrealloc ((char *) targets,
1185                                             max_targets * sizeof (char *));
1186               target_percents
1187                 = (char **) xrealloc ((char *) target_percents,
1188                                       max_targets * sizeof (char *));
1189             }
1190           targets[target_idx] = name;
1191           target_percents[target_idx] = implicit_percent;
1192           ++target_idx;
1193           continue;
1194         }
1195
1196       /* If there are multiple filenames, copy the chain DEPS
1197          for all but the last one.  It is not safe for the same deps
1198          to go in more than one place in the data base.  */
1199       this = nextf != 0 ? copy_dep_chain (deps) : deps;
1200
1201       if (pattern != 0)
1202         /* If this is an extended static rule:
1203            `targets: target%pattern: dep%pattern; cmds',
1204            translate each dependency pattern into a plain filename
1205            using the target pattern and this target's name.  */
1206         if (!pattern_matches (pattern, pattern_percent, name))
1207           {
1208             /* Give a warning if the rule is meaningless.  */
1209             makefile_error (filename, lineno,
1210                             "target `%s' doesn't match the target pattern",
1211                             name);
1212             this = 0;
1213           }
1214         else
1215           {
1216             /* We use patsubst_expand to do the work of translating
1217                the target pattern, the target's name and the dependencies'
1218                patterns into plain dependency names.  */
1219             char *buffer = variable_expand ("");
1220
1221             for (d = this; d != 0; d = d->next)
1222               {
1223                 char *o;
1224                 char *percent = find_percent (d->name);
1225                 if (percent == 0)
1226                   continue;
1227                 o = patsubst_expand (buffer, name, pattern, d->name,
1228                                      pattern_percent, percent);
1229                 free (d->name);
1230                 d->name = savestring (buffer, o - buffer);
1231               }
1232           }
1233
1234       if (!two_colon)
1235         {
1236           /* Single-colon.  Combine these dependencies
1237              with others in file's existing record, if any.  */
1238           f = enter_file (name);
1239
1240           if (f->double_colon)
1241             makefile_fatal (filename, lineno,
1242                             "target file `%s' has both : and :: entries",
1243                             f->name);
1244
1245           /* If CMDS == F->CMDS, this target was listed in this rule
1246              more than once.  Just give a warning since this is harmless.  */
1247           if (cmds != 0 && cmds == f->cmds)
1248             makefile_error
1249               (filename, lineno,
1250                "target `%s' given more than once in the same rule.",
1251                f->name);
1252
1253           /* Check for two single-colon entries both with commands.
1254              Check is_target so that we don't lose on files such as .c.o
1255              whose commands were preinitialized.  */
1256           else if (cmds != 0 && f->cmds != 0 && f->is_target)
1257             {
1258               makefile_error (cmds->filename, cmds->lineno,
1259                               "warning: overriding commands for target `%s'",
1260                               f->name);
1261               makefile_error (f->cmds->filename, f->cmds->lineno,
1262                               "warning: ignoring old commands for target `%s'",
1263                               f->name);
1264             }
1265
1266           f->is_target = 1;
1267
1268           /* Defining .DEFAULT with no deps or cmds clears it.  */
1269           if (f == default_file && this == 0 && cmds == 0)
1270             f->cmds = 0;
1271           if (cmds != 0)
1272             f->cmds = cmds;
1273           /* Defining .SUFFIXES with no dependencies
1274              clears out the list of suffixes.  */
1275           if (f == suffix_file && this == 0)
1276             {
1277               d = f->deps;
1278               while (d != 0)
1279                 {
1280                   struct dep *nextd = d->next;
1281                   free (d->name);
1282                   free (d);
1283                   d = nextd;
1284                 }
1285               f->deps = 0;
1286             }
1287           else if (f->deps != 0)
1288             {
1289               /* Add the file's old deps and the new ones in THIS together.  */
1290
1291               struct dep *firstdeps, *moredeps;
1292               if (cmds != 0)
1293                 {
1294                   /* This is the rule with commands, so put its deps first.
1295                      The rationale behind this is that $< expands to the
1296                      first dep in the chain, and commands use $< expecting
1297                      to get the dep that rule specifies.  */
1298                   firstdeps = this;
1299                   moredeps = f->deps;
1300                 }
1301               else
1302                 {
1303                   /* Append the new deps to the old ones.  */
1304                   firstdeps = f->deps;
1305                   moredeps = this;
1306                 }
1307
1308               if (firstdeps == 0)
1309                 firstdeps = moredeps;
1310               else
1311                 {
1312                   d = firstdeps;
1313                   while (d->next != 0)
1314                     d = d->next;
1315                   d->next = moredeps;
1316                 }
1317
1318               f->deps = firstdeps;
1319             }
1320           else
1321             f->deps = this;
1322
1323           /* If this is a static pattern rule, set the file's stem to
1324              the part of its name that matched the `%' in the pattern,
1325              so you can use $* in the commands.  */
1326           if (pattern != 0)
1327             {
1328               static char *percent = "%";
1329               char *buffer = variable_expand ("");
1330               char *o = patsubst_expand (buffer, name, pattern, percent,
1331                                          pattern_percent, percent);
1332               f->stem = savestring (buffer, o - buffer);
1333             }
1334         }
1335       else
1336         {
1337           /* Double-colon.  Make a new record
1338              even if the file already has one.  */
1339           f = lookup_file (name);
1340           /* Check for both : and :: rules.  Check is_target so
1341              we don't lose on default suffix rules or makefiles.  */
1342           if (f != 0 && f->is_target && !f->double_colon)
1343             makefile_fatal (filename, lineno,
1344                             "target file `%s' has both : and :: entries",
1345                             f->name);
1346           f = enter_file (name);
1347           /* If there was an existing entry and it was a double-colon
1348              entry, enter_file will have returned a new one, making it the
1349              prev pointer of the old one, and setting its double_colon
1350              pointer to the first one.  */
1351           if (f->double_colon == 0)
1352             /* This is the first entry for this name, so we must
1353                set its double_colon pointer to itself.  */
1354             f->double_colon = f;
1355           f->is_target = 1;
1356           f->deps = this;
1357           f->cmds = cmds;
1358         }
1359
1360       /* Free name if not needed further.  */
1361       if (f != 0 && name != f->name
1362           && (name < f->name || name > f->name + strlen (f->name)))
1363         {
1364           free (name);
1365           name = f->name;
1366         }
1367
1368       /* See if this is first target seen whose name does
1369          not start with a `.', unless it contains a slash.  */
1370       if (default_goal_file == 0 && set_default
1371           && (*name != '.' || index (name, '/') != 0))
1372         {
1373           int reject = 0;
1374
1375           /* If this file is a suffix, don't
1376              let it be the default goal file.  */
1377
1378           for (d = suffix_file->deps; d != 0; d = d->next)
1379             {
1380               register struct dep *d2;
1381               if (*dep_name (d) != '.' && streq (name, dep_name (d)))
1382                 {
1383                   reject = 1;
1384                   break;
1385                 }
1386               for (d2 = suffix_file->deps; d2 != 0; d2 = d2->next)
1387                 {
1388                   register unsigned int len = strlen (dep_name (d2));
1389                   if (strncmp (name, dep_name (d2), len))
1390                     continue;
1391                   if (streq (name + len, dep_name (d)))
1392                     {
1393                       reject = 1;
1394                       break;
1395                     }
1396                 }
1397               if (reject)
1398                 break;
1399             }
1400
1401           if (!reject)
1402             default_goal_file = f;
1403         }
1404     }
1405
1406   if (implicit)
1407     {
1408       targets[target_idx] = 0;
1409       target_percents[target_idx] = 0;
1410       create_pattern_rule (targets, target_percents, two_colon, deps, cmds, 1);
1411       free ((char *) target_percents);
1412     }
1413 }
1414 \f
1415 /* Search STRING for an unquoted STOPCHAR or blank (if BLANK is nonzero).
1416    Backslashes quote STOPCHAR, blanks if BLANK is nonzero, and backslash.
1417    Quoting backslashes are removed from STRING by compacting it into
1418    itself.  Returns a pointer to the first unquoted STOPCHAR if there is
1419    one, or nil if there are none.  */
1420
1421 char *
1422 find_char_unquote (string, stopchar, blank)
1423      char *string;
1424      int stopchar;
1425      int blank;
1426 {
1427   unsigned int string_len = strlen (string);
1428   register char *p = string;
1429
1430   while (1)
1431     {
1432       if (blank)
1433         {
1434           while (*p != '\0' && *p != stopchar && !isblank (*p))
1435             ++p;
1436           if (*p == '\0')
1437             break;
1438         }
1439       else
1440         {
1441           p = index (p, stopchar);
1442           if (p == 0)
1443             break;
1444         }
1445       if (p > string && p[-1] == '\\')
1446         {
1447           /* Search for more backslashes.  */
1448           register int i = -2;
1449           while (&p[i] >= string && p[i] == '\\')
1450             --i;
1451           ++i;
1452           /* The number of backslashes is now -I.
1453              Copy P over itself to swallow half of them.  */
1454           bcopy (&p[i / 2], &p[i], (string_len - (p - string)) - (i / 2) + 1);
1455           p += i / 2;
1456           if (i % 2 == 0)
1457             /* All the backslashes quoted each other; the STOPCHAR was
1458                unquoted.  */
1459             return p;
1460
1461           /* The STOPCHAR was quoted by a backslash.  Look for another.  */
1462         }
1463       else
1464         /* No backslash in sight.  */
1465         return p;
1466     }
1467
1468   /* Never hit a STOPCHAR or blank (with BLANK nonzero).  */
1469   return 0;
1470 }
1471
1472 /* Search PATTERN for an unquoted %.  */
1473
1474 char *
1475 find_percent (pattern)
1476      char *pattern;
1477 {
1478   return find_char_unquote (pattern, '%', 0);
1479 }
1480
1481 /* Search STRING for an unquoted ; that is not after an unquoted #.  */
1482
1483 static char *
1484 find_semicolon (string)
1485      char *string;
1486 {
1487   return (find_char_unquote (string, '#', 0) == 0
1488           ? find_char_unquote (string, ';', 0) : 0);
1489 }
1490 \f
1491 /* Parse a string into a sequence of filenames represented as a
1492    chain of struct nameseq's in reverse order and return that chain.
1493
1494    The string is passed as STRINGP, the address of a string pointer.
1495    The string pointer is updated to point at the first character
1496    not parsed, which either is a null char or equals STOPCHAR.
1497
1498    SIZE is how big to construct chain elements.
1499    This is useful if we want them actually to be other structures
1500    that have room for additional info.
1501
1502    If STRIP is nonzero, strip `./'s off the beginning.  */
1503
1504 struct nameseq *
1505 parse_file_seq (stringp, stopchar, size, strip)
1506      char **stringp;
1507      char stopchar;
1508      unsigned int size;
1509      int strip;
1510 {
1511   register struct nameseq *new = 0;
1512   register struct nameseq *new1, *lastnew1;
1513   register char *p = *stringp;
1514   char *q;
1515   char *name;
1516
1517   while (1)
1518     {
1519       /* Skip whitespace; see if any more names are left.  */
1520       p = next_token (p);
1521       if (*p == '\0')
1522         break;
1523       if (*p == stopchar)
1524         break;
1525       /* Yes, find end of next name.  */
1526       q = p;
1527       p = find_char_unquote (q, stopchar, 1);
1528       if (p == 0)
1529         p = q + strlen (q);
1530
1531       if (strip)
1532         /* Skip leading `./'s.  */
1533         while (p - q > 2 && q[0] == '.' && q[1] == '/')
1534           {
1535             q += 2;             /* Skip "./".  */
1536             while (q < p && *q == '/')
1537               /* Skip following slashes: ".//foo" is "foo", not "/foo".  */
1538               ++q;
1539           }
1540
1541       /* Extract the filename just found, and skip it.  */
1542
1543       if (q == p)
1544         /* ".///" was stripped to "".  */
1545         name = savestring ("./", 2);
1546       else
1547         name = savestring (q, p - q);
1548
1549       /* Add it to the front of the chain.  */
1550       new1 = (struct nameseq *) xmalloc (size);
1551       new1->name = name;
1552       new1->next = new;
1553       new = new1;
1554     }
1555
1556 #ifndef NO_ARCHIVES
1557
1558   /* Look for multi-word archive references.
1559      They are indicated by a elt ending with an unmatched `)' and
1560      an elt further down the chain (i.e., previous in the file list)
1561      with an unmatched `(' (e.g., "lib(mem").  */
1562
1563   for (new1 = new, lastnew1 = 0; new1 != 0; lastnew1 = new1, new1 = new1->next)
1564     if (new1->name[0] != '('    /* Don't catch "(%)" and suchlike.  */
1565         && new1->name[strlen (new1->name) - 1] == ')'
1566         && index (new1->name, '(') == 0)
1567       {
1568         /* NEW1 ends with a `)' but does not contain a `('.
1569            Look back for an elt with an opening `(' but no closing `)'.  */
1570
1571         struct nameseq *n = new1->next, *lastn = new1;
1572         char *paren;
1573         while (n != 0 && (paren = index (n->name, '(')) == 0)
1574           {
1575             lastn = n;
1576             n = n->next;
1577           }
1578         if (n != 0
1579             /* Ignore something starting with `(', as that cannot actually
1580                be an archive-member reference (and treating it as such
1581                results in an empty file name, which causes much lossage).  */
1582             && n->name[0] != '(')
1583           {
1584             /* N is the first element in the archive group.
1585                Its name looks like "lib(mem" (with no closing `)').  */
1586
1587             char *libname;
1588
1589             /* Copy "lib(" into LIBNAME.  */
1590             ++paren;
1591             libname = (char *) alloca (paren - n->name + 1);
1592             bcopy (n->name, libname, paren - n->name);
1593             libname[paren - n->name] = '\0';
1594
1595             if (*paren == '\0')
1596               {
1597                 /* N was just "lib(", part of something like "lib( a b)".
1598                    Edit it out of the chain and free its storage.  */
1599                 lastn->next = n->next;
1600                 free (n->name);
1601                 free ((char *) n);
1602                 /* LASTN->next is the new stopping elt for the loop below.  */
1603                 n = lastn->next;
1604               }
1605             else
1606               {
1607                 /* Replace N's name with the full archive reference.  */
1608                 name = concat (libname, paren, ")");
1609                 free (n->name);
1610                 n->name = name;
1611               }
1612
1613             if (new1->name[1] == '\0')
1614               {
1615                 /* NEW1 is just ")", part of something like "lib(a b )".
1616                    Omit it from the chain and free its storage.  */
1617                 if (lastnew1 == 0)
1618                   new = new1->next;
1619                 else
1620                   lastnew1->next = new1->next;
1621                 lastn = new1;
1622                 new1 = new1->next;
1623                 free (lastn->name);
1624                 free ((char *) lastn);
1625               }
1626             else
1627               {
1628                 /* Replace also NEW1->name, which already has closing `)'.  */
1629                 name = concat (libname, new1->name, "");
1630                 free (new1->name);
1631                 new1->name = name;
1632                 new1 = new1->next;
1633               }
1634
1635             /* Trace back from NEW1 (the end of the list) until N
1636                (the beginning of the list), rewriting each name
1637                with the full archive reference.  */
1638
1639             while (new1 != n)
1640               {
1641                 name = concat (libname, new1->name, ")");
1642                 free (new1->name);
1643                 new1->name = name;
1644                 new1 = new1->next;
1645               }
1646
1647             if (new1 == 0)
1648               /* We might have slurped up the whole list,
1649                  and continuing the loop would dereference NEW1.  */
1650               break;
1651           }
1652       }
1653
1654 #endif
1655
1656   *stringp = p;
1657   return new;
1658 }
1659 \f
1660 /* Read a line of text from STREAM into LINEBUFFER.
1661    Combine continuation lines into one line.
1662    Return the number of actual lines read (> 1 if hacked continuation lines).
1663  */
1664
1665 static unsigned int
1666 readline (linebuffer, stream, filename, lineno)
1667      struct linebuffer *linebuffer;
1668      FILE *stream;
1669      char *filename;
1670      unsigned int lineno;
1671 {
1672   char *buffer = linebuffer->buffer;
1673   register char *p = linebuffer->buffer;
1674   register char *end = p + linebuffer->size;
1675   register int len, lastlen = 0;
1676   register char *p2;
1677   register unsigned int nlines = 0;
1678   register int backslash;
1679
1680   *p = '\0';
1681
1682   while (fgets (p, end - p, stream) != 0)
1683     {
1684       len = strlen (p);
1685       if (len == 0)
1686         {
1687           /* This only happens when the first thing on the line is a '\0'.
1688              It is a pretty hopeless case, but (wonder of wonders) Athena
1689              lossage strikes again!  (xmkmf puts NULs in its makefiles.)
1690              There is nothing really to be done; we synthesize a newline so
1691              the following line doesn't appear to be part of this line.  */
1692           makefile_error (filename, lineno,
1693                           "warning: NUL character seen; rest of line ignored");
1694           p[0] = '\n';
1695           len = 1;
1696         }
1697
1698       p += len;
1699       if (p[-1] != '\n')
1700         {
1701           /* Probably ran out of buffer space.  */
1702           register unsigned int p_off = p - buffer;
1703           linebuffer->size *= 2;
1704           buffer = (char *) xrealloc (buffer, linebuffer->size);
1705           p = buffer + p_off;
1706           end = buffer + linebuffer->size;
1707           linebuffer->buffer = buffer;
1708           *p = '\0';
1709           lastlen = len;
1710           continue;
1711         }
1712
1713       ++nlines;
1714
1715       if (len == 1 && p > buffer)
1716         /* P is pointing at a newline and it's the beginning of
1717            the buffer returned by the last fgets call.  However,
1718            it is not necessarily the beginning of a line if P is
1719            pointing past the beginning of the holding buffer.
1720            If the buffer was just enlarged (right before the newline),
1721            we must account for that, so we pretend that the two lines
1722            were one line.  */
1723         len += lastlen;
1724       lastlen = len;
1725       backslash = 0;
1726       for (p2 = p - 2; --len > 0; --p2)
1727         {
1728           if (*p2 == '\\')
1729             backslash = !backslash;
1730           else
1731             break;
1732         }
1733
1734       if (!backslash)
1735         {
1736           p[-1] = '\0';
1737           break;
1738         }
1739
1740       if (end - p <= 1)
1741         {
1742           /* Enlarge the buffer.  */
1743           register unsigned int p_off = p - buffer;
1744           linebuffer->size *= 2;
1745           buffer = (char *) xrealloc (buffer, linebuffer->size);
1746           p = buffer + p_off;
1747           end = buffer + linebuffer->size;
1748           linebuffer->buffer = buffer;
1749         }
1750     }
1751
1752   if (ferror (stream))
1753     pfatal_with_name (filename);
1754
1755   return nlines;
1756 }
1757 \f
1758 /* Construct the list of include directories
1759    from the arguments and the default list.  */
1760
1761 void
1762 construct_include_path (arg_dirs)
1763      char **arg_dirs;
1764 {
1765   register unsigned int i;
1766   struct stat stbuf;
1767
1768   /* Table to hold the dirs.  */
1769
1770   register unsigned int defsize = (sizeof (default_include_directories)
1771                                    / sizeof (default_include_directories[0]));
1772   register unsigned int max = 5;
1773   register char **dirs = (char **) xmalloc ((5 + defsize) * sizeof (char *));
1774   register unsigned int idx = 0;
1775
1776   /* First consider any dirs specified with -I switches.
1777      Ignore dirs that don't exist.  */
1778
1779   if (arg_dirs != 0)
1780     while (*arg_dirs != 0)
1781       {
1782         char *dir = *arg_dirs++;
1783
1784         if (dir[0] == '~')
1785           {
1786             char *expanded = tilde_expand (dir);
1787             if (expanded != 0)
1788               dir = expanded;
1789           }
1790
1791         if (stat (dir, &stbuf) == 0 && S_ISDIR (stbuf.st_mode))
1792           {
1793             if (idx == max - 1)
1794               {
1795                 max += 5;
1796                 dirs = (char **)
1797                   xrealloc ((char *) dirs, (max + defsize) * sizeof (char *));
1798               }
1799             dirs[idx++] = dir;
1800           }
1801         else if (dir != arg_dirs[-1])
1802           free (dir);
1803       }
1804
1805   /* Now add at the end the standard default dirs.  */
1806
1807   for (i = 0; default_include_directories[i] != 0; ++i)
1808     if (stat (default_include_directories[i], &stbuf) == 0
1809         && S_ISDIR (stbuf.st_mode))
1810       dirs[idx++] = default_include_directories[i];
1811
1812   dirs[idx] = 0;
1813
1814   /* Now compute the maximum length of any name in it.  */
1815
1816   max_incl_len = 0;
1817   for (i = 0; i < idx; ++i)
1818     {
1819       unsigned int len = strlen (dirs[i]);
1820       /* If dir name is written with a trailing slash, discard it.  */
1821       if (dirs[i][len - 1] == '/')
1822         /* We can't just clobber a null in because it may have come from
1823            a literal string and literal strings may not be writable.  */
1824         dirs[i] = savestring (dirs[i], len - 1);
1825       if (len > max_incl_len)
1826         max_incl_len = len;
1827     }
1828
1829   include_directories = dirs;
1830 }
1831 \f
1832 /* Expand ~ or ~USER at the beginning of NAME.
1833    Return a newly malloc'd string or 0.  */
1834
1835 char *
1836 tilde_expand (name)
1837      char *name;
1838 {
1839   if (name[1] == '/' || name[1] == '\0')
1840     {
1841       extern char *getenv ();
1842       char *home_dir;
1843       int is_variable;
1844
1845       {
1846         /* Turn off --warn-undefined-variables while we expand HOME.  */
1847         int save = warn_undefined_variables_flag;
1848         warn_undefined_variables_flag = 0;
1849
1850         home_dir = allocated_variable_expand ("$(HOME)");
1851
1852         warn_undefined_variables_flag = save;
1853       }
1854
1855       is_variable = home_dir[0] != '\0';
1856       if (!is_variable)
1857         {
1858           free (home_dir);
1859           home_dir = getenv ("HOME");
1860         }
1861       if (home_dir == 0 || home_dir[0] == '\0')
1862         {
1863           extern char *getlogin ();
1864           char *name = getlogin ();
1865           home_dir = 0;
1866           if (name != 0)
1867             {
1868               struct passwd *p = getpwnam (name);
1869               if (p != 0)
1870                 home_dir = p->pw_dir;
1871             }
1872         }
1873       if (home_dir != 0)
1874         {
1875           char *new = concat (home_dir, "", name + 1);
1876           if (is_variable)
1877             free (home_dir);
1878           return new;
1879         }
1880     }
1881   else
1882     {
1883       struct passwd *pwent;
1884       char *userend = index (name + 1, '/');
1885       if (userend != 0)
1886         *userend = '\0';
1887       pwent = getpwnam (name + 1);
1888       if (pwent != 0)
1889         {
1890           if (userend == 0)
1891             return savestring (pwent->pw_dir, strlen (pwent->pw_dir));
1892           else
1893             return concat (pwent->pw_dir, "/", userend + 1);
1894         }
1895       else if (userend != 0)
1896         *userend = '/';
1897     }
1898
1899   return 0;
1900 }
1901
1902 /* Given a chain of struct nameseq's describing a sequence of filenames,
1903    in reverse of the intended order, return a new chain describing the
1904    result of globbing the filenames.  The new chain is in forward order.
1905    The links of the old chain are freed or used in the new chain.
1906    Likewise for the names in the old chain.
1907
1908    SIZE is how big to construct chain elements.
1909    This is useful if we want them actually to be other structures
1910    that have room for additional info.  */
1911
1912 struct nameseq *
1913 multi_glob (chain, size)
1914      struct nameseq *chain;
1915      unsigned int size;
1916 {
1917   register struct nameseq *new = 0;
1918   register struct nameseq *old;
1919   struct nameseq *nexto;
1920
1921   for (old = chain; old != 0; old = nexto)
1922     {
1923       glob_t gl;
1924 #ifndef NO_ARCHIVES
1925       char *memname;
1926 #endif
1927
1928       nexto = old->next;
1929
1930       if (old->name[0] == '~')
1931         {
1932           char *newname = tilde_expand (old->name);
1933           if (newname != 0)
1934             {
1935               free (old->name);
1936               old->name = newname;
1937             }
1938         }
1939
1940 #ifndef NO_ARCHIVES
1941       if (ar_name (old->name))
1942         {
1943           /* OLD->name is an archive member reference.
1944              Replace it with the archive file name,
1945              and save the member name in MEMNAME.
1946              We will glob on the archive name and then
1947              reattach MEMNAME later.  */
1948           char *arname;
1949           ar_parse_name (old->name, &arname, &memname);
1950           free (old->name);
1951           old->name = arname;
1952         }
1953       else
1954         memname = 0;
1955 #endif
1956
1957       switch (glob (old->name, GLOB_NOCHECK, NULL, &gl))
1958         {
1959         case 0:                 /* Success.  */
1960           {
1961             register int i = gl.gl_pathc;
1962             while (i-- > 0)
1963               {
1964 #ifndef NO_ARCHIVES
1965                 if (memname != 0)
1966                   {
1967                     /* Try to glob on MEMNAME within the archive.  */
1968                     struct nameseq *found
1969                       = ar_glob (gl.gl_pathv[i], memname, size);
1970                     if (found == 0)
1971                       {
1972                         /* No matches.  Use MEMNAME as-is.  */
1973                         struct nameseq *elt
1974                           = (struct nameseq *) xmalloc (size);
1975                         unsigned int alen = strlen (gl.gl_pathv[i]);
1976                         unsigned int mlen = strlen (memname);
1977                         elt->name = (char *) xmalloc (alen + 1 + mlen + 2);
1978                         bcopy (gl.gl_pathv[i], elt->name, alen);
1979                         elt->name[alen] = '(';
1980                         bcopy (memname, &elt->name[alen + 1], mlen);
1981                         elt->name[alen + 1 + mlen] = ')';
1982                         elt->name[alen + 1 + mlen + 1] = '\0';
1983                         elt->next = new;
1984                         new = elt;
1985                       }
1986                     else
1987                       {
1988                         /* Find the end of the FOUND chain.  */
1989                         struct nameseq *f = found;
1990                         while (f->next != 0)
1991                           f = f->next;
1992
1993                         /* Attach the chain being built to the end of the FOUND
1994                            chain, and make FOUND the new NEW chain.  */
1995                         f->next = new;
1996                         new = found;
1997                       }
1998
1999                     free (memname);
2000                   }
2001                 else
2002 #endif
2003                   {
2004                     struct nameseq *elt = (struct nameseq *) xmalloc (size);
2005                     elt->name = savestring (gl.gl_pathv[i],
2006                                             strlen (gl.gl_pathv[i]));
2007                     elt->next = new;
2008                     new = elt;
2009                   }
2010               }
2011             globfree (&gl);
2012             free (old->name);
2013             free (old);
2014             break;
2015           }
2016
2017         case GLOB_NOSPACE:
2018           fatal ("virtual memory exhausted");
2019           break;
2020
2021         default:
2022           old->next = new;
2023           new = old;
2024           break;
2025         }
2026     }
2027
2028   return new;
2029 }