 @@ -1,1831 +1,1833 @@
-/* $NetBSD: decl.c,v 1.200 2021/07/15 07:58:05 rin Exp $ */
+/* $NetBSD: decl.c,v 1.201 2021/07/15 21:56:51 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
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *      This product includes software developed by Jochen Pohl for
  *	The NetBSD Project.
  * 4. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID) && !defined(lint)
-__RCSID("$NetBSD: decl.c,v 1.200 2021/07/15 07:58:05 rin Exp $");
+__RCSID("$NetBSD: decl.c,v 1.201 2021/07/15 21:56:51 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;
 /* value of next enumerator during declaration of enum types */
 int	enumval;
 /*
  * pointer to top element of a stack which contains information local
  * to nested declarations
  */
 dinfo_t	*dcs;
 static	type_t	*tdeferr(type_t *, tspec_t);
 static	void	settdsym(type_t *, sym_t *);
 static	tspec_t	merge_type_specifiers(tspec_t, tspec_t);
 static	void	align(int, int);
 static	sym_t	*newtag(sym_t *, scl_t, bool, bool);
 static	bool	eqargs(const type_t *, const type_t *, bool *);
 static	bool	mnoarg(const type_t *, bool *);
 static	bool	check_old_style_definition(sym_t *, sym_t *);
 static	bool	check_prototype_declaration(sym_t *, sym_t *);
 static	sym_t	*new_style_function(sym_t *, 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
 #ifdef __sh3__
 /* XXX port-sh3/56311 */
 __attribute__((optimize("O0")))
 #endif
 initdecl(void)
+{
 	int i;
 	/* declaration stack */
 	dcs = xcalloc(1, sizeof(*dcs));
 	dcs->d_ctx = EXTERN;
 	dcs->d_ldlsym = &dcs->d_dlsyms;
 	/* type information and classification */
 	inittyp();
 	/* shared type structures */
 	typetab = xcalloc(NTSPEC, sizeof(*typetab));
 	for (i = 0; i < NTSPEC; i++)
 		typetab[i].t_tspec = NOTSPEC;
 	typetab[BOOL].t_tspec = BOOL;
 	typetab[CHAR].t_tspec = CHAR;
 	typetab[SCHAR].t_tspec = SCHAR;
 	typetab[UCHAR].t_tspec = UCHAR;
 	typetab[SHORT].t_tspec = SHORT;
 	typetab[USHORT].t_tspec = USHORT;
 	typetab[INT].t_tspec = INT;
 	typetab[UINT].t_tspec = UINT;
 	typetab[LONG].t_tspec = LONG;
 	typetab[ULONG].t_tspec = ULONG;
 	typetab[QUAD].t_tspec = QUAD;
 	typetab[UQUAD].t_tspec = UQUAD;
 	typetab[FLOAT].t_tspec = FLOAT;
 	typetab[DOUBLE].t_tspec = DOUBLE;
 	typetab[LDOUBLE].t_tspec = LDOUBLE;
 	typetab[FCOMPLEX].t_tspec = FCOMPLEX;
 	typetab[DCOMPLEX].t_tspec = DCOMPLEX;
 	typetab[LCOMPLEX].t_tspec = LCOMPLEX;
 	typetab[COMPLEX].t_tspec = COMPLEX;
 	typetab[VOID].t_tspec = VOID;
 	/*
 	 * Next two are not real types. They are only used by the parser
 	 * to return keywords "signed" and "unsigned"
 	 */
 	typetab[SIGNED].t_tspec = SIGNED;
 	typetab[UNSIGN].t_tspec = UNSIGN;
+}
 /*
  * Returns a shared type structure for arithmetic types and void.
+ *
  * It's important to duplicate this structure (using dup_type() or
  * expr_dup_type()) if it is to be modified (adding qualifiers or anything
  * else).
  */
 type_t *
 gettyp(tspec_t t)
+{
 	/* TODO: make the return type 'const' */
 	return &typetab[t];
+}
 type_t *
 dup_type(const type_t *tp)
+{
 	type_t	*ntp;
 	ntp = getblk(sizeof(*ntp));
 	*ntp = *tp;
 	return ntp;
+}
 /*
  * Use expr_dup_type() instead of dup_type() inside expressions (if the
  * allocated memory should be freed after the expr).
  */
 type_t *
 expr_dup_type(const type_t *tp)
+{
 	type_t	*ntp;
 	ntp = expr_zalloc(sizeof(*ntp));
 	*ntp = *tp;
 	return ntp;
+}
 /*
  * Returns whether the argument is void or an incomplete array,
  * struct, union or enum type.
  */
 bool
 is_incomplete(const type_t *tp)
+{
 	tspec_t	t;
 	if ((t = tp->t_tspec) == VOID) {
 		return true;
 	} else if (t == ARRAY) {
 		return tp->t_incomplete_array;
 	} else if (t == STRUCT || t == UNION) {
 		return tp->t_str->sou_incomplete;
 	} else if (t == ENUM) {
 		return tp->t_enum->en_incomplete;
+	}
 	return false;
+}
 /*
  * Mark an array, struct, union or enum type as complete or incomplete.
  */
 void
 setcomplete(type_t *tp, bool complete)
+{
 	tspec_t	t;
 	lint_assert(tp != NULL);
 	if ((t = tp->t_tspec) == ARRAY) {
 		tp->t_incomplete_array = !complete;
 	} else if (t == STRUCT || t == UNION) {
 		tp->t_str->sou_incomplete = !complete;
 	} else {
 		lint_assert(t == ENUM);
 		tp->t_enum->en_incomplete = !complete;
+	}
+}
 /*
  * Remember the storage class of the current declaration in dcs->d_scl
  * (the top element of the declaration stack) and detect multiple
  * storage classes.
  */
 void
 add_storage_class(scl_t sc)
+{
 	if (sc == INLINE) {
 		if (dcs->d_inline)
 			/* duplicate '%s' */
 			warning(10, "inline");
 		dcs->d_inline = true;
 		return;
+	}
 	if (dcs->d_type != NULL || dcs->d_abstract_type != NOTSPEC ||
 	    dcs->d_sign_mod != NOTSPEC || dcs->d_rank_mod != NOTSPEC) {
 		/* storage class after type is obsolescent */
 		warning(83);
+	}
 	if (dcs->d_scl == NOSCL) {
 		dcs->d_scl = sc;
 	} else {
 		/*
 		 * multiple storage classes. An error will be reported in
 		 * end_type().
 		 */
 		dcs->d_mscl = true;
+	}
+}
 /*
  * Remember the type, modifier or typedef name returned by the parser
  * in *dcs (top element of decl stack). This information is used in
  * end_type() to build the type used for all declarators in this
  * declaration.
+ *
  * If tp->t_typedef is 1, the type comes from a previously defined typename.
  * Otherwise it comes from a type specifier (int, long, ...) or a
  * struct/union/enum tag.
  */
 void
 add_type(type_t *tp)
+{
 	tspec_t	t;
 #ifdef DEBUG
 	printf("%s: %s\n", __func__, type_name(tp));
 #endif
 	if (tp->t_typedef) {
 		/*
 		 * something like "typedef int a; int a b;"
 		 * This should not happen with current grammar.
 		 */
 		lint_assert(dcs->d_type == NULL);
 		lint_assert(dcs->d_abstract_type == NOTSPEC);
 		lint_assert(dcs->d_sign_mod == NOTSPEC);
 		lint_assert(dcs->d_rank_mod == NOTSPEC);
 		dcs->d_type = tp;
 		return;
+	}
 	t = tp->t_tspec;
 	if (t == STRUCT || t == UNION || t == ENUM) {
 		/*
 		 * something like "int struct a ..."
 		 * struct/union/enum with anything else is not allowed
 		 */
 		if (dcs->d_type != NULL || dcs->d_abstract_type != NOTSPEC ||
 		    dcs->d_rank_mod != NOTSPEC || dcs->d_sign_mod != NOTSPEC) {
 			/*
 			 * remember that an error must be reported in
 			 * end_type().
 			 */
 			dcs->d_terr = true;
 			dcs->d_abstract_type = NOTSPEC;
 			dcs->d_sign_mod = NOTSPEC;
 			dcs->d_rank_mod = NOTSPEC;
+		}
 		dcs->d_type = tp;
 		return;
+	}
 	if (dcs->d_type != NULL && !dcs->d_type->t_typedef) {
 		/*
 		 * something like "struct a int"
 		 * struct/union/enum with anything else is not allowed
 		 */
 		dcs->d_terr = true;
 		return;
+	}
 	if (t == COMPLEX) {
 		if (dcs->d_complex_mod == FLOAT)
 			t = FCOMPLEX;
 		else if (dcs->d_complex_mod == DOUBLE)
 			t = DCOMPLEX;
 		else {
 			/* invalid type for _Complex */
 			error(308);
 			t = DCOMPLEX; /* just as a fallback */
+		}
 		dcs->d_complex_mod = NOTSPEC;
+	}
 	if (t == LONG && dcs->d_rank_mod == LONG) {
 		/* "long long" or "long ... long" */
 		t = QUAD;
 		dcs->d_rank_mod = NOTSPEC;
 		if (!quadflg)
 			/* %s C does not support 'long long' */
 			c99ism(265, tflag ? "traditional" : "c89");
+	}
 	if (dcs->d_type != NULL && dcs->d_type->t_typedef) {
 		/* something like "typedef int a; a long ..." */
 		dcs->d_type = tdeferr(dcs->d_type, t);
 		return;
+	}
 	/* now it can be only a combination of arithmetic types and void */
 	if (t == SIGNED || t == UNSIGN) {
 		/*
 		 * remember specifiers "signed" & "unsigned" in
 		 * dcs->d_sign_mod
 		 */
 		if (dcs->d_sign_mod != NOTSPEC)
 			/*
 			 * more than one "signed" and/or "unsigned"; print
 			 * an error in end_type()
 			 */
 			dcs->d_terr = true;
 		dcs->d_sign_mod = t;
 	} else if (t == SHORT || t == LONG || t == QUAD) {
 		/*
 		 * remember specifiers "short", "long" and "long long" in
 		 * dcs->d_rank_mod
 		 */
 		if (dcs->d_rank_mod != NOTSPEC)
 			/* more than one, print error in end_type() */
 			dcs->d_terr = true;
 		dcs->d_rank_mod = t;
 	} else if (t == FLOAT || t == DOUBLE) {
 		if (dcs->d_rank_mod == NOTSPEC || dcs->d_rank_mod == LONG) {
 			if (dcs->d_complex_mod != NOTSPEC
 			    || (t == FLOAT && dcs->d_rank_mod == LONG))
 				dcs->d_terr = true;
 			dcs->d_complex_mod = t;
 		} else {
 			if (dcs->d_abstract_type != NOTSPEC)
 				dcs->d_terr = true;
 			dcs->d_abstract_type = t;
+		}
 	} else if (t == PTR) {
 		dcs->d_type = tp;
 	} else {
 		/*
 		 * remember specifiers "void", "char", "int",
 		 * or "_Complex" in dcs->d_abstract_type
 		 */
 		if (dcs->d_abstract_type != NOTSPEC)
 			/* more than one, print error in end_type() */
 			dcs->d_terr = true;
 		dcs->d_abstract_type = t;
+	}
+}
 /*
  * called if a list of declaration specifiers contains a typedef name
  * and other specifiers (except struct, union, enum, typedef name)
  */
 static type_t *
 tdeferr(type_t *td, tspec_t t)
+{
 	tspec_t	t2;
 	t2 = td->t_tspec;
 	switch (t) {
 	case SIGNED:
 	case UNSIGN:
 		if (t2 == CHAR || t2 == SHORT || t2 == INT || t2 == LONG ||
 		    t2 == QUAD) {
 			if (!tflag)
 				/* modifying typedef with '%s'; only ... */
 				warning(5, ttab[t].tt_name);
 			td = dup_type(gettyp(merge_type_specifiers(t2, t)));
 			td->t_typedef = true;
 			return td;
+		}
 		break;
 	case SHORT:
 		if (t2 == INT || t2 == UINT) {
 			/* modifying typedef with '%s'; only qualifiers ... */
 			warning(5, "short");
 			td = dup_type(gettyp(t2 == INT ? SHORT : USHORT));
 			td->t_typedef = true;
 			return td;
+		}
 		break;
 	case LONG:
 		if (t2 == INT || t2 == UINT || t2 == LONG || t2 == ULONG ||
 		    t2 == FLOAT || t2 == DOUBLE || t2 == DCOMPLEX) {
 			/* modifying typedef with '%s'; only qualifiers ... */
 			warning(5, "long");
 			if (t2 == INT) {
 				td = gettyp(LONG);
 			} else if (t2 == UINT) {
 				td = gettyp(ULONG);
 			} else if (t2 == LONG) {
 				td = gettyp(QUAD);
 			} else if (t2 == ULONG) {
 				td = gettyp(UQUAD);
 			} else if (t2 == FLOAT) {
 				td = gettyp(DOUBLE);
 			} else if (t2 == DOUBLE) {
 				td = gettyp(LDOUBLE);
 			} else if (t2 == DCOMPLEX) {
 				td = gettyp(LCOMPLEX);
+			}
 			td = dup_type(td);
 			td->t_typedef = true;
 			return td;
+		}
 		break;
 		/* LINTED206: (enumeration values not handled in switch) */
 	case NOTSPEC:
 	case USHORT:
 	case UCHAR:
 	case SCHAR:
 	case CHAR:
 	case BOOL:
 	case FUNC:
 	case ARRAY:
 	case PTR:
 	case ENUM:
 	case UNION:
 	case STRUCT:
 	case VOID:
 	case LDOUBLE:
 	case FLOAT:
 	case DOUBLE:
 	case UQUAD:
 	case QUAD:
 #ifdef INT128_SIZE
 	case UINT128:
 	case INT128:
 #endif
 	case ULONG:
 	case UINT:
 	case INT:
 	case FCOMPLEX:
 	case DCOMPLEX:
 	case LCOMPLEX:
 	case COMPLEX:
 		break;
+	}
 	/* Anything other is not accepted. */
 	dcs->d_terr = true;
 	return td;
+}
 /*
  * Remember the symbol of a typedef name (2nd arg) in a struct, union
  * or enum tag if the typedef name is the first defined for this tag.
+ *
  * If the tag is unnamed, the typdef name is used for identification
  * of this tag in lint2. Although it's possible that more than one typedef
  * name is defined for one tag, the first name defined should be unique
  * if the tag is unnamed.
  */
 static void
 settdsym(type_t *tp, sym_t *sym)
+{
 	tspec_t	t;
 	if ((t = tp->t_tspec) == STRUCT || t == UNION) {
 		if (tp->t_str->sou_first_typedef == NULL)
 			tp->t_str->sou_first_typedef = sym;
 	} else if (t == ENUM) {
 		if (tp->t_enum->en_first_typedef == NULL)
 			tp->t_enum->en_first_typedef = sym;
+	}
+}
 static size_t
 bitfieldsize(sym_t **mem)
+{
 	size_t len = (*mem)->s_type->t_flen;
 	while (*mem != NULL && (*mem)->s_type->t_bitfield) {
 		len += (*mem)->s_type->t_flen;
 		*mem = (*mem)->s_next;
+	}
 	return ((len + INT_SIZE - 1) / INT_SIZE) * INT_SIZE;
+}
 static void
 setpackedsize(type_t *tp)
+{
 	struct_or_union *sp;
 	sym_t *mem;
 	switch (tp->t_tspec) {
 	case STRUCT:
 	case UNION:
 		sp = tp->t_str;
 		sp->sou_size_in_bits = 0;
 		for (mem = sp->sou_first_member;
 		     mem != NULL; mem = mem->s_next) {
 			if (mem->s_type->t_bitfield) {
 				sp->sou_size_in_bits += bitfieldsize(&mem);
 				if (mem == NULL)
 					break;
+			}
 			size_t x = (size_t)type_size_in_bits(mem->s_type);
 			if (tp->t_tspec == STRUCT)
 				sp->sou_size_in_bits += x;
 			else if (x > sp->sou_size_in_bits)
 				sp->sou_size_in_bits = x;
+		}
 		break;
 	default:
 		/* %s attribute ignored for %s */
 		warning(326, "packed", type_name(tp));
 		break;
+	}
+}
 void
 addpacked(void)
+{
 	if (dcs->d_type == NULL)
 		dcs->d_packed = true;
 	else
 		setpackedsize(dcs->d_type);
+}
 void
 add_attr_used(void)
+{
 	dcs->d_used = true;
+}
 /*
  * Remember a qualifier which is part of the declaration specifiers
  * (and not the declarator) in the top element of the declaration stack.
  * Also detect multiple qualifiers of the same kind.
  * The remembered qualifier is used by end_type() to construct the type
  * for all declarators.
  */
 void
 add_qualifier(tqual_t q)
+{
 	if (q == CONST) {
 		if (dcs->d_const) {
 			/* duplicate '%s' */
 			warning(10, "const");
+		}
 		dcs->d_const = true;
 	} else if (q == VOLATILE) {
 		if (dcs->d_volatile) {
 			/* duplicate '%s' */
 			warning(10, "volatile");
+		}
 		dcs->d_volatile = true;
 	} else {
 		lint_assert(q == RESTRICT || q == THREAD);
 		/* Silently ignore these qualifiers. */
+	}
+}
 /*
  * Go to the next declaration level (structs, nested structs, blocks,
  * argument declaration lists ...)
  */
 void
 begin_declaration_level(scl_t sc)
+{
 	dinfo_t	*di;
 	/* put a new element on the declaration stack */
 	di = xcalloc(1, sizeof(*di));
 	di->d_next = dcs;
 	dcs = di;
 	di->d_ctx = sc;
 	di->d_ldlsym = &di->d_dlsyms;
 	if (dflag)
 		(void)printf("%s(%p %s)\n", __func__, dcs, scl_name(sc));
+}
 /*
  * Go back to previous declaration level
  */
 void
 end_declaration_level(void)
+{
 	dinfo_t	*di;
 	if (dflag)
 		(void)printf("%s(%p %s)\n",
 		    __func__, dcs, scl_name(dcs->d_ctx));
 	lint_assert(dcs->d_next != NULL);
 	di = dcs;
 	dcs = di->d_next;
 	switch (di->d_ctx) {
 	case MOS:
 	case MOU:
 	case CTCONST:
 		/*
 		 * Symbols declared in (nested) structs or enums are
 		 * part of the next level (they are removed from the
 		 * symbol table if the symbols of the outer level are
 		 * removed).
 		 */
 		if ((*dcs->d_ldlsym = di->d_dlsyms) != NULL)
 			dcs->d_ldlsym = di->d_ldlsym;
 		break;
 	case ARG:
 		/*
 		 * All symbols in dcs->d_dlsyms are introduced in old style
 		 * argument declarations (it's not clean, but possible).
 		 * They are appended to the list of symbols declared in
 		 * an old style argument identifier list or a new style
 		 * parameter type list.
 		 */
 		if (di->d_dlsyms != NULL) {
 			*di->d_ldlsym = dcs->d_func_proto_syms;
 			dcs->d_func_proto_syms = di->d_dlsyms;
+		}
 		break;
 	case ABSTRACT:
 		/*
 		 * casts and sizeof
 		 * Append all symbols declared in the abstract declaration
 		 * to the list of symbols declared in the surrounding
 		 * declaration or block.
 		 * XXX I'm not sure whether they should be removed from the
 		 * symbol table now or later.
 		 */
 		if ((*dcs->d_ldlsym = di->d_dlsyms) != NULL)
 			dcs->d_ldlsym = di->d_ldlsym;
 		break;
 	case AUTO:
 		/* check usage of local vars */
 		check_usage(di);
 		/* FALLTHROUGH */
 	case PROTO_ARG:
 		/* usage of arguments will be checked by funcend() */
 		rmsyms(di->d_dlsyms);
 		break;
 	case EXTERN:
 		/* there is nothing after external declarations */
 		/* FALLTHROUGH */
 	default:
 		lint_assert(/*CONSTCOND*/false);
+	}
 	free(di);
+}
 /*
  * Set flag d_asm in all declaration stack elements up to the
  * outermost one.
+ *
  * This is used to mark compound statements which have, possibly in
  * nested compound statements, asm statements. For these compound
  * statements no warnings about unused or uninitialized variables are
  * printed.
+ *
  * There is no need to clear d_asm in dinfo structs with context AUTO,
  * because these structs are freed at the end of the compound statement.
  * But it must be cleared in the outermost dinfo struct, which has
  * context EXTERN. This could be done in begin_type() and would work for C90,
  * but not for C99 or C++ (due to mixed statements and declarations). Thus
  * we clear it in global_clean_up_decl(), which is used to do some cleanup
  * after global declarations/definitions.
  */
 void
 setasm(void)
+{
 	dinfo_t	*di;
 	for (di = dcs; di != NULL; di = di->d_next)
 		di->d_asm = true;
+}
 /*
  * Clean all elements of the top element of declaration stack which
  * will be used by the next declaration
  */
 void
 begin_type(void)
+{
 	dcs->d_abstract_type = NOTSPEC;
 	dcs->d_complex_mod = NOTSPEC;
 	dcs->d_sign_mod = NOTSPEC;
 	dcs->d_rank_mod = NOTSPEC;
 	dcs->d_scl = NOSCL;
 	dcs->d_type = NULL;
 	dcs->d_const = false;
 	dcs->d_volatile = false;
 	dcs->d_inline = false;
 	dcs->d_mscl = false;
 	dcs->d_terr = false;
 	dcs->d_nonempty_decl = false;
 	dcs->d_notyp = false;
+}
 static void
 dcs_adjust_storage_class(void)
+{
 	if (dcs->d_ctx == EXTERN) {
 		if (dcs->d_scl == REG || dcs->d_scl == AUTO) {
 			/* illegal storage class */
 			error(8);
 			dcs->d_scl = NOSCL;
+		}
 	} else if (dcs->d_ctx == ARG || dcs->d_ctx == PROTO_ARG) {
 		if (dcs->d_scl != NOSCL && dcs->d_scl != REG) {
 			/* only register valid as formal parameter storage... */
 			error(9);
 			dcs->d_scl = NOSCL;
+		}
+	}
+}
 /*
  * Create a type structure from the information gathered in
  * the declaration stack.
  * Complain about storage classes which are not possible in current
  * context.
  */
 void
 end_type(void)
+{
 	tspec_t	t, s, l, c;
 	type_t	*tp;
 	t = dcs->d_abstract_type; /* VOID, BOOL, CHAR, INT or COMPLEX */
 	c = dcs->d_complex_mod;	/* FLOAT or DOUBLE */
 	s = dcs->d_sign_mod;	/* SIGNED or UNSIGN */
 	l = dcs->d_rank_mod;	/* SHORT, LONG or QUAD */
 	tp = dcs->d_type;
 #ifdef DEBUG
 	printf("%s: %s\n", __func__, type_name(tp));
 #endif
 	if (t == NOTSPEC && s == NOTSPEC && l == NOTSPEC && c == NOTSPEC &&
 	    tp == NULL)
 		dcs->d_notyp = true;
 	if (t == NOTSPEC && s == NOTSPEC && (l == NOTSPEC || l == LONG) &&
 	    tp == NULL)
 		t = c;
 	if (tp != NULL) {
 		lint_assert(t == NOTSPEC);
 		lint_assert(s == NOTSPEC);
 		lint_assert(l == NOTSPEC);
+	}
 	if (tp == NULL) {
 		switch (t) {
 		case BOOL:
 			break;
 		case NOTSPEC:
 			t = INT;
 			/* FALLTHROUGH */
 		case INT:
 			if (s == NOTSPEC)
 				s = SIGNED;
 			break;
 		case CHAR:
 			if (l != NOTSPEC) {
 				dcs->d_terr = true;
 				l = NOTSPEC;
+			}
 			break;
 		case FLOAT:
 			if (l == LONG) {
 				l = NOTSPEC;
 				t = DOUBLE;
 				if (!tflag)
 					/* use 'double' instead of 'long ... */
 					warning(6);
+			}
 			break;
 		case DOUBLE:
 			if (l == LONG) {
 		case LDOUBLE:
 				l = NOTSPEC;
 				t = LDOUBLE;
 				if (tflag)
 					/* 'long double' is illegal in ... */
 					warning(266);
+			}
 			break;
 		case DCOMPLEX:
 			if (l == LONG) {
 				l = NOTSPEC;
 				t = LCOMPLEX;
 				if (tflag)
 					/* 'long double' is illegal in ... */
 					warning(266);
+			}
 			break;
 		case VOID:
 		case FCOMPLEX:
 		case LCOMPLEX:
 			break;
 		default:
 			if (is_integer(t))
 				break;
 			INTERNAL_ERROR("end_type(%s)", tspec_name(t));
+		}
 		if (t != INT && t != CHAR && (s != NOTSPEC || l != NOTSPEC)) {
 			dcs->d_terr = true;
 			l = s = NOTSPEC;
+		}
 		if (l != NOTSPEC)
 			t = l;
 		dcs->d_type = gettyp(merge_type_specifiers(t, s));
+	}
 	if (dcs->d_mscl) {
 		/* only one storage class allowed */
 		error(7);
+	}
 	if (dcs->d_terr) {
 		/* illegal type combination */
 		error(4);
+	}
 	dcs_adjust_storage_class();
 	if (dcs->d_const && dcs->d_type->t_const) {
 		lint_assert(dcs->d_type->t_typedef);
 		/* typedef already qualified with '%s' */
 		warning(68, "const");
+	}
 	if (dcs->d_volatile && dcs->d_type->t_volatile) {
 		lint_assert(dcs->d_type->t_typedef);
 		/* typedef already qualified with '%s' */
 		warning(68, "volatile");
+	}
 	if (dcs->d_const || dcs->d_volatile) {
 		dcs->d_type = dup_type(dcs->d_type);
 		dcs->d_type->t_const |= dcs->d_const;
 		dcs->d_type->t_volatile |= dcs->d_volatile;
+	}
+}
 /*
  * Merge type specifiers (char, ..., long long, signed, unsigned).
  */
 static tspec_t
 merge_type_specifiers(tspec_t t, tspec_t s)
+{
 	if (s != SIGNED && s != UNSIGN)
 		return t;
 	if (t == CHAR)
 		return s == SIGNED ? SCHAR : UCHAR;
 	if (t == SHORT)
 		return s == SIGNED ? SHORT : USHORT;
 	if (t == INT)
 		return s == SIGNED ? INT : UINT;
 	if (t == LONG)
 		return s == SIGNED ? LONG : ULONG;
 	if (t == QUAD)
 		return s == SIGNED ? QUAD : UQUAD;
 	return t;
+}
 /*
  * Return the length of a type in bits.
+ *
  * Printing a message if the outermost dimension of an array is 0 must
  * be done by the caller. All other problems are reported by length()
  * if name is not NULL.
  */
 int
 length(const type_t *tp, const char *name)
+{
 	int	elem, elsz;
 	elem = 1;
 	while (tp != NULL && tp->t_tspec == ARRAY) {
 		elem *= tp->t_dim;
 		tp = tp->t_subt;
+	}
 	if (tp == NULL)
 		return -1;
 	switch (tp->t_tspec) {
 	case FUNC:
 		/* compiler takes size of function */
 		INTERNAL_ERROR("%s", msgs[12]);
 		/* NOTREACHED */
 	case STRUCT:
 	case UNION:
 		if (is_incomplete(tp) && name != NULL) {
 			/* '%s' has incomplete type '%s' */
 			error(31, name, type_name(tp));
+		}
 		elsz = tp->t_str->sou_size_in_bits;
 		break;
 	case ENUM:
 		if (is_incomplete(tp) && name != NULL) {
 			/* incomplete enum type: %s */
 			warning(13, name);
+		}
 		/* FALLTHROUGH */
 	default:
 		elsz = size_in_bits(tp->t_tspec);
 		if (elsz <= 0)
 			INTERNAL_ERROR("length(%d)", elsz);
 		break;
+	}
 	return elem * elsz;
+}
 int
 alignment_in_bits(const type_t *tp)
+{
 	size_t	a;
 	tspec_t	t;
 	while (tp != NULL && tp->t_tspec == ARRAY)
 		tp = tp->t_subt;
 	if (tp == NULL)
 		return -1;
 	if ((t = tp->t_tspec) == STRUCT || t == UNION) {
 		a = tp->t_str->sou_align_in_bits;
 	} else if (t == FUNC) {
 		/* compiler takes alignment of function */
 		error(14);
 		a = WORST_ALIGN(1) * CHAR_SIZE;
 	} else {
 		if ((a = size_in_bits(t)) == 0) {
 			a = CHAR_SIZE;
 		} else if (a > WORST_ALIGN(1) * CHAR_SIZE) {
 			a = WORST_ALIGN(1) * CHAR_SIZE;
+		}
+	}
 	lint_assert(a >= CHAR_SIZE);
 	lint_assert(a <= WORST_ALIGN(1) * CHAR_SIZE);
 	return a;
+}
 /*
  * Concatenate two lists of symbols by s_next. Used by declarations of
  * struct/union/enum elements and parameters.
  */
 sym_t *
 lnklst(sym_t *l1, sym_t *l2)
+{
 	sym_t	*l;
 	if ((l = l1) == NULL)
 		return l2;
 	while (l1->s_next != NULL)
 		l1 = l1->s_next;
 	l1->s_next = l2;
 	return l;
+}
 /*
  * Check if the type of the given symbol is valid and print an error
  * message if it is not.
+ *
  * Invalid types are:
  * - arrays of incomplete types or functions
  * - functions returning arrays or functions
  * - void types other than type of function or pointer
  */
 void
 check_type(sym_t *sym)
+{
 	tspec_t	to, t;
 	type_t	**tpp, *tp;
 	tpp = &sym->s_type;
 	to = NOTSPEC;
 	while ((tp = *tpp) != NULL) {
 		t = tp->t_tspec;
 		/*
 		 * If this is the type of an old style function definition,
 		 * a better warning is printed in funcdef().
 		 */
 		if (t == FUNC && !tp->t_proto &&
 		    !(to == NOTSPEC && sym->s_osdef)) {
 			if (sflag && hflag)
 				/* function declaration is not a prototype */
 				warning(287);
+		}
 		if (to == FUNC) {
 			if (t == FUNC || t == ARRAY) {
 				/* function returns illegal type */
 				error(15);
 				if (t == FUNC) {
 					*tpp = derive_type(*tpp, PTR);
 				} else {
 					*tpp = derive_type((*tpp)->t_subt, PTR);
+				}
 				return;
 			} else if (tp->t_const || tp->t_volatile) {
 				if (sflag) {	/* XXX or better !tflag ? */
 					/* function cannot return const... */
 					warning(228);
+				}
+			}
 		} if (to == ARRAY) {
 			if (t == FUNC) {
 				/* array of function is illegal */
 				error(16);
 				*tpp = gettyp(INT);
 				return;
 			} else if (t == ARRAY && tp->t_dim == 0) {
 				/* null dimension */
 				error(17);
 				return;
 			} else if (t == VOID) {
 				/* illegal use of 'void' */
 				error(18);
 				*tpp = gettyp(INT);
 #if 0	/* errors are produced by length() */
 			} else if (is_incomplete(tp)) {
 				/* array of incomplete type */
 				if (sflag) {
 					/* array of incomplete type */
 					error(301);
 				} else {
 					/* array of incomplete type */
 					warning(301);
+				}
 #endif
+			}
 		} else if (to == NOTSPEC && t == VOID) {
 			if (dcs->d_ctx == PROTO_ARG) {
 				if (sym->s_scl != ABSTRACT) {
 					lint_assert(sym->s_name != unnamed);
 					/* void param. cannot have name: %s */
 					error(61, sym->s_name);
 					*tpp = gettyp(INT);
+				}
 			} else if (dcs->d_ctx == ABSTRACT) {
 				/* ok */
 			} else if (sym->s_scl != TYPEDEF) {
 				/* void type for '%s' */
 				error(19, sym->s_name);
 				*tpp = gettyp(INT);
+			}
+		}
 		if (t == VOID && to != PTR) {
 			if (tp->t_const || tp->t_volatile) {
 				/* inappropriate qualifiers with 'void' */
 				warning(69);
 				tp->t_const = tp->t_volatile = false;
+			}
+		}
 		tpp = &tp->t_subt;
 		to = t;
+	}
+}
 /*
  * In traditional C, the only portable type for bit-fields is unsigned int.
+ *
  * In C90, the only allowed types for bit-fields are int, signed int and
  * unsigned int (3.5.2.1).  There is no mention of implementation-defined
  * types.
+ *
  * In C99, the only portable types for bit-fields are _Bool, signed int and
  * unsigned int (6.7.2.1p4).  In addition, C99 allows "or some other
  * implementation-defined type".
  */
 static void
 check_bit_field_type(sym_t *dsym,  type_t **const inout_tp, tspec_t *inout_t)
+{
 	type_t *tp = *inout_tp;
 	tspec_t t = *inout_t;
 	if (t == CHAR || t == UCHAR || t == SCHAR ||
 	    t == SHORT || t == USHORT || t == ENUM) {
 		if (!bitfieldtype_ok) {
 			if (sflag) {
 				/* bit-field type '%s' invalid in ANSI C */
 				warning(273, type_name(tp));
 			} else if (pflag) {
 				/* nonportable bit-field type '%s' */
 				warning(34, type_name(tp));
+			}
+		}
 	} else if (t == INT && dcs->d_sign_mod == NOTSPEC) {
 		if (pflag && !bitfieldtype_ok) {
 			/* bit-field of type plain 'int' has ... */
 			warning(344);
+		}
 	} else if (t != INT && t != UINT && t != BOOL) {
 		/*
 		 * Non-integer types are always illegal for bitfields,
 		 * regardless of BITFIELDTYPE. Integer types not dealt with
 		 * above are okay only if BITFIELDTYPE is in effect.
 		 */
 		if (!(bitfieldtype_ok || gflag) || !is_integer(t)) {
 			/* illegal bit-field type '%s' */
 			warning(35, type_name(tp));
 			int sz = tp->t_flen;
 			dsym->s_type = tp = dup_type(gettyp(t = INT));
 			if ((tp->t_flen = sz) > size_in_bits(t))
 				tp->t_flen = size_in_bits(t);
 			*inout_t = t;
 			*inout_tp = tp;
+		}
+	}
+}
 static void
 declare_bit_field(sym_t *dsym, tspec_t *inout_t, type_t **const inout_tp)
+{
 	check_bit_field_type(dsym, inout_tp, inout_t);
 	type_t *const tp = *inout_tp;
 	tspec_t const t = *inout_t;
 	if (tp->t_flen < 0 || tp->t_flen > (ssize_t)size_in_bits(t)) {
 		/* illegal bit-field size: %d */
 		error(36, tp->t_flen);
 		tp->t_flen = size_in_bits(t);
 	} else if (tp->t_flen == 0 && dsym->s_name != unnamed) {
 		/* zero size bit-field */
 		error(37);
 		tp->t_flen = size_in_bits(t);
+	}
 	if (dsym->s_scl == MOU) {
 		/* illegal use of bit-field */
 		error(41);
 		dsym->s_type->t_bitfield = false;
 		dsym->s_bitfield = false;
+	}
+}
 /*
  * Process the declarator of a struct/union element.
  */
 sym_t *
 declarator_1_struct_union(sym_t *dsym)
+{
 	type_t	*tp;
 	tspec_t	t;
 	int	sz;
 	int	o = 0;	/* Appease GCC */
 	lint_assert(dsym->s_scl == MOS || dsym->s_scl == MOU);
 	if (dcs->d_redeclared_symbol != NULL) {
 		/* should be ensured by storesym() */
 		lint_assert(dcs->d_redeclared_symbol->s_scl == MOS ||
 		    dcs->d_redeclared_symbol->s_scl == MOU);
 		if (dsym->s_styp == dcs->d_redeclared_symbol->s_styp) {
 			/* duplicate member name: %s */
 			error(33, dsym->s_name);
 			rmsym(dcs->d_redeclared_symbol);
+		}
+	}
 	check_type(dsym);
 	t = (tp = dsym->s_type)->t_tspec;
 	if (dsym->s_bitfield) {
 		declare_bit_field(dsym, &t, &tp);
 	} else if (t == FUNC) {
 		/* function illegal in structure or union */
 		error(38);
 		dsym->s_type = tp = derive_type(tp, t = PTR);
+	}
 	/*
 	 * bit-fields of length 0 are not warned about because length()
 	 * does not return the length of the bit-field but the length
 	 * of the type the bit-field is packed in (it's ok)
 	 */
 	if ((sz = length(dsym->s_type, dsym->s_name)) == 0) {
 		if (t == ARRAY && dsym->s_type->t_dim == 0) {
 			/* zero sized array in struct is a C99 extension: %s */
 			c99ism(39, dsym->s_name);
+		}
+	}
 	if (dcs->d_ctx == MOU) {
 		o = dcs->d_offset;
 		dcs->d_offset = 0;
+	}
 	if (dsym->s_bitfield) {
 		align(alignment_in_bits(tp), tp->t_flen);
 		dsym->s_value.v_quad =
 		    (dcs->d_offset / size_in_bits(t)) * size_in_bits(t);
 		tp->t_foffs = dcs->d_offset - (int)dsym->s_value.v_quad;
 		dcs->d_offset += tp->t_flen;
 	} else {
 		align(alignment_in_bits(tp), 0);
 		dsym->s_value.v_quad = dcs->d_offset;
 		dcs->d_offset += sz;
+	}
 	if (dcs->d_ctx == MOU) {
 		if (o > dcs->d_offset)
 			dcs->d_offset = o;
+	}
 	check_function_definition(dsym, false);
 	/*
 	 * Clear the BITFIELDTYPE indicator after processing each
 	 * structure element.
 	 */
 	bitfieldtype_ok = false;
 	return dsym;
+}
 /*
  * Aligns next structure element as required.
+ *
  * al contains the required alignment, len the length of a bit-field.
  */
 static void
 align(int al, int len)
+{
 	int	no;
 	/*
 	 * The alignment of the current element becomes the alignment of
 	 * the struct/union if it is larger than the current alignment
 	 * of the struct/union.
 	 */
 	if (al > dcs->d_sou_align_in_bits)
 		dcs->d_sou_align_in_bits = al;
 	no = (dcs->d_offset + (al - 1)) & ~(al - 1);
 	if (len == 0 || dcs->d_offset + len > no)
 		dcs->d_offset = no;
+}
 /*
  * Remember the width of the field in its type structure.
  */
 sym_t *
 bitfield(sym_t *dsym, int len)
+{
 	if (dsym == NULL) {
 		dsym = getblk(sizeof(*dsym));
 		dsym->s_name = unnamed;
 		dsym->s_kind = FMEMBER;
 		dsym->s_scl = MOS;
 		dsym->s_type = gettyp(UINT);
 		dsym->s_block_level = -1;
+	}
 	dsym->s_type = dup_type(dsym->s_type);
 	dsym->s_type->t_bitfield = true;
 	dsym->s_type->t_flen = len;
 	dsym->s_bitfield = true;
 	return dsym;
+}
 /*
  * A sequence of asterisks and qualifiers, from right to left.  For example,
  * 'const ***volatile **const volatile' results in [cvp, p, vp, p, p].  The
  * leftmost 'const' is not included in this list, it is stored in dcs->d_const
  * instead.
  */
 qual_ptr *
 merge_qualified_pointer(qual_ptr *p1, qual_ptr *p2)
+{
 	qual_ptr *tail;
 	if (p2 == NULL)
 		return p1;	/* for optional qualifiers */
 	if (p2->p_pointer) {
 		/* append p1 to p2, keeping p2 */
 		for (tail = p2; tail->p_next != NULL; tail = tail->p_next)
 			continue;
 		tail->p_next = p1;
 		return p2;
+	}
 	/* merge p2 into p1, keeping p1 */
 	if (p2->p_const) {
 		if (p1->p_const) {
 			/* duplicate '%s' */
 			warning(10, "const");
+		}
 		p1->p_const = true;
+	}
 	if (p2->p_volatile) {
 		if (p1->p_volatile) {
 			/* duplicate '%s' */
 			warning(10, "volatile");
+		}
 		p1->p_volatile = true;
+	}
 	free(p2);
 	return p1;
+}
 /*
  * The following 3 functions extend the type of a declarator with
  * pointer, function and array types.
+ *
  * The current type is the type built by end_type() (dcs->d_type) and
  * pointer, function and array types already added for this
  * declarator. The new type extension is inserted between both.
  */
 sym_t *
 add_pointer(sym_t *decl, qual_ptr *p)
+{
 	type_t **tpp, *tp;
 	qual_ptr *next;
 	tpp = &decl->s_type;
 	while (*tpp != NULL && *tpp != dcs->d_type)
 		tpp = &(*tpp)->t_subt;
 	if (*tpp == NULL)
 		return decl;
 	while (p != NULL) {
 		*tpp = tp = getblk(sizeof(*tp));
 		tp->t_tspec = PTR;
 		tp->t_const = p->p_const;
 		tp->t_volatile = p->p_volatile;
 		*(tpp = &tp->t_subt) = dcs->d_type;
 		next = p->p_next;
 		free(p);
 		p = next;
+	}
 	return decl;
+}
 /*
  * If a dimension was specified, dim is true, otherwise false
  * n is the specified dimension
  */
 sym_t *
 add_array(sym_t *decl, bool dim, int n)
+{
 	type_t	**tpp, *tp;
 	tpp = &decl->s_type;
 	while (*tpp != NULL && *tpp != dcs->d_type)
 		tpp = &(*tpp)->t_subt;
 	if (*tpp == NULL)
 	    return decl;
 	*tpp = tp = getblk(sizeof(*tp));
 	tp->t_tspec = ARRAY;
 	tp->t_subt = dcs->d_type;
 	tp->t_dim = n;
 	if (n < 0) {
 		/* negative array dimension (%d) */
 		error(20, n);
 		n = 0;
 	} else if (n == 0 && dim) {
 		/* zero sized array is a C99 extension */
 		c99ism(322);
 	} else if (n == 0 && !dim) {
 		setcomplete(tp, false);
+	}
 	return decl;
+}
 sym_t *
 add_function(sym_t *decl, sym_t *args)
+{
 	type_t	**tpp, *tp;
 	if (dcs->d_proto) {
 		if (tflag)
 			/* function prototypes are illegal in traditional C */
 			warning(270);
 		args = new_style_function(decl, args);
 	} else {
 		old_style_function(decl, args);
+	}
 	/*
 	 * The symbols are removed from the symbol table by
 	 * end_declaration_level after add_function. To be able to restore
 	 * them if this is a function definition, a pointer to the list of all
 	 * symbols is stored in dcs->d_next->d_func_proto_syms. Also a list of
 	 * the arguments (concatenated by s_next) is stored in
 	 * dcs->d_next->d_func_args. (dcs->d_next must be used because *dcs is
 	 * the declaration stack element created for the list of params and is
 	 * removed after add_function.)
 	 */
 	if (dcs->d_next->d_ctx == EXTERN &&
 	    decl->s_type == dcs->d_next->d_type) {
 		dcs->d_next->d_func_proto_syms = dcs->d_dlsyms;
 		dcs->d_next->d_func_args = args;
+	}
 	tpp = &decl->s_type;
 	while (*tpp != NULL && *tpp != dcs->d_next->d_type)
 		tpp = &(*tpp)->t_subt;
 	if (*tpp == NULL)
 	    return decl;
 	*tpp = tp = getblk(sizeof(*tp));
 	tp->t_tspec = FUNC;
 	tp->t_subt = dcs->d_next->d_type;
 	if ((tp->t_proto = dcs->d_proto) != false)
 		tp->t_args = args;
 	tp->t_vararg = dcs->d_vararg;
 	return decl;
+}
 /*
  * Called for new style function declarations.
  */
 /* ARGSUSED */
 static sym_t *
 new_style_function(sym_t *decl, sym_t *args)
+{
 	sym_t	*arg, *sym;
 	scl_t	sc;
 	int	n;
 	/*
 	 * Declarations of structs/unions/enums in param lists are legal,
 	 * but senseless.
 	 */
 	for (sym = dcs->d_dlsyms; sym != NULL; sym = sym->s_dlnxt) {
 		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);
+		}
+	}
 	n = 1;
 	for (arg = args; arg != NULL; arg = arg->s_next) {
 		if (arg->s_type->t_tspec == VOID) {
 			if (n > 1 || arg->s_next != NULL) {
 				/* void must be sole parameter */
 				error(60);
 				arg->s_type = gettyp(INT);
+			}
+		}
 		n++;
+	}
 	/* return NULL if first param is VOID */
 	return args != NULL && args->s_type->t_tspec != VOID ? args : NULL;
