 @@ -1,2120 +1,2120 @@
-/* $NetBSD: decl.c,v 1.98 2021/01/02 03:49:25 rillig Exp $ */
+/* $NetBSD: decl.c,v 1.99 2021/01/02 16:33:39 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.98 2021/01/02 03:49:25 rillig Exp $");
+__RCSID("$NetBSD: decl.c,v 1.99 2021/01/02 16:33:39 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 arithmtic 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, int, int);
 static	int	eqargs(type_t *, type_t *, int *);
 static	int	mnoarg(type_t *, int *);
 static	int	check_old_style_definition(sym_t *, sym_t *);
 static	int	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	ledecl(sym_t *);
 static	int	check_init(sym_t *);
 static	void	check_argument_usage(int, sym_t *);
 static	void	check_variable_usage(int, sym_t *);
 static	void	check_label_usage(sym_t *);
 static	void	check_tag_usage(sym_t *);
 static	void	check_global_variable(sym_t *);
 static	void	check_global_variable_size(sym_t *);
 /*
  * initializes all global vars used in declarations
  */
 void
 initdecl(void)
+{
 	int i;
 	/* declaration stack */
 	dcs = xcalloc(1, sizeof (dinfo_t));
 	dcs->d_ctx = EXTERN;
 	dcs->d_ldlsym = &dcs->d_dlsyms;
 	/* type information and classification */
 	inittyp();
 	/* shared type structures */
 	typetab = xcalloc(NTSPEC, sizeof (type_t));
 	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 duptyp() or tduptyp())
  * if it is to be modified (adding qualifiers or anything else).
  */
 type_t *
 gettyp(tspec_t t)
+{
 	return &typetab[t];
+}
 type_t *
 duptyp(const type_t *tp)
+{
 	type_t	*ntp;
 	ntp = getblk(sizeof (type_t));
 	*ntp = *tp;
 	return ntp;
+}
 /*
  * Use tduptyp() instead of duptyp() inside expressions (if the
  * allocated memory should be freed after the expr).
  */
 type_t *
 tduptyp(const type_t *tp)
+{
 	type_t	*ntp;
 	ntp = tgetblk(sizeof (type_t));
 	*ntp = *tp;
 	return ntp;
+}
 /*
  * Returns 1 if the argument is void or an incomplete array,
  * struct, union or enum type.
  */
 int
 incompl(type_t *tp)
+{
 	tspec_t	t;
 	if ((t = tp->t_tspec) == VOID) {
 		return 1;
 	} else if (t == ARRAY) {
 		return tp->t_aincompl;
 	} else if (t == STRUCT || t == UNION) {
 		return tp->t_str->sincompl;
 	} else if (t == ENUM) {
 		return tp->t_enum->eincompl;
+	}
 	return 0;
+}
 /*
  * Mark an array, struct, union or enum type as complete or incomplete.
  */
 void
 setcomplete(type_t *tp, int complete)
+{
 	tspec_t	t;
 	if ((t = tp->t_tspec) == ARRAY) {
 		tp->t_aincompl = !complete;
 	} else if (t == STRUCT || t == UNION) {
 		tp->t_str->sincompl = !complete;
 	} else {
 		lint_assert(t == ENUM);
 		tp->t_enum->eincompl = !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 = 1;
 		return;
+	}
 	if (dcs->d_type != NULL || dcs->d_atyp != NOTSPEC ||
 	    dcs->d_smod != NOTSPEC || dcs->d_lmod != 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
 		 * deftyp().
 		 */
 		dcs->d_mscl = 1;
+	}
+}
 /*
  * Remember the type, modifier or typedef name returned by the parser
  * in *dcs (top element of decl stack). This information is used in
  * deftyp() 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_atyp == NOTSPEC);
 		lint_assert(dcs->d_lmod == NOTSPEC);
 		lint_assert(dcs->d_smod == 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_atyp != NOTSPEC ||
 		    dcs->d_lmod != NOTSPEC || dcs->d_smod != NOTSPEC) {
 			/*
 			 * remember that an error must be reported in
 			 * deftyp().
 			 */
 			dcs->d_terr = 1;
 			dcs->d_atyp = dcs->d_lmod = dcs->d_smod = 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 = 1;
 		return;
