 @@ -1,14 +1,14 @@
-/*	$NetBSD: debug.c,v 1.45 2023/06/10 07:05:18 rillig Exp $	*/
+/*	$NetBSD: debug.c,v 1.46 2023/06/10 07:42:41 rillig Exp $	*/
 /*-
  * Copyright (c) 2023 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.
 @@ -20,27 +20,27 @@
  * ``AS IS'' AND ANY EXPRESS OR 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 FOUNDATION OR CONTRIBUTORS
  * 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>
-__RCSID("$NetBSD: debug.c,v 1.45 2023/06/10 07:05:18 rillig Exp $");
+__RCSID("$NetBSD: debug.c,v 1.46 2023/06/10 07:42:41 rillig Exp $");
 #include <stdarg.h>
 #include "indent.h"
 #ifdef debug
 /*-
  * false	show only the changes to the parser state
  * true		show unchanged parts of the parser state as well
  */
 static bool debug_full_parser_state = true;
 @@ -289,27 +289,27 @@ debug_parser_state(void)
+{
 	static struct parser_state prev_ps;
 	debug_blank_line();
 	debug_println("             ps.prev_lsym = %s",
 	    lsym_name[ps.prev_lsym]);
 	debug_println("token classification");
 	debug_ps_bool(in_stmt_or_decl);
 	debug_ps_bool(in_decl);
 	debug_ps_bool(in_var_decl);
 	debug_ps_bool(in_init);
 	debug_ps_int(init_level);
-	debug_ps_bool(in_func_def_line);
+	debug_ps_bool(line_has_func_def);
 	debug_ps_bool(in_func_def_params);
 	debug_ps_bool(line_has_decl);
 	debug_ps_enum(lbrace_kind, psym_name);
 	debug_ps_enum(spaced_expr_psym, psym_name);
 	debug_ps_bool(seen_case);
 	debug_ps_bool(prev_paren_was_cast);
 	debug_ps_int(quest_level);
 	debug_println("indentation of statements and declarations");
 	debug_ps_int(ind_level);
 	debug_ps_int(ind_level_follow);
 	debug_ps_bool(in_stmt_cont);
 	debug_ps_int(decl_level);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: indent.c,v 1.350 2023/06/10 06:52:35 rillig Exp $	*/
+/*	$NetBSD: indent.c,v 1.351 2023/06/10 07:42:41 rillig Exp $	*/
 /*-
  * SPDX-License-Identifier: BSD-4-Clause
+ *
  * Copyright (c) 1985 Sun Microsystems, Inc.
  * Copyright (c) 1976 Board of Trustees of the University of Illinois.
  * Copyright (c) 1980, 1993
  *	The Regents of the University of California.  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
 @@ -28,27 +28,27 @@
  * ANY EXPRESS OR 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 REGENTS OR CONTRIBUTORS 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>
-__RCSID("$NetBSD: indent.c,v 1.350 2023/06/10 06:52:35 rillig Exp $");
+__RCSID("$NetBSD: indent.c,v 1.351 2023/06/10 07:42:41 rillig Exp $");
 #include <sys/param.h>
 #include <err.h>
 #include <fcntl.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include "indent.h"
 struct options opt = {
 @@ -362,27 +362,27 @@ indent_declarator(int decl_ind, bool tab
 	if (code.len == orig_code_len && ps.want_blank) {
 		buf_add_char(&code, ' ');
 		ps.want_blank = false;
+	}
 	ps.decl_indent_done = true;
+}
 static bool
 is_function_pointer_declaration(void)
+{
 	return ps.in_decl
 	    && !ps.in_init
 	    && !ps.decl_indent_done
-	    && !ps.in_func_def_line
+	    && !ps.line_has_func_def
 	    && ps.line_start_nparen == 0;
+}
 static int
 process_eof(void)
+{
 	output_finish();
 	if (ps.psyms.top > 1)	/* check for balanced braces */
 		diag(1, "Stuff missing from end of file");
 	return found_err ? EXIT_FAILURE : EXIT_SUCCESS;
+}
 @@ -535,27 +535,27 @@ process_lparen(void)
 		parse(psym_stmt);	/* prepare for function definition */
 		ps.in_var_decl = false;
+	}
 	int indent = ind_add(0, code.s, code.len);
 	enum paren_level_cast cast = cast_unknown;
 	if (ps.prev_lsym == lsym_offsetof
 	    || ps.prev_lsym == lsym_sizeof
 	    || ps.prev_lsym == lsym_for
 	    || ps.prev_lsym == lsym_if
 	    || ps.prev_lsym == lsym_switch
 	    || ps.prev_lsym == lsym_while
-	    || ps.in_func_def_line)
+	    || ps.line_has_func_def)
 		cast = cast_no;
 	ps.paren[ps.nparen - 1].indent = indent;
 	ps.paren[ps.nparen - 1].cast = cast;
 	debug_println("paren_indents[%d] is now %s%d",
 	    ps.nparen - 1, paren_level_cast_name[cast], indent);
