Fri Jun 9 13:03:49 2023 UTC ()

lint: indent local variables consistently

No binary change.


(rillig)

diff -r1.18 -r1.19 src/usr.bin/xlint/common/emit.c
diff -r1.34 -r1.35 src/usr.bin/xlint/common/inittyp.c
diff -r1.315 -r1.316 src/usr.bin/xlint/lint1/decl.c
diff -r1.66 -r1.67 src/usr.bin/xlint/lint1/emit1.c
diff -r1.197 -r1.198 src/usr.bin/xlint/lint1/err.c
diff -r1.154 -r1.155 src/usr.bin/xlint/lint1/func.c
diff -r1.158 -r1.159 src/usr.bin/xlint/lint1/lex.c
diff -r1.525 -r1.526 src/usr.bin/xlint/lint1/tree.c
diff -r1.54 -r1.55 src/usr.bin/xlint/lint2/chk.c
diff -r1.30 -r1.31 src/usr.bin/xlint/lint2/emit2.c
diff -r1.24 -r1.25 src/usr.bin/xlint/lint2/hash.c
diff -r1.28 -r1.29 src/usr.bin/xlint/lint2/main2.c
diff -r1.19 -r1.20 src/usr.bin/xlint/lint2/msg.c
diff -r1.80 -r1.81 src/usr.bin/xlint/lint2/read.c
diff -r1.109 -r1.110 src/usr.bin/xlint/xlint/xlint.c

--- src/usr.bin/xlint/common/emit.c 2023/01/14 09:30:07	1.18
+++ src/usr.bin/xlint/common/emit.c 2023/06/09 13:03:49	1.19

 @@ -1,14 +1,14 @@
-/*	$NetBSD: emit.c,v 1.18 2023/01/14 09:30:07 rillig Exp $	*/
+/*	$NetBSD: emit.c,v 1.19 2023/06/09 13:03:49 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.
 @@ -27,27 +27,27 @@
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID)
-__RCSID("$NetBSD: emit.c,v 1.18 2023/01/14 09:30:07 rillig Exp $");
+__RCSID("$NetBSD: emit.c,v 1.19 2023/06/09 13:03:49 rillig Exp $");
 #endif
 #include <stdio.h>
 #include <string.h>
 #include "lint.h"
 /* name and handle of output file */
 static	const	char *loname;
 static	FILE	*lout;
 /* output buffer data */
 static	ob_t	ob;
 @@ -96,27 +96,27 @@ outxbuf(void)
 	coffs = ob.o_next - ob.o_buf;
 	ob.o_len *= 2;
 	ob.o_end = (ob.o_buf = xrealloc(ob.o_buf, ob.o_len)) + ob.o_len;
 	ob.o_next = ob.o_buf + coffs;
+}
 /*
  * reset output buffer
  * if it is not empty, it is flushed
  */
 void
 outclr(void)
+{
-	size_t	sz;
+	size_t sz;
 	if (ob.o_buf != ob.o_next) {
 		outchar('\n');
 		sz = ob.o_next - ob.o_buf;
 		if (sz > ob.o_len)
 			errx(1, "internal error: outclr");
 		if (fwrite(ob.o_buf, sz, 1, lout) != 1)
 			err(1, "cannot write to %s", loname);
 		ob.o_next = ob.o_buf;
+	}
+}
 /*

--- src/usr.bin/xlint/common/inittyp.c 2023/05/22 12:55:04	1.34
+++ src/usr.bin/xlint/common/inittyp.c 2023/06/09 13:03:49	1.35

 @@ -1,14 +1,14 @@
-/*	$NetBSD: inittyp.c,v 1.34 2023/05/22 12:55:04 rillig Exp $	*/
+/*	$NetBSD: inittyp.c,v 1.35 2023/06/09 13:03:49 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.
 @@ -27,27 +27,27 @@
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID)
-__RCSID("$NetBSD: inittyp.c,v 1.34 2023/05/22 12:55:04 rillig Exp $");
+__RCSID("$NetBSD: inittyp.c,v 1.35 2023/06/09 13:03:49 rillig Exp $");
 #endif
 #if defined(IS_LINT1)
 #include "lint1.h"
 #else
 #include "lint2.h"
 #endif
 #define INT_RSIZE	(/*CONSTCOND*/INTPTR_TSPEC == LONG ? 3 : 4)
 #ifdef IS_LINT1
 #define typeinfo( \
 	    name, signed_type, unsigned_type, \
 @@ -118,27 +118,27 @@ ttab_t	ttab[NTSPEC] = {
 	typeinfo("float _Complex", FCOMPLEX, FCOMPLEX,
 	    FLOAT_SIZE * 2, 32 * 2, 'c'),
 	typeinfo("double _Complex", DCOMPLEX, DCOMPLEX,
 	    DOUBLE_SIZE * 2, 64 * 2, 'c'),
 	typeinfo("long double _Complex", LCOMPLEX, LCOMPLEX,
 	    LDOUBLE_SIZE * 2, 80 * 2, 'c'),
 };
 #undef typeinfo
 #ifdef IS_LINT1
 void
 inittyp(void)
+{
-	size_t	i;
+	size_t i;
 	if (!pflag) {
 		for (i = 0; i < NTSPEC; i++)
 			ttab[i].tt_portable_size_in_bits =
 			    ttab[i].tt_size_in_bits;
+	}
 	if (Tflag) {
 		ttab[BOOL].tt_is_integer = false;
 		ttab[BOOL].tt_is_uinteger = false;
 		ttab[BOOL].tt_is_arithmetic = false;
+	}
+}

--- src/usr.bin/xlint/lint1/decl.c 2023/06/03 21:08:06	1.315
+++ src/usr.bin/xlint/lint1/decl.c 2023/06/09 13:03:49	1.316

 @@ -1,14 +1,14 @@
-/* $NetBSD: decl.c,v 1.315 2023/06/03 21:08:06 rillig Exp $ */
+/* $NetBSD: decl.c,v 1.316 2023/06/09 13:03:49 rillig Exp $ */
 /*
  * Copyright (c) 1996 Christopher G. Demetriou.  All Rights Reserved.
  * Copyright (c) 1994, 1995 Jochen Pohl
  * All Rights Reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
 @@ -28,27 +28,27 @@
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID)
-__RCSID("$NetBSD: decl.c,v 1.315 2023/06/03 21:08:06 rillig Exp $");
+__RCSID("$NetBSD: decl.c,v 1.316 2023/06/09 13:03:49 rillig Exp $");
 #endif
 #include <sys/param.h>
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 const char unnamed[] = "<unnamed>";
 /* shared type structures for arithmetic types and void */
 static	type_t	typetab[NTSPEC];
 @@ -142,38 +142,38 @@ initdecl(void)
  * 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;
+	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;
+	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 *
 @@ -194,27 +194,27 @@ expr_unqualified_type(const type_t *tp)
 	 * tp1->t_sou == tp2->t_sou.
 	 */
 	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;
+	tspec_t t;
 	if ((t = tp->t_tspec) == VOID)
 		return true;
 	if (t == ARRAY)
 		return tp->t_incomplete_array;
 	if (is_struct_or_union(t))
 		return tp->t_sou->sou_incomplete;
 	if (t == ENUM)
 		return tp->t_enum->en_incomplete;
 	return false;
+}
 @@ -249,27 +249,27 @@ dcs_add_storage_class(scl_t sc)
 /*
  * Remember the type, modifier or typedef name returned by the parser
  * in *dcs (top element of decl stack). This information is used in
  * dcs_end_type to build the type used for all declarators in this
  * declaration.
+ *
  * If tp->t_typedef is true, the type comes from a previously defined
  * typename. Otherwise, it comes from a type specifier (int, long, ...) or a
  * struct/union/enum tag.
  */
 void
 dcs_add_type(type_t *tp)
+{
-	tspec_t	t;
+	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 == NO_TSPEC);
 		lint_assert(dcs->d_sign_mod == NO_TSPEC);
 		lint_assert(dcs->d_rank_mod == NO_TSPEC);
 		dcs->d_type = tp;
 @@ -387,27 +387,27 @@ merge_signedness(tspec_t t, tspec_t s)
 	    : 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 *
 typedef_error(type_t *td, tspec_t t)
+{
-	tspec_t	t2;
+	tspec_t t2;
 	t2 = td->t_tspec;
 	if ((t == SIGNED || t == UNSIGN) &&
 	    (t2 == CHAR || t2 == SHORT || t2 == INT ||
 	     t2 == LONG || t2 == QUAD)) {
 		if (allow_c90)
 			/* modifying typedef with '%s'; only qualifiers... */
 			warning(5, tspec_name(t));
 		td = block_dup_type(gettyp(merge_signedness(t2, t)));
 		td->t_typedef = true;
 		return td;
+	}
 @@ -454,27 +454,27 @@ invalid:
 /*
  * 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
 set_first_typedef(type_t *tp, sym_t *sym)
+{
-	tspec_t	t;
+	tspec_t t;
 	if (is_struct_or_union(t = tp->t_tspec)) {
 		if (tp->t_sou->sou_first_typedef == NULL)
 			tp->t_sou->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
 bit_field_size(sym_t **mem)
+{
 @@ -562,44 +562,44 @@ dcs_add_qualifier(tqual_t q)
 	} else {
 		lint_assert(q == RESTRICT || q == THREAD || q == ATOMIC);
 		/* Silently ignore these qualifiers. */
+	}
+}
 /*
  * Go to the next declaration level (structs, nested structs, blocks,
  * argument declaration lists ...)
  */
 void
 begin_declaration_level(declaration_kind dk)
+{
-	dinfo_t	*di;
+	dinfo_t *di;
 	/* put a new element on the declaration stack */
 	di = xcalloc(1, sizeof(*di));
 	di->d_enclosing = dcs;
 	dcs = di;
 	di->d_kind = dk;
 	di->d_ldlsym = &di->d_dlsyms;
 	debug_step("%s(%s)", __func__, declaration_kind_name(dk));
+}
 /*
  * Go back to previous declaration level
  */
 void
 end_declaration_level(void)
