 @@ -1,15 +1,15 @@
 %{
-/* $NetBSD: cgram.y,v 1.386 2022/02/27 19:32:51 rillig Exp $ */
+/* $NetBSD: cgram.y,v 1.387 2022/03/01 00:17:12 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) && !defined(lint)
-__RCSID("$NetBSD: cgram.y,v 1.386 2022/02/27 19:32:51 rillig Exp $");
+__RCSID("$NetBSD: cgram.y,v 1.387 2022/03/01 00:17:12 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.
 @@ -2152,46 +2152,43 @@ yyerror(const char *msg)
+{
 	/* syntax error '%s' */
 	error(249, yytext);
 	if (++sytxerr >= 5)
 		norecover();
 	return 0;
+}
 #if (defined(YYDEBUG) && YYDEBUG > 0 && defined(YYBYACC)) \
     || (defined(YYDEBUG) && defined(YYBISON))
 static const char *
 cgram_to_string(int token, YYSTYPE val)
+{
 	static const char *tqual_name[] = {
 		"const", "volatile", "restrict", "_Thread_local"
 	};
 	switch (token) {
 	case T_INCDEC:
 	case T_MULTIPLICATIVE:
 	case T_ADDITIVE:
 	case T_SHIFT:
 	case T_RELATIONAL:
 	case T_EQUALITY:
 	case T_OPASSIGN:
 		return modtab[val.y_op].m_name;
 	case T_SCLASS:
 		return scl_name(val.y_scl);
 	case T_TYPE:
 	case T_STRUCT_OR_UNION:
 		return tspec_name(val.y_tspec);
 	case T_QUAL:
-		return tqual_name[val.y_tqual];
+		return tqual_name(val.y_tqual);
 	case T_NAME:
 		return val.y_name->sb_name;
 	default:
 		return "<none>";
+	}
+}
 #endif
 #if defined(YYDEBUG) && defined(YYBISON)
 static inline void
 cgram_print(FILE *output, int token, YYSTYPE val)
