 @@ -1,14 +1,14 @@
-/* $NetBSD: lsym_comment.c,v 1.20 2023/06/10 16:43:56 rillig Exp $ */
+/* $NetBSD: lsym_comment.c,v 1.21 2023/06/14 09:31:05 rillig Exp $ */
 /*
  * Tests for the token lsym_comment, which starts a comment.
+ *
  * C11 distinguishes block comments and end-of-line comments.  Indent further
  * distinguishes box comments that are a special kind of block comments.
+ *
  * See also:
  *	opt_fc1.c
  *	lsym_comment.c
  */
 /*-
 @@ -33,27 +33,26 @@
  * - block/end-of-line comment to the right of label with code
+ *
  * - with/without opt.comment_delimiter_on_blank_line (-cdb)
  * - with/without opt.star_comment_cont (-sc)
  * - with/without opt.format_block_comments (-fbc)
  * - with varying opt.max_line_length (32, 64, 80, 140)
  * - with varying opt.unindent_displace (-d0, -d2, -d-5)
  * - with varying opt.indent_size (3, 4, 8)
  * - with varying opt.tabsize (3, 4, 8, 16)
  * - with varying opt.block_comment_max_line_length (-lc60, -lc78, -lc90)
  * - with varying opt.comment_column (-c0, -c1, -c33, -c80)
  * - with varying opt.decl_comment_column (-cd0, -cd1, -cd20, -cd33, -cd80)
  * - with/without ps.line_has_decl
  * - with/without ps.next_col_1
+ *
  * - very long comments that overflow the buffer 'com'
  * - comments that come from save_com
  * - very long word that already spills over the right margin
  * - wrap/nowrap comment containing '\n'
  * - wrap/nowrap comment containing '\f'
  * - wrap/nowrap comment containing '\t'
  * - wrap/nowrap comment containing '\b'
  */
 //indent input
 typedef enum x {
 	aaaaaaaaaaaaaaaaaaaaaa = 1 << 0,	/* test a */
 @@ -1010,28 +1009,28 @@ f(void)
 /*
  * Test for form feeds in nowrap comments.
  */
 //indent input
 /*-*/
 /*-<>*/
 //indent end
 //indent run-equals-input
 /*
- * Test two completely empty lines in a wrap comment. The second empty line
+ * In a comment that is wrapped, one or more empty lines separate paragraphs.
- * covers the condition ps.next_col_1 in copy_comment_wrap.
+ * All of these empty lines are preserved.
  */
 //indent input
 /* line 1
 line 4 */
 //indent end
 //indent run
 /*
  * line 1
+ *
+ *
 @@ -1121,13 +1120,27 @@ a>b;
 int line;	// comment line 1
 		// comment line 2
 int block;	/* comment line 1
 		 * comment line 2
 		 */
 //indent end
 //indent run -di0
 int line;			// comment line 1
 // $ XXX: This comment was probably intended to continue 'comment line 1'.
 // comment line 2
 int block;			/* comment line 1 comment line 2 */
 //indent end
 //indent input
 /*/ comment? or:not; /* */
 //indent end
 //indent run
 /* / comment? or:not; /* */
 //indent end
 //indent run -nfc1
 // $ FIXME: It's a comment, not code.
 /*/ comment ? or : not;		/* */
 //indent end

 @@ -1,14 +1,14 @@
-/*	$NetBSD: debug.c,v 1.56 2023/06/14 08:36:51 rillig Exp $	*/
+/*	$NetBSD: debug.c,v 1.57 2023/06/14 09:31:05 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.56 2023/06/14 08:36:51 rillig Exp $");
+__RCSID("$NetBSD: debug.c,v 1.57 2023/06/14 09:31:05 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
 	 */
 @@ -353,30 +353,30 @@ debug_parser_state(void)
 	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_int(nparen);
 	debug_ps_paren();
-	state.heading = "horizontal spacing for comments";
+	state.heading = "indentation of comments";
-	debug_ps_int(comment_delta);
+	debug_ps_int(comment_ind);
-	debug_ps_int(n_comment_delta);
+	debug_ps_int(comment_shift);
-	debug_ps_int(com_ind);
+	debug_ps_bool(comment_in_first_line);
 	state.heading = "vertical spacing";
 	debug_ps_bool(break_after_comma);
 	debug_ps_bool(force_nl);
 	debug_ps_enum(declaration, declaration_name);
 	debug_ps_bool(blank_line_after_decl);
 	state.heading = NULL;
 	debug_blank_line();
 	state.prev_ps = ps;
 	state.ps_first = false;
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: indent.h,v 1.191 2023/06/14 08:36:51 rillig Exp $	*/
+/*	$NetBSD: indent.h,v 1.192 2023/06/14 09:31:05 rillig Exp $	*/
 /*-
  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
+ *
  * Copyright (c) 2001 Jens Schweikhardt
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
 @@ -61,27 +61,27 @@
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <ctype.h>
 #include <stdbool.h>
 #include <stdio.h>
 typedef enum lexer_symbol {
 	lsym_eof,
 	lsym_preprocessing,	/* the initial '#' of a preprocessing line */
-	lsym_newline,
+	lsym_newline,		/* outside block comments */
 	lsym_comment,		/* the initial '/ *' or '//' of a comment */
 	lsym_lparen,
 	lsym_rparen,
 	lsym_lbracket,
 	lsym_rbracket,
 	lsym_lbrace,
 	lsym_rbrace,
 	lsym_period,
 	lsym_unary_op,		/* e.g. '*', '&', '-' or leading '++' */
 	lsym_sizeof,
 	lsym_offsetof,
 @@ -219,28 +219,28 @@ extern struct options {
 					 * column 1 are to be reformatted (just
 					 * like comments that begin in later
 					 * columns) */
 	bool format_block_comments;	/* whether to reformat comments that
 					 * begin with '/ * \n' */
 	bool indent_parameters;
 	int indent_size;	/* the size of one indentation level */
 	int block_comment_max_line_length;
 	int local_decl_indent;	/* like decl_indent but for locals */
 	bool lineup_to_parens_always;	/* whether to not(?) attempt to keep
 					 * lined-up code within the margin */
 	bool lineup_to_parens;	/* whether continued code within parens will be
 				 * lined up to the open paren */
-	bool proc_calls_space;	/* whether function calls look like: foo (bar)
+	bool proc_calls_space;	/* whether function calls look like 'foo (bar)'
-				 * rather than foo(bar) */
+				 * rather than 'foo(bar)' */
 	bool procnames_start_line;	/* whether the names of functions being
 					 * defined get placed in column 1 (i.e.
 					 * a newline is placed between the type
 					 * of the function and its name) */
 	bool space_after_cast;	/* "b = (int) a" vs. "b = (int)a" */
 	bool star_comment_cont;	/* whether comment continuation lines should
 				 * have stars at the beginning of each line */
 	bool swallow_optional_blank_lines;
 	bool auto_typedefs;	/* whether to recognize identifiers ending in
 				 * "_t" like typedefs */
 	int tabsize;		/* the size of a tab */
 	int max_line_length;
 	bool use_tabs;		/* set true to use tabs for spacing, false uses
 @@ -366,35 +366,32 @@ extern struct parser_state {
 				 * well as in expressions */
 	bool want_blank;	/* whether the following token should be
 				 * prefixed by a blank. (Said prefixing is
 				 * ignored in some cases.) */
 	int ind_paren_level;	/* the number of parentheses or brackets that
 				 * is used for indenting a continuation line of
 				 * a declaration, initializer or statement */
 	int nparen;		/* the number of parentheses or brackets that
 				 * are currently open; used to indent the
 				 * remaining lines of the statement,
 				 * initializer or declaration */
 	struct paren_level paren[20];
-	/* Horizontal spacing for comments */
+	/* Indentation of comments */
-	int comment_delta;	/* used to set up indentation for all lines of
+	int comment_ind;	/* indentation of the current comment */
-				 * a boxed comment after the first one */
+	int comment_shift;	/* all but the first line of a boxed comment
-	int n_comment_delta;	/* remembers how many columns there were before
+				 * are shifted this much to the right */
-				 * the start of a box comment so that
+	bool comment_in_first_line;
 				 * forthcoming lines of the comment are
 				 * indented properly */
 	int com_ind;		/* indentation of the current comment */
 	/* Vertical spacing */
 	bool break_after_comma;	/* whether to add a newline after the next
 				 * comma; used in declarations but not in
 				 * initializer lists */
 	bool force_nl;		/* whether the next token is forced to go to a
 				 * new line; used after 'if (expr)' and in
 				 * similar situations; tokens like '{' may
 				 * ignore this */
 	enum declaration {
 		decl_no,	/* no declaration anywhere nearby */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: io.c,v 1.217 2023/06/10 21:36:38 rillig Exp $	*/
+/*	$NetBSD: io.c,v 1.218 2023/06/14 09:31:05 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.217 2023/06/10 21:36:38 rillig Exp $");
+__RCSID("$NetBSD: io.c,v 1.218 2023/06/14 09:31:05 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
 @@ -284,55 +284,57 @@ output_line_code(void)
 			    i, paren_ind, ps.paren[i].indent, target_ind + 1);
+		}
+	}
 	if (lab.len > 0 && target_ind <= out_ind)
 		write_range(" ", 1);
 	write_indent(target_ind);
 	write_range(code.s, code.len);
+}
 static void
 output_comment(void)
+{
-	int target_ind = ps.com_ind + ps.comment_delta;
+	int target_ind = ps.comment_ind;
 	const char *p;
-	/* consider original indentation in case this is a box comment */
+	if (!ps.comment_in_first_line)
 		target_ind += ps.comment_shift;
 	ps.comment_in_first_line = false;
 	/* 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));
 	ps.comment_delta = ps.n_comment_delta;
+}
 static void
 output_indented_line(void)
+{
 	if (lab.len == 0 && code.len == 0 && com.len == 0)
 		out.line_kind = lk_blank;
 	if (want_blank_line() && newlines < 2
 	    && out.line_kind != lk_blank)
 		add_buffered_newline();
 	/* This kludge aligns function definitions correctly. */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: pr_comment.c,v 1.163 2023/06/14 08:36:51 rillig Exp $	*/
+/*	$NetBSD: pr_comment.c,v 1.164 2023/06/14 09:31:05 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,66 +28,65 @@
  * 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.163 2023/06/14 08:36:51 rillig Exp $");
+__RCSID("$NetBSD: pr_comment.c,v 1.164 2023/06/14 09:31:05 rillig Exp $");
 #include <string.h>
 #include "indent.h"
 static void
 com_add_char(char ch)
+{
 	buf_add_char(&com, ch);
+}
 static void
 com_add_delim(void)
+{
 	if (opt.star_comment_cont)
 		buf_add_chars(&com, " * ", 3);
+}
 static bool
-fits_in_one_line(int com_ind, int max_line_length)
+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 len = ind_add(com_ind + 3,
+			int ind = ind_add(ps.comment_ind + 3,
 			    start, (size_t)(p - start));
-			len += p == start || ch_isblank(p[-1]) ? 2 : 3;
+			ind += p == start || ch_isblank(p[-1]) ? 2 : 3;
-			return len <= max_line_length;
+			return ind <= max_line_length;
+		}
+	}
 	return false;
+}
 static void
-analyze_comment(bool *p_may_wrap, bool *p_delim,
+analyze_comment(bool *p_may_wrap, bool *p_delim, int *p_line_length)
     int *p_ind, int *p_line_length)
+{
 	bool may_wrap = true;
 	bool delim = false;
 	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))
 @@ -112,70 +111,68 @@ analyze_comment(bool *p_may_wrap, bool *
 			    ? 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)
 				ind = next_tab(target_ind);
 			if (ind + 25 > line_length)
 				line_length = ind + 25;
+		}
+	}
 	ps.com_ind = ind;
 	if (!may_wrap) {
 		/* Find out how much indentation there was originally, because
 		 * that much will have to be ignored by output_line. */
 		size_t len = (size_t)(inp_p - 2 - inp.s);
-		ps.n_comment_delta = -ind_add(0, inp.s, len);
+		ps.comment_shift = -ind_add(0, inp.s, len);
 	} else {
-		ps.n_comment_delta = 0;
+		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_ind = ind;
 	*p_line_length = line_length;
+}
 static void
-copy_comment_start(bool may_wrap, bool *delim, int ind, int line_length)
+copy_comment_start(bool may_wrap, bool *delim, int line_length)
+{
-	ps.comment_delta = 0;
+	ps.comment_in_first_line = true;
 	com_add_char('/');
 	com_add_char(token.s[token.len - 1]);	/* either '*' or '/' */
 	if (may_wrap) {
 		if (!ch_isblank(inp_p[0]))
 			com_add_char(' ');
-		if (*delim && fits_in_one_line(ind, line_length))
+		if (*delim && fits_in_one_line(line_length))
 			*delim = false;
 		if (*delim) {
 			output_line();
 			com_add_delim();
+		}
+	}
+}
 static void
 copy_comment_wrap_text(int line_length, ssize_t *last_blank)
+{
-	int now_len = ind_add(ps.com_ind, com.s, com.len);
+	int now_len = 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++;
 		if (memchr("*\n\r\b\t", inp_p[0], 6) != NULL)
 			break;
 		if (now_len >= line_length && *last_blank != -1)
 			break;
+	}
 	if (now_len <= line_length)
 @@ -194,40 +191,39 @@ copy_comment_wrap_text(int line_length,
 	size_t last_word_len = com.len - (size_t)(*last_blank + 1);
 	com.len = (size_t)*last_blank;
 	output_line();
 	com_add_delim();
 	/* Assume that output_line and com_add_delim don't invalidate the
 	 * "unused" part of the buffer beyond com.s + com.len. */
 	memmove(com.s + com.len, last_word_s, last_word_len);
 	com.len += last_word_len;
 	*last_blank = -1;
+}
 static bool
-copy_comment_wrap_newline(ssize_t *last_blank, bool *seen_newline)
+copy_comment_wrap_newline(ssize_t *last_blank, bool seen_newline)
+{
 	*last_blank = -1;
-	if (*seen_newline) {
+	if (seen_newline) {
 		if (com.len == 0)
 			com_add_char(' ');	/* force empty output line */
 		if (com.len > 3) {
 			output_line();
 			com_add_delim();
+		}
 		output_line();
 		com_add_delim();
 	} else {
 		*seen_newline = true;
 		if (!(com.len > 0 && ch_isblank(com.s[com.len - 1])))
 			com_add_char(' ');
 		*last_blank = (int)com.len - 1;
+	}
 	++line_no;
 	/* flush any blanks and/or tabs at start of next line */
 	inp_skip();		/* '\n' */
 	while (ch_isblank(inp_p[0]))
 		inp_p++;
 	if (inp_p[0] == '*' && inp_p[1] == '/')
 		return false;
 	if (inp_p[0] == '*') {
 @@ -242,27 +238,27 @@ 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;
 		while (ch_isblank(com.s[len - 1]))
 			len--;
-		int end_ind = ind_add(ps.com_ind, com.s, len);
+		int end_ind = ind_add(ps.comment_ind, com.s, len);
 		if (end_ind + 3 > line_length)
 			output_line();
+	}
 	while (com.len >= 2
 	    && ch_isblank(com.s[com.len - 1])
 	    && ch_isblank(com.s[com.len - 2]))
 		com.len--;
 	buf_terminate(&com);
 	inp_p += 2;
 	if (com.len > 0 && ch_isblank(com.s[com.len - 1]))
 		buf_add_chars(&com, "*/", 2);
 @@ -277,37 +273,37 @@ copy_comment_wrap_finish(int line_length
  * 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))
+			    seen_newline))
-				goto end_of_comment;
+				break;
 			seen_newline = true;
 		} else if (inp_p[0] == '*' && inp_p[1] == '/')
