scc

lex.c (19285B)

---

 #include <assert.h>
 #include <ctype.h>
 #include <errno.h>
 #include <limits.h>
 #include <setjmp.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <scc/cstd.h>
 #include <scc/scc.h>
 #include "cc1.h"
 
 #define REPLACECHAR 0xFFFD
 #define NOMULTICHAR 0
 #define MULTICHAR   1
 #define UTF8_MAX    4
 
 int yytoken;
 struct yystype yylval;
 char yytext[STRINGSIZ+3];
 unsigned short yylen;
 int yyspace, lexmode = CCMODE;
 unsigned lineno;
 char filenam[FILENAME_MAX];
 
 int namespace = NS_IDEN;
 static int safe;
 Input *input;
 
 void
 setloc(char *fname, unsigned line)
 {
 	size_t len;
 
 	if (fname) {
 		if ((len = strlen(fname)) >= FILENAME_MAX)
 			die("cc1: %s: file name too long", fname);
 		memmove(filenam, fname, len);
 		filenam[len] = '\0';
 
 		/*
 		 * There are cases where we want to call setloc()
 		 * with the data in input, and then we have t be
 		 * careful about freeing input->filenam
 		 */
 		if (fname != input->filenam) {
 			free(input->filenam);
 			input->filenam = xstrdup(fname);
 		}
 	}
 
 	lineno = input->lineno = line;
 }
 
 int
 addinput(int type, void *arg, int fail)
 {
 	FILE *fp;
 	char *extp, *fname, *buffer, *infile;
 	int infileln;
 	Macro *mp;
 	Symbol *sym, **hs;
 	Input *newip, *curip = input;
 
 	if (curip)
 		curip->lineno = lineno;
 
 	switch (type) {
 	case IMACRO:
 		fp = NULL;
 		mp = arg;
 		sym = mp->sym;
 		fname = mp->fname;
 		buffer = mp->buffer;
 		DBG("INPUT expanding macro %s", sym->name);
 		break;
 	case IPARAM:
 		fp = NULL;
 		mp = NULL;
 		buffer = arg;
 		fname = filenam;
 		DBG("INPUT macro parameter '%s'", buffer);
 		break;
 	case IFILE:
 		fname = arg;
 		mp = NULL;
 		buffer = NULL;
 
 		if ((fp = fopen(fname, "r")) == NULL) {
 			if (!fail)
 				return 0;
 			die("cc1: %s: %s", fname, strerror(errno));
 		}
 		if (curip && onlyheader) {
 			infile = curip->filenam;
 			infileln = strlen(infile);
 			if (extp = strrchr(infile, '.'))
 				infileln -= strlen(extp);
 			printf("%.*s.o: %s %s\n",
 			       infileln, infile, infile, fname);
 		}
 		lineno = 0;
 		DBG("INPUT file input '%s'", fname);
 		break;
 	case ISTDIN:
 		fp = stdin;
 		mp = NULL;
 		fname = "<stdin>";
 		buffer = NULL;
 		lineno = 0;
 		DBG("INPUT file input 'stdin'");
 		break;
 	default:
 		abort();
 	}
 
 	if (!buffer) {
 		buffer = xmalloc(INPUTSIZ);
 		buffer[0] = '\0';
 	} else {
 		buffer = xstrdup(buffer);
 	}
 
 	if (input)
 		unsethideset(input);
 
 	newip = xmalloc(sizeof(*newip));
 	newip->next = curip;
 	newip->macro = mp;
 	newip->p = newip->begin = newip->line = buffer;
 	newip->filenam = NULL;
 	newip->lineno = 0;
 	newip->fp = fp;
 	newip->flags = type;
 	memset(newip->hideset, 0, sizeof(newip->hideset));
 	input = newip;
 
 	hs = NULL;
 	if (curip)
 		hs = curip->hideset;
 	if (type == IMACRO)
 		hs = mp->hideset;
 	if (type == IPARAM && curip)
 		hs = curip->macro->hideset;
 	if (hs) {
 		memcpy(input->hideset, hs, sizeof(input->hideset));
 		sethideset(input);
 	}
 
 	setloc(fname, lineno);
 	return 1;
 }
 
 void
 delinput(void)
 {
 	Input *ip = input;
 
 	switch (ip->flags & ITYPE) {
 	case IFILE:
 		DBG("INPUT file finished '%s'", ip->filenam);
 		if (fclose(ip->fp))
 			die("cc1: %s: %s", ip->filenam, strerror(errno));
 		break;
 	case IMACRO:
 		DBG("INPUT macro %s finished", ip->macro->sym->name);
 		delmacro(ip->macro);
 		break;
 	case IPARAM:
 		DBG("INPUT macro param finished");
 		break;
 	case ISTDIN:
 		DBG("INPUT stdin finished");
 		break;
 	default:
 		abort();
 	}
 	unsethideset(input);
 
 	input = ip->next;
 	free(ip->filenam);
 	free(ip->line);
 	free(ip);
 	if (input) {
 		sethideset(input);
 		setloc(input->filenam, input->lineno);
 	}
 }
 
 static void
 newline(void)
 {
 	if (++lineno == 0)
 		die("cc1: %s: file too long", filenam);
 }
 
 /*
  * Read the next character from the input file, counting number of lines
  * and joining lines escaped with \
  */
 static int
 readchar(void)
 {
 	FILE *fp = input->fp;
 	int c;
 
 repeat:
 	switch (c = getc(fp)) {
 	case '\\':
 		if ((c = getc(fp)) == '\n') {
 			newline();
 			goto repeat;
 		}
 		ungetc(c, fp);
 		c = '\\';
 		break;
 	case '\n':
 		newline();
 		break;
 	case EOF:
 		break;
 	}
 
 	return c;
 }
 
 /*
  * discard a C comment. This function is only called from readline
  * because it is impossible to have a comment in a macro, because
  * comments are always discarded before processing any cpp directive
  */
 static void
 comment(int type)
 {
 	int c;
 
 	c = readchar();
 repeat:
 	for ( ; c != EOF && c != type; c = readchar())
 		;
 
 	if (c == EOF) {
 		errorp("unterminated comment");
 		return;
 	}
 
 	if (type == '*' && (c = readchar()) != '/')
 		goto repeat;
 }
 
 /*
  * readline is used to read a full logic line from a file.
  * It discards comments and check that the line fits in
  * the input buffer
  */
 static int
 readline(void)
 {
 	char *bp, *lim;
 	int c, peekc = 0, delim = 0;
 
 	if (feof(input->fp)) {
 		input->flags |= IEOF;
 		*input->p = '\0';
 		return 0;
 	}
 
 	*input->line = '\0';
 	lim = &input->line[INPUTSIZ-1];
 	for (bp = input->line; bp < lim-1; *bp++ = c) {
 		c = (peekc) ? peekc : readchar();
 		peekc = 0;
 		if (c == '\n' || c == EOF)
 			break;
 		if (c == '\\') {
 			peekc = readchar();
 			if (peekc == '\n' || peekc == EOF)
 				continue;
 			if (bp == lim-2)
 				break;
 			*bp++ = c;
 			c = peekc;
 			peekc = 0;
 			continue;
 		}
 
 		if (delim && c == delim)
 			delim = 0;
 		else if (!delim && (c == '"' || c == '\''))
 			delim = c;
 		if (c != '/' || delim)
 			continue;
 
 		/* check for /* or // */
 		peekc = readchar();
 		if (peekc != '*' && peekc != '/')
 			continue;
 
 		if (peekc == '/') {
 			comment('\n');
 			break;
 		} else {
 			comment('*');
 			c = ' ';
 		}
 		peekc = 0;
 	}
 
 	input->begin = input->p = input->line;
 	if (bp == lim-1) {
 		errorp("line too long");
 		--bp;
 	}
 	*bp++ = '\n';
 	*bp = '\0';
 
 	return 1;
 }
 
 /*
  * moreinput gets more bytes to be passed to the lexer.
  * It can take more bytes from macro expansions or
  * directly reading from files. When a cpp directive
  * is processed the line is discarded because it must not
  * be passed to the lexer
  */
 int
 moreinput(void)
 {
 	int wasexpand = 0;
 
 repeat:
 	if (!input)
 		return 0;
 
 	if (*input->p == '\0') {
 		int t = input->flags & ITYPE;
 		if (t == IPARAM) {
 			input->flags |= IEOF;
 			return 0;
 		}
 		if (t == IMACRO) {
 			wasexpand = 1;
 			input->flags |= IEOF;
 		}
 		if (input->flags & IEOF) {
 			delinput();
 			goto repeat;
 		}
 		if (!readline()) {
 			*input->p = '\0';
 			goto repeat;
 		}
 		if (cpp())
 			goto repeat;
 	}
 
 	if (onlycpp && !wasexpand)
 		ppragmaln();
 	return 1;
 }
 
 static void
 tok2str(void)
 {
 	if ((yylen = input->p - input->begin) >= sizeof(yytext))
 		error("token too big");
 	memcpy(yytext, input->begin, yylen);
 	yytext[yylen] = '\0';
 	input->begin = input->p;
 }
 
 static Symbol *
 readint(int base, int sign, Symbol *sym)
 {
 	char *s = yytext;
 	Type *tp = sym->type;
 	struct limits *lim;
 	unsigned long long u, val, max;
 	int c;
 
 	lim = getlimits(tp);
 	max = lim->max.i;
 	if (*s == '0')
 		++s;
 	if (toupper(*s) == 'X')
 		++s;
 
 	for (u = 0; isxdigit(c = *s++); u = u*base + val) {
 		static char letters[] = "0123456789ABCDEF";
 		val = strchr(letters, toupper(c)) - letters;
 	repeat:
 		if (u <= max/base && u*base <= max - val)
 			continue;
 		if (tp->prop & TSIGNED) {
 			if (tp == inttype)
 				tp = (base==10) ? longtype : uinttype;
 			else if (tp == longtype)
 				tp = (base==10) ? llongtype : ulongtype;
 			else if (tp == llongtype && base != 10)
 				tp = ullongtype;
 			else
 				goto overflow;
 		} else {
 			if (tp == uinttype)
 				tp = (sign==UNSIGNED) ? ulongtype : longtype;
 			else if (tp == ulongtype)
 				tp = (sign==UNSIGNED) ? ullongtype : llongtype;
 			else
 				goto overflow;
 		}
 		sym->type = tp;
 		lim = getlimits(tp);
 		max = lim->max.i;
 		goto repeat;
 	}
 
 	if (tp->prop & TSIGNED)
 		sym->u.i = u;
 	else
 		sym->u.u = u;
 
 	return sym;
 
 overflow:
 	errorp("overflow in integer constant");
 	return sym;
 }
 
 static int
 integer(int base)
 {
 	Type *tp;
 	Symbol *sym;
 	unsigned size, sign;
 
 	for (size = sign = 0; ; ++input->p) {
 		switch (toupper(*input->p)) {
 		case 'L':
 			if (size == LLONG)
 				goto wrong_type;
 			size = (size == LONG) ? LLONG : LONG;
 			continue;
 		case 'U':
 			if (sign == UNSIGNED)
 				goto wrong_type;
 			sign = UNSIGNED;
 			continue;
 		default:
 			goto convert;
 		wrong_type:
 			error("invalid suffix in integer constant");
 		}
 	}
 
 convert:
 	tok2str();
 	tp = ctype(INT, sign, size);
 	sym = newsym(NS_IDEN, NULL);
 	sym->type = tp;
 	sym->flags |= SCONSTANT;
 	yylval.sym = readint(base, sign, sym);
 	return CONSTANT;
 }
 
 static void
 digits(int base)
 {
 	char *p;
 	int c;
 
 	for (p = input->p; c = *p; ++p) {
 		switch (base) {
 		case 8:
 			if (!strchr("01234567", c))
 				goto end;
 			break;
 		case 10:
 			if (!isdigit(c))
 				goto end;
 			break;
 		case 16:
 			if (!isxdigit(c))
 				goto end;
 			break;
 		}
 	}
 end:
 	input->p = p;
 }
 
 static int
 number(void)
 {
 	Type *tp;
 	Symbol *sym;
 	int ch, base;
 	long double ld;
 
 	if (*input->p != '0') {
 		base = 10;
 	} else {
 		if (toupper(*++input->p) == 'X') {
 			++input->p;
 			base = 16;
 		} else {
 			base = 8;
 		}
 	}
 	digits(base);
 
 	if (*input->p != '.')
 		return integer(base);
 
 	sym = newsym(NS_IDEN, NULL);
 
 	ld = strtold(input->begin, &input->p);
 	switch (toupper(*input->p)) {
 	case 'F':
 		++input->p;
 		tp = floattype;
 		sym->u.f = ld;
 		break;
 	case 'L':
 		++input->p;
 		tp = ldoubletype;
 		sym->u.ld = ld;
 		break;
 	default:
 		tp = doubletype;
 		sym->u.d = ld;
 		break;
 	}
 
 	tok2str();
 	sym->type = tp;
 	sym->flags |= SCONSTANT;
 	yylval.sym = sym;
 	return CONSTANT;
 }
 
 static Rune
 escape(int multi)
 {
 	Rune c;
 	int uni, d, i, cnt, base;
 
 	switch (*++input->p) {
 	case 'a':
 		return '\a';
 	case 'b':
 		return '\b';
 	case 'f':
 		return '\f';
 	case 'n':
 		return '\n';
 	case 'r':
 		return '\r';
 	case 't':
 		return '\t';
 	case 'v':
 		return '\v';
 	case '"':
 		return '"';
 	case '\'':
 		return '\'';
 	case '\\':
 		return '\\';
 	case '\?':
 		return '\?';
 	case 'U':
 		cnt = 8;
 		goto check_universal;
 	case 'u':
 		cnt = 4;
 	check_universal:
 		if (!multi)
 			warn("multi-character character constant");
 		++input->p;
 		uni = 1;
 		base = 16;
 		break;
 	case 'x':
 		++input->p;
 		uni = 0;
 		cnt = 2;
 		base = 16;
 		break;
 	case '0':
 	case '1':
 	case '2':
 	case '3':
 	case '4':
 	case '5':
 	case '6':
 	case '7':
 		uni = 0;
 		cnt = 3;
 		base = 8;
 		break;
 	default:
 		warn("unknown escape sequence");
 		return ' ';
 	}
 
 	for (c = i = 0; i < cnt && isxdigit(*input->p); ++i) {
 		static char digits[] = "0123456789ABCDEF";
 		char *p = strchr(digits, toupper(*input->p));
 
 		if (!p || (d = p - digits) > base)
 			break;
 		c *= base;
 		c += d;
 		++input->p;
 	}
 	--input->p;
 
 	if (base == 16 && i != cnt) {
 		if (uni) {
 			errorp("incorrect digit for universal character constant");
 			c = REPLACECHAR;
 		} else {
 			errorp("\\x used with no following hex digits");
 			c = ' ';
 		}
 	}
 
 	if (!uni)
 		return c;
 
 	if (c < 0xa0 && c != 0x24 && c != 0x40 && c != 0x60
 	|| c >= 0xD800 && c <= 0xDFFF
 	|| c >= 0x110000) {
 		errorp("invalid universal character constant");
 		c = REPLACECHAR;
 	}
 
 	return c;
 }
 
 static int
 validutf8(Rune wc, int *nbytes)
 {
 	static struct range {
 		unsigned long begin, end;
 		int valid;
 		int nbytes;
 	} ranges[] = {
 		{0,         0x80,       1, 1},
 		{0x80,      0x800,      1, 2},
 		{0x800,     0xD800,     1, 3},
 		{0xD800,    0xDD00,     0, 3},
 		{0xDD00,    0x10000,    1, 3},
 		{0x10000,   0x110000,   1, 4},
 		{0x110000,  -1ul,       0, 0},
 	};
 	struct range *bp;
 
 	for (bp = ranges; bp->begin > wc || bp->end <= wc; ++
 bp)
 		;
 	*nbytes = bp->nbytes;
 
 	return bp->valid;
 }
 
 static Rune
 utf8rune(void)
 {
 	Rune wc;
 	int i, sh, n;
 	unsigned oc, c;
 	unsigned char *s = (unsigned char *) input->p;
 
 	/* fast track for ascii */
 	if ((c = *s) < 0x80)
 		return c;
 
 	/* out of sequence multibyte? */
 	if ((c & 0xc0) != 0xc0)
 		goto invalid;
 
 	sh = 1;
 	wc = 0;
 	oc = c << 1;
 
 	for (i = 0; i < UTF8_MAX; ++i) {
 		c = s[1];
 		if ((c & 0xc0) != 0x80)
 			goto invalid;
 		++s;
 
 		wc <<= 6;
 		wc |= c & 0x3f;
 		oc <<= 1;
 		sh++;
 
 		if ((oc & 0x80) == 0) {
 			oc = (oc & 0xff) >> sh;
 			wc |= oc << (sh-1) * 6;
 
 			if (!validutf8(wc, &n) || sh != n)
 				goto invalid;
 			goto return_code;
 		}
 	}
 
 invalid:
 	errorp("invalid multibyte sequence");
 	wc = REPLACECHAR;
 
 return_code:
 	input->p = s;
 	return wc;
 }
 
 static Rune
 decode(int multi)
 {
 	Rune r;
 
 	if (*input->p == '\\') {
 		r = escape(multi);
 		return r;
 	}
 
 	return multi ? utf8rune() : *input->p;
 }
 
 static int
 character(void)
 {
 	int i, multi = NOMULTICHAR;
 	Rune r;
 	Type *tp;
 	Symbol *sym;
 	long long d;
 	struct limits *lim;
 
 	tp = chartype;
 	if (*input->p == 'L') {
 		multi = MULTICHAR;
 		input->p++;
 		tp = wchartype;
 	}
 
 	lim = getlimits(tp);
 
 	d = 0;
 	input->p++;
 	for (i = 0; *input->p != '\''; i++) {
 		r = decode(multi);
 		if (r > lim->max.i)
 			warn("character too large for enclosing character literal type");
 		d |= r;
 		input->p++;
 	}
 	input->p++;
 
 	if (i == 0)
 		errorp("empty character constant");
 	if (i > 1)
 		warn("multi-character character constant");
 
 	if (tp == chartype) {
 		if (tp->prop & TSIGNED && d > lim->max.i)
 			d -= getlimits(uchartype)->max.i + 1;
 		tp = inttype;
 	}
 
 	sym = newsym(NS_IDEN, NULL);
 	sym->u.i = d;
 	sym->type = tp;
 	yylval.sym = sym;
 	tok2str();
 
 	return CONSTANT;
 }
 
 static int
 rstring(void)
 {
 	char *beg = input->p++;
 	Rune c, buff[STRINGSIZ+1], *bp = buff;
 
 	for (++input->p; ; ++input->p) {
 		switch (*input->p) {
 		case '\0':
 			errorp("missing terminating '\"' character");
 		case '"':
 			goto end_loop;
 		}
 
 		c = decode(MULTICHAR);
 		if (input->p - beg == STRINGSIZ + 1) {
 			/* too long, ignore everything until next quote */
 			for (++input->p; *input->p != '"'; ++input->p) {
 				if (*input->p == '\\')
 					++input->p;
 				if (*input->p == '\0')
 					break;
 			}
 			--bp;
 			errorp("string too long");
 			break;
 		}
 		*bp++ = c;
 	}
 
 end_loop:
 	*bp++ = '\0';
 	input->p++;
 
 	yylval.sym = newrstring(buff, bp - buff);
 	tok2str();
 
 	return STRING;
 }
 
 static int
 sstring(void)
 {
 	int c;
 	struct limits *lim;
 	char buff[STRINGSIZ+1], *bp = buff, *beg = input->p;
 
 	for (++input->p; ; ++input->p) {
 		switch (*input->p) {
 		case '\0':
 			errorp("missing terminating '\"' character");
 		case '"':
 			goto end_loop;
 		}
 
 		c = decode(NOMULTICHAR);
 		if (input->p - beg == STRINGSIZ + 1) {
 			/* too long, ignore everything until next quote */
 			for (++input->p; *input->p != '"'; ++input->p) {
 				if (*input->p == '\\')
 					++input->p;
 				if (*input->p == '\0')
 					break;
 			}
 			--bp;
 			errorp("string too long");
 			break;
 		}
 		*bp++ = c;
 	}
 
 end_loop:
 	*bp++ = '\0';
 	input->p++;
 
 	yylval.sym = newstring(buff, bp - buff);
 	tok2str();
 
 	return STRING;
 }
 
 static int
 string(void)
 {
 	if (*input->p == 'L')
 		return rstring();
 	return sstring();
 }
 
 static int
 iden(void)
 {
 	Symbol *sym;
 	char *p, *begin;
 
 	if (input->p[0] == 'L' && input->p[1] == '\'')
 		return character();
 
 	if (input->p[0] == 'L' && input->p[1] == '"')
 		return string();
 
 	begin = input->p;
 	for (p = begin; isalnum(*p) || *p == '_'; ++p)
 		;
 	input->p = p;
 	tok2str();
 
 	sym = lookup(NS_CPP, yytext, NOALLOC);
 	if ((yylval.cppsym = sym) != NULL) {
 		if (expand(sym))
 			return next();
 	}
 
 	sym = lookup(namespace, yytext, ALLOC);
 	yylval.sym = sym;
 	if (sym->flags & SCONSTANT)
 		return CONSTANT;
 	if (sym->token != IDEN)
 		yylval.token = sym->u.token;
 	return sym->token;
 }
 
 static int
 follow(int expect, int ifyes, int ifno)
 {
 	if (*input->p++ == expect)
 		return ifyes;
 	--input->p;
 	return ifno;
 }
 
 static int
 minus(void)
 {
 	switch (*input->p++) {
 	case '-':
 		return DEC;
 	case '>':
 		return INDIR;
 	case '=':
 		return SUB_EQ;
 	default:
 		--input->p;
 		return '-';
 	}
 }
 
 static int
 plus(void)
 {
 	switch (*input->p++) {
 	case '+':
 		return INC;
 	case '=':
 		return ADD_EQ;
 	default:
 		--input->p;
 		return '+';
 	}
 }
 
 static int
 relational(int op, int equal, int shift, int assig)
 {
 	int c;
 
 	if ((c = *input->p++) == '=')
 		return equal;
 	if (c == op)
 		return follow('=', assig, shift);
 	--input->p;
 	return op;
 }
 
 static int
 logic(int op, int equal, int logic)
 {
 	int c;
 
 	if ((c = *input->p++) == '=')
 		return equal;
 	if (c == op)
 		return logic;
 	--input->p;
 	return op;
 }
 
 static int
 dot(void)
 {
 	int c;
 
 	if (isdigit(*input->p))
 		return number();
 	if ((c = *input->p) != '.')
 		return '.';
 	if ((c = *++input->p) != '.')
 		error("incorrect token '..'");
 	++input->p;
 	return ELLIPSIS;
 }
 
 static int
 operator(void)
 {
 	int t;
 
 	switch (t = *input->p++) {
 	case '<':
 		t = relational('<', LE, SHL, SHL_EQ);
 		break;
 	case '>':
 		t = relational('>', GE, SHR, SHR_EQ);
 		break;
 	case '&':
 		t = logic('&', AND_EQ, AND);
 		break;
 	case '|':
 		t = logic('|', OR_EQ, OR);
 		break;
 	case '=':
 		t = follow('=', EQ, '=');
 		break;
 	case '^':
 		t = follow('=', XOR_EQ, '^');
 		break;
 	case '*':
 		t = follow('=', MUL_EQ, '*');
 		break;
 	case '/':
 		t = follow('=', DIV_EQ, '/');
 		break;
 	case '%':
 		t = follow('=', MOD_EQ, '%');
 		break;
 	case '!':
 		t = follow('=', NE, '!');
 		break;
 	case '-':
 		t = minus();
 		break;
 	case '+':
 		t = plus();
 		break;
 	case '.':
 		t = dot();
 		break;
 	}
 	tok2str();
 	return t;
 }
 
 /* TODO: Ensure that namespace is NS_IDEN after a recovery */
 
 /*
  * skip all the spaces until the next token. When we are in
  * CPPMODE \n is not considered a whitespace
  */
 static int
 skipspaces(void)
 {
 	int c;
 
 	if (!input)
 		return EOF;
 
 	for (;;) {
 		switch (c = *input->p) {
 		case '\0':
 			if (!moreinput())
 				return EOF;
 			break;
 		case '\n':
 		case ' ':
 		case '\t':
 		case '\v':
 		case '\r':
 		case '\f':
 			yyspace = c;
 			if (c == '\n' && lexmode == CPPMODE)
 				goto return_byte;
 			++input->p;
 			break;
 		default:
 			goto return_byte;
 		}
 	}
 
 return_byte:
 	input->begin = input->p;
 	return c;
 }
 
 static int
 lex(void)
 {
 	int c;
 
 repeat:
 	switch (c = skipspaces()) {
 	case EOF:
 		return EOFTOK;
 	case NOEXPAND:
 	case EXPAND:
 		disexpand += (c == NOEXPAND) ? +1 : -1;
 		input->p++;
 		goto repeat;
 	case '_':
 		return iden();
 	case '"':
 		return string();
 	case '\'':
 		return character();
 	default:
 		if (isalpha(c))
 			return iden();
 		if (isdigit(c))
 			return number();
 		return operator();
 	}
 }
 
 int
 next(void)
 {
 	yytoken = lex();
 
 	if (yytoken == EOFTOK) {
 		strcpy(yytext, "<EOF>");
 		if (cppctx && !input)
 			errorp("#endif expected");
 	}
 
 	DBG("TOKEN %s", yytext);
 	return yytoken;
 }
 
 void
 expect(int tok)
 {
 	if (yytoken != tok) {
 		if (isgraph(tok))
 			errorp("expected '%c' before '%s'", tok, yytext);
 		else
 			errorp("unexpected '%s'", yytext);
 	} else {
 		next();
 	}
 }
 
 int
 ahead(void)
 {
 	skipspaces();
 	return *input->begin;
 }
 
 void
 setsafe(int type)
 {
 	safe = type;
 }
 
 void
 discard(void)
 {
 	extern jmp_buf recover;
 	int c;
 
 	if (!input)
 		exit(EXIT_FAILURE);
 	for (c = yytoken; ; c = *input->p++) {
 		switch (safe) {
 		case END_COMP:
 			if (c == '}')
 				goto jump;
 			goto semicolon;
 		case END_COND:
 			if (c == ')')
 				goto jump;
 			break;
 		case END_LDECL:
 			if (c == ',')
 				goto jump;
 		case END_DECL:
 		semicolon:
 			if (c == ';')
 				goto jump;
 			break;
 		}
 		if ((c == '\0' || c == EOFTOK) && !moreinput())
 			exit(EXIT_FAILURE);
 	}
 jump:
 	input->begin = input->p;
 	yytoken = c;
 	yytext[0] = c;
 	yytext[1] = '\0';
 	exit(EXIT_FAILURE);
 
 	/*
 	 * FIXME: We don't have a proper recover mechanism at this moment
 	 * and we don't set the recover point ever, so executing this
 	 * longjmp will generate surely a segmentation fault, so it does
 	 * not make sense to do it. We just exit until we can find time
 	 * to solve this problem.
 	 */
 	longjmp(recover, 1);
 }