/*************************************************************************

*

* m a k e : i n p u t . c

*

* Parse a makefile

*========================================================================

* Edition history

*

* # Date Comments By

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

* 1 ?? ??

* 2 23.08.89 new name tree structure introduced to speed up make,

* testname introduced to shrink the memory usage RAL

* 3 30.08.89 indention changed PSH,RAL

* 4 03.09.89 fixed LZ eliminated RAL

* 5 06.09.89 ; command added RAL

* ------------ Version 2.0 released ------------------------------- RAL

*

*************************************************************************/

#include "h.h"

static struct name *lastrrp;

static struct name *freerp = (struct name *)NULL;

void init()

{

if( (suffparray = (struct name **) malloc( sizesuffarray *

sizeof(struct name *))) == (struct name **) NULL)

fatal("No memory for suffarray",(char *)0,0);

if ((*suffparray = (struct name *)malloc(sizeof (struct name)))

== (struct name *)0)

fatal("No memory for name",(char *)0,0);

(*suffparray)->n_next = (struct name *)0;

if ((str1 = (char *) malloc(LZ1)) == ((char *)0))

fatal("No memory for str1",(char *)0,0);

str1s.ptr = &str1;

str1s.len = LZ1;

if ((str2 = (char *) malloc(LZ2)) == (char *)0)

fatal("No memory for str2",(char *)0,0);

str2s.ptr = &str2;

str2s.len = LZ2;

}

void strrealloc(strs)

struct str *strs;

{

strs->len *= 2;

*strs->ptr = (char *) realloc(*strs->ptr, strs->len + 16);

if(*strs->ptr == (char *) NULL)

fatal("No memory for string reallocation",(char *)0,0);

}

/*

* Intern a name. Return a pointer to the name struct

*/

struct name *newname(name)

char *name;

{

register struct name *rp;

register struct name *rrp;

register char *cp;

register int i;

register char *suff; /* ptr. to suffix in current name */

register struct name **sp; /* ptr. to ptr. to chain of names */

if ( (suff = suffix(name)) != (char *)NULL) {

for (i = 1, sp = suffparray, sp++;

i <= maxsuffarray && strcmp(suff, (*sp)->n_name) != 0;

sp++,i++);

if (i > maxsuffarray) {

if ( i >= sizesuffarray) { /* must realloc suffarray */

sizesuffarray *= 2;

if( (suffparray = (struct name **) realloc((char *) suffparray,

sizesuffarray * sizeof(struct name *))) == (struct name **) NULL)

fatal("No memory for suffarray",(char *)0,0);

}

maxsuffarray++;

sp = &suffparray[i];

if ((*sp = (struct name *)malloc(sizeof (struct name)))

== (struct name *)0)

fatal("No memory for name",(char *)0,0);

(*sp)->n_next = (struct name *)0;

if ((cp = (char *) malloc(strlen(suff)+1)) == (char *)0)

fatal("No memory for name",(char *)0,0);

strcpy(cp, suff);

(*sp)->n_name = cp;

}

}

else

sp = suffparray;

for ( rp = (*sp)->n_next, rrp = *sp; rp; rp = rp->n_next, rrp = rrp->n_next )

if (strcmp(name, rp->n_name) == 0) return rp;

if ( freerp == (struct name *)NULL) {

if ((rp = (struct name *)malloc(sizeof (struct name))) == (struct name *)0)

fatal("No memory for name",(char *)0,0);

}

else {

rp = freerp;

freerp = (struct name *)NULL;

}

rrp->n_next = rp;

rp->n_next = (struct name *)0;

if ((cp = (char *) malloc(strlen(name)+1)) == (char *)0)

fatal("No memory for name",(char *)0,0);

strcpy(cp, name);

rp->n_name = cp;

rp->n_line = (struct line *)0;

rp->n_time = (time_t)0;

rp->n_flag = 0;

lastrrp = rrp;

return rp;

}

/*

* Test a name.

* If the name already exists return the ptr. to its name structure.

* Else if the file exists 'intern' the name and return the ptr.

* Otherwise don't waste memory and return a NULL pointer

*/

