home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / zip / gnu / diff115.lzh / DIFF115 / DIFF.C < prev    next >
C/C++ Source or Header  |  1991-01-30  |  19KB  |  704 lines
  1. /* GNU DIFF main routine.
  2.    Copyright (C) 1988, 1989 Free Software Foundation, Inc.
  3.  
  4. This file is part of GNU DIFF.
  5.  
  6. GNU DIFF is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 1, or (at your option)
  9. any later version.
  10.  
  11. GNU DIFF is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GNU DIFF; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. /* GNU DIFF was written by Mike Haertel, David Hayes,
  21.    Richard Stallman and Len Tower.  */
  22.  
  23. #define GDIFF_MAIN
  24. #include "regex.h"
  25. #include "diff.h"
  26. #include "getopt.h"
  27.  
  28.  
  29. /* Nonzero for -r: if comparing two directories,
  30.    compare their common subdirectories recursively.  */
  31.  
  32. int recursive;
  33.  
  34. /* For debugging: don't do discard_confusing_lines.  */
  35.  
  36. int no_discards;
  37.  
  38. /* Return a string containing the command options with which diff was invoked.
  39.    Spaces appear between what were separate ARGV-elements.
  40.    There is a space at the beginning but none at the end.
  41.    If there were no options, the result is an empty string.
  42.  
  43.    Arguments: OPTIONVEC, a vector containing separate ARGV-elements, and COUNT,
  44.    the length of that vector.  */
  45.  
  46. static char *
  47. option_list (optionvec, count)
  48.      char **optionvec;  /* Was `vector', but that collides on Alliant.  */
  49.      int count;
  50. {
  51.   int i;
  52.   int length = 0;
  53.   char *result;
  54.  
  55.   for (i = 0; i < count; i++)
  56.     length += strlen (optionvec[i]) + 1;
  57.  
  58.   result = (char *) xmalloc (length + 1);
  59.   result[0] = 0;
  60.  
  61.   for (i = 0; i < count; i++)
  62.     {
  63.       strcat (result, " ");
  64.       strcat (result, optionvec[i]);
  65.     }
  66.  
  67.   return result;
  68. }
  69.  
  70. /* The numbers 129 and 130 that appear in the fourth element
  71.    for the context and unidiff entries are used as a way of
  72.    telling the big switch in `main' how to process those options.  */
  73.  
  74. static struct option longopts[] =
  75. {
  76.   {"ignore-blank-lines", 0, 0, 'B'},
  77.   {"context", 2, 0, 129},
  78.   {"ifdef", 1, 0, 'D'},
  79.   {"show-function-line", 1, 0, 'F'},
  80.   {"speed-large-files", 0, 0, 'H'},
  81.   {"ignore-matching-lines", 1, 0, 'I'},
  82.   {"file-label", 1, 0, 'L'},
  83.   {"entire-new-files", 0, 0, 'N'},
  84.   {"new-files", 0, 0, 'N'},
  85.   {"starting-file", 1, 0, 'S'},
  86.   {"initial-tab", 0, 0, 'T'},
  87.   {"text", 0, 0, 'a'},
  88.   {"all-text", 0, 0, 'a'},
  89.   {"ascii", 0, 0, 'a'},
  90.   {"ignore-space-change", 0, 0, 'b'},
  91.   {"minimal", 0, 0, 'd'},
  92.   {"ed", 0, 0, 'e'},
  93.   {"reversed-ed", 0, 0, 'f'},
  94.   {"ignore-case", 0, 0, 'i'},
  95.   {"print", 0, 0, 'l'},
  96.   {"rcs", 0, 0, 'n'},
  97.   {"show-c-function", 0, 0, 'p'},
  98.   {"binary", 0, 0, 'q'},
  99.   {"brief", 0, 0, 'q'},
  100.   {"recursive", 0, 0, 'r'},
  101.   {"report-identical-files", 0, 0, 's'},
  102.   {"expand-tabs", 0, 0, 't'},
  103.   {"ignore-all-space", 0, 0, 'w'},
  104.   {"unified", 2, 0, 130},
  105.   {"version", 0, 0, 'v'},
  106.   {0, 0, 0, 0}
  107. };
  108.  
  109. main (argc, argv)
  110.      int argc;
  111.      char *argv[];
  112. {
  113.   int val;
  114.   int c;
  115.   int prev = -1;
  116.   int longind;
  117.   extern char *version_string;
  118.  
  119.   program = argv[0];
  120.  
  121.   /* Do our initializations. */
  122.   output_style = OUTPUT_NORMAL;
  123.   always_text_flag = FALSE;
  124.   ignore_space_change_flag = FALSE;
  125.   ignore_all_space_flag = FALSE;
  126.   length_varies = FALSE;
  127.   ignore_case_flag = FALSE;
  128.   ignore_blank_lines_flag = FALSE;
  129.   ignore_regexp = 0;
  130.   function_regexp = 0;
  131.   print_file_same_flag = FALSE;
  132.   entire_new_file_flag = FALSE;
  133.   no_details_flag = FALSE;
  134.   context = -1;
  135.   line_end_char = '\n';
  136.   tab_align_flag = FALSE;
  137.   tab_expand_flag = FALSE;
  138.   recursive = FALSE;
  139.   paginate_flag = FALSE;
  140.   ifdef_string = NULL;
  141.   heuristic = FALSE;
  142.   dir_start_file = NULL;
  143.   msg_chain = NULL;
  144.   msg_chain_end = NULL;
  145.   no_discards = 0;
  146.  
  147.   /* Decode the options.  */
  148.  
  149.   while ((c = getopt_long (argc, argv,
  150.                "0123456789abBcC:dD:efF:hHiI:lL:nNpqrsS:tTuvw",
  151.                longopts, &longind)) != EOF)
  152.     {
  153.       if (c == 0)        /* Long option. */
  154.     c = longopts[longind].val;
  155.       switch (c)
  156.     {
  157.       /* All digits combine in decimal to specify the context-size.  */
  158.     case '1':
  159.     case '2':
  160.     case '3':
  161.     case '4':
  162.     case '5':
  163.     case '6':
  164.     case '7':
  165.     case '8':
  166.     case '9':
  167.     case '0':
  168.       if (context == -1)
  169.         context = 0;
  170.       /* If a context length has already been specified,
  171.          more digits allowed only if they follow right after the others.
  172.          Reject two separate runs of digits, or digits after -C.  */
  173.       else if (prev < '0' || prev > '9')
  174.         fatal ("context length specified twice");
  175.  
  176.       context = context * 10 + c - '0';
  177.       break;
  178.  
  179.     case 'a':
  180.       /* Treat all files as text files; never treat as binary.  */
  181.       always_text_flag = 1;
  182.       break;
  183.  
  184.     case 'b':
  185.       /* Ignore changes in amount of whitespace.  */
  186.       ignore_space_change_flag = 1;
  187.       length_varies = 1;
  188.       break;
  189.  
  190.     case 'B':
  191.       /* Ignore changes affecting only blank lines.  */
  192.       ignore_blank_lines_flag = 1;
  193.       break;
  194.  
  195.     case 'C':
  196.     case 129:        /* +context[=lines] */
  197.     case 130:        /* +unified[=lines] */
  198.       if (optarg)
  199.         {
  200.           if (context >= 0)
  201.         fatal ("context length specified twice");
  202.           {
  203.         char *p;
  204.         for (p = optarg; *p; p++)
  205.           if (*p < '0' || *p > '9')
  206.             fatal ("invalid context length argument");
  207.           }
  208.           context = atoi (optarg);
  209.         }
  210.  
  211.       /* Falls through.  */
  212.     case 'c':
  213.       /* Make context-style output.  */
  214.       specify_style (c == 130 ? OUTPUT_UNIFIED : OUTPUT_CONTEXT);
  215.       break;
  216.  
  217.     case 'd':
  218.       /* Don't discard lines.  This makes things slower (sometimes much
  219.          slower) but will find a guaranteed minimal set of changes.  */
  220.       no_discards = 1;
  221.       break;
  222.  
  223.     case 'D':
  224.       /* Make merged #ifdef output.  */
  225.       specify_style (OUTPUT_IFDEF);
  226.       ifdef_string = optarg;
  227.       break;
  228.  
  229.     case 'e':
  230.       /* Make output that is a valid `ed' script.  */
  231.       specify_style (OUTPUT_ED);
  232.       break;
  233.  
  234.     case 'f':
  235.       /* Make output that looks vaguely like an `ed' script
  236.          but has changes in the order they appear in the file.  */
  237.       specify_style (OUTPUT_FORWARD_ED);
  238.       break;
  239.  
  240.     case 'F':
  241.       /* Show, for each set of changes, the previous line that
  242.          matches the specified regexp.  Currently affects only
  243.          context-style output.  */
  244.       function_regexp = optarg;
  245.       break;
  246.  
  247.     case 'h':
  248.       /* Split the files into chunks of around 1500 lines
  249.          for faster processing.  Usually does not change the result.
  250.  
  251.          This currently has no effect.  */
  252.       break;
  253.  
  254.     case 'H':
  255.       /* Turn on heuristics that speed processing of large files
  256.          with a small density of changes.  */
  257.       heuristic = 1;
  258.       break;
  259.  
  260.     case 'i':
  261.       /* Ignore changes in case.  */
  262.       ignore_case_flag = 1;
  263.       break;
  264.  
  265.     case 'I':
  266.       /* Ignore changes affecting only lines that match the
  267.          specified regexp.  */
  268.       ignore_regexp = optarg;
  269.       break;
  270.  
  271.     case 'l':
  272.       /* Pass the output through `pr' to paginate it.  */
  273. #if !NO_PAGINATE
  274.       /* AKP 1/91: see util.c about the NO_PAGINATE flag */
  275.       paginate_flag = 1;
  276. #else
  277.       fatal("This diff can't pipe through pr!");
  278. #endif
  279.       break;
  280.  
  281.     case 'L':
  282.       /* Specify file labels for `-c' output headers.  */
  283.       if (!file_label[0])
  284.         file_label[0] = optarg;
  285.       else if (!file_label[1])
  286.         file_label[1] = optarg;
  287.       else
  288.         fatal ("too many file label options");
  289.       break;
  290.  
  291.     case 'n':
  292.       /* Output RCS-style diffs, like `-f' except that each command
  293.          specifies the number of lines affected.  */
  294.       specify_style (OUTPUT_RCS);
  295.       break;
  296.  
  297.     case 'N':
  298.       /* When comparing directories, if a file appears only in one
  299.          directory, treat it as present but empty in the other.  */
  300.       entire_new_file_flag = 1;
  301.       break;
  302.  
  303.     case 'p':
  304.       /* Make context-style output and show name of last C function.  */
  305.       specify_style (OUTPUT_CONTEXT);
  306.       function_regexp = "^[_a-zA-Z]";
  307.       break;
  308.  
  309.     case 'q':
  310.       no_details_flag = 1;
  311.       break;
  312.  
  313.     case 'r':
  314.       /* When comparing directories, 
  315.          recursively compare any subdirectories found.  */
  316.       recursive = 1;
  317.       break;
  318.  
  319.     case 's':
  320.       /* Print a message if the files are the same.  */
  321.       print_file_same_flag = 1;
  322.       break;
  323.  
  324.     case 'S':
  325.       /* When comparing directories, start with the specified
  326.          file name.  This is used for resuming an aborted comparison.  */
  327.       dir_start_file = optarg;
  328.       break;
  329.  
  330.     case 't':
  331.       /* Expand tabs to spaces in the output so that it preserves
  332.          the alignment of the input files.  */
  333.       tab_expand_flag = 1;
  334.       break;
  335.  
  336.     case 'T':
  337.       /* Use a tab in the output, rather than a space, before the
  338.          text of an input line, so as to keep the proper alignment
  339.          in the input line without changing the characters in it.  */
  340.       tab_align_flag = 1;
  341.       break;
  342.  
  343.     case 'v':
  344.       printf ("GNU diff version %s\n", version_string);
  345. #if DONT_USE_STAT_INO || NO_PAGINATE
  346.       printf ("Modified for TOS by Allan Pratt, atari!apratt\n");
  347. #endif
  348.       break;
  349.  
  350.     case 'u':
  351.       /* Output the context diff in unidiff format.  */
  352.       specify_style (OUTPUT_UNIFIED);
  353.       break;
  354.  
  355.     case 'w':
  356.       /* Ignore horizontal whitespace when comparing lines.  */
  357.       ignore_all_space_flag = 1;
  358.       length_varies = 1;
  359.       break;
  360.  
  361.     default:
  362.       usage ();
  363.     }
  364.       prev = c;
  365.     }
  366.  
  367.   if (optind != argc - 2)
  368.     usage ();
  369.  
  370.   if (ignore_regexp)
  371.     {
  372.       char *val;
  373.       bzero (&ignore_regexp_compiled, sizeof ignore_regexp_compiled);
  374.       val = re_compile_pattern (ignore_regexp, strlen (ignore_regexp),
  375.                 &ignore_regexp_compiled);
  376.       if (val != 0)
  377.     error ("%s: %s", ignore_regexp, val);
  378.       ignore_regexp_compiled.fastmap = (char *) xmalloc (256);
  379.     }
  380.  
  381.   if (function_regexp)
  382.     {
  383.       char *val;
  384.       bzero (&function_regexp_compiled, sizeof function_regexp_compiled);
  385.       val = re_compile_pattern (function_regexp, strlen (function_regexp),
  386.                 &function_regexp_compiled);
  387.       if (val != 0)
  388.     error ("%s: %s", function_regexp, val);
  389.       function_regexp_compiled.fastmap = (char *) xmalloc (256);
  390.     }
  391.  
  392.   if (output_style != OUTPUT_CONTEXT && output_style != OUTPUT_UNIFIED)
  393.     context = 0;
  394.   else if (context == -1)
  395.     /* Default amount of context for -c.  */
  396.     context = 3;
  397.  
  398.   switch_string = option_list (argv + 1, optind - 1);
  399.  
  400.   val = compare_files (0, argv[optind], 0, argv[optind + 1], 0);
  401.  
  402.   /* Print any messages that were saved up for last.  */
  403.   print_message_queue ();
  404.  
  405.   if (ferror (stdout) || fclose (stdout) != 0)
  406.     fatal ("write error");
  407.   exit (val);
  408. }
  409.  
  410. usage ()
  411. {
  412.   fprintf (stderr, "\
  413. Usage: diff [-#] [-abBcdefhHilnNprstTuvw] [-C lines] [-F regexp] [-I regexp]\n\
  414.        [-L label [-L label]] [-S file] [-D symbol] [+ignore-blank-lines]\n\
  415.        [+context[=lines]] [+unified[=lines]] [+ifdef=symbol]\n\
  416.        [+show-function-line=regexp]\n");
  417.   fprintf (stderr, "\
  418.        [+speed-large-files] [+ignore-matching-lines=regexp] [+new-file]\n\
  419.        [+initial-tab] [+starting-file=file] [+text] [+all-text] [+ascii]\n\
  420.        [+minimal] [+ignore-space-change] [+ed] [+reversed-ed] [+ignore-case]\n");
  421.   fprintf (stderr, "\
  422.        [+print] [+rcs] [+show-c-function] [+binary] [+brief] [+recursive]\n\
  423.        [+report-identical-files] [+expand-tabs] [+ignore-all-space]\n\
  424.        [+file-label=label [+file-label=label]] [+version] path1 path2\n");
  425.   exit (2);
  426. } 
  427.  
  428. specify_style (style)
  429.      enum output_style style;
  430. {
  431.   if (output_style != OUTPUT_NORMAL
  432.       && output_style != style)
  433.     error ("conflicting specifications of output style");
  434.   output_style = style;
  435. }
  436.  
  437. /* Compare two files (or dirs) with specified names
  438.    DIR0/NAME0 and DIR1/NAME1, at level DEPTH in directory recursion.
  439.    (if DIR0 is 0, then the name is just NAME0, etc.)
  440.    This is self-contained; it opens the files and closes them.
  441.  
  442.    Value is 0 if files are identical, 1 if different,
  443.    2 if there is a problem opening them.  */
  444.  
  445. int
  446. compare_files (dir0, name0, dir1, name1, depth)
  447.      char *dir0, *dir1;
  448.      char *name0, *name1;
  449.      int depth;
  450. {
  451.   static char Standard_Input[] = "Standard Input";
  452.   struct file_data inf[2];
  453.   register int i;
  454.   int val;
  455.   int errorcount = 0;
  456.   int stat_result[2];
  457.  
  458.   /* If this is directory comparison, perhaps we have a file
  459.      that exists only in one of the directories.
  460.      If so, just print a message to that effect.  */
  461.  
  462.   if (! entire_new_file_flag && (name0 == 0 || name1 == 0))
  463.     {
  464.       char *name = name0 == 0 ? name1 : name0;
  465.       char *dir = name0 == 0 ? dir1 : dir0;
  466.       message ("Only in %s: %s\n", dir, name);
  467.       /* Return 1 so that diff_dirs will return 1 ("some files differ").  */
  468.       return 1;
  469.     }
  470.  
  471.   /* Mark any nonexistent file with -1 in the desc field.  */
  472.   /* Mark unopened files (i.e. directories) with -2. */
  473.  
  474.   inf[0].desc = name0 == 0 ? -1 : -2;
  475.   inf[1].desc = name1 == 0 ? -1 : -2;
  476.  
  477.   /* Now record the full name of each file, including nonexistent ones.  */
  478.  
  479.   if (name0 == 0)
  480.     name0 = name1;
  481.   if (name1 == 0)
  482.     name1 = name0;
  483.  
  484.   inf[0].name = dir0 == 0 ? name0 : concat (dir0, "/", name0);
  485.   inf[1].name = dir1 == 0 ? name1 : concat (dir1, "/", name1);
  486.  
  487.   /* Stat the files.  Record whether they are directories.
  488.      Record in stat_result whether stat fails.  */
  489.  
  490.   for (i = 0; i <= 1; i++)
  491.     {
  492.       bzero (&inf[i].stat, sizeof(struct stat));
  493.       inf[i].dir_p = 0;
  494.       stat_result[i] = 0;
  495.  
  496.       if (inf[i].desc != -1)
  497.     {
  498.       char *filename = inf[i].name;
  499.  
  500.       stat_result[i] = 
  501.         strcmp (filename, "-")
  502.           ? stat (filename, &inf[i].stat)
  503.           : fstat (0, &inf[i].stat);
  504.           
  505.       if (stat_result[i] < 0)
  506.         {
  507.           perror_with_name (filename);
  508.           errorcount = 1;
  509.         }
  510.       else
  511.         inf[i].dir_p = 
  512.           S_IFDIR == (inf[i].stat.st_mode & S_IFMT)
  513.           && strcmp (filename, "-");
  514.     }
  515.     }
  516.  
  517. #if !DONT_USE_STAT_INO
  518.   /* AKP: see analyze.c for comments on DONT_USE_STAT_INO */
  519.   /* See if the two named files are actually the same physical file.
  520.      If so, we know they are identical without actually reading them.  */
  521.  
  522.   if (output_style != OUTPUT_IFDEF
  523.       && inf[0].stat.st_ino == inf[1].stat.st_ino
  524.       && inf[0].stat.st_dev == inf[1].stat.st_dev
  525.       && stat_result[0] == 0
  526.       && stat_result[1] == 0)
  527.     {
  528.       val = 0;
  529.       goto done;
  530.     }
  531. #endif
  532.  
  533.   if (name0 == 0)
  534.     inf[0].dir_p = inf[1].dir_p;
  535.   if (name1 == 0)
  536.     inf[1].dir_p = inf[0].dir_p;
  537.  
  538.   /* Open the files and record their descriptors.  */
  539.  
  540.   for (i = 0; i <= 1; i++)
  541.     {
  542.       if (inf[i].desc == -1)
  543.     ;
  544.       else if (!strcmp (inf[i].name, "-"))
  545.     {
  546.       inf[i].desc = 0;
  547.       inf[i].name = Standard_Input;
  548.     }
  549.       /* Don't bother opening if stat already failed.  */
  550.       else if (stat_result[i] == 0 && ! inf[i].dir_p)
  551.     {
  552.       char *filename = inf[i].name;
  553.  
  554.       inf[i].desc = open (filename, O_RDONLY, 0);
  555.       if (0 > inf[i].desc)
  556.         {
  557.           perror_with_name (filename);
  558.           errorcount = 1;
  559.         }
  560.     }
  561.     }
  562.  
  563.   if (errorcount)
  564.     {
  565.  
  566.       /* If either file should exist but fails to be opened, return 2.  */
  567.  
  568.       val = 2;
  569.  
  570.     }
  571.   else if (inf[0].dir_p && inf[1].dir_p)
  572.     {
  573.       if (output_style == OUTPUT_IFDEF)
  574.     fatal ("-D option not supported with directories");
  575.  
  576.       /* If both are directories, compare the files in them.  */
  577.  
  578.       if (depth > 0 && !recursive)
  579.     {
  580.       /* But don't compare dir contents one level down
  581.          unless -r was specified.  */
  582.       message ("Common subdirectories: %s and %s\n",
  583.            inf[0].name, inf[1].name);
  584.       val = 0;
  585.     }
  586.       else
  587.     {
  588.       val = diff_dirs (inf[0].name, inf[1].name, 
  589.                compare_files, depth, 0, 0);
  590.     }
  591.  
  592.     }
  593.   else if (depth == 0 && (inf[0].dir_p || inf[1].dir_p))
  594.     {
  595.  
  596.       /* If only one is a directory, and it was specified in the command line,
  597.      use the file in that dir whose basename matches the other file.  */
  598.  
  599.       int dir_arg = (inf[0].dir_p ? 0 : 1);
  600.       int fnm_arg = (inf[0].dir_p ? 1 : 0);
  601.       char *p = rindex (inf[fnm_arg].name, '/');
  602.       char *filename = concat (inf[dir_arg].name,  "/",
  603.                    (p ? p+1 : inf[fnm_arg].name));
  604.  
  605.       if (inf[fnm_arg].name == Standard_Input)
  606.     fatal ("can't compare - to a directory");
  607.  
  608.       inf[dir_arg].desc = open (filename, O_RDONLY, 0);
  609.  
  610.       if (0 > inf[dir_arg].desc)
  611.     {
  612.       perror_with_name (filename);
  613.       val = 2;
  614.     }
  615.       else
  616.     {
  617.       /* JF: patch from the net to check and make sure we can really free
  618.          this.  If it's from argv[], freeing it is a *really* bad idea */
  619.       if (0 != (dir_arg ? dir1 : dir0))
  620.         free (inf[dir_arg].name);
  621.       inf[dir_arg].name = filename;
  622.       if (fstat (inf[dir_arg].desc, &inf[dir_arg].stat) < 0)
  623.         pfatal_with_name (inf[dir_arg].name);
  624.  
  625.       inf[dir_arg].dir_p
  626.         = (S_IFDIR == (inf[dir_arg].stat.st_mode & S_IFMT));
  627.       if (inf[dir_arg].dir_p)
  628.         {
  629.           error ("%s is a directory but %s is not",
  630.              inf[dir_arg].name, inf[fnm_arg].name);
  631.           val = 1;
  632.         }
  633.       else
  634.         val = diff_2_files (inf, depth);
  635.     }
  636.  
  637.     }
  638.   else if (depth > 0 && (inf[0].dir_p || inf[1].dir_p))
  639.     {
  640.       /* Perhaps we have a subdirectory that exists only in one directory.
  641.      If so, just print a message to that effect.  */
  642.  
  643.       if (inf[0].desc == -1 || inf[1].desc == -1)
  644.     {
  645.       if (entire_new_file_flag && recursive)
  646.         val = diff_dirs (inf[0].name, inf[1].name, compare_files, depth,
  647.                  inf[0].desc == -1, inf[1].desc == -1);
  648.       else
  649.         {
  650.           char *dir = (inf[0].desc == -1) ? dir1 : dir0;
  651.           message ("Only in %s: %s\n", dir, name0);
  652.           val = 1;
  653.         }
  654.     }
  655.       else
  656.     {
  657.       /* We have a subdirectory in one directory
  658.          and a file in the other.  */
  659.  
  660.       if (inf[0].dir_p)
  661.         message ("%s is a directory but %s is not\n",
  662.              inf[0].name, inf[1].name);
  663.       else
  664.         message ("%s is a directory but %s is not\n",
  665.              inf[1].name, inf[0].name);
  666.       /* This is a difference.  */
  667.       val = 1;
  668.     }
  669.     }
  670.   else
  671.     {
  672.  
  673.       /* Both exist and both are ordinary files.  */
  674.  
  675.       val = diff_2_files (inf, depth);
  676.  
  677.     }
  678.  
  679.   /* Now the comparison has been done, if no error prevented it,
  680.      and VAL is the value this function will return.  */
  681.  
  682.   if (inf[0].desc >= 0)
  683.     close (inf[0].desc);
  684.   if (inf[1].desc >= 0)
  685.     close (inf[1].desc);
  686.  
  687.  done:
  688.   if (val == 0 && !inf[0].dir_p)
  689.     {
  690.       if (print_file_same_flag)
  691.     message ("Files %s and %s are identical\n",
  692.          inf[0].name, inf[1].name);
  693.     }
  694.   else
  695.     fflush (stdout);
  696.  
  697.   if (dir0 != 0)
  698.     free (inf[0].name);
  699.   if (dir1 != 0)
  700.     free (inf[1].name);
  701.  
  702.   return val;
  703. }
  704.