 @@ -1,14 +1,14 @@
-/*	$NetBSD: init.c,v 1.191 2021/04/02 14:19:33 rillig Exp $	*/
+/*	$NetBSD: init.c,v 1.192 2021/04/02 14:32:27 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
 @@ -28,27 +28,27 @@
  * 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.191 2021/04/02 14:19:33 rillig Exp $");
+__RCSID("$NetBSD: init.c,v 1.192 2021/04/02 14:32:27 rillig Exp $");
 #endif
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 /*
  * Initialization of global or local objects, like in:
+ *
  *	int number = 12345;
  *	int number_with_braces = { 12345 };
 @@ -112,31 +112,33 @@ struct designation {
 };
 /*
  * 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;
+	const sym_t	*bl_member;		/* for structs and unions */
 	size_t		bl_subscript;		/* for arrays */
 	bool		bl_scalar_done: 1;	/* for scalars */
 	bool		bl_confused: 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.
 	 * 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. */
 @@ -539,84 +541,80 @@ designation_reset(struct designation *dn
 	dn->dn_tail = NULL;
+}
 static struct brace_level *
 brace_level_new(const type_t *tp, struct brace_level *enclosing)
+{
 	struct brace_level *bl;
 	bl = xcalloc(1, sizeof(*bl));
 	bl->bl_type = tp;
 	bl->bl_enclosing = enclosing;
 	if (is_struct_or_union(tp->t_tspec))
-		bl->bl_next_member = first_named_member(tp);
+		bl->bl_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
 static void
 brace_level_debug(const struct brace_level *bl)
+{
 	lint_assert(bl->bl_type != NULL);
-	lint_assert(bl->bl_next_member == NULL ||
+	lint_assert(bl->bl_member == NULL || !is_unnamed(bl->bl_member));
 	    !is_unnamed(bl->bl_next_member));
 	debug_printf("type '%s'", type_name(bl->bl_type));
-	if (is_struct_or_union(bl->bl_type->t_tspec) &&
+	if (is_struct_or_union(bl->bl_type->t_tspec) && bl->bl_member != NULL)
-	    bl->bl_next_member != NULL)
+		debug_printf(", member '%s'", bl->bl_member->s_name);
 		debug_printf(", next member '%s'",
 		    bl->bl_next_member->s_name);
 	if (bl->bl_type->t_tspec == ARRAY)
-		debug_printf(", next array subscript %zu",
+		debug_printf(", subscript %zu", bl->bl_subscript);
 		    bl->bl_array_next_subscript);
 	debug_printf("\n");
+}
 #else
 #define brace_level_debug(level) do { } while (false)
 #endif
 static const type_t *
 brace_level_sub_type_struct_or_union(const struct brace_level *bl)
+{
-	if (bl->bl_next_member == NULL) {
+	if (bl->bl_member == NULL) {
 		/* too many struct/union initializers */
 		error(172);
 		return NULL;
+	}
-	lint_assert(!is_unnamed(bl->bl_next_member));
+	lint_assert(!is_unnamed(bl->bl_member));
-	return sym_type(bl->bl_next_member);
+	return sym_type(bl->bl_member);
+}
 static const type_t *
 brace_level_sub_type_array(const struct brace_level *bl)
+{
 	if (!bl->bl_confused && !bl->bl_type->t_incomplete_array &&
-	    bl->bl_array_next_subscript >= (size_t)bl->bl_type->t_dim) {
+	    bl->bl_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 const type_t *
 brace_level_sub_type_scalar(const struct brace_level *bl)
+{
 	if (bl->bl_scalar_done) {
 		/* too many initializers */
 @@ -635,72 +633,73 @@ brace_level_sub_type(const struct brace_
 		return designation_look_up(&bl->bl_designation, bl->bl_type);
 	switch (bl->bl_type->t_tspec) {
 	case STRUCT:
 	case UNION:
 		return brace_level_sub_type_struct_or_union(bl);
 	case ARRAY:
 		return brace_level_sub_type_array(bl);
 	default:
 		return brace_level_sub_type_scalar(bl);
+	}
+}
 /* C99 6.7.8p17 */
 static void
 brace_level_apply_designation(struct brace_level *bl)
+{
 	const struct designator *dr = bl->bl_designation.dn_head;
 	if (dr == NULL)
 		return;
 	designation_debug(&bl->bl_designation);
 	switch (bl->bl_type->t_tspec) {
 	case STRUCT:
 	case UNION:
 		if (dr->dr_name == NULL)
 			return;	/* error, silently ignored */
-		bl->bl_next_member = look_up_member(bl->bl_type, dr->dr_name);
+		bl->bl_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;
+		bl->bl_subscript = dr->dr_subscript;
 		break;
 	default:
 		break;		/* error, silently ignored */
+	}
+}
 /*
  * After initializing a sub-object, advance to the next sub-object.
+ *
  * C99 6.7.8p17
  */
 static void
 brace_level_advance(struct brace_level *bl)
+{
 	switch (bl->bl_type->t_tspec) {
 	case STRUCT:
-		lint_assert(bl->bl_next_member != NULL);
+		lint_assert(bl->bl_member != NULL);
-		bl->bl_next_member = skip_unnamed(bl->bl_next_member->s_next);
+		bl->bl_member = skip_unnamed(bl->bl_member->s_next);
 		break;
 	case UNION:
-		bl->bl_next_member = NULL;
+		bl->bl_member = NULL;
 		break;
 	case ARRAY:
-		bl->bl_array_next_subscript++;
+		bl->bl_subscript++;
 		break;
 	default:
 		bl->bl_scalar_done = true;
 		break;
+	}
+}
 static struct initialization *
 initialization_new(sym_t *sym)
+{
 	struct initialization *in;
 @@ -803,27 +802,27 @@ initialization_begin_brace_level(struct
 done:
 	initialization_debug(in);
 	debug_leave();
+}
 /* C99 6.7.8p22 */
 static void
 initialization_set_size_of_unknown_array(struct initialization *in)
+{
 	if (in->in_sym->s_type->t_incomplete_array &&
 	    in->in_brace_level->bl_enclosing == NULL)
 		update_type_of_array_of_unknown_size(in->in_sym,
-		    in->in_brace_level->bl_array_next_subscript);
+		    in->in_brace_level->bl_subscript);
+}
 static void
 initialization_end_brace_level(struct initialization *in)
+{
 	struct brace_level *bl;
 	if (in->in_err)
 		return;
 	debug_enter();
 	initialization_set_size_of_unknown_array(in);
 @@ -890,38 +889,37 @@ initialization_init_array_using_string(s
 	struct brace_level *bl;
 	const type_t *tp;
 	strg_t	*strg;
 	if (tn->tn_op != STRING)
 		return false;
 	bl = in->in_brace_level;
 	tp = initialization_sub_type(in);
 	strg = tn->tn_string;
 	if (!is_string_array(tp, strg->st_tspec))
 		return false;
-	if (bl != NULL && tp->t_tspec != ARRAY &&
+	if (bl != NULL && tp->t_tspec != ARRAY && bl->bl_subscript != 0)
 	    bl->bl_array_next_subscript != 0)
 		return false;
 	if (bl != NULL && tp->t_dim < (int)strg->st_len) {
 		/* non-null byte ignored in string initializer */
 		warning(187);
+	}
 	if (tp == in->in_sym->s_type && tp->t_incomplete_array) {
 		if (bl != NULL) {
-			bl->bl_array_next_subscript = strg->st_len + 1;
+			bl->bl_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);
+	}
 	return true;
+}
 /*
  * Initialize a single sub-object as part of the currently ongoing
  * initialization.
  */