 @@ -1,14 +1,14 @@
-/*	$NetBSD: io.c,v 1.210 2023/06/10 07:42:41 rillig Exp $	*/
+/*	$NetBSD: io.c,v 1.211 2023/06/10 07:48:55 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.210 2023/06/10 07:42:41 rillig Exp $");
+__RCSID("$NetBSD: io.c,v 1.211 2023/06/10 07:48:55 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 wrote_newlines = 2;	/* 0 in the middle of a line, 1 after a
 					 * single '\n', > 1 means there were (n
 @@ -98,95 +98,79 @@ inp_skip(void)
 		inp_read_line();
+}
 char
 inp_next(void)
+{
 	char ch = inp_p[0];
 	inp_skip();
 	return ch;
+}
 static void
-output_newline(void)
+write_newline(void)
+{
 	buffered_blank_lines++;
 	wrote_newlines++;
 	out_ind = 0;
+}
 static void
 write_buffered_blank_lines(void)
+{
 	for (; buffered_blank_lines > 0; buffered_blank_lines--) {
 		fputc('\n', output);
 		debug_println("output_newline");
+	}
+}
 static void
-output_range(const char *s, size_t len)
+write_range(const char *s, size_t len)
+{
 	write_buffered_blank_lines();
 	fwrite(s, 1, len, output);
 	debug_vis_range("output_range \"", s, len, "\"\n");
 	for (size_t i = 0; i < len; i++)
 		wrote_newlines = s[i] == '\n' ? wrote_newlines + 1 : 0;
 	out_ind = ind_add(out_ind, s, len);
+}
 static void
-output_indent(int new_ind)
+write_indent(int new_ind)
+{
 	write_buffered_blank_lines();
 	int ind = out_ind;
 	if (opt.use_tabs) {
 		int n = new_ind / opt.tabsize - ind / opt.tabsize;
 		if (n > 0) {
 			ind = ind - ind % opt.tabsize + n * opt.tabsize;
 			while (n-- > 0)
 				fputc('\t', output);
 			wrote_newlines = 0;
+		}
+	}
 	for (; ind < new_ind; ind++) {
 		fputc(' ', output);
 		wrote_newlines = 0;
+	}
 	debug_println("output_indent %d", ind);
 	out_ind = ind;
+}
 void
 output_finish(void)
 	if (lab.len > 0 || code.len > 0 || com.len > 0)
 		output_line();
 	if (indent_enabled == indent_on) {
 		if (buffered_blank_lines > 1)
 			buffered_blank_lines = 1;
 		write_buffered_blank_lines();
 	} else {
 		indent_enabled = indent_last_off_line;
 		output_line();
 	fflush(output);
 static bool
 want_blank_line(void)
+{
 	debug_println("%s: %s -> %s", __func__,
 	    line_kind_name[out.prev_line_kind], line_kind_name[out.line_kind]);
 	if (ps.blank_line_after_decl && ps.declaration == decl_no) {
 		ps.blank_line_after_decl = false;
 		return true;
+	}
 	if (opt.blanklines_around_conditional_compilation) {
 		if (out.prev_line_kind != lk_if && out.line_kind == lk_if)
 			return true;
 @@ -226,28 +210,28 @@ compute_case_label_indent(void)
 int
 compute_label_indent(void)
+{
 	if (out.line_kind == lk_case_or_default)
 		return compute_case_label_indent();
 	if (lab.s[0] == '#')
 		return 0;
 	return opt.indent_size * (ps.ind_level - 2);
+}
 static void
 output_line_label(void)
+{
-	output_indent(compute_label_indent());
+	write_indent(compute_label_indent());
-	output_range(lab.s, lab.len);
+	write_range(lab.s, lab.len);
+}
 static int
 compute_code_indent_lineup(int base_ind)
+{
 	int ind = paren_indent;
 	int overflow = ind_add(ind, code.s, code.len) - opt.max_line_length;
 	if (overflow >= 0
 	    && ind_add(base_ind, code.s, code.len) < opt.max_line_length) {
 		ind -= overflow + 2;
 		if (ind < base_ind)
 			ind = base_ind;
+	}
 @@ -290,112 +274,112 @@ output_line_code(void)
 	int target_ind = compute_code_indent();
 	for (int i = 0; i < ps.nparen; i++) {
 		int paren_ind = ps.paren[i].indent;
 		if (paren_ind >= 0) {
 			ps.paren[i].indent = -1 - (paren_ind + target_ind);
 			debug_println(
 			    "setting paren_indents[%d] from %d to %d "
 			    "for column %d",
 			    i, paren_ind, ps.paren[i].indent, target_ind + 1);
+		}
+	}
 	if (lab.len > 0 && target_ind <= out_ind)
-		output_range(" ", 1);
+		write_range(" ", 1);
-	output_indent(target_ind);
+	write_indent(target_ind);
-	output_range(code.s, code.len);
+	write_range(code.s, code.len);
+}
 static void
 output_line_comment(void)
+{
 	int target_ind = ps.com_ind + ps.comment_delta;
 	const char *p;
 	/* consider original indentation in case this is a box comment */
 	for (p = com.s; *p == '\t'; p++)
 		target_ind += opt.tabsize;
 	for (; target_ind < 0; p++) {
 		if (*p == ' ')
 			target_ind++;
 		else if (*p == '\t')
 			target_ind = next_tab(target_ind);
 		else {
 			target_ind = 0;
 			break;
+		}
+	}
 	if (out_ind > target_ind)
