 @@ -1,14 +1,14 @@
-/*	$NetBSD: debug.c,v 1.43 2023/06/09 18:09:30 rillig Exp $	*/
+/*	$NetBSD: debug.c,v 1.44 2023/06/10 06:38:20 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.43 2023/06/09 18:09:30 rillig Exp $");
+__RCSID("$NetBSD: debug.c,v 1.44 2023/06/10 06:38:20 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;
 @@ -284,39 +284,39 @@ debug_ps_di_stack(const struct parser_st
 	debug_println("");
+}
 void
 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_int(quest_level);
 	debug_ps_bool(is_function_definition);
 	debug_ps_bool(block_init);
 	debug_ps_int(block_init_level);
 	debug_ps_bool(init_or_struct);
 	debug_ps_bool(decl_on_line);
 	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(in_func_def_params);
-	debug_ps_bool(seen_case);
+	debug_ps_bool(line_has_decl);
 	debug_ps_enum(spaced_expr_psym, psym_name);
 	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);
 	debug_ps_di_stack(&prev_ps);
 	debug_ps_bool(decl_indent_done);
 	debug_ps_int(decl_ind);
 	debug_ps_bool(tabs_to_var);
 	debug_ps_enum(extra_expr_indent, extra_expr_indent_name);
 	// The parser symbol stack is printed in debug_parse_stack instead.

 @@ -1,14 +1,14 @@
-/*	$NetBSD: indent.c,v 1.348 2023/06/09 22:01:26 rillig Exp $	*/
+/*	$NetBSD: indent.c,v 1.349 2023/06/10 06:38:21 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.348 2023/06/09 22:01:26 rillig Exp $");
+__RCSID("$NetBSD: indent.c,v 1.349 2023/06/10 06:38:21 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 = {
 @@ -360,29 +360,29 @@ indent_declarator(int decl_ind, bool tab
 		buf_add_char(&code, ' ');
 	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.block_init
+	    && !ps.in_init
 	    && !ps.decl_indent_done
-	    && !ps.is_function_definition
+	    && !ps.in_func_def_line
 	    && 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;
+}
 @@ -467,27 +467,27 @@ process_preprocessing(void)
 	} else if (dir_len == 5 && memcmp(dir, "endif", 5) == 0) {
 		if (ifdef_level <= 0)
 			diag(1, "Unmatched #endif");
 		else
 			ifdef_level--;
 		out.line_kind = lk_endif;
+	}
+}
 static void
 process_newline(void)
+{
 	if (ps.prev_lsym == lsym_comma
-	    && ps.nparen == 0 && !ps.block_init
+	    && ps.nparen == 0 && !ps.in_init
 	    && !opt.break_after_comma && ps.break_after_comma
 	    && lab.len == 0	/* for preprocessing lines */
 	    && com.len == 0)
 		goto stay_in_line;
 	if (ps.psyms.sym[ps.psyms.top] == psym_switch_expr
 	    && opt.brace_same_line) {
 		ps.force_nl = true;
 		goto stay_in_line;
+	}
 	output_line();
 stay_in_line:
 @@ -521,60 +521,60 @@ process_lparen(void)
 		ps.nparen--;
+	}
 	if (is_function_pointer_declaration())
 		indent_declarator(ps.decl_ind, ps.tabs_to_var);
 	else if (want_blank_before_lparen())
 		buf_add_char(&code, ' ');
 	ps.want_blank = false;
 	buf_add_char(&code, token.s[0]);
 	if (opt.extra_expr_indent && ps.spaced_expr_psym != psym_0)
 		ps.extra_expr_indent = eei_maybe;
-	if (ps.init_or_struct && ps.psyms.top <= 2) {
+	if (ps.in_var_decl && ps.psyms.top <= 2) {
 		/* A kludge to correctly align function definitions. */
 		parse(psym_stmt);
-		ps.init_or_struct = false;
+		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.is_function_definition)
+	    || ps.in_func_def_line)
 		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);
 		goto unbalanced;
+	}
 	enum paren_level_cast cast = ps.paren[--ps.nparen].cast;
