 @@ -1,10 +1,13 @@
-#	$NetBSD: Makefile,v 1.10 2021/03/12 19:11:29 rillig Exp $
+#	$NetBSD: Makefile,v 1.11 2021/03/14 00:22:16 rillig Exp $
 #	from: @(#)Makefile	8.1 (Berkeley) 6/6/93
 PROG=	indent
 SRCS=	indent.c io.c lexi.c parse.c pr_comment.c args.c
 CPPFLAGS+=	${DEBUG:D-Ddebug}
-LINTFLAGS+=	-e
+LINTFLAGS+=	-e -w
 # bug in lint; see tests/usr.bin/lint/lint1/msg_168.c
 LINTFLAGS.lexi.c+=	-X 168
 .include <bsd.prog.mk>

 @@ -1,14 +1,14 @@
-/*	$NetBSD: args.c,v 1.21 2021/03/13 13:51:08 rillig Exp $	*/
+/*	$NetBSD: args.c,v 1.22 2021/03/14 00:22:16 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[] = "@(#)args.c	8.1 (Berkeley) 6/6/93";
 #endif /* not lint */
 #endif
 #include <sys/cdefs.h>
 #ifndef lint
 #if defined(__NetBSD__)
-__RCSID("$NetBSD: args.c,v 1.21 2021/03/13 13:51:08 rillig Exp $");
+__RCSID("$NetBSD: args.c,v 1.22 2021/03/14 00:22:16 rillig Exp $");
 #elif defined(__FreeBSD__)
 __FBSDID("$FreeBSD: head/usr.bin/indent/args.c 336318 2018-07-15 21:04:21Z pstef $");
 #endif
 #endif
 /*
  * Argument scanning and profile reading code.  Default parameters are set
  * here as well.
  */
 #include <ctype.h>
 #include <err.h>
 #include <limits.h>
 @@ -202,32 +202,32 @@ set_profile(const char *profile_name)
 	scan_profile(f);
 	(void) fclose(f);
+    }
     option_source = "Command line";
+}
 static void
 scan_profile(FILE *f)
