?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Sync usage with man page.
[netbsd-mini2440.git] / usr.bin / indent / indent.c
blobc13a04752b473775883f1c91606d0d3065d92e5a
1 /* $NetBSD: indent.c,v 1.17 2008/07/21 14:19:23 lukem Exp $ */
2
3 /*
4 * Copyright (c) 1980, 1993
5 * The Regents of the University of California. 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 /*
33 * Copyright (c) 1976 Board of Trustees of the University of Illinois.
34 * Copyright (c) 1985 Sun Microsystems, Inc.
35 * All rights reserved.
36 *
37 * Redistribution and use in source and binary forms, with or without
38 * modification, are permitted provided that the following conditions
39 * are met:
40 * 1. Redistributions of source code must retain the above copyright
41 * notice, this list of conditions and the following disclaimer.
42 * 2. Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in the
44 * documentation and/or other materials provided with the distribution.
45 * 3. All advertising materials mentioning features or use of this software
46 * must display the following acknowledgement:
47 * This product includes software developed by the University of
48 * California, Berkeley and its contributors.
49 * 4. Neither the name of the University nor the names of its contributors
50 * may be used to endorse or promote products derived from this software
51 * without specific prior written permission.
52 *
53 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
54 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
55 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
56 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
57 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
58 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
59 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
60 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
61 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
62 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
63 * SUCH DAMAGE.
64 */
65
66 #include <sys/cdefs.h>
67 #ifndef lint
68 __COPYRIGHT("@(#) Copyright (c) 1985 Sun Microsystems, Inc.\
69 Copyright (c) 1976 Board of Trustees of the University of Illinois.\
70 Copyright (c) 1980, 1993\
71 The Regents of the University of California. All rights reserved.");
72 #endif /* not lint */
73
74 #ifndef lint
75 #if 0
76 static char sccsid[] = "@(#)indent.c 5.17 (Berkeley) 6/7/93";
77 #else
78 __RCSID("$NetBSD: indent.c,v 1.17 2008/07/21 14:19:23 lukem Exp $");
79 #endif
80 #endif /* not lint */
81
82 #include <sys/param.h>
83 #include <ctype.h>
84 #include <err.h>
85 #include <errno.h>
86 #include <fcntl.h>
87 #include <stdio.h>
88 #include <stdlib.h>
89 #include <string.h>
90 #include <unistd.h>
91 #include <locale.h>
92 #define EXTERN
93 #include "indent_globs.h"
94 #undef EXTERN
95 #include "indent_codes.h"
96
97 const char *in_name = "Standard Input"; /* will always point to name of
98 * input file */
99 const char *out_name = "Standard Output"; /* will always point to name of
100 * output file */
101 char bakfile[MAXPATHLEN] = "";
102
103 int main(int, char **);
104
105 int
106 main(int argc, char **argv)
107 {
108
109 extern int found_err; /* flag set in diag() on error */
110 int dec_ind; /* current indentation for declarations */
111 int di_stack[20]; /* a stack of structure indentation levels */
112 int flushed_nl; /* used when buffering up comments to remember
113 * that a newline was passed over */
114 int force_nl; /* when true, code must be broken */
115 int hd_type; /* used to store type of stmt for if (...),
116 * for (...), etc */
117 int i; /* local loop counter */
118 int scase; /* set to true when we see a case, so we will
119 * know what to do with the following colon */
120 int sp_sw; /* when true, we are in the expressin of
121 * if(...), while(...), etc. */
122 int squest; /* when this is positive, we have seen a ?
123 * without the matching : in a <c>?<s>:<s>
124 * construct */
125 const char *t_ptr; /* used for copying tokens */
126 int type_code; /* the type of token, returned by lexi */
127
128 int last_else = 0; /* true iff last keyword was an else */
129
130
131 /*-----------------------------------------------*\
132 | INITIALIZATION |
133 \*-----------------------------------------------*/
134
135 if (!setlocale(LC_ALL, ""))
136 fprintf(stderr, "indent: can't set locale.\n");
137
138 hd_type = 0;
139 ps.p_stack[0] = stmt; /* this is the parser's stack */
140 ps.last_nl = true; /* this is true if the last thing scanned was
141 * a newline */
142 ps.last_token = semicolon;
143 combuf = (char *) malloc(bufsize);
144 labbuf = (char *) malloc(bufsize);
145 codebuf = (char *) malloc(bufsize);
146 tokenbuf = (char *) malloc(bufsize);
147 l_com = combuf + bufsize - 5;
148 l_lab = labbuf + bufsize - 5;
149 l_code = codebuf + bufsize - 5;
150 l_token = tokenbuf + bufsize - 5;
151 combuf[0] = codebuf[0] = labbuf[0] = ' '; /* set up code, label,
152 * and comment buffers */
153 combuf[1] = codebuf[1] = labbuf[1] = '\0';
154 ps.else_if = 1; /* Default else-if special processing to on */
155 s_lab = e_lab = labbuf + 1;
156 s_code = e_code = codebuf + 1;
157 s_com = e_com = combuf + 1;
158 s_token = e_token = tokenbuf + 1;
159
160 in_buffer = (char *) malloc(10);
161 in_buffer_limit = in_buffer + 8;
162 buf_ptr = buf_end = in_buffer;
163 line_no = 1;
164 had_eof = ps.in_decl = ps.decl_on_line = break_comma = false;
165 sp_sw = force_nl = false;
166 ps.in_or_st = false;
167 ps.bl_line = true;
168 dec_ind = 0;
169 di_stack[ps.dec_nest = 0] = 0;
170 ps.want_blank = ps.in_stmt = ps.ind_stmt = false;
171
172
173 scase = ps.pcase = false;
174 squest = 0;
175 sc_end = 0;
176 bp_save = 0;
177 be_save = 0;
178
179 output = 0;
180
181
182
183 /*--------------------------------------------------*\
184 | COMMAND LINE SCAN |
185 \*--------------------------------------------------*/
186
187 #ifdef undef
188 max_col = 78; /* -l78 */
189 lineup_to_parens = 1; /* -lp */
190 ps.ljust_decl = 0; /* -ndj */
191 ps.com_ind = 33; /* -c33 */
192 star_comment_cont = 1; /* -sc */
193 ps.ind_size = 8; /* -i8 */
194 verbose = 0;
195 ps.decl_indent = 16; /* -di16 */
196 ps.indent_parameters = 1; /* -ip */
197 ps.decl_com_ind = 0; /* if this is not set to some positive value
198 * by an arg, we will set this equal to
199 * ps.com_ind */
200 btype_2 = 1; /* -br */
201 cuddle_else = 1; /* -ce */
202 ps.unindent_displace = 0; /* -d0 */
203 ps.case_indent = 0; /* -cli0 */
204 format_col1_comments = 1; /* -fc1 */
205 procnames_start_line = 1; /* -psl */
206 proc_calls_space = 0; /* -npcs */
207 comment_delimiter_on_blankline = 1; /* -cdb */
208 ps.leave_comma = 1; /* -nbc */
209 #endif
210
211 for (i = 1; i < argc; ++i)
212 if (strcmp(argv[i], "-npro") == 0)
213 break;
214 set_defaults();
215 if (i >= argc)
216 set_profile();
217
218 for (i = 1; i < argc; ++i) {
219
220 /*
221 * look thru args (if any) for changes to defaults
222 */
223 if (argv[i][0] != '-') { /* no flag on parameter */
224 if (input == 0) { /* we must have the input file */
225 in_name = argv[i]; /* remember name of
226 * input file */
227 input = fopen(in_name, "r");
228 if (input == 0) /* check for open error */
229 err(1, "%s", in_name);
230 continue;
231 } else
232 if (output == 0) { /* we have the output
233 * file */
234 out_name = argv[i]; /* remember name of
235 * output file */
236 if (strcmp(in_name, out_name) == 0) { /* attempt to overwrite
237 * the file */
238 fprintf(stderr, "indent: input and output files must be different\n");
239 exit(1);
240 }
241 output = fopen(out_name, "w");
242 if (output == 0) /* check for create
243 * error */
244 err(1, "%s", out_name);
245 continue;
246 }
247 fprintf(stderr, "indent: unknown parameter: %s\n", argv[i]);
248 exit(1);
249 } else
250 set_option(argv[i]);
251 } /* end of for */
252 if (input == 0) {
253 input = stdin;
254 }
255 if (output == 0) {
256 if (troff || input == stdin)
257 output = stdout;
258 else {
259 out_name = in_name;
260 bakcopy();
261 }
262 }
263 if (ps.com_ind <= 1)
264 ps.com_ind = 2; /* dont put normal comments before column 2 */
265 if (troff) {
266 if (bodyf.font[0] == 0)
267 parsefont(&bodyf, "R");
268 if (scomf.font[0] == 0)
269 parsefont(&scomf, "I");
270 if (blkcomf.font[0] == 0)
271 blkcomf = scomf, blkcomf.size += 2;
272 if (boxcomf.font[0] == 0)
273 boxcomf = blkcomf;
274 if (stringf.font[0] == 0)
275 parsefont(&stringf, "L");
276 if (keywordf.font[0] == 0)
277 parsefont(&keywordf, "B");
278 writefdef(&bodyf, 'B');
279 writefdef(&scomf, 'C');
280 writefdef(&blkcomf, 'L');
281 writefdef(&boxcomf, 'X');
282 writefdef(&stringf, 'S');
283 writefdef(&keywordf, 'K');
284 }
285 if (block_comment_max_col <= 0)
286 block_comment_max_col = max_col;
287 if (ps.decl_com_ind <= 0) /* if not specified by user, set this */
288 ps.decl_com_ind = ps.ljust_decl ? (ps.com_ind <= 10 ? 2 : ps.com_ind - 8) : ps.com_ind;
289 if (continuation_indent == 0)
290 continuation_indent = ps.ind_size;
291 fill_buffer(); /* get first batch of stuff into input buffer */
292
293 parse(semicolon);
294 {
295 char *p = buf_ptr;
296 int col = 1;
297
298 while (1) {
299 if (*p == ' ')
300 col++;
301 else
302 if (*p == '\t')
303 col = ((col - 1) & ~7) + 9;
304 else
305 break;
306 p++;
307 }
308 if (col > ps.ind_size)
309 ps.ind_level = ps.i_l_follow = col / ps.ind_size;
310 }
311 if (troff) {
312 const char *p = in_name, *beg = in_name;
313
314 while (*p)
315 if (*p++ == '/')
316 beg = p;
317 fprintf(output, ".Fn \"%s\"\n", beg);
318 }
319 /*
320 * START OF MAIN LOOP
321 */
322
323 while (1) { /* this is the main loop. it will go until we
324 * reach eof */
325 int is_procname;
326
327 type_code = lexi(); /* lexi reads one token. The actual
328 * characters read are stored in
329 * "token". lexi returns a code
330 * indicating the type of token */
331 is_procname = ps.procname[0];
332
333 /*
334 * The following code moves everything following an if (), while (),
335 * else, etc. up to the start of the following stmt to a buffer. This
336 * allows proper handling of both kinds of brace placement.
337 */
338
339 flushed_nl = false;
340 while (ps.search_brace) { /* if we scanned an if(),
341 * while(), etc., we might
342 * need to copy stuff into a
343 * buffer we must loop,
344 * copying stuff into
345 * save_com, until we find the
346 * start of the stmt which
347 * follows the if, or whatever */
348 switch (type_code) {
349 case newline:
350 ++line_no;
351 flushed_nl = true;
352 case form_feed:
353 break; /* form feeds and newlines found here
354 * will be ignored */
355
356 case lbrace: /* this is a brace that starts the
357 * compound stmt */
358 if (sc_end == 0) { /* ignore buffering if a
359 * comment wasnt stored
360 * up */
361 ps.search_brace = false;
362 goto check_type;
363 }
364 if (btype_2) {
365 save_com[0] = '{'; /* we either want to put
366 * the brace right after
367 * the if */
368 goto sw_buffer; /* go to common code to
369 * get out of this loop */
370 }
371 case comment: /* we have a comment, so we must copy
372 * it into the buffer */
373 if (!flushed_nl || sc_end != 0) {
374 if (sc_end == 0) { /* if this is the first
375 * comment, we must set
376 * up the buffer */
377 save_com[0] = save_com[1] = ' ';
378 sc_end = &(save_com[2]);
379 } else {
380 *sc_end++ = '\n'; /* add newline between
381 * comments */
382 *sc_end++ = ' ';
383 --line_no;
384 }
385 *sc_end++ = '/'; /* copy in start of
386 * comment */
387 *sc_end++ = '*';
388
389 for (;;) { /* loop until we get to
390 * the end of the
391 * comment */
392 *sc_end = *buf_ptr++;
393 if (buf_ptr >= buf_end)
394 fill_buffer();
395
396 if (*sc_end++ == '*' && *buf_ptr == '/')
397 break; /* we are at end of
398 * comment */
399
400 if (sc_end >= &(save_com[sc_size])) { /* check for temp buffer
401 * overflow */
402 diag(1, "Internal buffer overflow - Move big comment from right after if, while, or whatever.");
403 fflush(output);
404 exit(1);
405 }
406 }
407 *sc_end++ = '/'; /* add ending slash */
408 if (++buf_ptr >= buf_end) /* get past / in buffer */
409 fill_buffer();
410 break;
411 }
412 default: /* it is the start of a normal
413 * statment */
414 if (flushed_nl) /* if we flushed a newline,
415 * make sure it is put back */
416 force_nl = true;
417 if ((type_code == sp_paren && *token == 'i'
418 && last_else && ps.else_if) ||
419 (type_code == sp_nparen && *token == 'e'
420 && e_code != s_code && e_code[-1] == '}'))
421 force_nl = false;
422
423 if (sc_end == 0) { /* ignore buffering if
424 * comment wasnt saved
425 * up */
426 ps.search_brace = false;
427 goto check_type;
428 }
429 if (force_nl) { /* if we should insert a nl
430 * here, put it into the
431 * buffer */
432 force_nl = false;
433 --line_no; /* this will be
434 * re-increased when the
435 * nl is read from the
436 * buffer */
437 *sc_end++ = '\n';
438 *sc_end++ = ' ';
439 if (verbose && !flushed_nl) /* print error msg if
440 * the line was not
441 * already broken */
442 diag(0, "Line broken");
443 flushed_nl = false;
444 }
445 for (t_ptr = token; *t_ptr; ++t_ptr)
446 *sc_end++ = *t_ptr; /* copy token into temp
447 * buffer */
448 ps.procname[0] = 0;
449
450 sw_buffer:
451 ps.search_brace = false; /* stop looking for
452 * start of stmt */
453 bp_save = buf_ptr; /* save current input
454 * buffer */
455 be_save = buf_end;
456 buf_ptr = save_com; /* fix so that
457 * subsequent calls to
458 * lexi will take tokens
459 * out of save_com */
460 *sc_end++ = ' '; /* add trailing blank,
461 * just in case */
462 buf_end = sc_end;
463 sc_end = 0;
464 break;
465 } /* end of switch */
466 if (type_code != 0) /* we must make this check,
467 * just in case there was an
468 * unexpected EOF */
469 type_code = lexi(); /* read another token */
470 /* if (ps.search_brace) ps.procname[0] = 0; */
471 if ((is_procname = ps.procname[0]) && flushed_nl
472 && !procnames_start_line && ps.in_decl
473 && type_code == ident)
474 flushed_nl = 0;
475 } /* end of while (search_brace) */
476 last_else = 0;
477 check_type:
478 if (type_code == 0) { /* we got eof */
479 if (s_lab != e_lab || s_code != e_code
480 || s_com != e_com) /* must dump end of line */
481 dump_line();
482 if (ps.tos > 1) /* check for balanced braces */
483 diag(1, "Stuff missing from end of file.");
484
485 if (verbose) {
486 printf("There were %d output lines and %d comments\n",
487 ps.out_lines, ps.out_coms);
488 printf("(Lines with comments)/(Lines with code): %6.3f\n",
489 (1.0 * ps.com_lines) / code_lines);
490 }
491 fflush(output);
492 exit(found_err);
493 }
494 if (
495 (type_code != comment) &&
496 (type_code != newline) &&
497 (type_code != preesc) &&
498 (type_code != form_feed)) {
499 if (force_nl &&
500 (type_code != semicolon) &&
501 (type_code != lbrace || !btype_2)) {
502 /* we should force a broken line here */
503 if (verbose && !flushed_nl)
504 diag(0, "Line broken");
505 flushed_nl = false;
506 dump_line();
507 ps.want_blank = false; /* dont insert blank at
508 * line start */
509 force_nl = false;
510 }
511 ps.in_stmt = true; /* turn on flag which causes
512 * an extra level of
513 * indentation. this is turned
514 * off by a ; or '}' */
515 if (s_com != e_com) { /* the turkey has embedded a
516 * comment in a line. fix it */
517 *e_code++ = ' ';
518 for (t_ptr = s_com; *t_ptr; ++t_ptr) {
519 CHECK_SIZE_CODE;
520 *e_code++ = *t_ptr;
521 }
522 *e_code++ = ' ';
523 *e_code = '\0'; /* null terminate code sect */
524 ps.want_blank = false;
525 e_com = s_com;
526 }
527 } else
528 if (type_code != comment) /* preserve force_nl
529 * thru a comment */
530 force_nl = false; /* cancel forced newline
531 * after newline, form
532 * feed, etc */
533
534
535
536 /*-----------------------------------------------------*\
537 | do switch on type of token scanned |
538 \*-----------------------------------------------------*/
539 CHECK_SIZE_CODE;
540 switch (type_code) { /* now, decide what to do with the
541 * token */
542
543 case form_feed:/* found a form feed in line */
544 ps.use_ff = true; /* a form feed is treated much
545 * like a newline */
546 dump_line();
547 ps.want_blank = false;
548 break;
549
550 case newline:
551 if (ps.last_token != comma || ps.p_l_follow > 0
552 || !ps.leave_comma || ps.block_init || !break_comma || s_com != e_com) {
553 dump_line();
554 ps.want_blank = false;
555 }
556 ++line_no; /* keep track of input line number */
557 break;
558
559 case lparen: /* got a '(' or '[' */
560 ++ps.p_l_follow; /* count parens to make Healy
561 * happy */
562 if (ps.want_blank && *token != '[' &&
563 (ps.last_token != ident || proc_calls_space
564 || (ps.its_a_keyword && (!ps.sizeof_keyword || Bill_Shannon))))
565 *e_code++ = ' ';
566 if (ps.in_decl && !ps.block_init) {
567 if (troff && !ps.dumped_decl_indent && !is_procname && ps.last_token == decl) {
568 ps.dumped_decl_indent = 1;
569 sprintf(e_code, "\n.Du %dp+\200p \"%s\"\n", dec_ind * 7, token);
570 e_code += strlen(e_code);
571 } else {
572 while ((e_code - s_code) < dec_ind) {
573 CHECK_SIZE_CODE;
574 *e_code++ = ' ';
575 }
576 *e_code++ = token[0];
577 }
578 } else
579 *e_code++ = token[0];
580 ps.paren_indents[ps.p_l_follow - 1] = e_code - s_code;
581 if (sp_sw && ps.p_l_follow == 1 && extra_expression_indent
582 && ps.paren_indents[0] < 2 * ps.ind_size)
583 ps.paren_indents[0] = 2 * ps.ind_size;
584 ps.want_blank = false;
585 if (ps.in_or_st && *token == '(' && ps.tos <= 2) {
586 /*
587 * this is a kluge to make sure that declarations will be
588 * aligned right if proc decl has an explicit type on it, i.e.
589 * "int a(x) {..."
590 */
591 parse(semicolon); /* I said this was a
592 * kluge... */
593 ps.in_or_st = false; /* turn off flag for
594 * structure decl or
595 * initialization */
596 }
597 if (ps.sizeof_keyword)
598 ps.sizeof_mask |= 1 << ps.p_l_follow;
599 break;
600
601 case rparen: /* got a ')' or ']' */
602 rparen_count--;
603 if (ps.cast_mask & (1 << ps.p_l_follow) & ~ps.sizeof_mask) {
604 ps.last_u_d = true;
605 ps.cast_mask &= (1 << ps.p_l_follow) - 1;
606 }
607 ps.sizeof_mask &= (1 << ps.p_l_follow) - 1;
608 if (--ps.p_l_follow < 0) {
609 ps.p_l_follow = 0;
610 diag(0, "Extra %c", *token);
611 }
612 if (e_code == s_code) /* if the paren starts the
613 * line */
614 ps.paren_level = ps.p_l_follow; /* then indent it */
615
616 *e_code++ = token[0];
617 ps.want_blank = true;
618
619 if (sp_sw && (ps.p_l_follow == 0)) { /* check for end of if
620 * (...), or some such */
621 sp_sw = false;
622 force_nl = true; /* must force newline
623 * after if */
624 ps.last_u_d = true; /* inform lexi that a
625 * following operator is
626 * unary */
627 ps.in_stmt = false; /* dont use stmt
628 * continuation
629 * indentation */
630
631 parse(hd_type); /* let parser worry about if,
632 * or whatever */
633 }
634 ps.search_brace = btype_2; /* this should insure
635 * that constructs such
636 * as main(){...} and
637 * int[]{...} have their
638 * braces put in the
639 * right place */
640 break;
641
642 case unary_op: /* this could be any unary operation */
643 if (ps.want_blank)
644 *e_code++ = ' ';
645
646 if (troff && !ps.dumped_decl_indent && ps.in_decl && !is_procname) {
647 sprintf(e_code, "\n.Du %dp+\200p \"%s\"\n", dec_ind * 7, token);
648 ps.dumped_decl_indent = 1;
649 e_code += strlen(e_code);
650 } else {
651 const char *res = token;
652
653 if (ps.in_decl && !ps.block_init) { /* if this is a unary op
654 * in a declaration, we
655 * should indent this
656 * token */
657 for (i = 0; token[i]; ++i); /* find length of token */
658 while ((e_code - s_code) < (dec_ind - i)) {
659 CHECK_SIZE_CODE;
660 *e_code++ = ' '; /* pad it */
661 }
662 }
663 if (troff && token[0] == '-' && token[1] == '>')
664 res = "\\(->";
665 for (t_ptr = res; *t_ptr; ++t_ptr) {
666 CHECK_SIZE_CODE;
667 *e_code++ = *t_ptr;
668 }
669 }
670 ps.want_blank = false;
671 break;
672
673 case binary_op:/* any binary operation */
674 if (ps.want_blank)
675 *e_code++ = ' ';
676 {
677 const char *res = token;
678
679 if (troff)
680 switch (token[0]) {
681 case '<':
682 if (token[1] == '=')
683 res = "\\(<=";
684 break;
685 case '>':
686 if (token[1] == '=')
687 res = "\\(>=";
688 break;
689 case '!':
690 if (token[1] == '=')
691 res = "\\(!=";
692 break;
693 case '|':
694 if (token[1] == '|')
695 res = "\\(br\\(br";
696 else
697 if (token[1] == 0)
698 res = "\\(br";
699 break;
700 }
701 for (t_ptr = res; *t_ptr; ++t_ptr) {
702 CHECK_SIZE_CODE;
703 *e_code++ = *t_ptr; /* move the operator */
704 }
705 }
706 ps.want_blank = true;
707 break;
708
709 case postop: /* got a trailing ++ or -- */
710 *e_code++ = token[0];
711 *e_code++ = token[1];
712 ps.want_blank = true;
713 break;
714
715 case question: /* got a ? */
716 squest++; /* this will be used when a later
717 * colon appears so we can distinguish
718 * the <c>?<n>:<n> construct */
719 if (ps.want_blank)
720 *e_code++ = ' ';
721 *e_code++ = '?';
722 ps.want_blank = true;
723 break;
724
725 case casestmt: /* got word 'case' or 'default' */
726 scase = true; /* so we can process the later colon
727 * properly */
728 goto copy_id;
729
730 case colon: /* got a ':' */
731 if (squest > 0) { /* it is part of the <c>?<n>:
732 * <n> construct */
733 --squest;
734 if (ps.want_blank)
735 *e_code++ = ' ';
736 *e_code++ = ':';
737 ps.want_blank = true;
738 break;
739 }
740 if (ps.in_or_st) {
741 *e_code++ = ':';
742 ps.want_blank = false;
743 break;
744 }
745 ps.in_stmt = false; /* seeing a label does not
746 * imply we are in a stmt */
747 for (t_ptr = s_code; *t_ptr; ++t_ptr)
748 *e_lab++ = *t_ptr; /* turn everything so
749 * far into a label */
750 e_code = s_code;
751 *e_lab++ = ':';
752 *e_lab++ = ' ';
753 *e_lab = '\0';
754
755 force_nl = ps.pcase = scase; /* ps.pcase will be used
756 * by dump_line to
757 * decide how to indent
758 * the label. force_nl
759 * will force a case n:
760 * to be on a line by
761 * itself */
762 scase = false;
763 ps.want_blank = false;
764 break;
765
766 case semicolon:/* got a ';' */
767 ps.in_or_st = false; /* we are not in an
768 * initialization or structure
769 * declaration */
770 scase = false; /* these will only need resetting in a
771 * error */
772 squest = 0;
773 if (ps.last_token == rparen && rparen_count == 0)
774 ps.in_parameter_declaration = 0;
775 ps.cast_mask = 0;
776 ps.sizeof_mask = 0;
777 ps.block_init = 0;
778 ps.block_init_level = 0;
779 ps.just_saw_decl--;
780
781 if (ps.in_decl && s_code == e_code && !ps.block_init)
782 while ((e_code - s_code) < (dec_ind - 1)) {
783 CHECK_SIZE_CODE;
784 *e_code++ = ' ';
785 }
786
787 ps.in_decl = (ps.dec_nest > 0); /* if we were in a first
788 * level structure
789 * declaration, we arent
790 * any more */
791
792 if ((!sp_sw || hd_type != forstmt) && ps.p_l_follow > 0) {
793
794 /*
795 * This should be true iff there were unbalanced parens in the
796 * stmt. It is a bit complicated, because the semicolon might
797 * be in a for stmt
798 */
799 diag(1, "Unbalanced parens");
800 ps.p_l_follow = 0;
801 if (sp_sw) { /* this is a check for a if,
802 * while, etc. with unbalanced
803 * parens */
804 sp_sw = false;
805 parse(hd_type); /* dont lose the if, or
806 * whatever */
807 }
808 }
809 *e_code++ = ';';
810 ps.want_blank = true;
811 ps.in_stmt = (ps.p_l_follow > 0); /* we are no longer in
812 * the middle of a stmt */
813
814 if (!sp_sw) { /* if not if for (;;) */
815 parse(semicolon); /* let parser know about
816 * end of stmt */
817 force_nl = true; /* force newline after a
818 * end of stmt */
819 }
820 break;
821
822 case lbrace: /* got a '{' */
823 ps.in_stmt = false; /* dont indent the {} */
824 if (!ps.block_init)
825 force_nl = true; /* force other stuff on
826 * same line as '{' onto
827 * new line */
828 else
829 if (ps.block_init_level <= 0)
830 ps.block_init_level = 1;
831 else
832 ps.block_init_level++;
833
834 if (s_code != e_code && !ps.block_init) {
835 if (!btype_2) {
836 dump_line();
837 ps.want_blank = false;
838 } else
839 if (ps.in_parameter_declaration && !ps.in_or_st) {
840 ps.i_l_follow = 0;
841 dump_line();
842 ps.want_blank = false;
843 }
844 }
845 if (ps.in_parameter_declaration)
846 prefix_blankline_requested = 0;
847
848 if (ps.p_l_follow > 0) { /* check for preceding
849 * unbalanced parens */
850 diag(1, "Unbalanced parens");
851 ps.p_l_follow = 0;
852 if (sp_sw) { /* check for unclosed if, for,
853 * etc. */
854 sp_sw = false;
855 parse(hd_type);
856 ps.ind_level = ps.i_l_follow;
857 }
858 }
859 if (s_code == e_code)
860 ps.ind_stmt = false; /* dont put extra
861 * indentation on line
862 * with '{' */
863 if (ps.in_decl && ps.in_or_st) { /* this is either a
864 * structure declaration
865 * or an init */
866 di_stack[ps.dec_nest++] = dec_ind;
867 /* ? dec_ind = 0; */
868 } else {
869 ps.decl_on_line = false; /* we cant be in the
870 * middle of a
871 * declaration, so dont
872 * do special
873 * indentation of
874 * comments */
875 if (blanklines_after_declarations_at_proctop
876 && ps.in_parameter_declaration)
877 postfix_blankline_requested = 1;
878 ps.in_parameter_declaration = 0;
879 }
880 dec_ind = 0;
881 parse(lbrace); /* let parser know about this */
882 if (ps.want_blank) /* put a blank before '{' if
883 * '{' is not at start of line */
884 *e_code++ = ' ';
885 ps.want_blank = false;
886 *e_code++ = '{';
887 ps.just_saw_decl = 0;
888 break;
889
890 case rbrace: /* got a '}' */
891 if (ps.p_stack[ps.tos] == decl && !ps.block_init) /* semicolons can be
892 * omitted in
893 * declarations */
894 parse(semicolon);
895 if (ps.p_l_follow) { /* check for unclosed if, for,
896 * else. */
897 diag(1, "Unbalanced parens");
898 ps.p_l_follow = 0;
899 sp_sw = false;
900 }
901 ps.just_saw_decl = 0;
902 ps.block_init_level--;
903 if (s_code != e_code && !ps.block_init) { /* '}' must be first on
904 * line */
905 if (verbose)
906 diag(0, "Line broken");
907 dump_line();
908 }
909 *e_code++ = '}';
910 ps.want_blank = true;
911 ps.in_stmt = ps.ind_stmt = false;
912 if (ps.dec_nest > 0) { /* we are in multi-level
913 * structure declaration */
914 dec_ind = di_stack[--ps.dec_nest];
915 if (ps.dec_nest == 0 && !ps.in_parameter_declaration)
916 ps.just_saw_decl = 2;
917 ps.in_decl = true;
918 }
919 prefix_blankline_requested = 0;
920 parse(rbrace); /* let parser know about this */
921 ps.search_brace = cuddle_else && ps.p_stack[ps.tos] == ifhead
922 && ps.il[ps.tos] >= ps.ind_level;
923 if (ps.tos <= 1 && blanklines_after_procs && ps.dec_nest <= 0)
924 postfix_blankline_requested = 1;
925 break;
926
927 case swstmt: /* got keyword "switch" */
928 sp_sw = true;
929 hd_type = swstmt; /* keep this for when we have
930 * seen the expression */
931 goto copy_id; /* go move the token into buffer */
932
933 case sp_paren: /* token is if, while, for */
934 sp_sw = true; /* the interesting stuff is done after
935 * the expression is scanned */
936 hd_type = (*token == 'i' ? ifstmt :
937 (*token == 'w' ? whilestmt : forstmt));
938
939 /*
940 * remember the type of header for later use by parser
941 */
942 goto copy_id; /* copy the token into line */
943
944 case sp_nparen:/* got else, do */
945 ps.in_stmt = false;
946 if (*token == 'e') {
947 if (e_code != s_code && (!cuddle_else || e_code[-1] != '}')) {
948 if (verbose)
949 diag(0, "Line broken");
950 dump_line(); /* make sure this starts
951 * a line */
952 ps.want_blank = false;
953 }
954 force_nl = true; /* also, following stuff
955 * must go onto new line */
956 last_else = 1;
957 parse(elselit);
958 } else {
959 if (e_code != s_code) { /* make sure this starts
960 * a line */
961 if (verbose)
962 diag(0, "Line broken");
963 dump_line();
964 ps.want_blank = false;
965 }
966 force_nl = true; /* also, following stuff
967 * must go onto new line */
968 last_else = 0;
969 parse(dolit);
970 }
971 goto copy_id; /* move the token into line */
972
973 case decl: /* we have a declaration type (int, register,
974 * etc.) */
975 parse(decl); /* let parser worry about indentation */
976 if (ps.last_token == rparen && ps.tos <= 1) {
977 ps.in_parameter_declaration = 1;
978 if (s_code != e_code) {
979 dump_line();
980 ps.want_blank = 0;
981 }
982 }
983 if (ps.in_parameter_declaration && ps.indent_parameters && ps.dec_nest == 0) {
984 ps.ind_level = ps.i_l_follow = 1;
985 ps.ind_stmt = 0;
986 }
987 ps.in_or_st = true; /* this might be a structure
988 * or initialization
989 * declaration */
990 ps.in_decl = ps.decl_on_line = true;
991 if ( /* !ps.in_or_st && */ ps.dec_nest <= 0)
992 ps.just_saw_decl = 2;
993 prefix_blankline_requested = 0;
994 for (i = 0; token[i++];); /* get length of token */
995
996 /*
997 * dec_ind = e_code - s_code + (ps.decl_indent>i ? ps.decl_indent
998 * : i);
999 */
1000 dec_ind = ps.decl_indent > 0 ? ps.decl_indent : i;
1001 goto copy_id;
1002
1003 case ident: /* got an identifier or constant */
1004 if (ps.in_decl) { /* if we are in a declaration,
1005 * we must indent identifier */
1006 if (ps.want_blank)
1007 *e_code++ = ' ';
1008 ps.want_blank = false;
1009 if (is_procname == 0 || !procnames_start_line) {
1010 if (!ps.block_init) {
1011 if (troff && !ps.dumped_decl_indent) {
1012 sprintf(e_code, "\n.De %dp+\200p\n", dec_ind * 7);
1013 ps.dumped_decl_indent = 1;
1014 e_code += strlen(e_code);
1015 } else
1016 while ((e_code - s_code) < dec_ind) {
1017 CHECK_SIZE_CODE;
1018 *e_code++ = ' ';
1019 }
1020 }
1021 } else {
1022 if (dec_ind && s_code != e_code)
1023 dump_line();
1024 dec_ind = 0;
1025 ps.want_blank = false;
1026 }
1027 } else
1028 if (sp_sw && ps.p_l_follow == 0) {
1029 sp_sw = false;
1030 force_nl = true;
1031 ps.last_u_d = true;
1032 ps.in_stmt = false;
1033 parse(hd_type);
1034 }
1035 copy_id:
1036 if (ps.want_blank)
1037 *e_code++ = ' ';
1038 if (troff && ps.its_a_keyword) {
1039 e_code = chfont(&bodyf, &keywordf, e_code);
1040 for (t_ptr = token; *t_ptr; ++t_ptr) {
1041 CHECK_SIZE_CODE;
1042 *e_code++ = keywordf.allcaps
1043 ? toupper((unsigned char)*t_ptr)
1044 : *t_ptr;
1045 }
1046 e_code = chfont(&keywordf, &bodyf, e_code);
1047 } else
1048 for (t_ptr = token; *t_ptr; ++t_ptr) {
1049 CHECK_SIZE_CODE;
1050 *e_code++ = *t_ptr;
1051 }
1052 ps.want_blank = true;
1053 break;
1054
1055 case period: /* treat a period kind of like a binary
1056 * operation */
1057 *e_code++ = '.'; /* move the period into line */
1058 ps.want_blank = false; /* dont put a blank after a
1059 * period */
1060 break;
1061
1062 case comma:
1063 ps.want_blank = (s_code != e_code); /* only put blank after
1064 * comma if comma does
1065 * not start the line */
1066 if (ps.in_decl && is_procname == 0 && !ps.block_init)
1067 while ((e_code - s_code) < (dec_ind - 1)) {
1068 CHECK_SIZE_CODE;
1069 *e_code++ = ' ';
1070 }
1071
1072 *e_code++ = ',';
1073 if (ps.p_l_follow == 0) {
1074 if (ps.block_init_level <= 0)
1075 ps.block_init = 0;
1076 if (break_comma && (!ps.leave_comma || compute_code_target() + (e_code - s_code) > max_col - 8))
1077 force_nl = true;
1078 }
1079 break;
1080
1081 case preesc: /* got the character '#' */
1082 if ((s_com != e_com) ||
1083 (s_lab != e_lab) ||
1084 (s_code != e_code))
1085 dump_line();
1086 *e_lab++ = '#'; /* move whole line to 'label' buffer */
1087 {
1088 int in_comment = 0;
1089 int com_start = 0;
1090 char quote = 0;
1091 int com_end = 0;
1092
1093 while (*buf_ptr == ' ' || *buf_ptr == '\t') {
1094 buf_ptr++;
1095 if (buf_ptr >= buf_end)
1096 fill_buffer();
1097 }
1098 while (*buf_ptr != '\n' || in_comment) {
1099 CHECK_SIZE_LAB;
1100 *e_lab = *buf_ptr++;
1101 if (buf_ptr >= buf_end)
1102 fill_buffer();
1103 switch (*e_lab++) {
1104 case BACKSLASH:
1105 if (troff)
1106 *e_lab++ = BACKSLASH;
1107 if (!in_comment) {
1108 *e_lab++ = *buf_ptr++;
1109 if (buf_ptr >= buf_end)
1110 fill_buffer();
1111 }
1112 break;
1113 case '/':
1114 if (*buf_ptr == '*' && !in_comment && !quote) {
1115 in_comment = 1;
1116 *e_lab++ = *buf_ptr++;
1117 com_start = e_lab - s_lab - 2;
1118 }
1119 break;
1120 case '"':
1121 if (quote == '"')
1122 quote = 0;
1123 break;
1124 case '\'':
1125 if (quote == '\'')
1126 quote = 0;
1127 break;
1128 case '*':
1129 if (*buf_ptr == '/' && in_comment) {
1130 in_comment = 0;
1131 *e_lab++ = *buf_ptr++;
1132 com_end = e_lab - s_lab;
1133 }
1134 break;
1135 }
1136 }
1137
1138 while (e_lab > s_lab && (e_lab[-1] == ' ' || e_lab[-1] == '\t'))
1139 e_lab--;
1140 if (e_lab - s_lab == com_end && bp_save == 0) { /* comment on
1141 * preprocessor line */
1142 if (sc_end == 0) /* if this is the first
1143 * comment, we must set
1144 * up the buffer */
1145 sc_end = &(save_com[0]);
1146 else {
1147 *sc_end++ = '\n'; /* add newline between
1148 * comments */
1149 *sc_end++ = ' ';
1150 --line_no;
1151 }
1152 memmove(sc_end, s_lab + com_start, com_end - com_start);
1153 sc_end += com_end - com_start;
1154 if (sc_end >= &save_com[sc_size])
1155 abort();
1156 e_lab = s_lab + com_start;
1157 while (e_lab > s_lab && (e_lab[-1] == ' ' || e_lab[-1] == '\t'))
1158 e_lab--;
1159 bp_save = buf_ptr; /* save current input
1160 * buffer */
1161 be_save = buf_end;
1162 buf_ptr = save_com; /* fix so that
1163 * subsequent calls to
1164 * lexi will take tokens
1165 * out of save_com */
1166 *sc_end++ = ' '; /* add trailing blank,
1167 * just in case */
1168 buf_end = sc_end;
1169 sc_end = 0;
1170 }
1171 *e_lab = '\0'; /* null terminate line */
1172 ps.pcase = false;
1173 }
1174
1175 if (strncmp(s_lab, "#if", 3) == 0) {
1176 if (blanklines_around_conditional_compilation) {
1177 int c;
1178 prefix_blankline_requested++;
1179 while ((c = getc(input)) == '\n');
1180 ungetc(c, input);
1181 }
1182 if (ifdef_level < (int)(sizeof state_stack / sizeof state_stack[0])) {
1183 match_state[ifdef_level].tos = -1;
1184 state_stack[ifdef_level++] = ps;
1185 } else
1186 diag(1, "#if stack overflow");
1187 } else
1188 if (strncmp(s_lab, "#else", 5) == 0) {
1189 if (ifdef_level <= 0)
1190 diag(1, "Unmatched #else");
1191 else {
1192 match_state[ifdef_level - 1] = ps;
1193 ps = state_stack[ifdef_level - 1];
1194 }
1195 } else
1196 if (strncmp(s_lab, "#endif", 6) == 0) {
1197 if (ifdef_level <= 0)
1198 diag(1, "Unmatched #endif");
1199 else {
1200 ifdef_level--;
1201
1202 #ifdef undef
1203 /*
1204 * This match needs to be more intelligent before the
1205 * message is useful
1206 */
1207 if (match_state[ifdef_level].tos >= 0
1208 && memcmp(&ps, &match_state[ifdef_level], sizeof ps))
1209 diag(0, "Syntactically inconsistant #ifdef alternatives.");
1210 #endif
1211 }
1212 if (blanklines_around_conditional_compilation) {
1213 postfix_blankline_requested++;
1214 n_real_blanklines = 0;
1215 }
1216 }
1217 break; /* subsequent processing of the newline
1218 * character will cause the line to be printed */
1219
1220 case comment: /* we have gotten a start comment */
1221 /* this is a biggie */
1222 if (flushed_nl) { /* we should force a broken
1223 * line here */
1224 flushed_nl = false;
1225 dump_line();
1226 ps.want_blank = false; /* dont insert blank at
1227 * line start */
1228 force_nl = false;
1229 }
1230 pr_comment();
1231 break;
1232 } /* end of big switch stmt */
1233
1234 *e_code = '\0'; /* make sure code section is null terminated */
1235 if (type_code != comment && type_code != newline && type_code != preesc)
1236 ps.last_token = type_code;
1237 } /* end of main while (1) loop */
1238 }
1239 /*
1240 * copy input file to backup file if in_name is /blah/blah/blah/file, then
1241 * backup file will be ".Bfile" then make the backup file the input and
1242 * original input file the output
1243 */
1244 void
1245 bakcopy(void)
1246 {
1247 int n, bakchn;
1248 char buff[8 * 1024];
1249 const char *p;
1250
1251 /* construct file name .Bfile */
1252 for (p = in_name; *p; p++); /* skip to end of string */
1253 while (p > in_name && *p != '/') /* find last '/' */
1254 p--;
1255 if (*p == '/')
1256 p++;
1257 sprintf(bakfile, "%s.BAK", p);
1258
1259 /* copy in_name to backup file */
1260 bakchn = creat(bakfile, 0600);
1261 if (bakchn < 0)
1262 err(1, "%s", bakfile);
1263 while ((n = read(fileno(input), buff, sizeof buff)) > 0)
1264 if (write(bakchn, buff, n) != n)
1265 err(1, "%s", bakfile);
1266 if (n < 0)
1267 err(1, "%s", in_name);
1268 close(bakchn);
1269 fclose(input);
1270
1271 /* re-open backup file as the input file */
1272 input = fopen(bakfile, "r");
1273 if (input == 0)
1274 err(1, "%s", bakfile);
1275 /* now the original input file will be the output */
1276 output = fopen(in_name, "w");
1277 if (output == 0) {
1278 unlink(bakfile);
1279 err(1, "%s", in_name);
1280 }
1281 }
NetBSD on the FriendlyARM MINI2440