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_LITERAL_INTEGER] = PREC_PRIMARY,
static void print_select(const select_expression_t *expression)
{
print_expression_prec(expression->compound, PREC_POSTFIX);
+ /* do not print anything for anonymous struct/union selects
+ * FIXME: if the anonymous select was a '->' this will print '.'
+ */
+ if (expression->compound_entry->base.symbol == NULL)
+ return;
+
if (is_type_pointer(skip_typeref(expression->compound->base.type))) {
print_string("->");
} else {
if (parenthesized)
print_string("(");
switch (expression->kind) {
- case EXPR_UNKNOWN:
- case EXPR_INVALID:
- print_string("$invalid expression$");
+ case EXPR_ERROR:
+ print_string("$error$");
break;
case EXPR_WIDE_STRING_LITERAL:
case EXPR_STRING_LITERAL:
case EXPR_STATEMENT:
print_statement_expression(&expression->statement);
break;
-
-#if 0
- default:
- /* TODO */
- print_format("some expression of type %d", (int)expression->kind);
- break;
-#endif
}
if (parenthesized)
print_string(")");
case STATEMENT_LEAVE:
print_leave_statement(&statement->leave);
break;
- case STATEMENT_INVALID:
- print_string("$invalid statement$\n");
+ case STATEMENT_ERROR:
+ print_string("$error statement$\n");
break;
}
}
case ENTITY_LABEL:
case ENTITY_ENUM_VALUE:
panic("print_entity used on unexpected entity type");
- case ENTITY_INVALID:
- break;
}
panic("Invalid entity type encountered");
}
return EXPR_CLASS_CONSTANT;
case INITIALIZER_VALUE:
- return is_constant_expression(initializer->value.value);
+ return is_linker_constant(initializer->value.value);
case INITIALIZER_LIST: {
expression_classification_t all = EXPR_CLASS_CONSTANT;
return EXPR_CLASS_VARIABLE;
}
- case EXPR_INVALID:
+ case EXPR_ERROR:
return EXPR_CLASS_ERROR;
default:
case EXPR_LABEL_ADDRESS:
return EXPR_CLASS_CONSTANT;
+ case EXPR_COMPOUND_LITERAL:
+ return is_constant_initializer(expression->compound_literal.initializer);
+
case EXPR_UNARY_TAKE_ADDRESS:
return is_object_with_linker_constant_address(expression->unary.value);
!(get_atomic_type_flags(dest->atomic.akind) & ATOMIC_TYPE_FLAG_INTEGER) ||
get_atomic_type_size(dest->atomic.akind) < get_type_size(type_void_ptr)
))
- return EXPR_CLASS_VARIABLE;
+ return is_constant_expression(expression);
- expression_classification_t const expr = is_constant_expression(expression->unary.value);
- expression_classification_t const addr = is_linker_constant(expression->unary.value);
- return expr > addr ? expr : addr;
+ return is_linker_constant(expression->unary.value);
}
case EXPR_BINARY_ADD:
} else if (!is_type_valid(ltype) || !is_type_valid(rtype)) {
return EXPR_CLASS_ERROR;
} else {
- return EXPR_CLASS_VARIABLE;
+ return is_constant_expression(expression);
}
}
skip_typeref(revert_automatic_type_conversion(expression));
if (!is_type_array(type))
return EXPR_CLASS_VARIABLE;
- expression_classification_t const ref = is_linker_constant(expression->array_access.array_ref);
- expression_classification_t const idx = is_constant_expression(expression->array_access.index);
- return ref < idx ? ref : idx;
+ return is_linker_constant(expression->array_access.array_ref);
}
case EXPR_CONDITIONAL: {
return EXPR_CLASS_VARIABLE;
}
- case EXPR_INVALID:
- return EXPR_CLASS_ERROR;
-
default:
- return EXPR_CLASS_VARIABLE;
+ return is_constant_expression(expression);
}
}
return EXPR_CLASS_VARIABLE;
switch (ref->entity->function.btk) {
- case bk_gnu_builtin_huge_val:
- case bk_gnu_builtin_huge_valf:
- case bk_gnu_builtin_huge_vall:
- 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:
+ case BUILTIN_INF:
+ case BUILTIN_NAN:
return EXPR_CLASS_CONSTANT;
default:
return EXPR_CLASS_VARIABLE;
case EXPR_UNARY_DEREFERENCE:
return is_constant_pointer(expression->unary.value);
- case EXPR_INVALID:
+ case EXPR_ERROR:
return EXPR_CLASS_ERROR;
default:
}
}
- case EXPR_INVALID:
+ case EXPR_ERROR:
return EXPR_CLASS_ERROR;
-
- case EXPR_UNKNOWN:
- break;
}
panic("invalid expression found (is constant expression)");
}