X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast.c;h=e25d2446d531cde7173e3e7ddb65e40e4d90d473;hb=6731ea31e05b733e558c3daeb6817e7b2737e803;hp=7d84d0b451e0e76956284897ed2ea49d3875a3ed;hpb=07611ee0ac745341d7d8ea4874b1cba13df0abab;p=cparser diff --git a/ast.c b/ast.c index 7d84d0b..e25d244 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 @@ -239,10 +241,11 @@ static void print_quoted_string(const string_t *const string, char border, int s fputc(border, out); const char *end = string->begin + string->size - skip; for (const char *c = string->begin; c != end; ++c) { - if (*c == border) { + unsigned char const tc = *c; + if (tc == border) { fputc('\\', out); } - switch (*c) { + switch (tc) { case '\\': fputs("\\\\", out); break; case '\a': fputs("\\a", out); break; case '\b': fputs("\\b", out); break; @@ -258,11 +261,11 @@ static void print_quoted_string(const string_t *const string, char border, int s } /* FALLTHROUGH */ default: - if (!isprint(*c)) { - fprintf(out, "\\%03o", (unsigned)*c); - break; + if (tc < 0x80 && !isprint(tc)) { + fprintf(out, "\\%03o", (unsigned)tc); + } else { + fputc(tc, out); } - fputc(*c, out); break; } } @@ -302,10 +305,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 +385,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 +408,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 +501,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 +603,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 +615,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 +654,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 +668,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 +700,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 +761,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 +854,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 +880,7 @@ static void print_compound_statement(const compound_statement_t *block) } --indent; print_indent(); - fputs("}\n", out); + fputs(block->stmt_expr ? "}" : "}\n", out); } /** @@ -989,25 +1000,6 @@ 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); @@ -1047,7 +1039,7 @@ static void print_declaration_statement( entity_t *const end = statement->declarations_end->base.next; for (; entity != end; entity = entity->base.next) { - if (!is_declaration(entity) && entity->kind != ENTITY_TYPEDEF) + if (entity->kind == ENTITY_ENUM_VALUE) continue; if (is_generated_entity(entity)) continue; @@ -1058,13 +1050,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); } } @@ -1116,18 +1102,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); @@ -1261,9 +1248,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; @@ -1316,16 +1300,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"); } /** @@ -1343,7 +1326,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: { @@ -1609,9 +1592,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; @@ -1943,8 +1928,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: @@ -1956,6 +1939,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);