GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: usr.bin/indent/pr_comment.c Lines: 0 187 0.0 %
Date: 2017-11-07 Branches: 0 193 0.0 %

Line Branch Exec Source
1
/*	$OpenBSD: pr_comment.c,v 1.7 2009/10/27 23:59:39 deraadt Exp $	*/
2
3
/*
4
 * Copyright (c) 1980, 1993
5
 *	The Regents of the University of California.
6
 * Copyright (c) 1976 Board of Trustees of the University of Illinois.
7
 * Copyright (c) 1985 Sun Microsystems, Inc.
8
 * All rights reserved.
9
 *
10
 * Redistribution and use in source and binary forms, with or without
11
 * modification, are permitted provided that the following conditions
12
 * are met:
13
 * 1. Redistributions of source code must retain the above copyright
14
 *    notice, this list of conditions and the following disclaimer.
15
 * 2. Redistributions in binary form must reproduce the above copyright
16
 *    notice, this list of conditions and the following disclaimer in the
17
 *    documentation and/or other materials provided with the distribution.
18
 * 3. Neither the name of the University nor the names of its contributors
19
 *    may be used to endorse or promote products derived from this software
20
 *    without specific prior written permission.
21
 *
22
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32
 * SUCH DAMAGE.
33
 */
34
35
#include <err.h>
36
#include <stdio.h>
37
#include <stdlib.h>
38
#include "indent_globs.h"
39
40
/*
41
 * NAME:
42
 *	pr_comment
43
 *
44
 * FUNCTION:
45
 *	This routine takes care of scanning and printing comments.
46
 *
47
 * ALGORITHM:
48
 *	1) Decide where the comment should be aligned, and if lines should
49
 *	   be broken.
50
 *	2) If lines should not be broken and filled, just copy up to end of
51
 *	   comment.
52
 *	3) If lines should be filled, then scan thru input_buffer copying
53
 *	   characters to com_buf.  Remember where the last blank, tab, or
54
 *	   newline was.  When line is filled, print up to last blank and
55
 *	   continue copying.
56
 *
57
 * HISTORY:
58
 *	November 1976	D A Willcox of CAC	Initial coding
59
 *	12/6/76		D A Willcox of CAC	Modification to handle
60
 *						UNIX-style comments
61
 *
62
 */
63
64
/*
65
 * this routine processes comments.  It makes an attempt to keep comments from
66
 * going over the max line length.  If a line is too long, it moves everything
67
 * from the last blank to the next comment line.  Blanks and tabs from the
68
 * beginning of the input line are removed
69
 */
