 @@ -1,54 +1,54 @@
-/*	$NetBSD: d_c99_init.c,v 1.23 2021/03/29 22:42:10 rillig Exp $	*/
+/*	$NetBSD: d_c99_init.c,v 1.24 2021/03/30 14:25:28 rillig Exp $	*/
 # 3 "d_c99_init.c"
 /*
  * Test C99 initializers.
+ *
  * See C99 6.7.8 "Initialization".
 */
 void use(const void *);
 typedef struct any {
 	const void *value;
 } any;
 // C99 6.7.8p11 says "optionally enclosed in braces".  There is no limitation
 // on the number of brace pairs.
 int scalar_without_braces = 3;
 int scalar_with_optional_braces = { 3 };
 int scalar_with_too_many_braces = {{ 3 }};
 int scalar_with_too_many_initializers = { 3, 5 };	/* expect: 174 */
-// See init_using_expr, 'handing over to ASSIGN'.
+// See init_expr, 'handing over to ASSIGN'.
 void
 struct_initialization_via_assignment(any arg)
+{
 	any local = arg;
 	use(&local);
+}
-// See init_using_expr, initstack_string.
+// See init_expr, initialization_init_array_using_string.
 char static_duration[] = "static duration";
 signed char static_duration_signed[] = "static duration";
 unsigned char static_duration_unsigned[] = "static duration";
 int static_duration_wchar[] = L"static duration";
-// See init_using_expr.
+// See init_expr.
 void
 initialization_by_braced_string(void)
+{
 	any local = { "hello" };
 	use(&local);
+}
 void
 initialization_by_redundantly_braced_string(void)
