X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast.c;h=13081b15451698d59c8fb50e84c276ae70f04871;hb=3cdead30b5c1d131d5c363188c26255514ea2fc8;hp=f0946ef62ade7fca7544e9f870ae7df567922a22;hpb=36621324d1789e20f27e0df8e693b5527886068f;p=cparser diff --git a/ast.c b/ast.c index f0946ef..13081b1 100644 --- a/ast.c +++ b/ast.c @@ -114,10 +114,8 @@ static unsigned get_expression_precedence(expression_kind_t kind) [EXPR_ALIGNOF] = PREC_UNARY, [EXPR_FUNCNAME] = PREC_PRIMARY, - [EXPR_BUILTIN_SYMBOL] = PREC_PRIMARY, [EXPR_BUILTIN_CONSTANT_P] = PREC_PRIMARY, [EXPR_BUILTIN_TYPES_COMPATIBLE_P] = PREC_PRIMARY, - [EXPR_BUILTIN_PREFETCH] = PREC_PRIMARY, [EXPR_OFFSETOF] = PREC_PRIMARY, [EXPR_VA_START] = PREC_PRIMARY, [EXPR_VA_ARG] = PREC_PRIMARY, @@ -399,8 +397,7 @@ static void print_assignment_expression(const expression_t *const expr) */ static void print_call_expression(const call_expression_t *call) { - unsigned prec = get_expression_precedence(call->base.kind); - print_expression_prec(call->function, prec); + print_expression_prec(call->function, PREC_POSTFIX); fputc('(', out); call_argument_t *argument = call->arguments; int first = 1; @@ -548,14 +545,13 @@ static void print_label_address_expression(const label_address_expression_t *le) */ static void print_array_expression(const array_access_expression_t *expression) { - unsigned prec = get_expression_precedence(expression->base.kind); if (!expression->flipped) { - print_expression_prec(expression->array_ref, prec); + print_expression_prec(expression->array_ref, PREC_POSTFIX); fputc('[', out); print_expression(expression->index); fputc(']', out); } else { - print_expression_prec(expression->index, prec); + print_expression_prec(expression->index, PREC_POSTFIX); fputc('[', out); print_expression(expression->array_ref); fputc(']', out); @@ -576,10 +572,8 @@ static void print_typeprop_expression(const typeprop_expression_t *expression) fputs("__alignof__", out); } if (expression->tp_expression != NULL) { - /* always print the '()' here, sizeof x is right but unusual */ - fputc('(', out); - print_expression(expression->tp_expression); - fputc(')', out); + /* PREC_TOP: always print the '()' here, sizeof x is right but unusual */ + print_expression_prec(expression->tp_expression, PREC_TOP); } else { fputc('(', out); print_type(expression->type); @@ -587,16 +581,6 @@ static void print_typeprop_expression(const typeprop_expression_t *expression) } } -/** - * Prints an builtin symbol. - * - * @param expression the builtin symbol expression - */ -static void print_builtin_symbol(const builtin_symbol_expression_t *expression) -{ - fputs(expression->symbol->string, out); -} - /** * Prints a builtin constant expression. * @@ -624,26 +608,6 @@ static void print_builtin_types_compatible( fputc(')', out); } -/** - * Prints a builtin prefetch expression. - * - * @param expression the builtin prefetch expression - */ -static void print_builtin_prefetch(const builtin_prefetch_expression_t *expression) -{ - fputs("__builtin_prefetch(", out); - print_assignment_expression(expression->adr); - if (expression->rw) { - fputc(',', out); - print_assignment_expression(expression->rw); - } - if (expression->locality) { - fputc(',', out); - print_assignment_expression(expression->locality); - } - fputc(')', out); -} - /** * Prints a conditional expression. * @@ -652,12 +616,12 @@ static void print_builtin_prefetch(const builtin_prefetch_expression_t *expressi static void print_conditional(const conditional_expression_t *expression) { print_expression_prec(expression->condition, PREC_LOGICAL_OR); - fputs(" ? ", out); if (expression->true_expression != NULL) { + fputs(" ? ", out); print_expression_prec(expression->true_expression, PREC_EXPRESSION); fputs(" : ", out); } else { - fputs(": ", out); + fputs(" ?: ", out); } precedence_t prec = c_mode & _CXX ? PREC_ASSIGNMENT : PREC_CONDITIONAL; print_expression_prec(expression->false_expression, prec); @@ -698,8 +662,7 @@ static void print_va_arg(const va_arg_expression_t *expression) */ static void print_select(const select_expression_t *expression) { - unsigned prec = get_expression_precedence(expression->base.kind); - print_expression_prec(expression->compound, prec); + print_expression_prec(expression->compound, PREC_POSTFIX); if (is_type_pointer(skip_typeref(expression->compound->base.type))) { fputs("->", out); } else { @@ -835,18 +798,12 @@ static void print_expression_prec(const expression_t *expression, unsigned top_p case EXPR_ALIGNOF: print_typeprop_expression(&expression->typeprop); break; - case EXPR_BUILTIN_SYMBOL: - print_builtin_symbol(&expression->builtin_symbol); - break; case EXPR_BUILTIN_CONSTANT_P: print_builtin_constant(&expression->builtin_constant); break; case EXPR_BUILTIN_TYPES_COMPATIBLE_P: print_builtin_types_compatible(&expression->builtin_types_compatible); break; - case EXPR_BUILTIN_PREFETCH: - print_builtin_prefetch(&expression->builtin_prefetch); - break; case EXPR_CONDITIONAL: print_conditional(&expression->conditional); break; @@ -1111,22 +1068,17 @@ static void print_do_while_statement(const do_while_statement_t *statement) static void print_for_statement(const for_statement_t *statement) { fputs("for (", out); - entity_t *entity = statement->scope.entities; - while (entity != NULL && is_generated_entity(entity)) - entity = entity->base.next; - - if (entity != NULL) { - assert(statement->initialisation == NULL); - assert(is_declaration(entity)); - print_declaration(entity); - if (entity->base.next != NULL) { - panic("multiple declarations in for statement not supported yet"); - } + if (statement->initialisation != NULL) { + print_expression(statement->initialisation); + fputc(';', out); } else { - if (statement->initialisation) { - print_expression(statement->initialisation); + entity_t const *entity = statement->scope.entities; + for (; entity != NULL; entity = entity->base.next) { + if (is_generated_entity(entity)) + continue; + /* FIXME display of multiple declarations is wrong */ + print_declaration(entity); } - fputc(';', out); } if (statement->condition != NULL) { fputc(' ', out); @@ -1788,27 +1740,32 @@ bool is_address_constant(const expression_t *expression) } } +/** + * Check if the given expression is a call to a builtin function + * returning a constant result. + */ static bool is_builtin_const_call(const expression_t *expression) { expression_t *function = expression->call.function; - if (function->kind != EXPR_BUILTIN_SYMBOL) { + if (function->kind != EXPR_REFERENCE) + return false; + reference_expression_t *ref = &function->reference; + if (ref->entity->kind != ENTITY_FUNCTION) return false; - } - - symbol_t *symbol = function->builtin_symbol.symbol; - switch (symbol->ID) { - case T___builtin_huge_val: - case T___builtin_inf: - case T___builtin_inff: - case T___builtin_infl: - case T___builtin_nan: - case T___builtin_nanf: - case T___builtin_nanl: + switch (ref->entity->function.btk) { + case bk_gnu_builtin_huge_val: + 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: return true; + default: + return false; } - return false; } static bool is_constant_pointer(const expression_t *expression) @@ -1885,8 +1842,6 @@ bool is_constant_expression(const expression_t *expression) return true; } - case EXPR_BUILTIN_SYMBOL: - case EXPR_BUILTIN_PREFETCH: case EXPR_SELECT: case EXPR_VA_START: case EXPR_VA_ARG: