	@@ -1,22 +1,21 @@		@@ -1,22 +1,21 @@
1	/* $NetBSD: fmt_block.c,v 1.7 2023/05/22 23:03:16 rillig Exp $ */	1	/* $NetBSD: fmt_block.c,v 1.8 2023/06/14 20:46:08 rillig Exp $ */
2		2
3	/*	3	/*
4	* Tests for formatting blocks of statements and declarations.	4	* Tests for formatting blocks of statements and declarations.
5	*	5	*
6	* See also:	6	* See also:
7	* lsym_lbrace.c	7	* lsym_lbrace.c
8	* psym_stmt.c	8	* psym_stmt.c
9	* psym_stmt_list.c
10	*/	9	*/
11		10
12	//indent input	11	//indent input
13	void	12	void
14	function(void)	13	function(void)
15	{	14	{
16	if (true) {	15	if (true) {
17		16
18	}	17	}
19		18
20	{	19	{
21	print("block");	20	print("block");
22	}	21	}

 @@ -1,41 +1,50 @@
-/* $NetBSD: ps_ind_level.c,v 1.7 2023/05/15 14:55:47 rillig Exp $ */
+/* $NetBSD: ps_ind_level.c,v 1.8 2023/06/14 20:46:08 rillig Exp $ */
 /*
  * The indentation of the very first line of a file determines the
- * indentation of the remaining code. Even if later code has a smaller
+ * indentation of the remaining code. This mode is meant for code snippets from
- * indentation, it is nevertheless indented to the level given by the first
+ * function bodies. At this level, function definitions are not recognized
- * line of code.
+ * properly.
+ *
  * Even if later code has a smaller indentation, it is nevertheless indented to
  * the level given by the first line of code.
+ *
  * In this particular test, the indentation is set to 5 and the tabulator
  * width is set to 8, to demonstrate an off-by-one error in
  * main_prepare_parsing that has been fixed in indent.c 1.107 from 2021-10-05.
+ *
  * The declaration in the first line is indented by 3 tabs, amounting to 24
  * spaces. The initial indentation of the code is intended to be rounded down,
  * to 4 levels of indentation, amounting to 20 spaces.
  */
 //indent input
 			int indented_by_24;
 void function_in_column_1(void){}
 			#if indented
 #endif
 //indent end
 /* 5 spaces indentation, 8 spaces per tabulator */
 //indent run -i5 -ts8
 		    int		    indented_by_24;
 		    void	    function_in_column_1(void) {
+		    }
 #if indented
 #endif
 //indent end
 /*
  * Labels are always indented 2 levels left of the code. The first line starts
  * at indentation level 3, the code in the function is therefore at level 4,
  * and the label is at level 2, sticking out of the code.
  */
 //indent input
 			int indent_by_24;
 void function(void) {
 label:;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: fmt_decl.c,v 1.54 2023/06/10 17:56:29 rillig Exp $	*/
+/*	$NetBSD: fmt_decl.c,v 1.55 2023/06/14 20:46:08 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
 @@ -1075,13 +1075,114 @@ b[] = {1, 2};
  * When a type occurs at the top level, it forces a line break before.
  */
 //indent input
 __attribute__((__dead__)) void die(void) {}
 //indent end
 //indent run
 __attribute__((__dead__))
 void
 die(void)
+{
+}
 //indent end
 /*
  * In very rare cases, the type of a declarator might include literal tab
  * characters. This tab might affect the indentation of the declarator, but
  * only if it occurs before the declarator, and that is hard to achieve.
  */
 //indent input
 int		arr[sizeof "	"];
 //indent end
 //indent run-equals-input
 /*
  * The '}' of an initializer is not supposed to end the statement, it only ends
  * the brace level of the initializer expression.
  */
 //indent input
 int multi_line[1][1][1] = {
+{
+{
 },
 },
 };
 int single_line[2][1][1] = {{{1},},{{2}}};
 //indent end
 //indent run -di0
 int multi_line[1][1][1] = {
+	{
+		{
 		},
 	},
 };
 int single_line[2][1][1] = {{{1},}, {{2}}};
 //indent end
 /*
  * The '}' of an initializer is not supposed to end the statement, it only ends
  * the brace level of the initializer expression.
  */
 //indent input
+{
 int multi_line = {
+{
+{
+b
 },
 },
 };
 int single_line = {{{b},},{}};
+}
 //indent end
 //indent run -di0
+{
 	int multi_line = {
+		{
+			{
+				b
 			},
 		},
 	};
 	int single_line = {{{b},}, {}};
+}
 //indent end
 /*
  * In initializers, multi-line expressions don't have their second line
  * indented, even though they should.
  */
 //indent input
+{
 multi_line = (int[]){
 {1
 +1},
 {1
 +1},
 {1
 +1},
 };
+}
 //indent end
 //indent run
+{
 	multi_line = (int[]){
 		{1
 		+ 1},
 		{1
 		+ 1},
 		{1
 		+ 1},
 	};
+}
 //indent end

 @@ -1,14 +1,14 @@
-/* $NetBSD: lsym_preprocessing.c,v 1.13 2023/06/14 17:07:32 rillig Exp $ */
+/* $NetBSD: lsym_preprocessing.c,v 1.14 2023/06/14 20:46:08 rillig Exp $ */
 /*
  * Tests for the token lsym_preprocessing, which represents a '#' that starts
  * a preprocessing line.
+ *
  * #define
  * #ifdef
  * #include
  * #line
  * #pragma
+ *
  * The whole preprocessing line is processed separately from the main source
  * code, without much tokenizing or parsing.
 @@ -297,13 +297,48 @@ int before;
 #else
 #elif 0
 #elifdef var
 #endif
 #unknown
 # 3 "file.c"
 exit 1
 error: Standard Input:1: Unmatched #else
 error: Standard Input:2: Unmatched #elif
 error: Standard Input:3: Unmatched #elifdef
 error: Standard Input:4: Unmatched #endif
 //indent end
 /*
  * The '#' can only occur at the beginning of a line, therefore indent does not
  * care when it occurs in the middle of a line.
  */
 //indent input
 int no = #;
 //indent end
 //indent run -di0
 int no =
 #;
 //indent end
 /*
  * Preprocessing directives may be indented; indent moves them to the beginning
  * of a line.
  */
 //indent input
 #if 0
 	#if 1 \
 	 || 2
 	#endif
 #endif
 //indent end
 //indent run
 #if 0
 #if 1 \
 	 || 2
 #endif
 #endif
 //indent end

 @@ -1,14 +1,14 @@
-/* $NetBSD: opt_bc.c,v 1.11 2023/06/14 14:11:28 rillig Exp $ */
+/* $NetBSD: opt_bc.c,v 1.12 2023/06/14 20:46:08 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);
 @@ -111,26 +111,37 @@ int		d;
 //indent input
 int a = 1, b = 2;
 int a = (1), b = 2;
 //indent end
 //indent run -bc
 int		a = 1,
 		b = 2;
 int		a = (1),
 		b = 2;
 //indent end
 //indent input
 int a,
 b,
 c;
 //indent end
 //indent run -nbc -di0
 int a, b, c;
 //indent end
 /*
  * When declarations are too long to fit in a single line, they should not be
  * joined.
  */
 //indent input
+{
 	const struct paren_level *prev = state.prev_ps.paren.item,
 	    *curr = ps.paren.item;
+}
 //indent end
 //indent run
 // $ FIXME: The line becomes too long.

 @@ -1,15 +1,88 @@
-/* $NetBSD: psym_rbrace.c,v 1.3 2022/04/24 09:04:12 rillig Exp $ */
+/* $NetBSD: psym_rbrace.c,v 1.4 2023/06/14 20:46:08 rillig Exp $ */
 /*
  * Tests for the parser symbol psym_rbrace, which represents '}' and finishes
  * the previous '{'.
+ *
  * See also:
  *	psym_lbrace.c
  */
 /*
  * While it is a syntax error to have an unfinished declaration between braces,
  * indent is forgiving enough to accept this input.
  */
 //indent input
+{
 	int
+}
 //indent end
 //indent run
+{
 	int
+	}
 exit 1
 error: Standard Input:3: Statement nesting error
 error: Standard Input:3: Stuff missing from end of file
 //indent end
 //indent input
 // TODO: add input
 	do {
 	} while (cond)
+}
 //indent end
 // XXX: Why doesn't indent complain about the missing semicolon?
 //indent run-equals-input
 //indent input
+{
 	if (cond)
+}
 //indent end
 //indent run
+{
 	if (cond)
+		}
 exit 1
 error: Standard Input:3: Statement nesting error
 error: Standard Input:3: Stuff missing from end of file
 //indent end
 //indent input
+{
 	switch (expr)
+}
 //indent end
 //indent run
+{
 	switch (expr)
+		}
 exit 1
 error: Standard Input:3: Statement nesting error
 error: Standard Input:3: Stuff missing from end of file
 //indent end
 //indent input
+{
 	while (cond)
+}
 //indent end
 //indent run
+{
 	while (cond)
+		}
 exit 1
 error: Standard Input:3: Statement nesting error
 error: Standard Input:3: Stuff missing from end of file
 //indent end

 @@ -1,14 +1,14 @@
-/*	$NetBSD: debug.c,v 1.60 2023/06/14 16:14:30 rillig Exp $	*/
+/*	$NetBSD: debug.c,v 1.61 2023/06/14 20:46:08 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.60 2023/06/14 16:14:30 rillig Exp $");
+__RCSID("$NetBSD: debug.c,v 1.61 2023/06/14 20:46:08 rillig Exp $");
 #include <stdarg.h>
 #include <string.h>
 #include "indent.h"
 #ifdef debug
 static struct {
 	// false	show only the changes to the parser state
 	// true		show unchanged parts of the parser state as well
 	bool full_parser_state;
 } config = {
 @@ -357,27 +357,27 @@ debug_parser_state(void)
 	state.heading = "spacing inside a statement or declaration";
 	debug_ps_bool(next_unary);
 	debug_ps_bool(want_blank);
 	debug_ps_int(ind_paren_level);
 	debug_ps_paren();
 	state.heading = "indentation of comments";
 	debug_ps_int(comment_ind);
 	debug_ps_int(comment_shift);
 	debug_ps_bool(comment_in_first_line);
 	state.heading = "vertical spacing";
 	debug_ps_bool(break_after_comma);
-	debug_ps_bool(force_nl);
+	debug_ps_bool(want_newline);
 	debug_ps_enum(declaration, declaration_name);
 	debug_ps_bool(blank_line_after_decl);
 	state.heading = NULL;
 	debug_blank_line();
 	state.prev_ps = ps;
 	state.ps_first = false;
+}
 void
 debug_psyms_stack(const char *situation)
+{

 @@ -1,14 +1,14 @@
-/*	$NetBSD: indent.c,v 1.366 2023/06/14 19:05:40 rillig Exp $	*/
+/*	$NetBSD: indent.c,v 1.367 2023/06/14 20:46:08 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.366 2023/06/14 19:05:40 rillig Exp $");
+__RCSID("$NetBSD: indent.c,v 1.367 2023/06/14 20:46:08 rillig Exp $");
 #include <sys/param.h>
 #include <err.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "indent.h"
 struct options opt = {
 	.brace_same_line = true,
 	.comment_delimiter_on_blank_line = true,
 @@ -177,27 +177,27 @@ ind_add(int ind, const char *s, size_t l
 		else if (*p == '\t')
 			ind = next_tab(ind);
 		else if (*p == '\b')
 			--ind;
 		else
 			++ind;
+	}
 	return ind;
+}
 static void
 init_globals(void)
+{
-	ps_push(psym_stmt, false);
+	ps_push(psym_stmt, false);	/* as a stop symbol */
 	ps.prev_lsym = lsym_semicolon;
 	ps.lbrace_kind = psym_lbrace_block;
 	const char *suffix = getenv("SIMPLE_BACKUP_SUFFIX");
 	if (suffix != NULL)
 		backup_suffix = suffix;
+}
 static void
 load_profiles(int argc, char **argv)
+{
 	const char *profile_name = NULL;
 @@ -335,51 +335,51 @@ move_com_to_code(lexer_symbol lsym)
 		buf_add_char(&code, ' ');
 	buf_add_buf(&code, &com);
 	buf_clear(&com);
 	ps.want_blank = lsym != lsym_rparen && lsym != lsym_rbracket;
+}
 static void
 update_ps_lbrace_kind(lexer_symbol lsym)
+{
 	if (lsym == lsym_tag) {
 		ps.lbrace_kind = token.s[0] == 's' ? psym_lbrace_struct :
 		    token.s[0] == 'u' ? psym_lbrace_union :
 		    psym_lbrace_enum;
-	} else if (lsym != lsym_type_outside_parentheses
+	} else if (lsym == lsym_type_outside_parentheses
-	    && lsym != lsym_word
+	    || lsym == lsym_word
-	    && lsym != lsym_lbrace)
+	    || lsym == lsym_lbrace) {
 		/* Keep the current '{' kind. */
 	} else
 		ps.lbrace_kind = psym_lbrace_block;
+}
 static void
 indent_declarator(int decl_ind, bool tabs_to_var)
