 @@ -1,14 +1,14 @@
-/* $NetBSD: decl.c,v 1.364 2023/07/29 07:03:19 rillig Exp $ */
+/* $NetBSD: decl.c,v 1.365 2023/07/29 07:26:53 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.364 2023/07/29 07:03:19 rillig Exp $");
+__RCSID("$NetBSD: decl.c,v 1.365 2023/07/29 07:26:53 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];
 @@ -2782,27 +2782,27 @@ global_clean_up(void)
+}
 sym_t *
 declare_abstract_type(sym_t *sym)
+{
 	check_function_definition(sym, true);
 	check_type(sym);
 	return sym;
+}
 /* Checks size after declarations of variables and their initialization. */
 void
-check_size(sym_t *dsym)
+check_size(const sym_t *dsym)
+{
 	if (dsym->s_def == DEF &&
 	    dsym->s_scl != TYPEDEF &&
 	    dsym->s_type->t_tspec != FUNC &&
 	    length_in_bits(dsym->s_type, dsym->s_name) == 0 &&
 	    dsym->s_type->t_tspec == ARRAY &&
 	    dsym->s_type->t_dim == 0) {
 		if (!allow_c90)
 			/* empty array declaration for '%s' */
 			warning(190, dsym->s_name);
 		else
 			/* empty array declaration for '%s' */
 @@ -2833,57 +2833,57 @@ mark_as_used(sym_t *sym, bool fcall, boo
 	/*
 	 * For function calls, another record is written.
+	 *
 	 * XXX: Should symbols used in sizeof() be treated as used or not?
 	 * Probably not, because there is no point in declaring an external
 	 * variable only to get its size.
 	 */
 	if (!fcall && !szof && sym->s_kind == FVFT && sym->s_scl == EXTERN)
 		outusg(sym);
+}
 /* Warns about variables and labels that are not used or only set. */
 void
-check_usage(decl_level *dl)
+check_usage(const decl_level *dl)
+{
 	/* for this warning LINTED has no effect */
 	int saved_lwarn = lwarn;
 	lwarn = LWARN_ALL;
 	debug_step("begin lwarn %d", lwarn);
 	for (sym_t *sym = dl->d_first_dlsym;
 	     sym != NULL; sym = sym->s_level_next)
 		check_usage_sym(dl->d_asm, sym);
 	lwarn = saved_lwarn;
 	debug_step("end lwarn %d", lwarn);
+}
 static void
-check_argument_usage(bool novar, sym_t *arg)
+check_argument_usage(bool novar, const sym_t *arg)
+{
 	lint_assert(arg->s_set);
 	if (novar)
 		return;
 	if (!arg->s_used && !vflag) {
 		/* parameter '%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)
+check_variable_usage(bool novar, const sym_t *sym)
+{
 	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 (seen_error)
 		return;
 	/*
 @@ -2931,45 +2931,45 @@ check_variable_usage(bool novar, sym_t *
 			if (sym->s_used && !xsym->s_used) {
 				xsym->s_used = true;
 				xsym->s_use_pos = sym->s_use_pos;
+			}
 			if (sym->s_set && !xsym->s_set) {
 				xsym->s_set = true;
 				xsym->s_set_pos = sym->s_set_pos;
+			}
+		}
+	}
+}
 static void
-check_label_usage(sym_t *lab)
+check_label_usage(const sym_t *lab)
+{
 	lint_assert(block_level == 1);
 	lint_assert(lab->s_block_level == 1);
 	if (funcsym == NULL)
 		/* syntax error '%s' */
 		error(249, "labels are only valid inside a function");
 	else if (lab->s_set && !lab->s_used)
 		/* label '%s' unused in function '%s' */
 		warning_at(232, &lab->s_set_pos, lab->s_name, funcsym->s_name);
 	else if (!lab->s_set)
 		/* undefined label '%s' */
 		warning_at(23, &lab->s_use_pos, lab->s_name);
+}
 static void
-check_tag_usage(sym_t *sym)
+check_tag_usage(const sym_t *sym)
+{
 	if (!is_incomplete(sym->s_type))
 		return;
 	/* always complain about incomplete tags declared inside blocks */
 	if (zflag || dcs->d_kind != DLK_EXTERN)
 		return;
 	switch (sym->s_type->t_tspec) {
 	case STRUCT:
 		/* struct '%s' never defined */
 		warning_at(233, &sym->s_def_pos, sym->s_name);
 @@ -2978,27 +2978,27 @@ check_tag_usage(sym_t *sym)
 		/* union '%s' never defined */
 		warning_at(234, &sym->s_def_pos, sym->s_name);
 		break;
 	default:
 		lint_assert(sym->s_type->t_tspec == ENUM);
 		/* enum '%s' never defined */
 		warning_at(235, &sym->s_def_pos, sym->s_name);
 		break;
+	}
+}
 /* Warns about a variable or a label that is not used or only set. */
 void
-check_usage_sym(bool novar, sym_t *sym)
+check_usage_sym(bool novar, const sym_t *sym)
+{
 	if (sym->s_block_level == -1)
 		return;
 	if (sym->s_kind == FVFT && sym->s_arg)
 		check_argument_usage(novar, sym);
 	else if (sym->s_kind == FVFT)
 		check_variable_usage(novar, sym);
 	else if (sym->s_kind == FLABEL)
 		check_label_usage(sym);
 	else if (sym->s_kind == FTAG)
 		check_tag_usage(sym);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: externs1.h,v 1.200 2023/07/29 06:44:44 rillig Exp $	*/
+/*	$NetBSD: externs1.h,v 1.201 2023/07/29 07:26:53 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.
 @@ -240,31 +240,31 @@ void	declare(sym_t *, bool, sbuf_t *);
 void	copy_usage_info(sym_t *, sym_t *);
 bool	check_redeclaration(sym_t *, bool *);
 bool	pointer_types_are_compatible(const type_t *, const type_t *, bool);
 bool	types_compatible(const type_t *, const type_t *, bool, bool, bool *);
 void	complete_type(sym_t *, sym_t *);
 sym_t	*declare_argument(sym_t *, bool);
 void	check_func_lint_directives(void);
 void	check_func_old_style_arguments(void);
 void	declare_local(sym_t *, bool);
 sym_t	*abstract_name(void);
 void	global_clean_up(void);
 sym_t	*declare_abstract_type(sym_t *);
-void	check_size(sym_t *);
+void	check_size(const sym_t *);
 void	mark_as_set(sym_t *);
 void	mark_as_used(sym_t *, bool, bool);
-void	check_usage(decl_level *);
+void	check_usage(const decl_level *);
-void	check_usage_sym(bool, sym_t *);
+void	check_usage_sym(bool, const sym_t *);
 void	check_global_symbols(void);
 void	print_previous_declaration(const sym_t *);
 int	to_int_constant(tnode_t *, bool);
 /*
  * tree.c
  */
 const tnode_t *before_conversion(const tnode_t *);
 type_t	*block_derive_type(type_t *, tspec_t);
 type_t	*expr_derive_type(type_t *, tspec_t);
 bool	is_compiler_builtin(const char *);
 tnode_t	*build_constant(type_t *, val_t *);
 tnode_t	*build_name(sym_t *, bool);