 @@ -1,14 +1,14 @@
-/*	$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
 @@ -28,27 +28,27 @@
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: indent.c,v 1.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,
 @@ -167,51 +167,51 @@ diag(int level, const char *msg, ...)
 /*
  * 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
 @@ -245,27 +245,27 @@ copy_to_bak_file(void)
 	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 "
 @@ -556,27 +556,27 @@ process_newline(void)
 	    && 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

 @@ -1,14 +1,14 @@
-/*	$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
 @@ -28,27 +28,27 @@
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: 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
 @@ -321,26 +321,30 @@ output_comment(void)
+	}
 	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;
 @@ -372,67 +376,69 @@ output_indented_line(void)
 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,14 +1,14 @@
-/*	$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
 @@ -28,27 +28,27 @@
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: 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},
 @@ -176,43 +176,41 @@ 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]))
 @@ -220,38 +218,38 @@ lex_word(void)
 		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;
 @@ -315,28 +313,28 @@ register_typename(const char *name)
 	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)))
 @@ -349,65 +347,67 @@ probably_function_definition(void)
 			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;
+	}
 @@ -422,27 +422,27 @@ found_typename:
 			    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;
+	}
 @@ -457,44 +457,44 @@ is_asterisk_pointer(void)
 		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))
 @@ -570,113 +570,113 @@ lexi(void)
 	/* 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,14 +1,14 @@
-/*	$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
 @@ -28,27 +28,27 @@
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: 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;
 @@ -58,27 +58,27 @@ psyms_reduce_stmt(void)
 		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];
 @@ -160,36 +160,36 @@ parse(parser_symbol psym)
 			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;
+		}
 @@ -238,26 +238,26 @@ parse(parser_symbol psym)
 	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,14 +1,14 @@
-/*	$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
 @@ -28,40 +28,40 @@
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: 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]))
 @@ -69,27 +69,27 @@ fits_in_one_line(int max_line_length)
 			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;
 @@ -97,35 +97,35 @@ analyze_comment(bool *p_may_wrap, bool *
 		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])))
 @@ -144,91 +144,95 @@ copy_comment_start(bool may_wrap, bool *
+{
 	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++;
+	}
 @@ -236,52 +240,46 @@ copy_comment_wrap_newline(ssize_t *last_
+}
 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;
 @@ -312,44 +310,40 @@ copy_comment_nowrap(void)
 			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();
+}

 @@ -1,14 +1,14 @@
-/*	$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.
 @@ -20,27 +20,27 @@
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: debug.c,v 1.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 = {
 @@ -374,19 +374,19 @@ debug_parser_state(void)
 	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