10.1 Selecting the patch Input Format

patch normally determines which diff format the patch file uses by examining its contents. For patch files that contain particularly confusing leading text, you might need to use one of the following options to force patch to interpret the patch file as a certain format of diff. The output formats listed here are the only ones that patch can understand.

-c

--context

context diff.

-e

--ed

ed script.

-n

--normal

normal diff.

-u

--unified

unified diff.

10.2 Revision Control

If a nonexistent input file is under a revision control system supported by patch, patch normally asks the user whether to get (or check out) the file from the revision control system. Patch currently supports RCS, ClearCase and SCCS. Under RCS and SCCS, patch also asks when the input file is read-only and matches the default version in the revision control system.

The --get=num (-g num) option affects access to files under supported revision control systems. If num is positive, patch gets the file without asking the user; if zero, patch neither asks the user nor gets the file; and if negative, patch asks the user before getting the file. The default value of num is given by the value of the PATCH_GET environment variable if it is set; if not, the default value is zero if patch is conforming to POSIX, negative otherwise. See patch and the POSIX Standard.

The choice of revision control system is unaffected by the VERSION_CONTROL environment variable (see Backup File Names).

10.3 Applying Imperfect Patches

patch tries to skip any leading text in the patch file, apply the diff, and then skip any trailing text. Thus you can feed a mail message directly to patch, and it should work. If the entire diff is indented by a constant amount of white space, patch automatically ignores the indentation. If a context diff contains trailing carriage return on each line, patch automatically ignores the carriage return. If a context diff has been encapsulated by prepending ‘- ’ to lines beginning with ‘-’ as per Internet RFC 934, patch automatically unencapsulates the input.

However, certain other types of imperfect input require user intervention or testing.

• Applying Patches with Changed White Space
• Applying Reversed Patches
• Helping patch Find Inexact Matches
• Predicting what patch will do

10.4 Creating and Removing Files

Sometimes when comparing two directories, a file may exist in one directory but not the other. If you give diff the --new-file (-N) option, or if you supply an old or new file that is named /dev/null or is empty and is dated the Epoch (1970-01-01 00:00:00 UTC), diff outputs a patch that adds or deletes the contents of this file. When given such a patch, patch normally creates a new file or removes the old file. However, when conforming to POSIX (see patch and the POSIX Standard), patch does not remove the old file, but leaves it empty. The --remove-empty-files (-E) option causes patch to remove output files that are empty after applying a patch, even if the patch does not appear to be one that removed the file.

If the patch appears to create a file that already exists, patch asks for confirmation before applying the patch.

10.5 Updating Timestamps on Patched Files

When patch updates a file, it normally sets the file’s last-modified timestamp to the current time of day. If you are using patch to track a software distribution, this can cause make to incorrectly conclude that a patched file is out of date. For example, if syntax.c depends on syntax.y, and patch updates syntax.c and then syntax.y, then syntax.c will normally appear to be out of date with respect to syntax.y even though its contents are actually up to date.

The --set-utc (-Z) option causes patch to set a patched file’s modification and access times to the timestamps given in context diff headers. If the context diff headers do not specify a time zone, they are assumed to use Coordinated Universal Time (UTC, often known as GMT).

The --set-time (-T) option acts like -Z or --set-utc, except that it assumes that the context diff headers’ timestamps use local time instead of UTC. This option is not recommended, because patches using local time cannot easily be used by people in other time zones, and because local timestamps are ambiguous when local clocks move backwards during daylight-saving time adjustments. If the context diff headers specify a time zone, this option is equivalent to --set-utc (-Z).

patch normally refrains from setting a file’s timestamps if the file’s original last-modified timestamp does not match the time given in the diff header, of if the file’s contents do not exactly match the patch. However, if the --force (-f) option is given, the file’s timestamps are set regardless.

Due to the limitations of the current diff format, patch cannot update the times of files whose contents have not changed. Also, if you set file timestamps to values other than the current time of day, you should also remove (e.g., with ‘make clean’) all files that depend on the patched files, so that later invocations of make do not get confused by the patched files’ times.

10.6 Multiple Patches in a File

If the patch file contains more than one patch, and if you do not specify an input file on the command line, patch tries to apply each patch as if they came from separate patch files. This means that it determines the name of the file to patch for each patch, and that it examines the leading text before each patch for file names and prerequisite revision level (see Tips for Making and Using Patches, for more on that topic).

patch uses the following rules to intuit a file name from the leading text before a patch. First, patch takes an ordered list of candidate file names as follows:

