Mercurial > hgbook
comparison ja/mq.tex @ 343:f3f56da2e650
more mq.tex
author | Yoshiki Yazawa <yaz@honeyplnaet.jp> |
---|---|
date | Sun, 13 Jul 2008 01:01:02 +0900 |
parents | cb130184dd23 |
children | cea705a64649 |
comparison
equal
deleted
inserted
replaced
342:dfa9910e2a2e | 343:f3f56da2e650 |
---|---|
966 \end{itemize} | 966 \end{itemize} |
967 | 967 |
968 %\subsection{Beware the fuzz} | 968 %\subsection{Beware the fuzz} |
969 \subsection{$B[#Kf$JE@$K$D$$$F(B} | 969 \subsection{$B[#Kf$JE@$K$D$$$F(B} |
970 | 970 |
971 While applying a hunk at an offset, or with a fuzz factor, will often | 971 %While applying a hunk at an offset, or with a fuzz factor, will often |
972 be completely successful, these inexact techniques naturally leave | 972 %be completely successful, these inexact techniques naturally leave |
973 open the possibility of corrupting the patched file. The most common | 973 %open the possibility of corrupting the patched file. The most common |
974 cases typically involve applying a patch twice, or at an incorrect | 974 %cases typically involve applying a patch twice, or at an incorrect |
975 location in the file. | 975 %location in the file. If \command{patch} or \hgxcmd{mq}{qpush} ever |
976 | 976 %mentions an offset or fuzz factor, you should make sure that the |
977 If \command{patch} or \hgxcmd{mq}{qpush} ever | 977 %modified files are correct afterwards. |
978 mentions an offset or fuzz factor, you should make sure that the | 978 |
979 modified files are correct afterwards. | 979 $B$"$k%*%U%;%C%H$d(Bfuzz factor$B$N0LCV$X$N(Bhunk$B$NE,MQ$O!$B?$/$N>l9gLdBj$J$/@.8y(B |
980 | 980 $B$9$k$,!$IT@53N$J%^%C%A$rMQ$$$?>l9g!$%Q%C%A$rE,MQ$7$?%U%!%$%k$r2u$7$F$$$k(B |
981 $B$"$k%*%U%;%C%H$d(Bfuzz factor$B$N0LCV$X$N(Bhunk$B$NE,MQ$OB?$/$N>l9gA4$/LdBj$J$/@.(B | 981 $B2DG=@-$,;D$k!%:G$b$h$/$"$k$N$O!$%Q%C%A$rFsEYE,MQ$7$?$j!$%U%!%$%k$N4V0c$C(B |
982 $B8y$9$k$,!$IT@53N$J%^%C%A$rMQ$$$?>l9g!$%Q%C%A$rE,MQ$7$?%U%!%$%k$r2u$7$F$$(B | 982 $B$?>l=j$KE,MQ$7$F$7$^$&$3$H$@!%(B\command{patch}$B$^$?$O(B\hgxcmd{mq}{qpush}$B$,%*(B |
983 $B$k2DG=@-$,;D$k!%(B | 983 $B%U%;%C%H$+(Bfuzz$B%U%!%/%?!<$rI=<($7$F$$$k9g!$JQ99$5$l$?%U%!%$%k$,@5>o$G$"$k(B |
984 | 984 $B$+3NG'$9$kI,MW$,$"$k!%(B |
985 $B%Q%C%A$rFsEYE,MQ$7$?$j!$%U%!%$%k$N4V0c$C$?>l=j$KE,MQ$7$F$7$^$&$N$,0lHV$h(B | 985 |
986 $B$/$"$k4V0c$$$@!%(B | 986 %It's often a good idea to refresh a patch that has applied with an |
987 | 987 %offset or fuzz factor; refreshing the patch generates new context |
988 | 988 %information that will make it apply cleanly. I say ``often,'' not |
989 | 989 %``always,'' because sometimes refreshing a patch will make it fail to |
990 | 990 %apply against a different revision of the underlying files. In some |
991 It's often a good idea to refresh a patch that has applied with an | 991 %cases, such as when you're maintaining a patch that must sit on top of |
992 offset or fuzz factor; refreshing the patch generates new context | 992 %multiple versions of a source tree, it's acceptable to have a patch |
993 information that will make it apply cleanly. I say ``often,'' not | 993 %apply with some fuzz, provided you've verified the results of the |
994 ``always,'' because sometimes refreshing a patch will make it fail to | 994 %patching process in such cases. |
995 apply against a different revision of the underlying files. In some | 995 |
996 cases, such as when you're maintaining a patch that must sit on top of | 996 $B%*%U%;%C%H$d(Bfuzz factor$B$N=P$?%Q%C%A$r%j%U%l%C%7%e$9$k$N$OB?$/$N>l9gNI$$9M(B |
997 multiple versions of a source tree, it's acceptable to have a patch | 997 $B$($G$"$k!%%Q%C%A$r%j%U%l%C%7%e$9$k$H!$?7$7$$%3%s%F%-%9%H>pJs$,@8@.$5$l!$(B |
998 apply with some fuzz, provided you've verified the results of the | 998 $B%Q%C%A$,%/%j!<%s$KE,MQ$G$-$k$h$&$K$J$k!%!V>o$K!W$G$O$J$J$/!VB?$/$N>l9g!W(B |
999 patching process in such cases. | 999 $B$HCG$C$?$N$O!$%Q%C%A$r%j%U%l%C%7%e$9$k$3$H$G!$85$N%U%!%$%k$N0[$J$C$?%j%S(B |
1000 $B%8%g%s$G%Q%C%A$,E,MQ$G$-$J$/$J$k$3$H$,$"$k$+$i$@!%J#?t$N%P!<%8%g%s$N%=!<(B | |
1001 $B%9%D%j!<$N>e$GE,MQ2DG=$J%Q%C%A$r4IM}$7$J$1$l$P$J$i$J$$$h$&$J>l9g$J$I$O!$(B | |
1002 $B%Q%C%A$N7k2L$r8!>Z$7$F$"$k$N$G$"$l$P(Bfuzz$B$N=P$k%Q%C%A$b5vMF$5$lF@$k!%(B | |
1000 | 1003 |
1001 %\subsection{Handling rejection} | 1004 %\subsection{Handling rejection} |
1002 \subsection{$B%j%8%'%/%H$N<h$j07$$(B} | 1005 \subsection{$B%j%8%'%/%H$N<h$j07$$(B} |
1003 | 1006 |
1004 If \hgxcmd{mq}{qpush} fails to apply a patch, it will print an error | 1007 %If \hgxcmd{mq}{qpush} fails to apply a patch, it will print an error |
1005 message and exit. If it has left \sfilename{.rej} files behind, it is | 1008 %message and exit. If it has left \sfilename{.rej} files behind, it is |
1006 usually best to fix up the rejected hunks before you push more patches | 1009 %usually best to fix up the rejected hunks before you push more patches |
1007 or do any further work. | 1010 %or do any further work. |
1008 | 1011 |
1009 If your patch \emph{used to} apply cleanly, and no longer does because | 1012 \hgxcmd{mq}{qpush}$B$O%Q%C%A$NE,MQ$K<:GT$7$?>l9g!$%(%i!<%a%C%;!<%8$rI=<($7(B |
1010 you've changed the underlying code that your patches are based on, | 1013 $B$F=*N;$9$k!%(B\sfilename{.rej}$B%U%!%$%k$,:n$i$l$F$$$k>l9g$O!$DL>o!$$5$i$J$k(B |
1011 Mercurial Queues can help; see section~\ref{sec:mq:merge} for details. | 1014 $B%Q%C%A$NDI2C$d?7$7$$:n6H$NA0$K%j%8%'%/%H$5$l$?(Bhunk$B$K$D$$$F=$@5$r9T$&$Y$-(B |
1012 | 1015 $B$G$"$k!%(B |
1013 Unfortunately, there aren't any great techniques for dealing with | 1016 |
1014 rejected hunks. Most often, you'll need to view the \sfilename{.rej} | 1017 %If your patch \emph{used to} apply cleanly, and no longer does because |
1015 file and edit the target file, applying the rejected hunks by hand. | 1018 %you've changed the underlying code that your patches are based on, |
1016 | 1019 %Mercurial Queues can help; see section~\ref{sec:mq:merge} for details. |
1017 If you're feeling adventurous, Neil Brown, a Linux kernel hacker, | 1020 |
1018 wrote a tool called \command{wiggle}~\cite{web:wiggle}, which is more | 1021 $B$=$l$^$G%Q%C%A$,%/%j!<%s$KE,MQ$5$l$F$*$j!$%Q%C%A$NBP>]$K$J$C$F$$$k%3!<%I(B |
1019 vigorous than \command{patch} in its attempts to make a patch apply. | 1022 $B$KJQ99$r2C$($?$?$a$KE,MQ$G$-$J$/$J$C$?$N$J$i!$(BMercurial Queues$B$N;Y1g$r<u(B |
1020 | 1023 $B$1$k$3$H$,$G$-$k!%>\$7$$>pJs$O%;%/%7%g%s(B~\ref{sec:mq:merge}$B$r8+$FM_$7$$!%(B |
1021 Another Linux kernel hacker, Chris Mason (the author of Mercurial | 1024 |
1022 Queues), wrote a similar tool called | 1025 %Unfortunately, there aren't any great techniques for dealing with |
1023 \command{mpatch}~\cite{web:mpatch}, which takes a simple approach to | 1026 %rejected hunks. Most often, you'll need to view the \sfilename{.rej} |
1024 automating the application of hunks rejected by \command{patch}. The | 1027 %file and edit the target file, applying the rejected hunks by hand. |
1025 \command{mpatch} command can help with four common reasons that a hunk | 1028 |
1026 may be rejected: | 1029 $B;DG0$J$3$H$K!$%j%8%'%/%H$5$l$?(Bhunk$B$r<h$j07$&7h$^$C$?NI$$J}K!$OB8:_$7$J(B |
1030 $B$$!%BgDq$N>l9g!$(B\sfilename{.rej}$B%U%!%$%k$r8+$F%?!<%2%C%H%U%!%$%k$rJT=8(B | |
1031 $B$7!$%j%8%'%/%H$5$l$?(Bhunk$B$r<j$GE,MQ$9$k$3$H$K$J$k!%(B | |
1032 | |
1033 %If you're feeling adventurous, Neil Brown, a Linux kernel hacker, | |
1034 %wrote a tool called \command{wiggle}~\cite{web:wiggle}, which is more | |
1035 %vigorous than \command{patch} in its attempts to make a patch apply. | |
1036 | |
1037 $BKA81$,9%$-$J$i!$(BLinux kerner$B%O%C%+!<$N(BNeil Brown$B$,=q$$$?(B | |
1038 \command{wiggle}~\cite{web:wiggle}$B$r;n$7$F$_$k$HNI$$!%$3$N%3%^%s%I$O(B | |
1039 \command{patch}$B$h$j$b@:NOE*$K%Q%C%A$NE,MQ$r;n$_$k!%(B | |
1040 | |
1041 %Another Linux kernel hacker, Chris Mason (the author of Mercurial | |
1042 %Queues), wrote a similar tool called | |
1043 %\command{mpatch}~\cite{web:mpatch}, which takes a simple approach to | |
1044 %automating the application of hunks rejected by \command{patch}. The | |
1045 %\command{mpatch} command can help with four common reasons that a hunk | |
1046 %may be rejected: | |
1047 | |
1048 $BJL$N(BLinux kerner$B%O%C%+!<(B Chris Mason$B!J(BMercurial Queues$B$N:n<T$G$b$"$k!%!K(B | |
1049 $B$O(B\command{mpatch}~\cite{web:mpatch}$B$H$$$&%D!<%k$r=q$$$?!%$3$N%3%^%s%I$O(B | |
1050 \command{patch}$B%3%^%s%I$G%j%8%'%/%H$5$l$?(Bhunk$B$NE,MQ$r<+F02=$9(B | |
1051 $B$k!%(B\command{mpatch}$B%3%^%s%I$O!$(Bhunk$B$,%j%8%'%/%H$5$l$k<g$J860x(B4$B$D$KBP1~(B | |
1052 $B$9$k(B: | |
1027 | 1053 |
1028 \begin{itemize} | 1054 \begin{itemize} |
1029 \item The context in the middle of a hunk has changed. | 1055 %\item The context in the middle of a hunk has changed. |
1030 \item A hunk is missing some context at the beginning or end. | 1056 \item hunk$B$NCf$N%3%s%F%-%9%H$,JQ99$5$l$?(B |
1031 \item A large hunk might apply better---either entirely or in | 1057 %\item A hunk is missing some context at the beginning or end. |
1032 part---if it was broken up into smaller hunks. | 1058 \item hunk$B$N3+;OIt!&=*C<It$G%3%s%F%-%9%H$,8+$D$1$i$l$J$$(B |
1033 \item A hunk removes lines with slightly different content than those | 1059 %\item A large hunk might apply better---either entirely or in |
1034 currently present in the file. | 1060 % part---if it was broken up into smaller hunks. |
1061 \item $BBg$-$J(Bhunk$B$O$b$C$H>e<j$KE,MQ$G$-$kH&$@(B---hunk$B$r>.$5$J(Bhunk$B$KJ,3d$7(B | |
1062 $B$FE,MQ$9$k(B | |
1063 %\item A hunk removes lines with slightly different content than those | |
1064 % currently present in the file. | |
1065 \item hunk$BFb$N9T$,8=:_%U%!%$%k$K$"$k9T$H<c430c$C$F$$$k>l9g!$$=$N9T$r:o=|(B | |
1066 $B$9$k(B | |
1035 \end{itemize} | 1067 \end{itemize} |
1036 | 1068 |
1037 If you use \command{wiggle} or \command{mpatch}, you should be doubly | 1069 %If you use \command{wiggle} or \command{mpatch}, you should be doubly |
1038 careful to check your results when you're done. In fact, | 1070 %careful to check your results when you're done. In fact, |
1039 \command{mpatch} enforces this method of double-checking the tool's | 1071 %\command{mpatch} enforces this method of double-checking the tool's |
1040 output, by automatically dropping you into a merge program when it has | 1072 %output, by automatically dropping you into a merge program when it has |
1041 done its job, so that you can verify its work and finish off any | 1073 %done its job, so that you can verify its work and finish off any |
1042 remaining merges. | 1074 %remaining merges. |
1075 | |
1076 \command{wiggle}$B$^$?$O(B\command{mpatch}$B$r;HMQ$7$?>l9g$O!$7k2L$K:Y?4$NCm0U(B | |
1077 $B$,I,MW$G$"$k!%<B:]$K$O(B\command{mpatch}$B$O%D!<%k$N=PNO$GFs=E%A%'%C%/$r6/@)(B | |
1078 $B$7!$F0:n$,=*$k$H<+F0E*$K%^!<%8%W%m%0%i%`$r5/F0$9$k!%$3$l$K$h$C$F:n6H$r3N(B | |
1079 $BG'$7!$%^!<%8$r40N;$9$k$3$H$,$G$-$k!%(B | |
1043 | 1080 |
1044 %\section{Getting the best performance out of MQ} | 1081 %\section{Getting the best performance out of MQ} |
1045 \section{MQ$B$r:GBg8B$K3hMQ$9$k(B} | 1082 \section{MQ$B$r:GBg8B$K3hMQ$9$k(B} |
1046 \label{sec:mq:perf} | 1083 \label{sec:mq:perf} |
1047 | 1084 |
1048 MQ is very efficient at handling a large number of patches. I ran | 1085 %MQ is very efficient at handling a large number of patches. I ran |
1049 some performance experiments in mid-2006 for a talk that I gave at the | 1086 %some performance experiments in mid-2006 for a talk that I gave at the |
1050 2006 EuroPython conference~\cite{web:europython}. I used as my data | 1087 %2006 EuroPython conference~\cite{web:europython}. I used as my data |
1051 set the Linux 2.6.17-mm1 patch series, which consists of 1,738 | 1088 %set the Linux 2.6.17-mm1 patch series, which consists of 1,738 |
1052 patches. I applied these on top of a Linux kernel repository | 1089 %patches. I applied these on top of a Linux kernel repository |
1053 containing all 27,472 revisions between Linux 2.6.12-rc2 and Linux | 1090 %containing all 27,472 revisions between Linux 2.6.12-rc2 and Linux |
1054 2.6.17. | 1091 %2.6.17. |
1055 | 1092 |
1056 On my old, slow laptop, I was able to | 1093 MQ$B$O$H$F$b8zN(E*$KBgNL$N%Q%C%A$r=hM}$9$k$3$H$,$G$-$k!%I.<T$O(B2006$BG/$NCf:"!$(B |
1057 \hgcmdargs{qpush}{\hgxopt{mq}{qpush}{-a}} all 1,738 patches in 3.5 minutes, | 1094 2006 EuroPython conference~\cite{web:europython}$B$G$N9V1i$N$?$a$K@-G=B,Dj(B |
1058 and \hgcmdargs{qpop}{\hgxopt{mq}{qpop}{-a}} them all in 30 seconds. (On a | 1095 $B$r9T$C$?!%B,Dj$KMQ$$$?%G!<%?$O(BLinux 2.6.17-mm1$B$N%Q%C%A%7%j!<%:$G!$(B1,738 |
1059 newer laptop, the time to push all patches dropped to two minutes.) I | 1096 $B$N%Q%C%A$r4^$`!%$3$N%Q%C%A$r(BLinux kernel$B%j%]%8%H%j$KE,MQ$7$?!%%j%]%8%H%j(B |
1060 could \hgxcmd{mq}{qrefresh} one of the biggest patches (which made 22,779 | 1097 $B$O(BLinux 2.6.12-rc2$B$+$i(BLinux 2.6.17$B$^$G$N(B27,472$B$N%j%S%8%g%s$r4^$s$G$$$k!%(B |
1061 lines of changes to 287 files) in 6.6 seconds. | 1098 |
1062 | 1099 %On my old, slow laptop, I was able to |
1063 Clearly, MQ is well suited to working in large trees, but there are a | 1100 %\hgcmdargs{qpush}{\hgxopt{mq}{qpush}{-a}} all 1,738 patches in 3.5 minutes, |
1064 few tricks you can use to get the best performance of it. | 1101 %and \hgcmdargs{qpop}{\hgxopt{mq}{qpop}{-a}} them all in 30 seconds. (On a |
1065 | 1102 %newer laptop, the time to push all patches dropped to two minutes.) I |
1066 First of all, try to ``batch'' operations together. Every time you | 1103 %could \hgxcmd{mq}{qrefresh} one of the biggest patches (which made 22,779 |
1067 run \hgxcmd{mq}{qpush} or \hgxcmd{mq}{qpop}, these commands scan the working | 1104 %lines of changes to 287 files) in 6.6 seconds. |
1068 directory once to make sure you haven't made some changes and then | 1105 |
1069 forgotten to run \hgxcmd{mq}{qrefresh}. On a small tree, the time that | 1106 $BI.<T$N8E$/CY$$%i%C%W%H%C%W$G!$(B\hgcmdargs{qpush}{\hgxopt{mq}{qpush}{-a}}$B$G(B |
1070 this scan takes is unnoticeable. However, on a medium-sized tree | 1107 1738$B$N%Q%C%A$9$Y$F$r=hM}$9$k$N$K(B |
1071 (containing tens of thousands of files), it can take a second or more. | 1108 3.5$BJ,!$(B\hgcmdargs{qpop}{\hgxopt{mq}{qpop}{-a}}$B$r9T$&$N$K(B30$BIC$rMW$7$?!%(B($B?7(B |
1072 | 1109 $B$7$$%i%C%W%H%C%W$G$O%W%C%7%e$N=jMW;~4V$O(B2$BJ,$G$"$C$?!%(B)$B:GBg$N%Q%C%A(B |
1073 The \hgxcmd{mq}{qpush} and \hgxcmd{mq}{qpop} commands allow you to push and pop | 1110 (22.778$B9T$G!$(B287$B$N%U%!%$%k$rJQ99$9$k(B)$B$K(B\hgxcmd{mq}{qrefresh}$B$r9T$C$?$H$3(B |
1074 multiple patches at a time. You can identify the ``destination | 1111 $B$m!$(B6.6$BIC$rMW$7$?!%(B |
1075 patch'' that you want to end up at. When you \hgxcmd{mq}{qpush} with a | 1112 |
1076 destination specified, it will push patches until that patch is at the | 1113 %Clearly, MQ is well suited to working in large trees, but there are a |
1077 top of the applied stack. When you \hgxcmd{mq}{qpop} to a destination, MQ | 1114 %few tricks you can use to get the best performance of it. |
1078 will pop patches until the destination patch is at the top. | 1115 |
1079 | 1116 MQ$B$,5pBg$J%D%j!<$G$N:n6H$KE,$7$F$$$k$N$OL@$i$+$@$,!$$5$i$K:G9b$N@-G=$r0z(B |
1080 You can identify a destination patch using either the name of the | 1117 $B$-=P$9$?$a$K$$$/$D$+$N%H%j%C%/$,;H$($k!%(B |
1081 patch, or by number. If you use numeric addressing, patches are | 1118 |
1082 counted from zero; this means that the first patch is zero, the second | 1119 %First of all, try to ``batch'' operations together. Every time you |
1083 is one, and so on. | 1120 %run \hgxcmd{mq}{qpush} or \hgxcmd{mq}{qpop}, these commands scan the working |
1121 %directory once to make sure you haven't made some changes and then | |
1122 %forgotten to run \hgxcmd{mq}{qrefresh}. On a small tree, the time that | |
1123 %this scan takes is unnoticeable. However, on a medium-sized tree | |
1124 %(containing tens of thousands of files), it can take a second or more. | |
1125 | |
1126 $B$^$:Bh0l$K!$(B``batch''$B%*%Z%l!<%7%g%s$rJ;MQ$9$k$3$H$,$G$-(B | |
1127 $B$k!%(B\hgxcmd{mq}{qpush}$B$^$?$O(B\hgxcmd{mq}{qpop}$B$O!$%o!<%-%s%0%G%#%l%/%H%j$K(B | |
1128 $BJQ99$r2C$($?$N$K(B\hgxcmd{mq}{qrefresh}$B$N<B9T$rK:$l$F$$$J$$$+$I$&$+D4$Y$k$?(B | |
1129 $B$a!$<B9T;~$K>o$K%o!<%-%s%0%G%#%l%/%H%j$r%9%-%c%s$9$k!%>.5,LO$J%D%j!<$G$O(B | |
1130 $B5$$E$+$J$$DxEY$N;~4V$7$+$+$+$i$J$$$,!$(B($B?tK|$N%U%!%$%k$r;}$D$h$&$J(B)$BCf5,LO(B | |
1131 $B$N$G$O?tIC$N;~4V$rMW$9$k!%(B | |
1132 | |
1133 %The \hgxcmd{mq}{qpush} and \hgxcmd{mq}{qpop} commands allow you to push and pop | |
1134 %multiple patches at a time. You can identify the ``destination | |
1135 %patch'' that you want to end up at. When you \hgxcmd{mq}{qpush} with a | |
1136 %destination specified, it will push patches until that patch is at the | |
1137 %top of the applied stack. When you \hgxcmd{mq}{qpop} to a destination, MQ | |
1138 %will pop patches until the destination patch is at the top. | |
1139 | |
1140 \hgxcmd{mq}{qpush}$B%3%^%s%I$H(B\hgxcmd{mq}{qpop}$B%3%^%s%I$OJ#?t$N%U%!%$%k$rF1(B | |
1141 $B;~$K(Bpush$B$^$?$O(Bpop$B$9$k$3$H$,$G$-$k!%:G=*L\E*$N%Q%C%A$,$"$k$J$i(B | |
1142 $B$P!$(B\hgxcmd{mq}{qpush}$B$KL\E*$N%Q%C%A$r;XDj$7$F<B9T$9$k$3$H$G!$;XDj$7$?%Q%C(B | |
1143 $B%A$,:F>e0L$K$J$k$^$G%Q%C%A$r(Bpush$B$9$k!%F1MM$K(B\hgxcmd{mq}{qpop}$B$KL\E*$N%Q%C(B | |
1144 $B%A$r;XDj$9$l$P!$;XDj$7$?%Q%C%A$,:F>e0L$K$J$k$^$G%Q%C%A$r(Bpop$B$9$k!%(B | |
1145 | |
1146 %You can identify a destination patch using either the name of the | |
1147 %patch, or by number. If you use numeric addressing, patches are | |
1148 %counted from zero; this means that the first patch is zero, the second | |
1149 %is one, and so on. | |
1150 | |
1151 $BL\E*$N%Q%C%A$OL>A0$G$bHV9f$G$b;XDj2DG=$G$"$k!%HV9f$,MQ$$$i$l$k>l9g$O!$%Q%C(B | |
1152 $B%A$O(B0$B$+$i%+%&%s%H$5$l$k!%$D$^$j:G=i$N%Q%C%A$O(B0$B$H$J$j!$(B2$BHVL\$O(B1$B!$$H$$$&Iw(B | |
1153 $B$K$J$k!%(B | |
1084 | 1154 |
1085 %\section{Updating your patches when the underlying code changes} | 1155 %\section{Updating your patches when the underlying code changes} |
1086 \section{$B2<0L%3!<%I$NJQ2=$K9g$o$;$F%Q%C%A$r99?7$9$k(B} | 1156 \section{$BBP>]%3!<%I$NJQ2=$K9g$o$;$F%Q%C%A$r99?7$9$k(B} |
1087 \label{sec:mq:merge} | 1157 \label{sec:mq:merge} |
1088 | 1158 |
1089 It's common to have a stack of patches on top of an underlying | 1159 It's common to have a stack of patches on top of an underlying |
1090 repository that you don't modify directly. If you're working on | 1160 repository that you don't modify directly. If you're working on |
1091 changes to third-party code, or on a feature that is taking longer to | 1161 changes to third-party code, or on a feature that is taking longer to |
1301 | 1371 |
1302 You can then issue commands of the form \cmdargs{mq}{pull} from | 1372 You can then issue commands of the form \cmdargs{mq}{pull} from |
1303 the main repository. | 1373 the main repository. |
1304 | 1374 |
1305 %\subsection{A few things to watch out for} | 1375 %\subsection{A few things to watch out for} |
1306 \subsection{$B4F;k$7$F$*$/$Y$-$$$/$D$+$NE@(B} | 1376 \subsection{$BCm0U$7$F$*$/$Y$-$$$/$D$+$NE@(B} |
1307 | 1377 |
1308 MQ's support for working with a repository full of patches is limited | 1378 MQ's support for working with a repository full of patches is limited |
1309 in a few small respects. | 1379 in a few small respects. |
1310 | 1380 |
1311 MQ cannot automatically detect changes that you make to the patch | 1381 MQ cannot automatically detect changes that you make to the patch |