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