+}
 /*
  * Called for old style function declarations.
  */
 static void
 old_style_function(sym_t *decl, sym_t *args)
+{
 	/*
 	 * Remember list of params only if this is really seams to be
 	 * a function definition.
 	 */
 	if (dcs->d_next->d_ctx == EXTERN &&
 	    decl->s_type == dcs->d_next->d_type) {
 		/*
 		 * We assume that this becomes a function definition. If
 		 * we are wrong, it's corrected in check_function_definition().
 		 */
 		if (args != NULL) {
 			decl->s_osdef = true;
 			decl->s_args = args;
+		}
 	} else {
 		if (args != NULL)
 			/* function prototype parameters must have types */
 			warning(62);
+	}
+}
 /*
  * Lists of identifiers in functions declarations are allowed only if
  * it's also a function definition. If this is not the case, print an
  * error message.
  */
 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->s_args = NULL;
+	}
+}
 /*
  * Process the name in a declarator.
  * The symbol gets one of the storage classes EXTERN, STATIC, AUTO or
  * TYPEDEF.
  * s_def and s_reg are valid after declarator_name().
  */
 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 {
 		dcs->d_redeclared_symbol = sym;
 		sym = pushdown(sym);
+	}
 	switch (dcs->d_ctx) {
 	case MOS:
 	case MOU:
 		/* Set parent */
 		sym->s_styp = dcs->d_tagtyp->t_str;
 		sym->s_def = DEF;
 		sym->s_value.v_tspec = INT;
 		sc = dcs->d_ctx;
 		break;
 	case EXTERN:
 		/*
 		 * static and external symbols without "extern" are
 		 * considered to be tentative defined, external
 		 * symbols with "extern" are declared, and typedef names
 		 * are defined. Tentative defined and declared symbols
 		 * may become defined if an initializer is present or
 		 * this is a function definition.
 		 */
 		if ((sc = dcs->d_scl) == NOSCL) {
 			sc = EXTERN;
 			sym->s_def = TDEF;
 		} else if (sc == STATIC) {
 			sym->s_def = TDEF;
 		} else if (sc == TYPEDEF) {
 			sym->s_def = DEF;
 		} else {
 			lint_assert(sc == EXTERN);
 			sym->s_def = DECL;
+		}
 		break;
 	case PROTO_ARG:
 		sym->s_arg = true;
 		/* FALLTHROUGH */
 	case ARG:
 		if ((sc = dcs->d_scl) == NOSCL) {
 			sc = AUTO;
 		} else {
 			lint_assert(sc == REG);
 			sym->s_reg = true;
 			sc = AUTO;
+		}
 		sym->s_def = DEF;
 		break;
 	case AUTO:
 		if ((sc = dcs->d_scl) == NOSCL) {
 			/*
 			 * XXX somewhat ugly because we dont know whether
 			 * this is AUTO or EXTERN (functions). If we are
 			 * wrong it must be corrected in declare_local(),
 			 * where we have the necessary type information.
 			 */
 			sc = AUTO;
 			sym->s_def = DEF;
 		} else if (sc == AUTO || sc == STATIC || sc == TYPEDEF) {
 			sym->s_def = DEF;
 		} else if (sc == REG) {
 			sym->s_reg = true;
 			sc = AUTO;
 			sym->s_def = DEF;
 		} else {
 			lint_assert(sc == EXTERN);
 			sym->s_def = DECL;
+		}
 		break;
 	default:
 		lint_assert(/*CONSTCOND*/false);
+	}
 	sym->s_scl = sc;
 	sym->s_type = dcs->d_type;
 	dcs->d_func_proto_syms = NULL;
 	return sym;
+}
 /*
  * Process a name in the list of formal parameters in an old style function
  * definition.
  */
 sym_t *
 old_style_function_name(sym_t *sym)
+{
 	if (sym->s_scl != NOSCL) {
 		if (block_level == sym->s_block_level) {
 			/* redeclaration of formal parameter %s */
 			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;
+}
 /*
  * Create the type of a tag.
+ *
  * tag points to the symbol table entry of the tag
  * kind is the kind of the tag (STRUCT/UNION/ENUM)
  * decl is true if the type of the tag will be completed in this declaration
  * (the following token is T_LBRACE)
  * semi is true if the following token is T_SEMI
  */
 type_t *
 mktag(sym_t *tag, tspec_t kind, bool decl, bool semi)
+{
 	scl_t	scl;
 	type_t	*tp;
 	if (kind == STRUCT) {
 		scl = STRUCT_TAG;
 	} else if (kind == UNION) {
 		scl = UNION_TAG;
 	} else {
 		lint_assert(kind == ENUM);
 		scl = ENUM_TAG;
+	}
 	if (tag != NULL) {
 		if (tag->s_scl != NOSCL) {
 			tag = newtag(tag, scl, decl, semi);
 		} else {
 			/* a new tag, no empty declaration */
 			dcs->d_next->d_nonempty_decl = true;
 			if (scl == ENUM_TAG && !decl) {
 				if (!tflag && (sflag || pflag))
 					/* forward reference to enum type */
 					warning(42);
+			}
+		}
 		if (tag->s_scl == NOSCL) {
 			tag->s_scl = scl;
 			tag->s_type = tp = getblk(sizeof(*tp));
 			tp->t_packed = dcs->d_packed;
 		} else {
 			tp = tag->s_type;
+		}
 	} else {
 		tag = getblk(sizeof(*tag));
 		tag->s_name = unnamed;
 		UNIQUE_CURR_POS(tag->s_def_pos);
 		tag->s_kind = FTAG;
 		tag->s_scl = scl;
 		tag->s_block_level = -1;
 		tag->s_type = tp = getblk(sizeof(*tp));
 		tp->t_packed = dcs->d_packed;
 		dcs->d_next->d_nonempty_decl = true;
+	}
 	if (tp->t_tspec == NOTSPEC) {
 		tp->t_tspec = kind;
 		if (kind != ENUM) {
 			tp->t_str = getblk(sizeof(*tp->t_str));
 			tp->t_str->sou_align_in_bits = CHAR_SIZE;
 			tp->t_str->sou_tag = tag;
 		} else {
 			tp->t_is_enum = true;
 			tp->t_enum = getblk(sizeof(*tp->t_enum));
 			tp->t_enum->en_tag = tag;
+		}
 		setcomplete(tp, false);
+	}
 	return tp;
+}
 /*
  * Checks all possible cases of tag redeclarations.
  * decl is true if T_LBRACE follows
  * semi is true if T_SEMI follows
  */
 static sym_t *
 newtag(sym_t *tag, scl_t scl, bool decl, bool semi)
+{
 	if (tag->s_block_level < block_level) {
 		if (semi) {
 			/* "struct a;" */
 			if (!tflag) {
 				if (!sflag)
 					/* decl. introduces new type ... */
 					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_next->d_nonempty_decl = true;
 		} else if (decl) {
 			/* "struct a { ... } " */
 			if (hflag)
 				/* redefinition hides earlier one: %s */
 				warning(43, tag->s_name);
 			tag = pushdown(tag);
 			dcs->d_next->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);
 			/* declaration introduces new type in ANSI C: %s %s */
 			if (!sflag) {
 				/* decl. introduces new type in ANSI C: %s %s */
 				warning(44, storage_class_name(scl),
 				    tag->s_name);
+			}
 			tag = pushdown(tag);
 			dcs->d_next->d_nonempty_decl = true;
+		}
 	} else {
 		if (tag->s_scl != scl) {
 			/* (%s) tag redeclared */
 			error(46, storage_class_name(tag->s_scl));
 			print_previous_declaration(-1, tag);
 			tag = pushdown(tag);
 			dcs->d_next->d_nonempty_decl = true;
 		} else if (decl && !is_incomplete(tag->s_type)) {
 			/* (%s) tag redeclared */
 			error(46, storage_class_name(tag->s_scl));
 			print_previous_declaration(-1, tag);
 			tag = pushdown(tag);
 			dcs->d_next->d_nonempty_decl = true;
 		} else if (semi || decl) {
 			dcs->d_next->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);
+	}
+}
 /*
  * tp points to the type of the tag, fmem to the list of members.
  */
 type_t *
 complete_tag_struct_or_union(type_t *tp, sym_t *fmem)
+{
 	tspec_t	t;
 	struct_or_union	*sp;
 	int	n;
 	sym_t	*mem;
 	if (tp == NULL)		/* in case of syntax errors */
 		return gettyp(INT);
 	setcomplete(tp, true);
 	t = tp->t_tspec;
 	align(dcs->d_sou_align_in_bits, 0);
 	sp = tp->t_str;
 	sp->sou_align_in_bits = dcs->d_sou_align_in_bits;
 	sp->sou_first_member = fmem;
 	if (tp->t_packed)
 		setpackedsize(tp);
 	else
 		sp->sou_size_in_bits = dcs->d_offset;
 	if (sp->sou_size_in_bits == 0) {
 		/* zero sized %s is a C9X feature */
 		c99ism(47, ttab[t].tt_name);

 @@ -1,137 +1,163 @@
-/*	$NetBSD: decl.c,v 1.7 2021/07/15 21:34:11 rillig Exp $	*/
+/*	$NetBSD: decl.c,v 1.8 2021/07/15 21:56:51 rillig Exp $	*/
 # 3 "decl.c"
 /*
  * Tests for declarations, especially the distinction between the
  * declaration-specifiers and the declarators.
  */
 /*
  * Even though 'const' comes after 'char' and is therefore quite close to the
  * first identifier, it applies to both identifiers.
  */
 void
 specifier_qualifier(void)
+{
 	char const a = 1, b = 2;
 	/* expect+1: warning: left operand of '=' must be modifiable lvalue [115] */
 	a = 1;
 	/* expect+1: warning: left operand of '=' must be modifiable lvalue [115] */
 	b = 2;
+}
 /*
  * Since 'const' comes before 'char', there is no ambiguity whether the
  * 'const' applies to all variables or just to the first.
  */
 void
 qualifier_specifier(void)
+{
 	const char a = 1, b = 2;
 	/* expect+1: warning: left operand of '=' must be modifiable lvalue [115] */
 	a = 3;
 	/* expect+1: warning: left operand of '=' must be modifiable lvalue [115] */
 	b = 5;
+}
 void
 declarator_with_prefix_qualifier(void)
+{
 	/* expect+1: syntax error 'const' [249] */
 	char a = 1, const b = 2;
 	a = 1;
 	/* expect+1: error: 'b' undefined [99] */
 	b = 2;
+}
 void
 declarator_with_postfix_qualifier(void)
+{
 	/* expect+1: syntax error 'const' [249] */
 	char a = 1, b const = 2;
 	a = 1;
 	b = 2;
+}
 void sink(double *);
 void
 declarators(void)
+{
 	char *pc = 0, c = 0, **ppc = 0;
 	/* expect+1: warning: converting 'pointer to char' to incompatible 'pointer to double' */
 	sink(pc);
 	/* expect+1: warning: illegal combination of pointer (pointer to double) and integer (char) */
 	sink(c);
 	/* expect+1: converting 'pointer to pointer to char' to incompatible 'pointer to double' */
 	sink(ppc);
+}
 _Bool
 enum_error_handling(void)
+{
 	enum {
 		/* expect+1: syntax error '"' [249] */
 		"error 1"
 		:		/* still the same error */
 		,		/* back on track */
 		A,
+		B
 	} x = A;
 	return x == B;
+}
 /*
  * An __attribute__ at the beginning of a declaration may become ambiguous
  * since a GCC fallthrough statement starts with __attribute__ as well.
  */
 void
 unused_local_variable(void)
+{
 	__attribute__((unused)) _Bool unused_var;
 	__attribute__((unused))
 	__attribute__((unused)) _Bool unused_twice;
+}
 int
 declaration_without_type_specifier(void)
+{
 	const i = 3;
 	return i;
+}
 /* TODO: add quotes around %s */
 /* expect+2: warning: static function unused unused [236] */
 static void
 unused(void)
+{
+}
 /*
  * The attribute 'used' does not influence static functions, it only
  * applies to function parameters.
  */
 /* LINTED */
 static void
 unused_linted(void)
+{
+}
 /* covers 'type_qualifier_list: type_qualifier_list type_qualifier' */
 int *const volatile cover_type_qualifier_list;
 unsigned long cover_abstract_declaration_declmods = sizeof(const);
 unsigned long cover_abstract_declaration_declmods_abstract_declarator =
     sizeof(const *);
 // FIXME:
-// lint: internal error in decl.c:833 near decl.c:135: end_type(unsigned long)
+unsigned long cover_abstract_declarator_typeof =
-//unsigned long cover_abstract_declarator_typeof =
+    sizeof(const typeof(cover_abstract_declaration_declmods));
 //    sizeof(const typeof(cover_abstract_declaration_declmods));
 _Bool bool;
 char plain_char;
 signed char signed_char;
 unsigned char unsigned_char;
 short signed_short;
 unsigned short unsigned_short;
 int signed_int;
 unsigned int unsigned_int;
 long signed_long;
 unsigned long unsigned_long;
 /*
  * Before decl.c 1.201 from 2021-07-15, lint crashed with an internal error
  * in end_type.
  */
 unsigned long sizes =
     sizeof(const typeof(bool)) +
     sizeof(const typeof(plain_char)) +
     sizeof(const typeof(signed_char)) +
     sizeof(const typeof(unsigned_char)) +
     sizeof(const typeof(signed_short)) +
     sizeof(const typeof(unsigned_short)) +
     sizeof(const typeof(signed_int)) +
     sizeof(const typeof(unsigned_int)) +
     sizeof(const typeof(signed_long)) +
     sizeof(const typeof(unsigned_long));