--- /dev/null
+/* Copyright (C) 1988, 1989, 1990, 1991 Free Software Foundation, Inc.
+This file is part of GNU Make.
+
+GNU Make is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Make is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Make; see the file COPYING. If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include "make.h"
+#include "commands.h"
+#include "dep.h"
+#include "file.h"
+#include "variable.h"
+
+/* This is POSIX.2, but most systems using -DPOSIX probably don't have it. */
+#ifdef __GNU_LIBRARY__
+#include <glob.h>
+#else
+#include "glob/glob.h"
+#endif
+
+#include <pwd.h>
+struct passwd *getpwnam ();
+
+
+static void read_makefile ();
+static unsigned int readline (), do_define ();
+static int conditional_line ();
+static void record_files ();
+static char *find_semicolon ();
+
+
+/* A `struct linebuffer' is a structure which holds a line of text.
+ `readline' reads a line from a stream into a linebuffer
+ and works regardless of the length of the line. */
+
+struct linebuffer
+ {
+ /* Note: This is the number of bytes malloc'ed for `buffer'
+ It does not indicate `buffer's real length.
+ Instead, a null char indicates end-of-string. */
+ unsigned int size;
+ char *buffer;
+ };
+
+#define initbuffer(lb) (lb)->buffer = (char *) xmalloc ((lb)->size = 200)
+#define freebuffer(lb) free ((lb)->buffer)
+
+
+/* A `struct conditionals' contains the information describing
+ all the active conditionals in a makefile.
+
+ The global variable `conditionals' contains the conditionals
+ information for the current makefile. It is initialized from
+ the static structure `toplevel_conditionals' and is later changed
+ to new structures for included makefiles. */
+
+struct conditionals
+ {
+ unsigned int if_cmds;
+ unsigned int max_ignoring;
+ char *ignoring;
+ };
+
+static struct conditionals toplevel_conditionals;
+static struct conditionals *conditionals = &toplevel_conditionals;
+
+
+/* Default directories to search for include files in */
+
+static char *default_include_directories[] =
+ {
+ "/usr/gnu/include",
+ "/usr/local/include",
+ "/usr/include",
+ 0
+ };
+
+/* List of directories to search for include files in */
+
+static char **include_directories;
+
+/* Maximum length of an element of the above. */
+
+static unsigned int max_incl_len;
+
+/* The filename and pointer to line number of the
+ makefile currently being read in. */
+
+char *reading_filename;
+unsigned int *reading_lineno_ptr;
+
+/* The chain of makefiles read by read_makefile. */
+
+static struct dep *read_makefiles = 0;
+\f
+/* Read in all the makefiles and return the chain of their names. */
+
+struct dep *
+read_all_makefiles (makefiles)
+ char **makefiles;
+{
+ unsigned int num_makefiles = 0;
+
+ if (debug_flag)
+ puts ("Reading makefiles...");
+
+ /* If there's a non-null variable MAKEFILES, its value is a list of
+ files to read first thing. But don't let it prevent reading the
+ default makefiles and don't let the default goal come from there. */
+
+ {
+ char *value = allocated_variable_expand ("$(MAKEFILES)");
+ char *name, *p;
+ unsigned int length;
+
+ /* Set NAME to the start of next token and LENGTH to its length.
+ MAKEFILES is updated for finding remaining tokens. */
+ p = value;
+ while ((name = find_next_token (&p, &length)) != 0)
+ read_makefile (name, 1);
+
+ free (value);
+ }
+
+ /* Read makefiles specified with -f switches. */
+
+ if (makefiles != 0)
+ while (*makefiles != 0)
+ {
+ struct dep *tail = read_makefiles;
+ register struct dep *d;
+
+ read_makefile (*makefiles, 0);
+
+ /* Find the right element of read_makefiles. */
+ d = read_makefiles;
+ while (d->next != tail)
+ d = d->next;
+
+ /* Use the storage read_filename allocates. */
+ free (*makefiles);
+ *makefiles = dep_name (d);
+ ++num_makefiles;
+ ++makefiles;
+ }
+
+ /* If there were no -f switches, try the default names. */
+
+ if (num_makefiles == 0)
+ {
+ static char *default_makefiles[] =
+ { "GNUmakefile", "makefile", "Makefile", 0 };
+ register char **p = default_makefiles;
+ while (*p != 0 && !file_exists_p (*p))
+ ++p;
+
+ if (*p != 0)
+ read_makefile (*p, 0);
+ else
+ {
+ /* No default makefile was found. Add the default makefiles to the
+ `read_makefiles' chain so they will be updated if possible. */
+ struct dep *tail = read_makefiles;
+ for (p = default_makefiles; *p != 0; ++p)
+ {
+ struct dep *d = (struct dep *) xmalloc (sizeof (struct dep));
+ d->name = 0;
+ d->file = enter_file (*p);
+ d->file->dontcare = 1;
+ /* Setting the `changed' member to 1 will make failure to
+ update or find this makefile as if it had come from the
+ MAKEFILES variable: we don't care, so we won't die. */
+ d->changed = 1;
+ if (tail == 0)
+ read_makefiles = d;
+ else
+ tail->next = d;
+ tail = d;
+ }
+ if (tail != 0)
+ tail->next = 0;
+ }
+ }
+
+ return read_makefiles;
+}
+\f
+/* Read file FILENAME as a makefile and add its contents to the data base.
+
+ TYPE indicates what flavor of makefile this is: 0 => a default or -f
+ makefile (the basis for comparison); 1 => from the MAKEFILES variable:
+ cannot determine the default goal, is searched for in the search path,
+ and it's not an error if it doesn't exist; 2 => an included makefile:
+ is searched for in the search path.
+
+ FILENAME is added to the `read_makefiles' chain. */
+
+static void
+read_makefile (filename, type)
+ char *filename;
+ int type;
+{
+ static char *collapsed = 0;
+ static unsigned int collapsed_length = 0;
+ register FILE *infile;
+ struct linebuffer lb;
+ unsigned int commands_len = 200;
+ char *commands = (char *) xmalloc (200);
+ unsigned int commands_idx = 0;
+ unsigned int commands_started;
+ register char *p;
+ char *p2;
+ int ignoring = 0;
+
+ struct nameseq *filenames = 0;
+ struct dep *deps;
+ unsigned int lineno = 1;
+ unsigned int nlines = 0;
+ int two_colon;
+ char *pattern = 0, *pattern_percent;
+
+#define record_waiting_files() \
+ do \
+ { \
+ record_files (filenames, pattern, pattern_percent, deps, \
+ commands_started, commands, commands_idx, \
+ two_colon, filename, lineno, type != 1); \
+ filenames = 0; \
+ commands_idx = 0; \
+ pattern = 0; \
+ } while (0)
+
+#ifdef lint /* Suppress `used before set' messages. */
+ two_colon = 0;
+#endif
+
+ /* First, get a stream to read. */
+
+ infile = fopen (filename, "r");
+
+ /* If the makefile wasn't found and it's either a makefile from
+ the `MAKEFILES' variable (type 1) or an included makefile (type 2),
+ search the included makefile search path for this makefile. */
+
+ if (infile == 0 && (type == 1 || type == 2) && *filename != '/')
+ {
+ register unsigned int i;
+ for (i = 0; include_directories[i] != 0; ++i)
+ {
+ char *name = concat (include_directories[i], "/", filename);
+ infile = fopen (name, "r");
+ if (infile != 0)
+ {
+ filename = name;
+ break;
+ }
+ else
+ free (name);
+ }
+ }
+
+ /* Add FILENAME to the chain of read makefiles. */
+ deps = (struct dep *) xmalloc (sizeof (struct dep));
+ deps->next = read_makefiles;
+ read_makefiles = deps;
+ deps->name = 0;
+ deps->file = lookup_file (filename);
+ if (deps->file == 0)
+ {
+ deps->file = enter_file (savestring (filename, strlen (filename)));
+ if (type == 1)
+ deps->file->dontcare = 1;
+ }
+ filename = deps->file->name;
+ deps->file->precious = 1;
+ deps->changed = type;
+ deps = 0;
+
+ /* If the makefile can't be found at all,
+ either ignore it or give up entirely. */
+
+ if (infile == 0)
+ {
+ if (type != 1)
+ perror_with_name ("fopen: ", filename);
+ return;
+ }
+
+ reading_filename = filename;
+ reading_lineno_ptr = &lineno;
+
+ /* Loop over lines in the file.
+ The strategy is to accumulate target names in FILENAMES, dependencies
+ in DEPS and commands in COMMANDS. These are used to define a rule
+ when the start of the next rule (or eof) is encountered. */
+
+ initbuffer (&lb);
+
+ while (!feof (infile))
+ {
+ lineno += nlines;
+ nlines = readline (&lb, infile, filename);
+
+ if (collapsed_length < lb.size)
+ {
+ collapsed_length = lb.size;
+ if (collapsed != 0)
+ free (collapsed);
+ collapsed = (char *) xmalloc (collapsed_length);
+ }
+ strcpy (collapsed, lb.buffer);
+ /* Collapse continuation lines. */
+ collapse_continuations (collapsed);
+ remove_comments (collapsed);
+
+ p = collapsed;
+ while (isspace (*p))
+ ++p;
+ if (*p == '\0' && lb.buffer[0] != '\t')
+ continue;
+
+#define word1eq(s, l) ((p[l] == '\0' || isblank (p[l])) && \
+ !strncmp (s, p, l))
+ if (word1eq ("ifdef", 5) || word1eq ("ifndef", 6)
+ || word1eq ("ifeq", 4) || word1eq ("ifneq", 5)
+ || word1eq ("else", 4) || word1eq ("endif", 5))
+ {
+ int i = conditional_line (p, filename, lineno);
+ if (i >= 0)
+ {
+ ignoring = i;
+ continue;
+ }
+ else
+ makefile_fatal (filename, lineno,
+ "invalid syntax in conditional");
+ }
+ else if (word1eq ("endef", 5))
+ makefile_fatal (filename, lineno, "extraneous `endef'");
+ if (ignoring)
+ continue;
+ else if (lb.buffer[0] == '\t')
+ {
+ /* This line is a shell command. */
+ unsigned int len;
+
+ if (filenames == 0)
+ makefile_fatal (filename, lineno,
+ "commands commence before first target");
+
+ /* Add this command line to end of the line being accumulated. */
+ p = lb.buffer;
+ if (commands_idx == 0)
+ commands_started = lineno;
+ len = strlen (p);
+ if (len + 1 + commands_idx > commands_len)
+ {
+ commands_len = (len + 1 + commands_idx) * 2;
+ commands = (char *) xrealloc (commands, commands_len);
+ }
+ bcopy (p, &commands[commands_idx], len);
+ commands_idx += len;
+ commands[commands_idx++] = '\n';
+ }
+ else if (word1eq ("define", 6))
+ {
+ p2 = next_token (p + 6);
+ p = end_of_token (p2);
+ lineno = do_define (p2, p - p2, o_file, lineno, infile, filename);
+ continue;
+ }
+ else if (word1eq ("override", 8))
+ {
+ p2 = next_token (p + 8);
+ if (p2 == 0)
+ makefile_error (filename, lineno, "empty `override' directive");
+ if (!strncmp (p2, "define", 6))
+ {
+ unsigned int len;
+ p2 = end_of_token (p2);
+ p = find_next_token (&p2, &len);
+ lineno = do_define (p, len, o_override,
+ lineno, infile, filename);
+ }
+ else if (!try_variable_definition (p2, o_override))
+ makefile_error (filename, lineno,
+ "Empty `override' directive");
+ continue;
+ }
+ else if (word1eq ("include", 7))
+ {
+ /* We have found an `include' line specifying a nested
+ makefile to be read at this point. */
+ struct conditionals *save = conditionals;
+ struct conditionals new_conditionals;
+ p = allocated_variable_expand (next_token (p + 8));
+ if (*p == '\0')
+ {
+ makefile_error (filename, lineno, "no filename for `include'");
+ continue;
+ }
+ p2 = end_of_token (p);
+ if (*p2 != '\0')
+ {
+ *p2++ = '\0';
+ if (*next_token (p2) != '\0')
+ makefile_error (filename, lineno,
+ "extraneous text after `include'");
+ }
+ bzero ((char *) &new_conditionals, sizeof new_conditionals);
+ conditionals = &new_conditionals;
+ /* Record the rules that are waiting so they will determine
+ the default goal before those in the included makefile. */
+ record_waiting_files ();
+ read_makefile (p, 2);
+ free (p);
+ conditionals = save;
+ reading_filename = filename;
+ reading_lineno_ptr = &lineno;
+ continue;
+ }
+ else if (word1eq ("vpath", 5))
+ {
+ char *pattern;
+ unsigned int len;
+ p2 = variable_expand (p + 5);
+ p = find_next_token (&p2, &len);
+ if (p != 0)
+ {
+ pattern = savestring (p, len);
+ p = find_next_token (&p2, &len);
+ if (p != 0)
+ {
+ p = savestring (p, len);
+ if (find_next_token (&p2, (unsigned int *) 0) != 0)
+ makefile_error (filename, lineno,
+ "extraneous text after `vpath' directive");
+ }
+ /* No searchpath means remove all previous
+ selective VPATH's with the same pattern. */
+ }
+ else
+ /* No pattern means remove all previous selective VPATH's. */
+ pattern = 0;
+ construct_vpath_list (pattern, p);
+ if (pattern != 0)
+ free (pattern);
+ if (p != 0)
+ free (p);
+ continue;
+ }
+#undef word1eq
+ else if (try_variable_definition (p, o_file))
+ continue;
+ else
+ {
+ /* This line describes some target files. */
+
+ char *cmdleft;
+
+ /* Record the previous rule. */
+
+ record_waiting_files ();
+
+ /* Look for a semicolon in the unexpanded line. */
+ cmdleft = find_semicolon (lb.buffer);
+ if (cmdleft != 0)
+ /* Found one. Cut the line short there before expanding it. */
+ *cmdleft = '\0';
+
+ collapse_continuations (lb.buffer);
+
+ /* Expand variable and function references before doing anything
+ else so that special characters can be inside variables. */
+ p = variable_expand (lb.buffer);
+
+ if (cmdleft == 0)
+ /* Look for a semicolon in the expanded line. */
+ cmdleft = find_semicolon (p);
+
+ if (cmdleft != 0)
+ /* Cut the line short at the semicolon. */
+ *cmdleft = '\0';
+
+ /* Remove comments from the line. */
+ remove_comments (p);
+
+ p2 = next_token (p);
+ if (*p2 == '\0')
+ {
+ if (cmdleft != 0)
+ makefile_fatal (filename, lineno,
+ "missing rule before commands");
+ else
+ /* This line contained a variable reference that
+ expanded to nothing but whitespace. */
+ continue;
+ }
+ else if (*p2 == ':')
+ makefile_fatal (filename, lineno, "missing target name");
+
+ filenames = multi_glob (parse_file_seq (&p2, ':',
+ sizeof (struct nameseq), 1),
+ sizeof (struct nameseq));
+ if (*p2++ == '\0')
+ makefile_fatal (filename, lineno, "missing separator");
+ /* Is this a one-colon or two-colon entry? */
+ two_colon = *p2 == ':';
+ if (two_colon)
+ p2++;
+
+ /* Is this a static pattern rule: `target: %targ: %dep; ...'? */
+ p = index (p2, ':');
+ while (p != 0 && p[-1] == '\\')
+ {
+ register char *q = &p[-1];
+ register int backslash = 0;
+ while (*q-- == '\\')
+ backslash = !backslash;
+ if (backslash)
+ p = index (p + 1, ':');
+ else
+ break;
+ }
+ if (p != 0)
+ {
+ struct nameseq *target;
+ target = parse_file_seq (&p2, ':', sizeof (struct nameseq), 1);
+ ++p2;
+ if (target == 0)
+ makefile_fatal (filename, lineno, "missing target pattern");
+ else if (target->next != 0)
+ makefile_fatal (filename, lineno, "multiple target patterns");
+ pattern = target->name;
+ pattern_percent = find_percent (pattern);
+ if (pattern_percent == 0)
+ makefile_fatal (filename, lineno,
+ "target pattern contains no `%%'");
+ }
+ else
+ pattern = 0;
+
+ /* Parse the dependencies. */
+ deps = (struct dep *)
+ multi_glob (parse_file_seq (&p2, '\0', sizeof (struct dep), 1),
+ sizeof (struct dep));
+
+ commands_idx = 0;
+ if (cmdleft != 0)
+ {
+ /* Semicolon means rest of line is a command. */
+ unsigned int len = strlen (cmdleft + 1);
+
+ commands_started = lineno;
+
+ /* Add this command line to the buffer. */
+ if (len + 2 > commands_len)
+ {
+ commands_len = (len + 2) * 2;
+ commands = (char *) xrealloc (commands, commands_len);
+ }
+ bcopy (cmdleft + 1, commands, len);
+ commands_idx += len;
+ commands[commands_idx++] = '\n';
+ }
+ }
+ }
+
+ if (ignoring)
+ makefile_fatal (filename, lineno, "missing `endif'");
+
+ /* At eof, record the last rule. */
+ record_waiting_files ();
+
+ freebuffer (&lb);
+ free ((char *) commands);
+ fclose (infile);
+
+ reading_filename = 0;
+ reading_lineno_ptr = 0;
+}
+\f
+/* Execute a `define' directive.
+ The first line has already been read, and NAME is the name of
+ the variable to be defined. The following lines remain to be read.
+ LINENO, INFILE and FILENAME refer to the makefile being read.
+ The value returned is LINENO, updated for lines read here. */
+
+static unsigned int
+do_define (name, namelen, origin, lineno, infile, filename)
+ char *name;
+ unsigned int namelen;
+ enum variable_origin origin;
+ unsigned int lineno;
+ FILE *infile;
+ char *filename;
+{
+ struct linebuffer lb;
+ unsigned int nlines = 0;
+ unsigned int length = 100;
+ char *definition = (char *) xmalloc (100);
+ register unsigned int idx = 0;
+ register char *p;
+
+ initbuffer (&lb);
+ while (!feof (infile))
+ {
+ lineno += nlines;
+ nlines = readline (&lb, infile, filename);
+ p = next_token (lb.buffer);
+
+ if ((p[5] == '\0' || isblank (p[5])) && !strncmp (p, "endef", 5))
+ {
+ p += 5;
+ collapse_continuations (p);
+ remove_comments (p);
+ if (*next_token (p) != '\0')
+ makefile_error (filename, lineno,
+ "Extraneous text after `endef' directive");
+ /* Define the variable. */
+ if (idx == 0)
+ definition[0] = '\0';
+ else
+ definition[idx - 1] = '\0';
+ (void) define_variable (name, namelen, definition, origin, 1);
+ free (definition);
+ return lineno;
+ }
+ else
+ {
+ unsigned int len = strlen (p);
+
+ /* Increase the buffer size if necessary. */
+ if (idx + len + 1 > length)
+ {
+ length = (idx + len) * 2;
+ definition = (char *) xrealloc (definition, length + 1);
+ }
+
+ bcopy (p, &definition[idx], len);
+ idx += len;
+ /* Separate lines with a newline. */
+ definition[idx++] = '\n';
+ }
+ }
+
+ /* No `endef'!! */
+ makefile_fatal (filename, lineno, "missing `endef', unterminated `define'");
+ return 0;
+}
+\f
+/* Interpret conditional commands "ifdef", "ifndef", "ifeq",
+ "ifneq", "else" and "endif".
+ LINE is the input line, with the command as its first word.
+
+ FILENAME and LINENO are the filename and line number in the
+ current makefile. They are used for error messages.
+
+ Value is -1 if the line is invalid,
+ 0 if following text should be interpreted,
+ 1 if following text should be ignored. */
+
+static int
+conditional_line (line, filename, lineno)
+ char *line;
+ char *filename;
+ unsigned int lineno;
+{
+ int notdef;
+ char *cmdname;
+ register unsigned int i;
+
+ if (*line == 'i')
+ {
+ /* It's an "if..." command. */
+ notdef = line[2] == 'n';
+ if (notdef)
+ {
+ cmdname = line[3] == 'd' ? "ifndef" : "ifneq";
+ line += cmdname[3] == 'd' ? 7 : 6;
+ }
+ else
+ {
+ cmdname = line[2] == 'd' ? "ifdef" : "ifeq";
+ line += cmdname[2] == 'd' ? 6 : 5;
+ }
+ }
+ else
+ {
+ /* It's an "else" or "endif" command. */
+ notdef = line[1] == 'n';
+ cmdname = notdef ? "endif" : "else";
+ line += notdef ? 5 : 4;
+ }
+
+ line = next_token (line);
+
+ if (*cmdname == 'e')
+ {
+ if (*line != '\0')
+ makefile_error (filename, lineno,
+ "Extraneous text after `%s' directive",
+ cmdname);
+ /* "Else" or "endif". */
+ if (conditionals->if_cmds == 0)
+ makefile_fatal (filename, lineno, "extraneous `%s'", cmdname);
+ /* NOTDEF indicates an `endif' command. */
+ if (notdef)
+ --conditionals->if_cmds;
+ else
+ conditionals->ignoring[conditionals->if_cmds - 1]
+ = !conditionals->ignoring[conditionals->if_cmds - 1];
+ for (i = 0; i < conditionals->if_cmds; ++i)
+ if (conditionals->ignoring[i])
+ return 1;
+ return 0;
+ }
+
+ if (conditionals->max_ignoring == 0)
+ {
+ conditionals->max_ignoring = 5;
+ conditionals->ignoring = (char *) xmalloc (conditionals->max_ignoring);
+ }
+
+ ++conditionals->if_cmds;
+ if (conditionals->if_cmds > conditionals->max_ignoring)
+ {
+ conditionals->max_ignoring += 5;
+ conditionals->ignoring = (char *)
+ xrealloc (conditionals->ignoring, conditionals->max_ignoring);
+ }
+
+ if (conditionals->if_cmds > 1 &&
+ conditionals->ignoring[conditionals->if_cmds - 2])
+ /* We are already ignoring, so just push a level
+ to match the next "else" or "endif", and keep ignoring. */
+ conditionals->ignoring[conditionals->if_cmds - 1] = 1;
+ else if (cmdname[notdef ? 3 : 2] == 'd')
+ {
+ /* "Ifdef" or "ifndef". */
+ struct variable *v;
+ register char *p = end_of_token (line);
+ i = p - line;
+ p = next_token (p);
+ if (*p != '\0')
+ return -1;
+ v = lookup_variable (line, i);
+ conditionals->ignoring[conditionals->if_cmds - 1]
+ = (v != 0 && *v->value != '\0') == notdef;
+ }
+ else
+ {
+ /* "Ifeq" or "ifneq". */
+ char *s1, *s2;
+ unsigned int len;
+ char termin = *line == '(' ? ',' : *line;
+
+ if (termin != ',' && termin != '"' && termin != '\'')
+ return -1;
+
+ s1 = ++line;
+ /* Find the end of the first string. */
+ if (termin == ',')
+ {
+ register int count = 0;
+ for (; *line != '\0'; ++line)
+ if (*line == '(')
+ ++count;
+ else if (*line == ')')
+ --count;
+ else if (*line == ',' && count <= 0)
+ break;
+ }
+ else
+ while (*line != '\0' && *line != termin)
+ ++line;
+
+ if (*line == '\0')
+ return -1;
+
+ *line++ = '\0';
+
+ s2 = variable_expand (s1);
+ /* We must allocate a new copy of the expanded string because
+ variable_expand re-uses the same buffer. */
+ len = strlen (s2);
+ s1 = (char *) alloca (len + 1);
+ bcopy (s2, s1, len + 1);
+
+ if (termin != ',')
+ /* Find the start of the second string. */
+ line = next_token (line);
+
+ termin = termin == ',' ? ')' : *line;
+ if (termin != ')' && termin != '"' && termin != '\'')
+ return -1;
+
+ /* Find the end of the second string. */
+ if (termin == ')')
+ {
+ register int count = 0;
+ s2 = next_token (line);
+ for (line = s2; *line != '\0'; ++line)
+ {
+ if (*line == '(')
+ ++count;
+ else if (*line == ')')
+ if (count <= 0)
+ break;
+ else
+ --count;
+ }
+ }
+ else
+ {
+ ++line;
+ s2 = line;
+ while (*line != '\0' && *line != termin)
+ ++line;
+ }
+
+ if (*line == '\0')
+ return -1;
+
+ *line = '\0';
+ line = next_token (++line);
+ if (*line != '\0')
+ makefile_error (filename, lineno,
+ "Extraneous text after `%s' directive",
+ cmdname);
+
+ s2 = variable_expand (s2);
+ conditionals->ignoring[conditionals->if_cmds - 1]
+ = streq (s1, s2) == notdef;
+ }
+
+ /* Search through the stack to see if we're ignoring. */
+ for (i = 0; i < conditionals->if_cmds; ++i)
+ if (conditionals->ignoring[i])
+ return 1;
+ return 0;
+}
+\f
+/* Remove duplicate dependencies in CHAIN. */
+
+void
+uniquize_deps (chain)
+ struct dep *chain;
+{
+ register struct dep *d;
+
+ /* Make sure that no dependencies are repeated. This does not
+ really matter for the purpose of updating targets, but it
+ might make some names be listed twice for $^ and $?. */
+
+ for (d = chain; d != 0; d = d->next)
+ {
+ struct dep *last, *next;
+
+ last = d;
+ next = d->next;
+ while (next != 0)
+ if (streq (dep_name (d), dep_name (next)))
+ {
+ struct dep *n = next->next;
+ last->next = n;
+ if (next->name != 0 && next->name != d->name)
+ free (next->name);
+ if (next != d)
+ free ((char *) next);
+ next = n;
+ }
+ else
+ {
+ last = next;
+ next = next->next;
+ }
+ }
+}
+\f
+/* Record a description line for files FILENAMES,
+ with dependencies DEPS, commands to execute described
+ by COMMANDS and COMMANDS_IDX, coming from FILENAME:COMMANDS_STARTED.
+ TWO_COLON is nonzero if a double colon was used.
+ If not nil, PATTERN is the `%' pattern to make this
+ a static pattern rule, and PATTERN_PERCENT is a pointer
+ to the `%' within it.
+
+ The links of FILENAMES are freed, and so are any names in it
+ that are not incorporated into other data structures. */
+
+static void
+record_files (filenames, pattern, pattern_percent, deps, commands_started,
+ commands, commands_idx, two_colon, filename, lineno, set_default)
+ struct nameseq *filenames;
+ char *pattern, *pattern_percent;
+ struct dep *deps;
+ unsigned int commands_started;
+ char *commands;
+ unsigned int commands_idx;
+ int two_colon;
+ char *filename;
+ unsigned int lineno;
+ int set_default;
+{
+ struct nameseq *nextf;
+ int implicit = 0;
+ unsigned int max_targets, target_idx;
+ char **targets = 0, **target_percents = 0;
+ struct commands *cmds;
+
+ if (commands_idx > 0)
+ {
+ cmds = (struct commands *) xmalloc (sizeof (struct commands));
+ cmds->filename = filename;
+ cmds->lineno = commands_started;
+ cmds->commands = savestring (commands, commands_idx);
+ cmds->command_lines = 0;
+ }
+ else
+ cmds = 0;
+
+ for (; filenames != 0; filenames = nextf)
+ {
+ register char *name = filenames->name;
+ register struct file *f;
+ register struct dep *d;
+ struct dep *this;
+ char *implicit_percent;
+
+ nextf = filenames->next;
+ free ((char *) filenames);
+
+ implicit_percent = find_percent (name);
+ implicit |= implicit_percent != 0;
+
+ if (implicit && pattern != 0)
+ makefile_fatal (filename, lineno,
+ "mixed implicit and static pattern rules");
+
+ if (implicit && implicit_percent == 0)
+ makefile_fatal (filename, lineno, "mixed implicit and normal rules");
+
+ if (implicit)
+ {
+ if (targets == 0)
+ {
+ max_targets = 5;
+ targets = (char **) xmalloc (5 * sizeof (char *));
+ target_percents = (char **) xmalloc (5 * sizeof (char *));
+ target_idx = 0;
+ }
+ else if (target_idx == max_targets - 1)
+ {
+ max_targets += 5;
+ targets = (char **) xrealloc ((char *) targets,
+ max_targets * sizeof (char *));
+ target_percents
+ = (char **) xrealloc ((char *) target_percents,
+ max_targets * sizeof (char *));
+ }
+ targets[target_idx] = name;
+ target_percents[target_idx] = implicit_percent;
+ ++target_idx;
+ continue;
+ }
+
+ /* If there are multiple filenames, copy the chain DEPS
+ for all but the last one. It is not safe for the same deps
+ to go in more than one place in the data base. */
+ this = nextf != 0 ? copy_dep_chain (deps) : deps;
+
+ if (pattern != 0)
+ /* If this is an extended static rule:
+ `targets: target%pattern: dep%pattern; cmds',
+ translate each dependency pattern into a plain filename
+ using the target pattern and this target's name. */
+ if (!pattern_matches (pattern, pattern_percent, name))
+ {
+ /* Give a warning if the rule is meaningless. */
+ makefile_error (filename, lineno,
+ "target `%s' doesn't match the target pattern",
+ name);
+ this = 0;
+ }
+ else
+ {
+ /* We use patsubst_expand to do the work of translating
+ the target pattern, the target's name and the dependencies'
+ patterns into plain dependency names. */
+ char *buffer = variable_expand ("");
+
+ for (d = this; d != 0; d = d->next)
+ {
+ char *o;
+ char *percent = find_percent (d->name);
+ if (percent == 0)
+ continue;
+ o = patsubst_expand (buffer, name, pattern, d->name,
+ pattern_percent, percent);
+ free (d->name);
+ d->name = savestring (buffer, o - buffer);
+ }
+ }
+
+ if (!two_colon)
+ {
+ /* Single-colon. Combine these dependencies
+ with others in file's existing record, if any. */
+ f = enter_file (name);
+
+ if (f->double_colon)
+ makefile_fatal (filename, lineno,
+ "target file `%s' has both : and :: entries",
+ f->name);
+
+ /* If CMDS == F->CMDS, this target was listed in this rule
+ more than once. Just give a warning since this is harmless. */
+ if (cmds != 0 && cmds == f->cmds)
+ makefile_error
+ (filename, lineno,
+ "target `%s' given more than once in the same rule.",
+ f->name);
+
+ /* Check for two single-colon entries both with commands.
+ Check is_target so that we don't lose on files such as .c.o
+ whose commands were preinitialized. */
+ else if (cmds != 0 && f->cmds != 0 && f->is_target)
+ {
+ makefile_error (cmds->filename, cmds->lineno,
+ "warning: overriding commands for target `%s'",
+ f->name);
+ makefile_error (f->cmds->filename, f->cmds->lineno,
+ "warning: ignoring old commands for target `%s'",
+ f->name);
+ }
+
+ f->is_target = 1;
+
+ /* Defining .DEFAULT with no deps or cmds clears it. */
+ if (f == default_file && this == 0 && cmds == 0)
+ f->cmds = 0;
+ if (cmds != 0)
+ f->cmds = cmds;
+ /* Defining .SUFFIXES with no dependencies
+ clears out the list of suffixes. */
+ if (f == suffix_file && this == 0)
+ f->deps = 0;
+ else if (f->deps != 0)
+ {
+ d = f->deps;
+ while (d->next != 0)
+ d = d->next;
+ d->next = this;
+ }
+ else
+ f->deps = this;
+
+ uniquize_deps (f->deps);
+
+ /* If this is a static pattern rule, set the file's stem to
+ the part of its name that matched the `%' in the pattern,
+ so you can use $* in the commands. */
+ if (pattern != 0)
+ {
+ static char *percent = "%";
+ char *buffer = variable_expand ("");
+ char *o = patsubst_expand (buffer, name, pattern, percent,
+ pattern_percent, percent);
+ f->stem = savestring (buffer, o - buffer);
+ }
+ }
+ else
+ {
+ /* Double-colon. Make a new record
+ even if the file already has one. */
+ f = lookup_file (name);
+ /* Check for both : and :: rules. Check is_target so
+ we don't lose on default suffix rules or makefiles. */
+ if (f != 0 && f->is_target && !f->double_colon)
+ makefile_fatal (filename, lineno,
+ "target file `%s' has both : and :: entries",
+ f->name);
+ f = enter_file (name);
+ /* If there was an existing entry and it was a
+ double-colon entry, enter_file will have returned a
+ new one, making it the prev pointer of the old one. */
+ f->is_target = 1;
+ f->double_colon = 1;
+ f->deps = this;
+ f->cmds = cmds;
+ }
+
+ /* Free name if not needed further. */
+ if (f != 0 && name != f->name
+ && !(f->name == name + 2 && name[0] == '.' && name[1] == '/'))
+ {
+ free (name);
+ name = f->name;
+ }
+
+ /* See if this is first target seen whose name does
+ not start with a `.', unless it contains a slash. */
+ if (default_goal_file == 0 && set_default
+ && (*name != '.' || index (name, '/') != 0))
+ {
+ int reject = 0;
+
+ /* If this file is a suffix, don't
+ let it be the default goal file. */
+
+ for (d = suffix_file->deps; d != 0; d = d->next)
+ {
+ register struct dep *d2;
+ if (*dep_name (d) != '.' && streq (name, dep_name (d)))
+ {
+ reject = 1;
+ break;
+ }
+ for (d2 = suffix_file->deps; d2 != 0; d2 = d2->next)
+ {
+ register unsigned int len = strlen (dep_name (d2));
+ if (strncmp (name, dep_name (d2), len))
+ continue;
+ if (streq (name + len, dep_name (d)))
+ {
+ reject = 1;
+ break;
+ }
+ }
+ if (reject)
+ break;
+ }
+
+ if (!reject)
+ default_goal_file = f;
+ }
+ }
+
+ if (implicit)
+ {
+ targets[target_idx] = 0;
+ target_percents[target_idx] = 0;
+ create_pattern_rule (targets, target_percents, two_colon, deps, cmds, 1);
+ free ((char *) target_percents);
+ }
+}
+\f
+/* Search STRING for an unquoted ; that is not after an unquoted #. */
+
+static char *
+find_semicolon (string)
+ char *string;
+{
+ char *found, *p;
+
+ found = index (string, ';');
+ while (found != 0 && found[-1] == '\\')
+ {
+ register char *q = &found[-1];
+ register int backslash = 0;
+ while (*q-- == '\\')
+ backslash = !backslash;
+ if (backslash)
+ found = index (found + 1, ';');
+ else
+ break;
+ }
+ if (found == 0)
+ return 0;
+
+ /* Look for a comment character (#) before the ; we found. */
+ p = lindex (string, found, '#');
+ while (p != 0 && p[-1] == '\\')
+ {
+ register char *q = &p[-1];
+ register int backslash = 0;
+ while (*q-- == '\\')
+ backslash = !backslash;
+ if (backslash)
+ p = lindex (p + 1, found, '#');
+ else
+ break;
+ }
+ if (p == 0)
+ return found;
+ return 0;
+}
+\f
+/* Search PATTERN for an unquoted %. Backslashes quote % and backslash.
+ Quoting backslashes are removed from PATTERN by compacting it into
+ itself. Returns a pointer to the first unquoted % if there is one,
+ or nil if there are none. */
+
+char *
+find_percent (pattern)
+ char *pattern;
+{
+ unsigned int pattern_len = strlen (pattern);
+ register char *p = pattern;
+
+ while ((p = index (p, '%')) != 0)
+ if (p > pattern && p[-1] == '\\')
+ {
+ /* Search for more backslashes. */
+ register int i = -2;
+ while (&p[i] >= pattern && p[i] == '\\')
+ --i;
+ ++i;
+ /* The number of backslashes is now -I.
+ Copy P over itself to swallow half of them. */
+ bcopy (&p[i / 2], &p[i], (pattern_len - (p - pattern)) - (i / 2) + 1);
+ p += i / 2;
+ if (i % 2 == 0)
+ /* All the backslashes quoted each other; the % was unquoted. */
+ return p;
+ else
+ /* The % was quoted by a backslash. Look for another. */
+ ++p;
+ }
+ else
+ /* No backslash in sight. */
+ return p;
+
+ /* Never hit a %. */
+ return 0;
+}
+\f
+/* Parse a string into a sequence of filenames represented as a
+ chain of struct nameseq's in reverse order and return that chain.
+
+ The string is passed as STRINGP, the address of a string pointer.
+ The string pointer is updated to point at the first character
+ not parsed, which either is a null char or equals STOPCHAR.
+
+ SIZE is how big to construct chain elements.
+ This is useful if we want them actually to be other structures
+ that have room for additional info. */
+
+struct nameseq *
+parse_file_seq (stringp, stopchar, size, strip)
+ char **stringp;
+ char stopchar;
+ unsigned int size;
+ int strip;
+{
+ register struct nameseq *new = 0;
+ register struct nameseq *new1;
+ register char *p = *stringp;
+ char *q;
+ char *name;
+ register int c;
+
+ while (1)
+ {
+ /* Skip whitespace; see if any more names are left. */
+ p = next_token (p);
+ if (*p == '\0')
+ break;
+ if (*p == stopchar)
+ break;
+ /* Yes, find end of next name. */
+ q = p;
+ while (1)
+ {
+ c = *p++;
+ if (c == '\0')
+ break;
+ else if (c == '\\' &&
+ (*p == '\\' || isblank (*p) || *p == stopchar))
+ ++p;
+ else if (isblank (c) || c == stopchar)
+ break;
+ }
+ p--;
+
+ if (strip)
+ while (q[0] == '.' && q[1] == '/' && q[2] != '\0')
+ q += 2;
+
+ /* Extract the filename just found, and skip it. */
+ name = savestring (q, p - q);
+
+ /* Add it to the front of the chain. */
+ new1 = (struct nameseq *) xmalloc (size);
+ new1->name = name;
+ new1->next = new;
+ new = new1;
+ }
+
+ *stringp = p;
+ return new;
+}
+\f
+/* Read a line of text from STREAM into LINEBUFFER.
+ Combine continuation lines into one line.
+ Return the number of actual lines read (> 1 if hacked continuation lines).
+ */
+
+static unsigned int
+readline (linebuffer, stream, filename)
+ struct linebuffer *linebuffer;
+ FILE *stream;
+ char *filename;
+{
+ char *buffer = linebuffer->buffer;
+ register char *p = linebuffer->buffer;
+ register char *end = p + linebuffer->size;
+ register int len, lastlen = 0;
+ register char *p2;
+ register unsigned int nlines = 0;
+ register int backslash;
+
+ *p = '\0';
+
+ while (1)
+ {
+ if (fgets (p, end - p, stream) == 0)
+ if (feof (stream))
+ return nlines;
+ else
+ pfatal_with_name (filename);
+
+ len = strlen (p);
+ if (len == 0 || (p += len)[-1] != '\n')
+ {
+ /* Probably ran out of buffer space. */
+ register unsigned int p_off = p - buffer;
+ linebuffer->size *= 2;
+ buffer = (char *) xrealloc (buffer, linebuffer->size);
+ p = buffer + p_off;
+ end = buffer + linebuffer->size;
+ linebuffer->buffer = buffer;
+ *p = '\0';
+ lastlen = len;
+ continue;
+ }
+
+ ++nlines;
+
+ if (len == 1 && p > buffer)
+ /* P is pointing at a newline and it's the beginning of
+ the buffer returned by the last fgets call. However,
+ it is not necessarily the beginning of a line if P is
+ pointing past the beginning of the holding buffer.
+ If the buffer was just enlarged (right before the newline),
+ we must account for that, so we pretend that the two lines
+ were one line. */
+ len += lastlen;
+ lastlen = len;
+ backslash = 0;
+ for (p2 = p - 2; --len > 0; --p2)
+ {
+ if (*p2 == '\\')
+ backslash = !backslash;
+ else
+ break;
+ }
+
+ if (!backslash)
+ {
+ p[-1] = '\0';
+ return nlines;
+ }
+
+ if (end - p <= 1)
+ {
+ /* Enlarge the buffer. */
+ register unsigned int p_off = p - buffer;
+ linebuffer->size *= 2;
+ buffer = (char *) xrealloc (buffer, linebuffer->size);
+ p = buffer + p_off;
+ end = buffer + linebuffer->size;
+ linebuffer->buffer = buffer;
+ }
+ }
+}
+\f
+/* Construct the list of include directories
+ from the arguments and the default list. */
+
+void
+construct_include_path (arg_dirs)
+ char **arg_dirs;
+{
+ register unsigned int i;
+ struct stat stbuf;
+
+ /* Table to hold the dirs. */
+
+ register unsigned int defsize = (sizeof (default_include_directories)
+ / sizeof (default_include_directories[0]));
+ register unsigned int max = 5;
+ register char **dirs = (char **) xmalloc ((5 + defsize) * sizeof (char *));
+ register unsigned int idx = 0;
+
+ /* First consider any dirs specified with -I switches.
+ Ignore dirs that don't exist. */
+
+ if (arg_dirs != 0)
+ while (*arg_dirs != 0)
+ {
+ char *dir = *arg_dirs++;
+ if (stat (dir, &stbuf) == 0 && S_ISDIR (stbuf.st_mode))
+ {
+ if (idx == max - 1)
+ {
+ max += 5;
+ dirs = (char **)
+ xrealloc ((char *) dirs, (max + defsize) * sizeof (char *));
+ }
+ dirs[idx++] = dir;
+ }
+ }
+
+ /* Now add at the end the standard default dirs. */
+
+ for (i = 0; default_include_directories[i] != 0; ++i)
+ if (stat (default_include_directories[i], &stbuf) == 0
+ && S_ISDIR (stbuf.st_mode))
+ dirs[idx++] = default_include_directories[i];
+
+ dirs[idx] = 0;
+
+ /* Now compute the maximum length of any name in it. */
+
+ max_incl_len = 0;
+ for (i = 0; i < idx; ++i)
+ {
+ unsigned int len = strlen (dirs[i]);
+ /* If dir name is written with a trailing slash, discard it. */
+ if (dirs[i][len - 1] == '/')
+ /* We can't just clobber a null in because it may have come from
+ a literal string and literal strings may not be writable. */
+ dirs[i] = savestring (dirs[i], len - 1);
+ if (len > max_incl_len)
+ max_incl_len = len;
+ }
+
+ include_directories = dirs;
+}
+\f
+/* Given a chain of struct nameseq's describing a sequence of filenames,
+ in reverse of the intended order, return a new chain describing the
+ result of globbing the filenames. The new chain is in forward order.
+ The links of the old chain are freed or used in the new chain.
+ Likewise for the names in the old chain.
+
+ SIZE is how big to construct chain elements.
+ This is useful if we want them actually to be other structures
+ that have room for additional info. */
+
+struct nameseq *
+multi_glob (chain, size)
+ struct nameseq *chain;
+ unsigned int size;
+{
+ register struct nameseq *new = 0;
+ register struct nameseq *old;
+ struct nameseq *nexto;
+
+ for (old = chain; old != 0; old = nexto)
+ {
+ glob_t gl;
+
+ nexto = old->next;
+
+ if (old->name[0] == '~')
+ {
+ if (old->name[1] == '/' || old->name[1] == '\0')
+ {
+ extern char *getenv ();
+ char *home_dir = allocated_variable_expand ("$(HOME)");
+ int is_variable = home_dir[0] != '\0';
+ if (!is_variable)
+ {
+ free (home_dir);
+ home_dir = getenv ("HOME");
+ }
+ if (home_dir == 0 || home_dir[0] == '\0')
+ {
+ extern char *getlogin ();
+ char *name = getlogin ();
+ home_dir = 0;
+ if (name != 0)
+ {
+ struct passwd *p = getpwnam (name);
+ if (p != 0)
+ home_dir = p->pw_dir;
+ }
+ }
+ if (home_dir != 0)
+ {
+ char *new = concat (home_dir, "", old->name + 1);
+ if (is_variable)
+ free (home_dir);
+ free (old->name);
+ old->name = new;
+ }
+ }
+ else
+ {
+ struct passwd *pwent;
+ char *userend = index (old->name + 1, '/');
+ if (userend != 0)
+ *userend = '\0';
+ pwent = getpwnam (old->name + 1);
+ if (pwent != 0)
+ {
+ if (userend == 0)
+ {
+ free (old->name);
+ old->name = savestring (pwent->pw_dir,
+ strlen (pwent->pw_dir));
+ }
+ else
+ {
+ char *new = concat (pwent->pw_dir, "/", userend + 1);
+ free (old->name);
+ old->name = new;
+ }
+ }
+ else if (userend != 0)
+ *userend = '/';
+ }
+ }
+
+ switch (glob (old->name, GLOB_NOCHECK, NULL, &gl))
+ {
+ case 0: /* Success. */
+ {
+ register int i = gl.gl_pathc;
+ while (i-- > 0)
+ {
+ struct nameseq *elt = (struct nameseq *) xmalloc (size);
+ elt->name = savestring (gl.gl_pathv[i],
+ strlen (gl.gl_pathv[i]));
+ elt->next = new;
+ new = elt;
+ }
+ globfree (&gl);
+ break;
+ }
+
+ case GLOB_NOSPACE:
+ fatal ("virtual memory exhausted");
+ break;
+
+ default:
+ old->next = new;
+ new = old;
+ }
+ }
+
+ return new;
+}
projects / thirdparty / make.git / commitdiff
