 @@ -1,1111 +1,1111 @@
-/*	$NetBSD: indent.c,v 1.341 2023/06/08 21:18:54 rillig Exp $	*/
+/*	$NetBSD: indent.c,v 1.342 2023/06/09 07:20:30 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.341 2023/06/08 21:18:54 rillig Exp $");
+__RCSID("$NetBSD: indent.c,v 1.342 2023/06/09 07:20:30 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 = {
 	.brace_same_line = true,
 	.comment_delimiter_on_blankline = 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;
 enum indent_enabled indent_enabled;
 static int ifdef_level;
 static struct parser_state state_stack[5];
 FILE *input;
 FILE *output;
 static const char *in_name = "Standard Input";
 static const char *out_name = "Standard Output";
 static const char *backup_suffix = ".BAK";
 static char bakfile[MAXPATHLEN] = "";
 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));
+}
 void
 buf_add_char(struct buffer *buf, char ch)
+{
 	if (buf->len == buf->cap)
 		buf_expand(buf, 1);
 	buf->s[buf->len++] = ch;
+}
 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;
+}
 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;
+}
 /*
  * Copy the input file to the backup file, then make the backup file the input
  * and the original input file the output.
  */
 static void
 bakcopy(void)
+{
 	ssize_t n;
 	int bak_fd;
 	char buff[8 * 1024];
 	const char *last_slash = strrchr(in_name, '/');
 	snprintf(bakfile, sizeof(bakfile), "%s%s",
 	    last_slash != NULL ? last_slash + 1 : in_name, backup_suffix);
 	/* copy in_name to backup file */
 	bak_fd = creat(bakfile, 0600);
 	if (bak_fd < 0)
 		err(1, "%s", bakfile);
 	while ((n = read(fileno(input), buff, sizeof(buff))) > 0)
 		if (write(bak_fd, buff, (size_t)n) != n)
 			err(1, "%s", bakfile);
 	if (n < 0)
 		err(1, "%s", in_name);
 	close(bak_fd);
 	(void)fclose(input);
 	/* re-open backup file as the input file */
 	input = fopen(bakfile, "r");
 	if (input == NULL)
 		err(1, "%s", bakfile);
 	/* now the original input file will be the output */
 	output = fopen(in_name, "w");
 	if (output == NULL) {
 		unlink(bakfile);
 		err(1, "%s", in_name);
+	}
+}
 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);
+}
 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) {
 			out_name = arg;
 			if (strcmp(in_name, out_name) == 0)
 				errx(1, "input and output files "
 				    "must be different");
 			if ((output = fopen(out_name, "w")) == NULL)
 				err(1, "%s", out_name);
 		} else
 			errx(1, "too many arguments: %s", arg);
+	}
 	if (input == NULL) {
 		input = stdin;
 		output = stdout;
 	} else if (output == NULL) {
 		out_name = in_name;
 		bakcopy();
+	}
 	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 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 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 int
 process_eof(void)
+{
 	if (lab.len > 0 || code.len > 0 || com.len > 0)
 		output_line();
 	if (indent_enabled != indent_on) {
 		indent_enabled = indent_last_off_line;
 		output_line();
+	}
 	if (ps.psyms.top > 1)	/* check for balanced braces */
 		diag(1, "Stuff missing from end of file");
 	fflush(output);
 	return found_err ? EXIT_FAILURE : EXIT_SUCCESS;
+}
 static void
 maybe_break_line(lexer_symbol lsym)
+{
 	if (!ps.force_nl)
 		return;
 	if (lsym == lsym_semicolon)
 		return;
 	if (lsym == lsym_lbrace && opt.brace_same_line
 	    && ps.prev_lsym != lsym_lbrace)
 		return;
 	output_line();
 	ps.force_nl = false;
+}
 static void
 move_com_to_code(lexer_symbol lsym)
+{
 	if (ps.want_blank)
 		buf_add_char(&code, ' ');
 	buf_add_buf(&code, &com);
 	com.len = 0;
 	ps.want_blank = lsym != lsym_rparen && lsym != lsym_rbracket;
+}
 static void
 process_newline(void)
+{
 	if (ps.prev_lsym == lsym_comma
 	    && ps.nparen == 0 && !ps.block_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
 is_function_pointer_declaration(void)
+{
 	return ps.in_decl
 	    && !ps.block_init
 	    && !ps.decl_indent_done
 	    && !ps.is_function_definition
 	    && ps.line_start_nparen == 0;
+}
 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 && !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;
+	}
 	int indent = ind_add(0, code.s, code.len);
 	if (opt.extra_expr_indent && ps.spaced_expr_psym != psym_0
 	    && ps.nparen == 1 && indent < 2 * opt.indent_size)
 		indent = 2 * opt.indent_size;
 	enum paren_level_cast cast = cast_unknown;
 	if (ps.prev_lsym == lsym_offsetof
 	    || ps.prev_lsym == lsym_sizeof
 	    || ps.prev_lsym == lsym_for
 	    || ps.prev_lsym == lsym_if
 	    || ps.prev_lsym == lsym_switch
 	    || ps.prev_lsym == lsym_while
 	    || ps.is_function_definition)
 		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_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_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.decl_on_line && !ps.block_init)
 		cast = cast_no;
 	if (cast == cast_maybe) {
 		ps.next_unary = true;
 		ps.want_blank = opt.space_after_cast;
 	} else
 		ps.want_blank = true;
 	if (code.len == 0)
 		ps.line_start_nparen = ps.nparen;
 unbalanced:
 	buf_add_char(&code, token.s[0]);
 	if (ps.spaced_expr_psym != psym_0 && ps.nparen == 0) {
 		if (ps.extra_expr_indent == eei_yes)
 			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_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;
 unbalanced:
 	buf_add_char(&code, token.s[0]);
+}
 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])
+	    && 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_question(void)
+{
 	ps.quest_level++;
 	if (code.len == 0) {
 		ps.in_stmt_cont = true;
 		ps.in_stmt_or_decl = true;
 		ps.in_decl = false;
+	}
+}
 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;
+	}
+}
 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;
 	ps.seen_case = false;
 	ps.want_blank = false;
+}
 static void
 process_colon_other(void)
+{
 	buf_add_char(&code, ':');
 	ps.want_blank = false;
+}
 static void
 process_semicolon(void)
