Rename EXPR_REFERENCE_ENUM_VALUE to EXPR_ENUM_CONSTANT.

[cparser] / ast2firm.c

diff --git a/ast2firm.c b/ast2firm.c
index f5b010a..5f7f660 100644 (file)
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -680,10 +680,6 @@ ir_type *get_ir_type(type_t *type)
 
        ir_type *firm_type = NULL;
        switch (type->kind) {
-       case TYPE_ERROR:
-               /* Happens while constant folding, when there was an error */
-               return create_atomic_type(ATOMIC_TYPE_VOID, NULL);
-
        case TYPE_ATOMIC:
                firm_type = create_atomic_type(type->atomic.akind, type);
                break;
@@ -715,6 +711,7 @@ ir_type *get_ir_type(type_t *type)
                firm_type = create_enum_type(&type->enumt);
                break;
 
+       case TYPE_ERROR:
        case TYPE_TYPEOF:
        case TYPE_TYPEDEF:
                break;
@@ -1536,8 +1533,7 @@ static void keep_all_memory(ir_node *block)
        set_cur_block(old);
 }
 
-static ir_node *reference_expression_enum_value_to_firm(
-               const reference_expression_t *ref)
+static ir_node *enum_constant_to_firm(reference_expression_t const *const ref)
 {
        entity_t *entity = ref->entity;
        if (entity->enum_value.tv == NULL) {
@@ -3028,16 +3024,12 @@ static ir_tarval *fold_constant_to_tarval(const expression_t *expression)
 /* this function is only used in parser.c, but it relies on libfirm functionality */
 bool constant_is_negative(const expression_t *expression)
 {
-       assert(is_constant_expression(expression) == EXPR_CLASS_CONSTANT);
        ir_tarval *tv = fold_constant_to_tarval(expression);
        return tarval_is_negative(tv);
 }
 
 long fold_constant_to_int(const expression_t *expression)
 {
-       if (expression->kind == EXPR_ERROR)
-               return 0;
-
        ir_tarval *tv = fold_constant_to_tarval(expression);
        if (!tarval_is_long(tv)) {
                panic("result of constant folding is not integer");
@@ -3048,8 +3040,6 @@ long fold_constant_to_int(const expression_t *expression)
 
 bool fold_constant_to_bool(const expression_t *expression)
 {
-       if (expression->kind == EXPR_ERROR)
-               return false;
        ir_tarval *tv = fold_constant_to_tarval(expression);
        return !tarval_is_null(tv);
 }
@@ -3436,12 +3426,6 @@ static ir_node *label_address_to_firm(const label_address_expression_t *label)
        return new_d_SymConst(dbgi, mode_P_code, value, symconst_addr_ent);
 }
 
-static ir_node *error_to_firm(const expression_t *expression)
-{
-       ir_mode *mode = get_ir_mode_arithmetic(expression->base.type);
-       return new_Bad(mode);
-}
-
 /**
  * creates firm nodes for an expression. The difference between this function
  * and expression_to_firm is, that this version might produce mode_b nodes
@@ -3466,8 +3450,8 @@ static ir_node *_expression_to_firm(const expression_t *expression)
                return wide_string_literal_to_firm(&expression->string_literal);
        case EXPR_REFERENCE:
                return reference_expression_to_firm(&expression->reference);
-       case EXPR_REFERENCE_ENUM_VALUE:
-               return reference_expression_enum_value_to_firm(&expression->reference);
+       case EXPR_ENUM_CONSTANT:
+               return enum_constant_to_firm(&expression->reference);
        case EXPR_CALL:
                return call_expression_to_firm(&expression->call);
        case EXPR_UNARY_CASES:
@@ -3508,7 +3492,7 @@ static ir_node *_expression_to_firm(const expression_t *expression)
                return label_address_to_firm(&expression->label_address);
 
        case EXPR_ERROR:
-               return error_to_firm(expression);
+               break;
        }
        panic("invalid expression found");
 }