/***********************************************************************
*                                                                      *
*               This software is part of the ast package               *
*           Copyright (c) 1986-2007 AT&T Knowledge Ventures            *
*                      and is licensed under the                       *
*                  Common Public License, Version 1.0                  *
*                      by AT&T Knowledge Ventures                      *
*                                                                      *
*                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 lexical analyzer
 * standalone and tokenizing lexer combined in one source
 * define CPP=1 for standalone
 */

#include "pplib.h"
#include "ppfsm.h"

#if CPP

/*
 * standalone entry point
 */

#define PPCPP_T		void

#define START		QUICK
#define INMACRO(x)	INQMACRO(x)
#define DOSTRIP()	(st&STRIP)

#if DEBUG & TRACE_debug
static int		hit[LAST-TERMINAL+2];
#endif

#define BACKIN()	(ip--)
#define BACKOUT()	(op=tp)
#define CACHE()		do{CACHEINX();CACHEOUTX();st=pp.state;if(!pp.hidden)spliced=0;}while(0)
#define CACHEIN()	do{CACHEINX();st=pp.state;if(!pp.hidden)spliced=0;}while(0)
#define CACHEINX()	do{ip=pp.in->nextchr;}while(0)
#define CACHEOUT()	do{CACHEOUTX();st=pp.state;if(!pp.hidden)spliced=0;}while(0)
#define CACHEOUTX()	do{tp=op=pp.outp;xp=pp.oute;if(sp)sp=op;}while(0)
#define GETCHR()	(*(unsigned char*)ip++)
#define LASTCHR()	(*(ip-1))
#define LASTOUT()	((op>pp.outbuf)?*(op-1):pp.lastout)
#define SKIPIN()	(ip++)
#define PUTCHR(c)	(*op++=(c))
#define SETCHR(c)	(*op=(c))
#define SYNC()		do{SYNCINX();SYNCOUTX();pp.state=st;}while(0)
#define SYNCIN()	do{SYNCINX();pp.state=st;}while(0)
#define SYNCINX()	do{pp.in->nextchr=ip;}while(0)
#define SYNCOUT()	do{SYNCOUTX();pp.state=st;}while(0)
#define SYNCOUTX()	do{if(sp)op=tp=sp;pp.outp=op;}while(0)
#define UNGETCHR(c)	(*--ip=(c))

#define PPCHECKOUT()	do{if(op>xp){{PPWRITE(PPBUFSIZ);if(pp.outbuf==pp.outb){pp.outbuf+=PPBUFSIZ;xp=pp.oute+=PPBUFSIZ;}else{pp.outbuf-=PPBUFSIZ;memcpy(pp.outbuf,xp,op-xp);xp=pp.oute-=PPBUFSIZ;op-=2*PPBUFSIZ;}}}}while(0)
#define PPCHECKOUTSP()	do{if(op>xp){if(sp)op=sp;else{PPWRITE(PPBUFSIZ);if(pp.outbuf==pp.outb){pp.outbuf+=PPBUFSIZ;xp=pp.oute+=PPBUFSIZ;}else{pp.outbuf-=PPBUFSIZ;memcpy(pp.outbuf,xp,op-xp);xp=pp.oute-=PPBUFSIZ;op-=2*PPBUFSIZ;}}}}while(0)
#define PPCHECKOUTTP()	do{if(op>xp){{PPWRITE(PPBUFSIZ);if(pp.outbuf==pp.outb){pp.outbuf+=PPBUFSIZ;xp=pp.oute+=PPBUFSIZ;}else{pp.outbuf-=PPBUFSIZ;memcpy(pp.outbuf,xp,op-xp);xp=pp.oute-=PPBUFSIZ;op-=2*PPBUFSIZ;}}tp=op;}}while(0)

#define PPSYNCLINE()	do { \
		if ((st & (ADD|HIDDEN)) && !(*pp.control & SKIP)) \
		{ \
		    if (spliced) \
		    { \
			error_info.line += spliced; \
			spliced = 0; \
		    } \
		    else \
		    { \
			if (st & ADD) \
			{ \
				st &= ~ADD; \
				m = pp.addp - pp.addbuf; \
				pp.addp = pp.addbuf; \
				memcpy(op, pp.addbuf, m); \
				op += m; \
				PPCHECKOUT(); \
			} \
			if (pp.linesync) \
			{ \
				if ((st & SYNCLINE) || pp.hidden >= MAXHIDDEN) \
				{ \
					pp.hidden = 0; \
					st &= ~(HIDDEN|SYNCLINE); \
					if (error_info.line) \
					{ \
						if (LASTOUT() != '\n') \
							PUTCHR('\n'); \
						SYNCOUT(); \
						(*pp.linesync)(error_info.line, error_info.file); \
						CACHEOUT(); \
					} \
				} \
				else \
				{ \
					m = pp.hidden; \
					pp.hidden = 0; \
					st &= ~HIDDEN; \
					while (m-- > 0) \
						PUTCHR('\n'); \
				} \
			} \
			else \
			{ \
				pp.hidden = 0; \
				st &= ~HIDDEN; \
				PUTCHR('\n'); \
			} \
		    } \
		} \
	} while (0)

#if POOL

/*
 * <wait.h> is poison here so pool moved to the end
 */

static void	poolstatus(void);
static void	pool(void);

#endif

#else

/*
 * return next pp token
 *
 * NOTE: pp.token points to at least MAXTOKEN*2 chars and is
 *       truncated back to MAXTOKEN on EOB
 */

#define PPCPP_T		int
#define ppcpp		pplex

#define START		TOKEN
#define INMACRO(x)	INTMACRO(x)
#define DOSTRIP()	((st&STRIP)||pp.level==1&&(st&(COMPILE|JOINING))==COMPILE&&!(pp.option&PRESERVE))

#define st		pp.state
#define tp		pp.token
#define xp		&pp.token[MAXTOKEN]

#define BACKIN()	(ip--)
#define BACKOUT()	(op=pp.token)
#define CACHE()		do{CACHEIN();CACHEOUT();}while(0)
#define CACHEIN()	(ip=pp.in->nextchr)
#define CACHEOUT()	(op=pp.token)
#define GETCHR()	(*(unsigned char*)ip++)
#define LASTCHR()	(*(ip-1))
#define PUTCHR(c)	(*op++=(c))
#define SETCHR(c)	(*op=(c))
#define SKIPIN()	(ip++)
#define SYNC()		do{SYNCIN();SYNCOUT();}while(0)
#define SYNCIN()	(pp.in->nextchr=ip)
#define SYNCOUT()	(pp.toknxt=op)
#define UNGETCHR(c)	(*--ip=(c))

#endif

