Module Name: src
Committed By: rillig
Date: Mon Mar 29 21:34:17 UTC 2021
Modified Files:
src/usr.bin/xlint/lint1: init.c
Log Message:
lint: rename variable 'level' to 'bl'
For consistency with its type prefix and the other variables. This
variable is used so often that it makes sense to abbreviate it.
No functional change.
To generate a diff of this commit:
cvs rdiff -u -r1.177 -r1.178 src/usr.bin/xlint/lint1/init.c
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
Modified files:
Index: src/usr.bin/xlint/lint1/init.c
diff -u src/usr.bin/xlint/lint1/init.c:1.177 src/usr.bin/xlint/lint1/init.c:1.178
--- src/usr.bin/xlint/lint1/init.c:1.177 Mon Mar 29 21:09:21 2021
+++ src/usr.bin/xlint/lint1/init.c Mon Mar 29 21:34:17 2021
@@ -1,4 +1,4 @@
-/* $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
@@ -37,7 +37,7 @@
#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>
@@ -542,20 +542,20 @@ 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;
- level->bl_subtype = subtype;
- level->bl_remaining = remaining;
- level->bl_enclosing = enclosing;
+ bl->bl_type = type;
+ bl->bl_subtype = subtype;
+ bl->bl_remaining = remaining;
+ 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
@@ -565,98 +565,98 @@ brace_level_free(struct brace_level *lev
* 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)
- debug_printf("type '%s'", type_name(level->bl_type));
- if (level->bl_type != NULL && level->bl_subtype != NULL)
+ 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 (level->bl_subtype != NULL)
- debug_printf("subtype '%s'", type_name(level->bl_subtype));
+ if (bl->bl_subtype != NULL)
+ 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
- ? level->bl_type : level->bl_subtype;
- if (eff_type->t_tspec == STRUCT && level->bl_next_member != NULL)
+ const type_t *eff_type = bl->bl_type != NULL
+ ? bl->bl_type : bl->bl_subtype;
+ 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)
- return level->bl_subtype;
+ if (bl->bl_subtype != NULL)
+ 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);
- return look_up_member(level->bl_type->t_str->sou_first_member, name);
+ brace_level_assert_struct_or_union(bl);
+ 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;
@@ -670,20 +670,20 @@ brace_level_look_up_first_member_named(s
}
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;
- level->bl_subtype = m->s_type;
+ bl->bl_next_member = m;
+ bl->bl_subtype = m->s_type;
}
}
@@ -693,27 +693,27 @@ brace_level_look_up_first_member_unnamed
/* 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) {
- level->bl_brace = true;
+ if (bl->bl_enclosing->bl_seen_named_member) {
+ bl->bl_brace = true;
debug_step("ARRAY, seen named member, needs closing brace");
}
- if (is_incomplete(level->bl_type) &&
- level->bl_enclosing->bl_enclosing != NULL) {
+ if (is_incomplete(bl->bl_type) &&
+ bl->bl_enclosing->bl_enclosing != NULL) {
/* initialization of an incomplete type */
error(175);
return false;
}
- level->bl_subtype = level->bl_type->t_subt;
- level->bl_array_of_unknown_size = is_incomplete(level->bl_type);
- level->bl_remaining = level->bl_type->t_dim;
+ bl->bl_subtype = bl->bl_type->t_subt;
+ bl->bl_array_of_unknown_size = is_incomplete(bl->bl_type);
+ 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;
}
@@ -726,30 +726,30 @@ brace_level_push_array(struct brace_leve
* 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 &&
- !level->bl_seen_named_member) {
- brace_level_next_member(level);
- level->bl_subtype = level->bl_next_member->s_type;
+ 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
-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);
@@ -762,10 +762,10 @@ brace_level_check_too_many_initializers(
/* 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
@@ -775,18 +775,18 @@ brace_level_extend_if_array_of_unknown_s
/*
* 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(level->bl_type->t_tspec == ARRAY);
+ 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(level->bl_type));
- level->bl_remaining = 1;
- level->bl_type->t_dim++;
- setcomplete(level->bl_type, true);
+ 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(level->bl_type));
+ debug_step("extended type is '%s'", type_name(bl->bl_type));
}
@@ -826,11 +826,11 @@ initialization_debug(const struct initia
}
size_t i = 0;
- for (const struct brace_level *level = in->in_brace_level;
- level != NULL; level = level->bl_enclosing) {
+ for (const struct brace_level *bl = in->in_brace_level;
+ bl != NULL; bl = bl->bl_enclosing) {
debug_indent();
debug_printf("brace level %zu: ", i);
- brace_level_debug(level);
+ brace_level_debug(bl);
i++;
}
}
@@ -877,11 +877,11 @@ initialization_set_error(struct initiali
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);
@@ -891,49 +891,49 @@ initialization_push_struct_or_union(stru
cnt = 0;
designation_debug(&in->in_designation);
debug_step("lookup for '%s'%s",
- type_name(level->bl_type),
- level->bl_seen_named_member ? ", seen named member" : "");
+ 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(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;
- level->bl_subtype = m->s_type;
- level->bl_seen_named_member = 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 = 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),
- level->bl_brace ? ", needs closing brace" : "");
+ 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;
}
- 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;
- in->in_brace_level = level->bl_enclosing;
- brace_level_free(level);
+ struct brace_level *bl = in->in_brace_level;
+ in->in_brace_level = bl->bl_enclosing;
+ brace_level_free(bl);
}
/* TODO: document me */
@@ -941,35 +941,35 @@ initialization_end_brace_level(struct in
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;
- lint_assert(level->bl_remaining > 0);
+ bl = in->in_brace_level;
+ lint_assert(bl->bl_remaining > 0);
- in->in_brace_level = brace_level_new(brace_level_subtype(level), NULL, 0,
- level);
+ in->in_brace_level = brace_level_new(brace_level_subtype(bl), NULL, 0,
+ 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));
- lint_assert(level->bl_type != NULL);
- switch (level->bl_type->t_tspec) {
+ debug_step("expecting type '%s'", type_name(bl->bl_type));
+ lint_assert(bl->bl_type != NULL);
+ 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;
@@ -990,7 +990,7 @@ again:
goto again;
}
/* The initialization stack now expects a single scalar. */
- level->bl_remaining = 1;
+ bl->bl_remaining = 1;
break;
}
@@ -1002,7 +1002,7 @@ again:
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;
/*
@@ -1011,28 +1011,28 @@ initialization_pop_item_named(struct ini
*/
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);
}
@@ -1041,28 +1041,28 @@ initialization_pop_item_named(struct ini
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;
- brace_level_free(level);
- level = in->in_brace_level;
- lint_assert(level != NULL);
-
- level->bl_remaining--;
- lint_assert(level->bl_remaining >= 0);
- debug_step("%d elements remaining", level->bl_remaining);
+ 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(level);
+ brace_level_pop_item_unnamed(bl);
initialization_debug(in);
debug_leave();
@@ -1117,15 +1117,15 @@ initialization_next_brace(struct initial
}
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 */
@@ -1202,7 +1202,7 @@ 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)
@@ -1214,12 +1214,12 @@ initialization_add_designator_subscript(
/* XXX: This call is wrong here, it must be somewhere else. */
initialization_pop_nobrace(in);
- level = in->in_brace_level;
- if (level->bl_array_of_unknown_size) {
+ bl = in->in_brace_level;
+ 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)
- brace_level_set_array_dimension(level, auto_dim);
+ if (auto_dim > bl->bl_type->t_dim)
+ brace_level_set_array_dimension(bl, auto_dim);
}
debug_leave();
@@ -1229,7 +1229,7 @@ initialization_add_designator_subscript(
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)
@@ -1237,43 +1237,43 @@ initialization_init_array_using_string(s
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) {
- level->bl_array_of_unknown_size = false;
- level->bl_type->t_dim = (int)(strg->st_len + 1);
- setcomplete(level->bl_type, true);
+ 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 (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);
}
@@ -1286,7 +1286,7 @@ initialization_init_array_using_string(s
}
/* In every case the array is initialized completely. */
- level->bl_remaining = 0;
+ bl->bl_remaining = 0;
initialization_debug(in);
debug_leave();
@@ -1341,19 +1341,19 @@ initialization_next_nobrace(struct initi
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 &&
- level->bl_enclosing != NULL &&
- level->bl_enclosing->bl_enclosing != NULL) {
- level->bl_brace = false;
- level->bl_remaining = 1; /* the struct itself */
+ bl->bl_type == tn->tn_type &&
+ bl->bl_enclosing != NULL &&
+ bl->bl_enclosing->bl_enclosing != NULL) {
+ bl->bl_brace = false;
+ bl->bl_remaining = 1; /* the struct itself */
break;
}
- if (level->bl_type != NULL &&
- is_scalar(level->bl_type->t_tspec))
+ if (bl->bl_type != NULL &&
+ is_scalar(bl->bl_type->t_tspec))
break;
initialization_push(in);
}
