add space after if, improve while_statement_to_firm

[cparser] / lexer.c

diff --git a/lexer.c b/lexer.c
index b4d5000..faecfe3 100644 (file)
--- a/lexer.c
+++ b/lexer.c
@@ -21,6 +21,7 @@
 
 #include "diagnostic.h"
 #include "lexer.h"
+#include "symbol_t.h"
 #include "token_t.h"
 #include "symbol_table_t.h"
 #include "adt/error.h"
@@ -63,7 +64,17 @@ 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 inline void next_real_char(void)
@@ -332,7 +343,7 @@ static void parse_integer_suffix(bool is_oct_hex)
                        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;
                        }
@@ -480,7 +491,7 @@ static void parse_number_hex(void)
 
        if(c == '.' || c == 'p' || c == 'P') {
                next_char();
-               panic("Hex floating point numbers not implemented yet");
+               internal_error("Hex floating point numbers not implemented yet");
        }
        if(*string == '\0') {
                parse_error("invalid hex number");
@@ -678,7 +689,7 @@ static int digit_value(int digit) {
        case 'f':
        case 'F': return 15;
        default:
-               panic("wrong character given");
+               internal_error("wrong character given");
        }
 }
 
@@ -861,7 +872,7 @@ static void parse_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;
                }
@@ -906,14 +917,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");
@@ -924,28 +938,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;
 }
 
 /**
@@ -970,7 +990,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;
                }
@@ -1022,32 +1042,32 @@ static void parse_character_constant(void)
 
        eat('\'');
 
-       int tc;
        while(1) {
                switch(c) {
-               case '\\':
-                       tc = parse_escape_sequence();
+               case '\\': {
+                       int tc = parse_escape_sequence();
                        obstack_1grow(&symbol_obstack, (char) 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);
                        next_char();
@@ -1060,7 +1080,7 @@ 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;
@@ -1095,7 +1115,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;
                }
 
@@ -1264,7 +1284,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");
                                }
                        }
                }
@@ -1273,7 +1293,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");
        }
 }
 
@@ -1356,7 +1376,7 @@ static void parse_preprocessor_directive(void)
 
 #define ELSE_CODE(code)                                    \
                                default:                                   \
-                                       code;                                  \
+                                       code                                   \
                                }                                          \
                        } /* end of while(1) */                        \
                        break;
@@ -1473,25 +1493,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
@@ -1517,7 +1537,7 @@ void lexer_next_preprocessing_token(void)
                        ELSE('|')
                case ':':
                        MAYBE_PROLOG
-                       MAYBE('>', T_COLONGREATER)
+                       MAYBE('>', ']')
                        ELSE(':')
                case '=':
                        MAYBE_PROLOG
@@ -1549,7 +1569,7 @@ void lexer_next_preprocessing_token(void)
 
                default:
                        next_char();
-                       errorf(lexer_token.source_position, "unknown character '%c' found\n", c);
+                       errorf(&lexer_token.source_position, "unknown character '%c' found\n", c);
                        lexer_token.type = T_ERROR;
                        return;
                }