sbase/make/parser.c

#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "make.h"

#define MAXREPL  30
#define TABSIZ   64
#define MAXTOKEN FILENAME_MAX
#define ITEM     128

typedef struct macro Macro;

enum inputype {
	FTFILE,
	FTEXPAN,
};

enum {
	STBEGIN,
	STINTERNAL,
	STREPLACE,
	STTO,
	STEND,
};

struct input {
	int siz;
	int type;

	FILE *fp;
	struct loc loc;

	int pos;
	char *buf;

	struct input *prev;
};

struct macro {
	char *name;
	char *value;
	int where;

	struct macro *next;
};

static struct input *input;
static char token[MAXTOKEN];
static int tok;
static Macro *htab[TABSIZ];

void
dumpmacros(void)
{
	Macro **pp, *p;

	for (pp = htab; pp < &htab[TABSIZ]; ++pp) {
		for (p = *pp; p; p = p->next)
			printf("%s = %s\n", p->name, getmacro(p->name));
	}
}

static Macro *
lookup(char *name)
{
	Macro *mp;
	int h = hash(name) & TABSIZ-1;

	for (mp = htab[h]; mp && strcmp(mp->name, name); mp = mp->next)
		;

	if (mp)
		return mp;

	mp = emalloc(sizeof(*mp));
	mp->name = estrdup(name);
	mp->value = estrdup("");
	mp->next = htab[h];
	mp->where = UNDEF;
	htab[h] = mp;

	return mp;
}

static char *
macroinfo(char *name, int *pwhere, Macro **mpp)
{
	char *s, *t;
	int hide, where;
	Macro *mp = lookup(name);

	hide = 0;
	if (!strcmp(name, "SHELL") || !strcmp(name, "MAKEFLAGS"))
		hide = 1;

	s = mp->value;
	where = mp->where;

	if (!hide && (where == UNDEF || where == INTERNAL || eflag)) {
		t = getenv(name);
		if (t) {
			where = ENVIRON;
			s = t;
		}
	}

	if (pwhere)
		*pwhere = where;
	if (mpp)
		*mpp = mp;

	return s;
}

char *
getmacro(char *name)
{
	return macroinfo(name, NULL, NULL);
}

void
setmacro(char *name, char *val, int where, int export)
{
	int owhere, set;
	char *s;
	Macro *mp;

	assert(where != ENVIRON);

	s = macroinfo(name, &owhere, &mp);

	/*
	 *  Default values are defined before anything else, and marked
	 *  as INTERNAL because they are injected as parseable text, and
	 *  MAKEFILE and INTERNAL variables are always overriden. ENVIRON
	 *  macros are generated in macroinfo() and this is why this function
	 *  should not receive a where == ENVIRON ever.
	 */
	switch (owhere) {
	case UNDEF:
	case INTERNAL:
	case MAKEFILE:
		set = 1;
		break;
	case ENVIRON:
		set = (where == MAKEFLAGS || where == CMDLINE);
		set |= (where == MAKEFILE && !eflag);
		break;
	case MAKEFLAGS:
		set = (where == CMDLINE || where == MAKEFLAGS);
		break;
	case CMDLINE:
		set = (where == CMDLINE);
		break;
	default:
		abort();
	}

	if (!set) {
		debug("hidding override of %s from '%s' to '%s'", name, s, val);
	} else {
		debug("override %s from '%s' to '%s'", name, s, val);
		free(mp->value);
		mp->value = estrdup(val);
		mp->where = where;

		if (export && strcmp(name, "SHELL") != 0) {
			debug("exporting macro %s", name);
			exportvar(name, val);
		}
	}
}

void
freeloc(struct loc *loc)
{
	free(loc->fname);
}

static struct loc *
getloc(void)
{
	struct input *ip;

	for (ip = input; ip && ip->type != FTFILE; ip = ip->prev)
		;
	if (!ip)
		return NULL;

	return &ip->loc;
}


void
error(char *fmt, ...)
{
	va_list va;
	struct loc *loc;

	fprintf(stderr, "make: error: ");
	if ((loc = getloc()) != NULL)
		fprintf(stderr, "%s:%d: ", loc->fname, loc->lineno);

	va_start(va, fmt);
	vfprintf(stderr, fmt, va);
	va_end(va);
	putc('\n', stderr);

	exit(EXIT_FAILURE);
}

