home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 4 / FreshFish_May-June1994.bin / bbs / gnu / diffutils-2.6-src.lha / src / amiga / diffutils-2.6 / cmp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-11-10  |  13.2 KB  |  548 lines
  1. /* cmp -- compare two files.
  2.    Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
  3.  
  4.    This program is free software; you can redistribute it and/or modify
  5.    it under the terms of the GNU General Public License as published by
  6.    the Free Software Foundation; either version 2, or (at your option)
  7.    any later version.
  8.  
  9.    This program is distributed in the hope that it will be useful,
  10.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.    GNU General Public License for more details.
  13.  
  14.    You should have received a copy of the GNU General Public License
  15.    along with this program; if not, write to the Free Software
  16.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  17.  
  18. /* Written by Torbjorn Granlund and David MacKenzie. */
  19.  
  20. #include "system.h"
  21. #include <stdio.h>
  22. #include "getopt.h"
  23. #include "cmpbuf.h"
  24.  
  25. extern char const version_string[];
  26.  
  27. #if __STDC__ && defined (HAVE_VPRINTF)
  28. void error (int, int, char const *, ...);
  29. #else
  30. void error ();
  31. #endif
  32. VOID *xmalloc PARAMS((size_t));
  33.  
  34. static int cmp PARAMS((void));
  35. static off_t file_position PARAMS((int));
  36. static size_t block_compare PARAMS((char const *, char const *));
  37. static size_t block_compare_and_count PARAMS((char const *, char const *, long *));
  38. static size_t block_read PARAMS((int, char *, size_t));
  39. static void printc PARAMS((int, unsigned));
  40. static void usage PARAMS((char const *));
  41.  
  42. /* Name under which this program was invoked.  */
  43. char const *program_name;
  44.  
  45. /* Filenames of the compared files.  */
  46. static char const *file[2];
  47.  
  48. /* File descriptors of the files.  */
  49. static int file_desc[2];
  50.  
  51. /* Read buffers for the files.  */
  52. static char *buffer[2];
  53.  
  54. /* Optimal block size for the files.  */
  55. static size_t buf_size;
  56.  
  57. /* Initial prefix to ignore for each file.  */
  58. static off_t ignore_initial;
  59.  
  60. /* Output format:
  61.    type_first_diff
  62.      to print the offset and line number of the first differing bytes
  63.    type_all_diffs
  64.      to print the (decimal) offsets and (octal) values of all differing bytes
  65.    type_status
  66.      to only return an exit status indicating whether the files differ */
  67. static enum
  68.   {
  69.     type_first_diff, type_all_diffs, type_status
  70.   } comparison_type;
  71.  
  72. /* Type used for fast comparison of several bytes at a time.  */
  73. typedef int word;
  74.  
  75. /* If nonzero, print values of bytes quoted like cat -t does. */
  76. static int opt_print_chars;
  77.  
  78. static struct option const long_options[] =
  79. {
  80.   {"print-chars", 0, 0, 'c'},
  81.   {"ignore-initial", 1, 0, 'i'},
  82.   {"verbose", 0, 0, 'l'},
  83.   {"silent", 0, 0, 's'},
  84.   {"quiet", 0, 0, 's'},
  85.   {"version", 0, 0, 'v'},
  86.   {"help", 0, 0, 129},
  87.   {0, 0, 0, 0}
  88. };
  89.  
  90. static void
  91. usage (reason)
  92.      char const *reason;
  93. {
  94.   if (reason && *reason)
  95.     fprintf (stderr, "%s: %s\n", program_name, reason);
  96.   fflush (stderr);
  97.   printf ("\
  98. Usage: %s [options] from-file [to-file]\n\
  99. Options:\n\
  100.     [-clsv] [-i bytes] [--help] [--ignore-initial=bytes]\n\
  101.     [--print-chars] [--quiet] [--silent] [--verbose] [--version]\n",
  102.       program_name);
  103.  
  104.   exit (reason ? 2 : 0);
  105. }
  106.  
  107. int
  108. main (argc, argv)
  109.      int argc;
  110.      char *argv[];
  111. {
  112.   int c, i, exit_status;
  113.   struct stat stat_buf[2];
  114.  
  115.   program_name = argv[0];
  116.  
  117.   /* Parse command line options.  */
  118.  
  119.   while ((c = getopt_long (argc, argv, "ci:lsv", long_options, 0))
  120.      != EOF)
  121.     switch (c)
  122.       {
  123.       case 'c':
  124.     opt_print_chars = 1;
  125.     break;
  126.  
  127.       case 'i':
  128.     ignore_initial = 0;
  129.     while (*optarg)
  130.       {
  131.         /* Don't use `atol', because `off_t' may be longer than `long'.  */
  132.         unsigned digit = *optarg++ - '0';
  133.         if (9 < digit)
  134.           usage ("non-digit in --ignore-initial value");
  135.         ignore_initial = 10 * ignore_initial + digit;
  136.       }
  137.     break;
  138.  
  139.       case 'l':
  140.     comparison_type = type_all_diffs;
  141.     break;
  142.  
  143.       case 's':
  144.     comparison_type = type_status;
  145.     break;
  146.  
  147.       case 'v':
  148.     printf ("GNU cmp version %s\n", version_string);
  149.     exit (0);
  150.  
  151.       case 129:
  152.     usage (0);
  153.  
  154.       default:
  155.     usage ("");
  156.       }
  157.  
  158.   if (optind == argc)
  159.     usage ("missing operand");
  160.  
  161.   file[0] = argv[optind++];
  162.   file[1] = optind < argc ? argv[optind++] : "-";
  163.  
  164.   if (optind < argc)
  165.     usage ("extra operands");
  166.  
  167.   for (i = 0; i < 2; i++)
  168.     {
  169.       /* If file[1] is "-", treat it first; this avoids a misdiagnostic if
  170.      stdin is closed and opening file[0] yields file descriptor 0.  */
  171.       int i1 = i ^ (strcmp (file[1], "-") == 0);
  172.  
  173.       /* Two files with the same name are identical.
  174.      But wait until we open the file once, for proper diagnostics.  */
  175.       if (i && strcmp (file[0], file[1]) == 0)
  176.     exit (0);
  177.  
  178.       file_desc[i1] = (strcmp (file[i1], "-") == 0
  179.                ? STDIN_FILENO
  180.                : open (file[i1], O_RDONLY));
  181.       if (file_desc[i1] < 0 || fstat (file_desc[i1], &stat_buf[i1]) != 0)
  182.     {
  183.       if (file_desc[i1] < 0 && comparison_type == type_status)
  184.         exit (2);
  185.       else
  186.         error (2, errno, "%s", file[i1]);
  187.     }
  188.     }
  189.  
  190.   /* If the files are links to the same inode and have the same file position,
  191.      they are identical.  */
  192.  
  193.   if (stat_buf[0].st_dev == stat_buf[1].st_dev
  194.       && stat_buf[0].st_ino == stat_buf[1].st_ino
  195.       && file_position (0) == file_position (1))
  196.     exit (0);
  197.  
  198.   /* If output is redirected to "/dev/null", we may assume `-s'.  */
  199.  
  200.   if (comparison_type != type_status)
  201.     {
  202.       struct stat outstat, nullstat;
  203.  
  204.       if (fstat (STDOUT_FILENO, &outstat) == 0
  205.       && stat ("/dev/null", &nullstat) == 0
  206.       && outstat.st_dev == nullstat.st_dev
  207.       && outstat.st_ino == nullstat.st_ino)
  208.     comparison_type = type_status;
  209.     }
  210.  
  211.   /* If only a return code is needed,
  212.      and if both input descriptors are associated with plain files,
  213.      conclude that the files differ if they have different sizes.  */
  214.  
  215.   if (comparison_type == type_status
  216.       && S_ISREG (stat_buf[0].st_mode)
  217.       && S_ISREG (stat_buf[1].st_mode))
  218.     {
  219.       off_t s0 = stat_buf[0].st_size - file_position (0);
  220.       off_t s1 = stat_buf[1].st_size - file_position (1);
  221.  
  222.       if (max (0, s0) != max (0, s1))
  223.     exit (1);
  224.     }
  225.  
  226.   /* Get the optimal block size of the files.  */
  227.  
  228.   buf_size = buffer_lcm (STAT_BLOCKSIZE (stat_buf[0]),
  229.              STAT_BLOCKSIZE (stat_buf[1]));
  230.  
  231.   /* Allocate buffers, with space for sentinels at the end.  */
  232.  
  233.   for (i = 0; i < 2; i++)
  234.     buffer[i] = xmalloc (buf_size + sizeof (word));
  235.  
  236.   exit_status = cmp ();
  237.  
  238.   for (i = 0; i < 2; i++)
  239.     if (close (file_desc[i]) != 0)
  240.       error (2, errno, "%s", file[i]);
  241.   if (comparison_type != type_status)
  242.     {
  243.       if (ferror (stdout))
  244.     error (2, 0, "write error");
  245.       else if (fclose (stdout) != 0)
  246.     error (2, errno, "write error");
  247.     }
  248.   exit (exit_status);
  249.   return exit_status;
  250. }
  251.  
  252. /* Compare the two files already open on `file_desc[0]' and `file_desc[1]',
  253.    using `buffer[0]' and `buffer[1]'.
  254.    Return 0 if identical, 1 if different, >1 if error. */
  255.  
  256. static int
  257. cmp ()
  258. {
  259.   long line_number = 1;        /* Line number (1...) of first difference. */
  260.   long char_number = ignore_initial + 1;
  261.                 /* Offset (1...) in files of 1st difference. */
  262.   size_t read0, read1;        /* Number of chars read from each file. */
  263.   size_t first_diff;        /* Offset (0...) in buffers of 1st diff. */
  264.   size_t smaller;        /* The lesser of `read0' and `read1'. */
  265.   char *buf0 = buffer[0];
  266.   char *buf1 = buffer[1];
  267.   int ret = 0;
  268.   int i;
  269.  
  270.   if (ignore_initial)
  271.     for (i = 0; i < 2; i++)
  272.       if (file_position (i) == -1)
  273.     {
  274.       /* lseek failed; read and discard the ignored initial prefix.  */
  275.       off_t ig = ignore_initial;
  276.       do
  277.         {
  278.           size_t r = read (file_desc[i], buf0, (size_t) min (ig, buf_size));
  279.           if (!r)
  280.         break;
  281.           if (r == -1)
  282.         error (2, errno, "%s", file[i]);
  283.           ig -= r;
  284.         }
  285.       while (ig);
  286.     }
  287.  
  288.   do
  289.     {
  290.       read0 = block_read (file_desc[0], buf0, buf_size);
  291.       if (read0 == -1)
  292.     error (2, errno, "%s", file[0]);
  293.       read1 = block_read (file_desc[1], buf1, buf_size);
  294.       if (read1 == -1)
  295.     error (2, errno, "%s", file[1]);
  296.  
  297.       /* Insert sentinels for the block compare.  */
  298.  
  299.       buf0[read0] = ~buf1[read0];
  300.       buf1[read1] = ~buf0[read1];
  301.  
  302.       /* If the line number should be written for differing files,
  303.      compare the blocks and count the number of newlines
  304.      simultaneously.  */
  305.       first_diff = (comparison_type == type_first_diff
  306.             ? block_compare_and_count (buf0, buf1, &line_number)
  307.             : block_compare (buf0, buf1));
  308.  
  309.       char_number += first_diff;
  310.       smaller = min (read0, read1);
  311.  
  312.       if (first_diff < smaller)
  313.     {
  314.       switch (comparison_type)
  315.         {
  316.         case type_first_diff:
  317.           /* See Posix.2 section 4.10.6.1 for this format.  */
  318.           printf ("%s %s differ: char %ld, line %ld",
  319.               file[0], file[1], char_number, line_number);
  320.           if (opt_print_chars)
  321.         {
  322.           unsigned char c0 = buf0[first_diff];
  323.           unsigned char c1 = buf1[first_diff];
  324.           printf (" is %3o ", c0);
  325.           printc (0, c0);
  326.           printf (" %3o ", c1);
  327.           printc (0, c1);
  328.         }
  329.           putchar ('\n');
  330.           /* Fall through. */
  331.         case type_status:
  332.           return 1;
  333.  
  334.         case type_all_diffs:
  335.           do
  336.         {
  337.           unsigned char c0 = buf0[first_diff];
  338.           unsigned char c1 = buf1[first_diff];
  339.           if (c0 != c1)
  340.             {
  341.               if (opt_print_chars)
  342.             {
  343.               printf ("%6lu %3o ", char_number, c0);
  344.               printc (4, c0);
  345.               printf (" %3o ", c1);
  346.               printc (0, c1);
  347.               putchar ('\n');
  348.             }
  349.               else
  350.             /* See Posix.2 section 4.10.6.1 for this format.  */
  351.             printf ("%6ld %3o %3o\n", char_number, c0, c1);
  352.             }
  353.           char_number++;
  354.           first_diff++;
  355.         }
  356.           while (first_diff < smaller);
  357.           ret = 1;
  358.           break;
  359.         }
  360.     }
  361.  
  362.       if (read0 != read1)
  363.     {
  364.       if (comparison_type != type_status)
  365.         /* See Posix.2 section 4.10.6.2 for this format.  */
  366.         fprintf (stderr, "cmp: EOF on %s\n", file[read1 < read0]);
  367.  
  368.       return 1;
  369.     }
  370.     }
  371.   while (read0 == buf_size);
  372.   return ret;
  373. }
  374.  
  375. /* Compare two blocks of memory P0 and P1 until they differ,
  376.    and count the number of '\n' occurrences in the common
  377.    part of P0 and P1.
  378.    Assumes that P0 and P1 are aligned at word addresses!
  379.    If the blocks are not guaranteed to be different, put sentinels at the ends
  380.    of the blocks before calling this function.
  381.  
  382.    Return the offset of the first byte that differs.
  383.    Increment *COUNT by the count of '\n' occurrences.  */
  384.  
  385. static size_t
  386. block_compare_and_count (p0, p1, count)
  387.      char const *p0, *p1;
  388.      long *count;
  389. {
  390.   word l;        /* One word from first buffer. */
  391.   word const *l0, *l1;    /* Pointers into each buffer. */
  392.   char const *c0, *c1;    /* Pointers for finding exact address. */
  393.   long cnt = 0;        /* Number of '\n' occurrences. */
  394.   word nnnn;        /* Newline, sizeof (word) times.  */
  395.   int i;
  396.  
  397.   l0 = (word const *) p0;
  398.   l1 = (word const *) p1;
  399.  
  400.   nnnn = 0;
  401.   for (i = 0; i < sizeof (word); i++)
  402.     nnnn = (nnnn << CHAR_BIT) | '\n';
  403.  
  404.   /* Find the rough position of the first difference by reading words,
  405.      not bytes.  */
  406.  
  407.   while ((l = *l0++) == *l1++)
  408.     {
  409.       l ^= nnnn;
  410.       for (i = 0; i < sizeof (word); i++)
  411.     {
  412.       cnt += ! (unsigned char) l;
  413.       l >>= CHAR_BIT;
  414.     }
  415.     }
  416.  
  417.   /* Find the exact differing position (endianness independent).  */
  418.  
  419.   c0 = (char const *) (l0 - 1);
  420.   c1 = (char const *) (l1 - 1);
  421.   while (*c0 == *c1)
  422.     {
  423.       cnt += *c0 == '\n';
  424.       c0++;
  425.       c1++;
  426.     }
  427.  
  428.   *count += cnt;
  429.   return c0 - p0;
  430. }
  431.  
  432. /* Compare two blocks of memory P0 and P1 until they differ.
  433.    Assumes that P0 and P1 are aligned at word addresses!
  434.    If the blocks are not guaranteed to be different, put sentinels at the ends
  435.    of the blocks before calling this function.
  436.  
  437.    Return the offset of the first byte that differs.  */
  438.  
  439. static size_t
  440. block_compare (p0, p1)
  441.      char const *p0, *p1;
  442. {
  443.   word const *l0, *l1;
  444.   char const *c0, *c1;
  445.  
  446.   l0 = (word const *) p0;
  447.   l1 = (word const *) p1;
  448.  
  449.   /* Find the rough position of the first difference by reading words,
  450.      not bytes.  */
  451.  
  452.   while (*l0++ == *l1++)
  453.     ;
  454.  
  455.   /* Find the exact differing position (endianness independent).  */
  456.  
  457.   c0 = (char const *) (l0 - 1);
  458.   c1 = (char const *) (l1 - 1);
  459.   while (*c0 == *c1)
  460.     {
  461.       c0++;
  462.       c1++;
  463.     }
  464.  
  465.   return c0 - p0;
  466. }
  467.  
  468. /* Read NCHARS bytes from descriptor FD into BUF.
  469.    Return the number of characters successfully read.
  470.    The number returned is always NCHARS unless end-of-file or error.  */
  471.  
  472. static size_t
  473. block_read (fd, buf, nchars)
  474.      int fd;
  475.      char *buf;
  476.      size_t nchars;
  477. {
  478.   char *bp = buf;
  479.  
  480.   do
  481.     {
  482.       size_t nread = read (fd, bp, nchars);
  483.       if (nread == -1)
  484.     return -1;
  485.       if (nread == 0)
  486.     break;
  487.       bp += nread;
  488.       nchars -= nread;
  489.     }
  490.   while (nchars != 0);
  491.  
  492.   return bp - buf;
  493. }
  494.  
  495. /* Print character C, making nonvisible characters
  496.    visible by quoting like cat -t does.
  497.    Pad with spaces on the right to WIDTH characters.  */
  498.  
  499. static void
  500. printc (width, c)
  501.      int width;
  502.      unsigned c;
  503. {
  504.   register FILE *fs = stdout;
  505.  
  506.   if (c >= 128)
  507.     {
  508.       putc ('M', fs);
  509.       putc ('-', fs);
  510.       c -= 128;
  511.       width -= 2;
  512.     }
  513.   if (c < 32)
  514.     {
  515.       putc ('^', fs);
  516.       c += 64;
  517.       --width;
  518.     }
  519.   else if (c == 127)
  520.     {
  521.       putc ('^', fs);
  522.       c = '?';
  523.       --width;
  524.     }
  525.  
  526.   putc (c, fs);
  527.   while (--width > 0)
  528.     putc (' ', fs);
  529. }
  530.  
  531. /* Position file I to `ignore_initial' bytes from its initial position,
  532.    and yield its new position.  Don't try more than once.  */
  533.  
  534. static off_t
  535. file_position (i)
  536.      int i;
  537. {
  538.   static int positioned[2];
  539.   static off_t position[2];
  540.  
  541.   if (! positioned[i])
  542.     {
  543.       positioned[i] = 1;
  544.       position[i] = lseek (file_desc[i], ignore_initial, SEEK_CUR);
  545.     }
  546.   return position[i];
  547. }
  548.