 @@ -1,1070 +1,1083 @@
-/*	$NetBSD: indent.c,v 1.352 2023/06/10 08:17:04 rillig Exp $	*/
+/*	$NetBSD: indent.c,v 1.353 2023/06/10 12:59:31 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.352 2023/06/10 08:17:04 rillig Exp $");
+__RCSID("$NetBSD: indent.c,v 1.353 2023/06/10 12:59:31 rillig Exp $");
 #include <sys/param.h>
 #include <err.h>
 #include <fcntl.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include "indent.h"
 struct options opt = {
 	.brace_same_line = true,
 	.comment_delimiter_on_blankline = true,
 	.cuddle_else = true,
 	.comment_column = 33,
 	.decl_indent = 16,
 	.else_if_in_same_line = true,
 	.function_brace_split = true,
 	.format_col1_comments = true,
 	.format_block_comments = true,
 	.indent_parameters = true,
 	.indent_size = 8,
 	.local_decl_indent = -1,
 	.lineup_to_parens = true,
 	.procnames_start_line = true,
 	.star_comment_cont = true,
 	.tabsize = 8,
 	.max_line_length = 78,
 	.use_tabs = true,
 };
 struct parser_state ps;
 struct buffer token;
 struct buffer lab;
 struct buffer code;
 struct buffer com;
 bool found_err;
 bool had_eof;
 int line_no = 1;
 static int ifdef_level;
 static struct parser_state state_stack[5];
 FILE *input;
 FILE *output;
 static const char *in_name = "Standard Input";
 static const char *backup_suffix = ".BAK";
 static char bakfile[MAXPATHLEN] = "";
 void *
 nonnull(void *p)
+{
 	if (p == NULL)
 		err(EXIT_FAILURE, NULL);
 	return p;
+}
 static void
 buf_expand(struct buffer *buf, size_t add_size)
+{
 	buf->cap = buf->cap + add_size + 400;
 	buf->s = nonnull(realloc(buf->s, buf->cap));
+}
 #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;
 		else
 			++ind;
+	}
 	return ind;
+}
 static void
 init_globals(void)
+{
 	ps.psyms.sym[0] = psym_stmt_list;
 	ps.prev_lsym = lsym_semicolon;
 	ps.next_col_1 = true;
 	ps.lbrace_kind = psym_lbrace_block;
 	const char *suffix = getenv("SIMPLE_BACKUP_SUFFIX");
 	if (suffix != NULL)
 		backup_suffix = suffix;
+}
 static void
 load_profiles(int argc, char **argv)
+{
 	const char *profile_name = NULL;
 	for (int i = 1; i < argc; ++i) {
 		const char *arg = argv[i];
 		if (strcmp(arg, "-npro") == 0)
 			return;
 		if (arg[0] == '-' && arg[1] == 'P' && arg[2] != '\0')
 			profile_name = arg + 2;
+	}
 	load_profile_files(profile_name);
+}
 /*
  * Copy the input file to the backup file, then make the backup file the input
  * and the original input file the output.
  */
 static void
 bakcopy(void)
+{
 	ssize_t n;
 	int bak_fd;
 	char buff[8 * 1024];
 	const char *last_slash = strrchr(in_name, '/');
 	snprintf(bakfile, sizeof(bakfile), "%s%s",
 	    last_slash != NULL ? last_slash + 1 : in_name, backup_suffix);
 	/* copy in_name to backup file */
 	bak_fd = creat(bakfile, 0600);
 	if (bak_fd < 0)
 		err(1, "%s", bakfile);
 	while ((n = read(fileno(input), buff, sizeof(buff))) > 0)
 		if (write(bak_fd, buff, (size_t)n) != n)
 			err(1, "%s", bakfile);
 	if (n < 0)
 		err(1, "%s", in_name);
 	close(bak_fd);
 	(void)fclose(input);
 	/* re-open backup file as the input file */
 	input = fopen(bakfile, "r");
 	if (input == NULL)
 		err(1, "%s", bakfile);
 	/* now the original input file will be the output */
 	output = fopen(in_name, "w");
 	if (output == NULL) {
 		unlink(bakfile);
 		err(1, "%s", in_name);
+	}
+}
 static void
 parse_command_line(int argc, char **argv)
+{
 	for (int i = 1; i < argc; ++i) {
 		const char *arg = argv[i];
 		if (arg[0] == '-') {
 			set_option(arg, "Command line");
 		} else if (input == NULL) {
 			in_name = arg;
 			if ((input = fopen(in_name, "r")) == NULL)
 				err(1, "%s", in_name);
 		} else if (output == NULL) {
 			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)
 		bakcopy();
 	if (opt.comment_column <= 1)
 		opt.comment_column = 2;	/* don't put normal comments in column
 					 * 1, see opt.format_col1_comments */
 	if (opt.block_comment_max_line_length <= 0)
 		opt.block_comment_max_line_length = opt.max_line_length;
 	if (opt.local_decl_indent < 0)
 		opt.local_decl_indent = opt.decl_indent;
 	if (opt.decl_comment_column <= 0)
 		opt.decl_comment_column = opt.left_justify_decl
 		    ? (opt.comment_column <= 10 ? 2 : opt.comment_column - 8)
 		    : opt.comment_column;
 	if (opt.continuation_indent == 0)
 		opt.continuation_indent = opt.indent_size;
+}
 static void
 set_initial_indentation(void)
+{
 	inp_read_line();
 	int ind = 0;
 	for (const char *p = inp_p;; p++) {
 		if (*p == ' ')
 			ind++;
 		else if (*p == '\t')
 			ind = next_tab(ind);
 		else
 			break;
+	}
 	ps.ind_level = ps.ind_level_follow = ind / opt.indent_size;
+}
 static void
 maybe_break_line(lexer_symbol lsym)
+{
 	if (!ps.force_nl)
 		return;
 	if (lsym == lsym_semicolon)
 		return;
 	if (lsym == lsym_lbrace && opt.brace_same_line
 	    && ps.prev_lsym != lsym_lbrace)
 		return;
 	output_line();
 	ps.force_nl = false;
+}
 static void
 move_com_to_code(lexer_symbol lsym)
+{
 	if (ps.want_blank)
 		buf_add_char(&code, ' ');
 	buf_add_buf(&code, &com);
-	com.len = 0;
+	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_outside_parentheses
 	    && lsym != lsym_word
 	    && lsym != lsym_lbrace)
 		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 = base + (int)code.len;
 	int target = base + decl_ind;
 	size_t orig_code_len = code.len;
 	if (tabs_to_var)
 		for (int next; (next = next_tab(ind)) <= target; ind = next)
 			buf_add_char(&code, '\t');
 	for (; ind < target; ind++)
 		buf_add_char(&code, ' ');
 	if (code.len == orig_code_len && ps.want_blank) {
 		buf_add_char(&code, ' ');
 		ps.want_blank = false;
+	}
 	ps.decl_indent_done = true;
+}
 static bool
 is_function_pointer_declaration(void)
