X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ast.c;h=36338a605717caa43e898910b364625aa7f96a66;hb=9fc5a3152558711a37406f79913f77cab1dc9db7;hp=e68aa1c59488d2eed1352c91769868bb2484e1fa;hpb=a71b896e451da9851aecbde5b5726304530f91f6;p=cparser diff --git a/ast.c b/ast.c index e68aa1c..36338a6 100644 --- a/ast.c +++ b/ast.c @@ -31,8 +31,10 @@ #include #include -#ifdef __INTEL_COMPILER +#if defined(__INTEL_COMPILER) #include +#elif defined(__CYGWIN__) +#include "win32/cygwin_math_ext.h" #else #include #endif @@ -259,7 +261,7 @@ static void print_quoted_string(const string_t *const string, char border, int s /* FALLTHROUGH */ default: if (!isprint(*c)) { - fprintf(out, "\\%03o", (unsigned)*c); + fprintf(out, "\\%03o", (unsigned)(unsigned char)*c); break; } fputc(*c, out); @@ -302,10 +304,10 @@ static void print_quoted_wide_string(const wide_string_t *const wstr, default: { const unsigned tc = *c; if (tc < 0x80U) { - if (!isprint(*c)) { - fprintf(out, "\\%03o", (char)*c); - } else { + if (isprint(*c)) { fputc(*c, out); + } else { + fprintf(out, "\\%03o", tc); } } else if (tc < 0x800) { fputc(0xC0 | (tc >> 6), out); @@ -382,6 +384,11 @@ static void print_compound_literal( print_initializer(expression->initializer); } +static void print_assignment_expression(const expression_t *const expr) +{ + print_expression_prec(expr, PREC_ASSIGNMENT); +} + /** * Prints a call expression. * @@ -400,7 +407,7 @@ static void print_call_expression(const call_expression_t *call) } else { first = 0; } - print_expression_prec(argument->expression, PREC_ASSIGNMENT); + print_assignment_expression(argument->expression); argument = argument->next; } @@ -493,7 +500,7 @@ static void print_unary_expression(const unary_expression_t *unexpr) break; case EXPR_UNARY_ASSUME: fputs("__assume(", out); - print_expression_prec(unexpr->value, PREC_ASSIGNMENT); + print_assignment_expression(unexpr->value); fputc(')', out); return; @@ -595,7 +602,7 @@ static void print_builtin_symbol(const builtin_symbol_expression_t *expression) static void print_builtin_constant(const builtin_constant_expression_t *expression) { fputs("__builtin_constant_p(", out); - print_expression_prec(expression->value, PREC_ASSIGNMENT); + print_assignment_expression(expression->value); fputc(')', out); } @@ -607,14 +614,14 @@ static void print_builtin_constant(const builtin_constant_expression_t *expressi static void print_builtin_prefetch(const builtin_prefetch_expression_t *expression) { fputs("__builtin_prefetch(", out); - print_expression_prec(expression->adr, PREC_ASSIGNMENT); + print_assignment_expression(expression->adr); if (expression->rw) { fputc(',', out); - print_expression_prec(expression->rw, PREC_ASSIGNMENT); + print_assignment_expression(expression->rw); } if (expression->locality) { fputc(',', out); - print_expression_prec(expression->locality, PREC_ASSIGNMENT); + print_assignment_expression(expression->locality); } fputc(')', out); } @@ -646,7 +653,7 @@ static void print_conditional(const conditional_expression_t *expression) static void print_va_start(const va_start_expression_t *const expression) { fputs("__builtin_va_start(", out); - print_expression_prec(expression->ap, PREC_ASSIGNMENT); + print_assignment_expression(expression->ap); fputs(", ", out); fputs(expression->parameter->base.base.symbol->string, out); fputc(')', out); @@ -660,7 +667,7 @@ static void print_va_start(const va_start_expression_t *const expression) static void print_va_arg(const va_arg_expression_t *expression) { fputs("__builtin_va_arg(", out); - print_expression_prec(expression->ap, PREC_ASSIGNMENT); + print_assignment_expression(expression->ap); fputs(", ", out); print_type(expression->base.type); fputc(')', out); @@ -692,7 +699,7 @@ static void print_classify_type_expression( const classify_type_expression_t *const expr) { fputs("__builtin_classify_type(", out); - print_expression_prec(expr->type_expression, PREC_ASSIGNMENT); + print_assignment_expression(expr->type_expression); fputc(')', out); } @@ -753,10 +760,13 @@ static void print_expression_prec(const expression_t *expression, unsigned top_p if (expression->kind == EXPR_UNARY_CAST_IMPLICIT && !print_implicit_casts) { expression = expression->unary.value; } - unsigned prec = get_expression_precedence(expression->base.kind); - if (print_parenthesis && top_prec != PREC_BOTTOM) - top_prec = PREC_TOP; - if (top_prec > prec) + + bool parenthesized = + expression->base.parenthesized || + (print_parenthesis && top_prec != PREC_BOTTOM) || + top_prec > get_expression_precedence(expression->base.kind); + + if (parenthesized) fputc('(', out); switch (expression->kind) { case EXPR_UNKNOWN: @@ -843,7 +853,7 @@ static void print_expression_prec(const expression_t *expression, unsigned top_p fprintf(out, "some expression of type %d", (int)expression->kind); break; } - if (top_prec > prec) + if (parenthesized) fputc(')', out); } @@ -869,7 +879,7 @@ static void print_compound_statement(const compound_statement_t *block) } --indent; print_indent(); - fputs("}\n", out); + fputs(block->stmt_expr ? "}" : "}\n", out); } /** @@ -879,10 +889,14 @@ static void print_compound_statement(const compound_statement_t *block) */ static void print_return_statement(const return_statement_t *statement) { - fputs("return ", out); - if (statement->value != NULL) - print_expression(statement->value); - fputs(";\n", out); + expression_t const *const val = statement->value; + if (val != NULL) { + fputs("return ", out); + print_expression(val); + fputs(";\n", out); + } else { + fputs("return;\n", out); + } } /** @@ -985,30 +999,11 @@ static void print_case_label(const case_label_statement_t *statement) } } -static void print_local_label(const local_label_statement_t *statement) -{ - fputs("__label__ ", out); - - bool first = true; - entity_t *entity = statement->labels_begin; - for (; - entity != statement->labels_end->base.next; - entity = entity->base.next) { - if (!first) { - fputs(", ", out); - } else { - first = false; - } - fputs(entity->base.symbol->string, out); - } - fputs(";\n", out); -} - static void print_typedef(const entity_t *entity) { fputs("typedef ", out); print_type_ext(entity->typedefe.type, entity->base.symbol, NULL); - fputs(";", out); + fputc(';', out); } /** @@ -1036,10 +1031,14 @@ static void print_declaration_statement( { bool first = true; entity_t *entity = statement->declarations_begin; - for (; - entity != statement->declarations_end->base.next; - entity = entity->base.next) { - if (!is_declaration(entity) && entity->kind != ENTITY_TYPEDEF) + if (entity == NULL) { + fputs("/* empty declaration statement */\n", out); + return; + } + + entity_t *const end = statement->declarations_end->base.next; + for (; entity != end; entity = entity->base.next) { + if (entity->kind == ENTITY_ENUM_VALUE) continue; if (is_generated_entity(entity)) continue; @@ -1050,13 +1049,7 @@ static void print_declaration_statement( first = false; } - if (entity->kind == ENTITY_TYPEDEF) { - print_typedef(entity); - } else { - assert(is_declaration(entity)); - print_declaration(entity); - } - + print_entity(entity); fputc('\n', out); } } @@ -1108,18 +1101,19 @@ static void print_for_statement(const for_statement_t *statement) if (entity->base.next != NULL) { panic("multiple declarations in for statement not supported yet"); } - fputc(' ', out); } else { if (statement->initialisation) { print_expression(statement->initialisation); } - fputs("; ", out); + fputc(';', out); } if (statement->condition != NULL) { + fputc(' ', out); print_expression(statement->condition); } - fputs("; ", out); + fputc(';', out); if (statement->step != NULL) { + fputc(' ', out); print_expression(statement->step); } fputs(") ", out); @@ -1253,9 +1247,6 @@ void print_statement(const statement_t *statement) case STATEMENT_LABEL: print_label_statement(&statement->label); break; - case STATEMENT_LOCAL_LABEL: - print_local_label(&statement->local_label); - break; case STATEMENT_GOTO: print_goto_statement(&statement->gotos); break; @@ -1308,16 +1299,15 @@ void print_statement(const statement_t *statement) */ static void print_storage_class(storage_class_tag_t storage_class) { - const char *text; switch (storage_class) { case STORAGE_CLASS_NONE: return; - case STORAGE_CLASS_TYPEDEF: text = "typedef "; break; - case STORAGE_CLASS_EXTERN: text = "extern "; break; - case STORAGE_CLASS_STATIC: text = "static "; break; - case STORAGE_CLASS_AUTO: text = "auto "; break; - case STORAGE_CLASS_REGISTER: text = "register "; break; + case STORAGE_CLASS_TYPEDEF: fputs("typedef ", out); return; + case STORAGE_CLASS_EXTERN: fputs("extern ", out); return; + case STORAGE_CLASS_STATIC: fputs("static ", out); return; + case STORAGE_CLASS_AUTO: fputs("auto ", out); return; + case STORAGE_CLASS_REGISTER: fputs("register ", out); return; } - fputs(text, out); + panic("invalid storage class"); } /** @@ -1335,7 +1325,7 @@ void print_initializer(const initializer_t *initializer) switch (initializer->kind) { case INITIALIZER_VALUE: { const initializer_value_t *value = &initializer->value; - print_expression(value->value); + print_assignment_expression(value->value); return; } case INITIALIZER_LIST: { @@ -1601,9 +1591,11 @@ void print_entity(const entity_t *entity) case ENTITY_NAMESPACE: print_namespace(&entity->namespacee); return; + case ENTITY_LOCAL_LABEL: + fprintf(out, "__label__ %s;", entity->base.symbol->string); + return; case ENTITY_LABEL: case ENTITY_ENUM_VALUE: - case ENTITY_LOCAL_LABEL: panic("print_entity used on unexpected entity type"); case ENTITY_INVALID: break; @@ -1935,8 +1927,6 @@ bool is_constant_expression(const expression_t *expression) case EXPR_BINARY_BITWISE_AND: case EXPR_BINARY_BITWISE_OR: case EXPR_BINARY_BITWISE_XOR: - case EXPR_BINARY_LOGICAL_AND: - case EXPR_BINARY_LOGICAL_OR: case EXPR_BINARY_SHIFTLEFT: case EXPR_BINARY_SHIFTRIGHT: case EXPR_BINARY_ISGREATER: @@ -1948,6 +1938,24 @@ bool is_constant_expression(const expression_t *expression) return is_constant_expression(expression->binary.left) && is_constant_expression(expression->binary.right); + case EXPR_BINARY_LOGICAL_AND: { + expression_t const *const left = expression->binary.left; + if (!is_constant_expression(left)) + return false; + if (fold_constant(left) == 0) + return true; + return is_constant_expression(expression->binary.right); + } + + case EXPR_BINARY_LOGICAL_OR: { + expression_t const *const left = expression->binary.left; + if (!is_constant_expression(left)) + return false; + if (fold_constant(left) != 0) + return true; + return is_constant_expression(expression->binary.right); + } + case EXPR_COMPOUND_LITERAL: return is_constant_initializer(expression->compound_literal.initializer);