 @@ -1,399 +1,399 @@
-/*	$NetBSD: debug.c,v 1.52 2023/06/10 20:37:12 rillig Exp $	*/
+/*	$NetBSD: debug.c,v 1.53 2023/06/10 21:36:38 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``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.52 2023/06/10 20:37:12 rillig Exp $");
+__RCSID("$NetBSD: debug.c,v 1.53 2023/06/10 21:36:38 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 = {
 	.full_parser_state = false,
 };
 const char *const lsym_name[] = {
 	"eof",
 	"preprocessing",
 	"newline",
 	"comment",
 	"lparen",
 	"rparen",
 	"lbracket",
 	"rbracket",
 	"lbrace",
 	"rbrace",
 	"period",
 	"unary_op",
 	"sizeof",
 	"offsetof",
 	"postfix_op",
 	"binary_op",
 	"question",
 	"question_colon",
 	"comma",
 	"typedef",
 	"modifier",
 	"tag",
 	"type_outside_parentheses",
 	"type_in_parentheses",
 	"word",
 	"funcname",
 	"label_colon",
 	"other_colon",
 	"semicolon",
 	"case",
 	"default",
 	"do",
 	"else",
 	"for",
 	"if",
 	"switch",
 	"while",
 	"return",
 };
 const char *const psym_name[] = {
 	"-",
 	"{block",
 	"{struct",
 	"{union",
 	"{enum",
 	"}",
 	"decl",
 	"stmt",
 	"stmt_list",
 	"for_exprs",
 	"if_expr",
 	"if_expr_stmt",
 	"if_expr_stmt_else",
 	"else",
 	"switch_expr",
 	"do",
 	"do_stmt",
 	"while_expr",
 };
 static const char *const declaration_name[] = {
 	"no",
 	"begin",
 	"end",
 };
 const char *const paren_level_cast_name[] = {
 	"(unknown cast)",
 	"(maybe cast)",
 	"(no cast)",
 };
 const char *const line_kind_name[] = {
 	"other",
 	"blank",
 	"#if",
 	"#endif",
 	"stmt head",
 	"}",
 	"block comment",
 	"case/default",
 };
 static const char *const extra_expr_indent_name[] = {
 	"no",
 	"maybe",
 	"last",
 };
 static struct {
 	struct parser_state prev_ps;
 	bool ps_first;
 	const char *heading;
 	unsigned wrote_newlines;
 } state = {
 	.ps_first = true,
 	.wrote_newlines = 1,
 };
 void
 debug_printf(const char *fmt, ...)
+{
 	FILE *f = output == stdout ? stderr : stdout;
 	va_list ap;
 	if (state.heading != NULL) {
 		fprintf(f, "%s\n", state.heading);
 		state.heading = NULL;
+	}
 	va_start(ap, fmt);
 	vfprintf(f, fmt, ap);
 	va_end(ap);
 	state.wrote_newlines = 0;
+}
 void
 debug_println(const char *fmt, ...)
+{
 	FILE *f = output == stdout ? stderr : stdout;
 	va_list ap;
 	if (state.heading != NULL) {
 		fprintf(f, "%s\n", state.heading);
 		state.heading = NULL;
 		state.wrote_newlines = 1;
+	}
 	va_start(ap, fmt);
 	vfprintf(f, fmt, ap);
 	va_end(ap);
 	fprintf(f, "\n");
 	state.wrote_newlines = fmt[0] == '\0' ? state.wrote_newlines + 1 : 1;
+}
 void
 debug_blank_line(void)
+{
 	while (state.wrote_newlines < 2)
 		debug_println("");
+}
 void
 debug_vis_range(const char *prefix, const char *s, size_t len,
     const char *suffix)
+{
 	debug_printf("%s", prefix);
 	for (size_t i = 0; i < len; i++) {
 		const char *p = s + i;
 		if (*p == '\\' || *p == '"')
 			debug_printf("\\%c", *p);
 		else if (isprint((unsigned char)*p))
 			debug_printf("%c", *p);
 		else if (*p == '\n')
 			debug_printf("\\n");
 		else if (*p == '\t')
 			debug_printf("\\t");
 		else
 			debug_printf("\\x%02x", (unsigned char)*p);
+	}
 	debug_printf("%s", suffix);
+}
 void
 debug_print_buf(const char *name, const struct buffer *buf)
+{
 	if (buf->len > 0) {
 		debug_printf(" %s ", name);
 		debug_vis_range("\"", buf->s, buf->len, "\"");
+	}
+}
 void
 debug_buffers(void)
+{
 	debug_print_buf("label", &lab);
 	debug_print_buf("code", &code);
 	debug_print_buf("comment", &com);
 	debug_blank_line();
+}
 static void
 write_ps_bool(const char *name, bool prev, bool curr)
+{
 	if (!state.ps_first && curr != prev) {
 		char diff = " -+x"[(prev ? 1 : 0) + (curr ? 2 : 0)];
 		debug_println("        [%c]  ps.%s", diff, name);
 	} else if (config.full_parser_state || state.ps_first)
 		debug_println("        [%c]  ps.%s", curr ? 'x' : ' ', name);
+}
 static void
 write_ps_int(const char *name, int prev, int curr)
+{
 	if (!state.ps_first && curr != prev)
 		debug_println(" %3d -> %3d  ps.%s", prev, curr, name);
 	else if (config.full_parser_state || state.ps_first)
 		debug_println("        %3d  ps.%s", curr, name);
+}
 static void
 write_ps_enum(const char *name, const char *prev, const char *curr)
+{
 	if (!state.ps_first && strcmp(prev, curr) != 0)
 		debug_println(" %3s -> %3s  ps.%s", prev, curr, name);
 	else if (config.full_parser_state || state.ps_first)
 		debug_println(" %10s  ps.%s", curr, name);
+}
 static bool
 ps_paren_has_changed(void)
+{
 	if (state.prev_ps.nparen != ps.nparen)
 		return true;
 	const struct paren_level *prev = state.prev_ps.paren, *curr = ps.paren;
 	for (int i = 0; i < ps.nparen; i++)
 		if (curr[i].indent != prev[i].indent
 		    || curr[i].cast != prev[i].cast)
 			return true;
 	return false;
+}
 static void
 debug_ps_paren(void)
+{
 	if (!config.full_parser_state && !ps_paren_has_changed()
 	    && !state.ps_first)
 		return;
 	debug_printf("             ps.paren:");
 	for (int i = 0; i < ps.nparen; i++) {
 		debug_printf(" %s%d",
 		    paren_level_cast_name[ps.paren[i].cast],
 		    ps.paren[i].indent);
+	}
 	if (ps.nparen == 0)
 		debug_printf(" none");
 	debug_println("");
+}
 static bool
 ps_di_stack_has_changed(void)
+{
 	if (state.prev_ps.decl_level != ps.decl_level)
 		return true;
 	for (int i = 0; i < ps.decl_level; i++)
 		if (state.prev_ps.di_stack[i] != ps.di_stack[i])
 			return true;
 	return false;
+}
 static void
 debug_ps_di_stack(void)
+{
 	bool changed = ps_di_stack_has_changed();
 	if (!config.full_parser_state && !changed && !state.ps_first)
 		return;
 	debug_printf("     %s      ps.di_stack:", changed ? "->" : "  ");
 	for (int i = 0; i < ps.decl_level; i++)
 		debug_printf(" %d", ps.di_stack[i]);
 	if (ps.decl_level == 0)
 		debug_printf(" none");
 	debug_println("");
+}
 #define debug_ps_bool(name) \
 	write_ps_bool(#name, state.prev_ps.name, ps.name)
 #define debug_ps_int(name) \
 	write_ps_int(#name, state.prev_ps.name, ps.name)
 #define debug_ps_enum(name, names) \
         write_ps_enum(#name, (names)[state.prev_ps.name], (names)[ps.name])
 void
 debug_parser_state(void)
+{
 	debug_blank_line();
 	state.heading = "token classification";
 	debug_ps_enum(prev_lsym, lsym_name);
 	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(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);
 	state.heading = "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();
 	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_psyms_stack instead.
 	state.heading = "spacing inside a statement or declaration";
 	debug_ps_bool(next_unary);
 	debug_ps_bool(want_blank);
-	debug_ps_int(line_start_nparen);
+	debug_ps_int(ind_paren_level);
 	debug_ps_int(nparen);
 	debug_ps_paren();
 	state.heading = "horizontal spacing for comments";
 	debug_ps_int(comment_delta);
 	debug_ps_int(n_comment_delta);
 	debug_ps_int(com_ind);
 	state.heading = "vertical spacing";
 	debug_ps_bool(break_after_comma);
 	debug_ps_bool(force_nl);
 	debug_ps_enum(declaration, declaration_name);
 	debug_ps_bool(blank_line_after_decl);
 	state.heading = "comments";
 	debug_ps_bool(curr_col_1);
 	debug_ps_bool(next_col_1);
 	state.heading = NULL;
 	debug_blank_line();
 	state.prev_ps = ps;
 	state.ps_first = false;
+}
 void
 debug_psyms_stack(const char *situation)
+{
 	debug_printf("parse stack %s:", situation);
 	const struct psym_stack *psyms = &ps.psyms;
 	for (int i = 0; i <= psyms->top; ++i)
 		debug_printf(" %d %s",
 		    psyms->ind_level[i], psym_name[psyms->sym[i]]);
 	debug_println("");
+}
 #endif

 @@ -1,1080 +1,1080 @@
-/*	$NetBSD: indent.c,v 1.356 2023/06/10 20:37:12 rillig Exp $	*/
+/*	$NetBSD: indent.c,v 1.357 2023/06/10 21:36:38 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
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *	This product includes software developed by the University of
  *	California, Berkeley and its contributors.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 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.356 2023/06/10 20:37:12 rillig Exp $");
+__RCSID("$NetBSD: indent.c,v 1.357 2023/06/10 21:36:38 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,
 	.cuddle_else = true,
 	.comment_column = 33,
 	.decl_indent = 16,
 	.else_if_in_same_line = true,
 	.function_brace_split = true,
 	.format_col1_comments = true,
 	.format_block_comments = true,
 	.indent_parameters = true,
 	.indent_size = 8,
 	.local_decl_indent = -1,
 	.lineup_to_parens = true,
 	.procnames_start_line = true,
 	.star_comment_cont = true,
 	.tabsize = 8,
 	.max_line_length = 78,
 	.use_tabs = true,
 };
 struct parser_state ps;
 struct buffer token;
 struct buffer lab;
 struct buffer code;
 struct buffer com;
 bool found_err;
 bool had_eof;
 int line_no = 1;
 static int ifdef_level;
 static struct parser_state state_stack[5];
 FILE *input;
 FILE *output;
 static const char *in_name = "Standard Input";
 static char backup_name[PATH_MAX];
 static const char *backup_suffix = ".BAK";
 void *
 nonnull(void *p)
+{
 	if (p == NULL)
 		err(EXIT_FAILURE, NULL);
 	return p;
+}
 static void
 buf_expand(struct buffer *buf, size_t add_size)
+{
 	buf->cap = buf->cap + add_size + 400;
 	buf->s = nonnull(realloc(buf->s, buf->cap));
+}
 #ifdef debug
 void
 buf_terminate(struct buffer *buf)
+{
 	if (buf->len == buf->cap)
 		buf_expand(buf, 1);
 	buf->s[buf->len] = '\0';
+}
 #endif
 void
 buf_add_char(struct buffer *buf, char ch)
+{
 	if (buf->len == buf->cap)
 		buf_expand(buf, 1);
 	buf->s[buf->len++] = ch;
 	buf_terminate(buf);
+}
 void
 buf_add_chars(struct buffer *buf, const char *s, size_t len)
+{
 	if (len == 0)
 		return;
 	if (len > buf->cap - buf->len)
 		buf_expand(buf, len);
 	memcpy(buf->s + buf->len, s, len);
 	buf->len += len;
 	buf_terminate(buf);
+}
 static void
 buf_add_buf(struct buffer *buf, const struct buffer *add)
+{
 	buf_add_chars(buf, add->s, add->len);
+}
 void
 diag(int level, const char *msg, ...)
+{
 	va_list ap;
 	if (level != 0)
 		found_err = true;
 	va_start(ap, msg);
 	fprintf(stderr, "%s: %s:%d: ",
 	    level == 0 ? "warning" : "error", in_name, line_no);
 	vfprintf(stderr, msg, ap);
 	fprintf(stderr, "\n");
 	va_end(ap);
+}
 /*
  * Compute the indentation from starting at 'ind' and adding the text starting
  * at 's'.
  */
 int
 ind_add(int ind, const char *s, size_t len)
