 @@ -1,1398 +1,1398 @@
-/* $NetBSD: decl.c,v 1.100 2021/01/02 17:17:00 rillig Exp $ */
+/* $NetBSD: decl.c,v 1.101 2021/01/02 18:06:01 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.100 2021/01/02 17:17:00 rillig Exp $");
+__RCSID("$NetBSD: decl.c,v 1.101 2021/01/02 18:06:01 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 for _Complex */
 			error(308);
 			t = DCOMPLEX; /* just as a fallback */
+		}
 		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 ... */
+				/* modifying typedef with '%s'; only ... */
 				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 ... */
+			/* modifying typedef with '%s'; only qualifiers ... */
 			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 && 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.

 @@ -1,7 +1,10 @@
-/*	$NetBSD: msg_000.c,v 1.1 2021/01/02 10:22:42 rillig Exp $	*/
+/*	$NetBSD: msg_000.c,v 1.2 2021/01/02 18:06:01 rillig Exp $	*/
 # 3 "msg_000.c"
 // Test for message: empty declaration [0]
-TODO: "Add example code that triggers the above message."
+extern int extern_declared;
 TODO: "Add example code that almost triggers the above message."
+;
 static int local_defined;

 @@ -1,7 +1,8 @@
-/*	$NetBSD: msg_001.c,v 1.1 2021/01/02 10:22:42 rillig Exp $	*/
+/*	$NetBSD: msg_001.c,v 1.2 2021/01/02 18:06:01 rillig Exp $	*/
 # 3 "msg_001.c"
 // Test for message: old style declaration; add int [1]
-TODO: "Add example code that triggers the above message."
+old_style = 1;
 TODO: "Add example code that almost triggers the above message."
 int new_style = 1;

 @@ -1,7 +1,8 @@
-/*	$NetBSD: msg_002.c,v 1.1 2021/01/02 10:22:42 rillig Exp $	*/
+/*	$NetBSD: msg_002.c,v 1.2 2021/01/02 18:06:01 rillig Exp $	*/
 # 3 "msg_002.c"
 // Test for message: empty declaration [2]
-TODO: "Add example code that triggers the above message."
+int;
 TODO: "Add example code that almost triggers the above message."
 int local_variable;

 @@ -1,7 +1,21 @@
-/*	$NetBSD: msg_004.c,v 1.1 2021/01/02 10:22:42 rillig Exp $	*/
+/*	$NetBSD: msg_004.c,v 1.2 2021/01/02 18:06:01 rillig Exp $	*/
 # 3 "msg_004.c"
 // Test for message: illegal type combination [4]
-TODO: "Add example code that triggers the above message."
+// XXX: this goes undetected
-TODO: "Add example code that almost triggers the above message."
+signed double signed_double;
 int ok_int;
 double ok_double;
 float _Complex ok_float_complex;
 int _Complex illegal_int_complex;
 char enum {
 	CHAR
 };
 long struct {
 	int member;
 };

 @@ -1,7 +1,8 @@
-/*	$NetBSD: msg_005.c,v 1.1 2021/01/02 10:22:42 rillig Exp $	*/
+/*	$NetBSD: msg_005.c,v 1.2 2021/01/02 18:06:01 rillig Exp $	*/
 # 3 "msg_005.c"
 // Test for message: modifying typedef with '%s'; only qualifiers allowed [5]
-TODO: "Add example code that triggers the above message."
+typedef int number;
-TODO: "Add example code that almost triggers the above message."
+number long long_variable;
 number const const_variable;

 @@ -1,7 +1,9 @@
-/*	$NetBSD: msg_085.c,v 1.1 2021/01/02 10:22:43 rillig Exp $	*/
+/*	$NetBSD: msg_085.c,v 1.2 2021/01/02 18:06:01 rillig Exp $	*/
 # 3 "msg_085.c"
 // Test for message: dubious tag declaration: %s %s [85]
-TODO: "Add example code that triggers the above message."
+extern int stat(struct stat *);
 TODO: "Add example code that almost triggers the above message."
 struct ok;
 extern int ok(struct ok *);