#include <u.h>#include <libc.h>#include <stdio.h>#include "cpp.h" /* * do a macro definition.  tp points to the name being defined in the line */voiddodefine(Tokenrow *trp){	Token *tp;	Nlist *np;	Tokenrow *def, *args;	int dots; 	dots = 0;	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 == ELLIPS)					dots++;				else 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 (dots)					error(ERROR, "arguments after '...' in macro");				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;	if(dots)		np->flag |= ISVARMAC;} /* * Definition received via -D or -U */voiddoadefine(Tokenrow *trp, int type){	Nlist *np;	static unsigned char one[] = "1";	static Token onetoken[1] = {{ NUMBER, 0, 0, 0, 1, one }};	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. */voidexpandrow(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) */voidexpand(Tokenrow *trp, Nlist *np){	int ntokc, narg, nparam, i, hs;	Tokenrow *atr[NARG+1];	Tokenrow ntr;	Token *tp; 	copytokenrow(&ntr, np->vp);		/* copy macro value */	if (np->ap==NULL) {			/* parameterless */		ntokc = 1;		/* substargs for handling # and ## */		atr[0] = nil;		substargs(np, &ntr, atr, trp->tp->hideset);	} else {		ntokc = gatherargs(trp, atr, (np->flag&ISVARMAC) ? rowlen(np->ap) : 0, &narg);		if (narg<0) {			/* not actually a call (no '(') */			/* gatherargs has already pushed trp->tr to the next token */			return;		}		nparam = rowlen(np->ap); 		if(narg == nparam - 1		&& (narg == 0 || (np->flag&ISVARMAC))) {			if(narg == NARG)				error(ERROR, "Too many arguments");			atr[narg] = new(Tokenrow);			maketokenrow(0, atr[narg]);			narg++;		} 		if (narg != nparam) {			error(ERROR, "Disagreement in number of macro arguments");			trp->tp->hideset = newhideset(trp->tp->hideset, np);			trp->tp += ntokc;			return;		}		substargs(np, &ntr, atr, trp->tp->hideset);	/* put args into replacement */		for (i=0; i<narg; i++) {			dofree(atr[i]->bp);			dofree(atr[i]);		}	} 	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);	free(ntr.bp);}	 /* * 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. */intgatherargs(Tokenrow *trp, Tokenrow **atr, int dots, 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;				if (*narg>=0)					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 (lp->type == COMMA && dots && *narg == dots-1)				continue;			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;}	intispaste(Tokenrow *rtr, Token **ap, Token **an, int *ntok){	*ap = nil;	*an = nil;	/* EMPTY ## tok */	if (rtr->tp->type == DSHARP && rtr->tp != rtr->bp)		rtr->tp--;	/* tok ## tok */	if(rtr->tp + 1 != rtr->lp && rtr->tp[1].type == DSHARP) {		*ap = rtr->tp;		if(rtr->tp + 2 != rtr->lp)			*an = rtr->tp + 2;		*ntok = 1 + (*ap != nil) + (*an != nil);		return 1;	}	return 0;} /* * substitute the argument list into the replacement string *  This would be simple except for ## and # */voidsubstargs(Nlist *np, Tokenrow *rtr, Tokenrow **atr, int hideset){	Tokenrow ttr, rp, rn;	Token *tp, *ap, *an, *pp, *pn;	int ntok, argno, hs; 	for (rtr->tp=rtr->bp; rtr->tp<rtr->lp; ) {		if(rtr->tp->hideset && checkhideset(hideset, np)) {			rtr->tp++;		} else 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]));		} else if (ispaste(rtr, &ap, &an, &ntok)) { /* first token, just do the next one */			pp = ap;			memset(&rp, 0, sizeof(rp));			pn = an;			memset(&rn, 0, sizeof(rp));			if (ap && (argno = lookuparg(np, ap)) >= 0){				pp = nil;				rp = *atr[argno];				if(rp.tp != rp.lp)					pp = --rp.lp;			}			if (an && (argno = lookuparg(np, an)) >= 0) {				pn = nil;				rn = *atr[argno];				if(rn.tp != rn.lp)					pn = rn.bp++;			}			glue(&ttr, pp, pn);			insertrow(rtr, 0, &rp);			insertrow(rtr, ntok, &ttr);			insertrow(rtr, 0, &rn);			free(ttr.bp);		} else if (rtr->tp->type==NAME) {			if((argno = lookuparg(np, rtr->tp)) >= 0) {				if (rtr->tp < rtr->bp) {					error(ERROR, "access out of bounds");					continue;				}				copytokenrow(&ttr, atr[argno]);				expandrow(&ttr, "<macro>");				insertrow(rtr, 1, &ttr);				free(ttr.bp);			} else {				maketokenrow(1, &ttr);				ttr.lp = ttr.tp + 1;				*ttr.tp = *rtr->tp; 				hs = newhideset(rtr->tp->hideset, np);				if(hideset == 0)					ttr.tp->hideset = hs;				else					ttr.tp->hideset = unionhideset(hideset, hs);				expandrow(&ttr, (char*)np->name);				for(tp = ttr.bp; tp != ttr.lp; tp++)					if(tp->type == COMMA)						tp->type = XCOMMA;				insertrow(rtr, 1, &ttr);				dofree(ttr.bp);			}		} else {			rtr->tp++;		}	}} /* * Evaluate the ## operators in a tokenrow */voidglue(Tokenrow *ntr, Token *tp, Token *tn){	int np, nn;	char *tt, *p, *n; 	np = tp ? tp->len : 0;	nn = tn ? tn->len : 0;	tt = domalloc(np + nn + 1);	if(tp)		memcpy(tt, tp->t, tp->len);	if(tn)		memcpy(tt+np, tn->t, tn->len);	tt[np+nn] = '\0';	setsource("<##>", -1, tt);	maketokenrow(3, ntr);	gettokens(ntr, 1);	unsetsource();	dofree(tt);	if (np + nn == 0) {		ntr->lp = ntr->bp;	} else {		if (ntr->lp - ntr->bp!=2 || ntr->bp->type==UNCLASS) {			p = tp ? (char*)tp->t : "<empty>";			n = tn ? (char*)tn->t : "<empty>";			error(WARNING, "Bad token %r produced by %s ## %s", &ntr, p, n);		}		ntr->lp = ntr->bp+1;	}	makespace(ntr);} /* * 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. */intlookuparg(Nlist *mac, Token *tp){	Token *ap; 	if (tp->type!=NAME || mac->ap==NULL)		return -1;	if((mac->flag & ISVARMAC) && strcmp((char*)tp->t, "__VA_ARGS__") == 0)		return rowlen(mac->ap) - 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	512Tokenrow *stringify(Tokenrow *vp){	static Token t = { STRING };	static Tokenrow tr = { &t, &t, &t+1, 1 };

Lines 1–500 of 587. Load more