/* diff - compare files line by line

   Copyright (C) 1988-1989, 1992-1994, 1996, 1998, 2001-2002, 2004, 2006-2007,

   2009-2013, 2015-2017 Free Software Foundation, Inc.

   This file is part of GNU DIFF.

   This program is free software: you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation, either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#define GDIFF_MAIN

#include "diff.h"

#include "die.h"

#include <assert.h>

#include "paths.h"

#include <c-stack.h>

#include <dirname.h>

#include <error.h>

#include <exclude.h>

#include <exitfail.h>

#include <filenamecat.h>

#include <file-type.h>

#include <fnmatch.h>

#include <getopt.h>

#include <hard-locale.h>

#include <prepargs.h>

#include <progname.h>

#include <sh-quote.h>

#include <stat-time.h>

#include <timespec.h>

#include <version-etc.h>

#include <xalloc.h>

#include <xreadlink.h>

#include <binary-io.h>

/* The official name of this program (e.g., no 'g' prefix).  */

#define PROGRAM_NAME "diff"

#define AUTHORS \

  proper_name ("Paul Eggert"), \

  proper_name ("Mike Haertel"), \

  proper_name ("David Hayes"), \

  proper_name ("Richard Stallman"), \

  proper_name ("Len Tower")

#ifndef GUTTER_WIDTH_MINIMUM

# define GUTTER_WIDTH_MINIMUM 3

#endif

struct regexp_list

{

  char *regexps;	/* chars representing disjunction of the regexps */

  size_t len;		/* chars used in 'regexps' */

  size_t size;		/* size malloc'ed for 'regexps'; 0 if not malloc'ed */

  bool multiple_regexps;/* Does 'regexps' represent a disjunction?  */

  struct re_pattern_buffer *buf;

};

static int compare_files (struct comparison const *, char const *, char const *);

static void add_regexp (struct regexp_list *, char const *);

static void summarize_regexp_list (struct regexp_list *);

static void specify_style (enum output_style);

static void specify_value (char const **, char const *, char const *);

static void specify_colors_style (char const *);

static void try_help (char const *, char const *) __attribute__((noreturn));

static void check_stdout (void);

static void usage (void);

bool (*lines_differ) (char const *, size_t, char const *, size_t);

/* If comparing directories, compare their common subdirectories

   recursively.  */

static bool recursive;

/* In context diffs, show previous lines that match these regexps.  */

static struct regexp_list function_regexp_list;

/* Ignore changes affecting only lines that match these regexps.  */

static struct regexp_list ignore_regexp_list;

#if O_BINARY

/* Use binary I/O when reading and writing data (--binary).

   On POSIX hosts, this has no effect.  */

static bool binary;

#else

enum { binary = true };

#endif

/* If one file is missing, treat it as present but empty (-N).  */

static bool new_file;

/* If the first file is missing, treat it as present but empty

   (--unidirectional-new-file).  */

static bool unidirectional_new_file;

/* Report files compared that are the same (-s).

   Normally nothing is output when that happens.  */

static bool report_identical_files;

static char const shortopts[] =

"0123456789abBcC:dD:eEfF:hHiI:lL:nNpPqrsS:tTuU:vwW:x:X:yZ";

/* Values for long options that do not have single-letter equivalents.  */

enum

{

  BINARY_OPTION = CHAR_MAX + 1,

  FROM_FILE_OPTION,

  HELP_OPTION,

  HORIZON_LINES_OPTION,

  IGNORE_FILE_NAME_CASE_OPTION,

  INHIBIT_HUNK_MERGE_OPTION,

  LEFT_COLUMN_OPTION,

  LINE_FORMAT_OPTION,

  NO_DEREFERENCE_OPTION,

  NO_IGNORE_FILE_NAME_CASE_OPTION,

  NORMAL_OPTION,

  SDIFF_MERGE_ASSIST_OPTION,

  STRIP_TRAILING_CR_OPTION,

  SUPPRESS_BLANK_EMPTY_OPTION,

  SUPPRESS_COMMON_LINES_OPTION,

