static struct block *object_initializer(struct block *block, struct var target)
{
int i,
filled = target.offset;
const struct typetree *type = target.type;
assert(!is_tagged(type));
consume('{');
target.lvalue = 1;
switch (type->type) {
case T_UNION:
/* C89 states that only the first element of a union can be
* initialized. Zero the whole thing first if there is padding. */
if (size_of(get_member(type, 0)->type) < type->size) {
target.type =
(type->size % 8) ?
type_init(T_ARRAY, &basic_type__char, type->size) :
type_init(T_ARRAY, &basic_type__long, type->size / 8);
zero_initialize(block, target);
}
target.type = get_member(type, 0)->type;
block = initializer(block, target);
if (peek().token != '}') {
error("Excess elements in union initializer.");
exit(1);
}
break;
case T_STRUCT:
for (i = 0; i < nmembers(type); ++i) {
target.type = get_member(type, i)->type;
target.offset = filled + get_member(type, i)->offset;
block = initializer(block, target);
if (peek().token == ',') {
consume(',');
} else break;
if (peek().token == '}') {
break;
}
}
while (++i < nmembers(type)) {
target.type = get_member(type, i)->type;
target.offset = filled + get_member(type, i)->offset;
zero_initialize(block, target);
}
break;
case T_ARRAY:
target.type = type->next;
for (i = 0; !type->size || i < type->size / size_of(type->next); ++i) {
target.offset = filled + i * size_of(type->next);
block = initializer(block, target);
if (peek().token == ',') {
consume(',');
} else break;
if (peek().token == '}') {
break;
}
}
if (!type->size) {
assert(!target.symbol->type.size);
assert(is_array(&target.symbol->type));
/* Incomplete array type can only be in the root level of target
* type tree, overwrite type directly in symbol. */
((struct symbol *) target.symbol)->type.size =
(i + 1) * size_of(type->next);
} else {
while (++i < type->size / size_of(type->next)) {
target.offset = filled + i * size_of(type->next);
zero_initialize(block, target);
}
}
break;
default:
error("Block initializer only apply to aggregate or union type.");
exit(1);
}
consume('}');
return block;
}
static void member_declaration_list(struct typetree *type)
{
struct namespace ns = {0};
struct typetree *decl_base, *decl_type;
const char *name;
push_scope(&ns);
do {
decl_base = declaration_specifiers(NULL);
do {
name = NULL;
decl_type = declarator(decl_base, &name);
if (!name) {
error("Missing name in member declarator.");
exit(1);
} else if (!size_of(decl_type)) {
error("Field '%s' has incomplete type '%t'.", name, decl_type);
exit(1);
} else {
sym_add(&ns, name, decl_type, SYM_DECLARATION, LINK_NONE);
type_add_member(type, name, decl_type);
}
if (peek().token == ',') {
consume(',');
continue;
}
} while (peek().token != ';');
consume(';');
} while (peek().token != '}');
pop_scope(&ns);
}
static struct typetree *struct_or_union_declaration(void)
{
struct symbol *sym = NULL;
struct typetree *type = NULL;
enum type kind =
(next().token == STRUCT) ? T_STRUCT : T_UNION;
if (peek().token == IDENTIFIER) {
const char *name = consume(IDENTIFIER).strval;
sym = sym_lookup(&ns_tag, name);
if (!sym) {
type = type_init(kind);
sym = sym_add(&ns_tag, name, type, SYM_TYPEDEF, LINK_NONE);
} else if (is_integer(&sym->type)) {
error("Tag '%s' was previously declared as enum.", sym->name);
exit(1);
} else if (sym->type.type != kind) {
error("Tag '%s' was previously declared as %s.",
sym->name, (sym->type.type == T_STRUCT) ? "struct" : "union");
exit(1);
}
/* Retrieve type from existing symbol, possibly providing a complete
* definition that will be available for later declarations. Overwrites
* existing type information from symbol table. */
type = &sym->type;
if (peek().token == '{' && type->size) {
error("Redefiniton of '%s'.", sym->name);
exit(1);
}
}
if (peek().token == '{') {
if (!type) {
/* Anonymous structure; allocate a new standalone type,
* not part of any symbol. */
type = type_init(kind);
}
consume('{');
member_declaration_list(type);
assert(type->size);
consume('}');
}
/* Return to the caller a copy of the root node, which can be overwritten
* with new type qualifiers without altering the tag registration. */
return (sym) ? type_tagged_copy(&sym->type, sym->name) : type;
}
static void enumerator_list(void)
{
struct var val;
struct symbol *sym;
int enum_value = 0;
consume('{');
do {
const char *name = consume(IDENTIFIER).strval;
if (peek().token == '=') {
consume('=');
val = constant_expression();
if (!is_integer(val.type)) {
error("Implicit conversion from non-integer type in enum.");
}
enum_value = val.imm.i;
}
sym = sym_add(
&ns_ident,
name,
&basic_type__int,
SYM_ENUM_VALUE,
LINK_NONE);
sym->enum_value = enum_value++;
if (peek().token != ',')
break;
consume(',');
} while (peek().token != '}');
consume('}');
}
static struct typetree *enum_declaration(void)
{
struct typetree *type = type_init(T_SIGNED, 4);
consume(ENUM);
if (peek().token == IDENTIFIER) {
struct symbol *tag = NULL;
const char *name = consume(IDENTIFIER).strval;
tag = sym_lookup(&ns_tag, name);
if (!tag || tag->depth < ns_tag.current_depth) {
tag = sym_add(&ns_tag, name, type, SYM_TYPEDEF, LINK_NONE);
} else if (!is_integer(&tag->type)) {
error("Tag '%s' was previously defined as aggregate type.",
tag->name);
exit(1);
}
/* Use enum_value as a sentinel to represent definition, checked on
* lookup to detect duplicate definitions. */
if (peek().token == '{') {
if (tag->enum_value) {
error("Redefiniton of enum '%s'.", tag->name);
}
enumerator_list();
tag->enum_value = 1;
}
} else {
enumerator_list();
}
/* Result is always integer. Do not care about the actual enum definition,
* all enums are ints and no type checking is done. */
return type;
}
static struct typetree get_basic_type_from_specifier(unsigned short spec)
{
switch (spec) {
case 0x0001: /* void */
return basic_type__void;
case 0x0002: /* char */
case 0x0012: /* signed char */
return basic_type__char;
case 0x0022: /* unsigned char */
return basic_type__unsigned_char;
case 0x0004: /* short */
case 0x0014: /* signed short */
case 0x000C: /* short int */
case 0x001C: /* signed short int */
return basic_type__short;
case 0x0024: /* unsigned short */
case 0x002C: /* unsigned short int */
return basic_type__unsigned_short;
case 0x0008: /* int */
case 0x0010: /* signed */
case 0x0018: /* signed int */
return basic_type__int;
case 0x0020: /* unsigned */
case 0x0028: /* unsigned int */
return basic_type__unsigned_int;
case 0x0040: /* long */
case 0x0050: /* signed long */
case 0x0048: /* long int */
case 0x0058: /* signed long int */
case 0x00C0: /* long long */
case 0x00D0: /* signed long long */
case 0x00D8: /* signed long long int */
return basic_type__long;
case 0x0060: /* unsigned long */
case 0x0068: /* unsigned long int */
case 0x00E0: /* unsigned long long */
case 0x00E8: /* unsigned long long int */
return basic_type__unsigned_long;
case 0x0100: /* float */
return basic_type__float;
case 0x0200: /* double */
case 0x0240: /* long double */
return basic_type__double;
default:
error("Invalid type specification.");
exit(1);
}
}
/* Parse type, qualifiers and storage class. Do not assume int by default, but
* require at least one type specifier. Storage class is returned as token
* value, unless the provided pointer is NULL, in which case the input is parsed
* as specifier-qualifier-list.
*/
struct typetree *declaration_specifiers(int *stc)
{
struct typetree *type = NULL;
struct token tok;
int done = 0;
/* Use a compact bit representation to hold state about declaration
* specifiers. Initialize storage class to sentinel value. */
unsigned short spec = 0x0000;
enum qualifier qual = Q_NONE;
if (stc) *stc = '$';
#define set_specifier(d) \
if (spec & d) error("Duplicate type specifier '%s'.", tok.strval); \
next(); spec |= d;
#define set_qualifier(d) \
if (qual & d) error("Duplicate type qualifier '%s'.", tok.strval); \
next(); qual |= d;
#define set_storage_class(t) \
if (!stc) error("Unexpected storage class in qualifier list."); \
else if (*stc != '$') error("Multiple storage class specifiers."); \
next(); *stc = t;
do {
switch ((tok = peek()).token) {
case VOID: set_specifier(0x001); break;
case CHAR: set_specifier(0x002); break;
case SHORT: set_specifier(0x004); break;
case INT: set_specifier(0x008); break;
case SIGNED: set_specifier(0x010); break;
case UNSIGNED: set_specifier(0x020); break;
case LONG:
if (spec & 0x040) {
set_specifier(0x080);
} else {
set_specifier(0x040);
}
break;
case FLOAT: set_specifier(0x100); break;
case DOUBLE: set_specifier(0x200); break;
case CONST: set_qualifier(Q_CONST); break;
case VOLATILE: set_qualifier(Q_VOLATILE); break;
case IDENTIFIER: {
struct symbol *tag = sym_lookup(&ns_ident, tok.strval);
if (tag && tag->symtype == SYM_TYPEDEF && !type) {
consume(IDENTIFIER);
type = type_init(T_STRUCT);
*type = tag->type;
} else {
done = 1;
}
break;
}
case UNION:
case STRUCT:
if (!type) {
type = struct_or_union_declaration();
} else {
done = 1;
}
break;
case ENUM:
if (!type) {
type = enum_declaration();
} else {
done = 1;
}
break;
case AUTO:
case REGISTER:
case STATIC:
case EXTERN:
case TYPEDEF:
set_storage_class(tok.token);
break;
default:
done = 1;
break;
}
if (type && spec) {
error("Invalid combination of declaration specifiers.");
exit(1);
}
} while (!done);
#undef set_specifier
#undef set_qualifier
#undef set_storage_class
if (type) {
if (qual & type->qualifier) {
error("Duplicate type qualifier:%s%s.",
(qual & Q_CONST) ? " const" : "",
(qual & Q_VOLATILE) ? " volatile" : "");
}
} else if (spec) {
type = type_init(T_STRUCT);
*type = get_basic_type_from_specifier(spec);
} else {
error("Missing type specifier.");
exit(1);
}
type->qualifier |= qual;
return type;
}
/* Set var = 0, using simple assignment on members for composite types. This
* rule does not consume any input, but generates a series of assignments on the
* given variable. Point is to be able to zero initialize using normal simple
* assignment rules, although IR can become verbose for large structures.
*/
static void zero_initialize(struct block *block, struct var target)
{
int i;
struct var var;
assert(target.kind == DIRECT);
switch (target.type->type) {
case T_STRUCT:
case T_UNION:
target.type = unwrapped(target.type);
var = target;
for (i = 0; i < nmembers(var.type); ++i) {
target.type = get_member(var.type, i)->type;
target.offset = var.offset + get_member(var.type, i)->offset;
zero_initialize(block, target);
}
break;
case T_ARRAY:
assert(target.type->size);
var = target;
target.type = target.type->next;
assert(is_struct(target.type) || !target.type->next);
for (i = 0; i < var.type->size / var.type->next->size; ++i) {
target.offset = var.offset + i * var.type->next->size;
zero_initialize(block, target);
}
break;
case T_POINTER:
var = var_zero(8);
var.type = type_init(T_POINTER, &basic_type__void);
eval_assign(block, target, var);
break;
case T_UNSIGNED:
case T_SIGNED:
var = var_zero(target.type->size);
eval_assign(block, target, var);
break;
default:
error("Invalid type to zero-initialize, was '%t'.", target.type);
exit(1);
}
}
void operator()(Aggregate_value& v) { zero_initialize(v); };
void operator()(Float_value& v) { zero_initialize(v); };
void operator()(Integer_value& v) { zero_initialize(v); };
// Recursively zero initialize the aggregate.
void
zero_initialize(Aggregate_value& v)
{
for (std::size_t i = 0; i < v.len; ++i)
zero_initialize(v.data[i]);
}
