{
static const size_t sizes[] = {
[TYPE_ATOMIC] = sizeof(atomic_type_t),
+ [TYPE_BITFIELD] = sizeof(bitfield_type_t),
[TYPE_COMPOUND_STRUCT] = sizeof(compound_type_t),
[TYPE_COMPOUND_UNION] = sizeof(compound_type_t),
[TYPE_ENUM] = sizeof(enum_type_t),
}
}
-/**
- * Called when we find a 2nd declarator for an identifier we already have a
- * declarator for.
- */
-static bool is_compatible_declaration(declaration_t *declaration,
- declaration_t *previous)
-{
- /* happens for K&R style function parameters */
- if(previous->type == NULL) {
- previous->type = declaration->type;
- return true;
- }
-
- type_t *type1 = skip_typeref(declaration->type);
- type_t *type2 = skip_typeref(previous->type);
-
- return types_compatible(type1, type2);
-}
-
/**
* Search a symbol in a given namespace and returns its declaration or
* NULL if this symbol was not found.
*/
-static declaration_t *get_declaration(symbol_t *symbol, namespace_t namespc)
+static declaration_t *get_declaration(const symbol_t *const symbol, const namespace_t namespc)
{
declaration_t *declaration = symbol->declaration;
for( ; declaration != NULL; declaration = declaration->symbol_next) {
return NULL;
}
-/**
- * Return the "prefix" of a given namespace.
- */
-static const char *get_namespace_prefix(namespace_t namespc)
-{
- switch(namespc) {
- case NAMESPACE_NORMAL:
- return "";
- case NAMESPACE_UNION:
- return "union ";
- case NAMESPACE_STRUCT:
- return "struct ";
- case NAMESPACE_ENUM:
- return "enum ";
- case NAMESPACE_LABEL:
- return "label ";
- }
- panic("invalid namespace found");
-}
-
/**
* pushs an environment_entry on the environment stack and links the
* corresponding symbol to the new entry
*/
-static declaration_t *stack_push(stack_entry_t **stack_ptr,
- declaration_t *declaration,
- context_t *parent_context)
+static void stack_push(stack_entry_t **stack_ptr, declaration_t *declaration)
{
symbol_t *symbol = declaration->symbol;
namespace_t namespc = (namespace_t)declaration->namespc;
- /* a declaration should be only pushed once */
- declaration->parent_context = parent_context;
-
- declaration_t *previous_declaration = get_declaration(symbol, namespc);
- assert(declaration != previous_declaration);
- if(previous_declaration != NULL
- && previous_declaration->parent_context == context) {
- if(!is_compatible_declaration(declaration, previous_declaration)) {
- errorf(declaration->source_position, "definition of symbol '%s%s' with type '%T'", get_namespace_prefix(namespc), symbol->string, declaration->type);
- errorf(previous_declaration->source_position, "is incompatible with previous declaration of type '%T'", previous_declaration->type);
- } else {
- unsigned old_storage_class = previous_declaration->storage_class;
- unsigned new_storage_class = declaration->storage_class;
- type_t *type = previous_declaration->type;
- type = skip_typeref(type);
-
- if (current_function == NULL) {
- if (old_storage_class != STORAGE_CLASS_STATIC &&
- new_storage_class == STORAGE_CLASS_STATIC) {
- errorf(declaration->source_position, "static declaration of '%s' follows non-static declaration", symbol->string);
- errorf(previous_declaration->source_position, "previous declaration of '%s' was here\n", symbol->string);
- } else {
- if (old_storage_class == STORAGE_CLASS_EXTERN) {
- if (new_storage_class == STORAGE_CLASS_NONE) {
- previous_declaration->storage_class = STORAGE_CLASS_NONE;
- }
- } else if(!is_type_function(type)) {
- warningf(declaration->source_position, "redundant declaration for '%s'\n", symbol->string);
- warningf(previous_declaration->source_position, "previous declaration of '%s' was here\n", symbol->string);
- }
- }
- } else {
- if (old_storage_class == STORAGE_CLASS_EXTERN &&
- new_storage_class == STORAGE_CLASS_EXTERN) {
- warningf(declaration->source_position, "redundant extern declaration for '%s'\n", symbol->string);
- warningf(previous_declaration->source_position, "previous declaration of '%s' was here\n", symbol->string);
- } else {
- if (old_storage_class == new_storage_class) {
- errorf(declaration->source_position, "redeclaration of '%s'\n", symbol->string);
- } else {
- errorf(declaration->source_position, "redeclaration of '%s' with different linkage\n", symbol->string);
- }
- errorf(previous_declaration->source_position, "previous declaration of '%s' was here", symbol->string);
- }
- }
- }
- return previous_declaration;
- }
-
/* remember old declaration */
stack_entry_t entry;
entry.symbol = symbol;
iter_last->symbol_next = declaration;
}
}
-
- return declaration;
}
-static declaration_t *environment_push(declaration_t *declaration)
+static void environment_push(declaration_t *declaration)
{
assert(declaration->source_position.input_name != NULL);
- return stack_push(&environment_stack, declaration, context);
+ assert(declaration->parent_context != NULL);
+ stack_push(&environment_stack, declaration);
}
-static declaration_t *label_push(declaration_t *declaration)
+static void label_push(declaration_t *declaration)
{
- return stack_push(&label_stack, declaration, ¤t_function->context);
+ declaration->parent_context = ¤t_function->context;
+ stack_push(&label_stack, declaration);
}
/**
static type_t *promote_integer(type_t *type)
{
+ if(type->kind == TYPE_BITFIELD)
+ return promote_integer(type->bitfield.base);
+
if(get_rank(type) < ATOMIC_TYPE_INT)
type = type_int;
switch (dest_type->kind) {
case TYPE_ENUM:
/* TODO warning for implicitly converting to enum */
+ case TYPE_BITFIELD:
case TYPE_ATOMIC:
if (source_type->kind != TYPE_ATOMIC &&
- source_type->kind != TYPE_ENUM) {
+ source_type->kind != TYPE_ENUM &&
+ source_type->kind != TYPE_BITFIELD) {
panic("casting of non-atomic types not implemented yet");
}
/* ยง 6.7.8.14/15 char array may be initialized by string literals */
type_t *const expr_type = expression->base.datatype;
if (is_type_array(type) && expr_type->kind == TYPE_POINTER) {
- array_type_t *const array_type = &type->array;
- type_t *const element_type = skip_typeref(array_type->element_type);
+ array_type_t *const array_type = &type->array;
+ type_t *const element_type = skip_typeref(array_type->element_type);
if (element_type->kind == TYPE_ATOMIC) {
switch (expression->kind) {
}
}
- default: break;
+ default:
+ break;
}
}
}
static bool had_initializer_brace_warning;
+static void skip_designator(void)
+{
+ while(1) {
+ if(token.type == '.') {
+ next_token();
+ if(token.type == T_IDENTIFIER)
+ next_token();
+ } else if(token.type == '[') {
+ next_token();
+ parse_constant_expression();
+ if(token.type == ']')
+ next_token();
+ } else {
+ break;
+ }
+ }
+}
+
static initializer_t *parse_sub_initializer(type_t *type,
expression_t *expression,
type_t *expression_type)
type_t *element_type = array_type->element_type;
element_type = skip_typeref(element_type);
+ if(token.type == '.') {
+ errorf(HERE,
+ "compound designator in initializer for array type '%T'",
+ type);
+ skip_designator();
+ }
+
initializer_t *sub;
had_initializer_brace_warning = false;
if(expression == NULL) {
compound_type_t *compound_type = &type->compound;
context_t *context = &compound_type->declaration->context;
+ if(token.type == '[') {
+ errorf(HERE,
+ "array designator in initializer for compound type '%T'",
+ type);
+ skip_designator();
+ }
+
declaration_t *first = context->declarations;
if(first == NULL)
return NULL;
if(token.type == '{') {
if(declaration->init.is_defined) {
assert(symbol != NULL);
- errorf(HERE, "multiple definition of %s %s", is_struct ? "struct" : "union", symbol->string);
+ errorf(HERE, "multiple definition of '%s %Y'",
+ is_struct ? "struct" : "union", symbol);
declaration->context.declarations = NULL;
}
declaration->init.is_defined = true;
if(token.type == '{') {
if(declaration->init.is_defined) {
- errorf(HERE, "multiple definitions of enum %s", symbol->string);
+ errorf(HERE, "multiple definitions of enum %Y", symbol);
}
record_declaration(declaration);
declaration->init.is_defined = 1;
}
if(is_type_incomplete(type)) {
- errorf(HERE, "incomplete type ('%T') not allowed for parameter '%s'", orig_type, declaration->symbol->string);
+ errorf(HERE, "incomplete type ('%T') not allowed for parameter '%Y'",
+ orig_type, declaration->symbol);
}
}
type_t *type = specifiers->type;
declaration_t *declaration = allocate_ast_zero(sizeof(declaration[0]));
declaration->storage_class = specifiers->storage_class;
- declaration->decl_modifiers = specifiers->decl_modifiers;
+ declaration->modifiers = specifiers->decl_modifiers;
declaration->is_inline = specifiers->is_inline;
construct_type_t *construct_type
return result;
}
-static declaration_t *record_declaration(declaration_t *declaration)
+static declaration_t *append_declaration(declaration_t* const declaration)
{
- assert(declaration->parent_context == NULL);
- assert(context != NULL);
-
- symbol_t *symbol = declaration->symbol;
- if(symbol != NULL) {
- declaration_t *alias = environment_push(declaration);
- if(alias != declaration)
- return alias;
- } else {
- declaration->parent_context = context;
- }
-
- if(last_declaration != NULL) {
+ if (last_declaration != NULL) {
last_declaration->next = declaration;
} else {
context->declarations = declaration;
}
last_declaration = declaration;
-
return declaration;
}
+static declaration_t *internal_record_declaration(
+ declaration_t *const declaration,
+ const bool is_function_definition)
+{
+ const symbol_t *const symbol = declaration->symbol;
+ const namespace_t namespc = (namespace_t)declaration->namespc;
+
+ const type_t *const type = skip_typeref(declaration->type);
+ if (is_type_function(type) && type->function.unspecified_parameters) {
+ warningf(declaration->source_position,
+ "function declaration '%#T' is not a prototype",
+ type, declaration->symbol);
+ }
+
+ declaration_t *const previous_declaration = get_declaration(symbol, namespc);
+ assert(declaration != previous_declaration);
+ if (previous_declaration != NULL
+ && previous_declaration->parent_context == context) {
+ const type_t *const prev_type = skip_typeref(previous_declaration->type);
+ if (!types_compatible(type, prev_type)) {
+ errorf(declaration->source_position,
+ "declaration '%#T' is incompatible with previous declaration '%#T'",
+ type, symbol, previous_declaration->type, symbol);
+ errorf(previous_declaration->source_position, "previous declaration of '%Y' was here", symbol);
+ } else {
+ unsigned old_storage_class = previous_declaration->storage_class;
+ unsigned new_storage_class = declaration->storage_class;
+
+ /* pretend no storage class means extern for function declarations
+ * (except if the previous declaration is neither none nor extern) */
+ if (is_type_function(type)) {
+ switch (old_storage_class) {
+ case STORAGE_CLASS_NONE:
+ old_storage_class = STORAGE_CLASS_EXTERN;
+
+ case STORAGE_CLASS_EXTERN:
+ if (new_storage_class == STORAGE_CLASS_NONE && !is_function_definition) {
+ new_storage_class = STORAGE_CLASS_EXTERN;
+ }
+ break;
+
+ default: break;
+ }
+ }
+
+ if (old_storage_class == STORAGE_CLASS_EXTERN &&
+ new_storage_class == STORAGE_CLASS_EXTERN) {
+warn_redundant_declaration:
+ warningf(declaration->source_position, "redundant declaration for '%Y'", symbol);
+ warningf(previous_declaration->source_position, "previous declaration of '%Y' was here", symbol);
+ } else if (current_function == NULL) {
+ if (old_storage_class != STORAGE_CLASS_STATIC &&
+ new_storage_class == STORAGE_CLASS_STATIC) {
+ errorf(declaration->source_position, "static declaration of '%Y' follows non-static declaration", symbol);
+ errorf(previous_declaration->source_position, "previous declaration of '%Y' was here", symbol);
+ } else {
+ if (old_storage_class != STORAGE_CLASS_EXTERN) {
+ goto warn_redundant_declaration;
+ }
+ if (new_storage_class == STORAGE_CLASS_NONE) {
+ previous_declaration->storage_class = STORAGE_CLASS_NONE;
+ }
+ }
+ } else {
+ if (old_storage_class == new_storage_class) {
+ errorf(declaration->source_position, "redeclaration of '%Y'", symbol);
+ } else {
+ errorf(declaration->source_position, "redeclaration of '%Y' with different linkage", symbol);
+ }
+ errorf(previous_declaration->source_position, "previous declaration of '%Y' was here", symbol);
+ }
+ }
+ return previous_declaration;
+ }
+
+ assert(declaration->parent_context == NULL);
+ assert(declaration->symbol != NULL);
+ assert(context != NULL);
+
+ declaration->parent_context = context;
+
+ environment_push(declaration);
+ return append_declaration(declaration);
+}
+
+static declaration_t *record_declaration(declaration_t *declaration)
+{
+ return internal_record_declaration(declaration, false);
+}
+
+static declaration_t *record_function_definition(declaration_t *const declaration)
+{
+ return internal_record_declaration(declaration, true);
+}
+
static void parser_error_multiple_definition(declaration_t *declaration,
const source_position_t source_position)
{
- errorf(source_position, "multiple definition of symbol '%s'", declaration->symbol->string);
- errorf(declaration->source_position, "this is the location of the previous definition.");
+ errorf(source_position, "multiple definition of symbol '%Y'",
+ declaration->symbol);
+ errorf(declaration->source_position,
+ "this is the location of the previous definition.");
}
static bool is_declaration_specifier(const token_t *token,
}
if(type != NULL && is_type_function(type)) {
- errorf(declaration->source_position, "initializers not allowed for function types at declator '%s' (type '%T')", declaration->symbol->string, orig_type);
+ errorf(declaration->source_position,
+ "initializers not allowed for function types at declator '%Y' (type '%T')",
+ declaration->symbol, orig_type);
} else {
declaration->init.initializer = initializer;
}
type_t *type = skip_typeref(orig_type);
if(type->kind != TYPE_FUNCTION && declaration->is_inline) {
- warningf(declaration->source_position, "variable '%s' declared 'inline'\n", declaration->symbol->string);
+ warningf(declaration->source_position,
+ "variable '%Y' declared 'inline'\n", declaration->symbol);
}
if(token.type == '=') {
declaration_t *parameter = declaration->context.declarations;
for( ; parameter != NULL; parameter = parameter->next) {
+ assert(parameter->parent_context == NULL);
+ parameter->parent_context = context;
environment_push(parameter);
}
type_t *parameter_type = parameter_declaration->type;
if(parameter_type == NULL) {
if (strict_mode) {
- errorf(HERE, "no type specified for function parameter '%s'", parameter_declaration->symbol->string);
+ errorf(HERE, "no type specified for function parameter '%Y'",
+ parameter_declaration->symbol);
} else {
- warningf(HERE, "no type specified for function parameter '%s', using int", parameter_declaration->symbol->string);
+ warningf(HERE, "no type specified for function parameter '%Y', using int",
+ parameter_declaration->symbol);
parameter_type = type_int;
parameter_declaration->type = parameter_type;
}
/* must be a declaration */
if(token.type == ';') {
- parse_anonymous_declaration_rest(&specifiers, record_declaration);
+ parse_anonymous_declaration_rest(&specifiers, append_declaration);
return;
}
ndeclaration->type = type;
}
- declaration_t *declaration = record_declaration(ndeclaration);
+ declaration_t *const declaration = record_function_definition(ndeclaration);
if(ndeclaration != declaration) {
- memcpy(&declaration->context, &ndeclaration->context,
- sizeof(declaration->context));
+ declaration->context = ndeclaration->context;
}
type = skip_typeref(declaration->type);
declaration_t *parameter = declaration->context.declarations;
for( ; parameter != NULL; parameter = parameter->next) {
+ assert(parameter->parent_context == NULL || parameter->parent_context == context);
+ parameter->parent_context = context;
environment_push(parameter);
}
environment_pop_to(top);
}
+static type_t *make_bitfield_type(type_t *base, expression_t *size)
+{
+ type_t *type = allocate_type_zero(TYPE_BITFIELD);
+ type->bitfield.base = base;
+ type->bitfield.size = size;
+
+ return type;
+}
+
static void parse_struct_declarators(const declaration_specifiers_t *specifiers)
{
+ /* TODO: check constraints for struct declarations (in specifiers) */
while(1) {
+ declaration_t *declaration;
+
if(token.type == ':') {
next_token();
- parse_constant_expression();
- /* TODO (bitfields) */
- } else {
- declaration_t *declaration = parse_declarator(specifiers, /*may_be_abstract=*/true);
- /* TODO: check constraints for struct declarations */
- /* TODO: check for doubled fields */
+ type_t *base_type = specifiers->type;
+ expression_t *size = parse_constant_expression();
+
+ type_t *type = make_bitfield_type(base_type, size);
+
+ declaration = allocate_ast_zero(sizeof(declaration[0]));
+
+ declaration->namespc = NAMESPACE_NORMAL;
+ declaration->storage_class = STORAGE_CLASS_NONE;
+ declaration->source_position = token.source_position;
+ declaration->modifiers = specifiers->decl_modifiers;
+ declaration->type = type;
+
record_declaration(declaration);
+ } else {
+ declaration = parse_declarator(specifiers,/*may_be_abstract=*/true);
if(token.type == ':') {
next_token();
- parse_constant_expression();
- /* TODO (bitfields) */
+ expression_t *size = parse_constant_expression();
+
+ type_t *type = make_bitfield_type(declaration->type, size);
+ declaration->type = type;
}
}
+ record_declaration(declaration);
if(token.type != ',')
break;
declaration->type = type;
declaration->symbol = symbol;
declaration->source_position = source_position;
-
- /* prepend the implicit definition to the global context
- * this is safe since the symbol wasn't declared as anything else yet
- */
- assert(symbol->declaration == NULL);
-
- context_t *last_context = context;
- context = global_context;
+ declaration->parent_context = global_context;
environment_push(declaration);
declaration->next = context->declarations;
context->declarations = declaration;
- context = last_context;
-
return declaration;
}
if(declaration == NULL) {
if (! strict_mode && token.type == '(') {
/* an implicitly defined function */
- warningf(HERE, "implicit declaration of function '%s'\n", ref->symbol->string);
+ warningf(HERE, "implicit declaration of function '%Y'",
+ ref->symbol);
declaration = create_implicit_function(ref->symbol,
source_position);
} else {
- errorf(HERE, "unknown symbol '%s' found.\n", ref->symbol->string);
+ errorf(HERE, "unknown symbol '%Y' found.", ref->symbol);
return expression;
}
}
- type_t *type = declaration->type;
+ type_t *type = declaration->type;
+
/* we always do the auto-type conversions; the & and sizeof parser contains
* code to revert this! */
type = automatic_type_conversion(type);
return parse_int_const();
case T_FLOATINGPOINT:
return parse_float_const();
- case T_STRING_LITERAL: /* TODO merge */
+ case T_STRING_LITERAL:
return parse_string_const();
case T_WIDE_STRING_LITERAL:
return parse_wide_string_const();
if(type_left->kind != TYPE_COMPOUND_STRUCT
&& type_left->kind != TYPE_COMPOUND_UNION) {
- errorf(HERE, "request for member '%s' in something not a struct or union, but '%T'", symbol->string, type_left);
+ errorf(HERE, "request for member '%Y' in something not a struct or "
+ "union, but '%T'", symbol, type_left);
return create_invalid_expression();
}
declaration_t *declaration = compound_type->declaration;
if(!declaration->init.is_defined) {
- errorf(HERE, "request for member '%s' of incomplete type '%T'", symbol->string, type_left);
+ errorf(HERE, "request for member '%Y' of incomplete type '%T'",
+ symbol, type_left);
return create_invalid_expression();
}
}
}
if(iter == NULL) {
- errorf(HERE, "'%T' has no member names '%s'", type_left, symbol->string);
+ errorf(HERE, "'%T' has no member named '%Y'", orig_type, symbol);
return create_invalid_expression();
}
select->select.compound_entry = iter;
select->base.datatype = expression_type;
+
+ if(expression_type->kind == TYPE_BITFIELD) {
+ expression_t *extract
+ = allocate_expression_zero(EXPR_UNARY_BITFIELD_EXTRACT);
+ extract->unary.value = select;
+ extract->base.datatype = expression_type->bitfield.base;
+
+ return extract;
+ }
+
return select;
}
(void) precedence;
expression_t *result = allocate_expression_zero(EXPR_CALL);
- call_expression_t *call = &result->call;
- call->function = expression;
+ call_expression_t *call = &result->call;
+ call->function = expression;
function_type_t *function_type = NULL;
type_t *orig_type = expression->base.datatype;
const declaration_t *declaration = context->declarations;
for (; declaration != NULL; declaration = declaration->next) {
+ if (declaration->namespc != NAMESPACE_NORMAL)
+ continue;
+
const type_t *decl_type = skip_typeref(declaration->type);
if (decl_type->base.qualifiers & TYPE_QUALIFIER_CONST)
return true;
return;
}
if(type_left->base.qualifiers & TYPE_QUALIFIER_CONST) {
- errorf(HERE, "assignment to readonly location '%E' (type '%T')", left, orig_type_left);
+ errorf(HERE, "assignment to readonly location '%E' (type '%T')", left,
+ orig_type_left);
return;
}
if(is_type_incomplete(type_left)) {
- errorf(HERE, "left-hand side of assignment '%E' has incomplete type '%T'", left, orig_type_left);
+ errorf(HERE,
+ "left-hand side of assignment '%E' has incomplete type '%T'",
+ left, orig_type_left);
return;
}
if(is_type_compound(type_left) && has_const_fields(&type_left->compound)) {
- errorf(HERE, "cannot assign to '%E' because compound type '%T' has readonly fields", left, orig_type_left);
+ errorf(HERE, "cannot assign to '%E' because compound type '%T' has readonly fields",
+ left, orig_type_left);
return;
}
/* if source position is already set then the label is defined twice,
* otherwise it was just mentioned in a goto so far */
if(label->source_position.input_name != NULL) {
- errorf(HERE, "duplicate label '%s'\n", symbol->string);
- errorf(label->source_position, "previous definition of '%s' was here\n", symbol->string);
+ errorf(HERE, "duplicate label '%Y'", symbol);
+ errorf(label->source_position, "previous definition of '%Y' was here",
+ symbol);
} else {
label->source_position = token.source_position;
}
label_statement->statement.source_position = token.source_position;
label_statement->label = label;
- expect(':');
+ eat(':');
if(token.type == '}') {
/* TODO only warn? */
initialize_builtin_types();
while(token.type != T_EOF) {
- parse_external_declaration();
+ if (token.type == ';') {
+ /* TODO error in strict mode */
+ warningf(HERE, "stray ';' outside of function");
+ next_token();
+ } else {
+ parse_external_declaration();
+ }
}
assert(context == &unit->context);