  TABSIZE_OPTION,

  TO_FILE_OPTION,

  /* These options must be in sequence.  */

  UNCHANGED_LINE_FORMAT_OPTION,

  OLD_LINE_FORMAT_OPTION,

  NEW_LINE_FORMAT_OPTION,

  /* These options must be in sequence.  */

  UNCHANGED_GROUP_FORMAT_OPTION,

  OLD_GROUP_FORMAT_OPTION,

  NEW_GROUP_FORMAT_OPTION,

  CHANGED_GROUP_FORMAT_OPTION,

  COLOR_OPTION,

  COLOR_PALETTE_OPTION,

  PRESUME_OUTPUT_TTY_OPTION,

};

static char const group_format_option[][sizeof "--unchanged-group-format"] =

  {

    "--unchanged-group-format",

    "--old-group-format",

    "--new-group-format",

    "--changed-group-format"

  };

static char const line_format_option[][sizeof "--unchanged-line-format"] =

  {

    "--unchanged-line-format",

    "--old-line-format",

    "--new-line-format"

  };

static struct option const longopts[] =

{

  {"binary", 0, 0, BINARY_OPTION},

  {"brief", 0, 0, 'q'},

  {"changed-group-format", 1, 0, CHANGED_GROUP_FORMAT_OPTION},

  {"color", 2, 0, COLOR_OPTION},

  {"context", 2, 0, 'C'},

  {"ed", 0, 0, 'e'},

  {"exclude", 1, 0, 'x'},

  {"exclude-from", 1, 0, 'X'},

  {"expand-tabs", 0, 0, 't'},

  {"forward-ed", 0, 0, 'f'},

  {"from-file", 1, 0, FROM_FILE_OPTION},

  {"help", 0, 0, HELP_OPTION},

  {"horizon-lines", 1, 0, HORIZON_LINES_OPTION},

  {"ifdef", 1, 0, 'D'},

  {"ignore-all-space", 0, 0, 'w'},

  {"ignore-blank-lines", 0, 0, 'B'},

  {"ignore-case", 0, 0, 'i'},

  {"ignore-file-name-case", 0, 0, IGNORE_FILE_NAME_CASE_OPTION},

  {"ignore-matching-lines", 1, 0, 'I'},

  {"ignore-space-change", 0, 0, 'b'},

  {"ignore-tab-expansion", 0, 0, 'E'},

  {"ignore-trailing-space", 0, 0, 'Z'},

  {"inhibit-hunk-merge", 0, 0, INHIBIT_HUNK_MERGE_OPTION},

  {"initial-tab", 0, 0, 'T'},

  {"label", 1, 0, 'L'},

  {"left-column", 0, 0, LEFT_COLUMN_OPTION},

  {"line-format", 1, 0, LINE_FORMAT_OPTION},

  {"minimal", 0, 0, 'd'},

  {"new-file", 0, 0, 'N'},

  {"new-group-format", 1, 0, NEW_GROUP_FORMAT_OPTION},

  {"new-line-format", 1, 0, NEW_LINE_FORMAT_OPTION},

  {"no-dereference", 0, 0, NO_DEREFERENCE_OPTION},

  {"no-ignore-file-name-case", 0, 0, NO_IGNORE_FILE_NAME_CASE_OPTION},

  {"normal", 0, 0, NORMAL_OPTION},

  {"old-group-format", 1, 0, OLD_GROUP_FORMAT_OPTION},

  {"old-line-format", 1, 0, OLD_LINE_FORMAT_OPTION},

  {"paginate", 0, 0, 'l'},

  {"palette", 1, 0, COLOR_PALETTE_OPTION},

  {"rcs", 0, 0, 'n'},

  {"recursive", 0, 0, 'r'},

  {"report-identical-files", 0, 0, 's'},

  {"sdiff-merge-assist", 0, 0, SDIFF_MERGE_ASSIST_OPTION},

  {"show-c-function", 0, 0, 'p'},

  {"show-function-line", 1, 0, 'F'},

