 @@ -1,14 +1,14 @@
-/*	$NetBSD: indent.c,v 1.338 2023/06/07 15:46:11 rillig Exp $	*/
+/*	$NetBSD: indent.c,v 1.339 2023/06/08 06:47:13 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.338 2023/06/07 15:46:11 rillig Exp $");
+__RCSID("$NetBSD: indent.c,v 1.339 2023/06/08 06:47:13 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 = {
 @@ -302,67 +302,68 @@ set_initial_indentation(void)
 	for (const char *p = inp_p;; p++) {
 		if (*p == ' ')
 			ind++;
 		else if (*p == '\t')
 			ind = next_tab(ind);
 		else
 			break;
+	}
 	ps.ind_level = ps.ind_level_follow = ind / opt.indent_size;
+}
 static void
-code_add_decl_indent(int decl_ind, bool tabs_to_var)
+indent_declarator(int decl_ind, bool tabs_to_var)
+{
 	int base = ps.ind_level * opt.indent_size;
 	int ind = base + (int)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) {
 		buf_add_char(&code, ' ');
 		ps.want_blank = false;
+	}
 	ps.decl_indent_done = true;
+}
 static void
 update_ps_decl_ptr(lexer_symbol lsym)
+{
 	if (lsym == lsym_semicolon
 	    || lsym == lsym_lbrace
 	    || lsym == lsym_rbrace
 	    || (lsym == lsym_lparen && ps.prev_lsym != lsym_sizeof)
 	    || (lsym == lsym_comma && ps.in_decl)
 	    || lsym == lsym_modifier)
 		ps.decl_ptr = dp_start;
 	else if (ps.decl_ptr == dp_start && lsym == lsym_word)
 		ps.decl_ptr = dp_word;
 	else if ((ps.decl_ptr == dp_word || ps.decl_ptr == dp_word_asterisk)
 	    && (lsym == lsym_unary_op && token.s[0] == '*'))
 		ps.decl_ptr = dp_word_asterisk;
 	else
 		ps.decl_ptr = dp_other;
+}
 static void
-update_ps_prev_tag(lexer_symbol lsym)
+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
 	    && lsym != lsym_word
 	    && lsym != lsym_lbrace)
 		ps.lbrace_kind = psym_lbrace_block;
+}
 static int
 process_eof(void)
 @@ -454,30 +455,29 @@ want_blank_before_lparen(void)
 		return false;
 	return true;
+}
 static void
 process_lparen(void)
+{
 	if (++ps.nparen == array_length(ps.paren)) {
 		diag(0, "Reached internal limit of %zu unclosed parentheses",
 		    array_length(ps.paren));
 		ps.nparen--;
+	}
-	if (is_function_pointer_declaration()) {
+	if (is_function_pointer_declaration())
-		code_add_decl_indent(ps.decl_ind, ps.tabs_to_var);
+		indent_declarator(ps.decl_ind, ps.tabs_to_var);
-		ps.decl_indent_done = true;
+	else if (want_blank_before_lparen())
 	} 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 && !opt.lineup_to_parens
 	    && ps.spaced_expr_psym != psym_0 && ps.nparen == 1
 	    && opt.continuation_indent == opt.indent_size)
 		ps.extra_expr_indent = eei_yes;
 	if (ps.init_or_struct && ps.psyms.top <= 2) {
 		/* A kludge to correctly align function definitions. */
 		parse(psym_stmt);
 		ps.init_or_struct = false;
 @@ -494,48 +494,36 @@ process_lparen(void)
 	    || ps.prev_lsym == lsym_for
 	    || ps.prev_lsym == lsym_if
 	    || ps.prev_lsym == lsym_switch
 	    || ps.prev_lsym == lsym_while
 	    || ps.is_function_definition)
 		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 bool
 want_blank_before_lbracket(void)
 	if (code.len == 0)
 		return false;
 	if (ps.prev_lsym == lsym_comma)
 		return true;
 	if (ps.prev_lsym == lsym_binary_op)
 		return true;
 	return false;
 static void
 process_lbracket(void)