+{
 	int base = ps.ind_level * opt.indent_size;
-	int ind = base + (int)code.len;
+	int ind = ind_add(base, code.s, code.len);
 	int target = base + decl_ind;
 	size_t orig_code_len = code.len;
 	if (tabs_to_var)
 		for (int next; (next = next_tab(ind)) <= target; ind = next)
 			buf_add_char(&code, '\t');
 	for (; ind < target; ind++)
 		buf_add_char(&code, ' ');
 	if (code.len == orig_code_len && ps.want_blank)
 	if (code.len == orig_code_len && ps.want_blank) {
 		buf_add_char(&code, ' ');
 		ps.want_blank = false;
 	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.line_has_func_def
 	    && ps.ind_paren_level == 0;
+}
 @@ -546,27 +546,27 @@ process_preprocessing(void)
 static void
 process_newline(void)
+{
 	if (ps.prev_lsym == lsym_comma
 	    && ps.paren.len == 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.len - 1] == psym_switch_expr
 	    && opt.brace_same_line
 	    && com.len == 0) {
-		ps.force_nl = true;
+		ps.want_newline = true;
 		goto stay_in_line;
+	}
 	output_line();
 stay_in_line:
 	++line_no;
+}
 static bool
 want_blank_before_lparen(void)
+{
 	if (opt.proc_calls_space)
 @@ -581,133 +581,128 @@ want_blank_before_lparen(void)
 		return false;
 	return true;
+}
 static void
 process_lparen(void)