void
warning(char *fmt, ...)
{
	va_list va;
	struct loc *loc;

	fprintf(stderr, "make: warning: ");
	if ((loc = getloc()) != NULL)
		fprintf(stderr, "%s:%d: ", loc->fname, loc->lineno);

	va_start(va, fmt);
	vfprintf(stderr, fmt, va);
	va_end(va);
	putc('\n', stderr);
}

static void
pop(void)
{
	struct input *ip = input->prev;

	if (input->type == FTFILE) {
		if (input->fp)
			fclose(input->fp);
		freeloc(&input->loc);
	}
	free(input->buf);
	free(input);

	input = ip;
}

static void
push(int type, ...)
{
	int line, len, pos;
	FILE *fp = NULL;
	char *buf, *s, *fname = NULL;
	va_list va;
	struct input *ip;

	va_start(va, type);
	switch (type) {
	case FTFILE:
		fp = va_arg(va, FILE *);
		s = va_arg(va, char *);
		line = va_arg(va, int);
		fname = estrdup(s);
		buf = emalloc(BUFSIZ);
		pos = len = BUFSIZ;
		break;
	case FTEXPAN:
		s = va_arg(va, char *);
		buf = estrdup(s);
		line = pos = 0;
		len = strlen(s);
		break;
	}
	va_end(va);

	ip = emalloc(sizeof(*ip));
	ip->siz = len;
	ip->buf = buf;
	ip->type = type;
	ip->fp = fp;
	ip->loc.fname = fname;
	ip->loc.lineno = line;
	ip->pos = pos;
	ip->prev = input;

	input = ip;
}

static char *
trim(char *s)
{
	size_t len;

	while (isspace(*s))
		s++;

	for (len = strlen(s); len > 0 && isspace(s[len-1]); --len)
		s[len-1] = '\0';

	return s;
}

static void
include(char *s)
{
	int len;
	FILE *fp;
	char *fil, *t;

	s = trim(s);
	fil = expandstring(s, NULL, getloc());

	t = trim(fil);
	if (strlen(t) != 0) {
		debug("including '%s'", t);
		if ((fp = fopen(t, "r")) == NULL)
			error("opening %s:%s", t, strerror(errno));
		push(FTFILE, fp, t, 0);
	}

	free(fil);
}

static char *
nextline(void)
{
	int c;
	FILE *fp;
	char *s, *lim;

	assert(input->type == FTFILE);

repeat:
	fp = input->fp;
	if (!fp || feof(fp))
		return NULL;

	lim = &input->buf[input->siz];
	for (s = input->buf; s < lim; *s++ = c) {
		c = getc(fp);
		if (c == '\n' || c == EOF) {
			input->loc.lineno++;
			*s++ = '\n';
			break;
		}
		if (c > UCHAR_MAX || c < 0)
			error("invalid character '%c' (%d)", c, c);
	}


	if (s == lim)
		error("too long line");
	if (ferror(fp))
		error(strerror(errno));
	*s = '\0';

	if (!strcmp(input->buf, ""))
		goto repeat;

	if (!strncmp(input->buf, "include", 7) && isblank(input->buf[7])) {
		input->pos = input->siz;
		include(input->buf+7);
		goto repeat;
	}

	input->pos = 0;


	return input->buf;
}

static int
empty(struct input *ip)
{
	return ip->pos == ip->siz || ip->buf[ip->pos] == '\0';
}

static int
moreinput(void)
{
	while (input) {
		if (!empty(input))
			break;

		switch (input->type) {
		case FTEXPAN:
			pop();
			break;
		case FTFILE:
			if (!nextline())
				pop();
			break;
		}
	}

	return input != NULL;
}

static int
nextc(void)
{
	if (!moreinput())
		return EOF;

	return input->buf[input->pos++];
}

/*
 * This function only can be called after a call to nextc
 * that didn't return EOF. It can return '\0', but as
 * it is used only to check against '$' then it is not
 * a problem.
 */
static int
ahead(void)
{
	return input->buf[input->pos];
}

static int
back(int c)
{
	if (c == EOF)
		return c;
	assert(input->pos > 0);
	return input->buf[--input->pos] = c;
}

