lex.c

window下的c编译器。

		cp += 1;
	}
	else if (base == 10 && n > (unsigned) LONG_MAX)
		tval.type = unsignedlong;
	else if (n > (unsigned) INT_MAX)
		tval.type = unsignedtype;
	else
		tval.type = inttype;
	if (overflow) {
		warning(StrTab[190], token, // <overflow in constant `%S'\n>
				(char *) cp - token);
		n = LONG_MAX;
	}
	if (isunsigned(tval.type))
		tval.u.c.v.u = n;
	else
		tval.u.c.v.i = n;
	ppnumber(StrTab[191]);      // <integer>
	return &tval;
}
static void ppnumber(char *which)
{
	unsigned char *rcp = cp--;
	for (; (map[*cp] & (DIGIT | LETTER)) || *cp == '.'; cp++)
		if ((cp[0] == 'E' || cp[0] == 'e')
				&& (cp[1] == '-' || cp[1] == '+'))
			cp++;
	if (cp > rcp)
		error(StrTab[192], token,   // <`%S' is a preprocessing number but an invalid %s constant\n>
			(char *) cp - token, which);
}
static Symbol fcon(void)
{
	if (*cp == '.')
		do
			cp++;
		while (map[*cp] & DIGIT);
	if (*cp == 'e' || *cp == 'E') {
		if (*++cp == '-' || *cp == '+')
			cp++;
		if (map[*cp] & DIGIT)
			do
				cp++;
			while (map[*cp] & DIGIT);
		else
		error(StrTab[193], token,   // <invalid floating constant `%S'\n>
			(char *) cp - token);
	}
	errno = 0;
	tval.u.c.v.d = strtod(token, NULL);
	if (errno == ERANGE)
		warning(StrTab[194], token, // <overflow in double constant `%S'\n>
				(char *) cp - token);
	if (*cp == 'f' || *cp == 'F') {
		++cp;
		if (tval.u.c.v.d > FLT_MAX) {
			warning(StrTab[195], token, // <overflow in floating constant `%S'\n>
					(char *) cp - token);
		}
		tval.type = floattype;
		tval.u.c.v.f = (float) tval.u.c.v.d;
	}
	else if (*cp == 'l' || *cp == 'L') {
		cp++;
		tval.type = longdouble;
	}
	else
		tval.type = doubletype;
	ppnumber(StrTab[196]);      // <floating>
	return &tval;
}
static int readString(int unicodeFlag)
{
	static char cbuf[BUFSIZE + 1];
	char *s = cbuf;
	int nbad = 0;
	*s++ = *--cp;
	do {
		cp++;
		while (*cp != cbuf[0]) {
			int c;
			if (map[*cp] & NEWLINE) {
				if (cp < limit)
					break;
				cp++;
				nextline();
				if (cp == limit)
					break;
				continue;
			}
			c = *cp++;
#ifdef JAPAN                    // DBCS (Shift-KIS) trap
			if (((0x80 < c) && (c <= 0x9f)) ||
					((0xe0 <= c) && (c <= 0xff))) {
				if (s < &cbuf[sizeof cbuf] - 3) {
					*s++ = (char) c;
					c = *cp++;
					*s++ = (char) c;
					continue;
				}
			}
#endif
			if (c == '\\') {
				if (map[*cp] & NEWLINE) {
					if (cp < limit)
						break;
					cp++;
					nextline();
				}
				if (limit - cp < MAXTOKEN)
					fillbuf();
				c = backslash(cbuf[0]);
			}
			else if (map[c] == 0)
				nbad++;
			if (s < &cbuf[sizeof cbuf] - 2)
				*s++ = (char) c;
		}
		if (*cp == cbuf[0])
			cp++;
		else
			error(StrTab[178], cbuf[0]);    // <missing %c\n>
	} while (cbuf[0] == '"' && getchr() == '"');
	*s++ = 0;
	if (s >= &cbuf[sizeof cbuf])
		error(StrTab[179],      // <%s literal too long\n>
			cbuf[0] == '"' ? StrTab[180] : "character"); // <string>
	if (Aflag >= 2 && cbuf[0] == '"' && s - cbuf - 1 > 509)
		warning(StrTab[182]);   // <more than 509 characters in a string literal\n>
	if (Aflag >= 2 && nbad)
		warning(StrTab[183],    // <%s literal contains non-portable characters\n>
				cbuf[0] == '"' ? StrTab[184] : "character");   // <string>
	token = cbuf;
	tsym = &tval;
	if (cbuf[0] == '"') {
		if (unicodeFlag) {
			unsigned short *pwcs = allocate(2 * (s - cbuf), PERM);
			int l = s - cbuf - 1;
			if (l > 0) {
				mbstowcs(pwcs, cbuf + 1, l - 1);
				pwcs[l - 1] = 0;
			}
			else
				pwcs[0] = 0;
			tval.type = array(unsignedshort, l, 0);
			tval.u.c.v.p = (unsigned char *) pwcs;
		}
		else {
			tval.type = array(chartype, s - cbuf - 1, 0);
			tval.u.c.v.p = cbuf + 1;
		}
		return SCON;
	}
	else {
		if (s - cbuf > 3)
			warning(StrTab[186], token, (char *) cp - token);   // <excess characters in multibyte character literal `%S' ignored\n>
		else if (s - cbuf <= 2)
			error(StrTab[187]); // <missing '\n>
		tval.type = inttype;
		tval.u.c.v.i = cbuf[1];
		return ICON;
	}
}
int getchr(void)
{
	register int c;
	for (;;) {
		c = *cp;
		while (map[c] & BLANK)
			c = *++cp;
		if (!(map[c] & NEWLINE)) {
			if (c == '_' && cp[1] == '_' && cp[2] == 't' &&
					cp[3] == 'r' && cp[4] == 'y') {
				unsigned char *oldcp = cp;
				cp += 5;
				c = getchr();
				cp = oldcp;
				return (c);
			}
			return c;
		}
		cp++;
		nextline();
		if (cp == limit)
			return EOI;
	}
}
static int backslash(int q)
{
	int c;
	switch (*cp++) {
	case 'a':
		return 7;
	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 '\'':
	case '"':
	case '\\':
	case '\?':
		break;
	case 'x':
		{
			int overflow = 0;
			if ((map[*cp] & (DIGIT | HEX)) == 0) {
				if (*cp < ' ' || *cp == 0177)
					error(StrTab[197]); // <ill-formed hexadecimal escape sequence\n>
				else
					error(StrTab[198], *cp);    // <ill-formed hexadecimal escape sequence `\\x%c'\n>
				if (*cp != q)
					cp++;
				return 0;
			}
			for (c = 0; map[*cp] & (DIGIT | HEX); cp++) {
				if (c & ~((unsigned) -1 >> 4))
					overflow++;
				if (map[*cp] & DIGIT)
					c = (c << 4) + *cp - '0';
				else
					c = (c << 4) + (*cp & ~040) - 'A' + 10;
			}
			if (c & ~0377 || overflow)
				warning(StrTab[199]);   // <overflow in hexadecimal escape sequence\n>
			return c & 0377;
		}
	case '0':
	case '1':
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
		c = *(cp - 1) - '0';
		if (*cp >= '0' && *cp <= '7') {
			c = (c << 3) + *cp++ - '0';
			if (*cp >= '0' && *cp <= '7')
				c = (c << 3) + *cp++ - '0';
		}
		if (c & ~0377)
			warning(StrTab[200]);   // <overflow in octal escape sequence\n>
		return c & 0377;
	default:
		if (cp[-1] < ' ' || cp[-1] >= 0177)
			warning(StrTab[201]);   // <unrecognized character escape sequence\n>
		else
			warning(StrTab[202], cp[-1]);   // <unrecognized character escape sequence `\\%c'\n>
	}
	return cp[-1];
}
static char packstack[32];
static char packstackptr = 0;
static double densitystack[32];
static char densitystackptr=0;
void ProcessPragmaDensity(void)
{
	t = gettok();
	if (t == '(') {
		t = gettok();
		if (t != FCON) {
			if (t != ')') {
				if (t == ID) {
					if (token[0] == 'p' && token[1] == 'u' &&
							token[2] == 's' && token[3] == 'h') {
						if (densitystackptr > 31) {
							error(StrTab[203]); // <Overflow in #pragma(push)\n>
							return;
						}
						densitystack[densitystackptr++] = density;
						t = gettok();
						if (t == ',') {
							t = gettok();
							if (t == FCON)
								goto suite;
						}
						else if (t == ')')
							return;
						else
							error(StrTab[204]); // <Syntax error in pragma <pack>\n>
						return;
					}
					else if (token[0] == 'p' && token[1] == 'o' &&
							token[2] == 'p') {
						t = gettok();
						if (densitystackptr < 1) {
							error(StrTab[205]); // <pragma pack(pop) stack underflow\n>
							return;
						}
						if (t != ')')
							error(StrTab[210]); // <pragma pack(pop) syntax error\n>
						densitystackptr--;
						density = densitystack[densitystackptr];
						return;
					}
				}
				warning(StrTab[436]);   // <Floating point constant expected in 'density' pragma. Ignored.>
				return;
			}
		}
		else {
	suite:
			density = tval.u.c.v.d;
			t = gettok();
			if (t != ')') {
				warning(StrTab[210]);   // <Incorrect syntax in pragma statement>
				return;
			}
		}
	}
	else {
		warning(StrTab[210]);   // <Incorrect syntax in pragma statement>
		return;
	}
}

