 @@ -1,3353 +1,3353 @@
-/* $NetBSD: decl.c,v 1.247 2022/02/27 10:31:58 rillig Exp $ */
+/* $NetBSD: decl.c,v 1.248 2022/02/27 10:44:45 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.247 2022/02/27 10:31:58 rillig Exp $");
+__RCSID("$NetBSD: decl.c,v 1.248 2022/02/27 10:44:45 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	void	align(unsigned int, unsigned 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;
 	/*
 	 * The following two are not real types. They are only used by the
 	 * parser to handle the keywords "signed" and "unsigned".
 	 */
 	typetab[SIGNED].t_tspec = SIGNED;
 	typetab[UNSIGN].t_tspec = UNSIGN;
 	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;
 #ifdef INT128_SIZE
 	typetab[INT128].t_tspec = INT128;
 	typetab[UINT128].t_tspec = UINT128;
 #endif
 	typetab[FLOAT].t_tspec = FLOAT;
 	typetab[DOUBLE].t_tspec = DOUBLE;
 	typetab[LDOUBLE].t_tspec = LDOUBLE;
 	typetab[VOID].t_tspec = VOID;
 	/* struct, union, enum, ptr, array and func are not shared. */
 	typetab[COMPLEX].t_tspec = COMPLEX;
 	typetab[FCOMPLEX].t_tspec = FCOMPLEX;
 	typetab[DCOMPLEX].t_tspec = DCOMPLEX;
 	typetab[LCOMPLEX].t_tspec = LCOMPLEX;
+}
 #ifdef DEBUG
 /* Return the name of the "storage class" in the wider sense. */
 const char *
 scl_name(scl_t scl)
+{
 	static const char *const names[] = {
 	    "none", "extern", "static", "auto", "register", "typedef",
 	    "struct", "union", "enum", "member of struct", "member of union",
 	    "compile-time constant", "abstract",
 	    "old-style function argument", "prototype argument", "inline"
 	};
 	return names[scl];
+}
 #endif
 /*
  * Returns a shared type structure for arithmetic types and void.
+ *
  * It's important to duplicate this structure using block_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 *
 block_dup_type(const type_t *tp)
+{
 	type_t	*ntp;
 	ntp = block_zero_alloc(sizeof(*ntp));
 	*ntp = *tp;
 	return ntp;
+}
 /* Duplicate a type, free the allocated memory after the expression. */
 type_t *
 expr_dup_type(const type_t *tp)
+{
 	type_t	*ntp;
 	ntp = expr_zero_alloc(sizeof(*ntp));
 	*ntp = *tp;
 	return ntp;
+}
 /*
  * Return the unqualified version of the type.  The returned type is freed at
  * the end of the current expression.
+ *
  * See C99 6.2.5p25.
  */
 type_t *
 expr_unqualified_type(const type_t *tp)
+{
 	type_t *ntp;
 	ntp = expr_zero_alloc(sizeof(*ntp));
 	*ntp = *tp;
 	ntp->t_const = false;
 	ntp->t_volatile = false;
 	/*
 	 * In case of a struct or union type, the members should lose their
 	 * qualifiers as well, but that would require a deep copy of the
 	 * struct or union type.  This in turn would defeat the type
 	 * comparison in eqtype, which simply tests whether tp1->t_str ==
 	 * tp2->t_str.
 	 */
 	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 {
 		dcs->d_multiple_storage_classes = 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;
 	debug_step("%s: %s", __func__, type_name(tp));
 	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) {
 			dcs->d_invalid_type_combination = 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_invalid_type_combination = 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 does not support 'long long' */
 			c99ism(265, tflag ? "traditional C" : "C90");
+	}
 	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" */
 			dcs->d_invalid_type_combination = 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)
 			dcs->d_invalid_type_combination = 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_invalid_type_combination = true;
 			dcs->d_complex_mod = t;
 		} else {
 			if (dcs->d_abstract_type != NOTSPEC)
 				dcs->d_invalid_type_combination = 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)
 			dcs->d_invalid_type_combination = true;
 		dcs->d_abstract_type = t;
+	}
+}
 /* Merge the signedness into the abstract type. */
 static tspec_t
 merge_signedness(tspec_t t, tspec_t s)
+{
 	if (s == SIGNED)
 		return t == CHAR ? SCHAR : t;
 	if (s != UNSIGN)
 		return t;
 	return t == CHAR ? UCHAR
 	    : t == SHORT ? USHORT
 	    : t == INT ? UINT
 	    : t == LONG ? ULONG
 	    : t == QUAD ? UQUAD
 	    : 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;
 	if ((t == SIGNED || t == UNSIGN) &&
 	    (t2 == CHAR || t2 == SHORT || t2 == INT ||
 	     t2 == LONG || t2 == QUAD)) {
 		if (!tflag)
 			/* modifying typedef with '%s'; only qualifiers... */
 			warning(5, tspec_name(t));
 		td = block_dup_type(gettyp(merge_signedness(t2, t)));
 		td->t_typedef = true;
 		return td;
+	}
 	if (t == SHORT && (t2 == INT || t2 == UINT)) {
 		/* modifying typedef with '%s'; only qualifiers allowed */
 		warning(5, "short");
 		td = block_dup_type(gettyp(t2 == INT ? SHORT : USHORT));
 		td->t_typedef = true;
 		return td;
+	}
 	if (t == LONG &&
 	    (t2 == INT || t2 == UINT || t2 == LONG || t2 == ULONG ||
 	     t2 == FLOAT || t2 == DOUBLE || t2 == DCOMPLEX)) {
 		/* modifying typedef with '%s'; only qualifiers allowed */
 		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 = block_dup_type(td);
 		td->t_typedef = true;
 		return td;
+	}
 	/* Anything else is not accepted. */
 	dcs->d_invalid_type_combination = 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 typedef 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 unsigned int
 bitfieldsize(sym_t **mem)
+{
 	unsigned int 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 - len % 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) {
 			unsigned int x;
 			if (mem->s_type->t_bitfield) {
 				sp->sou_size_in_bits += bitfieldsize(&mem);
 				if (mem == NULL)
 					break;
+			}
 			x = 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;
 	debug_step("%s(%p %s)", __func__, dcs, scl_name(sc));
+}
 /*
  * Go back to previous declaration level
  */
 void
 end_declaration_level(void)
+{
 	dinfo_t	*di;
 	debug_step("%s(%p %s)", __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 OLD_STYLE_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_multiple_storage_classes = false;
 	dcs->d_invalid_type_combination = 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 == OLD_STYLE_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;
+		}
+	}
+}
 /*
  * Merge the declaration specifiers from dcs into dcs->d_type.
+ *
  * See C99 6.7.2 "Type specifiers".
  */
 static void
 dcs_merge_declaration_specifiers(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;
 	debug_step("%s: %s", __func__, type_name(tp));
 	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);
 		return;
+	}
 	if (t == NOTSPEC)
 		t = INT;
 	if (s == NOTSPEC && t == INT)
 		s = SIGNED;
 	if (l != NOTSPEC && t == CHAR) {
 		dcs->d_invalid_type_combination = true;
 		l = NOTSPEC;
+	}
 	if (l == LONG && t == FLOAT) {
 		l = NOTSPEC;
 		t = DOUBLE;
 		if (!tflag)
 			/* use 'double' instead of 'long float' */
 			warning(6);
+	}
 	if ((l == LONG && t == DOUBLE) || t == LDOUBLE) {
 		l = NOTSPEC;
 		t = LDOUBLE;
+	}
 	if (t == LDOUBLE && tflag) {
 		/* 'long double' is illegal in traditional C */
 		warning(266);
+	}
 	if (l == LONG && t == DCOMPLEX) {
 		l = NOTSPEC;
 		t = LCOMPLEX;
+	}
 	if (t != INT && t != CHAR && (s != NOTSPEC || l != NOTSPEC)) {
 		dcs->d_invalid_type_combination = true;
 		l = s = NOTSPEC;
+	}
 	if (l != NOTSPEC)
 		t = l;
 	dcs->d_type = gettyp(merge_signedness(t, s));
+}
 /*
  * 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)
+{
 	dcs_merge_declaration_specifiers();
 	if (dcs->d_multiple_storage_classes) {
 		/* only one storage class allowed */
 		error(7);
+	}
 	if (dcs->d_invalid_type_combination) {
 		/* 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 = block_dup_type(dcs->d_type);
 		dcs->d_type->t_const |= dcs->d_const;
 		dcs->d_type->t_volatile |= dcs->d_volatile;
+	}
+}
 /*
  * 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)
+{
 	unsigned 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);
 		lint_assert(elsz > 0);
 		break;
+	}
 	return (int)(elem * elsz);
+}
 unsigned int
 alignment_in_bits(const type_t *tp)
+{
 	unsigned int a;
 	tspec_t t;
 	while (tp->t_tspec == ARRAY)
 		tp = tp->t_subt;
 	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 = block_derive_type(*tpp, PTR);
 				} else {
 					*tpp = block_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 parameter cannot have ... */
 					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)) {
 			unsigned int sz;
 			/* illegal bit-field type '%s' */
 			warning(35, type_name(tp));
 			sz = tp->t_flen;
 			dsym->s_type = tp = block_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)
