 @@ -1,15 +1,15 @@
 %{
-/* $NetBSD: cgram.y,v 1.466 2023/07/28 21:50:03 rillig Exp $ */
+/* $NetBSD: cgram.y,v 1.467 2023/08/01 16:08:58 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
 @@ -25,27 +25,27 @@
  * 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: cgram.y,v 1.466 2023/07/28 21:50:03 rillig Exp $");
+__RCSID("$NetBSD: cgram.y,v 1.467 2023/08/01 16:08:58 rillig Exp $");
 #endif
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 extern char *yytext;
 /*
  * Contains the level of current declaration, used for symbol table entries.
  * 0 is the top-level, > 0 is inside a function body.
 @@ -153,27 +153,31 @@ is_either(const char *s, const char *a,
 	struct generic_association *y_generic;
 	struct array_size y_array_size;
 	bool	y_in_system_header;
 };
 /* for Bison:
 %printer {
 	if (is_integer($$->v_tspec))
 		fprintf(yyo, "%lld", (unsigned long long)$$->u.integer);
 	else
 		fprintf(yyo, "%Lg", $$->u.floating);
 } <y_val>
 %printer { fprintf(yyo, "'%s'", $$ != NULL ? $$->sb_name : "<null>"); } <y_name>
-%printer { debug_sym("", $$, ""); } <y_sym>
+%printer {
 	bool indented = debug_push_indented(true);
 	debug_sym("", $$, "");
 	debug_pop_indented(indented);
 } <y_sym>
 %printer { fprintf(yyo, "%s", op_name($$)); } <y_op>
 %printer { fprintf(yyo, "%s", scl_name($$)); } <y_scl>
 %printer { fprintf(yyo, "%s", tspec_name($$)); } <y_tspec>
 %printer { fprintf(yyo, "%s", type_qualifiers_string($$)); } <y_type_qualifiers>
 %printer {
 	fprintf(yyo, "%s", function_specifier_name($$));
 } <y_function_specifier>
 %printer { fprintf(yyo, "%s", type_name($$)); } <y_type>
 %printer {
 	if ($$ == NULL)
 		fprintf(yyo, "<null>");
 	else
 		fprintf(yyo, "%s '%s'",

 @@ -1,14 +1,14 @@
-/* $NetBSD: debug.c,v 1.58 2023/07/30 22:27:21 rillig Exp $ */
+/* $NetBSD: debug.c,v 1.59 2023/08/01 16:08:58 rillig Exp $ */
 /*-
  * Copyright (c) 2021 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Roland Illig <rillig@NetBSD.org>.
+ *
  * 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.
 @@ -25,27 +25,27 @@
  * 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: debug.c,v 1.58 2023/07/30 22:27:21 rillig Exp $");
+__RCSID("$NetBSD: debug.c,v 1.59 2023/08/01 16:08:58 rillig Exp $");
 #endif
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 #include "cgram.h"
 #ifdef DEBUG
 static int debug_indentation = 0;
 static bool did_indentation;
 @@ -98,26 +98,40 @@ debug_indent_inc(void)
+{
 	debug_indentation++;
+}
 void
 debug_indent_dec(void)
+{
 	lint_assert(debug_indentation > 0);
 	debug_indentation--;
+}
 bool
 debug_push_indented(bool indented)
+{
 	bool prev = did_indentation;
 	did_indentation = indented;
 	return prev;
+}
 void
 debug_pop_indented(bool indented)
+{
 	did_indentation = indented;
+}
 void
 debug_step(const char *fmt, ...)
+{
 	va_list va;
 	va_start(va, fmt);
 	debug_vprintf(fmt, va);
 	va_end(va);
 	debug_printf("\n");
+}
 void
 debug_enter_func(const char *func)
 @@ -416,27 +430,27 @@ debug_sym(const char *prefix, const sym_
 	debug_word(sym->s_osdef && sym->u.s_old_style_args != NULL,
 	    "old-style-args");
 	if (strcmp(suffix, "\n") == 0)
 		debug_printf("\n");
 	else
 		debug_printf("%s", suffix);
+}
 static void
 debug_decl_level(const decl_level *dl)
+{
-	debug_printf("decl_level: %s", decl_level_kind_name(dl->d_kind));
+	debug_printf("kind=%s", decl_level_kind_name(dl->d_kind));
 	if (dl->d_scl != NOSCL)
 		debug_printf(" %s", scl_name(dl->d_scl));
 	if (dl->d_type != NULL)
 		debug_printf(" '%s'", type_name(dl->d_type));
 	else {
 		if (dl->d_abstract_type != NO_TSPEC)
 			debug_printf(" %s", tspec_name(dl->d_abstract_type));
 		if (dl->d_complex_mod != NO_TSPEC)
 			debug_printf(" %s", tspec_name(dl->d_complex_mod));
 		if (dl->d_sign_mod != NO_TSPEC)
 			debug_printf(" %s", tspec_name(dl->d_sign_mod));
 		if (dl->d_rank_mod != NO_TSPEC)
 			debug_printf(" %s", tspec_name(dl->d_rank_mod));
 @@ -467,25 +481,29 @@ debug_decl_level(const decl_level *dl)
 	     arg != NULL; arg = arg->s_next)
 		debug_sym(" arg(", arg, ")");
 	if (dl->d_func_def_pos.p_file != NULL)
 		debug_printf(" func_def_pos=%s:%d:%d",
 		    dl->d_func_def_pos.p_file, dl->d_func_def_pos.p_line,
 		    dl->d_func_def_pos.p_uniq);
 	for (const sym_t *sym = dl->d_func_proto_syms;
 	     sym != NULL; sym = sym->s_next)
 		debug_sym(" func_proto_sym(", sym, ")");
 	debug_printf("\n");
+}
 void
-debug_dcs(bool all)
+debug_dcs(void)
+{
 	debug_printf("dcs ");
 	debug_decl_level(dcs);
+}
 void
 debug_dcs_all(void)
+{
-	int prev_indentation = debug_indentation;
+	size_t i = 0;
 	for (const decl_level *dl = dcs; dl != NULL; dl = dl->d_enclosing) {
 		debug_printf("dcs[%zu] ", i++);
 		debug_decl_level(dl);
 		if (!all)
 			return;
 		debug_indentation++;
+	}
 	debug_indentation = prev_indentation;
+}
 #endif

 @@ -1,14 +1,14 @@
-/* $NetBSD: decl.c,v 1.370 2023/07/31 20:31:58 rillig Exp $ */
+/* $NetBSD: decl.c,v 1.371 2023/08/01 16:08:58 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.370 2023/07/31 20:31:58 rillig Exp $");
+__RCSID("$NetBSD: decl.c,v 1.371 2023/08/01 16:08:58 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];
 @@ -206,28 +206,28 @@ dcs_add_storage_class(scl_t sc)
 		warning(83);
+	}
 	if (dcs->d_scl == NOSCL)
 		dcs->d_scl = sc;
 	else if ((dcs->d_scl == EXTERN && sc == THREAD_LOCAL)
 	    || (dcs->d_scl == THREAD_LOCAL && sc == EXTERN))
 		dcs->d_scl = EXTERN;	/* ignore thread_local */
 	else if ((dcs->d_scl == STATIC && sc == THREAD_LOCAL)
 	    || (dcs->d_scl == THREAD_LOCAL && sc == STATIC))
 		dcs->d_scl = STATIC;	/* ignore thread_local */
 	else
 		dcs->d_multiple_storage_classes = true;
-	debug_step("%s:", __func__);
+	debug_printf("%s: ", __func__);
-	debug_dcs(false);
+	debug_dcs();
+}
 /* Merge the signedness into the abstract type. */
 static tspec_t
 merge_signedness(tspec_t t, tspec_t s)
