![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to indent.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / indent|
Return to indent.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / indent |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * Copyright (c) 1976 Board of Trustees of the University of Illinois.
4: * All rights reserved.
5: *
6: * Redistribution and use in source and binary forms are permitted
7: * provided that the above copyright notice and this paragraph are
8: * duplicated in all such forms and that any documentation,
9: * advertising materials, and other materials related to such
10: * distribution and use acknowledge that the software was developed
11: * by the University of California, Berkeley and the University
12: * of Illinois, Urbana. The name of either
13: * University may not be used to endorse or promote products derived
14: * from this software without specific prior written permission.
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
16: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
17: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18: */
19:
20: #ifndef lint
21: char copyright[] =
22: "@(#) Copyright (c) 1980 Regents of the University of California.\n\
23: Copyright (c) 1976 Board of Trustees of the University of Illinois.\n\
24: All rights reserved.\n";
25: #endif /* not lint */
26:
27: #ifndef lint
28: static char sccsid[] = "@(#)indent.c 5.8 (Berkeley) 6/29/88";
29: #endif /* not lint */
30:
31: /*
32: NAME:
33: indent main program
34:
35: FUNCTION:
36: This is the main program of the indent program. Indent will take a C
37: program source and reformat it into a semi-reasonable form.
38:
39: ALGORITHM:
40: The routine lexi scans tokens and passes them back one at a time to the
41: main routine. The subroutine parse takes care of much of the work of
42: figuring indentation level.
43:
44: 1) Call lexi
45: 2) Enter a monster switch statement on the code returned by lexi. If
46: the indentation level for the line yet to be printed should be
47: changed, set the variable ps.ind_level. If the indentation level for
48: the following line should be changed, set the variable ps.i_l_follow.
49:
50: */
51: #include "indent_globs.h"
52: #include "indent_codes.h"
53:
54: char *in_name = "Standard Input"; /* will always point to name of
55: * input file */
56: char *out_name = "Standard Output"; /* will always point to
57: * name of output file */
58: char bakfile[32] = "";
59:
60: main(argc, argv)
61: int argc;
62: char **argv;
63: {
64: extern int found_err; /* if any error occurred */
65:
66: int dec_ind; /* current indentation for declarations */
67: int di_stack[20]; /* a stack of structure indentation levels */
68: int flushed_nl; /* used when buffering up comments to
69: * remember that a newline was passed over */
70: int force_nl; /* when true, code must be broken */
71: int hd_type; /* used to store type of stmt for if
72: * (...), for (...), etc */
73: register int i; /* local loop counter */
74: register int j; /* local loop counter */
75: int scase; /* set to true when we see a case, so we
76: * will know what to do with the following
77: * colon */
78: int sp_sw; /* when true, we are in the expressin of
79: * if(...), while(...), etc. */
80: int squest; /* when this is positive, we have seen a ?
81: * without the matching : in a <c>?<s>:<s>
82: * construct */
83: register char *t_ptr; /* used for copying tokens */
84: int type_code; /* the type of token, returned by lexi */
85:
86: int last_else = 0; /* true iff last keyword was an else */
87:
88:
89: /*-----------------------------------------------*\
90: | INITIALIZATION |
91: \*-----------------------------------------------*/
92:
93:
94: ps.p_stack[0] = stmt; /* this is the parser's stack */
95: ps.last_nl = true; /* this is true if the last thing scanned
96: * was a newline */
97: ps.last_token = semicolon;
98: combuf[0] = codebuf[0] = labbuf[0] = ' '; /* set up code, label, and
99: * comment buffers */
100: combuf[1] = codebuf[1] = labbuf[1] = '\0';
101: s_lab = e_lab = labbuf + 1;
102: s_code = e_code = codebuf + 1;
103: s_com = e_com = combuf + 1;
104:
105: buf_ptr = buf_end = in_buffer;
106: line_no = 1;
107: had_eof = ps.in_decl = ps.decl_on_line = break_comma = false;
108: sp_sw = force_nl = false;
109: ps.in_or_st = false;
110: ps.bl_line = true;
111: dec_ind = 0;
112: di_stack[ps.dec_nest = 0] = 0;
113: ps.want_blank = ps.in_stmt = ps.ind_stmt = false;
114:
115:
116: scase = ps.pcase = false;
117: squest = 0;
118: sc_end = 0;
119: bp_save = 0;
120: be_save = 0;
121:
122: output = 0;
123:
124:
125:
126: /*--------------------------------------------------*\
127: | COMMAND LINE SCAN
128: \*--------------------------------------------------*/
129:
130: set_defaults();
131:
132: /*
133: * Unfortunately, we must look for -npro here because the profiles
134: * are read before the command line arguments.
135: */
136: for (i = 1; i < argc; ++i)
137: if (strcmp(argv[i], "-npro") == 0)
138: break;
139: if (i >= argc)
140: set_profile();
141:
142: input = 0; /* cancel -st if it was in the profiles, */
143: output = 0; /* as it doesn't make any sense there. */
144:
145: for (i = 1; i < argc; ++i) {
146:
147: /*
148: * look thru args (if any) for changes to defaults
149: */
150: if (argv[i][0] != '-') {/* no flag on parameter */
151: if (input == 0) { /* we must have the input file */
152: in_name = argv[i]; /* remember name of input file */
153: input = fopen(in_name, "r");
154: if (input == 0) { /* check for open error */
155: fprintf(stderr, "indent: can't open %s\n", argv[i]);
156: exit(1);
157: }
158: continue;
159: } else if (output == 0) { /* we have the output file */
160: out_name = argv[i]; /* remember name of output file */
161: if (strcmp(in_name, out_name) == 0) { /* attempt to overwrite
162: * the file */
163: fprintf(stderr, "indent: input and output files must be different\n");
164: exit(1);
165: }
166: output = fopen(out_name, "w");
167: if (output == 0) { /* check for create error */
168: fprintf(stderr, "indent: can't create %s\n", argv[i]);
169: exit(1);
170: }
171: continue;
172: }
173: fprintf(stderr, "indent: unknown parameter: %s\n", argv[i]);
174: exit(1);
175: } else
176: set_option(argv[i]);
177:
178: } /* end of for */
179: if (input == 0) {
180: printf("Usage: indent file [ outfile ] [ options ]\n");
181: exit(1);
182: }
183: if (output == 0)
184: if (troff)
185: output = stdout;
186: else {
187: out_name = in_name;
188: bakcopy();
189: }
190:
191: /*
192: * Adjust parameters that are out of range, or set defaults if
193: * no values were specified.
194: */
195: if (ps.com_ind <= 1)
196: ps.com_ind = 2; /* dont put normal comments before column
197: * 2 */
198: if (block_comment_max_col <= 0)
199: block_comment_max_col = max_col;
200: if (ps.decl_com_ind <= 0) /* if not specified by user, set this */
201: ps.decl_com_ind = ps.ljust_decl ? ps.com_ind - 8 : ps.com_ind;
202: if (ps.decl_com_ind <= 1)
203: ps.decl_com_ind = 2;
204: if (continuation_indent == 0)
205: continuation_indent = ps.ind_size;
206: fill_buffer(); /* get first batch of stuff into input
207: * buffer */
208:
209: parse(semicolon);
210: {
211: register char *p = buf_ptr;
212: register col = 1;
213:
214: while (1) {
215: if (*p == ' ')
216: col++;
217: else if (*p == '\t')
218: col = ((col - 1) & ~7) + 9;
219: else
220: break;
221: p++;
222: };
223: if (col > ps.ind_size)
224: ps.ind_level = ps.i_l_follow = col / ps.ind_size;
225: }
226: if (troff) {
227: register char *p = in_name,
228: *beg = in_name;
229:
230: while (*p)
231: if (*p++ == '/')
232: beg = p;
233: fprintf(output, ".Fn \"%s\"\n", beg);
234: }
235:
236: /*
237: * START OF MAIN LOOP
238: */
239:
240: while (1) { /* this is the main loop. it will go
241: * until we reach eof */
242: int is_procname;
243:
244: type_code = lexi(); /* lexi reads one token. The actual
245: * characters read are stored in "token".
246: * lexi returns a code indicating the type
247: * of token */
248: is_procname = ps.procname[0];
249:
250: /*
251: * The following code moves everything following an if (), while
252: * (), else, etc. up to the start of the following stmt to a
253: * buffer. This allows proper handling of both kinds of brace
254: * placement.
255: */
256:
257: flushed_nl = false;
258: while (ps.search_brace) { /* if we scanned an if(), while(),
259: * etc., we might need to copy
260: * stuff into a buffer we must
261: * loop, copying stuff into
262: * save_com, until we find the
263: * start of the stmt which follows
264: * the if, or whatever */
265: switch (type_code) {
266: case newline:
267: ++line_no;
268: flushed_nl = true;
269: case form_feed:
270: break; /* form feeds and newlines found here will
271: * be ignored */
272:
273: case lbrace: /* this is a brace that starts the
274: * compound stmt */
275: if (sc_end == 0) { /* ignore buffering if a comment
276: * wasnt stored up */
277: ps.search_brace = false;
278: goto check_type;
279: }
280: if (btype_2) {
281: save_com[0] = '{'; /* we either want to put
282: * the brace right after
283: * the if */
284: goto sw_buffer; /* go to common code to get out of
285: * this loop */
286: }
287: case comment: /* we have a comment, so we must copy it
288: * into the buffer */
289: if (!flushed_nl) {
290: if (sc_end == 0) { /* if this is the first
291: * comment, we must set up
292: * the buffer */
293: save_com[0] = save_com[1] = ' ';
294: sc_end = &(save_com[2]);
295: } else {
296: *sc_end++ = '\n'; /* add newline between
297: * comments */
298: *sc_end++ = ' ';
299: --line_no;
300: }
301: *sc_end++ = '/'; /* copy in start of
302: * comment */
303: *sc_end++ = '*';
304:
305: for (;;) { /* loop until we get to the end of
306: * the comment */
307: *sc_end = *buf_ptr++;
308: if (buf_ptr >= buf_end)
309: fill_buffer();
310:
311: if (*sc_end++ == '*' && *buf_ptr == '/')
312: break; /* we are at end of comment */
313:
314: if (sc_end >= &(save_com[sc_size])) { /* check for temp buffer
315: * overflow */
316: diag(1, "Internal buffer overflow - Move big comment from right after if, while, or whatever.");
317: fflush(output);
318: exit(1);
319: }
320: }
321: *sc_end++ = '/'; /* add ending slash */
322: if (++buf_ptr >= buf_end) /* get past / in buffer */
323: fill_buffer();
324: break;
325: }
326: default: /* it is the start of a normal statment */
327: if (flushed_nl) /* if we flushed a newline, make
328: * sure it is put back */
329: force_nl = true;
330: if (type_code == sp_paren && *token == 'i'
331: && last_else && ps.else_if
332: || type_code == sp_nparen && *token == 'e'
333: && e_code != s_code && e_code[-1] == '}')
334: force_nl = false;
335:
336: if (sc_end == 0) { /* ignore buffering if comment
337: * wasnt saved up */
338: ps.search_brace = false;
339: goto check_type;
340: }
341: if (force_nl) { /* if we should insert a nl here,
342: * put it into the buffer */
343: force_nl = false;
344: --line_no; /* this will be re-increased when
345: * the nl is read from the buffer */
346: *sc_end++ = '\n';
347: *sc_end++ = ' ';
348: if (verbose && !flushed_nl) /* print error msg if
349: * the line was not
350: * already broken */
351: diag(0, "Line broken");
352: flushed_nl = false;
353: }
354: for (t_ptr = token; *t_ptr; ++t_ptr)
355: *sc_end++ = *t_ptr; /* copy token into temp
356: * buffer */
357:
358: sw_buffer:
359: ps.search_brace = false; /* stop looking for start
360: * of stmt */
361: bp_save = buf_ptr; /* save current input buffer */
362: be_save = buf_end;
363: buf_ptr = save_com; /* fix so that subsequent calls to
364: * lexi will take tokens out of
365: * save_com */
366: *sc_end++ = ' '; /* add trailing blank, just in
367: * case */
368: buf_end = sc_end;
369: sc_end = 0;
370: break;
371: } /* end of switch */
372: if (type_code != 0) /* we must make this check, just in case
373: * there was an unexpected EOF */
374: type_code = lexi(); /* read another token */
375: is_procname = ps.procname[0];
376: } /* end of while (serach_brace) */
377: last_else = 0;
378: check_type:
379: if (type_code == 0) { /* we got eof */
380: if (s_lab != e_lab || s_code != e_code
381: || s_com != e_com) /* must dump end of line */
382: dump_line();
383: if (ps.tos > 1) /* check for balanced braces */
384: diag(1, "Stuff missing from end of file.");
385:
386: if (verbose) {
387: printf("There were %d output lines and %d comments\n",
388: ps.out_lines, ps.out_coms);
389: printf("(Lines with comments)/(Lines with code): %6.3f\n",
390: (1.0 * ps.com_lines) / code_lines);
391: }
392: fflush(output);
393: exit(ps.tos > 1 || found_err);
394: }
395: if (
396: (type_code != comment) &&
397: (type_code != newline) &&
398: (type_code != preesc) &&
399: (type_code != form_feed)) {
400: if (
401: force_nl
402: &&
403: (type_code != semicolon) &&
404: (
405: type_code != lbrace
406: ||
407: !btype_2
408: )) { /* we should force a broken line here */
409: if (verbose && !flushed_nl)
410: diag(0, "Line broken");
411: flushed_nl = false;
412: dump_line();
413: ps.want_blank = false; /* dont insert blank at line start */
414: force_nl = false;
415: }
416: ps.in_stmt = true; /* turn on flag which causes an extra
417: * level of indentation. this is turned
418: * off by a ; or '}' */
419: if (s_com != e_com) { /* the turkey has embedded a
420: * comment in a line. fix it */
421: *e_code++ = ' ';
422: for (t_ptr = s_com; *t_ptr; ++t_ptr)
423: *e_code++ = *t_ptr;
424: *e_code++ = ' ';
425: *e_code = '\0'; /* null terminate code sect */
426: ps.want_blank = false;
427: e_com = s_com;
428: }
429: } else if (type_code != comment) /* preserve force_nl thru
430: * a comment */
431: force_nl = false;
432:
433: /*
434: * cancel forced newline after newline, form feed, etc
435: */
436:
437:
438:
439: /*----------------------------------------------------*\
440: | do switch on type of token scanned
441: \*----------------------------------------------------*/
442: switch (type_code) { /* now, decide what to do with the token */
443:
444: case form_feed: /* found a form feed in line */
445: ps.use_ff = true; /* a form feed is treated much
446: * like a newline */
447: dump_line();
448: ps.want_blank = false;
449: break;
450:
451: case newline:
452: if (ps.last_token != comma || ps.p_l_follow > 0
453: || !ps.leave_comma || !break_comma || s_com != e_com) {
454: dump_line();
455: ps.want_blank = false;
456: }
457: ++line_no; /* keep track of input line number */
458: break;
459:
460: case lparen: /* got a '(' or '[' */
461: ++ps.p_l_follow;/* count parens to make Healy happy */
462: if (ps.want_blank && *token != '[' &&
463: (ps.last_token != ident || proc_calls_space
464: || (ps.its_a_keyword && !ps.sizeof_keyword)))
465: *e_code++ = ' ';
466: if (ps.in_decl && !ps.block_init)
467: if (troff && !ps.dumped_decl_indent) {
468: ps.dumped_decl_indent = 1;
469: sprintf(e_code, "\\c\n.Du %dp+\200p \"%s\"\n", dec_ind * 7, token);
470: e_code += strlen(e_code);
471: } else {
472: while ((e_code - s_code) < dec_ind)
473: *e_code++ = ' ';
474: *e_code++ = token[0];
475: } else
476: *e_code++ = token[0];
477: ps.paren_indents[ps.p_l_follow - 1] = e_code - s_code;
478: ps.want_blank = false;
479: if (ps.in_or_st && *token == '(') {
480:
481: /*
482: * this is a kluge to make sure that declarations will
483: * be aligned right if proc decl has an explicit type
484: * on it, i.e. "int a(x) {..."
485: */
486: parse(semicolon); /* I said this was a kluge... */
487: ps.in_or_st = false; /* turn off flag for
488: * structure decl or
489: * initialization */
490: }
491: if (ps.sizeof_keyword) ps.sizeof_mask |= 1<<ps.p_l_follow;
492: break;
493:
494: case rparen: /* got a ')' or ']' */
495: if (ps.cast_mask & (1 << ps.p_l_follow) & ~ps.sizeof_mask) {
496: ps.last_u_d = true;
497: ps.cast_mask &= (1 << ps.p_l_follow) - 1;
498: }
499: ps.sizeof_mask &= (1 << ps.p_l_follow) - 1;
500: if (--ps.p_l_follow < 0) {
501: ps.p_l_follow = 0;
502: diag(0, "Extra %c", *token);
503: }
504: if (e_code == s_code) /* if the paren starts the line */
505: ps.paren_level = ps.p_l_follow; /* then indent it */
506:
507: *e_code++ = token[0];
508: ps.want_blank = true;
509:
510: if (sp_sw && (ps.p_l_follow == 0)) { /* check for end of if
511: * (...), or some such */
512: sp_sw = false;
513: force_nl = true; /* must force newline after if */
514: ps.last_u_d = true; /* inform lexi that a following
515: * operator is unary */
516: ps.in_stmt = false; /* dont use stmt continuation
517: * indentation */
518:
519: parse(hd_type); /* let parser worry about if, or
520: * whatever */
521: }
522: ps.search_brace = btype_2; /* this should insure that
523: * constructs such as
524: * main(){...} and
525: * int[]{...} have their
526: * braces put in the right
527: * place */
528: break;
529:
530: case unary_op: /* this could be any unary operation */
531: if (ps.want_blank)
532: *e_code++ = ' ';
533:
534: if (troff && !ps.dumped_decl_indent && ps.in_decl) {
535: sprintf(e_code, "\\c\n.Du %dp+\200p \"%s\"\n", dec_ind * 7, token);
536: ps.dumped_decl_indent = 1;
537: e_code += strlen(e_code);
538: } else {
539: char *res = token;
540:
541: if (ps.in_decl && !ps.block_init) { /* if this is a unary op
542: * in a declaration, we
543: * should indent this
544: * token */
545: for (i = 0; token[i]; ++i); /* find length of token */
546: while ((e_code - s_code) < (dec_ind - i))
547: *e_code++ = ' '; /* pad it */
548: }
549: if (troff && token[0] == '-' && token[1] == '>')
550: res = "\\(->";
551: for (t_ptr = res; *t_ptr; ++t_ptr)
552: *e_code++ = *t_ptr;
553: }
554: ps.want_blank = false;
555: break;
556:
557: case binary_op: /* any binary operation */
558: do_binary:
559: if (ps.want_blank)
560: *e_code++ = ' ';
561: {
562: char *res = token;
563:
564: if (troff)
565: switch (token[0]) {
566: case '<':
567: if (token[1] == '=')
568: res = "\\(<=";
569: break;
570: case '>':
571: if (token[1] == '=')
572: res = "\\(>=";
573: break;
574: case '!':
575: if (token[1] == '=')
576: res = "\\(!=";
577: break;
578: case '|':
579: if (token[1] == '|')
580: res = "\\(br\\(br";
581: else if (token[1] == 0)
582: res = "\\(br";
583: break;
584: case '-':
585: if (token[1] == '>')
586: res = "\\(->";
587: }
588: for (t_ptr = res; *t_ptr; ++t_ptr)
589: *e_code++ = *t_ptr; /* move the operator */
590: }
591: ps.want_blank = true;
592: break;
593:
594: case postop: /* got a trailing ++ or -- */
595: *e_code++ = token[0];
596: *e_code++ = token[1];
597: ps.want_blank = true;
598: break;
599:
600: case question: /* got a ? */
601: squest++; /* this will be used when a later colon
602: * appears so we can distinguish the
603: * <c>?<n>:<n> construct */
604: if (ps.want_blank)
605: *e_code++ = ' ';
606: *e_code++ = '?';
607: ps.want_blank = true;
608: break;
609:
610: case casestmt: /* got word 'case' or 'default' */
611: scase = true; /* so we can process the later colon
612: * properly */
613: goto copy_id;
614:
615: case colon: /* got a ':' */
616: if (squest > 0) { /* it is part of the <c>?<n>: <n>
617: * construct */
618: --squest;
619: if (ps.want_blank)
620: *e_code++ = ' ';
621: *e_code++ = ':';
622: ps.want_blank = true;
623: break;
624: }
625: if (ps.in_decl) {
626: *e_code++ = ':';
627: ps.want_blank = false;
628: break;
629: }
630: ps.in_stmt = false; /* seeing a label does not imply
631: * we are in a stmt */
632: for (t_ptr = s_code; *t_ptr; ++t_ptr)
633: *e_lab++ = *t_ptr; /* turn everything so far into a
634: * label */
635: e_code = s_code;
636: *e_lab++ = ':';
637: *e_lab++ = ' ';
638: *e_lab = '\0';
639:
640: force_nl = ps.pcase = scase; /* ps.pcase will be used
641: * by dump_line to decide
642: * how to indent the
643: * label. force_nl will
644: * force a case n: to be
645: * on a line by itself */
646: scase = false;
647: ps.want_blank = false;
648: break;
649:
650: case semicolon: /* got a ';' */
651: ps.in_or_st = false; /* we are not in an initialization
652: * or structure declaration */
653: scase = false; /* these will only need resetting in a
654: * error */
655: squest = 0;
656: if (ps.last_token == rparen)
657: ps.in_parameter_declaration = 0;
658: ps.cast_mask = 0;
659: ps.sizeof_mask = 0;
660: ps.block_init = 0;
661: ps.just_saw_decl--;
662:
663: if (ps.in_decl && s_code == e_code && !ps.block_init)
664: while ((e_code - s_code) < (dec_ind - 1))
665: *e_code++ = ' ';
666:
667: ps.in_decl = (ps.dec_nest > 0); /* if we were in a first
668: * level structure
669: * declaration, we arent
670: * any more */
671:
672: if ((!sp_sw || hd_type != forstmt) && ps.p_l_follow > 0) {
673:
674: /*
675: * This should be true iff there were unbalanced
676: * parens in the stmt. It is a bit complicated,
677: * because the semicolon might be in a for stmt
678: */
679: diag(1, "Unbalanced parens");
680: ps.p_l_follow = 0;
681: if (sp_sw) {/* this is a check for a if, while, etc.
682: * with unbalanced parens */
683: sp_sw = false;
684: parse(hd_type); /* dont lose the if, or whatever */
685: }
686: }
687: *e_code++ = ';';
688: ps.want_blank = true;
689: ps.in_stmt = (ps.p_l_follow > 0); /* we are no longer in
690: * the middle of a stmt */
691:
692: if (!sp_sw) { /* if not if for (;;) */
693: parse(semicolon); /* let parser know about end of
694: * stmt */
695: force_nl = true; /* force newline after a end of
696: * stmt */
697: }
698: break;
699:
700: case lbrace: /* got a '{' */
701: ps.in_stmt = false; /* dont indent the {} */
702: if (!ps.block_init)
703: force_nl = true; /* force other stuff on same line
704: * as '{' onto new line */
705:
706: if (s_code != e_code && !ps.block_init) {
707: if (!btype_2) {
708: dump_line();
709: ps.want_blank = false;
710: } else if (ps.in_parameter_declaration && !ps.in_or_st) {
711: ps.i_l_follow = 0;
712: dump_line();
713: ps.want_blank = false;
714: }
715: }
716: if (ps.in_parameter_declaration)
717: prefix_blankline_requested = 0;
718:
719: if (ps.p_l_follow > 0) { /* check for preceding
720: * unbalanced parens */
721: diag(1, "Unbalanced parens");
722: ps.p_l_follow = 0;
723: if (sp_sw) {/* check for unclosed if, for, etc. */
724: sp_sw = false;
725: parse(hd_type);
726: ps.ind_level = ps.i_l_follow;
727: }
728: }
729: if (s_code == e_code)
730: ps.ind_stmt = false; /* dont put extra
731: * indentation on line
732: * with '{' */
733: if (ps.in_decl && ps.in_or_st) { /* this is either a
734: * structure declaration
735: * or an init */
736: di_stack[ps.dec_nest++] = dec_ind;
737: dec_ind = 0;
738: } else {
739: ps.decl_on_line = false; /* we cant be in the
740: * middle of a
741: * declaration, so dont do
742: * special indentation of
743: * comments */
744: ps.in_parameter_declaration = 0;
745: }
746: parse(lbrace); /* let parser know about this */
747: if (ps.want_blank) /* put a blank before '{' if '{'
748: * is not at start of line */
749: *e_code++ = ' ';
750: ps.want_blank = false;
751: *e_code++ = '{';
752: ps.just_saw_decl = 0;
753: break;
754:
755: case rbrace: /* got a '}' */
756: if (ps.p_l_follow) { /* check for unclosed if, for,
757: * else. */
758: diag(1, "Unbalanced parens");
759: ps.p_l_follow = 0;
760: sp_sw = false;
761: }
762: ps.just_saw_decl = 0;
763: if (s_code != e_code && !ps.block_init) { /* '}' must be first on
764: * line */
765: if (verbose)
766: diag(0, "Line broken");
767: dump_line();
768: }
769: *e_code++ = '}';
770: ps.want_blank = true;
771: ps.in_stmt = ps.ind_stmt = false;
772: if (ps.dec_nest > 0) { /* we are in multi-level structure
773: * declaration */
774: dec_ind = di_stack[--ps.dec_nest];
775: if (ps.dec_nest == 0 && !ps.in_parameter_declaration)
776: ps.just_saw_decl = 2;
777: ps.in_decl = true;
778: }
779: prefix_blankline_requested = 0;
780: parse(rbrace); /* let parser know about this */
781: ps.search_brace = cuddle_else && ps.p_stack[ps.tos] == ifhead && ps.il[ps.tos] >= ps.ind_level;
782: if (ps.tos <= 1 && blanklines_after_procs && ps.dec_nest <= 0)
783: postfix_blankline_requested = 1;
784: break;
785:
786: case swstmt: /* got keyword "switch" */
787: sp_sw = true;
788: hd_type = swstmt; /* keep this for when we have seen
789: * the expression */
790: goto copy_id; /* go move the token into buffer */
791:
792: case sp_paren: /* token is if, while, for */
793: sp_sw = true; /* the interesting stuff is done after the
794: * expression is scanned */
795: hd_type = (*token == 'i' ? ifstmt :
796: (*token == 'w' ? whilestmt : forstmt));
797:
798: /*
799: * remember the type of header for later use by parser
800: */
801: goto copy_id; /* copy the token into line */
802:
803: case sp_nparen: /* got else, do */
804: ps.in_stmt = false;
805: if (*token == 'e') {
806: if (e_code != s_code && (!cuddle_else || e_code[-1] != '}')) {
807: if (verbose)
808: diag(0, "Line broken");
809: dump_line(); /* make sure this starts a line */
810: ps.want_blank = false;
811: }
812: force_nl = true; /* also, following stuff must go
813: * onto new line */
814: last_else = 1;
815: parse(elselit);
816: } else {
817: if (e_code != s_code) { /* make sure this starts a
818: * line */
819: if (verbose)
820: diag(0, "Line broken");
821: dump_line();
822: ps.want_blank = false;
823: }
824: force_nl = true; /* also, following stuff must go
825: * onto new line */
826: last_else = 0;
827: parse(dolit);
828: }
829: goto copy_id; /* move the token into line */
830:
831: case decl: /* we have a declaration type (int,
832: * register, etc.) */
833: parse(decl); /* let parser worry about indentation */
834: if (ps.last_token == rparen && ps.tos <= 1)
835: ps.in_parameter_declaration = 1;
836: if (ps.in_parameter_declaration && ps.indent_parameters && ps.dec_nest == 0) {
837: ps.ind_level = ps.i_l_follow = 1;
838: ps.ind_stmt = 0;
839: }
840: ps.in_or_st = true; /* this might be a structure or
841: * initialization declaration */
842: ps.in_decl = ps.decl_on_line = true;
843: if ( /* !ps.in_or_st && */ ps.dec_nest <= 0)
844: ps.just_saw_decl = 2;
845: prefix_blankline_requested = 0;
846: for (i = 0; token[i++];); /* get length of token */
847:
848: /*
849: * dec_ind = e_code - s_code + (ps.decl_indent>i ?
850: * ps.decl_indent : i);
851: */
852: dec_ind = ps.decl_indent > 0 ? ps.decl_indent : i;
853: goto copy_id;
854:
855: case ident: /* got an identifier or constant */
856: if (ps.in_decl) { /* if we are in a declaration, we
857: * must indent identifier */
858: if (ps.want_blank)
859: *e_code++ = ' ';
860: ps.want_blank = false;
861: if (is_procname == 0 || !procnames_start_line) {
862: if (!ps.block_init)
863: if (troff && !ps.dumped_decl_indent) {
864: sprintf(e_code, "\\c\n.De %dp+\200p\n", dec_ind * 7);
865: ps.dumped_decl_indent = 1;
866: e_code += strlen(e_code);
867: } else
868: while ((e_code - s_code) < dec_ind)
869: *e_code++ = ' ';
870: } else {
871: if (dec_ind && s_code != e_code)
872: dump_line();
873: dec_ind = 0;
874: ps.want_blank = false;
875: }
876: } else if (sp_sw && ps.p_l_follow == 0) {
877: sp_sw = false;
878: force_nl = true;
879: ps.last_u_d = true;
880: ps.in_stmt = false;
881: parse(hd_type);
882: }
883: copy_id:
884: if (ps.want_blank)
885: *e_code++ = ' ';
886: if (troff && ps.its_a_keyword) {
887: *e_code++ = BACKSLASH;
888: *e_code++ = 'f';
889: *e_code++ = 'B';
890: }
891: for (t_ptr = token; *t_ptr; ++t_ptr)
892: *e_code++ = *t_ptr;
893: if (troff && ps.its_a_keyword) {
894: *e_code++ = BACKSLASH;
895: *e_code++ = 'f';
896: *e_code++ = 'R';
897: }
898: ps.want_blank = true;
899: break;
900:
901: case period: /* treat a period kind of like a binary
902: * operation */
903: *e_code++ = '.';/* move the period into line */
904: ps.want_blank = false; /* dont put a blank after a period */
905: break;
906:
907: case comma:
908: ps.want_blank = (s_code != e_code); /* only put blank after
909: * comma if comma does
910: * not start the line */
911: if (ps.in_decl && is_procname == 0 && !ps.block_init)
912: while ((e_code - s_code) < (dec_ind - 1))
913: *e_code++ = ' ';
914:
915: *e_code++ = ',';
916: if (ps.p_l_follow == 0) {
917: ps.block_init = 0;
918: if (break_comma && !ps.leave_comma)
919: force_nl = true;
920: }
921: break;
922:
923: case preesc: /* got the character '#' */
924: if ((s_com != e_com) ||
925: (s_lab != e_lab) ||
926: (s_code != e_code))
927: dump_line();
928: *e_lab++ = '#'; /* move whole line to 'label' buffer */
929: {
930: int in_comment = 0;
931: char *com_start = 0;
932: char quote = 0;
933: char *com_end = 0;
934:
935: while (*buf_ptr != '\n' || in_comment) {
936: *e_lab = *buf_ptr++;
937: if (buf_ptr >= buf_end)
938: fill_buffer();
939: switch (*e_lab++) {
940: case BACKSLASH:
941: if (troff)
942: *e_lab++ = BACKSLASH;
943: if (!in_comment) {
944: *e_lab++ = *buf_ptr++;
945: if (buf_ptr >= buf_end)
946: fill_buffer();
947: }
948: break;
949: case '/':
950: if (*buf_ptr == '*' && !in_comment && !quote) {
951: in_comment = 1;
952: *e_lab++ = *buf_ptr++;
953: com_start = e_lab - 2;
954: }
955: break;
956: case '"':
957: if (quote == '"')
958: quote = 0;
959: break;
960: case '\'':
961: if (quote == '\'')
962: quote = 0;
963: break;
964: case '*':
965: if (*buf_ptr == '/' && in_comment) {
966: in_comment = 0;
967: *e_lab++ = *buf_ptr++;
968: com_end = e_lab;
969: }
970: break;
971: }
972: }
973: while (e_lab > s_lab && (e_lab[-1] == ' ' || e_lab[-1] == '\t'))
974: e_lab--;
975: if (e_lab == com_end && bp_save == 0) { /* comment on
976: * preprocessor line */
977: if (sc_end == 0) /* if this is the first
978: * comment, we must set up
979: * the buffer */
980: sc_end = &(save_com[0]);
981: else {
982: *sc_end++ = '\n'; /* add newline between
983: * comments */
984: *sc_end++ = ' ';
985: --line_no;
986: }
987: bcopy(com_start, sc_end, com_end - com_start);
988: sc_end += com_end - com_start;
989: e_lab = com_start;
990: while (e_lab > s_lab && (e_lab[-1] == ' ' || e_lab[-1] == '\t'))
991: e_lab--;
992: bp_save = buf_ptr; /* save current input
993: * buffer */
994: be_save = buf_end;
995: buf_ptr = save_com; /* fix so that subsequent
996: * calls to lexi will take
997: * tokens out of save_com */
998: *sc_end++ = ' '; /* add trailing blank,
999: * just in case */
1000: buf_end = sc_end;
1001: sc_end = 0;
1002: }
1003: *e_lab = '\0'; /* null terminate line */
1004: ps.pcase = false;
1005: }
1006: if (strncmp(s_lab, "#if", 3) == 0)
1007: if (ifdef_level < sizeof state_stack / sizeof state_stack[0]) {
1008: match_state[ifdef_level].tos = -1;
1009: state_stack[ifdef_level++] = ps;
1010: } else
1011: diag(1, "#if stack overflow");
1012: else if (strncmp(s_lab, "#else", 5) == 0)
1013: if (ifdef_level <= 0)
1014: diag(1, "Unmatched #else");
1015: else {
1016: match_state[ifdef_level - 1] = ps;
1017: ps = state_stack[ifdef_level - 1];
1018: } else if (strncmp(s_lab, "#endif", 6) == 0)
1019: if (ifdef_level <= 0)
1020: diag(1, "Unmatched #endif");
1021: else {
1022: ifdef_level--;
1023: #ifdef undef
1024:
1025: /*
1026: * This match needs to be more intelligent before
1027: * the message is useful
1028: */
1029: if (match_state[ifdef_level].tos >= 0
1030: && bcmp(&ps, &match_state[ifdef_level], sizeof ps))
1031: diag(0, "Syntactically inconsistant #ifdef alternatives.");
1032: #endif
1033: }
1034: break; /* subsequent processing of the newline
1035: * character will cause the line to be
1036: * printed */
1037:
1038: case comment: /* we have gotten a /* this is a biggie */
1039: proc_comment:
1040: if (flushed_nl) { /* we should force a broken line
1041: * here */
1042: flushed_nl = false;
1043: dump_line();
1044: ps.want_blank = false; /* dont insert blank at
1045: * line start */
1046: force_nl = false;
1047: }
1048: pr_comment();
1049: break;
1050: } /* end of big switch stmt */
1051: *e_code = '\0'; /* make sure code section is null
1052: * terminated */
1053: if (type_code != comment && type_code != newline && type_code != preesc)
1054: ps.last_token = type_code;
1055: } /* end of main while (1) loop */
1056: };
1057:
1058: /*
1059: * copy input file to backup file. If in_name is /blah/blah/blah/file, then
1060: * backup file will be "file.BAK". Then make the backup file the input and
1061: * original input file the output.
1062: */
1063: bakcopy()
1064: {
1065: int n,
1066: bakchn;
1067: char buff[BUFSIZ];
1068: register char *p;
1069: char *rindex();
1070:
1071: if ((p = rindex(in_name, '/')) != NULL)
1072: p++;
1073: else
1074: p = in_name;
1075: sprintf(bakfile, "%s.BAK", p);
1076:
1077: /* copy in_name to backup file */
1078: bakchn = creat(bakfile, 0600);
1079: if (bakchn < 0) {
1080: fprintf(stderr, "indent: can't create backup file \"%s\"\n", bakfile);
1081: exit(1);
1082: }
1083: while ((n = read(fileno(input), buff, sizeof buff)) > 0)
1084: if (write(bakchn, buff, n) != n) {
1085: fprintf(stderr, "indent: error writing backup file \"%s\"\n",
1086: bakfile);
1087: exit(1);
1088: }
1089: if (n < 0) {
1090: fprintf(stderr, "indent: error reading input file \"%s\"\n", in_name);
1091: exit(1);
1092: }
1093: close(bakchn);
1094: fclose(input);
1095:
1096: /* re-open backup file as the input file */
1097: input = fopen(bakfile, "r");
1098: if (input == NULL) {
1099: fprintf(stderr, "indent: can't re-open backup file\n");
1100: exit(1);
1101: }
1102: /* now the original input file will be the output */
1103: output = fopen(in_name, "w");
1104: if (output == NULL) {
1105: fprintf(stderr, "indent: can't create %s\n", in_name);
1106: unlink(bakfile);
1107: exit(1);
1108: }
1109: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.