Head

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 %


/*	$OpenBSD: pr_comment.c,v 1.7 2009/10/27 23:59:39 deraadt Exp $	*/

/*
 * Copyright (c) 1980, 1993
 *	The Regents of the University of California.
 * Copyright (c) 1976 Board of Trustees of the University of Illinois.
 * Copyright (c) 1985 Sun Microsystems, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <err.h>
#include <stdio.h>
#include <stdlib.h>
#include "indent_globs.h"

/*
 * NAME:
 *	pr_comment
 *
 * FUNCTION:
 *	This routine takes care of scanning and printing comments.
 *
 * ALGORITHM:
 *	1) Decide where the comment should be aligned, and if lines should
 *	   be broken.
 *	2) If lines should not be broken and filled, just copy up to end of
 *	   comment.
 *	3) If lines should be filled, then scan thru input_buffer copying
 *	   characters to com_buf.  Remember where the last blank, tab, or
 *	   newline was.  When line is filled, print up to last blank and
 *	   continue copying.
 *
 * HISTORY:
 *	November 1976	D A Willcox of CAC	Initial coding
 *	12/6/76		D A Willcox of CAC	Modification to handle
 *						UNIX-style comments
 *
 */

/*
 * this routine processes comments.  It makes an attempt to keep comments from
 * going over the max line length.  If a line is too long, it moves everything
 * from the last blank to the next comment line.  Blanks and tabs from the
 * beginning of the input line are removed
 */

void
pr_comment(void)
{
    int         now_col;	/* column we are in now */
    int         adj_max_col;	/* Adjusted max_col for when we decide to
				 * spill comments over the right margin */
    char       *last_bl;	/* points to the last blank in the output
				 * buffer */
    char       *t_ptr;		/* used for moving string */
    int         unix_comment;	/* tri-state variable used to decide if it is
				 * a unix-style comment. 0 means only blanks
				 * since / *, 1 means regular style comment, 2
				 * means unix style comment */
    int         break_delim = comment_delimiter_on_blankline;
    int         l_just_saw_decl = ps.just_saw_decl;
    /*
     * int         ps.last_nl = 0;	 true iff the last significant thing
     * we've seen is a newline
     */
    int         one_liner = 1;	/* true iff this comment is a one-liner */
    adj_max_col = max_col;
    ps.just_saw_decl = 0;
    last_bl = 0;		/* no blanks found so far */
    ps.box_com = false;		/* at first, assume that we are not in
				 * a boxed comment or some other
				 * comment that should not be touched */
    ++ps.out_coms;		/* keep track of number of comments */
    unix_comment = 1;		/* set flag to let us figure out if there is a
				 * unix-style comment ** DISABLED: use 0 to
				 * reenable this hack! */

    /* Figure where to align and how to treat the comment */

    if (ps.col_1 && !format_col1_comments) {	/* if comment starts in column
						 * 1 it should not be touched */
	ps.box_com = true;
	ps.com_col = 1;
    }
    else {
	if (*buf_ptr == '-' || *buf_ptr == '*' || *buf_ptr == '\n') {
	    ps.box_com = true;	/* a comment with a '-', '*' or newline
				 * immediately after the / * is assumed to be
				 * a boxed comment */
	    break_delim = 0;
	}
	if ( /* ps.bl_line && */ (s_lab == e_lab) && (s_code == e_code)) {
	    /* klg: check only if this line is blank */
	    /*
	     * If this (*and previous lines are*) blank, don't put comment way
	     * out at left
	     */
	    ps.com_col = (ps.ind_level - ps.unindent_displace) * ps.ind_size + 1;
	    adj_max_col = block_comment_max_col;
	    if (ps.com_col <= 1)
		ps.com_col = 1 + !format_col1_comments;
	}
	else {
	    int    target_col;
	    break_delim = 0;
	    if (s_code != e_code)
		target_col = count_spaces(compute_code_target(), s_code);
	    else {
		target_col = 1;
		if (s_lab != e_lab)
		    target_col = count_spaces(compute_label_target(), s_lab);
	    }
	    ps.com_col = ps.decl_on_line || ps.ind_level == 0 ? ps.decl_com_ind : ps.com_ind;
	    if (ps.com_col < target_col)
		ps.com_col = ((target_col + 7) & ~7) + 1;
	    if (ps.com_col + 24 > adj_max_col)
		adj_max_col = ps.com_col + 24;
	}
    }
    if (ps.box_com) {
	buf_ptr[-2] = 0;
	ps.n_comment_delta = 1 - count_spaces(1, in_buffer);
	buf_ptr[-2] = '/';
    }
    else {
	ps.n_comment_delta = 0;
	while (*buf_ptr == ' ' || *buf_ptr == '\t')
	    buf_ptr++;
    }
    ps.comment_delta = 0;
    *e_com++ = '/';		/* put '/ *' into buffer */
    *e_com++ = '*';
    if (*buf_ptr != ' ' && !ps.box_com)
	*e_com++ = ' ';

    *e_com = '\0';
    if (troff) {
	now_col = 1;
	adj_max_col = 80;
    }
    else
	now_col = count_spaces(ps.com_col, s_com);	/* figure what column we
							 * would be in if we
							 * printed the comment
							 * now */

    /* Start to copy the comment */

    while (1) {			/* this loop will go until the comment is
				 * copied */
	if (*buf_ptr > 040 && *buf_ptr != '*')
	    ps.last_nl = 0;
	CHECK_SIZE_COM;
	switch (*buf_ptr) {	/* this checks for various spcl cases */
	case 014:		/* check for a form feed */
	    if (!ps.box_com) {	/* in a text comment, break the line here */
		ps.use_ff = true;
		/* fix so dump_line uses a form feed */
		dump_line();
		last_bl = 0;
		*e_com++ = ' ';
		*e_com++ = '*';
		*e_com++ = ' ';
		while (*++buf_ptr == ' ' || *buf_ptr == '\t');
	    }
	    else {
		if (++buf_ptr >= buf_end)
		    fill_buffer();
		*e_com++ = 014;
	    }
	    break;

	case '\n':
	    if (had_eof) {	/* check for unexpected eof */
		printf("Unterminated comment\n");
		*e_com = '\0';
		dump_line();
		return;
	    }
	    one_liner = 0;
	    if (ps.box_com || ps.last_nl) {	/* if this is a boxed comment,
						 * we don't ignore the newline
						 */
		if (s_com == e_com) {
		    *e_com++ = ' ';
		    *e_com++ = ' ';
		}
		*e_com = '\0';
		if (!ps.box_com && e_com - s_com > 3) {
		    if (break_delim == 1 && s_com[0] == '/'
			    && s_com[1] == '*' && s_com[2] == ' ') {
			char       *t = e_com;
			break_delim = 2;
			e_com = s_com + 2;
			*e_com = 0;
			if (blanklines_before_blockcomments)
			    prefix_blankline_requested = 1;
			dump_line();
			e_com = t;
			s_com[0] = s_com[1] = s_com[2] = ' ';
		    }
		    dump_line();
		    CHECK_SIZE_COM;
		    *e_com++ = ' ';
		    *e_com++ = ' ';
		}
		dump_line();
		now_col = ps.com_col;
	    }
	    else {
		ps.last_nl = 1;
		if (unix_comment != 1) {	/* we not are in unix_style
						 * comment */
		    if (unix_comment == 0 && s_code == e_code) {
			/*
			 * if it is a UNIX-style comment, ignore the
			 * requirement that previous line be blank for
			 * unindention
			 */
			ps.com_col = (ps.ind_level - ps.unindent_displace) * ps.ind_size + 1;
			if (ps.com_col <= 1)
			    ps.com_col = 2;
		    }
		    unix_comment = 2;	/* permanently remember that we are in
					 * this type of comment */
		    dump_line();
		    ++line_no;
		    now_col = ps.com_col;
		    *e_com++ = ' ';
		    /*
		     * fix so that the star at the start of the line will line
		     * up
		     */
		    do		/* flush leading white space */
			if (++buf_ptr >= buf_end)
			    fill_buffer();
		    while (*buf_ptr == ' ' || *buf_ptr == '\t');
		    break;
		}
		if (*(e_com - 1) == ' ' || *(e_com - 1) == '\t')
		    last_bl = e_com - 1;
		/*
		 * if there was a space at the end of the last line, remember
		 * where it was
		 */
		else {		/* otherwise, insert one */
		    last_bl = e_com;
		    CHECK_SIZE_COM;
		    *e_com++ = ' ';
		    ++now_col;
		}
	    }
	    ++line_no;		/* keep track of input line number */
	    if (!ps.box_com) {
		int         nstar = 1;
		do {		/* flush any blanks and/or tabs at start of
				 * next line */
		    if (++buf_ptr >= buf_end)
			fill_buffer();
		    if (*buf_ptr == '*' && --nstar >= 0) {
			if (++buf_ptr >= buf_end)
			    fill_buffer();
			if (*buf_ptr == '/')
			    goto end_of_comment;
		    }
		} while (*buf_ptr == ' ' || *buf_ptr == '\t');
	    }
	    else if (++buf_ptr >= buf_end)
		fill_buffer();
	    break;		/* end of case for newline */

	case '*':		/* must check for possibility of being at end
				 * of comment */
	    if (++buf_ptr >= buf_end)	/* get to next char after * */
		fill_buffer();

	    if (unix_comment == 0)	/* set flag to show we are not in
					 * unix-style comment */
		unix_comment = 1;

	    if (*buf_ptr == '/') {	/* it is the end!!! */
	end_of_comment:
		if (++buf_ptr >= buf_end)
		    fill_buffer();

		if (*(e_com - 1) != ' ' && !ps.box_com) {	/* insure blank before
								 * end */
		    *e_com++ = ' ';
		    ++now_col;
		}
		if (break_delim == 1 && !one_liner && s_com[0] == '/'
			&& s_com[1] == '*' && s_com[2] == ' ') {
		    char       *t = e_com;
		    break_delim = 2;
		    e_com = s_com + 2;
		    *e_com = 0;
		    if (blanklines_before_blockcomments)
			prefix_blankline_requested = 1;
		    dump_line();
		    e_com = t;
		    s_com[0] = s_com[1] = s_com[2] = ' ';
		}
		if (break_delim == 2 && e_com > s_com + 3
			 /* now_col > adj_max_col - 2 && !ps.box_com */ ) {
		    *e_com = '\0';
		    dump_line();
		    now_col = ps.com_col;
		}
		CHECK_SIZE_COM;
		*e_com++ = '*';
		*e_com++ = '/';
		*e_com = '\0';
		ps.just_saw_decl = l_just_saw_decl;
		return;
	    }
	    else {		/* handle isolated '*' */
		*e_com++ = '*';
		++now_col;
	    }
	    break;
	default:		/* we have a random char */
	    if (unix_comment == 0 && *buf_ptr != ' ' && *buf_ptr != '\t')
		unix_comment = 1;	/* we are not in unix-style comment */

	    *e_com = *buf_ptr++;
	    if (buf_ptr >= buf_end)
		fill_buffer();

	    if (*e_com == '\t')	/* keep track of column */
		now_col = ((now_col - 1) & tabmask) + tabsize + 1;
	    else if (*e_com == '\b')	/* this is a backspace */
		--now_col;
	    else
		++now_col;

	    if (*e_com == ' ' || *e_com == '\t')
		last_bl = e_com;
	    /* remember we saw a blank */

	    ++e_com;
	    if (now_col > adj_max_col && !ps.box_com && unix_comment == 1 && e_com[-1] > ' ') {
		/*
		 * the comment is too long, it must be broken up
		 */
		if (break_delim == 1 && s_com[0] == '/'
			&& s_com[1] == '*' && s_com[2] == ' ') {
		    char       *t = e_com;
		    break_delim = 2;
		    e_com = s_com + 2;
		    *e_com = 0;
		    if (blanklines_before_blockcomments)
			prefix_blankline_requested = 1;
		    dump_line();
		    e_com = t;
		    s_com[0] = s_com[1] = s_com[2] = ' ';
		}
		if (last_bl == 0) {	/* we have seen no blanks */
		    last_bl = e_com;	/* fake it */
		    *e_com++ = ' ';
		}
		*e_com = '\0';	/* print what we have */
		*last_bl = '\0';
		while (last_bl > s_com && last_bl[-1] < 040)
		    *--last_bl = 0;
		e_com = last_bl;
		dump_line();

		*e_com++ = ' ';	/* add blanks for continuation */
		*e_com++ = ' ';
		*e_com++ = ' ';

		t_ptr = last_bl + 1;
		last_bl = 0;
		if (t_ptr >= e_com) {
		    while (*t_ptr == ' ' || *t_ptr == '\t')
			t_ptr++;
		    while (*t_ptr != '\0') {	/* move unprinted part of
						 * comment down in buffer */
			if (*t_ptr == ' ' || *t_ptr == '\t')
			    last_bl = e_com;
			*e_com++ = *t_ptr++;
		    }
		}
		*e_com = '\0';
		now_col = count_spaces(ps.com_col, s_com);	/* recompute current
								 * position */
	    }
	    break;
	}
    }
}


Generated by: GCOVR (Version 3.3)

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			}