+{
 	return ps.in_decl
 	    && !ps.in_init
 	    && !ps.decl_indent_done
 	    && !ps.line_has_func_def
 	    && ps.line_start_nparen == 0;
+}
 static int
 process_eof(void)
+{
 	output_finish();
 	if (ps.psyms.top > 1)	/* 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
 process_preprocessing(void)
+{
 	if (lab.len > 0 || code.len > 0 || com.len > 0)
 		output_line();
 	read_preprocessing_line();
 	const char *dir = lab.s + 1, *line_end = lab.s + lab.len;
 	while (dir < line_end && ch_isblank(*dir))
 		dir++;
 	size_t dir_len = 0;
 	while (dir + dir_len < line_end && ch_isalpha(dir[dir_len]))
 		dir_len++;
 	if (dir_len >= 2 && memcmp(dir, "if", 2) == 0) {
 		if ((size_t)ifdef_level < array_length(state_stack))
 			state_stack[ifdef_level++] = ps;
 		else
 			diag(1, "#if stack overflow");
 		out.line_kind = lk_if;
 	} else if (dir_len >= 2 && memcmp(dir, "el", 2) == 0) {
 		if (ifdef_level <= 0)
 			diag(1, dir[2] == 'i'
 			    ? "Unmatched #elif" : "Unmatched #else");
 		else
 			ps = state_stack[ifdef_level - 1];
 	} else if (dir_len == 5 && memcmp(dir, "endif", 5) == 0) {
 		if (ifdef_level <= 0)
 			diag(1, "Unmatched #endif");
 		else
 			ifdef_level--;
 		out.line_kind = lk_endif;
+	}
+}
 static void
 process_newline(void)
+{
 	if (ps.prev_lsym == lsym_comma
 	    && ps.nparen == 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.top] == psym_switch_expr
 	    && opt.brace_same_line) {
 		ps.force_nl = true;
 		goto stay_in_line;
+	}
 	output_line();
 stay_in_line:
 	++line_no;
+}
 static bool
 want_blank_before_lparen(void)
+{
 	if (!ps.want_blank)
 		return false;
 	if (opt.proc_calls_space)
 		return true;
 	if (ps.prev_lsym == lsym_rparen || ps.prev_lsym == lsym_rbracket)
 		return false;
 	if (ps.prev_lsym == lsym_offsetof)
 		return false;
 	if (ps.prev_lsym == lsym_sizeof)
 		return opt.blank_after_sizeof;
 	if (ps.prev_lsym == lsym_word || ps.prev_lsym == lsym_funcname)
 		return false;
 	return true;
+}
 static void
 process_lparen(void)
+{
 	if (++ps.nparen == array_length(ps.paren)) {
 		diag(0, "Reached internal limit of %zu unclosed parentheses",
 		    array_length(ps.paren));
 		ps.nparen--;
+	}
 	if (is_function_pointer_declaration())
 		indent_declarator(ps.decl_ind, ps.tabs_to_var);
 	else if (want_blank_before_lparen())
 		buf_add_char(&code, ' ');
 	ps.want_blank = false;
 	buf_add_char(&code, token.s[0]);
 	if (opt.extra_expr_indent && ps.spaced_expr_psym != psym_0)
 		ps.extra_expr_indent = eei_maybe;
 	if (ps.in_var_decl && ps.psyms.top <= 2 && !ps.in_init) {
 		parse(psym_stmt);	/* prepare for function definition */
 		ps.in_var_decl = false;
+	}
 	int indent = ind_add(0, code.s, code.len);
 	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;
 	ps.paren[ps.nparen - 1].indent = indent;
 	ps.paren[ps.nparen - 1].cast = cast;
 	debug_println("paren_indents[%d] is now %s%d",
 	    ps.nparen - 1, paren_level_cast_name[cast], indent);
+}
 static void
 process_rparen(void)
+{
 	if (ps.nparen == 0) {
 		diag(0, "Extra '%c'", *token.s);
 		goto unbalanced;
+	}
 	enum paren_level_cast cast = ps.paren[--ps.nparen].cast;
 	if (ps.in_func_def_params || (ps.line_has_decl && !ps.in_init))
 		cast = cast_no;
 	ps.prev_paren_was_cast = cast == cast_maybe;
 	if (cast == cast_maybe) {
 		ps.next_unary = true;
 		ps.want_blank = opt.space_after_cast;
 	} else
 		ps.want_blank = true;
 	if (code.len == 0)
 		ps.line_start_nparen = ps.nparen;
 unbalanced:
 	buf_add_char(&code, token.s[0]);
 	if (ps.spaced_expr_psym != psym_0 && ps.nparen == 0) {
 		if (ps.extra_expr_indent == eei_maybe)
 			ps.extra_expr_indent = eei_last;
 		ps.force_nl = true;
 		ps.next_unary = true;
 		ps.in_stmt_or_decl = false;
 		parse(ps.spaced_expr_psym);
 		ps.spaced_expr_psym = psym_0;
 		ps.want_blank = true;
 		out.line_kind = lk_stmt_head;
+	}
+}
 static void
 process_lbracket(void)
+{
 	if (++ps.nparen == array_length(ps.paren)) {
 		diag(0, "Reached internal limit of %zu unclosed parentheses",
 		    array_length(ps.paren));
 		ps.nparen--;
+	}
 	if (code.len > 0
 	    && (ps.prev_lsym == lsym_comma || ps.prev_lsym == lsym_binary_op))
 		buf_add_char(&code, ' ');
 	ps.want_blank = false;
 	buf_add_char(&code, token.s[0]);
 	int indent = ind_add(0, code.s, code.len);
 	ps.paren[ps.nparen - 1].indent = indent;
 	ps.paren[ps.nparen - 1].cast = cast_no;
 	debug_println("paren_indents[%d] is now %d", ps.nparen - 1, indent);
+}
 static void
 process_rbracket(void)
