strip  count  specifies how many slashes are to be stripped from the
          front of the pathname.  (Any intervening  directory  names  also  go
          away.)  For example, supposing the filename in the patch file was

                  /u/howard/src/blurfl/blurfl.c

          setting -p or -p0 gives the entire pathname unmodified, -p1 gives

                  u/howard/src/blurfl/blurfl.c

          without the leading slash, -p4 gives

                  blurfl/blurfl.c

          and not specifying -p at all just gives you "blurfl.c",  unless  all
          of  the  directories in the leading path (u/howard/src/blurfl) exist
          and that path is relative, in which case you get the entire pathname
          unmodified.   Whatever  you  end up with is looked for either in the
          current directory, or the directory specified by the -d switch.

     -r   causes the next argument to be interpreted as the reject file name.

     -R   tells patch that this patch was created with the old and  new  files
          swapped.   (Yes,  I'm  afraid  that  does happen occasionally, human
          nature being what it is.)  Patch will  attempt  to  swap  each  hunk


                                    LOCAL                                    4



PATCH(1)                  Minix Programmer's Manual                   PATCH(1)


          around before applying it.  Rejects will come  out  in  the  swapped
          format.   The  -R  switch will not work with ed diff scripts because
          there  is  too  little  information  to  reconstruct   the   reverse
          operation.

          If the first hunk of a patch fails, patch will reverse the  hunk  to
          see  if it can be applied that way.  If it can, you will be asked if
          you want to have the -R switch set.  If it  can't,  the  patch  will
          continue to be applied normally.  (Note: this method cannot detect a
          reversed patch if it is a normal diff and if the first command is an
          append  (i.e.  it  should  have  been a delete) since appends always
          succeed, due to the fact that a null context  will  match  anywhere.
          Luckily,  most  patches add or change lines rather than delete them,
          so most reversed normal diffs will begin with a delete,  which  will
          fail, triggering the heuristic.)

     -s   makes patch do its work silently, unless an error occurs.

     -S   causes patch to ignore this patch from the patch file, but  continue
          on looking for the next patch in the file.  Thus

                  patch -S + -S + <patchfile

          will ignore the first and second of three patches.

     -u   forces patch to interpret the patch file as a unified  context  diff
          (a unidiff).

     -v   causes patch to print out its revision header and patch level.

     -V   causes the next argument to be interpreted as a method for  creating
          backup  file  names.   The type of backups made can also be given in
          the VERSION_CONTROL environment variable,  which  is  overridden  by
          this  option.   The  -B  option  overrides  this option, causing the
          prefix to always be used for making backup file names.  The value of
          the  VERSION_CONTROL environment variable and the argument to the -V
          option are like the GNU Emacs `version-control' variable; they  also
          recognize  synonyms that are more descriptive.  The valid values are
          (unique abbreviations are accepted):

     `t' or `numbered'
          Always make numbered backups.

     `nil' or `existing'
          Make numbered backups  of  files  that  already  have  them,  simple
          backups of the others.  This is the default.

     `never' or `simple'
          Always make simple backups.



                                    LOCAL                                    5



PATCH(1)                  Minix Programmer's Manual                   PATCH(1)


     -x<number>
          sets internal debugging flags, and is  of  interest  only  to  patch
          patchers.

AUTHOR
     Larry Wall <lwall@netlabs.com>
     with many other contributors.

ENVIRONMENT

     TMPDIR
          Directory to put temporary files in; default is /tmp.

     SIMPLE_BACKUP_SUFFIX
          Extension to use for backup  file  names  instead  of  ``.orig''  or
          ``~''.

     VERSION_CONTROL
          Selects when numbered backup files are made.

FILES
     $TMPDIR/patch*

SEE ALSO
     diff(1)

NOTES FOR PATCH SENDERS
     There are several things you should bear in mind if you are going  to  be
     sending  out  patches.   First,  you  can  save  people a lot of grief by
     keeping a patchlevel.h file which is patched to increment the patch level
     as  the  first diff in the patch file you send out.  If you put a Prereq:
     line in with the patch, it won't let them  apply  patches  out  of  order
     without  some  warning.  Second, make sure you've specified the filenames
     right, either in a context diff header, or with an Index: line.   If  you
     are  patching something in a subdirectory, be sure to tell the patch user
     to specify a -p switch as needed.   Third,  you  can  create  a  file  by
     sending  out  a  diff  that  compares a null file to the file you want to
     create.  This will only work if the file you want to create doesn't exist
     already  in  the  target  directory.   Fourth,  take care not to send out
     reversed patches, since it  makes  people  wonder  whether  they  already
     applied the patch.  Fifth, while you may be able to get away with putting
     582 diff listings into one file, it is probably wiser  to  group  related
     patches into separate files in case something goes haywire.

DIAGNOSTICS
     Too many to list here, but generally indicative that patch couldn't parse
     your patch file.





                                    LOCAL                                    6



PATCH(1)                  Minix Programmer's Manual                   PATCH(1)


     The message ``Hmm...'' indicates that there is unprocessed  text  in  the
     patch  file  and  that  patch  is attempting to intuit whether there is a
     patch in that text and, if so, what kind of patch it is.

     Patch will exit with a non-zero status if any reject files were  created.
     When  applying  a  set of patches in a loop it behooves you to check this
     exit status so you don't apply a later patch to a partially patched file.

CAVEATS
     Patch cannot tell if the line numbers are off in an ed  script,  and  can
     only  detect bad line numbers in a normal diff when it finds a ``change''
     or a ``delete'' command.  A context diff using fuzz factor 3 may have the
     same  problem.   Until  a  suitable  interactive  interface is added, you
     should probably do a context diff in these cases to see  if  the  changes
     made  sense.   Of  course,  compiling  without  errors  is  a pretty good
     indication that the patch worked, but not always.

     Patch usually produces the correct results, even when it has to do a  lot
     of guessing.  However, the results are guaranteed to be correct only when
     the patch is applied to exactly the same version of  the  file  that  the
     patch was generated from.

BUGS
     Could be smarter about partial matches, excessively deviant  offsets  and
     swapped code, but that would take an extra pass.

     If code has been duplicated (for instance with #ifdef OLDCODE  ...  #else
     ...   #endif),  patch  is incapable of patching both versions, and, if it
     works at all, will likely patch the wrong  one,  and  tell  you  that  it
     succeeded to boot.

     If you apply a patch you've already applied, patch will  think  it  is  a
     reversed patch, and offer to un-apply the patch.  This could be construed
     as a feature.


















                                    LOCAL                                    7