+ return result;
+ }
+
+ return NULL;
+}
+
+static initializer_t *parse_sub_initializer(type_t *type,
+ expression_t *expression,
+ type_t *expression_type);
+
+static initializer_t *parse_sub_initializer_elem(type_t *type)
+{
+ if(token.type == '{') {
+ return parse_sub_initializer(type, NULL, NULL);
+ }
+
+ expression_t *expression = parse_assignment_expression();
+ type_t *expression_type = skip_typeref(expression->base.datatype);
+
+ return parse_sub_initializer(type, expression, expression_type);
+}
+
+static bool had_initializer_brace_warning;
+
+static initializer_t *parse_sub_initializer(type_t *type,
+ expression_t *expression,
+ type_t *expression_type)
+{
+ if(is_type_scalar(type)) {
+ /* there might be extra {} hierarchies */
+ if(token.type == '{') {
+ next_token();
+ if(!had_initializer_brace_warning) {
+ warningf(HERE, "braces around scalar initializer");
+ had_initializer_brace_warning = true;
+ }
+ initializer_t *result = parse_sub_initializer(type, NULL, NULL);
+ if(token.type == ',') {
+ next_token();
+ /* TODO: warn about excessive elements */
+ }
+ expect_block('}');
+ return result;
+ }
+
+ if(expression == NULL) {
+ expression = parse_assignment_expression();
+ }
+ return initializer_from_expression(type, expression);
+ }
+
+ /* does the expression match the currently looked at object to initialize */
+ if(expression != NULL) {
+ initializer_t *result = initializer_from_expression(type, expression);
+ if(result != NULL)
+ return result;
+ }
+
+ bool read_paren = false;
+ if(token.type == '{') {
+ next_token();
+ read_paren = true;
+ }
+
+ /* descend into subtype */
+ initializer_t *result = NULL;
+ initializer_t **elems;
+ if(is_type_array(type)) {
+ array_type_t *array_type = &type->array;
+ type_t *element_type = array_type->element_type;
+ element_type = skip_typeref(element_type);
+
+ initializer_t *sub;
+ had_initializer_brace_warning = false;
+ if(expression == NULL) {
+ sub = parse_sub_initializer_elem(element_type);
+ } else {
+ sub = parse_sub_initializer(element_type, expression,
+ expression_type);
+ }
+
+ /* didn't match the subtypes -> try the parent type */
+ if(sub == NULL) {
+ assert(!read_paren);
+ return NULL;
+ }
+
+ elems = NEW_ARR_F(initializer_t*, 0);
+ ARR_APP1(initializer_t*, elems, sub);
+
+ while(true) {
+ if(token.type == '}')
+ break;
+ expect_block(',');
+ if(token.type == '}')
+ break;
+
+ sub = parse_sub_initializer_elem(element_type);
+ if(sub == NULL) {
+ /* TODO error, do nicer cleanup */
+ errorf(HERE, "member initializer didn't match");
+ DEL_ARR_F(elems);
+ return NULL;
+ }
+ ARR_APP1(initializer_t*, elems, sub);
+ }
+ } else {
+ assert(is_type_compound(type));
+ compound_type_t *compound_type = &type->compound;
+ context_t *context = &compound_type->declaration->context;
+
+ declaration_t *first = context->declarations;
+ if(first == NULL)
+ return NULL;
+ type_t *first_type = first->type;
+ first_type = skip_typeref(first_type);
+
+ initializer_t *sub;
+ had_initializer_brace_warning = false;
+ if(expression == NULL) {
+ sub = parse_sub_initializer_elem(first_type);
+ } else {
+ sub = parse_sub_initializer(first_type, expression,expression_type);
+ }
+
+ /* didn't match the subtypes -> try our parent type */
+ if(sub == NULL) {
+ assert(!read_paren);
+ return NULL;
+ }
+
+ elems = NEW_ARR_F(initializer_t*, 0);
+ ARR_APP1(initializer_t*, elems, sub);
+
+ declaration_t *iter = first->next;
+ for( ; iter != NULL; iter = iter->next) {
+ if(iter->symbol == NULL)
+ continue;
+ if(iter->namespc != NAMESPACE_NORMAL)
+ continue;
+
+ if(token.type == '}')
+ break;
+ expect_block(',');
+ if(token.type == '}')
+ break;
+
+ type_t *iter_type = iter->type;
+ iter_type = skip_typeref(iter_type);
+
+ sub = parse_sub_initializer_elem(iter_type);
+ if(sub == NULL) {
+ /* TODO error, do nicer cleanup */
+ errorf(HERE, "member initializer didn't match");
+ DEL_ARR_F(elems);
+ return NULL;
+ }
+ ARR_APP1(initializer_t*, elems, sub);
+ }
+ }
+
+ int len = ARR_LEN(elems);
+ size_t elems_size = sizeof(initializer_t*) * len;
+
+ initializer_list_t *init = allocate_ast_zero(sizeof(init[0]) + elems_size);
+
+ init->initializer.kind = INITIALIZER_LIST;
+ init->len = len;
+ memcpy(init->initializers, elems, elems_size);
+ DEL_ARR_F(elems);
+
+ result = (initializer_t*) init;
+
+ if(read_paren) {
+ if(token.type == ',')
+ next_token();
+ expect('}');
+ }
+ return result;
+}
+
+static initializer_t *parse_initializer(type_t *type)
+{
+ initializer_t *result;
+
+ type = skip_typeref(type);
+
+ if(token.type != '{') {
+ expression_t *expression = parse_assignment_expression();
+ initializer_t *initializer = initializer_from_expression(type, expression);
+ if(initializer == NULL) {
+ errorf(HERE, "initializer expression '%E', type '%T' is incompatible with type '%T'", expression, expression->base.datatype, type);
+ }
+ return initializer;
+ }
+
+ if(is_type_scalar(type)) {
+ /* § 6.7.8.11 */
+ eat('{');
+
+ expression_t *expression = parse_assignment_expression();
+ result = initializer_from_expression(type, expression);
+
+ if(token.type == ',')
+ next_token();
+
+ expect('}');
+ return result;
+ } else {
+ result = parse_sub_initializer(type, NULL, NULL);