+{
 	for (const char *p = s; len > 0; p++, len--) {
 		if (*p == '\n')
 			ind = 0;
 		else if (*p == '\t')
 			ind = next_tab(ind);
 		else if (*p == '\b')
 			--ind;
 		else
 			++ind;
+	}
 	return ind;
+}
 static void
 init_globals(void)
+{
 	ps.psyms.sym[0] = psym_stmt_list;
 	ps.prev_lsym = lsym_semicolon;
 	ps.next_col_1 = true;
 	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;
 	for (int i = 1; i < argc; ++i) {
 		const char *arg = argv[i];
 		if (strcmp(arg, "-npro") == 0)
 			return;
 		if (arg[0] == '-' && arg[1] == 'P' && arg[2] != '\0')
 			profile_name = arg + 2;
+	}
 	load_profile_files(profile_name);
+}
 /*
  * Copy the input file to the backup file, then make the backup file the input
  * and the original input file the output.
  */
 static void
 copy_to_bak_file(void)
+{
 	size_t n;
 	char buff[BUFSIZ];
 	const char *last_slash = strrchr(in_name, '/');
 	const char *base = last_slash != NULL ? last_slash + 1 : in_name;
 	snprintf(backup_name, sizeof(backup_name), "%s%s", base, backup_suffix);
 	/* copy the input file to the backup file */
 	FILE *bak = fopen(backup_name, "w");
 	if (bak == NULL)
 		err(1, "%s", backup_name);
 	while ((n = fread(buff, 1, sizeof(buff), input)) > 0)
 		if (fwrite(buff, 1, n, bak) != n)
 			err(1, "%s", backup_name);
 	if (fclose(input) != 0)
 		err(1, "%s", in_name);
 	if (fclose(bak) != 0)
 		err(1, "%s", backup_name);
 	/* re-open the backup file as the input file */
 	input = fopen(backup_name, "r");
 	if (input == NULL)
 		err(1, "%s", backup_name);
 	/* now the original input file will be the output */
 	output = fopen(in_name, "w");
 	if (output == NULL) {
 		remove(backup_name);
 		err(1, "%s", in_name);
+	}
+}
 static void
 parse_command_line(int argc, char **argv)
