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