• If the header is that of a context diff, patch takes the old and new file names in the header. A name is ignored if it does not have enough slashes to satisfy the -pnum or --strip=num option. The name /dev/null is also ignored.
• If there is an ‘Index:’ line in the leading garbage and if either the old and new names are both absent or if patch is conforming to POSIX, patch takes the name in the ‘Index:’ line.
• For the purpose of the following rules, the candidate file names are considered to be in the order (old, new, index), regardless of the order that they appear in the header.

Then patch selects a file name from the candidate list as follows:

• If some of the named files exist, patch selects the first name if conforming to POSIX, and the best name otherwise.
• If patch is not ignoring RCS, ClearCase, and SCCS (see Revision Control), and no named files exist but an RCS, ClearCase, or SCCS master is found, patch selects the first named file with an RCS, ClearCase, or SCCS master.
• If no named files exist, no RCS, ClearCase, or SCCS master was found, some names are given, patch is not conforming to POSIX, and the patch appears to create a file, patch selects the best name requiring the creation of the fewest directories.
• If no file name results from the above heuristics, you are asked for the name of the file to patch, and patch selects that name.

To determine the best of a nonempty list of file names, patch first takes all the names with the fewest path name components; of those, it then takes all the names with the shortest basename; of those, it then takes all the shortest names; finally, it takes the first remaining name.

See patch and the POSIX Standard, to see whether patch is conforming to POSIX.

10.7 Applying Patches in Other Directories

The --directory=directory (-d directory) option to patch makes directory directory the current directory for interpreting both file names in the patch file, and file names given as arguments to other options (such as -B and -o). For example, while in a mail reading program, you can patch a file in the /usr/src/emacs directory directly from a message containing the patch like this:

| patch -d /usr/src/emacs

Sometimes the file names given in a patch contain leading directories, but you keep your files in a directory different from the one given in the patch. In those cases, you can use the --strip=number (-pnumber) option to set the file name strip count to number. The strip count tells patch how many slashes, along with the directory names between them, to strip from the front of file names. A sequence of one or more adjacent slashes is counted as a single slash. By default, patch strips off all leading directories, leaving just the base file names.

For example, suppose the file name in the patch file is /gnu/src/emacs/etc/NEWS. Using -p0 gives the entire file name unmodified, -p1 gives gnu/src/emacs/etc/NEWS (no leading slash), -p4 gives etc/NEWS, and not specifying -p at all gives NEWS.

patch looks for each file (after any slashes have been stripped) in the current directory, or if you used the -d directory option, in that directory.

10.8 Backup Files

Normally, patch creates a backup file if the patch does not exactly match the original input file, because in that case the original data might not be recovered if you undo the patch with ‘patch -R’ (see Applying Reversed Patches). However, when conforming to POSIX, patch does not create backup files by default. See patch and the POSIX Standard.

The --backup (-b) option causes patch to make a backup file regardless of whether the patch matches the original input. The --backup-if-mismatch option causes patch to create backup files for mismatches files; this is the default when not conforming to POSIX. The --no-backup-if-mismatch option causes patch to not create backup files, even for mismatched patches; this is the default when conforming to POSIX.

When backing up a file that does not exist, an empty, unreadable backup file is created as a placeholder to represent the nonexistent file.

10.9 Backup File Names

Normally, patch renames an original input file into a backup file by appending to its name the extension ‘.orig’, or ‘~’ if using ‘.orig’ would make the backup file name too long.¹ The -z backup-suffix or --suffix=backup-suffix option causes patch to use backup-suffix as the backup extension instead.

Alternately, you can specify the extension for backup files with the SIMPLE_BACKUP_SUFFIX environment variable, which the options override.

patch can also create numbered backup files the way GNU Emacs does. With this method, instead of having a single backup of each file, patch makes a new backup file name each time it patches a file. For example, the backups of a file named sink would be called, successively, sink.~1~, sink.~2~, sink.~3~, etc.

The -V backup-style or --version-control=backup-style option takes as an argument a method for creating backup file names. You can alternately control the type of backups that patch makes with the PATCH_VERSION_CONTROL environment variable, which the -V option overrides. If PATCH_VERSION_CONTROL is not set, the VERSION_CONTROL environment variable is used instead. Please note that these options and variables control backup file names; they do not affect the choice of revision control system (see Revision Control).

The values of these environment variables and the argument to the -V option are like the GNU Emacs version-control variable (see Backup Names in The GNU Emacs Manual, for more information on backup versions in Emacs). They also recognize synonyms that are more descriptive. The valid values are listed below; unique abbreviations are acceptable.

t

numbered

Always make numbered backups.

nil

existing

Make numbered backups of files that already have them, simple backups of the others. This is the default.

never

simple

Always make simple backups.

