type: Make an assert()ion independent of the last entry of an enum.

[cparser] / ast2firm.c

diff --git a/ast2firm.c b/ast2firm.c
index 9ddd3b2..384450c 100644 (file)
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -235,12 +235,6 @@ static void init_atomic_modes(void)
        }
 }
 
-ir_mode *get_atomic_mode(atomic_type_kind_t kind)
-{
-       assert(kind <= ATOMIC_TYPE_LAST);
-       return atomic_modes[kind];
-}
-
 static ir_node *get_vla_size(array_type_t *const type)
 {
        ir_node *size_node = type->size_node;
@@ -334,6 +328,8 @@ static type_t *get_parameter_type(type_t *orig_type)
        return type;
 }
 
+static ir_type *get_ir_type(type_t *type);
+
 static ir_type *create_method_type(const function_type_t *function_type, bool for_closure)
 {
        type_t        *return_type  = skip_typeref(function_type->return_type);
@@ -680,7 +676,7 @@ static ir_type *get_ir_type_incomplete(type_t *type)
        }
 }
 
-ir_type *get_ir_type(type_t *type)
+static ir_type *get_ir_type(type_t *type)
 {
        type = skip_typeref(type);
 
@@ -2204,15 +2200,15 @@ static ir_node *handle_assume(expression_t const *const expr)
 
 static ir_node *create_cast(unary_expression_t const *const expr)
 {
-       type_t *const type = skip_typeref(expr->base.type);
-       if (is_type_void(type))
-               return NULL;
-
        type_t  *const from_type = skip_typeref(expr->value->base.type);
        ir_node       *value     = is_type_complex(from_type)
                ? expression_to_complex(expr->value).real
                : expression_to_value(expr->value);
 
+       type_t *const type = skip_typeref(expr->base.type);
+       if (is_type_void(type))
+               return NULL;
+
        dbg_info *const dbgi = get_dbg_info(&expr->base.pos);
        ir_mode  *const mode = get_ir_mode_storage(type);
        /* check for conversion from / to __based types */
@@ -3200,7 +3196,9 @@ static ir_node *expression_to_value(expression_t const *const expr)
 
        switch (expr->kind) {
        case EXPR_UNARY_CAST:
-               if (is_type_atomic(skip_typeref(expr->base.type), ATOMIC_TYPE_BOOL)) {
+               if (!is_type_atomic(skip_typeref(expr->base.type), ATOMIC_TYPE_BOOL))
+                       return create_cast(&expr->unary);
+               /* FALLTHROUGH */
        case EXPR_BINARY_EQUAL:
        case EXPR_BINARY_GREATER:
        case EXPR_BINARY_GREATEREQUAL:
@@ -3215,16 +3213,14 @@ static ir_node *expression_to_value(expression_t const *const expr)
        case EXPR_BINARY_LOGICAL_AND:
        case EXPR_BINARY_LOGICAL_OR:
        case EXPR_BINARY_NOTEQUAL:
-       case EXPR_UNARY_NOT:;
-                       jump_target true_target;
-                       jump_target false_target;
-                       init_jump_target(&true_target,  NULL);
-                       init_jump_target(&false_target, NULL);
-                       expression_to_control_flow(expr, &true_target, &false_target);
-                       return control_flow_to_1_0(expr, &true_target, &false_target);
-               } else {
-                       return create_cast(&expr->unary);
-               }
+       case EXPR_UNARY_NOT: {
+               jump_target true_target;
+               jump_target false_target;
+               init_jump_target(&true_target,  NULL);
+               init_jump_target(&false_target, NULL);
+               expression_to_control_flow(expr, &true_target, &false_target);
+               return control_flow_to_1_0(expr, &true_target, &false_target);
+       }
 
        case EXPR_BINARY_ADD:
        case EXPR_BINARY_BITWISE_AND:
@@ -3385,23 +3381,24 @@ static ir_node *expression_to_control_flow(expression_t const *const expr, jump_
                if (is_type_atomic(skip_typeref(expr->base.type), ATOMIC_TYPE_BOOL)) {
                        expression_to_control_flow(expr->unary.value, true_target, false_target);
                        return NULL;
-               } else {
-       default:;
-                       type_t *const type = skip_typeref(expr->base.type);
-                       if (is_type_complex(type)) {
-                               complex_to_control_flow(expr, true_target, false_target);
-                               return NULL;
-                       }
-
-                       dbg_info   *const dbgi  = get_dbg_info(&expr->base.pos);
-                       ir_mode    *const mode  = get_ir_mode_arithmetic(type);
-                       ir_node    *const val   = create_conv(dbgi, expression_to_value(expr), mode);
-                       ir_node    *const left  = val;
-                       ir_node    *const right = new_Const(get_mode_null(get_irn_mode(val)));
-                       ir_relation const relation = ir_relation_unordered_less_greater;
-                       compare_to_control_flow(expr, left, right, relation, true_target, false_target);
-                       return val;
                }
+               /* FALLTHROUGH */
+       default: {
+               type_t *const type = skip_typeref(expr->base.type);
+               if (is_type_complex(type)) {
+                       complex_to_control_flow(expr, true_target, false_target);
+                       return NULL;
+               }
+
+               dbg_info   *const dbgi  = get_dbg_info(&expr->base.pos);
+               ir_mode    *const mode  = get_ir_mode_arithmetic(type);
+               ir_node    *const val   = create_conv(dbgi, expression_to_value(expr), mode);
+               ir_node    *const left  = val;
+               ir_node    *const right = new_Const(get_mode_null(get_irn_mode(val)));
+               ir_relation const relation = ir_relation_unordered_less_greater;
+               compare_to_control_flow(expr, left, right, relation, true_target, false_target);
+               return val;
+       }
        }
 }