+	}
 	if (t == COMPLEX) {
 		if (dcs->d_cmod == FLOAT)
 			t = FCOMPLEX;
 		else if (dcs->d_cmod == DOUBLE)
 			t = DCOMPLEX;
 		else
 			/* Invalid type %s for _Complex */
 			error(308, tspec_name(dcs->d_cmod));
 		dcs->d_cmod = NOTSPEC;
+	}
 	if (t == LONG && dcs->d_lmod == LONG) {
 		/* "long long" or "long ... long" */
 		t = QUAD;
 		dcs->d_lmod = NOTSPEC;
 		if (!quadflg)
 			/* %s C does not support 'long long' */
 			(void)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_smod */
 		if (dcs->d_smod != NOTSPEC)
 			/*
 			 * more than one "signed" and/or "unsigned"; print
 			 * an error in deftyp()
 			 */
 			dcs->d_terr = 1;
 		dcs->d_smod = t;
 	} else if (t == SHORT || t == LONG || t == QUAD) {
 		/*
 		 * remember specifiers "short", "long" and "long long" in
 		 * dcs->d_lmod
 		 */
 		if (dcs->d_lmod != NOTSPEC)
 			/* more than one, print error in deftyp() */
 			dcs->d_terr = 1;
 		dcs->d_lmod = t;
 	} else if (t == FLOAT || t == DOUBLE) {
 		if (dcs->d_lmod == NOTSPEC || dcs->d_lmod == LONG) {
 			if (dcs->d_cmod != NOTSPEC
 			    || (t == FLOAT && dcs->d_lmod == LONG))
 				dcs->d_terr = 1;
 			dcs->d_cmod = t;
 		} else {
 			if (dcs->d_atyp != NOTSPEC)
 				dcs->d_terr = 1;
 			dcs->d_atyp = t;
+		}
 	} else if (t == PTR) {
 		dcs->d_type = tp;
 	} else {
 		/*
 		 * remember specifiers "void", "char", "int",
 		 * or "_Complex" int dcs->d_atyp
 		 */
 		if (dcs->d_atyp != NOTSPEC)
 			/* more than one, print error in deftyp() */
 			dcs->d_terr = 1;
 		dcs->d_atyp = 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 ... */
 				warning(5, ttab[t].tt_name);
 			td = duptyp(gettyp(merge_type_specifiers(t2, t)));
 			td->t_typedef = 1;
 			return td;
+		}
 		break;
 	case SHORT:
 		if (t2 == INT || t2 == UINT) {
 			/* modifying typedef with ... */
 			warning(5, "short");
 			td = duptyp(gettyp(t2 == INT ? SHORT : USHORT));
 			td->t_typedef = 1;
 			return td;
+		}
 		break;
 	case LONG:
 		if (t2 == INT || t2 == UINT || t2 == LONG || t2 == ULONG ||
 		    t2 == FLOAT || t2 == DOUBLE || t2 == DCOMPLEX) {
 			/* modifying typedef with ... */
 			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 = duptyp(td);
 			td->t_typedef = 1;
 			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 = 1;
 	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->stdef == NULL)
 			tp->t_str->stdef = sym;
 	} else if (t == ENUM) {
 		if (tp->t_enum->etdef == NULL)
 			tp->t_enum->etdef = sym;
+	}
+}
 static size_t
 bitfieldsize(sym_t **mem)
+{
 	size_t len = (*mem)->s_type->t_flen;
 	while (*mem && (*mem)->s_type->t_isfield) {
 		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)
+{
 	str_t *sp;
 	sym_t *mem;
 	switch (tp->t_tspec) {
 	case STRUCT:
 	case UNION:
 		sp = tp->t_str;
 		sp->size = 0;
 		for (mem = sp->memb; mem != NULL; mem = mem->s_next) {
 			if (mem->s_type->t_isfield) {
 				sp->size += bitfieldsize(&mem);
 				if (mem == NULL)
 					break;
+			}
 			size_t x = (size_t)tsize(mem->s_type);
 			if (tp->t_tspec == STRUCT)
 				sp->size += x;
 			else if (x > sp->size)
 				sp->size = 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_ispacked = 1;
 	else
 		setpackedsize(dcs->d_type);
+}
 void
 add_attr_used(void)
+{
 	dcs->d_used = 1;
+}
 /*
  * 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 deftyp() 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 = 1;
 	} else {
 		if (q == THREAD)
 			return;
 		lint_assert(q == VOLATILE);
 		if (dcs->d_volatile) {
 			/* duplicate '%s' */
 			warning(10, "volatile");
+		}
 		dcs->d_volatile = 1;
+	}
+}
 /*
  * Go to the next declaration level (structs, nested structs, blocks,
  * argument declaration lists ...)
  */
 void
 pushdecl(scl_t sc)
+{
 	dinfo_t	*di;
 	/* put a new element on the declaration stack */
 	di = xcalloc(1, sizeof (dinfo_t));
 	di->d_next = dcs;
 	dcs = di;
 	di->d_ctx = sc;
 	di->d_ldlsym = &di->d_dlsyms;
 	if (dflag)
 		(void)printf("pushdecl(%p %d)\n", dcs, (int)sc);
+}
 /*
  * Go back to previous declaration level
  */
 void
 popdecl(void)
