X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast.c;h=ac8caeb63bb3607af5832a2eb63bed99a1efd457;hb=18a1fc944eceff05ebdc0f6baab33db346cdf0a8;hp=7d84d0b451e0e76956284897ed2ea49d3875a3ed;hpb=07611ee0ac745341d7d8ea4874b1cba13df0abab;p=cparser diff --git a/ast.c b/ast.c index 7d84d0b..ac8caeb 100644 --- a/ast.c +++ b/ast.c @@ -31,13 +31,16 @@ #include #include -#ifdef __INTEL_COMPILER +#if defined(__INTEL_COMPILER) #include +#elif defined(__CYGWIN__) +#include "win32/cygwin_math_ext.h" #else #include #endif #include "adt/error.h" +#include "adt/util.h" struct obstack ast_obstack; @@ -92,90 +95,90 @@ 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_CHARACTER_CONSTANT] = PREC_PRIMARY, - [EXPR_WIDE_CHARACTER_CONSTANT] = PREC_PRIMARY, - [EXPR_CONST] = 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_SYMBOL] = PREC_PRIMARY, - [EXPR_BUILTIN_CONSTANT_P] = PREC_PRIMARY, - [EXPR_BUILTIN_PREFETCH] = PREC_PRIMARY, - [EXPR_OFFSETOF] = PREC_PRIMARY, - [EXPR_VA_START] = PREC_PRIMARY, - [EXPR_VA_ARG] = 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_CAST_IMPLICIT] = 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_UNKNOWN] = PREC_PRIMARY, + [EXPR_INVALID] = PREC_PRIMARY, + [EXPR_REFERENCE] = PREC_PRIMARY, + [EXPR_REFERENCE_ENUM_VALUE] = PREC_PRIMARY, + [EXPR_CHARACTER_CONSTANT] = PREC_PRIMARY, + [EXPR_WIDE_CHARACTER_CONSTANT] = PREC_PRIMARY, + [EXPR_CONST] = 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_SYMBOL] = 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_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_CAST_IMPLICIT] = 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 }; - assert((unsigned)kind < (sizeof(prec)/sizeof(prec[0]))); + assert((size_t)kind < lengthof(prec)); unsigned res = prec[kind]; assert(res != PREC_BOTTOM); @@ -239,10 +242,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 +262,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 +306,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 +386,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 +409,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 +502,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; @@ -566,10 +575,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); @@ -595,27 +602,22 @@ 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); } /** - * Prints a builtin prefetch expression. + * Prints a builtin types compatible expression. * - * @param expression the builtin prefetch expression + * @param expression the builtin types compatible expression */ -static void print_builtin_prefetch(const builtin_prefetch_expression_t *expression) +static void print_builtin_types_compatible( + const builtin_types_compatible_expression_t *expression) { - fputs("__builtin_prefetch(", out); - print_expression_prec(expression->adr, PREC_ASSIGNMENT); - if (expression->rw) { - fputc(',', out); - print_expression_prec(expression->rw, PREC_ASSIGNMENT); - } - if (expression->locality) { - fputc(',', out); - print_expression_prec(expression->locality, PREC_ASSIGNMENT); - } + fputs("__builtin_types_compatible_p(", out); + print_type(expression->left); + fputs(", ", out); + print_type(expression->right); fputc(')', out); } @@ -646,7 +648,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 +662,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 +694,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 +755,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: @@ -813,8 +818,8 @@ static void print_expression_prec(const expression_t *expression, unsigned top_p case EXPR_BUILTIN_CONSTANT_P: print_builtin_constant(&expression->builtin_constant); break; - case EXPR_BUILTIN_PREFETCH: - print_builtin_prefetch(&expression->builtin_prefetch); + case EXPR_BUILTIN_TYPES_COMPATIBLE_P: + print_builtin_types_compatible(&expression->builtin_types_compatible); break; case EXPR_CONDITIONAL: print_conditional(&expression->conditional); @@ -843,7 +848,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 +874,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 +994,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 +1033,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 +1044,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); } } @@ -1105,29 +1085,25 @@ 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"); - } - fputc(' ', out); + 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); } - fputs("; ", 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 +1237,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 +1289,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 +1315,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: { @@ -1573,8 +1545,6 @@ void print_entity(const entity_t *entity) case ENTITY_VARIABLE: case ENTITY_PARAMETER: case ENTITY_COMPOUND_MEMBER: - print_declaration(entity); - return; case ENTITY_FUNCTION: print_declaration(entity); return; @@ -1609,9 +1579,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; @@ -1866,6 +1838,7 @@ bool is_constant_expression(const expression_t *expression) case EXPR_OFFSETOF: case EXPR_ALIGNOF: case EXPR_BUILTIN_CONSTANT_P: + case EXPR_BUILTIN_TYPES_COMPATIBLE_P: case EXPR_LABEL_ADDRESS: case EXPR_REFERENCE_ENUM_VALUE: return true; @@ -1882,7 +1855,6 @@ bool is_constant_expression(const expression_t *expression) } case EXPR_BUILTIN_SYMBOL: - case EXPR_BUILTIN_PREFETCH: case EXPR_SELECT: case EXPR_VA_START: case EXPR_VA_ARG: @@ -1943,8 +1915,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 +1926,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); @@ -1965,10 +1953,12 @@ bool is_constant_expression(const expression_t *expression) return false; long val = fold_constant(condition); - if (val != 0) - return is_constant_expression(expression->conditional.true_expression); - else + if (val != 0) { + expression_t const *const t = expression->conditional.true_expression; + return t == NULL || is_constant_expression(t); + } else { return is_constant_expression(expression->conditional.false_expression); + } } case EXPR_INVALID: