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