static int indent;
-/** If set, implicit casts are printed. */
bool print_implicit_casts = false;
-
-/** If set parenthesis are printed to indicate operator precedence. */
bool print_parenthesis = false;
static void print_statement(const statement_t *statement);
print_string("\t");
}
-static void print_symbol(const symbol_t *symbol)
-{
- print_string(symbol->string);
-}
-
static void print_stringrep(const string_t *string)
{
for (size_t i = 0; i < string->size; ++i) {
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,
[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,
print_char(border);
const char *end = string->begin + string->size - skip;
for (const char *c = string->begin; c != end; ++c) {
- unsigned char const tc = *c;
+ const char tc = *c;
if (tc == border) {
print_string("\\");
}
}
/* FALLTHROUGH */
default:
- if (tc < 0x80 && !isprint(tc)) {
+ if ((unsigned)tc < 0x80 && !isprint(tc)) {
print_format("\\%03o", (unsigned)tc);
} else {
print_char(tc);
case EXPR_LITERAL_INTEGER_OCTAL:
case EXPR_LITERAL_FLOATINGPOINT:
print_stringrep(&literal->value);
- if (literal->suffix != NULL)
- print_symbol(literal->suffix);
+ if (literal->suffix.size > 0)
+ print_stringrep(&literal->suffix);
return;
case EXPR_LITERAL_WIDE_CHARACTER:
print_char('L');
print_expression_prec(unexpr->value, prec);
print_string("--");
return;
- case EXPR_UNARY_CAST_IMPLICIT:
case EXPR_UNARY_CAST:
print_string("(");
print_type(unexpr->base.type);
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 {
*/
static void print_expression_prec(const expression_t *expression, unsigned top_prec)
{
- if (expression->kind == EXPR_UNARY_CAST_IMPLICIT && !print_implicit_casts) {
+ if (expression->kind == EXPR_UNARY_CAST
+ && expression->base.implicit && !print_implicit_casts) {
expression = expression->unary.value;
}
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;
}
}
}
break;
+ case ENTITY_COMPOUND_MEMBER:
+ print_type_ext(declaration->type, declaration->base.symbol, NULL);
+ if (entity->compound_member.bitfield) {
+ print_format(" : %u", entity->compound_member.bit_size);
+ }
+ break;
+
default:
print_type_ext(declaration->type, declaration->base.symbol, NULL);
break;
return;
case ENTITY_STRUCT:
print_string("struct ");
- print_string(entity->base.symbol->string);
- if (entity->structe.complete) {
- print_string(" ");
- print_compound_definition(&entity->structe);
- }
- print_string(";");
- return;
+ goto print_compound;
case ENTITY_UNION:
print_string("union ");
+print_compound:
print_string(entity->base.symbol->string);
- if (entity->unione.complete) {
+ if (entity->compound.complete) {
print_string(" ");
- print_compound_definition(&entity->unione);
+ print_compound_definition(&entity->compound);
}
print_string(";");
return;
case ENTITY_LABEL:
case ENTITY_ENUM_VALUE:
panic("print_entity used on unexpected entity type");
- case ENTITY_INVALID:
- break;
}
panic("Invalid entity type encountered");
}
}
}
-bool is_constant_initializer(const initializer_t *initializer)
+expression_classification_t is_constant_initializer(const initializer_t *initializer)
{
switch (initializer->kind) {
case INITIALIZER_STRING:
case INITIALIZER_WIDE_STRING:
case INITIALIZER_DESIGNATOR:
- return true;
+ return EXPR_CLASS_CONSTANT;
case INITIALIZER_VALUE:
- return is_constant_expression(initializer->value.value);
+ return is_linker_constant(initializer->value.value);
- case INITIALIZER_LIST:
+ case INITIALIZER_LIST: {
+ expression_classification_t all = EXPR_CLASS_CONSTANT;
for (size_t i = 0; i < initializer->list.len; ++i) {
initializer_t *sub_initializer = initializer->list.initializers[i];
- if (!is_constant_initializer(sub_initializer))
- return false;
+ expression_classification_t const cur = is_constant_initializer(sub_initializer);
+ if (all > cur) {
+ all = cur;
+ }
}
- return true;
+ return all;
+ }
}
panic("invalid initializer kind found");
}
-static bool is_object_with_linker_constant_address(const expression_t *expression)
+/**
+ * Checks if an expression references an object with a constant/known location
+ * to the linker. Example:
+ * - "x", "*&x" with x being a global variable. The value of x need not be
+ * constant but the address of x is.
+ * - "a.b.c" when a has a constant/known location to the linker
+ */
+static expression_classification_t is_object_with_linker_constant_address(
+ const expression_t *expression)
{
switch (expression->kind) {
case EXPR_UNARY_DEREFERENCE:
- return is_address_constant(expression->unary.value);
+ return is_linker_constant(expression->unary.value);
case EXPR_SELECT: {
type_t *base_type = skip_typeref(expression->select.compound->base.type);
if (is_type_pointer(base_type)) {
/* it's a -> */
- return is_address_constant(expression->select.compound);
+ return is_linker_constant(expression->select.compound);
} else {
return is_object_with_linker_constant_address(expression->select.compound);
}
}
- case EXPR_ARRAY_ACCESS:
- return is_constant_expression(expression->array_access.index)
- && is_address_constant(expression->array_access.array_ref);
+ case EXPR_ARRAY_ACCESS: {
+ 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;
+ }
case EXPR_REFERENCE: {
entity_t *entity = expression->reference.entity;
- if (is_declaration(entity)) {
- switch ((storage_class_tag_t)entity->declaration.storage_class) {
- case STORAGE_CLASS_NONE:
- case STORAGE_CLASS_EXTERN:
- case STORAGE_CLASS_STATIC:
- return
- entity->kind != ENTITY_VARIABLE ||
- !entity->variable.thread_local;
-
- case STORAGE_CLASS_REGISTER:
- case STORAGE_CLASS_TYPEDEF:
- case STORAGE_CLASS_AUTO:
- break;
- }
+ if (!is_declaration(entity))
+ return EXPR_CLASS_VARIABLE;
+
+ switch ((storage_class_tag_t)entity->declaration.storage_class) {
+ case STORAGE_CLASS_NONE:
+ case STORAGE_CLASS_EXTERN:
+ case STORAGE_CLASS_STATIC:
+ return
+ entity->kind != ENTITY_VARIABLE ||
+ !entity->variable.thread_local ? EXPR_CLASS_CONSTANT :
+ EXPR_CLASS_VARIABLE;
+
+ case STORAGE_CLASS_REGISTER:
+ case STORAGE_CLASS_TYPEDEF:
+ case STORAGE_CLASS_AUTO:
+ break;
}
- return false;
+ return EXPR_CLASS_VARIABLE;
}
+ case EXPR_ERROR:
+ return EXPR_CLASS_ERROR;
+
default:
- return false;
+ return EXPR_CLASS_VARIABLE;
}
}
-bool is_address_constant(const expression_t *expression)
+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 true;
+ 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);
= revert_automatic_type_conversion(expression->unary.value);
/* dereferencing a function is a NOP */
if (is_type_function(real_type)) {
- return is_address_constant(expression->unary.value);
+ return is_linker_constant(expression->unary.value);
}
/* FALLTHROUGH */
}
case EXPR_UNARY_CAST: {
type_t *dest = skip_typeref(expression->base.type);
if (!is_type_pointer(dest) && (
- dest->kind != TYPE_ATOMIC ||
- !(get_atomic_type_flags(dest->atomic.akind) & ATOMIC_TYPE_FLAG_INTEGER) ||
- get_atomic_type_size(dest->atomic.akind) < get_atomic_type_size(get_intptr_kind())
+ dest->kind != TYPE_ATOMIC ||
+ !(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 false;
+ return is_constant_expression(expression);
- return (is_constant_expression(expression->unary.value)
- || is_address_constant(expression->unary.value));
+ return is_linker_constant(expression->unary.value);
}
case EXPR_BINARY_ADD:
case EXPR_BINARY_SUB: {
- expression_t *left = expression->binary.left;
- expression_t *right = expression->binary.right;
-
- if (is_type_pointer(skip_typeref(left->base.type))) {
- return is_address_constant(left) && is_constant_expression(right);
- } else if (is_type_pointer(skip_typeref(right->base.type))) {
- return is_constant_expression(left) && is_address_constant(right);
+ expression_t *const left = expression->binary.left;
+ expression_t *const right = expression->binary.right;
+ type_t *const ltype = skip_typeref(left->base.type);
+ type_t *const rtype = skip_typeref(right->base.type);
+
+ if (is_type_pointer(ltype)) {
+ expression_classification_t const l = is_linker_constant(left);
+ expression_classification_t const r = is_constant_expression(right);
+ return l < r ? l : r;
+ } else if (is_type_pointer(rtype)) {
+ expression_classification_t const l = is_constant_expression(left);
+ expression_classification_t const r = is_linker_constant(right);
+ return l < r ? l : r;
+ } else if (!is_type_valid(ltype) || !is_type_valid(rtype)) {
+ return EXPR_CLASS_ERROR;
+ } else {
+ return is_constant_expression(expression);
}
-
- return false;
}
case EXPR_REFERENCE: {
entity_t *entity = expression->reference.entity;
if (!is_declaration(entity))
- return false;
+ return EXPR_CLASS_VARIABLE;
type_t *type = skip_typeref(entity->declaration.type);
if (is_type_function(type))
- return true;
+ return EXPR_CLASS_CONSTANT;
if (is_type_array(type)) {
return is_object_with_linker_constant_address(expression);
}
/* Prevent stray errors */
if (!is_type_valid(type))
- return true;
- return false;
+ return EXPR_CLASS_ERROR;
+ return EXPR_CLASS_VARIABLE;
}
case EXPR_ARRAY_ACCESS: {
type_t *const type =
skip_typeref(revert_automatic_type_conversion(expression));
- return
- is_type_array(type) &&
- is_constant_expression(expression->array_access.index) &&
- is_address_constant(expression->array_access.array_ref);
+ if (!is_type_array(type))
+ return EXPR_CLASS_VARIABLE;
+ return is_linker_constant(expression->array_access.array_ref);
}
case EXPR_CONDITIONAL: {
expression_t *const c = expression->conditional.condition;
- if (!is_constant_expression(c))
- return false;
+ expression_classification_t const cclass = is_constant_expression(c);
+ if (cclass != EXPR_CLASS_CONSTANT)
+ return cclass;
if (fold_constant_to_bool(c)) {
expression_t const *const t = expression->conditional.true_expression;
- return is_address_constant(t != NULL ? t : c);
+ return is_linker_constant(t != NULL ? t : c);
} else {
- return is_address_constant(expression->conditional.false_expression);
+ return is_linker_constant(expression->conditional.false_expression);
}
}
+ case EXPR_SELECT: {
+ entity_t *entity = expression->select.compound_entry;
+ if (!is_declaration(entity))
+ return EXPR_CLASS_VARIABLE;
+ type_t *type = skip_typeref(entity->declaration.type);
+ if (is_type_array(type)) {
+ /* arrays automatically convert to their address */
+ expression_t *compound = expression->select.compound;
+ type_t *base_type = skip_typeref(compound->base.type);
+ if (is_type_pointer(base_type)) {
+ /* it's a -> */
+ return is_linker_constant(compound);
+ } else {
+ return is_object_with_linker_constant_address(compound);
+ }
+ }
+ return EXPR_CLASS_VARIABLE;
+ }
+
default:
- return false;
+ return is_constant_expression(expression);
}
}
* Check if the given expression is a call to a builtin function
* returning a constant result.
*/
-static bool is_builtin_const_call(const expression_t *expression)
+static expression_classification_t is_builtin_const_call(const expression_t *expression)
{
expression_t *function = expression->call.function;
if (function->kind != EXPR_REFERENCE)
- return false;
+ return EXPR_CLASS_VARIABLE;
reference_expression_t *ref = &function->reference;
if (ref->entity->kind != ENTITY_FUNCTION)
- return false;
+ 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:
- return true;
+ case BUILTIN_INF:
+ case BUILTIN_NAN:
+ return EXPR_CLASS_CONSTANT;
default:
- return false;
+ return EXPR_CLASS_VARIABLE;
}
}
-static bool is_constant_pointer(const expression_t *expression)
+static expression_classification_t is_constant_pointer(const expression_t *expression)
{
- if (is_constant_expression(expression))
- return true;
+ expression_classification_t const expr_class = is_constant_expression(expression);
+ if (expr_class != EXPR_CLASS_VARIABLE)
+ return expr_class;
switch (expression->kind) {
case EXPR_UNARY_CAST:
return is_constant_pointer(expression->unary.value);
default:
- return false;
+ return EXPR_CLASS_VARIABLE;
}
}
-static bool is_object_with_constant_address(const expression_t *expression)
+static expression_classification_t is_object_with_constant_address(const expression_t *expression)
{
switch (expression->kind) {
case EXPR_SELECT: {
case EXPR_ARRAY_ACCESS: {
array_access_expression_t const* const array_access =
&expression->array_access;
- return
- is_constant_expression(array_access->index) && (
- is_object_with_constant_address(array_access->array_ref) ||
- is_constant_pointer(array_access->array_ref)
- );
+ expression_classification_t const idx_class = is_constant_expression(array_access->index);
+ if (idx_class != EXPR_CLASS_CONSTANT)
+ return idx_class;
+ expression_classification_t const ref_addr = is_object_with_constant_address(array_access->array_ref);
+ expression_classification_t const ref_ptr = is_constant_pointer(array_access->array_ref);
+ return ref_addr > ref_ptr ? ref_addr : ref_ptr;
}
case EXPR_UNARY_DEREFERENCE:
return is_constant_pointer(expression->unary.value);
+
+ case EXPR_ERROR:
+ return EXPR_CLASS_ERROR;
+
default:
- return false;
+ return EXPR_CLASS_VARIABLE;
}
}
-bool is_constant_expression(const expression_t *expression)
+expression_classification_t is_constant_expression(const expression_t *expression)
{
switch (expression->kind) {
EXPR_LITERAL_CASES
case EXPR_BUILTIN_CONSTANT_P:
case EXPR_BUILTIN_TYPES_COMPATIBLE_P:
case EXPR_REFERENCE_ENUM_VALUE:
- return true;
+ 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;
+ return
+ !is_type_array(type) || !type->array.is_vla ? EXPR_CLASS_CONSTANT :
+ EXPR_CLASS_VARIABLE;
}
case EXPR_STRING_LITERAL:
case EXPR_VA_ARG:
case EXPR_VA_COPY:
case EXPR_STATEMENT:
- case EXPR_REFERENCE:
case EXPR_UNARY_POSTFIX_INCREMENT:
case EXPR_UNARY_POSTFIX_DECREMENT:
case EXPR_UNARY_PREFIX_INCREMENT:
case EXPR_BINARY_BITWISE_OR_ASSIGN:
case EXPR_BINARY_COMMA:
case EXPR_ARRAY_ACCESS:
- return false;
+ return EXPR_CLASS_VARIABLE;
+
+ case EXPR_REFERENCE: {
+ type_t *const type = skip_typeref(expression->base.type);
+ return is_type_valid(type) ? EXPR_CLASS_VARIABLE : EXPR_CLASS_ERROR;
+ }
case EXPR_UNARY_TAKE_ADDRESS:
return is_object_with_constant_address(expression->unary.value);
case EXPR_UNARY_NOT:
return is_constant_expression(expression->unary.value);
- case EXPR_UNARY_CAST:
- case EXPR_UNARY_CAST_IMPLICIT:
- return is_type_arithmetic(skip_typeref(expression->base.type))
- && is_constant_expression(expression->unary.value);
+ case EXPR_UNARY_CAST: {
+ type_t *const type = skip_typeref(expression->base.type);
+ if (is_type_scalar(type))
+ return is_constant_expression(expression->unary.value);
+ if (!is_type_valid(type))
+ return EXPR_CLASS_ERROR;
+ return EXPR_CLASS_VARIABLE;
+ }
case EXPR_BINARY_ADD:
case EXPR_BINARY_SUB:
case EXPR_BINARY_ISLESS:
case EXPR_BINARY_ISLESSEQUAL:
case EXPR_BINARY_ISLESSGREATER:
- case EXPR_BINARY_ISUNORDERED:
- return is_constant_expression(expression->binary.left)
- && is_constant_expression(expression->binary.right);
+ case EXPR_BINARY_ISUNORDERED: {
+ expression_classification_t const l = is_constant_expression(expression->binary.left);
+ expression_classification_t const r = is_constant_expression(expression->binary.right);
+ return l < r ? l : r;
+ }
case EXPR_BINARY_LOGICAL_AND: {
- expression_t const *const left = expression->binary.left;
- if (!is_constant_expression(left))
- return false;
- if (fold_constant_to_bool(left) == false)
- return true;
+ expression_t const *const left = expression->binary.left;
+ expression_classification_t const lclass = is_constant_expression(left);
+ if (lclass != EXPR_CLASS_CONSTANT)
+ return lclass;
+ if (!fold_constant_to_bool(left))
+ return EXPR_CLASS_CONSTANT;
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_to_bool(left) == true)
- return true;
+ expression_t const *const left = expression->binary.left;
+ expression_classification_t const lclass = is_constant_expression(left);
+ if (lclass != EXPR_CLASS_CONSTANT)
+ return lclass;
+ if (fold_constant_to_bool(left))
+ return EXPR_CLASS_CONSTANT;
return is_constant_expression(expression->binary.right);
}
return is_constant_initializer(expression->compound_literal.initializer);
case EXPR_CONDITIONAL: {
- expression_t *condition = expression->conditional.condition;
- if (!is_constant_expression(condition))
- return false;
+ expression_t *const condition = expression->conditional.condition;
+ expression_classification_t const cclass = is_constant_expression(condition);
+ if (cclass != EXPR_CLASS_CONSTANT)
+ return cclass;
- if (fold_constant_to_bool(condition) == true) {
+ if (fold_constant_to_bool(condition)) {
expression_t const *const t = expression->conditional.true_expression;
- return t == NULL || is_constant_expression(t);
+ return t == NULL ? EXPR_CLASS_CONSTANT : is_constant_expression(t);
} else {
return is_constant_expression(expression->conditional.false_expression);
}
}
- case EXPR_INVALID:
- return true;
-
- case EXPR_UNKNOWN:
- break;
+ case EXPR_ERROR:
+ return EXPR_CLASS_ERROR;
}
panic("invalid expression found (is constant expression)");
}
-/**
- * Initialize the AST construction.
- */
void init_ast(void)
{
obstack_init(&ast_obstack);
}
-/**
- * Free the AST.
- */
void exit_ast(void)
{
obstack_free(&ast_obstack, NULL);
}
-
-/**
- * Allocate an AST object of the given size.
- *
- * @param size the size of the object to allocate
- *
- * @return A new allocated object in the AST memeory space.
- */
-void *(allocate_ast)(size_t size)
-{
- return _allocate_ast(size);
-}
projects / cparser / blobdiff