 @@ -1,392 +1,392 @@
-/*	$NetBSD: debug.c,v 1.66 2023/06/16 23:51:32 rillig Exp $	*/
+/*	$NetBSD: debug.c,v 1.67 2023/06/17 22:28:49 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.66 2023/06/16 23:51:32 rillig Exp $");
+__RCSID("$NetBSD: debug.c,v 1.67 2023/06/17 22:28:49 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",
 	"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",
 	"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",
 	"#other",
 	"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 *s, size_t len)
+{
 	debug_printf("\"");
 	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("\"");
+}
 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
 debug_ps_bool_member(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
 debug_ps_int_member(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
 debug_ps_enum_member(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
 paren_stack_equal(const struct paren_stack *a, const struct paren_stack *b)
+{
 	if (a->len != b->len)
 		return false;
 	for (size_t i = 0, n = a->len; i < n; i++)
 		if (a->item[i].indent != b->item[i].indent
 		    || a->item[i].cast != b->item[i].cast)
 			return true;
 	return false;
+}
 static void
 debug_ps_paren(void)
+{
 	if (!config.full_parser_state
 	    && paren_stack_equal(&state.prev_ps.paren, &ps.paren)
 	    && !state.ps_first)
 		return;
 	debug_printf("             ps.paren:");
 	for (size_t i = 0; i < ps.paren.len; i++) {
 		debug_printf(" %s%d",
 		    paren_level_cast_name[ps.paren.item[i].cast],
 		    ps.paren.item[i].indent);
+	}
 	if (ps.paren.len == 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) \
 	debug_ps_bool_member(#name, state.prev_ps.name, ps.name)
 #define debug_ps_int(name) \
 	debug_ps_int_member(#name, state.prev_ps.name, ps.name)
 #define debug_ps_enum(name, names) \
         debug_ps_enum_member(#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_typedef_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(line_is_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(ind_paren_level);
 	debug_ps_paren();
 	state.heading = "indentation of comments";
 	debug_ps_int(comment_ind);
 	debug_ps_int(comment_shift);
 	debug_ps_bool(comment_cont);
 	state.heading = "vertical spacing";
 	debug_ps_bool(break_after_comma);
 	debug_ps_bool(want_newline);
 	debug_ps_enum(declaration, declaration_name);
 	debug_ps_bool(blank_line_after_decl);
 	state.heading = NULL;
 	debug_blank_line();
 	state.prev_ps = ps;
 	state.ps_first = false;
+}
 void
 debug_psyms_stack(const char *situation)
+{
 	debug_printf("parse stack %s:", situation);
 	const struct psym_stack *psyms = &ps.psyms;
-	for (size_t i = 0; i < psyms->len; ++i)
+	for (size_t i = 0; i < psyms->len; i++)
 		debug_printf(" %d %s",
 		    psyms->ind_level[i], psym_name[psyms->sym[i]]);
 	debug_println("");
+}
 #endif

 @@ -1,1137 +1,1137 @@
-/*	$NetBSD: indent.c,v 1.379 2023/06/16 23:51:32 rillig Exp $	*/
+/*	$NetBSD: indent.c,v 1.380 2023/06/17 22:28:49 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.379 2023/06/16 23:51:32 rillig Exp $");
+__RCSID("$NetBSD: indent.c,v 1.380 2023/06/17 22:28:49 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 struct {
 	struct parser_state *item;
 	size_t len;
 	size_t cap;
 } ifdef;
 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;
+			ind--;
 		else
-			++ind;
+			ind++;
+	}
 	return ind;
+}
 static void
 init_globals(void)
+{
 	ps_push(psym_stmt, false);	/* as a stop symbol */
 	ps.prev_lsym = lsym_semicolon;
 	ps.lbrace_kind = psym_lbrace_block;
 	const char *suffix = getenv("SIMPLE_BACKUP_SUFFIX");
 	if (suffix != NULL)
 		backup_suffix = suffix;
+}
 static void
 load_profiles(int argc, char **argv)
+{
 	const char *profile_name = NULL;
-	for (int i = 1; i < argc; ++i) {
+	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) {
+	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 && ps.paren.len == 0)
 	    || lsym == lsym_word
 	    || lsym == lsym_lbrace) {
 		/* Keep the current '{' kind. */
 	} else
 		ps.lbrace_kind = psym_lbrace_block;
+}
 static void
 indent_declarator(int decl_ind, bool tabs_to_var)
+{
 	int base = ps.ind_level * opt.indent_size;
 	int ind = ind_add(base, code.s, code.len);
 	int target = base + decl_ind;
 	size_t orig_code_len = code.len;
 	if (tabs_to_var)
 		for (int next; (next = next_tab(ind)) <= target; ind = next)
 			buf_add_char(&code, '\t');
 	for (; ind < target; ind++)
 		buf_add_char(&code, ' ');
 	if (code.len == orig_code_len && ps.want_blank)
 		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_typedef_decl
 	    && !ps.in_init
 	    && !ps.decl_indent_done
 	    && !ps.line_has_func_def
 	    && ps.ind_paren_level == 0;
+}
 static int
 process_eof(void)