+{
 	dinfo_t	*di;
 	if (dflag)
 		(void)printf("popdecl(%p %d)\n", dcs, (int)dcs->d_ctx);
 	lint_assert(dcs->d_next != NULL);
 	di = dcs;
 	dcs = di->d_next;
 	switch (di->d_ctx) {
 	case MOS:
 	case MOU:
 	case ENUMCON:
 		/*
 		 * 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 outher 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_fpsyms;
 			dcs->d_fpsyms = 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 PARG:
 		/* 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(0);
+	}
 	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 unitialized 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 clrtyp() and would work for
  * C, but not for 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 = 1;
+}
 /*
  * Clean all elements of the top element of declaration stack which
  * will be used by the next declaration
  */
 void
 clrtyp(void)
+{
 	dcs->d_atyp = dcs->d_cmod = dcs->d_smod = dcs->d_lmod = NOTSPEC;
 	dcs->d_scl = NOSCL;
 	dcs->d_type = NULL;
 	dcs->d_const = dcs->d_volatile = 0;
 	dcs->d_inline = 0;
 	dcs->d_mscl = dcs->d_terr = 0;
 	dcs->d_nedecl = 0;
 	dcs->d_notyp = 0;
+}
 /*
  * Create a type structure from the information gathered in
  * the declaration stack.
  * Complain about storage classes which are not possible in current
  * context.
  */
 void
 deftyp(void)
+{
 	tspec_t	t, s, l, c;
 	type_t	*tp;
 	scl_t	scl;
 	t = dcs->d_atyp;	/* BOOL, CHAR, INT, COMPLEX, VOID */
 	s = dcs->d_smod;	/* SIGNED, UNSIGNED */
 	l = dcs->d_lmod;	/* SHORT, LONG, QUAD */
 	c = dcs->d_cmod;	/* FLOAT, DOUBLE */
 	tp = dcs->d_type;
 	scl = dcs->d_scl;
 #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 = 1;
 	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 = 1;
 				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:
 			LERROR("deftyp(%s)", tspec_name(t));
+		}
 		if (t != INT && t != CHAR && (s != NOTSPEC || l != NOTSPEC)) {
 			dcs->d_terr = 1;
 			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);
+	}
 	if (dcs->d_ctx == EXTERN) {
 		if (scl == REG || scl == AUTO) {
 			/* illegal storage class */
 			error(8);
 			scl = NOSCL;
+		}
 	} else if (dcs->d_ctx == ARG || dcs->d_ctx == PARG) {
 		if (scl != NOSCL && scl != REG) {
 			/* only register valid ... */
 			error(9);
 			scl = NOSCL;
+		}
+	}
 	dcs->d_scl = scl;
 	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 = duptyp(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) {
 		if (t == CHAR) {
 			t = s == SIGNED ? SCHAR : UCHAR;
 		} else if (t == SHORT) {
 			t = s == SIGNED ? SHORT : USHORT;
 		} else if (t == INT) {
 			t = s == SIGNED ? INT : UINT;
 		} else if (t == LONG) {
 			t = s == SIGNED ? LONG : ULONG;
 		} else if (t == QUAD) {
 			t = s == SIGNED ? QUAD : UQUAD;
+		}
+	}
 	return t;
+}
 /*
  * Return the length of a type in bits.
+ *
  * Printing a message if the outhermost 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(type_t *tp, const char *name)
+{
 	int	elem, elsz;
 	elem = 1;
 	while (tp && 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 */
 		LERROR("%s", msgs[12]);
 		/* NOTREACHED */
 	case STRUCT:
 	case UNION:
 		if (incompl(tp) && name != NULL) {
 			/* incomplete structure or union %s: %s */
 			error(31, tp->t_str->stag->s_name, name);
+		}
 		elsz = tp->t_str->size;
 		break;
 	case ENUM:
 		if (incompl(tp) && name != NULL) {
 			/* incomplete enum type: %s */
 			warning(13, name);
+		}
 		/* FALLTHROUGH */
 	default:
 		elsz = size(tp->t_tspec);
 		if (elsz <= 0)
 			LERROR("length(%d)", elsz);
 		break;
+	}
 	return elem * elsz;
+}
 /*
  * Get the alignment of the given Type in bits.
  */
 int
 getbound(type_t *tp)
