Initial import.

1 files changed, 515 insertions, 0 deletions

diff --git a/src/tools/lcc/cpp/macro.c b/src/tools/lcc/cpp/macro.c
new file mode 100644
index 0000000..49d1129
--- /dev/null
+++ b/src/tools/lcc/cpp/macro.c
@@ -0,0 +1,515 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "cpp.h"
+
+/*
+ * do a macro definition.  tp points to the name being defined in the line
+ */
+void
+dodefine(Tokenrow *trp)
+{
+	Token *tp;
+	Nlist *np;
+	Tokenrow *def, *args;
+
+	tp = trp->tp+1;
+	if (tp>=trp->lp || tp->type!=NAME) {
+		error(ERROR, "#defined token is not a name");
+		return;
+	}
+	np = lookup(tp, 1);
+	if (np->flag&ISUNCHANGE) {
+		error(ERROR, "#defined token %t can't be redefined", tp);
+		return;
+	}
+	/* collect arguments */
+	tp += 1;
+	args = NULL;
+	if (tp<trp->lp && tp->type==LP && tp->wslen==0) {
+		/* macro with args */
+		int narg = 0;
+		tp += 1;
+		args = new(Tokenrow);
+		maketokenrow(2, args);
+		if (tp->type!=RP) {
+			int err = 0;
+			for (;;) {
+				Token *atp;
+				if (tp->type!=NAME) {
+					err++;
+					break;
+				}
+				if (narg>=args->max)
+					growtokenrow(args);
+				for (atp=args->bp; atp<args->lp; atp++)
+					if (atp->len==tp->len
+					 && strncmp((char*)atp->t, (char*)tp->t, tp->len)==0)
+						error(ERROR, "Duplicate macro argument");
+				*args->lp++ = *tp;
+				narg++;
+				tp += 1;
+				if (tp->type==RP)
+					break;
+				if (tp->type!=COMMA) {
+					err++;
+					break;
+				}
+				tp += 1;
+			}
+			if (err) {
+				error(ERROR, "Syntax error in macro parameters");
+				return;
+			}
+		}
+		tp += 1;
+	}
+	trp->tp = tp;
+	if (((trp->lp)-1)->type==NL)
+		trp->lp -= 1;
+	def = normtokenrow(trp);
+	if (np->flag&ISDEFINED) {
+		if (comparetokens(def, np->vp)
+		 || (np->ap==NULL) != (args==NULL)
+		 || (np->ap && comparetokens(args, np->ap)))
+			error(ERROR, "Macro redefinition of %t", trp->bp+2);
+	}
+	if (args) {
+		Tokenrow *tap;
+		tap = normtokenrow(args);
+		dofree(args->bp);
+		args = tap;
+	}
+	np->ap = args;
+	np->vp = def;
+	np->flag |= ISDEFINED;
+}
+
+/*
+ * Definition received via -D or -U
+ */
+void
+doadefine(Tokenrow *trp, int type)
+{
+	Nlist *np;
+	static Token onetoken[1] = {{ NUMBER, 0, 0, 0, 1, (uchar*)"1" }};
+	static Tokenrow onetr = { onetoken, onetoken, onetoken+1, 1 };
+
+	trp->tp = trp->bp;
+	if (type=='U') {
+		if (trp->lp-trp->tp != 2 || trp->tp->type!=NAME)
+			goto syntax;
+		if ((np = lookup(trp->tp, 0)) == NULL)
+			return;
+		np->flag &= ~ISDEFINED;
+		return;
+	}
+	if (trp->tp >= trp->lp || trp->tp->type!=NAME)
+		goto syntax;
+	np = lookup(trp->tp, 1);
+	np->flag |= ISDEFINED;
+	trp->tp += 1;
+	if (trp->tp >= trp->lp || trp->tp->type==END) {
+		np->vp = &onetr;
+		return;
+	}
+	if (trp->tp->type!=ASGN)
+		goto syntax;
+	trp->tp += 1;
+	if ((trp->lp-1)->type == END)
+		trp->lp -= 1;
+	np->vp = normtokenrow(trp);
+	return;
+syntax:
+	error(FATAL, "Illegal -D or -U argument %r", trp);
+}
+			
+/*
+ * Do macro expansion in a row of tokens.
+ * Flag is NULL if more input can be gathered.
+ */
+void
+expandrow(Tokenrow *trp, char *flag)
+{
+	Token *tp;
+	Nlist *np;
+
+	if (flag)
+		setsource(flag, -1, "");
+	for (tp = trp->tp; tp<trp->lp; ) {
+		if (tp->type!=NAME
+		 || quicklook(tp->t[0], tp->len>1?tp->t[1]:0)==0
+		 || (np = lookup(tp, 0))==NULL
+		 || (np->flag&(ISDEFINED|ISMAC))==0
+		 || (tp->hideset && checkhideset(tp->hideset, np))) {
+			tp++;
+			continue;
+		}
+		trp->tp = tp;
+		if (np->val==KDEFINED) {
+			tp->type = DEFINED;
+			if ((tp+1)<trp->lp && (tp+1)->type==NAME)
+				(tp+1)->type = NAME1;
+			else if ((tp+3)<trp->lp && (tp+1)->type==LP
+			 && (tp+2)->type==NAME && (tp+3)->type==RP)
+				(tp+2)->type = NAME1;
+			else
+				error(ERROR, "Incorrect syntax for `defined'");
+			tp++;
+			continue;
+		}
+		if (np->flag&ISMAC)
+			builtin(trp, np->val);
+		else {
+			expand(trp, np);
+		}
+		tp = trp->tp;
+	}
+	if (flag)
+		unsetsource();
+}
+
+/*
+ * Expand the macro whose name is np, at token trp->tp, in the tokenrow.
+ * Return trp->tp at the first token next to be expanded
+ * (ordinarily the beginning of the expansion)
+ */
+void
+expand(Tokenrow *trp, Nlist *np)
+{
+	Tokenrow ntr;
+	int ntokc, narg, i;
+	Token *tp;
+	Tokenrow *atr[NARG+1];
+	int hs;
+
+	copytokenrow(&ntr, np->vp);		/* copy macro value */
+	if (np->ap==NULL)			/* parameterless */
+		ntokc = 1;
+	else {
+		ntokc = gatherargs(trp, atr, &narg);
+		if (narg<0) {			/* not actually a call (no '(') */
+			trp->tp++;
+			return;
+		}
+		if (narg != rowlen(np->ap)) {
+			error(ERROR, "Disagreement in number of macro arguments");
+			trp->tp->hideset = newhideset(trp->tp->hideset, np);
+			trp->tp += ntokc;
+			return;
+		}
+		substargs(np, &ntr, atr);	/* put args into replacement */
+		for (i=0; i<narg; i++) {
+			dofree(atr[i]->bp);
+			dofree(atr[i]);
+		}
+	}
+	doconcat(&ntr);				/* execute ## operators */
+	hs = newhideset(trp->tp->hideset, np);
+	for (tp=ntr.bp; tp<ntr.lp; tp++) {	/* distribute hidesets */
+		if (tp->type==NAME) {
+			if (tp->hideset==0)
+				tp->hideset = hs;
+			else
+				tp->hideset = unionhideset(tp->hideset, hs);
+		}
+	}
+	ntr.tp = ntr.bp;
+	insertrow(trp, ntokc, &ntr);
+	trp->tp -= rowlen(&ntr);
+	dofree(ntr.bp);
+	return;
+}	
+
+/*
+ * Gather an arglist, starting in trp with tp pointing at the macro name.
+ * Return total number of tokens passed, stash number of args found.
+ * trp->tp is not changed relative to the tokenrow.
+ */
+int
+gatherargs(Tokenrow *trp, Tokenrow **atr, int *narg)
+{
+	int parens = 1;
+	int ntok = 0;
+	Token *bp, *lp;
+	Tokenrow ttr;
+	int ntokp;
+	int needspace;
+
+	*narg = -1;			/* means that there is no macro call */
+	/* look for the ( */
+	for (;;) {
+		trp->tp++;
+		ntok++;
+		if (trp->tp >= trp->lp) {
+			gettokens(trp, 0);
+			if ((trp->lp-1)->type==END) {
+				trp->lp -= 1;
+				trp->tp -= ntok;
+				return ntok;
+			}
+		}
+		if (trp->tp->type==LP)
+			break;
+		if (trp->tp->type!=NL)
+			return ntok;
+	}
+	*narg = 0;
+	ntok++;
+	ntokp = ntok;
+	trp->tp++;
+	/* search for the terminating ), possibly extending the row */
+	needspace = 0;
+	while (parens>0) {
+		if (trp->tp >= trp->lp)
+			gettokens(trp, 0);
+		if (needspace) {
+			needspace = 0;
+			makespace(trp);
+		}
+		if (trp->tp->type==END) {
+			trp->lp -= 1;
+			trp->tp -= ntok;
+			error(ERROR, "EOF in macro arglist");
+			return ntok;
+		}
+		if (trp->tp->type==NL) {
+			trp->tp += 1;
+			adjustrow(trp, -1);
+			trp->tp -= 1;
+			makespace(trp);
+			needspace = 1;
+			continue;
+		}
+		if (trp->tp->type==LP)
+			parens++;
+		else if (trp->tp->type==RP)
+			parens--;
+		trp->tp++;
+		ntok++;
+	}
+	trp->tp -= ntok;
+	/* Now trp->tp won't move underneath us */
+	lp = bp = trp->tp+ntokp;
+	for (; parens>=0; lp++) {
+		if (lp->type == LP) {
+			parens++;
+			continue;
+		}
+		if (lp->type==RP)
+			parens--;
+		if (lp->type==DSHARP)
+			lp->type = DSHARP1;	/* ## not special in arg */
+		if ((lp->type==COMMA && parens==0) || (parens<0 && (lp-1)->type!=LP)) {
+			if (*narg>=NARG-1)
+				error(FATAL, "Sorry, too many macro arguments");
+			ttr.bp = ttr.tp = bp;
+			ttr.lp = lp;
+			atr[(*narg)++] = normtokenrow(&ttr);
+			bp = lp+1;
+		}
+	}
+	return ntok;
+}
+
+/*
+ * substitute the argument list into the replacement string
+ *  This would be simple except for ## and #
+ */
+void
+substargs(Nlist *np, Tokenrow *rtr, Tokenrow **atr)
+{
+	Tokenrow tatr;
+	Token *tp;
+	int ntok, argno;
+
+	for (rtr->tp=rtr->bp; rtr->tp<rtr->lp; ) {
+		if (rtr->tp->type==SHARP) {	/* string operator */
+			tp = rtr->tp;
+			rtr->tp += 1;
+			if ((argno = lookuparg(np, rtr->tp))<0) {
+				error(ERROR, "# not followed by macro parameter");
+				continue;
+			}
+			ntok = 1 + (rtr->tp - tp);
+			rtr->tp = tp;
+			insertrow(rtr, ntok, stringify(atr[argno]));
+			continue;
+		}
+		if (rtr->tp->type==NAME
+		 && (argno = lookuparg(np, rtr->tp)) >= 0) {
+			if ((rtr->tp+1)->type==DSHARP
+			 || (rtr->tp!=rtr->bp && (rtr->tp-1)->type==DSHARP))
+				insertrow(rtr, 1, atr[argno]);
+			else {
+				copytokenrow(&tatr, atr[argno]);
+				expandrow(&tatr, "<macro>");
+				insertrow(rtr, 1, &tatr);
+				dofree(tatr.bp);
+			}
+			continue;
+		}
+		rtr->tp++;
+	}
+}
+
+/*
+ * Evaluate the ## operators in a tokenrow
+ */
+void
+doconcat(Tokenrow *trp)
+{
+	Token *ltp, *ntp;
+	Tokenrow ntr;
+	int len;
+
+	for (trp->tp=trp->bp; trp->tp<trp->lp; trp->tp++) {
+		if (trp->tp->type==DSHARP1)
+			trp->tp->type = DSHARP;
+		else if (trp->tp->type==DSHARP) {
+			char tt[128];
+			ltp = trp->tp-1;
+			ntp = trp->tp+1;
+			if (ltp<trp->bp || ntp>=trp->lp) {
+				error(ERROR, "## occurs at border of replacement");
+				continue;
+			}
+			len = ltp->len + ntp->len;
+			strncpy((char*)tt, (char*)ltp->t, ltp->len);
+			strncpy((char*)tt+ltp->len, (char*)ntp->t, ntp->len);
+			tt[len] = '\0';
+			setsource("<##>", -1, tt);
+			maketokenrow(3, &ntr);
+			gettokens(&ntr, 1);
+			unsetsource();
+			if (ntr.lp-ntr.bp!=2 || ntr.bp->type==UNCLASS)
+				error(WARNING, "Bad token %r produced by ##", &ntr);
+			ntr.lp = ntr.bp+1;
+			trp->tp = ltp;
+			makespace(&ntr);
+			insertrow(trp, (ntp-ltp)+1, &ntr);
+			dofree(ntr.bp);
+			trp->tp--;
+		}
+	}
+}
+
+/*
+ * tp is a potential parameter name of macro mac;
+ * look it up in mac's arglist, and if found, return the
+ * corresponding index in the argname array.  Return -1 if not found.
+ */
+int
+lookuparg(Nlist *mac, Token *tp)
+{
+	Token *ap;
+
+	if (tp->type!=NAME || mac->ap==NULL)
+		return -1;
+	for (ap=mac->ap->bp; ap<mac->ap->lp; ap++) {
+		if (ap->len==tp->len && strncmp((char*)ap->t,(char*)tp->t,ap->len)==0)
+			return ap - mac->ap->bp;
+	}
+	return -1;
+}
+
+/*
+ * Return a quoted version of the tokenrow (from # arg)
+ */
+#define	STRLEN	512
+Tokenrow *
+stringify(Tokenrow *vp)
+{
+	static Token t = { STRING };
+	static Tokenrow tr = { &t, &t, &t+1, 1 };
+	Token *tp;
+	uchar s[STRLEN];
+	uchar *sp = s, *cp;
+	int i, instring;
+
+	*sp++ = '"';
+	for (tp = vp->bp; tp < vp->lp; tp++) {
+		instring = tp->type==STRING || tp->type==CCON;
+		if (sp+2*tp->len >= &s[STRLEN-10]) {
+			error(ERROR, "Stringified macro arg is too long");
+			break;
+		}
+		if (tp->wslen && (tp->flag&XPWS)==0)
+			*sp++ = ' ';
+		for (i=0, cp=tp->t; i<tp->len; i++) {	
+			if (instring && (*cp=='"' || *cp=='\\'))
+				*sp++ = '\\';
+			*sp++ = *cp++;
+		}
+	}
+	*sp++ = '"';
+	*sp = '\0';
+	sp = s;
+	t.len = strlen((char*)sp);
+	t.t = newstring(sp, t.len, 0);
+	return &tr;
+}
+
+/*
+ * expand a builtin name
+ */
+void
+builtin(Tokenrow *trp, int biname)
+{
+	char *op;
+	Token *tp;
+	Source *s;
+
+	tp = trp->tp;
+	trp->tp++;
+	/* need to find the real source */
+	s = cursource;
+	while (s && s->fd==-1)
+		s = s->next;
+	if (s==NULL)
+		s = cursource;
+	/* most are strings */
+	tp->type = STRING;
+	if (tp->wslen) {
+		*outp++ = ' ';
+		tp->wslen = 1;
+	}
+	op = outp;
+	*op++ = '"';
+	switch (biname) {
+
+	case KLINENO:
+		tp->type = NUMBER;
+		op = outnum(op-1, s->line);
+		break;
+
+	case KFILE: {
+		char *src = s->filename;
+		while ((*op++ = *src++) != 0)
+			if (src[-1] == '\\')
+				*op++ = '\\';
+		op--;
+		break;
+		}
+
+	case KDATE:
+		strncpy(op, curtime+4, 7);
+		strncpy(op+7, curtime+20, 4);
+		op += 11;
+		break;
+
+	case KTIME:
+		strncpy(op, curtime+11, 8);
+		op += 8;
+		break;
+
+	default:
+		error(ERROR, "cpp botch: unknown internal macro");
+		return;
+	}
+	if (tp->type==STRING)
+		*op++ = '"';
+	tp->t = (uchar*)outp;
+	tp->len = op - outp;
+	outp = op;
+}