+{
 	if (s == SIGNED)
 		return t == CHAR ? SCHAR : t;
 	if (s != UNSIGN)
 		return t;
 	return t == CHAR ? UCHAR
 	    : t == SHORT ? USHORT
 @@ -305,27 +305,27 @@ invalid:
  * Remember the type, modifier or typedef name returned by the parser in the
  * top element of the declaration 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)
+{
 	debug_step("%s: %s", __func__, type_name(tp));
-	debug_dcs(false);
+	debug_dcs();
 	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;
 		return;
+	}
 @@ -334,27 +334,27 @@ dcs_add_type(type_t *tp)
 	if (is_struct_or_union(t) || t == ENUM) {
 		/*
 		 * something like "int struct a ..."
 		 * struct/union/enum with anything else is not allowed
 		 */
 		if (dcs->d_type != NULL || dcs->d_abstract_type != NO_TSPEC ||
 		    dcs->d_rank_mod != NO_TSPEC || dcs->d_sign_mod != NO_TSPEC) {
 			dcs->d_invalid_type_combination = true;
 			dcs->d_abstract_type = NO_TSPEC;
 			dcs->d_sign_mod = NO_TSPEC;
 			dcs->d_rank_mod = NO_TSPEC;
+		}
 		dcs->d_type = tp;
-		debug_dcs(false);
+		debug_dcs();
 		return;
+	}
 	if (dcs->d_type != NULL && !dcs->d_type->t_typedef) {
 		/*
 		 * something like "struct a int"
 		 * struct/union/enum with anything else is not allowed
 		 */
 		dcs->d_invalid_type_combination = true;
 		return;
+	}
 	if (t == COMPLEX) {
 @@ -402,27 +402,27 @@ dcs_add_type(type_t *tp)
 			dcs->d_complex_mod = t;
 		} else {
 			if (dcs->d_abstract_type != NO_TSPEC)
 				dcs->d_invalid_type_combination = true;
 			dcs->d_abstract_type = t;
+		}
 	} else if (t == PTR) {
 		dcs->d_type = tp;
 	} else {
 		if (dcs->d_abstract_type != NO_TSPEC)
 			dcs->d_invalid_type_combination = true;
 		dcs->d_abstract_type = t;
+	}
-	debug_dcs(false);
+	debug_dcs();
+}
 static void
 set_first_typedef(type_t *tp, sym_t *sym)