+{
 	if (++ps.nparen == array_length(ps.paren)) {
 		diag(0, "Reached internal limit of %zu unclosed parentheses",
 		    array_length(ps.paren));
 		ps.nparen--;
+	}
-	if (want_blank_before_lbracket())
+	if (ps.prev_lsym == lsym_comma || ps.prev_lsym == lsym_binary_op)
 		buf_add_char(&code, ' ');
 	ps.want_blank = false;
 	buf_add_char(&code, token.s[0]);
 	int indent = ind_add(0, code.s, code.len);
 	ps.paren[ps.nparen - 1].indent = indent;
 	ps.paren[ps.nparen - 1].cast = cast_no;
 	debug_println("paren_indents[%d] is now %d", ps.nparen - 1, indent);
+}
 static void
 process_rparen(void)
 @@ -581,95 +569,69 @@ process_rbracket(void)
 		diag(0, "Extra '%c'", *token.s);
 		goto unbalanced;
+	}
 	--ps.nparen;
 	ps.want_blank = true;
 	if (code.len == 0)
 		ps.line_start_nparen = ps.nparen;
 unbalanced:
 	buf_add_char(&code, token.s[0]);
+}
 static bool
 want_blank_before_unary_op(void)
 	if (ps.want_blank)
 		return true;
 	if (token.s[0] == '+' || token.s[0] == '-')
 		return code.len > 0 && code.s[code.len - 1] == token.s[0];
 	return false;
 static void
 process_unary_op(void)
+{
-	if (!ps.decl_indent_done && ps.in_decl && !ps.block_init &&
+	if (is_function_pointer_declaration()) {
-	    !ps.is_function_definition && ps.line_start_nparen == 0) {
+		int ind = ps.decl_ind - (int)token.len;
-		/* pointer declarations */
+		indent_declarator(ind, ps.tabs_to_var);
-		code_add_decl_indent(ps.decl_ind - (int)token.len,
+		ps.want_blank = false;
-		    ps.tabs_to_var);
+	} else if ((token.s[0] == '+' || token.s[0] == '-')
-		ps.decl_indent_done = true;
+	   && code.len > 0 && code.s[code.len - 1] == token.s[0])
-	} else if (want_blank_before_unary_op())
+		ps.want_blank = true;
 		buf_add_char(&code, ' ');
 	buf_add_buf(&code, &token);
 	ps.want_blank = false;
-static void
+	if (ps.want_blank)
 process_binary_op(void)
 	if (code.len > 0 && ps.want_blank)
 		buf_add_char(&code, ' ');
 	buf_add_buf(&code, &token);
-	ps.want_blank = true;
+	ps.want_blank = false;
+}
 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) {
 		ps.in_stmt_cont = true;
 		ps.in_stmt_or_decl = true;
 		ps.in_decl = false;
+	}
 	if (ps.want_blank)
 		buf_add_char(&code, ' ');
 	buf_add_char(&code, '?');
 	ps.want_blank = true;
+}
 static void
 process_colon_question(void)
+{
 	if (code.len == 0) {
 		ps.in_stmt_cont = true;
 		ps.in_stmt_or_decl = true;
 		ps.in_decl = false;
+	}
 	if (ps.want_blank)
 		buf_add_char(&code, ' ');
 	buf_add_char(&code, ':');
 	ps.want_blank = true;
+}
 static void
 process_colon_label(void)
+{
 	buf_add_buf(&lab, &code);
 	buf_add_char(&lab, ':');
 	code.len = 0;
 	if (ps.seen_case)
 		out.line_kind = lk_case_or_default;
 	ps.in_stmt_or_decl = false;
 	ps.force_nl = ps.seen_case;
 @@ -692,28 +654,27 @@ process_semicolon(void)
 	if (ps.decl_level == 0)
 		ps.init_or_struct = 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.block_init_level = 0;
 	ps.declaration = ps.declaration == decl_begin ? decl_end : decl_no;
 	if (ps.in_decl && code.len == 0 && !ps.block_init &&
 	    !ps.decl_indent_done && ps.line_start_nparen == 0) {
 		/* indent stray semicolons in declarations */
-		code_add_decl_indent(ps.decl_ind - 1, ps.tabs_to_var);
+		indent_declarator(ps.decl_ind - 1, ps.tabs_to_var);
 		ps.decl_indent_done = true;
+	}
 	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. */
 		diag(1, "Unbalanced parentheses");
 		ps.nparen = 0;
 		if (ps.spaced_expr_psym != psym_0) {
 @@ -813,27 +774,27 @@ process_rbrace(void)
 		ps.nparen = 0;
 		ps.spaced_expr_psym = psym_0;
+	}
 	ps.declaration = decl_no;
 	if (ps.block_init_level > 0)
 		ps.block_init_level--;
 	if (code.len > 0 && !ps.block_init)
 		output_line();
 	buf_add_char(&code, '}');
 	ps.want_blank = true;
-	ps.in_stmt_or_decl = false;
+	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)
 @@ -868,30 +829,28 @@ process_else(void)
 	if (code.len > 0
 	    && !(opt.cuddle_else && code.s[code.len - 1] == '}'))
 		output_line();
 	ps.force_nl = true;
 	parse(psym_else);
