xref: /onnv-gate/usr/src/lib/libpp/common/ppcontrol.c (revision 10898:1883b621b3ea)

/***********************************************************************
*                                                                      *
*               This software is part of the ast package               *
*          Copyright (c) 1986-2009 AT&T Intellectual Property          *
*                      and is licensed under the                       *
*                  Common Public License, Version 1.0                  *
*                    by AT&T Intellectual Property                     *
*                                                                      *
*                A copy of the License is available at                 *
*            http://www.opensource.org/licenses/cpl1.0.txt             *
*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
*                                                                      *
*              Information and Software Systems Research               *
*                            AT&T Research                             *
*                           Florham Park NJ                            *
*                                                                      *
*                 Glenn Fowler <gsf@research.att.com>                  *
*                                                                      *
***********************************************************************/
#pragma prototyped
/*
 * Glenn Fowler
 * AT&T Research
 *
 * preprocessor control directive support
 */

#include "pplib.h"

#include <regex.h>

#define TOKOP_DUP	(1<<0)
#define TOKOP_STRING	(1<<1)
#define TOKOP_UNSET	(1<<2)

struct edit
{
	struct edit*	next;
	regex_t		re;
};

struct map
{
	struct map*	next;
	regex_t		re;
	struct edit*	edit;
};

#define RESTORE		(COLLECTING|CONDITIONAL|DEFINITION|DIRECTIVE|DISABLE|EOF2NL|HEADER|NOSPACE|NOVERTICAL|PASSEOF|STRIP)

/*
 * common predicate assertion operations
 * op is DEFINE or UNDEF
 */

static void
assert(int op, char* pred, char* args)
{
	register struct pplist*		a;
	register struct ppsymbol*	sym;
	register struct pplist*		p;
	register struct pplist*		q;

	if (!args) switch (op)
	{
	case DEFINE:
		goto mark;
	case UNDEF:
		a = 0;
		goto unmark;
	}
	if (a = (struct pplist*)hashget(pp.prdtab, pred))
	{
		p = 0;
		q = a;
		while (q)
		{
			if (streq(q->value, args))
			{
				if (op == DEFINE) return;
				q = q->next;
				if (p) p->next = q;
				else a = q;
			}
			else
			{
				p = q;
				q = q->next;
			}
		}
		if (op == UNDEF)
		{
		unmark:
			hashput(pp.prdtab, pred, a);
			if (sym = ppsymref(pp.symtab, pred))
				sym->flags &= ~SYM_PREDICATE;
			return;
		}
	}
	if (op == DEFINE)
	{
		p = newof(0, struct pplist, 1, 0);
		p->next = a;
		p->value = strdup(args);
		hashput(pp.prdtab, NiL, p);
	mark:
		if ((pp.state & COMPILE) && pp.truncate) return;
		if (sym = ppsymset(pp.symtab, pred))
			sym->flags |= SYM_PREDICATE;
	}
}

/*
 * tokenize string ppop()
 *
 *	op	PP_* op
 *	name	option name
 *	s	string of option values
 *	n	option sense
 *	flags	TOKOP_* flags
 */

static void
tokop(int op, char* name, register char* s, register int n, int flags)
{
	register int	c;
	register char*	t;

	if (!(flags & TOKOP_UNSET) && !n) error(2, "%s: option cannot be unset", name);
	else if (!s) ppop(op, s, n);
	else if (flags & TOKOP_STRING)
	{
		PUSH_LINE(s);
		for (;;)
		{
			pp.state &= ~NOSPACE;
			c = pplex();
			pp.state |= NOSPACE;
			if (!c) break;
			if (c != ' ')
				ppop(op, (flags & TOKOP_DUP) ? strdup(pp.token) : pp.token, n);
		}
		POP_LINE();
	}
	else do
	{
		while (*s == ' ') s++;
		for (t = s; *t && *t != ' '; t++);
		if (*t) *t++ = 0;
		else t = 0;
		if (*s) ppop(op, (flags & TOKOP_DUP) ? strdup(s) : s, n);
	} while (s = t);
}

/*
 * return symbol pointer for next token macro (re)definition
 */

static struct ppsymbol*
macsym(int tok)
{
	register struct ppsymbol*	sym;

	if (tok != T_ID)
	{
		error(2, "%s: invalid macro name", pptokstr(pp.token, 0));
		return 0;
	}
	sym = pprefmac(pp.token, REF_CREATE);
	if ((sym->flags & SYM_FINAL) && (pp.mode & HOSTED)) return 0;
	if (sym->flags & (SYM_ACTIVE|SYM_READONLY))
	{
		if (!(pp.option & ALLPOSSIBLE))
			error(2, "%s: macro is %s", sym->name, (sym->flags & SYM_READONLY) ? "readonly" : "active");
		return 0;
	}
	if (!sym->macro) sym->macro = newof(0, struct ppmacro, 1, 0);
	return sym;
}

/*
 * get one space canonical pplex() line, sans '\n', and place in p
 * x is max+1 pos in p
 * 0 returned if line too large
 * otherwise end of p ('\0') returned
 */

static char*
getline(register char* p, char* x, int disable)
{
	register int	c;
	register char*	s;
	char*		b;
	long		restore;

	restore = pp.state & (NOSPACE|STRIP);
	pp.state &= ~(NEWLINE|NOSPACE|STRIP);
	pp.state |= EOF2NL;
	b = p;
	while ((c = pplex()) != '\n')
	{
		if (disable)
		{
			if (c == ' ')
				/*ignore*/;
			else if (disable == 1)
				disable = (c == T_ID && streq(pp.token, pp.pass)) ? 2 : 0;
			else
			{
				disable = 0;
				if (c == ':')
					pp.state |= DISABLE;
			}
		}
		s = pp.token;
		while (*p = *s++)
			if (++p >= x)
			{
				p = 0;
				goto done;
			}
	}
	if (p > b && *(p - 1) == ' ')
		p--;
	if (p >= x)
		p = 0;
	else
		*p = 0;
 done:
	pp.state &= ~(NOSPACE|STRIP);
	pp.state |= restore;
	return p;
}

/*
 * regex error handler
 */

void
regfatal(regex_t* p, int level, int code)
{
	char	buf[128];

	regerror(code, p, buf, sizeof(buf));
	regfree(p);
	error(level, "regular expression: %s", buf);
}

/*
 * process a single directive line
 */

