scc

cpp.c (14562B)

---

 static char sccsid[] = "@(#) ./cc1/cpp.c";
 #include <ctype.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 
 #include <cstd.h>
 #include "../inc/scc.h"
 #include "cc1.h"
 
 static char *argp, *macroname;
 static unsigned arglen;
 static unsigned ncmdlines;
 static Symbol *symline, *symfile;
 static unsigned char ifstatus[NR_COND];
 static int cppoff;
 static struct items dirinclude;
 
 unsigned cppctx;
 int disexpand;
 
 void
 defdefine(char *macro, char *val, char *source)
 {
 	char *def, *fmt = "#define %s %s\n";
 	Symbol dummy = {.flags = SDECLARED};
 
 	if (!val)
 		val = "";
 	def = xmalloc(strlen(fmt) + strlen(macro) + strlen(val));
 
 	sprintf(def, fmt, macro, val);
 	lineno = ++ncmdlines;
 	addinput(source, &dummy, def);
 	cpp();
 	delinput();
 }
 
 void
 undefmacro(char *s)
 {
 	killsym(lookup(NS_CPP, s, NOALLOC));
 }
 
 void
 icpp(void)
 {
 	static char sdate[14], stime[11];
 	struct tm *tm;
 	time_t t;
 	static char **bp, *list[] = {
 		"__STDC__",
 		"__STDC_HOSTED__",
 		"__SCC__",
 		NULL
 	};
 	static struct keyword keys[] = {
 		{"define", DEFINE, DEFINE},
 		{"include", INCLUDE, INCLUDE},
 		{"line", LINE, LINE},
 		{"ifdef", IFDEF, IFDEF},
 		{"if", IF, IF},
 		{"elif", ELIF, ELIF},
 		{"else", ELSE, ELSE},
 		{"ifndef", IFNDEF, IFNDEF},
 		{"endif", ENDIF, ENDIF},
 		{"undef", UNDEF, UNDEF},
 		{"pragma", PRAGMA, PRAGMA},
 		{"error", ERROR, ERROR},
 		{NULL, 0, 0}
 	};
 
 	keywords(keys, NS_CPPCLAUSES);
 
 	t = time(NULL);
 	tm = localtime(&t);
 	strftime(sdate, sizeof(sdate), "\"%b %d %Y\"", tm);
 	strftime(stime, sizeof(stime), "\"%H:%M:%S\"", tm);
 	defdefine("__DATE__", sdate, "built-in");
 	defdefine("__TIME__", stime, "built-in");
 	defdefine("__STDC_VERSION__", STDC_VERSION, "built-in");
 	defdefine("__LINE__", NULL, "built-in");
 	defdefine("__FILE__", NULL, "built-in");
 
 	symline = lookup(NS_CPP, "__LINE__", ALLOC);
 	symfile = lookup(NS_CPP, "__FILE__", ALLOC);
 
 	for (bp = list; *bp; ++bp)
 		defdefine(*bp, "1", "built-in");
 
 	ncmdlines = 0;
 }
 
 static void
 nextcpp(void)
 {
 	next();
 	if (yytoken == EOFTOK)
 		error("unterminated argument list invoking macro \"%s\"",
 		      macroname);
 	if (yylen + 1 > arglen)
 		error("argument overflow invoking macro \"%s\"",
 		      macroname);
 	if (yytoken == IDEN)
 		yylval.sym->flags |= SUSED;
 	memcpy(argp, yytext, yylen);
 	argp += yylen;
 	*argp++ = ' ';
 	arglen -= yylen + 1;
 }
 
 static void
 paren(void)
 {
 	for (;;) {
 		nextcpp();
 		switch (yytoken) {
 		case ')':
 			return;
 		case '(':
 			paren();
 			break;
 		}
 	}
 }
 
 static void
 parameter(void)
 {
 	for (;;) {
 		nextcpp();
 		switch (yytoken) {
 		case ')':
 		case ',':
 			argp -= 3;  /* remove " , "  or " ) "*/
 			*argp++ = '\0';
 			return;
 		case '(':
 			paren();
 			break;
 		}
 	}
 }
 
 static int
 parsepars(char *buffer, char **listp, int nargs)
 {
 	int n;
 
 	if (nargs == -1)
 		return -1;
 	if (ahead() != '(' && nargs > 0)
 		return 0;
 
 	disexpand = 1;
 	next();
 	n = 0;
 	argp = buffer;
 	arglen = INPUTSIZ;
 	if (ahead() == ')') {
 		next();
 	} else {
 		do {
 			*listp++ = argp;
 			parameter();
 		} while (++n < NR_MACROARG && yytoken == ',');
 	}
 	if (yytoken != ')')
 		error("incorrect macro function-alike invocation");
 	disexpand = 0;
 
 	if (n == NR_MACROARG)
 		error("too many parameters in macro \"%s\"", macroname);
 	if (n != nargs) {
 		error("macro \"%s\" received %d arguments, but it takes %d",
 		      macroname, n, nargs);
 	}
 
 	return 1;
 }
 
 static size_t
 copymacro(char *buffer, char *s, size_t bufsiz, char *arglist[])
 {
 	int delim, prevc, c;
 	char *p, *arg, *bp = buffer;
 	size_t size;
 
 	for (prevc = '\0'; c = *s; prevc = c, ++s) {
 		switch (c) {
 		case '$':
 			while (bp[-1] == ' ')
 				--bp, ++bufsiz;
 			while (s[1] == ' ')
 				++s;
 		case '#':
 			break;
 		case '\'':
 			delim = '\'';
 			goto search_delim;
 		case '\"':
 			delim = '"';
 		search_delim:
 			for (p = s; *++s != delim; )
 				/* nothing */;
 			size = s - p + 1;
 			if (size > bufsiz)
 				goto expansion_too_long;
 			memcpy(bp, p, size);
 			bufsiz -= size;
 			bp += size;
 			break;
 		case '@':
 			if (prevc == '#')
 				bufsiz -= 2;
 			arg = arglist[atoi(++s)];
 			size = strlen(arg);
 			if (size > bufsiz)
 				goto expansion_too_long;
 			if (prevc == '#')
 				*bp++ = '"';
 			memcpy(bp, arg, size);
 			bp += size;
 			if (prevc == '#')
 				*bp++ = '"';
 			bufsiz -= size;
 			s += 2;
 			break;
 		default:
 			if (bufsiz-- == 0)
 				goto expansion_too_long;
 			*bp++ = c;
 			break;
 		}
 	}
 	*bp = '\0';
 
 	return bp - buffer;
 
 expansion_too_long:
 	error("macro expansion of \"%s\" too long", macroname);
 }
 
 int
 expand(char *begin, Symbol *sym)
 {
 	size_t elen;
 	int n, i;
 	char *s = sym->u.s;
 	char *arglist[NR_MACROARG], arguments[INPUTSIZ], buffer[INPUTSIZ];
 
 	macroname = sym->name;
 	if (sym == symfile) {
 		elen = sprintf(buffer, "\"%s\" ", filenam);
 		goto substitute;
 	}
 	if (sym == symline) {
 		elen = sprintf(buffer, "%d ", lineno);
 		goto substitute;
 	}
 	if (!s)
 		return 1;
 
 	n = atoi(s);
 	if (!parsepars(arguments, arglist, atoi(s)))
 		return 0;
 	for (i = 0; i < n; ++i)
 		DBG("MACRO par%d:%s", i, arglist[i]);
 
 	elen = copymacro(buffer, s+3, INPUTSIZ-1, arglist);
 
 substitute:
 	DBG("MACRO '%s' expanded to :'%s'", macroname, buffer);
 	buffer[elen] = '\0';
 	addinput(filenam, sym, xstrdup(buffer));
 
 	return 1;
 }
 
 static int
 getpars(Symbol *args[NR_MACROARG])
 {
 	int n, c;
 	Symbol *sym;
 
 	c = *input->p;
 	next();
 	if (c != '(')
 		return -1;
 	next(); /* skip the '(' */
 	if (accept(')'))
 		return 0;
 
 	n = 0;
 	do {
 		if (n == NR_MACROARG) {
 			cpperror("too many parameters in macro");
 			return NR_MACROARG;
 		}
 		if (accept(ELLIPSIS)) {
 			args[n++] = NULL;
 			break;
 		}
 		if (yytoken != IDEN) {
 			cpperror("macro arguments must be identifiers");
 			return NR_MACROARG;
 		}
 		sym = install(NS_IDEN, yylval.sym);
 		sym->flags |= SUSED;
 		args[n++] = sym;
 		next();
 	} while (accept(','));
 	expect(')');
 
 	return n;
 }
 
 static int
 getdefs(Symbol *args[NR_MACROARG], int nargs, char *bp, size_t bufsiz)
 {
 	Symbol **argp;
 	size_t len;
 	int prevc = 0, ispar;
 
 	if (yytoken == '$') {
 		cpperror("'##' cannot appear at either ends of a macro expansion");
 		return 0;
 	}
 
 	for (;;) {
 		ispar = 0;
 		if (yytoken == IDEN && nargs >= 0) {
 			for (argp = args; argp < &args[nargs]; ++argp) {
 				if (*argp == yylval.sym)
 					break;
 			}
 			if (argp != &args[nargs]) {
 				sprintf(yytext, "@%02d@", (int) (argp - args));
 				ispar = 1;
 			}
 		}
 		if (prevc == '#' && !ispar) {
 			cpperror("'#' is not followed by a macro parameter");
 			return 0;
 		}
 		if (yytoken == '\n')
 			break;
 
 		if ((len = strlen(yytext)) >= bufsiz) {
 			cpperror("macro too long");
 			return 0;
 		}
 		if (yytoken == '$') {
 			*bp++ = '$';
 			 --bufsiz;
 		} else {
 			memcpy(bp, yytext, len);
 			bp += len;
 			bufsiz -= len;
 		}
 		if ((prevc = yytoken) != '#') {
 			*bp++ = ' ';
 			--bufsiz;
 		}
 		next();
 	}
 	*bp = '\0';
 	return 1;
 }
 
 static void
 define(void)
 {
 	Symbol *sym,*args[NR_MACROARG];
 	char buff[LINESIZ+1];
 	int n;
 
 	if (cppoff)
 		return;
 
 	namespace = NS_CPP;
 	next();
 
 	if (yytoken != IDEN) {
 		cpperror("macro names must be identifiers");
 		return;
 	}
 	sym = yylval.sym;
 	if (sym->flags & SDECLARED) {
 		warn("'%s' redefined", yytext);
 		free(sym->u.s);
 	} else {
 		sym = install(NS_CPP, sym);
 		sym->flags |= SDECLARED|SSTRING;
 	}
 
 	namespace = NS_IDEN;       /* Avoid polution in NS_CPP */
 	if ((n = getpars(args)) == NR_MACROARG)
 		goto delete;
 	if (n > 0 && !args[n-1])  /* it is a variadic function */
 		--n;
 	sprintf(buff, "%02d#", n);
 	if (!getdefs(args, n, buff+3, LINESIZ-3))
 		goto delete;
 	sym->u.s = xstrdup(buff);
 	DBG("MACRO '%s' defined as '%s'", sym->name, buff);
 	return;
 
 delete:
 	killsym(sym);
 }
 
 void
 incdir(char *dir)
 {
 	if (!dir || *dir == '\0')
 		die("incorrect -I flag");
 	newitem(&dirinclude, dir);
 }
 
 static int
 includefile(char *dir, char *file, size_t filelen)
 {
 	size_t dirlen;
 	char path[FILENAME_MAX];
 
 	if (!dir) {
 		dirlen = 0;
 		if (filelen > FILENAME_MAX-1)
 			return 0;
 	} else {
 		dirlen = strlen(dir);
 		if (dirlen + filelen > FILENAME_MAX-2)
 			return 0;
 		memcpy(path, dir, dirlen);
 		if (dir[dirlen-1] != '/')
 			path[dirlen++] = '/';
 	}
 	memcpy(path+dirlen, file, filelen);
 	path[dirlen + filelen] = '\0';
 
 	return addinput(path, NULL, NULL);
 }
 
 static char *
 cwd(char *buf)
 {
 	char *p, *s = filenam;
 	size_t len;
 
 	if ((p = strrchr(s, '/')) == NULL)
 		return NULL;
 	if ((len = p - s) >= FILENAME_MAX)
 		die("current work directory too long");
 	memcpy(buf, s, len);
 	buf[len] = '\0';
 	return buf;
 }
 
 static void
 include(void)
 {
 	char dir[FILENAME_MAX], file[FILENAME_MAX], *p, **bp;
 	size_t filelen;
 	int n;
 
 	if (cppoff)
 		return;
 
 	namespace = NS_IDEN;
 	next();
 
 	switch (*yytext) {
 	case '<':
 		if ((p = strchr(input->begin, '>')) == NULL || p[-1] == '<')
 			goto bad_include;
 		filelen = p - input->begin;
 		if (filelen >= FILENAME_MAX)
 			goto too_long;
 		memcpy(file, input->begin, filelen);
 		file[filelen] = '\0';
 
 		input->begin = input->p = p+1;
 		if (next() != '\n')
 			goto trailing_characters;
 
 		break;
 	case '"':
 		if (yylen < 3)
 			goto bad_include;
 		filelen = yylen-2;
 		if (filelen >= FILENAME_MAX)
 			goto too_long;
 		memcpy(file, yytext+1, filelen);
 		file[filelen] = '\0';
 
 		if (next() != '\n')
 			goto trailing_characters;
 
 		if (includefile(cwd(dir), file, filelen))
 			goto its_done;
 		break;
 	default:
 		goto bad_include;
 	}
 
 	n = dirinclude.n;
 	for (bp = dirinclude.s; n--; ++bp) {
 		if (includefile(*bp, file, filelen))
 			goto its_done;
 	}
 	cpperror("included file '%s' not found", file);
 
 its_done:
 	return;
 
 trailing_characters:
 	cpperror("trailing characters after preprocessor directive");
 	return;
 
 too_long:
 	cpperror("too long file name in #include");
 	return;
 
 bad_include:
 	cpperror("#include expects \"FILENAME\" or <FILENAME>");
 	return;
 }
 
 static void
 line(void)
 {
 	long n;
 	char *endp, *fname;
 
 	if (cppoff)
 		return;
 
 	disexpand = 0;
 	next();
 	n = strtol(yytext, &endp, 10);
 	if (n <= 0 || n > USHRT_MAX || *endp != '\0') {
 		cpperror("first parameter of #line is not a positive integer");
 		return;
 	}
 
 	next();
 	if (yytoken == '\n') {
 		fname = NULL;
 	} else {
 		if (*yytext != '\"' || yylen == 1) {
 			cpperror("second parameter of #line is not a valid filename");
 			return;
 		}
 		fname = yylval.sym->u.s;
 	}
 	setloc(fname, n - 1);
 	if (yytoken != '\n')
 		next();
 }
 
 static void
 pragma(void)
 {
 	if (cppoff)
 		return;
 	next();
 	warn("ignoring pragma '%s'", yytext);
 	*input->p = '\0';
 	next();
 }
 
 static void
 usererr(void)
 {
 	if (cppoff)
 		return;
 	cpperror("#error %s", input->p);
 	*input->p = '\0';
 	next();
 }
 
 static void
 ifclause(int negate, int isifdef)
 {
 	Symbol *sym;
 	unsigned n;
 	int status;
 	Node *expr;
 
 	if (cppctx == NR_COND-1)
 		error("too many nesting levels of conditional inclusion");
 
 	n = cppctx++;
 	namespace = NS_CPP;
 	next();
 
 	if (isifdef) {
 		if (yytoken != IDEN) {
 			cpperror("no macro name given in #%s directive",
 			         (negate) ? "ifndef" : "ifdef");
 			return;
 		}
 		sym = yylval.sym;
 		next();
 		status = (sym->flags & SDECLARED) != 0;
 		if (!status)
 			killsym(sym);
 	} else {
 		/* TODO: catch recovery here */
 		if ((expr = constexpr()) == NULL) {
 			cpperror("parameter of #if is not an integer constant expression");
 			return;
 		}
 		status = expr->sym->u.i != 0;
 		freetree(expr);
 	}
 
 	if (negate)
 		status = !status;
 	if ((ifstatus[n] = status) == 0)
 		++cppoff;
 }
 
 static void
 cppif(void)
 {
 	disexpand = 0;
 	ifclause(0, 0);
 }
 
 static void
 ifdef(void)
 {
 	ifclause(0, 1);
 }
 
 static void
 ifndef(void)
 {
 	ifclause(1, 1);
 }
 
 static void
 elseclause(void)
 {
 	int status;
 
 	if (cppctx == 0) {
 		cpperror("#else without #ifdef/ifndef");
 		return;
 	}
 
 	status = ifstatus[cppctx-1];
 	ifstatus[cppctx-1] = !status;
 	cppoff += (status) ? 1 : -1;
 }
 
 static void
 cppelse(void)
 {
 	elseclause();
 	next();
 }
 
 static void
 elif(void)
 {
 	elseclause();
 	if (ifstatus[cppctx-1]) {
 		--cppctx;
 		cppif();
 	}
 }
 
 static void
 endif(void)
 {
 	if (cppctx == 0)
 		error("#endif without #if");
 	if (!ifstatus[--cppctx])
 		--cppoff;
 	next();
 }
 
 static void
 undef(void)
 {
 	if (cppoff)
 		return;
 
 	namespace = NS_CPP;
 	next();
 	if (yytoken != IDEN) {
 		error("no macro name given in #undef directive");
 		return;
 	}
 	killsym(yylval.sym);
 	next();
 }
 
 int
 cpp(void)
 {
 	static struct {
 		unsigned char token;
 		void (*fun)(void);
 	} *bp, clauses [] = {
 		{DEFINE, define},
 		{INCLUDE, include},
 		{LINE, line},
 		{IFDEF, ifdef},
 		{IF, cppif},
 		{ELIF, elif},
 		{IFNDEF, ifndef},
 		{ELSE, cppelse},
 		{ENDIF, endif},
 		{UNDEF, undef},
 		{PRAGMA, pragma},
 		{ERROR, usererr},
 		{0, NULL}
 	};
 	int ns;
 	char *p;
 
 	for (p = input->p; isspace(*p); ++p)
 		/* nothing */;
 
 	if (*p != '#')
 		return cppoff;
 	input->p = p+1;
 
 	disexpand = 1;
 	lexmode = CPPMODE;
 	ns = namespace;
 	namespace = NS_CPPCLAUSES;
 	next();
 	namespace = NS_IDEN;
 
 	for (bp = clauses; bp->token && bp->token != yytoken; ++bp)
 		/* nothing */;
 	if (!bp->token) {
 		errorp("incorrect preprocessor directive '%s'", yytext);
 		goto error;
 	}
 
 	DBG("CPP %s", yytext);
 
 	pushctx();              /* create a new context to avoid polish */
 	(*bp->fun)();           /* the current context, and to get all  */
 	popctx();               /* the symbols freed at the  end        */
 
 	/*
 	 * #include changes the content of input->line, so the correctness
 	 * of the line must be checked in the own include(), and we have
 	 * to skip this tests. For the same reason include() is the only
 	 * function which does not prepare the next token
 	 */
 	if (yytoken != '\n' && !cppoff && bp->token != INCLUDE)
 		errorp("trailing characters after preprocessor directive");
 
 error:
 	disexpand = 0;
 	lexmode = CCMODE;
 	namespace = ns;
 
 	return 1;
 }
 
 void
 ppragmaln(void)
 {
 	static char file[FILENAME_MAX];
 	static unsigned nline;
 	char *s;
 
 	putchar('\n');
 	if (strcmp(file, filenam)) {
 		strcpy(file, filenam);
 		s = "#line %u \"%s\"\n";
 	} else if (nline+1 != lineno) {
 		s = "#line %u\n";
 	} else {
 		s = "";
 	}
 	nline = lineno;
 	printf(s, nline, file);
 }
 
 void
 outcpp(void)
 {
 	int c;
 	char *s, *t;
 
 	for (next(); yytoken != EOFTOK; next()) {
 		if (onlyheader)
 			continue;
 		if (yytoken != STRING) {
 			printf("%s ", yytext);
 			continue;
 		}
 		for (s = yytext; c = *s; ++s) {
 			switch (c) {
 			case '\n':
 				t = "\\n";
 				goto print_str;
 			case '\v':
 				t = "\\v";
 				goto print_str;
 			case '\b':
 				t = "\\b";
 				goto print_str;
 			case '\t':
 				t = "\\t";
 				goto print_str;
 			case '\a':
 				t = "\\a";
 			print_str:
 				fputs(t, stdout);
 				break;
 			case '\\':
 				putchar('\\');
 			default:
 				if (!isprint(c))
 					printf("\\x%x", c);
 				else
 					putchar(c);
 				break;
 			}
 		}
 		putchar(' ');
 	}
 	putchar('\n');
 }