+{
 	for (int i = 1; i < argc; ++i) {
 		const char *arg = argv[i];
 		if (arg[0] == '-') {
 			set_option(arg, "Command line");
 		} else if (input == NULL) {
 			in_name = arg;
 			if ((input = fopen(in_name, "r")) == NULL)
 				err(1, "%s", in_name);
 		} else if (output == NULL) {
 			if (strcmp(arg, in_name) == 0)
 				errx(1, "input and output files "
 				    "must be different");
 			if ((output = fopen(arg, "w")) == NULL)
 				err(1, "%s", arg);
 		} else
 			errx(1, "too many arguments: %s", arg);
+	}
 	if (input == NULL) {
 		input = stdin;
 		output = stdout;
 	} else if (output == NULL)
 		copy_to_bak_file();
 	if (opt.comment_column <= 1)
 		opt.comment_column = 2;	/* don't put normal comments in column
 					 * 1, see opt.format_col1_comments */
 	if (opt.block_comment_max_line_length <= 0)
 		opt.block_comment_max_line_length = opt.max_line_length;
 	if (opt.local_decl_indent < 0)
 		opt.local_decl_indent = opt.decl_indent;
 	if (opt.decl_comment_column <= 0)
 		opt.decl_comment_column = opt.left_justify_decl
 		    ? (opt.comment_column <= 10 ? 2 : opt.comment_column - 8)
 		    : opt.comment_column;
 	if (opt.continuation_indent == 0)
 		opt.continuation_indent = opt.indent_size;
+}
 static void
 set_initial_indentation(void)
+{
 	inp_read_line();
 	int ind = 0;
 	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 bool
 should_break_line(lexer_symbol lsym)
+{
 	if (lsym == lsym_semicolon)
 		return false;
 	if (ps.prev_lsym == lsym_lbrace || ps.prev_lsym == lsym_semicolon)
 		return true;
 	if (lsym == lsym_lbrace && opt.brace_same_line)
 		return false;
 	return true;
+}
 static void
 move_com_to_code(lexer_symbol lsym)
+{
 	if (ps.want_blank)
 		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
 	    && lsym != lsym_word
 	    && lsym != lsym_lbrace)
 		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 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 bool
 is_function_pointer_declaration(void)
+{
 	return ps.in_decl
 	    && !ps.in_init
 	    && !ps.decl_indent_done
 	    && !ps.line_has_func_def
-	    && ps.line_start_nparen == 0;
+	    && ps.ind_paren_level == 0;
+}
 static int
 process_eof(void)
+{
 	finish_output();
 	if (ps.psyms.top > 1)	/* check for balanced braces */
 		diag(1, "Stuff missing from end of file");
 	return found_err ? EXIT_FAILURE : EXIT_SUCCESS;
+}
 /* move the whole line to the 'label' buffer */
 static void
 read_preprocessing_line(void)
+{
 	enum {
 		PLAIN, STR, CHR, COMM
 	} state = PLAIN;
 	buf_add_char(&lab, '#');
 	while (inp_p[0] != '\n' || (state == COMM && !had_eof)) {
 		buf_add_char(&lab, inp_next());
 		switch (lab.s[lab.len - 1]) {
 		case '\\':
 			if (state != COMM)
 				buf_add_char(&lab, inp_next());
 			break;
 		case '/':
 			if (inp_p[0] == '*' && state == PLAIN) {
 				state = COMM;
 				buf_add_char(&lab, *inp_p++);
+			}
 			break;
 		case '"':
 			if (state == STR)
 				state = PLAIN;
 			else if (state == PLAIN)
 				state = STR;
 			break;
 		case '\'':
 			if (state == CHR)
 				state = PLAIN;
 			else if (state == PLAIN)
 				state = CHR;
 			break;
 		case '*':
 			if (inp_p[0] == '/' && state == COMM) {
 				state = PLAIN;
 				buf_add_char(&lab, *inp_p++);
+			}
 			break;
+		}
+	}
 	while (lab.len > 0 && ch_isblank(lab.s[lab.len - 1]))
 		lab.len--;
 	buf_terminate(&lab);
+}
 static void
 process_preprocessing(void)
+{
 	if (lab.len > 0 || code.len > 0 || com.len > 0)
 		output_line();
 	read_preprocessing_line();
 	const char *dir = lab.s + 1, *line_end = lab.s + lab.len;
 	while (dir < line_end && ch_isblank(*dir))
 		dir++;
 	size_t dir_len = 0;
 	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;
+	}
+}
 static void
 process_newline(void)
