![[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] / 43BSD / ucb / indent|
Return to indent.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / indent |
1.1 ! root 1: /* ! 2: * Copyright (c) 1980 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: */ ! 6: ! 7: #ifndef lint ! 8: char copyright[] = ! 9: "@(#) Copyright (c) 1980 Regents of the University of California.\n\ ! 10: All rights reserved.\n"; ! 11: #endif not lint ! 12: ! 13: #ifndef lint ! 14: static char sccsid[] = "@(#)indent.c 5.4 (Berkeley) 9/10/85"; ! 15: #endif not lint ! 16: ! 17: /*- ! 18: ! 19: Copyright (C) 1976 ! 20: by the ! 21: Board of Trustees ! 22: of the ! 23: University of Illinois ! 24: ! 25: All rights reserved ! 26: ! 27: ! 28: NAME: ! 29: indent main program ! 30: ! 31: FUNCTION: ! 32: This is the main program of the indent program. Indent will take a C ! 33: program source and reformat it into a semi-reasonable form. ! 34: ! 35: ALGORITHM: ! 36: The routine lexi scans tokens and passes them back one at a time to the ! 37: main routine. The subroutine parse takes care of much of the work of ! 38: figuring indentation level. ! 39: ! 40: 1) Call lexi ! 41: 2) Enter a monster switch statement on the code returned by lexi. If ! 42: the indentation level for the line yet to be printed should be ! 43: changed, set the variable ps.ind_level. If the indentation level for ! 44: the following line should be changed, set the variable ps.i_l_follow. ! 45: ! 46: */ ! 47: #include "indent_globs.h"; ! 48: #include "indent_codes.h"; ! 49: ! 50: char *in_name = "Standard Input"; /* will always point to name of ! 51: * input file */ ! 52: char *out_name = "Standard Output"; /* will always point to ! 53: * name of output file */ ! 54: char bakfile[32] = ""; ! 55: ! 56: main(argc, argv) ! 57: int argc; ! 58: char **argv; ! 59: { ! 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); ! 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: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.