X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=lexer.c;h=38473a2fb5f935716b7711509f802e2df12f121c;hb=6dc5b6251ac0d183a62021b991d17d2debd603eb;hp=ba5e8fb0f80ba5e75ee9dd4ab10fd56e3d5c583f;hpb=f8ab3dc5a14d699adc515632b3b8d4e7f49d8cea;p=cparser diff --git a/lexer.c b/lexer.c index ba5e8fb..38473a2 100644 --- a/lexer.c +++ b/lexer.c @@ -7,6 +7,7 @@ #include "adt/strset.h" #include "adt/util.h" #include "type_t.h" +#include "target_architecture.h" #include #include @@ -17,6 +18,19 @@ //#define DEBUG_CHARS #define MAX_PUTBACK 3 +#ifdef _WIN32 +/* No strtold on windows and no replacement yet */ +#define strtold(s, e) strtod(s, e) +#endif + +#if defined HAS_SIGNED_CHAR +typedef signed char char_type; +#elif defined HAS_UNSIGNED_CHAR +typedef unsigned char char_type; +#else +# error signedness of char not determined +#endif + static int c; token_t lexer_token; symbol_t *symbol_L; @@ -75,7 +89,7 @@ static inline void put_back(int pc) //assert(bufpos < buf+MAX_PUTBACK || *bufpos == pc); char *p = buf + (bufpos - buf); - *p = pc; + *p = (char) pc; /* going backwards in the buffer is legal as long as it's not more often * than MAX_PUTBACK */ @@ -234,14 +248,14 @@ static void parse_symbol(void) symbol_t *symbol; char *string; - obstack_1grow(&symbol_obstack, c); + obstack_1grow(&symbol_obstack, (char) c); next_char(); while(1) { switch(c) { DIGITS SYMBOL_CHARS - obstack_1grow(&symbol_obstack, c); + obstack_1grow(&symbol_obstack, (char) c); next_char(); break; @@ -264,39 +278,78 @@ end_symbol: } } -static void parse_integer_suffix(void) +static void parse_integer_suffix(bool is_oct_hex) { - if(c == 'U' || c == 'U') { + bool is_unsigned = false; + bool min_long = false; + bool min_longlong = false; + + if(c == 'U' || c == 'u') { + is_unsigned = true; next_char(); if(c == 'L' || c == 'l') { + min_long = true; next_char(); if(c == 'L' || c == 'l') { + min_longlong = true; next_char(); - lexer_token.datatype = type_ulonglong; - } else { - lexer_token.datatype = type_ulong; } - } else { - lexer_token.datatype = type_uint; } } else if(c == 'l' || c == 'L') { + min_long = true; next_char(); if(c == 'l' || c == 'L') { + min_longlong = true; next_char(); if(c == 'u' || c == 'U') { + is_unsigned = true; next_char(); - lexer_token.datatype = type_ulonglong; - } else { - lexer_token.datatype = type_longlong; } } else if(c == 'u' || c == 'U') { + is_unsigned = true; next_char(); lexer_token.datatype = type_ulong; - } else { - lexer_token.datatype = type_int; } + } + + if(!is_unsigned) { + long long v = lexer_token.v.intvalue; + if(!min_long) { + if(v >= TARGET_INT_MIN && v <= TARGET_INT_MAX) { + lexer_token.datatype = type_int; + return; + } else if(is_oct_hex && v >= 0 && v <= TARGET_UINT_MAX) { + lexer_token.datatype = type_uint; + return; + } + } + if(!min_longlong) { + if(v >= TARGET_LONG_MIN && v <= TARGET_LONG_MAX) { + lexer_token.datatype = type_long; + return; + } else if(is_oct_hex && v >= 0 && v <= TARGET_ULONG_MAX) { + lexer_token.datatype = type_ulong; + return; + } + } + unsigned long long uv = (unsigned long long) v; + if(is_oct_hex && uv > (unsigned long long) TARGET_LONGLONG_MAX) { + lexer_token.datatype = type_ulonglong; + return; + } + + lexer_token.datatype = type_longlong; } else { - lexer_token.datatype = type_int; + unsigned long long v = (unsigned long long) lexer_token.v.intvalue; + if(!min_long && v <= TARGET_UINT_MAX) { + lexer_token.datatype = type_uint; + return; + } + if(!min_longlong && v <= TARGET_ULONG_MAX) { + lexer_token.datatype = type_ulong; + return; + } + lexer_token.datatype = type_ulonglong; } } @@ -320,11 +373,88 @@ static void parse_floating_suffix(void) } } -static inline bool is_hex_digit(int c) -{ - return (c >= '0' && c <= '9') - || (c >= 'a' && c <= 'f') - || (c >= 'A' && c <= 'F'); +/** + * A replacement for strtoull. Only those parts needed for + * our parser are implemented. + */ +static unsigned long long parse_int_string(const char *s, const char **endptr, int base) { + unsigned long long v = 0; + + switch (base) { + case 16: + for (;; ++s) { + /* check for overrun */ + if (v >= 0x1000000000000000ULL) + break; + switch (tolower(*s)) { + case '0': v <<= 4; break; + case '1': v <<= 4; v |= 0x1; break; + case '2': v <<= 4; v |= 0x2; break; + case '3': v <<= 4; v |= 0x3; break; + case '4': v <<= 4; v |= 0x4; break; + case '5': v <<= 4; v |= 0x5; break; + case '6': v <<= 4; v |= 0x6; break; + case '7': v <<= 4; v |= 0x7; break; + case '8': v <<= 4; v |= 0x8; break; + case '9': v <<= 4; v |= 0x9; break; + case 'a': v <<= 4; v |= 0xa; break; + case 'b': v <<= 4; v |= 0xb; break; + case 'c': v <<= 4; v |= 0xc; break; + case 'd': v <<= 4; v |= 0xd; break; + case 'e': v <<= 4; v |= 0xe; break; + case 'f': v <<= 4; v |= 0xf; break; + default: + goto end; + } + } + break; + case 8: + for (;; ++s) { + /* check for overrun */ + if (v >= 0x2000000000000000ULL) + break; + switch (tolower(*s)) { + case '0': v <<= 3; break; + case '1': v <<= 3; v |= 1; break; + case '2': v <<= 3; v |= 2; break; + case '3': v <<= 3; v |= 3; break; + case '4': v <<= 3; v |= 4; break; + case '5': v <<= 3; v |= 5; break; + case '6': v <<= 3; v |= 6; break; + case '7': v <<= 3; v |= 7; break; + default: + goto end; + } + } + break; + case 10: + for (;; ++s) { + /* check for overrun */ + if (v > 0x1999999999999999ULL) + break; + switch (tolower(*s)) { + case '0': v *= 10; break; + case '1': v *= 10; v += 1; break; + case '2': v *= 10; v += 2; break; + case '3': v *= 10; v += 3; break; + case '4': v *= 10; v += 4; break; + case '5': v *= 10; v += 5; break; + case '6': v *= 10; v += 6; break; + case '7': v *= 10; v += 7; break; + case '8': v *= 10; v += 8; break; + case '9': v *= 10; v += 9; break; + default: + goto end; + } + } + break; + default: + assert(0); + break; + } +end: + *endptr = s; + return v; } static void parse_number_hex(void) @@ -332,8 +462,8 @@ static void parse_number_hex(void) assert(c == 'x' || c == 'X'); next_char(); - while(is_hex_digit(c)) { - obstack_1grow(&symbol_obstack, c); + while(isxdigit(c)) { + obstack_1grow(&symbol_obstack, (char) c); next_char(); } obstack_1grow(&symbol_obstack, '\0'); @@ -348,14 +478,15 @@ static void parse_number_hex(void) lexer_token.type = T_ERROR; } - char *endptr; + const char *endptr; lexer_token.type = T_INTEGER; - lexer_token.v.intvalue = strtoull(string, &endptr, 16); + lexer_token.v.intvalue = parse_int_string(string, &endptr, 16); if(*endptr != '\0') { parse_error("hex number literal too long"); } obstack_free(&symbol_obstack, string); + parse_integer_suffix(true); } static inline bool is_octal_digit(int chr) @@ -366,28 +497,28 @@ static inline bool is_octal_digit(int chr) static void parse_number_oct(void) { while(is_octal_digit(c)) { - obstack_1grow(&symbol_obstack, c); + obstack_1grow(&symbol_obstack, (char) c); next_char(); } obstack_1grow(&symbol_obstack, '\0'); char *string = obstack_finish(&symbol_obstack); - char *endptr; + const char *endptr; lexer_token.type = T_INTEGER; - lexer_token.v.intvalue = strtoull(string, &endptr, 8); + lexer_token.v.intvalue = parse_int_string(string, &endptr, 8); if(*endptr != '\0') { parse_error("octal number literal too long"); } obstack_free(&symbol_obstack, string); - parse_integer_suffix(); + parse_integer_suffix(true); } static void parse_number_dec(void) { bool is_float = false; while(isdigit(c)) { - obstack_1grow(&symbol_obstack, c); + obstack_1grow(&symbol_obstack, (char) c); next_char(); } @@ -396,7 +527,7 @@ static void parse_number_dec(void) next_char(); while(isdigit(c)) { - obstack_1grow(&symbol_obstack, c); + obstack_1grow(&symbol_obstack, (char) c); next_char(); } is_float = true; @@ -406,12 +537,12 @@ static void parse_number_dec(void) next_char(); if(c == '-' || c == '+') { - obstack_1grow(&symbol_obstack, c); + obstack_1grow(&symbol_obstack, (char) c); next_char(); } while(isdigit(c)) { - obstack_1grow(&symbol_obstack, c); + obstack_1grow(&symbol_obstack, (char) c); next_char(); } is_float = true; @@ -420,8 +551,8 @@ static void parse_number_dec(void) obstack_1grow(&symbol_obstack, '\0'); char *string = obstack_finish(&symbol_obstack); - char *endptr; if(is_float) { + char *endptr; lexer_token.type = T_FLOATINGPOINT; lexer_token.v.floatvalue = strtold(string, &endptr); @@ -431,14 +562,15 @@ static void parse_number_dec(void) parse_floating_suffix(); } else { + const char *endptr; lexer_token.type = T_INTEGER; - lexer_token.v.intvalue = strtoull(string, &endptr, 10); + lexer_token.v.intvalue = parse_int_string(string, &endptr, 10); if(*endptr != '\0') { parse_error("invalid number literal"); } - parse_integer_suffix(); + parse_integer_suffix(false); } obstack_free(&symbol_obstack, string); } @@ -491,7 +623,7 @@ static int parse_octal_sequence(const int first_digit) if (!is_octal_digit(c)) return value; value = 8 * value + c - '0'; next_char(); - return value; + return (char_type)value; } static int parse_hex_sequence(void) @@ -510,7 +642,7 @@ static int parse_hex_sequence(void) next_char(); } - return value; + return (char_type)value; } static int parse_escape_sequence(void) @@ -583,7 +715,7 @@ static void parse_string_literal(void) switch(c) { case '\\': tc = parse_escape_sequence(); - obstack_1grow(&symbol_obstack, tc); + obstack_1grow(&symbol_obstack, (char) tc); break; case EOF: @@ -598,7 +730,7 @@ static void parse_string_literal(void) goto end_of_string; default: - obstack_1grow(&symbol_obstack, c); + obstack_1grow(&symbol_obstack, (char) c); next_char(); break; } @@ -762,7 +894,7 @@ static void parse_line_directive(void) if(pp_token.type != T_INTEGER) { parse_error("expected integer"); } else { - lexer_token.source_position.linenr = pp_token.v.intvalue - 1; + lexer_token.source_position.linenr = (unsigned int)(pp_token.v.intvalue - 1); next_pp_token(); } if(pp_token.type == T_STRING_LITERAL) { @@ -1045,14 +1177,14 @@ void init_lexer(void) { strset_init(&stringset); - type_int = make_atomic_type(ATOMIC_TYPE_INT, TYPE_QUALIFIER_CONST); - type_uint = make_atomic_type(ATOMIC_TYPE_UINT, TYPE_QUALIFIER_CONST); - type_long = make_atomic_type(ATOMIC_TYPE_LONG, TYPE_QUALIFIER_CONST); - type_ulong = make_atomic_type(ATOMIC_TYPE_ULONG, TYPE_QUALIFIER_CONST); + type_int = make_atomic_type(ATOMIC_TYPE_INT, TYPE_QUALIFIER_NONE); + type_uint = make_atomic_type(ATOMIC_TYPE_UINT, TYPE_QUALIFIER_NONE); + type_long = make_atomic_type(ATOMIC_TYPE_LONG, TYPE_QUALIFIER_NONE); + type_ulong = make_atomic_type(ATOMIC_TYPE_ULONG, TYPE_QUALIFIER_NONE); type_longlong = make_atomic_type(ATOMIC_TYPE_LONGLONG, - TYPE_QUALIFIER_CONST); + TYPE_QUALIFIER_NONE); type_ulonglong = make_atomic_type(ATOMIC_TYPE_ULONGLONG, - TYPE_QUALIFIER_CONST); + TYPE_QUALIFIER_NONE); type_float = make_atomic_type(ATOMIC_TYPE_FLOAT, TYPE_QUALIFIER_CONST); type_double = make_atomic_type(ATOMIC_TYPE_DOUBLE, @@ -1082,7 +1214,7 @@ void exit_lexer(void) static __attribute__((unused)) void dbg_pos(const source_position_t source_position) { - fprintf(stdout, "%s:%d\n", source_position.input_name, + fprintf(stdout, "%s:%u\n", source_position.input_name, source_position.linenr); fflush(stdout); }