1 /*-
2 * SPDX-License-Identifier: BSD-4-Clause
3 *
4 * Copyright (c) 1985 Sun Microsystems, Inc.
5 * Copyright (c) 1980, 1993
6 * The Regents of the University of California. All rights reserved.
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. All advertising materials mentioning features or use of this software
18 * must display the following acknowledgement:
19 * This product includes software developed by the University of
20 * California, Berkeley and its contributors.
21 * 4. Neither the name of the University nor the names of its contributors
22 * may be used to endorse or promote products derived from this software
23 * without specific prior written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 * SUCH DAMAGE.
36 */
37
38 #if 0
39 #ifndef lint
40 static char sccsid[] = "@(#)io.c 8.1 (Berkeley) 6/6/93";
41 #endif /* not lint */
42 #endif
43
44 #include <sys/cdefs.h>
45 #include <ctype.h>
46 #include <err.h>
47 #include <stdio.h>
48 #include <stdlib.h>
49 #include <string.h>
50 #include "indent_globs.h"
51 #include "indent.h"
52
53 /* Globals */
54 int found_err;
55 int n_real_blanklines;
56 int prefix_blankline_requested, postfix_blankline_requested;
57 int code_lines;
58 int had_eof;
59 int inhibit_formatting;
60 int suppress_blanklines;
61
62 int comment_open;
63 static int paren_target;
64 static int pad_output(int current, int target);
65
66 void
dump_line(void)67 dump_line(void)
68 { /* dump_line is the routine that actually
69 * effects the printing of the new source. It
70 * prints the label section, followed by the
71 * code section with the appropriate nesting
72 * level, followed by any comments */
73 int cur_col,
74 target_col = 1;
75 static int not_first_line;
76
77 if (ps.procname[0]) {
78 ps.ind_level = 0;
79 ps.procname[0] = 0;
80 }
81 if (s_code == e_code && s_lab == e_lab && s_com == e_com) {
82 if (suppress_blanklines > 0)
83 suppress_blanklines--;
84 else {
85 ps.bl_line = true;
86 n_real_blanklines++;
87 }
88 }
89 else if (!inhibit_formatting) {
90 suppress_blanklines = 0;
91 ps.bl_line = false;
92 if (prefix_blankline_requested && not_first_line) {
93 if (opt.swallow_optional_blanklines) {
94 if (n_real_blanklines == 1)
95 n_real_blanklines = 0;
96 }
97 else {
98 if (n_real_blanklines == 0)
99 n_real_blanklines = 1;
100 }
101 }
102 while (--n_real_blanklines >= 0)
103 putc('\n', output);
104 n_real_blanklines = 0;
105 if (ps.ind_level == 0)
106 ps.ind_stmt = 0; /* this is a class A kludge. dont do
107 * additional statement indentation if we are
108 * at bracket level 0 */
109
110 if (e_lab != s_lab || e_code != s_code)
111 ++code_lines; /* keep count of lines with code */
112
113
114 if (e_lab != s_lab) { /* print lab, if any */
115 if (comment_open) {
116 comment_open = 0;
117 fprintf(output, ".*/\n");
118 }
119 while (e_lab > s_lab && (e_lab[-1] == ' ' || e_lab[-1] == '\t'))
120 e_lab--;
121 *e_lab = '\0';
122 cur_col = pad_output(1, compute_label_target());
123 if (s_lab[0] == '#' && (strncmp(s_lab, "#else", 5) == 0
124 || strncmp(s_lab, "#endif", 6) == 0)) {
125 char *s = s_lab;
126 if (e_lab[-1] == '\n') e_lab--;
127 do putc(*s++, output);
128 while (s < e_lab && 'a' <= *s && *s<='z');
129 while ((*s == ' ' || *s == '\t') && s < e_lab)
130 s++;
131 if (s < e_lab)
132 fprintf(output, s[0]=='/' && s[1]=='*' ? "\t%.*s" : "\t/* %.*s */",
133 (int)(e_lab - s), s);
134 }
135 else fprintf(output, "%.*s", (int)(e_lab - s_lab), s_lab);
136 cur_col = count_spaces(cur_col, s_lab);
137 }
138 else
139 cur_col = 1; /* there is no label section */
140
141 ps.pcase = false;
142
143 if (s_code != e_code) { /* print code section, if any */
144 char *p;
145
146 if (comment_open) {
147 comment_open = 0;
148 fprintf(output, ".*/\n");
149 }
150 target_col = compute_code_target();
151 {
152 int i;
153
154 for (i = 0; i < ps.p_l_follow; i++)
155 if (ps.paren_indents[i] >= 0)
156 ps.paren_indents[i] = -(ps.paren_indents[i] + target_col);
157 }
158 cur_col = pad_output(cur_col, target_col);
159 for (p = s_code; p < e_code; p++)
160 if (*p == (char) 0200)
161 fprintf(output, "%d", target_col * 7);
162 else
163 putc(*p, output);
164 cur_col = count_spaces(cur_col, s_code);
165 }
166 if (s_com != e_com) { /* print comment, if any */
167 int target = ps.com_col;
168 char *com_st = s_com;
169
170 target += ps.comment_delta;
171 while (*com_st == '\t') /* consider original indentation in
172 * case this is a box comment */
173 com_st++, target += opt.tabsize;
174 while (target <= 0)
175 if (*com_st == ' ')
176 target++, com_st++;
177 else if (*com_st == '\t') {
178 target = opt.tabsize * (1 + (target - 1) / opt.tabsize) + 1;
179 com_st++;
180 }
181 else
182 target = 1;
183 if (cur_col > target) { /* if comment can't fit on this line,
184 * put it on next line */
185 putc('\n', output);
186 cur_col = 1;
187 ++ps.out_lines;
188 }
189 while (e_com > com_st && isspace((unsigned char)e_com[-1]))
190 e_com--;
191 (void)pad_output(cur_col, target);
192 fwrite(com_st, e_com - com_st, 1, output);
193 ps.comment_delta = ps.n_comment_delta;
194 ++ps.com_lines; /* count lines with comments */
195 }
196 if (ps.use_ff)
197 putc('\014', output);
198 else
199 putc('\n', output);
200 ++ps.out_lines;
201 if (ps.just_saw_decl == 1 && opt.blanklines_after_declarations) {
202 prefix_blankline_requested = 1;
203 ps.just_saw_decl = 0;
204 }
205 else
206 prefix_blankline_requested = postfix_blankline_requested;
207 postfix_blankline_requested = 0;
208 }
209 ps.decl_on_line = ps.in_decl; /* if we are in the middle of a
210 * declaration, remember that fact for
211 * proper comment indentation */
212 ps.ind_stmt = ps.in_stmt & ~ps.in_decl; /* next line should be
213 * indented if we have not
214 * completed this stmt and if
215 * we are not in the middle of
216 * a declaration */
217 ps.use_ff = false;
218 ps.dumped_decl_indent = 0;
219 *(e_lab = s_lab) = '\0'; /* reset buffers */
220 *(e_code = s_code) = '\0';
221 *(e_com = s_com = combuf + 1) = '\0';
222 ps.ind_level = ps.i_l_follow;
223 ps.paren_level = ps.p_l_follow;
224 if (ps.paren_level > 0)
225 paren_target = -ps.paren_indents[ps.paren_level - 1];
226 not_first_line = 1;
227 }
228
229 int
compute_code_target(void)230 compute_code_target(void)
231 {
232 int target_col = opt.ind_size * ps.ind_level + 1;
233
234 if (ps.paren_level)
235 if (!opt.lineup_to_parens)
236 target_col += opt.continuation_indent *
237 (2 * opt.continuation_indent == opt.ind_size ? 1 : ps.paren_level);
238 else if (opt.lineup_to_parens_always)
239 target_col = paren_target;
240 else {
241 int w;
242 int t = paren_target;
243
244 if ((w = count_spaces(t, s_code) - opt.max_col) > 0
245 && count_spaces(target_col, s_code) <= opt.max_col) {
246 t -= w + 1;
247 if (t > target_col)
248 target_col = t;
249 }
250 else
251 target_col = t;
252 }
253 else if (ps.ind_stmt)
254 target_col += opt.continuation_indent;
255 return target_col;
256 }
257
258 int
compute_label_target(void)259 compute_label_target(void)
260 {
261 return
262 ps.pcase ? (int) (case_ind * opt.ind_size) + 1
263 : *s_lab == '#' ? 1
264 : opt.ind_size * (ps.ind_level - label_offset) + 1;
265 }
266
267
268 /*
269 * Copyright (C) 1976 by the Board of Trustees of the University of Illinois
270 *
271 * All rights reserved
272 *
273 *
274 * NAME: fill_buffer
275 *
276 * FUNCTION: Reads one block of input into input_buffer
277 *
278 * HISTORY: initial coding November 1976 D A Willcox of CAC 1/7/77 A
279 * Willcox of CAC Added check for switch back to partly full input
280 * buffer from temporary buffer
281 *
282 */
283 void
fill_buffer(void)284 fill_buffer(void)
285 { /* this routine reads stuff from the input */
286 char *p;
287 int i;
288 FILE *f = input;
289
290 if (bp_save != NULL) { /* there is a partly filled input buffer left */
291 buf_ptr = bp_save; /* do not read anything, just switch buffers */
292 buf_end = be_save;
293 bp_save = be_save = NULL;
294 if (buf_ptr < buf_end)
295 return; /* only return if there is really something in
296 * this buffer */
297 }
298 for (p = in_buffer;;) {
299 if (p >= in_buffer_limit) {
300 int size = (in_buffer_limit - in_buffer) * 2 + 10;
301 int offset = p - in_buffer;
302 in_buffer = realloc(in_buffer, size);
303 if (in_buffer == NULL)
304 errx(1, "input line too long");
305 p = in_buffer + offset;
306 in_buffer_limit = in_buffer + size - 2;
307 }
308 if ((i = getc(f)) == EOF) {
309 *p++ = ' ';
310 *p++ = '\n';
311 had_eof = true;
312 break;
313 }
314 if (i != '\0')
315 *p++ = i;
316 if (i == '\n')
317 break;
318 }
319 buf_ptr = in_buffer;
320 buf_end = p;
321 if (p - in_buffer > 2 && p[-2] == '/' && p[-3] == '*') {
322 if (in_buffer[3] == 'I' && strncmp(in_buffer, "/**INDENT**", 11) == 0)
323 fill_buffer(); /* flush indent error message */
324 else {
325 int com = 0;
326
327 p = in_buffer;
328 while (*p == ' ' || *p == '\t')
329 p++;
330 if (*p == '/' && p[1] == '*') {
331 p += 2;
332 while (*p == ' ' || *p == '\t')
333 p++;
334 if (p[0] == 'I' && p[1] == 'N' && p[2] == 'D' && p[3] == 'E'
335 && p[4] == 'N' && p[5] == 'T') {
336 p += 6;
337 while (*p == ' ' || *p == '\t')
338 p++;
339 if (*p == '*')
340 com = 1;
341 else if (*p == 'O') {
342 if (*++p == 'N')
343 p++, com = 1;
344 else if (*p == 'F' && *++p == 'F')
345 p++, com = 2;
346 }
347 while (*p == ' ' || *p == '\t')
348 p++;
349 if (p[0] == '*' && p[1] == '/' && p[2] == '\n' && com) {
350 if (s_com != e_com || s_lab != e_lab || s_code != e_code)
351 dump_line();
352 if (!(inhibit_formatting = com - 1)) {
353 n_real_blanklines = 0;
354 postfix_blankline_requested = 0;
355 prefix_blankline_requested = 0;
356 suppress_blanklines = 1;
357 }
358 }
359 }
360 }
361 }
362 }
363 if (inhibit_formatting) {
364 p = in_buffer;
365 do
366 putc(*p, output);
367 while (*p++ != '\n');
368 }
369 }
370
371 /*
372 * Copyright (C) 1976 by the Board of Trustees of the University of Illinois
373 *
374 * All rights reserved
375 *
376 *
377 * NAME: pad_output
378 *
379 * FUNCTION: Writes tabs and spaces to move the current column up to the desired
380 * position.
381 *
382 * ALGORITHM: Put tabs and/or blanks into pobuf, then write pobuf.
383 *
384 * PARAMETERS: current integer The current column target
385 * nteger The desired column
386 *
387 * RETURNS: Integer value of the new column. (If current >= target, no action is
388 * taken, and current is returned.
389 *
390 * GLOBALS: None
391 *
392 * CALLS: write (sys)
393 *
394 * CALLED BY: dump_line
395 *
396 * HISTORY: initial coding November 1976 D A Willcox of CAC
397 *
398 */
399 static int
pad_output(int current,int target)400 pad_output(int current, int target)
401 /* writes tabs and blanks (if necessary) to
402 * get the current output position up to the
403 * target column */
404 /* current: the current column value */
405 /* target: position we want it at */
406 {
407 int curr; /* internal column pointer */
408
409 if (current >= target)
410 return (current); /* line is already long enough */
411 curr = current;
412 if (opt.use_tabs) {
413 int tcur;
414
415 while ((tcur = opt.tabsize * (1 + (curr - 1) / opt.tabsize) + 1) <= target) {
416 putc('\t', output);
417 curr = tcur;
418 }
419 }
420 while (curr++ < target)
421 putc(' ', output); /* pad with final blanks */
422
423 return (target);
424 }
425
426 /*
427 * Copyright (C) 1976 by the Board of Trustees of the University of Illinois
428 *
429 * All rights reserved
430 *
431 *
432 * NAME: count_spaces
433 *
434 * FUNCTION: Find out where printing of a given string will leave the current
435 * character position on output.
436 *
437 * ALGORITHM: Run thru input string and add appropriate values to current
438 * position.
439 *
440 * RETURNS: Integer value of position after printing "buffer" starting in column
441 * "current".
442 *
443 * HISTORY: initial coding November 1976 D A Willcox of CAC
444 *
445 */
446 int
count_spaces_until(int cur,char * buffer,char * end)447 count_spaces_until(int cur, char *buffer, char *end)
448 /*
449 * this routine figures out where the character position will be after
450 * printing the text in buffer starting at column "current"
451 */
452 {
453 char *buf; /* used to look thru buffer */
454
455 for (buf = buffer; *buf != '\0' && buf != end; ++buf) {
456 switch (*buf) {
457
458 case '\n':
459 case 014: /* form feed */
460 cur = 1;
461 break;
462
463 case '\t':
464 cur = opt.tabsize * (1 + (cur - 1) / opt.tabsize) + 1;
465 break;
466
467 case 010: /* backspace */
468 --cur;
469 break;
470
471 default:
472 ++cur;
473 break;
474 } /* end of switch */
475 } /* end of for loop */
476 return (cur);
477 }
478
479 int
count_spaces(int cur,char * buffer)480 count_spaces(int cur, char *buffer)
481 {
482 return (count_spaces_until(cur, buffer, NULL));
483 }
484
485 void
diag4(int level,const char * msg,int a,int b)486 diag4(int level, const char *msg, int a, int b)
487 {
488 if (level)
489 found_err = 1;
490 if (output == stdout) {
491 fprintf(stdout, "/**INDENT** %s@%d: ", level == 0 ? "Warning" : "Error", line_no);
492 fprintf(stdout, msg, a, b);
493 fprintf(stdout, " */\n");
494 }
495 else {
496 fprintf(stderr, "%s@%d: ", level == 0 ? "Warning" : "Error", line_no);
497 fprintf(stderr, msg, a, b);
498 fprintf(stderr, "\n");
499 }
500 }
501
502 void
diag3(int level,const char * msg,int a)503 diag3(int level, const char *msg, int a)
504 {
505 if (level)
506 found_err = 1;
507 if (output == stdout) {
508 fprintf(stdout, "/**INDENT** %s@%d: ", level == 0 ? "Warning" : "Error", line_no);
509 fprintf(stdout, msg, a);
510 fprintf(stdout, " */\n");
511 }
512 else {
513 fprintf(stderr, "%s@%d: ", level == 0 ? "Warning" : "Error", line_no);
514 fprintf(stderr, msg, a);
515 fprintf(stderr, "\n");
516 }
517 }
518
519 void
diag2(int level,const char * msg)520 diag2(int level, const char *msg)
521 {
522 if (level)
523 found_err = 1;
524 if (output == stdout) {
525 fprintf(stdout, "/**INDENT** %s@%d: ", level == 0 ? "Warning" : "Error", line_no);
526 fprintf(stdout, "%s", msg);
527 fprintf(stdout, " */\n");
528 }
529 else {
530 fprintf(stderr, "%s@%d: ", level == 0 ? "Warning" : "Error", line_no);
531 fprintf(stderr, "%s", msg);
532 fprintf(stderr, "\n");
533 }
534 }
535
536