2009-03-26 04:55:54 +00:00
|
|
|
#include "builtin.h"
|
|
|
|
#include "cache.h"
|
|
|
|
#include "parse-options.h"
|
|
|
|
#include "bisect.h"
|
2017-09-29 06:49:39 +00:00
|
|
|
#include "refs.h"
|
2019-01-02 15:38:31 +00:00
|
|
|
#include "dir.h"
|
2020-07-28 20:23:39 +00:00
|
|
|
#include "strvec.h"
|
2019-01-02 15:38:31 +00:00
|
|
|
#include "run-command.h"
|
2019-01-02 15:38:34 +00:00
|
|
|
#include "prompt.h"
|
2019-01-02 15:38:36 +00:00
|
|
|
#include "quote.h"
|
2009-03-26 04:55:54 +00:00
|
|
|
|
2017-09-29 06:49:39 +00:00
|
|
|
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
|
2017-09-29 06:49:40 +00:00
|
|
|
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
|
|
|
|
static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
|
2019-01-02 15:38:31 +00:00
|
|
|
static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
|
2019-01-02 15:38:32 +00:00
|
|
|
static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
|
2019-01-02 15:38:36 +00:00
|
|
|
static GIT_PATH_FUNC(git_path_head_name, "head-name")
|
|
|
|
static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
|
2020-08-07 21:58:37 +00:00
|
|
|
static GIT_PATH_FUNC(git_path_bisect_first_parent, "BISECT_FIRST_PARENT")
|
2017-09-29 06:49:39 +00:00
|
|
|
|
2009-03-26 04:55:54 +00:00
|
|
|
static const char * const git_bisect_helper_usage[] = {
|
2020-08-07 21:58:36 +00:00
|
|
|
N_("git bisect--helper --next-all"),
|
2017-09-29 06:49:39 +00:00
|
|
|
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
|
2017-09-29 06:49:39 +00:00
|
|
|
N_("git bisect--helper --bisect-clean-state"),
|
2019-01-02 15:38:31 +00:00
|
|
|
N_("git bisect--helper --bisect-reset [<commit>]"),
|
2019-01-02 15:38:32 +00:00
|
|
|
N_("git bisect--helper --bisect-write [--no-log] <state> <revision> <good_term> <bad_term>"),
|
2019-01-02 15:38:33 +00:00
|
|
|
N_("git bisect--helper --bisect-check-and-set-terms <command> <good_term> <bad_term>"),
|
2019-01-02 15:38:34 +00:00
|
|
|
N_("git bisect--helper --bisect-next-check <good_term> <bad_term> [<term>]"),
|
2019-01-02 15:38:35 +00:00
|
|
|
N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
|
2019-01-02 15:38:36 +00:00
|
|
|
N_("git bisect--helper --bisect-start [--term-{old,good}=<term> --term-{new,bad}=<term>]"
|
2020-08-07 21:58:37 +00:00
|
|
|
" [--no-checkout] [--first-parent] [<bad> [<good>...]] [--] [<paths>...]"),
|
2009-03-26 04:55:54 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2019-01-02 15:38:32 +00:00
|
|
|
struct bisect_terms {
|
|
|
|
char *term_good;
|
|
|
|
char *term_bad;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void free_terms(struct bisect_terms *terms)
|
|
|
|
{
|
|
|
|
FREE_AND_NULL(terms->term_good);
|
|
|
|
FREE_AND_NULL(terms->term_bad);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void set_terms(struct bisect_terms *terms, const char *bad,
|
|
|
|
const char *good)
|
|
|
|
{
|
|
|
|
free((void *)terms->term_good);
|
|
|
|
terms->term_good = xstrdup(good);
|
|
|
|
free((void *)terms->term_bad);
|
|
|
|
terms->term_bad = xstrdup(bad);
|
|
|
|
}
|
|
|
|
|
2020-02-17 08:40:28 +00:00
|
|
|
static const char vocab_bad[] = "bad|new";
|
|
|
|
static const char vocab_good[] = "good|old";
|
2019-01-02 15:38:34 +00:00
|
|
|
|
2017-09-29 06:49:39 +00:00
|
|
|
/*
|
|
|
|
* Check whether the string `term` belongs to the set of strings
|
|
|
|
* included in the variable arguments.
|
|
|
|
*/
|
|
|
|
LAST_ARG_MUST_BE_NULL
|
|
|
|
static int one_of(const char *term, ...)
|
|
|
|
{
|
|
|
|
int res = 0;
|
|
|
|
va_list matches;
|
|
|
|
const char *match;
|
|
|
|
|
|
|
|
va_start(matches, term);
|
|
|
|
while (!res && (match = va_arg(matches, const char *)))
|
|
|
|
res = !strcmp(term, match);
|
|
|
|
va_end(matches);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int check_term_format(const char *term, const char *orig_term)
|
|
|
|
{
|
|
|
|
int res;
|
|
|
|
char *new_term = xstrfmt("refs/bisect/%s", term);
|
|
|
|
|
|
|
|
res = check_refname_format(new_term, 0);
|
|
|
|
free(new_term);
|
|
|
|
|
|
|
|
if (res)
|
|
|
|
return error(_("'%s' is not a valid term"), term);
|
|
|
|
|
|
|
|
if (one_of(term, "help", "start", "skip", "next", "reset",
|
2017-11-12 09:30:38 +00:00
|
|
|
"visualize", "view", "replay", "log", "run", "terms", NULL))
|
2017-09-29 06:49:39 +00:00
|
|
|
return error(_("can't use the builtin command '%s' as a term"), term);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In theory, nothing prevents swapping completely good and bad,
|
|
|
|
* but this situation could be confusing and hasn't been tested
|
|
|
|
* enough. Forbid it for now.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if ((strcmp(orig_term, "bad") && one_of(term, "bad", "new", NULL)) ||
|
|
|
|
(strcmp(orig_term, "good") && one_of(term, "good", "old", NULL)))
|
|
|
|
return error(_("can't change the meaning of the term '%s'"), term);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-09-29 06:49:39 +00:00
|
|
|
static int write_terms(const char *bad, const char *good)
|
|
|
|
{
|
|
|
|
FILE *fp = NULL;
|
|
|
|
int res;
|
|
|
|
|
|
|
|
if (!strcmp(bad, good))
|
|
|
|
return error(_("please use two different terms"));
|
|
|
|
|
|
|
|
if (check_term_format(bad, "bad") || check_term_format(good, "good"))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
fp = fopen(git_path_bisect_terms(), "w");
|
|
|
|
if (!fp)
|
|
|
|
return error_errno(_("could not open the file BISECT_TERMS"));
|
|
|
|
|
|
|
|
res = fprintf(fp, "%s\n%s\n", bad, good);
|
|
|
|
res |= fclose(fp);
|
|
|
|
return (res < 0) ? -1 : 0;
|
|
|
|
}
|
|
|
|
|
2017-09-29 06:49:40 +00:00
|
|
|
static int is_expected_rev(const char *expected_hex)
|
|
|
|
{
|
|
|
|
struct strbuf actual_hex = STRBUF_INIT;
|
|
|
|
int res = 0;
|
|
|
|
if (strbuf_read_file(&actual_hex, git_path_bisect_expected_rev(), 0) >= 40) {
|
|
|
|
strbuf_trim(&actual_hex);
|
|
|
|
res = !strcmp(actual_hex.buf, expected_hex);
|
|
|
|
}
|
|
|
|
strbuf_release(&actual_hex);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void check_expected_revs(const char **revs, int rev_nr)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < rev_nr; i++) {
|
|
|
|
if (!is_expected_rev(revs[i])) {
|
|
|
|
unlink_or_warn(git_path_bisect_ancestors_ok());
|
|
|
|
unlink_or_warn(git_path_bisect_expected_rev());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-02 15:38:31 +00:00
|
|
|
static int bisect_reset(const char *commit)
|
|
|
|
{
|
|
|
|
struct strbuf branch = STRBUF_INIT;
|
|
|
|
|
|
|
|
if (!commit) {
|
|
|
|
if (strbuf_read_file(&branch, git_path_bisect_start(), 0) < 1) {
|
|
|
|
printf(_("We are not bisecting.\n"));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
strbuf_rtrim(&branch);
|
|
|
|
} else {
|
|
|
|
struct object_id oid;
|
|
|
|
|
|
|
|
if (get_oid_commit(commit, &oid))
|
|
|
|
return error(_("'%s' is not a valid commit"), commit);
|
|
|
|
strbuf_addstr(&branch, commit);
|
|
|
|
}
|
|
|
|
|
2020-07-10 17:19:52 +00:00
|
|
|
if (!ref_exists("BISECT_HEAD")) {
|
2020-07-28 20:24:27 +00:00
|
|
|
struct strvec argv = STRVEC_INIT;
|
2019-01-02 15:38:31 +00:00
|
|
|
|
2020-07-28 20:24:27 +00:00
|
|
|
strvec_pushl(&argv, "checkout", branch.buf, "--", NULL);
|
2020-07-29 00:37:20 +00:00
|
|
|
if (run_command_v_opt(argv.v, RUN_GIT_CMD)) {
|
2019-12-09 10:56:47 +00:00
|
|
|
error(_("could not check out original"
|
|
|
|
" HEAD '%s'. Try 'git bisect"
|
|
|
|
" reset <commit>'."), branch.buf);
|
2019-01-02 15:38:31 +00:00
|
|
|
strbuf_release(&branch);
|
2020-07-28 20:24:27 +00:00
|
|
|
strvec_clear(&argv);
|
2019-12-09 10:56:47 +00:00
|
|
|
return -1;
|
2019-01-02 15:38:31 +00:00
|
|
|
}
|
2020-07-28 20:24:27 +00:00
|
|
|
strvec_clear(&argv);
|
2019-01-02 15:38:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
strbuf_release(&branch);
|
|
|
|
return bisect_clean_state();
|
|
|
|
}
|
|
|
|
|
2019-01-02 15:38:32 +00:00
|
|
|
static void log_commit(FILE *fp, char *fmt, const char *state,
|
|
|
|
struct commit *commit)
|
|
|
|
{
|
|
|
|
struct pretty_print_context pp = {0};
|
|
|
|
struct strbuf commit_msg = STRBUF_INIT;
|
|
|
|
char *label = xstrfmt(fmt, state);
|
|
|
|
|
|
|
|
format_commit_message(commit, "%s", &commit_msg, &pp);
|
|
|
|
|
|
|
|
fprintf(fp, "# %s: [%s] %s\n", label, oid_to_hex(&commit->object.oid),
|
|
|
|
commit_msg.buf);
|
|
|
|
|
|
|
|
strbuf_release(&commit_msg);
|
|
|
|
free(label);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int bisect_write(const char *state, const char *rev,
|
|
|
|
const struct bisect_terms *terms, int nolog)
|
|
|
|
{
|
|
|
|
struct strbuf tag = STRBUF_INIT;
|
|
|
|
struct object_id oid;
|
|
|
|
struct commit *commit;
|
|
|
|
FILE *fp = NULL;
|
2020-02-17 08:40:29 +00:00
|
|
|
int res = 0;
|
2019-01-02 15:38:32 +00:00
|
|
|
|
|
|
|
if (!strcmp(state, terms->term_bad)) {
|
|
|
|
strbuf_addf(&tag, "refs/bisect/%s", state);
|
|
|
|
} else if (one_of(state, terms->term_good, "skip", NULL)) {
|
|
|
|
strbuf_addf(&tag, "refs/bisect/%s-%s", state, rev);
|
|
|
|
} else {
|
2020-02-17 08:40:29 +00:00
|
|
|
res = error(_("Bad bisect_write argument: %s"), state);
|
2019-01-02 15:38:32 +00:00
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (get_oid(rev, &oid)) {
|
2020-02-17 08:40:29 +00:00
|
|
|
res = error(_("couldn't get the oid of the rev '%s'"), rev);
|
2019-01-02 15:38:32 +00:00
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (update_ref(NULL, tag.buf, &oid, NULL, 0,
|
|
|
|
UPDATE_REFS_MSG_ON_ERR)) {
|
2020-02-17 08:40:29 +00:00
|
|
|
res = -1;
|
2019-01-02 15:38:32 +00:00
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
|
|
|
|
fp = fopen(git_path_bisect_log(), "a");
|
|
|
|
if (!fp) {
|
2020-02-17 08:40:29 +00:00
|
|
|
res = error_errno(_("couldn't open the file '%s'"), git_path_bisect_log());
|
2019-01-02 15:38:32 +00:00
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
|
|
|
|
commit = lookup_commit_reference(the_repository, &oid);
|
|
|
|
log_commit(fp, "%s", state, commit);
|
|
|
|
|
|
|
|
if (!nolog)
|
|
|
|
fprintf(fp, "git bisect %s %s\n", state, rev);
|
|
|
|
|
|
|
|
finish:
|
|
|
|
if (fp)
|
|
|
|
fclose(fp);
|
|
|
|
strbuf_release(&tag);
|
2020-02-17 08:40:29 +00:00
|
|
|
return res;
|
2019-01-02 15:38:32 +00:00
|
|
|
}
|
|
|
|
|
2019-01-02 15:38:33 +00:00
|
|
|
static int check_and_set_terms(struct bisect_terms *terms, const char *cmd)
|
|
|
|
{
|
|
|
|
int has_term_file = !is_empty_or_missing_file(git_path_bisect_terms());
|
|
|
|
|
|
|
|
if (one_of(cmd, "skip", "start", "terms", NULL))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (has_term_file && strcmp(cmd, terms->term_bad) &&
|
|
|
|
strcmp(cmd, terms->term_good))
|
|
|
|
return error(_("Invalid command: you're currently in a "
|
|
|
|
"%s/%s bisect"), terms->term_bad,
|
|
|
|
terms->term_good);
|
|
|
|
|
|
|
|
if (!has_term_file) {
|
|
|
|
if (one_of(cmd, "bad", "good", NULL)) {
|
|
|
|
set_terms(terms, "bad", "good");
|
|
|
|
return write_terms(terms->term_bad, terms->term_good);
|
|
|
|
}
|
|
|
|
if (one_of(cmd, "new", "old", NULL)) {
|
|
|
|
set_terms(terms, "new", "old");
|
|
|
|
return write_terms(terms->term_bad, terms->term_good);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-01-02 15:38:34 +00:00
|
|
|
static int mark_good(const char *refname, const struct object_id *oid,
|
|
|
|
int flag, void *cb_data)
|
|
|
|
{
|
|
|
|
int *m_good = (int *)cb_data;
|
|
|
|
*m_good = 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2019-12-14 08:11:24 +00:00
|
|
|
static const char need_bad_and_good_revision_warning[] =
|
2019-01-02 15:38:34 +00:00
|
|
|
N_("You need to give me at least one %s and %s revision.\n"
|
|
|
|
"You can use \"git bisect %s\" and \"git bisect %s\" for that.");
|
|
|
|
|
2019-12-14 08:11:24 +00:00
|
|
|
static const char need_bisect_start_warning[] =
|
2019-01-02 15:38:34 +00:00
|
|
|
N_("You need to start by \"git bisect start\".\n"
|
|
|
|
"You then need to give me at least one %s and %s revision.\n"
|
|
|
|
"You can use \"git bisect %s\" and \"git bisect %s\" for that.");
|
|
|
|
|
2020-02-17 08:40:31 +00:00
|
|
|
static int decide_next(const struct bisect_terms *terms,
|
|
|
|
const char *current_term, int missing_good,
|
|
|
|
int missing_bad)
|
2019-01-02 15:38:34 +00:00
|
|
|
{
|
|
|
|
if (!missing_good && !missing_bad)
|
2020-02-17 08:40:31 +00:00
|
|
|
return 0;
|
|
|
|
if (!current_term)
|
|
|
|
return -1;
|
2019-01-02 15:38:34 +00:00
|
|
|
|
|
|
|
if (missing_good && !missing_bad &&
|
|
|
|
!strcmp(current_term, terms->term_good)) {
|
|
|
|
char *yesno;
|
|
|
|
/*
|
|
|
|
* have bad (or new) but not good (or old). We could bisect
|
|
|
|
* although this is less optimum.
|
|
|
|
*/
|
|
|
|
warning(_("bisecting only with a %s commit"), terms->term_bad);
|
|
|
|
if (!isatty(0))
|
2020-02-17 08:40:31 +00:00
|
|
|
return 0;
|
2019-01-02 15:38:34 +00:00
|
|
|
/*
|
|
|
|
* TRANSLATORS: Make sure to include [Y] and [n] in your
|
|
|
|
* translation. The program will only accept English input
|
|
|
|
* at this point.
|
|
|
|
*/
|
|
|
|
yesno = git_prompt(_("Are you sure [Y/n]? "), PROMPT_ECHO);
|
|
|
|
if (starts_with(yesno, "N") || starts_with(yesno, "n"))
|
2020-02-17 08:40:31 +00:00
|
|
|
return -1;
|
|
|
|
return 0;
|
2019-01-02 15:38:34 +00:00
|
|
|
}
|
|
|
|
|
2020-02-17 08:40:31 +00:00
|
|
|
if (!is_empty_or_missing_file(git_path_bisect_start()))
|
|
|
|
return error(_(need_bad_and_good_revision_warning),
|
|
|
|
vocab_bad, vocab_good, vocab_bad, vocab_good);
|
|
|
|
else
|
|
|
|
return error(_(need_bisect_start_warning),
|
|
|
|
vocab_good, vocab_bad, vocab_good, vocab_bad);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int bisect_next_check(const struct bisect_terms *terms,
|
|
|
|
const char *current_term)
|
|
|
|
{
|
|
|
|
int missing_good = 1, missing_bad = 1;
|
|
|
|
char *bad_ref = xstrfmt("refs/bisect/%s", terms->term_bad);
|
|
|
|
char *good_glob = xstrfmt("%s-*", terms->term_good);
|
|
|
|
|
|
|
|
if (ref_exists(bad_ref))
|
|
|
|
missing_bad = 0;
|
|
|
|
|
|
|
|
for_each_glob_ref_in(mark_good, good_glob, "refs/bisect/",
|
|
|
|
(void *) &missing_good);
|
|
|
|
|
|
|
|
free(good_glob);
|
|
|
|
free(bad_ref);
|
|
|
|
|
|
|
|
return decide_next(terms, current_term, missing_good, missing_bad);
|
2019-01-02 15:38:34 +00:00
|
|
|
}
|
|
|
|
|
2019-01-02 15:38:35 +00:00
|
|
|
static int get_terms(struct bisect_terms *terms)
|
|
|
|
{
|
|
|
|
struct strbuf str = STRBUF_INIT;
|
|
|
|
FILE *fp = NULL;
|
|
|
|
int res = 0;
|
|
|
|
|
|
|
|
fp = fopen(git_path_bisect_terms(), "r");
|
|
|
|
if (!fp) {
|
|
|
|
res = -1;
|
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
|
|
|
|
free_terms(terms);
|
|
|
|
strbuf_getline_lf(&str, fp);
|
|
|
|
terms->term_bad = strbuf_detach(&str, NULL);
|
|
|
|
strbuf_getline_lf(&str, fp);
|
|
|
|
terms->term_good = strbuf_detach(&str, NULL);
|
|
|
|
|
|
|
|
finish:
|
|
|
|
if (fp)
|
|
|
|
fclose(fp);
|
|
|
|
strbuf_release(&str);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int bisect_terms(struct bisect_terms *terms, const char *option)
|
|
|
|
{
|
|
|
|
if (get_terms(terms))
|
|
|
|
return error(_("no terms defined"));
|
|
|
|
|
|
|
|
if (option == NULL) {
|
|
|
|
printf(_("Your current terms are %s for the old state\n"
|
|
|
|
"and %s for the new state.\n"),
|
|
|
|
terms->term_good, terms->term_bad);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (one_of(option, "--term-good", "--term-old", NULL))
|
|
|
|
printf("%s\n", terms->term_good);
|
|
|
|
else if (one_of(option, "--term-bad", "--term-new", NULL))
|
|
|
|
printf("%s\n", terms->term_bad);
|
|
|
|
else
|
|
|
|
return error(_("invalid argument %s for 'git bisect terms'.\n"
|
|
|
|
"Supported options are: "
|
|
|
|
"--term-good|--term-old and "
|
|
|
|
"--term-bad|--term-new."), option);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-01-02 15:38:36 +00:00
|
|
|
static int bisect_append_log_quoted(const char **argv)
|
|
|
|
{
|
2020-02-17 08:40:29 +00:00
|
|
|
int res = 0;
|
2019-01-02 15:38:36 +00:00
|
|
|
FILE *fp = fopen(git_path_bisect_log(), "a");
|
|
|
|
struct strbuf orig_args = STRBUF_INIT;
|
|
|
|
|
|
|
|
if (!fp)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (fprintf(fp, "git bisect start") < 1) {
|
2020-02-17 08:40:29 +00:00
|
|
|
res = -1;
|
2019-01-02 15:38:36 +00:00
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
|
|
|
|
sq_quote_argv(&orig_args, argv);
|
|
|
|
if (fprintf(fp, "%s\n", orig_args.buf) < 1)
|
2020-02-17 08:40:29 +00:00
|
|
|
res = -1;
|
2019-01-02 15:38:36 +00:00
|
|
|
|
|
|
|
finish:
|
|
|
|
fclose(fp);
|
|
|
|
strbuf_release(&orig_args);
|
2020-02-17 08:40:29 +00:00
|
|
|
return res;
|
2019-01-02 15:38:36 +00:00
|
|
|
}
|
|
|
|
|
2020-08-07 21:58:36 +00:00
|
|
|
static int bisect_start(struct bisect_terms *terms, const char **argv, int argc)
|
2019-01-02 15:38:36 +00:00
|
|
|
{
|
2020-08-07 21:58:36 +00:00
|
|
|
int no_checkout = 0;
|
2020-08-07 21:58:37 +00:00
|
|
|
int first_parent_only = 0;
|
2019-01-02 15:38:36 +00:00
|
|
|
int i, has_double_dash = 0, must_write_terms = 0, bad_seen = 0;
|
2020-02-17 08:40:29 +00:00
|
|
|
int flags, pathspec_pos, res = 0;
|
2019-01-02 15:38:36 +00:00
|
|
|
struct string_list revs = STRING_LIST_INIT_DUP;
|
|
|
|
struct string_list states = STRING_LIST_INIT_DUP;
|
|
|
|
struct strbuf start_head = STRBUF_INIT;
|
|
|
|
struct strbuf bisect_names = STRBUF_INIT;
|
|
|
|
struct object_id head_oid;
|
|
|
|
struct object_id oid;
|
|
|
|
const char *head;
|
|
|
|
|
|
|
|
if (is_bare_repository())
|
|
|
|
no_checkout = 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for one bad and then some good revisions
|
|
|
|
*/
|
|
|
|
for (i = 0; i < argc; i++) {
|
|
|
|
if (!strcmp(argv[i], "--")) {
|
|
|
|
has_double_dash = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < argc; i++) {
|
|
|
|
const char *arg = argv[i];
|
|
|
|
if (!strcmp(argv[i], "--")) {
|
|
|
|
break;
|
|
|
|
} else if (!strcmp(arg, "--no-checkout")) {
|
|
|
|
no_checkout = 1;
|
2020-08-07 21:58:37 +00:00
|
|
|
} else if (!strcmp(arg, "--first-parent")) {
|
|
|
|
first_parent_only = 1;
|
2019-01-02 15:38:36 +00:00
|
|
|
} else if (!strcmp(arg, "--term-good") ||
|
|
|
|
!strcmp(arg, "--term-old")) {
|
2020-05-20 23:26:27 +00:00
|
|
|
i++;
|
|
|
|
if (argc <= i)
|
|
|
|
return error(_("'' is not a valid term"));
|
2019-01-02 15:38:36 +00:00
|
|
|
must_write_terms = 1;
|
|
|
|
free((void *) terms->term_good);
|
2020-05-20 23:26:27 +00:00
|
|
|
terms->term_good = xstrdup(argv[i]);
|
2019-01-02 15:38:36 +00:00
|
|
|
} else if (skip_prefix(arg, "--term-good=", &arg) ||
|
|
|
|
skip_prefix(arg, "--term-old=", &arg)) {
|
|
|
|
must_write_terms = 1;
|
|
|
|
free((void *) terms->term_good);
|
|
|
|
terms->term_good = xstrdup(arg);
|
|
|
|
} else if (!strcmp(arg, "--term-bad") ||
|
|
|
|
!strcmp(arg, "--term-new")) {
|
2020-05-20 23:26:27 +00:00
|
|
|
i++;
|
|
|
|
if (argc <= i)
|
|
|
|
return error(_("'' is not a valid term"));
|
2019-01-02 15:38:36 +00:00
|
|
|
must_write_terms = 1;
|
|
|
|
free((void *) terms->term_bad);
|
2020-05-20 23:26:27 +00:00
|
|
|
terms->term_bad = xstrdup(argv[i]);
|
2019-01-02 15:38:36 +00:00
|
|
|
} else if (skip_prefix(arg, "--term-bad=", &arg) ||
|
|
|
|
skip_prefix(arg, "--term-new=", &arg)) {
|
|
|
|
must_write_terms = 1;
|
|
|
|
free((void *) terms->term_bad);
|
|
|
|
terms->term_bad = xstrdup(arg);
|
2020-05-20 23:26:27 +00:00
|
|
|
} else if (starts_with(arg, "--")) {
|
2019-01-02 15:38:36 +00:00
|
|
|
return error(_("unrecognized option: '%s'"), arg);
|
|
|
|
} else {
|
|
|
|
char *commit_id = xstrfmt("%s^{commit}", arg);
|
|
|
|
if (get_oid(commit_id, &oid) && has_double_dash)
|
|
|
|
die(_("'%s' does not appear to be a valid "
|
|
|
|
"revision"), arg);
|
|
|
|
|
|
|
|
string_list_append(&revs, oid_to_hex(&oid));
|
|
|
|
free(commit_id);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pathspec_pos = i;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The user ran "git bisect start <sha1> <sha1>", hence did not
|
|
|
|
* explicitly specify the terms, but we are already starting to
|
|
|
|
* set references named with the default terms, and won't be able
|
|
|
|
* to change afterwards.
|
|
|
|
*/
|
|
|
|
if (revs.nr)
|
|
|
|
must_write_terms = 1;
|
|
|
|
for (i = 0; i < revs.nr; i++) {
|
|
|
|
if (bad_seen) {
|
|
|
|
string_list_append(&states, terms->term_good);
|
|
|
|
} else {
|
|
|
|
bad_seen = 1;
|
|
|
|
string_list_append(&states, terms->term_bad);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Verify HEAD
|
|
|
|
*/
|
|
|
|
head = resolve_ref_unsafe("HEAD", 0, &head_oid, &flags);
|
|
|
|
if (!head)
|
|
|
|
if (get_oid("HEAD", &head_oid))
|
|
|
|
return error(_("bad HEAD - I need a HEAD"));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if we are bisecting
|
|
|
|
*/
|
|
|
|
if (!is_empty_or_missing_file(git_path_bisect_start())) {
|
|
|
|
/* Reset to the rev from where we started */
|
|
|
|
strbuf_read_file(&start_head, git_path_bisect_start(), 0);
|
|
|
|
strbuf_trim(&start_head);
|
|
|
|
if (!no_checkout) {
|
2020-07-28 20:24:27 +00:00
|
|
|
struct strvec argv = STRVEC_INIT;
|
2019-01-02 15:38:36 +00:00
|
|
|
|
2020-07-28 20:24:27 +00:00
|
|
|
strvec_pushl(&argv, "checkout", start_head.buf,
|
strvec: fix indentation in renamed calls
Code which split an argv_array call across multiple lines, like:
argv_array_pushl(&args, "one argument",
"another argument", "and more",
NULL);
was recently mechanically renamed to use strvec, which results in
mis-matched indentation like:
strvec_pushl(&args, "one argument",
"another argument", "and more",
NULL);
Let's fix these up to align the arguments with the opening paren. I did
this manually by sifting through the results of:
git jump grep 'strvec_.*,$'
and liberally applying my editor's auto-format. Most of the changes are
of the form shown above, though I also normalized a few that had
originally used a single-tab indentation (rather than our usual style of
aligning with the open paren). I also rewrapped a couple of obvious
cases (e.g., where previously too-long lines became short enough to fit
on one), but I wasn't aggressive about it. In cases broken to three or
more lines, the grouping of arguments is sometimes meaningful, and it
wasn't worth my time or reviewer time to ponder each case individually.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-07-28 20:26:31 +00:00
|
|
|
"--", NULL);
|
2020-07-29 00:37:20 +00:00
|
|
|
if (run_command_v_opt(argv.v, RUN_GIT_CMD)) {
|
2020-02-17 08:40:29 +00:00
|
|
|
res = error(_("checking out '%s' failed."
|
2019-01-02 15:38:36 +00:00
|
|
|
" Try 'git bisect start "
|
|
|
|
"<valid-branch>'."),
|
|
|
|
start_head.buf);
|
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Get the rev from where we start. */
|
|
|
|
if (!get_oid(head, &head_oid) &&
|
|
|
|
!starts_with(head, "refs/heads/")) {
|
|
|
|
strbuf_reset(&start_head);
|
|
|
|
strbuf_addstr(&start_head, oid_to_hex(&head_oid));
|
|
|
|
} else if (!get_oid(head, &head_oid) &&
|
|
|
|
skip_prefix(head, "refs/heads/", &head)) {
|
|
|
|
/*
|
|
|
|
* This error message should only be triggered by
|
|
|
|
* cogito usage, and cogito users should understand
|
|
|
|
* it relates to cg-seek.
|
|
|
|
*/
|
|
|
|
if (!is_empty_or_missing_file(git_path_head_name()))
|
|
|
|
return error(_("won't bisect on cg-seek'ed tree"));
|
|
|
|
strbuf_addstr(&start_head, head);
|
|
|
|
} else {
|
|
|
|
return error(_("bad HEAD - strange symbolic ref"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get rid of any old bisect state.
|
|
|
|
*/
|
|
|
|
if (bisect_clean_state())
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In case of mistaken revs or checkout error, or signals received,
|
|
|
|
* "bisect_auto_next" below may exit or misbehave.
|
|
|
|
* We have to trap this to be able to clean up using
|
|
|
|
* "bisect_clean_state".
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write new start state
|
|
|
|
*/
|
|
|
|
write_file(git_path_bisect_start(), "%s\n", start_head.buf);
|
|
|
|
|
2020-08-07 21:58:37 +00:00
|
|
|
if (first_parent_only)
|
|
|
|
write_file(git_path_bisect_first_parent(), "\n");
|
|
|
|
|
2019-01-02 15:38:36 +00:00
|
|
|
if (no_checkout) {
|
2019-05-21 17:50:21 +00:00
|
|
|
if (get_oid(start_head.buf, &oid) < 0) {
|
2020-02-17 08:40:29 +00:00
|
|
|
res = error(_("invalid ref: '%s'"), start_head.buf);
|
2019-05-21 17:50:21 +00:00
|
|
|
goto finish;
|
|
|
|
}
|
2019-01-02 15:38:36 +00:00
|
|
|
if (update_ref(NULL, "BISECT_HEAD", &oid, NULL, 0,
|
|
|
|
UPDATE_REFS_MSG_ON_ERR)) {
|
2020-02-17 08:40:29 +00:00
|
|
|
res = -1;
|
2019-01-02 15:38:36 +00:00
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pathspec_pos < argc - 1)
|
|
|
|
sq_quote_argv(&bisect_names, argv + pathspec_pos);
|
|
|
|
write_file(git_path_bisect_names(), "%s\n", bisect_names.buf);
|
|
|
|
|
|
|
|
for (i = 0; i < states.nr; i++)
|
|
|
|
if (bisect_write(states.items[i].string,
|
|
|
|
revs.items[i].string, terms, 1)) {
|
2020-02-17 08:40:29 +00:00
|
|
|
res = -1;
|
2019-01-02 15:38:36 +00:00
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (must_write_terms && write_terms(terms->term_bad,
|
|
|
|
terms->term_good)) {
|
2020-02-17 08:40:29 +00:00
|
|
|
res = -1;
|
2019-01-02 15:38:36 +00:00
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
|
2020-02-17 08:40:29 +00:00
|
|
|
res = bisect_append_log_quoted(argv);
|
|
|
|
if (res)
|
|
|
|
res = -1;
|
2019-01-02 15:38:36 +00:00
|
|
|
|
|
|
|
finish:
|
|
|
|
string_list_clear(&revs, 0);
|
|
|
|
string_list_clear(&states, 0);
|
|
|
|
strbuf_release(&start_head);
|
|
|
|
strbuf_release(&bisect_names);
|
2020-02-17 08:40:29 +00:00
|
|
|
return res;
|
2019-01-02 15:38:36 +00:00
|
|
|
}
|
|
|
|
|
2009-03-26 04:55:54 +00:00
|
|
|
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
2017-09-29 06:49:39 +00:00
|
|
|
enum {
|
|
|
|
NEXT_ALL = 1,
|
2017-09-29 06:49:39 +00:00
|
|
|
WRITE_TERMS,
|
2017-09-29 06:49:40 +00:00
|
|
|
BISECT_CLEAN_STATE,
|
2019-01-02 15:38:31 +00:00
|
|
|
CHECK_EXPECTED_REVS,
|
2019-01-02 15:38:32 +00:00
|
|
|
BISECT_RESET,
|
2019-01-02 15:38:33 +00:00
|
|
|
BISECT_WRITE,
|
2019-01-02 15:38:34 +00:00
|
|
|
CHECK_AND_SET_TERMS,
|
2019-01-02 15:38:35 +00:00
|
|
|
BISECT_NEXT_CHECK,
|
2019-01-02 15:38:36 +00:00
|
|
|
BISECT_TERMS,
|
|
|
|
BISECT_START
|
2017-09-29 06:49:39 +00:00
|
|
|
} cmdmode = 0;
|
2020-08-07 21:58:36 +00:00
|
|
|
int res = 0, nolog = 0;
|
2009-03-26 04:55:54 +00:00
|
|
|
struct option options[] = {
|
2017-09-29 06:49:39 +00:00
|
|
|
OPT_CMDMODE(0, "next-all", &cmdmode,
|
|
|
|
N_("perform 'git bisect next'"), NEXT_ALL),
|
2017-09-29 06:49:39 +00:00
|
|
|
OPT_CMDMODE(0, "write-terms", &cmdmode,
|
|
|
|
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
|
2017-09-29 06:49:39 +00:00
|
|
|
OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
|
|
|
|
N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
|
2017-09-29 06:49:40 +00:00
|
|
|
OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
|
|
|
|
N_("check for expected revs"), CHECK_EXPECTED_REVS),
|
2019-01-02 15:38:31 +00:00
|
|
|
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
|
|
|
|
N_("reset the bisection state"), BISECT_RESET),
|
2019-01-02 15:38:32 +00:00
|
|
|
OPT_CMDMODE(0, "bisect-write", &cmdmode,
|
|
|
|
N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
|
2019-01-02 15:38:33 +00:00
|
|
|
OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
|
|
|
|
N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
|
2019-01-02 15:38:34 +00:00
|
|
|
OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
|
|
|
|
N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
|
2019-01-02 15:38:35 +00:00
|
|
|
OPT_CMDMODE(0, "bisect-terms", &cmdmode,
|
|
|
|
N_("print out the bisect terms"), BISECT_TERMS),
|
2019-01-02 15:38:36 +00:00
|
|
|
OPT_CMDMODE(0, "bisect-start", &cmdmode,
|
|
|
|
N_("start the bisect session"), BISECT_START),
|
2019-01-02 15:38:32 +00:00
|
|
|
OPT_BOOL(0, "no-log", &nolog,
|
2019-02-11 06:44:53 +00:00
|
|
|
N_("no log for BISECT_WRITE")),
|
2009-03-26 04:55:54 +00:00
|
|
|
OPT_END()
|
|
|
|
};
|
2019-01-02 15:38:32 +00:00
|
|
|
struct bisect_terms terms = { .term_good = NULL, .term_bad = NULL };
|
2009-03-26 04:55:54 +00:00
|
|
|
|
2009-05-23 18:53:12 +00:00
|
|
|
argc = parse_options(argc, argv, prefix, options,
|
2019-01-02 15:38:36 +00:00
|
|
|
git_bisect_helper_usage,
|
|
|
|
PARSE_OPT_KEEP_DASHDASH | PARSE_OPT_KEEP_UNKNOWN);
|
2009-03-26 04:55:54 +00:00
|
|
|
|
2017-09-29 06:49:39 +00:00
|
|
|
if (!cmdmode)
|
2009-03-26 04:55:54 +00:00
|
|
|
usage_with_options(git_bisect_helper_usage, options);
|
|
|
|
|
2017-09-29 06:49:39 +00:00
|
|
|
switch (cmdmode) {
|
|
|
|
case NEXT_ALL:
|
2020-08-07 21:58:36 +00:00
|
|
|
res = bisect_next_all(the_repository, prefix);
|
2020-02-17 08:40:37 +00:00
|
|
|
break;
|
2017-09-29 06:49:39 +00:00
|
|
|
case WRITE_TERMS:
|
2017-09-29 06:49:39 +00:00
|
|
|
if (argc != 2)
|
2017-09-29 06:49:39 +00:00
|
|
|
return error(_("--write-terms requires two arguments"));
|
|
|
|
return write_terms(argv[0], argv[1]);
|
2017-09-29 06:49:39 +00:00
|
|
|
case BISECT_CLEAN_STATE:
|
|
|
|
if (argc != 0)
|
|
|
|
return error(_("--bisect-clean-state requires no arguments"));
|
|
|
|
return bisect_clean_state();
|
2017-09-29 06:49:40 +00:00
|
|
|
case CHECK_EXPECTED_REVS:
|
|
|
|
check_expected_revs(argv, argc);
|
|
|
|
return 0;
|
2019-01-02 15:38:31 +00:00
|
|
|
case BISECT_RESET:
|
|
|
|
if (argc > 1)
|
|
|
|
return error(_("--bisect-reset requires either no argument or a commit"));
|
|
|
|
return !!bisect_reset(argc ? argv[0] : NULL);
|
2019-01-02 15:38:32 +00:00
|
|
|
case BISECT_WRITE:
|
|
|
|
if (argc != 4 && argc != 5)
|
|
|
|
return error(_("--bisect-write requires either 4 or 5 arguments"));
|
|
|
|
set_terms(&terms, argv[3], argv[2]);
|
|
|
|
res = bisect_write(argv[0], argv[1], &terms, nolog);
|
|
|
|
break;
|
2019-01-02 15:38:33 +00:00
|
|
|
case CHECK_AND_SET_TERMS:
|
|
|
|
if (argc != 3)
|
|
|
|
return error(_("--check-and-set-terms requires 3 arguments"));
|
|
|
|
set_terms(&terms, argv[2], argv[1]);
|
|
|
|
res = check_and_set_terms(&terms, argv[0]);
|
|
|
|
break;
|
2019-01-02 15:38:34 +00:00
|
|
|
case BISECT_NEXT_CHECK:
|
|
|
|
if (argc != 2 && argc != 3)
|
|
|
|
return error(_("--bisect-next-check requires 2 or 3 arguments"));
|
|
|
|
set_terms(&terms, argv[1], argv[0]);
|
|
|
|
res = bisect_next_check(&terms, argc == 3 ? argv[2] : NULL);
|
|
|
|
break;
|
2019-01-02 15:38:35 +00:00
|
|
|
case BISECT_TERMS:
|
|
|
|
if (argc > 1)
|
|
|
|
return error(_("--bisect-terms requires 0 or 1 argument"));
|
|
|
|
res = bisect_terms(&terms, argc == 1 ? argv[0] : NULL);
|
|
|
|
break;
|
2019-01-02 15:38:36 +00:00
|
|
|
case BISECT_START:
|
|
|
|
set_terms(&terms, "bad", "good");
|
2020-08-07 21:58:36 +00:00
|
|
|
res = bisect_start(&terms, argv, argc);
|
2019-01-02 15:38:36 +00:00
|
|
|
break;
|
2017-09-29 06:49:39 +00:00
|
|
|
default:
|
2020-08-28 12:46:05 +00:00
|
|
|
BUG("unknown subcommand %d", cmdmode);
|
2017-09-29 06:49:39 +00:00
|
|
|
}
|
2019-01-02 15:38:32 +00:00
|
|
|
free_terms(&terms);
|
2020-02-17 08:40:37 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Handle early success
|
|
|
|
* From check_merge_bases > check_good_are_ancestors_of_bad > bisect_next_all
|
|
|
|
*/
|
|
|
|
if (res == BISECT_INTERNAL_SUCCESS_MERGE_BASE)
|
|
|
|
res = BISECT_OK;
|
|
|
|
|
2020-08-28 12:46:06 +00:00
|
|
|
return -res;
|
2009-03-26 04:55:54 +00:00
|
|
|
}
|