+{
 	if (ps.nparen == 0) {
 		diag(0, "Extra '%c'", *token.s);
 		goto unbalanced;
+	}
 	--ps.nparen;
 	ps.want_blank = true;
 	if (code.len == 0)
 		ps.line_start_nparen = ps.nparen;
 unbalanced:
 	buf_add_char(&code, token.s[0]);
+}
 static void
 process_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.force_nl = true;
 	else
 		ps.init_level++;
 	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.nparen > 0 && ps.init_level == 0) {
 		diag(1, "Unbalanced parentheses");
 		ps.nparen = 0;
 		if (ps.spaced_expr_psym != psym_0) {
 			parse(ps.spaced_expr_psym);
 			ps.spaced_expr_psym = psym_0;
 			ps.ind_level = ps.ind_level_follow;
+		}
+	}
 	if (code.len == 0)
 		ps.in_stmt_cont = false;	/* don't indent the '{' itself
 						 */
 	if (ps.in_decl && ps.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;	/* we can't be in the middle of
 						 * a declaration, so don't do
 						 * special indentation of
 						 * comments */
 		ps.in_func_def_params = false;
 		ps.in_decl = false;
+	}
 	ps.decl_ind = 0;
 	parse(ps.lbrace_kind);
 	if (ps.want_blank)
 		buf_add_char(&code, ' ');
 	ps.want_blank = false;
 	buf_add_char(&code, '{');
 	ps.declaration = decl_no;
+}
 static void
 process_rbrace(void)
+{
 	if (ps.nparen > 0 && ps.init_level == 0) {
 		diag(1, "Unbalanced parentheses");
 		ps.nparen = 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.in_stmt_cont = false;
 	if (ps.decl_level > 0) {	/* multi-level structure declaration */
 		ps.decl_ind = ps.di_stack[--ps.decl_level];
 		if (ps.decl_level == 0 && !ps.in_func_def_params) {
 			ps.declaration = decl_begin;
 			ps.decl_ind = ps.ind_level == 0
 			    ? opt.decl_indent : opt.local_decl_indent;
+		}
 		ps.in_decl = true;
+	}
 	if (ps.psyms.top == 2)
 		out.line_kind = lk_func_end;
 	parse(psym_rbrace);
 	if (!ps.in_var_decl
 	    && ps.psyms.sym[ps.psyms.top] != psym_do_stmt
 	    && ps.psyms.sym[ps.psyms.top] != psym_if_expr_stmt)
 		ps.force_nl = true;
+}
 static void
 process_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);
 		ps.want_blank = false;
 	} 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.line_has_func_def && !ps.in_init &&
 	    !ps.decl_indent_done && ps.line_start_nparen == 0) {
 		/* indent leading commas and not the actual identifiers */
 		indent_declarator(ps.decl_ind - 1, ps.tabs_to_var);
+	}
 	buf_add_char(&code, ',');
 	if (ps.nparen == 0) {
 		if (ps.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.force_nl = true;
+	}
+}
 static void
 process_colon_label(void)
+{
 	buf_add_buf(&lab, &code);
 	buf_add_char(&lab, ':');
-	code.len = 0;
+	buf_clear(&code);
 	if (ps.seen_case)
 		out.line_kind = lk_case_or_default;
 	ps.in_stmt_or_decl = false;
 	ps.force_nl = ps.seen_case;
 	ps.seen_case = false;
 	ps.want_blank = false;
+}
 static void
 process_colon_other(void)
+{
 	buf_add_char(&code, ':');
 	ps.want_blank = 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.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.line_start_nparen == 0) {
 		/* indent stray semicolons in declarations */
 		indent_declarator(ps.decl_ind - 1, ps.tabs_to_var);
+	}
 	ps.in_decl = ps.decl_level > 0;	/* if we were in a first level
 					 * structure declaration before, we
 					 * aren't anymore */
 	if (ps.nparen > 0 && ps.spaced_expr_psym != psym_for_exprs) {
 		/* There were unbalanced parentheses in the statement. It is a
 		 * bit complicated, because the semicolon might be in a for
 		 * statement. */
 		diag(1, "Unbalanced parentheses");
 		ps.nparen = 0;
 		if (ps.spaced_expr_psym != psym_0) {
 			parse(ps.spaced_expr_psym);
 			ps.spaced_expr_psym = psym_0;
+		}
+	}
 	buf_add_char(&code, ';');
 	ps.want_blank = true;
 	ps.in_stmt_or_decl = ps.nparen > 0;
 	ps.decl_ind = 0;
 	if (ps.spaced_expr_psym == psym_0) {
 		parse(psym_stmt);
 		ps.force_nl = true;
+	}
+}
 static void
 process_type_outside_parentheses(void)
+{
 	parse(psym_decl);	/* let the parser worry about indentation */
 	if (ps.prev_lsym == lsym_rparen && ps.psyms.top <= 1 && code.len > 0)
 		output_line();
 	if (ps.in_func_def_params && opt.indent_parameters &&
 	    ps.decl_level == 0) {
 		ps.ind_level = ps.ind_level_follow = 1;
 		ps.in_stmt_cont = false;
+	}
 	ps.in_var_decl = /* maybe */ true;
 	ps.in_decl = ps.line_has_decl = ps.prev_lsym != lsym_typedef;
 	if (ps.decl_level <= 0)
 		ps.declaration = decl_begin;
 	int len = (int)token.len + 1;
 	int ind = ps.ind_level == 0 || ps.decl_level > 0
 	    ? opt.decl_indent	/* global variable or local member */
 	    : opt.local_decl_indent;	/* local variable */
 	ps.decl_ind = ind > 0 ? ind : len;
 	ps.tabs_to_var = opt.use_tabs && ind > 0;
+}
 static void
 process_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_init && !ps.decl_indent_done &&
 		    ps.line_start_nparen == 0) {
 			if (opt.decl_indent == 0
 			    && code.len > 0 && code.s[code.len - 1] == '}')
 				ps.decl_ind = ind_add(0, code.s, code.len) + 1;
 			indent_declarator(ps.decl_ind, ps.tabs_to_var);
 			ps.want_blank = false;
+		}
 	} else if (ps.spaced_expr_psym != psym_0 && ps.nparen == 0) {
 		ps.force_nl = true;
 		ps.in_stmt_or_decl = false;
 		ps.next_unary = true;
 		parse(ps.spaced_expr_psym);
 		ps.spaced_expr_psym = psym_0;
+	}
+}
 static void
 process_do(void)
