/usr/src/usr.bin/indent/indent.c

Bug Summary

File:	src/usr.bin/indent/indent.c
Warning:	line 1058, column 12 Branch condition evaluates to a garbage value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name indent.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/usr.bin/indent/obj -resource-dir /usr/local/llvm16/lib/clang/16 -internal-isystem /usr/local/llvm16/lib/clang/16/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/usr.bin/indent/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fno-jump-tables -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/scan/2024-01-11-140451-98009-1 -x c /usr/src/usr.bin/indent/indent.c
1/*	$OpenBSD: indent.c,v 1.33 2022/12/26 19:16:01 jmc Exp $	*/

3/*
* 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.
*/

35#include <fcntl.h>
36#include <unistd.h>
37#include <limits.h>
38#include <stdio.h>
39#include <stdlib.h>
40#include <string.h>
41#include "indent_globs.h"
42#include "indent_codes.h"
43#include <ctype.h>
44#include <errno(*__errno()).h>
45#include <err.h>

47char       *in_name = "Standard Input";	/* will always point to name of input
			 * file */
49char       *out_name = "Standard Output";	/* will always point to name
				 * of output file */
51char        bakfile[PATH_MAX1024] = "";

53FILE       *input;              /* the fid for the input file */
54FILE       *output;             /* the output file */

56char       *labbuf;             /* buffer for label */
57char       *s_lab;              /* start ... */
58char       *e_lab;              /* .. and end of stored label */
59char       *l_lab;              /* limit of label buffer */

61char       *codebuf;            /* buffer for code section */
62char       *s_code;             /* start ... */
63char       *e_code;             /* .. and end of stored code */
64char       *l_code;             /* limit of code section */

66char       *combuf;             /* buffer for comments */
67char       *s_com;              /* start ... */
68char       *e_com;              /* ... and end of stored comments */
69char       *l_com;              /* limit of comment buffer */

71char       *tokenbuf;           /* the last token scanned */
72char       *s_token;
73char       *e_token;
74char       *l_token;

76char       *in_buffer;          /* input buffer */
77char       *in_buffer_limit;    /* the end of the input buffer */
78char       *buf_ptr;            /* ptr to next character to be taken from
                               * in_buffer */
80char       *buf_end;            /* ptr to first after last char in in_buffer */

82char        save_com[sc_size5000];  /* input text is saved here when looking for
                               * the brace after an if, while, etc */
84char       *sc_end;             /* pointer into save_com buffer */

86char       *bp_save;            /* saved value of buf_ptr when taking input
                               * from save_com */
88char       *be_save;            /* similarly saved value of buf_end */

90int         pointer_as_binop;
91int         blanklines_after_declarations;
92int         blanklines_before_blockcomments;
93int         blanklines_after_procs;
94int         blanklines_around_conditional_compilation;
95int         swallow_optional_blanklines;
96int         n_real_blanklines;
97int         prefix_blankline_requested;
98int         postfix_blankline_requested;
99int         break_comma;        /* when true and not in parens, break after a
                               * comma */
101int         btype_2;            /* when true, brace should be on same line as
                               * if, while, etc */
103float       case_ind;           /* indentation level to be used for a "case
                               * n:" */
105int         code_lines;         /* count of lines with code */
106int         had_eof;            /* set to true when input is exhausted */
107int         line_no;            /* the current line number. */
108int         max_col;            /* the maximum allowable line length */
109int         verbose;            /* when true, non-essential error messages are
                               * printed */
111int         cuddle_else;        /* true if else should cuddle up to '}' */
112int         star_comment_cont;  /* true iff comment continuation lines should
                               * have stars at the beginning of each line. */
114int         comment_delimiter_on_blankline;
115int         troff;              /* true iff were generating troff input */
116int         procnames_start_line;       /* if true, the names of procedures
                                       * being defined get placed in column
                                       * 1 (ie. a newline is placed between
                                       * the type of the procedure and its
                                       * name) */
121int         proc_calls_space;   /* If true, procedure calls look like:
                               * foo(bar) rather than foo (bar) */
123int         format_col1_comments;       /* If comments which start in column 1
                                       * are to be magically reformatted
                                       * (just like comments that begin in
                                       * later columns) */
127int         inhibit_formatting; /* true if INDENT OFF is in effect */
128int         suppress_blanklines;/* set iff following blanklines should be
                               * suppressed */
130int         continuation_indent;/* set to the indentation between the edge of
                               * code and continuation lines */
132int         lineup_to_parens;   /* if true, continued code within parens will
                               * be lined up to the open paren */
134int         Bill_Shannon;       /* true iff a blank should always be inserted
                               * after sizeof */
136int         blanklines_after_declarations_at_proctop;   /* This is vaguely
                                                       * similar to
                                                       * blanklines_after_decla
                                                       * rations except that
                                                       * it only applies to
                                                       * the first set of
                                                       * declarations in a
                                                       * procedure (just after
                                                       * the first '{') and it
                                                       * causes a blank line
                                                       * to be generated even
                                                       * if there are no
                                                       * declarations */
149int         block_comment_max_col;
150int         extra_expression_indent;    /* True if continuation lines from the
                                       * expression part of "if(e)",
                                       * "while(e)", "for(e;e;e)" should be
                                       * indented an extra tab stop so that
                                       * they don't conflict with the code
                                       * that follows */
156int         use_tabs;                   /* set true to use tabs for spacing,
                                       * false uses all spaces */

159/* -troff font state information */

161struct fstate
          keywordf,           /* keyword font */
          stringf,            /* string font */
          boxcomf,            /* Box comment font */
          blkcomf,            /* Block comment font */
          scomf,              /* Same line comment font */
          bodyf;              /* major body font */

169struct parser_state ps;

171int ifdef_level;
172int rparen_count;
173struct parser_state state_stack[5];
174struct parser_state match_state[5];


177void bakcopy(void);

