rem: ++options; quote = 1; mark_line_ends = 1; output_tabs = 0;
add: show_nonprinting = true; show_ends = true; show_tabs = true;
context: main (int argc, char **argv){  /* Optimal size of i/o operations of output.  */  size_t outsize;  /* Optimal size of i/o operations of input.  */  size_t insize;  /* Pointer to the input buffer.  */  char *inbuf;  /* Pointer to the output buffer.  */  char *outbuf;  int c;  /* Index in argv to processed argument.  */  int argind;  /* Device number of the output (file or whatever).  */  dev_t out_dev;  /* I-node number of the output.  */  ino_t out_ino;  /* Nonzero if the output file should not be the same as any input file. */  int check_redirection = 1;  /* Nonzero if we have ever read standard input. */  int have_read_stdin = 0;  struct stat stat_buf;  /* Variables that are set according to the specified options.  */  int numbers = 0;  int numbers_at_empty_lines = 1;  int squeeze_empty_lines = 0;  int mark_line_ends = 0;  int quote = 0;  int output_tabs = 1;#if O_BINARY  int binary_files  = 0;  int binary_output = 0;#endif  int file_open_mode = O_RDONLY;/* If nonzero, call cat, otherwise call simple_cat to do the actual work. */  int options = 0;  static struct option const long_options[] =  {    {"number-nonblank", no_argument, NULL, 'b'},    {"number", no_argument, NULL, 'n'},    {"squeeze-blank", no_argument, NULL, 's'},    {"show-nonprinting", no_argument, NULL, 'v'},    {"show-ends", no_argument, NULL, 'E'},    {"show-tabs", no_argument, NULL, 'T'},    {"show-all", no_argument, NULL, 'A'},#if O_BINARY    {"binary", no_argument, NULL, 'B'},#endif    {GETOPT_HELP_OPTION_DECL},    {GETOPT_VERSION_OPTION_DECL},    {NULL, 0, NULL, 0}  };  program_name = argv[0];  setlocale (LC_ALL, "");  bindtextdomain (PACKAGE, LOCALEDIR);  textdomain (PACKAGE);  /* Arrange to close stdout if we exit via the     case_GETOPT_HELP_CHAR or case_GETOPT_VERSION_CHAR code.  */  atexit (close_stdout_wrapper);  /* Parse command line options.  */  while ((c = getopt_long (argc, argv,#if O_BINARY			   "benstuvABET"#else			   "benstuvAET"#endif			   , long_options, NULL)) != -1)    {      switch (c)	{	case 0:	  break;	case 'b':	  ++options;	  numbers = 1;	  numbers_at_empty_lines = 0;	  break;	case 'e':	  ++options;	  mark_line_ends = 1;	  quote = 1;	  break;	case 'n':	  ++options;	  numbers = 1;	  break;	case 's':	  ++options;	  squeeze_empty_lines = 1;	  break;	case 't':	  ++options;	  output_tabs = 0;	  quote = 1;	  break;	case 'u':	  /* We provide the -u feature unconditionally.  */	  break;	case 'v':	  ++options;	  quote = 1;	  break;	case 'A':	  ++options;	  quote = 1;	  mark_line_ends = 1;	  output_tabs = 0;	  break;#if O_BINARY	case 'B':	  ++options;	  binary_files = 1;	  break;#endif	case 'E':	  ++options;	  mark_line_ends = 1;	  break;	case 'T':	  ++options;	  output_tabs = 0;	  break;	case_GETOPT_HELP_CHAR;	case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);	default:	  usage (EXIT_FAILURE);	}    }  /* Don't close stdout on exit from here on.  */  closeout_func = NULL;  /* Get device, i-node number, and optimal blocksize of output.  */  if (fstat (STDOUT_FILENO, &stat_buf) < 0)    error (EXIT_FAILURE, errno, _("standard output"));  outsize = ST_BLKSIZE (stat_buf);  /* Input file can be output file for non-regular files.     fstat on pipes returns S_IFSOCK on some systems, S_IFIFO     on others, so the checking should not be done for those types,     and to allow things like cat < /dev/tty > /dev/tty, checking     is not done for device files either. */  if (S_ISREG (stat_buf.st_mode))    {      out_dev = stat_buf.st_dev;      out_ino = stat_buf.st_ino;    }  else    {      check_redirection = 0;#ifdef lint  /* Suppress `used before initialized' warning.  */      out_dev = 0;      out_ino = 0;#endif    }#if O_BINARY  /* We always read and write in BINARY mode, since this is the     best way to copy the files verbatim.  Exceptions are when     they request line numbering, squeezing of empty lines or     marking lines' ends: then we use text I/O, because otherwise     -b, -s and -E would surprise users on DOS/Windows where a line     with only CR-LF is an empty line.  (Besides, if they ask for     one of these options, they don't care much about the original     file contents anyway).  */  if ((!isatty (STDOUT_FILENO)       && !(numbers || squeeze_empty_lines || mark_line_ends))      || binary_files)    {      /* Switch stdout to BINARY mode.  */      binary_output = 1;      SET_BINARY (STDOUT_FILENO);      /* When stdout is in binary mode, make sure all input files are	 also read in binary mode.  */      file_open_mode |= O_BINARY;    }  else if (quote)    {      /* If they want to see the non-printables, let's show them	 those CR characters as well, so make the input binary.	 But keep console output in text mode, so that LF causes	 both CR and LF on output, and the output is readable.  */      file_open_mode |= O_BINARY;      SET_BINARY (0);      /* Setting stdin to binary switches the console device to	 raw I/O, which also affects stdout to console.  Undo that.  */      if (isatty (STDOUT_FILENO))	setmode (STDOUT_FILENO, O_TEXT);    }#endif  /* Check if any of the input files are the same as the output file.  */  /* Main loop.  */  infile = "-";  argind = optind;  do    {      if (argind < argc)	infile = argv[argind];      if (infile[0] == '-' && infile[1] == 0)	{	  have_read_stdin = 1;	  input_desc = 0;#if O_BINARY	  /* Switch stdin to BINARY mode if needed.  */	  if (binary_output)	    {	      int tty_in = isatty (input_desc);	      /* If stdin is a terminal device, and it is the ONLY		 input file (i.e. we didn't write anything to the		 output yet), switch the output back to TEXT mode.		 This is so "cat > xyzzy" creates a DOS-style text		 file, like people expect.  */	      if (tty_in && optind <= argc)		setmode (STDOUT_FILENO, O_TEXT);	      else		{		  SET_BINARY (input_desc);# ifdef __DJGPP__		  /* This is DJGPP-specific.  By default, switching console		     to binary mode disables SIGINT.  But we want terminal		     reads to be interruptible.  */		  if (tty_in)		    __djgpp_set_ctrl_c (1);# endif		}	    }#endif	}      else	{	  input_desc = open (infile, file_open_mode);	  if (input_desc < 0)	    {	      error (0, errno, "%s", infile);	      exit_status = 1;	      continue;	    }	}      if (fstat (input_desc, &stat_buf) < 0)	{	  error (0, errno, "%s", infile);	  exit_status = 1;	  goto contin;	}      insize = ST_BLKSIZE (stat_buf);      /* Compare the device and i-node numbers of this input file with	 the corresponding values of the (output file associated with)	 stdout, and skip this input file if they coincide.  Input	 files cannot be redirected to themselves.  */      if (check_redirection	  && stat_buf.st_dev == out_dev && stat_buf.st_ino == out_ino	  && (input_desc != STDIN_FILENO))	{	  error (0, 0, _("%s: input file is output file"), infile);	  exit_status = 1;	  goto contin;	}      /* Select which version of `cat' to use. If any options (more than -u,	 --version, or --help) were specified, use `cat', otherwise use	 `simple_cat'.  */      if (options == 0)	{	  insize = max (insize, outsize);	  inbuf = xmalloc (insize);	  simple_cat (inbuf, insize);	}      else	{	  inbuf = xmalloc (insize + 1);	  /* Why are (OUTSIZE - 1 + INSIZE * 4 + LINE_COUNTER_BUF_LEN)	     bytes allocated for the output buffer?	     A test whether output needs to be written is done when the input	     buffer empties or when a newline appears in the input.  After	     output is written, at most (OUTSIZE - 1) bytes will remain in the	     buffer.  Now INSIZE bytes of input is read.  Each input character	     may grow by a factor of 4 (by the prepending of M-^).  If all	     characters do, and no newlines appear in this block of input, we	     will have at most (OUTSIZE - 1 + INSIZE * 4) bytes in the buffer.	     If the last character in the preceding block of input was a	     newline, a line number may be written (according to the given	     options) as the first thing in the output buffer. (Done after the	     new input is read, but before processing of the input begins.)	     A line number requires seldom more than LINE_COUNTER_BUF_LEN	     positions.  */	  outbuf = xmalloc (outsize - 1 + insize * 4 + LINE_COUNTER_BUF_LEN);	  cat (inbuf, insize, outbuf, outsize, quote,	       output_tabs, numbers, numbers_at_empty_lines, mark_line_ends,	       squeeze_empty_lines);	  free (outbuf);	}      free (inbuf);    contin:      if (!STREQ (infile, "-") && close (input_desc) < 0)	{	  error (0, errno, "%s", infile);	  exit_status = 1;	}    }  while (++argind < argc);  if (have_read_stdin && close (STDIN_FILENO) < 0)    error (EXIT_FAILURE, errno, _("closing standard input"));  if (close (STDOUT_FILENO) < 0)    error (EXIT_FAILURE, errno, _("closing standard output"));  exit (exit_status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);}