+{
 	size_t	a;
 	tspec_t	t;
 	while (tp && 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->align;
 	} else if (t == FUNC) {
 		/* compiler takes alignment of function */
 		error(14);
 		a = WORST_ALIGN(1) * CHAR_BIT;
 	} else {
 		if ((a = size(t)) == 0) {
 			a = CHAR_BIT;
 		} else if (a > WORST_ALIGN(1) * CHAR_BIT) {
 			a = WORST_ALIGN(1) * CHAR_BIT;
+		}
+	}
 	lint_assert(a >= CHAR_BIT);
 	lint_assert(a <= WORST_ALIGN(1) * CHAR_BIT);
 	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 incomlete 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 = incref(*tpp, PTR);
 				} else {
 					*tpp = incref((*tpp)->t_subt, PTR);
+				}
 				return;
 			} else if (tp->t_const || tp->t_volatile) {
 				if (sflag) {	/* XXX oder 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 (incompl(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 == PARG) {
 				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 = 0;
+			}
+		}
 		tpp = &tp->t_subt;
 		to = t;
+	}
+}
 /*
  * 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, len;
 	int	o = 0;	/* Appease gcc */
 	scl_t	sc;
 	lint_assert((sc = dsym->s_scl) == MOS || sc == MOU);
 	if (dcs->d_rdcsym != NULL) {
 		/* should be ensured by storesym() */
 		lint_assert((sc = dcs->d_rdcsym->s_scl) == MOS || sc == MOU);
 		if (dsym->s_styp == dcs->d_rdcsym->s_styp) {
 			/* duplicate member name: %s */
 			error(33, dsym->s_name);
 			rmsym(dcs->d_rdcsym);
+		}
+	}
 	check_type(dsym);
 	t = (tp = dsym->s_type)->t_tspec;
 	if (dsym->s_bitfield) {
 		/*
 		 * only unsigned and signed int are portable bit-field types
 		 *(at least in ANSI C, in traditional C only unsigned int)
 		 */
 		if (t == CHAR || t == UCHAR || t == SCHAR ||
 		    t == SHORT || t == USHORT || t == ENUM) {
 			if (bitfieldtype_ok == 0) {
 				if (sflag) {
 					/* bit-field type '%s' invalid ... */
 					warning(273, type_name(tp));
 				} else if (pflag) {
 					/* nonportable bit-field type */
 					warning(34);
+				}
+			}
 		} else if (t == INT && dcs->d_smod == NOTSPEC) {
 			if (pflag && bitfieldtype_ok == 0) {
 				/* nonportable bit-field type */
 				warning(34);
+			}
-		} else if (t != INT && t != UINT) {
+		} 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 == 0 || tspec_is_int(t) == 0) {
 				/* illegal bit-field type */
 				warning(35);
 				sz = tp->t_flen;
 				dsym->s_type = tp = duptyp(gettyp(t = INT));
 				if ((tp->t_flen = sz) > size(t))
 					tp->t_flen = size(t);
+			}
+		}
 		if ((len = tp->t_flen) < 0 || len > (ssize_t)size(t)) {
 			/* illegal bit-field size: %d */
 			error(36, len);
 			tp->t_flen = size(t);
 		} else if (len == 0 && dsym->s_name != unnamed) {
 			/* zero size bit-field */
 			error(37);
 			tp->t_flen = size(t);
+		}
 		if (dsym->s_scl == MOU) {
 			/* illegal use of bit-field */
 			error(41);
 			dsym->s_type->t_isfield = 0;
 			dsym->s_bitfield = 0;
+		}
 	} else if (t == FUNC) {
 		/* function illegal in structure or union */
 		error(38);
 		dsym->s_type = tp = incref(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(getbound(tp), tp->t_flen);
 		dsym->s_value.v_quad = (dcs->d_offset / size(t)) * size(t);
 		tp->t_foffs = dcs->d_offset - (int)dsym->s_value.v_quad;
 		dcs->d_offset += tp->t_flen;
 	} else {
 		align(getbound(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, 0);
 	/*
 	 * Clear the BITFIELDTYPE indicator after processing each
 	 * structure element.
 	 */
 	bitfieldtype_ok = 0;
 	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_stralign)
 		dcs->d_stralign = 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 (sym_t));
 		dsym->s_name = unnamed;
 		dsym->s_kind = FMEMBER;
 		dsym->s_scl = MOS;
 		dsym->s_type = gettyp(UINT);
 		dsym->s_blklev = -1;
+	}
 	dsym->s_type = duptyp(dsym->s_type);
 	dsym->s_type->t_isfield = 1;
 	dsym->s_type->t_flen = len;
 	dsym->s_bitfield = 1;
 	return dsym;
+}
 /*
  * Collect information about a sequence of asterisks and qualifiers in a
  * list of type pqinf_t.
  * Qualifiers always refer to the left asterisk.
  * The rightmost asterisk will be at the top of the list.
  */
 pqinf_t *
 merge_pointers_and_qualifiers(pqinf_t *p1, pqinf_t *p2)
