rename the statement_base_t statement to base in the statement structs

[r18779]

diff --git a/TODO b/TODO
index e59ee95..6aca31e 100644 (file)
--- a/TODO
+++ b/TODO
@@ -1,7 +1,6 @@
 Refactoring:
-- Rename type_string to type_char_ptr
-- Rename the statement_base_t statement; field in all the statements to
-  statement_base_t base;
+- create an empty_statement_t and use that instead of a NULL pointer in places
+  like if, loop bodys, statements after labels
 
 Lexer:
 - Add preprocessor code

diff --git a/ast.c b/ast.c
index c3d014e..e5d7362 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -487,8 +487,8 @@ static void print_compound_statement(const compound_statement_t *block)
 static void print_return_statement(const return_statement_t *statement)
 {
        fprintf(out, "return ");
-       if(statement->return_value != NULL)
-               print_expression(statement->return_value);
+       if(statement->value != NULL)
+               print_expression(statement->value);
        fputs(";\n", out);
 }
 
@@ -510,8 +510,8 @@ static void print_label_statement(const label_statement_t *statement)
 {
        fprintf(stderr, "(%p)", (void*) statement->label);
        fprintf(out, "%s:\n", statement->label->symbol->string);
-       if(statement->label_statement != NULL) {
-               print_statement(statement->label_statement);
+       if(statement->statement != NULL) {
+               print_statement(statement->statement);
        }
 }
 
@@ -548,7 +548,9 @@ static void print_case_label(const case_label_statement_t *statement)
                print_expression(statement->expression);
                fputs(":\n", out);
        }
