home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Amiga MA Magazine 1998 #6
/
amigamamagazinepolishissue1998.iso
/
coders
/
indent
/
pr_comment.c
< prev
next >
Wrap
C/C++ Source or Header
|
1999-06-05
|
26KB
|
968 lines
/* Copyright (c) 1992, Free Software Foundation, Inc. All rights reserved.
Copyright (c) 1985 Sun Microsystems, Inc. Copyright (c) 1980 The Regents
of the University of California. Copyright (c) 1976 Board of Trustees of
the University of Illinois. All rights reserved.
Redistribution and use in source and binary forms are permitted
provided that
the above copyright notice and this paragraph are duplicated in all such
forms and that any documentation, advertising materials, and other
materials related to such distribution and use acknowledge that the
software was developed by the University of California, Berkeley, the
University of Illinois, Urbana, and Sun Microsystems, Inc. The name of
either University or Sun Microsystems may not be used to endorse or
promote products derived from this software without specific prior written
permission. THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES
OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. */
#define CHECK_COM_SIZE \
if (e_com >= l_com) { \
register nsize = l_com-s_com+400; \
combuf = (char *) xrealloc (combuf, nsize); \
e_com = combuf + (e_com-s_com) + 1; \
l_com = combuf + nsize - 5; \
s_com = combuf + 1; \
}
/* 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
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 */
#include "sys.h"
#include "indent.h"
int debug_comments;
/* Declared and documented in indent.h. */
int out_coms;
#ifndef NEW_COMMENTS
print_comment ()
{
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 one_liner = 1; /* true iff this comment is a one-liner */
adj_max_col = max_col;
parser_state_tos->just_saw_decl = 0;
last_bl = 0;
parser_state_tos->box_com = false;
++out_coms;
unix_comment = 1;
if (parser_state_tos->col_1 && !format_col1_comments)
{
parser_state_tos->box_com = true;
parser_state_tos->com_col = 1;
}
else
{
/* Don't format the comment if it is a "boxed" comment. */
if (*buf_ptr == '-' || *buf_ptr == '*' || !format_comments)
{
parser_state_tos->box_com = true;
break_delim = 0;
}
if ((s_lab == e_lab) && (s_code == e_code))
{
/* klg: check only if this line is blank */
/* If this (*and previous lines are*) blank, dont put comment way
out at left */
parser_state_tos->com_col
= (parser_state_tos->ind_level - unindent_displace) + 1;
adj_max_col = block_comment_max_col;
if (parser_state_tos->com_col <= 1)
parser_state_tos->com_col = 1 + !format_col1_comments;
/* If we have a comment in an old-style (pre-ANSI) parameter
declaration, indent it like we would the parameter declaration.
For example:
int destroy (what) / * N things to destroy. * / int what;
*/
if (parser_state_tos->in_parameter_declaration
&& indent_parameters != 0
&& parser_state_tos->dec_nest == 0)
{
parser_state_tos->com_col = indent_parameters + 1;
parser_state_tos->ind_stmt = 0;
}
}
else
{
register 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);
}
parser_state_tos->com_col = parser_state_tos->decl_on_line
|| parser_state_tos->ind_level == 0 ? decl_com_ind : com_ind;
/* If we are already past the position for the comment, put it at
the next tab stop. */
if (parser_state_tos->com_col < target_col)
parser_state_tos->com_col = ((target_col + (tabsize - 1))
& ~(tabsize - 1)) + 1;
if (else_or_endif)
{
parser_state_tos->com_col = else_endif_col;
else_or_endif = false;
/* We want the comment to appear one space after the #else or
#endif. */
if (parser_state_tos->com_col < target_col)
parser_state_tos->com_col = target_col + 1;
}
if (parser_state_tos->com_col + 24 > adj_max_col)
adj_max_col = parser_state_tos->com_col + 24;
}
}
if (parser_state_tos->box_com)
{
parser_state_tos->n_comment_delta = 1 - parser_state_tos->com_col;
#if 0
buf_ptr[-2] = 0;
parser_state_tos->n_comment_delta = 1 - count_spaces (1, cur_line);
buf_ptr[-2] = '/';
#endif
}
else
{
parser_state_tos->n_comment_delta = 0;
while (*buf_ptr == ' ' || *buf_ptr == TAB)
buf_ptr++;
}
parser_state_tos->comment_delta = 0;
*e_com++ = '/'; /* put '/*' into buffer */
*e_com++ = '*';
if (*buf_ptr != ' ' && !parser_state_tos->box_com)
*e_com++ = ' ';
*e_com = '\0';
if (troff)
{
now_col = 1;
adj_max_col = 80;
}
else
/* figure what column we would be in if we printed the comment now */
now_col = count_spaces (parser_state_tos->com_col, s_com);
/* Start to copy the comment */
while (1)
{ /* this loop will go until the comment is
copied */
if (*buf_ptr > 040 && *buf_ptr != '*')
parser_state_tos->last_nl = 0;
CHECK_COM_SIZE;
switch (*buf_ptr)
{ /* this checks for various spcl cases */
case 014: /* check for a form feed */
if (!parser_state_tos->box_com)
{ /* in a text comment, break the line here */
parser_state_tos->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 == TAB);
}
else
{
if (++buf_ptr >= buf_end)
fill_buffer ();
*e_com++ = 014;
}
break;
case EOL:
if (had_eof)
{ /* check for unexpected eof */
printf ("Unterminated comment\n");
*e_com = '\0';
dump_line ();
return;
}
one_liner = 0;
if (parser_state_tos->box_com || parser_state_tos->last_nl)
{ /* if this is a boxed comment, we dont ignore
the newline */
if (s_com == e_com)
{
*e_com++ = ' ';
*e_com++ = ' ';
}
*e_com = '\0';
if (!parser_state_tos->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_COM_SIZE;
*e_com++ = ' ';
*e_com++ = ' ';
}
dump_line ();
now_col = parser_state_tos->com_col;
}
else
{
parser_state_tos->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 */
parser_state_tos->com_col
= ((parser_state_tos->ind_level - unindent_displace)
+ ind_size);
if (parser_state_tos->com_col <= 1)
parser_state_tos->com_col = 2;
}
unix_comment = 2; /* permanently remember that we are
in this type of comment */
dump_line ();
++line_no;
now_col = parser_state_tos->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 == TAB);
break;
}
if (*(e_com - 1) == ' ' || *(e_com - 1) == TAB)
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_COM_SIZE;
*e_com++ = ' ';
++now_col;
}
}
++line_no; /* keep track of input line number */
/* Disregard any leading whitespace. */
if (!parser_state_tos->box_com)
{
int nstar = 1;
do
{
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 == TAB);
}
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) != ' ' && !parser_state_tos->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 && !parser_state_tos->box_com */ )
{
*e_com = '\0';
dump_line ();
now_col = parser_state_tos->com_col;
}
CHECK_COM_SIZE;
*e_com++ = '*';
*e_com++ = '/';
*e_com = '\0';
return;
}
else
{ /* handle isolated '*' */
*e_com++ = '*';
++now_col;
}
break;
default: /* we have a random char */
if (unix_comment == 0 && *buf_ptr != ' ' && *buf_ptr != TAB)
unix_comment = 1; /* we are not in unix-style comment */
*e_com = *buf_ptr++;
if (buf_ptr >= buf_end)
fill_buffer ();
if (*e_com == TAB) /* keep track of column */
now_col = now_col + tabsize - (now_col - 1) % tabsize;
else if (*e_com == '\b') /* this is a backspace */
--now_col;
else
++now_col;
if (*e_com == ' ' || *e_com == TAB)
last_bl = e_com;
/* remember we saw a blank */
++e_com;
if (now_col > adj_max_col
&& !parser_state_tos->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 == TAB)
t_ptr++;
while (*t_ptr != '\0')
{ /* move unprinted part of comment down in
buffer */
if (*t_ptr == ' ' || *t_ptr == TAB)
last_bl = e_com;
*e_com++ = *t_ptr++;
}
}
*e_com = '\0';
/* recompute current position */
now_col = count_spaces (parser_state_tos->com_col, s_com);
}
break;
}
}
}
#else /* New Comment code -- UNDER CONSTRUCTION */
/* Output a comment. `buf_ptr' is pointing to the character after
the beginning comment delimiter when this is called. This handles
both C and C++ comments.
As far as indent is concerned, there are basically two types
of comments -- those on lines by themselves and those which are
on lines with other code. Variables (and the options specifying them)
affecting the printing of comments are:
`format_comments' ("fca"): Ignore newlines in the
comment and perform filling up to `max_col'. Double newlines
indicate paragraph breaks.
`format_col1_comments' ("fc1"): Format comments which
begin in column 1.
`unindent_displace' ("d"): The hanging indentation for
comments which do not appear to the right of code.
`comment_delimiter_on_blankline' ("cdb"): If set, place the comment
delimiters on lines by themselves. This only affects comments
which are not to the right of code.
`com_ind' ("c"): The column in which to begin
comments that are to the right of code.
`decl_com_ind' ("cd"): The column in which to begin
comments that are to the right of declarations.
`else_endif_col' ("cp"): The column in which to begin
comments to the right of preprocessor directives.
`star_comment_cont' ("sc"): Place a star ('*') to the
left of the comment body.
`max_col' ("l"): The length of a line. Formatted
comments which extend past this column will be continued on the
following line.
`block_comment_max_col' ("lc"): Unused.
`blanklines_before_blockcomments'("nbbb"): Unused.
*/
void
print_comment ()
{
register int tab_increment;
register int column, format;
enum codes comment_type;
int start_column, save_length, found_column;
int first_comment_line, right_margin;
int boxed_comment, stars, blankline_delims, paragraph_break,
merge_blank_comment_lines;
char *line_break_ptr = 0;
char *save_ptr = 0;
char *text_on_line = 0;
char *start_delim, *end_delim;
char *line_preamble;
int line_preamble_length;
/* Increment the parser stack, as we will store some things
there for dump_line to use. */
inc_pstack ();
/* Have to do it this way because this piece of shit program doesn't
always place the last token code on the stack. */
if (*(token + 1) == '/')
comment_type = cplus_comment;
else
comment_type = comment;
/* First, decide what kind of comment this is: C++, C, or boxed C.
Even if this appears to be a normal C comment, we may change our
minds if we find a star in the right column of the second line,
in which case that's a boxed comment too. */
if (comment_type == cplus_comment)
{
start_delim = "//";
line_preamble = "// ";
line_preamble_length = 3;
boxed_comment = 0;
stars = 0;
blankline_delims = 0;
}
else if (*buf_ptr == '*' || *buf_ptr == '-')
{
start_delim = "/*";
end_delim = "*/";
line_preamble = " ";
line_preamble_length = 1;
boxed_comment = 1;
stars = 0;
blankline_delims = 0;
}
else
{
start_delim = "/*";
end_delim = "*/";
line_preamble = 0;
line_preamble_length = 0;
boxed_comment = 0;
stars = star_comment_cont;
blankline_delims = comment_delimiter_on_blankline;
}
paragraph_break = 0;
merge_blank_comment_lines = 0;
first_comment_line = com_lines;
right_margin = max_col;
/* Now, compute the correct indentation for this comment
and whether or not it should be formatted. */
found_column = current_column () - 2;
if (boxed_comment)
{
start_column = found_column;
format = 0;
blankline_delims = 0;
}
else
{
/* First handle comments which begin the line. */
if ((s_lab == e_lab) && (s_code == e_code))
{
/* This is a top-level comment, not within some code. */
if (parser_state_tos->ind_level <= 0)
{
if (parser_state_tos->col_1)
{
format = format_col1_comments;
start_column = 1;
}
else
{
format = format_comments;
start_column = found_column;
}
}
/* Here for comments starting a line, in the middle of code. */
else
{
if (parser_state_tos->col_1)
{
format = format_col1_comments;
start_column = 1;
}
else
{
format = format_comments;
start_column = (parser_state_tos->ind_level
- unindent_displace + 1);
if (start_column < 0)
start_column = 1;
}
}
}
else
/* This comment follows code of some sort. */
{
int target;
/* First, computer where the comment SHOULD go. */
if (parser_state_tos->decl_on_line)
target = decl_com_ind;
else if (else_or_endif)
target = else_endif_col;
else
target = com_ind;
/* Now determine if the code on the line is short enough
to allow the comment to begin where it should. */
if (s_code != e_code)
start_column = count_spaces (compute_code_target (), s_code);
else
/* s_lab != e_lab : there is a label here. */
start_column = count_spaces (compute_label_target (), s_lab);
if (start_column < target)
start_column = target;
else
{
/* If the too-long code is a pre-processor command,
start the comment 1 space afterwards, otherwise
start at the next tab mark. */
if (else_or_endif)
{
start_column++;
else_or_endif = false;
}
else
start_column += (tabsize - (start_column % tabsize) + 1);
}
format = format_comments;
}
}
if (! line_preamble)
{
line_preamble_length = 3;
if (stars)
line_preamble = " * ";
else
line_preamble = " ";
}
/* These are the parser stack variables used to communicate
formatting information to dump_line (). */
parser_state_tos->com_col = start_column;
parser_state_tos->box_com = boxed_comment;
parser_state_tos->comment_delta = 0;
parser_state_tos->n_comment_delta = 0;
if (boxed_comment)
{
stars = 0;
blankline_delims = 0;
}
/* Output the beginning comment delimiter. They are both two
characters long. */
memcpy (e_com, start_delim, 2);
e_com += 2;
column = start_column + 2;
/* If the user specified -cdb, put the delimiter on one line. */
if (blankline_delims)
{
char *p = buf_ptr;
*e_com = '\0';
dump_line ();
/* Check if the delimiter was already on a line by itself,
and skip whitespace if formating. */
while ((*p == ' ' || *p == TAB) && p < buf_end)
p++;
if (*p == EOL)
buf_ptr = p + 1;
else if (format)
buf_ptr = p;
if (buf_ptr >= buf_end)
fill_buffer ();
column = start_column;
goto begin_line;
}
else if (format)
{
*e_com++ = ' ';
column = start_column + 3;
while (*buf_ptr == ' ' || *buf_ptr == TAB)
if (++buf_ptr >= buf_end)
fill_buffer ();
}
/* Iterate through the lines of the comment */
while (1)
{
/* Iterate through the characters on one line */
while (1)
{
CHECK_COM_SIZE;
switch (*buf_ptr)
{
case ' ':
case TAB:
/* If formatting, and previous break marker is
nonexistant, or before text on line, reset
it to here. */
if (format && line_break_ptr < text_on_line)
line_break_ptr = e_com;
if (*buf_ptr == ' ')
{
*e_com++ = ' ';
column++;
}
else
{
/* Convert the tab to the appropriate number of spaces,
based on the column we found the comment in, not
the one we're printing in. */
int tab_width
= (tabsize - ((column + found_column - start_column - 1)
% tabsize));
column += tab_width;
while (tab_width--)
*e_com++ = ' ';
}
break;
case EOL:
/* We may be at the end of a C++ comment */
if (comment_type == cplus_comment)
{
dump_line ();
buf_ptr++;
if (buf_ptr == buf_end)
fill_buffer ();
parser_state_tos->tos--;
parser_state_tos->com_col = start_column;
return;
}
if (format)
{
/* Newline and null are the two characters which
end a line, so check here if we need to
advance to the next line. */
if (++buf_ptr == buf_end)
fill_buffer ();
if (*buf_ptr == EOL)
{
paragraph_break = 1;
postfix_blankline_requested = 1;
goto end_line;
}
/* This is a single newline. Transform it, and any
following whitespace into a single blank. */
line_break_ptr = e_com;
*e_com++ = ' ';
column++;
while (*buf_ptr == TAB || *buf_ptr == ' ')
if (++buf_ptr == buf_end)
fill_buffer ();
continue;
}
else
/* We are printing this line "as is", so output it
and continue on to the next line. */
goto end_line;
break;
case '*':
/* Check if we've reached the end of the comment. */
if (comment_type == comment)
{
if (*(buf_ptr + 1) == '/')
{
/* If it's a boxed comment, skip this and simply
insert the delimiter on the line. Otherwise, put
some whitespace before the delimiter. */
if (! boxed_comment)
{
if (text_on_line)
{
if (blankline_delims)
{
*e_com = '\0';
dump_line ();
*e_com++ = ' ';
}
else
if (*(e_com - 1) != ' ')
*e_com++ = ' ';
}
else
e_com = s_com + 1;
}
*e_com++ = '*';
*e_com++ = '/';
*e_com = '\0';
/* Skip any whitespace following the comment. If
there is only whitespace after it, print the line. */
buf_ptr += 2;
while (*buf_ptr == ' ' || *buf_ptr == TAB)
buf_ptr++;
if (buf_ptr >= buf_end)
fill_buffer ();
parser_state_tos->tos--;
parser_state_tos->com_col = start_column;
return;
}
/* If this star is on the second line of the
comment in the same column as the star of the
beginning delimiter, then consider it
a boxed comment. */
if (first_comment_line == com_lines - 1
&& e_com == s_com + line_preamble_length
&& current_column () == start_column + 1)
{
line_preamble = " ";
line_preamble_length = 1;
boxed_comment = 1;
format = 0;
blankline_delims = 0;
*s_com = ' ';
*(s_com + 1) = '*';
e_com = s_com + 2;
column++;
break;
}
}
/* If it was not the end of the comment, drop through
and insert the star on the line. */
default:
/* Some textual character. */
text_on_line = e_com;
*e_com++ = *buf_ptr;
column++;
break;
}
/* If we are formatting, check that we haven't exceeded the
line length. If we haven't set line_break_ptr, keep going. */
if (format && column >= right_margin && line_break_ptr)
{
if (line_break_ptr < e_com - 1)
{
*line_break_ptr = '\0';
save_ptr = line_break_ptr + 1;
save_length = e_com - save_ptr;
e_com = line_break_ptr;
/* If we had to go past `right_margin' to print stuff out,
extend `right_margin' out to this point. */
if ((column - save_length) > right_margin)
right_margin = column - save_length;
}
else
*e_com = '\0';
goto end_line;
}
buf_ptr++;
}
end_line:
buf_ptr++;
if (buf_ptr >= buf_end)
fill_buffer ();
*e_com = '\0';
dump_line ();
/* If formatting (paragraph_break is only used for formatted
comments) and user wants blank lines merged, kill all white
space after the "\n\n" indicating a paragraph break. */
if (paragraph_break)
{
if (merge_blank_comment_lines)
while (*buf_ptr == EOL || *buf_ptr == ' ' || *buf_ptr == TAB)
if (++buf_ptr >= buf_end)
fill_buffer ();
paragraph_break = 0;
}
begin_line:
/* Indent the line properly. If it's a boxed comment, align with
the '*' in the beginning slash-star and start inserting there.
Otherwise, insert blanks for alignment, or a star if the
user specified -sc. */
if (line_preamble)
{
memcpy (e_com, line_preamble, line_preamble_length);
e_com += line_preamble_length;
column = start_column + line_preamble_length;
}
else
column = start_column;
line_break_ptr = 0;
/* If we have broken the line before the end for formatting,
copy the text after the break onto the beginning of this
new comment line. */
if (save_ptr)
{
while ((*save_ptr == ' ' || *save_ptr == TAB) && save_length)
{
save_ptr++;
save_length--;
}
memcpy (e_com, save_ptr, save_length);
text_on_line = e_com;
e_com += save_length;
/* We only break if formatting, in which cases there
are no tabs, only spaces.*/
column += save_length;
save_ptr = 0;
}
else
{
while (*buf_ptr == ' ' || *buf_ptr == TAB)
if (++buf_ptr >= buf_end)
fill_buffer ();
text_on_line = 0;
}
}
}
#endif /* New comment code */