+{
 	pqinf_t	*p;
 	if (p2->p_pcnt != 0) {
 		/* left '*' at the end of the list */
 		for (p = p2; p->p_next != NULL; p = p->p_next)
 			continue;
 		p->p_next = p1;
 		return p2;
 	} else {
 		if (p2->p_const) {
 			if (p1->p_const) {
 				/* duplicate '%s' */
 				warning(10, "const");
+			}
 			p1->p_const = 1;
+		}
 		if (p2->p_volatile) {
 			if (p1->p_volatile) {
 				/* duplicate '%s' */
 				warning(10, "volatile");
+			}
 			p1->p_volatile = 1;
+		}
 		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 deftyp() (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, pqinf_t *pi)
+{
 	type_t	**tpp, *tp;
 	pqinf_t	*npi;
 	tpp = &decl->s_type;
 	while (*tpp && *tpp != dcs->d_type)
 		tpp = &(*tpp)->t_subt;
 	if (*tpp == NULL)
 		return decl;
 	while (pi != NULL) {
 		*tpp = tp = getblk(sizeof (type_t));
 		tp->t_tspec = PTR;
 		tp->t_const = pi->p_const;
 		tp->t_volatile = pi->p_volatile;
 		*(tpp = &tp->t_subt) = dcs->d_type;
 		npi = pi->p_next;
 		free(pi);
 		pi = npi;
+	}
 	return decl;
+}
 /*
  * If a dimension was specified, dim is 1, otherwise 0
  * n is the specified dimension
  */
 sym_t *
 add_array(sym_t *decl, int dim, int n)
+{
 	type_t	**tpp, *tp;
 	tpp = &decl->s_type;
 	while (*tpp && *tpp != dcs->d_type)
 		tpp = &(*tpp)->t_subt;
 	if (*tpp == NULL)
 	    return decl;
 	*tpp = tp = getblk(sizeof (type_t));
 	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, 0);
+	}
 	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 popdecl() 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_fpsyms. Also a list of the arguments (concatenated
 	 * by s_next) is stored in dcs->d_next->d_fargs.
 	 * (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_fpsyms = dcs->d_dlsyms;
 		dcs->d_next->d_fargs = args;
+	}
 	tpp = &decl->s_type;
 	while (*tpp && *tpp != dcs->d_next->d_type)
 		tpp = &(*tpp)->t_subt;
 	if (*tpp == NULL)
 	    return decl;
 	*tpp = tp = getblk(sizeof (type_t));
 	tp->t_tspec = FUNC;
 	tp->t_subt = dcs->d_next->d_type;
 	if ((tp->t_proto = dcs->d_proto) != 0)
 		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 == STRTAG || sc == UNIONTAG || sc == ENUMTAG) {
 			/* 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 = 1;
 			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 a
  * error message.
  */
 void
 check_function_definition(sym_t *sym, int msg)
+{
 	if (sym->s_osdef) {
 		if (msg) {
 			/* incomplete or misplaced function definition */
 			error(22);
+		}
 		sym->s_osdef = 0;
 		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_rdcsym = NULL;
 	} else if (sym->s_defarg) {
 		sym->s_defarg = 0;
 		dcs->d_rdcsym = NULL;
 	} else {
 		dcs->d_rdcsym = 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 PARG:
 		sym->s_arg = 1;
 		/* FALLTHROUGH */
 	case ARG:
 		if ((sc = dcs->d_scl) == NOSCL) {
 			sc = AUTO;
 		} else {
 			lint_assert(sc == REG);
 			sym->s_reg = 1;
 			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 decl1loc(), 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 = 1;
 			sc = AUTO;
 			sym->s_def = DEF;
 		} else {
 			lint_assert(sc == EXTERN);
 			sym->s_def = DECL;
+		}
 		break;
 	default:
 		lint_assert(0);
+	}
 	sym->s_scl = sc;
 	sym->s_type = dcs->d_type;
 	dcs->d_fpsyms = NULL;
 	return sym;
+}
 /*
  * Process a name in the list of formal params in an old style function
  * definition.
  */
 sym_t *
 old_style_function_name(sym_t *sym)
+{
 	if (sym->s_scl != NOSCL) {
 		if (blklev == sym->s_blklev) {
 			/* 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 = 1;
 	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 1 if the type of the tag will be completed in this declaration
  * (the following token is T_LBRACE)
  * semi is 1 if the following token is T_SEMI
  */
 type_t *
 mktag(sym_t *tag, tspec_t kind, int decl, int semi)
+{
 	scl_t	scl = NOSCL;
 	type_t	*tp;
 	if (kind == STRUCT) {
 		scl = STRTAG;
 	} else if (kind == UNION) {
 		scl = UNIONTAG;
 	} else {
 		lint_assert(kind == ENUM);
 		scl = ENUMTAG;
+	}
 	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_nedecl = 1;
 			if (scl == ENUMTAG && !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 (type_t));
 			tp->t_ispacked = dcs->d_ispacked;
 		} else {
 			tp = tag->s_type;
+		}
 	} else {
 		tag = getblk(sizeof (sym_t));
 		tag->s_name = unnamed;
 		UNIQUE_CURR_POS(tag->s_def_pos);
 		tag->s_kind = FTAG;
 		tag->s_scl = scl;
 		tag->s_blklev = -1;
 		tag->s_type = tp = getblk(sizeof (type_t));
 		tp->t_ispacked = dcs->d_ispacked;
 		dcs->d_next->d_nedecl = 1;
+	}
 	if (tp->t_tspec == NOTSPEC) {
 		tp->t_tspec = kind;
 		if (kind != ENUM) {
 			tp->t_str = getblk(sizeof (str_t));
 			tp->t_str->align = CHAR_BIT;
 			tp->t_str->stag = tag;
 		} else {
 			tp->t_isenum = 1;
 			tp->t_enum = getblk(sizeof(*tp->t_enum));
 			tp->t_enum->etag = tag;
+		}
 		setcomplete(tp, 0);
+	}
 	return tp;
+}
 /*
  * Checks all possible cases of tag redeclarations.
  * decl is 1 if T_LBRACE follows
  * semi is 1 if T_SEMI follows
  */
 static sym_t *
 newtag(sym_t *tag, scl_t scl, int decl, int semi)
+{
 	if (tag->s_blklev < blklev) {
 		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_nedecl = 1;
 		} else if (decl) {
 			/* "struct a { ... } " */
 			if (hflag)
 				/* redefinition hides earlier one: %s */
 				warning(43, tag->s_name);
 			tag = pushdown(tag);
 			dcs->d_next->d_nedecl = 1;
 		} 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_nedecl = 1;
+		}
 	} 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_nedecl = 1;
 		} else if (decl && !incompl(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_nedecl = 1;
 		} else if (semi || decl) {
 			dcs->d_next->d_nedecl = 1;
+		}
+	}
 	return tag;