+{
 	finish_output();
 	if (ps.psyms.len > 2)	/* 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
 paren_stack_push(struct paren_stack *s, int indent, enum paren_level_cast cast)
+{
 	if (s->len == s->cap) {
 		s->cap = 10 + s->cap;
 		s->item = nonnull(realloc(s->item,
 			sizeof(s->item[0]) * s->cap));
+	}
 	s->item[s->len++] = (struct paren_level){indent, cast};
+}
 static void *
 dup_mem(const void *src, size_t size)
+{
 	return memcpy(nonnull(malloc(size)), src, size);
+}
 #define dup_array(src, len) \
     dup_mem((src), sizeof((src)[0]) * (len))
 #define copy_array(dst, src, len) \
     memcpy((dst), (src), sizeof((dst)[0]) * (len))
 static void
 parser_state_back_up(struct parser_state *dst)
+{
 	*dst = ps;
 	dst->paren.item = dup_array(ps.paren.item, ps.paren.len);
 	dst->psyms.sym = dup_array(ps.psyms.sym, ps.psyms.len);
 	dst->psyms.ind_level = dup_array(ps.psyms.ind_level, ps.psyms.len);
+}
 static void
 parser_state_restore(const struct parser_state *src)
+{
 	struct paren_level *ps_paren_item = ps.paren.item;
 	size_t ps_paren_cap = ps.paren.cap;
 	enum parser_symbol *ps_psyms_sym = ps.psyms.sym;
 	int *ps_psyms_ind_level = ps.psyms.ind_level;
 	size_t ps_psyms_cap = ps.psyms.cap;
 	ps = *src;
 	ps.paren.item = ps_paren_item;
 	ps.paren.cap = ps_paren_cap;
 	ps.psyms.sym = ps_psyms_sym;
 	ps.psyms.ind_level = ps_psyms_ind_level;
 	ps.psyms.cap = ps_psyms_cap;
 	copy_array(ps.paren.item, src->paren.item, src->paren.len);
 	copy_array(ps.psyms.sym, src->psyms.sym, src->psyms.len);
 	copy_array(ps.psyms.ind_level, src->psyms.ind_level, src->psyms.len);
+}
 static void
 parser_state_free(struct parser_state *pst)
+{
 	free(pst->paren.item);
 	free(pst->psyms.sym);
 	free(pst->psyms.ind_level);
+}
 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 (ifdef.len >= ifdef.cap) {
 			ifdef.cap += 5;
 			ifdef.item = nonnull(realloc(ifdef.item,
 				sizeof(ifdef.item[0]) * ifdef.cap));
+		}
 		parser_state_back_up(ifdef.item + ifdef.len++);
 		out.line_kind = lk_pre_if;
 	} else if (dir_len >= 2 && memcmp(dir, "el", 2) == 0) {
 		if (ifdef.len == 0)
 			diag(1, "Unmatched #%.*s", (int)dir_len, dir);
 		else
 			parser_state_restore(ifdef.item + ifdef.len - 1);
 		out.line_kind = lk_pre_other;
 	} else if (dir_len == 5 && memcmp(dir, "endif", 5) == 0) {
 		if (ifdef.len == 0)
 			diag(1, "Unmatched #endif");
 		else
 			parser_state_free(ifdef.item + --ifdef.len);
 		out.line_kind = lk_pre_endif;
 	} else
 		out.line_kind = lk_pre_other;
+}
 static void
 process_newline(void)
+{
 	if (ps.prev_lsym == lsym_comma
 	    && ps.paren.len == 0 && !ps.in_init
 	    && !opt.break_after_comma && ps.break_after_comma
 	    && lab.len == 0	/* for preprocessing lines */
 	    && com.len == 0)
 		goto stay_in_line;
 	if (ps.psyms.sym[ps.psyms.len - 1] == psym_switch_expr
 	    && opt.brace_same_line
 	    && com.len == 0) {
 		ps.want_newline = true;
 		goto stay_in_line;
+	}
 	output_line();
 stay_in_line:
-	++line_no;
+	line_no++;
+}
 static bool
 want_blank_before_lparen(void)
+{
 	if (opt.proc_calls_space)
 		return true;
 	if (ps.prev_lsym == lsym_sizeof)
 		return opt.blank_after_sizeof;
 	if (ps.prev_lsym == lsym_rparen
 	    || ps.prev_lsym == lsym_rbracket
 	    || ps.prev_lsym == lsym_postfix_op
 	    || ps.prev_lsym == lsym_offsetof
 	    || ps.prev_lsym == lsym_word
 	    || ps.prev_lsym == lsym_funcname)
 		return false;
 	return true;
+}
 static void
 process_lparen(void)
+{
 	if (is_function_pointer_declaration())
 		indent_declarator(ps.decl_ind, ps.tabs_to_var);
 	else if (ps.want_blank && want_blank_before_lparen())
 		buf_add_char(&code, ' ');
 	ps.want_blank = false;
 	buf_add_buf(&code, &token);
 	if (opt.extra_expr_indent && ps.spaced_expr_psym != psym_0)
 		ps.extra_expr_indent = eei_maybe;
 	if (ps.in_var_decl && ps.psyms.len <= 3 && !ps.in_init) {
 		parse(psym_stmt);	/* prepare for function definition */
 		ps.in_var_decl = false;
+	}
 	enum paren_level_cast cast = cast_unknown;
 	if (ps.prev_lsym == lsym_offsetof
 	    || ps.prev_lsym == lsym_sizeof
 	    || ps.prev_lsym == lsym_for
 	    || ps.prev_lsym == lsym_if
 	    || ps.prev_lsym == lsym_switch
 	    || ps.prev_lsym == lsym_while
 	    || ps.line_has_func_def)
 		cast = cast_no;
 	paren_stack_push(&ps.paren, ind_add(0, code.s, code.len), cast);
+}
 static bool
 rparen_is_cast(bool paren_cast)
