scc

lex.c (16737B)

---

 #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"
 
 int yytoken;
 struct yystype yylval;
 char yytext[STRINGSIZ+3];
 unsigned short yylen;
 int 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;
 	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);
 	}
 
 	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;
 	input = newip;
 
 	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();
 	}
 
 	input = ip->next;
 	free(ip->filenam);
 	free(ip->line);
 	free(ip);
 	if (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
  */
 static 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) > INTIDENTSIZ)
 		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
 				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 int
 escape(void)
 {
 	int c, 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':
 		/*
 		 * FIXME: universal constants are not correctly handled
 		 */
 		if (!isdigit(*++input->p))
 			warn("incorrect digit for numerical character constant");
 		base = 10;
 		break;
 	case 'x':
 		if (!isxdigit(*++input->p))
 			warn("\\x used with no following hex digits");
 		cnt = 2;
 		base = 16;
 		break;
 	case '0':
 	case '1':
 	case '2':
 	case '3':
 	case '4':
 	case '5':
 	case '6':
 	case '7':
 		cnt = 3;
 		base = 8;
 		break;
 	default:
 		warn("unknown escape sequence");
 		return ' ';
 	}
 
 	for (c = i = 0; i < cnt; ++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;
 
 	return c;
 }
 
 static Rune
 utf8rune(void)
 {
 	Rune wc;
 	unsigned c;
 	size_t i, len;
 
 	c = *input->p;
 	for (len = 0; c & 0x80; len++)
 		c <<= 1;
 	if (len == 0)
 		return c;
 	if (len == 1 || len == 8)
 		goto invalid;
 
 	wc = (c & 0xFF) >> len;
 	for (i = 0; i < len-1; i++) {
 		c = input->p[1];
 		if ((c & 0xC0) != 0x80)
 			goto invalid;
 		input->p++;
 		wc <<= 6;
 		wc |= c & 0x3F;
 	}
 	return wc;
 
 invalid:
 	errorp("invalid multibyte sequence");
 	return 0xFFFD;
 }
 
 static Rune
 decode(int multi)
 {
 	Rune r;
 
 	if (*input->p == '\\') {
 		r = escape();
 		return r;
 	}
 
 	return multi ? utf8rune() : *input->p;
 }
 
 static int
 character(void)
 {
 	int i, multi = 0;
 	Rune r, d;
 	Type *tp = inttype;
 	Symbol *sym;
 
 	if (*input->p == 'L') {
 		multi = 1;
 		tp = wchartype;
 		input->p++;
 	}
 
 	d = 0;
 	input->p++;
 	for (i = 0; *input->p != '\''; i++) {
 		r = decode(multi);
 		if (r > getlimits(tp)->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");
 
 	sym = newsym(NS_IDEN, NULL);
 	sym->u.i = d;
 	sym->type = tp;
 	yylval.sym = sym;
 	tok2str();
 	return CONSTANT;
 }
 
 /*
  * string() parses a constant string, and convert all the
  * escape sequences into single characters. This behaviour
  * is correct except when we parse a #define, where we want
  * to preserve the literal content of the string. In that
  * case cpp.c:/^define( sets the variable disescape to
  * disable converting escape sequences into characters.
  */
 static int
 string(void)
 {
 	char *bp = yytext;
 	int c, esc;
 
 	*bp++ = '"';
 	esc = 0;
 	for (++input->p; ; ++input->p) {
 		c = *input->p;
 
 		if (c == '"' && !esc)
 			break;
 
 		if (c == '\0') {
 			errorp("missing terminating '\"' character");
 			break;
 		}
 
 		esc = (c == '\\' && !esc && disescape);
 
 		if (c == '\\' && !esc)
 			c = escape();
 
 		if (bp == &yytext[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;
 	}
 
 	input->begin = ++input->p;
 	*bp = '\0';
 
 	yylen = bp - yytext + 1;
 	yylval.sym = newstring(yytext+1, yylen-1);
 	*bp++ = '"';
 	*bp = '\0';
 	return STRING;
 }
 
 static int
 iden(void)
 {
 	Symbol *sym;
 	char *p, *begin;
 
 	if (input->p[0] == 'L' && input->p[1] == '\'')
 		return character();
 
 	begin = input->p;
 	for (p = begin; isalnum(*p) || *p == '_'; ++p)
 		;
 	input->p = p;
 	tok2str();
 	if ((sym = lookup(NS_CPP, yytext, NOALLOC)) != 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 '\n':
 			if (lexmode == CPPMODE)
 				goto return_byte;
 			++input->p;
 		case '\0':
 			if (!moreinput())
 				return EOF;
 			break;
 		case ' ':
 		case '\t':
 		case '\v':
 		case '\r':
 		case '\f':
 			++input->p;
 			break;
 		default:
 			goto return_byte;
 		}
 	}
 
 return_byte:
 	input->begin = input->p;
 	return c;
 }
 
 int
 next(void)
 {
 	int c;
 
 	if ((c = skipspaces()) == EOF)
 		yytoken = EOFTOK;
 	else if (isalpha(c) || c == '_')
 		yytoken = iden();
 	else if (isdigit(c))
 		yytoken = number();
 	else if (c == '"')
 		yytoken = string();
 	else if (c == '\'')
 		yytoken = character();
 	else
 		yytoken = operator();
 
 	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;
 
 	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);
 }