+{
 	tspec_t t = tp->t_tspec;
 	if (is_struct_or_union(t) && tp->t_sou->sou_first_typedef == NULL)
 		tp->t_sou->sou_first_typedef = sym;
 	if (t == ENUM && tp->t_enum->en_first_typedef == NULL)
 		tp->t_enum->en_first_typedef = sym;
+}
 @@ -460,27 +460,27 @@ pack_struct_or_union(type_t *tp)
 		// TODO: Maybe update mem->u.s_member.sm_offset_in_bits.
 		if (mem->s_type->t_bitfield) {
 			bits += bit_fields_width(&mem, &named);
 			if (mem == NULL)
 				break;
+		}
 		unsigned int mem_bits = type_size_in_bits(mem->s_type);
 		if (tp->t_tspec == STRUCT)
 			bits += mem_bits;
 		else if (mem_bits > bits)
 			bits = mem_bits;
+	}
 	tp->t_sou->sou_size_in_bits = bits;
-	debug_dcs(false);
+	debug_dcs();
+}
 void
 dcs_add_packed(void)
+{
 	if (dcs->d_type == NULL)
 		dcs->d_packed = true;
 	else
 		pack_struct_or_union(dcs->d_type);
+}
 void
 dcs_set_used(void)
 @@ -499,34 +499,34 @@ dcs_add_qualifiers(type_qualifiers qs)
 	add_type_qualifiers(&dcs->d_qual, qs);
+}
 void
 begin_declaration_level(decl_level_kind kind)