+{
 	if (ps.in_func_def_params)
 		return false;
 	if (ps.line_has_decl && !ps.in_init)
 		return false;
 	if (ps.prev_lsym == lsym_unary_op)
 		return true;
 	if (ps.spaced_expr_psym != psym_0 && ps.paren.len == 0)
 		return false;
 	return paren_cast || ch_isalpha(inp_p[0]) || inp_p[0] == '{';
+}
 static void
 process_rparen(void)
+{
 	if (ps.paren.len == 0)
 		diag(0, "Extra '%c'", *token.s);
 	bool paren_cast = ps.paren.len > 0
 	    && ps.paren.item[--ps.paren.len].cast == cast_maybe;
 	ps.prev_paren_was_cast = rparen_is_cast(paren_cast);
 	if (ps.prev_paren_was_cast) {
 		ps.next_unary = true;
 		ps.want_blank = opt.space_after_cast;
 	} else
 		ps.want_blank = true;
 	if (code.len == 0)
 		ps.ind_paren_level = (int)ps.paren.len;
 	buf_add_buf(&code, &token);
 	if (ps.spaced_expr_psym != psym_0 && ps.paren.len == 0) {
 		parse(ps.spaced_expr_psym);
 		ps.spaced_expr_psym = psym_0;
 		ps.want_newline = true;
 		ps.next_unary = true;
 		ps.in_stmt_or_decl = false;
 		ps.want_blank = true;
 		out.line_kind = lk_stmt_head;
 		if (ps.extra_expr_indent == eei_maybe)
 			ps.extra_expr_indent = eei_last;
+	}
+}
 static void
 process_lbracket(void)
+{
 	if (code.len > 0
 	    && (ps.prev_lsym == lsym_comma || ps.prev_lsym == lsym_binary_op))
 		buf_add_char(&code, ' ');
 	buf_add_buf(&code, &token);
 	ps.want_blank = false;
 	paren_stack_push(&ps.paren, ind_add(0, code.s, code.len), cast_no);
+}
 static void
 process_rbracket(void)
+{
 	if (ps.paren.len == 0)
 		diag(0, "Extra '%c'", *token.s);
 	if (ps.paren.len > 0)
 		ps.paren.len--;
 	if (code.len == 0)
 		ps.ind_paren_level = (int)ps.paren.len;
 	buf_add_buf(&code, &token);
 	ps.want_blank = true;
+}
 static void
 process_lbrace(void)
+{
 	if (ps.prev_lsym == lsym_rparen && ps.prev_paren_was_cast) {
 		ps.in_var_decl = true;	// XXX: not really
 		ps.in_init = true;
+	}
 	if (out.line_kind == lk_stmt_head)
 		out.line_kind = lk_other;
 	ps.in_stmt_or_decl = false;	/* don't indent the {} */
 	if (ps.in_init)
 		ps.init_level++;
 	else
 		ps.want_newline = true;
 	if (code.len > 0 && !ps.in_init) {
 		if (!opt.brace_same_line ||
 		    (code.len > 0 && code.s[code.len - 1] == '}'))
 			output_line();
 		else if (ps.in_func_def_params && !ps.in_var_decl) {
 			ps.ind_level_follow = 0;
 			if (opt.function_brace_split)
 				output_line();
 			else
 				ps.want_blank = true;
+		}
+	}
 	if (ps.paren.len > 0 && ps.init_level == 0) {
 		diag(1, "Unbalanced parentheses");
 		ps.paren.len = 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.line_is_stmt_cont = false;
 	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;	/* 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.paren.len > 0 && ps.init_level == 0) {
 		diag(1, "Unbalanced parentheses");
 		ps.paren.len = 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.line_is_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.len == 3)
 		out.line_kind = lk_func_end;
 	parse(psym_rbrace);
 	if (!ps.in_var_decl
 	    && ps.psyms.sym[ps.psyms.len - 1] != psym_do_stmt
 	    && ps.psyms.sym[ps.psyms.len - 1] != psym_if_expr_stmt)
 		ps.want_newline = true;
+}
 static void
 process_period(void)
+{
 	if (code.len > 0 && code.s[code.len - 1] == ',')
 		buf_add_char(&code, ' ');
 	buf_add_char(&code, '.');
 	ps.want_blank = false;
+}
 static void
 process_unary_op(void)
+{
 	if (is_function_pointer_declaration()) {
 		int ind = ps.decl_ind - (int)token.len;
 		indent_declarator(ind, ps.tabs_to_var);
 	} 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.ind_paren_level == 0
 	    && !ps.line_has_func_def && !ps.in_init && !ps.decl_indent_done) {
 		/* indent leading commas and not the actual identifiers */
 		indent_declarator(ps.decl_ind - 1, ps.tabs_to_var);
+	}
 	buf_add_char(&code, ',');
 	if (ps.paren.len == 0) {
 		if (ps.init_level == 0)
 			ps.in_init = false;
 		int typical_varname_length = 8;
 		if (ps.break_after_comma && (opt.break_after_comma ||
 			ind_add(compute_code_indent(), code.s, code.len)
 			>= opt.max_line_length - typical_varname_length))
 			ps.want_newline = true;
+	}
+}
 static void
 process_label_colon(void)