179int
180main(int argc, char **argv)
181{

  extern int  found_err;	/* flag set in diag() on error */
  int         dec_ind;	/* current indentation for declarations */
  int         di_stack[20];	/* a stack of structure indentation levels */
  int         flushed_nl;	/* used when buffering up comments to remember
		 * that a newline was passed over */
  int         force_nl;	/* when true, code must be broken */
  int         hd_type;	/* used to store type of stmt for if (...),
		 * for (...), etc */
  int 	i;		/* local loop counter */
  int         scase;		/* set to true when we see a case, so we will
		 * know what to do with the following colon */
  int         sp_sw;		/* when true, we are in the expressin of
		 * if(...), while(...), etc. */
  int         squest;		/* when this is positive, we have seen a ?
		 * without the matching : in a <c>?<s>:<s>
		 * construct */
  char 	*t_ptr;		/* used for copying tokens */
  int         tabs_to_var;	/* true if using tabs to indent to var name */
1
'tabs_to_var' declared without an initial value→
  int         type_code;	/* the type of token, returned by lexi */

  int         last_else = 0;	/* true iff last keyword was an else */

  if (pledge("stdio rpath wpath cpath", NULL((void *)0)) == -1)
2
←
Assuming the condition is false→
3
←
Taking false branch→
err(1, "pledge");

  /*-----------------------------------------------*\
  |		      INITIALIZATION		      |
  \*-----------------------------------------------*/


  hd_type = 0;
  ps.p_stack[0] = stmt25;	/* this is the parser's stack */
  ps.last_nl = true1;		/* this is true if the last thing scanned was
		 * a newline */
  ps.last_token = semicolon10;
  combuf = malloc(bufsize200);
  labbuf = malloc(bufsize200);
  codebuf = malloc(bufsize200);
  tokenbuf = malloc(bufsize200);
  if (combuf == NULL((void *)0) || labbuf == NULL((void *)0) || codebuf == NULL((void *)0) ||
4
←
Assuming 'combuf' is not equal to NULL→
5
←
Assuming 'labbuf' is not equal to NULL→
6
←
Assuming 'codebuf' is not equal to NULL→
8
←
Taking false branch→
      tokenbuf == NULL((void *)0))
7
←
Assuming 'tokenbuf' is not equal to NULL→
   err(1, NULL((void *)0));
  l_com = combuf + bufsize200 - 5;
  l_lab = labbuf + bufsize200 - 5;
  l_code = codebuf + bufsize200 - 5;
  l_token = tokenbuf + bufsize200 - 5;
  combuf[0] = codebuf[0] = labbuf[0] = ' ';	/* set up code, label, and
				 * comment buffers */
  combuf[1] = codebuf[1] = labbuf[1] = '\0';
  ps.else_if = 1;		/* Default else-if special processing to on */
  s_lab = e_lab = labbuf + 1;
  s_code = e_code = codebuf + 1;
  s_com = e_com = combuf + 1;
  s_token = e_token = tokenbuf + 1;

  in_buffer = malloc(10);
  if (in_buffer == NULL((void *)0))
9
←
Assuming 'in_buffer' is not equal to NULL→
10
←
Taking false branch→
   err(1, NULL((void *)0));
  in_buffer_limit = in_buffer + 8;
  buf_ptr = buf_end = in_buffer;
  line_no = 1;
  had_eof = ps.in_decl = ps.decl_on_line = break_comma = false0;
  sp_sw = force_nl = false0;
  ps.in_or_st = false0;
  ps.bl_line = true1;
  dec_ind = 0;
  di_stack[ps.dec_nest = 0] = 0;
  ps.want_blank = ps.in_stmt = ps.ind_stmt = false0;


  scase = ps.pcase = false0;
  squest = 0;
  sc_end = 0;
  bp_save = 0;
  be_save = 0;

  output = 0;



  /*--------------------------------------------------*\
  |   		COMMAND LINE SCAN		 |
  \*--------------------------------------------------*/

267#ifdef undef
  max_col = 78;		/* -l78 */
  lineup_to_parens = 1;	/* -lp */
  ps.ljust_decl = 0;		/* -ndj */
  ps.com_ind = 33;		/* -c33 */
  star_comment_cont = 1;	/* -sc */
  ps.ind_size = 8;		/* -i8 */
  verbose = 0;
  ps.decl_indent = 16;	/* -di16 */
  ps.indent_parameters = 1;	/* -ip */
  ps.decl_com_ind = 0;	/* if this is not set to some positive value
		 * by an arg, we will set this equal to
		 * ps.com_ind */
  btype_2 = 1;		/* -br */
  cuddle_else = 1;		/* -ce */
  ps.unindent_displace = 0;	/* -d0 */
  ps.case_indent = 0;		/* -cli0 */
  format_col1_comments = 1;	/* -fc1 */
  procnames_start_line = 1;	/* -psl */
  proc_calls_space = 0;	/* -npcs */
  comment_delimiter_on_blankline = 1;	/* -cdb */
  ps.leave_comma = 1;		/* -nbc */
289#endif

  for (i = 1; i < argc; ++i)
11
←
Assuming 'i' is >= 'argc'→
12
←
Loop condition is false. Execution continues on line 294→
if (strcmp(argv[i], "-npro") == 0)
   break;
  set_defaults();
  if (i12.1
'i' is >= 'argc'
 >= argc)
13
←
Taking true branch→
set_profile();

  for (i = 1; i < argc; ++i) {
14
←
Loop condition is false. Execution continues on line 326→

/*
* look thru args (if any) for changes to defaults
*/
if (argv[i][0] != '-') {/* no flag on parameter */
   if (input == 0) {	/* we must have the input file */
in_name = argv[i];	/* remember name of input file */
input = fopen(in_name, "r");
if (input == NULL((void *)0))		/* check for open error */
	err(1, "%s", in_name);
continue;
   }
   else if (output == 0) {	/* we have the output file */
out_name = argv[i];	/* remember name of output file */
if (strcmp(in_name, out_name) == 0)	/* attempt to overwrite
					 * the file */
	errx(1, "input and output files must be different");
output = fopen(out_name, "w");
if (output == NULL((void *)0))	/* check for create error */
	err(1, "%s", out_name);
continue;
   }
   errx(1, "unknown parameter: %s", argv[i]);
}
else
   set_option(argv[i]);
  }				/* end of for */
  if (input == NULL((void *)0)) {
15
←
Assuming 'input' is not equal to NULL→
16
←
Taking false branch→
input = stdin(&__sF[0]);
  }
  if (output == NULL((void *)0)) {
17
←
Assuming 'output' is not equal to NULL→
18
←
Taking false branch→
if (troff || input == stdin(&__sF[0]))
   output = stdout(&__sF[1]);
else {
   out_name = in_name;
   bakcopy();
}
  }
  if (ps.com_ind <= 1)
19
←
Assuming field 'com_ind' is > 1→
20
←
Taking false branch→
ps.com_ind = 2;		/* dont put normal comments before column 2 */
  if (troff) {
21
←
Assuming 'troff' is 0→
22
←
Taking false branch→
if (bodyf.font[0] == 0)
   parsefont(&bodyf, "R");
if (scomf.font[0] == 0)
   parsefont(&scomf, "I");
if (blkcomf.font[0] == 0)
   blkcomf = scomf, blkcomf.size += 2;
if (boxcomf.font[0] == 0)
   boxcomf = blkcomf;
if (stringf.font[0] == 0)
   parsefont(&stringf, "L");
if (keywordf.font[0] == 0)
   parsefont(&keywordf, "B");
writefdef(&bodyf, 'B');
writefdef(&scomf, 'C');
writefdef(&blkcomf, 'L');
writefdef(&boxcomf, 'X');
writefdef(&stringf, 'S');
writefdef(&keywordf, 'K');
  }
  if (block_comment_max_col <= 0)
23
←
Assuming 'block_comment_max_col' is > 0→
24
←
Taking false branch→
block_comment_max_col = max_col;
  if (ps.decl_com_ind <= 0)	/* if not specified by user, set this */
25
←
Assuming field 'decl_com_ind' is > 0→
26
←
Taking false branch→
ps.decl_com_ind = ps.ljust_decl ? (ps.com_ind <= 10 ? 2 : ps.com_ind - 8) : ps.com_ind;
  if (continuation_indent == 0)
27
←
Assuming 'continuation_indent' is not equal to 0→
28
←
Taking false branch→
continuation_indent = ps.ind_size;
  fill_buffer();	/* get first batch of stuff into input buffer */

  parse(semicolon10);
  {
char *p = buf_ptr;
int   col = 1;

while (1) {
29
←
Loop condition is true.  Entering loop body→
   if (*p == ' ')
30
←
Assuming the condition is false→
31
←
Taking false branch→
col++;
   else if (*p == '\t')
32
←
Assuming the condition is false→
33
←
Taking false branch→
col = ((col - 1) & ~7) + 9;
   else
break;
   p++;
}
if (col > ps.ind_size)
34
←
 Execution continues on line 381→
35
←
Assuming 'col' is <= field 'ind_size'→
36
←
Taking false branch→
   ps.ind_level = ps.i_l_follow = col / ps.ind_size;
  }
  if (troff) {
37
←
Assuming 'troff' is 0→
38
←
Taking false branch→
char *p = in_name,
          *beg = in_name;

while (*p)
   if (*p++ == '/')
beg = p;
fprintf(output, ".Fn \"%s\"\n", beg);
  }
  /*
   * START OF MAIN LOOP
   */

  while (1) {			/* this is the main loop.  it will go until we
39
←
Loop condition is true.  Entering loop body→
		 * reach eof */
int         is_procname;

type_code = lexi();	/* lexi reads one token.  The actual
		 * characters read are stored in "token". lexi
		 * returns a code indicating the type of token */
is_procname = ps.procname[0];

/*
* The following code moves everything following an if (), while (),
* else, etc. up to the start of the following stmt to a buffer. This
* allows proper handling of both kinds of brace placement.
*/

flushed_nl = false0;
while (ps.search_brace) {	/* if we scanned an if(), while(),
40
←
Loop condition is false. Execution continues on line 530→
			 * etc., we might need to copy stuff
			 * into a buffer we must loop, copying
			 * stuff into save_com, until we find
			 * the start of the stmt which follows
			 * the if, or whatever */
   switch (type_code) {
   case newline1:
++line_no;
flushed_nl = true1;
   case form_feed18:
break;		/* form feeds and newlines found here will be
		 * ignored */

   case lbrace11:	/* this is a brace that starts the compound
		 * stmt */
if (sc_end == 0) {	/* ignore buffering if a comment wasnt
			 * stored up */
    ps.search_brace = false0;
    goto check_type;
}
if (btype_2) {
    save_com[0] = '{';	/* we either want to put the brace
			 * right after the if */
    goto sw_buffer;	/* go to common code to get out of
			 * this loop */
}
   case comment15:	/* we have a comment, so we must copy it into
		 * the buffer */
if (!flushed_nl || sc_end != 0) {
    if (sc_end == 0) {	/* if this is the first comment, we
			 * must set up the buffer */
	save_com[0] = save_com[1] = ' ';
	sc_end = &(save_com[2]);
    }
    else {
	*sc_end++ = '\n';	/* add newline between
				 * comments */
	*sc_end++ = ' ';
	--line_no;
    }
    *sc_end++ = '/';	/* copy in start of comment */
    *sc_end++ = '*';

    for (;;) {	/* loop until we get to the end of the comment */
	*sc_end = *buf_ptr++;
	if (buf_ptr >= buf_end)
	    fill_buffer();

	if (*sc_end++ == '*' && *buf_ptr == '/')
	    break;	/* we are at end of comment */

	if (sc_end >= &(save_com[sc_size5000])) {	/* check for temp buffer
						 * overflow */
	    diag(1, "Internal buffer overflow - Move big comment from right after if, while, or whatever.");
	    fflush(output);
	    exit(1);
	}
    }
    *sc_end++ = '/';	/* add ending slash */
    if (++buf_ptr >= buf_end)	/* get past / in buffer */
	fill_buffer();
    break;
}
   default:		/* it is the start of a normal statement */
if (flushed_nl)	/* if we flushed a newline, make sure it is
		 * put back */
    force_nl = true1;
if ((type_code == sp_paren20 && *tokens_token == 'i'
     && last_else && ps.else_if) ||
    (type_code == sp_nparen21 && *tokens_token == 'e'
     && e_code != s_code && e_code[-1] == '}'))
	force_nl = false0;

if (sc_end == 0) {	/* ignore buffering if comment wasnt
			 * saved up */
    ps.search_brace = false0;
    goto check_type;
}
if (force_nl) {	/* if we should insert a nl here, put it into
		 * the buffer */
    force_nl = false0;
    --line_no;	/* this will be re-increased when the nl is
		 * read from the buffer */
    *sc_end++ = '\n';
    *sc_end++ = ' ';
    if (verbose && !flushed_nl)	/* print error msg if the line
				 * was not already broken */
	diag(0, "Line broken");
    flushed_nl = false0;
}
for (t_ptr = tokens_token; *t_ptr; ++t_ptr)
    *sc_end++ = *t_ptr;	/* copy token into temp buffer */
ps.procname[0] = 0;

sw_buffer:
ps.search_brace = false0;	/* stop looking for start of
				 * stmt */
bp_save = buf_ptr;	/* save current input buffer */
be_save = buf_end;
buf_ptr = save_com;	/* fix so that subsequent calls to
			 * lexi will take tokens out of
			 * save_com */
*sc_end++ = ' ';/* add trailing blank, just in case */
buf_end = sc_end;
sc_end = 0;
break;
   }			/* end of switch */
   if (type_code != 0)	/* we must make this check, just in case there
		 * was an unexpected EOF */
type_code = lexi();	/* read another token */
   /* if (ps.search_brace) ps.procname[0] = 0; */
   if ((is_procname = ps.procname[0]) && flushed_nl
    && !procnames_start_line && ps.in_decl
    && type_code == ident13)
flushed_nl = 0;
}			/* end of while (search_brace) */
last_else = 0;
531check_type:
if (type_code == 0) {	/* we got eof */
41
←
Assuming 'type_code' is not equal to 0→
   if (s_lab != e_lab || s_code != e_code
    || s_com != e_com)	/* must dump end of line */
dump_line();
   if (ps.tos > 1)	/* check for balanced braces */
diag(1, "Missing braces at end of file.");

   if (verbose) {
printf("There were %d output lines and %d comments\n",
       ps.out_lines, ps.out_coms);
printf("(Lines with comments)/(Lines with code): %6.3f\n",
       (1.0 * ps.com_lines) / code_lines);
   }
   fflush(output);
   exit(found_err);
}
if (
(type_code != comment15) &&
42
←
Assuming 'type_code' is not equal to comment→
(type_code != newline1) &&
43
←
Assuming 'type_code' is not equal to newline→
(type_code != preesc17) &&
44
←
Assuming 'type_code' is not equal to preesc→
(type_code != form_feed18)) {
45
←
Assuming 'type_code' is not equal to form_feed→
   if (force_nl45.1
'force_nl' is 0
 &&
    (type_code != semicolon10) &&
    (type_code != lbrace11 || !btype_2)) {
/* we should force a broken line here */
if (verbose && !flushed_nl)
    diag(0, "Line broken");
flushed_nl = false0;
dump_line();
ps.want_blank = false0;	/* dont insert blank at line start */
force_nl = false0;
   }
   ps.in_stmt = true1;	/* turn on flag which causes an extra level of
		 * indentation. this is turned off by a ; or
		 * '}' */
   if (s_com != e_com) {	/* the turkey has embedded a comment
46
←
Assuming 's_com' is equal to 'e_com'→
47
←
Taking false branch→
			 * in a line. fix it */
*e_code++ = ' ';
for (t_ptr = s_com; *t_ptr; ++t_ptr) {
    CHECK_SIZE_CODEif (e_code >= l_code) { int nsize = l_code-s_code+400; codebuf
 = realloc(codebuf, nsize); if (codebuf == ((void *)0)) err(1
, ((void *)0)); e_code = codebuf + (e_code-s_code) + 1; l_code
 = codebuf + nsize - 5; s_code = codebuf + 1; };
    *e_code++ = *t_ptr;
}
*e_code++ = ' ';
*e_code = '\0';	/* null terminate code sect */
ps.want_blank = false0;
e_com = s_com;
   }
}
else if (type_code != comment15)	/* preserve force_nl thru a comment */
   force_nl = false0;	/* cancel forced newline after newline, form
		 * feed, etc */



/*-----------------------------------------------------*\
|	   do switch on type of token scanned		|
\*-----------------------------------------------------*/
CHECK_SIZE_CODEif (e_code >= l_code) { int nsize = l_code-s_code+400; codebuf
 = realloc(codebuf, nsize); if (codebuf == ((void *)0)) err(1
, ((void *)0)); e_code = codebuf + (e_code-s_code) + 1; l_code
 = codebuf + nsize - 5; s_code = codebuf + 1; };
48
←
Assuming 'e_code' is < 'l_code'→
49
←
Taking false branch→
switch (type_code) {	/* now, decide what to do with the token */
50
←
Control jumps to 'case 13:'  at line 1023→

case form_feed18:	/* found a form feed in line */
   ps.use_ff = true1;	/* a form feed is treated much like a newline */
   dump_line();
   ps.want_blank = false0;
   break;

case newline1:
   if (ps.last_token != comma14 || ps.p_l_follow > 0
    || !ps.leave_comma || ps.block_init || !break_comma || s_com != e_com) {
dump_line();
ps.want_blank = false0;
   }
   ++line_no;		/* keep track of input line number */
   break;

case lparen2:		/* got a '(' or '[' */
   ++ps.p_l_follow;	/* count parens to make Healy happy */
   if (ps.want_blank && *tokens_token != '[' &&
    (ps.last_token != ident13 || proc_calls_space
     || (ps.its_a_keyword && (!ps.sizeof_keyword || Bill_Shannon))))
*e_code++ = ' ';
   if (ps.in_decl && !ps.block_init)
if (troff && !ps.dumped_decl_indent && !is_procname && ps.last_token == decl19) {
    ps.dumped_decl_indent = 1;
    snprintf(e_code, (l_code - e_code) + 5, 
	"\n.Du %dp+\200p \"%s\"\n", dec_ind * 7, tokens_token);
    e_code += strlen(e_code);
    CHECK_SIZE_CODEif (e_code >= l_code) { int nsize = l_code-s_code+400; codebuf
 = realloc(codebuf, nsize); if (codebuf == ((void *)0)) err(1
, ((void *)0)); e_code = codebuf + (e_code-s_code) + 1; l_code
 = codebuf + nsize - 5; s_code = codebuf + 1; };
}
else {
    while ((e_code - s_code) < dec_ind) {
	CHECK_SIZE_CODEif (e_code >= l_code) { int nsize = l_code-s_code+400; codebuf
 = realloc(codebuf, nsize); if (codebuf == ((void *)0)) err(1
, ((void *)0)); e_code = codebuf + (e_code-s_code) + 1; l_code
 = codebuf + nsize - 5; s_code = codebuf + 1; };
	*e_code++ = ' ';
    }
    *e_code++ = tokens_token[0];
}
   else
*e_code++ = tokens_token[0];
   ps.paren_indents[ps.p_l_follow - 1] = e_code - s_code;
   if (sp_sw && ps.p_l_follow == 1 && extra_expression_indent
    && ps.paren_indents[0] < 2 * ps.ind_size)
ps.paren_indents[0] = 2 * ps.ind_size;
   ps.want_blank = false0;
   if (ps.in_or_st && *tokens_token == '(' && ps.tos <= 2) {
/*
 * this is a kluge to make sure that declarations will be
 * aligned right if proc decl has an explicit type on it, i.e.
 * "int a(x) {..."
 */
parse(semicolon10);	/* I said this was a kluge... */
ps.in_or_st = false0;	/* turn off flag for structure decl or
			 * initialization */
   }
   if (ps.sizeof_keyword)
ps.sizeof_mask |= 1 << ps.p_l_follow;
   break;

case rparen3:		/* got a ')' or ']' */
   rparen_count--;
   if (ps.cast_mask & (1 << ps.p_l_follow) & ~ps.sizeof_mask) {
ps.last_u_d = true1;
ps.cast_mask &= (1 << ps.p_l_follow) - 1;
   }
   ps.sizeof_mask &= (1 << ps.p_l_follow) - 1;
   if (--ps.p_l_follow < 0) {
ps.p_l_follow = 0;
diag(0, "Extra %c", *tokens_token);
   }
   if (e_code == s_code)	/* if the paren starts the line */
ps.paren_level = ps.p_l_follow;	/* then indent it */

   *e_code++ = tokens_token[0];
   ps.want_blank = true1;

   if (sp_sw && (ps.p_l_follow == 0)) {	/* check for end of if
					 * (...), or some such */
sp_sw = false0;
force_nl = true1;/* must force newline after if */
ps.last_u_d = true1;	/* inform lexi that a following
			 * operator is unary */
ps.in_stmt = false0;	/* dont use stmt continuation
			 * indentation */

parse(hd_type);	/* let parser worry about if, or whatever */
   }
   ps.search_brace = btype_2;	/* this should insure that constructs
			 * such as main(){...} and int[]{...}
			 * have their braces put in the right
			 * place */
   break;

case unary_op4:		/* this could be any unary operation */
   if (ps.want_blank)
*e_code++ = ' ';

   if (troff && !ps.dumped_decl_indent && ps.in_decl && !is_procname) {
snprintf(e_code, (l_code - e_code) + 5,
    "\n.Du %dp+\200p \"%s\"\n", dec_ind * 7, tokens_token);
ps.dumped_decl_indent = 1;
e_code += strlen(e_code);
CHECK_SIZE_CODEif (e_code >= l_code) { int nsize = l_code-s_code+400; codebuf
 = realloc(codebuf, nsize); if (codebuf == ((void *)0)) err(1
, ((void *)0)); e_code = codebuf + (e_code-s_code) + 1; l_code
 = codebuf + nsize - 5; s_code = codebuf + 1; };
   }
   else {
char       *res = tokens_token;

if (ps.in_decl && !ps.block_init) {	/* if this is a unary op
					 * in a declaration, we
					 * should indent this
					 * token */
    for (i = 0; tokens_token[i]; ++i);	/* find length of token */
    while ((e_code - s_code) < (dec_ind - i)) {
	CHECK_SIZE_CODEif (e_code >= l_code) { int nsize = l_code-s_code+400; codebuf
 = realloc(codebuf, nsize); if (codebuf == ((void *)0)) err(1
, ((void *)0)); e_code = codebuf + (e_code-s_code) + 1; l_code
 = codebuf + nsize - 5; s_code = codebuf + 1; };
	*e_code++ = ' ';	/* pad it */
    }
}
if (troff && tokens_token[0] == '-' && tokens_token[1] == '>')
    res = "\\(->";
for (t_ptr = res; *t_ptr; ++t_ptr) {
    CHECK_SIZE_CODEif (e_code >= l_code) { int nsize = l_code-s_code+400; codebuf
 = realloc(codebuf, nsize); if (codebuf == ((void *)0)) err(1
, ((void *)0)); e_code = codebuf + (e_code-s_code) + 1; l_code
 = codebuf + nsize - 5; s_code = codebuf + 1; };
    *e_code++ = *t_ptr;
}
   }
   ps.want_blank = false0;
   break;

case binary_op5:	/* any binary operation */
   if (ps.want_blank)
*e_code++ = ' ';
   {
char       *res = tokens_token;

if (troff)
    switch (tokens_token[0]) {
    case '<':
	if (tokens_token[1] == '=')
	    res = "\\(<=";
	break;
    case '>':
	if (tokens_token[1] == '=')
	    res = "\\(>=";
	break;
    case '!':
	if (tokens_token[1] == '=')
	    res = "\\(!=";
	break;
    case '|':
	if (tokens_token[1] == '|')
	    res = "\\(br\\(br";
	else if (tokens_token[1] == 0)
	    res = "\\(br";
	break;
    }
for (t_ptr = res; *t_ptr; ++t_ptr) {
    CHECK_SIZE_CODEif (e_code >= l_code) { int nsize = l_code-s_code+400; codebuf
 = realloc(codebuf, nsize); if (codebuf == ((void *)0)) err(1
, ((void *)0)); e_code = codebuf + (e_code-s_code) + 1; l_code
 = codebuf + nsize - 5; s_code = codebuf + 1; };
    *e_code++ = *t_ptr;	/* move the operator */
}
   }
   ps.want_blank = true1;
   break;

case postop6:		/* got a trailing ++ or -- */
   *e_code++ = tokens_token[0];
   *e_code++ = tokens_token[1];
   ps.want_blank = true1;
   break;

case question7:		/* got a ? */
   squest++;		/* this will be used when a later colon
		 * appears so we can distinguish the
		 * <c>?<n>:<n> construct */
   if (ps.want_blank)
*e_code++ = ' ';
   *e_code++ = '?';
   ps.want_blank = true1;
   break;

case casestmt8:		/* got word 'case' or 'default' */
   scase = true1;	/* so we can process the later colon properly */
   goto copy_id;

case colon9:		/* got a ':' */
   if (squest > 0) {	/* it is part of the <c>?<n>: <n> construct */
--squest;
if (ps.want_blank)
    *e_code++ = ' ';
*e_code++ = ':';
ps.want_blank = true1;
break;
   }
   if (ps.in_decl) {
*e_code++ = ':';
ps.want_blank = false0;
break;
   }
   ps.in_stmt = false0;	/* seeing a label does not imply we are in a
		 * stmt */
   for (t_ptr = s_code; *t_ptr; ++t_ptr)
*e_lab++ = *t_ptr;	/* turn everything so far into a label */
   e_code = s_code;
   *e_lab++ = ':';
   *e_lab++ = ' ';
   *e_lab = '\0';

   force_nl = ps.pcase = scase;	/* ps.pcase will be used by
				 * dump_line to decide how to
				 * indent the label. force_nl
				 * will force a case n: to be
				 * on a line by itself */
   scase = false0;
   ps.want_blank = false0;
   break;

case semicolon10:	/* got a ';' */
   ps.in_or_st = false0;/* we are not in an initialization or
		 * structure declaration */
   scase = false0;	/* these will only need resetting in a error */
   squest = 0;
   if (ps.last_token == rparen3 && rparen_count == 0)
ps.in_parameter_declaration = 0;
   ps.cast_mask = 0;
   ps.sizeof_mask = 0;
   ps.block_init = 0;
   ps.block_init_level = 0;
   ps.just_saw_decl--;

   if (ps.in_decl && s_code == e_code && !ps.block_init)
while ((e_code - s_code) < (dec_ind - 1)) {
    CHECK_SIZE_CODEif (e_code >= l_code) { int nsize = l_code-s_code+400; codebuf
 = realloc(codebuf, nsize); if (codebuf == ((void *)0)) err(1
, ((void *)0)); e_code = codebuf + (e_code-s_code) + 1; l_code
 = codebuf + nsize - 5; s_code = codebuf + 1; };
    *e_code++ = ' ';
}

   ps.in_decl = (ps.dec_nest > 0);	/* if we were in a first level
				 * structure declaration, we
				 * arent any more */

   if ((!sp_sw || hd_type != forstmt24) && ps.p_l_follow > 0) {

/*
 * This should be true iff there were unbalanced parens in the
 * stmt.  It is a bit complicated, because the semicolon might
 * be in a for stmt
 */
diag(1, "Unbalanced parens");
ps.p_l_follow = 0;
if (sp_sw) {	/* this is a check for a if, while, etc. with
		 * unbalanced parens */
    sp_sw = false0;
    parse(hd_type);	/* dont lose the if, or whatever */
}
   }
   *e_code++ = ';';
   ps.want_blank = true1;
   ps.in_stmt = (ps.p_l_follow > 0);	/* we are no longer in the
				 * middle of a stmt */

   if (!sp_sw) {	/* if not if for (;;) */
parse(semicolon10);	/* let parser know about end of stmt */
force_nl = true1;/* force newline after a end of stmt */
   }
   break;

case lbrace11:		/* got a '{' */
   ps.in_stmt = false0;	/* dont indent the {} */
   if (!ps.block_init)
force_nl = true1;/* force other stuff on same line as '{' onto
		 * new line */
   else if (ps.block_init_level <= 0)
ps.block_init_level = 1;
   else
ps.block_init_level++;

   if (s_code != e_code && !ps.block_init) {
if (!btype_2) {
    dump_line();
    ps.want_blank = false0;
}
else if (ps.in_parameter_declaration && !ps.in_or_st) {
    ps.i_l_follow = 0;
    dump_line();
    ps.want_blank = false0;
}
   }
   if (ps.in_parameter_declaration)
prefix_blankline_requested = 0;

   if (ps.p_l_follow > 0) {	/* check for preceding unbalanced
			 * parens */
diag(1, "Unbalanced parens");
ps.p_l_follow = 0;
if (sp_sw) {	/* check for unclosed if, for, etc. */
    sp_sw = false0;
    parse(hd_type);
    ps.ind_level = ps.i_l_follow;
}
   }
   if (s_code == e_code)
ps.ind_stmt = false0;	/* dont put extra indentation on line
			 * with '{' */
   if (ps.in_decl && ps.in_or_st) {	/* this is either a structure
				 * declaration or an init */
di_stack[ps.dec_nest++] = dec_ind;
/* ?		dec_ind = 0; */
   }
   else {
ps.decl_on_line = false0;
/* we can't be in the middle of a declaration, so don't do
 * special indentation of comments */
if (blanklines_after_declarations_at_proctop
	&& ps.in_parameter_declaration)
    postfix_blankline_requested = 1;
ps.in_parameter_declaration = 0;
   }
   dec_ind = 0;
   parse(lbrace11);	/* let parser know about this */
   if (ps.want_blank)	/* put a blank before '{' if '{' is not at
		 * start of line */
*e_code++ = ' ';
   ps.want_blank = false0;
   *e_code++ = '{';
   ps.just_saw_decl = 0;
   break;

case rbrace12:		/* got a '}' */
   if (ps.p_stack[ps.tos] == decl19 && !ps.block_init)	/* semicolons can be
						 * omitted in
						 * declarations */
parse(semicolon10);
   if (ps.p_l_follow) {/* check for unclosed if, for, else. */
diag(1, "Unbalanced parens");
ps.p_l_follow = 0;
sp_sw = false0;
   }
   ps.just_saw_decl = 0;
   ps.block_init_level--;
   if (s_code != e_code && !ps.block_init) {	/* '}' must be first on
					 * line */
if (verbose)
    diag(0, "Line broken");
dump_line();
   }
   *e_code++ = '}';
   ps.want_blank = true1;
   ps.in_stmt = ps.ind_stmt = false0;
   if (ps.dec_nest > 0) {	/* we are in multi-level structure
			 * declaration */
dec_ind = di_stack[--ps.dec_nest];
if (ps.dec_nest == 0 && !ps.in_parameter_declaration)
    ps.just_saw_decl = 2;
ps.in_decl = true1;
   }
   prefix_blankline_requested = 0;
   parse(rbrace12);	/* let parser know about this */
   ps.search_brace = cuddle_else && ps.p_stack[ps.tos] == ifhead30
&& ps.il[ps.tos] >= ps.ind_level;
   if (ps.tos <= 1 && blanklines_after_procs && ps.dec_nest <= 0)
postfix_blankline_requested = 1;
   break;

case swstmt16:		/* got keyword "switch" */
   sp_sw = true1;
   hd_type = swstmt16;	/* keep this for when we have seen the
		 * expression */
   goto copy_id;	/* go move the token into buffer */

case sp_paren20:		/* token is if, while, for */
   sp_sw = true1;	/* the interesting stuff is done after the
		 * expression is scanned */
   hd_type = (*tokens_token == 'i' ? ifstmt22 :
       (*tokens_token == 'w' ? whilestmt23 : forstmt24));

   /*
    * remember the type of header for later use by parser
    */
   goto copy_id;	/* copy the token into line */

case sp_nparen21:	/* got else, do */
   ps.in_stmt = false0;
   if (*tokens_token == 'e') {
if (e_code != s_code && (!cuddle_else || e_code[-1] != '}')) {
    if (verbose)
	diag(0, "Line broken");
    dump_line();/* make sure this starts a line */
    ps.want_blank = false0;
}
force_nl = true1;/* also, following stuff must go onto new line */
last_else = 1;
parse(elselit27);
   }
   else {
if (e_code != s_code) {	/* make sure this starts a line */
    if (verbose)
	diag(0, "Line broken");
    dump_line();
    ps.want_blank = false0;
}
force_nl = true1;/* also, following stuff must go onto new line */
last_else = 0;
parse(dolit28);
   }
   goto copy_id;	/* move the token into line */

case decl19:		/* we have a declaration type (int, register,
		 * etc.) */
   parse(decl19);	/* let parser worry about indentation */
   if (ps.last_token == rparen3 && ps.tos <= 1) {
ps.in_parameter_declaration = 1;
if (s_code != e_code) {
    dump_line();
    ps.want_blank = 0;
}
   }
   if (ps.in_parameter_declaration && ps.indent_parameters && ps.dec_nest == 0) {
ps.ind_level = ps.i_l_follow = 1;
ps.ind_stmt = 0;
   }
   ps.in_or_st = true1;	/* this might be a structure or initialization
		 * declaration */
   ps.in_decl = ps.decl_on_line = true1;
   if ( /* !ps.in_or_st && */ ps.dec_nest <= 0)
ps.just_saw_decl = 2;
   prefix_blankline_requested = 0;
   for (i = 0; tokens_token[i++];);	/* get length of token */

   /*
    * dec_ind = e_code - s_code + (ps.decl_indent>i ? ps.decl_indent
    * : i);
    */
   dec_ind = ps.decl_indent > 0 ? ps.decl_indent : i;
   tabs_to_var = (use_tabs ? ps.decl_indent > 0 : 0);
   goto copy_id;

case ident13:		/* got an identifier or constant */
   if (ps.in_decl) {	/* if we are in a declaration, we must indent
51
←
Assuming field 'in_decl' is not equal to 0→
52
←
Taking true branch→
		 * identifier */
if (ps.want_blank)
53
←
Assuming field 'want_blank' is 0→
54
←
Taking false branch→
    *e_code++ = ' ';
ps.want_blank = false0;
if (is_procname == 0 || !procnames_start_line) {
55
←
Assuming 'is_procname' is equal to 0→
    if (!ps.block_init) {
56
←
Assuming field 'block_init' is 0→
	if (troff && !ps.dumped_decl_indent) {
57
←
Assuming 'troff' is 0→
	    snprintf(e_code, (l_code - e_code) + 5,
		"\n.De %dp+\200p\n", dec_ind * 7);
	    ps.dumped_decl_indent = 1;
	    e_code += strlen(e_code);
	    CHECK_SIZE_CODEif (e_code >= l_code) { int nsize = l_code-s_code+400; codebuf
 = realloc(codebuf, nsize); if (codebuf == ((void *)0)) err(1
, ((void *)0)); e_code = codebuf + (e_code-s_code) + 1; l_code
 = codebuf + nsize - 5; s_code = codebuf + 1; };
	} else {
	    int cur_dec_ind;
	    int pos, startpos;

	    /*
	     * in order to get the tab math right for
	     * indentations that are not multiples of 8 we
	     * need to modify both startpos and dec_ind
	     * (cur_dec_ind) here by eight minus the
	     * remainder of the current starting column
	     * divided by eight. This seems to be a
	     * properly working fix
	     */
	    startpos = e_code - s_code;
	    cur_dec_ind = dec_ind;
	    pos = startpos;
	    if ((ps.ind_level * ps.ind_size) % 8 != 0) {
58
←
Assuming the condition is false→
59
←
Taking false branch→
		pos += (ps.ind_level * ps.ind_size) % 8;
		cur_dec_ind += (ps.ind_level * ps.ind_size) % 8;
	    }

	    if (tabs_to_var) {
60
←
Branch condition evaluates to a garbage value
		while ((pos & ~7) + 8 <= cur_dec_ind) {
		    CHECK_SIZE_CODEif (e_code >= l_code) { int nsize = l_code-s_code+400; codebuf
 = realloc(codebuf, nsize); if (codebuf == ((void *)0)) err(1
, ((void *)0)); e_code = codebuf + (e_code-s_code) + 1; l_code
 = codebuf + nsize - 5; s_code = codebuf + 1; };
		    *e_code++ = '\t';
		    pos = (pos & ~7) + 8;
		}
	    }
	    while (pos < cur_dec_ind) {
		CHECK_SIZE_CODEif (e_code >= l_code) { int nsize = l_code-s_code+400; codebuf
 = realloc(codebuf, nsize); if (codebuf == ((void *)0)) err(1
, ((void *)0)); e_code = codebuf + (e_code-s_code) + 1; l_code
 = codebuf + nsize - 5; s_code = codebuf + 1; };
		*e_code++ = ' ';
		pos++;
	    }
	    if (ps.want_blank && e_code - s_code == startpos)
		*e_code++ = ' ';
	    ps.want_blank = false0;
	}
    }
}
else {
    if (dec_ind && s_code != e_code)
	dump_line();
    dec_ind = 0;
    ps.want_blank = false0;
}
   }
   else if (sp_sw && ps.p_l_follow == 0) {
sp_sw = false0;
force_nl = true1;
ps.last_u_d = true1;
ps.in_stmt = false0;
parse(hd_type);
   }
  copy_id:
   if (ps.want_blank)
*e_code++ = ' ';
   if (troff && ps.its_a_keyword) {
e_code = chfont(&bodyf, &keywordf, e_code);
for (t_ptr = tokens_token; *t_ptr; ++t_ptr) {
    CHECK_SIZE_CODEif (e_code >= l_code) { int nsize = l_code-s_code+400; codebuf
 = realloc(codebuf, nsize); if (codebuf == ((void *)0)) err(1
, ((void *)0)); e_code = codebuf + (e_code-s_code) + 1; l_code
 = codebuf + nsize - 5; s_code = codebuf + 1; };
    *e_code++ = keywordf.allcaps &&
      islower((unsigned char)*t_ptr) ?
      toupper((unsigned char)*t_ptr) : *t_ptr;
}
e_code = chfont(&keywordf, &bodyf, e_code);
   }
   else
for (t_ptr = tokens_token; *t_ptr; ++t_ptr) {
    CHECK_SIZE_CODEif (e_code >= l_code) { int nsize = l_code-s_code+400; codebuf
 = realloc(codebuf, nsize); if (codebuf == ((void *)0)) err(1
, ((void *)0)); e_code = codebuf + (e_code-s_code) + 1; l_code
 = codebuf + nsize - 5; s_code = codebuf + 1; };
    *e_code++ = *t_ptr;
}
   ps.want_blank = true1;
   break;

case period32:		/* treat a period kind of like a binary
		 * operation */
   *e_code++ = '.';	/* move the period into line */
   ps.want_blank = false0;	/* dont put a blank after a period */
   break;

case comma14:
   ps.want_blank = (s_code != e_code);	/* only put blank after comma
				 * if comma does not start the
				 * line */
   if (ps.in_decl && is_procname == 0 && !ps.block_init)
while ((e_code - s_code) < (dec_ind - 1)) {
    CHECK_SIZE_CODEif (e_code >= l_code) { int nsize = l_code-s_code+400; codebuf
 = realloc(codebuf, nsize); if (codebuf == ((void *)0)) err(1
, ((void *)0)); e_code = codebuf + (e_code-s_code) + 1; l_code
 = codebuf + nsize - 5; s_code = codebuf + 1; };
    *e_code++ = ' ';
}

   *e_code++ = ',';
   if (ps.p_l_follow == 0) {
if (ps.block_init_level <= 0)
    ps.block_init = 0;
if (break_comma && (!ps.leave_comma || compute_code_target() + (e_code - s_code) > max_col - 8))
    force_nl = true1;
   }
   break;

case preesc17:		/* got the character '#' */
   if ((s_com != e_com) ||
    (s_lab != e_lab) ||
    (s_code != e_code))
dump_line();
   *e_lab++ = '#';	/* move whole line to 'label' buffer */
   {
int         in_comment = 0;
int         com_start = 0;
char        quote = 0;
int         com_end = 0;

while (*buf_ptr == ' ' || *buf_ptr == '\t') {
    buf_ptr++;
    if (buf_ptr >= buf_end)
	fill_buffer();
}
while (*buf_ptr != '\n' || (in_comment && !had_eof)) {
    CHECK_SIZE_LABif (e_lab >= l_lab) { int nsize = l_lab-s_lab+400; labbuf =
 realloc(labbuf, nsize); if (labbuf == ((void *)0)) err(1, ((
void *)0)); e_lab = labbuf + (e_lab-s_lab) + 1; l_lab = labbuf
 + nsize - 5; s_lab = labbuf + 1; };
    *e_lab = *buf_ptr++;
    if (buf_ptr >= buf_end)
	fill_buffer();
    switch (*e_lab++) {
    case BACKSLASH'\\':
	if (troff)
	    *e_lab++ = BACKSLASH'\\';
	if (!in_comment) {
	    *e_lab++ = *buf_ptr++;
	    if (buf_ptr >= buf_end)
		fill_buffer();
	}
	break;
    case '/':
	if (*buf_ptr == '*' && !in_comment && !quote) {
	    in_comment = 1;
	    *e_lab++ = *buf_ptr++;
	    com_start = e_lab - s_lab - 2;
	}
	break;
    case '"':
	if (quote == '"')
	    quote = 0;
	break;
    case '\'':
	if (quote == '\'')
	    quote = 0;
	break;
    case '*':
	if (*buf_ptr == '/' && in_comment) {
	    in_comment = 0;
	    *e_lab++ = *buf_ptr++;
	    com_end = e_lab - s_lab;
	}
	break;
    }
}

while (e_lab > s_lab && (e_lab[-1] == ' ' || e_lab[-1] == '\t'))
    e_lab--;
if (e_lab - s_lab == com_end && bp_save == 0) {	/* comment on
						 * preprocessor line */
    if (sc_end == 0)	/* if this is the first comment, we
			 * must set up the buffer */
	sc_end = &(save_com[0]);
    else {
	*sc_end++ = '\n';	/* add newline between
				 * comments */
	*sc_end++ = ' ';
	--line_no;
    }
    bcopy(s_lab + com_start, sc_end, com_end - com_start);
    sc_end += com_end - com_start;
    if (sc_end >= &save_com[sc_size5000])
	abort();
    e_lab = s_lab + com_start;
    while (e_lab > s_lab && (e_lab[-1] == ' ' || e_lab[-1] == '\t'))
	e_lab--;
    bp_save = buf_ptr;	/* save current input buffer */
    be_save = buf_end;
    buf_ptr = save_com;	/* fix so that subsequent calls to
			 * lexi will take tokens out of
			 * save_com */
    *sc_end++ = ' ';	/* add trailing blank, just in case */
    buf_end = sc_end;
    sc_end = 0;
}
*e_lab = '\0';	/* null terminate line */
ps.pcase = false0;
   }

   if (strncmp(s_lab, "#if", 3) == 0) {
if (blanklines_around_conditional_compilation) {
    int    c;
    prefix_blankline_requested++;
    while ((c = getc(input)(!__isthreaded ? (--(input)->_r < 0 ? __srget(input) : (
int)(*(input)->_p++)) : (getc)(input))) == '\n');
    ungetc(c, input);
}
if (ifdef_level < sizeof state_stack / sizeof state_stack[0]) {
    match_state[ifdef_level].tos = -1;
    state_stack[ifdef_level++] = ps;
}
else
    diag(1, "#if stack overflow");
   }
   else if (strncmp(s_lab, "#else", 5) == 0)
if (ifdef_level <= 0)
    diag(1, "Unmatched #else");
else {
    match_state[ifdef_level - 1] = ps;
    ps = state_stack[ifdef_level - 1];
}
   else if (strncmp(s_lab, "#endif", 6) == 0) {
if (ifdef_level <= 0)
    diag(1, "Unmatched #endif");
else {
    ifdef_level--;

1253#ifdef undef
    /*
     * This match needs to be more intelligent before the
     * message is useful
     */
    if (match_state[ifdef_level].tos >= 0
	  && bcmp(&ps, &match_state[ifdef_level], sizeof ps))
	diag(0, "Syntactically inconsistent #ifdef alternatives.");
1261#endif
}
if (blanklines_around_conditional_compilation) {
    postfix_blankline_requested++;
    n_real_blanklines = 0;
}
   }
   break;		/* subsequent processing of the newline
		 * character will cause the line to be printed */

case comment15:		/* we have gotten a comment this is a biggie */
   if (flushed_nl) {	/* we should force a broken line here */
flushed_nl = false0;
dump_line();
ps.want_blank = false0;	/* dont insert blank at line start */
force_nl = false0;
   }
   pr_comment();
   break;
}			/* end of big switch stmt */

*e_code = '\0';		/* make sure code section is null terminated */
if (type_code != comment15 && type_code != newline1 && type_code != preesc17)
   ps.last_token = type_code;
  }				/* end of main while (1) loop */
1286}

