#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;
+ entity_namespace_t namespc;
} stack_entry_t;
+typedef struct argument_list_t argument_list_t;
+struct argument_list_t {
+ long argument;
+ argument_list_t *next;
+};
+
typedef struct gnu_attribute_t gnu_attribute_t;
struct gnu_attribute_t {
- gnu_attribute_kind_t kind;
+ gnu_attribute_kind_t kind; /**< The kind of the GNU attribute. */
gnu_attribute_t *next;
- bool invalid;
- bool have_arguments;
+ bool invalid; /**< Set if this attribute had argument errors, */
+ bool have_arguments; /**< True, if this attribute has arguments. */
union {
size_t value;
string_t string;
atomic_type_kind_t akind;
+ long argument; /**< Single argument. */
+ argument_list_t *arguments; /**< List of argument expressions. */
} u;
};
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);
-
-static token_t token;
-static token_t lookahead_buffer[MAX_LOOKAHEAD];
-static int lookahead_bufpos;
-static stack_entry_t *environment_stack = NULL;
-static stack_entry_t *label_stack = NULL;
-static scope_t *global_scope = NULL;
-static scope_t *scope = NULL;
-static declaration_t *last_declaration = NULL;
-static declaration_t *current_function = NULL;
-static switch_statement_t *current_switch = NULL;
-static statement_t *current_loop = NULL;
-static ms_try_statement_t *current_try = NULL;
-static goto_statement_t *goto_first = NULL;
-static goto_statement_t *goto_last = NULL;
-static label_statement_t *label_first = NULL;
-static label_statement_t *label_last = NULL;
-static translation_unit_t *unit = NULL;
-static struct obstack temp_obst;
-
-static source_position_t null_position = { NULL, 0 };
+typedef entity_t* (*parsed_declaration_func) (entity_t *declaration, bool is_definition);
+
+/** The current token. */
+static token_t token;
+/** The lookahead ring-buffer. */
+static token_t lookahead_buffer[MAX_LOOKAHEAD];
+/** Position of the next token in the lookahead buffer. */
+static int lookahead_bufpos;
+static stack_entry_t *environment_stack = NULL;
+static stack_entry_t *label_stack = NULL;
+static scope_t *file_scope = NULL;
+static scope_t *current_scope = NULL;
+/** Point to the current function declaration if inside a function. */
+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;
+static ms_try_statement_t *current_try = NULL;
+static linkage_kind_t current_linkage = LINKAGE_INVALID;
+static goto_statement_t *goto_first = NULL;
+static goto_statement_t **goto_anchor = NULL;
+static label_statement_t *label_first = NULL;
+static label_statement_t **label_anchor = NULL;
+/** current translation unit. */
+static translation_unit_t *unit = NULL;
+/** true if we are in a type property context (evaluation only for type. */
+static bool in_type_prop = false;
+/** true in we are in a __extension__ context. */
+static bool in_gcc_extension = false;
+static struct obstack temp_obst;
+
+
+#define PUSH_PARENT(stmt) \
+ statement_t *const prev_parent = current_parent; \
+ ((void)(current_parent = (stmt)))
+#define POP_PARENT ((void)(current_parent = prev_parent))
+
+/** special symbol used for anonymous entities. */
+static const symbol_t *sym_anonymous = NULL;
/* symbols for Microsoft extended-decl-modifier */
static const symbol_t *sym_align = NULL;
/** The current source position. */
#define HERE (&token.source_position)
+/** true if we are in GCC mode. */
+#define GNU_MODE ((c_mode & _GNUC) || in_gcc_extension)
+
static type_t *type_valist;
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_externals(void);
+static void parse_external(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);
+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);
case T_extern: \
case T_static: \
case T_auto: \
- case T_register:
+ case T_register: \
+ case T___thread:
+
+#define STORAGE_CLASSES_NO_EXTERN \
+ case T_typedef: \
+ case T_static: \
+ case T_auto: \
+ case T_register: \
+ case T___thread:
#define TYPE_QUALIFIERS \
case T_const: \
case T__forceinline: \
case T___attribute__:
-#ifdef PROVIDE_COMPLEX
#define COMPLEX_SPECIFIERS \
case T__Complex:
#define IMAGINARY_SPECIFIERS \
case T__Imaginary:
-#else
-#define COMPLEX_SPECIFIERS
-#define IMAGINARY_SPECIFIERS
-#endif
#define TYPE_SPECIFIERS \
- case T_void: \
+ case T__Bool: \
+ case T___builtin_va_list: \
+ case T___typeof__: \
+ case T__declspec: \
+ case T_bool: \
case T_char: \
- case T_short: \
+ case T_double: \
+ case T_enum: \
+ case T_float: \
case T_int: \
case T_long: \
- case T_float: \
- case T_double: \
+ case T_short: \
case T_signed: \
- case T_unsigned: \
- case T__Bool: \
case T_struct: \
case T_union: \
- case T_enum: \
- case T___typeof__: \
- case T___builtin_va_list: \
- case T__declspec: \
+ case T_unsigned: \
+ case T_void: \
COMPLEX_SPECIFIERS \
IMAGINARY_SPECIFIERS
TYPE_QUALIFIERS \
TYPE_SPECIFIERS
+#define DECLARATION_START_NO_EXTERN \
+ STORAGE_CLASSES_NO_EXTERN \
+ TYPE_QUALIFIERS \
+ TYPE_SPECIFIERS
+
#define TYPENAME_START \
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_delete: \
+ case T_false: \
+ case T_sizeof: \
+ case T_throw: \
+ case T_true:
+
/**
* 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)
+{
+ 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),
+ [ENTITY_NAMESPACE] = sizeof(namespace_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)
{
- declaration_t *declaration = allocate_ast_zero(sizeof(declaration_t));
- declaration->type = type_error_type;
- declaration->alignment = 0;
- return declaration;
+ 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),
[STATEMENT_MS_TRY] = sizeof(ms_try_statement_t),
[STATEMENT_LEAVE] = sizeof(leave_statement_t)
};
- assert(kind <= sizeof(sizes) / sizeof(sizes[0]));
+ assert(kind < sizeof(sizes) / sizeof(sizes[0]));
assert(sizes[kind] != 0);
return sizes[kind];
}
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),
[EXPR_VA_START] = sizeof(va_start_expression_t),
[EXPR_VA_ARG] = sizeof(va_arg_expression_t),
[EXPR_STATEMENT] = sizeof(statement_expression_t),
+ [EXPR_LABEL_ADDRESS] = sizeof(label_address_expression_t),
};
if (kind >= EXPR_UNARY_FIRST && kind <= EXPR_UNARY_LAST) {
return sizes[EXPR_UNARY_FIRST];
if (kind >= EXPR_BINARY_FIRST && kind <= EXPR_BINARY_LAST) {
return sizes[EXPR_BINARY_FIRST];
}
- assert(kind <= sizeof(sizes) / sizeof(sizes[0]));
+ assert(kind < sizeof(sizes) / sizeof(sizes[0]));
assert(sizes[kind] != 0);
return sizes[kind];
}
size_t size = get_statement_struct_size(kind);
statement_t *res = allocate_ast_zero(size);
- res->base.kind = kind;
+ res->base.kind = kind;
+ res->base.parent = current_parent;
+ res->base.source_position = token.source_position;
return res;
}
size_t size = get_expression_struct_size(kind);
expression_t *res = allocate_ast_zero(size);
- res->base.kind = kind;
- res->base.type = type_error_type;
+ res->base.kind = kind;
+ res->base.type = type_error_type;
+ res->base.source_position = token.source_position;
return res;
}
*/
static expression_t *create_invalid_expression(void)
{
- expression_t *expression = allocate_expression_zero(EXPR_INVALID);
- expression->base.source_position = token.source_position;
- return expression;
+ return allocate_expression_zero(EXPR_INVALID);
}
/**
*/
static statement_t *create_invalid_statement(void)
{
- statement_t *statement = allocate_statement_zero(STATEMENT_INVALID);
- statement->base.source_position = token.source_position;
- return statement;
+ return allocate_statement_zero(STATEMENT_INVALID);
}
/**
*/
static statement_t *create_empty_statement(void)
{
- statement_t *statement = allocate_statement_zero(STATEMENT_EMPTY);
- statement->base.source_position = token.source_position;
- return statement;
+ return allocate_statement_zero(STATEMENT_EMPTY);
}
/**
/**
* Allocate a type node of given kind and initialize all
* fields with zero.
+ *
+ * @param kind type kind to allocate
*/
-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;
}
}
/**
- * Returns the index of the top element of the label stack.
+ * Returns the index of the top element of the global label stack.
*/
static size_t label_top(void)
{
/**
* Adds a token to the token anchor set (a multi-set).
*/
-static void add_anchor_token(int token_type) {
+static void add_anchor_token(int token_type)
+{
assert(0 <= token_type && token_type < T_LAST_TOKEN);
++token_anchor_set[token_type];
}
-static int save_and_reset_anchor_state(int token_type) {
+static int save_and_reset_anchor_state(int token_type)
+{
assert(0 <= token_type && token_type < T_LAST_TOKEN);
int count = token_anchor_set[token_type];
token_anchor_set[token_type] = 0;
return count;
}
-static void restore_anchor_state(int token_type, int count) {
+static void restore_anchor_state(int token_type, int count)
+{
assert(0 <= token_type && token_type < T_LAST_TOKEN);
token_anchor_set[token_type] = count;
}
/**
* Remove a token from the token anchor set (a multi-set).
*/
-static void rem_anchor_token(int token_type) {
+static void rem_anchor_token(int token_type)
+{
assert(0 <= token_type && token_type < T_LAST_TOKEN);
+ assert(token_anchor_set[token_type] != 0);
--token_anchor_set[token_type];
}
-static bool at_anchor(void) {
+static bool at_anchor(void)
+{
if (token.type < 0)
return false;
return token_anchor_set[token.type];
/**
* Eat tokens until a matching token is found.
*/
-static void eat_until_matching_token(int type) {
- unsigned parenthesis_count = 0;
- unsigned brace_count = 0;
- unsigned bracket_count = 0;
- int end_token = type;
-
- if (type == '(')
- end_token = ')';
- else if (type == '{')
- end_token = '}';
- else if (type == '[')
- end_token = ']';
-
- while(token.type != end_token ||
- (parenthesis_count > 0 || brace_count > 0 || bracket_count > 0)) {
+static void eat_until_matching_token(int type)
+{
+ int end_token;
+ switch (type) {
+ case '(': end_token = ')'; break;
+ case '{': end_token = '}'; break;
+ case '[': end_token = ']'; break;
+ default: end_token = type; break;
+ }
- switch(token.type) {
+ unsigned parenthesis_count = 0;
+ unsigned brace_count = 0;
+ unsigned bracket_count = 0;
+ while (token.type != end_token ||
+ parenthesis_count != 0 ||
+ brace_count != 0 ||
+ bracket_count != 0) {
+ switch (token.type) {
case T_EOF: return;
case '(': ++parenthesis_count; break;
case '{': ++brace_count; break;
case '[': ++bracket_count; break;
+
case ')':
if (parenthesis_count > 0)
--parenthesis_count;
- break;
+ goto check_stop;
+
case '}':
if (brace_count > 0)
--brace_count;
- break;
+ goto check_stop;
+
case ']':
if (bracket_count > 0)
--bracket_count;
+check_stop:
+ if (token.type == end_token &&
+ parenthesis_count == 0 &&
+ brace_count == 0 &&
+ bracket_count == 0)
+ return;
break;
+
default:
break;
}
/**
* Eat input tokens until an anchor is found.
*/
-static void eat_until_anchor(void) {
- if (token.type == T_EOF)
- return;
- while(token_anchor_set[token.type] == 0) {
+static void eat_until_anchor(void)
+{
+ while (token_anchor_set[token.type] == 0) {
if (token.type == '(' || token.type == '{' || token.type == '[')
eat_until_matching_token(token.type);
- if (token.type == T_EOF)
- break;
next_token();
}
}
-static void eat_block(void) {
+static void eat_block(void)
+{
eat_until_matching_token('{');
if (token.type == '}')
next_token();
}
-/**
- * eat all token until a ';' is reached or a stop token is found.
- */
-static void eat_statement(void) {
- eat_until_matching_token(';');
- if (token.type == ';')
- next_token();
-}
-
-#define eat(token_type) do { assert(token.type == token_type); next_token(); } while(0)
+#define eat(token_type) do { assert(token.type == (token_type)); next_token(); } while (0)
/**
* Report a parse error because an expected token was not found.
* If not, generate an error, eat the current statement,
* and goto the end_error label.
*/
-#define expect(expected) \
- do { \
- if (UNLIKELY(token.type != (expected))) { \
- parse_error_expected(NULL, (expected), NULL); \
- add_anchor_token(expected); \
- eat_until_anchor(); \
- if (token.type == expected) \
- next_token(); \
- rem_anchor_token(expected); \
- goto end_error; \
- } \
- next_token(); \
- } while(0)
+#define expect(expected) \
+ do { \
+ if (UNLIKELY(token.type != (expected))) { \
+ parse_error_expected(NULL, (expected), NULL); \
+ add_anchor_token(expected); \
+ eat_until_anchor(); \
+ if (token.type == expected) \
+ next_token(); \
+ rem_anchor_token(expected); \
+ goto end_error; \
+ } \
+ next_token(); \
+ } while (0)
-static void set_scope(scope_t *new_scope)
+static void scope_push(scope_t *new_scope)
{
- if (scope != NULL) {
- scope->last_declaration = last_declaration;
+ if (current_scope != NULL) {
+ new_scope->depth = current_scope->depth + 1;
}
- scope = new_scope;
+ new_scope->parent = current_scope;
+ current_scope = new_scope;
+}
- last_declaration = new_scope->last_declaration;
+static void scope_pop(void)
+{
+ current_scope = current_scope->parent;
}
/**
- * 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_tag_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;
+ entity_namespace_t namespc = entity->base.namespc;
+ assert(namespc != NAMESPACE_INVALID);
- /* replace/add declaration into declaration list of the symbol */
- declaration_t *iter = symbol->declaration;
- if (iter == NULL) {
- symbol->declaration = declaration;
- } else {
- declaration_t *iter_last = NULL;
- for( ; iter != NULL; iter_last = iter, iter = iter->symbol_next) {
- /* replace an entry? */
- if (iter->namespc == namespc) {
- if (iter_last == NULL) {
- symbol->declaration = declaration;
- } else {
- iter_last->symbol_next = declaration;
- }
- declaration->symbol_next = iter->symbol_next;
- break;
- }
- }
- if (iter == NULL) {
- assert(iter_last->symbol_next == NULL);
- iter_last->symbol_next = declaration;
+ /* 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->base.namespc == namespc) {
+ entity->base.symbol_next = iter->base.symbol_next;
+ break;
}
}
+ *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);
}
-static void environment_push(declaration_t *declaration)
+/**
+ * Push an entity on the environment stack.
+ */
+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);
}
-static void label_push(declaration_t *declaration)
+/**
+ * Push a declaration on the global label stack.
+ *
+ * @param declaration the 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);
}
/**
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;
+ entity_namespace_t namespc = entry->namespc;
- /* replace/remove declaration */
- declaration_t *declaration = symbol->declaration;
- assert(declaration != NULL);
- if (declaration->namespc == namespc) {
- if (old_declaration == NULL) {
- symbol->declaration = declaration->symbol_next;
- } else {
- symbol->declaration = old_declaration;
- }
- } else {
- declaration_t *iter_last = declaration;
- declaration_t *iter = declaration->symbol_next;
- for( ; iter != NULL; iter_last = iter, iter = iter->symbol_next) {
- /* replace an entry? */
- if (iter->namespc == namespc) {
- assert(iter_last != NULL);
- iter_last->symbol_next = old_declaration;
- if (old_declaration != NULL) {
- old_declaration->symbol_next = iter->symbol_next;
- }
- break;
- }
- }
+ /* 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->base.namespc == namespc)
+ break;
+ }
+
+ /* 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);
}
+/**
+ * Pop all entries from the environment stack until the new_top
+ * is reached.
+ *
+ * @param new_top the new stack top
+ */
static void environment_pop_to(size_t new_top)
{
stack_pop_to(&environment_stack, new_top);
}
+/**
+ * Pop all entries from the global label stack until the new_top
+ * is reached.
+ *
+ * @param new_top the new stack top
+ */
static void label_pop_to(size_t new_top)
{
stack_pop_to(&label_stack, new_top);
}
+static int get_akind_rank(atomic_type_kind_t akind)
+{
+ return (int) akind;
+}
static int get_rank(const type_t *type)
{
* (unsigned int would be preferable when possible... for stuff like
* struct { enum { ... } bla : 4; } ) */
if (type->kind == TYPE_ENUM)
- return ATOMIC_TYPE_INT;
+ return get_akind_rank(ATOMIC_TYPE_INT);
assert(type->kind == TYPE_ATOMIC);
- return type->atomic.akind;
+ return get_akind_rank(type->atomic.akind);
}
static type_t *promote_integer(type_t *type)
if (type->kind == TYPE_BITFIELD)
type = type->bitfield.base_type;
- if (get_rank(type) < ATOMIC_TYPE_INT)
+ if (get_rank(type) < get_akind_rank(ATOMIC_TYPE_INT))
type = type_int;
return type;
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;
- errorf(source_position,
- "destination type '%T' in %s from type '%T' lacks qualifiers '%Q' in pointed-to 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 integer '%T' from pointer '%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:
= skip_typeref(type_left->pointer.points_to);
type_t *points_to_right
= skip_typeref(type_right->pointer.points_to);
+ assign_error_t res = ASSIGN_SUCCESS;
/* the left type has all qualifiers from the right type */
unsigned missing_qualifiers
= points_to_right->base.qualifiers & ~points_to_left->base.qualifiers;
if (missing_qualifiers != 0) {
- return ASSIGN_ERROR_POINTER_QUALIFIER_MISSING;
+ res = ASSIGN_ERROR_POINTER_QUALIFIER_MISSING;
}
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)) {
- return ASSIGN_SUCCESS;
+ 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)) {
return ASSIGN_WARNING_POINTER_INCOMPATIBLE;
}
- return ASSIGN_SUCCESS;
+ return res;
} else if (is_type_integer(type_right)) {
return ASSIGN_WARNING_POINTER_FROM_INT;
}
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);
-}
-
-static type_t *make_global_typedef(const char *name, type_t *type)
-{
- 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;
-
- record_declaration(declaration);
-
- type_t *typedef_type = allocate_type_zero(TYPE_TYPEDEF, &builtin_source_position);
- typedef_type->typedeft.declaration = declaration;
-
- return typedef_type;
+ return parse_sub_expression(PREC_ASSIGNMENT);
}
static string_t parse_string_literals(void)
return result;
}
-static const char *gnu_attribute_names[GNU_AK_LAST] = {
+static const char *const gnu_attribute_names[GNU_AK_LAST] = {
[GNU_AK_CONST] = "const",
[GNU_AK_VOLATILE] = "volatile",
[GNU_AK_CDECL] = "cdecl",
[GNU_AK_ALWAYS_INLINE] = "always_inline",
[GNU_AK_MALLOC] = "malloc",
[GNU_AK_WEAK] = "weak",
- [GNU_AK_CONSTRUCTOR] = "constructor",
+ [GNU_AK_CONSTRUCTOR] = "constructor",
[GNU_AK_DESTRUCTOR] = "destructor",
[GNU_AK_NOTHROW] = "nothrow",
[GNU_AK_TRANSPARENT_UNION] = "transparent_union",
[GNU_AK_NO_INSTRUMENT_FUNCTION] = "no_instrument_function",
[GNU_AK_WARN_UNUSED_RESULT] = "warn_unused_result",
[GNU_AK_LONGCALL] = "longcall",
- [GNU_AK_SHORTCALL] = "shortcall",
+ [GNU_AK_SHORTCALL] = "shortcall",
[GNU_AK_LONG_CALL] = "long_call",
- [GNU_AK_SHORT_CALL] = "short_call",
+ [GNU_AK_SHORT_CALL] = "short_call",
[GNU_AK_FUNCTION_VECTOR] = "function_vector",
- [GNU_AK_INTERRUPT] = "interrupt",
- [GNU_AK_INTERRUPT_HANDLER] = "interrupt_handler",
- [GNU_AK_NMI_HANDLER] = "nmi_handler",
- [GNU_AK_NESTING] = "nesting",
- [GNU_AK_NEAR] = "near",
+ [GNU_AK_INTERRUPT] = "interrupt",
+ [GNU_AK_INTERRUPT_HANDLER] = "interrupt_handler",
+ [GNU_AK_NMI_HANDLER] = "nmi_handler",
+ [GNU_AK_NESTING] = "nesting",
+ [GNU_AK_NEAR] = "near",
[GNU_AK_FAR] = "far",
[GNU_AK_SIGNAL] = "signal",
[GNU_AK_EIGTHBIT_DATA] = "eightbit_data",
/**
* compare two string, ignoring double underscores on the second.
*/
-static int strcmp_underscore(const char *s1, const char *s2) {
+static int strcmp_underscore(const char *s1, const char *s2)
+{
if (s2[0] == '_' && s2[1] == '_') {
size_t len2 = strlen(s2);
size_t len1 = strlen(s1);
/**
* Allocate a new gnu temporal attribute.
*/
-static gnu_attribute_t *allocate_gnu_attribute(gnu_attribute_kind_t kind) {
+static gnu_attribute_t *allocate_gnu_attribute(gnu_attribute_kind_t kind)
+{
gnu_attribute_t *attribute = obstack_alloc(&temp_obst, sizeof(*attribute));
attribute->kind = kind;
attribute->next = NULL;
/**
* parse one constant expression argument.
*/
-static void parse_gnu_attribute_const_arg(gnu_attribute_t *attribute) {
+static void parse_gnu_attribute_const_arg(gnu_attribute_t *attribute)
+{
expression_t *expression;
add_anchor_token(')');
expression = parse_constant_expression();
rem_anchor_token(')');
expect(')');
- (void)expression;
+ attribute->u.argument = fold_constant(expression);
return;
end_error:
attribute->invalid = true;
/**
* parse a list of constant expressions arguments.
*/
-static void parse_gnu_attribute_const_arg_list(gnu_attribute_t *attribute) {
- expression_t *expression;
+static void parse_gnu_attribute_const_arg_list(gnu_attribute_t *attribute)
+{
+ argument_list_t **list = &attribute->u.arguments;
+ argument_list_t *entry;
+ expression_t *expression;
add_anchor_token(')');
add_anchor_token(',');
- while(true){
+ while (true) {
expression = parse_constant_expression();
+ entry = obstack_alloc(&temp_obst, sizeof(entry));
+ entry->argument = fold_constant(expression);
+ entry->next = NULL;
+ *list = entry;
+ list = &entry->next;
if (token.type != ',')
break;
next_token();
rem_anchor_token(',');
rem_anchor_token(')');
expect(')');
- (void)expression;
return;
end_error:
attribute->invalid = true;
/**
* parse one tls model.
*/
-static void parse_gnu_attribute_tls_model_arg(gnu_attribute_t *attribute) {
- static const char *tls_models[] = {
+static void parse_gnu_attribute_tls_model_arg(gnu_attribute_t *attribute)
+{
+ static const char *const tls_models[] = {
"global-dynamic",
"local-dynamic",
"initial-exec",
/**
* parse one tls model.
*/
-static void parse_gnu_attribute_visibility_arg(gnu_attribute_t *attribute) {
- static const char *visibilities[] = {
+static void parse_gnu_attribute_visibility_arg(gnu_attribute_t *attribute)
+{
+ static const char *const visibilities[] = {
"default",
"protected",
"hidden",
/**
* parse one (code) model.
*/
-static void parse_gnu_attribute_model_arg(gnu_attribute_t *attribute) {
- static const char *visibilities[] = {
+static void parse_gnu_attribute_model_arg(gnu_attribute_t *attribute)
+{
+ static const char *const visibilities[] = {
"small",
"medium",
"large"
/* This isn't really correct, the backend should provide a list of machine
* specific modes (according to gcc philosophy that is...) */
const char *symbol_str = token.v.symbol->string;
- if(strcmp_underscore("QI", symbol_str) == 0) {
+ if (strcmp_underscore("QI", symbol_str) == 0 ||
+ strcmp_underscore("byte", symbol_str) == 0) {
attribute->u.akind = ATOMIC_TYPE_CHAR;
} else if (strcmp_underscore("HI", symbol_str) == 0) {
attribute->u.akind = ATOMIC_TYPE_SHORT;
- } else if(strcmp_underscore("SI", symbol_str) == 0) {
+ } else if (strcmp_underscore("SI", symbol_str) == 0
+ || strcmp_underscore("word", symbol_str) == 0
+ || strcmp_underscore("pointer", symbol_str) == 0) {
attribute->u.akind = ATOMIC_TYPE_INT;
- } else if(strcmp_underscore("DI", symbol_str) == 0) {
+ } 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();
/**
* parse one interrupt argument.
*/
-static void parse_gnu_attribute_interrupt_arg(gnu_attribute_t *attribute) {
- static const char *interrupts[] = {
+static void parse_gnu_attribute_interrupt_arg(gnu_attribute_t *attribute)
+{
+ static const char *const interrupts[] = {
"IRQ",
"FIQ",
"SWI",
/**
* parse ( identifier, const expression, const expression )
*/
-static void parse_gnu_attribute_format_args(gnu_attribute_t *attribute) {
- static const char *format_names[] = {
+static void parse_gnu_attribute_format_args(gnu_attribute_t *attribute)
+{
+ static const char *const format_names[] = {
"printf",
"scanf",
"strftime",
add_anchor_token(',');
parse_constant_expression();
rem_anchor_token(',');
- rem_anchor_token('(');
+ rem_anchor_token(')');
expect(',');
add_anchor_token(')');
parse_constant_expression();
- rem_anchor_token('(');
+ rem_anchor_token(')');
expect(')');
return;
end_error:
if (token.type != ')') {
/* find the end of the list */
if (last != NULL) {
- while(last->next != NULL)
+ while (last->next != NULL)
last = last->next;
}
/* non-empty attribute list */
- while(true) {
+ while (true) {
const char *name;
if (token.type == T_const) {
name = "const";
attribute->have_arguments = true;
}
- switch(kind) {
- case GNU_AK_CONST:
+ switch (kind) {
case GNU_AK_VOLATILE:
- case GNU_AK_CDECL:
- case GNU_AK_STDCALL:
- case GNU_AK_FASTCALL:
- case GNU_AK_DEPRECATED:
case GNU_AK_NAKED:
case GNU_AK_MALLOC:
case GNU_AK_WEAK:
case GNU_AK_NOCOMMON:
case GNU_AK_SHARED:
case GNU_AK_NOTSHARED:
- case GNU_AK_USED:
- case GNU_AK_UNUSED:
case GNU_AK_NO_INSTRUMENT_FUNCTION:
case GNU_AK_WARN_UNUSED_RESULT:
case GNU_AK_LONGCALL:
case GNU_AK_MAY_ALIAS:
case GNU_AK_MS_STRUCT:
case GNU_AK_GCC_STRUCT:
- check_no_argument(attribute, name);
- break;
-
- case GNU_AK_PURE:
- check_no_argument(attribute, name);
- modifiers |= DM_PURE;
- break;
-
- case GNU_AK_ALWAYS_INLINE:
- check_no_argument(attribute, name);
- modifiers |= DM_FORCEINLINE;
- break;
-
- case GNU_AK_DLLIMPORT:
- check_no_argument(attribute, name);
- modifiers |= DM_DLLIMPORT;
- break;
-
- case GNU_AK_DLLEXPORT:
- check_no_argument(attribute, name);
- modifiers |= DM_DLLEXPORT;
- break;
-
- case GNU_AK_PACKED:
- check_no_argument(attribute, name);
- modifiers |= DM_PACKED;
- break;
-
- case GNU_AK_NOINLINE:
- check_no_argument(attribute, name);
- modifiers |= DM_NOINLINE;
- break;
-
- case GNU_AK_NORETURN:
- check_no_argument(attribute, name);
- modifiers |= DM_NORETURN;
- break;
-
- case GNU_AK_NOTHROW:
- check_no_argument(attribute, name);
- modifiers |= DM_NOTHROW;
- break;
-
- case GNU_AK_TRANSPARENT_UNION:
- check_no_argument(attribute, name);
- modifiers |= DM_TRANSPARENT_UNION;
- break;
-
- case GNU_AK_CONSTRUCTOR:
- check_no_argument(attribute, name);
- modifiers |= DM_CONSTRUCTOR;
- break;
-
- case GNU_AK_DESTRUCTOR:
- check_no_argument(attribute, name);
- modifiers |= DM_DESTRUCTOR;
- break;
+ goto no_arg;
+
+ case GNU_AK_CDECL: modifiers |= DM_CDECL; goto no_arg;
+ case GNU_AK_FASTCALL: modifiers |= DM_FASTCALL; goto no_arg;
+ case GNU_AK_STDCALL: modifiers |= DM_STDCALL; goto no_arg;
+ 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;
+ case GNU_AK_PACKED: modifiers |= DM_PACKED; goto no_arg;
+ case GNU_AK_NOINLINE: modifiers |= DM_NOINLINE; goto no_arg;
+ case GNU_AK_NORETURN: modifiers |= DM_NORETURN; goto no_arg;
+ case GNU_AK_NOTHROW: modifiers |= DM_NOTHROW; goto no_arg;
+ case GNU_AK_TRANSPARENT_UNION: modifiers |= DM_TRANSPARENT_UNION; goto no_arg;
+ case GNU_AK_CONSTRUCTOR: modifiers |= DM_CONSTRUCTOR; goto no_arg;
+ case GNU_AK_DESTRUCTOR: modifiers |= DM_DESTRUCTOR; goto no_arg;
+ case GNU_AK_DEPRECATED: modifiers |= DM_DEPRECATED; goto no_arg;
case GNU_AK_ALIGNED:
/* __align__ may be used without an argument */
case GNU_AK_LAST:
/* already handled */
break;
+
+no_arg:
+ check_no_argument(attribute, name);
}
}
if (attribute != NULL) {
{
decl_modifiers_t modifiers = 0;
- while(true) {
- switch(token.type) {
+ while (true) {
+ switch (token.type) {
case T___attribute__:
modifiers |= parse_gnu_attribute(attributes);
- break;
+ continue;
case T_asm:
next_token();
parse_string_literals();
}
expect(')');
- break;
+ continue;
+
+ case T_cdecl: modifiers |= DM_CDECL; break;
+ case T__fastcall: modifiers |= DM_FASTCALL; break;
+ case T__stdcall: modifiers |= DM_STDCALL; break;
- case T_cdecl:
- case T__fastcall:
- case T__stdcall:
case T___thiscall:
/* TODO record modifier */
- warningf(HERE, "Ignoring declaration modifier %K", &token);
- next_token();
+ if (warning.other)
+ warningf(HERE, "Ignoring declaration modifier %K", &token);
break;
- default:
- goto attributes_finished;
+end_error:
+ default: return modifiers;
}
- }
-attributes_finished:
-end_error:
- return modifiers;
+ next_token();
+ }
}
-static designator_t *parse_designation(void)
+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)
{
- designator_t *result = NULL;
- designator_t *last = NULL;
+ 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;
- while(true) {
- designator_t *designator;
- switch(token.type) {
- case '[':
- designator = allocate_ast_zero(sizeof(designator[0]));
- designator->source_position = token.source_position;
- next_token();
- add_anchor_token(']');
- designator->array_index = parse_constant_expression();
- rem_anchor_token(']');
- expect(']');
- break;
- case '.':
- designator = allocate_ast_zero(sizeof(designator[0]));
- designator->source_position = token.source_position;
- next_token();
- if (token.type != T_IDENTIFIER) {
- parse_error_expected("while parsing designator",
- T_IDENTIFIER, 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;
}
- designator->symbol = token.v.symbol;
- next_token();
- break;
- default:
- expect('=');
- return result;
}
- assert(designator != NULL);
- if (last != NULL) {
- last->next = designator;
- } else {
- result = designator;
+ 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;
+ }
}
- last = designator;
+
+ default:
+ mark_vars_read(expr, NULL);
+ return NULL;
}
-end_error:
- return NULL;
}
-static initializer_t *initializer_from_string(array_type_t *type,
- const string_t *const string)
-{
- /* TODO: check len vs. size of array type */
- (void) type;
+#define VAR_ANY ((variable_t*)-1)
- initializer_t *initializer = allocate_initializer_zero(INITIALIZER_STRING);
+/**
+ * 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;
+ designator_t *last = NULL;
+
+ while (true) {
+ designator_t *designator;
+ switch (token.type) {
+ case '[':
+ designator = allocate_ast_zero(sizeof(designator[0]));
+ designator->source_position = token.source_position;
+ next_token();
+ add_anchor_token(']');
+ designator->array_index = parse_constant_expression();
+ rem_anchor_token(']');
+ expect(']');
+ break;
+ case '.':
+ designator = allocate_ast_zero(sizeof(designator[0]));
+ designator->source_position = token.source_position;
+ next_token();
+ if (token.type != T_IDENTIFIER) {
+ parse_error_expected("while parsing designator",
+ T_IDENTIFIER, NULL);
+ return NULL;
+ }
+ designator->symbol = token.v.symbol;
+ next_token();
+ break;
+ default:
+ expect('=');
+ return result;
+ }
+
+ assert(designator != NULL);
+ if (last != NULL) {
+ last->next = designator;
+ } else {
+ result = designator;
+ }
+ last = designator;
+ }
+end_error:
+ return NULL;
+}
+
+static initializer_t *initializer_from_string(array_type_t *type,
+ const string_t *const string)
+{
+ /* TODO: check len vs. size of array type */
+ (void) type;
+
+ initializer_t *initializer = allocate_initializer_zero(INITIALIZER_STRING);
initializer->string.string = *string;
return initializer;
&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",
}
bool additional_warning_displayed = false;
- while(braces > 0) {
+ while (braces > 0) {
if (token.type == ',') {
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, "[%zd]", entry->v.index);
+ fprintf(stderr, "[%zu]", entry->v.index);
} else {
fprintf(stderr, "-INVALID-");
}
}
/**
- * 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)
{
type_t *orig_top_type = path->top_type;
type_t *top_type = skip_typeref(orig_top_type);
- assert(is_type_compound(top_type) || is_type_array(top_type));
-
type_path_entry_t *top = append_to_type_path(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 {
- assert(is_type_array(top_type));
-
+ } else if (is_type_array(top_type)) {
top->v.index = 0;
path->top_type = top_type->array.element_type;
+ } else {
+ assert(!is_type_valid(top_type));
}
}
{
size_t len = ARR_LEN(path->path);
- while(len > top_path_level) {
+ while (len > top_path_level) {
ascend_from_subtype(path);
len = ARR_LEN(path->path);
}
"'.%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
/**
* skip until token is found.
*/
-static void skip_until(int type) {
- while(token.type != type) {
+static void skip_until(int type)
+{
+ while (token.type != type) {
if (token.type == T_EOF)
return;
next_token();
if (token.type == '{')
next_token();
- while(token.type != '}') {
+ while (token.type != '}') {
if (token.type == T_EOF)
return;
if (token.type == '{') {
/* 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);
- while(true) {
+ while (true) {
designator_t *designator = NULL;
if (token.type == '.' || token.type == '[') {
designator = parse_designation();
+ goto finish_designator;
+ } else if (token.type == T_IDENTIFIER && look_ahead(1)->type == ':') {
+ /* GNU-style designator ("identifier: value") */
+ designator = allocate_ast_zero(sizeof(designator[0]));
+ designator->source_position = token.source_position;
+ designator->symbol = token.v.symbol;
+ eat(T_IDENTIFIER);
+ eat(':');
+finish_designator:
/* reset path to toplevel, evaluate designator from there */
ascend_to(path, top_path_level);
if (!walk_designator(path, designator, false)) {
} 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, ... */
+ 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);
}
}
/* descend into subtypes until expression matches type */
- while(true) {
+ while (true) {
orig_type = path->top_type;
type = skip_typeref(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:
result = parse_scalar_initializer(type, env->must_be_constant);
}
- /* § 6.7.5 (22) array initializers for arrays with unknown size determine
+ /* § 6.7.8 (22) array initializers for arrays with unknown size determine
* the array type size */
if (is_type_array(type) && type->array.size_expression == NULL
&& result != NULL) {
type_t *new_type = duplicate_type(type);
- new_type->array.size_expression = cnst;
- new_type->array.size_constant = true;
- new_type->array.size = size;
+ new_type->array.size_expression = cnst;
+ new_type->array.size_constant = true;
+ new_type->array.has_implicit_size = true;
+ new_type->array.size = size;
env->type = new_type;
}
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);
symbol = token.v.symbol;
next_token();
- if (is_struct) {
- declaration = get_declaration(symbol, NAMESPACE_STRUCT);
- } else {
- declaration = get_declaration(symbol, NAMESPACE_UNION);
+ namespace_tag_t const namespc =
+ is_struct ? NAMESPACE_STRUCT : NAMESPACE_UNION;
+ 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 != current_scope &&
+ (token.type == '{' || 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 %P)",
+ is_struct ? "struct" : "union", symbol,
+ &compound->base.source_position);
+ /* clear members in the hope to avoid further errors */
+ compound->members.entities = NULL;
+ }
}
} else if (token.type != '{') {
if (is_struct) {
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 = current_scope;
if (symbol != NULL) {
- environment_push(declaration);
+ environment_push(entity);
}
- append_declaration(declaration);
+ append_entity(current_scope, entity);
}
if (token.type == '{') {
- if (declaration->init.complete) {
- assert(symbol != NULL);
- errorf(HERE, "multiple definitions of '%s %Y' (previous definition at %P)",
- is_struct ? "struct" : "union", symbol,
- &declaration->source_position);
- declaration->scope.declarations = NULL;
- }
- 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);
+ record_entity(entity, false);
if (token.type != ',')
break;
next_token();
- } while(token.type != '}');
+ } while (token.type != '}');
rem_anchor_token('}');
expect('}');
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 = current_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(current_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)
expression_t *expression = NULL;
-restart:
- switch(token.type) {
- case T___extension__:
- /* this can be a prefix to a typename or an expression */
- /* we simply eat it now. */
- do {
- next_token();
- } while(token.type == T___extension__);
- goto restart;
+ bool old_type_prop = in_type_prop;
+ bool old_gcc_extension = in_gcc_extension;
+ in_type_prop = true;
+ while (token.type == T___extension__) {
+ /* This can be a prefix to a typename or an expression. */
+ next_token();
+ in_gcc_extension = true;
+ }
+ switch (token.type) {
case T_IDENTIFIER:
if (is_typedef_symbol(token.v.symbol)) {
type = parse_typename();
type = expression->base.type;
break;
}
+ in_type_prop = old_type_prop;
+ in_gcc_extension = old_gcc_extension;
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;
return NULL;
}
-typedef enum {
+typedef enum specifiers_t {
SPECIFIER_SIGNED = 1 << 0,
SPECIFIER_UNSIGNED = 1 << 1,
SPECIFIER_LONG = 1 << 2,
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;
}
/**
* check for the allowed MS alignment values.
*/
-static bool check_elignment_value(long long intvalue) {
+static bool check_alignment_value(long long intvalue)
+{
if (intvalue < 1 || intvalue > 8192) {
errorf(HERE, "illegal alignment value");
return false;
}
unsigned v = (unsigned)intvalue;
- for(unsigned i = 1; i <= 8192; i += i) {
+ for (unsigned i = 1; i <= 8192; i += i) {
if (i == v)
return true;
}
}
#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)
+} while (0)
static void parse_microsoft_extended_decl_modifier(declaration_specifiers_t *specifiers)
{
decl_modifiers_t *modifiers = &specifiers->modifiers;
- while(true) {
+ while (true) {
if (token.type == T_restrict) {
next_token();
DET_MOD(restrict, DM_RESTRICT);
expect('(');
if (token.type != T_INTEGER)
goto end_error;
- if (check_elignment_value(token.v.intvalue)) {
- if (specifiers->alignment != 0)
+ if (check_alignment_value(token.v.intvalue)) {
+ if (specifiers->alignment != 0 && warning.other)
warningf(HERE, "align used more than once");
specifiers->alignment = (unsigned char)token.v.intvalue;
}
} else if (symbol == sym_property) {
next_token();
expect('(');
- for(;;) {
+ for (;;) {
bool is_get = false;
if (token.type != T_IDENTIFIER)
goto end_error;
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 entity_t *create_error_entity(symbol_t *symbol, entity_kind_tag_t kind)
+{
+ entity_t *entity = allocate_entity_zero(kind);
+ entity->base.source_position = *HERE;
+ entity->base.symbol = symbol;
+ if (is_declaration(entity)) {
+ entity->declaration.type = type_error_type;
+ entity->declaration.implicit = true;
+ } else if (kind == ENTITY_TYPEDEF) {
+ entity->typedefe.type = type_error_type;
+ }
+ 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)
+{
+ assert(type->compound != NULL);
+
+ compound_t *compound = type->compound;
+ if (!compound->complete)
+ return;
+
+ il_size_t size = 0;
+ il_size_t offset;
+ il_alignment_t alignment = 1;
+ bool need_pad = false;
+
+ 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->declaration.type);
+ if (! is_type_valid(m_type)) {
+ /* simply ignore errors here */
+ continue;
+ }
+ il_alignment_t m_alignment = m_type->base.alignment;
+ if (m_alignment > alignment)
+ alignment = m_alignment;
+
+ offset = (size + m_alignment - 1) & -m_alignment;
+
+ if (offset > size)
+ need_pad = true;
+ entry->compound_member.offset = offset;
+ size = offset + m_type->base.size;
+ }
+ if (type->base.alignment != 0) {
+ alignment = type->base.alignment;
+ }
+
+ offset = (size + alignment - 1) & -alignment;
+ if (offset > size)
+ need_pad = true;
+
+ if (warning.padded && need_pad) {
+ warningf(&compound->base.source_position,
+ "'%#T' needs padding", type, compound->base.symbol);
+ }
+ if (warning.packed && !need_pad) {
+ warningf(&compound->base.source_position,
+ "superfluous packed attribute on '%#T'",
+ type, compound->base.symbol);
+ }
+
+ type->base.size = offset;
+ type->base.alignment = alignment;
+}
+
+/**
+ * Finish the construction of an union type by calculating
+ * its size and alignment.
+ */
+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;
+
+ 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->declaration.type);
+ if (! is_type_valid(m_type))
+ continue;
+
+ entry->compound_member.offset = 0;
+ if (m_type->base.size > size)
+ size = m_type->base.size;
+ if (m_type->base.alignment > alignment)
+ alignment = m_type->base.alignment;
+ }
+ if (type->base.alignment != 0) {
+ alignment = type->base.alignment;
+ }
+ size = (size + alignment - 1) & -alignment;
+ type->base.size = size;
+ type->base.alignment = alignment;
+}
+
static void parse_declaration_specifiers(declaration_specifiers_t *specifiers)
{
- type_t *type = NULL;
- type_qualifiers_t qualifiers = TYPE_QUALIFIER_NONE;
- type_modifiers_t modifiers = TYPE_MODIFIER_NONE;
- unsigned type_specifiers = 0;
- int newtype = 0;
+ type_t *type = NULL;
+ type_qualifiers_t qualifiers = TYPE_QUALIFIER_NONE;
+ type_modifiers_t modifiers = TYPE_MODIFIER_NONE;
+ unsigned type_specifiers = 0;
+ bool newtype = false;
+ bool saw_error = false;
+ bool old_gcc_extension = in_gcc_extension;
specifiers->source_position = token.source_position;
- while(true) {
- switch(token.type) {
+ while (true) {
+ specifiers->modifiers
+ |= parse_attributes(&specifiers->gnu_attributes);
+ if (specifiers->modifiers & DM_TRANSPARENT_UNION)
+ modifiers |= TYPE_MODIFIER_TRANSPARENT_UNION;
+
+ switch (token.type) {
/* 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:
case token: \
qualifiers |= qualifier; \
next_token(); \
- break;
+ break
MATCH_TYPE_QUALIFIER(T_const, TYPE_QUALIFIER_CONST);
MATCH_TYPE_QUALIFIER(T_restrict, TYPE_QUALIFIER_RESTRICT);
MATCH_TYPE_QUALIFIER(T___sptr, TYPE_QUALIFIER_SPTR);
case T___extension__:
- /* TODO */
next_token();
+ in_gcc_extension = true;
break;
/* type specifiers */
#define MATCH_SPECIFIER(token, specifier, name) \
case token: \
- next_token(); \
if (type_specifiers & specifier) { \
errorf(HERE, "multiple " name " type specifiers given"); \
} else { \
type_specifiers |= specifier; \
} \
- break;
-
- MATCH_SPECIFIER(T_void, SPECIFIER_VOID, "void")
- MATCH_SPECIFIER(T_char, SPECIFIER_CHAR, "char")
- MATCH_SPECIFIER(T_short, SPECIFIER_SHORT, "short")
- MATCH_SPECIFIER(T_int, SPECIFIER_INT, "int")
- MATCH_SPECIFIER(T_float, SPECIFIER_FLOAT, "float")
- MATCH_SPECIFIER(T_double, SPECIFIER_DOUBLE, "double")
- MATCH_SPECIFIER(T_signed, SPECIFIER_SIGNED, "signed")
- MATCH_SPECIFIER(T_unsigned, SPECIFIER_UNSIGNED, "unsigned")
- MATCH_SPECIFIER(T__Bool, SPECIFIER_BOOL, "_Bool")
- MATCH_SPECIFIER(T__int8, SPECIFIER_INT8, "_int8")
- MATCH_SPECIFIER(T__int16, SPECIFIER_INT16, "_int16")
- MATCH_SPECIFIER(T__int32, SPECIFIER_INT32, "_int32")
- MATCH_SPECIFIER(T__int64, SPECIFIER_INT64, "_int64")
- MATCH_SPECIFIER(T__int128, SPECIFIER_INT128, "_int128")
- MATCH_SPECIFIER(T__Complex, SPECIFIER_COMPLEX, "_Complex")
- MATCH_SPECIFIER(T__Imaginary, SPECIFIER_IMAGINARY, "_Imaginary")
+ next_token(); \
+ break
+
+ MATCH_SPECIFIER(T__Bool, SPECIFIER_BOOL, "_Bool");
+ MATCH_SPECIFIER(T__Complex, SPECIFIER_COMPLEX, "_Complex");
+ MATCH_SPECIFIER(T__Imaginary, SPECIFIER_IMAGINARY, "_Imaginary");
+ MATCH_SPECIFIER(T__int128, SPECIFIER_INT128, "_int128");
+ MATCH_SPECIFIER(T__int16, SPECIFIER_INT16, "_int16");
+ MATCH_SPECIFIER(T__int32, SPECIFIER_INT32, "_int32");
+ MATCH_SPECIFIER(T__int64, SPECIFIER_INT64, "_int64");
+ MATCH_SPECIFIER(T__int8, SPECIFIER_INT8, "_int8");
+ MATCH_SPECIFIER(T_bool, SPECIFIER_BOOL, "bool");
+ MATCH_SPECIFIER(T_char, SPECIFIER_CHAR, "char");
+ MATCH_SPECIFIER(T_double, SPECIFIER_DOUBLE, "double");
+ MATCH_SPECIFIER(T_float, SPECIFIER_FLOAT, "float");
+ MATCH_SPECIFIER(T_int, SPECIFIER_INT, "int");
+ MATCH_SPECIFIER(T_short, SPECIFIER_SHORT, "short");
+ MATCH_SPECIFIER(T_signed, SPECIFIER_SIGNED, "signed");
+ MATCH_SPECIFIER(T_unsigned, SPECIFIER_UNSIGNED, "unsigned");
+ MATCH_SPECIFIER(T_void, SPECIFIER_VOID, "void");
case T__forceinline:
/* only in microsoft mode */
specifiers->modifiers |= DM_FORCEINLINE;
+ /* FALLTHROUGH */
case T_inline:
next_token();
break;
case T_long:
- next_token();
if (type_specifiers & SPECIFIER_LONG_LONG) {
errorf(HERE, "multiple type specifiers given");
} else if (type_specifiers & SPECIFIER_LONG) {
} else {
type_specifiers |= SPECIFIER_LONG;
}
+ next_token();
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 T_enum:
next_token();
break;
- case T___attribute__:
- specifiers->modifiers
- |= parse_attributes(&specifiers->gnu_attributes);
- if (specifiers->modifiers & DM_TRANSPARENT_UNION)
- modifiers |= TYPE_MODIFIER_TRANSPARENT_UNION;
- break;
-
case T_IDENTIFIER: {
/* only parse identifier if we haven't found a type yet */
- if (type != NULL || type_specifiers != 0)
- goto finish_specifiers;
+ if (type != NULL || type_specifiers != 0) {
+ /* Be somewhat resilient to typos like 'unsigned lng* f()' in a
+ * declaration, so it doesn't generate errors about expecting '(' or
+ * '{' later on. */
+ switch (look_ahead(1)->type) {
+ STORAGE_CLASSES
+ TYPE_SPECIFIERS
+ case T_const:
+ case T_restrict:
+ case T_volatile:
+ case T_inline:
+ case T__forceinline: /* ^ DECLARATION_START except for __attribute__ */
+ case T_IDENTIFIER:
+ case '*':
+ errorf(HERE, "discarding stray %K in declaration specifier", &token);
+ next_token();
+ continue;
+
+ default:
+ goto finish_specifiers;
+ }
+ }
+
+ type_t *const typedef_type = get_typedef_type(token.v.symbol);
+ if (typedef_type == NULL) {
+ /* Be somewhat resilient to typos like 'vodi f()' at the beginning of a
+ * declaration, so it doesn't generate 'implicit int' followed by more
+ * errors later on. */
+ token_type_t const la1_type = (token_type_t)look_ahead(1)->type;
+ switch (la1_type) {
+ DECLARATION_START
+ case T_IDENTIFIER:
+ case '*': {
+ errorf(HERE, "%K does not name a type", &token);
- type_t *typedef_type = get_typedef_type(token.v.symbol);
+ entity_t *entity =
+ create_error_entity(token.v.symbol, ENTITY_TYPEDEF);
- if (typedef_type == NULL)
- goto finish_specifiers;
+ type = allocate_type_zero(TYPE_TYPEDEF);
+ type->typedeft.typedefe = &entity->typedefe;
+
+ next_token();
+ saw_error = true;
+ if (la1_type == '*')
+ goto finish_specifiers;
+ continue;
+ }
+
+ default:
+ goto finish_specifiers;
+ }
+ }
next_token();
type = typedef_type;
}
finish_specifiers:
+ in_gcc_extension = old_gcc_extension;
- if (type == NULL) {
+ if (type == NULL || (saw_error && type_specifiers != 0)) {
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;
case SPECIFIER_UNSIGNED | SPECIFIER_LONG | SPECIFIER_INT:
atomic_type = ATOMIC_TYPE_ULONG;
break;
+
case SPECIFIER_LONG | SPECIFIER_LONG_LONG:
case SPECIFIER_SIGNED | SPECIFIER_LONG | SPECIFIER_LONG_LONG:
case SPECIFIER_LONG | SPECIFIER_LONG_LONG | SPECIFIER_INT:
case SPECIFIER_SIGNED | SPECIFIER_LONG | SPECIFIER_LONG_LONG
| SPECIFIER_INT:
atomic_type = ATOMIC_TYPE_LONGLONG;
- break;
+ goto warn_about_long_long;
+
case SPECIFIER_UNSIGNED | SPECIFIER_LONG | SPECIFIER_LONG_LONG:
case SPECIFIER_UNSIGNED | SPECIFIER_LONG | SPECIFIER_LONG_LONG
| SPECIFIER_INT:
atomic_type = ATOMIC_TYPE_ULONGLONG;
+warn_about_long_long:
+ if (warning.long_long) {
+ warningf(&specifiers->source_position,
+ "ISO C90 does not support 'long long'");
+ }
break;
case SPECIFIER_UNSIGNED | SPECIFIER_INT8:
default:
/* invalid specifier combination, give an error message */
if (type_specifiers == 0) {
- if (! strict_mode) {
+ if (saw_error)
+ goto end_error;
+
+ /* 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'");
}
}
} else if ((type_specifiers & SPECIFIER_SIGNED) &&
(type_specifiers & SPECIFIER_UNSIGNED)) {
- errorf(HERE, "signed and unsigned specifiers gives");
+ errorf(HERE, "signed and unsigned specifiers given");
} else if (type_specifiers & (SPECIFIER_SIGNED | SPECIFIER_UNSIGNED)) {
errorf(HERE, "only integer types can be signed or unsigned");
} else {
errorf(HERE, "multiple datatypes in declaration");
}
- atomic_type = ATOMIC_TYPE_INVALID;
+ goto end_error;
}
- if (type_specifiers & SPECIFIER_COMPLEX &&
- atomic_type != ATOMIC_TYPE_INVALID) {
- type = allocate_type_zero(TYPE_COMPLEX, &builtin_source_position);
+ if (type_specifiers & SPECIFIER_COMPLEX) {
+ type = allocate_type_zero(TYPE_COMPLEX);
type->complex.akind = atomic_type;
- } else if (type_specifiers & SPECIFIER_IMAGINARY &&
- atomic_type != ATOMIC_TYPE_INVALID) {
- type = allocate_type_zero(TYPE_IMAGINARY, &builtin_source_position);
+ } else if (type_specifiers & SPECIFIER_IMAGINARY) {
+ 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 = 1;
- } else {
- if (type_specifiers != 0) {
- errorf(HERE, "multiple datatypes in declaration");
- }
+ newtype = true;
+ } else if (type_specifiers != 0) {
+ errorf(HERE, "multiple datatypes in declaration");
}
/* FIXME: check type qualifiers here */
}
specifiers->type = result;
+ return;
+
end_error:
+ specifiers->type = type_error_type;
return;
}
{
type_qualifiers_t qualifiers = TYPE_QUALIFIER_NONE;
- while(true) {
- switch(token.type) {
+ while (true) {
+ switch (token.type) {
/* type qualifiers */
MATCH_TYPE_QUALIFIER(T_const, TYPE_QUALIFIER_CONST);
MATCH_TYPE_QUALIFIER(T_restrict, TYPE_QUALIFIER_RESTRICT);
}
}
-static declaration_t *parse_identifier_list(void)
+/**
+ * Parses an K&R identifier list
+ */
+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);
-
- return declarations;
+ } while (token.type == T_IDENTIFIER);
}
+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->base.source_position;
- if (declaration->declared_storage_class == STORAGE_CLASS_TYPEDEF) {
- errorf(HERE, "typedef not allowed in parameter list");
- } else if (declaration->declared_storage_class != STORAGE_CLASS_NONE
- && declaration->declared_storage_class != STORAGE_CLASS_REGISTER) {
- errorf(HERE, "parameter may only have none or register storage class");
+ /* §6.9.1:6 */
+ switch (declaration->declared_storage_class) {
+ /* Allowed storage classes */
+ case STORAGE_CLASS_NONE:
+ case STORAGE_CLASS_REGISTER:
+ break;
+
+ default:
+ errorf(pos, "parameter may only have none or register storage class");
+ break;
}
type_t *const orig_type = declaration->type;
- type_t * type = skip_typeref(orig_type);
-
- /* Array as last part of a parameter type is just syntactic sugar. Turn it
- * into a pointer. § 6.7.5.3 (7) */
- if (is_type_array(type)) {
- type_t *const element_type = type->array.element_type;
-
- type = make_pointer_type(element_type, type->base.qualifiers);
+ /* §6.7.5.3(7): Array as last part of a parameter type is just syntactic
+ * sugar. Turn it into a pointer.
+ * §6.7.5.3(8): A declaration of a parameter as ``function returning type''
+ * shall be adjusted to ``pointer to function returning type'', as in 6.3.2.1.
+ */
+ type_t *const type = automatic_type_conversion(orig_type);
+ declaration->type = type;
- declaration->type = type;
- }
-
- if (is_type_incomplete(type)) {
- errorf(HERE, "incomplete type '%T' not allowed for parameter '%Y'",
- orig_type, declaration->symbol);
+ if (is_type_incomplete(skip_typeref(type))) {
+ errorf(pos, "parameter '%#T' is of incomplete type",
+ 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;
}
-static declaration_t *parse_parameters(function_type_t *type)
+/**
+ * Parses function type parameters (and optionally creates variable_t entities
+ * for them in a scope)
+ */
+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(',');
- if (token.type == T_IDENTIFIER) {
- symbol_t *symbol = token.v.symbol;
- if (!is_typedef_symbol(symbol)) {
+ if (token.type == T_IDENTIFIER &&
+ !is_typedef_symbol(token.v.symbol)) {
+ 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();
+ 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) {
+ while (true) {
+ 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);
- return declarations;
-
end_error:
restore_anchor_state(',', saved_comma_state);
- return NULL;
}
-typedef enum {
+typedef enum construct_type_kind_t {
CONSTRUCT_INVALID,
CONSTRUCT_POINTER,
CONSTRUCT_FUNCTION,
rem_anchor_token(']');
expect(']');
- return (construct_type_t*) array;
end_error:
- return NULL;
+ 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,
+ decl_modifiers_t modifiers)
{
- type_t *type;
- if (declaration != NULL) {
- type = allocate_type_zero(TYPE_FUNCTION, &declaration->source_position);
- } else {
- type = allocate_type_zero(TYPE_FUNCTION, HERE);
- }
+ type_t *type = allocate_type_zero(TYPE_FUNCTION);
+ function_type_t *ftype = &type->function;
- declaration_t *parameters = parse_parameters(&type->function);
- if (declaration != NULL) {
- declaration->scope.declarations = parameters;
+ ftype->linkage = current_linkage;
+
+ switch (modifiers & (DM_CDECL | DM_STDCALL | DM_FASTCALL | DM_THISCALL)) {
+ case DM_NONE: break;
+ case DM_CDECL: ftype->calling_convention = CC_CDECL; break;
+ case DM_STDCALL: ftype->calling_convention = CC_STDCALL; break;
+ case DM_FASTCALL: ftype->calling_convention = CC_FASTCALL; break;
+ case DM_THISCALL: ftype->calling_convention = CC_THISCALL; break;
+
+ default:
+ errorf(HERE, "multiple calling conventions in declaration");
+ break;
}
+ parse_parameters(ftype, scope);
+
construct_function_type_t *construct_function_type =
obstack_alloc(&temp_obst, sizeof(construct_function_type[0]));
memset(construct_function_type, 0, sizeof(construct_function_type[0]));
construct_function_type->construct_type.kind = CONSTRUCT_FUNCTION;
construct_function_type->function_type = type;
- return (construct_type_t*) construct_function_type;
+ 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);
/* pointers */
- while(token.type == '*') {
+ while (token.type == '*') {
construct_type_t *type = parse_pointer_declarator();
if (last == NULL) {
modifiers |= parse_attributes(&attributes);
}
+ if (env != NULL) {
+ modifiers |= env->modifiers;
+ 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 */
+ env = NULL;
+ }
rem_anchor_token(')');
expect(')');
break;
if (may_be_abstract)
break;
parse_error_expected("while parsing declarator", T_IDENTIFIER, '(', NULL);
- /* avoid a loop in the outermost scope, because eat_statement doesn't
- * eat '}' */
- if (token.type == '}' && current_function == NULL) {
- next_token();
- } else {
- eat_statement();
- }
+ eat_until_anchor();
return NULL;
}
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, modifiers);
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: {
function_type->function.return_type = type;
type_t *skipped_return_type = skip_typeref(type);
+ /* §6.7.5.3(1) */
if (is_type_function(skipped_return_type)) {
errorf(HERE, "function returning function is not allowed");
- type = type_error_type;
} else if (is_type_array(skipped_return_type)) {
errorf(HERE, "function returning array is not allowed");
- type = type_error_type;
} else {
- type = function_type;
+ if (skipped_return_type->base.qualifiers != 0 && warning.other) {
+ warningf(HERE,
+ "type qualifiers in return type of function type are meaningless");
+ }
}
+
+ type = function_type;
break;
}
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) {
}
type_t *skipped_type = skip_typeref(type);
- if (is_type_atomic(skipped_type, ATOMIC_TYPE_VOID)) {
- errorf(HERE, "array of void is not allowed");
- type = type_error_type;
- } else {
- type = array_type;
+ /* §6.7.5.2(1) */
+ if (is_type_incomplete(skipped_type)) {
+ errorf(HERE, "array of incomplete type '%T' is not allowed", type);
+ } else if (is_type_function(skipped_type)) {
+ errorf(HERE, "array of functions is not allowed");
}
+ type = array_type;
break;
}
}
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->declared_storage_class = specifiers->declared_storage_class;
- declaration->modifiers = specifiers->modifiers;
- declaration->deprecated = specifiers->deprecated;
- 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));
+ env.modifiers = specifiers->modifiers;
- declaration->storage_class = specifiers->declared_storage_class;
- if (declaration->storage_class == STORAGE_CLASS_NONE
- && scope != global_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;
+ 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
+ && current_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");
}
- if (skip_typeref(func_type->return_type) != type_int) {
- warningf(&decl->source_position,
- "return type of 'main' should be 'int', but is '%T'",
+
+ 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(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) {
- warningf(&decl->source_position, "'main' takes only zero, two or three arguments");
- }
+ if (parm != NULL)
+ goto warn_arg_count;
}
} else {
- warningf(&decl->source_position, "'main' takes only zero, two or three arguments");
+warn_arg_count:
+ warningf(pos, "'main' takes only zero, two or three arguments");
}
}
}
return strcmp(sym->string, "main") == 0;
}
-static declaration_t *internal_record_declaration(
- declaration_t *const declaration,
- const bool is_function_definition)
+static const char *get_entity_kind_name(entity_kind_t kind)
{
- const symbol_t *const symbol = declaration->symbol;
- const namespace_t namespc = (namespace_t)declaration->namespc;
+ switch ((entity_kind_tag_t) kind) {
+ case ENTITY_FUNCTION: return "function";
+ case ENTITY_VARIABLE: return "variable";
+ case ENTITY_COMPOUND_MEMBER: return "compound type member";
+ case ENTITY_STRUCT: return "struct";
+ case ENTITY_UNION: return "union";
+ case ENTITY_ENUM: return "enum";
+ case ENTITY_ENUM_VALUE: return "enum value";
+ case ENTITY_LABEL: return "label";
+ case ENTITY_LOCAL_LABEL: return "local label";
+ case ENTITY_TYPEDEF: return "typedef";
+ case ENTITY_NAMESPACE: return "namespace";
+ case ENTITY_INVALID: break;
+ }
- assert(declaration->symbol != NULL);
- declaration_t *previous_declaration = get_declaration(symbol, namespc);
+ panic("Invalid entity kind encountered in get_entity_kind_name");
+}
- 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, declaration->symbol);
+static void error_redefined_as_different_kind(const source_position_t *pos,
+ const entity_t *old, entity_kind_t new_kind)
+{
+ errorf(pos, "redeclaration of %s '%Y' as %s (declared %P)",
+ get_entity_kind_name(old->kind), old->base.symbol,
+ get_entity_kind_name(new_kind), &old->base.source_position);
+}
+
+/**
+ * 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 = entity->base.symbol;
+ const namespace_tag_t namespc = (namespace_tag_t)entity->base.namespc;
+ const source_position_t *pos = &entity->base.source_position;
+
+ assert(symbol != NULL);
+ entity_t *previous_entity = get_entity(symbol, namespc);
+ /* pushing the same entity twice will break the stack structure */
+ assert(previous_entity != entity);
+
+ 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 && current_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
+ && current_scope != file_scope) {
+ warningf(pos, "nested extern declaration of '%#T'",
+ entity->declaration.type, symbol);
+ }
}
- if (is_function_definition && warning.main && is_sym_main(symbol)) {
- check_type_of_main(declaration, &type->function);
+ if (previous_entity != NULL
+ && previous_entity->base.parent_scope == ¤t_function->parameters
+ && current_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;
}
- assert(declaration != previous_declaration);
- 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 == current_scope) {
+
+ if (previous_entity->kind != entity->kind) {
+ error_redefined_as_different_kind(pos, previous_entity,
+ entity->kind);
+ 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_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;
/* FALLTHROUGH */
case STORAGE_CLASS_EXTERN:
- if (is_function_definition) {
+ if (is_definition) {
if (warning.missing_prototypes &&
- prev_type->function.unspecified_parameters &&
- !is_sym_main(symbol)) {
- warningf(&declaration->source_position,
- "no previous prototype for '%#T'",
+ prev_type->function.unspecified_parameters &&
+ !is_sym_main(symbol)) {
+ warningf(pos, "no previous prototype for '%#T'",
orig_type, symbol);
}
} else if (new_storage_class == STORAGE_CLASS_NONE) {
if (old_storage_class == STORAGE_CLASS_EXTERN &&
new_storage_class == STORAGE_CLASS_EXTERN) {
warn_redundant_declaration:
- if (warning.redundant_decls && strcmp(previous_declaration->source_position.input_name, "<builtin>") != 0) {
- warningf(&declaration->source_position,
- "redundant declaration for '%Y' (declared %P)",
- symbol, &previous_declaration->source_position);
+ if (!is_definition &&
+ warning.redundant_decls &&
+ is_type_valid(prev_type) &&
+ strcmp(previous_entity->base.source_position.input_name, "<builtin>") != 0) {
+ warningf(pos,
+ "redundant declaration for '%Y' (declared %P)",
+ 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,
- "static declaration of '%Y' follows non-static declaration (declared %P)",
- symbol, &previous_declaration->source_position);
- } else if (old_storage_class != STORAGE_CLASS_EXTERN
- && !is_function_definition) {
- goto warn_redundant_declaration;
+ new_storage_class == STORAGE_CLASS_STATIC) {
+ errorf(pos,
+ "static declaration of '%Y' follows non-static declaration (declared %P)",
+ 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) {
+error_redeclaration:
+ errorf(pos, "redeclaration of '%Y' (declared %P)",
+ symbol, &previous_entity->base.source_position);
+ } else {
+ errorf(pos,
+ "redeclaration of '%Y' with different linkage (declared %P)",
+ symbol, &previous_entity->base.source_position);
}
- } else if (old_storage_class == new_storage_class) {
- errorf(&declaration->source_position,
- "redeclaration of '%Y' (declared %P)",
- symbol, &previous_declaration->source_position);
- } else {
- errorf(&declaration->source_position,
- "redeclaration of '%Y' with different linkage (declared %P)",
- symbol, &previous_declaration->source_position);
}
}
- if (declaration->is_inline)
- previous_declaration->is_inline = true;
- return previous_declaration;
- } else if (is_function_definition) {
- if (declaration->storage_class != STORAGE_CLASS_STATIC) {
+ previous_declaration->modifiers |= declaration->modifiers;
+ 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 &&
+ 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 == global_scope &&
- !is_type_function(type) && (
- 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
+ && current_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);
+ }
}
- assert(declaration->parent_scope == NULL);
- assert(scope != NULL);
-
- declaration->parent_scope = scope;
-
- environment_push(declaration);
- return append_declaration(declaration);
-}
+finish:
+ assert(entity->base.parent_scope == NULL);
+ assert(current_scope != NULL);
-static declaration_t *record_declaration(declaration_t *declaration)
-{
- return internal_record_declaration(declaration, false);
-}
+ entity->base.parent_scope = current_scope;
+ entity->base.namespc = NAMESPACE_NORMAL;
+ environment_push(entity);
+ append_entity(current_scope, entity);
-static declaration_t *record_function_definition(declaration_t *declaration)
-{
- return internal_record_declaration(declaration, true);
+ 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,
bool only_specifiers_qualifiers)
{
- switch(token->type) {
+ switch (token->type) {
TYPE_SPECIFIERS
TYPE_QUALIFIERS
return true;
}
}
-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 == global_scope) {
+ if (declaration->storage_class == STORAGE_CLASS_STATIC ||
+ declaration->storage_class == STORAGE_CLASS_THREAD_STATIC ||
+ entity->base.parent_scope == file_scope) {
must_be_constant = true;
}
+ if (is_type_function(type)) {
+ errorf(&entity->base.source_position,
+ "function '%#T' is initialized like a variable",
+ 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 = declaration;
+ env.entity = entity;
+ current_init_decl = entity;
initializer_t *initializer = parse_initializer(&env);
+ current_init_decl = NULL;
- if (env.type != orig_type) {
- orig_type = env.type;
- type = skip_typeref(orig_type);
- declaration->type = env.type;
- }
-
- if (is_type_function(type)) {
- errorf(&declaration->source_position,
- "initializers not allowed for function types at declator '%Y' (type '%T')",
- declaration->symbol, orig_type);
- } else {
- 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;
}
}
/* parse rest of a declaration without any declarator */
static void parse_anonymous_declaration_rest(
- const declaration_specifiers_t *specifiers,
- parsed_declaration_func finished_declaration)
+ const declaration_specifiers_t *specifiers)
{
eat(';');
- 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;
-
- if (declaration->declared_storage_class != STORAGE_CLASS_NONE) {
- warningf(&declaration->source_position,
- "useless storage class in empty declaration");
- }
- declaration->storage_class = STORAGE_CLASS_NONE;
-
- type_t *type = declaration->type;
- switch (type->kind) {
- case TYPE_COMPOUND_STRUCT:
- case TYPE_COMPOUND_UNION: {
- if (type->compound.declaration->symbol == NULL) {
- warningf(&declaration->source_position,
- "unnamed struct/union that defines no instances");
- }
- break;
+ if (warning.other) {
+ if (specifiers->storage_class != STORAGE_CLASS_NONE) {
+ warningf(&specifiers->source_position,
+ "useless storage class in empty declaration");
}
- case TYPE_ENUM:
- break;
+ 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;
+ }
- default:
- warningf(&declaration->source_position, "empty declaration");
- break;
- }
+ case TYPE_ENUM:
+ break;
- finished_declaration(declaration);
+ default:
+ warningf(&specifiers->source_position, "empty declaration");
+ break;
+ }
+ }
}
-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('=');
add_anchor_token(',');
while(true) {
- declaration_t *declaration = finished_declaration(ndeclaration);
-
- 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 != ',')
break;
eat(',');
- ndeclaration = parse_declarator(specifiers, /*may_be_abstract=*/false);
+ add_anchor_token('=');
+ ndeclaration = parse_declarator(specifiers, /*may_be_abstract=*/false, false);
+ rem_anchor_token('=');
}
expect(';');
end_error:
rem_anchor_token(';');
- rem_anchor_token('=');
rem_anchor_token(',');
}
-static declaration_t *finished_kr_declaration(declaration_t *declaration)
+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);
+ 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 != current_scope) {
errorf(HERE, "expected declaration of a function parameter, found '%Y'",
symbol);
- return declaration;
+ return entity;
}
- 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);
+ if (is_definition) {
+ errorf(HERE, "parameter %Y is initialised", entity->base.symbol);
}
+
+ return record_entity(entity, false);
}
static void parse_declaration(parsed_declaration_func finished_declaration)
{
declaration_specifiers_t specifiers;
memset(&specifiers, 0, sizeof(specifiers));
+
+ add_anchor_token(';');
parse_declaration_specifiers(&specifiers);
+ rem_anchor_token(';');
if (token.type == ';') {
- parse_anonymous_declaration_rest(&specifiers, append_declaration);
+ 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 */
- int top = environment_top();
- scope_t *last_scope = scope;
- set_scope(&declaration->scope);
-
- declaration_t *parameter = declaration->scope.declarations;
- for ( ; parameter != NULL; parameter = parameter->next) {
- assert(parameter->parent_scope == NULL);
- parameter->parent_scope = scope;
+ size_t const top = environment_top();
+ scope_push(&entity->function.parameters);
+
+ entity_t *parameter = entity->function.parameters.entities;
+ for ( ; parameter != NULL; parameter = parameter->base.next) {
+ assert(parameter->base.parent_scope == NULL);
+ parameter->base.parent_scope = current_scope;
environment_push(parameter);
}
}
/* pop function parameters */
- assert(scope == &declaration->scope);
- set_scope(last_scope);
+ assert(current_scope == &entity->function.parameters);
+ scope_pop();
environment_pop_to(top);
/* update function type */
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('{');
}
static bool first_err = true;
* When called with first_err set, prints the name of the current function,
* else does noting.
*/
-static void print_in_function(void) {
+static void print_in_function(void)
+{
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);
}
}
for (const goto_statement_t *goto_statement = goto_first;
goto_statement != NULL;
goto_statement = goto_statement->next) {
- declaration_t *label = goto_statement->label;
+ /* skip computed gotos */
+ if (goto_statement->expression != NULL)
+ continue;
+
+ 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;
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;
+}
+
+static void warn_unused_decl(entity_t *entity, entity_t *end,
+ char const *const what)
+{
+ 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 (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;
+ }
+
+ case STATEMENT_FOR:
+ warn_unused_decl(stmt->fors.scope.entities, NULL, "variable");
+ return;
+
+ default:
+ return;
+ }
}
/**
static void check_declarations(void)
{
if (warning.unused_parameter) {
- const scope_t *scope = ¤t_function->scope;
+ const scope_t *scope = ¤t_function->parameters;
- 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);
- }
+ /* 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);
}
}
-static void parse_external_declaration(void)
+static int determine_truth(expression_t const* const cond)
{
- /* function-definitions and declarations both start with declaration
- * specifiers */
- declaration_specifiers_t specifiers;
- memset(&specifiers, 0, sizeof(specifiers));
+ return
+ !is_constant_expression(cond) ? 0 :
+ fold_constant(cond) != 0 ? 1 :
+ -1;
+}
- add_anchor_token(';');
- parse_declaration_specifiers(&specifiers);
- rem_anchor_token(';');
+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;
+ }
- /* must be a declaration */
- if (token.type == ';') {
- parse_anonymous_declaration_rest(&specifiers, append_declaration);
- return;
- }
+ if (!expression_returns(func))
+ return false;
- add_anchor_token(',');
- add_anchor_token('=');
- rem_anchor_token(';');
+ for (call_argument_t const* arg = expr->call.arguments; arg != NULL; arg = arg->next) {
+ if (!expression_returns(arg->expression))
+ return false;
+ }
- /* declarator is common to both function-definitions and declarations */
- declaration_t *ndeclaration = parse_declarator(&specifiers, /*may_be_abstract=*/false);
+ return true;
+ }
- rem_anchor_token(',');
- rem_anchor_token('=');
- rem_anchor_token(';');
+ 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_INVALID:
+ case EXPR_STATEMENT: // TODO implement
+ return true;
- /* must be a declaration */
- if (token.type == ',' || token.type == '=' || token.type == ';') {
- parse_declaration_rest(ndeclaration, &specifiers, record_declaration);
- return;
- }
+ 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)
+ );
- /* must be a function definition */
- parse_kr_declaration_list(ndeclaration);
+ case EXPR_SELECT:
+ return expression_returns(expr->select.compound);
- if (token.type != '{') {
- parse_error_expected("while parsing function definition", '{', NULL);
- eat_until_matching_token(';');
- return;
- }
+ 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:
+ break;
+ }
+
+ panic("unhandled expression");
+}
+
+static bool noreturn_candidate;
+
+static void check_reachable(statement_t *const stmt)
+{
+ if (stmt->base.reachable)
+ return;
+ if (stmt->kind != STATEMENT_DO_WHILE)
+ stmt->base.reachable = true;
+
+ statement_t *last = stmt;
+ statement_t *next;
+ switch (stmt->kind) {
+ case STATEMENT_INVALID:
+ case STATEMENT_EMPTY:
+ case STATEMENT_DECLARATION:
+ case STATEMENT_LOCAL_LABEL:
+ case STATEMENT_ASM:
+ next = stmt->base.next;
+ break;
+
+ case STATEMENT_COMPOUND:
+ next = stmt->compound.statements;
+ break;
+
+ case STATEMENT_RETURN:
+ noreturn_candidate = false;
+ return;
+
+ case STATEMENT_IF: {
+ if_statement_t const* const ifs = &stmt->ifs;
+ int const val = determine_truth(ifs->condition);
+
+ if (val >= 0)
+ check_reachable(ifs->true_statement);
+
+ if (val > 0)
+ return;
+
+ if (ifs->false_statement != NULL) {
+ check_reachable(ifs->false_statement);
+ return;
+ }
+
+ next = stmt->base.next;
+ break;
+ }
+
+ case STATEMENT_SWITCH: {
+ switch_statement_t const *const switchs = &stmt->switchs;
+ expression_t const *const expr = switchs->expression;
+
+ if (is_constant_expression(expr)) {
+ long const val = fold_constant(expr);
+ case_label_statement_t * defaults = NULL;
+ for (case_label_statement_t *i = switchs->first_case; i != NULL; i = i->next) {
+ if (i->expression == NULL) {
+ defaults = i;
+ continue;
+ }
+
+ if (i->first_case <= val && val <= i->last_case) {
+ check_reachable((statement_t*)i);
+ return;
+ }
+ }
+
+ if (defaults != NULL) {
+ check_reachable((statement_t*)defaults);
+ return;
+ }
+ } else {
+ bool has_default = false;
+ for (case_label_statement_t *i = switchs->first_case; i != NULL; i = i->next) {
+ if (i->expression == NULL)
+ has_default = true;
+
+ check_reachable((statement_t*)i);
+ }
+
+ if (has_default)
+ return;
+ }
+
+ next = stmt->base.next;
+ break;
+ }
+
+ case STATEMENT_EXPRESSION: {
+ /* Check for noreturn function call */
+ expression_t const *const expr = stmt->expression.expression;
+ if (!expression_returns(expr))
+ return;
+
+ next = stmt->base.next;
+ break;
+ }
+
+ case STATEMENT_CONTINUE: {
+ statement_t *parent = stmt;
+ for (;;) {
+ parent = parent->base.parent;
+ if (parent == NULL) /* continue not within loop */
+ return;
+
+ next = parent;
+ switch (parent->kind) {
+ case STATEMENT_WHILE: goto continue_while;
+ case STATEMENT_DO_WHILE: goto continue_do_while;
+ case STATEMENT_FOR: goto continue_for;
+
+ default: break;
+ }
+ }
+ }
+
+ case STATEMENT_BREAK: {
+ statement_t *parent = stmt;
+ for (;;) {
+ parent = parent->base.parent;
+ if (parent == NULL) /* break not within loop/switch */
+ return;
+
+ switch (parent->kind) {
+ case STATEMENT_SWITCH:
+ case STATEMENT_WHILE:
+ case STATEMENT_DO_WHILE:
+ case STATEMENT_FOR:
+ last = parent;
+ next = parent->base.next;
+ goto found_break_parent;
+
+ default: break;
+ }
+ }
+found_break_parent:
+ break;
+ }
+
+ case STATEMENT_GOTO:
+ if (stmt->gotos.expression) {
+ statement_t *parent = stmt->base.parent;
+ if (parent == NULL) /* top level goto */
+ return;
+ next = parent;
+ } else {
+ next = stmt->gotos.label->statement;
+ if (next == NULL) /* missing label */
+ return;
+ }
+ break;
+
+ case STATEMENT_LABEL:
+ next = stmt->label.statement;
+ break;
+
+ case STATEMENT_CASE_LABEL:
+ next = stmt->case_label.statement;
+ break;
+
+ case STATEMENT_WHILE: {
+ while_statement_t const *const whiles = &stmt->whiles;
+ int const val = determine_truth(whiles->condition);
+
+ if (val >= 0)
+ check_reachable(whiles->body);
+
+ if (val > 0)
+ return;
+
+ next = stmt->base.next;
+ break;
+ }
+
+ case STATEMENT_DO_WHILE:
+ next = stmt->do_while.body;
+ break;
+
+ case STATEMENT_FOR: {
+ for_statement_t *const fors = &stmt->fors;
+
+ if (fors->condition_reachable)
+ return;
+ fors->condition_reachable = true;
+
+ expression_t const *const cond = fors->condition;
+ int const val =
+ cond == NULL ? 1 : determine_truth(cond);
+
+ if (val >= 0)
+ check_reachable(fors->body);
+
+ if (val > 0)
+ return;
+
+ next = stmt->base.next;
+ break;
+ }
+
+ case STATEMENT_MS_TRY: {
+ ms_try_statement_t const *const ms_try = &stmt->ms_try;
+ check_reachable(ms_try->try_statement);
+ next = ms_try->final_statement;
+ break;
+ }
+
+ case STATEMENT_LEAVE: {
+ statement_t *parent = stmt;
+ for (;;) {
+ parent = parent->base.parent;
+ if (parent == NULL) /* __leave not within __try */
+ return;
+
+ if (parent->kind == STATEMENT_MS_TRY) {
+ last = parent;
+ next = parent->ms_try.final_statement;
+ break;
+ }
+ }
+ break;
+ }
+ }
+
+ while (next == NULL) {
+ next = last->base.parent;
+ if (next == NULL) {
+ noreturn_candidate = false;
+
+ 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->base.base.symbol)) {
+ warningf(&stmt->base.source_position,
+ "control reaches end of non-void function");
+ }
+ return;
+ }
+
+ switch (next->kind) {
+ case STATEMENT_INVALID:
+ case STATEMENT_EMPTY:
+ case STATEMENT_DECLARATION:
+ case STATEMENT_LOCAL_LABEL:
+ case STATEMENT_EXPRESSION:
+ case STATEMENT_ASM:
+ case STATEMENT_RETURN:
+ case STATEMENT_CONTINUE:
+ case STATEMENT_BREAK:
+ case STATEMENT_GOTO:
+ case STATEMENT_LEAVE:
+ panic("invalid control flow in function");
+
+ case STATEMENT_COMPOUND:
+ case STATEMENT_IF:
+ case STATEMENT_SWITCH:
+ case STATEMENT_LABEL:
+ case STATEMENT_CASE_LABEL:
+ last = next;
+ next = next->base.next;
+ break;
+
+ case STATEMENT_WHILE: {
+continue_while:
+ if (next->base.reachable)
+ return;
+ next->base.reachable = true;
+
+ while_statement_t const *const whiles = &next->whiles;
+ int const val = determine_truth(whiles->condition);
+
+ if (val >= 0)
+ check_reachable(whiles->body);
+
+ if (val > 0)
+ return;
+
+ last = next;
+ next = next->base.next;
+ break;
+ }
+
+ case STATEMENT_DO_WHILE: {
+continue_do_while:
+ if (next->base.reachable)
+ return;
+ next->base.reachable = true;
+
+ do_while_statement_t const *const dw = &next->do_while;
+ int const val = determine_truth(dw->condition);
+
+ if (val >= 0)
+ check_reachable(dw->body);
+
+ if (val > 0)
+ return;
+
+ last = next;
+ next = next->base.next;
+ break;
+ }
+
+ case STATEMENT_FOR: {
+continue_for:;
+ for_statement_t *const fors = &next->fors;
+
+ fors->step_reachable = true;
+
+ if (fors->condition_reachable)
+ return;
+ fors->condition_reachable = true;
+
+ expression_t const *const cond = fors->condition;
+ int const val =
+ cond == NULL ? 1 : determine_truth(cond);
+
+ if (val >= 0)
+ check_reachable(fors->body);
+
+ if (val > 0)
+ return;
+
+ last = next;
+ next = next->base.next;
+ break;
+ }
+
+ case STATEMENT_MS_TRY:
+ last = next;
+ next = next->ms_try.final_statement;
+ break;
+ }
+ }
+
+ check_reachable(next);
+}
+
+static void check_unreachable(statement_t* const stmt, void *const env)
+{
+ (void)env;
+
+ switch (stmt->kind) {
+ case STATEMENT_DO_WHILE:
+ if (!stmt->base.reachable) {
+ expression_t const *const cond = stmt->do_while.condition;
+ if (determine_truth(cond) >= 0) {
+ warningf(&cond->base.source_position,
+ "condition of do-while-loop is unreachable");
+ }
+ }
+ return;
+
+ case STATEMENT_FOR: {
+ for_statement_t const* const fors = &stmt->fors;
+
+ // if init and step are unreachable, cond is unreachable, too
+ if (!stmt->base.reachable && !fors->step_reachable) {
+ warningf(&stmt->base.source_position, "statement is unreachable");
+ } else {
+ if (!stmt->base.reachable && fors->initialisation != NULL) {
+ warningf(&fors->initialisation->base.source_position,
+ "initialisation of for-statement is unreachable");
+ }
+
+ if (!fors->condition_reachable && fors->condition != NULL) {
+ warningf(&fors->condition->base.source_position,
+ "condition of for-statement is unreachable");
+ }
+
+ if (!fors->step_reachable && fors->step != NULL) {
+ warningf(&fors->step->base.source_position,
+ "step of for-statement is unreachable");
+ }
+ }
+ return;
+ }
+
+ case STATEMENT_COMPOUND:
+ if (stmt->compound.statements != NULL)
+ return;
+ /* FALLTHROUGH*/
+
+ default:
+ if (!stmt->base.reachable)
+ warningf(&stmt->base.source_position, "statement is unreachable");
+ return;
+ }
+}
+
+static void parse_external_declaration(void)
+{
+ /* function-definitions and declarations both start with declaration
+ * specifiers */
+ declaration_specifiers_t specifiers;
+ memset(&specifiers, 0, sizeof(specifiers));
+
+ add_anchor_token(';');
+ parse_declaration_specifiers(&specifiers);
+ rem_anchor_token(';');
+
+ /* must be a declaration */
+ if (token.type == ';') {
+ parse_anonymous_declaration_rest(&specifiers);
+ return;
+ }
+
+ add_anchor_token(',');
+ add_anchor_token('=');
+ add_anchor_token(';');
+ add_anchor_token('{');
+
+ /* declarator is common to both function-definitions and declarations */
+ entity_t *ndeclaration = parse_declarator(&specifiers, /*may_be_abstract=*/false, false);
+
+ rem_anchor_token('{');
+ rem_anchor_token(';');
+ rem_anchor_token('=');
+ rem_anchor_token(',');
+
+ /* must be a declaration */
+ switch (token.type) {
+ case ',':
+ case ';':
+ case '=':
+ parse_declaration_rest(ndeclaration, &specifiers, record_entity);
+ return;
+ }
+
+ /* must be a function definition */
+ parse_kr_declaration_list(ndeclaration);
+
+ if (token.type != '{') {
+ parse_error_expected("while parsing function definition", '{', NULL);
+ eat_until_matching_token(';');
+ return;
+ }
- type_t *type = ndeclaration->type;
+ assert(is_declaration(ndeclaration));
+ type_t *type = skip_typeref(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_function(type)) {
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->base.symbol);
+ }
+ if (warning.traditional && !type->function.unspecified_parameters) {
+ warningf(HERE, "traditional C rejects ISO C style function definition of function '%Y'",
+ ndeclaration->base.symbol);
+ }
+ if (warning.old_style_definition && type->function.unspecified_parameters) {
+ warningf(HERE, "old-style function definition '%Y'",
+ ndeclaration->base.symbol);
+ }
+
/* § 6.7.5.3 (14) a function definition with () means no
* parameters (and not unspecified parameters) */
if (type->function.unspecified_parameters
if (type != duplicate) {
obstack_free(type_obst, duplicate);
}
- ndeclaration->type = type;
+ ndeclaration->declaration.type = type;
}
- declaration_t *const declaration = record_function_definition(ndeclaration);
- 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 */
- int top = environment_top();
- scope_t *last_scope = scope;
- set_scope(&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(&ndeclaration->source_position, "parameter name omitted");
+ size_t const top = environment_top();
+ 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 = current_scope;
+ }
+ assert(parameter->base.parent_scope == NULL
+ || parameter->base.parent_scope == current_scope);
+ parameter->base.parent_scope = current_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();
- goto end_of_parse_external_declaration;
} else {
/* parse function body */
- int label_stack_top = label_top();
- declaration_t *old_current_function = current_function;
- current_function = declaration;
-
- declaration->init.statement = parse_compound_statement(false);
+ int label_stack_top = label_top();
+ function_t *old_current_function = current_function;
+ current_function = function;
+ current_parent = NULL;
+
+ goto_first = NULL;
+ goto_anchor = &goto_first;
+ label_first = NULL;
+ label_anchor = &label_first;
+
+ 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
+ && !(function->base.modifiers & DM_NORETURN))) {
+ noreturn_candidate = true;
+ check_reachable(body);
+ if (warning.unreachable_code)
+ walk_statements(body, check_unreachable, NULL);
+ if (warning.missing_noreturn &&
+ noreturn_candidate &&
+ !(function->base.modifiers & DM_NORETURN)) {
+ warningf(&body->base.source_position,
+ "function '%#T' is candidate for attribute 'noreturn'",
+ type, entity->base.symbol);
+ }
+ }
- assert(current_function == declaration);
+ assert(current_parent == NULL);
+ assert(current_function == function);
current_function = old_current_function;
label_pop_to(label_stack_top);
}
-end_of_parse_external_declaration:
- assert(scope == &declaration->scope);
- set_scope(last_scope);
+ assert(current_scope == &function->parameters);
+ scope_pop();
environment_pop_to(top);
}
static type_t *make_bitfield_type(type_t *base_type, expression_t *size,
- source_position_t *source_position)
+ 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;
+
+ il_size_t bit_size;
+ type_t *skipped_type = skip_typeref(base_type);
+ if (!is_type_integer(skipped_type)) {
+ errorf(HERE, "bitfield base type '%T' is not an integer type",
+ base_type);
+ bit_size = 0;
+ } else {
+ bit_size = skipped_type->base.size * 8;
+ }
- type->bitfield.base_type = base_type;
- type->bitfield.size = size;
+ if (is_constant_expression(size)) {
+ long v = fold_constant(size);
+
+ if (v < 0) {
+ errorf(source_position, "negative width in bit-field '%Y'",
+ symbol);
+ } else if (v == 0) {
+ errorf(source_position, "zero width for bit-field '%Y'",
+ symbol);
+ } else if (bit_size > 0 && (il_size_t)v > bit_size) {
+ errorf(source_position, "width of '%Y' exceeds its type",
+ symbol);
+ } else {
+ type->bitfield.bit_size = v;
+ }
+ }
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(1) {
- declaration_t *declaration;
+ while (true) {
+ entity_t *entity;
if (token.type == ':') {
source_position_t source_position = *HERE;
type_t *base_type = specifiers->type;
expression_t *size = parse_constant_expression();
- if (!is_type_integer(skip_typeref(base_type))) {
- errorf(HERE, "bitfield base type '%T' is not an integer type",
- base_type);
- }
+ type_t *type = make_bitfield_type(base_type, size,
+ &source_position, sym_anonymous);
- type_t *type = make_bitfield_type(base_type, size, &source_position);
-
- 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);
-
- type_t *orig_type = declaration->type;
- type_t *type = skip_typeref(orig_type);
+ entity = parse_declarator(specifiers,/*may_be_abstract=*/true, true);
+ assert(entity->kind == ENTITY_COMPOUND_MEMBER);
if (token.type == ':') {
source_position_t source_position = *HERE;
next_token();
expression_t *size = parse_constant_expression();
- if (!is_type_integer(type)) {
- errorf(HERE, "bitfield base type '%T' is not an "
- "integer type", orig_type);
- }
-
- type_t *bitfield_type = make_bitfield_type(orig_type, size, &source_position);
- 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);
- } else if (is_type_function(type)) {
- errorf(HERE, "compound member '%Y' must not have function "
- "type '%T'", declaration->symbol, orig_type);
- }
+ type_t *type = entity->declaration.type;
+ type_t *bitfield_type = make_bitfield_type(type, size,
+ &source_position, entity->base.symbol);
+ entity->declaration.type = bitfield_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 semantic_compound(compound_t *compound)
+{
+ entity_t *entity = compound->members.entities;
+ for ( ; entity != NULL; entity = entity->base.next) {
+ assert(entity->kind == ENTITY_COMPOUND_MEMBER);
+
+ type_t *orig_type = entity->declaration.type;
+ type_t *type = skip_typeref(orig_type);
+
+ if (is_type_function(type)) {
+ errorf(HERE,
+ "compound member '%Y' must not have function type '%T'",
+ entity->base.symbol, orig_type);
+ } else if (is_type_incomplete(type)) {
+ /* §6.7.2.1 (16) flexible array member */
+ if (is_type_array(type) && entity->base.next == NULL) {
+ compound->has_flexible_member = true;
+ } else {
+ errorf(HERE,
+ "compound member '%Y' has incomplete type '%T'",
+ entity->base.symbol, orig_type);
+ }
+ }
+ }
+}
+
+static void parse_compound_type_entries(compound_t *compound)
{
eat('{');
add_anchor_token('}');
- while(token.type != '}' && token.type != T_EOF) {
+ while (token.type != '}') {
+ if (token.type == T_EOF) {
+ errorf(HERE, "EOF while parsing struct");
+ break;
+ }
declaration_specifiers_t specifiers;
memset(&specifiers, 0, sizeof(specifiers));
parse_declaration_specifiers(&specifiers);
- parse_compound_declarators(compound_declaration, &specifiers);
+ parse_compound_declarators(compound, &specifiers);
}
+ semantic_compound(compound);
rem_anchor_token('}');
-
- if (token.type == T_EOF) {
- errorf(HERE, "EOF while parsing struct");
- }
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;
/* note: that we use type_char_ptr here, which is already the
* automatic converted type. revert_automatic_type_conversion
* will construct the array type */
- cnst->base.type = type_char_ptr;
+ cnst->base.type = warning.write_strings ? type_const_char_ptr : type_char_ptr;
cnst->string.value = res;
return cnst;
}
default: {
expression_t *const cnst = allocate_expression_zero(EXPR_WIDE_STRING_LITERAL);
- cnst->base.type = type_wchar_t_ptr;
+ cnst->base.type = warning.write_strings ? type_const_wchar_t_ptr : type_wchar_t_ptr;
cnst->wide_string.value = wres;
return cnst;
}
}
}
+/**
+ * Parse a boolean constant.
+ */
+static expression_t *parse_bool_const(bool value)
+{
+ expression_t *cnst = allocate_expression_zero(EXPR_CONST);
+ cnst->base.type = type_bool;
+ cnst->conste.v.int_value = value;
+
+ next_token();
+
+ return cnst;
+}
+
/**
* Parse an integer constant.
*/
static expression_t *parse_int_const(void)
{
- expression_t *cnst = allocate_expression_zero(EXPR_CONST);
- cnst->base.source_position = *HERE;
- cnst->base.type = token.datatype;
- cnst->conste.v.int_value = token.v.intvalue;
+ expression_t *cnst = allocate_expression_zero(EXPR_CONST);
+ cnst->base.type = token.datatype;
+ cnst->conste.v.int_value = token.v.intvalue;
next_token();
static expression_t *parse_character_constant(void)
{
expression_t *cnst = allocate_expression_zero(EXPR_CHARACTER_CONSTANT);
-
- cnst->base.source_position = *HERE;
- cnst->base.type = token.datatype;
- cnst->conste.v.character = token.v.string;
+ cnst->base.type = token.datatype;
+ cnst->conste.v.character = token.v.string;
if (cnst->conste.v.character.size != 1) {
- if (warning.multichar && (c_mode & _GNUC)) {
- /* TODO */
+ if (!GNU_MODE) {
+ errorf(HERE, "more than 1 character in character constant");
+ } else if (warning.multichar) {
warningf(HERE, "multi-character character constant");
- } else {
- errorf(HERE, "more than 1 characters in character constant");
}
}
next_token();
static expression_t *parse_wide_character_constant(void)
{
expression_t *cnst = allocate_expression_zero(EXPR_WIDE_CHARACTER_CONSTANT);
-
- cnst->base.source_position = *HERE;
cnst->base.type = token.datatype;
cnst->conste.v.wide_character = token.v.wide_string;
if (cnst->conste.v.wide_character.size != 1) {
- if (warning.multichar && (c_mode & _GNUC)) {
- /* TODO */
+ if (!GNU_MODE) {
+ errorf(HERE, "more than 1 character in character constant");
+ } else if (warning.multichar) {
warningf(HERE, "multi-character character constant");
- } else {
- errorf(HERE, "more than 1 characters in character constant");
}
}
next_token();
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;
+ 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);
+ 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_SELECT: return expression->select.compound_entry->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: {
+ 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);
- source_position_t source_position = token.source_position;
- next_token();
-
- if (declaration == NULL) {
- if (! strict_mode && token.type == '(') {
- /* an implicitly defined function */
+ if (entity == NULL) {
+ if (!strict_mode && look_ahead(1)->type == '(') {
+ /* an implicitly declared function */
if (warning.implicit_function_declaration) {
warningf(HERE, "implicit declaration of function '%Y'",
symbol);
}
- declaration = create_implicit_function(symbol,
- &source_position);
+ entity = create_implicit_function(symbol, HERE);
} else {
errorf(HERE, "unknown symbol '%Y' found.", symbol);
- return create_invalid_expression();
+ entity = create_error_entity(symbol, ENTITY_VARIABLE);
}
}
- type_t *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 if (entity->kind == ENTITY_TYPEDEF) {
+ errorf(HERE, "encountered typedef name '%Y' while parsing expression",
+ symbol);
+ next_token();
+ return create_invalid_expression();
+ } 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 = automatic_type_conversion(type);
+ 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 (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 (declaration->deprecated != 0) {
- const char *prefix = "";
- if (is_type_function(declaration->type))
- prefix = "function ";
+ 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(&source_position,
- "%s'%Y' was declared 'deprecated(\"%s\")'", prefix, declaration->symbol,
- declaration->deprecated_string);
+ warningf(HERE, "%s '%Y' is deprecated (declared %P): \"%s\"",
+ prefix, entity->base.symbol, &entity->base.source_position,
+ declaration->deprecated_string);
} else {
- warningf(&source_position,
- "%s'%Y' was declared 'deprecated'", prefix, declaration->symbol);
+ warningf(HERE, "%s '%Y' is deprecated (declared %P)", prefix,
+ entity->base.symbol, &entity->base.source_position);
}
}
+ 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",
+ entity->declaration.type, entity->base.symbol);
+ }
+
+ next_token();
return expression;
}
-static void check_cast_allowed(expression_t *expression, type_t *dest_type)
+static bool semantic_cast(expression_t *cast)
{
- (void) expression;
- (void) dest_type;
- /* TODO check if explicit cast is allowed and issue warnings/errors */
+ expression_t *expression = cast->unary.value;
+ type_t *orig_dest_type = cast->base.type;
+ type_t *orig_type_right = expression->base.type;
+ type_t const *dst_type = skip_typeref(orig_dest_type);
+ type_t const *src_type = skip_typeref(orig_type_right);
+ source_position_t const *pos = &cast->base.source_position;
+
+ /* §6.5.4 A (void) cast is explicitly permitted, more for documentation than for utility. */
+ if (dst_type == type_void)
+ return true;
+
+ /* only integer and pointer can be casted to pointer */
+ if (is_type_pointer(dst_type) &&
+ !is_type_pointer(src_type) &&
+ !is_type_integer(src_type) &&
+ is_type_valid(src_type)) {
+ errorf(pos, "cannot convert type '%T' to a pointer type", orig_type_right);
+ return false;
+ }
+
+ if (!is_type_scalar(dst_type) && is_type_valid(dst_type)) {
+ errorf(pos, "conversion to non-scalar type '%T' requested", orig_dest_type);
+ return false;
+ }
+
+ if (!is_type_scalar(src_type) && is_type_valid(src_type)) {
+ errorf(pos, "conversion from non-scalar type '%T' requested", orig_type_right);
+ return false;
+ }
+
+ if (warning.cast_qual &&
+ is_type_pointer(src_type) &&
+ is_type_pointer(dst_type)) {
+ type_t *src = skip_typeref(src_type->pointer.points_to);
+ type_t *dst = skip_typeref(dst_type->pointer.points_to);
+ unsigned missing_qualifiers =
+ src->base.qualifiers & ~dst->base.qualifiers;
+ if (missing_qualifiers != 0) {
+ warningf(pos,
+ "cast discards qualifiers '%Q' in pointer target type of '%T'",
+ missing_qualifiers, orig_type_right);
+ }
+ }
+ return true;
}
static expression_t *parse_compound_literal(type_t *type)
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;
*/
static expression_t *parse_cast(void)
{
+ add_anchor_token(')');
+
source_position_t source_position = token.source_position;
- type_t *type = parse_typename();
+ type_t *type = parse_typename();
- /* matching add_anchor_token() is at call site */
rem_anchor_token(')');
expect(')');
expression_t *cast = allocate_expression_zero(EXPR_UNARY_CAST);
cast->base.source_position = source_position;
- expression_t *value = parse_sub_expression(20);
-
- check_cast_allowed(value, type);
-
+ expression_t *value = parse_sub_expression(PREC_CAST);
cast->base.type = type;
cast->unary.value = value;
+ if (! semantic_cast(cast)) {
+ /* TODO: record the error in the AST. else it is impossible to detect it */
+ }
+
return cast;
end_error:
return create_invalid_expression();
*/
static expression_t *parse_statement_expression(void)
{
+ add_anchor_token(')');
+
expression_t *expression = allocate_expression_zero(EXPR_STATEMENT);
- statement_t *statement = parse_compound_statement(true);
- expression->statement.statement = statement;
- expression->base.source_position = statement->base.source_position;
+ statement_t *statement = parse_compound_statement(true);
+ expression->statement.statement = statement;
/* find last statement and use its type */
type_t *type = type_void;
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;
+ rem_anchor_token(')');
expect(')');
- return expression;
end_error:
- return create_invalid_expression();
+ return expression;
}
/**
- * Parse a braced expression.
+ * Parse a parenthesized expression.
*/
-static expression_t *parse_brace_expression(void)
+static expression_t *parse_parenthesized_expression(void)
{
eat('(');
- add_anchor_token(')');
- switch(token.type) {
+ switch (token.type) {
case '{':
/* gcc extension: a statement expression */
return parse_statement_expression();
}
}
+ add_anchor_token(')');
expression_t *result = parse_expression();
rem_anchor_token(')');
expect(')');
- return result;
end_error:
- return create_invalid_expression();
+ return result;
}
static expression_t *parse_function_keyword(void)
{
- next_token();
/* TODO */
if (current_function == NULL) {
expression->base.type = type_char_ptr;
expression->funcname.kind = FUNCNAME_FUNCTION;
+ next_token();
+
return expression;
}
static expression_t *parse_pretty_function_keyword(void)
{
- eat(T___PRETTY_FUNCTION__);
-
if (current_function == NULL) {
errorf(HERE, "'__PRETTY_FUNCTION__' used outside of a function");
}
expression->base.type = type_char_ptr;
expression->funcname.kind = FUNCNAME_PRETTY_FUNCTION;
+ eat(T___PRETTY_FUNCTION__);
+
return expression;
}
static expression_t *parse_funcsig_keyword(void)
{
- eat(T___FUNCSIG__);
-
if (current_function == NULL) {
errorf(HERE, "'__FUNCSIG__' used outside of a function");
}
expression->base.type = type_char_ptr;
expression->funcname.kind = FUNCNAME_FUNCSIG;
+ eat(T___FUNCSIG__);
+
return expression;
}
static expression_t *parse_funcdname_keyword(void)
{
- eat(T___FUNCDNAME__);
-
if (current_function == NULL) {
errorf(HERE, "'__FUNCDNAME__' used outside of a function");
}
expression->base.type = type_char_ptr;
expression->funcname.kind = FUNCNAME_FUNCDNAME;
+ eat(T___FUNCDNAME__);
+
return expression;
}
*/
static expression_t *parse_offsetof(void)
{
- eat(T___builtin_offsetof);
-
expression_t *expression = allocate_expression_zero(EXPR_OFFSETOF);
expression->base.type = type_size_t;
+ eat(T___builtin_offsetof);
+
expect('(');
add_anchor_token(',');
type_t *type = parse_typename();
*/
static expression_t *parse_va_start(void)
{
- eat(T___builtin_va_start);
-
expression_t *expression = allocate_expression_zero(EXPR_VA_START);
+ eat(T___builtin_va_start);
+
expect('(');
add_anchor_token(',');
expression->va_starte.ap = parse_assignment_expression();
expect(',');
expression_t *const expr = parse_assignment_expression();
if (expr->kind == EXPR_REFERENCE) {
- declaration_t *const decl = expr->reference.declaration;
- if (decl == NULL)
- return create_invalid_expression();
- if (decl->parent_scope == ¤t_function->scope &&
- decl->next == NULL) {
- expression->va_starte.parameter = decl;
- expect(')');
- return expression;
+ 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;
}
+ expect(')');
+ return expression;
}
- errorf(&expr->base.source_position,
- "second argument of 'va_start' must be last parameter of the current function");
+ expect(')');
end_error:
return create_invalid_expression();
}
*/
static expression_t *parse_va_arg(void)
{
- eat(T___builtin_va_arg);
-
expression_t *expression = allocate_expression_zero(EXPR_VA_ARG);
+ eat(T___builtin_va_arg);
+
expect('(');
expression->va_arge.ap = parse_assignment_expression();
expect(',');
*/
static expression_t *parse_builtin_constant(void)
{
- eat(T___builtin_constant_p);
-
expression_t *expression = allocate_expression_zero(EXPR_BUILTIN_CONSTANT_P);
+ eat(T___builtin_constant_p);
+
expect('(');
add_anchor_token(')');
expression->builtin_constant.value = parse_assignment_expression();
*/
static expression_t *parse_builtin_prefetch(void)
{
- eat(T___builtin_prefetch);
-
expression_t *expression = allocate_expression_zero(EXPR_BUILTIN_PREFETCH);
+ eat(T___builtin_prefetch);
+
expect('(');
add_anchor_token(')');
expression->builtin_prefetch.adr = parse_assignment_expression();
{
expression_t *expression;
- switch(token.type) {
+ switch (token.type) {
case T___builtin_isgreater:
expression = allocate_expression_zero(EXPR_BINARY_ISGREATER);
break;
break;
default:
internal_errorf(HERE, "invalid compare builtin found");
- break;
}
expression->base.source_position = *HERE;
next_token();
*/
static expression_t *parse_builtin_expect(void)
{
- eat(T___builtin_expect);
-
expression_t *expression
= allocate_expression_zero(EXPR_BINARY_BUILTIN_EXPECT);
+ eat(T___builtin_expect);
+
expect('(');
expression->binary.left = parse_assignment_expression();
expect(',');
/**
* Parses a MS assume() expression.
*/
-static expression_t *parse_assume(void) {
- eat(T__assume);
+static expression_t *parse_assume(void)
+{
+ expression_t *expression = allocate_expression_zero(EXPR_UNARY_ASSUME);
- expression_t *expression
- = allocate_expression_zero(EXPR_UNARY_ASSUME);
+ eat(T__assume);
expect('(');
add_anchor_token(')');
return create_invalid_expression();
}
+/**
+ * Return the declaration for a given label symbol or create a new one.
+ *
+ * @param symbol the symbol of the label
+ */
+static label_t *get_label(symbol_t *symbol)
+{
+ entity_t *label;
+ assert(current_function != NULL);
+
+ label = get_entity(symbol, NAMESPACE_LABEL);
+ /* if we found a local label, we already created the declaration */
+ if (label != NULL && label->kind == ENTITY_LOCAL_LABEL) {
+ if (label->base.parent_scope != current_scope) {
+ assert(label->base.parent_scope->depth < current_scope->depth);
+ current_function->goto_to_outer = true;
+ }
+ return &label->label;
+ }
+
+ label = get_entity(symbol, NAMESPACE_LABEL);
+ /* if we found a label in the same function, then we already created the
+ * declaration */
+ if (label != NULL
+ && label->base.parent_scope == ¤t_function->parameters) {
+ return &label->label;
+ }
+
+ /* otherwise we need to create a new one */
+ label = allocate_entity_zero(ENTITY_LABEL);
+ label->base.namespc = NAMESPACE_LABEL;
+ label->base.symbol = symbol;
+
+ label_push(label);
+
+ return &label->label;
+}
+
+/**
+ * Parses a GNU && label address expression.
+ */
+static expression_t *parse_label_address(void)
+{
+ source_position_t source_position = token.source_position;
+ eat(T_ANDAND);
+ if (token.type != T_IDENTIFIER) {
+ parse_error_expected("while parsing label address", T_IDENTIFIER, NULL);
+ goto end_error;
+ }
+ symbol_t *symbol = token.v.symbol;
+ next_token();
+
+ label_t *label = get_label(symbol);
+ label->used = true;
+ label->address_taken = true;
+
+ expression_t *expression = allocate_expression_zero(EXPR_LABEL_ADDRESS);
+ expression->base.source_position = source_position;
+
+ /* label address is threaten as a void pointer */
+ expression->base.type = type_void_ptr;
+ expression->label_address.label = label;
+ return expression;
+end_error:
+ return create_invalid_expression();
+}
+
/**
* Parse a microsoft __noop expression.
*/
-static expression_t *parse_noop_expression(void) {
- source_position_t source_position = *HERE;
+static expression_t *parse_noop_expression(void)
+{
+ /* the result is a (int)0 */
+ expression_t *cnst = allocate_expression_zero(EXPR_CONST);
+ cnst->base.type = type_int;
+ cnst->conste.v.int_value = 0;
+ cnst->conste.is_ms_noop = true;
+
eat(T___noop);
if (token.type == '(') {
rem_anchor_token(')');
expect(')');
- /* the result is a (int)0 */
- expression_t *cnst = allocate_expression_zero(EXPR_CONST);
- cnst->base.source_position = source_position;
- cnst->base.type = type_int;
- cnst->conste.v.int_value = 0;
- cnst->conste.is_ms_noop = true;
-
- return cnst;
-
end_error:
- return create_invalid_expression();
+ return cnst;
}
/**
static expression_t *parse_primary_expression(void)
{
switch (token.type) {
+ case T_false: return parse_bool_const(false);
+ case T_true: return parse_bool_const(true);
case T_INTEGER: return parse_int_const();
case T_CHARACTER_CONSTANT: return parse_character_constant();
case T_WIDE_CHARACTER_CONSTANT: return parse_wide_character_constant();
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:
case T___builtin_constant_p: return parse_builtin_constant();
case T___builtin_prefetch: return parse_builtin_prefetch();
case T__assume: return parse_assume();
+ case T_ANDAND:
+ if (GNU_MODE)
+ return parse_label_address();
+ break;
- case '(': return parse_brace_expression();
+ case '(': return parse_parenthesized_expression();
case T___noop: return parse_noop_expression();
}
/**
* Check if the expression has the character type and issue a warning then.
*/
-static void check_for_char_index_type(const expression_t *expression) {
+static void check_for_char_index_type(const expression_t *expression)
+{
type_t *const type = expression->base.type;
const type_t *const base_type = skip_typeref(type);
}
}
-static expression_t *parse_array_expression(unsigned precedence,
- expression_t *left)
+static expression_t *parse_array_expression(expression_t *left)
{
- (void) precedence;
+ expression_t *expression = allocate_expression_zero(EXPR_ARRAY_ACCESS);
eat('[');
add_anchor_token(']');
expression_t *inside = parse_expression();
- expression_t *expression = allocate_expression_zero(EXPR_ARRAY_ACCESS);
-
- array_access_expression_t *array_access = &expression->array_access;
-
type_t *const orig_type_left = left->base.type;
type_t *const orig_type_inside = inside->base.type;
type_t *const type_left = skip_typeref(orig_type_left);
type_t *const type_inside = skip_typeref(orig_type_inside);
- type_t *return_type;
+ type_t *return_type;
+ array_access_expression_t *array_access = &expression->array_access;
if (is_type_pointer(type_left)) {
return_type = type_left->pointer.points_to;
array_access->array_ref = left;
orig_type_left, orig_type_inside);
}
return_type = type_error_type;
- array_access->array_ref = create_invalid_expression();
- }
-
- rem_anchor_token(']');
- if (token.type != ']') {
- parse_error_expected("Problem while parsing array access", ']', NULL);
- return expression;
+ array_access->array_ref = left;
+ array_access->index = inside;
}
- next_token();
- return_type = automatic_type_conversion(return_type);
- expression->base.type = return_type;
+ expression->base.type = automatic_type_conversion(return_type);
+ rem_anchor_token(']');
+ expect(']');
+end_error:
return expression;
}
-static expression_t *parse_typeprop(expression_kind_t const kind,
- source_position_t const pos,
- unsigned const precedence)
+static expression_t *parse_typeprop(expression_kind_t const kind)
{
- expression_t *tp_expression = allocate_expression_zero(kind);
- tp_expression->base.type = type_size_t;
- tp_expression->base.source_position = pos;
+ expression_t *tp_expression = allocate_expression_zero(kind);
+ tp_expression->base.type = type_size_t;
+
+ eat(kind == EXPR_SIZEOF ? T_sizeof : T___alignof__);
- char const* const what = kind == EXPR_SIZEOF ? "sizeof" : "alignof";
+ /* 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) {
+ char const* const what = kind == EXPR_SIZEOF ? "sizeof" : "alignof";
+ errorf(&tp_expression->base.source_position,
+ "operand of %s expression must not be of %s type '%T'",
+ what, wrong_type, orig_type);
}
- return tp_expression;
end_error:
- return create_invalid_expression();
+ in_type_prop = old;
+ 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);
}
-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);
}
-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);
+ expression_t *select = allocate_expression_zero(EXPR_SELECT);
+ select->select.compound = compound;
+ assert(token.type == '.' || token.type == T_MINUSGREATER);
bool is_pointer = (token.type == T_MINUSGREATER);
next_token();
- expression_t *select = allocate_expression_zero(EXPR_SELECT);
- select->select.compound = compound;
-
if (token.type != T_IDENTIFIER) {
parse_error_expected("while parsing select", T_IDENTIFIER, NULL);
return select;
}
- symbol_t *symbol = token.v.symbol;
- select->select.symbol = symbol;
+ symbol_t *symbol = token.v.symbol;
next_token();
type_t *const orig_type = compound->base.type;
type_t *const type = skip_typeref(orig_type);
- type_t *type_left = type;
- if (is_pointer) {
- if (!is_type_pointer(type)) {
- if (is_type_valid(type)) {
- errorf(HERE, "left hand side of '->' is not a pointer, but '%T'", orig_type);
- }
- return create_invalid_expression();
+ type_t *type_left;
+ bool saw_error = false;
+ if (is_type_pointer(type)) {
+ if (!is_pointer) {
+ errorf(HERE,
+ "request for member '%Y' in something not a struct or union, but '%T'",
+ symbol, orig_type);
+ saw_error = true;
}
- type_left = type->pointer.points_to;
- }
- type_left = skip_typeref(type_left);
-
- if (type_left->kind != TYPE_COMPOUND_STRUCT &&
- type_left->kind != TYPE_COMPOUND_UNION) {
- if (is_type_valid(type_left)) {
- errorf(HERE, "request for member '%Y' in something not a struct or "
- "union, but '%T'", symbol, type_left);
+ type_left = skip_typeref(type->pointer.points_to);
+ } else {
+ if (is_pointer && is_type_valid(type)) {
+ errorf(HERE, "left hand side of '->' is not a pointer, but '%T'", orig_type);
+ saw_error = true;
}
- return create_invalid_expression();
+ type_left = type;
}
- declaration_t *const declaration = type_left->compound.declaration;
+ entity_t *entry;
+ if (type_left->kind == TYPE_COMPOUND_STRUCT ||
+ type_left->kind == TYPE_COMPOUND_UNION) {
+ compound_t *compound = type_left->compound.compound;
- if (!declaration->init.complete) {
- errorf(HERE, "request for member '%Y' of incomplete type '%T'",
- symbol, type_left);
- return create_invalid_expression();
- }
+ if (!compound->complete) {
+ errorf(HERE, "request for member '%Y' of incomplete type '%T'",
+ symbol, type_left);
+ goto create_error_entry;
+ }
- declaration_t *iter = find_compound_entry(declaration, symbol);
- if (iter == NULL) {
- errorf(HERE, "'%T' has no member named '%Y'", orig_type, 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;
+ }
+ } else {
+ if (is_type_valid(type_left) && !saw_error) {
+ errorf(HERE,
+ "request for member '%Y' in something not a struct or union, but '%T'",
+ symbol, type_left);
+ }
+create_error_entry:
return create_invalid_expression();
}
+ assert(is_declaration(entry));
+ select->select.compound_entry = entry;
+
+ 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! */
- type_t *expression_type = automatic_type_conversion(iter->type);
+ select->base.type = automatic_type_conversion(res_type);
- select->select.compound_entry = iter;
- select->base.type = expression_type;
-
- type_t *skipped = skip_typeref(iter->type);
+ type_t *skipped = skip_typeref(res_type);
if (skipped->kind == TYPE_BITFIELD) {
select->base.type = skipped->bitfield.base_type;
}
}
static void check_call_argument(const function_parameter_t *parameter,
- call_argument_t *argument)
+ call_argument_t *argument, unsigned pos)
{
type_t *expected_type = parameter->type;
type_t *expected_type_skip = skip_typeref(expected_type);
assign_error_t error = ASSIGN_ERROR_INCOMPATIBLE;
expression_t *arg_expr = argument->expression;
+ type_t *arg_type = skip_typeref(arg_expr->base.type);
/* handle transparent union gnu extension */
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)
argument->expression = create_implicit_cast(argument->expression,
expected_type);
- /* TODO report exact scope in error messages (like "in 3rd parameter") */
- report_assign_error(error, expected_type, arg_expr, "function call",
- &arg_expr->base.source_position);
+ if (error != ASSIGN_SUCCESS) {
+ /* report exact scope in error messages (like "in argument 3") */
+ char buf[64];
+ snprintf(buf, sizeof(buf), "call argument %u", pos);
+ report_assign_error(error, expected_type, arg_expr, buf,
+ &arg_expr->base.source_position);
+ } else if (warning.traditional || warning.conversion) {
+ type_t *const promoted_type = get_default_promoted_type(arg_type);
+ if (!types_compatible(expected_type_skip, promoted_type) &&
+ !types_compatible(expected_type_skip, type_void_ptr) &&
+ !types_compatible(type_void_ptr, promoted_type)) {
+ /* Deliberately show the skipped types in this warning */
+ warningf(&arg_expr->base.source_position,
+ "passing call argument %u as '%T' rather than '%T' due to prototype",
+ pos, expected_type_skip, promoted_type);
+ }
+ }
}
/**
*
* @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;
-
- call_expression_t *call = &result->call;
- call->function = expression;
+ expression_t *result = allocate_expression_zero(EXPR_CALL);
+ call_expression_t *call = &result->call;
+ call->function = expression;
type_t *const orig_type = expression->base.type;
type_t *const type = skip_typeref(orig_type);
if (token.type != ')') {
call_argument_t *last_argument = NULL;
- while(true) {
+ while (true) {
call_argument_t *argument = allocate_ast_zero(sizeof(argument[0]));
argument->expression = parse_assignment_expression();
function_parameter_t *parameter = function_type->parameters;
call_argument_t *argument = call->arguments;
if (!function_type->unspecified_parameters) {
- for( ; parameter != NULL && argument != NULL;
+ for (unsigned pos = 0; parameter != NULL && argument != NULL;
parameter = parameter->next, argument = argument->next) {
- check_call_argument(parameter, argument);
+ check_call_argument(parameter, argument, ++pos);
}
if (parameter != NULL) {
check_format(&result->call);
- return result;
+ if (warning.aggregate_return &&
+ is_type_compound(skip_typeref(function_type->return_type))) {
+ warningf(&result->base.source_position,
+ "function call has aggregate value");
+ }
+
end_error:
- return create_invalid_expression();
+ return result;
}
static type_t *semantic_arithmetic(type_t *type_left, type_t *type_right);
return
is_type_compound(type1) &&
type1->kind == type2->kind &&
- type1->compound.declaration == type2->compound.declaration;
+ type1->compound.compound == type2->compound.compound;
+}
+
+static expression_t const *get_reference_address(expression_t const *expr)
+{
+ bool regular_take_address = true;
+ for (;;) {
+ if (expr->kind == EXPR_UNARY_TAKE_ADDRESS) {
+ expr = expr->unary.value;
+ } else {
+ regular_take_address = false;
+ }
+
+ if (expr->kind != EXPR_UNARY_DEREFERENCE)
+ break;
+
+ expr = expr->unary.value;
+ }
+
+ if (expr->kind != EXPR_REFERENCE)
+ 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->reference.entity->kind != ENTITY_FUNCTION) {
+ return NULL;
+ }
+
+ return expr;
+}
+
+static void warn_reference_address_as_bool(expression_t const* expr)
+{
+ if (!warning.address)
+ return;
+
+ expr = get_reference_address(expr);
+ if (expr != NULL) {
+ warningf(&expr->base.source_position,
+ "the address of '%Y' will always evaluate as 'true'",
+ expr->reference.entity->base.symbol);
+ }
}
/**
*
* @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)
{
- eat('?');
- add_anchor_token(':');
-
expression_t *result = allocate_expression_zero(EXPR_CONDITIONAL);
conditional_expression_t *conditional = &result->conditional;
- conditional->condition = expression;
+ conditional->condition = expression;
+
+ warn_reference_address_as_bool(expression);
+
+ eat('?');
+ add_anchor_token(':');
/* 6.5.15.2 */
type_t *const condition_type_orig = expression->base.type;
&expression->base.source_position, condition_type_orig);
}
- expression_t *true_expression = parse_expression();
+ expression_t *true_expression = expression;
+ bool gnu_cond = false;
+ if (GNU_MODE && token.type == ':') {
+ gnu_cond = true;
+ } 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(&expression->base.source_position,
- "ISO C forbids conditional expression with only one void side");
+ 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;
}
- 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(&expression->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;
}
- type_t *const copy = duplicate_type(to);
- copy->base.qualifiers = to1->base.qualifiers | to2->base.qualifiers;
-
- type_t *const type = typehash_insert(copy);
- if (type != copy)
- free_type(copy);
-
+ type_t *const type =
+ 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(&expression->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",
- &expression->base.source_position, true_type,
+ &conditional->base.source_position, true_type,
false_type);
}
result_type = type_error_type;
}
conditional->true_expression
- = create_implicit_cast(true_expression, result_type);
+ = gnu_cond ? NULL : create_implicit_cast(true_expression, result_type);
conditional->false_expression
= create_implicit_cast(false_expression, result_type);
conditional->base.type = result_type;
/**
* Parse an extension expression.
*/
-static expression_t *parse_extension(unsigned precedence)
+static expression_t *parse_extension(void)
{
eat(T___extension__);
- /* TODO enable extensions */
- expression_t *expression = parse_sub_expression(precedence);
- /* TODO disable extensions */
+ bool old_gcc_extension = in_gcc_extension;
+ in_gcc_extension = true;
+ 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);
-
expression_t *result = allocate_expression_zero(EXPR_CLASSIFY_TYPE);
result->base.type = type_int;
+ 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();
}
-static void check_pointer_arithmetic(const source_position_t *source_position,
+/**
+ * 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.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.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)
{
type_t *points_to = pointer_type->pointer.points_to;
points_to = skip_typeref(points_to);
- if (is_type_incomplete(points_to) &&
- (! (c_mode & _GNUC)
- || !is_type_atomic(points_to, ATOMIC_TYPE_VOID))) {
- errorf(source_position,
- "arithmetic with pointer to incomplete type '%T' not allowed",
- orig_pointer_type);
+ if (is_type_incomplete(points_to)) {
+ if (!GNU_MODE || !is_type_atomic(points_to, ATOMIC_TYPE_VOID)) {
+ errorf(source_position,
+ "arithmetic with pointer to incomplete type '%T' not allowed",
+ orig_pointer_type);
+ return false;
+ } else if (warning.pointer_arith) {
+ warningf(source_position,
+ "pointer of type '%T' used in arithmetic",
+ orig_pointer_type);
+ }
} else if (is_type_function(points_to)) {
- errorf(source_position,
- "arithmetic with pointer to function type '%T' not allowed",
- orig_pointer_type);
+ if (!GNU_MODE) {
+ errorf(source_position,
+ "arithmetic with pointer to function type '%T' not allowed",
+ orig_pointer_type);
+ return false;
+ } else if (warning.pointer_arith) {
+ warningf(source_position,
+ "pointer to a function '%T' used in arithmetic",
+ orig_pointer_type);
+ }
+ }
+ return true;
+}
+
+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:
+ case EXPR_SELECT:
+ case EXPR_UNARY_DEREFERENCE:
+ return true;
+
+ default:
+ /* 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));
}
}
type_t *const orig_type = expression->value->base.type;
type_t *const type = skip_typeref(orig_type);
if (is_type_pointer(type)) {
- check_pointer_arithmetic(&expression->base.source_position,
- type, orig_type);
+ if (!check_pointer_arithmetic(&expression->base.source_position,
+ type, orig_type)) {
+ return;
+ }
} else if (!is_type_real(type) && is_type_valid(type)) {
/* TODO: improve error message */
- errorf(HERE, "operation needs an arithmetic or pointer type");
+ errorf(&expression->base.source_position,
+ "operation needs an arithmetic or pointer type");
+ return;
+ }
+ if (!is_lvalue(expression->value)) {
+ /* TODO: improve error message */
+ errorf(&expression->base.source_position, "lvalue required as operand");
}
expression->base.type = orig_type;
}
if (!is_type_arithmetic(type)) {
if (is_type_valid(type)) {
/* TODO: improve error message */
- errorf(HERE, "operation needs an arithmetic type");
+ errorf(&expression->base.source_position,
+ "operation needs an arithmetic type");
}
return;
}
expression->base.type = orig_type;
}
-static void semantic_unexpr_scalar(unary_expression_t *expression)
+static void semantic_unexpr_plus(unary_expression_t *expression)
+{
+ semantic_unexpr_arithmetic(expression);
+ if (warning.traditional)
+ warningf(&expression->base.source_position,
+ "traditional C rejects the unary plus operator");
+}
+
+static void semantic_not(unary_expression_t *expression)
{
type_t *const orig_type = expression->value->base.type;
type_t *const type = skip_typeref(orig_type);
- if (!is_type_scalar(type)) {
- if (is_type_valid(type)) {
- errorf(HERE, "operand of ! must be of scalar type");
- }
- return;
+ if (!is_type_scalar(type) && is_type_valid(type)) {
+ errorf(&expression->base.source_position,
+ "operand of ! must be of scalar type");
}
- expression->base.type = orig_type;
+ warn_reference_address_as_bool(expression->value);
+
+ expression->base.type = c_mode & _CXX ? type_bool : type_int;
}
static void semantic_unexpr_integer(unary_expression_t *expression)
type_t *const type = skip_typeref(orig_type);
if (!is_type_integer(type)) {
if (is_type_valid(type)) {
- errorf(HERE, "operand of ~ must be of integer type");
+ errorf(&expression->base.source_position,
+ "operand of ~ must be of integer type");
}
return;
}
type_t *const type = skip_typeref(orig_type);
if (!is_type_pointer(type)) {
if (is_type_valid(type)) {
- errorf(HERE, "Unary '*' needs pointer or arrray type, but type '%T' given", orig_type);
+ errorf(&expression->base.source_position,
+ "Unary '*' needs pointer or array type, but type '%T' given", orig_type);
}
return;
}
expression->base.type = result_type;
}
+/**
+ * Record that an address is taken (expression represents an lvalue).
+ *
+ * @param expression the expression
+ * @param may_be_register if true, the expression might be an register
+ */
static void set_address_taken(expression_t *expression, bool may_be_register)
{
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 (!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) \
-{ \
- eat(token_type); \
- \
- expression_t *unary_expression \
- = allocate_expression_zero(unexpression_type); \
- unary_expression->base.source_position = *HERE; \
- 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); \
+ 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,
semantic_unexpr_arithmetic)
CREATE_UNARY_EXPRESSION_PARSER('+', EXPR_UNARY_PLUS,
- semantic_unexpr_arithmetic)
+ semantic_unexpr_plus)
CREATE_UNARY_EXPRESSION_PARSER('!', EXPR_UNARY_NOT,
- semantic_unexpr_scalar)
+ semantic_not)
CREATE_UNARY_EXPRESSION_PARSER('*', EXPR_UNARY_DEREFERENCE,
semantic_dereference)
CREATE_UNARY_EXPRESSION_PARSER('&', EXPR_UNARY_TAKE_ADDRESS,
#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; \
- eat(token_type); \
- \
expression_t *unary_expression \
= allocate_expression_zero(unexpression_type); \
+ eat(token_type); \
unary_expression->unary.value = left; \
\
sfunc(&unary_expression->unary); \
{
/* TODO: handle complex + imaginary types */
+ type_left = get_unqualified_type(type_left);
+ type_right = get_unqualified_type(type_right);
+
/* § 6.3.1.8 Usual arithmetic conversions */
if (type_left == type_long_double || type_right == type_long_double) {
return type_long_double;
return type_float;
}
- type_right = promote_integer(type_right);
type_left = promote_integer(type_left);
+ type_right = promote_integer(type_right);
if (type_left == type_right)
return type_left;
- bool signed_left = is_type_signed(type_left);
- bool signed_right = is_type_signed(type_right);
- int rank_left = get_rank(type_left);
- int rank_right = get_rank(type_right);
- if (rank_left < rank_right) {
- if (signed_left == signed_right || !signed_right) {
- return type_right;
- } else {
- return type_left;
- }
+ bool const signed_left = is_type_signed(type_left);
+ bool const signed_right = is_type_signed(type_right);
+ int const rank_left = get_rank(type_left);
+ int const rank_right = get_rank(type_right);
+
+ if (signed_left == signed_right)
+ return rank_left >= rank_right ? type_left : type_right;
+
+ int s_rank;
+ int u_rank;
+ type_t *s_type;
+ type_t *u_type;
+ if (signed_left) {
+ s_rank = rank_left;
+ s_type = type_left;
+ u_rank = rank_right;
+ u_type = type_right;
} else {
- if (signed_left == signed_right || !signed_left) {
- return type_left;
- } else {
- return type_right;
- }
+ s_rank = rank_right;
+ s_type = type_right;
+ u_rank = rank_left;
+ u_type = type_left;
+ }
+
+ if (u_rank >= s_rank)
+ return u_type;
+
+ /* casting rank to atomic_type_kind is a bit hacky, but makes things
+ * easier here... */
+ if (get_atomic_type_size((atomic_type_kind_t) s_rank)
+ > get_atomic_type_size((atomic_type_kind_t) u_rank))
+ return s_type;
+
+ switch (s_rank) {
+ case ATOMIC_TYPE_INT: return type_unsigned_int;
+ case ATOMIC_TYPE_LONG: return type_unsigned_long;
+ case ATOMIC_TYPE_LONGLONG: return type_unsigned_long_long;
+
+ default: panic("invalid atomic type");
}
}
if (!is_type_arithmetic(type_left) || !is_type_arithmetic(type_right)) {
/* TODO: improve error message */
if (is_type_valid(type_left) && is_type_valid(type_right)) {
- errorf(HERE, "operation needs arithmetic types");
+ errorf(&expression->base.source_position,
+ "operation needs arithmetic types");
}
return;
}
expression->base.type = arithmetic_type;
}
+static void warn_div_by_zero(binary_expression_t const *const expression)
+{
+ if (!warning.div_by_zero ||
+ !is_type_integer(expression->base.type))
+ return;
+
+ expression_t const *const right = expression->right;
+ /* The type of the right operand can be different for /= */
+ if (is_type_integer(right->base.type) &&
+ is_constant_expression(right) &&
+ fold_constant(right) == 0) {
+ warningf(&expression->base.source_position, "division by zero");
+ }
+}
+
+/**
+ * Check the semantic restrictions for a div/mod expression.
+ */
+static void semantic_divmod_arithmetic(binary_expression_t *expression) {
+ semantic_binexpr_arithmetic(expression);
+ warn_div_by_zero(expression);
+}
+
static void semantic_shift_op(binary_expression_t *expression)
{
expression_t *const left = expression->left;
if (!is_type_integer(type_left) || !is_type_integer(type_right)) {
/* TODO: improve error message */
if (is_type_valid(type_left) && is_type_valid(type_right)) {
- errorf(HERE, "operation needs integer types");
+ errorf(&expression->base.source_position,
+ "operands of shift operation must have integer types");
}
return;
}
static void semantic_sub(binary_expression_t *expression)
{
- expression_t *const left = expression->left;
- expression_t *const right = expression->right;
- type_t *const orig_type_left = left->base.type;
- type_t *const orig_type_right = right->base.type;
- type_t *const type_left = skip_typeref(orig_type_left);
- type_t *const type_right = skip_typeref(orig_type_right);
+ expression_t *const left = expression->left;
+ expression_t *const right = expression->right;
+ type_t *const orig_type_left = left->base.type;
+ type_t *const orig_type_right = right->base.type;
+ type_t *const type_left = skip_typeref(orig_type_left);
+ type_t *const type_right = skip_typeref(orig_type_right);
+ source_position_t const *const pos = &expression->base.source_position;
/* § 5.6.5 */
if (is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
type_t *const unqual_left = get_unqualified_type(skip_typeref(type_left->pointer.points_to));
type_t *const unqual_right = get_unqualified_type(skip_typeref(type_right->pointer.points_to));
if (!types_compatible(unqual_left, unqual_right)) {
- errorf(&expression->base.source_position,
+ errorf(pos,
"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(&expression->base.source_position,
- "subtracting pointers to void");
- } else {
- errorf(&expression->base.source_position,
- "subtracting pointers to non-object types '%T'",
+ 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;
} else if (is_type_valid(type_left) && is_type_valid(type_right)) {
- errorf(HERE, "invalid operands of types '%T' and '%T' to binary '-'",
+ errorf(pos, "invalid operands of types '%T' and '%T' to binary '-'",
orig_type_left, orig_type_right);
}
}
+static void warn_string_literal_address(expression_t const* expr)
+{
+ while (expr->kind == EXPR_UNARY_TAKE_ADDRESS) {
+ expr = expr->unary.value;
+ if (expr->kind != EXPR_UNARY_DEREFERENCE)
+ return;
+ expr = expr->unary.value;
+ }
+
+ if (expr->kind == EXPR_STRING_LITERAL ||
+ expr->kind == EXPR_WIDE_STRING_LITERAL) {
+ warningf(&expr->base.source_position,
+ "comparison with string literal results in unspecified behaviour");
+ }
+}
+
/**
* Check the semantics of comparison expressions.
*
*/
static void semantic_comparison(binary_expression_t *expression)
{
- expression_t *left = expression->left;
- expression_t *right = expression->right;
- type_t *orig_type_left = left->base.type;
- type_t *orig_type_right = right->base.type;
+ expression_t *left = expression->left;
+ expression_t *right = expression->right;
- type_t *type_left = skip_typeref(orig_type_left);
- type_t *type_right = skip_typeref(orig_type_right);
+ if (warning.address) {
+ warn_string_literal_address(left);
+ warn_string_literal_address(right);
+
+ 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.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.entity->base.symbol);
+ }
+ }
+
+ type_t *orig_type_left = left->base.type;
+ type_t *orig_type_right = right->base.type;
+ type_t *type_left = skip_typeref(orig_type_left);
+ type_t *type_right = skip_typeref(orig_type_right);
/* TODO non-arithmetic types */
if (is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
&expression->base.source_position,
type_left, type_right);
}
- expression->base.type = type_int;
+ expression->base.type = c_mode & _CXX ? type_bool : type_int;
}
/**
*/
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;
-}
-
-static bool is_lvalue(const expression_t *expression)
-{
- switch (expression->kind) {
- case EXPR_REFERENCE:
- case EXPR_ARRAY_ACCESS:
- case EXPR_SELECT:
- case EXPR_UNARY_DEREFERENCE:
- return true;
- default:
- return false;
- }
+ return false;
}
static bool is_valid_assignment_lhs(expression_t const* const left)
if (!is_type_arithmetic(type_left) || !is_type_arithmetic(type_right)) {
/* TODO: improve error message */
if (is_type_valid(type_left) && is_type_valid(type_right)) {
- errorf(HERE, "operation needs arithmetic types");
+ errorf(&expression->base.source_position,
+ "operation needs arithmetic types");
}
return;
}
expression->base.type = type_left;
}
+static void semantic_divmod_assign(binary_expression_t *expression)
+{
+ semantic_arithmetic_assign(expression);
+ warn_div_by_zero(expression);
+}
+
static void semantic_arithmetic_addsubb_assign(binary_expression_t *expression)
{
expression_t *const left = expression->left;
type_left, orig_type_left);
expression->base.type = type_left;
} else if (is_type_valid(type_left) && is_type_valid(type_right)) {
- errorf(HERE, "incompatible types '%T' and '%T' in assignment", orig_type_left, orig_type_right);
+ errorf(&expression->base.source_position,
+ "incompatible types '%T' and '%T' in assignment",
+ orig_type_left, orig_type_right);
}
}
type_t *const type_left = skip_typeref(orig_type_left);
type_t *const type_right = skip_typeref(orig_type_right);
+ warn_reference_address_as_bool(left);
+ warn_reference_address_as_bool(right);
+
if (!is_type_scalar(type_left) || !is_type_scalar(type_right)) {
/* TODO: improve error message */
if (is_type_valid(type_left) && is_type_valid(type_right)) {
- errorf(HERE, "operation needs scalar types");
+ errorf(&expression->base.source_position,
+ "operation needs scalar types");
}
return;
}
- expression->base.type = type_int;
+ expression->base.type = c_mode & _CXX ? type_bool : type_int;
}
/**
expression_t *left = expression->left;
type_t *orig_type_left = left->base.type;
- type_t *type_left = revert_automatic_type_conversion(left);
- type_left = skip_typeref(orig_type_left);
-
if (!is_valid_assignment_lhs(left))
return;
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_WIDE_CHARACTER_CONSTANT: return false;
case EXPR_STRING_LITERAL: return false;
case EXPR_WIDE_STRING_LITERAL: return false;
+ case EXPR_LABEL_ADDRESS: return false;
case EXPR_CALL: {
const call_expression_t *const call = &expr->call;
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) \
-{ \
- eat(token_type); \
- source_position_t pos = *HERE; \
- \
- expression_t *right = parse_sub_expression(precedence + lr); \
- \
- expression_t *binexpr = allocate_expression_zero(binexpression_type); \
- binexpr->base.source_position = pos; \
- binexpr->binary.left = left; \
- 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_binexpr_arithmetic, 1)
-CREATE_BINEXPR_PARSER('%', EXPR_BINARY_MOD, semantic_binexpr_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_arithmetic_assign, 0)
-CREATE_BINEXPR_PARSER(T_PERCENTEQUAL, EXPR_BINARY_MOD_ASSIGN,
- semantic_arithmetic_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->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);
}
/**
*/
static asm_argument_t *parse_asm_arguments(bool is_out)
{
- asm_argument_t *result = NULL;
- asm_argument_t *last = NULL;
+ asm_argument_t *result = NULL;
+ asm_argument_t **anchor = &result;
while (token.type == T_STRING_LITERAL || token.type == '[') {
asm_argument_t *argument = allocate_ast_zero(sizeof(argument[0]));
argument->constraints = parse_string_literals();
expect('(');
+ add_anchor_token(')');
expression_t *expression = parse_expression();
- argument->expression = expression;
- if (is_out && !is_lvalue(expression)) {
- errorf(&expression->base.source_position,
- "asm output argument is not an lvalue");
+ rem_anchor_token(')');
+ if (is_out) {
+ /* Ugly GCC stuff: Allow lvalue casts. Skip casts, when they do not
+ * change size or type representation (e.g. int -> long is ok, but
+ * int -> float is not) */
+ if (expression->kind == EXPR_UNARY_CAST) {
+ type_t *const type = expression->base.type;
+ type_kind_t const kind = type->kind;
+ if (kind == TYPE_ATOMIC || kind == TYPE_POINTER) {
+ unsigned flags;
+ unsigned size;
+ if (kind == TYPE_ATOMIC) {
+ atomic_type_kind_t const akind = type->atomic.akind;
+ flags = get_atomic_type_flags(akind) & ~ATOMIC_TYPE_FLAG_SIGNED;
+ size = get_atomic_type_size(akind);
+ } else {
+ flags = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC;
+ size = get_atomic_type_size(get_intptr_kind());
+ }
+
+ do {
+ expression_t *const value = expression->unary.value;
+ type_t *const value_type = value->base.type;
+ type_kind_t const value_kind = value_type->kind;
+
+ unsigned value_flags;
+ unsigned value_size;
+ if (value_kind == TYPE_ATOMIC) {
+ atomic_type_kind_t const value_akind = value_type->atomic.akind;
+ value_flags = get_atomic_type_flags(value_akind) & ~ATOMIC_TYPE_FLAG_SIGNED;
+ value_size = get_atomic_type_size(value_akind);
+ } else if (value_kind == TYPE_POINTER) {
+ value_flags = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC;
+ value_size = get_atomic_type_size(get_intptr_kind());
+ } else {
+ break;
+ }
+
+ if (value_flags != flags || value_size != size)
+ break;
+
+ expression = value;
+ } while (expression->kind == EXPR_UNARY_CAST);
+ }
+ }
+
+ if (!is_lvalue(expression)) {
+ 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(')');
set_address_taken(expression, true);
- if (last != NULL) {
- last->next = argument;
- } else {
- result = argument;
- }
- last = argument;
+ *anchor = argument;
+ anchor = &argument->next;
if (token.type != ',')
break;
*/
static statement_t *parse_asm_statement(void)
{
- eat(T_asm);
-
- statement_t *statement = allocate_statement_zero(STATEMENT_ASM);
- statement->base.source_position = token.source_position;
-
+ statement_t *statement = allocate_statement_zero(STATEMENT_ASM);
asm_statement_t *asm_statement = &statement->asms;
+ eat(T_asm);
+
if (token.type == T_volatile) {
next_token();
asm_statement->is_volatile = true;
rem_anchor_token(')');
expect(')');
expect(';');
+
+ if (asm_statement->outputs == NULL) {
+ /* GCC: An 'asm' instruction without any output operands will be treated
+ * identically to a volatile 'asm' instruction. */
+ asm_statement->is_volatile = true;
+ }
+
return statement;
end_error:
return create_invalid_statement();
*/
static statement_t *parse_case_statement(void)
{
- eat(T_case);
+ statement_t *const statement = allocate_statement_zero(STATEMENT_CASE_LABEL);
+ source_position_t *const pos = &statement->base.source_position;
- statement_t *statement = allocate_statement_zero(STATEMENT_CASE_LABEL);
+ eat(T_case);
- statement->base.source_position = token.source_position;
- statement->case_label.expression = parse_expression();
+ expression_t *const expression = parse_expression();
+ statement->case_label.expression = expression;
+ if (!is_constant_expression(expression)) {
+ /* 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(skip_typeref(expression->base.type))) {
+ errorf(pos, "case label does not reduce to an integer constant");
+ }
+ statement->case_label.is_bad = true;
+ } else {
+ long const val = fold_constant(expression);
+ statement->case_label.first_case = val;
+ statement->case_label.last_case = val;
+ }
- if (c_mode & _GNUC) {
+ if (GNU_MODE) {
if (token.type == T_DOTDOTDOT) {
next_token();
- statement->case_label.end_range = parse_expression();
+ expression_t *const end_range = parse_expression();
+ statement->case_label.end_range = end_range;
+ if (!is_constant_expression(end_range)) {
+ /* 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(skip_typeref(end_range->base.type))) {
+ errorf(pos, "case range does not reduce to an integer constant");
+ }
+ statement->case_label.is_bad = true;
+ } else {
+ long const val = fold_constant(end_range);
+ statement->case_label.last_case = val;
+
+ if (warning.other && val < statement->case_label.first_case) {
+ statement->case_label.is_empty_range = true;
+ warningf(pos, "empty range specified");
+ }
+ }
}
}
+ PUSH_PARENT(statement);
+
expect(':');
- if (! is_constant_expression(statement->case_label.expression)) {
- errorf(&statement->base.source_position,
- "case label does not reduce to an integer constant");
- } else {
- /* TODO: check if the case label is already known */
- if (current_switch != NULL) {
- /* link all cases into the switch statement */
- if (current_switch->last_case == NULL) {
- current_switch->first_case =
- current_switch->last_case = &statement->case_label;
- } else {
- current_switch->last_case->next = &statement->case_label;
+ if (current_switch != NULL) {
+ if (! statement->case_label.is_bad) {
+ /* Check for duplicate case values */
+ case_label_statement_t *c = &statement->case_label;
+ for (case_label_statement_t *l = current_switch->first_case; l != NULL; l = l->next) {
+ if (l->is_bad || l->is_empty_range || l->expression == NULL)
+ continue;
+
+ if (c->last_case < l->first_case || c->first_case > l->last_case)
+ continue;
+
+ errorf(pos, "duplicate case value (previously used %P)",
+ &l->base.source_position);
+ break;
}
+ }
+ /* link all cases into the switch statement */
+ if (current_switch->last_case == NULL) {
+ current_switch->first_case = &statement->case_label;
} else {
- errorf(&statement->base.source_position,
- "case label not within a switch statement");
+ current_switch->last_case->next = &statement->case_label;
}
+ current_switch->last_case = &statement->case_label;
+ } else {
+ errorf(pos, "case label not within a switch statement");
+ }
+
+ statement_t *const inner_stmt = parse_statement();
+ statement->case_label.statement = inner_stmt;
+ if (inner_stmt->kind == STATEMENT_DECLARATION) {
+ errorf(&inner_stmt->base.source_position, "declaration after case label");
}
- statement->case_label.statement = parse_statement();
+ POP_PARENT;
return statement;
end_error:
+ POP_PARENT;
return create_invalid_statement();
}
-/**
- * Finds an existing default label of a switch statement.
- */
-static case_label_statement_t *
-find_default_label(const switch_statement_t *statement)
-{
- case_label_statement_t *label = statement->first_case;
- for ( ; label != NULL; label = label->next) {
- if (label->expression == NULL)
- return label;
- }
- return NULL;
-}
-
/**
* Parse a default statement.
*/
static statement_t *parse_default_statement(void)
{
- eat(T_default);
-
statement_t *statement = allocate_statement_zero(STATEMENT_CASE_LABEL);
- statement->base.source_position = token.source_position;
+ eat(T_default);
+
+ PUSH_PARENT(statement);
expect(':');
if (current_switch != NULL) {
- const case_label_statement_t *def_label = find_default_label(current_switch);
+ const case_label_statement_t *def_label = current_switch->default_label;
if (def_label != NULL) {
errorf(HERE, "multiple default labels in one switch (previous declared %P)",
&def_label->base.source_position);
} else {
+ current_switch->default_label = &statement->case_label;
+
/* link all cases into the switch statement */
if (current_switch->last_case == NULL) {
- current_switch->first_case =
- current_switch->last_case = &statement->case_label;
+ current_switch->first_case = &statement->case_label;
} else {
current_switch->last_case->next = &statement->case_label;
}
+ current_switch->last_case = &statement->case_label;
}
} else {
errorf(&statement->base.source_position,
"'default' label not within a switch statement");
}
- statement->case_label.statement = parse_statement();
+ statement_t *const inner_stmt = parse_statement();
+ statement->case_label.statement = inner_stmt;
+ if (inner_stmt->kind == STATEMENT_DECLARATION) {
+ errorf(&inner_stmt->base.source_position, "declaration after default label");
+ }
+
+ POP_PARENT;
return statement;
end_error:
+ POP_PARENT;
return create_invalid_statement();
}
-/**
- * Return the declaration for a given label symbol or create a new one.
- */
-static declaration_t *get_label(symbol_t *symbol)
-{
- declaration_t *candidate = get_declaration(symbol, NAMESPACE_LABEL);
- assert(current_function != NULL);
- /* 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;
- }
-
- /* otherwise we need to create a new one */
- declaration_t *const declaration = allocate_declaration_zero();
- declaration->namespc = NAMESPACE_LABEL;
- declaration->symbol = symbol;
-
- label_push(declaration);
-
- return declaration;
-}
-
/**
* Parse a label statement.
*/
{
assert(token.type == T_IDENTIFIER);
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;
+
next_token();
- declaration_t *label = get_label(symbol);
+ PUSH_PARENT(statement);
- /* if source position is already set then the label is defined twice,
- * otherwise it was just mentioned in a goto so far */
- if (label->source_position.input_name != NULL) {
+ /* 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->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->base.source_position = token.source_position;
+ label->statement = statement;
}
- statement_t *statement = allocate_statement_zero(STATEMENT_LABEL);
-
- statement->base.source_position = token.source_position;
- statement->label.label = label;
-
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 {
errorf(HERE, "label at end of compound statement");
statement->label.statement = create_invalid_statement();
}
- return statement;
+ } else if (token.type == ';') {
+ /* Eat an empty statement here, to avoid the warning about an empty
+ * statement after a label. label:; is commonly used to have a label
+ * before a closing brace. */
+ statement->label.statement = create_empty_statement();
+ next_token();
} else {
- if (token.type == ';') {
- /* eat an empty statement here, to avoid the warning about an empty
- * after a label. label:; is commonly used to have a label before
- * a }. */
- statement->label.statement = create_empty_statement();
- next_token();
- } else {
- statement->label.statement = parse_statement();
+ statement_t *const inner_stmt = parse_statement();
+ statement->label.statement = inner_stmt;
+ if (inner_stmt->kind == STATEMENT_DECLARATION) {
+ errorf(&inner_stmt->base.source_position, "declaration after label");
}
}
- /* remember the labels's in a list for later checking */
- if (label_last == NULL) {
- label_first = &statement->label;
- } else {
- label_last->next = &statement->label;
- }
- label_last = &statement->label;
+ /* remember the labels in a list for later checking */
+ *label_anchor = &statement->label;
+ label_anchor = &statement->label.next;
+ POP_PARENT;
return statement;
}
*/
static statement_t *parse_if(void)
{
+ statement_t *statement = allocate_statement_zero(STATEMENT_IF);
+
eat(T_if);
- statement_t *statement = allocate_statement_zero(STATEMENT_IF);
- statement->base.source_position = token.source_position;
+ 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;
+ warn_reference_address_as_bool(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);
statement->ifs.false_statement = parse_statement();
}
+ POP_PARENT;
return statement;
-end_error:
- return create_invalid_statement();
+}
+
+/**
+ * Check that all enums are handled in a switch.
+ *
+ * @param statement the switch statement to check
+ */
+static void check_enum_cases(const switch_statement_t *statement) {
+ const type_t *type = skip_typeref(statement->expression->base.type);
+ if (! is_type_enum(type))
+ return;
+ const enum_type_t *enumt = &type->enumt;
+
+ /* if we have a default, no warnings */
+ if (statement->default_label != NULL)
+ return;
+
+ /* FIXME: calculation of value should be done while parsing */
+ /* 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 (l->expression == NULL)
+ continue;
+ if (l->first_case <= value && value <= l->last_case) {
+ found = true;
+ break;
+ }
+ }
+ if (! found) {
+ warningf(&statement->base.source_position,
+ "enumeration value '%Y' not handled in switch",
+ entry->base.symbol);
+ }
+ last_value = value;
+ }
}
/**
*/
static statement_t *parse_switch(void)
{
+ statement_t *statement = allocate_statement_zero(STATEMENT_SWITCH);
+
eat(T_switch);
- statement_t *statement = allocate_statement_zero(STATEMENT_SWITCH);
- statement->base.source_position = token.source_position;
+ PUSH_PARENT(statement);
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);
+ if (warning.traditional) {
+ if (get_rank(type) >= get_akind_rank(ATOMIC_TYPE_LONG)) {
+ warningf(&expr->base.source_position,
+ "'%T' switch expression not converted to '%T' in ISO C",
+ type, type_int);
+ }
+ }
} else if (is_type_valid(type)) {
errorf(&expr->base.source_position,
"switch quantity is not an integer, but '%T'", type);
}
statement->switchs.expression = create_implicit_cast(expr, type);
expect(')');
+ rem_anchor_token(')');
switch_statement_t *rem = current_switch;
current_switch = &statement->switchs;
current_switch = rem;
if (warning.switch_default &&
- find_default_label(&statement->switchs) == NULL) {
+ statement->switchs.default_label == NULL) {
warningf(&statement->base.source_position, "switch has no default case");
}
+ if (warning.switch_enum)
+ check_enum_cases(&statement->switchs);
+ POP_PARENT;
return statement;
end_error:
+ POP_PARENT;
return create_invalid_statement();
}
*/
static statement_t *parse_while(void)
{
+ statement_t *statement = allocate_statement_zero(STATEMENT_WHILE);
+
eat(T_while);
- statement_t *statement = allocate_statement_zero(STATEMENT_WHILE);
- statement->base.source_position = token.source_position;
+ PUSH_PARENT(statement);
expect('(');
add_anchor_token(')');
- statement->whiles.condition = parse_expression();
+ expression_t *const cond = parse_expression();
+ statement->whiles.condition = cond;
+ warn_reference_address_as_bool(cond);
+ mark_vars_read(cond, NULL);
rem_anchor_token(')');
expect(')');
statement->whiles.body = parse_loop_body(statement);
+ POP_PARENT;
return statement;
end_error:
+ POP_PARENT;
return create_invalid_statement();
}
*/
static statement_t *parse_do(void)
{
- eat(T_do);
-
statement_t *statement = allocate_statement_zero(STATEMENT_DO_WHILE);
- statement->base.source_position = token.source_position;
+ eat(T_do);
+
+ 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;
+ warn_reference_address_as_bool(cond);
+ mark_vars_read(cond, NULL);
rem_anchor_token(')');
expect(')');
expect(';');
+ POP_PARENT;
return statement;
end_error:
+ POP_PARENT;
return create_invalid_statement();
}
*/
static statement_t *parse_for(void)
{
+ statement_t *statement = allocate_statement_zero(STATEMENT_FOR);
+
eat(T_for);
- statement_t *statement = allocate_statement_zero(STATEMENT_FOR);
- statement->base.source_position = token.source_position;
+ PUSH_PARENT(statement);
- int top = environment_top();
- scope_t *last_scope = scope;
- set_scope(&statement->fors.scope);
+ size_t const top = environment_top();
+ scope_push(&statement->fors.scope);
expect('(');
add_anchor_token(')');
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;
+ warn_reference_address_as_bool(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);
- set_scope(last_scope);
+ assert(current_scope == &statement->fors.scope);
+ scope_pop();
environment_pop_to(top);
+ POP_PARENT;
return statement;
end_error:
+ POP_PARENT;
rem_anchor_token(')');
- assert(scope == &statement->fors.scope);
- set_scope(last_scope);
+ assert(current_scope == &statement->fors.scope);
+ scope_pop();
environment_pop_to(top);
return create_invalid_statement();
*/
static statement_t *parse_goto(void)
{
+ statement_t *statement = allocate_statement_zero(STATEMENT_GOTO);
eat(T_goto);
- if (token.type != T_IDENTIFIER) {
- parse_error_expected("while parsing goto", T_IDENTIFIER, NULL);
- eat_statement();
- goto end_error;
- }
- symbol_t *symbol = token.v.symbol;
- next_token();
-
- declaration_t *label = get_label(symbol);
+ if (GNU_MODE && token.type == '*') {
+ next_token();
+ expression_t *expression = parse_expression();
+ mark_vars_read(expression, NULL);
- statement_t *statement = allocate_statement_zero(STATEMENT_GOTO);
- statement->base.source_position = token.source_position;
+ /* Argh: although documentation says the expression must be of type void*,
+ * gcc accepts anything that can be casted into void* without error */
+ type_t *type = expression->base.type;
- statement->gotos.label = label;
+ if (type != type_error_type) {
+ if (!is_type_pointer(type) && !is_type_integer(type)) {
+ errorf(&expression->base.source_position,
+ "cannot convert to a pointer type");
+ } else if (warning.other && type != type_void_ptr) {
+ warningf(&expression->base.source_position,
+ "type of computed goto expression should be 'void*' not '%T'", type);
+ }
+ expression = create_implicit_cast(expression, type_void_ptr);
+ }
- /* remember the goto's in a list for later checking */
- if (goto_last == NULL) {
- goto_first = &statement->gotos;
+ statement->gotos.expression = expression;
} else {
- goto_last->next = &statement->gotos;
+ if (token.type != T_IDENTIFIER) {
+ if (GNU_MODE)
+ parse_error_expected("while parsing goto", T_IDENTIFIER, '*', NULL);
+ else
+ parse_error_expected("while parsing goto", T_IDENTIFIER, NULL);
+ eat_until_anchor();
+ goto end_error;
+ }
+ symbol_t *symbol = token.v.symbol;
+ next_token();
+
+ statement->gotos.label = get_label(symbol);
}
- goto_last = &statement->gotos;
+
+ /* remember the goto's in a list for later checking */
+ *goto_anchor = &statement->gotos;
+ goto_anchor = &statement->gotos.next;
expect(';');
*/
static statement_t *parse_continue(void)
{
- statement_t *statement;
- if (current_loop == NULL) {
- errorf(HERE, "continue statement not within loop");
- statement = create_invalid_statement();
- } else {
- statement = allocate_statement_zero(STATEMENT_CONTINUE);
-
- statement->base.source_position = token.source_position;
+ if (current_loop == NULL) {
+ errorf(HERE, "continue statement not within loop");
}
+ statement_t *statement = allocate_statement_zero(STATEMENT_CONTINUE);
+
eat(T_continue);
expect(';');
- return statement;
end_error:
- return create_invalid_statement();
+ return statement;
}
/**
*/
static statement_t *parse_break(void)
{
- statement_t *statement;
if (current_switch == NULL && current_loop == NULL) {
errorf(HERE, "break statement not within loop or switch");
- statement = create_invalid_statement();
- } else {
- statement = allocate_statement_zero(STATEMENT_BREAK);
-
- statement->base.source_position = token.source_position;
}
+ statement_t *statement = allocate_statement_zero(STATEMENT_BREAK);
+
eat(T_break);
expect(';');
- return statement;
end_error:
- return create_invalid_statement();
+ return statement;
}
/**
* Parse a __leave statement.
*/
-static statement_t *parse_leave(void)
+static statement_t *parse_leave_statement(void)
{
- statement_t *statement;
if (current_try == NULL) {
errorf(HERE, "__leave statement not within __try");
- statement = create_invalid_statement();
- } else {
- statement = allocate_statement_zero(STATEMENT_LEAVE);
-
- statement->base.source_position = token.source_position;
}
+ statement_t *statement = allocate_statement_zero(STATEMENT_LEAVE);
+
eat(T___leave);
expect(';');
- return statement;
end_error:
- return create_invalid_statement();
+ return statement;
}
/**
- * 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) {
- switch ((storage_class_tag_t) declaration->storage_class) {
+static bool is_local_variable(const entity_t *entity)
+{
+ 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;
}
/**
*/
static statement_t *parse_return(void)
{
- statement_t *statement = allocate_statement_zero(STATEMENT_RETURN);
- statement->base.source_position = token.source_position;
-
eat(T_return);
+ statement_t *statement = allocate_statement_zero(STATEMENT_RETURN);
+
expression_t *return_value = NULL;
if (token.type != ';') {
return_value = parse_expression();
+ mark_vars_read(return_value, NULL);
}
- expect(';');
- const type_t *const func_type = current_function->type;
+ const type_t *const func_type = skip_typeref(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;
- return statement;
+ expect(';');
+
end_error:
- return create_invalid_statement();
+ return statement;
}
/**
{
statement_t *statement = allocate_statement_zero(STATEMENT_DECLARATION);
- statement->base.source_position = token.source_position;
-
- declaration_t *before = last_declaration;
- parse_declaration(record_declaration);
+ entity_t *before = current_scope->last_entity;
+ if (GNU_MODE)
+ parse_external_declaration();
+ else
+ parse_declaration(record_entity);
if (before == NULL) {
- statement->declaration.declarations_begin = scope->declarations;
+ statement->declaration.declarations_begin = current_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 = current_scope->last_entity;
return statement;
}
{
statement_t *statement = allocate_statement_zero(STATEMENT_EXPRESSION);
- statement->base.source_position = token.source_position;
expression_t *const expr = parse_expression();
statement->expression.expression = expr;
+ mark_vars_read(expr, VAR_ANY);
expect(';');
- return statement;
end_error:
- return create_invalid_statement();
+ return statement;
}
/**
* Parse a microsoft __try { } __finally { } or
* __try{ } __except() { }
*/
-static statement_t *parse_ms_try_statment(void) {
+static statement_t *parse_ms_try_statment(void)
+{
statement_t *statement = allocate_statement_zero(STATEMENT_MS_TRY);
-
- statement->base.source_position = token.source_position;
eat(T___try);
+ PUSH_PARENT(statement);
+
ms_try_statement_t *rem = current_try;
current_try = &statement->ms_try;
statement->ms_try.try_statement = parse_compound_statement(false);
current_try = rem;
+ POP_PARENT;
+
if (token.type == T___except) {
eat(T___except);
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 create_invalid_statement();
}
-/**
- * Parse a statement.
- * There's also parse_statement() which additionally checks for
- * "statement has no effect" warnings
- */
-static statement_t *intern_parse_statement(void)
+static statement_t *parse_empty_statement(void)
{
- statement_t *statement = NULL;
+ if (warning.empty_statement) {
+ warningf(HERE, "statement is empty");
+ }
+ statement_t *const statement = create_empty_statement();
+ eat(';');
+ return statement;
+}
- /* declaration or statement */
- add_anchor_token(';');
- switch(token.type) {
- case T_asm:
- statement = parse_asm_statement();
- break;
+static statement_t *parse_local_label_declaration(void)
+{
+ statement_t *statement = allocate_statement_zero(STATEMENT_DECLARATION);
- case T_case:
- statement = parse_case_statement();
- break;
+ eat(T___label__);
- case T_default:
- statement = parse_default_statement();
- break;
+ entity_t *begin = NULL, *end = NULL;
- case '{':
- statement = parse_compound_statement(false);
- break;
+ while (true) {
+ if (token.type != T_IDENTIFIER) {
+ parse_error_expected("while parsing local label declaration",
+ T_IDENTIFIER, NULL);
+ goto end_error;
+ }
+ symbol_t *symbol = token.v.symbol;
+ entity_t *entity = get_entity(symbol, NAMESPACE_LABEL);
+ if (entity != NULL && entity->base.parent_scope == current_scope) {
+ errorf(HERE, "multiple definitions of '__label__ %Y' (previous definition %P)",
+ symbol, &entity->base.source_position);
+ } else {
+ entity = allocate_entity_zero(ENTITY_LOCAL_LABEL);
- case T_if:
- statement = parse_if ();
- break;
+ entity->base.parent_scope = current_scope;
+ entity->base.namespc = NAMESPACE_LABEL;
+ entity->base.source_position = token.source_position;
+ entity->base.symbol = symbol;
- case T_switch:
- statement = parse_switch();
- break;
+ if (end != NULL)
+ end->base.next = entity;
+ end = entity;
+ if (begin == NULL)
+ begin = entity;
- case T_while:
- statement = parse_while();
- break;
+ environment_push(entity);
+ }
+ next_token();
- case T_do:
- statement = parse_do();
- break;
+ if (token.type != ',')
+ break;
+ next_token();
+ }
+ eat(';');
+end_error:
+ statement->declaration.declarations_begin = begin;
+ statement->declaration.declarations_end = end;
+ return statement;
+}
- case T_for:
- statement = parse_for();
- break;
+static void parse_namespace_definition(void)
+{
+ eat(T_namespace);
- case T_goto:
- statement = parse_goto();
- break;
+ entity_t *entity = NULL;
+ symbol_t *symbol = NULL;
- case T_continue:
- statement = parse_continue();
- break;
+ if (token.type == T_IDENTIFIER) {
+ symbol = token.v.symbol;
+ next_token();
- case T_break:
- statement = parse_break();
- break;
+ entity = get_entity(symbol, NAMESPACE_NORMAL);
+ if (entity != NULL && entity->kind != ENTITY_NAMESPACE
+ && entity->base.parent_scope == current_scope) {
+ error_redefined_as_different_kind(&token.source_position,
+ entity, ENTITY_NAMESPACE);
+ entity = NULL;
+ }
+ }
- case T___leave:
- statement = parse_leave();
- break;
+ if (entity == NULL) {
+ entity = allocate_entity_zero(ENTITY_NAMESPACE);
+ entity->base.symbol = symbol;
+ entity->base.source_position = token.source_position;
+ entity->base.namespc = NAMESPACE_NORMAL;
+ entity->base.parent_scope = current_scope;
+ }
- case T_return:
- statement = parse_return();
- break;
+ if (token.type == '=') {
+ /* TODO: parse namespace alias */
+ panic("namespace alias definition not supported yet");
+ }
- case ';':
- if (warning.empty_statement) {
- warningf(HERE, "statement is empty");
- }
- statement = create_empty_statement();
- next_token();
- break;
+ environment_push(entity);
+ append_entity(current_scope, entity);
- case T_IDENTIFIER:
- if (look_ahead(1)->type == ':') {
- statement = parse_label_statement();
- break;
- }
+ size_t const top = environment_top();
+ scope_push(&entity->namespacee.members);
- if (is_typedef_symbol(token.v.symbol)) {
+ expect('{');
+ parse_externals();
+ expect('}');
+
+end_error:
+ assert(current_scope == &entity->namespacee.members);
+ scope_pop();
+ environment_pop_to(top);
+}
+
+/**
+ * Parse a statement.
+ * There's also parse_statement() which additionally checks for
+ * "statement has no effect" warnings
+ */
+static statement_t *intern_parse_statement(void)
+{
+ statement_t *statement = NULL;
+
+ /* declaration or statement */
+ add_anchor_token(';');
+ switch (token.type) {
+ case T_IDENTIFIER: {
+ token_type_t la1_type = (token_type_t)look_ahead(1)->type;
+ if (la1_type == ':') {
+ statement = parse_label_statement();
+ } else if (is_typedef_symbol(token.v.symbol)) {
statement = parse_declaration_statement();
- break;
- }
+ } 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_entity(token.v.symbol, NAMESPACE_NORMAL) != NULL)
+ goto expression_statment;
+ /* FALLTHROUGH */
+
+ DECLARATION_START
+ case T_IDENTIFIER:
+ statement = parse_declaration_statement();
+ break;
- statement = parse_expression_statement();
+ default:
+expression_statment:
+ statement = parse_expression_statement();
+ break;
+ }
+ }
break;
+ }
case T___extension__:
- /* this can be a prefix to a declaration or an expression statement */
- /* we simply eat it now and parse the rest with tail recursion */
+ /* This can be a prefix to a declaration or an expression statement.
+ * We simply eat it now and parse the rest with tail recursion. */
do {
next_token();
- } while(token.type == T___extension__);
+ } while (token.type == T___extension__);
+ bool old_gcc_extension = in_gcc_extension;
+ in_gcc_extension = true;
statement = parse_statement();
+ in_gcc_extension = old_gcc_extension;
break;
DECLARATION_START
statement = parse_declaration_statement();
break;
- case T___try:
- statement = parse_ms_try_statment();
+ case T___label__:
+ statement = parse_local_label_declaration();
break;
- default:
+ case ';': statement = parse_empty_statement(); break;
+ case '{': statement = parse_compound_statement(false); break;
+ case T___leave: statement = parse_leave_statement(); break;
+ case T___try: statement = parse_ms_try_statment(); break;
+ case T_asm: statement = parse_asm_statement(); break;
+ case T_break: statement = parse_break(); break;
+ case T_case: statement = parse_case_statement(); break;
+ case T_continue: statement = parse_continue(); break;
+ case T_default: statement = parse_default_statement(); 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_return: statement = parse_return(); break;
+ case T_switch: statement = parse_switch(); break;
+ case T_while: statement = parse_while(); break;
+
+ EXPRESSION_START
statement = parse_expression_statement();
break;
+
+ default:
+ errorf(HERE, "unexpected token %K while parsing statement", &token);
+ statement = create_invalid_statement();
+ if (!at_anchor())
+ next_token();
+ break;
}
rem_anchor_token(';');
{
statement_t *statement = allocate_statement_zero(STATEMENT_COMPOUND);
- statement->base.source_position = token.source_position;
+ PUSH_PARENT(statement);
eat('{');
add_anchor_token('}');
- int top = environment_top();
- scope_t *last_scope = scope;
- set_scope(&statement->compound.scope);
-
- statement_t *last_statement = NULL;
+ size_t const top = environment_top();
+ scope_push(&statement->compound.scope);
- while(token.type != '}' && token.type != T_EOF) {
+ statement_t **anchor = &statement->compound.statements;
+ bool only_decls_so_far = true;
+ while (token.type != '}') {
+ if (token.type == T_EOF) {
+ errorf(&statement->base.source_position,
+ "EOF while parsing compound statement");
+ break;
+ }
statement_t *sub_statement = intern_parse_statement();
if (is_invalid_statement(sub_statement)) {
/* an error occurred. if we are at an anchor, return */
continue;
}
- if (last_statement != NULL) {
- last_statement->base.next = sub_statement;
- } else {
- statement->compound.statements = sub_statement;
+ if (warning.declaration_after_statement) {
+ if (sub_statement->kind != STATEMENT_DECLARATION) {
+ only_decls_so_far = false;
+ } else if (!only_decls_so_far) {
+ warningf(&sub_statement->base.source_position,
+ "ISO C90 forbids mixed declarations and code");
+ }
}
- while(sub_statement->base.next != NULL)
- sub_statement = sub_statement->base.next;
+ *anchor = sub_statement;
- last_statement = sub_statement;
- }
+ while (sub_statement->base.next != NULL)
+ sub_statement = sub_statement->base.next;
- if (token.type == '}') {
- next_token();
- } else {
- errorf(&statement->base.source_position,
- "end of file while looking for closing '}'");
+ anchor = &sub_statement->base.next;
}
+ next_token();
/* look over all statements again to produce no effect warnings */
if (warning.unused_value) {
end_error:
rem_anchor_token('}');
- assert(scope == &statement->compound.scope);
- set_scope(last_scope);
+ assert(current_scope == &statement->compound.scope);
+ scope_pop();
environment_pop_to(top);
+ POP_PARENT;
return statement;
}
-/**
- * Initialize builtin types.
- */
-static void initialize_builtin_types(void)
-{
- type_intmax_t = make_global_typedef("__intmax_t__", type_long_long);
- type_size_t = make_global_typedef("__SIZE_TYPE__", type_unsigned_long);
- type_ssize_t = make_global_typedef("__SSIZE_TYPE__", type_long);
- type_ptrdiff_t = make_global_typedef("__PTRDIFF_TYPE__", type_long);
- type_uintmax_t = make_global_typedef("__uintmax_t__", type_unsigned_long_long);
- type_uptrdiff_t = make_global_typedef("__UPTRDIFF_TYPE__", type_unsigned_long);
- type_wchar_t = make_global_typedef("__WCHAR_TYPE__", type_int);
- type_wint_t = make_global_typedef("__WINT_TYPE__", type_int);
-
- type_intmax_t_ptr = make_pointer_type(type_intmax_t, TYPE_QUALIFIER_NONE);
- type_ptrdiff_t_ptr = make_pointer_type(type_ptrdiff_t, TYPE_QUALIFIER_NONE);
- type_ssize_t_ptr = make_pointer_type(type_ssize_t, TYPE_QUALIFIER_NONE);
- type_wchar_t_ptr = make_pointer_type(type_wchar_t, TYPE_QUALIFIER_NONE);
-}
-
/**
* Check for unused global static functions and variables
*/
if (!warning.unused_function && !warning.unused_variable)
return;
- for (const declaration_t *decl = global_scope->declarations; decl != NULL; decl = decl->next) {
- if (decl->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;
+
+ 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 = decl->type;
+ 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);
+ }
+}
+
+static void parse_global_asm(void)
+{
+ statement_t *statement = allocate_statement_zero(STATEMENT_ASM);
+
+ eat(T_asm);
+ expect('(');
+
+ statement->asms.asm_text = parse_string_literals();
+ statement->base.next = unit->global_asm;
+ unit->global_asm = statement;
+
+ expect(')');
+ expect(';');
+
+end_error:;
+}
+
+static void parse_linkage_specification(void)
+{
+ eat(T_extern);
+ assert(token.type == T_STRING_LITERAL);
+
+ const char *linkage = parse_string_literals().begin;
+
+ linkage_kind_t old_linkage = current_linkage;
+ linkage_kind_t new_linkage;
+ if (strcmp(linkage, "C") == 0) {
+ new_linkage = LINKAGE_C;
+ } else if (strcmp(linkage, "C++") == 0) {
+ new_linkage = LINKAGE_CXX;
+ } else {
+ errorf(HERE, "linkage string \"%s\" not recognized", linkage);
+ new_linkage = LINKAGE_INVALID;
+ }
+ current_linkage = new_linkage;
+
+ if (token.type == '{') {
+ next_token();
+ parse_externals();
+ expect('}');
+ } else {
+ parse_external();
+ }
+
+end_error:
+ assert(current_linkage == new_linkage);
+ current_linkage = old_linkage;
+}
+
+static void parse_external(void)
+{
+ switch (token.type) {
+ DECLARATION_START_NO_EXTERN
+ case T_IDENTIFIER:
+ case T___extension__:
+ case '(': /* for function declarations with implicit return type and
+ * parenthesized declarator, i.e. (f)(void); */
+ parse_external_declaration();
+ return;
+
+ case T_extern:
+ if (look_ahead(1)->type == T_STRING_LITERAL) {
+ parse_linkage_specification();
+ } else {
+ parse_external_declaration();
+ }
+ return;
+
+ case T_asm:
+ parse_global_asm();
+ return;
+
+ case T_namespace:
+ parse_namespace_definition();
+ return;
+
+ case ';':
+ if (!strict_mode) {
+ if (warning.other)
+ warningf(HERE, "stray ';' outside of function");
+ next_token();
+ return;
+ }
+ /* FALLTHROUGH */
+
+ default:
+ errorf(HERE, "stray %K outside of function", &token);
+ if (token.type == '(' || token.type == '{' || token.type == '[')
+ eat_until_matching_token(token.type);
+ next_token();
+ return;
+ }
+}
+
+static void parse_externals(void)
+{
+ add_anchor_token('}');
+ add_anchor_token(T_EOF);
+
+#ifndef NDEBUG
+ unsigned char token_anchor_copy[T_LAST_TOKEN];
+ memcpy(token_anchor_copy, token_anchor_set, sizeof(token_anchor_copy));
+#endif
+
+ while (token.type != T_EOF && token.type != '}') {
+#ifndef NDEBUG
+ bool anchor_leak = false;
+ for (int i = 0; i != T_LAST_TOKEN; ++i) {
+ unsigned char count = token_anchor_set[i] - token_anchor_copy[i];
+ if (count != 0) {
+ errorf(HERE, "Leaked anchor token %k %d times", i, count);
+ anchor_leak = true;
+ }
+ }
+ if (in_gcc_extension) {
+ errorf(HERE, "Leaked __extension__");
+ anchor_leak = true;
+ }
+
+ if (anchor_leak)
+ abort();
+#endif
+
+ parse_external();
}
+
+ rem_anchor_token(T_EOF);
+ rem_anchor_token('}');
}
/**
*/
static void parse_translation_unit(void)
{
- while(token.type != T_EOF) {
- if (token.type == ';') {
- /* TODO error in strict mode */
- warningf(HERE, "stray ';' outside of function");
- next_token();
- } else {
- parse_external_declaration();
- }
+ add_anchor_token(T_EOF);
+
+ while (true) {
+ parse_externals();
+
+ if (token.type == T_EOF)
+ break;
+
+ errorf(HERE, "stray %K outside of function", &token);
+ if (token.type == '(' || token.type == '{' || token.type == '[')
+ eat_until_matching_token(token.type);
+ next_token();
}
}
assert(unit == NULL);
unit = allocate_ast_zero(sizeof(unit[0]));
- assert(global_scope == NULL);
- global_scope = &unit->scope;
+ assert(file_scope == NULL);
+ file_scope = &unit->scope;
- assert(scope == NULL);
- set_scope(&unit->scope);
-
- initialize_builtin_types();
+ assert(current_scope == NULL);
+ scope_push(&unit->scope);
}
translation_unit_t *finish_parsing(void)
{
- assert(scope == &unit->scope);
- scope = NULL;
- last_declaration = NULL;
+ /* do NOT use scope_pop() here, this will crash, will it by hand */
+ assert(current_scope == &unit->scope);
+ current_scope = NULL;
- assert(global_scope == &unit->scope);
+ assert(file_scope == &unit->scope);
check_unused_globals();
- global_scope = NULL;
+ file_scope = NULL;
DEL_ARR_F(environment_stack);
DEL_ARR_F(label_stack);
void parse(void)
{
lookahead_bufpos = 0;
- for(int i = 0; i < MAX_LOOKAHEAD + 2; ++i) {
+ for (int i = 0; i < MAX_LOOKAHEAD + 2; ++i) {
next_token();
}
+ current_linkage = c_mode & _CXX ? LINKAGE_CXX : LINKAGE_C;
parse_translation_unit();
}
*/
void init_parser(void)
{
+ sym_anonymous = symbol_table_insert("<anonymous>");
+
if (c_mode & _MS) {
/* add predefined symbols for extended-decl-modifier */
sym_align = symbol_table_insert("align");
projects / cparser / blobdiff