+{
     int		comment_index, i;
     char	*p;
     char        buf[BUFSIZ];
-    while (1) {
+    for (;;) {
 	p = buf;
 	comment_index = 0;
 	while ((i = getc(f)) != EOF) {
 	    if (i == '*' && !comment_index && p > buf && p[-1] == '/') {
-		comment_index = p - buf;
+		comment_index = (int)(p - buf);
 		*p++ = i;
 	    } else if (i == '/' && comment_index && p > buf && p[-1] == '*') {
 		p = buf + comment_index - 1;
 		comment_index = 0;
 	    } else if (isspace((unsigned char)i)) {
 		if (p > buf && !comment_index)
 		    break;
 	    } else {
 		*p++ = i;
+	    }
+	}
 	if (p != buf) {
 	    *p++ = 0;
 @@ -304,26 +304,27 @@ found:
 		goto need_param;
 	    add_typename(param_start);
 	    break;
 	case KEY_FILE:
 	    if (*param_start == 0)
 		goto need_param;
 	    add_typedefs_from_file(param_start);
 	    break;
 	case VERSION:
 	    printf("FreeBSD indent %s\n", INDENT_VERSION);
 	    exit(0);
 	    /*NOTREACHED*/
 	default:
 	    errx(1, "set_option: internal error: p_special %d", p->p_special);
+	}
 	break;
     case PRO_BOOL:
 	if (p->p_special == OFF)
 	    *p->p_obj = false;
 	else
 	    *p->p_obj = true;
 	break;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: indent.c,v 1.58 2021/03/13 18:46:39 rillig Exp $	*/
+/*	$NetBSD: indent.c,v 1.59 2021/03/14 00:22:16 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.58 2021/03/13 18:46:39 rillig Exp $");
+__RCSID("$NetBSD: indent.c,v 1.59 2021/03/14 00:22:16 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>
 @@ -196,36 +196,37 @@ search_brace(token_type *inout_type_code
 		sc_end = &save_com[2];
+	    }
 	    *sc_end++ = '\n';
 	    /*
 	     * We may have inherited a force_nl == true from the previous
 	     * token (like a semicolon). But once we know that a newline
 	     * has been scanned in this loop, force_nl should be false.
+	     *
 	     * However, the force_nl == true must be preserved if newline
 	     * is never scanned in this loop, so this assignment cannot be
 	     * done earlier.
 	     */
 	    *inout_force_nl = false;
 	    break;
 	case form_feed:
 	    break;
 	case comment:
 	    if (sc_end == NULL) {
 		/*
 		 * Copy everything from the start of the line, because
 		 * process_comment() will use that to calculate original
 		 * indentation of a boxed comment.
 		 */
-		memcpy(sc_buf, in_buffer, buf_ptr - in_buffer - 4);
+		memcpy(sc_buf, in_buffer, (size_t)(buf_ptr - in_buffer) - 4);
 		save_com = sc_buf + (buf_ptr - in_buffer - 4);
 		save_com[0] = save_com[1] = ' ';
 		sc_end = &save_com[2];
+	    }
 	    *inout_comment_buffered = true;
 	    *sc_end++ = '/';	/* copy in start of comment */
 	    *sc_end++ = '*';
 	    for (;;) {		/* loop until the end of the comment */
 		*sc_end = *buf_ptr++;
 		if (buf_ptr >= buf_end)
 		    fill_buffer();
 		if (*sc_end++ == '*' && *buf_ptr == '/')
 		    break;	/* we are at end of comment */
 @@ -522,27 +523,27 @@ main_parse_command_line(int argc, char *
 	opt.continuation_indent = opt.indent_size;
+}
 static void
 main_prepare_parsing(void)
+{
     fill_buffer();		/* get first batch of stuff into input buffer */
     parse(semicolon);
     char *p = buf_ptr;
     int col = 1;
-    while (1) {
+    for (;;) {
 	if (*p == ' ')
 	    col++;
 	else if (*p == '\t')
 	    col = opt.tabsize * (1 + (col - 1) / opt.tabsize) + 1;
 	else
 	    break;
 	p++;
+    }
     if (col > opt.indent_size)
 	ps.ind_level = ps.i_l_follow = col / opt.indent_size;
+}
 static void
 @@ -575,27 +576,27 @@ process_comment_in_code(token_type type_
 	/* we should force a broken line here */
 	if (opt.verbose)
 	    diag(0, "Line broken");
 	dump_line();
 	ps.want_blank = false;	/* dont insert blank at line start */
 	*inout_force_nl = false;
+    }
     ps.in_stmt = true;		/* turn on flag which causes an extra level of
 				 * indentation. this is turned off by a ; or
 				 * '}' */
     if (s_com != e_com) {	/* the turkey has embedded a comment
 				 * in a line. fix it */
-	int len = e_com - s_com;
+	size_t 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;
+    }
+}
 static void
 @@ -714,39 +715,39 @@ process_unary_op(int dec_ind, int tabs_t
 	/*
 	 * if this is a unary op in a declaration, we should indent
 	 * this token
 	 */
 	int i;
 	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)
 	*e_code++ = ' ';
+    {
-	int len = e_token - s_token;
+	size_t len = e_token - s_token;
 	check_size_code(len);
 	memcpy(e_code, token, len);
 	e_code += len;
+    }
     ps.want_blank = false;
+}
 static void
 process_binary_op(void)
+{
-    int len = e_token - s_token;
+    size_t len = e_token - s_token;
     check_size_code(len + 1);
     if (ps.want_blank)
 	*e_code++ = ' ';
     memcpy(e_code, token, len);
     e_code += len;
     ps.want_blank = true;
+}
 static void
 process_postfix_op(void)
+{
 @@ -779,27 +780,27 @@ process_colon(int *inout_squest, int *in
 	return;
+    }
     if (ps.in_or_st) {
 	*e_code++ = ':';
 	ps.want_blank = false;
 	return;
+    }
     ps.in_stmt = false;		/* seeing a label does not imply we are in a
 				 * stmt */
     /*
      * turn everything so far into a label
      */
+    {
-	int len = e_code - s_code;
+	size_t len = e_code - s_code;
 	check_size_label(len + 3);
 	memcpy(e_lab, s_code, len);
 	e_lab += len;
 	*e_lab++ = ':';
 	*e_lab = '\0';
 	e_code = s_code;
+    }
     *inout_force_nl = ps.pcase = *inout_scase;	/* ps.pcase will be used by
 						 * dump_line to decide how to
 						 * indent the label. force_nl
 						 * will force a case n: to be
 						 * on a line by itself */
 @@ -1056,39 +1057,39 @@ process_ident(token_type type_code, int
+	}
     } else if (*inout_sp_sw && ps.p_l_follow == 0) {
 	*inout_sp_sw = false;
 	*inout_force_nl = true;
 	ps.last_u_d = true;
 	ps.in_stmt = false;
 	parse(hd_type);
+    }
+}
 static void
 copy_id(void)
+{
-    int len = e_token - s_token;
+    size_t len = e_token - s_token;
     check_size_code(len + 1);
     if (ps.want_blank)
 	*e_code++ = ' ';
     memcpy(e_code, s_token, len);
     e_code += len;
+}
 static void
 process_string_prefix(void)
+{
-    int len = e_token - s_token;
+    size_t len = e_token - s_token;
     check_size_code(len + 1);
     if (ps.want_blank)
 	*e_code++ = ' ';
     memcpy(e_code, token, len);
     e_code += len;
     ps.want_blank = false;
+}
 static void
 process_period(void)
+{
 @@ -1145,46 +1146,46 @@ process_preprocessing(void)
 		fill_buffer();
 	    switch (*e_lab++) {
 	    case '\\':
 		if (!in_comment) {
 		    *e_lab++ = *buf_ptr++;
 		    if (buf_ptr >= buf_end)
 			fill_buffer();
+		}
 		break;
 	    case '/':
 		if (*buf_ptr == '*' && !in_comment && quote == '\0') {
 		    in_comment = 1;
 		    *e_lab++ = *buf_ptr++;
-		    com_start = e_lab - s_lab - 2;
+		    com_start = (int)(e_lab - s_lab) - 2;
+		}
 		break;
 	    case '"':
 		if (quote == '"')
 		    quote = '\0';
 		else if (quote == '\0')
 		    quote = '"';
 		break;
 	    case '\'':
 		if (quote == '\'')
 		    quote = '\0';
 		else if (quote == '\0')
 		    quote = '\'';
 		break;
 	    case '*':
 		if (*buf_ptr == '/' && in_comment) {
 		    in_comment = 0;
 		    *e_lab++ = *buf_ptr++;
-		    com_end = e_lab - s_lab;
+		    com_end = (int)(e_lab - s_lab);
+		}
 		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];
 @@ -1284,27 +1285,27 @@ main_loop(void)
     int         squest;		/* when this is positive, we have seen a ?
 				 * without the matching : in a <c>?<s>:<s>
 				 * construct */
     int         scase;		/* set to true when we see a case, so we will
 				 * know what to do with the following colon */
     sp_sw = force_nl = false;
     dec_ind = 0;
     di_stack[ps.dec_nest = 0] = 0;
     scase = false;
     squest = 0;
     tabs_to_var = 0;
-    while (1) {			/* this is the main loop.  it will go until we
+    for (;;) {			/* this is the main loop.  it will go until we
 				 * reach eof */
 	int comment_buffered = false;
 	type_code = lexi(&ps);	/* lexi reads one token.  The actual
 				 * characters read are stored in "token". lexi
 				 * returns a code indicating the type of token */
 	/*
 	 * The following code moves newlines and comments following an if (),
 	 * while (), else, etc. up to the start of the following stmt to
 	 * a buffer. This allows proper handling of both kinds of brace
 	 * placement (-br, -bl) and cuddling "else" (-ce).
 	 */
 @@ -1374,27 +1375,27 @@ main_loop(void)
 	    goto copy_id;
 	case colon:		/* got a ':' */
 	    process_colon(&squest, &force_nl, &scase);
 	    break;
 	case semicolon:		/* got a ';' */
 	    process_semicolon(&scase, &squest, dec_ind, tabs_to_var, &sp_sw,
 		hd_type, &force_nl);
 	    break;
 	case lbrace:		/* got a '{' */
 	    process_lbrace(&force_nl, &sp_sw, hd_type, di_stack,
-		nitems(di_stack), &dec_ind);
+		(int)nitems(di_stack), &dec_ind);
 	    break;
 	case rbrace:		/* got a '}' */
 	    process_rbrace(&sp_sw, &dec_ind, di_stack);
 	    break;
 	case switch_expr:	/* got keyword "switch" */
 	    sp_sw = true;
 	    hd_type = switch_expr; /* keep this for when we have seen the
 				 * expression */
 	    goto copy_id;	/* go move the token into buffer */
 	case keyword_for_if_while:
 @@ -1474,67 +1475,67 @@ main(int argc, char **argv)
 #endif
     main_prepare_parsing();
     main_loop();
+}
 /*
  * copy input file to backup file if in_name is /blah/blah/blah/file, then
  * backup file will be ".Bfile" then make the backup file the input and
  * original input file the output
  */
 static void
 bakcopy(void)
+{
-    int         n,
+    ssize_t n;
-                bakchn;
+    int bakchn;
-    char        buff[8 * 1024];
+    char buff[8 * 1024];
     const char *p;
     /* construct file name .Bfile */
     for (p = in_name; *p; p++);	/* skip to end of string */
     while (p > in_name && *p != '/')	/* find last '/' */
 	p--;
     if (*p == '/')
 	p++;
     sprintf(bakfile, "%s%s", p, simple_backup_suffix);
     /* copy in_name to backup file */
     bakchn = creat(bakfile, 0600);
     if (bakchn < 0)
 	err(1, "%s", bakfile);
     while ((n = read(fileno(input), buff, sizeof(buff))) > 0)
-	if (write(bakchn, buff, n) != n)
+	if (write(bakchn, buff, (size_t)n) != n)
 	    err(1, "%s", bakfile);
     if (n < 0)
 	err(1, "%s", in_name);
     close(bakchn);
     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
 indent_declaration(int cur_dec_ind, int tabs_to_var)
+{
-    int pos = e_code - s_code;
+    int pos = (int)(e_code - s_code);
     char *startpos = e_code;
     /*
      * get the tab math right for indentations that are not multiples of tabsize
      */
     if ((ps.ind_level * opt.indent_size) % opt.tabsize != 0) {
 	pos += (ps.ind_level * opt.indent_size) % opt.tabsize;
 	cur_dec_ind += (ps.ind_level * opt.indent_size) % opt.tabsize;
+    }
     if (tabs_to_var) {
 	int tpos;
 	check_size_code(cur_dec_ind / opt.tabsize);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: io.c,v 1.47 2021/03/13 18:46:39 rillig Exp $	*/
+/*	$NetBSD: io.c,v 1.48 2021/03/14 00:22:16 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.47 2021/03/13 18:46:39 rillig Exp $");
+__RCSID("$NetBSD: io.c,v 1.48 2021/03/14 00:22:16 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"
 @@ -343,28 +343,28 @@ fill_buffer(void)
     FILE *f = input;
     if (bp_save != NULL) {	/* there is a partly filled input buffer left */
 	buf_ptr = bp_save;	/* do not read anything, just switch buffers */
 	buf_end = be_save;
 	bp_save = be_save = NULL;
 	debug_println("switched buf_ptr back to bp_save");
 	if (buf_ptr < buf_end)
 	    return;		/* only return if there is really something in
 				 * this buffer */
+    }
     for (p = in_buffer;;) {
 	if (p >= in_buffer_limit) {
-	    int size = (in_buffer_limit - in_buffer) * 2 + 10;
+	    size_t size = (in_buffer_limit - in_buffer) * 2 + 10;
-	    int offset = p - in_buffer;
+	    size_t offset = p - in_buffer;
 	    in_buffer = realloc(in_buffer, size);
 	    if (in_buffer == NULL)
 		errx(1, "input line too long");
 	    p = in_buffer + offset;
 	    in_buffer_limit = in_buffer + size - 2;
+	}
 	if ((i = getc(f)) == EOF) {
 	    *p++ = ' ';
 	    *p++ = '\n';
 	    had_eof = true;
 	    break;
+	}
 	if (i != '\0')

 @@ -1,14 +1,14 @@
-/*	$NetBSD: lexi.c,v 1.40 2021/03/13 11:27:01 rillig Exp $	*/
+/*	$NetBSD: lexi.c,v 1.41 2021/03/14 00:22:16 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.40 2021/03/13 11:27:01 rillig Exp $");
+__RCSID("$NetBSD: lexi.c,v 1.41 2021/03/14 00:22:16 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>
 @@ -471,27 +471,27 @@ lexi(struct parser_state *state)
 	state->last_nl = true;	/* remember that we just had a newline */
 	code = (had_eof ? end_of_file : newline);
 	/*
 	 * if data has been exhausted, the newline is a dummy, and we should
 	 * return code to stop
 	 */
 	break;
     case '\'':			/* start of quoted character */
     case '"':			/* start of string */
 	qchar = *token;
 	do {			/* copy the string */
-	    while (1) {		/* move one character or [/<char>]<char> */
+	    for (;;) {		/* 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

 @@ -1,14 +1,14 @@
-/*	$NetBSD: pr_comment.c,v 1.30 2021/03/13 18:11:31 rillig Exp $	*/
+/*	$NetBSD: pr_comment.c,v 1.31 2021/03/14 00:22:16 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.30 2021/03/13 18:11:31 rillig Exp $");
+__RCSID("$NetBSD: pr_comment.c,v 1.31 2021/03/14 00:22:16 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
 @@ -212,27 +212,27 @@ process_comment(void)
 	char       *t = e_com;
 	e_com = s_com + 2;
 	*e_com = 0;
 	if (opt.blanklines_before_blockcomments && ps.last_token != lbrace)
 	    prefix_blankline_requested = 1;
 	dump_line();
 	e_com = s_com = t;
 	if (!ps.box_com && opt.star_comment_cont)
 	    *e_com++ = ' ', *e_com++ = '*', *e_com++ = ' ';
+    }
     /* Start to copy the comment */
-    while (1) {			/* this loop will go until the comment is
+    for (;;) {			/* this loop will go until the comment is
 				 * copied */
 	switch (*buf_ptr) {	/* this checks for various special 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')
+		    ;