X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=lexer.c;h=b00b8a22481625ec455015dba152c10ca47fb853;hb=8c2442b5efb0f534ac76b62f2b0cee24481991f9;hp=a6983280be85dceb22868846c0536e6d2cc3d7ba;hpb=c1449206f35164b677f1123d20cb2b306e0b4781;p=cparser diff --git a/lexer.c b/lexer.c index a698328..b00b8a2 100644 --- a/lexer.c +++ b/lexer.c @@ -1,20 +1,39 @@ #include +#include "diagnostic.h" #include "lexer.h" #include "token_t.h" #include "symbol_table_t.h" #include "adt/error.h" #include "adt/strset.h" #include "adt/util.h" +#include "types.h" +#include "type_t.h" +#include "target_architecture.h" +#include "parser.h" #include #include #include +#include #include //#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; @@ -43,8 +62,8 @@ static void parse_error(const char *msg) static inline void next_real_char(void) { - bufpos++; - if(bufpos >= bufend) { + assert(bufpos <= bufend); + if (bufpos >= bufend) { size_t s = fread(buf + MAX_PUTBACK, 1, sizeof(buf) - MAX_PUTBACK, input); if(s == 0) { @@ -54,20 +73,13 @@ static inline void next_real_char(void) bufpos = buf + MAX_PUTBACK; bufend = buf + MAX_PUTBACK + s; } - c = *(bufpos); + c = *bufpos++; } static inline void put_back(int pc) { - assert(bufpos >= buf); - assert(bufpos < buf+MAX_PUTBACK || *bufpos == pc); - - char *p = buf + (bufpos - buf); - *p = pc; - - /* going backwards in the buffer is legal as long as it's not more often - * than MAX_PUTBACK */ - bufpos--; + assert(bufpos > buf); + *(--bufpos - buf + buf) = (char) pc; #ifdef DEBUG_CHARS printf("putback '%c'\n", pc); @@ -110,7 +122,6 @@ static inline void next_char(void) { next_real_char(); -#if 0 /* filter trigraphs */ if(UNLIKELY(c == '\\')) { maybe_concat_lines(); @@ -139,15 +150,13 @@ static inline void next_char(void) case '>': c = '}'; break; case '-': c = '~'; break; default: - put_back('?'); put_back(c); + put_back('?'); c = '?'; break; } end_of_next_char:; -#endif - (void) maybe_concat_lines; #ifdef DEBUG_CHARS printf("nchar '%c'\n", c); #endif @@ -225,14 +234,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; @@ -255,27 +264,78 @@ end_symbol: } } -static void parse_integer_suffix(void) +static void parse_integer_suffix(bool is_oct_hex) { - if(c == 'U' || c == 'U') { - /* TODO do something with the suffixes... */ + 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(); } } } 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(); } } else if(c == 'u' || c == 'U') { + is_unsigned = true; next_char(); + lexer_token.datatype = type_unsigned_long; + } + } + + 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_unsigned_int; + 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_unsigned_long; + return; + } + } + unsigned long long uv = (unsigned long long) v; + if(is_oct_hex && uv > (unsigned long long) TARGET_LONGLONG_MAX) { + lexer_token.datatype = type_unsigned_long_long; + return; + } + + lexer_token.datatype = type_long_long; + } else { + unsigned long long v = (unsigned long long) lexer_token.v.intvalue; + if(!min_long && v <= TARGET_UINT_MAX) { + lexer_token.datatype = type_unsigned_int; + return; + } + if(!min_longlong && v <= TARGET_ULONG_MAX) { + lexer_token.datatype = type_unsigned_long; + return; } + lexer_token.datatype = type_unsigned_long_long; } } @@ -285,149 +345,220 @@ static void parse_floating_suffix(void) /* TODO: do something usefull with the suffixes... */ case 'f': case 'F': + next_char(); + lexer_token.datatype = type_float; + break; case 'l': case 'L': next_char(); + lexer_token.datatype = type_long_double; break; default: + lexer_token.datatype = type_double; break; } } +/** + * 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) { assert(c == 'x' || c == 'X'); next_char(); - if (!isdigit(c) && - !('A' <= c && c <= 'F') && - !('a' <= c && c <= 'f')) { - parse_error("premature end of hex number literal"); - lexer_token.type = T_ERROR; - return; - } - - int value = 0; - while(1) { - if (isdigit(c)) { - value = 16 * value + c - '0'; - } else if ('A' <= c && c <= 'F') { - value = 16 * value + c - 'A' + 10; - } else if ('a' <= c && c <= 'f') { - value = 16 * value + c - 'a' + 10; - } else { - parse_integer_suffix(); - - lexer_token.type = T_INTEGER; - lexer_token.v.intvalue = value; - return; - } + while(isxdigit(c)) { + obstack_1grow(&symbol_obstack, (char) c); next_char(); } + obstack_1grow(&symbol_obstack, '\0'); + char *string = obstack_finish(&symbol_obstack); if(c == '.' || c == 'p' || c == 'P') { next_char(); panic("Hex floating point numbers not implemented yet"); } -} - -static void parse_number_oct(void) -{ - int value = 0; - while(c >= '0' && c <= '7') { - value = 8 * value + c - '0'; - next_char(); - } - if (c == '8' || c == '9') { - parse_error("invalid octal number"); + if(*string == '\0') { + parse_error("invalid hex number"); lexer_token.type = T_ERROR; - return; } + const char *endptr; lexer_token.type = T_INTEGER; - lexer_token.v.intvalue = value; + lexer_token.v.intvalue = parse_int_string(string, &endptr, 16); + if(*endptr != '\0') { + parse_error("hex number literal too long"); + } - parse_integer_suffix(); + obstack_free(&symbol_obstack, string); + parse_integer_suffix(true); } -static void parse_floatingpoint_exponent(long double value) +static inline bool is_octal_digit(int chr) { - unsigned int expo = 0; - long double factor = 10.; - - if(c == '-') { - next_char(); - factor = 0.1; - } else if(c == '+') { - next_char(); - } - - while(c >= '0' && c <= '9') { - expo = 10 * expo + (c - '0'); - next_char(); - } - - while(1) { - if(expo & 1) - value *= factor; - expo >>= 1; - if(expo == 0) - break; - factor *= factor; - } - - lexer_token.type = T_FLOATINGPOINT; - lexer_token.v.floatvalue = value; - - parse_floating_suffix(); + return '0' <= chr && chr <= '7'; } -static void parse_floatingpoint_fract(int integer_part) +static void parse_number_oct(void) { - long double value = integer_part; - long double factor = 1.; - - while(c >= '0' && c <= '9') { - factor *= 0.1; - value += (c - '0') * factor; + while(is_octal_digit(c)) { + obstack_1grow(&symbol_obstack, (char) c); next_char(); } + obstack_1grow(&symbol_obstack, '\0'); + char *string = obstack_finish(&symbol_obstack); - if(c == 'e' || c == 'E') { - next_char(); - parse_floatingpoint_exponent(value); - return; + const char *endptr; + lexer_token.type = T_INTEGER; + lexer_token.v.intvalue = parse_int_string(string, &endptr, 8); + if(*endptr != '\0') { + parse_error("octal number literal too long"); } - lexer_token.type = T_FLOATINGPOINT; - lexer_token.v.floatvalue = value; - - parse_floating_suffix(); + obstack_free(&symbol_obstack, string); + parse_integer_suffix(true); } static void parse_number_dec(void) { - int value = 0; - + bool is_float = false; while(isdigit(c)) { - value = 10 * value + c - '0'; + obstack_1grow(&symbol_obstack, (char) c); next_char(); } if(c == '.') { + obstack_1grow(&symbol_obstack, '.'); next_char(); - parse_floatingpoint_fract(value); - return; + + while(isdigit(c)) { + obstack_1grow(&symbol_obstack, (char) c); + next_char(); + } + is_float = true; } if(c == 'e' || c == 'E') { + obstack_1grow(&symbol_obstack, 'e'); next_char(); - parse_floatingpoint_exponent(value); - return; + + if(c == '-' || c == '+') { + obstack_1grow(&symbol_obstack, (char) c); + next_char(); + } + + while(isdigit(c)) { + obstack_1grow(&symbol_obstack, (char) c); + next_char(); + } + is_float = true; } - parse_integer_suffix(); - lexer_token.type = T_INTEGER; - lexer_token.v.intvalue = value; + obstack_1grow(&symbol_obstack, '\0'); + char *string = obstack_finish(&symbol_obstack); + + if(is_float) { + char *endptr; + lexer_token.type = T_FLOATINGPOINT; + lexer_token.v.floatvalue = strtold(string, &endptr); + + if(*endptr != '\0') { + parse_error("invalid number literal"); + } + + parse_floating_suffix(); + } else { + const char *endptr; + lexer_token.type = T_INTEGER; + lexer_token.v.intvalue = parse_int_string(string, &endptr, 10); + + if(*endptr != '\0') { + parse_error("invalid number literal"); + } + + parse_integer_suffix(false); + } + obstack_free(&symbol_obstack, string); } static void parse_number(void) @@ -449,23 +580,17 @@ static void parse_number(void) case '7': parse_number_oct(); break; - case '.': - next_char(); - parse_floatingpoint_fract(0); - break; - case 'e': - case 'E': - parse_floatingpoint_exponent(0); - break; case '8': case '9': next_char(); parse_error("invalid octal number"); lexer_token.type = T_ERROR; return; + case '.': + case 'e': + case 'E': default: - put_back(c); - c = '0'; + obstack_1grow(&symbol_obstack, '0'); parse_number_dec(); return; } @@ -474,11 +599,6 @@ static void parse_number(void) } } -static inline int is_octal_digit(int chr) -{ - return '0' <= chr && chr <= '7'; -} - static int parse_octal_sequence(const int first_digit) { assert(is_octal_digit(first_digit)); @@ -489,7 +609,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) @@ -508,7 +628,7 @@ static int parse_hex_sequence(void) next_char(); } - return value; + return (char_type)value; } static int parse_escape_sequence(void) @@ -550,28 +670,30 @@ static int parse_escape_sequence(void) } } -const char *concat_strings(const char *s1, const char *s2) +string_t concat_strings(const string_t *const s1, const string_t *const s2) { - size_t len1 = strlen(s1); - size_t len2 = strlen(s2); + const size_t len1 = s1->size - 1; + const size_t len2 = s2->size - 1; - char *concat = obstack_alloc(&symbol_obstack, len1 + len2 + 1); - memcpy(concat, s1, len1); - memcpy(concat + len1, s2, len2 + 1); + char *const concat = obstack_alloc(&symbol_obstack, len1 + len2 + 1); + memcpy(concat, s1->begin, len1); + memcpy(concat + len1, s2->begin, len2 + 1); +#if 0 /* TODO hash */ const char *result = strset_insert(&stringset, concat); if(result != concat) { obstack_free(&symbol_obstack, concat); } return result; +#else + return (string_t){ concat, len1 + len2 + 1 }; +#endif } static void parse_string_literal(void) { - unsigned start_linenr = lexer_token.source_position.linenr; - char *string; - const char *result; + const unsigned start_linenr = lexer_token.source_position.linenr; assert(c == '"'); next_char(); @@ -581,7 +703,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: @@ -596,7 +718,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; } @@ -608,16 +730,126 @@ end_of_string: /* add finishing 0 to the string */ obstack_1grow(&symbol_obstack, '\0'); - string = obstack_finish(&symbol_obstack); + const size_t size = (size_t)obstack_object_size(&symbol_obstack); + const char *const string = obstack_finish(&symbol_obstack); +#if 0 /* TODO hash */ /* check if there is already a copy of the string */ result = strset_insert(&stringset, string); if(result != string) { obstack_free(&symbol_obstack, string); } +#else + const char *const result = string; +#endif + + lexer_token.type = T_STRING_LITERAL; + lexer_token.v.string.begin = result; + lexer_token.v.string.size = size; +} + +static void parse_wide_character_constant(void) +{ + eat('\''); + + int found_char = 0; + while(1) { + switch(c) { + case '\\': + found_char = parse_escape_sequence(); + break; + + MATCH_NEWLINE( + parse_error("newline while parsing character constant"); + break; + ) + + case '\'': + next_char(); + goto end_of_wide_char_constant; + + case EOF: + parse_error("EOF while parsing character constant"); + lexer_token.type = T_ERROR; + return; + + default: + if(found_char != 0) { + parse_error("more than 1 characters in character " + "constant"); + goto end_of_wide_char_constant; + } else { + found_char = c; + next_char(); + } + break; + } + } + +end_of_wide_char_constant: + lexer_token.type = T_INTEGER; + lexer_token.v.intvalue = found_char; + lexer_token.datatype = type_wchar_t; +} + +static void parse_wide_string_literal(void) +{ + const unsigned start_linenr = lexer_token.source_position.linenr; + + assert(c == '"'); + next_char(); + + while(1) { + switch(c) { + case '\\': { + wchar_rep_t tc = parse_escape_sequence(); + obstack_grow(&symbol_obstack, &tc, sizeof(tc)); + break; + } + + case EOF: + error_prefix_at(lexer_token.source_position.input_name, + start_linenr); + fprintf(stderr, "string has no end\n"); + lexer_token.type = T_ERROR; + return; + + case '"': + next_char(); + goto end_of_string; + + default: { + wchar_rep_t tc = c; + obstack_grow(&symbol_obstack, &tc, sizeof(tc)); + next_char(); + break; + } + } + } + +end_of_string:; + + /* TODO: concatenate multiple strings separated by whitespace... */ + + /* add finishing 0 to the string */ + wchar_rep_t nul = L'\0'; + obstack_grow(&symbol_obstack, &nul, sizeof(nul)); + const size_t size = (size_t)obstack_object_size(&symbol_obstack) / sizeof(wchar_rep_t); + const wchar_rep_t *const string = obstack_finish(&symbol_obstack); + +#if 0 /* TODO hash */ + /* check if there is already a copy of the string */ + const wchar_rep_t *const result = strset_insert(&stringset, string); + if(result != string) { + obstack_free(&symbol_obstack, string); + } +#else + const wchar_rep_t *const result = string; +#endif - lexer_token.type = T_STRING_LITERAL; - lexer_token.v.string = result; + lexer_token.type = T_WIDE_STRING_LITERAL; + lexer_token.v.wide_string.begin = result; + lexer_token.v.wide_string.size = size; } static void parse_character_constant(void) @@ -661,6 +893,7 @@ static void parse_character_constant(void) end_of_char_constant: lexer_token.type = T_INTEGER; lexer_token.v.intvalue = found_char; + lexer_token.datatype = type_int; } static void skip_multiline_comment(void) @@ -760,11 +993,11 @@ 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) { - lexer_token.source_position.input_name = pp_token.v.string; + lexer_token.source_position.input_name = pp_token.v.string.begin; next_pp_token(); } @@ -804,6 +1037,8 @@ static void parse_preprocessor_identifier(void) error_directive(); break; case TP_pragma: + warningf(lexer_token.source_position, "encountered unknown #pragma"); + eat_until_newline(); break; } } @@ -867,10 +1102,13 @@ void lexer_next_preprocessing_token(void) SYMBOL_CHARS parse_symbol(); /* might be a wide string ( L"string" ) */ - if(c == '"' && (lexer_token.type == T_IDENTIFIER && - lexer_token.v.symbol == symbol_L)) { - parse_string_literal(); - return; + if(lexer_token.type == T_IDENTIFIER && + lexer_token.v.symbol == symbol_L) { + if(c == '"') { + parse_wide_string_literal(); + } else if(c == '\'') { + parse_wide_character_constant(); + } } return; @@ -888,6 +1126,21 @@ void lexer_next_preprocessing_token(void) case '.': MAYBE_PROLOG + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + put_back(c); + c = '.'; + parse_number_dec(); + return; + case '.': MAYBE_PROLOG MAYBE('.', T_DOTDOTDOT) @@ -1051,6 +1304,8 @@ void lexer_open_stream(FILE *stream, const char *input_name) lexer_token.source_position.input_name = input_name; symbol_L = symbol_table_insert("L"); + bufpos = NULL; + bufend = NULL; /* place a virtual \n at the beginning so the lexer knows that we're * at the beginning of a line */ @@ -1065,7 +1320,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); }