| #include "c.h" |
| #include <float.h> |
| #include <errno.h> |
| |
| static char rcsid[] = "$Id: lex.c 355 2007-02-18 22:08:49Z drh $"; |
| |
| #define MAXTOKEN 32 |
| |
| enum { BLANK=01, NEWLINE=02, LETTER=04, |
| DIGIT=010, HEX=020, OTHER=040 }; |
| |
| static unsigned char map[256] = { /* 000 nul */ 0, |
| /* 001 soh */ 0, |
| /* 002 stx */ 0, |
| /* 003 etx */ 0, |
| /* 004 eot */ 0, |
| /* 005 enq */ 0, |
| /* 006 ack */ 0, |
| /* 007 bel */ 0, |
| /* 010 bs */ 0, |
| /* 011 ht */ BLANK, |
| /* 012 nl */ NEWLINE, |
| /* 013 vt */ BLANK, |
| /* 014 ff */ BLANK, |
| /* 015 cr */ 0, |
| /* 016 so */ 0, |
| /* 017 si */ 0, |
| /* 020 dle */ 0, |
| /* 021 dc1 */ 0, |
| /* 022 dc2 */ 0, |
| /* 023 dc3 */ 0, |
| /* 024 dc4 */ 0, |
| /* 025 nak */ 0, |
| /* 026 syn */ 0, |
| /* 027 etb */ 0, |
| /* 030 can */ 0, |
| /* 031 em */ 0, |
| /* 032 sub */ 0, |
| /* 033 esc */ 0, |
| /* 034 fs */ 0, |
| /* 035 gs */ 0, |
| /* 036 rs */ 0, |
| /* 037 us */ 0, |
| /* 040 sp */ BLANK, |
| /* 041 ! */ OTHER, |
| /* 042 " */ OTHER, |
| /* 043 # */ OTHER, |
| /* 044 $ */ 0, |
| /* 045 % */ OTHER, |
| /* 046 & */ OTHER, |
| /* 047 ' */ OTHER, |
| /* 050 ( */ OTHER, |
| /* 051 ) */ OTHER, |
| /* 052 * */ OTHER, |
| /* 053 + */ OTHER, |
| /* 054 , */ OTHER, |
| /* 055 - */ OTHER, |
| /* 056 . */ OTHER, |
| /* 057 / */ OTHER, |
| /* 060 0 */ DIGIT, |
| /* 061 1 */ DIGIT, |
| /* 062 2 */ DIGIT, |
| /* 063 3 */ DIGIT, |
| /* 064 4 */ DIGIT, |
| /* 065 5 */ DIGIT, |
| /* 066 6 */ DIGIT, |
| /* 067 7 */ DIGIT, |
| /* 070 8 */ DIGIT, |
| /* 071 9 */ DIGIT, |
| /* 072 : */ OTHER, |
| /* 073 ; */ OTHER, |
| /* 074 < */ OTHER, |
| /* 075 = */ OTHER, |
| /* 076 > */ OTHER, |
| /* 077 ? */ OTHER, |
| /* 100 @ */ 0, |
| /* 101 A */ LETTER|HEX, |
| /* 102 B */ LETTER|HEX, |
| /* 103 C */ LETTER|HEX, |
| /* 104 D */ LETTER|HEX, |
| /* 105 E */ LETTER|HEX, |
| /* 106 F */ LETTER|HEX, |
| /* 107 G */ LETTER, |
| /* 110 H */ LETTER, |
| /* 111 I */ LETTER, |
| /* 112 J */ LETTER, |
| /* 113 K */ LETTER, |
| /* 114 L */ LETTER, |
| /* 115 M */ LETTER, |
| /* 116 N */ LETTER, |
| /* 117 O */ LETTER, |
| /* 120 P */ LETTER, |
| /* 121 Q */ LETTER, |
| /* 122 R */ LETTER, |
| /* 123 S */ LETTER, |
| /* 124 T */ LETTER, |
| /* 125 U */ LETTER, |
| /* 126 V */ LETTER, |
| /* 127 W */ LETTER, |
| /* 130 X */ LETTER, |
| /* 131 Y */ LETTER, |
| /* 132 Z */ LETTER, |
| /* 133 [ */ OTHER, |
| /* 134 \ */ OTHER, |
| /* 135 ] */ OTHER, |
| /* 136 ^ */ OTHER, |
| /* 137 _ */ LETTER, |
| /* 140 ` */ 0, |
| /* 141 a */ LETTER|HEX, |
| /* 142 b */ LETTER|HEX, |
| /* 143 c */ LETTER|HEX, |
| /* 144 d */ LETTER|HEX, |
| /* 145 e */ LETTER|HEX, |
| /* 146 f */ LETTER|HEX, |
| /* 147 g */ LETTER, |
| /* 150 h */ LETTER, |
| /* 151 i */ LETTER, |
| /* 152 j */ LETTER, |
| /* 153 k */ LETTER, |
| /* 154 l */ LETTER, |
| /* 155 m */ LETTER, |
| /* 156 n */ LETTER, |
| /* 157 o */ LETTER, |
| /* 160 p */ LETTER, |
| /* 161 q */ LETTER, |
| /* 162 r */ LETTER, |
| /* 163 s */ LETTER, |
| /* 164 t */ LETTER, |
| /* 165 u */ LETTER, |
| /* 166 v */ LETTER, |
| /* 167 w */ LETTER, |
| /* 170 x */ LETTER, |
| /* 171 y */ LETTER, |
| /* 172 z */ LETTER, |
| /* 173 { */ OTHER, |
| /* 174 | */ OTHER, |
| /* 175 } */ OTHER, |
| /* 176 ~ */ OTHER, }; |
| static struct symbol tval; |
| static char cbuf[BUFSIZE+1]; |
| static unsigned int wcbuf[BUFSIZE+1]; |
| |
| Coordinate src; /* current source coordinate */ |
| int t; |
| char *token; /* current token */ |
| Symbol tsym; /* symbol table entry for current token */ |
| |
| static void *cput(int c, void *cl); |
| static void *wcput(int c, void *cl); |
| static void *scon(int q, void *put(int c, void *cl), void *cl); |
| static int backslash(int q); |
| static Symbol fcon(void); |
| static Symbol icon(unsigned long, int, int); |
| static void ppnumber(char *); |
| |
| int gettok(void) { |
| for (;;) { |
| register unsigned char *rcp = cp; |
| while (map[*rcp]&BLANK) |
| rcp++; |
| if (limit - rcp < MAXTOKEN) { |
| cp = rcp; |
| fillbuf(); |
| rcp = cp; |
| } |
| src.file = file; |
| src.x = (char *)rcp - line; |
| src.y = lineno; |
| cp = rcp + 1; |
| switch (*rcp++) { |
| case '/': if (*rcp == '*') { |
| int c = 0; |
| for (rcp++; *rcp != '/' || c != '*'; ) |
| if (map[*rcp]&NEWLINE) { |
| if (rcp < limit) |
| c = *rcp; |
| cp = rcp + 1; |
| nextline(); |
| rcp = cp; |
| if (rcp == limit) |
| break; |
| } else |
| c = *rcp++; |
| if (rcp < limit) |
| rcp++; |
| else |
| error("unclosed comment\n"); |
| cp = rcp; |
| continue; |
| } |
| return '/'; |
| case '<': |
| if (*rcp == '=') return cp++, LEQ; |
| if (*rcp == '<') return cp++, LSHIFT; |
| return '<'; |
| case '>': |
| if (*rcp == '=') return cp++, GEQ; |
| if (*rcp == '>') return cp++, RSHIFT; |
| return '>'; |
| case '-': |
| if (*rcp == '>') return cp++, DEREF; |
| if (*rcp == '-') return cp++, DECR; |
| return '-'; |
| case '=': return *rcp == '=' ? cp++, EQL : '='; |
| case '!': return *rcp == '=' ? cp++, NEQ : '!'; |
| case '|': return *rcp == '|' ? cp++, OROR : '|'; |
| case '&': return *rcp == '&' ? cp++, ANDAND : '&'; |
| case '+': return *rcp == '+' ? cp++, INCR : '+'; |
| case ';': case ',': case ':': |
| case '*': case '~': case '%': case '^': case '?': |
| case '[': case ']': case '{': case '}': case '(': case ')': |
| return rcp[-1]; |
| case '\n': case '\v': case '\r': case '\f': |
| nextline(); |
| if (cp == limit) { |
| tsym = NULL; |
| return EOI; |
| } |
| continue; |
| |
| case 'i': |
| if (rcp[0] == 'f' |
| && !(map[rcp[1]]&(DIGIT|LETTER))) { |
| cp = rcp + 1; |
| return IF; |
| } |
| if (rcp[0] == 'n' |
| && rcp[1] == 't' |
| && !(map[rcp[2]]&(DIGIT|LETTER))) { |
| cp = rcp + 2; |
| tsym = inttype->u.sym; |
| return INT; |
| } |
| goto id; |
| case 'h': case 'j': case 'k': case 'm': case 'n': case 'o': |
| case 'p': case 'q': case 'x': case 'y': case 'z': |
| case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': |
| case 'G': case 'H': case 'I': case 'J': case 'K': |
| case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': |
| case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': |
| case 'Y': case 'Z': |
| id: |
| if (limit - rcp < MAXLINE) { |
| cp = rcp - 1; |
| fillbuf(); |
| rcp = ++cp; |
| } |
| assert(cp == rcp); |
| token = (char *)rcp - 1; |
| while (map[*rcp]&(DIGIT|LETTER)) |
| rcp++; |
| token = stringn(token, (char *)rcp - token); |
| tsym = lookup(token, identifiers); |
| cp = rcp; |
| return ID; |
| case '0': case '1': case '2': case '3': case '4': |
| case '5': case '6': case '7': case '8': case '9': { |
| unsigned long n = 0; |
| if (limit - rcp < MAXLINE) { |
| cp = rcp - 1; |
| fillbuf(); |
| rcp = ++cp; |
| } |
| assert(cp == rcp); |
| token = (char *)rcp - 1; |
| if (*token == '0' && (*rcp == 'x' || *rcp == 'X')) { |
| int d, overflow = 0; |
| while (*++rcp) { |
| if (map[*rcp]&DIGIT) |
| d = *rcp - '0'; |
| else if (*rcp >= 'a' && *rcp <= 'f') |
| d = *rcp - 'a' + 10; |
| else if (*rcp >= 'A' && *rcp <= 'F') |
| d = *rcp - 'A' + 10; |
| else |
| break; |
| if (n&~(~0UL >> 4)) |
| overflow = 1; |
| else |
| n = (n<<4) + d; |
| } |
| if ((char *)rcp - token <= 2) |
| error("invalid hexadecimal constant `%S'\n", token, (char *)rcp-token); |
| cp = rcp; |
| tsym = icon(n, overflow, 16); |
| } else if (*token == '0') { |
| int err = 0, overflow = 0; |
| for ( ; map[*rcp]&DIGIT; rcp++) { |
| if (*rcp == '8' || *rcp == '9') |
| err = 1; |
| if (n&~(~0UL >> 3)) |
| overflow = 1; |
| else |
| n = (n<<3) + (*rcp - '0'); |
| } |
| if (*rcp == '.' || *rcp == 'e' || *rcp == 'E') { |
| cp = rcp; |
| tsym = fcon(); |
| return FCON; |
| } |
| cp = rcp; |
| tsym = icon(n, overflow, 8); |
| if (err) |
| error("invalid octal constant `%S'\n", token, (char*)cp-token); |
| } else { |
| int overflow = 0; |
| for (n = *token - '0'; map[*rcp]&DIGIT; ) { |
| int d = *rcp++ - '0'; |
| if (n > (ULONG_MAX - d)/10) |
| overflow = 1; |
| else |
| n = 10*n + d; |
| } |
| if (*rcp == '.' || *rcp == 'e' || *rcp == 'E') { |
| cp = rcp; |
| tsym = fcon(); |
| return FCON; |
| } |
| cp = rcp; |
| tsym = icon(n, overflow, 10); |
| } |
| return ICON; |
| } |
| case '.': |
| if (rcp[0] == '.' && rcp[1] == '.') { |
| cp += 2; |
| return ELLIPSIS; |
| } |
| if ((map[*rcp]&DIGIT) == 0) |
| return '.'; |
| if (limit - rcp < MAXLINE) { |
| cp = rcp - 1; |
| fillbuf(); |
| rcp = ++cp; |
| } |
| assert(cp == rcp); |
| cp = rcp - 1; |
| token = (char *)cp; |
| tsym = fcon(); |
| return FCON; |
| case 'L': |
| if (*rcp == '\'') { |
| unsigned int *s = scon(*cp, wcput, wcbuf); |
| if (s - wcbuf > 2) |
| warning("excess characters in wide-character literal ignored\n"); |
| tval.type = widechar; |
| tval.u.c.v.u = wcbuf[0]; |
| tsym = &tval; |
| return ICON; |
| } else if (*rcp == '"') { |
| unsigned int *s = scon(*cp, wcput, wcbuf); |
| tval.type = array(widechar, s - wcbuf, 0); |
| tval.u.c.v.p = wcbuf; |
| tsym = &tval; |
| return SCON; |
| } else |
| goto id; |
| case '\'': { |
| char *s = scon(*--cp, cput, cbuf); |
| if (s - cbuf > 2) |
| warning("excess characters in multibyte character literal ignored\n"); |
| tval.type = inttype; |
| if (chartype->op == INT) |
| tval.u.c.v.i = extend(cbuf[0], chartype); |
| else |
| tval.u.c.v.i = cbuf[0]&0xFF; |
| tsym = &tval; |
| return ICON; |
| } |
| case '"': { |
| char *s = scon(*--cp, cput, cbuf); |
| tval.type = array(chartype, s - cbuf, 0); |
| tval.u.c.v.p = cbuf; |
| tsym = &tval; |
| return SCON; |
| } |
| case 'a': |
| if (rcp[0] == 'u' |
| && rcp[1] == 't' |
| && rcp[2] == 'o' |
| && !(map[rcp[3]]&(DIGIT|LETTER))) { |
| cp = rcp + 3; |
| return AUTO; |
| } |
| goto id; |
| case 'b': |
| if (rcp[0] == 'r' |
| && rcp[1] == 'e' |
| && rcp[2] == 'a' |
| && rcp[3] == 'k' |
| && !(map[rcp[4]]&(DIGIT|LETTER))) { |
| cp = rcp + 4; |
| return BREAK; |
| } |
| goto id; |
| case 'c': |
| if (rcp[0] == 'a' |
| && rcp[1] == 's' |
| && rcp[2] == 'e' |
| && !(map[rcp[3]]&(DIGIT|LETTER))) { |
| cp = rcp + 3; |
| return CASE; |
| } |
| if (rcp[0] == 'h' |
| && rcp[1] == 'a' |
| && rcp[2] == 'r' |
| && !(map[rcp[3]]&(DIGIT|LETTER))) { |
| cp = rcp + 3; |
| tsym = chartype->u.sym; |
| return CHAR; |
| } |
| if (rcp[0] == 'o' |
| && rcp[1] == 'n' |
| && rcp[2] == 's' |
| && rcp[3] == 't' |
| && !(map[rcp[4]]&(DIGIT|LETTER))) { |
| cp = rcp + 4; |
| return CONST; |
| } |
| if (rcp[0] == 'o' |
| && rcp[1] == 'n' |
| && rcp[2] == 't' |
| && rcp[3] == 'i' |
| && rcp[4] == 'n' |
| && rcp[5] == 'u' |
| && rcp[6] == 'e' |
| && !(map[rcp[7]]&(DIGIT|LETTER))) { |
| cp = rcp + 7; |
| return CONTINUE; |
| } |
| goto id; |
| case 'd': |
| if (rcp[0] == 'e' |
| && rcp[1] == 'f' |
| && rcp[2] == 'a' |
| && rcp[3] == 'u' |
| && rcp[4] == 'l' |
| && rcp[5] == 't' |
| && !(map[rcp[6]]&(DIGIT|LETTER))) { |
| cp = rcp + 6; |
| return DEFAULT; |
| } |
| if (rcp[0] == 'o' |
| && rcp[1] == 'u' |
| && rcp[2] == 'b' |
| && rcp[3] == 'l' |
| && rcp[4] == 'e' |
| && !(map[rcp[5]]&(DIGIT|LETTER))) { |
| cp = rcp + 5; |
| tsym = doubletype->u.sym; |
| return DOUBLE; |
| } |
| if (rcp[0] == 'o' |
| && !(map[rcp[1]]&(DIGIT|LETTER))) { |
| cp = rcp + 1; |
| return DO; |
| } |
| goto id; |
| case 'e': |
| if (rcp[0] == 'l' |
| && rcp[1] == 's' |
| && rcp[2] == 'e' |
| && !(map[rcp[3]]&(DIGIT|LETTER))) { |
| cp = rcp + 3; |
| return ELSE; |
| } |
| if (rcp[0] == 'n' |
| && rcp[1] == 'u' |
| && rcp[2] == 'm' |
| && !(map[rcp[3]]&(DIGIT|LETTER))) { |
| cp = rcp + 3; |
| return ENUM; |
| } |
| if (rcp[0] == 'x' |
| && rcp[1] == 't' |
| && rcp[2] == 'e' |
| && rcp[3] == 'r' |
| && rcp[4] == 'n' |
| && !(map[rcp[5]]&(DIGIT|LETTER))) { |
| cp = rcp + 5; |
| return EXTERN; |
| } |
| goto id; |
| case 'f': |
| if (rcp[0] == 'l' |
| && rcp[1] == 'o' |
| && rcp[2] == 'a' |
| && rcp[3] == 't' |
| && !(map[rcp[4]]&(DIGIT|LETTER))) { |
| cp = rcp + 4; |
| tsym = floattype->u.sym; |
| return FLOAT; |
| } |
| if (rcp[0] == 'o' |
| && rcp[1] == 'r' |
| && !(map[rcp[2]]&(DIGIT|LETTER))) { |
| cp = rcp + 2; |
| return FOR; |
| } |
| goto id; |
| case 'g': |
| if (rcp[0] == 'o' |
| && rcp[1] == 't' |
| && rcp[2] == 'o' |
| && !(map[rcp[3]]&(DIGIT|LETTER))) { |
| cp = rcp + 3; |
| return GOTO; |
| } |
| goto id; |
| case 'l': |
| if (rcp[0] == 'o' |
| && rcp[1] == 'n' |
| && rcp[2] == 'g' |
| && !(map[rcp[3]]&(DIGIT|LETTER))) { |
| cp = rcp + 3; |
| return LONG; |
| } |
| goto id; |
| case 'r': |
| if (rcp[0] == 'e' |
| && rcp[1] == 'g' |
| && rcp[2] == 'i' |
| && rcp[3] == 's' |
| && rcp[4] == 't' |
| && rcp[5] == 'e' |
| && rcp[6] == 'r' |
| && !(map[rcp[7]]&(DIGIT|LETTER))) { |
| cp = rcp + 7; |
| return REGISTER; |
| } |
| if (rcp[0] == 'e' |
| && rcp[1] == 't' |
| && rcp[2] == 'u' |
| && rcp[3] == 'r' |
| && rcp[4] == 'n' |
| && !(map[rcp[5]]&(DIGIT|LETTER))) { |
| cp = rcp + 5; |
| return RETURN; |
| } |
| goto id; |
| case 's': |
| if (rcp[0] == 'h' |
| && rcp[1] == 'o' |
| && rcp[2] == 'r' |
| && rcp[3] == 't' |
| && !(map[rcp[4]]&(DIGIT|LETTER))) { |
| cp = rcp + 4; |
| return SHORT; |
| } |
| if (rcp[0] == 'i' |
| && rcp[1] == 'g' |
| && rcp[2] == 'n' |
| && rcp[3] == 'e' |
| && rcp[4] == 'd' |
| && !(map[rcp[5]]&(DIGIT|LETTER))) { |
| cp = rcp + 5; |
| return SIGNED; |
| } |
| if (rcp[0] == 'i' |
| && rcp[1] == 'z' |
| && rcp[2] == 'e' |
| && rcp[3] == 'o' |
| && rcp[4] == 'f' |
| && !(map[rcp[5]]&(DIGIT|LETTER))) { |
| cp = rcp + 5; |
| return SIZEOF; |
| } |
| if (rcp[0] == 't' |
| && rcp[1] == 'a' |
| && rcp[2] == 't' |
| && rcp[3] == 'i' |
| && rcp[4] == 'c' |
| && !(map[rcp[5]]&(DIGIT|LETTER))) { |
| cp = rcp + 5; |
| return STATIC; |
| } |
| if (rcp[0] == 't' |
| && rcp[1] == 'r' |
| && rcp[2] == 'u' |
| && rcp[3] == 'c' |
| && rcp[4] == 't' |
| && !(map[rcp[5]]&(DIGIT|LETTER))) { |
| cp = rcp + 5; |
| return STRUCT; |
| } |
| if (rcp[0] == 'w' |
| && rcp[1] == 'i' |
| && rcp[2] == 't' |
| && rcp[3] == 'c' |
| && rcp[4] == 'h' |
| && !(map[rcp[5]]&(DIGIT|LETTER))) { |
| cp = rcp + 5; |
| return SWITCH; |
| } |
| goto id; |
| case 't': |
| if (rcp[0] == 'y' |
| && rcp[1] == 'p' |
| && rcp[2] == 'e' |
| && rcp[3] == 'd' |
| && rcp[4] == 'e' |
| && rcp[5] == 'f' |
| && !(map[rcp[6]]&(DIGIT|LETTER))) { |
| cp = rcp + 6; |
| return TYPEDEF; |
| } |
| goto id; |
| case 'u': |
| if (rcp[0] == 'n' |
| && rcp[1] == 'i' |
| && rcp[2] == 'o' |
| && rcp[3] == 'n' |
| && !(map[rcp[4]]&(DIGIT|LETTER))) { |
| cp = rcp + 4; |
| return UNION; |
| } |
| if (rcp[0] == 'n' |
| && rcp[1] == 's' |
| && rcp[2] == 'i' |
| && rcp[3] == 'g' |
| && rcp[4] == 'n' |
| && rcp[5] == 'e' |
| && rcp[6] == 'd' |
| && !(map[rcp[7]]&(DIGIT|LETTER))) { |
| cp = rcp + 7; |
| return UNSIGNED; |
| } |
| goto id; |
| case 'v': |
| if (rcp[0] == 'o' |
| && rcp[1] == 'i' |
| && rcp[2] == 'd' |
| && !(map[rcp[3]]&(DIGIT|LETTER))) { |
| cp = rcp + 3; |
| tsym = voidtype->u.sym; |
| return VOID; |
| } |
| if (rcp[0] == 'o' |
| && rcp[1] == 'l' |
| && rcp[2] == 'a' |
| && rcp[3] == 't' |
| && rcp[4] == 'i' |
| && rcp[5] == 'l' |
| && rcp[6] == 'e' |
| && !(map[rcp[7]]&(DIGIT|LETTER))) { |
| cp = rcp + 7; |
| return VOLATILE; |
| } |
| goto id; |
| case 'w': |
| if (rcp[0] == 'h' |
| && rcp[1] == 'i' |
| && rcp[2] == 'l' |
| && rcp[3] == 'e' |
| && !(map[rcp[4]]&(DIGIT|LETTER))) { |
| cp = rcp + 4; |
| return WHILE; |
| } |
| goto id; |
| case '_': |
| if (rcp[0] == '_' |
| && rcp[1] == 't' |
| && rcp[2] == 'y' |
| && rcp[3] == 'p' |
| && rcp[4] == 'e' |
| && rcp[5] == 'c' |
| && rcp[6] == 'o' |
| && rcp[7] == 'd' |
| && rcp[8] == 'e' |
| && !(map[rcp[9]]&(DIGIT|LETTER))) { |
| cp = rcp + 9; |
| return TYPECODE; |
| } |
| if (rcp[0] == '_' |
| && rcp[1] == 'f' |
| && rcp[2] == 'i' |
| && rcp[3] == 'r' |
| && rcp[4] == 's' |
| && rcp[5] == 't' |
| && rcp[6] == 'a' |
| && rcp[7] == 'r' |
| && rcp[8] == 'g' |
| && !(map[rcp[9]]&(DIGIT|LETTER))) { |
| cp = rcp + 9; |
| return FIRSTARG; |
| } |
| goto id; |
| default: |
| if ((map[cp[-1]]&BLANK) == 0) |
| if (cp[-1] < ' ' || cp[-1] >= 0177) |
| error("illegal character `\\0%o'\n", cp[-1]); |
| else |
| error("illegal character `%c'\n", cp[-1]); |
| } |
| } |
| } |
| static Symbol icon(unsigned long n, int overflow, int base) { |
| if ((*cp=='u'||*cp=='U') && (cp[1]=='l'||cp[1]=='L') |
| || (*cp=='l'||*cp=='L') && (cp[1]=='u'||cp[1]=='U')) { |
| tval.type = unsignedlong; |
| cp += 2; |
| } else if (*cp == 'u' || *cp == 'U') { |
| if (overflow || n > unsignedtype->u.sym->u.limits.max.i) |
| tval.type = unsignedlong; |
| else |
| tval.type = unsignedtype; |
| cp += 1; |
| } else if (*cp == 'l' || *cp == 'L') { |
| if (overflow || n > longtype->u.sym->u.limits.max.i) |
| tval.type = unsignedlong; |
| else |
| tval.type = longtype; |
| cp += 1; |
| } else if (overflow || n > longtype->u.sym->u.limits.max.i) |
| tval.type = unsignedlong; |
| else if (n > inttype->u.sym->u.limits.max.i) |
| tval.type = longtype; |
| else if (base != 10 && n > inttype->u.sym->u.limits.max.i) |
| tval.type = unsignedtype; |
| else |
| tval.type = inttype; |
| switch (tval.type->op) { |
| case INT: |
| if (overflow || n > tval.type->u.sym->u.limits.max.i) { |
| warning("overflow in constant `%S'\n", token, |
| (char*)cp - token); |
| tval.u.c.v.i = tval.type->u.sym->u.limits.max.i; |
| } else |
| tval.u.c.v.i = n; |
| break; |
| case UNSIGNED: |
| if (overflow || n > tval.type->u.sym->u.limits.max.u) { |
| warning("overflow in constant `%S'\n", token, |
| (char*)cp - token); |
| tval.u.c.v.u = tval.type->u.sym->u.limits.max.u; |
| } else |
| tval.u.c.v.u = n; |
| break; |
| default: assert(0); |
| } |
| ppnumber("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("`%S' is a preprocessing number but an invalid %s constant\n", token, |
| |
| (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("invalid floating constant `%S'\n", token, |
| (char*)cp - token); |
| } |
| |
| errno = 0; |
| tval.u.c.v.d = strtod(token, NULL); |
| if (errno == ERANGE) |
| warning("overflow in floating constant `%S'\n", token, |
| (char*)cp - token); |
| if (*cp == 'f' || *cp == 'F') { |
| ++cp; |
| if (tval.u.c.v.d > floattype->u.sym->u.limits.max.d) |
| warning("overflow in floating constant `%S'\n", token, |
| (char*)cp - token); |
| tval.type = floattype; |
| } else if (*cp == 'l' || *cp == 'L') { |
| cp++; |
| tval.type = longdouble; |
| } else { |
| if (tval.u.c.v.d > doubletype->u.sym->u.limits.max.d) |
| warning("overflow in floating constant `%S'\n", token, |
| (char*)cp - token); |
| tval.type = doubletype; |
| } |
| ppnumber("floating"); |
| return &tval; |
| } |
| |
| static void *cput(int c, void *cl) { |
| char *s = cl; |
| |
| if (c < 0 || c > 255) |
| warning("overflow in escape sequence with resulting value `%d'\n", c); |
| *s++ = c; |
| return s; |
| } |
| |
| static void *wcput(int c, void *cl) { |
| unsigned int *s = cl; |
| |
| *s++ = c; |
| return s; |
| } |
| |
| static void *scon(int q, void *put(int c, void *cl), void *cl) { |
| int n = 0, nbad = 0; |
| |
| do { |
| cp++; |
| while (*cp != q) { |
| int c; |
| if (map[*cp]&NEWLINE) { |
| if (cp < limit) |
| break; |
| cp++; |
| nextline(); |
| if (cp == limit) |
| break; |
| continue; |
| } |
| c = *cp++; |
| if (c == '\\') { |
| if (map[*cp]&NEWLINE) { |
| if (cp++ < limit) |
| continue; |
| nextline(); |
| } |
| if (limit - cp < MAXTOKEN) |
| fillbuf(); |
| c = backslash(q); |
| } else if (c < 0 || c > 255 || map[c] == 0) |
| nbad++; |
| if (n++ < BUFSIZE) |
| cl = put(c, cl); |
| } |
| if (*cp == q) |
| cp++; |
| else |
| error("missing %c\n", q); |
| if (q == '"' && put == wcput && getchr() == 'L') { |
| if (limit - cp < 2) |
| fillbuf(); |
| if (cp[1] == '"') |
| cp++; |
| } |
| } while (q == '"' && getchr() == '"'); |
| cl = put(0, cl); |
| if (n >= BUFSIZE) |
| error("%s literal too long\n", q == '"' ? "string" : "character"); |
| if (Aflag >= 2 && q == '"' && n > 509) |
| warning("more than 509 characters in a string literal\n"); |
| if (Aflag >= 2 && nbad > 0) |
| warning("%s literal contains non-portable characters\n", |
| q == '"' ? "string" : "character"); |
| return cl; |
| } |
| int getchr(void) { |
| for (;;) { |
| while (map[*cp]&BLANK) |
| cp++; |
| if (!(map[*cp]&NEWLINE)) |
| return *cp; |
| cp++; |
| nextline(); |
| if (cp == limit) |
| return EOI; |
| } |
| } |
| static int backslash(int q) { |
| unsigned 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("ill-formed hexadecimal escape sequence\n"); |
| else |
| error("ill-formed hexadecimal escape sequence `\\x%c'\n", *cp); |
| if (*cp != q) |
| cp++; |
| return 0; |
| } |
| for (c = 0; map[*cp]&(DIGIT|HEX); cp++) { |
| if (c >> (8*widechar->size - 4)) |
| overflow = 1; |
| if (map[*cp]&DIGIT) |
| c = (c<<4) + *cp - '0'; |
| else |
| c = (c<<4) + (*cp&~040) - 'A' + 10; |
| } |
| if (overflow) |
| warning("overflow in hexadecimal escape sequence\n"); |
| return c&ones(8*widechar->size); |
| } |
| 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'; |
| } |
| return c; |
| default: |
| if (cp[-1] < ' ' || cp[-1] >= 0177) |
| warning("unrecognized character escape sequence\n"); |
| else |
| warning("unrecognized character escape sequence `\\%c'\n", cp[-1]); |
| } |
| return cp[-1]; |
| } |