-			goto end_of_comment;
+			break;
 		else {
 			copy_comment_wrap_text(line_length, &last_blank);
 			seen_newline = false;
+		}
+	}
 end_of_comment:
 	copy_comment_wrap_finish(line_length, delim);
 	return;
 unterminated_comment:
 	diag(1, "Unterminated comment");
 	output_line();
+}
 static void
 copy_comment_nowrap(void)
+{
 	char kind = token.s[token.len - 1];
 @@ -338,22 +334,22 @@ copy_comment_nowrap(void)
 		    && kind == '*')
 			return;
+	}
+}
 /*
  * Scan, reformat and output a single comment, which is either a block comment
  * starting with '/' '*' or an end-of-line comment starting with '//'.
  */
 void
 process_comment(void)
+{
 	bool may_wrap, delim;
-	int ind, line_length;
+	int line_length;
-	analyze_comment(&may_wrap, &delim, &ind, &line_length);
+	analyze_comment(&may_wrap, &delim, &line_length);
-	copy_comment_start(may_wrap, &delim, ind, line_length);
+	copy_comment_start(may_wrap, &delim, line_length);
 	if (may_wrap)
 		copy_comment_wrap(line_length, delim);
 	else
 		copy_comment_nowrap();
+}

 @@ -1,38 +1,55 @@