+}
 static void
 process_type(void)
+{
 	parse(psym_decl);	/* let the parser worry about indentation */
-	if (ps.prev_lsym == lsym_rparen && ps.psyms.top <= 1) {
+	if (ps.prev_lsym == lsym_rparen && ps.psyms.top <= 1 && code.len > 0)
-		if (code.len > 0)
+		output_line();
 			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_decl = ps.decl_on_line = ps.prev_lsym != lsym_typedef;
 	if (ps.decl_level <= 0)
 		ps.declaration = decl_begin;
 	int len = (int)token.len + 1;
 @@ -908,30 +867,28 @@ 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 &&
 		    ps.line_start_nparen == 0) {
 			if (opt.decl_indent == 0
 			    && code.len > 0 && code.s[code.len - 1] == '}')
-				ps.decl_ind =
+				ps.decl_ind = ind_add(0, code.s, code.len) + 1;
-				    ind_add(0, code.s, code.len) + 1;
+			indent_declarator(ps.decl_ind, ps.tabs_to_var);
 			code_add_decl_indent(ps.decl_ind, ps.tabs_to_var);
 			ps.decl_indent_done = true;
 			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);
 		ps.spaced_expr_psym = psym_0;
+	}
+}
 static void
 @@ -942,28 +899,27 @@ process_period(void)
 	buf_add_char(&code, '.');
 	ps.want_blank = 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 &&
 	    !ps.decl_indent_done && ps.line_start_nparen == 0) {
 		/* indent leading commas and not the actual identifiers */
-		code_add_decl_indent(ps.decl_ind - 1, ps.tabs_to_var);
+		indent_declarator(ps.decl_ind - 1, ps.tabs_to_var);
 		ps.decl_indent_done = true;
+	}
 	buf_add_char(&code, ',');
 	if (ps.nparen == 0) {
 		if (ps.block_init_level == 0)
 			ps.block_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;
+	}
 @@ -1015,197 +971,115 @@ read_preprocessing_line(void)
 	while (lab.len > 0 && ch_isblank(lab.s[lab.len - 1]))
 		lab.len--;
+}
 static void
 process_preprocessing(void)
+{
 	if (lab.len > 0 || code.len > 0 || com.len > 0)
 		output_line();
 	read_preprocessing_line();
-	const char *end = lab.s + lab.len;
+	const char *dir = lab.s + 1, *line_end = lab.s + lab.len;
-	const char *dir = lab.s + 1;
+	while (dir < line_end && ch_isblank(*dir))
 	while (dir < end && ch_isblank(*dir))
 		dir++;
 	size_t dir_len = 0;
-	while (dir + dir_len < end && ch_isalpha(dir[dir_len]))
+	while (dir + dir_len < line_end && ch_isalpha(dir[dir_len]))
 		dir_len++;
 	if (dir_len >= 2 && memcmp(dir, "if", 2) == 0) {
 		if ((size_t)ifdef_level < array_length(state_stack))
 			state_stack[ifdef_level++] = ps;
 		else
 			diag(1, "#if stack overflow");
 		out.line_kind = lk_if;
 	} else if (dir_len >= 2 && memcmp(dir, "el", 2) == 0) {
 		if (ifdef_level <= 0)
 			diag(1, dir[2] == 'i'
 			    ? "Unmatched #elif" : "Unmatched #else");
 		else
 			ps = state_stack[ifdef_level - 1];
 	} 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;
+	}
 	/* subsequent processing of the newline character will cause the line
 	 * to be printed */
+}
 static void
 process_lsym(lexer_symbol lsym)
