#include "adt/array.h"
//#define PRINT_TOKENS
-#define MAX_LOOKAHEAD 2
+#define MAX_LOOKAHEAD 1
typedef struct {
entity_t *old_entity;
typedef struct gnu_attribute_t gnu_attribute_t;
struct gnu_attribute_t {
- gnu_attribute_kind_t kind; /**< The kind of the GNU attribute. */
+ gnu_attribute_kind_t kind; /**< The kind of the GNU attribute. */
gnu_attribute_t *next;
- bool invalid; /**< Set if this attribute had argument errors, */
- bool have_arguments; /**< True, if this attribute has arguments. */
+ bool invalid; /**< Set if this attribute had argument errors, */
+ bool has_arguments; /**< True, if this attribute has arguments. */
union {
size_t value;
string_t string;
- atomic_type_kind_t akind;
+ symbol_t *symbol;
long argument; /**< Single argument. */
argument_list_t *arguments; /**< List of argument expressions. */
} u;
/** 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 size_t lookahead_bufpos;
static stack_entry_t *environment_stack = NULL;
static stack_entry_t *label_stack = NULL;
static scope_t *file_scope = NULL;
static bool in_gcc_extension = false;
static struct obstack temp_obst;
static entity_t *anonymous_entity;
+static declaration_t **incomplete_arrays;
#define PUSH_PARENT(stmt) \
static const symbol_t *sym_anonymous = NULL;
/* symbols for Microsoft extended-decl-modifier */
-static const symbol_t *sym_align = NULL;
-static const symbol_t *sym_allocate = NULL;
-static const symbol_t *sym_dllimport = NULL;
-static const symbol_t *sym_dllexport = NULL;
-static const symbol_t *sym_naked = NULL;
-static const symbol_t *sym_noinline = NULL;
-static const symbol_t *sym_noreturn = NULL;
-static const symbol_t *sym_nothrow = NULL;
-static const symbol_t *sym_novtable = NULL;
-static const symbol_t *sym_property = NULL;
-static const symbol_t *sym_get = NULL;
-static const symbol_t *sym_put = NULL;
-static const symbol_t *sym_selectany = NULL;
-static const symbol_t *sym_thread = NULL;
-static const symbol_t *sym_uuid = NULL;
-static const symbol_t *sym_deprecated = NULL;
-static const symbol_t *sym_restrict = NULL;
-static const symbol_t *sym_noalias = NULL;
+static const symbol_t *sym_align = NULL;
+static const symbol_t *sym_allocate = NULL;
+static const symbol_t *sym_dllimport = NULL;
+static const symbol_t *sym_dllexport = NULL;
+static const symbol_t *sym_naked = NULL;
+static const symbol_t *sym_noinline = NULL;
+static const symbol_t *sym_returns_twice = NULL;
+static const symbol_t *sym_noreturn = NULL;
+static const symbol_t *sym_nothrow = NULL;
+static const symbol_t *sym_novtable = NULL;
+static const symbol_t *sym_property = NULL;
+static const symbol_t *sym_get = NULL;
+static const symbol_t *sym_put = NULL;
+static const symbol_t *sym_selectany = NULL;
+static const symbol_t *sym_thread = NULL;
+static const symbol_t *sym_uuid = NULL;
+static const symbol_t *sym_deprecated = NULL;
+static const symbol_t *sym_restrict = NULL;
+static const symbol_t *sym_noalias = NULL;
/** The token anchor set */
static unsigned char token_anchor_set[T_LAST_TOKEN];
case T_union: \
case T_unsigned: \
case T_void: \
+ case T_wchar_t: \
COMPLEX_SPECIFIERS \
IMAGINARY_SPECIFIERS
return res;
}
+/**
+ * Returns the size of an entity node.
+ *
+ * @param kind the entity kind
+ */
static size_t get_entity_struct_size(entity_kind_t kind)
{
static const size_t sizes[] = {
[ENTITY_LOCAL_LABEL] = sizeof(label_t),
[ENTITY_NAMESPACE] = sizeof(namespace_t)
};
- assert(kind < sizeof(sizes) / sizeof(sizes[0]));
+ assert(kind < lengthof(sizes));
assert(sizes[kind] != 0);
return sizes[kind];
}
+/**
+ * Allocate an entity of given kind and initialize all
+ * fields with zero.
+ */
static entity_t *allocate_entity_zero(entity_kind_t kind)
{
size_t size = get_entity_struct_size(kind);
[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 < lengthof(sizes));
assert(sizes[kind] != 0);
return sizes[kind];
}
static size_t get_expression_struct_size(expression_kind_t 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_STRING_LITERAL] = sizeof(string_literal_expression_t),
- [EXPR_WIDE_STRING_LITERAL] = sizeof(wide_string_literal_expression_t),
- [EXPR_COMPOUND_LITERAL] = sizeof(compound_literal_expression_t),
- [EXPR_CALL] = sizeof(call_expression_t),
- [EXPR_UNARY_FIRST] = sizeof(unary_expression_t),
- [EXPR_BINARY_FIRST] = sizeof(binary_expression_t),
- [EXPR_CONDITIONAL] = sizeof(conditional_expression_t),
- [EXPR_SELECT] = sizeof(select_expression_t),
- [EXPR_ARRAY_ACCESS] = sizeof(array_access_expression_t),
- [EXPR_SIZEOF] = sizeof(typeprop_expression_t),
- [EXPR_ALIGNOF] = sizeof(typeprop_expression_t),
- [EXPR_CLASSIFY_TYPE] = sizeof(classify_type_expression_t),
- [EXPR_FUNCNAME] = sizeof(funcname_expression_t),
- [EXPR_BUILTIN_SYMBOL] = sizeof(builtin_symbol_expression_t),
- [EXPR_BUILTIN_CONSTANT_P] = sizeof(builtin_constant_expression_t),
- [EXPR_BUILTIN_PREFETCH] = sizeof(builtin_prefetch_expression_t),
- [EXPR_OFFSETOF] = sizeof(offsetof_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),
+ [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_STRING_LITERAL] = sizeof(string_literal_expression_t),
+ [EXPR_WIDE_STRING_LITERAL] = sizeof(wide_string_literal_expression_t),
+ [EXPR_COMPOUND_LITERAL] = sizeof(compound_literal_expression_t),
+ [EXPR_CALL] = sizeof(call_expression_t),
+ [EXPR_UNARY_FIRST] = sizeof(unary_expression_t),
+ [EXPR_BINARY_FIRST] = sizeof(binary_expression_t),
+ [EXPR_CONDITIONAL] = sizeof(conditional_expression_t),
+ [EXPR_SELECT] = sizeof(select_expression_t),
+ [EXPR_ARRAY_ACCESS] = sizeof(array_access_expression_t),
+ [EXPR_SIZEOF] = sizeof(typeprop_expression_t),
+ [EXPR_ALIGNOF] = sizeof(typeprop_expression_t),
+ [EXPR_CLASSIFY_TYPE] = sizeof(classify_type_expression_t),
+ [EXPR_FUNCNAME] = sizeof(funcname_expression_t),
+ [EXPR_BUILTIN_SYMBOL] = sizeof(builtin_symbol_expression_t),
+ [EXPR_BUILTIN_CONSTANT_P] = sizeof(builtin_constant_expression_t),
+ [EXPR_BUILTIN_TYPES_COMPATIBLE_P] = sizeof(builtin_types_compatible_expression_t),
+ [EXPR_OFFSETOF] = sizeof(offsetof_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 < lengthof(sizes));
assert(sizes[kind] != 0);
return sizes[kind];
}
/**
* Allocate a statement node of given kind and initialize all
- * fields with zero.
+ * fields with zero. Sets its source position to the position
+ * of the current token.
*/
static statement_t *allocate_statement_zero(statement_kind_t kind)
{
}
/**
- * Creates a new invalid expression.
+ * Creates a new invalid expression at the source position
+ * of the current token.
*/
static expression_t *create_invalid_expression(void)
{
[TYPE_TYPEDEF] = sizeof(typedef_type_t),
[TYPE_TYPEOF] = sizeof(typeof_type_t),
};
- assert(sizeof(sizes) / sizeof(sizes[0]) == (int) TYPE_TYPEOF + 1);
+ assert(lengthof(sizes) == (int)TYPE_TYPEOF + 1);
assert(kind <= TYPE_TYPEOF);
assert(sizes[kind] != 0);
return sizes[kind];
[INITIALIZER_LIST] = sizeof(initializer_list_t),
[INITIALIZER_DESIGNATOR] = sizeof(initializer_designator_t)
};
- assert(kind < sizeof(sizes) / sizeof(*sizes));
+ assert(kind < lengthof(sizes));
assert(sizes[kind] != 0);
return sizes[kind];
}
return result;
}
-/**
- * Free a type from the type obstack.
- */
-static void free_type(void *type)
-{
- obstack_free(type_obst, type);
-}
-
/**
* Returns the index of the top element of the environment stack.
*/
lookahead_buffer[lookahead_bufpos] = lexer_token;
lexer_next_token();
- lookahead_bufpos = (lookahead_bufpos+1) % MAX_LOOKAHEAD;
+ lookahead_bufpos = (lookahead_bufpos + 1) % MAX_LOOKAHEAD;
#ifdef PRINT_TOKENS
print_token(stderr, &token);
/**
* Return the next token with a given lookahead.
*/
-static inline const token_t *look_ahead(int num)
+static inline const token_t *look_ahead(size_t num)
{
- assert(num > 0 && num <= MAX_LOOKAHEAD);
- int pos = (lookahead_bufpos+num-1) % MAX_LOOKAHEAD;
+ assert(0 < num && num <= MAX_LOOKAHEAD);
+ size_t pos = (lookahead_bufpos + num - 1) % MAX_LOOKAHEAD;
return &lookahead_buffer[pos];
}
/**
- * Adds a token to the token anchor set (a multi-set).
+ * Adds a token type to the token type anchor set (a multi-set).
*/
static void add_anchor_token(int token_type)
{
++token_anchor_set[token_type];
}
+/**
+ * Set the number of tokens types of the given type
+ * to zero and return the old count.
+ */
static int save_and_reset_anchor_state(int token_type)
{
assert(0 <= token_type && token_type < T_LAST_TOKEN);
return count;
}
+/**
+ * Restore the number of token types to the given count.
+ */
static void restore_anchor_state(int token_type, int count)
{
assert(0 <= token_type && token_type < T_LAST_TOKEN);
}
/**
- * Remove a token from the token anchor set (a multi-set).
+ * Remove a token type from the token type anchor set (a multi-set).
*/
static void rem_anchor_token(int token_type)
{
--token_anchor_set[token_type];
}
+/**
+ * Return true if the token type of the current token is
+ * in the anchor set.
+ */
static bool at_anchor(void)
{
if (token.type < 0)
}
/**
- * Eat tokens until a matching token is found.
+ * Eat tokens until a matching token type is found.
*/
static void eat_until_matching_token(int type)
{
}
}
+/**
+ * Eat a whole block from input tokens.
+ */
static void eat_block(void)
{
eat_until_matching_token('{');
next_token();
}
-#define eat(token_type) do { assert(token.type == (token_type)); next_token(); } while (0)
+#define eat(token_type) (assert(token.type == (token_type)), next_token())
/**
* Report a parse error because an expected token was not found.
}
va_list ap;
va_start(ap, message);
- errorf(HERE, "got '%K', expected %#k", &token, &ap, ", ");
+ errorf(HERE, "got %K, expected %#k", &token, &ap, ", ");
va_end(ap);
}
}
/**
- * Expect the the current token is the expected token.
+ * Expect the current token is the expected token.
* If not, generate an error, eat the current statement,
* and goto the end_error label.
*/
-#define expect(expected) \
+#define expect(expected, error_label) \
do { \
if (UNLIKELY(token.type != (expected))) { \
parse_error_expected(NULL, (expected), NULL); \
if (token.type == expected) \
next_token(); \
rem_anchor_token(expected); \
- goto end_error; \
+ goto error_label; \
} \
next_token(); \
} while (0)
+/**
+ * Push a given scope on the scope stack and make it the
+ * current scope
+ */
static scope_t *scope_push(scope_t *new_scope)
{
if (current_scope != NULL) {
return old_scope;
}
+/**
+ * Pop the current scope from the scope stack.
+ */
static void scope_pop(scope_t *old_scope)
{
current_scope = old_scope;
return (int) akind;
}
+/**
+ * Return the type rank for an atomic type.
+ */
static int get_rank(const type_t *type)
{
assert(!is_typeref(type));
- /* The C-standard allows promoting enums to int or unsigned int (see § 7.2.2
- * and esp. footnote 108). However we can't fold constants (yet), so we
- * can't decide whether unsigned int is possible, while int always works.
- * (unsigned int would be preferable when possible... for stuff like
- * struct { enum { ... } bla : 4; } ) */
if (type->kind == TYPE_ENUM)
- return get_akind_rank(ATOMIC_TYPE_INT);
+ return get_akind_rank(type->enumt.akind);
assert(type->kind == TYPE_ATOMIC);
return get_akind_rank(type->atomic.akind);
}
+/**
+ * Do integer promotion for a given type.
+ *
+ * @param type the type to promote
+ * @return the promoted type
+ */
static type_t *promote_integer(type_t *type)
{
if (type->kind == TYPE_BITFIELD)
}
/**
- * Check if a given expression represents the 0 pointer constant.
+ * Check if a given expression represents a null pointer constant.
+ *
+ * @param expression the expression to check
*/
static bool is_null_pointer_constant(const expression_t *expression)
{
/* skip void* cast */
- if (expression->kind == EXPR_UNARY_CAST
- || expression->kind == EXPR_UNARY_CAST_IMPLICIT) {
- expression = expression->unary.value;
+ if (expression->kind == EXPR_UNARY_CAST ||
+ expression->kind == EXPR_UNARY_CAST_IMPLICIT) {
+ type_t *const type = skip_typeref(expression->base.type);
+ if (types_compatible(type, type_void_ptr))
+ expression = expression->unary.value;
}
- /* TODO: not correct yet, should be any constant integer expression
- * which evaluates to 0 */
- if (expression->kind != EXPR_CONST)
- return false;
-
type_t *const type = skip_typeref(expression->base.type);
- if (!is_type_integer(type))
- return false;
-
- return expression->conste.v.int_value == 0;
+ return
+ is_type_integer(type) &&
+ is_constant_expression(expression) &&
+ fold_constant(expression) == 0;
}
/**
}
}
-/** Implements the rules from § 6.5.16.1 */
+/** Implements the rules from §6.5.16.1 */
static assign_error_t semantic_assign(type_t *orig_type_left,
const expression_t *const right)
{
if (!is_constant_expression(result)) {
errorf(&result->base.source_position,
- "expression '%E' is not constant\n", result);
+ "expression '%E' is not constant", result);
}
return result;
[GNU_AK_FASTCALL] = "fastcall",
[GNU_AK_DEPRECATED] = "deprecated",
[GNU_AK_NOINLINE] = "noinline",
+ [GNU_AK_RETURNS_TWICE] = "returns_twice",
[GNU_AK_NORETURN] = "noreturn",
[GNU_AK_NAKED] = "naked",
[GNU_AK_PURE] = "pure",
}
/**
- * Allocate a new gnu temporal attribute.
+ * Allocate a new gnu temporal attribute of given kind.
*/
static gnu_attribute_t *allocate_gnu_attribute(gnu_attribute_kind_t kind)
{
attribute->kind = kind;
attribute->next = NULL;
attribute->invalid = false;
- attribute->have_arguments = false;
+ attribute->has_arguments = false;
return attribute;
}
/**
- * parse one constant expression argument.
+ * Parse one constant expression argument of the given attribute.
*/
static void parse_gnu_attribute_const_arg(gnu_attribute_t *attribute)
{
add_anchor_token(')');
expression = parse_constant_expression();
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
attribute->u.argument = fold_constant(expression);
return;
end_error:
}
/**
- * parse a list of constant expressions arguments.
+ * Parse a list of constant expressions arguments of the given attribute.
*/
static void parse_gnu_attribute_const_arg_list(gnu_attribute_t *attribute)
{
}
rem_anchor_token(',');
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
return;
end_error:
attribute->invalid = true;
}
/**
- * parse one string literal argument.
+ * Parse one string literal argument of the given attribute.
*/
static void parse_gnu_attribute_string_arg(gnu_attribute_t *attribute,
string_t *string)
}
*string = parse_string_literals();
rem_anchor_token('(');
- expect(')');
+ expect(')', end_error);
return;
end_error:
attribute->invalid = true;
}
/**
- * parse one tls model.
+ * Parse one tls model of the given attribute.
*/
static void parse_gnu_attribute_tls_model_arg(gnu_attribute_t *attribute)
{
}
/**
- * parse one tls model.
+ * Parse one tls model of the given attribute.
*/
static void parse_gnu_attribute_visibility_arg(gnu_attribute_t *attribute)
{
}
/**
- * parse one (code) model.
+ * Parse one (code) model of the given attribute.
*/
static void parse_gnu_attribute_model_arg(gnu_attribute_t *attribute)
{
attribute->invalid = true;
}
+/**
+ * Parse one mode of the given attribute.
+ */
static void parse_gnu_attribute_mode_arg(gnu_attribute_t *attribute)
{
- /* TODO: find out what is allowed here... */
-
- /* at least: byte, word, pointer, list of machine modes
- * __XXX___ is interpreted as XXX */
add_anchor_token(')');
if (token.type != T_IDENTIFIER) {
- expect(T_IDENTIFIER);
+ expect(T_IDENTIFIER, end_error);
}
- /* 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 ||
- 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
- || 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) {
- attribute->u.akind = ATOMIC_TYPE_LONGLONG;
- } else {
- if (warning.other)
- warningf(HERE, "ignoring unknown mode '%s'", symbol_str);
- attribute->invalid = true;
- }
+ attribute->u.symbol = token.v.symbol;
next_token();
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
return;
end_error:
attribute->invalid = true;
}
/**
- * parse one interrupt argument.
+ * Parse one interrupt argument of the given attribute.
*/
static void parse_gnu_attribute_interrupt_arg(gnu_attribute_t *attribute)
{
}
/**
- * parse ( identifier, const expression, const expression )
+ * Parse ( identifier, const expression, const expression )
*/
static void parse_gnu_attribute_format_args(gnu_attribute_t *attribute)
{
}
next_token();
- expect(',');
+ expect(',', end_error);
add_anchor_token(')');
add_anchor_token(',');
parse_constant_expression();
rem_anchor_token(',');
rem_anchor_token(')');
- expect(',');
+ expect(',', end_error);
add_anchor_token(')');
parse_constant_expression();
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
return;
end_error:
attribute->u.value = true;
}
+/**
+ * Check that a given GNU attribute has no arguments.
+ */
static void check_no_argument(gnu_attribute_t *attribute, const char *name)
{
- if (!attribute->have_arguments)
+ if (!attribute->has_arguments)
return;
/* should have no arguments */
gnu_attribute_t *attribute;
eat(T___attribute__);
- expect('(');
- expect('(');
+ expect('(', end_error);
+ expect('(', end_error);
if (token.type != ')') {
/* find the end of the list */
/* empty args are allowed */
next_token();
} else
- attribute->have_arguments = true;
+ attribute->has_arguments = true;
}
switch (kind) {
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_RETURNS_TWICE: modifiers |= DM_RETURNS_TWICE; 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_ALIGNED:
/* __align__ may be used without an argument */
- if (attribute->have_arguments) {
+ if (attribute->has_arguments) {
parse_gnu_attribute_const_arg(attribute);
}
break;
case GNU_AK_FORMAT_ARG:
case GNU_AK_REGPARM:
case GNU_AK_TRAP_EXIT:
- if (!attribute->have_arguments) {
+ if (!attribute->has_arguments) {
/* should have arguments */
errorf(HERE, "wrong number of arguments specified for '%s' attribute", name);
attribute->invalid = true;
case GNU_AK_ALIAS:
case GNU_AK_SECTION:
case GNU_AK_SP_SWITCH:
- if (!attribute->have_arguments) {
+ if (!attribute->has_arguments) {
/* should have arguments */
errorf(HERE, "wrong number of arguments specified for '%s' attribute", name);
attribute->invalid = true;
parse_gnu_attribute_string_arg(attribute, &attribute->u.string);
break;
case GNU_AK_FORMAT:
- if (!attribute->have_arguments) {
+ if (!attribute->has_arguments) {
/* should have arguments */
errorf(HERE, "wrong number of arguments specified for '%s' attribute", name);
attribute->invalid = true;
break;
case GNU_AK_WEAKREF:
/* may have one string argument */
- if (attribute->have_arguments)
+ if (attribute->has_arguments)
parse_gnu_attribute_string_arg(attribute, &attribute->u.string);
break;
case GNU_AK_NONNULL:
- if (attribute->have_arguments)
+ if (attribute->has_arguments)
parse_gnu_attribute_const_arg_list(attribute);
break;
case GNU_AK_TLS_MODEL:
- if (!attribute->have_arguments) {
+ if (!attribute->has_arguments) {
/* should have arguments */
errorf(HERE, "wrong number of arguments specified for '%s' attribute", name);
} else
parse_gnu_attribute_tls_model_arg(attribute);
break;
case GNU_AK_VISIBILITY:
- if (!attribute->have_arguments) {
+ if (!attribute->has_arguments) {
/* should have arguments */
errorf(HERE, "wrong number of arguments specified for '%s' attribute", name);
} else
parse_gnu_attribute_visibility_arg(attribute);
break;
case GNU_AK_MODEL:
- if (!attribute->have_arguments) {
+ if (!attribute->has_arguments) {
/* should have arguments */
errorf(HERE, "wrong number of arguments specified for '%s' attribute", name);
} else {
}
break;
case GNU_AK_MODE:
- if (!attribute->have_arguments) {
+ if (!attribute->has_arguments) {
/* should have arguments */
errorf(HERE, "wrong number of arguments specified for '%s' attribute", name);
} else {
break;
case GNU_AK_INTERRUPT:
/* may have one string argument */
- if (attribute->have_arguments)
+ if (attribute->has_arguments)
parse_gnu_attribute_interrupt_arg(attribute);
break;
case GNU_AK_SENTINEL:
/* may have one string argument */
- if (attribute->have_arguments)
+ if (attribute->has_arguments)
parse_gnu_attribute_const_arg(attribute);
break;
case GNU_AK_LAST:
next_token();
}
}
- expect(')');
- expect(')');
+ expect(')', end_error);
+ expect(')', end_error);
end_error:
*attributes = head;
case T_asm:
next_token();
- expect('(');
+ expect('(', end_error);
if (token.type != T_STRING_LITERAL) {
parse_error_expected("while parsing assembler attribute",
T_STRING_LITERAL, NULL);
} else {
parse_string_literals();
}
- expect(')');
+ expect(')', end_error);
continue;
case T_cdecl: modifiers |= DM_CDECL; break;
case T___thiscall:
/* TODO record modifier */
if (warning.other)
- warningf(HERE, "Ignoring declaration modifier '%K'", &token);
+ warningf(HERE, "Ignoring declaration modifier %K", &token);
break;
end_error:
case EXPR_FUNCNAME:
case EXPR_BUILTIN_SYMBOL:
case EXPR_BUILTIN_CONSTANT_P:
- case EXPR_BUILTIN_PREFETCH:
+ case EXPR_BUILTIN_TYPES_COMPATIBLE_P:
case EXPR_OFFSETOF:
case EXPR_STATEMENT: // TODO
case EXPR_LABEL_ADDRESS:
- case EXPR_BINARY_BUILTIN_EXPECT:
case EXPR_REFERENCE_ENUM_VALUE:
return;
}
add_anchor_token(']');
designator->array_index = parse_constant_expression();
rem_anchor_token(']');
- expect(']');
+ expect(']', end_error);
break;
case '.':
designator = allocate_ast_zero(sizeof(designator[0]));
next_token();
break;
default:
- expect('=');
+ expect('=', end_error);
return result;
}
{
/* TODO check that expression is a constant expression */
- /* § 6.7.8.14/15 char array may be initialized by string literals */
+ /* §6.7.8.14/15 char array may be initialized by string literals */
type_t *type = skip_typeref(orig_type);
type_t *expr_type_orig = expression->base.type;
type_t *expr_type = skip_typeref(expr_type_orig);
return initializer_from_string(array_type,
&expression->string.value);
}
+ break;
case EXPR_WIDE_STRING_LITERAL: {
type_t *bare_wchar_type = skip_typeref(type_wchar_t);
return initializer_from_wide_string(array_type,
&expression->wide_string.value);
}
+ break;
}
default:
/**
* Parses an scalar initializer.
*
- * § 6.7.8.11; eat {} without warning
+ * §6.7.8.11; eat {} without warning
*/
static initializer_t *parse_scalar_initializer(type_t *type,
bool must_be_constant)
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",
+ "Initialisation expression '%E' is not constant",
expression);
}
if (type != NULL) {
ascend_from_subtype(path);
- expect('}');
+ expect('}', end_error);
} else {
- expect('}');
+ expect('}', end_error);
goto error_parse_next;
}
}
} else {
/* must be an expression */
expression_t *expression = parse_assignment_expression();
+ mark_vars_read(expression, NULL);
if (env->must_be_constant && !is_initializer_constant(expression)) {
errorf(&expression->base.source_position,
- "Initialisation expression '%E' is not constant\n",
+ "Initialisation expression '%E' is not constant",
expression);
}
if (token.type == '}') {
break;
}
- expect(',');
+ expect(',', end_error);
if (token.type == '}') {
break;
}
*/
static initializer_t *parse_initializer(parse_initializer_env_t *env)
{
- type_t *type = skip_typeref(env->type);
- initializer_t *result = NULL;
- size_t max_index;
+ type_t *type = skip_typeref(env->type);
+ size_t max_index = 0xdeadbeaf; // TODO: Resolve this uninitialized variable problem
+ initializer_t *result;
if (is_type_scalar(type)) {
result = parse_scalar_initializer(type, env->must_be_constant);
max_index = path.max_index;
DEL_ARR_F(path.path);
- expect('}');
+ expect('}', end_error);
} else {
/* parse_scalar_initializer() also works in this case: we simply
* have an expression without {} around it */
result = parse_scalar_initializer(type, env->must_be_constant);
}
- /* § 6.7.8 (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) {
size_t size;
switch (result->kind) {
case INITIALIZER_LIST:
+ assert(max_index != 0xdeadbeaf);
size = max_index + 1;
break;
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 */
+ /* we're in an inner scope and have a definition. Shadow
+ * existing definition in outer scope */
compound = NULL;
} else if (compound->complete && token.type == '{') {
assert(symbol != NULL);
} while (token.type != '}');
rem_anchor_token('}');
- expect('}');
+ expect('}', end_error);
end_error:
;
next_token();
entity = get_entity(symbol, NAMESPACE_ENUM);
- assert(entity == NULL || entity->kind == ENTITY_ENUM);
+ if (entity != NULL) {
+ assert(entity->kind == ENTITY_ENUM);
+ if (entity->base.parent_scope != current_scope &&
+ (token.type == '{' || token.type == ';')) {
+ /* we're in an inner scope and have a definition. Shadow
+ * existing definition in outer scope */
+ entity = NULL;
+ } else if (entity->enume.complete && token.type == '{') {
+ errorf(HERE, "multiple definitions of 'enum %Y' (previous definition %P)",
+ symbol, &entity->base.source_position);
+ }
+ }
} else if (token.type != '{') {
parse_error_expected("while parsing enum type specifier",
T_IDENTIFIER, '{', NULL);
type_t *const type = allocate_type_zero(TYPE_ENUM);
type->enumt.enume = &entity->enume;
+ type->enumt.akind = ATOMIC_TYPE_INT;
if (token.type == '{') {
- if (entity->enume.complete) {
- errorf(HERE, "multiple definitions of enum %Y (previous definition %P)",
- symbol, &entity->base.source_position);
- }
if (symbol != NULL) {
environment_push(entity);
}
anonymous_entity = entity;
}
} else if (!entity->enume.complete && !(c_mode & _GNUC)) {
- errorf(HERE, "enum %Y used before definition (incomplete enumes are a GNU extension)",
+ errorf(HERE, "'enum %Y' used before definition (incomplete enums are a GNU extension)",
symbol);
}
type_t *type;
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
expression_t *expression = NULL;
type = parse_typename();
} else {
expression = parse_expression();
- type = expression->base.type;
+ type = revert_automatic_type_conversion(expression);
}
break;
in_gcc_extension = old_gcc_extension;
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
type_t *typeof_type = allocate_type_zero(TYPE_TYPEOF);
typeof_type->typeoft.expression = expression;
SPECIFIER_INT = 1 << 3,
SPECIFIER_DOUBLE = 1 << 4,
SPECIFIER_CHAR = 1 << 5,
- SPECIFIER_SHORT = 1 << 6,
- SPECIFIER_LONG_LONG = 1 << 7,
- SPECIFIER_FLOAT = 1 << 8,
- SPECIFIER_BOOL = 1 << 9,
- SPECIFIER_VOID = 1 << 10,
- SPECIFIER_INT8 = 1 << 11,
- SPECIFIER_INT16 = 1 << 12,
- SPECIFIER_INT32 = 1 << 13,
- SPECIFIER_INT64 = 1 << 14,
- SPECIFIER_INT128 = 1 << 15,
- SPECIFIER_COMPLEX = 1 << 16,
- SPECIFIER_IMAGINARY = 1 << 17,
+ SPECIFIER_WCHAR_T = 1 << 6,
+ SPECIFIER_SHORT = 1 << 7,
+ SPECIFIER_LONG_LONG = 1 << 8,
+ SPECIFIER_FLOAT = 1 << 9,
+ SPECIFIER_BOOL = 1 << 10,
+ SPECIFIER_VOID = 1 << 11,
+ SPECIFIER_INT8 = 1 << 12,
+ SPECIFIER_INT16 = 1 << 13,
+ SPECIFIER_INT32 = 1 << 14,
+ SPECIFIER_INT64 = 1 << 15,
+ SPECIFIER_INT128 = 1 << 16,
+ SPECIFIER_COMPLEX = 1 << 17,
+ SPECIFIER_IMAGINARY = 1 << 18,
} specifiers_t;
static type_t *create_builtin_type(symbol_t *const symbol,
type_t *type = allocate_type_zero(TYPE_BUILTIN);
type->builtin.symbol = symbol;
type->builtin.real_type = real_type;
-
- type_t *result = typehash_insert(type);
- if (type != result) {
- free_type(type);
- }
-
- return result;
+ return identify_new_type(type);
}
static type_t *get_typedef_type(symbol_t *symbol)
symbol_t *symbol = token.v.symbol;
if (symbol == sym_align) {
next_token();
- expect('(');
+ expect('(', end_error);
if (token.type != T_INTEGER)
goto end_error;
if (check_alignment_value(token.v.intvalue)) {
specifiers->alignment = (unsigned char)token.v.intvalue;
}
next_token();
- expect(')');
+ expect(')', end_error);
} else if (symbol == sym_allocate) {
next_token();
- expect('(');
+ expect('(', end_error);
if (token.type != T_IDENTIFIER)
goto end_error;
(void)token.v.symbol;
- expect(')');
+ expect(')', end_error);
} else if (symbol == sym_dllimport) {
next_token();
DET_MOD(dllimport, DM_DLLIMPORT);
} else if (symbol == sym_noinline) {
next_token();
DET_MOD(noinline, DM_NOINLINE);
+ } else if (symbol == sym_returns_twice) {
+ next_token();
+ DET_MOD(returns_twice, DM_RETURNS_TWICE);
} else if (symbol == sym_noreturn) {
next_token();
DET_MOD(noreturn, DM_NORETURN);
DET_MOD(novtable, DM_NOVTABLE);
} else if (symbol == sym_property) {
next_token();
- expect('(');
+ expect('(', end_error);
for (;;) {
bool is_get = false;
if (token.type != T_IDENTIFIER)
goto end_error;
}
next_token();
- expect('=');
+ expect('=', end_error);
if (token.type != T_IDENTIFIER)
goto end_error;
if (is_get) {
}
break;
}
- expect(')');
+ expect(')', end_error);
} else if (symbol == sym_selectany) {
next_token();
DET_MOD(selectany, DM_SELECTANY);
} else if (symbol == sym_uuid) {
next_token();
- expect('(');
+ expect('(', end_error);
if (token.type != T_STRING_LITERAL)
goto end_error;
next_token();
- expect(')');
+ expect(')', end_error);
} else if (symbol == sym_deprecated) {
next_token();
if (specifiers->deprecated != 0 && warning.other)
} else {
errorf(HERE, "string literal expected");
}
- expect(')');
+ expect(')', end_error);
}
} else if (symbol == sym_noalias) {
next_token();
DET_MOD(noalias, DM_NOALIAS);
} else {
if (warning.other)
- warningf(HERE, "Unknown modifier %Y ignored", token.v.symbol);
+ warningf(HERE, "Unknown modifier '%Y' ignored", token.v.symbol);
next_token();
if (token.type == '(')
skip_until(')');
entity->declaration.type = type_error_type;
entity->declaration.implicit = true;
} else if (kind == ENTITY_TYPEDEF) {
- entity->typedefe.type = type_error_type;
+ entity->typedefe.type = type_error_type;
+ entity->typedefe.builtin = true;
}
- record_entity(entity, false);
+ if (kind != ENTITY_COMPOUND_MEMBER)
+ record_entity(entity, false);
return entity;
}
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);
+ if (need_pad) {
+ if (warning.padded) {
+ warningf(&compound->base.source_position, "'%T' needs padding", type);
+ }
+ } else {
+ if (compound->modifiers & DM_PACKED && warning.packed) {
+ warningf(&compound->base.source_position,
+ "superfluous packed attribute on '%T'", type);
+ }
}
type->base.size = offset;
type->base.alignment = alignment;
}
+static type_t *handle_attribute_mode(const gnu_attribute_t *attribute,
+ type_t *orig_type)
+{
+ type_t *type = skip_typeref(orig_type);
+
+ /* at least: byte, word, pointer, list of machine modes
+ * __XXX___ is interpreted as XXX */
+
+ /* 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 = attribute->u.symbol->string;
+ bool sign = is_type_signed(type);
+ atomic_type_kind_t akind;
+ if (strcmp_underscore("QI", symbol_str) == 0 ||
+ strcmp_underscore("byte", symbol_str) == 0) {
+ akind = sign ? ATOMIC_TYPE_CHAR : ATOMIC_TYPE_UCHAR;
+ } else if (strcmp_underscore("HI", symbol_str) == 0) {
+ akind = sign ? ATOMIC_TYPE_SHORT : ATOMIC_TYPE_USHORT;
+ } else if (strcmp_underscore("SI", symbol_str) == 0
+ || strcmp_underscore("word", symbol_str) == 0
+ || strcmp_underscore("pointer", symbol_str) == 0) {
+ akind = sign ? ATOMIC_TYPE_INT : ATOMIC_TYPE_UINT;
+ } else if (strcmp_underscore("DI", symbol_str) == 0) {
+ akind = sign ? ATOMIC_TYPE_LONGLONG : ATOMIC_TYPE_ULONGLONG;
+ } else {
+ if (warning.other)
+ warningf(HERE, "ignoring unknown mode '%s'", symbol_str);
+ return orig_type;
+ }
+
+ if (type->kind == TYPE_ATOMIC) {
+ type_t *copy = duplicate_type(type);
+ copy->atomic.akind = akind;
+ return identify_new_type(copy);
+ } else if (type->kind == TYPE_ENUM) {
+ type_t *copy = duplicate_type(type);
+ copy->enumt.akind = akind;
+ return identify_new_type(copy);
+ } else if (is_type_pointer(type)) {
+ warningf(HERE, "__attribute__((mode)) on pointers not implemented yet (ignored)");
+ return type;
+ }
+
+ errorf(HERE, "__attribute__((mode)) only allowed on integer, enum or pointer type");
+ return orig_type;
+}
+
+static type_t *handle_type_attributes(const gnu_attribute_t *attributes,
+ type_t *type)
+{
+ const gnu_attribute_t *attribute = attributes;
+ for ( ; attribute != NULL; attribute = attribute->next) {
+ if (attribute->invalid)
+ continue;
+
+ if (attribute->kind == GNU_AK_MODE) {
+ type = handle_attribute_mode(attribute, type);
+ } else if (attribute->kind == GNU_AK_ALIGNED) {
+ int alignment = 32; /* TODO: fill in maximum useful alignment for
+ target machine */
+ if (attribute->has_arguments)
+ alignment = attribute->u.argument;
+
+ type_t *copy = duplicate_type(type);
+ copy->base.alignment = attribute->u.argument;
+ type = identify_new_type(copy);
+ }
+ }
+
+ return type;
+}
+
static void parse_declaration_specifiers(declaration_specifiers_t *specifiers)
{
type_t *type = NULL;
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 */
case T__declspec:
next_token();
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
parse_microsoft_extended_decl_modifier(specifiers);
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
break;
case T___thread:
MATCH_SPECIFIER(T_signed, SPECIFIER_SIGNED, "signed");
MATCH_SPECIFIER(T_unsigned, SPECIFIER_UNSIGNED, "unsigned");
MATCH_SPECIFIER(T_void, SPECIFIER_VOID, "void");
+ MATCH_SPECIFIER(T_wchar_t, SPECIFIER_WCHAR_T, "wchar_t");
case T__forceinline:
/* only in microsoft mode */
case T_IDENTIFIER:
case '&':
case '*':
- errorf(HERE, "discarding stray '%K' in declaration specifier", &token);
+ errorf(HERE, "discarding stray %K in declaration specifier", &token);
next_token();
continue;
case T_IDENTIFIER:
case '&':
case '*': {
- errorf(HERE, "'%K' does not name a type", &token);
+ errorf(HERE, "%K does not name a type", &token);
entity_t *entity =
create_error_entity(token.v.symbol, ENTITY_TYPEDEF);
}
finish_specifiers:
+ specifiers->modifiers
+ |= parse_attributes(&specifiers->gnu_attributes);
+
in_gcc_extension = old_gcc_extension;
if (type == NULL || (saw_error && type_specifiers != 0)) {
case SPECIFIER_VOID:
atomic_type = ATOMIC_TYPE_VOID;
break;
+ case SPECIFIER_WCHAR_T:
+ atomic_type = ATOMIC_TYPE_WCHAR_T;
+ break;
case SPECIFIER_CHAR:
atomic_type = ATOMIC_TYPE_CHAR;
break;
type = allocate_type_zero(TYPE_IMAGINARY);
type->imaginary.akind = atomic_type;
} else {
- type = allocate_type_zero(TYPE_ATOMIC);
- type->atomic.akind = atomic_type;
+ type = allocate_type_zero(TYPE_ATOMIC);
+ type->atomic.akind = atomic_type;
}
+ type->base.alignment = get_atomic_type_alignment(atomic_type);
+ unsigned const size = get_atomic_type_size(atomic_type);
+ type->base.size =
+ type_specifiers & SPECIFIER_COMPLEX ? size * 2 : size;
newtype = true;
} else if (type_specifiers != 0) {
errorf(HERE, "multiple datatypes in declaration");
/* FIXME: check type qualifiers here */
+ if (specifiers->modifiers & DM_TRANSPARENT_UNION)
+ modifiers |= TYPE_MODIFIER_TRANSPARENT_UNION;
type->base.qualifiers = qualifiers;
type->base.modifiers = modifiers;
- type_t *result = typehash_insert(type);
- if (newtype && result != type) {
- free_type(type);
+ if (newtype) {
+ type = identify_new_type(type);
+ } else {
+ type = typehash_insert(type);
}
- specifiers->type = result;
+ type = handle_type_attributes(specifiers->gnu_attributes, type);
+ specifiers->type = type;
return;
end_error:
/* a K&R parameter has no type, yet */
next_token();
- append_entity(scope, entity);
+ if (scope != NULL)
+ append_entity(scope, entity);
if (token.type != ',') {
break;
type_t *type = skip_typeref(entity->declaration.type);
if (is_type_incomplete(type)) {
errorf(&entity->base.source_position,
- "parameter '%Y' has incomplete type %T", entity->base.symbol,
+ "parameter '%Y' has incomplete type '%T'", entity->base.symbol,
entity->declaration.type);
}
}
!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;
+ type->kr_style_parameters = true;
+ type->unspecified_parameters = true;
parse_identifier_list(scope);
goto parameters_finished;
}
parameters_finished:
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
end_error:
restore_anchor_state(',', saved_comma_state);
array->is_variable = true;
next_token();
} else if (token.type != ']') {
- array->size = parse_assignment_expression();
+ expression_t *const size = parse_assignment_expression();
+ array->size = size;
+ mark_vars_read(size, NULL);
}
rem_anchor_token(']');
- expect(']');
+ expect(']', end_error);
end_error:
return &array->construct_type;
case T__based:
next_token();
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
parse_microsoft_based(&base_spec);
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
continue;
default:
next_token();
break;
case '(':
- next_token();
- add_anchor_token(')');
- inner_types = parse_inner_declarator(env, may_be_abstract);
- if (inner_types != NULL) {
- /* All later declarators only modify the return type */
- env = NULL;
+ /* §6.7.6:2 footnote 126: Empty parentheses in a type name are
+ * interpreted as ``function with no parameter specification'', rather
+ * than redundant parentheses around the omitted identifier. */
+ if (look_ahead(1)->type != ')') {
+ next_token();
+ add_anchor_token(')');
+ 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(')', end_error);
}
- rem_anchor_token(')');
- expect(')');
break;
default:
if (may_be_abstract)
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)
+ if (attribute->invalid)
continue;
- atomic_type_kind_t akind = attribute->u.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;
- case ATOMIC_TYPE_LONGLONG: akind = ATOMIC_TYPE_ULONGLONG; 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");
+ if (attribute->kind == GNU_AK_MODE) {
+ type = handle_attribute_mode(attribute, type);
+ } else if (attribute->kind == GNU_AK_ALIGNED) {
+ int alignment = 32; /* TODO: fill in maximum usefull alignment for target machine */
+ if (attribute->has_arguments)
+ alignment = attribute->u.argument;
+
+ if (entity->kind == ENTITY_TYPEDEF) {
+ type_t *copy = duplicate_type(type);
+ copy->base.alignment = attribute->u.argument;
+ type = identify_new_type(copy);
+ } else if(entity->kind == ENTITY_VARIABLE) {
+ entity->variable.alignment = alignment;
+ } else if(entity->kind == ENTITY_COMPOUND_MEMBER) {
+ entity->compound_member.alignment = alignment;
}
}
-
- 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;
+ type_modifiers |= TYPE_MODIFIER_TRANSPARENT_UNION;
if (type->base.modifiers != type_modifiers) {
- type_t *copy = duplicate_type(type);
+ type_t *copy = duplicate_type(type);
copy->base.modifiers = type_modifiers;
-
- type = typehash_insert(copy);
- if (type != copy) {
- obstack_free(type_obst, copy);
- }
+ type = identify_new_type(copy);
}
if (entity->kind == ENTITY_TYPEDEF) {
function_type->function.return_type = type;
type_t *skipped_return_type = skip_typeref(type);
- /* §6.7.5.3(1) */
+ /* §6.7.5.3:1 */
if (is_type_function(skipped_return_type)) {
errorf(HERE, "function returning function is not allowed");
} else if (is_type_array(skipped_return_type)) {
}
type_t *skipped_type = skip_typeref(type);
- /* §6.7.5.2(1) */
+ /* §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)) {
}
}
- type_t *hashed_type = typehash_insert(type);
- if (hashed_type != type) {
- /* the function type was constructed earlier freeing it here will
- * destroy other types... */
- if (iter->kind != CONSTRUCT_FUNCTION) {
- free_type(type);
- }
- type = hashed_type;
+ /* The function type was constructed earlier. Freeing it here will
+ * destroy other types. */
+ if (iter->kind == CONSTRUCT_FUNCTION) {
+ type = typehash_insert(type);
+ } else {
+ type = identify_new_type(type);
}
}
if (flags & DECL_CREATE_COMPOUND_MEMBER) {
entity = allocate_entity_zero(ENTITY_COMPOUND_MEMBER);
- if (specifiers->is_inline && is_type_valid(type)) {
- errorf(&env.source_position,
- "compound member '%Y' declared 'inline'", env.symbol);
- }
+ if (env.symbol != NULL) {
+ if (specifiers->is_inline && is_type_valid(type)) {
+ errorf(&env.source_position,
+ "compound member '%Y' declared 'inline'", env.symbol);
+ }
- if (specifiers->thread_local ||
- specifiers->storage_class != STORAGE_CLASS_NONE) {
- errorf(&env.source_position,
- "compound member '%Y' must have no storage class",
- env.symbol);
+ if (specifiers->thread_local ||
+ specifiers->storage_class != STORAGE_CLASS_NONE) {
+ errorf(&env.source_position,
+ "compound member '%Y' must have no storage class",
+ env.symbol);
+ }
}
} else if (flags & DECL_IS_PARAMETER) {
- orig_type = semantic_parameter(&env.source_position, type,
+ orig_type = semantic_parameter(&env.source_position, orig_type,
specifiers, env.symbol);
entity = allocate_entity_zero(ENTITY_PARAMETER);
entity->function.is_inline = specifiers->is_inline;
entity->function.parameters = env.parameters;
- if (specifiers->thread_local || (
- specifiers->storage_class != STORAGE_CLASS_EXTERN &&
- specifiers->storage_class != STORAGE_CLASS_NONE &&
- specifiers->storage_class != STORAGE_CLASS_STATIC)
- ) {
- errorf(&env.source_position,
- "invalid storage class for function '%Y'", env.symbol);
+ if (env.symbol != NULL) {
+ if (specifiers->thread_local || (
+ specifiers->storage_class != STORAGE_CLASS_EXTERN &&
+ specifiers->storage_class != STORAGE_CLASS_NONE &&
+ specifiers->storage_class != STORAGE_CLASS_STATIC
+ )) {
+ errorf(&env.source_position,
+ "invalid storage class for function '%Y'", env.symbol);
+ }
}
} else {
entity = allocate_entity_zero(ENTITY_VARIABLE);
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 (specifiers->is_inline && is_type_valid(type)) {
- errorf(&env.source_position,
- "variable '%Y' declared 'inline'", env.symbol);
- }
entity->variable.thread_local = specifiers->thread_local;
- bool invalid_storage_class = false;
- if (current_scope == file_scope) {
- if (specifiers->storage_class != STORAGE_CLASS_EXTERN &&
- specifiers->storage_class != STORAGE_CLASS_NONE &&
- specifiers->storage_class != STORAGE_CLASS_STATIC) {
- invalid_storage_class = true;
+ if (env.symbol != NULL) {
+ if (specifiers->is_inline && is_type_valid(type)) {
+ errorf(&env.source_position,
+ "variable '%Y' declared 'inline'", env.symbol);
}
- } else {
- if (specifiers->thread_local &&
- specifiers->storage_class == STORAGE_CLASS_NONE) {
- invalid_storage_class = true;
+
+ bool invalid_storage_class = false;
+ if (current_scope == file_scope) {
+ if (specifiers->storage_class != STORAGE_CLASS_EXTERN &&
+ specifiers->storage_class != STORAGE_CLASS_NONE &&
+ specifiers->storage_class != STORAGE_CLASS_STATIC) {
+ invalid_storage_class = true;
+ }
+ } else {
+ if (specifiers->thread_local &&
+ specifiers->storage_class == STORAGE_CLASS_NONE) {
+ invalid_storage_class = true;
+ }
+ }
+ if (invalid_storage_class) {
+ errorf(&env.source_position,
+ "invalid storage class for variable '%Y'", env.symbol);
}
- }
- if (invalid_storage_class) {
- errorf(&env.source_position,
- "invalid storage class for variable '%Y'", env.symbol);
}
}
- entity->base.source_position = env.source_position;
- entity->base.symbol = env.symbol;
+ if (env.symbol != NULL) {
+ entity->base.symbol = env.symbol;
+ entity->base.source_position = env.source_position;
+ } else {
+ entity->base.source_position = specifiers->source_position;
+ }
entity->base.namespc = NAMESPACE_NORMAL;
entity->declaration.type = orig_type;
entity->declaration.modifiers = env.modifiers;
get_entity_kind_name(new_kind), &old->base.source_position);
}
+static bool is_error_entity(entity_t *const ent)
+{
+ if (is_declaration(ent)) {
+ return is_type_valid(skip_typeref(ent->declaration.type));
+ } else if (ent->kind == ENTITY_TYPEDEF) {
+ return is_type_valid(skip_typeref(ent->typedefe.type));
+ }
+ return false;
+}
+
/**
* record entities for the NAMESPACE_NORMAL, and produce error messages/warnings
* for various problems that occur for multiple definitions
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);
+ /* can happen in error cases */
+ if (symbol == NULL)
+ return entity;
+
+ entity_t *const previous_entity = get_entity(symbol, namespc);
/* pushing the same entity twice will break the stack structure */
assert(previous_entity != 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_declaration(entity) &&
+ 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 (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_PARAMETER);
- errorf(pos,
- "declaration '%#T' redeclares the parameter '%#T' (declared %P)",
- entity->declaration.type, symbol,
- previous_entity->declaration.type, symbol,
- &previous_entity->base.source_position);
- goto finish;
- }
-
- if (previous_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 */
+ if (previous_entity != NULL) {
+ if (previous_entity->base.parent_scope == ¤t_function->parameters &&
+ previous_entity->base.parent_scope->depth + 1 == current_scope->depth) {
+ assert(previous_entity->kind == ENTITY_PARAMETER);
errorf(pos,
- "redefinition of typedef '%Y' (declared %P)",
- symbol, &previous_entity->base.source_position);
+ "declaration '%#T' redeclares the parameter '%#T' (declared %P)",
+ entity->declaration.type, symbol,
+ previous_entity->declaration.type, 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_PARAMETER
- && previous_entity->declaration.type == NULL
- && entity->kind == ENTITY_PARAMETER) {
- 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);
+ if (previous_entity->base.parent_scope == current_scope) {
+ if (previous_entity->kind != entity->kind) {
+ if (!is_error_entity(previous_entity) && !is_error_entity(entity)) {
+ 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;
+ }
- type_t *prev_type = skip_typeref(previous_declaration->type);
+ /* at this point we should have only VARIABLES or FUNCTIONS */
+ assert(is_declaration(previous_entity) && is_declaration(entity));
- if (!types_compatible(type, prev_type)) {
- errorf(pos,
- "declaration '%#T' is incompatible with '%#T' (declared %P)",
- orig_type, symbol, previous_declaration->type, symbol,
- &previous_entity->base.source_position);
- } else {
- unsigned old_storage_class = previous_declaration->storage_class;
- 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);
- }
+ declaration_t *const prev_decl = &previous_entity->declaration;
+ declaration_t *const decl = &entity->declaration;
- unsigned new_storage_class = declaration->storage_class;
- if (is_type_incomplete(prev_type)) {
- previous_declaration->type = type;
- prev_type = type;
+ /* can happen for K&R style declarations */
+ if (prev_decl->type == NULL &&
+ previous_entity->kind == ENTITY_PARAMETER &&
+ entity->kind == ENTITY_PARAMETER) {
+ prev_decl->type = decl->type;
+ prev_decl->storage_class = decl->storage_class;
+ prev_decl->declared_storage_class = decl->declared_storage_class;
+ prev_decl->modifiers = decl->modifiers;
+ prev_decl->deprecated_string = decl->deprecated_string;
+ return previous_entity;
}
- /* pretend no storage class means extern for function
- * declarations (except if the previous declaration is neither
- * none nor extern) */
- if (entity->kind == ENTITY_FUNCTION) {
- if (prev_type->function.unspecified_parameters) {
- previous_declaration->type = type;
- prev_type = type;
+ type_t *const orig_type = decl->type;
+ assert(orig_type != NULL);
+ type_t *const type = skip_typeref(orig_type);
+ type_t *const prev_type = skip_typeref(prev_decl->type);
+
+ if (!types_compatible(type, prev_type)) {
+ errorf(pos,
+ "declaration '%#T' is incompatible with '%#T' (declared %P)",
+ orig_type, symbol, prev_decl->type, symbol,
+ &previous_entity->base.source_position);
+ } else {
+ unsigned old_storage_class = prev_decl->storage_class;
+ if (warning.redundant_decls &&
+ is_definition &&
+ !prev_decl->used &&
+ !(prev_decl->modifiers & DM_USED) &&
+ prev_decl->storage_class == STORAGE_CLASS_STATIC) {
+ warningf(&previous_entity->base.source_position,
+ "unnecessary static forward declaration for '%#T'",
+ prev_decl->type, symbol);
}
- switch (old_storage_class) {
- case STORAGE_CLASS_NONE:
- old_storage_class = STORAGE_CLASS_EXTERN;
- /* FALLTHROUGH */
-
- case STORAGE_CLASS_EXTERN:
- if (is_definition) {
- if (warning.missing_prototypes &&
- 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) {
- new_storage_class = STORAGE_CLASS_EXTERN;
- }
- break;
+ storage_class_t new_storage_class = decl->storage_class;
+
+ /* pretend no storage class means extern for function
+ * declarations (except if the previous declaration is neither
+ * none nor extern) */
+ if (entity->kind == ENTITY_FUNCTION) {
+ /* the previous declaration could have unspecified parameters or
+ * be a typedef, so use the new type */
+ if (prev_type->function.unspecified_parameters || is_definition)
+ prev_decl->type = type;
+
+ switch (old_storage_class) {
+ case STORAGE_CLASS_NONE:
+ old_storage_class = STORAGE_CLASS_EXTERN;
+ /* FALLTHROUGH */
+
+ case STORAGE_CLASS_EXTERN:
+ if (is_definition) {
+ if (warning.missing_prototypes &&
+ 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) {
+ new_storage_class = STORAGE_CLASS_EXTERN;
+ }
+ break;
- default:
- break;
+ default:
+ break;
+ }
+ } else if (is_type_incomplete(prev_type)) {
+ prev_decl->type = type;
}
- }
- if (old_storage_class == STORAGE_CLASS_EXTERN &&
- new_storage_class == STORAGE_CLASS_EXTERN) {
+ if (old_storage_class == STORAGE_CLASS_EXTERN &&
+ new_storage_class == STORAGE_CLASS_EXTERN) {
warn_redundant_declaration:
- 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(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) {
+ 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(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) {
+ prev_decl->storage_class = STORAGE_CLASS_NONE;
+ prev_decl->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);
+ 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);
+ }
}
}
+
+ prev_decl->modifiers |= decl->modifiers;
+ if (entity->kind == ENTITY_FUNCTION) {
+ previous_entity->function.is_inline |= entity->function.is_inline;
+ }
+ return previous_entity;
}
- previous_declaration->modifiers |= declaration->modifiers;
- if (entity->kind == ENTITY_FUNCTION) {
- previous_entity->function.is_inline |= entity->function.is_inline;
+ if (warning.shadow) {
+ warningf(pos, "%s '%Y' shadows %s (declared %P)",
+ get_entity_kind_name(entity->kind), symbol,
+ get_entity_kind_name(previous_entity->kind),
+ &previous_entity->base.source_position);
}
- return previous_entity;
}
if (entity->kind == ENTITY_FUNCTION) {
entity->declaration.type, symbol);
}
}
- } else if (warning.missing_declarations
- && entity->kind == ENTITY_VARIABLE
- && current_scope == file_scope) {
+ } 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) {
warningf(pos, "no previous declaration for '%#T'",
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)",
+ errorf(source_position, "multiple definition of '%Y' (declared %P)",
entity->base.symbol, &entity->base.source_position);
}
current_init_decl = NULL;
if (entity->kind == ENTITY_VARIABLE) {
- /* § 6.7.5 (22) array initializers for arrays with unknown size
+ /* §6.7.5:22 array initializers for arrays with unknown size
* determine the array type size */
declaration->type = env.type;
entity->variable.initializer = initializer;
if (decl->storage_class != STORAGE_CLASS_NONE)
return;
- type_t *type = decl->type;
- if (!is_type_incomplete(skip_typeref(type)))
+ type_t *const orig_type = decl->type;
+ type_t *const type = skip_typeref(orig_type);
+ if (!is_type_incomplete(type))
return;
+ /* §6.9.2:2 and §6.9.2:5: At the end of the translation incomplete arrays
+ * are given length one. */
+ if (is_type_array(type) && ent->base.parent_scope == file_scope) {
+ ARR_APP1(declaration_t*, incomplete_arrays, decl);
+ return;
+ }
+
errorf(&ent->base.source_position, "variable '%#T' has incomplete type",
- type, ent->base.symbol);
+ orig_type, ent->base.symbol);
}
ndeclaration = parse_declarator(specifiers, flags);
rem_anchor_token('=');
}
- expect(';');
+ expect(';', end_error);
end_error:
anonymous_entity = NULL;
}
if (is_definition) {
- errorf(HERE, "parameter %Y is initialised", entity->base.symbol);
+ errorf(HERE, "parameter '%Y' is initialised", entity->base.symbol);
}
return record_entity(entity, false);
}
/* parse declaration list */
- while (is_declaration_specifier(&token, false)) {
- parse_declaration(finished_kr_declaration, DECL_IS_PARAMETER);
+ for (;;) {
+ switch (token.type) {
+ DECLARATION_START
+ case T___extension__:
+ /* This covers symbols, which are no type, too, and results in
+ * better error messages. The typical cases are misspelled type
+ * names and missing includes. */
+ case T_IDENTIFIER:
+ parse_declaration(finished_kr_declaration, DECL_IS_PARAMETER);
+ break;
+ default:
+ goto decl_list_end;
+ }
}
+decl_list_end:
/* pop function parameters */
assert(current_scope == &entity->function.parameters);
parameter = entity->function.parameters.entities;
for (; parameter != NULL; parameter = parameter->base.next) {
+ if (parameter->kind != ENTITY_PARAMETER)
+ continue;
+
type_t *parameter_type = parameter->declaration.type;
if (parameter_type == NULL) {
if (strict_mode) {
last_parameter = function_parameter;
}
- /* § 6.9.1.7: A K&R style parameter list does NOT act as a function
+ /* §6.9.1.7: A K&R style parameter list does NOT act as a function
* prototype */
new_type->function.parameters = parameters;
new_type->function.unspecified_parameters = true;
- type = typehash_insert(new_type);
- if (type != new_type) {
- obstack_free(type_obst, new_type);
- }
+ new_type = identify_new_type(new_type);
- entity->declaration.type = type;
+ entity->declaration.type = new_type;
rem_anchor_token('{');
}
}
}
-static void warn_unused_entity(entity_t *entity, entity_t *end)
+static void warn_unused_entity(entity_t *entity, entity_t *last)
{
- for (; entity != NULL; entity = entity->base.next) {
+ entity_t const *const end = last != NULL ? last->base.next : NULL;
+ for (; entity != end; entity = entity->base.next) {
if (!is_declaration(entity))
continue;
warningf(&entity->base.source_position, "%s '%Y' is never read",
what, entity->base.symbol);
}
-
- if (entity == end)
- break;
}
}
}
static void check_reachable(statement_t *);
+static bool reaches_end;
static bool expression_returns(expression_t const *const expr)
{
case EXPR_FUNCNAME:
case EXPR_BUILTIN_SYMBOL:
case EXPR_BUILTIN_CONSTANT_P:
- case EXPR_BUILTIN_PREFETCH:
+ case EXPR_BUILTIN_TYPES_COMPATIBLE_P:
case EXPR_OFFSETOF:
case EXPR_INVALID:
return true;
- case EXPR_STATEMENT:
+ case EXPR_STATEMENT: {
+ bool old_reaches_end = reaches_end;
+ reaches_end = false;
check_reachable(expr->statement.statement);
- // TODO check if statement can be left
- return true;
+ bool returns = reaches_end;
+ reaches_end = old_reaches_end;
+ return returns;
+ }
case EXPR_CONDITIONAL:
// TODO handle constant expression
if (!expression_returns(expr->conditional.condition))
return false;
- if (expr->condition.true_expression != NULL
+ if (expr->conditional.true_expression != NULL
&& expression_returns(expr->conditional.true_expression))
return true;
switch (stmt->kind) {
case STATEMENT_INVALID:
case STATEMENT_EMPTY:
- case STATEMENT_LOCAL_LABEL:
case STATEMENT_ASM:
next = stmt->base.next;
break;
declaration_statement_t const *const decl = &stmt->declaration;
entity_t const * ent = decl->declarations_begin;
entity_t const *const last = decl->declarations_end;
- for (;; ent = ent->base.next) {
- if (ent->kind == ENTITY_VARIABLE &&
- ent->variable.initializer != NULL &&
- !initializer_returns(ent->variable.initializer)) {
- return;
+ if (ent != NULL) {
+ for (;; ent = ent->base.next) {
+ if (ent->kind == ENTITY_VARIABLE &&
+ ent->variable.initializer != NULL &&
+ !initializer_returns(ent->variable.initializer)) {
+ return;
+ }
+ if (ent == last)
+ break;
}
- if (ent == last)
- break;
}
next = stmt->base.next;
break;
case STATEMENT_COMPOUND:
next = stmt->compound.statements;
+ if (next == NULL)
+ next = stmt->base.next;
break;
case STATEMENT_RETURN: {
}
break;
}
+
+ default:
+ panic("invalid statement kind");
}
while (next == NULL) {
if (next == NULL) {
noreturn_candidate = false;
- type_t *const type = current_function->base.type;
+ type_t *const type = skip_typeref(current_function->base.type);
assert(is_type_function(type));
type_t *const ret = skip_typeref(type->function.return_type);
if (warning.return_type &&
case STATEMENT_INVALID:
case STATEMENT_EMPTY:
case STATEMENT_DECLARATION:
- case STATEMENT_LOCAL_LABEL:
case STATEMENT_EXPRESSION:
case STATEMENT_ASM:
case STATEMENT_RETURN:
panic("invalid control flow in function");
case STATEMENT_COMPOUND:
+ if (next->compound.stmt_expr) {
+ reaches_end = true;
+ return;
+ }
+ /* FALLTHROUGH */
case STATEMENT_IF:
case STATEMENT_SWITCH:
case STATEMENT_LABEL:
declaration_statement_t const *const decl = &stmt->declaration;
entity_t const * ent = decl->declarations_begin;
entity_t const *const last = decl->declarations_end;
- for (;; ent = ent->base.next) {
- if (ent->kind == ENTITY_VARIABLE &&
- ent->variable.initializer != NULL) {
- goto warn_unreachable;
+ if (ent != NULL) {
+ for (;; ent = ent->base.next) {
+ if (ent->kind == ENTITY_VARIABLE &&
+ ent->variable.initializer != NULL) {
+ goto warn_unreachable;
+ }
+ if (ent == last)
+ return;
}
- if (ent == last)
- return;
}
}
}
assert(is_declaration(ndeclaration));
- type_t *type = skip_typeref(ndeclaration->declaration.type);
+ type_t *const orig_type = ndeclaration->declaration.type;
+ type_t * type = skip_typeref(orig_type);
if (!is_type_function(type)) {
if (is_type_valid(type)) {
}
eat_block();
return;
+ } else if (is_typeref(orig_type)) {
+ /* §6.9.1:2 */
+ errorf(&ndeclaration->base.source_position,
+ "type of function definition '%#T' is a typedef",
+ orig_type, ndeclaration->base.symbol);
}
if (warning.aggregate_return &&
ndeclaration->base.symbol);
}
- /* § 6.7.5.3 (14) a function definition with () means no
+ /* §6.7.5.3:14 a function definition with () means no
* parameters (and not unspecified parameters) */
- if (type->function.unspecified_parameters
- && type->function.parameters == NULL
- && !type->function.kr_style_parameters) {
- type_t *duplicate = duplicate_type(type);
- duplicate->function.unspecified_parameters = false;
+ if (type->function.unspecified_parameters &&
+ type->function.parameters == NULL &&
+ !type->function.kr_style_parameters) {
+ type_t *copy = duplicate_type(type);
+ copy->function.unspecified_parameters = false;
+ type = identify_new_type(copy);
- type = typehash_insert(duplicate);
- if (type != duplicate) {
- obstack_free(type_obst, duplicate);
- }
ndeclaration->declaration.type = type;
}
entity->declaration.storage_class = STORAGE_CLASS_NONE;
entity->declaration.modifiers = specifiers->modifiers;
entity->declaration.type = type;
+ append_entity(&compound->members, entity);
} else {
entity = parse_declarator(specifiers,
DECL_MAY_BE_ABSTRACT | DECL_CREATE_COMPOUND_MEMBER);
- assert(entity->kind == ENTITY_COMPOUND_MEMBER);
-
- if (token.type == ':') {
- source_position_t source_position = *HERE;
- next_token();
- expression_t *size = parse_constant_expression();
-
- 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 = entity->base.symbol;
- if (symbol != NULL) {
- entity_t *prev = find_compound_entry(compound, symbol);
-
- if (prev != NULL) {
+ if (entity->kind == ENTITY_TYPEDEF) {
errorf(&entity->base.source_position,
- "multiple declarations of symbol '%Y' (declared %P)",
- symbol, &prev->base.source_position);
- }
- }
+ "typedef not allowed as compound member");
+ } else {
+ assert(entity->kind == ENTITY_COMPOUND_MEMBER);
+
+ /* make sure we don't define a symbol multiple times */
+ symbol_t *symbol = entity->base.symbol;
+ if (symbol != NULL) {
+ entity_t *prev = find_compound_entry(compound, symbol);
+ if (prev != NULL) {
+ errorf(&entity->base.source_position,
+ "multiple declarations of symbol '%Y' (declared %P)",
+ symbol, &prev->base.source_position);
+ }
+ }
- append_entity(&compound->members, entity);
+ if (token.type == ':') {
+ source_position_t source_position = *HERE;
+ next_token();
+ expression_t *size = parse_constant_expression();
- type_t *orig_type = entity->declaration.type;
- type_t *type = skip_typeref(orig_type);
- if (is_type_function(type)) {
- errorf(&entity->base.source_position,
- "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) &&
- token.type == ';' &&
- look_ahead(1)->type == '}') {
- compound->has_flexible_member = true;
- } else {
- errorf(&entity->base.source_position,
- "compound member '%Y' has incomplete type '%T'",
- entity->base.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;
+ } else {
+ type_t *orig_type = entity->declaration.type;
+ type_t *type = skip_typeref(orig_type);
+ if (is_type_function(type)) {
+ errorf(&entity->base.source_position,
+ "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) &&
+ token.type == ';' &&
+ look_ahead(1)->type == '}') {
+ compound->has_flexible_member = true;
+ } else {
+ errorf(&entity->base.source_position,
+ "compound member '%Y' has incomplete type '%T'",
+ entity->base.symbol, orig_type);
+ }
+ }
+ }
+
+ append_entity(&compound->members, entity);
}
}
break;
next_token();
}
- expect(';');
+ expect(';', end_error);
end_error:
anonymous_entity = NULL;
typedef struct expression_parser_function_t expression_parser_function_t;
struct expression_parser_function_t {
parse_expression_function parser;
- unsigned infix_precedence;
+ precedence_t infix_precedence;
parse_expression_infix_function infix_parser;
};
{
/* skip the error message if the error token was read */
if (token.type != T_ERROR) {
- errorf(HERE, "expected expression, got token '%K'", &token);
+ errorf(HERE, "expected expression, got token %K", &token);
}
next_token();
type_t *ntype = allocate_type_zero(TYPE_FUNCTION);
ntype->function.return_type = type_int;
ntype->function.unspecified_parameters = true;
-
- type_t *type = typehash_insert(ntype);
- if (type != ntype) {
- free_type(ntype);
- }
+ ntype->function.linkage = LINKAGE_C;
+ type_t *type = identify_new_type(ntype);
entity_t *entity = allocate_entity_zero(ENTITY_FUNCTION);
entity->declaration.storage_class = STORAGE_CLASS_EXTERN;
type->function.return_type = return_type;
type->function.parameters = parameter1;
- type_t *result = typehash_insert(type);
- if (result != type) {
- free_type(type);
- }
-
- return result;
+ return identify_new_type(type);
}
/**
type->function.return_type = return_type;
type->function.parameters = parameter;
- type_t *result = typehash_insert(type);
- if (result != type) {
- free_type(type);
- }
+ return identify_new_type(type);
+}
- return result;
+static type_t *make_function_1_type_variadic(type_t *return_type, type_t *argument_type)
+{
+ type_t *res = make_function_1_type(return_type, argument_type);
+ res->function.variadic = 1;
+ return res;
}
+/**
+ * Creates a return_type (func)(void) function type if not
+ * already exists.
+ *
+ * @param return_type the return type
+ */
static type_t *make_function_0_type(type_t *return_type)
{
type_t *type = allocate_type_zero(TYPE_FUNCTION);
type->function.return_type = return_type;
type->function.parameters = NULL;
- type_t *result = typehash_insert(type);
- if (result != type) {
- free_type(type);
- }
-
- return result;
+ return identify_new_type(type);
}
/**
return make_function_1_type(type_void, type_valist);
case T___builtin_expect:
return make_function_2_type(type_long, type_long, type_long);
+ case T___builtin_return_address:
+ case T___builtin_frame_address:
+ return make_function_1_type(type_void_ptr, type_unsigned_int);
+ case T___builtin_prefetch:
+ return make_function_1_type_variadic(type_float, type_void_ptr);
default:
- internal_errorf(HERE, "not implemented builtin symbol found");
+ internal_errorf(HERE, "not implemented builtin identifier found");
}
}
/**
- * Performs automatic type cast as described in § 6.3.2.1.
+ * Performs automatic type cast as described in §6.3.2.1.
*
* @param orig_type the original type
*/
/**
* reverts the automatic casts of array to pointer types and function
- * to function-pointer types as defined § 6.3.2.1
+ * to function-pointer types as defined §6.3.2.1
*/
type_t *revert_automatic_type_conversion(const expression_t *expression)
{
assert(is_declaration(entity));
type_t *type = entity->declaration.type;
return get_qualified_type(type,
- expression->base.type->base.qualifiers);
+ expression->base.type->base.qualifiers);
}
case EXPR_UNARY_DEREFERENCE: {
const expression_t *const value = expression->unary.value;
type_t *const type = skip_typeref(value->base.type);
- assert(is_type_pointer(type));
+ if (!is_type_pointer(type))
+ return type_error_type;
return type->pointer.points_to;
}
case EXPR_ARRAY_ACCESS: {
const expression_t *array_ref = expression->array_access.array_ref;
type_t *type_left = skip_typeref(array_ref->base.type);
- if (!is_type_valid(type_left))
- return type_left;
- assert(is_type_pointer(type_left));
+ if (!is_type_pointer(type_left))
+ return type_error_type;
return type_left->pointer.points_to;
}
case EXPR_COMPOUND_LITERAL:
return expression->compound_literal.type;
- default: break;
+ default:
+ return expression->base.type;
}
-
- return expression->base.type;
}
static expression_t *parse_reference(void)
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);
+ if (warning.error_implicit_function_declaration) {
+ errorf(HERE, "implicit declaration of function '%Y'", symbol);
+ } else if (warning.implicit_function_declaration) {
+ warningf(HERE, "implicit declaration of function '%Y'", symbol);
}
entity = create_implicit_function(symbol, HERE);
} else {
- errorf(HERE, "unknown symbol '%Y' found.", symbol);
+ errorf(HERE, "unknown identifier '%Y' found.", symbol);
entity = create_error_entity(symbol, ENTITY_VARIABLE);
}
}
type_t *type = parse_typename();
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
if (token.type == '{') {
return parse_compound_literal(type);
expression_t *expression = allocate_expression_zero(EXPR_STATEMENT);
statement_t *statement = parse_compound_statement(true);
+ statement->compound.stmt_expr = true;
expression->statement.statement = statement;
/* find last statement and use its type */
expression->base.type = type;
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
end_error:
return expression;
add_anchor_token(')');
expression_t *result = parse_expression();
+ result->base.parenthesized = true;
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
end_error:
return result;
designator->source_position = *HERE;
designator->array_index = parse_expression();
rem_anchor_token(']');
- expect(']');
+ expect(']', end_error);
if (designator->array_index == NULL) {
return NULL;
}
eat(T___builtin_offsetof);
- expect('(');
+ expect('(', end_error);
add_anchor_token(',');
type_t *type = parse_typename();
rem_anchor_token(',');
- expect(',');
+ expect(',', end_error);
add_anchor_token(')');
designator_t *designator = parse_designator();
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
expression->offsetofe.type = type;
expression->offsetofe.designator = designator;
eat(T___builtin_va_start);
- expect('(');
+ expect('(', end_error);
add_anchor_token(',');
expression->va_starte.ap = parse_assignment_expression();
rem_anchor_token(',');
- expect(',');
+ expect(',', end_error);
expression_t *const expr = parse_assignment_expression();
if (expr->kind == EXPR_REFERENCE) {
entity_t *const entity = expr->reference.entity;
} else {
expression->va_starte.parameter = &entity->variable;
}
- expect(')');
+ expect(')', end_error);
return expression;
}
- expect(')');
+ expect(')', end_error);
end_error:
return create_invalid_expression();
}
eat(T___builtin_va_arg);
- expect('(');
+ expect('(', end_error);
expression->va_arge.ap = parse_assignment_expression();
- expect(',');
+ expect(',', end_error);
expression->base.type = parse_typename();
- expect(')');
+ expect(')', end_error);
return expression;
end_error:
}
/**
- * Parses a __builtin_constant() expression.
+ * Parses a __builtin_constant_p() expression.
*/
static expression_t *parse_builtin_constant(void)
{
eat(T___builtin_constant_p);
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
expression->builtin_constant.value = parse_assignment_expression();
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
expression->base.type = type_int;
return expression;
}
/**
- * Parses a __builtin_prefetch() expression.
+ * Parses a __builtin_types_compatible_p() expression.
*/
-static expression_t *parse_builtin_prefetch(void)
+static expression_t *parse_builtin_types_compatible(void)
{
- expression_t *expression = allocate_expression_zero(EXPR_BUILTIN_PREFETCH);
+ expression_t *expression = allocate_expression_zero(EXPR_BUILTIN_TYPES_COMPATIBLE_P);
- eat(T___builtin_prefetch);
+ eat(T___builtin_types_compatible_p);
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
- expression->builtin_prefetch.adr = parse_assignment_expression();
- if (token.type == ',') {
- next_token();
- expression->builtin_prefetch.rw = parse_assignment_expression();
- }
- if (token.type == ',') {
- next_token();
- expression->builtin_prefetch.locality = parse_assignment_expression();
- }
+ add_anchor_token(',');
+ expression->builtin_types_compatible.left = parse_typename();
+ rem_anchor_token(',');
+ expect(',', end_error);
+ expression->builtin_types_compatible.right = parse_typename();
rem_anchor_token(')');
- expect(')');
- expression->base.type = type_void;
+ expect(')', end_error);
+ expression->base.type = type_int;
return expression;
end_error:
expression->base.source_position = *HERE;
next_token();
- expect('(');
+ expect('(', end_error);
expression->binary.left = parse_assignment_expression();
- expect(',');
+ expect(',', end_error);
expression->binary.right = parse_assignment_expression();
- expect(')');
+ expect(')', end_error);
type_t *const orig_type_left = expression->binary.left->base.type;
type_t *const orig_type_right = expression->binary.right->base.type;
#if 0
/**
- * Parses a __builtin_expect() expression.
+ * Parses a __builtin_expect(, end_error) expression.
*/
-static expression_t *parse_builtin_expect(void)
+static expression_t *parse_builtin_expect(void, end_error)
{
expression_t *expression
= allocate_expression_zero(EXPR_BINARY_BUILTIN_EXPECT);
eat(T___builtin_expect);
- expect('(');
+ expect('(', end_error);
expression->binary.left = parse_assignment_expression();
- expect(',');
+ expect(',', end_error);
expression->binary.right = parse_constant_expression();
- expect(')');
+ expect(')', end_error);
expression->base.type = expression->binary.left->base.type;
eat(T__assume);
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
expression->unary.value = parse_assignment_expression();
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
expression->base.type = type_void;
return expression;
}
rem_anchor_token(',');
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
end_error:
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_FLOATINGPOINT: return parse_float_const();
+ 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_FLOATINGPOINT: return parse_float_const();
case T_STRING_LITERAL:
- case T_WIDE_STRING_LITERAL: return parse_string_const();
- case T_IDENTIFIER: return parse_reference();
+ case T_WIDE_STRING_LITERAL: return parse_string_const();
+ case T_IDENTIFIER: return parse_reference();
case T___FUNCTION__:
- case T___func__: return parse_function_keyword();
- case T___PRETTY_FUNCTION__: return parse_pretty_function_keyword();
- case T___FUNCSIG__: return parse_funcsig_keyword();
- case T___FUNCDNAME__: return parse_funcdname_keyword();
- case T___builtin_offsetof: return parse_offsetof();
- case T___builtin_va_start: return parse_va_start();
- case T___builtin_va_arg: return parse_va_arg();
+ case T___func__: return parse_function_keyword();
+ case T___PRETTY_FUNCTION__: return parse_pretty_function_keyword();
+ case T___FUNCSIG__: return parse_funcsig_keyword();
+ case T___FUNCDNAME__: return parse_funcdname_keyword();
+ case T___builtin_offsetof: return parse_offsetof();
+ case T___builtin_va_start: return parse_va_start();
+ case T___builtin_va_arg: return parse_va_arg();
case T___builtin_expect:
case T___builtin_alloca:
case T___builtin_inf:
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_va_end:
+ case T___builtin_return_address:
+ case T___builtin_frame_address:
+ case T___builtin_prefetch: return parse_builtin_symbol();
case T___builtin_isgreater:
case T___builtin_isgreaterequal:
case T___builtin_isless:
case T___builtin_islessequal:
case T___builtin_islessgreater:
- case T___builtin_isunordered: return parse_compare_builtin();
- 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___builtin_isunordered: return parse_compare_builtin();
+ case T___builtin_constant_p: return parse_builtin_constant();
+ case T___builtin_types_compatible_p: return parse_builtin_types_compatible();
+ case T__assume: return parse_assume();
case T_ANDAND:
if (GNU_MODE)
return parse_label_address();
break;
- case '(': return parse_parenthesized_expression();
- case T___noop: return parse_noop_expression();
+ case '(': return parse_parenthesized_expression();
+ case T___noop: return parse_noop_expression();
}
- errorf(HERE, "unexpected token '%K', expected an expression", &token);
+ errorf(HERE, "unexpected token %K, expected an expression", &token);
return create_invalid_expression();
}
expression->base.type = automatic_type_conversion(return_type);
rem_anchor_token(']');
- expect(']');
+ expect(']', end_error);
end_error:
return expression;
}
add_anchor_token(')');
orig_type = parse_typename();
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
if (token.type == '{') {
/* It was not sizeof(type) after all. It is sizeof of an expression
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" :
+ GNU_MODE && is_type_atomic(type, ATOMIC_TYPE_VOID) ? NULL :
+ 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";
symbol, type_left);
}
create_error_entry:
- return create_invalid_expression();
+ entry = create_error_entity(symbol, ENTITY_COMPOUND_MEMBER);
}
assert(is_declaration(entry));
}
}
+/**
+ * Handle the semantic restrictions of builtin calls
+ */
+static void handle_builtin_argument_restrictions(call_expression_t *call) {
+ switch (call->function->builtin_symbol.symbol->ID) {
+ case T___builtin_return_address:
+ case T___builtin_frame_address: {
+ /* argument must be constant */
+ call_argument_t *argument = call->arguments;
+
+ if (! is_constant_expression(argument->expression)) {
+ errorf(&call->base.source_position,
+ "argument of '%Y' must be a constant expression",
+ call->function->builtin_symbol.symbol);
+ }
+ break;
+ }
+ case T___builtin_prefetch: {
+ /* second and third argument must be constant if existant */
+ call_argument_t *rw = call->arguments->next;
+ call_argument_t *locality = NULL;
+
+ if (rw != NULL) {
+ if (! is_constant_expression(rw->expression)) {
+ errorf(&call->base.source_position,
+ "second argument of '%Y' must be a constant expression",
+ call->function->builtin_symbol.symbol);
+ }
+ locality = rw->next;
+ }
+ if (locality != NULL) {
+ if (! is_constant_expression(locality->expression)) {
+ errorf(&call->base.source_position,
+ "third argument of '%Y' must be a constant expression",
+ call->function->builtin_symbol.symbol);
+ }
+ locality = rw->next;
+ }
+ break;
+ }
+ default:
+ break;
+ }
+}
+
/**
* Parse a call expression, ie. expression '( ... )'.
*
}
rem_anchor_token(',');
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
if (function_type == NULL)
return result;
"function call has aggregate value");
}
+ if (call->function->kind == EXPR_BUILTIN_SYMBOL) {
+ handle_builtin_argument_restrictions(&result->call);
+ }
+
end_error:
return result;
}
}
}
+static void warn_assignment_in_condition(const expression_t *const expr)
+{
+ if (!warning.parentheses)
+ return;
+ if (expr->base.kind != EXPR_BINARY_ASSIGN)
+ return;
+ if (expr->base.parenthesized)
+ return;
+ warningf(&expr->base.source_position,
+ "suggest parentheses around assignment used as truth value");
+}
+
static void semantic_condition(expression_t const *const expr,
char const *const context)
{
type_t *const type = skip_typeref(expr->base.type);
if (is_type_scalar(type)) {
warn_reference_address_as_bool(expr);
+ warn_assignment_in_condition(expr);
} else if (is_type_valid(type)) {
errorf(&expr->base.source_position,
"%s must have scalar type", context);
true_expression = parse_expression();
}
rem_anchor_token(':');
- expect(':');
+ expect(':', end_error);
+end_error:;
expression_t *false_expression =
parse_sub_expression(c_mode & _CXX ? PREC_ASSIGNMENT : PREC_CONDITIONAL);
= create_implicit_cast(false_expression, result_type);
conditional->base.type = result_type;
return result;
-end_error:
- return create_invalid_expression();
}
/**
eat(T___builtin_classify_type);
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
expression_t *expression = parse_expression();
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
result->classify_type.type_expression = expression;
return result;
if (token.type == '[') {
next_token();
result->kind = EXPR_UNARY_DELETE_ARRAY;
- expect(']');
+ expect(']', end_error);
end_error:;
}
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");
+ if (is_type_valid(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,
static bool is_lvalue(const expression_t *expression)
{
- /* TODO: doesn't seem to be consistent with §6.3.2.1 (1) */
+ /* 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_COMPOUND_LITERAL:
+ case EXPR_REFERENCE:
case EXPR_SELECT:
case EXPR_UNARY_DEREFERENCE:
return true;
type_left = get_unqualified_type(type_left);
type_right = get_unqualified_type(type_right);
- /* § 6.3.1.8 Usual arithmetic conversions */
+ /* §6.3.1.8 Usual arithmetic conversions */
if (type_left == type_long_double || type_right == type_long_double) {
return type_long_double;
} else if (type_left == type_double || type_right == type_double) {
/**
* Check the semantic restrictions for a div/mod expression.
*/
-static void semantic_divmod_arithmetic(binary_expression_t *expression) {
+static void semantic_divmod_arithmetic(binary_expression_t *expression)
+{
semantic_binexpr_arithmetic(expression);
warn_div_by_zero(expression);
}
+static void warn_addsub_in_shift(const expression_t *const expr)
+{
+ if (expr->base.parenthesized)
+ return;
+
+ char op;
+ switch (expr->kind) {
+ case EXPR_BINARY_ADD: op = '+'; break;
+ case EXPR_BINARY_SUB: op = '-'; break;
+ default: return;
+ }
+
+ warningf(&expr->base.source_position,
+ "suggest parentheses around '%c' inside shift", op);
+}
+
static void semantic_shift_op(binary_expression_t *expression)
{
expression_t *const left = expression->left;
return;
}
+ if (warning.parentheses) {
+ warn_addsub_in_shift(left);
+ warn_addsub_in_shift(right);
+ }
+
type_left = promote_integer(type_left);
type_right = promote_integer(type_right);
type_t *const type_left = skip_typeref(orig_type_left);
type_t *const type_right = skip_typeref(orig_type_right);
- /* § 6.5.6 */
+ /* §6.5.6 */
if (is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
type_t *arithmetic_type = semantic_arithmetic(type_left, type_right);
expression->left = create_implicit_cast(left, arithmetic_type);
expression->right = create_implicit_cast(right, arithmetic_type);
expression->base.type = arithmetic_type;
- return;
} else if (is_type_pointer(type_left) && is_type_integer(type_right)) {
check_pointer_arithmetic(&expression->base.source_position,
type_left, 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 */
+ /* §5.6.5 */
if (is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
type_t *arithmetic_type = semantic_arithmetic(type_left, type_right);
expression->left = create_implicit_cast(left, arithmetic_type);
expression->right = create_implicit_cast(right, arithmetic_type);
expression->base.type = arithmetic_type;
- return;
} else if (is_type_pointer(type_left) && is_type_integer(type_right)) {
check_pointer_arithmetic(&expression->base.source_position,
type_left, orig_type_left);
}
}
+static void warn_comparison_in_comparison(const expression_t *const expr)
+{
+ if (expr->base.parenthesized)
+ return;
+ switch (expr->base.kind) {
+ case EXPR_BINARY_LESS:
+ case EXPR_BINARY_GREATER:
+ case EXPR_BINARY_LESSEQUAL:
+ case EXPR_BINARY_GREATEREQUAL:
+ case EXPR_BINARY_NOTEQUAL:
+ case EXPR_BINARY_EQUAL:
+ warningf(&expr->base.source_position,
+ "comparisons like 'x <= y < z' do not have their mathematical meaning");
+ break;
+ default:
+ break;
+ }
+}
+
+static bool maybe_negative(expression_t const *const expr)
+{
+ return
+ !is_constant_expression(expr) ||
+ fold_constant(expr) < 0;
+}
+
/**
* Check the semantics of comparison expressions.
*
}
}
+ if (warning.parentheses) {
+ warn_comparison_in_comparison(left);
+ warn_comparison_in_comparison(right);
+ }
+
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);
/* TODO non-arithmetic types */
if (is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
+ type_t *arithmetic_type = semantic_arithmetic(type_left, type_right);
+
/* test for signed vs unsigned compares */
- if (warning.sign_compare &&
- (expression->base.kind != EXPR_BINARY_EQUAL &&
- expression->base.kind != EXPR_BINARY_NOTEQUAL) &&
- (is_type_signed(type_left) != is_type_signed(type_right))) {
-
- /* check if 1 of the operands is a constant, in this case we just
- * check wether we can safely represent the resulting constant in
- * the type of the other operand. */
- expression_t *const_expr = NULL;
- expression_t *other_expr = NULL;
-
- if (is_constant_expression(left)) {
- const_expr = left;
- other_expr = right;
- } else if (is_constant_expression(right)) {
- const_expr = right;
- other_expr = left;
- }
-
- if (const_expr != NULL) {
- type_t *other_type = skip_typeref(other_expr->base.type);
- long val = fold_constant(const_expr);
- /* TODO: check if val can be represented by other_type */
- (void) other_type;
- (void) val;
+ if (warning.sign_compare && is_type_integer(arithmetic_type)) {
+ bool const signed_left = is_type_signed(type_left);
+ bool const signed_right = is_type_signed(type_right);
+ if (signed_left != signed_right) {
+ /* FIXME long long needs better const folding magic */
+ /* TODO check whether constant value can be represented by other type */
+ if ((signed_left && maybe_negative(left)) ||
+ (signed_right && maybe_negative(right))) {
+ warningf(&expression->base.source_position,
+ "comparison between signed and unsigned");
+ }
}
- warningf(&expression->base.source_position,
- "comparison between signed and unsigned");
}
- type_t *arithmetic_type = semantic_arithmetic(type_left, type_right);
+
expression->left = create_implicit_cast(left, arithmetic_type);
expression->right = create_implicit_cast(right, arithmetic_type);
expression->base.type = arithmetic_type;
}
}
+static void warn_logical_and_within_or(const expression_t *const expr)
+{
+ if (expr->base.kind != EXPR_BINARY_LOGICAL_AND)
+ return;
+ if (expr->base.parenthesized)
+ return;
+ warningf(&expr->base.source_position,
+ "suggest parentheses around && within ||");
+}
+
/**
* Check the semantic restrictions of a logical expression.
*/
* §6.5.14:2 Each of the operands shall have scalar type. */
semantic_condition(expression->left, "left operand of logical operator");
semantic_condition(expression->right, "right operand of logical operator");
+ if (expression->base.kind == EXPR_BINARY_LOGICAL_OR &&
+ warning.parentheses) {
+ warn_logical_and_within_or(expression->left);
+ warn_logical_and_within_or(expression->right);
+ }
expression->base.type = c_mode & _CXX ? type_bool : type_int;
}
static bool expression_has_effect(const expression_t *const expr)
{
switch (expr->kind) {
- case EXPR_UNKNOWN: break;
- case EXPR_INVALID: return true; /* do NOT warn */
- case EXPR_REFERENCE: return false;
- case EXPR_REFERENCE_ENUM_VALUE: return false;
+ case EXPR_UNKNOWN: break;
+ case EXPR_INVALID: return true; /* do NOT warn */
+ case EXPR_REFERENCE: return false;
+ case EXPR_REFERENCE_ENUM_VALUE: return false;
/* suppress the warning for microsoft __noop operations */
- case EXPR_CONST: return expr->conste.is_ms_noop;
- case EXPR_CHARACTER_CONSTANT: return false;
- case EXPR_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_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;
return true;
switch (call->function->builtin_symbol.symbol->ID) {
- case T___builtin_va_end: return true;
- default: return false;
+ case T___builtin_prefetch:
+ case T___builtin_va_end: return true;
+ default: return false;
}
}
/* Generate the warning if either the left or right hand side of a
* conditional expression has no effect */
case EXPR_CONDITIONAL: {
- const conditional_expression_t *const cond = &expr->conditional;
+ conditional_expression_t const *const cond = &expr->conditional;
+ expression_t const *const t = cond->true_expression;
return
- expression_has_effect(cond->true_expression) &&
+ (t == NULL || expression_has_effect(t)) &&
expression_has_effect(cond->false_expression);
}
- case EXPR_SELECT: return false;
- case EXPR_ARRAY_ACCESS: return false;
- case EXPR_SIZEOF: return false;
- case EXPR_CLASSIFY_TYPE: return false;
- case EXPR_ALIGNOF: return false;
-
- case EXPR_FUNCNAME: return false;
- case EXPR_BUILTIN_SYMBOL: break; /* handled in EXPR_CALL */
- case EXPR_BUILTIN_CONSTANT_P: return false;
- case EXPR_BUILTIN_PREFETCH: return true;
- case EXPR_OFFSETOF: return false;
- case EXPR_VA_START: return true;
- case EXPR_VA_ARG: return true;
- case EXPR_STATEMENT: return true; // TODO
- case EXPR_COMPOUND_LITERAL: return false;
-
- case EXPR_UNARY_NEGATE: return false;
- case EXPR_UNARY_PLUS: return false;
- case EXPR_UNARY_BITWISE_NEGATE: return false;
- case EXPR_UNARY_NOT: return false;
- case EXPR_UNARY_DEREFERENCE: return false;
- case EXPR_UNARY_TAKE_ADDRESS: return false;
- case EXPR_UNARY_POSTFIX_INCREMENT: return true;
- case EXPR_UNARY_POSTFIX_DECREMENT: return true;
- case EXPR_UNARY_PREFIX_INCREMENT: return true;
- case EXPR_UNARY_PREFIX_DECREMENT: return true;
+ case EXPR_SELECT: return false;
+ case EXPR_ARRAY_ACCESS: return false;
+ case EXPR_SIZEOF: return false;
+ case EXPR_CLASSIFY_TYPE: return false;
+ case EXPR_ALIGNOF: return false;
+
+ case EXPR_FUNCNAME: return false;
+ case EXPR_BUILTIN_SYMBOL: break; /* handled in EXPR_CALL */
+ case EXPR_BUILTIN_CONSTANT_P: return false;
+ case EXPR_BUILTIN_TYPES_COMPATIBLE_P: return false;
+ case EXPR_OFFSETOF: return false;
+ case EXPR_VA_START: return true;
+ case EXPR_VA_ARG: return true;
+ case EXPR_STATEMENT: return true; // TODO
+ case EXPR_COMPOUND_LITERAL: return false;
+
+ case EXPR_UNARY_NEGATE: return false;
+ case EXPR_UNARY_PLUS: return false;
+ case EXPR_UNARY_BITWISE_NEGATE: return false;
+ case EXPR_UNARY_NOT: return false;
+ case EXPR_UNARY_DEREFERENCE: return false;
+ case EXPR_UNARY_TAKE_ADDRESS: return false;
+ case EXPR_UNARY_POSTFIX_INCREMENT: return true;
+ case EXPR_UNARY_POSTFIX_DECREMENT: return true;
+ case EXPR_UNARY_PREFIX_INCREMENT: return true;
+ case EXPR_UNARY_PREFIX_DECREMENT: return true;
/* Treat void casts as if they have an effect in order to being able to
* suppress the warning */
return is_type_atomic(type, ATOMIC_TYPE_VOID);
}
- 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;
- case EXPR_BINARY_MUL: return false;
- case EXPR_BINARY_DIV: return false;
- case EXPR_BINARY_MOD: return false;
- case EXPR_BINARY_EQUAL: return false;
- case EXPR_BINARY_NOTEQUAL: return false;
- case EXPR_BINARY_LESS: return false;
- case EXPR_BINARY_LESSEQUAL: return false;
- case EXPR_BINARY_GREATER: return false;
- case EXPR_BINARY_GREATEREQUAL: return false;
- case EXPR_BINARY_BITWISE_AND: return false;
- case EXPR_BINARY_BITWISE_OR: return false;
- case EXPR_BINARY_BITWISE_XOR: return false;
- case EXPR_BINARY_SHIFTLEFT: return false;
- case EXPR_BINARY_SHIFTRIGHT: return false;
- case EXPR_BINARY_ASSIGN: return true;
- case EXPR_BINARY_MUL_ASSIGN: return true;
- case EXPR_BINARY_DIV_ASSIGN: return true;
- case EXPR_BINARY_MOD_ASSIGN: return true;
- case EXPR_BINARY_ADD_ASSIGN: return true;
- case EXPR_BINARY_SUB_ASSIGN: return true;
- case EXPR_BINARY_SHIFTLEFT_ASSIGN: return true;
- case EXPR_BINARY_SHIFTRIGHT_ASSIGN: return true;
- case EXPR_BINARY_BITWISE_AND_ASSIGN: return true;
- case EXPR_BINARY_BITWISE_XOR_ASSIGN: return true;
- case EXPR_BINARY_BITWISE_OR_ASSIGN: return true;
+ 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;
+ case EXPR_BINARY_MUL: return false;
+ case EXPR_BINARY_DIV: return false;
+ case EXPR_BINARY_MOD: return false;
+ case EXPR_BINARY_EQUAL: return false;
+ case EXPR_BINARY_NOTEQUAL: return false;
+ case EXPR_BINARY_LESS: return false;
+ case EXPR_BINARY_LESSEQUAL: return false;
+ case EXPR_BINARY_GREATER: return false;
+ case EXPR_BINARY_GREATEREQUAL: return false;
+ case EXPR_BINARY_BITWISE_AND: return false;
+ case EXPR_BINARY_BITWISE_OR: return false;
+ case EXPR_BINARY_BITWISE_XOR: return false;
+ case EXPR_BINARY_SHIFTLEFT: return false;
+ case EXPR_BINARY_SHIFTRIGHT: return false;
+ case EXPR_BINARY_ASSIGN: return true;
+ case EXPR_BINARY_MUL_ASSIGN: return true;
+ case EXPR_BINARY_DIV_ASSIGN: return true;
+ case EXPR_BINARY_MOD_ASSIGN: return true;
+ case EXPR_BINARY_ADD_ASSIGN: return true;
+ case EXPR_BINARY_SUB_ASSIGN: return true;
+ case EXPR_BINARY_SHIFTLEFT_ASSIGN: return true;
+ case EXPR_BINARY_SHIFTRIGHT_ASSIGN: return true;
+ case EXPR_BINARY_BITWISE_AND_ASSIGN: return true;
+ case EXPR_BINARY_BITWISE_XOR_ASSIGN: return true;
+ case EXPR_BINARY_BITWISE_OR_ASSIGN: return true;
/* Only examine the right hand side of && and ||, because the left hand
* side already has the effect of controlling the execution of the right
case EXPR_BINARY_COMMA:
return expression_has_effect(expr->binary.right);
- case EXPR_BINARY_BUILTIN_EXPECT: return true;
- case EXPR_BINARY_ISGREATER: return false;
- case EXPR_BINARY_ISGREATEREQUAL: return false;
- case EXPR_BINARY_ISLESS: return false;
- case EXPR_BINARY_ISLESSEQUAL: return false;
- case EXPR_BINARY_ISLESSGREATER: return false;
- case EXPR_BINARY_ISUNORDERED: return false;
+ case EXPR_BINARY_ISGREATER: return false;
+ case EXPR_BINARY_ISGREATEREQUAL: return false;
+ case EXPR_BINARY_ISLESS: return false;
+ case EXPR_BINARY_ISLESSEQUAL: return false;
+ case EXPR_BINARY_ISLESSGREATER: return false;
+ case EXPR_BINARY_ISUNORDERED: return false;
}
internal_errorf(HERE, "unexpected expression");
* @param precedence the precedence of the operator
*/
static void register_infix_parser(parse_expression_infix_function parser,
- int token_type, unsigned precedence)
+ int token_type, precedence_t precedence)
{
expression_parser_function_t *entry = &expression_parsers[token_type];
}
argument->symbol = token.v.symbol;
- expect(']');
+ expect(']', end_error);
}
argument->constraints = parse_string_literals();
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
expression_t *expression = parse_expression();
rem_anchor_token(')');
mark_vars_read(expression, NULL);
}
argument->expression = expression;
- expect(')');
+ expect(')', end_error);
set_address_taken(expression, true);
asm_statement->is_volatile = true;
}
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
add_anchor_token(':');
asm_statement->asm_text = parse_string_literals();
end_of_asm:
rem_anchor_token(')');
- expect(')');
- expect(';');
+ expect(')', end_error);
+ expect(';', end_error);
if (asm_statement->outputs == NULL) {
/* GCC: An 'asm' instruction without any output operands will be treated
PUSH_PARENT(statement);
- expect(':');
+ expect(':', end_error);
end_error:
if (current_switch != NULL) {
PUSH_PARENT(statement);
- expect(':');
+ expect(':', end_error);
if (current_switch != NULL) {
const case_label_statement_t *def_label = current_switch->default_label;
if (def_label != NULL) {
add_anchor_token('{');
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
expression_t *const expr = parse_expression();
statement->ifs.condition = expr;
semantic_condition(expr, "condition of 'if'-statment");
mark_vars_read(expr, NULL);
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
end_error:
rem_anchor_token('{');
add_anchor_token(T_else);
- statement->ifs.true_statement = parse_statement();
+ statement_t *const true_stmt = parse_statement();
+ statement->ifs.true_statement = true_stmt;
rem_anchor_token(T_else);
if (token.type == T_else) {
next_token();
statement->ifs.false_statement = parse_statement();
+ } else if (warning.parentheses &&
+ true_stmt->kind == STATEMENT_IF &&
+ true_stmt->ifs.false_statement != NULL) {
+ warningf(&true_stmt->base.source_position,
+ "suggest explicit braces to avoid ambiguous 'else'");
}
POP_PARENT;
*
* @param statement the switch statement to check
*/
-static void check_enum_cases(const switch_statement_t *statement) {
+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;
PUSH_PARENT(statement);
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
expression_t *const expr = parse_expression();
mark_vars_read(expr, NULL);
type = type_error_type;
}
statement->switchs.expression = create_implicit_cast(expr, type);
- expect(')');
+ expect(')', end_error);
rem_anchor_token(')');
switch_statement_t *rem = current_switch;
PUSH_PARENT(statement);
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
expression_t *const cond = parse_expression();
statement->whiles.condition = cond;
semantic_condition(cond, "condition of 'while'-statement");
mark_vars_read(cond, NULL);
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
statement->whiles.body = parse_loop_body(statement);
statement->do_while.body = parse_loop_body(statement);
rem_anchor_token(T_while);
- expect(T_while);
- expect('(');
+ expect(T_while, end_error);
+ expect('(', end_error);
add_anchor_token(')');
expression_t *const cond = parse_expression();
statement->do_while.condition = cond;
semantic_condition(cond, "condition of 'do-while'-statement");
mark_vars_read(cond, NULL);
rem_anchor_token(')');
- expect(')');
- expect(';');
+ expect(')', end_error);
+ expect(';', end_error);
POP_PARENT;
return statement;
eat(T_for);
+ expect('(', end_error1);
+ add_anchor_token(')');
+
PUSH_PARENT(statement);
size_t const top = environment_top();
scope_t *old_scope = scope_push(&statement->fors.scope);
- expect('(');
- add_anchor_token(')');
-
if (token.type == ';') {
next_token();
} else if (is_declaration_specifier(&token, false)) {
"initialisation of 'for'-statement has no effect");
}
rem_anchor_token(';');
- expect(';');
+ expect(';', end_error2);
}
if (token.type != ';') {
mark_vars_read(cond, NULL);
rem_anchor_token(';');
}
- expect(';');
+ expect(';', end_error2);
if (token.type != ')') {
expression_t *const step = parse_expression();
statement->fors.step = step;
"step of 'for'-statement has no effect");
}
}
- expect(')');
+ expect(')', end_error2);
rem_anchor_token(')');
statement->fors.body = parse_loop_body(statement);
POP_PARENT;
return statement;
-end_error:
+end_error2:
POP_PARENT;
rem_anchor_token(')');
assert(current_scope == &statement->fors.scope);
scope_pop(old_scope);
environment_pop_to(top);
+ /* fallthrough */
+end_error1:
return create_invalid_statement();
}
*goto_anchor = &statement->gotos;
goto_anchor = &statement->gotos.next;
- expect(';');
+ expect(';', end_error);
return statement;
end_error:
statement_t *statement = allocate_statement_zero(STATEMENT_CONTINUE);
eat(T_continue);
- expect(';');
+ expect(';', end_error);
end_error:
return statement;
statement_t *statement = allocate_statement_zero(STATEMENT_BREAK);
eat(T_break);
- expect(';');
+ expect(';', end_error);
end_error:
return statement;
statement_t *statement = allocate_statement_zero(STATEMENT_LEAVE);
eat(T___leave);
- expect(';');
+ expect(';', end_error);
end_error:
return statement;
assert(is_type_function(func_type));
type_t *const return_type = skip_typeref(func_type->function.return_type);
+ source_position_t const *const pos = &statement->base.source_position;
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)) {
- if (warning.other) {
- warningf(&statement->base.source_position,
- "'return' with a value, in function returning void");
+ if (is_type_atomic(return_type, ATOMIC_TYPE_VOID)) {
+ if (is_type_atomic(return_value_type, ATOMIC_TYPE_VOID)) {
+ /* ISO/IEC 14882:1998(E) §6.6.3:2 */
+ /* Only warn in C mode, because GCC does the same */
+ if (c_mode & _CXX || strict_mode) {
+ errorf(pos,
+ "'return' with a value, in function returning 'void'");
+ } else if (warning.other) {
+ warningf(pos,
+ "'return' with a value, in function returning 'void'");
+ }
+ } else if (!(c_mode & _CXX)) { /* ISO/IEC 14882:1998(E) §6.6.3:3 */
+ /* Only warn in C mode, because GCC does the same */
+ if (strict_mode) {
+ errorf(pos,
+ "'return' with expression in function return 'void'");
+ } else if (warning.other) {
+ warningf(pos,
+ "'return' with expression in function return 'void'");
+ }
}
- return_value = NULL;
} else {
assign_error_t error = semantic_assign(return_type, return_value);
report_assign_error(error, return_type, return_value, "'return'",
- &statement->base.source_position);
- return_value = create_implicit_cast(return_value, return_type);
+ pos);
}
+ return_value = create_implicit_cast(return_value, return_type);
/* check for returning address of a local var */
if (warning.other && return_value != NULL
&& return_value->base.kind == EXPR_UNARY_TAKE_ADDRESS) {
const expression_t *expression = return_value->unary.value;
if (expression_is_local_variable(expression)) {
- warningf(&statement->base.source_position,
- "function returns address of local variable");
+ warningf(pos, "function returns address of local variable");
}
}
} 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");
+ /* ISO/IEC 14882:1998(E) §6.6.3:3 */
+ if (c_mode & _CXX || strict_mode) {
+ errorf(pos,
+ "'return' without value, in function returning non-void");
+ } else {
+ warningf(pos,
+ "'return' without value, in function returning non-void");
+ }
}
statement->returns.value = return_value;
- expect(';');
+ expect(';', end_error);
end_error:
return statement;
parse_declaration(record_entity, DECL_FLAGS_NONE);
}
- if (before == NULL) {
- statement->declaration.declarations_begin = current_scope->entities;
- } else {
- statement->declaration.declarations_begin = before->base.next;
- }
- statement->declaration.declarations_end = current_scope->last_entity;
+ declaration_statement_t *const decl = &statement->declaration;
+ entity_t *const begin =
+ before != NULL ? before->base.next : current_scope->entities;
+ decl->declarations_begin = begin;
+ decl->declarations_end = begin != NULL ? current_scope->last_entity : NULL;
return statement;
}
statement->expression.expression = expr;
mark_vars_read(expr, ENT_ANY);
- expect(';');
+ expect(';', end_error);
end_error:
return statement;
if (token.type == T___except) {
eat(T___except);
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
expression_t *const expr = parse_expression();
mark_vars_read(expr, NULL);
}
statement->ms_try.except_expression = create_implicit_cast(expr, type);
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
statement->ms_try.final_statement = parse_compound_statement(false);
} else if (token.type == T__finally) {
eat(T___finally);
next_token();
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);
+ if (entity != NULL &&
+ entity->kind != ENTITY_NAMESPACE &&
+ entity->base.parent_scope == current_scope) {
+ if (!is_error_entity(entity)) {
+ error_redefined_as_different_kind(&token.source_position,
+ entity, ENTITY_NAMESPACE);
+ }
entity = NULL;
}
}
size_t const top = environment_top();
scope_t *old_scope = scope_push(&entity->namespacee.members);
- expect('{');
+ expect('{', end_error);
parse_externals();
- expect('}');
+ expect('}', end_error);
end_error:
assert(current_scope == &entity->namespacee.members);
break;
default:
- errorf(HERE, "unexpected token '%K' while parsing statement", &token);
+ errorf(HERE, "unexpected token %K while parsing statement", &token);
statement = create_invalid_statement();
if (!at_anchor())
next_token();
eat('{');
add_anchor_token('}');
+ /* tokens, which can start a statement */
+ /* TODO MS, __builtin_FOO */
+ add_anchor_token('!');
+ add_anchor_token('&');
+ add_anchor_token('(');
+ add_anchor_token('*');
+ add_anchor_token('+');
+ add_anchor_token('-');
+ add_anchor_token('{');
+ add_anchor_token('~');
+ add_anchor_token(T_CHARACTER_CONSTANT);
+ add_anchor_token(T_COLONCOLON);
+ add_anchor_token(T_FLOATINGPOINT);
+ add_anchor_token(T_IDENTIFIER);
+ add_anchor_token(T_INTEGER);
+ add_anchor_token(T_MINUSMINUS);
+ add_anchor_token(T_PLUSPLUS);
+ add_anchor_token(T_STRING_LITERAL);
+ add_anchor_token(T_WIDE_CHARACTER_CONSTANT);
+ add_anchor_token(T_WIDE_STRING_LITERAL);
+ add_anchor_token(T__Bool);
+ add_anchor_token(T__Complex);
+ add_anchor_token(T__Imaginary);
+ add_anchor_token(T___FUNCTION__);
+ add_anchor_token(T___PRETTY_FUNCTION__);
+ add_anchor_token(T___alignof__);
+ add_anchor_token(T___attribute__);
+ add_anchor_token(T___builtin_va_start);
+ add_anchor_token(T___extension__);
+ add_anchor_token(T___func__);
+ add_anchor_token(T___imag__);
+ add_anchor_token(T___label__);
+ add_anchor_token(T___real__);
+ add_anchor_token(T___thread);
+ add_anchor_token(T_asm);
+ add_anchor_token(T_auto);
+ add_anchor_token(T_bool);
+ add_anchor_token(T_break);
+ add_anchor_token(T_case);
+ add_anchor_token(T_char);
+ add_anchor_token(T_class);
+ add_anchor_token(T_const);
+ add_anchor_token(T_const_cast);
+ add_anchor_token(T_continue);
+ add_anchor_token(T_default);
+ add_anchor_token(T_delete);
+ add_anchor_token(T_double);
+ add_anchor_token(T_do);
+ add_anchor_token(T_dynamic_cast);
+ add_anchor_token(T_enum);
+ add_anchor_token(T_extern);
+ add_anchor_token(T_false);
+ add_anchor_token(T_float);
+ add_anchor_token(T_for);
+ add_anchor_token(T_goto);
+ add_anchor_token(T_if);
+ add_anchor_token(T_inline);
+ add_anchor_token(T_int);
+ add_anchor_token(T_long);
+ add_anchor_token(T_new);
+ add_anchor_token(T_operator);
+ add_anchor_token(T_register);
+ add_anchor_token(T_reinterpret_cast);
+ add_anchor_token(T_restrict);
+ add_anchor_token(T_return);
+ add_anchor_token(T_short);
+ add_anchor_token(T_signed);
+ add_anchor_token(T_sizeof);
+ add_anchor_token(T_static);
+ add_anchor_token(T_static_cast);
+ add_anchor_token(T_struct);
+ add_anchor_token(T_switch);
+ add_anchor_token(T_template);
+ add_anchor_token(T_this);
+ add_anchor_token(T_throw);
+ add_anchor_token(T_true);
+ add_anchor_token(T_try);
+ add_anchor_token(T_typedef);
+ add_anchor_token(T_typeid);
+ add_anchor_token(T_typename);
+ add_anchor_token(T_typeof);
+ add_anchor_token(T_union);
+ add_anchor_token(T_unsigned);
+ add_anchor_token(T_using);
+ add_anchor_token(T_void);
+ add_anchor_token(T_volatile);
+ add_anchor_token(T_wchar_t);
+ add_anchor_token(T_while);
size_t const top = environment_top();
scope_t *old_scope = scope_push(&statement->compound.scope);
}
end_error:
+ rem_anchor_token(T_while);
+ rem_anchor_token(T_wchar_t);
+ rem_anchor_token(T_volatile);
+ rem_anchor_token(T_void);
+ rem_anchor_token(T_using);
+ rem_anchor_token(T_unsigned);
+ rem_anchor_token(T_union);
+ rem_anchor_token(T_typeof);
+ rem_anchor_token(T_typename);
+ rem_anchor_token(T_typeid);
+ rem_anchor_token(T_typedef);
+ rem_anchor_token(T_try);
+ rem_anchor_token(T_true);
+ rem_anchor_token(T_throw);
+ rem_anchor_token(T_this);
+ rem_anchor_token(T_template);
+ rem_anchor_token(T_switch);
+ rem_anchor_token(T_struct);
+ rem_anchor_token(T_static_cast);
+ rem_anchor_token(T_static);
+ rem_anchor_token(T_sizeof);
+ rem_anchor_token(T_signed);
+ rem_anchor_token(T_short);
+ rem_anchor_token(T_return);
+ rem_anchor_token(T_restrict);
+ rem_anchor_token(T_reinterpret_cast);
+ rem_anchor_token(T_register);
+ rem_anchor_token(T_operator);
+ rem_anchor_token(T_new);
+ rem_anchor_token(T_long);
+ rem_anchor_token(T_int);
+ rem_anchor_token(T_inline);
+ rem_anchor_token(T_if);
+ rem_anchor_token(T_goto);
+ rem_anchor_token(T_for);
+ rem_anchor_token(T_float);
+ rem_anchor_token(T_false);
+ rem_anchor_token(T_extern);
+ rem_anchor_token(T_enum);
+ rem_anchor_token(T_dynamic_cast);
+ rem_anchor_token(T_do);
+ rem_anchor_token(T_double);
+ rem_anchor_token(T_delete);
+ rem_anchor_token(T_default);
+ rem_anchor_token(T_continue);
+ rem_anchor_token(T_const_cast);
+ rem_anchor_token(T_const);
+ rem_anchor_token(T_class);
+ rem_anchor_token(T_char);
+ rem_anchor_token(T_case);
+ rem_anchor_token(T_break);
+ rem_anchor_token(T_bool);
+ rem_anchor_token(T_auto);
+ rem_anchor_token(T_asm);
+ rem_anchor_token(T___thread);
+ rem_anchor_token(T___real__);
+ rem_anchor_token(T___label__);
+ rem_anchor_token(T___imag__);
+ rem_anchor_token(T___func__);
+ rem_anchor_token(T___extension__);
+ rem_anchor_token(T___builtin_va_start);
+ rem_anchor_token(T___attribute__);
+ rem_anchor_token(T___alignof__);
+ rem_anchor_token(T___PRETTY_FUNCTION__);
+ rem_anchor_token(T___FUNCTION__);
+ rem_anchor_token(T__Imaginary);
+ rem_anchor_token(T__Complex);
+ rem_anchor_token(T__Bool);
+ rem_anchor_token(T_WIDE_STRING_LITERAL);
+ rem_anchor_token(T_WIDE_CHARACTER_CONSTANT);
+ rem_anchor_token(T_STRING_LITERAL);
+ rem_anchor_token(T_PLUSPLUS);
+ rem_anchor_token(T_MINUSMINUS);
+ rem_anchor_token(T_INTEGER);
+ rem_anchor_token(T_IDENTIFIER);
+ rem_anchor_token(T_FLOATINGPOINT);
+ rem_anchor_token(T_COLONCOLON);
+ rem_anchor_token(T_CHARACTER_CONSTANT);
+ rem_anchor_token('~');
+ rem_anchor_token('{');
+ rem_anchor_token('-');
+ rem_anchor_token('+');
+ rem_anchor_token('*');
+ rem_anchor_token('(');
+ rem_anchor_token('&');
+ rem_anchor_token('!');
rem_anchor_token('}');
assert(current_scope == &statement->compound.scope);
scope_pop(old_scope);
statement_t *statement = allocate_statement_zero(STATEMENT_ASM);
eat(T_asm);
- expect('(');
+ expect('(', end_error);
statement->asms.asm_text = parse_string_literals();
statement->base.next = unit->global_asm;
unit->global_asm = statement;
- expect(')');
- expect(';');
+ expect(')', end_error);
+ expect(';', end_error);
end_error:;
}
if (token.type == '{') {
next_token();
parse_externals();
- expect('}');
+ expect('}', end_error);
} else {
parse_external();
}
/* FALLTHROUGH */
default:
- errorf(HERE, "stray '%K' outside of function", &token);
+ errorf(HERE, "stray %K outside of function", &token);
if (token.type == '(' || token.type == '{' || token.type == '[')
eat_until_matching_token(token.type);
next_token();
if (token.type == T_EOF)
break;
- errorf(HERE, "stray '%K' outside of function", &token);
+ errorf(HERE, "stray %K outside of function", &token);
if (token.type == '(' || token.type == '{' || token.type == '[')
eat_until_matching_token(token.type);
next_token();
return result;
}
+/* §6.9.2:2 and §6.9.2:5: At the end of the translation incomplete arrays
+ * are given length one. */
+static void complete_incomplete_arrays(void)
+{
+ size_t n = ARR_LEN(incomplete_arrays);
+ for (size_t i = 0; i != n; ++i) {
+ declaration_t *const decl = incomplete_arrays[i];
+ type_t *const orig_type = decl->type;
+ type_t *const type = skip_typeref(orig_type);
+
+ if (!is_type_incomplete(type))
+ continue;
+
+ if (warning.other) {
+ warningf(&decl->base.source_position,
+ "array '%#T' assumed to have one element",
+ orig_type, decl->base.symbol);
+ }
+
+ type_t *const new_type = duplicate_type(type);
+ new_type->array.size_constant = true;
+ new_type->array.has_implicit_size = true;
+ new_type->array.size = 1;
+
+ type_t *const result = identify_new_type(new_type);
+
+ decl->type = result;
+ }
+}
+
void parse(void)
{
lookahead_bufpos = 0;
for (int i = 0; i < MAX_LOOKAHEAD + 2; ++i) {
next_token();
}
- current_linkage = c_mode & _CXX ? LINKAGE_CXX : LINKAGE_C;
+ current_linkage = c_mode & _CXX ? LINKAGE_CXX : LINKAGE_C;
+ incomplete_arrays = NEW_ARR_F(declaration_t*, 0);
parse_translation_unit();
+ complete_incomplete_arrays();
+ DEL_ARR_F(incomplete_arrays);
+ incomplete_arrays = NULL;
}
/**
if (c_mode & _MS) {
/* add predefined symbols for extended-decl-modifier */
- sym_align = symbol_table_insert("align");
- sym_allocate = symbol_table_insert("allocate");
- sym_dllimport = symbol_table_insert("dllimport");
- sym_dllexport = symbol_table_insert("dllexport");
- sym_naked = symbol_table_insert("naked");
- sym_noinline = symbol_table_insert("noinline");
- sym_noreturn = symbol_table_insert("noreturn");
- sym_nothrow = symbol_table_insert("nothrow");
- sym_novtable = symbol_table_insert("novtable");
- sym_property = symbol_table_insert("property");
- sym_get = symbol_table_insert("get");
- sym_put = symbol_table_insert("put");
- sym_selectany = symbol_table_insert("selectany");
- sym_thread = symbol_table_insert("thread");
- sym_uuid = symbol_table_insert("uuid");
- sym_deprecated = symbol_table_insert("deprecated");
- sym_restrict = symbol_table_insert("restrict");
- sym_noalias = symbol_table_insert("noalias");
+ sym_align = symbol_table_insert("align");
+ sym_allocate = symbol_table_insert("allocate");
+ sym_dllimport = symbol_table_insert("dllimport");
+ sym_dllexport = symbol_table_insert("dllexport");
+ sym_naked = symbol_table_insert("naked");
+ sym_noinline = symbol_table_insert("noinline");
+ sym_returns_twice = symbol_table_insert("returns_twice");
+ sym_noreturn = symbol_table_insert("noreturn");
+ sym_nothrow = symbol_table_insert("nothrow");
+ sym_novtable = symbol_table_insert("novtable");
+ sym_property = symbol_table_insert("property");
+ sym_get = symbol_table_insert("get");
+ sym_put = symbol_table_insert("put");
+ sym_selectany = symbol_table_insert("selectany");
+ sym_thread = symbol_table_insert("thread");
+ sym_uuid = symbol_table_insert("uuid");
+ sym_deprecated = symbol_table_insert("deprecated");
+ sym_restrict = symbol_table_insert("restrict");
+ sym_noalias = symbol_table_insert("noalias");
}
memset(token_anchor_set, 0, sizeof(token_anchor_set));
projects / cparser / blobdiff