You can also tell patch to prepend a prefix, such as a directory name, to produce backup file names. The --prefix=prefix (-B prefix) option makes backup files by prepending prefix to them. The --basename-prefix=prefix (-Y prefix) prepends prefix to the last file name component of backup file names instead; for example, -Y ~ causes the backup name for dir/file.c to be dir/~file.c. If you use either of these prefix options, the suffix-based options are ignored.

If you specify the output file with the -o option, that file is the one that is backed up, not the input file.

Options that affect the names of backup files do not affect whether backups are made. For example, if you specify the --no-backup-if-mismatch option, none of the options described in this section have any affect, because no backups are made.

10.10 Reject File Names

The names for reject files (files containing patches that patch could not find a place to apply) are normally the name of the output file with ‘.rej’ appended (or ‘#’ if using ‘.rej’ would make the backup file name too long).

Alternatively, you can tell patch to place all of the rejected patches in a single file. The -r reject-file or --reject-file=reject-file option uses reject-file as the reject file name.

10.11 Messages and Questions from patch

patch can produce a variety of messages, especially if it has trouble decoding its input. In a few situations where it’s not sure how to proceed, patch normally prompts you for more information from the keyboard. There are options to produce more or fewer messages, to have it not ask for keyboard input, and to affect the way that file names are quoted in messages.

patch exits with status 0 if all hunks are applied successfully, 1 if some hunks cannot be applied, and 2 if there is more serious trouble. When applying a set of patches in a loop, you should check the exit status, so you don’t apply a later patch to a partially patched file.

• Controlling the Verbosity of patch
• Inhibiting Keyboard Input
• patch Quoting Style

10.12 patch and the POSIX Standard

If you specify the --posix option, or set the POSIXLY_CORRECT environment variable, patch conforms more strictly to the POSIX standard, as follows:

• Take the first existing file from the list (old, new, index) when intuiting file names from diff headers. See Multiple Patches in a File.
• Do not remove files that are removed by a diff. See Creating and Removing Files.
• Do not ask whether to get files from RCS, ClearCase, or SCCS. See Revision Control.
• Require that all options precede the files in the command line.
• Do not backup files, even when there is a mismatch. See Backup Files.

10.13 GNU patch and Traditional patch

The current version of GNU patch normally follows the POSIX standard. See patch and the POSIX Standard, for the few exceptions to this general rule.

Unfortunately, POSIX redefined the behavior of patch in several important ways. You should be aware of the following differences if you must interoperate with traditional patch, or with GNU patch version 2.1 and earlier.

• In traditional patch, the -p option’s operand was optional, and a bare -p was equivalent to -p0. The -p option now requires an operand, and -p 0 is now equivalent to -p0. For maximum compatibility, use options like -p0 and -p1.

  Also, traditional patch simply counted slashes when stripping path prefixes; patch now counts pathname components. That is, a sequence of one or more adjacent slashes now counts as a single slash. For maximum portability, avoid sending patches containing // in file names.

• In traditional patch, backups were enabled by default. This behavior is now enabled with the --backup (-b) option.

  Conversely, in POSIX patch, backups are never made, even when there is a mismatch. In GNU patch, this behavior is enabled with the --no-backup-if-mismatch option, or by conforming to POSIX.

  The -b suffix option of traditional patch is equivalent to the ‘-b -z suffix’ options of GNU patch.

• Traditional patch used a complicated (and incompletely documented) method to intuit the name of the file to be patched from the patch header. This method did not conform to POSIX, and had a few gotchas. Now patch uses a different, equally complicated (but better documented) method that is optionally POSIX-conforming; we hope it has fewer gotchas. The two methods are compatible if the file names in the context diff header and the ‘Index:’ line are all identical after prefix-stripping. Your patch is normally compatible if each header’s file names all contain the same number of slashes.
• When traditional patch asked the user a question, it sent the question to standard error and looked for an answer from the first file in the following list that was a terminal: standard error, standard output, /dev/tty, and standard input. Now patch sends questions to standard output and gets answers from /dev/tty. Defaults for some answers have been changed so that patch never goes into an infinite loop when using default answers.
• Traditional patch exited with a status value that counted the number of bad hunks, or with status 1 if there was real trouble. Now patch exits with status 1 if some hunks failed, or with 2 if there was real trouble.
• Limit yourself to the following options when sending instructions meant to be executed by anyone running GNU patch, traditional patch, or a patch that conforms to POSIX. Spaces are significant in the following list, and operands are required.

  -c
  -d dir
  -D define
  -e
  -l
  -n
  -N
  -o outfile
  -pnum
  -R
  -r rejectfile