#include "type_t.h"
#include "type_hash.h"
#include "ast_t.h"
+#include "entity_t.h"
#include "lang_features.h"
+#include "walk_statements.h"
#include "warning.h"
#include "adt/bitfiddle.h"
#include "adt/error.h"
#define MAX_LOOKAHEAD 2
typedef struct {
- declaration_t *old_declaration;
- symbol_t *symbol;
- unsigned short namespc;
+ entity_t *old_entity;
+ symbol_t *symbol;
+ namespace_t namespc;
} stack_entry_t;
typedef struct argument_list_t argument_list_t;
typedef struct declaration_specifiers_t declaration_specifiers_t;
struct declaration_specifiers_t {
source_position_t source_position;
- unsigned char declared_storage_class;
+ storage_class_t storage_class;
unsigned char alignment; /**< Alignment, 0 if not set. */
- unsigned int is_inline : 1;
- unsigned int deprecated : 1;
+ bool is_inline : 1;
+ bool deprecated : 1;
decl_modifiers_t modifiers; /**< declaration modifiers */
gnu_attribute_t *gnu_attributes; /**< list of GNU attributes */
const char *deprecated_string; /**< can be set if declaration was marked deprecated. */
* An environment for parsing initializers (and compound literals).
*/
typedef struct parse_initializer_env_t {
- type_t *type; /**< the type of the initializer. In case of an
- array type with unspecified size this gets
- adjusted to the actual size. */
- declaration_t *declaration; /**< the declaration that is initialized if any */
- bool must_be_constant;
+ type_t *type; /**< the type of the initializer. In case of an
+ array type with unspecified size this gets
+ adjusted to the actual size. */
+ entity_t *entity; /**< the variable that is initialized if any */
+ bool must_be_constant;
} parse_initializer_env_t;
-typedef declaration_t* (*parsed_declaration_func) (declaration_t *declaration, bool is_definition);
+typedef entity_t* (*parsed_declaration_func) (entity_t *declaration, bool is_definition);
/** The current token. */
static token_t token;
static scope_t *file_scope = NULL;
/** The current scope. */
static scope_t *scope = NULL;
-static declaration_t *last_declaration = NULL;
/** Point to the current function declaration if inside a function. */
-static declaration_t *current_function = NULL;
-static declaration_t *current_init_decl = NULL;
+static function_t *current_function = NULL;
+static entity_t *current_init_decl = NULL;
static switch_statement_t *current_switch = NULL;
static statement_t *current_loop = NULL;
static statement_t *current_parent = NULL;
#define PUSH_PARENT(stmt) \
statement_t *const prev_parent = current_parent; \
- current_parent = (stmt);
+ ((void)(current_parent = (stmt)))
#define POP_PARENT ((void)(current_parent = prev_parent))
-static source_position_t null_position = { NULL, 0 };
-
/** special symbol used for anonymous entities. */
static const symbol_t *sym_anonymous = NULL;
static statement_t *parse_compound_statement(bool inside_expression_statement);
static statement_t *parse_statement(void);
-static expression_t *parse_sub_expression(unsigned precedence);
+static expression_t *parse_sub_expression(precedence_t);
static expression_t *parse_expression(void);
static type_t *parse_typename(void);
-static void parse_compound_type_entries(declaration_t *compound_declaration);
-static declaration_t *parse_declarator(
- const declaration_specifiers_t *specifiers, bool may_be_abstract);
-static declaration_t *record_declaration(declaration_t *declaration, bool is_definition);
+static void parse_compound_type_entries(compound_t *compound_declaration);
+static entity_t *parse_declarator(const declaration_specifiers_t *specifiers,
+ bool may_be_abstract,
+ bool create_compound_member);
+static entity_t *record_entity(entity_t *entity, bool is_definition);
static void semantic_comparison(binary_expression_t *expression);
TYPE_QUALIFIERS \
TYPE_SPECIFIERS
+#define EXPRESSION_START \
+ case '!': \
+ case '&': \
+ case '(': \
+ case '*': \
+ case '+': \
+ case '-': \
+ case '~': \
+ case T_ANDAND: \
+ case T_CHARACTER_CONSTANT: \
+ case T_FLOATINGPOINT: \
+ case T_INTEGER: \
+ case T_MINUSMINUS: \
+ case T_PLUSPLUS: \
+ case T_STRING_LITERAL: \
+ case T_WIDE_CHARACTER_CONSTANT: \
+ case T_WIDE_STRING_LITERAL: \
+ case T___FUNCDNAME__: \
+ case T___FUNCSIG__: \
+ case T___FUNCTION__: \
+ case T___PRETTY_FUNCTION__: \
+ case T___alignof__: \
+ case T___builtin_alloca: \
+ case T___builtin_classify_type: \
+ case T___builtin_constant_p: \
+ case T___builtin_expect: \
+ case T___builtin_huge_val: \
+ case T___builtin_inf: \
+ case T___builtin_inff: \
+ case T___builtin_infl: \
+ case T___builtin_isgreater: \
+ case T___builtin_isgreaterequal: \
+ case T___builtin_isless: \
+ case T___builtin_islessequal: \
+ case T___builtin_islessgreater: \
+ case T___builtin_isunordered: \
+ case T___builtin_nan: \
+ case T___builtin_nanf: \
+ case T___builtin_nanl: \
+ case T___builtin_offsetof: \
+ case T___builtin_prefetch: \
+ case T___builtin_va_arg: \
+ case T___builtin_va_end: \
+ case T___builtin_va_start: \
+ case T___func__: \
+ case T___noop: \
+ case T__assume: \
+ case T_sizeof: \
+ case T_delete: \
+ case T_throw:
+
/**
* Allocate an AST node with given size and
* initialize all fields with zero.
return res;
}
-static declaration_t *allocate_declaration_zero(void)
+static size_t get_entity_struct_size(entity_kind_t kind)
{
- declaration_t *declaration = allocate_ast_zero(sizeof(declaration_t));
- declaration->type = type_error_type;
- declaration->alignment = 0;
- return declaration;
+ static const size_t sizes[] = {
+ [ENTITY_VARIABLE] = sizeof(variable_t),
+ [ENTITY_COMPOUND_MEMBER] = sizeof(variable_t),
+ [ENTITY_FUNCTION] = sizeof(function_t),
+ [ENTITY_TYPEDEF] = sizeof(typedef_t),
+ [ENTITY_STRUCT] = sizeof(compound_t),
+ [ENTITY_UNION] = sizeof(compound_t),
+ [ENTITY_ENUM] = sizeof(enum_t),
+ [ENTITY_ENUM_VALUE] = sizeof(enum_value_t),
+ [ENTITY_LABEL] = sizeof(label_t),
+ [ENTITY_LOCAL_LABEL] = sizeof(label_t)
+ };
+ assert(kind <= sizeof(sizes) / sizeof(sizes[0]));
+ assert(sizes[kind] != 0);
+ return sizes[kind];
+}
+
+static entity_t *allocate_entity_zero(entity_kind_t kind)
+{
+ size_t size = get_entity_struct_size(kind);
+ entity_t *entity = allocate_ast_zero(size);
+ entity->kind = kind;
+ return entity;
}
/**
[STATEMENT_COMPOUND] = sizeof(compound_statement_t),
[STATEMENT_RETURN] = sizeof(return_statement_t),
[STATEMENT_DECLARATION] = sizeof(declaration_statement_t),
+ [STATEMENT_LOCAL_LABEL] = sizeof(local_label_statement_t),
[STATEMENT_IF] = sizeof(if_statement_t),
[STATEMENT_SWITCH] = sizeof(switch_statement_t),
[STATEMENT_EXPRESSION] = sizeof(expression_statement_t),
static const size_t sizes[] = {
[EXPR_INVALID] = sizeof(expression_base_t),
[EXPR_REFERENCE] = sizeof(reference_expression_t),
+ [EXPR_REFERENCE_ENUM_VALUE] = sizeof(reference_expression_t),
[EXPR_CONST] = sizeof(const_expression_t),
[EXPR_CHARACTER_CONSTANT] = sizeof(const_expression_t),
[EXPR_WIDE_CHARACTER_CONSTANT] = sizeof(const_expression_t),
* fields with zero.
*
* @param kind type kind to allocate
- * @param source_position the source position of the type definition
*/
-static type_t *allocate_type_zero(type_kind_t kind, const source_position_t *source_position)
+static type_t *allocate_type_zero(type_kind_t kind)
{
size_t size = get_type_struct_size(kind);
type_t *res = obstack_alloc(type_obst, size);
memset(res, 0, size);
+ res->base.kind = kind;
- res->base.kind = kind;
- res->base.source_position = *source_position;
return res;
}
static void scope_push(scope_t *new_scope)
{
if (scope != NULL) {
- scope->last_declaration = last_declaration;
- new_scope->depth = scope->depth + 1;
+ new_scope->depth = scope->depth + 1;
}
new_scope->parent = scope;
scope = new_scope;
-
- last_declaration = new_scope->last_declaration;
}
static void scope_pop(void)
{
- scope->last_declaration = last_declaration;
scope = scope->parent;
- last_declaration = scope->last_declaration;
}
/**
- * Search a symbol in a given namespace and returns its declaration or
- * NULL if this symbol was not found.
+ * Search an entity by its symbol in a given namespace.
*/
-static declaration_t *get_declaration(const symbol_t *const symbol,
- const namespace_t namespc)
+static entity_t *get_entity(const symbol_t *const symbol, namespace_t namespc)
{
- declaration_t *declaration = symbol->declaration;
- for( ; declaration != NULL; declaration = declaration->symbol_next) {
- if (declaration->namespc == namespc)
- return declaration;
+ entity_t *entity = symbol->entity;
+ for( ; entity != NULL; entity = entity->base.symbol_next) {
+ if (entity->base.namespc == namespc)
+ return entity;
}
return NULL;
}
/**
- * pushs an environment_entry on the environment stack and links the
- * corresponding symbol to the new entry
+ * pushs an entity on the environment stack and links the corresponding symbol
+ * it.
*/
-static void stack_push(stack_entry_t **stack_ptr, declaration_t *declaration)
+static void stack_push(stack_entry_t **stack_ptr, entity_t *entity)
{
- symbol_t *symbol = declaration->symbol;
- namespace_t namespc = (namespace_t) declaration->namespc;
+ symbol_t *symbol = entity->base.symbol;
+ namespace_t namespc = entity->base.namespc;
+ assert(namespc != NAMESPACE_INVALID);
- /* replace/add declaration into declaration list of the symbol */
- declaration_t **anchor;
- declaration_t *iter;
- for (anchor = &symbol->declaration;; anchor = &iter->symbol_next) {
+ /* replace/add entity into entity list of the symbol */
+ entity_t **anchor;
+ entity_t *iter;
+ for (anchor = &symbol->entity; ; anchor = &iter->base.symbol_next) {
iter = *anchor;
if (iter == NULL)
break;
/* replace an entry? */
- if (iter->namespc == namespc) {
- declaration->symbol_next = iter->symbol_next;
+ if (iter->base.namespc == namespc) {
+ entity->base.symbol_next = iter->base.symbol_next;
break;
}
}
- *anchor = declaration;
+ *anchor = entity;
/* remember old declaration */
stack_entry_t entry;
- entry.symbol = symbol;
- entry.old_declaration = iter;
- entry.namespc = (unsigned short) namespc;
+ entry.symbol = symbol;
+ entry.old_entity = iter;
+ entry.namespc = namespc;
ARR_APP1(stack_entry_t, *stack_ptr, entry);
}
/**
- * Push a declaration on the environment stack.
- *
- * @param declaration the declaration
+ * Push an entity on the environment stack.
*/
-static void environment_push(declaration_t *declaration)
+static void environment_push(entity_t *entity)
{
- assert(declaration->source_position.input_name != NULL);
- assert(declaration->parent_scope != NULL);
- stack_push(&environment_stack, declaration);
+ assert(entity->base.source_position.input_name != NULL);
+ assert(entity->base.parent_scope != NULL);
+ stack_push(&environment_stack, entity);
}
/**
*
* @param declaration the declaration
*/
-static void label_push(declaration_t *declaration)
+static void label_push(entity_t *label)
{
- declaration->parent_scope = ¤t_function->scope;
- stack_push(&label_stack, declaration);
+ /* we abuse the parameters scope as parent for the labels */
+ label->base.parent_scope = ¤t_function->parameters;
+ stack_push(&label_stack, label);
}
/**
*
* @param declaration the declaration
*/
-static void local_label_push(declaration_t *declaration)
+static void local_label_push(entity_t *label)
{
- assert(declaration->parent_scope != NULL);
- stack_push(&local_label_stack, declaration);
+ assert(label->base.parent_scope != NULL);
+ label->base.parent_scope = scope;
+ stack_push(&local_label_stack, label);
}
/**
for(i = top; i > new_top; --i) {
stack_entry_t *entry = &stack[i - 1];
- declaration_t *old_declaration = entry->old_declaration;
- symbol_t *symbol = entry->symbol;
- namespace_t namespc = (namespace_t)entry->namespc;
+ entity_t *old_entity = entry->old_entity;
+ symbol_t *symbol = entry->symbol;
+ namespace_t namespc = entry->namespc;
- /* replace/remove declaration */
- declaration_t **anchor;
- declaration_t *iter;
- for (anchor = &symbol->declaration;; anchor = &iter->symbol_next) {
+ /* replace with old_entity/remove */
+ entity_t **anchor;
+ entity_t *iter;
+ for (anchor = &symbol->entity; ; anchor = &iter->base.symbol_next) {
iter = *anchor;
assert(iter != NULL);
/* replace an entry? */
- if (iter->namespc == namespc)
+ if (iter->base.namespc == namespc)
break;
}
- /* Because of scopes and appending other namespaces to the end of
- * the list, this must hold. */
- assert((old_declaration != NULL ? old_declaration->symbol_next : NULL) == iter->symbol_next);
- *anchor = old_declaration;
+ /* restore definition from outer scopes (if there was one) */
+ if (old_entity != NULL) {
+ old_entity->base.symbol_next = iter->base.symbol_next;
+ *anchor = old_entity;
+ } else {
+ /* remove entry from list */
+ *anchor = iter->base.symbol_next;
+ }
}
ARR_SHRINKLEN(*stack_ptr, (int) new_top);
return;
case ASSIGN_ERROR_POINTER_QUALIFIER_MISSING: {
- type_t *points_to_left
- = skip_typeref(type_left->pointer.points_to);
- type_t *points_to_right
- = skip_typeref(type_right->pointer.points_to);
-
- /* the left type has all qualifiers from the right type */
- unsigned missing_qualifiers
- = points_to_right->base.qualifiers & ~points_to_left->base.qualifiers;
- warningf(source_position,
- "destination type '%T' in %s from type '%T' lacks qualifiers '%Q' in pointer target type",
- orig_type_left, context, orig_type_right, missing_qualifiers);
+ if (warning.other) {
+ type_t *points_to_left = skip_typeref(type_left->pointer.points_to);
+ type_t *points_to_right = skip_typeref(type_right->pointer.points_to);
+
+ /* the left type has all qualifiers from the right type */
+ unsigned missing_qualifiers
+ = points_to_right->base.qualifiers & ~points_to_left->base.qualifiers;
+ warningf(source_position,
+ "destination type '%T' in %s from type '%T' lacks qualifiers '%Q' in pointer target type",
+ orig_type_left, context, orig_type_right, missing_qualifiers);
+ }
return;
}
case ASSIGN_WARNING_POINTER_INCOMPATIBLE:
- warningf(source_position,
- "destination type '%T' in %s is incompatible with '%E' of type '%T'",
- orig_type_left, context, right, orig_type_right);
+ if (warning.other) {
+ warningf(source_position,
+ "destination type '%T' in %s is incompatible with '%E' of type '%T'",
+ orig_type_left, context, right, orig_type_right);
+ }
return;
case ASSIGN_WARNING_POINTER_FROM_INT:
- warningf(source_position,
- "%s makes pointer '%T' from integer '%T' without a cast",
- context, orig_type_left, orig_type_right);
+ if (warning.other) {
+ warningf(source_position,
+ "%s makes pointer '%T' from integer '%T' without a cast",
+ context, orig_type_left, orig_type_right);
+ }
return;
case ASSIGN_WARNING_INT_FROM_POINTER:
- warningf(source_position,
- "%s makes integer '%T' from pointer '%T' without a cast",
- context, orig_type_left, orig_type_right);
+ if (warning.other) {
+ warningf(source_position,
+ "%s makes integer '%T' from pointer '%T' without a cast",
+ context, orig_type_left, orig_type_right);
+ }
return;
default:
points_to_left = get_unqualified_type(points_to_left);
points_to_right = get_unqualified_type(points_to_right);
- if (is_type_atomic(points_to_left, ATOMIC_TYPE_VOID) ||
- is_type_atomic(points_to_right, ATOMIC_TYPE_VOID)) {
+ if (is_type_atomic(points_to_left, ATOMIC_TYPE_VOID))
return res;
+
+ if (is_type_atomic(points_to_right, ATOMIC_TYPE_VOID)) {
+ /* ISO/IEC 14882:1998(E) §C.1.2:6 */
+ return c_mode & _CXX ? ASSIGN_ERROR_INCOMPATIBLE : res;
}
if (!types_compatible(points_to_left, points_to_right)) {
static expression_t *parse_constant_expression(void)
{
- /* start parsing at precedence 7 (conditional expression) */
- expression_t *result = parse_sub_expression(7);
+ expression_t *result = parse_sub_expression(PREC_CONDITIONAL);
if (!is_constant_expression(result)) {
errorf(&result->base.source_position,
static expression_t *parse_assignment_expression(void)
{
- /* start parsing at precedence 2 (assignment expression) */
- return parse_sub_expression(2);
+ return parse_sub_expression(PREC_ASSIGNMENT);
}
static type_t *make_global_typedef(const char *name, type_t *type)
{
- symbol_t *const symbol = symbol_table_insert(name);
+ symbol_t *const symbol = symbol_table_insert(name);
- declaration_t *const declaration = allocate_declaration_zero();
- declaration->namespc = NAMESPACE_NORMAL;
- declaration->storage_class = STORAGE_CLASS_TYPEDEF;
- declaration->declared_storage_class = STORAGE_CLASS_TYPEDEF;
- declaration->type = type;
- declaration->symbol = symbol;
- declaration->source_position = builtin_source_position;
- declaration->implicit = true;
+ entity_t *const entity = allocate_entity_zero(ENTITY_TYPEDEF);
+ entity->base.symbol = symbol;
+ entity->base.source_position = builtin_source_position;
+ entity->base.namespc = NAMESPACE_NORMAL;
+ entity->typedefe.type = type;
+ entity->typedefe.builtin = true;
- record_declaration(declaration, false);
+ record_entity(entity, false);
- type_t *typedef_type = allocate_type_zero(TYPE_TYPEDEF, &builtin_source_position);
- typedef_type->typedeft.declaration = declaration;
+ type_t *typedef_type = allocate_type_zero(TYPE_TYPEDEF);
+ typedef_type->typedeft.typedefe = &entity->typedefe;
return typedef_type;
}
} else if (strcmp_underscore("DI", symbol_str) == 0) {
attribute->u.akind = ATOMIC_TYPE_LONGLONG;
} else {
- warningf(HERE, "ignoring unknown mode '%s'", symbol_str);
+ if (warning.other)
+ warningf(HERE, "ignoring unknown mode '%s'", symbol_str);
attribute->invalid = true;
}
next_token();
attribute->have_arguments = true;
}
- switch(kind) {
- case GNU_AK_CONST:
+ switch (kind) {
case GNU_AK_VOLATILE:
case GNU_AK_NAKED:
case GNU_AK_MALLOC:
case GNU_AK_UNUSED: modifiers |= DM_UNUSED; goto no_arg;
case GNU_AK_USED: modifiers |= DM_USED; goto no_arg;
case GNU_AK_PURE: modifiers |= DM_PURE; goto no_arg;
+ case GNU_AK_CONST: modifiers |= DM_CONST; goto no_arg;
case GNU_AK_ALWAYS_INLINE: modifiers |= DM_FORCEINLINE; goto no_arg;
case GNU_AK_DLLIMPORT: modifiers |= DM_DLLIMPORT; goto no_arg;
case GNU_AK_DLLEXPORT: modifiers |= DM_DLLEXPORT; goto no_arg;
decl_modifiers_t modifiers = 0;
while (true) {
- switch(token.type) {
+ switch (token.type) {
case T___attribute__:
modifiers |= parse_gnu_attribute(attributes);
continue;
case T___thiscall:
/* TODO record modifier */
- warningf(HERE, "Ignoring declaration modifier %K", &token);
+ if (warning.other)
+ warningf(HERE, "Ignoring declaration modifier %K", &token);
break;
end_error:
}
}
+static void mark_vars_read(expression_t *expr, variable_t *lhs_var);
+
+static variable_t *determine_lhs_var(expression_t *const expr,
+ variable_t *lhs_var)
+{
+ switch (expr->kind) {
+ case EXPR_REFERENCE: {
+ entity_t *const entity = expr->reference.entity;
+ /* we should only find variables as lavlues... */
+ if (entity->base.kind != ENTITY_VARIABLE)
+ return NULL;
+
+ return &entity->variable;
+ }
+
+ case EXPR_ARRAY_ACCESS: {
+ expression_t *const ref = expr->array_access.array_ref;
+ variable_t * var = NULL;
+ if (is_type_array(skip_typeref(revert_automatic_type_conversion(ref)))) {
+ var = determine_lhs_var(ref, lhs_var);
+ lhs_var = var;
+ } else {
+ mark_vars_read(expr->select.compound, lhs_var);
+ }
+ mark_vars_read(expr->array_access.index, lhs_var);
+ return var;
+ }
+
+ case EXPR_SELECT: {
+ if (is_type_compound(skip_typeref(expr->base.type))) {
+ return determine_lhs_var(expr->select.compound, lhs_var);
+ } else {
+ mark_vars_read(expr->select.compound, lhs_var);
+ return NULL;
+ }
+ }
+
+ case EXPR_UNARY_DEREFERENCE: {
+ expression_t *const val = expr->unary.value;
+ if (val->kind == EXPR_UNARY_TAKE_ADDRESS) {
+ /* *&x is a NOP */
+ return determine_lhs_var(val->unary.value, lhs_var);
+ } else {
+ mark_vars_read(val, NULL);
+ return NULL;
+ }
+ }
+
+ default:
+ mark_vars_read(expr, NULL);
+ return NULL;
+ }
+}
+
+#define VAR_ANY ((variable_t*)-1)
+
+/**
+ * Mark declarations, which are read. This is used to deted variables, which
+ * are never read.
+ * Example:
+ * x = x + 1;
+ * x is not marked as "read", because it is only read to calculate its own new
+ * value.
+ *
+ * x += y; y += x;
+ * x and y are not detected as "not read", because multiple variables are
+ * involved.
+ */
+static void mark_vars_read(expression_t *const expr, variable_t *lhs_var)
+{
+ switch (expr->kind) {
+ case EXPR_REFERENCE: {
+ entity_t *const entity = expr->reference.entity;
+ if (entity->kind != ENTITY_VARIABLE)
+ return;
+
+ variable_t *variable = &entity->variable;
+ if (lhs_var != variable && lhs_var != VAR_ANY) {
+ variable->read = true;
+ }
+ return;
+ }
+
+ case EXPR_CALL:
+ // TODO respect pure/const
+ mark_vars_read(expr->call.function, NULL);
+ for (call_argument_t *arg = expr->call.arguments; arg != NULL; arg = arg->next) {
+ mark_vars_read(arg->expression, NULL);
+ }
+ return;
+
+ case EXPR_CONDITIONAL:
+ // TODO lhs_decl should depend on whether true/false have an effect
+ mark_vars_read(expr->conditional.condition, NULL);
+ if (expr->conditional.true_expression != NULL)
+ mark_vars_read(expr->conditional.true_expression, lhs_var);
+ mark_vars_read(expr->conditional.false_expression, lhs_var);
+ return;
+
+ case EXPR_SELECT:
+ if (lhs_var == VAR_ANY && !is_type_compound(skip_typeref(expr->base.type)))
+ lhs_var = NULL;
+ mark_vars_read(expr->select.compound, lhs_var);
+ return;
+
+ case EXPR_ARRAY_ACCESS: {
+ expression_t *const ref = expr->array_access.array_ref;
+ mark_vars_read(ref, lhs_var);
+ lhs_var = determine_lhs_var(ref, lhs_var);
+ mark_vars_read(expr->array_access.index, lhs_var);
+ return;
+ }
+
+ case EXPR_VA_ARG:
+ mark_vars_read(expr->va_arge.ap, lhs_var);
+ return;
+
+ case EXPR_UNARY_CAST:
+ /* Special case: Use void cast to mark a variable as "read" */
+ if (is_type_atomic(skip_typeref(expr->base.type), ATOMIC_TYPE_VOID))
+ lhs_var = NULL;
+ goto unary;
+
+
+ case EXPR_UNARY_THROW:
+ if (expr->unary.value == NULL)
+ return;
+ /* FALLTHROUGH */
+ case EXPR_UNARY_DEREFERENCE:
+ case EXPR_UNARY_DELETE:
+ case EXPR_UNARY_DELETE_ARRAY:
+ if (lhs_var == VAR_ANY)
+ lhs_var = NULL;
+ goto unary;
+
+ case EXPR_UNARY_NEGATE:
+ case EXPR_UNARY_PLUS:
+ case EXPR_UNARY_BITWISE_NEGATE:
+ case EXPR_UNARY_NOT:
+ case EXPR_UNARY_TAKE_ADDRESS:
+ case EXPR_UNARY_POSTFIX_INCREMENT:
+ case EXPR_UNARY_POSTFIX_DECREMENT:
+ case EXPR_UNARY_PREFIX_INCREMENT:
+ case EXPR_UNARY_PREFIX_DECREMENT:
+ case EXPR_UNARY_CAST_IMPLICIT:
+ case EXPR_UNARY_ASSUME:
+unary:
+ mark_vars_read(expr->unary.value, lhs_var);
+ return;
+
+ case EXPR_BINARY_ADD:
+ case EXPR_BINARY_SUB:
+ case EXPR_BINARY_MUL:
+ case EXPR_BINARY_DIV:
+ case EXPR_BINARY_MOD:
+ case EXPR_BINARY_EQUAL:
+ case EXPR_BINARY_NOTEQUAL:
+ case EXPR_BINARY_LESS:
+ case EXPR_BINARY_LESSEQUAL:
+ case EXPR_BINARY_GREATER:
+ case EXPR_BINARY_GREATEREQUAL:
+ 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_COMMA:
+ case EXPR_BINARY_ISGREATER:
+ case EXPR_BINARY_ISGREATEREQUAL:
+ case EXPR_BINARY_ISLESS:
+ case EXPR_BINARY_ISLESSEQUAL:
+ case EXPR_BINARY_ISLESSGREATER:
+ case EXPR_BINARY_ISUNORDERED:
+ mark_vars_read(expr->binary.left, lhs_var);
+ mark_vars_read(expr->binary.right, lhs_var);
+ return;
+
+ case EXPR_BINARY_ASSIGN:
+ case EXPR_BINARY_MUL_ASSIGN:
+ case EXPR_BINARY_DIV_ASSIGN:
+ case EXPR_BINARY_MOD_ASSIGN:
+ case EXPR_BINARY_ADD_ASSIGN:
+ case EXPR_BINARY_SUB_ASSIGN:
+ case EXPR_BINARY_SHIFTLEFT_ASSIGN:
+ case EXPR_BINARY_SHIFTRIGHT_ASSIGN:
+ case EXPR_BINARY_BITWISE_AND_ASSIGN:
+ case EXPR_BINARY_BITWISE_XOR_ASSIGN:
+ case EXPR_BINARY_BITWISE_OR_ASSIGN: {
+ if (lhs_var == VAR_ANY)
+ lhs_var = NULL;
+ lhs_var = determine_lhs_var(expr->binary.left, lhs_var);
+ mark_vars_read(expr->binary.right, lhs_var);
+ return;
+ }
+
+ case EXPR_VA_START:
+ determine_lhs_var(expr->va_starte.ap, lhs_var);
+ return;
+
+ case EXPR_UNKNOWN:
+ case EXPR_INVALID:
+ case EXPR_CONST:
+ case EXPR_CHARACTER_CONSTANT:
+ case EXPR_WIDE_CHARACTER_CONSTANT:
+ case EXPR_STRING_LITERAL:
+ case EXPR_WIDE_STRING_LITERAL:
+ case EXPR_COMPOUND_LITERAL: // TODO init?
+ case EXPR_SIZEOF:
+ case EXPR_CLASSIFY_TYPE:
+ case EXPR_ALIGNOF:
+ case EXPR_FUNCNAME:
+ case EXPR_BUILTIN_SYMBOL:
+ case EXPR_BUILTIN_CONSTANT_P:
+ case EXPR_BUILTIN_PREFETCH:
+ case EXPR_OFFSETOF:
+ case EXPR_STATEMENT: // TODO
+ case EXPR_LABEL_ADDRESS:
+ case EXPR_BINARY_BUILTIN_EXPECT:
+ case EXPR_REFERENCE_ENUM_VALUE:
+ return;
+ }
+
+ panic("unhandled expression");
+}
+
static designator_t *parse_designation(void)
{
designator_t *result = NULL;
while (true) {
designator_t *designator;
- switch(token.type) {
+ switch (token.type) {
case '[':
designator = allocate_ast_zero(sizeof(designator[0]));
designator->source_position = token.source_position;
&expression->base.source_position);
initializer_t *const result = allocate_initializer_zero(INITIALIZER_VALUE);
+#if 0
+ if (type->kind == TYPE_BITFIELD) {
+ type = type->bitfield.base_type;
+ }
+#endif
result->value.value = create_implicit_cast(expression, type);
return result;
/* there might be extra {} hierarchies */
int braces = 0;
if (token.type == '{') {
- warningf(HERE, "extra curly braces around scalar initializer");
+ if (warning.other)
+ warningf(HERE, "extra curly braces around scalar initializer");
do {
++braces;
next_token();
}
expression_t *expression = parse_assignment_expression();
+ mark_vars_read(expression, NULL);
if (must_be_constant && !is_initializer_constant(expression)) {
errorf(&expression->base.source_position,
"Initialisation expression '%E' is not constant\n",
next_token();
}
if (token.type != '}') {
- if (!additional_warning_displayed) {
+ if (!additional_warning_displayed && warning.other) {
warningf(HERE, "additional elements in scalar initializer");
additional_warning_displayed = true;
}
assert(i == len-1);
continue;
}
- fprintf(stderr, ".%s", entry->v.compound_entry->symbol->string);
+ fprintf(stderr, ".%s",
+ entry->v.compound_entry->base.symbol->string);
} else if (is_type_array(type)) {
fprintf(stderr, "[%zu]", entry->v.index);
} else {
}
/**
- * Descending into a sub-type. Enter the scope of the current
- * top_type.
+ * Descending into a sub-type. Enter the scope of the current top_type.
*/
static void descend_into_subtype(type_path_t *path)
{
top->type = top_type;
if (is_type_compound(top_type)) {
- declaration_t *declaration = top_type->compound.declaration;
- declaration_t *entry = declaration->scope.declarations;
- top->v.compound_entry = entry;
+ compound_t *compound = top_type->compound.compound;
+ entity_t *entry = compound->members.entities;
if (entry != NULL) {
- path->top_type = entry->type;
+ assert(entry->kind == ENTITY_COMPOUND_MEMBER);
+ top->v.compound_entry = &entry->declaration;
+ path->top_type = entry->declaration.type;
} else {
- path->top_type = NULL;
+ path->top_type = NULL;
}
} else if (is_type_array(top_type)) {
top->v.index = 0;
"'.%Y' designator used for non-compound type '%T'",
symbol, orig_type);
}
- goto failed;
- }
- declaration_t *declaration = type->compound.declaration;
- declaration_t *iter = declaration->scope.declarations;
- for( ; iter != NULL; iter = iter->next) {
- if (iter->symbol == symbol) {
- break;
+ top->type = type_error_type;
+ top->v.compound_entry = NULL;
+ orig_type = type_error_type;
+ } else {
+ compound_t *compound = type->compound.compound;
+ entity_t *iter = compound->members.entities;
+ for( ; iter != NULL; iter = iter->base.next) {
+ if (iter->base.symbol == symbol) {
+ break;
+ }
}
- }
- if (iter == NULL) {
- errorf(&designator->source_position,
- "'%T' has no member named '%Y'", orig_type, symbol);
- goto failed;
- }
- if (used_in_offsetof) {
- type_t *real_type = skip_typeref(iter->type);
- if (real_type->kind == TYPE_BITFIELD) {
+ if (iter == NULL) {
errorf(&designator->source_position,
- "offsetof designator '%Y' may not specify bitfield",
- symbol);
+ "'%T' has no member named '%Y'", orig_type, symbol);
goto failed;
}
- }
+ assert(iter->kind == ENTITY_COMPOUND_MEMBER);
+ if (used_in_offsetof) {
+ type_t *real_type = skip_typeref(iter->declaration.type);
+ if (real_type->kind == TYPE_BITFIELD) {
+ errorf(&designator->source_position,
+ "offsetof designator '%Y' may not specify bitfield",
+ symbol);
+ goto failed;
+ }
+ }
- top->type = orig_type;
- top->v.compound_entry = iter;
- orig_type = iter->type;
+ top->type = orig_type;
+ top->v.compound_entry = &iter->declaration;
+ orig_type = iter->declaration.type;
+ }
} else {
expression_t *array_index = designator->array_index;
assert(designator->array_index != NULL);
}
goto failed;
}
- if (!is_type_valid(array_index->base.type)) {
- goto failed;
- }
long index = fold_constant(array_index);
if (!used_in_offsetof) {
if (index < 0) {
errorf(&designator->source_position,
"array index [%E] must be positive", array_index);
- goto failed;
- }
- if (type->array.size_constant == true) {
+ } else if (type->array.size_constant) {
long array_size = type->array.size;
if (index >= array_size) {
errorf(&designator->source_position,
"designator [%E] (%d) exceeds array size %d",
array_index, index, array_size);
- goto failed;
}
}
}
} else if (is_type_struct(type)) {
declaration_t *entry = top->v.compound_entry;
- entry = entry->next;
+ entity_t *next_entity = entry->base.next;
+ if (next_entity != NULL) {
+ assert(is_declaration(next_entity));
+ entry = &next_entity->declaration;
+ } else {
+ entry = NULL;
+ }
+
top->v.compound_entry = entry;
if (entry != NULL) {
path->top_type = entry->type;
return;
}
- } else {
+ } else if (is_type_array(type)) {
assert(is_type_array(type));
top->v.index++;
if (!type->array.size_constant || top->v.index < type->array.size) {
return;
}
+ } else {
+ assert(!is_type_valid(type));
+ return;
}
/* we're past the last member of the current sub-aggregate, try if we
/* We are initializing an empty compound. */
} else {
type = skip_typeref(orig_type);
-
- /* we can't do usefull stuff if we didn't even parse the type. Skip the
- * initializers in this case. */
- if (!is_type_valid(type)) {
- skip_initializers();
- return create_empty_initializer();
- }
}
initializer_t **initializers = NEW_ARR_F(initializer_t*, 0);
} else {
eat('{');
if (type == NULL) {
- if (env->declaration != NULL) {
- errorf(HERE, "extra brace group at end of initializer for '%Y'",
- env->declaration->symbol);
+ if (env->entity != NULL) {
+ errorf(HERE,
+ "extra brace group at end of initializer for '%Y'",
+ env->entity->base.symbol);
} else {
errorf(HERE, "extra brace group at end of initializer");
}
if (type == NULL) {
/* we are already outside, ... */
- if (is_type_compound(outer_type) &&
- !outer_type->compound.declaration->init.complete) {
+ type_t *const outer_type_skip = skip_typeref(outer_type);
+ if (is_type_compound(outer_type_skip) &&
+ !outer_type_skip->compound.compound->complete) {
goto error_parse_next;
}
goto error_excess;
if (token.type == ',') {
next_token();
}
- if (token.type != '}') {
+ if (token.type != '}' && warning.other) {
warningf(HERE, "excessive elements in initializer for type '%T'",
orig_type);
}
ARR_APP1(initializer_t*, initializers, sub);
} else {
error_excess:
- if (env->declaration != NULL)
- warningf(HERE, "excess elements in struct initializer for '%Y'",
- env->declaration->symbol);
- else
- warningf(HERE, "excess elements in struct initializer");
+ if (warning.other) {
+ if (env->entity != NULL) {
+ warningf(HERE, "excess elements in struct initializer for '%Y'",
+ env->entity->base.symbol);
+ } else {
+ warningf(HERE, "excess elements in struct initializer");
+ }
+ }
}
error_parse_next:
return NULL;
}
-static declaration_t *append_declaration(declaration_t *declaration);
+static void append_entity(scope_t *scope, entity_t *entity)
+{
+ if (scope->last_entity != NULL) {
+ scope->last_entity->base.next = entity;
+ } else {
+ scope->entities = entity;
+ }
+ scope->last_entity = entity;
+}
+
-static declaration_t *parse_compound_type_specifier(bool is_struct)
+static compound_t *parse_compound_type_specifier(bool is_struct)
{
gnu_attribute_t *attributes = NULL;
decl_modifiers_t modifiers = 0;
eat(T_union);
}
- symbol_t *symbol = NULL;
- declaration_t *declaration = NULL;
+ symbol_t *symbol = NULL;
+ compound_t *compound = NULL;
if (token.type == T___attribute__) {
modifiers |= parse_attributes(&attributes);
namespace_t const namespc =
is_struct ? NAMESPACE_STRUCT : NAMESPACE_UNION;
- declaration = get_declaration(symbol, namespc);
- if (declaration != NULL) {
- if (declaration->parent_scope != scope &&
+ entity_t *entity = get_entity(symbol, namespc);
+ if (entity != NULL) {
+ assert(entity->kind == (is_struct ? ENTITY_STRUCT : ENTITY_UNION));
+ compound = &entity->compound;
+ if (compound->base.parent_scope != scope &&
(token.type == '{' || token.type == ';')) {
- declaration = NULL;
- } else if (declaration->init.complete &&
- token.type == '{') {
+ /* we're in an inner scope and have a definition. Override
+ existing definition in outer scope */
+ compound = NULL;
+ } else if (compound->complete && token.type == '{') {
assert(symbol != NULL);
- errorf(HERE, "multiple definitions of '%s %Y' (previous definition at %P)",
+ errorf(HERE, "multiple definitions of '%s %Y' (previous definition %P)",
is_struct ? "struct" : "union", symbol,
- &declaration->source_position);
- declaration->scope.declarations = NULL;
+ &compound->base.source_position);
+ /* clear members in the hope to avoid further errors */
+ compound->members.entities = NULL;
}
}
} else if (token.type != '{') {
return NULL;
}
- if (declaration == NULL) {
- declaration = allocate_declaration_zero();
- declaration->namespc =
+ if (compound == NULL) {
+ entity_kind_t kind = is_struct ? ENTITY_STRUCT : ENTITY_UNION;
+ entity_t *entity = allocate_entity_zero(kind);
+ compound = &entity->compound;
+
+ compound->base.namespc =
(is_struct ? NAMESPACE_STRUCT : NAMESPACE_UNION);
- declaration->source_position = token.source_position;
- declaration->symbol = symbol;
- declaration->parent_scope = scope;
+ compound->base.source_position = token.source_position;
+ compound->base.symbol = symbol;
+ compound->base.parent_scope = scope;
if (symbol != NULL) {
- environment_push(declaration);
+ environment_push(entity);
}
- append_declaration(declaration);
+ append_entity(scope, entity);
}
if (token.type == '{') {
- declaration->init.complete = true;
+ compound->complete = true;
- parse_compound_type_entries(declaration);
+ parse_compound_type_entries(compound);
modifiers |= parse_attributes(&attributes);
}
- declaration->modifiers |= modifiers;
- return declaration;
+ compound->modifiers |= modifiers;
+ return compound;
}
static void parse_enum_entries(type_t *const enum_type)
return;
}
- declaration_t *const entry = allocate_declaration_zero();
- entry->storage_class = STORAGE_CLASS_ENUM_ENTRY;
- entry->type = enum_type;
- entry->symbol = token.v.symbol;
- entry->source_position = token.source_position;
+ entity_t *entity = allocate_entity_zero(ENTITY_ENUM_VALUE);
+ entity->enum_value.enum_type = enum_type;
+ entity->base.symbol = token.v.symbol;
+ entity->base.source_position = token.source_position;
next_token();
if (token.type == '=') {
expression_t *value = parse_constant_expression();
value = create_implicit_cast(value, enum_type);
- entry->init.enum_value = value;
+ entity->enum_value.value = value;
/* TODO semantic */
}
- record_declaration(entry, false);
+ record_entity(entity, false);
if (token.type != ',')
break;
static type_t *parse_enum_specifier(void)
{
gnu_attribute_t *attributes = NULL;
- declaration_t *declaration;
+ entity_t *entity;
symbol_t *symbol;
eat(T_enum);
symbol = token.v.symbol;
next_token();
- declaration = get_declaration(symbol, NAMESPACE_ENUM);
+ entity = get_entity(symbol, NAMESPACE_ENUM);
+ assert(entity == NULL || entity->kind == ENTITY_ENUM);
} else if (token.type != '{') {
parse_error_expected("while parsing enum type specifier",
T_IDENTIFIER, '{', NULL);
return NULL;
} else {
- declaration = NULL;
- symbol = NULL;
+ entity = NULL;
+ symbol = NULL;
}
- if (declaration == NULL) {
- declaration = allocate_declaration_zero();
- declaration->namespc = NAMESPACE_ENUM;
- declaration->source_position = token.source_position;
- declaration->symbol = symbol;
- declaration->parent_scope = scope;
+ if (entity == NULL) {
+ entity = allocate_entity_zero(ENTITY_ENUM);
+ entity->base.namespc = NAMESPACE_ENUM;
+ entity->base.source_position = token.source_position;
+ entity->base.symbol = symbol;
+ entity->base.parent_scope = scope;
}
- type_t *const type = allocate_type_zero(TYPE_ENUM, &declaration->source_position);
- type->enumt.declaration = declaration;
+ type_t *const type = allocate_type_zero(TYPE_ENUM);
+ type->enumt.enume = &entity->enume;
if (token.type == '{') {
- if (declaration->init.complete) {
- errorf(HERE, "multiple definitions of enum %Y", symbol);
+ if (entity->enume.complete) {
+ errorf(HERE, "multiple definitions of enum %Y (previous definition %P)",
+ symbol, &entity->base.source_position);
}
if (symbol != NULL) {
- environment_push(declaration);
+ environment_push(entity);
}
- append_declaration(declaration);
- declaration->init.complete = true;
+ append_entity(scope, entity);
+ entity->enume.complete = true;
parse_enum_entries(type);
parse_attributes(&attributes);
+ } else if(!entity->enume.complete && !(c_mode & _GNUC)) {
+ errorf(HERE, "enum %Y used before definition (incomplete enumes are a GNU extension)",
+ symbol);
}
return type;
*/
static bool is_typedef_symbol(symbol_t *symbol)
{
- const declaration_t *const declaration =
- get_declaration(symbol, NAMESPACE_NORMAL);
- return
- declaration != NULL &&
- declaration->storage_class == STORAGE_CLASS_TYPEDEF;
+ const entity_t *const entity = get_entity(symbol, NAMESPACE_NORMAL);
+ return entity != NULL && entity->kind == ENTITY_TYPEDEF;
}
static type_t *parse_typeof(void)
rem_anchor_token(')');
expect(')');
- type_t *typeof_type = allocate_type_zero(TYPE_TYPEOF, &expression->base.source_position);
+ type_t *typeof_type = allocate_type_zero(TYPE_TYPEOF);
typeof_type->typeoft.expression = expression;
typeof_type->typeoft.typeof_type = type;
static type_t *create_builtin_type(symbol_t *const symbol,
type_t *const real_type)
{
- type_t *type = allocate_type_zero(TYPE_BUILTIN, &builtin_source_position);
+ type_t *type = allocate_type_zero(TYPE_BUILTIN);
type->builtin.symbol = symbol;
type->builtin.real_type = real_type;
static type_t *get_typedef_type(symbol_t *symbol)
{
- declaration_t *declaration = get_declaration(symbol, NAMESPACE_NORMAL);
- if (declaration == NULL ||
- declaration->storage_class != STORAGE_CLASS_TYPEDEF)
+ entity_t *entity = get_entity(symbol, NAMESPACE_NORMAL);
+ if (entity == NULL || entity->kind != ENTITY_TYPEDEF)
return NULL;
- type_t *type = allocate_type_zero(TYPE_TYPEDEF, &declaration->source_position);
- type->typedeft.declaration = declaration;
+ type_t *type = allocate_type_zero(TYPE_TYPEDEF);
+ type->typedeft.typedefe = &entity->typedefe;
return type;
}
}
#define DET_MOD(name, tag) do { \
- if (*modifiers & tag) warningf(HERE, #name " used more than once"); \
+ if (*modifiers & tag && warning.other) warningf(HERE, #name " used more than once"); \
*modifiers |= tag; \
} while (0)
if (token.type != T_INTEGER)
goto end_error;
if (check_alignment_value(token.v.intvalue)) {
- if (specifiers->alignment != 0)
+ if (specifiers->alignment != 0 && warning.other)
warningf(HERE, "align used more than once");
specifiers->alignment = (unsigned char)token.v.intvalue;
}
expect(')');
} else if (symbol == sym_deprecated) {
next_token();
- if (specifiers->deprecated != 0)
+ if (specifiers->deprecated != 0 && warning.other)
warningf(HERE, "deprecated used more than once");
- specifiers->deprecated = 1;
+ specifiers->deprecated = true;
if (token.type == '(') {
next_token();
if (token.type == T_STRING_LITERAL) {
next_token();
DET_MOD(noalias, DM_NOALIAS);
} else {
- warningf(HERE, "Unknown modifier %Y ignored", token.v.symbol);
+ if (warning.other)
+ warningf(HERE, "Unknown modifier %Y ignored", token.v.symbol);
next_token();
if (token.type == '(')
skip_until(')');
return;
}
-static declaration_t *create_error_declaration(symbol_t *symbol, storage_class_tag_t storage_class)
+static entity_t *create_error_entity(symbol_t *symbol, entity_kind_tag_t kind)
{
- declaration_t *const decl = allocate_declaration_zero();
- decl->source_position = *HERE;
- decl->declared_storage_class = storage_class;
- decl->storage_class =
- storage_class != STORAGE_CLASS_NONE || scope == file_scope ?
- storage_class : STORAGE_CLASS_AUTO;
- decl->symbol = symbol;
- decl->implicit = true;
- record_declaration(decl, false);
- return decl;
+ entity_t *entity = allocate_entity_zero(kind);
+ entity->base.source_position = *HERE;
+ entity->base.symbol = symbol;
+ if (is_declaration(entity)) {
+ entity->declaration.implicit = true;
+ }
+ record_entity(entity, false);
+ return entity;
}
/**
* Finish the construction of a struct type by calculating
* its size, offsets, alignment.
*/
-static void finish_struct_type(compound_type_t *type) {
- if (type->declaration == NULL)
- return;
- declaration_t *struct_decl = type->declaration;
- if (! struct_decl->init.complete)
+static void finish_struct_type(compound_type_t *type)
+{
+ assert(type->compound != NULL);
+
+ compound_t *compound = type->compound;
+ if (!compound->complete)
return;
il_size_t size = 0;
il_alignment_t alignment = 1;
bool need_pad = false;
- declaration_t *entry = struct_decl->scope.declarations;
- for (; entry != NULL; entry = entry->next) {
- if (entry->namespc != NAMESPACE_NORMAL)
+ entity_t *entry = compound->members.entities;
+ for (; entry != NULL; entry = entry->base.next) {
+ if (entry->kind != ENTITY_COMPOUND_MEMBER)
continue;
- type_t *m_type = skip_typeref(entry->type);
+ type_t *m_type = skip_typeref(entry->declaration.type);
if (! is_type_valid(m_type)) {
/* simply ignore errors here */
continue;
if (offset > size)
need_pad = true;
- entry->offset = offset;
+ entry->compound_member.offset = offset;
size = offset + m_type->base.size;
}
if (type->base.alignment != 0) {
need_pad = true;
if (warning.padded && need_pad) {
- warningf(&struct_decl->source_position,
- "'%#T' needs padding", type, struct_decl->symbol);
+ warningf(&compound->base.source_position,
+ "'%#T' needs padding", type, compound->base.symbol);
}
if (warning.packed && !need_pad) {
- warningf(&struct_decl->source_position,
+ warningf(&compound->base.source_position,
"superfluous packed attribute on '%#T'",
- type, struct_decl->symbol);
+ type, compound->base.symbol);
}
type->base.size = offset;
* Finish the construction of an union type by calculating
* its size and alignment.
*/
-static void finish_union_type(compound_type_t *type) {
- if (type->declaration == NULL)
- return;
- declaration_t *union_decl = type->declaration;
- if (! union_decl->init.complete)
+static void finish_union_type(compound_type_t *type)
+{
+ assert(type->compound != NULL);
+
+ compound_t *compound = type->compound;
+ if (! compound->complete)
return;
il_size_t size = 0;
il_alignment_t alignment = 1;
- declaration_t *entry = union_decl->scope.declarations;
- for (; entry != NULL; entry = entry->next) {
- if (entry->namespc != NAMESPACE_NORMAL)
+ entity_t *entry = compound->members.entities;
+ for (; entry != NULL; entry = entry->base.next) {
+ if (entry->kind != ENTITY_COMPOUND_MEMBER)
continue;
- type_t *m_type = skip_typeref(entry->type);
+ type_t *m_type = skip_typeref(entry->declaration.type);
if (! is_type_valid(m_type))
continue;
- entry->offset = 0;
+ entry->compound_member.offset = 0;
if (m_type->base.size > size)
size = m_type->base.size;
if (m_type->base.alignment > alignment)
/* storage class */
#define MATCH_STORAGE_CLASS(token, class) \
case token: \
- if (specifiers->declared_storage_class != STORAGE_CLASS_NONE) { \
+ if (specifiers->storage_class != STORAGE_CLASS_NONE) { \
errorf(HERE, "multiple storage classes in declaration specifiers"); \
} \
- specifiers->declared_storage_class = class; \
+ specifiers->storage_class = class; \
next_token(); \
break;
break;
case T___thread:
- switch (specifiers->declared_storage_class) {
+ switch (specifiers->storage_class) {
case STORAGE_CLASS_NONE:
- specifiers->declared_storage_class = STORAGE_CLASS_THREAD;
+ specifiers->storage_class = STORAGE_CLASS_THREAD;
break;
case STORAGE_CLASS_EXTERN:
- specifiers->declared_storage_class = STORAGE_CLASS_THREAD_EXTERN;
+ specifiers->storage_class = STORAGE_CLASS_THREAD_EXTERN;
break;
case STORAGE_CLASS_STATIC:
- specifiers->declared_storage_class = STORAGE_CLASS_THREAD_STATIC;
+ specifiers->storage_class = STORAGE_CLASS_THREAD_STATIC;
break;
default:
break;
case T_struct: {
- type = allocate_type_zero(TYPE_COMPOUND_STRUCT, HERE);
+ type = allocate_type_zero(TYPE_COMPOUND_STRUCT);
- type->compound.declaration = parse_compound_type_specifier(true);
+ type->compound.compound = parse_compound_type_specifier(true);
finish_struct_type(&type->compound);
break;
}
case T_union: {
- type = allocate_type_zero(TYPE_COMPOUND_UNION, HERE);
- type->compound.declaration = parse_compound_type_specifier(false);
- if (type->compound.declaration->modifiers & DM_TRANSPARENT_UNION)
+ type = allocate_type_zero(TYPE_COMPOUND_UNION);
+ type->compound.compound = parse_compound_type_specifier(false);
+ if (type->compound.compound->modifiers & DM_TRANSPARENT_UNION)
modifiers |= TYPE_MODIFIER_TRANSPARENT_UNION;
finish_union_type(&type->compound);
break;
case '*': {
errorf(HERE, "%K does not name a type", &token);
- declaration_t *const decl =
- create_error_declaration(token.v.symbol, STORAGE_CLASS_TYPEDEF);
+ entity_t *entity =
+ create_error_entity(token.v.symbol, ENTITY_TYPEDEF);
- type = allocate_type_zero(TYPE_TYPEDEF, HERE);
- type->typedeft.declaration = decl;
+ type = allocate_type_zero(TYPE_TYPEDEF);
+ type->typedeft.typedefe = &entity->typedefe;
next_token();
saw_error = true;
atomic_type_kind_t atomic_type;
/* match valid basic types */
- switch(type_specifiers) {
+ switch (type_specifiers) {
case SPECIFIER_VOID:
atomic_type = ATOMIC_TYPE_VOID;
break;
if (saw_error)
goto end_error;
- if (!strict_mode) {
+ /* ISO/IEC 14882:1998(E) §C.1.5:4 */
+ if (!(c_mode & _CXX) && !strict_mode) {
if (warning.implicit_int) {
warningf(HERE, "no type specifiers in declaration, using 'int'");
}
}
if (type_specifiers & SPECIFIER_COMPLEX) {
- type = allocate_type_zero(TYPE_COMPLEX, &builtin_source_position);
+ type = allocate_type_zero(TYPE_COMPLEX);
type->complex.akind = atomic_type;
} else if (type_specifiers & SPECIFIER_IMAGINARY) {
- type = allocate_type_zero(TYPE_IMAGINARY, &builtin_source_position);
+ type = allocate_type_zero(TYPE_IMAGINARY);
type->imaginary.akind = atomic_type;
} else {
- type = allocate_type_zero(TYPE_ATOMIC, &builtin_source_position);
+ type = allocate_type_zero(TYPE_ATOMIC);
type->atomic.akind = atomic_type;
}
newtype = true;
type_qualifiers_t qualifiers = TYPE_QUALIFIER_NONE;
while (true) {
- switch(token.type) {
+ switch (token.type) {
/* type qualifiers */
MATCH_TYPE_QUALIFIER(T_const, TYPE_QUALIFIER_CONST);
MATCH_TYPE_QUALIFIER(T_restrict, TYPE_QUALIFIER_RESTRICT);
}
/**
- * Parses an K&R identifier list and return a list of declarations.
- *
- * @param last points to the last declaration in the list
- * @return the list of declarations
+ * Parses an K&R identifier list
*/
-static declaration_t *parse_identifier_list(declaration_t **last)
+static void parse_identifier_list(scope_t *scope)
{
- declaration_t *declarations = NULL;
- declaration_t *last_declaration = NULL;
do {
- declaration_t *const declaration = allocate_declaration_zero();
- declaration->type = NULL; /* a K&R parameter list has no types, yet */
- declaration->source_position = token.source_position;
- declaration->symbol = token.v.symbol;
+ entity_t *entity = allocate_entity_zero(ENTITY_VARIABLE);
+ entity->base.source_position = token.source_position;
+ entity->base.namespc = NAMESPACE_NORMAL;
+ entity->base.symbol = token.v.symbol;
+ /* a K&R parameter has no type, yet */
next_token();
- if (last_declaration != NULL) {
- last_declaration->next = declaration;
- } else {
- declarations = declaration;
- }
- last_declaration = declaration;
+ append_entity(scope, entity);
if (token.type != ',') {
break;
}
next_token();
} while (token.type == T_IDENTIFIER);
-
- *last = last_declaration;
- return declarations;
}
static type_t *automatic_type_conversion(type_t *orig_type);
static void semantic_parameter(declaration_t *declaration)
{
/* TODO: improve error messages */
- source_position_t const* const pos = &declaration->source_position;
+ source_position_t const* const pos = &declaration->base.source_position;
+ /* §6.9.1:6 */
switch (declaration->declared_storage_class) {
- case STORAGE_CLASS_TYPEDEF:
- errorf(pos, "typedef not allowed in parameter list");
- break;
-
/* Allowed storage classes */
case STORAGE_CLASS_NONE:
case STORAGE_CLASS_REGISTER:
if (is_type_incomplete(skip_typeref(type))) {
errorf(pos, "parameter '%#T' is of incomplete type",
- orig_type, declaration->symbol);
+ orig_type, declaration->base.symbol);
}
}
-static declaration_t *parse_parameter(void)
+static entity_t *parse_parameter(void)
{
declaration_specifiers_t specifiers;
memset(&specifiers, 0, sizeof(specifiers));
parse_declaration_specifiers(&specifiers);
- declaration_t *declaration = parse_declarator(&specifiers, /*may_be_abstract=*/true);
-
- return declaration;
+ entity_t *entity = parse_declarator(&specifiers, true, false);
+ return entity;
}
/**
- * Parses a function type parameter list and return a list of declarations.
- *
- * @param last point to the last element of the list
- * @return the parameter list
+ * Parses function type parameters (and optionally creates variable_t entities
+ * for them in a scope)
*/
-static declaration_t *parse_parameters(function_type_t *type, declaration_t **last)
+static void parse_parameters(function_type_t *type, scope_t *scope)
{
- declaration_t *declarations = NULL;
-
eat('(');
add_anchor_token(')');
int saved_comma_state = save_and_reset_anchor_state(',');
token_type_t la1_type = (token_type_t)look_ahead(1)->type;
if (la1_type == ',' || la1_type == ')') {
type->kr_style_parameters = true;
- declarations = parse_identifier_list(last);
+ parse_identifier_list(scope);
goto parameters_finished;
}
}
if (token.type == ')') {
- type->unspecified_parameters = 1;
+ /* ISO/IEC 14882:1998(E) §C.1.6:1 */
+ if (!(c_mode & _CXX))
+ type->unspecified_parameters = true;
goto parameters_finished;
}
- declaration_t *declaration;
- declaration_t *last_declaration = NULL;
function_parameter_t *parameter;
function_parameter_t *last_parameter = NULL;
while (true) {
- switch(token.type) {
+ switch (token.type) {
case T_DOTDOTDOT:
next_token();
- type->variadic = 1;
+ type->variadic = true;
goto parameters_finished;
case T_IDENTIFIER:
case T___extension__:
DECLARATION_START
- declaration = parse_parameter();
+ {
+ entity_t *entity = parse_parameter();
+ if (entity->kind == ENTITY_TYPEDEF) {
+ errorf(&entity->base.source_position,
+ "typedef not allowed as function parameter");
+ break;
+ }
+ assert(is_declaration(entity));
/* func(void) is not a parameter */
if (last_parameter == NULL
&& token.type == ')'
- && declaration->symbol == NULL
- && skip_typeref(declaration->type) == type_void) {
+ && entity->base.symbol == NULL
+ && skip_typeref(entity->declaration.type) == type_void) {
goto parameters_finished;
}
- semantic_parameter(declaration);
+ semantic_parameter(&entity->declaration);
- parameter = obstack_alloc(type_obst, sizeof(parameter[0]));
+ parameter = obstack_alloc(type_obst, sizeof(parameter[0]));
memset(parameter, 0, sizeof(parameter[0]));
- parameter->type = declaration->type;
+ parameter->type = entity->declaration.type;
+
+ if (scope != NULL) {
+ append_entity(scope, entity);
+ }
if (last_parameter != NULL) {
- last_declaration->next = declaration;
- last_parameter->next = parameter;
+ last_parameter->next = parameter;
} else {
type->parameters = parameter;
- declarations = declaration;
}
last_parameter = parameter;
- last_declaration = declaration;
break;
+ }
default:
goto parameters_finished;
rem_anchor_token(')');
expect(')');
- restore_anchor_state(',', saved_comma_state);
- *last = last_declaration;
- return declarations;
-
end_error:
restore_anchor_state(',', saved_comma_state);
- *last = NULL;
- return NULL;
}
typedef enum construct_type_kind_t {
return (construct_type_t*) array;
}
-static construct_type_t *parse_function_declarator(declaration_t *declaration)
+static construct_type_t *parse_function_declarator(scope_t *scope)
{
- type_t *type;
- if (declaration != NULL) {
- type = allocate_type_zero(TYPE_FUNCTION, &declaration->source_position);
+ type_t *type = allocate_type_zero(TYPE_FUNCTION);
- unsigned mask = declaration->modifiers & (DM_CDECL|DM_STDCALL|DM_FASTCALL|DM_THISCALL);
+ /* TODO: revive this... once we know exactly how to do it */
+#if 0
+ decl_modifiers_t modifiers = entity->declaration.modifiers;
- if (mask & (mask-1)) {
- const char *first = NULL, *second = NULL;
+ unsigned mask = modifiers & (DM_CDECL|DM_STDCALL|DM_FASTCALL|DM_THISCALL);
- /* more than one calling convention set */
- if (declaration->modifiers & DM_CDECL) {
- if (first == NULL) first = "cdecl";
- else if (second == NULL) second = "cdecl";
- }
- if (declaration->modifiers & DM_STDCALL) {
- if (first == NULL) first = "stdcall";
- else if (second == NULL) second = "stdcall";
- }
- if (declaration->modifiers & DM_FASTCALL) {
- if (first == NULL) first = "fastcall";
- else if (second == NULL) second = "fastcall";
- }
- if (declaration->modifiers & DM_THISCALL) {
- if (first == NULL) first = "thiscall";
- else if (second == NULL) second = "thiscall";
- }
- errorf(&declaration->source_position, "%s and %s attributes are not compatible", first, second);
- }
+ if (mask & (mask-1)) {
+ const char *first = NULL, *second = NULL;
- if (declaration->modifiers & DM_CDECL)
- type->function.calling_convention = CC_CDECL;
- else if (declaration->modifiers & DM_STDCALL)
- type->function.calling_convention = CC_STDCALL;
- else if (declaration->modifiers & DM_FASTCALL)
- type->function.calling_convention = CC_FASTCALL;
- else if (declaration->modifiers & DM_THISCALL)
- type->function.calling_convention = CC_THISCALL;
- } else {
- type = allocate_type_zero(TYPE_FUNCTION, HERE);
+ /* more than one calling convention set */
+ if (modifiers & DM_CDECL) {
+ if (first == NULL) first = "cdecl";
+ else if (second == NULL) second = "cdecl";
+ }
+ if (modifiers & DM_STDCALL) {
+ if (first == NULL) first = "stdcall";
+ else if (second == NULL) second = "stdcall";
+ }
+ if (modifiers & DM_FASTCALL) {
+ if (first == NULL) first = "fastcall";
+ else if (second == NULL) second = "fastcall";
+ }
+ if (modifiers & DM_THISCALL) {
+ if (first == NULL) first = "thiscall";
+ else if (second == NULL) second = "thiscall";
+ }
+ errorf(&entity->base.source_position,
+ "%s and %s attributes are not compatible", first, second);
}
- declaration_t *last;
- declaration_t *parameters = parse_parameters(&type->function, &last);
- if (declaration != NULL) {
- declaration->scope.declarations = parameters;
- declaration->scope.last_declaration = last;
- declaration->scope.is_parameter = true;
- }
+ if (modifiers & DM_CDECL)
+ type->function.calling_convention = CC_CDECL;
+ else if (modifiers & DM_STDCALL)
+ type->function.calling_convention = CC_STDCALL;
+ else if (modifiers & DM_FASTCALL)
+ type->function.calling_convention = CC_FASTCALL;
+ else if (modifiers & DM_THISCALL)
+ type->function.calling_convention = CC_THISCALL;
+#endif
+
+ parse_parameters(&type->function, scope);
construct_function_type_t *construct_function_type =
obstack_alloc(&temp_obst, sizeof(construct_function_type[0]));
return &construct_function_type->construct_type;
}
-static void fix_declaration_type(declaration_t *declaration)
-{
- decl_modifiers_t declaration_modifiers = declaration->modifiers;
- type_modifiers_t type_modifiers = declaration->type->base.modifiers;
-
- if (declaration_modifiers & DM_TRANSPARENT_UNION)
- type_modifiers |= TYPE_MODIFIER_TRANSPARENT_UNION;
-
- if (declaration->type->base.modifiers == type_modifiers)
- return;
-
- type_t *copy = duplicate_type(declaration->type);
- copy->base.modifiers = type_modifiers;
-
- type_t *result = typehash_insert(copy);
- if (result != copy) {
- obstack_free(type_obst, copy);
- }
-
- declaration->type = result;
-}
+typedef struct parse_declarator_env_t {
+ decl_modifiers_t modifiers;
+ symbol_t *symbol;
+ source_position_t source_position;
+ scope_t parameters;
+} parse_declarator_env_t;
-static construct_type_t *parse_inner_declarator(declaration_t *declaration,
+static construct_type_t *parse_inner_declarator(parse_declarator_env_t *env,
bool may_be_abstract)
{
/* construct a single linked list of construct_type_t's which describe
* how to construct the final declarator type */
- construct_type_t *first = NULL;
- construct_type_t *last = NULL;
+ construct_type_t *first = NULL;
+ construct_type_t *last = NULL;
gnu_attribute_t *attributes = NULL;
decl_modifiers_t modifiers = parse_attributes(&attributes);
modifiers |= parse_attributes(&attributes);
}
- if (declaration != NULL)
- declaration->modifiers |= modifiers;
+ if (env != NULL)
+ env->modifiers |= modifiers;
construct_type_t *inner_types = NULL;
- switch(token.type) {
+ switch (token.type) {
case T_IDENTIFIER:
- if (declaration == NULL) {
+ if (env == NULL) {
errorf(HERE, "no identifier expected in typename");
} else {
- declaration->symbol = token.v.symbol;
- declaration->source_position = token.source_position;
+ env->symbol = token.v.symbol;
+ env->source_position = token.source_position;
}
next_token();
break;
case '(':
next_token();
add_anchor_token(')');
- inner_types = parse_inner_declarator(declaration, may_be_abstract);
+ inner_types = parse_inner_declarator(env, may_be_abstract);
if (inner_types != NULL) {
- /* All later declarators only modify the return type, not declaration */
- declaration = NULL;
+ /* All later declarators only modify the return type */
+ env = NULL;
}
rem_anchor_token(')');
expect(')');
while(true) {
construct_type_t *type;
- switch(token.type) {
- case '(':
- type = parse_function_declarator(declaration);
+ switch (token.type) {
+ case '(': {
+ scope_t *scope = NULL;
+ if (env != NULL)
+ scope = &env->parameters;
+
+ type = parse_function_declarator(scope);
break;
+ }
case '[':
type = parse_array_declarator();
break;
return NULL;
}
-static void parse_declaration_attributes(declaration_t *declaration)
+static void parse_declaration_attributes(entity_t *entity)
{
gnu_attribute_t *attributes = NULL;
decl_modifiers_t modifiers = parse_attributes(&attributes);
- if (declaration == NULL)
+ if (entity == NULL)
return;
- declaration->modifiers |= modifiers;
- /* check if we have these stupid mode attributes... */
- type_t *old_type = declaration->type;
- if (old_type == NULL)
+ type_t *type;
+ if (entity->kind == ENTITY_TYPEDEF) {
+ modifiers |= entity->typedefe.modifiers;
+ type = entity->typedefe.type;
+ } else {
+ assert(is_declaration(entity));
+ modifiers |= entity->declaration.modifiers;
+ type = entity->declaration.type;
+ }
+ if (type == NULL)
return;
+ /* handle these strange/stupid mode attributes */
gnu_attribute_t *attribute = attributes;
for ( ; attribute != NULL; attribute = attribute->next) {
if (attribute->kind != GNU_AK_MODE || attribute->invalid)
continue;
atomic_type_kind_t akind = attribute->u.akind;
- if (!is_type_signed(old_type)) {
- switch(akind) {
+ if (!is_type_signed(type)) {
+ switch (akind) {
case ATOMIC_TYPE_CHAR: akind = ATOMIC_TYPE_UCHAR; break;
case ATOMIC_TYPE_SHORT: akind = ATOMIC_TYPE_USHORT; break;
case ATOMIC_TYPE_INT: akind = ATOMIC_TYPE_UINT; break;
default:
panic("invalid akind in mode attribute");
}
+ } else {
+ switch (akind) {
+ case ATOMIC_TYPE_CHAR: akind = ATOMIC_TYPE_SCHAR; break;
+ case ATOMIC_TYPE_SHORT: akind = ATOMIC_TYPE_SHORT; break;
+ case ATOMIC_TYPE_INT: akind = ATOMIC_TYPE_INT; break;
+ case ATOMIC_TYPE_LONGLONG: akind = ATOMIC_TYPE_LONGLONG; break;
+ default:
+ panic("invalid akind in mode attribute");
+ }
}
- declaration->type
- = make_atomic_type(akind, old_type->base.qualifiers);
+
+ type = make_atomic_type(akind, type->base.qualifiers);
+ }
+
+ type_modifiers_t type_modifiers = type->base.modifiers;
+ if (modifiers & DM_TRANSPARENT_UNION)
+ modifiers |= TYPE_MODIFIER_TRANSPARENT_UNION;
+
+ if (type->base.modifiers != type_modifiers) {
+ type_t *copy = duplicate_type(type);
+ copy->base.modifiers = type_modifiers;
+
+ type = typehash_insert(copy);
+ if (type != copy) {
+ obstack_free(type_obst, copy);
+ }
+ }
+
+ if (entity->kind == ENTITY_TYPEDEF) {
+ entity->typedefe.type = type;
+ entity->typedefe.modifiers = modifiers;
+ } else {
+ entity->declaration.type = type;
+ entity->declaration.modifiers = modifiers;
}
}
{
construct_type_t *iter = construct_list;
for( ; iter != NULL; iter = iter->next) {
- switch(iter->kind) {
+ switch (iter->kind) {
case CONSTRUCT_INVALID:
internal_errorf(HERE, "invalid type construction found");
case CONSTRUCT_FUNCTION: {
} else if (is_type_array(skipped_return_type)) {
errorf(HERE, "function returning array is not allowed");
} else {
- if (skipped_return_type->base.qualifiers != 0) {
+ if (skipped_return_type->base.qualifiers != 0 && warning.other) {
warningf(HERE,
"type qualifiers in return type of function type are meaningless");
}
case CONSTRUCT_POINTER: {
parsed_pointer_t *parsed_pointer = (parsed_pointer_t*) iter;
- type_t *pointer_type = allocate_type_zero(TYPE_POINTER, &null_position);
- pointer_type->pointer.points_to = type;
- pointer_type->base.qualifiers = parsed_pointer->type_qualifiers;
-
- type = pointer_type;
- break;
+ type = make_pointer_type(type, parsed_pointer->type_qualifiers);
+ continue;
}
case CONSTRUCT_ARRAY: {
parsed_array_t *parsed_array = (parsed_array_t*) iter;
- type_t *array_type = allocate_type_zero(TYPE_ARRAY, &null_position);
+ type_t *array_type = allocate_type_zero(TYPE_ARRAY);
expression_t *size_expression = parsed_array->size;
if (size_expression != NULL) {
return type;
}
-static declaration_t *parse_declarator(
- const declaration_specifiers_t *specifiers, bool may_be_abstract)
+static entity_t *parse_declarator(const declaration_specifiers_t *specifiers,
+ bool may_be_abstract,
+ bool create_compound_member)
{
- declaration_t *const declaration = allocate_declaration_zero();
- declaration->source_position = specifiers->source_position;
- declaration->declared_storage_class = specifiers->declared_storage_class;
- declaration->modifiers = specifiers->modifiers;
- declaration->deprecated_string = specifiers->deprecated_string;
- declaration->get_property_sym = specifiers->get_property_sym;
- declaration->put_property_sym = specifiers->put_property_sym;
- declaration->is_inline = specifiers->is_inline;
+ parse_declarator_env_t env;
+ memset(&env, 0, sizeof(env));
- declaration->storage_class = specifiers->declared_storage_class;
- if (declaration->storage_class == STORAGE_CLASS_NONE &&
- scope != file_scope) {
- declaration->storage_class = STORAGE_CLASS_AUTO;
- }
+ construct_type_t *construct_type
+ = parse_inner_declarator(&env, may_be_abstract);
+ type_t *type = construct_declarator_type(construct_type, specifiers->type);
- if (specifiers->alignment != 0) {
- /* TODO: add checks here */
- declaration->alignment = specifiers->alignment;
+ if (construct_type != NULL) {
+ obstack_free(&temp_obst, construct_type);
}
- construct_type_t *construct_type
- = parse_inner_declarator(declaration, may_be_abstract);
- type_t *const type = specifiers->type;
- declaration->type = construct_declarator_type(construct_type, type);
+ entity_t *entity;
+ if (specifiers->storage_class == STORAGE_CLASS_TYPEDEF) {
+ entity = allocate_entity_zero(ENTITY_TYPEDEF);
+ entity->base.symbol = env.symbol;
+ entity->base.source_position = env.source_position;
+ entity->typedefe.type = type;
+ } else {
+ if (create_compound_member) {
+ entity = allocate_entity_zero(ENTITY_COMPOUND_MEMBER);
+ } else if (is_type_function(skip_typeref(type))) {
+ entity = allocate_entity_zero(ENTITY_FUNCTION);
- parse_declaration_attributes(declaration);
+ entity->function.is_inline = specifiers->is_inline;
+ entity->function.parameters = env.parameters;
+ } else {
+ entity = allocate_entity_zero(ENTITY_VARIABLE);
- fix_declaration_type(declaration);
+ entity->variable.get_property_sym = specifiers->get_property_sym;
+ entity->variable.put_property_sym = specifiers->put_property_sym;
+ if (specifiers->alignment != 0) {
+ /* TODO: add checks here */
+ entity->variable.alignment = specifiers->alignment;
+ }
- if (construct_type != NULL) {
- obstack_free(&temp_obst, construct_type);
+ if (warning.other && specifiers->is_inline && is_type_valid(type)) {
+ warningf(&env.source_position,
+ "variable '%Y' declared 'inline'\n", env.symbol);
+ }
+ }
+
+ entity->base.source_position = env.source_position;
+ entity->base.symbol = env.symbol;
+ entity->base.namespc = NAMESPACE_NORMAL;
+ entity->declaration.type = type;
+ entity->declaration.modifiers = env.modifiers | specifiers->modifiers;
+ entity->declaration.deprecated_string = specifiers->deprecated_string;
+
+ storage_class_t storage_class = specifiers->storage_class;
+ entity->declaration.declared_storage_class = storage_class;
+
+ if (storage_class == STORAGE_CLASS_NONE && scope != file_scope) {
+ storage_class = STORAGE_CLASS_AUTO;
+ }
+ entity->declaration.storage_class = storage_class;
}
- return declaration;
+ parse_declaration_attributes(entity);
+
+ return entity;
}
static type_t *parse_abstract_declarator(type_t *base_type)
return result;
}
-static declaration_t *append_declaration(declaration_t* const declaration)
-{
- if (last_declaration != NULL) {
- last_declaration->next = declaration;
- } else {
- scope->declarations = declaration;
- }
- last_declaration = declaration;
- return declaration;
-}
-
/**
* Check if the declaration of main is suspicious. main should be a
* function with external linkage, returning int, taking either zero
* @param decl the declaration to check
* @param type the function type of the declaration
*/
-static void check_type_of_main(const declaration_t *const decl, const function_type_t *const func_type)
+static void check_type_of_main(const entity_t *entity)
{
- if (decl->storage_class == STORAGE_CLASS_STATIC) {
- warningf(&decl->source_position,
- "'main' is normally a non-static function");
+ const source_position_t *pos = &entity->base.source_position;
+ if (entity->kind != ENTITY_FUNCTION) {
+ warningf(pos, "'main' is not a function");
+ return;
+ }
+
+ if (entity->declaration.storage_class == STORAGE_CLASS_STATIC) {
+ warningf(pos, "'main' is normally a non-static function");
}
+
+ type_t *type = skip_typeref(entity->declaration.type);
+ assert(is_type_function(type));
+
+ function_type_t *func_type = &type->function;
if (!types_compatible(skip_typeref(func_type->return_type), type_int)) {
- warningf(&decl->source_position,
- "return type of 'main' should be 'int', but is '%T'",
+ warningf(pos, "return type of 'main' should be 'int', but is '%T'",
func_type->return_type);
}
const function_parameter_t *parm = func_type->parameters;
if (parm != NULL) {
type_t *const first_type = parm->type;
if (!types_compatible(skip_typeref(first_type), type_int)) {
- warningf(&decl->source_position,
- "first argument of 'main' should be 'int', but is '%T'", first_type);
+ warningf(pos,
+ "first argument of 'main' should be 'int', but is '%T'",
+ first_type);
}
parm = parm->next;
if (parm != NULL) {
type_t *const second_type = parm->type;
if (!types_compatible(skip_typeref(second_type), type_char_ptr_ptr)) {
- warningf(&decl->source_position,
- "second argument of 'main' should be 'char**', but is '%T'", second_type);
+ warningf(pos, "second argument of 'main' should be 'char**', but is '%T'", second_type);
}
parm = parm->next;
if (parm != NULL) {
type_t *const third_type = parm->type;
if (!types_compatible(skip_typeref(third_type), type_char_ptr_ptr)) {
- warningf(&decl->source_position,
- "third argument of 'main' should be 'char**', but is '%T'", third_type);
+ warningf(pos, "third argument of 'main' should be 'char**', but is '%T'", third_type);
}
parm = parm->next;
if (parm != NULL)
}
} else {
warn_arg_count:
- warningf(&decl->source_position, "'main' takes only zero, two or three arguments");
+ warningf(pos, "'main' takes only zero, two or three arguments");
}
}
}
return strcmp(sym->string, "main") == 0;
}
-static declaration_t *record_declaration(
- declaration_t *const declaration,
- const bool is_definition)
+/**
+ * record entities for the NAMESPACE_NORMAL, and produce error messages/warnings
+ * for various problems that occur for multiple definitions
+ */
+static entity_t *record_entity(entity_t *entity, const bool is_definition)
{
- const symbol_t *const symbol = declaration->symbol;
- const namespace_t namespc = (namespace_t)declaration->namespc;
+ const symbol_t *const symbol = entity->base.symbol;
+ const namespace_t namespc = entity->base.namespc;
+ const source_position_t *pos = &entity->base.source_position;
assert(symbol != NULL);
- declaration_t *previous_declaration = get_declaration(symbol, namespc);
+ entity_t *previous_entity = get_entity(symbol, namespc);
+ /* pushing the same entity twice will break the stack structure */
+ assert(previous_entity != entity);
- type_t *const orig_type = declaration->type;
- type_t *const type = skip_typeref(orig_type);
- if (is_type_function(type) &&
- type->function.unspecified_parameters &&
- warning.strict_prototypes &&
- previous_declaration == NULL) {
- warningf(&declaration->source_position,
- "function declaration '%#T' is not a prototype",
- orig_type, symbol);
- }
-
- if (warning.main && is_type_function(type) && is_sym_main(symbol)) {
- check_type_of_main(declaration, &type->function);
- }
-
- if (warning.nested_externs &&
- declaration->storage_class == STORAGE_CLASS_EXTERN &&
- scope != file_scope) {
- warningf(&declaration->source_position,
- "nested extern declaration of '%#T'", declaration->type, symbol);
- }
-
- assert(declaration != previous_declaration);
- if (previous_declaration != NULL &&
- previous_declaration->parent_scope->is_parameter &&
- scope->depth == previous_declaration->parent_scope->depth + 1) {
- errorf(&declaration->source_position,
- "declaration '%#T' redeclares the parameter '%#T' (declared %P)",
- orig_type, symbol, previous_declaration->type, symbol,
- &previous_declaration->source_position);
+ if (entity->kind == ENTITY_FUNCTION) {
+ type_t *const orig_type = entity->declaration.type;
+ type_t *const type = skip_typeref(orig_type);
+
+ assert(is_type_function(type));
+ if (type->function.unspecified_parameters &&
+ warning.strict_prototypes &&
+ previous_entity == NULL) {
+ warningf(pos, "function declaration '%#T' is not a prototype",
+ orig_type, symbol);
+ }
+
+ if (warning.main && scope == file_scope && is_sym_main(symbol)) {
+ check_type_of_main(entity);
+ }
+ }
+
+ if (is_declaration(entity)) {
+ if (warning.nested_externs
+ && entity->declaration.storage_class == STORAGE_CLASS_EXTERN
+ && scope != file_scope) {
+ warningf(pos, "nested extern declaration of '%#T'",
+ entity->declaration.type, symbol);
+ }
+ }
+
+ if (previous_entity != NULL
+ && previous_entity->base.parent_scope == ¤t_function->parameters
+ && scope->depth == previous_entity->base.parent_scope->depth + 1) {
+
+ assert(previous_entity->kind == ENTITY_VARIABLE);
+ errorf(pos,
+ "declaration '%#T' redeclares the parameter '%#T' (declared %P)",
+ entity->declaration.type, symbol,
+ previous_entity->declaration.type, symbol,
+ &previous_entity->base.source_position);
goto finish;
}
- if (previous_declaration != NULL &&
- previous_declaration->parent_scope == scope) {
- /* can happen for K&R style declarations */
- if (previous_declaration->type == NULL) {
- previous_declaration->type = declaration->type;
+
+ if (previous_entity != NULL
+ && previous_entity->base.parent_scope == scope) {
+
+ if (previous_entity->kind != entity->kind) {
+ errorf(pos,
+ "redeclaration of '%Y' as different kind of symbol (declared %P)",
+ symbol, &previous_entity->base.source_position);
+ goto finish;
}
+ if (previous_entity->kind == ENTITY_ENUM_VALUE) {
+ errorf(pos,
+ "redeclaration of enum entry '%Y' (declared %P)",
+ symbol, &previous_entity->base.source_position);
+ goto finish;
+ }
+ if (previous_entity->kind == ENTITY_TYPEDEF) {
+ /* TODO: C++ allows this for exactly the same type */
+ errorf(pos,
+ "redefinition of typedef '%Y' (declared %P)",
+ symbol, &previous_entity->base.source_position);
+ goto finish;
+ }
+
+ /* at this point we should have only VARIABLES or FUNCTIONS */
+ assert(is_declaration(previous_entity) && is_declaration(entity));
+
+ /* can happen for K&R style declarations */
+ if (previous_entity->kind == ENTITY_VARIABLE
+ && previous_entity->declaration.type == NULL
+ && entity->kind == ENTITY_VARIABLE) {
+ previous_entity->declaration.type = entity->declaration.type;
+ previous_entity->declaration.storage_class
+ = entity->declaration.storage_class;
+ previous_entity->declaration.declared_storage_class
+ = entity->declaration.declared_storage_class;
+ previous_entity->declaration.modifiers
+ = entity->declaration.modifiers;
+ previous_entity->declaration.deprecated_string
+ = entity->declaration.deprecated_string;
+ }
+ assert(entity->declaration.type != NULL);
+
+ declaration_t *const previous_declaration
+ = &previous_entity->declaration;
+ declaration_t *const declaration = &entity->declaration;
+ type_t *const orig_type = entity->declaration.type;
+ type_t *const type = skip_typeref(orig_type);
+
+ type_t *prev_type = skip_typeref(previous_declaration->type);
- const type_t *prev_type = skip_typeref(previous_declaration->type);
if (!types_compatible(type, prev_type)) {
- errorf(&declaration->source_position,
+ errorf(pos,
"declaration '%#T' is incompatible with '%#T' (declared %P)",
orig_type, symbol, previous_declaration->type, symbol,
- &previous_declaration->source_position);
+ &previous_entity->base.source_position);
} else {
unsigned old_storage_class = previous_declaration->storage_class;
- if (old_storage_class == STORAGE_CLASS_ENUM_ENTRY) {
- errorf(&declaration->source_position,
- "redeclaration of enum entry '%Y' (declared %P)",
- symbol, &previous_declaration->source_position);
- return previous_declaration;
- }
-
- if (warning.redundant_decls &&
- is_definition &&
- previous_declaration->storage_class == STORAGE_CLASS_STATIC &&
- !(previous_declaration->modifiers & DM_USED) &&
- !previous_declaration->used) {
- warningf(&previous_declaration->source_position,
+ if (warning.redundant_decls && is_definition
+ && previous_declaration->storage_class == STORAGE_CLASS_STATIC
+ && !(previous_declaration->modifiers & DM_USED)
+ && !previous_declaration->used) {
+ warningf(&previous_entity->base.source_position,
"unnecessary static forward declaration for '%#T'",
previous_declaration->type, symbol);
}
unsigned new_storage_class = declaration->storage_class;
-
if (is_type_incomplete(prev_type)) {
previous_declaration->type = type;
prev_type = type;
/* pretend no storage class means extern for function
* declarations (except if the previous declaration is neither
* none nor extern) */
- if (is_type_function(type)) {
+ if (entity->kind == ENTITY_FUNCTION) {
if (prev_type->function.unspecified_parameters) {
previous_declaration->type = type;
prev_type = type;
if (warning.missing_prototypes &&
prev_type->function.unspecified_parameters &&
!is_sym_main(symbol)) {
- warningf(&declaration->source_position,
- "no previous prototype for '%#T'",
+ warningf(pos, "no previous prototype for '%#T'",
orig_type, symbol);
}
} else if (new_storage_class == STORAGE_CLASS_NONE) {
if (!is_definition &&
warning.redundant_decls &&
is_type_valid(prev_type) &&
- strcmp(previous_declaration->source_position.input_name, "<builtin>") != 0) {
- warningf(&declaration->source_position,
+ strcmp(previous_entity->base.source_position.input_name, "<builtin>") != 0) {
+ warningf(pos,
"redundant declaration for '%Y' (declared %P)",
- symbol, &previous_declaration->source_position);
+ symbol, &previous_entity->base.source_position);
}
} else if (current_function == NULL) {
if (old_storage_class != STORAGE_CLASS_STATIC &&
new_storage_class == STORAGE_CLASS_STATIC) {
- errorf(&declaration->source_position,
+ errorf(pos,
"static declaration of '%Y' follows non-static declaration (declared %P)",
- symbol, &previous_declaration->source_position);
+ symbol, &previous_entity->base.source_position);
} else if (old_storage_class == STORAGE_CLASS_EXTERN) {
previous_declaration->storage_class = STORAGE_CLASS_NONE;
previous_declaration->declared_storage_class = STORAGE_CLASS_NONE;
} else {
+ /* ISO/IEC 14882:1998(E) §C.1.2:1 */
+ if (c_mode & _CXX)
+ goto error_redeclaration;
goto warn_redundant_declaration;
}
} else if (is_type_valid(prev_type)) {
if (old_storage_class == new_storage_class) {
- errorf(&declaration->source_position,
- "redeclaration of '%Y' (declared %P)",
- symbol, &previous_declaration->source_position);
+error_redeclaration:
+ errorf(pos, "redeclaration of '%Y' (declared %P)",
+ symbol, &previous_entity->base.source_position);
} else {
- errorf(&declaration->source_position,
+ errorf(pos,
"redeclaration of '%Y' with different linkage (declared %P)",
- symbol, &previous_declaration->source_position);
+ symbol, &previous_entity->base.source_position);
}
}
}
previous_declaration->modifiers |= declaration->modifiers;
- previous_declaration->is_inline |= declaration->is_inline;
- return previous_declaration;
- } else if (is_type_function(type)) {
+ if (entity->kind == ENTITY_FUNCTION) {
+ previous_entity->function.is_inline |= entity->function.is_inline;
+ }
+ return previous_entity;
+ }
+
+ if (entity->kind == ENTITY_FUNCTION) {
if (is_definition &&
- declaration->storage_class != STORAGE_CLASS_STATIC) {
+ entity->declaration.storage_class != STORAGE_CLASS_STATIC) {
if (warning.missing_prototypes && !is_sym_main(symbol)) {
- warningf(&declaration->source_position,
- "no previous prototype for '%#T'", orig_type, symbol);
+ warningf(pos, "no previous prototype for '%#T'",
+ entity->declaration.type, symbol);
} else if (warning.missing_declarations && !is_sym_main(symbol)) {
- warningf(&declaration->source_position,
- "no previous declaration for '%#T'", orig_type,
- symbol);
+ warningf(pos, "no previous declaration for '%#T'",
+ entity->declaration.type, symbol);
}
}
- } else {
- if (warning.missing_declarations &&
- scope == file_scope && (
- declaration->storage_class == STORAGE_CLASS_NONE ||
- declaration->storage_class == STORAGE_CLASS_THREAD
- )) {
- warningf(&declaration->source_position,
- "no previous declaration for '%#T'", orig_type, symbol);
+ } else if (warning.missing_declarations
+ && entity->kind == ENTITY_VARIABLE
+ && scope == file_scope) {
+ declaration_t *declaration = &entity->declaration;
+ if (declaration->storage_class == STORAGE_CLASS_NONE ||
+ declaration->storage_class == STORAGE_CLASS_THREAD) {
+ warningf(pos, "no previous declaration for '%#T'",
+ declaration->type, symbol);
}
}
+
finish:
- assert(declaration->parent_scope == NULL);
+ assert(entity->base.parent_scope == NULL);
assert(scope != NULL);
- declaration->parent_scope = scope;
+ entity->base.parent_scope = scope;
+ entity->base.namespc = NAMESPACE_NORMAL;
+ environment_push(entity);
+ append_entity(scope, entity);
- environment_push(declaration);
- return append_declaration(declaration);
+ return entity;
}
-static void parser_error_multiple_definition(declaration_t *declaration,
+static void parser_error_multiple_definition(entity_t *entity,
const source_position_t *source_position)
{
errorf(source_position, "multiple definition of symbol '%Y' (declared %P)",
- declaration->symbol, &declaration->source_position);
+ entity->base.symbol, &entity->base.source_position);
}
static bool is_declaration_specifier(const token_t *token,
}
}
-static void parse_init_declarator_rest(declaration_t *declaration)
+static void parse_init_declarator_rest(entity_t *entity)
{
+ assert(is_declaration(entity));
+ declaration_t *const declaration = &entity->declaration;
+
eat('=');
type_t *orig_type = declaration->type;
type_t *type = skip_typeref(orig_type);
- if (declaration->init.initializer != NULL) {
- parser_error_multiple_definition(declaration, HERE);
+ if (entity->kind == ENTITY_VARIABLE
+ && entity->variable.initializer != NULL) {
+ parser_error_multiple_definition(entity, HERE);
}
bool must_be_constant = false;
if (declaration->storage_class == STORAGE_CLASS_STATIC ||
declaration->storage_class == STORAGE_CLASS_THREAD_STATIC ||
- declaration->parent_scope == file_scope) {
+ entity->base.parent_scope == file_scope) {
must_be_constant = true;
}
if (is_type_function(type)) {
- errorf(&declaration->source_position,
+ errorf(&entity->base.source_position,
"function '%#T' is initialized like a variable",
- orig_type, declaration->symbol);
+ orig_type, entity->base.symbol);
orig_type = type_error_type;
}
parse_initializer_env_t env;
env.type = orig_type;
env.must_be_constant = must_be_constant;
- env.declaration = current_init_decl = declaration;
+ env.entity = entity;
+ current_init_decl = entity;
initializer_t *initializer = parse_initializer(&env);
current_init_decl = NULL;
- if (!is_type_function(type)) {
- /* § 6.7.5 (22) array initializers for arrays with unknown size determine
- * the array type size */
- declaration->type = env.type;
- declaration->init.initializer = initializer;
+ if (entity->kind == ENTITY_VARIABLE) {
+ /* § 6.7.5 (22) array initializers for arrays with unknown size
+ * determine the array type size */
+ declaration->type = env.type;
+ entity->variable.initializer = initializer;
}
}
{
eat(';');
- if (specifiers->declared_storage_class != STORAGE_CLASS_NONE) {
- warningf(&specifiers->source_position,
- "useless storage class in empty declaration");
- }
+ if (warning.other) {
+ if (specifiers->storage_class != STORAGE_CLASS_NONE) {
+ warningf(&specifiers->source_position,
+ "useless storage class in empty declaration");
+ }
- type_t *type = specifiers->type;
- switch (type->kind) {
- case TYPE_COMPOUND_STRUCT:
- case TYPE_COMPOUND_UNION: {
- if (type->compound.declaration->symbol == NULL) {
- warningf(&specifiers->source_position,
- "unnamed struct/union that defines no instances");
+ type_t *type = specifiers->type;
+ switch (type->kind) {
+ case TYPE_COMPOUND_STRUCT:
+ case TYPE_COMPOUND_UNION: {
+ if (type->compound.compound->base.symbol == NULL) {
+ warningf(&specifiers->source_position,
+ "unnamed struct/union that defines no instances");
+ }
+ break;
}
- break;
- }
- case TYPE_ENUM:
- break;
+ case TYPE_ENUM:
+ break;
- default:
- warningf(&specifiers->source_position, "empty declaration");
- break;
+ default:
+ warningf(&specifiers->source_position, "empty declaration");
+ break;
+ }
}
-
-#ifdef RECORD_EMPTY_DECLARATIONS
- declaration_t *const declaration = allocate_declaration_zero();
- declaration->type = specifiers->type;
- declaration->declared_storage_class = specifiers->declared_storage_class;
- declaration->source_position = specifiers->source_position;
- declaration->modifiers = specifiers->modifiers;
- declaration->storage_class = STORAGE_CLASS_NONE;
-
- append_declaration(declaration);
-#endif
}
-static void parse_declaration_rest(declaration_t *ndeclaration,
+static void parse_declaration_rest(entity_t *ndeclaration,
const declaration_specifiers_t *specifiers,
parsed_declaration_func finished_declaration)
{
add_anchor_token(';');
add_anchor_token(',');
while(true) {
- declaration_t *declaration =
- finished_declaration(ndeclaration, token.type == '=');
-
- type_t *orig_type = declaration->type;
- type_t *type = skip_typeref(orig_type);
-
- if (type->kind != TYPE_FUNCTION &&
- declaration->is_inline &&
- is_type_valid(type)) {
- warningf(&declaration->source_position,
- "variable '%Y' declared 'inline'\n", declaration->symbol);
- }
+ entity_t *entity = finished_declaration(ndeclaration, token.type == '=');
if (token.type == '=') {
- parse_init_declarator_rest(declaration);
+ parse_init_declarator_rest(entity);
}
if (token.type != ',')
eat(',');
add_anchor_token('=');
- ndeclaration = parse_declarator(specifiers, /*may_be_abstract=*/false);
+ ndeclaration = parse_declarator(specifiers, /*may_be_abstract=*/false, false);
rem_anchor_token('=');
}
expect(';');
rem_anchor_token(',');
}
-static declaration_t *finished_kr_declaration(declaration_t *declaration, bool is_definition)
+static entity_t *finished_kr_declaration(entity_t *entity, bool is_definition)
{
- symbol_t *symbol = declaration->symbol;
+ symbol_t *symbol = entity->base.symbol;
if (symbol == NULL) {
errorf(HERE, "anonymous declaration not valid as function parameter");
- return declaration;
- }
- namespace_t namespc = (namespace_t) declaration->namespc;
- if (namespc != NAMESPACE_NORMAL) {
- return record_declaration(declaration, false);
+ return entity;
}
- declaration_t *previous_declaration = get_declaration(symbol, namespc);
- if (previous_declaration == NULL ||
- previous_declaration->parent_scope != scope) {
+ assert(entity->base.namespc == NAMESPACE_NORMAL);
+ entity_t *previous_entity = get_entity(symbol, NAMESPACE_NORMAL);
+ if (previous_entity == NULL
+ || previous_entity->base.parent_scope != scope) {
errorf(HERE, "expected declaration of a function parameter, found '%Y'",
symbol);
- return declaration;
+ return entity;
}
if (is_definition) {
- errorf(HERE, "parameter %Y is initialised", declaration->symbol);
+ errorf(HERE, "parameter %Y is initialised", entity->base.symbol);
}
- if (previous_declaration->type == NULL) {
- previous_declaration->type = declaration->type;
- previous_declaration->declared_storage_class = declaration->declared_storage_class;
- previous_declaration->storage_class = declaration->storage_class;
- previous_declaration->parent_scope = scope;
- return previous_declaration;
- } else {
- return record_declaration(declaration, false);
- }
+ return record_entity(entity, false);
}
static void parse_declaration(parsed_declaration_func finished_declaration)
if (token.type == ';') {
parse_anonymous_declaration_rest(&specifiers);
} else {
- declaration_t *declaration = parse_declarator(&specifiers, /*may_be_abstract=*/false);
- parse_declaration_rest(declaration, &specifiers, finished_declaration);
+ entity_t *entity = parse_declarator(&specifiers, /*may_be_abstract=*/false, false);
+ parse_declaration_rest(entity, &specifiers, finished_declaration);
}
}
return result;
}
-static void parse_kr_declaration_list(declaration_t *declaration)
+static void parse_kr_declaration_list(entity_t *entity)
{
- type_t *type = skip_typeref(declaration->type);
- if (!is_type_function(type))
+ if (entity->kind != ENTITY_FUNCTION)
return;
+ type_t *type = skip_typeref(entity->declaration.type);
+ assert(is_type_function(type));
if (!type->function.kr_style_parameters)
return;
+
add_anchor_token('{');
/* push function parameters */
size_t const top = environment_top();
- scope_push(&declaration->scope);
+ scope_push(&entity->function.parameters);
- declaration_t *parameter = declaration->scope.declarations;
- for ( ; parameter != NULL; parameter = parameter->next) {
- assert(parameter->parent_scope == NULL);
- parameter->parent_scope = scope;
+ entity_t *parameter = entity->function.parameters.entities;
+ for ( ; parameter != NULL; parameter = parameter->base.next) {
+ assert(parameter->base.parent_scope == NULL);
+ parameter->base.parent_scope = scope;
environment_push(parameter);
}
}
/* pop function parameters */
- assert(scope == &declaration->scope);
+ assert(scope == &entity->function.parameters);
scope_pop();
environment_pop_to(top);
function_parameter_t *parameters = NULL;
function_parameter_t *last_parameter = NULL;
- declaration_t *parameter_declaration = declaration->scope.declarations;
+ entity_t *parameter_declaration = entity->function.parameters.entities;
for( ; parameter_declaration != NULL;
- parameter_declaration = parameter_declaration->next) {
- type_t *parameter_type = parameter_declaration->type;
+ parameter_declaration = parameter_declaration->base.next) {
+ type_t *parameter_type = parameter_declaration->declaration.type;
if (parameter_type == NULL) {
if (strict_mode) {
errorf(HERE, "no type specified for function parameter '%Y'",
- parameter_declaration->symbol);
+ parameter_declaration->base.symbol);
} else {
if (warning.implicit_int) {
warningf(HERE, "no type specified for function parameter '%Y', using 'int'",
- parameter_declaration->symbol);
+ parameter_declaration->base.symbol);
}
- parameter_type = type_int;
- parameter_declaration->type = parameter_type;
+ parameter_type = type_int;
+ parameter_declaration->declaration.type = parameter_type;
}
}
- semantic_parameter(parameter_declaration);
- parameter_type = parameter_declaration->type;
+ semantic_parameter(¶meter_declaration->declaration);
+ parameter_type = parameter_declaration->declaration.type;
/*
* we need the default promoted types for the function type
obstack_free(type_obst, new_type);
}
- declaration->type = type;
+ entity->declaration.type = type;
rem_anchor_token('{');
}
if (first_err) {
first_err = false;
diagnosticf("%s: In function '%Y':\n",
- current_function->source_position.input_name,
- current_function->symbol);
+ current_function->base.base.source_position.input_name,
+ current_function->base.base.symbol);
}
}
if (goto_statement->expression != NULL)
continue;
- declaration_t *label = goto_statement->label;
+ label_t *label = goto_statement->label;
label->used = true;
- if (label->source_position.input_name == NULL) {
+ if (label->base.source_position.input_name == NULL) {
print_in_function();
errorf(&goto_statement->base.source_position,
- "label '%Y' used but not defined", label->symbol);
+ "label '%Y' used but not defined", label->base.symbol);
}
}
- goto_first = goto_last = NULL;
+ goto_first = NULL;
+ goto_last = NULL;
if (warning.unused_label) {
for (const label_statement_t *label_statement = label_first;
label_statement != NULL;
label_statement = label_statement->next) {
- const declaration_t *label = label_statement->label;
+ label_t *label = label_statement->label;
if (! label->used) {
print_in_function();
warningf(&label_statement->base.source_position,
- "label '%Y' defined but not used", label->symbol);
+ "label '%Y' defined but not used", label->base.symbol);
}
}
}
label_first = label_last = NULL;
}
-/**
- * Check declarations of current_function for unused entities.
- */
-static void check_declarations(void)
+static void warn_unused_decl(entity_t *entity, entity_t *end,
+ char const *const what)
{
- if (warning.unused_parameter) {
- const scope_t *scope = ¤t_function->scope;
+ for (; entity != NULL; entity = entity->base.next) {
+ if (!is_declaration(entity))
+ continue;
+
+ declaration_t *declaration = &entity->declaration;
+ if (declaration->implicit)
+ continue;
+
+ if (!declaration->used) {
+ print_in_function();
+ warningf(&entity->base.source_position, "%s '%Y' is unused",
+ what, entity->base.symbol);
+ } else if (entity->kind == ENTITY_VARIABLE && !entity->variable.read) {
+ print_in_function();
+ warningf(&entity->base.source_position, "%s '%Y' is never read",
+ what, entity->base.symbol);
+ }
- if (is_sym_main(current_function->symbol)) {
- /* do not issue unused warnings for main */
+ if (entity == end)
+ break;
+ }
+}
+
+static void check_unused_variables(statement_t *const stmt, void *const env)
+{
+ (void)env;
+
+ switch (stmt->kind) {
+ case STATEMENT_DECLARATION: {
+ declaration_statement_t const *const decls = &stmt->declaration;
+ warn_unused_decl(decls->declarations_begin, decls->declarations_end,
+ "variable");
return;
}
- const declaration_t *parameter = scope->declarations;
- for (; parameter != NULL; parameter = parameter->next) {
- if (! parameter->used) {
- print_in_function();
- warningf(¶meter->source_position,
- "unused parameter '%Y'", parameter->symbol);
- }
+
+ case STATEMENT_FOR:
+ warn_unused_decl(stmt->fors.scope.entities, NULL, "variable");
+ return;
+
+ default:
+ return;
+ }
+}
+
+/**
+ * Check declarations of current_function for unused entities.
+ */
+static void check_declarations(void)
+{
+ if (warning.unused_parameter) {
+ const scope_t *scope = ¤t_function->parameters;
+
+ /* do not issue unused warnings for main */
+ if (!is_sym_main(current_function->base.base.symbol)) {
+ warn_unused_decl(scope->entities, NULL, "parameter");
}
}
if (warning.unused_variable) {
+ walk_statements(current_function->statement, check_unused_variables,
+ NULL);
}
}
-1;
}
+static bool expression_returns(expression_t const *const expr)
+{
+ switch (expr->kind) {
+ case EXPR_CALL: {
+ expression_t const *const func = expr->call.function;
+ if (func->kind == EXPR_REFERENCE) {
+ entity_t *entity = func->reference.entity;
+ if (entity->kind == ENTITY_FUNCTION
+ && entity->declaration.modifiers & DM_NORETURN)
+ return false;
+ }
+
+ if (!expression_returns(func))
+ return false;
+
+ for (call_argument_t const* arg = expr->call.arguments; arg != NULL; arg = arg->next) {
+ if (!expression_returns(arg->expression))
+ return false;
+ }
+
+ return true;
+ }
+
+ case EXPR_REFERENCE:
+ case EXPR_REFERENCE_ENUM_VALUE:
+ case EXPR_CONST:
+ case EXPR_CHARACTER_CONSTANT:
+ case EXPR_WIDE_CHARACTER_CONSTANT:
+ case EXPR_STRING_LITERAL:
+ case EXPR_WIDE_STRING_LITERAL:
+ case EXPR_COMPOUND_LITERAL: // TODO descend into initialisers
+ case EXPR_LABEL_ADDRESS:
+ case EXPR_CLASSIFY_TYPE:
+ case EXPR_SIZEOF: // TODO handle obscure VLA case
+ case EXPR_ALIGNOF:
+ case EXPR_FUNCNAME:
+ case EXPR_BUILTIN_SYMBOL:
+ case EXPR_BUILTIN_CONSTANT_P:
+ case EXPR_BUILTIN_PREFETCH:
+ case EXPR_OFFSETOF:
+ case EXPR_STATEMENT: // TODO implement
+ return true;
+
+ case EXPR_CONDITIONAL:
+ // TODO handle constant expression
+ return
+ expression_returns(expr->conditional.condition) && (
+ expression_returns(expr->conditional.true_expression) ||
+ expression_returns(expr->conditional.false_expression)
+ );
+
+ case EXPR_SELECT:
+ return expression_returns(expr->select.compound);
+
+ case EXPR_ARRAY_ACCESS:
+ return
+ expression_returns(expr->array_access.array_ref) &&
+ expression_returns(expr->array_access.index);
+
+ case EXPR_VA_START:
+ return expression_returns(expr->va_starte.ap);
+
+ case EXPR_VA_ARG:
+ return expression_returns(expr->va_arge.ap);
+
+ EXPR_UNARY_CASES_MANDATORY
+ return expression_returns(expr->unary.value);
+
+ case EXPR_UNARY_THROW:
+ return false;
+
+ EXPR_BINARY_CASES
+ // TODO handle constant lhs of && and ||
+ return
+ expression_returns(expr->binary.left) &&
+ expression_returns(expr->binary.right);
+
+ case EXPR_UNKNOWN:
+ case EXPR_INVALID:
+ break;
+ }
+
+ panic("unhandled expression");
+}
+
static bool noreturn_candidate;
static void check_reachable(statement_t *const stmt)
case STATEMENT_INVALID:
case STATEMENT_EMPTY:
case STATEMENT_DECLARATION:
+ case STATEMENT_LOCAL_LABEL:
case STATEMENT_ASM:
next = stmt->base.next;
break;
case STATEMENT_EXPRESSION: {
/* Check for noreturn function call */
expression_t const *const expr = stmt->expression.expression;
- if (expr->kind == EXPR_CALL) {
- expression_t const *const func = expr->call.function;
- if (func->kind == EXPR_REFERENCE) {
- declaration_t const *const decl = func->reference.declaration;
- if (decl != NULL && decl->modifiers & DM_NORETURN) {
- return;
- }
- }
- }
+ if (!expression_returns(expr))
+ return;
next = stmt->base.next;
break;
return;
next = parent;
} else {
- next = stmt->gotos.label->init.statement;
+ next = stmt->gotos.label->statement;
if (next == NULL) /* missing label */
return;
}
if (next == NULL) {
noreturn_candidate = false;
- type_t *const type = current_function->type;
+ type_t *const type = current_function->base.type;
assert(is_type_function(type));
type_t *const ret = skip_typeref(type->function.return_type);
if (warning.return_type &&
!is_type_atomic(ret, ATOMIC_TYPE_VOID) &&
is_type_valid(ret) &&
- !is_sym_main(current_function->symbol)) {
+ !is_sym_main(current_function->base.base.symbol)) {
warningf(&stmt->base.source_position,
"control reaches end of non-void function");
}
case STATEMENT_INVALID:
case STATEMENT_EMPTY:
case STATEMENT_DECLARATION:
+ case STATEMENT_LOCAL_LABEL:
case STATEMENT_EXPRESSION:
case STATEMENT_ASM:
case STATEMENT_RETURN:
}
}
- if (next == NULL) {
- next = stmt->base.parent;
- if (next == NULL) {
- warningf(&stmt->base.source_position,
- "control reaches end of non-void function");
- }
- }
-
check_reachable(next);
}
-static void check_unreachable(statement_t const* const stmt)
+static void check_unreachable(statement_t* const stmt, void *const env)
{
- if (!stmt->base.reachable &&
- stmt->kind != STATEMENT_DO_WHILE &&
- stmt->kind != STATEMENT_FOR &&
- (stmt->kind != STATEMENT_COMPOUND || stmt->compound.statements == NULL)) {
- warningf(&stmt->base.source_position, "statement is unreachable");
- }
+ (void)env;
switch (stmt->kind) {
- case STATEMENT_INVALID:
- case STATEMENT_EMPTY:
- case STATEMENT_RETURN:
- case STATEMENT_DECLARATION:
- case STATEMENT_EXPRESSION:
- case STATEMENT_CONTINUE:
- case STATEMENT_BREAK:
- case STATEMENT_GOTO:
- case STATEMENT_ASM:
- case STATEMENT_LEAVE:
- break;
-
- case STATEMENT_COMPOUND:
- if (stmt->compound.statements)
- check_unreachable(stmt->compound.statements);
- break;
-
- case STATEMENT_IF:
- check_unreachable(stmt->ifs.true_statement);
- if (stmt->ifs.false_statement != NULL)
- check_unreachable(stmt->ifs.false_statement);
- break;
-
- case STATEMENT_SWITCH:
- check_unreachable(stmt->switchs.body);
- break;
-
- case STATEMENT_LABEL:
- check_unreachable(stmt->label.statement);
- break;
-
- case STATEMENT_CASE_LABEL:
- check_unreachable(stmt->case_label.statement);
- break;
-
- case STATEMENT_WHILE:
- check_unreachable(stmt->whiles.body);
- break;
-
case STATEMENT_DO_WHILE:
- check_unreachable(stmt->do_while.body);
if (!stmt->base.reachable) {
expression_t const *const cond = stmt->do_while.condition;
if (determine_truth(cond) >= 0) {
"condition of do-while-loop is unreachable");
}
}
- break;
+ return;
case STATEMENT_FOR: {
for_statement_t const* const fors = &stmt->fors;
"step of for-statement is unreachable");
}
}
-
- check_unreachable(fors->body);
- break;
+ return;
}
- case STATEMENT_MS_TRY: {
- ms_try_statement_t const *const ms_try = &stmt->ms_try;
- check_unreachable(ms_try->try_statement);
- check_unreachable(ms_try->final_statement);
- }
- }
+ case STATEMENT_COMPOUND:
+ if (stmt->compound.statements != NULL)
+ return;
+ /* FALLTHROUGH*/
- if (stmt->base.next)
- check_unreachable(stmt->base.next);
+ default:
+ if (!stmt->base.reachable)
+ warningf(&stmt->base.source_position, "statement is unreachable");
+ return;
+ }
}
static void parse_external_declaration(void)
add_anchor_token('{');
/* declarator is common to both function-definitions and declarations */
- declaration_t *ndeclaration = parse_declarator(&specifiers, /*may_be_abstract=*/false);
+ entity_t *ndeclaration = parse_declarator(&specifiers, /*may_be_abstract=*/false, false);
rem_anchor_token('{');
rem_anchor_token(';');
case ',':
case ';':
case '=':
- parse_declaration_rest(ndeclaration, &specifiers, record_declaration);
+ parse_declaration_rest(ndeclaration, &specifiers, record_entity);
return;
}
return;
}
- type_t *type = ndeclaration->type;
+ assert(is_declaration(ndeclaration));
+ type_t *type = ndeclaration->declaration.type;
/* note that we don't skip typerefs: the standard doesn't allow them here
* (so we can't use is_type_function here) */
if (type->kind != TYPE_FUNCTION) {
if (is_type_valid(type)) {
errorf(HERE, "declarator '%#T' has a body but is not a function type",
- type, ndeclaration->symbol);
+ type, ndeclaration->base.symbol);
}
eat_block();
return;
if (warning.aggregate_return &&
is_type_compound(skip_typeref(type->function.return_type))) {
warningf(HERE, "function '%Y' returns an aggregate",
- ndeclaration->symbol);
+ ndeclaration->base.symbol);
}
if (warning.traditional && !type->function.unspecified_parameters) {
warningf(HERE, "traditional C rejects ISO C style function definition of function '%Y'",
- ndeclaration->symbol);
+ ndeclaration->base.symbol);
}
if (warning.old_style_definition && type->function.unspecified_parameters) {
warningf(HERE, "old-style function definition '%Y'",
- ndeclaration->symbol);
+ ndeclaration->base.symbol);
}
/* § 6.7.5.3 (14) a function definition with () means no
if (type != duplicate) {
obstack_free(type_obst, duplicate);
}
- ndeclaration->type = type;
+ ndeclaration->declaration.type = type;
}
- declaration_t *const declaration = record_declaration(ndeclaration, true);
- if (ndeclaration != declaration) {
- declaration->scope = ndeclaration->scope;
+ entity_t *const entity = record_entity(ndeclaration, true);
+ assert(entity->kind == ENTITY_FUNCTION);
+ assert(ndeclaration->kind == ENTITY_FUNCTION);
+
+ function_t *function = &entity->function;
+ if (ndeclaration != entity) {
+ function->parameters = ndeclaration->function.parameters;
}
- type = skip_typeref(declaration->type);
+ assert(is_declaration(entity));
+ type = skip_typeref(entity->declaration.type);
/* push function parameters and switch scope */
size_t const top = environment_top();
- scope_push(&declaration->scope);
-
- declaration_t *parameter = declaration->scope.declarations;
- for( ; parameter != NULL; parameter = parameter->next) {
- if (parameter->parent_scope == &ndeclaration->scope) {
- parameter->parent_scope = scope;
- }
- assert(parameter->parent_scope == NULL
- || parameter->parent_scope == scope);
- parameter->parent_scope = scope;
- if (parameter->symbol == NULL) {
- errorf(¶meter->source_position, "parameter name omitted");
+ scope_push(&function->parameters);
+
+ entity_t *parameter = function->parameters.entities;
+ for( ; parameter != NULL; parameter = parameter->base.next) {
+ if (parameter->base.parent_scope == &ndeclaration->function.parameters) {
+ parameter->base.parent_scope = scope;
+ }
+ assert(parameter->base.parent_scope == NULL
+ || parameter->base.parent_scope == scope);
+ parameter->base.parent_scope = scope;
+ if (parameter->base.symbol == NULL) {
+ errorf(¶meter->base.source_position, "parameter name omitted");
continue;
}
environment_push(parameter);
}
- if (declaration->init.statement != NULL) {
- parser_error_multiple_definition(declaration, HERE);
+ if (function->statement != NULL) {
+ parser_error_multiple_definition(entity, HERE);
eat_block();
} else {
/* parse function body */
- int label_stack_top = label_top();
- declaration_t *old_current_function = current_function;
- current_function = declaration;
- current_parent = NULL;
+ int label_stack_top = label_top();
+ function_t *old_current_function = current_function;
+ current_function = function;
+ current_parent = NULL;
- statement_t *const body = parse_compound_statement(false);
- declaration->init.statement = body;
+ statement_t *const body = parse_compound_statement(false);
+ function->statement = body;
first_err = true;
check_labels();
check_declarations();
if (warning.return_type ||
warning.unreachable_code ||
- (warning.missing_noreturn && !(declaration->modifiers & DM_NORETURN))) {
+ (warning.missing_noreturn
+ && !(function->base.modifiers & DM_NORETURN))) {
noreturn_candidate = true;
check_reachable(body);
if (warning.unreachable_code)
- check_unreachable(body);
+ walk_statements(body, check_unreachable, NULL);
if (warning.missing_noreturn &&
noreturn_candidate &&
- !(declaration->modifiers & DM_NORETURN)) {
+ !(function->base.modifiers & DM_NORETURN)) {
warningf(&body->base.source_position,
"function '%#T' is candidate for attribute 'noreturn'",
- type, declaration->symbol);
+ type, entity->base.symbol);
}
}
assert(current_parent == NULL);
- assert(current_function == declaration);
+ assert(current_function == function);
current_function = old_current_function;
label_pop_to(label_stack_top);
}
- assert(scope == &declaration->scope);
+ assert(scope == &function->parameters);
scope_pop();
environment_pop_to(top);
}
source_position_t *source_position,
const symbol_t *symbol)
{
- type_t *type = allocate_type_zero(TYPE_BITFIELD, source_position);
+ type_t *type = allocate_type_zero(TYPE_BITFIELD);
type->bitfield.base_type = base_type;
type->bitfield.size_expression = size;
return type;
}
-static declaration_t *find_compound_entry(declaration_t *compound_declaration,
- symbol_t *symbol)
+static entity_t *find_compound_entry(compound_t *compound, symbol_t *symbol)
{
- declaration_t *iter = compound_declaration->scope.declarations;
- for( ; iter != NULL; iter = iter->next) {
- if (iter->namespc != NAMESPACE_NORMAL)
+ entity_t *iter = compound->members.entities;
+ for( ; iter != NULL; iter = iter->base.next) {
+ if (iter->kind != ENTITY_COMPOUND_MEMBER)
continue;
- if (iter->symbol == NULL) {
- type_t *type = skip_typeref(iter->type);
+ if (iter->base.symbol == NULL) {
+ type_t *type = skip_typeref(iter->declaration.type);
if (is_type_compound(type)) {
- declaration_t *result
- = find_compound_entry(type->compound.declaration, symbol);
+ entity_t *result
+ = find_compound_entry(type->compound.compound, symbol);
if (result != NULL)
return result;
}
continue;
}
- if (iter->symbol == symbol) {
+ if (iter->base.symbol == symbol) {
return iter;
}
}
return NULL;
}
-static void parse_compound_declarators(declaration_t *struct_declaration,
+static void parse_compound_declarators(compound_t *compound,
const declaration_specifiers_t *specifiers)
{
- declaration_t *last_declaration = struct_declaration->scope.declarations;
- if (last_declaration != NULL) {
- while (last_declaration->next != NULL) {
- last_declaration = last_declaration->next;
- }
- }
-
while (true) {
- declaration_t *declaration;
+ entity_t *entity;
if (token.type == ':') {
source_position_t source_position = *HERE;
type_t *type = make_bitfield_type(base_type, size,
&source_position, sym_anonymous);
- declaration = allocate_declaration_zero();
- declaration->namespc = NAMESPACE_NORMAL;
- declaration->declared_storage_class = STORAGE_CLASS_NONE;
- declaration->storage_class = STORAGE_CLASS_NONE;
- declaration->source_position = source_position;
- declaration->modifiers = specifiers->modifiers;
- declaration->type = type;
+ entity = allocate_entity_zero(ENTITY_COMPOUND_MEMBER);
+ entity->base.namespc = NAMESPACE_NORMAL;
+ entity->base.source_position = source_position;
+ entity->declaration.declared_storage_class = STORAGE_CLASS_NONE;
+ entity->declaration.storage_class = STORAGE_CLASS_NONE;
+ entity->declaration.modifiers = specifiers->modifiers;
+ entity->declaration.type = type;
} else {
- declaration = parse_declarator(specifiers,/*may_be_abstract=*/true);
+ entity = parse_declarator(specifiers,/*may_be_abstract=*/true, true);
- type_t *orig_type = declaration->type;
+ assert(is_declaration(entity));
+ type_t *orig_type = entity->declaration.type;
type_t *type = skip_typeref(orig_type);
if (token.type == ':') {
expression_t *size = parse_constant_expression();
type_t *bitfield_type = make_bitfield_type(orig_type, size,
- &source_position, declaration->symbol);
- declaration->type = bitfield_type;
+ &source_position, entity->base.symbol);
+ entity->declaration.type = bitfield_type;
} else {
/* TODO we ignore arrays for now... what is missing is a check
* that they're at the end of the struct */
if (is_type_incomplete(type) && !is_type_array(type)) {
errorf(HERE,
"compound member '%Y' has incomplete type '%T'",
- declaration->symbol, orig_type);
+ entity->base.symbol, orig_type);
} else if (is_type_function(type)) {
errorf(HERE, "compound member '%Y' must not have function type '%T'",
- declaration->symbol, orig_type);
+ entity->base.symbol, orig_type);
}
}
}
/* make sure we don't define a symbol multiple times */
- symbol_t *symbol = declaration->symbol;
+ symbol_t *symbol = entity->base.symbol;
if (symbol != NULL) {
- declaration_t *prev_decl
- = find_compound_entry(struct_declaration, symbol);
+ entity_t *prev = find_compound_entry(compound, symbol);
- if (prev_decl != NULL) {
- assert(prev_decl->symbol == symbol);
- errorf(&declaration->source_position,
+ if (prev != NULL) {
+ assert(prev->base.symbol == symbol);
+ errorf(&entity->base.source_position,
"multiple declarations of symbol '%Y' (declared %P)",
- symbol, &prev_decl->source_position);
+ symbol, &prev->base.source_position);
}
}
- /* append declaration */
- if (last_declaration != NULL) {
- last_declaration->next = declaration;
- } else {
- struct_declaration->scope.declarations = declaration;
- }
- last_declaration = declaration;
+ append_entity(&compound->members, entity);
if (token.type != ',')
break;
;
}
-static void parse_compound_type_entries(declaration_t *compound_declaration)
+static void parse_compound_type_entries(compound_t *compound)
{
eat('{');
add_anchor_token('}');
memset(&specifiers, 0, sizeof(specifiers));
parse_declaration_specifiers(&specifiers);
- parse_compound_declarators(compound_declaration, &specifiers);
+ parse_compound_declarators(compound, &specifiers);
}
rem_anchor_token('}');
next_token();
declaration_specifiers_t specifiers;
memset(&specifiers, 0, sizeof(specifiers));
parse_declaration_specifiers(&specifiers);
- if (specifiers.declared_storage_class != STORAGE_CLASS_NONE) {
+ if (specifiers.storage_class != STORAGE_CLASS_NONE) {
/* TODO: improve error message, user does probably not know what a
* storage class is...
*/
-typedef expression_t* (*parse_expression_function) (unsigned precedence);
-typedef expression_t* (*parse_expression_infix_function) (unsigned precedence,
- expression_t *left);
+typedef expression_t* (*parse_expression_function)(void);
+typedef expression_t* (*parse_expression_infix_function)(expression_t *left);
typedef struct expression_parser_function_t expression_parser_function_t;
struct expression_parser_function_t {
- unsigned precedence;
parse_expression_function parser;
unsigned infix_precedence;
parse_expression_infix_function infix_parser;
return cnst;
}
-static declaration_t *create_implicit_function(symbol_t *symbol,
+static entity_t *create_implicit_function(symbol_t *symbol,
const source_position_t *source_position)
{
- type_t *ntype = allocate_type_zero(TYPE_FUNCTION, source_position);
+ type_t *ntype = allocate_type_zero(TYPE_FUNCTION);
ntype->function.return_type = type_int;
ntype->function.unspecified_parameters = true;
free_type(ntype);
}
- declaration_t *const declaration = allocate_declaration_zero();
- declaration->storage_class = STORAGE_CLASS_EXTERN;
- declaration->declared_storage_class = STORAGE_CLASS_EXTERN;
- declaration->type = type;
- declaration->symbol = symbol;
- declaration->source_position = *source_position;
- declaration->implicit = true;
+ entity_t *entity = allocate_entity_zero(ENTITY_FUNCTION);
+ entity->declaration.storage_class = STORAGE_CLASS_EXTERN;
+ entity->declaration.declared_storage_class = STORAGE_CLASS_EXTERN;
+ entity->declaration.type = type;
+ entity->declaration.implicit = true;
+ entity->base.symbol = symbol;
+ entity->base.source_position = *source_position;
bool strict_prototypes_old = warning.strict_prototypes;
warning.strict_prototypes = false;
- record_declaration(declaration, false);
+ record_entity(entity, false);
warning.strict_prototypes = strict_prototypes_old;
- return declaration;
+ return entity;
}
/**
parameter1->type = argument_type1;
parameter1->next = parameter2;
- type_t *type = allocate_type_zero(TYPE_FUNCTION, &builtin_source_position);
+ type_t *type = allocate_type_zero(TYPE_FUNCTION);
type->function.return_type = return_type;
type->function.parameters = parameter1;
memset(parameter, 0, sizeof(parameter[0]));
parameter->type = argument_type;
- type_t *type = allocate_type_zero(TYPE_FUNCTION, &builtin_source_position);
+ type_t *type = allocate_type_zero(TYPE_FUNCTION);
type->function.return_type = return_type;
type->function.parameters = parameter;
static type_t *make_function_0_type(type_t *return_type)
{
- type_t *type = allocate_type_zero(TYPE_FUNCTION, &builtin_source_position);
+ type_t *type = allocate_type_zero(TYPE_FUNCTION);
type->function.return_type = return_type;
type->function.parameters = NULL;
*/
static type_t *get_builtin_symbol_type(symbol_t *symbol)
{
- switch(symbol->ID) {
+ switch (symbol->ID) {
case T___builtin_alloca:
return make_function_1_type(type_void_ptr, type_size_t);
case T___builtin_huge_val:
return make_function_0_type(type_double);
+ case T___builtin_inf:
+ return make_function_0_type(type_double);
+ case T___builtin_inff:
+ return make_function_0_type(type_float);
+ case T___builtin_infl:
+ return make_function_0_type(type_long_double);
case T___builtin_nan:
return make_function_1_type(type_double, type_char_ptr);
case T___builtin_nanf:
return make_function_1_type(type_float, type_char_ptr);
- case T___builtin_nand:
+ case T___builtin_nanl:
return make_function_1_type(type_long_double, type_char_ptr);
case T___builtin_va_end:
return make_function_1_type(type_void, type_valist);
type_t *revert_automatic_type_conversion(const expression_t *expression)
{
switch (expression->kind) {
- case EXPR_REFERENCE: return expression->reference.declaration->type;
+ case EXPR_REFERENCE: {
+ entity_t *entity = expression->reference.entity;
+ if (is_declaration(entity)) {
+ return entity->declaration.type;
+ } else if (entity->kind == ENTITY_ENUM_VALUE) {
+ return entity->enum_value.enum_type;
+ } else {
+ panic("no declaration or enum in reference");
+ }
+ }
- case EXPR_SELECT:
- return get_qualified_type(expression->select.compound_entry->type,
+ case EXPR_SELECT: {
+ entity_t *entity = expression->select.compound_entry;
+ assert(is_declaration(entity));
+ type_t *type = entity->declaration.type;
+ return get_qualified_type(type,
expression->base.type->base.qualifiers);
+ }
case EXPR_UNARY_DEREFERENCE: {
const expression_t *const value = expression->unary.value;
static expression_t *parse_reference(void)
{
- expression_t *expression = allocate_expression_zero(EXPR_REFERENCE);
-
- reference_expression_t *ref = &expression->reference;
symbol_t *const symbol = token.v.symbol;
- declaration_t *declaration = get_declaration(symbol, NAMESPACE_NORMAL);
+ entity_t *entity = get_entity(symbol, NAMESPACE_NORMAL);
- if (declaration == NULL) {
+ if (entity == NULL) {
if (!strict_mode && look_ahead(1)->type == '(') {
/* an implicitly declared function */
if (warning.implicit_function_declaration) {
symbol);
}
- declaration = create_implicit_function(symbol, HERE);
+ entity = create_implicit_function(symbol, HERE);
} else {
errorf(HERE, "unknown symbol '%Y' found.", symbol);
- declaration = create_error_declaration(symbol, STORAGE_CLASS_NONE);
+ entity = create_error_entity(symbol, ENTITY_VARIABLE);
}
}
- type_t *orig_type = declaration->type;
+ type_t *orig_type;
+
+ if (is_declaration(entity)) {
+ orig_type = entity->declaration.type;
+ } else if (entity->kind == ENTITY_ENUM_VALUE) {
+ orig_type = entity->enum_value.enum_type;
+ } else {
+ panic("expected declaration or enum value in reference");
+ }
/* we always do the auto-type conversions; the & and sizeof parser contains
* code to revert this! */
type_t *type = automatic_type_conversion(orig_type);
- ref->declaration = declaration;
- ref->base.type = type;
+ expression_kind_t kind = EXPR_REFERENCE;
+ if (entity->kind == ENTITY_ENUM_VALUE)
+ kind = EXPR_REFERENCE_ENUM_VALUE;
+
+ expression_t *expression = allocate_expression_zero(kind);
+ expression->reference.entity = entity;
+ expression->base.type = type;
/* this declaration is used */
- declaration->used = true;
-
- if (declaration->parent_scope != file_scope &&
- declaration->parent_scope->depth < current_function->scope.depth &&
- is_type_valid(orig_type) && !is_type_function(orig_type)) {
- /* access of a variable from an outer function */
- declaration->address_taken = true;
- ref->is_outer_ref = true;
+ if (is_declaration(entity)) {
+ entity->declaration.used = true;
+ }
+
+ if (entity->base.parent_scope != file_scope
+ && entity->base.parent_scope->depth < current_function->parameters.depth
+ && is_type_valid(orig_type) && !is_type_function(orig_type)) {
+ if (entity->kind == ENTITY_VARIABLE) {
+ /* access of a variable from an outer function */
+ entity->variable.address_taken = true;
+ }
current_function->need_closure = true;
}
/* check for deprecated functions */
- if (warning.deprecated_declarations &&
- declaration->modifiers & DM_DEPRECATED) {
- char const *const prefix = is_type_function(declaration->type) ?
+ if (warning.deprecated_declarations
+ && is_declaration(entity)
+ && entity->declaration.modifiers & DM_DEPRECATED) {
+ declaration_t *declaration = &entity->declaration;
+
+ char const *const prefix = entity->kind == ENTITY_FUNCTION ?
"function" : "variable";
if (declaration->deprecated_string != NULL) {
warningf(HERE, "%s '%Y' is deprecated (declared %P): \"%s\"",
- prefix, declaration->symbol, &declaration->source_position,
- declaration->deprecated_string);
+ prefix, entity->base.symbol, &entity->base.source_position,
+ declaration->deprecated_string);
} else {
warningf(HERE, "%s '%Y' is deprecated (declared %P)", prefix,
- declaration->symbol, &declaration->source_position);
+ entity->base.symbol, &entity->base.source_position);
}
}
- if (warning.init_self && declaration == current_init_decl && !in_type_prop) {
+
+ if (warning.init_self && entity == current_init_decl && !in_type_prop
+ && entity->kind == ENTITY_VARIABLE) {
current_init_decl = NULL;
warningf(HERE, "variable '%#T' is initialized by itself",
- declaration->type, declaration->symbol);
+ entity->declaration.type, entity->base.symbol);
}
next_token();
parse_initializer_env_t env;
env.type = type;
- env.declaration = NULL;
+ env.entity = NULL;
env.must_be_constant = false;
initializer_t *initializer = parse_initializer(&env);
type = env.type;
expression_t *cast = allocate_expression_zero(EXPR_UNARY_CAST);
cast->base.source_position = source_position;
- expression_t *value = parse_sub_expression(20);
+ expression_t *value = parse_sub_expression(PREC_CAST);
cast->base.type = type;
cast->unary.value = value;
if (stmt->kind == STATEMENT_EXPRESSION) {
type = stmt->expression.expression->base.type;
}
- } else {
+ } else if (warning.other) {
warningf(&expression->base.source_position, "empty statement expression ({})");
}
expression->base.type = type;
{
eat('(');
- switch(token.type) {
+ switch (token.type) {
case '{':
/* gcc extension: a statement expression */
return parse_statement_expression();
expect(',');
expression_t *const expr = parse_assignment_expression();
if (expr->kind == EXPR_REFERENCE) {
- declaration_t *const decl = expr->reference.declaration;
- if (decl->parent_scope != ¤t_function->scope || decl->next != NULL) {
+ entity_t *const entity = expr->reference.entity;
+ if (entity->base.parent_scope != ¤t_function->parameters
+ || entity->base.next != NULL
+ || entity->kind != ENTITY_VARIABLE) {
errorf(&expr->base.source_position,
"second argument of 'va_start' must be last parameter of the current function");
+ } else {
+ expression->va_starte.parameter = &entity->variable;
}
- expression->va_starte.parameter = decl;
expect(')');
return expression;
}
{
expression_t *expression;
- switch(token.type) {
+ switch (token.type) {
case T___builtin_isgreater:
expression = allocate_expression_zero(EXPR_BINARY_ISGREATER);
break;
*
* @param symbol the symbol of the label
*/
-static declaration_t *get_label(symbol_t *symbol)
+static label_t *get_label(symbol_t *symbol)
{
- declaration_t *candidate;
+ entity_t *label;
assert(current_function != NULL);
- candidate = get_declaration(symbol, NAMESPACE_LOCAL_LABEL);
+ label = get_entity(symbol, NAMESPACE_LOCAL_LABEL);
/* if we found a local label, we already created the declaration */
- if (candidate != NULL) {
- if (candidate->parent_scope != scope) {
- assert(candidate->parent_scope->depth < scope->depth);
+ if (label != NULL && label->kind == ENTITY_LOCAL_LABEL) {
+ if (label->base.parent_scope != scope) {
+ assert(label->base.parent_scope->depth < scope->depth);
current_function->goto_to_outer = true;
}
- return candidate;
+ return &label->label;
}
- candidate = get_declaration(symbol, NAMESPACE_LABEL);
+ label = get_entity(symbol, NAMESPACE_LABEL);
/* if we found a label in the same function, then we already created the
* declaration */
- if (candidate != NULL
- && candidate->parent_scope == ¤t_function->scope) {
- return candidate;
+ if (label != NULL
+ && label->base.parent_scope == ¤t_function->parameters) {
+ return &label->label;
}
/* otherwise we need to create a new one */
- declaration_t *const declaration = allocate_declaration_zero();
- declaration->namespc = NAMESPACE_LABEL;
- declaration->symbol = symbol;
+ label = allocate_entity_zero(ENTITY_LABEL);
+ label->base.namespc = NAMESPACE_LABEL;
+ label->base.symbol = symbol;
- label_push(declaration);
+ label_push(label);
- return declaration;
+ return &label->label;
}
/**
symbol_t *symbol = token.v.symbol;
next_token();
- declaration_t *label = get_label(symbol);
-
+ label_t *label = get_label(symbol);
label->used = true;
label->address_taken = true;
expression->base.source_position = source_position;
/* label address is threaten as a void pointer */
- expression->base.type = type_void_ptr;
- expression->label_address.declaration = label;
+ expression->base.type = type_void_ptr;
+ expression->label_address.label = label;
return expression;
end_error:
return create_invalid_expression();
case T___builtin_va_arg: return parse_va_arg();
case T___builtin_expect:
case T___builtin_alloca:
+ case T___builtin_inf:
+ case T___builtin_inff:
+ case T___builtin_infl:
case T___builtin_nan:
- case T___builtin_nand:
case T___builtin_nanf:
+ case T___builtin_nanl:
case T___builtin_huge_val:
case T___builtin_va_end: return parse_builtin_symbol();
case T___builtin_isgreater:
}
}
-static expression_t *parse_array_expression(unsigned precedence,
- expression_t *left)
+static expression_t *parse_array_expression(expression_t *left)
{
- (void) precedence;
-
eat('[');
add_anchor_token(']');
}
static expression_t *parse_typeprop(expression_kind_t const kind,
- source_position_t const pos,
- unsigned const precedence)
+ source_position_t const pos)
{
expression_t *tp_expression = allocate_expression_zero(kind);
tp_expression->base.type = type_size_t;
/* we only refer to a type property, mark this case */
bool old = in_type_prop;
in_type_prop = true;
+
+ type_t *orig_type;
+ expression_t *expression;
if (token.type == '(' && is_declaration_specifier(look_ahead(1), true)) {
next_token();
add_anchor_token(')');
- type_t* const orig_type = parse_typename();
- tp_expression->typeprop.type = orig_type;
-
- type_t const* const type = skip_typeref(orig_type);
- char const* const wrong_type =
- is_type_incomplete(type) ? "incomplete" :
- type->kind == TYPE_FUNCTION ? "function designator" :
- type->kind == TYPE_BITFIELD ? "bitfield" :
- NULL;
- if (wrong_type != NULL) {
- errorf(&pos, "operand of %s expression must not be %s type '%T'",
- what, wrong_type, type);
- }
-
+ orig_type = parse_typename();
rem_anchor_token(')');
expect(')');
- } else {
- expression_t *expression = parse_sub_expression(precedence);
-
- type_t* const orig_type = revert_automatic_type_conversion(expression);
- expression->base.type = orig_type;
- type_t const* const type = skip_typeref(orig_type);
- char const* const wrong_type =
- is_type_incomplete(type) ? "incomplete" :
- type->kind == TYPE_FUNCTION ? "function designator" :
- type->kind == TYPE_BITFIELD ? "bitfield" :
- NULL;
- if (wrong_type != NULL) {
- errorf(&pos, "operand of %s expression must not be expression of %s type '%T'", what, wrong_type, type);
+ if (token.type == '{') {
+ /* It was not sizeof(type) after all. It is sizeof of an expression
+ * starting with a compound literal */
+ expression = parse_compound_literal(orig_type);
+ goto typeprop_expression;
}
+ } else {
+ expression = parse_sub_expression(PREC_UNARY);
- tp_expression->typeprop.type = expression->base.type;
+typeprop_expression:
tp_expression->typeprop.tp_expression = expression;
+
+ orig_type = revert_automatic_type_conversion(expression);
+ expression->base.type = orig_type;
+ }
+
+ tp_expression->typeprop.type = orig_type;
+ type_t const* const type = skip_typeref(orig_type);
+ char const* const wrong_type =
+ is_type_incomplete(type) ? "incomplete" :
+ type->kind == TYPE_FUNCTION ? "function designator" :
+ type->kind == TYPE_BITFIELD ? "bitfield" :
+ NULL;
+ if (wrong_type != NULL) {
+ errorf(&pos, "operand of %s expression must not be of %s type '%T'",
+ what, wrong_type, orig_type);
}
end_error:
return tp_expression;
}
-static expression_t *parse_sizeof(unsigned precedence)
+static expression_t *parse_sizeof(void)
{
source_position_t pos = *HERE;
eat(T_sizeof);
- return parse_typeprop(EXPR_SIZEOF, pos, precedence);
+ return parse_typeprop(EXPR_SIZEOF, pos);
}
-static expression_t *parse_alignof(unsigned precedence)
+static expression_t *parse_alignof(void)
{
source_position_t pos = *HERE;
eat(T___alignof__);
- return parse_typeprop(EXPR_ALIGNOF, pos, precedence);
+ return parse_typeprop(EXPR_ALIGNOF, pos);
}
-static expression_t *parse_select_expression(unsigned precedence,
- expression_t *compound)
+static expression_t *parse_select_expression(expression_t *compound)
{
- (void) precedence;
assert(token.type == '.' || token.type == T_MINUSGREATER);
bool is_pointer = (token.type == T_MINUSGREATER);
type_left = type;
}
- declaration_t *entry;
+ entity_t *entry;
if (type_left->kind == TYPE_COMPOUND_STRUCT ||
type_left->kind == TYPE_COMPOUND_UNION) {
- declaration_t *const declaration = type_left->compound.declaration;
+ compound_t *compound = type_left->compound.compound;
- if (!declaration->init.complete) {
+ if (!compound->complete) {
errorf(HERE, "request for member '%Y' of incomplete type '%T'",
symbol, type_left);
goto create_error_entry;
}
- entry = find_compound_entry(declaration, symbol);
+ entry = find_compound_entry(compound, symbol);
if (entry == NULL) {
errorf(HERE, "'%T' has no member named '%Y'", orig_type, symbol);
goto create_error_entry;
symbol, type_left);
}
create_error_entry:
- entry = allocate_declaration_zero();
- entry->symbol = symbol;
+ return create_invalid_expression();
}
+ assert(is_declaration(entry));
select->select.compound_entry = entry;
- type_t *const res_type =
- get_qualified_type(entry->type, type_left->base.qualifiers);
+ type_t *entry_type = entry->declaration.type;
+ type_t *res_type
+ = get_qualified_type(entry_type, type_left->base.qualifiers);
/* we always do the auto-type conversions; the & and sizeof parser contains
* code to revert this! */
if (is_type_union(expected_type_skip)
&& (expected_type_skip->base.modifiers
& TYPE_MODIFIER_TRANSPARENT_UNION)) {
- declaration_t *union_decl = expected_type_skip->compound.declaration;
-
- declaration_t *declaration = union_decl->scope.declarations;
- type_t *best_type = NULL;
- for ( ; declaration != NULL; declaration = declaration->next) {
- type_t *decl_type = declaration->type;
+ compound_t *union_decl = expected_type_skip->compound.compound;
+ type_t *best_type = NULL;
+ entity_t *entry = union_decl->members.entities;
+ for ( ; entry != NULL; entry = entry->base.next) {
+ assert(is_declaration(entry));
+ type_t *decl_type = entry->declaration.type;
error = semantic_assign(decl_type, arg_expr);
if (error == ASSIGN_ERROR_INCOMPATIBLE
|| error == ASSIGN_ERROR_POINTER_QUALIFIER_MISSING)
*
* @param expression the function address
*/
-static expression_t *parse_call_expression(unsigned precedence,
- expression_t *expression)
+static expression_t *parse_call_expression(expression_t *expression)
{
- (void) precedence;
expression_t *result = allocate_expression_zero(EXPR_CALL);
result->base.source_position = expression->base.source_position;
return
is_type_compound(type1) &&
type1->kind == type2->kind &&
- type1->compound.declaration == type2->compound.declaration;
+ type1->compound.compound == type2->compound.compound;
}
/**
*
* @param expression the conditional expression
*/
-static expression_t *parse_conditional_expression(unsigned precedence,
- expression_t *expression)
+static expression_t *parse_conditional_expression(expression_t *expression)
{
expression_t *result = allocate_expression_zero(EXPR_CONDITIONAL);
bool gnu_cond = false;
if (GNU_MODE && token.type == ':') {
gnu_cond = true;
- } else
+ } else {
true_expression = parse_expression();
+ }
rem_anchor_token(':');
expect(':');
- expression_t *false_expression = parse_sub_expression(precedence);
+ expression_t *false_expression =
+ parse_sub_expression(c_mode & _CXX ? PREC_ASSIGNMENT : PREC_CONDITIONAL);
type_t *const orig_true_type = true_expression->base.type;
type_t *const orig_false_type = false_expression->base.type;
/* 6.5.15.3 */
type_t *result_type;
- if (is_type_atomic(true_type, ATOMIC_TYPE_VOID) ||
- is_type_atomic(false_type, ATOMIC_TYPE_VOID)) {
- if (!is_type_atomic(true_type, ATOMIC_TYPE_VOID)
- || !is_type_atomic(false_type, ATOMIC_TYPE_VOID)) {
- warningf(&conditional->base.source_position,
- "ISO C forbids conditional expression with only one void side");
- }
- result_type = type_void;
+ if (is_type_atomic(true_type, ATOMIC_TYPE_VOID) ||
+ is_type_atomic(false_type, ATOMIC_TYPE_VOID)) {
+ /* ISO/IEC 14882:1998(E) §5.16:2 */
+ if (true_expression->kind == EXPR_UNARY_THROW) {
+ result_type = false_type;
+ } else if (false_expression->kind == EXPR_UNARY_THROW) {
+ result_type = true_type;
+ } else {
+ if (warning.other && (
+ !is_type_atomic(true_type, ATOMIC_TYPE_VOID) ||
+ !is_type_atomic(false_type, ATOMIC_TYPE_VOID)
+ )) {
+ warningf(&conditional->base.source_position,
+ "ISO C forbids conditional expression with only one void side");
+ }
+ result_type = type_void;
+ }
} else if (is_type_arithmetic(true_type)
&& is_type_arithmetic(false_type)) {
result_type = semantic_arithmetic(true_type, false_type);
get_unqualified_type(to2))) {
to = to1;
} else {
- warningf(&conditional->base.source_position,
- "pointer types '%T' and '%T' in conditional expression are incompatible",
- true_type, false_type);
+ if (warning.other) {
+ warningf(&conditional->base.source_position,
+ "pointer types '%T' and '%T' in conditional expression are incompatible",
+ true_type, false_type);
+ }
to = type_void;
}
get_qualified_type(to, to1->base.qualifiers | to2->base.qualifiers);
result_type = make_pointer_type(type, TYPE_QUALIFIER_NONE);
} else if (is_type_integer(other_type)) {
- warningf(&conditional->base.source_position,
- "pointer/integer type mismatch in conditional expression ('%T' and '%T')", true_type, false_type);
+ if (warning.other) {
+ warningf(&conditional->base.source_position,
+ "pointer/integer type mismatch in conditional expression ('%T' and '%T')", true_type, false_type);
+ }
result_type = pointer_type;
} else {
- type_error_incompatible("while parsing conditional",
- &expression->base.source_position, true_type, false_type);
+ if (is_type_valid(other_type)) {
+ type_error_incompatible("while parsing conditional",
+ &expression->base.source_position, true_type, false_type);
+ }
result_type = type_error_type;
}
} else {
- /* TODO: one pointer to void*, other some pointer */
-
if (is_type_valid(true_type) && is_type_valid(false_type)) {
type_error_incompatible("while parsing conditional",
&conditional->base.source_position, true_type,
/**
* Parse an extension expression.
*/
-static expression_t *parse_extension(unsigned precedence)
+static expression_t *parse_extension(void)
{
eat(T___extension__);
bool old_gcc_extension = in_gcc_extension;
in_gcc_extension = true;
- expression_t *expression = parse_sub_expression(precedence);
+ expression_t *expression = parse_sub_expression(PREC_UNARY);
in_gcc_extension = old_gcc_extension;
return expression;
}
/**
* Parse a __builtin_classify_type() expression.
*/
-static expression_t *parse_builtin_classify_type(const unsigned precedence)
+static expression_t *parse_builtin_classify_type(void)
{
eat(T___builtin_classify_type);
expect('(');
add_anchor_token(')');
- expression_t *expression = parse_sub_expression(precedence);
+ expression_t *expression = parse_expression();
rem_anchor_token(')');
expect(')');
result->classify_type.type_expression = expression;
return create_invalid_expression();
}
+/**
+ * Parse a delete expression
+ * ISO/IEC 14882:1998(E) §5.3.5
+ */
+static expression_t *parse_delete(void)
+{
+ expression_t *const result = allocate_expression_zero(EXPR_UNARY_DELETE);
+ result->base.source_position = *HERE;
+ result->base.type = type_void;
+
+ eat(T_delete);
+
+ if (token.type == '[') {
+ next_token();
+ result->kind = EXPR_UNARY_DELETE_ARRAY;
+ expect(']');
+end_error:;
+ }
+
+ expression_t *const value = parse_sub_expression(PREC_CAST);
+ result->unary.value = value;
+
+ type_t *const type = skip_typeref(value->base.type);
+ if (!is_type_pointer(type)) {
+ errorf(&value->base.source_position,
+ "operand of delete must have pointer type");
+ } else if (warning.other &&
+ is_type_atomic(skip_typeref(type->pointer.points_to), ATOMIC_TYPE_VOID)) {
+ warningf(&value->base.source_position,
+ "deleting 'void*' is undefined");
+ }
+
+ return result;
+}
+
+/**
+ * Parse a throw expression
+ * ISO/IEC 14882:1998(E) §15:1
+ */
+static expression_t *parse_throw(void)
+{
+ expression_t *const result = allocate_expression_zero(EXPR_UNARY_THROW);
+ result->base.source_position = *HERE;
+ result->base.type = type_void;
+
+ eat(T_throw);
+
+ expression_t *value = NULL;
+ switch (token.type) {
+ EXPRESSION_START {
+ value = parse_assignment_expression();
+ /* ISO/IEC 14882:1998(E) §15.1:3 */
+ type_t *const orig_type = value->base.type;
+ type_t *const type = skip_typeref(orig_type);
+ if (is_type_incomplete(type)) {
+ errorf(&value->base.source_position,
+ "cannot throw object of incomplete type '%T'", orig_type);
+ } else if (is_type_pointer(type)) {
+ type_t *const points_to = skip_typeref(type->pointer.points_to);
+ if (is_type_incomplete(points_to) &&
+ !is_type_atomic(points_to, ATOMIC_TYPE_VOID)) {
+ errorf(&value->base.source_position,
+ "cannot throw pointer to incomplete type '%T'", orig_type);
+ }
+ }
+ }
+
+ default:
+ break;
+ }
+ result->unary.value = value;
+
+ return result;
+}
+
static bool check_pointer_arithmetic(const source_position_t *source_position,
type_t *pointer_type,
type_t *orig_pointer_type)
static bool is_lvalue(const expression_t *expression)
{
+ /* TODO: doesn't seem to be consistent with §6.3.2.1 (1) */
switch (expression->kind) {
case EXPR_REFERENCE:
case EXPR_ARRAY_ACCESS:
return true;
default:
- return false;
+ /* Claim it is an lvalue, if the type is invalid. There was a parse
+ * error before, which maybe prevented properly recognizing it as
+ * lvalue. */
+ return !is_type_valid(skip_typeref(expression->base.type));
}
}
expr = expr->unary.value;
}
- if (expr->kind != EXPR_REFERENCE)
- return NULL;
-
- if (!regular_take_address &&
- !is_type_function(skip_typeref(expr->reference.declaration->type))) {
- return NULL;
+ /* special case for functions which are automatically converted to a
+ * pointer to function without an extra TAKE_ADDRESS operation */
+ if (!regular_take_address && expr->kind == EXPR_REFERENCE
+ && expr->reference.entity->kind == ENTITY_FUNCTION) {
+ return expr;
}
- return expr;
+ return NULL;
}
static void warn_function_address_as_bool(expression_t const* expr)
expr = get_reference_address(expr);
if (expr != NULL) {
warningf(&expr->base.source_position,
- "the address of '%Y' will always evaluate as 'true'",
- expr->reference.declaration->symbol);
+ "the address of '%Y' will always evaluate as 'true'",
+ expr->reference.entity->base.symbol);
}
}
if (expression->kind != EXPR_REFERENCE)
return;
- declaration_t *const declaration = expression->reference.declaration;
- /* happens for parse errors */
- if (declaration == NULL)
+ entity_t *const entity = expression->reference.entity;
+
+ if (entity->kind != ENTITY_VARIABLE)
return;
- if (declaration->storage_class == STORAGE_CLASS_REGISTER && !may_be_register) {
+ if (entity->declaration.storage_class == STORAGE_CLASS_REGISTER
+ && !may_be_register) {
errorf(&expression->base.source_position,
"address of register variable '%Y' requested",
- declaration->symbol);
- } else {
- declaration->address_taken = 1;
+ entity->base.symbol);
}
+
+ entity->variable.address_taken = true;
}
/**
value->base.type = revert_automatic_type_conversion(value);
type_t *orig_type = value->base.type;
- if (!is_type_valid(orig_type))
+ type_t *type = skip_typeref(orig_type);
+ if (!is_type_valid(type))
return;
+ /* §6.5.3.2 */
+ if (value->kind != EXPR_ARRAY_ACCESS
+ && value->kind != EXPR_UNARY_DEREFERENCE
+ && !is_lvalue(value)) {
+ errorf(&expression->base.source_position,
+ "'&' requires an lvalue");
+ }
+ if (type->kind == TYPE_BITFIELD) {
+ errorf(&expression->base.source_position,
+ "'&' not allowed on object with bitfield type '%T'",
+ type);
+ }
+
set_address_taken(value, false);
expression->base.type = make_pointer_type(orig_type, TYPE_QUALIFIER_NONE);
}
-#define CREATE_UNARY_EXPRESSION_PARSER(token_type, unexpression_type, sfunc) \
-static expression_t *parse_##unexpression_type(unsigned precedence) \
-{ \
- expression_t *unary_expression \
- = allocate_expression_zero(unexpression_type); \
- unary_expression->base.source_position = *HERE; \
- eat(token_type); \
- unary_expression->unary.value = parse_sub_expression(precedence); \
- \
- sfunc(&unary_expression->unary); \
- \
- return unary_expression; \
+#define CREATE_UNARY_EXPRESSION_PARSER(token_type, unexpression_type, sfunc) \
+static expression_t *parse_##unexpression_type(void) \
+{ \
+ expression_t *unary_expression \
+ = allocate_expression_zero(unexpression_type); \
+ unary_expression->base.source_position = *HERE; \
+ eat(token_type); \
+ unary_expression->unary.value = parse_sub_expression(PREC_UNARY); \
+ \
+ sfunc(&unary_expression->unary); \
+ \
+ return unary_expression; \
}
CREATE_UNARY_EXPRESSION_PARSER('-', EXPR_UNARY_NEGATE,
#define CREATE_UNARY_POSTFIX_EXPRESSION_PARSER(token_type, unexpression_type, \
sfunc) \
-static expression_t *parse_##unexpression_type(unsigned precedence, \
- expression_t *left) \
+static expression_t *parse_##unexpression_type(expression_t *left) \
{ \
- (void) precedence; \
- \
expression_t *unary_expression \
= allocate_expression_zero(unexpression_type); \
unary_expression->base.source_position = *HERE; \
"subtracting pointers to incompatible types '%T' and '%T'",
orig_type_left, orig_type_right);
} else if (!is_type_object(unqual_left)) {
- if (is_type_atomic(unqual_left, ATOMIC_TYPE_VOID)) {
- warningf(pos, "subtracting pointers to void");
- } else {
+ if (!is_type_atomic(unqual_left, ATOMIC_TYPE_VOID)) {
errorf(pos, "subtracting pointers to non-object types '%T'",
orig_type_left);
+ } else if (warning.other) {
+ warningf(pos, "subtracting pointers to void");
}
}
expression->base.type = type_ptrdiff_t;
expression_t const* const func_left = get_reference_address(left);
if (func_left != NULL && is_null_pointer_constant(right)) {
warningf(&expression->base.source_position,
- "the address of '%Y' will never be NULL",
- func_left->reference.declaration->symbol);
+ "the address of '%Y' will never be NULL",
+ func_left->reference.entity->base.symbol);
}
expression_t const* const func_right = get_reference_address(right);
if (func_right != NULL && is_null_pointer_constant(right)) {
warningf(&expression->base.source_position,
- "the address of '%Y' will never be NULL",
- func_right->reference.declaration->symbol);
+ "the address of '%Y' will never be NULL",
+ func_right->reference.entity->base.symbol);
}
}
*/
static bool has_const_fields(const compound_type_t *type)
{
- const scope_t *scope = &type->declaration->scope;
- const declaration_t *declaration = scope->declarations;
+ compound_t *compound = type->compound;
+ entity_t *entry = compound->members.entities;
- for (; declaration != NULL; declaration = declaration->next) {
- if (declaration->namespc != NAMESPACE_NORMAL)
+ for (; entry != NULL; entry = entry->base.next) {
+ if (!is_declaration(entry))
continue;
- const type_t *decl_type = skip_typeref(declaration->type);
+ const type_t *decl_type = skip_typeref(entry->declaration.type);
if (decl_type->base.qualifiers & TYPE_QUALIFIER_CONST)
return true;
}
- /* TODO */
+
return false;
}
case EXPR_UNKNOWN: break;
case EXPR_INVALID: return true; /* do NOT warn */
case EXPR_REFERENCE: return false;
+ case EXPR_REFERENCE_ENUM_VALUE: return false;
/* suppress the warning for microsoft __noop operations */
case EXPR_CONST: return expr->conste.is_ms_noop;
case EXPR_CHARACTER_CONSTANT: return false;
case EXPR_UNARY_CAST_IMPLICIT: return true;
case EXPR_UNARY_ASSUME: return true;
+ case EXPR_UNARY_DELETE: return true;
+ case EXPR_UNARY_DELETE_ARRAY: return true;
+ case EXPR_UNARY_THROW: return true;
case EXPR_BINARY_ADD: return false;
case EXPR_BINARY_SUB: return false;
expression->base.type = expression->right->base.type;
}
-#define CREATE_BINEXPR_PARSER(token_type, binexpression_type, sfunc, lr) \
-static expression_t *parse_##binexpression_type(unsigned precedence, \
- expression_t *left) \
-{ \
- expression_t *binexpr = allocate_expression_zero(binexpression_type); \
- binexpr->base.source_position = *HERE; \
- binexpr->binary.left = left; \
- eat(token_type); \
- \
- expression_t *right = parse_sub_expression(precedence + lr); \
- \
- binexpr->binary.right = right; \
- sfunc(&binexpr->binary); \
- \
- return binexpr; \
-}
-
-CREATE_BINEXPR_PARSER(',', EXPR_BINARY_COMMA, semantic_comma, 1)
-CREATE_BINEXPR_PARSER('*', EXPR_BINARY_MUL, semantic_binexpr_arithmetic, 1)
-CREATE_BINEXPR_PARSER('/', EXPR_BINARY_DIV, semantic_divmod_arithmetic, 1)
-CREATE_BINEXPR_PARSER('%', EXPR_BINARY_MOD, semantic_divmod_arithmetic, 1)
-CREATE_BINEXPR_PARSER('+', EXPR_BINARY_ADD, semantic_add, 1)
-CREATE_BINEXPR_PARSER('-', EXPR_BINARY_SUB, semantic_sub, 1)
-CREATE_BINEXPR_PARSER('<', EXPR_BINARY_LESS, semantic_comparison, 1)
-CREATE_BINEXPR_PARSER('>', EXPR_BINARY_GREATER, semantic_comparison, 1)
-CREATE_BINEXPR_PARSER('=', EXPR_BINARY_ASSIGN, semantic_binexpr_assign, 0)
-
-CREATE_BINEXPR_PARSER(T_EQUALEQUAL, EXPR_BINARY_EQUAL,
- semantic_comparison, 1)
-CREATE_BINEXPR_PARSER(T_EXCLAMATIONMARKEQUAL, EXPR_BINARY_NOTEQUAL,
- semantic_comparison, 1)
-CREATE_BINEXPR_PARSER(T_LESSEQUAL, EXPR_BINARY_LESSEQUAL,
- semantic_comparison, 1)
-CREATE_BINEXPR_PARSER(T_GREATEREQUAL, EXPR_BINARY_GREATEREQUAL,
- semantic_comparison, 1)
-
-CREATE_BINEXPR_PARSER('&', EXPR_BINARY_BITWISE_AND,
- semantic_binexpr_arithmetic, 1)
-CREATE_BINEXPR_PARSER('|', EXPR_BINARY_BITWISE_OR,
- semantic_binexpr_arithmetic, 1)
-CREATE_BINEXPR_PARSER('^', EXPR_BINARY_BITWISE_XOR,
- semantic_binexpr_arithmetic, 1)
-CREATE_BINEXPR_PARSER(T_ANDAND, EXPR_BINARY_LOGICAL_AND,
- semantic_logical_op, 1)
-CREATE_BINEXPR_PARSER(T_PIPEPIPE, EXPR_BINARY_LOGICAL_OR,
- semantic_logical_op, 1)
-CREATE_BINEXPR_PARSER(T_LESSLESS, EXPR_BINARY_SHIFTLEFT,
- semantic_shift_op, 1)
-CREATE_BINEXPR_PARSER(T_GREATERGREATER, EXPR_BINARY_SHIFTRIGHT,
- semantic_shift_op, 1)
-CREATE_BINEXPR_PARSER(T_PLUSEQUAL, EXPR_BINARY_ADD_ASSIGN,
- semantic_arithmetic_addsubb_assign, 0)
-CREATE_BINEXPR_PARSER(T_MINUSEQUAL, EXPR_BINARY_SUB_ASSIGN,
- semantic_arithmetic_addsubb_assign, 0)
-CREATE_BINEXPR_PARSER(T_ASTERISKEQUAL, EXPR_BINARY_MUL_ASSIGN,
- semantic_arithmetic_assign, 0)
-CREATE_BINEXPR_PARSER(T_SLASHEQUAL, EXPR_BINARY_DIV_ASSIGN,
- semantic_divmod_assign, 0)
-CREATE_BINEXPR_PARSER(T_PERCENTEQUAL, EXPR_BINARY_MOD_ASSIGN,
- semantic_divmod_assign, 0)
-CREATE_BINEXPR_PARSER(T_LESSLESSEQUAL, EXPR_BINARY_SHIFTLEFT_ASSIGN,
- semantic_arithmetic_assign, 0)
-CREATE_BINEXPR_PARSER(T_GREATERGREATEREQUAL, EXPR_BINARY_SHIFTRIGHT_ASSIGN,
- semantic_arithmetic_assign, 0)
-CREATE_BINEXPR_PARSER(T_ANDEQUAL, EXPR_BINARY_BITWISE_AND_ASSIGN,
- semantic_arithmetic_assign, 0)
-CREATE_BINEXPR_PARSER(T_PIPEEQUAL, EXPR_BINARY_BITWISE_OR_ASSIGN,
- semantic_arithmetic_assign, 0)
-CREATE_BINEXPR_PARSER(T_CARETEQUAL, EXPR_BINARY_BITWISE_XOR_ASSIGN,
- semantic_arithmetic_assign, 0)
-
-static expression_t *parse_sub_expression(unsigned precedence)
+/**
+ * @param prec_r precedence of the right operand
+ */
+#define CREATE_BINEXPR_PARSER(token_type, binexpression_type, prec_r, sfunc) \
+static expression_t *parse_##binexpression_type(expression_t *left) \
+{ \
+ expression_t *binexpr = allocate_expression_zero(binexpression_type); \
+ binexpr->base.source_position = *HERE; \
+ binexpr->binary.left = left; \
+ eat(token_type); \
+ \
+ expression_t *right = parse_sub_expression(prec_r); \
+ \
+ binexpr->binary.right = right; \
+ sfunc(&binexpr->binary); \
+ \
+ return binexpr; \
+}
+
+CREATE_BINEXPR_PARSER('*', EXPR_BINARY_MUL, PREC_CAST, semantic_binexpr_arithmetic)
+CREATE_BINEXPR_PARSER('/', EXPR_BINARY_DIV, PREC_CAST, semantic_divmod_arithmetic)
+CREATE_BINEXPR_PARSER('%', EXPR_BINARY_MOD, PREC_CAST, semantic_divmod_arithmetic)
+CREATE_BINEXPR_PARSER('+', EXPR_BINARY_ADD, PREC_MULTIPLICATIVE, semantic_add)
+CREATE_BINEXPR_PARSER('-', EXPR_BINARY_SUB, PREC_MULTIPLICATIVE, semantic_sub)
+CREATE_BINEXPR_PARSER(T_LESSLESS, EXPR_BINARY_SHIFTLEFT, PREC_ADDITIVE, semantic_shift_op)
+CREATE_BINEXPR_PARSER(T_GREATERGREATER, EXPR_BINARY_SHIFTRIGHT, PREC_ADDITIVE, semantic_shift_op)
+CREATE_BINEXPR_PARSER('<', EXPR_BINARY_LESS, PREC_SHIFT, semantic_comparison)
+CREATE_BINEXPR_PARSER('>', EXPR_BINARY_GREATER, PREC_SHIFT, semantic_comparison)
+CREATE_BINEXPR_PARSER(T_LESSEQUAL, EXPR_BINARY_LESSEQUAL, PREC_SHIFT, semantic_comparison)
+CREATE_BINEXPR_PARSER(T_GREATEREQUAL, EXPR_BINARY_GREATEREQUAL, PREC_SHIFT, semantic_comparison)
+CREATE_BINEXPR_PARSER(T_EXCLAMATIONMARKEQUAL, EXPR_BINARY_NOTEQUAL, PREC_RELATIONAL, semantic_comparison)
+CREATE_BINEXPR_PARSER(T_EQUALEQUAL, EXPR_BINARY_EQUAL, PREC_RELATIONAL, semantic_comparison)
+CREATE_BINEXPR_PARSER('&', EXPR_BINARY_BITWISE_AND, PREC_EQUALITY, semantic_binexpr_arithmetic)
+CREATE_BINEXPR_PARSER('^', EXPR_BINARY_BITWISE_XOR, PREC_AND, semantic_binexpr_arithmetic)
+CREATE_BINEXPR_PARSER('|', EXPR_BINARY_BITWISE_OR, PREC_XOR, semantic_binexpr_arithmetic)
+CREATE_BINEXPR_PARSER(T_ANDAND, EXPR_BINARY_LOGICAL_AND, PREC_OR, semantic_logical_op)
+CREATE_BINEXPR_PARSER(T_PIPEPIPE, EXPR_BINARY_LOGICAL_OR, PREC_LOGICAL_AND, semantic_logical_op)
+CREATE_BINEXPR_PARSER('=', EXPR_BINARY_ASSIGN, PREC_ASSIGNMENT, semantic_binexpr_assign)
+CREATE_BINEXPR_PARSER(T_PLUSEQUAL, EXPR_BINARY_ADD_ASSIGN, PREC_ASSIGNMENT, semantic_arithmetic_addsubb_assign)
+CREATE_BINEXPR_PARSER(T_MINUSEQUAL, EXPR_BINARY_SUB_ASSIGN, PREC_ASSIGNMENT, semantic_arithmetic_addsubb_assign)
+CREATE_BINEXPR_PARSER(T_ASTERISKEQUAL, EXPR_BINARY_MUL_ASSIGN, PREC_ASSIGNMENT, semantic_arithmetic_assign)
+CREATE_BINEXPR_PARSER(T_SLASHEQUAL, EXPR_BINARY_DIV_ASSIGN, PREC_ASSIGNMENT, semantic_divmod_assign)
+CREATE_BINEXPR_PARSER(T_PERCENTEQUAL, EXPR_BINARY_MOD_ASSIGN, PREC_ASSIGNMENT, semantic_divmod_assign)
+CREATE_BINEXPR_PARSER(T_LESSLESSEQUAL, EXPR_BINARY_SHIFTLEFT_ASSIGN, PREC_ASSIGNMENT, semantic_arithmetic_assign)
+CREATE_BINEXPR_PARSER(T_GREATERGREATEREQUAL, EXPR_BINARY_SHIFTRIGHT_ASSIGN, PREC_ASSIGNMENT, semantic_arithmetic_assign)
+CREATE_BINEXPR_PARSER(T_ANDEQUAL, EXPR_BINARY_BITWISE_AND_ASSIGN, PREC_ASSIGNMENT, semantic_arithmetic_assign)
+CREATE_BINEXPR_PARSER(T_PIPEEQUAL, EXPR_BINARY_BITWISE_OR_ASSIGN, PREC_ASSIGNMENT, semantic_arithmetic_assign)
+CREATE_BINEXPR_PARSER(T_CARETEQUAL, EXPR_BINARY_BITWISE_XOR_ASSIGN, PREC_ASSIGNMENT, semantic_arithmetic_assign)
+CREATE_BINEXPR_PARSER(',', EXPR_BINARY_COMMA, PREC_ASSIGNMENT, semantic_comma)
+
+
+static expression_t *parse_sub_expression(precedence_t precedence)
{
if (token.type < 0) {
return expected_expression_error();
expression_t *left;
if (parser->parser != NULL) {
- left = parser->parser(parser->precedence);
+ left = parser->parser();
} else {
left = parse_primary_expression();
}
if (parser->infix_precedence < precedence)
break;
- left = parser->infix_parser(parser->infix_precedence, left);
+ left = parser->infix_parser(left);
assert(left != NULL);
assert(left->kind != EXPR_UNKNOWN);
*/
static expression_t *parse_expression(void)
{
- return parse_sub_expression(1);
+ return parse_sub_expression(PREC_EXPRESSION);
}
/**
- * Register a parser for a prefix-like operator with given precedence.
+ * Register a parser for a prefix-like operator.
*
* @param parser the parser function
* @param token_type the token type of the prefix token
- * @param precedence the precedence of the operator
*/
static void register_expression_parser(parse_expression_function parser,
- int token_type, unsigned precedence)
+ int token_type)
{
expression_parser_function_t *entry = &expression_parsers[token_type];
diagnosticf("for token '%k'\n", (token_type_t)token_type);
panic("trying to register multiple expression parsers for a token");
}
- entry->parser = parser;
- entry->precedence = precedence;
+ entry->parser = parser;
}
/**
{
memset(&expression_parsers, 0, sizeof(expression_parsers));
- register_infix_parser(parse_array_expression, '[', 30);
- register_infix_parser(parse_call_expression, '(', 30);
- register_infix_parser(parse_select_expression, '.', 30);
- register_infix_parser(parse_select_expression, T_MINUSGREATER, 30);
- register_infix_parser(parse_EXPR_UNARY_POSTFIX_INCREMENT,
- T_PLUSPLUS, 30);
- register_infix_parser(parse_EXPR_UNARY_POSTFIX_DECREMENT,
- T_MINUSMINUS, 30);
-
- register_infix_parser(parse_EXPR_BINARY_MUL, '*', 17);
- register_infix_parser(parse_EXPR_BINARY_DIV, '/', 17);
- register_infix_parser(parse_EXPR_BINARY_MOD, '%', 17);
- register_infix_parser(parse_EXPR_BINARY_ADD, '+', 16);
- register_infix_parser(parse_EXPR_BINARY_SUB, '-', 16);
- register_infix_parser(parse_EXPR_BINARY_SHIFTLEFT, T_LESSLESS, 15);
- register_infix_parser(parse_EXPR_BINARY_SHIFTRIGHT, T_GREATERGREATER, 15);
- register_infix_parser(parse_EXPR_BINARY_LESS, '<', 14);
- register_infix_parser(parse_EXPR_BINARY_GREATER, '>', 14);
- register_infix_parser(parse_EXPR_BINARY_LESSEQUAL, T_LESSEQUAL, 14);
- register_infix_parser(parse_EXPR_BINARY_GREATEREQUAL, T_GREATEREQUAL, 14);
- register_infix_parser(parse_EXPR_BINARY_EQUAL, T_EQUALEQUAL, 13);
- register_infix_parser(parse_EXPR_BINARY_NOTEQUAL,
- T_EXCLAMATIONMARKEQUAL, 13);
- register_infix_parser(parse_EXPR_BINARY_BITWISE_AND, '&', 12);
- register_infix_parser(parse_EXPR_BINARY_BITWISE_XOR, '^', 11);
- register_infix_parser(parse_EXPR_BINARY_BITWISE_OR, '|', 10);
- register_infix_parser(parse_EXPR_BINARY_LOGICAL_AND, T_ANDAND, 9);
- register_infix_parser(parse_EXPR_BINARY_LOGICAL_OR, T_PIPEPIPE, 8);
- register_infix_parser(parse_conditional_expression, '?', 7);
- register_infix_parser(parse_EXPR_BINARY_ASSIGN, '=', 2);
- register_infix_parser(parse_EXPR_BINARY_ADD_ASSIGN, T_PLUSEQUAL, 2);
- register_infix_parser(parse_EXPR_BINARY_SUB_ASSIGN, T_MINUSEQUAL, 2);
- register_infix_parser(parse_EXPR_BINARY_MUL_ASSIGN, T_ASTERISKEQUAL, 2);
- register_infix_parser(parse_EXPR_BINARY_DIV_ASSIGN, T_SLASHEQUAL, 2);
- register_infix_parser(parse_EXPR_BINARY_MOD_ASSIGN, T_PERCENTEQUAL, 2);
- register_infix_parser(parse_EXPR_BINARY_SHIFTLEFT_ASSIGN,
- T_LESSLESSEQUAL, 2);
- register_infix_parser(parse_EXPR_BINARY_SHIFTRIGHT_ASSIGN,
- T_GREATERGREATEREQUAL, 2);
- register_infix_parser(parse_EXPR_BINARY_BITWISE_AND_ASSIGN,
- T_ANDEQUAL, 2);
- register_infix_parser(parse_EXPR_BINARY_BITWISE_OR_ASSIGN,
- T_PIPEEQUAL, 2);
- register_infix_parser(parse_EXPR_BINARY_BITWISE_XOR_ASSIGN,
- T_CARETEQUAL, 2);
-
- register_infix_parser(parse_EXPR_BINARY_COMMA, ',', 1);
-
- register_expression_parser(parse_EXPR_UNARY_NEGATE, '-', 25);
- register_expression_parser(parse_EXPR_UNARY_PLUS, '+', 25);
- register_expression_parser(parse_EXPR_UNARY_NOT, '!', 25);
- register_expression_parser(parse_EXPR_UNARY_BITWISE_NEGATE, '~', 25);
- register_expression_parser(parse_EXPR_UNARY_DEREFERENCE, '*', 25);
- register_expression_parser(parse_EXPR_UNARY_TAKE_ADDRESS, '&', 25);
- register_expression_parser(parse_EXPR_UNARY_PREFIX_INCREMENT,
- T_PLUSPLUS, 25);
- register_expression_parser(parse_EXPR_UNARY_PREFIX_DECREMENT,
- T_MINUSMINUS, 25);
- register_expression_parser(parse_sizeof, T_sizeof, 25);
- register_expression_parser(parse_alignof, T___alignof__, 25);
- register_expression_parser(parse_extension, T___extension__, 25);
- register_expression_parser(parse_builtin_classify_type,
- T___builtin_classify_type, 25);
+ register_infix_parser(parse_array_expression, '[', PREC_POSTFIX);
+ register_infix_parser(parse_call_expression, '(', PREC_POSTFIX);
+ register_infix_parser(parse_select_expression, '.', PREC_POSTFIX);
+ register_infix_parser(parse_select_expression, T_MINUSGREATER, PREC_POSTFIX);
+ register_infix_parser(parse_EXPR_UNARY_POSTFIX_INCREMENT, T_PLUSPLUS, PREC_POSTFIX);
+ register_infix_parser(parse_EXPR_UNARY_POSTFIX_DECREMENT, T_MINUSMINUS, PREC_POSTFIX);
+ register_infix_parser(parse_EXPR_BINARY_MUL, '*', PREC_MULTIPLICATIVE);
+ register_infix_parser(parse_EXPR_BINARY_DIV, '/', PREC_MULTIPLICATIVE);
+ register_infix_parser(parse_EXPR_BINARY_MOD, '%', PREC_MULTIPLICATIVE);
+ register_infix_parser(parse_EXPR_BINARY_ADD, '+', PREC_ADDITIVE);
+ register_infix_parser(parse_EXPR_BINARY_SUB, '-', PREC_ADDITIVE);
+ register_infix_parser(parse_EXPR_BINARY_SHIFTLEFT, T_LESSLESS, PREC_SHIFT);
+ register_infix_parser(parse_EXPR_BINARY_SHIFTRIGHT, T_GREATERGREATER, PREC_SHIFT);
+ register_infix_parser(parse_EXPR_BINARY_LESS, '<', PREC_RELATIONAL);
+ register_infix_parser(parse_EXPR_BINARY_GREATER, '>', PREC_RELATIONAL);
+ register_infix_parser(parse_EXPR_BINARY_LESSEQUAL, T_LESSEQUAL, PREC_RELATIONAL);
+ register_infix_parser(parse_EXPR_BINARY_GREATEREQUAL, T_GREATEREQUAL, PREC_RELATIONAL);
+ register_infix_parser(parse_EXPR_BINARY_EQUAL, T_EQUALEQUAL, PREC_EQUALITY);
+ register_infix_parser(parse_EXPR_BINARY_NOTEQUAL, T_EXCLAMATIONMARKEQUAL, PREC_EQUALITY);
+ register_infix_parser(parse_EXPR_BINARY_BITWISE_AND, '&', PREC_AND);
+ register_infix_parser(parse_EXPR_BINARY_BITWISE_XOR, '^', PREC_XOR);
+ register_infix_parser(parse_EXPR_BINARY_BITWISE_OR, '|', PREC_OR);
+ register_infix_parser(parse_EXPR_BINARY_LOGICAL_AND, T_ANDAND, PREC_LOGICAL_AND);
+ register_infix_parser(parse_EXPR_BINARY_LOGICAL_OR, T_PIPEPIPE, PREC_LOGICAL_OR);
+ register_infix_parser(parse_conditional_expression, '?', PREC_CONDITIONAL);
+ register_infix_parser(parse_EXPR_BINARY_ASSIGN, '=', PREC_ASSIGNMENT);
+ register_infix_parser(parse_EXPR_BINARY_ADD_ASSIGN, T_PLUSEQUAL, PREC_ASSIGNMENT);
+ register_infix_parser(parse_EXPR_BINARY_SUB_ASSIGN, T_MINUSEQUAL, PREC_ASSIGNMENT);
+ register_infix_parser(parse_EXPR_BINARY_MUL_ASSIGN, T_ASTERISKEQUAL, PREC_ASSIGNMENT);
+ register_infix_parser(parse_EXPR_BINARY_DIV_ASSIGN, T_SLASHEQUAL, PREC_ASSIGNMENT);
+ register_infix_parser(parse_EXPR_BINARY_MOD_ASSIGN, T_PERCENTEQUAL, PREC_ASSIGNMENT);
+ register_infix_parser(parse_EXPR_BINARY_SHIFTLEFT_ASSIGN, T_LESSLESSEQUAL, PREC_ASSIGNMENT);
+ register_infix_parser(parse_EXPR_BINARY_SHIFTRIGHT_ASSIGN, T_GREATERGREATEREQUAL, PREC_ASSIGNMENT);
+ register_infix_parser(parse_EXPR_BINARY_BITWISE_AND_ASSIGN, T_ANDEQUAL, PREC_ASSIGNMENT);
+ register_infix_parser(parse_EXPR_BINARY_BITWISE_OR_ASSIGN, T_PIPEEQUAL, PREC_ASSIGNMENT);
+ register_infix_parser(parse_EXPR_BINARY_BITWISE_XOR_ASSIGN, T_CARETEQUAL, PREC_ASSIGNMENT);
+ register_infix_parser(parse_EXPR_BINARY_COMMA, ',', PREC_EXPRESSION);
+
+ register_expression_parser(parse_EXPR_UNARY_NEGATE, '-');
+ register_expression_parser(parse_EXPR_UNARY_PLUS, '+');
+ register_expression_parser(parse_EXPR_UNARY_NOT, '!');
+ register_expression_parser(parse_EXPR_UNARY_BITWISE_NEGATE, '~');
+ register_expression_parser(parse_EXPR_UNARY_DEREFERENCE, '*');
+ register_expression_parser(parse_EXPR_UNARY_TAKE_ADDRESS, '&');
+ register_expression_parser(parse_EXPR_UNARY_PREFIX_INCREMENT, T_PLUSPLUS);
+ register_expression_parser(parse_EXPR_UNARY_PREFIX_DECREMENT, T_MINUSMINUS);
+ register_expression_parser(parse_sizeof, T_sizeof);
+ register_expression_parser(parse_alignof, T___alignof__);
+ register_expression_parser(parse_extension, T___extension__);
+ register_expression_parser(parse_builtin_classify_type, T___builtin_classify_type);
+ register_expression_parser(parse_delete, T_delete);
+ register_expression_parser(parse_throw, T_throw);
}
/**
errorf(&expression->base.source_position,
"asm output argument is not an lvalue");
}
+
+ if (argument->constraints.begin[0] == '+')
+ mark_vars_read(expression, NULL);
+ } else {
+ mark_vars_read(expression, NULL);
}
argument->expression = expression;
expect(')');
/* This check does not prevent the error message in all cases of an
* prior error while parsing the expression. At least it catches the
* common case of a mistyped enum entry. */
- if (is_type_valid(expression->base.type)) {
+ if (is_type_valid(skip_typeref(expression->base.type))) {
errorf(pos, "case label does not reduce to an integer constant");
}
statement->case_label.is_bad = true;
/* This check does not prevent the error message in all cases of an
* prior error while parsing the expression. At least it catches the
* common case of a mistyped enum entry. */
- if (is_type_valid(end_range->base.type)) {
+ if (is_type_valid(skip_typeref(end_range->base.type))) {
errorf(pos, "case range does not reduce to an integer constant");
}
statement->case_label.is_bad = true;
long const val = fold_constant(end_range);
statement->case_label.last_case = val;
- if (val < statement->case_label.first_case) {
+ if (warning.other && val < statement->case_label.first_case) {
statement->case_label.is_empty_range = true;
warningf(pos, "empty range specified");
}
static statement_t *parse_label_statement(void)
{
assert(token.type == T_IDENTIFIER);
- symbol_t *symbol = token.v.symbol;
- declaration_t *label = get_label(symbol);
+ symbol_t *symbol = token.v.symbol;
+ label_t *label = get_label(symbol);
statement_t *const statement = allocate_statement_zero(STATEMENT_LABEL);
statement->label.label = label;
PUSH_PARENT(statement);
/* if statement is already set then the label is defined twice,
- * otherwise it was just mentioned in a goto/local label declaration so far */
- if (label->init.statement != NULL) {
+ * otherwise it was just mentioned in a goto/local label declaration so far
+ */
+ if (label->statement != NULL) {
errorf(HERE, "duplicate label '%Y' (declared %P)",
- symbol, &label->source_position);
+ symbol, &label->base.source_position);
} else {
- label->source_position = token.source_position;
- label->init.statement = statement;
+ label->base.source_position = token.source_position;
+ label->statement = statement;
}
eat(':');
if (token.type == '}') {
/* TODO only warn? */
- if (false) {
+ if (warning.other && false) {
warningf(HERE, "label at end of compound statement");
statement->label.statement = create_empty_statement();
} else {
PUSH_PARENT(statement);
+ add_anchor_token('{');
+
expect('(');
add_anchor_token(')');
- statement->ifs.condition = parse_expression();
+ expression_t *const expr = parse_expression();
+ statement->ifs.condition = expr;
+ mark_vars_read(expr, NULL);
rem_anchor_token(')');
expect(')');
+end_error:
+ rem_anchor_token('{');
+
add_anchor_token(T_else);
statement->ifs.true_statement = parse_statement();
rem_anchor_token(T_else);
POP_PARENT;
return statement;
-end_error:
- POP_PARENT;
- return create_invalid_statement();
}
/**
return;
/* FIXME: calculation of value should be done while parsing */
- const declaration_t *declaration;
- long last_value = -1;
- for (declaration = enumt->declaration->next;
- declaration != NULL && declaration->storage_class == STORAGE_CLASS_ENUM_ENTRY;
- declaration = declaration->next) {
- const expression_t *expression = declaration->init.enum_value;
+ /* TODO: quadratic algorithm here. Change to an n log n one */
+ long last_value = -1;
+ const entity_t *entry = enumt->enume->base.next;
+ for (; entry != NULL && entry->kind == ENTITY_ENUM_VALUE;
+ entry = entry->base.next) {
+ const expression_t *expression = entry->enum_value.value;
long value = expression != NULL ? fold_constant(expression) : last_value + 1;
bool found = false;
for (const case_label_statement_t *l = statement->first_case; l != NULL; l = l->next) {
}
if (! found) {
warningf(&statement->base.source_position,
- "enumeration value '%Y' not handled in switch", declaration->symbol);
+ "enumeration value '%Y' not handled in switch",
+ entry->base.symbol);
}
last_value = value;
}
expect('(');
add_anchor_token(')');
expression_t *const expr = parse_expression();
+ mark_vars_read(expr, NULL);
type_t * type = skip_typeref(expr->base.type);
if (is_type_integer(type)) {
type = promote_integer(type);
expect('(');
add_anchor_token(')');
- statement->whiles.condition = parse_expression();
+ expression_t *const cond = parse_expression();
+ statement->whiles.condition = cond;
+ mark_vars_read(cond, NULL);
rem_anchor_token(')');
expect(')');
eat(T_do);
- PUSH_PARENT(statement)
+ PUSH_PARENT(statement);
add_anchor_token(T_while);
statement->do_while.body = parse_loop_body(statement);
expect(T_while);
expect('(');
add_anchor_token(')');
- statement->do_while.condition = parse_expression();
+ expression_t *const cond = parse_expression();
+ statement->do_while.condition = cond;
+ mark_vars_read(cond, NULL);
rem_anchor_token(')');
expect(')');
expect(';');
if (token.type != ';') {
if (is_declaration_specifier(&token, false)) {
- parse_declaration(record_declaration);
+ parse_declaration(record_entity);
} else {
add_anchor_token(';');
expression_t *const init = parse_expression();
statement->fors.initialisation = init;
+ mark_vars_read(init, VAR_ANY);
if (warning.unused_value && !expression_has_effect(init)) {
warningf(&init->base.source_position,
"initialisation of 'for'-statement has no effect");
if (token.type != ';') {
add_anchor_token(';');
- statement->fors.condition = parse_expression();
+ expression_t *const cond = parse_expression();
+ statement->fors.condition = cond;
+ mark_vars_read(cond, NULL);
rem_anchor_token(';');
}
expect(';');
if (token.type != ')') {
expression_t *const step = parse_expression();
statement->fors.step = step;
+ mark_vars_read(step, VAR_ANY);
if (warning.unused_value && !expression_has_effect(step)) {
warningf(&step->base.source_position,
"step of 'for'-statement has no effect");
}
}
- rem_anchor_token(')');
expect(')');
+ rem_anchor_token(')');
statement->fors.body = parse_loop_body(statement);
assert(scope == &statement->fors.scope);
if (GNU_MODE && token.type == '*') {
next_token();
expression_t *expression = parse_expression();
+ mark_vars_read(expression, NULL);
/* Argh: although documentation say the expression must be of type void *,
* gcc excepts anything that can be casted into void * without error */
if (!is_type_pointer(type) && !is_type_integer(type)) {
errorf(&expression->base.source_position,
"cannot convert to a pointer type");
- } else if (type != type_void_ptr) {
+ } else if (warning.other && type != type_void_ptr) {
warningf(&expression->base.source_position,
"type of computed goto expression should be 'void*' not '%T'", type);
}
next_token();
statement->gotos.label = get_label(symbol);
-
- if (statement->gotos.label->parent_scope->depth < current_function->scope.depth) {
- statement->gotos.outer_fkt_jmp = true;
- }
}
/* remember the goto's in a list for later checking */
}
/**
- * Check if a given declaration represents a local variable.
+ * Check if a given entity represents a local variable.
*/
-static bool is_local_var_declaration(const declaration_t *declaration)
+static bool is_local_variable(const entity_t *entity)
{
- switch ((storage_class_tag_t) declaration->storage_class) {
+ if (entity->kind != ENTITY_VARIABLE)
+ return false;
+
+ switch ((storage_class_tag_t) entity->declaration.storage_class) {
case STORAGE_CLASS_AUTO:
case STORAGE_CLASS_REGISTER: {
- const type_t *type = skip_typeref(declaration->type);
+ const type_t *type = skip_typeref(entity->declaration.type);
if (is_type_function(type)) {
return false;
} else {
}
}
-/**
- * Check if a given declaration represents a variable.
- */
-static bool is_var_declaration(const declaration_t *declaration)
-{
- if (declaration->storage_class == STORAGE_CLASS_TYPEDEF)
- return false;
-
- const type_t *type = skip_typeref(declaration->type);
- return !is_type_function(type);
-}
-
/**
* Check if a given expression represents a local variable.
*/
-static bool is_local_variable(const expression_t *expression)
+static bool expression_is_local_variable(const expression_t *expression)
{
if (expression->base.kind != EXPR_REFERENCE) {
return false;
}
- const declaration_t *declaration = expression->reference.declaration;
- return is_local_var_declaration(declaration);
+ const entity_t *entity = expression->reference.entity;
+ return is_local_variable(entity);
}
/**
* Check if a given expression represents a local variable and
* return its declaration then, else return NULL.
*/
-declaration_t *expr_is_variable(const expression_t *expression)
+entity_t *expression_is_variable(const expression_t *expression)
{
if (expression->base.kind != EXPR_REFERENCE) {
return NULL;
}
- declaration_t *declaration = expression->reference.declaration;
- if (is_var_declaration(declaration))
- return declaration;
- return NULL;
+ entity_t *entity = expression->reference.entity;
+ if (entity->kind != ENTITY_VARIABLE)
+ return NULL;
+
+ return entity;
}
/**
expression_t *return_value = NULL;
if (token.type != ';') {
return_value = parse_expression();
+ mark_vars_read(return_value, NULL);
}
- const type_t *const func_type = current_function->type;
+ const type_t *const func_type = current_function->base.type;
assert(is_type_function(func_type));
type_t *const return_type = skip_typeref(func_type->function.return_type);
if (return_value != NULL) {
type_t *return_value_type = skip_typeref(return_value->base.type);
- if (is_type_atomic(return_type, ATOMIC_TYPE_VOID)
- && !is_type_atomic(return_value_type, ATOMIC_TYPE_VOID)) {
- warningf(&statement->base.source_position,
- "'return' with a value, in function returning void");
+ if (is_type_atomic(return_type, ATOMIC_TYPE_VOID) &&
+ !is_type_atomic(return_value_type, ATOMIC_TYPE_VOID)) {
+ if (warning.other) {
+ warningf(&statement->base.source_position,
+ "'return' with a value, in function returning void");
+ }
return_value = NULL;
} else {
assign_error_t error = semantic_assign(return_type, return_value);
return_value = create_implicit_cast(return_value, return_type);
}
/* check for returning address of a local var */
- if (return_value != NULL &&
- return_value->base.kind == EXPR_UNARY_TAKE_ADDRESS) {
+ if (warning.other && return_value != NULL
+ && return_value->base.kind == EXPR_UNARY_TAKE_ADDRESS) {
const expression_t *expression = return_value->unary.value;
- if (is_local_variable(expression)) {
+ if (expression_is_local_variable(expression)) {
warningf(&statement->base.source_position,
"function returns address of local variable");
}
}
- } else {
- if (!is_type_atomic(return_type, ATOMIC_TYPE_VOID)) {
- warningf(&statement->base.source_position,
- "'return' without value, in function returning non-void");
- }
+ } else if (warning.other && !is_type_atomic(return_type, ATOMIC_TYPE_VOID)) {
+ warningf(&statement->base.source_position,
+ "'return' without value, in function returning non-void");
}
statement->returns.value = return_value;
{
statement_t *statement = allocate_statement_zero(STATEMENT_DECLARATION);
- declaration_t *before = last_declaration;
+ entity_t *before = scope->last_entity;
if (GNU_MODE)
parse_external_declaration();
else
- parse_declaration(record_declaration);
+ parse_declaration(record_entity);
if (before == NULL) {
- statement->declaration.declarations_begin = scope->declarations;
+ statement->declaration.declarations_begin = scope->entities;
} else {
- statement->declaration.declarations_begin = before->next;
+ statement->declaration.declarations_begin = before->base.next;
}
- statement->declaration.declarations_end = last_declaration;
+ statement->declaration.declarations_end = scope->last_entity;
return statement;
}
expression_t *const expr = parse_expression();
statement->expression.expression = expr;
+ mark_vars_read(expr, VAR_ANY);
expect(';');
expect('(');
add_anchor_token(')');
expression_t *const expr = parse_expression();
+ mark_vars_read(expr, NULL);
type_t * type = skip_typeref(expr->base.type);
if (is_type_integer(type)) {
type = promote_integer(type);
return statement;
}
-static statement_t *parse_local_label_declaration(void) {
+static statement_t *parse_local_label_declaration(void)
+{
statement_t *statement = allocate_statement_zero(STATEMENT_DECLARATION);
eat(T___label__);
- declaration_t *begin = NULL, *end = NULL;
+ entity_t *begin = NULL, *end = NULL;
while (true) {
if (token.type != T_IDENTIFIER) {
T_IDENTIFIER, NULL);
goto end_error;
}
- symbol_t *symbol = token.v.symbol;
- declaration_t *declaration = get_declaration(symbol, NAMESPACE_LOCAL_LABEL);
- if (declaration != NULL) {
- errorf(HERE, "multiple definitions of '__label__ %Y' (previous definition at %P)",
- symbol, &declaration->source_position);
+ symbol_t *symbol = token.v.symbol;
+ entity_t *entity = get_entity(symbol, NAMESPACE_LOCAL_LABEL);
+ if (entity != NULL && entity->base.parent_scope == scope) {
+ errorf(HERE, "multiple definitions of '__label__ %Y' (previous definition %P)",
+ symbol, &entity->base.source_position);
} else {
- declaration = allocate_declaration_zero();
- declaration->namespc = NAMESPACE_LOCAL_LABEL;
- declaration->source_position = token.source_position;
- declaration->symbol = symbol;
- declaration->parent_scope = scope;
- declaration->init.statement = NULL;
+ entity = allocate_entity_zero(ENTITY_LOCAL_LABEL);
+
+ entity->base.parent_scope = scope;
+ entity->base.namespc = NAMESPACE_LOCAL_LABEL;
+ entity->base.source_position = token.source_position;
+ entity->base.symbol = symbol;
if (end != NULL)
- end->next = declaration;
- end = declaration;
+ end->base.next = entity;
+ end = entity;
if (begin == NULL)
- begin = declaration;
+ begin = entity;
- local_label_push(declaration);
+ local_label_push(entity);
}
next_token();
statement = parse_label_statement();
} else if (is_typedef_symbol(token.v.symbol)) {
statement = parse_declaration_statement();
- } else switch (la1_type) {
+ } else {
+ /* it's an identifier, the grammar says this must be an
+ * expression statement. However it is common that users mistype
+ * declaration types, so we guess a bit here to improve robustness
+ * for incorrect programs */
+ switch (la1_type) {
case '*':
- if (get_declaration(token.v.symbol, NAMESPACE_NORMAL) != NULL)
+ if (get_entity(token.v.symbol, NAMESPACE_NORMAL) != NULL)
goto expression_statment;
/* FALLTHROUGH */
expression_statment:
statement = parse_expression_statement();
break;
+ }
}
break;
}
case T_do: statement = parse_do(); break;
case T_for: statement = parse_for(); break;
case T_goto: statement = parse_goto(); break;
- case T_if: statement = parse_if (); break;
+ case T_if: statement = parse_if(); break;
case T_return: statement = parse_return(); break;
case T_switch: statement = parse_switch(); break;
case T_while: statement = parse_while(); break;
- case '!':
- case '&':
- case '(':
- case '*':
- case '+':
- case '-':
- case '~':
- case T_ANDAND:
- case T_CHARACTER_CONSTANT:
- case T_FLOATINGPOINT:
- case T_INTEGER:
- case T_MINUSMINUS:
- case T_PLUSPLUS:
- case T_STRING_LITERAL:
- case T_WIDE_CHARACTER_CONSTANT:
- case T_WIDE_STRING_LITERAL:
- case T___FUNCDNAME__:
- case T___FUNCSIG__:
- case T___FUNCTION__:
- case T___PRETTY_FUNCTION__:
- case T___builtin_alloca:
- case T___builtin_classify_type:
- case T___builtin_constant_p:
- case T___builtin_expect:
- case T___builtin_huge_val:
- case T___builtin_isgreater:
- case T___builtin_isgreaterequal:
- case T___builtin_isless:
- case T___builtin_islessequal:
- case T___builtin_islessgreater:
- case T___builtin_isunordered:
- case T___builtin_nan:
- case T___builtin_nand:
- case T___builtin_nanf:
- case T___builtin_offsetof:
- case T___builtin_prefetch:
- case T___builtin_va_arg:
- case T___builtin_va_end:
- case T___builtin_va_start:
- case T___func__:
- case T___noop:
- case T__assume:
+ EXPRESSION_START
statement = parse_expression_statement();
break;
type_wchar_t_ptr = make_pointer_type(type_wchar_t, TYPE_QUALIFIER_NONE);
/* const version of wchar_t */
- type_const_wchar_t = allocate_type_zero(TYPE_TYPEDEF, &builtin_source_position);
- type_const_wchar_t->typedeft.declaration = type_wchar_t->typedeft.declaration;
- type_const_wchar_t->base.qualifiers |= TYPE_QUALIFIER_CONST;
+ type_const_wchar_t = allocate_type_zero(TYPE_TYPEDEF);
+ type_const_wchar_t->typedeft.typedefe = type_wchar_t->typedeft.typedefe;
+ type_const_wchar_t->base.qualifiers |= TYPE_QUALIFIER_CONST;
type_const_wchar_t_ptr = make_pointer_type(type_const_wchar_t, TYPE_QUALIFIER_NONE);
}
if (!warning.unused_function && !warning.unused_variable)
return;
- for (const declaration_t *decl = file_scope->declarations; decl != NULL; decl = decl->next) {
- if (decl->used ||
- decl->modifiers & DM_UNUSED ||
- decl->modifiers & DM_USED ||
- decl->storage_class != STORAGE_CLASS_STATIC)
+ for (const entity_t *entity = file_scope->entities; entity != NULL;
+ entity = entity->base.next) {
+ if (!is_declaration(entity))
continue;
- type_t *const type = decl->type;
+ const declaration_t *declaration = &entity->declaration;
+ if (declaration->used ||
+ declaration->modifiers & DM_UNUSED ||
+ declaration->modifiers & DM_USED ||
+ declaration->storage_class != STORAGE_CLASS_STATIC)
+ continue;
+
+ type_t *const type = declaration->type;
const char *s;
- if (is_type_function(skip_typeref(type))) {
- if (!warning.unused_function || decl->is_inline)
+ if (entity->kind == ENTITY_FUNCTION) {
+ /* inhibit warning for static inline functions */
+ if (entity->function.is_inline)
continue;
- s = (decl->init.statement != NULL ? "defined" : "declared");
+ s = entity->function.statement != NULL ? "defined" : "declared";
} else {
- if (!warning.unused_variable)
- continue;
-
s = "defined";
}
- warningf(&decl->source_position, "'%#T' %s but not used",
- type, decl->symbol, s);
+ warningf(&declaration->base.source_position, "'%#T' %s but not used",
+ type, declaration->base.symbol, s);
}
}
case ';':
if (!strict_mode) {
- warningf(HERE, "stray ';' outside of function");
+ if (warning.other)
+ warningf(HERE, "stray ';' outside of function");
next_token();
break;
}
/* do NOT use scope_pop() here, this will crash, will it by hand */
assert(scope == &unit->scope);
scope = NULL;
- last_declaration = NULL;
assert(file_scope == &unit->scope);
check_unused_globals();
projects / cparser / blobdiff