diff - differential file and directory comparator

     diff [ -l ] [ -r ] [ -s ] [ -cuefhn ] [ -biwt ] dir1 dir2
     diff [ -cuefhn ] [ -biwt ] file1 file2
     diff [ -Dstring ] [ -biw ] file1 file2

     If both arguments  are  directories,  diff  sorts  the  contents  of  the
     directories  by  name,  and  then  runs  the  regular file diff algorithm
     (described below) on text files which are different.  Binary files  which
     differ,  common  subdirectories,  and  files  which  appear  in  only one
     directory are listed.  Options when comparing directories are:

     -l   long output format; each text file diff is piped  through  pr(1)  to
          paginate  it,  other differences are remembered and summarized after
          all text file differences are reported.

     -r   causes application of  diff  recursively  to  common  subdirectories

     -s   causes diff to report files which are the same, which are  otherwise
          not mentioned.

          starts a directory diff in the middle beginning with file name.

     When run on regular files, and when comparing  text  files  which  differ
     during directory comparison, diff tells what lines must be changed in the
     files to bring them into agreement.  Except in rare  circumstances,  diff
     finds  a  smallest  sufficient set of file differences.  If neither file1
     nor file2 is a directory, then either may be given as `-', in which  case
     the standard input is used.  If file1 is a directory, then a file in that
     directory whose file-name is the same as the file-name of file2  is  used
     (and vice versa).

     There are several options for output format; the  default  output  format
     contains lines of these forms:

          n1 a n3,n4
          n1,n2 d n3
          n1,n2 c n3,n4

     These lines resemble ed  commands  to  convert  file1  into  file2.   The
     numbers  after  the letters pertain to file2.  In fact, by exchanging `a'
     for `d' and reading backward one may ascertain  equally  how  to  convert
     file2 into file1.  As in ed, identical pairs where n1 = n2 or n3 = n4 are
     abbreviated as a single number.

     Following each of these lines come all the lines that are affected in the
     first  file  flagged  by `<', then all the lines that are affected in the
     second file flagged by `>'.

     Except for -b, -w, -i or -t which may be given with any  of  the  others,
     the following options are mutually exclusive:

     -e       produces a script of a, c and d  commands  for  the  editor  ed,
              which  will  recreate  file2 from file1.  In connection with -e,
              the following shell program may help maintain multiple  versions
              of  a file.  Only an ancestral file ($1) and a chain of version-
              to-version ed scripts ($2,$3,...) made by diff need be on  hand.
              A `latest version' appears on the standard output.

                      (shift; cat $*; echo '1,$p') | ed - $1

              Extra  commands  are  added  to  the   output   when   comparing
              directories  with  -e,  so that the result is a sh(1) script for
              converting text files which are common to  the  two  directories
              from their state in dir1 to their state in dir2.

     -f       produces a script similar to that of -e, not useful with ed, and
              in the opposite order.

     -n       produces a script similar to that of -e,  but  in  the  opposite
              order and with a count of changed lines on each insert or delete
              command.  This is the form used by rcsdiff(1).

     -c       produces a diff with  lines  of  context.   The  default  is  to
              present  3  lines  of  context and may be changed, e.g to 10, by
              -c10.  With -c the output  format  is  modified  slightly:   the
              output  beginning  with identification of the files involved and
              their creation dates and then each change is separated by a line
              with  a dozen *'s.  The lines removed from file1 are marked with
              `- '; those added to file2 are marked `+  '.   Lines  which  are
              changed from one file to the other are marked in both files with
              with `! '.

              Changes which lie within  <context>  lines  of  each  other  are
              grouped together on output.  (This is a change from the previous
              ``diff -c'' but the resulting output is usually much  easier  to

     -u       Like -c, but produces a diff in  "unified  diff"  format.   This
              format marks lines that are only in file1 with a `-', lines only
              in file2 with  a  `+',  with  context  lines  surrounding  these
              changes.   This  format is much shorter than a context diff, and
              much preferred by people who have learned to read it.

     -h       does a fast, half-hearted  job.   It  works  only  when  changed
              stretches  are  short and well separated, but does work on files
              of unlimited length.

     -Dstring causes diff to create a merged version of file1 and file2 on the
              standard output, with C preprocessor controls included so that a
              compilation of the result without defining string is  equivalent
              to compiling file1, while defining string will yield file2.

     -b       causes trailing blanks (spaces and  tabs)  to  be  ignored,  and
              other strings of blanks to compare equal.

     -w       is similar to -b but causes whitespace (blanks and tabs)  to  be
              totally  ignored.  E.g., ``if ( a == b )'' will compare equal to

     -i       ignores the case of letters.  E.g., ``A'' will compare equal  to

     -t       will expand tabs in output lines.   Normal  or  -c  output  adds
              character(s)  to  the  front of each line which may screw up the
              indentation of the original source lines  and  make  the  output
              listing  difficult  to interpret.  This option will preserve the
              original source's indentation.

     cmp(1), cc(1), comm(1), ed(1), diff3(1).

     Exit status is 0 for no differences, 1 for some, 2 for trouble.