+{
 	buf_add_buf(&lab, &code);
 	buf_add_char(&lab, ':');
 	buf_clear(&code);
 	if (ps.seen_case)
 		out.line_kind = lk_case_or_default;
 	ps.in_stmt_or_decl = false;
 	ps.want_newline = ps.seen_case;
 	ps.seen_case = false;
 	ps.want_blank = false;
+}
 static void
 process_other_colon(void)
+{
 	buf_add_char(&code, ':');
 	ps.want_blank = ps.decl_level == 0;
+}
 static void
 process_semicolon(void)
+{
 	if (out.line_kind == lk_stmt_head)
 		out.line_kind = lk_other;
 	if (ps.decl_level == 0) {
 		ps.in_var_decl = false;
 		ps.in_typedef_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.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.paren.len > 0 && ps.spaced_expr_psym != psym_for_exprs) {
 		diag(1, "Unbalanced parentheses");
 		ps.paren.len = 0;
 		if (ps.spaced_expr_psym != psym_0) {
 			parse(ps.spaced_expr_psym);
 			ps.spaced_expr_psym = psym_0;
+		}
+	}
 	buf_add_char(&code, ';');
 	ps.want_blank = true;
 	ps.in_stmt_or_decl = ps.paren.len > 0;
 	ps.decl_ind = 0;
 	if (ps.spaced_expr_psym == psym_0) {
 		parse(psym_stmt);
 		ps.want_newline = true;
+	}
+}
 static void
 process_type_outside_parentheses(void)
+{
 	parse(psym_decl);	/* let the parser worry about indentation */
 	if (ps.prev_lsym == lsym_rparen && ps.psyms.len <= 2 && code.len > 0)
 		output_line();
 	if (ps.in_func_def_params && opt.indent_parameters &&
 	    ps.decl_level == 0) {
 		ps.ind_level = ps.ind_level_follow = 1;
 		ps.line_is_stmt_cont = false;
+	}
 	ps.in_var_decl = /* maybe */ true;
 	ps.in_decl = true;
 	ps.line_has_decl = ps.in_decl;
 	if (ps.decl_level == 0)
 		ps.declaration = decl_begin;
 	int ind = ps.ind_level > 0 && ps.decl_level == 0
 	    ? opt.local_decl_indent	/* local variable */
 	    : opt.decl_indent;	/* global variable, or member */
 	if (ind == 0) {
 		int ind0 = code.len > 0 ? ind_add(0, code.s, code.len) + 1 : 0;
 		ps.decl_ind = ind_add(ind0, token.s, token.len) + 1;
 	} else
 		ps.decl_ind = ind;
 	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_typedef_decl && ps.decl_level == 0) {
 			/* Do not indent typedef declarators. */
 		} else if (!ps.in_init && !ps.decl_indent_done &&
 		    ps.ind_paren_level == 0) {
 			if (opt.decl_indent == 0
 			    && code.len > 0 && code.s[code.len - 1] == '}')
 				ps.decl_ind = ind_add(0, code.s, code.len) + 1;
 			indent_declarator(ps.decl_ind, ps.tabs_to_var);
+		}
 	} else if (ps.spaced_expr_psym != psym_0 && ps.paren.len == 0) {
 		parse(ps.spaced_expr_psym);
 		ps.spaced_expr_psym = psym_0;
 		ps.want_newline = true;
 		ps.in_stmt_or_decl = false;
 		ps.next_unary = true;
+	}
+}
 static void
 process_do(void)
+{
 	ps.in_stmt_or_decl = false;
 	ps.in_decl = false;
 	if (code.len > 0)
 		output_line();
 	parse(psym_do);
 	ps.want_newline = true;
+}
 static void
 process_else(void)
+{
 	ps.in_stmt_or_decl = false;
 	ps.in_decl = false;
 	if (code.len > 0
 	    && !(opt.cuddle_else && code.s[code.len - 1] == '}'))
 		output_line();
 	parse(psym_else);
 	ps.want_newline = true;
+}
 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:	ps.in_typedef_decl = true; 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.paren.len > 0)
 			goto copy_token;
 		/* FALLTHROUGH */
 	case lsym_type:
 		if (ps.paren.len == 0) {
 			process_type_outside_parentheses();
 			goto copy_token;
+		}
 		/* FALLTHROUGH */
 	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_preprocessing || lsym == lsym_newline)
 			ps.want_newline = false;
 		else if (lsym == lsym_comment) {
 			/* no special processing */
 		} else {
 			if (lsym == lsym_if && ps.prev_lsym == lsym_else
 			    && opt.else_if_in_same_line)
 				ps.want_newline = false;
 			if (ps.want_newline && should_break_line(lsym)) {
 				ps.want_newline = false;
 				output_line();
+			}
 			ps.in_stmt_or_decl = true;
 			if (com.len > 0)
 				move_com_to_code(lsym);
 			update_ps_lbrace_kind(lsym);
+		}
 		process_lsym(lsym);
 		if (lsym != lsym_preprocessing
 		    && lsym != lsym_newline
 		    && lsym != lsym_comment)
 			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,438 +1,444 @@