+{
 	switch (lsym) {
 	/* INDENT OFF */
-	case lsym_newline:
+	case lsym_preprocessing: process_preprocessing(); break;
-		process_newline();
+	case lsym_newline:	process_newline();	break;
-		break;
+	case lsym_comment:	process_comment();	break;
 	case lsym_lparen:	process_lparen();	break;
-	case lsym_lparen:
+	case lsym_lbracket:	process_lbracket();	break;
-		process_lparen();
+	case lsym_rparen:	process_rparen();	break;
-		break;
+	case lsym_rbracket:	process_rbracket();	break;
 	case lsym_lbrace:	process_lbrace();	break;
-	case lsym_lbracket:
+	case lsym_rbrace:	process_rbrace();	break;
-		process_lbracket();
+	case lsym_period:	process_period();	break;
-		break;
+	case lsym_unary_op:	process_unary_op();	break;
 	case lsym_postfix_op:	process_postfix_op();	break;
-	case lsym_rparen:
+	case lsym_binary_op:				goto copy_token;
-		process_rparen();
+	case lsym_question:	process_question();	goto copy_token;
-		break;
+	case lsym_colon_question: process_colon_question(); goto copy_token;
 	case lsym_colon_label:	process_colon_label();	break;
-	case lsym_rbracket:
+	case lsym_colon_other:	process_colon_other();	break;
-		process_rbracket();
+	case lsym_comma:	process_comma();	break;
-		break;
+	case lsym_semicolon:	process_semicolon();	break;
 	case lsym_typedef:				goto copy_token;
-	case lsym_unary_op:
+	case lsym_modifier:				goto copy_token;
-		process_unary_op();
+	case lsym_case:		ps.seen_case = true;	goto copy_token;
-		break;
+	case lsym_default:	ps.seen_case = true;	goto copy_token;
 	case lsym_do:		process_do();		goto copy_token;
-	case lsym_binary_op:
+	case lsym_else:		process_else();		goto copy_token;
-		process_binary_op();
+	case lsym_for:		ps.spaced_expr_psym = psym_for_exprs; goto copy_token;
-		break;
+	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_postfix_op:
+	case lsym_while:	ps.spaced_expr_psym = psym_while_expr; goto copy_token;
-		process_postfix_op();
+	/* INDENT ON */
 		break;
 	case lsym_question:
 		process_question();
 		break;
 	case lsym_case:
 	case lsym_default:
 		ps.seen_case = true;
 		goto copy_token;
 	case lsym_colon_question:
 		process_colon_question();
 		break;
 	case lsym_colon_label:
 		process_colon_label();
 		break;
 	case lsym_colon_other:
 		process_colon_other();
 		break;
 	case lsym_semicolon:
 		process_semicolon();
 		break;
 	case lsym_lbrace:
 		process_lbrace();
 		break;
 	case lsym_rbrace:
 		process_rbrace();
 		break;
 	case lsym_switch:
 		ps.spaced_expr_psym = psym_switch_expr;
 		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_while:
 		ps.spaced_expr_psym = psym_while_expr;
 		goto copy_token;
 	case lsym_do:
 		process_do();
 		goto copy_token;
 	case lsym_else:
 		process_else();
 		goto copy_token;
 	case lsym_typedef:
 	case lsym_modifier:
 		goto copy_token;
 	case lsym_tag:
 		if (ps.nparen > 0)
 			goto copy_token;
 		/* FALLTHROUGH */
 	case lsym_type_outside_parentheses:
 		process_type();
 		goto copy_token;
 	case lsym_type_in_parentheses:
 	case lsym_offsetof:
 	case lsym_sizeof:
 	case lsym_offsetof:
 	case lsym_word:
 	case lsym_funcname:
 	case lsym_return:
 		process_ident(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;
 	case lsym_period:
 		process_period();
 		break;
 	case lsym_comma:
 		process_comma();
 		break;
 	case lsym_preprocessing:
 		process_preprocessing();
 		break;
 	case lsym_comment:
 		process_comment();
 		break;
 	default:
 		break;
+	}
+}
 static int
 indent(void)
+{
 	debug_parser_state();
 	for (;;) {		/* loop until we reach eof */
 		lexer_symbol lsym = lexi();
 @@ -1218,35 +1092,31 @@ indent(void)
 		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;
 		if (lsym == lsym_newline || lsym == lsym_preprocessing)
 			ps.force_nl = false;
 		else if (lsym == lsym_comment) {
 			/* no special processing */
 		} else {
 			maybe_break_line(lsym);
 			/*
 			 * Add an extra level of indentation; turned off again
 			 * by a ';' or '}'.
 			 */
 			ps.in_stmt_or_decl = true;
 			if (com.len > 0)
 				move_com_to_code(lsym);
 			update_ps_decl_ptr(lsym);
-			update_ps_prev_tag(lsym);
+			update_ps_lbrace_kind(lsym);
+		}
 		process_lsym(lsym);
 		debug_parser_state();
 		if (lsym != lsym_comment && lsym != lsym_newline &&
 		    lsym != lsym_preprocessing)
 			ps.prev_lsym = lsym;
+	}
+}
 int

 @@ -1,14 +1,14 @@
-/* $NetBSD: lsym_rbrace.c,v 1.6 2023/06/04 13:49:00 rillig Exp $ */
+/* $NetBSD: lsym_rbrace.c,v 1.7 2023/06/08 06:47:14 rillig Exp $ */
 /*
  * Tests for the token lsym_rbrace, which represents a '}' in these contexts:
+ *
  * In an initializer, '}' ends an inner group of initializers, usually to
  * initialize a nested struct, union or array.
+ *
  * In a function body, '}' ends a block.
+ *
  * In an expression like '(type){...}', '}' ends a compound literal, which is
  * typically used in an assignment to a struct or array.
+ *
  * In macro arguments, a '}' is an ordinary character, it does not need to be
 @@ -56,13 +56,43 @@ function(void)
 /* Compound literal */
 //indent input
 struct point
 origin(void)
+{
 	return (struct point){
 		.x = 0,
 		.y = 0,
 	};
+}
 //indent end
 //indent run-equals-input
 //indent input
+{
 int numbers[][] = {
 {11},
 {21},
 {31},
 };
 int numbers[][] = {{11},
 {21},
 {31},
 };
+}
 //indent end
 //indent run -di0
+{
 	int numbers[][] = {
 		{11},
 		{21},
 		{31},
 	};
 	int numbers[][] = {{11},
 	// $ FIXME: Must be indented.
 	{21},
 	{31},
 	};
+}
 //indent end

 @@ -1,14 +1,14 @@
-/*	$NetBSD: indent.h,v 1.177 2023/06/07 15:46:12 rillig Exp $	*/
+/*	$NetBSD: indent.h,v 1.178 2023/06/08 06:47:13 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
 @@ -71,28 +71,28 @@
 typedef enum lexer_symbol {
 	lsym_eof,
 	lsym_preprocessing,	/* the initial '#' of a preprocessing line */
 	lsym_newline,
 	lsym_comment,		/* the initial '/ *' or '//' of a comment */
 	lsym_lparen,
 	lsym_lbracket,
 	lsym_rparen,
 	lsym_rbracket,
 	lsym_lbrace,
 	lsym_rbrace,
 	lsym_period,
 	lsym_unary_op,		/* e.g. '*', '&', '-' or leading '++' */
 	lsym_binary_op,		/* e.g. '*', '&', '<<', '&&' or '/=' */
 	lsym_postfix_op,	/* trailing '++' or '--' */
 	lsym_binary_op,		/* e.g. '*', '&', '<<', '&&' or '/=' */
 	lsym_question,		/* the '?' from a '?:' expression */
 	lsym_colon_question,	/* the ':' from a '?:' expression */
 	lsym_colon_label,	/* the ':' after a label */
 	lsym_colon_other,	/* bit-fields, generic-association (C11),
 				 * enum-type-specifier (C23),
 				 * attribute-prefixed-token (C23),
 				 * pp-prefixed-parameter (C23 6.10) */
 	lsym_comma,
 	lsym_semicolon,
 	lsym_typedef,
 	lsym_modifier,		/* modifiers for types, functions, variables */
 	lsym_type_outside_parentheses,
 	lsym_type_in_parentheses,
 @@ -307,32 +307,31 @@ extern struct parser_state {
 					 * 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 */
+				 * 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;		/* whether we are in a declaration. The
+	bool in_decl;		/* XXX: double-check the exact meaning */
 				 * processing of braces is then slightly
 				 * different */
 	bool in_func_def_params;
 	bool seen_case;		/* whether there was a 'case' or 'default', to
 				 * properly space the following ':' */
 	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
 					 * the parser symbol stack next */
 	/* Indentation of statements and declarations */
 	int ind_level;		/* the indentation level for the line that is