 @@ -1,14 +1,14 @@
-/*	$NetBSD: pr_comment.c,v 1.18 2021/03/11 22:32:06 rillig Exp $	*/
+/*	$NetBSD: pr_comment.c,v 1.19 2021/03/12 23:10:18 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
 @@ -36,27 +36,27 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #if 0
 #ifndef lint
 static char sccsid[] = "@(#)pr_comment.c	8.1 (Berkeley) 6/6/93";
 #endif /* not lint */
 #endif
 #include <sys/cdefs.h>
 #ifndef lint
 #if defined(__NetBSD__)
-__RCSID("$NetBSD: pr_comment.c,v 1.18 2021/03/11 22:32:06 rillig Exp $");
+__RCSID("$NetBSD: pr_comment.c,v 1.19 2021/03/12 23:10:18 rillig Exp $");
 #elif defined(__FreeBSD__)
 __FBSDID("$FreeBSD: head/usr.bin/indent/pr_comment.c 334927 2018-06-10 16:44:18Z pstef $");
 #endif
 #endif
 #include <err.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "indent.h"
 static void
 @@ -126,51 +126,49 @@ pr_comment(void)
     last_bl = NULL;		/* no blanks found so far */
     ps.box_com = false;		/* at first, assume that we are not in
 				 * a boxed comment or some other
 				 * comment that should not be touched */
     ++ps.out_coms;		/* keep track of number of comments */
     /* Figure where to align and how to treat the comment */
     if (ps.col_1 && !opt.format_col1_comments) {	/* if comment starts in column
 						 * 1 it should not be touched */
 	ps.box_com = true;
 	break_delim = false;
 	ps.com_col = 1;
     } else {
     else {
 	if (*buf_ptr == '-' || *buf_ptr == '*' || e_token[-1] == '/' ||
 	    (*buf_ptr == '\n' && !opt.format_block_comments)) {
 	    ps.box_com = true;	/* A comment with a '-' or '*' immediately
 				 * after the /+* is assumed to be a boxed
 				 * comment. A comment with a newline
 				 * immediately after the /+* is assumed to
 				 * be a block comment and is treated as a
 				 * box comment unless format_block_comments
 				 * is nonzero (the default). */
 	    break_delim = false;
+	}
 	if ( /* ps.bl_line && */ (s_lab == e_lab) && (s_code == e_code)) {
 	    /* klg: check only if this line is blank */
 	    /*
 	     * If this (*and previous lines are*) blank, dont put comment way
 	     * out at left
 	     */
 	    ps.com_col = (ps.ind_level - opt.unindent_displace) * opt.ind_size + 1;
 	    adj_max_col = opt.block_comment_max_col;
 	    if (ps.com_col <= 1)
 		ps.com_col = 1 + !opt.format_col1_comments;
 	} else {
 	else {
 	    int target_col;
 	    break_delim = false;
 	    if (s_code != e_code)
 		target_col = count_spaces(compute_code_target(), s_code);
 	    else {
 		target_col = 1;
 		if (s_lab != e_lab)
 		    target_col = count_spaces(compute_label_target(), s_lab);
+	    }
 	    ps.com_col = ps.decl_on_line || ps.ind_level == 0 ? opt.decl_com_ind : opt.com_ind;
 	    if (ps.com_col <= target_col)
 		ps.com_col = opt.tabsize * (1 + (target_col - 1) / opt.tabsize) + 1;
 	    if (ps.com_col + 24 > adj_max_col)
 @@ -181,28 +179,27 @@ pr_comment(void)
 	/*
 	 * Find out how much indentation there was originally, because that
 	 * much will have to be ignored by pad_output() in dump_line(). This
 	 * is a box comment, so nothing changes -- not even indentation.
+	 *
 	 * The comment we're about to read usually comes from in_buffer,
 	 * unless it has been copied into save_com.
 	 */
 	char *start;
 	start = buf_ptr >= save_com && buf_ptr < save_com + sc_size ?
 	    sc_buf : in_buffer;
 	ps.n_comment_delta = 1 - count_spaces_until(1, start, buf_ptr - 2);
     } else {
     else {
 	ps.n_comment_delta = 0;
 	while (*buf_ptr == ' ' || *buf_ptr == '\t')
 	    buf_ptr++;
+    }
     ps.comment_delta = 0;
     *e_com++ = '/';
     *e_com++ = e_token[-1];
     if (*buf_ptr != ' ' && !ps.box_com)
 	*e_com++ = ' ';
     /*
      * Don't put a break delimiter if this is a one-liner that won't wrap.
      */
 @@ -235,28 +232,27 @@ pr_comment(void)
 				 * copied */
 	switch (*buf_ptr) {	/* this checks for various spcl cases */
 	case 014:		/* check for a form feed */
 	    check_size_comment(3, &last_bl);
 	    if (!ps.box_com) {	/* in a text comment, break the line here */
 		ps.use_ff = true;
 		/* fix so dump_line uses a form feed */
 		dump_line();
 		last_bl = NULL;
 		if (!ps.box_com && opt.star_comment_cont)
 		    *e_com++ = ' ', *e_com++ = '*', *e_com++ = ' ';
 		while (*++buf_ptr == ' ' || *buf_ptr == '\t')
+		    ;
 	    } else {
 	    else {
 		if (++buf_ptr >= buf_end)
 		    fill_buffer();
 		*e_com++ = 014;
+	    }
 	    break;
 	case '\n':
 	    if (e_token[-1] == '/') {
 		++line_no;
 		goto end_of_comment;
+	    }
 	    if (had_eof) {	/* check for unexpected eof */
 		printf("Unterminated comment\n");
 @@ -267,86 +263,82 @@ pr_comment(void)
 	    check_size_comment(4, &last_bl);
 	    if (ps.box_com || ps.last_nl) {	/* if this is a boxed comment,
 						 * we dont ignore the newline */
 		if (s_com == e_com)
 		    *e_com++ = ' ';
 		if (!ps.box_com && e_com - s_com > 3) {
 		    dump_line();
 		    if (opt.star_comment_cont)
 			*e_com++ = ' ', *e_com++ = '*', *e_com++ = ' ';
+		}
 		dump_line();
 		if (!ps.box_com && opt.star_comment_cont)
 		    *e_com++ = ' ', *e_com++ = '*', *e_com++ = ' ';
 	    } else {
 	    else {
 		ps.last_nl = 1;
 		if (e_com[-1] == ' ' || e_com[-1] == '\t')
 		    last_bl = e_com - 1;
 		/*
 		 * if there was a space at the end of the last line, remember
 		 * where it was
 		 */
 		else {		/* otherwise, insert one */
 		    last_bl = e_com;
 		    *e_com++ = ' ';
+		}
+	    }
 	    ++line_no;		/* keep track of input line number */
 	    if (!ps.box_com) {
 		int         nstar = 1;
 		do {		/* flush any blanks and/or tabs at start of
 				 * next line */
 		    if (++buf_ptr >= buf_end)
 			fill_buffer();
 		    if (*buf_ptr == '*' && --nstar >= 0) {
 			if (++buf_ptr >= buf_end)
 			    fill_buffer();
 			if (*buf_ptr == '/')
 			    goto end_of_comment;
+		    }
 		} while (*buf_ptr == ' ' || *buf_ptr == '\t');
 	    } else if (++buf_ptr >= buf_end)
 	    else if (++buf_ptr >= buf_end)
 		fill_buffer();
 	    break;		/* end of case for newline */
 	case '*':		/* must check for possibility of being at end
 				 * of comment */
 	    if (++buf_ptr >= buf_end)	/* get to next char after * */
 		fill_buffer();
 	    check_size_comment(4, &last_bl);
 	    if (*buf_ptr == '/') {	/* it is the end!!! */
 	end_of_comment:
 		if (++buf_ptr >= buf_end)
 		    fill_buffer();
 		if (break_delim) {
-		    if (e_com > s_com + 3) {
+		    if (e_com > s_com + 3)
 			dump_line();
 		    else
 			s_com = e_com;
 		    *e_com++ = ' ';
+		}
 		if (e_com[-1] != ' ' && e_com[-1] != '\t' && !ps.box_com)
 		    *e_com++ = ' ';	/* ensure blank before end */
 		if (e_token[-1] == '/')
 		    *e_com++ = '\n', *e_com = '\0';
 		else
 		    *e_com++ = '*', *e_com++ = '/', *e_com = '\0';
 		ps.just_saw_decl = l_just_saw_decl;
 		return;
 	    } else		/* handle isolated '*' */
 	    else		/* handle isolated '*' */
 		*e_com++ = '*';
 	    break;
 	default:		/* we have a random char */
 	    now_col = count_spaces_until(ps.com_col, s_com, e_com);
 	    do {
 		check_size_comment(1, &last_bl);
 		*e_com = *buf_ptr++;
 		if (buf_ptr >= buf_end)
 		    fill_buffer();
 		if (*e_com == ' ' || *e_com == '\t')
 		    last_bl = e_com;	/* remember we saw a blank */
 		++e_com;
 		now_col++;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: indent.c,v 1.44 2021/03/12 00:15:34 rillig Exp $	*/
+/*	$NetBSD: indent.c,v 1.45 2021/03/12 23:10:18 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
 @@ -36,27 +36,27 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #if 0
 #ifndef lint
 static char sccsid[] = "@(#)indent.c	5.17 (Berkeley) 6/7/93";
 #endif /* not lint */
 #endif
 #include <sys/cdefs.h>
 #ifndef lint
 #if defined(__NetBSD__)
-__RCSID("$NetBSD: indent.c,v 1.44 2021/03/12 00:15:34 rillig Exp $");
+__RCSID("$NetBSD: indent.c,v 1.45 2021/03/12 23:10:18 rillig Exp $");
 #elif defined(__FreeBSD__)
 __FBSDID("$FreeBSD: head/usr.bin/indent/indent.c 340138 2018-11-04 19:24:49Z oshogbo $");
 #endif
 #endif
 #include <sys/param.h>
 #if HAVE_CAPSICUM
 #include <sys/capsicum.h>
 #include <capsicum_helpers.h>
 #endif
 #include <err.h>
 #include <errno.h>
 #include <fcntl.h>
 @@ -497,41 +497,39 @@ main(int argc, char **argv)
     for (i = 1; i < argc; ++i) {
 	/*
 	 * look thru args (if any) for changes to defaults
 	 */
 	if (argv[i][0] != '-') {/* no flag on parameter */
 	    if (input == NULL) {	/* we must have the input file */
 		in_name = argv[i];	/* remember name of input file */
 		input = fopen(in_name, "r");
 		if (input == NULL)	/* check for open error */
 			err(1, "%s", in_name);
 		continue;
 	    } else if (output == NULL) {	/* we have the output file */
 	    else if (output == NULL) {	/* we have the output file */
 		out_name = argv[i];	/* remember name of output file */
 		if (strcmp(in_name, out_name) == 0) {	/* attempt to overwrite
 							 * the file */
 		    errx(1, "input and output files must be different");
+		}
 		output = fopen(out_name, "w");
 		if (output == NULL)	/* check for create error */
 			err(1, "%s", out_name);
 		continue;
+	    }
 	    errx(1, "unknown parameter: %s", argv[i]);
 	} else
 	else
 	    set_option(argv[i]);
     }				/* end of for */
     if (input == NULL)
 	input = stdin;
     if (output == NULL) {
 	if (input == stdin)
 	    output = stdout;
 	else {
 	    out_name = in_name;
 	    bakcopy();
+	}
+    }
 @@ -626,28 +624,27 @@ main(int argc, char **argv)
 	    if (s_com != e_com) {	/* the turkey has embedded a comment
 					 * in a line. fix it */
 		int len = e_com - s_com;
 		check_size_code(len + 3);
 		*e_code++ = ' ';
 		memcpy(e_code, s_com, len);
 		e_code += len;
 		*e_code++ = ' ';
 		*e_code = '\0';	/* null terminate code sect */
 		ps.want_blank = false;
 		e_com = s_com;
+	    }
 	} else if (type_code != comment) /* preserve force_nl thru a comment */
 	else if (type_code != comment)	/* preserve force_nl thru a comment */
 	    force_nl = false;	/* cancel forced newline after newline, form
 				 * feed, etc */
 	/*-----------------------------------------------------*\
 	|	   do switch on type of token scanned		|
 	\*-----------------------------------------------------*/
 	check_size_code(3);	/* maximum number of increments of e_code
 				 * before the next check_size_code or
 				 * dump_line() is 2. After that there's the
 				 * final increment for the null character. */
 	switch (type_code) {	/* now, decide what to do with the token */
 @@ -671,28 +668,27 @@ main(int argc, char **argv)
 	    /* count parens to make Healy happy */
 	    if (++ps.p_l_follow == nitems(ps.paren_indents)) {
 		diag(0, "Reached internal limit of %zu unclosed parens",
 		    nitems(ps.paren_indents));
 		ps.p_l_follow--;
+	    }
 	    if (*token == '[')
 		/* not a function pointer declaration or a function call */;
 	    else if (ps.in_decl && !ps.block_init && !ps.dumped_decl_indent &&
 		ps.procname[0] == '\0' && ps.paren_level == 0) {
 		/* function pointer declarations */
 		indent_declaration(dec_ind, tabs_to_var);
 		ps.dumped_decl_indent = true;
 	    } else if (ps.want_blank &&
 	    else if (ps.want_blank &&
 		    ((ps.last_token != ident && ps.last_token != funcname) ||
 		    opt.proc_calls_space ||
 		    (ps.keyword == rw_sizeof ? opt.Bill_Shannon :
 		    ps.keyword != rw_0 && ps.keyword != rw_offsetof)))
 		*e_code++ = ' ';
 	    ps.want_blank = false;
 	    *e_code++ = token[0];
 	    ps.paren_indents[ps.p_l_follow - 1] = count_spaces_until(1, s_code, e_code) - 1;
 	    if (sp_sw && ps.p_l_follow == 1 && opt.extra_expression_indent
 		    && ps.paren_indents[0] < 2 * opt.ind_size)
 		ps.paren_indents[0] = 2 * opt.ind_size;
 	    if (ps.in_or_st && *token == '(' && ps.tos <= 2) {
 		/*
 @@ -746,28 +742,27 @@ main(int argc, char **argv)
 	case unary_op:		/* this could be any unary operation */
 	    if (!ps.dumped_decl_indent && ps.in_decl && !ps.block_init &&
 		ps.procname[0] == '\0' && ps.paren_level == 0) {
 		/* pointer declarations */
 		/*
 		 * if this is a unary op in a declaration, we should indent
 		 * this token
 		 */
 		for (i = 0; token[i]; ++i)
 		    /* find length of token */;
 		indent_declaration(dec_ind - i, tabs_to_var);
 		ps.dumped_decl_indent = true;
 	    } else if (ps.want_blank)
 	    else if (ps.want_blank)
 		*e_code++ = ' ';
+	    {
 		int len = e_token - s_token;
 		check_size_code(len);
 		memcpy(e_code, token, len);
 		e_code += len;
+	    }
 	    ps.want_blank = false;
 	    break;
 	case binary_op:		/* any binary operation */
 @@ -896,28 +891,27 @@ main(int argc, char **argv)
 	    ps.in_stmt = false;	/* dont indent the {} */
 	    if (!ps.block_init)
 		force_nl = true;/* force other stuff on same line as '{' onto
 				 * new line */
 	    else if (ps.block_init_level <= 0)
 		ps.block_init_level = 1;
 	    else
 		ps.block_init_level++;
 	    if (s_code != e_code && !ps.block_init) {
 		if (!opt.btype_2) {
 		    dump_line();
 		    ps.want_blank = false;
 		} else if (ps.in_parameter_declaration && !ps.in_or_st) {
 		else if (ps.in_parameter_declaration && !ps.in_or_st) {
 		    ps.i_l_follow = 0;
 		    if (opt.function_brace_split) { /* dump the line prior
 				 * to the brace ... */
 			dump_line();
 			ps.want_blank = false;
 		    } else	/* add a space between the decl and brace */
 			ps.want_blank = true;
+		}
+	    }
 	    if (ps.in_parameter_declaration)
 		prefix_blankline_requested = 0;
 	    if (ps.p_l_follow > 0) {	/* check for preceding unbalanced
 @@ -932,28 +926,27 @@ main(int argc, char **argv)
+	    }
 	    if (s_code == e_code)
 		ps.ind_stmt = false;	/* dont put extra indentation on line
 					 * with '{' */
 	    if (ps.in_decl && ps.in_or_st) {	/* this is either a structure
 						 * declaration or an init */
 		di_stack[ps.dec_nest] = dec_ind;
 		if (++ps.dec_nest == nitems(di_stack)) {
 		    diag(0, "Reached internal limit of %zu struct levels",
 			nitems(di_stack));
 		    ps.dec_nest--;
+		}
 		/* ?		dec_ind = 0; */
 	    } else {
 	    else {
 		ps.decl_on_line = false;	/* we can't be in the middle of
 						 * a declaration, so don't do
 						 * special indentation of
 						 * comments */
 		if (opt.blanklines_after_declarations_at_proctop
 			&& ps.in_parameter_declaration)
 		    postfix_blankline_requested = 1;
 		ps.in_parameter_declaration = 0;
 		ps.in_decl = false;
+	    }
 	    dec_ind = 0;
 	    parse(lbrace);	/* let parser know about this */
 	    if (ps.want_blank)	/* put a blank before '{' if '{' is not at
 @@ -1020,28 +1013,27 @@ main(int argc, char **argv)
 	case keyword_do_else:
 	    ps.in_stmt = false;
 	    if (*token == 'e') {
 		if (e_code != s_code && (!opt.cuddle_else || e_code[-1] != '}')) {
 		    if (opt.verbose)
 			diag(0, "Line broken");
 		    dump_line();/* make sure this starts a line */
 		    ps.want_blank = false;
+		}
 		force_nl = true;/* also, following stuff must go onto new line */
 		last_else = 1;
 		parse(keyword_else);
 	    } else {
 	    else {
 		if (e_code != s_code) {	/* make sure this starts a line */
 		    if (opt.verbose)
 			diag(0, "Line broken");
 		    dump_line();
 		    ps.want_blank = false;
+		}
 		force_nl = true;/* also, following stuff must go onto new line */
 		last_else = 0;
 		parse(keyword_do);
+	    }
 	    goto copy_id;	/* move the token into line */
 	case type_def:
 @@ -1082,41 +1074,38 @@ main(int argc, char **argv)
 		dec_ind = opt.local_decl_indent > 0 ? opt.local_decl_indent : i;
 		tabs_to_var = (opt.use_tabs ? opt.local_decl_indent > 0 : 0);
+	    }
 	    goto copy_id;
 	case funcname:
 	case ident:		/* got an identifier or constant */
 	    if (ps.in_decl) {
 		if (type_code == funcname) {
 		    ps.in_decl = false;
 		    if (opt.procnames_start_line && s_code != e_code) {
 			*e_code = '\0';
 			dump_line();
 		    } else if (ps.want_blank) {
 		    else if (ps.want_blank) {
 			*e_code++ = ' ';
+		    }
 		    ps.want_blank = false;
 		} else if (!ps.block_init && !ps.dumped_decl_indent &&
 		else if (!ps.block_init && !ps.dumped_decl_indent &&
 		    ps.paren_level == 0) { /* if we are in a declaration, we
 					    * must indent identifier */
 		    indent_declaration(dec_ind, tabs_to_var);
 		    ps.dumped_decl_indent = true;
 		    ps.want_blank = false;
+		}
 	    } else if (sp_sw && ps.p_l_follow == 0) {
 	    else if (sp_sw && ps.p_l_follow == 0) {
 		sp_sw = false;
 		force_nl = true;
 		ps.last_u_d = true;
 		ps.in_stmt = false;
 		parse(hd_type);
+	    }
     copy_id:
+	    {
 		int len = e_token - s_token;
 		check_size_code(len + 1);
 		if (ps.want_blank)
 		    *e_code++ = ' ';
 @@ -1221,28 +1210,27 @@ main(int argc, char **argv)
+			}
 			break;
+		    }
+		}
 		while (e_lab > s_lab && (e_lab[-1] == ' ' || e_lab[-1] == '\t'))
 		    e_lab--;
 		if (e_lab - s_lab == com_end && bp_save == NULL) {
 		    /* comment on preprocessor line */
 		    if (sc_end == NULL) {	/* if this is the first comment,
 						 * we must set up the buffer */
 			save_com = sc_buf;
 			sc_end = &save_com[0];
 		    } else {
 		    else {
 			*sc_end++ = '\n';	/* add newline between
 						 * comments */
 			*sc_end++ = ' ';
 			--line_no;
+		    }
 		    if (sc_end - save_com + com_end - com_start > sc_size)
 			errx(1, "input too long");
 		    memmove(sc_end, s_lab + com_start, com_end - com_start);
 		    sc_end += com_end - com_start;
 		    e_lab = s_lab + com_start;
 		    while (e_lab > s_lab && (e_lab[-1] == ' ' || e_lab[-1] == '\t'))
 			e_lab--;
 		    bp_save = buf_ptr;	/* save current input buffer */
 @@ -1253,39 +1241,36 @@ main(int argc, char **argv)
 		    *sc_end++ = ' ';	/* add trailing blank, just in case */
 		    buf_end = sc_end;
 		    sc_end = NULL;
+		}
 		check_size_label(1);
 		*e_lab = '\0';	/* null terminate line */
 		ps.pcase = false;
+	    }
 	    if (strncmp(s_lab, "#if", 3) == 0) { /* also ifdef, ifndef */
 		if ((size_t)ifdef_level < nitems(state_stack)) {
 		    match_state[ifdef_level].tos = -1;
 		    state_stack[ifdef_level++] = ps;
 		} else
 		else
 		    diag(1, "#if stack overflow");
 	    } else if (strncmp(s_lab, "#el", 3) == 0) { /* else, elif */
 	    else if (strncmp(s_lab, "#el", 3) == 0) { /* else, elif */
 		if (ifdef_level <= 0)
 		    diag(1, s_lab[3] == 'i' ? "Unmatched #elif" : "Unmatched #else");
 		else {
 		    match_state[ifdef_level - 1] = ps;
 		    ps = state_stack[ifdef_level - 1];
+		}
 	    } else if (strncmp(s_lab, "#endif", 6) == 0) {
 	    else if (strncmp(s_lab, "#endif", 6) == 0) {
 		if (ifdef_level <= 0)
 		    diag(1, "Unmatched #endif");
 		else
 		    ifdef_level--;
 	    } else {
 		static const struct directives {
 		    int size;
 		    const char *string;
 		} recognized[] = {
 		    {7, "include"},
 		    {6, "define"},
 		    {5, "undef"},
 		    {4, "line"},
 @@ -1294,28 +1279,27 @@ main(int argc, char **argv)
 		};
 		int d = nitems(recognized);
 		while (--d >= 0)
 		    if (strncmp(s_lab + 1, recognized[d].string, recognized[d].size) == 0)
 			break;
 		if (d < 0) {
 		    diag(1, "Unrecognized cpp directive");
 		    break;
+		}
+	    }
 	    if (opt.blanklines_around_conditional_compilation) {
 		postfix_blankline_requested++;
 		n_real_blanklines = 0;
 	    } else {
 	    else {
 		postfix_blankline_requested = 0;
 		prefix_blankline_requested = 0;
+	    }
 	    break;		/* subsequent processing of the newline
 				 * character will cause the line to be printed */
 	case comment:		/* we have gotten a / followed by * this is a biggie */
 	    pr_comment();
 	    break;
 	default:
 	    break;
 	}			/* end of big switch stmt */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: io.c,v 1.29 2021/03/12 19:14:18 rillig Exp $	*/
+/*	$NetBSD: io.c,v 1.30 2021/03/12 23:10:18 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
 @@ -36,27 +36,27 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #if 0
 #ifndef lint
 static char sccsid[] = "@(#)io.c	8.1 (Berkeley) 6/6/93";
 #endif /* not lint */
 #endif
 #include <sys/cdefs.h>
 #ifndef lint
 #if defined(__NetBSD__)
-__RCSID("$NetBSD: io.c,v 1.29 2021/03/12 19:14:18 rillig Exp $");
+__RCSID("$NetBSD: io.c,v 1.30 2021/03/12 23:10:18 rillig Exp $");
 #elif defined(__FreeBSD__)
 __FBSDID("$FreeBSD: head/usr.bin/indent/io.c 334927 2018-06-10 16:44:18Z pstef $");
 #endif
 #endif
 #include <ctype.h>
 #include <err.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 #include "indent.h"
 @@ -94,43 +94,42 @@ output_int(int i)
  * source. It prints the label section, followed by the code section with
  * the appropriate nesting level, followed by any comments.
  */
 void
 dump_line(void)
+{
     int cur_col, target_col;
     static int  not_first_line;
     if (ps.procname[0]) {
 	ps.ind_level = 0;
 	ps.procname[0] = 0;
+    }
     if (s_code == e_code && s_lab == e_lab && s_com == e_com) {
 	if (suppress_blanklines > 0)
 	    suppress_blanklines--;
 	else {
 	    ps.bl_line = true;
 	    n_real_blanklines++;
+	}
     } else if (!inhibit_formatting) {
     else if (!inhibit_formatting) {
 	suppress_blanklines = 0;
 	ps.bl_line = false;
 	if (prefix_blankline_requested && not_first_line) {
 	    if (opt.swallow_optional_blanklines) {
 		if (n_real_blanklines == 1)
 		    n_real_blanklines = 0;
 	    } else {
 	    else {
 		if (n_real_blanklines == 0)
 		    n_real_blanklines = 1;
+	    }
+	}
 	while (--n_real_blanklines >= 0)
 	    output_char('\n');
 	n_real_blanklines = 0;
 	if (ps.ind_level == 0)
 	    ps.ind_stmt = 0;	/* this is a class A kludge. dont do
 				 * additional statement indentation if we are
 				 * at bracket level 0 */
 	if (e_lab != s_lab || e_code != s_code)
 @@ -158,28 +157,27 @@ dump_line(void)
 		if (s < e_lab) {
 		    if (s[0] == '/' && s[1] == '*') {
 			output_char('\t');
 			output_range(s, e_lab);
 		    } else {
 		        output_string("\t/* ");
 			output_range(s, e_lab);
 			output_string(" */");
+		    }
+		}
 	    } else
 	        output_range(s_lab, e_lab);
 	    cur_col = count_spaces(cur_col, s_lab);
 	} else
 	else
 	    cur_col = 1;	/* there is no label section */
 	ps.pcase = false;
 	if (s_code != e_code) {	/* print code section, if any */
 	    char *p;
 	    if (comment_open) {
 		comment_open = 0;
 		output_string(".*/\n");
+	    }
 	    target_col = compute_code_target();
+	    {
 @@ -201,52 +199,50 @@ dump_line(void)
 	    int target = ps.com_col;
 	    char *com_st = s_com;
 	    target += ps.comment_delta;
 	    while (*com_st == '\t')	/* consider original indentation in
 				     * case this is a box comment */
 		com_st++, target += opt.tabsize;
 	    while (target <= 0)
 		if (*com_st == ' ')
 		    target++, com_st++;
 		else if (*com_st == '\t') {
 		    target = opt.tabsize * (1 + (target - 1) / opt.tabsize) + 1;
 		    com_st++;
 		} else
 		else
 		    target = 1;
 	    if (cur_col > target) {	/* if comment can't fit on this line,
 				     * put it on next line */
 		output_char('\n');
 		cur_col = 1;
 		++ps.out_lines;
+	    }
 	    while (e_com > com_st && isspace((unsigned char)e_com[-1]))
 		e_com--;
 	    (void)pad_output(cur_col, target);
 	    output_range(com_st, e_com);
 	    ps.comment_delta = ps.n_comment_delta;
 	    ++ps.com_lines;	/* count lines with comments */
+	}
 	if (ps.use_ff)
 	    output_char('\014');
 	else
 	    output_char('\n');
 	++ps.out_lines;
 	if (ps.just_saw_decl == 1 && opt.blanklines_after_declarations) {
 	    prefix_blankline_requested = 1;
 	    ps.just_saw_decl = 0;
 	} else
 	else
 	    prefix_blankline_requested = postfix_blankline_requested;
 	postfix_blankline_requested = 0;
+    }
     /* keep blank lines after '//' comments */
     if (e_com - s_com > 1 && s_com[1] == '/')
 	output_range(s_token, e_token);
     ps.decl_on_line = ps.in_decl;	/* if we are in the middle of a
 					 * declaration, remember that fact for
 					 * proper comment indentation */
     ps.ind_stmt = ps.in_stmt & ~ps.in_decl;	/* next line should be
 						 * indented if we have not
 @@ -260,46 +256,45 @@ dump_line(void)
     *(e_com = s_com = combuf + 1) = '\0';
     ps.ind_level = ps.i_l_follow;
     ps.paren_level = ps.p_l_follow;
     if (ps.paren_level > 0)
 	paren_target = -ps.paren_indents[ps.paren_level - 1];
     not_first_line = 1;
+}
 int
 compute_code_target(void)
+{
     int target_col = opt.ind_size * ps.ind_level + 1;
-    if (ps.paren_level)
+    if (ps.paren_level) {
 	if (!opt.lineup_to_parens)
 	    target_col += opt.continuation_indent *
 		(2 * opt.continuation_indent == opt.ind_size ? 1 : ps.paren_level);
 	else if (opt.lineup_to_parens_always)
 	    target_col = paren_target;
 	else {
 	    int w;
 	    int t = paren_target;
 	    if ((w = count_spaces(t, s_code) - opt.max_col) > 0
 		    && count_spaces(target_col, s_code) <= opt.max_col) {
 		t -= w + 1;
 		if (t > target_col)
 		    target_col = t;
 	    } else
 	    else
 		target_col = t;
+	}
-    else if (ps.ind_stmt)
+    } else if (ps.ind_stmt)
 	target_col += opt.continuation_indent;
     return target_col;
+}
 int
 compute_label_target(void)
+{
     return
 	ps.pcase ? (int) (case_ind * opt.ind_size) + 1
 	: *s_lab == '#' ? 1
 	: opt.ind_size * (ps.ind_level - label_offset) + 1;
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: lexi.c,v 1.37 2021/03/12 18:11:50 rillig Exp $	*/
+/*	$NetBSD: lexi.c,v 1.38 2021/03/12 23:10:18 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
 @@ -36,27 +36,27 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #if 0
 #ifndef lint
 static char sccsid[] = "@(#)lexi.c	8.1 (Berkeley) 6/6/93";
 #endif /* not lint */
 #endif
 #include <sys/cdefs.h>
 #ifndef lint
 #if defined(__NetBSD__)
-__RCSID("$NetBSD: lexi.c,v 1.37 2021/03/12 18:11:50 rillig Exp $");
+__RCSID("$NetBSD: lexi.c,v 1.38 2021/03/12 23:10:18 rillig Exp $");
 #elif defined(__FreeBSD__)
 __FBSDID("$FreeBSD: head/usr.bin/indent/lexi.c 337862 2018-08-15 18:19:45Z pstef $");
 #endif
 #endif
 /*
  * Here we have the token scanner for indent.  It scans off one token and puts
  * it in the global variable "token".  It returns a code, indicating the type
  * of token scanned.
  */
 #include <assert.h>
 #include <err.h>
 @@ -331,43 +331,43 @@ lexi(struct parser_state *state)
 	    for (s = 'A'; s != 'f' && s != 'i' && s != 'u'; ) {
 		i = (unsigned char)*buf_ptr;
 		if (i >= nitems(table) || table[i] == NULL ||
 		    table[i][s - 'A'] == ' ') {
 		    s = table[0][s - 'A'];
 		    break;
+		}
 		s = table[i][s - 'A'];
 		check_size_token(1);
 		*e_token++ = inbuf_next();
+	    }
 	    /* s now indicates the type: f(loating), i(integer), u(nknown) */
 	} else {
 	else
 	    while (isalnum((unsigned char)*buf_ptr) ||
-	        *buf_ptr == '\\' ||
+		   *buf_ptr == '\\' ||
-		*buf_ptr == '_' || *buf_ptr == '$') {
+		   *buf_ptr == '_' || *buf_ptr == '$') {
 		/* fill_buffer() terminates buffer with newline */
 		if (*buf_ptr == '\\') {
 		    if (buf_ptr[1] == '\n') {
 			buf_ptr += 2;
 			if (buf_ptr >= buf_end)
 			    fill_buffer();
 		    } else
 			break;
+		}
 		check_size_token(1);
 		*e_token++ = inbuf_next();
+	    }
+	}
 	*e_token = '\0';
 	if (s_token[0] == 'L' && s_token[1] == '\0' &&
 	      (*buf_ptr == '"' || *buf_ptr == '\''))
 	    return lexi_end(string_prefix);
 	while (*buf_ptr == ' ' || *buf_ptr == '\t')	/* get rid of blanks */
 	    inbuf_next();
 	state->keyword = rw_0;
 	if (state->last_token == keyword_struct_union_enum &&
 	    !state->p_l_follow) {
 	    /* if last token was 'struct' and we're not in parentheses, then
 	     * this token should be treated as a declaration */
 @@ -494,28 +494,27 @@ lexi(struct parser_state *state)
 	    while (1) {		/* move one character or [/<char>]<char> */
 		if (*buf_ptr == '\n') {
 		    diag(1, "Unterminated literal");
 		    goto stop_lit;
+		}
 		check_size_token(2);
 		*e_token = inbuf_next();
 		if (*e_token == '\\') {		/* if escape, copy extra char */
 		    if (*buf_ptr == '\n')	/* check for escaped newline */
 			++line_no;
 		    *++e_token = inbuf_next();
 		    ++e_token;	/* we must increment this again because we
 				 * copied two chars */
 		} else
 		else
 		    break;	/* we copied one character */
 	    }			/* end of while (1) */
 	} while (*e_token++ != qchar);
 stop_lit:
 	code = ident;
 	break;
     case ('('):
     case ('['):
 	unary_delim = true;
 	code = lparen;
 	break;
 @@ -581,28 +580,27 @@ stop_lit:
     case '+':			/* check for -, +, --, ++ */
 	code = (state->last_u_d ? unary_op : binary_op);
 	unary_delim = true;
 	if (*buf_ptr == token[0]) {
 	    /* check for doubled character */
 	    *e_token++ = *buf_ptr++;
 	    /* buffer overflow will be checked at end of loop */
 	    if (state->last_token == ident || state->last_token == rparen) {
 		code = (state->last_u_d ? unary_op : postfix_op);
 		/* check for following ++ or -- */
 		unary_delim = false;
+	    }
 	} else if (*buf_ptr == '=')
 	else if (*buf_ptr == '=')
 	    /* check for operator += */
 	    *e_token++ = *buf_ptr++;
 	else if (*buf_ptr == '>') {
 	    /* check for operator -> */
 	    *e_token++ = *buf_ptr++;
 	    unary_delim = false;
 	    code = unary_op;
 	    state->want_blank = false;
+	}
 	break;			/* buffer overflow will be checked at end of
 				 * switch */
     case '=':
 @@ -705,28 +703,27 @@ add_typename(const char *key)
     if (typename_top + 1 >= typename_count) {
 	typenames = realloc((void *)typenames,
 	    sizeof(typenames[0]) * (typename_count *= 2));
 	if (typenames == NULL)
 	    err(1, NULL);
+    }
     if (typename_top == -1)
 	typenames[++typename_top] = copy = strdup(key);
     else if ((comparison = strcmp(key, typenames[typename_top])) >= 0) {
 	/* take advantage of sorted input */
 	if (comparison == 0)	/* remove duplicates */
 	    return;
 	typenames[++typename_top] = copy = strdup(key);
     } else {
     else {
 	int p;
 	for (p = 0; (comparison = strcmp(key, typenames[p])) > 0; p++)
 	    /* find place for the new key */;
 	if (comparison == 0)	/* remove duplicates */
 	    return;
 	memmove(&typenames[p + 1], &typenames[p],
 	    sizeof(typenames[0]) * (++typename_top - p));
 	typenames[p] = copy = strdup(key);
+    }
     if (copy == NULL)
 	err(1, NULL);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: parse.c,v 1.17 2021/03/09 19:14:39 rillig Exp $	*/
+/*	$NetBSD: parse.c,v 1.18 2021/03/12 23:10:18 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
 @@ -146,28 +146,27 @@ parse(token_type tk)		/* tk: the code fo
 	ps.p_stack[++ps.tos] = lbrace;
 	ps.il[ps.tos] = ps.ind_level;
 	ps.p_stack[++ps.tos] = stmt;
 	/* allow null stmt between braces */
 	ps.il[ps.tos] = ps.i_l_follow;
 	break;
     case while_expr:		/* 'while' '(' <expr> ')' */
 	if (ps.p_stack[ps.tos] == do_stmt) {
 	    /* it is matched with do stmt */
 	    ps.ind_level = ps.i_l_follow = ps.il[ps.tos];
 	    ps.p_stack[++ps.tos] = while_expr;
 	    ps.il[ps.tos] = ps.ind_level = ps.i_l_follow;
 	} else {		/* it is a while loop */
 	else {			/* it is a while loop */
 	    ps.p_stack[++ps.tos] = while_expr;
 	    ps.il[ps.tos] = ps.i_l_follow;
 	    ++ps.i_l_follow;
 	    ps.search_brace = opt.btype_2;
+	}
 	break;
     case keyword_else:
 	if (ps.p_stack[ps.tos] != if_expr_stmt)
 	    diag(1, "Unmatched 'else'");
 	else {
 	    ps.ind_level = ps.il[ps.tos];	/* indentation for else should
 @@ -175,28 +174,27 @@ parse(token_type tk)		/* tk: the code fo
 	    ps.i_l_follow = ps.ind_level + 1;	/* everything following should
 						 * be in 1 level */
 	    ps.p_stack[ps.tos] = if_expr_stmt_else;
 	    /* remember if with else */
 	    ps.search_brace = opt.btype_2 | opt.else_if;
+	}
 	break;
     case rbrace:		/* scanned a } */
 	/* stack should have <lbrace> <stmt> or <lbrace> <stmt_list> */
 	if (ps.tos > 0 && ps.p_stack[ps.tos - 1] == lbrace) {
 	    ps.ind_level = ps.i_l_follow = ps.il[--ps.tos];
 	    ps.p_stack[ps.tos] = stmt;
 	} else
 	else
 	    diag(1, "Statement nesting error");
 	break;
     case switch_expr:		/* had switch (...) */
 	ps.p_stack[++ps.tos] = switch_expr;
 	ps.cstk[ps.tos] = case_ind;
 	/* save current case indent level */
 	ps.il[ps.tos] = ps.i_l_follow;
 	case_ind = ps.i_l_follow + opt.case_indent;	/* cases should be one
 							 * level down from
 							 * switch */
 	ps.i_l_follow += opt.case_indent + 1;	/* statements should be two
 						 * levels in */