struct name *testname(name)

char *name;

{

register struct name *rp;

lastrrp = (struct name *)NULL;

rp = newname( name);

if (rp->n_line || rp->n_flag & N_EXISTS)

return(rp);

modtime(rp);

if (rp->n_flag & N_EXISTS)

return(rp);

if (lastrrp != (struct name *)NULL) {

free (rp->n_name);

lastrrp->n_next = (struct name *)NULL;

freerp = rp;

}

return((struct name *)NULL);

}

/*

* Add a dependant to the end of the supplied list of dependants.

* Return the new head pointer for that list.

*/

struct depend *newdep(np, dp)

struct name *np;

struct depend *dp;

{

register struct depend *rp;

register struct depend *rrp;

if ((rp = (struct depend *)malloc(sizeof (struct depend)))

== (struct depend *)0)

fatal("No memory for dependant",(char *)0,0);

rp->d_next = (struct depend *)0;

rp->d_name = np;

if (dp == (struct depend *)0) return rp;

for (rrp = dp; rrp->d_next; rrp = rrp->d_next) ;

rrp->d_next = rp;

return dp;

}

/*

* Add a command to the end of the supplied list of commands.

* Return the new head pointer for that list.

*/

struct cmd *newcmd(str, cp)

char *str;

struct cmd *cp;

{

register struct cmd *rp;

register struct cmd *rrp;

register char *rcp;

if (rcp = strrchr(str, '\n')) *rcp = '\0'; /* Loose newline */

while (isspace(*str)) str++;

if (*str == '\0') return cp; /* If nothing left, the exit */

if ((rp = (struct cmd *)malloc(sizeof (struct cmd))) == (struct cmd *)0)

fatal("No memory for command",(char *)0,0);

rp->c_next = (struct cmd *)0;

if ((rcp = (char *) malloc(strlen(str)+1)) == (char *)0)

fatal("No memory for command",(char *)0,0);

strcpy(rcp, str);

rp->c_cmd = rcp;

if (cp == (struct cmd *)0) return rp;

for (rrp = cp; rrp->c_next; rrp = rrp->c_next) ;

rrp->c_next = rp;

return cp;

}

/*

* Add a new 'line' of stuff to a target. This check to see

* if commands already exist for the target. If flag is set,

* the line is a double colon target.

*

* Kludges:

* i) If the new name begins with a '.', and there are no dependents,

* then the target must cease to be a target. This is for .SUFFIXES.

* ii) If the new name begins with a '.', with no dependents and has

* commands, then replace the current commands. This is for

* redefining commands for a default rule.

* Neither of these free the space used by dependents or commands,

* since they could be used by another target.

*/

void newline(np, dp, cp, flag)

struct name *np;

struct depend *dp;

struct cmd *cp;

int flag;

{

bool hascmds = FALSE; /* Target has commands */

register struct line *rp;

register struct line *rrp;

/* Handle the .SUFFIXES case */

if (np->n_name[0] == '.' && !dp && !cp) {

for (rp = np->n_line; rp; rp = rrp) {

rrp = rp->l_next;

free(rp);

}

np->n_line = (struct line *)0;

np->n_flag &= ~N_TARG;

return;

}

/* This loop must happen since rrp is used later. */

for ( rp = np->n_line, rrp = (struct line *)0; rp; rrp = rp, rp = rp->l_next)

if (rp->l_cmd) hascmds = TRUE;

if (hascmds && cp && !(np->n_flag & N_DOUBLE))

/* Handle the implicit rules redefinition case */

if (np->n_name[0] == '.' && dp == (struct depend *)0) {

np->n_line->l_cmd = cp;

return;

}

else

error("Commands defined twice for target %s", np->n_name);

if (np->n_flag & N_TARG)

if (!(np->n_flag & N_DOUBLE) != !flag) /* like xor */

error("Inconsistent rules for target %s", np->n_name);

if ((rp = (struct line *)malloc(sizeof (struct line))) == (struct line *)0)

fatal("No memory for line",(char *)0,0);

rp->l_next = (struct line *)0;

rp->l_dep = dp;

rp->l_cmd = cp;

if (rrp)

rrp->l_next = rp;

else

np->n_line = rp;

np->n_flag |= N_TARG;

if (flag) np->n_flag |= N_DOUBLE;

}