+{
 	any local = {{{{ "hello" }}}};
 	use(&local);
+}
 @@ -70,27 +70,27 @@ initialization_with_too_many_braces(any
 int number = 12345;
 int number_with_braces_and_comma = {
 ,
 };
 int array_with_fixed_size[3] = {
 ,
 ,
 ,
 ,			/* expect: too many array initializers */
 };
-// See initstack_push, 'extending array of unknown size'.
+// See initialization_set_set_of_unknown_array.
 int array_of_unknown_size[] = {
 ,
 ,
 ,
 };
 int array_flat[2][2] = {
 ,
 ,
 ,
 };
 @@ -125,28 +125,28 @@ struct point {
 struct point point = {
 ,
 };
 struct point point_with_designators = {
 	.y = 4,
 	.x = 3,
 };
 struct point point_with_mixed_designators = {
 	.x = 3,
 ,
-	// FIXME: assertion failure '== ARRAY'
+	/* TODO: remove me */
-	// 5,
+,			/* expect: too many struct/union initializers */
 	.x = 3,
 };
 int array_with_designator[] = {
 ,
 	.member = 222,		/* expect: 249 */
 ,
 };
 /*
  * C99 6.7.8p11 says that the initializer of a scalar can be "optionally
  * enclosed in braces".  It does not explicitly set an upper limit on the
  * number of braces.  It also doesn't restrict the term "initializer" to only
 @@ -201,56 +201,56 @@ struct pentagon {
 };
 struct geometry {
 	struct pentagon pentagons[6];
 	struct triangle triangles[10];
 	struct point points[3][5][2];
 };
 /*
  * Initialization of a complex struct containing nested arrays and nested
  * structs.
  */
 struct geometry geometry = {
-	// FIXME: assertion "istk->i_type != NULL" failed in initstack_push
+	/* TODO: remove me */
-	//.pentagons[0].points[4].x = 1,
+	.pentagons[0].points[4].x = 1,
 	.points[0][0][0] = { 0, 0 },
 	.points[2][4][1] = {301, 302 },
 	/* TODO: expect+1: array index 3 must be between 0 and 2 */
 	.points[3][0][0] = {3001, 3002 },
 	/* TODO: expect+1: array index 5 must be between 0 and 4 */
 	.points[0][5][0] = {501, 502 },
 	/* TODO: expect+1: array index 2 must be between 0 and 1 */
 	.points[0][0][2] = {21, 22 },
 };
 struct ends_with_unnamed_bit_field {
 	int member;
 	int : 0;
 } ends_with_unnamed_bit_field = {
 ,
 	/* expect+1: too many struct/union initializers */
 ,
 };
 char prefixed_message[] = {
 	'E', ':', ' ',
 	/* expect+1: illegal combination of integer (char) and pointer */
 	"message\n",
 };
 char message_with_suffix[] = {
-	"message",
+	"message",		/* expect: illegal combination */
-	/* expect+1: too many array initializers */
+	/* */
 	'\n',
 };
 struct ten {
 	int i0;
 	int i1;
 	int i2;
 	int i3;
 	int i4;
 	int i5;
 	int i6;
 	int i7;
 	int i8;
 @@ -269,27 +269,27 @@ int c99_6_7_8_p26_example3[4][3] = {
 	{ 1, 3, 5 },
 	{ 2, 4, 6 },
 	{ 3, 5, 7 },
 };
 int c99_6_7_8_p27_example4[4][3] = {
 	{ 1 }, { 2 }, { 3 }, { 4 }
 };
 struct {
 	int a[3], b;
 } c99_6_7_8_p28_example5[] = {
 	{ 1 },
-,
+,			/* XXX *//* expect: cannot initialize */
 };
 short c99_6_7_8_p29_example6a[4][3][2] = {
 	{ 1 },
 	{ 2, 3 },
 	{ 4, 5, 6 },
 };
 short c99_6_7_8_p29_example6b[4][3][2] = {
 , 0, 0, 0, 0, 0,
 , 3, 0, 0, 0, 0,
 , 5, 6, 0, 0, 0,
 };
 @@ -320,47 +320,65 @@ ensure_array_type_is_not_modified_during
 	array_of_unknown_size a1 = { 1, 2, 3};
 	switch (4) {
 	case sizeof(array_of_unknown_size):
 	case 0:			/* expect: duplicate case in switch: 0 */
 	case 3:
 	case 4:
 	case 12:
 		break;
+	}
+}
 struct point unknown_member_name_beginning = {
-	// FIXME: assertion "bl->bl_type != NULL" failed in initialization_push
+	/* TODO: remove me */
-	// .r = 5,
+	.r = 5,			/* expect: undefined struct/union member: r */
 	.x = 4,
 	.y = 3,
 };
 struct point unknown_member_name_middle = {
 	.x = 4,
 	.r = 5,			/* expect: undefined struct/union member: r */
 	.y = 3,
 };
 struct point unknown_member_name_end = {
 	.x = 4,
 	.y = 3,
 	.r = 5,			/* expect: undefined struct/union member: r */
 };
 union value {
 	int int_value;
 	void *pointer_value;
 };
 union value unknown_union_member_name_first = {
-	// FIXME: assertion "bl->bl_type != NULL" failed in initialization_push
+	/* TODO: remove me */
-	// .unknown_value = 4,
+	.unknown_value = 4,	/* expect: undefined struct/union member */
 	.int_value = 3,
 };
 union value unknown_union_member_name_second = {
 	.int_value = 3,
-	// FIXME: assertion "bl->bl_type->t_tspec == ARRAY" failed in brace_level_extend_if_array_of_unknown_size
+	/* TODO: remove me */
-	// .unknown_value = 4,
+	.unknown_value = 4,	/* expect: undefined struct/union member */
 };
 struct point designators_with_subscript = {
 	[0] = 3,		/* expect: only for arrays */
 	.member[0][0].member = 4, /* expect: undefined struct/union member */
 	.x.y.z = 5,	/* intentionally not caught, see designator_look_up */
 };
 struct {
 	int : 16;
 } struct_with_only_unnamed_members = {	/* expect: has no named members */
 ,		/* expect: too many struct/union initializers */
 };
 union {
 	int : 16;
 } union_with_only_unnamed_members = {	/* expect: has no named members */
 ,		/* expect: too many struct/union initializers */
 };

 @@ -1,17 +1,18 @@
-/*	$NetBSD: init.c,v 1.178 2021/03/29 21:34:17 rillig Exp $	*/
+/*	$NetBSD: init.c,v 1.179 2021/03/30 14:25:28 rillig Exp $	*/
 /*
  * Copyright (c) 1994, 1995 Jochen Pohl
  * Copyright (c) 2021 Roland Illig
  * All Rights Reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *      This product includes software developed by Jochen Pohl for
 @@ -27,323 +28,213 @@
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID) && !defined(lint)
-__RCSID("$NetBSD: init.c,v 1.178 2021/03/29 21:34:17 rillig Exp $");
+__RCSID("$NetBSD: init.c,v 1.179 2021/03/30 14:25:28 rillig Exp $");
 #endif
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 /*
- * Initialization
+ * Initialization of global or local objects, like in:
  * Handles initializations of global or local objects, like in:
+ *
  *	int number = 12345;
  *	int number_with_braces = { 12345 };
+ *
  *	int array_of_unknown_size[] = { 111, 222, 333 };
  *	int array_flat[2][2] = { 11, 12, 21, 22 };
  *	int array_nested[2][2] = { { 11, 12 }, { 21, 22 } };
+ *
  *	struct { int x, y; } point = { 3, 4 };
  *	struct { int x, y; } point = { .y = 4, .x = 3 };
+ *
  * Any scalar expression in the initializer may be surrounded by arbitrarily
  * many extra pairs of braces, like in the example 'number_with_braces' (C99
  * 6.7.8p11).
+ *
  * For multi-dimensional arrays, the inner braces may be omitted like in
- * array_flat or spelled out like in array_nested.
+ * array_flat or spelled out like in array_nested.  This is unusual in
  * practice and therefore only supported very basically.
+ *
- * For the initializer, the grammar parser calls these functions:
+ * During initialization, the grammar parser calls these functions:
+ *
  *	begin_initialization
  *		init_lbrace			for each '{'
  *		add_designator_member		for each '.member' before '='
  *		add_designator_subscript	for each '[123]' before '='
- *		init_using_expr			for each expression
+ *		init_expr			for each expression
  *		init_rbrace			for each '}'
  *	end_initialization
+ *
  * Each '{' begins a new brace level, each '}' ends the current brace level.
  * Each brace level has an associated "current object".
+ *
  * Most of the time, the topmost level of brace_level contains a scalar type,
  * and its remaining count toggles between 1 and 0.
  * See also:
  *	C99 6.7.8 "Initialization"
  *	d_c99_init.c for more examples
  */
 /*
  * Describes a single brace level of an ongoing initialization.
  * XXX: Since C99, the initializers can be listed in arbitrary order by using
  * designators to specify the sub-object to be initialized.  The member names
  * of non-leaf structs may thus appear repeatedly, as demonstrated in
  * d_init_pop_member.c.
  * See C99 6.7.8, which spans 6 pages full of tricky details and carefully
  * selected examples.
  */
 struct brace_level {
 	/*
 	 * The type of the current object that is initialized at this brace
 	 * level.
 	 * On the outermost element, this is always NULL since the outermost
 	 * initializer-expression may be enclosed in an optional pair of
 	 * braces, as of the current implementation.
 	 * FIXME: This approach is wrong.  It's not that the outermost
 	 * initializer may be enclosed in additional braces, it's every scalar
 	 * that may be enclosed in additional braces, as of C99 6.7.8p11.
 	 * Everywhere else it is nonnull.
 	 */
 	type_t	*bl_type;
 	/*
 	 * The type that will be initialized at the next initialization level,
 	 * usually enclosed by another pair of braces.
 	 * For an array, it is the element type, but without 'const'.
 	 * For a struct or union type, it is one of the member types, but
 	 * without 'const'.
 	 * The outermost stack element has no bl_type but nevertheless has
 	 * bl_subtype.  For example, in 'int var = { 12345 }', initially there
 	 * is a brace_level with bl_subtype 'int'.  When the '{' is processed,
 	 * an element with bl_type 'int' is pushed to the stack.  When the
 	 * corresponding '}' is processed, the inner element is popped again.
 	 * During initialization, only the top 2 elements of the stack are
 	 * looked at.
 	 * XXX: Having bl_subtype here is the wrong approach, it should not be
 	 * necessary at all; see bl_type.
 	 */
 	type_t	*bl_subtype;
 	/*
 	 * Whether this level of the initializer requires a '}' to be
 	 * completed.
 	 * Multidimensional arrays do not need a closing brace to complete
 	 * an inner array; for example, { 1, 2, 3, 4 } is a valid initializer
 	 * for 'int arr[2][2]'.
 	 * XXX: Double-check whether this is the correct approach at all; see
 	 * bl_type.
 	 */
 	bool bl_brace: 1;
 	/* Whether bl_type is an array of unknown size. */
 	bool bl_array_of_unknown_size: 1;
 	/*
 	 * XXX: This feels wrong.  Whether or not there has been a named
 	 * initializer (called 'designation' since C99) should not matter at
 	 * all.  Even after an initializer with designation, counting of the
 	 * remaining elements continues, see C99 6.7.8p17.
 	 */
 	bool bl_seen_named_member: 1;
 	/*
 	 * For structs, the next member to be initialized by a designator-less
 	 * initializer.
 	 */
 	sym_t *bl_next_member;
 	/* TODO: Add bl_next_subscript for arrays. */
 	/* TODO: Understand C99 6.7.8p17 and footnote 128 for unions. */
 	/*
 	 * The number of remaining elements to be used by expressions without
 	 * designator.
 	 * This says nothing about which members have been initialized or not
 	 * since starting with C99, members may be initialized in arbitrary
 	 * order by using designators.
 	 * For an array of unknown size, this is always 0 and thus irrelevant.
 	 * XXX: for scalars?
 	 * XXX: for structs?
 	 * XXX: for unions?
 	 * XXX: for arrays?
 	 * XXX: Having the count of remaining objects should not be necessary.
 	 * It is probably clearer to use bl_next_member and bl_next_subscript
 	 * for this purpose.
 	 */
 	int bl_remaining;
 	/*
 	 * The initialization state of the enclosing data structure
 	 * (struct, union, array).
 	 * XXX: Or for a scalar, for the top-level element, or for expressions
 	 * in redundant braces such as '{{{{ 0 }}}}' (not yet implemented as
 	 * of 2021-03-25).
 	 */
 	struct brace_level *bl_enclosing;
 };
 /*
  * A single component on the path to the sub-object that is initialized by an
  * initializer expression.  Either a struct or union member, or an array
  * subscript.
+ *
- * See also: C99 6.7.8 "Initialization"
+ * C99 6.7.8p6, 6.7.8p7
  */
 struct designator {
-	const char	*dr_name;		/* for struct and union */
+	const char	*dr_name;	/* for struct and union */
-	/* TODO: add 'dr_subscript' for arrays */
+	size_t		dr_subscript;	/* for array */
 	struct designator *dr_next;
 };
 /*
  * The optional designation for an initializer, saying which sub-object to
  * initialize.  Examples for designations are '.member' or
  * '.member[123].member.member[1][1]'.
+ *
- * See also: C99 6.7.8 "Initialization"
+ * C99 6.7.8p6, 6.7.8p7
  */
 struct designation {
 	struct designator *dn_head;
 	struct designator *dn_tail;
 };
 /*
  * Describes a single brace level of an ongoing initialization.
+ *
  * See C99 6.7.8p17.
  */
 struct brace_level {
 	/*
 	 * The type of the current object that is initialized at this brace
 	 * level.
 	 */
 	const type_t	*bl_type;
 	const sym_t	*bl_next_member;	/* for structs and unions */
 	size_t		bl_array_next_subscript;
 	bool		bl_array_of_unknown_size: 1;
 	bool		bl_scalar_done: 1;	/* for scalars */
 	bool		bl_omitted_braces: 1;	/* skip further checks */
 	struct designation bl_designation;	/* .member[123].member */
 	struct brace_level *bl_enclosing;
 };
 struct initialization {
 	/*
-	 * is set as soon as a fatal error occurred in the initialization.
+	 * Is set as soon as a fatal error occurred in the initialization.
 	 * The effect is that the rest of the initialization is ignored
 	 * (parsed by yacc, expression trees built, but no initialization
 	 * takes place).
 	 */
 	bool		in_err;
 	/* The symbol that is to be initialized. */
 	sym_t		*in_sym;
 	/* The innermost brace level. */
 	struct brace_level *in_brace_level;
-	/*
+	struct initialization *in_enclosing;
 	 * The C99 designator, if any, for the current initialization
 	 * expression.
 	 */
 	struct designation in_designation;
 	struct initialization *in_next;
 };
 static struct initialization *init;
 #ifdef DEBUG
-static int debug_ind = 0;
+static int debug_indentation = 0;
 #endif
 #ifdef DEBUG
 static void __printflike(1, 2)
 debug_printf(const char *fmt, ...)
+{
 	va_list va;
 	va_start(va, fmt);
 	vfprintf(stdout, fmt, va);
 	va_end(va);
+}
 static void
 debug_indent(void)
+{
-	debug_printf("%*s", 2 * debug_ind, "");
+	debug_printf("%*s", 2 * debug_indentation, "");
+}
 static void
 debug_enter(const char *func)
+{
-	printf("%*s+ %s\n", 2 * debug_ind++, "", func);
+	printf("%*s+ %s\n", 2 * debug_indentation++, "", func);
+}
 static void __printflike(1, 2)
 debug_step(const char *fmt, ...)
+{
 	va_list va;
 	debug_indent();
 	va_start(va, fmt);
 	vfprintf(stdout, fmt, va);
 	va_end(va);
 	printf("\n");
+}
 static void
 debug_leave(const char *func)
+{
-	printf("%*s- %s\n", 2 * --debug_ind, "", func);
+	printf("%*s- %s\n", 2 * --debug_indentation, "", func);
+}
 #define debug_enter()		(debug_enter)(__func__)
 #define debug_leave()		(debug_leave)(__func__)
 #else
 /* TODO: This is C99 */
 #define debug_printf(fmt, ...)	do { } while (false)
 #define debug_indent()		do { } while (false)
 #define debug_enter()		do { } while (false)
 #define debug_step(fmt, ...)	do { } while (false)
 #define debug_leave()		do { } while (false)
 #endif
 static void *
 unconst_cast(const void *p)
+{
 	void *r;
 	memcpy(&r, &p, sizeof r);
 	return r;
+}
 /* C99 6.7.8p7 */
 static bool
 is_struct_or_union(tspec_t t)
+{
 	return t == STRUCT || t == UNION;
+}
 static bool
 has_automatic_storage_duration(const sym_t *sym)
+{
 	return sym->s_scl == AUTO || sym->s_scl == REG;
+}
 @@ -355,42 +246,95 @@ is_string_array(const type_t *tp, tspec_
 	tspec_t st;
 	if (tp == NULL || tp->t_tspec != ARRAY)
 		return false;
 	st = tp->t_subt->t_tspec;
 	return t == CHAR
 	    ? st == CHAR || st == UCHAR || st == SCHAR
 	    : st == WCHAR;
+}
 /* C99 6.7.8p9 */
 static bool
-is_unnamed_member(const sym_t *m)
+is_unnamed(const sym_t *m)
+{
 	return m->s_bitfield && m->s_name == unnamed;
+}
 /* C99 6.7.8p9 */
 static const sym_t *
 skip_unnamed(const sym_t *m)
+{
 	while (m != NULL && is_unnamed(m))
 		m = m->s_next;
 	return m;
+}
 static const sym_t *
-look_up_member(const sym_t *m, const char *name)
+first_named_member(const type_t *tp)
+{
-	for (; m != NULL; m = m->s_next)
+	lint_assert(is_struct_or_union(tp->t_tspec));
-		if (!is_unnamed_member(m) && strcmp(m->s_name, name) == 0)
+	return skip_unnamed(tp->t_str->sou_first_member);
+}
 static const sym_t *
 look_up_member(const type_t *tp, const char *name)
+{
 	const sym_t *m;
 	lint_assert(is_struct_or_union(tp->t_tspec));
 	for (m = tp->t_str->sou_first_member; m != NULL; m = m->s_next)
 		if (!is_unnamed(m) && strcmp(m->s_name, name) == 0)
 			return m;
 	return NULL;
+}
 static const type_t *
 sym_type(const sym_t *sym)
+{
 	return sym != NULL ? sym->s_type : NULL;
+}
 static const type_t *
 look_up_member_type(const type_t *tp, const char *name)
+{
 	const sym_t *member;
 	member = look_up_member(tp, name);
 	if (member == NULL) {
 		/* TODO: add type information */
 		/* undefined struct/union member: %s */
 		error(101, name);
+	}
 	return sym_type(member);
+}
 static void
 update_type_of_array_of_unknown_size(sym_t *sym, size_t size)
+{
 	type_t *tp;
 	tp = duptyp(sym->s_type);
 	tp->t_dim = (int)size;
 	tp->t_incomplete_array = false;
 	sym->s_type = tp;
+}
 /* In traditional C, bit-fields can be initialized only by integer constants. */
 static void
 check_bit_field_init(const tnode_t *ln, tspec_t lt, tspec_t rt)
+{
 	if (tflag &&
 	    is_integer(lt) &&
 	    ln->tn_type->t_bitfield &&
 	    !is_integer(rt)) {
 		/* bit-field initialization is illegal in traditional C */
 		warning(186);
+	}
 @@ -408,26 +352,38 @@ check_non_constant_initializer(const tno
 	if (constant_addr(tn, &unused_sym, &unused_offs))
 		return;
 	if (has_automatic_storage_duration(sym)) {
 		/* non-constant initializer */
 		c99ism(177);
 	} else {
 		/* non-constant initializer */
 		error(177);
+	}
+}
 static void
 check_no_auto_aggregate(const sym_t *sym)
+{
 	if (tflag &&
 	    has_automatic_storage_duration(sym) &&
 	    !is_scalar(sym->s_type->t_tspec)) {
 		/* no automatic aggregate initialization in trad. C */
 		warning(188);
+	}
+}
 static void
 check_init_expr(const type_t *tp, sym_t *sym, tnode_t *tn)
+{
 	tnode_t *ln;
 	tspec_t lt, rt;
 	struct mbl *tmem;
 	/* Create a temporary node for the left side. */
 	ln = tgetblk(sizeof *ln);
 	ln->tn_op = NAME;
 	ln->tn_type = tduptyp(tp);
 	ln->tn_type->t_const = false;
 	ln->tn_lvalue = true;
 	ln->tn_sym = sym;
 @@ -453,1042 +409,682 @@ check_init_expr(const type_t *tp, sym_t
 	check_bit_field_init(ln, lt, rt);
 	/*
 	 * XXX: Is it correct to do this conversion _after_ the typeok above?
 	 */
 	if (lt != rt || (tp->t_bitfield && tn->tn_op == CON))
 		tn = convert(INIT, 0, unconst_cast(tp), tn);
 	check_non_constant_initializer(tn, sym);
+}
 static struct designator *
-designator_new(const char *name)
+designator_new(const char *name, size_t subscript)
+{
 	struct designator *dr;
 	dr = xcalloc(1, sizeof *dr);
 	dr->dr_name = name;
 	dr->dr_subscript = subscript;
 	return dr;
+}
 static void
 designator_free(struct designator *dr)
+{
 	free(dr);
+}
 static const type_t *
 designator_look_up(const struct designator *dr, const type_t *tp)
+{
 	switch (tp->t_tspec) {
 	case STRUCT:
 	case UNION:
 		if (dr->dr_name == NULL) {
 			/* syntax error '%s' */
 			error(249, "designator '[...]' is only for arrays");
 			return sym_type(first_named_member(tp));
+		}
 		return look_up_member_type(tp, dr->dr_name);
 	case ARRAY:
 		if (dr->dr_name != NULL) {
 			/* TODO: reword; kept for compatibility */
 			/* syntax error '%s' */
 			error(249,
 			    "named member must only be used with struct/union");
+		}
 		return tp->t_subt;
 	default:
 		/* syntax error '%s' */
 		error(249, "scalar type cannot use designator");
 		return tp;
+	}
+}
 #ifdef DEBUG
 static void
 designation_debug(const struct designation *dn)
+{
 	const struct designator *dr;
 	if (dn->dn_head == NULL)
 		return;
 	debug_indent();
 	debug_printf("designation: ");
-	for (dr = dn->dn_head; dr != NULL; dr = dr->dr_next)
+	for (dr = dn->dn_head; dr != NULL; dr = dr->dr_next) {
-		debug_printf(".%s", dr->dr_name);
+		if (dr->dr_name != NULL) {
 			debug_printf(".%s", dr->dr_name);
 			lint_assert(dr->dr_subscript == 0);
 		} else
 			debug_printf("[%zu]", dr->dr_subscript);
+	}
 	debug_printf("\n");
+}
 #else
 #define designation_debug(dn) do { } while (false)
 #endif
 static void
-designation_add(struct designation *dn, struct designator *dr)
+designation_add(struct designation *dn, const char *name, size_t subscript)
+{
 	struct designator *dr;
 	dr = designator_new(name, subscript);
 	if (dn->dn_head != NULL) {
 		dn->dn_tail->dr_next = dr;
 		dn->dn_tail = dr;
 	} else {
 		dn->dn_head = dr;
 		dn->dn_tail = dr;
+	}
 	designation_debug(dn);
+}
 /* TODO: add support for array subscripts, not only named members */
 /*
- * TODO: This function should not be necessary at all.  There is no need to
+ * Starting at the type of the current object, resolve the type of the
- *  remove the head of the list.
+ * sub-object by following each designator in the list.
  */
 static const type_t *
 designation_look_up(const struct designation *dn, const type_t *tp)
+{
 	const struct designator *dr;
 	for (dr = dn->dn_head; dr != NULL && tp != NULL; dr = dr->dr_next)
 		tp = designator_look_up(dr, tp);
 	return tp;
+}
 static void
-designation_shift_level(struct designation *dn)
+designation_reset(struct designation *dn)
+{
-	lint_assert(dn->dn_head != NULL);
+	struct designator *dr, *next;
-	if (dn->dn_head == dn->dn_tail) {
+	for (dr = dn->dn_head; dr != NULL; dr = next) {
-		designator_free(dn->dn_head);
+		next = dr->dr_next;
-		dn->dn_head = NULL;
+		designator_free(dr);
 		dn->dn_tail = NULL;
 	} else {
 		struct designator *head = dn->dn_head;
 		dn->dn_head = dn->dn_head->dr_next;
 		designator_free(head);
+	}
 	designation_debug(dn);
+}
 static struct brace_level *
-brace_level_new(type_t *type, type_t *subtype, int remaining,
+brace_level_new(const type_t *tp, struct brace_level *enclosing)
 		struct brace_level *enclosing)
+{
-	struct brace_level *bl = xcalloc(1, sizeof(*bl));
+	struct brace_level *bl;
-	bl->bl_type = type;
+	bl = xcalloc(1, sizeof(*bl));
-	bl->bl_subtype = subtype;
+	bl->bl_type = tp;
 	bl->bl_remaining = remaining;
 	bl->bl_enclosing = enclosing;
 	if (is_struct_or_union(tp->t_tspec))
 		bl->bl_next_member = first_named_member(tp);
 	return bl;
+}
 static void
 brace_level_free(struct brace_level *bl)
+{
 	designation_reset(&bl->bl_designation);
 	free(bl);
+}
 #ifdef DEBUG
 /*
  * TODO: only log the top of the stack after each modifying operation
  * TODO: wrap all write accesses to brace_level in setter functions
  */
 static void
 brace_level_debug(const struct brace_level *bl)
+{
 	if (bl->bl_type != NULL)
 		debug_printf("type '%s'", type_name(bl->bl_type));
 	if (bl->bl_type != NULL && bl->bl_subtype != NULL)
 		debug_printf(", ");
 	if (bl->bl_subtype != NULL)
 		debug_printf("subtype '%s'", type_name(bl->bl_subtype));
-	if (bl->bl_brace)
+	lint_assert(bl->bl_type != NULL);
-		debug_printf(", needs closing brace");
+	lint_assert(bl->bl_next_member == NULL ||
 	    !is_unnamed(bl->bl_next_member));
 	debug_printf("type '%s'", type_name(bl->bl_type));
 	if (bl->bl_array_of_unknown_size)
 		debug_printf(", array of unknown size");
 	if (bl->bl_seen_named_member)
 		debug_printf(", seen named member");
-	const type_t *eff_type = bl->bl_type != NULL
+	if (is_struct_or_union(bl->bl_type->t_tspec) &&
-	    ? bl->bl_type : bl->bl_subtype;
+	    bl->bl_next_member != NULL)
 	if (eff_type->t_tspec == STRUCT && bl->bl_next_member != NULL)
 		debug_printf(", next member '%s'",
 		    bl->bl_next_member->s_name);
 	if (bl->bl_type->t_tspec == ARRAY)
 		debug_printf(", next array subscript %zu",
 		    bl->bl_array_next_subscript);
-	debug_printf(", remaining %d\n", bl->bl_remaining);
+	debug_printf("\n");
+}
 #else
-#define brace_level_debug(bl) do { } while (false)
+#define brace_level_debug(level) do { } while (false)
 #endif
 static void
-brace_level_assert_struct_or_union(const struct brace_level *bl)
+brace_level_remove_designation(struct brace_level *bl)
+{
-	lint_assert(is_struct_or_union(bl->bl_type->t_tspec));
+	struct designator *dr, *next;
-static void
+	for (dr = bl->bl_designation.dn_head; dr != NULL; dr = next) {
-brace_level_assert_array(const struct brace_level *bl)
+		next = dr->dr_next;
 		designator_free(dr);
 	lint_assert(bl->bl_type->t_tspec == ARRAY);
 static type_t *
 brace_level_subtype(struct brace_level *bl)
 	if (bl->bl_subtype != NULL)
 		return bl->bl_subtype;
-	return bl->bl_type;
+	bl->bl_designation.dn_head = NULL;
 	bl->bl_designation.dn_tail = NULL;
+}
 static void
 brace_level_set_array_dimension(struct brace_level *bl, int dim)
 	brace_level_assert_array(bl);
 	debug_step("setting the array size to %d", dim);
 	bl->bl_type->t_dim = dim;
 	debug_indent();
 	brace_level_debug(bl);
-static void
+static const type_t *
-brace_level_next_member(struct brace_level *bl)
+brace_level_sub_type_struct_or_union(const struct brace_level *bl)
+{
 	const sym_t *m;
-	brace_level_assert_struct_or_union(bl);
+	if (bl->bl_next_member == NULL) {
-	do {
+		/* too many struct/union initializers */
-		m = bl->bl_next_member = bl->bl_next_member->s_next;
+		error(172);
-		/* XXX: can this assertion be made to fail? */
+		return NULL;
 		lint_assert(m != NULL);
 	} while (m->s_bitfield && m->s_name == unnamed);
-	debug_indent();
+	lint_assert(!is_unnamed(bl->bl_next_member));
-	brace_level_debug(bl);
+	return sym_type(bl->bl_next_member);
+}
-static const sym_t *
+static const type_t *
-brace_level_look_up_member(const struct brace_level *bl, const char *name)
+brace_level_sub_type_array(const struct brace_level *bl)
+{
-	brace_level_assert_struct_or_union(bl);
+	if (!bl->bl_type->t_incomplete_array &&
-	return look_up_member(bl->bl_type->t_str->sou_first_member, name);
+	    !bl->bl_omitted_braces &&
 	    bl->bl_array_next_subscript >= (size_t)bl->bl_type->t_dim) {
 		/* too many array initializers, expected %d */
 		error(173, bl->bl_type->t_dim);
+	}
 	return bl->bl_type->t_subt;
+}
-static sym_t *
+static const type_t *
-brace_level_look_up_first_member_named(struct brace_level *bl,
+brace_level_sub_type_scalar(const struct brace_level *bl)
 				       const char *name, int *count)
+{
 	sym_t *m;
-	for (m = bl->bl_type->t_str->sou_first_member;
+	if (bl->bl_scalar_done) {
-	     m != NULL; m = m->s_next) {
+		/* too many initializers */
-		if (is_unnamed_member(m))
+		error(174);
 			continue;
 		if (strcmp(m->s_name, name) != 0)
 			continue;
 		(*count)++;
 		break;
+	}
-	return m;
+	return bl->bl_type;
+}
-static sym_t *
+/* Return the type of the sub-object that is currently being initialized. */
-brace_level_look_up_first_member_unnamed(struct brace_level *bl, int *count)
+static const type_t *
 brace_level_sub_type(const struct brace_level *bl)
+{
 	sym_t *m;
-	brace_level_assert_struct_or_union(bl);
+	if (bl->bl_designation.dn_head != NULL)
 		return designation_look_up(&bl->bl_designation, bl->bl_type);
-	for (m = bl->bl_type->t_str->sou_first_member;
+	switch (bl->bl_type->t_tspec) {
-	     m != NULL; m = m->s_next) {
+	case STRUCT:
-		if (is_unnamed_member(m))
+	case UNION:
-			continue;
+		return brace_level_sub_type_struct_or_union(bl);
-		/* XXX: What is this code for? */
+	case ARRAY:
-		if (++(*count) == 1) {
+		return brace_level_sub_type_array(bl);
-			bl->bl_next_member = m;
+	default:
-			bl->bl_subtype = m->s_type;
+		return brace_level_sub_type_scalar(bl);
+	}
 	return m;
+}
-/* TODO: document me */
+static void
-/* TODO: think of a better name than 'push' */
+brace_level_apply_designation(struct brace_level *bl)
 static bool
 brace_level_push_array(struct brace_level *bl)
+{
-	brace_level_assert_array(bl);
+	const struct designator *dr = bl->bl_designation.dn_head;
-	if (bl->bl_enclosing->bl_seen_named_member) {
+	if (dr == NULL)
-		bl->bl_brace = true;
+		return;
 		debug_step("ARRAY, seen named member, needs closing brace");
-	if (is_incomplete(bl->bl_type) &&
+	designation_debug(&bl->bl_designation);
 	    bl->bl_enclosing->bl_enclosing != NULL) {
 		/* initialization of an incomplete type */
 		error(175);
 		return false;
-	bl->bl_subtype = bl->bl_type->t_subt;
+	switch (bl->bl_type->t_tspec) {
-	bl->bl_array_of_unknown_size = is_incomplete(bl->bl_type);
+	case STRUCT:
-	bl->bl_remaining = bl->bl_type->t_dim;
+	case UNION:
-	debug_step("type '%s' remaining %d",
+		if (dr->dr_name == NULL)
-	    type_name(bl->bl_type), bl->bl_remaining);
+			return;	/* error, silently ignored */
-	return true;
+		bl->bl_next_member = look_up_member(bl->bl_type, dr->dr_name);
 		break;
 	case ARRAY:
 		if (dr->dr_name != NULL)
 			return;	/* error, silently ignored */
 		bl->bl_array_next_subscript = dr->dr_subscript;
 		break;
 	default:
 		break;		/* error, silently ignored */
+	}
+}
 /*
- * If the removed element was a structure member, we must go
+ * After initializing a sub-object, advance to the next sub-object.
  * to the next structure member.
  * XXX: Nothing should ever be "removed" at this point.
+ *
- * TODO: think of a better name than 'pop'
+ * C99 6.7.8p17
  */
 static void
-brace_level_pop_item_unnamed(struct brace_level *bl)
+brace_level_advance(struct brace_level *bl)
+{
 	if (bl->bl_remaining > 0 && bl->bl_type->t_tspec == STRUCT &&
 	    !bl->bl_seen_named_member) {
 		brace_level_next_member(bl);
 		bl->bl_subtype = bl->bl_next_member->s_type;
-static bool
+	switch (bl->bl_type->t_tspec) {
-brace_level_check_too_many_initializers(struct brace_level *bl)
+	case STRUCT:
 		lint_assert(bl->bl_next_member != NULL);
-	if (bl->bl_remaining > 0)
+		bl->bl_next_member = skip_unnamed(bl->bl_next_member->s_next);
-		return true;
+		break;
-	/*
+	case UNION:
-	 * FIXME: even with named members, there can be too many initializers
+		bl->bl_next_member = NULL;
-	 */
+		break;
-	if (bl->bl_array_of_unknown_size || bl->bl_seen_named_member)
+	case ARRAY:
-		return true;
+		bl->bl_array_next_subscript++;
 		break;
-	tspec_t t = bl->bl_type->t_tspec;
+	default:
-	if (t == ARRAY) {
+		bl->bl_scalar_done = true;
-		/* too many array initializers, expected %d */
+		break;
 		error(173, bl->bl_type->t_dim);
 	} else if (is_struct_or_union(t)) {
 		/* too many struct/union initializers */
 		error(172);
 	} else {
 		/* too many initializers */
 		error(174);
+	}
 	return false;
 /* Extend an array of unknown size by one element */
 static void
 brace_level_extend_if_array_of_unknown_size(struct brace_level *bl)
 	if (bl->bl_remaining != 0)
 		return;
 	/*
 	 * XXX: According to the function name, there should be a 'return' if
 	 * bl_array_of_unknown_size is false.  There's probably a test missing
 	 * for that case.
 	 */
 	/*
 	 * The only place where an incomplete array may appear is at the
 	 * outermost aggregate bl of the object to be initialized.
 	 */
 	lint_assert(bl->bl_enclosing->bl_enclosing == NULL);
 	lint_assert(bl->bl_type->t_tspec == ARRAY);
 	debug_step("extending array of unknown size '%s'",
 	    type_name(bl->bl_type));
 	bl->bl_remaining = 1;
 	bl->bl_type->t_dim++;
 	setcomplete(bl->bl_type, true);
 	debug_step("extended type is '%s'", type_name(bl->bl_type));
+}
 static struct initialization *
 initialization_new(sym_t *sym)
+{
-	struct initialization *in = xcalloc(1, sizeof(*in));
+	struct initialization *in;
 	in = xcalloc(1, sizeof(*in));
 	in->in_sym = sym;
 	return in;
+}
 static void
 initialization_free(struct initialization *in)
+{
 	struct brace_level *bl, *next;
 	for (bl = in->in_brace_level; bl != NULL; bl = next) {
 		next = bl->bl_enclosing;
 		brace_level_free(bl);
+	}
 	free(in);
+}
 #ifdef DEBUG
 /*
  * TODO: only call debug_initstack after each push/pop.
  */
 static void
 initialization_debug(const struct initialization *in)
+{
 	size_t i;
 	const struct brace_level *bl;
 	if (in->in_brace_level == NULL) {
-		debug_step("no brace level in the current initialization");
+		debug_step("no brace level");
 		return;
+	}
-	size_t i = 0;
+	i = 0;
-	for (const struct brace_level *bl = in->in_brace_level;
+	for (bl = in->in_brace_level; bl != NULL; bl = bl->bl_enclosing) {
 	     bl != NULL; bl = bl->bl_enclosing) {
 		debug_indent();
 		debug_printf("brace level %zu: ", i);
 		brace_level_debug(bl);
 		i++;
+	}
+}
 #else
 #define initialization_debug(in) do { } while (false)
 #endif
 /*
- * Initialize the initialization stack by putting an entry for the object
+ * Return the type of the object or sub-object that is currently being
- * which is to be initialized on it.
+ * initialized.
  * TODO: merge into initialization_new if possible
  */
-static void
+static const type_t *
-initialization_init(struct initialization *in)
+initialization_sub_type(struct initialization *in)
 	if (in->in_err)
 		return;
 	debug_enter();
 	/*
 	 * If the type which is to be initialized is an incomplete array,
 	 * it must be duplicated.
 	 */
 	if (in->in_sym->s_type->t_tspec == ARRAY && is_incomplete(in->in_sym->s_type))
 		in->in_sym->s_type = duptyp(in->in_sym->s_type);
 	/* TODO: does 'duptyp' create a memory leak? */
 	in->in_brace_level = brace_level_new(NULL, in->in_sym->s_type, 1, NULL);
 	initialization_debug(in);
 	debug_leave();
 static void
 initialization_set_error(struct initialization *in)
+{
-	in->in_err = true;
+	const type_t *tp;
-/* TODO: document me */
+	tp = in->in_brace_level != NULL
-/* TODO: think of a better name than 'push' */
+	    ? brace_level_sub_type(in->in_brace_level)
-static bool
+	    : in->in_sym->s_type;
-initialization_push_struct_or_union(struct initialization *in)
+	if (tp == NULL)
 		in->in_err = true;
-	struct brace_level *bl = in->in_brace_level;
+	return tp;
 	int cnt;
 	sym_t *m;
 	if (is_incomplete(bl->bl_type)) {
 		/* initialization of an incomplete type */
 		error(175);
 		initialization_set_error(in);
 		return false;
 	cnt = 0;
 	designation_debug(&in->in_designation);
 	debug_step("lookup for '%s'%s",
 	    type_name(bl->bl_type),
 	    bl->bl_seen_named_member ? ", seen named member" : "");
 	if (in->in_designation.dn_head != NULL)
 		m = brace_level_look_up_first_member_named(bl,
 		    in->in_designation.dn_head->dr_name, &cnt);
 	else
 		m = brace_level_look_up_first_member_unnamed(bl, &cnt);
 	if (in->in_designation.dn_head != NULL) {
 		if (m == NULL) {
 			debug_step("pop struct");
 			return true;
 		bl->bl_next_member = m;
 		bl->bl_subtype = m->s_type;
 		bl->bl_seen_named_member = true;
 		debug_step("named member '%s'",
 		    in->in_designation.dn_head->dr_name);
 		designation_shift_level(&in->in_designation);
 		cnt = bl->bl_type->t_tspec == STRUCT ? 2 : 1;
 	bl->bl_brace = true;
 	debug_step("unnamed element with type '%s'%s",
 	    type_name(
 		bl->bl_type != NULL ? bl->bl_type : bl->bl_subtype),
 	    bl->bl_brace ? ", needs closing brace" : "");
 	if (cnt == 0) {
 		/* cannot init. struct/union with no named member */
 		error(179);
 		initialization_set_error(in);
 		return false;
 	bl->bl_remaining = bl->bl_type->t_tspec == STRUCT ? cnt : 1;
 	return false;
+}
 static void
-initialization_end_brace_level(struct initialization *in)
+initialization_begin_brace_level(struct initialization *in)
+{
-	struct brace_level *bl = in->in_brace_level;
+	const type_t *tp;
 	in->in_brace_level = bl->bl_enclosing;
 	brace_level_free(bl);
-/* TODO: document me */
+	if (in->in_err)
-/* TODO: think of a better name than 'push' */
+		return;
 static void
 initialization_push(struct initialization *in)
 	struct brace_level *bl;
 	debug_enter();
-	brace_level_extend_if_array_of_unknown_size(in->in_brace_level);
+	tp = initialization_sub_type(in);
 	if (tp == NULL) {
-	bl = in->in_brace_level;
+		in->in_err = true;
-	lint_assert(bl->bl_remaining > 0);
+		goto done;
+	}
-	in->in_brace_level = brace_level_new(brace_level_subtype(bl), NULL, 0,
+	if (tflag && in->in_brace_level == NULL)
-	    bl);
+		check_no_auto_aggregate(in->in_sym);
 	lint_assert(in->in_brace_level->bl_type != NULL);
 	lint_assert(in->in_brace_level->bl_type->t_tspec != FUNC);
-again:
+	if (tflag && tp->t_tspec == UNION) {
-	bl = in->in_brace_level;
+		/* initialization of union is illegal in traditional C */
 		warning(238);
+	}
-	debug_step("expecting type '%s'", type_name(bl->bl_type));
+	if (tp->t_tspec == STRUCT && tp->t_str->sou_incomplete) {
-	lint_assert(bl->bl_type != NULL);
+		/* TODO: add type information */
-	switch (bl->bl_type->t_tspec) {
+		/* initialization of an incomplete type */
-	case ARRAY:
+		error(175);
-		if (in->in_designation.dn_head != NULL) {
+		in->in_err = true;
-			debug_step("pop array, named member '%s'%s",
+		goto done;
 			    in->in_designation.dn_head->dr_name,
 			    bl->bl_brace ? ", needs closing brace" : "");
 			goto pop;
-		if (!brace_level_push_array(bl))
+	if (in->in_brace_level != NULL)
-			initialization_set_error(in);
+		brace_level_apply_designation(in->in_brace_level);
 		break;
-	case UNION:
+	in->in_brace_level = brace_level_new(tp, in->in_brace_level);
 		if (tflag)
 			/* initialization of union is illegal in trad. C */
 			warning(238);
 		/* FALLTHROUGH */
 	case STRUCT:
 		if (initialization_push_struct_or_union(in))
 			goto pop;
 		break;
 	default:
 		if (in->in_designation.dn_head != NULL) {
 			debug_step("pop scalar");
 		pop:
 			initialization_end_brace_level(in);
 			goto again;
 		/* The initialization stack now expects a single scalar. */
 		bl->bl_remaining = 1;
 		break;
 done:
 	initialization_debug(in);
 	debug_leave();
+}
-/* TODO: document me */
+/* C99 6.7.8p22 */
 static void
-initialization_pop_item_named(struct initialization *in, const char *name)
+initialization_set_size_of_unknown_array(struct initialization *in)
+{
 	struct brace_level *bl = in->in_brace_level;
 	const sym_t *m;
 	/*
 	 * TODO: fix wording of the debug message; this doesn't seem to be
 	 * related to initializing the named member.
 	 */
 	debug_step("initializing named member '%s'", name);
-	if (!is_struct_or_union(bl->bl_type->t_tspec)) {
+	if (in->in_sym->s_type->t_incomplete_array &&
-		/* syntax error '%s' */
+	    in->in_brace_level->bl_enclosing == NULL)
-		error(249, "named member must only be used with struct/union");
+		update_type_of_array_of_unknown_size(in->in_sym,
-		initialization_set_error(in);
+		    in->in_brace_level->bl_array_next_subscript);
 		return;
 	m = brace_level_look_up_member(bl, name);
 	if (m == NULL) {
 		/* TODO: add type information to the message */
 		/* undefined struct/union member: %s */
 		error(101, name);
 		designation_shift_level(&in->in_designation);
 		bl->bl_seen_named_member = true;
 		return;
 	debug_step("found matching member");
 	bl->bl_subtype = m->s_type;
 	/* XXX: why ++? */
 	bl->bl_remaining++;
 	/* XXX: why is bl_seen_named_member not set? */
 	designation_shift_level(&in->in_designation);
+}
 /* TODO: think of a better name than 'pop' */
 static void
-initialization_pop_item(struct initialization *in)
+initialization_end_brace_level(struct initialization *in)
+{
 	struct brace_level *bl;
 	if (in->in_err)
 		return;
 	debug_enter();
-	bl = in->in_brace_level;
+	initialization_set_size_of_unknown_array(in);
 	debug_indent();
 	debug_printf("popping: ");
 	brace_level_debug(bl);
 	bl = in->in_brace_level;
 	in->in_brace_level = bl->bl_enclosing;
 	brace_level_free(bl);
 	bl = in->in_brace_level;
 	lint_assert(bl != NULL);
 	bl->bl_remaining--;
 	lint_assert(bl->bl_remaining >= 0);
 	debug_step("%d elements remaining", bl->bl_remaining);
 	if (in->in_designation.dn_head != NULL && in->in_designation.dn_head->dr_name != NULL)
 		initialization_pop_item_named(in, in->in_designation.dn_head->dr_name);
 	else
 		brace_level_pop_item_unnamed(bl);
 	initialization_debug(in);
 	debug_leave();
 /*
  * Take all entries which cannot be used for further initializers from the
  * stack, but do this only if they do not require a closing brace.
  */
 /* TODO: think of a better name than 'pop' */
 static void
 initialization_pop_nobrace(struct initialization *in)
 	debug_enter();
 	while (!in->in_brace_level->bl_brace &&
 	       in->in_brace_level->bl_remaining == 0 &&
 	       !in->in_brace_level->bl_array_of_unknown_size)
 		initialization_pop_item(in);
 	debug_leave();
 /*
  * Process a '{' in an initializer by starting the initialization of the
  * nested data structure, with bl_type being the bl_subtype of the outer
  * initialization level.
  */
 static void
 initialization_next_brace(struct initialization *in)
-	debug_enter();
+	if (in->in_brace_level != NULL) {
-	initialization_debug(in);
+		brace_level_advance(in->in_brace_level);
 		brace_level_remove_designation(in->in_brace_level);
 	if (!in->in_err &&
 	    !brace_level_check_too_many_initializers(in->in_brace_level))
 		initialization_set_error(in);
 	if (!in->in_err)
 		initialization_push(in);
 	if (!in->in_err) {
 		in->in_brace_level->bl_brace = true;
 		designation_debug(&in->in_designation);
 		if (in->in_brace_level->bl_type != NULL)
 			debug_step("expecting type '%s'",
 			    type_name(in->in_brace_level->bl_type));
+	}
 	initialization_debug(in);
 	debug_leave();
+}
 static void
-check_no_auto_aggregate(scl_t sclass, const struct brace_level *bl)
+initialization_add_designator(struct initialization *in,
 			      const char *name, size_t subscript)
+{
 	if (!tflag)
 		return;
 	if (!(sclass == AUTO || sclass == REG))
 		return;
 	if (!(bl->bl_enclosing == NULL))
 		return;
 	if (is_scalar(bl->bl_subtype->t_tspec))
 		return;
 	/* no automatic aggregate initialization in trad. C */
 	warning(188);
 static void
 initialization_lbrace(struct initialization *in)
 	if (in->in_err)
 		return;
-	debug_enter();
+	lint_assert(in->in_brace_level != NULL);
-	initialization_debug(in);
+	designation_add(&in->in_brace_level->bl_designation, name, subscript);
 	check_no_auto_aggregate(in->in_sym->s_scl, in->in_brace_level);
 	/*
 	 * Remove all entries which cannot be used for further initializers
 	 * and do not expect a closing brace.
 	 */
 	initialization_pop_nobrace(in);
 	initialization_next_brace(in);
 	initialization_debug(in);
 	debug_leave();
+}
 /*
  * Process a '}' in an initializer by finishing the current level of the
  * initialization stack.
  * Take all entries, including the first which requires a closing brace,
  * from the stack.
  */
 static void
-initialization_rbrace(struct initialization *in)
+initialization_remove_designation(struct initialization *in)
+{
 	bool brace;
 	if (in->in_err)
 		return;
-	debug_enter();
+	if (in->in_brace_level != NULL)
-	do {
+		brace_level_remove_designation(in->in_brace_level);
 		brace = in->in_brace_level->bl_brace;
 		/* TODO: improve wording of the debug message */
 		debug_step("loop brace=%d", brace);
 		initialization_pop_item(in);
 	} while (!brace);
 	initialization_debug(in);
 	debug_leave();
+}
 /*
- * A sub-object of an array is initialized using a designator.  This does not
+ * An object with automatic storage duration that has a single initializer
- * have to be an array element directly, it can also be used to initialize
+ * expression without braces and is not an array is initialized by delegating
- * only a sub-object of the array element.
+ * to the ASSIGN operator.
  * C99 example: struct { int member[4]; } var = { [2] = 12345 };
  * GNU example: struct { int member[4]; } var = { [1 ... 3] = 12345 };
  * TODO: test the following initialization with an outer and an inner type:
  * .deeply[0].nested = {
  *	.deeply[1].nested = {
  *		12345,
  *	},
  * }
  */
-static void
+static bool
-initialization_add_designator_subscript(struct initialization *in,
+initialization_expr_using_assign(struct initialization *in, tnode_t *rn)
 					range_t range)
+{
-	struct brace_level *bl;
+	tnode_t *ln, *tn;
-	debug_enter();
+	if (!has_automatic_storage_duration(in->in_sym))
-	if (range.lo == range.hi)
+		return false;
-		debug_step("subscript is %zu", range.hi);
+	if (in->in_brace_level != NULL)
-	else
+		return false;
-		debug_step("subscript range is %zu ... %zu",
+	if (in->in_sym->s_type->t_tspec == ARRAY)
-		    range.lo, range.hi);
+		return false;
-	/* XXX: This call is wrong here, it must be somewhere else. */
+	debug_step("handing over to ASSIGN");
 	initialization_pop_nobrace(in);
-	bl = in->in_brace_level;
+	ln = new_name_node(in->in_sym, 0);
-	if (bl->bl_array_of_unknown_size) {
+	ln->tn_type = tduptyp(ln->tn_type);
-		/* No +1 here, extend_if_array_of_unknown_size will add it. */
+	ln->tn_type->t_const = false;
 		int auto_dim = (int)range.hi;
 		if (auto_dim > bl->bl_type->t_dim)
 			brace_level_set_array_dimension(bl, auto_dim);
-	debug_leave();
+	tn = build(ASSIGN, ln, rn);
 	expr(tn, false, false, false, false);
 	return true;
+}
 /* Initialize a character array or wchar_t array with a string literal. */
 static bool
 initialization_init_array_using_string(struct initialization *in, tnode_t *tn)
+{
 	struct brace_level *bl;
 	const type_t *tp;
 	strg_t	*strg;
 	if (tn->tn_op != STRING)
 		return false;
 	debug_enter();
 	bl = in->in_brace_level;
 	tp = initialization_sub_type(in);
 	strg = tn->tn_string;
-	/*
+	if (!is_string_array(tp, strg->st_tspec))
-	 * Check if we have an array type which can be initialized by
+		return false;
-	 * the string.
+	if (bl != NULL && tp->t_tspec != ARRAY &&
-	 */
+	    bl->bl_array_next_subscript != 0)
-	if (is_string_array(bl->bl_subtype, strg->st_tspec)) {
+		return false;
 		debug_step("subtype is an array");
 		/* Put the array at top of stack */
 		initialization_push(in);
 		bl = in->in_brace_level;
 	} else if (is_string_array(bl->bl_type, strg->st_tspec)) {
 		debug_step("type is an array");
 		/*
 		 * If the array is already partly initialized, we are
 		 * wrong here.
 		 */
 		if (bl->bl_remaining != bl->bl_type->t_dim)
 			goto nope;
 	} else
 		goto nope;
 	if (bl->bl_array_of_unknown_size) {
 		bl->bl_array_of_unknown_size = false;
 		bl->bl_type->t_dim = (int)(strg->st_len + 1);
 		setcomplete(bl->bl_type, true);
 	} else {
 		/*
 		 * TODO: check for buffer overflow in the object to be
 		 * initialized
 		 */
 		/* XXX: double-check for off-by-one error */
 		if (bl->bl_type->t_dim < (int)strg->st_len) {
 			/* non-null byte ignored in string initializer */
 			warning(187);
-		/*
+	if (bl != NULL && tp->t_dim < (int)strg->st_len) {
-		 * TODO: C99 6.7.8p14 allows a string literal to be enclosed
+		/* non-null byte ignored in string initializer */
-		 * in optional redundant braces, just like scalars.  Add tests
+		warning(187);
 		 * for this.
 		 */
+	}
-	/* In every case the array is initialized completely. */
+	if (tp == in->in_sym->s_type && tp->t_incomplete_array) {
-	bl->bl_remaining = 0;
+		if (bl != NULL) {
 			bl->bl_array_next_subscript = strg->st_len + 1;
 			/* see initialization_set_size_of_unknown_array */
 		} else
 			update_type_of_array_of_unknown_size(in->in_sym,
 			    strg->st_len + 1);
+	}
 	initialization_debug(in);
 	debug_leave();
 	return true;
 nope:
 	debug_leave();
 	return false;
+}
 /*
- * Initialize a non-array object with automatic storage duration and only a
+ * Initialize a single sub-object as part of the currently ongoing
- * single initializer expression without braces by delegating to ASSIGN.
+ * initialization.
  */
-static bool
+static void
-initialization_init_using_assign(struct initialization *in, tnode_t *rn)
+initialization_expr(struct initialization *in, tnode_t *tn)
+{
-	tnode_t *ln, *tn;
+	const type_t *tp;
 	if (in->in_sym->s_type->t_tspec == ARRAY)
 		return false;
 	if (in->in_brace_level->bl_enclosing != NULL)
 		return false;
-	debug_step("handing over to ASSIGN");
+	if (in->in_err)
 		return;
-	ln = new_name_node(in->in_sym, 0);
+	if (in->in_brace_level != NULL &&
-	ln->tn_type = tduptyp(ln->tn_type);
+	    in->in_brace_level->bl_omitted_braces)
-	ln->tn_type->t_const = false;
+		return;
-	tn = build(ASSIGN, ln, rn);
+	debug_enter();
 	expr(tn, false, false, false, false);
-	/* XXX: why not clean up the initstack here already? */
+	if (tn == NULL)
-	return true;
+		goto advance;
 	if (initialization_expr_using_assign(in, tn))
 		goto done;
 	if (initialization_init_array_using_string(in, tn))
 		goto advance;
-/* TODO: document me, or think of a better name */
+	if (in->in_brace_level != NULL)
-static void
+		brace_level_apply_designation(in->in_brace_level);
-initialization_next_nobrace(struct initialization *in, tnode_t *tn)
+	tp = initialization_sub_type(in);
 	if (tp == NULL)
-	debug_enter();
+		goto done;
-	if (in->in_brace_level->bl_type == NULL &&
+	if (in->in_brace_level == NULL && !is_scalar(tp->t_tspec)) {
 	    !is_scalar(in->in_brace_level->bl_subtype->t_tspec)) {
 		/* {}-enclosed initializer required */
 		error(181);
-		/* XXX: maybe set initerr here */
+		goto done;
+	}
-	if (!in->in_err &&
+	/*
-	    !brace_level_check_too_many_initializers(in->in_brace_level))
+	 * Hack to accept initializations with omitted braces, see
-		initialization_set_error(in);
+	 * c99_6_7_8_p28_example5 in test d_c99_init.c.  Since both GCC and
 	 * Clang already warn about this at level -Wall, there is no point
-	while (!in->in_err) {
+	 * in letting lint check this again.
-		struct brace_level *bl = in->in_brace_level;
+	 */
 	if (is_scalar(tn->tn_type->t_tspec) &&
-		if (tn->tn_type->t_tspec == STRUCT &&
+	    tp->t_tspec == ARRAY &&
-		    bl->bl_type == tn->tn_type &&
+	    in->in_brace_level != NULL) {
-		    bl->bl_enclosing != NULL &&
+		in->in_brace_level->bl_omitted_braces = true;
-		    bl->bl_enclosing->bl_enclosing != NULL) {
+		goto done;
 			bl->bl_brace = false;
 			bl->bl_remaining = 1; /* the struct itself */
 			break;
 		if (bl->bl_type != NULL &&
 		    is_scalar(bl->bl_type->t_tspec))
 			break;
 		initialization_push(in);
+	}
 	debug_step("expecting '%s', expression has '%s'",
 	    type_name(tp), type_name(tn->tn_type));
 	check_init_expr(tp, in->in_sym, tn);
 advance:
 	if (in->in_brace_level != NULL)
 		brace_level_advance(in->in_brace_level);
 done:
 	initialization_remove_designation(in);
 	initialization_debug(in);
 	debug_leave();
+}
 static void
 initialization_expr(struct initialization *in, tnode_t *tn)
 	debug_enter();
 	initialization_debug(in);
 	designation_debug(&in->in_designation);
 	debug_step("expr:");
 	debug_node(tn, debug_ind + 1);
-	if (in->in_err || tn == NULL)
+static struct initialization *init;
 		goto done;
 	if (has_automatic_storage_duration(in->in_sym) &&
 	    initialization_init_using_assign(in, tn))
 		goto done;
 	initialization_pop_nobrace(in);
 	if (initialization_init_array_using_string(in, tn)) {
 		debug_step("after initializing the string:");
 		goto done_debug;
 	initialization_next_nobrace(in, tn);
 	if (in->in_err || tn == NULL)
 		goto done_debug;
 	/* Using initsym here is better than nothing. */
 	check_init_expr(in->in_brace_level->bl_type, in->in_sym, tn);
 	in->in_brace_level->bl_remaining--;
 	debug_step("%d elements remaining", in->in_brace_level->bl_remaining);
 done_debug:
 	initialization_debug(in);
 done:
 	while (in->in_designation.dn_head != NULL)
 		designation_shift_level(&in->in_designation);
 	debug_leave();
 static struct initialization *
 current_init(void)
+{
 	lint_assert(init != NULL);
 	return init;
+}
 bool *
 current_initerr(void)
 	return &current_init()->in_err;
 sym_t **
 current_initsym(void)
+{
 	return &current_init()->in_sym;
+}
 void
 begin_initialization(sym_t *sym)
+{
 	struct initialization *in;
 	debug_step("begin initialization of '%s'", type_name(sym->s_type));
 #ifdef DEBUG
 	debug_indentation++;
 #endif
 	in = initialization_new(sym);
-	in->in_next = init;
+	in->in_enclosing = init;
 	init = in;
+}
 void
 end_initialization(void)
+{
 	struct initialization *in;
 	in = init;
-	init = init->in_next;
+	init = in->in_enclosing;
 	initialization_free(in);
 #ifdef DEBUG
 	debug_indentation--;
 #endif
 	debug_step("end initialization");
+}
 void
 add_designator_member(sbuf_t *sb)
+{
-	designation_add(&current_init()->in_designation,
+	initialization_add_designator(current_init(), sb->sb_name, 0);
 	    designator_new(sb->sb_name));
+}
 void
 add_designator_subscript(range_t range)
+{
-	initialization_add_designator_subscript(current_init(), range);
+	initialization_add_designator(current_init(), NULL, range.hi);
 void
 initstack_init(void)
 	initialization_init(current_init());
+}
 void
 init_lbrace(void)
+{
-	initialization_lbrace(current_init());
+	initialization_begin_brace_level(current_init());
+}
 void
-init_using_expr(tnode_t *tn)
+init_expr(tnode_t *tn)
+{
 	initialization_expr(current_init(), tn);
+}
 void
 init_rbrace(void)
+{
-	initialization_rbrace(current_init());
+	initialization_end_brace_level(current_init());
+}

 @@ -1,10 +1,21 @@
 d_c99_init.c(23): error: too many initializers [174]
 d_c99_init.c(63): error: cannot initialize 'pointer to const void' from 'struct any' [185]
 d_c99_init.c(80): error: too many array initializers, expected 3 [173]
 d_c99_init.c(139): error: too many struct/union initializers [172]
 d_c99_init.c(145): error: syntax error 'named member must only be used with struct/union' [249]
 d_c99_init.c(232): error: too many struct/union initializers [172]
 d_c99_init.c(238): warning: illegal combination of integer (char) and pointer (pointer to char) [183]
-d_c99_init.c(244): error: too many array initializers, expected 8 [173]
+d_c99_init.c(242): warning: illegal combination of integer (char) and pointer (pointer to char) [183]
 d_c99_init.c(282): error: cannot initialize 'struct <unnamed>' from 'int' [185]
 d_c99_init.c(324): error: duplicate case in switch: 0 [199]
 d_c99_init.c(334): error: undefined struct/union member: r [101]
 d_c99_init.c(341): error: undefined struct/union member: r [101]
 d_c99_init.c(348): error: undefined struct/union member: r [101]
 d_c99_init.c(358): error: undefined struct/union member: unknown_value [101]
 d_c99_init.c(365): error: undefined struct/union member: unknown_value [101]
 d_c99_init.c(369): error: syntax error 'designator '[...]' is only for arrays' [249]
 d_c99_init.c(370): error: undefined struct/union member: member [101]
 d_c99_init.c(376): warning: structure has no named members [65]
 d_c99_init.c(377): error: too many struct/union initializers [172]
 d_c99_init.c(382): warning: union has no named members [65]
 d_c99_init.c(383): error: too many struct/union initializers [172]

 @@ -1,14 +1,14 @@
-/*	$NetBSD: d_init_array_using_string.c,v 1.2 2021/03/23 22:58:08 rillig Exp $	*/
+/*	$NetBSD: d_init_array_using_string.c,v 1.3 2021/03/30 14:25:28 rillig Exp $	*/
 # 3 "d_init_array_using_string.c"
 /*
  * Test initialization of arrays and pointers by string literals.
  */
 void sink(const void *);
 void
 test_assignment_initialization(void)
+{
 	const char *cs_match = "";
 	const int *ws_match = L"";
 @@ -46,32 +46,34 @@ void
 test_array_initialization_in_struct(void)
+{
 	struct cs_ws {
 		const char cs[10];
 		const int ws[10];
 	};
 	struct cs_ws type_match = {
 	    	"",
 	    	L"",
 	};
 	struct cs_ws type_mismatch = {
-	    	L"",		/* expect: illegal combination */
+	    	L"",		/* expect: cannot initialize */
-	    	"",		/* expect: illegal combination */
+	    	"",		/* expect: cannot initialize */
 	};
 	struct cs_ws no_terminating_null = {
 	    	"0123456789",
 	    	L"0123456789",
 	};
 	struct cs_ws too_many_characters = {
 	    	"0123456789X",	/* expect: non-null byte ignored */
 	    	L"0123456789X",	/* expect: non-null byte ignored */
 	};
 	struct cs_ws extra_braces = {
 		{ "" },
 		{ L"" },
 	};
 	/* expect-3: illegal combination of integer (char) and pointer (pointer to char) */
 	/* expect-3: illegal combination of integer (int) and pointer (pointer to int) */
+}

 @@ -1,8 +1,10 @@
 d_init_array_using_string.c(16): warning: illegal pointer combination (pointer to const char) and (pointer to int), op = [124]
 d_init_array_using_string.c(17): warning: illegal pointer combination (pointer to const int) and (pointer to char), op = [124]
 d_init_array_using_string.c(34): warning: illegal pointer combination [184]
 d_init_array_using_string.c(35): warning: illegal pointer combination [184]
-d_init_array_using_string.c(59): warning: illegal combination of integer (char) and pointer (pointer to int) [183]
+d_init_array_using_string.c(59): error: cannot initialize 'array[10] of const char' from 'pointer to int' [185]
-d_init_array_using_string.c(60): warning: illegal combination of integer (char) and pointer (pointer to char) [183]
+d_init_array_using_string.c(60): error: cannot initialize 'array[10] of const int' from 'pointer to char' [185]
 d_init_array_using_string.c(69): warning: non-null byte ignored in string initializer [187]
 d_init_array_using_string.c(70): warning: non-null byte ignored in string initializer [187]
 d_init_array_using_string.c(74): warning: illegal combination of integer (char) and pointer (pointer to char) [183]
 d_init_array_using_string.c(75): warning: illegal combination of integer (int) and pointer (pointer to int) [183]

 @@ -1,15 +1,15 @@
 %{
-/* $NetBSD: cgram.y,v 1.206 2021/03/29 20:39:18 rillig Exp $ */
+/* $NetBSD: cgram.y,v 1.207 2021/03/30 14:25:28 rillig Exp $ */
 /*
  * Copyright (c) 1996 Christopher G. Demetriou.  All Rights Reserved.
  * Copyright (c) 1994, 1995 Jochen Pohl
  * All Rights Reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
 @@ -25,27 +25,27 @@
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #if defined(__RCSID) && !defined(lint)
-__RCSID("$NetBSD: cgram.y,v 1.206 2021/03/29 20:39:18 rillig Exp $");
+__RCSID("$NetBSD: cgram.y,v 1.207 2021/03/30 14:25:28 rillig Exp $");
 #endif
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 extern char *yytext;
 /*
  * Contains the level of current declaration, used for symbol table entries.
  * 0 is the top-level, > 0 is inside a function body.
 @@ -1335,27 +1335,27 @@ opt_asm_or_symbolrename:		/* expect only
 		$$ = NULL;
+	  }
 	| T_ASM T_LPAREN T_STRING T_RPAREN {
 		freeyyv(&$3, T_STRING);
 		$$ = NULL;
+	  }
 	| T_SYMBOLRENAME T_LPAREN T_NAME T_RPAREN {
 		$$ = $3;
+	  }
+	;
 initializer:			/* C99 6.7.8 "Initialization" */
 	  expr				%prec T_COMMA {
-		init_using_expr($1);
+		init_expr($1);
+	  }
 	| init_lbrace init_rbrace {
 		/* XXX: Empty braces are not covered by C99 6.7.8. */
+	  }
 	| init_lbrace initializer_list comma_opt init_rbrace
 	| error
+	;
 initializer_list:		/* C99 6.7.8 "Initialization" */
 	  initializer_list_item
 	| initializer_list T_COMMA initializer_list_item
+	;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: externs1.h,v 1.94 2021/03/28 13:09:43 rillig Exp $	*/
+/*	$NetBSD: externs1.h,v 1.95 2021/03/30 14:25:28 rillig Exp $	*/
 /*
  * Copyright (c) 1994, 1995 Jochen Pohl
  * All Rights Reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -282,33 +282,31 @@ extern	void	lintlib(int);
 extern	void	linted(int);
 extern	void	varargs(int);
 extern	void	printflike(int);
 extern	void	scanflike(int);
 extern	void	protolib(int);
 extern	void	longlong(int);
 extern	void	bitfieldtype(int);
 /*
  * init.c
  */
 extern	void	begin_initialization(sym_t *);
 extern	void	end_initialization(void);
 extern	bool	*current_initerr(void);
 extern	sym_t	**current_initsym(void);
 extern	void	initstack_init(void);
 extern	void	init_rbrace(void);
 extern	void	init_lbrace(void);
-extern	void	init_using_expr(tnode_t *);
+extern	void	init_expr(tnode_t *);
 extern	void	add_designator_member(sbuf_t *);
 extern	void	add_designator_subscript(range_t);
 /*
  * emit.c
  */
 extern	void	outtype(const type_t *);
 extern	const	char *ttos(const type_t *);
 extern	void	outsym(const sym_t *, scl_t, def_t);
 extern	void	outfdef(const sym_t *, const pos_t *, bool, bool,
 		    const sym_t *);
 extern	void	outcall(const tnode_t *, bool, bool);
 extern	void	outusg(const sym_t *);

 @@ -1,25 +1,25 @@
-/*	$NetBSD: d_c99_bool.c,v 1.6 2021/02/21 09:07:58 rillig Exp $	*/
+/*	$NetBSD: d_c99_bool.c,v 1.7 2021/03/30 14:25:28 rillig Exp $	*/
 # 3 "d_c99_bool.c"
 /*
  * C99 6.3.1.2 says: "When any scalar value is converted to _Bool, the result
  * is 0 if the value compares equal to 0; otherwise the result is 1."
+ *
  * This is different from the other integer types, which get truncated or
  * invoke undefined behavior.
  */
-/* Below, each wrong assertion produces "negative array dimension" [20]. */
+/* Below, each false statement produces "negative array dimension" [20]. */
 int int_0_converts_to_false[(_Bool)0 ? -1 : 1];
 int int_0_converts_to_true_[(_Bool)0 ? 1 : -1];			/* expect: 20 */
 int int_1_converts_to_false[(_Bool)1 ? -1 : 1];			/* expect: 20 */
 int int_1_converts_to_true_[(_Bool)1 ? 1 : -1];
 int int_2_converts_to_false[(_Bool)2 ? -1 : 1];			/* expect: 20 */
 int int_2_converts_to_true_[(_Bool)2 ? 1 : -1];
 int int_256_converts_to_false[(_Bool)256 ? -1 : 1];		/* expect: 20 */
 int int_256_converts_to_true_[(_Bool)256 ? 1 : -1];

 @@ -1,14 +1,14 @@
-/*	$NetBSD: d_init_pop_member.c,v 1.6 2021/03/19 17:40:37 rillig Exp $	*/
+/*	$NetBSD: d_init_pop_member.c,v 1.7 2021/03/30 14:25:28 rillig Exp $	*/
 # 3 "d_init_pop_member.c"
 /*
  * Since init.c 1.27 from 2015-07-28,
  * a bug in memberpop or pop_member led to a wrong error message
  * "undefined struct/union member: capital [101]" in the second and third
  * named initializer.
  */
 struct rgb {
 	unsigned red;
 	unsigned green;
 	unsigned blue;
 @@ -25,35 +25,35 @@ struct person {
 	struct rgb favorite_color;
 };
 struct city {
 	struct person mayor;
 };
 struct state {
 	struct city capital;
 };
 void func(void)
+{
-	struct state st = {
+	struct state st = {	/* expect: set but not used */
 	    .capital.mayor.hobbies.dancing = 1,
 	    /*
 	     * Since 2015-07-28:
 	     * wrong "undefined struct/union member: capital [101]"
 	     */
 	    /*
 	     * Before init.c 1.52 from 2020-01-01:
 	     * wrong "warning: bit-field initializer does not fit [180]"
 	     */
-	    .capital.mayor.favorite_color.green = 0xFF,	/*FIXME*//* expect: 101 */
+	    .capital.mayor.favorite_color.green = 0xFF,
 	    /*
 	     * Since 2015-07-28:
 	     * wrong "undefined struct/union member: capital [101]"
 	     */
 	    /*
 	     * Before init.c 1.52 from 2020-01-01:
 	     * wrong "warning: bit-field initializer does not fit [180]"
 	     */
-	    .capital.mayor.favorite_color.red = 0xFF, /*FIXME*//* expect: 101 */
+	    .capital.mayor.favorite_color.red = 0xFF,
 	};
+}