+{
 	if (ps.prev_lsym == lsym_comma
 	    && 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:
 	++line_no;
+}
 static bool
 want_blank_before_lparen(void)
+{
 	if (!ps.want_blank)
 		return false;
 	if (opt.proc_calls_space)
 		return true;
 	if (ps.prev_lsym == lsym_rparen || ps.prev_lsym == lsym_rbracket)
 		return false;
 	if (ps.prev_lsym == lsym_offsetof)
 		return false;
 	if (ps.prev_lsym == lsym_sizeof)
 		return opt.blank_after_sizeof;
 	if (ps.prev_lsym == lsym_word || ps.prev_lsym == lsym_funcname)
 		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())
 		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.in_var_decl && ps.psyms.top <= 2 && !ps.in_init) {
 		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.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);
 		goto unbalanced;
+	}
 	enum paren_level_cast cast = ps.paren[--ps.nparen].cast;
 	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;
+		ps.ind_paren_level = ps.nparen;
 unbalanced:
 	buf_add_char(&code, token.s[0]);
 	if (ps.spaced_expr_psym != psym_0 && ps.nparen == 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_blank = true;
 		out.line_kind = lk_stmt_head;
+	}
+}
 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 (code.len > 0
 	    && (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_rbracket(void)
+{
 	if (ps.nparen == 0) {
 		diag(0, "Extra '%c'", *token.s);
 		goto unbalanced;
+	}
 	--ps.nparen;
 	ps.want_blank = true;
 	if (code.len == 0)
-		ps.line_start_nparen = ps.nparen;
+		ps.ind_paren_level = 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.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;
 	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;
+		}
+	}
 	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.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 %zu struct levels",
 			    array_length(ps.di_stack));
 			ps.decl_level--;
+		}
 	} else {
 		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.init_level == 0) {
 		diag(1, "Unbalanced parentheses");
 		ps.nparen = 0;
 		ps.spaced_expr_psym = psym_0;
+	}
 	ps.declaration = decl_no;
 	if (ps.init_level > 0)
 		ps.init_level--;
 	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.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;
+}
 static void
 process_unary_op(void)
+{
 	if (is_function_pointer_declaration()) {
 		int ind = ps.decl_ind - (int)token.len;
 		indent_declarator(ind, ps.tabs_to_var);
 		ps.want_blank = false;
 	} else if ((token.s[0] == '+' || token.s[0] == '-')
 	    && code.len > 0 && code.s[code.len - 1] == token.s[0])
 		ps.want_blank = true;
 	if (ps.want_blank)
 		buf_add_char(&code, ' ');
 	buf_add_buf(&code, &token);
 	ps.want_blank = false;
+}
 static void
 process_postfix_op(void)
+{
 	buf_add_buf(&code, &token);
 	ps.want_blank = true;
+}
 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.line_has_func_def && !ps.in_init &&
-	    !ps.decl_indent_done && ps.line_start_nparen == 0) {
+	    !ps.decl_indent_done && ps.ind_paren_level == 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)
 			>= opt.max_line_length - typical_varname_length))
 			ps.force_nl = 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.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)
+{
 	if (out.line_kind == lk_stmt_head)
 		out.line_kind = lk_other;
 	if (ps.decl_level == 0)
 		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.in_init = false;
 	ps.init_level = 0;
 	ps.declaration = ps.declaration == decl_begin ? decl_end : decl_no;
 	if (ps.in_decl && code.len == 0 && !ps.in_init &&
-	    !ps.decl_indent_done && ps.line_start_nparen == 0) {
+	    !ps.decl_indent_done && ps.ind_paren_level == 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. */
 		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;
+		}
+	}
 	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_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.local_decl_indent	/* local variable */
 	    : opt.decl_indent;	/* global variable, or member */
 	ps.decl_ind = ind > 0 ? ind : len;
 	ps.tabs_to_var = opt.use_tabs && ind > 0;
+}
 static void
 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) {
+		    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.nparen == 0) {
 		ps.force_nl = 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;
 	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;
 	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;
 	case lsym_rparen:	process_rparen();	break;
 	case lsym_rbracket:	process_rbracket();	break;
 	case lsym_lbrace:	process_lbrace();	break;
 	case lsym_rbrace:	process_rbrace();	break;
 	case lsym_period:	process_period();	break;
 	case lsym_unary_op:	process_unary_op();	break;
 	case lsym_postfix_op:	process_postfix_op();	break;
 	case lsym_binary_op:				goto copy_token;
 	case lsym_question:	ps.quest_level++;	goto copy_token;
 	case lsym_question_colon:			goto copy_token;
 	case lsym_label_colon:	process_label_colon();	break;
 	case lsym_other_colon:	process_other_colon();	break;
 	case lsym_comma:	process_comma();	break;
 	case lsym_semicolon:	process_semicolon();	break;
 	case lsym_typedef:				goto copy_token;
 	case lsym_modifier:				goto copy_token;
 	case lsym_case:		ps.seen_case = true;	goto copy_token;
 	case lsym_default:	ps.seen_case = true;	goto copy_token;
 	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_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_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;
+	}
+}
 static int
 indent(void)