void ProcessPragmaPack(void)
{
	int newAlignment;
	t = gettok();
	if (t == '(') {
		t = gettok();
		if (t != ICON) {
			if (t != ')') {
				if (t == ID) {
					if (token[0] == 'p' && token[1] == 'u' &&
							token[2] == 's' && token[3] == 'h') {
						if (packstackptr > 31) {
							error(StrTab[203]); // <Overflow in #pragma(push)\n>
							return;
						}
						packstack[packstackptr++] = DefaultAlignment;
						t = gettok();
						if (t == ',') {
							t = gettok();
							if (t == ICON)
								goto suite;
						}
						else if (t == ')')
							return;
						else
							error(StrTab[204]); // <Syntax error in pragma <pack>\n>
						return;
					}
					else if (token[0] == 'p' && token[1] == 'o' &&
							token[2] == 'p') {
						t = gettok();
						if (packstackptr < 1) {
							error(StrTab[205]); // <pragma pack(pop) stack underflow\n>
							return;
						}
						if (t != ')')
							error(StrTab[206]); // <pragma pack(pop) syntax error\n>
						packstackptr--;
						DefaultAlignment = packstack[packstackptr];
						return;
					}
				}
				warning(StrTab[207]);   // <Integer constant expected in 'pack' pragma. Ignored.>
				return;
			}
			newAlignment = 16;
		}
		else {
	suite:
			newAlignment = tval.u.c.v.i;
			t = gettok();
			if (t != ')') {
				warning(StrTab[208]);   // <Incorrect 'pragma pack' syntax>
				return;
			}
		}
		switch (newAlignment) {
		case 1:
			break;
		case 2:
			break;
		case 4:
			break;
		case 8:
			break;
		case 16:
			break;
		default:
			warning(StrTab[209], newAlignment); // <Illegal pragma pack(%d) ignored>
			return;
		}
	}
	else {
		warning(StrTab[210]);   // <Incorrect syntax in pragma statement>
		return;
	}
	DefaultAlignment = newAlignment;
}
void ProcessOptimize(void)
{
	int val;
	t = gettok();
	if (t == '(') {
		t = gettok();
		if (t != ICON) {
			if (t != ')') {
				warning(StrTab[211]);   // <Integer constant expected in 'optimize' pragma. Ignored.>
				return;
			}
			val = 0;
		}
		else {
			val = tval.u.c.v.i;
			t = gettok();
			if (t != ')') {
				warning(StrTab[212]);   // <Incorrect 'optimize' syntax>
				return;
			}
		}
		OptimizeFlag = val;
	}
	else {
		warning(StrTab[213]);   // <Incorrect syntax in pragma statement>
		return;
	}
}
void ProcessSection(void)
{
	char tmpbuf[40];
	t = gettok();
	if (t == '(') {
		t = gettok();
		if (t != SCON) {
			if (t != ')') {
				warning(StrTab[214]);   // <String constant expected in 'pack' pragma. Ignored.>
				return;
			}
			print(StrTab[215]); // <\tsection .text\n>
		}
		else {
			assert(tval.type);
			if (tval.type->size > 9) {
				warning(StrTab[216]);   // <Section name too long. Max. 8 chars. Ignored.>
				return;
			}
			sprintf(tmpbuf, "\t.section %s\n", tval.u.c.v.p);
			t = gettok();
			if (t != ')') {
				warning(StrTab[217]);   // <Incorrect 'pragma section' syntax>
				return;
			}
			print(tmpbuf);
		}
	}
	else {
		warning(StrTab[218]);   // <Incorrect syntax in pragma statement>
		return;
	}
}
int getTvalValue(void)
{
	return (tval.u.c.v.i);
}
int getLevel(void)
{
	return (statementLevel);
}

static int doDeclSpec(void)
{
	t = gettok();
	if (t != '(') goto errout;
	t = gettok();
	if (t != ID) goto errout;
	if (!strcmp(token,"dllexport")) {
		t = gettok();
		if (t != ')') goto errout;
		return DLLEXPORT;
	}
	else if (!strcmp(token,"dllimport")) {
		t = gettok();
		if (t != ')') goto errout;
		return DLLIMPORT;
	}
	else if (!strcmp(token,"thread")) {
		warning("__declspec(thread) not implemented");
		t = gettok();
		if (t != ')') goto errout;
		return gettok();
	}
	else if (!strcmp(token,"naked")) {
		warning("__declspec(naked) not implemented");
		t = gettok();
		if (t != ')') goto errout;
		return gettok();
	}
errout:
	error("Incorrect syntax in __declspec statement\n");
	return t;
}