+}
 const char *
 storage_class_name(scl_t sc)
+{
 	const	char *s;
 	switch (sc) {
 	case EXTERN:	s = "extern";	break;
 	case STATIC:	s = "static";	break;
 	case AUTO:	s = "auto";	break;
 	case REG:	s = "register";	break;
 	case TYPEDEF:	s = "typedef";	break;
 	case STRTAG:	s = "struct";	break;
 	case UNIONTAG:	s = "union";	break;
 	case ENUMTAG:	s = "enum";	break;
 	default:	lint_assert(0);
+	}
 	return s;
+}
 /*
  * 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;
 	str_t	*sp;
 	int	n;
 	sym_t	*mem;
 	setcomplete(tp, 1);
 	t = tp->t_tspec;
 	align(dcs->d_stralign, 0);
 	sp = tp->t_str;
 	sp->align = dcs->d_stralign;
 	sp->memb = fmem;
 	if (tp->t_ispacked)
 		setpackedsize(tp);
 	else
 		sp->size = dcs->d_offset;
 	if (sp->size == 0) {
 		/* zero sized %s */
 		(void)c99ism(47, ttab[t].tt_name);
+	}
 	n = 0;
 	for (mem = fmem; mem != NULL; mem = mem->s_next) {
 		/* bind anonymous members to the structure */
 		if (mem->s_styp == NULL) {
 			mem->s_styp = sp;
 			if (mem->s_type->t_isfield) {
 				sp->size += bitfieldsize(&mem);
 				if (mem == NULL)
 					break;
+			}
 			sp->size += tsize(mem->s_type);
+		}
 		if (mem->s_name != unnamed)
 			n++;
+	}
 	if (n == 0 && sp->size != 0) {
 		/* %s has no named members */
 		warning(65, t == STRUCT ? "structure" : "union");
+	}
 	return tp;
+}
 type_t *
 complete_tag_enum(type_t *tp, sym_t *fmem)
+{
 	setcomplete(tp, 1);
 	tp->t_enum->elem = fmem;
 	return tp;
+}
 /*
  * Processes the name of an enumerator in an enum declaration.
+ *
  * sym points to the enumerator
  * val is the value of the enumerator
  * impl is 1 if the value of the enumerator was not explicitly specified.
  */
 sym_t *
 ename(sym_t *sym, int val, int impl)
+{
 	if (sym->s_scl) {
 		if (sym->s_blklev == blklev) {
 			/* no hflag, because this is illegal!!! */
 			if (sym->s_arg) {
 				/* enumeration constant hides parameter: %s */
 				warning(57, sym->s_name);
 			} else {
 				/* redeclaration of %s */
 				error(27, sym->s_name);
 				/*
 				 * inside blocks it should not be too
 				 * complicated to find the position of the
 				 * previous declaration
 				 */
 				if (blklev == 0)
 					print_previous_declaration(-1, sym);
+			}
 		} else {
 			if (hflag)
 				/* redefinition hides earlier one: %s */
 				warning(43, sym->s_name);
+		}
 		sym = pushdown(sym);
+	}
 	sym->s_scl = ENUMCON;
 	sym->s_type = dcs->d_tagtyp;
 	sym->s_value.v_tspec = INT;
 	sym->s_value.v_quad = val;
 	if (impl && val - 1 == TARG_INT_MAX) {
 		/* overflow in enumeration values: %s */
 		warning(48, sym->s_name);
+	}
 	enumval = val + 1;
 	return sym;
+}
 /*
  * Process a single external declarator.
  */
 void
 decl1ext(sym_t *dsym, int initflg)
