src/usr.bin/make/parse.c - diff

Return to parse.c CVS log

Up to [local] / src / usr.bin / make

Diff for /src/usr.bin/make/parse.c between version 1.10 and 1.11

version 1.10, 1996/09/21 05:03:37

version 1.11, 1996/11/30 21:09:02

Line 1

/* $OpenBSD$ */

/* $NetBSD: parse.c,v 1.25 1996/09/13 04:22:09 christos Exp $ */

/* $NetBSD: parse.c,v 1.27 1996/11/06 17:59:20 christos Exp $ */

Line 41

#ifndef lint

#if 0

static char sccsid[] = "@(#)parse.c 5.18 (Berkeley) 2/19/91";

static char sccsid[] = "@(#)parse.c 8.3 (Berkeley) 3/19/94";

#else

static char rcsid[] = "$NetBSD: parse.c,v 1.25 1996/09/13 04:22:09 christos Exp $";

static char rcsid[] = "$OpenBSD$";

#endif

#endif /* not lint */

Line 276

end,

cur;

start = 0;

end = (sizeof(parseKeywords)/sizeof(parseKeywords[0])) - 1;

Line 399

* 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))

Line 419

LstNode ln;

cohort = Targ_NewGN(gn->name);

* Duplicate links to parents so graph traversal is simple. Perhaps

Line 443

}

* 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;

return (0);

}

/*-

*---------------------------------------------------------------------

* ParseAddDep --

* Check if the pair of GNodes given needs to be synchronized.

Line 463

* Side Effects:

* A dependency can be added between the two nodes.

*---------------------------------------------------------------------

int

Line 738

curTargs = Lst_Init(FALSE);

curSrcs = Lst_Init(FALSE);

do {

for (cp = line;

*cp && !isspace (*cp) &&

Line 786

}

savec = *cp;

if (!*cp) {

* Ending a dependency line without an operator is a Bozo

* no-no

Parse_Error (PARSE_FATAL, "Need an operator");

return;

Line 803

if (*line == '.' && isupper (line[1])) {

* See if the target is a special target that must have it

* or its sources handled specially.

int keywd = ParseFindKeyword(line);

if (keywd != -1) {

Line 811

Parse_Error(PARSE_FATAL, "Mismatched special targets");

return;

}

specType = parseKeywords[keywd].spec;

tOp = parseKeywords[keywd].op;

Line 871

case NotParallel:

{

extern int maxJobs;

maxJobs = 1;

break;

}

Line 891

* modify.

Lst path;

specType = ExPath;

path = Suff_GetPath (&line[5]);

if (path == NILLST) {

Line 907

}

* Have word in line. Get or create its node and stick it at

* the end of the targets list

if ((specType == Not) && (*line != '\0')) {

if (Dir_HasWildcards(line)) {

Line 921

* Dir module could have added a directory to the path...

Lst emptyPath = Lst_Init(FALSE);

Dir_Expand(line, emptyPath, curTargs);

Lst_Destroy(emptyPath, Dir_Destroy);

} else {

Line 932

(void)Lst_AtEnd(curTargs, (ClientData)line);

}

while(!Lst_IsEmpty(curTargs)) {

char *targName = (char *)Lst_DeQueue(curTargs);

if (!Suff_IsTransform (targName)) {

gn = Targ_FindNode (targName, TARG_CREATE);

} else {

gn = Suff_AddTransform (targName);

}

(void)Lst_AtEnd (targets, (ClientData)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

Line 955

if (specType != Not && specType != ExPath) {

Boolean warn = FALSE;

while ((*cp != '!') && (*cp != ':') && *cp) {

if (*cp != ' ' && *cp != '\t') {

warn = TRUE;

Line 1022

Lst_ForEach (targets, ParseDoOp, (ClientData)&op);

* Get to the first source

while (*cp && isspace (*cp)) {

cp++;

Line 1075

} else if ((specType == NotParallel) || (specType == SingleShell)) {

*line = '\0';

}

* NOW GO FOR THE SOURCES

if ((specType == Suffixes) || (specType == ExPath) ||

(specType == Includes) || (specType == Libs) ||

Line 1196

line = cp;

}

if (mainNode == NILGNODE) {

* If we have yet to decide on a main target to make, in the

Line 1242

* Skip to variable name

for (;(*line == ' ') || (*line == '\t'); line++)

continue;

for (; *line != '=' || level != 0; line++)

Line 1257

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;

Line 1271

case ')':

level--;

break;

default:

if (wasSpace && haveName) {

if (ISEQOPERATOR(*line)) {

Line 1302

return FALSE;

}

else {

haveName = TRUE;

wasSpace = FALSE;

}

break;

Line 1341

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

Line 1549

*---------------------------------------------------------------------

* ParseDoInclude --

* Push to another file.

* 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

Line 1641

prefEnd = strrchr (Fname, '/');

if (prefEnd != (char *)NULL) {

char *newName;

*prefEnd = '\0';

if (file[0] == '/')

newName = estrdup(file);

Line 1731

*---------------------------------------------------------------------

* Parse_FromString --

* Start Parsing from the given string

* Results:

* None

Line 1754

oldFile->fname = fname;

oldFile->F = curFILE;

oldFile->p = curPTR;

(void) Lst_AtFront (includes, (ClientData)oldFile);

curFILE = NULL;

Line 1770

*---------------------------------------------------------------------

* ParseTraditionalInclude --

* Push to another file.

* The input is the line minus the "include". The file name is

* the string following the "include".

Line 1833

prefEnd = strrchr (fname, '/');

if (prefEnd != (char *)NULL) {

char *newName;

*prefEnd = '\0';

newName = str_concat (fname, file, STR_ADDSLASH);

fullname = Dir_FindFile (newName, parseIncPath);

Line 1953

/*-

*---------------------------------------------------------------------

* ParseReadc --

* Read a character from the current file

* Results:

* The character that was read

Line 1966

{

if (curFILE)

return fgetc(curFILE);

if (curPTR && *curPTR->ptr)

return *curPTR->ptr++;

return EOF;

Line 1976

/*-

*---------------------------------------------------------------------

* ParseUnreadc --

* Put back a character to the current file

* Results:

* None.

Line 2007

int skip; /* Skip lines that don't start with . */

