X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ast.c;h=f852a9d4078a8b7ea4532f09ff86eeb85ccf8133;hb=8845feb009950d2c76a394660a5bd81a0be0f2a6;hp=586ce2b005f757361ac9d88125043dfddd22cbbb;hpb=f181ba24df15120ce46e9a23d9466e6177de3473;p=cparser diff --git a/ast.c b/ast.c index 586ce2b..f852a9d 100644 --- a/ast.c +++ b/ast.c @@ -1,21 +1,6 @@ /* * This file is part of cparser. - * Copyright (C) 2007-2009 Matthias Braun - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA - * 02111-1307, USA. + * Copyright (C) 2012 Matthias Braun */ #include @@ -26,6 +11,7 @@ #include "lang_features.h" #include "entity_t.h" #include "printer.h" +#include "separator_t.h" #include "types.h" #include @@ -67,13 +53,6 @@ void print_indent(void) print_char('\t'); } -static void print_stringrep(const string_t *string) -{ - for (size_t i = 0; i < string->size; ++i) { - print_char(string->begin[i]); - } -} - /** * Returns 1 if a given precedence level has right-to-left * associativity, else 0. @@ -101,91 +80,88 @@ static int right_to_left(unsigned precedence) static unsigned get_expression_precedence(expression_kind_t kind) { static const unsigned prec[] = { - [EXPR_ERROR] = PREC_PRIMARY, - [EXPR_REFERENCE] = PREC_PRIMARY, - [EXPR_REFERENCE_ENUM_VALUE] = PREC_PRIMARY, - [EXPR_LITERAL_INTEGER] = PREC_PRIMARY, - [EXPR_LITERAL_INTEGER_OCTAL] = PREC_PRIMARY, - [EXPR_LITERAL_INTEGER_HEXADECIMAL] = PREC_PRIMARY, - [EXPR_LITERAL_FLOATINGPOINT] = PREC_PRIMARY, - [EXPR_LITERAL_FLOATINGPOINT_HEXADECIMAL] = PREC_PRIMARY, - [EXPR_LITERAL_CHARACTER] = PREC_PRIMARY, - [EXPR_LITERAL_WIDE_CHARACTER] = PREC_PRIMARY, - [EXPR_LITERAL_MS_NOOP] = PREC_PRIMARY, - [EXPR_STRING_LITERAL] = PREC_PRIMARY, - [EXPR_WIDE_STRING_LITERAL] = PREC_PRIMARY, - [EXPR_COMPOUND_LITERAL] = PREC_UNARY, - [EXPR_CALL] = PREC_POSTFIX, - [EXPR_CONDITIONAL] = PREC_CONDITIONAL, - [EXPR_SELECT] = PREC_POSTFIX, - [EXPR_ARRAY_ACCESS] = PREC_POSTFIX, - [EXPR_SIZEOF] = PREC_UNARY, - [EXPR_CLASSIFY_TYPE] = PREC_UNARY, - [EXPR_ALIGNOF] = PREC_UNARY, - - [EXPR_FUNCNAME] = PREC_PRIMARY, - [EXPR_BUILTIN_CONSTANT_P] = PREC_PRIMARY, - [EXPR_BUILTIN_TYPES_COMPATIBLE_P] = PREC_PRIMARY, - [EXPR_OFFSETOF] = PREC_PRIMARY, - [EXPR_VA_START] = PREC_PRIMARY, - [EXPR_VA_ARG] = PREC_PRIMARY, - [EXPR_VA_COPY] = PREC_PRIMARY, - [EXPR_STATEMENT] = PREC_PRIMARY, - [EXPR_LABEL_ADDRESS] = PREC_PRIMARY, - - [EXPR_UNARY_NEGATE] = PREC_UNARY, - [EXPR_UNARY_PLUS] = PREC_UNARY, - [EXPR_UNARY_BITWISE_NEGATE] = PREC_UNARY, - [EXPR_UNARY_NOT] = PREC_UNARY, - [EXPR_UNARY_DEREFERENCE] = PREC_UNARY, - [EXPR_UNARY_TAKE_ADDRESS] = PREC_UNARY, - [EXPR_UNARY_POSTFIX_INCREMENT] = PREC_POSTFIX, - [EXPR_UNARY_POSTFIX_DECREMENT] = PREC_POSTFIX, - [EXPR_UNARY_PREFIX_INCREMENT] = PREC_UNARY, - [EXPR_UNARY_PREFIX_DECREMENT] = PREC_UNARY, - [EXPR_UNARY_CAST] = PREC_UNARY, - [EXPR_UNARY_ASSUME] = PREC_PRIMARY, - [EXPR_UNARY_DELETE] = PREC_UNARY, - [EXPR_UNARY_DELETE_ARRAY] = PREC_UNARY, - [EXPR_UNARY_THROW] = PREC_ASSIGNMENT, - - [EXPR_BINARY_ADD] = PREC_ADDITIVE, - [EXPR_BINARY_SUB] = PREC_ADDITIVE, - [EXPR_BINARY_MUL] = PREC_MULTIPLICATIVE, - [EXPR_BINARY_DIV] = PREC_MULTIPLICATIVE, - [EXPR_BINARY_MOD] = PREC_MULTIPLICATIVE, - [EXPR_BINARY_EQUAL] = PREC_EQUALITY, - [EXPR_BINARY_NOTEQUAL] = PREC_EQUALITY, - [EXPR_BINARY_LESS] = PREC_RELATIONAL, - [EXPR_BINARY_LESSEQUAL] = PREC_RELATIONAL, - [EXPR_BINARY_GREATER] = PREC_RELATIONAL, - [EXPR_BINARY_GREATEREQUAL] = PREC_RELATIONAL, - [EXPR_BINARY_BITWISE_AND] = PREC_AND, - [EXPR_BINARY_BITWISE_OR] = PREC_OR, - [EXPR_BINARY_BITWISE_XOR] = PREC_XOR, - [EXPR_BINARY_LOGICAL_AND] = PREC_LOGICAL_AND, - [EXPR_BINARY_LOGICAL_OR] = PREC_LOGICAL_OR, - [EXPR_BINARY_SHIFTLEFT] = PREC_SHIFT, - [EXPR_BINARY_SHIFTRIGHT] = PREC_SHIFT, - [EXPR_BINARY_ASSIGN] = PREC_ASSIGNMENT, - [EXPR_BINARY_MUL_ASSIGN] = PREC_ASSIGNMENT, - [EXPR_BINARY_DIV_ASSIGN] = PREC_ASSIGNMENT, - [EXPR_BINARY_MOD_ASSIGN] = PREC_ASSIGNMENT, - [EXPR_BINARY_ADD_ASSIGN] = PREC_ASSIGNMENT, - [EXPR_BINARY_SUB_ASSIGN] = PREC_ASSIGNMENT, - [EXPR_BINARY_SHIFTLEFT_ASSIGN] = PREC_ASSIGNMENT, - [EXPR_BINARY_SHIFTRIGHT_ASSIGN] = PREC_ASSIGNMENT, - [EXPR_BINARY_BITWISE_AND_ASSIGN] = PREC_ASSIGNMENT, - [EXPR_BINARY_BITWISE_XOR_ASSIGN] = PREC_ASSIGNMENT, - [EXPR_BINARY_BITWISE_OR_ASSIGN] = PREC_ASSIGNMENT, - [EXPR_BINARY_COMMA] = PREC_EXPRESSION, - - [EXPR_BINARY_ISGREATER] = PREC_PRIMARY, - [EXPR_BINARY_ISGREATEREQUAL] = PREC_PRIMARY, - [EXPR_BINARY_ISLESS] = PREC_PRIMARY, - [EXPR_BINARY_ISLESSEQUAL] = PREC_PRIMARY, - [EXPR_BINARY_ISLESSGREATER] = PREC_PRIMARY, - [EXPR_BINARY_ISUNORDERED] = PREC_PRIMARY + [EXPR_ERROR] = PREC_PRIMARY, + [EXPR_REFERENCE] = PREC_PRIMARY, + [EXPR_ENUM_CONSTANT] = PREC_PRIMARY, + [EXPR_LITERAL_INTEGER] = PREC_PRIMARY, + [EXPR_LITERAL_FLOATINGPOINT] = PREC_PRIMARY, + [EXPR_LITERAL_CHARACTER] = PREC_PRIMARY, + [EXPR_LITERAL_MS_NOOP] = PREC_PRIMARY, + [EXPR_STRING_LITERAL] = PREC_PRIMARY, + [EXPR_COMPOUND_LITERAL] = PREC_UNARY, + [EXPR_CALL] = PREC_POSTFIX, + [EXPR_CONDITIONAL] = PREC_CONDITIONAL, + [EXPR_SELECT] = PREC_POSTFIX, + [EXPR_ARRAY_ACCESS] = PREC_POSTFIX, + [EXPR_SIZEOF] = PREC_UNARY, + [EXPR_CLASSIFY_TYPE] = PREC_UNARY, + [EXPR_ALIGNOF] = PREC_UNARY, + + [EXPR_FUNCNAME] = PREC_PRIMARY, + [EXPR_BUILTIN_CONSTANT_P] = PREC_PRIMARY, + [EXPR_BUILTIN_TYPES_COMPATIBLE_P] = PREC_PRIMARY, + [EXPR_OFFSETOF] = PREC_PRIMARY, + [EXPR_VA_START] = PREC_PRIMARY, + [EXPR_VA_ARG] = PREC_PRIMARY, + [EXPR_VA_COPY] = PREC_PRIMARY, + [EXPR_STATEMENT] = PREC_PRIMARY, + [EXPR_LABEL_ADDRESS] = PREC_PRIMARY, + + [EXPR_UNARY_NEGATE] = PREC_UNARY, + [EXPR_UNARY_PLUS] = PREC_UNARY, + [EXPR_UNARY_COMPLEMENT] = PREC_UNARY, + [EXPR_UNARY_NOT] = PREC_UNARY, + [EXPR_UNARY_DEREFERENCE] = PREC_UNARY, + [EXPR_UNARY_TAKE_ADDRESS] = PREC_UNARY, + [EXPR_UNARY_POSTFIX_INCREMENT] = PREC_POSTFIX, + [EXPR_UNARY_POSTFIX_DECREMENT] = PREC_POSTFIX, + [EXPR_UNARY_PREFIX_INCREMENT] = PREC_UNARY, + [EXPR_UNARY_PREFIX_DECREMENT] = PREC_UNARY, + [EXPR_UNARY_CAST] = PREC_UNARY, + [EXPR_UNARY_ASSUME] = PREC_PRIMARY, + [EXPR_UNARY_DELETE] = PREC_UNARY, + [EXPR_UNARY_DELETE_ARRAY] = PREC_UNARY, + [EXPR_UNARY_THROW] = PREC_ASSIGNMENT, + [EXPR_UNARY_IMAG] = PREC_UNARY, + [EXPR_UNARY_REAL] = PREC_UNARY, + + [EXPR_BINARY_ADD] = PREC_ADDITIVE, + [EXPR_BINARY_SUB] = PREC_ADDITIVE, + [EXPR_BINARY_MUL] = PREC_MULTIPLICATIVE, + [EXPR_BINARY_DIV] = PREC_MULTIPLICATIVE, + [EXPR_BINARY_MOD] = PREC_MULTIPLICATIVE, + [EXPR_BINARY_EQUAL] = PREC_EQUALITY, + [EXPR_BINARY_NOTEQUAL] = PREC_EQUALITY, + [EXPR_BINARY_LESS] = PREC_RELATIONAL, + [EXPR_BINARY_LESSEQUAL] = PREC_RELATIONAL, + [EXPR_BINARY_GREATER] = PREC_RELATIONAL, + [EXPR_BINARY_GREATEREQUAL] = PREC_RELATIONAL, + [EXPR_BINARY_BITWISE_AND] = PREC_AND, + [EXPR_BINARY_BITWISE_OR] = PREC_OR, + [EXPR_BINARY_BITWISE_XOR] = PREC_XOR, + [EXPR_BINARY_LOGICAL_AND] = PREC_LOGICAL_AND, + [EXPR_BINARY_LOGICAL_OR] = PREC_LOGICAL_OR, + [EXPR_BINARY_SHIFTLEFT] = PREC_SHIFT, + [EXPR_BINARY_SHIFTRIGHT] = PREC_SHIFT, + [EXPR_BINARY_ASSIGN] = PREC_ASSIGNMENT, + [EXPR_BINARY_MUL_ASSIGN] = PREC_ASSIGNMENT, + [EXPR_BINARY_DIV_ASSIGN] = PREC_ASSIGNMENT, + [EXPR_BINARY_MOD_ASSIGN] = PREC_ASSIGNMENT, + [EXPR_BINARY_ADD_ASSIGN] = PREC_ASSIGNMENT, + [EXPR_BINARY_SUB_ASSIGN] = PREC_ASSIGNMENT, + [EXPR_BINARY_SHIFTLEFT_ASSIGN] = PREC_ASSIGNMENT, + [EXPR_BINARY_SHIFTRIGHT_ASSIGN] = PREC_ASSIGNMENT, + [EXPR_BINARY_BITWISE_AND_ASSIGN] = PREC_ASSIGNMENT, + [EXPR_BINARY_BITWISE_XOR_ASSIGN] = PREC_ASSIGNMENT, + [EXPR_BINARY_BITWISE_OR_ASSIGN] = PREC_ASSIGNMENT, + [EXPR_BINARY_COMMA] = PREC_EXPRESSION, + + [EXPR_BINARY_ISGREATER] = PREC_PRIMARY, + [EXPR_BINARY_ISGREATEREQUAL] = PREC_PRIMARY, + [EXPR_BINARY_ISLESS] = PREC_PRIMARY, + [EXPR_BINARY_ISLESSEQUAL] = PREC_PRIMARY, + [EXPR_BINARY_ISLESSGREATER] = PREC_PRIMARY, + [EXPR_BINARY_ISUNORDERED] = PREC_PRIMARY }; assert((size_t)kind < lengthof(prec)); unsigned res = prec[kind]; @@ -199,13 +175,13 @@ static unsigned get_expression_precedence(expression_kind_t kind) * * @param string the string constant * @param border the border char - * @param skip number of chars to skip at the end */ -static void print_quoted_string(const string_t *const string, char border, - int skip) +static void print_quoted_string(const string_t *const string, char border) { + print_string(get_string_encoding_prefix(string->encoding)); + print_char(border); - const char *end = string->begin + string->size - skip; + const char *end = string->begin + string->size; for (const char *c = string->begin; c != end; ++c) { const char tc = *c; if (tc == border) { @@ -238,12 +214,9 @@ static void print_quoted_string(const string_t *const string, char border, print_char(border); } -static void print_string_literal(const string_literal_expression_t *literal) +static void print_string_literal(string_literal_expression_t const *const literal, char const delimiter) { - if (literal->base.kind == EXPR_WIDE_STRING_LITERAL) { - print_char('L'); - } - print_quoted_string(&literal->value, '"', 1); + print_quoted_string(&literal->value, delimiter); } static void print_literal(const literal_expression_t *literal) @@ -252,24 +225,13 @@ static void print_literal(const literal_expression_t *literal) case EXPR_LITERAL_MS_NOOP: print_string("__noop"); return; - case EXPR_LITERAL_INTEGER_HEXADECIMAL: - case EXPR_LITERAL_FLOATINGPOINT_HEXADECIMAL: - print_string("0x"); - /* FALLTHROUGH */ + case EXPR_LITERAL_BOOLEAN: - case EXPR_LITERAL_INTEGER: - case EXPR_LITERAL_INTEGER_OCTAL: case EXPR_LITERAL_FLOATINGPOINT: - print_stringrep(&literal->value); - if (literal->suffix.size > 0) - print_stringrep(&literal->suffix); - return; - case EXPR_LITERAL_WIDE_CHARACTER: - print_char('L'); - /* FALLTHROUGH */ - case EXPR_LITERAL_CHARACTER: - print_quoted_string(&literal->value, '\'', 0); + case EXPR_LITERAL_INTEGER: + print_string(literal->value.begin); return; + default: break; } @@ -314,10 +276,9 @@ static void print_call_expression(const call_expression_t *call) { print_expression_prec(call->function, PREC_POSTFIX); print_char('('); - char const *sep = ""; + separator_t sep = { "", ", " }; for (call_argument_t const *arg = call->arguments; arg; arg = arg->next) { - print_string(sep); - sep = ", "; + print_string(sep_next(&sep)); print_assignment_expression(arg->expression); } print_char(')'); @@ -382,16 +343,18 @@ static void print_unary_expression(const unary_expression_t *unexpr) { unsigned prec = get_expression_precedence(unexpr->base.kind); switch (unexpr->base.kind) { - case EXPR_UNARY_NEGATE: print_char ('-' ); break; - case EXPR_UNARY_PLUS: print_char ('+' ); break; - case EXPR_UNARY_NOT: print_char ('!' ); break; - case EXPR_UNARY_BITWISE_NEGATE: print_char ('~' ); break; - case EXPR_UNARY_PREFIX_INCREMENT: print_string("++"); break; - case EXPR_UNARY_PREFIX_DECREMENT: print_string("--"); break; - case EXPR_UNARY_DEREFERENCE: print_char ('*' ); break; - case EXPR_UNARY_TAKE_ADDRESS: print_char ('&' ); break; - case EXPR_UNARY_DELETE: print_string("delete "); break; + case EXPR_UNARY_NEGATE: print_char ('-' ); break; + case EXPR_UNARY_PLUS: print_char ('+' ); break; + case EXPR_UNARY_NOT: print_char ('!' ); break; + case EXPR_UNARY_COMPLEMENT: print_char ('~' ); break; + case EXPR_UNARY_PREFIX_INCREMENT: print_string("++"); break; + case EXPR_UNARY_PREFIX_DECREMENT: print_string("--"); break; + case EXPR_UNARY_DEREFERENCE: print_char ('*' ); break; + case EXPR_UNARY_TAKE_ADDRESS: print_char ('&' ); break; + case EXPR_UNARY_DELETE: print_string("delete "); break; case EXPR_UNARY_DELETE_ARRAY: print_string("delete [] "); break; + case EXPR_UNARY_REAL: print_string("__real__ "); break; + case EXPR_UNARY_IMAG: print_string("__imag__ "); break; case EXPR_UNARY_POSTFIX_INCREMENT: print_expression_prec(unexpr->value, prec); @@ -411,7 +374,6 @@ static void print_unary_expression(const unary_expression_t *unexpr) print_assignment_expression(unexpr->value); print_char(')'); return; - case EXPR_UNARY_THROW: if (unexpr->value == NULL) { print_string("throw"); @@ -473,11 +435,10 @@ static void print_array_expression(const array_access_expression_t *expression) */ static void print_typeprop_expression(const typeprop_expression_t *expression) { - if (expression->base.kind == EXPR_SIZEOF) { - print_string("sizeof"); - } else { - assert(expression->base.kind == EXPR_ALIGNOF); - print_string("__alignof__"); + switch (expression->base.kind) { + case EXPR_SIZEOF: print_string("sizeof"); break; + case EXPR_ALIGNOF: print_string(c_mode & _C11 ? "_Alignof" : "__alignof__"); break; + default: panic("invalid typeprop kind"); } if (expression->tp_expression != NULL) { /* PREC_TOP: always print the '()' here, sizeof x is right but unusual */ @@ -545,7 +506,7 @@ static void print_va_start(const va_start_expression_t *const expression) print_string("__builtin_va_start("); print_assignment_expression(expression->ap); print_string(", "); - print_string(expression->parameter->base.base.symbol->string); + print_assignment_expression(expression->parameter); print_char(')'); } @@ -623,6 +584,10 @@ static void print_designator(const designator_t *designator) if (designator->symbol == NULL) { print_char('['); print_expression(designator->array_index); + if (designator->range_last) { + print_string(" ... "); + print_expression(designator->range_last); + } print_char(']'); } else { print_char('.'); @@ -657,6 +622,33 @@ static void print_statement_expression(const statement_expression_t *expression) print_char(')'); } +static bool needs_parentheses(expression_t const *const expr, unsigned const top_prec) +{ + if (expr->base.parenthesized) + return true; + + if (top_prec > get_expression_precedence(expr->base.kind)) + return true; + + if (print_parenthesis && top_prec != PREC_BOTTOM) { + switch (expr->kind) { + case EXPR_ENUM_CONSTANT: + case EXPR_FUNCNAME: + case EXPR_LITERAL_CASES: + case EXPR_LITERAL_CHARACTER: + case EXPR_REFERENCE: + case EXPR_STRING_LITERAL: + /* Do not print () around subexpressions consisting of a single token. */ + return false; + + default: + return true; + } + } + + return false; +} + /** * Prints an expression with parenthesis if needed. * @@ -669,10 +661,7 @@ static void print_expression_prec(expression_t const *expr, unsigned const top_p expr = expr->unary.value; } - bool parenthesized = - expr->base.parenthesized || - (print_parenthesis && top_prec != PREC_BOTTOM) || - top_prec > get_expression_precedence(expr->base.kind); + bool const parenthesized = needs_parentheses(expr, top_prec); if (parenthesized) print_char('('); @@ -691,13 +680,13 @@ static void print_expression_prec(expression_t const *expr, unsigned const top_p case EXPR_FUNCNAME: print_funcname( &expr->funcname); break; case EXPR_LABEL_ADDRESS: print_label_address_expression(&expr->label_address); break; case EXPR_LITERAL_CASES: print_literal( &expr->literal); break; + case EXPR_LITERAL_CHARACTER: print_string_literal( &expr->string_literal, '\''); break; case EXPR_OFFSETOF: print_offsetof_expression( &expr->offsetofe); break; case EXPR_REFERENCE: - case EXPR_REFERENCE_ENUM_VALUE: print_reference_expression( &expr->reference); break; + case EXPR_ENUM_CONSTANT: print_reference_expression( &expr->reference); break; case EXPR_SELECT: print_select( &expr->select); break; case EXPR_STATEMENT: print_statement_expression( &expr->statement); break; - case EXPR_STRING_LITERAL: - case EXPR_WIDE_STRING_LITERAL: print_string_literal( &expr->string_literal); break; + case EXPR_STRING_LITERAL: print_string_literal( &expr->string_literal, '"'); break; case EXPR_UNARY_CASES: print_unary_expression( &expr->unary); break; case EXPR_VA_ARG: print_va_arg( &expr->va_arge); break; case EXPR_VA_COPY: print_va_copy( &expr->va_copye); break; @@ -950,19 +939,6 @@ static void print_declaration_statement( } } -/** - * Print a while statement. - * - * @param statement the statement - */ -static void print_while_statement(const while_statement_t *statement) -{ - print_string("while ("); - print_expression(statement->condition); - print_char(')'); - print_inner_statement(statement->body); -} - /** * Print a do-while statement. * @@ -985,28 +961,33 @@ static void print_do_while_statement(const do_while_statement_t *statement) */ static void print_for_statement(const for_statement_t *statement) { - print_string("for ("); - if (statement->initialisation != NULL) { - print_expression(statement->initialisation); + if (statement->initialisation || statement->scope.entities || !statement->condition || statement->step) { + print_string("for ("); + if (statement->initialisation != NULL) { + print_expression(statement->initialisation); + print_char(';'); + } else { + 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); + } + } + if (statement->condition != NULL) { + print_char(' '); + print_expression(statement->condition); + } print_char(';'); - } else { - 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); + if (statement->step != NULL) { + print_char(' '); + print_expression(statement->step); } - } - if (statement->condition != NULL) { - print_char(' '); + } else { + print_string("while ("); print_expression(statement->condition); } - print_char(';'); - if (statement->step != NULL) { - print_char(' '); - print_expression(statement->step); - } print_char(')'); print_inner_statement(statement->body); } @@ -1016,19 +997,17 @@ static void print_for_statement(const for_statement_t *statement) * * @param arguments the arguments */ -static void print_asm_arguments(asm_argument_t *arguments) -{ - asm_argument_t *argument = arguments; - for (; argument != NULL; argument = argument->next) { - if (argument != arguments) - print_string(", "); - - if (argument->symbol) { - print_format("[%s] ", argument->symbol->string); - } - print_quoted_string(&argument->constraints, '"', 1); +static void print_asm_arguments(asm_argument_t const *const arguments) +{ + print_string(" :"); + separator_t sep = { " ", ", " }; + for (asm_argument_t const *i = arguments; i; i = i->next) { + print_string(sep_next(&sep)); + if (i->symbol) + print_format("[%s] ", i->symbol->string); + print_quoted_string(&i->constraints, '"'); print_string(" ("); - print_expression(argument->expression); + print_expression(i->expression); print_char(')'); } } @@ -1038,49 +1017,50 @@ static void print_asm_arguments(asm_argument_t *arguments) * * @param clobbers the clobbers */ -static void print_asm_clobbers(asm_clobber_t *clobbers) +static void print_asm_clobbers(asm_clobber_t const *const clobbers) { - asm_clobber_t *clobber = clobbers; - for (; clobber != NULL; clobber = clobber->next) { - if (clobber != clobbers) - print_string(", "); + print_string(" :"); + separator_t sep = { " ", ", " }; + for (asm_clobber_t const *i = clobbers; i; i = i->next) { + print_string(sep_next(&sep)); + print_quoted_string(&i->clobber, '"'); + } +} - print_quoted_string(&clobber->clobber, '"', 1); +static void print_asm_labels(asm_label_t const *const labels) +{ + print_string(" :"); + separator_t sep = { " ", ", " }; + for (asm_label_t const *i = labels; i; i = i->next) { + print_string(sep_next(&sep)); + print_string(i->label->base.symbol->string); } } /** * Print an assembler statement. * - * @param statement the statement + * @param stmt the statement */ -static void print_asm_statement(const asm_statement_t *statement) +static void print_asm_statement(asm_statement_t const *const stmt) { - print_string("asm "); - if (statement->is_volatile) { - print_string("volatile "); - } + print_string("asm"); + if (stmt->is_volatile) print_string(" volatile"); + if (stmt->labels) print_string(" goto"); print_char('('); - print_quoted_string(&statement->asm_text, '"', 1); - if (statement->outputs == NULL && - statement->inputs == NULL && - statement->clobbers == NULL) - goto end_of_print_asm_statement; - - print_string(" : "); - print_asm_arguments(statement->outputs); - if (statement->inputs == NULL && statement->clobbers == NULL) - goto end_of_print_asm_statement; - - print_string(" : "); - print_asm_arguments(statement->inputs); - if (statement->clobbers == NULL) - goto end_of_print_asm_statement; - - print_string(" : "); - print_asm_clobbers(statement->clobbers); - -end_of_print_asm_statement: + print_quoted_string(&stmt->asm_text, '"'); + + unsigned const n = + stmt->labels ? 4 : + stmt->clobbers ? 3 : + stmt->inputs ? 2 : + stmt->outputs ? 1 : + 0; + if (n >= 1) print_asm_arguments(stmt->outputs); + if (n >= 2) print_asm_arguments(stmt->inputs); + if (n >= 3) print_asm_clobbers( stmt->clobbers); + if (n >= 4) print_asm_labels( stmt->labels); + print_string(");"); } @@ -1142,7 +1122,6 @@ void print_statement(statement_t const *const stmt) case STATEMENT_MS_TRY: print_ms_try_statement( &stmt->ms_try); break; case STATEMENT_RETURN: print_return_statement( &stmt->returns); break; case STATEMENT_SWITCH: print_switch_statement( &stmt->switchs); break; - case STATEMENT_WHILE: print_while_statement( &stmt->whiles); break; } } @@ -1177,13 +1156,12 @@ void print_initializer(const initializer_t *initializer) } switch (initializer->kind) { - case INITIALIZER_VALUE: { - const initializer_value_t *value = &initializer->value; - print_assignment_expression(value->value); + case INITIALIZER_STRING: + case INITIALIZER_VALUE: + print_assignment_expression(initializer->value.value); return; - } + case INITIALIZER_LIST: { - assert(initializer->kind == INITIALIZER_LIST); print_string("{ "); const initializer_list_t *list = &initializer->list; @@ -1198,12 +1176,7 @@ void print_initializer(const initializer_t *initializer) print_string(" }"); return; } - case INITIALIZER_STRING: - print_quoted_string(&initializer->string.string, '"', 1); - return; - case INITIALIZER_WIDE_STRING: - print_quoted_string(&initializer->string.string, '"', 1); - return; + case INITIALIZER_DESIGNATOR: print_designator(initializer->designator.designator); print_string(" = "); @@ -1224,26 +1197,20 @@ static void print_ms_modifiers(const declaration_t *declaration) decl_modifiers_t modifiers = declaration->modifiers; - bool ds_shown = false; - const char *next = "("; + separator_t sep = { "__declspec(", ", " }; if (declaration->base.kind == ENTITY_VARIABLE) { variable_t *variable = (variable_t*)declaration; if (variable->alignment != 0 || variable->get_property_sym != NULL || variable->put_property_sym != NULL) { - if (!ds_shown) { - print_string("__declspec"); - ds_shown = true; - } - if (variable->alignment != 0) { - print_string(next); next = ", "; print_format("align(%u)", variable->alignment); + print_format("%salign(%u)", sep_next(&sep), variable->alignment); } if (variable->get_property_sym != NULL || variable->put_property_sym != NULL) { char *comma = ""; - print_string(next); next = ", "; print_string("property("); + print_format("%sproperty(", sep_next(&sep)); if (variable->get_property_sym != NULL) { print_format("get=%s", variable->get_property_sym->string); comma = ", "; @@ -1257,52 +1224,48 @@ static void print_ms_modifiers(const declaration_t *declaration) /* DM_FORCEINLINE handled outside. */ if ((modifiers & ~DM_FORCEINLINE) != 0) { - if (!ds_shown) { - print_string("__declspec"); - ds_shown = true; - } if (modifiers & DM_DLLIMPORT) { - print_string(next); next = ", "; print_string("dllimport"); + print_format("%sdllimport", sep_next(&sep)); } if (modifiers & DM_DLLEXPORT) { - print_string(next); next = ", "; print_string("dllexport"); + print_format("%sdllexport", sep_next(&sep)); } if (modifiers & DM_THREAD) { - print_string(next); next = ", "; print_string("thread"); + print_format("%sthread", sep_next(&sep)); } if (modifiers & DM_NAKED) { - print_string(next); next = ", "; print_string("naked"); + print_format("%snaked", sep_next(&sep)); } if (modifiers & DM_THREAD) { - print_string(next); next = ", "; print_string("thread"); + print_format("%sthread", sep_next(&sep)); } if (modifiers & DM_SELECTANY) { - print_string(next); next = ", "; print_string("selectany"); + print_format("%sselectany", sep_next(&sep)); } if (modifiers & DM_NOTHROW) { - print_string(next); next = ", "; print_string("nothrow"); + print_format("%snothrow", sep_next(&sep)); } if (modifiers & DM_NORETURN) { - print_string(next); next = ", "; print_string("noreturn"); + print_format("%snoreturn", sep_next(&sep)); } if (modifiers & DM_NOINLINE) { - print_string(next); next = ", "; print_string("noinline"); + print_format("%snoinline", sep_next(&sep)); } if (modifiers & DM_DEPRECATED) { - print_string(next); next = ", "; print_string("deprecated"); + print_format("%sdeprecated", sep_next(&sep)); if (declaration->deprecated_string != NULL) print_format("(\"%s\")", declaration->deprecated_string); } if (modifiers & DM_RESTRICT) { - print_string(next); next = ", "; print_string("restrict"); + print_format("%srestrict", sep_next(&sep)); } if (modifiers & DM_NOALIAS) { - print_string(next); next = ", "; print_string("noalias"); + print_format("%snoalias", sep_next(&sep)); } } - if (ds_shown) + if (!sep_at_first(&sep)) print_string(") "); } #endif @@ -1362,9 +1325,9 @@ void print_declaration(const entity_t *entity) print_type_ext(entity->declaration.type, entity->base.symbol, &entity->function.parameters); - if (entity->function.statement != NULL) { + if (entity->function.body != NULL) { print_char('\n'); - print_indented_statement(entity->function.statement); + print_indented_statement(entity->function.body); print_char('\n'); return; } @@ -1372,7 +1335,7 @@ void print_declaration(const entity_t *entity) case ENTITY_VARIABLE: if (entity->variable.thread_local) - print_string("__thread "); + print_string(c_mode & _C11 ? "_Thread_local " : "__thread "); print_type_ext(declaration->type, declaration->base.symbol, NULL); if (entity->variable.initializer != NULL) { print_string(" = "); @@ -1492,7 +1455,6 @@ expression_classification_t is_constant_initializer(const initializer_t *initial { switch (initializer->kind) { case INITIALIZER_STRING: - case INITIALIZER_WIDE_STRING: case INITIALIZER_DESIGNATOR: return EXPR_CLASS_CONSTANT; @@ -1528,6 +1490,14 @@ static expression_classification_t is_object_with_linker_constant_address( case EXPR_UNARY_DEREFERENCE: return is_linker_constant(expression->unary.value); + case EXPR_COMPOUND_LITERAL: { + const compound_literal_expression_t *literal + = &expression->compound_literal; + return literal->global_scope || + ((literal->type->base.qualifiers & TYPE_QUALIFIER_CONST) + && is_constant_initializer(literal->initializer)); + } + case EXPR_SELECT: { type_t *base_type = skip_typeref(expression->select.compound->base.type); if (is_type_pointer(base_type)) { @@ -1578,7 +1548,6 @@ expression_classification_t is_linker_constant(const expression_t *expression) { switch (expression->kind) { case EXPR_STRING_LITERAL: - case EXPR_WIDE_STRING_LITERAL: case EXPR_FUNCNAME: case EXPR_LABEL_ADDRESS: return EXPR_CLASS_CONSTANT; @@ -1772,24 +1741,48 @@ static expression_classification_t is_object_with_constant_address(const express expression_classification_t is_constant_expression(const expression_t *expression) { switch (expression->kind) { - case EXPR_LITERAL_CASES: - case EXPR_CLASSIFY_TYPE: - case EXPR_OFFSETOF: - case EXPR_ALIGNOF: - case EXPR_BUILTIN_CONSTANT_P: + case EXPR_LITERAL_CHARACTER: case EXPR_BUILTIN_TYPES_COMPATIBLE_P: - case EXPR_REFERENCE_ENUM_VALUE: + case EXPR_ENUM_CONSTANT: + case EXPR_LITERAL_BOOLEAN: + case EXPR_LITERAL_MS_NOOP: return EXPR_CLASS_CONSTANT; - case EXPR_SIZEOF: { - type_t *const type = skip_typeref(expression->typeprop.type); - return - !is_type_array(type) || !type->array.is_vla ? EXPR_CLASS_CONSTANT : - EXPR_CLASS_VARIABLE; + { + type_t *type; + case EXPR_ALIGNOF: + type = skip_typeref(expression->typeprop.type); + goto check_type; + + case EXPR_CLASSIFY_TYPE: + type = skip_typeref(expression->classify_type.type_expression->base.type); + goto check_type; + + case EXPR_LITERAL_INTEGER: + case EXPR_LITERAL_FLOATINGPOINT: + type = skip_typeref(expression->base.type); + goto check_type; + + case EXPR_OFFSETOF: + type = skip_typeref(expression->offsetofe.type); + goto check_type; + + case EXPR_SIZEOF: + type = skip_typeref(expression->typeprop.type); + if (is_type_array(type) && type->array.is_vla) + return EXPR_CLASS_VARIABLE; + goto check_type; + +check_type: + return is_type_valid(type) ? EXPR_CLASS_CONSTANT : EXPR_CLASS_ERROR; + } + + case EXPR_BUILTIN_CONSTANT_P: { + expression_classification_t const c = is_constant_expression(expression->builtin_constant.value); + return c != EXPR_CLASS_ERROR ? EXPR_CLASS_CONSTANT : EXPR_CLASS_ERROR; } case EXPR_STRING_LITERAL: - case EXPR_WIDE_STRING_LITERAL: case EXPR_FUNCNAME: case EXPR_LABEL_ADDRESS: case EXPR_SELECT: @@ -1834,10 +1827,18 @@ expression_classification_t is_constant_expression(const expression_t *expressio case EXPR_UNARY_NEGATE: case EXPR_UNARY_PLUS: - case EXPR_UNARY_BITWISE_NEGATE: + case EXPR_UNARY_COMPLEMENT: case EXPR_UNARY_NOT: return is_constant_expression(expression->unary.value); + case EXPR_UNARY_IMAG: + case EXPR_UNARY_REAL: { + type_t *type = skip_typeref(expression->base.type); + if (!is_type_valid(type)) + return EXPR_CLASS_ERROR; + return is_constant_expression(expression->unary.value); + } + case EXPR_UNARY_CAST: { type_t *const type = skip_typeref(expression->base.type); if (is_type_scalar(type)) @@ -1914,7 +1915,7 @@ expression_classification_t is_constant_expression(const expression_t *expressio case EXPR_ERROR: return EXPR_CLASS_ERROR; } - panic("invalid expression found (is constant expression)"); + panic("invalid expression"); } void init_ast(void)