+{
 	if (is_function_pointer_declaration())
 		indent_declarator(ps.decl_ind, ps.tabs_to_var);
 	else if (ps.want_blank && want_blank_before_lparen())
 		buf_add_char(&code, ' ');
 	ps.want_blank = false;
-	buf_add_char(&code, token.s[0]);
+	buf_add_buf(&code, &token);
 	if (opt.extra_expr_indent && ps.spaced_expr_psym != psym_0)
 		ps.extra_expr_indent = eei_maybe;
 	if (ps.in_var_decl && ps.psyms.len <= 3 && !ps.in_init) {
 		parse(psym_stmt);	/* prepare for function definition */
 		ps.in_var_decl = false;
+	}
 	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.line_has_func_def)
 		cast = cast_no;
 	paren_stack_push(&ps.paren, ind_add(0, code.s, code.len), cast);
+}
 static void
 process_rparen(void)
+{
-	if (ps.paren.len == 0) {
+	if (ps.paren.len == 0)
 		diag(0, "Extra '%c'", *token.s);
 		goto unbalanced;
-	enum paren_level_cast cast = ps.paren.item[--ps.paren.len].cast;
+	ps.prev_paren_was_cast = ps.paren.len > 0
-	if (ps.in_func_def_params || (ps.line_has_decl && !ps.in_init))
+	    && ps.paren.item[--ps.paren.len].cast == cast_maybe
-		cast = cast_no;
+	    && !ps.in_func_def_params
 	    && !(ps.line_has_decl && !ps.in_init);
-	ps.prev_paren_was_cast = cast == cast_maybe;
+	if (ps.prev_paren_was_cast) {
 	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.ind_paren_level = (int)ps.paren.len;
-unbalanced:
+	buf_add_buf(&code, &token);
 	buf_add_char(&code, token.s[0]);
 	if (ps.spaced_expr_psym != psym_0 && ps.paren.len == 0) {
 		if (ps.extra_expr_indent == eei_maybe)
 			ps.extra_expr_indent = eei_last;
 		ps.force_nl = true;
 		ps.next_unary = true;
 		ps.in_stmt_or_decl = false;
 		parse(ps.spaced_expr_psym);
 		ps.spaced_expr_psym = psym_0;
 		ps.want_newline = true;
 		ps.next_unary = true;
 		ps.in_stmt_or_decl = false;
 		ps.want_blank = true;
 		out.line_kind = lk_stmt_head;
 		if (ps.extra_expr_indent == eei_maybe)
 			ps.extra_expr_indent = eei_last;
+	}
+}
 static void
 process_lbracket(void)
+{
 	if (code.len > 0
 	    && (ps.prev_lsym == lsym_comma || ps.prev_lsym == lsym_binary_op))
 		buf_add_char(&code, ' ');
 	buf_add_buf(&code, &token);
 	ps.want_blank = false;
 	buf_add_char(&code, token.s[0]);
 	paren_stack_push(&ps.paren, ind_add(0, code.s, code.len), cast_no);
+}
 static void
 process_rbracket(void)
+{
-	if (ps.paren.len == 0) {
+	if (ps.paren.len == 0)
 		diag(0, "Extra '%c'", *token.s);
-		goto unbalanced;
+	if (ps.paren.len > 0)
 		ps.paren.len--;
 	ps.paren.len--;
 	ps.want_blank = true;
 	if (code.len == 0)
 		ps.ind_paren_level = (int)ps.paren.len;
-unbalanced:
+	buf_add_buf(&code, &token);
-	buf_add_char(&code, token.s[0]);
+	ps.want_blank = true;
+}
 static void
 process_lbrace(void)
+{
 	if (ps.prev_lsym == lsym_rparen && ps.prev_paren_was_cast) {
 		ps.in_var_decl = true;	// XXX: not really
 		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.in_init)
 		ps.init_level++;
 	else
-		ps.force_nl = true;
+		ps.want_newline = true;
 	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.in_var_decl) {
 			ps.ind_level_follow = 0;
 			if (opt.function_brace_split)
 				output_line();
 			else
 				ps.want_blank = true;
+		}
+	}
 @@ -779,27 +774,27 @@ process_rbrace(void)
 			    ? opt.decl_indent : opt.local_decl_indent;
+		}
 		ps.in_decl = true;
+	}
 	if (ps.psyms.len == 3)
 		out.line_kind = lk_func_end;
 	parse(psym_rbrace);
 	if (!ps.in_var_decl
 	    && ps.psyms.sym[ps.psyms.len - 1] != psym_do_stmt
 	    && ps.psyms.sym[ps.psyms.len - 1] != psym_if_expr_stmt)
