implement K&R style function definitions, code cleanup here and there

[cparser] / lexer.c

diff --git a/lexer.c b/lexer.c
index 9fa306d..38473a2 100644 (file)
--- 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 <assert.h>
 #include <errno.h>
@@ -22,6 +23,14 @@
 #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;
@@ -80,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 */
@@ -239,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;
 
@@ -269,39 +278,78 @@ end_symbol:
        }
 }
 
-static void parse_integer_suffix(void)
+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;
                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;
        }
 }
 
@@ -336,7 +384,7 @@ static unsigned long long parse_int_string(const char *s, const char **endptr, i
        case 16:
                for (;; ++s) {
                        /* check for overrun */
-                       if (v <= 0x1000000000000000ULL)
+                       if (v >= 0x1000000000000000ULL)
                                break;
                        switch (tolower(*s)) {
                        case '0': v <<= 4; break;
@@ -363,7 +411,7 @@ static unsigned long long parse_int_string(const char *s, const char **endptr, i
        case 8:
                for (;; ++s) {
                        /* check for overrun */
-                       if (v <= 0x2000000000000000ULL)
+                       if (v >= 0x2000000000000000ULL)
                                break;
                        switch (tolower(*s)) {
                        case '0': v <<= 3; break;
@@ -415,7 +463,7 @@ static void parse_number_hex(void)
        next_char();
 
        while(isxdigit(c)) {
-               obstack_1grow(&symbol_obstack, c);
+               obstack_1grow(&symbol_obstack, (char) c);
                next_char();
        }
        obstack_1grow(&symbol_obstack, '\0');
@@ -438,7 +486,7 @@ static void parse_number_hex(void)
        }
 
        obstack_free(&symbol_obstack, string);
-       parse_integer_suffix();
+       parse_integer_suffix(true);
 }
 
 static inline bool is_octal_digit(int chr)
@@ -449,7 +497,7 @@ 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');
@@ -463,14 +511,14 @@ static void parse_number_oct(void)
        }
 
        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();
        }
 
@@ -479,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;
@@ -489,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;
@@ -503,8 +551,8 @@ static void parse_number_dec(void)
        obstack_1grow(&symbol_obstack, '\0');
        char *string = obstack_finish(&symbol_obstack);
 
-       const char *endptr;
        if(is_float) {
+               char *endptr;
                lexer_token.type         = T_FLOATINGPOINT;
                lexer_token.v.floatvalue = strtold(string, &endptr);
 
@@ -514,6 +562,7 @@ static void parse_number_dec(void)
 
                parse_floating_suffix();
        } else {
+               const char *endptr;
                lexer_token.type       = T_INTEGER;
                lexer_token.v.intvalue = parse_int_string(string, &endptr, 10);
 
@@ -521,7 +570,7 @@ static void parse_number_dec(void)
                        parse_error("invalid number literal");
                }
 
-               parse_integer_suffix();
+               parse_integer_suffix(false);
        }
        obstack_free(&symbol_obstack, string);
 }
@@ -574,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)
@@ -593,7 +642,7 @@ static int parse_hex_sequence(void)
                next_char();
        }
 
-       return value;
+       return (char_type)value;
 }
 
 static int parse_escape_sequence(void)
@@ -666,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:
@@ -681,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;
                }
@@ -1128,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,
@@ -1165,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);
 }