-/* $NetBSD: psym_decl.c,v 1.4 2022/04/24 10:36:37 rillig Exp $ */
+/* $NetBSD: psym_decl.c,v 1.5 2023/06/14 09:31:05 rillig Exp $ */
 /*
  * Tests for the parser symbol psym_decl, which represents a declaration.
+ *
  * Since C99, declarations and statements can be mixed in blocks.
+ *
- * A label can be followed by a statement but not by a declaration.
+ * In C, a label can be followed by a statement but not by a declaration.
+ *
  * Indent distinguishes global and local declarations.
+ *
  * Declarations can be for functions or for variables.
  */
 // TODO: prove that psym_decl can only ever occur at the top of the stack.
 // TODO: delete decl_level if the above is proven.
 //indent input
 int global_var;
 int global_array = [1,2,3,4];
 int global_array = [
 ,2,
 ,
 ,
 ];
 //indent end
 //indent run -di0
 int global_var;
 int global_array = [1, 2, 3, 4];
 int global_array = [
 		    ,2,
 ,
 ,
 ];
 //indent end
 // Declarations can be nested.
 //indent input
 struct level_1 {
 	union level_2 {
 		enum level_3 {
 			level_3_c_1,
 			level_3_c_2,
 		}		level_3;
 	}		level_2;
 } level_1;
 //indent end
 // The outermost declarator 'level_1' is indented as a global variable.
 // The inner declarators 'level_2' and 'level_3' are indented as local
 // variables.
 // XXX: This is inconsistent, as in practice, struct members are usually
 // aligned, while local variables aren't.
 //indent run-equals-input -ldi0