PPCPP_T
ppcpp(void)
{
	register short*		rp;
	register char*		ip;
	register int		state;
	register int		c;
	register char*		op;
	char*			bp;
	int			n;
	int			m;
	int			quot;
	int			quotquot;
	int			comdelim = 0;
	int			comstart = 0;
	int			comwarn = 0;
	char*			s;
	struct ppsymbol*	sym;
#if CPP
	register long		st;
	char*			tp;
	char*			xp;
	char*			sp = 0;
	int			qual = 0;
	int			spliced = 0;
#else
	int			qual;
#endif

#if CPP
#if POOL
 fsm_pool:
#endif
#else
	count(pplex);
#endif
	error_info.indent++;
	pp.level++;
	CACHE();
#if !CPP
 fsm_top:
	qual = 0;
#endif
 fsm_start:
#if CPP
	PPCHECKOUTSP();
	tp = op;
#endif
	state = START;
 fsm_begin:
	bp = ip;
	do
	{
		rp = fsm[state];
 fsm_get:
		while (!(state = rp[c = GETCHR()]));
 fsm_next:
		;
	} while (state > 0);
	if (((state = ~state) != S_COMMENT || pp.comment || c == '/' && !INCOMMENT(rp)) && (n = ip - bp - 1) > 0)
	{
		ip = bp;
#if CPP
		if (op == tp && (st & (ADD|HIDDEN)) && !(st & PASSTHROUGH))
			switch (TERM(state))
			{
			case S_SHARP:
				break;
			case S_CHRB:
			case S_NL:
				if (*ip == '\n')
					break;
				/*FALLTHROUGH*/
			default:
				PPSYNCLINE();
				tp = op;
				break;
			}
#endif
		MEMCPY(op, ip, n);
		ip++;
	}
	count(terminal);
#if CPP && (DEBUG & TRACE_debug)
	hit[(state & SPLICE) ? (elementsof(hit) - 1) : (TERM(state) - TERMINAL)]++;
#endif
 fsm_terminal:
	debug((-9, "TERM %s > %s%s%s |%-*.*s|%s|", pplexstr(INDEX(rp)), pplexstr(state), (st & NEWLINE) ? "|NEWLINE" : "", (st & SKIPCONTROL) ? "|SKIP" : "", op - tp, op - tp, tp, pptokchr(c)));
	switch (TERM(state))
	{

#if !CPP
	case S_CHR:
		PUTCHR(c);
		break;
#endif

	case S_CHRB:
		BACKIN();
#if CPP
		st &= ~NEWLINE;
		pp.in->flags |= IN_tokens;
		count(token);
		goto fsm_start;
#else
		c = *tp;
		break;
#endif

	case S_COMMENT:
		switch (c)
		{
		case '\n':
			if (!INCOMMENTXX(rp))
			{
				qual = 0;
				if (!comstart) comstart = comdelim = error_info.line;
				error_info.line++;
				if (pp.comment) PUTCHR(c);
				else BACKOUT();
#if CPP
				rp = fsm[COM2];
				bp = ip;
				goto fsm_get;
#else
				state = COM2;
				goto fsm_begin;
#endif
			}
			else if (comwarn < 0 && !(pp.mode & HOSTED))
				error(1, "/* appears in // comment");
			break;
		case '*':
			if (!comwarn && !(pp.mode & HOSTED))
			{
				if (INCOMMENTXX(rp)) comwarn = -1;
				else if (comstart && comstart != error_info.line)
				{
					if (qual || comdelim < error_info.line - 1)
					{
						error(1, "/* appears in /* ... */ comment starting at line %d", comstart);
						comwarn = 1;
					}
					else comdelim = error_info.line;
				}
			}
 fsm_comment:
			PUTCHR(c);
#if CPP
			rp = fsm[INCOMMENTXX(rp) ? COM5 : COM3];
			bp = ip;
			goto fsm_get;
#else
			state = INCOMMENTXX(rp) ? COM5 : COM3;
			goto fsm_begin;
#endif
		case '/':
			if (!INCOMMENT(rp))
			{
				if (!(pp.mode & HOSTED))
					error(1, "*/ appears outside of comment");
				BACKIN();
#if CPP
				st &= ~NEWLINE;
				pp.in->flags |= IN_tokens;
				count(token);
				goto fsm_start;
#else
				c = '*';
				if (!pp.comment) PUTCHR(c);
				goto fsm_token;
#endif
			}
			else if (INCOMMENTXX(rp))
			{
				if (!(pp.mode & HOSTED))
				{
					if (comwarn < 0) comwarn = 0;
					else if (!comwarn)
					{
						comwarn = 1;
						error(1, "*/ appears in // comment");
					}
				}
				goto fsm_comment;
			}
			break;
		case EOF:
			BACKIN();
			if (!(pp.mode & HOSTED))
			{
				if (comstart) error(2, "unterminated /* ... */ comment starting at line %d", comstart);
				else if (INCOMMENTXX(rp)) error(2, "unterminated // ... comment");
				else error(2, "unterminated /* ... */ comment");
			}
			break;
		}
#if CPP
		if (!pp.comment || sp)
		{
#if COMPATIBLE
			if (!(pp.state & COMPATIBILITY) || *bp == ' ' || *bp == '\t')
#endif
			{
				BACKOUT();
				PUTCHR(' ');
				tp = op;
			}
		}
		else if (pp.in->type & IN_TOP)
#else
		if (pp.comment && !(st & (COLLECTING|DIRECTIVE|JOINING)) && !(*pp.control & SKIP) && (pp.in->type & IN_TOP))
#endif
		{
			st &= ~HIDDEN;
			pp.hidden = 0;
			*(op - (c != '\n')) = 0;
			m = (op - (c != '\n') - tp > MAXTOKEN - 6) ? (error_info.line - MAXHIDDEN) : 0;
			BACKOUT();
			SYNC();
			while (*tp != '/') tp++;
			(*pp.comment)(c == '\n' ? "//" : "/*", tp + 2, c == '\n' ? "" : (st & HEADER) ? "*/\n" : "*/", comstart ? comstart : error_info.line);
			CACHE();
			comstart = m;
		}
		if (comstart)
		{
			st |= HIDDEN;
			pp.hidden += error_info.line - comstart;
			comstart = 0;
		}
		qual = comwarn = comdelim = 0;
		BACKOUT();
		if (c == '\n') goto fsm_newline;
		if ((st & PASSTHROUGH) && ((st & (HIDDEN|NEWLINE)) || *ip == '\n'))
		{
			if (*ip == '\n')
				ip++;
			goto fsm_newline;
		}
#if COMPATIBLE
		if ((st & (COMPATIBILITY|TRANSITION)) == COMPATIBILITY) st &= ~NEWLINE;
#endif
#if !CPP
		if (pp.level > 1 && !(st & (NOSPACE|SKIPCONTROL)))
		{
#if COMPATIBLE
			c = ((st & (COMPATIBILITY|DEFINITION)) == ((COMPATIBILITY|DEFINITION))) ? '\t' : ' ';
#else
			c = ' ';
#endif
			goto fsm_return;
		}
#endif
		goto fsm_start;

	case S_EOB:
		if (c)
		{
			if (state = fsm[TERMINAL][INDEX(rp)+1])
				goto fsm_terminal;
#if CPP
#if POOL
			if (pp.pool.input)
			{
				BACKIN();
				SYNC();
				pool();
				CACHE();
				goto fsm_pool;
			}
#endif
			SYNCOUT();
			return;
#else
			BACKIN();
			c = 0;
			goto fsm_return;
#endif
		}
		{
			register struct ppinstk*	cur = pp.in;
			register struct ppinstk*	prv = pp.in->prev;

#if CPP
			if (sp) op = sp;
#endif
			switch (cur->type)
			{
			case IN_BUFFER:
			case IN_INIT:
			case IN_RESCAN:
#if CPP
				if (prv)
#else
				if (!(st & PASSEOF) && prv)
#endif
				{
					if (cur->type == IN_RESCAN || cur->type == IN_BUFFER)
					{
 fsm_pop:
#if PROTOTYPE
						if (cur->flags & IN_prototype)
							pppclose(cur->buffer + PPBAKSIZ);
						else
#endif
						if (!(cur->flags & IN_static))
							free(cur->buffer);
					}
					while (pp.control-- != cur->control)
						error(2, "#%s on line %d has no #%s", dirname(IF), GETIFLINE(pp.control+1), dirname(ENDIF));
					st |= NEWLINE;
					error_info.file = cur->file;
					error_info.line = cur->line;
					pp.hidden = 0;
#if CPP
					spliced = 0;
#endif
					if (cur->flags & IN_hosted)
					{
						pp.mode |= HOSTED;
						pp.flags |= PP_hosted;
					}
					else
					{
						pp.mode &= ~HOSTED;
						pp.flags &= ~PP_hosted;
					}
#if !CPP && CATSTRINGS
					if (st & JOINING) st |= HIDDEN|SYNCLINE;
					else
#endif
					{
						st &= ~(HIDDEN|SYNCLINE);
						switch (cur->type)
						{
						case IN_BUFFER:
						case IN_INIT:
							if (!prv->prev) break;
							/*FALLTHROUGH*/
						case IN_FILE:
						case IN_RESCAN:
							if (prv->type == IN_FILE || cur->type == IN_FILE && (prv->type == IN_RESCAN || prv->type == IN_MULTILINE))
							{
								if (pp.linesync && (cur->type != IN_RESCAN || (cur->flags & IN_sync)))
								{
									POP();
									SYNCOUT();
									(*pp.linesync)(error_info.line, error_info.file);
									CACHEOUT();
									prv = pp.in;
								}
							}
#if DEBUG
							else if (!prv->prev)
							{
								/*UNDENT*/
	c = 0;
#if DEBUG & TRACE_count
	if (pp.test & TEST_count)
	{
		c = 1;
		sfprintf(sfstderr, "\n");
		sfprintf(sfstderr, "%7d: pplex calls\n", pp.counter.pplex);
		sfprintf(sfstderr, "%7d: terminal states\n", pp.counter.terminal);
		sfprintf(sfstderr, "%7d: emitted tokens\n", pp.counter.token);
		sfprintf(sfstderr, "%7d: input stream pushes\n", pp.counter.push);
		sfprintf(sfstderr, "%7d: macro candidates\n", pp.counter.candidate);
		sfprintf(sfstderr, "%7d: macro expansions\n", pp.counter.macro);
		sfprintf(sfstderr, "%7d: function macros\n", pp.counter.function);
	}
#endif
#if CPP && (DEBUG & TRACE_debug)
	if (pp.test & TEST_hit)
	{
		c = 1;
		sfprintf(sfstderr, "\n");
		if (hit[elementsof(hit) - 1])
			sfprintf(sfstderr, "%7d: SPLICE\n", hit[elementsof(hit) - 1]);
		for (n = 0; n < elementsof(hit) - 1; n++)
			if (hit[n])
				sfprintf(sfstderr, "%7d: %s\n", hit[n], pplexstr(TERMINAL + n));
	}
#endif
	if (pp.test & (TEST_hashcount|TEST_hashdump))
	{
		c = 1;
		sfprintf(sfstderr, "\n");
		hashdump(NiL, (pp.test & TEST_hashdump) ? HASH_BUCKET : 0);
	}
	if (c) sfprintf(sfstderr, "\n");
								/*INDENT*/
							}
#endif
							break;
						}
					}
#if CHECKPOINT
					if (cur->index)
					{
						SYNCOUT();
						cur->index->end = ppoffset();
						cur->index = 0;
						CACHEOUT();
					}
#endif
					POP();
					bp = ip;
					tp = op;
					goto fsm_get;
				}
				c = EOF;
				break;
			case IN_COPY:
				if (prv)
				{
					error_info.line = cur->line;
					if (!(prv->symbol->flags & SYM_MULTILINE))
						prv->symbol->flags |= SYM_DISABLED;
					POP();
					bp = ip;
					goto fsm_get;
				}
				c = EOF;
				break;
			case IN_EXPAND:
				if (prv)
				{
					error_info.line = cur->line;
					free(cur->buffer);
					POP();
					bp = ip;
					goto fsm_get;
				}
				c = EOF;
				break;
			case IN_FILE:
				FGET(c, c, tp, xp);
				if (c == EOB)
				{
#if CPP
					if ((st & (NOTEXT|HIDDEN)) == HIDDEN && LASTOUT() != '\n')
						PUTCHR('\n');
					if (prv)
#else
					if (st & EOF2NL)
					{
						st &= ~EOF2NL;
						*(ip - 1) = c = '\n';
					}
					else if (!(st & (FILEPOP|PASSEOF)) && prv)
#endif
					{
						if (!(cur->flags & IN_newline))
						{
							cur->flags |= IN_newline;
							if ((pp.mode & (HOSTED|PEDANTIC)) == PEDANTIC && LASTCHR() != '\f' && LASTCHR() != CC_sub)
								error(1, "file does not end with %s", pptokchr('\n'));
							*(ip - 1) = c = '\n';
						}
						else
						{
							if (!(cur->flags & (IN_noguard|IN_tokens)) && cur->symbol)
								ppmultiple(ppsetfile(error_info.file), cur->symbol);
							if (cur->fd >= 0)
								close(cur->fd);
							if (pp.incref && !(pp.mode & INIT))
							{
								SYNCOUT();
								(*pp.incref)(error_info.file, cur->file, error_info.line - 1, PP_SYNC_POP);
								CACHEOUT();
							}
							goto fsm_pop;
						}
					}
					else
						c = EOF;
				}
				break;
			case IN_MACRO:
			case IN_MULTILINE:
#if !CPP
				if (!(st & PASSEOF))
#endif
#if COMPATIBLE
				if (prv && (!INMACRO(rp) || (st & (COMPATIBILITY|TRANSITION)) == COMPATIBILITY && ppismac(*prv->nextchr)))
#else
				if (prv && !INMACRO(rp))
#endif
				{
					if (cur->type == IN_MULTILINE)
					{
						while (pp.control-- != cur->control)
							error(2, "#%s on line %d has no #%s", dirname(IF), GETIFLINE(pp.control+1), dirname(ENDIF));
						free(cur->buffer);
						error_info.file = cur->file;
						error_info.line = cur->line;
						if (pp.linesync)
						{
							SYNCOUT();
							(*pp.linesync)(error_info.line, error_info.file);
							CACHEOUT();
						}
					}
					cur->symbol->flags &= ~SYM_DISABLED;
					if (cur->symbol->flags & SYM_FUNCTION)
						popframe(pp.macp);
					POP();
#if CPP
					if (!(st & COMPATIBILITY) && ppisidig(*(op - 1)) && ppisidig(*ip)) UNGETCHR(' ');
#endif
					bp = ip;
					goto fsm_get;
				}
				c = EOF;
				break;
			case IN_QUOTE:
				if (prv)
				{
					error_info.line = cur->line;
					st &= ~(ESCAPE|QUOTE);
					POP();
					c = '"';
				}
				else c = EOF;
				break;
			case IN_SQUOTE:
				if (prv)
				{
					error_info.line = cur->line;
					st &= ~(ESCAPE|SQUOTE);
					POP();
					c = '\'';
				}
				else c = EOF;
				break;
			case IN_STRING:
#if CPP
				if (prv)
#else
				if (!(st & PASSEOF) && !(cur->flags & IN_expand) && prv)
#endif
				{
					if (cur->flags & IN_disable) st |= DISABLE;
					else st &= ~DISABLE;
					POP();
					bp = ip;
					goto fsm_get;
				}
				c = EOF;
				break;
			default:
				c = EOF;
				break;
			}
		}
		bp = ip - 1;
		if (state = rp[c]) goto fsm_next;
		goto fsm_get;

#if !CPP
	case S_HUH:
		if (INOPSPACE(rp))
		{
			if (c == '=')
			{
#if PROTOTYPE
				if (pp.in->flags & IN_prototype) PUTCHR(c);
				else
				{
#endif
					while (*(op - 1) == ' ' || *(op - 1) == '\t') op--;
					PUTCHR(c);
					if (st & (STRICT|WARN)) error(1, "%-*.*s: space ignored in operator", op - tp, op - tp, tp);
#if PROTOTYPE
				}
#endif
				switch (*tp)
				{
				case '/':
					c = T_DIVEQ;
					break;
				case '%':
					c = T_MODEQ;
					break;
				case '&':
					c = T_ANDEQ;
					break;
				case '*':
					c = T_MPYEQ;
					break;
				case '+':
					c = T_ADDEQ;
					break;
				case '-':
					c = T_SUBEQ;
					break;
				case '^':
					c = T_XOREQ;
					break;
				case '|':
					c = T_OREQ;
					break;
				case '<':
					c = T_LSHIFTEQ;
					break;
				case '>':
					c = T_RSHIFTEQ;
					break;
				}
			}
			else
			{
				BACKIN();
				switch (c = *tp)
				{
				case '<':
					c = T_LSHIFT;
					break;
				case '>':
					c = T_RSHIFT;
					break;
				}
			}
		}
		else if (pp.level > 1 || (pp.option & PRESERVE)) PUTCHR(c);
		else if (tp == op)
		{
			if (pp.in->type != IN_BUFFER)
			{
				if (!(pp.option & ALLPOSSIBLE))
					error(1, "%s: invalid character ignored", pptokchr(c));
				goto fsm_top;
			}
			PUTCHR(c);
		}
		else if (*tp == ':')
		{
			PUTCHR(c);
			if (c == '=') error(2, "real programmers use =");
			else c = '+';
		}
		else
		{
			BACKIN();
			c = *tp;
		}
		break;
#endif

	case S_QUAL:
		if ((state = NEXT(state)) != LIT1)
		{
			rp = fsm[state];
			bp = ip;
#if CPP
			qual = 1;
#if COMPATIBLE
			if (!(st & COMPATIBILITY) || c != 'u' && c != 'U')
#endif
				PUTCHR(c);
#else
			switch (c)
			{
			case 'f':
			case 'F':
				qual |= N_FLOAT;
#if COMPATIBLE
				if (!(st & COMPATIBILITY))
#endif
				PUTCHR(c);
				break;
			case 'l':
			case 'L':
				qual |= N_LONG;
				PUTCHR(c);
				break;
			case 'u':
			case 'U':
				qual |= N_UNSIGNED;
#if COMPATIBLE
				if (!(st & COMPATIBILITY))
#endif
				PUTCHR(c);
				break;
			default:
				PUTCHR(c);
				break;
			}
#endif
			goto fsm_get;
		}
#if !CPP
		qual |= N_WIDE;
		if (DOSTRIP()) BACKOUT();
#endif
		/*FALLTHROUGH*/

	case S_LITBEG:
#if CPP
		quot = c;
		rp = fsm[LIT1];
		if (op == tp)
		{
			PPSYNCLINE();
			tp = op;
		}
#else
		if ((quot = c) == '<')
		{
			if (!(st & HEADER) || (pp.option & (HEADEREXPAND|HEADEREXPANDALL)) && pp.in->type != IN_FILE && pp.in->type != IN_BUFFER && pp.in->type != IN_INIT && pp.in->type != IN_RESCAN)
			{
				PUTCHR(c);
				bp = ip;
				rp = fsm[LT1];
				goto fsm_get;
			}
			quot = '>';
			rp = fsm[HDR1];
		}
		else rp = fsm[LIT1];
		if (!DOSTRIP())
#endif
		PUTCHR(c);
		bp = ip;
		goto fsm_get;

	case S_LITEND:
		n = 1;
		if (c != quot)
		{
			if (c != '\n' && c != EOF)
			{
				if (st & (QUOTE|SQUOTE))
				{
					if (!(st & ESCAPE))
					{
						st |= ESCAPE;
						quotquot = c;
					}
					else if (c == quotquot) st &= ~ESCAPE;
				}
				PUTCHR(c);
				bp = ip;
				goto fsm_get;
			}
#if CPP
			if (st & PASSTHROUGH)
			{
				if (c == '\n') goto fsm_newline;
				bp = ip;
				goto fsm_start;
			}
#endif
			m = (st & SKIPCONTROL) && (pp.mode & HOSTED) ? -1 : 1;
			if (c == '\n' && quot == '\'' && (pp.option & STRINGSPAN)) n = 0;
			else
#if COMPATIBLE && !CPP
			if ((st & (COMPATIBILITY|DEFINITION)) != (COMPATIBILITY|DEFINITION))
#endif
			{
				switch (quot)
				{
				case '"':
					if (c == '\n')
					{
						if (!(pp.option & STRINGSPAN) || (st & (COMPATIBILITY|STRICT)) == STRICT)
							error(m, "%s in string", pptokchr(c));
						error_info.line++;
						if (!(pp.option & STRINGSPAN))
						{
							PUTCHR('\\');
							c = 'n';
						}
						else if (pp.option & STRINGSPLIT)
						{
							PUTCHR('\\');
							PUTCHR('n');
							PUTCHR('"');
							PUTCHR('\n');
							c = '"';
						}
						PUTCHR(c);
						bp = ip;
						goto fsm_get;
					}
					error(m, "%s in string", pptokchr(c));
					c = '\n';
					break;
				case '\'':
					if (!(st & DIRECTIVE) || !(pp.mode & (HOSTED|RELAX)))
						error(m, "%s in character constant", pptokchr(c));
					break;
				case '>':
					error(m, "%s in header constant", pptokchr(c));
					break;
				default:
					error(m, "%s in %c quote", pptokchr(c), quot);
					break;
				}
#if !CPP
				if (!DOSTRIP())
#endif
				PUTCHR(quot);
			}
			if (c == '\n')
			{
				UNGETCHR(c);
				c = quot;
			}
		}
		else if (st & (SQUOTE|QUOTE))
		{
			if (!(st & ESCAPE))
			{
				st |= ESCAPE;
				quotquot = c;
			}
			else if (c == quotquot) st &= ~ESCAPE;
			PUTCHR('\\');
			PUTCHR(c);
			bp = ip;
			goto fsm_get;
		}
#if CPP
		else PUTCHR(c);
#else
		else if (!DOSTRIP()) PUTCHR(c);
#endif
#if CATSTRINGS
#if CPP
		if (c == '"' && !(st & (COLLECTING|NOTEXT|PASSTHROUGH|SKIPCONTROL)) && (pp.mode & CATLITERAL))
#else
		if (c == '"' && pp.level == 1 && !(st & (COLLECTING|JOINING|NOTEXT|SKIPCONTROL)) && (pp.mode & CATLITERAL))
#endif
		{
			char*	pptoken;
			long	ppstate;

			pptoken = pp.token;
			pp.token = pp.catbuf;
			*pp.token++ = 0;
			ppstate = (st & STRIP);
			if (DOSTRIP())
				ppstate |= ADD|QUOTE;
			st |= JOINING;
			st &= ~(NEWLINE|STRIP);

			/*
			 * revert to the top level since string
			 * concatenation crosses file boundaries
			 * (allowing intervening directives)
			 */

			pp.level = 0;
			SYNCIN();
			m = n = 0;
			for (;;)
			{
				switch (c = pplex())
				{
				case '\n':
					m++;
					continue;
				case ' ':
					*pp.catbuf = ' ';
					continue;
				case T_WSTRING:
#if !CPP
					qual = N_WIDE;
#endif
					if (ppstate & ADD)
						ppstate &= ~ADD;
					else if (m == n || !(st & SPACEOUT))
						op--;
					else
					{
						n = m;
						*(op - 1) = '\\';
						*op++ = '\n';
					}
					STRCOPY(op, pp.token + 2 + (*pp.token == ' '), s);
					continue;
				case T_STRING:
					if (ppstate & ADD)
						ppstate &= ~ADD;
					else if (m == n || !(st & SPACEOUT))
						op--;
					else
					{
						n = m;
						*(op - 1) = '\\';
						*op++ = '\n';
					}
					STRCOPY(op, pp.token + 1 + (*pp.token == ' '), s);
					continue;
				case 0:
					m = error_info.line ? (error_info.line - 1) : 0;
					*pp.token = 0;
					/*FALLTHROUGH*/
				default:
					if (m)
					{
						if (--m)
						{
							pp.state |= HIDDEN|SYNCLINE;
							pp.hidden += m;
						}
#if COMPATIBLE
						if ((st & COMPATIBILITY) && c == '#' && *(pp.token - 1))
						{
							*(pp.token + 3) = *(pp.token + 2);
							*(pp.token + 2) = *(pp.token + 1);
							*(pp.token + 1) = *pp.token;
							*pp.token = *(pp.token - 1);
						}
						error_info.line--;
						*--pp.token = '\n';
#endif
					}
					else if (*(pp.token - 1))
						pp.token--;
					if (ppisidig(*pp.token))
						*op++ = ' ';
					if (pp.in->type == IN_MACRO && (s = strchr(pp.token, MARK)) && !*(s + 1))
					{
						*(s + 1) = MARK;
						*(s + 2) = 0;
					}
					PUSH_STRING(pp.token);
					pp.state &= ~(JOINING|NEWLINE);
					pp.state |= ppstate & ~(ADD|QUOTE);
					if ((ppstate & (ADD|QUOTE)) == QUOTE)
						op--;
					break;
				}
				break;
			}
			pp.token = pptoken;
			CACHEIN();
			pp.level = 1;
#if !CPP
			c = T_STRING | qual;
			break;
#endif
		}
#endif
#if CPP
		if (n && !(st & (PASSTHROUGH|SKIPCONTROL|NOTEXT)) && c == '\'' && (op - tp) <= 2 && !(pp.mode & (HOSTED|RELAX)))
			error(1, "empty character constant");
		st &= ~(ESCAPE|NEWLINE);
		pp.in->flags |= IN_tokens;
		count(token);
		goto fsm_start;
#else
		st &= ~ESCAPE;
		switch (quot)
		{
		case '\'':
			if (n && !(st & NOTEXT) && (op - tp) <= (DOSTRIP() ? 0 : 2) && !(pp.mode & (HOSTED|RELAX)))
				error(1, "empty character constant");
			c = T_CHARCONST | qual;
			break;
		case '>':
			c = T_HEADER;
			break;
		default:
			if (c == quot)
				c = T_STRING | qual;
			break;
		}
		break;
#endif

	case S_LITESC:
		if (st & (COLLECTING|DIRECTIVE|QUOTE|SQUOTE))
		{
			if (st & ESCAPE)
			{
				PUTCHR('\\');
				if (c == quot) PUTCHR('\\');
			}
			PUTCHR(c);
		}
#if CPP
		else if (st & PASSTHROUGH) PUTCHR(c);
#endif
		else if (pp.option & PRESERVE) PUTCHR(c);
		else switch (c)
		{
		case 'b':
		case 'f':
		case 'n':
		case 'r':
		case 't':
		case '\\':
		case '\'':
		case '"':
		case '?':
			PUTCHR(c);
			break;
#if COMPATIBLE
		case '8':
		case '9':
			if (!(st & COMPATIBILITY)) goto unknown;
			if (st & STRICT) error(1, "%c: invalid character in octal character escape", c);
			/*FALLTHROUGH*/
#endif
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
			n = c - '0';
			for (m = 0; m < 2; m++)
			{
				GET(c, c, tp, xp);
				switch (c)
				{
#if COMPATIBLE
				case '8':
				case '9':
					if (!(st & COMPATIBILITY))
					{
						UNGETCHR(c);
						break;
					}
					if (st & STRICT) error(1, "%c: invalid character in octal character escape", c);
					/*FALLTHROUGH*/
#endif
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
					n = (n << 3) + c - '0';
					continue;
				default:
					UNGETCHR(c);
					break;
				}
				break;
			}
			if (n & ~0777) error(1, "octal character constant too large");
			goto octal;
		case 'a':
			if (pp.option & MODERN)
			{
				PUTCHR(c);
				break;
			}
#if COMPATIBLE
			if (st & COMPATIBILITY) goto unknown;
#endif
			n = CC_bel;
			goto octal;
		case 'v':
			if (pp.option & MODERN)
			{
				PUTCHR(c);
				break;
			}
			n = CC_vt;
			goto octal;
		case 'E':
			if (st & (COMPATIBILITY|STRICT)) goto unknown;
			n = CC_esc;
			goto octal;
		case 'x':
#if COMPATIBLE
			if (st & COMPATIBILITY) goto unknown;
#endif
			n = 0;
			for (m = 0; m < 3; m++)
			{
				GET(c, c, tp, xp);
				switch (c)
				{
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
					n = (n << 4) + c - '0';
					continue;
				case 'a':
				case 'b':
				case 'c':
				case 'd':
				case 'e':
				case 'f':
					n = (n << 4) + c - 'a' + 10;
					continue;
				case 'A':
				case 'B':
				case 'C':
				case 'D':
				case 'E':
				case 'F':
					n = (n << 4) + c - 'A' + 10;
					continue;
				default:
					if (!m) error(1, "\\x%c: invalid character in hexadecimal character constant", c);
					UNGETCHR(c);
					break;
				}
				break;
			}
			if (n & ~0777) error(1, "hexadecimal character constant too large");
		octal:
			PUTCHR(((n >> 6) & 07) + '0');
			PUTCHR(((n >> 3) & 07) + '0');
			PUTCHR((n & 07) + '0');
			break;
		default:
		unknown:
			if (st & (STRICT|WARN)) error(1, "\\%c: non-standard character constant", c);
			PUTCHR(c);
			break;
		}
		state = LIT1;
		goto fsm_begin;

	case S_MACRO:
		BACKIN();
#if CPP
		if (st & (DISABLE|SKIPCONTROL|SKIPMACRO))
		{
			if (st & SKIPMACRO)
				pp.mode |= MARKMACRO;
			st &= ~(NEWLINE|SKIPMACRO);
			pp.in->flags |= IN_tokens;
			count(token);
			goto fsm_start;
		}
		count(candidate);
		SETCHR(0);
		switch (state = INDEX(rp))
		{
		case HIT0:
			tp = op - 1;
			break;
		case HITN:
			bp = tp;
			tp = op - ((pp.truncate && pp.truncate < (HITN - HIT0)) ? (pp.truncate - 1) : (HITN - HIT0));
			while (tp > bp && ppisidig(*(tp - 1))) tp--;
			break;
		default:
			bp = tp;
			if ((tp = op - (state - HIT0)) > bp && *(tp - 1) == 'L') tp--;
			break;
		}
		if (sym = ppsymref(pp.symtab, tp))
		{
			SYNCIN();
			n = ppcall(sym, 0);
			CACHEIN();
			if (n >= 0)
			{
				BACKOUT();
				if (!n)
				{
					if (sp) op = sp;
					else
					{
						s = ip;
						ip = sym->macro->value;
						c = sym->macro->size;
						while (c > 0)
						{
							if (op + c < xp + PPBUFSIZ) n = c;
							else n = xp + PPBUFSIZ - op;
							MEMCPY(op, ip, n);
							c -= n;
							PPCHECKOUT();
						}
						ip = s;
					}
				}
				else if ((sym->flags & SYM_MULTILINE) && pp.linesync)
				{
					SYNCOUT();
					if (!(state & NEWLINE))
						ppputchar('\n');
					(*pp.linesync)(error_info.line, error_info.file);
					CACHEOUT();
				}
			}
		}
		pp.in->flags |= IN_tokens;
		goto fsm_start;
#else
		if (st & (COLLECTING|DEFINITION|DISABLE|SKIPCONTROL|SKIPMACRO))
		{
			if (st & SKIPMACRO)
				pp.mode |= MARKMACRO;
			st &= ~(NEWLINE|NOEXPAND|SKIPMACRO);
			c = T_ID;
			if (pp.level == 1)
			{
				pp.in->flags |= IN_tokens;
				if (st & NOTEXT)
				{
					BACKOUT();
					goto fsm_top;
				}
				if (st & COMPILE)
				{
					SETCHR(0);
					if (pp.truncate && (op - tp) > pp.truncate) tp[pp.truncate] = 0;
					sym = (pp.option & NOHASH) ? ppsymref(pp.symtab, tp) : ppsymset(pp.symtab, tp);
 fsm_noise:
					if (pp.symbol = sym)
					{
						if ((sym->flags & SYM_KEYWORD) && (!pp.truncate || (op - tp) <= pp.truncate || (tp[pp.truncate] = '_', tp[pp.truncate + 1] = 0, pp.symbol = sym = (pp.option & NOHASH) ? ppsymref(pp.symtab, tp) : ppsymset(pp.symtab, tp), 0)))
						{
							c = ((struct ppsymkey*)sym)->lex;
							/*UNDENT*/

#define ADVANCE()	do{if(pp.toknxt<op)pp.token=pp.toknxt;}while(0)

#define NOISE_BRACE		01
#define NOISE_NOSPACEOUT	02
#define NOISE_PAREN		04

	if ((pp.option & NOISE) && ppisnoise(c))
	{
		if (c != T_NOISE)
		{
			int		p;
			int		f;
			char*		pptoken;
			PPCOMMENT	ppcomment;

			SYNCIN();
			pp.toknxt = op;
			f = 0;
			if (!(pp.state & SPACEOUT))
			{
				pp.state |= SPACEOUT;
				f |= NOISE_NOSPACEOUT;
			}
			ppcomment = pp.comment;
			pp.comment = 0;
			op = (pptoken = tp) + MAXTOKEN;
			switch (c)
			{
			case T_X_GROUP:
				m = p = 0;
				quot = 1;
				for (;;)
				{
					ADVANCE();
					switch (c = pplex())
					{
					case '(':
					case '{':
						if (!p)
						{
							if (c == '(')
							{
								if (f & NOISE_PAREN)
								{
									ungetchr(c);
									*--pp.toknxt = 0;
									break;
								}
								f |= NOISE_PAREN;
								p = ')';
							}
							else
							{
								f |= NOISE_BRACE|NOISE_PAREN;
								p = '}';
							}
							n = 1;
							m = c;
						}
						else if (c == m) n++;
						quot = 0;
						continue;
					case ')':
					case '}':
						if (c == p && --n <= 0)
						{
							if (c == '}') break;
							m = '\n';
							p = 0;
						}
						quot = 0;
						continue;
					case ' ':
						continue;
					case '\n':
						error_info.line++;
						if (!m) m = '\n';
						continue;
					case 0:
						break;
					case T_ID:
						if (quot) continue;
						/*FALLTHROUGH*/
					default:
						if (m == '\n')
						{
							/*
							 * NOTE: token expanded again
							 */

							s = pp.toknxt;
							while (s > pp.token) ungetchr(*--s);
							*(pp.toknxt = s) = 0;
							break;
						}
						continue;
					}
					break;
				}
				break;
			case T_X_LINE:
				for (;;)
				{
					ADVANCE();
					switch (pplex())
					{
					case 0:
						break;
					case '\n':
						error_info.line++;
						break;
					default:
						continue;
					}
					break;
				}
				break;
			case T_X_STATEMENT:
				for (;;)
				{
					ADVANCE();
					switch (pplex())
					{
					case 0:
						break;
					case ';':
						ungetchr(';');
						*(pp.toknxt = pp.token) = 0;
						break;
					default:
						continue;
					}
					break;
				}
				break;
			}
			pp.comment = ppcomment;
			if (f & NOISE_NOSPACEOUT)
				pp.state &= ~SPACEOUT;
			CACHEIN();
			tp = pptoken;
			op = pp.toknxt;
			c = T_NOISES;
		}
		if (pp.option & NOISEFILTER)
		{
			BACKOUT();
			goto fsm_top;
		}
	}

							/*INDENT*/
						}
						else if ((pp.option & NOISE) && c == T_ID && strneq(tp, "__builtin_", 10))
						{
							hashlook(pp.symtab, tp, HASH_DELETE, NiL);
							pp.symbol = sym = (struct ppsymbol*)ppkeyset(pp.symtab, tp);
							sym->flags |= SYM_KEYWORD;
							c = ((struct ppsymkey*)sym)->lex = T_BUILTIN;
						}
					}
				}
				goto fsm_symbol;
			}
			goto fsm_check;
		}
		if (pp.level == 1)
		{
			st &= ~(NEWLINE|PASSEOF);
			pp.in->flags |= IN_tokens;
		}
		else st &= ~PASSEOF;
		count(candidate);
		SETCHR(0);
		if (sym = ppsymref(pp.symtab, tp))
		{
			SYNCIN();
			c = ppcall(sym, 1);
			CACHEIN();
			if (c >= 0)
			{
				BACKOUT();
				if ((sym->flags & SYM_MULTILINE) && pp.linesync)
				{
					SYNCOUT();
					(*pp.linesync)(error_info.line, error_info.file);
					CACHEOUT();
				}
				goto fsm_top;
			}
		}
		c = T_ID;
		if (pp.level == 1)
		{
			if (st & NOTEXT)
			{
				BACKOUT();
				goto fsm_top;
			}
			if (st & COMPILE)
			{
				if (pp.truncate && (op - tp) > pp.truncate)
				{
					tp[pp.truncate] = 0;
					sym = 0;
				}
				if (!sym)
				{
					if (!(pp.option & NOHASH)) sym = ppsymset(pp.symtab, tp);
					else if (!(sym = ppsymref(pp.symtab, tp))) goto fsm_symbol;
				}
				goto fsm_noise;
			}
			goto fsm_symbol;
		}
		goto fsm_check;
#endif

	case S_SHARP:
		if (c == '(')
		{
			pp.in->flags |= IN_tokens;
			if ((st & STRICT) && pp.in->type != IN_MACRO && pp.in->type != IN_MULTILINE)
			{
				if (!(pp.mode & HOSTED)) error(1, "non-standard reference to #(...)");
				if (st & STRICT)
				{
					PUTCHR(c);
#if CPP
					st &= ~NEWLINE;
					count(token);
					goto fsm_start;
#else
					break;
#endif
				}
			}
			if (st & (COLLECTING|DEFINITION|DISABLE|SKIPCONTROL))
			{
				PUTCHR(c);
#if CPP
				st &= ~NEWLINE;
				count(token);
				goto fsm_start;
#else
				st &= ~NOEXPAND;
				break;
#endif
			}
			op--;
			SYNC();
			ppbuiltin();
			CACHE();
#if CPP
			count(token);
			goto fsm_start;
#else
			goto fsm_top;
#endif
		}
		BACKIN();
#if CPP
		if (!(st & NEWLINE) || !(pp.in->type & IN_TOP))
		{
 fsm_nondirective:
			st &= ~NEWLINE;
			pp.in->flags |= IN_tokens;
			count(token);
			goto fsm_start;
		}
		if (*(s = tp) != '#')
		{
#if COMPATIBLE
			if ((st & (COMPATIBILITY|TRANSITION)) == COMPATIBILITY) goto fsm_nondirective;
#endif
			while (*s == ' ' || *s == '\t') s++;
			if (*s != '#') goto fsm_nondirective;
		}
		BACKOUT();
#else
		if (!(st & NEWLINE) || (st & DEFINITION) || !(pp.in->type & IN_TOP))
		{
			if (c == '#')
			{
				SKIPIN();
				if (!(st & DEFINITION))
					PUTCHR(c);
				c = T_TOKCAT;
			}
			else if (pp.level == 1 && !(st & (JOINING|SPACEOUT)) && !(pp.option & PRESERVE))
			{
				char*		pptoken;
				char*		oop;
				PPCOMMENT	ppcomment;

				SYNCIN();
				pp.toknxt = oop = op;
				pp.state |= SPACEOUT;
				ppcomment = pp.comment;
				pp.comment = 0;
				op = (pptoken = tp) + MAXTOKEN;
				for (;;)
				{
					ADVANCE();
					switch (pplex())
					{
					case 0:
						break;
					case '\n':
						error_info.line++;
						break;
					default:
						continue;
					}
					break;
				}
				pp.comment = ppcomment;
				pp.state &= ~SPACEOUT;
				CACHEIN();
				tp = pptoken;
				*--op = 0;
				op = oop;
				if (pp.pragma && !(st & NOTEXT))
				{
					*s = 0;
					SYNC();
					(*pp.pragma)(NiL, NiL, NiL, tp, 1);
					CACHE();
				}
				if (!c) BACKIN();
				goto fsm_top;
			}
			else c = '#';
			break;
		}
		if ((st & (COLLECTING|STRICT)) == (COLLECTING|STRICT))
			error(1, "directives in macro call arguments are not portable");
#endif
		if (c == '#' && pp.in->type == IN_RESCAN)
		{
			/*
			 * pass line to pp.pragma VERBATIM
			 */
			
			SKIPIN();
			s = pp.valbuf;
			while ((c = GETCHR()) && c != '\n')
				if ((*s++ = c) == MARK) SKIPIN();
			if (pp.pragma && !(st & NOTEXT))
			{
				*s = 0;
				SYNC();
				(*pp.pragma)(NiL, NiL, NiL, pp.valbuf, 1);
				CACHE();
			}
			if (!c) BACKIN();
#if CPP
			goto fsm_start;
#else
			goto fsm_top;
#endif
		}
		SYNC();
		ppcontrol();
		CACHE();
#if CPP
		if (st & (NOTEXT|SKIPCONTROL))
		{
			if (!sp)
			{
				PPCHECKOUTTP();
				sp = tp;
			}
		}
		else if (sp)
		{
			tp = op = sp;
			sp = 0;
		}
		goto fsm_start;
#else
		goto fsm_top;
#endif

	case S_NL:
#if CPP
		if (op == tp && !(st & JOINING) && pp.in->type == IN_FILE)
		{
			st |= NEWLINE|HIDDEN;
			pp.hidden++;
			error_info.line++;
			goto fsm_start;
		}
#endif
 fsm_newline:
#if CPP
		if (sp)
			op = sp;
		else if (!(pp.in->flags & IN_noguard))
		{
			while (tp < op)
				if ((c = *tp++) != ' ' && c != '\t')
				{
					pp.in->flags |= IN_tokens;
					break;
				}
			c = '\n';
		}
		st |= NEWLINE;
		error_info.line++;
		if (*ip == '\n' && *(ip + 1) != '\n' && !pp.macref && !(st & (ADD|HIDDEN)))
		{
			ip++;
			PUTCHR('\n');
			error_info.line++;
		}
		if ((st & NOTEXT) && ((pp.mode & FILEDEPS) || (pp.option & (DEFINITIONS|PREDEFINITIONS))))
			BACKOUT();
		else
		{
			debug((-5, "token[%d] %03o = %s [line=%d]", pp.level, c, pptokchr(c), error_info.line));
			PUTCHR('\n');
			PPSYNCLINE();
			if (sp)
			{
				PPCHECKOUT();
				sp = op;
			}
		}
		goto fsm_start;
#else
		st |= NEWLINE;
		if (pp.level == 1)
		{
			error_info.line++;
			if (!(st & (JOINING|SPACEOUT)))
			{
				debug((-5, "token[%d] %03o = %s [line=%d]", pp.level, c, pptokchr(c), error_info.line));
				BACKOUT();
				goto fsm_top;
			}
		}
		BACKOUT();
		if (st & SKIPCONTROL)
		{
			error_info.line++;
			st |= HIDDEN;
			pp.hidden++;
			goto fsm_start;
		}
		PUTCHR(c = '\n');
		goto fsm_return;
#endif

#if !CPP
	case S_TOK:
		PUTCHR(c);
		c = TYPE(state) | qual;
		break;

	case S_TOKB:
		BACKIN();
		c = TYPE(state) | qual;
		break;
#endif

	case S_VS:
		PUTCHR(c);
#if !CPP
		if (st & NOVERTICAL)
		{
			error(1, "%s invalid in directives", pptokchr(c));
			st &= ~NOVERTICAL;
		}
#endif
#if COMPATIBLE
		if (st & COMPATIBILITY) st |= NEWLINE;
#endif
#if CPP
		if (!(pp.in->flags & IN_noguard))
			while (tp < op)
				if ((c = *tp++) != ' ' && c != '\t')
				{
					pp.in->flags |= IN_tokens;
					break;
				}
		goto fsm_start;
#else
		bp = ip;
		rp = fsm[WS1];
		goto fsm_get;
#endif

#if !CPP
	case S_WS:
#if COMPATIBLE
		if ((st & (COMPATIBILITY|TRANSITION)) == COMPATIBILITY) st &= ~NEWLINE;
#endif
		if (pp.level == 1)
		{
			if ((st & (COMPATIBILITY|SPACEOUT)) && !(st & TRANSITION))
			{
				if (st & (COMPILE|NOTEXT))
				{
#if CATSTRINGS
					if ((st & (JOINING|NOTEXT|SPACEOUT)) != SPACEOUT)
#else
					if ((st & (NOTEXT|SPACEOUT)) != SPACEOUT)
#endif
					{
						BACKOUT();
						bp = ip - 1;
						rp = fsm[START];
						if (state = rp[c]) goto fsm_next;
						goto fsm_get;
					}
				}
				else
#if CATSTRINGS
				if (!(st & JOINING))
#endif
				{
					tp = op;
					bp = ip - 1;
					rp = fsm[START];
					if (state = rp[c]) goto fsm_next;
					goto fsm_get;
				}
				BACKIN();
				c = ' ';
				goto fsm_return;
			}
			BACKOUT();
			bp = ip - 1;
			rp = fsm[START];
			if (state = rp[c]) goto fsm_next;
			goto fsm_get;
		}
		if (st & (NOSPACE|SKIPCONTROL))
		{
			BACKOUT();
			bp = ip - 1;
			rp = fsm[START];
			if (state = rp[c]) goto fsm_next;
			goto fsm_get;
		}
		if (c != '\n')
		{
			BACKIN();
			c = ' ';
		}
		if (!(pp.option & PRESERVE))
		{
			BACKOUT();
			PUTCHR(c);
		}
		goto fsm_return;
#endif

	default:
		if (state & SPLICE)
		{
			switch (c)
			{
			case MARK:
				/*
				 * internal mark
				 */

				switch (pp.in->type)
				{
				case IN_BUFFER:
				case IN_FILE:
#if !CPP
				case IN_INIT:
#if CATSTRINGS
					if ((st & JOINING) && (!INQUOTE(rp) || quot != '"') || pp.level > 1 && (rp == fsm[START] || INQUOTE(rp)))
#else
					if (pp.level > 1 && (rp == fsm[START] || INQUOTE(rp)))
#endif
						PUTCHR(c);
#endif
					break;
				default:
					switch (GETCHR())
					{
					case 'A':
						if (!(st & (DEFINITION|DISABLE)))
						{
							c = GETCHR();
							SYNCIN();
							if (pp.macp->arg[c - ARGOFFSET][-1])
								PUSH_EXPAND(pp.macp->arg[c - ARGOFFSET], pp.macp->line);
							else
								PUSH_COPY(pp.macp->arg[c - ARGOFFSET], pp.macp->line);
							CACHEIN();
							bp = ip;
							goto fsm_get;
						}
						/*FALLTHROUGH*/
					case 'C':
						c = GETCHR() - ARGOFFSET;
						if (!*(s = pp.macp->arg[c]) && (pp.in->symbol->flags & SYM_VARIADIC) && pp.in->symbol->macro->arity == (c + 1))
						{
							s = ip - 3;
							while (--op > tp && --s > bp && ppisidig(*s));
						}
						else
						{
							SYNCIN();
							PUSH_COPY(s, pp.macp->line);
							CACHEIN();
						}
						bp = ip;
						goto fsm_get;
					case 'F':
						error_info.file = (char*)strtoul(ip, &s, 16);
						debug((-6, "actual sync: file = \"%s\"", error_info.file));
						bp = ip = s + 1;
						goto fsm_get;
					case 'L':
						error_info.line = strtoul(ip, &s, 16);
						debug((-6, "actual sync: line = %d", error_info.line));
						bp = ip = s + 1;
						goto fsm_get;
					case 'Q':
						c = GETCHR();
						SYNCIN();
						PUSH_QUOTE(pp.macp->arg[c - ARGOFFSET], pp.macp->line);
						CACHEIN();
						bp = ip - 1;
						if (st & (COLLECTING|EOF2NL|JOINING)) rp = fsm[START];
						if (state = rp[c = '"']) goto fsm_next;
						goto fsm_get;
					case 'S':
						c = GETCHR();
						SYNCIN();
						PUSH_SQUOTE(pp.macp->arg[c - ARGOFFSET], pp.macp->line);
						CACHEIN();
						bp = ip - 1;
						if (st & COLLECTING) rp = fsm[START];
						if (state = rp[c = '\'']) goto fsm_next;
						goto fsm_get;
					case 'X':
						if (pp.in->type != IN_COPY)
							st |= SKIPMACRO;
						if (pp.level <= 1)
						{
							bp = ip;
							goto fsm_get;
						}
						if (pp.in->type == IN_EXPAND)
						{
							st &= ~SKIPMACRO;
							PUTCHR(c);
							PUTCHR('X');
						}
						c = GETCHR();
						break;
					case 0:
						if ((state &= ~SPLICE) >= TERMINAL) goto fsm_terminal;
						goto fsm_begin;
					default:
#if DEBUG
						error(PANIC, "invalid mark op `%c'", LASTCHR());
						/*FALLTHROUGH*/
					case MARK:
#endif
#if CATSTRINGS
						if ((st & (JOINING|QUOTE)) == JOINING)
						{
							if (!INQUOTE(rp))
								PUTCHR(c);
						}
						else
#endif
#if CPP
						if (rp != fsm[START] && !INQUOTE(rp))
							UNGETCHR(c);
#else
						if (rp != fsm[START] && !INQUOTE(rp))
							UNGETCHR(c);
						else if (pp.level > 1)
							PUTCHR(c);
#endif
						break;
					}
					break;
				}
				break;
			case '?':
				/*
				 * trigraph
				 */

				if (pp.in->type == IN_FILE)
				{
					GET(c, n, tp, xp);
					if (n == '?')
					{
						GET(c, n, tp, xp);
						if (c = trigraph[n])
						{
							if ((st & WARN) && (st & (COMPATIBILITY|TRANSITION)) && !(pp.mode & HOSTED) && !INCOMMENT(rp))
								error(1, "trigraph conversion %c%c%c -> %c%s", '?', '?', n, c, (st & TRANSITION) ? "" : " inhibited");
#if COMPATIBLE
							if ((st & (COMPATIBILITY|TRANSITION)) != COMPATIBILITY)
							{
#endif
							*(bp = ip - 1) = c;
							if (state = rp[c]) goto fsm_next;
							goto fsm_get;
#if COMPATIBLE
							}
#endif
						}
						if (n != EOB) BACKIN();
						UNGETCHR(c = '?');
					}
					else if (n != EOB) BACKIN();
				}
				break;
			case '%':
			case '<':
			case ':':
				/*
				 * digraph = --trigraph
				 */

				if (pp.in->type == IN_FILE && (pp.option & PLUSPLUS))
				{
					m = 0;
					GET(c, n, tp, xp);
					switch (n)
					{
					case '%':
						if (c == '<') m = '{';
						break;
					case '>':
						if (c == '%') m = '}';
						else if (c == ':') m = ']';
						break;
					case ':':
						if (c == '%') m = '#';
						else if (c == '<') m = '[';
						break;
					}
					if (m)
					{
						if ((st & WARN) && (st & (COMPATIBILITY|TRANSITION)) && !(pp.mode & HOSTED) && !INCOMMENT(rp))
							error(1, "digraph conversion %c%c -> %c%s", c, n, m, (st & TRANSITION) ? "" : " inhibited");
#if COMPATIBLE
						if ((st & (COMPATIBILITY|TRANSITION)) != COMPATIBILITY)
						{
#endif
						*(bp = ip - 1) = c = m;
						if (state = rp[c]) goto fsm_next;
						goto fsm_get;
#if COMPATIBLE
						}
#endif
					}
					if (n != EOB) BACKIN();
				}
				break;
			case '\\':
				/*
				 * line splice
				 */

				if (pp.in->type == IN_FILE && (!(pp.option & PLUSSPLICE) || !INCOMMENTXX(rp)))
				{
					m = 0;
					GET(c, n, tp, xp);
					if ((pp.option & SPLICESPACE) && !INQUOTE(rp))
						while (n == ' ')
						{
							GET(c, n, tp, xp);
							m = 1;
						}
					if (n == '\r')
					{
						GET(c, n, tp, xp);
						if (n != '\n' && n != EOB)
							BACKIN();
					}
					if (n == '\n')
					{
#if CPP
						if (INQUOTE(rp))
						{
							if ((pp.option & STRINGSPLIT) && quot == '"')
							{
								PUTCHR(quot);
								PUTCHR(n);
								PUTCHR(quot);
							}
							else if (*pp.lineid)
							{
								PUTCHR(c);
								PUTCHR(n);
							}
							else
							{
								st |= HIDDEN;
								pp.hidden++;
							}
						}
						else
#else
#if COMPATIBLE
						if (!INQUOTE(rp) && (st & (COMPATIBILITY|DEFINITION|TRANSITION)) == (COMPATIBILITY|DEFINITION))
						{
							if (op == tp)
							{
								st |= HIDDEN;
								pp.hidden++;
								error_info.line++;
								if (st & SPACEOUT)
									goto fsm_start;
								c = (pp.option & SPLICECAT) ? '\t' : ' ';
								PUTCHR(c);
								goto fsm_check;
							}
							UNGETCHR(n);
							state &= ~SPLICE;
							goto fsm_terminal;
						}
#endif
#endif
						{
							st |= HIDDEN;
							pp.hidden++;
						}
#if CPP
						spliced++;
#else
						error_info.line++;
#endif
						bp = ip;
						goto fsm_get;
					}
					else if ((n == 'u' || n == 'U') && !INQUOTE(rp))
					{
						PUTCHR(c);
						PUTCHR(n);
						bp = ip;
						goto fsm_get;
					}
#if COMPATIBLE
					else if ((st & (COMPATIBILITY|TRANSITION)) == COMPATIBILITY && (n == '"' || n == '\'') && !INQUOTE(rp))
					{
						PUTCHR(c);
						PUTCHR(n);
						bp = ip;
						goto fsm_get;
					}
#endif
					else if (n != EOB)
						BACKIN();
					if (m && INSPACE(rp))
						UNGETCHR(c);
				}
#if COMPATIBLE
				else if ((st & (COMPATIBILITY|TRANSITION)) == COMPATIBILITY && !INQUOTE(rp))
				{
					GET(c, n, tp, xp);
					if (n == '"' || n == '\'')
					{
						PUTCHR(c);
						PUTCHR(n);
						bp = ip;
						goto fsm_get;
					}
					if (n != EOB)
						BACKIN();
				}
#endif
				break;
			case '\r':
				/*
				 * barf
				 */

				if (pp.in->type == IN_FILE)
				{
					GET(c, n, tp, xp);
					if (n == '\n')
					{
						*(bp = ip - 1) = c = n;
						if (state = rp[c]) goto fsm_next;
						goto fsm_get;
					}
					if (n != EOB) BACKIN();
				}
				break;
			case CC_sub:
				/*
				 * barf & puke
				 */

				if ((pp.option & ZEOF) && pp.in->type == IN_FILE)
				{
					pp.in->flags |= IN_eof;
					c = 0;
					state = S_EOB;
					goto fsm_terminal;
				}
				break;
			}
			if ((state &= ~SPLICE) >= TERMINAL)
				goto fsm_terminal;
			PUTCHR(c);
			goto fsm_begin;
		}
#if CPP
		if (INOPSPACE(rp))
		{
			BACKIN();
			goto fsm_start;
		}
#endif
		PUTCHR(c);
		bp = ip;
		goto fsm_get;
	}
#if !CPP
 fsm_token:
	st &= ~NEWLINE;
	if (pp.level == 1)
	{
		pp.in->flags |= IN_tokens;
		if (st & NOTEXT)
		{
			BACKOUT();
			goto fsm_top;
		}
 fsm_symbol:
		count(token);
	}
 fsm_check:
	if (st & SKIPCONTROL)
	{
		BACKOUT();
		goto fsm_start;
	}
 fsm_return:
#if CPP
	error_info.line += spliced;
#endif
	SETCHR(0);
	debug((-5, "token[%d] %03o = %s", pp.level, c, pptokstr(tp, 0)));
	SYNC();
	pp.level--;
	error_info.indent--;
	return c;
#endif
}