static void
comment(void)
{
	int c;

	while ((c = nextc()) != EOF && c != '\n') {
		if (c == '\\' && nextc() == EOF)
			break;
	}
}

static void
skipspaces(void)
{
	int c;

	for (c = nextc(); c == ' ' || c == '\t'; c = nextc())
		;
	back(c);
}

static int
validchar(int c)
{
	if (c == EOF)
		return 0;
	return c == '.' || c == '/' || c == '_' || c == '-' || isalnum(c);
}

static char *
expandmacro(char *name)
{
	char *s;

	s = expandstring(getmacro(name), NULL, getloc());
	debug("macro %s expanded to '%s'", name, s);

	return s;
}

static void
replace(char *line, char *repl, char *to)
{
	int siz, at, len, replsiz, tosiz, sep, pos;
	char *oline, *s, *cur, *buf;

	debug("replacing '%s', with '%s' to '%s'", line, repl, to);
	oline = line;
	tosiz = strlen(to);
	replsiz = strlen(repl);

	buf = NULL;
	for (pos = 0; *line; pos += siz) {
		cur = NULL;
		siz = 0;

		for (siz = 0; *line == ' ' || *line == '\t'; ++siz) {
			cur = erealloc(cur, siz+1);
			cur[siz] = *line++;
		}

		len = strcspn(line, " \t");
		at = len - replsiz;
		if (at < 0 || memcmp(line + at, repl, replsiz)) {
			cur = erealloc(cur, siz + len);
			memcpy(cur + siz, line, len);
			siz += len;
		} else {
			cur = erealloc(cur, siz + at + tosiz);
			memcpy(cur + siz, line, at);
			memcpy(cur + siz + at, to, tosiz);
			siz += at + tosiz;
		}

		line += len;
		buf = erealloc(buf, pos + siz);
		memcpy(buf + pos, cur, siz);
		free(cur);
	}

	if (pos > 0) {
		buf = erealloc(buf, pos + 1);
		buf[pos] = '\0';
		debug("\treplace '%s' with '%s'", oline, buf);
		push(FTEXPAN, buf);
	}

	free(buf);
}

static void
expandsimple(Target *tp)
{
	char *s;
	Target **p;
	int len, c;

	switch (c = nextc()) {
	case '@':
		if (!tp || !tp->target)
			return;
		push(FTEXPAN, tp->target);
		break;
	case '<':
		if (!tp || !tp->req)
			return;
		push(FTEXPAN, tp->req);
		break;
	case '*':
		if (!tp || !tp->target)
			return;
		s = strrchr(tp->target, '.');
		if (!s) {
			push(FTEXPAN, tp->target);
			return;
		}

		len = s - tp->target;
		s = emalloc(len+1);
		memcpy(s, tp->target, len);
		s[len] = '\0';
		push(FTEXPAN, s);
		free(s);
		break;
	case '?':
		if (!tp)
			return;

		if (tp->req && stamp(tp->req) > tp->stamp) {
			push(FTEXPAN, " ");
			push(FTEXPAN, tp->req);
		}

		for (p = tp->deps; p && *p; ++p) {
			if (stamp((*p)->name) > tp->stamp) {
				push(FTEXPAN, " ");
				push(FTEXPAN, (*p)->name);
			}
		}
		break;
	default:
		token[0] = c;
		token[1] = '\0';
		s = expandmacro(token);
		push(FTEXPAN, s);
		free(s);
		break;
	}
}

static int
internal(int ch)
{
	switch (ch) {
	case '@':
	case '?':
	case '*':
	case '<':
		return 1;
	default:
		return 0;
	}
}