+{
 	ps.in_stmt_or_decl = false;
 	ps.in_decl = false;
 	if (code.len > 0)
 		output_line();
 	ps.force_nl = true;
 	parse(psym_do);
+}
 static void
 process_else(void)
+{
 	ps.in_stmt_or_decl = false;
 	if (code.len > 0
 	    && !(opt.cuddle_else && code.s[code.len - 1] == '}'))
 		output_line();
 	ps.force_nl = true;
 	parse(psym_else);
+}
 static void
 process_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_colon_question:			goto copy_token;
 	case lsym_colon_label:	process_colon_label();	break;
 	case lsym_colon_other:	process_colon_other();	break;
 	case lsym_comma:	process_comma();	break;
 	case lsym_semicolon:	process_semicolon();	break;
 	case lsym_typedef:				goto copy_token;
 	case lsym_modifier:				goto copy_token;
 	case lsym_case:		ps.seen_case = true;	goto copy_token;
 	case lsym_default:	ps.seen_case = true;	goto copy_token;
 	case lsym_do:		process_do();		goto copy_token;
 	case lsym_else:		process_else();		goto copy_token;
 	case lsym_for:		ps.spaced_expr_psym = psym_for_exprs; goto copy_token;
 	case lsym_if:		ps.spaced_expr_psym = psym_if_expr; goto copy_token;
 	case lsym_switch:	ps.spaced_expr_psym = psym_switch_expr; goto copy_token;
 	case lsym_while:	ps.spaced_expr_psym = psym_while_expr; goto copy_token;
 		/* INDENT ON */
 	case lsym_tag:
 		if (ps.nparen > 0)
 			goto copy_token;
 		/* FALLTHROUGH */
 	case lsym_type_outside_parentheses:
 		process_type_outside_parentheses();
 		goto copy_token;
 	case lsym_type_in_parentheses:
 	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_if && ps.prev_lsym == lsym_else
 		    && opt.else_if_in_same_line)
 			ps.force_nl = false;
 		if (lsym == lsym_newline || lsym == lsym_preprocessing)
 			ps.force_nl = false;
 		else if (lsym == lsym_comment) {
 			/* no special processing */
 		} else {
 			maybe_break_line(lsym);
 			ps.in_stmt_or_decl = true;
 			if (com.len > 0)
 				move_com_to_code(lsym);
 			update_ps_lbrace_kind(lsym);
+		}
 		process_lsym(lsym);
 		debug_parser_state();
 		if (lsym != lsym_comment && lsym != lsym_newline &&
 		    lsym != lsym_preprocessing)
 			ps.prev_lsym = lsym;
+	}
+}
 int
 main(int argc, char **argv)
+{
 	init_globals();
 	load_profiles(argc, argv);
 	parse_command_line(argc, argv);
 	set_initial_indentation();
 	return indent();
+}

 @@ -1,524 +1,537 @@
-/*	$NetBSD: indent.h,v 1.185 2023/06/10 07:42:41 rillig Exp $	*/
+/*	$NetBSD: indent.h,v 1.186 2023/06/10 12:59:31 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
  *    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 AUTHOR ``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 AUTHOR 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.
  */
 /*-
  * 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 <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_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,
 	lsym_postfix_op,	/* trailing '++' or '--' */
 	lsym_binary_op,		/* e.g. '*', '&', '<<', '&&' or '/=' */
 	lsym_question,		/* the '?' from a '?:' expression */
 	lsym_colon_question,	/* the ':' from a '?:' expression */
 	lsym_comma,
 	lsym_typedef,
 	lsym_modifier,		/* modifiers for types, functions, variables */
 	lsym_tag,		/* 'struct', 'union' or 'enum' */
 	lsym_type_outside_parentheses,
 	lsym_type_in_parentheses,
 	lsym_word,		/* identifier, constant or string */
 	lsym_funcname,		/* name of a function being defined */
 	lsym_colon_label,	/* the ':' after a label */
 	lsym_colon_other,	/* bit-fields, generic-association (C11),
 				 * enum-type-specifier (C23),
 				 * attribute-prefixed-token (C23),
 				 * pp-prefixed-parameter (C23 6.10) */
 	lsym_semicolon,
 	lsym_case,
 	lsym_default,
 	lsym_do,
 	lsym_else,
 	lsym_for,
 	lsym_if,
 	lsym_switch,
 	lsym_while,
 	lsym_return,
 } lexer_symbol;
 /*
  * Structure of the source code, in terms of declarations, statements and
  * braces; used to determine the indentation level of these parts.
  */
 typedef enum parser_symbol {
 	psym_0,			/* a placeholder; not stored on the stack */
 	psym_lbrace_block,	/* '{' for a block of code */
 	psym_lbrace_struct,	/* '{' in 'struct ... { ... }' */
 	psym_lbrace_union,	/* '{' in 'union ... { ... }' */
 	psym_lbrace_enum,	/* '{' in 'enum ... { ... }' */
 	psym_rbrace,		/* not stored on the stack */
 	psym_decl,
 	psym_stmt,
 	psym_stmt_list,
 	psym_for_exprs,		/* 'for' '(' ... ')' */
 	psym_if_expr,		/* 'if' '(' expr ')' */
 	psym_if_expr_stmt,	/* 'if' '(' expr ')' stmt */
 	psym_if_expr_stmt_else,	/* 'if' '(' expr ')' stmt 'else' */
 	psym_else,		/* 'else'; not stored on the stack */
 	psym_switch_expr,	/* 'switch' '(' expr ')' */
 	psym_do,		/* 'do' */
 	psym_do_stmt,		/* 'do' stmt */
 	psym_while_expr,	/* 'while' '(' expr ')' */
 } parser_symbol;