+{
 	if (out.line_kind == lk_stmt_head)
 		out.line_kind = lk_other;
 	if (ps.decl_level == 0)
 		ps.init_or_struct = false;
 	ps.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 */
 		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_lbrace(void)
+{
 	parser_symbol psym = ps.psyms.sym[ps.psyms.top];
 	if (ps.prev_lsym == lsym_rparen
 	    && ps.psyms.top >= 2
 	    && !(psym == psym_for_exprs || psym == psym_if_expr
-		    || psym == psym_switch_expr || psym == psym_while_expr)) {
+		|| psym == psym_switch_expr || psym == psym_while_expr)) {
 		ps.block_init = true;
 		ps.init_or_struct = true;
+	}
 	if (out.line_kind == lk_stmt_head)
 		out.line_kind = lk_other;
 	ps.in_stmt_or_decl = false;	/* don't indent the {} */
 	if (!ps.block_init)
 		ps.force_nl = true;
 	else
 		ps.block_init_level++;
 	if (code.len > 0 && !ps.block_init) {
 		if (!opt.brace_same_line ||
 		    (code.len > 0 && code.s[code.len - 1] == '}'))
 			output_line();
 		else if (ps.in_func_def_params && !ps.init_or_struct) {
 			ps.ind_level_follow = 0;
 			if (opt.function_brace_split)
 				output_line();
 			else
 				ps.want_blank = true;
+		}
+	}
 	if (ps.nparen > 0) {
 		diag(1, "Unbalanced parentheses");
 		ps.nparen = 0;
 		if (ps.spaced_expr_psym != psym_0) {
 			parse(ps.spaced_expr_psym);
 			ps.spaced_expr_psym = psym_0;
 			ps.ind_level = ps.ind_level_follow;
+		}
+	}
 	if (code.len == 0)
 		ps.in_stmt_cont = false;	/* don't indent the '{' itself
 						 */
 	if (ps.in_decl && ps.init_or_struct) {
 		ps.di_stack[ps.decl_level] = ps.decl_ind;
 		if (++ps.decl_level == (int)array_length(ps.di_stack)) {
 			diag(0, "Reached internal limit of %d struct levels",
 			    (int)array_length(ps.di_stack));
 			ps.decl_level--;
+		}
 	} else {
 		ps.decl_on_line = 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) {	/* check for unclosed if, for, else. */
 		diag(1, "Unbalanced parentheses");
 		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;	// XXX: Initializers don't end a stmt
 	ps.in_stmt_cont = false;
 	if (ps.decl_level > 0) {	/* multi-level structure declaration */
 		ps.decl_ind = ps.di_stack[--ps.decl_level];
 		if (ps.decl_level == 0 && !ps.in_func_def_params) {
 			ps.declaration = decl_begin;
 			ps.decl_ind = ps.ind_level == 0
 			    ? opt.decl_indent : opt.local_decl_indent;
+		}
 		ps.in_decl = true;
+	}
 	if (ps.psyms.top == 2)
 		out.line_kind = lk_func_end;
 	parse(psym_rbrace);
 	if (!ps.init_or_struct
 	    && 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_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_type(void)
+{
 	parse(psym_decl);	/* let the parser worry about indentation */
 	if (ps.prev_lsym == lsym_rparen && ps.psyms.top <= 1 && code.len > 0)
 		output_line();
 	if (ps.in_func_def_params && opt.indent_parameters &&
 	    ps.decl_level == 0) {
 		ps.ind_level = ps.ind_level_follow = 1;
 		ps.in_stmt_cont = false;
+	}
 	ps.init_or_struct = /* maybe */ true;
 	ps.in_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;
 	int ind = ps.ind_level == 0 || ps.decl_level > 0
 	    ? opt.decl_indent	/* global variable or local member */
 	    : opt.local_decl_indent;	/* local variable */
 	ps.decl_ind = ind > 0 ? ind : len;
 	ps.tabs_to_var = opt.use_tabs && ind > 0;
+}
 static void
 process_ident(lexer_symbol lsym)
+{
 	if (ps.in_decl) {
 		if (lsym == lsym_funcname) {
 			ps.in_decl = false;
 			if (opt.procnames_start_line && code.len > 0)
 				output_line();
 			else if (ps.want_blank)
 				buf_add_char(&code, ' ');
 			ps.want_blank = false;
 		} else if (!ps.block_init && !ps.decl_indent_done &&
 		    ps.line_start_nparen == 0) {
 			if (opt.decl_indent == 0
 			    && code.len > 0 && code.s[code.len - 1] == '}')
 				ps.decl_ind = ind_add(0, code.s, code.len) + 1;
 			indent_declarator(ps.decl_ind, ps.tabs_to_var);
 			ps.want_blank = false;
+		}
 	} else if (ps.spaced_expr_psym != psym_0 && ps.nparen == 0) {
 		ps.force_nl = true;
 		ps.next_unary = true;
 		ps.in_stmt_or_decl = false;
 		parse(ps.spaced_expr_psym);
 		ps.spaced_expr_psym = psym_0;
+	}
+}
 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_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 */
 		indent_declarator(ps.decl_ind - 1, ps.tabs_to_var);
+	}
 	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)
+			ind_add(compute_code_indent(), code.s, code.len)
-		    >= opt.max_line_length - typical_varname_length))
+			>= opt.max_line_length - typical_varname_length))
 			ps.force_nl = true;
+	}
+}
 /* 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--;
+}
 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_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:	process_question();	goto copy_token;
 	case lsym_colon_question: process_colon_question(); goto copy_token;
 	case lsym_colon_label:	process_colon_label();	break;
 	case lsym_colon_other:	process_colon_other();	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();
 		goto copy_token;
 	case lsym_type_in_parentheses:
 	case lsym_sizeof:
 	case lsym_offsetof:
 	case lsym_word:
 	case lsym_funcname:
 	case lsym_return:
 		process_ident(lsym);
 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_newline || lsym == lsym_preprocessing)
 			ps.force_nl = false;
 		else if (lsym == lsym_comment) {
 			/* no special processing */
 		} else {
 			maybe_break_line(lsym);
 			ps.in_stmt_or_decl = true;
 			if (com.len > 0)
 				move_com_to_code(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
 main(int argc, char **argv)
+{
 	init_globals();
 	load_profiles(argc, argv);
 	parse_command_line(argc, argv);
 	set_initial_indentation();
 	return indent();
+}

 @@ -1,390 +1,390 @@
-/*	$NetBSD: io.c,v 1.205 2023/06/09 06:36:57 rillig Exp $	*/
+/*	$NetBSD: io.c,v 1.206 2023/06/09 07:20:30 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.205 2023/06/09 06:36:57 rillig Exp $");
+__RCSID("$NetBSD: io.c,v 1.206 2023/06/09 07:20:30 rillig Exp $");
 #include <stdio.h>
 #include "indent.h"
 struct buffer inp;
 const char *inp_p;
 struct output_state out;
 static int out_ind;		/* width of the line that is being written */
 static unsigned wrote_newlines = 2;	/* 0 in the middle of a line, 1 after a
 					 * single '\n', > 1 means there were (n
 					 * - 1) blank lines above */
 static int paren_indent;
 static void
 inp_read_next_line(FILE *f)
+{
 	inp.len = 0;
 	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;
+	}
 	inp_p = inp.s;
+}
 void
 inp_read_line(void)
+{
 	if (indent_enabled == indent_on)
 		out.indent_off_text.len = 0;
 	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
 output_newline(void)
+{
 	fputc('\n', output);
 	debug_println("output_newline");
 	wrote_newlines++;
 	out_ind = 0;
+}
 static void
 output_range(const char *s, size_t len)
+{
 	fwrite(s, 1, len, output);
 	debug_vis_range("output_range \"", s, len, "\"\n");
 	for (size_t i = 0; i < len; i++)
 		wrote_newlines = s[i] == '\n' ? wrote_newlines + 1 : 0;
 	out_ind = ind_add(out_ind, s, len);
+}
 static void
 output_indent(int new_ind)
+{
 	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);
 			wrote_newlines = 0;
+		}
+	}
 	for (; ind < new_ind; ind++) {
 		fputc(' ', output);
 		wrote_newlines = 0;
+	}
 	debug_println("output_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.blanklines_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.blanklines_after_procs && out.prev_line_kind == lk_func_end
 	    && out.line_kind != lk_endif)
 		return true;
 	if (opt.blanklines_before_block_comments
 	    && 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 wrote_newlines >= 1;
 	if (ps.psyms.top >= 2)
 		return wrote_newlines >= 2;
 	return wrote_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)
