Adapted cparser to CopyB lowering changes.

[cparser] / token.c

diff --git a/token.c b/token.c
index 47806f1..183a0ca 100644 (file)
--- a/token.c
+++ b/token.c
@@ -36,7 +36,7 @@ const source_position_t builtin_source_position = { "<built-in>", 0, 0 };
 
 static int last_id;
 
-static symbol_t *intern_register_token(token_type_t id, const char *string)
+static symbol_t *intern_register_token(token_kind_t id, const char *string)
 {
        assert(0 <= id && id < T_LAST_TOKEN);
        symbol_t *symbol = symbol_table_insert(string);
@@ -45,7 +45,7 @@ static symbol_t *intern_register_token(token_type_t id, const char *string)
        return symbol;
 }
 
-static symbol_t *intern_register_pp_token(preprocessor_token_type_t id, const char *string)
+static symbol_t *intern_register_pp_token(preprocessor_token_kind_t id, const char *string)
 {
        assert(0 <= id && id < TP_LAST_TOKEN);
        symbol_t *symbol = symbol_table_insert(string);
@@ -54,7 +54,7 @@ static symbol_t *intern_register_pp_token(preprocessor_token_type_t id, const ch
        return symbol;
 }
 
-static void register_token(unsigned mode, token_type_t id, const char *string)
+static void register_token(unsigned mode, token_kind_t id, const char *string)
 {
        if (id > 255) {
                assert(id >= last_id);
@@ -66,7 +66,7 @@ static void register_token(unsigned mode, token_type_t id, const char *string)
        }
 }
 
-static void register_pp_token(unsigned mode, token_type_t id,
+static void register_pp_token(unsigned mode, token_kind_t id,
                               const char *string)
 {
        if (! (c_mode & mode))
@@ -100,38 +100,38 @@ void exit_tokens(void)
 {
 }
 
-void print_token_type(FILE *f, token_type_t token_type)
+void print_token_kind(FILE *f, token_kind_t token_kind)
 {
-       if(token_type == T_EOF) {
+       if(token_kind == T_EOF) {
                fputs("end of file", f);
                return;
        }
-       if(token_type == T_ERROR) {
+       if(token_kind == T_ERROR) {
                fputs("error", f);
                return;
        }
 
        int token_symbols_len = T_LAST_TOKEN;
-       if(token_type < 0 || token_type >= token_symbols_len) {
+       if(token_kind < 0 || token_kind >= token_symbols_len) {
                fputs("invalid token", f);
                return;
        }
 
-       const symbol_t *symbol = token_symbols[token_type];
+       const symbol_t *symbol = token_symbols[token_kind];
        if(symbol != NULL) {
                fputs(symbol->string, f);
        } else {
-               if(token_type >= 0 && token_type < 256) {
-                       fputc(token_type, f);
+               if(token_kind >= 0 && token_kind < 256) {
+                       fputc(token_kind, f);
                        return;
                }
                fputs("unknown token", f);
        }
 }
 
-symbol_t *get_token_symbol(const token_t *token)
+symbol_t *get_token_kind_symbol(int kind)
 {
-       return token_symbols[token->type];
+       return token_symbols[kind];
 }
 
 static void print_stringrep(const string_t *string, FILE *f)
@@ -143,65 +143,65 @@ static void print_stringrep(const string_t *string, FILE *f)
 
 void print_token(FILE *f, const token_t *token)
 {
-       switch(token->type) {
+       switch(token->kind) {
        case T_IDENTIFIER:
-               fprintf(f, "identifier '%s'", token->symbol->string);
+               fprintf(f, "identifier '%s'", token->identifier.symbol->string);
                break;
        case T_INTEGER:
        case T_INTEGER_OCTAL:
        case T_INTEGER_HEXADECIMAL:
        case T_FLOATINGPOINT:
        case T_FLOATINGPOINT_HEXADECIMAL:
-               print_token_type(f, (token_type_t)token->type);
+               print_token_kind(f, (token_kind_t)token->kind);
                fputs(" '", f);
-               print_stringrep(&token->literal, f);
-               if (token->symbol != NULL)
-                       fputs(token->symbol->string, f);
+               print_stringrep(&token->number.number, f);
+               if (token->number.suffix.size > 0)
+                       print_stringrep(&token->number.suffix, f);
                fputc('\'', f);
                break;
        case T_WIDE_STRING_LITERAL:
        case T_STRING_LITERAL:
-               print_token_type(f, (token_type_t)token->type);
-               fprintf(f, " \"%s\"", token->literal.begin);
+               print_token_kind(f, (token_kind_t)token->kind);
+               fprintf(f, " \"%s\"", token->string.string.begin);
                break;
        case T_CHARACTER_CONSTANT:
        case T_WIDE_CHARACTER_CONSTANT:
-               print_token_type(f, (token_type_t)token->type);
+               print_token_kind(f, (token_kind_t)token->kind);
                fputs(" \'", f);
-               print_stringrep(&token->literal, f);
+               print_stringrep(&token->string.string, f);
                fputs("'", f);
                break;
        default:
                fputc('\'', f);
-               print_token_type(f, (token_type_t)token->type);
+               print_token_kind(f, (token_kind_t)token->kind);
                fputc('\'', f);
                break;
        }
 }
 
-void print_pp_token_type(FILE *f, int token_type)
+void print_pp_token_kind(FILE *f, int token_kind)
 {
-       if (token_type == TP_EOF) {
+       if (token_kind == TP_EOF) {
                fputs("end of file", f);
                return;
        }
-       if (token_type == TP_ERROR) {
+       if (token_kind == TP_ERROR) {
                fputs("error", f);
                return;
        }
 
        int token_symbols_len = TP_LAST_TOKEN;
-       if (token_type < 0 || token_type >= token_symbols_len) {
+       if (token_kind < 0 || token_kind >= token_symbols_len) {
                fputs("invalid token", f);
                return;
        }
 
-       const symbol_t *symbol = pp_token_symbols[token_type];
+       const symbol_t *symbol = pp_token_symbols[token_kind];
        if (symbol != NULL) {
                fputs(symbol->string, f);
        } else {
-               if(token_type >= 0 && token_type < 256) {
-                       fputc(token_type, f);
+               if(token_kind >= 0 && token_kind < 256) {
+                       fputc(token_kind, f);
                        return;
                }
                fputs("unknown token", f);
@@ -210,24 +210,24 @@ void print_pp_token_type(FILE *f, int token_type)
 
 void print_pp_token(FILE *f, const token_t *token)
 {
-       switch((preprocessor_token_type_t) token->type) {
+       switch((preprocessor_token_kind_t) token->kind) {
        case TP_IDENTIFIER:
-               fprintf(f, "identifier '%s'", token->symbol->string);
+               fprintf(f, "identifier '%s'", token->identifier.symbol->string);
                break;
        case TP_NUMBER:
-               fprintf(f, "number '%s'", token->literal.begin);
+               fprintf(f, "number '%s'", token->number.number.begin);
                break;
        case TP_STRING_LITERAL:
-               fprintf(f, "string \"%s\"", token->literal.begin);
+               fprintf(f, "string \"%s\"", token->string.string.begin);
                break;
        default:
-               print_pp_token_type(f, (preprocessor_token_type_t) token->type);
+               print_pp_token_kind(f, (preprocessor_token_kind_t) token->kind);
                break;
        }
 }
 
-bool tokens_would_paste(preprocessor_token_type_t token1,
-                        preprocessor_token_type_t token2)
+bool tokens_would_paste(preprocessor_token_kind_t token1,
+                        preprocessor_token_kind_t token2)
 {
        char c = token2 < 256 ? (char) token2 : pp_token_symbols[token2]->string[0];