On Tue, Jul 04, 2017 at 04:50:00PM +0100, Maciej W. Rozycki wrote:
> On Mon, 3 Jul 2017, James Hogan wrote:
> 
> > > Hardcode the absence of the MIPS16e2 ASE for all the systems that do so 
> > > for the MIPS16 ASE already, providing for code to be optimized away.
> > > 
> > > Signed-off-by: Maciej W. Rozycki <macro@imgtec.com>
> > 
> > I'm inclined to agree with Florian, that git formatted patches are
> > slightly easier to review, perhaps they just subjectively look more
> > familiar. Out of interest, do you not use git for retrieving kernel
> > source already?
> 
>  I do use GIT for managing the sources themselves of course, however I 
> keep using `quilt' for patches for two main reasons:
> 
> 1. It works efficiently for the work flow I've got used to,

fair enough.

> e.g. how do I hand-edit 16th previous diff with GIT;

git rebase -i HEAD~17
You can change a commit from "pick" to "edit" to get the rebase to stop
and allow you to edit the tree at that point in the series, before
continuing with "git rebase --continue" (or --abort to cancel the
rebase).

> how do I swap patches;

git rebase -i $base
and reorder the lines

> how do I move individual hunks between patches? -- these actions are
> trivial with `quilt'.

git rebase -i is again the answer, though probably not as trivial as
quilt (though perhaps more robust than hand editing patches?).

I've found a few ways that generally revolve around using
git checkout -p,

Example 1:
To move a hunk from a later commit into an earlier commit, add

x git checkout -p $later_commit && git commit --amend $earlier_commit

before the later commit in the interactive rebase. Pick the hunks you
want to grab (you can edit them there too), and when rebase is done you
have a fixup commit before the later commit. Finally do another rebase
with --autosquash:

git rebase -i $base --autosquash

to automatically squash the fixup commit into the earlier commit

Example 2:
To move a hunk from an earlier commit into a later commit, you could
"git checkout -p" after both commits, e.g.

pick $earlier_commit
x git checkout -p HEAD~ && git commit --amend
pick $intermediate1
pick $later_commit
x git checkout -p $later_commit && git commit --amend

Interactively undo the change (first checkout -p), and interactively
reapply the change (second checkout -p).

Being git there's 100 variants of that, e.g. changing pick to edit and
doing the commands manually, or doing the same thing as Example 1 for
moving hunks later if you aren't expecting conflicts (but you'll have to
move the fixup yourself as --autosquash doesn't move fixups later).

Its obviously advisable to inspect and diff after rebase -i to double
check.

Cheers
James