-		ps.force_nl = true;
+		ps.want_newline = 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;
+}
 static void
 process_unary_op(void)
 @@ -836,41 +831,41 @@ process_comma(void)
 		/* indent leading commas and not the actual identifiers */
 		indent_declarator(ps.decl_ind - 1, ps.tabs_to_var);
+	}
 	buf_add_char(&code, ',');
 	if (ps.paren.len == 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)
 			>= opt.max_line_length - typical_varname_length))
-			ps.force_nl = true;
+			ps.want_newline = true;
+	}
+}
 static void
 process_label_colon(void)
+{
 	buf_add_buf(&lab, &code);
 	buf_add_char(&lab, ':');
 	buf_clear(&code);
 	if (ps.seen_case)
 		out.line_kind = lk_case_or_default;
 	ps.in_stmt_or_decl = false;
-	ps.force_nl = ps.seen_case;
+	ps.want_newline = ps.seen_case;
 	ps.seen_case = false;
 	ps.want_blank = false;
+}
 static void
 process_other_colon(void)
+{
 	buf_add_char(&code, ':');
 	ps.want_blank = ps.decl_level == 0;
+}
 static void
 process_semicolon(void)
 @@ -905,27 +900,27 @@ process_semicolon(void)
 		ps.paren.len = 0;
 		if (ps.spaced_expr_psym != psym_0) {
 			parse(ps.spaced_expr_psym);
 			ps.spaced_expr_psym = psym_0;
+		}
+	}
 	buf_add_char(&code, ';');
 	ps.want_blank = true;
 	ps.in_stmt_or_decl = ps.paren.len > 0;
 	ps.decl_ind = 0;
 	if (ps.spaced_expr_psym == psym_0) {
 		parse(psym_stmt);
-		ps.force_nl = true;
+		ps.want_newline = true;
+	}
+}
 static void
 process_type_outside_parentheses(void)
