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