 @@ -1,14 +1,14 @@
-/*	$NetBSD: init.c,v 1.177 2021/03/29 21:09:21 rillig Exp $	*/
+/*	$NetBSD: init.c,v 1.178 2021/03/29 21:34:17 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.
 @@ -27,27 +27,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.177 2021/03/29 21:09:21 rillig Exp $");
+__RCSID("$NetBSD: init.c,v 1.178 2021/03/29 21:34:17 rillig Exp $");
 #endif
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 /*
  * Initialization
+ *
  * Handles initializations of global or local objects, like in:
+ *
 @@ -532,271 +532,271 @@ designation_shift_level(struct designati
 		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,
 		struct brace_level *enclosing)
+{
-	struct brace_level *level = xcalloc(1, sizeof(*level));
+	struct brace_level *bl = xcalloc(1, sizeof(*bl));
-	level->bl_type = type;
+	bl->bl_type = type;
-	level->bl_subtype = subtype;
+	bl->bl_subtype = subtype;
-	level->bl_remaining = remaining;
+	bl->bl_remaining = remaining;
-	level->bl_enclosing = enclosing;
+	bl->bl_enclosing = enclosing;
-	return level;
+	return bl;
+}
 static void
-brace_level_free(struct brace_level *level)
+brace_level_free(struct brace_level *bl)
+{
-	free(level);
+	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 *level)
+brace_level_debug(const struct brace_level *bl)
+{
-	if (level->bl_type != NULL)
+	if (bl->bl_type != NULL)
-		debug_printf("type '%s'", type_name(level->bl_type));
+		debug_printf("type '%s'", type_name(bl->bl_type));
-	if (level->bl_type != NULL && level->bl_subtype != NULL)
+	if (bl->bl_type != NULL && bl->bl_subtype != NULL)
 		debug_printf(", ");
-	if (level->bl_subtype != NULL)
+	if (bl->bl_subtype != NULL)
-		debug_printf("subtype '%s'", type_name(level->bl_subtype));
+		debug_printf("subtype '%s'", type_name(bl->bl_subtype));
-	if (level->bl_brace)
+	if (bl->bl_brace)
 		debug_printf(", needs closing brace");
-	if (level->bl_array_of_unknown_size)
+	if (bl->bl_array_of_unknown_size)
 		debug_printf(", array of unknown size");
-	if (level->bl_seen_named_member)
+	if (bl->bl_seen_named_member)
 		debug_printf(", seen named member");
-	const type_t *eff_type = level->bl_type != NULL
+	const type_t *eff_type = bl->bl_type != NULL
-	    ? level->bl_type : level->bl_subtype;
+	    ? bl->bl_type : bl->bl_subtype;
-	if (eff_type->t_tspec == STRUCT && level->bl_next_member != NULL)
+	if (eff_type->t_tspec == STRUCT && bl->bl_next_member != NULL)
 		debug_printf(", next member '%s'",
-		    level->bl_next_member->s_name);
+		    bl->bl_next_member->s_name);
-	debug_printf(", remaining %d\n", level->bl_remaining);
+	debug_printf(", remaining %d\n", bl->bl_remaining);
+}
 #else
-#define brace_level_debug(level) do { } while (false)
+#define brace_level_debug(bl) do { } while (false)
 #endif
 static void
-brace_level_assert_struct_or_union(const struct brace_level *level)
+brace_level_assert_struct_or_union(const struct brace_level *bl)
+{
-	lint_assert(is_struct_or_union(level->bl_type->t_tspec));
+	lint_assert(is_struct_or_union(bl->bl_type->t_tspec));
+}
 static void
-brace_level_assert_array(const struct brace_level *level)
+brace_level_assert_array(const struct brace_level *bl)
+{
-	lint_assert(level->bl_type->t_tspec == ARRAY);
+	lint_assert(bl->bl_type->t_tspec == ARRAY);
+}
 static type_t *
-brace_level_subtype(struct brace_level *level)
+brace_level_subtype(struct brace_level *bl)
+{
-	if (level->bl_subtype != NULL)
+	if (bl->bl_subtype != NULL)
-		return level->bl_subtype;
+		return bl->bl_subtype;
-	return level->bl_type;
+	return bl->bl_type;
+}
 static void
-brace_level_set_array_dimension(struct brace_level *level, int dim)
+brace_level_set_array_dimension(struct brace_level *bl, int dim)
+{
-	brace_level_assert_array(level);
+	brace_level_assert_array(bl);
 	debug_step("setting the array size to %d", dim);
-	level->bl_type->t_dim = dim;
+	bl->bl_type->t_dim = dim;
 	debug_indent();
-	brace_level_debug(level);
+	brace_level_debug(bl);
+}
 static void
-brace_level_next_member(struct brace_level *level)
+brace_level_next_member(struct brace_level *bl)
+{
 	const sym_t *m;
-	brace_level_assert_struct_or_union(level);
+	brace_level_assert_struct_or_union(bl);
 	do {
-		m = level->bl_next_member = level->bl_next_member->s_next;
+		m = bl->bl_next_member = bl->bl_next_member->s_next;
 		/* XXX: can this assertion be made to fail? */
 		lint_assert(m != NULL);
 	} while (m->s_bitfield && m->s_name == unnamed);
 	debug_indent();
