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: static char sccsid[] = "@(#)pr_comment.c 5.3 (Berkeley) 9/8/85"; 9: #endif not lint 10: 11: /*- 12: * 13: * Copyright (C) 1976 14: * by the 15: * Board of Trustees 16: * of the 17: * University of Illinois 18: * 19: * All rights reserved 20: * 21: * 22: * NAME: 23: * pr_comment 24: * 25: * FUNCTION: 26: * This routine takes care of scanning and printing comments. 27: * 28: * ALGORITHM: 29: * 1) Decide where the comment should be aligned, and if lines should 30: * be broken. 31: * 2) If lines should not be broken and filled, just copy up to end of 32: * comment. 33: * 3) If lines should be filled, then scan thru input_buffer copying 34: * characters to com_buf. Remember where the last blank, tab, or 35: * newline was. When line is filled, print up to last blank and 36: * continue copying. 37: * 38: * HISTORY: 39: * November 1976 D A Willcox of CAC Initial coding 40: * 12/6/76 D A Willcox of CAC Modification to handle 41: * UNIX-style comments 42: * 43: */ 44: 45: /* 46: * this routine processes comments. It makes an attempt to keep comments 47: * from going over the max line length. If a line is too long, it moves 48: * everything from the last blank to the next comment line. Blanks and 49: * tabs from the beginning of the input line are removed 50: */ 51: 52: #include "indent_globs.h"; 53: 54: 55: pr_comment() 56: { 57: int now_col; /* column we are in now */ 58: int adj_max_col; /* Adjusted max_col for when we decide to 59: * spill comments over the right margin */ 60: int col_1_com; /* this comment should not be touched */ 61: char *last_bl; /* points to the last blank in the output 62: * buffer */ 63: char achar; 64: char *t_ptr; /* used for moving string */ 65: int unix_comment; /* tri-state variable used to decide if it 66: * is a unix-style comment. 0 means only 67: * blanks since /*, 1 means regular style 68: * comment, 2 means unix style comment */ 69: int break_delim = comment_delimiter_on_blankline; 70: int l_just_saw_decl = ps.just_saw_decl; 71: /* 72: * int ps.last_nl = 0; /* true iff the last significant 73: * thing weve seen is a newline 74: */ 75: int one_liner = 1; /* true iff this comment is a one-liner */ 76: adj_max_col = max_col; 77: ps.just_saw_decl = 0; 78: last_bl = 0; /* no blanks found so far */ 79: ps.box_com = col_1_com = false; /* at first, assume that we are 80: * not in a boxed comment or some 81: * other comment that should not 82: * be touched */ 83: ++ps.out_coms; /* keep track of number of comments */ 84: unix_comment = 1; /* set flag to let us figure out if there 85: * is a unix-style comment ** DISABLED: 86: * use 0 to reenable this hack! */ 87: 88: /* Figure where to align and how to treat the comment */ 89: 90: if (ps.col_1 && !format_col1_comments) { /* if comment starts in 91: * column 1 it should not 92: * be touched */ 93: col_1_com = ps.box_com = true; 94: ps.com_col = 1; 95: } else { 96: if (*buf_ptr == '-' || *buf_ptr == '*') { 97: ps.box_com = true; /* a comment with a '-' or '*' immediately 98: * after the /* is assumed to be a boxed 99: * comment */ 100: col_1_com = true; 101: break_delim = 0; 102: } 103: if ( /* ps.bl_line && */ (s_lab == e_lab) && (s_code == e_code)) { 104: /* klg: check only if this line is blank */ 105: /* 106: * If this (*and previous lines are*) blank, dont put comment 107: * way out at left 108: */ 109: ps.com_col = (ps.ind_level - ps.unindent_displace) * ps.ind_size + 1; 110: adj_max_col = block_comment_max_col; 111: if (ps.com_col <= 1) 112: ps.com_col = 1 + !format_col1_comments; 113: } else { 114: register target_col; 115: break_delim = 0; 116: if (s_code != e_code) 117: target_col = count_spaces(compute_code_target(), s_code); 118: else { 119: target_col = 1; 120: if (s_lab != e_lab) 121: target_col = count_spaces(compute_label_target(), s_lab); 122: } 123: ps.com_col = ps.decl_on_line || ps.ind_level == 0 ? ps.decl_com_ind : ps.com_ind; 124: if (ps.com_col < target_col) 125: ps.com_col = ((target_col + 7) & ~7) + 1; 126: if (ps.com_col + 24 > adj_max_col) 127: adj_max_col = ps.com_col + 24; 128: } 129: } 130: if (ps.box_com) { 131: buf_ptr[-2] = 0; 132: ps.n_comment_delta = 1 - count_spaces(1, in_buffer); 133: ps.comment_delta = 0; 134: buf_ptr[-2] = '/'; 135: } else { 136: ps.n_comment_delta = 0; 137: ps.comment_delta = 0; 138: while (*buf_ptr == ' ' || *buf_ptr == '\t') 139: buf_ptr++; 140: } 141: ps.comment_delta = 0; 142: *e_com++ = '/'; /* put '/*' into buffer */ 143: *e_com++ = '*'; 144: if (*buf_ptr != ' ' && !ps.box_com) 145: *e_com++ = ' '; 146: 147: *e_com = '\0'; 148: now_col = count_spaces(ps.com_col, s_com); /* figure what column we 149: * would be in if we 150: * printed the comment now */ 151: 152: /* Start to copy the comment */ 153: 154: while (1) { /* this loop will go until the comment is 155: * copied */ 156: if (*buf_ptr > 040 && *buf_ptr != '*') 157: ps.last_nl = 0; 158: switch (*buf_ptr) { /* this checks for various spcl cases */ 159: case 014: /* check for a form feed */ 160: if (!ps.box_com) { /* in a text comment, break the 161: * line here */ 162: ps.use_ff = true; 163: /* fix so dump_line uses a form feed */ 164: dump_line(); 165: last_bl = 0; 166: *e_com++ = ' '; 167: *e_com++ = '*'; 168: *e_com++ = ' '; 169: while (*++buf_ptr == ' ' || *buf_ptr == '\t'); 170: } else { 171: if (++buf_ptr >= buf_end) 172: fill_buffer(); 173: *e_com++ = 014; 174: } 175: break; 176: 177: case '\n': 178: if (had_eof) { /* check for unexpected eof */ 179: printf("Unterminated comment\n"); 180: *e_com = '\0'; 181: dump_line(); 182: return; 183: } 184: one_liner = 0; 185: if (ps.box_com || ps.last_nl) { /* if this is a boxed 186: * comment, we dont ignore 187: * the newline */ 188: if (s_com == e_com) { 189: *e_com++ = ' '; 190: *e_com++ = ' '; 191: } 192: *e_com = '\0'; 193: if (!ps.box_com && e_com - s_com > 3) { 194: if (break_delim == 1 && s_com[0] == '/' 195: && s_com[1] == '*' && s_com[2] == ' ') { 196: char *t = e_com; 197: break_delim = 2; 198: e_com = s_com + 2; 199: *e_com = 0; 200: if (blanklines_before_blockcomments) prefix_blankline_requested = 1; 201: dump_line(); 202: e_com = t; 203: s_com[0] = s_com[1] = s_com[2] = ' '; 204: } 205: dump_line(); 206: *e_com++ = ' '; 207: *e_com++ = ' '; 208: } 209: dump_line(); 210: now_col = ps.com_col; 211: } else { 212: ps.last_nl = 1; 213: if (unix_comment != 1) { /* we not are in 214: * unix_style comment */ 215: if (unix_comment == 0 && s_code == e_code) { 216: /* 217: * if it is a UNIX-style comment, ignore the 218: * requirement that previous line be blank for 219: * unindention 220: */ 221: ps.com_col = (ps.ind_level - ps.unindent_displace) * ps.ind_size + 1; 222: if (ps.com_col <= 1) 223: ps.com_col = 2; 224: } 225: unix_comment = 2; /* permanently remember that we 226: * are in this type of comment */ 227: dump_line(); 228: ++line_no; 229: now_col = ps.com_col; 230: *e_com++ = ' '; 231: /* 232: * fix so that the star at the start of the line will 233: * line up 234: */ 235: do /* flush leading white space */ 236: if (++buf_ptr >= buf_end) 237: fill_buffer(); 238: while (*buf_ptr == ' ' || *buf_ptr == '\t'); 239: break; 240: } 241: if (*(e_com - 1) == ' ' || *(e_com - 1) == '\t') 242: last_bl = e_com - 1; 243: /* 244: * if there was a space at the end of the last line, 245: * remember where it was 246: */ 247: else { /* otherwise, insert one */ 248: last_bl = e_com; 249: *e_com++ = ' '; 250: ++now_col; 251: } 252: } 253: ++line_no; /* keep track of input line number */ 254: if (!ps.box_com) { 255: int nstar = 1; 256: do { /* flush any blanks and/or tabs at start 257: * of next line */ 258: if (++buf_ptr >= buf_end) 259: fill_buffer(); 260: if (*buf_ptr == '*' && --nstar >= 0) { 261: if (++buf_ptr >= buf_end) 262: fill_buffer(); 263: if (*buf_ptr == '/') 264: goto end_of_comment; 265: } 266: } while (*buf_ptr == ' ' || *buf_ptr == '\t'); 267: } else if (++buf_ptr >= buf_end) fill_buffer(); 268: break; /* end of case for newline */ 269: 270: case '*': /* must check for possibility of being at 271: * end of comment */ 272: if (++buf_ptr >= buf_end) /* get to next char after * */ 273: fill_buffer(); 274: 275: if (unix_comment == 0) /* set flag to show we are not in 276: * unix-style comment */ 277: unix_comment = 1; 278: 279: if (*buf_ptr == '/') { /* it is the end!!! */ 280: end_of_comment: 281: if (++buf_ptr >= buf_end) 282: fill_buffer(); 283: 284: if (*(e_com - 1) != ' ' && !ps.box_com) { /* insure blank before 285: * end */ 286: *e_com++ = ' '; 287: ++now_col; 288: } 289: if (break_delim == 1 && !one_liner && s_com[0] == '/' 290: && s_com[1] == '*' && s_com[2] == ' ') { 291: char *t = e_com; 292: break_delim = 2; 293: e_com = s_com + 2; 294: *e_com = 0; 295: if (blanklines_before_blockcomments) prefix_blankline_requested = 1; 296: dump_line(); 297: e_com = t; 298: s_com[0] = s_com[1] = s_com[2] = ' '; 299: } 300: if (break_delim == 2 && e_com > s_com + 3 301: /* now_col > adj_max_col - 2 && !ps.box_com */ ) { 302: *e_com = '\0'; 303: dump_line(); 304: now_col = ps.com_col; 305: } 306: *e_com++ = '*'; 307: *e_com++ = '/'; 308: *e_com = '\0'; 309: ps.just_saw_decl = l_just_saw_decl; 310: return; 311: } else { /* handle isolated '*' */ 312: *e_com++ = '*'; 313: ++now_col; 314: } 315: break; 316: default: /* we have a random char */ 317: if (unix_comment == 0 && *buf_ptr != ' ' && *buf_ptr != '\t') 318: unix_comment = 1; /* we are not in unix-style 319: * comment */ 320: 321: *e_com = *buf_ptr++; 322: if (buf_ptr >= buf_end) 323: fill_buffer(); 324: 325: if (*e_com == '\t') /* keep track of column */ 326: now_col = ((now_col - 1) & tabmask) + tabsize + 1; 327: else if (*e_com == '\b') /* this is a backspace */ 328: --now_col; 329: else 330: ++now_col; 331: 332: if (*e_com == ' ' || *e_com == '\t') 333: last_bl = e_com; 334: /* remember we saw a blank */ 335: 336: ++e_com; 337: if (now_col > adj_max_col && !ps.box_com && unix_comment == 1 && e_com[-1] > ' ') { 338: /* the comment is too long, it must be broken up */ 339: if (break_delim == 1 && s_com[0] == '/' 340: && s_com[1] == '*' && s_com[2] == ' ') { 341: char *t = e_com; 342: break_delim = 2; 343: e_com = s_com + 2; 344: *e_com = 0; 345: if (blanklines_before_blockcomments) prefix_blankline_requested = 1; 346: dump_line(); 347: e_com = t; 348: s_com[0] = s_com[1] = s_com[2] = ' '; 349: } 350: if (last_bl == 0) { /* we have seen no blanks */ 351: last_bl = e_com; /* fake it */ 352: *e_com++ = ' '; 353: } 354: *e_com = '\0'; /* print what we have */ 355: *last_bl = '\0'; 356: while (last_bl > s_com && last_bl[-1] < 040) 357: *--last_bl = 0; 358: e_com = last_bl; 359: dump_line(); 360: 361: *e_com++ = ' '; /* add blanks for continuation */ 362: *e_com++ = ' '; 363: *e_com++ = ' '; 364: 365: t_ptr = last_bl + 1; 366: last_bl = 0; 367: if (t_ptr >= e_com) { 368: while (*t_ptr == ' ' || *t_ptr == '\t') 369: t_ptr++; 370: while (*t_ptr != '\0') { /* move unprinted part 371: * of comment down in 372: * buffer */ 373: if (*t_ptr == ' ' || *t_ptr == '\t') 374: last_bl = e_com; 375: *e_com++ = *t_ptr++; 376: } 377: } 378: *e_com = '\0'; 379: now_col = count_spaces(ps.com_col, s_com); /* recompute current 380: * position */ 381: } 382: break; 383: } 384: } 385: }
Defined functions
Defined variables
|
Last modified: 1985-09-09
Generated: 2016-12-26 |
Generated by src2html V0.67
page hit count: 1242 |
|