X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=dgit.git;a=blobdiff_plain;f=git-debrebase;h=bf9af61627bfc2f5bbd85c87417eec7e2a6c7d42;hp=4667e8b1b8b408b8245e634f597adca7e78a12f3;hb=223328e90bbec5bd8a0c55bf1a0f0f609e8154ac;hpb=b5cd66f2a318d196e4497bd428567826f5c2b5d6

diff --git a/git-debrebase b/git-debrebase
index 4667e8b1..bf9af616 100755
--- a/git-debrebase
+++ b/git-debrebase
@@ -18,6 +18,9 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+END { $? = $Debian::Dgit::ExitStatus::desired // -1; };
+use Debian::Dgit::ExitStatus;
+
 use strict;
 
 use Debian::Dgit qw(:DEFAULT :playground);
@@ -32,12 +35,14 @@ use Dpkg::Version;
 use File::FnMatch qw(:fnmatch);
 
 our ($opt_force, $opt_noop_ok, @opt_anchors);
+our ($opt_defaultcmd_interactive);
 
 our $us = qw(git-debrebase);
 
 sub badusage ($) {
     my ($m) = @_;
-    die "bad usage: $m\n";
+    print STDERR "bad usage: $m\n";
+    finish 12;
 }
 
 sub cfg ($;$) {
@@ -97,12 +102,18 @@ sub fresh_workarea () {
     in_workarea sub { playtree_setup };
 }
 
+our $snags_forced;
+our $snags_tripped;
+our $snags_checked;
 our @deferred_updates;
 our @deferred_update_messages;
 
 sub run_deferred_updates ($) {
     my ($mrest) = @_;
 
+    confess 'dangerous internal error' if
+	!$snags_checked || $snags_tripped || $snags_forced;
+
     my @upd_cmd = (@git, qw(update-ref --stdin -m), "debrebase: $mrest");
     debugcmd '>|', @upd_cmd;
     open U, "|-", @upd_cmd or die $!;
@@ -224,40 +235,41 @@ sub make_commit ($$) {
     return cmdoutput @cmd;
 }
 
-our @fproblem_force_opts;
-our $fproblems_forced;
-our $fproblems_tripped;
-sub fproblem ($$) {
+our @snag_force_opts;
+sub snag ($$) {
     my ($tag,$msg) = @_;
-    if (grep { $_ eq $tag } @fproblem_force_opts) {
-	$fproblems_forced++;
-	print STDERR "git-debrebase: safety catch overridden (-f$tag): $msg\n";
+    if (grep { $_ eq $tag } @snag_force_opts) {
+	$snags_forced++;
+	print STDERR "git-debrebase: snag ignored (-f$tag): $msg\n";
     } else {
-	$fproblems_tripped++;
-	print STDERR "git-debrebase: safety catch tripped (-f$tag): $msg\n";
+	$snags_tripped++;
+	print STDERR "git-debrebase: snag detected (-f$tag): $msg\n";
     }
 }
 
-sub fproblems_maybe_bail () {
-    if ($fproblems_forced) {
+sub snags_maybe_bail () {
+    $snags_checked++;
+    if ($snags_forced) {
 	printf STDERR
-	    "%s: safety catch trips: %d overriden by individual -f options\n",
-	    $us, $fproblems_forced;
+	    "%s: snags: %d overriden by individual -f options\n",
+	    $us, $snags_forced;
+	$snags_forced=0;
     }
-    if ($fproblems_tripped) {
+    if ($snags_tripped) {
 	if ($opt_force) {
 	    printf STDERR
-		"%s: safety catch trips: %d overriden by global --force\n",
-		$us, $fproblems_tripped;
+		"%s: snags: %d overriden by global --force\n",
+		$us, $snags_tripped;
+	    $snags_tripped=0;
 	} else {
 	    fail sprintf
-  "%s: safety catch trips: %d blockers (you could -f<tag>, or --force)",
-		$us, $fproblems_tripped;
+  "%s: snags: %d blockers (you could -f<tag>, or --force)",
+		$us, $snags_tripped;
 	}
     }
 }
-sub any_fproblems () {
-    return $fproblems_forced || $fproblems_tripped;
+sub any_snags () {
+    return $snags_forced || $snags_tripped;
 }
 
 # classify returns an info hash like this
@@ -394,6 +406,15 @@ sub classify ($) {
 	# BreakwaterStart commits are also anchors in the terminology
 	# of git-debrebase(5), but they are untagged (and always
 	# manually generated).
+	#
+	# We cannot not tolerate any tagged linear commit (ie,
+	# BreakwaterStart commits tagged `[anchor:') because such a
+	# thing could result from an erroneous linearising raw git
+	# rebase of a merge anchor.  That would represent a corruption
+	# of the branch. and we want to detect and reject the results
+	# of such corruption before it makes it out anywhere.  If we
+	# reject it here then we avoid making the pseudomerge which
+	# would be needed to push it.
 
 	my $badanchor = sub { $unknown->("git-debrebase \`anchor' but @_"); };
 	@p == 2 or return $badanchor->("has other than two parents");
@@ -503,7 +524,7 @@ sub keycommits ($;$$$) {
     # $dgitimport->("unclean-$tagsfx", $msg)
     #   is callled for each situation or commit that
     #   wouldn't be found in a laundered branch
-    # $furniture is forfurniture commits such as might be found on an
+    # $furniture is for furniture commits such as might be found on an
     #   interchange branch (pseudomerge, d/patches, changelog)
     # $trouble is for things whnich prevent the return of
     #   anchor and breakwater information; if that is ignored,
@@ -549,7 +570,7 @@ sub keycommits ($;$$$) {
 	    $breakwater = undef;
 	} elsif ($ty eq 'Mixed') {
 	    $x->($unclean, 'mixed',
-		 'found mixed upstream/packaging commit ($head)');
+		 "found mixed upstream/packaging commit ($head)");
 	    $clogonly = undef;
 	    $breakwater = undef;
 	} elsif ($ty eq 'Pseudomerge' or
@@ -885,6 +906,16 @@ sub update_head_postlaunder ($$$) {
     runcmd @git, qw(rm --quiet --ignore-unmatch -rf debian/patches);
 }
 
+sub do_launder_head ($) {
+    my ($reflogmsg) = @_;
+    my $old = get_head();
+    record_ffq_auto();
+    my ($tip,$breakwater) = walk $old;
+    snags_maybe_bail();
+    update_head_postlaunder $old, $tip, $reflogmsg;
+    return ($tip,$breakwater);
+}
+
 sub cmd_launder_v0 () {
     badusage "no arguments to launder-v0 allowed" if @ARGV;
     my $old = get_head();
@@ -896,11 +927,9 @@ sub cmd_launder_v0 () {
 }
 
 sub defaultcmd_rebase () {
-    my $old = get_head();
-    record_ffq_auto();
-    my ($tip,$breakwater) = walk $old;
-    update_head_postlaunder $old, $tip, 'launder for rebase';
-    runcmd @git, qw(rebase), @ARGV, $breakwater;
+    push @ARGV, @{ $opt_defaultcmd_interactive // [] };
+    my ($tip,$breakwater) = do_launder_head 'launder for rebase';
+    runcmd @git, qw(rebase), @ARGV, $breakwater if @ARGV;
 }
 
 sub cmd_analyse () {
@@ -917,7 +946,7 @@ sub cmd_analyse () {
 }
 
 sub ffq_prev_branchinfo () {
-    # => ('status', "message", [$current, $ffq_prev, $drlast])
+    # => ('status', "message", [$current, $ffq_prev, $gdrlast])
     # 'status' may be
     #    branch         message is undef
     #    weird-symref   } no $current,
@@ -927,9 +956,9 @@ sub ffq_prev_branchinfo () {
     return ('weird-symref', 'HEAD symref is not to refs/')
 	unless $current =~ m{^refs/};
     my $ffq_prev = "refs/$ffq_refprefix/$'";
-    my $drlast = "refs/$gdrlast_refprefix/$'";
+    my $gdrlast = "refs/$gdrlast_refprefix/$'";
     printdebug "ffq_prev_branchinfo branch current $current\n";
-    return ('branch', undef, $current, $ffq_prev, $drlast);
+    return ('branch', undef, $current, $ffq_prev, $gdrlast);
 }
 
 sub record_ffq_prev_deferred () {
@@ -940,11 +969,11 @@ sub record_ffq_prev_deferred () {
     #    detached
     #    weird-symref
     #    notbranch
-    # if not ff from some branch we should be ff from, is an fproblem
+    # if not ff from some branch we should be ff from, is an snag
     # if "deferred", will have added something about that to
     #   @deferred_update_messages, and also maybe printed (already)
     #   some messages about ff checks
-    my ($status, $message, $current, $ffq_prev, $drlast)
+    my ($status, $message, $current, $ffq_prev, $gdrlast)
 	= ffq_prev_branchinfo();
     return ($status, $message) unless $status eq 'branch';
 
@@ -980,10 +1009,10 @@ sub record_ffq_prev_deferred () {
 	    $checked{$lrref} = 1;
 	} elsif (is_fast_fwd $currentval, $lrval) {
 	    $checked{$lrref} = -1;
-	    fproblem 'behind', "you are behind $lrref, divergence risk";
+	    snag 'behind', "you are behind $lrref, divergence risk";
 	} else {
 	    $checked{$lrref} = -1;
-	    fproblem 'diverged', "you have diverged from $lrref";
+	    snag 'diverged', "you have diverged from $lrref";
 	}
     };
 
@@ -1009,10 +1038,10 @@ sub record_ffq_prev_deferred () {
 	$check->("refs/remotes/dgit/dgit/sid", 'remote dgit branch for sid');
     }
 
-    fproblems_maybe_bail();
+    snags_maybe_bail();
 
     push @deferred_updates, "update $ffq_prev $currentval $git_null_obj";
-    push @deferred_updates, "delete $drlast";
+    push @deferred_updates, "delete $gdrlast";
     push @deferred_update_messages, "Recorded current head for preservation";
     return ('deferred', undef);
 }
@@ -1021,9 +1050,64 @@ sub record_ffq_auto () {
     my ($status, $message) = record_ffq_prev_deferred();
     if ($status eq 'deferred' || $status eq 'exists') {
     } else {
-	fproblem $status, "could not record ffq-prev: $message";
-	fproblems_maybe_bail();
+	snag $status, "could not record ffq-prev: $message";
+	snags_maybe_bail();
+    }
+}
+
+sub ffq_prev_info () {
+    # => ($ffq_prev, $gdrlast, $ffq_prev_commitish)
+    my ($status, $message, $current, $ffq_prev, $gdrlast)
+	= ffq_prev_branchinfo();
+    if ($status ne 'branch') {
+	snag $status, "could not check ffq-prev: $message";
+	snags_maybe_bail();
+    }
+    my $ffq_prev_commitish = $ffq_prev && git_get_ref $ffq_prev;
+    return ($ffq_prev, $gdrlast, $ffq_prev_commitish);
+}
+
+sub stitch ($$$$$) {
+    my ($old_head, $ffq_prev, $gdrlast, $ffq_prev_commitish, $prose) = @_;
+
+    push @deferred_updates, "delete $ffq_prev $ffq_prev_commitish";
+
+    if (is_fast_fwd $old_head, $ffq_prev_commitish) {
+	my $differs = get_differs $old_head, $ffq_prev_commitish;
+	unless ($differs & ~D_PAT_ADD) {
+	    # ffq-prev is ahead of us, and the only tree changes it has
+	    # are possibly addition of things in debian/patches/.
+	    # Just wind forwards rather than making a pointless pseudomerge.
+	    push @deferred_updates,
+		"update $gdrlast $ffq_prev_commitish $git_null_obj";
+	    update_head_checkout $old_head, $ffq_prev_commitish,
+		"stitch (fast forward)";
+	    return;
+	}
+    }
+    fresh_workarea();
+    my $new_head = make_commit [ $old_head, $ffq_prev ], [
+	'Declare fast forward / record previous work',
+        "[git-debrebase pseudomerge: $prose]",
+    ];
+    push @deferred_updates, "update $gdrlast $new_head $git_null_obj";
+    update_head $old_head, $new_head, "stitch: $prose";
+}
+
+sub do_stitch ($;$) {
+    my ($prose, $unclean) = @_;
+
+    my ($ffq_prev, $gdrlast, $ffq_prev_commitish) = ffq_prev_info();
+    if (!$ffq_prev_commitish) {
+	fail "No ffq-prev to stitch." unless $opt_noop_ok;
+	return;
     }
+    my $dangling_head = get_head();
+
+    keycommits $dangling_head, $unclean,$unclean,$unclean;
+    snags_maybe_bail();
+
+    stitch($dangling_head, $ffq_prev, $gdrlast, $ffq_prev_commitish, $prose);
 }
 
 sub cmd_new_upstream_v0 () {
@@ -1083,7 +1167,7 @@ sub cmd_new_upstream_v0 () {
     my $old_anchor_cl = classify $old_anchor;
     my $old_upstream;
     if (!$old_anchor_cl->{OrigParents}) {
-	fproblem 'anchor-treated',
+	snag 'anchor-treated',
 	    'old anchor is recognised due to --anchor, cannot check upstream';
     } else {
 	$old_upstream = parsecommit
@@ -1102,7 +1186,7 @@ sub cmd_new_upstream_v0 () {
 		$piece->($n, Old => $old_upstream->{CommitId}.'^'.$parentix);
 	    }
 	} else {
-	    fproblem 'upstream-confusing',
+	    snag 'upstream-confusing',
 		"previous upstream $old_upstream->{CommitId} is from".
                " git-debrebase but not an \`upstream-combine' commit";
 	}
@@ -1112,13 +1196,13 @@ sub cmd_new_upstream_v0 () {
 	if (!$old_upstream) {
 	    # we have complained already
 	} elsif (!$pc->{Old}) {
-	    fproblem 'upstream-new-piece',
+	    snag 'upstream-new-piece',
 		"introducing upstream piece \`$pc->{Name}'";
 	} elsif (!$pc->{New}) {
-	    fproblem 'upstream-rm-piece',
+	    snag 'upstream-rm-piece',
 		"dropping upstream piece \`$pc->{Name}'";
 	} elsif (!is_fast_fwd $pc->{Old}, $pc->{New}) {
-	    fproblem 'upstream-not-ff',
+	    snag 'upstream-not-ff',
 		"not fast forward: $pc->{Name} $pc->{Old}..$pc->{New}";
 	}
     }
@@ -1126,7 +1210,7 @@ sub cmd_new_upstream_v0 () {
     printdebug "%pieces = ", (dd \%pieces), "\n";
     printdebug "\@newpieces = ", (dd \@newpieces), "\n";
 
-    fproblems_maybe_bail();
+    snags_maybe_bail();
 
     my $new_bw;
 
@@ -1134,7 +1218,7 @@ sub cmd_new_upstream_v0 () {
     in_workarea sub {
 	my @upstream_merge_parents;
 
-	if (!any_fproblems()) {
+	if (!any_snags()) {
 	    push @upstream_merge_parents, $old_upstream->{CommitId};
 	}
 
@@ -1171,6 +1255,10 @@ sub cmd_new_upstream_v0 () {
  "[git-debrebase anchor: new upstream $new_upstream_version, merge]",
             ];
 
+	my $clogsignoff = cmdoutput qw(git show),
+	    '--pretty=format:%an <%ae>  %aD',
+	    $new_bw;
+
 	# Now we have to add a changelog stanza so the Debian version
 	# is right.
 	die if unlink "debian";
@@ -1187,7 +1275,7 @@ $p ($new_version) UNRELEASED; urgency=medium
 
   * Update to new upstream version $new_upstream_version.
 
- -- 
+ -- $clogsignoff
 
 END
 	close CN or die $!;
@@ -1224,6 +1312,12 @@ sub cmd_record_ffq_prev () {
     }
 }
 
+sub cmd_anchor () {
+    badusage "no arguments allowed" if @ARGV;
+    my ($anchor, $bw) = keycommits +(git_rev_parse 'HEAD'), 0,0;
+    print "$bw\n" or die $!;
+}
+
 sub cmd_breakwater () {
     badusage "no arguments allowed" if @ARGV;
     my ($anchor, $bw) = keycommits +(git_rev_parse 'HEAD'), 0,0;
@@ -1231,44 +1325,82 @@ sub cmd_breakwater () {
 }
 
 sub cmd_stitch () {
-    my $prose = '';
+    my $prose = 'stitch';
     GetOptions('prose=s', \$prose) or die badusage("bad options to stitch");
     badusage "no arguments allowed" if @ARGV;
-    my ($status, $message, $current, $ffq_prev, $drlast)
-	= ffq_prev_branchinfo();
-    if ($status ne 'branch') {
-	fproblem $status, "could not check ffq-prev: $message";
-	fproblems_maybe_bail();
-    }
-    my $prev = $ffq_prev && git_get_ref $ffq_prev;
-    if (!$prev) {
-	fail "No ffq-prev to stitch." unless $opt_noop_ok;
+    do_stitch $prose, 0;
+}
+sub cmd_prepush () { cmd_stitch(); }
+
+sub cmd_quick () {
+    badusage "no arguments allowed" if @ARGV;
+    do_launder_head 'launder for git-debrebase quick';
+    do_stitch 'quick';
+}
+
+sub cmd_conclude () {
+    my ($ffq_prev, $gdrlast, $ffq_prev_commitish) = ffq_prev_info();
+    if (!$ffq_prev_commitish) {
+	fail "No ongoing git-debrebase session." unless $opt_noop_ok;
 	return;
     }
-    my $old_head = get_head();
+    my $dangling_head = get_head();
+    
+    badusage "no arguments allowed" if @ARGV;
+    do_launder_head 'launder for git-debrebase quick';
+    do_stitch 'quick';
+}
 
-    keycommits $old_head, \&fproblem, \&fproblem, \&fproblem;
+sub make_patches_staged ($) {
+    my ($head) = @_;
+    # Produces the patches that would result from $head if it were
+    # laundered.
+    my ($secret_head, $secret_bw, $last_anchor) = walk $head;
+    fresh_workarea();
+    in_workarea sub {
+	runcmd @git, qw(checkout -q -b bw), $secret_bw;
+	runcmd @git, qw(checkout -q -b patch-queue/bw), $secret_head;
+	runcmd qw(gbp pq export);
+	runcmd @git, qw(add debian/patches);
+    };
+}
 
-    push @deferred_updates, "delete $ffq_prev $prev";
+sub make_patches ($) {
+    my ($head) = @_;
+    keycommits $head, 0, \&snag;
+    make_patches_staged $head;
+    my $out;
+    in_workarea sub {
+	my $ptree = cmdoutput @git, qw(write-tree --prefix=debian/patches/);
+	runcmd @git, qw(read-tree), $head;
+	read_tree_subdir 'debian/patches', $ptree;
+	$out = make_commit [$head], [
+            'Commit patch queue (exported by git-debrebase)',
+            '[git-debrebase: export and commit patches]',
+        ];
+    };
+    my $d = get_differs $head, $out;
+    if ($d == 0) {
+	return undef; # nothing to do
+    } elsif ($d == D_PAT_ADD) {
+	return $out; # OK
+    } else {
+	fail "Patch export produced patch amendments".
+	    " (abandoned output commit $out).".
+	    "  Try laundering first.";
+    }
+}
 
-    if (is_fast_fwd $old_head, $prev) {
-	my $differs = get_differs $old_head, $prev;
-	unless ($differs & ~D_PAT_ADD) {
-	    # ffq-prev is ahead of us, and the only tree changes it has
-	    # are possibly addition of things in debian/patches/.
-	    # Just wind forwards rather than making a pointless pseudomerge.
-	    push @deferred_updates, "update $drlast $prev $git_null_obj";
-	    update_head_checkout $old_head, $prev, "stitch (fast forward)";
-	    return;
-	}
+sub cmd_make_patches () {
+    badusage "no arguments allowed" if @ARGV;
+    my $old_head = get_head();
+    my $new = make_patches $old_head;
+    snags_maybe_bail();
+    if (!$new) {
+	fail "No (more) patches to export." unless $opt_noop_ok;
+	return;
     }
-    fresh_workarea();
-    my $new_head = make_commit [ $old_head, $ffq_prev ], [
-	'Declare fast forward / record previous work',
-        "[git-debrebase pseudomerge: stitch$prose]",
-    ];
-    push @deferred_updates, "update $drlast $new_head $git_null_obj";
-    update_head $old_head, $new_head, "stitch";
+    update_head_checkout $old_head, $new, 'make-patches';
 }
 
 sub cmd_convert_from_gbp () {
@@ -1288,25 +1420,25 @@ sub cmd_convert_from_gbp () {
     }
 
     if (!is_fast_fwd $upstream, $old_head) {
-	fproblem 'upstream-not-ancestor',
+	snag 'upstream-not-ancestor',
 	    "upstream ($upstream) is not an ancestor of HEAD";
     } else {
 	my $wrong = cmdoutput
 	    (@git, qw(rev-list --ancestry-path), "$upstream..HEAD",
 	     qw(-- :/ :!/debian));
 	if (length $wrong) {
-	    fproblem 'unexpected-upstream-changes',
+	    snag 'unexpected-upstream-changes',
 		"history between upstream ($upstream) and HEAD contains direct changes to upstream files - are you sure this is a gbp (patches-unapplied) branch?";
 	    print STDERR "list expected changes with:  git log --stat --ancestry-path $upstream_spec..HEAD -- :/ ':!/debian'\n";
 	}
     }
 
     if ((git_cat_file "$upstream:debian")[0] ne 'missing') {
-	fproblem 'upstream-has-debian',
+	snag 'upstream-has-debian',
 	    "upstream ($upstream) contains debian/ directory";
     }
 
-    fproblems_maybe_bail();
+    snags_maybe_bail();
 
     my $work;
 
@@ -1343,15 +1475,11 @@ sub cmd_convert_from_gbp () {
 sub cmd_convert_to_gbp () {
     badusage "no arguments allowed" if @ARGV;
     my $head = get_head();
-    my (undef, undef, undef, $ffq, $drlast) = ffq_prev_branchinfo();
-    my ($anchor, $bw) = keycommits $head, 0;
-    fresh_workarea();
+    my (undef, undef, undef, $ffq, $gdrlast) = ffq_prev_branchinfo();
+    keycommits $head, 0;
     my $out;
+    make_patches_staged $head;
     in_workarea sub {
-	runcmd @git, qw(checkout -q -b bw), $bw;
-	runcmd @git, qw(checkout -q -b patch-queue/bw), $head;
-	runcmd qw(gbp pq export);
-	runcmd @git, qw(add debian/patches);
 	$out = make_commit ['HEAD'], [
             'Commit patch queue (converted from git-debrebase format)',
             '[git-debrebase convert-to-gbp: commit patches]',
@@ -1359,8 +1487,9 @@ sub cmd_convert_to_gbp () {
     };
     if (defined $ffq) {
 	push @deferred_updates, "delete $ffq";
-	push @deferred_updates, "delete $drlast";
+	push @deferred_updates, "delete $gdrlast";
     }
+    snags_maybe_bail();
     update_head_checkout $head, $out, "convert to gbp (v0)";
     print <<END or die $!;
 git-debrebase: converted to git-buildpackage branch format
@@ -1420,9 +1549,21 @@ sub cmd_downstream_rebase_launder_v0 () {
 
 GetOptions("D+" => \$debuglevel,
 	   'noop-ok', => \$opt_noop_ok,
-	   'f=s' => \@fproblem_force_opts,
+	   'f=s' => \@snag_force_opts,
 	   'anchor=s' => \@opt_anchors,
-	   'force!') or die badusage "bad options\n";
+	   'force!',
+	   '-i:s' => sub {
+	       my ($opt,$val) = @_;
+	       badusage "git-debrebase: no cuddling to -i for git-rebase"
+		   if length $val;
+	       die if $opt_defaultcmd_interactive; # should not happen
+	       $opt_defaultcmd_interactive = [ qw(-i) ];
+	       # This access to @ARGV is excessive familiarity with
+	       # Getopt::Long, but there isn't another sensible
+	       # approach.  '-i=s{0,}' does not work with bundling.
+	       push @$opt_defaultcmd_interactive, @ARGV;
+	       @ARGV=();
+	   }) or die badusage "bad options\n";
 initdebug('git-debrebase ');
 enabledebug if $debuglevel;
 
@@ -1433,7 +1574,7 @@ $rd = fresh_playground "$playprefix/misc";
 
 @opt_anchors = map { git_rev_parse $_ } @opt_anchors;
 
-if (!@ARGV || $ARGV[0] =~ m{^-}) {
+if (!@ARGV || $opt_defaultcmd_interactive || $ARGV[0] =~ m{^-}) {
     defaultcmd_rebase();
 } else {
     my $cmd = shift @ARGV;
@@ -1444,3 +1585,5 @@ if (!@ARGV || $ARGV[0] =~ m{^-}) {
     $cmdfn or badusage "unknown git-debrebase sub-operation $cmd";
     $cmdfn->();
 }
+
+finish 0;