static void
expansion(Target *tp)
{
	int delim, c, repli, toi, namei, st;
	char name[MAXTOKEN], repl[MAXREPL], to[MAXREPL];
	char *s, *erepl;

	c = nextc();
	if (c == '(')
		delim = ')';
	else if (c == '{')
		delim = '}';
	else
		delim = 0;

	if (!delim) {
		back(c);
		expandsimple(tp);
		return;
	}

	s = NULL;
	namei = repli = toi = 0;
	st = STBEGIN;

	while (st != STEND && (c = nextc()) != EOF) {
		switch (st) {
		case STBEGIN:
			if (c == ':') {
				st = STREPLACE;
				name[namei] = '\0';
				s = expandmacro(name);
				break;
			}
			if (c == delim) {
				name[namei] = '\0';
				s = expandmacro(name);
				goto no_replace;
			}
			if (namei == MAXTOKEN-1)
				error("expansion text too long");

			if (namei == 0 && internal(c)) {
				name[namei++] = '$';
				name[namei++] = c;
				name[namei] = '\0';
				st = STINTERNAL;
				s = expandstring(name, tp, getloc());
				break;
			}

			if (!validchar(c))
				error("invalid macro name in expansion");
			name[namei++] = c;
			break;
		case STINTERNAL:
			if (c == delim)
				goto no_replace;
			if (c != ':')
				error("invalid internal macro in expansion");
			st = STREPLACE;
			break;
		case STREPLACE:
			if (c == '=') {
				st = STTO;
				break;
			}
			if (c == delim)
				error("invalid replacement pattern in expansion");
			if (repli == MAXREPL-1)
				error("macro replacement too big");
			repl[repli++] = c;
			break;
		case STTO:
			if (c == delim) {
				st = STEND;
				break;
			}

			if (toi == MAXREPL-1)
				error("macro substiturion too big");
			to[toi++] = c;
			break;
		}
	}

	if (c == EOF)
		error("found eof while parsing expansion");

	repl[repli] = '\0';
	to[toi] = '\0';

	erepl = expandstring(repl, tp, getloc());
	replace(s, erepl, to);

	free(erepl);
	free(s);
	return;

no_replace:
	push(FTEXPAN, s);
	free(s);
}

/*
 * Horrible hack to do string expansion.
 * We cannot use normal push and nextc because that
 * would consume characters of the current file too.
 * For that reason it cleans the input and it recovers
 * it later.
 */
char *
expandstring(char *line, Target *tp, struct loc *loc)
{
	int c, n;
	char *s;
	struct input *ip = input;

	input = NULL;
	push(FTFILE, NULL, loc->fname, loc->lineno);
	push(FTEXPAN, line);

	n = 0;
	s = NULL;
	while ((c = nextc()) != EOF) {
		if (c != '$') {
			s = erealloc(s, ++n);
			s[n-1] = c;
			continue;
		}

		if ((c = nextc()) == '$') {
			s = erealloc(s, n += 2);
			s[n-2] = '$';
			s[n-1] = '$';
		} else {
			back(c);
			expansion(tp);
		}
	}

	s = erealloc(s, n+1);
	s[n] = '\0';
	input = ip;

	return s;
}

static int
item(void)
{
	int c;
	char *s;
	char buf[MAXTOKEN];

	for (s = buf; s < &buf[MAXTOKEN] - 1; ) {
		c = nextc();
		if (c == '$' && ahead() != '$')
			expansion(NULL);
		else if (validchar(c))
			*s++ = c;
		else
			break;
	}
	back(c);

	if (s >= &buf[MAXTOKEN] - 1)
		error("token too long");
	if (s == buf)
		error("invalid empty token");
	*s++ = '\0';
	memcpy(token, buf, s - buf);

	return ITEM;
}

static int
next(void)
{
	int c;

repeat:
	/*
	 * It is better to avoid skipspaces() here, because
	 * it can generate the need for 2 calls to back(),
	 * and we need the character anyway.
	 */
	c = nextc();
	if (c == ' ' || c == '\t')
		goto repeat;

	if (c == '\\') {
		if ((c = nextc()) == '\n')
			goto repeat;
		back(c);
		c = '\\';
	}

	switch (c) {
	case EOF:
		strcpy(token, "<EOF>");
		tok = EOF;
		break;
	case '$':
		if ((c = nextc()) == '$')
			goto single;
		back(c);
		expansion(NULL);
		goto repeat;
	case '#':
		comment();
		c = '\n';
	case ';':
	case ':':
	case '=':
	case '\n':
	single:
		token[0] = c;
		token[1] = '\0';
		tok = c;
		break;
	default:
		if (!validchar(c))
			error("unexpected character '%c'", c);
		back(c);
		tok = item();
		break;
	}

	return tok;
}