int
ppcontrol(void)
{
	register char*			p;
	register int			c;
	register int			n;
	register char*			s;
	register struct ppmacro*	mac;
	register struct ppsymbol*	sym;
	struct edit*			edit;
	struct map*			map;
	struct ppfile*			fp;
	int				o;
	int				directive;
	long				restore;
	struct pptuple*			rp;
	struct pptuple*			tp;
	char*				v;
	int				emitted;

	union
	{
		struct map*		best;
		struct ppinstk*		inp;
		struct pplist*		list;
		char*			string;
		struct ppsymbol*	symbol;
		int			type;
		PPLINESYNC		linesync;
	}				var;

	static char			__va_args__[] = "__VA_ARGS__";
	static int			i0;
	static int			i1;
	static int			i2;
	static int			i3;
	static int			i4;

	static long			n1;
	static long			n2;
	static long			n3;

	static char*			p0;
	static char*			p1;
	static char*			p2;
	static char*			p3;
	static char*			p4;
	static char*			p5;
	static char*			p6;

	static struct ppmacro		old;
	static char*			formargs[MAXFORMALS];
#if MACKEYARGS
	static char*			formvals[MAXFORMALS];
#endif

	emitted = 0;
	if (pp.state & SKIPCONTROL) pp.level--;
	restore = (pp.state & RESTORE)|NEWLINE;
	if (pp.state & PASSTHROUGH) restore |= DISABLE;
	else restore &= ~DISABLE;
	pp.state &= ~(NEWLINE|RESTORE|SKIPCONTROL);
	pp.state |= DIRECTIVE|DISABLE|EOF2NL|NOSPACE|NOVERTICAL;
#if COMPATIBLE
	if ((pp.state & (COMPATIBILITY|STRICT)) == COMPATIBILITY || (pp.mode & HOSTED)) pp.state &= ~NOVERTICAL;
#else
	if (pp.mode & HOSTED) pp.state &= ~NOVERTICAL;
#endif
	switch (c = pplex())
	{
	case T_DECIMAL:
	case T_OCTAL:
		if ((pp.state & STRICT) && !(pp.mode & (HOSTED|RELAX)))
			error(1, "# <line> [ \"<file>\" [ <type> ] ]: non-standard directive");
		directive = INCLUDE;
		goto linesync;
	case T_ID:
		switch (directive = (int)hashref(pp.dirtab, pp.token))
		{
		case ELIF:
		else_if:
			if ((pp.option & ALLPOSSIBLE) && !pp.in->prev->prev)
				goto eatdirective;
			if (pp.control <= pp.in->control)
			{
				error(2, "no matching #%s for #%s", dirname(IF), dirname(ELIF));
				goto eatdirective;
			}
			if (pp.control == (pp.in->control + 1)) pp.in->flags |= IN_noguard;
			if (*pp.control & HADELSE)
			{
				error(2, "invalid #%s after #%s", dirname(ELIF), dirname(ELSE));
				*pp.control |= SKIP;
				goto eatdirective;
			}
			if (*pp.control & KEPT)
			{
				*pp.control |= SKIP;
				goto eatdirective;
			}
			if (directive == IFDEF || directive == IFNDEF)
			{
				*pp.control &= ~SKIP;
				goto else_ifdef;
			}
		conditional:
			if (ppexpr(&i1))
			{
				*pp.control &= ~SKIP;
				*pp.control |= KEPT;
			}
			else *pp.control |= SKIP;
			c = (pp.state & NEWLINE) ? '\n' : ' ';
			goto eatdirective;
		case ELSE:
			if ((pp.option & ALLPOSSIBLE) && !pp.in->prev->prev)
				goto eatdirective;
			if ((pp.option & ELSEIF) && (c = pplex()) == T_ID && ((n = (int)hashref(pp.dirtab, pp.token)) == IF || n == IFDEF || n == IFNDEF))
			{
				error(1, "#%s %s is non-standard -- use #%s", dirname(directive), dirname(n), dirname(ELIF));
				directive = n;
				goto else_if;
			}
			if (pp.control <= pp.in->control) error(2, "no matching #%s for #%s", dirname(IF), dirname(ELSE));
			else
			{
				if (pp.control == (pp.in->control + 1)) pp.in->flags |= IN_noguard;
				if (!(*pp.control & KEPT))
				{
					*pp.control &= ~SKIP;
					*pp.control |= HADELSE|KEPT;
				}
				else
				{
					if (*pp.control & HADELSE) error(2, "more than one #%s for #%s", dirname(ELSE), dirname(IF));
					*pp.control |= HADELSE|SKIP;
				}
			}
			goto enddirective;
		case ENDIF:
			if ((pp.option & ALLPOSSIBLE) && !pp.in->prev->prev)
				goto eatdirective;
			if (pp.control <= pp.in->control) error(2, "no matching #%s for #%s", dirname(IF), dirname(ENDIF));
			else if (--pp.control == pp.in->control && pp.in->symbol)
			{
				if (pp.in->flags & IN_endguard) pp.in->flags |= IN_noguard;
				else
				{
					pp.in->flags &= ~IN_tokens;
					pp.in->flags |= IN_endguard;
				}
			}
			goto enddirective;
		case IF:
		case IFDEF:
		case IFNDEF:
			if ((pp.option & ALLPOSSIBLE) && !pp.in->prev->prev)
				goto eatdirective;
			pushcontrol();
			SETIFBLOCK(pp.control);
			if (*pp.control & SKIP)
			{
				*pp.control |= KEPT;
				goto eatdirective;
			}
			if (directive == IF) goto conditional;
		else_ifdef:
			if ((c = pplex()) == T_ID)
			{
				sym = pprefmac(pp.token, REF_IF);
				if (directive == IFNDEF && pp.control == pp.in->control + 1)
				{
					if (pp.in->flags & (IN_defguard|IN_endguard))
						pp.in->flags |= IN_noguard;
					else
					{
						pp.in->flags |= IN_defguard;
						if (!(pp.in->flags & IN_tokens))
							pp.in->symbol = sym ? sym : pprefmac(pp.token, REF_CREATE);
					}
				}
			}
			else
			{
				sym = 0;
				if (!(pp.mode & HOSTED))
					error(1, "%s: invalid macro name", pptokstr(pp.token, 0));
			}
			*pp.control |= ((sym != 0) == (directive == IFDEF)) ? KEPT : SKIP;
			goto enddirective;
		case INCLUDE:
			if (*pp.control & SKIP)
			{
				pp.state |= HEADER;
				c = pplex();
				pp.state &= ~HEADER;
				goto eatdirective;
			}
			pp.state &= ~DISABLE;
			pp.state |= HEADER|STRIP;
			pp.in->flags |= IN_noguard;
			switch (c = pplex())
			{
			case T_STRING:
				p = pp.token;
				do pp.token = pp.toknxt; while ((c = pplex()) == T_STRING);
				*pp.token = 0;
				pp.token = p;
				/*FALLTHROUGH*/
			case T_HEADER:
			header:
				if (!*pp.token)
				{
					error(2, "#%s: null file name", dirname(INCLUDE));
					break;
				}
				if (*pp.token == '/' && !(pp.mode & (HOSTED|RELAX)))
					error(1, "#%s: reference to %s is not portable", dirname(INCLUDE), pp.token);
				n = ppsearch(pp.token, c, SEARCH_INCLUDE);
				break;
			case '<':
				/*
				 * HEADEREXPAND|HEADEREXPANDALL gets us here
				 */

				if (!(p = pp.hdrbuf) && !(p = pp.hdrbuf = newof(0, char, MAXTOKEN, 0)))
					error(3, "out of space");
				pp.state &= ~NOSPACE;
				while ((c = pplex()) && c != '>')
				{
					v = p + 1;
					STRCOPY(p, pp.token, s);
					if (p == v && *(p - 1) == ' ' && pp.in->type != IN_MACRO)
						p--;
				}
				pp.state |= NOSPACE;
				*p++ = 0;
				memcpy(pp.token, pp.hdrbuf, p - pp.hdrbuf);
				c = T_HEADER;
				goto header;
			default:
				error(2, "#%s: \"...\" or <...> argument expected", dirname(INCLUDE));
				goto eatdirective;
			}
			goto enddirective;
		case 0:
			{
				regmatch_t	match[10];

				/*UNDENT*/
	p = pp.valbuf;
	*p++ = '#';
	STRCOPY(p, pp.token, s);
	p0 = p;
	pp.mode |= EXPOSE;
	pp.state |= HEADER;
	p6 = getline(p, &pp.valbuf[MAXTOKEN], 0);
	pp.state &= ~HEADER;
	pp.mode &= ~EXPOSE;
	if (!p6)
	{
		*p0 = 0;
		error(2, "%s: directive too long", pp.valbuf);
		c = 0;
		goto eatdirective;
	}
	p1 = p2 = p3 = p4 = 0;
	p5 = *p ? p + 1 : 0;
 checkmap:
	i0 = *p0;
	p = pp.valbuf;
	var.best = 0;
	n = 0;
	for (map = (struct map*)pp.maps; map; map = map->next)
		if (!(i1 = regexec(&map->re, p, elementsof(match), match, 0)))
		{
			if ((c = match[0].rm_eo - match[0].rm_so) > n)
			{
				n = c;
				var.best = map;
			}
		}
		else if (i1 != REG_NOMATCH)
			regfatal(&map->re, 3, i1);
	c = '\n';
	if (map = var.best)
	{
		if ((pp.state & (STRICT|WARN)) && !(pp.mode & (HOSTED|RELAX)))
		{
			*p0 = 0;
			if (!(pp.state & WARN) || strcmp(p + 1, dirname(PRAGMA)))
				error(1, "%s: non-standard directive", p);
			*p0 = i0;
		}
		if (!(*pp.control & SKIP))
		{
			n = 0;
			for (edit = map->edit; edit; edit = edit->next)
				if (!(i0 = regexec(&edit->re, p, elementsof(match), match, 0)))
				{
					n++;
					if (i0 = regsubexec(&edit->re, p, elementsof(match), match))
						regfatal(&edit->re, 3, i0);
					p = edit->re.re_sub->re_buf;
					if (edit->re.re_sub->re_flags & REG_SUB_STOP)
						break;
				}
				else if (i0 != REG_NOMATCH)
					regfatal(&edit->re, 3, i0);
			if (n && *p)
			{
				p1 = s = oldof(0, char, 0, strlen(p) + 32);
				while (*s = *p++) s++;
				debug((-4, "map: %s", p1));
				*s++ = '\n';
				*s = 0;
				error_info.line++;
				PUSH_RESCAN(p1);
				error_info.line--;
				directive = LINE;
			}
		}
		goto donedirective;
	}
	if (directive != PRAGMA && (!(*pp.control & SKIP) || !(pp.mode & (HOSTED|RELAX))))
	{
		*p0 = 0;
		error(1, "%s: unknown directive", pptokstr(pp.valbuf, 0));
		*p0 = i0;
	}
 pass:
	if (!(*pp.control & SKIP) && pp.pragma && !(pp.state & NOTEXT) && (directive == PRAGMA || !(pp.mode & INIT)))
	{
		*p0 = 0;
		if (p2) *p2 = 0;
		if (p4)
		{
			if (p4 == p5)
			{
				p5 = strcpy(pp.tmpbuf, p5);
				if (p = strchr(p5, MARK))
				{
					s = p;
					while (*p)
						if ((*s++ = *p++) == MARK && *p == MARK) p++;
					*s = 0;
				}
			}
			*p4 = 0;
		}
		if (p = (char*)memchr(pp.valbuf + 1, MARK, p6 - pp.valbuf - 1))
		{
			s = p;
			while (p < p6) switch (*s++ = *p++)
			{
			case 0:
				s = p;
				break;
			case MARK:
				p++;
				break;
			}
			*s = 0;
		}
		(*pp.pragma)(pp.valbuf + 1, p1, p3, p5, (pp.state & COMPILE) || (pp.mode & INIT) != 0);
		emitted = 1;
	}
	goto donedirective;

				/*INDENT*/
			}
		}
		if (*pp.control & SKIP) goto eatdirective;
		switch (directive)
		{
#if MACDEF
		case ENDMAC:
			c = pplex();
			error(2, "no matching #%s for #%s", dirname(MACDEF), dirname(ENDMAC));
			goto enddirective;
#endif
#if MACDEF
		case MACDEF:
			if ((pp.state & STRICT) && !(pp.mode & (HOSTED|RELAX)))
				error(1, "#%s: non-standard directive", pp.token);
			/*FALLTHROUGH*/
#endif
		case DEFINE:
			n2 = error_info.line;
			if ((c = pplex()) == '#' && directive == DEFINE)
				goto assertion;
			if (c == '<')
			{
				n = 1;
				c = pplex();
			}
			else
				n = 0;
			if (!(sym = macsym(c)))
				goto eatdirective;
			if (pp.truncate)
				ppfsm(FSM_MACRO, pp.token);
			mac = sym->macro;
			if ((pp.option & ALLPOSSIBLE) && !pp.in->prev->prev && mac->value)
				goto eatdirective;
			if (n)
				goto tuple;
			old = *mac;
			i0 = sym->flags;
			sym->flags &= ~(SYM_BUILTIN|SYM_EMPTY|SYM_FINAL|SYM_FUNCTION|SYM_INIT|SYM_INITIAL|SYM_MULTILINE|SYM_NOEXPAND|SYM_PREDEFINED|SYM_REDEFINE|SYM_VARIADIC);
#if MACDEF
			if (directive == MACDEF)
				sym->flags |= SYM_MULTILINE;
#endif
			mac->arity = 0;
			mac->formals = 0;
			mac->value = 0;
			pp.state &= ~NOSPACE;
			pp.state |= DEFINITION|NOEXPAND;
			switch (c = pplex())
			{
			case '(':
				sym->flags |= SYM_FUNCTION;
				pp.state |= NOSPACE;
#if MACKEYARGS
				if (pp.option & KEYARGS)
				{
					n = 2 * MAXTOKEN;
					p = mac->formals = oldof(0, char, 0, n);
					if ((c = pplex()) == T_ID) for (;;)
					{
						if (mac->arity < MAXFORMALS)
						{
							if (mac->arity) p++;
							formargs[mac->arity] = p;
							STRAPP(p, pp.token, s);
							formvals[mac->arity++] = p1 = p;
							if (mac->arity == 1) *p++ = ' ';
							*p++ = ' ';
							*p = 0;
						}
						else error(2, "%s: formal argument %s ignored", sym->name, pp.token);
						switch (c = pplex())
						{
						case '=':
							c = pplex();
							break;
						case ',':
							break;
						default:
							goto endformals;
						}
						pp.state &= ~NOSPACE;
						p0 = 0;
						for (;;)
						{
							switch (c)
							{
							case '\n':
								goto endformals;
							case '(':
								p0++;
								break;
							case ')':
								if (!p0--)
								{
									if (p > formvals[mac->arity - 1] && *(p - 1) == ' ') *--p = 0;
									goto endformals;
								}
								break;
							case ',':
								if (!p0)
								{
									if (p > formvals[mac->arity - 1] && *(p - 1) == ' ') *--p = 0;
									goto nextformal;
								}
								break;
							case ' ':
								if (p > formvals[mac->arity - 1] && *(p - 1) == ' ') continue;
								break;
							}
							STRCOPY(p, pp.token, s);
							if (p > &mac->formals[n - MAXTOKEN] && (s = newof(mac->formals, char, n += MAXTOKEN, 0)) != mac->formals)
							{
								n1 = s - mac->formals;
								for (n = 0; n < mac->arity; n++)
								{
									formargs[n] += n1;
									formvals[n] += n1;
								}
								c = p - mac->formals;
								mac->formals = s;
								p = mac->formals + c;
							}
							c = pplex();
						}
					nextformal:
						pp.state |= NOSPACE;
						if ((c = pplex()) != T_ID)
						{
							c = ',';
							break;
						}
					}
				endformals: /*NOP*/;
				}
				else
#endif
				{
					p = mac->formals = oldof(0, char, 0, MAXFORMALS * (MAXID + 1));
					c = pplex();
#if COMPATIBLE
					if ((pp.state & COMPATIBILITY) && c == ',')
					{
						if ((pp.state & WARN) && !(pp.mode & HOSTED))
							error(1, "%s: macro formal argument expected", sym->name);
						while ((c = pplex()) == ',');
					}
#endif
					for (;;)
					{
						if (c == T_VARIADIC)
						{
							if (sym->flags & SYM_VARIADIC)
								error(2, "%s: %s: duplicate macro formal argument", sym->name, pp.token);
							sym->flags |= SYM_VARIADIC;
							v = __va_args__;
						}
						else if (c == T_ID)
						{
							v = pp.token;
							if (sym->flags & SYM_VARIADIC)
								error(2, "%s: %s: macro formal argument cannot follow ...", sym->name, v);
							else if (streq(v, __va_args__))
								error(2, "%s: %s: invalid macro formal argument", sym->name, v);
						}
						else
							break;
						if (mac->arity < MAXFORMALS)
						{
							for (n = 0; n < mac->arity; n++)
								if (streq(formargs[n], v))
									error(2, "%s: %s: duplicate macro formal argument", sym->name, v);
							formargs[mac->arity++] = p;
							STRAPP(p, v, s);
						}
						else
							error(2, "%s: %s: macro formal argument ignored", sym->name, v);
						if ((c = pplex()) == ',')
						{
							c = pplex();
#if COMPATIBLE
							if ((pp.state & COMPATIBILITY) && c == ',')
							{
								if ((pp.state & WARN) && !(pp.mode & HOSTED))
									error(1, "%s: macro formal argument expected", sym->name);
								while ((c = pplex()) == ',');
							}
#endif
						}
						else if (c != T_VARIADIC)
							break;
						else
						{
							if (sym->flags & SYM_VARIADIC)
								error(2, "%s: %s: duplicate macro formal argument", sym->name, pp.token);
							sym->flags |= SYM_VARIADIC;
							c = pplex();
							break;
						}
					}
					if (mac->arity && (s = newof(mac->formals, char, p - mac->formals, 0)) != mac->formals)
					{
						n1 = s - mac->formals;
						for (n = 0; n < mac->arity; n++)
							formargs[n] += n1;
						mac->formals = s;
					}
				}
				if (!mac->arity)
				{
					free(mac->formals);
					mac->formals = 0;
				}
				switch (c)
				{
				case ')':
#if MACKEYARGS
					pp.state |= NOEXPAND|NOSPACE;
#else
					pp.state |= NOEXPAND;
#endif
					c = pplex();
					break;
				default:
					error(2, "%s: invalid macro formal argument list", sym->name);
					if (mac->formals)
					{
						free(mac->formals);
						mac->formals = 0;
						mac->arity = 0;
					}
					free(mac);
					sym->macro = 0;
					goto eatdirective;
				}
				pp.state &= ~NOSPACE;
				break;
			case ' ':
			case '\t':
				c = pplex();
				break;
			}
			n = 2 * MAXTOKEN;
#if MACKEYARGS
			p1 = p;
#endif
			p = mac->value = oldof(0, char, 0, n);
			var.type = 0;
			n1 = 0;
#if MACDEF
			i2 = i3 = 0;
			n3 = pp.state;
#endif
			if ((pp.option & PLUSPLUS) && (pp.state & (COMPATIBILITY|TRANSITION)) != COMPATIBILITY)
				switch (c)
				{
				case '+':
				case '-':
				case '&':
				case '|':
				case '<':
				case '>':
				case ':':
				case '=':
					*p++ = ' ';
					break;
				}
			o = 0;
			for (;;)
			{
				switch (c)
				{
				case T_ID:
					for (c = 0; c < mac->arity; c++)
						if (streq(formargs[c], pp.token))
						{
#if COMPATIBLE
							if (!(pp.state & COMPATIBILITY))
#endif
							if (var.type != TOK_TOKCAT && p > mac->value && *(p - 1) != ' ' && !(pp.option & PRESERVE)) *p++ = ' ';
							*p++ = MARK;
#if COMPATIBLE
							if ((pp.state & (COMPATIBILITY|TRANSITION)) == COMPATIBILITY) *p++ = 'C';
							else
#endif
							*p++ = (n1 || var.type == TOK_TOKCAT) ? 'C' : 'A';
							*p++ = c + ARGOFFSET;
							if ((pp.state & WARN) && !(pp.mode & (HOSTED|RELAX)) && var.type != TOK_TOKCAT && !(var.type & TOK_ID))
							{
								s = pp.in->nextchr;
								while ((c = *s++) && (c == ' ' || c == '\t'));
								if (c == '\n')
									c = 0;
								else if (c == '*' && *s == ')')
									c = ')';
								else if (c == '=' || ppisidig(c) || c == *s || *s == '=')
									c = 0;
								if (o != '.' && o != T_PTRMEM)
								{
									if ((var.type & TOK_ID) || o == ' ' || ppisseparate(o))
										o = 0;
									if (!((o == 0 || o == '(' || o == ')' || o == '[' || o == ']' || o == ',' || o == '|' || o == ';' || o == '{' || o == '}') && (c == '(' || c == ')' || c == '[' || c == ']' || c == ',' || c == '|' || c == ';' || c == '}' || c == 0)) && !(o == '*' && c == ')'))
										error(1, "%s: %s: formal should be parenthesized in macro value (t=%x o=%#c c=%#c)", sym->name, pp.token, var.type, o, c);
								}
							}
							var.type = TOK_FORMAL|TOK_ID;
							c = '>';
							goto checkvalue;
						}
					if (var.type == TOK_BUILTIN) switch ((int)hashget(pp.strtab, pp.token))
					{
					case V_DEFAULT:
					case V_EMPTY:
						sym->flags |= SYM_EMPTY;
						break;
					}
					else if (pp.hiding && (var.symbol = ppsymref(pp.symtab, pp.token)) && var.symbol->hidden)
					{
						for (var.inp = pp.in; var.inp->type != IN_FILE && var.inp->prev; var.inp = var.inp->prev);
						p += sfsprintf(p, MAXTOKEN, "_%d_%s_hIDe", var.inp->hide, pp.token);
						var.type = TOK_ID;
						goto checkvalue;
					}
					var.type = TOK_ID;
					break;
				case '#':
					var.type = 0;
#if MACDEF
					if (!(sym->flags & (SYM_FUNCTION|SYM_MULTILINE))) break;
#else
					if (!(sym->flags & SYM_FUNCTION)) break;
#endif
					pp.state |= NOSPACE;
					c = pplex();
					if (c == '@')
					{
						c = pplex();
						i4 = 'S';
					}
					else i4 = 'Q';
					pp.state &= ~NOSPACE;
					if (c != T_ID) c = mac->arity;
					else for (c = 0; c < mac->arity; c++)
						if (streq(formargs[c], pp.token))
							break;
					if (c >= mac->arity)
					{
#if MACDEF
						if (sym->flags & SYM_MULTILINE)
						{
							if (n3 & NEWLINE)
							{
								pp.state &= ~NOEXPAND;
								switch ((int)hashref(pp.dirtab, pp.token))
								{
								case ENDMAC:
									if (!i2--) goto gotdefinition;
									break;
								case INCLUDE:
									/* PARSE HEADER constant */
									break;
								case MACDEF:
									i2++;
									break;
								}
								*p++ = '#';
							}
						}
						else
#endif
#if COMPATIBLE
						if (pp.state & COMPATIBILITY) *p++ = '#';
						else
#endif
						error(2, "# must precede a formal parameter");
					}
					else
					{
						if (p > mac->value && ppisidig(*(p - 1)) && !(pp.option & PRESERVE)) *p++ = ' ';
						*p++ = MARK;
						*p++ = i4;
						*p++ = c + ARGOFFSET;
						goto checkvalue;
					}
					break;
				case T_TOKCAT:
					if (p <= mac->value) error(2, "%s lhs operand omitted", pp.token);
					else
					{
						if (*(p - 1) == ' ') p--;
						if (var.type == (TOK_FORMAL|TOK_ID)) *(p - 2) = 'C';
					}
					pp.state |= NOSPACE;
					c = pplex();
					pp.state &= ~NOSPACE;
					if (c == '\n') error(2, "%s rhs operand omitted", pptokchr(T_TOKCAT));
					var.type = TOK_TOKCAT;
					continue;
				case '(':
					if (*pp.token == '#')
					{
						var.type = TOK_BUILTIN;
						n1++;
					}
					else
					{
						var.type = 0;
						if (n1) n1++;
					}
					break;
				case ')':
					var.type = 0;
					if (n1) n1--;
					break;
				case T_STRING:
				case T_CHARCONST:
					pp.state &= ~NOEXPAND;
					var.type = 0;
					if (strchr(pp.token, MARK)) pp.state &= ~NOEXPAND;
#if COMPATIBLE
					/*UNDENT*/

	if ((sym->flags & SYM_FUNCTION) && (pp.state & (COMPATIBILITY|TRANSITION)))
	{
		char*	v;

		s = pp.token;
		for (;;)
		{
			if (!*s) goto checkvalue;
			if (ppisid(*s))
			{
				v = s;
				while (ppisid(*++s));
				i1 = *s;
				*s = 0;
				for (c = 0; c < mac->arity; c++)
					if (streq(formargs[c], v))
					{
						*p++ = MARK;
						*p++ = 'C';
						*p++ = c + ARGOFFSET;
						if (!(pp.mode & HOSTED) && (!(pp.state & COMPATIBILITY) || (pp.state & WARN))) switch (*pp.token)
						{
						case '"':
							error(1, "use the # operator to \"...\" quote macro arguments");
							break;
						case '\'':
							error(1, "macro arguments should be '...' quoted before substitution");
							break;
						}
						goto quotearg;
					}
				STRCOPY2(p, v);
			quotearg:
				*s = i1;
			}
			else *p++ = *s++;
		}
	}
					/*INDENT*/
#endif
					break;
				case '\n':
#if MACDEF
					if (sym->flags & SYM_MULTILINE)
					{
						if (pp.state & EOF2NL)
						{
							error_info.line++;
							pp.state |= HIDDEN;
							pp.hidden++;
							var.type = 0;
							if (!i3++)
								goto checkvalue;
							break;
						}
						pp.state |= EOF2NL;
						error(2, "%s: missing #%s", sym->name, dirname(ENDMAC));
					}
#endif
					goto gotdefinition;
				case 0:
					c = '\n';
					goto gotdefinition;
#if COMPATIBLE
				case ' ':
					if (pp.state & COMPATIBILITY) var.type = 0;
					if (pp.option & PRESERVE) break;
					if (p > mac->value && *(p - 1) != ' ') *p++ = ' ';
					goto checkvalue;
				case '\t':
					if (var.type & TOK_ID)
					{
						while ((c = pplex()) == '\t');
						if (c == T_ID)
						{
							if (var.type == (TOK_FORMAL|TOK_ID)) *(p - 2) = 'C';
							var.type = TOK_TOKCAT;
							if (pp.state & WARN) error(1, "use the ## operator to concatenate macro arguments");
						}
						else var.type = 0;
						continue;
					}
					var.type = 0;
					if (pp.option & PRESERVE) break;
					if (p > mac->value && *(p - 1) != ' ') *p++ = ' ';
					goto checkvalue;
#endif
				case MARK:
					pp.state &= ~NOEXPAND;
					/*FALLTHROUGH*/

				default:
					var.type = 0;
					break;
				}
				STRCOPY(p, pp.token, s);
			checkvalue:
				o = c;
				if (p > &mac->value[n - MAXTOKEN] && (s = newof(mac->value, char, n += MAXTOKEN, 0)) != mac->value)
				{
					c = p - mac->value;
					mac->value = s;
					p = mac->value + c;
				}
#if MACDEF
				n3 = pp.state;
#endif
				c = pplex();
			}
		gotdefinition:
			while (p > mac->value && *(p - 1) == ' ') p--;
			if (p > mac->value && (pp.option & PLUSPLUS) && (pp.state & (COMPATIBILITY|TRANSITION)) != COMPATIBILITY)
				switch (o)
				{
				case '+':
				case '-':
				case '&':
				case '|':
				case '<':
				case '>':
				case ':':
				case '=':
					*p++ = ' ';
					break;
				}
			*p = 0;
#if MACKEYARGS
			if (!mac->arity) /* ok */;
			else if (pp.option & KEYARGS)
			{
				p0 = mac->formals;
				mac->formkeys = newof(0, struct ppkeyarg, n, p1 - p0 + 1);
				s = (char*)&mac->formkeys[mac->arity];
				(void)memcpy(s, p0, p1 - p0 + 1);
				free(p0);
				for (n = 0; n < mac->arity; n++)
				{
					mac->formkeys[n].name = s + (formargs[n] - p0);
					mac->formkeys[n].value = s + (formvals[n] - p0);
				}
			}
			else
#endif
			for (n = 1; n < mac->arity; n++)
				*(formargs[n] - 1) = ',';
			if (old.value)
			{
				if ((i0 & SYM_FUNCTION) != (sym->flags & SYM_FUNCTION) || old.arity != mac->arity || !streq(old.value, mac->value)) goto redefined;
				if (!old.formals)
				{
					if (mac->formals) goto redefined;
				}
				else if (mac->formals)
				{
#if MACKEYARGS
					if (pp.option & KEYARGS)
					{
						for (n = 0; n < mac->arity; n++)
							if (!streq(mac->formkeys[n].name, old.formkeys[n].name) || !streq(mac->formkeys[n].value, old.formkeys[n].value))
								goto redefined;
					}
					else
#endif
					if (!streq(mac->formals, old.formals)) goto redefined;
				}
#if MACKEYARGS
				if (pp.option & KEYARGS)
				{
					if (mac->formkeys) free(mac->formkeys);
					mac->formkeys = old.formkeys;
				}
				else
#endif
				{
					if (mac->formals) free(mac->formals);
					mac->formals = old.formals;
				}
				free(mac->value);
				mac->value = old.value;
				goto benign;
			redefined:
				if (!(pp.mode & HOSTED) || !(i0 & SYM_INITIAL))
					error(1, "%s redefined", sym->name);
#if MACKEYARGS
				if ((pp.option & KEYARGS) && mac->formkeys)
					free(mac->formkeys);
#endif
#if MACKEYARGS
				if (!(pp.option & KEYARGS))
#endif
				if (old.formals) free(old.formals);
				free(old.value);
			}
			else if (!pp.truncate) ppfsm(FSM_MACRO, sym->name);
			mac->value = newof(mac->value, char, (mac->size = p - mac->value) + 1, 0);
			if ((pp.option & (DEFINITIONS|PREDEFINITIONS|REGUARD)) && !sym->hidden && !(sym->flags & SYM_MULTILINE) && ((pp.option & PREDEFINITIONS) || !(pp.mode & INIT)) && ((pp.option & (DEFINITIONS|PREDEFINITIONS)) || !(pp.state & NOTEXT)))
			{
				ppsync();
				ppprintf("#%s %s", dirname(DEFINE), sym->name);
				if (sym->flags & SYM_FUNCTION)
				{
					ppputchar('(');
					if (mac->formals)
						ppprintf("%s", mac->formals);
					ppputchar(')');
				}
				if ((p = mac->value) && *p)
				{
					ppputchar(' ');
					i0 = 0;
					while (n = *p++)
					{
						if (n != MARK || (n = *p++) == MARK)
						{
							ppputchar(n);
							i0 = ppisid(n);
						}
						else
						{
							if (n == 'Q')
								ppputchar('#');
							else if (i0)
							{
								ppputchar('#');
								ppputchar('#');
							}
							s = formargs[*p++ - ARGOFFSET];
							while ((n = *s++) && n != ',')
								ppputchar(n);
							if (ppisid(*p) || *p == MARK)
							{
								ppputchar('#');
								ppputchar('#');
							}
							i0 = 0;
						}
						ppcheckout();
					}
				}
				emitted = 1;
			}
		benign:
			if (pp.mode & BUILTIN) sym->flags |= SYM_BUILTIN;
			if (pp.option & FINAL) sym->flags |= SYM_FINAL;
			if (pp.mode & INIT) sym->flags |= SYM_INIT;
			if (pp.option & INITIAL) sym->flags |= SYM_INITIAL;
			if (pp.state & NOEXPAND)  sym->flags |= SYM_NOEXPAND;
			if (pp.option & PREDEFINED) sym->flags |= SYM_PREDEFINED;
			if (pp.mode & READONLY) sym->flags |= SYM_READONLY;
			if (pp.macref) (*pp.macref)(sym, error_info.file, n2, mac ? error_info.line - n2 + 1 : REF_UNDEF, mac ? strsum(mac->value, (long)mac->arity) : 0L);
			break;
		assertion:
			c = pplex();
			if ((pp.state & STRICT) && !(pp.mode & (HOSTED|RELAX)))
				error(1, "#%s #%s: assertions are non-standard", dirname(directive), pptokstr(pp.token, 0));
			if (c != T_ID)
			{
				error(2, "%s: invalid predicate name", pptokstr(pp.token, 0));
				goto eatdirective;
			}
			switch ((int)hashref(pp.strtab, pp.token))
			{
			case X_DEFINED:
			case X_EXISTS:
			case X_STRCMP:
				error(2, "%s is a builtin predicate", pp.token);
				goto eatdirective;
			case X_SIZEOF:
				error(2, "%s cannot be a predicate", pp.token);
				goto eatdirective;
			}
			strcpy(pp.tmpbuf, pp.token);
			switch (pppredargs())
			{
			case T_ID:
			case T_STRING:
				assert(directive, pp.tmpbuf, pp.args);
				break;
			case 0:
				assert(directive, pp.tmpbuf, NiL);
				break;
			default:
				error(2, "invalid predicate argument list");
				goto eatdirective;
			}
			break;
		tuple:
			pp.state |= DEFINITION|NOEXPAND|NOSPACE;
			rp = 0;
			tp = mac->tuple;
			if (!tp && !mac->value)
				ppfsm(FSM_MACRO, sym->name);
			while ((c = pplex()) && c != '>' && c != '\n')
			{
				for (; tp; tp = tp->nomatch)
					if (streq(tp->token, pp.token))
						break;
				if (!tp)
				{
					if (!(tp = newof(0, struct pptuple, 1, strlen(pp.token))))
						error(3, "out of space");
					strcpy(tp->token, pp.token);
					if (rp)
					{
						tp->nomatch = rp;
						rp->nomatch = tp;
					}
					else
					{
						tp->nomatch = mac->tuple;
						mac->tuple = tp;
					}
				}
				rp = tp;
				tp = tp->match;
			}
			pp.state &= ~NOSPACE;
			if (!rp || c != '>')
				error(2, "%s: > omitted in tuple macro definition", sym->name);
			else
			{
				n = 2 * MAXTOKEN;
				p = v = oldof(0, char, 0, n);
				while ((c = pplex()) && c != '\n')
					if (p > v || c != ' ')
					{
						STRCOPY(p, pp.token, s);
						if (p > &v[n - MAXTOKEN] && (s = newof(v, char, n += MAXTOKEN, 0)) != v)
						{
							c = p - v;
							v = s;
							p = v + c;
						}
					}
				while (p > v && *(p - 1) == ' ')
					p--;
				n = p - v;
				tp = newof(0, struct pptuple, 1, n);
				strcpy(tp->token, v);
				tp->match = rp->match;
				rp->match = tp;
			}
			goto benign;
		case WARNING:
			if ((pp.state & STRICT) && !(pp.mode & (HOSTED|RELAX)))
				error(1, "#%s: non-standard directive", pp.token);
			/*FALLTHROUGH*/
		case ERROR:
			pp.state &= ~DISABLE;
			p = pp.tmpbuf;
			while ((c = pplex()) != '\n')
				if (p + strlen(pp.token) < &pp.tmpbuf[MAXTOKEN])
				{
					STRCOPY(p, pp.token, s);
					pp.state &= ~NOSPACE;
				}
			*p = 0;
			p = *pp.tmpbuf ? pp.tmpbuf : ((directive == WARNING) ? "user warning" : "user error");
			n = (directive == WARNING) ? 1 : 3;
			error(n, "%s", p);
			break;
		case LET:
			n2 = error_info.line;
			if ((pp.state & STRICT) && !(pp.mode & (HOSTED|RELAX)))
				error(1, "#%s: non-standard directive", pp.token);
			if (!(sym = macsym(c = pplex()))) goto eatdirective;
			if ((c = pplex()) != '=')
			{
				error(2, "%s: = expected", sym->name);
				goto eatdirective;
			}
			sym->flags &= ~(SYM_BUILTIN|SYM_FUNCTION|SYM_MULTILINE|SYM_PREDEFINED|SYM_VARIADIC);
			mac = sym->macro;
			mac->arity = 0;
			if (mac->value)
			{
				if (!(sym->flags & SYM_REDEFINE) && !sym->hidden)
					error(1, "%s: redefined", sym->name);
#if MACKEYARGS
				if ((pp.option & KEYARGS) && mac->formkeys) free(mac->formkeys);
				else
#endif
				free(mac->formals);
				mac->formals = 0;
				n = strlen(mac->value) + 1;
			}
			else
			{
				ppfsm(FSM_MACRO, sym->name);
				n = 0;
			}
			n1 = ppexpr(&i1);
			if (i1) c = sfsprintf(pp.tmpbuf, MAXTOKEN, "%luU", n1);
			else c = sfsprintf(pp.tmpbuf, MAXTOKEN, "%ld", n1);
			if (n < ++c)
			{
				if (mac->value) free(mac->value);
				mac->value = oldof(0, char, 0, c);
			}
			strcpy(mac->value, pp.tmpbuf);
			sym->flags |= SYM_REDEFINE;
			c = (pp.state & NEWLINE) ? '\n' : ' ';
			goto benign;
		case LINE:
			pp.state &= ~DISABLE;
			if ((c = pplex()) == '#')
			{
				c = pplex();
				directive = INCLUDE;
			}
			if (c != T_DECIMAL && c != T_OCTAL)
			{
				error(1, "#%s: line number expected", dirname(LINE));
				goto eatdirective;
			}
		linesync:
			n = error_info.line;
			error_info.line = strtol(pp.token, NiL, 0);
			if (error_info.line == 0 && directive == LINE && (pp.state & STRICT) && !(pp.mode & HOSTED))
				error(1, "#%s: line number should be > 0", dirname(LINE));
			pp.state &= ~DISABLE;
			pp.state |= STRIP;
			switch (c = pplex())
			{
			case T_STRING:
				s = error_info.file;
				if (*(p = pp.token))
					pathcanon(p, 0);
				fp = ppsetfile(p);
				error_info.file = fp->name;
				if (error_info.line == 1)
					ppmultiple(fp, INC_IGNORE);
				switch (c = pplex())
				{
				case '\n':
					break;
				case T_DECIMAL:
				case T_OCTAL:
					if (directive == LINE && (pp.state & STRICT) && !(pp.mode & (HOSTED|RELAX)))
						error(1, "#%s: integer file type argument is non-standard", dirname(LINE));
					break;
				default:
					error(1, "#%s: integer file type argument expected", dirname(LINE));
					break;
				}
				if (directive == LINE) pp.in->flags &= ~IN_ignoreline;
				else if (pp.incref)
				{
					if (error_info.file != s)
					{
						switch (*pp.token)
						{
						case PP_sync_push:
							if (pp.insert) (*pp.incref)(s, error_info.file, n, PP_SYNC_INSERT);
							else (*pp.incref)(s, error_info.file, n, PP_SYNC_PUSH);
							break;
						case PP_sync_pop:
							if (pp.insert) (*pp.incref)(s, error_info.file, n, PP_SYNC_INSERT);
							else (*pp.incref)(s, error_info.file, n - 1, PP_SYNC_POP);
							break;
						case PP_sync_ignore:
							if (pp.insert) (*pp.incref)(s, error_info.file, n, PP_SYNC_INSERT);
							else
							{
								(*pp.incref)(s, error_info.file, n, PP_SYNC_IGNORE);
								error_info.file = s;
							}
							break;
						default:
							if (*s)
							{
								if (fp == pp.insert)
									pp.insert = 0;
								else if (error_info.line == 1 && !pp.insert)
									(*pp.incref)(s, error_info.file, n, PP_SYNC_PUSH);
								else
								{
									if (!pp.insert) pp.insert = ppgetfile(s);
									(*pp.incref)(s, error_info.file, n, PP_SYNC_INSERT);
								}
							}
							break;
						}
					}
				}
				break;
			case '\n':
				break;
			default:
				error(1, "#%s: \"file-name\" expected", dirname(LINE));
				break;
			}
			if (directive == LINE && (pp.in->flags & IN_ignoreline))
				error_info.line = n + 1;
			else
			{
				pp.hidden = 0;
				pp.state &= ~HIDDEN;
				if (pp.linesync)
				{
#if CATSTRINGS
					if (pp.state & JOINING) pp.state |= HIDDEN|SYNCLINE;
					else
#endif
					{
						s = pp.lineid;
						n = pp.flags;
						if (directive == LINE)
						{
							pp.flags &= ~PP_linetype;
							if (pp.macref) pp.lineid = dirname(LINE);
						}
						(*pp.linesync)(error_info.line, error_info.file);
						pp.flags = n;
						pp.lineid = s;
					}
				}
			}
			directive = LINE;
			break;
		case PRAGMA:
			/*
			 * #pragma [STDC] [pass:] [no]option [arg ...]
			 *
			 * pragma args are not expanded by default
			 *
			 * if STDC is present then it is silently passed on
			 *
			 * if pass is pp.pass then the option is used
			 * and verified but is not passed on
			 *
			 * if pass is omitted then the option is passed on
			 *
			 * otherwise if pass is non-null and not pp.pass then
			 * the option is passed on but not used
			 *
			 * if the line does not match this form then
			 * it is passed on unchanged
			 *
			 *	#directive   pass:  option  [...]
			 *	^         ^  ^   ^  ^     ^  ^   ^
			 *	pp.valbuf p0 p1  p2 p3    p4 p5  p6
			 *
			 * p?	0 if component omitted
			 * i0	0 if ``no''option
			 */

			p = pp.valbuf;
			*p++ = '#';
			STRCOPY(p, pp.token, s);
			p0 = p;
			if (pp.option & PRAGMAEXPAND)
				pp.state &= ~DISABLE;
			if (!(p6 = getline(p, &pp.valbuf[MAXTOKEN], !!(pp.option & PRAGMAEXPAND))))
			{
				*p0 = 0;
				error(2, "%s: directive too long", pp.valbuf);
				c = 0;
				goto eatdirective;
			}
			p1 = ++p;
			while (ppisid(*p))
				p++;
			if (p == p1)
			{
				p5 = p;
				p4 = 0;
				p3 = 0;
				p2 = 0;
				p1 = 0;
			}
			else if (*p != ':')
			{
				p5 = *p ? p + (*p == ' ') : 0;
				p4 = p;
				p3 = p1;
				p2 = 0;
				p1 = 0;
			}
			else
			{
				p2 = p++;
				p3 = p;
				while (ppisid(*p))
					p++;
				if (p == p3)
				{
					p4 = p1;
					p3 = 0;
					p2 = 0;
					p1 = 0;
				}
				else
					p4 = p;
				p5 = *p4 ? p4 + (*p4 == ' ') : 0;
			}
			if (!p1 && p3 && (p4 - p3) == 4 && strneq(p3, "STDC", 4))
				goto pass;
			if ((pp.state & WARN) && (pp.mode & (HOSTED|RELAX|PEDANTIC)) == PEDANTIC)
				error(1, "#%s: non-standard directive", dirname(PRAGMA));
			i0 = !p3 || *p3 != 'n' || *(p3 + 1) != 'o';
			if (!p3)
				goto checkmap;
			if (p1)
			{
				*p2 = 0;
				n = streq(p1, pp.pass);
				*p2 = ':';
				if (!n)
					goto checkmap;
			}
			else
				n = 0;
			i2 = *p4;
			*p4 = 0;
			if (((i1 = (int)hashref(pp.strtab, p3 + (i0 ? 0 : 2))) < 1 || i1 > X_last_option) && (i0 || (i1 = (int)hashref(pp.strtab, p3)) > X_last_option))
				i1 = 0;
			if ((pp.state & (COMPATIBILITY|STRICT)) == STRICT && !(pp.mode & (HOSTED|RELAX)))
			{
				if (pp.optflags[i1] & OPT_GLOBAL)
					goto donedirective;
				if (n || (pp.mode & WARN))
				{
					n = 0;
					error(1, "#%s: non-standard directive ignored", dirname(PRAGMA));
				}
				i1 = 0;
			}
			if (!n)
			{
				if (!(pp.optflags[i1] & OPT_GLOBAL))
				{
					*p4 = i2;
					goto checkmap;
				}
				if (!(pp.optflags[i1] & OPT_PASS))
					n = 1;
			}
			else if (!i1)
				error(2, "%s: unknown option", p1);
			else if ((pp.state & STRICT) && !(pp.mode & (HOSTED|RELAX)))
				error(1, "%s: non-standard option", p1);
			p = p5;
			switch (i1)
			{
			case X_ALLMULTIPLE:
				ppop(PP_MULTIPLE, i0);
				break;
			case X_ALLPOSSIBLE:
				setoption(ALLPOSSIBLE, i0);
				break;
			case X_BUILTIN:
				setmode(BUILTIN, i0);
				break;
			case X_CATLITERAL:
				setmode(CATLITERAL, i0);
				if (pp.mode & CATLITERAL)
					setoption(STRINGSPLIT, 0);
				break;
			case X_CDIR:
				tokop(PP_CDIR, p3, p, i0, TOKOP_UNSET|TOKOP_STRING|TOKOP_DUP);
				break;
			case X_CHECKPOINT:
#if CHECKPOINT
				ppload(p);
#else
				error(3, "%s: preprocessor not compiled with checkpoint enabled", p3);
#endif
				break;
			case X_CHOP:
				tokop(PP_CHOP, p3, p, i0, TOKOP_UNSET|TOKOP_STRING);
				break;
			case X_COMPATIBILITY:
				ppop(PP_COMPATIBILITY, i0);
				break;
			case X_DEBUG:
				error_info.trace = i0 ? (p ? -strtol(p, NiL, 0) : -1) : 0;
				break;
			case X_ELSEIF:
				setoption(ELSEIF, i0);
				break;
			case X_EXTERNALIZE:
				setmode(EXTERNALIZE, i0);
				break;
			case X_FINAL:
				setoption(FINAL, i0);
				break;
			case X_HEADEREXPAND:
				setoption(HEADEREXPAND, i0);
				break;
			case X_HEADEREXPANDALL:
				setoption(HEADEREXPANDALL, i0);
				break;
			case X_HIDE:
			case X_NOTE:
				PUSH_LINE(p);
				/* UNDENT...*/
	while (c = pplex())
	{
		if (c != T_ID) error(1, "%s: %s: identifier expected", p3, pp.token);
		else if (sym = ppsymset(pp.symtab, pp.token))
		{
			if (i1 == X_NOTE)
			{
				sym->flags &= ~SYM_NOTICED;
				ppfsm(FSM_MACRO, sym->name);
			}
			else if (i0)
			{
				if (!sym->hidden && !(sym->hidden = newof(0, struct pphide, 1, 0)))
					error(3, "out of space");
				if (!sym->macro)
					ppfsm(FSM_MACRO, sym->name);
				if (!sym->hidden->level++)
				{
					pp.hiding++;
					if (sym->macro && !(sym->flags & (SYM_ACTIVE|SYM_READONLY)))
					{
						sym->hidden->macro = sym->macro;
						sym->macro = 0;
						sym->hidden->flags = sym->flags;
						sym->flags &= ~(SYM_BUILTIN|SYM_FUNCTION|SYM_INIT|SYM_MULTILINE|SYM_PREDEFINED|SYM_REDEFINE|SYM_VARIADIC);
					}
				}
			}
			else if (sym->hidden)
			{
				if ((mac = sym->macro) && !(sym->flags & (SYM_ACTIVE|SYM_READONLY)))
				{
					if (mac->formals) free(mac->formals);
					free(mac->value);
					free(mac);
					sym->macro = 0;
					sym->flags &= ~(SYM_BUILTIN|SYM_FUNCTION|SYM_INIT|SYM_MULTILINE|SYM_PREDEFINED|SYM_REDEFINE|SYM_VARIADIC);
				}
				if (!--sym->hidden->level)
				{
					pp.hiding--;
					if (sym->hidden->macro)
					{
						sym->macro = sym->hidden->macro;
						sym->flags = sym->hidden->flags;
					}
					free(sym->hidden);
					sym->hidden = 0;
				}
			}
		}
	}
				/*...INDENT*/
				POP_LINE();
				break;
			case X_HOSTDIR:
				tokop(PP_HOSTDIR, p3, p, i0, TOKOP_UNSET|TOKOP_STRING|TOKOP_DUP);
				break;
			case X_HOSTED:
				setmode(HOSTED, i0);
				break;
			case X_HOSTEDTRANSITION:
				setmode(HOSTEDTRANSITION, i0);
				break;
			case X_ID:
				tokop(PP_ID, p3, p, i0, TOKOP_UNSET|TOKOP_STRING);
				break;
			case X_IGNORE:
				tokop(PP_IGNORE, p3, p, i0, TOKOP_UNSET|TOKOP_STRING);
				break;
			case X_INCLUDE:
				tokop(PP_INCLUDE, p3, p, i0, TOKOP_STRING|TOKOP_DUP);
				break;
			case X_INITIAL:
				setoption(INITIAL, i0);
				break;
			case X_KEYARGS:
				ppop(PP_KEYARGS, i0);
				break;
			case X_LINE:
				if (pp.linesync) pp.olinesync = pp.linesync;
				pp.linesync = i0 ? pp.olinesync : (PPLINESYNC)0;
				break;
			case X_LINEBASE:
				ppop(PP_LINEBASE, i0);
				break;
			case X_LINEFILE:
				ppop(PP_LINEFILE, i0);
				break;
			case X_LINEID:
				ppop(PP_LINEID, i0 ? p : (char*)0);
				break;
			case X_LINETYPE:
				ppop(PP_LINETYPE, i0 ? (p ? strtol(p, NiL, 0) : 1) : 0);
				break;
			case X_MACREF:
				if (!p)
				{
					if (i0 && !pp.macref)
					{
						ppop(PP_LINETYPE, 1);
						ppop(PP_MACREF, ppmacref);
					}
					else error(2, "%s: option cannot be unset", p3);
				}
				else if (s = strchr(p, ' '))
				{
					if (pp.macref && (s = strchr(p, ' ')))
					{
						*s++ = 0;
						c = strtol(s, NiL, 0);
						var.type = pp.truncate;
						pp.truncate = PPTOKSIZ;
						(*pp.macref)(pprefmac(p, REF_CREATE), error_info.file, error_info.line - (c == REF_NORMAL ? 2 : 1), c, (s = strchr(s, ' ')) ? strtol(s, NiL, 0) : 0L);
						pp.truncate = var.type;
					}
					error_info.line -= 2;
				}
				break;
			case X_MAP:
				/*UNDENT*/
	/*
	 * #pragma pp:map [id ...] "/from/[,/to/]" [ "/old/new/[glnu]" ... ]
	 */

	if (!i0)
	{
		error(2, "%s: option cannot be unset", p3);
		goto donedirective;
	}
	if (!p5)
	{
		error(2, "%s: address argument expected", p3);
		goto donedirective;
	}
	PUSH_LINE(p5);
	while ((c = pplex()) == T_ID)
	{
		sfsprintf(pp.tmpbuf, MAXTOKEN, "__%s__", s = pp.token);
		if (c = (int)hashget(pp.dirtab, s))
		{
			hashput(pp.dirtab, 0, 0);
			hashput(pp.dirtab, pp.tmpbuf, c);
		}
		if (c = (int)hashget(pp.strtab, s))
		{
			hashput(pp.strtab, 0, 0);
			hashput(pp.strtab, pp.tmpbuf, c);
		}
	}
	if (c != T_STRING || !*(s = pp.token))
	{
		if (c)
			error(2, "%s: %s: address argument expected", p3, pptokstr(pp.token, 0));
		goto eatmap;
	}
	map = newof(0, struct map, 1, 0);

	/*
	 * /from/
	 */

	if (i0 = regcomp(&map->re, s, REG_AUGMENTED|REG_DELIMITED|REG_LENIENT|REG_NULL))
		regfatal(&map->re, 3, i0);
	if (*(s += map->re.re_npat))
	{
		error(2, "%s: invalid characters after pattern: %s ", p3, s);
		goto eatmap;
	}

	/*
	 * /old/new/[flags]
	 */

	edit = 0;
	while ((c = pplex()) == T_STRING)
	{
		if (!*(s = pp.token))
		{
			error(2, "%s: substitution argument expected", p3);
			goto eatmap;
		}
		if (edit)
			edit = edit->next = newof(0, struct edit, 1, 0);
		else
			edit = map->edit = newof(0, struct edit, 1, 0);
		if (!(i0 = regcomp(&edit->re, s, REG_AUGMENTED|REG_DELIMITED|REG_LENIENT|REG_NULL)) && !(i0 = regsubcomp(&edit->re, s += edit->re.re_npat, NiL, 0, 0)))
			s += edit->re.re_npat;
		if (i0)
			regfatal(&edit->re, 3, i0);
		if (*s)
		{
			error(2, "%s: invalid characters after substitution: %s ", p3, s);
			goto eatmap;
		}
	}
	if (c)
	{
		error(2, "%s: %s: substitution argument expected", p3, pptokstr(pp.token, 0));
		goto eatmap;
	}
	map->next = (struct map*)pp.maps;
	pp.maps = (char*)map;
 eatmap:
	POP_LINE();
				/*INDENT*/
				break;
			case X_MAPINCLUDE:
				ppmapinclude(NiL, p5);
				break;
			case X_MODERN:
				setoption(MODERN, i0);
				break;
			case X_MULTIPLE:
				n = 1;
				if (pp.in->type == IN_FILE || pp.in->type == IN_RESCAN)
					ppmultiple(ppsetfile(error_info.file), i0 ? INC_CLEAR : INC_IGNORE);
				break;
			case X_NATIVE:
				setoption(NATIVE, i0);
				break;
			case X_OPSPACE:
				ppfsm(FSM_OPSPACE, i0 ? p4 : (char*)0);
				break;
			case X_PASSTHROUGH:
				ppop(PP_PASSTHROUGH, i0);
				break;
			case X_PEDANTIC:
				ppop(PP_PEDANTIC, i0);
				break;
			case X_PLUSCOMMENT:
				ppop(PP_PLUSCOMMENT, i0);
				break;
			case X_PLUSPLUS:
				ppop(PP_PLUSPLUS, i0);
				break;
			case X_PLUSSPLICE:
				setoption(PLUSSPLICE, i0);
				break;
			case X_PRAGMAEXPAND:
				setoption(PRAGMAEXPAND, i0);
				break;
			case X_PRAGMAFLAGS:
				tokop(PP_PRAGMAFLAGS, p3, p, i0, 0);
				break;
			case X_PREDEFINED:
				setoption(PREDEFINED, i0);
				break;
			case X_PREFIX:
				setoption(PREFIX, i0);
				break;
			case X_PRESERVE:
				setoption(PRESERVE, i0);
				if (pp.option & PRESERVE)
				{
					setmode(CATLITERAL, 0);
					ppop(PP_COMPATIBILITY, 1);
					ppop(PP_TRANSITION, 0);
					ppop(PP_PLUSCOMMENT, 1);
					ppop(PP_SPACEOUT, 1);
					setoption(STRINGSPAN, 1);
					setoption(STRINGSPLIT, 0);
					ppop(PP_HOSTDIR, "-", 1);
				}
				break;
			case X_PROTOTYPED:
				/*
				 * this option doesn't bump the token count
				 */

				n = 1;
				directive = ENDIF;
#if PROTOTYPE
				setoption(PROTOTYPED, i0);
#else
				error(1, "preprocessor not compiled with prototype conversion enabled");
#endif
				break;
			case X_PROTO:
				setoption(NOPROTO, !i0);
				break;
			case X_QUOTE:
				tokop(PP_QUOTE, p3, p, i0, TOKOP_UNSET|TOKOP_STRING);
				break;
			case X_READONLY:
				setmode(READONLY, i0);
				break;
			case X_REGUARD:
				setoption(REGUARD, i0);
				break;
			case X_RESERVED:
				tokop(PP_RESERVED, p3, p, i0, 0);
				break;
			case X_SPACEOUT:
				if (!(pp.state & (COMPATIBILITY|COMPILE)))
					ppop(PP_SPACEOUT, i0);
				break;
			case X_SPLICECAT:
				setoption(SPLICECAT, i0);
				break;
			case X_SPLICESPACE:
				setoption(SPLICESPACE, i0);
				break;
			case X_STANDARD:
				tokop(PP_STANDARD, p3, p, i0, TOKOP_UNSET|TOKOP_STRING|TOKOP_DUP);
				break;
			case X_STRICT:
				ppop(PP_STRICT, i0);
				break;
			case X_STRINGSPAN:
				setoption(STRINGSPAN, i0);
				break;
			case X_STRINGSPLIT:
				setoption(STRINGSPLIT, i0);
				if (pp.option & STRINGSPLIT)
					setmode(CATLITERAL, 0);
				break;
			case X_SYSTEM_HEADER:
				if (i0)
				{
					pp.mode |= HOSTED;
					pp.flags |= PP_hosted;
					pp.in->flags |= IN_hosted;
				}
				else
				{
					pp.mode &= ~HOSTED;
					pp.flags &= ~PP_hosted;
					pp.in->flags &= ~PP_hosted;
				}
				break;
			case X_TEST:
				ppop(PP_TEST, p);
				break;
			case X_TEXT:
				if (!(pp.option & KEEPNOTEXT))
					setstate(NOTEXT, !i0);
				break;
			case X_TRANSITION:
				ppop(PP_TRANSITION, i0);
				if (pp.state & TRANSITION) ppop(PP_COMPATIBILITY, i0);
				break;
			case X_TRUNCATE:
				ppop(PP_TRUNCATE, i0 ? (p ? strtol(p, NiL, 0) : TRUNCLENGTH) : 0);
				break;
			case X_VENDOR:
				tokop(PP_VENDOR, p3, p, i0, TOKOP_UNSET|TOKOP_STRING|TOKOP_DUP);
				break;
			case X_VERSION:
				if (!(*pp.control & SKIP) && pp.pragma && !(pp.state & NOTEXT))
				{
					sfsprintf(pp.tmpbuf, MAXTOKEN, "\"%s\"", pp.version);
					(*pp.pragma)(dirname(PRAGMA), pp.pass, p3, pp.tmpbuf, !n);
					if (pp.linesync && !n)
						(*pp.linesync)(error_info.line, error_info.file);
					emitted = 1;
				}
				break;
			case X_WARN:
				ppop(PP_WARN, i0);
				break;
			case X_ZEOF:
				setoption(ZEOF, i0);
				break;
#if DEBUG
			case 0:
			case X_INCLUDED:
			case X_NOTICED:
			case X_OPTION:
			case X_STATEMENT:
				break;
			default:
				error(PANIC, "%s: option recognized but not implemented", pp.valbuf);
				break;
#endif
			}
			*p4 = i2;
			if (!n)
				goto checkmap;
			goto donedirective;
		case RENAME:
			if ((pp.state & STRICT) && !(pp.mode & (HOSTED|RELAX)))
				error(1, "#%s: non-standard directive", pp.token);
			if ((c = pplex()) != T_ID)
			{
				error(1, "%s: invalid macro name", pptokstr(pp.token, 0));
				goto eatdirective;
			}
			if (!(sym = pprefmac(pp.token, REF_DELETE)) || !sym->macro)
				goto eatdirective;
			if (sym->flags & (SYM_ACTIVE|SYM_READONLY))
			{
				if (!(pp.option & ALLPOSSIBLE))
					error(2, "%s: macro is %s", sym->name, (sym->flags & SYM_READONLY) ? "readonly" : "active");
				goto eatdirective;
			}
			if ((c = pplex()) != T_ID)
			{
				error(1, "%s: invalid macro name", pptokstr(pp.token, 0));
				goto eatdirective;
			}
			var.symbol = pprefmac(pp.token, REF_CREATE);
			if (mac = var.symbol->macro)
			{
				if (var.symbol->flags & (SYM_ACTIVE|SYM_READONLY))
				{
					if (!(pp.option & ALLPOSSIBLE))
						error(2, "%s: macro is %s", var.symbol->name, (var.symbol->flags & SYM_READONLY) ? "readonly" : "active");
					goto eatdirective;
				}
				if (!(pp.mode & HOSTED) || !(var.symbol->flags & SYM_INITIAL))
					error(1, "%s redefined", var.symbol->name);
				if (mac->formals) free(mac->formals);
				free(mac->value);
				free(mac);
			}
			ppfsm(FSM_MACRO, var.symbol->name);
			var.symbol->flags = sym->flags;
			sym->flags &= ~(SYM_BUILTIN|SYM_FUNCTION|SYM_INIT|SYM_MULTILINE|SYM_PREDEFINED|SYM_REDEFINE|SYM_VARIADIC);
			var.symbol->macro = sym->macro;
			sym->macro = 0;
			break;
		case UNDEF:
			if ((c = pplex()) != T_ID)
			{
				error(1, "%s: invalid macro name", pptokstr(pp.token, 0));
				goto eatdirective;
			}
			if (sym = pprefmac(pp.token, REF_DELETE))
			{
				if (mac = sym->macro)
				{
					if (sym->flags & (SYM_ACTIVE|SYM_READONLY))
					{
						if (!(pp.option & ALLPOSSIBLE))
							error(2, "%s: macro is %s", sym->name, (sym->flags & SYM_READONLY) ? "readonly" : "active");
						goto eatdirective;
					}
					if (mac->formals) free(mac->formals);
					free(mac->value);
					free(mac);
					mac = sym->macro = 0;
				}
				if ((pp.option & (DEFINITIONS|PREDEFINITIONS|REGUARD)) && !sym->hidden && !(sym->flags & SYM_MULTILINE) && ((pp.option & PREDEFINITIONS) || !(pp.mode & INIT)) && ((pp.option & (DEFINITIONS|PREDEFINITIONS)) || !(pp.state & NOTEXT)))
				{
					ppsync();
					ppprintf("#%s %s", dirname(UNDEF), sym->name);
					emitted = 1;
				}
				sym->flags &= ~(SYM_BUILTIN|SYM_FUNCTION|SYM_INIT|SYM_MULTILINE|SYM_PREDEFINED|SYM_REDEFINE|SYM_VARIADIC);
				n2 = error_info.line;
				goto benign;
			}
			else pprefmac(pp.token, REF_UNDEF);
			break;
#if DEBUG
		default:
			error(PANIC, "#%s: directive recognized but not implemented", pp.token);
			goto eatdirective;
#endif
		}
		break;
	case '\n':
		break;
	default:
		error(1, "%s: invalid directive name", pptokstr(pp.token, 0));
		goto eatdirective;
	}
 enddirective:
#if COMPATIBLE
	if (c != '\n' && !(pp.state & COMPATIBILITY))
#else
	if (c != '\n')
#endif
	{
		pp.state |= DISABLE|NOSPACE;
		if ((c = pplex()) != '\n' && (pp.mode & (HOSTED|PEDANTIC)) == PEDANTIC)
			error(1, "%s: invalid characters after directive", pptokstr(pp.token, 0));
	}
 eatdirective:
	if (c != '\n')
	{
		pp.state |= DISABLE;
		while (pplex() != '\n');
	}
 donedirective:
#if _HUH_2002_05_09
	if (!(pp.state & EOF2NL))
		error(2, "%s in directive", pptokchr(0));
#endif
	pp.state &= ~RESTORE;
	pp.mode &= ~RELAX;
	if (!(*pp.control & SKIP))
	{
		pp.state |= restore;
		switch (directive)
		{
		case LINE:
			return 0;
		case INCLUDE:
			if (pp.include)
			{
				error_info.line++;
				PUSH_FILE(pp.include, n);
				if (!pp.vendor && (pp.found->type & TYPE_VENDOR))
					pp.vendor = 1;
				pp.include = 0;
				return 0;
			}
			if (pp.incref)
				(*pp.incref)(error_info.file, ppgetfile(pp.path)->name, error_info.line, PP_SYNC_IGNORE);
			else if (pp.linesync && pp.macref)
			{
				pp.flags |= PP_lineignore;
				(*pp.linesync)(error_info.line, ppgetfile(pp.path)->name);
			}
			/*FALLTHROUGH*/
		default:
			pp.in->flags |= IN_tokens;
			/*FALLTHROUGH*/
		case ENDIF:
			error_info.line++;
			if (emitted)
			{
				ppputchar('\n');
				ppcheckout();
			}
			else
			{
				pp.state |= HIDDEN;
				pp.hidden++;
			}
			return 0;
		}
	}
	pp.state |= restore|HIDDEN|SKIPCONTROL;
	pp.hidden++;
	pp.level++;
	error_info.line++;
	return 0;
}

/*
 * grow the pp nesting control stack
 */

void
ppnest(void)
{
	register struct ppinstk*	ip;
	int				oz;
	int				nz;
	long				adjust;
	long*				op;
	long*				np;

	oz = pp.constack;
	op = pp.maxcon - oz + 1;
	nz = oz * 2;
	np = newof(op, long, nz, 0);
	if (adjust = (np - op))
	{
		ip = pp.in;
		do
		{
			if (ip->control)
				ip->control += adjust;
		} while (ip = ip->prev);
	}
	pp.control = np + oz;
	pp.constack = nz;
	pp.maxcon = np + nz - 1;
}