# quilt

## NAME



           quilt - manage a series of patches
    


## SYNOPSIS



           **quilt**[**--quiltrc** _file_] [**--trace**] _command_ [_options_]
    
           **quilt**[_command_] -h
           **quilt --version**
    


## DESCRIPTION



           _Quilt_ is a tool to manage large sets of patches by keeping track
           of the changes each patch makes.  Patches can be applied,
           unapplied, refreshed, and so forth.  The key philosophical concept
           is that your primary working material is patches.
    
           With _quilt_ , all work occurs within a single directory tree.
           Commands can be invoked from anywhere within the source tree.
           Like _CVS_ , _Subversion_ , or _Git_ , _quilt_ takes commands of the form
           “quilt _command_ ”.  A command can be truncated (abbreviated) as long
           as the specified part of the command is unambiguous.  If _command_
           is ambiguously short, _quilt_ lists all commands matching that
           prefix and exits.  All commands print a brief contextual help
           message and exit if given the “-h” option.
    
           _Quilt_ manages a stack of patches.  Patches are applied
           incrementally on top of the base tree plus all preceding patches.
           They can be pushed onto the stack (“quilt push”), and popped off
           the stack (“quilt pop”).  Commands are available for querying the
           contents of the stack (“quilt applied”, “quilt previous”, “quilt
           top”) and the patches that are not applied at a particular moment
           (“quilt next”, “quilt unapplied”).  By default, most commands
           apply to the topmost patch on the stack.
    
           Patch files are located in the _patches_ subdirectory of the source
           tree (see **Example of working tree** , under **FILES** , below).  The
           _QUILT_PATCHES_ environment variable overrides this default
           location.  When not found in the current directory, that
           subdirectory is searched recursively in the parent directories
           (this is similar to the way _Git_ searches for its configuration
           files).  The _patches_ directory may contain subdirectories.  It may
           also be a symbolic link instead of a directory.
    
           _Quilt_ creates and maintains a file called _series_ , which defines
           the order in which patches are applied.  The _QUILT_SERIES_
           environment variable overrides this default name.  You can query
           the contents of the series file at any time with “quilt series”.
           In this file, each patch file name is on a separate line.  Patch
           files are identified by path names that are relative to the
           _patches_ directory; patches may be in subdirectories below this
           directory.  Lines in the series file that start with a hash
           character (#) are ignored.  Patch options, such as the strip level
           or whether the patch is reversed, can be added after each patch
           file name.  Options are introduced by a space, separated by
           spaces, and follow the syntax of the patch(1) options (e.g.,
           “-p2”).  Quilt records patch options automatically when a command
           supporting them is used.  Without options, strip level 1 is
           assumed.  You can also add a comment after each patch file name
           and options, introduced by a space followed by a hash character.
           When _quilt_ adds, removes, or renames patches, it automatically
           updates the series file.  Users of _quilt_ can modify series files
           while some patches are applied, as long as the applied patches
           remain in their original order.  Unless there are means by which a
           series file can be generated automatically, you should provide it
           along with any set of _quilt_ -managed patches you distribute.
           Different series files can be used to assemble patches in
           different ways, corresponding (for example) to different
           development branches.
    
           Before a patch is applied, copies of all files the patch modifies
           are saved to the _.pc/_ patch-name directory, where _patch-name_ is the
           name of the patch (for example, _fix-buffer-overflow.patch_).  The
           patch is added to the list of currently applied patches
           (_.pc/applied-patches_).  Later, when a patch is regenerated (“quilt
           refresh”), the backup copies in _.pc/_ patch-name are compared with
           the current versions of the files in the source tree using GNU
           diff(1).
    
           A similar process occurs when starting a new patch (“quilt new”);
           the new patch file name is added to the series file.  A file to be
           changed by the patch is backed up and opened for editing (“quilt
           edit”).  After editing, inspect the impact of your changes (“quilt
           diff”); the changes stay local to your working tree until you call
           “quilt refresh” to write them to the patch file.
    
           Documentation related to a patch can be put at the beginning of
           its patch file (“quilt header”).  _Quilt_ is careful to preserve all
           text that precedes the actual patch when doing a refresh.  (This
           is limited to patches in unified format; see the GNU _Diffutils_
           manual.)
    
           The series file is looked up in the _.pc_ directory, in the root of
           the source tree, and in the patches directory.  The first series
           file that is found is used.  This may also be a symbolic link, or
           a file with multiple hard links.  Usually, only one series file is
           used for a set of patches, making the patches subdirectory a
           convenient location.
    
           The _.pc_ directory cannot be relocated, but it can be a symbolic
           link.  Its subdirectories must not be renamed or restructured.
           While patches are applied to the source tree, this directory is
           essential for many operations, including popping patches off the
           stack and refreshing them.  Files in the _.pc_ directory are
           automatically removed when they are no longer needed, so there is
           no need to clean up manually.
    
       **Quilt commands reference**
           **add**[-P patch] {file} ...
    
               Add one or more files to the topmost or named patch.  Files
               must be added to the patch before being modified.  Files that
               are modified by patches already applied on top of the
               specified patch cannot be added.
    
               -P patch
    
                   Patch to add files to.
    
           **annotate**[-P patch] {file}
    
               Print an annotated listing of the specified file showing which
               patches modify which lines. Only applied patches are included.
    
               -P patch
    
                   Stop checking for changes at the specified rather than the
                   topmost patch.
    
           **applied**[patch]
    
               Print a list of applied patches, or all patches up to and
               including the specified patch in the file series.
    
           **delete**[-r] [--backup] [patch|-n]
    
               Remove the specified or topmost patch from the series file.
               If the patch is applied, quilt will attempt to remove it
               first. (Only the topmost patch can be removed right now.)
    
               -n  Delete the next patch after topmost, rather than the
                   specified or topmost patch.
    
               -r  Remove the deleted patch file from the patches directory
                   as well.
    
               --backup
    
                   Rename the patch file to patch~ rather than deleting it.
                   Ignored if not used with `-r'.
    
           **diff**[-p n|-p ab] [-u|-U num|-c|-C num] [--combine patch|-z] [-R]
           [-P patch] [--snapshot] [--diff=utility] [--no-timestamps] [--no-
           index] [--sort] [--color[=always|auto|never]] [file ...]
    
               Produces a diff of the specified file(s) in the topmost or
               specified patch.  If no files are specified, all files that
               are modified are included.
    
               -p n
                   Create a -p n style patch (-p0 or -p1 are supported).
    
               -p ab
                   Create a -p1 style patch, but use a/file and b/file as the
                   original and new filenames instead of the default
                   dir.orig/file and dir/file names.
    
               -u, -U num, -c, -C num
    
                   Create a unified diff (-u, -U) with num lines of context.
                   Create a context diff (-c, -C) with num lines of context.
                   The number of context lines defaults to 3.
    
               --no-timestamps
    
                   Do not include file timestamps in patch headers.
    
               --no-index
    
                   Do not output Index: lines.
    
               -z  Write to standard output the changes that have been made
                   relative to the topmost or specified patch.
    
               -R  Create a reverse diff.
    
               -P patch
    
                   Create a diff for the specified patch.  (Defaults to the
                   topmost patch.)
    
               --combine patch
    
                   Create a combined diff for all patches between this patch
                   and the patch specified with -P. A patch name of `-' is
                   equivalent to specifying the first applied patch.
    
               --snapshot
    
                   Diff against snapshot (see `quilt snapshot -h').
    
               --diff=utility
    
                   Use the specified utility for generating the diff. The
                   utility is invoked with the original and new file name as
                   arguments.
    
               --color[=always|auto|never]
    
                   Use syntax coloring (auto activates it only if the output
                   is a tty).
    
               --sort
                   Sort files by their name instead of preserving the
                   original order.
    
           **edit** file ...
    
               Edit the specified file(s) in $EDITOR after adding it (them)
               to the topmost patch.
    
           **files**[-v] [-a] [-l] [--combine patch] [patch]
    
               Print the list of files that the topmost or specified patch
               changes.
    
               -a  List all files in all applied patches.
    
               -l  Add patch name to output.
    
               -v  Verbose, more user friendly output.
    
               --combine patch
    
                   Create a listing for all patches between this patch and
                   the topmost or specified patch. A patch name of `-' is
                   equivalent to specifying the first applied patch.
    
           **fold**[-R] [-q] [-f] [-p strip-level]
    
               Integrate the patch read from standard input into the topmost
               patch: After making sure that all files modified are part of
               the topmost patch, the patch is applied with the specified
               strip level (which defaults to 1).
    
               -R  Apply patch in reverse.
    
               -q  Quiet operation.
    
               -f  Force apply, even if the patch has rejects. Unless in
                   quiet mode, apply the patch interactively: the patch
                   utility may ask questions.
    
               -p strip-level
    
                   The number of pathname components to strip from file names
                   when applying patchfile.
    
           **fork**[new_name]
    
               Fork the topmost patch.  Forking a patch means creating a
               verbatim copy of it under a new name, and use that new name
               instead of the original one in the current series.  This is
               useful when a patch has to be modified, but the original
               version of it should be preserved, e.g.  because it is used in
               another series, or for the history.  A typical sequence of
               commands would be: fork, edit, refresh.
    
               If new_name is missing, the name of the forked patch will be
               the current patch name, followed by `-2'.  If the patch name
               already ends in a dash-and-number, the number is further
               incremented (e.g., patch.diff, patch-2.diff, patch-3.diff).
    
           **graph**[--all] [--reduce] [--lines[=num]] [--edge-labels=files] [-T
           ps] [patch]
    
               Generate a dot(1) directed graph showing the dependencies
               between applied patches. A patch depends on another patch if
               both touch the same file or, with the --lines option, if their
               modifications overlap. Unless otherwise specified, the graph
               includes all patches that the topmost patch depends on.  When
               a patch name is specified, instead of the topmost patch,
               create a graph for the specified patch. The graph will include
               all other patches that this patch depends on, as well as all
               patches that depend on this patch.
    
               --all
                   Generate a graph including all applied patches and their
                   dependencies. (Unapplied patches are not included.)
    
               --reduce
    
                   Eliminate transitive edges from the graph.
    
               --lines[=num]
    
                   Compute dependencies by looking at the lines the patches
                   modify.  Unless a different num is specified, two lines of
                   context are included.
    
               --edge-labels=files
    
                   Label graph edges with the file names that the adjacent
                   patches modify.
    
               -T ps
                   Directly produce a PostScript output file.
    
           **grep**[-h|options] {pattern}
    
               Grep through the source files, recursively, skipping patches
               and quilt meta-information. If no filename argument is given,
               the whole source tree is searched. Please see the grep(1)
               manual page for options.
    
               -h  Print this help. The grep -h option can be passed after a
                   double-dash (--). Search expressions that start with a
                   dash can be passed after a second double-dash (-- --).
    
           **header**[-a|-r|-e] [--backup] [--strip-diffstat] [--strip-trailing-
           whitespace] [patch]
    
               Print or change the header of the topmost or specified patch.
    
               -a, -r, -e
    
                   Append to (-a) or replace (-r) the exiting patch header,
                   or edit (-e) the header in $EDITOR. If none of these
                   options is given, print the patch header.
    
               --strip-diffstat
    
                   Strip diffstat output from the header.
    
               --strip-trailing-whitespace
    
                   Strip trailing whitespace at the end of lines of the
                   header.
    
               --backup
    
                   Create a backup copy of the old version of a patch as
                   patch~.
    
           **import**[-p num] [-R] [-P patch] [-f] [-d {o|a|n}] patchfile ...
    
               Import external patches.  The patches will be inserted
               following the current top patch, and must be pushed after
               import to apply them.
    
               -p num
    
                   Number of directory levels to strip when applying
                   (default=1)
    
               -R
    
                   Apply patch in reverse.
    
               -P patch
    
                   Patch filename to use inside quilt. This option can only
                   be used when importing a single patch.
    
               -f  Overwrite/update existing patches.
    
               -d {o|a|n}
    
                   When overwriting in existing patch, keep the old (o), all
                   (a), or new (n) patch header. If both patches include
                   headers, this option must be specified. This option is
                   only effective when -f is used.
    
           **mail**{--mbox file|--send} [-m text] [-M file] [--prefix prefix]
           [--sender ...] [--from ...] [--to ...] [--cc ...] [--bcc ...]
           [--subject ...] [--reply-to message] [--charset ...] [--signature
           file] [first_patch [last_patch]]
    
               Create mail messages from a specified range of patches, or all
               patches in the series file, and either store them in a mailbox
               file, or send them immediately. The editor is opened with a
               template for the introduction.  Please see
               /usr/local/share/doc/quilt/README.MAIL for details.  When
               specifying a range of patches, a first patch name of `-'
               denotes the first, and a last patch name of `-' denotes the
               last patch in the series.
    
               -m text
    
                   Text to use as the text in the introduction. When this
                   option is used, the editor will not be invoked, and the
                   patches will be processed immediately.
    
               -M file
    
                   Like the -m option, but read the introduction from file.
    
               --prefix prefix
    
                   Use an alternate prefix in the bracketed part of the
                   subjects generated. Defaults to `patch'.
    
               --mbox file
    
                   Store all messages in the specified file in mbox format.
                   The mbox can later be sent using formail, for example.
    
               --send
    
                   Send the messages directly.
    
               --sender
    
                   The envelope sender address to use. The address must be of
                   the form `user@domain.name'. No display name is allowed.
    
               --from, --subject
    
                   The values for the From and Subject headers to use. If no
                   --from option is given, the value of the --sender option
                   is used.
    
               --to, --cc, --bcc
    
                   Append a recipient to the To, Cc, or Bcc header.
    
               --charset
    
                   Specify a particular message encoding on systems which
                   don't use UTF-8 or ISO-8859-15. This character encoding
                   must match the one used in the patches.
    
               --signature file
    
                   Append the specified signature to messages (defaults to
                   ~/.signature if found; use `-' for no signature).
    
               --reply-to message
    
                   Add the appropriate headers to reply to the specified
                   message.
    
           **new**[-p n] {patchname}
    
               Create a new patch with the specified file name, and insert it
               after the topmost patch. The name can be prefixed with a sub-
               directory name, allowing for grouping related patches
               together.
    
               -p n
                   Create a -p n style patch (-p0 or -p1 are supported).
    
                   Quilt can be used in sub-directories of a source tree. It
                   determines the root of a source tree by searching for a
                   directory above the current working directory. Create a
                   directory in the intended root directory if quilt chooses
                   a top-level directory that is too high up in the directory
                   tree.
    
           **next**[patch]
    
               Print the name of the next patch after the specified or
               topmost patch in the series file.
    
           **patches**[-v] [--color[=always|auto|never]] {file} [files...]
    
               Print the list of patches that modify any of the specified
               files. (Uses a heuristic to determine which files are modified
               by unapplied patches.  Note that this heuristic is much slower
               than scanning applied patches.)
    
               -v  Verbose, more user friendly output.
    
               --color[=always|auto|never]
    
                   Use syntax coloring (auto activates it only if the output
                   is a tty).
    
           **pop**[-afRqv] [--refresh] [num|patch]
    
               Remove patch(es) from the stack of applied patches.  Without
               options, the topmost patch is removed.  When a number is
               specified, remove the specified number of patches.  When a
               patch name is specified, remove patches until the specified
               patch end up on top of the stack.  Patch names may include the
               patches/ prefix, which means that filename completion can be
               used.
    
               -a  Remove all applied patches.
    
               -f  Force remove. The state before the patch(es) were applied
                   will be restored from backup files.
    
               -R  Always verify if the patch removes cleanly; don't rely on
                   timestamp checks.
    
               -q  Quiet operation.
    
               -v  Verbose operation.
    
               --refresh
    
                   Automatically refresh every patch before it gets
                   unapplied.
    
           **previous**[patch]
    
               Print the name of the previous patch before the specified or
               topmost patch in the series file.
    
           **push**[-afqvm] [--fuzz=N] [--merge[=merge|diff3]] [--leave-rejects]
           [--color[=always|auto|never]] [--refresh] [num|patch]
    
               Apply patch(es) from the series file.  Without options, the
               next patch in the series file is applied.  When a number is
               specified, apply the specified number of patches.  When a
               patch name is specified, apply all patches up to and including
               the specified patch.  Patch names may include the patches/
               prefix, which means that filename completion can be used.
    
               -a  Apply all patches in the series file.
    
               -q  Quiet operation.
    
               -f  Force apply, even if the patch has rejects.
    
               -v  Verbose operation.
    
               --fuzz=N
    
                   Set the maximum fuzz factor (default: 2).
    
               -m, --merge[=merge|diff3]
    
                   Merge the patch file into the original files (see
                   patch(1)).
    
               --leave-rejects
    
                   Leave around the reject files patch produced, even if the
                   patch is not actually applied.
    
               --color[=always|auto|never]
    
                   Use syntax coloring (auto activates it only if the output
                   is a tty).
    
               --refresh
    
                   Automatically refresh every patch after it was
                   successfully applied.
    
           **refresh**[-p n|-p ab] [-u|-U num|-c|-C num] [-z[new_name]] [-f]
           [--no-timestamps] [--no-index] [--diffstat] [--sort] [--backup]
           [--strip-trailing-whitespace] [patch]
    
               Refreshes the specified patch, or the topmost patch by
               default.  Documentation that comes before the actual patch in
               the patch file is retained.
    
               It is possible to refresh patches that are not on top.  If any
               patches on top of the patch to refresh modify the same files,
               the script aborts by default.  Patches can still be refreshed
               with -f.  In that case this script will print a warning for
               each shadowed file, changes by more recent patches will be
               ignored, and only changes in files that have not been modified
               by any more recent patches will end up in the specified patch.
    
               -p n
                   Create a -p n style patch (-p0 or -p1 supported).
    
               -p ab
                   Create a -p1 style patch, but use a/file and b/file as the
                   original and new filenames instead of the default
                   dir.orig/file and dir/file names.
    
               -u, -U num, -c, -C num
    
                   Create a unified diff (-u, -U) with num lines of context.
                   Create a context diff (-c, -C) with num lines of context.
                   The number of context lines defaults to 3.
    
               -z[new_name]
    
                   Create a new patch containing the changes instead of
                   refreshing the topmost patch. If no new name is specified,
                   `-2' is added to the original patch name, etc. (See the
                   fork command.)
    
               --no-timestamps
    
                   Do not include file timestamps in patch headers.
    
               --no-index
    
                   Do not output Index: lines.
    
               --diffstat
    
                   Add a diffstat section to the patch header, or replace the
                   existing diffstat section.
    
               -f  Enforce refreshing of a patch that is not on top.
    
               --backup
    
                   Create a backup copy of the old version of a patch as
                   patch~.
    
               --sort
                   Sort files by their name instead of preserving the
                   original order.
    
               --strip-trailing-whitespace
    
                   Strip trailing whitespace at the end of lines.
    
           **remove**[-P patch] {file} ...
    
               Remove one or more files from the topmost or named patch.
               Files that are modified by patches on top of the specified
               patch cannot be removed.
    
               -P patch
    
                   Remove named files from the named patch.
    
           **rename**[-P patch] new_name
    
               Rename the topmost or named patch.
    
               -P patch
    
                   Patch to rename.
    
           **revert**[-P patch] {file} ...
    
               Revert uncommitted changes to the topmost or named patch for
               the specified file(s): after the revert, 'quilt diff -z' will
               show no differences for those files. Changes to files that are
               modified by patches on top of the specified patch cannot be
               reverted.
    
               -P patch
    
                   Revert changes in the named patch.
    
           **series**[--color[=always|auto|never]] [-v]
    
               Print the names of all patches in the series file.
    
               --color[=always|auto|never]
    
                   Use syntax coloring (auto activates it only if the output
                   is a tty).
    
               -v  Verbose, more user friendly output.
    
           **setup**[-d path-prefix] [-v] [--sourcedir dir] [--fuzz=N] [--spec-
           filter FILTER] [--slow|--fast] {specfile|seriesfile}
    
               Initializes a source tree from an rpm spec file or a quilt
               series file.
    
               -d  Optional path prefix for the resulting source tree.
    
               --sourcedir
    
                   Directory that contains the package sources. Defaults to
                   `.'.
    
               -v  Verbose debug output.
    
               --fuzz=N
    
                   Set the maximum fuzz factor (needs rpm 4.6 or later).
    
               --spec-filter FILTER
    
                   Before passing the spec file to rpmbuild for processing,
                   apply a filter to it. FILTER must be an executable script
                   which reads the original spec file from stdin and writes
                   the filtered spec file to stdout. FILTER can be specified
                   as a path to a custom script, or as a simple name, in
                   which case it references one of the filter scripts shipped
                   with quilt.
    
               --slow
                   Use the original, slow method to process the spec file. In
                   this mode, rpmbuild generates a working tree in a
                   temporary directory while all its actions are recorded,
                   and then everything is replayed from scratch in the target
                   directory.
    
               --fast
                   Use the new, faster method to process the spec file. In
                   this mode, rpmbuild is told to generate a working tree
                   directly in the target directory. This is the default
                   (since quilt version 0.67).
    
                   The setup command is only guaranteed to work properly on
                   spec files where applying all the patches is the last
                   thing done in the %prep section. This is a design
                   limitation due to the fact that quilt can only operate on
                   patches. If other commands in the %prep section modify the
                   patched files, they must come first, otherwise you won't
                   be able to push the patch series.
    
                   For example, a %prep section where you first unpack a
                   tarball, then apply patches, and lastly perform a tree-
                   wide string substitution, is not OK. For "quilt setup" to
                   work, it would have to be changed to unpacking the
                   tarball, then performing the tree-wide string
                   substitution, and lastly applying the patches.
    
           **snapshot**[-d]
    
               Take a snapshot of the current working state.  After taking
               the snapshot, the tree can be modified in the usual ways,
               including pushing and popping patches.  A diff against the
               tree at the moment of the snapshot can be generated with
               `quilt diff --snapshot'.
    
               -d  Only remove current snapshot.
    
           **top**
    
               Print the name of the topmost patch on the current stack of
               applied patches.
    
           **unapplied**[patch]
    
               Print a list of patches that are not applied, or all patches
               that follow the specified patch in the series file.
    
           **upgrade**
    
               Upgrade the meta-data in a working tree from an old version of
               quilt to the current version. This command is only needed when
               the quilt meta-data format has changed, and the working tree
               still contains old-format meta-data. In that case, quilt will
               request to run `quilt upgrade'.
    


## OPTIONS



           These options are common to all _quilt_ commands.
    
           **-h** Print a usage message (for the given _command_ , if one is
                  specified, otherwise for _quilt_ itself) and exit.
    
           **--quiltrc** _file_
                  Use _file_ as the configuration file instead of _~/.quiltrc_
                  (or _/etc/quilt.quiltrc_ if _~/.quiltrc_ does not exist).  The
                  special value “-” causes _quilt_ not to read any
                  configuration file.
    
           **--trace**
                  Run the command in the shell's trace mode (-x) for
                  debugging of internal operations.
    
           **--version**
                  Print the version number and exit.
    


## EXIT STATUS



           The exit status is 0 if the requested operation completed
           successfully, or 1 in case of error.
    
           An exit status of 2 indicates that _quilt_ did not do anything to
           complete the command.  This happens in particular when asking
           _quilt_ to push when the whole stack is already pushed, or to pop
           when the whole stack is already popped.  This behavior is intended
           to ease scripting with _quilt_.
    


## ENVIRONMENT



           _Quilt_ recognizes the following variables:
    
           _EDITOR_
               Specify the program to run to edit files; for instance, with
               “quilt edit” or “quilt header -e”.
    
           _LESS_
               Specify the arguments used to invoke the less(1) pager.
               Defaults to “-FRSX”.
    


## FILES



       **Example of working tree**
           project-1.2.3/
           ├── patches/
           │    ├── series         (list of patches to apply)
           │    ├── patch1.diff    (one particular patch)
           │    ├── patch2.diff
           │    └── ...
           ├── .pc/
           │    ├── .quilt_patches (content of QUILT_PATCHES)
           │    ├── .quilt_series  (content of QUILT_SERIES)
           │    ├── patch1.diff/   (copy of patched files)
           │    │    └── ...
           │    ├── patch2.diff/
           │    │    └── ...
           │    └── ...
           └── ...
    
           The _patches_ directory is precious as it contains all your patches
           as well as the order in which they should be applied.
    
           The _.pc_ directory contains metadata about the current state of
           your patch series.  Changing its content is not advised.  This
           directory can usually be regenerated from the initial files and
           the content of the _patches_ directory (provided that all patches
           were regenerated before the removal).
    
       **Configuration file**
           Upon startup, _quilt_ evaluates the file specified with the
           “--quiltrc” option; if that option is not given, the file _.quiltrc_
           in the user's home directory is used, and if that does not exist,
           _/etc/quilt.quiltrc_ is read.  This file is a bash(1) script.
           _EDITOR_ and _LESS_ can be overridden here if desired; see
           **ENVIRONMENT** , above.
    
           Define a variable of the form _QUILT__ COMMAND __ARGS_ to specify
           default options to be passed to any _quilt_ command (in uppercase).
           For example,
                  QUILT_DIFF_ARGS="--color=auto"
           causes the output of “quilt diff” to be syntax-colored when
           writing to a terminal.
    
           _QUILT_DIFF_OPTS_
               Additional options that _quilt_ shall pass to GNU _diff_ when
               generating patches.  A useful setting for C source code is
               “-p”, which causes GNU _diff_ to show in the resulting patch
               which function a change is in.
    
           _QUILT_PATCH_OPTS_
               Additional options that _quilt_ shall pass to GNU _patch_ when
               applying patches.  For example, recent versions of GNU _patch_
               support the “--reject-format=unified” option for generating
               reject files in “unified diff” style (older _patch_ versions
               used “--unified-reject-files” for that).
    
               You may also want to add the “-E” option if you have issues
               with _quilt_ not deleting empty files when you think it should.
               The documentation of GNU _patch_ says that “normally this option
               is unnecessary”, but when _patch_ is in POSIX mode or if the
               patch format doesn't distinguish empty files from deleted
               files, _patch_ deletes empty files only if the “-E” option is
               given.  Beware that when passing “-E” to _patch_ , _quilt_ will no
               longer be able to deal with empty files, which is why using
               “-E” is no longer the default.
    
           _QUILT_DIFFSTAT_OPTS_
               indicates additional options that _quilt_ shall pass to
               **diffstat**(1) when generating patch statistics.  For example,
               “-f0” can be used for an alternative output format.  Recent
               versions of _diffstat_ also support alternative rounding methods
               (“-r1”, “-r2”).
    
           _QUILT_PC_
               The location of backup files and any other data relating to
               the current state of the working directory from _quilt_ 's
               perspective.  Defaults to “.pc”.
    
           _QUILT_PATCHES_
               The location of patch files, defaulting to _patches_.
    
           _QUILT_SERIES_
               The name of the series file, defaulting to _series_.  Unless an
               absolute path is used, the search algorithm described above
               applies.
    
           _QUILT_PATCHES_PREFIX_
               Boolean flag; if set to anything, _quilt_ will prefix any patch
               name it prints with its directory (_QUILT_PATCHES_).
    
           _QUILT_NO_DIFF_INDEX_
               Boolean flag; if set to anything, no “Index:” line is
               prepended to patches generated by _quilt_.  This is shorthand
               for adding “--no-index” to both _QUILT_DIFF_ARGS_ and
               _QUILT_REFRESH_ARGS_.
    
           _QUILT_NO_DIFF_TIMESTAMPS_
               Boolean flag; if set to anything, no timestamps are included
               in headers when generating patches.  This is shorthand for
               adding “--no-timestamps” to both _QUILT_DIFF_ARGS_ and
               _QUILT_REFRESH_ARGS_.
    
           _QUILT_PAGER_
               The pager _quilt_ shall use for commands which produce paginated
               output.  If unset, the value of _GIT_PAGER_ or, failing that,
               _PAGER_ is used.  If none of these variables is set, “less -R”
               is used.  An empty value indicates that no pager should be
               used.
    
           _QUILT_COLORS_
               A sequence of definitions that directs _quilt_ which ANSI escape
               sequences to associate with an output context, overriding the
               defaults.  The most common use is to set colors (thus the name
               of this variable), but other attributes exist, such as bold or
               reverse.
    
               To override one or more settings, set _QUILT_COLORS_ to a colon-
               separated list of elements, each of the form “ _format-_
               _name_**=**_digit-sequence_[**;**...]”.
    
               Each _digit-sequence_ should be a SGR (Select Graphic Rendition)
               value supported by your terminal.  The standardized SGR values
               were specified by ANSI and incorporated into ISO-6429 and
               ECMA-48 (§8.3.117).  The colors have standard names but their
               values were not defined within a color space; their precise
               appearance will vary and may be customizable in your terminal
               (emulator).
    
               Recognized _format-name_ s, along with the _quilt_ commands that
               use them, their use contexts, and default values, follow.
               ┌──────────────────────────────────────────────────────────────┐
               │ _format-name_   command   context                 default      │
               ├──────────────────────────────────────────────────────────────┤
               │ **diff_add** diff      added lines             36 (cyan)    │
               │ **diff_cctx** diff      asterisk sequences      33 (yellow)  │
               │ **diff_ctx** diff      text after hunk         35 (magenta) │
               │ **diff_hdr** diff      index line              32 (green)   │
               │ **diff_hunk** diff      hunk header             33 (yellow)  │
               │ **diff_mod** diff      modified lines          35 (magenta) │
               │ **diff_rem** diff      removed lines           35 (magenta) │
               │ **patch_fail** push      failure message         31 (red)     │
               │ **patch_fuzz** push      fuzz information        35 (magenta) │
               │ **patch_offs** push      offset information      33 (yellow)  │
               │ **series_app** series    applied patch names     32 (green)   │
               │ **series_top** series    top patch name          33 (yellow)  │
               │ **series_una** series    unapplied patch names   0 (none)     │
               └──────────────────────────────────────────────────────────────┘
    
               All _format-name_ s used by the series command are also used by
               the patches command.
    
               The special _format-name_ “clear” is used to turn off special
               graphic renditions and return to the terminal defaults.
               Changing its definition should not be necessary for any
               terminal that claims to support ANSI escape sequences.  If
               your terminal is corrupted despite your best efforts, try the
               command “tput sgr0” to restore the default graphic rendition.
    
               As an example, one can put the following in _~/.quiltrc_ (or
               _/etc/quilt.quiltrc_):
                       QUILT_DIFF_ARGS="--color"
                       # Render diff file headers in bold blue over yellow.
                       # Render diff hunk headers in "negative image" yellow.
                       # Render failed patches with a red background.
                       QUILT_COLORS="diff_hdr=1;34;43:diff_hunk=7;33:patch_fail=41"
    


## EXAMPLES



           Please refer to the PDF documentation for a full example of use
           (under **SEE ALSO** below).
    


* * *