static char *
readmacrodef(void)
{
	int n, c;
	char *line;

	n = 0;
	line = NULL;
	while ((c = nextc()) != EOF) {
		line = erealloc(line, n+1);
		if (c == '\n')
			break;
		if (c == '#') {
			comment();
			break;
		}
		if (c == '\\') {
			if ((c = nextc()) != '\n') {
				back(c);
				c = '\\';
			} else {
				skipspaces();
				c = ' ';
			}
		}

		line[n++] = c;
	}
	if (c == EOF)
		error("EOF while looking for end of line");
	line[n] = '\0';

	return line;
}

static struct action
readcmd(void)
{
	int n, c;
	struct loc *loc;
	struct action act;

	skipspaces();

	loc = getloc();
	act.loc.fname = estrdup(loc->fname);
	act.loc.lineno = loc->lineno;

	n = 0;
	act.line = NULL;
	while ((c = nextc()) != EOF) {
		act.line = erealloc(act.line, n+1);
		if (c == '\n')
			break;
		if (c == '\\') {
			if ((c = nextc()) == '\n') {
				if ((c = nextc()) != '\t')
					back(c);
				continue;
			}
			back(c);
			c = '\\';
		}
		act.line[n++] = c;
	}
	if (c == EOF)
		error("EOF while looking for end of command");
	act.line[n] = '\0';

	return act;
}

static void
rule(char *targets[], int ntargets)
{
	int c, i, j, ndeps, nactions;
	struct action *acts;
	char **deps = NULL;

	if (ntargets == 0)
		error("missing target");

	for (ndeps = 0; next() == ITEM; ++ndeps) {
		deps = erealloc(deps, (ndeps+1) * sizeof(char *));
		deps[ndeps] = estrdup(token);
	}

	if (tok != '\n' && tok != ';')
		error("garbage at the end of the line");

	nactions = 0;
	acts = NULL;
	if (tok == ';') {
		nactions++;
		acts = erealloc(acts, nactions * sizeof(*acts));
		acts[nactions-1] = readcmd();
	}

	for (;;) {
		if ((c = nextc()) == '#') {
			comment();
			continue;
		}
		if (c != '\t')
			break;
		nactions++;
		acts = erealloc(acts, nactions * sizeof(*acts));
		acts[nactions-1] = readcmd();
	}
	back(c);

	for (i = 0; i < ntargets; i++) {
		addtarget(targets[i], ndeps);
		for (j = 0; j < ndeps; j++)
			adddep(targets[i], deps[j]);
		if (nactions > 0)
			addrule(targets[i], acts, nactions);
	}

	for (i = 0; i < ndeps; i++)
		free(deps[i]);
	free(deps);

	for (i = 0; i < nactions; i++) {
		free(acts[i].line);
		freeloc(&acts[i].loc);
	}
	free(acts);
}

static void
assign(char *macros[], int where, int n)
{
	char *defs;

	if (n != 1)
		error("invalid macro definition");

	skipspaces();
	defs = readmacrodef();
	setmacro(*macros, defs, where, NOEXPORT);
	free(defs);
}

void
parseinput(int where)
{
	int i, n;
	char **targets;

	while (moreinput()) {
		n = 0;
		targets = NULL;

		next();
		if (tok == '\n')
			continue;

		while (tok == ITEM) {
			n++;
			targets = erealloc(targets, n * sizeof(char *));
			targets[n-1] = estrdup(token);
			next();
		}

		switch (tok) {
		case ':':
			rule(targets, n);
			break;
		case '=':
			assign(targets, where, n);
			break;
		default:
			error("unexpected token '%s'(%d)", token, tok);
		}

		for (i = 0; i < n; i++)
			free(targets[i]);
		free(targets);
	}
}

int
parse(char *fname)
{
	FILE *fp;

	if (!fname) {
		fp = stdin;
		fname = "<stdin>";
	} else if ((fp = fopen(fname, "r")) == NULL) {
		return 0;
	}

	debug("parsing %s", fname);
	push(FTFILE, fp, fname, 0);
	parseinput(MAKEFILE);

	return 1;
}

void
inject(char *s)
{
	push(FTFILE, NULL, "<internal>", 0);
	push(FTEXPAN, s);
	parseinput(INTERNAL);
}