+{
 	output_indent(compute_label_indent());
 	output_range(lab.s, lab.len);
+}
 static int
 compute_code_indent_lineup(int base_ind)
+{
 	int ind = paren_indent;
 	int overflow = ind_add(ind, code.s, code.len) - opt.max_line_length;
 	if (overflow < 0)
 		return ind;
 	if (ind_add(base_ind, code.s, code.len) < opt.max_line_length) {
 		ind -= overflow + 2;
 		if (ind > base_ind)
 			return ind;
 		return base_ind;
+	}
 	return ind;
+}
 int
 compute_code_indent(void)
+{
 	int base_ind = ps.ind_level * opt.indent_size;
 	if (ps.line_start_nparen == 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_code_indent_lineup(base_ind);
+	}
 	if (ps.extra_expr_indent != eei_no)
 		return base_ind + 2 * opt.continuation_indent;
 	return base_ind + opt.continuation_indent * ps.line_start_nparen;
+}
 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)
 		output_range(" ", 1);
 	output_indent(target_ind);
 	output_range(code.s, code.len);
+}
 static void
 output_line_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)
 		output_newline();
 	while (com.s + com.len > p && ch_isspace(com.s[com.len - 1]))
 		com.len--;
 	output_indent(target_ind);
 	output_range(p, com.len - (size_t)(p - com.s));
 	ps.comment_delta = ps.n_comment_delta;
+}
 /*
  * Write a line of formatted source to the output file. The line consists of
  * the label, the code and the comment.
  */
 void
 output_line(void)
+{
 	debug_blank_line();
 	debug_printf("%s", __func__);
 	debug_buffers();
 	ps.is_function_definition = false;
 	if (indent_enabled == indent_on) {
 		if (lab.len == 0 && code.len == 0 && com.len == 0)
 			out.line_kind = lk_blank;
 		if (want_blank_line() && wrote_newlines < 2
 		    && out.line_kind != lk_blank)
 			output_newline();
 		/* This kludge aligns function definitions correctly. */
 		if (ps.ind_level == 0)
 			ps.in_stmt_cont = false;
 		if (opt.blank_line_after_decl && ps.declaration == decl_end
 		    && ps.psyms.top > 1) {
 			ps.declaration = decl_no;
 			ps.blank_line_after_decl = true;
+		}
 		if (opt.swallow_optional_blanklines
 		    && out.line_kind == lk_blank
 		    && is_blank_line_optional())
 			goto prepare_next_line;
 		if (lab.len > 0)
 			output_line_label();
 		if (code.len > 0)
 			output_line_code();
 		if (com.len > 0)
 			output_line_comment();
 		output_newline();
 		out.prev_line_kind = out.line_kind;
+	}
 	if (indent_enabled == indent_last_off_line) {
 		indent_enabled = indent_on;
 		output_range(out.indent_off_text.s, out.indent_off_text.len);
 		out.indent_off_text.len = 0;
+	}
 prepare_next_line:
 	lab.len = 0;
 	code.len = 0;
 	com.len = 0;
 	ps.decl_on_line = ps.in_decl;
 	// XXX: don't reset in_stmt_cont here; see process_colon_question.
 	ps.in_stmt_cont = ps.in_stmt_or_decl
 	    && !ps.in_decl && ps.block_init_level == 0;
 	ps.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.nparen > 0))
 		ps.ind_level = ps.ind_level_follow;
 	ps.line_start_nparen = ps.nparen;
 	ps.want_blank = false;
 	if (ps.nparen > 0) {
 		/* TODO: explain what negative indentation means */
 		paren_indent = -1 - ps.paren[ps.nparen - 1].indent;
 		debug_println("paren_indent is now %d", paren_indent);
+	}
 	out.line_kind = lk_other;
+}

 @@ -1,703 +1,703 @@