1288/*
* copy input file to backup file if in_name is /blah/blah/blah/file, then
* backup file will be ".Bfile" then make the backup file the input and
* original input file the output
*/
1293void
1294bakcopy(void)
1295{
  int         n,
              bakchn;
  char        buff[8 * 1024];
  char       *p;

  /* construct file name .Bfile */
  for (p = in_name; *p; p++);	/* skip to end of string */
  while (p > in_name && *p != '/')	/* find last '/' */
p--;
  if (*p == '/')
p++;
  if (snprintf(bakfile, PATH_MAX1024, "%s.BAK", p) >= PATH_MAX1024)
   errc(1, ENAMETOOLONG63, "%s.BAK", p);

  /* copy in_name to backup file */
  bakchn = open(bakfile, O_CREAT0x0200 | O_TRUNC0x0400 | O_WRONLY0x0001, 0600);
  if (bakchn == -1)
err(1, "%s", bakfile);
  while ((n = read(fileno(input)(!__isthreaded ? ((input)->_file) : (fileno)(input)), buff, sizeof buff)) > 0)
if (write(bakchn, buff, n) != n)
   err(1, "%s", bakfile);
  if (n == -1)
err(1, "%s", in_name);
  close(bakchn);
  fclose(input);

  /* re-open backup file as the input file */
  input = fopen(bakfile, "r");
  if (input == NULL((void *)0))
err(1, "%s", bakfile);
  /* now the original input file will be the output */
  output = fopen(in_name, "w");
  if (output == NULL((void *)0)) {
int saved_errno = errno(*__errno());
unlink(bakfile);
errc(1, saved_errno, "%s", in_name);
  }
1333}