+{
 	debug_parser_state();
 	for (;;) {		/* loop until we reach eof */
 		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;
 		if (lsym == lsym_preprocessing || lsym == lsym_newline)
 			ps.force_nl = false;
 		else if (lsym == lsym_comment) {
 			/* no special processing */
 		} else {
 			if (ps.force_nl && should_break_line(lsym)) {
 				ps.force_nl = 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)
 			ps.prev_lsym = lsym;
 		debug_parser_state();
+	}
+}
 int
 main(int argc, char **argv)
+{
 	init_globals();
 	load_profiles(argc, argv);
 	parse_command_line(argc, argv);
 	set_initial_indentation();
 	return indent();
+}

 @@ -1,536 +1,535 @@
-/*	$NetBSD: indent.h,v 1.187 2023/06/10 16:43:56 rillig Exp $	*/
+/*	$NetBSD: indent.h,v 1.188 2023/06/10 21:36:38 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
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 /*-
  * 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
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *	This product includes software developed by the University of
  *	California, Berkeley and its contributors.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 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 <ctype.h>
 #include <stdbool.h>
 #include <stdio.h>
 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_rparen,
 	lsym_lbracket,
 	lsym_rbracket,
 	lsym_lbrace,
 	lsym_rbrace,
 	lsym_period,
 	lsym_unary_op,		/* e.g. '*', '&', '-' or leading '++' */
 	lsym_sizeof,
 	lsym_offsetof,
 	lsym_postfix_op,	/* trailing '++' or '--' */
 	lsym_binary_op,		/* e.g. '*', '&', '<<', '&&' or '/=' */
 	lsym_question,		/* the '?' from a '?:' expression */
 	lsym_question_colon,	/* the ':' from a '?:' expression */
 	lsym_comma,
 	lsym_typedef,
 	lsym_modifier,		/* modifiers for types, functions, variables */
 	lsym_tag,		/* 'struct', 'union' or 'enum' */
 	lsym_type_outside_parentheses,
 	lsym_type_in_parentheses,
 	lsym_word,		/* identifier, constant or string */
 	lsym_funcname,		/* name of a function being defined */
 	lsym_label_colon,	/* the ':' after a label */
 	lsym_other_colon,	/* bit-fields, generic-association (C11),
 				 * enum-type-specifier (C23),
 				 * attribute-prefixed-token (C23),
 				 * pp-prefixed-parameter (C23 6.10) */
 	lsym_semicolon,
 	lsym_case,
 	lsym_default,
 	lsym_do,
 	lsym_else,
 	lsym_for,
 	lsym_if,
 	lsym_switch,
 	lsym_while,
 	lsym_return,
 } lexer_symbol;
 /*
  * Structure of the source code, in terms of declarations, statements and
  * braces; used to determine the indentation level of these parts.
  */
 typedef enum parser_symbol {
 	psym_0,			/* a placeholder; not stored on the stack */
 	psym_lbrace_block,	/* '{' for a block of code */
 	psym_lbrace_struct,	/* '{' in 'struct ... { ... }' */
 	psym_lbrace_union,	/* '{' in 'union ... { ... }' */
 	psym_lbrace_enum,	/* '{' in 'enum ... { ... }' */
 	psym_rbrace,		/* not stored on the stack */
 	psym_decl,
 	psym_stmt,
 	psym_stmt_list,
 	psym_for_exprs,		/* 'for' '(' ... ')' */
 	psym_if_expr,		/* 'if' '(' expr ')' */
 	psym_if_expr_stmt,	/* 'if' '(' expr ')' stmt */
 	psym_if_expr_stmt_else,	/* 'if' '(' expr ')' stmt 'else' */
 	psym_else,		/* 'else'; not stored on the stack */
 	psym_switch_expr,	/* 'switch' '(' expr ')' */
 	psym_do,		/* 'do' */
 	psym_do_stmt,		/* 'do' stmt */
 	psym_while_expr,	/* 'while' '(' expr ')' */
 } parser_symbol;
 /* A range of characters, only null-terminated in debug mode. */
 struct buffer {
 	char *s;
 	size_t len;
 	size_t cap;
 };
 extern FILE *input;
 extern FILE *output;
 /*
  * The current line from the input file, used by the lexer to generate tokens.
  * To read from the line, start at inp_p and continue up to and including the
  * next '\n'. To read beyond the '\n', call inp_skip or inp_next, which will
  * make the next line available, invalidating any pointers into the previous
  * line.
  */
 extern struct buffer inp;
 extern const char *inp_p;
 extern struct buffer token;	/* the current token to be processed, is
 				 * typically copied to the buffer 'code', or in
 				 * some cases to 'lab'. */
 extern struct buffer lab;	/* the label or preprocessor directive */
 extern struct buffer code;	/* the main part of the current line of code,
 				 * containing declarations or statements */
 extern struct buffer com;	/* the trailing comment of the line, or the
 				 * start or end of a multi-line comment, or
 				 * while in process_comment, a single line of a
 				 * multi-line comment */
 extern struct options {
 	bool blank_line_around_conditional_compilation;
 	bool blank_line_after_decl_at_top;	/* this is vaguely similar to
 						 * blank_line_after_decl except
 						 * that it only applies to the
 						 * first set of declarations in
 						 * a procedure (just after the
 						 * first '{') and it causes a
 						 * blank line to be generated
 						 * even if there are no
 						 * declarations */
 	bool blank_line_after_decl;
 	bool blank_line_after_proc;
 	bool blank_line_before_block_comment;
 	bool break_after_comma;	/* whether to add a line break after each
 				 * declarator */
 	bool brace_same_line;	/* whether a brace should be on same line as an
 				 * if, while, etc. */
 	bool blank_after_sizeof;
 	bool comment_delimiter_on_blank_line;
 	int decl_comment_column;	/* the column in which comments after
 					 * declarations should be put */
 	bool cuddle_else;	/* whether 'else' should cuddle up to '}' */
 	int continuation_indent;	/* the indentation between the edge of
 					 * code and continuation lines */
 	float case_indent;	/* the distance (measured in indentation
 				 * levels) to indent case labels from the
 				 * switch statement */
 	int comment_column;	/* the column in which comments to the right of
 				 * code should start */
 	int decl_indent;	/* indentation of identifier in declaration */
 	bool left_justify_decl;
 	int unindent_displace;	/* comments not to the right of code will be
 				 * placed this many indentation levels to the
 				 * left of code */
 	bool extra_expr_indent;	/* whether continuation lines from the
 				 * expression part of "if (e)", "while (e)",
 				 * "for (e; e; e)" should be indented an extra
 				 * tab stop so that they are not confused with
 				 * the code that follows */
 	bool else_if_in_same_line;
 	bool function_brace_split;	/* split function declaration and brace
 					 * onto separate lines */
 	bool format_col1_comments;	/* whether comments that start in
 					 * column 1 are to be reformatted (just
 					 * like comments that begin in later
 					 * columns) */
 	bool format_block_comments;	/* whether to reformat comments that
 					 * begin with '/ * \n' */
 	bool indent_parameters;
 	int indent_size;	/* the size of one indentation level */
 	int block_comment_max_line_length;
 	int local_decl_indent;	/* like decl_indent but for locals */
 	bool lineup_to_parens_always;	/* whether to not(?) attempt to keep
 					 * lined-up code within the margin */
 	bool lineup_to_parens;	/* whether continued code within parens will be
 				 * lined up to the open paren */
 	bool proc_calls_space;	/* whether function calls look like: foo (bar)
 				 * rather than foo(bar) */
 	bool procnames_start_line;	/* whether the names of functions being
 					 * defined get placed in column 1 (i.e.
 					 * a newline is placed between the type
 					 * of the function and its name) */
 	bool space_after_cast;	/* "b = (int) a" vs. "b = (int)a" */
 	bool star_comment_cont;	/* whether comment continuation lines should
 				 * have stars at the beginning of each line */
 	bool swallow_optional_blank_lines;
 	bool auto_typedefs;	/* whether to recognize identifiers ending in
 				 * "_t" like typedefs */
 	int tabsize;		/* the size of a tab */
 	int max_line_length;
 	bool use_tabs;		/* set true to use tabs for spacing, false uses
 				 * all spaces */
 	bool verbose;		/* print configuration to stderr */
 } opt;
 extern bool found_err;
 extern bool had_eof;		/* whether input is exhausted */
 extern int line_no;		/* the current input line number */
 extern enum indent_enabled {
 	indent_on,
 	indent_off,
 	indent_last_off_line,
 } indent_enabled;
 #define	STACKSIZE 256
 /* Properties of each level of parentheses or brackets. */
 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 {
 	int top;		/* pointer to top of stack */
 	parser_symbol sym[STACKSIZE];
 	int ind_level[STACKSIZE];
 };
 /*
  * 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
  * indentation of follow-up lines.
+ *
  * 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 */
 	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 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 '(' */
 	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;
 	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 */
 	bool decl_indent_done;	/* whether the indentation for a declaration
 				 * has been added to the code buffer. */
 	int decl_ind;		/* current indentation for declarations */
 	bool tabs_to_var;	/* true if using tabs to indent to var name */
 	enum {
 		eei_no,
 		eei_maybe,
 		eei_last
 	} extra_expr_indent;
 	struct psym_stack psyms;
 	/* Spacing inside a statement or declaration */
 	bool next_unary;	/* whether the following operator should be
 				 * unary; is used in declarations for '*', as
 				 * well as in expressions */
 	bool want_blank;	/* whether the following token should be
 				 * prefixed by a blank. (Said prefixing is
 				 * ignored in some cases.) */
