X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast.c;h=3944ade866817870eaaafd48b5b5e4dd626f0a03;hb=ef0330776eb4dc05c1bde7354d9ed6c86f2c4727;hp=b8f2b87f6fd3d28242dac9046b36e769860e1fd4;hpb=9634f9c53e95b6bdc7883228c5ec5147f3de4f8e;p=cparser diff --git a/ast.c b/ast.c index b8f2b87..3944ade 100644 --- a/ast.c +++ b/ast.c @@ -66,11 +66,6 @@ void print_indent(void) print_string("\t"); } -static void print_symbol(const symbol_t *symbol) -{ - print_string(symbol->string); -} - static void print_stringrep(const string_t *string) { for (size_t i = 0; i < string->size; ++i) { @@ -105,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, @@ -149,7 +142,6 @@ static unsigned get_expression_precedence(expression_kind_t kind) [EXPR_UNARY_PREFIX_INCREMENT] = PREC_UNARY, [EXPR_UNARY_PREFIX_DECREMENT] = PREC_UNARY, [EXPR_UNARY_CAST] = PREC_UNARY, - [EXPR_UNARY_CAST_IMPLICIT] = PREC_UNARY, [EXPR_UNARY_ASSUME] = PREC_PRIMARY, [EXPR_UNARY_DELETE] = PREC_UNARY, [EXPR_UNARY_DELETE_ARRAY] = PREC_UNARY, @@ -267,8 +259,8 @@ static void print_literal(const literal_expression_t *literal) case EXPR_LITERAL_INTEGER_OCTAL: case EXPR_LITERAL_FLOATINGPOINT: print_stringrep(&literal->value); - if (literal->suffix != NULL) - print_symbol(literal->suffix); + if (literal->suffix.size > 0) + print_stringrep(&literal->suffix); return; case EXPR_LITERAL_WIDE_CHARACTER: print_char('L'); @@ -413,7 +405,6 @@ static void print_unary_expression(const unary_expression_t *unexpr) print_expression_prec(unexpr->value, prec); print_string("--"); return; - case EXPR_UNARY_CAST_IMPLICIT: case EXPR_UNARY_CAST: print_string("("); print_type(unexpr->base.type); @@ -598,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 { @@ -672,7 +669,8 @@ static void print_statement_expression(const statement_expression_t *expression) */ static void print_expression_prec(const expression_t *expression, unsigned top_prec) { - if (expression->kind == EXPR_UNARY_CAST_IMPLICIT && !print_implicit_casts) { + if (expression->kind == EXPR_UNARY_CAST + && expression->base.implicit && !print_implicit_casts) { expression = expression->unary.value; } @@ -684,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: @@ -754,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(")"); @@ -1190,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; } } @@ -1430,6 +1420,13 @@ void print_declaration(const entity_t *entity) } break; + case ENTITY_COMPOUND_MEMBER: + print_type_ext(declaration->type, declaration->base.symbol, NULL); + if (entity->compound_member.bitfield) { + print_format(" : %u", entity->compound_member.bit_size); + } + break; + default: print_type_ext(declaration->type, declaration->base.symbol, NULL); break; @@ -1504,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"); } @@ -1611,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: @@ -1646,7 +1641,7 @@ expression_classification_t is_linker_constant(const expression_t *expression) if (!is_type_pointer(dest) && ( dest->kind != TYPE_ATOMIC || !(get_atomic_type_flags(dest->atomic.akind) & ATOMIC_TYPE_FLAG_INTEGER) || - get_atomic_type_size(dest->atomic.akind) < get_atomic_type_size(get_intptr_kind()) + get_atomic_type_size(dest->atomic.akind) < get_type_size(type_void_ptr) )) return EXPR_CLASS_VARIABLE; @@ -1737,7 +1732,7 @@ expression_classification_t is_linker_constant(const expression_t *expression) return EXPR_CLASS_VARIABLE; } - case EXPR_INVALID: + case EXPR_ERROR: return EXPR_CLASS_ERROR; default: @@ -1759,15 +1754,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; @@ -1817,7 +1805,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: @@ -1894,8 +1882,7 @@ expression_classification_t is_constant_expression(const expression_t *expressio case EXPR_UNARY_NOT: return is_constant_expression(expression->unary.value); - case EXPR_UNARY_CAST: - case EXPR_UNARY_CAST_IMPLICIT: { + case EXPR_UNARY_CAST: { type_t *const type = skip_typeref(expression->base.type); if (is_type_scalar(type)) return is_constant_expression(expression->unary.value); @@ -1968,11 +1955,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)"); }