+}
 static void
 process_rparen(void)
+{
 	if (ps.nparen == 0) {
 		diag(0, "Extra '%c'", *token.s);
 @@ -769,50 +769,44 @@ process_unary_op(void)
+}
 static void
 process_postfix_op(void)
+{
 	buf_add_buf(&code, &token);
 	ps.want_blank = true;
+}
 static void
 process_question(void)
+{
 	ps.quest_level++;
-	if (code.len == 0) {
+	if (code.len == 0)
-		ps.in_stmt_cont = true;
+		ps.in_stmt_cont = true;	// XXX: should be unnecessary.
 		ps.in_stmt_or_decl = true;
 		ps.in_decl = false;
+}
 static void
 process_colon_question(void)
+{
-	if (code.len == 0) {
+	if (code.len == 0)
-		ps.in_stmt_cont = true;
+		ps.in_stmt_cont = true;	// XXX: should be unnecessary.
 		ps.in_stmt_or_decl = true;
 		ps.in_decl = false;
+}
 static void
 process_comma(void)
+{
 	ps.want_blank = code.len > 0;	/* only put blank after comma if comma
 					 * does not start the line */
-	if (ps.in_decl && !ps.in_func_def_line && !ps.in_init &&
+	if (ps.in_decl && !ps.line_has_func_def && !ps.in_init &&
 	    !ps.decl_indent_done && ps.line_start_nparen == 0) {
 		/* indent leading commas and not the actual identifiers */
 		indent_declarator(ps.decl_ind - 1, ps.tabs_to_var);
+	}
 	buf_add_char(&code, ',');
 	if (ps.nparen == 0) {
 		if (ps.init_level == 0)
 			ps.in_init = false;
 		int typical_varname_length = 8;
 		if (ps.break_after_comma && (opt.break_after_comma ||
 			ind_add(compute_code_indent(), code.s, code.len)
 @@ -881,77 +875,77 @@ process_semicolon(void)
+	}
 	buf_add_char(&code, ';');
 	ps.want_blank = true;
 	ps.in_stmt_or_decl = ps.nparen > 0;
 	ps.decl_ind = 0;
 	if (ps.spaced_expr_psym == psym_0) {
 		parse(psym_stmt);
 		ps.force_nl = true;
+	}
+}
 static void
-process_type(void)
+process_type_outside_parentheses(void)
+{
 	parse(psym_decl);	/* let the parser worry about indentation */
 	if (ps.prev_lsym == lsym_rparen && ps.psyms.top <= 1 && code.len > 0)
 		output_line();
 	if (ps.in_func_def_params && opt.indent_parameters &&
 	    ps.decl_level == 0) {
 		ps.ind_level = ps.ind_level_follow = 1;
 		ps.in_stmt_cont = false;
+	}
 	ps.in_var_decl = /* maybe */ true;
 	ps.in_decl = ps.line_has_decl = ps.prev_lsym != lsym_typedef;
 	if (ps.decl_level <= 0)
 		ps.declaration = decl_begin;
 	int len = (int)token.len + 1;
 	int ind = ps.ind_level == 0 || ps.decl_level > 0
 	    ? opt.decl_indent	/* global variable or local member */
 	    : opt.local_decl_indent;	/* local variable */
 	ps.decl_ind = ind > 0 ? ind : len;
 	ps.tabs_to_var = opt.use_tabs && ind > 0;
+}
 static void
-process_ident(lexer_symbol lsym)
+process_word(lexer_symbol lsym)
+{
 	if (ps.in_decl) {
 		if (lsym == lsym_funcname) {
 			ps.in_decl = false;
 			if (opt.procnames_start_line && code.len > 0)
 				output_line();
 			else if (ps.want_blank)
 				buf_add_char(&code, ' ');
 			ps.want_blank = false;
 		} else if (!ps.in_init && !ps.decl_indent_done &&
 		    ps.line_start_nparen == 0) {
 			if (opt.decl_indent == 0
 			    && code.len > 0 && code.s[code.len - 1] == '}')
 				ps.decl_ind = ind_add(0, code.s, code.len) + 1;
 			indent_declarator(ps.decl_ind, ps.tabs_to_var);
 			ps.want_blank = false;
+		}
 	} else if (ps.spaced_expr_psym != psym_0 && ps.nparen == 0) {
 		ps.force_nl = true;
 		ps.next_unary = true;
 		ps.in_stmt_or_decl = false;
 		ps.next_unary = true;
 		parse(ps.spaced_expr_psym);
 		ps.spaced_expr_psym = psym_0;
+	}
+}
 static void
 process_do(void)
+{
 	ps.in_stmt_or_decl = false;
 	ps.in_decl = false;
 	if (code.len > 0)
 		output_line();
 @@ -1004,36 +998,36 @@ process_lsym(lexer_symbol lsym)
 	case lsym_do:		process_do();		goto copy_token;
 	case lsym_else:		process_else();		goto copy_token;
 	case lsym_for:		ps.spaced_expr_psym = psym_for_exprs; goto copy_token;
 	case lsym_if:		ps.spaced_expr_psym = psym_if_expr; goto copy_token;
 	case lsym_switch:	ps.spaced_expr_psym = psym_switch_expr; goto copy_token;
 	case lsym_while:	ps.spaced_expr_psym = psym_while_expr; goto copy_token;
 		/* INDENT ON */
 	case lsym_tag:
 		if (ps.nparen > 0)
 			goto copy_token;
 		/* FALLTHROUGH */
 	case lsym_type_outside_parentheses:
-		process_type();
+		process_type_outside_parentheses();
 		goto copy_token;
 	case lsym_type_in_parentheses:
 	case lsym_sizeof:
 	case lsym_offsetof:
 	case lsym_word:
 	case lsym_funcname:
 	case lsym_return:
-		process_ident(lsym);
+		process_word(lsym);
 copy_token:
 		if (ps.want_blank)
 			buf_add_char(&code, ' ');
 		buf_add_buf(&code, &token);
 		if (lsym != lsym_funcname)
 			ps.want_blank = true;
 		break;
 	default:
 		break;
+	}
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: indent.h,v 1.184 2023/06/10 06:38:21 rillig Exp $	*/
+/*	$NetBSD: indent.h,v 1.185 2023/06/10 07:42:41 rillig Exp $	*/
 /*-
  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
+ *
  * Copyright (c) 2001 Jens Schweikhardt
  * 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
 @@ -304,32 +304,31 @@ extern struct parser_state {
 	/* Token classification */
 	bool in_stmt_or_decl;	/* whether in a statement or a struct
 				 * declaration or a plain declaration */
 	bool in_decl;		/* XXX: double-check the exact meaning */
 	bool in_var_decl;	/* starts at a type name or a '){' from a
 				 * compound literal; ends at the '(' from a
 				 * function definition or a ';' outside '{}';
 				 * when active, '{}' form struct or union
 				 * declarations, ':' marks a bit-field, and '='
 				 * starts an initializer */
 	bool in_init;		/* whether inside an initializer */
 	int init_level;		/* the number of '{}' in an initializer */
-	bool in_func_def_line;	/* starts either at the 'name(' from a function
+	bool line_has_func_def;	/* starts either at the 'name(' from a function
 				 * definition if it occurs at the beginning of
 				 * a line, or at the first '*' from inside a
 				 * declaration when the line starts with words
-				 * followed by a '('; ends at the end of that
+				 * followed by a '(' */
 				 * line */
 	bool in_func_def_params;	/* for old-style functions */
 	bool line_has_decl;	/* whether this line of code has part of a
 				 * declaration on it; used for indenting
 				 * comments */
 	parser_symbol lbrace_kind;	/* the kind of brace to be pushed to
 					 * the parser symbol stack next */
 	parser_symbol spaced_expr_psym;	/* the parser symbol to be shifted
 					 * after the parenthesized expression
 					 * from a 'for', 'if', 'switch' or
 					 * 'while'; or psym_0 */
 	bool seen_case;		/* whether there was a 'case' or 'default', to
 				 * properly space the following ':' */
 	bool prev_paren_was_cast;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: io.c,v 1.209 2023/06/10 06:38:21 rillig Exp $	*/
+/*	$NetBSD: io.c,v 1.210 2023/06/10 07:42:41 rillig Exp $	*/
 /*-
  * SPDX-License-Identifier: BSD-4-Clause
+ *
  * Copyright (c) 1985 Sun Microsystems, Inc.
  * Copyright (c) 1980, 1993
  *	The Regents of the University of California.  All rights reserved.
  * 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
 @@ -28,27 +28,27 @@
  * ANY EXPRESS OR 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 REGENTS OR CONTRIBUTORS 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>
-__RCSID("$NetBSD: io.c,v 1.209 2023/06/10 06:38:21 rillig Exp $");
+__RCSID("$NetBSD: io.c,v 1.210 2023/06/10 07:42:41 rillig Exp $");
 #include <stdio.h>
 #include "indent.h"
 struct buffer inp;
 const char *inp_p;
 struct output_state out;
 enum indent_enabled indent_enabled;
 static int out_ind;		/* width of the line that is being written */
 static unsigned wrote_newlines = 2;	/* 0 in the middle of a line, 1 after a
 					 * single '\n', > 1 means there were (n
 @@ -339,28 +339,26 @@ output_line_comment(void)
+}
 /*
  * Write a line of formatted source to the output file. The line consists of
  * the label, the code and the comment.
  */
 void
 output_line(void)
+{
 	debug_blank_line();
 	debug_printf("%s", __func__);
 	debug_buffers();
 	ps.in_func_def_line = false;
 	if (indent_enabled == indent_on) {
 		if (lab.len == 0 && code.len == 0 && com.len == 0)
 			out.line_kind = lk_blank;
 		if (want_blank_line() && wrote_newlines < 2
 		    && out.line_kind != lk_blank)
 			output_newline();
 		/* This kludge aligns function definitions correctly. */
 		if (ps.ind_level == 0)
 			ps.in_stmt_cont = false;
 		if (opt.blank_line_after_decl && ps.declaration == decl_end
 @@ -387,26 +385,27 @@ output_line(void)
 	if (indent_enabled == indent_last_off_line) {
 		indent_enabled = indent_on;
 		output_range(out.indent_off_text.s, out.indent_off_text.len);
 		out.indent_off_text.len = 0;
+	}
 prepare_next_line:
 	lab.len = 0;
 	code.len = 0;
 	com.len = 0;
 	ps.line_has_decl = ps.in_decl;
 	ps.line_has_func_def = false;
 	// XXX: don't reset in_stmt_cont here; see process_colon_question.
 	ps.in_stmt_cont = ps.in_stmt_or_decl
 	    && !ps.in_decl && ps.init_level == 0;
 	ps.decl_indent_done = false;
 	if (ps.extra_expr_indent == eei_last)
 		ps.extra_expr_indent = eei_no;
 	if (!(ps.psyms.sym[ps.psyms.top] == psym_if_expr_stmt_else
 		&& ps.nparen > 0))
 		ps.ind_level = ps.ind_level_follow;
 	ps.line_start_nparen = ps.nparen;
 	ps.want_blank = false;
 	if (ps.nparen > 0) {

 @@ -1,14 +1,14 @@
-/*	$NetBSD: lexi.c,v 1.221 2023/06/10 06:38:21 rillig Exp $	*/
+/*	$NetBSD: lexi.c,v 1.222 2023/06/10 07:42:41 rillig Exp $	*/
 /*-
  * SPDX-License-Identifier: BSD-4-Clause
+ *
  * Copyright (c) 1985 Sun Microsystems, Inc.
  * Copyright (c) 1980, 1993
  *	The Regents of the University of California.  All rights reserved.
  * 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
 @@ -28,27 +28,27 @@
  * ANY EXPRESS OR 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 REGENTS OR CONTRIBUTORS 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>
-__RCSID("$NetBSD: lexi.c,v 1.221 2023/06/10 06:38:21 rillig Exp $");
+__RCSID("$NetBSD: lexi.c,v 1.222 2023/06/10 07:42:41 rillig Exp $");
 #include <stdlib.h>
 #include <string.h>
 #include "indent.h"
 /* In lexi_alnum, this constant marks a type, independent of parentheses. */
 #define lsym_type lsym_type_outside_parentheses
 /* must be sorted alphabetically, is used in binary search */
 static const struct keyword {
 	const char name[12];
 	lexer_symbol lsym;
 @@ -409,27 +409,27 @@ found_typename:
 		if (ps.prev_lsym != lsym_period
 		    && ps.prev_lsym != lsym_unary_op) {
 			if (kw != NULL && kw->lsym == lsym_tag)
 				return lsym_tag;
 			if (ps.nparen == 0)
 				return lsym_type_outside_parentheses;
+		}
+	}
 	if (inp_p[0] == '(' && ps.psyms.top <= 1 && ps.ind_level == 0 &&
 	    !ps.in_func_def_params && !ps.in_init) {
 		if (ps.nparen == 0 && probably_looking_at_definition()) {
-			ps.in_func_def_line = true;
+			ps.line_has_func_def = true;
 			if (ps.in_decl)
 				ps.in_func_def_params = true;
 			return lsym_funcname;
+		}
 	} else if (ps.nparen == 0 && probably_typename()) {
 		ps.next_unary = true;
 		return lsym_type_outside_parentheses;
+	}
 	return lsym;
+}
 @@ -463,27 +463,27 @@ probably_in_function_definition(void)
 	return false;
+}
 static void
 lex_asterisk_unary(void)
+{
 	while (inp_p[0] == '*' || ch_isspace(inp_p[0])) {
 		if (inp_p[0] == '*')
 			token_add_char('*');
 		inp_skip();
+	}
 	if (ps.in_decl && probably_in_function_definition())
-		ps.in_func_def_line = true;
+		ps.line_has_func_def = true;
+}
 static void
 skip_blank(const char **pp)
+{
 	while (ch_isblank(**pp))
 		(*pp)++;
+}
 static bool
 skip_string(const char **pp, const char *s)
+{
 	size_t len = strlen(s);