-	int line_start_nparen;	/* the number of parentheses or brackets that
+	int ind_paren_level;	/* the number of parentheses or brackets that
-				 * were open at the beginning of the current
+				 * is used for indenting a continuation line of
-				 * line; used to indent within statements,
+				 * a declaration, initializer or statement */
 				 * initializers and declarations */
 	int nparen;		/* the number of parentheses or brackets that
 				 * are currently open; used to indent the
 				 * remaining lines of the statement,
 				 * initializer or declaration */
 	struct paren_level paren[20];
 	/* Horizontal spacing for comments */
 	int comment_delta;	/* used to set up indentation for all lines of
 				 * a boxed comment after the first one */
 	int n_comment_delta;	/* remembers how many columns there were before
 				 * the start of a box comment so that
 				 * forthcoming lines of the comment are
 				 * indented properly */
 	int com_ind;		/* indentation of the current comment */
 	/* 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
 				 * new line; used after 'if (expr)' and in
 				 * similar situations; tokens like '{' 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;
 	/* Comments */
 	bool curr_col_1;	/* whether the current token started in column
 				 * 1 of the original input */
 	bool next_col_1;
 } ps;
 extern struct output_state {
 	enum line_kind {
 		lk_other,
 		lk_blank,
 		lk_if,		/* #if, #ifdef, #ifndef */
 		lk_endif,	/* #endif */
 		lk_stmt_head,	/* the ')' of an incomplete statement such as
 				 * 'if (expr)' or 'for (expr; expr; expr)' */
 		lk_func_end,	/* the last '}' of a function body */
 		lk_block_comment,
 		lk_case_or_default,
 	} line_kind;		/* kind of the line that is being prepared for
 				 * output; is reset to lk_other each time after
 				 * trying to send a line to the output, even if
 				 * that line was a suppressed blank line; used
 				 * for inserting or removing blank lines */
 	enum line_kind prev_line_kind;	/* the kind of line that was actually
 					 * sent to the output */
 	struct buffer indent_off_text;	/* text from between 'INDENT OFF' and
 					 * 'INDENT ON', both inclusive */
 } out;
 #define array_length(array) (sizeof(array) / sizeof((array)[0]))
 #ifdef debug
 void debug_printf(const char *, ...) __printflike(1, 2);
 void debug_println(const char *, ...) __printflike(1, 2);
 void debug_blank_line(void);
 void debug_vis_range(const char *, const char *, size_t, const char *);
 void debug_parser_state(void);
 void debug_psyms_stack(const char *);
 void debug_print_buf(const char *, const struct buffer *);
 void debug_buffers(void);
 extern const char *const lsym_name[];
 extern const char *const psym_name[];
 extern const char *const paren_level_cast_name[];
 extern const char *const line_kind_name[];
 #else
 #define debug_noop() do { } while (false)
 #define	debug_printf(fmt, ...) debug_noop()
 #define	debug_println(fmt, ...) debug_noop()
 #define debug_blank_line() debug_noop()
 #define	debug_vis_range(prefix, s, e, suffix) debug_noop()
 #define	debug_parser_state() debug_noop()
 #define	debug_psyms_stack(situation) debug_noop()
 #define debug_print_buf(name, buf) debug_noop()
 #define	debug_buffers() debug_noop()
 #endif
 void register_typename(const char *);
 int compute_code_indent(void);
 int compute_label_indent(void);
 int ind_add(int, const char *, size_t);
 void inp_skip(void);
 char inp_next(void);
 void finish_output(void);
 lexer_symbol lexi(void);
 void diag(int, const char *, ...) __printflike(2, 3);
 void output_line(void);
 void inp_read_line(void);
 void parse(parser_symbol);
 void process_comment(void);
 void set_option(const char *, const char *);
 void load_profile_files(const char *);
 void *nonnull(void *);
 void buf_add_char(struct buffer *, char);
 void buf_add_chars(struct buffer *, const char *, size_t);
 static inline bool
 ch_isalnum(char ch)