  {"side-by-side", 0, 0, 'y'},

  {"speed-large-files", 0, 0, 'H'},

  {"starting-file", 1, 0, 'S'},

  {"strip-trailing-cr", 0, 0, STRIP_TRAILING_CR_OPTION},

  {"suppress-blank-empty", 0, 0, SUPPRESS_BLANK_EMPTY_OPTION},

  {"suppress-common-lines", 0, 0, SUPPRESS_COMMON_LINES_OPTION},

  {"tabsize", 1, 0, TABSIZE_OPTION},

  {"text", 0, 0, 'a'},

  {"to-file", 1, 0, TO_FILE_OPTION},

  {"unchanged-group-format", 1, 0, UNCHANGED_GROUP_FORMAT_OPTION},

  {"unchanged-line-format", 1, 0, UNCHANGED_LINE_FORMAT_OPTION},

  {"unidirectional-new-file", 0, 0, 'P'},

  {"unified", 2, 0, 'U'},

  {"version", 0, 0, 'v'},

  {"width", 1, 0, 'W'},

  /* This is solely for testing.  Do not document.  */

  {"-presume-output-tty", no_argument, NULL, PRESUME_OUTPUT_TTY_OPTION},

  {0, 0, 0, 0}

};

/* Return a string containing the command options with which diff was invoked.

   Spaces appear between what were separate ARGV-elements.

   There is a space at the beginning but none at the end.

   If there were no options, the result is an empty string.

   Arguments: OPTIONVEC, a vector containing separate ARGV-elements, and COUNT,

   the length of that vector.  */

static char *

option_list (char **optionvec, int count)

{

  int i;

  size_t size = 1;

  char *result;

  char *p;

  for (i = 0; i < count; i++)

    size += 1 + shell_quote_length (optionvec[i]);

  p = result = xmalloc (size);

  for (i = 0; i < count; i++)

    {

      *p++ = ' ';

      p = shell_quote_copy (p, optionvec[i]);

    }

  *p = '\0';

  return result;

}

/* Return an option value suitable for add_exclude.  */

static int

exclude_options (void)

{

  return EXCLUDE_WILDCARDS | (ignore_file_name_case ? FNM_CASEFOLD : 0);

}

int

main (int argc, char **argv)