+{
 	int	dowarn, rval, redec;
 	sym_t	*rdsym;
 	check_function_definition(dsym, 1);
 	check_type(dsym);
 	if (initflg && !(initerr = check_init(dsym)))
 		dsym->s_def = DEF;
 	/*
 	 * Declarations of functions are marked as "tentative" in
 	 * declarator_name(). This is wrong because there are no
 	 * tentative function definitions.
 	 */
 	if (dsym->s_type->t_tspec == FUNC && dsym->s_def == TDEF)
 		dsym->s_def = DECL;
 	if (dcs->d_inline) {
 		if (dsym->s_type->t_tspec == FUNC) {
 			dsym->s_inline = 1;
 		} else {
 			/* variable declared inline: %s */
 			warning(268, dsym->s_name);
+		}
+	}
 	/* Write the declaration into the output file */
 	if (plibflg && llibflg &&
 	    dsym->s_type->t_tspec == FUNC && dsym->s_type->t_proto) {
 		/*
 		 * With both LINTLIBRARY and PROTOLIB the prototyp is
 		 * written as a function definition to the output file.
 		 */
 		rval = dsym->s_type->t_subt->t_tspec != VOID;
 		outfdef(dsym, &dsym->s_def_pos, rval, 0, NULL);
 	} else {
 		outsym(dsym, dsym->s_scl, dsym->s_def);
+	}
 	if ((rdsym = dcs->d_rdcsym) != NULL) {
 		/*
 		 * If the old symbol stems from an old style function
 		 * definition, we have remembered the params in rdsmy->s_args
 		 * and compare them with the params of the prototype.
 		 */
 		if (rdsym->s_osdef && dsym->s_type->t_proto) {
 			redec = check_old_style_definition(rdsym, dsym);
 		} else {
 			redec = 0;
+		}
 		if (!redec && !check_redeclaration(dsym, (dowarn = 0, &dowarn))) {
 			if (dowarn) {
 				/* redeclaration of %s */
 				(*(sflag ? error : warning))(27, dsym->s_name);
 				print_previous_declaration(-1, rdsym);
+			}
 			/*
 			 * Take over the remembered params if the new symbol
 			 * is not a prototype.
 			 */
 			if (rdsym->s_osdef && !dsym->s_type->t_proto) {
 				dsym->s_osdef = rdsym->s_osdef;
 				dsym->s_args = rdsym->s_args;
 				dsym->s_def_pos = rdsym->s_def_pos;
+			}
 			/*
 			 * Remember the position of the declaration if the
 			 * old symbol was a prototype and the new is not.
 			 * Also remember the position if the old symbol
 			 * was defined and the new is not.
 			 */
 			if (rdsym->s_type->t_proto && !dsym->s_type->t_proto) {
 				dsym->s_def_pos = rdsym->s_def_pos;
 			} else if (rdsym->s_def == DEF && dsym->s_def != DEF) {
 				dsym->s_def_pos = rdsym->s_def_pos;
+			}
 			/*
 			 * Copy usage information of the name into the new
 			 * symbol.
 			 */
 			copy_usage_info(dsym, rdsym);
 			/* Once a name is defined, it remains defined. */
 			if (rdsym->s_def == DEF)
 				dsym->s_def = DEF;
 			/* once a function is inline, it remains inline */
 			if (rdsym->s_inline)
 				dsym->s_inline = 1;
 			complete_type(dsym, rdsym);
+		}
 		rmsym(rdsym);
+	}
 	if (dsym->s_scl == TYPEDEF) {
 		dsym->s_type = duptyp(dsym->s_type);
 		dsym->s_type->t_typedef = 1;
 		settdsym(dsym->s_type, dsym);
+	}
+}
 /*
  * Copies information about usage into a new symbol table entry of
  * the same symbol.
  */
 void
 copy_usage_info(sym_t *sym, sym_t *rdsym)
+{
 	sym->s_set_pos = rdsym->s_set_pos;
 	sym->s_use_pos = rdsym->s_use_pos;
 	sym->s_set = rdsym->s_set;
 	sym->s_used = rdsym->s_used;
+}
 /*
  * Prints an error and returns 1 if a symbol is redeclared/redefined.
  * Otherwise returns 0 and, in some cases of minor problems, prints
  * a warning.
  */
 int
 check_redeclaration(sym_t *dsym, int *dowarn)
+{
 	sym_t	*rsym;
 	if ((rsym = dcs->d_rdcsym)->s_scl == ENUMCON) {
 		/* redeclaration of %s */
 		error(27, dsym->s_name);
 		print_previous_declaration(-1, rsym);
 		return 1;
+	}
 	if (rsym->s_scl == TYPEDEF) {
 		/* typedef redeclared: %s */
 		error(89, dsym->s_name);
 		print_previous_declaration(-1, rsym);
 		return 1;
+	}
 	if (dsym->s_scl == TYPEDEF) {
 		/* redeclaration of %s */
 		error(27, dsym->s_name);
 		print_previous_declaration(-1, rsym);
 		return 1;
+	}
 	if (rsym->s_def == DEF && dsym->s_def == DEF) {
 		/* redefinition of %s */
 		error(28, dsym->s_name);
 		print_previous_declaration(-1, rsym);
 		return(1);
+	}
 	if (!eqtype(rsym->s_type, dsym->s_type, 0, 0, dowarn)) {
 		/* redeclaration of %s */
 		error(27, dsym->s_name);
 		print_previous_declaration(-1, rsym);
 		return(1);
+	}
 	if (rsym->s_scl == EXTERN && dsym->s_scl == EXTERN)
 		return(0);
 	if (rsym->s_scl == STATIC && dsym->s_scl == STATIC)
 		return(0);
 	if (rsym->s_scl == STATIC && dsym->s_def == DECL)
 		return(0);
 	if (rsym->s_scl == EXTERN && rsym->s_def == DEF) {
 		/*
 		 * All cases except "int a = 1; static int a;" are caught
 		 * above with or without a warning
 		 */
 		/* redeclaration of %s */
 		error(27, dsym->s_name);
 		print_previous_declaration(-1, rsym);
 		return(1);
+	}
 	if (rsym->s_scl == EXTERN) {
 		/* previously declared extern, becomes static: %s */
 		warning(29, dsym->s_name);
 		print_previous_declaration(-1, rsym);
 		return(0);
+	}
 	/*
 	 * Now it's one of:
 	 * "static a; int a;", "static a; int a = 1;", "static a = 1; int a;"
 	 */
 	/* redeclaration of %s; ANSI C requires "static" */
 	if (sflag) {
 		/* redeclaration of %s; ANSI C requires static */
 		warning(30, dsym->s_name);
 		print_previous_declaration(-1, rsym);
+	}
 	dsym->s_scl = STATIC;
 	return 0;
+}
 static int
 chkqual(type_t *tp1, type_t *tp2, int ignqual)