+{
 	type_t *tp;
 	tspec_t t;
 	check_bit_field_type(dsym, inout_tp, inout_t);
 	tp = *inout_tp;
 	t = *inout_t;
 	if (tp->t_flen > 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) {
 		/* bit-field in union is very unusual */
 		warning(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;
 	unsigned 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 = block_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 - dcs->d_offset % 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(unsigned int al, unsigned int len)
+{
 	unsigned 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 = block_zero_alloc(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 = block_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 = block_zero_alloc(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 = block_zero_alloc(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;
+	}
 	/*
 	 * XXX: What is this code doing on a semantic level, and why?
 	 * Returning decl leads to the wrong function types in msg_347.
 	 */
 	tpp = &decl->s_type;
 	while (*tpp != NULL && *tpp != dcs->d_next->d_type)
 		/*
 		 * XXX: accessing INT->t_subt feels strange, even though it
 		 * may even be guaranteed to be NULL.
 		 */
 		tpp = &(*tpp)->t_subt;
 	if (*tpp == NULL)
 	    return decl;	/* see msg_347 */
 	*tpp = tp = block_zero_alloc(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;
 	/*
 	 * Declarations of structs/unions/enums in param lists are legal,
 	 * but senseless.
 	 */
-	for (sym = dcs->d_dlsyms; sym != NULL; sym = sym->s_dlnxt) {
+	for (sym = dcs->d_dlsyms; sym != NULL; sym = sym->s_level_next) {
 		sc = sym->s_scl;
 		if (sc == STRUCT_TAG || sc == UNION_TAG || sc == ENUM_TAG) {
 			/* dubious tag declaration: %s %s */
 			warning(85, storage_class_name(sc), sym->s_name);
+		}
+	}
 	for (arg = args; arg != NULL; arg = arg->s_next) {
 		if (arg->s_type->t_tspec == VOID &&
 		    !(arg == args && arg->s_next == NULL)) {
 			/* void must be sole parameter */
 			error(60);
 			arg->s_type = gettyp(INT);
+		}
+	}
 	if (args == NULL || args->s_type->t_tspec == VOID)
 		return NULL;
 	return args;
+}
 /*
  * 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 OLD_STYLE_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 = block_zero_alloc(sizeof(*tp));
 			tp->t_packed = dcs->d_packed;
 		} else {
 			tp = tag->s_type;
+		}
 	} else {
 		tag = block_zero_alloc(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 = block_zero_alloc(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 = block_zero_alloc(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 = block_zero_alloc(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)
 					/* declaration introduces new ... */
 					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);
 			if (!sflag) {
 				/* declaration introduces new type in ... */
 				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 ||
 		    (decl && !is_incomplete(tag->s_type))) {
 			/* %s tag '%s' redeclared as %s */
 			error(46, storage_class_name(tag->s_scl),
 			    tag->s_name, storage_class_name(scl));
 			print_previous_declaration(-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);
+	}
 	/* NOTREACHED */
+}
 /*
  * 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((u_int)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);
+	}
 	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_bitfield) {
 				sp->sou_size_in_bits += bitfieldsize(&mem);
 				if (mem == NULL)
 					break;
+			}
 			sp->sou_size_in_bits +=
 			    type_size_in_bits(mem->s_type);
+		}
 		if (mem->s_name != unnamed)
 			n++;
+	}
 	if (n == 0 && sp->sou_size_in_bits != 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, true);
 	tp->t_enum->en_first_enumerator = 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 true if the value of the enumerator was not explicitly specified.
  */
 sym_t *
 enumeration_constant(sym_t *sym, int val, bool impl)
+{
 	if (sym->s_scl != NOSCL) {
 		if (sym->s_block_level == block_level) {
 			/* 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 (block_level == 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 = CTCONST;
 	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.
  */
 static void
 declare_extern(sym_t *dsym, bool initflg, sbuf_t *renaming)
+{
 	bool	dowarn, rval, redec;
 	sym_t	*rdsym;
 	char	*s;
 	if (renaming != NULL) {
 		lint_assert(dsym->s_rename == NULL);
 		s = level_zero_alloc(1, renaming->sb_len + 1);
 		(void)memcpy(s, renaming->sb_name, renaming->sb_len + 1);
 		dsym->s_rename = s;
+	}
 	check_function_definition(dsym, true);
 	check_type(dsym);
 	if (initflg && !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 = true;
 		} 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 prototype 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, false, NULL);
 	} else if (!is_compiler_builtin(dsym->s_name)) {
 		outsym(dsym, dsym->s_scl, dsym->s_def);
+	}
 	if ((rdsym = dcs->d_redeclared_symbol) != 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 = false;
+		}
 		if (!redec &&
 		    !check_redeclaration(dsym, (dowarn = false, &dowarn))) {
 			if (dowarn) {
 				if (sflag)
 					/* redeclaration of %s */
 					error(27, dsym->s_name);
 				else
 					/* redeclaration of %s */
 					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 = true;
 			complete_type(dsym, rdsym);
+		}
 		rmsym(rdsym);
+	}
 	if (dsym->s_scl == TYPEDEF) {
 		dsym->s_type = block_dup_type(dsym->s_type);
 		dsym->s_type->t_typedef = true;
 		settdsym(dsym->s_type, dsym);
+	}
+}
 void
 declare(sym_t *decl, bool initflg, sbuf_t *renaming)
+{
 	if (dcs->d_ctx == EXTERN) {
 		declare_extern(decl, initflg, renaming);
 	} else if (dcs->d_ctx == OLD_STYLE_ARG || dcs->d_ctx == PROTO_ARG) {
 		if (renaming != NULL) {
 			/* symbol renaming can't be used on function arguments */
 			error(310);
 		} else
 			(void)declare_argument(decl, initflg);
 	} else {
 		lint_assert(dcs->d_ctx == AUTO);
 		if (renaming != NULL) {
 			/* symbol renaming can't be used on automatic variables */
 			error(311);
 		} else
 			declare_local(decl, initflg);
+	}
+}
 /*
  * 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 true if a symbol is redeclared/redefined.
  * Otherwise returns false and, in some cases of minor problems, prints
  * a warning.
  */
 bool
 check_redeclaration(sym_t *dsym, bool *dowarn)
+{
 	sym_t	*rsym;
 	if ((rsym = dcs->d_redeclared_symbol)->s_scl == CTCONST) {
 		/* redeclaration of %s */
 		error(27, dsym->s_name);
 		print_previous_declaration(-1, rsym);
 		return true;
+	}
 	if (rsym->s_scl == TYPEDEF) {
 		/* typedef redeclared: %s */
 		error(89, dsym->s_name);
 		print_previous_declaration(-1, rsym);
 		return true;
+	}
 	if (dsym->s_scl == TYPEDEF) {
 		/* redeclaration of %s */
 		error(27, dsym->s_name);
 		print_previous_declaration(-1, rsym);
 		return true;
+	}
 	if (rsym->s_def == DEF && dsym->s_def == DEF) {
 		/* redefinition of %s */
 		error(28, dsym->s_name);
 		print_previous_declaration(-1, rsym);
 		return true;
+	}
 	if (!eqtype(rsym->s_type, dsym->s_type, false, false, dowarn)) {
 		/* redeclaration of '%s' with type '%s', expected '%s' */
 		error(347, dsym->s_name,
 		    type_name(dsym->s_type), type_name(rsym->s_type));
 		print_previous_declaration(-1, rsym);
 		return true;
+	}
 	if (rsym->s_scl == EXTERN && dsym->s_scl == EXTERN)
 		return false;
 	if (rsym->s_scl == STATIC && dsym->s_scl == STATIC)
 		return false;
 	if (rsym->s_scl == STATIC && dsym->s_def == DECL)
 		return false;
 	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 true;
+	}
 	if (rsym->s_scl == EXTERN) {
 		/* previously declared extern, becomes static: %s */
 		warning(29, dsym->s_name);
 		print_previous_declaration(-1, rsym);
 		return false;
+	}
 	/*
 	 * 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 false;
+}
 static bool
 qualifiers_correspond(const type_t *tp1, const type_t *tp2, bool ignqual)
+{
 	if (tp1->t_const != tp2->t_const && !ignqual && !tflag)
 		return false;
 	if (tp1->t_volatile != tp2->t_volatile && !ignqual && !tflag)
 		return false;
 	return true;
+}
 bool
 eqptrtype(const type_t *tp1, const type_t *tp2, bool ignqual)
+{
 	if (tp1->t_tspec != VOID && tp2->t_tspec != VOID)
 		return false;
 	if (!qualifiers_correspond(tp1, tp2, ignqual))
 		return false;
 	return true;
+}
 /*
  * Checks if two types are compatible.
+ *
  * 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 true if an old style function declaration is not
  *		compatible with a prototype
  */
 bool
 eqtype(const type_t *tp1, const type_t *tp2,
        bool ignqual, bool promot, bool *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;
 			} else if (t == USHORT) {
 				/* CONSTCOND */
 				t = TARG_INT_MAX < TARG_USHRT_MAX || tflag ? UINT : INT;
+			}
+		}
 		if (t != tp2->t_tspec)
 			return false;
 		if (!qualifiers_correspond(tp1, tp2, ignqual))
 			return false;
 		if (t == STRUCT || t == UNION)
 			return tp1->t_str == tp2->t_str;
 		if (t == ENUM && eflag)
 			return tp1->t_enum == tp2->t_enum;
 		if (t == ARRAY && tp1->t_dim != tp2->t_dim) {
 			if (tp1->t_dim != 0 && tp2->t_dim != 0)
 				return false;
+		}
 		/* don't check prototypes for traditional */
 		if (t == FUNC && !tflag) {
 			if (tp1->t_proto && tp2->t_proto) {
 				if (!eqargs(tp1, tp2, dowarn))
 					return false;
 			} else if (tp1->t_proto) {
 				if (!mnoarg(tp1, dowarn))
 					return false;
 			} else if (tp2->t_proto) {
 				if (!mnoarg(tp2, dowarn))
 					return false;
+			}
+		}
 		tp1 = tp1->t_subt;
 		tp2 = tp2->t_subt;
 		ignqual = promot = false;
+	}
 	return tp1 == tp2;
+}
 /*
  * Compares the parameter types of two prototypes.
  */
 static bool
 eqargs(const type_t *tp1, const type_t *tp2, bool *dowarn)
+{
 	sym_t	*a1, *a2;
 	if (tp1->t_vararg != tp2->t_vararg)
 		return false;
 	a1 = tp1->t_args;
 	a2 = tp2->t_args;
 	while (a1 != NULL && a2 != NULL) {
 		if (!eqtype(a1->s_type, a2->s_type, true, false, dowarn))
 			return false;
 		a1 = a1->s_next;
 		a2 = a2->s_next;
+	}
 	return a1 == a2;
+}
 /*
  * mnoarg() (matches functions with no argument type information)
  * returns whether all parameters of a prototype are compatible with
  * an old style function declaration.
  * This is the case if the following conditions are met:
  *	1. the prototype has a fixed number of parameters
  *	2. no parameter is of type float
  *	3. no parameter is converted to another type if integer promotion
  *	   is applied on it
  */
 static bool
 mnoarg(const type_t *tp, bool *dowarn)
+{
 	sym_t	*arg;
 	tspec_t	t;
 	if (tp->t_vararg) {
 		if (dowarn != NULL)
 			*dowarn = true;
+	}
 	for (arg = tp->t_args; arg != NULL; arg = arg->s_next) {
 		if ((t = arg->s_type->t_tspec) == FLOAT ||
 		    t == CHAR || t == SCHAR || t == UCHAR ||
 		    t == SHORT || t == USHORT) {
 			if (dowarn != NULL)
 				*dowarn = true;
+		}
+	}
 	return true;
+}
 /*
  * Compares a prototype declaration with the remembered arguments of
  * a previous old style function definition.
  */
 static bool
 check_old_style_definition(sym_t *rdsym, sym_t *dsym)
+{
 	sym_t	*args, *pargs, *arg, *parg;
 	int	narg, nparg, n;
 	bool	dowarn, msg;
 	args = rdsym->s_args;
 	pargs = dsym->s_type->t_args;
 	msg = false;
 	narg = nparg = 0;
 	for (arg = args; arg != NULL; arg = arg->s_next)
 		narg++;
 	for (parg = pargs; parg != NULL; parg = parg->s_next)
 		nparg++;
 	if (narg != nparg) {
 		/* prototype does not match old-style definition */
 		error(63);
 		msg = true;
 		goto end;
+	}
 	arg = args;
 	parg = pargs;
 	n = 1;
 	while (narg-- > 0) {
 		dowarn = false;
 		/*
 		 * If it does not match due to promotion and sflag is
 		 * not set we print only a warning.
 		 */
 		if (!eqtype(arg->s_type, parg->s_type, true, true, &dowarn) ||
 		    dowarn) {
 			/* prototype does not match old style ... */
 			error(299, n);
 			msg = true;
+		}
 		arg = arg->s_next;
 		parg = parg->s_next;
 		n++;
+	}
  end:
 	if (msg)
 		/* old style definition */
 		print_previous_declaration(300, rdsym);
 	return msg;
+}
 /*
  * Completes a type by copying the dimension and prototype information
  * from a second compatible type.
+ *
  * Following lines are legal:
  *  "typedef a[]; a b; a b[10]; a c; a c[20];"
  *  "typedef ft(); ft f; f(int); ft g; g(long);"
  * This means that, if a type is completed, the type structure must
  * be duplicated.
  */
 void
 complete_type(sym_t *dsym, sym_t *ssym)
+{
 	type_t	**dstp, *src;
 	type_t	*dst;
 	dstp = &dsym->s_type;
 	src = ssym->s_type;
 	while ((dst = *dstp) != NULL) {
 		lint_assert(src != NULL);
 		lint_assert(dst->t_tspec == src->t_tspec);
 		if (dst->t_tspec == ARRAY) {
 			if (dst->t_dim == 0 && src->t_dim != 0) {
 				*dstp = dst = block_dup_type(dst);
 				dst->t_dim = src->t_dim;
 				setcomplete(dst, true);
+			}
 		} else if (dst->t_tspec == FUNC) {
 			if (!dst->t_proto && src->t_proto) {
 				*dstp = dst = block_dup_type(dst);
 				dst->t_proto = true;
 				dst->t_args = src->t_args;
+			}
+		}
 		dstp = &dst->t_subt;
 		src = src->t_subt;
+	}
+}
 /*
  * Completes the declaration of a single argument.
  */
 sym_t *
 declare_argument(sym_t *sym, bool initflg)
+{
 	tspec_t	t;
 	check_function_definition(sym, true);
 	check_type(sym);
 	if (dcs->d_redeclared_symbol != NULL &&
 	    dcs->d_redeclared_symbol->s_block_level == block_level) {
 		/* redeclaration of formal parameter %s */
 		error(237, sym->s_name);
 		rmsym(dcs->d_redeclared_symbol);
 		sym->s_arg = true;
+	}
 	if (!sym->s_arg) {
 		/* declared argument %s is missing */
 		error(53, sym->s_name);
 		sym->s_arg = true;
+	}
 	if (initflg) {
 		/* cannot initialize parameter: %s */
 		error(52, sym->s_name);
+	}
 	if (sym->s_type == NULL)	/* for c(void()) */
 		sym->s_type = gettyp(VOID);
 	if ((t = sym->s_type->t_tspec) == ARRAY) {
 		sym->s_type = block_derive_type(sym->s_type->t_subt, PTR);
 	} else if (t == FUNC) {
 		if (tflag)
 			/* a function is declared as an argument: %s */
 			warning(50, sym->s_name);
 		sym->s_type = block_derive_type(sym->s_type, PTR);
 	} else if (t == FLOAT) {
 		if (tflag)
 			sym->s_type = gettyp(DOUBLE);
+	}
 	if (dcs->d_inline)
 		/* argument declared inline: %s */
 		warning(269, sym->s_name);
 	/*
 	 * Arguments must have complete types. length() prints the needed
 	 * error messages (null dimension is impossible because arrays are
 	 * converted to pointers).
 	 */
 	if (sym->s_type->t_tspec != VOID)
 		(void)length(sym->s_type, sym->s_name);
 	sym->s_used = dcs->d_used;
 	mark_as_set(sym);
 	return sym;
+}
 void
 check_func_lint_directives(void)
+{
 	sym_t *arg;
 	int narg, n;
 	tspec_t t;
 	/* check for illegal combinations of lint directives */
 	if (printflike_argnum != -1 && scanflike_argnum != -1) {
 		/* can't be used together: ** PRINTFLIKE ** ** SCANFLIKE ** */
 		warning(289);
 		printflike_argnum = scanflike_argnum = -1;
+	}
 	if (nvararg != -1 &&
 	    (printflike_argnum != -1 || scanflike_argnum != -1)) {
 		/* dubious use of ** VARARGS ** with ** %s ** */
 		warning(288,
 		    printflike_argnum != -1 ? "PRINTFLIKE" : "SCANFLIKE");
 		nvararg = -1;
+	}
 	/*
 	 * check if the argument of a lint directive is compatible with the
 	 * number of arguments.
 	 */
 	narg = 0;
 	for (arg = dcs->d_func_args; arg != NULL; arg = arg->s_next)
 		narg++;
 	if (nargusg > narg) {
 		/* argument number mismatch with directive: ** %s ** */
 		warning(283, "ARGSUSED");
 		nargusg = 0;
+	}
 	if (nvararg > narg) {
 		/* argument number mismatch with directive: ** %s ** */
 		warning(283, "VARARGS");
 		nvararg = 0;
+	}
 	if (printflike_argnum > narg) {
 		/* argument number mismatch with directive: ** %s ** */
 		warning(283, "PRINTFLIKE");
 		printflike_argnum = -1;
 	} else if (printflike_argnum == 0) {
 		printflike_argnum = -1;
+	}
 	if (scanflike_argnum > narg) {
 		/* argument number mismatch with directive: ** %s ** */
 		warning(283, "SCANFLIKE");
 		scanflike_argnum = -1;
 	} else if (scanflike_argnum == 0) {
 		scanflike_argnum = -1;
+	}
 	if (printflike_argnum != -1 || scanflike_argnum != -1) {
 		narg = printflike_argnum != -1
 		    ? printflike_argnum : scanflike_argnum;
 		arg = dcs->d_func_args;
 		for (n = 1; n < narg; n++)
 			arg = arg->s_next;
 		if (arg->s_type->t_tspec != PTR ||
 		    ((t = arg->s_type->t_subt->t_tspec) != CHAR &&
 		     t != UCHAR && t != SCHAR)) {
 			/* argument %d must be 'char *' for PRINTFLIKE/... */
 			warning(293, narg);
 			printflike_argnum = scanflike_argnum = -1;
+		}
+	}
+}
 /*
  * Warn about arguments in old style function definitions that default to int.
  * Check that an old style function definition is compatible to a previous
  * prototype.
  */
 void
 check_func_old_style_arguments(void)
+{
 	sym_t *args, *arg, *pargs, *parg;
 	int narg, nparg;
 	bool msg;
 	args = funcsym->s_args;
 	pargs = funcsym->s_type->t_args;
 	/*
 	 * print a warning for each argument of an old style function
 	 * definition which defaults to int
 	 */
 	for (arg = args; arg != NULL; arg = arg->s_next) {
 		if (arg->s_defarg) {
 			/* argument type defaults to 'int': %s */
 			warning(32, arg->s_name);
 			arg->s_defarg = false;
 			mark_as_set(arg);
+		}
+	}
 	/*
 	 * If this is an old style function definition and a prototype
 	 * exists, compare the types of arguments.
 	 */
 	if (funcsym->s_osdef && funcsym->s_type->t_proto) {
 		/*
 		 * If the number of arguments does not match, we need not
 		 * continue.
 		 */
 		narg = nparg = 0;
 		msg = false;
 		for (parg = pargs; parg != NULL; parg = parg->s_next)
 			nparg++;
 		for (arg = args; arg != NULL; arg = arg->s_next)
 			narg++;
 		if (narg != nparg) {
 			/* parameter mismatch: %d declared, %d defined */
 			error(51, nparg, narg);
 			msg = true;
 		} else {
 			parg = pargs;
 			arg = args;
 			while (narg-- > 0) {
 				msg |= check_prototype_declaration(arg, parg);
 				parg = parg->s_next;
 				arg = arg->s_next;
+			}
+		}
 		if (msg)
 			/* prototype declaration */
 			print_previous_declaration(285,
 			    dcs->d_redeclared_symbol);
 		/* from now on the prototype is valid */
 		funcsym->s_osdef = false;
 		funcsym->s_args = NULL;
+	}
+}
 /*
  * Checks compatibility of an old style function definition with a previous
  * prototype declaration.
  * Returns true if the position of the previous declaration should be reported.
  */
 static bool
 check_prototype_declaration(sym_t *arg, sym_t *parg)
+{
 	type_t	*tp, *ptp;
 	bool	dowarn, msg;
 	tp = arg->s_type;
 	ptp = parg->s_type;
 	msg = false;
 	dowarn = false;
 	if (!eqtype(tp, ptp, true, true, &dowarn)) {
 		if (eqtype(tp, ptp, true, false, &dowarn)) {
 			/* type does not match prototype: %s */
 			gnuism(58, arg->s_name);
 			msg = sflag || !gflag;
 		} else {
 			/* type does not match prototype: %s */
 			error(58, arg->s_name);
 			msg = true;
+		}
 	} else if (dowarn) {
 		if (sflag)
 			/* type does not match prototype: %s */
 			error(58, arg->s_name);
 		else
 			/* type does not match prototype: %s */
 			warning(58, arg->s_name);
 		msg = true;
+	}
 	return msg;
+}
 static void
 check_local_hiding(const sym_t *dsym)
+{
 	switch (dsym->s_scl) {
 	case AUTO:
 		/* automatic hides external declaration: %s */
 		warning(86, dsym->s_name);
 		break;
 	case STATIC:
 		/* static hides external declaration: %s */
 		warning(87, dsym->s_name);
 		break;
 	case TYPEDEF:
 		/* typedef hides external declaration: %s */
 		warning(88, dsym->s_name);
 		break;
 	case EXTERN:
 		/* Already checked in declare_external_in_block. */
 		break;
 	default:
 		lint_assert(/*CONSTCOND*/false);
+	}
+}
 static void
 check_local_redeclaration(const sym_t *dsym, sym_t *rsym)
+{
 	if (rsym->s_block_level == 0) {
 		if (hflag)
 			check_local_hiding(dsym);
 	} else if (rsym->s_block_level == block_level) {
 		/* no hflag, because it's illegal! */
 		if (rsym->s_arg) {
 			/*
 			 * if !tflag, a "redeclaration of %s" error
 			 * is produced below
 			 */
 			if (tflag) {
 				if (hflag)
 					/* declaration hides parameter: %s */
 					warning(91, dsym->s_name);
 				rmsym(rsym);
+			}
+		}
 	} else if (rsym->s_block_level < block_level) {
 		if (hflag)
 			/* declaration hides earlier one: %s */
 			warning(95, dsym->s_name);
+	}
 	if (rsym->s_block_level == block_level) {
 		/* redeclaration of %s */
 		error(27, dsym->s_name);
 		rmsym(rsym);
+	}
+}
 /*
  * Completes a single local declaration/definition.
  */
 void
 declare_local(sym_t *dsym, bool initflg)
+{
 	/* Correct a mistake done in declarator_name(). */
 	if (dsym->s_type->t_tspec == FUNC) {
 		dsym->s_def = DECL;
 		if (dcs->d_scl == NOSCL)
 			dsym->s_scl = EXTERN;
+	}
 	if (dsym->s_type->t_tspec == FUNC) {
 		if (dsym->s_scl == STATIC) {
 			/* dubious static function at block level: %s */
 			warning(93, dsym->s_name);
 			dsym->s_scl = EXTERN;
 		} else if (dsym->s_scl != EXTERN && dsym->s_scl != TYPEDEF) {
 			/* function has illegal storage class: %s */
 			error(94, dsym->s_name);
 			dsym->s_scl = EXTERN;
+		}
+	}
 	/*
 	 * functions may be declared inline at local scope, although
 	 * this has no effect for a later definition of the same
 	 * function.
 	 * XXX it should have an effect if tflag is set. this would
 	 * also be the way gcc behaves.
 	 */
 	if (dcs->d_inline) {
 		if (dsym->s_type->t_tspec == FUNC) {
 			dsym->s_inline = true;
 		} else {
 			/* variable declared inline: %s */
 			warning(268, dsym->s_name);
+		}
+	}
 	check_function_definition(dsym, true);
 	check_type(dsym);
 	if (dcs->d_redeclared_symbol != NULL && dsym->s_scl == EXTERN)
 		declare_external_in_block(dsym);
 	if (dsym->s_scl == EXTERN) {
 		/*
 		 * XXX if the static variable at level 0 is only defined
 		 * later, checking will be possible.
 		 */
 		if (dsym->s_ext_sym == NULL) {
 			outsym(dsym, EXTERN, dsym->s_def);
 		} else {
 			outsym(dsym, dsym->s_ext_sym->s_scl, dsym->s_def);
+		}
+	}
 	if (dcs->d_redeclared_symbol != NULL)
 		check_local_redeclaration(dsym, dcs->d_redeclared_symbol);
 	if (initflg && !check_init(dsym)) {
 		dsym->s_def = DEF;
 		mark_as_set(dsym);
+	}
 	if (dsym->s_scl == TYPEDEF) {
 		dsym->s_type = block_dup_type(dsym->s_type);
 		dsym->s_type->t_typedef = true;
 		settdsym(dsym->s_type, dsym);
+	}
 	/*
 	 * Before we can check the size we must wait for a initialization
 	 * which may follow.
 	 */
+}
 /*
  * Processes (re)declarations of external symbols inside blocks.
  */
 static void
 declare_external_in_block(sym_t *dsym)
+{
 	bool	eqt, dowarn;
 	sym_t	*esym;
 	/* look for a symbol with the same name */
 	esym = dcs->d_redeclared_symbol;
 	while (esym != NULL && esym->s_block_level != 0) {
-		while ((esym = esym->s_link) != NULL) {
+		while ((esym = esym->s_symtab_next) != NULL) {
 			if (esym->s_kind != FVFT)
 				continue;
 			if (strcmp(dsym->s_name, esym->s_name) == 0)
 				break;
+		}
+	}
 	if (esym == NULL)
 		return;
 	if (esym->s_scl != EXTERN && esym->s_scl != STATIC) {
 		/* gcc accepts this without a warning, pcc prints an error. */
 		/* redeclaration of %s */
 		warning(27, dsym->s_name);
 		print_previous_declaration(-1, esym);
 		return;
+	}
 	dowarn = false;
 	eqt = eqtype(esym->s_type, dsym->s_type, false, false, &dowarn);
 	if (!eqt || dowarn) {
 		if (esym->s_scl == EXTERN) {
 			/* inconsistent redeclaration of extern: %s */
 			warning(90, dsym->s_name);
 			print_previous_declaration(-1, esym);
 		} else {
 			/* inconsistent redeclaration of static: %s */
 			warning(92, dsym->s_name);
 			print_previous_declaration(-1, esym);
+		}
+	}
 	if (eqt) {
 		/*
 		 * Remember the external symbol so we can update usage
 		 * information at the end of the block.
 		 */
 		dsym->s_ext_sym = esym;
+	}
+}
 /*
  * Print an error or a warning if the symbol cannot be initialized due
  * to type/storage class. Return whether an error has been detected.
  */
 static bool
 check_init(sym_t *sym)
+{
 	bool	erred;
 	erred = false;
 	if (sym->s_type->t_tspec == FUNC) {
 		/* cannot initialize function: %s */
 		error(24, sym->s_name);
 		erred = true;
 	} else if (sym->s_scl == TYPEDEF) {
 		/* cannot initialize typedef: %s */
 		error(25, sym->s_name);
 		erred = true;
 	} else if (sym->s_scl == EXTERN && sym->s_def == DECL) {
 		/* cannot initialize "extern" declaration: %s */
 		if (dcs->d_ctx == EXTERN) {
 			/* cannot initialize extern declaration: %s */
 			warning(26, sym->s_name);
 		} else {
 			/* cannot initialize extern declaration: %s */
 			error(26, sym->s_name);
 			erred = true;
+		}
+	}
 	return erred;
+}
 /*
  * Create a symbol for an abstract declaration.
  */
 sym_t *
 abstract_name(void)
+{
 	sym_t	*sym;
 	lint_assert(dcs->d_ctx == ABSTRACT || dcs->d_ctx == PROTO_ARG);
 	sym = block_zero_alloc(sizeof(*sym));
 	sym->s_name = unnamed;
 	sym->s_def = DEF;
 	sym->s_scl = ABSTRACT;
 	sym->s_block_level = -1;
 	if (dcs->d_ctx == PROTO_ARG)
 		sym->s_arg = true;
 	/*
 	 * At this point, dcs->d_type contains only the basic type.  That
 	 * type will be updated later, adding pointers, arrays and functions
 	 * as necessary.
 	 */
 	/*
 	 * XXX: This is not the correct type.  For example in msg_347, it is
 	 * the type of the last prototype parameter, but it should rather be
 	 * the return type of the function.
 	 */
 	sym->s_type = dcs->d_type;
 	dcs->d_redeclared_symbol = NULL;
 	dcs->d_vararg = false;
 	return sym;
+}
 /*
  * Removes anything which has nothing to do on global level.
  */
 void
 global_clean_up(void)
+{
 	while (dcs->d_next != NULL)
 		end_declaration_level();
 	cleanup();
 	block_level = 0;
 	mem_block_level = 0;
 	/*
 	 * remove all information about pending lint directives without
 	 * warnings.
 	 */
 	global_clean_up_decl(true);
+}
 /*
  * Process an abstract type declaration
  */
 sym_t *
 declare_1_abstract(sym_t *sym)
+{
 	check_function_definition(sym, true);
 	check_type(sym);
 	return sym;
+}
 /*
  * Checks size after declarations of variables and their initialization.
  */
 void
 check_size(sym_t *dsym)
+{
 	if (dsym->s_def != DEF)
 		return;
 	if (dsym->s_scl == TYPEDEF)
 		return;
 	if (dsym->s_type->t_tspec == FUNC)
 		return;
 	if (length(dsym->s_type, dsym->s_name) == 0 &&
 	    dsym->s_type->t_tspec == ARRAY && dsym->s_type->t_dim == 0) {
 		if (tflag) {
 			/* empty array declaration: %s */
 			warning(190, dsym->s_name);
 		} else {
 			/* empty array declaration: %s */
 			error(190, dsym->s_name);
+		}
+	}
+}
 /*
  * Mark an object as set if it is not already
  */
 void
 mark_as_set(sym_t *sym)
+{
 	if (!sym->s_set) {
 		sym->s_set = true;
 		UNIQUE_CURR_POS(sym->s_set_pos);
+	}
+}
 /*
  * Mark an object as used if it is not already
  */
 void
 mark_as_used(sym_t *sym, bool fcall, bool szof)
+{
 	if (!sym->s_used) {
 		sym->s_used = true;
 		UNIQUE_CURR_POS(sym->s_use_pos);
+	}
 	/*
 	 * for function calls another record is written
+	 *
 	 * XXX Should symbols used in sizeof() be treated as used or not?
 	 * Probably not, because there is no sense to declare an
 	 * external variable only to get their size.
 	 */
 	if (!fcall && !szof && sym->s_kind == FVFT && sym->s_scl == EXTERN)
 		outusg(sym);
+}
 /*
  * Prints warnings for a list of variables and labels (concatenated
- * with s_dlnxt) if these are not used or only set.
+ * with s_level_next) if these are not used or only set.
  */
 void
 check_usage(dinfo_t *di)
+{
 	sym_t	*sym;
 	int	mklwarn;
 	/* for this warning LINTED has no effect */
 	mklwarn = lwarn;
 	lwarn = LWARN_ALL;
 	debug_step("begin lwarn %d", lwarn);
-	for (sym = di->d_dlsyms; sym != NULL; sym = sym->s_dlnxt)
+	for (sym = di->d_dlsyms; sym != NULL; sym = sym->s_level_next)
 		check_usage_sym(di->d_asm, sym);
 	lwarn = mklwarn;
 	debug_step("end lwarn %d", lwarn);
+}
 /*
  * Prints a warning for a single variable or label if it is not used or
  * only set.
  */
 void
 check_usage_sym(bool novar, sym_t *sym)
+{
 	if (sym->s_block_level == -1)
 		return;
 	if (sym->s_kind == FVFT && sym->s_arg)
 		check_argument_usage(novar, sym);
 	else if (sym->s_kind == FVFT)
 		check_variable_usage(novar, sym);
 	else if (sym->s_kind == FLABEL)
 		check_label_usage(sym);
 	else if (sym->s_kind == FTAG)
 		check_tag_usage(sym);
+}
 static void
 check_argument_usage(bool novar, sym_t *arg)
+{
 	lint_assert(arg->s_set);
 	if (novar)
 		return;
 	if (!arg->s_used && vflag) {
 		/* argument '%s' unused in function '%s' */
 		warning_at(231, &arg->s_def_pos, arg->s_name, funcsym->s_name);
+	}
+}
 static void
 check_variable_usage(bool novar, sym_t *sym)
+{
 	scl_t	sc;
 	sym_t	*xsym;
 	lint_assert(block_level != 0);
 	/* example at file scope: int c = ({ return 3; }); */
 	if (sym->s_block_level == 0 && ch_isdigit(sym->s_name[0]))
 		return;
 	/* errors in expressions easily cause lots of these warnings */
 	if (nerr != 0)
 		return;
 	/*
 	 * XXX Only variables are checked, although types should
 	 * probably also be checked
 	 */
 	if ((sc = sym->s_scl) != EXTERN && sc != STATIC &&
 	    sc != AUTO && sc != REG) {
 		return;
+	}
 	if (novar)
 		return;
 	if (sc == EXTERN) {
 		if (!sym->s_used && !sym->s_set) {
 			/* '%s' unused in function '%s' */
 			warning_at(192, &sym->s_def_pos,
 			    sym->s_name, funcsym->s_name);
+		}
 	} else {
 		if (sym->s_set && !sym->s_used) {
 			/* '%s' set but not used in function '%s' */
 			warning_at(191, &sym->s_set_pos,
 			    sym->s_name, funcsym->s_name);
 		} else if (!sym->s_used) {
 			/* '%s' unused in function '%s' */
 			warning_at(192, &sym->s_def_pos,
 			    sym->s_name, funcsym->s_name);
+		}
+	}
 	if (sc == EXTERN) {
 		/*
 		 * information about usage is taken over into the symbol
 		 * table entry at level 0 if the symbol was locally declared
 		 * as an external symbol.
+		 *
 		 * XXX This is wrong for symbols declared static at level 0
 		 * if the usage information stems from sizeof(). This is
 		 * because symbols at level 0 only used in sizeof() are
 		 * considered to not be used.
 		 */
 		if ((xsym = sym->s_ext_sym) != NULL) {
 			if (sym->s_used && !xsym->s_used) {
 				xsym->s_used = true;
 				xsym->s_use_pos = sym->s_use_pos;
+			}
 			if (sym->s_set && !xsym->s_set) {
 				xsym->s_set = true;
 				xsym->s_set_pos = sym->s_set_pos;
+			}
+		}
+	}
+}
 static void
 check_label_usage(sym_t *lab)
+{
 	lint_assert(block_level == 1);
 	lint_assert(lab->s_block_level == 1);
 	if (lab->s_set && !lab->s_used) {
 		/* label '%s' unused in function '%s' */
 		warning_at(232, &lab->s_set_pos, lab->s_name, funcsym->s_name);
 	} else if (!lab->s_set) {
 		/* undefined label '%s' */
 		warning_at(23, &lab->s_use_pos, lab->s_name);
+	}
+}
 static void
 check_tag_usage(sym_t *sym)
+{
 	if (!is_incomplete(sym->s_type))
 		return;
 	/* always complain about incomplete tags declared inside blocks */
 	if (!zflag || dcs->d_ctx != EXTERN)
 		return;
 	switch (sym->s_type->t_tspec) {
 	case STRUCT:
 		/* struct %s never defined */
 		warning_at(233, &sym->s_def_pos, sym->s_name);
 		break;
 	case UNION:
 		/* union %s never defined */
 		warning_at(234, &sym->s_def_pos, sym->s_name);
 		break;
 	case ENUM:
 		/* enum %s never defined */
 		warning_at(235, &sym->s_def_pos, sym->s_name);
 		break;
 	default:
 		lint_assert(/*CONSTCOND*/false);
+	}
+}
 /*
  * Called after the entire translation unit has been parsed.
  * Changes tentative definitions into definitions.
  * Performs some tests on global symbols. Detected problems are:
  * - defined variables of incomplete type
  * - constant variables which are not initialized
  * - static symbols which are never used
  */
 void
 check_global_symbols(void)
+{
 	sym_t	*sym;
 	if (block_level != 0 || dcs->d_next != NULL)
 		norecover();
-	for (sym = dcs->d_dlsyms; sym != NULL; sym = sym->s_dlnxt) {
+	for (sym = dcs->d_dlsyms; sym != NULL; sym = sym->s_level_next) {
 		if (sym->s_block_level == -1)
 			continue;
 		if (sym->s_kind == FVFT) {
 			check_global_variable(sym);
 		} else if (sym->s_kind == FTAG) {
 			check_tag_usage(sym);
 		} else {
 			lint_assert(sym->s_kind == FMEMBER);
+		}
+	}
+}
 static void
 check_unused_static_global_variable(const sym_t *sym)
+{
 	if (sym->s_type->t_tspec == FUNC) {
 		if (sym->s_def == DEF) {
 			if (!sym->s_inline)
 				/* static function %s unused */
 				warning_at(236, &sym->s_def_pos, sym->s_name);
 		} else {
 			/* static function %s declared but not defined */
 			warning_at(290, &sym->s_def_pos, sym->s_name);
+		}
 	} else if (!sym->s_set) {
 		/* static variable %s unused */
 		warning_at(226, &sym->s_def_pos, sym->s_name);
 	} else {
 		/* static variable %s set but not used */
 		warning_at(307, &sym->s_def_pos, sym->s_name);
+	}
+}
 static void
 check_static_global_variable(const sym_t *sym)
+{
 	if (sym->s_type->t_tspec == FUNC && sym->s_used && sym->s_def != DEF) {
 		/* static function called but not defined: %s() */
 		error_at(225, &sym->s_use_pos, sym->s_name);
+	}
 	if (!sym->s_used)
 		check_unused_static_global_variable(sym);
 	if (!tflag && sym->s_def == TDEF && sym->s_type->t_const) {
 		/* const object %s should have initializer */
 		warning_at(227, &sym->s_def_pos, sym->s_name);
+	}
+}
 static void
 check_global_variable(const sym_t *sym)
+{
 	if (sym->s_scl == TYPEDEF || sym->s_scl == CTCONST)
 		return;
 	if (sym->s_scl == NOSCL)
 		return;		/* May be caused by a syntax error. */
 	lint_assert(sym->s_scl == EXTERN || sym->s_scl == STATIC);
 	check_global_variable_size(sym);
 	if (sym->s_scl == STATIC)
 		check_static_global_variable(sym);
+}
 static void
 check_global_variable_size(const sym_t *sym)
+{
 	pos_t cpos;
 	int length_in_bits;
 	if (sym->s_def != TDEF)
 		return;
 	if (sym->s_type->t_tspec == FUNC)
 		/*
 		 * this can happen if a syntax error occurred after a
 		 * function declaration
 		 */
 		return;
 	if (sym->s_def == TDEF && sym->s_type->t_tspec == VOID)
 		return;		/* prevent internal error in length() below */
 	cpos = curr_pos;
 	curr_pos = sym->s_def_pos;
 	length_in_bits = length(sym->s_type, sym->s_name);
 	curr_pos = cpos;
 	if (length_in_bits == 0 &&
 	    sym->s_type->t_tspec == ARRAY && sym->s_type->t_dim == 0) {
 		if (tflag || (sym->s_scl == EXTERN && !sflag)) {
 			/* empty array declaration: %s */
 			warning_at(190, &sym->s_def_pos, sym->s_name);
 		} else {
 			/* empty array declaration: %s */
 			error_at(190, &sym->s_def_pos, sym->s_name);
+		}
+	}
+}
 /*
  * Prints information about location of previous definition/declaration.
  */
 void
 print_previous_declaration(int msg, const sym_t *psym)
+{
 	if (!rflag)
 		return;
 	if (msg != -1) {
 		(message_at)(msg, &psym->s_def_pos);
 	} else if (psym->s_def == DEF || psym->s_def == TDEF) {
 		/* previous definition of %s */
 		message_at(261, &psym->s_def_pos, psym->s_name);
 	} else {
 		/* previous declaration of %s */
 		message_at(260, &psym->s_def_pos, psym->s_name);
+	}
+}
 /*
  * Gets a node for a constant and returns the value of this constant
  * as integer.
+ *
  * If the node is not constant or too large for int or of type float,
  * a warning will be printed.
+ *
  * to_int_constant() should be used only inside declarations. If it is used in
  * expressions, it frees the memory used for the expression.
  */
 int
 to_int_constant(tnode_t *tn, bool required)
+{
 	int	i;
 	tspec_t	t;
 	val_t	*v;
 	v = constant(tn, required);
 	if (tn == NULL) {
 		i = 1;
 		goto done;
+	}
 	/*
 	 * Abstract declarations are used inside expression. To free
 	 * the memory would be a fatal error.
 	 * We don't free blocks that are inside casts because these
 	 * will be used later to match types.
 	 */
 	if (tn->tn_op != CON && dcs->d_ctx != ABSTRACT)
 		expr_free_all();
 	if ((t = v->v_tspec) == FLOAT || t == DOUBLE || t == LDOUBLE) {
 		i = (int)v->v_ldbl;
 		/* integral constant expression expected */
 		error(55);
 	} else {
 		i = (int)v->v_quad;
 		if (is_uinteger(t)) {
 			if ((uint64_t)v->v_quad > (uint64_t)TARG_INT_MAX) {
 				/* integral constant too large */
 				warning(56);
+			}
 		} else {
 			if (v->v_quad > (int64_t)TARG_INT_MAX ||
 			    v->v_quad < (int64_t)TARG_INT_MIN) {
 				/* integral constant too large */
 				warning(56);
+			}
+		}
+	}
 done:
 	free(v);
 	return i;
+}

 @@ -1,1237 +1,1238 @@
-/*	$NetBSD: func.c,v 1.127 2022/02/27 08:31:26 rillig Exp $	*/
+/*	$NetBSD: func.c,v 1.128 2022/02/27 10:44:45 rillig Exp $	*/
 /*
  * 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: func.c,v 1.127 2022/02/27 08:31:26 rillig Exp $");
+__RCSID("$NetBSD: func.c,v 1.128 2022/02/27 10:44:45 rillig Exp $");
 #endif
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 #include "cgram.h"
 /*
  * Contains a pointer to the symbol table entry of the current function
  * definition.
  */
 sym_t	*funcsym;
 /* Is set as long as a statement can be reached. Must be set at level 0. */
 bool	reached = true;
 /*
  * Is true by default, can be cleared by NOTREACHED.
  * Is reset to true whenever 'reached' changes.
  */
 bool	warn_about_unreachable;
 /*
  * In conjunction with 'reached', controls printing of "fallthrough on ..."
  * warnings.
  * Reset by each statement and set by FALLTHROUGH, switch (switch1())
  * and case (label()).
+ *
  * Control statements if, for, while and switch do not reset seen_fallthrough
  * because this must be done by the controlled statement. At least for if this
  * is important because ** FALLTHROUGH ** after "if (expr) statement" is
  * evaluated before the following token, which causes reduction of above.
  * This means that ** FALLTHROUGH ** after "if ..." would always be ignored.
  */
 bool	seen_fallthrough;
 /* The innermost control statement */
 control_statement *cstmt;
 /*
  * Number of arguments which will be checked for usage in following
  * function definition. -1 stands for all arguments.
+ *
  * The position of the last ARGSUSED comment is stored in argsused_pos.
  */
 int	nargusg = -1;
 pos_t	argsused_pos;
 /*
  * Number of arguments of the following function definition whose types
  * shall be checked by lint2. -1 stands for all arguments.
+ *
  * The position of the last VARARGS comment is stored in vapos.
  */
 int	nvararg = -1;
 pos_t	vapos;
 /*
  * Both printflike_argnum and scanflike_argnum contain the 1-based number
  * of the string argument which shall be used to check the types of remaining
  * arguments (for PRINTFLIKE and SCANFLIKE).
+ *
  * printflike_pos and scanflike_pos are the positions of the last PRINTFLIKE
  * or SCANFLIKE comment.
  */
 int	printflike_argnum = -1;
 int	scanflike_argnum = -1;
 pos_t	printflike_pos;
 pos_t	scanflike_pos;
 /*
  * If both plibflg and llibflg are set, prototypes are written as function
  * definitions to the output file.
  */
 bool	plibflg;
 /*
  * True means that no warnings about constants in conditional
  * context are printed.
  */
 bool	constcond_flag;
 /*
  * llibflg is set if a lint library shall be created. The effect of
  * llibflg is that all defined symbols are treated as used.
  * (The LINTLIBRARY comment also resets vflag.)
  */
 bool	llibflg;
 /*
  * Nonzero if warnings are suppressed by a LINTED directive
  * LWARN_BAD:	error
  * LWARN_ALL:	warnings on
  * LWARN_NONE:	all warnings ignored
  * 0..n: warning n ignored
  */
 int	lwarn = LWARN_ALL;
 /*
  * Whether bitfield type errors are suppressed by a BITFIELDTYPE
  * directive.
  */
 bool	bitfieldtype_ok;
 /*
  * Whether complaints about use of "long long" are suppressed in
  * the next statement or declaration.
  */
 bool	quadflg;
 /*
  * Puts a new element at the top of the stack used for control statements.
  */
 void
 begin_control_statement(control_statement_kind kind)
+{
 	control_statement *cs;
 	cs = xcalloc(1, sizeof(*cs));
 	cs->c_kind = kind;
 	cs->c_surrounding = cstmt;
 	cstmt = cs;
+}
 /*
  * Removes the top element of the stack used for control statements.
  */
 void
 end_control_statement(control_statement_kind kind)
+{
 	control_statement *cs;
 	case_label_t *cl, *next;
 	lint_assert(cstmt != NULL);
 	while (cstmt->c_kind != kind)
 		cstmt = cstmt->c_surrounding;
 	cs = cstmt;
 	cstmt = cs->c_surrounding;
 	for (cl = cs->c_case_labels; cl != NULL; cl = next) {
 		next = cl->cl_next;
 		free(cl);
+	}
 	free(cs->c_switch_type);
 	free(cs);
+}
 static void
 set_reached(bool new_reached)
+{
 	debug_step("%s -> %s",
 	    reached ? "reachable" : "unreachable",
 	    new_reached ? "reachable" : "unreachable");
 	reached = new_reached;
 	warn_about_unreachable = true;
+}
 /*
  * Prints a warning if a statement cannot be reached.
  */
 void
 check_statement_reachable(void)
+{
 	if (!reached && warn_about_unreachable) {
 		/* statement not reached */
 		warning(193);
 		warn_about_unreachable = false;
+	}
+}
 /*
  * Called after a function declaration which introduces a function definition
  * and before an (optional) old style argument declaration list.
+ *
  * Puts all symbols declared in the prototype or in an old style argument
  * list back to the symbol table.
+ *
  * Does the usual checking of storage class, type (return value),
  * redeclaration, etc.
  */
 void
 funcdef(sym_t *fsym)
+{
 	int	n;
 	bool	dowarn;
 	sym_t	*arg, *sym, *rdsym;
 	funcsym = fsym;
 	/*
 	 * Put all symbols declared in the argument list back to the
 	 * symbol table.
 	 */
-	for (sym = dcs->d_func_proto_syms; sym != NULL; sym = sym->s_dlnxt) {
+	for (sym = dcs->d_func_proto_syms; sym != NULL;
 	    sym = sym->s_level_next) {
 		if (sym->s_block_level != -1) {
 			lint_assert(sym->s_block_level == 1);
 			inssym(1, sym);
+		}
+	}
 	/*
 	 * In old_style_function() we did not know whether it is an old
 	 * style function definition or only an old style declaration,
 	 * if there are no arguments inside the argument list ("f()").
 	 */
 	if (!fsym->s_type->t_proto && fsym->s_args == NULL)
 		fsym->s_osdef = true;
 	check_type(fsym);
 	/*
 	 * check_type() checks for almost all possible errors, but not for
 	 * incomplete return values (these are allowed in declarations)
 	 */
 	if (fsym->s_type->t_subt->t_tspec != VOID &&
 	    is_incomplete(fsym->s_type->t_subt)) {
 		/* cannot return incomplete type */
 		error(67);
+	}
 	fsym->s_def = DEF;
 	if (fsym->s_scl == TYPEDEF) {
 		fsym->s_scl = EXTERN;
 		/* illegal storage class */
 		error(8);
+	}
 	if (dcs->d_inline)
 		fsym->s_inline = true;
 	/*
 	 * Arguments in new style function declarations need a name.
 	 * (void is already removed from the list of arguments)
 	 */
 	n = 1;
 	for (arg = fsym->s_type->t_args; arg != NULL; arg = arg->s_next) {
 		if (arg->s_scl == ABSTRACT) {
 			lint_assert(arg->s_name == unnamed);
 			/* formal parameter lacks name: param #%d */
 			error(59, n);
 		} else {
 			lint_assert(arg->s_name != unnamed);
+		}
 		n++;
+	}
 	/*
 	 * We must also remember the position. s_def_pos is overwritten
 	 * if this is an old style definition and we had already a
 	 * prototype.
 	 */
 	dcs->d_func_def_pos = fsym->s_def_pos;
 	if ((rdsym = dcs->d_redeclared_symbol) != NULL) {
 		if (!check_redeclaration(fsym, (dowarn = false, &dowarn))) {
 			/*
 			 * Print nothing if the newly defined function
 			 * is defined in old style. A better warning will
 			 * be printed in check_func_lint_directives().
 			 */
 			if (dowarn && !fsym->s_osdef) {
 				if (sflag)
 					/* redeclaration of %s */
 					error(27, fsym->s_name);
 				else
 					/* redeclaration of %s */
 					warning(27, fsym->s_name);
 				print_previous_declaration(-1, rdsym);
+			}
 			copy_usage_info(fsym, rdsym);
 			/*
 			 * If the old symbol was a prototype and the new
 			 * one is none, overtake the position of the
 			 * declaration of the prototype.
 			 */
 			if (fsym->s_osdef && rdsym->s_type->t_proto)
 				fsym->s_def_pos = rdsym->s_def_pos;
 			complete_type(fsym, rdsym);
 			if (rdsym->s_inline)
 				fsym->s_inline = true;
+		}
 		/* remove the old symbol from the symbol table */
 		rmsym(rdsym);
+	}
 	if (fsym->s_osdef && !fsym->s_type->t_proto) {
 		if (sflag && hflag && strcmp(fsym->s_name, "main") != 0)
 			/* function definition is not a prototype */
 			warning(286);
+	}
 	if (dcs->d_notyp)
 		fsym->s_return_type_implicit_int = true;
 	set_reached(true);
+}
 static void
 check_missing_return_value(void)
+{
 	if (funcsym->s_type->t_subt->t_tspec == VOID)
 		return;
 	if (funcsym->s_return_type_implicit_int)
 		return;
 	/* C99 5.1.2.2.3 "Program termination" p1 */
 	if (Sflag && strcmp(funcsym->s_name, "main") == 0)
 		return;
 	/* function %s falls off bottom without returning value */
 	warning(217, funcsym->s_name);
+}
 /*
  * Called at the end of a function definition.
  */
 void
 funcend(void)
+{
 	sym_t	*arg;
 	int	n;
 	if (reached) {
 		cstmt->c_had_return_noval = true;
 		check_missing_return_value();
+	}
 	/*
 	 * This warning is printed only if the return value was implicitly
 	 * declared to be int. Otherwise the wrong return statement
 	 * has already printed a warning.
 	 */
 	if (cstmt->c_had_return_noval && cstmt->c_had_return_value &&
 	    funcsym->s_return_type_implicit_int)
 		/* function %s has return (e); and return; */
 		warning(216, funcsym->s_name);
 	/* Print warnings for unused arguments */
 	arg = dcs->d_func_args;
 	n = 0;
 	while (arg != NULL && (nargusg == -1 || n < nargusg)) {
 		check_usage_sym(dcs->d_asm, arg);
 		arg = arg->s_next;
 		n++;
+	}
 	nargusg = -1;
 	/*
 	 * write the information about the function definition to the
 	 * output file
 	 * inline functions explicitly declared extern are written as
 	 * declarations only.
 	 */
 	if (dcs->d_scl == EXTERN && funcsym->s_inline) {
 		outsym(funcsym, funcsym->s_scl, DECL);
 	} else {
 		outfdef(funcsym, &dcs->d_func_def_pos,
 		    cstmt->c_had_return_value, funcsym->s_osdef,
 		    dcs->d_func_args);
+	}
 	/* clean up after syntax errors, see test stmt_for.c. */
 	while (dcs->d_next != NULL)
 		dcs = dcs->d_next;
 	/*
 	 * remove all symbols declared during argument declaration from
 	 * the symbol table
 	 */
 	lint_assert(dcs->d_next == NULL);
 	lint_assert(dcs->d_ctx == EXTERN);
 	rmsyms(dcs->d_func_proto_syms);
 	/* must be set on level 0 */
 	set_reached(true);
+}
 void
 named_label(sym_t *sym)
+{
 	if (sym->s_set) {
 		/* label %s redefined */
 		error(194, sym->s_name);
 	} else {
 		mark_as_set(sym);
+	}
 	set_reached(true);
+}
 static void
 check_case_label_bitand(const tnode_t *case_expr, const tnode_t *switch_expr)
+{
 	uint64_t case_value, mask;
 	if (switch_expr->tn_op != BITAND ||
 	    switch_expr->tn_right->tn_op != CON)
 		return;
 	lint_assert(case_expr->tn_op == CON);
 	case_value = case_expr->tn_val->v_quad;
 	mask = switch_expr->tn_right->tn_val->v_quad;
 	if ((case_value & ~mask) != 0) {
 		/* statement not reached */
 		warning(193);
+	}
+}
 static void
 check_case_label_enum(const tnode_t *tn, const control_statement *cs)
+{
 	/* similar to typeok_enum in tree.c */
 	if (!(tn->tn_type->t_is_enum || cs->c_switch_type->t_is_enum))
 		return;
 	if (tn->tn_type->t_is_enum && cs->c_switch_type->t_is_enum &&
 	    tn->tn_type->t_enum == cs->c_switch_type->t_enum)
 		return;
 #if 0 /* not yet ready, see msg_130.c */
 	/* enum type mismatch: '%s' '%s' '%s' */
 	warning(130, type_name(cs->c_switch_type), op_name(EQ),
 	    type_name(tn->tn_type));
 #endif
+}
 static void
 check_case_label(tnode_t *tn, control_statement *cs)
+{
 	case_label_t *cl;
 	val_t	*v;
 	val_t	nv;
 	tspec_t	t;
 	if (cs == NULL) {
 		/* case not in switch */
 		error(195);
 		return;
+	}
 	if (tn != NULL && tn->tn_op != CON) {
 		/* non-constant case expression */
 		error(197);
 		return;
+	}
 	if (tn != NULL && !is_integer(tn->tn_type->t_tspec)) {
 		/* non-integral case expression */
 		error(198);
 		return;
+	}
 	check_case_label_bitand(tn, cs->c_switch_expr);
 	check_case_label_enum(tn, cs);
 	lint_assert(cs->c_switch_type != NULL);
 	if (reached && !seen_fallthrough) {
 		if (hflag)
 			/* fallthrough on case statement */
 			warning(220);
+	}
 	t = tn->tn_type->t_tspec;
 	if (t == LONG || t == ULONG ||
 	    t == QUAD || t == UQUAD) {
 		if (tflag)
 			/* case label must be of type 'int' in traditional C */
 			warning(203);
+	}
 	/*
 	 * get the value of the expression and convert it
 	 * to the type of the switch expression
 	 */
 	v = constant(tn, true);
 	(void)memset(&nv, 0, sizeof(nv));
 	convert_constant(CASE, 0, cs->c_switch_type, &nv, v);
 	free(v);
 	/* look if we had this value already */
 	for (cl = cs->c_case_labels; cl != NULL; cl = cl->cl_next) {
 		if (cl->cl_val.v_quad == nv.v_quad)
 			break;
+	}
 	if (cl != NULL && is_uinteger(nv.v_tspec)) {
 		/* duplicate case in switch: %lu */
 		error(200, (unsigned long)nv.v_quad);
 	} else if (cl != NULL) {
 		/* duplicate case in switch: %ld */
 		error(199, (long)nv.v_quad);
 	} else {
 		check_getopt_case_label(nv.v_quad);
 		/* append the value to the list of case values */
 		cl = xcalloc(1, sizeof(*cl));
 		cl->cl_val = nv;
 		cl->cl_next = cs->c_case_labels;
 		cs->c_case_labels = cl;
+	}
+}
 void
 case_label(tnode_t *tn)
+{
 	control_statement *cs;
 	/* find the innermost switch statement */
 	for (cs = cstmt; cs != NULL && !cs->c_switch; cs = cs->c_surrounding)
 		continue;
 	check_case_label(tn, cs);
 	expr_free_all();
 	set_reached(true);
+}
 void
 default_label(void)
+{
 	control_statement *cs;
 	/* find the innermost switch statement */
 	for (cs = cstmt; cs != NULL && !cs->c_switch; cs = cs->c_surrounding)
 		continue;
 	if (cs == NULL) {
 		/* default outside switch */
 		error(201);
 	} else if (cs->c_default) {
 		/* duplicate default in switch */
 		error(202);
 	} else {
 		if (reached && !seen_fallthrough) {
 			if (hflag)
 				/* fallthrough on default statement */
 				warning(284);
+		}
 		cs->c_default = true;
+	}
 	set_reached(true);
+}
 static tnode_t *
 check_controlling_expression(tnode_t *tn)
+{
 	tn = cconv(tn);
 	if (tn != NULL)
 		tn = promote(NOOP, false, tn);
 	if (tn != NULL && !is_scalar(tn->tn_type->t_tspec)) {
 		/* C99 6.5.15p4 for the ?: operator; see typeok:QUEST */
 		/* C99 6.8.4.1p1 for if statements */
 		/* C99 6.8.5p2 for while, do and for loops */
 		/* controlling expressions must have scalar type */
 		error(204);
 		return NULL;
+	}
 	if (tn != NULL && Tflag && !is_typeok_bool_operand(tn)) {
 		/* controlling expression must be bool, not '%s' */
 		error(333, tspec_name(tn->tn_type->t_tspec));
+	}
 	return tn;
+}
 /*
  * T_IF T_LPAREN expr T_RPAREN
  */
 void
 if1(tnode_t *tn)
+{
 	if (tn != NULL)
 		tn = check_controlling_expression(tn);
 	if (tn != NULL)
 		expr(tn, false, true, false, false);
 	begin_control_statement(CS_IF);
 	if (tn != NULL && tn->tn_op == CON && !tn->tn_system_dependent) {
 		/* XXX: what if inside 'if (0)'? */
 		set_reached(constant_is_nonzero(tn));
 		/* XXX: what about always_else? */
 		cstmt->c_always_then = reached;
+	}
+}
 /*
  * if_without_else
  * if_without_else T_ELSE
  */
 void
 if2(void)
+{
 	cstmt->c_reached_end_of_then = reached;
 	/* XXX: what if inside 'if (0)'? */
 	set_reached(!cstmt->c_always_then);
+}
 /*
  * if_without_else
  * if_without_else T_ELSE statement
  */
 void
 if3(bool els)
+{
 	if (cstmt->c_reached_end_of_then)
 		set_reached(true);
 	else if (cstmt->c_always_then)
 		set_reached(false);
 	else if (!els)
 		set_reached(true);
 	end_control_statement(CS_IF);
+}
 /*
  * T_SWITCH T_LPAREN expr T_RPAREN
  */
 void
 switch1(tnode_t *tn)
+{
 	tspec_t	t;
 	type_t	*tp;
 	if (tn != NULL)
 		tn = cconv(tn);
 	if (tn != NULL)
 		tn = promote(NOOP, false, tn);
 	if (tn != NULL && !is_integer(tn->tn_type->t_tspec)) {
 		/* switch expression must have integral type */
 		error(205);
 		tn = NULL;
+	}
 	if (tn != NULL && tflag) {
 		t = tn->tn_type->t_tspec;
 		if (t == LONG || t == ULONG || t == QUAD || t == UQUAD) {
 			/* switch expression must be of type 'int' in ... */
 			warning(271);
+		}
+	}
 	/*
 	 * Remember the type of the expression. Because it's possible
 	 * that (*tp) is allocated on tree memory, the type must be
 	 * duplicated. This is not too complicated because it is
 	 * only an integer type.
 	 */
 	tp = xcalloc(1, sizeof(*tp));
 	if (tn != NULL) {
 		tp->t_tspec = tn->tn_type->t_tspec;
 		if ((tp->t_is_enum = tn->tn_type->t_is_enum) != false)
 			tp->t_enum = tn->tn_type->t_enum;
 	} else {
 		tp->t_tspec = INT;
+	}
 	/* leak the memory, for check_case_label_bitand */
 	(void)expr_save_memory();
 	check_getopt_begin_switch();
 	expr(tn, true, false, false, false);
 	begin_control_statement(CS_SWITCH);
 	cstmt->c_switch = true;
 	cstmt->c_switch_type = tp;
 	cstmt->c_switch_expr = tn;
 	set_reached(false);
 	seen_fallthrough = true;
+}
 /*
  * switch_expr statement
  */
 void
 switch2(void)
+{
 	int	nenum = 0, nclab = 0;
 	sym_t	*esym;
 	case_label_t *cl;
 	lint_assert(cstmt->c_switch_type != NULL);
 	if (cstmt->c_switch_type->t_is_enum) {
 		/*
 		 * Warn if the number of case labels is different from the
 		 * number of enumerators.
 		 */
 		nenum = nclab = 0;
 		lint_assert(cstmt->c_switch_type->t_enum != NULL);
 		for (esym = cstmt->c_switch_type->t_enum->en_first_enumerator;
 		     esym != NULL; esym = esym->s_next) {
 			nenum++;
+		}
 		for (cl = cstmt->c_case_labels; cl != NULL; cl = cl->cl_next)
 			nclab++;
 		if (hflag && eflag && nenum != nclab && !cstmt->c_default) {
 			/* enumeration value(s) not handled in switch */
 			warning(206);
+		}
+	}
 	check_getopt_end_switch();
 	if (cstmt->c_break) {
 		/*
 		 * The end of the switch statement is always reached since
 		 * c_break is only set if a break statement can actually
 		 * be reached.
 		 */
 		set_reached(true);
 	} else if (cstmt->c_default ||
 		   (hflag && cstmt->c_switch_type->t_is_enum &&
 		    nenum == nclab)) {
 		/*
 		 * The end of the switch statement is reached if the end
 		 * of the last statement inside it is reached.
 		 */
 	} else {
 		/*
 		 * There are possible values that are not handled in the
 		 * switch statement.
 		 */
 		set_reached(true);
+	}
 	end_control_statement(CS_SWITCH);
+}
 /*
  * T_WHILE T_LPAREN expr T_RPAREN
  */
 void
 while1(tnode_t *tn)
+{
 	bool body_reached;
 	if (!reached) {
 		/* loop not entered at top */
 		warning(207);
 		/* FIXME: that's plain wrong. */
 		set_reached(true);
+	}
 	if (tn != NULL)
 		tn = check_controlling_expression(tn);
 	begin_control_statement(CS_WHILE);
 	cstmt->c_loop = true;
 	cstmt->c_maybe_endless = is_nonzero(tn);
 	body_reached = !is_zero(tn);
 	check_getopt_begin_while(tn);
 	expr(tn, false, true, true, false);
 	set_reached(body_reached);
+}
 /*
  * while_expr statement
  * while_expr error
  */
 void
 while2(void)
+{
 	/*
 	 * The end of the loop can be reached if it is no endless loop
 	 * or there was a break statement which was reached.
 	 */
 	set_reached(!cstmt->c_maybe_endless || cstmt->c_break);
 	check_getopt_end_while();
 	end_control_statement(CS_WHILE);
+}
 /*
  * T_DO
  */
 void
 do1(void)
+{
 	if (!reached) {
 		/* loop not entered at top */
 		warning(207);
 		set_reached(true);
+	}
 	begin_control_statement(CS_DO_WHILE);
 	cstmt->c_loop = true;
+}
 /*
  * do statement do_while_expr
  * do error
  */
 void
 do2(tnode_t *tn)
+{
 	/*
 	 * If there was a continue statement, the expression controlling the
 	 * loop is reached.
 	 */
 	if (cstmt->c_continue)
 		set_reached(true);
 	if (tn != NULL)
 		tn = check_controlling_expression(tn);
 	if (tn != NULL && tn->tn_op == CON) {
 		cstmt->c_maybe_endless = constant_is_nonzero(tn);
 		if (!cstmt->c_maybe_endless && cstmt->c_continue)
 			/* continue in 'do ... while (0)' loop */
 			error(323);
+	}
 	expr(tn, false, true, true, true);
 	if (cstmt->c_maybe_endless)
 		set_reached(false);
 	if (cstmt->c_break)
 		set_reached(true);
 	end_control_statement(CS_DO_WHILE);
+}
 /*
  * T_FOR T_LPAREN opt_expr T_SEMI opt_expr T_SEMI opt_expr T_RPAREN
  */
 void
 for1(tnode_t *tn1, tnode_t *tn2, tnode_t *tn3)
+{
 	/*
 	 * If there is no initialization expression it is possible that
 	 * it is intended not to enter the loop at top.
 	 */
 	if (tn1 != NULL && !reached) {
 		/* loop not entered at top */
 		warning(207);
 		set_reached(true);
+	}
 	begin_control_statement(CS_FOR);
 	cstmt->c_loop = true;
 	/*
 	 * Store the tree memory for the reinitialization expression.
 	 * Also remember this expression itself. We must check it at
 	 * the end of the loop to get "used but not set" warnings correct.
 	 */
 	cstmt->c_for_expr3_mem = expr_save_memory();
 	cstmt->c_for_expr3 = tn3;
 	cstmt->c_for_expr3_pos = curr_pos;
 	cstmt->c_for_expr3_csrc_pos = csrc_pos;
 	if (tn1 != NULL)
 		expr(tn1, false, false, true, false);
 	if (tn2 != NULL)
 		tn2 = check_controlling_expression(tn2);
 	if (tn2 != NULL)
 		expr(tn2, false, true, true, false);
 	cstmt->c_maybe_endless = tn2 == NULL || is_nonzero(tn2);
 	/* Checking the reinitialization expression is done in for2() */
 	set_reached(!is_zero(tn2));
+}
 /*
  * for_exprs statement
  * for_exprs error
  */
 void
 for2(void)
+{
 	pos_t	cpos, cspos;
 	tnode_t	*tn3;
 	if (cstmt->c_continue)
 		set_reached(true);
 	cpos = curr_pos;
 	cspos = csrc_pos;
 	/* Restore the tree memory for the reinitialization expression */
 	expr_restore_memory(cstmt->c_for_expr3_mem);
 	tn3 = cstmt->c_for_expr3;
 	curr_pos = cstmt->c_for_expr3_pos;
 	csrc_pos = cstmt->c_for_expr3_csrc_pos;
 	/* simply "statement not reached" would be confusing */
 	if (!reached && warn_about_unreachable) {
 		/* end-of-loop code not reached */
 		warning(223);
 		set_reached(true);
+	}
 	if (tn3 != NULL) {
 		expr(tn3, false, false, true, false);
 	} else {
 		expr_free_all();
+	}
 	curr_pos = cpos;
 	csrc_pos = cspos;
 	/* An endless loop without break will never terminate */
 	/* TODO: What if the loop contains a 'return'? */
 	set_reached(cstmt->c_break || !cstmt->c_maybe_endless);
 	end_control_statement(CS_FOR);
+}
 /*
  * T_GOTO identifier T_SEMI
  */
 void
 do_goto(sym_t *lab)
+{
 	mark_as_used(lab, false, false);
 	check_statement_reachable();
 	set_reached(false);
+}
 /*
  * T_BREAK T_SEMI
  */
 void
 do_break(void)
+{
 	control_statement *cs;
 	cs = cstmt;
 	while (cs != NULL && !cs->c_loop && !cs->c_switch)
 		cs = cs->c_surrounding;
 	if (cs == NULL) {
 		/* break outside loop or switch */
 		error(208);
 	} else {
 		if (reached)
 			cs->c_break = true;
+	}
 	if (bflag)
 		check_statement_reachable();
 	set_reached(false);
+}
 /*
  * T_CONTINUE T_SEMI
  */
 void
 do_continue(void)
+{
 	control_statement *cs;
 	for (cs = cstmt; cs != NULL && !cs->c_loop; cs = cs->c_surrounding)
 		continue;
 	if (cs == NULL) {
 		/* continue outside loop */
 		error(209);
 	} else {
 		/* TODO: only if reachable, for symmetry with c_break */
 		cs->c_continue = true;
+	}
 	check_statement_reachable();
 	set_reached(false);
+}
 /*
  * T_RETURN T_SEMI
  * T_RETURN expr T_SEMI
  */
 void
 do_return(bool sys, tnode_t *tn)
+{
 	tnode_t	*ln, *rn;
 	control_statement *cs;
 	op_t	op;
 	cs = cstmt;
 	if (cs == NULL) {
 		/* syntax error '%s' */
 		error(249, "return outside function");
 		return;
+	}
 	for (; cs->c_surrounding != NULL; cs = cs->c_surrounding)
 		continue;
 	if (tn != NULL)
 		cs->c_had_return_value = true;
 	else
 		cs->c_had_return_noval = true;
 	if (tn != NULL && funcsym->s_type->t_subt->t_tspec == VOID) {
 		/* void function %s cannot return value */
 		error(213, funcsym->s_name);
 		expr_free_all();
 		tn = NULL;
 	} else if (tn == NULL && funcsym->s_type->t_subt->t_tspec != VOID) {
 		/*
 		 * Assume that the function has a return value only if it
 		 * is explicitly declared.
 		 */
 		if (!funcsym->s_return_type_implicit_int)
 			/* function '%s' expects to return value */
 			warning(214, funcsym->s_name);
+	}
 	if (tn != NULL) {
 		/* Create a temporary node for the left side */
 		ln = expr_zero_alloc(sizeof(*ln));
 		ln->tn_op = NAME;
 		ln->tn_type = expr_unqualified_type(funcsym->s_type->t_subt);
 		ln->tn_lvalue = true;
 		ln->tn_sym = funcsym;		/* better than nothing */
 		tn = build_binary(ln, RETURN, sys, tn);
 		if (tn != NULL) {
 			rn = tn->tn_right;
 			while ((op = rn->tn_op) == CVT || op == PLUS)
 				rn = rn->tn_left;
 			if (rn->tn_op == ADDR && rn->tn_left->tn_op == NAME &&
 			    rn->tn_left->tn_sym->s_scl == AUTO) {
 				/* %s returns pointer to automatic object */
 				warning(302, funcsym->s_name);
+			}
+		}
 		expr(tn, true, false, true, false);
 	} else {
 		check_statement_reachable();
+	}
 	set_reached(false);
+}
 /*
  * Do some cleanup after a global declaration or definition.
  * Especially remove information about unused lint comments.
  */
 void
 global_clean_up_decl(bool silent)
+{
 	if (nargusg != -1) {
 		if (!silent) {
 			/* must precede function definition: ** %s ** */
 			warning_at(282, &argsused_pos, "ARGSUSED");
+		}
 		nargusg = -1;
+	}
 	if (nvararg != -1) {
 		if (!silent) {
 			/* must precede function definition: ** %s ** */
 			warning_at(282, &vapos, "VARARGS");
+		}
 		nvararg = -1;
+	}
 	if (printflike_argnum != -1) {
 		if (!silent) {
 			/* must precede function definition: ** %s ** */
 			warning_at(282, &printflike_pos, "PRINTFLIKE");
+		}
 		printflike_argnum = -1;
+	}
 	if (scanflike_argnum != -1) {
 		if (!silent) {
 			/* must precede function definition: ** %s ** */
 			warning_at(282, &scanflike_pos, "SCANFLIKE");
+		}
 		scanflike_argnum = -1;
+	}
 	dcs->d_asm = false;
 	/*
 	 * Needed for BSD yacc in case of parse errors; GNU Bison 3.0.4 is
 	 * fine.  See test gcc_attribute.c, function_with_unknown_attribute.
 	 */
 	in_gcc_attribute = false;
+}
 /*
  * ARGSUSED comment
+ *
  * Only the first n arguments of the following function are checked
  * for usage. A missing argument is taken to be 0.
  */
 void
 argsused(int n)
+{
 	if (n == -1)
 		n = 0;
 	if (dcs->d_ctx != EXTERN) {
 		/* must be outside function: ** %s ** */
 		warning(280, "ARGSUSED");
 		return;
+	}
 	if (nargusg != -1) {
 		/* duplicate use of ** %s ** */
 		warning(281, "ARGSUSED");
+	}
 	nargusg = n;
 	argsused_pos = curr_pos;
+}
 /*
  * VARARGS comment
+ *
  * Causes lint2 to check only the first n arguments for compatibility
  * with the function definition. A missing argument is taken to be 0.
  */
 void
 varargs(int n)
+{
 	if (n == -1)
 		n = 0;
 	if (dcs->d_ctx != EXTERN) {
 		/* must be outside function: ** %s ** */
 		warning(280, "VARARGS");
 		return;
+	}
 	if (nvararg != -1) {
 		/* duplicate use of ** %s ** */
 		warning(281, "VARARGS");
+	}
 	nvararg = n;
 	vapos = curr_pos;
+}
 /*
  * PRINTFLIKE comment
+ *
  * Check all arguments until the (n-1)-th as usual. The n-th argument is
  * used the check the types of remaining arguments.
  */
 void
 printflike(int n)
+{
 	if (n == -1)
 		n = 0;
 	if (dcs->d_ctx != EXTERN) {
 		/* must be outside function: ** %s ** */
 		warning(280, "PRINTFLIKE");
 		return;
+	}
 	if (printflike_argnum != -1) {
 		/* duplicate use of ** %s ** */
 		warning(281, "PRINTFLIKE");

 @@ -1,1542 +1,1542 @@
-/* $NetBSD: lex.c,v 1.101 2022/02/27 08:31:26 rillig Exp $ */
+/* $NetBSD: lex.c,v 1.102 2022/02/27 10:44:45 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: lex.c,v 1.101 2022/02/27 08:31:26 rillig Exp $");
+__RCSID("$NetBSD: lex.c,v 1.102 2022/02/27 10:44:45 rillig Exp $");
 #endif
 #include <ctype.h>
 #include <errno.h>
 #include <float.h>
 #include <limits.h>
 #include <math.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 #include "cgram.h"
 #define CHAR_MASK	((1U << CHAR_SIZE) - 1)
 /* Current position (it's also updated when an included file is parsed) */
 pos_t	curr_pos = { "", 1, 0 };
 /*
  * Current position in C source (not updated when an included file is
  * parsed).
  */
 pos_t	csrc_pos = { "", 1, 0 };
 bool in_gcc_attribute;
 bool in_system_header;
 static	int	inpc(void);
 static	unsigned int hash(const char *);
 static	sym_t *	search(sbuf_t *);
 static	int	keyw(sym_t *);
 static	int	get_escaped_char(int);
 void
 lex_next_line(void)
+{
 	curr_pos.p_line++;
 	curr_pos.p_uniq = 0;
 	debug_step("parsing %s:%d", curr_pos.p_file, curr_pos.p_line);
 	if (curr_pos.p_file == csrc_pos.p_file) {
 		csrc_pos.p_line++;
 		csrc_pos.p_uniq = 0;
+	}
+}
 void
 lex_unknown_character(int c)
+{
 	/* unknown character \%o */
 	error(250, c);
+}
 #define kwdef(name, token, scl, tspec, tqual,	c90, c99, gcc, attr, deco) \
 	{ \
 		name, token, scl, tspec, tqual, \
 		(c90) > 0, (c99) > 0, (gcc) > 0, (attr) > 0, \
 		((deco) & 1) != 0, ((deco) & 2) != 0, ((deco) & 4) != 0, \
+	}
 #define kwdef_token(name, token,		c90, c99, gcc, attr, deco) \
 	kwdef(name, token, 0, 0, 0,		c90, c99, gcc, attr, deco)
 #define kwdef_sclass(name, sclass,		c90, c99, gcc, attr, deco) \
 	kwdef(name, T_SCLASS, sclass, 0, 0,	c90, c99, gcc, attr, deco)
 #define kwdef_type(name, tspec,			c90, c99, gcc, attr, deco) \
 	kwdef(name, T_TYPE, 0, tspec, 0,	c90, c99, gcc, attr, deco)
 #define kwdef_tqual(name, tqual,		c90, c99, gcc, attr, deco) \
 	kwdef(name, T_QUAL, 0, 0, tqual,	c90, c99, gcc, attr, deco)
 #define kwdef_keyword(name, token) \
 	kwdef(name, token, 0, 0, 0,		0, 0, 0, 0, 1)
 #define kwdef_gcc_attr(name, token) \
 	kwdef(name, token, 0, 0, 0,		0, 0, 1, 1, 5)
 /* During initialization, these keywords are written to the symbol table. */
 static struct keyword {
 	const	char *kw_name;	/* keyword */
 	int	kw_token;	/* token returned by yylex() */
 	scl_t	kw_scl;		/* storage class if kw_token T_SCLASS */
 	tspec_t	kw_tspec;	/* type spec. if kw_token
 				 * T_TYPE or T_STRUCT_OR_UNION */
 	tqual_t	kw_tqual;	/* type qual. if kw_token T_QUAL */
 	bool	kw_c90:1;	/* C90 keyword */
 	bool	kw_c99:1;	/* C99 keyword */
 	bool	kw_gcc:1;	/* GCC keyword */
 	bool	kw_attr:1;	/* GCC attribute, keyword */
 	bool	kw_plain:1;	/* 'name' */
 	bool	kw_leading:1;	/* '__name' */
 	bool	kw_both:1;	/* '__name__' */
 } keywords[] = {
 	kwdef_gcc_attr(	"alias",	T_AT_ALIAS),
 	kwdef_keyword(	"_Alignas",	T_ALIGNAS),
 	kwdef_keyword(	"_Alignof",	T_ALIGNOF),
 	kwdef_gcc_attr(	"aligned",	T_AT_ALIGNED),
 	kwdef_token(	"__alignof__",	T_ALIGNOF,		0,0,0,0,1),
 	kwdef_gcc_attr(	"alloc_size",	T_AT_ALLOC_SIZE),
 	kwdef_gcc_attr(	"always_inline",T_AT_ALWAYS_INLINE),
 	kwdef_token(	"asm",		T_ASM,			0,0,1,0,7),
 	kwdef_token(	"attribute",	T_ATTRIBUTE,		0,0,1,0,6),
 	kwdef_sclass(	"auto",		AUTO,			0,0,0,0,1),
 	kwdef_type(	"_Bool",	BOOL,			0,1,0,0,1),
 	kwdef_gcc_attr(	"bounded",	T_AT_BOUNDED),
 	kwdef_keyword(	"break",	T_BREAK),
 	kwdef_gcc_attr(	"buffer",	T_AT_BUFFER),
 	kwdef_token(	"__builtin_offsetof", T_BUILTIN_OFFSETOF, 0,0,1,0,1),
 	kwdef_keyword(	"case",		T_CASE),
 	kwdef_type(	"char",		CHAR,			0,0,0,0,1),
 	kwdef_gcc_attr(	"cold",		T_AT_COLD),
 	kwdef_gcc_attr(	"common",	T_AT_COMMON),
 	kwdef_type(	"_Complex",	COMPLEX,		0,1,0,0,1),
 	kwdef_tqual(	"const",	CONST,			1,0,0,0,7),
 	kwdef_gcc_attr(	"constructor",	T_AT_CONSTRUCTOR),
 	kwdef_keyword(	"continue",	T_CONTINUE),
 	kwdef_keyword(	"default",	T_DEFAULT),
 	kwdef_gcc_attr(	"deprecated",	T_AT_DEPRECATED),
 	kwdef_gcc_attr(	"destructor",	T_AT_DESTRUCTOR),
 	kwdef_gcc_attr(	"disable_sanitizer_instrumentation",
 	    T_AT_DISABLE_SANITIZER_INSTRUMENTATION),
 	kwdef_keyword(	"do",		T_DO),
 	kwdef_type(	"double",	DOUBLE,			0,0,0,0,1),
 	kwdef_keyword(	"else",		T_ELSE),
 	kwdef_keyword(	"enum",		T_ENUM),
 	kwdef_token(	"__extension__",T_EXTENSION,		0,0,1,0,1),
 	kwdef_sclass(	"extern",	EXTERN,			0,0,0,0,1),
 	kwdef_gcc_attr(	"fallthrough",	T_AT_FALLTHROUGH),
 	kwdef_type(	"float",	FLOAT,			0,0,0,0,1),
 	kwdef_keyword(	"for",		T_FOR),
 	kwdef_gcc_attr(	"format",	T_AT_FORMAT),
 	kwdef_gcc_attr(	"format_arg",	T_AT_FORMAT_ARG),
 	kwdef_token(	"_Generic",	T_GENERIC,		0,1,0,0,1),
 	kwdef_gcc_attr(	"gnu_inline",	T_AT_GNU_INLINE),
 	kwdef_gcc_attr(	"gnu_printf",	T_AT_FORMAT_GNU_PRINTF),
 	kwdef_keyword(	"goto",		T_GOTO),
 	kwdef_gcc_attr(	"hot",		T_AT_HOT),
 	kwdef_keyword(	"if",		T_IF),
 	kwdef_token(	"__imag__",	T_IMAG,			0,0,1,0,1),
 	kwdef_sclass(	"inline",	INLINE,			0,1,0,0,7),
 	kwdef_type(	"int",		INT,			0,0,0,0,1),
 #ifdef INT128_SIZE
 	kwdef_type(	"__int128_t",	INT128,			0,1,0,0,1),
 #endif
 	kwdef_type(	"long",		LONG,			0,0,0,0,1),
 	kwdef_gcc_attr(	"malloc",	T_AT_MALLOC),
 	kwdef_gcc_attr(	"may_alias",	T_AT_MAY_ALIAS),
 	kwdef_gcc_attr(	"minbytes",	T_AT_MINBYTES),
 	kwdef_gcc_attr(	"mode",		T_AT_MODE),
 	kwdef_gcc_attr("no_instrument_function",
 					T_AT_NO_INSTRUMENT_FUNCTION),
 	kwdef_gcc_attr(	"no_sanitize",	T_AT_NO_SANITIZE),
 	kwdef_gcc_attr(	"no_sanitize_thread",	T_AT_NO_SANITIZE_THREAD),
 	kwdef_gcc_attr(	"noinline",	T_AT_NOINLINE),
 	kwdef_gcc_attr(	"nonnull",	T_AT_NONNULL),
 	kwdef_gcc_attr(	"nonstring",	T_AT_NONSTRING),
 	kwdef_token(	"_Noreturn",	T_NORETURN,		0,1,0,0,1),
 	kwdef_gcc_attr(	"noreturn",	T_AT_NORETURN),
 	kwdef_gcc_attr(	"nothrow",	T_AT_NOTHROW),
 	kwdef_gcc_attr(	"optimize",	T_AT_OPTIMIZE),
 	kwdef_gcc_attr(	"optnone",	T_AT_OPTNONE),
 	kwdef_gcc_attr(	"packed",	T_AT_PACKED),
 	kwdef_token(	"__packed",	T_PACKED,		0,0,0,0,1),
 	kwdef_gcc_attr(	"pcs",		T_AT_PCS),
 	kwdef_gcc_attr(	"printf",	T_AT_FORMAT_PRINTF),
 	kwdef_gcc_attr(	"pure",		T_AT_PURE),
 	kwdef_token(	"__real__",	T_REAL,			0,0,1,0,1),
 	kwdef_sclass(	"register",	REG,			0,0,0,0,1),
 	kwdef_gcc_attr(	"regparm",	T_AT_REGPARM),
 	kwdef_tqual(	"restrict",	RESTRICT,		0,1,0,0,7),
 	kwdef_keyword(	"return",	T_RETURN),
 	kwdef_gcc_attr(	"returns_nonnull",T_AT_RETURNS_NONNULL),
 	kwdef_gcc_attr(	"returns_twice",T_AT_RETURNS_TWICE),
 	kwdef_gcc_attr(	"scanf",	T_AT_FORMAT_SCANF),
 	kwdef_token(	"section",	T_AT_SECTION,		0,0,1,1,7),
 	kwdef_gcc_attr(	"sentinel",	T_AT_SENTINEL),
 	kwdef_type(	"short",	SHORT,			0,0,0,0,1),
 	kwdef_type(	"signed",	SIGNED,			1,0,0,0,3),
 	kwdef_keyword(	"sizeof",	T_SIZEOF),
 	kwdef_sclass(	"static",	STATIC,			0,0,0,0,1),
 	kwdef_keyword(	"_Static_assert",	T_STATIC_ASSERT),
 	kwdef_gcc_attr(	"strfmon",	T_AT_FORMAT_STRFMON),
 	kwdef_gcc_attr(	"strftime",	T_AT_FORMAT_STRFTIME),
 	kwdef_gcc_attr(	"string",	T_AT_STRING),
 	kwdef("struct",	T_STRUCT_OR_UNION, 0,	STRUCT,	0,	0,0,0,0,1),
 	kwdef_keyword(	"switch",	T_SWITCH),
 	kwdef_token(	"__symbolrename",	T_SYMBOLRENAME,	0,0,0,0,1),
 	kwdef_gcc_attr(	"syslog",	T_AT_FORMAT_SYSLOG),
 	kwdef_gcc_attr(	"target",	T_AT_TARGET),
 	kwdef_tqual(	"__thread",	THREAD,			0,0,1,0,1),
 	kwdef_tqual(	"_Thread_local", THREAD,		0,1,0,0,1),
 	kwdef_gcc_attr(	"tls_model",	T_AT_TLS_MODEL),
 	kwdef_gcc_attr(	"transparent_union", T_AT_TUNION),
 	kwdef_sclass(	"typedef",	TYPEDEF,		0,0,0,0,1),
 	kwdef_token(	"typeof",	T_TYPEOF,		0,0,1,0,7),
 #ifdef INT128_SIZE
 	kwdef_type(	"__uint128_t",	UINT128,		0,1,0,0,1),
 #endif
 	kwdef("union",	T_STRUCT_OR_UNION, 0,	UNION,	0,	0,0,0,0,1),
 	kwdef_type(	"unsigned",	UNSIGN,			0,0,0,0,1),
 	kwdef_gcc_attr(	"unused",	T_AT_UNUSED),
 	kwdef_gcc_attr(	"used",		T_AT_USED),
 	kwdef_gcc_attr(	"visibility",	T_AT_VISIBILITY),
 	kwdef_type(	"void",		VOID,			0,0,0,0,1),
 	kwdef_tqual(	"volatile",	VOLATILE,		1,0,0,0,7),
 	kwdef_gcc_attr(	"warn_unused_result", T_AT_WARN_UNUSED_RESULT),
 	kwdef_gcc_attr(	"weak",		T_AT_WEAK),
 	kwdef_keyword(	"while",	T_WHILE),
 	kwdef(NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0),
 #undef kwdef
 #undef kwdef_token
 #undef kwdef_sclass
 #undef kwdef_type
 #undef kwdef_tqual
 #undef kwdef_keyword
 #undef kwdef_gcc_attr
 };
 /* Symbol table */
 static	sym_t	*symtab[HSHSIZ1];
 /* type of next expected symbol */
 symt_t	symtyp;
 static void
 symtab_add(sym_t *sym)
+{
 	size_t h;
 	h = hash(sym->s_name);
-	if ((sym->s_link = symtab[h]) != NULL)
+	if ((sym->s_symtab_next = symtab[h]) != NULL)
-		symtab[h]->s_rlink = &sym->s_link;
+		symtab[h]->s_symtab_ref = &sym->s_symtab_next;
-	sym->s_rlink = &symtab[h];
+	sym->s_symtab_ref = &symtab[h];
 	symtab[h] = sym;
+}
 static void
 symtab_remove(sym_t *sym)
+{
-	if ((*sym->s_rlink = sym->s_link) != NULL)
+	if ((*sym->s_symtab_ref = sym->s_symtab_next) != NULL)
-		sym->s_link->s_rlink = sym->s_rlink;
+		sym->s_symtab_next->s_symtab_ref = sym->s_symtab_ref;
-	sym->s_link = NULL;
+	sym->s_symtab_next = NULL;
+}
 static void
 add_keyword(const struct keyword *kw, bool leading, bool trailing)
+{
 	sym_t *sym;
 	char buf[256];
 	const char *name;
 	if (!leading && !trailing) {
 		name = kw->kw_name;
 	} else {
 		(void)snprintf(buf, sizeof(buf), "%s%s%s",
 		    leading ? "__" : "", kw->kw_name, trailing ? "__" : "");
 		name = xstrdup(buf);
+	}
 	sym = block_zero_alloc(sizeof(*sym));
 	sym->s_name = name;
 	sym->s_keyword = kw;
 	sym->s_value.v_quad = kw->kw_token;
 	if (kw->kw_token == T_TYPE || kw->kw_token == T_STRUCT_OR_UNION) {
 		sym->s_tspec = kw->kw_tspec;
 	} else if (kw->kw_token == T_SCLASS) {
 		sym->s_scl = kw->kw_scl;
 	} else if (kw->kw_token == T_QUAL) {
 		sym->s_tqual = kw->kw_tqual;
+	}
 	symtab_add(sym);
+}
 /*
  * All keywords are written to the symbol table. This saves us looking
  * in an extra table for each name we found.
  */
 void
 initscan(void)
+{
 	struct keyword *kw;
 	for (kw = keywords; kw->kw_name != NULL; kw++) {
 		if ((kw->kw_c90 || kw->kw_c99) && tflag)
 			continue;
 		if (kw->kw_c99 && !(Sflag || gflag))
 			continue;
 		if (kw->kw_gcc && !gflag)
 			continue;
 		if (kw->kw_plain)
 			add_keyword(kw, false, false);
 		if (kw->kw_leading)
 			add_keyword(kw, true, false);
 		if (kw->kw_both)
 			add_keyword(kw, true, true);
+	}
+}
 /*
  * Read a character and ensure that it is positive (except EOF).
  * Increment line count(s) if necessary.
  */
 static int
 inpc(void)
+{
 	int	c;
 	if ((c = lex_input()) == EOF)
 		return c;
 	c &= CHAR_MASK;
 	if (c == '\0')
 		return EOF;	/* lex returns 0 on EOF. */
 	if (c == '\n')
 		lex_next_line();
 	return c;
+}
 static unsigned int
 hash(const char *s)
+{
 	unsigned int v;
 	const char *p;
 	v = 0;
 	for (p = s; *p != '\0'; p++) {
 		v = (v << 4) + (unsigned char)*p;
 		v ^= v >> 28;
+	}
 	return v % HSHSIZ1;
+}
 /*
  * Lex has found a letter followed by zero or more letters or digits.
  * It looks for a symbol in the symbol table with the same name. This
  * symbol must either be a keyword or a symbol of the type required by
  * symtyp (label, member, tag, ...).
+ *
  * If it is a keyword, the token is returned. In some cases it is described
  * more deeply by data written to yylval.
+ *
  * If it is a symbol, T_NAME is returned and the name is stored in yylval.
  * If there is already a symbol of the same name and type in the symbol
  * table, yylval.y_name->sb_sym points there.
  */
 extern int
 lex_name(const char *yytext, size_t yyleng)
+{
 	char	*s;
 	sbuf_t	*sb;
 	sym_t	*sym;
 	int	tok;
 	sb = xmalloc(sizeof(*sb));
 	sb->sb_name = yytext;
 	sb->sb_len = yyleng;
 	if ((sym = search(sb)) != NULL && sym->s_keyword != NULL) {
 		free(sb);
 		return keyw(sym);
+	}
 	sb->sb_sym = sym;
 	if (sym != NULL) {
 		lint_assert(block_level >= sym->s_block_level);
 		sb->sb_name = sym->s_name;
 		sb->sb_len = strlen(sym->s_name);
 		tok = sym->s_scl == TYPEDEF ? T_TYPENAME : T_NAME;
 	} else {
 		s = block_zero_alloc(yyleng + 1);
 		(void)memcpy(s, yytext, yyleng + 1);
 		sb->sb_name = s;
 		sb->sb_len = yyleng;
 		tok = T_NAME;
+	}
 	yylval.y_name = sb;
 	return tok;
+}
 static sym_t *
 search(sbuf_t *sb)
+{
 	unsigned int h;
 	sym_t *sym;
 	const struct keyword *kw;
 	h = hash(sb->sb_name);
-	for (sym = symtab[h]; sym != NULL; sym = sym->s_link) {
+	for (sym = symtab[h]; sym != NULL; sym = sym->s_symtab_next) {
 		if (strcmp(sym->s_name, sb->sb_name) != 0)
 			continue;
 		kw = sym->s_keyword;
 		if (kw != NULL && !kw->kw_attr)
 			return sym;
 		if (kw != NULL && in_gcc_attribute)
 			return sym;
 		if (kw == NULL && !in_gcc_attribute && sym->s_kind == symtyp)
 			return sym;
+	}
 	return NULL;
+}
 static int
 keyw(sym_t *sym)
+{
 	int	t;
 	if ((t = (int)sym->s_value.v_quad) == T_SCLASS) {
 		yylval.y_scl = sym->s_scl;
 	} else if (t == T_TYPE || t == T_STRUCT_OR_UNION) {
 		yylval.y_tspec = sym->s_tspec;
 	} else if (t == T_QUAL) {
 		yylval.y_tqual = sym->s_tqual;
+	}
 	return t;
+}
 /*
  * Convert a string representing an integer into internal representation.
  * Return T_CON, storing the numeric value in yylval, for yylex.
  */
 int
 lex_integer_constant(const char *yytext, size_t yyleng, int base)
+{
 	int	l_suffix, u_suffix;
 	size_t	len;
 	const	char *cp;
 	char	c, *eptr;
 	tspec_t	typ;
 	bool	ansiu;
 	bool	warned = false;
 	uint64_t uq = 0;
 	/* C11 6.4.4.1p5 */
 	static const tspec_t suffix_type[2][3] = {
 		{ INT,  LONG,  QUAD, },
 		{ UINT, ULONG, UQUAD, }
 	};
 	cp = yytext;
 	len = yyleng;
 	/* skip 0[xX] or 0[bB] */
 	if (base == 16 || base == 2) {
 		cp += 2;
 		len -= 2;
+	}
 	/* read suffixes */
 	l_suffix = u_suffix = 0;
 	for (;;) {
 		if ((c = cp[len - 1]) == 'l' || c == 'L') {
 			l_suffix++;
 		} else if (c == 'u' || c == 'U') {
 			u_suffix++;
 		} else {
 			break;
+		}
 		len--;
+	}
 	if (l_suffix > 2 || u_suffix > 1) {
 		/* malformed integer constant */
 		warning(251);
 		if (l_suffix > 2)
 			l_suffix = 2;
 		if (u_suffix > 1)
 			u_suffix = 1;
+	}
 	if (tflag && u_suffix != 0) {
 		/* suffix U is illegal in traditional C */
 		warning(97);
+	}
 	typ = suffix_type[u_suffix][l_suffix];
 	errno = 0;
 	uq = (uint64_t)strtoull(cp, &eptr, base);
 	lint_assert(eptr == cp + len);
 	if (errno != 0) {
 		/* integer constant out of range */
 		warning(252);
 		warned = true;
+	}
 	/*
 	 * If the value is too big for the current type, we must choose
 	 * another type.
 	 */
 	ansiu = false;
 	switch (typ) {
 	case INT:
 		if (uq <= TARG_INT_MAX) {
 			/* ok */
 		} else if (uq <= TARG_UINT_MAX && base != 10) {
 			typ = UINT;
 		} else if (uq <= TARG_LONG_MAX) {
 			typ = LONG;
 		} else {
 			typ = ULONG;
 			if (uq > TARG_ULONG_MAX && !warned) {
 				/* integer constant out of range */
 				warning(252);
+			}
+		}
 		if (typ == UINT || typ == ULONG) {
 			if (tflag) {
 				typ = LONG;
 			} else if (!sflag) {
 				/*
 				 * Remember that the constant is unsigned
 				 * only in ANSI C
 				 */
 				ansiu = true;
+			}
+		}
 		break;
 	case UINT:
 		if (uq > TARG_UINT_MAX) {
 			typ = ULONG;
 			if (uq > TARG_ULONG_MAX && !warned) {
 				/* integer constant out of range */
 				warning(252);
+			}
+		}
 		break;
 	case LONG:
 		if (uq > TARG_LONG_MAX && !tflag) {
 			typ = ULONG;
 			if (!sflag)
 				ansiu = true;
 			if (uq > TARG_ULONG_MAX && !warned) {
 				/* integer constant out of range */
 				warning(252);
+			}
+		}
 		break;
 	case ULONG:
 		if (uq > TARG_ULONG_MAX && !warned) {
 			/* integer constant out of range */
 			warning(252);
+		}
 		break;
 	case QUAD:
 		if (uq > TARG_QUAD_MAX && !tflag) {
 			typ = UQUAD;
 			if (!sflag)
 				ansiu = true;
+		}
 		break;
 	case UQUAD:
 		if (uq > TARG_UQUAD_MAX && !warned) {
 			/* integer constant out of range */
 			warning(252);
+		}
 		break;
 	default:
 		break;
+	}
 	uq = (uint64_t)convert_integer((int64_t)uq, typ, 0);
 	yylval.y_val = xcalloc(1, sizeof(*yylval.y_val));
 	yylval.y_val->v_tspec = typ;
 	yylval.y_val->v_unsigned_since_c90 = ansiu;
 	yylval.y_val->v_quad = (int64_t)uq;
 	return T_CON;
+}
 /*
  * Extend or truncate q to match t.  If t is signed, sign-extend.
+ *
  * len is the number of significant bits. If len is -1, len is set
  * to the width of type t.
  */
 int64_t
 convert_integer(int64_t q, tspec_t t, unsigned int len)
+{
 	uint64_t vbits;
 	if (len == 0)
 		len = size_in_bits(t);
 	vbits = value_bits(len);
 	return t == PTR || is_uinteger(t) || ((q & bit(len - 1)) == 0)
 	    ? (int64_t)(q & vbits)
 	    : (int64_t)(q | ~vbits);
+}
 /*
  * Convert a string representing a floating point value into its numerical
  * representation. Type and value are returned in yylval.
+ *
  * XXX Currently it is not possible to convert constants of type
  * long double which are greater than DBL_MAX.
  */
 int
 lex_floating_constant(const char *yytext, size_t yyleng)
+{
 	const	char *cp;
 	size_t	len;
 	tspec_t typ;
 	char	c, *eptr;
 	double	d;
 	float	f = 0;
 	cp = yytext;
 	len = yyleng;
 	if (cp[len - 1] == 'i')
 		len--;		/* imaginary, do nothing for now */
 	if ((c = cp[len - 1]) == 'f' || c == 'F') {
 		typ = FLOAT;
 		len--;
 	} else if (c == 'l' || c == 'L') {
 		typ = LDOUBLE;
 		len--;
 	} else {
 		if (c == 'd' || c == 'D')
 			len--;
 		typ = DOUBLE;
+	}
 	if (tflag && typ != DOUBLE) {
 		/* suffixes F and L are illegal in traditional C */
 		warning(98);
+	}
 	errno = 0;
 	d = strtod(cp, &eptr);
 	if (eptr != cp + len) {
 		switch (*eptr) {
 			/*
 			 * XXX: non-native non-current strtod() may not handle hex
 			 * floats, ignore the rest if we find traces of hex float
 			 * syntax...
 			 */
 		case 'p':
 		case 'P':
 		case 'x':
 		case 'X':
 			d = 0;
 			errno = 0;
 			break;
 		default:
 			INTERNAL_ERROR("lex_floating_constant(%s->%s)",
 			    cp, eptr);
+		}
+	}
 	if (errno != 0)
 		/* floating-point constant out of range */
 		warning(248);
 	if (typ == FLOAT) {
 		f = (float)d;
 		if (isfinite(f) == 0) {
 			/* floating-point constant out of range */
 			warning(248);
 			f = f > 0 ? FLT_MAX : -FLT_MAX;
+		}
+	}
 	yylval.y_val = xcalloc(1, sizeof(*yylval.y_val));
 	yylval.y_val->v_tspec = typ;
 	if (typ == FLOAT) {
 		yylval.y_val->v_ldbl = f;
 	} else {
 		yylval.y_val->v_ldbl = d;
+	}
 	return T_CON;
+}
 int
 lex_operator(int t, op_t o)
+{
 	yylval.y_op = o;
 	return t;
+}
 /*
  * Called if lex found a leading \'.
  */
 int
 lex_character_constant(void)
+{
 	size_t	n;
 	int val, c;
 	n = 0;
 	val = 0;
 	while ((c = get_escaped_char('\'')) >= 0) {
 		val = (val << CHAR_SIZE) + c;
 		n++;
+	}
 	if (c == -2) {
 		/* unterminated character constant */
 		error(253);
 	} else if (n > sizeof(int) || (n > 1 && (pflag || hflag))) {
 		/* XXX: should rather be sizeof(TARG_INT) */
 		/* too many characters in character constant */
 		error(71);
 	} else if (n > 1) {
 		/* multi-character character constant */
 		warning(294);
 	} else if (n == 0) {
 		/* empty character constant */
 		error(73);
+	}
 	if (n == 1)
 		val = (int)convert_integer(val, CHAR, CHAR_SIZE);
 	yylval.y_val = xcalloc(1, sizeof(*yylval.y_val));
 	yylval.y_val->v_tspec = INT;
 	yylval.y_val->v_quad = val;
 	return T_CON;
+}
 /*
  * Called if lex found a leading L\'
  */
 int
 lex_wide_character_constant(void)
+{
 	static	char buf[MB_LEN_MAX + 1];
 	size_t	n, nmax;
 	int c;
 	wchar_t	wc;
 	nmax = MB_CUR_MAX;
 	n = 0;
 	while ((c = get_escaped_char('\'')) >= 0) {
 		if (n < nmax)
 			buf[n] = (char)c;
 		n++;
+	}
 	wc = 0;
 	if (c == -2) {
 		/* unterminated character constant */
 		error(253);
 	} else if (n == 0) {
 		/* empty character constant */
 		error(73);
 	} else if (n > nmax) {
 		n = nmax;
 		/* too many characters in character constant */
 		error(71);
 	} else {
 		buf[n] = '\0';
 		(void)mbtowc(NULL, NULL, 0);
 		if (mbtowc(&wc, buf, nmax) < 0)
 			/* invalid multibyte character */
 			error(291);
+	}
 	yylval.y_val = xcalloc(1, sizeof(*yylval.y_val));
 	yylval.y_val->v_tspec = WCHAR;
 	yylval.y_val->v_quad = wc;
 	return T_CON;
+}
 /*
  * Read a character which is part of a character constant or of a string
  * and handle escapes.
+ *
  * The argument is the character which delimits the character constant or
  * string.
+ *
  * Returns -1 if the end of the character constant or string is reached,
  * -2 if the EOF is reached, and the character otherwise.
  */
 static int
 get_escaped_char(int delim)
+{
 	static	int pbc = -1;
 	int	n, c, v;
 	if (pbc == -1) {
 		c = inpc();
 	} else {
 		c = pbc;
 		pbc = -1;
+	}
 	if (c == delim)
 		return -1;
 	switch (c) {
 	case '\n':
 		if (tflag) {
 			/* newline in string or char constant */
 			error(254);
 			return -2;
+		}
 		return c;
 	case 0:
 		/* syntax error '%s' */
 		error(249, "EOF or null byte in literal");
 		return -2;
 	case EOF:
 		return -2;
 	case '\\':
 		switch (c = inpc()) {
 		case '"':
 			if (tflag && delim == '\'')
 				/* \" inside character constants undef... */
 				warning(262);
 			return '"';
 		case '\'':
 			return '\'';
 		case '?':
 			if (tflag)
 				/* \? undefined in traditional C */
 				warning(263);
 			return '?';
 		case '\\':
 			return '\\';
 		case 'a':
 			if (tflag)
 				/* \a undefined in traditional C */
 				warning(81);
 			return '\a';
 		case 'b':
 			return '\b';
 		case 'f':
 			return '\f';
 		case 'n':
 			return '\n';
 		case 'r':
 			return '\r';
 		case 't':
 			return '\t';
 		case 'v':
 			if (tflag)
 				/* \v undefined in traditional C */
 				warning(264);
 			return '\v';
 		case '8': case '9':
 			/* bad octal digit %c */
 			warning(77, c);
 			/* FALLTHROUGH */
 		case '0': case '1': case '2': case '3':
 		case '4': case '5': case '6': case '7':
 			n = 3;
 			v = 0;
 			do {
 				v = (v << 3) + (c - '0');
 				c = inpc();
 			} while (--n > 0 && '0' <= c && c <= '7');
 			pbc = c;
 			if (v > TARG_UCHAR_MAX) {
 				/* character escape does not fit in character */
 				warning(76);
 				v &= CHAR_MASK;
+			}
 			return v;
 		case 'x':
 			if (tflag)
 				/* \x undefined in traditional C */
 				warning(82);
 			v = 0;
 			n = 0;
 			while (c = inpc(), isxdigit(c)) {
 				c = isdigit(c) ?
 				    c - '0' : toupper(c) - 'A' + 10;
 				v = (v << 4) + c;
 				if (n >= 0) {
 					if ((v & ~CHAR_MASK) != 0) {
 						/* overflow in hex escape */
 						warning(75);
 						n = -1;
 					} else {
 						n++;
+					}
+				}
+			}
 			pbc = c;
 			if (n == 0) {
 				/* no hex digits follow \x */
 				error(74);
 			} if (n == -1) {
 				v &= CHAR_MASK;
+			}
 			return v;
 		case '\n':
 			return get_escaped_char(delim);
 		case EOF:
 			return -2;
 		default:
 			if (isprint(c)) {
 				/* dubious escape \%c */
 				warning(79, c);
 			} else {
 				/* dubious escape \%o */
 				warning(80, c);
+			}
+		}
+	}
 	return c;
+}
 /* See https://gcc.gnu.org/onlinedocs/cpp/Preprocessor-Output.html */
 static void
 parse_line_directive_flags(const char *p,
 			   bool *is_begin, bool *is_end, bool *is_system)
+{
 	*is_begin = false;
 	*is_end = false;
 	*is_system = false;
 	while (*p != '\0') {
 		const char *word_start, *word_end;
 		while (ch_isspace(*p))
 			p++;
 		word_start = p;
 		while (*p != '\0' && !ch_isspace(*p))
 			p++;
 		word_end = p;
 		if (word_end - word_start == 1 && word_start[0] == '1')
 			*is_begin = true;
 		if (word_end - word_start == 1 && word_start[0] == '2')
 			*is_end = true;
 		if (word_end - word_start == 1 && word_start[0] == '3')
 			*is_system = true;
 		/* Flag '4' is only interesting for C++. */
+	}
+}
 /*
  * Called for preprocessor directives. Currently implemented are:
  *	# pragma [argument...]
  *	# lineno
  *	# lineno "filename"
  *	# lineno "filename" GCC-flag...
  */
 void
 lex_directive(const char *yytext)
+{
 	const	char *cp, *fn;
 	char	c, *eptr;
 	size_t	fnl;
 	long	ln;
 	bool	is_begin, is_end, is_system;
 	static	bool first = true;
 	/* Go to first non-whitespace after # */
 	for (cp = yytext + 1; (c = *cp) == ' ' || c == '\t'; cp++)
 		continue;
 	if (!ch_isdigit(c)) {
 		if (strncmp(cp, "pragma", 6) == 0 && ch_isspace(cp[6]))
 			return;
 	error:
 		/* undefined or invalid # directive */
 		warning(255);
 		return;
+	}
 	ln = strtol(--cp, &eptr, 10);
 	if (eptr == cp)
 		goto error;
 	if ((c = *(cp = eptr)) != ' ' && c != '\t' && c != '\0')
 		goto error;
 	while ((c = *cp++) == ' ' || c == '\t')
 		continue;
 	if (c != '\0') {
 		if (c != '"')
 			goto error;
 		fn = cp;
 		while ((c = *cp) != '"' && c != '\0')
 			cp++;
 		if (c != '"')
 			goto error;
 		if ((fnl = cp++ - fn) > PATH_MAX)
 			goto error;
 		/* empty string means stdin */
 		if (fnl == 0) {
 			fn = "{standard input}";
 			fnl = 16;			/* strlen (fn) */
+		}
 		curr_pos.p_file = record_filename(fn, fnl);
 		/*
 		 * If this is the first directive, the name is the name
 		 * of the C source file as specified at the command line.
 		 * It is written to the output file.
 		 */
 		if (first) {
 			csrc_pos.p_file = curr_pos.p_file;
 			outsrc(transform_filename(curr_pos.p_file,
 			    strlen(curr_pos.p_file)));
 			first = false;
+		}
 		parse_line_directive_flags(cp, &is_begin, &is_end, &is_system);
 		update_location(curr_pos.p_file, (int)ln, is_begin, is_end);
 		in_system_header = is_system;
+	}
 	curr_pos.p_line = (int)ln - 1;
 	curr_pos.p_uniq = 0;
 	if (curr_pos.p_file == csrc_pos.p_file) {
 		csrc_pos.p_line = (int)ln - 1;
 		csrc_pos.p_uniq = 0;
+	}
+}
 /*
  * Handle lint comments such as ARGSUSED.
+ *
  * If one of these comments is recognized, the argument, if any, is
  * parsed and a function which handles this comment is called.
  */
 void
 lex_comment(void)
+{
 	int	c, lc;
 	static const struct {
 		const	char *keywd;
 		bool	arg;
 		void	(*func)(int);
 	} keywtab[] = {
 		{ "ARGSUSED",		true,	argsused	},
 		{ "BITFIELDTYPE",	false,	bitfieldtype	},
 		{ "CONSTCOND",		false,	constcond	},
 		{ "CONSTANTCOND",	false,	constcond	},
 		{ "CONSTANTCONDITION",	false,	constcond	},
 		{ "FALLTHRU",		false,	fallthru	},
 		{ "FALLTHROUGH",	false,	fallthru	},
 		{ "FALL THROUGH",	false,	fallthru	},
 		{ "fallthrough",	false,	fallthru	},
 		{ "LINTLIBRARY",	false,	lintlib		},
 		{ "LINTED",		true,	linted		},
 		{ "LONGLONG",		false,	longlong	},
 		{ "NOSTRICT",		true,	linted		},
 		{ "NOTREACHED",		false,	not_reached	},
 		{ "PRINTFLIKE",		true,	printflike	},
 		{ "PROTOLIB",		true,	protolib	},
 		{ "SCANFLIKE",		true,	scanflike	},
 		{ "VARARGS",		true,	varargs		},
 	};
 	char	keywd[32];
 	char	arg[32];
 	size_t	l, i;
 	int	a;
 	bool	eoc;
 	eoc = false;
 	/* Skip whitespace after the start of the comment */
 	while (c = inpc(), isspace(c))
 		continue;
 	/* Read the potential keyword to keywd */
 	l = 0;
 	while (c != EOF && l < sizeof(keywd) - 1 &&
 	    (isalpha(c) || isspace(c))) {
 		if (islower(c) && l > 0 && ch_isupper(keywd[0]))
 			break;
 		keywd[l++] = (char)c;
 		c = inpc();
+	}
 	while (l > 0 && ch_isspace(keywd[l - 1]))
 		l--;
 	keywd[l] = '\0';
 	/* look for the keyword */
 	for (i = 0; i < sizeof(keywtab) / sizeof(keywtab[0]); i++) {
 		if (strcmp(keywtab[i].keywd, keywd) == 0)
 			break;
+	}
 	if (i == sizeof(keywtab) / sizeof(keywtab[0]))
 		goto skip_rest;
 	/* skip whitespace after the keyword */
 	while (isspace(c))
 		c = inpc();
 	/* read the argument, if the keyword accepts one and there is one */
 	l = 0;
 	if (keywtab[i].arg) {
 		while (isdigit(c) && l < sizeof(arg) - 1) {
 			arg[l++] = (char)c;
 			c = inpc();
+		}
+	}
 	arg[l] = '\0';
 	a = l != 0 ? atoi(arg) : -1;
 	/* skip whitespace after the argument */
 	while (isspace(c))
 		c = inpc();
 	if (c != '*' || (c = inpc()) != '/') {
 		if (keywtab[i].func != linted)
 			/* extra characters in lint comment */
 			warning(257);
 	} else {
 		/*
 		 * remember that we have already found the end of the
 		 * comment
 		 */
 		eoc = true;
+	}
 	if (keywtab[i].func != NULL)
 		(*keywtab[i].func)(a);
 skip_rest:
 	while (!eoc) {
 		lc = c;
 		if ((c = inpc()) == EOF) {
 			/* unterminated comment */
 			error(256);
 			break;
+		}
 		if (lc == '*' && c == '/')
 			eoc = true;
+	}
+}
 /*
  * Handle // style comments
  */
 void
 lex_slash_slash_comment(void)
+{
 	int c;
 	if (!Sflag && !gflag)
 		/* %s does not support // comments */
 		gnuism(312, tflag ? "traditional C" : "C90");
 	while ((c = inpc()) != EOF && c != '\n')
 		continue;
+}
 /*
  * Clear flags for lint comments LINTED, LONGLONG and CONSTCOND.
  * clear_warn_flags is called after function definitions and global and
  * local declarations and definitions. It is also called between
  * the controlling expression and the body of control statements
  * (if, switch, for, while).
  */
 void
 clear_warn_flags(void)
+{
 	lwarn = LWARN_ALL;
 	quadflg = false;
 	constcond_flag = false;
+}
 /*
  * Strings are stored in a dynamically allocated buffer and passed
  * in yylval.y_string to the parser. The parser or the routines called
  * by the parser are responsible for freeing this buffer.
  */
 int
 lex_string(void)
+{
 	unsigned char *s;
 	int	c;
 	size_t	len, max;
 	strg_t	*strg;
 	s = xmalloc(max = 64);
 	len = 0;
 	while ((c = get_escaped_char('"')) >= 0) {
 		/* +1 to reserve space for a trailing NUL character */
 		if (len + 1 == max)
 			s = xrealloc(s, max *= 2);
 		s[len++] = (char)c;
+	}
 	s[len] = '\0';
 	if (c == -2)
 		/* unterminated string constant */
 		error(258);
 	strg = xcalloc(1, sizeof(*strg));
 	strg->st_tspec = CHAR;
 	strg->st_len = len;
 	strg->st_cp = s;
 	yylval.y_string = strg;
 	return T_STRING;
+}
 int
 lex_wide_string(void)
+{
 	char	*s;
 	int	c, n;
 	size_t	i, wi;
 	size_t	len, max, wlen;
 	wchar_t	*ws;
 	strg_t	*strg;
 	s = xmalloc(max = 64);
 	len = 0;
 	while ((c = get_escaped_char('"')) >= 0) {
 		/* +1 to save space for a trailing NUL character */
 		if (len + 1 >= max)
 			s = xrealloc(s, max *= 2);
 		s[len++] = (char)c;
+	}
 	s[len] = '\0';
 	if (c == -2)
 		/* unterminated string constant */
 		error(258);
 	/* get length of wide-character string */
 	(void)mblen(NULL, 0);
 	for (i = 0, wlen = 0; i < len; i += n, wlen++) {
 		if ((n = mblen(&s[i], MB_CUR_MAX)) == -1) {
 			/* invalid multibyte character */
 			error(291);
 			break;
+		}
 		if (n == 0)
 			n = 1;
+	}
 	ws = xmalloc((wlen + 1) * sizeof(*ws));
 	/* convert from multibyte to wide char */
 	(void)mbtowc(NULL, NULL, 0);
 	for (i = 0, wi = 0; i < len; i += n, wi++) {
 		if ((n = mbtowc(&ws[wi], &s[i], MB_CUR_MAX)) == -1)
 			break;
 		if (n == 0)
 			n = 1;
+	}
 	ws[wi] = 0;
 	free(s);
 	strg = xcalloc(1, sizeof(*strg));
 	strg->st_tspec = WCHAR;
 	strg->st_len = wlen;
 	strg->st_wcp = ws;
 	yylval.y_string = strg;
 	return T_STRING;
+}
 #ifdef DEBUG
 static const char *
 symt_name(symt_t kind)
+{
 	static const char *name[] = {
 		"var-func-type",
 		"member",
 		"tag",
 		"label",
 	};
 	return name[kind];
+}
 #endif
 /*
  * As noted above, the scanner does not create new symbol table entries
  * for symbols it cannot find in the symbol table. This is to avoid
  * putting undeclared symbols into the symbol table if a syntax error
  * occurs.
+ *
  * getsym() is called as soon as it is probably ok to put the symbol in the
  * symbol table. It is still possible that symbols are put in the symbol
  * table that are not completely declared due to syntax errors. To avoid too
  * many problems in this case, symbols get type 'int' in getsym().
+ *
  * XXX calls to getsym() should be delayed until decl1*() is called.
  */
 sym_t *
 getsym(sbuf_t *sb)
+{
 	dinfo_t	*di;
 	char	*s;
 	sym_t	*sym;
 	sym = sb->sb_sym;
 	/*
 	 * During member declaration it is possible that name() looked
 	 * for symbols of type FVFT, although it should have looked for
 	 * symbols of type FTAG. Same can happen for labels. Both cases
 	 * are compensated here.
 	 */
 	if (symtyp == FMEMBER || symtyp == FLABEL) {
 		if (sym == NULL || sym->s_kind == FVFT)
 			sym = search(sb);
+	}
 	if (sym != NULL) {
 		lint_assert(sym->s_kind == symtyp);
 		symtyp = FVFT;
 		free(sb);
 		return sym;
+	}
 	/* create a new symbol table entry */
 	/* labels must always be allocated at level 1 (outermost block) */
 	if (symtyp == FLABEL) {
 		sym = level_zero_alloc(1, sizeof(*sym));
 		s = level_zero_alloc(1, sb->sb_len + 1);
 		(void)memcpy(s, sb->sb_name, sb->sb_len + 1);
 		sym->s_name = s;
 		sym->s_block_level = 1;
 		di = dcs;
 		while (di->d_next != NULL && di->d_next->d_next != NULL)
 			di = di->d_next;
 		lint_assert(di->d_ctx == AUTO);
 	} else {
 		sym = block_zero_alloc(sizeof(*sym));
 		sym->s_name = sb->sb_name;
 		sym->s_block_level = block_level;
 		di = dcs;
+	}
 	UNIQUE_CURR_POS(sym->s_def_pos);
 	if ((sym->s_kind = symtyp) != FLABEL)
 		sym->s_type = gettyp(INT);
 	symtyp = FVFT;
 	symtab_add(sym);
 	*di->d_ldlsym = sym;
-	di->d_ldlsym = &sym->s_dlnxt;
+	di->d_ldlsym = &sym->s_level_next;
 	free(sb);
 	return sym;
+}
 /*
  * Construct a temporary symbol. The symbol name starts with a digit, making
  * the name illegal.
  */
 sym_t *
 mktempsym(type_t *t)
+{
 	static int n = 0;
 	char *s = level_zero_alloc(block_level, 64);
 	sym_t *sym = block_zero_alloc(sizeof(*sym));
 	scl_t scl;
 	(void)snprintf(s, 64, "%.8d_tmp", n++);
 	scl = dcs->d_scl;
 	if (scl == NOSCL)
 		scl = block_level > 0 ? AUTO : EXTERN;
 	sym->s_name = s;
 	sym->s_type = t;
 	sym->s_block_level = block_level;
 	sym->s_scl = scl;
 	sym->s_kind = FVFT;
 	sym->s_used = true;
 	sym->s_set = true;
 	symtab_add(sym);
 	*dcs->d_ldlsym = sym;
-	dcs->d_ldlsym = &sym->s_dlnxt;
+	dcs->d_ldlsym = &sym->s_level_next;
 	return sym;
+}
 /* Remove a symbol forever from the symbol table. */
 void
 rmsym(sym_t *sym)
+{
 	debug_step("rmsym '%s' %s '%s'",
 	    sym->s_name, symt_name(sym->s_kind), type_name(sym->s_type));
 	symtab_remove(sym);
 	/* avoid that the symbol will later be put back to the symbol table */
 	sym->s_block_level = -1;
+}
 /*
  * Remove a list of symbols declared at one level from the symbol
  * table.
  */
 void
 rmsyms(sym_t *syms)
+{
 	sym_t	*sym;
-	for (sym = syms; sym != NULL; sym = sym->s_dlnxt) {
+	for (sym = syms; sym != NULL; sym = sym->s_level_next) {
 		if (sym->s_block_level != -1) {
 			debug_step("rmsyms '%s' %s '%s'",
 			    sym->s_name, symt_name(sym->s_kind),
 			    type_name(sym->s_type));
 			symtab_remove(sym);
-			sym->s_rlink = NULL;
+			sym->s_symtab_ref = NULL;
+		}
+	}
+}
 /*
  * Put a symbol into the symbol table.
  */
 void
 inssym(int bl, sym_t *sym)
+{
 	debug_step("inssym '%s' %s '%s'",
 	    sym->s_name, symt_name(sym->s_kind), type_name(sym->s_type));
 	symtab_add(sym);
 	sym->s_block_level = bl;
-	lint_assert(sym->s_link == NULL ||
+	lint_assert(sym->s_symtab_next == NULL ||
-		    sym->s_block_level >= sym->s_link->s_block_level);
+		    sym->s_block_level >= sym->s_symtab_next->s_block_level);
+}
 /*
  * Called at level 0 after syntax errors.
+ *
  * Removes all symbols which are not declared at level 0 from the
  * symbol table. Also frees all memory which is not associated with
  * level 0.
  */
 void
 cleanup(void)
+{
 	sym_t	*sym, *nsym;
 	size_t	i;
 	for (i = 0; i < HSHSIZ1; i++) {
 		for (sym = symtab[i]; sym != NULL; sym = nsym) {
-			nsym = sym->s_link;
+			nsym = sym->s_symtab_next;
 			if (sym->s_block_level >= 1)
 				symtab_remove(sym);
+		}
+	}
 	for (i = mem_block_level; i > 0; i--)
 		level_free_all(i);
+}
 /*
  * Create a new symbol with the name of an existing symbol.
  */
 sym_t *
 pushdown(const sym_t *sym)
+{
 	sym_t	*nsym;
 	debug_step("pushdown '%s' %s '%s'",
 	    sym->s_name, symt_name(sym->s_kind), type_name(sym->s_type));
 	nsym = block_zero_alloc(sizeof(*nsym));
 	lint_assert(sym->s_block_level <= block_level);
 	nsym->s_name = sym->s_name;
 	UNIQUE_CURR_POS(nsym->s_def_pos);
 	nsym->s_kind = sym->s_kind;
 	nsym->s_block_level = block_level;
 	symtab_add(nsym);
 	*dcs->d_ldlsym = nsym;
-	dcs->d_ldlsym = &nsym->s_dlnxt;
+	dcs->d_ldlsym = &nsym->s_level_next;
 	return nsym;
+}
 /*
  * Free any dynamically allocated memory referenced by
  * the value stack or yylval.
  * The type of information in yylval is described by tok.
  */
 void
 freeyyv(void *sp, int tok)
+{
 	if (tok == T_NAME || tok == T_TYPENAME) {
 		sbuf_t *sb = *(sbuf_t **)sp;
 		free(sb);
 	} else if (tok == T_CON) {
 		val_t *val = *(val_t **)sp;
 		free(val);
 	} else if (tok == T_STRING) {
 		strg_t *strg = *(strg_t **)sp;
 		if (strg->st_tspec == CHAR) {
 			free(strg->st_cp);
 		} else {
 			lint_assert(strg->st_tspec == WCHAR);
 			free(strg->st_wcp);
+		}
 		free(strg);
+	}
+}

 @@ -1,601 +1,603 @@
-/* $NetBSD: lint1.h,v 1.138 2022/02/27 07:50:09 rillig Exp $ */
+/* $NetBSD: lint1.h,v 1.139 2022/02/27 10:44:45 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.
  */
 #include "lint.h"
 #include "err-msgs.h"
 #include "op.h"
 /*
  * XXX - Super conservative so that works for most systems, but we should
  * not depend on the host settings but the target settings in determining
  * the alignment. The only valid use for this is in mem1.c; uses in decl.c
  * are bogus.
  */
 #ifndef WORST_ALIGN
 #ifdef _LP64
 # define AVAL	15
 #else
 # define AVAL	7
 #endif
 #define WORST_ALIGN(x) (((x) + AVAL) & ~AVAL)
 #endif
 #define LWARN_BAD	(-3)
 #define LWARN_ALL	(-2)
 #define LWARN_NONE	(-1)
 /*
  * Describes the position of a declaration or anything else.
+ *
  * FIXME: Just a single file:lineno pair is not enough to accurately describe
  *  the position of a symbol.  The whole inclusion path at that point must be
  *  stored as well.  This makes a difference for symbols from included
  *  headers, see print_stack_trace.
  */
 typedef struct {
 	const	char *p_file;
 	int	p_line;
 	int	p_uniq;			/* uniquifier */
 } pos_t;
 /* Copies curr_pos, keeping things unique. */
 #define	UNIQUE_CURR_POS(pos)						\
 	do {								\
 		(pos) = curr_pos;					\
 		curr_pos.p_uniq++;					\
 		if (curr_pos.p_file == csrc_pos.p_file)			\
 			csrc_pos.p_uniq++;				\
 	} while (false)
 /*
  * Strings cannot be referenced simply by a pointer to their first
  * char. This is because strings can contain NUL characters other than the
  * trailing NUL.
+ *
  * Strings are stored with a trailing NUL.
  */
 typedef	struct strg {
 	tspec_t	st_tspec;		/* CHAR or WCHAR */
 	size_t	st_len;			/* length without trailing NUL */
 	union {
 		unsigned char *_st_cp;
 		wchar_t *_st_wcp;
 	} st_u;
 } strg_t;
 #define st_cp	st_u._st_cp
 #define	st_wcp	st_u._st_wcp
 /*
  * qualifiers (only for lex/yacc interface)
  */
 typedef enum {
 	CONST, VOLATILE, RESTRICT, THREAD
 } tqual_t;
 /* An integer or floating-point value. */
 typedef struct {
 	tspec_t	v_tspec;
 	/*
 	 * Set if an integer constant is unsigned only in C90 and later, but
 	 * not in traditional C.
+	 *
 	 * See the operators table in ops.def, columns "l r".
 	 */
 	bool	v_unsigned_since_c90;
 	union {
 		int64_t	_v_quad;	/* integers */
 		ldbl_t	_v_ldbl;	/* floats */
 	} v_u;
 } val_t;
 #define v_quad	v_u._v_quad
 #define v_ldbl	v_u._v_ldbl
 /*
  * Structures of type struct_or_union uniquely identify structures. This can't
  * be done in structures of type type_t, because these are copied
  * if they must be modified. So it would not be possible to check
  * if two structures are identical by comparing the pointers to
  * the type structures.
+ *
  * The typename is used if the structure is unnamed to identify
  * the structure type in pass 2.
  */
 typedef	struct {
 	unsigned int sou_size_in_bits;
 	unsigned short sou_align_in_bits;
 	bool	sou_incomplete:1;
 	struct	sym *sou_first_member;
 	struct	sym *sou_tag;
 	struct	sym *sou_first_typedef;
 } struct_or_union;
 /*
  * same as above for enums
  */
 typedef	struct {
 	bool	en_incomplete:1;
 	struct	sym *en_first_enumerator;
 	struct	sym *en_tag;
 	struct	sym *en_first_typedef;
 } enumeration;
 /*
  * The type of an expression or object. Complex types are formed via t_subt
  * (for arrays, pointers and functions), as well as t_str.
  */
 struct lint1_type {
 	tspec_t	t_tspec;	/* type specifier */
 	bool	t_incomplete_array:1;
 	bool	t_const:1;	/* const modifier */
 	bool	t_volatile:1;	/* volatile modifier */
 	bool	t_proto:1;	/* function prototype (t_args valid) */
 	bool	t_vararg:1;	/* prototype with '...' */
 	bool	t_typedef:1;	/* type defined with typedef */
 	bool	t_bitfield:1;
 	/*
 	 * Either the type is currently an enum (having t_tspec ENUM), or
 	 * it is an integer type (typically INT) that has been implicitly
 	 * converted from an enum type.  In both cases, t_enum is valid.
+	 *
 	 * The information about a former enum type is retained to allow
 	 * type checks in expressions such as ((var1 & 0x0001) == var2), to
 	 * detect when var1 and var2 are from incompatible enum types.
 	 */
 	bool	t_is_enum:1;
 	bool	t_packed:1;
 	union {
 		int	_t_dim;		/* dimension (if ARRAY) */
 		struct_or_union	*_t_str;
 		enumeration	*_t_enum;
 		struct	sym *_t_args;	/* arguments (if t_proto) */
 	} t_u;
 	struct {
 		unsigned int	_t_flen:8;	/* length of bit-field */
 		unsigned int	_t_foffs:24;	/* offset of bit-field */
 	} t_b;
 	struct	lint1_type *t_subt; /* element type (if ARRAY),
 				 * return value (if FUNC),
 				 * target type (if PTR) */
 };
 #define	t_dim	t_u._t_dim
 /* TODO: rename t_str to t_sou, to avoid confusing it with strings. */
 #define	t_str	t_u._t_str
 #define	t_enum	t_u._t_enum
 #define	t_args	t_u._t_args
 #define	t_flen	t_b._t_flen
 #define	t_foffs	t_b._t_foffs
 /*
  * types of symbols
  */
 typedef	enum {
 	FVFT,		/* variables, functions, type names, enums */
 	FMEMBER,	/* members of structs or unions */
 	FTAG,		/* tags */
 	FLABEL		/* labels */
 } symt_t;
 /*
  * storage classes and related things
  */
 typedef enum {
 	NOSCL,
 	EXTERN,		/* external symbols (independent of decl_t) */
 	STATIC,		/* static symbols (local and global) */
 	AUTO,		/* automatic symbols (except register) */
 	REG,		/* register */
 	TYPEDEF,	/* typedef */
 	STRUCT_TAG,
 	UNION_TAG,
 	ENUM_TAG,
 	MOS,		/* member of struct */
 	MOU,		/* member of union */
 	CTCONST,	/* enumerator, enum constant or bool constant */
 	ABSTRACT,	/* abstract symbol (sizeof, casts, unnamed argument) */
 	OLD_STYLE_ARG,	/* old-style function argument declarations */
 	PROTO_ARG,	/* used in declaration stack during prototype
 			   declaration */
 	INLINE		/* only used by the parser */
 } scl_t;
 /*
  * symbol table entry
  */
 typedef	struct sym {
 	const	char *s_name;
 	const	char *s_rename;	/* renamed symbol's given name */
 	pos_t	s_def_pos;	/* position of last (prototype) definition,
 				   prototype declaration, no-prototype-def.,
 				   tentative definition or declaration,
 				   in this order */
 	pos_t	s_set_pos;	/* position of first initialization */
 	pos_t	s_use_pos;	/* position of first use */
 	symt_t	s_kind;		/* type of symbol */
 	const struct keyword *s_keyword;
 	bool	s_bitfield:1;
 	bool	s_set:1;	/* variable set, label defined */
 	bool	s_used:1;	/* variable/label used */
 	bool	s_arg:1;	/* symbol is function argument */
 	bool	s_reg:1;	/* symbol is register variable */
 	bool	s_defarg:1;	/* undefined symbol in old style function
 				   definition */
 	bool	s_return_type_implicit_int:1;
 	bool	s_osdef:1;	/* symbol stems from old style function def. */
 	bool	s_inline:1;	/* true if this is an inline function */
 	struct	sym *s_ext_sym;	/* for local declared external symbols pointer
 				   to external symbol with same name */
 	def_t	s_def;		/* declared, tentative defined, defined */
 	scl_t	s_scl;		/* storage class */
 	int	s_block_level;	/* level of declaration, -1 if not in symbol
 				   table */
 	type_t	*s_type;
 	val_t	s_value;	/* value (if enum or bool constant) */
 	union {
 		/* XXX: what is the difference to s_type->t_str? */
 		struct_or_union	*_s_st;
 		enumeration	*_s_et;
 		tspec_t	_s_tsp;	/* type (only for keywords) */
 		tqual_t	_s_tqu;	/* qualifier (only for keywords) */
 		struct	sym *_s_args; /* arguments in old style function
 					 definitions */
 	} u;
-	struct	sym *s_link;	/* next symbol with same hash value */
+	struct	sym *s_symtab_next;	/* next symbol with same hash value */
-	struct	sym **s_rlink;	/* pointer to s_link of prev. symbol */
+	struct	sym **s_symtab_ref;	/* pointer to s_symtab_next of the
 					 * previous symbol */
 	struct	sym *s_next;	/* next struct/union member, enumerator,
 				   argument */
-	struct	sym *s_dlnxt;	/* next symbol declared on same level */
+	struct	sym *s_level_next;	/* next symbol declared on the same
 					 * level */
 } sym_t;
 #define	s_styp	u._s_st
 #define	s_etyp	u._s_et
 #define	s_tspec	u._s_tsp
 #define	s_tqual	u._s_tqu
 #define	s_args	u._s_args
 /*
  * Used to keep some information about symbols before they are entered
  * into the symbol table.
  */
 typedef	struct sbuf {
 	const	char *sb_name;		/* name of symbol */
 	size_t	sb_len;			/* length (without '\0') */
 	sym_t	*sb_sym;		/* symbol table entry */
 } sbuf_t;
 /*
  * tree node
  */
 typedef	struct tnode {
 	op_t	tn_op;		/* operator */
 	type_t	*tn_type;	/* type */
 	bool	tn_lvalue:1;	/* node is lvalue */
 	bool	tn_cast:1;	/* if tn_op == CVT, it's an explicit cast */
 	bool	tn_parenthesized:1;
 	bool	tn_sys:1;	/* in strict bool mode, allow mixture between
 				 * bool and scalar, for code from system
 				 * headers that may be a mixture between
 				 * scalar types and bool
 				 */
 	bool	tn_system_dependent:1; /* depends on sizeof or offsetof */
 	union {
 		struct {
 			struct	tnode *_tn_left;	/* (left) operand */
 			struct	tnode *_tn_right;	/* right operand */
 		} tn_s;
 		sym_t	*_tn_sym;	/* symbol if op == NAME */
 		val_t	*_tn_val;	/* value if op == CON */
 		strg_t	*_tn_string;	/* string if op == STRING */
 	} tn_u;
 } tnode_t;
 #define	tn_left		tn_u.tn_s._tn_left
 #define tn_right	tn_u.tn_s._tn_right
 #define tn_sym		tn_u._tn_sym
 #define	tn_val		tn_u._tn_val
 #define	tn_string	tn_u._tn_string
 struct generic_association {
 	type_t *ga_arg;		/* NULL means default or error */
 	tnode_t *ga_result;	/* NULL means error */
 	struct generic_association *ga_prev;
 };
 struct array_size {
 	bool has_dim;
 	int dim;
 };
 /*
  * For nested declarations there is a stack that holds all information
  * needed for the current level. dcs points to the innermost element of this
  * stack.
+ *
  * d_ctx describes the context of the current declaration. Its value is
  * one of
  *	EXTERN		global declarations
  *	MOS or MOU	declarations of struct or union members
  *	CTCONST		declarations of enums or boolean constants
  *	OLD_STYLE_ARG	declaration of arguments in old-style function
  *			definitions
  *	PROTO_ARG	declaration of arguments in function prototypes
  *	AUTO		declaration of local symbols
  *	ABSTRACT	abstract declarations (sizeof, casts)
+ *
  */
 typedef	struct dinfo {
 	tspec_t	d_abstract_type;/* VOID, BOOL, CHAR, INT or COMPLEX */
 	tspec_t	d_complex_mod;	/* FLOAT or DOUBLE */
 	tspec_t	d_sign_mod;	/* SIGNED or UNSIGN */
 	tspec_t	d_rank_mod;	/* SHORT, LONG or QUAD */
 	scl_t	d_scl;		/* storage class */
 	type_t	*d_type;	/* after end_type() pointer to the type used
 				   for all declarators */
 	sym_t	*d_redeclared_symbol;
 	unsigned int d_offset;	/* offset of next structure member */
 	unsigned short d_sou_align_in_bits; /* alignment required for current
 				 * structure */
 	scl_t	d_ctx;		/* context of declaration */
 	bool	d_const:1;	/* const in declaration specifiers */
 	bool	d_volatile:1;	/* volatile in declaration specifiers */
 	bool	d_inline:1;	/* inline in declaration specifiers */
 	bool	d_multiple_storage_classes:1; /* reported in end_type */
 	bool	d_invalid_type_combination:1;
 	bool	d_nonempty_decl:1; /* if at least one tag is declared
 				 * ... in the current function decl. */
 	bool	d_vararg:1;
 	bool	d_proto:1;	/* current function decl. is prototype */
 	bool	d_notyp:1;	/* set if no type specifier was present */
 	bool	d_asm:1;	/* set if d_ctx == AUTO and asm() present */
 	bool	d_packed:1;
 	bool	d_used:1;
 	type_t	*d_tagtyp;	/* tag during member declaration */
 	sym_t	*d_func_args;	/* list of arguments during function def. */
 	pos_t	d_func_def_pos;	/* position of function definition */
 	sym_t	*d_dlsyms;	/* first symbol declared at this level */
-	sym_t	**d_ldlsym;	/* points to s_dlnxt in last symbol decl.
+	sym_t	**d_ldlsym;	/* points to s_level_next in the last symbol
-				   at this level */
+				   declaration at this level */
 	sym_t	*d_func_proto_syms; /* symbols defined in prototype */
 	struct	dinfo *d_next;	/* next level */
 } dinfo_t;
 /* One level of pointer indirection in declarators, including qualifiers. */
 typedef	struct qual_ptr {
 	bool	p_const: 1;
 	bool	p_volatile: 1;
 	bool	p_pointer: 1;
 	struct	qual_ptr *p_next;
 } qual_ptr;
 /*
  * The values of the 'case' labels, linked via cl_next in reverse order of
  * appearance in the code, that is from bottom to top.
  */
 typedef	struct case_label {
 	val_t	cl_val;
 	struct case_label *cl_next;
 } case_label_t;
 typedef enum {
 	CS_DO_WHILE,
 	CS_FOR,
 	CS_FUNCTION_BODY,
 	CS_IF,
 	CS_SWITCH,
 	CS_WHILE
 } control_statement_kind;
 /*
  * Used to keep information about nested control statements.
  */
 typedef struct control_statement {
 	control_statement_kind c_kind;	/* to ensure proper nesting */
 	bool	c_loop:1;		/* 'continue' and 'break' are valid */
 	bool	c_switch:1;		/* 'case' and 'break' are valid */
 	bool	c_break:1;		/* the loop/switch has a reachable
 					 * 'break' statement */
 	bool	c_continue:1;		/* the loop has a reachable 'continue'
 					 * statement */
 	bool	c_default:1;		/* the switch has a 'default' label */
 	bool	c_maybe_endless:1;	/* the controlling expression is
 					 * always true (as in 'for (;;)' or
 					 * 'while (1)'), there may be break
 					 * statements though */
 	bool	c_always_then:1;
 	bool	c_reached_end_of_then:1;
 	bool	c_had_return_noval:1;	/* had "return;" */
 	bool	c_had_return_value:1;	/* had "return expr;" */
 	type_t	*c_switch_type;		/* type of switch expression */
 	tnode_t	*c_switch_expr;
 	case_label_t *c_case_labels;	/* list of case values */
 	struct	memory_block *c_for_expr3_mem; /* saved memory for end of loop
 					 * expression in for() */
 	tnode_t	*c_for_expr3;		/* end of loop expr in for() */
 	pos_t	c_for_expr3_pos;	/* position of end of loop expr */
 	pos_t	c_for_expr3_csrc_pos;	/* same for csrc_pos */
 	struct control_statement *c_surrounding;
 } control_statement;
 typedef struct {
 	size_t lo;			/* inclusive */
 	size_t hi;			/* inclusive */
 } range_t;
 #include "externs1.h"
 #define	ERR_SETSIZE	1024
 #define __NERRBITS (sizeof(unsigned int))
 typedef	struct err_set {
 	unsigned int	errs_bits[(ERR_SETSIZE + __NERRBITS-1) / __NERRBITS];
 } err_set;
 #define	ERR_SET(n, p)	\
 	((p)->errs_bits[(n)/__NERRBITS] |= (1 << ((n) % __NERRBITS)))
 #define	ERR_CLR(n, p)	\
 	((p)->errs_bits[(n)/__NERRBITS] &= ~(1 << ((n) % __NERRBITS)))
 #define	ERR_ISSET(n, p)	\
 	(((p)->errs_bits[(n)/__NERRBITS] & (1 << ((n) % __NERRBITS))) != 0)
 #define	ERR_ZERO(p)	(void)memset((p), 0, sizeof(*(p)))
 #define INTERNAL_ERROR(fmt, args...) \
 	internal_error(__FILE__, __LINE__, fmt, ##args)
 #define lint_assert(cond)						\
 	do {								\
 		if (!(cond))						\
 			assert_failed(__FILE__, __LINE__, __func__, #cond); \
 	} while (false)
 extern err_set	msgset;
 #ifdef DEBUG
 #  include "err-msgs.h"
 /* ARGSUSED */
 static inline void __attribute__((format(printf, 1, 2)))
 check_printf(const char *fmt, ...)
+{
+}
 #  define wrap_check_printf_at(func, msgid, pos, args...)		\
 	do {								\
 		check_printf(__CONCAT(MSG_, msgid), ##args);		\
 		(func)(msgid, pos, ##args);				\
 	} while (false)
 #  define error_at(msgid, pos, args...) \
 	wrap_check_printf_at(error_at, msgid, pos, ##args)
 #  define warning_at(msgid, pos, args...) \
 	wrap_check_printf_at(warning_at, msgid, pos, ##args)
 #  define message_at(msgid, pos, args...) \
 	wrap_check_printf_at(message_at, msgid, pos, ##args)
 #  define wrap_check_printf(func, msgid, args...)			\
 	do {								\
 		check_printf(__CONCAT(MSG_, msgid), ##args);		\
 		(func)(msgid, ##args);					\
 	} while (false)
 #  define error(msgid, args...) wrap_check_printf(error, msgid, ##args)
 #  define warning(msgid, args...) wrap_check_printf(warning, msgid, ##args)
 #  define gnuism(msgid, args...) wrap_check_printf(gnuism, msgid, ##args)
 #  define c99ism(msgid, args...) wrap_check_printf(c99ism, msgid, ##args)
 #  define c11ism(msgid, args...) wrap_check_printf(c11ism, msgid, ##args)
 #endif
 static inline bool
 is_nonzero_val(const val_t *val)
+{
 	return is_floating(val->v_tspec)
 	    ? val->v_ldbl != 0.0
 	    : val->v_quad != 0;
+}
 static inline bool
 constant_is_nonzero(const tnode_t *tn)
+{
 	lint_assert(tn->tn_op == CON);
 	lint_assert(tn->tn_type->t_tspec == tn->tn_val->v_tspec);
 	return is_nonzero_val(tn->tn_val);
+}
 static inline bool
 is_zero(const tnode_t *tn)
+{
 	return tn != NULL && tn->tn_op == CON && !is_nonzero_val(tn->tn_val);
+}
 static inline bool
 is_nonzero(const tnode_t *tn)
+{
 	return tn != NULL && tn->tn_op == CON && is_nonzero_val(tn->tn_val);
+}
 static inline bool
 is_binary(const tnode_t *tn)
+{
 	return modtab[tn->tn_op].m_binary;
+}
 static inline uint64_t
 bit(unsigned i)
+{
 	/*
 	 * TODO: Add proper support for INT128.
 	 * This involves changing val_t to 128 bits.
 	 */
 	if (i >= 64)
 		return 0;	/* XXX: not correct for INT128 and UINT128 */
 	lint_assert(i < 64);
 	return (uint64_t)1 << i;
+}
 static inline bool
 msb(int64_t q, tspec_t t)
+{
 	return (q & bit((unsigned int)size_in_bits(t) - 1)) != 0;
+}
 static inline uint64_t
 value_bits(unsigned bitsize)
+{
 	lint_assert(bitsize > 0);
 	/* for long double (80 or 128), double _Complex (128) */
 	/*
 	 * XXX: double _Complex does not have 128 bits of precision,
 	 * therefore it should never be necessary to query the value bits
 	 * of such a type; see d_c99_complex_split.c to trigger this case.
 	 */
 	if (bitsize >= 64)
 		return ~((uint64_t)0);
 	return ~(~(uint64_t)0 << bitsize);
+}
 /* C99 6.7.8p7 */
 static inline bool
 is_struct_or_union(tspec_t t)
+{
 	return t == STRUCT || t == UNION;
+}

 @@ -1,1402 +1,1403 @@
-/*	$NetBSD: tree.c,v 1.406 2022/02/27 10:31:58 rillig Exp $	*/
+/*	$NetBSD: tree.c,v 1.407 2022/02/27 10:44:45 rillig Exp $	*/
 /*
  * 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: tree.c,v 1.406 2022/02/27 10:31:58 rillig Exp $");
+__RCSID("$NetBSD: tree.c,v 1.407 2022/02/27 10:44:45 rillig Exp $");
 #endif
 #include <float.h>
 #include <limits.h>
 #include <math.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 #include "cgram.h"
 static	tnode_t	*build_integer_constant(tspec_t, int64_t);
 static	void	check_pointer_comparison(op_t,
 					 const tnode_t *, const tnode_t *);
 static	bool	check_assign_types_compatible(op_t, int,
 					      const tnode_t *, const tnode_t *);
 static	void	check_bad_enum_operation(op_t,
 					 const tnode_t *, const tnode_t *);
 static	void	check_enum_type_mismatch(op_t, int,
 				         const tnode_t *, const tnode_t *);
 static	void	check_enum_int_mismatch(op_t, int,
 					const tnode_t *, const tnode_t *);
 static	tnode_t	*new_tnode(op_t, bool, type_t *, tnode_t *, tnode_t *);
 static	void	balance(op_t, tnode_t **, tnode_t **);
 static	void	warn_incompatible_types(op_t, const type_t *, tspec_t,
 					const type_t *, tspec_t);
 static	void	warn_incompatible_pointers(const mod_t *,
 					   const type_t *, const type_t *);
 static	bool	has_constant_member(const type_t *);
 static	void	check_prototype_conversion(int, tspec_t, tspec_t, type_t *,
 					   tnode_t *);
 static	void	check_integer_conversion(op_t, int, tspec_t, tspec_t, type_t *,
 					 tnode_t *);
 static	void	check_pointer_integer_conversion(op_t, tspec_t, type_t *,
 						 tnode_t *);
 static	void	check_pointer_conversion(tnode_t *, type_t *);
 static	tnode_t	*build_struct_access(op_t, bool, tnode_t *, tnode_t *);
 static	tnode_t	*build_prepost_incdec(op_t, bool, tnode_t *);
 static	tnode_t	*build_real_imag(op_t, bool, tnode_t *);
 static	tnode_t	*build_address(bool, tnode_t *, bool);
 static	tnode_t	*build_plus_minus(op_t, bool, tnode_t *, tnode_t *);
 static	tnode_t	*build_bit_shift(op_t, bool, tnode_t *, tnode_t *);
 static	tnode_t	*build_colon(bool, tnode_t *, tnode_t *);
 static	tnode_t	*build_assignment(op_t, bool, tnode_t *, tnode_t *);
 static	tnode_t	*plength(type_t *);
 static	tnode_t	*fold(tnode_t *);
 static	tnode_t	*fold_test(tnode_t *);
 static	tnode_t	*fold_float(tnode_t *);
 static	tnode_t	*check_function_arguments(type_t *, tnode_t *);
 static	tnode_t	*check_prototype_argument(int, type_t *, tnode_t *);
 static	void	check_null_effect(const tnode_t *);
 static	void	check_array_index(tnode_t *, bool);
 static	void	check_integer_comparison(op_t, tnode_t *, tnode_t *);
 static	void	check_precedence_confusion(tnode_t *);
 extern sig_atomic_t fpe;
 static const char *
 op_name(op_t op)
+{
 	return modtab[op].m_name;
+}
 /* Build 'pointer to tp', 'array of tp' or 'function returning tp'. */
 type_t *
 block_derive_type(type_t *tp, tspec_t t)
+{
 	type_t	*tp2;
 	tp2 = block_zero_alloc(sizeof(*tp2));
 	tp2->t_tspec = t;
 	tp2->t_subt = tp;
 	return tp2;
+}
 /*
  * Derive 'pointer to tp' or 'function returning tp'.
  * The memory is freed at the end of the current expression.
  */
 type_t *
 expr_derive_type(type_t *tp, tspec_t t)
+{
 	type_t	*tp2;
 	tp2 = expr_zero_alloc(sizeof(*tp2));
 	tp2->t_tspec = t;
 	tp2->t_subt = tp;
 	return tp2;
+}
 /*
  * Create a node for a constant.
  */
 tnode_t *
 build_constant(type_t *tp, val_t *v)
+{
 	tnode_t	*n;
 	n = expr_alloc_tnode();
 	n->tn_op = CON;
 	n->tn_type = tp;
 	n->tn_val = expr_zero_alloc(sizeof(*n->tn_val));
 	n->tn_val->v_tspec = tp->t_tspec;
 	n->tn_val->v_unsigned_since_c90 = v->v_unsigned_since_c90;
 	n->tn_val->v_u = v->v_u;
 	free(v);
 	return n;
+}
 static tnode_t *
 build_integer_constant(tspec_t t, int64_t q)
+{
 	tnode_t	*n;
 	n = expr_alloc_tnode();
 	n->tn_op = CON;
 	n->tn_type = gettyp(t);
 	n->tn_val = expr_zero_alloc(sizeof(*n->tn_val));
 	n->tn_val->v_tspec = t;
 	n->tn_val->v_quad = q;
 	return n;
+}
 static void
 fallback_symbol(sym_t *sym)
+{
 	if (fallback_symbol_strict_bool(sym))
 		return;
 	if (block_level > 0 && (strcmp(sym->s_name, "__FUNCTION__") == 0 ||
 			   strcmp(sym->s_name, "__PRETTY_FUNCTION__") == 0)) {
 		/* __FUNCTION__/__PRETTY_FUNCTION__ is a GCC extension */
 		gnuism(316);
 		sym->s_type = block_derive_type(gettyp(CHAR), PTR);
 		sym->s_type->t_const = true;
 		return;
+	}
 	if (block_level > 0 && strcmp(sym->s_name, "__func__") == 0) {
 		if (!Sflag)
 			/* __func__ is a C9X feature */
 			warning(317);
 		sym->s_type = block_derive_type(gettyp(CHAR), PTR);
 		sym->s_type->t_const = true;
 		return;
+	}
 	/* '%s' undefined */
 	error(99, sym->s_name);
+}
 /*
  * Functions that are predeclared by GCC or other compilers can be called
  * with arbitrary arguments.  Since lint usually runs after a successful
  * compilation, it's the compiler's job to catch any errors.
  */
 bool
 is_compiler_builtin(const char *name)
+{
 	/* https://gcc.gnu.org/onlinedocs/gcc/C-Extensions.html */
 	if (gflag) {
 		if (strncmp(name, "__atomic_", 9) == 0 ||
 		    strncmp(name, "__builtin_", 10) == 0 ||
 		    strcmp(name, "alloca") == 0 ||
 		    /* obsolete but still in use, as of 2021 */
 		    strncmp(name, "__sync_", 7) == 0)
 			return true;
+	}
 	/* https://software.intel.com/sites/landingpage/IntrinsicsGuide/ */
 	if (strncmp(name, "_mm_", 4) == 0)
 		return true;
 	return false;
+}
 static bool
 str_endswith(const char *haystack, const char *needle)
+{
 	size_t hlen = strlen(haystack);
 	size_t nlen = strlen(needle);
 	return nlen <= hlen &&
 	       memcmp(haystack + hlen - nlen, needle, nlen) == 0;
+}
 /* https://gcc.gnu.org/onlinedocs/gcc/Integer-Overflow-Builtins.html */
 static bool
 is_gcc_bool_builtin(const char *name)
+{
 	return strncmp(name, "__builtin_", 10) == 0 &&
 	       (str_endswith(name, "_overflow") ||
 		str_endswith(name, "_overflow_p"));
+}
 static void
 build_name_call(sym_t *sym)
+{
 	if (is_compiler_builtin(sym->s_name)) {
 		/*
 		 * Do not warn about these, just assume that
 		 * they are regular functions compatible with
 		 * non-prototype calling conventions.
 		 */
 		if (gflag && is_gcc_bool_builtin(sym->s_name))
 			sym->s_type = gettyp(BOOL);
 	} else if (Sflag) {
 		/* function '%s' implicitly declared to return int */
 		error(215, sym->s_name);
 	} else if (sflag) {
 		/* function '%s' implicitly declared to return int */
 		warning(215, sym->s_name);
+	}
 	/* XXX if tflag is set, the symbol should be exported to level 0 */
 	sym->s_type = block_derive_type(sym->s_type, FUNC);
+}
 /* Create a node for a name (symbol table entry). */
 tnode_t *
 build_name(sym_t *sym, bool is_funcname)
+{
 	tnode_t	*n;
 	if (sym->s_scl == NOSCL) {
 		sym->s_scl = EXTERN;
 		sym->s_def = DECL;
 		if (is_funcname)
 			build_name_call(sym);
 		else
 			fallback_symbol(sym);
+	}
 	lint_assert(sym->s_kind == FVFT || sym->s_kind == FMEMBER);
 	n = expr_alloc_tnode();
 	n->tn_type = sym->s_type;
 	if (sym->s_scl == CTCONST) {
 		n->tn_op = CON;
 		n->tn_val = expr_zero_alloc(sizeof(*n->tn_val));
 		*n->tn_val = sym->s_value;
 	} else {
 		n->tn_op = NAME;
 		n->tn_sym = sym;
 		if (sym->s_kind == FVFT && sym->s_type->t_tspec != FUNC)
 			n->tn_lvalue = true;
+	}
 	return n;
+}
 tnode_t *
 build_string(strg_t *strg)
+{
 	size_t	len;
 	tnode_t	*n;
 	type_t *tp;
 	len = strg->st_len;
 	n = expr_alloc_tnode();
 	tp = expr_zero_alloc(sizeof(*tp));
 	tp->t_tspec = ARRAY;
 	tp->t_subt = gettyp(strg->st_tspec);
 	tp->t_dim = (int)(len + 1);
 	n->tn_op = STRING;
 	n->tn_type = tp;
 	n->tn_lvalue = true;
 	n->tn_string = expr_zero_alloc(sizeof(*n->tn_string));
 	n->tn_string->st_tspec = strg->st_tspec;
 	n->tn_string->st_len = len;
 	if (strg->st_tspec == CHAR) {
 		n->tn_string->st_cp = expr_zero_alloc(len + 1);
 		(void)memcpy(n->tn_string->st_cp, strg->st_cp, len + 1);
 		free(strg->st_cp);
 	} else {
 		size_t size = (len + 1) * sizeof(*n->tn_string->st_wcp);
 		n->tn_string->st_wcp = expr_zero_alloc(size);
 		(void)memcpy(n->tn_string->st_wcp, strg->st_wcp, size);
 		free(strg->st_wcp);
+	}
 	free(strg);
 	return n;
+}
 /*
  * Returns a symbol which has the same name as the msym argument and is a
  * member of the struct or union specified by the tn argument.
  */
 static sym_t *
 struct_or_union_member(tnode_t *tn, op_t op, sym_t *msym)
+{
 	struct_or_union	*str;
 	type_t	*tp;
 	sym_t	*sym, *csym;
 	bool	eq;
 	tspec_t	t;
 	/*
 	 * Remove the member if it was unknown until now, which means
 	 * that no defined struct or union has a member with the same name.
 	 */
 	if (msym->s_scl == NOSCL) {
 		/* type '%s' does not have member '%s' */
 		error(101, type_name(tn->tn_type), msym->s_name);
 		rmsym(msym);
 		msym->s_kind = FMEMBER;
 		msym->s_scl = MOS;
 		msym->s_styp = expr_zero_alloc(sizeof(*msym->s_styp));
 		msym->s_styp->sou_tag = expr_zero_alloc(
 		    sizeof(*msym->s_styp->sou_tag));
 		msym->s_styp->sou_tag->s_name = unnamed;
 		msym->s_value.v_tspec = INT;
 		return msym;
+	}
 	/* Set str to the tag of which msym is expected to be a member. */
 	str = NULL;
 	t = (tp = tn->tn_type)->t_tspec;
 	if (op == POINT) {
 		if (t == STRUCT || t == UNION)
 			str = tp->t_str;
 	} else if (op == ARROW && t == PTR) {
 		t = (tp = tp->t_subt)->t_tspec;
 		if (t == STRUCT || t == UNION)
 			str = tp->t_str;
+	}
 	/*
 	 * If this struct/union has a member with the name of msym, return it.
 	 */
 	if (str != NULL) {
-		for (sym = msym; sym != NULL; sym = sym->s_link) {
+		for (sym = msym; sym != NULL; sym = sym->s_symtab_next) {
 			if (sym->s_scl != MOS && sym->s_scl != MOU)
 				continue;
 			if (sym->s_styp != str)
 				continue;
 			if (strcmp(sym->s_name, msym->s_name) != 0)
 				continue;
 			return sym;
+		}
+	}
 	/*
 	 * Set eq to false if there are struct/union members with the same
 	 * name and different types and/or offsets.
 	 */
 	eq = true;
-	for (csym = msym; csym != NULL; csym = csym->s_link) {
+	for (csym = msym; csym != NULL; csym = csym->s_symtab_next) {
 		if (csym->s_scl != MOS && csym->s_scl != MOU)
 			continue;
 		if (strcmp(msym->s_name, csym->s_name) != 0)
 			continue;
-		for (sym = csym->s_link; sym != NULL; sym = sym->s_link) {
+		for (sym = csym->s_symtab_next; sym != NULL;
 		    sym = sym->s_symtab_next) {
 			bool w;
 			if (sym->s_scl != MOS && sym->s_scl != MOU)
 				continue;
 			if (strcmp(csym->s_name, sym->s_name) != 0)
 				continue;
 			if (csym->s_value.v_quad != sym->s_value.v_quad) {
 				eq = false;
 				break;
+			}
 			w = false;
 			eq = eqtype(csym->s_type, sym->s_type,
 			    false, false, &w) && !w;
 			if (!eq)
 				break;
 			if (csym->s_bitfield != sym->s_bitfield) {
 				eq = false;
 				break;
+			}
 			if (csym->s_bitfield) {
 				type_t	*tp1, *tp2;
 				tp1 = csym->s_type;
 				tp2 = sym->s_type;
 				if (tp1->t_flen != tp2->t_flen) {
 					eq = false;
 					break;
+				}
 				if (tp1->t_foffs != tp2->t_foffs) {
 					eq = false;
 					break;
+				}
+			}
+		}
 		if (!eq)
 			break;
+	}
 	/*
 	 * Now handle the case in which the left operand refers really
 	 * to a struct/union, but the right operand is not member of it.
 	 */
 	if (str != NULL) {
 		if (eq && tflag) {
 			/* illegal member use: %s */
 			warning(102, msym->s_name);
 		} else {
 			/* illegal member use: %s */
 			error(102, msym->s_name);
+		}
 		return msym;
+	}
 	/*
 	 * Now the left operand of ARROW does not point to a struct/union
 	 * or the left operand of POINT is no struct/union.
 	 */
 	if (eq) {
 		if (op == POINT) {
 			if (tflag) {
 				/* left operand of '.' must be struct ... */
 				warning(103, type_name(tn->tn_type));
 			} else {
 				/* left operand of '.' must be struct ... */
 				error(103, type_name(tn->tn_type));
+			}
 		} else {
 			if (tflag && tn->tn_type->t_tspec == PTR) {
 				/* left operand of '->' must be pointer ... */
 				warning(104, type_name(tn->tn_type));
 			} else {
 				/* left operand of '->' must be pointer ... */
 				error(104, type_name(tn->tn_type));
+			}
+		}
 	} else {
 		if (tflag) {
 			/* non-unique member requires struct/union %s */
 			error(105, op == POINT ? "object" : "pointer");
 		} else {
 			/* unacceptable operand of '%s' */
 			error(111, op_name(op));
+		}
+	}
 	return msym;
+}
 tnode_t *
 build_generic_selection(const tnode_t *expr,
 			struct generic_association *sel)
+{
 	tnode_t *default_result = NULL;
 	for (; sel != NULL; sel = sel->ga_prev)
 		if (expr != NULL &&
 		    eqtype(sel->ga_arg, expr->tn_type, false, false, NULL))
 			return sel->ga_result;
 		else if (sel->ga_arg == NULL)
 			default_result = sel->ga_result;
 	return default_result;
+}
 /*
  * Create a tree node for a binary operator and its two operands. Also called
  * for unary operators; in that case rn is NULL.
+ *
  * Function calls, sizeof and casts are handled elsewhere.
  */
 tnode_t *
 build_binary(tnode_t *ln, op_t op, bool sys, tnode_t *rn)
+{
 	const mod_t *mp;
 	tnode_t	*ntn;
 	type_t	*rettp;
 	mp = &modtab[op];
 	/* If there was an error in one of the operands, return. */
 	if (ln == NULL || (mp->m_binary && rn == NULL))
 		return NULL;
 	/*
 	 * Apply class conversions to the left operand, but only if its
 	 * value is needed or it is compared with null.
 	 */
 	if (mp->m_left_value_context || mp->m_left_test_context)
 		ln = cconv(ln);
 	/*
 	 * The right operand is almost always in a test or value context,
 	 * except if it is a struct or union member.
 	 */
 	if (mp->m_binary && op != ARROW && op != POINT)
 		rn = cconv(rn);
 	/*
 	 * Print some warnings for comparisons of unsigned values with
 	 * constants lower than or equal to null. This must be done
 	 * before promote() because otherwise unsigned char and unsigned
 	 * short would be promoted to int. Also types are tested to be
 	 * CHAR, which would also become int.
 	 */
 	if (mp->m_comparison)
 		check_integer_comparison(op, ln, rn);
 	/*
 	 * Promote the left operand if it is in a test or value context
 	 */
 	if (mp->m_left_value_context || mp->m_left_test_context)
 		ln = promote(op, false, ln);
 	/*
 	 * Promote the right operand, but only if it is no struct or
 	 * union member, or if it is not to be assigned to the left operand
 	 */
 	if (mp->m_binary && op != ARROW && op != POINT &&
 	    op != ASSIGN && op != RETURN && op != INIT) {
 		rn = promote(op, false, rn);
+	}
 	/*
 	 * If the result of the operation is different for signed or
 	 * unsigned operands and one of the operands is signed only in
 	 * ANSI C, print a warning.
 	 */
 	if (mp->m_warn_if_left_unsigned_in_c90 &&
 	    ln->tn_op == CON && ln->tn_val->v_unsigned_since_c90) {
 		/* ANSI C treats constant as unsigned, op %s */
 		warning(218, mp->m_name);
 		ln->tn_val->v_unsigned_since_c90 = false;
+	}
 	if (mp->m_warn_if_right_unsigned_in_c90 &&
 	    rn->tn_op == CON && rn->tn_val->v_unsigned_since_c90) {
 		/* ANSI C treats constant as unsigned, op %s */
 		warning(218, mp->m_name);
 		rn->tn_val->v_unsigned_since_c90 = false;
+	}
 	/* Make sure both operands are of the same type */
 	if (mp->m_balance_operands || (tflag && (op == SHL || op == SHR)))
 		balance(op, &ln, &rn);
 	/*
 	 * Check types for compatibility with the operation and mutual
 	 * compatibility. Return if there are serious problems.
 	 */
 	if (!typeok(op, 0, ln, rn))
 		return NULL;
 	/* And now create the node. */
 	switch (op) {
 	case POINT:
 	case ARROW:
 		ntn = build_struct_access(op, sys, ln, rn);
 		break;
 	case INCAFT:
 	case DECAFT:
 	case INCBEF:
 	case DECBEF:
 		ntn = build_prepost_incdec(op, sys, ln);
 		break;
 	case ADDR:
 		ntn = build_address(sys, ln, false);
 		break;
 	case INDIR:
 		ntn = new_tnode(INDIR, sys, ln->tn_type->t_subt, ln, NULL);
 		break;
 	case PLUS:
 	case MINUS:
 		ntn = build_plus_minus(op, sys, ln, rn);
 		break;
 	case SHL:
 	case SHR:
 		ntn = build_bit_shift(op, sys, ln, rn);
 		break;
 	case COLON:
 		ntn = build_colon(sys, ln, rn);
 		break;
 	case ASSIGN:
 	case MULASS:
 	case DIVASS:
 	case MODASS:
 	case ADDASS:
 	case SUBASS:
 	case SHLASS:
 	case SHRASS:
 	case ANDASS:
 	case XORASS:
 	case ORASS:
 	case RETURN:
 	case INIT:
 		ntn = build_assignment(op, sys, ln, rn);
 		break;
 	case COMMA:
 	case QUEST:
 		ntn = new_tnode(op, sys, rn->tn_type, ln, rn);
 		break;
 	case REAL:
 	case IMAG:
 		ntn = build_real_imag(op, sys, ln);
 		break;
 	default:
 		rettp = mp->m_returns_bool
 		    ? gettyp(Tflag ? BOOL : INT) : ln->tn_type;
 		lint_assert(mp->m_binary || rn == NULL);
 		ntn = new_tnode(op, sys, rettp, ln, rn);
 		break;
+	}
 	/* Return if an error occurred. */
 	if (ntn == NULL)
 		return NULL;
 	/* Print a warning if precedence confusion is possible */
 	if (mp->m_possible_precedence_confusion)
 		check_precedence_confusion(ntn);
 	/*
 	 * Print a warning if one of the operands is in a context where
 	 * it is compared with null and if this operand is a constant.
 	 */
 	if (mp->m_left_test_context) {
 		if (ln->tn_op == CON ||
 		    ((mp->m_binary && op != QUEST) && rn->tn_op == CON)) {
 			if (hflag && !constcond_flag &&
 			    !ln->tn_system_dependent)
 				/* constant in conditional context */
 				warning(161);
+		}
+	}
 	/* Fold if the operator requires it */
 	if (mp->m_fold_constant_operands) {
 		if (ln->tn_op == CON && (!mp->m_binary || rn->tn_op == CON)) {
 			if (mp->m_left_test_context) {
 				ntn = fold_test(ntn);
 			} else if (is_floating(ntn->tn_type->t_tspec)) {
 				ntn = fold_float(ntn);
 			} else {
 				ntn = fold(ntn);
+			}
 		} else if (op == QUEST && ln->tn_op == CON) {
 			ntn = ln->tn_val->v_quad != 0
 			    ? rn->tn_left : rn->tn_right;
+		}
+	}
 	return ntn;
+}
 tnode_t *
 build_unary(op_t op, bool sys, tnode_t *tn)
+{
 	return build_binary(tn, op, sys, NULL);
+}
 tnode_t *
 build_member_access(tnode_t *ln, op_t op, bool sys, sbuf_t *member)
+{
 	sym_t	*msym;
 	if (ln == NULL)
 		return NULL;
 	if (op == ARROW) {
 		/* must do this before struct_or_union_member is called */
 		ln = cconv(ln);
+	}
 	msym = struct_or_union_member(ln, op, getsym(member));
 	return build_binary(ln, op, sys, build_name(msym, false));
+}
 /*
  * Perform class conversions.
+ *
  * Arrays of type T are converted into pointers to type T.
  * Functions are converted to pointers to functions.
  * Lvalues are converted to rvalues.
+ *
  * C99 6.3 "Conversions"
  * C99 6.3.2 "Other operands"
  * C99 6.3.2.1 "Lvalues, arrays, and function designators"
  */
 tnode_t *
 cconv(tnode_t *tn)
+{
 	type_t	*tp;
 	/*
 	 * Array-lvalue (array of type T) is converted into rvalue
 	 * (pointer to type T)
 	 */
 	if (tn->tn_type->t_tspec == ARRAY) {
 		if (!tn->tn_lvalue) {
 			/* XXX print correct operator */
 			/* %soperand of '%s' must be lvalue */
 			gnuism(114, "", op_name(ADDR));
+		}
 		tn = new_tnode(ADDR, tn->tn_sys,
 		    expr_derive_type(tn->tn_type->t_subt, PTR), tn, NULL);
+	}
 	/*
 	 * Expression of type function (function with return value of type T)
 	 * in rvalue-expression (pointer to function with return value
 	 * of type T)
 	 */
 	if (tn->tn_type->t_tspec == FUNC)
 		tn = build_address(tn->tn_sys, tn, true);
 	/* lvalue to rvalue */
 	if (tn->tn_lvalue) {
 		tp = expr_dup_type(tn->tn_type);
 		/* C99 6.3.2.1p2 sentence 2 says to remove the qualifiers. */
 		tp->t_const = tp->t_volatile = false;
 		tn = new_tnode(LOAD, tn->tn_sys, tp, tn, NULL);
+	}
 	return tn;
+}
 const tnode_t *
 before_conversion(const tnode_t *tn)
+{
 	while (tn->tn_op == CVT && !tn->tn_cast)
 		tn = tn->tn_left;
 	return tn;
+}
 static bool
 is_null_pointer(const tnode_t *tn)
+{
 	tspec_t t = tn->tn_type->t_tspec;
 	return ((t == PTR && tn->tn_type->t_subt->t_tspec == VOID) ||
 		is_integer(t))
 	       && (tn->tn_op == CON && tn->tn_val->v_quad == 0);
+}
 /*
  * Most errors required by ANSI C are reported in struct_or_union_member().
  * Here we only check for totally wrong things.
  */
 static bool
 typeok_point(const tnode_t *ln, const type_t *ltp, tspec_t lt)
+{
 	if (lt == FUNC || lt == VOID || ltp->t_bitfield ||
 	    ((lt != STRUCT && lt != UNION) && !ln->tn_lvalue)) {
 		/* Without tflag we got already an error */
 		if (tflag)
 			/* unacceptable operand of '%s' */
 			error(111, op_name(POINT));
 		return false;
+	}
 	return true;
+}
 static bool
 typeok_arrow(tspec_t lt)
+{
 	if (lt == PTR || (tflag && is_integer(lt)))
 		return true;
 	/* Without tflag we got already an error */
 	if (tflag)
 		/* unacceptable operand of '%s' */
 		error(111, op_name(ARROW));
 	return false;
+}
 static bool
 typeok_incdec(op_t op, const tnode_t *tn, const type_t *tp)
+{
 	/* operand has scalar type (checked in typeok) */
 	if (!tn->tn_lvalue) {
 		if (tn->tn_op == CVT && tn->tn_cast &&
 		    tn->tn_left->tn_op == LOAD) {
 			/* a cast does not yield an lvalue */
 			error(163);
+		}
 		/* %soperand of '%s' must be lvalue */
 		error(114, "", op_name(op));
 		return false;
 	} else if (tp->t_const) {
 		if (!tflag)
 			/* %soperand of '%s' must be modifiable lvalue */
 			warning(115, "", op_name(op));
+	}
 	return true;
+}
 static bool
 typeok_address(const mod_t *mp,
 	       const tnode_t *tn, const type_t *tp, tspec_t t)
+{
 	if (t == ARRAY || t == FUNC) {
 		/* ok, a warning comes later (in build_address()) */
 	} else if (!tn->tn_lvalue) {
 		if (tn->tn_op == CVT && tn->tn_cast &&
 		    tn->tn_left->tn_op == LOAD) {
 			/* a cast does not yield an lvalue */
 			error(163);
+		}
 		/* %soperand of '%s' must be lvalue */
 		error(114, "", mp->m_name);
 		return false;
 	} else if (is_scalar(t)) {
 		if (tp->t_bitfield) {
 			/* cannot take address of bit-field */
 			error(112);
 			return false;
+		}
 	} else if (t != STRUCT && t != UNION) {
 		/* unacceptable operand of '%s' */
 		error(111, mp->m_name);
 		return false;
+	}
 	if (tn->tn_op == NAME && tn->tn_sym->s_reg) {
 		/* cannot take address of register %s */
 		error(113, tn->tn_sym->s_name);
 		return false;
+	}
 	return true;
+}
 static bool
 typeok_indir(tspec_t t)
+{
 	/* until now there were no type checks for this operator */
 	if (t != PTR) {
 		/* cannot dereference non-pointer type */
 		error(96);
 		return false;
+	}
 	return true;
+}
 static bool
 typeok_plus(op_t op,
 	    const type_t *ltp, tspec_t lt,
 	    const type_t *rtp, tspec_t rt)
+{
 	/* operands have scalar types (checked above) */
 	if ((lt == PTR && !is_integer(rt)) || (rt == PTR && !is_integer(lt))) {
 		warn_incompatible_types(op, ltp, lt, rtp, rt);
 		return false;
+	}
 	return true;
+}
 static bool
 typeok_minus(op_t op,
 	     const type_t *ltp, tspec_t lt,
 	     const type_t *rtp, tspec_t rt)
+{
 	/* operands have scalar types (checked above) */
 	if (lt == PTR && (!is_integer(rt) && rt != PTR)) {
 		warn_incompatible_types(op, ltp, lt, rtp, rt);
 		return false;
 	} else if (rt == PTR && lt != PTR) {
 		warn_incompatible_types(op, ltp, lt, rtp, rt);
 		return false;
+	}
 	if (lt == PTR && rt == PTR) {
 		if (!eqtype(ltp->t_subt, rtp->t_subt, true, false, NULL)) {
 			/* illegal pointer subtraction */
 			error(116);
+		}
+	}
 	return true;
+}
 static void
 typeok_shr(const mod_t *mp,
 	   const tnode_t *ln, tspec_t lt,
 	   const tnode_t *rn, tspec_t rt)
+{
 	tspec_t olt, ort;
 	olt = before_conversion(ln)->tn_type->t_tspec;
 	ort = before_conversion(rn)->tn_type->t_tspec;
 	/* operands have integer types (checked above) */
 	if (pflag && !is_uinteger(olt)) {
 		/*
 		 * The left operand is signed. This means that
 		 * the operation is (possibly) nonportable.
 		 */
 		if (ln->tn_op != CON) {
 			/* bitwise '%s' on signed value possibly nonportable */
 			warning(117, mp->m_name);
 		} else if (ln->tn_val->v_quad < 0) {
 			/* bitwise '%s' on signed value nonportable */
 			warning(120, mp->m_name);
+		}
 	} else if (!tflag && !sflag && !is_uinteger(olt) && is_uinteger(ort)) {
 		/*
 		 * The left operand would become unsigned in
 		 * traditional C.
 		 */
 		if (hflag && !Sflag &&
 		    (ln->tn_op != CON || ln->tn_val->v_quad < 0)) {
 			/* semantics of '%s' change in ANSI C; use ... */
 			warning(118, mp->m_name);
+		}
 	} else if (!tflag && !sflag && !is_uinteger(olt) && !is_uinteger(ort) &&
 		   portable_size_in_bits(lt) < portable_size_in_bits(rt)) {
 		/*
 		 * In traditional C the left operand would be extended,
 		 * possibly with 1, and then shifted.
 		 */
 		if (hflag && !Sflag &&
 		    (ln->tn_op != CON || ln->tn_val->v_quad < 0)) {
 			/* semantics of '%s' change in ANSI C; use ... */
 			warning(118, mp->m_name);
+		}
+	}
+}
 static void
 typeok_shl(const mod_t *mp, tspec_t lt, tspec_t rt)
+{
 	/*
 	 * C90 does not perform balancing for shift operations,
 	 * but traditional C does. If the width of the right operand
 	 * is greater than the width of the left operand, then in
 	 * traditional C the left operand would be extended to the
 	 * width of the right operand. For SHL this may result in
 	 * different results.
 	 */
 	if (portable_size_in_bits(lt) < portable_size_in_bits(rt)) {
 		/*
 		 * XXX If both operands are constant, make sure
 		 * that there is really a difference between
 		 * ANSI C and traditional C.
 		 */
 		if (hflag && !Sflag)
 			/* semantics of '%s' change in ANSI C; use ... */
 			warning(118, mp->m_name);
+	}
+}
 static void
 typeok_shift(tspec_t lt, const tnode_t *rn, tspec_t rt)
+{
 	if (rn->tn_op != CON)
 		return;
 	if (!is_uinteger(rt) && rn->tn_val->v_quad < 0) {
 		/* negative shift */
 		warning(121);
 	} else if ((uint64_t)rn->tn_val->v_quad ==
 		   (uint64_t)size_in_bits(lt)) {
 		/* shift equal to size of object */
 		warning(267);
 	} else if ((uint64_t)rn->tn_val->v_quad > (uint64_t)size_in_bits(lt)) {
 		/* shift amount %llu is greater than bit-size %llu of '%s' */
 		warning(122, (unsigned long long)rn->tn_val->v_quad,
 		    (unsigned long long)size_in_bits(lt),
 		    tspec_name(lt));
+	}
+}
 static bool
 is_typeok_eq(const tnode_t *ln, tspec_t lt, const tnode_t *rn, tspec_t rt)
+{
 	if (lt == PTR && is_null_pointer(rn))
 		return true;
 	if (rt == PTR && is_null_pointer(ln))
 		return true;
 	return false;
+}
 static bool
 typeok_compare(op_t op,
 	       const tnode_t *ln, const type_t *ltp, tspec_t lt,
 	       const tnode_t *rn, const type_t *rtp, tspec_t rt)
+{
 	const char *lx, *rx;
 	if (lt == PTR && rt == PTR) {
 		check_pointer_comparison(op, ln, rn);
 		return true;
+	}
 	if (lt != PTR && rt != PTR)
 		return true;
 	if (!is_integer(lt) && !is_integer(rt)) {
 		warn_incompatible_types(op, ltp, lt, rtp, rt);
 		return false;
+	}
 	lx = lt == PTR ? "pointer" : "integer";
 	rx = rt == PTR ? "pointer" : "integer";
 	/* illegal combination of %s '%s' and %s '%s', op '%s' */
 	warning(123, lx, type_name(ltp), rx, type_name(rtp), op_name(op));
 	return true;
+}
 static bool
 typeok_quest(tspec_t lt, const tnode_t *rn)
+{
 	if (!is_scalar(lt)) {
 		/* first operand must have scalar type, op ? : */
 		error(170);
 		return false;
+	}
 	lint_assert(before_conversion(rn)->tn_op == COLON);
 	return true;
+}
 static void
 typeok_colon_pointer(const mod_t *mp, const type_t *ltp, const type_t *rtp)
+{
 	type_t *lstp = ltp->t_subt;
 	type_t *rstp = rtp->t_subt;
 	tspec_t lst = lstp->t_tspec;
 	tspec_t rst = rstp->t_tspec;
 	if ((lst == VOID && rst == FUNC) || (lst == FUNC && rst == VOID)) {
 		/* (void *)0 handled above */
 		if (sflag)
 			/* ANSI C forbids conversion of %s to %s, op %s */
 			warning(305, "function pointer", "'void *'",
 			    mp->m_name);
 		return;
+	}
 	if (eqptrtype(lstp, rstp, true))
 		return;
 	if (!eqtype(lstp, rstp, true, false, NULL))
 		warn_incompatible_pointers(mp, ltp, rtp);
+}
 static bool
 typeok_colon(const mod_t *mp,
 	     const tnode_t *ln, const type_t *ltp, tspec_t lt,
 	     const tnode_t *rn, const type_t *rtp, tspec_t rt)
+{
 	if (is_arithmetic(lt) && is_arithmetic(rt))
 		return true;
 	if (lt == BOOL && rt == BOOL)
 		return true;
 	if (lt == STRUCT && rt == STRUCT && ltp->t_str == rtp->t_str)
 		return true;
 	if (lt == UNION && rt == UNION && ltp->t_str == rtp->t_str)
 		return true;
 	if (lt == PTR && is_null_pointer(rn))
 		return true;
 	if (rt == PTR && is_null_pointer(ln))
 		return true;
 	if ((lt == PTR && is_integer(rt)) || (is_integer(lt) && rt == PTR)) {
 		const char *lx = lt == PTR ? "pointer" : "integer";
 		const char *rx = rt == PTR ? "pointer" : "integer";
 		/* illegal combination of %s '%s' and %s '%s', op '%s' */
 		warning(123, lx, type_name(ltp),
 		    rx, type_name(rtp), mp->m_name);
 		return true;
+	}
 	if (lt == VOID || rt == VOID) {
 		if (lt != VOID || rt != VOID)
 			/* incompatible types '%s' and '%s' in conditional */
 			warning(126, type_name(ltp), type_name(rtp));
 		return true;
+	}
 	if (lt == PTR && rt == PTR) {
 		typeok_colon_pointer(mp, ltp, rtp);
 		return true;
+	}
 	/* incompatible types '%s' and '%s' in conditional */
 	error(126, type_name(ltp), type_name(rtp));
 	return false;
+}
 static bool
 typeok_assign(op_t op, const tnode_t *ln, const type_t *ltp, tspec_t lt)
+{
 	if (op == RETURN || op == INIT || op == FARG)
 		return true;
 	if (!ln->tn_lvalue) {
 		if (ln->tn_op == CVT && ln->tn_cast &&
 		    ln->tn_left->tn_op == LOAD) {
 			/* a cast does not yield an lvalue */
 			error(163);
+		}
 		/* %soperand of '%s' must be lvalue */
 		error(114, "left ", op_name(op));
 		return false;
 	} else if (ltp->t_const || ((lt == STRUCT || lt == UNION) &&
 				    has_constant_member(ltp))) {
 		if (!tflag)
 			/* %soperand of '%s' must be modifiable lvalue */
 			warning(115, "left ", op_name(op));
+	}
 	return true;
+}
 /* Check the types using the information from modtab[]. */
 static bool
 typeok_scalar(op_t op, const mod_t *mp,
 	      const type_t *ltp, tspec_t lt,
 	      const type_t *rtp, tspec_t rt)
+{
 	if (mp->m_takes_bool && lt == BOOL && rt == BOOL)
 		return true;
 	if (mp->m_requires_integer) {
 		if (!is_integer(lt) || (mp->m_binary && !is_integer(rt))) {
 			warn_incompatible_types(op, ltp, lt, rtp, rt);
 			return false;
+		}
 	} else if (mp->m_requires_integer_or_complex) {
 		if ((!is_integer(lt) && !is_complex(lt)) ||
 		    (mp->m_binary && (!is_integer(rt) && !is_complex(rt)))) {
 			warn_incompatible_types(op, ltp, lt, rtp, rt);
 			return false;
+		}
 	} else if (mp->m_requires_scalar) {
 		if (!is_scalar(lt) || (mp->m_binary && !is_scalar(rt))) {
 			warn_incompatible_types(op, ltp, lt, rtp, rt);
 			return false;
+		}
 	} else if (mp->m_requires_arith) {
 		if (!is_arithmetic(lt) ||
 		    (mp->m_binary && !is_arithmetic(rt))) {
 			warn_incompatible_types(op, ltp, lt, rtp, rt);
 			return false;
+		}
+	}
 	return true;
+}
 /*
  * Check the types for specific operators and type combinations.
+ *
  * At this point, the operands already conform to the type requirements of
  * the operator, such as being integer, floating or scalar.
  */
 static bool
 typeok_op(op_t op, const mod_t *mp, int arg,
 	  const tnode_t *ln, const type_t *ltp, tspec_t lt,
 	  const tnode_t *rn, const type_t *rtp, tspec_t rt)
+{
 	switch (op) {
 	case ARROW:
 		return typeok_arrow(lt);
 	case POINT:
 		return typeok_point(ln, ltp, lt);
 	case INCBEF:
 	case DECBEF:
 	case INCAFT:
 	case DECAFT:
 		return typeok_incdec(op, ln, ltp);
 	case INDIR:
 		return typeok_indir(lt);
 	case ADDR:
 		return typeok_address(mp, ln, ltp, lt);
 	case PLUS:
 		return typeok_plus(op, ltp, lt, rtp, rt);
 	case MINUS:
 		return typeok_minus(op, ltp, lt, rtp, rt);
 	case SHL:
 		typeok_shl(mp, lt, rt);
 		goto shift;
 	case SHR:
 		typeok_shr(mp, ln, lt, rn, rt);
 	shift:
 		typeok_shift(lt, rn, rt);
 		break;
 	case LT:
 	case LE:
 	case GT:
 	case GE:
 	compare:
 		return typeok_compare(op, ln, ltp, lt, rn, rtp, rt);
 	case EQ:
 	case NE:
 		if (is_typeok_eq(ln, lt, rn, rt))
 			break;
 		goto compare;
 	case QUEST:
 		return typeok_quest(lt, rn);
 	case COLON:
 		return typeok_colon(mp, ln, ltp, lt, rn, rtp, rt);
 	case ASSIGN:
 	case INIT:
 	case FARG:
 	case RETURN:
 		if (!check_assign_types_compatible(op, arg, ln, rn))
 			return false;
 		goto assign;
 	case MULASS:
 	case DIVASS:
 	case MODASS:
 		goto assign;
 	case ADDASS:
 	case SUBASS:
 		if ((lt == PTR && !is_integer(rt)) || rt == PTR) {
 			warn_incompatible_types(op, ltp, lt, rtp, rt);
 			return false;
+		}
 		goto assign;
 	case SHLASS:
 		goto assign;
 	case SHRASS:
 		if (pflag && !is_uinteger(lt) && !(tflag && is_uinteger(rt))) {
 			/* bitwise '%s' on signed value possibly nonportable */
 			warning(117, mp->m_name);
+		}
 		goto assign;
 	case ANDASS:
 	case XORASS:
 	case ORASS:
 	assign:
 		return typeok_assign(op, ln, ltp, lt);
 	case COMMA:
 		if (!modtab[ln->tn_op].m_has_side_effect)
 			check_null_effect(ln);
 		break;
 	default:
 		break;
+	}
 	return true;
+}
 static void
 typeok_enum(op_t op, const mod_t *mp, int arg,
 	    const tnode_t *ln, const type_t *ltp,
 	    const tnode_t *rn, const type_t *rtp)
+{
 	if (mp->m_bad_on_enum &&
 	    (ltp->t_is_enum || (mp->m_binary && rtp->t_is_enum))) {
 		check_bad_enum_operation(op, ln, rn);
 	} else if (mp->m_valid_on_enum &&
 		   (ltp->t_is_enum && rtp != NULL && rtp->t_is_enum)) {
 		check_enum_type_mismatch(op, arg, ln, rn);
 	} else if (mp->m_valid_on_enum &&
 		   (ltp->t_is_enum || (rtp != NULL && rtp->t_is_enum))) {
 		check_enum_int_mismatch(op, arg, ln, rn);
+	}
+}
 /* Perform most type checks. Return whether the types are ok. */
 bool
 typeok(op_t op, int arg, const tnode_t *ln, const tnode_t *rn)
+{
 	const mod_t *mp;
 	tspec_t	lt, rt;
 	type_t	*ltp, *rtp;
 	mp = &modtab[op];
 	lint_assert((ltp = ln->tn_type) != NULL);
 	lt = ltp->t_tspec;
 	if (mp->m_binary) {
 		lint_assert((rtp = rn->tn_type) != NULL);
 		rt = rtp->t_tspec;
 	} else {
 		rtp = NULL;
 		rt = NOTSPEC;
+	}
 	if (Tflag && !typeok_scalar_strict_bool(op, mp, arg, ln, rn))
 		return false;
 	if (!typeok_scalar(op, mp, ltp, lt, rtp, rt))
 		return false;
 	if (!typeok_op(op, mp, arg, ln, ltp, lt, rn, rtp, rt))
 		return false;
 	typeok_enum(op, mp, arg, ln, ltp, rn, rtp);
 	return true;
+}
 static void
 check_pointer_comparison(op_t op, const tnode_t *ln, const tnode_t *rn)
+{
 	type_t	*ltp, *rtp;
 	tspec_t	lst, rst;
 	const	char *lsts, *rsts;
 	lst = (ltp = ln->tn_type)->t_subt->t_tspec;
 	rst = (rtp = rn->tn_type)->t_subt->t_tspec;
 	if (lst == VOID || rst == VOID) {
 		if (sflag && (lst == FUNC || rst == FUNC)) {
 			/* (void *)0 already handled in typeok() */
 			*(lst == FUNC ? &lsts : &rsts) = "function pointer";
 			*(lst == VOID ? &lsts : &rsts) = "'void *'";
 			/* ANSI C forbids comparison of %s with %s */
 			warning(274, lsts, rsts);
+		}
 		return;
+	}
 	if (!eqtype(ltp->t_subt, rtp->t_subt, true, false, NULL)) {
 		warn_incompatible_pointers(&modtab[op], ltp, rtp);
 		return;
+	}
 	if (lst == FUNC && rst == FUNC) {
 		if (sflag && op != EQ && op != NE)
 			/* ANSI C forbids ordered comparisons of ... */
 			warning(125);
+	}
+}
 static bool
 is_direct_function_call(const tnode_t *tn, const char **out_name)
+{
 	if (!(tn->tn_op == CALL &&
 	      tn->tn_left->tn_op == ADDR &&
 	      tn->tn_left->tn_left->tn_op == NAME))
 		return false;
 	*out_name = tn->tn_left->tn_left->tn_sym->s_name;
 	return true;
+}
 static bool
 is_unconst_function(const char *name)
+{
 	return strcmp(name, "memchr") == 0 ||
 	       strcmp(name, "strchr") == 0 ||
 	       strcmp(name, "strpbrk") == 0 ||
 	       strcmp(name, "strrchr") == 0 ||
 	       strcmp(name, "strstr") == 0;
+}
 static bool
 is_const_char_pointer(const tnode_t *tn)
+{
 	const type_t *tp;
 	/*
 	 * For traditional reasons, C99 6.4.5p5 defines that string literals
 	 * have type 'char[]'.  They are often implicitly converted to
 	 * 'char *', for example when they are passed as function arguments.
+	 *
 	 * C99 6.4.5p6 further defines that modifying a string that is
 	 * constructed from a string literal invokes undefined behavior.
+	 *
 	 * Out of these reasons, string literals are treated as 'effectively
 	 * const' here.
 	 */
 	if (tn->tn_op == CVT &&
 	    tn->tn_left->tn_op == ADDR &&
 	    tn->tn_left->tn_left->tn_op == STRING)
 		return true;