+{
 	decl_level *dl = xcalloc(1, sizeof(*dl));
 	dl->d_enclosing = dcs;
 	dl->d_kind = kind;
 	dl->d_last_dlsym = &dl->d_first_dlsym;
 	dcs = dl;
 	debug_enter();
-	debug_dcs(true);
+	debug_dcs_all();
+}
 void
 end_declaration_level(void)
+{
-	debug_dcs(true);
+	debug_dcs_all();
 	decl_level *dl = dcs;
 	dcs = dl->d_enclosing;
 	lint_assert(dcs != NULL);
 	switch (dl->d_kind) {
 	case DLK_STRUCT:
 	case DLK_UNION:
 	case DLK_ENUM:
 		/*
 		 * Symbols declared in (nested) structs or enums are part of
 		 * the next level (they are removed from the symbol table if
 		 * the symbols of the outer level are removed).
 @@ -647,28 +647,26 @@ dcs_merge_declaration_specifiers(void)
 	tspec_t t = dcs->d_abstract_type;
 	tspec_t c = dcs->d_complex_mod;
 	tspec_t s = dcs->d_sign_mod;
 	tspec_t l = dcs->d_rank_mod;
 	type_t *tp = dcs->d_type;
 	if (tp != NULL) {
 		lint_assert(t == NO_TSPEC);
 		lint_assert(s == NO_TSPEC);
 		lint_assert(l == NO_TSPEC);
 		return;
+	}
 	debug_step("%s: %s", __func__, type_name(tp));
 	if (t == NO_TSPEC && s == NO_TSPEC && l == NO_TSPEC && c == NO_TSPEC)
 		dcs->d_no_type_specifier = true;
 	if (t == NO_TSPEC && s == NO_TSPEC && (l == NO_TSPEC || l == LONG))
 		t = c;
 	if (t == NO_TSPEC)
 		t = INT;
 	if (s == NO_TSPEC && t == INT)
 		s = SIGNED;
 	if (l != NO_TSPEC && t == CHAR) {
 		dcs->d_invalid_type_combination = true;
 		l = NO_TSPEC;
+	}
 @@ -689,27 +687,28 @@ dcs_merge_declaration_specifiers(void)
+	}
 	if (l == LONG && t == DCOMPLEX) {
 		l = NO_TSPEC;
 		t = LCOMPLEX;
+	}
 	if (t != INT && t != CHAR && (s != NO_TSPEC || l != NO_TSPEC)) {
 		dcs->d_invalid_type_combination = true;
 		l = s = NO_TSPEC;
+	}
 	if (l != NO_TSPEC)
 		t = l;
 	dcs->d_type = gettyp(merge_signedness(t, s));
-	debug_dcs(false);
+	debug_printf("%s: ", __func__);
 	debug_dcs();
+}
 /* Create a type in 'dcs->d_type' from the information gathered in 'dcs'. */
 void
 dcs_end_type(void)
+{
 	dcs_merge_declaration_specifiers();
 	if (dcs->d_multiple_storage_classes) {
 		/* only one storage class allowed */
 		error(7);
+	}
 @@ -729,27 +728,27 @@ dcs_end_type(void)
 	if (dcs->d_qual.tq_volatile && dcs->d_type->t_volatile &&
 	    !dcs->d_type->t_typeof) {
 		lint_assert(dcs->d_type->t_typedef);
 		/* typedef already qualified with '%s' */
 		warning(68, "volatile");
+	}
 	if (dcs->d_qual.tq_const || dcs->d_qual.tq_volatile) {
 		dcs->d_type = block_dup_type(dcs->d_type);
 		dcs->d_type->t_const |= dcs->d_qual.tq_const;
 		dcs->d_type->t_volatile |= dcs->d_qual.tq_volatile;
+	}
-	debug_dcs(false);
+	debug_dcs();
 	debug_leave();
+}
 /*
  * Return the length of a type in bits. For bit-fields, return the length of
  * the underlying storage type.
+ *
  * Printing a message if the outermost dimension of an array is 0 must
  * be done by the caller. All other problems are reported by this function
  * if name is not NULL.
  */
 int
 length_in_bits(const type_t *tp, const char *name)
 @@ -1040,27 +1039,27 @@ dcs_add_member(sym_t *mem)
 		    - dcs->d_sou_size_in_bits % size_in_bits(tp->t_tspec);
 		tp->t_bit_field_offset = dcs->d_sou_size_in_bits
 		    - mem->u.s_member.sm_offset_in_bits;
 		dcs->d_sou_size_in_bits += tp->t_bit_field_width;
 	} else {
 		dcs_align(alignment_in_bits(tp), 0);
 		mem->u.s_member.sm_offset_in_bits = dcs->d_sou_size_in_bits;
 		dcs->d_sou_size_in_bits += type_size_in_bits(tp);
+	}
 	if (union_size > dcs->d_sou_size_in_bits)
 		dcs->d_sou_size_in_bits = union_size;
-	debug_dcs(false);
+	debug_dcs();
+}
 sym_t *
 declare_unnamed_member(void)
