xref: /titanic_50/usr/src/lib/libpp/common/pplex.c (revision 3e5bc1d795e8c41f3680a71e3954e72d079ee46d)
1 /***********************************************************************
2 *                                                                      *
3 *               This software is part of the ast package               *
4 *          Copyright (c) 1986-2008 AT&T Intellectual Property          *
5 *                      and is licensed under the                       *
6 *                  Common Public License, Version 1.0                  *
7 *                    by AT&T Intellectual Property                     *
8 *                                                                      *
9 *                A copy of the License is available at                 *
10 *            http://www.opensource.org/licenses/cpl1.0.txt             *
11 *         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
12 *                                                                      *
13 *              Information and Software Systems Research               *
14 *                            AT&T Research                             *
15 *                           Florham Park NJ                            *
16 *                                                                      *
17 *                 Glenn Fowler <gsf@research.att.com>                  *
18 *                                                                      *
19 ***********************************************************************/
20 #pragma prototyped
21 /*
22  * Glenn Fowler
23  * AT&T Research
24  *
25  * preprocessor lexical analyzer
26  * standalone and tokenizing lexer combined in one source
27  * define CPP=1 for standalone
28  */
29 
30 #include "pplib.h"
31 #include "ppfsm.h"
32 
33 #if CPP
34 
35 /*
36  * standalone entry point
37  */
38 
39 #define PPCPP_T		void
40 
41 #define START		QUICK
42 #define INMACRO(x)	INQMACRO(x)
43 #define DOSTRIP()	(st&STRIP)
44 
45 #if DEBUG & TRACE_debug
46 static int		hit[LAST-TERMINAL+2];
47 #endif
48 
49 #define BACKIN()	(ip--)
50 #define BACKOUT()	(op=tp)
51 #define CACHE()		do{CACHEINX();CACHEOUTX();st=pp.state;if(!pp.hidden)spliced=0;}while(0)
52 #define CACHEIN()	do{CACHEINX();st=pp.state;if(!pp.hidden)spliced=0;}while(0)
53 #define CACHEINX()	do{ip=pp.in->nextchr;}while(0)
54 #define CACHEOUT()	do{CACHEOUTX();st=pp.state;if(!pp.hidden)spliced=0;}while(0)
55 #define CACHEOUTX()	do{tp=op=pp.outp;xp=pp.oute;if(sp)sp=op;}while(0)
56 #define GETCHR()	(*(unsigned char*)ip++)
57 #define LASTCHR()	(*(ip-1))
58 #define LASTOUT()	((op>pp.outbuf)?*(op-1):pp.lastout)
59 #define SKIPIN()	(ip++)
60 #define PUTCHR(c)	(*op++=(c))
61 #define SETCHR(c)	(*op=(c))
62 #define SYNC()		do{SYNCINX();SYNCOUTX();pp.state=st;}while(0)
63 #define SYNCIN()	do{SYNCINX();pp.state=st;}while(0)
64 #define SYNCINX()	do{pp.in->nextchr=ip;}while(0)
65 #define SYNCOUT()	do{SYNCOUTX();pp.state=st;}while(0)
66 #define SYNCOUTX()	do{if(sp)op=tp=sp;pp.outp=op;}while(0)
67 #define UNGETCHR(c)	(*--ip=(c))
68 
69 #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)
70 #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)
71 #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)
72 
73 #define PPSYNCLINE()	do { \
74 		if ((st & (ADD|HIDDEN)) && !(*pp.control & SKIP)) \
75 		{ \
76 		    if (spliced) \
77 		    { \
78 			error_info.line += spliced; \
79 			spliced = 0; \
80 		    } \
81 		    else \
82 		    { \
83 			if (st & ADD) \
84 			{ \
85 				st &= ~ADD; \
86 				m = pp.addp - pp.addbuf; \
87 				pp.addp = pp.addbuf; \
88 				memcpy(op, pp.addbuf, m); \
89 				op += m; \
90 				PPCHECKOUT(); \
91 			} \
92 			if (pp.linesync) \
93 			{ \
94 				if ((st & SYNCLINE) || pp.hidden >= MAXHIDDEN) \
95 				{ \
96 					pp.hidden = 0; \
97 					st &= ~(HIDDEN|SYNCLINE); \
98 					if (error_info.line) \
99 					{ \
100 						if (LASTOUT() != '\n') \
101 							PUTCHR('\n'); \
102 						SYNCOUT(); \
103 						(*pp.linesync)(error_info.line, error_info.file); \
104 						CACHEOUT(); \
105 					} \
106 				} \
107 				else \
108 				{ \
109 					m = pp.hidden; \
110 					pp.hidden = 0; \
111 					st &= ~HIDDEN; \
112 					while (m-- > 0) \
113 						PUTCHR('\n'); \
114 				} \
115 			} \
116 			else \
117 			{ \
118 				pp.hidden = 0; \
119 				st &= ~HIDDEN; \
120 				PUTCHR('\n'); \
121 			} \
122 		    } \
123 		} \
124 	} while (0)
125 
126 #if POOL
127 
128 /*
129  * <wait.h> is poison here so pool moved to the end
130  */
131 
132 static void	poolstatus(void);
133 static void	pool(void);
134 
135 #endif
136 
137 #else
138 
139 /*
140  * return next pp token
141  *
142  * NOTE: pp.token points to at least MAXTOKEN*2 chars and is
143  *       truncated back to MAXTOKEN on EOB
144  */
145 
146 #define PPCPP_T		int
147 #define ppcpp		pplex
148 
149 #define START		TOKEN
150 #define INMACRO(x)	INTMACRO(x)
151 #define DOSTRIP()	((st&STRIP)||pp.level==1&&(st&(COMPILE|JOINING))==COMPILE&&!(pp.option&PRESERVE))
152 
153 #define st		pp.state
154 #define tp		pp.token
155 #define xp		&pp.token[MAXTOKEN]
156 
157 #define BACKIN()	(ip--)
158 #define BACKOUT()	(op=pp.token)
159 #define CACHE()		do{CACHEIN();CACHEOUT();}while(0)
160 #define CACHEIN()	(ip=pp.in->nextchr)
161 #define CACHEOUT()	(op=pp.token)
162 #define GETCHR()	(*(unsigned char*)ip++)
163 #define LASTCHR()	(*(ip-1))
164 #define PUTCHR(c)	(*op++=(c))
165 #define SETCHR(c)	(*op=(c))
166 #define SKIPIN()	(ip++)
167 #define SYNC()		do{SYNCIN();SYNCOUT();}while(0)
168 #define SYNCIN()	(pp.in->nextchr=ip)
169 #define SYNCOUT()	(pp.toknxt=op)
170 #define UNGETCHR(c)	(*--ip=(c))
171 
172 #endif
173 
174 PPCPP_T
175 ppcpp(void)
176 {
177 	register short*		rp;
178 	register char*		ip;
179 	register int		state;
180 	register int		c;
181 	register char*		op;
182 	char*			bp;
183 	int			n;
184 	int			m;
185 	int			quot;
186 	int			quotquot;
187 	int			comdelim = 0;
188 	int			comstart = 0;
189 	int			comwarn = 0;
190 	char*			s;
191 	struct ppsymbol*	sym;
192 #if CPP
193 	register long		st;
194 	char*			tp;
195 	char*			xp;
196 	char*			sp = 0;
197 	int			qual = 0;
198 	int			spliced = 0;
199 #else
200 	int			qual;
201 #endif
202 
203 #if CPP
204 #if POOL
205  fsm_pool:
206 #endif
207 #else
208 	count(pplex);
209 #endif
210 	error_info.indent++;
211 	pp.level++;
212 	CACHE();
213 #if !CPP
214  fsm_top:
215 	qual = 0;
216 #endif
217  fsm_start:
218 #if CPP
219 	PPCHECKOUTSP();
220 	tp = op;
221 #endif
222 	state = START;
223  fsm_begin:
224 	bp = ip;
225 	do
226 	{
227 		rp = fsm[state];
228  fsm_get:
229 		while (!(state = rp[c = GETCHR()]));
230  fsm_next:
231 		;
232 	} while (state > 0);
233 	if (((state = ~state) != S_COMMENT || pp.comment || c == '/' && !INCOMMENT(rp)) && (n = ip - bp - 1) > 0)
234 	{
235 		ip = bp;
236 #if CPP
237 		if (op == tp && (st & (ADD|HIDDEN)) && !(st & PASSTHROUGH) && !(pp.option & PRESERVE))
238 			switch (TERM(state))
239 			{
240 			case S_SHARP:
241 				break;
242 			case S_CHRB:
243 			case S_NL:
244 				if (*ip == '\n')
245 					break;
246 				/*FALLTHROUGH*/
247 			default:
248 				if ((pp.option & PRESERVE) && !(st & NEWLINE) && c != '\n')
249 					break;
250 				PPSYNCLINE();
251 				tp = op;
252 				break;
253 			}
254 #endif
255 		MEMCPY(op, ip, n);
256 		ip++;
257 	}
258 	count(terminal);
259 #if CPP && (DEBUG & TRACE_debug)
260 	hit[(state & SPLICE) ? (elementsof(hit) - 1) : (TERM(state) - TERMINAL)]++;
261 #endif
262  fsm_terminal:
263 	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)));
264 	switch (TERM(state))
265 	{
266 
267 #if !CPP
268 	case S_CHR:
269 		PUTCHR(c);
270 		break;
271 #endif
272 
273 	case S_CHRB:
274 		BACKIN();
275 #if CPP
276 		st &= ~NEWLINE;
277 		pp.in->flags |= IN_tokens;
278 		count(token);
279 		goto fsm_start;
280 #else
281 		c = *tp;
282 		break;
283 #endif
284 
285 	case S_COMMENT:
286 		switch (c)
287 		{
288 		case '\n':
289 			if (!INCOMMENTXX(rp))
290 			{
291 				qual = 0;
292 				if (!comstart) comstart = comdelim = error_info.line;
293 				error_info.line++;
294 				if (pp.comment) PUTCHR(c);
295 				else BACKOUT();
296 #if CPP
297 				rp = fsm[COM2];
298 				bp = ip;
299 				goto fsm_get;
300 #else
301 				state = COM2;
302 				goto fsm_begin;
303 #endif
304 			}
305 			else if (comwarn < 0 && !(pp.mode & HOSTED))
306 				error(1, "/* appears in // comment");
307 			break;
308 		case '*':
309 			if (!comwarn && !(pp.mode & HOSTED))
310 			{
311 				if (INCOMMENTXX(rp)) comwarn = -1;
312 				else if (comstart && comstart != error_info.line)
313 				{
314 					if (qual || comdelim < error_info.line - 1)
315 					{
316 						error(1, "/* appears in /* ... */ comment starting at line %d", comstart);
317 						comwarn = 1;
318 					}
319 					else comdelim = error_info.line;
320 				}
321 			}
322  fsm_comment:
323 			PUTCHR(c);
324 #if CPP
325 			rp = fsm[INCOMMENTXX(rp) ? COM5 : COM3];
326 			bp = ip;
327 			goto fsm_get;
328 #else
329 			state = INCOMMENTXX(rp) ? COM5 : COM3;
330 			goto fsm_begin;
331 #endif
332 		case '/':
333 			if (!INCOMMENT(rp))
334 			{
335 				if (!(pp.mode & HOSTED))
336 					error(1, "*/ appears outside of comment");
337 				BACKIN();
338 #if CPP
339 				st &= ~NEWLINE;
340 				pp.in->flags |= IN_tokens;
341 				count(token);
342 				goto fsm_start;
343 #else
344 				c = '*';
345 				if (!pp.comment) PUTCHR(c);
346 				goto fsm_token;
347 #endif
348 			}
349 			else if (INCOMMENTXX(rp))
350 			{
351 				if (!(pp.mode & HOSTED))
352 				{
353 					if (comwarn < 0) comwarn = 0;
354 					else if (!comwarn)
355 					{
356 						comwarn = 1;
357 						error(1, "*/ appears in // comment");
358 					}
359 				}
360 				goto fsm_comment;
361 			}
362 			break;
363 		case EOF:
364 			BACKIN();
365 			if (!(pp.mode & HOSTED))
366 			{
367 				if (comstart) error(2, "unterminated /* ... */ comment starting at line %d", comstart);
368 				else if (INCOMMENTXX(rp)) error(2, "unterminated // ... comment");
369 				else error(2, "unterminated /* ... */ comment");
370 			}
371 			break;
372 		}
373 #if CPP
374 		if (!pp.comment || sp)
375 		{
376 #if COMPATIBLE
377 			if (!(pp.state & COMPATIBILITY) || *bp == ' ' || *bp == '\t')
378 #endif
379 			{
380 				BACKOUT();
381 				PUTCHR(' ');
382 				tp = op;
383 			}
384 		}
385 		else if (pp.in->type & IN_TOP)
386 #else
387 		if (pp.comment && !(st & (COLLECTING|DIRECTIVE|JOINING)) && !(*pp.control & SKIP) && (pp.in->type & IN_TOP))
388 #endif
389 		{
390 			st &= ~HIDDEN;
391 			pp.hidden = 0;
392 			*(op - (c != '\n')) = 0;
393 			m = (op - (c != '\n') - tp > MAXTOKEN - 6) ? (error_info.line - MAXHIDDEN) : 0;
394 			BACKOUT();
395 			SYNC();
396 			while (*tp != '/') tp++;
397 			(*pp.comment)(c == '\n' ? "//" : "/*", tp + 2, c == '\n' ? "" : (st & HEADER) ? "*/\n" : "*/", comstart ? comstart : error_info.line);
398 			CACHE();
399 			comstart = m;
400 		}
401 		if (comstart)
402 		{
403 			st |= HIDDEN;
404 			pp.hidden += error_info.line - comstart;
405 			comstart = 0;
406 		}
407 		qual = comwarn = comdelim = 0;
408 		BACKOUT();
409 		if (c == '\n') goto fsm_newline;
410 		if ((st & PASSTHROUGH) && ((st & (HIDDEN|NEWLINE)) || *ip == '\n'))
411 		{
412 			if (*ip == '\n')
413 				ip++;
414 			goto fsm_newline;
415 		}
416 #if COMPATIBLE
417 		if ((st & (COMPATIBILITY|TRANSITION)) == COMPATIBILITY) st &= ~NEWLINE;
418 #endif
419 #if !CPP
420 		if (pp.level > 1 && !(st & (NOSPACE|SKIPCONTROL)))
421 		{
422 #if COMPATIBLE
423 			c = ((st & (COMPATIBILITY|DEFINITION)) == ((COMPATIBILITY|DEFINITION))) ? '\t' : ' ';
424 #else
425 			c = ' ';
426 #endif
427 			goto fsm_return;
428 		}
429 #endif
430 		goto fsm_start;
431 
432 	case S_EOB:
433 		if (c)
434 		{
435 			if (state = fsm[TERMINAL][INDEX(rp)+1])
436 				goto fsm_terminal;
437 #if CPP
438 #if POOL
439 			if (pp.pool.input)
440 			{
441 				BACKIN();
442 				SYNC();
443 				pool();
444 				CACHE();
445 				goto fsm_pool;
446 			}
447 #endif
448 			SYNCOUT();
449 			return;
450 #else
451 			BACKIN();
452 			c = 0;
453 			goto fsm_return;
454 #endif
455 		}
456 		{
457 			register struct ppinstk*	cur = pp.in;
458 			register struct ppinstk*	prv = pp.in->prev;
459 
460 #if CPP
461 			if (sp) op = sp;
462 #endif
463 			switch (cur->type)
464 			{
465 			case IN_BUFFER:
466 			case IN_INIT:
467 			case IN_RESCAN:
468 #if CPP
469 				if (prv)
470 #else
471 				if (!(st & PASSEOF) && prv)
472 #endif
473 				{
474 					if (cur->type == IN_RESCAN || cur->type == IN_BUFFER)
475 					{
476  fsm_pop:
477 #if PROTOTYPE
478 						if (cur->flags & IN_prototype)
479 							pppclose(cur->buffer + PPBAKSIZ);
480 						else
481 #endif
482 						if (!(cur->flags & IN_static))
483 							free(cur->buffer);
484 					}
485 					while (pp.control-- != cur->control)
486 						error(2, "#%s on line %d has no #%s", dirname(IF), GETIFLINE(pp.control+1), dirname(ENDIF));
487 					st |= NEWLINE;
488 					error_info.file = cur->file;
489 					error_info.line = cur->line;
490 					pp.hidden = 0;
491 #if CPP
492 					spliced = 0;
493 #endif
494 					if (cur->flags & IN_hosted)
495 					{
496 						pp.mode |= HOSTED;
497 						pp.flags |= PP_hosted;
498 					}
499 					else
500 					{
501 						pp.mode &= ~HOSTED;
502 						pp.flags &= ~PP_hosted;
503 					}
504 #if !CPP && CATSTRINGS
505 					if (st & JOINING) st |= HIDDEN|SYNCLINE;
506 					else
507 #endif
508 					{
509 						st &= ~(HIDDEN|SYNCLINE);
510 						switch (cur->type)
511 						{
512 						case IN_BUFFER:
513 						case IN_INIT:
514 							if (!prv->prev) break;
515 							/*FALLTHROUGH*/
516 						case IN_FILE:
517 						case IN_RESCAN:
518 							if (prv->type == IN_FILE || cur->type == IN_FILE && (prv->type == IN_RESCAN || prv->type == IN_MULTILINE))
519 							{
520 								if (pp.linesync && (cur->type != IN_RESCAN || (cur->flags & IN_sync)))
521 								{
522 									POP();
523 									SYNCOUT();
524 									(*pp.linesync)(error_info.line, error_info.file);
525 									CACHEOUT();
526 									prv = pp.in;
527 								}
528 							}
529 #if DEBUG
530 							else if (!prv->prev)
531 							{
532 								/*UNDENT*/
533 	c = 0;
534 #if DEBUG & TRACE_count
535 	if (pp.test & TEST_count)
536 	{
537 		c = 1;
538 		sfprintf(sfstderr, "\n");
539 		sfprintf(sfstderr, "%7d: pplex calls\n", pp.counter.pplex);
540 		sfprintf(sfstderr, "%7d: terminal states\n", pp.counter.terminal);
541 		sfprintf(sfstderr, "%7d: emitted tokens\n", pp.counter.token);
542 		sfprintf(sfstderr, "%7d: input stream pushes\n", pp.counter.push);
543 		sfprintf(sfstderr, "%7d: macro candidates\n", pp.counter.candidate);
544 		sfprintf(sfstderr, "%7d: macro expansions\n", pp.counter.macro);
545 		sfprintf(sfstderr, "%7d: function macros\n", pp.counter.function);
546 	}
547 #endif
548 #if CPP && (DEBUG & TRACE_debug)
549 	if (pp.test & TEST_hit)
550 	{
551 		c = 1;
552 		sfprintf(sfstderr, "\n");
553 		if (hit[elementsof(hit) - 1])
554 			sfprintf(sfstderr, "%7d: SPLICE\n", hit[elementsof(hit) - 1]);
555 		for (n = 0; n < elementsof(hit) - 1; n++)
556 			if (hit[n])
557 				sfprintf(sfstderr, "%7d: %s\n", hit[n], pplexstr(TERMINAL + n));
558 	}
559 #endif
560 	if (pp.test & (TEST_hashcount|TEST_hashdump))
561 	{
562 		c = 1;
563 		sfprintf(sfstderr, "\n");
564 		hashdump(NiL, (pp.test & TEST_hashdump) ? HASH_BUCKET : 0);
565 	}
566 	if (c) sfprintf(sfstderr, "\n");
567 								/*INDENT*/
568 							}
569 #endif
570 							break;
571 						}
572 					}
573 #if CHECKPOINT
574 					if (cur->index)
575 					{
576 						SYNCOUT();
577 						cur->index->end = ppoffset();
578 						cur->index = 0;
579 						CACHEOUT();
580 					}
581 #endif
582 					POP();
583 					bp = ip;
584 					tp = op;
585 					goto fsm_get;
586 				}
587 				c = EOF;
588 				break;
589 			case IN_COPY:
590 				if (prv)
591 				{
592 					error_info.line = cur->line;
593 					if (!(prv->symbol->flags & SYM_MULTILINE))
594 						prv->symbol->flags |= SYM_DISABLED;
595 					POP();
596 					bp = ip;
597 					goto fsm_get;
598 				}
599 				c = EOF;
600 				break;
601 			case IN_EXPAND:
602 				if (prv)
603 				{
604 					error_info.line = cur->line;
605 					free(cur->buffer);
606 					POP();
607 					bp = ip;
608 					goto fsm_get;
609 				}
610 				c = EOF;
611 				break;
612 			case IN_FILE:
613 				FGET(c, c, tp, xp);
614 				if (c == EOB)
615 				{
616 #if CPP
617 					if ((st & (NOTEXT|HIDDEN)) == HIDDEN && LASTOUT() != '\n')
618 						PUTCHR('\n');
619 					if (prv)
620 #else
621 					if (st & EOF2NL)
622 					{
623 						st &= ~EOF2NL;
624 						*(ip - 1) = c = '\n';
625 					}
626 					else if (!(st & (FILEPOP|PASSEOF)) && prv)
627 #endif
628 					{
629 						if (!(cur->flags & IN_newline))
630 						{
631 							cur->flags |= IN_newline;
632 							if ((pp.mode & (HOSTED|PEDANTIC)) == PEDANTIC && LASTCHR() != '\f' && LASTCHR() != CC_sub)
633 								error(1, "file does not end with %s", pptokchr('\n'));
634 							*(ip - 1) = c = '\n';
635 						}
636 						else
637 						{
638 							if (!(cur->flags & (IN_noguard|IN_tokens)) && cur->symbol)
639 								ppmultiple(ppsetfile(error_info.file), cur->symbol);
640 							if (cur->fd >= 0)
641 								close(cur->fd);
642 							if (pp.incref && !(pp.mode & INIT))
643 							{
644 								SYNCOUT();
645 								(*pp.incref)(error_info.file, cur->file, error_info.line - 1, PP_SYNC_POP);
646 								CACHEOUT();
647 							}
648 							goto fsm_pop;
649 						}
650 					}
651 					else
652 						c = EOF;
653 				}
654 				break;
655 			case IN_MACRO:
656 			case IN_MULTILINE:
657 #if !CPP
658 				if (!(st & PASSEOF))
659 #endif
660 #if COMPATIBLE
661 				if (prv && (!INMACRO(rp) || (st & (COMPATIBILITY|TRANSITION)) == COMPATIBILITY && ppismac(*prv->nextchr)))
662 #else
663 				if (prv && !INMACRO(rp))
664 #endif
665 				{
666 					if (cur->type == IN_MULTILINE)
667 					{
668 						while (pp.control-- != cur->control)
669 							error(2, "#%s on line %d has no #%s", dirname(IF), GETIFLINE(pp.control+1), dirname(ENDIF));
670 						free(cur->buffer);
671 						error_info.file = cur->file;
672 						error_info.line = cur->line;
673 						if (pp.linesync)
674 						{
675 							SYNCOUT();
676 							(*pp.linesync)(error_info.line, error_info.file);
677 							CACHEOUT();
678 						}
679 					}
680 					cur->symbol->flags &= ~SYM_DISABLED;
681 					if (cur->symbol->flags & SYM_FUNCTION)
682 						popframe(pp.macp);
683 					POP();
684 #if CPP
685 					if (!(st & COMPATIBILITY) && ppisidig(*(op - 1)) && ppisidig(*ip)) UNGETCHR(' ');
686 #endif
687 					bp = ip;
688 					goto fsm_get;
689 				}
690 				c = EOF;
691 				break;
692 			case IN_QUOTE:
693 				if (prv)
694 				{
695 					error_info.line = cur->line;
696 					st &= ~(ESCAPE|QUOTE);
697 					POP();
698 					c = '"';
699 				}
700 				else c = EOF;
701 				break;
702 			case IN_SQUOTE:
703 				if (prv)
704 				{
705 					error_info.line = cur->line;
706 					st &= ~(ESCAPE|SQUOTE);
707 					POP();
708 					c = '\'';
709 				}
710 				else c = EOF;
711 				break;
712 			case IN_STRING:
713 #if CPP
714 				if (prv)
715 #else
716 				if (!(st & PASSEOF) && !(cur->flags & IN_expand) && prv)
717 #endif
718 				{
719 					if (cur->flags & IN_disable) st |= DISABLE;
720 					else st &= ~DISABLE;
721 					POP();
722 					bp = ip;
723 					goto fsm_get;
724 				}
725 				c = EOF;
726 				break;
727 			default:
728 				c = EOF;
729 				break;
730 			}
731 		}
732 		bp = ip - 1;
733 		if (state = rp[c]) goto fsm_next;
734 		goto fsm_get;
735 
736 #if !CPP
737 	case S_HUH:
738 		if (INOPSPACE(rp))
739 		{
740 			if (c == '=')
741 			{
742 #if PROTOTYPE
743 				if (pp.in->flags & IN_prototype) PUTCHR(c);
744 				else
745 				{
746 #endif
747 					while (*(op - 1) == ' ' || *(op - 1) == '\t') op--;
748 					PUTCHR(c);
749 					if (st & (STRICT|WARN)) error(1, "%-*.*s: space ignored in operator", op - tp, op - tp, tp);
750 #if PROTOTYPE
751 				}
752 #endif
753 				switch (*tp)
754 				{
755 				case '/':
756 					c = T_DIVEQ;
757 					break;
758 				case '%':
759 					c = T_MODEQ;
760 					break;
761 				case '&':
762 					c = T_ANDEQ;
763 					break;
764 				case '*':
765 					c = T_MPYEQ;
766 					break;
767 				case '+':
768 					c = T_ADDEQ;
769 					break;
770 				case '-':
771 					c = T_SUBEQ;
772 					break;
773 				case '^':
774 					c = T_XOREQ;
775 					break;
776 				case '|':
777 					c = T_OREQ;
778 					break;
779 				case '<':
780 					c = T_LSHIFTEQ;
781 					break;
782 				case '>':
783 					c = T_RSHIFTEQ;
784 					break;
785 				}
786 			}
787 			else
788 			{
789 				BACKIN();
790 				switch (c = *tp)
791 				{
792 				case '<':
793 					c = T_LSHIFT;
794 					break;
795 				case '>':
796 					c = T_RSHIFT;
797 					break;
798 				}
799 			}
800 		}
801 		else if (pp.level > 1 || (pp.option & PRESERVE)) PUTCHR(c);
802 		else if (tp == op)
803 		{
804 			if (pp.in->type != IN_BUFFER)
805 			{
806 				if (!(pp.option & ALLPOSSIBLE))
807 					error(1, "%s: invalid character ignored", pptokchr(c));
808 				goto fsm_top;
809 			}
810 			PUTCHR(c);
811 		}
812 		else if (*tp == ':')
813 		{
814 			PUTCHR(c);
815 			if (c == '=') error(2, "real programmers use =");
816 			else c = '+';
817 		}
818 		else
819 		{
820 			BACKIN();
821 			c = *tp;
822 		}
823 		break;
824 #endif
825 
826 	case S_QUAL:
827 		if ((state = NEXT(state)) != LIT1)
828 		{
829 			rp = fsm[state];
830 			bp = ip;
831 #if CPP
832 			qual = 1;
833 #if COMPATIBLE
834 			if (!(st & COMPATIBILITY) || c != 'u' && c != 'U')
835 #endif
836 				PUTCHR(c);
837 #else
838 			switch (c)
839 			{
840 			case 'f':
841 			case 'F':
842 				qual |= N_FLOAT;
843 #if COMPATIBLE
844 				if (!(st & COMPATIBILITY))
845 #endif
846 				PUTCHR(c);
847 				break;
848 			case 'l':
849 			case 'L':
850 				qual |= N_LONG;
851 				PUTCHR(c);
852 				break;
853 			case 'u':
854 			case 'U':
855 				qual |= N_UNSIGNED;
856 #if COMPATIBLE
857 				if (!(st & COMPATIBILITY))
858 #endif
859 				PUTCHR(c);
860 				break;
861 			default:
862 				PUTCHR(c);
863 				break;
864 			}
865 #endif
866 			goto fsm_get;
867 		}
868 #if !CPP
869 		qual |= N_WIDE;
870 		if (DOSTRIP()) BACKOUT();
871 #endif
872 		/*FALLTHROUGH*/
873 
874 	case S_LITBEG:
875 #if CPP
876 		quot = c;
877 		rp = fsm[LIT1];
878 		if (op == tp)
879 		{
880 			PPSYNCLINE();
881 			tp = op;
882 		}
883 #else
884 		if ((quot = c) == '<')
885 		{
886 			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)
887 			{
888 				PUTCHR(c);
889 				bp = ip;
890 				rp = fsm[LT1];
891 				goto fsm_get;
892 			}
893 			quot = '>';
894 			rp = fsm[HDR1];
895 		}
896 		else rp = fsm[LIT1];
897 		if (!DOSTRIP())
898 #endif
899 		PUTCHR(c);
900 		bp = ip;
901 		goto fsm_get;
902 
903 	case S_LITEND:
904 		n = 1;
905 		if (c != quot)
906 		{
907 			if (c != '\n' && c != EOF)
908 			{
909 				if (st & (QUOTE|SQUOTE))
910 				{
911 					if (!(st & ESCAPE))
912 					{
913 						st |= ESCAPE;
914 						quotquot = c;
915 					}
916 					else if (c == quotquot) st &= ~ESCAPE;
917 				}
918 				PUTCHR(c);
919 				bp = ip;
920 				goto fsm_get;
921 			}
922 #if CPP
923 			if ((st & PASSTHROUGH) || (pp.option & PRESERVE))
924 			{
925 				if (c == '\n') goto fsm_newline;
926 				bp = ip;
927 				goto fsm_start;
928 			}
929 #endif
930 			m = (st & SKIPCONTROL) && (pp.mode & HOSTED) ? -1 : 1;
931 			if (c == '\n' && quot == '\'' && (pp.option & STRINGSPAN)) n = 0;
932 			else
933 #if COMPATIBLE && !CPP
934 			if ((st & (COMPATIBILITY|DEFINITION)) != (COMPATIBILITY|DEFINITION))
935 #endif
936 			{
937 				switch (quot)
938 				{
939 				case '"':
940 					if (c == '\n')
941 					{
942 						if (!(pp.option & STRINGSPAN) || (st & (COMPATIBILITY|STRICT)) == STRICT)
943 							error(m, "%s in string", pptokchr(c));
944 						error_info.line++;
945 						if (!(pp.option & STRINGSPAN))
946 						{
947 							PUTCHR('\\');
948 							c = 'n';
949 						}
950 						else if (pp.option & STRINGSPLIT)
951 						{
952 							PUTCHR('\\');
953 							PUTCHR('n');
954 							PUTCHR('"');
955 							PUTCHR('\n');
956 							c = '"';
957 						}
958 						PUTCHR(c);
959 						bp = ip;
960 						goto fsm_get;
961 					}
962 					error(m, "%s in string", pptokchr(c));
963 					c = '\n';
964 					break;
965 				case '\'':
966 					if (!(st & DIRECTIVE) || !(pp.mode & (HOSTED|RELAX)))
967 						error(m, "%s in character constant", pptokchr(c));
968 					break;
969 				case '>':
970 					error(m, "%s in header constant", pptokchr(c));
971 					break;
972 				default:
973 					error(m, "%s in %c quote", pptokchr(c), quot);
974 					break;
975 				}
976 #if !CPP
977 				if (!DOSTRIP())
978 #endif
979 				PUTCHR(quot);
980 			}
981 			if (c == '\n')
982 			{
983 				UNGETCHR(c);
984 				c = quot;
985 			}
986 		}
987 		else if (st & (SQUOTE|QUOTE))
988 		{
989 			if (!(st & ESCAPE))
990 			{
991 				st |= ESCAPE;
992 				quotquot = c;
993 			}
994 			else if (c == quotquot) st &= ~ESCAPE;
995 			PUTCHR('\\');
996 			PUTCHR(c);
997 			bp = ip;
998 			goto fsm_get;
999 		}
1000 #if CPP
1001 		else PUTCHR(c);
1002 #else
1003 		else if (!DOSTRIP()) PUTCHR(c);
1004 #endif
1005 #if CATSTRINGS
1006 #if CPP
1007 		if (c == '"' && !(st & (COLLECTING|NOTEXT|PASSTHROUGH|SKIPCONTROL)) && (pp.mode & CATLITERAL))
1008 #else
1009 		if (c == '"' && pp.level == 1 && !(st & (COLLECTING|JOINING|NOTEXT|SKIPCONTROL)) && (pp.mode & CATLITERAL))
1010 #endif
1011 		{
1012 			char*	pptoken;
1013 			long	ppstate;
1014 
1015 			pptoken = pp.token;
1016 			pp.token = pp.catbuf;
1017 			*pp.token++ = 0;
1018 			ppstate = (st & STRIP);
1019 			if (DOSTRIP())
1020 				ppstate |= ADD|QUOTE;
1021 			st |= JOINING;
1022 			st &= ~(NEWLINE|STRIP);
1023 
1024 			/*
1025 			 * revert to the top level since string
1026 			 * concatenation crosses file boundaries
1027 			 * (allowing intervening directives)
1028 			 */
1029 
1030 			pp.level = 0;
1031 			SYNCIN();
1032 			m = n = 0;
1033 			for (;;)
1034 			{
1035 				switch (c = pplex())
1036 				{
1037 				case '\n':
1038 					m++;
1039 					continue;
1040 				case ' ':
1041 					*pp.catbuf = ' ';
1042 					continue;
1043 				case T_WSTRING:
1044 #if !CPP
1045 					qual = N_WIDE;
1046 #endif
1047 					if (ppstate & ADD)
1048 						ppstate &= ~ADD;
1049 					else if (m == n || !(st & SPACEOUT))
1050 						op--;
1051 					else
1052 					{
1053 						n = m;
1054 						*(op - 1) = '\\';
1055 						*op++ = '\n';
1056 					}
1057 					STRCOPY(op, pp.token + 2 + (*pp.token == ' '), s);
1058 					continue;
1059 				case T_STRING:
1060 					if (ppstate & ADD)
1061 						ppstate &= ~ADD;
1062 					else if (m == n || !(st & SPACEOUT))
1063 						op--;
1064 					else
1065 					{
1066 						n = m;
1067 						*(op - 1) = '\\';
1068 						*op++ = '\n';
1069 					}
1070 					STRCOPY(op, pp.token + 1 + (*pp.token == ' '), s);
1071 					continue;
1072 				case 0:
1073 					m = error_info.line ? (error_info.line - 1) : 0;
1074 					*pp.token = 0;
1075 					/*FALLTHROUGH*/
1076 				default:
1077 					if (m)
1078 					{
1079 						if (--m)
1080 						{
1081 							pp.state |= HIDDEN|SYNCLINE;
1082 							pp.hidden += m;
1083 						}
1084 #if COMPATIBLE
1085 						if ((st & COMPATIBILITY) && c == '#' && *(pp.token - 1))
1086 						{
1087 							*(pp.token + 3) = *(pp.token + 2);
1088 							*(pp.token + 2) = *(pp.token + 1);
1089 							*(pp.token + 1) = *pp.token;
1090 							*pp.token = *(pp.token - 1);
1091 						}
1092 						error_info.line--;
1093 						*--pp.token = '\n';
1094 #endif
1095 					}
1096 					else if (*(pp.token - 1))
1097 						pp.token--;
1098 					if (ppisidig(*pp.token))
1099 						*op++ = ' ';
1100 					if (pp.in->type == IN_MACRO && (s = strchr(pp.token, MARK)) && !*(s + 1))
1101 					{
1102 						*(s + 1) = MARK;
1103 						*(s + 2) = 0;
1104 					}
1105 					PUSH_STRING(pp.token);
1106 					pp.state &= ~(JOINING|NEWLINE);
1107 					pp.state |= ppstate & ~(ADD|QUOTE);
1108 					if ((ppstate & (ADD|QUOTE)) == QUOTE)
1109 						op--;
1110 					break;
1111 				}
1112 				break;
1113 			}
1114 			pp.token = pptoken;
1115 			CACHEIN();
1116 			pp.level = 1;
1117 #if !CPP
1118 			c = T_STRING | qual;
1119 			break;
1120 #endif
1121 		}
1122 #endif
1123 #if CPP
1124 		if (n && !(st & (PASSTHROUGH|SKIPCONTROL|NOTEXT)) && c == '\'' && (op - tp) <= 2 && !(pp.mode & (HOSTED|RELAX)))
1125 			error(1, "empty character constant");
1126 		if (pp.option & PRESERVE)
1127 			st &= ~ESCAPE;
1128 		else
1129 			st &= ~(ESCAPE|NEWLINE);
1130 		pp.in->flags |= IN_tokens;
1131 		count(token);
1132 		goto fsm_start;
1133 #else
1134 		st &= ~ESCAPE;
1135 		switch (quot)
1136 		{
1137 		case '\'':
1138 			if (n && !(st & NOTEXT) && (op - tp) <= (DOSTRIP() ? 0 : 2) && !(pp.mode & (HOSTED|RELAX)))
1139 				error(1, "empty character constant");
1140 			c = T_CHARCONST | qual;
1141 			break;
1142 		case '>':
1143 			c = T_HEADER;
1144 			break;
1145 		default:
1146 			if (c == quot)
1147 				c = T_STRING | qual;
1148 			break;
1149 		}
1150 		break;
1151 #endif
1152 
1153 	case S_LITESC:
1154 		if (st & (COLLECTING|DIRECTIVE|QUOTE|SQUOTE))
1155 		{
1156 			if (st & ESCAPE)
1157 			{
1158 				PUTCHR('\\');
1159 				if (c == quot) PUTCHR('\\');
1160 			}
1161 			PUTCHR(c);
1162 		}
1163 #if CPP
1164 		else if (st & PASSTHROUGH) PUTCHR(c);
1165 #endif
1166 		else if (pp.option & PRESERVE) PUTCHR(c);
1167 		else switch (c)
1168 		{
1169 		case 'b':
1170 		case 'f':
1171 		case 'n':
1172 		case 'r':
1173 		case 't':
1174 		case '\\':
1175 		case '\'':
1176 		case '"':
1177 		case '?':
1178 			PUTCHR(c);
1179 			break;
1180 #if COMPATIBLE
1181 		case '8':
1182 		case '9':
1183 			if (!(st & COMPATIBILITY)) goto unknown;
1184 			if (st & STRICT) error(1, "%c: invalid character in octal character escape", c);
1185 			/*FALLTHROUGH*/
1186 #endif
1187 		case '0':
1188 		case '1':
1189 		case '2':
1190 		case '3':
1191 		case '4':
1192 		case '5':
1193 		case '6':
1194 		case '7':
1195 			n = c - '0';
1196 			for (m = 0; m < 2; m++)
1197 			{
1198 				GET(c, c, tp, xp);
1199 				switch (c)
1200 				{
1201 #if COMPATIBLE
1202 				case '8':
1203 				case '9':
1204 					if (!(st & COMPATIBILITY))
1205 					{
1206 						UNGETCHR(c);
1207 						break;
1208 					}
1209 					if (st & STRICT) error(1, "%c: invalid character in octal character escape", c);
1210 					/*FALLTHROUGH*/
1211 #endif
1212 				case '0':
1213 				case '1':
1214 				case '2':
1215 				case '3':
1216 				case '4':
1217 				case '5':
1218 				case '6':
1219 				case '7':
1220 					n = (n << 3) + c - '0';
1221 					continue;
1222 				default:
1223 					UNGETCHR(c);
1224 					break;
1225 				}
1226 				break;
1227 			}
1228 			if (n & ~0777) error(1, "octal character constant too large");
1229 			goto octal;
1230 		case 'a':
1231 			if (pp.option & MODERN)
1232 			{
1233 				PUTCHR(c);
1234 				break;
1235 			}
1236 #if COMPATIBLE
1237 			if (st & COMPATIBILITY) goto unknown;
1238 #endif
1239 			n = CC_bel;
1240 			goto octal;
1241 		case 'v':
1242 			if (pp.option & MODERN)
1243 			{
1244 				PUTCHR(c);
1245 				break;
1246 			}
1247 			n = CC_vt;
1248 			goto octal;
1249 		case 'E':
1250 			if (st & (COMPATIBILITY|STRICT)) goto unknown;
1251 			n = CC_esc;
1252 			goto octal;
1253 		case 'x':
1254 #if COMPATIBLE
1255 			if (st & COMPATIBILITY) goto unknown;
1256 #endif
1257 			n = 0;
1258 			for (m = 0; m < 3; m++)
1259 			{
1260 				GET(c, c, tp, xp);
1261 				switch (c)
1262 				{
1263 				case '0':
1264 				case '1':
1265 				case '2':
1266 				case '3':
1267 				case '4':
1268 				case '5':
1269 				case '6':
1270 				case '7':
1271 				case '8':
1272 				case '9':
1273 					n = (n << 4) + c - '0';
1274 					continue;
1275 				case 'a':
1276 				case 'b':
1277 				case 'c':
1278 				case 'd':
1279 				case 'e':
1280 				case 'f':
1281 					n = (n << 4) + c - 'a' + 10;
1282 					continue;
1283 				case 'A':
1284 				case 'B':
1285 				case 'C':
1286 				case 'D':
1287 				case 'E':
1288 				case 'F':
1289 					n = (n << 4) + c - 'A' + 10;
1290 					continue;
1291 				default:
1292 					if (!m) error(1, "\\x%c: invalid character in hexadecimal character constant", c);
1293 					UNGETCHR(c);
1294 					break;
1295 				}
1296 				break;
1297 			}
1298 			if (n & ~0777) error(1, "hexadecimal character constant too large");
1299 		octal:
1300 			PUTCHR(((n >> 6) & 07) + '0');
1301 			PUTCHR(((n >> 3) & 07) + '0');
1302 			PUTCHR((n & 07) + '0');
1303 			break;
1304 		default:
1305 		unknown:
1306 			if (st & (STRICT|WARN)) error(1, "\\%c: non-standard character constant", c);
1307 			PUTCHR(c);
1308 			break;
1309 		}
1310 		state = LIT1;
1311 		goto fsm_begin;
1312 
1313 	case S_MACRO:
1314 		BACKIN();
1315 #if CPP
1316 		if (st & (DISABLE|SKIPCONTROL|SKIPMACRO))
1317 		{
1318 			if (st & SKIPMACRO)
1319 				pp.mode |= MARKMACRO;
1320 			st &= ~(NEWLINE|SKIPMACRO);
1321 			pp.in->flags |= IN_tokens;
1322 			count(token);
1323 			goto fsm_start;
1324 		}
1325 		count(candidate);
1326 		SETCHR(0);
1327 		switch (state = INDEX(rp))
1328 		{
1329 		case HIT0:
1330 			tp = op - 1;
1331 			break;
1332 		case HITN:
1333 			bp = tp;
1334 			tp = op - ((pp.truncate && pp.truncate < (HITN - HIT0)) ? (pp.truncate - 1) : (HITN - HIT0));
1335 			while (tp > bp && ppisidig(*(tp - 1))) tp--;
1336 			break;
1337 		default:
1338 			bp = tp;
1339 			if ((tp = op - (state - HIT0)) > bp && *(tp - 1) == 'L') tp--;
1340 			break;
1341 		}
1342 		if (sym = ppsymref(pp.symtab, tp))
1343 		{
1344 			SYNCIN();
1345 			n = ppcall(sym, 0);
1346 			CACHEIN();
1347 			if (n >= 0)
1348 			{
1349 				BACKOUT();
1350 				if (!n)
1351 				{
1352 					if (sp) op = sp;
1353 					else
1354 					{
1355 						s = ip;
1356 						ip = sym->macro->value;
1357 						c = sym->macro->size;
1358 						while (c > 0)
1359 						{
1360 							if (op + c < xp + PPBUFSIZ) n = c;
1361 							else n = xp + PPBUFSIZ - op;
1362 							MEMCPY(op, ip, n);
1363 							c -= n;
1364 							PPCHECKOUT();
1365 						}
1366 						ip = s;
1367 					}
1368 				}
1369 				else if ((sym->flags & SYM_MULTILINE) && pp.linesync)
1370 				{
1371 					SYNCOUT();
1372 					if (!(state & NEWLINE))
1373 						ppputchar('\n');
1374 					(*pp.linesync)(error_info.line, error_info.file);
1375 					CACHEOUT();
1376 				}
1377 			}
1378 		}
1379 		pp.in->flags |= IN_tokens;
1380 		goto fsm_start;
1381 #else
1382 		if (st & (COLLECTING|DEFINITION|DISABLE|SKIPCONTROL|SKIPMACRO))
1383 		{
1384 			if (st & SKIPMACRO)
1385 				pp.mode |= MARKMACRO;
1386 			st &= ~(NEWLINE|NOEXPAND|SKIPMACRO);
1387 			c = T_ID;
1388 			if (pp.level == 1)
1389 			{
1390 				pp.in->flags |= IN_tokens;
1391 				if (st & NOTEXT)
1392 				{
1393 					BACKOUT();
1394 					goto fsm_top;
1395 				}
1396 				if (st & COMPILE)
1397 				{
1398 					SETCHR(0);
1399 					if (pp.truncate && (op - tp) > pp.truncate) tp[pp.truncate] = 0;
1400 					sym = (pp.option & NOHASH) ? ppsymref(pp.symtab, tp) : ppsymset(pp.symtab, tp);
1401  fsm_noise:
1402 					if (pp.symbol = sym)
1403 					{
1404 						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)))
1405 						{
1406 							c = ((struct ppsymkey*)sym)->lex;
1407 							/*UNDENT*/
1408 
1409 #define ADVANCE()	do{if(pp.toknxt<op)pp.token=pp.toknxt;}while(0)
1410 
1411 #define NOISE_BRACE		01
1412 #define NOISE_NOSPACEOUT	02
1413 #define NOISE_PAREN		04
1414 
1415 	if ((pp.option & NOISE) && ppisnoise(c))
1416 	{
1417 		if (c != T_NOISE)
1418 		{
1419 			int		p;
1420 			int		f;
1421 			char*		pptoken;
1422 			PPCOMMENT	ppcomment;
1423 
1424 			SYNCIN();
1425 			pp.toknxt = op;
1426 			f = 0;
1427 			if (!(pp.state & SPACEOUT))
1428 			{
1429 				pp.state |= SPACEOUT;
1430 				f |= NOISE_NOSPACEOUT;
1431 			}
1432 			ppcomment = pp.comment;
1433 			pp.comment = 0;
1434 			op = (pptoken = tp) + MAXTOKEN;
1435 			switch (c)
1436 			{
1437 			case T_X_GROUP:
1438 				m = p = 0;
1439 				quot = 1;
1440 				for (;;)
1441 				{
1442 					ADVANCE();
1443 					switch (c = pplex())
1444 					{
1445 					case '(':
1446 					case '{':
1447 						if (!p)
1448 						{
1449 							if (c == '(')
1450 							{
1451 								if (f & NOISE_PAREN)
1452 								{
1453 									ungetchr(c);
1454 									*--pp.toknxt = 0;
1455 									break;
1456 								}
1457 								f |= NOISE_PAREN;
1458 								p = ')';
1459 							}
1460 							else
1461 							{
1462 								f |= NOISE_BRACE|NOISE_PAREN;
1463 								p = '}';
1464 							}
1465 							n = 1;
1466 							m = c;
1467 						}
1468 						else if (c == m) n++;
1469 						quot = 0;
1470 						continue;
1471 					case ')':
1472 					case '}':
1473 						if (c == p && --n <= 0)
1474 						{
1475 							if (c == '}') break;
1476 							m = '\n';
1477 							p = 0;
1478 						}
1479 						quot = 0;
1480 						continue;
1481 					case ' ':
1482 						continue;
1483 					case '\n':
1484 						error_info.line++;
1485 						if (!m) m = '\n';
1486 						continue;
1487 					case 0:
1488 						break;
1489 					case T_ID:
1490 						if (quot) continue;
1491 						/*FALLTHROUGH*/
1492 					default:
1493 						if (m == '\n')
1494 						{
1495 							/*
1496 							 * NOTE: token expanded again
1497 							 */
1498 
1499 							s = pp.toknxt;
1500 							while (s > pp.token) ungetchr(*--s);
1501 							*(pp.toknxt = s) = 0;
1502 							break;
1503 						}
1504 						continue;
1505 					}
1506 					break;
1507 				}
1508 				break;
1509 			case T_X_LINE:
1510 				for (;;)
1511 				{
1512 					ADVANCE();
1513 					switch (pplex())
1514 					{
1515 					case 0:
1516 						break;
1517 					case '\n':
1518 						error_info.line++;
1519 						break;
1520 					default:
1521 						continue;
1522 					}
1523 					break;
1524 				}
1525 				break;
1526 			case T_X_STATEMENT:
1527 				for (;;)
1528 				{
1529 					ADVANCE();
1530 					switch (pplex())
1531 					{
1532 					case 0:
1533 						break;
1534 					case ';':
1535 						ungetchr(';');
1536 						*(pp.toknxt = pp.token) = 0;
1537 						break;
1538 					default:
1539 						continue;
1540 					}
1541 					break;
1542 				}
1543 				break;
1544 			}
1545 			pp.comment = ppcomment;
1546 			if (f & NOISE_NOSPACEOUT)
1547 				pp.state &= ~SPACEOUT;
1548 			CACHEIN();
1549 			tp = pptoken;
1550 			op = pp.toknxt;
1551 			c = T_NOISES;
1552 		}
1553 		if (pp.option & NOISEFILTER)
1554 		{
1555 			BACKOUT();
1556 			goto fsm_top;
1557 		}
1558 	}
1559 
1560 							/*INDENT*/
1561 						}
1562 						else if ((pp.option & NOISE) && c == T_ID && strneq(tp, "__builtin_", 10))
1563 						{
1564 							hashlook(pp.symtab, tp, HASH_DELETE, NiL);
1565 							pp.symbol = sym = (struct ppsymbol*)ppkeyset(pp.symtab, tp);
1566 							sym->flags |= SYM_KEYWORD;
1567 							c = ((struct ppsymkey*)sym)->lex = T_BUILTIN;
1568 						}
1569 					}
1570 				}
1571 				goto fsm_symbol;
1572 			}
1573 			goto fsm_check;
1574 		}
1575 		if (pp.level == 1)
1576 		{
1577 			st &= ~(NEWLINE|PASSEOF);
1578 			pp.in->flags |= IN_tokens;
1579 		}
1580 		else st &= ~PASSEOF;
1581 		count(candidate);
1582 		SETCHR(0);
1583 		if (sym = ppsymref(pp.symtab, tp))
1584 		{
1585 			SYNCIN();
1586 			c = ppcall(sym, 1);
1587 			CACHEIN();
1588 			if (c >= 0)
1589 			{
1590 				BACKOUT();
1591 				if ((sym->flags & SYM_MULTILINE) && pp.linesync)
1592 				{
1593 					SYNCOUT();
1594 					(*pp.linesync)(error_info.line, error_info.file);
1595 					CACHEOUT();
1596 				}
1597 				goto fsm_top;
1598 			}
1599 		}
1600 		c = T_ID;
1601 		if (pp.level == 1)
1602 		{
1603 			if (st & NOTEXT)
1604 			{
1605 				BACKOUT();
1606 				goto fsm_top;
1607 			}
1608 			if (st & COMPILE)
1609 			{
1610 				if (pp.truncate && (op - tp) > pp.truncate)
1611 				{
1612 					tp[pp.truncate] = 0;
1613 					sym = 0;
1614 				}
1615 				if (!sym)
1616 				{
1617 					if (!(pp.option & NOHASH)) sym = ppsymset(pp.symtab, tp);
1618 					else if (!(sym = ppsymref(pp.symtab, tp))) goto fsm_symbol;
1619 				}
1620 				goto fsm_noise;
1621 			}
1622 			goto fsm_symbol;
1623 		}
1624 		goto fsm_check;
1625 #endif
1626 
1627 	case S_SHARP:
1628 		if (c == '(')
1629 		{
1630 			pp.in->flags |= IN_tokens;
1631 			if ((st & STRICT) && pp.in->type != IN_MACRO && pp.in->type != IN_MULTILINE)
1632 			{
1633 				if (!(pp.mode & HOSTED)) error(1, "non-standard reference to #(...)");
1634 				if (st & STRICT)
1635 				{
1636 					PUTCHR(c);
1637 #if CPP
1638 					st &= ~NEWLINE;
1639 					count(token);
1640 					goto fsm_start;
1641 #else
1642 					break;
1643 #endif
1644 				}
1645 			}
1646 			if (st & (COLLECTING|DEFINITION|DISABLE|SKIPCONTROL))
1647 			{
1648 				PUTCHR(c);
1649 #if CPP
1650 				st &= ~NEWLINE;
1651 				count(token);
1652 				goto fsm_start;
1653 #else
1654 				st &= ~NOEXPAND;
1655 				break;
1656 #endif
1657 			}
1658 			op--;
1659 			SYNC();
1660 			ppbuiltin();
1661 			CACHE();
1662 #if CPP
1663 			count(token);
1664 			goto fsm_start;
1665 #else
1666 			goto fsm_top;
1667 #endif
1668 		}
1669 		BACKIN();
1670 #if CPP
1671 		if (!(st & NEWLINE) || !(pp.in->type & IN_TOP))
1672 		{
1673  fsm_nondirective:
1674 			st &= ~NEWLINE;
1675 			pp.in->flags |= IN_tokens;
1676 			count(token);
1677 			goto fsm_start;
1678 		}
1679 		if (*(s = tp) != '#')
1680 		{
1681 #if COMPATIBLE
1682 			if ((st & (COMPATIBILITY|TRANSITION)) == COMPATIBILITY) goto fsm_nondirective;
1683 #endif
1684 			while (*s == ' ' || *s == '\t') s++;
1685 			if (*s != '#') goto fsm_nondirective;
1686 		}
1687 		BACKOUT();
1688 #else
1689 		if (!(st & NEWLINE) || (st & DEFINITION) || !(pp.in->type & IN_TOP))
1690 		{
1691 			if (c == '#')
1692 			{
1693 				SKIPIN();
1694 				if (!(st & DEFINITION))
1695 					PUTCHR(c);
1696 				c = T_TOKCAT;
1697 			}
1698 			else if (pp.level == 1 && !(st & (JOINING|SPACEOUT)) && !(pp.option & PRESERVE))
1699 			{
1700 				char*		pptoken;
1701 				char*		oop;
1702 				PPCOMMENT	ppcomment;
1703 
1704 				SYNCIN();
1705 				pp.toknxt = oop = op;
1706 				pp.state |= SPACEOUT;
1707 				ppcomment = pp.comment;
1708 				pp.comment = 0;
1709 				op = (pptoken = tp) + MAXTOKEN;
1710 				for (;;)
1711 				{
1712 					ADVANCE();
1713 					switch (pplex())
1714 					{
1715 					case 0:
1716 						break;
1717 					case '\n':
1718 						error_info.line++;
1719 						break;
1720 					default:
1721 						continue;
1722 					}
1723 					break;
1724 				}
1725 				pp.comment = ppcomment;
1726 				pp.state &= ~SPACEOUT;
1727 				CACHEIN();
1728 				tp = pptoken;
1729 				*--op = 0;
1730 				op = oop;
1731 				if (pp.pragma && !(st & NOTEXT))
1732 				{
1733 					*s = 0;
1734 					SYNC();
1735 					(*pp.pragma)(NiL, NiL, NiL, tp, 1);
1736 					CACHE();
1737 				}
1738 				if (!c) BACKIN();
1739 				goto fsm_top;
1740 			}
1741 			else c = '#';
1742 			break;
1743 		}
1744 		if ((st & (COLLECTING|STRICT)) == (COLLECTING|STRICT))
1745 			error(1, "directives in macro call arguments are not portable");
1746 #endif
1747 		if (c == '#' && pp.in->type == IN_RESCAN)
1748 		{
1749 			/*
1750 			 * pass line to pp.pragma VERBATIM
1751 			 */
1752 
1753 			SKIPIN();
1754 			s = pp.valbuf;
1755 			while ((c = GETCHR()) && c != '\n')
1756 				if ((*s++ = c) == MARK) SKIPIN();
1757 			if (pp.pragma && !(st & NOTEXT))
1758 			{
1759 				*s = 0;
1760 				SYNC();
1761 				(*pp.pragma)(NiL, NiL, NiL, pp.valbuf, 1);
1762 				CACHE();
1763 			}
1764 			if (!c) BACKIN();
1765 #if CPP
1766 			goto fsm_start;
1767 #else
1768 			goto fsm_top;
1769 #endif
1770 		}
1771 		SYNC();
1772 		ppcontrol();
1773 		CACHE();
1774 #if CPP
1775 		if (st & (NOTEXT|SKIPCONTROL))
1776 		{
1777 			if (!sp)
1778 			{
1779 				PPCHECKOUTTP();
1780 				sp = tp;
1781 			}
1782 		}
1783 		else if (sp)
1784 		{
1785 			tp = op = sp;
1786 			sp = 0;
1787 		}
1788 		goto fsm_start;
1789 #else
1790 		goto fsm_top;
1791 #endif
1792 
1793 	case S_NL:
1794 #if CPP
1795 		if (op == tp && !(st & JOINING) && pp.in->type == IN_FILE && !(pp.option & PRESERVE))
1796 		{
1797 			st |= NEWLINE|HIDDEN;
1798 			pp.hidden++;
1799 			error_info.line++;
1800 			goto fsm_start;
1801 		}
1802 #endif
1803  fsm_newline:
1804 #if CPP
1805 		if (sp)
1806 			op = sp;
1807 		else if (!(pp.in->flags & IN_noguard))
1808 		{
1809 			while (tp < op)
1810 				if ((c = *tp++) != ' ' && c != '\t')
1811 				{
1812 					pp.in->flags |= IN_tokens;
1813 					break;
1814 				}
1815 			c = '\n';
1816 		}
1817 		st |= NEWLINE;
1818 		error_info.line++;
1819 		if (*ip == '\n' && *(ip + 1) != '\n' && !pp.macref && !(st & (ADD|HIDDEN)))
1820 		{
1821 			ip++;
1822 			PUTCHR('\n');
1823 			error_info.line++;
1824 		}
1825 		if ((st & NOTEXT) && ((pp.mode & FILEDEPS) || (pp.option & (DEFINITIONS|PREDEFINITIONS))))
1826 			BACKOUT();
1827 		else
1828 		{
1829 			debug((-5, "token[%d] %03o = %s [line=%d]", pp.level, c, pptokchr(c), error_info.line));
1830 			PUTCHR('\n');
1831 			PPSYNCLINE();
1832 			if (sp)
1833 			{
1834 				PPCHECKOUT();
1835 				sp = op;
1836 			}
1837 		}
1838 		goto fsm_start;
1839 #else
1840 		st |= NEWLINE;
1841 		if (pp.level == 1)
1842 		{
1843 			error_info.line++;
1844 			if (!(st & (JOINING|SPACEOUT)))
1845 			{
1846 				debug((-5, "token[%d] %03o = %s [line=%d]", pp.level, c, pptokchr(c), error_info.line));
1847 				BACKOUT();
1848 				goto fsm_top;
1849 			}
1850 		}
1851 		BACKOUT();
1852 		if (st & SKIPCONTROL)
1853 		{
1854 			error_info.line++;
1855 			st |= HIDDEN;
1856 			pp.hidden++;
1857 			goto fsm_start;
1858 		}
1859 		PUTCHR(c = '\n');
1860 		goto fsm_return;
1861 #endif
1862 
1863 #if !CPP
1864 	case S_TOK:
1865 		PUTCHR(c);
1866 		c = TYPE(state) | qual;
1867 		break;
1868 
1869 	case S_TOKB:
1870 		BACKIN();
1871 		c = TYPE(state) | qual;
1872 		break;
1873 #endif
1874 
1875 	case S_VS:
1876 		PUTCHR(c);
1877 #if !CPP
1878 		if (st & NOVERTICAL)
1879 		{
1880 			error(1, "%s invalid in directives", pptokchr(c));
1881 			st &= ~NOVERTICAL;
1882 		}
1883 #endif
1884 #if COMPATIBLE
1885 		if (st & COMPATIBILITY) st |= NEWLINE;
1886 #endif
1887 #if CPP
1888 		if (!(pp.in->flags & IN_noguard))
1889 			while (tp < op)
1890 				if ((c = *tp++) != ' ' && c != '\t')
1891 				{
1892 					pp.in->flags |= IN_tokens;
1893 					break;
1894 				}
1895 		goto fsm_start;
1896 #else
1897 		bp = ip;
1898 		rp = fsm[WS1];
1899 		goto fsm_get;
1900 #endif
1901 
1902 #if !CPP
1903 	case S_WS:
1904 #if COMPATIBLE
1905 		if ((st & (COMPATIBILITY|TRANSITION)) == COMPATIBILITY) st &= ~NEWLINE;
1906 #endif
1907 		if (pp.level == 1)
1908 		{
1909 			if ((st & (COMPATIBILITY|SPACEOUT)) && !(st & TRANSITION))
1910 			{
1911 				if (st & (COMPILE|NOTEXT))
1912 				{
1913 #if CATSTRINGS
1914 					if ((st & (JOINING|NOTEXT|SPACEOUT)) != SPACEOUT)
1915 #else
1916 					if ((st & (NOTEXT|SPACEOUT)) != SPACEOUT)
1917 #endif
1918 					{
1919 						BACKOUT();
1920 						bp = ip - 1;
1921 						rp = fsm[START];
1922 						if (state = rp[c]) goto fsm_next;
1923 						goto fsm_get;
1924 					}
1925 				}
1926 				else
1927 #if CATSTRINGS
1928 				if (!(st & JOINING))
1929 #endif
1930 				{
1931 					tp = op;
1932 					bp = ip - 1;
1933 					rp = fsm[START];
1934 					if (state = rp[c]) goto fsm_next;
1935 					goto fsm_get;
1936 				}
1937 				BACKIN();
1938 				c = ' ';
1939 				goto fsm_return;
1940 			}
1941 			BACKOUT();
1942 			bp = ip - 1;
1943 			rp = fsm[START];
1944 			if (state = rp[c]) goto fsm_next;
1945 			goto fsm_get;
1946 		}
1947 		if (st & (NOSPACE|SKIPCONTROL))
1948 		{
1949 			BACKOUT();
1950 			bp = ip - 1;
1951 			rp = fsm[START];
1952 			if (state = rp[c]) goto fsm_next;
1953 			goto fsm_get;
1954 		}
1955 		if (c != '\n')
1956 		{
1957 			BACKIN();
1958 			c = ' ';
1959 		}
1960 		if (!(pp.option & PRESERVE))
1961 		{
1962 			BACKOUT();
1963 			PUTCHR(c);
1964 		}
1965 		goto fsm_return;
1966 #endif
1967 
1968 	default:
1969 		if (state & SPLICE)
1970 		{
1971 			switch (c)
1972 			{
1973 			case MARK:
1974 				/*
1975 				 * internal mark
1976 				 */
1977 
1978 				switch (pp.in->type)
1979 				{
1980 				case IN_BUFFER:
1981 				case IN_FILE:
1982 #if !CPP
1983 				case IN_INIT:
1984 #if CATSTRINGS
1985 					if ((st & JOINING) && (!INQUOTE(rp) || quot != '"') || pp.level > 1 && (rp == fsm[START] || INQUOTE(rp)))
1986 #else
1987 					if (pp.level > 1 && (rp == fsm[START] || INQUOTE(rp)))
1988 #endif
1989 						PUTCHR(c);
1990 #endif
1991 					break;
1992 				default:
1993 					switch (GETCHR())
1994 					{
1995 					case 'A':
1996 						if (!(st & (DEFINITION|DISABLE)))
1997 						{
1998 							c = GETCHR();
1999 							SYNCIN();
2000 							if (pp.macp->arg[c - ARGOFFSET][-1])
2001 								PUSH_EXPAND(pp.macp->arg[c - ARGOFFSET], pp.macp->line);
2002 							else
2003 								PUSH_COPY(pp.macp->arg[c - ARGOFFSET], pp.macp->line);
2004 							CACHEIN();
2005 							bp = ip;
2006 							goto fsm_get;
2007 						}
2008 						/*FALLTHROUGH*/
2009 					case 'C':
2010 						c = GETCHR() - ARGOFFSET;
2011 						if (!*(s = pp.macp->arg[c]) && (pp.in->symbol->flags & SYM_VARIADIC) && pp.in->symbol->macro->arity == (c + 1))
2012 						{
2013 							s = ip - 3;
2014 							while (--op > tp && --s > bp && ppisidig(*s));
2015 						}
2016 						else
2017 						{
2018 							SYNCIN();
2019 							PUSH_COPY(s, pp.macp->line);
2020 							CACHEIN();
2021 						}
2022 						bp = ip;
2023 						goto fsm_get;
2024 					case 'F':
2025 						error_info.file = (char*)strtoul(ip, &s, 16);
2026 						debug((-6, "actual sync: file = \"%s\"", error_info.file));
2027 						bp = ip = s + 1;
2028 						goto fsm_get;
2029 					case 'L':
2030 						error_info.line = strtoul(ip, &s, 16);
2031 						debug((-6, "actual sync: line = %d", error_info.line));
2032 						bp = ip = s + 1;
2033 						goto fsm_get;
2034 					case 'Q':
2035 						c = GETCHR();
2036 						SYNCIN();
2037 						PUSH_QUOTE(pp.macp->arg[c - ARGOFFSET], pp.macp->line);
2038 						CACHEIN();
2039 						bp = ip - 1;
2040 						if (st & (COLLECTING|EOF2NL|JOINING)) rp = fsm[START];
2041 						if (state = rp[c = '"']) goto fsm_next;
2042 						goto fsm_get;
2043 					case 'S':
2044 						c = GETCHR();
2045 						SYNCIN();
2046 						PUSH_SQUOTE(pp.macp->arg[c - ARGOFFSET], pp.macp->line);
2047 						CACHEIN();
2048 						bp = ip - 1;
2049 						if (st & COLLECTING) rp = fsm[START];
2050 						if (state = rp[c = '\'']) goto fsm_next;
2051 						goto fsm_get;
2052 					case 'X':
2053 						if (pp.in->type != IN_COPY)
2054 							st |= SKIPMACRO;
2055 						if (pp.level <= 1)
2056 						{
2057 							bp = ip;
2058 							goto fsm_get;
2059 						}
2060 						if (pp.in->type == IN_EXPAND)
2061 						{
2062 							st &= ~SKIPMACRO;
2063 							PUTCHR(c);
2064 							PUTCHR('X');
2065 						}
2066 						c = GETCHR();
2067 						break;
2068 					case 0:
2069 						if ((state &= ~SPLICE) >= TERMINAL) goto fsm_terminal;
2070 						goto fsm_begin;
2071 					default:
2072 #if DEBUG
2073 						error(PANIC, "invalid mark op `%c'", LASTCHR());
2074 						/*FALLTHROUGH*/
2075 					case MARK:
2076 #endif
2077 #if CATSTRINGS
2078 						if ((st & (JOINING|QUOTE)) == JOINING)
2079 						{
2080 							if (!INQUOTE(rp))
2081 								PUTCHR(c);
2082 						}
2083 						else
2084 #endif
2085 #if CPP
2086 						if (rp != fsm[START] && !INQUOTE(rp))
2087 							UNGETCHR(c);
2088 #else
2089 						if (rp != fsm[START] && !INQUOTE(rp))
2090 							UNGETCHR(c);
2091 						else if (pp.level > 1)
2092 							PUTCHR(c);
2093 #endif
2094 						break;
2095 					}
2096 					break;
2097 				}
2098 				break;
2099 			case '?':
2100 				/*
2101 				 * trigraph
2102 				 */
2103 
2104 				if (pp.in->type == IN_FILE)
2105 				{
2106 					GET(c, n, tp, xp);
2107 					if (n == '?')
2108 					{
2109 						GET(c, n, tp, xp);
2110 						if (c = trigraph[n])
2111 						{
2112 							if ((st & WARN) && (st & (COMPATIBILITY|TRANSITION)) && !(pp.mode & HOSTED) && !INCOMMENT(rp))
2113 								error(1, "trigraph conversion %c%c%c -> %c%s", '?', '?', n, c, (st & TRANSITION) ? "" : " inhibited");
2114 #if COMPATIBLE
2115 							if ((st & (COMPATIBILITY|TRANSITION)) != COMPATIBILITY)
2116 							{
2117 #endif
2118 							*(bp = ip - 1) = c;
2119 							if (state = rp[c]) goto fsm_next;
2120 							goto fsm_get;
2121 #if COMPATIBLE
2122 							}
2123 #endif
2124 						}
2125 						if (n != EOB) BACKIN();
2126 						UNGETCHR(c = '?');
2127 					}
2128 					else if (n != EOB) BACKIN();
2129 				}
2130 				break;
2131 			case '%':
2132 			case '<':
2133 			case ':':
2134 				/*
2135 				 * digraph = --trigraph
2136 				 */
2137 
2138 				if (pp.in->type == IN_FILE && (pp.option & PLUSPLUS))
2139 				{
2140 					m = 0;
2141 					GET(c, n, tp, xp);
2142 					switch (n)
2143 					{
2144 					case '%':
2145 						if (c == '<') m = '{';
2146 						break;
2147 					case '>':
2148 						if (c == '%') m = '}';
2149 						else if (c == ':') m = ']';
2150 						break;
2151 					case ':':
2152 						if (c == '%') m = '#';
2153 						else if (c == '<') m = '[';
2154 						break;
2155 					}
2156 					if (m)
2157 					{
2158 						if ((st & WARN) && (st & (COMPATIBILITY|TRANSITION)) && !(pp.mode & HOSTED) && !INCOMMENT(rp))
2159 							error(1, "digraph conversion %c%c -> %c%s", c, n, m, (st & TRANSITION) ? "" : " inhibited");
2160 #if COMPATIBLE
2161 						if ((st & (COMPATIBILITY|TRANSITION)) != COMPATIBILITY)
2162 						{
2163 #endif
2164 						*(bp = ip - 1) = c = m;
2165 						if (state = rp[c]) goto fsm_next;
2166 						goto fsm_get;
2167 #if COMPATIBLE
2168 						}
2169 #endif
2170 					}
2171 					if (n != EOB) BACKIN();
2172 				}
2173 				break;
2174 			case '\\':
2175 				/*
2176 				 * line splice
2177 				 */
2178 
2179 				if (pp.in->type == IN_FILE && (!(pp.option & PLUSSPLICE) || !INCOMMENTXX(rp)))
2180 				{
2181 					m = 0;
2182 					GET(c, n, tp, xp);
2183 					if ((pp.option & SPLICESPACE) && !INQUOTE(rp))
2184 						while (n == ' ')
2185 						{
2186 							GET(c, n, tp, xp);
2187 							m = 1;
2188 						}
2189 					if (n == '\r')
2190 					{
2191 						GET(c, n, tp, xp);
2192 						if (n != '\n' && n != EOB)
2193 							BACKIN();
2194 					}
2195 					if (n == '\n')
2196 					{
2197 #if CPP
2198 						if (INQUOTE(rp))
2199 						{
2200 							if ((pp.option & STRINGSPLIT) && quot == '"')
2201 							{
2202 								PUTCHR(quot);
2203 								PUTCHR(n);
2204 								PUTCHR(quot);
2205 							}
2206 							else if (*pp.lineid)
2207 							{
2208 								PUTCHR(c);
2209 								PUTCHR(n);
2210 							}
2211 							else
2212 							{
2213 								st |= HIDDEN;
2214 								pp.hidden++;
2215 							}
2216 						}
2217 						else
2218 #else
2219 #if COMPATIBLE
2220 						if (!INQUOTE(rp) && (st & (COMPATIBILITY|DEFINITION|TRANSITION)) == (COMPATIBILITY|DEFINITION))
2221 						{
2222 							if (op == tp)
2223 							{
2224 								st |= HIDDEN;
2225 								pp.hidden++;
2226 								error_info.line++;
2227 								if (st & SPACEOUT)
2228 									goto fsm_start;
2229 								c = (pp.option & SPLICECAT) ? '\t' : ' ';
2230 								PUTCHR(c);
2231 								goto fsm_check;
2232 							}
2233 							UNGETCHR(n);
2234 							state &= ~SPLICE;
2235 							goto fsm_terminal;
2236 						}
2237 #endif
2238 #endif
2239 						{
2240 							st |= HIDDEN;
2241 							pp.hidden++;
2242 						}
2243 #if CPP
2244 						spliced++;
2245 #else
2246 						error_info.line++;
2247 #endif
2248 						bp = ip;
2249 						goto fsm_get;
2250 					}
2251 					else if ((n == 'u' || n == 'U') && !INQUOTE(rp))
2252 					{
2253 						PUTCHR(c);
2254 						PUTCHR(n);
2255 						bp = ip;
2256 						goto fsm_get;
2257 					}
2258 #if COMPATIBLE
2259 					else if ((st & (COMPATIBILITY|TRANSITION)) == COMPATIBILITY && (n == '"' || n == '\'') && !INQUOTE(rp))
2260 					{
2261 						PUTCHR(c);
2262 						PUTCHR(n);
2263 						bp = ip;
2264 						goto fsm_get;
2265 					}
2266 #endif
2267 					else if (n != EOB)
2268 						BACKIN();
2269 					if (m && INSPACE(rp))
2270 						UNGETCHR(c);
2271 				}
2272 #if COMPATIBLE
2273 				else if ((st & (COMPATIBILITY|TRANSITION)) == COMPATIBILITY && !INQUOTE(rp))
2274 				{
2275 					GET(c, n, tp, xp);
2276 					if (n == '"' || n == '\'')
2277 					{
2278 						PUTCHR(c);
2279 						PUTCHR(n);
2280 						bp = ip;
2281 						goto fsm_get;
2282 					}
2283 					if (n != EOB)
2284 						BACKIN();
2285 				}
2286 #endif
2287 				break;
2288 			case '\r':
2289 				/*
2290 				 * barf
2291 				 */
2292 
2293 				if (pp.in->type == IN_FILE)
2294 				{
2295 					GET(c, n, tp, xp);
2296 					if (n == '\n')
2297 					{
2298 						*(bp = ip - 1) = c = n;
2299 						if (state = rp[c]) goto fsm_next;
2300 						goto fsm_get;
2301 					}
2302 					if (n != EOB) BACKIN();
2303 				}
2304 				break;
2305 			case CC_sub:
2306 				/*
2307 				 * barf & puke
2308 				 */
2309 
2310 				if ((pp.option & ZEOF) && pp.in->type == IN_FILE)
2311 				{
2312 					pp.in->flags |= IN_eof;
2313 					c = 0;
2314 					state = S_EOB;
2315 					goto fsm_terminal;
2316 				}
2317 				break;
2318 			}
2319 			if ((state &= ~SPLICE) >= TERMINAL)
2320 				goto fsm_terminal;
2321 			PUTCHR(c);
2322 			goto fsm_begin;
2323 		}
2324 #if CPP
2325 		if (INOPSPACE(rp))
2326 		{
2327 			BACKIN();
2328 			goto fsm_start;
2329 		}
2330 #endif
2331 		PUTCHR(c);
2332 		bp = ip;
2333 		goto fsm_get;
2334 	}
2335 #if !CPP
2336  fsm_token:
2337 	st &= ~NEWLINE;
2338 	if (pp.level == 1)
2339 	{
2340 		pp.in->flags |= IN_tokens;
2341 		if (st & NOTEXT)
2342 		{
2343 			BACKOUT();
2344 			goto fsm_top;
2345 		}
2346  fsm_symbol:
2347 		count(token);
2348 	}
2349  fsm_check:
2350 	if (st & SKIPCONTROL)
2351 	{
2352 		BACKOUT();
2353 		goto fsm_start;
2354 	}
2355  fsm_return:
2356 #if CPP
2357 	error_info.line += spliced;
2358 #endif
2359 	SETCHR(0);
2360 	debug((-5, "token[%d] %03o = %s", pp.level, c, pptokstr(tp, 0)));
2361 	SYNC();
2362 	pp.level--;
2363 	error_info.indent--;
2364 	return c;
2365 #endif
2366 }
2367 
2368 #if CPP && POOL
2369 
2370 #include <ls.h>
2371 #include <wait.h>
2372 
2373 /*
2374  * output pool status on exit
2375  */
2376 
2377 static void
2378 poolstatus(void)
2379 {
2380 	error(ERROR_OUTPUT|0, pp.pool.output, "%d", error_info.errors != 0);
2381 }
2382 
2383 /*
2384  * loop on < input output >
2385  */
2386 
2387 static void
2388 pool(void)
2389 {
2390 	char*	ifile;
2391 	char*	ofile;
2392 
2393 	ppflushout();
2394 	if (!sfnew(sfstdin, NiL, SF_UNBOUND, pp.pool.input, SF_READ))
2395 		error(ERROR_SYSTEM|3, "cannot dup pool input");
2396 
2397 	/*
2398 	 * kick the -I cache
2399 	 */
2400 
2401 	ppsearch(".", T_STRING, SEARCH_EXISTS);
2402 
2403 	/*
2404 	 * loop on < input output >
2405 	 */
2406 
2407 	pp.pool.input = 0;
2408 	while (ifile = sfgetr(sfstdin, '\n', 1))
2409 	{
2410 		if (!(ofile = strchr(ifile, ' ')))
2411 			error(3, "%s: pool output file expected", ifile);
2412 		*ofile++ = 0;
2413 		waitpid(0, NiL, WNOHANG);
2414 		switch (fork())
2415 		{
2416 		case -1:
2417 			error(ERROR_SYSTEM|3, "cannot fork pool");
2418 		case 0:
2419 			atexit(poolstatus);
2420 			error_info.errors = 0;
2421 			error_info.warnings = 0;
2422 			close(0);
2423 			if (open(ifile, O_RDONLY))
2424 				error(ERROR_SYSTEM|3, "%s: cannot read", ifile);
2425 			close(1);
2426 			if (open(ofile, O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH) != 1)
2427 				error(ERROR_SYSTEM|3, "%s: cannot create", ofile);
2428 			pp.outfile = ofile;
2429 			pathcanon(ifile, 0);
2430 			ifile = ppsetfile(ifile)->name;
2431 #if CHECKPOINT
2432 			if (pp.mode & DUMP)
2433 			{
2434 				if (!pp.pragma)
2435 					error(3, "#%s must be enabled for checkpoints", dirname(PRAGMA));
2436 				(*pp.pragma)(dirname(PRAGMA), pp.pass, keyname(X_CHECKPOINT), pp.checkpoint, 1);
2437 			}
2438 #endif
2439 			PUSH_FILE(ifile, 0);
2440 			return;
2441 		}
2442 	}
2443 	while (wait(NiL) != -1);
2444 }
2445 
2446 #endif
2447