+{
 	return isalnum((unsigned char)ch) != 0;
+}
 static inline bool
 ch_isalpha(char ch)
+{
 	return isalpha((unsigned char)ch) != 0;
+}
 static inline bool
 ch_isblank(char ch)
+{
 	return ch == ' ' || ch == '\t';
+}
 static inline bool
 ch_isdigit(char ch)
+{
 	return '0' <= ch && ch <= '9';
+}
 static inline bool
 ch_isspace(char ch)
+{
 	return isspace((unsigned char)ch) != 0;
+}
 static inline int
 next_tab(int ind)
+{
 	return ind - ind % opt.tabsize + opt.tabsize;
+}
 #ifdef debug
 void buf_terminate(struct buffer *);
 #else
 #define buf_terminate(buf) debug_noop()
 #endif
 static inline void
 buf_clear(struct buffer *buf)
+{
 	buf->len = 0;
 	buf_terminate(buf);
+}

 @@ -1,421 +1,421 @@
-/*	$NetBSD: io.c,v 1.216 2023/06/10 16:43:56 rillig Exp $	*/
+/*	$NetBSD: io.c,v 1.217 2023/06/10 21:36:38 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
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *	This product includes software developed by the University of
  *	California, Berkeley and its contributors.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 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.216 2023/06/10 16:43:56 rillig Exp $");
+__RCSID("$NetBSD: io.c,v 1.217 2023/06/10 21:36:38 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 newlines = 2;	/* the total of written and buffered newlines;
 				 * 0 in the middle of a line, 1 after a single
 				 * finished line, anything > 1 are trailing
 				 * blank lines */
 static unsigned buffered_newlines;	/* not yet written */
 static int paren_indent;
 static void
 inp_read_next_line(FILE *f)
+{
 	buf_clear(&inp);
 	for (;;) {
 		int ch = getc(f);
 		if (ch == EOF) {
 			if (indent_enabled == indent_on) {
 				buf_add_char(&inp, ' ');
 				buf_add_char(&inp, '\n');
+			}
 			had_eof = true;
 			break;
+		}
 		if (ch != '\0')
 			buf_add_char(&inp, (char)ch);
 		if (ch == '\n')
 			break;
+	}
 	buf_terminate(&inp);
 	inp_p = inp.s;
+}
 void
 inp_read_line(void)
+{
 	if (indent_enabled == indent_on)
 		buf_clear(&out.indent_off_text);
 	buf_add_chars(&out.indent_off_text, inp.s, inp.len);
 	inp_read_next_line(input);
+}
 void
 inp_skip(void)
+{
 	inp_p++;
 	if ((size_t)(inp_p - inp.s) >= inp.len)
 		inp_read_line();
+}
 char
 inp_next(void)
+{
 	char ch = inp_p[0];
 	inp_skip();
 	return ch;
+}
 static void
 add_buffered_newline(void)
+{
 	buffered_newlines++;
 	newlines++;
 	out_ind = 0;
+}
 static void
 write_buffered_newlines(void)
+{
 	for (; buffered_newlines > 0; buffered_newlines--) {
 		fputc('\n', output);
 		debug_println("write_newline");
+	}
+}
 static void
 write_range(const char *s, size_t len)
+{
 	write_buffered_newlines();
 	fwrite(s, 1, len, output);
 	debug_vis_range("write_range \"", s, len, "\"\n");
 	for (size_t i = 0; i < len; i++)
 		newlines = s[i] == '\n' ? newlines + 1 : 0;
 	out_ind = ind_add(out_ind, s, len);
+}
 static void
 write_indent(int new_ind)
+{
 	write_buffered_newlines();
 	int ind = out_ind;
 	if (opt.use_tabs) {
 		int n = new_ind / opt.tabsize - ind / opt.tabsize;
 		if (n > 0) {
 			ind = ind - ind % opt.tabsize + n * opt.tabsize;
 			while (n-- > 0)
 				fputc('\t', output);
 			newlines = 0;
+		}
+	}
 	for (; ind < new_ind; ind++) {
 		fputc(' ', output);
 		newlines = 0;
+	}
 	debug_println("write_indent %d", ind);
 	out_ind = ind;
+}
 static bool
 want_blank_line(void)
+{
 	debug_println("%s: %s -> %s", __func__,
 	    line_kind_name[out.prev_line_kind], line_kind_name[out.line_kind]);
 	if (ps.blank_line_after_decl && ps.declaration == decl_no) {
 		ps.blank_line_after_decl = false;
 		return true;
+	}
 	if (opt.blank_line_around_conditional_compilation) {
 		if (out.prev_line_kind != lk_if && out.line_kind == lk_if)
 			return true;
 		if (out.prev_line_kind == lk_endif
 		    && out.line_kind != lk_endif)
 			return true;
+	}
 	if (opt.blank_line_after_proc && out.prev_line_kind == lk_func_end
 	    && out.line_kind != lk_endif)
 		return true;
 	if (opt.blank_line_before_block_comment
 	    && out.line_kind == lk_block_comment)
 		return true;
 	return false;
+}
 static bool
 is_blank_line_optional(void)
