 @@ -1,14 +1,14 @@
-/* $NetBSD: decl.c,v 1.316 2023/06/09 13:03:49 rillig Exp $ */
+/* $NetBSD: decl.c,v 1.317 2023/06/09 15:36:31 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.316 2023/06/09 13:03:49 rillig Exp $");
+__RCSID("$NetBSD: decl.c,v 1.317 2023/06/09 15:36:31 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];
 @@ -1591,27 +1591,27 @@ declarator_name(sym_t *sym)
 	case DK_OLD_STYLE_ARG:
 		if ((sc = dcs->d_scl) == NOSCL)
 			sc = AUTO;
 		else {
 			lint_assert(sc == REG);
 			sym->s_register = true;
 			sc = AUTO;
+		}
 		sym->s_def = DEF;
 		break;
 	case DK_AUTO:
 		if ((sc = dcs->d_scl) == NOSCL) {
 			/*
-			 * XXX somewhat ugly because we dont know whether
+			 * XXX somewhat ugly because we don't know whether
 			 * this is AUTO or EXTERN (functions). If we are
 			 * wrong it must be corrected in declare_local(),
 			 * where we have the necessary type information.
 			 */
 			sc = AUTO;
 			sym->s_def = DEF;
 		} else if (sc == AUTO || sc == STATIC || sc == TYPEDEF)
 			sym->s_def = DEF;
 		else if (sc == REG) {
 			sym->s_register = true;
 			sc = AUTO;
 			sym->s_def = DEF;
 		} else {
 @@ -1883,27 +1883,27 @@ sym_t *
 enumeration_constant(sym_t *sym, int val, bool impl)
+{
 	if (sym->s_scl != NOSCL) {
 		if (sym->s_block_level == block_level) {
 			/* no hflag, because this is illegal */
 			if (sym->s_arg) {
 				/* enumeration constant '%s' hides parameter */
 				warning(57, sym->s_name);
 			} else {
 				/* redeclaration of '%s' */
 				error(27, sym->s_name);
 				/*
-				 * inside blocks it should not be too
+				 * Inside blocks, it should not be too
 				 * complicated to find the position of the
 				 * previous declaration
 				 */
 				if (block_level == 0)
 					print_previous_declaration(sym);
+			}
 		} else {
 			if (hflag)
 				/* redefinition of '%s' hides earlier one */
 				warning(43, sym->s_name);
+		}
 		sym = pushdown(sym);
+	}
 @@ -2835,27 +2835,27 @@ declare_external_in_block(sym_t *dsym)
 		if (esym->s_scl == EXTERN) {
 			/* inconsistent redeclaration of extern '%s' */
 			warning(90, dsym->s_name);
 			print_previous_declaration(esym);
 		} else {
 			/* inconsistent redeclaration of static '%s' */
 			warning(92, dsym->s_name);
 			print_previous_declaration(esym);
+		}
+	}
 	if (compatible) {
 		/*
-		 * Remember the external symbol so we can update usage
+		 * Remember the external symbol, so we can update usage
 		 * information at the end of the block.
 		 */
 		dsym->s_ext_sym = esym;
+	}
+}
 /*
  * Print an error or a warning if the symbol cannot be initialized due
  * to type/storage class. Return whether an error has been detected.
  */
 static bool
 check_init(sym_t *sym)