+{
-	dinfo_t	*di;
+	dinfo_t *di;
 	debug_step("%s(%s)", __func__, declaration_kind_name(dcs->d_kind));
 	lint_assert(dcs->d_enclosing != NULL);
 	di = dcs;
 	dcs = di->d_enclosing;
 	switch (di->d_kind) {
 	case DK_STRUCT_MEMBER:
 	case DK_UNION_MEMBER:
 	case DK_ENUM_CONSTANT:
 		/*
 		 * Symbols declared in (nested) structs or enums are
 @@ -716,28 +716,28 @@ dcs_adjust_storage_class(void)
 			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;
+	tspec_t t, s, l, c;
-	type_t	*tp;
+	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 == NO_TSPEC && s == NO_TSPEC && l == NO_TSPEC && c == NO_TSPEC &&
 	    tp == NULL)
 		dcs->d_notyp = true;
 	if (t == NO_TSPEC && s == NO_TSPEC && (l == NO_TSPEC || l == LONG) &&
 	    tp == NULL)
 @@ -907,50 +907,50 @@ alignment_in_bits(const type_t *tp)
+	}
 	lint_assert(a >= CHAR_SIZE);
 	lint_assert(a <= worst_align_in_bits);
 	return a;
+}
 /*
  * Concatenate two lists of symbols by s_next. Used by declarations of
  * struct/union/enum elements and parameters.
  */
 sym_t *
 concat_lists(sym_t *l1, sym_t *l2)
+{
-	sym_t	*l;
+	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;
+	tspec_t to, t;
-	type_t	**tpp, *tp;
+	type_t **tpp, *tp;
 	tpp = &sym->s_type;
 	to = NO_TSPEC;
 	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 begin_function().
 		 */
 		if (t == FUNC && !tp->t_proto &&
 		    !(to == NO_TSPEC && sym->s_osdef)) {
 			/* TODO: Make this an error in C99 mode as well. */
 			if ((!allow_trad && !allow_c99) && hflag)
 @@ -1099,29 +1099,29 @@ declare_bit_field(sym_t *dsym, tspec_t *
 		/* 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;
+	type_t *tp;
-	tspec_t	t;
+	tspec_t t;
-	int	sz;
+	int sz;
 	unsigned int o = 0;	/* Appease GCC */
 	lint_assert(is_member(dsym));
 	if (dcs->d_redeclared_symbol != NULL) {
 		lint_assert(is_member(dcs->d_redeclared_symbol));
 		if (dsym->u.s_member.sm_sou_type ==
 		    dcs->d_redeclared_symbol->u.s_member.sm_sou_type) {
 			/* duplicate member name '%s' */
 			error(33, dsym->s_name);
 			rmsym(dcs->d_redeclared_symbol);
+		}
 @@ -1447,28 +1447,28 @@ add_function(sym_t *decl, sym_t *args)
+	}
 	*tpp = block_derive_function(dcs->d_enclosing->d_type,
 	    dcs->d_proto, args, dcs->d_vararg);
 	debug_step("add_function: '%s'", type_name(decl->s_type));
 	debug_leave();
 	return decl;
+}
 static sym_t *
 new_style_function(sym_t *args)
+{
-	sym_t	*arg, *sym;
+	sym_t *arg, *sym;
-	scl_t	sc;
+	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_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);
+		}
+	}
 @@ -1531,27 +1531,27 @@ check_function_definition(sym_t *sym, bo
 		sym->u.s_old_style_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_register are valid after declarator_name().
  */
 sym_t *
 declarator_name(sym_t *sym)
+{
-	scl_t	sc = NOSCL;
+	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_kind) {
 	case DK_STRUCT_MEMBER:
 @@ -1659,28 +1659,28 @@ old_style_function_name(sym_t *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 *
 make_tag_type(sym_t *tag, tspec_t kind, bool decl, bool semi)
+{
-	scl_t	scl;
+	scl_t scl;
-	type_t	*tp;
+	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 = new_tag(tag, scl, decl, semi);
 @@ -2284,53 +2284,53 @@ prototypes_compatible(const type_t *tp1,
 /*
  * Returns whether all parameters of a prototype are compatible with an
  * old-style function declaration.
+ *
  * This is the case if the following conditions are met:
  *	1. the prototype has a fixed number of parameters
  *	2. no parameter is of type float
  *	3. no parameter is converted to another type if integer promotion
  *	   is applied on it
  */
 static bool
 matches_no_arg_function(const type_t *tp, bool *dowarn)
+{
-	sym_t	*arg;
+	sym_t *arg;
-	tspec_t	t;
+	tspec_t t;
 	if (tp->t_vararg && 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;
+		}
+	}
 	/* FIXME: Always returning true cannot be correct. */
 	return true;
+}
 /*
  * Compares a prototype declaration with the remembered arguments of
  * a previous old-style function definition.
  */
 static bool
 check_old_style_definition(sym_t *rdsym, sym_t *dsym)
+{
-	sym_t	*args, *pargs, *arg, *parg;
+	sym_t *args, *pargs, *arg, *parg;
-	int	narg, nparg, n;
+	int narg, nparg, n;
-	bool	dowarn, msg;
+	bool dowarn, msg;
 	args = rdsym->u.s_old_style_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 */
 @@ -2613,28 +2613,28 @@ check_func_old_style_arguments(void)
 		funcsym->s_osdef = false;
 		funcsym->u.s_old_style_args = NULL;
+	}
+}
 /*
  * Checks compatibility of an old-style function definition with a previous
  * prototype declaration.
  * Returns true if the position of the previous declaration should be reported.
  */
 static bool
 check_prototype_declaration(sym_t *arg, sym_t *parg)
+{
-	type_t	*tp, *ptp;
+	type_t *tp, *ptp;
-	bool	dowarn;
+	bool dowarn;
 	tp = arg->s_type;
 	ptp = parg->s_type;
 	dowarn = false;
 	if (!types_compatible(tp, ptp, true, true, &dowarn)) {
 		if (types_compatible(tp, ptp, true, false, &dowarn)) {
 			/* type of '%s' does not match prototype */
 			return gnuism(58, arg->s_name);
 		} else {
 			/* type of '%s' does not match prototype */
 			error(58, arg->s_name);
 @@ -2849,27 +2849,27 @@ declare_external_in_block(sym_t *dsym)
 		 * 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;
+	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) {
 		if (dcs->d_kind == DK_EXTERN) {
 @@ -2881,27 +2881,27 @@ check_init(sym_t *sym)
 			erred = true;
+		}
+	}
 	return erred;
+}
 /*
  * Create a symbol for an abstract declaration.
  */
 sym_t *
 abstract_name(void)
+{
-	sym_t	*sym;
+	sym_t *sym;
 	lint_assert(dcs->d_kind == DK_ABSTRACT ||
 	    dcs->d_kind == DK_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_kind == DK_PROTO_ARG)
 		sym->s_arg = true;
 @@ -3061,28 +3061,28 @@ check_argument_usage(bool novar, sym_t *
 	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;
+	scl_t sc;
-	sym_t	*xsym;
+	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
 @@ -3186,27 +3186,27 @@ check_tag_usage(sym_t *sym)
+}
 /*
  * Called after the entire translation unit has been parsed.
  * Changes tentative definitions into definitions.
  * Performs some tests on global symbols. Detected problems are:
  * - defined variables of incomplete type
  * - constant variables which are not initialized
  * - static symbols which are never used
  */
 void
 check_global_symbols(void)
+{
-	sym_t	*sym;
+	sym_t *sym;
 	if (block_level != 0 || dcs->d_enclosing != NULL)
 		norecover();
 	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);
 @@ -3328,28 +3328,28 @@ print_previous_declaration(const sym_t *
 /*
  * 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;
+	int i;
-	tspec_t	t;
+	tspec_t t;
 	if (tn == NULL)
 		return 1;
 	val_t *v = constant(tn, required);
 	/*
 	 * 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_kind != DK_ABSTRACT)

--- src/usr.bin/xlint/lint1/emit1.c 2023/04/22 17:49:15	1.66
+++ src/usr.bin/xlint/lint1/emit1.c 2023/06/09 13:03:49	1.67

 @@ -1,14 +1,14 @@
-/* $NetBSD: emit1.c,v 1.66 2023/04/22 17:49:15 rillig Exp $ */
+/* $NetBSD: emit1.c,v 1.67 2023/06/09 13:03:49 rillig Exp $ */
 /*
  * Copyright (c) 1996 Christopher G. Demetriou.  All Rights Reserved.
  * Copyright (c) 1994, 1995 Jochen Pohl
  * All Rights Reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
 @@ -28,27 +28,27 @@
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID)
-__RCSID("$NetBSD: emit1.c,v 1.66 2023/04/22 17:49:15 rillig Exp $");
+__RCSID("$NetBSD: emit1.c,v 1.67 2023/06/09 13:03:49 rillig Exp $");
 #endif
 #include "lint1.h"
 static	void	outtt(sym_t *, sym_t *);
 static	void	outfstrg(strg_t *);
 /*
  * Write type into the output buffer.
  * The type is written as a sequence of substrings, each of which describes a
  * node of type type_t
  * a node is encoded as follows:
  *	_Bool			B
 @@ -90,29 +90,29 @@ static	void	outfstrg(strg_t *);
  * and 'v' (for volatile)
  */
 void
 outtype(const type_t *tp)
+{
 	/* Available letters: ------GH--K-MNO--R--U-W-YZ */
 #ifdef INT128_SIZE
 	static const char tt[NTSPEC] = "???BCCCSSIILLQQJJDDDVTTTPAF?XXX";
 	static const char ss[NTSPEC] = "???  su u u u u us l sue   ?s l";
 #else
 	static const char tt[NTSPEC] = "???BCCCSSIILLQQDDDVTTTPAF?XXX";
 	static const char ss[NTSPEC] = "???  su u u u us l sue   ?s l";
 #endif
-	int	na;
+	int na;
-	sym_t	*arg;
+	sym_t *arg;
-	tspec_t	ts;
+	tspec_t ts;
 	while (tp != NULL) {
 		if ((ts = tp->t_tspec) == INT && tp->t_is_enum)
 			ts = ENUM;
 		lint_assert(tt[ts] != '?' && ss[ts] != '?');
 		if (tp->t_const)
 			outchar('c');
 		if (tp->t_volatile)
 			outchar('v');
 		if (ss[ts] != ' ')
 			outchar(ss[ts]);
 		outchar(tt[ts]);
 @@ -341,30 +341,30 @@ outfdef(const sym_t *fsym, const pos_t *
+}
 /*
  * write out all information necessary for lint2 to check function
  * calls
+ *
  * retval_used is set if the return value is used (assigned to a variable)
  * retval_discarded is set if the return value is neither used nor ignored
  * (that is, cast to void)
  */
 void
 outcall(const tnode_t *tn, bool retval_used, bool retval_discarded)
+{
-	tnode_t	*args, *arg;
+	tnode_t *args, *arg;
-	int	narg, n, i;
+	int narg, n, i;
-	int64_t	q;
+	int64_t q;
-	tspec_t	t;
+	tspec_t t;
 	/* reset buffer */
 	outclr();
 	/*
 	 * line number of .c source, 'c' for function call, Id of current
 	 * source (.c or .h), and line in current source
 	 */
 	outint(csrc_pos.p_line);
 	outchar('c');
 	outint(get_filename_id(curr_pos.p_file));
 	outchar('.');
 	outint(curr_pos.p_line);
 @@ -479,27 +479,27 @@ outqchar(char c)
 		outchar((char)((c & 07) + '0'));
 		break;
+	}
+}
 /*
  * extracts potential format specifiers for printf() and scanf() and
  * writes them, enclosed in "" and quoted if necessary, to the output buffer
  */
 static void
 outfstrg(strg_t *strg)
+{
 	char c, oc;
-	bool	first;
+	bool first;
 	const char *cp;
 	lint_assert(strg->st_char);
 	cp = strg->st_mem;
 	outchar('"');
 	c = *cp++;
 	while (c != '\0') {
 		if (c != '%') {
 			c = *cp++;

--- src/usr.bin/xlint/lint1/err.c 2023/06/03 21:08:06	1.197
+++ src/usr.bin/xlint/lint1/err.c 2023/06/09 13:03:49	1.198

 @@ -1,14 +1,14 @@
-/*	$NetBSD: err.c,v 1.197 2023/06/03 21:08:06 rillig Exp $	*/
+/*	$NetBSD: err.c,v 1.198 2023/06/09 13:03:49 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.
 @@ -27,27 +27,27 @@
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID)
-__RCSID("$NetBSD: err.c,v 1.197 2023/06/03 21:08:06 rillig Exp $");
+__RCSID("$NetBSD: err.c,v 1.198 2023/06/09 13:03:49 rillig Exp $");
 #endif
 #include <limits.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 /* number of errors found */
 int	nerr;
 /* number of syntax errors */
 @@ -509,43 +509,43 @@ lbasename(const char *path)
 	if (Fflag)
 		return path;
 	const char *base = path;
 	for (const char *p = path; *p != '\0'; p++)
 		if (*p == '/')
 			base = p + 1;
 	return base;
+}
 static void
 verror_at(int msgid, const pos_t *pos, va_list ap)
+{
-	const	char *fn;
+	const char *fn;
 	if (is_suppressed[msgid])
 		return;
 	fn = lbasename(pos->p_file);
 	(void)printf("%s(%d): error: ", fn, pos->p_line);
 	(void)vprintf(msgs[msgid], ap);
 	(void)printf(" [%d]\n", msgid);
 	nerr++;
 	print_stack_trace();
+}
 static void
 vwarning_at(int msgid, const pos_t *pos, va_list ap)
+{
-	const	char *fn;
+	const char *fn;
 	if (is_suppressed[msgid])
 		return;
 	debug_step("%s: lwarn=%d msgid=%d", __func__, lwarn, msgid);
 	if (lwarn == LWARN_NONE || lwarn == msgid)
 		/* this warning is suppressed by a LINTED comment */
 		return;
 	fn = lbasename(pos->p_file);
 	(void)printf("%s(%d): warning: ", fn, pos->p_line);
 	(void)vprintf(msgs[msgid], ap);
 	(void)printf(" [%d]\n", msgid);
 @@ -562,47 +562,47 @@ vmessage_at(int msgid, const pos_t *pos,
 	if (is_suppressed[msgid])
 		return;
 	fn = lbasename(pos->p_file);
 	(void)printf("%s(%d): ", fn, pos->p_line);
 	(void)vprintf(msgs[msgid], ap);
 	(void)printf(" [%d]\n", msgid);
 	print_stack_trace();
+}
 void
 (error_at)(int msgid, const pos_t *pos, ...)
+{
-	va_list	ap;
+	va_list ap;
 	va_start(ap, pos);
 	verror_at(msgid, pos, ap);
 	va_end(ap);
+}
 void
 (error)(int msgid, ...)
+{
-	va_list	ap;
+	va_list ap;
 	va_start(ap, msgid);
 	verror_at(msgid, &curr_pos, ap);
 	va_end(ap);
+}
 void
 assert_failed(const char *file, int line, const char *func, const char *cond)
+{
-	const	char *fn;
+	const char *fn;
 	/*
 	 * After encountering a parse error in the grammar, lint often does
 	 * not properly clean up its data structures, especially in 'dcs',
 	 * the stack of declaration levels.  This often leads to assertion
 	 * failures.  These cases are not interesting though, as the purpose
 	 * of lint is to check syntactically valid code.  In such a case,
 	 * exit gracefully.  This allows a fuzzer like afl to focus on more
 	 * interesting cases instead of reporting nonsense translation units
 	 * like 'f=({e:;}' or 'v(const(char););e(v){'.
 	 */
 	if (sytxerr > 0)
 		norecover();
 @@ -610,87 +610,87 @@ assert_failed(const char *file, int line
 	fn = lbasename(curr_pos.p_file);
 	(void)fflush(stdout);
 	(void)fprintf(stderr,
 	    "lint: assertion \"%s\" failed in %s at %s:%d near %s:%d\n",
 	    cond, func, file, line, fn, curr_pos.p_line);
 	print_stack_trace();
 	(void)fflush(stdout);
 	abort();
+}
 void
 (warning_at)(int msgid, const pos_t *pos, ...)
+{
-	va_list	ap;
+	va_list ap;
 	va_start(ap, pos);
 	vwarning_at(msgid, pos, ap);
 	va_end(ap);
+}
 void
 (warning)(int msgid, ...)
+{
-	va_list	ap;
+	va_list ap;
 	va_start(ap, msgid);
 	vwarning_at(msgid, &curr_pos, ap);
 	va_end(ap);
+}
 void
 (message_at)(int msgid, const pos_t *pos, ...)
+{
 	va_list ap;
 	va_start(ap, pos);
 	vmessage_at(msgid, pos, ap);
 	va_end(ap);
+}
 void
 (c99ism)(int msgid, ...)
+{
-	va_list	ap;
+	va_list ap;
 	if (allow_c99)
 		return;
 	va_start(ap, msgid);
 	int severity = (!allow_gcc ? 1 : 0) + (!allow_trad ? 1 : 0);
 	if (severity == 2)
 		verror_at(msgid, &curr_pos, ap);
 	if (severity == 1)
 		vwarning_at(msgid, &curr_pos, ap);
 	va_end(ap);
+}
 void
 (c11ism)(int msgid, ...)
+{
-	va_list	ap;
+	va_list ap;
 	/* FIXME: C11 mode has nothing to do with GCC mode. */
 	if (allow_c11 || allow_gcc)
 		return;
 	va_start(ap, msgid);
 	verror_at(msgid, &curr_pos, ap);
 	va_end(ap);
+}
 bool
 (gnuism)(int msgid, ...)
+{
-	va_list	ap;
+	va_list ap;
 	int severity = (!allow_gcc ? 1 : 0) +
 	    (!allow_trad && !allow_c99 ? 1 : 0);
 	va_start(ap, msgid);
 	if (severity == 2)
 		verror_at(msgid, &curr_pos, ap);
 	if (severity == 1)
 		vwarning_at(msgid, &curr_pos, ap);
 	va_end(ap);
 	return severity > 0;
+}

--- src/usr.bin/xlint/lint1/func.c 2023/05/11 08:01:36	1.154
+++ src/usr.bin/xlint/lint1/func.c 2023/06/09 13:03:49	1.155

 @@ -1,14 +1,14 @@
-/*	$NetBSD: func.c,v 1.154 2023/05/11 08:01:36 rillig Exp $	*/
+/*	$NetBSD: func.c,v 1.155 2023/06/09 13:03:49 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.
 @@ -27,27 +27,27 @@
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID)
-__RCSID("$NetBSD: func.c,v 1.154 2023/05/11 08:01:36 rillig Exp $");
+__RCSID("$NetBSD: func.c,v 1.155 2023/06/09 13:03:49 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;
 @@ -210,29 +210,29 @@ check_statement_reachable(void)
 /*
  * 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
 begin_function(sym_t *fsym)
+{
-	int	n;
+	int n;
-	bool	dowarn;
+	bool dowarn;
-	sym_t	*arg, *sym, *rdsym;
+	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_level_next) {
 		if (sym->s_block_level != -1) {
 			lint_assert(sym->s_block_level == 1);
 			inssym(1, sym);
+		}
 @@ -360,28 +360,28 @@ check_missing_return_value(void)
 	if (allow_c99 && 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
 end_function(void)
+{
-	sym_t	*arg;
+	sym_t *arg;
-	int	n;
+	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)
 @@ -476,29 +476,29 @@ check_case_label_enum(const tnode_t *tn,
 		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 *v;
-	val_t	nv;
+	val_t nv;
-	tspec_t	t;
+	tspec_t t;
 	if (cs == NULL) {
 		/* case not in switch */
 		error(195);
 		return;
+	}
 	if (tn == NULL)
 		return;
 	if (tn->tn_op != CON) {
 		/* non-constant case expression */
 		error(197);
 @@ -677,28 +677,28 @@ if3(bool els)
 		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;
+	tspec_t t;
-	type_t	*tp;
+	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 && !allow_c90) {
 		t = tn->tn_type->t_tspec;
 		if (t == LONG || t == ULONG || t == QUAD || t == UQUAD) {
 @@ -733,28 +733,28 @@ switch1(tnode_t *tn)
 	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;
+	int nenum = 0, nclab = 0;
-	sym_t	*esym;
+	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) {
 @@ -936,28 +936,28 @@ for1(tnode_t *tn1, tnode_t *tn2, tnode_t
 	/* 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;
+	pos_t cpos, cspos;
-	tnode_t	*tn3;
+	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;

--- src/usr.bin/xlint/lint1/lex.c 2023/04/11 00:03:42	1.158
+++ src/usr.bin/xlint/lint1/lex.c 2023/06/09 13:03:49	1.159

 @@ -1,14 +1,14 @@
-/* $NetBSD: lex.c,v 1.158 2023/04/11 00:03:42 rillig Exp $ */
+/* $NetBSD: lex.c,v 1.159 2023/06/09 13:03:49 rillig Exp $ */
 /*
  * Copyright (c) 1996 Christopher G. Demetriou.  All Rights Reserved.
  * Copyright (c) 1994, 1995 Jochen Pohl
  * All Rights Reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
 @@ -28,27 +28,27 @@
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID)
-__RCSID("$NetBSD: lex.c,v 1.158 2023/04/11 00:03:42 rillig Exp $");
+__RCSID("$NetBSD: lex.c,v 1.159 2023/06/09 13:03:49 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"
 @@ -395,27 +395,27 @@ initscan(void)
 			add_keyword(kw, true, true);
+	}
+}
 /*
  * When scanning the remainder of a long token (see lex_input), read a byte
  * and return it as an unsigned char or as EOF.
+ *
  * Increment the line counts if necessary.
  */
 static int
 read_byte(void)
+{
-	int	c;
+	int c;
 	if ((c = lex_input()) == EOF)
 		return c;
 	if (c == '\0')
 		return EOF;	/* lex returns 0 on EOF. */
 	if (c == '\n')
 		lex_next_line();
 	return c;
+}
 static int
 lex_keyword(sym_t *sym)
+{
 @@ -837,27 +837,27 @@ get_escaped_char(int delim)
 		return -2;
 	case '\\':
 		c = read_escaped_backslash(delim);
 		if (c == -3)
 			return get_escaped_char(delim);
+	}
 	return c;
+}
 /* Called if lex found a leading "'". */
 int
 lex_character_constant(void)
+{
-	size_t	n;
+	size_t n;
 	int val, c;
 	n = 0;
 	val = 0;
 	while ((c = get_escaped_char('\'')) >= 0) {
 		val = (int)((unsigned int)val << CHAR_SIZE) + c;
 		n++;
+	}
 	if (c == -2) {
 		/* unterminated character constant */
 		error(253);
 	} else if (n > sizeof(int) || (n > 1 && (pflag || hflag))) {
 		/*
 @@ -879,30 +879,30 @@ lex_character_constant(void)
 	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];
+	static char buf[MB_LEN_MAX + 1];
-	size_t	n, nmax;
+	size_t n, nmax;
 	int c;
-	wchar_t	wc;
+	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) {
 @@ -959,33 +959,33 @@ parse_line_directive_flags(const char *p
+	}
+}
 /*
  * 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;
+	const char *cp, *fn;
-	char	c, *eptr;
+	char c, *eptr;
-	size_t	fnl;
+	size_t fnl;
-	long	ln;
+	long ln;
-	bool	is_begin, is_end, is_system;
+	bool is_begin, is_end, is_system;
-	static	bool first = true;
+	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;
+	}
 @@ -1060,30 +1060,30 @@ lex_comment(void)
 		{ "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 keywd[32];
-	char	arg[32];
+	char arg[32];
-	size_t	l, i;
+	size_t l, i;
-	int	a;
+	int a;
 	bool seen_end_of_comment = false;
 	/* Skip whitespace after the start of the comment */
 	while (c = read_byte(), 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;
 @@ -1165,28 +1165,28 @@ lex_slash_slash_comment(void)
 void
 clear_warn_flags(void)
+{
 	lwarn = LWARN_ALL;
 	quadflg = false;
 	constcond_flag = false;
+}
 int
 lex_string(void)
+{
 	unsigned char *s;
-	int	c;
+	int c;
-	size_t	len, max;
+	size_t len, max;
 	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 */
 @@ -1194,27 +1194,27 @@ lex_string(void)
 	strg_t *strg = xcalloc(1, sizeof(*strg));
 	strg->st_char = true;
 	strg->st_len = len;
 	strg->st_mem = s;
 	yylval.y_string = strg;
 	return T_STRING;
+}
 int
 lex_wide_string(void)
+{
-	int	c, n;
+	int c, n;
 	size_t len = 0, max = 64;
 	char *s = xmalloc(max);
 	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);
 @@ -1222,27 +1222,27 @@ lex_wide_string(void)
 	/* get length of wide-character string */
 	(void)mblen(NULL, 0);
 	size_t wlen = 0;
 	for (size_t i = 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;
+	}
-	wchar_t	*ws = xmalloc((wlen + 1) * sizeof(*ws));
+	wchar_t *ws = xmalloc((wlen + 1) * sizeof(*ws));
 	size_t wi = 0;
 	/* convert from multibyte to wide char */
 	(void)mbtowc(NULL, NULL, 0);
 	for (size_t i = 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_t *strg = xcalloc(1, sizeof(*strg));
 @@ -1303,27 +1303,27 @@ getsym(sbuf_t *sb)
 			sym = symtab_search(sb->sb_name);
+	}
 	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) */
-	dinfo_t	*di;
+	dinfo_t *di;
 	if (symtyp == FLABEL) {
 		sym = level_zero_alloc(1, sizeof(*sym));
 		char *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_enclosing != NULL &&
 		    di->d_enclosing->d_enclosing != NULL)
 			di = di->d_enclosing;
 		lint_assert(di->d_kind == DK_AUTO);
 	} else {
 		sym = block_zero_alloc(sizeof(*sym));
 @@ -1393,27 +1393,27 @@ rmsym(sym_t *sym)
 	symtab_remove(sym);
 	/* avoid that the symbol will later be put back to the symbol table */
 	sym->s_block_level = -1;
+}
 /*
  * Remove all symbols from the symbol table that have the same level as the
  * given symbol.
  */
 void
 rmsyms(sym_t *syms)
+{
-	sym_t	*sym;
+	sym_t *sym;
 	/* Note the use of s_level_next instead of s_symtab_next. */
 	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_symtab_ref = NULL;
+		}
+	}
+}
 @@ -1442,27 +1442,27 @@ void
 clean_up_after_error(void)
+{
 	symtab_remove_locals();
 	while (mem_block_level > 0)
 		level_free_all(mem_block_level--);
+}
 /* Create a new symbol with the same name as an existing symbol. */
 sym_t *
 pushdown(const sym_t *sym)
+{
-	sym_t	*nsym;
+	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;

--- src/usr.bin/xlint/lint1/tree.c 2023/06/03 20:28:54	1.525
+++ src/usr.bin/xlint/lint1/tree.c 2023/06/09 13:03:49	1.526

 @@ -1,14 +1,14 @@
-/*	$NetBSD: tree.c,v 1.525 2023/06/03 20:28:54 rillig Exp $	*/
+/*	$NetBSD: tree.c,v 1.526 2023/06/09 13:03:49 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.
 @@ -27,27 +27,27 @@
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID)
-__RCSID("$NetBSD: tree.c,v 1.525 2023/06/03 20:28:54 rillig Exp $");
+__RCSID("$NetBSD: tree.c,v 1.526 2023/06/09 13:03:49 rillig Exp $");
 #endif
 #include <float.h>
 #include <limits.h>
 #include <math.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 typedef struct integer_constraints {
 @@ -305,42 +305,42 @@ ic_expr(const tnode_t *tn)
 	case QUEST:
 		lc = ic_expr(tn->tn_right->tn_left);
 		rc = ic_expr(tn->tn_right->tn_right);
 		return ic_cond(lc, rc);
 	default:
 		return ic_any(tn->tn_type);
+	}
+}
 /* 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;
+	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;
+	type_t *tp2;
 	tp2 = expr_zero_alloc(sizeof(*tp2));
 	tp2->t_tspec = t;
 	tp2->t_subt = tp;
 	return tp2;
+}
 /*
  * Build and initialize a new node.
  */
 static tnode_t *
 new_tnode(op_t op, bool sys, type_t *type, tnode_t *ln, tnode_t *rn)
+{
 @@ -358,43 +358,43 @@ new_tnode(op_t op, bool sys, type_t *typ
 		if (t != FUNC && t != VOID)
 			ntn->tn_lvalue = true;
+	}
 	return ntn;
+}
 /*
  * Create a node for a constant.
  */
 tnode_t *
 build_constant(type_t *tp, val_t *v)
+{
-	tnode_t	*n;
+	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;
+	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)
+{
 @@ -479,27 +479,27 @@ build_name_call(sym_t *sym)
 	} else if (!allow_trad) {
 		/* function '%s' implicitly declared to return int */
 		warning(215, sym->s_name);
+	}
 	/* XXX if !allow_c90, 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;
+	tnode_t *n;
 	if (sym->s_scl == NOSCL && !in_gcc_attribute) {
 		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();
 @@ -517,28 +517,28 @@ build_name(sym_t *sym, bool is_funcname)
 	} 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;
+	size_t len;
-	tnode_t	*n;
+	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_char ? CHAR : WCHAR);
 	tp->t_dim = (int)(len + 1);
 	n->tn_op = STRING;
 	n->tn_type = tp;
 @@ -579,27 +579,27 @@ static bool
 is_out_of_char_range(const tnode_t *tn)
+{
 	return tn->tn_op == CON &&
 	       !(0 <= tn->tn_val->v_quad &&
 		 tn->tn_val->v_quad < 1 << (CHAR_SIZE - 1));
+}
 /*
  * Check for ordered comparisons of unsigned values with 0.
  */
 static void
 check_integer_comparison(op_t op, tnode_t *ln, tnode_t *rn)
+{
-	tspec_t	lt, rt;
+	tspec_t lt, rt;
 	lt = ln->tn_type->t_tspec;
 	rt = rn->tn_type->t_tspec;
 	if (ln->tn_op != CON && rn->tn_op != CON)
 		return;
 	if (!is_integer(lt) || !is_integer(rt))
 		return;
 	if (hflag || pflag) {
 		if (lt == CHAR && is_out_of_char_range(rn)) {
 			char buf[128];
 @@ -743,27 +743,27 @@ balance(op_t op, tnode_t **lnp, tnode_t
 	if (t != lt)
 		*lnp = apply_usual_arithmetic_conversions(op, *lnp, t);
 	if (t != rt)
 		*rnp = apply_usual_arithmetic_conversions(op, *rnp, t);
+}
 /*
  * Create a tree node for the unary & operator
  */
 static tnode_t *
 build_address(bool sys, tnode_t *tn, bool noign)
+{
-	tspec_t	t;
+	tspec_t t;
 	if (!noign && ((t = tn->tn_type->t_tspec) == ARRAY || t == FUNC)) {
 		if (!allow_c90)
 			/* '&' before array or function: ignored */
 			warning(127);
 		return tn;
+	}
 	/* eliminate &* */
 	if (tn->tn_op == INDIR &&
 	    tn->tn_left->tn_type->t_tspec == PTR &&
 	    tn->tn_left->tn_type->t_subt == tn->tn_type) {
 		return tn->tn_left;
 @@ -922,28 +922,28 @@ fold(tnode_t *tn)
 		cn->tn_system_dependent = true;
 	if (is_binary(tn) && tn->tn_right->tn_system_dependent)
 		cn->tn_system_dependent = true;
 	return cn;
+}
 /*
  * Create a new node for one of the operators POINT and ARROW.
  */
 static tnode_t *
 build_struct_access(op_t op, bool sys, tnode_t *ln, tnode_t *rn)
+{
-	tnode_t	*ntn, *ctn;
+	tnode_t *ntn, *ctn;
-	bool	nolval;
+	bool nolval;
 	lint_assert(rn->tn_op == NAME);
 	lint_assert(is_member(rn->tn_sym));
 	/*
 	 * Remember if the left operand is an lvalue (structure members
 	 * are lvalues if and only if the structure itself is an lvalue).
 	 */
 	nolval = op == POINT && !ln->tn_lvalue;
 	if (op == POINT) {
 		ln = build_address(sys, ln, true);
 	} else if (ln->tn_type->t_tspec != PTR) {
 @@ -1031,27 +1031,27 @@ subt_size_in_bytes(type_t *tp)
 	if (elsz_in_bits == 0)
 		elsz_in_bits = CHAR_SIZE;
 	return build_integer_constant(PTRDIFF_TSPEC,
 	    (int64_t)(elem * elsz_in_bits / CHAR_SIZE));
+}
 /*
  * Create a node for INCAFT, INCBEF, DECAFT and DECBEF.
  */
 static tnode_t *
 build_prepost_incdec(op_t op, bool sys, tnode_t *ln)
+{
-	tnode_t	*cn, *ntn;
+	tnode_t *cn, *ntn;
 	lint_assert(ln != NULL);
 	if (ln->tn_type->t_tspec == PTR) {
 		cn = subt_size_in_bytes(ln->tn_type);
 	} else {
 		cn = build_integer_constant(INT, (int64_t)1);
+	}
 	ntn = new_tnode(op, sys, ln->tn_type, ln, cn);
 	return ntn;
+}
 @@ -1203,28 +1203,28 @@ merge_qualifiers(type_t *tp1, const type
 	nstp = expr_dup_type(tp1->t_subt);
 	nstp->t_const |= c2;
 	nstp->t_volatile |= v2;
 	ntp = expr_dup_type(tp1);
 	ntp->t_subt = nstp;
 	return ntp;
+}
 /* See C99 6.5.15 "Conditional operator". */
 static tnode_t *
 build_colon(bool sys, tnode_t *ln, tnode_t *rn)
+{
-	tspec_t	lt, rt;
+	tspec_t lt, rt;
-	type_t	*tp;
+	type_t *tp;
 	lt = ln->tn_type->t_tspec;
 	rt = rn->tn_type->t_tspec;
 	if (is_arithmetic(lt) && is_arithmetic(rt)) {
 		/* The operands were already balanced in build_binary. */
 		tp = ln->tn_type;
 	} else if (lt == BOOL && rt == BOOL) {
 		tp = ln->tn_type;
 	} else if (lt == VOID || rt == VOID) {
 		tp = gettyp(VOID);
 	} else if (is_struct_or_union(lt)) {
 		/* Both types must be identical. */
 @@ -1318,28 +1318,28 @@ is_assignment(op_t op)
 	       op == SHLASS ||
 	       op == SHRASS ||
 	       op == ANDASS ||
 	       op == XORASS ||
 	       op == ORASS ||
 	       op == RETURN ||
 	       op == INIT;
+}
 /* Create a node for an assignment operator (both '=' and 'op='). */
 static tnode_t *
 build_assignment(op_t op, bool sys, tnode_t *ln, tnode_t *rn)
+{
-	tspec_t	lt, rt;
+	tspec_t lt, rt;
-	tnode_t	*ntn, *ctn;
+	tnode_t *ntn, *ctn;
 	lt = ln->tn_type->t_tspec;
 	rt = rn->tn_type->t_tspec;
 	if (any_query_enabled && is_assignment(rn->tn_op)) {
 		/* chained assignment with '%s' and '%s' */
 		query_message(10, op_name(op), op_name(rn->tn_op));
+	}
 	if ((op == ADDASS || op == SUBASS) && lt == PTR) {
 		lint_assert(is_integer(rt));
 		ctn = subt_size_in_bytes(ln->tn_type);
 		if (rn->tn_type->t_tspec != ctn->tn_type->t_tspec)
 @@ -1390,27 +1390,27 @@ build_assignment(op_t op, bool sys, tnod
+	}
 	ntn = new_tnode(op, sys, ln->tn_type, ln, rn);
 	return ntn;
+}
 /*
  * Create a node for REAL, IMAG
  */
 static tnode_t *
 build_real_imag(op_t op, bool sys, tnode_t *ln)
+{
-	tnode_t	*cn, *ntn;
+	tnode_t *cn, *ntn;
 	lint_assert(ln != NULL);
 	if (ln->tn_op == NAME) {
 		/*
 		 * This may be too much, but it avoids wrong warnings.
 		 * See d_c99_complex_split.c.
 		 */
 		mark_as_used(ln->tn_sym, false, false);
 		mark_as_set(ln->tn_sym);
+	}
 	switch (ln->tn_type->t_tspec) {
 @@ -1501,28 +1501,28 @@ check_precedence_confusion(tnode_t *tn)
 	    ln->tn_op, ln->tn_parenthesized,
 	    rn->tn_op, rn->tn_parenthesized)) {
 		/* precedence confusion possible: parenthesize! */
 		warning(169);
+	}
+}
 /*
  * Fold constant nodes, as much as is needed for comparing the value with 0.
  */
 static tnode_t *
 fold_bool(tnode_t *tn)
+{
-	bool	l, r;
+	bool l, r;
-	val_t	*v;
+	val_t *v;
 	v = xcalloc(1, sizeof(*v));
 	v->v_tspec = tn->tn_type->t_tspec;
 	lint_assert(v->v_tspec == INT || (Tflag && v->v_tspec == BOOL));
 	l = constant_is_nonzero(tn->tn_left);
 	r = is_binary(tn) && constant_is_nonzero(tn->tn_right);
 	switch (tn->tn_op) {
 	case NOT:
 		if (hflag && !constcond_flag)
 			/* constant argument to '!' */
 			warning(239);
 @@ -1566,29 +1566,29 @@ floating_error_value(tspec_t t, ldbl_t l
 	 * few programs practically use 'long double'.
 	 */
 	/* LINTED 248: floating-point constant out of range */
 	ldbl_t max = LDBL_MAX;
 	return lv < 0 ? -max : max;
+}
 /*
  * Fold constant nodes having operands with floating point type.
  */
 static tnode_t *
 fold_float(tnode_t *tn)
+{
-	val_t	*v;
+	val_t *v;
-	tspec_t	t;
+	tspec_t t;
-	ldbl_t	lv, rv = 0;
+	ldbl_t lv, rv = 0;
 	fpe = 0;
 	v = xcalloc(1, sizeof(*v));
 	v->v_tspec = t = tn->tn_type->t_tspec;
 	lint_assert(is_floating(t));
 	lint_assert(t == tn->tn_left->tn_type->t_tspec);
 	lint_assert(!is_binary(tn) || t == tn->tn_right->tn_type->t_tspec);
 	lv = tn->tn_left->tn_val->v_ldbl;
 	if (is_binary(tn))
 		rv = tn->tn_right->tn_val->v_ldbl;
 @@ -1660,28 +1660,28 @@ fold_float(tnode_t *tn)
 	return build_constant(tn->tn_type, v);
+}
 /*
  * 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;
+	tnode_t *ntn;
-	type_t	*rettp;
+	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 zero.
 	 */
 	if (mp->m_value_context || mp->m_compares_with_zero)
 		ln = cconv(ln);
 @@ -1886,29 +1886,29 @@ all_members_compatible(const sym_t *msym
+			}
+		}
+	}
 	return true;
+}
 /*
  * 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;
+	struct_or_union *str;
-	type_t	*tp;
+	type_t *tp;
-	tspec_t	t;
+	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 = STRUCT_MEMBER;
 		struct_or_union *sou = expr_zero_alloc(sizeof(*sou));
 @@ -1993,27 +1993,27 @@ struct_or_union_member(tnode_t *tn, op_t
 			error(105, op == POINT ? "object" : "pointer");
 		} else {
 			/* unacceptable operand of '%s' */
 			error(111, op_name(op));
+		}
+	}
 	return msym;
+}
 tnode_t *
 build_member_access(tnode_t *ln, op_t op, bool sys, sbuf_t *member)
+{
-	sym_t	*msym;
+	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));
+}
 /*
 @@ -2859,28 +2859,28 @@ warn_assign(op_t op, int arg,
 		break;
+	}
+}
 /*
  * Checks type compatibility for ASSIGN, INIT, FARG and RETURN
  * and prints warnings/errors if necessary.
  * Returns whether the types are (almost) compatible.
  */
 static bool
 check_assign_types_compatible(op_t op, int arg,
 			      const tnode_t *ln, const tnode_t *rn)
+{
-	tspec_t	lt, rt, lst = NO_TSPEC, rst = NO_TSPEC;
+	tspec_t lt, rt, lst = NO_TSPEC, rst = NO_TSPEC;
-	type_t	*ltp, *rtp, *lstp = NULL, *rstp = NULL;
+	type_t *ltp, *rtp, *lstp = NULL, *rstp = NULL;
 	if ((lt = (ltp = ln->tn_type)->t_tspec) == PTR)
 		lst = (lstp = ltp->t_subt)->t_tspec;
 	if ((rt = (rtp = rn->tn_type)->t_tspec) == PTR)
 		rst = (rstp = rtp->t_subt)->t_tspec;
 	if (lt == BOOL && is_scalar(rt))	/* C99 6.3.1.2 */
 		return true;
 	if (is_arithmetic(lt) && (is_arithmetic(rt) || rt == BOOL))
 		return true;
 	if (is_struct_or_union(lt) && is_struct_or_union(rt))
 @@ -3178,28 +3178,28 @@ typeok_enum(op_t op, const mod_t *mp, in
 	} 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)
+{
-	tspec_t	lt, rt;
+	tspec_t lt, rt;
-	type_t	*ltp, *rtp;
+	type_t *ltp, *rtp;
 	const mod_t *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 = NO_TSPEC;
+	}
 @@ -4128,27 +4128,27 @@ cast_to_union(tnode_t *otn, type_t *ntp)
+	}
 	/* type '%s' is not a member of '%s' */
 	error(329, type_name(otn->tn_type), type_name(ntp));
 	return NULL;
+}
 /*
  * Type casts.
  */
 tnode_t *
 cast(tnode_t *tn, type_t *tp)
+{
-	tspec_t	nt, ot;
+	tspec_t nt, ot;
 	if (tn == NULL)
 		return NULL;
 	tn = cconv(tn);
 	lint_assert(tp != NULL);
 	nt = tp->t_tspec;
 	ot = tn->tn_type->t_tspec;
 	if (nt == VOID) {
 		/*
 		 * C90 6.3.4, C99 6.5.4p2 and C11 6.5.4p2 allow any type to
 @@ -4221,50 +4221,50 @@ build_function_argument(tnode_t *args, t
 /*
  * Compare the type of an argument with the corresponding type of a
  * prototype parameter. If it is a valid combination, but both types
  * are not the same, insert a conversion to convert the argument into
  * the type of the parameter.
  */
 static tnode_t *
 check_prototype_argument(
 	int	n,		/* pos of arg */
 	type_t	*tp,		/* expected type (from prototype) */
 	tnode_t	*tn)		/* argument */
+{
-	tnode_t	*ln = xcalloc(1, sizeof(*ln));
+	tnode_t *ln = xcalloc(1, sizeof(*ln));
 	ln->tn_type = expr_unqualified_type(tp);
 	ln->tn_lvalue = true;
 	if (typeok(FARG, n, ln, tn)) {
 		bool dowarn;
 		if (!types_compatible(tp, tn->tn_type,
 		    true, false, (dowarn = false, &dowarn)) || dowarn)
 			tn = convert(FARG, n, tp, tn);
+	}
 	free(ln);
 	return tn;
+}
 /*
  * Check types of all function arguments and insert conversions,
  * if necessary.
  */
 static tnode_t *
 check_function_arguments(type_t *ftp, tnode_t *args)
+{
-	tnode_t	*arg;
+	tnode_t *arg;
-	sym_t	*asym;
+	sym_t *asym;
-	tspec_t	at;
+	tspec_t at;
-	int	narg, npar, n, i;
+	int narg, npar, n, i;
 	/* get # of args in the prototype */
 	npar = 0;
 	for (asym = ftp->t_args; asym != NULL; asym = asym->s_next)
 		npar++;
 	/* get # of args in function call */
 	narg = 0;
 	for (arg = args; arg != NULL; arg = arg->tn_right)
 		narg++;
 	asym = ftp->t_args;
 	if (ftp->t_proto && npar != narg && !(ftp->t_vararg && npar < narg)) {
 @@ -4314,28 +4314,28 @@ check_function_arguments(type_t *ftp, tn
 			asym = asym->s_next;
+	}
 	return args;
+}
 /*
  * Create the node for a function call. Also check types of
  * function arguments and insert conversions, if necessary.
  */
 tnode_t *
 build_function_call(tnode_t *func, bool sys, tnode_t *args)
+{
-	tnode_t	*ntn;
+	tnode_t *ntn;
-	op_t	fcop;
+	op_t fcop;
 	if (func == NULL)
 		return NULL;
 	if (func->tn_op == NAME && func->tn_type->t_tspec == FUNC) {
 		fcop = CALL;
 	} else {
 		fcop = ICALL;
+	}
 	check_ctype_function_call(func, args);
 	/*
 @@ -4730,27 +4730,27 @@ check_expr_misc(const tnode_t *tn, bool
+ *
  * The expression can consist of PLUS, MINUS, ADDR, NAME, STRING and
  * CON. Type conversions are allowed if they do not change binary
  * representation (including width).
+ *
  * C99 6.6 "Constant expressions"
  * C99 6.7.8p4 restricts initializers for static storage duration
  */
 bool
 constant_addr(const tnode_t *tn, const sym_t **symp, ptrdiff_t *offsp)
+{
 	const sym_t *sym;
 	ptrdiff_t offs1, offs2;
-	tspec_t	t, ot;
+	tspec_t t, ot;
 	switch (tn->tn_op) {
 	case MINUS:
 		if (tn->tn_right->tn_op == CVT)
 			return constant_addr(tn->tn_right, symp, offsp);
 		else if (tn->tn_right->tn_op != CON)
 			return false;
 		/* FALLTHROUGH */
 	case PLUS:
 		offs1 = offs2 = 0;
 		if (tn->tn_left->tn_op == CON) {
 			offs1 = (ptrdiff_t)tn->tn_left->tn_val->v_quad;
 			if (!constant_addr(tn->tn_right, &sym, &offs2))

--- src/usr.bin/xlint/lint2/chk.c 2023/05/22 12:55:04	1.54
+++ src/usr.bin/xlint/lint2/chk.c 2023/06/09 13:03:49	1.55

 @@ -1,14 +1,14 @@
-/* $NetBSD: chk.c,v 1.54 2023/05/22 12:55:04 rillig Exp $ */
+/* $NetBSD: chk.c,v 1.55 2023/06/09 13:03:49 rillig Exp $ */
 /*
  * Copyright (c) 1996 Christopher G. Demetriou.  All Rights Reserved.
  * Copyright (c) 1994, 1995 Jochen Pohl
  * All Rights Reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
 @@ -28,27 +28,27 @@
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID)
-__RCSID("$NetBSD: chk.c,v 1.54 2023/05/22 12:55:04 rillig Exp $");
+__RCSID("$NetBSD: chk.c,v 1.55 2023/06/09 13:03:49 rillig Exp $");
 #endif
 #include <ctype.h>
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint2.h"
 static	void	check_used_not_defined(const hte_t *);
 static	void	check_defined_not_used(const hte_t *);
 static	void	check_declared_not_used_or_defined(const hte_t *);
 static	void	check_multiple_definitions(const hte_t *);
 @@ -66,39 +66,39 @@ static	void	inconsistent_arguments(const
 static	void	too_few_arguments(const hte_t *, fcall_t *);
 static	void	too_many_arguments(const hte_t *, fcall_t *);
 static	bool	types_compatible(type_t *, type_t *, bool, bool, bool, bool *);
 static	bool	prototypes_compatible(type_t *, type_t *, bool *);
 static	bool	matches_no_arg_function(type_t *, bool *);
 /*
  * If there is a symbol named "main", mark it as used.
  */
 void
 mark_main_as_used(void)
+{
-	hte_t	*hte;
+	hte_t *hte;
 	if ((hte = hsearch("main", false)) != NULL)
 		hte->h_used = true;
+}
 /*
  * Performs all tests for a single name
  */
 void
 check_name(const hte_t *hte)
+{
-	sym_t	*sym, *def, *pdecl, *decl;
+	sym_t *sym, *def, *pdecl, *decl;
 	if (uflag) {
 		check_used_not_defined(hte);
 		check_defined_not_used(hte);
 		if (xflag)
 			check_declared_not_used_or_defined(hte);
+	}
 	check_multiple_definitions(hte);
 	/* Get definition, prototype declaration and declaration */
 	def = pdecl = decl = NULL;
 	for (sym = hte->h_syms; sym != NULL; sym = sym->s_next) {
 		if (def == NULL && (sym->s_def == DEF || sym->s_def == TDEF))
 @@ -123,92 +123,92 @@ check_name(const hte_t *hte)
 	chkfaui(hte, def, decl);
 	check_return_values(hte, def);
 	check_argument_declarations(hte, def, decl);
+}
 /*
  * Print a warning if the name has been used, but not defined.
  */
 static void
 check_used_not_defined(const hte_t *hte)
+{
-	fcall_t	*fcall;
+	fcall_t *fcall;
-	usym_t	*usym;
+	usym_t *usym;
 	if (!hte->h_used || hte->h_def)
 		return;
 	if ((fcall = hte->h_calls) != NULL) {
 		/* %s used( %s ), but not defined */
 		msg(0, hte->h_name, mkpos(&fcall->f_pos));
 	} else if ((usym = hte->h_usyms) != NULL) {
 		/* %s used( %s ), but not defined */
 		msg(0, hte->h_name, mkpos(&usym->u_pos));
+	}
+}
 /*
  * Print a warning if the name has been defined, but never used.
  */
 static void
 check_defined_not_used(const hte_t *hte)
+{
-	sym_t	*sym;
+	sym_t *sym;
 	if (!hte->h_def || hte->h_used)
 		return;
 	for (sym = hte->h_syms; sym != NULL; sym = sym->s_next) {
 		if (sym->s_def == DEF || sym->s_def == TDEF) {
 			/* %s defined( %s ), but never used */
 			msg(1, hte->h_name, mkpos(&sym->s_pos));
 			break;
+		}
+	}
+}
 /*
  * Print a warning if the variable has been declared, but is not used
  * or defined.
  */
 static void
 check_declared_not_used_or_defined(const hte_t *hte)
+{
-	sym_t	*sym;
+	sym_t *sym;
 	if (hte->h_syms == NULL || hte->h_used || hte->h_def)
 		return;
 	sym = hte->h_syms;
 	if (TP(sym->s_type)->t_tspec == FUNC)
 		return;
 	if (sym->s_def != DECL)
 		errx(1, "internal error: check_declared_not_used_or_defined");
 	/* %s declared( %s ), but never used or defined */
 	msg(2, hte->h_name, mkpos(&sym->s_pos));
+}
 /*
  * Print a warning if there is more than one definition for
  * this name.
  */
 static void
 check_multiple_definitions(const hte_t *hte)
+{
-	sym_t	*sym, *def1;
+	sym_t *sym, *def1;
-	char	*pos1;
+	char *pos1;
 	if (!hte->h_def)
 		return;
 	def1 = NULL;
 	for (sym = hte->h_syms; sym != NULL; sym = sym->s_next) {
 		/*
 		 * ANSI C allows tentative definitions of the same name in
 		 * only one compilation unit.
 		 */
 		if (sym->s_def != DEF && (!sflag || sym->s_def != TDEF))
 			continue;
 		if (sym->s_inline)
 @@ -226,31 +226,31 @@ check_multiple_definitions(const hte_t *
 /*
  * Print a warning if the return value assumed for a function call
  * differs from the return value of the function definition or
  * function declaration.
+ *
  * If no definition/declaration can be found, the assumed return values
  * are always int. So there is no need to compare with another function
  * call as it's done for function arguments.
  */
 static void
 chkvtui(const hte_t *hte, sym_t *def, sym_t *decl)
+{
-	fcall_t	*call;
+	fcall_t *call;
-	char	*pos1;
+	char *pos1;
-	type_t	*tp1, *tp2;
+	type_t *tp1, *tp2;
-	bool	dowarn, eq;
+	bool dowarn, eq;
-	tspec_t	t1;
+	tspec_t t1;
 	if (hte->h_calls == NULL)
 		return;
 	if (def == NULL)
 		def = decl;
 	if (def == NULL)
 		return;
 	t1 = (tp1 = TP(def->s_type)->t_subt)->t_tspec;
 	for (call = hte->h_calls; call != NULL; call = call->f_next) {
 		tp2 = TP(call->f_type)->t_subt;
 		eq = types_compatible(tp1, tp2,
 @@ -288,30 +288,30 @@ chkvtui(const hte_t *hte, sym_t *def, sy
 			free(pos1);
+		}
+	}
+}
 /*
  * Print a warning if a definition/declaration does not match another
  * definition/declaration of the same name. For functions, only the
  * types of return values are tested.
  */
 static void
 chkvtdi(const hte_t *hte, sym_t *def, sym_t *decl)
+{
-	sym_t	*sym;
+	sym_t *sym;
-	type_t	*tp1, *tp2;
+	type_t *tp1, *tp2;
-	bool	eq, dowarn;
+	bool eq, dowarn;
-	char	*pos1;
+	char *pos1;
 	if (def == NULL)
 		def = decl;
 	if (def == NULL)
 		return;
 	tp1 = TP(def->s_type);
 	for (sym = hte->h_syms; sym != NULL; sym = sym->s_next) {
 		type_t *xt1, *xt2;
 		if (sym == def)
 			continue;
 		tp2 = TP(sym->s_type);
 		dowarn = false;
 @@ -330,31 +330,31 @@ chkvtdi(const hte_t *hte, sym_t *def, sy
 			free(pos1);
+		}
+	}
+}
 /*
  * Print a warning if a function is called with arguments which does
  * not match the function definition, declaration or another call
  * of the same function.
  */
 static void
 chkfaui(const hte_t *hte, sym_t *def, sym_t *decl)
+{
-	type_t	*tp1, *tp2, **ap1, **ap2;
+	type_t *tp1, *tp2, **ap1, **ap2;
-	pos_t	*pos1p = NULL;
+	pos_t *pos1p = NULL;
-	fcall_t	*calls, *call, *call1;
+	fcall_t *calls, *call, *call1;
-	int	n, as;
+	int n, as;
-	char	*pos1;
+	char *pos1;
 	arginf_t *ai;
 	if ((calls = hte->h_calls) == NULL)
 		return;
 	/*
 	 * If we find a function definition, we use this for comparison,
 	 * otherwise the first prototype we can find. If there is no
 	 * definition or prototype declaration, the first function call
 	 * is used.
 	 */
 	tp1 = NULL;
 	call1 = NULL;
 @@ -443,30 +443,30 @@ chkfaui(const hte_t *hte, sym_t *def, sy
  *  def		the function definition or NULL
  *  decl	prototype declaration, old-style declaration or NULL
  *  pos1p	position of definition, declaration of first call
  *  call1	first call, if both def and decl are old-style def/decl
  *  call	checked call
  *  arg1	currently checked argument of def/decl/call1
  *  arg2	currently checked argument of call
+ *
  */
 static void
 chkau(const hte_t *hte, int n, sym_t *def, sym_t *decl, pos_t *pos1p,
 	fcall_t *call1, fcall_t *call, type_t *arg1, type_t *arg2)
+{
-	bool	promote, asgn, dowarn;
+	bool promote, asgn, dowarn;
-	tspec_t	t1, t2;
+	tspec_t t1, t2;
 	arginf_t *ai, *ai1;
-	char	*pos1;
+	char *pos1;
 	/*
 	 * If a function definition is available (def != NULL), we compare the
 	 * function call (call) with the definition. Otherwise, if a function
 	 * definition is available and it is not an old-style definition
 	 * (decl != NULL && TP(decl->s_type)->t_proto), we compare the call
 	 * with this declaration. Otherwise we compare it with the first
 	 * call we have found (call1).
 	 */
 	/* arg1 must be promoted if it stems from an old-style definition */
 	promote = def != NULL && def->s_old_style_function;
 @@ -597,31 +597,31 @@ chkau(const hte_t *hte, int n, sym_t *de
 	/* %s, arg %d used inconsistently  \t%s[%s]  ::  %s[%s] */
 	msg(6, hte->h_name, n, pos1, type_name(arg1),
 	    mkpos(&call->f_pos), type_name(arg2));
 	free(pos1);
+}
 /*
  * Compare the types in the NULL-terminated array ap with the format
  * string fmt.
  */
 static void
 printflike(const hte_t *hte, fcall_t *call, int n, const char *fmt, type_t **ap)
+{
-	const	char *fp;
+	const char *fp;
-	char	fc;
+	char fc;
-	bool	fwidth, prec, left, sign, space, alt, zero;
+	bool fwidth, prec, left, sign, space, alt, zero;
-	tspec_t	sz, t1, t2 = NO_TSPEC;
+	tspec_t sz, t1, t2 = NO_TSPEC;
-	type_t	*tp;
+	type_t *tp;
 	fp = fmt;
 	fc = *fp++;
 	for (;;) {
 		if (fc == '\0') {
 			if (*ap != NULL)
 				too_many_arguments(hte, call);
 			break;
+		}
 		if (fc != '%') {
 			bad_format_string(hte, call);
 			break;
 @@ -822,31 +822,31 @@ printflike(const hte_t *hte, fcall_t *ca
+		}
 		fc = *fp++;
+	}
+}
 /*
  * Compare the types in the NULL-terminated array ap with the format
  * string fmt.
  */
 static void
 scanflike(const hte_t *hte, fcall_t *call, int n, const char *fmt, type_t **ap)
+{
-	const	char *fp;
+	const char *fp;
-	char	fc;
+	char fc;
-	bool	noasgn, fwidth;
+	bool noasgn, fwidth;
-	tspec_t	sz, t1 = NO_TSPEC, t2 = NO_TSPEC;
+	tspec_t sz, t1 = NO_TSPEC, t2 = NO_TSPEC;
-	type_t	*tp = NULL;
+	type_t *tp = NULL;
 	fp = fmt;
 	fc = *fp++;
 	for (;;) {
 		if (fc == '\0') {
 			if (*ap != NULL)
 				too_many_arguments(hte, call);
 			break;
+		}
 		if (fc != '%') {
 			bad_format_string(hte, call);
 			break;
 @@ -1063,28 +1063,28 @@ static const char ignorelist[][8] = {
 	"printf",
 	"strcat",
 	"strcpy",
 	"vprintf",
 };
 /*
  * Print warnings for return values which are used but not returned,
  * or return values which are always or sometimes ignored.
  */
 static void
 check_return_values(const hte_t *hte, sym_t *def)
+{
-	fcall_t	*call;
+	fcall_t *call;
-	bool	used, ignored;
+	bool used, ignored;
 	if (def == NULL)
 		/* don't know whether or not the functions returns a value */
 		return;
 	if (hte->h_calls == NULL)
 		return;
 	if (def->s_function_has_return_value) {
 		/*
 		 * XXX as soon as we are able to disable single warnings,
 		 * the following dependencies from hflag should be removed.
 		 * But for now I don't want to be bothered by these warnings
 @@ -1117,32 +1117,32 @@ check_return_values(const hte_t *hte, sy
 			if (call->f_rused)
 				/* %s value is used( %s ), but none returned */
 				msg(10, hte->h_name, mkpos(&call->f_pos));
+		}
+	}
+}
 /*
  * Print warnings for inconsistent argument declarations.
  */
 static void
 check_argument_declarations(const hte_t *hte, sym_t *def, sym_t *decl)
+{
-	bool	osdef, eq, dowarn;
+	bool osdef, eq, dowarn;
-	int	n;
+	int n;
-	sym_t	*sym1, *sym;
+	sym_t *sym1, *sym;
-	type_t	**ap1, **ap2, *tp1, *tp2;
+	type_t **ap1, **ap2, *tp1, *tp2;
-	char	*pos1;
+	char *pos1;
-	const	char *pos2;
+	const char *pos2;
 	osdef = false;
 	if (def != NULL) {
 		osdef = def->s_old_style_function;
 		sym1 = def;
 	} else if (decl != NULL && TP(decl->s_type)->t_proto) {
 		sym1 = decl;
 	} else {
 		return;
+	}
 	if (TP(sym1->s_type)->t_tspec != FUNC)
 		return;
 @@ -1200,28 +1200,28 @@ check_argument_declarations(const hte_t
  * promote	if set, promote left type before comparison; used for
  *		comparisons of arguments with parameters of old-style
  *		definitions
  * asgn		left indirected type must have at least the same qualifiers
  *		like right indirected type (for assignments and function
  *		arguments)
  * *dowarn	set to true if an old-style declaration was compared with
  *		an incompatible prototype declaration
  */
 static bool
 types_compatible(type_t *tp1, type_t *tp2,
 		 bool ignqual, bool promot, bool asgn, bool *dowarn)
+{
-	tspec_t	t, to;
+	tspec_t t, to;
-	int	indir;
+	int indir;
 	to = NO_TSPEC;
 	indir = 0;
 	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) {
 @@ -1326,27 +1326,27 @@ types_compatible(type_t *tp1, type_t *tp
 		indir++;
+	}
 	return tp1 == tp2;
+}
 /*
  * Compares arguments of two prototypes
  */
 static bool
 prototypes_compatible(type_t *tp1, type_t *tp2, bool *dowarn)
+{
-	type_t	**a1, **a2;
+	type_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 (!types_compatible(*a1, *a2, true, false, false, dowarn))
 			return false;
 		a1++;
 @@ -1360,28 +1360,28 @@ prototypes_compatible(type_t *tp1, type_
 /*
  * 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 must have a fixed number of parameters
  *	2. no parameter is of type float
  *	3. no parameter is converted to another type if integer promotion
  *	   is applied on it
  */
 static bool
 matches_no_arg_function(type_t *tp, bool *dowarn)
+{
-	type_t	**arg;
+	type_t **arg;
-	tspec_t	t;
+	tspec_t t;
 	if (tp->t_vararg && dowarn != NULL)
 		*dowarn = true;
 	for (arg = tp->t_args; *arg != NULL; arg++) {
 		if ((t = (*arg)->t_tspec) == FLOAT)
 			return false;
 		if (t == CHAR || t == SCHAR || t == UCHAR)
 			return false;
 		if (t == SHORT || t == USHORT)
 			return false;
+	}
 	return true;
+}

--- src/usr.bin/xlint/lint2/emit2.c 2023/02/02 22:23:30	1.30
+++ src/usr.bin/xlint/lint2/emit2.c 2023/06/09 13:03:49	1.31

 @@ -1,14 +1,14 @@
-/* $NetBSD: emit2.c,v 1.30 2023/02/02 22:23:30 rillig Exp $ */
+/* $NetBSD: emit2.c,v 1.31 2023/06/09 13:03:49 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
 @@ -24,52 +24,52 @@
  * 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 <sys/cdefs.h>
 #if defined(__RCSID)
-__RCSID("$NetBSD: emit2.c,v 1.30 2023/02/02 22:23:30 rillig Exp $");
+__RCSID("$NetBSD: emit2.c,v 1.31 2023/06/09 13:03:49 rillig Exp $");
 #endif
 #include "lint2.h"
 static	void	outtype(type_t *);
 static	void	outdef(hte_t *, sym_t *);
 static	void	dumpname(hte_t *);
 static	void	outfiles(void);
 /*
  * Write type into the output buffer.
  */
 static void
 outtype(type_t *tp)
+{
 #ifdef INT128_SIZE
 	static const char tt[NTSPEC] = "???BCCCSSIILLQQJJDDDVTTTPAF?XXX";
 	static const char ss[NTSPEC] = "???  su u u u u us l sue   ?s l";
 #else
 	static const char tt[NTSPEC] = "???BCCCSSIILLQQDDDVTTTPAF?XXX";
 	static const char ss[NTSPEC] = "???  su u u u us l sue   ?s l";
 #endif
 	while (tp != NULL) {
-		tspec_t	ts = tp->t_tspec;
+		tspec_t ts = tp->t_tspec;
 		if (ts == INT && tp->t_is_enum)
 			ts = ENUM;
 		if (!ch_isupper(tt[ts]))
 			errx(1, "internal error: outtype(%d)", ts);
 		if (tp->t_const)
 			outchar('c');
 		if (tp->t_volatile)
 			outchar('v');
 		if (ss[ts] != ' ')
 			outchar(ss[ts]);
 		if (ts == FUNC && tp->t_args != NULL && !tp->t_proto)
 			outchar('f');
 		else
 @@ -156,27 +156,27 @@ outdef(hte_t *hte, sym_t *sym)
 	/* name */
 	outname(hte->h_name);
 	/* type */
 	outtype(TP(sym->s_type));
+}
 /*
  * Write the first definition of a name into the lint library.
  */
 static void
 dumpname(hte_t *hte)
+{
-	sym_t	*sym, *def;
+	sym_t *sym, *def;
 	/* static and undefined symbols are not written */
 	if (hte->h_static || !hte->h_def)
 		return;
 	/*
 	 * If there is a definition, write it. Otherwise, write a tentative
 	 * definition. This is necessary because more than one tentative
 	 * definition is allowed (except with sflag).
 	 */
 	def = NULL;
 	for (sym = hte->h_syms; sym != NULL; sym = sym->s_next) {
 		if (sym->s_def == DEF) {

--- src/usr.bin/xlint/lint2/hash.c 2022/05/20 21:18:55	1.24
+++ src/usr.bin/xlint/lint2/hash.c 2023/06/09 13:03:49	1.25

 @@ -1,14 +1,14 @@
-/*	$NetBSD: hash.c,v 1.24 2022/05/20 21:18:55 rillig Exp $	*/
+/*	$NetBSD: hash.c,v 1.25 2023/06/09 13:03:49 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.
 @@ -27,27 +27,27 @@
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID)
-__RCSID("$NetBSD: hash.c,v 1.24 2022/05/20 21:18:55 rillig Exp $");
+__RCSID("$NetBSD: hash.c,v 1.25 2023/06/09 13:03:49 rillig Exp $");
 #endif
 /*
  * XXX Really need a generalized hash table package
  */
 #include <limits.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint2.h"
 @@ -78,27 +78,27 @@ hash(const char *s)
 		v ^= v >> 28;
+	}
 	return v % HSHSIZ2;
+}
 /*
  * Look for a hash table entry. If no hash table entry for the
  * given name exists and mknew is set, create a new one.
  */
 hte_t *
 _hsearch(hte_t **table, const char *s, bool mknew)
+{
 	unsigned int h;
-	hte_t	*hte;
+	hte_t *hte;
 	if (table == NULL)
 		table = htab;
 	h = hash(s);
 	for (hte = table[h]; hte != NULL; hte = hte->h_link) {
 		if (strcmp(hte->h_name, s) == 0)
 			break;
+	}
 	if (hte != NULL || !mknew)
 		return hte;
 @@ -149,29 +149,29 @@ hte_by_name(const void *va, const void *
 void
 symtab_init(void)
+{
 	htab = htab_new();
+}
 /*
  * Call the action for each name in the hash table.
  */
 void
 symtab_forall(void (*action)(hte_t *))
+{
-	int	i;
+	int i;
-	hte_t	*hte;
+	hte_t *hte;
-	hte_t	**table = htab;
+	hte_t **table = htab;
 	for (i = 0; i < HSHSIZ2; i++) {
 		for (hte = table[i]; hte != NULL; hte = hte->h_link)
 			action(hte);
+	}
+}
 /* Run the action for each name in the symbol table, in alphabetic order. */
 void
 symtab_forall_sorted(void (*action)(hte_t *))
+{
 	hte_t *hte;
 	struct hte_list sorted = { NULL, 0, 0 };
 @@ -186,28 +186,28 @@ symtab_forall_sorted(void (*action)(hte_
 	for (i = 0; i < sorted.len; i++)
 		action(sorted.items[i]);
 	free(sorted.items);
+}
 /*
  * Free all contents of the hash table that this module allocated.
  */
 void
 _destroyhash(hte_t **table)
+{
-	int	i;
+	int i;
-	hte_t	*hte, *nexthte;
+	hte_t *hte, *nexthte;
 	if (table == NULL)
 		err(1, "_destroyhash called on main hash table");
 	for (i = 0; i < HSHSIZ2; i++) {
 		for (hte = table[i]; hte != NULL; hte = nexthte) {
 			free(__UNCONST(hte->h_name));
 			nexthte = hte->h_link;
 			free(hte);
+		}
+	}
 	free(table);
+}

--- src/usr.bin/xlint/lint2/main2.c 2023/03/28 14:44:35	1.28
+++ src/usr.bin/xlint/lint2/main2.c 2023/06/09 13:03:49	1.29

 @@ -1,14 +1,14 @@
-/*	$NetBSD: main2.c,v 1.28 2023/03/28 14:44:35 rillig Exp $	*/
+/*	$NetBSD: main2.c,v 1.29 2023/06/09 13:03:49 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.
 @@ -27,27 +27,27 @@
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID)
-__RCSID("$NetBSD: main2.c,v 1.28 2023/03/28 14:44:35 rillig Exp $");
+__RCSID("$NetBSD: main2.c,v 1.29 2023/06/09 13:03:49 rillig Exp $");
 #endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include "lint2.h"
 /* warnings for symbols which are declared but not defined or used */
 bool	xflag;
 /*
 @@ -87,29 +87,29 @@ bool	Fflag;
 static const char **libs;
 static	void	usage(void) __attribute__((noreturn));
 static void
 check_name_non_const(hte_t *hte)
+{
 	check_name(hte);
+}
 int
 main(int argc, char *argv[])
+{
-	int	c, i;
+	int c, i;
-	size_t	len;
+	size_t len;
-	char	*lname;
+	char *lname;
 	libs = xcalloc(1, sizeof(*libs));
 	opterr = 0;
 	while ((c = getopt(argc, argv, "hstxuC:HFl:")) != -1) {
 		switch (c) {
 		case 's':
 			sflag = true;
 			break;
 		case 't':
 			tflag = true;
 			break;
 		case 'u':

--- src/usr.bin/xlint/lint2/msg.c 2023/02/19 19:27:01	1.19
+++ src/usr.bin/xlint/lint2/msg.c 2023/06/09 13:03:49	1.20

 @@ -1,14 +1,14 @@
-/*	$NetBSD: msg.c,v 1.19 2023/02/19 19:27:01 rillig Exp $	*/
+/*	$NetBSD: msg.c,v 1.20 2023/06/09 13:03:49 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.
 @@ -27,27 +27,27 @@
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID)
-__RCSID("$NetBSD: msg.c,v 1.19 2023/02/19 19:27:01 rillig Exp $");
+__RCSID("$NetBSD: msg.c,v 1.20 2023/06/09 13:03:49 rillig Exp $");
 #endif
 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
 #include "lint2.h"
 static	const	char *msgs[] = {
 	"%s used( %s ), but not defined",			      /* 0 */
 	"%s defined( %s ), but never used",			      /* 1 */
 	"%s declared( %s ), but never used or defined",		      /* 2 */
 	"%s multiply defined  \t%s  ::  %s",			      /* 3 */
 @@ -61,27 +61,27 @@ static	const	char *msgs[] = {
 	"%s, arg %d declared inconsistently (%s != %s)\t%s :: %s",    /* 11 */
 	"%s: variable # of args declared  \t%s  ::  %s",	      /* 12 */
 	"%s: malformed format string  \t%s",			      /* 13 */
 	"%s, arg %d inconsistent with format  \t%s",		      /* 14 */
 	"%s: too few args for format  \t%s",			      /* 15 */
 	"%s: too many args for format  \t%s",			      /* 16 */
 	"%s function value must be declared before use  \t%s  ::  %s",/* 17 */
 	"%s renamed multiple times  \t%s  ::  %s",		      /* 18 */
 };
 void
 msg(int n, ...)
+{
-	va_list	ap;
+	va_list ap;
 	va_start(ap, n);
 	(void)vprintf(msgs[n], ap);
 	(void)printf("\n");
 	va_end(ap);
+}
 /*
  * Return a pointer to the last component of a path.
  */
 static const char *
 @@ -94,32 +94,32 @@ lbasename(const char *path)
 	const char *base = path;
 	for (const char *p = path; *p != '\0'; p++)
 		if (*p == '/')
 			base = p + 1;
 	return base;
+}
 /*
  * Create a string which describes a position in a source file.
  */
 const char *
 mkpos(pos_t *posp)
+{
-	size_t	len;
+	size_t len;
-	const	char *fn;
+	const char *fn;
-	static	char	*buf;
+	static char *buf;
-	static	size_t	blen = 0;
+	static size_t blen = 0;
-	bool	qm;
+	bool qm;
-	int	src, line;
+	int src, line;
 	if (Hflag && posp->p_src != posp->p_isrc) {
 		src = posp->p_isrc;
 		line = posp->p_iline;
 	} else {
 		src = posp->p_src;
 		line = posp->p_line;
+	}
 	qm = !Hflag && posp->p_src != posp->p_isrc;
 	len = strlen(fn = lbasename(fnames[src]));
 	len += 3 * sizeof(unsigned short) + 4;

--- src/usr.bin/xlint/lint2/read.c 2023/05/22 12:55:04	1.80
+++ src/usr.bin/xlint/lint2/read.c 2023/06/09 13:03:49	1.81

 @@ -1,14 +1,14 @@
-/* $NetBSD: read.c,v 1.80 2023/05/22 12:55:04 rillig Exp $ */
+/* $NetBSD: read.c,v 1.81 2023/06/09 13:03:49 rillig Exp $ */
 /*
  * Copyright (c) 1996 Christopher G. Demetriou.  All Rights Reserved.
  * Copyright (c) 1994, 1995 Jochen Pohl
  * All Rights Reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
 @@ -28,27 +28,27 @@
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID)
-__RCSID("$NetBSD: read.c,v 1.80 2023/05/22 12:55:04 rillig Exp $");
+__RCSID("$NetBSD: read.c,v 1.81 2023/06/09 13:03:49 rillig Exp $");
 #endif
 #include <ctype.h>
 #include <limits.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint2.h"
 /* index of current (included) source file */
 @@ -204,29 +204,29 @@ read_ln_line(const char *line)
 		decldef(pos, cp);
 		break;
 	case 'u':
 		usedsym(pos, cp);
 		break;
 	default:
 		inperr("bad record type %c", rt);
+	}
+}
 void
 readfile(const char *name)
+{
-	FILE	*inp;
+	FILE *inp;
-	size_t	len;
+	size_t len;
-	char	*line;
+	char *line;
 	if (inpfns == NULL)
 		inpfns = xcalloc(ninpfns = 128, sizeof(*inpfns));
 	if (fnames == NULL)
 		fnames = xcalloc(nfnames = 256, sizeof(*fnames));
 	if (flines == NULL)
 		flines = xcalloc(nfnames, sizeof(*flines));
 	if (tlstlen == 0)
 		tlst = xcalloc(tlstlen = 256, sizeof(*tlst));
 	if (thtab == NULL)
 		thtab = xcalloc(THSHSIZ2, sizeof(*thtab));
 	renametab = htab_new();
 @@ -306,30 +306,30 @@ setfnid(int fid, const char *cp)
 	 */
 	if ((size_t)fid >= ninpfns)
 		errx(1, "internal error: setfnid");
 	inpfns[fid] = (unsigned short)getfnidx(cp);
+}
 /*
  * Process a function call record (c-record).
  */
 static void
 funccall(pos_t pos, const char *cp)
+{
 	arginf_t *ai, **lai;
-	char	c;
+	char c;
-	bool	rused, rdisc;
+	bool rused, rdisc;
-	hte_t	*hte;
+	hte_t *hte;
-	fcall_t	*fcall;
+	fcall_t *fcall;
 	const char *name;
 	fcall = xalloc(sizeof(*fcall));
 	fcall->f_pos = pos;
 	/* read flags */
 	rused = rdisc = false;
 	lai = &fcall->f_args;
 again:
 	c = *cp++;
 	switch (c) {
 	case 'u':
 @@ -458,30 +458,30 @@ parse_function_attribute(const char **pp
 	default:
 		(*pp)--;
 		return false;
+	}
 	return true;
+}
 /*
  * Process a declaration or definition (d-record).
  */
 static void
 decldef(pos_t pos, const char *cp)
+{
-	sym_t	*symp, sym;
+	sym_t *symp, sym;
-	char	*pos1, *tname;
+	char *pos1, *tname;
-	bool	used, renamed;
+	bool used, renamed;
-	hte_t	*hte, *renamehte = NULL;
+	hte_t *hte, *renamehte = NULL;
 	const char *name, *newname;
 	(void)memset(&sym, 0, sizeof(sym));
 	sym.s_pos = pos;
 	sym.s_def = NODECL;
 	used = false;
 	while (parse_function_attribute(&cp, &sym, &used))
 		continue;
 	/* read symbol name, doing renaming if necessary */
 	name = inpname(cp, &cp);
 @@ -554,28 +554,28 @@ decldef(pos_t pos, const char *cp)
 			renamehte->h_syms = symp;
+	}
 	if (*cp != '\0')
 		inperr("trailing line: %s", cp);
+}
 /*
  * Read an u-record (emitted by lint1 if a symbol was used).
  */
 static void
 usedsym(pos_t pos, const char *cp)
+{
-	usym_t	*usym;
+	usym_t *usym;
-	hte_t	*hte;
+	hte_t *hte;
 	const char *name;
 	usym = xalloc(sizeof(*usym));
 	usym->u_pos = pos;
 	/* needed as delimiter between two numbers */
 	if (*cp++ != 'x')
 		inperr("bad delim %c", cp[-1]);
 	name = inpname(cp, &cp);
 	hte = _hsearch(renametab, name, false);
 	if (hte != NULL)
 		hte = hte->h_hte;
 @@ -641,34 +641,34 @@ parse_tspec(const char **pp, char c, boo
 				       : (s == 'l' ? LCOMPLEX : DCOMPLEX);
 	default:
 		inperr("tspec '%c'", c);
 		/* NOTREACHED */
+	}
+}
 /*
  * Read a type and return the index of this type.
  */
 static unsigned short
 inptype(const char *cp, const char **epp)
+{
-	char	c;
+	char c;
-	const	char *ep;
+	const char *ep;
-	type_t	*tp;
+	type_t *tp;
-	int	narg, i;
+	int narg, i;
-	bool	osdef = false;
+	bool osdef = false;
-	size_t	tlen;
+	size_t tlen;
 	unsigned short tidx;
-	int	h;
+	int h;
 	/* If we have this type already, return its index. */
 	tlen = gettlen(cp, &ep);
 	h = thash(cp, tlen);
 	if ((tidx = findtype(cp, tlen, h)) != 0) {
 		*epp = ep;
 		return tidx;
+	}
 	/* No, we must create a new type. */
 	tp = xalloc(sizeof(*tp));
 	tidx = storetyp(tp, cp, tlen, h);
 @@ -743,30 +743,30 @@ inptype(const char *cp, const char **epp
 		break;
+	}
 	*epp = cp;
 	return tidx;
+}
 /*
  * Get the length of a type string.
  */
 static size_t
 gettlen(const char *cp, const char **epp)
+{
-	const	char *cp1;
+	const char *cp1;
-	char	c, s;
+	char c, s;
-	tspec_t	t;
+	tspec_t t;
-	int	narg, i;
+	int narg, i;
 	cp1 = cp;
 	c = *cp++;
 	if (c == 'c')
 		c = *cp++;
 	if (c == 'v')
 		c = *cp++;
 	switch (c) {
 	case 's':
 	case 'u':
 @@ -922,48 +922,48 @@ gettlen(const char *cp, const char **epp
 		break;
+	}
 	*epp = cp;
 	return (size_t)(cp - cp1);
+}
 /*
  * Search a type by its type string.
  */
 static unsigned short
 findtype(const char *cp, size_t len, int h)
+{
-	thtab_t	*thte;
+	thtab_t *thte;
 	for (thte = thtab[h]; thte != NULL; thte = thte->th_next) {
 		if (strncmp(thte->th_name, cp, len) != 0)
 			continue;
 		if (thte->th_name[len] == '\0')
 			return thte->th_idx;
+	}
 	return 0;
+}
 /*
  * Store a type and its type string, so we can later share this type
  * if we read the same type string from the input file.
  */
 static unsigned short
 storetyp(type_t *tp, const char *cp, size_t len, int h)
+{
 	static unsigned int tidx = 1;	/* 0 is reserved */
-	thtab_t	*thte;
+	thtab_t *thte;
-	char	*name;
+	char *name;
 	if (tidx >= USHRT_MAX)
 		errx(1, "sorry, too many types");
 	if (tidx == tlstlen - 1) {
 		tlst = xrealloc(tlst, (tlstlen * 2) * sizeof(*tlst));
 		(void)memset(tlst + tlstlen, 0, tlstlen * sizeof(*tlst));
 		tlstlen *= 2;
+	}
 	tlst[tidx] = tp;
 	/* create a hash table entry */
 @@ -992,30 +992,30 @@ thash(const char *s, size_t len)
 	while (len-- != 0) {
 		v = (v << sizeof(v)) + (unsigned char)*s++;
 		v ^= v >> (sizeof(v) * CHAR_BIT - sizeof(v));
+	}
 	return v % THSHSIZ2;
+}
 /*
  * Read a string enclosed by "". This string may contain quoted chars.
  */
 static char *
 inpqstrg(const char *src, const char **epp)
+{
-	char	*strg, *dst;
+	char *strg, *dst;
-	size_t	slen;
+	size_t slen;
-	char	c;
+	char c;
-	int	v;
+	int v;
 	dst = strg = xmalloc(slen = 32);
 	if ((c = *src++) != '"')
 		inperr("not quote: %c", c);
 	if ((c = *src++) == '\0')
 		inperr("trailing data: %c", c);
 	while (c != '"') {
 		if (c == '\\') {
 			if ((c = *src++) == '\0')
 				inperr("missing after \\");
 			switch (c) {
 @@ -1075,54 +1075,54 @@ inpqstrg(const char *src, const char **e
+	}
 	*dst = '\0';
 	*epp = src;
 	return strg;
+}
 /*
  * Read the name of a symbol in static memory.
  */
 static const char *
 inpname(const char *cp, const char **epp)
+{
-	static	char	*buf;
+	static char *buf;
-	static	size_t	blen = 0;
+	static size_t blen = 0;
-	size_t	len, i;
+	size_t len, i;
-	char	c;
+	char c;
 	len = parse_int(&cp);
 	if (len + 1 > blen)
 		buf = xrealloc(buf, blen = len + 1);
 	for (i = 0; i < len; i++) {
 		c = *cp++;
 		if (!ch_isalnum(c) && c != '_')
 			inperr("not alnum or _: %c", c);
 		buf[i] = c;
+	}
 	buf[i] = '\0';
 	*epp = cp;
 	return buf;
+}
 /*
  * Return the index of a file name. If the name cannot be found, create
  * a new entry and return the index of the newly created entry.
  */
 static int
 getfnidx(const char *fn)
+{
-	size_t	i;
+	size_t i;
 	/* 0 is reserved */
 	for (i = 1; fnames[i] != NULL; i++) {
 		if (strcmp(fnames[i], fn) == 0)
 			return (int)i;
+	}
 	if (i == nfnames - 1) {
 		size_t nlen = nfnames * 2;
 		fnames = xrealloc(fnames, nlen * sizeof(*fnames));
 		(void)memset(fnames + nfnames, 0, nfnames * sizeof(*fnames));
 		flines = xrealloc(flines, nlen * sizeof(*flines));
 		(void)memset(flines + nfnames, 0, nfnames * sizeof(*flines));
 @@ -1130,31 +1130,31 @@ getfnidx(const char *fn)
+	}
 	fnames[i] = xstrdup(fn);
 	flines[i] = 0;
 	return (int)i;
+}
 /*
  * Separate symbols with static and external linkage.
  */
 void
 mkstatic(hte_t *hte)
+{
-	sym_t	*sym1, **symp, *sym;
+	sym_t *sym1, **symp, *sym;
-	fcall_t	**callp, *call;
+	fcall_t **callp, *call;
-	usym_t	**usymp, *usym;
+	usym_t **usymp, *usym;
-	hte_t	*nhte;
+	hte_t *nhte;
-	bool	ofnd;
+	bool ofnd;
 	/* Look for first static definition */
 	for (sym1 = hte->h_syms; sym1 != NULL; sym1 = sym1->s_next) {
 		if (sym1->s_static)
 			break;
+	}
 	if (sym1 == NULL)
 		return;
 	/* Do nothing if this name is used only in one translation unit. */
 	ofnd = false;
 	for (sym = hte->h_syms; sym != NULL && !ofnd; sym = sym->s_next) {
 		if (sym->s_pos.p_src != sym1->s_pos.p_src)

--- src/usr.bin/xlint/xlint/xlint.c 2023/02/19 19:27:02	1.109
+++ src/usr.bin/xlint/xlint/xlint.c 2023/06/09 13:03:49	1.110

 @@ -1,14 +1,14 @@
-/* $NetBSD: xlint.c,v 1.109 2023/02/19 19:27:02 rillig Exp $ */
+/* $NetBSD: xlint.c,v 1.110 2023/06/09 13:03:49 rillig Exp $ */
 /*
  * Copyright (c) 1996 Christopher G. Demetriou.  All Rights Reserved.
  * Copyright (c) 1994, 1995 Jochen Pohl
  * All Rights Reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
 @@ -28,27 +28,27 @@
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID)
-__RCSID("$NetBSD: xlint.c,v 1.109 2023/02/19 19:27:02 rillig Exp $");
+__RCSID("$NetBSD: xlint.c,v 1.110 2023/06/09 13:03:49 rillig Exp $");
 #endif
 #include <sys/param.h>
 #include <sys/wait.h>
 #include <sys/stat.h>
 #include <sys/utsname.h>
 #include <errno.h>
 #include <stdarg.h>
 #include <fcntl.h>
 #include <paths.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 @@ -619,30 +619,30 @@ main(int argc, char *argv[])
 		lint2.outlib = NULL;
 	terminate(0);
 	/* NOTREACHED */
+}
 /*
  * Read a file name from the command line
  * and pass it through lint1 if it is a C source.
  */
 static void
 handle_filename(const char *name)
+{
-	const	char *bn, *suff;
+	const char *bn, *suff;
-	char	*ofn;
+	char *ofn;
-	size_t	len;
+	size_t len;
-	int	fd;
+	int fd;
 	bn = lbasename(name, '/');
 	suff = lbasename(bn, '.');
 	if (strcmp(suff, "ln") == 0) {
 		/* only for lint2 */
 		if (!iflag)
 			list_add(&lint2.infiles, name);
 		return;
+	}
 	if (strcmp(suff, "c") != 0 &&
 	    (strncmp(bn, "llib-l", 6) != 0 || bn != suff)) {
 @@ -706,27 +706,27 @@ needs_quoting:
 	(void)putchar('\'');
 	for (const char *p = s; *p != '\0'; p++) {
 		if (*p == '\'')
 			(void)printf("'\\''");
 		else
 			(void)putchar(*p);
+	}
 	(void)putchar('\'');
+}
 static void
 run_child(const char *path, list *args, const char *crfn, int fdout)
+{
-	int	status, rv, signo;
+	int status, rv, signo;
 	if (Vflag) {
 		print_sh_quoted(args->items[0]);
 		for (size_t i = 1; i < args->len - 1; i++) {
 			(void)printf(" ");
 			print_sh_quoted(args->items[i]);
+		}
 		(void)printf("\n");
+	}
 	currfn = crfn;
 	(void)fflush(stdout);
 @@ -799,43 +799,43 @@ found:
+}
 static void
 find_libs(const list *l)
+{
 	for (size_t i = 0; i < l->len; i++)
 		find_lib(l->items[i]);
+}
 static bool
 file_is_readable(const char *path)
+{
-	struct	stat sbuf;
+	struct stat sbuf;
 	if (stat(path, &sbuf) == -1)
 		return false;
 	if (!S_ISREG(sbuf.st_mode))
 		return false;
 	if (access(path, R_OK) == -1)
 		return false;
 	return true;
+}
 static void
 cat(const list *srcs, const char *dest)
+{
-	int	ifd, ofd;
+	int ifd, ofd;
-	ssize_t	rlen;
+	ssize_t rlen;
-	char	buf[0x4000];
+	char buf[0x4000];
 	if ((ofd = open(dest, O_WRONLY | O_CREAT | O_TRUNC, 0666)) == -1) {
 		warn("cannot open %s", dest);
 		terminate(-1);
+	}
 	for (size_t i = 0; i < srcs->len; i++) {
 		const char *src = srcs->items[i];
 		if ((ifd = open(src, O_RDONLY)) == -1) {
 			warn("cannot open %s", src);
 			terminate(-1);
+		}
 		do {