-/*	$NetBSD: lexi.c,v 1.217 2023/06/08 21:18:54 rillig Exp $	*/
+/*	$NetBSD: lexi.c,v 1.218 2023/06/09 07:20:30 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: lexi.c,v 1.217 2023/06/08 21:18:54 rillig Exp $");
+__RCSID("$NetBSD: lexi.c,v 1.218 2023/06/09 07:20:30 rillig Exp $");
 #include <stdlib.h>
 #include <string.h>
 #include "indent.h"
 /* In lexi_alnum, this constant marks a type, independent of parentheses. */
 #define lsym_type lsym_type_outside_parentheses
 /* must be sorted alphabetically, is used in binary search */
 static const struct keyword {
 	const char name[12];
 	lexer_symbol lsym;
 } keywords[] = {
 	{"_Bool", lsym_type},
 	{"_Complex", lsym_type},
 	{"_Imaginary", lsym_type},
 	{"auto", lsym_modifier},
 	{"bool", lsym_type},
 	{"break", lsym_word},
 	{"case", lsym_case},
 	{"char", lsym_type},
 	{"complex", lsym_type},
 	{"const", lsym_modifier},
 	{"continue", lsym_word},
 	{"default", lsym_default},
 	{"do", lsym_do},
 	{"double", lsym_type},
 	{"else", lsym_else},
 	{"enum", lsym_tag},
 	{"extern", lsym_modifier},
 	{"float", lsym_type},
 	{"for", lsym_for},
 	{"goto", lsym_word},
 	{"if", lsym_if},
 	{"imaginary", lsym_type},
 	{"inline", lsym_modifier},
 	{"int", lsym_type},
 	{"long", lsym_type},
 	{"offsetof", lsym_offsetof},
 	{"register", lsym_modifier},
 	{"restrict", lsym_word},
 	{"return", lsym_return},
 	{"short", lsym_type},
 	{"signed", lsym_type},
 	{"sizeof", lsym_sizeof},
 	{"static", lsym_modifier},
 	{"struct", lsym_tag},
 	{"switch", lsym_switch},
 	{"typedef", lsym_typedef},
 	{"union", lsym_tag},
 	{"unsigned", lsym_type},
 	{"void", lsym_type},
 	{"volatile", lsym_modifier},
 	{"while", lsym_while}
 };
 static struct {
 	const char **items;
 	unsigned int len;
 	unsigned int cap;
 } typenames;
 /*-
  * The transition table below was rewritten by hand from lx's output, given
  * the following definitions. lx is Katherine Flavel's lexer generator.
+ *
  * O  = /[0-7]/;        D  = /[0-9]/;          NZ = /[1-9]/;
  * H  = /[a-f0-9]/i;    B  = /[0-1]/;          HP = /0x/i;
  * BP = /0b/i;          E  = /e[+\-]?/i D+;    P  = /p[+\-]?/i D+;
  * FS = /[fl]/i;        IS = /u/i /(l|L|ll|LL)/? | /(l|L|ll|LL)/ /u/i?;
+ *
  * D+           E  FS? -> $float;
  * D*    "." D+ E? FS? -> $float;
  * D+    "."    E? FS? -> $float;    HP H+           IS? -> $int;
  * HP H+        P  FS? -> $float;    NZ D*           IS? -> $int;
  * HP H* "." H+ P  FS? -> $float;    "0" O*          IS? -> $int;
  * HP H+ "."    P  FS  -> $float;    BP B+           IS? -> $int;
  */
 /* INDENT OFF */
 static const unsigned char lex_number_state[][26] = {
 	/*                examples:
 	         s                      0xx
 	         t                    00xaa
 	         a     11       101100xxa..
 	         r   11ee0001101lbuuxx.a.pp
 	         t.01.e+008bLuxll0Ll.aa.p+0
 	states:  ABCDEFGHIJKLMNOPQRSTUVWXYZ */
 	[0] =   "uuiifuufiuuiiuiiiiiuiuuuuu",	/* (other) */
 	[1] =   "CEIDEHHHIJQ  U  Q  VUVVZZZ",	/* 0 */
 	[2] =   "DEIDEHHHIJQ  U  Q  VUVVZZZ",	/* 1 */
 	[3] =   "DEIDEHHHIJ   U     VUVVZZZ",	/* 2 3 4 5 6 7 */
 	[4] =   "DEJDEHHHJJ   U     VUVVZZZ",	/* 8 9 */
 	[5] =   "             U     VUVV   ",	/* A a C c D d */
 	[6] =   "  K          U     VUVV   ",	/* B b */
 	[7] =   "  FFF   FF   U     VUVV   ",	/* E e */
 	[8] =   "    f  f     U     VUVV  f",	/* F f */
 	[9] =   "  LLf  fL  PR   Li  L    f",	/* L */
 	[10] =  "  OOf  fO   S P O i O    f",	/* l */
 	[11] =  "                    FFX   ",	/* P p */
 	[12] =  "  MM    M  i  iiM   M     ",	/* U u */
 	[13] =  "  N                       ",	/* X x */
 	[14] =  "     G                 Y  ",	/* + - */
 	[15] =  "B EE    EE   T      W     ",	/* . */
 	/*       ABCDEFGHIJKLMNOPQRSTUVWXYZ */
 };
 /* INDENT ON */
 static const unsigned char lex_number_row[] = {
 	['0'] = 1,
 	['1'] = 2,
 	['2'] = 3, ['3'] = 3, ['4'] = 3, ['5'] = 3, ['6'] = 3, ['7'] = 3,
 	['8'] = 4, ['9'] = 4,
 	['A'] = 5, ['a'] = 5, ['C'] = 5, ['c'] = 5, ['D'] = 5, ['d'] = 5,
 	['B'] = 6, ['b'] = 6,
 	['E'] = 7, ['e'] = 7,
 	['F'] = 8, ['f'] = 8,
 	['L'] = 9,
 	['l'] = 10,
 	['P'] = 11, ['p'] = 11,
 	['U'] = 12, ['u'] = 12,
 	['X'] = 13, ['x'] = 13,
 	['+'] = 14, ['-'] = 14,
 	['.'] = 15,
 };
 static void
 token_add_char(char ch)
+{
 	buf_add_char(&token, ch);
+}
 static void
 lex_number(void)
+{
 	for (unsigned char s = 'A'; s != 'f' && s != 'i' && s != 'u';) {
 		unsigned char ch = (unsigned char)inp_p[0];
 		if (ch == '\\' && inp_p[1] == '\n') {
 			inp_p++;
 			inp_skip();
 			line_no++;
 			continue;
+		}
 		if (ch >= array_length(lex_number_row)
 		    || lex_number_row[ch] == 0)
 			break;
 		unsigned char row = lex_number_row[ch];
 		if (lex_number_state[row][s - 'A'] == ' ') {
 			/*-
 		         * lex_number_state[0][s - 'A'] now indicates the type:
 		         * f = floating, i = integer, u = unknown
 		         */
 			return;
+		}
 		s = lex_number_state[row][s - 'A'];
 		token_add_char(inp_next());
+	}
+}
 static bool
 is_identifier_start(char ch)
+{
 	return ch_isalpha(ch) || ch == '_' || ch == '$';
+}
 static bool
 is_identifier_part(char ch)
+{
 	return ch_isalnum(ch) || ch == '_' || ch == '$';
+}
 static void
 lex_word(void)
+{
 	for (;;) {
 		if (is_identifier_part(inp_p[0]))
 			token_add_char(*inp_p++);
 		else if (inp_p[0] == '\\' && inp_p[1] == '\n') {
 			inp_p++;
 			inp_skip();
 			line_no++;
 		} else
 			return;
+	}
+}
 static void
 lex_char_or_string(void)
+{
 	for (char delim = token.s[token.len - 1];;) {
 		if (inp_p[0] == '\n') {
 			diag(1, "Unterminated literal");
 			return;
+		}
 		token_add_char(*inp_p++);
 		if (token.s[token.len - 1] == delim)
 			return;
 		if (token.s[token.len - 1] == '\\') {
 			if (inp_p[0] == '\n')
 				++line_no;
 			token_add_char(inp_next());
+		}
+	}
+}
 /* Guess whether the current token is a declared type. */
 static bool
 probably_typename(void)
+{
 	if (ps.prev_lsym == lsym_modifier)
 		return true;
 	if (ps.block_init)
 		return false;
 	if (ps.in_stmt_or_decl)	/* XXX: this condition looks incorrect */
 		return false;
 	if (inp_p[0] == '*' && inp_p[1] != '=')
 		goto maybe;
 	/* XXX: is_identifier_start */
 	if (ch_isalpha(inp_p[0]))
 		goto maybe;
 	return false;
 maybe:
 	return ps.prev_lsym == lsym_semicolon ||
 	    ps.prev_lsym == lsym_lbrace ||
 	    ps.prev_lsym == lsym_rbrace;
+}
 static int
 bsearch_typenames(const char *key)
+{
 	const char **arr = typenames.items;
 	int lo = 0;
 	int hi = (int)typenames.len - 1;
 	while (lo <= hi) {
 		int mid = (int)((unsigned)(lo + hi) >> 1);
 		int cmp = strcmp(arr[mid], key);
 		if (cmp < 0)
 			lo = mid + 1;
 		else if (cmp > 0)
 			hi = mid - 1;
 		else
 			return mid;
+	}
 	return -(lo + 1);
+}
 static bool
 is_typename(void)
+{
 	if (opt.auto_typedefs &&
 	    token.len >= 2 && memcmp(token.s + token.len - 2, "_t", 2) == 0)
 		return true;
 	return bsearch_typenames(token.s) >= 0;
+}
 static int
 cmp_keyword_by_name(const void *key, const void *elem)
+{
 	return strcmp(key, ((const struct keyword *)elem)->name);
+}
 /*
  * Looking at something like 'function_name(...)' in a line, guess whether
  * this starts a function definition or a declaration.
  */
 static bool
 probably_looking_at_definition(void)