+{
 	if (tp1->t_const != tp2->t_const && !ignqual && !tflag)
 		return 0;
 	if (tp1->t_volatile != tp2->t_volatile && !ignqual && !tflag)
 		return 0;
 	return 1;
+}
 int
 eqptrtype(type_t *tp1, type_t *tp2, int ignqual)
+{
 	if (tp1->t_tspec != VOID && tp2->t_tspec != VOID)
 		return 0;
 	if (!chkqual(tp1, tp2, ignqual))
 		return 0;
 	return 1;
+}
 /*
  * Checks if two types are compatible. Returns 0 if not, otherwise 1.
+ *
  * ignqual	ignore qualifiers of type; used for function params
  * promot	promote left type; used for comparison of params of
  *		old style function definitions with params of prototypes.
  * *dowarn	set to 1 if an old style function declaration is not
  *		compatible with a prototype
  */
 int
 eqtype(type_t *tp1, type_t *tp2, int ignqual, int promot, int *dowarn)
+{
 	tspec_t	t;
 	while (tp1 != NULL && tp2 != NULL) {
 		t = tp1->t_tspec;
 		if (promot) {
 			if (t == FLOAT) {
 				t = DOUBLE;
 			} else if (t == CHAR || t == SCHAR) {
 				t = INT;
 			} else if (t == UCHAR) {
 				t = tflag ? UINT : INT;
 			} else if (t == SHORT) {
 				t = INT;

 @@ -1,61 +1,61 @@
-/*	$NetBSD: msg_035.c,v 1.3 2021/01/02 16:12:39 rillig Exp $	*/
+/*	$NetBSD: msg_035.c,v 1.4 2021/01/02 16:33:39 rillig Exp $	*/
 # 3 "msg_035.c"
 // Test for message: illegal bit-field type [35]
 /*
  * In traditional C, only unsigned int is a portable bit-field type.
+ *
  * In C89, only int, signed int and unsigned int are allowed (3.5.2.1p7).
+ *
  * In C99 and C11, only _Bool, signed int and unsigned int are allowed,
  * plus implementation-defined types (6.7.2.1p5).
  */
 typedef struct {
 	int dummy;
 } example_struct;
 typedef union {
 	int dummy;
 } example_union;
 typedef enum {
 	NO, YES
 } example_enum;
 typedef void (example_function)(int, const char *);
 /* Try all types from tspec_t. */
 struct example {
 	signed signed_flag: 1;
 	unsigned unsigned_flag: 1;
-	_Bool boolean_flag: 1;		// FIXME: allowed since C99 6.7.2.1p5
+	_Bool boolean_flag: 1;
 	char char_flag: 1;
 	signed char signed_char_flag: 1;
 	unsigned char unsigned_char_flag: 1;
 	short short_flag: 1;
 	unsigned short unsigned_short_flag: 1;
 	int int_flag: 1;
 	unsigned int unsigned_int_flag: 1;
 	long long_flag: 1;
 	unsigned long unsigned_long_flag: 1;
 	long long long_long_flag: 1;
 	unsigned long long unsigned_long_long_flag: 1;
 	/* __int128_t omitted since it is not always defined */
 	/* __uint128_t omitted since it is not always defined */
 	float float_flag: 1;
 	double double_flag: 1;
 	long double long_double_flag: 1;
 	void void_flag: 1;
 	example_struct struct_flag: 1;
 	example_union union_flag: 1;
 	example_enum enum_flag: 1;
 	void *pointer_flag: 1;
 	unsigned int array_flag[4]: 1;
 	example_function function_flag: 1;
 // FIXME: aborts:	_Complex complex_flag: 1;
 	float _Complex float_complex_flag: 1;
 	double _Complex double_complex_flag: 1;
 	long double _Complex long_double_complex_flag: 1;
 };

 @@ -1,18 +1,17 @@
 msg_035.c(33): warning: illegal bit-field type [35]
 msg_035.c(41): warning: illegal bit-field type [35]
 msg_035.c(42): warning: illegal bit-field type [35]
 msg_035.c(43): warning: illegal bit-field type [35]
 msg_035.c(44): warning: illegal bit-field type [35]
 msg_035.c(47): warning: illegal bit-field type [35]
 msg_035.c(48): warning: illegal bit-field type [35]
 msg_035.c(49): warning: illegal bit-field type [35]
 msg_035.c(50): void type for void_flag [19]
 msg_035.c(50): zero size bit-field [37]
 msg_035.c(51): warning: illegal bit-field type [35]
 msg_035.c(52): warning: illegal bit-field type [35]
 msg_035.c(54): warning: illegal bit-field type [35]
 msg_035.c(55): warning: illegal bit-field type [35]
 msg_035.c(56): warning: illegal bit-field type [35]
 msg_035.c(58): warning: illegal bit-field type [35]
 msg_035.c(59): warning: illegal bit-field type [35]
 msg_035.c(60): warning: illegal bit-field type [35]