+{

 @@ -1,14 +1,14 @@
-/* $NetBSD: emit1.c,v 1.67 2023/06/09 13:03:49 rillig Exp $ */
+/* $NetBSD: emit1.c,v 1.68 2023/06/09 15:36:31 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.67 2023/06/09 13:03:49 rillig Exp $");
+__RCSID("$NetBSD: emit1.c,v 1.68 2023/06/09 15:36:31 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
 @@ -183,32 +183,28 @@ outsym(const sym_t *sym, scl_t sc, def_t
 	 * file. Compatibility of function declarations (for both static
 	 * and extern functions) must be checked in lint2. Lint1 can't do
 	 * this, especially not if functions are declared at block level
 	 * before their first declaration at level 0.
 	 */
 	if (sc != EXTERN && !(sc == STATIC && sym->s_type->t_tspec == FUNC))
 		return;
 	if (ch_isdigit(sym->s_name[0]))	/* 00000000_tmp */
 		return;
 	/* reset buffer */
 	outclr();
 	/*
 	 * line number of .c source, 'd' for declaration, Id of current
 	 * source (.c or .h), and line in current source.
 	 */
 	outint(csrc_pos.p_line);
-	outchar('d');
+	outchar('d');		/* declaration */
 	outint(get_filename_id(sym->s_def_pos.p_file));
 	outchar('.');
 	outint(sym->s_def_pos.p_line);
 	/* flags */
 	if (def == DEF)
 		outchar('d');	/* defined */
 	else if (def == TDEF)
 		outchar('t');	/* tentative defined */
 	else {
 		lint_assert(def == DECL);
 		outchar('e');	/* declared */
 @@ -229,55 +225,45 @@ outsym(const sym_t *sym, scl_t sc, def_t
 	outname(sym->s_name);
 	/* renamed name of symbol, if necessary */
 	if (sym->s_rename != NULL) {
 		outchar('r');
 		outname(sym->s_rename);
+	}
 	/* type of the symbol */
 	outtype(sym->s_type);
+}
 /*
- * write information about function definition
+ * Write information about a function definition. This is also done for static
  * functions, to later check if they are called with proper argument types.
  * this is also done for static functions so we are able to check if
  * they are called with proper argument types
  */
 void
 outfdef(const sym_t *fsym, const pos_t *posp, bool rval, bool osdef,
 	const sym_t *args)
+{
 	int narg;
 	const sym_t *arg;
 	/* reset the buffer */
 	outclr();
 	/*
 	 * line number of .c source, 'd' for declaration, Id of current
 	 * source (.c or .h), and line in current source
 	 * we are already at the end of the function. If we are in the
 	 * .c source, posp->p_line is correct, otherwise csrc_pos.p_line
 	 * (for functions defined in header files).
 	 */
 	if (posp->p_file == csrc_pos.p_file) {
 		outint(posp->p_line);
 	} else {
 		outint(csrc_pos.p_line);
+	}
-	outchar('d');
+	outchar('d');		/* declaration */
 	outint(get_filename_id(posp->p_file));
 	outchar('.');
 	outint(posp->p_line);
 	/* flags */
 	/* both SCANFLIKE and PRINTFLIKE imply VARARGS */
 	if (printflike_argnum != -1) {
 		nvararg = printflike_argnum;
 	} else if (scanflike_argnum != -1) {
 		nvararg = scanflike_argnum;
+	}
 @@ -349,32 +335,28 @@ outfdef(const sym_t *fsym, const pos_t *
  * (that is, cast to void)
  */
 void
 outcall(const tnode_t *tn, bool retval_used, bool retval_discarded)
+{
 	tnode_t *args, *arg;
 	int narg, n, i;
 	int64_t q;
 	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');
+	outchar('c');		/* function call */
 	outint(get_filename_id(curr_pos.p_file));
 	outchar('.');
 	outint(curr_pos.p_line);
 	/*
 	 * flags; 'u' and 'i' must be last to make sure a letter
 	 * is between the numeric argument of a flag and the name of
 	 * the function
 	 */
 	narg = 0;
 	args = tn->tn_right;
 	for (arg = args; arg != NULL; arg = arg->tn_right)
 		narg++;
 @@ -577,34 +559,30 @@ outfstrg(strg_t *strg)
+		}
+	}
 	outchar('"');
+}
 /*
  * writes a record if sym was used
  */
 void
 outusg(const sym_t *sym)
+{
-	if (ch_isdigit(sym->s_name[0]))	/* 00000000_tmp */
+	if (ch_isdigit(sym->s_name[0]))	/* 00000000_tmp, from mktempsym */
 		return;
 	/* reset buffer */
 	outclr();
 	/*
 	 * line number of .c source, 'u' for used, Id of current
 	 * source (.c or .h), and line in current source
 	 */
 	outint(csrc_pos.p_line);
-	outchar('u');
+	outchar('u');		/* used */
 	outint(get_filename_id(curr_pos.p_file));
 	outchar('.');
 	outint(curr_pos.p_line);
 	/* necessary to delimit both numbers */
 	outchar('x');
 	outname(sym->s_name);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: err.c,v 1.198 2023/06/09 13:03:49 rillig Exp $	*/
+/*	$NetBSD: err.c,v 1.199 2023/06/09 15:36:31 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.198 2023/06/09 13:03:49 rillig Exp $");
+__RCSID("$NetBSD: err.c,v 1.199 2023/06/09 15:36:31 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 */
 @@ -425,27 +425,27 @@ suppress_messages(const char *p)
 	for (; ch_isdigit(*p); p = end + 1) {
 		unsigned long id = strtoul(p, &end, 10);
 		if ((*end != '\0' && *end != ',') ||
 		    id >= sizeof(msgs) / sizeof(msgs[0]) ||
 		    msgs[id][0] == '\0')
 			break;
 		is_suppressed[id] = true;
 		if (*end == '\0')
 			return;
+	}
-	errx(1, "invalid message ID '%.*s'", (int)(strcspn(p, ",")), p);
+	errx(1, "invalid message ID '%.*s'", (int)strcspn(p, ","), p);
+}
 void
 update_location(const char *filename, int lineno, bool is_begin, bool is_end)
+{
 	struct include_level *top;
 	top = includes;
 	if (is_begin && top != NULL)
 		top->lineno = curr_pos.p_line;
 	if (top == NULL || is_begin) {
 		top = xmalloc(sizeof(*top));
 @@ -736,15 +736,15 @@ enable_queries(const char *p)
 	for (; ch_isdigit(*p); p = end + 1) {
 		unsigned long id = strtoul(p, &end, 10);
 		if ((*end != '\0' && *end != ',') ||
 		    id >= sizeof(queries) / sizeof(queries[0]) ||
 		    queries[id][0] == '\0')
 			break;
 		any_query_enabled = true;
 		is_query_enabled[id] = true;
 		if (*end == '\0')
 			return;
+	}
-	errx(1, "invalid query ID '%.*s'", (int)(strcspn(p, ",")), p);
+	errx(1, "invalid query ID '%.*s'", (int)strcspn(p, ","), p);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: func.c,v 1.155 2023/06/09 13:03:49 rillig Exp $	*/
+/*	$NetBSD: func.c,v 1.156 2023/06/09 15:36:31 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.155 2023/06/09 13:03:49 rillig Exp $");
+__RCSID("$NetBSD: func.c,v 1.156 2023/06/09 15:36:31 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;
 @@ -277,28 +277,27 @@ begin_function(sym_t *fsym)
 	for (arg = fsym->s_type->t_args; arg != NULL; arg = arg->s_next) {
 		if (arg->s_scl == ABSTRACT) {
 			lint_assert(arg->s_name == unnamed);
 			/* formal parameter #%d lacks name */
 			error(59, n);
 		} else {
 			lint_assert(arg->s_name != unnamed);
+		}
 		n++;
+	}
 	/*
 	 * We must also remember the position. s_def_pos is overwritten
-	 * if this is an old-style definition and we had already a
+	 * if this is an old-style definition, and we had already a prototype.
 	 * prototype.
 	 */
 	dcs->d_func_def_pos = fsym->s_def_pos;
 	if ((rdsym = dcs->d_redeclared_symbol) != NULL) {
 		if (!check_redeclaration(fsym, (dowarn = false, &dowarn))) {
 			/*
 			 * Print nothing if the newly defined function
 			 * is defined in old style. A better warning will
 			 * be printed in check_func_lint_directives().
 			 */
 			if (dowarn && !fsym->s_osdef) {
 @@ -370,27 +369,27 @@ check_missing_return_value(void)
 void
 end_function(void)
+{
 	sym_t *arg;
 	int n;
 	if (reached) {
 		cstmt->c_had_return_noval = true;
 		check_missing_return_value();
+	}
 	/*
 	 * This warning is printed only if the return value was implicitly
-	 * declared to be int. Otherwise the wrong return statement
+	 * declared to be int. Otherwise, the wrong return statement
 	 * has already printed a warning.
 	 */
 	if (cstmt->c_had_return_noval && cstmt->c_had_return_value &&
 	    funcsym->s_return_type_implicit_int)
 		/* function '%s' has 'return expr' and 'return' */
 		warning(216, funcsym->s_name);
 	/* Print warnings for unused arguments */
 	arg = dcs->d_func_args;
 	n = 0;
 	while (arg != NULL && (nargusg == -1 || n < nargusg)) {
 		check_usage_sym(dcs->d_asm, arg);
 		arg = arg->s_next;
 @@ -1353,27 +1352,27 @@ linted(int n)
 /* ARGSUSED */
 void
 bitfieldtype(int n)
+{
 	debug_step("%s, %d: bitfieldtype_ok = true",
 	    curr_pos.p_file, curr_pos.p_line);
 	bitfieldtype_ok = true;
+}
 /*
  * PROTOLIB in conjunction with LINTLIBRARY can be used to handle
  * prototypes like function definitions. This is done if the argument
- * to PROTOLIB is nonzero. Otherwise prototypes are handled normally.
+ * to PROTOLIB is nonzero. Otherwise, prototypes are handled normally.
  */
 void
 protolib(int n)
+{
 	if (dcs->d_kind != DK_EXTERN) {
 		/* comment ** %s ** must be outside function */
 		warning(280, "PROTOLIB");
 		return;
+	}
 	plibflg = n != 0;
+}

 @@ -1,14 +1,14 @@
-/* $NetBSD: lint1.h,v 1.164 2023/04/22 17:49:15 rillig Exp $ */
+/* $NetBSD: lint1.h,v 1.165 2023/06/09 15:36:31 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
 @@ -100,28 +100,28 @@ typedef enum {
 } tqual_t;
 /* An integer or floating-point value. */
 typedef struct {
 	tspec_t	v_tspec;
 	/*
 	 * Set if an integer constant is unsigned only in C90 and later, but
 	 * not in traditional C.
+	 *
 	 * See the operators table in ops.def, columns "l r".
 	 */
 	bool	v_unsigned_since_c90;
 	union {
-		int64_t	_v_quad;	/* integers */
+		int64_t		_v_quad;	/* integers */
-		ldbl_t	_v_ldbl;	/* floats */
+		long double	_v_ldbl;	/* floats */
 	} v_u;
 } val_t;
 #define v_quad	v_u._v_quad
 #define v_ldbl	v_u._v_ldbl
 /*
  * Structures of type struct_or_union uniquely identify structures. This can't
  * be done in structures of type type_t, because these are copied
  * if they must be modified. So it would not be possible to check
  * if two structures are identical by comparing the pointers to
  * the type structures.
+ *
 @@ -365,27 +365,27 @@ typedef	struct dinfo {
 				   for all declarators */
 	sym_t	*d_redeclared_symbol;
 	unsigned int d_offset_in_bits; /* offset of next structure member */
 	unsigned short d_sou_align_in_bits; /* alignment required for current
 				 * structure */
 	bool	d_const:1;	/* const in declaration specifiers */
 	bool	d_volatile:1;	/* volatile in declaration specifiers */
 	bool	d_inline:1;	/* inline in declaration specifiers */
 	bool	d_multiple_storage_classes:1; /* reported in dcs_end_type */
 	bool	d_invalid_type_combination:1;
 	bool	d_nonempty_decl:1; /* if at least one tag is declared
 				 * ... in the current function decl. */
 	bool	d_vararg:1;
-	bool	d_proto:1;	/* current function decl. is prototype */
+	bool	d_proto:1;	/* current function decl. is a prototype */
 	bool	d_notyp:1;	/* set if no type specifier was present */
 	bool	d_asm:1;	/* set if d_ctx == AUTO and asm() present */
 	bool	d_packed:1;
 	bool	d_used:1;
 	type_t	*d_tagtyp;	/* tag during member declaration */
 	sym_t	*d_func_args;	/* list of arguments during function def. */
 	pos_t	d_func_def_pos;	/* position of function definition */
 	sym_t	*d_dlsyms;	/* first symbol declared at this level */
 	sym_t	**d_ldlsym;	/* points to s_level_next in the last symbol
 				   declaration at this level */
 	sym_t	*d_func_proto_syms; /* symbols defined in prototype */
 	struct dinfo *d_enclosing; /* the enclosing declaration level */
 } dinfo_t;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: tree.c,v 1.526 2023/06/09 13:03:49 rillig Exp $	*/
+/*	$NetBSD: tree.c,v 1.527 2023/06/09 15:36:31 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.526 2023/06/09 13:03:49 rillig Exp $");
+__RCSID("$NetBSD: tree.c,v 1.527 2023/06/09 15:36:31 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 {
 @@ -792,44 +792,44 @@ fold(tnode_t *tn)
 	int64_t sl, sr = 0, q = 0, mask;
 	uint64_t ul, ur = 0;
 	tnode_t *cn;
 	v = xcalloc(1, sizeof(*v));
 	v->v_tspec = tn->tn_type->t_tspec;
 	t = tn->tn_left->tn_type->t_tspec;
 	utyp = !is_integer(t) || is_uinteger(t);
 	ul = sl = tn->tn_left->tn_val->v_quad;
 	if (is_binary(tn))
 		ur = sr = tn->tn_right->tn_val->v_quad;
-	mask = value_bits(size_in_bits(t));
+	mask = (int64_t)value_bits(size_in_bits(t));
 	ovfl = false;
 	switch (tn->tn_op) {
 	case UPLUS:
 		q = sl;
 		break;
 	case UMINUS:
 		q = sl == INT64_MIN ? sl : -sl;
 		if (sl != 0 && msb(q, t) == msb(sl, t))
 			ovfl = true;
 		break;
 	case COMPL:
 		q = ~sl;
 		break;
 	case MULT:
 		if (utyp) {
-			q = ul * ur;
+			q = (int64_t)(ul * ur);
 			if (q != (q & mask))
 				ovfl = true;
 			else if ((ul != 0) && ((q / ul) != ur))
 				ovfl = true;
 		} else {
 			q = sl * sr;
 			if (msb(q, t) != (msb(sl, t) ^ msb(sr, t)))
 				ovfl = true;
+		}
 		break;
 	case DIV:
 		if (sr == 0) {
 			/* division by 0 */
 @@ -863,27 +863,27 @@ fold(tnode_t *tn)
 			ovfl = true;
 		break;
 	case SHL:
 		/* TODO: warn about out-of-bounds 'sr'. */
 		/* TODO: warn about overflow in signed '<<'. */
 		q = utyp ? (int64_t)(ul << (sr & 63)) : sl << (sr & 63);
 		break;
 	case SHR:
 		/*
 		 * The sign must be explicitly extended because
 		 * shifts of signed values are implementation dependent.
 		 */
 		/* TODO: warn about out-of-bounds 'sr'. */
-		q = ul >> (sr & 63);
+		q = (int64_t)(ul >> (sr & 63));
 		q = convert_integer(q, t, size_in_bits(t) - (int)sr);
 		break;
 	case LT:
 		q = (utyp ? ul < ur : sl < sr) ? 1 : 0;
 		break;
 	case LE:
 		q = (utyp ? ul <= ur : sl <= sr) ? 1 : 0;
 		break;
 	case GE:
 		q = (utyp ? ul >= ur : sl >= sr) ? 1 : 0;
 		break;
 	case GT:
 		q = (utyp ? ul > ur : sl > sr) ? 1 : 0;
 @@ -993,27 +993,27 @@ subt_size_in_bytes(type_t *tp)
+	}
 	switch (tp->t_tspec) {
 	case FUNC:
 		/* pointer to function is not allowed here */
 		error(110);
 		break;
 	case VOID:
 		/* cannot do pointer arithmetic on operand of unknown size */
 		gnuism(136);
 		break;
 	case STRUCT:
 	case UNION:
-		if ((elsz_in_bits = tp->t_sou->sou_size_in_bits) == 0)
+		if ((elsz_in_bits = (int)tp->t_sou->sou_size_in_bits) == 0)
 			/* cannot do pointer arithmetic on operand of ... */
 			error(136);
 		break;
 	case ENUM:
 		if (is_incomplete(tp)) {
 			/* cannot do pointer arithmetic on operand of ... */
 			warning(136);
+		}
 		/* FALLTHROUGH */
 	default:
 		if ((elsz_in_bits = size_in_bits(tp->t_tspec)) == 0) {
 			/* cannot do pointer arithmetic on operand of ... */
 			error(136);
 @@ -1531,64 +1531,64 @@ fold_bool(tnode_t *tn)
 	case LOGAND:
 		v->v_quad = l && r ? 1 : 0;
 		break;
 	case LOGOR:
 		v->v_quad = l || r ? 1 : 0;
 		break;
 	default:
 		lint_assert(/*CONSTCOND*/false);
+	}
 	return build_constant(tn->tn_type, v);
+}
-static ldbl_t
+static long double
-floating_error_value(tspec_t t, ldbl_t lv)
+floating_error_value(tspec_t t, long double lv)
+{
 	if (t == FLOAT)
 		return lv < 0 ? -FLT_MAX : FLT_MAX;
 	if (t == DOUBLE)
 		return lv < 0 ? -DBL_MAX : DBL_MAX;
 	/*
 	 * When NetBSD is cross-built in MKLINT=yes mode on x86_64 for
 	 * sparc64, tools/lint checks this code while building usr.bin/xlint.
 	 * In that situation, lint uses the preprocessor for sparc64, in which
 	 * the type 'long double' is IEEE-754-binary128, affecting the macro
 	 * LDBL_MAX below. The type 'long double', as well as the strtold
 	 * implementation, comes from the host platform x86_64 though, where
 	 * 'long double' consumes 128 bits as well but only uses 80 of them.
 	 * The exponent range of the two 'long double' types is the same, but
 	 * the maximum finite value differs due to the extended precision on
 	 * sparc64.
+	 *
 	 * To properly handle the data types of the target platform, lint
 	 * would have to implement the floating-point types in a
 	 * platform-independent way, which is not worth the effort, given how
 	 * few programs practically use 'long double'.
 	 */
 	/* LINTED 248: floating-point constant out of range */
-	ldbl_t max = LDBL_MAX;
+	long double 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;
 	tspec_t t;
-	ldbl_t lv, rv = 0;
+	long double 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;
 @@ -1671,27 +1671,27 @@ build_binary(tnode_t *ln, op_t op, bool
+{
 	const mod_t *mp;
 	tnode_t *ntn;
 	type_t *rettp;
 	mp = &modtab[op];
 	/* If there was an error in one of the operands, return. */
 	if (ln == NULL || (mp->m_binary && rn == NULL))
 		return NULL;
 	/*
 	 * Apply class conversions to the left operand, but only if its
-	 * value is needed or it is compared with zero.
+	 * value is needed or compared with zero.
 	 */
 	if (mp->m_value_context || mp->m_compares_with_zero)
 		ln = cconv(ln);
 	/*
 	 * The right operand is almost always in a test or value context,
 	 * except if it is a struct or union member.
 	 */
 	if (mp->m_binary && op != ARROW && op != POINT)
 		rn = cconv(rn);
 	/*
 	 * Print some warnings for comparisons of unsigned values with
 	 * constants lower than or equal to null. This must be done
 @@ -3666,27 +3666,27 @@ convert(op_t op, int arg, type_t *tp, tn
 		ntn->tn_op = CON;
 		ntn->tn_val = expr_zero_alloc(sizeof(*ntn->tn_val));
 		convert_constant(op, arg, ntn->tn_type, ntn->tn_val,
 		    tn->tn_val);
+	}
 	return ntn;
+}
 static void
 convert_constant_floating(op_t op, int arg, tspec_t ot, const type_t *tp,
 			  tspec_t nt, val_t *v, val_t *nv)
+{
-	ldbl_t max = 0.0, min = 0.0;
+	long double max = 0.0, min = 0.0;
 	switch (nt) {
 	case CHAR:
 		max = TARG_CHAR_MAX;	min = TARG_CHAR_MIN;	break;
 	case UCHAR:
 		max = TARG_UCHAR_MAX;	min = 0;		break;
 	case SCHAR:
 		max = TARG_SCHAR_MAX;	min = TARG_SCHAR_MIN;	break;
 	case SHORT:
 		max = TARG_SHRT_MAX;	min = TARG_SHRT_MIN;	break;
 	case USHORT:
 		max = TARG_USHRT_MAX;	min = 0;		break;
 	case ENUM:
 @@ -3744,27 +3744,27 @@ convert_constant_floating(op_t op, int a
 static bool
 convert_constant_to_floating(tspec_t nt, val_t *nv,
 			     tspec_t ot, const val_t *v)
+{
 	if (nt == FLOAT) {
 		nv->v_ldbl = (ot == PTR || is_uinteger(ot)) ?
 		    (float)(uint64_t)v->v_quad : (float)v->v_quad;
 	} else if (nt == DOUBLE) {
 		nv->v_ldbl = (ot == PTR || is_uinteger(ot)) ?
 		    (double)(uint64_t)v->v_quad : (double)v->v_quad;
 	} else if (nt == LDOUBLE) {
 		nv->v_ldbl = (ot == PTR || is_uinteger(ot)) ?
-		    (ldbl_t)(uint64_t)v->v_quad : (ldbl_t)v->v_quad;
+		    (long double)(uint64_t)v->v_quad : (long double)v->v_quad;
 	} else
 		return false;
 	return true;
+}
 /*
  * Print a warning if bits which were set are lost due to the conversion.
  * This can happen with operator ORASS only.
  */
 static void
 convert_constant_check_range_bitor(size_t nsz, size_t osz, const val_t *v,
 				   uint64_t xmask, op_t op)
+{
 @@ -3816,27 +3816,27 @@ convert_constant_check_range_signed(op_t
 	} else {
 		/* conversion of negative constant to unsigned type */
 		warning(222);
+	}
+}
 /*
  * Loss of significant bit(s). All truncated bits of unsigned types or all
  * truncated bits plus the msb of the target for signed types are considered
  * to be significant bits. Loss of significant bits means that at least one
  * of the bits was set in an unsigned type or that at least one but not all
  * of the bits was set in a signed type. Loss of significant bits means that
  * it is not possible, also not with necessary casts, to convert back to the
- * original type. A example for a necessary cast is:
+ * original type. An example for a necessary cast is:
  *	char c;	int	i; c = 128;
  *	i = c;			** yields -128 **
  *	i = (unsigned char)c;	** yields 128 **
  */
 static void
 convert_constant_check_range_truncated(op_t op, int arg, const type_t *tp,
 				       tspec_t ot)
+{
 	if (op == ASSIGN && tp->t_bitfield) {
 		/* precision lost in bit-field assignment */
 		warning(166);
 	} else if (op == ASSIGN) {
 		/* constant truncated by assignment */
 @@ -4382,27 +4382,27 @@ constant(tnode_t *tn, bool required)
 		return v;
+	}
 	v->v_tspec = tn->tn_type->t_tspec;
 	if (tn->tn_op == CON) {
 		lint_assert(tn->tn_type->t_tspec == tn->tn_val->v_tspec);
 		if (is_integer(tn->tn_val->v_tspec)) {
 			v->v_unsigned_since_c90 =
 			    tn->tn_val->v_unsigned_since_c90;
 			v->v_quad = tn->tn_val->v_quad;
 			return v;
+		}
-		v->v_quad = tn->tn_val->v_ldbl;
+		v->v_quad = (int64_t)tn->tn_val->v_ldbl;
 	} else {
 		v->v_quad = 1;
+	}
 	if (required)
 		/* integral constant expression expected */
 		error(55);
 	else
 		/* variable array dimension is a C99/GCC extension */
 		c99ism(318);
 	if (!is_integer(v->v_tspec))
 		v->v_tspec = INT;
 @@ -4540,27 +4540,27 @@ check_expr_load(const tnode_t *ln)
 		/* check the range of array indices */
 		check_array_index(ln->tn_left, false);
+}
 static void
 check_expr_side_effect(const tnode_t *ln, bool szof)
+{
 	dinfo_t *di;
 	/* XXX: Taking warn_about_unreachable into account here feels wrong. */
 	if (ln->tn_op == NAME && (reached || !warn_about_unreachable)) {
 		scl_t sc = ln->tn_sym->s_scl;
 		/*
-		 * Look if there was a asm statement in one of the
+		 * Look if there was an asm statement in one of the
 		 * compound statements we are in. If not, we don't
 		 * print a warning.
 		 */
 		for (di = dcs; di != NULL; di = di->d_enclosing) {
 			if (di->d_asm)
 				break;
+		}
 		if (sc != EXTERN && sc != STATIC &&
 		    !ln->tn_sym->s_set && !szof && di == NULL) {
 			/* '%s' may be used before set */
 			warning(158, ln->tn_sym->s_name);
 			mark_as_set(ln->tn_sym);
+		}
 @@ -4764,27 +4764,27 @@ constant_addr(const tnode_t *tn, const s
 		} else {
 			return false;
+		}
 		*symp = sym;
 		*offsp = offs1 + offs2;
 		return true;
 	case ADDR:
 		if (tn->tn_left->tn_op == NAME) {
 			*symp = tn->tn_left->tn_sym;
 			*offsp = 0;
 			return true;
 		} else {
 			/*
-			 * If this would be the front end of a compiler we
+			 * If this were the front end of a compiler, we
 			 * would return a label instead of 0, at least if
 			 * 'tn->tn_left->tn_op == STRING'.
 			 */
 			*symp = NULL;
 			*offsp = 0;
 			return true;
+		}
 	case CVT:
 		t = tn->tn_type->t_tspec;
 		ot = tn->tn_left->tn_type->t_tspec;
 		if ((!is_integer(t) && t != PTR) ||
 		    (!is_integer(ot) && ot != PTR)) {
 			return false;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: param.h,v 1.10 2023/01/14 09:21:58 rillig Exp $	*/
+/*	$NetBSD: param.h,v 1.11 2023/06/09 15:36:31 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.
 @@ -43,22 +43,13 @@
 #define	HSHSIZ1		503
 #define HSHSIZ2		1009
 #define	THSHSIZ2	1009
 /*
  * Pull in target-specific parameters.
  */
 #include "targparam.h"
 /*
  * Make sure this matches wchar_t.
  */
 #define WCHAR	INT
 /*
  * The sparc64 long double code generation is broken in old gcc.
  */
 #if !(defined(__sparc64__) && defined(__GNUC__) && __GNUC__ <= 2)
 typedef	long double ldbl_t;
 #else
 typedef	double	ldbl_t;
 #endif