![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pr_comment.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 pr_comment.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ucb / indent |
1.1 root 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 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.