-       print_statement(statement->label_statement);
+       if(statement->statement != NULL) {
+               print_statement(statement->statement);
+       }
 }
 
 static void print_declaration_statement(

diff --git a/ast2firm.c b/ast2firm.c
index 0ea5a4a..fb3d734 100644 (file)
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -3031,17 +3031,17 @@ static void return_statement_to_firm(return_statement_t *statement)
        if(get_cur_block() == NULL)
                return;
 
-       ir_type *func_irtype = get_ir_type(current_function_decl->type);
+       dbg_info *dbgi        = get_dbg_info(&statement->base.source_position);
+       ir_type  *func_irtype = get_ir_type(current_function_decl->type);
 
-       dbg_info *dbgi  = get_dbg_info(&statement->statement.source_position);
 
        ir_node *in[1];
        int      in_len;
        if(get_method_n_ress(func_irtype) > 0) {
                ir_type *res_type = get_method_res_type(func_irtype, 0);
 
-               if(statement->return_value != NULL) {
-                       ir_node *node = expression_to_firm(statement->return_value);
+               if(statement->value != NULL) {
+                       ir_node *node = expression_to_firm(statement->value);
                        node  = do_strict_conv(dbgi, node);
                        in[0] = node;
                } else {
@@ -3056,8 +3056,8 @@ static void return_statement_to_firm(return_statement_t *statement)
                in_len = 1;
        } else {
                /* build return_value for its side effects */
-               if(statement->return_value != NULL) {
-                       expression_to_firm(statement->return_value);
+               if(statement->value != NULL) {
+                       expression_to_firm(statement->value);
                }
                in_len = 0;
        }
@@ -3388,7 +3388,7 @@ static void create_jump_statement(const statement_t *statement,
 
 static void switch_statement_to_firm(const switch_statement_t *statement)
 {
-       dbg_info *dbgi = get_dbg_info(&statement->statement.source_position);
+       dbg_info *dbgi = get_dbg_info(&statement->base.source_position);
 
        ir_node *expression  = expression_to_firm(statement->expression);
        ir_node *cond        = new_d_Cond(dbgi, expression);
@@ -3430,7 +3430,7 @@ static void switch_statement_to_firm(const switch_statement_t *statement)
 
 static void case_label_to_firm(const case_label_statement_t *statement)
 {
-       dbg_info *dbgi = get_dbg_info(&statement->statement.source_position);
+       dbg_info *dbgi = get_dbg_info(&statement->base.source_position);
 
        ir_node *const fallthrough = (get_cur_block() == NULL ? NULL : new_Jmp());
 
@@ -3458,8 +3458,8 @@ static void case_label_to_firm(const case_label_statement_t *statement)
        add_immBlock_pred(block, proj);
        mature_immBlock(block);
 
-       if(statement->label_statement != NULL) {
-               statement_to_firm(statement->label_statement);
+       if(statement->statement != NULL) {
+               statement_to_firm(statement->statement);
        }
 }
 
@@ -3496,8 +3496,8 @@ static void label_to_firm(const label_statement_t *statement)
        set_cur_block(block);
        keep_alive(block);
 
-       if(statement->label_statement != NULL) {
-               statement_to_firm(statement->label_statement);
+       if(statement->statement != NULL) {
+               statement_to_firm(statement->statement);
        }
 }
 
@@ -3746,7 +3746,9 @@ static int count_decls_in_stmts(const statement_t *stmt)
 
                        case STATEMENT_LABEL: {
                                const label_statement_t *const label_stmt = &stmt->label;
-                               count += count_decls_in_stmts(label_stmt->label_statement);
+                               if(label_stmt->statement != NULL) {
+                                       count += count_decls_in_stmts(label_stmt->statement);
+                               }
                                break;
                        }
 
@@ -3777,7 +3779,9 @@ static int count_decls_in_stmts(const statement_t *stmt)
                        case STATEMENT_CASE_LABEL: {
                                const case_label_statement_t *label = &stmt->case_label;
                                count += count_decls_in_expression(label->expression);
-                               count += count_decls_in_stmts(label->label_statement);
+                               if(label->statement != NULL) {
+                                       count += count_decls_in_stmts(label->statement);
+                               }
                                break;
                        }
 
@@ -3798,7 +3802,7 @@ static int count_decls_in_stmts(const statement_t *stmt)
 
                        case STATEMENT_RETURN: {
                                const return_statement_t *ret_stmt = &stmt->returns;
-                               count += count_decls_in_expression(ret_stmt->return_value);
+                               count += count_decls_in_expression(ret_stmt->value);
                                break;
                        }
                }

diff --git a/ast_t.h b/ast_t.h
index 0e56928..1debd43 100644 (file)
--- a/ast_t.h
+++ b/ast_t.h
@@ -408,8 +408,6 @@ struct declaration_t {
        declaration_t      *next;
        /** next declaration with same symbol */
        declaration_t      *symbol_next;
-       /** next variable/parameter in function scope/global scope */
-       declaration_t      *next_var;
 
        /* the following fields are used in ast2firm module */
        unsigned char       declaration_kind;
@@ -447,75 +445,75 @@ struct statement_base_t {
 };
 
 struct return_statement_t {
-       statement_base_t  statement;
-       expression_t     *return_value;
+       statement_base_t  base;
+       expression_t     *value;
 };
 
 struct compound_statement_t {
-       statement_base_t  statement;
+       statement_base_t  base;
        statement_t      *statements;
        scope_t           scope;
 };
 
 struct declaration_statement_t {
-       statement_base_t  statement;
+       statement_base_t  base;
        declaration_t    *declarations_begin;
        declaration_t    *declarations_end;
 };
 
 struct if_statement_t {
-       statement_base_t  statement;
+       statement_base_t  base;
        expression_t     *condition;
        statement_t      *true_statement;
        statement_t      *false_statement;
 };
 
 struct switch_statement_t {
-       statement_base_t       statement;
+       statement_base_t       base;
        expression_t           *expression;
        statement_t            *body;
        case_label_statement_t *first_case, *last_case;
 };
 
 struct goto_statement_t {
-       statement_base_t  statement;
+       statement_base_t  base;
        declaration_t    *label;     /**< The destination label. */
        goto_statement_t *next;      /**< links all goto statements of a function */
 };
 
 struct case_label_statement_t {
-       statement_base_t        statement;
+       statement_base_t        base;
        expression_t           *expression;
-       statement_t            *label_statement;
-       case_label_statement_t *next; /**< link to the next case label in the switch */
+       statement_t            *statement;
+       case_label_statement_t *next; /**< link to the next case label in switch */
 };
 
 struct label_statement_t {
-       statement_base_t   statement;
+       statement_base_t   base;
        declaration_t     *label;
-       statement_t       *label_statement;
-       label_statement_t *next;            /**< links all label statements of a function */
+       statement_t       *statement;
+       label_statement_t *next;    /**< links all label statements of a function */
 };
 
 struct expression_statement_t {
-       statement_base_t  statement;
+       statement_base_t  base;
        expression_t     *expression;
 };
 
 struct while_statement_t {
-       statement_base_t  statement;
+       statement_base_t  base;
        expression_t     *condition;
        statement_t      *body;
 };
 
 struct do_while_statement_t {
-       statement_base_t  statement;
+       statement_base_t  base;
        expression_t     *condition;
        statement_t      *body;
 };
 
 struct for_statement_t {
-       statement_base_t  statement;
+       statement_base_t  base;
        expression_t     *initialisation;
        expression_t     *condition;
        expression_t     *step;
@@ -536,7 +534,7 @@ struct asm_clobber_t {
 };
 
 struct asm_statement_t {
-       statement_base_t  statement;
+       statement_base_t  base;
        string_t          asm_text;
        asm_constraint_t *inputs;
        asm_constraint_t *outputs;

diff --git a/format_check.c b/format_check.c
index 961381f..4fad47a 100644 (file)
--- a/format_check.c
+++ b/format_check.c
@@ -314,7 +314,7 @@ eval_fmt_mod_unsigned:
 
                        case 's':
                                switch (fmt_mod) {
-                                       case FMT_MOD_NONE: expected_type = type_string;      break;
+                                       case FMT_MOD_NONE: expected_type = type_char_ptr;    break;
                                        case FMT_MOD_l:    expected_type = type_wchar_t_ptr; break;
 
                                        default:

diff --git a/parser.c b/parser.c
index d0d3ddb..43a2d87 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -2744,8 +2744,8 @@ static void check_labels(void)
                label->used = true;
                if (label->source_position.input_name == NULL) {
                        print_in_function();
-                       errorf(goto_statement->statement.source_position,
-                               "label '%Y' used but not defined", label->symbol);
+                       errorf(goto_statement->base.source_position,
+                              "label '%Y' used but not defined", label->symbol);
                 }
        }
        goto_first = goto_last = NULL;
@@ -2758,7 +2758,7 @@ static void check_labels(void)
 
                        if (! label->used) {
                                print_in_function();
-                               warningf(label_statement->statement.source_position,
+                               warningf(label_statement->base.source_position,
                                        "label '%Y' defined but not used", label->symbol);
                        }
                }
@@ -3023,7 +3023,7 @@ static expression_t *expected_expression_error(void)
 static expression_t *parse_string_const(void)
 {
        expression_t *cnst = allocate_expression_zero(EXPR_STRING_LITERAL);
-       cnst->base.type    = type_string;
+       cnst->base.type    = type_char_ptr;
        cnst->string.value = parse_string_literals();
 
        return cnst;
@@ -3139,11 +3139,11 @@ static type_t *get_builtin_symbol_type(symbol_t *symbol)
        case T___builtin_alloca:
                return make_function_1_type(type_void_ptr, type_size_t);
        case T___builtin_nan:
-               return make_function_1_type(type_double, type_string);
+               return make_function_1_type(type_double, type_char_ptr);
        case T___builtin_nanf:
-               return make_function_1_type(type_float, type_string);
+               return make_function_1_type(type_float, type_char_ptr);
        case T___builtin_nand:
-               return make_function_1_type(type_long_double, type_string);
+               return make_function_1_type(type_long_double, type_char_ptr);
        case T___builtin_va_end:
                return make_function_1_type(type_void, type_valist);
        default:
@@ -3340,7 +3340,7 @@ static expression_t *parse_function_keyword(void)
        }
 
        expression_t *expression = allocate_expression_zero(EXPR_FUNCTION);
-       expression->base.type    = type_string;
+       expression->base.type    = type_char_ptr;
 
        return expression;
 }
@@ -3355,7 +3355,7 @@ static expression_t *parse_pretty_function_keyword(void)
        }
 
        expression_t *expression = allocate_expression_zero(EXPR_PRETTY_FUNCTION);
-       expression->base.type    = type_string;
+       expression->base.type    = type_char_ptr;
 
        return expression;
 }
@@ -5038,7 +5038,7 @@ static statement_t *parse_case_statement(void)
                                "case label not within a switch statement");
                }
        }
-       statement->case_label.label_statement = parse_statement();
+       statement->case_label.statement = parse_statement();
 
        return statement;
 }
@@ -5074,7 +5074,7 @@ static statement_t *parse_default_statement(void)
                const case_label_statement_t *def_label = find_default_label(current_switch);
                if (def_label != NULL) {
                        errorf(HERE, "multiple default labels in one switch");
-                       errorf(def_label->statement.source_position,
+                       errorf(def_label->base.source_position,
                                "this is the first default label");
                } else {
                        /* link all cases into the switch statement */
@@ -5089,7 +5089,7 @@ static statement_t *parse_default_statement(void)
                errorf(statement->base.source_position,
                        "'default' label not within a switch statement");
        }
-       statement->label.label_statement = parse_statement();
+       statement->label.statement = parse_statement();
 
        return statement;
 }
@@ -5139,18 +5139,17 @@ static statement_t *parse_label_statement(void)
                label->source_position = token.source_position;
        }
 
-       label_statement_t *label_statement = allocate_ast_zero(sizeof(label[0]));
+       statement_t *statement = allocate_statement_zero(STATEMENT_LABEL);
 
-       label_statement->statement.kind            = STATEMENT_LABEL;
-       label_statement->statement.source_position = token.source_position;
-       label_statement->label                     = label;
+       statement->base.source_position = token.source_position;
+       statement->label.label          = label;
 
        eat(':');
 
        if(token.type == '}') {
                /* TODO only warn? */
                errorf(HERE, "label at end of compound statement");
-               return (statement_t*) label_statement;
+               return statement;
        } else {
                if (token.type == ';') {
                        /* eat an empty statement here, to avoid the warning about an empty
@@ -5158,19 +5157,19 @@ static statement_t *parse_label_statement(void)
                         * a }. */
                        next_token();
                } else {
-                       label_statement->label_statement = parse_statement();
+                       statement->label.statement = parse_statement();
                }
        }
 
        /* remember the labels's in a list for later checking */
        if (label_last == NULL) {
-               label_first = label_statement;
+               label_first = &statement->label;
        } else {
-               label_last->next = label_statement;
+               label_last->next = &statement->label;
        }
-       label_last = label_statement;
+       label_last = &statement->label;
 
-       return (statement_t*) label_statement;
+       return statement;
 }
 
 /**
@@ -5180,21 +5179,20 @@ static statement_t *parse_if(void)
 {
        eat(T_if);
 
-       if_statement_t *statement = allocate_ast_zero(sizeof(statement[0]));
-       statement->statement.kind            = STATEMENT_IF;
-       statement->statement.source_position = token.source_position;
+       statement_t *statement          = allocate_statement_zero(STATEMENT_IF);
+       statement->base.source_position = token.source_position;
 
        expect('(');
-       statement->condition = parse_expression();
+       statement->ifs.condition = parse_expression();
        expect(')');
 
-       statement->true_statement = parse_statement();
+       statement->ifs.true_statement = parse_statement();
        if(token.type == T_else) {
                next_token();
-               statement->false_statement = parse_statement();
+               statement->ifs.false_statement = parse_statement();
        }
 
-       return (statement_t*) statement;
+       return statement;
 }
 
 /**
@@ -5204,9 +5202,8 @@ static statement_t *parse_switch(void)
 {
        eat(T_switch);
 
-       switch_statement_t *statement = allocate_ast_zero(sizeof(statement[0]));
-       statement->statement.kind            = STATEMENT_SWITCH;
-       statement->statement.source_position = token.source_position;
+       statement_t *statement          = allocate_statement_zero(STATEMENT_SWITCH);
+       statement->base.source_position = token.source_position;
 
        expect('(');
        expression_t *const expr = parse_expression();
@@ -5214,29 +5211,33 @@ static statement_t *parse_switch(void)
        if (is_type_integer(type)) {
                type = promote_integer(type);
        } else if (is_type_valid(type)) {
-               errorf(expr->base.source_position, "switch quantity is not an integer, but '%T'", type);
+               errorf(expr->base.source_position,
+                      "switch quantity is not an integer, but '%T'", type);
                type = type_error_type;
        }
-       statement->expression = create_implicit_cast(expr, type);
+       statement->switchs.expression = create_implicit_cast(expr, type);
        expect(')');
 
        switch_statement_t *rem = current_switch;
-       current_switch  = statement;
-       statement->body = parse_statement();
-       current_switch  = rem;
+       current_switch          = &statement->switchs;
+       statement->switchs.body = parse_statement();
+       current_switch          = rem;
 
-       if (warning.switch_default && find_default_label(statement) == NULL) {
-               warningf(statement->statement.source_position, "switch has no default case");
+       if (warning.switch_default
+                       && find_default_label(&statement->switchs) == NULL) {
+               warningf(statement->base.source_position, "switch has no default case");
        }
 
-       return (statement_t*) statement;
+       return statement;
 }
 
 static statement_t *parse_loop_body(statement_t *const loop)
 {
        statement_t *const rem = current_loop;
        current_loop = loop;
+
        statement_t *const body = parse_statement();
+
        current_loop = rem;
        return body;
 }
@@ -5248,17 +5249,16 @@ static statement_t *parse_while(void)
 {
        eat(T_while);
 
-       while_statement_t *statement = allocate_ast_zero(sizeof(statement[0]));
-       statement->statement.kind            = STATEMENT_WHILE;
-       statement->statement.source_position = token.source_position;
+       statement_t *statement          = allocate_statement_zero(STATEMENT_WHILE);
+       statement->base.source_position = token.source_position;
 
        expect('(');
-       statement->condition = parse_expression();
+       statement->whiles.condition = parse_expression();
        expect(')');
 
-       statement->body = parse_loop_body((statement_t*)statement);
+       statement->whiles.body = parse_loop_body(statement);
 
-       return (statement_t*) statement;
+       return statement;
 }
 
 /**
@@ -5268,18 +5268,19 @@ static statement_t *parse_do(void)
 {
        eat(T_do);
 
-       do_while_statement_t *statement = allocate_ast_zero(sizeof(statement[0]));
-       statement->statement.kind            = STATEMENT_DO_WHILE;
-       statement->statement.source_position = token.source_position;
+       statement_t *statement = allocate_statement_zero(STATEMENT_DO_WHILE);
+
+       statement->base.source_position = token.source_position;
+
+       statement->do_while.body = parse_loop_body(statement);
 
-       statement->body = parse_loop_body((statement_t*)statement);
        expect(T_while);
        expect('(');
-       statement->condition = parse_expression();
+       statement->do_while.condition = parse_expression();
        expect(')');
        expect(';');
 
-       return (statement_t*) statement;
+       return statement;
 }
 
 /**
@@ -5289,21 +5290,20 @@ static statement_t *parse_for(void)
 {
        eat(T_for);
 
-       for_statement_t *statement = allocate_ast_zero(sizeof(statement[0]));
-       statement->statement.kind            = STATEMENT_FOR;
-       statement->statement.source_position = token.source_position;
+       statement_t *statement          = allocate_statement_zero(STATEMENT_FOR);
+       statement->base.source_position = token.source_position;
 
        expect('(');
 
        int      top        = environment_top();
        scope_t *last_scope = scope;
-       set_scope(&statement->scope);
+       set_scope(&statement->fors.scope);
 
        if(token.type != ';') {
                if(is_declaration_specifier(&token, false)) {
                        parse_declaration(record_declaration);
                } else {
-                       statement->initialisation = parse_expression();
+                       statement->fors.initialisation = parse_expression();
                        expect(';');
                }
        } else {
@@ -5311,20 +5311,20 @@ static statement_t *parse_for(void)
        }
 
        if(token.type != ';') {
-               statement->condition = parse_expression();
+               statement->fors.condition = parse_expression();
        }
        expect(';');
        if(token.type != ')') {
-               statement->step = parse_expression();
+               statement->fors.step = parse_expression();
        }
        expect(')');
-       statement->body = parse_loop_body((statement_t*)statement);
+       statement->fors.body = parse_loop_body(statement);
 
-       assert(scope == &statement->scope);
+       assert(scope == &statement->fors.scope);
        set_scope(last_scope);
        environment_pop_to(top);
 
-       return (statement_t*) statement;
+       return statement;
 }
 
 /**
@@ -5344,24 +5344,22 @@ static statement_t *parse_goto(void)
 
        declaration_t *label = get_label(symbol);
 
-       goto_statement_t *statement = allocate_ast_zero(sizeof(statement[0]));
-
-       statement->statement.kind            = STATEMENT_GOTO;
-       statement->statement.source_position = token.source_position;
+       statement_t *statement          = allocate_statement_zero(STATEMENT_GOTO);
+       statement->base.source_position = token.source_position;
 
-       statement->label = label;
+       statement->gotos.label = label;
 
        /* remember the goto's in a list for later checking */
        if (goto_last == NULL) {
-               goto_first = statement;
+               goto_first = &statement->gotos;
        } else {
-               goto_last->next = statement;
+               goto_last->next = &statement->gotos;
        }
