static elf_visibility_tag_t default_visibility = ELF_VISIBILITY_DEFAULT;
+#define PUSH_CURRENT_ENTITY(entity) \
+ entity_t *const new_current_entity = (entity); \
+ entity_t *const old_current_entity = current_entity; \
+ ((void)(current_entity = new_current_entity))
+#define POP_CURRENT_ENTITY() (assert(current_entity == new_current_entity), (void)(current_entity = old_current_entity))
+
#define PUSH_PARENT(stmt) \
statement_t *const new_parent = (stmt); \
statement_t *const old_parent = current_parent; \
#define PUSH_SCOPE(scope) \
size_t const top = environment_top(); \
scope_t *const new_scope = (scope); \
- scope_t *const old_scope = scope_push(new_scope)
-#define POP_SCOPE() (assert(current_scope == new_scope), scope_pop(old_scope), environment_pop_to(top))
+ scope_t *const old_scope = (new_scope ? scope_push(new_scope) : NULL)
+#define PUSH_SCOPE_STATEMENT(scope) PUSH_SCOPE(c_mode & (_C99 | _CXX) ? (scope) : NULL)
+#define POP_SCOPE() (new_scope ? assert(current_scope == new_scope), scope_pop(old_scope), environment_pop_to(top) : (void)0)
#define PUSH_EXTENSION() \
(void)0; \
case T_ANDAND: \
case T_CHARACTER_CONSTANT: \
case T_FLOATINGPOINT: \
- case T_FLOATINGPOINT_HEXADECIMAL: \
case T_INTEGER: \
- case T_INTEGER_HEXADECIMAL: \
- case T_INTEGER_OCTAL: \
case T_MINUSMINUS: \
case T_PLUSPLUS: \
case T_STRING_LITERAL: \
[EXPR_ENUM_CONSTANT] = sizeof(reference_expression_t),
[EXPR_LITERAL_BOOLEAN] = sizeof(literal_expression_t),
[EXPR_LITERAL_INTEGER] = sizeof(literal_expression_t),
- [EXPR_LITERAL_INTEGER_OCTAL] = sizeof(literal_expression_t),
- [EXPR_LITERAL_INTEGER_HEXADECIMAL]= sizeof(literal_expression_t),
[EXPR_LITERAL_FLOATINGPOINT] = sizeof(literal_expression_t),
- [EXPR_LITERAL_FLOATINGPOINT_HEXADECIMAL] = sizeof(literal_expression_t),
[EXPR_LITERAL_CHARACTER] = sizeof(literal_expression_t),
[EXPR_LITERAL_WIDE_CHARACTER] = sizeof(literal_expression_t),
[EXPR_STRING_LITERAL] = sizeof(string_literal_expression_t),
#endif
}
-static inline bool next_if(int const type)
+static inline bool next_if(token_kind_t const type)
{
if (token.kind == type) {
next_token();
/**
* Adds a token type to the token type anchor set (a multi-set).
*/
-static void add_anchor_token(int token_kind)
+static void add_anchor_token(token_kind_t const token_kind)
{
- assert(0 <= token_kind && token_kind < T_LAST_TOKEN);
+ assert(token_kind < T_LAST_TOKEN);
++token_anchor_set[token_kind];
}
-/**
- * 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_kind)
-{
- assert(0 <= token_kind && token_kind < T_LAST_TOKEN);
- int count = token_anchor_set[token_kind];
- token_anchor_set[token_kind] = 0;
- return count;
-}
-
-/**
- * Restore the number of token types to the given count.
- */
-static void restore_anchor_state(int token_kind, int count)
-{
- assert(0 <= token_kind && token_kind < T_LAST_TOKEN);
- token_anchor_set[token_kind] = count;
-}
-
/**
* Remove a token type from the token type anchor set (a multi-set).
*/
-static void rem_anchor_token(int token_kind)
+static void rem_anchor_token(token_kind_t const token_kind)
{
- assert(0 <= token_kind && token_kind < T_LAST_TOKEN);
+ assert(token_kind < T_LAST_TOKEN);
assert(token_anchor_set[token_kind] != 0);
--token_anchor_set[token_kind];
}
-/**
- * Return true if the token type of the current token is
- * in the anchor set.
- */
-static bool at_anchor(void)
-{
- if (token.kind < 0)
- return false;
- return token_anchor_set[token.kind];
-}
-
/**
* Eat tokens until a matching token type is found.
*/
-static void eat_until_matching_token(int type)
+static void eat_until_matching_token(token_kind_t const type)
{
- int end_token;
+ token_kind_t end_token;
switch (type) {
case '(': end_token = ')'; break;
case '{': end_token = '}'; break;
/**
* Expect the current token is the expected token.
- * If not, generate an error, eat the current statement,
- * and goto the error_label label.
- */
-#define expect(expected, error_label) \
- do { \
- if (UNLIKELY(token.kind != (expected))) { \
- parse_error_expected(NULL, (expected), NULL); \
- add_anchor_token(expected); \
- eat_until_anchor(); \
- rem_anchor_token(expected); \
- if (token.kind != (expected)) \
- goto error_label; \
- } \
- next_token(); \
- } while (0)
+ * If not, generate an error and skip until the next anchor.
+ */
+static void expect(token_kind_t const expected)
+{
+ if (UNLIKELY(token.kind != expected)) {
+ parse_error_expected(NULL, expected, NULL);
+ add_anchor_token(expected);
+ eat_until_anchor();
+ rem_anchor_token(expected);
+ if (token.kind != expected)
+ return;
+ }
+ eat(expected);
+}
+
+static symbol_t *expect_identifier(char const *const context, source_position_t *const pos)
+{
+ if (token.kind != T_IDENTIFIER) {
+ parse_error_expected(context, T_IDENTIFIER, NULL);
+ add_anchor_token(T_IDENTIFIER);
+ eat_until_anchor();
+ rem_anchor_token(T_IDENTIFIER);
+ if (token.kind != T_IDENTIFIER)
+ return NULL;
+ }
+ symbol_t *const sym = token.identifier.symbol;
+ if (pos)
+ *pos = *HERE;
+ eat(T_IDENTIFIER);
+ return sym;
+}
/**
* Push a given scope on the scope stack and make it the
*anchor = argument;
anchor = &argument->next;
} while (next_if(','));
- expect(')', end_error);
-
- return first;
-
-end_error:
- /* TODO... */
+ expect(')');
return first;
}
{
attribute_t *attribute = allocate_attribute_zero(ATTRIBUTE_GNU_ASM);
eat(T_asm);
-
- expect('(', end_error);
+ expect('(');
attribute->a.arguments = parse_attribute_arguments();
return attribute;
-
-end_error:
- return NULL;
}
static symbol_t *get_symbol_from_token(void)
{
switch(token.kind) {
- case T_IDENTIFIER:
- return token.identifier.symbol;
- case T_auto:
- case T_char:
- case T_double:
- case T_enum:
- case T_extern:
- case T_float:
- case T_int:
- case T_long:
- case T_register:
- case T_short:
- case T_static:
- case T_struct:
- case T_union:
- case T_unsigned:
- case T_void:
- case T_bool:
- case T__Bool:
- case T_class:
- case T_explicit:
- case T_export:
- case T_wchar_t:
- case T_const:
- case T_signed:
- case T___real__:
- case T___imag__:
- case T_restrict:
- case T_volatile:
- case T_inline:
- /* maybe we need more tokens ... add them on demand */
- return get_token_kind_symbol(token.kind);
- default:
+ case T_CHARACTER_CONSTANT:
+ case T_EOF:
+ case T_FLOATINGPOINT:
+ case T_INTEGER:
+ case T_STRING_LITERAL:
+ case T_WIDE_CHARACTER_CONSTANT:
+ case T_WIDE_STRING_LITERAL:
return NULL;
+
+ default:
+ return token.identifier.symbol;
}
}
attribute_t **anchor = &first;
eat(T___attribute__);
- expect('(', end_error);
- expect('(', end_error);
+ expect('(');
+ expect('(');
+ add_anchor_token(')');
+ add_anchor_token(',');
if (token.kind != ')') do {
attribute_t *attribute = parse_attribute_gnu_single();
- if (attribute == NULL)
- goto end_error;
-
- *anchor = attribute;
- anchor = &attribute->next;
+ if (attribute) {
+ *anchor = attribute;
+ anchor = &attribute->next;
+ }
} while (next_if(','));
- expect(')', end_error);
- expect(')', end_error);
+ rem_anchor_token(',');
+ rem_anchor_token(')');
-end_error:
+ expect(')');
+ expect(')');
return first;
}
add_anchor_token(']');
designator->array_index = parse_constant_expression();
rem_anchor_token(']');
- expect(']', end_error);
+ expect(']');
break;
case '.':
designator = allocate_ast_zero(sizeof(designator[0]));
designator->source_position = token.base.source_position;
next_token();
- if (token.kind != T_IDENTIFIER) {
- parse_error_expected("while parsing designator",
- T_IDENTIFIER, NULL);
+ designator->symbol = expect_identifier("while parsing designator", NULL);
+ if (!designator->symbol)
return NULL;
- }
- designator->symbol = token.identifier.symbol;
- next_token();
break;
default:
- expect('=', end_error);
+ expect('=');
return result;
}
*anchor = designator;
anchor = &designator->next;
}
-end_error:
- return NULL;
}
static initializer_t *initializer_from_string(array_type_t *const type,
env);
rem_anchor_token('}');
- if (type != NULL) {
- ascend_from_subtype(path);
- expect('}', end_error);
- } else {
- expect('}', end_error);
+ expect('}');
+
+ if (!type)
goto error_parse_next;
- }
+
+ ascend_from_subtype(path);
}
} else {
/* must be an expression */
if (token.kind == '}') {
break;
}
- expect(',', end_error);
+ add_anchor_token('}');
+ expect(',');
+ rem_anchor_token('}');
if (token.kind == '}') {
break;
}
max_index = path.max_index;
DEL_ARR_F(path.path);
- expect('}', end_error);
-end_error:;
+ expect('}');
} else {
/* parse_scalar_initializer() also works in this case: we simply
* have an expression without {} around it */
}
if (entity == NULL) {
- entity = allocate_entity_zero(kind, NAMESPACE_TAG, symbol);
- entity->compound.alignment = 1;
- entity->base.source_position = pos;
- entity->base.parent_scope = current_scope;
+ entity = allocate_entity_zero(kind, NAMESPACE_TAG, symbol, &pos);
+ entity->compound.alignment = 1;
+ entity->base.parent_scope = current_scope;
if (symbol != NULL) {
environment_push(entity);
}
}
add_anchor_token('}');
+ add_anchor_token(',');
do {
- if (token.kind != T_IDENTIFIER) {
- parse_error_expected("while parsing enum entry", T_IDENTIFIER, NULL);
- eat_block();
- rem_anchor_token('}');
- return;
- }
-
- symbol_t *symbol = token.identifier.symbol;
- entity_t *const entity
- = allocate_entity_zero(ENTITY_ENUM_VALUE, NAMESPACE_NORMAL, symbol);
+ add_anchor_token('=');
+ source_position_t pos;
+ symbol_t *const symbol = expect_identifier("while parsing enum entry", &pos);
+ entity_t *const entity = allocate_entity_zero(ENTITY_ENUM_VALUE, NAMESPACE_NORMAL, symbol, &pos);
entity->enum_value.enum_type = enum_type;
- entity->base.source_position = token.base.source_position;
- next_token();
+ rem_anchor_token('=');
if (next_if('=')) {
expression_t *value = parse_constant_expression();
record_entity(entity, false);
} while (next_if(',') && token.kind != '}');
+ rem_anchor_token(',');
rem_anchor_token('}');
- expect('}', end_error);
-
-end_error:
- ;
+ expect('}');
}
static type_t *parse_enum_specifier(void)
}
if (entity == NULL) {
- entity = allocate_entity_zero(ENTITY_ENUM, NAMESPACE_TAG, symbol);
- entity->base.source_position = pos;
- entity->base.parent_scope = current_scope;
+ entity = allocate_entity_zero(ENTITY_ENUM, NAMESPACE_TAG, symbol, &pos);
+ entity->base.parent_scope = current_scope;
}
type_t *const type = allocate_type_zero(TYPE_ENUM);
type_t *type;
- expect('(', end_error);
+ expect('(');
add_anchor_token(')');
expression_t *expression = NULL;
}
rem_anchor_token(')');
- expect(')', end_error);
+ expect(')');
type_t *typeof_type = allocate_type_zero(TYPE_TYPEOF);
typeof_type->typeoft.expression = expression;
typeof_type->typeoft.typeof_type = type;
return typeof_type;
-end_error:
- return NULL;
}
typedef enum specifiers_t {
static attribute_t *parse_attribute_ms_property(attribute_t *attribute)
{
- expect('(', end_error);
+ attribute_property_argument_t *const property = allocate_ast_zero(sizeof(*property));
- attribute_property_argument_t *property
- = allocate_ast_zero(sizeof(*property));
+ expect('(');
+ add_anchor_token(')');
+ add_anchor_token(',');
do {
- if (token.kind != T_IDENTIFIER) {
- parse_error_expected("while parsing property declspec",
- T_IDENTIFIER, NULL);
- goto end_error;
- }
+ add_anchor_token('=');
+ source_position_t pos;
+ symbol_t *const prop_sym = expect_identifier("while parsing property declspec", &pos);
+ rem_anchor_token('=');
- symbol_t **prop;
- symbol_t *symbol = token.identifier.symbol;
- if (streq(symbol->string, "put")) {
- prop = &property->put_symbol;
- } else if (streq(symbol->string, "get")) {
- prop = &property->get_symbol;
- } else {
- errorf(HERE, "expected put or get in property declspec");
- prop = NULL;
- }
- eat(T_IDENTIFIER);
- expect('=', end_error);
- if (token.kind != T_IDENTIFIER) {
- parse_error_expected("while parsing property declspec",
- T_IDENTIFIER, NULL);
- goto end_error;
+ symbol_t **prop = NULL;
+ if (prop_sym) {
+ if (streq(prop_sym->string, "put")) {
+ prop = &property->put_symbol;
+ } else if (streq(prop_sym->string, "get")) {
+ prop = &property->get_symbol;
+ } else {
+ errorf(&pos, "expected put or get in property declspec, but got '%Y'", prop_sym);
+ }
}
+
+ add_anchor_token(T_IDENTIFIER);
+ expect('=');
+ rem_anchor_token(T_IDENTIFIER);
+
+ symbol_t *const sym = expect_identifier("while parsing property declspec", NULL);
if (prop != NULL)
- *prop = token.identifier.symbol;
- next_token();
+ *prop = sym ? sym : sym_anonymous;
} while (next_if(','));
+ rem_anchor_token(',');
+ rem_anchor_token(')');
attribute->a.property = property;
- expect(')', end_error);
-
-end_error:
+ expect(')');
return attribute;
}
{
eat(T__declspec);
- expect('(', end_error);
-
- if (next_if(')'))
- return NULL;
-
- add_anchor_token(')');
-
- attribute_t **anchor = &first;
- do {
- while (*anchor != NULL)
- anchor = &(*anchor)->next;
+ expect('(');
+ if (token.kind != ')') {
+ add_anchor_token(')');
- attribute_t *attribute
- = parse_microsoft_extended_decl_modifier_single();
- if (attribute == NULL)
- goto end_error;
+ attribute_t **anchor = &first;
+ do {
+ while (*anchor != NULL)
+ anchor = &(*anchor)->next;
- *anchor = attribute;
- anchor = &attribute->next;
- } while (next_if(','));
+ attribute_t *attribute
+ = parse_microsoft_extended_decl_modifier_single();
+ if (attribute == NULL)
+ break;
- rem_anchor_token(')');
- expect(')', end_error);
- return first;
+ *anchor = attribute;
+ anchor = &attribute->next;
+ } while (next_if(','));
-end_error:
- rem_anchor_token(')');
+ rem_anchor_token(')');
+ }
+ expect(')');
return first;
}
static entity_t *create_error_entity(symbol_t *symbol, entity_kind_tag_t kind)
{
- entity_t *const entity = allocate_entity_zero(kind, NAMESPACE_NORMAL, symbol);
- entity->base.source_position = *HERE;
+ entity_t *const entity = allocate_entity_zero(kind, NAMESPACE_NORMAL, symbol, HERE);
if (is_declaration(entity)) {
entity->declaration.type = type_error_type;
entity->declaration.implicit = true;
{
assert(token.kind == T_IDENTIFIER);
do {
- entity_t *const entity = allocate_entity_zero(ENTITY_PARAMETER, NAMESPACE_NORMAL, token.identifier.symbol);
- entity->base.source_position = token.base.source_position;
+ entity_t *const entity = allocate_entity_zero(ENTITY_PARAMETER, NAMESPACE_NORMAL, token.identifier.symbol, HERE);
/* a K&R parameter has no type, yet */
next_token();
{
eat('(');
add_anchor_token(')');
- int saved_comma_state = save_and_reset_anchor_state(',');
-
- if (token.kind == T_IDENTIFIER
- && !is_typedef_symbol(token.identifier.symbol)) {
- token_kind_t la1_type = (token_kind_t)look_ahead(1)->kind;
- if (la1_type == ',' || la1_type == ')') {
- type->kr_style_parameters = true;
- parse_identifier_list(scope);
- goto parameters_finished;
- }
- }
- if (token.kind == ')') {
+ if (token.kind == T_IDENTIFIER &&
+ !is_typedef_symbol(token.identifier.symbol) &&
+ (look_ahead(1)->kind == ',' || look_ahead(1)->kind == ')')) {
+ type->kr_style_parameters = true;
+ parse_identifier_list(scope);
+ } else if (token.kind == ')') {
/* ISO/IEC 14882:1998(E) ยงC.1.6:1 */
if (!(c_mode & _CXX))
type->unspecified_parameters = true;
} else if (has_parameters()) {
function_parameter_t **anchor = &type->parameters;
+ add_anchor_token(',');
do {
switch (token.kind) {
case T_DOTDOTDOT:
goto parameters_finished;
}
} while (next_if(','));
+parameters_finished:
+ rem_anchor_token(',');
}
-parameters_finished:
rem_anchor_token(')');
- expect(')', end_error);
-
-end_error:
- restore_anchor_state(',', saved_comma_state);
+ expect(')');
}
typedef enum construct_type_kind_t {
errorf(&array->base.pos, "static array parameters require a size");
rem_anchor_token(']');
- expect(']', end_error);
-
-end_error:
+ expect(']');
return cons;
}
env->must_be_abstract = true;
}
rem_anchor_token(')');
- expect(')', end_error);
+ expect(')');
}
break;
}
*anchor = inner_types;
return first;
-end_error:
- return NULL;
}
static type_t *construct_declarator_type(construct_type_t *construct_list,
entity_t *entity;
if (specifiers->storage_class == STORAGE_CLASS_TYPEDEF) {
- entity = allocate_entity_zero(ENTITY_TYPEDEF, NAMESPACE_NORMAL, env.symbol);
- entity->base.source_position = env.source_position;
- entity->typedefe.type = orig_type;
+ entity = allocate_entity_zero(ENTITY_TYPEDEF, NAMESPACE_NORMAL, env.symbol, &env.source_position);
+ entity->typedefe.type = orig_type;
if (anonymous_entity != NULL) {
if (is_type_compound(type)) {
}
} else {
/* create a declaration type entity */
+ source_position_t const *const pos = env.symbol ? &env.source_position : &specifiers->source_position;
if (flags & DECL_CREATE_COMPOUND_MEMBER) {
- entity = allocate_entity_zero(ENTITY_COMPOUND_MEMBER, NAMESPACE_NORMAL, env.symbol);
+ entity = allocate_entity_zero(ENTITY_COMPOUND_MEMBER, NAMESPACE_NORMAL, env.symbol, pos);
if (env.symbol != NULL) {
if (specifiers->is_inline && is_type_valid(type)) {
}
}
} else if (flags & DECL_IS_PARAMETER) {
- entity = allocate_entity_zero(ENTITY_PARAMETER, NAMESPACE_NORMAL, env.symbol);
+ entity = allocate_entity_zero(ENTITY_PARAMETER, NAMESPACE_NORMAL, env.symbol, pos);
orig_type = semantic_parameter(&env.source_position, orig_type, specifiers, entity);
} else if (is_type_function(type)) {
- entity = allocate_entity_zero(ENTITY_FUNCTION, NAMESPACE_NORMAL, env.symbol);
+ entity = allocate_entity_zero(ENTITY_FUNCTION, NAMESPACE_NORMAL, env.symbol, pos);
entity->function.is_inline = specifiers->is_inline;
entity->function.elf_visibility = default_visibility;
entity->function.parameters = env.parameters;
}
}
} else {
- entity = allocate_entity_zero(ENTITY_VARIABLE, NAMESPACE_NORMAL, env.symbol);
+ entity = allocate_entity_zero(ENTITY_VARIABLE, NAMESPACE_NORMAL, env.symbol, pos);
entity->variable.elf_visibility = default_visibility;
entity->variable.thread_local = specifiers->thread_local;
}
}
- entity->base.source_position = env.symbol != NULL ? env.source_position : specifiers->source_position;
entity->declaration.type = orig_type;
entity->declaration.alignment = get_type_alignment(orig_type);
entity->declaration.modifiers = env.modifiers;
}
}
-/**
- * Check if a symbol is the equal to "main".
- */
-static bool is_sym_main(const symbol_t *const sym)
-{
- return streq(sym->string, "main");
-}
-
static void error_redefined_as_different_kind(const source_position_t *pos,
const entity_t *old, entity_kind_t new_kind)
{
}
}
+static bool is_main(entity_t*);
+
/**
* record entities for the NAMESPACE_NORMAL, and produce error messages/warnings
* for various problems that occur for multiple definitions
if (symbol == NULL)
return entity;
+ assert(!entity->base.parent_scope);
+ assert(current_scope);
+ entity->base.parent_scope = current_scope;
+
entity_t *const previous_entity = get_entity(symbol, namespc);
/* pushing the same entity twice will break the stack structure */
assert(previous_entity != entity);
warningf(WARN_STRICT_PROTOTYPES, pos, "function declaration '%#N' is not a prototype", entity);
}
- if (current_scope == file_scope && is_sym_main(symbol)) {
+ if (is_main(entity)) {
check_main(entity);
}
}
case STORAGE_CLASS_EXTERN:
if (is_definition) {
- if (prev_type->function.unspecified_parameters && !is_sym_main(symbol)) {
+ if (prev_type->function.unspecified_parameters && !is_main(entity)) {
warningf(WARN_MISSING_PROTOTYPES, pos, "no previous prototype for '%#N'", entity);
}
} else if (new_storage_class == STORAGE_CLASS_NONE) {
if (entity->kind == ENTITY_FUNCTION) {
if (is_definition &&
entity->declaration.storage_class != STORAGE_CLASS_STATIC &&
- !is_sym_main(symbol)) {
+ !is_main(entity)) {
if (is_warn_on(WARN_MISSING_PROTOTYPES)) {
warningf(WARN_MISSING_PROTOTYPES, pos, "no previous prototype for '%#N'", entity);
} else {
}
finish:
- assert(entity->base.parent_scope == NULL);
- assert(current_scope != NULL);
-
- entity->base.parent_scope = current_scope;
environment_push(entity);
append_entity(current_scope, entity);
/* ISO/IEC 14882:1998(E) ยง8.5.3:3 The initializer can be omitted
* [...] where the extern specifier is explicitly used. */
declaration_t *decl = &entity->declaration;
- if (decl->storage_class != STORAGE_CLASS_EXTERN) {
- type_t *type = decl->type;
- if (is_type_reference(skip_typeref(type))) {
- source_position_t const *const pos = &entity->base.source_position;
- errorf(pos, "reference '%#N' must be initialized", entity);
- }
+ if (decl->storage_class != STORAGE_CLASS_EXTERN &&
+ is_type_reference(skip_typeref(decl->type))) {
+ source_position_t const *const pos = &entity->base.source_position;
+ errorf(pos, "reference '%#N' must be initialized", entity);
}
}
ndeclaration = parse_declarator(specifiers, flags);
rem_anchor_token('=');
}
- expect(';', end_error);
+ rem_anchor_token(',');
+ rem_anchor_token(';');
+ expect(';');
-end_error:
anonymous_entity = NULL;
- rem_anchor_token(';');
- rem_anchor_token(',');
}
static entity_t *finished_kr_declaration(entity_t *entity, bool is_definition)
{
if (is_warn_on(WARN_UNUSED_PARAMETER)) {
const scope_t *scope = ¤t_function->parameters;
-
- /* do not issue unused warnings for main */
- if (!is_sym_main(current_function->base.base.symbol)) {
- warn_unused_entity(WARN_UNUSED_PARAMETER, scope->entities, NULL);
- }
+ warn_unused_entity(WARN_UNUSED_PARAMETER, scope->entities, NULL);
}
if (is_warn_on(WARN_UNUSED_VARIABLE)) {
walk_statements(current_function->statement, check_unused_variables,
type_t *const ret = skip_typeref(type->function.return_type);
if (!is_type_void(ret) &&
is_type_valid(ret) &&
- !is_sym_main(current_function->base.base.symbol)) {
+ !is_main(current_entity)) {
source_position_t const *const pos = &stmt->base.source_position;
warningf(WARN_RETURN_TYPE, pos, "control reaches end of non-void function");
}
return true;
}
+static void prepare_main_collect2(entity_t*);
+
static void parse_external_declaration(void)
{
/* function-definitions and declarations both start with declaration
if (ndeclaration != entity) {
function->parameters = ndeclaration->function.parameters;
}
- assert(is_declaration(entity));
- type = skip_typeref(entity->declaration.type);
PUSH_SCOPE(&function->parameters);
/* parse function body */
int label_stack_top = label_top();
function_t *old_current_function = current_function;
- entity_t *old_current_entity = current_entity;
current_function = function;
- current_entity = entity;
+ PUSH_CURRENT_ENTITY(entity);
PUSH_PARENT(NULL);
goto_first = NULL;
}
}
- if (is_main(entity) && enable_main_collect2_hack)
- prepare_main_collect2(entity);
+ if (is_main(entity)) {
+ /* Force main to C linkage. */
+ type_t *const type = entity->declaration.type;
+ assert(is_type_function(type));
+ if (type->function.linkage != LINKAGE_C) {
+ type_t *new_type = duplicate_type(type);
+ new_type->function.linkage = LINKAGE_C;
+ entity->declaration.type = identify_new_type(new_type);
+ }
+
+ if (enable_main_collect2_hack)
+ prepare_main_collect2(entity);
+ }
+ POP_CURRENT_ENTITY();
POP_PARENT();
assert(current_function == function);
- assert(current_entity == entity);
- current_entity = old_current_entity;
current_function = old_current_function;
label_pop_to(label_stack_top);
}
static void parse_compound_declarators(compound_t *compound,
const declaration_specifiers_t *specifiers)
{
+ add_anchor_token(';');
+ add_anchor_token(',');
do {
entity_t *entity;
if (token.kind == ':') {
/* anonymous bitfield */
type_t *type = specifiers->type;
- entity_t *entity = allocate_entity_zero(ENTITY_COMPOUND_MEMBER,
- NAMESPACE_NORMAL, NULL);
- entity->base.source_position = *HERE;
+ entity_t *const entity = allocate_entity_zero(ENTITY_COMPOUND_MEMBER, NAMESPACE_NORMAL, NULL, HERE);
entity->declaration.declared_storage_class = STORAGE_CLASS_NONE;
entity->declaration.storage_class = STORAGE_CLASS_NONE;
entity->declaration.type = type;
}
}
} while (next_if(','));
- expect(';', end_error);
+ rem_anchor_token(',');
+ rem_anchor_token(';');
+ expect(';');
-end_error:
anonymous_entity = NULL;
}
default:
rem_anchor_token('}');
- expect('}', end_error);
-end_error:
+ expect('}');
/* ยง6.7.2.1:7 */
compound->complete = true;
return;
static expression_parser_function_t expression_parsers[T_LAST_TOKEN];
-/**
- * Prints an error message if an expression was expected but not read
- */
-static expression_t *expected_expression_error(void)
-{
- /* skip the error message if the error token was read */
- if (token.kind != T_ERROR) {
- errorf(HERE, "expected expression, got token %K", &token);
- }
- next_token();
-
- return create_error_expression();
-}
-
static type_t *get_string_type(void)
{
return is_warn_on(WARN_WRITE_STRINGS) ? type_const_char_ptr : type_char_ptr;
check_integer_suffix();
type = type_int;
break;
- case T_INTEGER_OCTAL:
- kind = EXPR_LITERAL_INTEGER_OCTAL;
- check_integer_suffix();
- type = type_int;
- break;
- case T_INTEGER_HEXADECIMAL:
- kind = EXPR_LITERAL_INTEGER_HEXADECIMAL;
- check_integer_suffix();
- type = type_int;
- break;
+
case T_FLOATINGPOINT:
kind = EXPR_LITERAL_FLOATINGPOINT;
type = check_floatingpoint_suffix();
break;
- case T_FLOATINGPOINT_HEXADECIMAL:
- kind = EXPR_LITERAL_FLOATINGPOINT_HEXADECIMAL;
- type = check_floatingpoint_suffix();
- break;
+
default:
panic("unexpected token type in parse_number_literal");
}
return literal;
}
-static entity_t *create_implicit_function(symbol_t *symbol,
- const source_position_t *source_position)
+static entity_t *create_implicit_function(symbol_t *symbol, source_position_t const *const pos)
{
type_t *ntype = allocate_type_zero(TYPE_FUNCTION);
ntype->function.return_type = type_int;
ntype->function.linkage = LINKAGE_C;
type_t *type = identify_new_type(ntype);
- entity_t *const entity = allocate_entity_zero(ENTITY_FUNCTION, NAMESPACE_NORMAL, symbol);
+ entity_t *const entity = allocate_entity_zero(ENTITY_FUNCTION, NAMESPACE_NORMAL, symbol, pos);
entity->declaration.storage_class = STORAGE_CLASS_EXTERN;
entity->declaration.declared_storage_class = STORAGE_CLASS_EXTERN;
entity->declaration.type = type;
entity->declaration.implicit = true;
- entity->base.source_position = *source_position;
if (current_scope != NULL)
record_entity(entity, false);
entity_t *entity;
while (true) {
- if (token.kind != T_IDENTIFIER) {
- parse_error_expected("while parsing identifier", T_IDENTIFIER, NULL);
+ symbol = expect_identifier("while parsing identifier", &pos);
+ if (!symbol)
return create_error_entity(sym_anonymous, ENTITY_VARIABLE);
- }
- symbol = token.identifier.symbol;
- pos = *HERE;
- next_token();
/* lookup entity */
entity = lookup_entity(lookup_scope, symbol, NAMESPACE_NORMAL);
type_t *type = parse_typename();
rem_anchor_token(')');
- expect(')', end_error);
+ expect(')');
if (token.kind == '{') {
return parse_compound_literal(&pos, type);
}
return cast;
-end_error:
- return create_error_expression();
}
/**
expression->base.type = type;
rem_anchor_token(')');
- expect(')', end_error);
-
-end_error:
+ expect(')');
return expression;
}
expression_t *result = parse_expression();
result->base.parenthesized = true;
rem_anchor_token(')');
- expect(')', end_error);
+ expect(')');
-end_error:
return result;
}
static designator_t *parse_designator(void)
{
- designator_t *result = allocate_ast_zero(sizeof(result[0]));
- result->source_position = *HERE;
-
- if (token.kind != T_IDENTIFIER) {
- parse_error_expected("while parsing member designator",
- T_IDENTIFIER, NULL);
+ designator_t *const result = allocate_ast_zero(sizeof(result[0]));
+ result->symbol = expect_identifier("while parsing member designator", &result->source_position);
+ if (!result->symbol)
return NULL;
- }
- result->symbol = token.identifier.symbol;
- next_token();
designator_t *last_designator = result;
while (true) {
if (next_if('.')) {
- if (token.kind != T_IDENTIFIER) {
- parse_error_expected("while parsing member designator",
- T_IDENTIFIER, NULL);
+ designator_t *const designator = allocate_ast_zero(sizeof(result[0]));
+ designator->symbol = expect_identifier("while parsing member designator", &designator->source_position);
+ if (!designator->symbol)
return NULL;
- }
- designator_t *designator = allocate_ast_zero(sizeof(result[0]));
- designator->source_position = *HERE;
- designator->symbol = token.identifier.symbol;
- next_token();
last_designator->next = designator;
last_designator = designator;
designator->source_position = *HERE;
designator->array_index = parse_expression();
rem_anchor_token(']');
- expect(']', end_error);
+ expect(']');
if (designator->array_index == NULL) {
return NULL;
}
}
return result;
-end_error:
- return NULL;
}
/**
eat(T___builtin_offsetof);
- expect('(', end_error);
+ expect('(');
+ add_anchor_token(')');
add_anchor_token(',');
type_t *type = parse_typename();
rem_anchor_token(',');
- expect(',', end_error);
- add_anchor_token(')');
+ expect(',');
designator_t *designator = parse_designator();
rem_anchor_token(')');
- expect(')', end_error);
+ expect(')');
expression->offsetofe.type = type;
expression->offsetofe.designator = designator;
DEL_ARR_F(path.path);
return expression;
-end_error:
- return create_error_expression();
}
/**
eat(T___builtin_va_start);
- expect('(', end_error);
+ expect('(');
+ add_anchor_token(')');
add_anchor_token(',');
expression->va_starte.ap = parse_assignment_expression();
rem_anchor_token(',');
- expect(',', end_error);
+ expect(',');
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(')', end_error);
- return expression;
+ } else {
+ expression = create_error_expression();
}
- expect(')', end_error);
-end_error:
- return create_error_expression();
+ rem_anchor_token(')');
+ expect(')');
+ return expression;
}
/**
eat(T___builtin_va_arg);
- expect('(', end_error);
+ expect('(');
+ add_anchor_token(')');
+ add_anchor_token(',');
call_argument_t ap;
ap.expression = parse_assignment_expression();
expression->va_arge.ap = ap.expression;
check_call_argument(type_valist, &ap, 1);
- expect(',', end_error);
+ rem_anchor_token(',');
+ expect(',');
expression->base.type = parse_typename();
- expect(')', end_error);
+ rem_anchor_token(')');
+ expect(')');
return expression;
-end_error:
- return create_error_expression();
}
/**
eat(T___builtin_va_copy);
- expect('(', end_error);
+ expect('(');
+ add_anchor_token(')');
+ add_anchor_token(',');
expression_t *dst = parse_assignment_expression();
assign_error_t error = semantic_assign(type_valist, dst);
report_assign_error(error, type_valist, dst, "call argument 1",
&dst->base.source_position);
expression->va_copye.dst = dst;
- expect(',', end_error);
+ rem_anchor_token(',');
+ expect(',');
call_argument_t src;
src.expression = parse_assignment_expression();
check_call_argument(type_valist, &src, 2);
expression->va_copye.src = src.expression;
- expect(')', end_error);
+ rem_anchor_token(')');
+ expect(')');
return expression;
-end_error:
- return create_error_expression();
}
/**
eat(T___builtin_constant_p);
- expect('(', end_error);
+ expect('(');
add_anchor_token(')');
expression->builtin_constant.value = parse_assignment_expression();
rem_anchor_token(')');
- expect(')', end_error);
+ expect(')');
expression->base.type = type_int;
return expression;
-end_error:
- return create_error_expression();
}
/**
eat(T___builtin_types_compatible_p);
- expect('(', end_error);
+ expect('(');
add_anchor_token(')');
add_anchor_token(',');
expression->builtin_types_compatible.left = parse_typename();
rem_anchor_token(',');
- expect(',', end_error);
+ expect(',');
expression->builtin_types_compatible.right = parse_typename();
rem_anchor_token(')');
- expect(')', end_error);
+ expect(')');
expression->base.type = type_int;
return expression;
-end_error:
- return create_error_expression();
}
/**
expression->base.source_position = *HERE;
next_token();
- expect('(', end_error);
+ expect('(');
+ add_anchor_token(')');
+ add_anchor_token(',');
expression->binary.left = parse_assignment_expression();
- expect(',', end_error);
+ rem_anchor_token(',');
+ expect(',');
expression->binary.right = parse_assignment_expression();
- expect(')', end_error);
+ rem_anchor_token(')');
+ expect(')');
type_t *const orig_type_left = expression->binary.left->base.type;
type_t *const orig_type_right = expression->binary.right->base.type;
}
return expression;
-end_error:
- return create_error_expression();
}
/**
eat(T__assume);
- expect('(', end_error);
+ expect('(');
add_anchor_token(')');
expression->unary.value = parse_assignment_expression();
rem_anchor_token(')');
- expect(')', end_error);
+ expect(')');
expression->base.type = type_void;
return expression;
-end_error:
- return create_error_expression();
}
/**
}
} else if (label == NULL || label->base.parent_scope != ¤t_function->parameters) {
/* There is no matching label in the same function, so create a new one. */
- label = allocate_entity_zero(ENTITY_LABEL, NAMESPACE_LABEL, token.identifier.symbol);
+ source_position_t const nowhere = { NULL, 0, 0, false };
+ label = allocate_entity_zero(ENTITY_LABEL, NAMESPACE_LABEL, token.identifier.symbol, &nowhere);
label_push(label);
}
rem_anchor_token(',');
rem_anchor_token(')');
}
- expect(')', end_error);
+ expect(')');
-end_error:
return literal;
}
case T_false: return parse_boolean_literal(false);
case T_true: return parse_boolean_literal(true);
case T_INTEGER:
- case T_INTEGER_OCTAL:
- case T_INTEGER_HEXADECIMAL:
- case T_FLOATINGPOINT:
- case T_FLOATINGPOINT_HEXADECIMAL: return parse_number_literal();
+ case T_FLOATINGPOINT: return parse_number_literal();
case T_CHARACTER_CONSTANT: return parse_character_constant();
case T_WIDE_CHARACTER_CONSTANT: return parse_wide_character_constant();
case T_STRING_LITERAL:
arr->base.type = res_type;
rem_anchor_token(']');
- expect(']', end_error);
-end_error:
+ expect(']');
return expr;
}
add_anchor_token(')');
orig_type = parse_typename();
rem_anchor_token(')');
- expect(')', end_error);
+ expect(')');
if (token.kind == '{') {
/* It was not sizeof(type) after all. It is sizeof of an expression
what, wrong_type, orig_type);
}
-end_error:
return tp_expression;
}
source_position_t const pos = *HERE;
next_token();
- if (token.kind != T_IDENTIFIER) {
- parse_error_expected("while parsing select", T_IDENTIFIER, NULL);
+ symbol_t *const symbol = expect_identifier("while parsing select", NULL);
+ if (!symbol)
return create_error_expression();
- }
- symbol_t *symbol = token.identifier.symbol;
- next_token();
type_t *const orig_type = addr->base.type;
type_t *const type = skip_typeref(orig_type);
}
rem_anchor_token(',');
rem_anchor_token(')');
- expect(')', end_error);
+ expect(')');
if (function_type == NULL)
return result;
handle_builtin_argument_restrictions(call);
}
-end_error:
return result;
}
true_expression = parse_expression();
}
rem_anchor_token(':');
- expect(':', end_error);
-end_error:;
+ expect(':');
expression_t *false_expression =
parse_subexpression(c_mode & _CXX ? PREC_ASSIGNMENT : PREC_CONDITIONAL);
eat(T___builtin_classify_type);
- expect('(', end_error);
+ expect('(');
add_anchor_token(')');
expression_t *expression = parse_expression();
rem_anchor_token(')');
- expect(')', end_error);
+ expect(')');
result->classify_type.type_expression = expression;
return result;
-end_error:
- return create_error_expression();
}
/**
if (next_if('[')) {
result->kind = EXPR_UNARY_DELETE_ARRAY;
- expect(']', end_error);
-end_error:;
+ expect(']');
}
expression_t *const value = parse_subexpression(PREC_CAST);
case EXPR_LITERAL_CHARACTER:
case EXPR_LITERAL_WIDE_CHARACTER:
case EXPR_LITERAL_INTEGER:
- case EXPR_LITERAL_INTEGER_OCTAL:
- case EXPR_LITERAL_INTEGER_HEXADECIMAL:
case EXPR_LITERAL_FLOATINGPOINT:
- case EXPR_LITERAL_FLOATINGPOINT_HEXADECIMAL: return false;
case EXPR_STRING_LITERAL: return false;
case EXPR_WIDE_STRING_LITERAL: return false;
static expression_t *parse_subexpression(precedence_t precedence)
{
- if (token.kind < 0) {
- return expected_expression_error();
- }
-
expression_parser_function_t *parser
= &expression_parsers[token.kind];
expression_t *left;
assert(left != NULL);
while (true) {
- if (token.kind < 0) {
- return expected_expression_error();
- }
-
parser = &expression_parsers[token.kind];
if (parser->infix_parser == NULL)
break;
while (token.kind == T_STRING_LITERAL || token.kind == '[') {
asm_argument_t *argument = allocate_ast_zero(sizeof(argument[0]));
- memset(argument, 0, sizeof(argument[0]));
if (next_if('[')) {
- if (token.kind != T_IDENTIFIER) {
- parse_error_expected("while parsing asm argument",
- T_IDENTIFIER, NULL);
+ add_anchor_token(']');
+ argument->symbol = expect_identifier("while parsing asm argument", NULL);
+ rem_anchor_token(']');
+ expect(']');
+ if (!argument->symbol)
return NULL;
- }
- argument->symbol = token.identifier.symbol;
-
- expect(']', end_error);
}
argument->constraints = parse_string_literals();
- expect('(', end_error);
+ expect('(');
add_anchor_token(')');
expression_t *expression = parse_expression();
rem_anchor_token(')');
mark_vars_read(expression, NULL);
}
argument->expression = expression;
- expect(')', end_error);
+ expect(')');
set_address_taken(expression, true);
}
return result;
-end_error:
- return NULL;
}
/**
if (next_if(T_volatile))
asm_statement->is_volatile = true;
- expect('(', end_error);
+ expect('(');
add_anchor_token(')');
if (token.kind != T_STRING_LITERAL) {
parse_error_expected("after asm(", T_STRING_LITERAL, NULL);
end_of_asm:
rem_anchor_token(')');
- expect(')', end_error);
- expect(';', end_error);
+ expect(')');
+ expect(';');
-end_error:
if (asm_statement->outputs == NULL) {
/* GCC: An 'asm' instruction without any output operands will be treated
* identically to a volatile 'asm' instruction. */
source_position_t *const pos = &statement->base.source_position;
eat(T_case);
+ add_anchor_token(':');
expression_t *expression = parse_expression();
type_t *expression_type = expression->base.type;
PUSH_PARENT(statement);
- expect(':', end_error);
-end_error:
+ rem_anchor_token(':');
+ expect(':');
if (current_switch != NULL) {
if (! statement->case_label.is_bad) {
PUSH_PARENT(statement);
- expect(':', end_error);
-end_error:
+ expect(':');
if (current_switch != NULL) {
const case_label_statement_t *def_label = current_switch->default_label;
*/
static expression_t *parse_condition(void)
{
- expect('(', end_error0);
+ expect('(');
add_anchor_token(')');
expression_t *const expr = parse_expression();
mark_vars_read(expr, NULL);
rem_anchor_token(')');
- expect(')', end_error1);
-end_error1:
+ expect(')');
return expr;
-end_error0:
- return create_error_expression();
}
/**
eat(T_if);
PUSH_PARENT(statement);
+ PUSH_SCOPE_STATEMENT(&statement->ifs.scope);
- add_anchor_token('{');
+ add_anchor_token(T_else);
expression_t *const expr = parse_condition();
statement->ifs.condition = expr;
* scalar type. */
semantic_condition(expr, "condition of 'if'-statment");
- rem_anchor_token('{');
-
- add_anchor_token(T_else);
statement_t *const true_stmt = parse_inner_statement();
statement->ifs.true_statement = true_stmt;
rem_anchor_token(T_else);
warningf(WARN_PARENTHESES, pos, "suggest explicit braces to avoid ambiguous 'else'");
}
+ POP_SCOPE();
POP_PARENT();
return statement;
}
eat(T_switch);
PUSH_PARENT(statement);
+ PUSH_SCOPE_STATEMENT(&statement->switchs.scope);
expression_t *const expr = parse_condition();
type_t * type = skip_typeref(expr->base.type);
}
check_enum_cases(&statement->switchs);
+ POP_SCOPE();
POP_PARENT();
return statement;
}
eat(T_while);
PUSH_PARENT(statement);
+ PUSH_SCOPE_STATEMENT(&statement->whiles.scope);
expression_t *const cond = parse_condition();
statement->whiles.condition = cond;
statement->whiles.body = parse_loop_body(statement);
+ POP_SCOPE();
POP_PARENT();
return statement;
}
eat(T_do);
PUSH_PARENT(statement);
+ PUSH_SCOPE_STATEMENT(&statement->do_while.scope);
add_anchor_token(T_while);
statement->do_while.body = parse_loop_body(statement);
rem_anchor_token(T_while);
- expect(T_while, end_error0);
-end_error0:;
+ expect(T_while);
expression_t *const cond = parse_condition();
statement->do_while.condition = cond;
/* ยง6.8.5:2 The controlling expression of an iteration statement shall
* have scalar type. */
semantic_condition(cond, "condition of 'do-while'-statement");
- expect(';', end_error1);
-end_error1:
+ expect(';');
+ POP_SCOPE();
POP_PARENT();
return statement;
}
eat(T_for);
PUSH_PARENT(statement);
- PUSH_SCOPE(&statement->fors.scope);
+ PUSH_SCOPE_STATEMENT(&statement->fors.scope);
- expect('(', end_error1);
+ expect('(');
add_anchor_token(')');
PUSH_EXTENSION();
warningf(WARN_UNUSED_VALUE, &init->base.source_position, "initialisation of 'for'-statement has no effect");
}
rem_anchor_token(';');
- expect(';', end_error3);
-end_error3:;
+ expect(';');
}
POP_EXTENSION();
mark_vars_read(cond, NULL);
rem_anchor_token(';');
}
- expect(';', end_error2);
-end_error2:
+ expect(';');
if (token.kind != ')') {
expression_t *const step = parse_expression();
statement->fors.step = step;
}
}
rem_anchor_token(')');
- expect(')', end_error1);
-end_error1:
+ expect(')');
statement->fors.body = parse_loop_body(statement);
POP_SCOPE();
else
parse_error_expected("while parsing goto", T_IDENTIFIER, NULL);
eat_until_anchor();
- statement->gotos.label = &allocate_entity_zero(ENTITY_LABEL, NAMESPACE_LABEL, sym_anonymous)->label;
+ statement->gotos.label = &allocate_entity_zero(ENTITY_LABEL, NAMESPACE_LABEL, sym_anonymous, &builtin_source_position)->label;
}
}
- expect(';', end_error);
-
-end_error:
+ expect(';');
return statement;
}
statement_t *statement = allocate_statement_zero(STATEMENT_CONTINUE);
eat(T_continue);
- expect(';', end_error);
-
-end_error:
+ expect(';');
return statement;
}
statement_t *statement = allocate_statement_zero(STATEMENT_BREAK);
eat(T_break);
- expect(';', end_error);
-
-end_error:
+ expect(';');
return statement;
}
statement_t *statement = allocate_statement_zero(STATEMENT_LEAVE);
eat(T___leave);
- expect(';', end_error);
-
-end_error:
+ expect(';');
return statement;
}
}
statement->returns.value = return_value;
- expect(';', end_error);
-
-end_error:
+ expect(';');
return statement;
}
statement->expression.expression = expr;
mark_vars_read(expr, ENT_ANY);
- expect(';', end_error);
-
-end_error:
+ expect(';');
return statement;
}
entity_t *end = NULL;
entity_t **anchor = &begin;
do {
- if (token.kind != T_IDENTIFIER) {
- parse_error_expected("while parsing local label declaration",
- T_IDENTIFIER, NULL);
+ source_position_t pos;
+ symbol_t *const symbol = expect_identifier("while parsing local label declaration", &pos);
+ if (!symbol)
goto end_error;
- }
- symbol_t *symbol = token.identifier.symbol;
+
entity_t *entity = get_entity(symbol, NAMESPACE_LABEL);
if (entity != NULL && entity->base.parent_scope == current_scope) {
source_position_t const *const ppos = &entity->base.source_position;
- errorf(HERE, "multiple definitions of '%N' (previous definition %P)", entity, ppos);
+ errorf(&pos, "multiple definitions of '%N' (previous definition %P)", entity, ppos);
} else {
- entity = allocate_entity_zero(ENTITY_LOCAL_LABEL, NAMESPACE_LABEL, symbol);
- entity->base.parent_scope = current_scope;
- entity->base.source_position = token.base.source_position;
+ entity = allocate_entity_zero(ENTITY_LOCAL_LABEL, NAMESPACE_LABEL, symbol, &pos);
+ entity->base.parent_scope = current_scope;
*anchor = entity;
anchor = &entity->base.next;
environment_push(entity);
}
- next_token();
} while (next_if(','));
- expect(';', end_error);
+ expect(';');
end_error:
statement->declaration.declarations_begin = begin;
statement->declaration.declarations_end = end;
}
if (entity == NULL) {
- entity = allocate_entity_zero(ENTITY_NAMESPACE, NAMESPACE_NORMAL, symbol);
- entity->base.source_position = token.base.source_position;
- entity->base.parent_scope = current_scope;
+ entity = allocate_entity_zero(ENTITY_NAMESPACE, NAMESPACE_NORMAL, symbol, HERE);
+ entity->base.parent_scope = current_scope;
}
if (token.kind == '=') {
append_entity(current_scope, entity);
PUSH_SCOPE(&entity->namespacee.members);
+ PUSH_CURRENT_ENTITY(entity);
- entity_t *old_current_entity = current_entity;
- current_entity = entity;
-
- expect('{', end_error);
+ add_anchor_token('}');
+ expect('{');
parse_externals();
- expect('}', end_error);
+ rem_anchor_token('}');
+ expect('}');
-end_error:
- assert(current_entity == entity);
- current_entity = old_current_entity;
+ POP_CURRENT_ENTITY();
POP_SCOPE();
}
statement_t **anchor = &statement->compound.statements;
bool only_decls_so_far = true;
- while (token.kind != '}') {
- if (token.kind == T_EOF) {
- errorf(&statement->base.source_position,
- "EOF while parsing compound statement");
- break;
- }
+ while (token.kind != '}' && token.kind != T_EOF) {
statement_t *sub_statement = intern_parse_statement();
if (sub_statement->kind == STATEMENT_ERROR) {
- /* an error occurred. if we are at an anchor, return */
- if (at_anchor())
- goto end_error;
- continue;
+ break;
}
if (sub_statement->kind != STATEMENT_DECLARATION) {
}
*anchor = sub_statement;
-
- while (sub_statement->base.next != NULL)
- sub_statement = sub_statement->base.next;
-
- anchor = &sub_statement->base.next;
+ anchor = &sub_statement->base.next;
}
- next_token();
+ expect('}');
/* look over all statements again to produce no effect warnings */
if (is_warn_on(WARN_UNUSED_VALUE)) {
}
}
-end_error:
rem_anchor_token(T_while);
rem_anchor_token(T_wchar_t);
rem_anchor_token(T_volatile);
statement_t *statement = allocate_statement_zero(STATEMENT_ASM);
eat(T_asm);
- expect('(', end_error);
+ add_anchor_token(';');
+ add_anchor_token(')');
+ add_anchor_token(T_STRING_LITERAL);
+ expect('(');
+ rem_anchor_token(T_STRING_LITERAL);
statement->asms.asm_text = parse_string_literals();
statement->base.next = unit->global_asm;
unit->global_asm = statement;
- expect(')', end_error);
- expect(';', end_error);
-
-end_error:;
+ rem_anchor_token(')');
+ expect(')');
+ rem_anchor_token(';');
+ expect(';');
}
static void parse_linkage_specification(void)
if (next_if('{')) {
parse_externals();
- expect('}', end_error);
+ expect('}');
} else {
parse_external();
}
-end_error:
assert(current_linkage == new_linkage);
current_linkage = old_linkage;
}
}
}
-void prepare_main_collect2(entity_t *entity)
+static void prepare_main_collect2(entity_t *const entity)
{
PUSH_SCOPE(&entity->function.statement->compound.scope);
projects / cparser / blobdiff