-/* A range of characters, not null-terminated. */
+/* A range of characters, only null-terminated in debug mode. */
 struct buffer {
 	char *s;
 	size_t len;
 	size_t cap;
 };
 extern FILE *input;
 extern FILE *output;
 /*
  * The current line from the input file, used by the lexer to generate tokens.
  * To read from the line, start at inp_p and continue up to and including the
  * next '\n'. To read beyond the '\n', call inp_skip or inp_next, which will
  * make the next line available, invalidating any pointers into the previous
  * line.
  */
 extern struct buffer inp;
 extern const char *inp_p;
 extern struct buffer token;	/* the current token to be processed, is
 				 * typically copied to the buffer 'code', or in
 				 * some cases to 'lab'. */
 extern struct buffer lab;	/* the label or preprocessor directive */
 extern struct buffer code;	/* the main part of the current line of code,
 				 * containing declarations or statements */
 extern struct buffer com;	/* the trailing comment of the line, or the
 				 * start or end of a multi-line comment, or
 				 * while in process_comment, a single line of a
 				 * multi-line comment */
 extern struct options {
 	bool blanklines_around_conditional_compilation;
 	bool blank_line_after_decl_at_top;	/* this is vaguely similar to
 						 * blank_line_after_decl except
 						 * that it only applies to the
 						 * first set of declarations in
 						 * a procedure (just after the
 						 * first '{') and it causes a
 						 * blank line to be generated
 						 * even if there are no
 						 * declarations */
 	bool blank_line_after_decl;
 	bool blanklines_after_procs;
 	bool blanklines_before_block_comments;
 	bool break_after_comma;	/* whether to add a line break after each
 				 * declarator */
 	bool brace_same_line;	/* whether brace should be on same line as if,
 				 * while, etc */
 	bool blank_after_sizeof;	/* whether a blank should always be
 					 * inserted after sizeof */
 	bool comment_delimiter_on_blankline;
 	int decl_comment_column;	/* the column in which comments after
 					 * declarations should be put */
 	bool cuddle_else;	/* whether 'else' should cuddle up to '}' */
 	int continuation_indent;	/* the indentation between the edge of
 					 * code and continuation lines */
 	float case_indent;	/* The distance (measured in indentation
 				 * levels) to indent case labels from the
 				 * switch statement */
 	int comment_column;	/* the column in which comments to the right of
 				 * code should start */
 	int decl_indent;	/* indentation of identifier in declaration */
 	bool left_justify_decl;
 	int unindent_displace;	/* comments not to the right of code will be
 				 * placed this many indentation levels to the
 				 * left of code */
 	bool extra_expr_indent;	/* whether continuation lines from the
 				 * expression part of "if (e)", "while (e)",
 				 * "for (e; e; e)" should be indented an extra
 				 * tab stop so that they are not confused with
 				 * the code that follows */
 	bool else_if_in_same_line;
 	bool function_brace_split;	/* split function declaration and brace
 					 * onto separate lines */
 	bool format_col1_comments;	/* If comments which start in column 1
 					 * are to be reformatted (just like
 					 * comments that begin in later
 					 * columns) */
 	bool format_block_comments;	/* whether comments beginning with '/ *
 					 * \n' are to be reformatted */
 	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)
 				 * 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_blanklines;
 	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
 				 * all spaces */
 	bool verbose;		/* print configuration to stderr */
 } opt;
 extern bool found_err;
 extern bool had_eof;		/* whether input is exhausted */
 extern int line_no;		/* the current line number. */
 extern enum indent_enabled {
 	indent_on,
 	indent_off,
 	indent_last_off_line,
 } indent_enabled;
 #define	STACKSIZE 256
 /* Properties of each level of parentheses or brackets. */
 typedef struct paren_level_props {
 	int indent;		/* indentation of the operand/argument,
 				 * relative to the enclosing statement; if
 				 * negative, reflected at -1 */
 	enum paren_level_cast {
 		cast_unknown,
 		cast_maybe,
 		cast_no,
 	} cast;			/* whether the parentheses form a type cast */
 } paren_level_props;
 struct psym_stack {
 	int top;		/* pointer to top of stack */
 	parser_symbol sym[STACKSIZE];
 	int ind_level[STACKSIZE];
 };
 /*
  * The parser state determines the layout of the formatted text.
+ *
  * At each '#if', the parser state is copied so that the corresponding '#else'
  * lines start in the same state.
+ *
  * In a function body, the number of block braces determines the indentation
  * of statements and declarations.
+ *
  * In a statement, the number of parentheses or brackets determines the
  * indentation of follow-up lines.
+ *
  * In an expression, the token type determine whether to put spaces around.
+ *
  * In a source file, the types of line determine the vertical spacing, such as
  * around preprocessing directives or function bodies, or above block
  * comments.
  */
 extern struct parser_state {
 	lexer_symbol prev_lsym;	/* the previous token, but never comment,
 				 * newline or preprocessing line */
 	/* Token classification */
 	bool in_stmt_or_decl;	/* whether in a statement or a struct
 				 * declaration or a plain declaration */
 	bool in_decl;		/* XXX: double-check the exact meaning */
 	bool in_var_decl;	/* starts at a type name or a '){' from a
 				 * compound literal; ends at the '(' from a
 				 * function definition or a ';' outside '{}';
 				 * when active, '{}' form struct or union
 				 * declarations, ':' marks a bit-field, and '='
 				 * starts an initializer */
 	bool in_init;		/* whether inside an initializer */
 	int init_level;		/* the number of '{}' in an initializer */
 	bool line_has_func_def;	/* starts either at the 'name(' from a function
 				 * definition if it occurs at the beginning of
 				 * a line, or at the first '*' from inside a
 				 * declaration when the line starts with words
 				 * followed by a '(' */
 	bool in_func_def_params;	/* for old-style functions */
 	bool line_has_decl;	/* whether this line of code has part of a
 				 * declaration on it; used for indenting
 				 * comments */
 	parser_symbol lbrace_kind;	/* the kind of brace to be pushed to
 					 * the parser symbol stack next */
 	parser_symbol spaced_expr_psym;	/* the parser symbol to be shifted
 					 * after the parenthesized expression
 					 * from a 'for', 'if', 'switch' or
 					 * 'while'; or psym_0 */
 	bool seen_case;		/* whether there was a 'case' or 'default', to
 				 * properly space the following ':' */
 	bool prev_paren_was_cast;
 	int quest_level;	/* when this is positive, we have seen a '?'
 				 * without the matching ':' in a '?:'
 				 * expression */
 	/* Indentation of statements and declarations */
 	int ind_level;		/* the indentation level for the line that is
 				 * currently prepared for output */
 	int ind_level_follow;	/* the level to which ind_level should be set
 				 * after the current line is printed */
 	bool in_stmt_cont;	/* whether the current line should have an
 				 * extra indentation level because we are in
 				 * the middle of a statement */
 	int decl_level;		/* current nesting level for a structure
 				 * declaration or an initializer */
 	int di_stack[20];	/* a stack of structure indentation levels */
 	bool decl_indent_done;	/* whether the indentation for a declaration
 				 * has been added to the code buffer. */
 	int decl_ind;		/* current indentation for declarations */
 	bool tabs_to_var;	/* true if using tabs to indent to var name */
 	enum {
 		eei_no,
 		eei_maybe,
 		eei_last
 	} extra_expr_indent;
 	struct psym_stack psyms;
 	/* Spacing inside a statement or declaration */
 	bool next_unary;	/* whether the following operator should be
 				 * unary; is used in declarations for '*', as
 				 * 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 line_start_nparen;	/* the number of parentheses or brackets that
 				 * were open at the beginning of the current
 				 * line; used to indent within statements,
 				 * initializers and declarations */
 	int nparen;		/* the number of parentheses or brackets that
 				 * are currently open; used to indent the
 				 * remaining lines of the statement,
 				 * initializer or declaration */
 	paren_level_props paren[20];
 	/* Horizontal spacing for comments */
 	int comment_delta;	/* used to set up indentation for all lines of
 				 * a boxed comment after the first one */
 	int n_comment_delta;	/* remembers how many columns there were before
 				 * the start of a box comment so that
 				 * 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 */
 		decl_begin,	/* collecting tokens of a declaration */
 		decl_end,	/* finished a declaration */
 	} declaration;
 	bool blank_line_after_decl;
 	/* Comments */
 	bool curr_col_1;	/* whether the current token started in column
 				 * 1 of the original input */
 	bool next_col_1;
 } ps;
 extern struct output_state {
 	enum line_kind {
 		lk_other,
 		lk_blank,
 		lk_if,		/* #if, #ifdef, #ifndef */
 		lk_endif,	/* #endif */
 		lk_stmt_head,	/* the ')' of an incomplete statement such as
 				 * 'if (expr)' or 'for (expr; expr; expr)' */
 		lk_func_end,	/* the last '}' of a function body */
 		lk_block_comment,
 		lk_case_or_default,
 	} line_kind;		/* kind of the line that is being prepared for
 				 * output; is reset to lk_other each time after
 				 * trying to send a line to the output, even if
 				 * that line was a suppressed blank line; used
 				 * for inserting or removing blank lines */
 	enum line_kind prev_line_kind;	/* the kind of line that was actually
 					 * sent to the output */
 	struct buffer indent_off_text;	/* text from between 'INDENT OFF' and
 					 * 'INDENT ON', both inclusive */
 } out;
 #define array_length(array) (sizeof(array) / sizeof((array)[0]))
 #ifdef debug
 void debug_printf(const char *, ...) __printflike(1, 2);
 void debug_println(const char *, ...) __printflike(1, 2);
 void debug_blank_line(void);
 void debug_vis_range(const char *, const char *, size_t, const char *);
 void debug_parser_state(void);
 void debug_parse_stack(const char *);
 void debug_print_buf(const char *, const struct buffer *);
 void debug_buffers(void);
 extern const char *const lsym_name[];
 extern const char *const psym_name[];
 extern const char *const paren_level_cast_name[];
 extern const char *const line_kind_name[];
 #else
 #define debug_noop() do { } while (false)
 #define	debug_printf(fmt, ...) debug_noop()
 #define	debug_println(fmt, ...) debug_noop()
 #define debug_blank_line() debug_noop()
 #define	debug_vis_range(prefix, s, e, suffix) debug_noop()
 #define	debug_parser_state() debug_noop()
 #define	debug_parse_stack(situation) debug_noop()
 #define debug_print_buf(name, buf) debug_noop()
 #define	debug_buffers() debug_noop()
 #endif
 void register_typename(const char *);
 int compute_code_indent(void);
 int compute_label_indent(void);
 int ind_add(int, const char *, size_t);
 void inp_skip(void);
 char inp_next(void);
 void output_finish(void);
 lexer_symbol lexi(void);
 void diag(int, const char *, ...) __printflike(2, 3);
 void output_line(void);
 void inp_read_line(void);
 void parse(parser_symbol);
 void process_comment(void);
 void set_option(const char *, const char *);
 void load_profile_files(const char *);
 void *nonnull(void *);
 void buf_add_char(struct buffer *, char);
 void buf_add_chars(struct buffer *, const char *, size_t);
 static inline bool
 ch_isalnum(char ch)