+{
 	(void)fprintf(output, "%s", cgram_to_string(token, val));

 @@ -1,14 +1,14 @@
-/* $NetBSD: debug.c,v 1.8 2022/02/27 18:29:14 rillig Exp $ */
+/* $NetBSD: debug.c,v 1.9 2022/03/01 00:17:12 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,32 +25,33 @@
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID) && !defined(lint)
-__RCSID("$NetBSD: debug.c,v 1.8 2022/02/27 18:29:14 rillig Exp $");
+__RCSID("$NetBSD: debug.c,v 1.9 2022/03/01 00:17:12 rillig Exp $");
 #endif
 #include <stdlib.h>
 #include "lint1.h"
 #include "cgram.h"
 #ifdef DEBUG
 static int debug_indentation = 0;
 void __printflike(1, 2)
 debug_printf(const char *fmt, ...)
+{
 	va_list va;
 	va_start(va, fmt);
 @@ -119,29 +120,31 @@ debug_node(const tnode_t *tn)
 	debug_print_indent();
 	debug_printf("'%s' with type '%s'%s%s%s",
 	    op == CVT && !tn->tn_cast ? "convert" : modtab[op].m_name,
 	    type_name(tn->tn_type), tn->tn_lvalue ? ", lvalue" : "",
 	    tn->tn_parenthesized ? ", parenthesized" : "",
 	    tn->tn_sys ? ", sys" : "");
 	if (op == NAME)
 		debug_printf(" %s %s\n", tn->tn_sym->s_name,
 		    storage_class_name(tn->tn_sym->s_scl));
 	else if (op == CON && is_floating(tn->tn_type->t_tspec))
 		debug_printf(", value %Lg", tn->tn_val->v_ldbl);
 	else if (op == CON && is_uinteger(tn->tn_type->t_tspec))
-		debug_printf(", value %llu\n", (unsigned long long)tn->tn_val->v_quad);
+		debug_printf(", value %llu\n",
 		    (unsigned long long)tn->tn_val->v_quad);
 	else if (op == CON && is_integer(tn->tn_type->t_tspec))
-		debug_printf(", value %lld\n", (long long)tn->tn_val->v_quad);
+		debug_printf(", value %lld\n",
 		    (long long)tn->tn_val->v_quad);
 	else if (op == CON && tn->tn_type->t_tspec == BOOL)
 		debug_printf(", value %s\n",
 		    tn->tn_val->v_quad != 0 ? "true" : "false");
 	else if (op == CON)
 		debug_printf(", unknown value\n");
 	else if (op == STRING && tn->tn_string->st_char)
 		debug_printf(", length %zu, \"%s\"\n",
 		    tn->tn_string->st_len,
 		    (const char *)tn->tn_string->st_mem);
 	else if (op == STRING) {
 		size_t n = MB_CUR_MAX * (tn->tn_string->st_len + 1);
 		char *s = xmalloc(n);
 		(void)wcstombs(s, tn->tn_string->st_mem, n);
 @@ -150,14 +153,148 @@ debug_node(const tnode_t *tn)
 		free(s);
 	} else {
 		debug_printf("\n");
 		debug_indent_inc();
 		debug_node(tn->tn_left);
 		if (is_binary(tn) || tn->tn_right != NULL)
 			debug_node(tn->tn_right);
 		debug_indent_dec();
+	}
+}
 static const char *
 def_name(def_t def)
+{
 	static const char *const name[] = {
 		"not-declared",
 		"declared",
 		"tentative-defined",
 		"defined",
 	};
 	return name[def];
+}
 const char *
 scl_name(scl_t scl)
+{
 	static const char *const name[] = {
 		"none",
 		"extern",
 		"static",
 		"auto",
 		"register",
 		"typedef",
 		"struct",
 		"union",
 		"enum",
 		"member-of-struct",
 		"member-of-union",
 		"compile-time-constant",
 		"abstract",
 		"old-style-function-argument",
 		"prototype-argument",
 		"inline",
 	};
 	return name[scl];
+}
 const char *
 symt_name(symt_t kind)
+{
 	static const char *const name[] = {
 		"var-func-type",
 		"member",
 		"tag",
 		"label",
 	};
 	return name[kind];
+}
 const char *
 tqual_name(tqual_t qual)
+{
 	static const char *const name[] = {
 		"const",
 		"volatile",
 		"restrict",
 		"_Thread_local",
 	};
 	return name[qual];
+}
 static void
 debug_word(bool flag, const char *name)
+{
 	if (flag)
 		debug_printf(" %s", name);
+}
 void
 debug_sym(const sym_t *sym)
+{
 	debug_print_indent();
 	debug_printf("%s", sym->s_name);
 	if (sym->s_type != NULL)
 		debug_printf(" type='%s'", type_name(sym->s_type));
 	if (sym->s_rename != NULL)
 		debug_printf(" rename=%s", sym->s_rename);
 	debug_printf(" %s", symt_name(sym->s_kind));
 	debug_word(sym->s_keyword != NULL, "keyword");
 	debug_word(sym->s_bitfield, "bit-field");
 	debug_word(sym->s_set, "set");
 	debug_word(sym->s_used, "used");
 	debug_word(sym->s_arg, "argument");
 	debug_word(sym->s_register, "register");
 	debug_word(sym->s_defarg, "old-style-undefined");
 	debug_word(sym->s_return_type_implicit_int, "return-int");
 	debug_word(sym->s_osdef, "old-style");
 	debug_word(sym->s_inline, "inline");
 	debug_word(sym->s_ext_sym != NULL, "has-external");
 	debug_word(sym->s_scl != NOSCL, scl_name(sym->s_scl));
 	debug_word(sym->s_keyword == NULL, def_name(sym->s_def));
 	if (sym->s_def_pos.p_file != NULL)
 		debug_printf(" defined-at=%s:%d",
 		    sym->s_def_pos.p_file, sym->s_def_pos.p_line);
 	if (sym->s_set_pos.p_file != NULL)
 		debug_printf(" set-at=%s:%d",
 		    sym->s_set_pos.p_file, sym->s_set_pos.p_line);
 	if (sym->s_use_pos.p_file != NULL)
 		debug_printf(" used-at=%s:%d",
 		    sym->s_use_pos.p_file, sym->s_use_pos.p_line);
 	if (sym->s_type != NULL &&
 	    (sym->s_type->t_is_enum || sym->s_type->t_tspec == BOOL))
 		debug_printf(" value=%d", (int)sym->s_value.v_quad);
 	if ((sym->s_scl == MOS || sym->s_scl == MOU) &&
 	    sym->s_sou_type != NULL) {
 		const char *tag = sym->s_sou_type->sou_tag->s_name;
 		const sym_t *def = sym->s_sou_type->sou_first_typedef;
 		if (tag == unnamed && def != NULL)
 			debug_printf(" sou='typedef %s'", def->s_name);
 		else
 			debug_printf(" sou=%s", tag);
+	}
 	if (sym->s_keyword != NULL) {
 		int t = (int)sym->s_value.v_quad;
 		if (t == T_TYPE || t == T_STRUCT_OR_UNION)
 			debug_printf(" %s", tspec_name(sym->s_tspec));
 		else if (t == T_QUAL)
 			debug_printf(" %s", tqual_name(sym->s_tqual));
+	}
 	debug_word(sym->s_osdef && sym->s_args != NULL, "old-style-args");
 	debug_printf("\n");
+}
 #endif

 @@ -1,14 +1,14 @@
-/* $NetBSD: decl.c,v 1.251 2022/02/27 20:02:43 rillig Exp $ */
+/* $NetBSD: decl.c,v 1.252 2022/03/01 00:17:12 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) && !defined(lint)
-__RCSID("$NetBSD: decl.c,v 1.251 2022/02/27 20:02:43 rillig Exp $");
+__RCSID("$NetBSD: decl.c,v 1.252 2022/03/01 00:17:12 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;
 @@ -130,42 +130,26 @@ initdecl(void)
 	typetab[UINT128].t_tspec = UINT128;
 #endif
 	typetab[FLOAT].t_tspec = FLOAT;
 	typetab[DOUBLE].t_tspec = DOUBLE;
 	typetab[LDOUBLE].t_tspec = LDOUBLE;
 	typetab[VOID].t_tspec = VOID;
 	/* struct, union, enum, ptr, array and func are not shared. */
 	typetab[COMPLEX].t_tspec = COMPLEX;
 	typetab[FCOMPLEX].t_tspec = FCOMPLEX;
 	typetab[DCOMPLEX].t_tspec = DCOMPLEX;
 	typetab[LCOMPLEX].t_tspec = LCOMPLEX;
+}
 #ifdef DEBUG
 /* Return the name of the "storage class" in the wider sense. */
 const char *
 scl_name(scl_t scl)
 	static const char *const names[] = {
 	    "none", "extern", "static", "auto", "register", "typedef",
 	    "struct", "union", "enum", "member of struct", "member of union",
 	    "compile-time constant", "abstract",
 	    "old-style function argument", "prototype argument", "inline"
 	};
 	return names[scl];
 #endif
 /*
  * Returns a shared type structure for arithmetic types and void.
+ *
  * It's important to duplicate this structure using block_dup_type or
  * expr_dup_type if it is to be modified (adding qualifiers or anything
  * else).
  */
 type_t *
 gettyp(tspec_t t)