/*

* Parse input from the makefile, and construct a tree structure

* of it.

*/

void input(fd)

FILE *fd;

{

char *p; /* General */

char *q;

register char *a;

struct name *np;

struct depend *dp;

struct cmd *cp;

bool dbl;

if (getline(&str1s, fd)) return; /* Read the first line */

for(;;) {

if (*str1 == TABCHAR) /* Rules without targets */

error("Rules not allowed here",(char *)0);

p = str1;

while (isspace(*p)) p++; /* Find first target */

while (((q = strchr(p, '=')) != (char *)0) &&

(p != q) && (q[-1] == '\\')) /* Find value */

{

a = q - 1; /* Del \ chr; move rest back */

p = q;

while(*a++ = *q++)

;

}

if (q != (char *)0) {

*q++ = '\0'; /* Separate name and val */

while (isspace(*q))

q++;

if (p = strrchr(q, '\n'))

*p = '\0';

p = str1;

if ((a = gettok(&p)) == (char *)0)

error("No macro name",(char *)0);

setmacro(a, q);

if (getline(&str1s, fd))

return;

continue;

}

/* include? */

p = str1;

while (isspace(*p)) p++;

if (strncmp(p, "include", 7) == 0 && isspace(p[7])) {

char *old_makefile = makefile;

int old_lineno = lineno;

FILE *ifd;

p += 8;

memmove(str1, p, strlen(p)+1);

expand(&str1s);

p = str1;

while (isspace(*p)) p++;

if ((q = malloc(strlen(p)+1)) == (char *)0)

fatal("No memory for include",(char *)0,0);

strcpy(q, p);

p = q;

while ((makefile = gettok(&q)) != (char *)0) {

if ((ifd = fopen(makefile, "r")) == (FILE *)0)

fatal("Can't open %s: %s", makefile, errno);

lineno = 0;

input(ifd);

fclose(ifd);

}

free(p);

makefile = old_makefile;

lineno = old_lineno;

if (getline(&str1s, fd))

return;

continue;

}

/* Search for commands on target line --- do not expand them ! */

q = str1;

cp = (struct cmd *)0;

if ((a = strchr(q, ';')) != (char *)0) {

*a++ = '\0'; /* Separate dependents and commands */

if ( a) cp = newcmd(a, cp);

}

expand(&str1s);

p = str1;

while (isspace(*p)) p++;

while (((q = strchr(p, ':')) != (char *)0) &&

(p != q) && (q[-1] == '\\')) /* Find dependents */

{

a = q - 1; /* Del \ chr; move rest back */

p = q;

while(*a++ = *q++) ;

}

if (q == (char *)0)

error("No targets provided",(char *)0);

*q++ = '\0'; /* Separate targets and dependents */

if (*q == ':') { /* Double colon */

dbl = 1;

q++;

}

else

dbl = 0;

for (dp = (struct depend *)0; ((p = gettok(&q)) != (char *)0);)

/* get list of dep's */

{

np = newname(p); /* Intern name */

dp = newdep(np, dp); /* Add to dep list */

}

*((q = str1) + strlen(str1) + 1) = '\0';

/* Need two nulls for gettok (Remember separation) */

if (getline(&str2s, fd) == FALSE) { /* Get commands */

while (*str2 == TABCHAR) {

cp = newcmd(&str2[0], cp);

if (getline(&str2s, fd))

break;

}

}

while ((p = gettok(&q)) != (char *)0) /* Get list of targ's */

{

np = newname(p); /* Intern name */

newline(np, dp, cp, dbl);

if (!firstname && p[0] != '.')

firstname = np;

}

if (feof(fd)) /* EOF? */

return;

while (strlen(str2) >= str1s.len) strrealloc(&str1s);

strcpy(str1, str2);

}

}