-/*	$NetBSD: io.c,v 1.227 2023/06/16 11:48:32 rillig Exp $	*/
+/*	$NetBSD: io.c,v 1.228 2023/06/17 22:28:49 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.227 2023/06/16 11:48:32 rillig Exp $");
+__RCSID("$NetBSD: io.c,v 1.228 2023/06/17 22:28:49 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;	/* total indentation when parenthesized */
 static void
 inp_read_next_line(void)
+{
 	buf_clear(&inp);
 	for (;;) {
 		int ch = getc(input);
 		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();
+}
 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_printf("write_range ");
 	debug_vis_range(s, len);
 	debug_println("");
 	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_pre_if
 		    && out.line_kind == lk_pre_if)
 			return true;
 		if (out.prev_line_kind == lk_pre_endif
 		    && out.line_kind != lk_pre_endif)
 			return true;
+	}
 	if (opt.blank_line_after_proc && out.prev_line_kind == lk_func_end
 	    && out.line_kind != lk_pre_endif && out.line_kind != lk_pre_other)
 		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.len >= 3)
 		return newlines >= 2;
 	return newlines >= 3;
+}
 static int
 compute_case_label_indent(void)
+{
 	size_t i = ps.psyms.len - 1;
 	while (i > 0 && ps.psyms.sym[i] != psym_switch_expr)
 		i--;
 	float case_ind = (float)ps.psyms.ind_level[i] + opt.case_indent;
 	// TODO: case_ind may become negative here.
 	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;
 	// TODO: the indentation may become negative here.
 	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 -= 2 + overflow;
 		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.ind_paren_level == 0) {
 		if (ps.line_is_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.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 (size_t i = 0; i < ps.paren.len; i++) {
 		int paren_ind = ps.paren.item[i].indent;
 		if (paren_ind >= 0) {
 			ps.paren.item[i].indent =
 			    -1 - (paren_ind + target_ind);
 			debug_println(
 			    "setting paren_indents[%zu] from %d to %d "
 			    "for column %d",
 			    i, paren_ind,
 			    ps.paren.item[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.comment_ind;
 	const char *p;
 	if (ps.comment_cont)
 		target_ind += ps.comment_shift;
 	ps.comment_cont = true;
 	/* consider the 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));
+}
 /*
  * Write a line of formatted source to the output file. The line consists of
  * the label, the code and the comment.
  */
 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.line_is_stmt_cont = false;
 	if (opt.blank_line_after_decl && ps.declaration == decl_end
 	    && ps.psyms.len > 2) {
 		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;
+}
 static bool
 is_stmt_cont(void)
+{
 	if (ps.psyms.len >= 2
 	    && ps.psyms.sym[ps.psyms.len - 2] == psym_lbrace_enum
 	    && ps.prev_lsym == lsym_comma
 	    && ps.paren.len == 0)
 		return false;
 	return ps.in_stmt_or_decl
 	    && (!ps.in_decl || ps.in_init)
 	    && ps.init_level == 0;
+}
-/*
+static void
- * Write a line of formatted source to the output file. The line consists of
+prepare_next_line(void)
  * 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.line_is_stmt_cont = is_stmt_cont();
 	ps.decl_indent_done = false;
 	if (ps.extra_expr_indent == eei_last)
 		ps.extra_expr_indent = eei_no;
 	if (!(ps.psyms.sym[ps.psyms.len - 1] == psym_if_expr_stmt_else
 		&& ps.paren.len > 0))
 		ps.ind_level = ps.ind_level_follow;
 	ps.ind_paren_level = (int)ps.paren.len;
 	ps.want_blank = false;
 	if (ps.paren.len > 0) {
 		/* TODO: explain what negative indentation means */
 		paren_indent = -1 - ps.paren.item[ps.paren.len - 1].indent;
 		debug_println("paren_indent is now %d", paren_indent);
+	}
 	out.line_kind = lk_other;
+}
 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);
 	prepare_next_line();
+}
 void
 finish_output(void)
+{
 	output_line();
 	if (indent_enabled != indent_on) {
 		indent_enabled = indent_last_off_line;
 		output_line();
+	}
 	fflush(output);
+}

 @@ -1,682 +1,682 @@
-/*	$NetBSD: lexi.c,v 1.230 2023/06/16 23:51:32 rillig Exp $	*/
+/*	$NetBSD: lexi.c,v 1.231 2023/06/17 22:28:49 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.230 2023/06/16 23:51:32 rillig Exp $");
+__RCSID("$NetBSD: lexi.c,v 1.231 2023/06/17 22:28:49 rillig Exp $");
 #include <stdlib.h>
 #include <string.h>
 #include "indent.h"
 /* 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 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
 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];
+		unsigned char ch = (unsigned char)*inp_p;
 		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:
-		         * lex_number_state[0][s - 'A'] now indicates the type:
+		        // f = floating, i = integer, u = unknown
 		         * f = floating, i = integer, u = unknown
 		         */
 			return;
+		}
 		s = lex_number_state[row][s - 'A'];
 		token_add_char(inp_next());
+	}
+}
 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') {