+{
 	/* TODO: make the return type 'const' */
 	return &typetab[t];
 @@ -1936,27 +1920,27 @@ declare_extern(sym_t *dsym, bool initflg
 		 * With both LINTLIBRARY and PROTOLIB the prototype is
 		 * written as a function definition to the output file.
 		 */
 		rval = dsym->s_type->t_subt->t_tspec != VOID;
 		outfdef(dsym, &dsym->s_def_pos, rval, false, NULL);
 	} else if (!is_compiler_builtin(dsym->s_name)) {
 		outsym(dsym, dsym->s_scl, dsym->s_def);
+	}
 	if ((rdsym = dcs->d_redeclared_symbol) != NULL) {
 		/*
 		 * If the old symbol stems from an old style function
-		 * definition, we have remembered the params in rdsmy->s_args
+		 * definition, we have remembered the params in rdsym->s_args
 		 * and compare them with the params of the prototype.
 		 */
 		if (rdsym->s_osdef && dsym->s_type->t_proto) {
 			redec = check_old_style_definition(rdsym, dsym);
 		} else {
 			redec = false;
+		}
 		if (!redec &&
 		    !check_redeclaration(dsym, (dowarn = false, &dowarn))) {
 			if (dowarn) {
 				if (sflag)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: externs1.h,v 1.148 2022/02/27 10:31:58 rillig Exp $	*/
+/*	$NetBSD: externs1.h,v 1.149 2022/03/01 00:17:12 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.
 @@ -105,27 +105,32 @@ extern	void	*level_zero_alloc(size_t, si
 extern	void	level_free_all(size_t);
 extern	void	*expr_zero_alloc(size_t);
 extern	tnode_t	*expr_alloc_tnode(void);
 extern	void	expr_free_all(void);
 extern	struct	memory_block *expr_save_memory(void);
 extern	void	expr_restore_memory(struct memory_block *);
 /*
  * debug.c
  */
 #ifdef DEBUG
 const char *scl_name(scl_t);
 const char *symt_name(symt_t);
 const char *tqual_name(tqual_t);
 void	debug_node(const tnode_t *);
 void	debug_sym(const sym_t *);
 void	debug_symtab(void);
 void	debug_printf(const char *fmt, ...) __printflike(1, 2);
 void	debug_print_indent(void);
 void	debug_indent_inc(void);
 void	debug_indent_dec(void);
 void	debug_enter(const char *);
 void	debug_step(const char *fmt, ...) __printflike(1, 2);
 void	debug_leave(const char *);
 #define	debug_enter()		(debug_enter)(__func__)
 #define	debug_leave()		(debug_leave)(__func__)
 #else
 #define	debug_noop()		do { } while (false)
 #define	debug_node(tn)		debug_noop()
 #define	debug_printf(...)	debug_noop()
 @@ -213,27 +218,26 @@ extern	void	check_func_old_style_argumen
 extern	void	declare_local(sym_t *, bool);
 extern	sym_t	*abstract_name(void);
 extern	void	global_clean_up(void);
 extern	sym_t	*declare_1_abstract(sym_t *);
 extern	void	check_size(sym_t *);
 extern	void	mark_as_set(sym_t *);
 extern	void	mark_as_used(sym_t *, bool, bool);
 extern	void	check_usage(dinfo_t *);
 extern	void	check_usage_sym(bool, sym_t *);
 extern	void	check_global_symbols(void);
 extern	void	print_previous_declaration(int, const sym_t *);
 extern	int	to_int_constant(tnode_t *, bool);
 extern	const char *scl_name(scl_t);
 /*
  * tree.c
  */
 extern	const tnode_t *before_conversion(const tnode_t *);
 extern	type_t	*block_derive_type(type_t *, tspec_t);
 extern	type_t	*expr_derive_type(type_t *, tspec_t);
 extern	bool	is_compiler_builtin(const char *);
 extern	tnode_t	*build_constant(type_t *, val_t *);
 extern	tnode_t	*build_name(sym_t *, bool);
 extern	tnode_t	*build_string(strg_t *);
 extern	tnode_t	*build_generic_selection(const tnode_t *,
 		    struct generic_association *);

 @@ -1,14 +1,14 @@
-/* $NetBSD: lex.c,v 1.106 2022/02/28 22:41:07 rillig Exp $ */
+/* $NetBSD: lex.c,v 1.107 2022/03/01 00:17:12 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) && !defined(lint)
-__RCSID("$NetBSD: lex.c,v 1.106 2022/02/28 22:41:07 rillig Exp $");
+__RCSID("$NetBSD: lex.c,v 1.107 2022/03/01 00:17:12 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"
 @@ -297,26 +297,91 @@ static void
 symtab_remove_locals(void)
+{
 	for (size_t i = 0; i < HSHSIZ1; i++) {
 		for (sym_t *sym = symtab[i]; sym != NULL; ) {
 			sym_t *next = sym->s_symtab_next;
 			if (sym->s_block_level >= 1)
 				symtab_remove(sym);
 			sym = next;
+		}
+	}
+}
 #ifdef DEBUG
 static int
 sym_by_name(const void *va, const void *vb)
+{
 	const sym_t *a = *(const sym_t *const *)va;
 	const sym_t *b = *(const sym_t *const *)vb;
 	return strcmp(a->s_name, b->s_name);
+}
 struct syms {
 	const sym_t **items;
 	size_t len;
 	size_t cap;
 };
 static void
 syms_add(struct syms *syms, const sym_t *sym)
+{
 	while (syms->len + 1 >= syms->cap) {
 		syms->cap *= 2;
 		syms->items = xrealloc(syms->items,
 		    syms->cap * sizeof(syms->items[0]));
+	}
 	syms->items[syms->len++] = sym;
+}
 void
 debug_symtab(void)
+{
 	struct syms syms = { xcalloc(64, sizeof(syms.items[0])), 0, 64 };
 	for (int level = 0;; level++) {
 		debug_printf("symbol table level %d\n", level);
 		bool more = false;
 		size_t n = sizeof(symtab) / sizeof(symtab[0]);
 		syms.len = 0;
 		for (size_t i = 0; i < n; i++) {
 			for (sym_t *sym = symtab[i]; sym != NULL;) {
 				if (sym->s_block_level == level &&
 				    sym->s_keyword == NULL)
 					syms_add(&syms, sym);
 				if (sym->s_block_level > level)
 					more = true;
 				sym = sym->s_symtab_next;
+			}
+		}
 		debug_indent_inc();
 		qsort(syms.items, syms.len, sizeof(syms.items[0]),
 		    sym_by_name);
 		for (size_t i = 0; i < syms.len; i++)
 			debug_sym(syms.items[i]);
 		debug_indent_dec();
 		if (!more)
 			break;
+	}
 	free(syms.items);
+}
 #endif
 static void
 add_keyword(const struct keyword *kw, bool leading, bool trailing)
+{
 	sym_t *sym;
 	char buf[256];
 	const char *name;
 	if (!leading && !trailing) {
 		name = kw->kw_name;
 	} else {
 		(void)snprintf(buf, sizeof(buf), "%s%s%s",
 		    leading ? "__" : "", kw->kw_name, trailing ? "__" : "");
 		name = xstrdup(buf);
 @@ -1291,40 +1356,26 @@ lex_next_line(void)
 		csrc_pos.p_line++;
 		csrc_pos.p_uniq = 0;
+	}
+}
 void
 lex_unknown_character(int c)
+{
 	/* unknown character \%o */
 	error(250, c);
+}
 #ifdef DEBUG
 static const char *
 symt_name(symt_t kind)
 	static const char *name[] = {
 		"var-func-type",
 		"member",
 		"tag",
 		"label",
 	};
 	return name[kind];
 #endif
 /*
  * As noted above, the scanner does not create new symbol table entries
  * for symbols it cannot find in the symbol table. This is to avoid
  * putting undeclared symbols into the symbol table if a syntax error
  * occurs.
+ *
  * getsym() is called as soon as it is probably ok to put the symbol in the
  * symbol table. It is still possible that symbols are put in the symbol
  * table that are not completely declared due to syntax errors. To avoid too
  * many problems in this case, symbols get type 'int' in getsym().
+ *
  * XXX calls to getsym() should be delayed until decl1*() is called.
  */