+{
 	int paren_level = 0;
 	for (const char *p = inp_p; *p != '\n'; p++) {
 		if (*p == '(')
 			paren_level++;
 		if (*p == ')' && --paren_level == 0) {
 			p++;
 			while (*p != '\n'
 			    && (ch_isspace(*p) || is_identifier_part(*p)))
 				p++;	/* '__dead' or '__unused' */
 			if (*p == '\n')	/* func(...) */
 				break;
 			if (*p == ';')	/* func(...); */
 				return false;
 			if (*p == ',')	/* double abs(), pi; */
 				return false;
 			if (*p == '(')	/* func(...) __attribute__((...)) */
 				paren_level++;	/* func(...) __printflike(...)
 						 */
 			else
 				break;	/* func(...) { ... */
+		}
+	}
 	/* To further reduce the cases where indent wrongly treats an
 	 * incomplete function declaration as a function definition, thus
 	 * adding a newline before the function name, it may be worth looking
 	 * for parameter names, as these are often omitted in function
 	 * declarations and only included in function definitions. Or just
 	 * increase the lookahead to more than just the current line of input,
 	 * until the next '{'. */
 	return true;
+}
 /* Read an alphanumeric token into 'token', or return lsym_eof. */
 static lexer_symbol
 lexi_alnum(void)
+{
 	if (ch_isdigit(inp_p[0]) ||
 	    (inp_p[0] == '.' && ch_isdigit(inp_p[1]))) {
 		lex_number();
 	} else if (is_identifier_start(inp_p[0])) {
 		lex_word();
 		if (token.len == 1 && token.s[0] == 'L' &&
 		    (inp_p[0] == '"' || inp_p[0] == '\'')) {
 			token_add_char(*inp_p++);
 			lex_char_or_string();
 			ps.next_unary = false;
 			return lsym_word;
+		}
 	} else
 		return lsym_eof;	/* just as a placeholder */
 	while (ch_isblank(inp_p[0]))
 		inp_p++;
 	ps.next_unary = ps.prev_lsym == lsym_tag
 	    || ps.prev_lsym == lsym_typedef;
 	if (ps.prev_lsym == lsym_tag && ps.nparen == 0)
 		return lsym_type_outside_parentheses;
 	token_add_char('\0');
 	token.len--;
 	const struct keyword *kw = bsearch(token.s, keywords,
 	    array_length(keywords), sizeof(keywords[0]), cmp_keyword_by_name);
 	lexer_symbol lsym = lsym_word;
 	if (kw != NULL) {
 		if (kw->lsym == lsym_type)
 			lsym = lsym_type_in_parentheses;
 		ps.next_unary = true;
 		if (kw->lsym == lsym_tag || kw->lsym == lsym_type)
 			goto found_typename;
 		return kw->lsym;
+	}
 	if (is_typename()) {
 		lsym = lsym_type_in_parentheses;
 		ps.next_unary = true;
 found_typename:
 		if (ps.nparen > 0) {
 			/* inside parentheses: cast, param list, offsetof or
 			 * sizeof */
 			if (ps.paren[ps.nparen - 1].cast == cast_unknown)
 				ps.paren[ps.nparen - 1].cast = cast_maybe;
+		}
 		if (ps.prev_lsym != lsym_period
 		    && ps.prev_lsym != lsym_unary_op) {
 			if (kw != NULL && kw->lsym == lsym_tag)
 				return lsym_tag;
 			if (ps.nparen == 0)
 				return lsym_type_outside_parentheses;
+		}
+	}
 	if (inp_p[0] == '(' && ps.psyms.top <= 1 && ps.ind_level == 0 &&
 	    !ps.in_func_def_params && !ps.block_init) {
 		if (ps.nparen == 0 && probably_looking_at_definition()) {
 			ps.is_function_definition = true;
 			if (ps.in_decl)
 				ps.in_func_def_params = true;
 			return lsym_funcname;
+		}
 	} else if (ps.nparen == 0 && probably_typename()) {
 		ps.next_unary = true;
 		return lsym_type_outside_parentheses;
+	}
 	return lsym;
+}
 static bool
 is_asterisk_unary(void)
+{
 	if (inp_p[strspn(inp_p, "* \t")] == ')')
 		return true;
 	if (ps.next_unary || ps.in_func_def_params)
 		return true;
 	if (ps.prev_lsym == lsym_word ||
 	    ps.prev_lsym == lsym_rparen ||
 	    ps.prev_lsym == lsym_rbracket)
 		return false;
 	return ps.in_decl && ps.nparen > 0;
+}
 static bool
 probably_in_function_definition(void)
+{
 	for (const char *tp = inp_p; *tp != '\n';) {
 		if (ch_isspace(*tp))
 			tp++;
 		else if (is_identifier_start(*tp)) {
 			tp++;
 			while (is_identifier_part(*tp))
 				tp++;
 		} else
 			return *tp == '(';
+	}
 	return false;
+}
 static void
 lex_asterisk_unary(void)
+{
 	while (inp_p[0] == '*' || ch_isspace(inp_p[0])) {
 		if (inp_p[0] == '*')
 			token_add_char('*');
 		inp_skip();
+	}
 	if (ps.in_decl && probably_in_function_definition())
 		ps.is_function_definition = true;
+}
 static void
 skip_blank(const char **pp)
+{
 	while (ch_isblank(**pp))
 		(*pp)++;
+}
 static bool
 skip_string(const char **pp, const char *s)
+{
 	size_t len = strlen(s);
 	if (strncmp(*pp, s, len) == 0) {
 		*pp += len;
 		return true;
+	}
 	return false;
+}
 static void
 lex_indent_comment(void)
+{
 	const char *p = inp.s;
 	skip_blank(&p);
 	if (!skip_string(&p, "/*"))
 		return;
 	skip_blank(&p);
 	if (!skip_string(&p, "INDENT"))
 		return;
 	enum indent_enabled enabled;
 	skip_blank(&p);
 	if (*p == '*' || skip_string(&p, "ON"))
 		enabled = indent_last_off_line;
 	else if (skip_string(&p, "OFF"))
 		enabled = indent_off;
 	else
 		return;
 	skip_blank(&p);
 	if (!skip_string(&p, "*/\n"))
 		return;
 	if (lab.len > 0 || code.len > 0 || com.len > 0)
 		output_line();
 	indent_enabled = enabled;
+}
 /* Reads the next token, placing it in the global variable "token". */
 lexer_symbol
 lexi(void)