+{
 	return isalnum((unsigned char)ch) != 0;
+}
 static inline bool
 ch_isalpha(char ch)
+{
 	return isalpha((unsigned char)ch) != 0;
+}
 static inline bool
 ch_isblank(char ch)
+{
 	return ch == ' ' || ch == '\t';
+}
 static inline bool
 ch_isdigit(char ch)
+{
 	return '0' <= ch && ch <= '9';
+}
 static inline bool
 ch_isspace(char ch)
+{
 	return isspace((unsigned char)ch) != 0;
+}
 static inline int
 next_tab(int ind)
+{
 	return ind - ind % opt.tabsize + opt.tabsize;
+}
 #ifdef debug
 void buf_terminate(struct buffer *);
 #else
 #define buf_terminate(buf) debug_noop()
 #endif
 static inline void
 buf_clear(struct buffer *buf)
+{
 	buf->len = 0;
 	buf_terminate(buf);
+}

 @@ -1,419 +1,421 @@
-/*	$NetBSD: io.c,v 1.214 2023/06/10 11:01:58 rillig Exp $	*/
+/*	$NetBSD: io.c,v 1.215 2023/06/10 12:59:31 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.214 2023/06/10 11:01:58 rillig Exp $");
+__RCSID("$NetBSD: io.c,v 1.215 2023/06/10 12:59:31 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;
 static void
 inp_read_next_line(FILE *f)
+{
-	inp.len = 0;
+	buf_clear(&inp);
 	for (;;) {
 		int ch = getc(f);
 		if (ch == EOF) {
 			if (indent_enabled == indent_on) {
 				buf_add_char(&inp, ' ');
 				buf_add_char(&inp, '\n');
+			}
 			had_eof = true;
 			break;
+		}
 		if (ch != '\0')
 			buf_add_char(&inp, (char)ch);
 		if (ch == '\n')
 			break;
+	}
 	buf_terminate(&inp);
 	inp_p = inp.s;
+}
 void
 inp_read_line(void)
+{
 	if (indent_enabled == indent_on)
-		out.indent_off_text.len = 0;
+		buf_clear(&out.indent_off_text);
 	buf_add_chars(&out.indent_off_text, inp.s, inp.len);
 	inp_read_next_line(input);
+}
 void
 inp_skip(void)
+{
 	inp_p++;
 	if ((size_t)(inp_p - inp.s) >= inp.len)
 		inp_read_line();
+}
 char
 inp_next(void)
+{
 	char ch = inp_p[0];
 	inp_skip();
 	return ch;
+}
 static void
 buffer_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_vis_range("write_range \"", s, len, "\"\n");
 	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.blanklines_around_conditional_compilation) {
 		if (out.prev_line_kind != lk_if && out.line_kind == lk_if)
 			return true;
 		if (out.prev_line_kind == lk_endif
 		    && out.line_kind != lk_endif)
 			return true;
+	}
 	if (opt.blanklines_after_procs && out.prev_line_kind == lk_func_end
 	    && out.line_kind != lk_endif)
 		return true;
 	if (opt.blanklines_before_block_comments
 	    && out.line_kind == lk_block_comment)
 		return true;
 	return false;
+}
 static bool
 is_blank_line_optional(void)
+{
 	if (out.prev_line_kind == lk_stmt_head)
 		return newlines >= 1;
 	if (ps.psyms.top >= 2)
 		return newlines >= 2;
 	return newlines >= 3;
+}
 static int
 compute_case_label_indent(void)
+{
 	int i = ps.psyms.top;
 	while (i > 0 && ps.psyms.sym[i] != psym_switch_expr)
 		i--;
 	float case_ind = (float)ps.psyms.ind_level[i] + opt.case_indent;
 	return (int)(case_ind * (float)opt.indent_size);
+}
 int
 compute_label_indent(void)
+{
 	if (out.line_kind == lk_case_or_default)
 		return compute_case_label_indent();
 	if (lab.s[0] == '#')
 		return 0;
 	return opt.indent_size * (ps.ind_level - 2);
+}
 static void
 output_line_label(void)
+{
 	write_indent(compute_label_indent());
 	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;
+	}
 	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.line_start_nparen == 0) {
 		if (ps.psyms.top >= 1
 		    && ps.psyms.sym[ps.psyms.top - 1] == psym_lbrace_enum)
 			return base_ind;
 		if (ps.in_stmt_cont)
 			return base_ind + opt.continuation_indent;
 		return base_ind;
+	}
 	if (opt.lineup_to_parens) {
 		if (opt.lineup_to_parens_always)
 			return paren_indent;
 		return compute_code_indent_lineup(base_ind);
+	}
 	int rel_ind = opt.continuation_indent * ps.line_start_nparen;
 	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 (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)
 		write_range(" ", 1);
 	write_indent(target_ind);
 	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)
 		buffer_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_line_indented(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)
 		buffer_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())
 		return;
 	if (lab.len > 0)
 		output_line_label();
 	if (code.len > 0)
 		output_line_code();
 	if (com.len > 0)
 		output_line_comment();
 	buffer_newline();
 	if (out.line_kind != lk_blank)
 		write_buffered_newlines();
 	out.prev_line_kind = out.line_kind;
+}
 /*
  * 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)
 		output_line_indented();
 	else if (indent_enabled == indent_last_off_line) {
 		indent_enabled = indent_on;
 		write_range(out.indent_off_text.s, out.indent_off_text.len);
-		out.indent_off_text.len = 0;
+		buf_clear(&out.indent_off_text);
+	}
-	lab.len = 0;
+	buf_clear(&lab);
-	code.len = 0;
+	buf_clear(&code);
-	com.len = 0;
+	buf_clear(&com);
 	ps.line_has_decl = ps.in_decl;
 	ps.line_has_func_def = false;
 	ps.in_stmt_cont = ps.in_stmt_or_decl
 	    && (!ps.in_decl || ps.in_init)
 	    && ps.init_level == 0;
 	ps.decl_indent_done = false;
 	if (ps.extra_expr_indent == eei_last)
 		ps.extra_expr_indent = eei_no;
 	if (!(ps.psyms.sym[ps.psyms.top] == psym_if_expr_stmt_else
 		&& ps.nparen > 0))
 		ps.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)
+{
 	output_line();
 	if (indent_enabled != indent_on) {
 		indent_enabled = indent_last_off_line;
 		output_line();
+	}
 	fflush(output);
+}

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

 @@ -1,356 +1,357 @@
-/*	$NetBSD: pr_comment.c,v 1.159 2023/06/10 06:38:21 rillig Exp $	*/
+/*	$NetBSD: pr_comment.c,v 1.160 2023/06/10 12:59:31 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.159 2023/06/10 06:38:21 rillig Exp $");
+__RCSID("$NetBSD: pr_comment.c,v 1.160 2023/06/10 12:59:31 rillig Exp $");
 #include <string.h>
 #include "indent.h"
 static void
 com_add_char(char ch)
+{
 	buf_add_char(&com, ch);
+}
 static void
 com_add_delim(void)
+{
 	if (opt.star_comment_cont)
 		buf_add_chars(&com, " * ", 3);
+}
 static bool
 fits_in_one_line(int com_ind, int max_line_length)
+{
 	for (const char *start = inp_p, *p = start; *p != '\n'; p++) {
 		if (p[0] == '*' && p[1] == '/') {
 			while (p - inp_p >= 2
 			    && ch_isblank(p[-1])
 			    && ch_isblank(p[-2]))
 				p--;
 			int len = ind_add(com_ind + 3,
 			    start, (size_t)(p - start));
 			len += p == start || ch_isblank(p[-1]) ? 2 : 3;
 			return len <= max_line_length;
+		}
+	}
 	return false;
+}
 static void
 analyze_comment(bool *p_may_wrap, bool *p_delim,
     int *p_ind, int *p_line_length)
+{
 	bool may_wrap = true;
 	bool delim = false;
 	int ind;
 	int line_length = opt.max_line_length;
 	if (ps.curr_col_1 && !opt.format_col1_comments) {
 		may_wrap = false;
 		ind = 0;
 	} else {
 		if (inp_p[0] == '-' || inp_p[0] == '*' ||
 		    token.s[token.len - 1] == '/' ||
 		    (inp_p[0] == '\n' && !opt.format_block_comments))
 			may_wrap = false;
 		if (code.len == 0 && inp_p[strspn(inp_p, "*")] == '\n')
 			out.line_kind = lk_block_comment;
 		if (com.len > 0)
 			output_line();
 		if (lab.len == 0 && code.len == 0) {
 			ind = (ps.ind_level - opt.unindent_displace)
 			    * opt.indent_size;
 			if (ind <= 0)
 				ind = opt.format_col1_comments ? 0 : 1;
 			line_length = opt.block_comment_max_line_length;
 			if (may_wrap && inp_p[0] == '\n')
 				delim = true;
 			if (may_wrap && opt.comment_delimiter_on_blankline)
 				delim = true;
 		} else {
 			int target_ind = code.len > 0
 			    ? ind_add(compute_code_indent(), code.s, code.len)
 			    : ind_add(compute_label_indent(), lab.s, lab.len);
 			ind = ps.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);
 	} else {
 		ps.n_comment_delta = 0;
 		if (!(inp_p[0] == '\t' && !ch_isblank(inp_p[1])))
 			while (ch_isblank(inp_p[0]))
 				inp_p++;
+	}
 	*p_may_wrap = may_wrap;
 	*p_delim = delim;
 	*p_ind = ind;
 	*p_line_length = line_length;
+}
 static void
 copy_comment_start(bool may_wrap, bool *delim, int ind, int line_length)
+{
 	ps.comment_delta = 0;
 	com_add_char('/');
 	com_add_char(token.s[token.len - 1]);	/* either '*' or '/' */
 	if (may_wrap) {
 		if (!ch_isblank(inp_p[0]))
 			com_add_char(' ');
 		if (*delim && fits_in_one_line(ind, line_length))
 			*delim = false;
 		if (*delim) {
 			output_line();
 			com_add_delim();
+		}
+	}
+}
 static void
 copy_comment_wrap_text(int line_length, ssize_t *last_blank)