{

char *line;

int c, lastc = '\0', lineLength;

int c, lastc, lineLength = 0;

Buffer buf;

c = ParseReadc();

buf = Buf_Init(MAKE_BSIZE);

if (skip) {

do {

Buf_Discard(buf, lineLength);

* Skip lines until get to one that begins with a

lastc = '\0';

* special char.

while (((c = ParseReadc()) != '\n' || lastc == '\\')

while ((c != '.') && (c != EOF)) {

&& c != EOF) {

while (((c != '\n') || (lastc == '\\')) && (c != EOF)) {

if (c == '\n') {

Buf_ReplaceLastByte(buf, (Byte)' ');

* Advance to next unescaped newline

lineno++;

if ((lastc = c) == '\n') {

while ((c = ParseReadc()) == ' ' || c == '\t');

lineno++;

}

if (c == EOF)

c = ParseReadc();

break;

}

lineno++;

Buf_AddByte(buf, (Byte)c);

lastc = c;

c = ParseReadc ();

}

if (c == EOF) {

Parse_Error(PARSE_FATAL, "Unclosed conditional/for loop");

if (c == EOF) {

Buf_Destroy(buf, TRUE);

Parse_Error (PARSE_FATAL, "Unclosed conditional/for loop");

return((char *)NULL);

return ((char *)NULL);

}

lineno++;

Buf_AddByte(buf, (Byte)'\0');

* Read the entire line into buf

line = (char *)Buf_GetAll(buf, &lineLength);

} while (skip == 1 && line[0] != '.');

buf = Buf_Init (MAKE_BSIZE);

if (c != '\n') {

Buf_Destroy(buf, FALSE);

lastc = '\0';

do {

if (lastc != '\0' && lastc != '\n')

Buf_AddByte (buf, (Byte) lastc);

if ((lastc = c) == '\n')

lineno++;

c = ParseReadc();

if (c == '\n' && lastc == '\\')

lastc = '\0';

} while (((c != '\n') || (lastc == '\0')) && (c != EOF));

if (lastc != '\0' && lastc != '\n')

Buf_AddByte (buf, (Byte) lastc);

}

lineno++;

Buf_AddByte (buf, (Byte)'\0');

line = (char *)Buf_GetAll (buf, &lineLength);

Buf_Destroy (buf, FALSE);

return line;

}

Line 2127

Line 2109

break;

}

if (c != EOF) {

lastc = c;

buf = Buf_Init(MAKE_BSIZE);

while (((c = ParseReadc ()) != '\n' || (lastc == '\\')) &&

(c != EOF))

{

Line 2179

Line 2161

ParseUnreadc('\t');

goto line_read;

}

break;

case '=':

if (!semiNL) {

Line 2246

Line 2228

Buf_AddByte (buf, (Byte)lastc);

lastc = c;

}

line_read:

lineno++;

if (lastc != '\0') {

Buf_AddByte (buf, (Byte)lastc);

}

Line 2266

Line 2248

ep = line;

while (*ep)

++ep;

while (ep > line && (ep[-1] == ' ' || ep[-1] == '\t')) {

while (ep > line + 1 && (ep[-1] == ' ' || ep[-1] == '\t')) {

if (ep > line + 1 && ep[-2] == '\\')

break;

--ep;

}

*ep = 0;

if (line[0] == '.') {

* The line might be a conditional. Ask the conditional module

Line 2304

Line 2286

line = ParseSkipLine(0);

if (line == NULL) {

Parse_Error (PARSE_FATAL,

"Unexpected end of file in for loop.\n");

break;

}

Line 2352

Line 2334

inLine = FALSE;

}

/*-

*---------------------------------------------------------------------

* Parse_File --

Line 2413

Line 2395

goto nextLine;

}

if (*line == '#' || *line == '\0') {

if (*line == '#') {

/* If we're this far, the line must be a comment.

/* If we're this far, the line must be a comment. */

(Empty lines are ignored as well) */

goto nextLine;

}

if (*line == '\t') {

* If a line starts with a tab, it can only hope to be

Line 2435

Line 2416

* 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 (targets, ParseAddCmd, cp);

Lst_AtEnd(targCmds, (ClientData) line);

Line 2447

Line 2428

}

#ifdef SYSVINCLUDE

} else if (strncmp (line, "include", 7) == 0 &&

isspace((unsigned char) line[7]) &&

strchr(line, ':') == NULL) {

Line 2473

Line 2454

#ifndef POSIX

Boolean nonSpace = FALSE;

#endif

cp = line;

if (isspace((unsigned char) line[0])) {

while ((*cp != '\0') && isspace((unsigned char) *cp)) {

Line 2489

Line 2470

}

#endif

}

#ifndef POSIX

if (*cp == '\0') {

if (inLine) {

Line 2506

Line 2487

cp = Var_Subst (NULL, line, VAR_CMD, TRUE);

free (line);

line = cp;

* Need a non-circular list for the target nodes

if (targets)

Lst_Destroy(targets, NOFREE);

targets = Lst_Init (FALSE);

inLine = TRUE;

ParseDoDependency (line);

#ifndef POSIX

}

Line 2527

Line 2508

free (line);

}

* Reached EOF, but it may be just EOF of an include file...

} while (ParseEOF(1) == CONTINUE);

Line 2574

Line 2555

Lst_Destroy(parseIncPath, Dir_Destroy);

Lst_Destroy(includes, NOFREE); /* Should be empty now */

}

/*-

*-----------------------------------------------------------------------