+{
 	token.len = 0;
 	ps.curr_col_1 = ps.next_col_1;
 	ps.next_col_1 = false;
 	for (;;) {
 		if (ch_isblank(inp_p[0])) {
 			ps.curr_col_1 = false;
 			inp_p++;
 		} else if (inp_p[0] == '\\' && inp_p[1] == '\n') {
 			inp_p++;
 			inp_skip();
 			line_no++;
 		} else
 			break;
+	}
 	lexer_symbol alnum_lsym = lexi_alnum();
 	if (alnum_lsym != lsym_eof)
 		return alnum_lsym;
 	/* Scan a non-alphanumeric token */
 	token_add_char(inp_next());
 	lexer_symbol lsym;
 	bool next_unary;
 	switch (token.s[token.len - 1]) {
 	/* INDENT OFF */
 	case '(':	lsym = lsym_lparen;	next_unary = true;	break;
 	case '[':	lsym = lsym_lbracket;	next_unary = true;	break;
 	case ')':	lsym = lsym_rparen;	next_unary = false;	break;
 	case ']':	lsym = lsym_rbracket;	next_unary = false;	break;
 	case '?':	lsym = lsym_question;	next_unary = true;	break;
 	case ';':	lsym = lsym_semicolon;	next_unary = true;	break;
 	case '{':	lsym = lsym_lbrace;	next_unary = true;	break;
 	case '}':	lsym = lsym_rbrace;	next_unary = true;	break;
 	case ',':	lsym = lsym_comma;	next_unary = true;	break;
 	case '.':	lsym = lsym_period;	next_unary = false;	break;
 	/* INDENT ON */
 	case ':':
 		lsym = ps.quest_level > 0
 		    ? (ps.quest_level--, lsym_colon_question)
 		    : ps.init_or_struct
 		    ? lsym_colon_other
 		    : lsym_colon_label;
 		next_unary = true;
 		break;
 	case '\n':
 		/* if data has been exhausted, the '\n' is a dummy. */
 		lsym = had_eof ? lsym_eof : lsym_newline;
 		next_unary = ps.next_unary;
 		ps.next_col_1 = true;
 		break;
 	case '#':
 		lsym = lsym_preprocessing;
 		next_unary = ps.next_unary;
 		break;
 	case '\'':
 	case '"':
 		lex_char_or_string();
 		lsym = lsym_word;
 		next_unary = false;
 		break;
 	case '-':
 	case '+':
 		lsym = ps.next_unary ? lsym_unary_op : lsym_binary_op;
 		next_unary = true;
 		/* '++' or '--' */
 		if (inp_p[0] == token.s[token.len - 1]) {
 			token_add_char(*inp_p++);
 			if (ps.prev_lsym == lsym_word ||
 			    ps.prev_lsym == lsym_rparen ||
 			    ps.prev_lsym == lsym_rbracket) {
 				lsym = ps.next_unary
 				    ? lsym_unary_op : lsym_postfix_op;
 				next_unary = false;
+			}
 		} else if (inp_p[0] == '=') {	/* '+=' or '-=' */
 			token_add_char(*inp_p++);
 		} else if (inp_p[0] == '>') {	/* '->' */
 			token_add_char(*inp_p++);
 			lsym = lsym_unary_op;
 			next_unary = false;
 			ps.want_blank = false;
+		}
 		break;
 	case '=':
 		if (ps.init_or_struct)
 			ps.block_init = true;
 		if (inp_p[0] == '=')
 			token_add_char(*inp_p++);
 		lsym = lsym_binary_op;
 		next_unary = true;
 		break;
 	case '>':
 	case '<':
 	case '!':		/* ops like <, <<, <=, !=, etc */
 		if (inp_p[0] == '>' || inp_p[0] == '<' || inp_p[0] == '=')
 			token_add_char(*inp_p++);
 		if (inp_p[0] == '=')
 			token_add_char(*inp_p++);
 		lsym = ps.next_unary ? lsym_unary_op : lsym_binary_op;
 		next_unary = true;
 		break;
 	case '*':
 		if (inp_p[0] == '=') {
 			token_add_char(*inp_p++);
 			lsym = lsym_binary_op;
 		} else if (is_asterisk_unary()) {
 			lex_asterisk_unary();
 			lsym = lsym_unary_op;
 		} else
 			lsym = lsym_binary_op;
 		next_unary = true;
 		break;
 	default:
 		if (token.s[token.len - 1] == '/'
 		    && (inp_p[0] == '*' || inp_p[0] == '/')) {
 			enum indent_enabled prev = indent_enabled;
 			lex_indent_comment();
 			if (prev == indent_on && indent_enabled == indent_off)
 				out.indent_off_text.len = 0;
 			token_add_char(*inp_p++);
 			lsym = lsym_comment;
 			next_unary = ps.next_unary;
 			break;
+		}
 		/* things like '||', '&&', '<<=' */
 		lsym = ps.next_unary ? lsym_unary_op : lsym_binary_op;
 		if (inp_p[0] == token.s[token.len - 1])
 			token_add_char(*inp_p++), lsym = lsym_binary_op;
 		if (inp_p[0] == '=')
 			token_add_char(*inp_p++), lsym = lsym_binary_op;
 		next_unary = true;
+	}
 	ps.next_unary = next_unary;
 	return lsym;
+}
 void
 register_typename(const char *name)
+{
 	if (typenames.len >= typenames.cap) {
 		typenames.cap = 16 + 2 * typenames.cap;
 		typenames.items = nonnull(realloc(typenames.items,
-		    sizeof(typenames.items[0]) * typenames.cap));
+			sizeof(typenames.items[0]) * typenames.cap));
+	}
 	int pos = bsearch_typenames(name);
 	if (pos >= 0)
 		return;		/* already in the list */
 	pos = -(pos + 1);
 	memmove(typenames.items + pos + 1, typenames.items + pos,
 	    sizeof(typenames.items[0]) * (typenames.len++ - (unsigned)pos));
 	typenames.items[pos] = nonnull(strdup(name));
+}

 @@ -1,269 +1,269 @@
-/*	$NetBSD: parse.c,v 1.69 2023/06/07 15:46:12 rillig Exp $	*/
+/*	$NetBSD: parse.c,v 1.70 2023/06/09 07:20:30 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: parse.c,v 1.69 2023/06/07 15:46:12 rillig Exp $");
+__RCSID("$NetBSD: parse.c,v 1.70 2023/06/09 07:20:30 rillig Exp $");
 #include <err.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)
+{
 	switch (psyms->sym[psyms->top - 1]) {
 	case psym_stmt:
 	case psym_stmt_list:
 		psyms->sym[--psyms->top] = psym_stmt_list;
 		return true;
 	case psym_do:
 		psyms->sym[--psyms->top] = psym_do_stmt;
 		ps.ind_level_follow = psyms->ind_level[psyms->top];
 		return true;
 	case psym_if_expr:
 		psyms->sym[--psyms->top] = psym_if_expr_stmt;
 		int i = psyms->top - 1;
 		while (psyms->sym[i] != psym_stmt &&
 		    psyms->sym[i] != psym_stmt_list &&
 		    psyms->sym[i] != psym_lbrace_block)
 			--i;
 		ps.ind_level_follow = psyms->ind_level[i];
 		/* For the time being, assume that there is no 'else' on this
 		 * 'if', and set the indentation level accordingly. If an
 		 * 'else' is scanned, it will be fixed up later. */
 		return true;
 	case psym_switch_expr:
 	case psym_decl:
 	case psym_if_expr_stmt_else:
 	case psym_for_exprs:
 	case psym_while_expr:
 		psyms->sym[--psyms->top] = psym_stmt;
 		ps.ind_level_follow = psyms->ind_level[psyms->top];
 		return true;
 	default:
 		return false;
+	}
+}
 static int
 decl_level(void)
+{
 	int level = 0;
 	for (int i = ps.psyms.top - 1; i > 0; i--)
 		if (ps.psyms.sym[i] == psym_decl)
 			level++;
 	return level;
+}
 static void
 ps_push(parser_symbol psym)
+{
 	ps.psyms.sym[++ps.psyms.top] = psym;
 	ps.psyms.ind_level[ps.psyms.top] = ps.ind_level;
+}
 static void
 ps_push_follow(parser_symbol psym)