+{
 	sym_t *mem = block_zero_alloc(sizeof(*mem), "sym");
 	mem->s_name = unnamed;
 	mem->s_kind = FMEMBER;
 	mem->s_scl = dcs->d_kind == DLK_STRUCT ? STRUCT_MEMBER : UNION_MEMBER;
 	mem->s_block_level = -1;
 	mem->s_type = dcs->d_type;
 	mem->u.s_member.sm_containing_type = dcs->d_tag_type->t_sou;
 @@ -1185,27 +1184,27 @@ block_derive_pointer(type_t *stp, bool i
 /*
  * The following 3 functions extend the type of a declarator with
  * pointer, function and array types.
+ *
  * The current type is the type built by dcs_end_type (dcs->d_type) and
  * pointer, function and array types already added for this
  * declarator. The new type extension is inserted between both.
  */
 sym_t *
 add_pointer(sym_t *decl, qual_ptr *p)
+{
-	debug_dcs(false);
+	debug_dcs();
 	type_t **tpp = &decl->s_type;
 	while (*tpp != NULL && *tpp != dcs->d_type)
 		tpp = &(*tpp)->t_subt;
 	if (*tpp == NULL) {
 		debug_step("add_pointer: unchanged '%s'",
 		    type_name(decl->s_type));
 		return decl;
+	}
 	while (p != NULL) {
 		*tpp = block_derive_pointer(dcs->d_type,
 		    p->qualifiers.tq_const, p->qualifiers.tq_volatile);
 @@ -1256,27 +1255,27 @@ block_derive_array(type_t *stp, bool dim
 	debug_step("%s: '%s'", __func__, type_name(tp));
 	return tp;
+}
 /*
  * If a dimension was specified, dim is true, otherwise false
  * n is the specified dimension
  */
 sym_t *
 add_array(sym_t *decl, bool dim, int n)
+{
-	debug_dcs(false);
+	debug_dcs();
 	type_t **tpp = &decl->s_type;
 	while (*tpp != NULL && *tpp != dcs->d_type)
 		tpp = &(*tpp)->t_subt;
 	if (*tpp == NULL) {
 		debug_step("add_array: unchanged '%s'",
 		    type_name(decl->s_type));
 		return decl;
+	}
 	*tpp = block_derive_array(dcs->d_type, dim, n);
 	debug_step("%s: '%s'", __func__, type_name(decl->s_type));
 @@ -1339,27 +1338,27 @@ old_style_function(sym_t *decl, sym_t *a
+		}
 	} else {
 		if (args != NULL)
 			/* function prototype parameters must have types */
 			warning(62);
+	}
+}
 sym_t *
 add_function(sym_t *decl, struct parameter_list params)
+{
 	debug_enter();
-	debug_dcs(true);
+	debug_dcs_all();
 	debug_sym("decl: ", decl, "\n");
 #ifdef DEBUG
 	for (const sym_t *arg = params.first; arg != NULL; arg = arg->s_next)
 		debug_sym("arg: ", arg, "\n");
 #endif
 	if (params.prototype) {
 		if (!allow_c90)
 			/* function prototypes are illegal in traditional C */
 			warning(270);
 		check_prototype_parameters(params.first);
 		if (params.first != NULL
 		    && params.first->s_type->t_tspec == VOID)
 @@ -1397,27 +1396,27 @@ add_function(sym_t *decl, struct paramet
 		 */
 		tpp = &(*tpp)->t_subt;
 	if (*tpp == NULL) {
 		debug_step("add_function: unchanged '%s'",
 		    type_name(decl->s_type));
 		debug_leave();
 		return decl;	/* see msg_347 */
+	}
 	*tpp = block_derive_function(dcs->d_enclosing->d_type,
 	    params.prototype, params.first, params.vararg);
 	debug_step("add_function: '%s'", type_name(decl->s_type));
-	debug_dcs(true);
+	debug_dcs_all();
 	debug_leave();
 	return decl;
+}
 /*
  * In a function declaration, a list of identifiers (as opposed to a list of
  * types) is allowed only if it's also a function definition.
  */
 void
 check_function_definition(sym_t *sym, bool msg)
+{
 	if (sym->s_osdef) {

 @@ -1,14 +1,14 @@
-/*	$NetBSD: externs1.h,v 1.203 2023/07/30 22:27:21 rillig Exp $	*/
+/*	$NetBSD: externs1.h,v 1.204 2023/08/01 16:08:58 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.
 @@ -126,51 +126,57 @@ void	expr_free_all(void);
 memory_pool expr_save_memory(void);
 void	expr_restore_memory(memory_pool);
 /*
  * debug.c
  */
 #ifdef DEBUG
 const char *decl_level_kind_name(decl_level_kind);
 const char *scl_name(scl_t);
 const char *symt_name(symt_t);
 const char *type_qualifiers_string(type_qualifiers);
 const char *function_specifier_name(function_specifier);
-void	debug_dcs(bool);
+void	debug_dcs(void);
 void	debug_dcs_all(void);
 void	debug_node(const tnode_t *);
 void	debug_type(const type_t *);
 void	debug_sym(const char *, const sym_t *, const char *);
 void	debug_symtab(void);
 void	debug_printf(const char *fmt, ...) __printflike(1, 2);
 void	debug_skip_indent(void);
 void	debug_indent_inc(void);
 void	debug_indent_dec(void);
 bool	debug_push_indented(bool);
 void	debug_pop_indented(bool);
 void	debug_enter_func(const char *);
 void	debug_step(const char *fmt, ...) __printflike(1, 2);
 void	debug_leave_func(const char *);
 #define	debug_enter()		debug_enter_func(__func__)
 #define	debug_leave()		debug_leave_func(__func__)
 #else
 #define	debug_noop()		do { } while (false)
-#define	debug_dcs(all)		debug_noop()
+#define	debug_dcs()		debug_noop()
 #define	debug_dcs_all()		debug_noop()
 #define	debug_sym(p, sym, s)	debug_noop()
 #define	debug_symtab()		debug_noop()
 #define	debug_node(tn)		debug_noop()
 #define	debug_type(tp)		debug_noop()
 #define	debug_printf(...)	debug_noop()
 #define	debug_skip_indent()	debug_noop()
 #define	debug_indent_inc()	debug_noop()
 #define	debug_indent_dec()	debug_noop()
 #define debug_push_indented(c)	true
 #define debug_pop_indented(c)	(void)(c)
 #define	debug_enter()		debug_noop()
 #define	debug_step(...)		debug_noop()
 #define	debug_leave()		debug_noop()
 #endif
 /*
  * err.c
  */
 extern	bool	seen_error;
 extern	bool	seen_warning;
 extern	int	sytxerr;
 extern	bool	any_query_enabled;