 @@ -1,14 +1,14 @@
-/* $NetBSD: decl.c,v 1.363 2023/07/28 21:50:03 rillig Exp $ */
+/* $NetBSD: decl.c,v 1.364 2023/07/29 07:03:19 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
 @@ -28,69 +28,51 @@
  * 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)
-__RCSID("$NetBSD: decl.c,v 1.363 2023/07/28 21:50:03 rillig Exp $");
+__RCSID("$NetBSD: decl.c,v 1.364 2023/07/29 07:03:19 rillig Exp $");
 #endif
 #include <sys/param.h>
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 const char unnamed[] = "<unnamed>";
 /* shared type structures for arithmetic types and void */
 static	type_t	typetab[NTSPEC];
 /* value of next enumerator during declaration of enum types */
 int	enumval;
 /*
  * Points to the innermost element of a stack that contains information about
  * nested declarations, such as struct declarations, function prototypes,
  * local variables.
  */
 decl_level	*dcs;
 static	type_t	*typedef_error(type_t *, tspec_t);
 static	void	set_first_typedef(type_t *, sym_t *);
 static	void	dcs_align(unsigned int, unsigned int);
 static	sym_t	*new_tag(sym_t *, scl_t, bool, bool);
 static	bool	prototypes_compatible(const type_t *, const type_t *, bool *);
 static	bool	matches_no_arg_function(const type_t *, bool *);
 static	bool	check_old_style_definition(sym_t *, sym_t *);
 static	bool	check_prototype_declaration(sym_t *, sym_t *);
 static	void	check_prototype_parameters(sym_t *);
 static	void	old_style_function(sym_t *, sym_t *);
 static	void	declare_external_in_block(sym_t *);
 static	bool	check_init(sym_t *);
 static	void	check_argument_usage(bool, sym_t *);
 static	void	check_variable_usage(bool, sym_t *);
 static	void	check_label_usage(sym_t *);
 static	void	check_tag_usage(sym_t *);
 static	void	check_global_variable(const sym_t *);
 static	void	check_global_variable_size(const sym_t *);
 /*
  * initializes all global vars used in declarations
  */
 void
 initdecl(void)
+{
 	/* declaration stack */
 	dcs = xcalloc(1, sizeof(*dcs));
 	dcs->d_kind = DLK_EXTERN;
 	dcs->d_last_dlsym = &dcs->d_first_dlsym;
 @@ -223,26 +205,104 @@ dcs_add_storage_class(scl_t sc)
 	if (dcs->d_scl == NOSCL)
 		dcs->d_scl = sc;
 	else if ((dcs->d_scl == EXTERN && sc == THREAD_LOCAL)
 	    || (dcs->d_scl == THREAD_LOCAL && sc == EXTERN))
 		dcs->d_scl = EXTERN;	/* ignore thread_local */
 	else if ((dcs->d_scl == STATIC && sc == THREAD_LOCAL)
 	    || (dcs->d_scl == THREAD_LOCAL && sc == STATIC))
 		dcs->d_scl = STATIC;	/* ignore thread_local */
 	else
 		dcs->d_multiple_storage_classes = true;
+}
 /* Merge the signedness into the abstract type. */
 static tspec_t
 merge_signedness(tspec_t t, tspec_t s)
+{
 	if (s == SIGNED)
 		return t == CHAR ? SCHAR : t;
 	if (s != UNSIGN)
 		return t;
 	return t == CHAR ? UCHAR
 	    : t == SHORT ? USHORT
 	    : t == INT ? UINT
 	    : t == LONG ? ULONG
 	    : t == LLONG ? ULLONG
 	    : t;
+}
 /*
  * Called if a list of declaration specifiers contains a typedef name
  * and other specifiers (except struct, union, enum, typedef name).
  */
 static type_t *
 typedef_error(type_t *td, tspec_t t)
+{
 	tspec_t t2 = td->t_tspec;
 	if ((t == SIGNED || t == UNSIGN) &&
 	    (t2 == CHAR || t2 == SHORT || t2 == INT ||
 	     t2 == LONG || t2 == LLONG)) {
 		if (allow_c90)
 			/* modifying typedef with '%s'; only qualifiers... */
 			warning(5, tspec_name(t));
 		td = block_dup_type(gettyp(merge_signedness(t2, t)));
 		td->t_typedef = true;
 		return td;
+	}
 	if (t == SHORT && (t2 == INT || t2 == UINT)) {
 		/* modifying typedef with '%s'; only qualifiers allowed */
 		warning(5, "short");
 		td = block_dup_type(gettyp(t2 == INT ? SHORT : USHORT));
 		td->t_typedef = true;
 		return td;
+	}
 	if (t != LONG)
 		goto invalid;
 	if (t2 == INT)
 		td = gettyp(LONG);
 	else if (t2 == UINT)
 		td = gettyp(ULONG);
 	else if (t2 == LONG)
 		td = gettyp(LLONG);
 	else if (t2 == ULONG)
 		td = gettyp(ULLONG);
 	else if (t2 == FLOAT)
 		td = gettyp(DOUBLE);
 	else if (t2 == DOUBLE)
 		td = gettyp(LDOUBLE);
 	else if (t2 == DCOMPLEX)
 		td = gettyp(LCOMPLEX);
 	else
 		goto invalid;
 	/* modifying typedef with '%s'; only qualifiers allowed */
 	warning(5, "long");
 	td = block_dup_type(td);
 	td->t_typedef = true;
 	return td;
 invalid:
 	/* Anything else is not accepted. */
 	dcs->d_invalid_type_combination = true;
 	return td;
+}
 /*
  * Remember the type, modifier or typedef name returned by the parser in the
  * top element of the declaration stack. This information is used in
  * dcs_end_type to build the type used for all declarators in this declaration.
+ *
  * If tp->t_typedef is true, the type comes from a previously defined typename.
  * Otherwise, it comes from a type specifier (int, long, ...) or a
  * struct/union/enum tag.
  */
 void
 dcs_add_type(type_t *tp)