+{
 	ps.psyms.sym[++ps.psyms.top] = psym;
 	ps.psyms.ind_level[ps.psyms.top] = ps.ind_level_follow;
+}
 /*
  * 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)
+{
 again:
 	if (psyms->sym[psyms->top] == psym_stmt && psyms_reduce_stmt(psyms))
 		goto again;
 	if (psyms->sym[psyms->top] == psym_while_expr &&
 	    psyms->sym[psyms->top - 1] == psym_do_stmt) {
 		psyms->top -= 2;
 		goto again;
+	}
+}
 static bool
 is_lbrace(parser_symbol psym)
+{
 	return psym == psym_lbrace_block
 	    || psym == psym_lbrace_struct
 	    || psym == psym_lbrace_union
 	    || psym == psym_lbrace_enum;
+}
 /*
  * Shift the token onto the parser stack, or 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->top] == psym_if_expr_stmt) {
 			psyms->sym[psyms->top] = psym_stmt;
 			psyms_reduce(&ps.psyms);
+		}
+	}
 	switch (psym) {
 	case psym_decl:
 		if (psyms->sym[psyms->top] == psym_decl)
 			break;	/* only put one declaration onto stack */
 		ps.break_after_comma = true;
 		ps_push_follow(psym_decl);
 		if (opt.left_justify_decl)
 			ps.ind_level_follow = ps.ind_level = decl_level();
 		break;
 	case psym_if_expr:
 		if (psyms->sym[psyms->top] == psym_if_expr_stmt_else
 		    && opt.else_if_in_same_line)
 			ps.ind_level_follow = psyms->ind_level[psyms->top--];
 		/* FALLTHROUGH */
 	case psym_do:
 	case psym_for_exprs:
 		ps.ind_level = ps.ind_level_follow++;
 		ps_push(psym);
 		break;
 	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->top] == psym_stmt
 		    || psyms->sym[psyms->top] == psym_decl
 		    || psyms->sym[psyms->top] == psym_stmt_list)
 			++ps.ind_level_follow;	/* it is a random, isolated
 						 * stmt group or a declaration
 						 */
 		else {
 			if (code.len == 0) {
 				/* it is a group as part of a while, for, etc.
 				 */
 				--ps.ind_level;
 				/* for a switch, brace should be two levels out
 				 * from the code */
 				if (psyms->sym[psyms->top] == psym_switch_expr
 				    && opt.case_indent >= 1.0F)
 					--ps.ind_level;
+			}
+		}
 		ps_push(psym);
 		ps_push_follow(psym_stmt);
 		break;
 	case psym_while_expr:
 		if (psyms->sym[psyms->top] == psym_do_stmt) {
 			ps.ind_level =
 			    ps.ind_level_follow = psyms->ind_level[psyms->top];
 			ps_push(psym_while_expr);
 		} else {
 			ps_push_follow(psym_while_expr);
 			++ps.ind_level_follow;
+		}
 		break;
 	case psym_else:
 		if (psyms->sym[psyms->top] != psym_if_expr_stmt) {
 			diag(1, "Unmatched 'else'");
 			break;
+		}
 		ps.ind_level = psyms->ind_level[psyms->top];
 		ps.ind_level_follow = ps.ind_level + 1;
 		psyms->sym[psyms->top] = psym_if_expr_stmt_else;
 		break;
 	case psym_rbrace:
 		/* stack should have <lbrace> <stmt> or <lbrace> <stmt_list> */
 		if (!(psyms->top > 0
-		    && is_lbrace(psyms->sym[psyms->top - 1]))) {
+			&& is_lbrace(psyms->sym[psyms->top - 1]))) {
 			diag(1, "Statement nesting error");
 			break;
+		}
 		ps.ind_level = ps.ind_level_follow =
 		    psyms->ind_level[--psyms->top];
 		psyms->sym[psyms->top] = psym_stmt;
 		break;
 	case psym_switch_expr:
 		ps_push_follow(psym_switch_expr);
 		ps.ind_level_follow += (int)opt.case_indent + 1;
 		break;
 	case psym_stmt:
 		ps.break_after_comma = false;
 		ps_push(psym_stmt);
 		break;
 	default:
 		diag(1, "Unknown code to parser");
 		return;
+	}
 	if (psyms->top >= STACKSIZE - 1)
 		errx(1, "Parser stack overflow");
 	debug_parse_stack("before reduction");
 	psyms_reduce(&ps.psyms);
 	debug_parse_stack("after reduction");
+}

 @@ -1,357 +1,356 @@
-/*	$NetBSD: pr_comment.c,v 1.157 2023/06/09 07:18:52 rillig Exp $	*/
+/*	$NetBSD: pr_comment.c,v 1.158 2023/06/09 07:20:30 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: pr_comment.c,v 1.157 2023/06/09 07:18:52 rillig Exp $");
+__RCSID("$NetBSD: pr_comment.c,v 1.158 2023/06/09 07:20:30 rillig Exp $");
 #include <string.h>
 #include "indent.h"
 static void
 com_add_char(char ch)
+{
 	buf_add_char(&com, ch);
+}
 static void
 com_add_delim(void)
+{
 	if (opt.star_comment_cont)
 		buf_add_chars(&com, " * ", 3);
+}
 static bool
 fits_in_one_line(int com_ind, int max_line_length)
+{
 	for (const char *start = inp_p, *p = start; *p != '\n'; p++) {
 		if (p[0] == '*' && p[1] == '/') {
 			while (p - inp_p >= 2
 			    && ch_isblank(p[-1])
 			    && ch_isblank(p[-2]))
 				p--;
 			int len = ind_add(com_ind + 3,
 			    start, (size_t)(p - start));
 			len += p == start || ch_isblank(p[-1]) ? 2 : 3;
 			return len <= max_line_length;
+		}
+	}
 	return false;
+}
 static void
 analyze_comment(bool *p_may_wrap, bool *p_delim,
     int *p_ind, int *p_line_length)
+{
 	bool may_wrap = true;
 	bool delim = false;
 	int ind;
 	int line_length = opt.max_line_length;
 	if (ps.curr_col_1 && !opt.format_col1_comments) {
 		may_wrap = false;
 		ind = 0;
 	} else {
 		if (inp_p[0] == '-' || inp_p[0] == '*' ||
 		    token.s[token.len - 1] == '/' ||
 		    (inp_p[0] == '\n' && !opt.format_block_comments))
 			may_wrap = false;
 		if (code.len == 0 && inp_p[strspn(inp_p, "*")] == '\n')
 			out.line_kind = lk_block_comment;
 		if (com.len > 0)
 			output_line();
 		if (lab.len == 0 && code.len == 0) {
 			ind = (ps.ind_level - opt.unindent_displace)
 			    * opt.indent_size;
 			if (ind <= 0)
 				ind = opt.format_col1_comments ? 0 : 1;
 			line_length = opt.block_comment_max_line_length;
 			if (may_wrap && inp_p[0] == '\n')
 				delim = true;
 			if (may_wrap && opt.comment_delimiter_on_blankline)
 				delim = true;
 		} else {
 			int target_ind = code.len > 0
 			    ? ind_add(compute_code_indent(), code.s, code.len)
 			    : ind_add(compute_label_indent(), lab.s, lab.len);
 			ind = ps.decl_on_line || ps.ind_level == 0
 			    ? opt.decl_comment_column - 1
 			    : opt.comment_column - 1;
 			if (ind <= target_ind)
 				ind = next_tab(target_ind);
 			if (ind + 25 > line_length)
 				line_length = ind + 25;
+		}
+	}
 	ps.com_ind = ind;
 	if (!may_wrap) {
 		/* Find out how much indentation there was originally, because
 		 * that much will have to be ignored by output_line. */
 		size_t len = (size_t)(inp_p - 2 - inp.s);
 		ps.n_comment_delta = -ind_add(0, inp.s, len);
 	} else {
 		ps.n_comment_delta = 0;
 		if (!(inp_p[0] == '\t' && !ch_isblank(inp_p[1])))
 			while (ch_isblank(inp_p[0]))
 				inp_p++;
+	}
 	*p_may_wrap = may_wrap;
 	*p_delim = delim;
 	*p_ind = ind;
 	*p_line_length = line_length;