+{
 	int now_len = ind_add(ps.com_ind, com.s, com.len);
 	for (;;) {
 		char ch = inp_next();
 		if (ch_isblank(ch))
 			*last_blank = (ssize_t)com.len;
 		com_add_char(ch);
 		now_len++;
 		if (memchr("*\n\r\b\t", inp_p[0], 6) != NULL)
 			break;
 		if (now_len >= line_length && *last_blank != -1)
 			break;
+	}
 	ps.next_col_1 = false;
 	if (now_len <= line_length)
 		return;
 	if (ch_isspace(com.s[com.len - 1]))
 		return;
 	if (*last_blank == -1) {
 		/* only a single word in this line */
 		output_line();
 		com_add_delim();
 		return;
+	}
 	const char *last_word_s = com.s + *last_blank + 1;
 	size_t last_word_len = com.len - (size_t)(*last_blank + 1);
 	com.len = (size_t)*last_blank;
 	output_line();
 	com_add_delim();
 	/* Assume that output_line and com_add_delim don't 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)
+{
 	*last_blank = -1;
 	if (ps.next_col_1) {
 		if (com.len == 0)
 			com_add_char(' ');	/* force empty output line */
 		if (com.len > 3) {
 			output_line();
 			com_add_delim();
+		}
 		output_line();
 		com_add_delim();
 	} else {
 		ps.next_col_1 = true;
 		if (!(com.len > 0 && ch_isblank(com.s[com.len - 1])))
 			com_add_char(' ');
 		*last_blank = (int)com.len - 1;
+	}
 	++line_no;
 	/* flush any blanks and/or tabs at start of next line */
 	inp_skip();		/* '\n' */
 	while (ch_isblank(inp_p[0]))
 		inp_p++;
 	if (inp_p[0] == '*' && inp_p[1] == '/')
 		return false;
 	if (inp_p[0] == '*') {
 		inp_p++;
 		while (ch_isblank(inp_p[0]))
 			inp_p++;
+	}
 	return true;
