Home | History | Annotate | Line # | Download | only in indent
io.c revision 1.63
      1 /*	$NetBSD: io.c,v 1.63 2021/09/25 20:23:42 rillig Exp $	*/
      2 
      3 /*-
      4  * SPDX-License-Identifier: BSD-4-Clause
      5  *
      6  * Copyright (c) 1985 Sun Microsystems, Inc.
      7  * Copyright (c) 1980, 1993
      8  *	The Regents of the University of California.  All rights reserved.
      9  * All rights reserved.
     10  *
     11  * Redistribution and use in source and binary forms, with or without
     12  * modification, are permitted provided that the following conditions
     13  * are met:
     14  * 1. Redistributions of source code must retain the above copyright
     15  *    notice, this list of conditions and the following disclaimer.
     16  * 2. Redistributions in binary form must reproduce the above copyright
     17  *    notice, this list of conditions and the following disclaimer in the
     18  *    documentation and/or other materials provided with the distribution.
     19  * 3. All advertising materials mentioning features or use of this software
     20  *    must display the following acknowledgement:
     21  *	This product includes software developed by the University of
     22  *	California, Berkeley and its contributors.
     23  * 4. Neither the name of the University nor the names of its contributors
     24  *    may be used to endorse or promote products derived from this software
     25  *    without specific prior written permission.
     26  *
     27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     37  * SUCH DAMAGE.
     38  */
     39 
     40 #if 0
     41 static char sccsid[] = "@(#)io.c	8.1 (Berkeley) 6/6/93";
     42 #endif
     43 
     44 #include <sys/cdefs.h>
     45 #if defined(__NetBSD__)
     46 __RCSID("$NetBSD: io.c,v 1.63 2021/09/25 20:23:42 rillig Exp $");
     47 #elif defined(__FreeBSD__)
     48 __FBSDID("$FreeBSD: head/usr.bin/indent/io.c 334927 2018-06-10 16:44:18Z pstef $");
     49 #endif
     50 
     51 #include <ctype.h>
     52 #include <err.h>
     53 #include <stdio.h>
     54 #include <stdlib.h>
     55 #include <string.h>
     56 #include <stdarg.h>
     57 
     58 #include "indent.h"
     59 
     60 bool comment_open;
     61 static int  paren_indent;
     62 
     63 static void
     64 output_char(char ch)
     65 {
     66     fputc(ch, output);
     67     debug_vis_range("output_char '", &ch, &ch + 1, "'\n");
     68 }
     69 
     70 static void
     71 output_range(const char *s, const char *e)
     72 {
     73     fwrite(s, 1, (size_t)(e - s), output);
     74     debug_vis_range("output_range \"", s, e, "\"\n");
     75 }
     76 
     77 static inline void
     78 output_string(const char *s)
     79 {
     80     output_range(s, s + strlen(s));
     81 }
     82 
     83 static int
     84 output_indent(int old_ind, int new_ind)
     85 {
     86     int ind = old_ind;
     87 
     88     if (opt.use_tabs) {
     89 	int tabsize = opt.tabsize;
     90 	int n = new_ind / tabsize - ind / tabsize;
     91 	if (n > 0)
     92 	    ind -= ind % tabsize;
     93 	for (int i = 0; i < n; i++) {
     94 	    fputc('\t', output);
     95 	    ind += tabsize;
     96 	}
     97     }
     98 
     99     for (; ind < new_ind; ind++)
    100         fputc(' ', output);
    101 
    102     debug_println("output_indent %d", ind);
    103     return ind;
    104 }
    105 
    106 /*
    107  * dump_line is the routine that actually effects the printing of the new
    108  * source. It prints the label section, followed by the code section with
    109  * the appropriate nesting level, followed by any comments.
    110  */
    111 void
    112 dump_line(void)
    113 {
    114     int cur_col;
    115     static bool not_first_line;
    116 
    117     if (ps.procname[0] != '\0') {
    118 	ps.ind_level = 0;
    119 	ps.procname[0] = '\0';
    120     }
    121 
    122     if (code.s == code.e && lab.s == lab.e && com.s == com.e) {
    123 	if (suppress_blanklines > 0)
    124 	    suppress_blanklines--;
    125 	else
    126 	    n_real_blanklines++;
    127     } else if (!inhibit_formatting) {
    128 	suppress_blanklines = 0;
    129 	if (prefix_blankline_requested && not_first_line) {
    130 	    if (opt.swallow_optional_blanklines) {
    131 		if (n_real_blanklines == 1)
    132 		    n_real_blanklines = 0;
    133 	    } else {
    134 		if (n_real_blanklines == 0)
    135 		    n_real_blanklines = 1;
    136 	    }
    137 	}
    138 	while (--n_real_blanklines >= 0)
    139 	    output_char('\n');
    140 	n_real_blanklines = 0;
    141 	if (ps.ind_level == 0)
    142 	    ps.ind_stmt = false;/* this is a class A kludge. don't do
    143 				 * additional statement indentation if we are
    144 				 * at bracket level 0 */
    145 
    146 	if (lab.e != lab.s || code.e != code.s)
    147 	    ps.stats.code_lines++;
    148 
    149 
    150 	if (lab.e != lab.s) {	/* print lab, if any */
    151 	    if (comment_open) {
    152 		comment_open = false;
    153 		output_string(".*/\n");
    154 	    }
    155 	    while (lab.e > lab.s && (lab.e[-1] == ' ' || lab.e[-1] == '\t'))
    156 		lab.e--;
    157 	    *lab.e = '\0';
    158 	    cur_col = 1 + output_indent(0, compute_label_indent());
    159 	    if (lab.s[0] == '#' && (strncmp(lab.s, "#else", 5) == 0
    160 				    || strncmp(lab.s, "#endif", 6) == 0)) {
    161 		char *s = lab.s;
    162 		if (lab.e[-1] == '\n') lab.e--;
    163 		do {
    164 		    output_char(*s++);
    165 		} while (s < lab.e && 'a' <= *s && *s <= 'z');
    166 		while ((*s == ' ' || *s == '\t') && s < lab.e)
    167 		    s++;
    168 		if (s < lab.e) {
    169 		    if (s[0] == '/' && s[1] == '*') {
    170 			output_char('\t');
    171 			output_range(s, lab.e);
    172 		    } else {
    173 		        output_string("\t/* ");
    174 			output_range(s, lab.e);
    175 			output_string(" */");
    176 		    }
    177 		}
    178 	    } else
    179 	        output_range(lab.s, lab.e);
    180 	    cur_col = 1 + indentation_after(cur_col - 1, lab.s);
    181 	} else
    182 	    cur_col = 1;	/* there is no label section */
    183 
    184 	ps.pcase = false;
    185 
    186 	if (code.s != code.e) {	/* print code section, if any */
    187 	    if (comment_open) {
    188 		comment_open = false;
    189 		output_string(".*/\n");
    190 	    }
    191 	    int target_col = 1 + compute_code_indent();
    192 	    {
    193 		int i;
    194 
    195 		for (i = 0; i < ps.p_l_follow; i++) {
    196 		    if (ps.paren_indents[i] >= 0) {
    197 			int ind = ps.paren_indents[i];
    198 			/*
    199 			 * XXX: this mix of 'indent' and 'column' smells like
    200 			 * an off-by-one error.
    201 			 */
    202 			ps.paren_indents[i] = -(ind + target_col);
    203 			debug_println(
    204 			    "setting pi[%d] from %d to %d for column %d",
    205 			    i, ind, ps.paren_indents[i], target_col);
    206 		    }
    207 		}
    208 	    }
    209 	    cur_col = 1 + output_indent(cur_col - 1, target_col - 1);
    210 	    output_range(code.s, code.e);
    211 	    cur_col = 1 + indentation_after(cur_col - 1, code.s);
    212 	}
    213 	if (com.s != com.e) {		/* print comment, if any */
    214 	    int target_col = ps.com_col;
    215 	    char *com_st = com.s;
    216 
    217 	    target_col += ps.comment_delta;
    218 	    while (*com_st == '\t')	/* consider original indentation in
    219 				 * case this is a box comment */
    220 		com_st++, target_col += opt.tabsize;
    221 	    while (target_col <= 0)
    222 		if (*com_st == ' ')
    223 		    target_col++, com_st++;
    224 		else if (*com_st == '\t') {
    225 		    target_col = opt.tabsize * (1 + (target_col - 1) / opt.tabsize) + 1;
    226 		    com_st++;
    227 		} else
    228 		    target_col = 1;
    229 	    if (cur_col > target_col) {	/* if comment can't fit on this line,
    230 				 * put it on next line */
    231 		output_char('\n');
    232 		cur_col = 1;
    233 		ps.stats.lines++;
    234 	    }
    235 	    while (com.e > com_st && isspace((unsigned char)com.e[-1]))
    236 		com.e--;
    237 	    (void)output_indent(cur_col - 1, target_col - 1);
    238 	    output_range(com_st, com.e);
    239 	    ps.comment_delta = ps.n_comment_delta;
    240 	    ps.stats.comment_lines++;
    241 	}
    242 	if (ps.use_ff)
    243 	    output_char('\014');
    244 	else
    245 	    output_char('\n');
    246 	ps.stats.lines++;
    247 	if (ps.just_saw_decl == 1 && opt.blanklines_after_declarations) {
    248 	    prefix_blankline_requested = true;
    249 	    ps.just_saw_decl = 0;
    250 	} else
    251 	    prefix_blankline_requested = postfix_blankline_requested;
    252 	postfix_blankline_requested = false;
    253     }
    254 
    255     /* keep blank lines after '//' comments */
    256     if (com.e - com.s > 1 && com.s[1] == '/'
    257 	&& token.s < token.e && isspace((unsigned char)token.s[0]))
    258 	output_range(token.s, token.e);
    259 
    260     ps.decl_on_line = ps.in_decl; /* if we are in the middle of a declaration,
    261 				 * remember that fact for proper comment
    262 				 * indentation */
    263     ps.ind_stmt = ps.in_stmt && !ps.in_decl; /* next line should be indented if
    264 				 * we have not completed this stmt and if we
    265 				 * are not in the middle of a declaration */
    266     ps.use_ff = false;
    267     ps.dumped_decl_indent = false;
    268     *(lab.e = lab.s) = '\0';	/* reset buffers */
    269     *(code.e = code.s) = '\0';
    270     *(com.e = com.s = com.buf + 1) = '\0';
    271     ps.ind_level = ps.i_l_follow;
    272     ps.paren_level = ps.p_l_follow;
    273     if (ps.paren_level > 0) {
    274         /* TODO: explain what negative indentation means */
    275 	paren_indent = -ps.paren_indents[ps.paren_level - 1];
    276 	debug_println("paren_indent is now %d", paren_indent);
    277     }
    278     not_first_line = true;
    279 }
    280 
    281 int
    282 compute_code_indent(void)
    283 {
    284     int target_ind = opt.indent_size * ps.ind_level;
    285 
    286     if (ps.paren_level != 0) {
    287 	if (!opt.lineup_to_parens)
    288 	    if (2 * opt.continuation_indent == opt.indent_size)
    289 		target_ind += opt.continuation_indent;
    290 	    else
    291 		target_ind += opt.continuation_indent * ps.paren_level;
    292 	else if (opt.lineup_to_parens_always)
    293 	    /*
    294 	     * XXX: where does this '- 1' come from?  It looks strange but is
    295 	     * nevertheless needed for proper indentation, as demonstrated in
    296 	     * the test opt-lpl.0.
    297 	     */
    298 	    target_ind = paren_indent - 1;
    299 	else {
    300 	    int w;
    301 	    int t = paren_indent;
    302 
    303 	    if ((w = 1 + indentation_after(t - 1, code.s) - opt.max_line_length) > 0
    304 		&& 1 + indentation_after(target_ind, code.s) <= opt.max_line_length) {
    305 		t -= w + 1;
    306 		if (t > target_ind + 1)
    307 		    target_ind = t - 1;
    308 	    } else
    309 		target_ind = t - 1;
    310 	}
    311     } else if (ps.ind_stmt)
    312 	target_ind += opt.continuation_indent;
    313     return target_ind;
    314 }
    315 
    316 int
    317 compute_label_indent(void)
    318 {
    319     if (ps.pcase)
    320 	return (int) (case_ind * opt.indent_size);
    321     if (lab.s[0] == '#')
    322         return 0;
    323     return opt.indent_size * (ps.ind_level - label_offset);
    324 }
    325 
    326 static void
    327 skip_hspace(const char **pp)
    328 {
    329     while (**pp == ' ' || **pp == '\t')
    330 	(*pp)++;
    331 }
    332 
    333 static void
    334 parse_indent_comment(void)
    335 {
    336     int on_off = 0;		/* 0 = keep, 1 = ON, 2 = OFF */
    337 
    338     const char *p = in_buffer;
    339 
    340     skip_hspace(&p);
    341 
    342     if (!(*p == '/' && p[1] == '*'))
    343 	return;
    344     p += 2;
    345 
    346     skip_hspace(&p);
    347 
    348     if (!(p[0] == 'I' && p[1] == 'N' && p[2] == 'D'
    349 	  && p[3] == 'E' && p[4] == 'N' && p[5] == 'T'))
    350 	return;
    351     p += 6;
    352 
    353     skip_hspace(&p);
    354 
    355     if (*p == '*')
    356 	on_off = 1;
    357     else if (*p == 'O') {
    358 	if (*++p == 'N')
    359 	    p++, on_off = 1;
    360 	else if (*p == 'F' && *++p == 'F')
    361 	    p++, on_off = 2;
    362     }
    363     if (on_off == 0)
    364 	return;
    365 
    366     skip_hspace(&p);
    367 
    368     if (!(p[0] == '*' && p[1] == '/' && p[2] == '\n'))
    369 	return;
    370 
    371     if (com.s != com.e || lab.s != lab.e || code.s != code.e)
    372 	dump_line();
    373 
    374     if (!(inhibit_formatting = (on_off == 2))) {
    375 	n_real_blanklines = 0;
    376 	postfix_blankline_requested = false;
    377 	prefix_blankline_requested = false;
    378 	suppress_blanklines = 1;
    379     }
    380 }
    381 
    382 /*
    383  * Copyright (C) 1976 by the Board of Trustees of the University of Illinois
    384  *
    385  * All rights reserved
    386  *
    387  * FUNCTION: Reads one block of input into the input buffer
    388  */
    389 void
    390 fill_buffer(void)
    391 {				/* this routine reads stuff from the input */
    392     char *p;
    393     int i;
    394     FILE *f = input;
    395 
    396     if (bp_save != NULL) {	/* there is a partly filled input buffer left */
    397 	buf_ptr = bp_save;	/* do not read anything, just switch buffers */
    398 	buf_end = be_save;
    399 	bp_save = be_save = NULL;
    400 	debug_println("switched buf_ptr back to bp_save");
    401 	if (buf_ptr < buf_end)
    402 	    return;		/* only return if there is really something in
    403 				 * this buffer */
    404     }
    405     for (p = in_buffer;;) {
    406 	if (p >= in_buffer_limit) {
    407 	    size_t size = (in_buffer_limit - in_buffer) * 2 + 10;
    408 	    size_t offset = p - in_buffer;
    409 	    in_buffer = xrealloc(in_buffer, size);
    410 	    p = in_buffer + offset;
    411 	    in_buffer_limit = in_buffer + size - 2;
    412 	}
    413 	if ((i = getc(f)) == EOF) {
    414 	    *p++ = ' ';
    415 	    *p++ = '\n';
    416 	    had_eof = true;
    417 	    break;
    418 	}
    419 	if (i != '\0')
    420 	    *p++ = i;
    421 	if (i == '\n')
    422 	    break;
    423     }
    424     buf_ptr = in_buffer;
    425     buf_end = p;
    426     if (p - in_buffer > 2 && p[-2] == '/' && p[-3] == '*') {
    427 	if (in_buffer[3] == 'I' && strncmp(in_buffer, "/**INDENT**", 11) == 0)
    428 	    fill_buffer();	/* flush indent error message */
    429 	else
    430 	    parse_indent_comment();
    431     }
    432     if (inhibit_formatting) {
    433 	p = in_buffer;
    434 	do {
    435 	    output_char(*p);
    436 	} while (*p++ != '\n');
    437     }
    438 }
    439 
    440 int
    441 indentation_after_range(int ind, const char *start, const char *end)
    442 {
    443     for (const char *p = start; *p != '\0' && p != end; ++p) {
    444 	if (*p == '\n' || *p == '\f')
    445 	    ind = 0;
    446 	else if (*p == '\t')
    447 	    ind = opt.tabsize * (ind / opt.tabsize + 1);
    448 	else if (*p == '\b')
    449 	    --ind;
    450 	else
    451 	    ++ind;
    452     }
    453     return ind;
    454 }
    455 
    456 int
    457 indentation_after(int ind, const char *s)
    458 {
    459     return indentation_after_range(ind, s, NULL);
    460 }
    461 
    462 void
    463 diag(int level, const char *msg, ...)
    464 {
    465     va_list ap;
    466     const char *s, *e;
    467 
    468     if (level != 0)
    469 	found_err = 1;
    470 
    471     if (output == stdout) {
    472 	s = "/**INDENT** ";
    473 	e = " */";
    474     } else {
    475 	s = e = "";
    476     }
    477 
    478     va_start(ap, msg);
    479     fprintf(stderr, "%s%s@%d: ", s, level == 0 ? "Warning" : "Error", line_no);
    480     vfprintf(stderr, msg, ap);
    481     fprintf(stderr, "%s\n", e);
    482     va_end(ap);
    483 }
    484