+}
 static void
 copy_comment_start(bool may_wrap, bool *delim, int ind, int line_length)
+{
 	ps.comment_delta = 0;
 	com_add_char('/');
 	com_add_char(token.s[token.len - 1]);	/* either '*' or '/' */
 	if (may_wrap) {
 		if (!ch_isblank(inp_p[0]))
 			com_add_char(' ');
 		if (*delim && fits_in_one_line(ind, line_length))
 			*delim = false;
 		if (*delim) {
 			output_line();
 			com_add_delim();
+		}
+	}
+}
 static void
 copy_comment_wrap_text(int line_length, ssize_t *last_blank)
+{
 	int now_len = ind_add(ps.com_ind, com.s, com.len);
 	for (;;) {
 		char ch = inp_next();
 		if (ch_isblank(ch))
 			*last_blank = (ssize_t)com.len;
 		com_add_char(ch);
 		now_len++;
 		if (memchr("*\n\r\b\t", inp_p[0], 6) != NULL)
 			break;
 		if (now_len >= line_length && *last_blank != -1)
 			break;
+	}
 	ps.next_col_1 = false;
 	if (now_len <= line_length)
 		return;
 	if (ch_isspace(com.s[com.len - 1]))
 		return;
 	if (*last_blank == -1) {
 		/* only a single word in this line */
 		output_line();
 		com_add_delim();
 		return;
+	}
 	const char *last_word_s = com.s + *last_blank + 1;
 	size_t last_word_len = com.len - (size_t)(*last_blank + 1);
 	com.len = (size_t)*last_blank;
 	output_line();
 	com_add_delim();
-	/* Assume that output_line and com_add_delim don't
+	/* Assume that output_line and com_add_delim don't invalidate the
-	 * invalidate the "unused" part of the buffer beyond
+	 * "unused" part of the buffer beyond com.s + com.len. */
 	 * com.s + com.len. */
 	memmove(com.s + com.len, last_word_s, last_word_len);
 	com.len += last_word_len;
 	*last_blank = -1;
+}
 static bool
 copy_comment_wrap_newline(ssize_t *last_blank)
+{
 	*last_blank = -1;
 	if (ps.next_col_1) {
 		if (com.len == 0)
 			com_add_char(' ');	/* force empty output line */
 		if (com.len > 3) {
 			output_line();
 			com_add_delim();
+		}
 		output_line();
 		com_add_delim();
 	} else {
 		ps.next_col_1 = true;
 		if (!(com.len > 0 && ch_isblank(com.s[com.len - 1])))
 			com_add_char(' ');
 		*last_blank = (int)com.len - 1;
+	}
 	++line_no;
 	/* flush any blanks and/or tabs at start of next line */
 	inp_skip();		/* '\n' */
 	while (ch_isblank(inp_p[0]))
 		inp_p++;
 	if (inp_p[0] == '*' && inp_p[1] == '/')
 		return false;
 	if (inp_p[0] == '*') {
 		inp_p++;
 		while (ch_isblank(inp_p[0]))
 			inp_p++;
+	}
 	return true;
+}
 static void
 copy_comment_wrap_finish(int line_length, bool delim)
+{
 	if (delim) {
 		if (com.len > 3)
 			output_line();
 		else
 			com.len = 0;
 		com_add_char(' ');
 	} else {
 		size_t len = com.len;
 		while (ch_isblank(com.s[len - 1]))
 			len--;
 		int end_ind = ind_add(ps.com_ind, com.s, len);
 		if (end_ind + 3 > line_length)
 			output_line();
+	}
 	while (com.len >= 2
 	    && ch_isblank(com.s[com.len - 1])
 	    && ch_isblank(com.s[com.len - 2]))
 		com.len--;
 	inp_p += 2;
 	if (com.len > 0 && ch_isblank(com.s[com.len - 1]))
 		buf_add_chars(&com, "*/", 2);
 	else
 		buf_add_chars(&com, " */", 3);
+}
 /*
  * Copy characters from 'inp' to 'com'. Try to keep comments from going over
  * the maximum line length. To do that, remember where the last blank, tab, or
  * newline was. When a line is filled, print up to the last blank and continue
  * copying.
  */
 static void
 copy_comment_wrap(int line_length, bool delim)
+{
 	ssize_t last_blank = -1;	/* index of the last blank in 'com' */
 	for (;;) {
 		if (inp_p[0] == '\n') {
 			if (had_eof)
 				goto unterminated_comment;
 			if (!copy_comment_wrap_newline(&last_blank))
 				goto end_of_comment;
 		} else if (inp_p[0] == '*' && inp_p[1] == '/')
 			goto end_of_comment;
 		else
 			copy_comment_wrap_text(line_length, &last_blank);
+	}
 end_of_comment:
 	copy_comment_wrap_finish(line_length, delim);
 	return;
 unterminated_comment:
 	diag(1, "Unterminated comment");
 	output_line();
+}
 static void
 copy_comment_nowrap(void)
+{
 	char kind = token.s[token.len - 1];
 	for (;;) {
 		if (inp_p[0] == '\n') {
 			if (kind == '/')
 				return;
 			if (had_eof) {
 				diag(1, "Unterminated comment");
 				output_line();
 				return;
+			}
 			if (com.len == 0)
 				com_add_char(' ');	/* force output of an
 							 * empty line */
 			output_line();
 			++line_no;
 			inp_skip();
 			continue;
+		}
 		com_add_char(*inp_p++);
 		if (com.len >= 2
 		    && com.s[com.len - 2] == '*'
 		    && com.s[com.len - 1] == '/'
 		    && kind == '*')
 			return;
+	}
+}
 /*
  * Scan, reformat and output a single comment, which is either a block comment
  * starting with '/' '*' or an end-of-line comment starting with '//'.
  */
 void
 process_comment(void)
+{
 	bool may_wrap, delim;
 	int ind, line_length;
 	analyze_comment(&may_wrap, &delim, &ind, &line_length);
 	copy_comment_start(may_wrap, &delim, ind, line_length);
 	if (may_wrap)
 		copy_comment_wrap(line_length, delim);
 	else
 		copy_comment_nowrap();
+}