contrib/diffutils/src/diff.c

   1 /* diff - compare files line by line
   2
   3    Copyright (C) 1988, 1989, 1992, 1993, 1994, 1996, 1998, 2001, 2002,
   4    2004 Free Software Foundation, Inc.
   5
   6    This file is part of GNU DIFF.
   7
   8    GNU DIFF is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    GNU DIFF is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  16    See the GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GNU DIFF; see the file COPYING.
  20    If not, write to the Free Software Foundation,
  21    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  22
  23 #define GDIFF_MAIN
  24 #include "diff.h"
  25 #include "paths.h"
  26 #include <c-stack.h>
  27 #include <dirname.h>
  28 #include <error.h>
  29 #include <exclude.h>
  30 #include <exit.h>
  31 #include <exitfail.h>
  32 #include <file-type.h>
  33 #include <fnmatch.h>
  34 #include <getopt.h>
  35 #include <hard-locale.h>
  36 #include <posixver.h>
  37 #include <prepargs.h>
  38 #include <quotesys.h>
  39 #include <setmode.h>
  40 #include <version-etc.h>
  41 #include <xalloc.h>
  42
  43 #ifndef GUTTER_WIDTH_MINIMUM
  44 # define GUTTER_WIDTH_MINIMUM 3
  45 #endif
  46
  47 struct regexp_list
  48 {
  49   char *regexps;        /* chars representing disjunction of the regexps */
  50   size_t len;           /* chars used in `regexps' */
  51   size_t size;          /* size malloc'ed for `regexps'; 0 if not malloc'ed */
  52   bool multiple_regexps;/* Does `regexps' represent a disjunction?  */
  53   struct re_pattern_buffer *buf;
  54 };
  55
  56 static int compare_files (struct comparison const *, char const *, char const *);
  57 static void add_regexp (struct regexp_list *, char const *);
  58 static void summarize_regexp_list (struct regexp_list *);
  59 static void specify_style (enum output_style);
  60 static void specify_value (char const **, char const *, char const *);
  61 static void try_help (char const *, char const *) __attribute__((noreturn));
  62 static void check_stdout (void);
  63 static void usage (void);
  64
  65 /* If comparing directories, compare their common subdirectories
  66    recursively.  */
  67 static bool recursive;
  68
  69 /* In context diffs, show previous lines that match these regexps.  */
  70 static struct regexp_list function_regexp_list;
  71
  72 /* Ignore changes affecting only lines that match these regexps.  */
  73 static struct regexp_list ignore_regexp_list;
  74
  75 #if HAVE_SETMODE_DOS
  76 /* Use binary I/O when reading and writing data (--binary).
  77    On POSIX hosts, this has no effect.  */
  78 static bool binary;
  79 #else
  80 enum { binary = true };
  81 #endif
  82
  83 /* When comparing directories, if a file appears only in one
  84    directory, treat it as present but empty in the other (-N).
  85    Then `patch' would create the file with appropriate contents.  */
  86 static bool new_file;
  87
  88 /* When comparing directories, if a file appears only in the second
  89    directory of the two, treat it as present but empty in the other
  90    (--unidirectional-new-file).
  91    Then `patch' would create the file with appropriate contents.  */
  92 static bool unidirectional_new_file;
  93
  94 /* Report files compared that are the same (-s).
  95    Normally nothing is output when that happens.  */
  96 static bool report_identical_files;
  97
  98
  99 /* Return a string containing the command options with which diff was invoked.
 100    Spaces appear between what were separate ARGV-elements.
 101    There is a space at the beginning but none at the end.
 102    If there were no options, the result is an empty string.
 103
 104    Arguments: OPTIONVEC, a vector containing separate ARGV-elements, and COUNT,
 105    the length of that vector.  */
 106
 107 static char *
 108 option_list (char **optionvec, int count)
 109 {
 110   int i;
 111   size_t size = 1;
 112   char *result;
 113   char *p;
 114
 115   for (i = 0; i < count; i++)
 116     size += 1 + quote_system_arg ((char *) 0, optionvec[i]);
 117
 118   p = result = xmalloc (size);
 119
 120   for (i = 0; i < count; i++)
 121     {
 122       *p++ = ' ';
 123       p += quote_system_arg (p, optionvec[i]);
 124     }
 125
 126   *p = 0;
 127   return result;
 128 }
 129
 130
 131 /* Return an option value suitable for add_exclude.  */
 132
 133 static int
 134 exclude_options (void)
 135 {
 136   return EXCLUDE_WILDCARDS | (ignore_file_name_case ? FNM_CASEFOLD : 0);
 137 }
 138 \f
 139 static char const shortopts[] =
 140 "0123456789abBcC:dD:eEfF:hHiI:lL:nNpPqrsS:tTuU:vwW:x:X:y";
 141
 142 /* Values for long options that do not have single-letter equivalents.  */
 143 enum
 144 {
 145   BINARY_OPTION = CHAR_MAX + 1,
 146   FROM_FILE_OPTION,
 147   HELP_OPTION,
 148   HORIZON_LINES_OPTION,
 149   IGNORE_FILE_NAME_CASE_OPTION,
 150   INHIBIT_HUNK_MERGE_OPTION,
 151   LEFT_COLUMN_OPTION,
 152   LINE_FORMAT_OPTION,
 153   NO_IGNORE_FILE_NAME_CASE_OPTION,
 154   NORMAL_OPTION,
 155   SDIFF_MERGE_ASSIST_OPTION,
 156   STRIP_TRAILING_CR_OPTION,
 157   SUPPRESS_COMMON_LINES_OPTION,
 158   TABSIZE_OPTION,
 159   TO_FILE_OPTION,
 160
 161   /* These options must be in sequence.  */
 162   UNCHANGED_LINE_FORMAT_OPTION,
 163   OLD_LINE_FORMAT_OPTION,
 164   NEW_LINE_FORMAT_OPTION,
 165
 166   /* These options must be in sequence.  */
 167   UNCHANGED_GROUP_FORMAT_OPTION,
 168   OLD_GROUP_FORMAT_OPTION,
 169   NEW_GROUP_FORMAT_OPTION,
 170   CHANGED_GROUP_FORMAT_OPTION
 171 };
 172
 173 static char const group_format_option[][sizeof "--unchanged-group-format"] =
 174   {
 175     "--unchanged-group-format",
 176     "--old-group-format",
 177     "--new-group-format",
 178     "--changed-group-format"
 179   };
 180
 181 static char const line_format_option[][sizeof "--unchanged-line-format"] =
 182   {
 183     "--unchanged-line-format",
 184     "--old-line-format",
 185     "--new-line-format"
 186   };
 187
 188 static struct option const longopts[] =
 189 {
 190   {"binary", 0, 0, BINARY_OPTION},
 191   {"brief", 0, 0, 'q'},
 192   {"changed-group-format", 1, 0, CHANGED_GROUP_FORMAT_OPTION},
 193   {"context", 2, 0, 'C'},
 194   {"ed", 0, 0, 'e'},
 195   {"exclude", 1, 0, 'x'},
 196   {"exclude-from", 1, 0, 'X'},
 197   {"expand-tabs", 0, 0, 't'},
 198   {"forward-ed", 0, 0, 'f'},
 199   {"from-file", 1, 0, FROM_FILE_OPTION},
 200   {"help", 0, 0, HELP_OPTION},
 201   {"horizon-lines", 1, 0, HORIZON_LINES_OPTION},
 202   {"ifdef", 1, 0, 'D'},
 203   {"ignore-all-space", 0, 0, 'w'},
 204   {"ignore-blank-lines", 0, 0, 'B'},
 205   {"ignore-case", 0, 0, 'i'},
 206   {"ignore-file-name-case", 0, 0, IGNORE_FILE_NAME_CASE_OPTION},
 207   {"ignore-matching-lines", 1, 0, 'I'},
 208   {"ignore-space-change", 0, 0, 'b'},
 209   {"ignore-tab-expansion", 0, 0, 'E'},
 210   {"inhibit-hunk-merge", 0, 0, INHIBIT_HUNK_MERGE_OPTION},
 211   {"initial-tab", 0, 0, 'T'},
 212   {"label", 1, 0, 'L'},
 213   {"left-column", 0, 0, LEFT_COLUMN_OPTION},
 214   {"line-format", 1, 0, LINE_FORMAT_OPTION},
 215   {"minimal", 0, 0, 'd'},
 216   {"new-file", 0, 0, 'N'},
 217   {"new-group-format", 1, 0, NEW_GROUP_FORMAT_OPTION},
 218   {"new-line-format", 1, 0, NEW_LINE_FORMAT_OPTION},
 219   {"no-ignore-file-name-case", 0, 0, NO_IGNORE_FILE_NAME_CASE_OPTION},
 220   {"normal", 0, 0, NORMAL_OPTION},
 221   {"old-group-format", 1, 0, OLD_GROUP_FORMAT_OPTION},
 222   {"old-line-format", 1, 0, OLD_LINE_FORMAT_OPTION},
 223   {"paginate", 0, 0, 'l'},
 224   {"rcs", 0, 0, 'n'},
 225   {"recursive", 0, 0, 'r'},
 226   {"report-identical-files", 0, 0, 's'},
 227   {"sdiff-merge-assist", 0, 0, SDIFF_MERGE_ASSIST_OPTION},
 228   {"show-c-function", 0, 0, 'p'},
 229   {"show-function-line", 1, 0, 'F'},
 230   {"side-by-side", 0, 0, 'y'},
 231   {"speed-large-files", 0, 0, 'H'},
 232   {"starting-file", 1, 0, 'S'},
 233   {"strip-trailing-cr", 0, 0, STRIP_TRAILING_CR_OPTION},
 234   {"suppress-common-lines", 0, 0, SUPPRESS_COMMON_LINES_OPTION},
 235   {"tabsize", 1, 0, TABSIZE_OPTION},
 236   {"text", 0, 0, 'a'},
 237   {"to-file", 1, 0, TO_FILE_OPTION},
 238   {"unchanged-group-format", 1, 0, UNCHANGED_GROUP_FORMAT_OPTION},
 239   {"unchanged-line-format", 1, 0, UNCHANGED_LINE_FORMAT_OPTION},
 240   {"unidirectional-new-file", 0, 0, 'P'},
 241   {"unified", 2, 0, 'U'},
 242   {"version", 0, 0, 'v'},
 243   {"width", 1, 0, 'W'},
 244   {0, 0, 0, 0}
 245 };
 246
 247 int
 248 main (int argc, char **argv)
 249 {
 250   int exit_status = EXIT_SUCCESS;
 251   int c;
 252   int i;
 253   int prev = -1;
 254   lin ocontext = -1;
 255   bool explicit_context = false;
 256   size_t width = 0;
 257   bool show_c_function = false;
 258   char const *from_file = 0;
 259   char const *to_file = 0;
 260   uintmax_t numval;
 261   char *numend;
 262
 263   /* Do our initializations.  */
 264   exit_failure = 2;
 265   initialize_main (&argc, &argv);
 266   program_name = argv[0];
 267   setlocale (LC_ALL, "");
 268   bindtextdomain (PACKAGE, LOCALEDIR);
 269   textdomain (PACKAGE);
 270   c_stack_action (0);
 271   function_regexp_list.buf = &function_regexp;
 272   ignore_regexp_list.buf = &ignore_regexp;
 273   re_set_syntax (RE_SYNTAX_GREP | RE_NO_POSIX_BACKTRACKING);
 274   excluded = new_exclude ();
 275
 276   /* Decode the options.  */
 277
 278   while ((c = getopt_long (argc, argv, shortopts, longopts, 0)) != -1)
 279     {
 280       switch (c)
 281         {
 282         case 0:
 283           break;
 284
 285         case '0':
 286         case '1':
 287         case '2':
 288         case '3':
 289         case '4':
 290         case '5':
 291         case '6':
 292         case '7':
 293         case '8':
 294         case '9':
 295           if (! ISDIGIT (prev))
 296             ocontext = c - '0';
 297           else if (LIN_MAX / 10 < ocontext
 298                    || ((ocontext = 10 * ocontext + c - '0') < 0))
 299             ocontext = LIN_MAX;
 300           break;
 301
 302         case 'a':
 303           text = true;
 304           break;
 305
 306         case 'b':
 307           if (ignore_white_space < IGNORE_SPACE_CHANGE)
 308             ignore_white_space = IGNORE_SPACE_CHANGE;
 309           break;
 310
 311         case 'B':
 312           ignore_blank_lines = true;
 313           break;
 314
 315         case 'C':
 316         case 'U':
 317           {
 318             if (optarg)
 319               {
 320                 numval = strtoumax (optarg, &numend, 10);
 321                 if (*numend)
 322                   try_help ("invalid context length `%s'", optarg);
 323                 if (LIN_MAX < numval)
 324                   numval = LIN_MAX;
 325               }
 326             else
 327               numval = 3;
 328
 329             specify_style (c == 'U' ? OUTPUT_UNIFIED : OUTPUT_CONTEXT);
 330             if (context < numval)
 331               context = numval;
 332             explicit_context = true;
 333           }
 334           break;
 335
 336         case 'c':
 337           specify_style (OUTPUT_CONTEXT);
 338           if (context < 3)
 339             context = 3;
 340           break;
 341
 342         case 'd':
 343           minimal = true;
 344           break;
 345
 346         case 'D':
 347           specify_style (OUTPUT_IFDEF);
 348           {
 349             static char const C_ifdef_group_formats[] =
 350               "%%=%c#ifndef %s\n%%<#endif /* ! %s */\n%c#ifdef %s\n%%>#endif /* %s */\n%c#ifndef %s\n%%<#else /* %s */\n%%>#endif /* %s */\n";
 351             char *b = xmalloc (sizeof C_ifdef_group_formats
 352                                + 7 * strlen (optarg) - 14 /* 7*"%s" */
 353                                - 8 /* 5*"%%" + 3*"%c" */);
 354             sprintf (b, C_ifdef_group_formats,
 355                      0,
 356                      optarg, optarg, 0,
 357                      optarg, optarg, 0,
 358                      optarg, optarg, optarg);
 359             for (i = 0; i < sizeof group_format / sizeof *group_format; i++)
 360               {
 361                 specify_value (&group_format[i], b, "-D");
 362                 b += strlen (b) + 1;
 363               }
 364           }
 365           break;
 366
 367         case 'e':
 368           specify_style (OUTPUT_ED);
 369           break;
 370
 371         case 'E':
 372           if (ignore_white_space < IGNORE_TAB_EXPANSION)
 373             ignore_white_space = IGNORE_TAB_EXPANSION;
 374           break;
 375
 376         case 'f':
 377           specify_style (OUTPUT_FORWARD_ED);
 378           break;
 379
 380         case 'F':
 381           add_regexp (&function_regexp_list, optarg);
 382           break;
 383
 384         case 'h':
 385           /* Split the files into chunks for faster processing.
 386              Usually does not change the result.
 387
 388              This currently has no effect.  */
 389           break;
 390
 391         case 'H':
 392           speed_large_files = true;
 393           break;
 394
 395         case 'i':
 396           ignore_case = true;
 397           break;
 398
 399         case 'I':
 400           add_regexp (&ignore_regexp_list, optarg);
 401           break;
 402
 403         case 'l':
 404           if (!pr_program[0])
 405             try_help ("pagination not supported on this host", 0);
 406           paginate = true;
 407 #ifdef SIGCHLD
 408           /* Pagination requires forking and waiting, and
 409              System V fork+wait does not work if SIGCHLD is ignored.  */
 410           signal (SIGCHLD, SIG_DFL);
 411 #endif
 412           break;
 413
 414         case 'L':
 415           if (!file_label[0])
 416             file_label[0] = optarg;
 417           else if (!file_label[1])
 418             file_label[1] = optarg;
 419           else
 420             fatal ("too many file label options");
 421           break;
 422
 423         case 'n':
 424           specify_style (OUTPUT_RCS);
 425           break;
 426
 427         case 'N':
 428           new_file = true;
 429           break;
 430
 431         case 'p':
 432           show_c_function = true;
 433           add_regexp (&function_regexp_list, "^[[:alpha:]$_]");
 434           break;
 435
 436         case 'P':
 437           unidirectional_new_file = true;
 438           break;
 439
 440         case 'q':
 441           brief = true;
 442           break;
 443
 444         case 'r':
 445           recursive = true;
 446           break;
 447
 448         case 's':
 449           report_identical_files = true;
 450           break;
 451
 452         case 'S':
 453           specify_value (&starting_file, optarg, "-S");
 454           break;
 455
 456         case 't':
 457           expand_tabs = true;
 458           break;
 459
 460         case 'T':
 461           initial_tab = true;
 462           break;
 463
 464         case 'u':
 465           specify_style (OUTPUT_UNIFIED);
 466           if (context < 3)
 467             context = 3;
 468           break;
 469
 470         case 'v':
 471           version_etc (stdout, "diff", PACKAGE_NAME, PACKAGE_VERSION,
 472                        "Paul Eggert", "Mike Haertel", "David Hayes",
 473                        "Richard Stallman", "Len Tower", (char *) 0);
 474           check_stdout ();
 475           return EXIT_SUCCESS;
 476
 477         case 'w':
 478           ignore_white_space = IGNORE_ALL_SPACE;
 479           break;
 480
 481         case 'x':
 482           add_exclude (excluded, optarg, exclude_options ());
 483           break;
 484
 485         case 'X':
 486           if (add_exclude_file (add_exclude, excluded, optarg,
 487                                 exclude_options (), '\n'))
 488             pfatal_with_name (optarg);
 489           break;
 490
 491         case 'y':
 492           specify_style (OUTPUT_SDIFF);
 493           break;
 494
 495         case 'W':
 496           numval = strtoumax (optarg, &numend, 10);
 497           if (! (0 < numval && numval <= SIZE_MAX) || *numend)
 498             try_help ("invalid width `%s'", optarg);
 499           if (width != numval)
 500             {
 501               if (width)
 502                 fatal ("conflicting width options");
 503               width = numval;
 504             }
 505           break;
 506
 507         case BINARY_OPTION:
 508 #if HAVE_SETMODE_DOS
 509           binary = true;
 510           set_binary_mode (STDOUT_FILENO, true);
 511 #endif
 512           break;
 513
 514         case FROM_FILE_OPTION:
 515           specify_value (&from_file, optarg, "--from-file");
 516           break;
 517
 518         case HELP_OPTION:
 519           usage ();
 520           check_stdout ();
 521           return EXIT_SUCCESS;
 522
 523         case HORIZON_LINES_OPTION:
 524           numval = strtoumax (optarg, &numend, 10);
 525           if (*numend)
 526             try_help ("invalid horizon length `%s'", optarg);
 527           horizon_lines = MAX (horizon_lines, MIN (numval, LIN_MAX));
 528           break;
 529
 530         case IGNORE_FILE_NAME_CASE_OPTION:
 531           ignore_file_name_case = true;
 532           break;
 533
 534         case INHIBIT_HUNK_MERGE_OPTION:
 535           /* This option is obsolete, but accept it for backward
 536              compatibility.  */
 537           break;
 538
 539         case LEFT_COLUMN_OPTION:
 540           left_column = true;
 541           break;
 542
 543         case LINE_FORMAT_OPTION:
 544           specify_style (OUTPUT_IFDEF);
 545           for (i = 0; i < sizeof line_format / sizeof *line_format; i++)
 546             specify_value (&line_format[i], optarg, "--line-format");
 547           break;
 548
 549         case NO_IGNORE_FILE_NAME_CASE_OPTION:
 550           ignore_file_name_case = false;
 551           break;
 552
 553         case NORMAL_OPTION:
 554           specify_style (OUTPUT_NORMAL);
 555           break;
 556
 557         case SDIFF_MERGE_ASSIST_OPTION:
 558           specify_style (OUTPUT_SDIFF);
 559           sdiff_merge_assist = true;
 560           break;
 561
 562         case STRIP_TRAILING_CR_OPTION:
 563           strip_trailing_cr = true;
 564           break;
 565
 566         case SUPPRESS_COMMON_LINES_OPTION:
 567           suppress_common_lines = true;
 568           break;
 569
 570         case TABSIZE_OPTION:
 571           numval = strtoumax (optarg, &numend, 10);
 572           if (! (0 < numval && numval <= SIZE_MAX) || *numend)
 573             try_help ("invalid tabsize `%s'", optarg);
 574           if (tabsize != numval)
 575             {
 576               if (tabsize)
 577                 fatal ("conflicting tabsize options");
 578               tabsize = numval;
 579             }
 580           break;
 581
 582         case TO_FILE_OPTION:
 583           specify_value (&to_file, optarg, "--to-file");
 584           break;
 585
 586         case UNCHANGED_LINE_FORMAT_OPTION:
 587         case OLD_LINE_FORMAT_OPTION:
 588         case NEW_LINE_FORMAT_OPTION:
 589           specify_style (OUTPUT_IFDEF);
 590           c -= UNCHANGED_LINE_FORMAT_OPTION;
 591           specify_value (&line_format[c], optarg, line_format_option[c]);
 592           break;
 593
 594         case UNCHANGED_GROUP_FORMAT_OPTION:
 595         case OLD_GROUP_FORMAT_OPTION:
 596         case NEW_GROUP_FORMAT_OPTION:
 597         case CHANGED_GROUP_FORMAT_OPTION:
 598           specify_style (OUTPUT_IFDEF);
 599           c -= UNCHANGED_GROUP_FORMAT_OPTION;
 600           specify_value (&group_format[c], optarg, group_format_option[c]);
 601           break;
 602
 603         default:
 604           try_help (0, 0);
 605         }
 606       prev = c;
 607     }
 608
 609   if (output_style == OUTPUT_UNSPECIFIED)
 610     {
 611       if (show_c_function)
 612         {
 613           specify_style (OUTPUT_CONTEXT);
 614           if (ocontext < 0)
 615             context = 3;
 616         }
 617       else
 618         specify_style (OUTPUT_NORMAL);
 619     }
 620
 621   if (output_style != OUTPUT_CONTEXT || hard_locale (LC_TIME))
 622     {
 623 #ifdef ST_MTIM_NSEC
 624       time_format = "%Y-%m-%d %H:%M:%S.%N %z";
 625 #else
 626       time_format = "%Y-%m-%d %H:%M:%S %z";
 627 #endif
 628     }
 629   else
 630     {
 631       /* See POSIX 1003.1-2001 for this format.  */
 632       time_format = "%a %b %e %T %Y";
 633     }
 634
 635   if (0 <= ocontext)
 636     {
 637       bool modern_usage = 200112 <= posix2_version ();
 638
 639       if ((output_style == OUTPUT_CONTEXT
 640            || output_style == OUTPUT_UNIFIED)
 641           && (context < ocontext
 642               || (ocontext < context && ! explicit_context)))
 643         {
 644           if (modern_usage)
 645             {
 646               error (0, 0,
 647                      _("`-%ld' option is obsolete; use `-%c %ld'"),
 648                      (long int) ocontext,
 649                      output_style == OUTPUT_CONTEXT ? 'C' : 'U',
 650                      (long int) ocontext);
 651               try_help (0, 0);
 652             }
 653           context = ocontext;
 654         }
 655       else
 656         {
 657           if (modern_usage)
 658             {
 659               error (0, 0, _("`-%ld' option is obsolete; omit it"),
 660                      (long int) ocontext);
 661               try_help (0, 0);
 662             }
 663         }
 664     }
 665
 666   if (! tabsize)
 667     tabsize = 8;
 668   if (! width)
 669     width = 130;
 670
 671   {
 672     /* Maximize first the half line width, and then the gutter width,
 673        according to the following constraints:
 674
 675         1.  Two half lines plus a gutter must fit in a line.
 676         2.  If the half line width is nonzero:
 677             a.  The gutter width is at least GUTTER_WIDTH_MINIMUM.
 678             b.  If tabs are not expanded to spaces,
 679                 a half line plus a gutter is an integral number of tabs,
 680                 so that tabs in the right column line up.  */
 681
 682     intmax_t t = expand_tabs ? 1 : tabsize;
 683     intmax_t w = width;
 684     intmax_t off = (w + t + GUTTER_WIDTH_MINIMUM) / (2 * t)  *  t;
 685     sdiff_half_width = MAX (0, MIN (off - GUTTER_WIDTH_MINIMUM, w - off)),
 686     sdiff_column2_offset = sdiff_half_width ? off : w;
 687   }
 688
 689   /* Make the horizon at least as large as the context, so that
 690      shift_boundaries has more freedom to shift the first and last hunks.  */
 691   if (horizon_lines < context)
 692     horizon_lines = context;
 693
 694   summarize_regexp_list (&function_regexp_list);
 695   summarize_regexp_list (&ignore_regexp_list);
 696
 697   if (output_style == OUTPUT_IFDEF)
 698     {
 699       for (i = 0; i < sizeof line_format / sizeof *line_format; i++)
 700         if (!line_format[i])
 701           line_format[i] = "%l\n";
 702       if (!group_format[OLD])
 703         group_format[OLD]
 704           = group_format[CHANGED] ? group_format[CHANGED] : "%<";
 705       if (!group_format[NEW])
 706         group_format[NEW]
 707           = group_format[CHANGED] ? group_format[CHANGED] : "%>";
 708       if (!group_format[UNCHANGED])
 709         group_format[UNCHANGED] = "%=";
 710       if (!group_format[CHANGED])
 711         group_format[CHANGED] = concat (group_format[OLD],
 712                                         group_format[NEW], "");
 713     }
 714
 715   no_diff_means_no_output =
 716     (output_style == OUTPUT_IFDEF ?
 717       (!*group_format[UNCHANGED]
 718        || (strcmp (group_format[UNCHANGED], "%=") == 0
 719            && !*line_format[UNCHANGED]))
 720      : (output_style != OUTPUT_SDIFF) | suppress_common_lines);
 721
 722   files_can_be_treated_as_binary =
 723     (brief & binary
 724      & ~ (ignore_blank_lines | ignore_case | strip_trailing_cr
 725           | (ignore_regexp_list.regexps || ignore_white_space)));
 726
 727   switch_string = option_list (argv + 1, optind - 1);
 728
 729   if (from_file)
 730     {
 731       if (to_file)
 732         fatal ("--from-file and --to-file both specified");
 733       else
 734         for (; optind < argc; optind++)
 735           {
 736             int status = compare_files ((struct comparison *) 0,
 737                                         from_file, argv[optind]);
 738             if (exit_status < status)
 739               exit_status = status;
 740           }
 741     }
 742   else
 743     {
 744       if (to_file)
 745         for (; optind < argc; optind++)
 746           {
 747             int status = compare_files ((struct comparison *) 0,
 748                                         argv[optind], to_file);
 749             if (exit_status < status)
 750               exit_status = status;
 751           }
 752       else
 753         {
 754           if (argc - optind != 2)
 755             {
 756               if (argc - optind < 2)
 757                 try_help ("missing operand after `%s'", argv[argc - 1]);
 758               else
 759                 try_help ("extra operand `%s'", argv[optind + 2]);
 760             }
 761
 762           exit_status = compare_files ((struct comparison *) 0,
 763                                        argv[optind], argv[optind + 1]);
 764         }
 765     }
 766
 767   /* Print any messages that were saved up for last.  */
 768   print_message_queue ();
 769
 770   check_stdout ();
 771   exit (exit_status);
 772   return exit_status;
 773 }
 774
 775 /* Append to REGLIST the regexp PATTERN.  */
 776
 777 static void
 778 add_regexp (struct regexp_list *reglist, char const *pattern)
 779 {
 780   size_t patlen = strlen (pattern);
 781   char const *m = re_compile_pattern (pattern, patlen, reglist->buf);
 782
 783   if (m != 0)
 784     error (0, 0, "%s: %s", pattern, m);
 785   else
 786     {
 787       char *regexps = reglist->regexps;
 788       size_t len = reglist->len;
 789       bool multiple_regexps = reglist->multiple_regexps = regexps != 0;
 790       size_t newlen = reglist->len = len + 2 * multiple_regexps + patlen;
 791       size_t size = reglist->size;
 792
 793       if (size <= newlen)
 794         {
 795           if (!size)
 796             size = 1;
 797
 798           do size *= 2;
 799           while (size <= newlen);
 800
 801           reglist->size = size;
 802           reglist->regexps = regexps = xrealloc (regexps, size);
 803         }
 804       if (multiple_regexps)
 805         {
 806           regexps[len++] = '\\';
 807           regexps[len++] = '|';
 808         }
 809       memcpy (regexps + len, pattern, patlen + 1);
 810     }
 811 }
 812
 813 /* Ensure that REGLIST represents the disjunction of its regexps.
 814    This is done here, rather than earlier, to avoid O(N^2) behavior.  */
 815
 816 static void
 817 summarize_regexp_list (struct regexp_list *reglist)
 818 {
 819   if (reglist->regexps)
 820     {
 821       /* At least one regexp was specified.  Allocate a fastmap for it.  */
 822       reglist->buf->fastmap = xmalloc (1 << CHAR_BIT);
 823       if (reglist->multiple_regexps)
 824         {
 825           /* Compile the disjunction of the regexps.
 826              (If just one regexp was specified, it is already compiled.)  */
 827           char const *m = re_compile_pattern (reglist->regexps, reglist->len,
 828                                               reglist->buf);
 829           if (m != 0)
 830             error (EXIT_TROUBLE, 0, "%s: %s", reglist->regexps, m);
 831         }
 832     }
 833 }
 834
 835 static void
 836 try_help (char const *reason_msgid, char const *operand)
 837 {
 838   if (reason_msgid)
 839     error (0, 0, _(reason_msgid), operand);
 840   error (EXIT_TROUBLE, 0, _("Try `%s --help' for more information."),
 841          program_name);
 842   abort ();
 843 }
 844
 845 static void
 846 check_stdout (void)
 847 {
 848   if (ferror (stdout))
 849     fatal ("write failed");
 850   else if (fclose (stdout) != 0)
 851     pfatal_with_name (_("standard output"));
 852 }
 853
 854 static char const * const option_help_msgid[] = {
 855   N_("Compare files line by line."),
 856   "",
 857   N_("-i  --ignore-case  Ignore case differences in file contents."),
 858   N_("--ignore-file-name-case  Ignore case when comparing file names."),
 859   N_("--no-ignore-file-name-case  Consider case when comparing file names."),
 860   N_("-E  --ignore-tab-expansion  Ignore changes due to tab expansion."),
 861   N_("-b  --ignore-space-change  Ignore changes in the amount of white space."),
 862   N_("-w  --ignore-all-space  Ignore all white space."),
 863   N_("-B  --ignore-blank-lines  Ignore changes whose lines are all blank."),
 864   N_("-I RE  --ignore-matching-lines=RE  Ignore changes whose lines all match RE."),
 865   N_("--strip-trailing-cr  Strip trailing carriage return on input."),
 866 #if HAVE_SETMODE_DOS
 867   N_("--binary  Read and write data in binary mode."),
 868 #endif
 869   N_("-a  --text  Treat all files as text."),
 870   "",
 871   N_("-c  -C NUM  --context[=NUM]  Output NUM (default 3) lines of copied context.\n\
 872 -u  -U NUM  --unified[=NUM]  Output NUM (default 3) lines of unified context.\n\
 873   --label LABEL  Use LABEL instead of file name.\n\
 874   -p  --show-c-function  Show which C function each change is in.\n\
 875   -F RE  --show-function-line=RE  Show the most recent line matching RE."),
 876   N_("-q  --brief  Output only whether files differ."),
 877   N_("-e  --ed  Output an ed script."),
 878   N_("--normal  Output a normal diff."),
 879   N_("-n  --rcs  Output an RCS format diff."),
 880   N_("-y  --side-by-side  Output in two columns.\n\
 881   -W NUM  --width=NUM  Output at most NUM (default 130) print columns.\n\
 882   --left-column  Output only the left column of common lines.\n\
 883   --suppress-common-lines  Do not output common lines."),
 884   N_("-D NAME  --ifdef=NAME  Output merged file to show `#ifdef NAME' diffs."),
 885   N_("--GTYPE-group-format=GFMT  Similar, but format GTYPE input groups with GFMT."),
 886   N_("--line-format=LFMT  Similar, but format all input lines with LFMT."),
 887   N_("--LTYPE-line-format=LFMT  Similar, but format LTYPE input lines with LFMT."),
 888   N_("  LTYPE is `old', `new', or `unchanged'.  GTYPE is LTYPE or `changed'."),
 889   N_("  GFMT may contain:\n\
 890     %<  lines from FILE1\n\
 891     %>  lines from FILE2\n\
 892     %=  lines common to FILE1 and FILE2\n\
 893     %[-][WIDTH][.[PREC]]{doxX}LETTER  printf-style spec for LETTER\n\
 894       LETTERs are as follows for new group, lower case for old group:\n\
 895         F  first line number\n\
 896         L  last line number\n\
 897         N  number of lines = L-F+1\n\
 898         E  F-1\n\
 899         M  L+1"),
 900   N_("  LFMT may contain:\n\
 901     %L  contents of line\n\
 902     %l  contents of line, excluding any trailing newline\n\
 903     %[-][WIDTH][.[PREC]]{doxX}n  printf-style spec for input line number"),
 904   N_("  Either GFMT or LFMT may contain:\n\
 905     %%  %\n\
 906     %c'C'  the single character C\n\
 907     %c'\\OOO'  the character with octal code OOO"),
 908   "",
 909   N_("-l  --paginate  Pass the output through `pr' to paginate it."),
 910   N_("-t  --expand-tabs  Expand tabs to spaces in output."),
 911   N_("-T  --initial-tab  Make tabs line up by prepending a tab."),
 912   N_("--tabsize=NUM  Tab stops are every NUM (default 8) print columns."),
 913   "",
 914   N_("-r  --recursive  Recursively compare any subdirectories found."),
 915   N_("-N  --new-file  Treat absent files as empty."),
 916   N_("--unidirectional-new-file  Treat absent first files as empty."),
 917   N_("-s  --report-identical-files  Report when two files are the same."),
 918   N_("-x PAT  --exclude=PAT  Exclude files that match PAT."),
 919   N_("-X FILE  --exclude-from=FILE  Exclude files that match any pattern in FILE."),
 920   N_("-S FILE  --starting-file=FILE  Start with FILE when comparing directories."),
 921   N_("--from-file=FILE1  Compare FILE1 to all operands.  FILE1 can be a directory."),
 922   N_("--to-file=FILE2  Compare all operands to FILE2.  FILE2 can be a directory."),
 923   "",
 924   N_("--horizon-lines=NUM  Keep NUM lines of the common prefix and suffix."),
 925   N_("-d  --minimal  Try hard to find a smaller set of changes."),
 926   N_("--speed-large-files  Assume large files and many scattered small changes."),
 927   "",
 928   N_("-v  --version  Output version info."),
 929   N_("--help  Output this help."),
 930   "",
 931   N_("FILES are `FILE1 FILE2' or `DIR1 DIR2' or `DIR FILE...' or `FILE... DIR'."),
 932   N_("If --from-file or --to-file is given, there are no restrictions on FILES."),
 933   N_("If a FILE is `-', read standard input."),
 934   N_("Exit status is 0 if inputs are the same, 1 if different, 2 if trouble."),
 935   "",
 936   N_("Report bugs to <bug-gnu-utils@gnu.org>."),
 937   0
 938 };
 939
 940 static void
 941 usage (void)
 942 {
 943   char const * const *p;
 944
 945   printf (_("Usage: %s [OPTION]... FILES\n"), program_name);
 946
 947   for (p = option_help_msgid;  *p;  p++)
 948     {
 949       if (!**p)
 950         putchar ('\n');
 951       else
 952         {
 953           char const *msg = _(*p);
 954           char const *nl;
 955           while ((nl = strchr (msg, '\n')))
 956             {
 957               int msglen = nl + 1 - msg;
 958               printf ("  %.*s", msglen, msg);
 959               msg = nl + 1;
 960             }
 961
 962           printf ("  %s\n" + 2 * (*msg != ' ' && *msg != '-'), msg);
 963         }
 964     }
 965 }
 966
 967 /* Set VAR to VALUE, reporting an OPTION error if this is a
 968    conflict.  */
 969 static void
 970 specify_value (char const **var, char const *value, char const *option)
 971 {
 972   if (*var && strcmp (*var, value) != 0)
 973     {
 974       error (0, 0, _("conflicting %s option value `%s'"), option, value);
 975       try_help (0, 0);
 976     }
 977   *var = value;
 978 }
 979
 980 /* Set the output style to STYLE, diagnosing conflicts.  */
 981 static void
 982 specify_style (enum output_style style)
 983 {
 984   if (output_style != style)
 985     {
 986       if (output_style != OUTPUT_UNSPECIFIED)
 987         try_help ("conflicting output style options", 0);
 988       output_style = style;
 989     }
 990 }
 991 \f
 992 /* Set the last-modified time of *ST to be the current time.  */
 993
 994 static void
 995 set_mtime_to_now (struct stat *st)
 996 {
 997 #ifdef ST_MTIM_NSEC
 998
 999 # if HAVE_CLOCK_GETTIME && defined CLOCK_REALTIME
1000   if (clock_gettime (CLOCK_REALTIME, &st->st_mtim) == 0)
1001     return;
1002 # endif
1003
1004 # if HAVE_GETTIMEOFDAY
1005   {
1006     struct timeval timeval;
1007     if (gettimeofday (&timeval, 0) == 0)
1008       {
1009         st->st_mtime = timeval.tv_sec;
1010         st->st_mtim.ST_MTIM_NSEC = timeval.tv_usec * 1000;
1011         return;
1012       }
1013   }
1014 # endif
1015
1016 #endif /* ST_MTIM_NSEC */
1017
1018   time (&st->st_mtime);
1019 }
1020 \f
1021 /* Compare two files (or dirs) with parent comparison PARENT
1022    and names NAME0 and NAME1.
1023    (If PARENT is 0, then the first name is just NAME0, etc.)
1024    This is self-contained; it opens the files and closes them.
1025
1026    Value is EXIT_SUCCESS if files are the same, EXIT_FAILURE if
1027    different, EXIT_TROUBLE if there is a problem opening them.  */
1028
1029 static int
1030 compare_files (struct comparison const *parent,
1031                char const *name0,
1032                char const *name1)
1033 {
1034   struct comparison cmp;
1035 #define DIR_P(f) (S_ISDIR (cmp.file[f].stat.st_mode) != 0)
1036   register int f;
1037   int status = EXIT_SUCCESS;
1038   bool same_files;
1039   char *free0, *free1;
1040
1041   /* If this is directory comparison, perhaps we have a file
1042      that exists only in one of the directories.
1043      If so, just print a message to that effect.  */
1044
1045   if (! ((name0 && name1)
1046          || (unidirectional_new_file && name1)
1047          || new_file))
1048     {
1049       char const *name = name0 == 0 ? name1 : name0;
1050       char const *dir = parent->file[name0 == 0].name;
1051
1052       /* See POSIX 1003.1-2001 for this format.  */
1053       message ("Only in %s: %s\n", dir, name);
1054
1055       /* Return EXIT_FAILURE so that diff_dirs will return
1056          EXIT_FAILURE ("some files differ").  */
1057       return EXIT_FAILURE;
1058     }
1059
1060   memset (cmp.file, 0, sizeof cmp.file);
1061   cmp.parent = parent;
1062
1063   /* cmp.file[f].desc markers */
1064 #define NONEXISTENT (-1) /* nonexistent file */
1065 #define UNOPENED (-2) /* unopened file (e.g. directory) */
1066 #define ERRNO_ENCODE(errno) (-3 - (errno)) /* encoded errno value */
1067
1068 #define ERRNO_DECODE(desc) (-3 - (desc)) /* inverse of ERRNO_ENCODE */
1069
1070   cmp.file[0].desc = name0 == 0 ? NONEXISTENT : UNOPENED;
1071   cmp.file[1].desc = name1 == 0 ? NONEXISTENT : UNOPENED;
1072
1073   /* Now record the full name of each file, including nonexistent ones.  */
1074
1075   if (name0 == 0)
1076     name0 = name1;
1077   if (name1 == 0)
1078     name1 = name0;
1079
1080   if (!parent)
1081     {
1082       free0 = 0;
1083       free1 = 0;
1084       cmp.file[0].name = name0;
1085       cmp.file[1].name = name1;
1086     }
1087   else
1088     {
1089       cmp.file[0].name = free0
1090         = dir_file_pathname (parent->file[0].name, name0);
1091       cmp.file[1].name = free1
1092         = dir_file_pathname (parent->file[1].name, name1);
1093     }
1094
1095   /* Stat the files.  */
1096
1097   for (f = 0; f < 2; f++)
1098     {
1099       if (cmp.file[f].desc != NONEXISTENT)
1100         {
1101           if (f && file_name_cmp (cmp.file[f].name, cmp.file[0].name) == 0)
1102             {
1103               cmp.file[f].desc = cmp.file[0].desc;
1104               cmp.file[f].stat = cmp.file[0].stat;
1105             }
1106           else if (strcmp (cmp.file[f].name, "-") == 0)
1107             {
1108               cmp.file[f].desc = STDIN_FILENO;
1109               if (fstat (STDIN_FILENO, &cmp.file[f].stat) != 0)
1110                 cmp.file[f].desc = ERRNO_ENCODE (errno);
1111               else
1112                 {
1113                   if (S_ISREG (cmp.file[f].stat.st_mode))
1114                     {
1115                       off_t pos = lseek (STDIN_FILENO, (off_t) 0, SEEK_CUR);
1116                       if (pos < 0)
1117                         cmp.file[f].desc = ERRNO_ENCODE (errno);
1118                       else
1119                         cmp.file[f].stat.st_size =
1120                           MAX (0, cmp.file[f].stat.st_size - pos);
1121                     }
1122
1123                   /* POSIX 1003.1-2001 requires current time for
1124                      stdin.  */
1125                   set_mtime_to_now (&cmp.file[f].stat);
1126                 }
1127             }
1128           else if (stat (cmp.file[f].name, &cmp.file[f].stat) != 0)
1129             cmp.file[f].desc = ERRNO_ENCODE (errno);
1130         }
1131     }
1132
1133   /* Mark files as nonexistent as needed for -N and -P, if they are
1134      inaccessible empty regular files (the kind of files that 'patch'
1135      creates to indicate nonexistent backups), or if they are
1136      top-level files that do not exist but their counterparts do
1137      exist.  */
1138   for (f = 0; f < 2; f++)
1139     if ((new_file || (f == 0 && unidirectional_new_file))
1140         && (cmp.file[f].desc == UNOPENED
1141             ? (S_ISREG (cmp.file[f].stat.st_mode)
1142                && ! (cmp.file[f].stat.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO))
1143                && cmp.file[f].stat.st_size == 0)
1144             : (cmp.file[f].desc == ERRNO_ENCODE (ENOENT)
1145                && ! parent
1146                && cmp.file[1 - f].desc == UNOPENED)))
1147       cmp.file[f].desc = NONEXISTENT;
1148
1149   for (f = 0; f < 2; f++)
1150     if (cmp.file[f].desc == NONEXISTENT)
1151       {
1152         memset (&cmp.file[f].stat, 0, sizeof cmp.file[f].stat);
1153         cmp.file[f].stat.st_mode = cmp.file[1 - f].stat.st_mode;
1154       }
1155
1156   for (f = 0; f < 2; f++)
1157     {
1158       int e = ERRNO_DECODE (cmp.file[f].desc);
1159       if (0 <= e)
1160         {
1161           errno = e;
1162           perror_with_name (cmp.file[f].name);
1163           status = EXIT_TROUBLE;
1164         }
1165     }
1166
1167   if (status == EXIT_SUCCESS && ! parent && DIR_P (0) != DIR_P (1))
1168     {
1169       /* If one is a directory, and it was specified in the command line,
1170          use the file in that dir with the other file's basename.  */
1171
1172       int fnm_arg = DIR_P (0);
1173       int dir_arg = 1 - fnm_arg;
1174       char const *fnm = cmp.file[fnm_arg].name;
1175       char const *dir = cmp.file[dir_arg].name;
1176       char const *filename = cmp.file[dir_arg].name = free0
1177         = dir_file_pathname (dir, base_name (fnm));
1178
1179       if (strcmp (fnm, "-") == 0)
1180         fatal ("cannot compare `-' to a directory");
1181
1182       if (stat (filename, &cmp.file[dir_arg].stat) != 0)
1183         {
1184           perror_with_name (filename);
1185           status = EXIT_TROUBLE;
1186         }
1187     }
1188
1189   if (status != EXIT_SUCCESS)
1190     {
1191       /* One of the files should exist but does not.  */
1192     }
1193   else if (cmp.file[0].desc == NONEXISTENT
1194            && cmp.file[1].desc == NONEXISTENT)
1195     {
1196       /* Neither file "exists", so there's nothing to compare.  */
1197     }
1198   else if ((same_files
1199             = (cmp.file[0].desc != NONEXISTENT
1200                && cmp.file[1].desc != NONEXISTENT
1201                && 0 < same_file (&cmp.file[0].stat, &cmp.file[1].stat)
1202                && same_file_attributes (&cmp.file[0].stat,
1203                                         &cmp.file[1].stat)))
1204            && no_diff_means_no_output)
1205     {
1206       /* The two named files are actually the same physical file.
1207          We know they are identical without actually reading them.  */
1208     }
1209   else if (DIR_P (0) & DIR_P (1))
1210     {
1211       if (output_style == OUTPUT_IFDEF)
1212         fatal ("-D option not supported with directories");
1213
1214       /* If both are directories, compare the files in them.  */
1215
1216       if (parent && !recursive)
1217         {
1218           /* But don't compare dir contents one level down
1219              unless -r was specified.
1220              See POSIX 1003.1-2001 for this format.  */
1221           message ("Common subdirectories: %s and %s\n",
1222                    cmp.file[0].name, cmp.file[1].name);
1223         }
1224       else
1225         status = diff_dirs (&cmp, compare_files);
1226     }
1227   else if ((DIR_P (0) | DIR_P (1))
1228            || (parent
1229                && (! S_ISREG (cmp.file[0].stat.st_mode)
1230                    || ! S_ISREG (cmp.file[1].stat.st_mode))))
1231     {
1232       if (cmp.file[0].desc == NONEXISTENT || cmp.file[1].desc == NONEXISTENT)
1233         {
1234           /* We have a subdirectory that exists only in one directory.  */
1235
1236           if ((DIR_P (0) | DIR_P (1))
1237               && recursive
1238               && (new_file
1239                   || (unidirectional_new_file
1240                       && cmp.file[0].desc == NONEXISTENT)))
1241             status = diff_dirs (&cmp, compare_files);
1242           else
1243             {
1244               char const *dir
1245                 = parent->file[cmp.file[0].desc == NONEXISTENT].name;
1246
1247               /* See POSIX 1003.1-2001 for this format.  */
1248               message ("Only in %s: %s\n", dir, name0);
1249
1250               status = EXIT_FAILURE;
1251             }
1252         }
1253       else
1254         {
1255           /* We have two files that are not to be compared.  */
1256
1257           /* See POSIX 1003.1-2001 for this format.  */
1258           message5 ("File %s is a %s while file %s is a %s\n",
1259                     file_label[0] ? file_label[0] : cmp.file[0].name,
1260                     file_type (&cmp.file[0].stat),
1261                     file_label[1] ? file_label[1] : cmp.file[1].name,
1262                     file_type (&cmp.file[1].stat));
1263
1264           /* This is a difference.  */
1265           status = EXIT_FAILURE;
1266         }
1267     }
1268   else if (files_can_be_treated_as_binary
1269            && S_ISREG (cmp.file[0].stat.st_mode)
1270            && S_ISREG (cmp.file[1].stat.st_mode)
1271            && cmp.file[0].stat.st_size != cmp.file[1].stat.st_size)
1272     {
1273       message ("Files %s and %s differ\n",
1274                file_label[0] ? file_label[0] : cmp.file[0].name,
1275                file_label[1] ? file_label[1] : cmp.file[1].name);
1276       status = EXIT_FAILURE;
1277     }
1278   else
1279     {
1280       /* Both exist and neither is a directory.  */
1281
1282       /* Open the files and record their descriptors.  */
1283
1284       if (cmp.file[0].desc == UNOPENED)
1285         if ((cmp.file[0].desc = open (cmp.file[0].name, O_RDONLY, 0)) < 0)
1286           {
1287             perror_with_name (cmp.file[0].name);
1288             status = EXIT_TROUBLE;
1289           }
1290       if (cmp.file[1].desc == UNOPENED)
1291         {
1292           if (same_files)
1293             cmp.file[1].desc = cmp.file[0].desc;
1294           else if ((cmp.file[1].desc = open (cmp.file[1].name, O_RDONLY, 0))
1295                    < 0)
1296             {
1297               perror_with_name (cmp.file[1].name);
1298               status = EXIT_TROUBLE;
1299             }
1300         }
1301
1302 #if HAVE_SETMODE_DOS
1303       if (binary)
1304         for (f = 0; f < 2; f++)
1305           if (0 <= cmp.file[f].desc)
1306             set_binary_mode (cmp.file[f].desc, true);
1307 #endif
1308
1309       /* Compare the files, if no error was found.  */
1310
1311       if (status == EXIT_SUCCESS)
1312         status = diff_2_files (&cmp);
1313
1314       /* Close the file descriptors.  */
1315
1316       if (0 <= cmp.file[0].desc && close (cmp.file[0].desc) != 0)
1317         {
1318           perror_with_name (cmp.file[0].name);
1319           status = EXIT_TROUBLE;
1320         }
1321       if (0 <= cmp.file[1].desc && cmp.file[0].desc != cmp.file[1].desc
1322           && close (cmp.file[1].desc) != 0)
1323         {
1324           perror_with_name (cmp.file[1].name);
1325           status = EXIT_TROUBLE;
1326         }
1327     }
1328
1329   /* Now the comparison has been done, if no error prevented it,
1330      and STATUS is the value this function will return.  */
1331
1332   if (status == EXIT_SUCCESS)
1333     {
1334       if (report_identical_files && !DIR_P (0))
1335         message ("Files %s and %s are identical\n",
1336                  file_label[0] ? file_label[0] : cmp.file[0].name,
1337                  file_label[1] ? file_label[1] : cmp.file[1].name);
1338     }
1339   else
1340     {
1341       /* Flush stdout so that the user sees differences immediately.
1342          This can hurt performance, unfortunately.  */
1343       if (fflush (stdout) != 0)
1344         pfatal_with_name (_("standard output"));
1345     }
1346
1347   if (free0)
1348     free (free0);
1349   if (free1)
1350     free (free1);
1351
1352   return status;
1353 }