+{
 @@ -334,104 +394,26 @@ dcs_add_type(type_t *tp)
 			if (dcs->d_abstract_type != NO_TSPEC)
 				dcs->d_invalid_type_combination = true;
 			dcs->d_abstract_type = t;
+		}
 	} else if (t == PTR) {
 		dcs->d_type = tp;
 	} else {
 		if (dcs->d_abstract_type != NO_TSPEC)
 			dcs->d_invalid_type_combination = true;
 		dcs->d_abstract_type = t;
+	}
+}
 /* Merge the signedness into the abstract type. */
 static tspec_t
 merge_signedness(tspec_t t, tspec_t s)
 	if (s == SIGNED)
 		return t == CHAR ? SCHAR : t;
 	if (s != UNSIGN)
 		return t;
 	return t == CHAR ? UCHAR
 	    : t == SHORT ? USHORT
 	    : t == INT ? UINT
 	    : t == LONG ? ULONG
 	    : t == LLONG ? ULLONG
 	    : t;
 /*
  * Called if a list of declaration specifiers contains a typedef name
  * and other specifiers (except struct, union, enum, typedef name).
  */
 static type_t *
 typedef_error(type_t *td, tspec_t t)
 	tspec_t t2 = td->t_tspec;
 	if ((t == SIGNED || t == UNSIGN) &&
 	    (t2 == CHAR || t2 == SHORT || t2 == INT ||
 	     t2 == LONG || t2 == LLONG)) {
 		if (allow_c90)
 			/* modifying typedef with '%s'; only qualifiers... */
 			warning(5, tspec_name(t));
 		td = block_dup_type(gettyp(merge_signedness(t2, t)));
 		td->t_typedef = true;
 		return td;
 	if (t == SHORT && (t2 == INT || t2 == UINT)) {
 		/* modifying typedef with '%s'; only qualifiers allowed */
 		warning(5, "short");
 		td = block_dup_type(gettyp(t2 == INT ? SHORT : USHORT));
 		td->t_typedef = true;
 		return td;
 	if (t != LONG)
 		goto invalid;
 	if (t2 == INT)
 		td = gettyp(LONG);
 	else if (t2 == UINT)
 		td = gettyp(ULONG);
 	else if (t2 == LONG)
 		td = gettyp(LLONG);
 	else if (t2 == ULONG)
 		td = gettyp(ULLONG);
 	else if (t2 == FLOAT)
 		td = gettyp(DOUBLE);
 	else if (t2 == DOUBLE)
 		td = gettyp(LDOUBLE);
 	else if (t2 == DCOMPLEX)
 		td = gettyp(LCOMPLEX);
 	else
 		goto invalid;
 	/* modifying typedef with '%s'; only qualifiers allowed */
 	warning(5, "long");
 	td = block_dup_type(td);
 	td->t_typedef = true;
 	return td;
 invalid:
 	/* Anything else is not accepted. */
 	dcs->d_invalid_type_combination = true;
 	return td;
 static void
 set_first_typedef(type_t *tp, sym_t *sym)
+{
 	tspec_t t = tp->t_tspec;
 	if (is_struct_or_union(t) && tp->t_sou->sou_first_typedef == NULL)
 		tp->t_sou->sou_first_typedef = sym;
 	if (t == ENUM && tp->t_enum->en_first_typedef == NULL)
 		tp->t_enum->en_first_typedef = sym;
+}
 static unsigned int
 bit_fields_width(const sym_t **mem, bool *named)
 @@ -1000,26 +982,41 @@ check_bit_field(sym_t *dsym, tspec_t *in
 	} else if (tp->t_bit_field_width == 0 && dsym->s_name != unnamed) {
 		/* zero size bit-field */
 		error(37);
 		tp->t_bit_field_width = t_width;
+	}
 	if (dsym->s_scl == UNION_MEMBER) {
 		/* bit-field in union is very unusual */
 		warning(41);
 		dsym->s_type->t_bitfield = false;
 		dsym->s_bitfield = false;
+	}
+}
 /* Aligns the next structure element as required. */
 static void
 dcs_align(unsigned int member_alignment, unsigned int bit_field_width)
+{
 	if (member_alignment > dcs->d_sou_align_in_bits)
 		dcs->d_sou_align_in_bits = member_alignment;
 	unsigned int offset = (dcs->d_sou_size_in_bits + member_alignment - 1)
 	    & ~(member_alignment - 1);
 	if (bit_field_width == 0
 	    || dcs->d_sou_size_in_bits + bit_field_width > offset)
 		dcs->d_sou_size_in_bits = offset;
+}
 /* Add a member to the struct or union type that is being built in 'dcs'. */
 static void
 dcs_add_member(sym_t *mem)
+{
 	type_t *tp = mem->s_type;
 	unsigned int union_size = 0;
 	if (dcs->d_kind == DLK_UNION) {
 		union_size = dcs->d_sou_size_in_bits;
 		dcs->d_sou_size_in_bits = 0;
+	}
 	if (mem->s_bitfield) {
 @@ -1096,41 +1093,26 @@ declare_member(sym_t *dsym)
 		/* zero-sized array '%s' in struct is a C99 extension */
 		c99ism(39, dsym->s_name);
+	}
 	dcs_add_member(dsym);
 	check_function_definition(dsym, false);
 	suppress_bitfieldtype = false;
 	return dsym;
+}
 /* Aligns the next structure element as required. */
 static void
 dcs_align(unsigned int member_alignment, unsigned int bit_field_width)
 	if (member_alignment > dcs->d_sou_align_in_bits)
 		dcs->d_sou_align_in_bits = member_alignment;
 	unsigned int offset = (dcs->d_sou_size_in_bits + member_alignment - 1)
 	    & ~(member_alignment - 1);
 	if (bit_field_width == 0
 	    || dcs->d_sou_size_in_bits + bit_field_width > offset)
 		dcs->d_sou_size_in_bits = offset;
 sym_t *
 set_bit_field_width(sym_t *dsym, int bit_field_width)
+{
 	if (dsym == NULL) {
 		dsym = block_zero_alloc(sizeof(*dsym), "sym");
 		dsym->s_name = unnamed;
 		dsym->s_kind = FMEMBER;
 		dsym->s_scl = STRUCT_MEMBER;
 		dsym->s_type = gettyp(UINT);
 		dsym->s_block_level = -1;
+	}
 	dsym->s_type = block_dup_type(dsym->s_type);
 @@ -1279,26 +1261,74 @@ add_array(sym_t *decl, bool dim, int n)
 static type_t *
 block_derive_function(type_t *ret, bool proto, sym_t *args, bool vararg)
+{
 	type_t *tp = block_derive_type(ret, FUNC);
 	tp->t_proto = proto;
 	if (proto)
 		tp->t_args = args;
 	tp->t_vararg = vararg;
 	return tp;
+}
 static void
 check_prototype_parameters(sym_t *args)
+{
 	for (sym_t *sym = dcs->d_first_dlsym;
 	     sym != NULL; sym = sym->s_level_next) {
 		scl_t sc = sym->s_scl;
 		if (sc == STRUCT_TAG || sc == UNION_TAG || sc == ENUM_TAG) {
 			/* dubious tag declaration '%s %s' */
 			warning(85, storage_class_name(sc), sym->s_name);
+		}
+	}
 	for (sym_t *arg = args; arg != NULL; arg = arg->s_next) {
 		if (arg->s_type->t_tspec == VOID &&
 		    !(arg == args && arg->s_next == NULL)) {
 			/* void must be sole parameter */
 			error(60);
 			arg->s_type = gettyp(INT);
+		}
+	}
+}
 static void
 old_style_function(sym_t *decl, sym_t *args)
+{
 	/*
 	 * Remember the list of parameters only if this really seems to be a
 	 * function definition.
 	 */
 	if (dcs->d_enclosing->d_kind == DLK_EXTERN &&
 	    decl->s_type == dcs->d_enclosing->d_type) {
 		/*
 		 * Assume that this becomes a function definition. If not, it
 		 * will be corrected in check_function_definition.
 		 */
 		if (args != NULL) {
 			decl->s_osdef = true;
 			decl->u.s_old_style_args = args;
+		}
 	} else {
 		if (args != NULL)
 			/* function prototype parameters must have types */
 			warning(62);
+	}
+}
 sym_t *
 add_function(sym_t *decl, struct parameter_list params)
+{
 	debug_enter();
 	debug_dcs(true);
 	debug_sym("decl: ", decl, "\n");
 #ifdef DEBUG
 	for (const sym_t *arg = params.first; arg != NULL; arg = arg->s_next)
 		debug_sym("arg: ", arg, "\n");
 #endif
 	if (params.prototype) {
 @@ -1347,91 +1377,43 @@ add_function(sym_t *decl, struct paramet
 		debug_leave();
 		return decl;	/* see msg_347 */
+	}
 	*tpp = block_derive_function(dcs->d_enclosing->d_type,
 	    params.prototype, params.first, params.vararg);
 	debug_step("add_function: '%s'", type_name(decl->s_type));
 	debug_dcs(true);
 	debug_leave();
 	return decl;
+}
-static void
+/*
-check_prototype_parameters(sym_t *args)
+ * In a function declaration, a list of identifiers (as opposed to a list of
  * types) is allowed only if it's also a function definition.
  */
 void
 check_function_definition(sym_t *sym, bool msg)
+{
-	for (sym_t *sym = dcs->d_first_dlsym;
+	if (sym->s_osdef) {
-	     sym != NULL; sym = sym->s_level_next) {
+		if (msg) {
-		scl_t sc = sym->s_scl;
+			/* incomplete or misplaced function definition */
-		if (sc == STRUCT_TAG || sc == UNION_TAG || sc == ENUM_TAG) {
+			error(22);
 			/* dubious tag declaration '%s %s' */
 			warning(85, storage_class_name(sc), sym->s_name);
+		}
 		sym->s_osdef = false;
 		sym->u.s_old_style_args = NULL;
+	}
+}
 	for (sym_t *arg = args; arg != NULL; arg = arg->s_next) {
 		if (arg->s_type->t_tspec == VOID &&
 		    !(arg == args && arg->s_next == NULL)) {
 			/* void must be sole parameter */
 			error(60);
 			arg->s_type = gettyp(INT);
 static void
 old_style_function(sym_t *decl, sym_t *args)
 	/*
 	 * Remember the list of parameters only if this really seems to be a
 	 * function definition.
 	 */
 	if (dcs->d_enclosing->d_kind == DLK_EXTERN &&
 	    decl->s_type == dcs->d_enclosing->d_type) {
 		/*
 		 * Assume that this becomes a function definition. If not, it
 		 * will be corrected in check_function_definition.
 		 */
 		if (args != NULL) {
 			decl->s_osdef = true;
 			decl->u.s_old_style_args = args;
 	} else {
 		if (args != NULL)
 			/* function prototype parameters must have types */
 			warning(62);
 /*
  * In a function declaration, a list of identifiers (as opposed to a list of
  * types) is allowed only if it's also a function definition.
  */
 void
 check_function_definition(sym_t *sym, bool msg)
 	if (sym->s_osdef) {
 		if (msg) {
 			/* incomplete or misplaced function definition */
 			error(22);
 		sym->s_osdef = false;
 		sym->u.s_old_style_args = NULL;
 /* The symbol gets a storage class and a definedness. */
 sym_t *
 declarator_name(sym_t *sym)
+{
 	scl_t sc = NOSCL;
 	if (sym->s_scl == NOSCL)
 		dcs->d_redeclared_symbol = NULL;
 	else if (sym->s_defarg) {
 		sym->s_defarg = false;
 		dcs->d_redeclared_symbol = NULL;
 	} else {
 @@ -1525,26 +1507,87 @@ old_style_function_parameter_name(sym_t
 			error(21, sym->s_name);
 			lint_assert(sym->s_defarg);
+		}
 		sym = pushdown(sym);
+	}
 	sym->s_type = gettyp(INT);
 	sym->s_scl = AUTO;
 	sym->s_def = DEF;
 	sym->s_defarg = sym->s_arg = true;
 	return sym;
+}
 /*-
  * Checks all possible cases of tag redeclarations.
+ *
  * decl		whether T_LBRACE follows
  * semi		whether T_SEMI follows
  */
 static sym_t *
 new_tag(sym_t *tag, scl_t scl, bool decl, bool semi)
+{
 	if (tag->s_block_level < block_level) {
 		if (semi) {
 			/* "struct a;" */
 			if (allow_c90) {
 				/* XXX: Why is this warning suppressed in C90 mode? */
 				if (allow_trad || allow_c99)
 					/* declaration of '%s %s' intro... */
 					warning(44, storage_class_name(scl),
 					    tag->s_name);
 				tag = pushdown(tag);
 			} else if (tag->s_scl != scl) {
 				/* base type is really '%s %s' */
 				warning(45, storage_class_name(tag->s_scl),
 				    tag->s_name);
+			}
 			dcs->d_enclosing->d_nonempty_decl = true;
 		} else if (decl) {
 			/* "struct a { ... } " */
 			if (hflag)
 				/* redefinition of '%s' hides earlier one */
 				warning(43, tag->s_name);
 			tag = pushdown(tag);
 			dcs->d_enclosing->d_nonempty_decl = true;
 		} else if (tag->s_scl != scl) {
 			/* base type is really '%s %s' */
 			warning(45, storage_class_name(tag->s_scl),
 			    tag->s_name);
 			/* XXX: Why is this warning suppressed in C90 mode? */
 			if (allow_trad || allow_c99) {
 				/* declaration of '%s %s' introduces ... */
 				warning(44, storage_class_name(scl),
 				    tag->s_name);
+			}
 			tag = pushdown(tag);
 			dcs->d_enclosing->d_nonempty_decl = true;
+		}
 	} else {
 		if (tag->s_scl != scl ||
 		    (decl && !is_incomplete(tag->s_type))) {
 			/* %s tag '%s' redeclared as %s */
 			error(46, storage_class_name(tag->s_scl),
 			    tag->s_name, storage_class_name(scl));
 			print_previous_declaration(tag);
 			tag = pushdown(tag);
 			dcs->d_enclosing->d_nonempty_decl = true;
 		} else if (semi || decl)
 			dcs->d_enclosing->d_nonempty_decl = true;
+	}
 	return tag;
+}
 /*-
  * tag		the symbol table entry of the tag
  * kind		the kind of the tag (STRUCT/UNION/ENUM)
  * decl		whether the tag type will be completed in this declaration
  *		(when the following token is T_LBRACE)
  * semi		whether the following token is T_SEMI
  */
 type_t *
 make_tag_type(sym_t *tag, tspec_t kind, bool decl, bool semi)
+{
 	scl_t scl;
 	type_t *tp;
 	if (kind == STRUCT)
 @@ -1599,87 +1642,26 @@ make_tag_type(sym_t *tag, tspec_t kind,
 			tp->t_sou->sou_tag = tag;
 			tp->t_sou->sou_incomplete = true;
 		} else {
 			tp->t_is_enum = true;
 			tp->t_enum = block_zero_alloc(sizeof(*tp->t_enum),
 			    "enumeration");
 			tp->t_enum->en_tag = tag;
 			tp->t_enum->en_incomplete = true;
+		}
+	}
 	return tp;
+}
 /*-
  * Checks all possible cases of tag redeclarations.
  * decl		whether T_LBRACE follows
  * semi		whether T_SEMI follows
  */
 static sym_t *
 new_tag(sym_t *tag, scl_t scl, bool decl, bool semi)
 	if (tag->s_block_level < block_level) {
 		if (semi) {
 			/* "struct a;" */
 			if (allow_c90) {
 				/* XXX: Why is this warning suppressed in C90 mode? */
 				if (allow_trad || allow_c99)
 					/* declaration of '%s %s' intro... */
 					warning(44, storage_class_name(scl),
 					    tag->s_name);
 				tag = pushdown(tag);
 			} else if (tag->s_scl != scl) {
 				/* base type is really '%s %s' */
 				warning(45, storage_class_name(tag->s_scl),
 				    tag->s_name);
 			dcs->d_enclosing->d_nonempty_decl = true;
 		} else if (decl) {
 			/* "struct a { ... } " */
 			if (hflag)
 				/* redefinition of '%s' hides earlier one */
 				warning(43, tag->s_name);
 			tag = pushdown(tag);
 			dcs->d_enclosing->d_nonempty_decl = true;
 		} else if (tag->s_scl != scl) {
 			/* base type is really '%s %s' */
 			warning(45, storage_class_name(tag->s_scl),
 			    tag->s_name);
 			/* XXX: Why is this warning suppressed in C90 mode? */
 			if (allow_trad || allow_c99) {
 				/* declaration of '%s %s' introduces ... */
 				warning(44, storage_class_name(scl),
 				    tag->s_name);
 			tag = pushdown(tag);
 			dcs->d_enclosing->d_nonempty_decl = true;
 	} else {
 		if (tag->s_scl != scl ||
 		    (decl && !is_incomplete(tag->s_type))) {
 			/* %s tag '%s' redeclared as %s */
 			error(46, storage_class_name(tag->s_scl),
 			    tag->s_name, storage_class_name(scl));
 			print_previous_declaration(tag);
 			tag = pushdown(tag);
 			dcs->d_enclosing->d_nonempty_decl = true;
 		} else if (semi || decl)
 			dcs->d_enclosing->d_nonempty_decl = true;
 	return tag;
 const char *
 storage_class_name(scl_t sc)
+{
 	switch (sc) {
 	case EXTERN:	return "extern";
 	case STATIC:	return "static";
 	case AUTO:	return "auto";
 	case REG:	return "register";
 	case TYPEDEF:	return "typedef";
 	case STRUCT_TAG:return "struct";
 	case UNION_TAG:	return "union";
 	case ENUM_TAG:	return "enum";
 	default:	lint_assert(/*CONSTCOND*/false);
 @@ -1812,26 +1794,116 @@ check_extern_declaration(const sym_t *sy
 		warning(351, sym->s_type->t_tspec == FUNC ? "" : " 'extern'",
 		    sym->s_name);
+	}
 	if (any_query_enabled &&
 	    sym->s_type->t_tspec == FUNC &&
 	    sym->s_scl == EXTERN &&
 	    sym->s_def == DECL &&
 	    !in_system_header) {
 		/* redundant 'extern' in function declaration of '%s' */
 		query_message(13, sym->s_name);
+	}
+}
 /*
  * Check whether the symbol cannot be initialized due to type/storage class.
  * Return whether an error has been detected.
  */
 static bool
 check_init(sym_t *sym)
+{
 	if (sym->s_type->t_tspec == FUNC) {
 		/* cannot initialize function '%s' */
 		error(24, sym->s_name);
 		return true;
+	}
 	if (sym->s_scl == TYPEDEF) {
 		/* cannot initialize typedef '%s' */
 		error(25, sym->s_name);
 		return true;
+	}
 	if (sym->s_scl == EXTERN && sym->s_def == DECL) {
 		if (dcs->d_kind == DLK_EXTERN) {
 			/* cannot initialize extern declaration '%s' */
 			warning(26, sym->s_name);
 		} else {
 			/* cannot initialize extern declaration '%s' */
 			error(26, sym->s_name);
 			return true;
+		}
+	}
 	return false;
+}
 /*
  * Compares a prototype declaration with the remembered arguments of a previous
  * old-style function definition.
  */
 static bool
 check_old_style_definition(sym_t *rdsym, sym_t *dsym)
+{
 	sym_t *args = rdsym->u.s_old_style_args;
 	sym_t *pargs = dsym->s_type->t_args;
 	bool msg = false;
 	int narg = 0;
 	for (sym_t *arg = args; arg != NULL; arg = arg->s_next)
 		narg++;
 	int nparg = 0;
 	for (sym_t *parg = pargs; parg != NULL; parg = parg->s_next)
 		nparg++;
 	if (narg != nparg) {
 		/* prototype does not match old-style definition */
 		error(63);
 		msg = true;
 		goto end;
+	}
 	sym_t *arg = args;
 	sym_t *parg = pargs;
 	int n = 1;
 	while (narg-- > 0) {
 		bool dowarn = false;
 		/*
 		 * If it does not match due to promotion and lint runs in
 		 * "traditional to C90" migration mode, print only a warning.
+		 *
 		 * XXX: Where is this "only a warning"?
 		 */
 		if (!types_compatible(arg->s_type, parg->s_type,
 		    true, true, &dowarn) ||
 		    dowarn) {
 			/* prototype does not match old-style ... */
 			error(299, n);
 			msg = true;
+		}
 		arg = arg->s_next;
 		parg = parg->s_next;
 		n++;
+	}
 end:
 	if (msg && rflag) {
 		/* old-style definition */
 		message_at(300, &rdsym->s_def_pos);
+	}
 	return msg;
+}
 /* Process a single external or 'static' declarator. */
 static void
 declare_extern(sym_t *dsym, bool has_initializer, sbuf_t *renaming)
+{
 	if (renaming != NULL) {
 		lint_assert(dsym->s_rename == NULL);
 		char *s = level_zero_alloc(1, renaming->sb_len + 1, "string");
 		(void)memcpy(s, renaming->sb_name, renaming->sb_len + 1);
 		dsym->s_rename = s;
+	}
 @@ -2063,26 +2135,73 @@ qualifiers_correspond(const type_t *tp1,
 	if (tp1->t_volatile != tp2->t_volatile && !ignqual && allow_c90)
 		return false;
 	return true;
+}
 bool
 pointer_types_are_compatible(const type_t *tp1, const type_t *tp2, bool ignqual)
+{
 	return tp1->t_tspec == VOID || tp2->t_tspec == VOID ||
 	       qualifiers_correspond(tp1, tp2, ignqual);
+}
 static bool
 prototypes_compatible(const type_t *tp1, const type_t *tp2, bool *dowarn)
+{
 	if (tp1->t_vararg != tp2->t_vararg)
 		return false;
 	sym_t *a1 = tp1->t_args;
 	sym_t *a2 = tp2->t_args;
 	for (; a1 != NULL && a2 != NULL; a1 = a1->s_next, a2 = a2->s_next) {
 		if (!types_compatible(a1->s_type, a2->s_type,
 		    true, false, dowarn))
 			return false;
+	}
 	return a1 == a2;
+}
 /*
  * Returns whether all parameters of a prototype are compatible with an
  * old-style function declaration.
+ *
  * This is the case if the following conditions are met:
  *	1. the prototype has a fixed number of parameters
  *	2. no parameter is of type float
  *	3. no parameter is converted to another type if integer promotion
  *	   is applied on it
  */
 static bool
 matches_no_arg_function(const type_t *tp, bool *dowarn)
+{
 	if (tp->t_vararg && dowarn != NULL)
 		*dowarn = true;
 	for (sym_t *arg = tp->t_args; arg != NULL; arg = arg->s_next) {
 		tspec_t t = arg->s_type->t_tspec;
 		if (t == FLOAT ||
 		    t == CHAR || t == SCHAR || t == UCHAR ||
 		    t == SHORT || t == USHORT) {
 			if (dowarn != NULL)
 				*dowarn = true;
+		}
+	}
 	/* FIXME: Always returning true cannot be correct. */
 	return true;
+}
 /*-
  * ignqual	ignore type qualifiers; used for function parameters
  * promot	promote the left type; used for comparison of parameters of
  *		old-style function definitions with parameters of prototypes.
  * *dowarn	is set to true if an old-style function declaration is not
  *		compatible with a prototype
  */
 bool
 types_compatible(const type_t *tp1, const type_t *tp2,
 		     bool ignqual, bool promot, bool *dowarn)
+{
 	while (tp1 != NULL && tp2 != NULL) {
 @@ -2132,131 +2251,26 @@ types_compatible(const type_t *tp1, cons
 				if (!matches_no_arg_function(tp2, dowarn))
 					return false;
+			}
+		}
 		tp1 = tp1->t_subt;
 		tp2 = tp2->t_subt;
 		ignqual = promot = false;
+	}
 	return tp1 == tp2;
+}
 static bool
 prototypes_compatible(const type_t *tp1, const type_t *tp2, bool *dowarn)
 	if (tp1->t_vararg != tp2->t_vararg)
 		return false;
 	sym_t *a1 = tp1->t_args;
 	sym_t *a2 = tp2->t_args;
 	for (; a1 != NULL && a2 != NULL; a1 = a1->s_next, a2 = a2->s_next) {
 		if (!types_compatible(a1->s_type, a2->s_type,
 		    true, false, dowarn))
 			return false;
 	return a1 == a2;
 /*
  * Returns whether all parameters of a prototype are compatible with an
  * old-style function declaration.
  * This is the case if the following conditions are met:
  *	1. the prototype has a fixed number of parameters
  *	2. no parameter is of type float
  *	3. no parameter is converted to another type if integer promotion
  *	   is applied on it
  */
 static bool
 matches_no_arg_function(const type_t *tp, bool *dowarn)
 	if (tp->t_vararg && dowarn != NULL)
 		*dowarn = true;
 	for (sym_t *arg = tp->t_args; arg != NULL; arg = arg->s_next) {
 		tspec_t t = arg->s_type->t_tspec;
 		if (t == FLOAT ||
 		    t == CHAR || t == SCHAR || t == UCHAR ||
 		    t == SHORT || t == USHORT) {
 			if (dowarn != NULL)
 				*dowarn = true;
 	/* FIXME: Always returning true cannot be correct. */
 	return true;
 /*
  * Compares a prototype declaration with the remembered arguments of a previous
  * old-style function definition.
  */
 static bool
 check_old_style_definition(sym_t *rdsym, sym_t *dsym)
 	sym_t *args = rdsym->u.s_old_style_args;
 	sym_t *pargs = dsym->s_type->t_args;
 	bool msg = false;
 	int narg = 0;
 	for (sym_t *arg = args; arg != NULL; arg = arg->s_next)
 		narg++;
 	int nparg = 0;
 	for (sym_t *parg = pargs; parg != NULL; parg = parg->s_next)
 		nparg++;
 	if (narg != nparg) {
 		/* prototype does not match old-style definition */
 		error(63);
 		msg = true;
 		goto end;
 	sym_t *arg = args;
 	sym_t *parg = pargs;
 	int n = 1;
 	while (narg-- > 0) {
 		bool dowarn = false;
 		/*
 		 * If it does not match due to promotion and lint runs in
 		 * "traditional to C90" migration mode, print only a warning.
 		 * XXX: Where is this "only a warning"?
 		 */
 		if (!types_compatible(arg->s_type, parg->s_type,
 		    true, true, &dowarn) ||
 		    dowarn) {
 			/* prototype does not match old-style ... */
 			error(299, n);
 			msg = true;
 		arg = arg->s_next;
 		parg = parg->s_next;
 		n++;
 end:
 	if (msg && rflag) {
 		/* old-style definition */
 		message_at(300, &rdsym->s_def_pos);
 	return msg;
 /*
  * Completes a type by copying the dimension and prototype information from a
  * second compatible type.
+ *
  * Following lines are legal:
  *  "typedef a[]; a b; a b[10]; a c; a c[20];"
  *  "typedef ft(); ft f; f(int); ft g; g(long);"
  * This means that, if a type is completed, the type structure must be
  * duplicated.
  */
 void
 complete_type(sym_t *dsym, sym_t *ssym)
+{
 @@ -2412,26 +2426,62 @@ check_func_lint_directives(void)
 		    ? printflike_argnum : scanflike_argnum;
 		sym_t *arg = dcs->d_func_args;
 		for (int n = 1; n < narg; n++)
 			arg = arg->s_next;
 		if (!is_character_pointer(arg->s_type)) {
 			/* argument %d must be 'char *' for PRINTFLIKE/... */
 			warning(293, narg);
 			printflike_argnum = scanflike_argnum = -1;
+		}
+	}
+}
 /*
  * Checks compatibility of an old-style function definition with a previous
  * prototype declaration.
  * Returns true if the position of the previous declaration should be reported.
  */
 static bool
 check_prototype_declaration(sym_t *arg, sym_t *parg)
+{
 	type_t *tp = arg->s_type;
 	type_t *ptp = parg->s_type;
 	bool dowarn = false;
 	if (!types_compatible(tp, ptp, true, true, &dowarn)) {
 		if (types_compatible(tp, ptp, true, false, &dowarn)) {
 			/* type of '%s' does not match prototype */
 			return gnuism(58, arg->s_name);
 		} else {
 			/* type of '%s' does not match prototype */
 			error(58, arg->s_name);
 			return true;
+		}
+	}
 	if (dowarn) {
 		/* TODO: Make this an error in C99 mode as well. */
 		if (!allow_trad && !allow_c99)
 			/* type of '%s' does not match prototype */
 			error(58, arg->s_name);
 		else
 			/* type of '%s' does not match prototype */
 			warning(58, arg->s_name);
 		return true;
+	}
 	return false;
+}
 /*
  * Warn about arguments in old-style function definitions that default to int.
  * Check that an old-style function definition is compatible to a previous
  * prototype.
  */
 void
 check_func_old_style_arguments(void)
+{
 	int narg;
 	int nparg;
 	bool msg;
 	sym_t *args = funcsym->u.s_old_style_args;
 	sym_t *pargs = funcsym->s_type->t_args;
 @@ -2478,62 +2528,26 @@ check_func_old_style_arguments(void)
+			}
+		}
 		if (msg && rflag) {
 			/* prototype declaration */
 			message_at(285, &dcs->d_redeclared_symbol->s_def_pos);
+		}
 		/* from now on the prototype is valid */
 		funcsym->s_osdef = false;
 		funcsym->u.s_old_style_args = NULL;
+	}
+}
 /*
  * Checks compatibility of an old-style function definition with a previous
  * prototype declaration.
  * Returns true if the position of the previous declaration should be reported.
  */
 static bool
 check_prototype_declaration(sym_t *arg, sym_t *parg)
 	type_t *tp = arg->s_type;
 	type_t *ptp = parg->s_type;
 	bool dowarn = false;
 	if (!types_compatible(tp, ptp, true, true, &dowarn)) {
 		if (types_compatible(tp, ptp, true, false, &dowarn)) {
 			/* type of '%s' does not match prototype */
 			return gnuism(58, arg->s_name);
 		} else {
 			/* type of '%s' does not match prototype */
 			error(58, arg->s_name);
 			return true;
 	if (dowarn) {
 		/* TODO: Make this an error in C99 mode as well. */
 		if (!allow_trad && !allow_c99)
 			/* type of '%s' does not match prototype */
 			error(58, arg->s_name);
 		else
 			/* type of '%s' does not match prototype */
 			warning(58, arg->s_name);
 		return true;
 	return false;
 static void
 check_local_hiding(const sym_t *dsym)
+{
 	switch (dsym->s_scl) {
 	case AUTO:
 		/* automatic '%s' hides external declaration */
 		warning(86, dsym->s_name);
 		break;
 	case STATIC:
 		/* static '%s' hides external declaration */
 		warning(87, dsym->s_name);
 		break;
 	case TYPEDEF:
 @@ -2562,37 +2576,87 @@ check_local_redeclaration(const sym_t *d
 			/*
 			 * if allow_c90, a "redeclaration of '%s'" error
 			 * is produced below
 			 */
 			if (!allow_c90) {
 				if (hflag) {
 					/* declaration of '%s' hides ... */
 					warning(91, dsym->s_name);
+				}
 				rmsym(rdsym);
+			}
+		}
 	} else if (rdsym->s_block_level < block_level) {
 		if (hflag) {
 			/* declaration of '%s' hides earlier one */
 			warning(95, dsym->s_name);
+		}
+	}
 	if (rdsym->s_block_level == block_level) {
 		/* redeclaration of '%s' */
 		error(27, dsym->s_name);
 		rmsym(rdsym);
+	}
+}
 /* Processes (re)declarations of external symbols inside blocks. */
 static void
 declare_external_in_block(sym_t *dsym)
+{
 	/* look for a symbol with the same name */
 	sym_t *esym = dcs->d_redeclared_symbol;
 	while (esym != NULL && esym->s_block_level != 0) {
 		while ((esym = esym->s_symtab_next) != NULL) {
 			if (esym->s_kind != FVFT)
 				continue;
 			if (strcmp(dsym->s_name, esym->s_name) == 0)
 				break;
+		}
+	}
 	if (esym == NULL)
 		return;
 	if (esym->s_scl != EXTERN && esym->s_scl != STATIC) {
 		/* gcc accepts this without a warning, pcc prints an error. */
 		/* redeclaration of '%s' */
 		warning(27, dsym->s_name);
 		print_previous_declaration(esym);
 		return;
+	}
 	bool dowarn = false;
 	bool compatible = types_compatible(esym->s_type, dsym->s_type,
 	    false, false, &dowarn);
 	if (!compatible || dowarn) {
 		if (esym->s_scl == EXTERN) {
 			/* inconsistent redeclaration of extern '%s' */
 			warning(90, dsym->s_name);
 			print_previous_declaration(esym);
 		} else {
 			/* inconsistent redeclaration of static '%s' */
 			warning(92, dsym->s_name);
 			print_previous_declaration(esym);
+		}
+	}
-	if (rdsym->s_block_level == block_level) {
+	if (compatible) {
-		/* redeclaration of '%s' */
+		/*
-		error(27, dsym->s_name);
+		 * Remember the external symbol, so we can update usage
-		rmsym(rdsym);
+		 * information at the end of the block.
 		 */
 		dsym->s_ext_sym = esym;
+	}
+}
 /*
  * Completes a single local declaration/definition.
  */
 void
 declare_local(sym_t *dsym, bool has_initializer)
+{
 	/* Correct a mistake done in declarator_name(). */
 	if (dsym->s_type->t_tspec == FUNC) {
 		dsym->s_def = DECL;
 @@ -2661,108 +2725,26 @@ declare_local(sym_t *dsym, bool has_init
 	if (dsym->s_scl == TYPEDEF) {
 		dsym->s_type = block_dup_type(dsym->s_type);
 		dsym->s_type->t_typedef = true;
 		set_first_typedef(dsym->s_type, dsym);
+	}
 	if (dsym->s_scl == STATIC && any_query_enabled) {
 		/* static variable '%s' in function */
 		query_message(11, dsym->s_name);
+	}
+}
 /* Processes (re)declarations of external symbols inside blocks. */
 static void
 declare_external_in_block(sym_t *dsym)
 	/* look for a symbol with the same name */
 	sym_t *esym = dcs->d_redeclared_symbol;
 	while (esym != NULL && esym->s_block_level != 0) {
 		while ((esym = esym->s_symtab_next) != NULL) {
 			if (esym->s_kind != FVFT)
 				continue;
 			if (strcmp(dsym->s_name, esym->s_name) == 0)
 				break;
 	if (esym == NULL)
 		return;
 	if (esym->s_scl != EXTERN && esym->s_scl != STATIC) {
 		/* gcc accepts this without a warning, pcc prints an error. */
 		/* redeclaration of '%s' */
 		warning(27, dsym->s_name);
 		print_previous_declaration(esym);
 		return;
 	bool dowarn = false;
 	bool compatible = types_compatible(esym->s_type, dsym->s_type,
 	    false, false, &dowarn);
 	if (!compatible || dowarn) {
 		if (esym->s_scl == EXTERN) {
 			/* inconsistent redeclaration of extern '%s' */
 			warning(90, dsym->s_name);
 			print_previous_declaration(esym);
 		} else {
 			/* inconsistent redeclaration of static '%s' */
 			warning(92, dsym->s_name);
 			print_previous_declaration(esym);
 	if (compatible) {
 		/*
 		 * Remember the external symbol, so we can update usage
 		 * information at the end of the block.
 		 */
 		dsym->s_ext_sym = esym;
 /*
  * Check whether the symbol cannot be initialized due to type/storage class.
  * Return whether an error has been detected.
  */
 static bool
 check_init(sym_t *sym)
 	if (sym->s_type->t_tspec == FUNC) {
 		/* cannot initialize function '%s' */
 		error(24, sym->s_name);
 		return true;
 	if (sym->s_scl == TYPEDEF) {
 		/* cannot initialize typedef '%s' */
 		error(25, sym->s_name);
 		return true;
 	if (sym->s_scl == EXTERN && sym->s_def == DECL) {
 		if (dcs->d_kind == DLK_EXTERN) {
 			/* cannot initialize extern declaration '%s' */
 			warning(26, sym->s_name);
 		} else {
 			/* cannot initialize extern declaration '%s' */
 			error(26, sym->s_name);
 			return true;
 	return false;
 /* Create a symbol for an abstract declaration. */
 sym_t *
 abstract_name(void)
+{
 	lint_assert(dcs->d_kind == DLK_ABSTRACT
 	    || dcs->d_kind == DLK_PROTO_PARAMS);
 	sym_t *sym = block_zero_alloc(sizeof(*sym), "sym");
 	sym->s_name = unnamed;
 	sym->s_def = DEF;
 	sym->s_scl = ABSTRACT;
 	sym->s_block_level = -1;
 @@ -2865,44 +2847,26 @@ check_usage(decl_level *dl)
+{
 	/* for this warning LINTED has no effect */
 	int saved_lwarn = lwarn;
 	lwarn = LWARN_ALL;
 	debug_step("begin lwarn %d", lwarn);
 	for (sym_t *sym = dl->d_first_dlsym;
 	     sym != NULL; sym = sym->s_level_next)
 		check_usage_sym(dl->d_asm, sym);
 	lwarn = saved_lwarn;
 	debug_step("end lwarn %d", lwarn);
+}
 /* Warns about a variable or a label that is not used or only set. */
 void
 check_usage_sym(bool novar, sym_t *sym)
 	if (sym->s_block_level == -1)
 		return;
 	if (sym->s_kind == FVFT && sym->s_arg)
 		check_argument_usage(novar, sym);
 	else if (sym->s_kind == FVFT)
 		check_variable_usage(novar, sym);
 	else if (sym->s_kind == FLABEL)
 		check_label_usage(sym);
 	else if (sym->s_kind == FTAG)
 		check_tag_usage(sym);
 static void
 check_argument_usage(bool novar, sym_t *arg)
+{
 	lint_assert(arg->s_set);
 	if (novar)
 		return;
 	if (!arg->s_used && !vflag) {
 		/* parameter '%s' unused in function '%s' */
 		warning_at(231, &arg->s_def_pos, arg->s_name, funcsym->s_name);
+	}
 @@ -3012,51 +2976,75 @@ check_tag_usage(sym_t *sym)
 		break;
 	case UNION:
 		/* union '%s' never defined */
 		warning_at(234, &sym->s_def_pos, sym->s_name);
 		break;
 	default:
 		lint_assert(sym->s_type->t_tspec == ENUM);
 		/* enum '%s' never defined */
 		warning_at(235, &sym->s_def_pos, sym->s_name);
 		break;
+	}
+}
-/*
+/* Warns about a variable or a label that is not used or only set. */
  * Called after the entire translation unit has been parsed.
  * Changes tentative definitions into definitions.
  * Performs some tests on global symbols. Detected problems are:
  * - defined variables of incomplete type
  * - constant variables which are not initialized
  * - static symbols which are never used
  */
 void
-check_global_symbols(void)
+check_usage_sym(bool novar, sym_t *sym)
+{
 	sym_t *sym;
-	if (block_level != 0 || dcs->d_enclosing != NULL)
+	if (sym->s_block_level == -1)
-		norecover();
+		return;
-	for (sym = dcs->d_first_dlsym; sym != NULL; sym = sym->s_level_next) {
+	if (sym->s_kind == FVFT && sym->s_arg)
-		if (sym->s_block_level == -1)
+		check_argument_usage(novar, sym);
-			continue;
+	else if (sym->s_kind == FVFT)
-		if (sym->s_kind == FVFT)
+		check_variable_usage(novar, sym);
-			check_global_variable(sym);
+	else if (sym->s_kind == FLABEL)
-		else if (sym->s_kind == FTAG)
+		check_label_usage(sym);
-			check_tag_usage(sym);
+	else if (sym->s_kind == FTAG)
-		else
+		check_tag_usage(sym);
 			lint_assert(sym->s_kind == FMEMBER);
 static void
 check_global_variable_size(const sym_t *sym)
+{
 	if (sym->s_def != TDEF)
 		return;
 	if (sym->s_type->t_tspec == FUNC) {
 		/* Maybe a syntax error after a function declaration. */
 		return;
+	}
 	if (sym->s_def == TDEF && sym->s_type->t_tspec == VOID) {
 		/* Prevent an internal error in length_in_bits below. */
 		return;
+	}
 	pos_t cpos = curr_pos;
 	curr_pos = sym->s_def_pos;
 	int len_in_bits = length_in_bits(sym->s_type, sym->s_name);
 	curr_pos = cpos;
 	if (len_in_bits == 0 &&
 	    sym->s_type->t_tspec == ARRAY && sym->s_type->t_dim == 0) {
 		/* TODO: C99 6.7.5.2p1 defines this as an error as well. */
 		if (!allow_c90 ||
 		    (sym->s_scl == EXTERN && (allow_trad || allow_c99))) {
 			/* empty array declaration for '%s' */
 			warning_at(190, &sym->s_def_pos, sym->s_name);
 		} else {
 			/* empty array declaration for '%s' */
 			error_at(190, &sym->s_def_pos, sym->s_name);
+		}
+	}
+}
 static void
 check_unused_static_global_variable(const sym_t *sym)
+{
 	if (sym->s_type->t_tspec == FUNC) {
 		if (sym->s_def == DEF) {
 			if (!sym->s_inline)
 				/* static function '%s' unused */
 				warning_at(236, &sym->s_def_pos, sym->s_name);
 		} else {
 			/* static function '%s' declared but not defined */
 @@ -3097,57 +3085,51 @@ check_global_variable(const sym_t *sym)
 		return;
 	if (scl == NOSCL)
 		return;		/* May be caused by a syntax error. */
 	lint_assert(scl == EXTERN || scl == STATIC);
 	check_global_variable_size(sym);
 	if (scl == STATIC)
 		check_static_global_variable(sym);
+}
-static void
+/*
-check_global_variable_size(const sym_t *sym)
+ * Called after the entire translation unit has been parsed.
  * Changes tentative definitions into definitions.
  * Performs some tests on global symbols. Detected problems are:
  * - defined variables of incomplete type
  * - constant variables which are not initialized
  * - static symbols which are never used
  */
 void
 check_global_symbols(void)
+{
 	sym_t *sym;
-	if (sym->s_def != TDEF)
+	if (block_level != 0 || dcs->d_enclosing != NULL)
-		return;
+		norecover();
 	if (sym->s_type->t_tspec == FUNC) {
 		/* Maybe a syntax error after a function declaration. */
 		return;
 	if (sym->s_def == TDEF && sym->s_type->t_tspec == VOID) {
 		/* Prevent an internal error in length_in_bits below. */
 		return;
 	pos_t cpos = curr_pos;
 	curr_pos = sym->s_def_pos;
 	int len_in_bits = length_in_bits(sym->s_type, sym->s_name);
 	curr_pos = cpos;
-	if (len_in_bits == 0 &&
+	for (sym = dcs->d_first_dlsym; sym != NULL; sym = sym->s_level_next) {
-	    sym->s_type->t_tspec == ARRAY && sym->s_type->t_dim == 0) {
+		if (sym->s_block_level == -1)
-		/* TODO: C99 6.7.5.2p1 defines this as an error as well. */
+			continue;
-		if (!allow_c90 ||
+		if (sym->s_kind == FVFT)
-		    (sym->s_scl == EXTERN && (allow_trad || allow_c99))) {
+			check_global_variable(sym);
-			/* empty array declaration for '%s' */
+		else if (sym->s_kind == FTAG)
-			warning_at(190, &sym->s_def_pos, sym->s_name);
+			check_tag_usage(sym);
-		} else {
+		else
-			/* empty array declaration for '%s' */
+			lint_assert(sym->s_kind == FMEMBER);
 			error_at(190, &sym->s_def_pos, sym->s_name);
+	}
+}
 /*
  * Prints information about location of previous definition/declaration.
  */
 void
 print_previous_declaration(const sym_t *psym)
+{
 	if (!rflag)
 		return;