-       goto_last = statement;
+       goto_last = &statement->gotos;
 
        expect(';');
 
-       return (statement_t*) statement;
+       return statement;
 }
 
 /**
@@ -5485,10 +5483,8 @@ static statement_t *parse_return(void)
 {
        eat(T_return);
 
-       return_statement_t *statement = allocate_ast_zero(sizeof(statement[0]));
-
-       statement->statement.kind            = STATEMENT_RETURN;
-       statement->statement.source_position = token.source_position;
+       statement_t *statement          = allocate_statement_zero(STATEMENT_RETURN);
+       statement->base.source_position = token.source_position;
 
        expression_t *return_value = NULL;
        if(token.type != ';') {
@@ -5505,16 +5501,16 @@ static statement_t *parse_return(void)
 
                if(is_type_atomic(return_type, ATOMIC_TYPE_VOID)
                                && !is_type_atomic(return_value_type, ATOMIC_TYPE_VOID)) {
-                       warningf(statement->statement.source_position,
-                               "'return' with a value, in function returning void");
+                       warningf(statement->base.source_position,
+                                "'return' with a value, in function returning void");
                        return_value = NULL;
                } else {
                        type_t *const res_type = semantic_assign(return_type,
                                return_value, "'return'");
                        if (res_type == NULL) {
-                               errorf(statement->statement.source_position,
-                                       "cannot return something of type '%T' in function returning '%T'",
-                                       return_value->base.type, return_type);
+                               errorf(statement->base.source_position,
+                                      "cannot return something of type '%T' in function returning '%T'",
+                                      return_value->base.type, return_type);
                        } else {
                                return_value = create_implicit_cast(return_value, res_type);
                        }
@@ -5523,19 +5519,19 @@ static statement_t *parse_return(void)
                if (return_value->base.kind == EXPR_UNARY_TAKE_ADDRESS) {
                        const expression_t *expression = return_value->unary.value;
                        if (is_local_variable(expression)) {
-                               warningf(statement->statement.source_position,
-                                       "function returns address of local variable");
+                               warningf(statement->base.source_position,
+                                        "function returns address of local variable");
                        }
                }
        } else {
                if(!is_type_atomic(return_type, ATOMIC_TYPE_VOID)) {
-                       warningf(statement->statement.source_position,
-                               "'return' without value, in function returning non-void");
+                       warningf(statement->base.source_position,
+                                "'return' without value, in function returning non-void");
                }
        }
-       statement->return_value = return_value;
+       statement->returns.value = return_value;
 
-       return (statement_t*) statement;
+       return statement;
 }
 
 /**
@@ -5692,47 +5688,47 @@ static statement_t *parse_statement(void)
  */
 static statement_t *parse_compound_statement(void)
 {
-       compound_statement_t *const compound_statement
-               = allocate_ast_zero(sizeof(compound_statement[0]));
-       compound_statement->statement.kind            = STATEMENT_COMPOUND;
-       compound_statement->statement.source_position = token.source_position;
+       statement_t *statement = allocate_statement_zero(STATEMENT_COMPOUND);
+
+       statement->base.source_position = token.source_position;
 
        eat('{');
 
        int      top        = environment_top();
        scope_t *last_scope = scope;
-       set_scope(&compound_statement->scope);
+       set_scope(&statement->compound.scope);
 
        statement_t *last_statement = NULL;
 
        while(token.type != '}' && token.type != T_EOF) {
-               statement_t *statement = parse_statement();
-               if(statement == NULL)
+               statement_t *sub_statement = parse_statement();
+               if(sub_statement == NULL)
                        continue;
 
                if(last_statement != NULL) {
-                       last_statement->base.next = statement;
+                       last_statement->base.next = sub_statement;
                } else {
-                       compound_statement->statements = statement;
+                       statement->compound.statements = sub_statement;
                }
 
-               while(statement->base.next != NULL)
-                       statement = statement->base.next;
+               while(sub_statement->base.next != NULL)
+                       sub_statement = sub_statement->base.next;
 
-               last_statement = statement;
+               last_statement = sub_statement;
        }
 
        if(token.type == '}') {
                next_token();
        } else {
-               errorf(compound_statement->statement.source_position, "end of file while looking for closing '}'");
+               errorf(statement->base.source_position,
+                      "end of file while looking for closing '}'");
        }
 
-       assert(scope == &compound_statement->scope);
+       assert(scope == &statement->compound.scope);
        set_scope(last_scope);
        environment_pop_to(top);
 
-       return (statement_t*) compound_statement;
+       return statement;
 }
 
 /**

diff --git a/type_t.h b/type_t.h
index d6131d5..6f5364a 100644 (file)
--- a/type_t.h
+++ b/type_t.h
@@ -210,4 +210,9 @@ static inline bool is_type_compound(const type_t *type)
                || type->kind == TYPE_COMPOUND_UNION;
 }
 
+static inline bool is_type_valid(const type_t *type)
+{
+       return type->kind != TYPE_ERROR;
+}
+
 #endif

diff --git a/types.c b/types.c
index ad35a19..c229827 100644 (file)
--- a/types.c
+++ b/types.c
@@ -13,12 +13,12 @@ type_t *type_long_long;
 type_t *type_long;
 type_t *type_short;
 type_t *type_signed_char;
-type_t *type_string;
 type_t *type_unsigned_int;
 type_t *type_unsigned_long_long;
 type_t *type_unsigned_long;
 type_t *type_void;
 
+type_t *type_char_ptr;
 type_t *type_int_ptr;
 type_t *type_long_long_ptr;
 type_t *type_long_ptr;
@@ -63,12 +63,12 @@ void init_basic_types(void)
        type_void               = make_atomic_type(ATOMIC_TYPE_VOID,        TYPE_QUALIFIER_NONE);
 
        type_void_ptr           = make_pointer_type(type_void,              TYPE_QUALIFIER_NONE);
-       type_string             = make_pointer_type(type_char,              TYPE_QUALIFIER_NONE);
+       type_char_ptr           = make_pointer_type(type_char,              TYPE_QUALIFIER_NONE);
        type_signed_char_ptr    = make_pointer_type(type_signed_char,       TYPE_QUALIFIER_NONE);
        type_short_ptr          = make_pointer_type(type_short,             TYPE_QUALIFIER_NONE);
        type_int_ptr            = make_pointer_type(type_int,               TYPE_QUALIFIER_NONE);
        type_long_ptr           = make_pointer_type(type_long,              TYPE_QUALIFIER_NONE);
        type_long_long_ptr      = make_pointer_type(type_long_long,         TYPE_QUALIFIER_NONE);
 
-       type_char_ptr_ptr       = make_pointer_type(type_string,            TYPE_QUALIFIER_NONE);
+       type_char_ptr_ptr       = make_pointer_type(type_char_ptr,          TYPE_QUALIFIER_NONE);
 }

diff --git a/types.h b/types.h
index 32fc5bc..b51501e 100644 (file)
--- a/types.h
+++ b/types.h
@@ -14,12 +14,12 @@ extern type_t *type_long_long;
 extern type_t *type_long;
 extern type_t *type_short;
 extern type_t *type_signed_char;
-extern type_t *type_string;
 extern type_t *type_unsigned_int;
 extern type_t *type_unsigned_long_long;
 extern type_t *type_unsigned_long;
 extern type_t *type_void;
 
+extern type_t *type_char_ptr;
 extern type_t *type_int_ptr;
 extern type_t *type_long_long_ptr;
 extern type_t *type_long_ptr;
@@ -45,6 +45,4 @@ extern type_t *type_wchar_t_ptr;
 
 void init_basic_types(void);
 
-#define is_type_valid(type) ((type)->kind != TYPE_ERROR)
-
 #endif