{

  int exit_status = EXIT_SUCCESS;

  int c;

  int i;

  int prev = -1;

  lin ocontext = -1;

  bool explicit_context = false;

  size_t width = 0;

  bool show_c_function = false;

  char const *from_file = NULL;

  char const *to_file = NULL;

  uintmax_t numval;

  char *numend;

  /* Do our initializations.  */

  exit_failure = EXIT_TROUBLE;

  initialize_main (&argc, &argv);

  set_program_name (argv[0]);

  setlocale (LC_ALL, "");

  bindtextdomain (PACKAGE, LOCALEDIR);

  textdomain (PACKAGE);

  c_stack_action (0);

  function_regexp_list.buf = &function_regexp;

  ignore_regexp_list.buf = &ignore_regexp;

  re_set_syntax (RE_SYNTAX_GREP | RE_NO_POSIX_BACKTRACKING);

  excluded = new_exclude ();

  presume_output_tty = false;

#ifdef HANDLE_MULTIBYTE

  if (MB_CUR_MAX > 1)

    lines_differ = lines_differ_multibyte;

  else

#endif

    lines_differ = lines_differ_singlebyte;

  /* Decode the options.  */

  while ((c = getopt_long (argc, argv, shortopts, longopts, NULL)) != -1)

    {

      switch (c)

	{

	case 0:

	  break;

	case '0':

	case '1':

	case '2':

	case '3':

	case '4':

	case '5':

	case '6':

	case '7':

	case '8':

	case '9':

	  ocontext = (! ISDIGIT (prev)

		      ? c - '0'

		      : (ocontext - (c - '0' <= CONTEXT_MAX % 10)

			 < CONTEXT_MAX / 10)

		      ? 10 * ocontext + (c - '0')

		      : CONTEXT_MAX);

	  break;

	case 'a':

	  text = true;

	  break;

	case 'b':

	  if (ignore_white_space < IGNORE_SPACE_CHANGE)

	    ignore_white_space = IGNORE_SPACE_CHANGE;

	  break;

	case 'Z':

	  if (ignore_white_space < IGNORE_SPACE_CHANGE)

	    ignore_white_space |= IGNORE_TRAILING_SPACE;

	  break;

	case 'B':

	  ignore_blank_lines = true;

	  break;

	case 'C':

	case 'U':

	  {

	    if (optarg)

	      {

		numval = strtoumax (optarg, &numend, 10);

		if (*numend)

		  try_help ("invalid context length '%s'", optarg);

		if (CONTEXT_MAX < numval)

		  numval = CONTEXT_MAX;

	      }

	    else

	      numval = 3;

	    specify_style (c == 'U' ? OUTPUT_UNIFIED : OUTPUT_CONTEXT);

	    if (context < numval)

	      context = numval;

	    explicit_context = true;

	  }

	  break;

	case 'c':

	  specify_style (OUTPUT_CONTEXT);

	  if (context < 3)

	    context = 3;

	  break;

	case 'd':

	  minimal = true;

	  break;

	case 'D':

	  specify_style (OUTPUT_IFDEF);

	  {

	    static char const C_ifdef_group_formats[] =

	      "%%=%c#ifndef %s\n%%<#endif /* ! %s */\n%c#ifdef %s\n%%>#endif /* %s */\n%c#ifndef %s\n%%<#else /* %s */\n%%>#endif /* %s */\n";

	    char *b = xmalloc (sizeof C_ifdef_group_formats

			       + 7 * strlen (optarg) - 14 /* 7*"%s" */

			       - 8 /* 5*"%%" + 3*"%c" */);

	    sprintf (b, C_ifdef_group_formats,

		     0,

		     optarg, optarg, 0,

		     optarg, optarg, 0,

		     optarg, optarg, optarg);

	    for (i = 0; i < sizeof group_format / sizeof group_format[0]; i++)

	      {

		specify_value (&group_format[i], b, "-D");

		b += strlen (b) + 1;

	      }

	  }

	  break;

	case 'e':

	  specify_style (OUTPUT_ED);

	  break;

	case 'E':

	  if (ignore_white_space < IGNORE_SPACE_CHANGE)

	    ignore_white_space |= IGNORE_TAB_EXPANSION;

	  break;

	case 'f':

	  specify_style (OUTPUT_FORWARD_ED);

	  break;

	case 'F':

	  add_regexp (&function_regexp_list, optarg);

	  break;

	case 'h':

	  /* Split the files into chunks for faster processing.

	     Usually does not change the result.

	     This currently has no effect.  */

	  break;

	case 'H':

	  speed_large_files = true;

	  break;

	case 'i':

	  ignore_case = true;

	  break;

	case 'I':

	  add_regexp (&ignore_regexp_list, optarg);

	  break;

	case 'l':

	  if (!pr_program[0])

	    try_help ("pagination not supported on this host", NULL);

	  paginate = true;

#ifdef SIGCHLD

	  /* Pagination requires forking and waiting, and

	     System V fork+wait does not work if SIGCHLD is ignored.  */

	  signal (SIGCHLD, SIG_DFL);

#endif

	  break;

	case 'L':

	  if (!file_label[0])

	    file_label[0] = optarg;

	  else if (!file_label[1])

	    file_label[1] = optarg;

	  else

	    fatal ("too many file label options");

	  break;

	case 'n':

	  specify_style (OUTPUT_RCS);

	  break;

	case 'N':

	  new_file = true;

	  break;

	case 'p':

	  show_c_function = true;

	  add_regexp (&function_regexp_list, "^[[:alpha:]$_]");

	  break;

	case 'P':

	  unidirectional_new_file = true;

	  break;

	case 'q':

	  brief = true;

	  break;

	case 'r':

	  recursive = true;

	  break;

	case 's':

	  report_identical_files = true;

	  break;

	case 'S':

	  specify_value (&starting_file, optarg, "-S");

	  break;

	case 't':

	  expand_tabs = true;

	  break;

	case 'T':

	  initial_tab = true;

	  break;

	case 'u':

	  specify_style (OUTPUT_UNIFIED);

	  if (context < 3)

	    context = 3;

	  break;

	case 'v':

	  version_etc (stdout, PROGRAM_NAME, PACKAGE_NAME, Version,

		       AUTHORS, (char *) NULL);

	  check_stdout ();

	  return EXIT_SUCCESS;

	case 'w':

	  ignore_white_space = IGNORE_ALL_SPACE;

	  break;

	case 'x':

	  add_exclude (excluded, optarg, exclude_options ());

	  break;

	case 'X':

	  if (add_exclude_file (add_exclude, excluded, optarg,

				exclude_options (), '\n'))

	    pfatal_with_name (optarg);

	  break;

	case 'y':

	  specify_style (OUTPUT_SDIFF);

	  break;

	case 'W':

	  numval = strtoumax (optarg, &numend, 10);

	  if (! (0 < numval && numval <= SIZE_MAX) || *numend)

	    try_help ("invalid width '%s'", optarg);

	  if (width != numval)

	    {

	      if (width)

		fatal ("conflicting width options");

	      width = numval;

	    }

	  break;

	case BINARY_OPTION:

#if O_BINARY

	  binary = true;

	  if (! isatty (STDOUT_FILENO))

	    set_binary_mode (STDOUT_FILENO, O_BINARY);

#endif

	  break;

	case FROM_FILE_OPTION:

	  specify_value (&from_file, optarg, "--from-file");

	  break;

	case HELP_OPTION:

	  usage ();

	  check_stdout ();

	  return EXIT_SUCCESS;

	case HORIZON_LINES_OPTION:

	  numval = strtoumax (optarg, &numend, 10);

	  if (*numend)

	    try_help ("invalid horizon length '%s'", optarg);

	  horizon_lines = MAX (horizon_lines, MIN (numval, LIN_MAX));

	  break;

	case IGNORE_FILE_NAME_CASE_OPTION:

	  ignore_file_name_case = true;

	  break;

	case INHIBIT_HUNK_MERGE_OPTION:

	  /* This option is obsolete, but accept it for backward

             compatibility.  */

	  break;

	case LEFT_COLUMN_OPTION:

	  left_column = true;

	  break;

	case LINE_FORMAT_OPTION:

	  specify_style (OUTPUT_IFDEF);

	  for (i = 0; i < sizeof line_format / sizeof line_format[0]; i++)

	    specify_value (&line_format[i], optarg, "--line-format");

	  break;

	case NO_DEREFERENCE_OPTION:

	  no_dereference_symlinks = true;

	  break;

	case NO_IGNORE_FILE_NAME_CASE_OPTION:

	  ignore_file_name_case = false;

	  break;

	case NORMAL_OPTION:

	  specify_style (OUTPUT_NORMAL);

	  break;

	case SDIFF_MERGE_ASSIST_OPTION:

	  specify_style (OUTPUT_SDIFF);

	  sdiff_merge_assist = true;

	  break;

	case STRIP_TRAILING_CR_OPTION:

	  strip_trailing_cr = true;

	  break;

	case SUPPRESS_BLANK_EMPTY_OPTION:

	  suppress_blank_empty = true;

	  break;

	case SUPPRESS_COMMON_LINES_OPTION:

	  suppress_common_lines = true;

	  break;

	case TABSIZE_OPTION:

	  numval = strtoumax (optarg, &numend, 10);

	  if (! (0 < numval && numval <= SIZE_MAX - GUTTER_WIDTH_MINIMUM)

	      || *numend)

	    try_help ("invalid tabsize '%s'", optarg);

	  if (tabsize != numval)

	    {

	      if (tabsize)

		fatal ("conflicting tabsize options");

	      tabsize = numval;

	    }

	  break;

	case TO_FILE_OPTION:

	  specify_value (&to_file, optarg, "--to-file");

	  break;

	case UNCHANGED_LINE_FORMAT_OPTION:

	case OLD_LINE_FORMAT_OPTION:

	case NEW_LINE_FORMAT_OPTION:

	  specify_style (OUTPUT_IFDEF);

	  c -= UNCHANGED_LINE_FORMAT_OPTION;

	  specify_value (&line_format[c], optarg, line_format_option[c]);

	  break;

	case UNCHANGED_GROUP_FORMAT_OPTION:

	case OLD_GROUP_FORMAT_OPTION:

	case NEW_GROUP_FORMAT_OPTION:

	case CHANGED_GROUP_FORMAT_OPTION:

	  specify_style (OUTPUT_IFDEF);

	  c -= UNCHANGED_GROUP_FORMAT_OPTION;

	  specify_value (&group_format[c], optarg, group_format_option[c]);

	  break;

	case COLOR_OPTION:

	  specify_colors_style (optarg);

	  break;

	case COLOR_PALETTE_OPTION:

	  set_color_palette (optarg);

	  break;

        case PRESUME_OUTPUT_TTY_OPTION:

          presume_output_tty = true;

          break;

	default:

	  try_help (NULL, NULL);

	}

      prev = c;

    }

  if (colors_style == AUTO)

    {

      char const *t = getenv ("TERM");

      if (t && STREQ (t, "dumb"))

        colors_style = NEVER;

    }

  if (output_style == OUTPUT_UNSPECIFIED)

    {

      if (show_c_function)

	{

	  specify_style (OUTPUT_CONTEXT);

	  if (ocontext < 0)

	    context = 3;

	}

      else

	specify_style (OUTPUT_NORMAL);

    }

  if (output_style != OUTPUT_CONTEXT || hard_locale (LC_TIME))

    {

#if (defined STAT_TIMESPEC || defined STAT_TIMESPEC_NS \

     || defined HAVE_STRUCT_STAT_ST_SPARE1)

      time_format = "%Y-%m-%d %H:%M:%S.%N %z";

#else

      time_format = "%Y-%m-%d %H:%M:%S %z";

#endif

    }

  else

    {

      /* See POSIX 1003.1-2001 for this format.  */

      time_format = "%a %b %e %T %Y";

    }

  if (0 <= ocontext

      && (output_style == OUTPUT_CONTEXT

	  || output_style == OUTPUT_UNIFIED)

      && (context < ocontext

	  || (ocontext < context && ! explicit_context)))

    context = ocontext;

  if (! tabsize)

    tabsize = 8;

  if (! width)

    width = 130;

  {

    /* Maximize first the half line width, and then the gutter width,

       according to the following constraints:

	1.  Two half lines plus a gutter must fit in a line.

	2.  If the half line width is nonzero:

	    a.  The gutter width is at least GUTTER_WIDTH_MINIMUM.

	    b.  If tabs are not expanded to spaces,

		a half line plus a gutter is an integral number of tabs,

		so that tabs in the right column line up.  */

    size_t t = expand_tabs ? 1 : tabsize;

    size_t w = width;

    size_t t_plus_g = t + GUTTER_WIDTH_MINIMUM;

    size_t unaligned_off = (w >> 1) + (t_plus_g >> 1) + (w & t_plus_g & 1);

    size_t off = unaligned_off - unaligned_off % t;

    sdiff_half_width = (off <= GUTTER_WIDTH_MINIMUM || w <= off

			? 0

			: MIN (off - GUTTER_WIDTH_MINIMUM, w - off));

    sdiff_column2_offset = sdiff_half_width ? off : w;

  }

  /* Make the horizon at least as large as the context, so that

     shift_boundaries has more freedom to shift the first and last hunks.  */

  if (horizon_lines < context)

    horizon_lines = context;

  summarize_regexp_list (&function_regexp_list);

  summarize_regexp_list (&ignore_regexp_list);

  if (output_style == OUTPUT_IFDEF)

    {

      for (i = 0; i < sizeof line_format / sizeof line_format[0]; i++)

	if (!line_format[i])

	  line_format[i] = "%l\n";

      if (!group_format[OLD])

	group_format[OLD]

	  = group_format[CHANGED] ? group_format[CHANGED] : "%<";

      if (!group_format[NEW])

	group_format[NEW]

	  = group_format[CHANGED] ? group_format[CHANGED] : "%>";

      if (!group_format[UNCHANGED])

	group_format[UNCHANGED] = "%=";

      if (!group_format[CHANGED])

	group_format[CHANGED] = concat (group_format[OLD],

					group_format[NEW], "");

    }

  no_diff_means_no_output =

    (output_style == OUTPUT_IFDEF ?

      (!*group_format[UNCHANGED]

       || (STREQ (group_format[UNCHANGED], "%=")

	   && !*line_format[UNCHANGED]))

     : (output_style != OUTPUT_SDIFF) | suppress_common_lines);

  files_can_be_treated_as_binary =

    (brief & binary

     & ~ (ignore_blank_lines | ignore_case | strip_trailing_cr

	  | (ignore_regexp_list.regexps || ignore_white_space)));

  switch_string = option_list (argv + 1, optind - 1);

  if (from_file)

    {

      if (to_file)

	fatal ("--from-file and --to-file both specified");

      else

	for (; optind < argc; optind++)

	  {

	    int status = compare_files (NULL, from_file, argv[optind]);

	    if (exit_status < status)

	      exit_status = status;

	  }

    }

  else

    {

      if (to_file)

	for (; optind < argc; optind++)

	  {

	    int status = compare_files (NULL, argv[optind], to_file);

	    if (exit_status < status)

	      exit_status = status;

	  }

      else

	{

	  if (argc - optind != 2)

	    {

	      if (argc - optind < 2)

		try_help ("missing operand after '%s'", argv[argc - 1]);

	      else

		try_help ("extra operand '%s'", argv[optind + 2]);

	    }

	  exit_status = compare_files (NULL, argv[optind], argv[optind + 1]);

	}

    }

  /* Print any messages that were saved up for last.  */

  print_message_queue ();

  check_stdout ();

  exit (exit_status);

  return exit_status;

}

