X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=lexer.c;h=4efc5bbd96530a8cefa7435f17a12e1096362859;hb=d8bbe649a1ad3d4769632462071d046bcd0e16e3;hp=3d26aefd622760d9c3a20639789f2ad9fd150b43;hpb=cedf7217c54c63acb637295ef4575ae676f9b853;p=cparser diff --git a/lexer.c b/lexer.c index 3d26aef..4efc5bb 100644 --- a/lexer.c +++ b/lexer.c @@ -1,7 +1,27 @@ +/* + * This file is part of cparser. + * Copyright (C) 2007-2008 Matthias Braun + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + */ #include #include "diagnostic.h" #include "lexer.h" +#include "symbol_t.h" #include "token_t.h" #include "symbol_table_t.h" #include "adt/error.h" @@ -20,22 +40,31 @@ #include #include +#ifndef _WIN32 +#include +#endif + //#define DEBUG_CHARS #define MAX_PUTBACK 3 +#define BUF_SIZE 1024 -#ifdef _WIN32 +#if defined(_WIN32) || defined(__CYGWIN__) /* No strtold on windows and no replacement yet */ -#define strtold(s, e) strtod(s, e) +#define strtold(s, e) strtod(s, e) +#define strcasecmp(a, b) stricmp(a, b) #endif -static int c; -token_t lexer_token; -symbol_t *symbol_L; -static FILE *input; -static char buf[1024 + MAX_PUTBACK]; -static const char *bufend; -static const char *bufpos; -static strset_t stringset; +typedef unsigned int utf32; + +static utf32 c; +token_t lexer_token; +symbol_t *symbol_L; +static FILE *input; +static utf32 buf[BUF_SIZE + MAX_PUTBACK]; +static const utf32 *bufend; +static const utf32 *bufpos; +static strset_t stringset; +bool allow_dollar_in_symbol = true; /** * Prints a parse error message at the current token. @@ -44,21 +73,239 @@ static strset_t stringset; */ static void parse_error(const char *msg) { - errorf(lexer_token.source_position, "%s", msg); + errorf(&lexer_token.source_position, "%s", msg); +} + +/** + * Prints an internal error message at the current token. + * + * @param msg the error message + */ +static NORETURN internal_error(const char *msg) +{ + internal_errorf(&lexer_token.source_position, "%s", msg); +} + +static size_t read_block(unsigned char *const read_buf, size_t const n) +{ + size_t const s = fread(read_buf, 1, n, input); + if (s == 0) { + if (ferror(input)) + parse_error("read from input failed"); + buf[MAX_PUTBACK] = EOF; + bufpos = buf + MAX_PUTBACK; + bufend = buf + MAX_PUTBACK + 1; + } + return s; +} + +static void decode_iso_8859_1(void) +{ + unsigned char read_buf[BUF_SIZE]; + size_t const s = read_block(read_buf, sizeof(read_buf)); + if (s == 0) + return; + + unsigned char const *src = read_buf; + unsigned char const *end = read_buf + s; + utf32 *dst = buf + MAX_PUTBACK; + while (src != end) + *dst++ = *src++; + + bufpos = buf + MAX_PUTBACK; + bufend = dst; +} + +static void decode_iso_8859_15(void) +{ + unsigned char read_buf[BUF_SIZE]; + size_t const s = read_block(read_buf, sizeof(read_buf)); + if (s == 0) + return; + + unsigned char const *src = read_buf; + unsigned char const *end = read_buf + s; + utf32 *dst = buf + MAX_PUTBACK; + while (src != end) { + utf32 tc = *src++; + switch (tc) { + case 0xA4: tc = 0x20AC; break; // € + case 0xA6: tc = 0x0160; break; // Š + case 0xA8: tc = 0x0161; break; // š + case 0xB4: tc = 0x017D; break; // Ž + case 0xB8: tc = 0x017E; break; // ž + case 0xBC: tc = 0x0152; break; // Œ + case 0xBD: tc = 0x0153; break; // œ + case 0xBE: tc = 0x0178; break; // Ÿ + } + *dst++ = tc; + } + + bufpos = buf + MAX_PUTBACK; + bufend = dst; +} + +static void decode_utf8(void) +{ + static utf32 part_decoded_min_code; + static utf32 part_decoded_char; + static size_t part_decoded_rest_len; + + do { + unsigned char read_buf[BUF_SIZE]; + size_t const s = read_block(read_buf, sizeof(read_buf)); + if (s == 0) { + if (part_decoded_rest_len > 0) + parse_error("incomplete input char at end of input"); + return; + } + + unsigned char const *src = read_buf; + unsigned char const *end = read_buf + s; + utf32 *dst = buf + MAX_PUTBACK; + utf32 decoded; + utf32 min_code; + + if (part_decoded_rest_len != 0) { + min_code = part_decoded_min_code; + decoded = part_decoded_char; + size_t const rest_len = part_decoded_rest_len; + part_decoded_rest_len = 0; + switch (rest_len) { + case 4: goto realign; + case 3: goto three_more; + case 2: goto two_more; + default: goto one_more; + } + } + + while (src != end) { + if ((*src & 0x80) == 0) { + decoded = *src++; + } else if ((*src & 0xE0) == 0xC0) { + min_code = 0x80; + decoded = *src++ & 0x1F; +one_more: + if (src == end) { + part_decoded_min_code = min_code; + part_decoded_char = decoded; + part_decoded_rest_len = 1; + break; + } + if ((*src & 0xC0) == 0x80) { + decoded = (decoded << 6) | (*src++ & 0x3F); + } else { + goto invalid_char; + } + if (decoded < min_code || + decoded > 0x10FFFF || + (0xD800 <= decoded && decoded < 0xE000) || // high/low surrogates + (0xFDD0 <= decoded && decoded < 0xFDF0) || // noncharacters + (decoded & 0xFFFE) == 0xFFFE) { // noncharacters + parse_error("invalid byte sequence in input"); + } + } else if ((*src & 0xF0) == 0xE0) { + min_code = 0x800; + decoded = *src++ & 0x0F; +two_more: + if (src == end) { + part_decoded_min_code = min_code; + part_decoded_char = decoded; + part_decoded_rest_len = 2; + break; + } + if ((*src & 0xC0) == 0x80) { + decoded = (decoded << 6) | (*src++ & 0x3F); + } else { + goto invalid_char; + } + goto one_more; + } else if ((*src & 0xF8) == 0xF0) { + min_code = 0x10000; + decoded = *src++ & 0x07; +three_more: + if (src == end) { + part_decoded_min_code = min_code; + part_decoded_char = decoded; + part_decoded_rest_len = 3; + break; + } + if ((*src & 0xC0) == 0x80) { + decoded = (decoded << 6) | (*src++ & 0x3F); + } else { + goto invalid_char; + } + goto two_more; + } else { +invalid_char: + parse_error("invalid byte sequence in input"); +realign: + do { + ++src; + if (src == end) { + part_decoded_rest_len = 4; + break; + } + } while ((*src & 0xC0) == 0x80 || (*src & 0xF8) == 0xF8); + continue; + } + *dst++ = decoded; + } + + bufpos = buf + MAX_PUTBACK; + bufend = dst; + } while (bufpos == bufend); +} + +typedef void (*decoder_t)(void); + +static decoder_t decoder = decode_utf8; + +typedef struct named_decoder_t { + char const *name; + decoder_t decoder; +} named_decoder_t; + +static named_decoder_t const decoders[] = { + { "CP819", decode_iso_8859_1 }, // offical alias + { "IBM819", decode_iso_8859_1 }, // offical alias + { "ISO-8859-1", decode_iso_8859_1 }, // offical alias + { "ISO-8859-15", decode_iso_8859_15 }, // offical name + { "ISO8859-1", decode_iso_8859_1 }, + { "ISO8859-15", decode_iso_8859_15 }, + { "ISO_8859-1", decode_iso_8859_1 }, // offical alias + { "ISO_8859-15", decode_iso_8859_15 }, // offical alias + { "ISO_8859-1:1987", decode_iso_8859_1 }, // offical name + { "Latin-9", decode_iso_8859_15 }, // offical alias + { "UTF-8", decode_utf8 }, // offical name + { "csISOLatin1", decode_iso_8859_1 }, // offical alias + { "iso-ir-100", decode_iso_8859_1 }, // offical alias + { "l1", decode_iso_8859_1 }, // offical alias + { "latin1", decode_iso_8859_1 }, // offical alias + + { NULL, NULL } +}; + +void select_input_encoding(char const* const encoding) +{ + for (named_decoder_t const *i = decoders; i->name != NULL; ++i) { + if (strcasecmp(encoding, i->name) != 0) + continue; + decoder = i->decoder; + return; + } + fprintf(stderr, "error: input encoding \"%s\" not supported\n", encoding); } static inline void next_real_char(void) { assert(bufpos <= bufend); if (bufpos >= bufend) { - size_t s = fread(buf + MAX_PUTBACK, 1, sizeof(buf) - MAX_PUTBACK, - input); - if(s == 0) { + if (input == NULL) { c = EOF; return; } - bufpos = buf + MAX_PUTBACK; - bufend = buf + MAX_PUTBACK + s; + decoder(); } c = *bufpos++; } @@ -68,13 +315,13 @@ static inline void next_real_char(void) * * @param pc the character to put back */ -static inline void put_back(int pc) +static inline void put_back(utf32 const pc) { assert(bufpos > buf); - *(--bufpos - buf + buf) = (char) pc; + *(--bufpos - buf + buf) = pc; #ifdef DEBUG_CHARS - printf("putback '%c'\n", pc); + printf("putback '%lc'\n", pc); #endif } @@ -159,6 +406,7 @@ end_of_next_char:; } #define SYMBOL_CHARS \ + case '$': if (!allow_dollar_in_symbol) goto dollar_sign; \ case 'a': \ case 'b': \ case 'c': \ @@ -246,6 +494,7 @@ static void parse_symbol(void) break; default: +dollar_sign: goto end_symbol; } } @@ -266,60 +515,78 @@ end_symbol: static void parse_integer_suffix(bool is_oct_hex) { - bool is_unsigned = false; - bool min_long = false; - bool min_longlong = false; - - if(c == 'U' || c == 'u') { - is_unsigned = true; + bool is_unsigned = false; + bool min_long = false; + bool min_longlong = false; + bool not_traditional = false; + int pos = 0; + char suffix[4]; + + if (c == 'U' || c == 'u') { + not_traditional = true; + suffix[pos++] = toupper(c); + is_unsigned = true; next_char(); - if(c == 'L' || c == 'l') { + if (c == 'L' || c == 'l') { + suffix[pos++] = toupper(c); min_long = true; next_char(); - if(c == 'L' || c == 'l') { + if (c == 'L' || c == 'l') { + suffix[pos++] = toupper(c); min_longlong = true; next_char(); } } - } else if(c == 'l' || c == 'L') { + } else if (c == 'l' || c == 'L') { + suffix[pos++] = toupper(c); min_long = true; next_char(); - if(c == 'l' || c == 'L') { - min_longlong = true; + if (c == 'l' || c == 'L') { + not_traditional = true; + suffix[pos++] = toupper(c); + min_longlong = true; next_char(); - if(c == 'u' || c == 'U') { - is_unsigned = true; + if (c == 'u' || c == 'U') { + suffix[pos++] = toupper(c); + is_unsigned = true; next_char(); } - } else if(c == 'u' || c == 'U') { - is_unsigned = true; + } else if (c == 'u' || c == 'U') { + not_traditional = true; + suffix[pos++] = toupper(c); + is_unsigned = true; next_char(); lexer_token.datatype = type_unsigned_long; } } - if(!is_unsigned) { + if (warning.traditional && not_traditional) { + suffix[pos] = '\0'; + warningf(&lexer_token.source_position, + "traditional C rejects the '%s' suffix", suffix); + } + if (!is_unsigned) { long long v = lexer_token.v.intvalue; - if(!min_long) { - if(v >= TARGET_INT_MIN && v <= TARGET_INT_MAX) { + 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) { + } 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) { + 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) { + } else if (is_oct_hex && v >= 0 && (unsigned long long)v <= (unsigned long long)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) { + if (is_oct_hex && uv > (unsigned long long) TARGET_LONGLONG_MAX) { lexer_token.datatype = type_unsigned_long_long; return; } @@ -327,11 +594,11 @@ static void parse_integer_suffix(bool is_oct_hex) 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) { + if (!min_long && v <= TARGET_UINT_MAX) { lexer_token.datatype = type_unsigned_int; return; } - if(!min_longlong && v <= TARGET_ULONG_MAX) { + if (!min_longlong && v <= TARGET_ULONG_MAX) { lexer_token.datatype = type_unsigned_long; return; } @@ -345,11 +612,19 @@ static void parse_floating_suffix(void) /* TODO: do something useful with the suffixes... */ case 'f': case 'F': + if (warning.traditional) { + warningf(&lexer_token.source_position, + "traditional C rejects the 'F' suffix"); + } next_char(); lexer_token.datatype = type_float; break; case 'l': case 'L': + if (warning.traditional) { + warningf(&lexer_token.source_position, + "traditional C rejects the 'F' suffix"); + } next_char(); lexer_token.datatype = type_long_double; break; @@ -363,7 +638,8 @@ static void parse_floating_suffix(void) * 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) { +static unsigned long long parse_int_string(const char *s, const char **endptr, int base) +{ unsigned long long v = 0; switch (base) { @@ -449,34 +725,74 @@ end: */ static void parse_number_hex(void) { + bool is_float = false; assert(c == 'x' || c == 'X'); next_char(); + obstack_1grow(&symbol_obstack, '0'); + obstack_1grow(&symbol_obstack, 'x'); + 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') { + if (c == '.') { + obstack_1grow(&symbol_obstack, (char) c); next_char(); - panic("Hex floating point numbers not implemented yet"); + + while (isxdigit(c)) { + obstack_1grow(&symbol_obstack, (char) c); + next_char(); + } + is_float = true; } + if (c == 'p' || c == 'P') { + obstack_1grow(&symbol_obstack, (char) c); + next_char(); + + if (c == '-' || c == '+') { + obstack_1grow(&symbol_obstack, (char) c); + next_char(); + } + + while (isxdigit(c)) { + obstack_1grow(&symbol_obstack, (char) c); + next_char(); + } + is_float = true; + } + + obstack_1grow(&symbol_obstack, '\0'); + char *string = obstack_finish(&symbol_obstack); if(*string == '\0') { parse_error("invalid hex number"); lexer_token.type = T_ERROR; + obstack_free(&symbol_obstack, string); + return; } - const char *endptr; - lexer_token.type = T_INTEGER; - lexer_token.v.intvalue = parse_int_string(string, &endptr, 16); - if(*endptr != '\0') { - parse_error("hex number literal too long"); + if (is_float) { + char *endptr; + lexer_token.type = T_FLOATINGPOINT; + lexer_token.v.floatvalue = strtold(string, &endptr); + + if(*endptr != '\0') { + parse_error("invalid hex float literal"); + } + + parse_floating_suffix(); + } else { + const char *endptr; + lexer_token.type = T_INTEGER; + lexer_token.v.intvalue = parse_int_string(string + 2, &endptr, 16); + if(*endptr != '\0') { + parse_error("hex number literal too long"); + } + parse_integer_suffix(true); } obstack_free(&symbol_obstack, string); - parse_integer_suffix(true); } /** @@ -484,7 +800,7 @@ static void parse_number_hex(void) * * @param char the character to check */ -static inline bool is_octal_digit(int chr) +static inline bool is_octal_digit(utf32 chr) { switch(chr) { case '0': @@ -531,23 +847,23 @@ static void parse_number_oct(void) static void parse_number_dec(void) { bool is_float = false; - while(isdigit(c)) { + while (isdigit(c)) { obstack_1grow(&symbol_obstack, (char) c); next_char(); } - if(c == '.') { + if (c == '.') { obstack_1grow(&symbol_obstack, '.'); next_char(); - while(isdigit(c)) { + while (isdigit(c)) { obstack_1grow(&symbol_obstack, (char) c); next_char(); } is_float = true; } if(c == 'e' || c == 'E') { - obstack_1grow(&symbol_obstack, 'e'); + obstack_1grow(&symbol_obstack, (char) c); next_char(); if(c == '-' || c == '+') { @@ -634,7 +950,8 @@ static void parse_number(void) * Returns the value of a digit. * The only portable way to do it ... */ -static int digit_value(int digit) { +static int digit_value(utf32 const digit) +{ switch (digit) { case '0': return 0; case '1': return 1; @@ -659,7 +976,7 @@ static int digit_value(int digit) { case 'f': case 'F': return 15; default: - panic("wrong character given"); + internal_error("wrong character given"); } } @@ -668,53 +985,43 @@ static int digit_value(int digit) { * * @param first_digit the already read first digit */ -static int parse_octal_sequence(const int first_digit) +static utf32 parse_octal_sequence(utf32 const first_digit) { assert(is_octal_digit(first_digit)); - int value = digit_value(first_digit); + utf32 value = digit_value(first_digit); if (!is_octal_digit(c)) return value; value = 8 * value + digit_value(c); next_char(); if (!is_octal_digit(c)) return value; value = 8 * value + digit_value(c); next_char(); - - if(char_is_signed) { - return (signed char) value; - } else { - return (unsigned char) value; - } + return value; } /** * Parses a hex character sequence. */ -static int parse_hex_sequence(void) +static utf32 parse_hex_sequence(void) { - int value = 0; + utf32 value = 0; while(isxdigit(c)) { value = 16 * value + digit_value(c); next_char(); } - - if(char_is_signed) { - return (signed char) value; - } else { - return (unsigned char) value; - } + return value; } /** * Parse an escape sequence. */ -static int parse_escape_sequence(void) +static utf32 parse_escape_sequence(void) { eat('\\'); - int ec = c; + utf32 const ec = c; next_char(); - switch(ec) { + switch (ec) { case '"': return '"'; case '\'': return '\''; case '\\': return '\\'; @@ -740,7 +1047,15 @@ static int parse_escape_sequence(void) case EOF: parse_error("reached end of file while parsing escape sequence"); return EOF; + /* \E is not documented, but handled, by GCC. It is acceptable according + * to §6.11.4, whereas \e is not. */ + case 'E': + case 'e': + if (c_mode & _GNUC) + return 27; /* hopefully 27 is ALWAYS the code for ESCAPE */ + /* FALLTHROUGH */ default: + /* §6.4.4.4:8 footnote 64 */ parse_error("unknown escape sequence"); return EOF; } @@ -758,6 +1073,10 @@ string_t concat_strings(const string_t *const s1, const string_t *const s2) memcpy(concat, s1->begin, len1); memcpy(concat + len1, s2->begin, len2 + 1); + if (warning.traditional) { + warningf(&lexer_token.source_position, + "traditional C rejects string constant concatenation"); + } #if 0 /* TODO hash */ const char *result = strset_insert(&stringset, concat); if(result != concat) { @@ -784,6 +1103,10 @@ wide_string_t concat_string_wide_string(const string_t *const s1, const wide_str concat[i] = src[i]; } memcpy(concat + len1, s2->begin, (len2 + 1) * sizeof(*concat)); + if (warning.traditional) { + warningf(&lexer_token.source_position, + "traditional C rejects string constant concatenation"); + } return (wide_string_t){ concat, len1 + len2 + 1 }; } @@ -799,6 +1122,10 @@ wide_string_t concat_wide_strings(const wide_string_t *const s1, const wide_stri wchar_rep_t *const concat = obstack_alloc(&symbol_obstack, (len1 + len2 + 1) * sizeof(*concat)); memcpy(concat, s1->begin, len1 * sizeof(*concat)); memcpy(concat + len1, s2->begin, (len2 + 1) * sizeof(*concat)); + if (warning.traditional) { + warningf(&lexer_token.source_position, + "traditional C rejects string constant concatenation"); + } return (wide_string_t){ concat, len1 + len2 + 1 }; } @@ -813,14 +1140,39 @@ wide_string_t concat_wide_string_string(const wide_string_t *const s1, const str wchar_rep_t *const concat = obstack_alloc(&symbol_obstack, (len1 + len2 + 1) * sizeof(*concat)); memcpy(concat, s1->begin, len1 * sizeof(*concat)); - const char *const src = s2->begin; + const char *const src = s2->begin; + wchar_rep_t *const dst = concat + len1; for (size_t i = 0; i != len2 + 1; ++i) { - concat[i] = src[i]; + dst[i] = src[i]; + } + if (warning.traditional) { + warningf(&lexer_token.source_position, + "traditional C rejects string constant concatenation"); } return (wide_string_t){ concat, len1 + len2 + 1 }; } +static void grow_symbol(utf32 const tc) +{ + struct obstack *const o = &symbol_obstack; + if (tc < 0x80U) { + obstack_1grow(o, tc); + } else if (tc < 0x800) { + obstack_1grow(o, 0xC0 | (tc >> 6)); + obstack_1grow(o, 0x80 | (tc & 0x3F)); + } else if (tc < 0x10000) { + obstack_1grow(o, 0xE0 | ( tc >> 12)); + obstack_1grow(o, 0x80 | ((tc >> 6) & 0x3F)); + obstack_1grow(o, 0x80 | ( tc & 0x3F)); + } else { + obstack_1grow(o, 0xF0 | ( tc >> 18)); + obstack_1grow(o, 0x80 | ((tc >> 12) & 0x3F)); + obstack_1grow(o, 0x80 | ((tc >> 6) & 0x3F)); + obstack_1grow(o, 0x80 | ( tc & 0x3F)); + } +} + /** * Parse a string literal and set lexer_token. */ @@ -830,19 +1182,23 @@ static void parse_string_literal(void) eat('"'); - int tc; while(1) { switch(c) { - case '\\': - tc = parse_escape_sequence(); - obstack_1grow(&symbol_obstack, (char) tc); + case '\\': { + utf32 const tc = parse_escape_sequence(); + if (tc >= 0x100) { + warningf(&lexer_token.source_position, + "escape sequence out of range"); + } + obstack_1grow(&symbol_obstack, tc); break; + } case EOF: { source_position_t source_position; source_position.input_name = lexer_token.source_position.input_name; source_position.linenr = start_linenr; - errorf(source_position, "string has no end"); + errorf(&source_position, "string has no end"); lexer_token.type = T_ERROR; return; } @@ -852,7 +1208,7 @@ static void parse_string_literal(void) goto end_of_string; default: - obstack_1grow(&symbol_obstack, (char) c); + grow_symbol(c); next_char(); break; } @@ -887,14 +1243,17 @@ end_of_string: */ static void parse_wide_character_constant(void) { + const unsigned start_linenr = lexer_token.source_position.linenr; + eat('\''); - int found_char = 0; while(1) { switch(c) { - case '\\': - found_char = parse_escape_sequence(); + case '\\': { + wchar_rep_t tc = parse_escape_sequence(); + obstack_grow(&symbol_obstack, &tc, sizeof(tc)); break; + } MATCH_NEWLINE( parse_error("newline while parsing character constant"); @@ -905,28 +1264,34 @@ static void parse_wide_character_constant(void) next_char(); goto end_of_wide_char_constant; - case EOF: - parse_error("EOF while parsing character constant"); + case EOF: { + source_position_t source_position = lexer_token.source_position; + source_position.linenr = start_linenr; + errorf(&source_position, "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(); - } + default: { + wchar_rep_t tc = (wchar_rep_t) c; + obstack_grow(&symbol_obstack, &tc, sizeof(tc)); + 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; +end_of_wide_char_constant:; + size_t size = (size_t) obstack_object_size(&symbol_obstack); + assert(size % sizeof(wchar_rep_t) == 0); + size /= sizeof(wchar_rep_t); + + const wchar_rep_t *string = obstack_finish(&symbol_obstack); + + lexer_token.type = T_WIDE_CHARACTER_CONSTANT; + lexer_token.v.wide_string.begin = string; + lexer_token.v.wide_string.size = size; + lexer_token.datatype = type_wchar_t; } /** @@ -951,7 +1316,7 @@ static void parse_wide_string_literal(void) source_position_t source_position; source_position.input_name = lexer_token.source_position.input_name; source_position.linenr = start_linenr; - errorf(source_position, "string has no end"); + errorf(&source_position, "string has no end"); lexer_token.type = T_ERROR; return; } @@ -1003,34 +1368,38 @@ static void parse_character_constant(void) eat('\''); - int tc; while(1) { switch(c) { - case '\\': - tc = parse_escape_sequence(); - obstack_1grow(&symbol_obstack, (char) tc); + case '\\': { + utf32 const tc = parse_escape_sequence(); + if (tc >= 0x100) { + warningf(&lexer_token.source_position, + "escape sequence out of range"); + } + obstack_1grow(&symbol_obstack, tc); break; + } MATCH_NEWLINE( parse_error("newline while parsing character constant"); break; ) + case '\'': + next_char(); + goto end_of_char_constant; + case EOF: { source_position_t source_position; source_position.input_name = lexer_token.source_position.input_name; source_position.linenr = start_linenr; - errorf(source_position, "EOF while parsing character constant"); + errorf(&source_position, "EOF while parsing character constant"); lexer_token.type = T_ERROR; return; } - case '\'': - next_char(); - goto end_of_char_constant; - default: - obstack_1grow(&symbol_obstack, (char) c); + grow_symbol(c); next_char(); break; @@ -1041,10 +1410,10 @@ end_of_char_constant:; const size_t size = (size_t)obstack_object_size(&symbol_obstack); const char *const string = obstack_finish(&symbol_obstack); - lexer_token.type = T_CHARS; + lexer_token.type = T_CHARACTER_CONSTANT; lexer_token.v.string.begin = string; lexer_token.v.string.size = size; - lexer_token.datatype = type_int; + lexer_token.datatype = c_mode & _CXX && size == 1 ? type_char : type_int; } /** @@ -1059,7 +1428,10 @@ static void skip_multiline_comment(void) case '/': next_char(); if (c == '*') { - /* TODO: nested comment, warn here */ + /* nested comment, warn here */ + if (warning.comment) { + warningf(&lexer_token.source_position, "'/*' within comment"); + } } break; case '*': @@ -1076,7 +1448,7 @@ static void skip_multiline_comment(void) source_position_t source_position; source_position.input_name = lexer_token.source_position.input_name; source_position.linenr = start_linenr; - errorf(source_position, "at end of file while looking for comment end"); + errorf(&source_position, "at end of file while looking for comment end"); return; } @@ -1101,6 +1473,15 @@ static void skip_line_comment(void) case '\r': return; + case '\\': + next_char(); + if (c == '\n' || c == '\r') { + if (warning.comment) + warningf(&lexer_token.source_position, "multi-line comment"); + return; + } + break; + default: next_char(); break; @@ -1183,7 +1564,7 @@ static void parse_line_directive(void) /** * STDC pragmas. */ -typedef enum { +typedef enum stdc_pragma_kind_t { STDC_UNKNOWN, STDC_FP_CONTRACT, STDC_FENV_ACCESS, @@ -1193,7 +1574,7 @@ typedef enum { /** * STDC pragma values. */ -typedef enum { +typedef enum stdc_pragma_value_kind_t { STDC_VALUE_UNKNOWN, STDC_VALUE_ON, STDC_VALUE_OFF, @@ -1203,7 +1584,8 @@ typedef enum { /** * Parse a pragma directive. */ -static void parse_pragma(void) { +static void parse_pragma(void) +{ bool unknown_pragma = true; next_pp_token(); @@ -1245,7 +1627,7 @@ static void parse_pragma(void) { if (value != STDC_VALUE_UNKNOWN) { unknown_pragma = false; } else { - errorf(pp_token.source_position, "bad STDC pragma argument"); + errorf(&pp_token.source_position, "bad STDC pragma argument"); } } } @@ -1254,7 +1636,7 @@ static void parse_pragma(void) { } eat_until_newline(); if (unknown_pragma && warning.unknown_pragmas) { - warningf(pp_token.source_position, "encountered unknown #pragma"); + warningf(&pp_token.source_position, "encountered unknown #pragma"); } } @@ -1337,7 +1719,7 @@ static void parse_preprocessor_directive(void) #define ELSE_CODE(code) \ default: \ - code; \ + code \ } \ } /* end of while(1) */ \ break; @@ -1389,16 +1771,7 @@ 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': + DIGITS put_back(c); c = '.'; parse_number_dec(); @@ -1454,25 +1827,25 @@ void lexer_next_preprocessing_token(void) ELSE('/') case '%': MAYBE_PROLOG - MAYBE('>', T_PERCENTGREATER) + MAYBE('>', '}') MAYBE('=', T_PERCENTEQUAL) case ':': MAYBE_PROLOG case '%': MAYBE_PROLOG - MAYBE(':', T_PERCENTCOLONPERCENTCOLON) + MAYBE(':', T_HASHHASH) ELSE_CODE( put_back(c); c = '%'; - lexer_token.type = T_PERCENTCOLON; + lexer_token.type = '#'; return; ) - ELSE(T_PERCENTCOLON) + ELSE('#') ELSE('%') case '<': MAYBE_PROLOG - MAYBE(':', T_LESSCOLON) - MAYBE('%', T_LESSPERCENT) + MAYBE(':', '[') + MAYBE('%', '{') MAYBE('=', T_LESSEQUAL) case '<': MAYBE_PROLOG @@ -1498,7 +1871,7 @@ void lexer_next_preprocessing_token(void) ELSE('|') case ':': MAYBE_PROLOG - MAYBE('>', T_COLONGREATER) + MAYBE('>', ']') ELSE(':') case '=': MAYBE_PROLOG @@ -1529,8 +1902,9 @@ void lexer_next_preprocessing_token(void) return; default: +dollar_sign: + errorf(&lexer_token.source_position, "unknown character '%c' found", c); next_char(); - errorf(lexer_token.source_position, "unknown character '%c' found\n", c); lexer_token.type = T_ERROR; return; } @@ -1540,15 +1914,13 @@ void lexer_next_preprocessing_token(void) void lexer_next_token(void) { lexer_next_preprocessing_token(); - if(lexer_token.type != '\n') - return; + while (lexer_token.type == '\n') { newline_found: - do { lexer_next_preprocessing_token(); - } while(lexer_token.type == '\n'); + } - if(lexer_token.type == '#') { + if (lexer_token.type == '#') { parse_preprocessor_directive(); goto newline_found; } @@ -1557,6 +1929,7 @@ newline_found: void init_lexer(void) { strset_init(&stringset); + symbol_L = symbol_table_insert("L"); } void lexer_open_stream(FILE *stream, const char *input_name) @@ -1565,7 +1938,6 @@ void lexer_open_stream(FILE *stream, const char *input_name) lexer_token.source_position.linenr = 0; lexer_token.source_position.input_name = input_name; - symbol_L = symbol_table_insert("L"); bufpos = NULL; bufend = NULL; @@ -1574,6 +1946,26 @@ void lexer_open_stream(FILE *stream, const char *input_name) c = '\n'; } +void lexer_open_buffer(const char *buffer, size_t len, const char *input_name) +{ + input = NULL; + lexer_token.source_position.linenr = 0; + lexer_token.source_position.input_name = input_name; + +#if 0 // TODO + bufpos = buffer; + bufend = buffer + len; +#else + (void)buffer; + (void)len; + panic("builtin lexing not done yet"); +#endif + + /* place a virtual \n at the beginning so the lexer knows that we're + * at the beginning of a line */ + c = '\n'; +} + void exit_lexer(void) { strset_destroy(&stringset);