-	if (ps.in_func_def_params || (ps.decl_on_line && !ps.block_init))
+	if (ps.in_func_def_params || (ps.line_has_decl && !ps.in_init))
 		cast = cast_no;
 	ps.prev_paren_was_cast = cast == cast_maybe;
 	if (cast == cast_maybe) {
 		ps.next_unary = true;
 		ps.want_blank = opt.space_after_cast;
 	} else
 		ps.want_blank = true;
 	if (code.len == 0)
 		ps.line_start_nparen = ps.nparen;
 unbalanced:
 @@ -626,128 +626,128 @@ process_rbracket(void)
 	ps.want_blank = true;
 	if (code.len == 0)
 		ps.line_start_nparen = ps.nparen;
 unbalanced:
 	buf_add_char(&code, token.s[0]);
+}
 static void
 process_lbrace(void)
+{
 	if (ps.prev_lsym == lsym_rparen && ps.prev_paren_was_cast) {
-		ps.block_init = true;
+		ps.in_var_decl = true;	// XXX: not really
-		ps.init_or_struct = true;
+		ps.in_init = true;
+	}
 	if (out.line_kind == lk_stmt_head)
 		out.line_kind = lk_other;
 	ps.in_stmt_or_decl = false;	/* don't indent the {} */
-	if (!ps.block_init)
+	if (!ps.in_init)
 		ps.force_nl = true;
 	else
-		ps.block_init_level++;
+		ps.init_level++;
-	if (code.len > 0 && !ps.block_init) {
+	if (code.len > 0 && !ps.in_init) {
 		if (!opt.brace_same_line ||
 		    (code.len > 0 && code.s[code.len - 1] == '}'))
 			output_line();
-		else if (ps.in_func_def_params && !ps.init_or_struct) {
+		else if (ps.in_func_def_params && !ps.in_var_decl) {
 			ps.ind_level_follow = 0;
 			if (opt.function_brace_split)
 				output_line();
 			else
 				ps.want_blank = true;
+		}
+	}
-	if (ps.nparen > 0 && ps.block_init_level == 0) {
+	if (ps.nparen > 0 && ps.init_level == 0) {
 		diag(1, "Unbalanced parentheses");
 		ps.nparen = 0;
 		if (ps.spaced_expr_psym != psym_0) {
 			parse(ps.spaced_expr_psym);
 			ps.spaced_expr_psym = psym_0;
 			ps.ind_level = ps.ind_level_follow;
+		}
+	}
 	if (code.len == 0)
 		ps.in_stmt_cont = false;	/* don't indent the '{' itself
 						 */
-	if (ps.in_decl && ps.init_or_struct) {
+	if (ps.in_decl && ps.in_var_decl) {
 		ps.di_stack[ps.decl_level] = ps.decl_ind;
 		if (++ps.decl_level == (int)array_length(ps.di_stack)) {
-			diag(0, "Reached internal limit of %d struct levels",
+			diag(0, "Reached internal limit of %zu struct levels",
-			    (int)array_length(ps.di_stack));
+			    array_length(ps.di_stack));
 			ps.decl_level--;
+		}
 	} else {
-		ps.decl_on_line = false;	/* we can't be in the middle of
+		ps.line_has_decl = false;	/* we can't be in the middle of
 						 * a declaration, so don't do
 						 * special indentation of
 						 * comments */
 		ps.in_func_def_params = false;
 		ps.in_decl = false;
+	}
 	ps.decl_ind = 0;
 	parse(ps.lbrace_kind);
 	if (ps.want_blank)
 		buf_add_char(&code, ' ');
 	ps.want_blank = false;
 	buf_add_char(&code, '{');
 	ps.declaration = decl_no;
+}
 static void
 process_rbrace(void)
+{
-	if (ps.nparen > 0 && ps.block_init_level == 0) {
+	if (ps.nparen > 0 && ps.init_level == 0) {
 		diag(1, "Unbalanced parentheses");
 		ps.nparen = 0;
 		ps.spaced_expr_psym = psym_0;
+	}
 	ps.declaration = decl_no;
-	if (ps.block_init_level > 0)
+	if (ps.init_level > 0)
-		ps.block_init_level--;
+		ps.init_level--;
-	if (code.len > 0 && !ps.block_init)
+	if (code.len > 0 && !ps.in_init)
 		output_line();
 	buf_add_char(&code, '}');
 	ps.want_blank = true;
 	ps.in_stmt_or_decl = false;	// XXX: Initializers don't end a stmt
 	ps.in_stmt_cont = false;
 	if (ps.decl_level > 0) {	/* multi-level structure declaration */
 		ps.decl_ind = ps.di_stack[--ps.decl_level];
 		if (ps.decl_level == 0 && !ps.in_func_def_params) {
 			ps.declaration = decl_begin;
 			ps.decl_ind = ps.ind_level == 0
 			    ? opt.decl_indent : opt.local_decl_indent;
+		}
 		ps.in_decl = true;
+	}
 	if (ps.psyms.top == 2)
 		out.line_kind = lk_func_end;
 	parse(psym_rbrace);
-	if (!ps.init_or_struct
+	if (!ps.in_var_decl
 	    && ps.psyms.sym[ps.psyms.top] != psym_do_stmt
 	    && ps.psyms.sym[ps.psyms.top] != psym_if_expr_stmt)
 		ps.force_nl = true;
+}
 static void
 process_period(void)
+{
 	if (code.len > 0 && code.s[code.len - 1] == ',')
 		buf_add_char(&code, ' ');
 	buf_add_char(&code, '.');
 	ps.want_blank = false;
+}
 @@ -793,37 +793,37 @@ process_colon_question(void)
 	if (code.len == 0) {
 		ps.in_stmt_cont = true;
 		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.is_function_definition && !ps.block_init &&
+	if (ps.in_decl && !ps.in_func_def_line && !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.block_init_level == 0)
+		if (ps.init_level == 0)
-			ps.block_init = false;
+			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)
 			>= opt.max_line_length - typical_varname_length))
 			ps.force_nl = true;
+	}
+}
 static void
 process_colon_label(void)
+{
 	buf_add_buf(&lab, &code);
 	buf_add_char(&lab, ':');
 @@ -840,36 +840,36 @@ process_colon_label(void)
 static void
 process_colon_other(void)
+{
 	buf_add_char(&code, ':');
 	ps.want_blank = false;
+}
 static void
 process_semicolon(void)
+{
 	if (out.line_kind == lk_stmt_head)
 		out.line_kind = lk_other;
 	if (ps.decl_level == 0)
-		ps.init_or_struct = false;
+		ps.in_var_decl = false;
 	ps.seen_case = false;	/* only needs to be reset on error */
 	ps.quest_level = 0;	/* only needs to be reset on error */
 	if (ps.prev_lsym == lsym_rparen)
 		ps.in_func_def_params = false;
-	ps.block_init = false;
+	ps.in_init = false;
-	ps.block_init_level = 0;
+	ps.init_level = 0;
 	ps.declaration = ps.declaration == decl_begin ? decl_end : decl_no;
-	if (ps.in_decl && code.len == 0 && !ps.block_init &&
+	if (ps.in_decl && code.len == 0 && !ps.in_init &&
 	    !ps.decl_indent_done && ps.line_start_nparen == 0) {
 		/* indent stray semicolons in declarations */
 		indent_declarator(ps.decl_ind - 1, ps.tabs_to_var);
+	}
 	ps.in_decl = ps.decl_level > 0;	/* if we were in a first level
 					 * structure declaration before, we
 					 * aren't anymore */
 	if (ps.nparen > 0 && ps.spaced_expr_psym != psym_for_exprs) {
 		/* There were unbalanced parentheses in the statement. It is a
 		 * bit complicated, because the semicolon might be in a for
 		 * statement. */
 @@ -895,52 +895,52 @@ static void
 process_type(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.init_or_struct = /* maybe */ true;
+	ps.in_var_decl = /* maybe */ true;
-	ps.in_decl = ps.decl_on_line = ps.prev_lsym != lsym_typedef;
+	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)
+{
 	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.block_init && !ps.decl_indent_done &&
+		} 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;
 		parse(ps.spaced_expr_psym);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: indent.h,v 1.183 2023/06/09 22:01:26 rillig Exp $	*/
+/*	$NetBSD: indent.h,v 1.184 2023/06/10 06:38:21 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
 @@ -293,59 +293,59 @@ struct psym_stack {
+ *
  * In an expression, the token type determine whether to put spaces around.
+ *
  * In a source file, the types of line determine the vertical spacing, such as
  * around preprocessing directives or function bodies, or above block
  * comments.
  */
 extern struct parser_state {
 	lexer_symbol prev_lsym;	/* the previous token, but never comment,
 				 * newline or preprocessing line */
 	/* Token classification */
 	int quest_level;	/* when this is positive, we have seen a '?'
 				 * without the matching ':' in a '?:'
 				 * expression */
 	bool is_function_definition;	/* 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 line */
 	bool block_init;	/* whether inside a block initialization */
 	int block_init_level;	/* the level of brace nesting in an
 				 * initialization */
 	bool init_or_struct;	/* whether there has been a type name and no
 				 * left parenthesis since the last semicolon.
 				 * When true, a '{' starts a structure
 				 * definition or an initialization list */
 	bool decl_on_line;	/* whether this line of code has part of a
 				 * declaration on it; used for indenting
 				 * comments */
 	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_func_def_params;
+	bool in_var_decl;	/* starts at a type name or a '){' from a
-	bool seen_case;		/* whether there was a 'case' or 'default', to
+				 * compound literal; ends at the '(' from a
-				 * properly space the following ':' */
+				 * 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
 				 * 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
 				 * 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 */
-	parser_symbol lbrace_kind;	/* the kind of brace to be pushed to
+	bool seen_case;		/* whether there was a 'case' or 'default', to
-					 * the parser symbol stack next */
+				 * properly space the following ':' */
 	bool prev_paren_was_cast;
 	int quest_level;	/* when this is positive, we have seen a '?'
 				 * without the matching ':' in a '?:'
 				 * expression */
 	/* Indentation of statements and declarations */
 	int ind_level;		/* the indentation level for the line that is
 				 * currently prepared for output */
 	int ind_level_follow;	/* the level to which ind_level should be set
 				 * after the current line is printed */
 	bool in_stmt_cont;	/* whether the current line should have an
 				 * extra indentation level because we are in
 				 * the middle of a statement */
 	int decl_level;		/* current nesting level for a structure
 				 * declaration or an initializer */
 	int di_stack[20];	/* a stack of structure indentation levels */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: io.c,v 1.208 2023/06/09 22:01:26 rillig Exp $	*/
+/*	$NetBSD: io.c,v 1.209 2023/06/10 06:38:21 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.208 2023/06/09 22:01:26 rillig Exp $");
+__RCSID("$NetBSD: io.c,v 1.209 2023/06/10 06:38:21 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,27 +339,27 @@ 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.is_function_definition = false;
+	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;
 @@ -386,30 +386,30 @@ 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.decl_on_line = ps.in_decl;
+	ps.line_has_decl = ps.in_decl;
 	// 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.block_init_level == 0;
+	    && !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) {
 		/* TODO: explain what negative indentation means */
 		paren_indent = -1 - ps.paren[ps.nparen - 1].indent;
 		debug_println("paren_indent is now %d", paren_indent);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: lexi.c,v 1.220 2023/06/09 19:50:51 rillig Exp $	*/
+/*	$NetBSD: lexi.c,v 1.221 2023/06/10 06:38:21 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.220 2023/06/09 19:50:51 rillig Exp $");
+__RCSID("$NetBSD: lexi.c,v 1.221 2023/06/10 06:38:21 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;
 @@ -246,27 +246,27 @@ lex_char_or_string(void)
 			if (inp_p[0] == '\n')
 				++line_no;
 			token_add_char(inp_next());
+		}
+	}
+}
 /* Guess whether the current token is a declared type. */
 static bool
 probably_typename(void)
+{
 	if (ps.prev_lsym == lsym_modifier)
 		return true;
-	if (ps.block_init)
+	if (ps.in_init)
 		return false;
 	if (ps.in_stmt_or_decl)	/* XXX: this condition looks incorrect */
 		return false;
 	if (ps.prev_lsym == lsym_semicolon
 	    || ps.prev_lsym == lsym_lbrace
 	    || ps.prev_lsym == lsym_rbrace) {
 		if (inp_p[0] == '*' && inp_p[1] != '=')
 			return true;
 		/* XXX: is_identifier_start */
 		if (ch_isalpha(inp_p[0]))
 			return true;
+	}
 	return false;
 @@ -406,30 +406,30 @@ found_typename:
 			if (ps.paren[ps.nparen - 1].cast == cast_unknown)
 				ps.paren[ps.nparen - 1].cast = cast_maybe;
+		}
 		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.block_init) {
+	    !ps.in_func_def_params && !ps.in_init) {
 		if (ps.nparen == 0 && probably_looking_at_definition()) {
-			ps.is_function_definition = true;
+			ps.in_func_def_line = 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.is_function_definition = true;
+		ps.in_func_def_line = 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);
 @@ -603,47 +603,47 @@ lexi(void)
 			token_add_char(*inp_p++);
 		} else if (inp_p[0] == '>') {	/* '->' */
 			token_add_char(*inp_p++);
 			lsym = lsym_unary_op;
 			next_unary = false;
 			ps.want_blank = false;
+		}
 		break;
 	case ':':
 		lsym = ps.quest_level > 0
 		    ? (ps.quest_level--, lsym_colon_question)
-		    : ps.init_or_struct
+		    : ps.in_var_decl
 		    ? lsym_colon_other
 		    : lsym_colon_label;
 		next_unary = true;
 		break;
 	case '*':
 		if (inp_p[0] == '=') {
 			token_add_char(*inp_p++);
 			lsym = lsym_binary_op;
 		} else if (is_asterisk_unary()) {
 			lex_asterisk_unary();
 			lsym = lsym_unary_op;
 		} else
 			lsym = lsym_binary_op;
 		next_unary = true;
 		break;
 	case '=':
-		if (ps.init_or_struct)
+		if (ps.in_var_decl)
-			ps.block_init = true;
+			ps.in_init = true;
 		if (inp_p[0] == '=')
 			token_add_char(*inp_p++);
 		lsym = lsym_binary_op;
 		next_unary = true;
 		break;
 	case '>':
 	case '<':
 	case '!':		/* ops like <, <<, <=, !=, etc */
 		if (inp_p[0] == '>' || inp_p[0] == '<' || inp_p[0] == '=')
 			token_add_char(*inp_p++);
 		if (inp_p[0] == '=')
 			token_add_char(*inp_p++);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: pr_comment.c,v 1.158 2023/06/09 07:20:30 rillig Exp $	*/
+/*	$NetBSD: pr_comment.c,v 1.159 2023/06/10 06:38:21 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: pr_comment.c,v 1.158 2023/06/09 07:20:30 rillig Exp $");
+__RCSID("$NetBSD: pr_comment.c,v 1.159 2023/06/10 06:38:21 rillig Exp $");
 #include <string.h>
 #include "indent.h"
 static void
 com_add_char(char ch)
+{
 	buf_add_char(&com, ch);
+}
 static void
 com_add_delim(void)
 @@ -102,27 +102,27 @@ analyze_comment(bool *p_may_wrap, bool *
 			    * opt.indent_size;
 			if (ind <= 0)
 				ind = opt.format_col1_comments ? 0 : 1;
 			line_length = opt.block_comment_max_line_length;
 			if (may_wrap && inp_p[0] == '\n')
 				delim = true;
 			if (may_wrap && opt.comment_delimiter_on_blankline)
 				delim = true;
 		} else {
 			int target_ind = code.len > 0
 			    ? ind_add(compute_code_indent(), code.s, code.len)
 			    : ind_add(compute_label_indent(), lab.s, lab.len);
-			ind = ps.decl_on_line || ps.ind_level == 0
+			ind = ps.line_has_decl || ps.ind_level == 0
 			    ? opt.decl_comment_column - 1
 			    : opt.comment_column - 1;
 			if (ind <= target_ind)
 				ind = next_tab(target_ind);
 			if (ind + 25 > line_length)
 				line_length = ind + 25;
+		}
+	}
 	ps.com_ind = ind;
 	if (!may_wrap) {
 		/* Find out how much indentation there was originally, because

 @@ -1,14 +1,14 @@
-/*	$NetBSD: fmt_decl.c,v 1.52 2023/06/09 09:49:07 rillig Exp $	*/
+/*	$NetBSD: fmt_decl.c,v 1.53 2023/06/10 06:38:21 rillig Exp $	*/
 /*
  * Tests for declarations of global variables, external functions, and local
  * variables.
+ *
  * See also:
  *	opt_di.c
  */
 /* See FreeBSD r303570 */
 /*
  * A type definition usually declares a single type, so there is no need to
 @@ -1038,13 +1038,34 @@ Job_CheckCommands(GNode *gn, void (*abor
 static void
 MAKE_ATTR_PRINTFLIKE(5, 0)
 ParseVErrorInternal(FILE *f, bool useVars, const GNode *gn,
 		    ParseErrorLevel level, const char *fmt, va_list ap)
+{
+}
 typedef struct {
 	const char *m_name;
+}
 // $ FIXME: Remove this line break.
 mod_t;
 //indent end
 //indent input
 int a[] = {1, 2},
 b[] = {1, 2};
+{
 int a[] = {1, 2},
 b[] = {1, 2};
+}
 //indent end
 //indent run -di0
 int a[] = {1, 2},
 // $ FIXME: Missing indentation.
 b[] = {1, 2};
+{
 	int a[] = {1, 2},
 	// $ FIXME: Missing indentation.
 	b[] = {1, 2};
+}
 //indent end

 @@ -1,14 +1,14 @@
-/* $NetBSD: lsym_comment.c,v 1.18 2023/06/06 07:51:35 rillig Exp $ */
+/* $NetBSD: lsym_comment.c,v 1.19 2023/06/10 06:38:21 rillig Exp $ */
 /*
  * Tests for the token lsym_comment, which starts a comment.
+ *
  * C11 distinguishes block comments and end-of-line comments.  Indent further
  * distinguishes box comments that are a special kind of block comments.
+ *
  * See also:
  *	opt_fc1.c
  *	lsym_comment.c
  */
 /*-
 @@ -32,27 +32,27 @@
  * - block/end-of-line comment to the right of code
  * - block/end-of-line comment to the right of label with code
+ *
  * - with/without opt.comment_delimiter_on_blankline (-cdb)
  * - with/without opt.star_comment_cont (-sc)
  * - with/without opt.format_block_comments (-fbc)
  * - with varying opt.max_line_length (32, 64, 80, 140)
  * - with varying opt.unindent_displace (-d0, -d2, -d-5)
  * - with varying opt.indent_size (3, 4, 8)
  * - with varying opt.tabsize (3, 4, 8, 16)
  * - with varying opt.block_comment_max_line_length (-lc60, -lc78, -lc90)
  * - with varying opt.comment_column (-c0, -c1, -c33, -c80)
  * - with varying opt.decl_comment_column (-cd0, -cd1, -cd20, -cd33, -cd80)
- * - with/without ps.decl_on_line
+ * - with/without ps.line_has_decl
  * - with/without ps.next_col_1
+ *
  * - very long comments that overflow the buffer 'com'
  * - comments that come from save_com
  * - very long word that already spills over the right margin
  * - wrap/nowrap comment containing '\n'
  * - wrap/nowrap comment containing '\f'
  * - wrap/nowrap comment containing '\t'
  * - wrap/nowrap comment containing '\b'
  */
 //indent input
 typedef enum x {

 @@ -1,14 +1,14 @@
-/* $NetBSD: opt_bc.c,v 1.8 2023/06/02 11:43:07 rillig Exp $ */
+/* $NetBSD: opt_bc.c,v 1.9 2023/06/10 06:38:21 rillig Exp $ */
 /*
  * Tests for the options '-bc' and '-nbc'.
+ *
  * The option '-bc' forces a newline after each comma in a declaration.
+ *
  * The option '-nbc' removes line breaks between declarators.  In most other
  * places, indent preserves line breaks.
  */
 //indent input
 int a,b,c;
 void function_declaration(int a,int b,int c);
 @@ -92,13 +92,30 @@ int		d;
 #endif
 //indent end
 //indent run -nbc
 int		a,
 #if 0
 		b, c;
 int		d;
 #else
 		b, c;
 int		d;
 #endif
 //indent end
 /*
  * A '(' at the top level is taken to start a function definition, leaving
  * variable declaration mode.
  */
 //indent input
 int a = 1, b = 2;
 int a = (1), b = 2;
 //indent end
 //indent run -bc
 int		a = 1,
 		b = 2;
 // $ FIXME: Missing line break.
 int		a = (1), b = 2;
 //indent end