 @@ -1,14 +1,14 @@
-/*	$NetBSD: io.c,v 1.27 2021/03/08 22:28:31 rillig Exp $	*/
+/*	$NetBSD: io.c,v 1.28 2021/03/12 19:11:29 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,45 +36,69 @@
  * 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.27 2021/03/08 22:28:31 rillig Exp $");
+__RCSID("$NetBSD: io.c,v 1.28 2021/03/12 19:11:29 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"
 int         comment_open;
 static int  paren_target;
 static int pad_output(int current, int target);
 static void
 output_char(char ch)
+{
     fputc(ch, output);
+}
 static void
 output_range(const char *s, const char *e)
+{
     fwrite(s, 1, (size_t)(e - s), output);
+}
 static void
 output_string(const char *s)
+{
     output_range(s, s + strlen(s));
+}
 static void
 output_int(int i)
+{
     fprintf(output, "%d", i);
+}
 /*
  * dump_line is the routine that actually effects the printing of the new
  * 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;
 @@ -92,137 +116,144 @@ dump_line(void)
 	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 {
 		if (n_real_blanklines == 0)
 		    n_real_blanklines = 1;
+	    }
+	}
 	while (--n_real_blanklines >= 0)
-	    putc('\n', output);
+	    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)
 	    ++code_lines;	/* keep count of lines with code */
 	if (e_lab != s_lab) {	/* print lab, if any */
 	    if (comment_open) {
 		comment_open = 0;
-		fprintf(output, ".*/\n");
+		output_string(".*/\n");
+	    }
 	    while (e_lab > s_lab && (e_lab[-1] == ' ' || e_lab[-1] == '\t'))
 		e_lab--;
 	    *e_lab = '\0';
 	    cur_col = pad_output(1, compute_label_target());
 	    if (s_lab[0] == '#' && (strncmp(s_lab, "#else", 5) == 0
 				    || strncmp(s_lab, "#endif", 6) == 0)) {
 		char *s = s_lab;
 		if (e_lab[-1] == '\n') e_lab--;
 		do {
-		    putc(*s++, output);
+		    output_char(*s++);
 		} while (s < e_lab && 'a' <= *s && *s <= 'z');
 		while ((*s == ' ' || *s == '\t') && s < e_lab)
 		    s++;
-		if (s < e_lab)
+		if (s < e_lab) {
-		    fprintf(output, s[0]=='/' && s[1]=='*' ? "\t%.*s" : "\t/* %.*s */",
+		    if (s[0] == '/' && s[1] == '*') {
-			    (int)(e_lab - s), s);
+			output_char('\t');
 			output_range(s, e_lab);
-	    else fprintf(output, "%.*s", (int)(e_lab - s_lab), s_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
 	    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;
-		fprintf(output, ".*/\n");
+		output_string(".*/\n");
+	    }
 	    target_col = compute_code_target();
+	    {
 		int i;
 		for (i = 0; i < ps.p_l_follow; i++)
 		    if (ps.paren_indents[i] >= 0)
 			ps.paren_indents[i] = -(ps.paren_indents[i] + target_col);
+	    }
 	    cur_col = pad_output(cur_col, target_col);
 	    for (p = s_code; p < e_code; p++)
 		if (*p == (char) 0200)
-		    fprintf(output, "%d", target_col * 7);
+		    output_int(target_col * 7);
 		else
-		    putc(*p, output);
+		    output_char(*p);
 	    cur_col = count_spaces(cur_col, s_code);
+	}
 	if (s_com != e_com) {		/* print comment, if any */
 	    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
 		    target = 1;
 	    if (cur_col > target) {	/* if comment can't fit on this line,
 				     * put it on next line */
-		putc('\n', output);
+		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);
-	    fwrite(com_st, e_com - com_st, 1, output);
+	    output_range(com_st, e_com);
 	    ps.comment_delta = ps.n_comment_delta;
 	    ++ps.com_lines;	/* count lines with comments */
+	}
 	if (ps.use_ff)
-	    putc('\014', output);
+	    output_char('\014');
 	else
-	    putc('\n', output);
+	    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
 	    prefix_blankline_requested = postfix_blankline_requested;
 	postfix_blankline_requested = 0;
+    }
     /* keep blank lines after '//' comments */
     if (e_com - s_com > 1 && s_com[1] == '/')
-	fprintf(output, "%.*s", (int)(e_token - s_token), s_token);
+	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
 						 * completed this stmt and if
 						 * we are not in the middle of
 						 * a declaration */
     ps.use_ff = false;
     ps.dumped_decl_indent = 0;
     *(e_lab = s_lab) = '\0';	/* reset buffers */
     *(e_code = s_code) = '\0';
 @@ -361,27 +392,27 @@ fill_buffer(void)
 			    n_real_blanklines = 0;
 			    postfix_blankline_requested = 0;
 			    prefix_blankline_requested = 0;
 			    suppress_blanklines = 1;
+			}
+		    }
+		}
+	    }
+	}
+    }
     if (inhibit_formatting) {
 	p = in_buffer;
 	do {
-	    putc(*p, output);
+	    output_char(*p);
 	} while (*p++ != '\n');
+    }
+}
 /*
  * Copyright (C) 1976 by the Board of Trustees of the University of Illinois
+ *
  * All rights reserved
+ *
+ *
  * NAME: pad_output
+ *
  * FUNCTION: Writes tabs and spaces to move the current column up to the desired
 @@ -411,32 +442,32 @@ pad_output(int current, int target)
 				 * target column */
     /* current: the current column value */
     /* target: position we want it at */
+{
     int curr;			/* internal column pointer */
     if (current >= target)
 	return current;		/* line is already long enough */
     curr = current;
     if (opt.use_tabs) {
 	int tcur;
 	while ((tcur = opt.tabsize * (1 + (curr - 1) / opt.tabsize) + 1) <= target) {
-	    putc('\t', output);
+	    output_char('\t');
 	    curr = tcur;
+	}
+    }
     while (curr++ < target)
-	putc(' ', output);	/* pad with final blanks */
+	output_char(' ');	/* pad with final blanks */
     return target;
+}
 /*
  * Copyright (C) 1976 by the Board of Trustees of the University of Illinois
+ *
  * All rights reserved
+ *
+ *
  * NAME: count_spaces
+ *
  * FUNCTION: Find out where printing of a given string will leave the current

 @@ -1,12 +1,10 @@
-#	$NetBSD: Makefile,v 1.9 2021/03/08 19:21:41 rillig Exp $
+#	$NetBSD: Makefile,v 1.10 2021/03/12 19:11:29 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
 COPTS.io.c += -Wno-error=format-nonliteral
 CPPFLAGS+=	${DEBUG:D-Ddebug}
 LINTFLAGS+=	-e
 .include <bsd.prog.mk>