+{
 	parse(psym_decl);	/* let the parser worry about indentation */
 	if (ps.prev_lsym == lsym_rparen && ps.psyms.len <= 2 && code.len > 0)
 		output_line();
 	if (ps.in_func_def_params && opt.indent_parameters &&
 	    ps.decl_level == 0) {
 @@ -958,57 +953,57 @@ process_word(lexer_symbol lsym)
 				buf_add_char(&code, ' ');
 			ps.want_blank = false;
 		} else if (!ps.in_init && !ps.decl_indent_done &&
 		    ps.ind_paren_level == 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.paren.len == 0) {
-		ps.force_nl = true;
+		ps.want_newline = 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();
-	ps.force_nl = true;
+	ps.want_newline = true;
 	parse(psym_do);
+}
 static void
 process_else(void)
+{
 	ps.in_stmt_or_decl = false;
 	if (code.len > 0
 	    && !(opt.cuddle_else && code.s[code.len - 1] == '}'))
 		output_line();
-	ps.force_nl = true;
+	ps.want_newline = true;
 	parse(psym_else);
+}
 static void
 process_lsym(lexer_symbol lsym)
+{
 	switch (lsym) {
 		/* INDENT OFF */
 	case lsym_preprocessing: process_preprocessing(); break;
 	case lsym_newline:	process_newline();	break;
 	case lsym_comment:	process_comment();	break;
 	case lsym_lparen:	process_lparen();	break;
 	case lsym_lbracket:	process_lbracket();	break;
 @@ -1075,35 +1070,35 @@ indent(void)
 		lexer_symbol lsym = lexi();
 		debug_blank_line();
 		debug_printf("line %d: %s", line_no, lsym_name[lsym]);
 		debug_print_buf("token", &token);
 		debug_buffers();
 		debug_blank_line();
 		if (lsym == lsym_eof)
 			return process_eof();
 		if (lsym == lsym_if && ps.prev_lsym == lsym_else
 		    && opt.else_if_in_same_line)
-			ps.force_nl = false;
+			ps.want_newline = false;
 		if (lsym == lsym_preprocessing || lsym == lsym_newline)
-			ps.force_nl = false;
+			ps.want_newline = false;
 		else if (lsym == lsym_comment) {
 			/* no special processing */
 		} else {
-			if (ps.force_nl && should_break_line(lsym)) {
+			if (ps.want_newline && should_break_line(lsym)) {
-				ps.force_nl = false;
+				ps.want_newline = false;
 				output_line();
+			}
 			ps.in_stmt_or_decl = true;
 			if (com.len > 0)
 				move_com_to_code(lsym);
 			update_ps_lbrace_kind(lsym);
+		}
 		process_lsym(lsym);
 		if (lsym != lsym_preprocessing
 		    && lsym != lsym_newline
 		    && lsym != lsym_comment)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: indent.h,v 1.196 2023/06/14 19:05:40 rillig Exp $	*/
+/*	$NetBSD: indent.h,v 1.197 2023/06/14 20:46:08 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
 @@ -262,30 +262,30 @@ struct paren_level {
 	int indent;		/* indentation of the operand/argument,
 				 * relative to the enclosing statement; if
 				 * negative, reflected at -1 */
 	enum paren_level_cast {
 		cast_unknown,
 		cast_maybe,
 		cast_no,
 	} cast;			/* whether the parentheses form a type cast */
 };
 struct psym_stack {
 	parser_symbol *sym;
 	int *ind_level;
-	size_t len;		/* points to one behind the top of the stack;
+	size_t len;		/* points to one behind the top of the stack; 1
-				 * 1 at the top level of the file outside a
+				 * at the top level of the file outside a
-				 * declaration or statement; 2 at the top
+				 * declaration or statement; 2 at the top level
-				 * level */
+				 */
 	size_t cap;
 };
 /*
  * The parser state determines the layout of the formatted text.
+ *
  * At each '#if', the parser state is copied so that the corresponding '#else'
  * lines start in the same state.
+ *
  * In a function body, the number of block braces determines the indentation
  * of statements and declarations.
+ *
  * In a statement, the number of parentheses or brackets determines the
 @@ -383,29 +383,29 @@ extern struct parser_state {
 	/* Indentation of comments */
 	int comment_ind;	/* indentation of the current comment */
 	int comment_shift;	/* all but the first line of a boxed comment
 				 * are shifted this much to the right */
 	bool comment_in_first_line;
 	/* Vertical spacing */
 	bool break_after_comma;	/* whether to add a newline after the next
 				 * comma; used in declarations but not in
 				 * initializer lists */
-	bool force_nl;		/* whether the next token is forced to go to a
+	bool want_newline;	/* whether the next token should go to a new
-				 * new line; used after 'if (expr)' and in
+				 * line; used after 'if (expr)' and in similar
-				 * similar situations; tokens like '{' may
+				 * situations; tokens like '{' or ';' may
 				 * ignore this */
 	enum declaration {
 		decl_no,	/* no declaration anywhere nearby */
 		decl_begin,	/* collecting tokens of a declaration */
 		decl_end,	/* finished a declaration */
 	} declaration;
 	bool blank_line_after_decl;
 } ps;
 extern struct output_state {
 	enum line_kind {
 		lk_other,

 @@ -1,14 +1,14 @@
-/*	$NetBSD: parse.c,v 1.76 2023/06/14 19:05:40 rillig Exp $	*/
+/*	$NetBSD: parse.c,v 1.77 2023/06/14 20:46:08 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,40 +28,40 @@
  * 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: parse.c,v 1.76 2023/06/14 19:05:40 rillig Exp $");
+__RCSID("$NetBSD: parse.c,v 1.77 2023/06/14 20:46:08 rillig Exp $");
 #include <err.h>
 #include <stdlib.h>
 #include "indent.h"
 /*
  * Try to combine the statement on the top of the parse stack with the symbol
  * directly below it, replacing these two symbols with a single symbol.
  */
 static bool
-psyms_reduce_stmt(struct psym_stack *psyms)
+psyms_reduce_stmt(void)
+{
 	struct psym_stack *psyms = &ps.psyms;
 	switch (psyms->sym[psyms->len - 2]) {
 	case psym_stmt:
 		psyms->sym[psyms->len-- - 2] = psym_stmt;
 		return true;
 	case psym_do:
 		psyms->sym[psyms->len-- - 2] = psym_do_stmt;
 		ps.ind_level_follow = psyms->ind_level[psyms->len - 1];
 		return true;
 	case psym_if_expr:
 		psyms->sym[psyms->len-- - 2] = psym_if_expr_stmt;
 @@ -95,46 +95,47 @@ decl_level(void)
 	int level = 0;
 	for (size_t i = ps.psyms.len - 2; i > 0; i--)
 		if (ps.psyms.sym[i] == psym_decl)
 			level++;
 	return level;
+}
 void
 ps_push(parser_symbol psym, bool follow)
+{
 	if (ps.psyms.len == ps.psyms.cap) {
 		ps.psyms.cap += 16;
 		ps.psyms.sym = nonnull(realloc(ps.psyms.sym,
-		    sizeof(ps.psyms.sym[0]) * ps.psyms.cap));
+			sizeof(ps.psyms.sym[0]) * ps.psyms.cap));
 		ps.psyms.ind_level = nonnull(realloc(ps.psyms.ind_level,
-		    sizeof(ps.psyms.ind_level[0]) * ps.psyms.cap));
+			sizeof(ps.psyms.ind_level[0]) * ps.psyms.cap));
+	}
 	ps.psyms.len++;
 	ps.psyms.sym[ps.psyms.len - 1] = psym;
 	ps.psyms.ind_level[ps.psyms.len - 1] =
 	    follow ? ps.ind_level_follow : ps.ind_level;
+}
 /*
  * Repeatedly try to reduce the top two symbols on the parse stack to a single
  * symbol, until no more reductions are possible.
  */
 static void
-psyms_reduce(struct psym_stack *psyms)
+psyms_reduce(void)
+{
 	struct psym_stack *psyms = &ps.psyms;
 again:
 	if (psyms->len >= 2 && psyms->sym[psyms->len - 1] == psym_stmt
-	    && psyms_reduce_stmt(psyms))
+	    && psyms_reduce_stmt())
 		goto again;
 	if (psyms->sym[psyms->len - 1] == psym_while_expr &&
 	    psyms->sym[psyms->len - 2] == psym_do_stmt) {
 		psyms->len -= 2;
 		goto again;
+	}
+}
 static bool
 is_lbrace(parser_symbol psym)