+{
 	if (out.prev_line_kind == lk_stmt_head)
 		return newlines >= 1;
 	if (ps.psyms.top >= 2)
 		return newlines >= 2;
 	return newlines >= 3;
+}
 static int
 compute_case_label_indent(void)
+{
 	int i = ps.psyms.top;
 	while (i > 0 && ps.psyms.sym[i] != psym_switch_expr)
 		i--;
 	float case_ind = (float)ps.psyms.ind_level[i] + opt.case_indent;
 	return (int)(case_ind * (float)opt.indent_size);
+}
 int
 compute_label_indent(void)
+{
 	if (out.line_kind == lk_case_or_default)
 		return compute_case_label_indent();
 	if (lab.s[0] == '#')
 		return 0;
 	return opt.indent_size * (ps.ind_level - 2);
+}
 static void
 output_line_label(void)
+{
 	write_indent(compute_label_indent());
 	write_range(lab.s, lab.len);
+}
 static int
 compute_lined_up_code_indent(int base_ind)
+{
 	int ind = paren_indent;
 	int overflow = ind_add(ind, code.s, code.len) - opt.max_line_length;
 	if (overflow >= 0
 	    && ind_add(base_ind, code.s, code.len) < opt.max_line_length) {
 		ind -= overflow + 2;
 		if (ind < base_ind)
 			ind = base_ind;
+	}
 	if (ps.extra_expr_indent != eei_no
 	    && ind == base_ind + opt.indent_size)
 		ind += opt.continuation_indent;
 	return ind;
+}
 int
 compute_code_indent(void)
+{
 	int base_ind = ps.ind_level * opt.indent_size;
-	if (ps.line_start_nparen == 0) {
+	if (ps.ind_paren_level == 0) {
 		if (ps.psyms.top >= 1
 		    && ps.psyms.sym[ps.psyms.top - 1] == psym_lbrace_enum)
 			return base_ind;
 		if (ps.in_stmt_cont)
 			return base_ind + opt.continuation_indent;
 		return base_ind;
+	}
 	if (opt.lineup_to_parens) {
 		if (opt.lineup_to_parens_always)
 			return paren_indent;
 		return compute_lined_up_code_indent(base_ind);
+	}
-	int rel_ind = opt.continuation_indent * ps.line_start_nparen;
+	int rel_ind = opt.continuation_indent * ps.ind_paren_level;
 	if (ps.extra_expr_indent != eei_no && rel_ind == opt.indent_size)
 		rel_ind += opt.continuation_indent;
 	return base_ind + rel_ind;
+}
 static void
 output_line_code(void)
+{
 	int target_ind = compute_code_indent();
 	for (int i = 0; i < ps.nparen; i++) {
 		int paren_ind = ps.paren[i].indent;
 		if (paren_ind >= 0) {
 			ps.paren[i].indent = -1 - (paren_ind + target_ind);
 			debug_println(
 			    "setting paren_indents[%d] from %d to %d "
 			    "for column %d",
 			    i, paren_ind, ps.paren[i].indent, target_ind + 1);
+		}
+	}
 	if (lab.len > 0 && target_ind <= out_ind)
 		write_range(" ", 1);
 	write_indent(target_ind);
 	write_range(code.s, code.len);
+}
 static void
 output_comment(void)
+{
 	int target_ind = ps.com_ind + ps.comment_delta;
 	const char *p;
 	/* consider original indentation in case this is a box comment */
 	for (p = com.s; *p == '\t'; p++)
 		target_ind += opt.tabsize;
 	for (; target_ind < 0; p++) {
 		if (*p == ' ')
 			target_ind++;
 		else if (*p == '\t')
 			target_ind = next_tab(target_ind);
 		else {
 			target_ind = 0;
 			break;
+		}
+	}
 	if (out_ind > target_ind)
 		add_buffered_newline();
 	while (com.s + com.len > p && ch_isspace(com.s[com.len - 1]))
 		com.len--;
 	buf_terminate(&com);
 	write_indent(target_ind);
 	write_range(p, com.len - (size_t)(p - com.s));
 	ps.comment_delta = ps.n_comment_delta;
+}
 static void
 output_indented_line(void)
+{
 	if (lab.len == 0 && code.len == 0 && com.len == 0)
 		out.line_kind = lk_blank;
 	if (want_blank_line() && newlines < 2
 	    && out.line_kind != lk_blank)
 		add_buffered_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
 	    && ps.psyms.top > 1) {
 		ps.declaration = decl_no;
 		ps.blank_line_after_decl = true;
+	}
 	if (opt.swallow_optional_blank_lines
 	    && out.line_kind == lk_blank
 	    && is_blank_line_optional())
 		return;
 	if (lab.len > 0)
 		output_line_label();
 	if (code.len > 0)
 		output_line_code();
 	if (com.len > 0)
 		output_comment();
 	add_buffered_newline();
 	if (out.line_kind != lk_blank)
 		write_buffered_newlines();
 	out.prev_line_kind = out.line_kind;
+}
 /*
  * 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();
 	if (indent_enabled == indent_on)
 		output_indented_line();
 	else if (indent_enabled == indent_last_off_line) {
 		indent_enabled = indent_on;
 		write_range(out.indent_off_text.s, out.indent_off_text.len);
 		buf_clear(&out.indent_off_text);
+	}
 	buf_clear(&lab);
 	buf_clear(&code);
 	buf_clear(&com);
 	ps.line_has_decl = ps.in_decl;
 	ps.line_has_func_def = false;
 	ps.in_stmt_cont = ps.in_stmt_or_decl
 	    && (!ps.in_decl || ps.in_init)
 	    && 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.ind_paren_level = 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);
+	}
 	out.line_kind = lk_other;
+}
 void
 finish_output(void)
+{
 	output_line();
 	if (indent_enabled != indent_on) {
 		indent_enabled = indent_last_off_line;
 		output_line();
+	}
 	fflush(output);
+}