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