+		if (*inp_p == '\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')
+			if (*inp_p == '\n')
-				++line_no;
+				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.in_init)
 		return false;
 	if (ps.in_stmt_or_decl)	/* XXX: this condition looks incorrect */
 		return false;
 	if (ps.prev_lsym == lsym_semicolon
 	    || ps.prev_lsym == lsym_lbrace
 	    || ps.prev_lsym == lsym_rbrace) {
 		if (inp_p[0] == '*' && inp_p[1] != '=')
 			return true;
 		/* XXX: is_identifier_start */
 		if (ch_isalpha(inp_p[0]))
 			return true;
+	}
 	return false;
+}
 static int
 bsearch_typenames(const char *key)
+{
 	const char **arr = typenames.items;
 	unsigned lo = 0;
 	unsigned hi = typenames.len;
 	while (lo < hi) {
 		unsigned mid = (lo + hi) / 2;
 		int cmp = strcmp(arr[mid], key);
 		if (cmp < 0)
 			lo = mid + 1;
 		else if (cmp > 0)
 			hi = mid;
 		else
 			return (int)mid;
+	}
 	return -1 - (int)lo;
+}
 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;
+}
 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));
+	}
 	int pos = bsearch_typenames(name);
 	if (pos >= 0)
 		return;		/* already in the list */
 	pos = -1 - pos;
 	memmove(typenames.items + pos + 1, typenames.items + pos,
 	    sizeof(typenames.items[0]) * (typenames.len++ - (unsigned)pos));
 	typenames.items[pos] = nonnull(strdup(name));
+}
 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
+ * Looking at the '(', guess whether this starts a function definition or a
- * this starts a function definition or a declaration.
+ * function declaration.
  */
 static bool
 probably_function_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(...) { ... */
+		}
 		if (paren_level == 1 && p[0] == '*' && p[1] == ',')
 			return false;
+	}
-	/* To further reduce the cases where indent wrongly treats an
+	/*
 	 * 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 '{'. */
+	 * until the next '{'.
 	 */
 	return true;
+}
 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]))
+	while (ch_isblank(*inp_p))
 		inp_p++;
 	ps.next_unary = ps.prev_lsym == lsym_tag
 	    || ps.prev_lsym == lsym_typedef;
 	if (ps.prev_lsym == lsym_tag && ps.paren.len == 0)
 		return lsym_type;
-	token_add_char('\0');
+	token_add_char('\0');		// Terminate in non-debug mode as well.
 	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;
 		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;
 		ps.next_unary = true;
 found_typename:
 		if (ps.paren.len > 0) {
 			/* inside parentheses: cast, param list, offsetof or
 			 * sizeof */
 			struct paren_level *paren_level =
 			    ps.paren.item + ps.paren.len - 1;
 			if (paren_level->cast == cast_unknown)
 				paren_level->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.paren.len == 0)
 				return lsym_type;
+		}
+	}
-	if (inp_p[0] == '(' && ps.psyms.len <= 2 && ps.ind_level == 0 &&
+	if (*inp_p == '(' && ps.psyms.len < 3 && ps.ind_level == 0 &&
 	    !ps.in_func_def_params && !ps.in_init) {
 		if (ps.paren.len == 0 && probably_function_definition()) {
 			ps.line_has_func_def = true;
 			if (ps.in_decl)
 				ps.in_func_def_params = true;
 			return lsym_funcname;
+		}
 	} else if (ps.paren.len == 0 && probably_typename()) {
 		ps.next_unary = true;
 		return lsym_type;
+	}
 	return lsym;
+}
 static bool
 is_asterisk_pointer(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.paren.len > 0;
+}
 static bool
 probably_in_function_definition(void)