-	brace_level_debug(level);
+	brace_level_debug(bl);
+}
 static const sym_t *
-brace_level_look_up_member(const struct brace_level *level, const char *name)
+brace_level_look_up_member(const struct brace_level *bl, const char *name)
+{
-	brace_level_assert_struct_or_union(level);
+	brace_level_assert_struct_or_union(bl);
-	return look_up_member(level->bl_type->t_str->sou_first_member, name);
+	return look_up_member(bl->bl_type->t_str->sou_first_member, name);
+}
 static sym_t *
-brace_level_look_up_first_member_named(struct brace_level *level,
+brace_level_look_up_first_member_named(struct brace_level *bl,
 				       const char *name, int *count)
+{
 	sym_t *m;
-	for (m = level->bl_type->t_str->sou_first_member;
+	for (m = bl->bl_type->t_str->sou_first_member;
 	     m != NULL; m = m->s_next) {
 		if (is_unnamed_member(m))
 			continue;
 		if (strcmp(m->s_name, name) != 0)
 			continue;
 		(*count)++;
 		break;
+	}
 	return m;
+}
 static sym_t *
-brace_level_look_up_first_member_unnamed(struct brace_level *level, int *count)
+brace_level_look_up_first_member_unnamed(struct brace_level *bl, int *count)
+{
 	sym_t *m;
-	brace_level_assert_struct_or_union(level);
+	brace_level_assert_struct_or_union(bl);
-	for (m = level->bl_type->t_str->sou_first_member;
+	for (m = bl->bl_type->t_str->sou_first_member;
 	     m != NULL; m = m->s_next) {
 		if (is_unnamed_member(m))
 			continue;
 		/* XXX: What is this code for? */
 		if (++(*count) == 1) {
-			level->bl_next_member = m;
+			bl->bl_next_member = m;
-			level->bl_subtype = m->s_type;
+			bl->bl_subtype = m->s_type;
+		}
+	}
 	return m;
+}
 /* TODO: document me */
 /* TODO: think of a better name than 'push' */
 static bool
-brace_level_push_array(struct brace_level *level)
+brace_level_push_array(struct brace_level *bl)
+{
-	brace_level_assert_array(level);
+	brace_level_assert_array(bl);
-	if (level->bl_enclosing->bl_seen_named_member) {
+	if (bl->bl_enclosing->bl_seen_named_member) {
-		level->bl_brace = true;
+		bl->bl_brace = true;
 		debug_step("ARRAY, seen named member, needs closing brace");
+	}
-	if (is_incomplete(level->bl_type) &&
+	if (is_incomplete(bl->bl_type) &&
-	    level->bl_enclosing->bl_enclosing != NULL) {
+	    bl->bl_enclosing->bl_enclosing != NULL) {
 		/* initialization of an incomplete type */
 		error(175);
 		return false;
+	}
-	level->bl_subtype = level->bl_type->t_subt;
+	bl->bl_subtype = bl->bl_type->t_subt;
-	level->bl_array_of_unknown_size = is_incomplete(level->bl_type);
+	bl->bl_array_of_unknown_size = is_incomplete(bl->bl_type);
-	level->bl_remaining = level->bl_type->t_dim;
+	bl->bl_remaining = bl->bl_type->t_dim;
 	debug_step("type '%s' remaining %d",
-	    type_name(level->bl_type), level->bl_remaining);
+	    type_name(bl->bl_type), bl->bl_remaining);
 	return true;
+}
 /*
  * If the removed element was a structure member, we must go
  * to the next structure member.
+ *
  * XXX: Nothing should ever be "removed" at this point.
+ *
  * TODO: think of a better name than 'pop'
  */
 static void
-brace_level_pop_item_unnamed(struct brace_level *level)
+brace_level_pop_item_unnamed(struct brace_level *bl)
+{
-	if (level->bl_remaining > 0 && level->bl_type->t_tspec == STRUCT &&
+	if (bl->bl_remaining > 0 && bl->bl_type->t_tspec == STRUCT &&
-	    !level->bl_seen_named_member) {
+	    !bl->bl_seen_named_member) {
-		brace_level_next_member(level);
+		brace_level_next_member(bl);
-		level->bl_subtype = level->bl_next_member->s_type;
+		bl->bl_subtype = bl->bl_next_member->s_type;
+	}
+}
 static bool
-brace_level_check_too_many_initializers(struct brace_level *level)
+brace_level_check_too_many_initializers(struct brace_level *bl)
+{
-	if (level->bl_remaining > 0)
+	if (bl->bl_remaining > 0)
 		return true;
 	/*
 	 * FIXME: even with named members, there can be too many initializers
 	 */
-	if (level->bl_array_of_unknown_size || level->bl_seen_named_member)
+	if (bl->bl_array_of_unknown_size || bl->bl_seen_named_member)
 		return true;
-	tspec_t t = level->bl_type->t_tspec;
+	tspec_t t = bl->bl_type->t_tspec;
 	if (t == ARRAY) {
 		/* too many array initializers, expected %d */
-		error(173, level->bl_type->t_dim);
+		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 *level)
+brace_level_extend_if_array_of_unknown_size(struct brace_level *bl)
+{
-	if (level->bl_remaining != 0)
+	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 level of the object to be initialized.
+	 * outermost aggregate bl of the object to be initialized.
 	 */
-	lint_assert(level->bl_enclosing->bl_enclosing == NULL);
+	lint_assert(bl->bl_enclosing->bl_enclosing == NULL);
-	lint_assert(level->bl_type->t_tspec == ARRAY);
+	lint_assert(bl->bl_type->t_tspec == ARRAY);
 	debug_step("extending array of unknown size '%s'",
-	    type_name(level->bl_type));
+	    type_name(bl->bl_type));
-	level->bl_remaining = 1;
+	bl->bl_remaining = 1;
-	level->bl_type->t_dim++;
+	bl->bl_type->t_dim++;
-	setcomplete(level->bl_type, true);
+	setcomplete(bl->bl_type, true);
-	debug_step("extended type is '%s'", type_name(level->bl_type));
+	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));
 	in->in_sym = sym;
 	return in;
+}
 @@ -816,31 +816,31 @@ initialization_free(struct initializatio
 #ifdef DEBUG
 /*
  * TODO: only call debug_initstack after each push/pop.
  */
 static void
 initialization_debug(const struct initialization *in)
+{
 	if (in->in_brace_level == NULL) {
 		debug_step("no brace level in the current initialization");
 		return;
+	}
 	size_t i = 0;
-	for (const struct brace_level *level = in->in_brace_level;
+	for (const struct brace_level *bl = in->in_brace_level;
-	     level != NULL; level = level->bl_enclosing) {
+	     bl != NULL; bl = bl->bl_enclosing) {
 		debug_indent();
 		debug_printf("brace level %zu: ", i);
-		brace_level_debug(level);
+		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
  * which is to be initialized on it.
+ *
  * TODO: merge into initialization_new if possible
  */
 @@ -867,212 +867,212 @@ initialization_init(struct initializatio
+}
 static void
 initialization_set_error(struct initialization *in)
+{
 	in->in_err = true;
+}
 /* TODO: document me */
 /* TODO: think of a better name than 'push' */
 static bool
 initialization_push_struct_or_union(struct initialization *in)
+{
-	struct brace_level *level = in->in_brace_level;
+	struct brace_level *bl = in->in_brace_level;
 	int cnt;
 	sym_t *m;
-	if (is_incomplete(level->bl_type)) {
+	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(level->bl_type),
+	    type_name(bl->bl_type),
-	    level->bl_seen_named_member ? ", seen named member" : "");
+	    bl->bl_seen_named_member ? ", seen named member" : "");
 	if (in->in_designation.dn_head != NULL)
-		m = brace_level_look_up_first_member_named(level,
+		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(level, &cnt);
+		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;
+		}
-		level->bl_next_member = m;
+		bl->bl_next_member = m;
-		level->bl_subtype = m->s_type;
+		bl->bl_subtype = m->s_type;
-		level->bl_seen_named_member = true;
+		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 = level->bl_type->t_tspec == STRUCT ? 2 : 1;
+		cnt = bl->bl_type->t_tspec == STRUCT ? 2 : 1;
+	}
-	level->bl_brace = true;
+	bl->bl_brace = true;
 	debug_step("unnamed element with type '%s'%s",
 	    type_name(
-		level->bl_type != NULL ? level->bl_type : level->bl_subtype),
+		bl->bl_type != NULL ? bl->bl_type : bl->bl_subtype),
-	    level->bl_brace ? ", needs closing brace" : "");
+	    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;
+	}
-	level->bl_remaining = level->bl_type->t_tspec == STRUCT ? cnt : 1;
+	bl->bl_remaining = bl->bl_type->t_tspec == STRUCT ? cnt : 1;
 	return false;
+}
 static void
 initialization_end_brace_level(struct initialization *in)
+{
-	struct brace_level *level = in->in_brace_level;
+	struct brace_level *bl = in->in_brace_level;
-	in->in_brace_level = level->bl_enclosing;
+	in->in_brace_level = bl->bl_enclosing;
-	brace_level_free(level);
+	brace_level_free(bl);
+}
 /* TODO: document me */
 /* TODO: think of a better name than 'push' */
 static void
 initialization_push(struct initialization *in)
+{
-	struct brace_level *level;
+	struct brace_level *bl;
 	debug_enter();
 	brace_level_extend_if_array_of_unknown_size(in->in_brace_level);
-	level = in->in_brace_level;
+	bl = in->in_brace_level;
-	lint_assert(level->bl_remaining > 0);
+	lint_assert(bl->bl_remaining > 0);
-	in->in_brace_level = brace_level_new(brace_level_subtype(level), NULL, 0,
+	in->in_brace_level = brace_level_new(brace_level_subtype(bl), NULL, 0,
-	    level);
+	    bl);
 	lint_assert(in->in_brace_level->bl_type != NULL);
 	lint_assert(in->in_brace_level->bl_type->t_tspec != FUNC);
 again:
-	level = in->in_brace_level;
+	bl = in->in_brace_level;
-	debug_step("expecting type '%s'", type_name(level->bl_type));
+	debug_step("expecting type '%s'", type_name(bl->bl_type));
-	lint_assert(level->bl_type != NULL);
+	lint_assert(bl->bl_type != NULL);
-	switch (level->bl_type->t_tspec) {
+	switch (bl->bl_type->t_tspec) {
 	case ARRAY:
 		if (in->in_designation.dn_head != NULL) {
 			debug_step("pop array, named member '%s'%s",
 			    in->in_designation.dn_head->dr_name,
-			    level->bl_brace ? ", needs closing brace" : "");
+			    bl->bl_brace ? ", needs closing brace" : "");
 			goto pop;
+		}
-		if (!brace_level_push_array(level))
+		if (!brace_level_push_array(bl))
 			initialization_set_error(in);
 		break;
 	case UNION:
 		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. */
-		level->bl_remaining = 1;
+		bl->bl_remaining = 1;
 		break;
+	}
 	initialization_debug(in);
 	debug_leave();
+}
 /* TODO: document me */
 static void
 initialization_pop_item_named(struct initialization *in, const char *name)
+{
-	struct brace_level *level = in->in_brace_level;
+	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(level->bl_type->t_tspec)) {
+	if (!is_struct_or_union(bl->bl_type->t_tspec)) {
 		/* syntax error '%s' */
 		error(249, "named member must only be used with struct/union");
 		initialization_set_error(in);
 		return;
+	}
-	m = brace_level_look_up_member(level, name);
+	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);
-		level->bl_seen_named_member = true;
+		bl->bl_seen_named_member = true;
 		return;
+	}
 	debug_step("found matching member");
-	level->bl_subtype = m->s_type;
+	bl->bl_subtype = m->s_type;
 	/* XXX: why ++? */
-	level->bl_remaining++;
+	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)
+{
-	struct brace_level *level;
+	struct brace_level *bl;
 	debug_enter();
-	level = in->in_brace_level;
+	bl = in->in_brace_level;
 	debug_indent();
 	debug_printf("popping: ");
-	brace_level_debug(level);
+	brace_level_debug(bl);
-	in->in_brace_level = level->bl_enclosing;
+	in->in_brace_level = bl->bl_enclosing;
-	brace_level_free(level);
+	brace_level_free(bl);
-	level = in->in_brace_level;
+	bl = in->in_brace_level;
-	lint_assert(level != NULL);
+	lint_assert(bl != NULL);
-	level->bl_remaining--;
+	bl->bl_remaining--;
-	lint_assert(level->bl_remaining >= 0);
+	lint_assert(bl->bl_remaining >= 0);
-	debug_step("%d elements remaining", level->bl_remaining);
+	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(level);
+		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)
+{
 @@ -1107,35 +1107,35 @@ initialization_next_brace(struct initial
 	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 *level)
+check_no_auto_aggregate(scl_t sclass, const struct brace_level *bl)
+{
 	if (!tflag)
 		return;
 	if (!(sclass == AUTO || sclass == REG))
 		return;
-	if (!(level->bl_enclosing == NULL))
+	if (!(bl->bl_enclosing == NULL))
 		return;
-	if (is_scalar(level->bl_subtype->t_tspec))
+	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();
 @@ -1192,111 +1192,111 @@ initialization_rbrace(struct initializat
+ *
  * TODO: test the following initialization with an outer and an inner type:
+ *
  * .deeply[0].nested = {
  *	.deeply[1].nested = {
  *		12345,
  *	},
  * }
  */
 static void
 initialization_add_designator_subscript(struct initialization *in,
 					range_t range)
+{
-	struct brace_level *level;
+	struct brace_level *bl;
 	debug_enter();
 	if (range.lo == range.hi)
 		debug_step("subscript is %zu", range.hi);
 	else
 		debug_step("subscript range is %zu ... %zu",
 		    range.lo, range.hi);
 	/* XXX: This call is wrong here, it must be somewhere else. */
 	initialization_pop_nobrace(in);
-	level = in->in_brace_level;
+	bl = in->in_brace_level;
-	if (level->bl_array_of_unknown_size) {
+	if (bl->bl_array_of_unknown_size) {
 		/* No +1 here, extend_if_array_of_unknown_size will add it. */
 		int auto_dim = (int)range.hi;
-		if (auto_dim > level->bl_type->t_dim)
+		if (auto_dim > bl->bl_type->t_dim)
-			brace_level_set_array_dimension(level, auto_dim);
+			brace_level_set_array_dimension(bl, auto_dim);
+	}
 	debug_leave();
+}
 /* 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 *level;
+	struct brace_level *bl;
 	strg_t	*strg;
 	if (tn->tn_op != STRING)
 		return false;
 	debug_enter();
-	level = in->in_brace_level;
+	bl = in->in_brace_level;
 	strg = tn->tn_string;
 	/*
 	 * Check if we have an array type which can be initialized by
 	 * the string.
 	 */
-	if (is_string_array(level->bl_subtype, strg->st_tspec)) {
+	if (is_string_array(bl->bl_subtype, strg->st_tspec)) {
 		debug_step("subtype is an array");
 		/* Put the array at top of stack */
 		initialization_push(in);
-		level = in->in_brace_level;
+		bl = in->in_brace_level;
-	} else if (is_string_array(level->bl_type, strg->st_tspec)) {
+	} 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 (level->bl_remaining != level->bl_type->t_dim)
+		if (bl->bl_remaining != bl->bl_type->t_dim)
 			goto nope;
 	} else
 		goto nope;
-	if (level->bl_array_of_unknown_size) {
+	if (bl->bl_array_of_unknown_size) {
-		level->bl_array_of_unknown_size = false;
+		bl->bl_array_of_unknown_size = false;
-		level->bl_type->t_dim = (int)(strg->st_len + 1);
+		bl->bl_type->t_dim = (int)(strg->st_len + 1);
-		setcomplete(level->bl_type, true);
+		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 (level->bl_type->t_dim < (int)strg->st_len) {
+		if (bl->bl_type->t_dim < (int)strg->st_len) {
 			/* non-null byte ignored in string initializer */
 			warning(187);
+		}
 		/*
 		 * TODO: C99 6.7.8p14 allows a string literal to be enclosed
 		 * in optional redundant braces, just like scalars.  Add tests
 		 * for this.
 		 */
+	}
 	/* In every case the array is initialized completely. */
-	level->bl_remaining = 0;
+	bl->bl_remaining = 0;
 	initialization_debug(in);
 	debug_leave();
 	return true;
 nope:
 	debug_leave();
 	return false;
+}
 /*
  * Initialize a non-array object with automatic storage duration and only a
  * single initializer expression without braces by delegating to ASSIGN.
  */
 @@ -1331,39 +1331,39 @@ initialization_next_nobrace(struct initi
 	if (in->in_brace_level->bl_type == NULL &&
 	    !is_scalar(in->in_brace_level->bl_subtype->t_tspec)) {
 		/* {}-enclosed initializer required */
 		error(181);
 		/* XXX: maybe set initerr here */
+	}
 	if (!in->in_err &&
 	    !brace_level_check_too_many_initializers(in->in_brace_level))
 		initialization_set_error(in);
 	while (!in->in_err) {
-		struct brace_level *level = in->in_brace_level;
+		struct brace_level *bl = in->in_brace_level;
 		if (tn->tn_type->t_tspec == STRUCT &&
-		    level->bl_type == tn->tn_type &&
+		    bl->bl_type == tn->tn_type &&
-		    level->bl_enclosing != NULL &&
+		    bl->bl_enclosing != NULL &&
-		    level->bl_enclosing->bl_enclosing != NULL) {
+		    bl->bl_enclosing->bl_enclosing != NULL) {
-			level->bl_brace = false;
+			bl->bl_brace = false;
-			level->bl_remaining = 1; /* the struct itself */
+			bl->bl_remaining = 1; /* the struct itself */
 			break;
+		}
-		if (level->bl_type != NULL &&
+		if (bl->bl_type != NULL &&
-		    is_scalar(level->bl_type->t_tspec))
+		    is_scalar(bl->bl_type->t_tspec))
 			break;
 		initialization_push(in);
+	}
 	initialization_debug(in);
 	debug_leave();
+}
 static void
 initialization_expr(struct initialization *in, tnode_t *tn)
+{
 	debug_enter();