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

pr_comment defined in line 55; used 1 times

Defined variables

sccsid defined in line 8; never used
Last modified: 1987-02-17
Generated: 2016-12-26
Generated by src2html V0.67
page hit count: 1808
Valid CSS Valid XHTML 1.0 Strict