X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast.c;h=0fb422b53dc9c1fef6b1b904b14b01a147a5ed04;hb=cb69923e40a94f9b611874437f00d7d31abf3dd7;hp=b7588c5c6c702a4ae527ef5da2d3297a814027d2;hpb=58558497dcf35ed589188c87600576b58d7c237d;p=cparser diff --git a/ast.c b/ast.c index b7588c5..0fb422b 100644 --- a/ast.c +++ b/ast.c @@ -100,8 +100,6 @@ static int right_to_left(unsigned precedence) static unsigned get_expression_precedence(expression_kind_t kind) { static const unsigned prec[] = { - [EXPR_UNKNOWN] = PREC_PRIMARY, - [EXPR_INVALID] = PREC_PRIMARY, [EXPR_REFERENCE] = PREC_PRIMARY, [EXPR_REFERENCE_ENUM_VALUE] = PREC_PRIMARY, [EXPR_LITERAL_INTEGER] = PREC_PRIMARY, @@ -591,6 +589,12 @@ static void print_va_copy(const va_copy_expression_t *expression) static void print_select(const select_expression_t *expression) { print_expression_prec(expression->compound, PREC_POSTFIX); + /* do not print anything for anonymous struct/union selects + * FIXME: if the anonymous select was a '->' this will print '.' + */ + if (expression->compound_entry->base.symbol == NULL) + return; + if (is_type_pointer(skip_typeref(expression->compound->base.type))) { print_string("->"); } else { @@ -678,9 +682,8 @@ static void print_expression_prec(const expression_t *expression, unsigned top_p if (parenthesized) print_string("("); switch (expression->kind) { - case EXPR_UNKNOWN: - case EXPR_INVALID: - print_string("$invalid expression$"); + case EXPR_ERROR: + print_string("$error$"); break; case EXPR_WIDE_STRING_LITERAL: case EXPR_STRING_LITERAL: @@ -748,13 +751,6 @@ static void print_expression_prec(const expression_t *expression, unsigned top_p case EXPR_STATEMENT: print_statement_expression(&expression->statement); break; - -#if 0 - default: - /* TODO */ - print_format("some expression of type %d", (int)expression->kind); - break; -#endif } if (parenthesized) print_string(")"); @@ -1184,8 +1180,8 @@ void print_statement(const statement_t *statement) case STATEMENT_LEAVE: print_leave_statement(&statement->leave); break; - case STATEMENT_INVALID: - print_string("$invalid statement$\n"); + case STATEMENT_ERROR: + print_string("$error statement$\n"); break; } } @@ -1505,8 +1501,6 @@ print_compound: case ENTITY_LABEL: case ENTITY_ENUM_VALUE: panic("print_entity used on unexpected entity type"); - case ENTITY_INVALID: - break; } panic("Invalid entity type encountered"); } @@ -1543,7 +1537,7 @@ expression_classification_t is_constant_initializer(const initializer_t *initial return EXPR_CLASS_CONSTANT; case INITIALIZER_VALUE: - return is_constant_expression(initializer->value.value); + return is_linker_constant(initializer->value.value); case INITIALIZER_LIST: { expression_classification_t all = EXPR_CLASS_CONSTANT; @@ -1612,7 +1606,7 @@ static expression_classification_t is_object_with_linker_constant_address( return EXPR_CLASS_VARIABLE; } - case EXPR_INVALID: + case EXPR_ERROR: return EXPR_CLASS_ERROR; default: @@ -1629,6 +1623,9 @@ expression_classification_t is_linker_constant(const expression_t *expression) case EXPR_LABEL_ADDRESS: return EXPR_CLASS_CONSTANT; + case EXPR_COMPOUND_LITERAL: + return is_constant_initializer(expression->compound_literal.initializer); + case EXPR_UNARY_TAKE_ADDRESS: return is_object_with_linker_constant_address(expression->unary.value); @@ -1649,11 +1646,9 @@ expression_classification_t is_linker_constant(const expression_t *expression) !(get_atomic_type_flags(dest->atomic.akind) & ATOMIC_TYPE_FLAG_INTEGER) || get_atomic_type_size(dest->atomic.akind) < get_type_size(type_void_ptr) )) - return EXPR_CLASS_VARIABLE; + return is_constant_expression(expression); - expression_classification_t const expr = is_constant_expression(expression->unary.value); - expression_classification_t const addr = is_linker_constant(expression->unary.value); - return expr > addr ? expr : addr; + return is_linker_constant(expression->unary.value); } case EXPR_BINARY_ADD: @@ -1674,7 +1669,7 @@ expression_classification_t is_linker_constant(const expression_t *expression) } else if (!is_type_valid(ltype) || !is_type_valid(rtype)) { return EXPR_CLASS_ERROR; } else { - return EXPR_CLASS_VARIABLE; + return is_constant_expression(expression); } } @@ -1700,9 +1695,7 @@ expression_classification_t is_linker_constant(const expression_t *expression) skip_typeref(revert_automatic_type_conversion(expression)); if (!is_type_array(type)) return EXPR_CLASS_VARIABLE; - expression_classification_t const ref = is_linker_constant(expression->array_access.array_ref); - expression_classification_t const idx = is_constant_expression(expression->array_access.index); - return ref < idx ? ref : idx; + return is_linker_constant(expression->array_access.array_ref); } case EXPR_CONDITIONAL: { @@ -1738,11 +1731,8 @@ expression_classification_t is_linker_constant(const expression_t *expression) return EXPR_CLASS_VARIABLE; } - case EXPR_INVALID: - return EXPR_CLASS_ERROR; - default: - return EXPR_CLASS_VARIABLE; + return is_constant_expression(expression); } } @@ -1760,15 +1750,8 @@ static expression_classification_t is_builtin_const_call(const expression_t *exp return EXPR_CLASS_VARIABLE; switch (ref->entity->function.btk) { - case bk_gnu_builtin_huge_val: - case bk_gnu_builtin_huge_valf: - case bk_gnu_builtin_huge_vall: - case bk_gnu_builtin_inf: - case bk_gnu_builtin_inff: - case bk_gnu_builtin_infl: - case bk_gnu_builtin_nan: - case bk_gnu_builtin_nanf: - case bk_gnu_builtin_nanl: + case BUILTIN_INF: + case BUILTIN_NAN: return EXPR_CLASS_CONSTANT; default: return EXPR_CLASS_VARIABLE; @@ -1818,7 +1801,7 @@ static expression_classification_t is_object_with_constant_address(const express case EXPR_UNARY_DEREFERENCE: return is_constant_pointer(expression->unary.value); - case EXPR_INVALID: + case EXPR_ERROR: return EXPR_CLASS_ERROR; default: @@ -1968,11 +1951,8 @@ expression_classification_t is_constant_expression(const expression_t *expressio } } - case EXPR_INVALID: + case EXPR_ERROR: return EXPR_CLASS_ERROR; - - case EXPR_UNKNOWN: - break; } panic("invalid expression found (is constant expression)"); }