mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2024-12-20 11:11:24 +00:00
Code Issues Releases Activity
4eb51779c8
freebsd/usr.bin/make/parse.c
Hartmut Brandt a139b7bac1 Move the remaining two prototypes from nonints.h to make.h and 
remove nonints.h.

Patch:	7.204
Submitted by:	Max Okumoto <okumoto@ucsd.edu>
2005-05-10 14:10:44 +00:00

2526 lines
61 KiB
C
Raw Blame History

/*-
* Copyright (c) 1988, 1989, 1990, 1993
* The Regents of the University of California. All rights reserved.
* Copyright (c) 1989 by Berkeley Softworks
* All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Adam de Boor.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* @(#)parse.c 8.3 (Berkeley) 3/19/94
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
/*-
* parse.c --
* Functions to parse a makefile.
*
* Most important structures are kept in Lsts. Directories for
* the #include "..." function are kept in the 'parseIncPath' Lst, while
* those for the #include <...> are kept in the 'sysIncPath' Lst. The
* targets currently being defined are kept in the 'targets' Lst.
*
* Interface:
*
* Parse_File Function used to parse a makefile. It must
* be given the name of the file, which should
* already have been opened, and a function
* to call to read a character from the file.
*
* Parse_IsVar Returns TRUE if the given line is a
* variable assignment. Used by MainParseArgs
* to determine if an argument is a target
* or a variable assignment. Used internally
* for pretty much the same thing...
*
* Parse_Error Function called when an error occurs in
* parsing. Used by the variable and
* conditional modules.
*
* Parse_MainName Returns a Lst of the main target to create.
*/
#include <assert.h>
#include <ctype.h>
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include <err.h>
#include "arch.h"
#include "buf.h"
#include "cond.h"
#include "config.h"
#include "dir.h"
#include "for.h"
#include "globals.h"
#include "GNode.h"
#include "hash_tables.h"
#include "job.h"
#include "make.h"
#include "parse.h"
#include "pathnames.h"
#include "str.h"
#include "suff.h"
#include "targ.h"
#include "util.h"
#include "var.h"
/*
* These values are returned by ParsePopInput to tell Parse_File whether to
* CONTINUE parsing, i.e. it had only reached the end of an include file,
* or if it's DONE.
*/
#define CONTINUE 1
#define DONE 0
/* targets we're working on */
static Lst targets = Lst_Initializer(targets);
/* true if currently in a dependency line or its commands */
static Boolean inLine;
static int fatals = 0;
/*
* The main target to create. This is the first target on the
* first dependency line in the first makefile.
*/
static GNode *mainNode;
/*
* Definitions for handling #include specifications
*/
struct IFile {
char *fname; /* name of previous file */
int lineno; /* saved line number */
FILE *F; /* the open stream */
char *str; /* the string when parsing a string */
char *ptr; /* the current pointer when parsing a string */
TAILQ_ENTRY(IFile) link;/* stack the files */
};
/* stack of IFiles generated by * #includes */
static TAILQ_HEAD(, IFile) includes = TAILQ_HEAD_INITIALIZER(includes);
/* access current file */
#define CURFILE (TAILQ_FIRST(&includes))
/* list of directories for "..." includes */
struct Path parseIncPath = TAILQ_HEAD_INITIALIZER(parseIncPath);
/* list of directories for <...> includes */
struct Path sysIncPath = TAILQ_HEAD_INITIALIZER(sysIncPath);
/*
* specType contains the SPECial TYPE of the current target. It is
* Not if the target is unspecial. If it *is* special, however, the children
* are linked as children of the parent but not vice versa. This variable is
* set in ParseDoDependency
*/
typedef enum {
Begin, /* .BEGIN */
Default, /* .DEFAULT */
End, /* .END */
ExportVar, /* .EXPORTVAR */
Ignore, /* .IGNORE */
Includes, /* .INCLUDES */
Interrupt, /* .INTERRUPT */
Libs, /* .LIBS */
MFlags, /* .MFLAGS or .MAKEFLAGS */
Main, /* .MAIN and we don't have anyth. user-spec. to make */
Not, /* Not special */
NotParallel, /* .NOTPARALELL */
Null, /* .NULL */
Order, /* .ORDER */
Parallel, /* .PARALLEL */
ExPath, /* .PATH */
Phony, /* .PHONY */
Posix, /* .POSIX */
Precious, /* .PRECIOUS */
ExShell, /* .SHELL */
Silent, /* .SILENT */
SingleShell, /* .SINGLESHELL */
Suffixes, /* .SUFFIXES */
Wait, /* .WAIT */
Warn, /* .WARN */
Attribute /* Generic attribute */
} ParseSpecial;
static ParseSpecial specType;
static int waiting;
/*
* Predecessor node for handling .ORDER. Initialized to NULL when .ORDER
* seen, then set to each successive source on the line.
*/
static GNode *predecessor;
/*
* The parseKeywords table is searched using binary search when deciding
* if a target or source is special. The 'spec' field is the ParseSpecial
* type of the keyword ("Not" if the keyword isn't special as a target) while
* the 'op' field is the operator to apply to the list of targets if the
* keyword is used as a source ("0" if the keyword isn't special as a source)
*/
static const struct keyword {
const char *name; /* Name of keyword */
ParseSpecial spec; /* Type when used as a target */
int op; /* Operator when used as a source */
} parseKeywords[] = {
/* KEYWORD-START-TAG */
{ ".BEGIN", Begin, 0 },
{ ".DEFAULT", Default, 0 },
{ ".END", End, 0 },
{ ".EXEC", Attribute, OP_EXEC },
{ ".EXPORTVAR", ExportVar, 0 },
{ ".IGNORE", Ignore, OP_IGNORE },
{ ".INCLUDES", Includes, 0 },
{ ".INTERRUPT", Interrupt, 0 },
{ ".INVISIBLE", Attribute, OP_INVISIBLE },
{ ".JOIN", Attribute, OP_JOIN },
{ ".LIBS", Libs, 0 },
{ ".MAIN", Main, 0 },
{ ".MAKE", Attribute, OP_MAKE },
{ ".MAKEFLAGS", MFlags, 0 },
{ ".MFLAGS", MFlags, 0 },
{ ".NOTMAIN", Attribute, OP_NOTMAIN },
{ ".NOTPARALLEL", NotParallel, 0 },
{ ".NO_PARALLEL", NotParallel, 0 },
{ ".NULL", Null, 0 },
{ ".OPTIONAL", Attribute, OP_OPTIONAL },
{ ".ORDER", Order, 0 },
{ ".PARALLEL", Parallel, 0 },
{ ".PATH", ExPath, 0 },
{ ".PHONY", Phony, OP_PHONY },
{ ".POSIX", Posix, 0 },
{ ".PRECIOUS", Precious, OP_PRECIOUS },
{ ".RECURSIVE", Attribute, OP_MAKE },
{ ".SHELL", ExShell, 0 },
{ ".SILENT", Silent, OP_SILENT },
{ ".SINGLESHELL", SingleShell, 0 },
{ ".SUFFIXES", Suffixes, 0 },
{ ".USE", Attribute, OP_USE },
{ ".WAIT", Wait, 0 },
{ ".WARN", Warn, 0 },
/* KEYWORD-END-TAG */
};
#define NKEYWORDS (sizeof(parseKeywords) / sizeof(parseKeywords[0]))
static void parse_include(char *, int, int);
static void parse_message(char *, int, int);
static void parse_undef(char *, int, int);
static void parse_for(char *, int, int);
static void parse_endfor(char *, int, int);
static const struct directive {
const char *name;
int code;
Boolean skip_flag; /* execute even when skipped */
void (*func)(char *, int, int);
} directives[] = {
/* DIRECTIVES-START-TAG */
{ "elif", COND_ELIF, TRUE, Cond_If },
{ "elifdef", COND_ELIFDEF, TRUE, Cond_If },
{ "elifmake", COND_ELIFMAKE, TRUE, Cond_If },
{ "elifndef", COND_ELIFNDEF, TRUE, Cond_If },
{ "elifnmake", COND_ELIFNMAKE, TRUE, Cond_If },
{ "else", COND_ELSE, TRUE, Cond_Else },
{ "endfor", 0, FALSE, parse_endfor },
{ "endif", COND_ENDIF, TRUE, Cond_Endif },
{ "error", 1, FALSE, parse_message },
{ "for", 0, FALSE, parse_for },
{ "if", COND_IF, TRUE, Cond_If },
{ "ifdef", COND_IFDEF, TRUE, Cond_If },
{ "ifmake", COND_IFMAKE, TRUE, Cond_If },
{ "ifndef", COND_IFNDEF, TRUE, Cond_If },
{ "ifnmake", COND_IFNMAKE, TRUE, Cond_If },
{ "include", 0, FALSE, parse_include },
{ "undef", 0, FALSE, parse_undef },
{ "warning", 0, FALSE, parse_message },
/* DIRECTIVES-END-TAG */
};
#define NDIRECTS (sizeof(directives) / sizeof(directives[0]))
/*-
* ParseFindKeyword
* Look in the table of keywords for one matching the given string.
*
* Results:
* The pointer to keyword table entry or NULL.
*/
static const struct keyword *
ParseFindKeyword(const char *str)
{
int kw;
kw = keyword_hash(str, strlen(str));
if (kw < 0 || kw >= (int)NKEYWORDS ||
strcmp(str, parseKeywords[kw].name) != 0)
return (NULL);
return (&parseKeywords[kw]);
}
/*-
* Parse_Error --
* Error message abort function for parsing. Prints out the context
* of the error (line number and file) as well as the message with
* two optional arguments.
*
* Results:
* None
*
* Side Effects:
* "fatals" is incremented if the level is PARSE_FATAL.
*/
/* VARARGS */
void
Parse_Error(int type, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
if (CURFILE != NULL)
fprintf(stderr, "\"%s\", line %d: ",
CURFILE->fname, CURFILE->lineno);
if (type == PARSE_WARNING)
fprintf(stderr, "warning: ");
vfprintf(stderr, fmt, ap);
va_end(ap);
fprintf(stderr, "\n");
fflush(stderr);
if (type == PARSE_FATAL)
fatals += 1;
}
/**
* ParsePushInput
*
* Push a new input source onto the input stack. If ptr is NULL
* the fullname is used to fopen the file. If it is not NULL,
* ptr is assumed to point to the string to be parsed. If opening the
* file fails, the fullname is freed.
*/
static void
ParsePushInput(char *fullname, FILE *fp, char *ptr, int lineno)
{
struct IFile *nf;
nf = emalloc(sizeof(*nf));
nf->fname = fullname;
nf->lineno = lineno;
if (ptr == NULL) {
/* the input source is a file */
if ((nf->F = fp) == NULL) {
nf->F = fopen(fullname, "r");
if (nf->F == NULL) {
Parse_Error(PARSE_FATAL, "Cannot open %s",
fullname);
free(fullname);
free(nf);
return;
}
}
nf->str = nf->ptr = NULL;
Var_Append(".MAKEFILE_LIST", fullname, VAR_GLOBAL);
} else {
nf->str = nf->ptr = ptr;
nf->F = NULL;
}
TAILQ_INSERT_HEAD(&includes, nf, link);
}
/**
* ParsePopInput
* Called when EOF is reached in the current file. If we were reading
* an include file, the includes stack is popped and things set up
* to go back to reading the previous file at the previous location.
*
* Results:
* CONTINUE if there's more to do. DONE if not.
*
* Side Effects:
* The old curFile.F is closed. The includes list is shortened.
* curFile.lineno, curFile.F, and curFile.fname are changed if
* CONTINUE is returned.
*/
static int
ParsePopInput(void)
{
struct IFile *ifile; /* the state on the top of the includes stack */
assert(!TAILQ_EMPTY(&includes));
ifile = TAILQ_FIRST(&includes);
TAILQ_REMOVE(&includes, ifile, link);
free(ifile->fname);
if (ifile->F != NULL) {
fclose(ifile->F);
Var_Append(".MAKEFILE_LIST", "..", VAR_GLOBAL);
}
if (ifile->str != NULL) {
free(ifile->str);
}
free(ifile);
return (TAILQ_EMPTY(&includes) ? DONE : CONTINUE);
}
/**
* parse_warn
* Parse the .WARN pseudo-target.
*/
static void
parse_warn(char *line)
{
char **argv;
int argc;
int i;
argv = brk_string(line, &argc, TRUE);
for (i = 1; i < argc; i++)
Main_ParseWarn(argv[i], 0);
}
/*-
*---------------------------------------------------------------------
* ParseLinkSrc --
* Link the parent nodes to their new child. Used by
* ParseDoDependency. If the specType isn't 'Not', the parent
* isn't linked as a parent of the child.
*
* Side Effects:
* New elements are added to the parents lists of cgn and the
* children list of cgn. the unmade field of pgn is updated
* to reflect the additional child.
*---------------------------------------------------------------------
*/
static void
ParseLinkSrc(Lst *parents, GNode *cgn)
{
LstNode *ln;
GNode *pgn;
LST_FOREACH(ln, parents) {
pgn = Lst_Datum(ln);
if (Lst_Member(&pgn->children, cgn) == NULL) {
Lst_AtEnd(&pgn->children, cgn);
if (specType == Not) {
Lst_AtEnd(&cgn->parents, pgn);
}
pgn->unmade += 1;
}
}
}
/*-
*---------------------------------------------------------------------
* ParseDoOp --
* Apply the parsed operator to all target nodes. Used in
* ParseDoDependency once all targets have been found and their
* operator parsed. If the previous and new operators are incompatible,
* a major error is taken.
*
* Side Effects:
* The type field of the node is altered to reflect any new bits in
* the op.
*---------------------------------------------------------------------
*/
static void
ParseDoOp(int op)
{
GNode *cohort;
LstNode *ln;
GNode *gn;
LST_FOREACH(ln, &targets) {
gn = Lst_Datum(ln);
/*
* If the dependency mask of the operator and the node don't
* match and the node has actually had an operator applied to
* it before, and the operator actually has some dependency
* information in it, complain.
*/
if ((op & OP_OPMASK) != (gn->type & OP_OPMASK) &&
!OP_NOP(gn->type) && !OP_NOP(op)) {
Parse_Error(PARSE_FATAL, "Inconsistent operator for %s",
gn->name);
return;
}
if (op == OP_DOUBLEDEP &&
(gn->type & OP_OPMASK) == OP_DOUBLEDEP) {
/*
* If the node was the object of a :: operator, we need
* to create a new instance of it for the children and
* commands on this dependency line. The new instance
* is placed on the 'cohorts' list of the initial one
* (note the initial one is not on its own cohorts list)
* and the new instance is linked to all parents of the
* initial instance.
*/
cohort = Targ_NewGN(gn->name);
/*
* Duplicate links to parents so graph traversal is
* simple. Perhaps some type bits should be duplicated?
*
* Make the cohort invisible as well to avoid
* duplicating it into other variables. True, parents
* of this target won't tend to do anything with their
* local variables, but better safe than sorry.
*/
ParseLinkSrc(&gn->parents, cohort);
cohort->type = OP_DOUBLEDEP|OP_INVISIBLE;
Lst_AtEnd(&gn->cohorts, cohort);
/*
* Replace the node in the targets list with the
* new copy
*/
Lst_Replace(ln, cohort);
gn = cohort;
}
/*
* We don't want to nuke any previous flags (whatever they were)
* so we just OR the new operator into the old
*/
gn->type |= op;
}
}
/*-
*---------------------------------------------------------------------
* ParseDoSrc --
* Given the name of a source, figure out if it is an attribute
* and apply it to the targets if it is. Else decide if there is
* some attribute which should be applied *to* the source because
* of some special target and apply it if so. Otherwise, make the
* source be a child of the targets in the list 'targets'
*
* Results:
* None
*
* Side Effects:
* Operator bits may be added to the list of targets or to the source.
* The targets may have a new source added to their lists of children.
*---------------------------------------------------------------------
*/
static void
ParseDoSrc(int tOp, char *src, Lst *allsrc)
{
GNode *gn = NULL;
const struct keyword *kw;
if (src[0] == '.' && isupper ((unsigned char)src[1])) {
if ((kw = ParseFindKeyword(src)) != NULL) {
if (kw->op != 0) {
ParseDoOp(kw->op);
return;
}
if (kw->spec == Wait) {
waiting++;
return;
}
}
}
switch (specType) {
case Main:
/*
* If we have noted the existence of a .MAIN, it means we need
* to add the sources of said target to the list of things
* to create. The string 'src' is likely to be free, so we
* must make a new copy of it. Note that this will only be
* invoked if the user didn't specify a target on the command
* line. This is to allow #ifmake's to succeed, or something...
*/
Lst_AtEnd(&create, estrdup(src));
/*
* Add the name to the .TARGETS variable as well, so the user
* can employ that, if desired.
*/
Var_Append(".TARGETS", src, VAR_GLOBAL);
return;
case Order:
/*
* Create proper predecessor/successor links between the
* previous source and the current one.
*/
gn = Targ_FindNode(src, TARG_CREATE);
if (predecessor != NULL) {
Lst_AtEnd(&predecessor->successors, gn);
Lst_AtEnd(&gn->preds, predecessor);
}
/*
* The current source now becomes the predecessor for the next
* one.
*/
predecessor = gn;
break;
default:
/*
* If the source is not an attribute, we need to find/create
* a node for it. After that we can apply any operator to it
* from a special target or link it to its parents, as
* appropriate.
*
* In the case of a source that was the object of a :: operator,
* the attribute is applied to all of its instances (as kept in
* the 'cohorts' list of the node) or all the cohorts are linked
* to all the targets.
*/
gn = Targ_FindNode(src, TARG_CREATE);
if (tOp) {
gn->type |= tOp;
} else {
ParseLinkSrc(&targets, gn);
}
if ((gn->type & OP_OPMASK) == OP_DOUBLEDEP) {
GNode *cohort;
LstNode *ln;
for (ln = Lst_First(&gn->cohorts); ln != NULL;
ln = Lst_Succ(ln)) {
cohort = Lst_Datum(ln);
if (tOp) {
cohort->type |= tOp;
} else {
ParseLinkSrc(&targets, cohort);
}
}
}
break;
}
gn->order = waiting;
Lst_AtEnd(allsrc, gn);
if (waiting) {
LstNode *ln;
GNode *p;
/*
* Check if GNodes needs to be synchronized.
* This has to be when two nodes are on different sides of a
* .WAIT directive.
*/
LST_FOREACH(ln, allsrc) {
p = Lst_Datum(ln);
if (p->order >= gn->order)
break;
/*
* XXX: This can cause loops, and loops can cause
* unmade targets, but checking is tedious, and the
* debugging output can show the problem
*/
Lst_AtEnd(&p->successors, gn);
Lst_AtEnd(&gn->preds, p);
}
}
}
/*-
*---------------------------------------------------------------------
* ParseDoDependency --
* Parse the dependency line in line.
*
* Results:
* None
*
* Side Effects:
* The nodes of the sources are linked as children to the nodes of the
* targets. Some nodes may be created.
*
* We parse a dependency line by first extracting words from the line and
* finding nodes in the list of all targets with that name. This is done
* until a character is encountered which is an operator character. Currently
* these are only ! and :. At this point the operator is parsed and the
* pointer into the line advanced until the first source is encountered.
* The parsed operator is applied to each node in the 'targets' list,
* which is where the nodes found for the targets are kept, by means of
* the ParseDoOp function.
* The sources are read in much the same way as the targets were except
* that now they are expanded using the wildcarding scheme of the C-Shell
* and all instances of the resulting words in the list of all targets
* are found. Each of the resulting nodes is then linked to each of the
* targets as one of its children.
* Certain targets are handled specially. These are the ones detailed
* by the specType variable.
* The storing of transformation rules is also taken care of here.
* A target is recognized as a transformation rule by calling
* Suff_IsTransform. If it is a transformation rule, its node is gotten
* from the suffix module via Suff_AddTransform rather than the standard
* Targ_FindNode in the target module.
*---------------------------------------------------------------------
*/
static void
ParseDoDependency(char *line)
{
char *cp; /* our current position */
GNode *gn; /* a general purpose temporary node */
int op; /* the operator on the line */
char savec; /* a place to save a character */
Lst paths; /* Search paths to alter when parsing .PATH targets */
int tOp; /* operator from special target */
LstNode *ln;
const struct keyword *kw;
tOp = 0;
specType = Not;
waiting = 0;
Lst_Init(&paths);
do {
for (cp = line;
*cp && !isspace((unsigned char)*cp) && *cp != '(';
cp++) {
if (*cp == '$') {
/*
* Must be a dynamic source (would have been
* expanded otherwise), so call the Var module
* to parse the puppy so we can safely advance
* beyond it...There should be no errors in this
* as they would have been discovered in the
* initial Var_Subst and we wouldn't be here.
*/
size_t length = 0;
Boolean freeIt;
char *result;
result = Var_Parse(cp, VAR_CMD, TRUE,
&length, &freeIt);
if (freeIt) {
free(result);
}
cp += length - 1;
} else if (*cp == '!' || *cp == ':') {
/*
* We don't want to end a word on ':' or '!' if
* there is a better match later on in the
* string (greedy matching).
* This allows the user to have targets like:
* fie::fi:fo: fum
* foo::bar:
* where "fie::fi:fo" and "foo::bar" are the
* targets. In real life this is used for perl5
* library man pages where "::" separates an
* object from its class. Ie:
* "File::Spec::Unix". This behaviour is also
* consistent with other versions of make.
*/
char *p = cp + 1;
if (*cp == ':' && *p == ':')
p++;
/* Found the best match already. */
if (*p == '\0' || isspace(*p))
break;
p += strcspn(p, "!:");
/* No better match later on... */
if (*p == '\0')
break;
}
continue;
}
if (*cp == '(') {
/*
* Archives must be handled specially to make sure the
* OP_ARCHV flag is set in their 'type' field, for one
* thing, and because things like "archive(file1.o
* file2.o file3.o)" are permissible. Arch_ParseArchive
* will set 'line' to be the first non-blank after the
* archive-spec. It creates/finds nodes for the members
* and places them on the given list, returning SUCCESS
* if all went well and FAILURE if there was an error in
* the specification. On error, line should remain
* untouched.
*/
if (Arch_ParseArchive(&line, &targets, VAR_CMD) !=
SUCCESS) {
Parse_Error(PARSE_FATAL,
"Error in archive specification: \"%s\"",
line);
return;
} else {
cp = line;
continue;
}
}
savec = *cp;
if (!*cp) {
/*
* Ending a dependency line without an operator is a * Bozo no-no. As a heuristic, this is also often
* triggered by undetected conflicts from cvs/rcs
* merges.
*/
if (strncmp(line, "<<<<<<", 6) == 0 ||
strncmp(line, "======", 6) == 0 ||
strncmp(line, ">>>>>>", 6) == 0) {
Parse_Error(PARSE_FATAL, "Makefile appears to "
"contain unresolved cvs/rcs/??? merge "
"conflicts");
} else
Parse_Error(PARSE_FATAL, "Need an operator");
return;
}
*cp = '\0';
/*
* Have a word in line. See if it's a special target and set
* specType to match it.
*/
if (*line == '.' && isupper((unsigned char)line[1])) {
/*
* See if the target is a special target that must have
* it or its sources handled specially.
*/
if ((kw = ParseFindKeyword(line)) != NULL) {
if (specType == ExPath && kw->spec != ExPath) {
Parse_Error(PARSE_FATAL,
"Mismatched special targets");
return;
}
specType = kw->spec;
tOp = kw->op;
/*
* Certain special targets have special
* semantics:
* .PATH Have to set the dirSearchPath
* variable too
* .MAIN Its sources are only used if
* nothing has been specified to
* create.
* .DEFAULT Need to create a node to hang
* commands on, but we don't want
* it in the graph, nor do we want
* it to be the Main Target, so we
* create it, set OP_NOTMAIN and
* add it to the list, setting
* DEFAULT to the new node for
* later use. We claim the node is
* A transformation rule to make
* life easier later, when we'll
* use Make_HandleUse to actually
* apply the .DEFAULT commands.
* .PHONY The list of targets
* .BEGIN
* .END
* .INTERRUPT Are not to be considered the
* main target.
* .NOTPARALLEL Make only one target at a time.
* .SINGLESHELL Create a shell for each
* command.
* .ORDER Must set initial predecessor
* to NULL
*/
switch (specType) {
case ExPath:
Lst_AtEnd(&paths, &dirSearchPath);
break;
case Main:
if (!Lst_IsEmpty(&create)) {
specType = Not;
}
break;
case Begin:
case End:
case Interrupt:
gn = Targ_FindNode(line, TARG_CREATE);
gn->type |= OP_NOTMAIN;
Lst_AtEnd(&targets, gn);
break;
case Default:
gn = Targ_NewGN(".DEFAULT");
gn->type |= (OP_NOTMAIN|OP_TRANSFORM);
Lst_AtEnd(&targets, gn);
DEFAULT = gn;
break;
case NotParallel:
maxJobs = 1;
break;
case SingleShell:
compatMake = 1;
break;
case Order:
predecessor = NULL;
break;
default:
break;
}
} else if (strncmp(line, ".PATH", 5) == 0) {
/*
* .PATH<suffix> has to be handled specially.
* Call on the suffix module to give us a path
* to modify.
*/
struct Path *path;
specType = ExPath;
path = Suff_GetPath(&line[5]);
if (path == NULL) {
Parse_Error(PARSE_FATAL, "Suffix '%s' "
"not defined (yet)", &line[5]);
return;
} else
Lst_AtEnd(&paths, path);
}
}
/*
* Have word in line. Get or create its node and stick it at
* the end of the targets list
*/
if (specType == Not && *line != '\0') {
/* target names to be found and added to targets list */
Lst curTargs = Lst_Initializer(curTargs);
if (Dir_HasWildcards(line)) {
/*
* Targets are to be sought only in the current
* directory, so create an empty path for the
* thing. Note we need to use Path_Clear in the
* destruction of the path as the Dir module
* could have added a directory to the path...
*/
struct Path emptyPath =
TAILQ_HEAD_INITIALIZER(emptyPath);
Path_Expand(line, &emptyPath, &curTargs);
Path_Clear(&emptyPath);
} else {
/*
* No wildcards, but we want to avoid code
* duplication, so create a list with the word
* on it.
*/
Lst_AtEnd(&curTargs, line);
}
while (!Lst_IsEmpty(&curTargs)) {
char *targName = Lst_DeQueue(&curTargs);
if (!Suff_IsTransform (targName)) {
gn = Targ_FindNode(targName,
TARG_CREATE);
} else {
gn = Suff_AddTransform(targName);
}
Lst_AtEnd(&targets, gn);
}
} else if (specType == ExPath && *line != '.' && *line != '\0'){
Parse_Error(PARSE_WARNING, "Extra target (%s) ignored",
line);
}
*cp = savec;
/*
* If it is a special type and not .PATH, it's the only
* target we allow on this line...
*/
if (specType != Not && specType != ExPath) {
Boolean warnFlag = FALSE;
while (*cp != '!' && *cp != ':' && *cp) {
if (*cp != ' ' && *cp != '\t') {
warnFlag = TRUE;
}
cp++;
}
if (warnFlag) {
Parse_Error(PARSE_WARNING,
"Extra target ignored");
}
} else {
while (*cp && isspace((unsigned char)*cp)) {
cp++;
}
}
line = cp;
} while (*line != '!' && *line != ':' && *line);
if (!Lst_IsEmpty(&targets)) {
switch (specType) {
default:
Parse_Error(PARSE_WARNING, "Special and mundane "
"targets don't mix. Mundane ones ignored");
break;
case Default:
case Begin:
case End:
case Interrupt:
/*
* These four create nodes on which to hang commands, so
* targets shouldn't be empty...
*/
case Not:
/*
* Nothing special here -- targets can be empty if it
* wants.
*/
break;
}
}
/*
* Have now parsed all the target names. Must parse the operator next.
* The result is left in op.
*/
if (*cp == '!') {
op = OP_FORCE;
} else if (*cp == ':') {
if (cp[1] == ':') {
op = OP_DOUBLEDEP;
cp++;
} else {
op = OP_DEPENDS;
}
} else {
Parse_Error(PARSE_FATAL, "Missing dependency operator");
return;
}
cp++; /* Advance beyond operator */
ParseDoOp(op);
/*
* Get to the first source
*/
while (*cp && isspace((unsigned char)*cp)) {
cp++;
}
line = cp;
/*
* Several special targets take different actions if present with no
* sources:
* a .SUFFIXES line with no sources clears out all old suffixes
* a .PRECIOUS line makes all targets precious
* a .IGNORE line ignores errors for all targets
* a .SILENT line creates silence when making all targets
* a .PATH removes all directories from the search path(s).
*/
if (!*line) {
switch (specType) {
case Suffixes:
Suff_ClearSuffixes();
break;
case Precious:
allPrecious = TRUE;
break;
case Ignore:
ignoreErrors = TRUE;
break;
case Silent:
beSilent = TRUE;
break;
case ExPath:
LST_FOREACH(ln, &paths)
Path_Clear(Lst_Datum(ln));
break;
case Posix:
Var_Set("%POSIX", "1003.2", VAR_GLOBAL);
break;
default:
break;
}
} else if (specType == MFlags) {
/*
* Call on functions in main.c to deal with these arguments and
* set the initial character to a null-character so the loop to
* get sources won't get anything
*/
Main_ParseArgLine(line, 0);
*line = '\0';
} else if (specType == Warn) {
parse_warn(line);
*line = '\0';
} else if (specType == ExShell) {
if (Job_ParseShell(line) != SUCCESS) {
Parse_Error(PARSE_FATAL,
"improper shell specification");
return;
}
*line = '\0';
} else if (specType == NotParallel || specType == SingleShell) {
*line = '\0';
}
/*
* NOW GO FOR THE SOURCES
*/
if (specType == Suffixes || specType == ExPath ||
specType == Includes || specType == Libs ||
specType == Null) {
while (*line) {
/*
* If the target was one that doesn't take files as its
* sources but takes something like suffixes, we take
* each space-separated word on the line as a something
* and deal with it accordingly.
*
* If the target was .SUFFIXES, we take each source as
* a suffix and add it to the list of suffixes
* maintained by the Suff module.
*
* If the target was a .PATH, we add the source as a
* directory to search on the search path.
*
* If it was .INCLUDES, the source is taken to be the
* suffix of files which will be #included and whose
* search path should be present in the .INCLUDES
* variable.
*
* If it was .LIBS, the source is taken to be the
* suffix of files which are considered libraries and
* whose search path should be present in the .LIBS
* variable.
*
* If it was .NULL, the source is the suffix to use
* when a file has no valid suffix.
*/
char savech;
while (*cp && !isspace((unsigned char)*cp)) {
cp++;
}
savech = *cp;
*cp = '\0';
switch (specType) {
case Suffixes:
Suff_AddSuffix(line);
break;
case ExPath:
LST_FOREACH(ln, &paths)
Path_AddDir(Lst_Datum(ln), line);
break;
case Includes:
Suff_AddInclude(line);
break;
case Libs:
Suff_AddLib(line);
break;
case Null:
Suff_SetNull(line);
break;
default:
break;
}
*cp = savech;
if (savech != '\0') {
cp++;
}
while (*cp && isspace((unsigned char)*cp)) {
cp++;
}
line = cp;
}
Lst_Destroy(&paths, NOFREE);
} else if (specType == ExportVar) {
Var_SetEnv(line, VAR_GLOBAL);
} else {
/* list of sources in order */
Lst curSrcs = Lst_Initializer(curSrc);
while (*line) {
/*
* The targets take real sources, so we must beware of
* archive specifications (i.e. things with left
* parentheses in them) and handle them accordingly.
*/
while (*cp && !isspace((unsigned char)*cp)) {
if (*cp == '(' && cp > line && cp[-1] != '$') {
/*
* Only stop for a left parenthesis if
* it isn't at the start of a word
* (that'll be for variable changes
* later) and isn't preceded by a dollar
* sign (a dynamic source).
*/
break;
} else {
cp++;
}
}
if (*cp == '(') {
GNode *gnp;
/* list of archive source names after exp. */
Lst sources = Lst_Initializer(sources);
if (Arch_ParseArchive(&line, &sources,
VAR_CMD) != SUCCESS) {
Parse_Error(PARSE_FATAL, "Error in "
"source archive spec \"%s\"", line);
return;
}
while (!Lst_IsEmpty(&sources)) {
gnp = Lst_DeQueue(&sources);
ParseDoSrc(tOp, gnp->name, &curSrcs);
}
cp = line;
} else {
if (*cp) {
*cp = '\0';
cp += 1;
}
ParseDoSrc(tOp, line, &curSrcs);
}
while (*cp && isspace((unsigned char)*cp)) {
cp++;
}
line = cp;
}
Lst_Destroy(&curSrcs, NOFREE);
}
if (mainNode == NULL) {
/*
* If we have yet to decide on a main target to make, in the
* absence of any user input, we want the first target on
* the first dependency line that is actually a real target
* (i.e. isn't a .USE or .EXEC rule) to be made.
*/
LST_FOREACH(ln, &targets) {
gn = Lst_Datum(ln);
if ((gn->type & (OP_NOTMAIN | OP_USE |
OP_EXEC | OP_TRANSFORM)) == 0) {
mainNode = gn;
Targ_SetMain(gn);
break;
}
}
}
}
/*-
*---------------------------------------------------------------------
* Parse_IsVar --
* Return TRUE if the passed line is a variable assignment. A variable
* assignment consists of a single word followed by optional whitespace
* followed by either a += or an = operator.
* This function is used both by the Parse_File function and main when
* parsing the command-line arguments.
*
* Results:
* TRUE if it is. FALSE if it ain't
*
* Side Effects:
* none
*---------------------------------------------------------------------
*/
Boolean
Parse_IsVar(char *line)
{
Boolean wasSpace = FALSE; /* set TRUE if found a space */
Boolean haveName = FALSE; /* Set TRUE if have a variable name */
int level = 0;
#define ISEQOPERATOR(c) \
((c) == '+' || (c) == ':' || (c) == '?' || (c) == '!')
/*
* Skip to variable name
*/
for (; *line == ' ' || *line == '\t'; line++)
continue;
for (; *line != '=' || level != 0; line++) {
switch (*line) {
case '\0':
/*
* end-of-line -- can't be a variable assignment.
*/
return (FALSE);
case ' ':
case '\t':
/*
* there can be as much white space as desired so long
* as there is only one word before the operator
*/
wasSpace = TRUE;
break;
case '(':
case '{':
level++;
break;
case '}':
case ')':
level--;
break;
default:
if (wasSpace && haveName) {
if (ISEQOPERATOR(*line)) {
/*
* We must have a finished word
*/
if (level != 0)
return (FALSE);
/*
* When an = operator [+?!:] is found,
* the next character must be an = or
* it ain't a valid assignment.
*/
if (line[1] == '=')
return (haveName);
#ifdef SUNSHCMD
/*
* This is a shell command
*/
if (strncmp(line, ":sh", 3) == 0)
return (haveName);
#endif
}
/*
* This is the start of another word, so not
* assignment.
*/
return (FALSE);
} else {
haveName = TRUE;
wasSpace = FALSE;
}
break;
}
}
return (haveName);
}
/*-
*---------------------------------------------------------------------
* Parse_DoVar --
* Take the variable assignment in the passed line and do it in the
* global context.
*
* Note: There is a lexical ambiguity with assignment modifier characters
* in variable names. This routine interprets the character before the =
* as a modifier. Therefore, an assignment like
* C++=/usr/bin/CC
* is interpreted as "C+ +=" instead of "C++ =".
*
* Results:
* none
*
* Side Effects:
* the variable structure of the given variable name is altered in the
* global context.
*---------------------------------------------------------------------
*/
void
Parse_DoVar(char *line, GNode *ctxt)
{
char *cp; /* pointer into line */
enum {
VAR_SUBST,
VAR_APPEND,
VAR_SHELL,
VAR_NORMAL
} type; /* Type of assignment */
char *opc; /* ptr to operator character to
* null-terminate the variable name */
/*
* Avoid clobbered variable warnings by forcing the compiler
* to ``unregister'' variables
*/
#if __GNUC__
(void)&cp;
(void)&line;
#endif
/*
* Skip to variable name
*/
while (*line == ' ' || *line == '\t') {
line++;
}
/*
* Skip to operator character, nulling out whitespace as we go
*/
for (cp = line + 1; *cp != '='; cp++) {
if (isspace((unsigned char)*cp)) {
*cp = '\0';
}
}
opc = cp - 1; /* operator is the previous character */
*cp++ = '\0'; /* nuke the = */
/*
* Check operator type
*/
switch (*opc) {
case '+':
type = VAR_APPEND;
*opc = '\0';
break;
case '?':
/*
* If the variable already has a value, we don't do anything.
*/
*opc = '\0';
if (Var_Exists(line, ctxt)) {
return;
} else {
type = VAR_NORMAL;
}
break;
case ':':
type = VAR_SUBST;
*opc = '\0';
break;
case '!':
type = VAR_SHELL;
*opc = '\0';
break;
default:
#ifdef SUNSHCMD
while (*opc != ':') {
if (opc == line)
break;
else
--opc;
}
if (strncmp(opc, ":sh", 3) == 0) {
type = VAR_SHELL;
*opc = '\0';
break;
}
#endif
type = VAR_NORMAL;
break;
}
while (isspace((unsigned char)*cp)) {
cp++;
}
if (type == VAR_APPEND) {
Var_Append(line, cp, ctxt);
} else if (type == VAR_SUBST) {
/*
* Allow variables in the old value to be undefined, but leave
* their invocation alone -- this is done by forcing oldVars
* to be false.
* XXX: This can cause recursive variables, but that's not
* hard to do, and this allows someone to do something like
*
* CFLAGS = $(.INCLUDES)
* CFLAGS := -I.. $(CFLAGS)
*
* And not get an error.
*/
Boolean oldOldVars = oldVars;
oldVars = FALSE;
/*
* make sure that we set the variable the first time to nothing
* so that it gets substituted!
*/
if (!Var_Exists(line, ctxt))
Var_Set(line, "", ctxt);
cp = Buf_Peel(Var_Subst(cp, ctxt, FALSE));
oldVars = oldOldVars;
Var_Set(line, cp, ctxt);
free(cp);
} else if (type == VAR_SHELL) {
/*
* TRUE if the command needs to be freed, i.e.
* if any variable expansion was performed
*/
Boolean freeCmd = FALSE;
Buffer *buf;
const char *error;
if (strchr(cp, '$') != NULL) {
/*
* There's a dollar sign in the command, so perform
* variable expansion on the whole thing. The
* resulting string will need freeing when we're done,
* so set freeCmd to TRUE.
*/
cp = Buf_Peel(Var_Subst(cp, VAR_CMD, TRUE));
freeCmd = TRUE;
}
buf = Cmd_Exec(cp, &error);
Var_Set(line, Buf_Data(buf), ctxt);
Buf_Destroy(buf, TRUE);
if (error)
Parse_Error(PARSE_WARNING, error, cp);
if (freeCmd)
free(cp);
} else {
/*
* Normal assignment -- just do it.
*/
Var_Set(line, cp, ctxt);
}
}
/*-
*-----------------------------------------------------------------------
* ParseHasCommands --
* Callback procedure for Parse_File when destroying the list of
* targets on the last dependency line. Marks a target as already
* having commands if it does, to keep from having shell commands
* on multiple dependency lines.
*
* Results:
* None
*
* Side Effects:
* OP_HAS_COMMANDS may be set for the target.
*
*-----------------------------------------------------------------------
*/
static void
ParseHasCommands(void *gnp)
{
GNode *gn = gnp;
if (!Lst_IsEmpty(&gn->commands)) {
gn->type |= OP_HAS_COMMANDS;
}
}
/*-
*-----------------------------------------------------------------------
* Parse_AddIncludeDir --
* Add a directory to the path searched for included makefiles
* bracketed by double-quotes. Used by functions in main.c
*
* Results:
* None.
*
* Side Effects:
* The directory is appended to the list.
*
*-----------------------------------------------------------------------
*/
void
Parse_AddIncludeDir(char *dir)
{
Path_AddDir(&parseIncPath, dir);
}
/*-
*---------------------------------------------------------------------
* Parse_FromString --
* Start Parsing from the given string
*
* Results:
* None
*
* Side Effects:
* A structure is added to the includes Lst and readProc, curFile.lineno,
* curFile.fname and curFile.F are altered for the new file
*---------------------------------------------------------------------
*/
void
Parse_FromString(char *str, int lineno)
{
DEBUGF(FOR, ("%s\n---- at line %d\n", str, lineno));
ParsePushInput(estrdup(CURFILE->fname), NULL, str, lineno);
}
#ifdef SYSVINCLUDE
/*-
*---------------------------------------------------------------------
* ParseTraditionalInclude --
* Push to another file.
*
* The input is the line minus the "include". The file name is
* the string following the "include".
*
* Results:
* None
*
* Side Effects:
* A structure is added to the includes Lst and readProc, curFile.lineno,
* curFile.fname and curFile.F are altered for the new file
*---------------------------------------------------------------------
*/
static void
ParseTraditionalInclude(char *file)
{
char *fullname; /* full pathname of file */
char *cp; /* current position in file spec */
/*
* Skip over whitespace
*/
while (*file == ' ' || *file == '\t') {
file++;
}
if (*file == '\0') {
Parse_Error(PARSE_FATAL, "Filename missing from \"include\"");
return;
}
/*
* Skip to end of line or next whitespace
*/
for (cp = file; *cp && *cp != '\n' && *cp != '\t' && *cp != ' '; cp++) {
continue;
}
*cp = '\0';
/*
* Substitute for any variables in the file name before trying to
* find the thing.
*/
file = Buf_Peel(Var_Subst(file, VAR_CMD, FALSE));
/*
* Now we know the file's name, we attempt to find the durn thing.
* Search for it first on the -I search path, then on the .PATH
* search path, if not found in a -I directory.
*/
fullname = Path_FindFile(file, &parseIncPath);
if (fullname == NULL) {
fullname = Path_FindFile(file, &dirSearchPath);
}
if (fullname == NULL) {
/*
* Still haven't found the makefile. Look for it on the system
* path as a last resort.
*/
fullname = Path_FindFile(file, &sysIncPath);
}
if (fullname == NULL) {
Parse_Error(PARSE_FATAL, "Could not find %s", file);
/* XXXHB free(file) */
return;
}
/* XXXHB free(file) */
/*
* We set up the name of the file to be the absolute
* name of the include file so error messages refer to the right
* place.
*/
ParsePushInput(fullname, NULL, NULL, 0);
}
#endif
/*-
*---------------------------------------------------------------------
* ParseReadc --
* Read a character from the current file
*
* Results:
* The character that was read
*
* Side Effects:
*---------------------------------------------------------------------
*/
static int
ParseReadc(void)
{
if (CURFILE->F != NULL)
return (fgetc(CURFILE->F));
if (CURFILE->str != NULL && *CURFILE->ptr != '\0')
return (*CURFILE->ptr++);
return (EOF);
}
/*-
*---------------------------------------------------------------------
* ParseUnreadc --
* Put back a character to the current file
*
* Results:
* None.
*
* Side Effects:
*---------------------------------------------------------------------
*/
static void
ParseUnreadc(int c)
{
if (CURFILE->F != NULL) {
ungetc(c, CURFILE->F);
return;
}
if (CURFILE->str != NULL) {
*--(CURFILE->ptr) = c;
return;
}
}
/* ParseSkipLine():
* Grab the next line unless it begins with a dot (`.') and we're told to
* ignore such lines.
*/
static char *
ParseSkipLine(int skip, int keep_newline)
{
char *line;
int c, lastc;
Buffer *buf;
buf = Buf_Init(MAKE_BSIZE);
do {
Buf_Clear(buf);
lastc = '\0';
while (((c = ParseReadc()) != '\n' || lastc == '\\')
&& c != EOF) {
if (skip && c == '#' && lastc != '\\') {
/*
* let a comment be terminated even by an
* escaped \n. This is consistent to comment
* handling in ParseReadLine
*/
while ((c = ParseReadc()) != '\n' && c != EOF)
;
break;
}
if (c == '\n') {
if (keep_newline)
Buf_AddByte(buf, (Byte)c);
else
Buf_ReplaceLastByte(buf, (Byte)' ');
CURFILE->lineno++;
while ((c = ParseReadc()) == ' ' || c == '\t')
continue;
if (c == EOF)
break;
}
Buf_AddByte(buf, (Byte)c);
lastc = c;
}
if (c == EOF) {
Parse_Error(PARSE_FATAL,
"Unclosed conditional/for loop");
Buf_Destroy(buf, TRUE);
return (NULL);
}
CURFILE->lineno++;
Buf_AddByte(buf, (Byte)'\0');
line = Buf_Data(buf);
} while (skip == 1 && line[0] != '.');
Buf_Destroy(buf, FALSE);
return (line);
}
/*-
*---------------------------------------------------------------------
* ParseReadLine --
* Read an entire line from the input file. Called only by Parse_File.
* To facilitate escaped newlines and what have you, a character is
* buffered in 'lastc', which is '\0' when no characters have been
* read. When we break out of the loop, c holds the terminating
* character and lastc holds a character that should be added to
* the line (unless we don't read anything but a terminator).
*
* Results:
* A line w/o its newline
*
* Side Effects:
* Only those associated with reading a character
*---------------------------------------------------------------------
*/
static char *
ParseReadLine(void)
{
Buffer *buf; /* Buffer for current line */
int c; /* the current character */
int lastc; /* The most-recent character */
Boolean semiNL; /* treat semi-colons as newlines */
Boolean ignDepOp; /* TRUE if should ignore dependency operators
* for the purposes of setting semiNL */
Boolean ignComment; /* TRUE if should ignore comments (in a
* shell command */
char *line; /* Result */
char *ep; /* to strip trailing blanks */
again:
semiNL = FALSE;
ignDepOp = FALSE;
ignComment = FALSE;
lastc = '\0';
/*
* Handle tab at the beginning of the line. A leading tab (shell
* command) forces us to ignore comments and dependency operators and
* treat semi-colons as semi-colons (by leaving semiNL FALSE).
* This also discards completely blank lines.
*/
for (;;) {
c = ParseReadc();
if (c == EOF) {
if (ParsePopInput() == DONE) {
/* End of all inputs - return NULL */
return (NULL);
}
continue;
}
if (c == '\t') {
ignComment = ignDepOp = TRUE;
lastc = c;
break;
}
if (c != '\n') {
ParseUnreadc(c);
break;
}
CURFILE->lineno++;
}
buf = Buf_Init(MAKE_BSIZE);
while (((c = ParseReadc()) != '\n' || lastc == '\\') && c != EOF) {
test_char:
switch (c) {
case '\n':
/*
* Escaped newline: read characters until a
* non-space or an unescaped newline and
* replace them all by a single space. This is
* done by storing the space over the backslash
* and dropping through with the next nonspace.
* If it is a semi-colon and semiNL is TRUE,
* it will be recognized as a newline in the
* code below this...
*/
CURFILE->lineno++;
lastc = ' ';
while ((c = ParseReadc()) == ' ' || c == '\t') {
continue;
}
if (c == EOF || c == '\n') {
goto line_read;
} else {
/*
* Check for comments, semiNL's, etc. --
* easier than ParseUnreadc(c);
* continue;
*/
goto test_char;
}
/*NOTREACHED*/
break;
case ';':
/*
* Semi-colon: Need to see if it should be
* interpreted as a newline
*/
if (semiNL) {
/*
* To make sure the command that may
* be following this semi-colon begins
* with a tab, we push one back into the
* input stream. This will overwrite the
* semi-colon in the buffer. If there is
* no command following, this does no
* harm, since the newline remains in
* the buffer and the
* whole line is ignored.
*/
ParseUnreadc('\t');
goto line_read;
}
break;
case '=':
if (!semiNL) {
/*
* Haven't seen a dependency operator
* before this, so this must be a
* variable assignment -- don't pay
* attention to dependency operators
* after this.
*/
ignDepOp = TRUE;
} else if (lastc == ':' || lastc == '!') {
/*
* Well, we've seen a dependency
* operator already, but it was the
* previous character, so this is really
* just an expanded variable assignment.
* Revert semi-colons to being just
* semi-colons again and ignore any more
* dependency operators.
*
* XXX: Note that a line like
* "foo : a:=b" will blow up, but who'd
* write a line like that anyway?
*/
ignDepOp = TRUE;
semiNL = FALSE;
}
break;
case '#':
if (!ignComment) {
if (lastc != '\\') {
/*
* If the character is a hash
* mark and it isn't escaped
* (or we're being compatible),
* the thing is a comment.
* Skip to the end of the line.
*/
do {
c = ParseReadc();
} while (c != '\n' && c != EOF);
goto line_read;
} else {
/*
* Don't add the backslash.
* Just let the # get copied
* over.
*/
lastc = c;
continue;
}
}
break;
case ':':
case '!':
if (!ignDepOp) {
/*
* A semi-colon is recognized as a
* newline only on dependency lines.
* Dependency lines are lines with a
* colon or an exclamation point.
* Ergo...
*/
semiNL = TRUE;
}
break;
default:
break;
}
/*
* Copy in the previous character (there may be none if this
* was the first character) and save this one in
* lastc.
*/
if (lastc != '\0')
Buf_AddByte(buf, (Byte)lastc);
lastc = c;
}
line_read:
CURFILE->lineno++;
if (lastc != '\0') {
Buf_AddByte(buf, (Byte)lastc);
}
Buf_AddByte(buf, (Byte)'\0');
line = Buf_Peel(buf);
/*
* Strip trailing blanks and tabs from the line.
* Do not strip a blank or tab that is preceded by
* a '\'
*/
ep = line;
while (*ep)
++ep;
while (ep > line + 1 && (ep[-1] == ' ' || ep[-1] == '\t')) {
if (ep > line + 1 && ep[-2] == '\\')
break;
--ep;
}
*ep = 0;
if (line[0] == '\0') {
/* empty line - just ignore */
free(line);
goto again;
}
return (line);
}
/*-
*-----------------------------------------------------------------------
* ParseFinishLine --
* Handle the end of a dependency group.
*
* Results:
* Nothing.
*
* Side Effects:
* inLine set FALSE. 'targets' list destroyed.
*
*-----------------------------------------------------------------------
*/
static void
ParseFinishLine(void)
{
const LstNode *ln;
if (inLine) {
LST_FOREACH(ln, &targets) {
if (((const GNode *)Lst_Datum(ln))->type & OP_TRANSFORM)
Suff_EndTransform(Lst_Datum(ln));
}
Lst_Destroy(&targets, ParseHasCommands);
inLine = FALSE;
}
}
/**
* parse_include
* Parse an .include directive and push the file onto the input stack.
* The input is the line minus the .include. A file spec is a string
* enclosed in <> or "". The former is looked for only in sysIncPath.
* The latter in . and the directories specified by -I command line
* options
*/
static void
parse_include(char *file, int code __unused, int lineno __unused)
{
char *fullname; /* full pathname of file */
char endc; /* the character which ends the file spec */
char *cp; /* current position in file spec */
Boolean isSystem; /* TRUE if makefile is a system makefile */
char *prefEnd, *Fname;
char *newName;
/*
* Skip to delimiter character so we know where to look
*/
while (*file == ' ' || *file == '\t') {
file++;
}
if (*file != '"' && *file != '<') {
Parse_Error(PARSE_FATAL,
".include filename must be delimited by '\"' or '<'");
return;
}
/*
* Set the search path on which to find the include file based on the
* characters which bracket its name. Angle-brackets imply it's
* a system Makefile while double-quotes imply it's a user makefile
*/
if (*file == '<') {
isSystem = TRUE;
endc = '>';
} else {
isSystem = FALSE;
endc = '"';
}
/*
* Skip to matching delimiter
*/
for (cp = ++file; *cp != endc; cp++) {
if (*cp == '\0') {
Parse_Error(PARSE_FATAL,
"Unclosed .include filename. '%c' expected", endc);
return;
}
}
*cp = '\0';
/*
* Substitute for any variables in the file name before trying to
* find the thing.
*/
file = Buf_Peel(Var_Subst(file, VAR_CMD, FALSE));
/*
* Now we know the file's name and its search path, we attempt to
* find the durn thing. A return of NULL indicates the file don't
* exist.
*/
if (!isSystem) {
/*
* Include files contained in double-quotes are first searched
* for relative to the including file's location. We don't want
* to cd there, of course, so we just tack on the old file's
* leading path components and call Dir_FindFile to see if
* we can locate the beast.
*/
/* Make a temporary copy of this, to be safe. */
Fname = estrdup(CURFILE->fname);
prefEnd = strrchr(Fname, '/');
if (prefEnd != NULL) {
*prefEnd = '\0';
if (file[0] == '/')
newName = estrdup(file);
else
newName = str_concat(Fname, file, STR_ADDSLASH);
fullname = Path_FindFile(newName, &parseIncPath);
if (fullname == NULL) {
fullname = Path_FindFile(newName,
&dirSearchPath);
}
free(newName);
*prefEnd = '/';
} else {
fullname = NULL;
}
free(Fname);
} else {
fullname = NULL;
}
if (fullname == NULL) {
/*
* System makefile or makefile wasn't found in same directory as
* included makefile. Search for it first on the -I search path,
* then on the .PATH search path, if not found in a -I
* directory.
* XXX: Suffix specific?
*/
fullname = Path_FindFile(file, &parseIncPath);
if (fullname == NULL) {
fullname = Path_FindFile(file, &dirSearchPath);
}
}
if (fullname == NULL) {
/*
* Still haven't found the makefile. Look for it on the system
* path as a last resort.
*/
fullname = Path_FindFile(file, &sysIncPath);
}
if (fullname == NULL) {
*cp = endc;
Parse_Error(PARSE_FATAL, "Could not find %s", file);
free(file);
return;
}
free(file);
/*
* We set up the name of the file to be the absolute
* name of the include file so error messages refer to the right
* place.
*/
ParsePushInput(fullname, NULL, NULL, 0);
}
/**
* parse_message
* Parse a .warning or .error directive
*
* The input is the line minus the ".error"/".warning". We substitute
* variables, print the message and exit(1) (for .error) or just print
* a warning if the directive is malformed.
*/
static void
parse_message(char *line, int iserror, int lineno __unused)
{
if (!isspace((u_char)*line)) {
Parse_Error(PARSE_WARNING, "invalid syntax: .%s%s",
iserror ? "error" : "warning", line);
return;
}
while (isspace((u_char)*line))
line++;
line = Buf_Peel(Var_Subst(line, VAR_GLOBAL, FALSE));
Parse_Error(iserror ? PARSE_FATAL : PARSE_WARNING, "%s", line);
free(line);
if (iserror) {
/* Terminate immediately. */
exit(1);
}
}
/**
* parse_undef
* Parse an .undef directive.
*/
static void
parse_undef(char *line, int code __unused, int lineno __unused)
{
char *cp;
while (isspace((u_char)*line))
line++;
for (cp = line; !isspace((u_char)*cp) && *cp != '\0'; cp++) {
;
}
*cp = '\0';
cp = Buf_Peel(Var_Subst(line, VAR_CMD, FALSE));
Var_Delete(cp, VAR_GLOBAL);
free(cp);
}
/**
* parse_for
* Parse a .for directive.
*/
static void
parse_for(char *line, int code __unused, int lineno)
{
if (!For_For(line)) {
/* syntax error */
return;
}
line = NULL;
/*
* Skip after the matching endfor.
*/
do {
free(line);
line = ParseSkipLine(0, 1);
if (line == NULL) {
Parse_Error(PARSE_FATAL,
"Unexpected end of file in for loop.\n");
return;
}
} while (For_Eval(line));
free(line);
/* execute */
For_Run(lineno);
}
/**
* parse_endfor
* Parse endfor. This may only happen if there was no matching .for.
*/
static void
parse_endfor(char *line __unused, int code __unused, int lineno __unused)
{
Parse_Error(PARSE_FATAL, "for-less endfor");
}
/**
* parse_directive
* Got a line starting with a '.'. Check if this is a directive
* and parse it.
*
* return:
* TRUE if line was a directive, FALSE otherwise.
*/
static Boolean
parse_directive(char *line)
{
char *start;
char *cp;
int dir;
/*
* Get the keyword:
* .[[:space:]]*\([[:alpha:]][[:alnum:]_]*\).*
* \1 is the keyword.
*/
for (start = line; isspace((u_char)*start); start++) {
;
}
if (!isalpha((u_char)*start)) {
return (FALSE);
}
cp = start + 1;
while (isalnum((u_char)*cp) || *cp == '_') {
cp++;
}
dir = directive_hash(start, cp - start);
if (dir < 0 || dir >= (int)NDIRECTS ||
(size_t)(cp - start) != strlen(directives[dir].name) ||
strncmp(start, directives[dir].name, cp - start) != 0) {
/* not actually matched */
return (FALSE);
}
if (!skipLine || directives[dir].skip_flag)
(*directives[dir].func)(cp, directives[dir].code,
CURFILE->lineno);
return (TRUE);
}
/*-
*---------------------------------------------------------------------
* Parse_File --
* Parse a file into its component parts, incorporating it into the
* current dependency graph. This is the main function and controls
* almost every other function in this module
*
* Results:
* None
*
* Side Effects:
* Loads. Nodes are added to the list of all targets, nodes and links
* are added to the dependency graph. etc. etc. etc.
*---------------------------------------------------------------------
*/
void
Parse_File(const char *name, FILE *stream)
{
char *cp; /* pointer into the line */
char *line; /* the line we're working on */
inLine = FALSE;
fatals = 0;
ParsePushInput(estrdup(name), stream, NULL, 0);
while ((line = ParseReadLine()) != NULL) {
if (*line == '.' && parse_directive(line + 1)) {
/* directive consumed */
goto nextLine;
}
if (skipLine || *line == '#') {
/* Skipping .if block or comment. */
goto nextLine;
}
if (*line == '\t') {
/*
* If a line starts with a tab, it can only
* hope to be a creation command.
*/
for (cp = line + 1; isspace((unsigned char)*cp); cp++) {
continue;
}
if (*cp) {
if (inLine) {
LstNode *ln;
GNode *gn;
/*
* So long as it's not a blank
* line and we're actually in a
* dependency spec, add the
* command to the list of
* commands of all targets in
* the dependency spec.
*/
LST_FOREACH(ln, &targets) {
gn = Lst_Datum(ln);
/*
* if target already
* supplied, ignore
* commands
*/
if (!(gn->type & OP_HAS_COMMANDS))
Lst_AtEnd(&gn->commands, cp);
else
Parse_Error(PARSE_WARNING, "duplicate script "
"for target \"%s\" ignored", gn->name);
}
continue;
} else {
Parse_Error(PARSE_FATAL,
"Unassociated shell command \"%s\"",
cp);
}
}
#ifdef SYSVINCLUDE
} else if (strncmp(line, "include", 7) == 0 &&
isspace((unsigned char)line[7]) &&
strchr(line, ':') == NULL) {
/*
* It's an S3/S5-style "include".
*/
ParseTraditionalInclude(line + 7);
goto nextLine;
#endif
} else if (Parse_IsVar(line)) {
ParseFinishLine();
Parse_DoVar(line, VAR_GLOBAL);
} else {
/*
* We now know it's a dependency line so it
* needs to have all variables expanded before
* being parsed. Tell the variable module to
* complain if some variable is undefined...
* To make life easier on novices, if the line
* is indented we first make sure the line has
* a dependency operator in it. If it doesn't
* have an operator and we're in a dependency
* line's script, we assume it's actually a
* shell command and add it to the current
* list of targets. XXX this comment seems wrong.
*/
cp = line;
if (isspace((unsigned char)line[0])) {
while (*cp != '\0' &&
isspace((unsigned char)*cp)) {
cp++;
}
if (*cp == '\0') {
goto nextLine;
}
}
ParseFinishLine();
cp = Buf_Peel(Var_Subst(line, VAR_CMD, TRUE));
free(line);
line = cp;
/*
* Need a non-circular list for the target nodes
*/
Lst_Destroy(&targets, NOFREE);
inLine = TRUE;
ParseDoDependency(line);
}
nextLine:
free(line);
}
ParseFinishLine();
/*
* Make sure conditionals are clean
*/
Cond_End();
if (fatals)
errx(1, "fatal errors encountered -- cannot continue");
}
/*-
*-----------------------------------------------------------------------
* Parse_MainName --
* Return a Lst of the main target to create for main()'s sake. If
* no such target exists, we Punt with an obnoxious error message.
*
* Results:
* A Lst of the single node to create.
*
* Side Effects:
* None.
*
*-----------------------------------------------------------------------
*/
void
Parse_MainName(Lst *listmain)
{
if (mainNode == NULL) {
Punt("no target to make.");
/*NOTREACHED*/
} else if (mainNode->type & OP_DOUBLEDEP) {
Lst_AtEnd(listmain, mainNode);
Lst_Concat(listmain, &mainNode->cohorts, LST_CONCNEW);
} else
Lst_AtEnd(listmain, mainNode);
}
Reference in New Issue View Git Blame Copy Permalink