+{
-	for (const char *tp = inp_p; *tp != '\n';) {
+	for (const char *p = inp_p; *p != '\n';) {
-		if (ch_isspace(*tp))
+		if (ch_isspace(*p))
-			tp++;
+			p++;
-		else if (is_identifier_start(*tp)) {
+		else if (is_identifier_start(*p)) {
-			tp++;
+			p++;
-			while (is_identifier_part(*tp))
+			while (is_identifier_part(*p))
-				tp++;
+				p++;
 		} else
-			return *tp == '(';
+			return *p == '(';
+	}
 	return false;
+}
 static void
 lex_asterisk_pointer(void)
+{
-	while (inp_p[0] == '*' || ch_isspace(inp_p[0])) {
+	while (*inp_p == '*' || ch_isspace(*inp_p)) {
-		if (inp_p[0] == '*')
+		if (*inp_p == '*')
 			token_add_char('*');
 		inp_skip();
+	}
 	if (ps.in_decl && probably_in_function_definition())
 		ps.line_has_func_def = true;
+}
 static bool
 skip(const char **pp, const char *s)
+{
 	size_t len = strlen(s);
 	while (ch_isblank(**pp))
 		(*pp)++;
 	if (strncmp(*pp, s, len) == 0) {
 		*pp += len;
 		return true;
+	}
 	return false;
+}
 static void
 lex_indent_comment(void)
+{
 	const char *p = inp.s;
 	if (skip(&p, "/*") && skip(&p, "INDENT")) {
 		enum indent_enabled enabled;
 		if (skip(&p, "ON") || *p == '*')
 			enabled = indent_last_off_line;
 		else if (skip(&p, "OFF"))
 			enabled = indent_off;
 		else
 			return;
 		if (skip(&p, "*/\n")) {
 			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)
+{
 	buf_clear(&token);
 	for (;;) {
 		if (ch_isblank(inp_p[0]))
 			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]) {
 	case '#':
 		lsym = lsym_preprocessing;
 		next_unary = ps.next_unary;
 		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;
 		break;
 	/* INDENT OFF */
 	case '(':	lsym = lsym_lparen;	next_unary = true;	break;
 	case ')':	lsym = lsym_rparen;	next_unary = false;	break;
 	case '[':	lsym = lsym_lbracket;	next_unary = true;	break;
 	case ']':	lsym = lsym_rbracket;	next_unary = false;	break;
 	case '{':	lsym = lsym_lbrace;	next_unary = true;	break;
 	case '}':	lsym = lsym_rbrace;	next_unary = true;	break;
 	case '.':	lsym = lsym_period;	next_unary = false;	break;
 	case '?':	lsym = lsym_question;	next_unary = true;	break;
 	case ',':	lsym = lsym_comma;	next_unary = true;	break;
 	case ';':	lsym = lsym_semicolon;	next_unary = true;	break;
 	/* INDENT ON */
 	case '-':
 	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]) {
+		if (*inp_p == 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 '-=' */
+		} else if (*inp_p == '=') {	/* '+=' or '-=' */
 			token_add_char(*inp_p++);
-		} else if (inp_p[0] == '>') {	/* '->' */
+		} else if (*inp_p == '>') {	/* '->' */
 			token_add_char(*inp_p++);
 			lsym = lsym_unary_op;
 			next_unary = false;
 			ps.want_blank = false;
+		}
 		break;
 	case ':':
 		lsym = ps.quest_level > 0
 		    ? (ps.quest_level--, lsym_question_colon)
 		    : ps.in_var_decl ? lsym_other_colon : lsym_label_colon;
 		next_unary = true;
 		break;
 	case '*':
-		if (inp_p[0] == '=') {
+		if (*inp_p == '=') {
 			token_add_char(*inp_p++);
 			lsym = lsym_binary_op;
 		} else if (is_asterisk_pointer()) {
 			lex_asterisk_pointer();
 			lsym = lsym_unary_op;
 		} else
 			lsym = lsym_binary_op;
 		next_unary = true;
 		break;
 	case '=':
 		if (ps.in_var_decl)
 			ps.in_init = true;
-		if (inp_p[0] == '=')
+		if (*inp_p == '=')
 			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] == '=')
+		if (*inp_p == '>' || *inp_p == '<' || *inp_p == '=')
 			token_add_char(*inp_p++);
-		if (inp_p[0] == '=')
+		if (*inp_p == '=')
 			token_add_char(*inp_p++);
 		lsym = ps.next_unary ? lsym_unary_op : lsym_binary_op;
 		next_unary = true;
 		break;
 	case '\'':
 	case '"':
 		lex_char_or_string();
 		lsym = lsym_word;
 		next_unary = false;
 		break;
 	default:
 		if (token.s[token.len - 1] == '/'
-		    && (inp_p[0] == '*' || inp_p[0] == '/')) {
+		    && (*inp_p == '*' || *inp_p == '/')) {
 			enum indent_enabled prev = indent_enabled;
 			lex_indent_comment();
 			if (prev == indent_on && indent_enabled == indent_off)
 				buf_clear(&out.indent_off_text);
 			token_add_char(*inp_p++);
 			lsym = lsym_comment;
 			next_unary = ps.next_unary;
 			break;
+		}
 		/* punctuation like '%', '&&', '/', '^', '||', '~' */
 		lsym = ps.next_unary ? lsym_unary_op : lsym_binary_op;
-		if (inp_p[0] == token.s[token.len - 1])
+		if (*inp_p == token.s[token.len - 1])
 			token_add_char(*inp_p++), lsym = lsym_binary_op;
-		if (inp_p[0] == '=')
+		if (*inp_p == '=')
 			token_add_char(*inp_p++), lsym = lsym_binary_op;
 		next_unary = true;
+	}
 	ps.next_unary = next_unary;
 	return lsym;
+}

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

 @@ -1,355 +1,349 @@
-/*	$NetBSD: pr_comment.c,v 1.166 2023/06/16 11:27:49 rillig Exp $	*/
+/*	$NetBSD: pr_comment.c,v 1.167 2023/06/17 22:28:49 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.166 2023/06/16 11:27:49 rillig Exp $");
+__RCSID("$NetBSD: pr_comment.c,v 1.167 2023/06/17 22:28:49 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)
+com_add_star(void)
+{
 	if (opt.star_comment_cont)
 		buf_add_chars(&com, " * ", 3);
+}
 static bool
 fits_in_one_line(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 ind = ind_add(ps.comment_ind + 3,
 			    start, (size_t)(p - start));
 			ind += p == start || ch_isblank(p[-1]) ? 2 : 3;
 			return ind <= max_line_length;
+		}
+	}
 	return false;
+}
 static void
 analyze_comment(bool *p_may_wrap, bool *p_delim, int *p_line_length)
+{
 	bool may_wrap = true;
-	bool delim = false;
+	bool delim = false;	// only relevant if may_wrap
 	int ind;
 	int line_length = opt.max_line_length;
 	if (inp_p - inp.s == 2 && !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_blank_line)
 				delim = true;
 		} else {
-			int target_ind = code.len > 0
+			int min_ind = code.len > 0
 			    ? ind_add(compute_code_indent(), code.s, code.len)
 			    : ind_add(compute_label_indent(), lab.s, lab.len);
 			ind = ps.line_has_decl || ps.ind_level == 0
 			    ? opt.decl_comment_column - 1
 			    : opt.comment_column - 1;
-			if (ind <= target_ind)
+			if (ind <= min_ind)
-				ind = next_tab(target_ind);
+				ind = next_tab(min_ind);
 			if (ind + 25 > line_length)
 				line_length = ind + 25;
+		}
+	}
 	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.comment_shift = -ind_add(0, inp.s, len);
 	} else {
 		ps.comment_shift = 0;
 		if (!(inp_p[0] == '\t' && !ch_isblank(inp_p[1])))
 			while (ch_isblank(inp_p[0]))
 				inp_p++;
+	}
 	ps.comment_ind = ind;
 	*p_may_wrap = may_wrap;
 	*p_delim = delim;
 	*p_line_length = line_length;
+}
 static void
 copy_comment_start(bool may_wrap, bool *delim, int line_length)
+{
 	ps.comment_cont = false;
 	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(line_length))
 			*delim = false;
 		if (*delim) {
 			output_line();
-			com_add_delim();
+			com_add_star();
+		}
+	}
+}
 static void
 copy_comment_wrap_text(int line_length, ssize_t *last_blank)
+{
-	int now_len = ind_add(ps.comment_ind, com.s, com.len);
+	int ind = ind_add(ps.comment_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++;
+		ind++;
 		if (memchr("*\n\r\b\t", inp_p[0], 6) != NULL)
 			break;
-		if (now_len >= line_length && *last_blank != -1)
+		if (ind >= line_length && *last_blank != -1)
 			break;
+	}
-	if (now_len <= line_length)
+	if (ind <= 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();
+		com_add_star();
 		return;
+	}
-	const char *last_word_s = com.s + *last_blank + 1;
+	// Move the overlong word to the next line.
 	const char *last_word = com.s + *last_blank + 1;
 	size_t last_word_len = com.len - (size_t)(*last_blank + 1);
 	com.len = (size_t)*last_blank;
 	buf_terminate(&com);
 	output_line();
-	com_add_delim();
+	com_add_star();
-	/* Assume that output_line and com_add_delim don't invalidate the
+	/* Assume that output_line and com_add_delim left the "unused" part of
-	 * "unused" part of the buffer beyond com.s + com.len. */
+	 * the now truncated buffer beyond com.s + com.len as-is. */
-	memmove(com.s + com.len, last_word_s, last_word_len);
+	memmove(com.s + com.len, last_word, last_word_len);
 	com.len += last_word_len;
 	buf_terminate(&com);
 	*last_blank = -1;
+}
 /* In a comment that is re-wrapped, handle a single newline character. */
 static bool
 copy_comment_wrap_newline(ssize_t *last_blank, bool seen_newline)
+{
 	*last_blank = -1;
 	if (seen_newline) {
 		if (com.len == 0)
 			com_add_char(' ');	/* force empty output line */
 		if (com.len > 3) {
 			output_line();
-			com_add_delim();
+			com_add_star();
+		}
 		output_line();
-		com_add_delim();
+		com_add_star();
 	} else {
 		if (!(com.len > 0 && ch_isblank(com.s[com.len - 1])))
 			com_add_char(' ');
 		*last_blank = (int)com.len - 1;
+	}
-	++line_no;
+	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
 			buf_clear(&com);
 		com_add_char(' ');
 	} else {
 		size_t len = com.len;
 		// XXX: This loop differs from the one below.
 		while (ch_isblank(com.s[len - 1]))
 			len--;
-		int end_ind = ind_add(ps.comment_ind, com.s, len);
+		if (ind_add(ps.comment_ind, com.s, len) + 3 > line_length)
 		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--;
 	buf_terminate(&com);
 	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' */
 	bool seen_newline = false;
 	for (;;) {
 		if (inp_p[0] == '\n') {
 			if (had_eof)
 				goto unterminated_comment;
 			if (!copy_comment_wrap_newline(&last_blank,
 				seen_newline))
 				break;
 			seen_newline = true;
 		} else if (inp_p[0] == '*' && inp_p[1] == '/')
 			break;
 		else {
 			copy_comment_wrap_text(line_length, &last_blank);
 			seen_newline = false;
+		}
+	}
 	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;
+			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 line_length;
 	analyze_comment(&may_wrap, &delim, &line_length);
 	copy_comment_start(may_wrap, &delim, line_length);
 	if (may_wrap)
 		copy_comment_wrap(line_length, delim);
 	else
 		copy_comment_nowrap();
+}