-		output_newline();
+		write_newline();
 	while (com.s + com.len > p && ch_isspace(com.s[com.len - 1]))
 		com.len--;
-	output_indent(target_ind);
+	write_indent(target_ind);
-	output_range(p, com.len - (size_t)(p - com.s));
+	write_range(p, com.len - (size_t)(p - com.s));
 	ps.comment_delta = ps.n_comment_delta;
+}
 /*
  * Write a line of formatted source to the output file. The line consists of
  * the label, the code and the comment.
  */
 void
 output_line(void)
+{
 	debug_blank_line();
 	debug_printf("%s", __func__);
 	debug_buffers();
 	if (indent_enabled == indent_on) {
 		if (lab.len == 0 && code.len == 0 && com.len == 0)
 			out.line_kind = lk_blank;
 		if (want_blank_line() && wrote_newlines < 2
 		    && out.line_kind != lk_blank)
-			output_newline();
+			write_newline();
 		/* This kludge aligns function definitions correctly. */
 		if (ps.ind_level == 0)
 			ps.in_stmt_cont = false;
 		if (opt.blank_line_after_decl && ps.declaration == decl_end
 		    && ps.psyms.top > 1) {
 			ps.declaration = decl_no;
 			ps.blank_line_after_decl = true;
+		}
 		if (opt.swallow_optional_blanklines
 		    && out.line_kind == lk_blank
 		    && is_blank_line_optional())
 			goto prepare_next_line;
 		if (lab.len > 0)
 			output_line_label();
 		if (code.len > 0)
 			output_line_code();
 		if (com.len > 0)
 			output_line_comment();
-		output_newline();
+		write_newline();
 		out.prev_line_kind = out.line_kind;
+	}
 	if (indent_enabled == indent_last_off_line) {
 		indent_enabled = indent_on;
-		output_range(out.indent_off_text.s, out.indent_off_text.len);
+		write_range(out.indent_off_text.s, out.indent_off_text.len);
 		out.indent_off_text.len = 0;
+	}
 prepare_next_line:
 	lab.len = 0;
 	code.len = 0;
 	com.len = 0;
 	ps.line_has_decl = ps.in_decl;
 	ps.line_has_func_def = false;
 	// XXX: don't reset in_stmt_cont here; see process_colon_question.
 	ps.in_stmt_cont = ps.in_stmt_or_decl
 	    && !ps.in_decl && ps.init_level == 0;
 @@ -406,13 +390,29 @@ prepare_next_line:
 		&& ps.nparen > 0))
 		ps.ind_level = ps.ind_level_follow;
 	ps.line_start_nparen = ps.nparen;
 	ps.want_blank = false;
 	if (ps.nparen > 0) {
 		/* TODO: explain what negative indentation means */
 		paren_indent = -1 - ps.paren[ps.nparen - 1].indent;
 		debug_println("paren_indent is now %d", paren_indent);
+	}
 	out.line_kind = lk_other;
+}
 void
 output_finish(void)
+{
 	if (lab.len > 0 || code.len > 0 || com.len > 0)
 		output_line();
 	if (indent_enabled == indent_on) {
 		if (buffered_blank_lines > 1)
 			buffered_blank_lines = 1;
 		write_buffered_blank_lines();
 	} else {
 		indent_enabled = indent_last_off_line;
 		output_line();
+	}
 	fflush(output);
+}