70
71
void
72
pr_comment(void)
73
{
74
    int         now_col;	/* column we are in now */
75
    int         adj_max_col;	/* Adjusted max_col for when we decide to
76
				 * spill comments over the right margin */
77
    char       *last_bl;	/* points to the last blank in the output
78
				 * buffer */
79
    char       *t_ptr;		/* used for moving string */
80
    int         unix_comment;	/* tri-state variable used to decide if it is
81
				 * a unix-style comment. 0 means only blanks
82
				 * since / *, 1 means regular style comment, 2
83
				 * means unix style comment */
84
    int         break_delim = comment_delimiter_on_blankline;
85
    int         l_just_saw_decl = ps.just_saw_decl;
86
    /*
87
     * int         ps.last_nl = 0;	 true iff the last significant thing
88
     * we've seen is a newline
89
     */
90
    int         one_liner = 1;	/* true iff this comment is a one-liner */
91
    adj_max_col = max_col;
92
    ps.just_saw_decl = 0;
93
    last_bl = 0;		/* no blanks found so far */
94
    ps.box_com = false;		/* at first, assume that we are not in
95
				 * a boxed comment or some other
96
				 * comment that should not be touched */
97
    ++ps.out_coms;		/* keep track of number of comments */
98
    unix_comment = 1;		/* set flag to let us figure out if there is a
99
				 * unix-style comment ** DISABLED: use 0 to
100
				 * reenable this hack! */
101
102
    /* Figure where to align and how to treat the comment */
103
104
    if (ps.col_1 && !format_col1_comments) {	/* if comment starts in column
105
						 * 1 it should not be touched */
106
	ps.box_com = true;
107
	ps.com_col = 1;
108
    }
109
    else {
110
	if (*buf_ptr == '-' || *buf_ptr == '*' || *buf_ptr == '\n') {
111
	    ps.box_com = true;	/* a comment with a '-', '*' or newline
112
				 * immediately after the / * is assumed to be
113
				 * a boxed comment */
114
	    break_delim = 0;
115
	}
116
	if ( /* ps.bl_line && */ (s_lab == e_lab) && (s_code == e_code)) {
117
	    /* klg: check only if this line is blank */
118
	    /*
119
	     * If this (*and previous lines are*) blank, don't put comment way
120
	     * out at left
121
	     */
122
	    ps.com_col = (ps.ind_level - ps.unindent_displace) * ps.ind_size + 1;
123
	    adj_max_col = block_comment_max_col;
124
	    if (ps.com_col <= 1)
125
		ps.com_col = 1 + !format_col1_comments;
126
	}
127
	else {
128
	    int    target_col;
129
	    break_delim = 0;
130
	    if (s_code != e_code)
131
		target_col = count_spaces(compute_code_target(), s_code);
132
	    else {
133
		target_col = 1;
134
		if (s_lab != e_lab)
135
		    target_col = count_spaces(compute_label_target(), s_lab);
136
	    }
137
	    ps.com_col = ps.decl_on_line || ps.ind_level == 0 ? ps.decl_com_ind : ps.com_ind;
138
	    if (ps.com_col < target_col)
139
		ps.com_col = ((target_col + 7) & ~7) + 1;
140
	    if (ps.com_col + 24 > adj_max_col)
141
		adj_max_col = ps.com_col + 24;
142
	}
143
    }
144
    if (ps.box_com) {
145
	buf_ptr[-2] = 0;
146
	ps.n_comment_delta = 1 - count_spaces(1, in_buffer);
147
	buf_ptr[-2] = '/';
148
    }
149
    else {
150
	ps.n_comment_delta = 0;
151
	while (*buf_ptr == ' ' || *buf_ptr == '\t')
152
	    buf_ptr++;
153
    }
154
    ps.comment_delta = 0;
155
    *e_com++ = '/';		/* put '/ *' into buffer */
156
    *e_com++ = '*';
157
    if (*buf_ptr != ' ' && !ps.box_com)
158
	*e_com++ = ' ';
159
160
    *e_com = '\0';
161
    if (troff) {
162
	now_col = 1;
163
	adj_max_col = 80;
164
    }
165
    else
166
	now_col = count_spaces(ps.com_col, s_com);	/* figure what column we
167
							 * would be in if we
168
							 * printed the comment
169
							 * now */
170
171
    /* Start to copy the comment */
172
173
    while (1) {			/* this loop will go until the comment is
174
				 * copied */
175
	if (*buf_ptr > 040 && *buf_ptr != '*')
176
	    ps.last_nl = 0;
177
	CHECK_SIZE_COM;
178
	switch (*buf_ptr) {	/* this checks for various spcl cases */
179
	case 014:		/* check for a form feed */
180
	    if (!ps.box_com) {	/* in a text comment, break the line here */
181
		ps.use_ff = true;
182
		/* fix so dump_line uses a form feed */
183
		dump_line();
184
		last_bl = 0;
185
		*e_com++ = ' ';
186
		*e_com++ = '*';
187
		*e_com++ = ' ';
188
		while (*++buf_ptr == ' ' || *buf_ptr == '\t');
189
	    }
190
	    else {
191
		if (++buf_ptr >= buf_end)
192
		    fill_buffer();
193
		*e_com++ = 014;
194
	    }
195
	    break;
196
197
	case '\n':
198
	    if (had_eof) {	/* check for unexpected eof */
199
		printf("Unterminated comment\n");
200
		*e_com = '\0';
201
		dump_line();
202
		return;
203
	    }
204
	    one_liner = 0;
205
	    if (ps.box_com || ps.last_nl) {	/* if this is a boxed comment,
206
						 * we don't ignore the newline
207
						 */
208
		if (s_com == e_com) {
209
		    *e_com++ = ' ';
210
		    *e_com++ = ' ';
211
		}
212
		*e_com = '\0';
213
		if (!ps.box_com && e_com - s_com > 3) {
214
		    if (break_delim == 1 && s_com[0] == '/'
215
			    && s_com[1] == '*' && s_com[2] == ' ') {
216
			char       *t = e_com;
217
			break_delim = 2;
218
			e_com = s_com + 2;
219
			*e_com = 0;
220
			if (blanklines_before_blockcomments)
221
			    prefix_blankline_requested = 1;
222
			dump_line();
223
			e_com = t;
224
			s_com[0] = s_com[1] = s_com[2] = ' ';
225
		    }
226
		    dump_line();
227
		    CHECK_SIZE_COM;
228
		    *e_com++ = ' ';
229
		    *e_com++ = ' ';
230
		}
231
		dump_line();
232
		now_col = ps.com_col;
233
	    }
234
	    else {
235
		ps.last_nl = 1;
236
		if (unix_comment != 1) {	/* we not are in unix_style
237
						 * comment */
238
		    if (unix_comment == 0 && s_code == e_code) {
239
			/*
240
			 * if it is a UNIX-style comment, ignore the
241
			 * requirement that previous line be blank for
242
			 * unindention
243
			 */
244
			ps.com_col = (ps.ind_level - ps.unindent_displace) * ps.ind_size + 1;
245
			if (ps.com_col <= 1)
246
			    ps.com_col = 2;
247
		    }
248
		    unix_comment = 2;	/* permanently remember that we are in
249
					 * this type of comment */
250
		    dump_line();
251
		    ++line_no;
252
		    now_col = ps.com_col;
253
		    *e_com++ = ' ';
254
		    /*
255
		     * fix so that the star at the start of the line will line
256
		     * up
257
		     */
258
		    do		/* flush leading white space */
259
			if (++buf_ptr >= buf_end)
260
			    fill_buffer();
261
		    while (*buf_ptr == ' ' || *buf_ptr == '\t');
262
		    break;
263
		}
264
		if (*(e_com - 1) == ' ' || *(e_com - 1) == '\t')
265
		    last_bl = e_com - 1;
266
		/*
267
		 * if there was a space at the end of the last line, remember
268
		 * where it was
269
		 */
270
		else {		/* otherwise, insert one */
271
		    last_bl = e_com;
272
		    CHECK_SIZE_COM;
273
		    *e_com++ = ' ';
274
		    ++now_col;
275
		}
276
	    }
277
	    ++line_no;		/* keep track of input line number */
278
	    if (!ps.box_com) {
279
		int         nstar = 1;
280
		do {		/* flush any blanks and/or tabs at start of
281
				 * next line */
282
		    if (++buf_ptr >= buf_end)
283
			fill_buffer();
284
		    if (*buf_ptr == '*' && --nstar >= 0) {
285
			if (++buf_ptr >= buf_end)
286
			    fill_buffer();
287
			if (*buf_ptr == '/')
288
			    goto end_of_comment;
289
		    }
290
		} while (*buf_ptr == ' ' || *buf_ptr == '\t');
291
	    }
292
	    else if (++buf_ptr >= buf_end)
293
		fill_buffer();
294
	    break;		/* end of case for newline */
295
296
	case '*':		/* must check for possibility of being at end
297
				 * of comment */
298
	    if (++buf_ptr >= buf_end)	/* get to next char after * */
299
		fill_buffer();
300
301
	    if (unix_comment == 0)	/* set flag to show we are not in
302
					 * unix-style comment */
303
		unix_comment = 1;
304
305
	    if (*buf_ptr == '/') {	/* it is the end!!! */
306
	end_of_comment:
307
		if (++buf_ptr >= buf_end)
308
		    fill_buffer();
309
310
		if (*(e_com - 1) != ' ' && !ps.box_com) {	/* insure blank before
311
								 * end */
312
		    *e_com++ = ' ';
313
		    ++now_col;
314
		}
315
		if (break_delim == 1 && !one_liner && s_com[0] == '/'
316
			&& s_com[1] == '*' && s_com[2] == ' ') {
317
		    char       *t = e_com;
318
		    break_delim = 2;
319
		    e_com = s_com + 2;
320
		    *e_com = 0;
321
		    if (blanklines_before_blockcomments)
322
			prefix_blankline_requested = 1;
323
		    dump_line();
324
		    e_com = t;
325
		    s_com[0] = s_com[1] = s_com[2] = ' ';
326
		}
327
		if (break_delim == 2 && e_com > s_com + 3
328
			 /* now_col > adj_max_col - 2 && !ps.box_com */ ) {
329
		    *e_com = '\0';
330
		    dump_line();
331
		    now_col = ps.com_col;
332
		}
333
		CHECK_SIZE_COM;
334
		*e_com++ = '*';
335
		*e_com++ = '/';
336
		*e_com = '\0';
337
		ps.just_saw_decl = l_just_saw_decl;
338
		return;
339
	    }
340
	    else {		/* handle isolated '*' */
341
		*e_com++ = '*';
342
		++now_col;
343
	    }
344
	    break;
345
	default:		/* we have a random char */
346
	    if (unix_comment == 0 && *buf_ptr != ' ' && *buf_ptr != '\t')
347
		unix_comment = 1;	/* we are not in unix-style comment */
348
349
	    *e_com = *buf_ptr++;
350
	    if (buf_ptr >= buf_end)
351
		fill_buffer();
352
353
	    if (*e_com == '\t')	/* keep track of column */
354
		now_col = ((now_col - 1) & tabmask) + tabsize + 1;
355
	    else if (*e_com == '\b')	/* this is a backspace */
356
		--now_col;
357
	    else
358
		++now_col;
359
360
	    if (*e_com == ' ' || *e_com == '\t')
361
		last_bl = e_com;
362
	    /* remember we saw a blank */
363
364
	    ++e_com;
365
	    if (now_col > adj_max_col && !ps.box_com && unix_comment == 1 && e_com[-1] > ' ') {
366
		/*
367
		 * the comment is too long, it must be broken up
368
		 */
369
		if (break_delim == 1 && s_com[0] == '/'
370
			&& s_com[1] == '*' && s_com[2] == ' ') {
371
		    char       *t = e_com;
372
		    break_delim = 2;
373
		    e_com = s_com + 2;
374
		    *e_com = 0;
375
		    if (blanklines_before_blockcomments)
376
			prefix_blankline_requested = 1;
377
		    dump_line();
378
		    e_com = t;
379
		    s_com[0] = s_com[1] = s_com[2] = ' ';
380
		}
381
		if (last_bl == 0) {	/* we have seen no blanks */
382
		    last_bl = e_com;	/* fake it */
383
		    *e_com++ = ' ';
384
		}
385
		*e_com = '\0';	/* print what we have */
386
		*last_bl = '\0';
387
		while (last_bl > s_com && last_bl[-1] < 040)
388
		    *--last_bl = 0;
389
		e_com = last_bl;
390
		dump_line();
391
392
		*e_com++ = ' ';	/* add blanks for continuation */
393
		*e_com++ = ' ';
394
		*e_com++ = ' ';
395
396
		t_ptr = last_bl + 1;
397
		last_bl = 0;
398
		if (t_ptr >= e_com) {
399
		    while (*t_ptr == ' ' || *t_ptr == '\t')
400
			t_ptr++;
401
		    while (*t_ptr != '\0') {	/* move unprinted part of
402
						 * comment down in buffer */
403
			if (*t_ptr == ' ' || *t_ptr == '\t')
404
			    last_bl = e_com;
405
			*e_com++ = *t_ptr++;
406
		    }
407
		}
408
		*e_com = '\0';
409
		now_col = count_spaces(ps.com_col, s_com);	/* recompute current
410
								 * position */
411
	    }
412
	    break;
413
	}
414
    }
415
}