symbol_t *get_property_sym; /**< the name of the get property if set. */
symbol_t *put_property_sym; /**< the name of the put property if set. */
type_t *type;
+ variable_t *based_variable; /**< Microsoft __based variable. */
};
/**
/** true in we are in a __extension__ context. */
static bool in_gcc_extension = false;
static struct obstack temp_obst;
+static entity_t *anonymous_entity;
#define PUSH_PARENT(stmt) \
namespace_tag_t namespc)
{
entity_t *entity = symbol->entity;
- for( ; entity != NULL; entity = entity->base.symbol_next) {
+ for (; entity != NULL; entity = entity->base.symbol_next) {
if (entity->base.namespc == namespc)
return entity;
}
if (new_top == top)
return;
- for(i = top; i > new_top; --i) {
+ for (i = top; i > new_top; --i) {
stack_entry_t *entry = &stack[i - 1];
entity_t *old_entity = entry->old_entity;
string_t string = { NULL, 0 };
parse_gnu_attribute_string_arg(attribute, &string);
if (string.begin != NULL) {
- for(size_t i = 0; i < 4; ++i) {
+ for (size_t i = 0; i < 4; ++i) {
if (strcmp(tls_models[i], string.begin) == 0) {
attribute->u.value = i;
return;
string_t string = { NULL, 0 };
parse_gnu_attribute_string_arg(attribute, &string);
if (string.begin != NULL) {
- for(size_t i = 0; i < 4; ++i) {
+ for (size_t i = 0; i < 4; ++i) {
if (strcmp(visibilities[i], string.begin) == 0) {
attribute->u.value = i;
return;
string_t string = { NULL, 0 };
parse_gnu_attribute_string_arg(attribute, &string);
if (string.begin != NULL) {
- for(int i = 0; i < 3; ++i) {
+ for (int i = 0; i < 3; ++i) {
if (strcmp(visibilities[i], string.begin) == 0) {
attribute->u.value = i;
return;
string_t string = { NULL, 0 };
parse_gnu_attribute_string_arg(attribute, &string);
if (string.begin != NULL) {
- for(size_t i = 0; i < 5; ++i) {
+ for (size_t i = 0; i < 5; ++i) {
if (strcmp(interrupts[i], string.begin) == 0) {
attribute->u.value = i;
return;
goto end_error;
}
const char *name = token.v.symbol->string;
- for(i = 0; i < 4; ++i) {
+ for (i = 0; i < 4; ++i) {
if (strcmp_underscore(format_names[i], name) == 0)
break;
}
next_token();
int i;
- for(i = 0; i < GNU_AK_LAST; ++i) {
+ for (i = 0; i < GNU_AK_LAST; ++i) {
if (strcmp_underscore(gnu_attribute_names[i], name) == 0)
break;
}
{
size_t len = ARR_LEN(path->path);
- for(size_t i = 0; i < len; ++i) {
+ for (size_t i = 0; i < len; ++i) {
const type_path_entry_t *entry = & path->path[i];
type_t *type = skip_typeref(entry->type);
fprintf(stderr, ".%s",
entry->v.compound_entry->base.symbol->string);
} else if (is_type_array(type)) {
- fprintf(stderr, "[%zu]", entry->v.index);
+ fprintf(stderr, "[%u]", (unsigned) entry->v.index);
} else {
fprintf(stderr, "-INVALID-");
}
static bool walk_designator(type_path_t *path, const designator_t *designator,
bool used_in_offsetof)
{
- for( ; designator != NULL; designator = designator->next) {
+ for (; designator != NULL; designator = designator->next) {
type_path_entry_t *top = get_type_path_top(path);
type_t *orig_type = top->type;
} else {
compound_t *compound = type->compound.compound;
entity_t *iter = compound->members.entities;
- for( ; iter != NULL; iter = iter->base.next) {
+ for (; iter != NULL; iter = iter->base.next) {
if (iter->base.symbol == symbol) {
break;
}
eat(T_union);
}
- symbol_t *symbol = NULL;
+ symbol_t *symbol = NULL;
compound_t *compound = NULL;
if (token.type == T___attribute__) {
}
if (token.type == '{') {
- compound->complete = true;
-
parse_compound_type_entries(compound);
modifiers |= parse_attributes(&attributes);
+
+ if (symbol == NULL) {
+ assert(anonymous_entity == NULL);
+ anonymous_entity = (entity_t*)compound;
+ }
}
compound->modifiers |= modifiers;
eat('{');
if (token.type == '}') {
- next_token();
errorf(HERE, "empty enum not allowed");
+ next_token();
return;
}
parse_enum_entries(type);
parse_attributes(&attributes);
- } else if(!entity->enume.complete && !(c_mode & _GNUC)) {
+
+ if (symbol == NULL) {
+ assert(anonymous_entity == NULL);
+ anonymous_entity = entity;
+ }
+ } else if (!entity->enume.complete && !(c_mode & _GNUC)) {
errorf(HERE, "enum %Y used before definition (incomplete enumes are a GNU extension)",
symbol);
}
return entity;
}
+static void parse_microsoft_based(declaration_specifiers_t *specifiers)
+{
+ if (token.type != T_IDENTIFIER) {
+ parse_error_expected("while parsing __based", T_IDENTIFIER, NULL);
+ return;
+ }
+ symbol_t *symbol = token.v.symbol;
+ entity_t *entity = get_entity(symbol, NAMESPACE_NORMAL);
+
+ if (entity == NULL || entity->base.kind != ENTITY_VARIABLE) {
+ errorf(HERE, "'%Y' is not a variable name.", symbol);
+ entity = create_error_entity(symbol, ENTITY_VARIABLE);
+ } else {
+ variable_t *variable = &entity->variable;
+
+ if (specifiers->based_variable != NULL) {
+ errorf(HERE, "__based type qualifier specified more than once");
+ }
+ specifiers->based_variable = variable;
+
+ type_t *const type = variable->base.type;
+
+ if (is_type_valid(type)) {
+ if (! is_type_pointer(skip_typeref(type))) {
+ errorf(HERE, "variable in __based modifier must have pointer type instead of %T", type);
+ }
+ if (variable->base.base.parent_scope != file_scope) {
+ errorf(HERE, "a nonstatic local variable may not be used in a __based specification");
+ }
+ }
+ }
+ next_token();
+}
+
/**
* Finish the construction of a struct type by calculating
* its size, offsets, alignment.
expect(')');
break;
+ case T__based:
+ next_token();
+ expect('(');
+ add_anchor_token(')');
+ parse_microsoft_based(specifiers);
+ rem_anchor_token(')');
+ expect(')');
+ break;
+
case T___thread:
switch (specifiers->storage_class) {
case STORAGE_CLASS_NONE:
parse_declaration_specifiers(&specifiers);
entity_t *entity = parse_declarator(&specifiers, true, false);
+ anonymous_entity = NULL;
return entity;
}
return (construct_type_t*) array;
}
-static construct_type_t *parse_function_declarator(scope_t *scope)
+static construct_type_t *parse_function_declarator(scope_t *scope,
+ decl_modifiers_t modifiers)
{
- type_t *type = allocate_type_zero(TYPE_FUNCTION);
-
- type->function.linkage = current_linkage;
-
- /* TODO: revive this... once we know exactly how to do it */
-#if 0
- decl_modifiers_t modifiers = entity->declaration.modifiers;
+ type_t *type = allocate_type_zero(TYPE_FUNCTION);
+ function_type_t *ftype = &type->function;
- unsigned mask = modifiers & (DM_CDECL|DM_STDCALL|DM_FASTCALL|DM_THISCALL);
+ ftype->linkage = current_linkage;
- if (mask & (mask-1)) {
- const char *first = NULL, *second = NULL;
+ switch (modifiers & (DM_CDECL | DM_STDCALL | DM_FASTCALL | DM_THISCALL)) {
+ case DM_NONE: break;
+ case DM_CDECL: ftype->calling_convention = CC_CDECL; break;
+ case DM_STDCALL: ftype->calling_convention = CC_STDCALL; break;
+ case DM_FASTCALL: ftype->calling_convention = CC_FASTCALL; break;
+ case DM_THISCALL: ftype->calling_convention = CC_THISCALL; break;
- /* more than one calling convention set */
- if (modifiers & DM_CDECL) {
- if (first == NULL) first = "cdecl";
- else if (second == NULL) second = "cdecl";
- }
- if (modifiers & DM_STDCALL) {
- if (first == NULL) first = "stdcall";
- else if (second == NULL) second = "stdcall";
- }
- if (modifiers & DM_FASTCALL) {
- if (first == NULL) first = "fastcall";
- else if (second == NULL) second = "fastcall";
- }
- if (modifiers & DM_THISCALL) {
- if (first == NULL) first = "thiscall";
- else if (second == NULL) second = "thiscall";
- }
- errorf(&entity->base.source_position,
- "%s and %s attributes are not compatible", first, second);
+ default:
+ errorf(HERE, "multiple calling conventions in declaration");
+ break;
}
- if (modifiers & DM_CDECL)
- type->function.calling_convention = CC_CDECL;
- else if (modifiers & DM_STDCALL)
- type->function.calling_convention = CC_STDCALL;
- else if (modifiers & DM_FASTCALL)
- type->function.calling_convention = CC_FASTCALL;
- else if (modifiers & DM_THISCALL)
- type->function.calling_convention = CC_THISCALL;
-#endif
-
- parse_parameters(&type->function, scope);
+ parse_parameters(ftype, scope);
construct_function_type_t *construct_function_type =
obstack_alloc(&temp_obst, sizeof(construct_function_type[0]));
modifiers |= parse_attributes(&attributes);
}
- if (env != NULL)
- env->modifiers |= modifiers;
+ if (env != NULL) {
+ modifiers |= env->modifiers;
+ env->modifiers = modifiers;
+ }
construct_type_t *inner_types = NULL;
construct_type_t *p = last;
- while(true) {
+ while (true) {
construct_type_t *type;
switch (token.type) {
case '(': {
if (env != NULL)
scope = &env->parameters;
- type = parse_function_declarator(scope);
+ type = parse_function_declarator(scope, modifiers);
break;
}
case '[':
}
static type_t *construct_declarator_type(construct_type_t *construct_list,
- type_t *type)
+ type_t *type, variable_t *variable)
{
construct_type_t *iter = construct_list;
- for( ; iter != NULL; iter = iter->next) {
+ for (; iter != NULL; iter = iter->next) {
switch (iter->kind) {
case CONSTRUCT_INVALID:
internal_errorf(HERE, "invalid type construction found");
case CONSTRUCT_POINTER: {
parsed_pointer_t *parsed_pointer = (parsed_pointer_t*) iter;
- type = make_pointer_type(type, parsed_pointer->type_qualifiers);
+ type = make_based_pointer_type(type, parsed_pointer->type_qualifiers, variable);
continue;
}
{
parse_declarator_env_t env;
memset(&env, 0, sizeof(env));
+ env.modifiers = specifiers->modifiers;
construct_type_t *construct_type
= parse_inner_declarator(&env, may_be_abstract);
- type_t *type = construct_declarator_type(construct_type, specifiers->type);
+ type_t *type = construct_declarator_type(construct_type, specifiers->type, specifiers->based_variable);
if (construct_type != NULL) {
obstack_free(&temp_obst, construct_type);
entity->base.symbol = env.symbol;
entity->base.source_position = env.source_position;
entity->typedefe.type = type;
+
+ if (anonymous_entity != NULL) {
+ if (is_type_compound(type)) {
+ assert(anonymous_entity->compound.alias == NULL);
+ assert(anonymous_entity->kind == ENTITY_STRUCT ||
+ anonymous_entity->kind == ENTITY_UNION);
+ anonymous_entity->compound.alias = entity;
+ anonymous_entity = NULL;
+ } else if (is_type_enum(type)) {
+ assert(anonymous_entity->enume.alias == NULL);
+ assert(anonymous_entity->kind == ENTITY_ENUM);
+ anonymous_entity->enume.alias = entity;
+ anonymous_entity = NULL;
+ }
+ }
} else {
if (create_compound_member) {
entity = allocate_entity_zero(ENTITY_COMPOUND_MEMBER);
}
}
- entity->base.source_position = env.source_position;
- entity->base.symbol = env.symbol;
- entity->base.namespc = NAMESPACE_NORMAL;
- entity->declaration.type = type;
- entity->declaration.modifiers = env.modifiers | specifiers->modifiers;
+ entity->base.source_position = env.source_position;
+ entity->base.symbol = env.symbol;
+ entity->base.namespc = NAMESPACE_NORMAL;
+ entity->declaration.type = type;
+ entity->declaration.modifiers = env.modifiers;
entity->declaration.deprecated_string = specifiers->deprecated_string;
storage_class_t storage_class = specifiers->storage_class;
{
construct_type_t *construct_type = parse_inner_declarator(NULL, 1);
- type_t *result = construct_declarator_type(construct_type, base_type);
+ type_t *result = construct_declarator_type(construct_type, base_type, NULL);
if (construct_type != NULL) {
obstack_free(&temp_obst, construct_type);
}
{
add_anchor_token(';');
add_anchor_token(',');
- while(true) {
+ while (true) {
entity_t *entity = finished_declaration(ndeclaration, token.type == '=');
if (token.type == '=') {
expect(';');
end_error:
+ anonymous_entity = NULL;
rem_anchor_token(';');
rem_anchor_token(',');
}
function_parameter_t *last_parameter = NULL;
entity_t *parameter_declaration = entity->function.parameters.entities;
- for( ; parameter_declaration != NULL;
+ for (; parameter_declaration != NULL;
parameter_declaration = parameter_declaration->base.next) {
type_t *parameter_type = parameter_declaration->declaration.type;
if (parameter_type == NULL) {
scope_push(&function->parameters);
entity_t *parameter = function->parameters.entities;
- for( ; parameter != NULL; parameter = parameter->base.next) {
+ for (; parameter != NULL; parameter = parameter->base.next) {
if (parameter->base.parent_scope == &ndeclaration->function.parameters) {
parameter->base.parent_scope = current_scope;
}
long v = fold_constant(size);
if (v < 0) {
- errorf(source_position, "negative width in bit-field '%Y'",
- symbol);
+ errorf(source_position, "negative width in bit-field '%Y'", symbol);
} else if (v == 0) {
- errorf(source_position, "zero width for bit-field '%Y'",
- symbol);
+ errorf(source_position, "zero width for bit-field '%Y'", symbol);
} else if (bit_size > 0 && (il_size_t)v > bit_size) {
- errorf(source_position, "width of '%Y' exceeds its type",
- symbol);
+ errorf(source_position, "width of '%Y' exceeds its type", symbol);
} else {
type->bitfield.bit_size = v;
}
static entity_t *find_compound_entry(compound_t *compound, symbol_t *symbol)
{
entity_t *iter = compound->members.entities;
- for( ; iter != NULL; iter = iter->base.next) {
+ for (; iter != NULL; iter = iter->base.next) {
if (iter->kind != ENTITY_COMPOUND_MEMBER)
continue;
- if (iter->base.symbol == NULL) {
+ if (iter->base.symbol == symbol) {
+ return iter;
+ } else if (iter->base.symbol == NULL) {
type_t *type = skip_typeref(iter->declaration.type);
if (is_type_compound(type)) {
entity_t *result
}
continue;
}
-
- if (iter->base.symbol == symbol) {
- return iter;
- }
}
return NULL;
entity_t *prev = find_compound_entry(compound, symbol);
if (prev != NULL) {
- assert(prev->base.symbol == symbol);
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 != ',')
- break;
- next_token();
- }
- expect(';');
-
-end_error:
- ;
-}
-
-static void semantic_compound(compound_t *compound)
-{
- entity_t *entity = compound->members.entities;
- for ( ; entity != NULL; entity = entity->base.next) {
- assert(entity->kind == ENTITY_COMPOUND_MEMBER);
-
type_t *orig_type = entity->declaration.type;
type_t *type = skip_typeref(orig_type);
-
if (is_type_function(type)) {
- errorf(HERE,
- "compound member '%Y' must not have function type '%T'",
- entity->base.symbol, orig_type);
+ 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) && entity->base.next == NULL) {
+ /* §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(HERE,
- "compound member '%Y' has incomplete type '%T'",
- entity->base.symbol, orig_type);
+ errorf(&entity->base.source_position,
+ "compound member '%Y' has incomplete type '%T'",
+ entity->base.symbol, orig_type);
}
}
+
+ if (token.type != ',')
+ break;
+ next_token();
}
+ expect(';');
+
+end_error:
+ anonymous_entity = NULL;
}
static void parse_compound_type_entries(compound_t *compound)
parse_compound_declarators(compound, &specifiers);
}
- semantic_compound(compound);
rem_anchor_token('}');
next_token();
+
+ /* §6.7.2.1:7 */
+ compound->complete = true;
}
static type_t *parse_typename(void)
next_token();
designator_t *last_designator = result;
- while(true) {
+ while (true) {
if (token.type == '.') {
next_token();
if (token.type != T_IDENTIFIER) {
add_anchor_token(',');
if (token.type != ')') {
- while(true) {
+ while (true) {
(void)parse_assignment_expression();
if (token.type != ',')
break;
eat(kind == EXPR_SIZEOF ? T_sizeof : T___alignof__);
- char const* const what = kind == EXPR_SIZEOF ? "sizeof" : "alignof";
-
/* we only refer to a type property, mark this case */
bool old = in_type_prop;
in_type_prop = true;
type->kind == TYPE_BITFIELD ? "bitfield" :
NULL;
if (wrong_type != NULL) {
+ char const* const what = kind == EXPR_SIZEOF ? "sizeof" : "alignof";
errorf(&tp_expression->base.source_position,
"operand of %s expression must not be of %s type '%T'",
what, wrong_type, orig_type);
}
/* do default promotion */
- for( ; argument != NULL; argument = argument->next) {
+ for (; argument != NULL; argument = argument->next) {
type_t *type = argument->expression->base.type;
type = get_default_promoted_type(type);
assert(left != NULL);
left->base.source_position = source_position;
- while(true) {
+ while (true) {
if (token.type < 0) {
return expected_expression_error();
}
asm_clobber_t *result = NULL;
asm_clobber_t *last = NULL;
- while(token.type == T_STRING_LITERAL) {
+ while (token.type == T_STRING_LITERAL) {
asm_clobber_t *clobber = allocate_ast_zero(sizeof(clobber[0]));
clobber->clobber = parse_string_literals();
/* look over all statements again to produce no effect warnings */
if (warning.unused_value) {
statement_t *sub_statement = statement->compound.statements;
- for( ; sub_statement != NULL; sub_statement = sub_statement->base.next) {
+ for (; sub_statement != NULL; sub_statement = sub_statement->base.next) {
if (sub_statement->kind != STATEMENT_EXPRESSION)
continue;
/* don't emit a warning for the last expression in an expression
projects / cparser / blobdiff