#if CPP && POOL

#include <ls.h>
#include <wait.h>

/*
 * output pool status on exit
 */

static void
poolstatus(void)
{
	error(ERROR_OUTPUT|0, pp.pool.output, "%d", error_info.errors != 0);
}

/*
 * loop on < input output >
 */

static void
pool(void)
{
	char*	ifile;
	char*	ofile;

	ppflushout();
	if (!sfnew(sfstdin, NiL, SF_UNBOUND, pp.pool.input, SF_READ))
		error(ERROR_SYSTEM|3, "cannot dup pool input");

	/*
	 * kick the -I cache
	 */

	ppsearch(".", T_STRING, SEARCH_EXISTS);

	/*
	 * loop on < input output >
	 */

	pp.pool.input = 0;
	while (ifile = sfgetr(sfstdin, '\n', 1))
	{
		if (!(ofile = strchr(ifile, ' ')))
			error(3, "%s: pool output file expected", ifile);
		*ofile++ = 0;
		waitpid(0, NiL, WNOHANG);
		switch (fork())
		{
		case -1:
			error(ERROR_SYSTEM|3, "cannot fork pool");
		case 0:
			atexit(poolstatus);
			error_info.errors = 0;
			error_info.warnings = 0;
			close(0);
			if (open(ifile, O_RDONLY))
				error(ERROR_SYSTEM|3, "%s: cannot read", ifile);
			close(1);
			if (open(ofile, O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH) != 1)
				error(ERROR_SYSTEM|3, "%s: cannot create", ofile);
			pp.outfile = ofile;
			pathcanon(ifile, 0);
			ifile = ppsetfile(ifile)->name;
#if CHECKPOINT
			if (pp.mode & DUMP)
			{
				if (!pp.pragma)
					error(3, "#%s must be enabled for checkpoints", dirname(PRAGMA));
				(*pp.pragma)(dirname(PRAGMA), pp.pass, keyname(X_CHECKPOINT), pp.checkpoint, 1);
			}
#endif
			PUSH_FILE(ifile, 0);
			return;
		}
	}
	while (wait(NiL) != -1);
}

#endif