Only push an enum into the environment, if it has a name.

[cparser] / lexer.c

diff --git a/lexer.c b/lexer.c
index 525bb85..6a6a945 100644 (file)
--- a/lexer.c
+++ b/lexer.c
@@ -1,11 +1,13 @@
 #include <config.h>
 
+#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"
@@ -41,16 +43,6 @@ static const char *bufend;
 static const char *bufpos;
 static strset_t    stringset;
 
-static type_t     *type_int        = NULL;
-static type_t     *type_uint       = NULL;
-static type_t     *type_long       = NULL;
-static type_t     *type_ulong      = NULL;
-static type_t     *type_longlong   = NULL;
-static type_t     *type_ulonglong  = NULL;
-static type_t     *type_float      = NULL;
-static type_t     *type_double     = NULL;
-static type_t     *type_longdouble = NULL;
-
 static void error_prefix_at(const char *input_name, unsigned linenr)
 {
        fprintf(stderr, "%s:%u: Error: ", input_name, linenr);
@@ -70,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) {
@@ -81,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 = (char) 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);
@@ -165,8 +150,8 @@ static inline void next_char(void)
        case '>': c = '}'; break;
        case '-': c = '~'; break;
        default:
-               put_back('?');
                put_back(c);
+               put_back('?');
                c = '?';
                break;
        }
@@ -309,7 +294,7 @@ static void parse_integer_suffix(bool is_oct_hex)
                } else if(c == 'u' || c == 'U') {
                        is_unsigned = true;
                        next_char();
-                       lexer_token.datatype = type_ulong;
+                       lexer_token.datatype = type_unsigned_long;
                }
        }
 
@@ -320,7 +305,7 @@ static void parse_integer_suffix(bool is_oct_hex)
                                lexer_token.datatype = type_int;
                                return;
                        } else if(is_oct_hex && v >= 0 && v <= TARGET_UINT_MAX) {
-                               lexer_token.datatype = type_uint;
+                               lexer_token.datatype = type_unsigned_int;
                                return;
                        }
                }
@@ -329,28 +314,28 @@ static void parse_integer_suffix(bool is_oct_hex)
                                lexer_token.datatype = type_long;
                                return;
                        } else if(is_oct_hex && v >= 0 && v <= TARGET_ULONG_MAX) {
-                               lexer_token.datatype = type_ulong;
+                               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_ulonglong;
+                       lexer_token.datatype = type_unsigned_long_long;
                        return;
                }
 
-               lexer_token.datatype = type_longlong;
+               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_uint;
+                       lexer_token.datatype = type_unsigned_int;
                        return;
                }
                if(!min_longlong && v <= TARGET_ULONG_MAX) {
-                       lexer_token.datatype = type_ulong;
+                       lexer_token.datatype = type_unsigned_long;
                        return;
                }
-               lexer_token.datatype = type_ulonglong;
+               lexer_token.datatype = type_unsigned_long_long;
        }
 }
 
@@ -366,7 +351,7 @@ static void parse_floating_suffix(void)
        case 'l':
        case 'L':
                next_char();
-               lexer_token.datatype = type_longdouble;
+               lexer_token.datatype = type_long_double;
                break;
        default:
                lexer_token.datatype = type_double;
@@ -1044,6 +1029,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;
        }
 }
@@ -1131,6 +1118,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)
@@ -1285,21 +1287,6 @@ newline_found:
 void init_lexer(void)
 {
        strset_init(&stringset);
-
-       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_NONE);
-       type_ulonglong = make_atomic_type(ATOMIC_TYPE_ULONGLONG,
-                                         TYPE_QUALIFIER_NONE);
-
-       type_float      = make_atomic_type(ATOMIC_TYPE_FLOAT, TYPE_QUALIFIER_CONST);
-       type_double     = make_atomic_type(ATOMIC_TYPE_DOUBLE,
-                                          TYPE_QUALIFIER_CONST);
-       type_longdouble = make_atomic_type(ATOMIC_TYPE_LONG_DOUBLE,
-                                          TYPE_QUALIFIER_CONST);
 }
 
 void lexer_open_stream(FILE *stream, const char *input_name)
@@ -1309,6 +1296,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 */