+}
 static void
 copy_comment_wrap_finish(int line_length, bool delim)
+{
 	if (delim) {
 		if (com.len > 3)
 			output_line();
 		else
-			com.len = 0;
+			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);
 		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' */
 	for (;;) {
 		if (inp_p[0] == '\n') {
 			if (had_eof)
 				goto unterminated_comment;
 			if (!copy_comment_wrap_newline(&last_blank))
 				goto end_of_comment;
 		} else if (inp_p[0] == '*' && inp_p[1] == '/')
 			goto end_of_comment;
 		else
 			copy_comment_wrap_text(line_length, &last_blank);
+	}
 end_of_comment:
 	copy_comment_wrap_finish(line_length, delim);
 	return;
 unterminated_comment:
 	diag(1, "Unterminated comment");
 	output_line();
+}
 static void
 copy_comment_nowrap(void)
+{
 	char kind = token.s[token.len - 1];
 	for (;;) {
 		if (inp_p[0] == '\n') {
 			if (kind == '/')
 				return;
 			if (had_eof) {
 				diag(1, "Unterminated comment");
 				output_line();
 				return;
+			}
 			if (com.len == 0)
 				com_add_char(' ');	/* force output of an
 							 * empty line */
 			output_line();
 			++line_no;
 			inp_skip();
 			continue;
+		}
 		com_add_char(*inp_p++);
 		if (com.len >= 2
 		    && com.s[com.len - 2] == '*'
 		    && com.s[com.len - 1] == '/'
 		    && kind == '*')
 			return;
+	}
+}
 /*
  * Scan, reformat and output a single comment, which is either a block comment
  * starting with '/' '*' or an end-of-line comment starting with '//'.
  */
 void
 process_comment(void)
+{
 	bool may_wrap, delim;
 	int ind, line_length;
 	analyze_comment(&may_wrap, &delim, &ind, &line_length);
 	copy_comment_start(may_wrap, &delim, ind, line_length);
 	if (may_wrap)
 		copy_comment_wrap(line_length, delim);
 	else
 		copy_comment_nowrap();
+}