%\chapter{Mercurial Queues reference}
\chapter{Mercurial Queues $B%j%U%!%l%s%9(B}
\label{chap:mqref}

%\section{MQ command reference}
\section{MQ $B%3%^%s%I%j%U%!%l%s%9(B}
\label{sec:mqref:cmdref}

%For an overview of the commands provided by MQ, use the command
%\hgcmdargs{help}{mq}.

MQ$B$K$h$C$FDs6!$5$l$k%3%^%s%I$N35MW$K$D$$$F$O(B\hgcmdargs{help}{mq}$B$rMxMQ$5(B
$B$l$?$$!%(B

%\subsection{\hgxcmd{mq}{qapplied}---print applied patches}
\subsection{\hgxcmd{mq}{qapplied}---$BE,MQ$5$l$?%Q%C%A$NI=<((B}

%The \hgxcmd{mq}{qapplied} command prints the current stack of applied
%patches.  Patches are printed in oldest-to-newest order, so the last
%patch in the list is the ``top'' patch.

\hgxcmd{mq}{qapplied}$B%3%^%s%I$O!$E,MQ$5$l$?%Q%C%A$N8=:_$N%9%?%C%/$rI=<((B
$B$9$k!%%Q%C%A$O8E$$$b$N$+$i?7$7$$$b$N$N=g$KI=<($5$l$k!%$=$N$?$a!$%j%9%H$N(B
$B:G8e$N%Q%C%A$O(B``top''$B%Q%C%A$H$J$k!%(B

%\subsection{\hgxcmd{mq}{qcommit}---commit changes in the queue
%repository}
\subsection{\hgxcmd{mq}{qcommit}---$B%-%e!<$NCf$NJQ99$r%3%_%C%H$9$k(B

%The \hgxcmd{mq}{qcommit} command commits any outstanding changes in the
%\sdirname{.hg/patches} repository.  This command only works if the
%\sdirname{.hg/patches} directory is a repository, i.e.~you created the
%directory using \hgcmdargs{qinit}{\hgxopt{mq}{qinit}{-c}} or ran
%\hgcmd{init} in the directory after running \hgxcmd{mq}{qinit}.

\hgxcmd{mq}{qcommit}$B%3%^%s%I$O!$(B\sdirname{.hg/patches}$B%G%#%l%/%H%j$K$"$k(B
$BV(N)$7$?JQ99$r%3%_%C%H$9$k!%$3$N%3%^%s%I$O(B\sdirname{.hg/patches}$B%G%#%l%/(B
$B%H%j$,%j%]%8%H%j$N>l9g$K$N$_F0:n$9$k!%Nc$($P(B
\hgcmdargs{qinit}{\hgxopt{mq}{qinit}{-c}}$B%3%^%s%I$K$h$C$F%G%#%l%/%H%j$r:n$C(B
$B$?$j!$(B\hgxcmd{mq}{qinit}$B%3%^%s%I$N8e$K(B\hgcmd{init}$B$r<B9T$7$?>l9g$,AjEv$9(B
$B$k!%(B

%This command is shorthand for \hgcmdargs{commit}{--cwd .hg/patches}.

$B$3$N%3%^%s%I$O(B\hgcmdargs{commit}{--cwd .hg/patches}$B$NC;=L7A$G$"$k!%(B

%\subsection{\hgxcmd{mq}{qdelete}---delete a patch from the
%  \sfilename{series} file}
\subsection{\hgxcmd{mq}{qdelete}---\sfilename{series}$B%U%!%$%k$+$i%Q%C%A(B
  $B$r>C5n$9$k(B}

%The \hgxcmd{mq}{qdelete} command removes the entry for a patch from the
%\sfilename{series} file in the \sdirname{.hg/patches} directory.  It
%does not pop the patch if the patch is already applied.  By default,
%it does not delete the patch file; use the \hgxopt{mq}{qdel}{-f} option to
%do that.

\hgxcmd{mq}{qdelete}$B%3%^%s%I$O(B\sdirname{.hg/patches}$B%G%#%l%/%H%j$N(B
\sfilename{series}$B%U%!%$%k$+$i%Q%C%A$r>C5n$9$k!%%Q%C%A$,4{$KE,MQ$5$l$F$$(B
$B$k>l9g$O%Q%C%A$r%]%C%W$7$J$$!%%G%U%)%k%H$G$O%Q%C%A%U%!%$%k$r>C5n$7$J$$$?(B
$B$a!$$=$NMQES$G$O(B\hgxopt{mq}{qdel}{-f}$B%*%W%7%g%s$r;H$&!%(B

%Options:
$B%*%W%7%g%s(B:
\begin{itemize}
%\item[\hgxopt{mq}{qdel}{-f}] Delete the patch file.
\item[\hgxopt{mq}{qdel}{-f}] $B%Q%C%A$r>C5n$9$k!%(B
\end{itemize}

%\subsection{\hgxcmd{mq}{qdiff}---print a diff of the topmost applied
%patch}
\subsection{\hgxcmd{mq}{qdiff}---$B:G>e0L$NE,MQ$5$l$?%Q%C%A$N(Bdiff$B$r=PNO$9(B
  $B$k(B}

%The \hgxcmd{mq}{qdiff} command prints a diff of the topmost applied patch.
%It is equivalent to \hgcmdargs{diff}{-r-2:-1}.

\hgxcmd{mq}{qdiff}$B%3%^%s%I$O:G>e0L$NE,MQ$5$l$?%Q%C%A$N(Bdiff$B$r=PNO$9$k!%$3(B
$B$l$O(B\hgcmdargs{diff}{-r-2:-1}$B$HEy2A$G$"$k!%(B

%\subsection{\hgxcmd{mq}{qfold}---merge (``fold'') several patches into
%one}
\subsection{\hgxcmd{mq}{qfold}---$B$$$/$D$+$N%Q%C%A$r0l$D$K%^!<%8(B($B$^$?$O(B``fold'')$B$9$k(B}

%The \hgxcmd{mq}{qfold} command merges multiple patches into the topmost
%applied patch, so that the topmost applied patch makes the union of
%all of the changes in the patches in question.

\hgxcmd{mq}{qfold}$B%3%^%s%I$OJ#?t$N%Q%C%A$rE,MQ$5$l$?:F>e0L$N%Q%C%A$K%^!<(B
$B%8$9$k!%:F>e0L$N%Q%C%A$O4X?4$N$"$k%Q%C%AA4$F$NJQ99$N=89g$K$J$k!%(B

%The patches to fold must not be applied; \hgxcmd{mq}{qfold} will exit with
%an error if any is.  The order in which patches are folded is
%significant; \hgcmdargs{qfold}{a b} means ``apply the current topmost
%patch, followed by \texttt{a}, followed by \texttt{b}''.

fold$B$9$k%Q%C%A$OE,MQ$5$l$F$$$F$O$J$i$J$$!%(B\hgxcmd{mq}{qfold}$B$O!$$I$l$+$,(B
$BE,MQ$5$l$F$$$k>l9g$O%(%i!<$rJV$7$F=*N;$9$k!%(Bfold$B$5$l$k%Q%C%A$N=g=x$O=EMW(B
$B$G!$(B\hgcmdargs{qfold}{a b}$B$O!$(B``\texttt{a}, \texttt{b}$B$,B3$$$F$$$k8=:_$N(B
$B:F>e0L$N%Q%C%A$rE,MQ$9$k(B''$B$H$$$&0UL#$K$J$k!%(B

%The comments from the folded patches are appended to the comments of
%the destination patch, with each block of comments separated by three
%asterisk (``\texttt{*}'') characters.  Use the \hgxopt{mq}{qfold}{-e}
%option to edit the commit message for the combined patch/changeset
%after the folding has completed.

$B%U%)!<%k%I$5$l$?%Q%C%A$N%3%a%s%H$O!$L\E*$N%Q%C%A$N%3%a%s%H$KDI2C$5$l$k!%(B
$B3F!9$N%3%a%s%H%V%m%C%/$O(B3$B$D$N%"%9%?%j%9%/$K$h$C$FJ,N%$5$l$F$$$k!%(B
\hgxopt{mq}{qfold}{-e}$B%*%W%7%g%s$K$h$C$F!$%U%)!<%k%I$,40N;$7$?8e$K7k9g$7(B
$B$?%Q%C%A!?%A%'%s%8%;%C%H$N%3%_%C%H%a%C%;!<%8$rJT=8$9$k$3$H$,$G$-$k!%(B

%Options:
$B%*%W%7%g%s(B:
\begin{itemize}
%\item[\hgxopt{mq}{qfold}{-e}] Edit the commit message and patch description
%  for the newly folded patch.
\item[\hgxopt{mq}{qfold}{-e}] $B?7$?$K%U%)!<%k%I$5$l$k%Q%C%A$N%3%_%C%H%a%C(B
			      $B%;!<%8$H%Q%C%A$N@bL@$rJT=8$9$k!%(B
%\item[\hgxopt{mq}{qfold}{-l}] Use the contents of the given file as the new
%  commit message and patch description for the folded patch.
\item[\hgxopt{mq}{qfold}{-l}] $B%U%)!<%k%I$5$l$?%Q%C%A$N?7$7$$%3%_%C%H%a%C(B
			      $B%;!<%85Z$S%Q%C%A$N@bL@$H$7$F!$M?$($i$l$?%U%!(B
			      $B%$%k$r;HMQ$9$k!%(B
%\item[\hgxopt{mq}{qfold}{-m}] Use the given text as the new commit message
%  and patch description for the folded patch.
\item[\hgxopt{mq}{qfold}{-m}] $B%U%)!<%k%I$5$l$?%Q%C%A$N?7$7$$%3%_%C%H%a%C(B
			      $B%;!<%85Z$S%Q%C%A$N@bL@$H$7$F!$M?$($i$l$?%F(B
			      $B%-%9%H$rMQ$$$k!%(B
\end{itemize}

%\subsection{\hgxcmd{mq}{qheader}---display the header/description of a patch}
\subsection{\hgxcmd{mq}{qheader}---$B%Q%C%A$N%X%C%@!?@bL@$rI=<((B}

%The \hgxcmd{mq}{qheader} command prints the header, or description, of a
%patch.  By default, it prints the header of the topmost applied patch.
%Given an argument, it prints the header of the named patch.

\hgxcmd{mq}{qheader}$B%3%^%s%I$O%Q%C%A$N%X%C%@$^$?$O@bL@$rI=<($9$k!%%G%U%)(B
$B%k%H$G$O:F>e0L$KE,MQ$5$l$?%Q%C%A$N%X%C%@$rI=<($9$k!%0z?t$,EO$5$l$k$H!$;X(B
$BDj$5$l$?%Q%C%A$N%X%C%@$rI=<($9$k(B

%\subsection{\hgxcmd{mq}{qimport}---import a third-party patch into the
%queue}
\subsection{\hgxcmd{mq}{qimport}---$B%5!<%I%Q!<%F%#$N%Q%C%A$r%-%e!<$X%$%s(B
  $B%]!<%H$9$k(B}

%The \hgxcmd{mq}{qimport} command adds an entry for an external patch to the
%\sfilename{series} file, and copies the patch into the
%\sdirname{.hg/patches} directory.  It adds the entry immediately after
%the topmost applied patch, but does not push the patch.

\hgxcmd{mq}{qimport}$B%3%^%s%I$O!$(B\sfilename{series}$B%U%!%$%k$K30It$N%Q%C%A(B
$B$N$?$a$N%(%s%H%j$rDI2C$7!$%Q%C%A$r(B\sdirname{.hg/patches}$B%G%#%l%/%H%j$K%3(B
$B%T!<$9$k!%DI2C$O:F>e0L$NE,MQ:Q$_%Q%C%A$ND>8e$K9T$o$l!$%Q%C%A$N%W%C%7%e$O(B
$B9T$o$J$$!%(B

%If the \sdirname{.hg/patches} directory is a repository,
%\hgxcmd{mq}{qimport} automatically does an \hgcmd{add} of the imported
%patch.

\sdirname{.hg/patches}$B%G%#%l%/%H%j$,%j%]%8%H%j$N>l(B
$B9g!$(B\hgxcmd{mq}{qimport}$B$O<+F0E*$K%$%s%]!<%H$5$l$?%Q%C%A$KBP$7$F(B
\hgcmd{add}$B$r9T$&!%(B

%\subsection{\hgxcmd{mq}{qinit}---prepare a repository to work with MQ}
\subsection{\hgxcmd{mq}{qinit}---MQ$B$G;HMQ$9$k%j%]%8%H%j$rMQ0U$9$k(B}

%The \hgxcmd{mq}{qinit} command prepares a repository to work with MQ.  It
%creates a directory called \sdirname{.hg/patches}.

\hgxcmd{mq}{qinit}$B%3%^%s%I$O(BMQ$B$G;HMQ$9$k%j%]%8%H%j$rMQ0U$9(B
$B$k!%(B\sdirname{.hg/patches}$B$H$$$&%G%#%l%/%H%j$,:n$i$l$k!%(B

%Options:
$B%*%W%7%g%s(B:
\begin{itemize}
%\item[\hgxopt{mq}{qinit}{-c}] Create \sdirname{.hg/patches} as a repository
%  in its own right.  Also creates a \sfilename{.hgignore} file that
%  will ignore the \sfilename{status} file.
\item[\hgxopt{mq}{qinit}{-c}] \sdirname{.hg/patches}$B$r%j%]%8%H%j$H$7$F!$(B
			      $B%3%^%s%I<B9T;~$N8"8B$G:n@.$9$k!%F1;~$K(B
			      \sfilename{status}$B%U%!%$%k$rL5;k$9$k$?$a$K(B
			      \sfilename{.hgignore}$B%U%!%$%k$r:n@.$9$k!%(B
\end{itemize}

%When the \sdirname{.hg/patches} directory is a repository, the
%\hgxcmd{mq}{qimport} and \hgxcmd{mq}{qnew} commands automatically \hgcmd{add}
%new patches.

\sdirname{.hg/patches}$B%G%#%l%/%H%j$,%j%]%8%H%j$N>l(B
$B9g!$(B\hgxcmd{mq}{qimport}$B%3%^%s%I$H(B\hgxcmd{mq}{qnew}$B%3%^%s%I$O?7$7$$%Q%C(B
$B%A$r<+F0E*$K(B\hgcmd{add}$B$9$k!%(B

%\subsection{\hgxcmd{mq}{qnew}---create a new patch}
\subsection{\hgxcmd{mq}{qnew}---$B?7$7$$%Q%C%A$r:n@.$9$k(B}

%The \hgxcmd{mq}{qnew} command creates a new patch.  It takes one mandatory
%argument, the name to use for the patch file.  The newly created patch
%is created empty by default.  It is added to the \sfilename{series}
%file after the current topmost applied patch, and is immediately
%pushed on top of that patch.

\hgxcmd{mq}{qnew}$B%3%^%s%I$O?7$7$$%Q%C%A$r:n@.$9$k!%$3$N%3%^%s%I$OI,?\$N0z(B
$B?t$H$7$F%Q%C%A%U%!%$%k$H$7$F;HMQ$9$kL>A0$r<h$k!%?75,$K:n@.$5$l$?%Q%C%A(B
$B$O!$%G%U%)%k%H$G$O6u$G$"$j!$(B\sfilename{series}$B%U%!%$%k$K!$8=:_$N:F>e0L$N(B
$BE,MQ$5$l$?%Q%C%A$ND>8e$KDI2C$5$l!$D>$A$K$=$N%Q%C%A$N>e$K%W%C%7%e$5$l$k!%(B

%If \hgxcmd{mq}{qnew} finds modified files in the working directory, it will
%refuse to create a new patch unless the \hgxopt{mq}{qnew}{-f} option is
%used (see below).  This behaviour allows you to \hgxcmd{mq}{qrefresh} your
%topmost applied patch before you apply a new patch on top of it.

\hgxcmd{mq}{qnew}$B$O!$%o!<%-%s%0%G%#%l%/%H%j$+$iJQ99$5$l$?%U%!%$%k$r8+$D$1(B
$B$k$H!$(B\hgxopt{mq}{qnew}{-f}$B%*%W%7%g%s!J2<5-$r;2>H!K$,;H$o$l$J$$8B$j?7$7$$(B
$B%Q%C%A$N:n@.$r5qH]$9$k!%$3$N5sF0$N$?$a!$:F>e0L$NE,MQ$5$l$?%Q%C%A$N>e$K?7(B
$B$?$J%Q%C%A$rE,MQ$9$kA0$K!$(B\hgxcmd{mq}{qrefresh}$B$9$k$3$H$,$G$-$k!%(B

%Options:
$B%*%W%7%g%s(B:
\begin{itemize}
%\item[\hgxopt{mq}{qnew}{-f}] Create a new patch if the contents of the
%  working directory are modified.  Any outstanding modifications are
%  added to the newly created patch, so after this command completes,
%  the working directory will no longer be modified.
\item[\hgxopt{mq}{qnew}{-f}] $B%+%l%s%H%G%#%l%/%H%j$NFbMF$,99?7$5$l$F$$$k(B
			     $B>l9g!$?7$7$$%Q%C%A$r:n@.$9$k!%8IN)$7$?JQ2&(B
			     $B$O?75,$K:n@.$7$?%Q%C%A$KDI2C$5$l!$$3$N%3%^(B
			     $B%s%I$,=*N;$9$k$H%o!<%-%s%0%G%#%l%/%H%j$OJQ(B
			     $B99$J$7$N>uBV$K$J$k!%(B
%\item[\hgxopt{mq}{qnew}{-m}] Use the given text as the commit message.
%  This text will be stored at the beginning of the patch file, before
%  the patch data.
\item[\hgxopt{mq}{qnew}{-m}] $BM?$($i$l$?%F%-%9%H$r%3%_%C%H%a%C%;!<%8$H$7(B
			     $B$FMQ$$$k!%$3$N%F%-%9%H$O%Q%C%A%U%!%$%k$N@h(B
			     $BF,$G%G!<%?$NA0$K5-O?$5$l$k!%(B
\end{itemize}

%\subsection{\hgxcmd{mq}{qnext}---print the name of the next patch}
\subsection{\hgxcmd{mq}{qnext}---$B<!$N%Q%C%A$NL>A0$rI=<($9$k(B}

%The \hgxcmd{mq}{qnext} command prints the name of the next patch in
%the \sfilename{series} file after the topmost applied patch.  This
%patch will become the topmost applied patch if you run \hgxcmd{mq}{qpush}.

\hgxcmd{mq}{qnext}$B%3%^%s%I$O(B\sfilename{series}$B%U%!%$%k$N<!$N%Q%C%A$NL>A0(B
$B$rI=<($9$k!%$3$N%Q%C%A$O!$(B\hgxcmd{mq}{qpush}$B$r<B9T$9$k$H:G>e0L$NE,MQ:Q$_(B
$B%Q%C%A$H$J$k(B

%\subsection{\hgxcmd{mq}{qpop}---pop patches off the stack}
\subsection{\hgxcmd{mq}{qpop}---$B%9%?%C%/$+$i%Q%C%A$r%]%C%W$9$k(B}

%The \hgxcmd{mq}{qpop} command removes applied patches from the top of the
%stack of applied patches.  By default, it removes only one patch.

\hgxcmd{mq}{qpop}$B%3%^%s%I$OE,MQ$5$l$?%Q%C%A$N%9%?%C%/$N%H%C%W$+$i%Q%C%A(B
$B$r=|5n$9$k!%%G%U%)%k%H$G$O%Q%C%A$r(B1$B$D=|5n$9$k!%(B

%This command removes the changesets that represent the popped patches
%from the repository, and updates the working directory to undo the
%effects of the patches.

$B$3$N%3%^%s%I$O%j%]%8%H%j$+$i%]%C%W$5$l$?%Q%C%A$rI=$9%A%'%s%8%;%C%H$r=|5n(B
$B$7!$%o!<%-%s%0%G%#%l%/%H%j$r%Q%C%A$N8z2L$r=|5n$9$k$h$&$K99?7$9$k!%(B

This command takes an optional argument, which it uses as the name or
index of the patch to pop to.  If given a name, it will pop patches
until the named patch is the topmost applied patch.  If given a
number, \hgxcmd{mq}{qpop} treats the number as an index into the entries in
the series file, counting from zero (empty lines and lines containing
only comments do not count).  It pops patches until the patch
identified by the given index is the topmost applied patch.

$B$3$N%3%^%s%I$O%*%W%7%g%s$N0z?t$r<h$j!$(B

The \hgxcmd{mq}{qpop} command does not read or write patches or the
\sfilename{series} file.  It is thus safe to \hgxcmd{mq}{qpop} a patch that
you have removed from the \sfilename{series} file, or a patch that you
have renamed or deleted entirely.  In the latter two cases, use the
name of the patch as it was when you applied it.

By default, the \hgxcmd{mq}{qpop} command will not pop any patches if the
working directory has been modified.  You can override this behaviour
using the \hgxopt{mq}{qpop}{-f} option, which reverts all modifications in
the working directory.

Options:
\begin{itemize}
\item[\hgxopt{mq}{qpop}{-a}] Pop all applied patches.  This returns the
  repository to its state before you applied any patches.
\item[\hgxopt{mq}{qpop}{-f}] Forcibly revert any modifications to the
  working directory when popping.
\item[\hgxopt{mq}{qpop}{-n}] Pop a patch from the named queue.
\end{itemize}

The \hgxcmd{mq}{qpop} command removes one line from the end of the
\sfilename{status} file for each patch that it pops.

%\subsection{\hgxcmd{mq}{qprev}---print the name of the previous patch}
\subsection{\hgxcmd{mq}{qprev}---$B0JA0$N%Q%C%A$NL>A0$rI=<($9$k(B}

The \hgxcmd{mq}{qprev} command prints the name of the patch in the
\sfilename{series} file that comes before the topmost applied patch.
This will become the topmost applied patch if you run \hgxcmd{mq}{qpop}.

%\subsection{\hgxcmd{mq}{qpush}---push patches onto the stack}
\subsection{\hgxcmd{mq}{qpush}---$B%Q%C%A$r%9%?%C%/$K%W%C%7%e$9$k(B}
\label{sec:mqref:cmd:qpush}

The \hgxcmd{mq}{qpush} command adds patches onto the applied stack.  By
default, it adds only one patch.

This command creates a new changeset to represent each applied patch,
and updates the working directory to apply the effects of the patches.

The default data used when creating a changeset are as follows:
\begin{itemize}
\item The commit date and time zone are the current date and time
  zone.  Because these data are used to compute the identity of a
  changeset, this means that if you \hgxcmd{mq}{qpop} a patch and
  \hgxcmd{mq}{qpush} it again, the changeset that you push will have a
  different identity than the changeset you popped.
\item The author is the same as the default used by the \hgcmd{commit}
  command.
\item The commit message is any text from the patch file that comes
  before the first diff header.  If there is no such text, a default
  commit message is used that identifies the name of the patch.
\end{itemize}
If a patch contains a Mercurial patch header (XXX add link), the
information in the patch header overrides these defaults.

Options:
\begin{itemize}
\item[\hgxopt{mq}{qpush}{-a}] Push all unapplied patches from the
  \sfilename{series} file until there are none left to push.
\item[\hgxopt{mq}{qpush}{-l}] Add the name of the patch to the end
  of the commit message.
\item[\hgxopt{mq}{qpush}{-m}] If a patch fails to apply cleanly, use the
  entry for the patch in another saved queue to compute the parameters
  for a three-way merge, and perform a three-way merge using the
  normal Mercurial merge machinery.  Use the resolution of the merge
  as the new patch content.
\item[\hgxopt{mq}{qpush}{-n}] Use the named queue if merging while pushing.
\end{itemize}

The \hgxcmd{mq}{qpush} command reads, but does not modify, the
\sfilename{series} file.  It appends one line to the \hgcmd{status}
file for each patch that it pushes.

%\subsection{\hgxcmd{mq}{qrefresh}---update the topmost applied patch}
\subsection{\hgxcmd{mq}{qrefresh}---$B:F>e0L$NE,MQ:Q$_%Q%C%A$r99?7$9$k(B}

The \hgxcmd{mq}{qrefresh} command updates the topmost applied patch.  It
modifies the patch, removes the old changeset that represented the
patch, and creates a new changeset to represent the modified patch.

The \hgxcmd{mq}{qrefresh} command looks for the following modifications:
\begin{itemize}
\item Changes to the commit message, i.e.~the text before the first
  diff header in the patch file, are reflected in the new changeset
  that represents the patch.
\item Modifications to tracked files in the working directory are
  added to the patch.
\item Changes to the files tracked using \hgcmd{add}, \hgcmd{copy},
  \hgcmd{remove}, or \hgcmd{rename}.  Added files and copy and rename
  destinations are added to the patch, while removed files and rename
  sources are removed.
\end{itemize}

Even if \hgxcmd{mq}{qrefresh} detects no changes, it still recreates the
changeset that represents the patch.  This causes the identity of the
changeset to differ from the previous changeset that identified the
patch.

Options:
\begin{itemize}
\item[\hgxopt{mq}{qrefresh}{-e}] Modify the commit and patch description,
  using the preferred text editor.
\item[\hgxopt{mq}{qrefresh}{-m}] Modify the commit message and patch
  description, using the given text.
\item[\hgxopt{mq}{qrefresh}{-l}] Modify the commit message and patch
  description, using text from the given file.
\end{itemize}

\subsection{\hgxcmd{mq}{qrename}---rename a patch}

The \hgxcmd{mq}{qrename} command renames a patch, and changes the entry for
the patch in the \sfilename{series} file.

With a single argument, \hgxcmd{mq}{qrename} renames the topmost applied
patch.  With two arguments, it renames its first argument to its
second.

%\subsection{\hgxcmd{mq}{qrestore}---restore saved queue state}
\subsection{\hgxcmd{mq}{qrestore}---$B%;!<%V$5$l$?%-%e!<>uBV$KI|85$9$k(B}

XXX No idea what this does.

%\subsection{\hgxcmd{mq}{qsave}---save current queue state}
\subsection{\hgxcmd{mq}{qsave}---$B8=:_$N%-%e!<>uBV$r%;!<%V$9$k(B}

XXX Likewise.

%\subsection{\hgxcmd{mq}{qseries}---print the entire patch series}
\subsection{\hgxcmd{mq}{qseries}---$B%Q%C%A7ONs$rA4$FI=<((B}

The \hgxcmd{mq}{qseries} command prints the entire patch series from the
\sfilename{series} file.  It prints only patch names, not empty lines
or comments.  It prints in order from first to be applied to last.

%\subsection{\hgxcmd{mq}{qtop}---print the name of the current patch}
\subsection{\hgxcmd{mq}{qtop}---$B8=:_$N%Q%C%A$NL>A0$rI=<((B}

The \hgxcmd{mq}{qtop} prints the name of the topmost currently applied
patch.

%\subsection{\hgxcmd{mq}{qunapplied}---print patches not yet applied}
\subsection{\hgxcmd{mq}{qunapplied}---$BL$E,MQ$N%Q%C%A$rI=<((B}

The \hgxcmd{mq}{qunapplied} command prints the names of patches from the
\sfilename{series} file that are not yet applied.  It prints them in
order from the next patch that will be pushed to the last.

%\subsection{\hgcmd{strip}---remove a revision and descendants}
\subsection{\hgcmd{strip}---$B%j%S%8%g%s$H$=$N;RB9$r:o=|(B}

The \hgcmd{strip} command removes a revision, and all of its
descendants, from the repository.  It undoes the effects of the
removed revisions from the repository, and updates the working
directory to the first parent of the removed revision.

The \hgcmd{strip} command saves a backup of the removed changesets in
a bundle, so that they can be reapplied if removed in error.

Options:
\begin{itemize}
\item[\hgopt{strip}{-b}] Save unrelated changesets that are intermixed
  with the stripped changesets in the backup bundle.
\item[\hgopt{strip}{-f}] If a branch has multiple heads, remove all
  heads. XXX This should be renamed, and use \texttt{-f} to strip revs
  when there are pending changes.
\item[\hgopt{strip}{-n}] Do not save a backup bundle.
\end{itemize}

%\section{MQ file reference}
\section{MQ $B%U%!%$%k%j%U%!%l%s%9(B}

%\subsection{The \sfilename{series} file}
\subsection{\sfilename{series}$B%U%!%$%k(B}

The \sfilename{series} file contains a list of the names of all
patches that MQ can apply.  It is represented as a list of names, with
one name saved per line.  Leading and trailing white space in each
line are ignored.

Lines may contain comments.  A comment begins with the ``\texttt{\#}''
character, and extends to the end of the line.  Empty lines, and lines
that contain only comments, are ignored.

You will often need to edit the \sfilename{series} file by hand, hence
the support for comments and empty lines noted above.  For example,
you can comment out a patch temporarily, and \hgxcmd{mq}{qpush} will skip
over that patch when applying patches.  You can also change the order
in which patches are applied by reordering their entries in the
\sfilename{series} file.

Placing the \sfilename{series} file under revision control is also
supported; it is a good idea to place all of the patches that it
refers to under revision control, as well.  If you create a patch
directory using the \hgxopt{mq}{qinit}{-c} option to \hgxcmd{mq}{qinit}, this
will be done for you automatically.

%\subsection{The \sfilename{status} file}
\subsection{\sfilename{status}$B%U%!%$%k(B}

%The \sfilename{status} file contains the names and changeset hashes of
%all patches that MQ currently has applied.  Unlike the
%\sfilename{series} file, this file is not intended for editing.  You
%should not place this file under revision control, or modify it in any
%way.  It is used by MQ strictly for internal book-keeping.

\sfilename{status}$B%U%!%$%k$O(BMQ$B$,8=:_E,MQ$7$F$$$k$9$Y$F$N%Q%C%A$NL>A0$H%A%'(B
$B%s%8%;%C%H%O%C%7%e$r;}$D!%(B\sfilename{series}$B%U%!%$%k$H0c$C$F!$$3$N%U%!%$(B
$B%k$OJT=8$5$l$k$3$H$r0U?^$7$F$$$J$$!%$3$N%U%!%$%k$O%j%S%8%g%s4IM}$7$?$j!$(B
$BJT=8$7$?$j$9$Y$-$G$O$J$$!%$3$l$O(BMQ$B$K$h$C$FFbIt$N4IM}$KMQ$$$i$l$k$Y$-$b$N(B
$B$G$"$k!%(B

%%% Local Variables: 
%%% mode: yatex
%%% TeX-master: "00book"
%%% End: 
