X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=parser.c;h=2a8f26928c3ec6bd79b6e80d3a4a938908085902;hb=442cc935f91c445283176287cd3c6fe536416bf7;hp=baeca3af89112343d6367bc1f88ea5d075e7d188;hpb=8bc140be79f9fa5fcf4018aca515f461a0d7ac25;p=cparser diff --git a/parser.c b/parser.c index baeca3a..2a8f269 100644 --- a/parser.c +++ b/parser.c @@ -42,7 +42,7 @@ #include "adt/array.h" //#define PRINT_TOKENS -#define MAX_LOOKAHEAD 2 +#define MAX_LOOKAHEAD 1 typedef struct { entity_t *old_entity; @@ -58,14 +58,14 @@ struct argument_list_t { 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; @@ -113,7 +113,7 @@ static token_t token; /** The lookahead ring-buffer. */ static token_t lookahead_buffer[MAX_LOOKAHEAD]; /** Position of the next token in the lookahead buffer. */ -static int lookahead_bufpos; +static size_t lookahead_bufpos; static stack_entry_t *environment_stack = NULL; static stack_entry_t *label_stack = NULL; static scope_t *file_scope = NULL; @@ -351,7 +351,7 @@ static size_t get_entity_struct_size(entity_kind_t kind) [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]; } @@ -381,7 +381,6 @@ static size_t get_statement_struct_size(statement_kind_t 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), @@ -397,7 +396,7 @@ static size_t get_statement_struct_size(statement_kind_t kind) [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]; } @@ -444,7 +443,7 @@ static size_t get_expression_struct_size(expression_kind_t kind) 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]; } @@ -527,7 +526,7 @@ static size_t get_type_struct_size(type_kind_t kind) [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]; @@ -563,7 +562,7 @@ static size_t get_initializer_size(initializer_kind_t 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]; } @@ -580,14 +579,6 @@ static initializer_t *allocate_initializer_zero(initializer_kind_t 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. */ @@ -613,7 +604,7 @@ static inline void next_token(void) 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); @@ -624,10 +615,10 @@ static inline void next_token(void) /** * 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]; } @@ -758,7 +749,7 @@ static void eat_block(void) 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. @@ -978,13 +969,8 @@ static int get_akind_rank(atomic_type_kind_t akind) 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); @@ -1032,21 +1018,18 @@ static expression_t *create_cast_expression(expression_t *expression, 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; } /** @@ -1328,7 +1311,7 @@ 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; } @@ -1477,35 +1460,13 @@ static void parse_gnu_attribute_model_arg(gnu_attribute_t *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, 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(')'); @@ -1591,7 +1552,7 @@ end_error: */ 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 */ @@ -1741,7 +1702,7 @@ static decl_modifiers_t parse_gnu_attribute(gnu_attribute_t **attributes) /* empty args are allowed */ next_token(); } else - attribute->have_arguments = true; + attribute->has_arguments = true; } switch (kind) { @@ -1800,7 +1761,7 @@ static decl_modifiers_t parse_gnu_attribute(gnu_attribute_t **attributes) 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; @@ -1808,7 +1769,7 @@ static decl_modifiers_t parse_gnu_attribute(gnu_attribute_t **attributes) 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; @@ -1818,7 +1779,7 @@ static decl_modifiers_t parse_gnu_attribute(gnu_attribute_t **attributes) 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; @@ -1826,7 +1787,7 @@ static decl_modifiers_t parse_gnu_attribute(gnu_attribute_t **attributes) 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; @@ -1835,29 +1796,29 @@ static decl_modifiers_t parse_gnu_attribute(gnu_attribute_t **attributes) 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 { @@ -1865,7 +1826,7 @@ static decl_modifiers_t parse_gnu_attribute(gnu_attribute_t **attributes) } 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 { @@ -1874,12 +1835,12 @@ static decl_modifiers_t parse_gnu_attribute(gnu_attribute_t **attributes) 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: @@ -2286,6 +2247,7 @@ static initializer_t *initializer_from_expression(type_t *orig_type, 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); @@ -2293,6 +2255,7 @@ static initializer_t *initializer_from_expression(type_t *orig_type, return initializer_from_wide_string(array_type, &expression->wide_string.value); } + break; } default: @@ -2946,7 +2909,7 @@ static initializer_t *parse_initializer(parse_initializer_env_t *env) 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) { @@ -3033,8 +2996,8 @@ static compound_t *parse_compound_type_specifier(bool is_struct) 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); @@ -3148,7 +3111,18 @@ static type_t *parse_enum_specifier(void) 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); @@ -3168,12 +3142,9 @@ static type_t *parse_enum_specifier(void) 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); } @@ -3286,13 +3257,7 @@ 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) @@ -3621,6 +3586,78 @@ static void finish_union_type(compound_type_t *type) 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; @@ -3636,8 +3673,6 @@ static void parse_declaration_specifiers(declaration_specifiers_t *specifiers) 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 */ @@ -3858,6 +3893,9 @@ wrong_thread_stoarge_class: } finish_specifiers: + specifiers->modifiers + |= parse_attributes(&specifiers->gnu_attributes); + in_gcc_extension = old_gcc_extension; if (type == NULL || (saw_error && type_specifiers != 0)) { @@ -4032,9 +4070,13 @@ warn_about_long_long: 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"); @@ -4042,15 +4084,19 @@ warn_about_long_long: /* 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: @@ -4550,34 +4596,28 @@ static void parse_declaration_attributes(entity_t *entity) 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; @@ -4585,13 +4625,9 @@ static void parse_declaration_attributes(entity_t *entity) 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) { @@ -4619,7 +4655,7 @@ static type_t *construct_declarator_type(construct_type_t *construct_list, type_ 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)) { @@ -4681,7 +4717,7 @@ static type_t *construct_declarator_type(construct_type_t *construct_list, 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)) { @@ -4692,14 +4728,12 @@ static type_t *construct_declarator_type(construct_type_t *construct_list, 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); } } @@ -4784,16 +4818,18 @@ static entity_t *parse_declarator(const declaration_specifiers_t *specifiers, 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, orig_type, @@ -4806,52 +4842,56 @@ static entity_t *parse_declarator(const declaration_specifiers_t *specifiers, 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; @@ -5055,7 +5095,7 @@ static entity_t *record_entity(entity_t *entity, const bool is_definition) type_t *const orig_type = decl->type; assert(orig_type != NULL); type_t *const type = skip_typeref(orig_type); - type_t * prev_type = skip_typeref(prev_decl->type); + type_t *const prev_type = skip_typeref(prev_decl->type); if (!types_compatible(type, prev_type)) { errorf(pos, @@ -5074,20 +5114,14 @@ static entity_t *record_entity(entity_t *entity, const bool is_definition) prev_decl->type, symbol); } - unsigned new_storage_class = decl->storage_class; - if (is_type_incomplete(prev_type)) { - prev_decl->type = type; - prev_type = type; - } + storage_class_tag_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) { - if (prev_type->function.unspecified_parameters) { + if (prev_type->function.unspecified_parameters) prev_decl->type = type; - prev_type = type; - } switch (old_storage_class) { case STORAGE_CLASS_NONE: @@ -5110,6 +5144,8 @@ static entity_t *record_entity(entity_t *entity, const bool is_definition) default: break; } + } else if (is_type_incomplete(prev_type)) { + prev_decl->type = type; } if (old_storage_class == STORAGE_CLASS_EXTERN && @@ -5256,7 +5292,7 @@ static void parse_init_declarator_rest(entity_t *entity) 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; @@ -5314,11 +5350,9 @@ static void check_variable_type_complete(entity_t *ent) if (!is_type_incomplete(type)) return; - /* GCC allows global arrays without size and assigns them a length of one, - * if no different declaration follows */ - if (is_type_array(type) && - c_mode & _GNUC && - ent->base.parent_scope == file_scope) { + /* §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; } @@ -5523,12 +5557,9 @@ decl_list_end: 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('{'); } @@ -5799,7 +5830,6 @@ static void check_reachable(statement_t *const stmt) switch (stmt->kind) { case STATEMENT_INVALID: case STATEMENT_EMPTY: - case STATEMENT_LOCAL_LABEL: case STATEMENT_ASM: next = stmt->base.next; break; @@ -5825,6 +5855,8 @@ static void check_reachable(statement_t *const stmt) case STATEMENT_COMPOUND: next = stmt->compound.statements; + if (next == NULL) + next = stmt->base.next; break; case STATEMENT_RETURN: { @@ -6059,7 +6091,7 @@ found_break_parent: 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 && @@ -6076,7 +6108,6 @@ found_break_parent: case STATEMENT_INVALID: case STATEMENT_EMPTY: case STATEMENT_DECLARATION: - case STATEMENT_LOCAL_LABEL: case STATEMENT_EXPRESSION: case STATEMENT_ASM: case STATEMENT_RETURN: @@ -6313,7 +6344,8 @@ static void parse_external_declaration(void) } 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)) { @@ -6322,6 +6354,11 @@ static void parse_external_declaration(void) } 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 && @@ -6338,18 +6375,15 @@ static void parse_external_declaration(void) 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; } @@ -6514,53 +6548,58 @@ static void parse_compound_declarators(compound_t *compound, 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); } } @@ -6624,7 +6663,7 @@ typedef expression_t* (*parse_expression_infix_function)(expression_t *left); typedef struct expression_parser_function_t expression_parser_function_t; struct expression_parser_function_t { parse_expression_function parser; - unsigned infix_precedence; + precedence_t infix_precedence; parse_expression_infix_function infix_parser; }; @@ -6785,11 +6824,7 @@ static entity_t *create_implicit_function(symbol_t *symbol, ntype->function.return_type = type_int; ntype->function.unspecified_parameters = true; ntype->function.linkage = LINKAGE_C; - - type_t *type = typehash_insert(ntype); - if (type != ntype) { - free_type(ntype); - } + type_t *type = identify_new_type(ntype); entity_t *entity = allocate_entity_zero(ENTITY_FUNCTION); entity->declaration.storage_class = STORAGE_CLASS_EXTERN; @@ -6829,12 +6864,7 @@ static type_t *make_function_2_type(type_t *return_type, type_t *argument_type1, 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); } /** @@ -6855,12 +6885,7 @@ static type_t *make_function_1_type(type_t *return_type, type_t *argument_type) type->function.return_type = return_type; type->function.parameters = parameter; - type_t *result = typehash_insert(type); - if (result != type) { - free_type(type); - } - - return result; + return identify_new_type(type); } static type_t *make_function_0_type(type_t *return_type) @@ -6869,12 +6894,7 @@ static type_t *make_function_0_type(type_t *return_type) 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); } /** @@ -6956,13 +6976,14 @@ 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; } @@ -6972,9 +6993,8 @@ type_t *revert_automatic_type_conversion(const expression_t *expression) 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; } @@ -6991,10 +7011,9 @@ type_t *revert_automatic_type_conversion(const expression_t *expression) 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) @@ -8523,7 +8542,7 @@ static bool check_pointer_arithmetic(const source_position_t *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_ARRAY_ACCESS: case EXPR_COMPOUND_LITERAL: @@ -8849,7 +8868,8 @@ static void warn_div_by_zero(binary_expression_t const *const expression) /** * 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); } @@ -9008,6 +9028,13 @@ static void warn_comparison_in_comparison(const expression_t *const expr) } } +static bool maybe_negative(expression_t const *const expr) +{ + return + !is_constant_expression(expr) || + fold_constant(expr) < 0; +} + /** * Check the semantics of comparison expressions. * @@ -9049,37 +9076,23 @@ static void semantic_comparison(binary_expression_t *expression) /* TODO non-arithmetic types */ if (is_type_arithmetic(type_left) && is_type_arithmetic(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; - } + type_t *arithmetic_type = semantic_arithmetic(type_left, type_right); - 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; + /* test for signed vs unsigned compares */ + 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; @@ -9549,7 +9562,7 @@ static void register_expression_parser(parse_expression_function parser, * @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]; @@ -10061,7 +10074,8 @@ end_error: * * @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; @@ -11342,8 +11356,8 @@ translation_unit_t *finish_parsing(void) return result; } -/* GCC allows global arrays without size and assigns them a length of one, - * if no different declaration follows */ +/* §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); @@ -11366,9 +11380,7 @@ static void complete_incomplete_arrays(void) new_type->array.has_implicit_size = true; new_type->array.size = 1; - type_t *const result = typehash_insert(new_type); - if (type != result) - free_type(type); + type_t *const result = identify_new_type(new_type); decl->type = result; }