/* Append to REGLIST the regexp PATTERN.  */

static void

add_regexp (struct regexp_list *reglist, char const *pattern)

{

  size_t patlen = strlen (pattern);

  char const *m = re_compile_pattern (pattern, patlen, reglist->buf);

  if (m != 0)

    error (EXIT_TROUBLE, 0, "%s: %s", pattern, m);

  else

    {

      char *regexps = reglist->regexps;

      size_t len = reglist->len;

      bool multiple_regexps = reglist->multiple_regexps = regexps != 0;

      size_t newlen = reglist->len = len + 2 * multiple_regexps + patlen;

      size_t size = reglist->size;

      if (size <= newlen)

	{

	  if (!size)

	    size = 1;

	  do size *= 2;

	  while (size <= newlen);

	  reglist->size = size;

	  reglist->regexps = regexps = xrealloc (regexps, size);

	}

      if (multiple_regexps)

	{

	  regexps[len++] = '\\';

	  regexps[len++] = '|';

	}

      memcpy (regexps + len, pattern, patlen + 1);

    }

}

/* Ensure that REGLIST represents the disjunction of its regexps.

   This is done here, rather than earlier, to avoid O(N^2) behavior.  */

static void

summarize_regexp_list (struct regexp_list *reglist)

{

  if (reglist->regexps)

    {

      /* At least one regexp was specified.  Allocate a fastmap for it.  */

      reglist->buf->fastmap = xmalloc (1 << CHAR_BIT);

      if (reglist->multiple_regexps)

	{

	  /* Compile the disjunction of the regexps.

	     (If just one regexp was specified, it is already compiled.)  */

	  char const *m = re_compile_pattern (reglist->regexps, reglist->len,

					      reglist->buf);

	  if (m)

	    die (EXIT_TROUBLE, 0, "%s: %s", reglist->regexps, m);

	}

    }

}