+{
 	return psym == psym_lbrace_block
 	    || psym == psym_lbrace_struct
 @@ -146,27 +147,27 @@ is_lbrace(parser_symbol psym)
  * Shift the token onto the parser stack, then try to reduce it by combining it with
  * previous tokens.
  */
 void
 parse(parser_symbol psym)
+{
 	debug_blank_line();
 	debug_println("parse token: %s", psym_name[psym]);
 	struct psym_stack *psyms = &ps.psyms;
 	if (psym != psym_else) {
 		while (psyms->sym[psyms->len - 1] == psym_if_expr_stmt) {
 			psyms->sym[psyms->len - 1] = psym_stmt;
-			psyms_reduce(&ps.psyms);
+			psyms_reduce();
+		}
+	}
 	switch (psym) {
 	case psym_lbrace_block:
 	case psym_lbrace_struct:
 	case psym_lbrace_union:
 	case psym_lbrace_enum:
 		ps.break_after_comma = false;
 		if (psyms->sym[psyms->len - 1] == psym_decl
 		    || psyms->sym[psyms->len - 1] == psym_stmt)
 			++ps.ind_level_follow;
 @@ -176,27 +177,27 @@ parse(parser_symbol psym)
 			/* for a switch, brace should be two levels out from
 			 * the code */
 			if (psyms->sym[psyms->len - 1] == psym_switch_expr
 			    && opt.case_indent >= 1.0F)
 				--ps.ind_level;
+		}
 		ps_push(psym, false);
 		ps_push(psym_stmt, true);
 		break;
 	case psym_rbrace:
-		/* stack should have <lbrace> <stmt> or <lbrace> <stmt_list> */
+		/* stack should have <lbrace> <stmt> or <lbrace> <decl> */
 		if (!(psyms->len >= 2
 			&& is_lbrace(psyms->sym[psyms->len - 2]))) {
 			diag(1, "Statement nesting error");
 			break;
+		}
 		ps.ind_level = ps.ind_level_follow =
 		    psyms->ind_level[psyms->len-- - 2];
 		psyms->sym[psyms->len - 1] = psym_stmt;
 		break;
 	case psym_decl:
 		if (psyms->sym[psyms->len - 1] == psym_decl)
 			break;	/* only put one declaration onto stack */
 @@ -247,16 +248,16 @@ parse(parser_symbol psym)
 			ps_push(psym_while_expr, false);
 		} else {
 			ps_push(psym_while_expr, true);
 			++ps.ind_level_follow;
+		}
 		break;
 	default:
 		diag(1, "Unknown code to parser");
 		return;
+	}
 	debug_psyms_stack("before reduction");
-	psyms_reduce(&ps.psyms);
+	psyms_reduce();
 	debug_psyms_stack("after reduction");
+}