* [PATCH 0/9] Resend of gitster/pb/bisect
@ 2016-07-12 22:35 Pranit Bauva
2016-07-12 22:35 ` [PATCH 1/9] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
` (11 more replies)
0 siblings, 12 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-12 22:35 UTC (permalink / raw)
To: gitster; +Cc: Pranit Bauva, larsxschneider, christian.couder, chriscool, git
Hey Junio,
A small mistake got unnoticed by me which Lars recently pointed out.
The naming convention is "git_path_<name_of_file>" and underscore
instead of spaces.
Thanks!
The interdiff is:
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index c2f3cee..88a1df8 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -7,7 +7,7 @@
#include "argv-array.h"
#include "run-command.h"
-static GIT_PATH_FUNC(git_path_bisect_write_terms, "BISECT_TERMS")
+static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
@@ -100,7 +100,7 @@ static int write_terms(const char *bad, const char *good)
if (check_term_format(bad, "bad") || check_term_format(good, "good"))
return -1;
- fp = fopen(git_path_bisect_write_terms(), "w");
+ fp = fopen(git_path_bisect_terms(), "w");
if (!fp)
return error_errno(_("could not open the file BISECT_TERMS"));
@@ -134,7 +134,7 @@ static int bisect_clean_state(void)
remove_path(git_path_bisect_log());
remove_path(git_path_bisect_names());
remove_path(git_path_bisect_run());
- remove_path(git_path_bisect_write_terms());
+ remove_path(git_path_bisect_terms());
/* Cleanup head-name if it got left by an old version of git-bisect */
remove_path(git_path_head_name());
/*
Pranit Bauva (9):
bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
bisect: rewrite `check_term_format` shell function in C
bisect--helper: `write_terms` shell function in C
bisect--helper: `bisect_clean_state` shell function in C
t6030: explicitly test for bisection cleanup
wrapper: move is_empty_file() and rename it as
is_empty_or_missing_file()
bisect--helper: `bisect_reset` shell function in C
bisect--helper: `is_expected_rev` & `check_expected_revs` shell
function in C
bisect--helper: `bisect_write` shell function in C
builtin/am.c | 20 +--
builtin/bisect--helper.c | 310 +++++++++++++++++++++++++++++++++++++++++++-
cache.h | 3 +
git-bisect.sh | 146 +++------------------
t/t6030-bisect-porcelain.sh | 17 +++
wrapper.c | 13 ++
6 files changed, 355 insertions(+), 154 deletions(-)
--
2.9.0
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH 1/9] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2016-07-12 22:35 [PATCH 0/9] Resend of gitster/pb/bisect Pranit Bauva
@ 2016-07-12 22:35 ` Pranit Bauva
2016-07-12 22:35 ` [PATCH 2/9] bisect: rewrite `check_term_format` shell function in C Pranit Bauva
` (10 subsequent siblings)
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-12 22:35 UTC (permalink / raw)
To: gitster; +Cc: Pranit Bauva, larsxschneider, christian.couder, chriscool, git
`--next-all` is meant to be used as a subcommand to support multiple
"operation mode" though the current implementation does not contain any
other subcommand along side with `--next-all` but further commits will
include some more subcommands.
Helped-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 17 +++++++++++------
1 file changed, 11 insertions(+), 6 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 3324229..8111c91 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -10,11 +10,11 @@ static const char * const git_bisect_helper_usage[] = {
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
- int next_all = 0;
+ enum { NEXT_ALL = 1 } cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
- OPT_BOOL(0, "next-all", &next_all,
- N_("perform 'git bisect next'")),
+ OPT_CMDMODE(0, "next-all", &cmdmode,
+ N_("perform 'git bisect next'"), NEXT_ALL),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -23,9 +23,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
argc = parse_options(argc, argv, prefix, options,
git_bisect_helper_usage, 0);
- if (!next_all)
+ if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
- /* next-all */
- return bisect_next_all(prefix, no_checkout);
+ switch (cmdmode) {
+ case NEXT_ALL:
+ return bisect_next_all(prefix, no_checkout);
+ default:
+ die("BUG: unknown subcommand '%d'", cmdmode);
+ }
+ return 0;
}
--
2.9.0
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH 2/9] bisect: rewrite `check_term_format` shell function in C
2016-07-12 22:35 [PATCH 0/9] Resend of gitster/pb/bisect Pranit Bauva
2016-07-12 22:35 ` [PATCH 1/9] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
@ 2016-07-12 22:35 ` Pranit Bauva
2016-07-12 22:35 ` [PATCH 3/9] bisect--helper: `write_terms` " Pranit Bauva
` (9 subsequent siblings)
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-12 22:35 UTC (permalink / raw)
To: gitster; +Cc: Pranit Bauva, larsxschneider, christian.couder, chriscool, git
Reimplement the `check_term_format` shell function in C and add
a `--check-term-format` subcommand to `git bisect--helper` to call it
from git-bisect.sh
Using `--check-term-format` subcommand is a temporary measure to port
shell function to C so as to use the existing test suite. As more
functions are ported, this subcommand will be retired and will
be called by some other method/subcommand. For eg. In conversion of
write_terms() of git-bisect.sh, the subcommand will be removed and
instead check_term_format() will be called in its C implementation while
a new subcommand will be introduced for write_terms().
Helped-by: Johannes Schindelein <Johannes.Schindelein@gmx.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 59 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 31 ++-----------------------
2 files changed, 60 insertions(+), 30 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 8111c91..3c748d1 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -2,19 +2,72 @@
#include "cache.h"
#include "parse-options.h"
#include "bisect.h"
+#include "refs.h"
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
+ N_("git bisect--helper --check-term-format <term> <orig_term>"),
NULL
};
+/*
+ * Check whether the string `term` belongs to the set of strings
+ * included in the variable arguments.
+ */
+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)
+{
+ struct strbuf new_term = STRBUF_INIT;
+ strbuf_addf(&new_term, "refs/bisect/%s", term);
+
+ if (check_refname_format(new_term.buf, 0)) {
+ strbuf_release(&new_term);
+ return error(_("'%s' is not a valid term"), term);
+ }
+ strbuf_release(&new_term);
+
+ if (one_of(term, "help", "start", "skip", "next", "reset",
+ "visualize", "replay", "log", "run", NULL))
+ 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;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
- enum { NEXT_ALL = 1 } cmdmode = 0;
+ enum {
+ NEXT_ALL = 1,
+ CHECK_TERM_FMT
+ } cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
+ OPT_CMDMODE(0, "check-term-format", &cmdmode,
+ N_("check format of the term"), CHECK_TERM_FMT),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -29,6 +82,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
switch (cmdmode) {
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
+ case CHECK_TERM_FMT:
+ if (argc != 2)
+ die(_("--check-term-format requires two arguments"));
+ return check_term_format(argv[0], argv[1]);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 5d1cb00..7d7965d 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -564,38 +564,11 @@ write_terms () {
then
die "$(gettext "please use two different terms")"
fi
- check_term_format "$TERM_BAD" bad
- check_term_format "$TERM_GOOD" good
+ git bisect--helper --check-term-format "$TERM_BAD" bad || exit
+ git bisect--helper --check-term-format "$TERM_GOOD" good || exit
printf '%s\n%s\n' "$TERM_BAD" "$TERM_GOOD" >"$GIT_DIR/BISECT_TERMS"
}
-check_term_format () {
- term=$1
- git check-ref-format refs/bisect/"$term" ||
- die "$(eval_gettext "'\$term' is not a valid term")"
- case "$term" in
- help|start|terms|skip|next|reset|visualize|replay|log|run)
- die "$(eval_gettext "can't use the builtin command '\$term' as a term")"
- ;;
- bad|new)
- if test "$2" != bad
- then
- # 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.
- die "$(eval_gettext "can't change the meaning of term '\$term'")"
- fi
- ;;
- good|old)
- if test "$2" != good
- then
- die "$(eval_gettext "can't change the meaning of term '\$term'")"
- fi
- ;;
- esac
-}
-
check_and_set_terms () {
cmd="$1"
case "$cmd" in
--
2.9.0
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH 3/9] bisect--helper: `write_terms` shell function in C
2016-07-12 22:35 [PATCH 0/9] Resend of gitster/pb/bisect Pranit Bauva
2016-07-12 22:35 ` [PATCH 1/9] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
2016-07-12 22:35 ` [PATCH 2/9] bisect: rewrite `check_term_format` shell function in C Pranit Bauva
@ 2016-07-12 22:35 ` Pranit Bauva
2016-07-12 22:35 ` [PATCH 4/9] bisect--helper: `bisect_clean_state` " Pranit Bauva
` (8 subsequent siblings)
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-12 22:35 UTC (permalink / raw)
To: gitster; +Cc: Pranit Bauva, larsxschneider, christian.couder, chriscool, git
Reimplement the `write_terms` shell function in C and add a `write-terms`
subcommand to `git bisect--helper` to call it from git-bisect.sh . Also
remove the subcommand `--check-term-format` as it can now be called from
inside the function write_terms() C implementation.
Also `|| exit` is added when calling write-terms subcommand from
git-bisect.sh so as to exit whenever there is an error.
Using `--write-terms` subcommand is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other method.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 36 +++++++++++++++++++++++++++++-------
git-bisect.sh | 22 +++++++---------------
2 files changed, 36 insertions(+), 22 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 3c748d1..bec63d6 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -4,9 +4,11 @@
#include "bisect.h"
#include "refs.h"
+static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
+
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
- N_("git bisect--helper --check-term-format <term> <orig_term>"),
+ N_("git bisect--helper --write-terms <bad_term> <good_term>"),
NULL
};
@@ -56,18 +58,38 @@ static int check_term_format(const char *term, const char *orig_term)
return 0;
}
+static int write_terms(const char *bad, const char *good)
+{
+ FILE *fp;
+ 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);
+ fclose(fp);
+ return (res < 0) ? -1 : 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
- CHECK_TERM_FMT
+ WRITE_TERMS
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
- OPT_CMDMODE(0, "check-term-format", &cmdmode,
- N_("check format of the term"), CHECK_TERM_FMT),
+ OPT_CMDMODE(0, "write-terms", &cmdmode,
+ N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -82,10 +104,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
switch (cmdmode) {
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
- case CHECK_TERM_FMT:
+ case WRITE_TERMS:
if (argc != 2)
- die(_("--check-term-format requires two arguments"));
- return check_term_format(argv[0], argv[1]);
+ die(_("--write-terms requires two arguments"));
+ return write_terms(argv[0], argv[1]);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 7d7965d..cd39bd0 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -210,7 +210,7 @@ bisect_start() {
eval "$eval true" &&
if test $must_write_terms -eq 1
then
- write_terms "$TERM_BAD" "$TERM_GOOD"
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD"
fi &&
echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
#
@@ -557,18 +557,6 @@ get_terms () {
fi
}
-write_terms () {
- TERM_BAD=$1
- TERM_GOOD=$2
- if test "$TERM_BAD" = "$TERM_GOOD"
- then
- die "$(gettext "please use two different terms")"
- fi
- git bisect--helper --check-term-format "$TERM_BAD" bad || exit
- git bisect--helper --check-term-format "$TERM_GOOD" good || exit
- printf '%s\n%s\n' "$TERM_BAD" "$TERM_GOOD" >"$GIT_DIR/BISECT_TERMS"
-}
-
check_and_set_terms () {
cmd="$1"
case "$cmd" in
@@ -582,13 +570,17 @@ check_and_set_terms () {
bad|good)
if ! test -s "$GIT_DIR/BISECT_TERMS"
then
- write_terms bad good
+ TERM_BAD=bad
+ TERM_GOOD=good
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
fi
;;
new|old)
if ! test -s "$GIT_DIR/BISECT_TERMS"
then
- write_terms new old
+ TERM_BAD=new
+ TERM_GOOD=old
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
fi
;;
esac ;;
--
2.9.0
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH 4/9] bisect--helper: `bisect_clean_state` shell function in C
2016-07-12 22:35 [PATCH 0/9] Resend of gitster/pb/bisect Pranit Bauva
` (2 preceding siblings ...)
2016-07-12 22:35 ` [PATCH 3/9] bisect--helper: `write_terms` " Pranit Bauva
@ 2016-07-12 22:35 ` Pranit Bauva
2016-07-12 22:35 ` [PATCH 5/9] t6030: explicitly test for bisection cleanup Pranit Bauva
` (7 subsequent siblings)
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-12 22:35 UTC (permalink / raw)
To: gitster; +Cc: Pranit Bauva, larsxschneider, christian.couder, chriscool, git
Reimplement `bisect_clean_state` shell function in C and add a
`bisect-clean-state` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Using `--bisect-clean-state` subcommand is a measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by
bisect_reset() and bisect_start().
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 55 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 26 +++--------------------
2 files changed, 57 insertions(+), 24 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index bec63d6..3089433 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -3,12 +3,21 @@
#include "parse-options.h"
#include "bisect.h"
#include "refs.h"
+#include "dir.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
+static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
+static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
+static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
+static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
+static GIT_PATH_FUNC(git_path_bisect_run, "BISECT_RUN")
+static GIT_PATH_FUNC(git_path_head_name, "head-name")
+static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
+ N_("git bisect--helper --bisect-clean-state"),
NULL
};
@@ -78,11 +87,49 @@ static int write_terms(const char *bad, const char *good)
return (res < 0) ? -1 : 0;
}
+static int mark_for_removal(const char *refname, const struct object_id *oid,
+ int flag, void *cb_data)
+{
+ struct string_list *refs = cb_data;
+ char *ref = xstrfmt("refs/bisect/%s", refname);
+ string_list_append(refs, ref);
+ return 0;
+}
+
+static int bisect_clean_state(void)
+{
+ int result = 0;
+
+ /* There may be some refs packed during bisection */
+ struct string_list refs_for_removal = STRING_LIST_INIT_NODUP;
+ for_each_ref_in("refs/bisect/", mark_for_removal, (void *) &refs_for_removal);
+ string_list_append(&refs_for_removal, xstrdup("BISECT_HEAD"));
+ result = delete_refs(&refs_for_removal);
+ refs_for_removal.strdup_strings = 1;
+ string_list_clear(&refs_for_removal, 0);
+ remove_path(git_path_bisect_expected_rev());
+ remove_path(git_path_bisect_ancestors_ok());
+ remove_path(git_path_bisect_log());
+ remove_path(git_path_bisect_names());
+ remove_path(git_path_bisect_run());
+ remove_path(git_path_bisect_terms());
+ /* Cleanup head-name if it got left by an old version of git-bisect */
+ remove_path(git_path_head_name());
+ /*
+ * Cleanup BISECT_START last to support the --no-checkout option
+ * introduced in the commit 4796e823a.
+ */
+ remove_path(git_path_bisect_start());
+
+ return result;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
- WRITE_TERMS
+ WRITE_TERMS,
+ BISECT_CLEAN_STATE
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -90,6 +137,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("perform 'git bisect next'"), NEXT_ALL),
OPT_CMDMODE(0, "write-terms", &cmdmode,
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
+ OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
+ N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -108,6 +157,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc != 2)
die(_("--write-terms requires two arguments"));
return write_terms(argv[0], argv[1]);
+ case BISECT_CLEAN_STATE:
+ if (argc != 0)
+ die(_("--bisect-clean-state requires no arguments"));
+ return bisect_clean_state();
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index cd39bd0..bbc57d2 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -187,7 +187,7 @@ bisect_start() {
#
# Get rid of any old bisect state.
#
- bisect_clean_state || exit
+ git bisect--helper --bisect-clean-state || exit
#
# Change state.
@@ -196,7 +196,7 @@ bisect_start() {
# We have to trap this to be able to clean up using
# "bisect_clean_state".
#
- trap 'bisect_clean_state' 0
+ trap 'git bisect--helper --bisect-clean-state' 0
trap 'exit 255' 1 2 3 15
#
@@ -430,27 +430,7 @@ bisect_reset() {
die "$(eval_gettext "Could not check out original HEAD '\$branch'.
Try 'git bisect reset <commit>'.")"
fi
- bisect_clean_state
-}
-
-bisect_clean_state() {
- # There may be some refs packed during bisection.
- git for-each-ref --format='%(refname) %(objectname)' refs/bisect/\* |
- while read ref hash
- do
- git update-ref -d $ref $hash || exit
- done
- rm -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
- rm -f "$GIT_DIR/BISECT_ANCESTORS_OK" &&
- rm -f "$GIT_DIR/BISECT_LOG" &&
- rm -f "$GIT_DIR/BISECT_NAMES" &&
- rm -f "$GIT_DIR/BISECT_RUN" &&
- rm -f "$GIT_DIR/BISECT_TERMS" &&
- # Cleanup head-name if it got left by an old version of git-bisect
- rm -f "$GIT_DIR/head-name" &&
- git update-ref -d --no-deref BISECT_HEAD &&
- # clean up BISECT_START last
- rm -f "$GIT_DIR/BISECT_START"
+ git bisect--helper --bisect-clean-state || exit
}
bisect_replay () {
--
2.9.0
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH 5/9] t6030: explicitly test for bisection cleanup
2016-07-12 22:35 [PATCH 0/9] Resend of gitster/pb/bisect Pranit Bauva
` (3 preceding siblings ...)
2016-07-12 22:35 ` [PATCH 4/9] bisect--helper: `bisect_clean_state` " Pranit Bauva
@ 2016-07-12 22:35 ` Pranit Bauva
2016-07-12 22:35 ` [PATCH 6/9] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
` (6 subsequent siblings)
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-12 22:35 UTC (permalink / raw)
To: gitster; +Cc: Pranit Bauva, larsxschneider, christian.couder, chriscool, git
Add test to explicitly check that 'git bisect reset' is working as
expected. This is already covered implicitly by the test suite.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
I faced this problem while converting `bisect_clean_state` and the tests
where showing breakages but it wasn't clear as to where exactly are they
breaking. This will patch will help in that. Also I tested the test
coverage of the test suite before this patch and it covers this (I did
this by purposely changing names of files in git-bisect.sh and running
the test suite).
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
t/t6030-bisect-porcelain.sh | 17 +++++++++++++++++
1 file changed, 17 insertions(+)
diff --git a/t/t6030-bisect-porcelain.sh b/t/t6030-bisect-porcelain.sh
index e74662b..a17f7a6 100755
--- a/t/t6030-bisect-porcelain.sh
+++ b/t/t6030-bisect-porcelain.sh
@@ -894,4 +894,21 @@ test_expect_success 'bisect start takes options and revs in any order' '
test_cmp expected actual
'
+test_expect_success 'git bisect reset cleans bisection state properly' '
+ git bisect reset &&
+ git bisect start &&
+ git bisect good $HASH1 &&
+ git bisect bad $HASH4 &&
+ git bisect reset &&
+ test -z "$(git for-each-ref "refs/bisect/*")" &&
+ test_path_is_missing "$GIT_DIR/BISECT_EXPECTED_REV" &&
+ test_path_is_missing "$GIT_DIR/BISECT_ANCESTORS_OK" &&
+ test_path_is_missing "$GIT_DIR/BISECT_LOG" &&
+ test_path_is_missing "$GIT_DIR/BISECT_RUN" &&
+ test_path_is_missing "$GIT_DIR/BISECT_TERMS" &&
+ test_path_is_missing "$GIT_DIR/head-name" &&
+ test_path_is_missing "$GIT_DIR/BISECT_HEAD" &&
+ test_path_is_missing "$GIT_DIR/BISECT_START"
+'
+
test_done
--
2.9.0
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH 6/9] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file()
2016-07-12 22:35 [PATCH 0/9] Resend of gitster/pb/bisect Pranit Bauva
` (4 preceding siblings ...)
2016-07-12 22:35 ` [PATCH 5/9] t6030: explicitly test for bisection cleanup Pranit Bauva
@ 2016-07-12 22:35 ` Pranit Bauva
2016-07-12 22:35 ` [PATCH 7/9] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
` (5 subsequent siblings)
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-12 22:35 UTC (permalink / raw)
To: gitster; +Cc: Pranit Bauva, larsxschneider, christian.couder, chriscool, git
is_empty_file() can help to refactor a lot of code. This will be very
helpful in porting "git bisect" to C.
Suggested-by: Torsten Bögershausen <tboegi@web.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/am.c | 20 ++------------------
cache.h | 3 +++
wrapper.c | 13 +++++++++++++
3 files changed, 18 insertions(+), 18 deletions(-)
diff --git a/builtin/am.c b/builtin/am.c
index 3dfe70b..6ee158f 100644
--- a/builtin/am.c
+++ b/builtin/am.c
@@ -30,22 +30,6 @@
#include "mailinfo.h"
/**
- * Returns 1 if the file is empty or does not exist, 0 otherwise.
- */
-static int is_empty_file(const char *filename)
-{
- struct stat st;
-
- if (stat(filename, &st) < 0) {
- if (errno == ENOENT)
- return 1;
- die_errno(_("could not stat %s"), filename);
- }
-
- return !st.st_size;
-}
-
-/**
* Returns the length of the first line of msg.
*/
static int linelen(const char *msg)
@@ -1323,7 +1307,7 @@ static int parse_mail(struct am_state *state, const char *mail)
goto finish;
}
- if (is_empty_file(am_path(state, "patch"))) {
+ if (is_empty_or_missing_file(am_path(state, "patch"))) {
printf_ln(_("Patch is empty. Was it split wrong?"));
die_user_resolve(state);
}
@@ -1911,7 +1895,7 @@ next:
resume = 0;
}
- if (!is_empty_file(am_path(state, "rewritten"))) {
+ if (!is_empty_or_missing_file(am_path(state, "rewritten"))) {
assert(state->rebasing);
copy_notes_for_rebase(state);
run_post_rewrite_hook(state);
diff --git a/cache.h b/cache.h
index 6049f86..91e2f81 100644
--- a/cache.h
+++ b/cache.h
@@ -1870,4 +1870,7 @@ void sleep_millisec(int millisec);
*/
void safe_create_dir(const char *dir, int share);
+/* Return 1 if the file is empty or does not exists, 0 otherwise. */
+extern int is_empty_or_missing_file(const char *filename);
+
#endif /* CACHE_H */
diff --git a/wrapper.c b/wrapper.c
index 5dc4e15..e70e4d1 100644
--- a/wrapper.c
+++ b/wrapper.c
@@ -696,3 +696,16 @@ void sleep_millisec(int millisec)
{
poll(NULL, 0, millisec);
}
+
+int is_empty_or_missing_file(const char *filename)
+{
+ struct stat st;
+
+ if (stat(filename, &st) < 0) {
+ if (errno == ENOENT)
+ return 1;
+ die_errno(_("could not stat %s"), filename);
+ }
+
+ return !st.st_size;
+}
--
2.9.0
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH 7/9] bisect--helper: `bisect_reset` shell function in C
2016-07-12 22:35 [PATCH 0/9] Resend of gitster/pb/bisect Pranit Bauva
` (5 preceding siblings ...)
2016-07-12 22:35 ` [PATCH 6/9] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
@ 2016-07-12 22:35 ` Pranit Bauva
2016-07-12 22:35 ` [PATCH 8/9] bisect--helper: `is_expected_rev` & `check_expected_revs` " Pranit Bauva
` (4 subsequent siblings)
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-12 22:35 UTC (permalink / raw)
To: gitster; +Cc: Pranit Bauva, larsxschneider, christian.couder, chriscool, git
Reimplement `bisect_reset` shell function in C and add a `--bisect-reset`
subcommand to `git bisect--helper` to call it from git-bisect.sh .
Using `bisect_reset` subcommand is a temporary measure to port shell
functions to C so as to use the existing test suite. As more functions
are ported, this subcommand would be retired and will be called by some
other method.
Note: --bisect-clean-state subcommand has not been retired as there are
still a function namely `bisect_start()` which still uses this
subcommand.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 47 ++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 28 ++--------------------------
2 files changed, 48 insertions(+), 27 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 3089433..636044a 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -4,6 +4,8 @@
#include "bisect.h"
#include "refs.h"
#include "dir.h"
+#include "argv-array.h"
+#include "run-command.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
@@ -13,11 +15,13 @@ static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static GIT_PATH_FUNC(git_path_bisect_run, "BISECT_RUN")
static GIT_PATH_FUNC(git_path_head_name, "head-name")
static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
+static GIT_PATH_FUNC(git_path_bisect_head, "BISECT_HEAD")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-clean-state"),
+ N_("git bisect--helper --bisect-reset [<commit>]"),
NULL
};
@@ -124,12 +128,47 @@ static int bisect_clean_state(void)
return result;
}
+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, &oid))
+ return error(_("'%s' is not a valid commit"), commit);
+ strbuf_addstr(&branch, commit);
+ }
+
+ if (!file_exists(git_path_bisect_head())) {
+ struct argv_array argv = ARGV_ARRAY_INIT;
+ argv_array_pushl(&argv, "checkout", branch.buf, "--", NULL);
+ if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
+ error(_("Could not check out original HEAD '%s'. Try"
+ "'git bisect reset <commit>'."), branch.buf);
+ strbuf_release(&branch);
+ argv_array_clear(&argv);
+ return -1;
+ }
+ argv_array_clear(&argv);
+ }
+
+ strbuf_release(&branch);
+ return bisect_clean_state();
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
WRITE_TERMS,
- BISECT_CLEAN_STATE
+ BISECT_CLEAN_STATE,
+ BISECT_RESET
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -139,6 +178,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
+ OPT_CMDMODE(0, "bisect-reset", &cmdmode,
+ N_("reset the bisection state"), BISECT_RESET),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -161,6 +202,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc != 0)
die(_("--bisect-clean-state requires no arguments"));
return bisect_clean_state();
+ case BISECT_RESET:
+ if (argc > 1)
+ die(_("--bisect-reset requires either zero or one arguments"));
+ return bisect_reset(argc ? argv[0] : NULL);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index bbc57d2..18580b7 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -409,35 +409,11 @@ bisect_visualize() {
eval '"$@"' --bisect -- $(cat "$GIT_DIR/BISECT_NAMES")
}
-bisect_reset() {
- test -s "$GIT_DIR/BISECT_START" || {
- gettextln "We are not bisecting."
- return
- }
- case "$#" in
- 0) branch=$(cat "$GIT_DIR/BISECT_START") ;;
- 1) git rev-parse --quiet --verify "$1^{commit}" >/dev/null || {
- invalid="$1"
- die "$(eval_gettext "'\$invalid' is not a valid commit")"
- }
- branch="$1" ;;
- *)
- usage ;;
- esac
-
- if ! test -f "$GIT_DIR/BISECT_HEAD" && ! git checkout "$branch" --
- then
- die "$(eval_gettext "Could not check out original HEAD '\$branch'.
-Try 'git bisect reset <commit>'.")"
- fi
- git bisect--helper --bisect-clean-state || exit
-}
-
bisect_replay () {
file="$1"
test "$#" -eq 1 || die "$(gettext "No logfile given")"
test -r "$file" || die "$(eval_gettext "cannot read \$file for replaying")"
- bisect_reset
+ git bisect--helper --bisect-reset || exit
while read git bisect command rev
do
test "$git $bisect" = "git bisect" || test "$git" = "git-bisect" || continue
@@ -627,7 +603,7 @@ case "$#" in
visualize|view)
bisect_visualize "$@" ;;
reset)
- bisect_reset "$@" ;;
+ git bisect--helper --bisect-reset "$@" ;;
replay)
bisect_replay "$@" ;;
log)
--
2.9.0
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH 8/9] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C
2016-07-12 22:35 [PATCH 0/9] Resend of gitster/pb/bisect Pranit Bauva
` (6 preceding siblings ...)
2016-07-12 22:35 ` [PATCH 7/9] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
@ 2016-07-12 22:35 ` Pranit Bauva
2016-07-12 22:35 ` [PATCH 9/9] bisect--helper: `bisect_write` " Pranit Bauva
` (3 subsequent siblings)
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-12 22:35 UTC (permalink / raw)
To: gitster; +Cc: Pranit Bauva, larsxschneider, christian.couder, chriscool, git
Reimplement `is_expected_rev` & `check_expected_revs` shell function in
C and add a `--check-expected-revs` subcommand to `git bisect--helper` to
call it from git-bisect.sh .
Using `--check-expected-revs` subcommand is a temporary measure to port
shell functions to C so as to use the existing test suite. As more
functions are ported, this subcommand would be retired and will be
called by some other method.
Helped-by: Eric Sunshine <sunshine@sunshineco.com>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 33 ++++++++++++++++++++++++++++++++-
git-bisect.sh | 20 ++------------------
2 files changed, 34 insertions(+), 19 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 636044a..88b5d0a 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -162,13 +162,40 @@ static int bisect_reset(const char *commit)
return bisect_clean_state();
}
+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) >= 0) {
+ strbuf_trim(&actual_hex);
+ res = !strcmp(actual_hex.buf, expected_hex);
+ }
+ strbuf_release(&actual_hex);
+ return res;
+}
+
+static int check_expected_revs(const char **revs, int rev_nr)
+{
+ int i;
+
+ for (i = 0; i < rev_nr; i++) {
+ if (!is_expected_rev(revs[i])) {
+ remove_path(git_path_bisect_ancestors_ok());
+ remove_path(git_path_bisect_expected_rev());
+ return 0;
+ }
+ }
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
WRITE_TERMS,
BISECT_CLEAN_STATE,
- BISECT_RESET
+ BISECT_RESET,
+ CHECK_EXPECTED_REVS
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -180,6 +207,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
N_("reset the bisection state"), BISECT_RESET),
+ OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
+ N_("check for expected revs"), CHECK_EXPECTED_REVS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -206,6 +235,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc > 1)
die(_("--bisect-reset requires either zero or one arguments"));
return bisect_reset(argc ? argv[0] : NULL);
+ case CHECK_EXPECTED_REVS:
+ return check_expected_revs(argv, argc);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 18580b7..4f6545e 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -238,22 +238,6 @@ bisect_write() {
test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
}
-is_expected_rev() {
- test -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
- test "$1" = $(cat "$GIT_DIR/BISECT_EXPECTED_REV")
-}
-
-check_expected_revs() {
- for _rev in "$@"; do
- if ! is_expected_rev "$_rev"
- then
- rm -f "$GIT_DIR/BISECT_ANCESTORS_OK"
- rm -f "$GIT_DIR/BISECT_EXPECTED_REV"
- return
- fi
- done
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -280,7 +264,7 @@ bisect_state() {
rev=$(git rev-parse --verify $(bisect_head)) ||
die "$(gettext "Bad rev input: $(bisect_head)")"
bisect_write "$state" "$rev"
- check_expected_revs "$rev" ;;
+ git bisect--helper --check-expected-revs "$rev" ;;
2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
shift
hash_list=''
@@ -294,7 +278,7 @@ bisect_state() {
do
bisect_write "$state" "$rev"
done
- check_expected_revs $hash_list ;;
+ git bisect--helper --check-expected-revs $hash_list ;;
*,"$TERM_BAD")
die "$(eval_gettext "'git bisect \$TERM_BAD' can take only one argument.")" ;;
*)
--
2.9.0
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH 9/9] bisect--helper: `bisect_write` shell function in C
2016-07-12 22:35 [PATCH 0/9] Resend of gitster/pb/bisect Pranit Bauva
` (7 preceding siblings ...)
2016-07-12 22:35 ` [PATCH 8/9] bisect--helper: `is_expected_rev` & `check_expected_revs` " Pranit Bauva
@ 2016-07-12 22:35 ` Pranit Bauva
2016-07-13 7:47 ` [PATCH 0/9] Resend of gitster/pb/bisect Christian Couder
` (2 subsequent siblings)
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-12 22:35 UTC (permalink / raw)
To: gitster; +Cc: Pranit Bauva, larsxschneider, christian.couder, chriscool, git
Reimplement the `bisect_write` shell function in C and add a
`bisect-write` subcommand to `git bisect--helper` to call it from
git-bisect.sh
Using `--bisect-write` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other methods.
Note: bisect_write() uses two variables namely TERM_GOOD and TERM_BAD
from the global shell script thus we need to pass it to the subcommand
using the arguments. We then store them in a struct bisect_terms and
pass the memory address around functions.
This patch also introduces new methods namely bisect_state_init() and
bisect_terms_release() for easy memory management for the struct
bisect_terms.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 97 ++++++++++++++++++++++++++++++++++++++++++++----
git-bisect.sh | 25 ++-----------
2 files changed, 94 insertions(+), 28 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 88b5d0a..88a1df8 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -22,9 +22,27 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-clean-state"),
N_("git bisect--helper --bisect-reset [<commit>]"),
+ N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
NULL
};
+struct bisect_terms {
+ struct strbuf term_good;
+ struct strbuf term_bad;
+};
+
+static void bisect_terms_init(struct bisect_terms *terms)
+{
+ strbuf_init(&terms->term_good, 0);
+ strbuf_init(&terms->term_bad, 0);
+}
+
+static void bisect_terms_release(struct bisect_terms *terms)
+{
+ strbuf_release(&terms->term_good);
+ strbuf_release(&terms->term_bad);
+}
+
/*
* Check whether the string `term` belongs to the set of strings
* included in the variable arguments.
@@ -188,6 +206,52 @@ static int check_expected_revs(const char **revs, int rev_nr)
return 0;
}
+static int bisect_write(const char *state, const char *rev,
+ const struct bisect_terms *terms, int nolog)
+{
+ struct strbuf tag = STRBUF_INIT;
+ struct strbuf commit_name = STRBUF_INIT;
+ struct object_id oid;
+ struct commit *commit;
+ struct pretty_print_context pp = {0};
+ FILE *fp;
+
+ if (!strcmp(state, terms->term_bad.buf))
+ strbuf_addf(&tag, "refs/bisect/%s", state);
+ else if(one_of(state, terms->term_good.buf, "skip", NULL))
+ strbuf_addf(&tag, "refs/bisect/%s-%s", state, rev);
+ else
+ return error(_("Bad bisect_write argument: %s"), state);
+
+ if (get_oid(rev, &oid)) {
+ strbuf_release(&tag);
+ return error(_("couldn't get the oid of the rev '%s'"), rev);
+ }
+
+ if (update_ref(NULL, tag.buf, oid.hash, NULL, 0,
+ UPDATE_REFS_MSG_ON_ERR)) {
+ strbuf_release(&tag);
+ return -1;
+ }
+ strbuf_release(&tag);
+
+ fp = fopen(git_path_bisect_log(), "a");
+ if (!fp)
+ return error_errno(_("couldn't open the file '%s'"), git_path_bisect_log());
+
+ commit = lookup_commit_reference(oid.hash);
+ format_commit_message(commit, "%s", &commit_name, &pp);
+ fprintf(fp, "# %s: [%s] %s\n", state, sha1_to_hex(oid.hash),
+ commit_name.buf);
+ strbuf_release(&commit_name);
+
+ if (!nolog)
+ fprintf(fp, "git bisect %s %s\n", state, rev);
+
+ fclose(fp);
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -195,9 +259,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
WRITE_TERMS,
BISECT_CLEAN_STATE,
BISECT_RESET,
- CHECK_EXPECTED_REVS
+ CHECK_EXPECTED_REVS,
+ BISECT_WRITE
} cmdmode = 0;
- int no_checkout = 0;
+ int no_checkout = 0, res = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
@@ -209,10 +274,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("reset the bisection state"), BISECT_RESET),
OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
N_("check for expected revs"), CHECK_EXPECTED_REVS),
+ OPT_CMDMODE(0, "bisect-write", &cmdmode,
+ N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
};
+ struct bisect_terms terms;
+ bisect_terms_init(&terms);
argc = parse_options(argc, argv, prefix, options,
git_bisect_helper_usage, 0);
@@ -221,24 +290,38 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
usage_with_options(git_bisect_helper_usage, options);
switch (cmdmode) {
+ int nolog;
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
case WRITE_TERMS:
if (argc != 2)
die(_("--write-terms requires two arguments"));
- return write_terms(argv[0], argv[1]);
+ res = write_terms(argv[0], argv[1]);
+ break;
case BISECT_CLEAN_STATE:
if (argc != 0)
die(_("--bisect-clean-state requires no arguments"));
- return bisect_clean_state();
+ res = bisect_clean_state();
+ break;
case BISECT_RESET:
if (argc > 1)
die(_("--bisect-reset requires either zero or one arguments"));
- return bisect_reset(argc ? argv[0] : NULL);
+ res = bisect_reset(argc ? argv[0] : NULL);
+ break;
case CHECK_EXPECTED_REVS:
- return check_expected_revs(argv, argc);
+ res = check_expected_revs(argv, argc);
+ break;
+ case BISECT_WRITE:
+ if (argc != 4 && argc != 5)
+ die(_("--bisect-write requires either 4 or 5 arguments"));
+ nolog = (argc == 5) && !strcmp(argv[4], "nolog");
+ strbuf_addstr(&terms.term_good, argv[2]);
+ strbuf_addstr(&terms.term_bad, argv[3]);
+ res = bisect_write(argv[0], argv[1], &terms, nolog);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
- return 0;
+ bisect_terms_release(&terms);
+ return res;
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 4f6545e..b9896a4 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -145,7 +145,7 @@ bisect_start() {
0) state=$TERM_BAD ; bad_seen=1 ;;
*) state=$TERM_GOOD ;;
esac
- eval="$eval bisect_write '$state' '$rev' 'nolog' &&"
+ eval="$eval git bisect--helper --bisect-write '$state' '$rev' '$TERM_GOOD' '$TERM_BAD' 'nolog' &&"
done
#
# Verify HEAD.
@@ -221,23 +221,6 @@ bisect_start() {
trap '-' 0
}
-bisect_write() {
- state="$1"
- rev="$2"
- nolog="$3"
- case "$state" in
- "$TERM_BAD")
- tag="$state" ;;
- "$TERM_GOOD"|skip)
- tag="$state"-"$rev" ;;
- *)
- die "$(eval_gettext "Bad bisect_write argument: \$state")" ;;
- esac
- git update-ref "refs/bisect/$tag" "$rev" || exit
- echo "# $state: $(git show-branch $rev)" >>"$GIT_DIR/BISECT_LOG"
- test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -263,7 +246,7 @@ bisect_state() {
1,"$TERM_BAD"|1,"$TERM_GOOD"|1,skip)
rev=$(git rev-parse --verify $(bisect_head)) ||
die "$(gettext "Bad rev input: $(bisect_head)")"
- bisect_write "$state" "$rev"
+ git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
git bisect--helper --check-expected-revs "$rev" ;;
2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
shift
@@ -276,7 +259,7 @@ bisect_state() {
done
for rev in $hash_list
do
- bisect_write "$state" "$rev"
+ git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
done
git bisect--helper --check-expected-revs $hash_list ;;
*,"$TERM_BAD")
@@ -413,7 +396,7 @@ bisect_replay () {
cmd="bisect_start $rev"
eval "$cmd" ;;
"$TERM_GOOD"|"$TERM_BAD"|skip)
- bisect_write "$command" "$rev" ;;
+ git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
terms)
bisect_terms $rev ;;
*)
--
2.9.0
^ permalink raw reply related [flat|nested] 320+ messages in thread
* Re: [PATCH 0/9] Resend of gitster/pb/bisect
2016-07-12 22:35 [PATCH 0/9] Resend of gitster/pb/bisect Pranit Bauva
` (8 preceding siblings ...)
2016-07-12 22:35 ` [PATCH 9/9] bisect--helper: `bisect_write` " Pranit Bauva
@ 2016-07-13 7:47 ` Christian Couder
2016-07-20 16:00 ` Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 01/12] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
11 siblings, 0 replies; 320+ messages in thread
From: Christian Couder @ 2016-07-13 7:47 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Junio C Hamano, Lars Schneider, Christian Couder, git
Hi Pranit,
On Wed, Jul 13, 2016 at 12:35 AM, Pranit Bauva <pranit.bauva@gmail.com> wrote:
> Hey Junio,
>
> A small mistake got unnoticed by me which Lars recently pointed out.
> The naming convention is "git_path_<name_of_file>" and underscore
> instead of spaces.
It's a good thing to resend when you find mistakes, but please use a
version number for your patch series (like "PATCH v3" or something).
Thanks,
Christian.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH 0/9] Resend of gitster/pb/bisect
2016-07-12 22:35 [PATCH 0/9] Resend of gitster/pb/bisect Pranit Bauva
` (9 preceding siblings ...)
2016-07-13 7:47 ` [PATCH 0/9] Resend of gitster/pb/bisect Christian Couder
@ 2016-07-20 16:00 ` Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 01/12] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-20 16:00 UTC (permalink / raw)
To: Junio C Hamano
Cc: Pranit Bauva, Lars Schneider, Christian Couder, Christian Couder,
Git List
On Wed, Jul 13, 2016 at 4:05 AM, Pranit Bauva <pranit.bauva@gmail.com> wrote:
> Hey Junio,
>
> A small mistake got unnoticed by me which Lars recently pointed out.
> The naming convention is "git_path_<name_of_file>" and underscore
> instead of spaces.
>
> Thanks!
>
> The interdiff is:
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index c2f3cee..88a1df8 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -7,7 +7,7 @@
> #include "argv-array.h"
> #include "run-command.h"
>
> -static GIT_PATH_FUNC(git_path_bisect_write_terms, "BISECT_TERMS")
> +static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
> static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
> static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
> static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
> @@ -100,7 +100,7 @@ static int write_terms(const char *bad, const char *good)
> if (check_term_format(bad, "bad") || check_term_format(good, "good"))
> return -1;
>
> - fp = fopen(git_path_bisect_write_terms(), "w");
> + fp = fopen(git_path_bisect_terms(), "w");
> if (!fp)
> return error_errno(_("could not open the file BISECT_TERMS"));
>
> @@ -134,7 +134,7 @@ static int bisect_clean_state(void)
> remove_path(git_path_bisect_log());
> remove_path(git_path_bisect_names());
> remove_path(git_path_bisect_run());
> - remove_path(git_path_bisect_write_terms());
> + remove_path(git_path_bisect_terms());
> /* Cleanup head-name if it got left by an old version of git-bisect */
> remove_path(git_path_head_name());
> /*
>
>
> Pranit Bauva (9):
> bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
> bisect: rewrite `check_term_format` shell function in C
> bisect--helper: `write_terms` shell function in C
> bisect--helper: `bisect_clean_state` shell function in C
> t6030: explicitly test for bisection cleanup
> wrapper: move is_empty_file() and rename it as
> is_empty_or_missing_file()
> bisect--helper: `bisect_reset` shell function in C
> bisect--helper: `is_expected_rev` & `check_expected_revs` shell
> function in C
> bisect--helper: `bisect_write` shell function in C
>
> builtin/am.c | 20 +--
> builtin/bisect--helper.c | 310 +++++++++++++++++++++++++++++++++++++++++++-
> cache.h | 3 +
> git-bisect.sh | 146 +++------------------
> t/t6030-bisect-porcelain.sh | 17 +++
> wrapper.c | 13 ++
> 6 files changed, 355 insertions(+), 154 deletions(-)
Could someone please look into this series and review so that Junio
can merge this into next which is a vital part of my GSoC project?
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* [PATCH v10 06/12] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file()
2016-07-20 21:47 ` [PATCH v10 01/12] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 11/12] bisect--helper: `bisect_next_check` shell function in C Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 12/12] bisect--helper: `get_terms` & `bisect_terms` " Pranit Bauva
@ 2016-07-20 21:47 ` Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 10/12] bisect--helper: `check_and_set_terms` shell function in C Pranit Bauva
` (8 subsequent siblings)
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-20 21:47 UTC (permalink / raw)
To: git
is_empty_file() can help to refactor a lot of code. This will be very
helpful in porting "git bisect" to C.
Suggested-by: Torsten Bögershausen <tboegi@web.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/am.c | 20 ++------------------
cache.h | 3 +++
wrapper.c | 13 +++++++++++++
3 files changed, 18 insertions(+), 18 deletions(-)
diff --git a/builtin/am.c b/builtin/am.c
index 3dfe70b..6ee158f 100644
--- a/builtin/am.c
+++ b/builtin/am.c
@@ -30,22 +30,6 @@
#include "mailinfo.h"
/**
- * Returns 1 if the file is empty or does not exist, 0 otherwise.
- */
-static int is_empty_file(const char *filename)
-{
- struct stat st;
-
- if (stat(filename, &st) < 0) {
- if (errno == ENOENT)
- return 1;
- die_errno(_("could not stat %s"), filename);
- }
-
- return !st.st_size;
-}
-
-/**
* Returns the length of the first line of msg.
*/
static int linelen(const char *msg)
@@ -1323,7 +1307,7 @@ static int parse_mail(struct am_state *state, const char *mail)
goto finish;
}
- if (is_empty_file(am_path(state, "patch"))) {
+ if (is_empty_or_missing_file(am_path(state, "patch"))) {
printf_ln(_("Patch is empty. Was it split wrong?"));
die_user_resolve(state);
}
@@ -1911,7 +1895,7 @@ static void am_run(struct am_state *state, int resume)
resume = 0;
}
- if (!is_empty_file(am_path(state, "rewritten"))) {
+ if (!is_empty_or_missing_file(am_path(state, "rewritten"))) {
assert(state->rebasing);
copy_notes_for_rebase(state);
run_post_rewrite_hook(state);
diff --git a/cache.h b/cache.h
index 6049f86..91e2f81 100644
--- a/cache.h
+++ b/cache.h
@@ -1870,4 +1870,7 @@ void sleep_millisec(int millisec);
*/
void safe_create_dir(const char *dir, int share);
+/* Return 1 if the file is empty or does not exists, 0 otherwise. */
+extern int is_empty_or_missing_file(const char *filename);
+
#endif /* CACHE_H */
diff --git a/wrapper.c b/wrapper.c
index 5dc4e15..e70e4d1 100644
--- a/wrapper.c
+++ b/wrapper.c
@@ -696,3 +696,16 @@ void sleep_millisec(int millisec)
{
poll(NULL, 0, millisec);
}
+
+int is_empty_or_missing_file(const char *filename)
+{
+ struct stat st;
+
+ if (stat(filename, &st) < 0) {
+ if (errno == ENOENT)
+ return 1;
+ die_errno(_("could not stat %s"), filename);
+ }
+
+ return !st.st_size;
+}
--
https://github.com/git/git/pull/273
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v10 01/12] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2016-07-12 22:35 [PATCH 0/9] Resend of gitster/pb/bisect Pranit Bauva
` (10 preceding siblings ...)
2016-07-20 16:00 ` Pranit Bauva
@ 2016-07-20 21:47 ` Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 11/12] bisect--helper: `bisect_next_check` shell function in C Pranit Bauva
` (11 more replies)
11 siblings, 12 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-20 21:47 UTC (permalink / raw)
To: git
`--next-all` is meant to be used as a subcommand to support multiple
"operation mode" though the current implementation does not contain any
other subcommand along side with `--next-all` but further commits will
include some more subcommands.
Helped-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 17 +++++++++++------
1 file changed, 11 insertions(+), 6 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 3324229..8111c91 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -10,11 +10,11 @@ static const char * const git_bisect_helper_usage[] = {
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
- int next_all = 0;
+ enum { NEXT_ALL = 1 } cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
- OPT_BOOL(0, "next-all", &next_all,
- N_("perform 'git bisect next'")),
+ OPT_CMDMODE(0, "next-all", &cmdmode,
+ N_("perform 'git bisect next'"), NEXT_ALL),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -23,9 +23,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
argc = parse_options(argc, argv, prefix, options,
git_bisect_helper_usage, 0);
- if (!next_all)
+ if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
- /* next-all */
- return bisect_next_all(prefix, no_checkout);
+ switch (cmdmode) {
+ case NEXT_ALL:
+ return bisect_next_all(prefix, no_checkout);
+ default:
+ die("BUG: unknown subcommand '%d'", cmdmode);
+ }
+ return 0;
}
--
https://github.com/git/git/pull/273
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v10 12/12] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-07-20 21:47 ` [PATCH v10 01/12] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 11/12] bisect--helper: `bisect_next_check` shell function in C Pranit Bauva
@ 2016-07-20 21:47 ` Pranit Bauva
2016-07-22 2:29 ` Torsten Bögershausen
2016-07-20 21:47 ` [PATCH v10 06/12] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
` (9 subsequent siblings)
11 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-07-20 21:47 UTC (permalink / raw)
To: git
Reimplement the `get_terms` and `bisect_terms` shell function in C and
add `bisect-terms` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
In the shell version, the terms were identified by strings but in C
version its done by bit manipulation and passing the integer value to
the function.
Using `--bisect-terms` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other methods.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 74 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 35 ++---------------------
2 files changed, 75 insertions(+), 34 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 001096a..185a8ad 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -8,6 +8,13 @@
#include "run-command.h"
#include "prompt.h"
+enum terms_defined {
+ TERM_BAD = 1,
+ TERM_GOOD = 2,
+ TERM_NEW = 4,
+ TERM_OLD = 8
+};
+
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
@@ -26,6 +33,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
+ N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
NULL
};
@@ -359,6 +367,43 @@ static int bisect_next_check(const struct bisect_terms *terms,
return 0;
}
+static int get_terms(struct bisect_terms *terms)
+{
+ FILE *fp;
+ int res;
+ fp = fopen(git_path_bisect_terms(), "r");
+ if (!fp)
+ return -1;
+
+ bisect_terms_reset(terms);
+ res = strbuf_getline(&terms->term_bad, fp) == EOF ||
+ strbuf_getline(&terms->term_good, fp) == EOF;
+
+ fclose(fp);
+ return res ? -1 : 0;
+}
+
+static int bisect_terms(struct bisect_terms *terms, int term_defined)
+{
+ if (get_terms(terms)) {
+ fprintf(stderr, "no terms defined\n");
+ return -1;
+ }
+ if (!term_defined) {
+ printf("Your current terms are %s for the old state\nand "
+ "%s for the new state.\n", terms->term_good.buf,
+ terms->term_bad.buf);
+ return 0;
+ }
+
+ if (term_defined == TERM_GOOD || term_defined == TERM_OLD)
+ printf("%s\n", terms->term_good.buf);
+ if (term_defined == TERM_BAD || term_defined == TERM_NEW)
+ printf("%s\n", terms->term_bad.buf);
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -369,9 +414,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
CHECK_EXPECTED_REVS,
BISECT_WRITE,
CHECK_AND_SET_TERMS,
- BISECT_NEXT_CHECK
+ BISECT_NEXT_CHECK,
+ BISECT_TERMS
} cmdmode = 0;
int no_checkout = 0, res = 0;
+ enum terms_defined term_defined = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
@@ -389,6 +436,16 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
+ OPT_CMDMODE(0, "bisect-terms", &cmdmode,
+ N_("print out the bisect terms"), BISECT_TERMS),
+ OPT_BIT(0, "term-bad", &term_defined,
+ N_("show the bad term"), TERM_BAD),
+ OPT_BIT(0, "term-good", &term_defined,
+ N_("show the good term"), TERM_GOOD),
+ OPT_BIT(0, "term-new", &term_defined,
+ N_("show the new term"), TERM_NEW),
+ OPT_BIT(0, "term-old", &term_defined,
+ N_("show the old term"), TERM_OLD),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -399,6 +456,16 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
argc = parse_options(argc, argv, prefix, options,
git_bisect_helper_usage, 0);
+ if (cmdmode != BISECT_TERMS && term_defined)
+ die(_("--term-bad, --term-good, --term-new and --term-old "
+ "can be used only with --bisect-terms"));
+
+ if (term_defined != 0 && term_defined != TERM_BAD &&
+ term_defined != TERM_GOOD && term_defined != TERM_NEW &&
+ term_defined != TERM_OLD)
+ die(_("only one option among --term-bad, --term-good, "
+ "--term-new and --term-old can be used."));
+
if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
@@ -446,6 +513,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
strbuf_addstr(&terms.term_bad, argv[1]);
res = bisect_next_check(&terms, argc == 3 ? argv[2] : NULL);
break;
+ case BISECT_TERMS:
+ if (argc > 1)
+ die(_("--bisect-terms requires 0 or 1 argument"));
+ res = bisect_terms(&terms, term_defined);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index c2d6319..aea97c5f 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -355,7 +355,7 @@ bisect_replay () {
"$TERM_GOOD"|"$TERM_BAD"|skip)
git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
terms)
- bisect_terms $rev ;;
+ git bisect--helper --bisect-terms $rev || exit;;
*)
die "$(gettext "?? what are you talking about?")" ;;
esac
@@ -437,37 +437,6 @@ get_terms () {
fi
}
-bisect_terms () {
- get_terms
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- die "$(gettext "no terms defined")"
- fi
- case "$#" in
- 0)
- gettextln "Your current terms are $TERM_GOOD for the old state
-and $TERM_BAD for the new state."
- ;;
- 1)
- arg=$1
- case "$arg" in
- --term-good|--term-old)
- printf '%s\n' "$TERM_GOOD"
- ;;
- --term-bad|--term-new)
- printf '%s\n' "$TERM_BAD"
- ;;
- *)
- die "$(eval_gettext "invalid argument \$arg for 'git bisect terms'.
-Supported options are: --term-good|--term-old and --term-bad|--term-new.")"
- ;;
- esac
- ;;
- *)
- usage ;;
- esac
-}
-
case "$#" in
0)
usage ;;
@@ -498,7 +467,7 @@ case "$#" in
run)
bisect_run "$@" ;;
terms)
- bisect_terms "$@" ;;
+ git bisect--helper --bisect-terms "$@" || exit;;
*)
usage ;;
esac
--
https://github.com/git/git/pull/273
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v10 10/12] bisect--helper: `check_and_set_terms` shell function in C
2016-07-20 21:47 ` [PATCH v10 01/12] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
` (2 preceding siblings ...)
2016-07-20 21:47 ` [PATCH v10 06/12] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
@ 2016-07-20 21:47 ` Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 02/12] bisect: rewrite `check_term_format` " Pranit Bauva
` (7 subsequent siblings)
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-20 21:47 UTC (permalink / raw)
To: git
Reimplement the `check_and_set_terms` shell function in C and add
`check-and-set-terms` subcommand to `git bisect--helper` to call it from
git-bisect.sh
Using `--check-and-set-terms` subcommand is a temporary measure to port
shell function in C so as to use the existing test suite. As more
functions are ported, this subcommand will be retired and will be called
by some other methods.
check_and_set_terms() sets and receives two global variables namely
TERM_GOOD and TERM_BAD in the shell script. Luckily the file BISECT_TERMS
also contains the value of those variables so its appropriate to evoke the
method get_terms() after calling the subcommand so that it retrieves the
value of TERM_GOOD and TERM_BAD from the file BISECT_TERMS. The two
global variables are passed as arguments to the subcommand.
Also introduce bisect_terms_reset() to empty the contents of `term_good`
and `term_bad` of `struct bisect_terms`.
Also introduce set_terms() to copy the `term_good` and `term_bad` into
`struct bisect_terms` and write it out to the file BISECT_TERMS.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 52 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 36 ++++-----------------------------
2 files changed, 55 insertions(+), 33 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index d1d12f2..b9119e3 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -23,6 +23,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-clean-state"),
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
+ N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
NULL
};
@@ -43,6 +44,12 @@ static void bisect_terms_release(struct bisect_terms *terms)
strbuf_release(&terms->term_bad);
}
+static void bisect_terms_reset(struct bisect_terms *term)
+{
+ strbuf_reset(&term->term_good);
+ strbuf_reset(&term->term_bad);
+}
+
/*
* Check whether the string `term` belongs to the set of strings
* included in the variable arguments.
@@ -252,6 +259,39 @@ static int bisect_write(const char *state, const char *rev,
return 0;
}
+static int set_terms(struct bisect_terms *terms, const char *bad,
+ const char *good)
+{
+ bisect_terms_reset(terms);
+ strbuf_addstr(&terms->term_good, good);
+ strbuf_addstr(&terms->term_bad, bad);
+ return write_terms(terms->term_bad.buf, terms->term_good.buf);
+}
+
+static int check_and_set_terms(struct bisect_terms *terms, const char *cmd)
+{
+ int no_term_file = is_empty_or_missing_file(git_path_bisect_terms());
+
+ if (one_of(cmd, "skip", "start", "terms", NULL))
+ return 0;
+
+ if (!no_term_file &&
+ strcmp(cmd, terms->term_bad.buf) &&
+ strcmp(cmd, terms->term_good.buf))
+ return error(_("Invalid command: you're currently in a "
+ "'%s' '%s' bisect"), terms->term_bad.buf,
+ terms->term_good.buf);
+
+ if (no_term_file) {
+ if (one_of(cmd, "bad", "good", NULL))
+ return set_terms(terms, "bad", "good");
+ if (one_of(cmd, "new", "old", NULL))
+ return set_terms(terms, "new", "old");
+ }
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -260,7 +300,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_CLEAN_STATE,
BISECT_RESET,
CHECK_EXPECTED_REVS,
- BISECT_WRITE
+ BISECT_WRITE,
+ CHECK_AND_SET_TERMS
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -276,6 +317,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check for expected revs"), CHECK_EXPECTED_REVS),
OPT_CMDMODE(0, "bisect-write", &cmdmode,
N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
+ OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
+ N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -319,6 +362,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
strbuf_addstr(&terms.term_bad, argv[3]);
res = bisect_write(argv[0], argv[1], &terms, nolog);
break;
+ case CHECK_AND_SET_TERMS:
+ if (argc != 3)
+ die(_("--check-and-set-terms requires 3 arguments"));
+ strbuf_addstr(&terms.term_good, argv[1]);
+ strbuf_addstr(&terms.term_bad, argv[2]);
+ res = check_and_set_terms(&terms, argv[0]);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index b9896a4..a41e69b 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -239,7 +239,8 @@ bisect_skip() {
bisect_state() {
bisect_autostart
state=$1
- check_and_set_terms $state
+ git bisect--helper --check-and-set-terms $state $TERM_GOOD $TERM_BAD || exit
+ get_terms
case "$#,$state" in
0,*)
die "$(gettext "Please call 'bisect_state' with at least one argument.")" ;;
@@ -390,7 +391,8 @@ bisect_replay () {
command="$bisect"
fi
get_terms
- check_and_set_terms "$command"
+ git bisect--helper --check-and-set-terms "$command" "$TERM_GOOD" "$TERM_BAD" || exit
+ get_terms
case "$command" in
start)
cmd="bisect_start $rev"
@@ -480,36 +482,6 @@ get_terms () {
fi
}
-check_and_set_terms () {
- cmd="$1"
- case "$cmd" in
- skip|start|terms) ;;
- *)
- if test -s "$GIT_DIR/BISECT_TERMS" && test "$cmd" != "$TERM_BAD" && test "$cmd" != "$TERM_GOOD"
- then
- die "$(eval_gettext "Invalid command: you're currently in a \$TERM_BAD/\$TERM_GOOD bisect.")"
- fi
- case "$cmd" in
- bad|good)
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- TERM_BAD=bad
- TERM_GOOD=good
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
- fi
- ;;
- new|old)
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- TERM_BAD=new
- TERM_GOOD=old
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
- fi
- ;;
- esac ;;
- esac
-}
-
bisect_voc () {
case "$1" in
bad) echo "bad|new" ;;
--
https://github.com/git/git/pull/273
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v10 11/12] bisect--helper: `bisect_next_check` shell function in C
2016-07-20 21:47 ` [PATCH v10 01/12] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
@ 2016-07-20 21:47 ` Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 12/12] bisect--helper: `get_terms` & `bisect_terms` " Pranit Bauva
` (10 subsequent siblings)
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-20 21:47 UTC (permalink / raw)
To: git
Reimplement `bisect_next_check` shell function in C and add
`bisect-next-check` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Using `--bisect-next-check` is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other methods.
bisect_voc() is removed as it is redundant and does not serve any useful
purpose. We are better off specifying "bad|new" "good|old" as and when
we require in bisect_next_check().
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 79 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 60 +++---------------------------------
2 files changed, 82 insertions(+), 57 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index b9119e3..001096a 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -6,6 +6,7 @@
#include "dir.h"
#include "argv-array.h"
#include "run-command.h"
+#include "prompt.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
@@ -24,6 +25,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
+ N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
NULL
};
@@ -292,6 +294,71 @@ static int check_and_set_terms(struct bisect_terms *terms, const char *cmd)
return 0;
}
+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 0;
+}
+
+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.buf);
+ char *good_glob = xstrfmt("%s*", terms->term_good.buf);
+
+ if (ref_exists(bad_ref))
+ missing_bad = 0;
+ free(bad_ref);
+
+ for_each_glob_ref_in(mark_good, good_glob, "refs/bisect/",
+ (void *) &missing_good);
+ free(good_glob);
+
+ if (!missing_good && !missing_bad)
+ return 0;
+
+ if (!current_term)
+ return -1;
+
+ if (missing_good && !missing_bad && current_term &&
+ !strcmp(current_term, terms->term_good.buf)) {
+ char *yesno;
+ /*
+ * have bad (or new) but not good (or old). We could bisect
+ * although this is less optimum.
+ */
+ fprintf(stderr, "Warning: bisecting only with a %s commit\n",
+ terms->term_bad.buf);
+ if (!isatty(0))
+ return 0;
+ /*
+ * 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"))
+ return -1;
+ return 0;
+ }
+ if (!is_empty_or_missing_file(git_path_bisect_start()))
+ return error(_("You need to give me at least one good|old and "
+ "bad|new revision. You can use \"git bisect "
+ "bad|new\" and \"git bisect good|old\" for "
+ "that. \n"));
+ else
+ return error(_("You need to start by \"git bisect start\". "
+ "You then need to give me at least one good|"
+ "old and bad|new revision. You can use \"git "
+ "bisect bad|new\" and \"git bisect good|old\" "
+ " for that.\n"));
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -301,7 +368,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_RESET,
CHECK_EXPECTED_REVS,
BISECT_WRITE,
- CHECK_AND_SET_TERMS
+ CHECK_AND_SET_TERMS,
+ BISECT_NEXT_CHECK
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -319,6 +387,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
+ OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
+ N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -369,6 +439,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
strbuf_addstr(&terms.term_bad, argv[2]);
res = check_and_set_terms(&terms, argv[0]);
break;
+ case BISECT_NEXT_CHECK:
+ if (argc != 2 && argc != 3)
+ die(_("--bisect-next-check requires 2 or 3 arguments"));
+ strbuf_addstr(&terms.term_good, argv[0]);
+ strbuf_addstr(&terms.term_bad, argv[1]);
+ res = bisect_next_check(&terms, argc == 3 ? argv[2] : NULL);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index a41e69b..c2d6319 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -271,59 +271,14 @@ bisect_state() {
bisect_auto_next
}
-bisect_next_check() {
- missing_good= missing_bad=
- git show-ref -q --verify refs/bisect/$TERM_BAD || missing_bad=t
- test -n "$(git for-each-ref "refs/bisect/$TERM_GOOD-*")" || missing_good=t
-
- case "$missing_good,$missing_bad,$1" in
- ,,*)
- : have both $TERM_GOOD and $TERM_BAD - ok
- ;;
- *,)
- # do not have both but not asked to fail - just report.
- false
- ;;
- t,,"$TERM_GOOD")
- # have bad (or new) but not good (or old). we could bisect although
- # this is less optimum.
- eval_gettextln "Warning: bisecting only with a \$TERM_BAD commit." >&2
- if test -t 0
- then
- # TRANSLATORS: Make sure to include [Y] and [n] in your
- # translation. The program will only accept English input
- # at this point.
- gettext "Are you sure [Y/n]? " >&2
- read yesno
- case "$yesno" in [Nn]*) exit 1 ;; esac
- fi
- : bisect without $TERM_GOOD...
- ;;
- *)
- bad_syn=$(bisect_voc bad)
- good_syn=$(bisect_voc good)
- if test -s "$GIT_DIR/BISECT_START"
- then
-
- eval_gettextln "You need to give me at least one \$bad_syn and one \$good_syn revision.
-(You can use \"git bisect \$bad_syn\" and \"git bisect \$good_syn\" for that.)" >&2
- else
- eval_gettextln "You need to start by \"git bisect start\".
-You then need to give me at least one \$good_syn and one \$bad_syn revision.
-(You can use \"git bisect \$bad_syn\" and \"git bisect \$good_syn\" for that.)" >&2
- fi
- exit 1 ;;
- esac
-}
-
bisect_auto_next() {
- bisect_next_check && bisect_next || :
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD && bisect_next || :
}
bisect_next() {
case "$#" in 0) ;; *) usage ;; esac
bisect_autostart
- bisect_next_check $TERM_GOOD
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD $TERM_GOOD|| exit
# Perform all bisection computation, display and checkout
git bisect--helper --next-all $(test -f "$GIT_DIR/BISECT_HEAD" && echo --no-checkout)
@@ -355,7 +310,7 @@ bisect_next() {
}
bisect_visualize() {
- bisect_next_check fail
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD fail || exit
if test $# = 0
then
@@ -409,7 +364,7 @@ bisect_replay () {
}
bisect_run () {
- bisect_next_check fail
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD fail || exit
while true
do
@@ -482,13 +437,6 @@ get_terms () {
fi
}
-bisect_voc () {
- case "$1" in
- bad) echo "bad|new" ;;
- good) echo "good|old" ;;
- esac
-}
-
bisect_terms () {
get_terms
if ! test -s "$GIT_DIR/BISECT_TERMS"
--
https://github.com/git/git/pull/273
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v10 04/12] bisect--helper: `bisect_clean_state` shell function in C
2016-07-20 21:47 ` [PATCH v10 01/12] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
` (9 preceding siblings ...)
2016-07-20 21:47 ` [PATCH v10 03/12] bisect--helper: `write_terms` " Pranit Bauva
@ 2016-07-20 21:47 ` Pranit Bauva
2016-07-31 9:21 ` [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-20 21:47 UTC (permalink / raw)
To: git
Reimplement `bisect_clean_state` shell function in C and add a
`bisect-clean-state` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Using `--bisect-clean-state` subcommand is a measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by
bisect_reset() and bisect_start().
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 55 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 26 +++--------------------
2 files changed, 57 insertions(+), 24 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index ef87c82..ad67a97 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -3,12 +3,21 @@
#include "parse-options.h"
#include "bisect.h"
#include "refs.h"
+#include "dir.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
+static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
+static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
+static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
+static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
+static GIT_PATH_FUNC(git_path_bisect_run, "BISECT_RUN")
+static GIT_PATH_FUNC(git_path_head_name, "head-name")
+static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
+ N_("git bisect--helper --bisect-clean-state"),
NULL
};
@@ -78,11 +87,49 @@ static int write_terms(const char *bad, const char *good)
return (res < 0) ? -1 : 0;
}
+static int mark_for_removal(const char *refname, const struct object_id *oid,
+ int flag, void *cb_data)
+{
+ struct string_list *refs = cb_data;
+ char *ref = xstrfmt("refs/bisect/%s", refname);
+ string_list_append(refs, ref);
+ return 0;
+}
+
+static int bisect_clean_state(void)
+{
+ int result = 0;
+
+ /* There may be some refs packed during bisection */
+ struct string_list refs_for_removal = STRING_LIST_INIT_NODUP;
+ for_each_ref_in("refs/bisect/", mark_for_removal, (void *) &refs_for_removal);
+ string_list_append(&refs_for_removal, xstrdup("BISECT_HEAD"));
+ result = delete_refs(&refs_for_removal);
+ refs_for_removal.strdup_strings = 1;
+ string_list_clear(&refs_for_removal, 0);
+ remove_path(git_path_bisect_expected_rev());
+ remove_path(git_path_bisect_ancestors_ok());
+ remove_path(git_path_bisect_log());
+ remove_path(git_path_bisect_names());
+ remove_path(git_path_bisect_run());
+ remove_path(git_path_bisect_terms());
+ /* Cleanup head-name if it got left by an old version of git-bisect */
+ remove_path(git_path_head_name());
+ /*
+ * Cleanup BISECT_START last to support the --no-checkout option
+ * introduced in the commit 4796e823a.
+ */
+ remove_path(git_path_bisect_start());
+
+ return result;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
- WRITE_TERMS
+ WRITE_TERMS,
+ BISECT_CLEAN_STATE
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -90,6 +137,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("perform 'git bisect next'"), NEXT_ALL),
OPT_CMDMODE(0, "write-terms", &cmdmode,
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
+ OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
+ N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -108,6 +157,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc != 2)
die(_("--write-terms requires two arguments"));
return write_terms(argv[0], argv[1]);
+ case BISECT_CLEAN_STATE:
+ if (argc != 0)
+ die(_("--bisect-clean-state requires no arguments"));
+ return bisect_clean_state();
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index cd39bd0..bbc57d2 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -187,7 +187,7 @@ bisect_start() {
#
# Get rid of any old bisect state.
#
- bisect_clean_state || exit
+ git bisect--helper --bisect-clean-state || exit
#
# Change state.
@@ -196,7 +196,7 @@ bisect_start() {
# We have to trap this to be able to clean up using
# "bisect_clean_state".
#
- trap 'bisect_clean_state' 0
+ trap 'git bisect--helper --bisect-clean-state' 0
trap 'exit 255' 1 2 3 15
#
@@ -430,27 +430,7 @@ bisect_reset() {
die "$(eval_gettext "Could not check out original HEAD '\$branch'.
Try 'git bisect reset <commit>'.")"
fi
- bisect_clean_state
-}
-
-bisect_clean_state() {
- # There may be some refs packed during bisection.
- git for-each-ref --format='%(refname) %(objectname)' refs/bisect/\* |
- while read ref hash
- do
- git update-ref -d $ref $hash || exit
- done
- rm -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
- rm -f "$GIT_DIR/BISECT_ANCESTORS_OK" &&
- rm -f "$GIT_DIR/BISECT_LOG" &&
- rm -f "$GIT_DIR/BISECT_NAMES" &&
- rm -f "$GIT_DIR/BISECT_RUN" &&
- rm -f "$GIT_DIR/BISECT_TERMS" &&
- # Cleanup head-name if it got left by an old version of git-bisect
- rm -f "$GIT_DIR/head-name" &&
- git update-ref -d --no-deref BISECT_HEAD &&
- # clean up BISECT_START last
- rm -f "$GIT_DIR/BISECT_START"
+ git bisect--helper --bisect-clean-state || exit
}
bisect_replay () {
--
https://github.com/git/git/pull/273
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v10 05/12] t6030: explicitly test for bisection cleanup
2016-07-20 21:47 ` [PATCH v10 01/12] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
` (4 preceding siblings ...)
2016-07-20 21:47 ` [PATCH v10 02/12] bisect: rewrite `check_term_format` " Pranit Bauva
@ 2016-07-20 21:47 ` Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 07/12] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
` (5 subsequent siblings)
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-20 21:47 UTC (permalink / raw)
To: git
Add test to explicitly check that 'git bisect reset' is working as
expected. This is already covered implicitly by the test suite.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
I faced this problem while converting `bisect_clean_state` and the tests
where showing breakages but it wasn't clear as to where exactly are they
breaking. This will patch will help in that. Also I tested the test
coverage of the test suite before this patch and it covers this (I did
this by purposely changing names of files in git-bisect.sh and running
the test suite).
---
t/t6030-bisect-porcelain.sh | 17 +++++++++++++++++
1 file changed, 17 insertions(+)
diff --git a/t/t6030-bisect-porcelain.sh b/t/t6030-bisect-porcelain.sh
index e74662b..a17f7a6 100755
--- a/t/t6030-bisect-porcelain.sh
+++ b/t/t6030-bisect-porcelain.sh
@@ -894,4 +894,21 @@ test_expect_success 'bisect start takes options and revs in any order' '
test_cmp expected actual
'
+test_expect_success 'git bisect reset cleans bisection state properly' '
+ git bisect reset &&
+ git bisect start &&
+ git bisect good $HASH1 &&
+ git bisect bad $HASH4 &&
+ git bisect reset &&
+ test -z "$(git for-each-ref "refs/bisect/*")" &&
+ test_path_is_missing "$GIT_DIR/BISECT_EXPECTED_REV" &&
+ test_path_is_missing "$GIT_DIR/BISECT_ANCESTORS_OK" &&
+ test_path_is_missing "$GIT_DIR/BISECT_LOG" &&
+ test_path_is_missing "$GIT_DIR/BISECT_RUN" &&
+ test_path_is_missing "$GIT_DIR/BISECT_TERMS" &&
+ test_path_is_missing "$GIT_DIR/head-name" &&
+ test_path_is_missing "$GIT_DIR/BISECT_HEAD" &&
+ test_path_is_missing "$GIT_DIR/BISECT_START"
+'
+
test_done
--
https://github.com/git/git/pull/273
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v10 02/12] bisect: rewrite `check_term_format` shell function in C
2016-07-20 21:47 ` [PATCH v10 01/12] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
` (3 preceding siblings ...)
2016-07-20 21:47 ` [PATCH v10 10/12] bisect--helper: `check_and_set_terms` shell function in C Pranit Bauva
@ 2016-07-20 21:47 ` Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 05/12] t6030: explicitly test for bisection cleanup Pranit Bauva
` (6 subsequent siblings)
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-20 21:47 UTC (permalink / raw)
To: git
Reimplement the `check_term_format` shell function in C and add
a `--check-term-format` subcommand to `git bisect--helper` to call it
from git-bisect.sh
Using `--check-term-format` subcommand is a temporary measure to port
shell function to C so as to use the existing test suite. As more
functions are ported, this subcommand will be retired and will
be called by some other method/subcommand. For eg. In conversion of
write_terms() of git-bisect.sh, the subcommand will be removed and
instead check_term_format() will be called in its C implementation while
a new subcommand will be introduced for write_terms().
Helped-by: Johannes Schindelein <Johannes.Schindelein@gmx.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 59 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 31 ++-----------------------
2 files changed, 60 insertions(+), 30 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 8111c91..48285d4 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -2,19 +2,72 @@
#include "cache.h"
#include "parse-options.h"
#include "bisect.h"
+#include "refs.h"
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
+ N_("git bisect--helper --check-term-format <term> <orig_term>"),
NULL
};
+/*
+ * Check whether the string `term` belongs to the set of strings
+ * included in the variable arguments.
+ */
+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",
+ "visualize", "replay", "log", "run", NULL))
+ 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;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
- enum { NEXT_ALL = 1 } cmdmode = 0;
+ enum {
+ NEXT_ALL = 1,
+ CHECK_TERM_FMT
+ } cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
+ OPT_CMDMODE(0, "check-term-format", &cmdmode,
+ N_("check format of the term"), CHECK_TERM_FMT),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -29,6 +82,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
switch (cmdmode) {
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
+ case CHECK_TERM_FMT:
+ if (argc != 2)
+ die(_("--check-term-format requires two arguments"));
+ return check_term_format(argv[0], argv[1]);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 5d1cb00..7d7965d 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -564,38 +564,11 @@ write_terms () {
then
die "$(gettext "please use two different terms")"
fi
- check_term_format "$TERM_BAD" bad
- check_term_format "$TERM_GOOD" good
+ git bisect--helper --check-term-format "$TERM_BAD" bad || exit
+ git bisect--helper --check-term-format "$TERM_GOOD" good || exit
printf '%s\n%s\n' "$TERM_BAD" "$TERM_GOOD" >"$GIT_DIR/BISECT_TERMS"
}
-check_term_format () {
- term=$1
- git check-ref-format refs/bisect/"$term" ||
- die "$(eval_gettext "'\$term' is not a valid term")"
- case "$term" in
- help|start|terms|skip|next|reset|visualize|replay|log|run)
- die "$(eval_gettext "can't use the builtin command '\$term' as a term")"
- ;;
- bad|new)
- if test "$2" != bad
- then
- # 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.
- die "$(eval_gettext "can't change the meaning of term '\$term'")"
- fi
- ;;
- good|old)
- if test "$2" != good
- then
- die "$(eval_gettext "can't change the meaning of term '\$term'")"
- fi
- ;;
- esac
-}
-
check_and_set_terms () {
cmd="$1"
case "$cmd" in
--
https://github.com/git/git/pull/273
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v10 03/12] bisect--helper: `write_terms` shell function in C
2016-07-20 21:47 ` [PATCH v10 01/12] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
` (8 preceding siblings ...)
2016-07-20 21:47 ` [PATCH v10 09/12] bisect--helper: `bisect_write` " Pranit Bauva
@ 2016-07-20 21:47 ` Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 04/12] bisect--helper: `bisect_clean_state` " Pranit Bauva
2016-07-31 9:21 ` [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-20 21:47 UTC (permalink / raw)
To: git
Reimplement the `write_terms` shell function in C and add a `write-terms`
subcommand to `git bisect--helper` to call it from git-bisect.sh . Also
remove the subcommand `--check-term-format` as it can now be called from
inside the function write_terms() C implementation.
Also `|| exit` is added when calling write-terms subcommand from
git-bisect.sh so as to exit whenever there is an error.
Using `--write-terms` subcommand is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other method.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 36 +++++++++++++++++++++++++++++-------
git-bisect.sh | 22 +++++++---------------
2 files changed, 36 insertions(+), 22 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 48285d4..ef87c82 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -4,9 +4,11 @@
#include "bisect.h"
#include "refs.h"
+static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
+
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
- N_("git bisect--helper --check-term-format <term> <orig_term>"),
+ N_("git bisect--helper --write-terms <bad_term> <good_term>"),
NULL
};
@@ -56,18 +58,38 @@ static int check_term_format(const char *term, const char *orig_term)
return 0;
}
+static int write_terms(const char *bad, const char *good)
+{
+ FILE *fp;
+ 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);
+ fclose(fp);
+ return (res < 0) ? -1 : 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
- CHECK_TERM_FMT
+ WRITE_TERMS
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
- OPT_CMDMODE(0, "check-term-format", &cmdmode,
- N_("check format of the term"), CHECK_TERM_FMT),
+ OPT_CMDMODE(0, "write-terms", &cmdmode,
+ N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -82,10 +104,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
switch (cmdmode) {
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
- case CHECK_TERM_FMT:
+ case WRITE_TERMS:
if (argc != 2)
- die(_("--check-term-format requires two arguments"));
- return check_term_format(argv[0], argv[1]);
+ die(_("--write-terms requires two arguments"));
+ return write_terms(argv[0], argv[1]);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 7d7965d..cd39bd0 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -210,7 +210,7 @@ bisect_start() {
eval "$eval true" &&
if test $must_write_terms -eq 1
then
- write_terms "$TERM_BAD" "$TERM_GOOD"
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD"
fi &&
echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
#
@@ -557,18 +557,6 @@ get_terms () {
fi
}
-write_terms () {
- TERM_BAD=$1
- TERM_GOOD=$2
- if test "$TERM_BAD" = "$TERM_GOOD"
- then
- die "$(gettext "please use two different terms")"
- fi
- git bisect--helper --check-term-format "$TERM_BAD" bad || exit
- git bisect--helper --check-term-format "$TERM_GOOD" good || exit
- printf '%s\n%s\n' "$TERM_BAD" "$TERM_GOOD" >"$GIT_DIR/BISECT_TERMS"
-}
-
check_and_set_terms () {
cmd="$1"
case "$cmd" in
@@ -582,13 +570,17 @@ check_and_set_terms () {
bad|good)
if ! test -s "$GIT_DIR/BISECT_TERMS"
then
- write_terms bad good
+ TERM_BAD=bad
+ TERM_GOOD=good
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
fi
;;
new|old)
if ! test -s "$GIT_DIR/BISECT_TERMS"
then
- write_terms new old
+ TERM_BAD=new
+ TERM_GOOD=old
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
fi
;;
esac ;;
--
https://github.com/git/git/pull/273
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v10 07/12] bisect--helper: `bisect_reset` shell function in C
2016-07-20 21:47 ` [PATCH v10 01/12] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
` (5 preceding siblings ...)
2016-07-20 21:47 ` [PATCH v10 05/12] t6030: explicitly test for bisection cleanup Pranit Bauva
@ 2016-07-20 21:47 ` Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 08/12] bisect--helper: `is_expected_rev` & `check_expected_revs` " Pranit Bauva
` (4 subsequent siblings)
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-20 21:47 UTC (permalink / raw)
To: git
Reimplement `bisect_reset` shell function in C and add a `--bisect-reset`
subcommand to `git bisect--helper` to call it from git-bisect.sh .
Using `bisect_reset` subcommand is a temporary measure to port shell
functions to C so as to use the existing test suite. As more functions
are ported, this subcommand would be retired and will be called by some
other method.
Note: --bisect-clean-state subcommand has not been retired as there are
still a function namely `bisect_start()` which still uses this
subcommand.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 47 ++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 28 ++--------------------------
2 files changed, 48 insertions(+), 27 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index ad67a97..d125fd3 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -4,6 +4,8 @@
#include "bisect.h"
#include "refs.h"
#include "dir.h"
+#include "argv-array.h"
+#include "run-command.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
@@ -13,11 +15,13 @@ static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static GIT_PATH_FUNC(git_path_bisect_run, "BISECT_RUN")
static GIT_PATH_FUNC(git_path_head_name, "head-name")
static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
+static GIT_PATH_FUNC(git_path_bisect_head, "BISECT_HEAD")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-clean-state"),
+ N_("git bisect--helper --bisect-reset [<commit>]"),
NULL
};
@@ -124,12 +128,47 @@ static int bisect_clean_state(void)
return result;
}
+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, &oid))
+ return error(_("'%s' is not a valid commit"), commit);
+ strbuf_addstr(&branch, commit);
+ }
+
+ if (!file_exists(git_path_bisect_head())) {
+ struct argv_array argv = ARGV_ARRAY_INIT;
+ argv_array_pushl(&argv, "checkout", branch.buf, "--", NULL);
+ if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
+ error(_("Could not check out original HEAD '%s'. Try"
+ "'git bisect reset <commit>'."), branch.buf);
+ strbuf_release(&branch);
+ argv_array_clear(&argv);
+ return -1;
+ }
+ argv_array_clear(&argv);
+ }
+
+ strbuf_release(&branch);
+ return bisect_clean_state();
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
WRITE_TERMS,
- BISECT_CLEAN_STATE
+ BISECT_CLEAN_STATE,
+ BISECT_RESET
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -139,6 +178,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
+ OPT_CMDMODE(0, "bisect-reset", &cmdmode,
+ N_("reset the bisection state"), BISECT_RESET),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -161,6 +202,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc != 0)
die(_("--bisect-clean-state requires no arguments"));
return bisect_clean_state();
+ case BISECT_RESET:
+ if (argc > 1)
+ die(_("--bisect-reset requires either zero or one arguments"));
+ return bisect_reset(argc ? argv[0] : NULL);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index bbc57d2..18580b7 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -409,35 +409,11 @@ bisect_visualize() {
eval '"$@"' --bisect -- $(cat "$GIT_DIR/BISECT_NAMES")
}
-bisect_reset() {
- test -s "$GIT_DIR/BISECT_START" || {
- gettextln "We are not bisecting."
- return
- }
- case "$#" in
- 0) branch=$(cat "$GIT_DIR/BISECT_START") ;;
- 1) git rev-parse --quiet --verify "$1^{commit}" >/dev/null || {
- invalid="$1"
- die "$(eval_gettext "'\$invalid' is not a valid commit")"
- }
- branch="$1" ;;
- *)
- usage ;;
- esac
-
- if ! test -f "$GIT_DIR/BISECT_HEAD" && ! git checkout "$branch" --
- then
- die "$(eval_gettext "Could not check out original HEAD '\$branch'.
-Try 'git bisect reset <commit>'.")"
- fi
- git bisect--helper --bisect-clean-state || exit
-}
-
bisect_replay () {
file="$1"
test "$#" -eq 1 || die "$(gettext "No logfile given")"
test -r "$file" || die "$(eval_gettext "cannot read \$file for replaying")"
- bisect_reset
+ git bisect--helper --bisect-reset || exit
while read git bisect command rev
do
test "$git $bisect" = "git bisect" || test "$git" = "git-bisect" || continue
@@ -627,7 +603,7 @@ case "$#" in
visualize|view)
bisect_visualize "$@" ;;
reset)
- bisect_reset "$@" ;;
+ git bisect--helper --bisect-reset "$@" ;;
replay)
bisect_replay "$@" ;;
log)
--
https://github.com/git/git/pull/273
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v10 09/12] bisect--helper: `bisect_write` shell function in C
2016-07-20 21:47 ` [PATCH v10 01/12] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
` (7 preceding siblings ...)
2016-07-20 21:47 ` [PATCH v10 08/12] bisect--helper: `is_expected_rev` & `check_expected_revs` " Pranit Bauva
@ 2016-07-20 21:47 ` Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 03/12] bisect--helper: `write_terms` " Pranit Bauva
` (2 subsequent siblings)
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-20 21:47 UTC (permalink / raw)
To: git
Reimplement the `bisect_write` shell function in C and add a
`bisect-write` subcommand to `git bisect--helper` to call it from
git-bisect.sh
Using `--bisect-write` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other methods.
Note: bisect_write() uses two variables namely TERM_GOOD and TERM_BAD
from the global shell script thus we need to pass it to the subcommand
using the arguments. We then store them in a struct bisect_terms and
pass the memory address around functions.
This patch also introduces new methods namely bisect_state_init() and
bisect_terms_release() for easy memory management for the struct
bisect_terms.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 97 ++++++++++++++++++++++++++++++++++++++++++++----
git-bisect.sh | 25 ++-----------
2 files changed, 94 insertions(+), 28 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 86bb334..d1d12f2 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -22,9 +22,27 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-clean-state"),
N_("git bisect--helper --bisect-reset [<commit>]"),
+ N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
NULL
};
+struct bisect_terms {
+ struct strbuf term_good;
+ struct strbuf term_bad;
+};
+
+static void bisect_terms_init(struct bisect_terms *terms)
+{
+ strbuf_init(&terms->term_good, 0);
+ strbuf_init(&terms->term_bad, 0);
+}
+
+static void bisect_terms_release(struct bisect_terms *terms)
+{
+ strbuf_release(&terms->term_good);
+ strbuf_release(&terms->term_bad);
+}
+
/*
* Check whether the string `term` belongs to the set of strings
* included in the variable arguments.
@@ -188,6 +206,52 @@ static int check_expected_revs(const char **revs, int rev_nr)
return 0;
}
+static int bisect_write(const char *state, const char *rev,
+ const struct bisect_terms *terms, int nolog)
+{
+ struct strbuf tag = STRBUF_INIT;
+ struct strbuf commit_name = STRBUF_INIT;
+ struct object_id oid;
+ struct commit *commit;
+ struct pretty_print_context pp = {0};
+ FILE *fp;
+
+ if (!strcmp(state, terms->term_bad.buf))
+ strbuf_addf(&tag, "refs/bisect/%s", state);
+ else if (one_of(state, terms->term_good.buf, "skip", NULL))
+ strbuf_addf(&tag, "refs/bisect/%s-%s", state, rev);
+ else
+ return error(_("Bad bisect_write argument: %s"), state);
+
+ if (get_oid(rev, &oid)) {
+ strbuf_release(&tag);
+ return error(_("couldn't get the oid of the rev '%s'"), rev);
+ }
+
+ if (update_ref(NULL, tag.buf, oid.hash, NULL, 0,
+ UPDATE_REFS_MSG_ON_ERR)) {
+ strbuf_release(&tag);
+ return -1;
+ }
+ strbuf_release(&tag);
+
+ fp = fopen(git_path_bisect_log(), "a");
+ if (!fp)
+ return error_errno(_("couldn't open the file '%s'"), git_path_bisect_log());
+
+ commit = lookup_commit_reference(oid.hash);
+ format_commit_message(commit, "%s", &commit_name, &pp);
+ fprintf(fp, "# %s: [%s] %s\n", state, sha1_to_hex(oid.hash),
+ commit_name.buf);
+ strbuf_release(&commit_name);
+
+ if (!nolog)
+ fprintf(fp, "git bisect %s %s\n", state, rev);
+
+ fclose(fp);
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -195,9 +259,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
WRITE_TERMS,
BISECT_CLEAN_STATE,
BISECT_RESET,
- CHECK_EXPECTED_REVS
+ CHECK_EXPECTED_REVS,
+ BISECT_WRITE
} cmdmode = 0;
- int no_checkout = 0;
+ int no_checkout = 0, res = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
@@ -209,10 +274,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("reset the bisection state"), BISECT_RESET),
OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
N_("check for expected revs"), CHECK_EXPECTED_REVS),
+ OPT_CMDMODE(0, "bisect-write", &cmdmode,
+ N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
};
+ struct bisect_terms terms;
+ bisect_terms_init(&terms);
argc = parse_options(argc, argv, prefix, options,
git_bisect_helper_usage, 0);
@@ -221,24 +290,38 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
usage_with_options(git_bisect_helper_usage, options);
switch (cmdmode) {
+ int nolog;
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
case WRITE_TERMS:
if (argc != 2)
die(_("--write-terms requires two arguments"));
- return write_terms(argv[0], argv[1]);
+ res = write_terms(argv[0], argv[1]);
+ break;
case BISECT_CLEAN_STATE:
if (argc != 0)
die(_("--bisect-clean-state requires no arguments"));
- return bisect_clean_state();
+ res = bisect_clean_state();
+ break;
case BISECT_RESET:
if (argc > 1)
die(_("--bisect-reset requires either zero or one arguments"));
- return bisect_reset(argc ? argv[0] : NULL);
+ res = bisect_reset(argc ? argv[0] : NULL);
+ break;
case CHECK_EXPECTED_REVS:
- return check_expected_revs(argv, argc);
+ res = check_expected_revs(argv, argc);
+ break;
+ case BISECT_WRITE:
+ if (argc != 4 && argc != 5)
+ die(_("--bisect-write requires either 4 or 5 arguments"));
+ nolog = (argc == 5) && !strcmp(argv[4], "nolog");
+ strbuf_addstr(&terms.term_good, argv[2]);
+ strbuf_addstr(&terms.term_bad, argv[3]);
+ res = bisect_write(argv[0], argv[1], &terms, nolog);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
- return 0;
+ bisect_terms_release(&terms);
+ return res;
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 4f6545e..b9896a4 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -145,7 +145,7 @@ bisect_start() {
0) state=$TERM_BAD ; bad_seen=1 ;;
*) state=$TERM_GOOD ;;
esac
- eval="$eval bisect_write '$state' '$rev' 'nolog' &&"
+ eval="$eval git bisect--helper --bisect-write '$state' '$rev' '$TERM_GOOD' '$TERM_BAD' 'nolog' &&"
done
#
# Verify HEAD.
@@ -221,23 +221,6 @@ bisect_start() {
trap '-' 0
}
-bisect_write() {
- state="$1"
- rev="$2"
- nolog="$3"
- case "$state" in
- "$TERM_BAD")
- tag="$state" ;;
- "$TERM_GOOD"|skip)
- tag="$state"-"$rev" ;;
- *)
- die "$(eval_gettext "Bad bisect_write argument: \$state")" ;;
- esac
- git update-ref "refs/bisect/$tag" "$rev" || exit
- echo "# $state: $(git show-branch $rev)" >>"$GIT_DIR/BISECT_LOG"
- test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -263,7 +246,7 @@ bisect_state() {
1,"$TERM_BAD"|1,"$TERM_GOOD"|1,skip)
rev=$(git rev-parse --verify $(bisect_head)) ||
die "$(gettext "Bad rev input: $(bisect_head)")"
- bisect_write "$state" "$rev"
+ git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
git bisect--helper --check-expected-revs "$rev" ;;
2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
shift
@@ -276,7 +259,7 @@ bisect_state() {
done
for rev in $hash_list
do
- bisect_write "$state" "$rev"
+ git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
done
git bisect--helper --check-expected-revs $hash_list ;;
*,"$TERM_BAD")
@@ -413,7 +396,7 @@ bisect_replay () {
cmd="bisect_start $rev"
eval "$cmd" ;;
"$TERM_GOOD"|"$TERM_BAD"|skip)
- bisect_write "$command" "$rev" ;;
+ git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
terms)
bisect_terms $rev ;;
*)
--
https://github.com/git/git/pull/273
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v10 08/12] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C
2016-07-20 21:47 ` [PATCH v10 01/12] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
` (6 preceding siblings ...)
2016-07-20 21:47 ` [PATCH v10 07/12] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
@ 2016-07-20 21:47 ` Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 09/12] bisect--helper: `bisect_write` " Pranit Bauva
` (3 subsequent siblings)
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-20 21:47 UTC (permalink / raw)
To: git
Reimplement `is_expected_rev` & `check_expected_revs` shell function in
C and add a `--check-expected-revs` subcommand to `git bisect--helper` to
call it from git-bisect.sh .
Using `--check-expected-revs` subcommand is a temporary measure to port
shell functions to C so as to use the existing test suite. As more
functions are ported, this subcommand would be retired and will be
called by some other method.
Helped-by: Eric Sunshine <sunshine@sunshineco.com>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 33 ++++++++++++++++++++++++++++++++-
git-bisect.sh | 20 ++------------------
2 files changed, 34 insertions(+), 19 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index d125fd3..86bb334 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -162,13 +162,40 @@ static int bisect_reset(const char *commit)
return bisect_clean_state();
}
+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) >= 0) {
+ strbuf_trim(&actual_hex);
+ res = !strcmp(actual_hex.buf, expected_hex);
+ }
+ strbuf_release(&actual_hex);
+ return res;
+}
+
+static int check_expected_revs(const char **revs, int rev_nr)
+{
+ int i;
+
+ for (i = 0; i < rev_nr; i++) {
+ if (!is_expected_rev(revs[i])) {
+ remove_path(git_path_bisect_ancestors_ok());
+ remove_path(git_path_bisect_expected_rev());
+ return 0;
+ }
+ }
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
WRITE_TERMS,
BISECT_CLEAN_STATE,
- BISECT_RESET
+ BISECT_RESET,
+ CHECK_EXPECTED_REVS
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -180,6 +207,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
N_("reset the bisection state"), BISECT_RESET),
+ OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
+ N_("check for expected revs"), CHECK_EXPECTED_REVS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -206,6 +235,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc > 1)
die(_("--bisect-reset requires either zero or one arguments"));
return bisect_reset(argc ? argv[0] : NULL);
+ case CHECK_EXPECTED_REVS:
+ return check_expected_revs(argv, argc);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 18580b7..4f6545e 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -238,22 +238,6 @@ bisect_write() {
test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
}
-is_expected_rev() {
- test -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
- test "$1" = $(cat "$GIT_DIR/BISECT_EXPECTED_REV")
-}
-
-check_expected_revs() {
- for _rev in "$@"; do
- if ! is_expected_rev "$_rev"
- then
- rm -f "$GIT_DIR/BISECT_ANCESTORS_OK"
- rm -f "$GIT_DIR/BISECT_EXPECTED_REV"
- return
- fi
- done
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -280,7 +264,7 @@ bisect_state() {
rev=$(git rev-parse --verify $(bisect_head)) ||
die "$(gettext "Bad rev input: $(bisect_head)")"
bisect_write "$state" "$rev"
- check_expected_revs "$rev" ;;
+ git bisect--helper --check-expected-revs "$rev" ;;
2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
shift
hash_list=''
@@ -294,7 +278,7 @@ bisect_state() {
do
bisect_write "$state" "$rev"
done
- check_expected_revs $hash_list ;;
+ git bisect--helper --check-expected-revs $hash_list ;;
*,"$TERM_BAD")
die "$(eval_gettext "'git bisect \$TERM_BAD' can take only one argument.")" ;;
*)
--
https://github.com/git/git/pull/273
^ permalink raw reply related [flat|nested] 320+ messages in thread
* Re: [PATCH v10 12/12] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-07-20 21:47 ` [PATCH v10 12/12] bisect--helper: `get_terms` & `bisect_terms` " Pranit Bauva
@ 2016-07-22 2:29 ` Torsten Bögershausen
2016-07-22 14:07 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Torsten Bögershausen @ 2016-07-22 2:29 UTC (permalink / raw)
To: Pranit Bauva, git
On 07/20/2016 11:47 PM, Pranit Bauva wrote:
> Reimplement the `get_terms` and `bisect_terms` shell function in C and
> add `bisect-terms` subcommand to `git bisect--helper` to call it from
> git-bisect.sh .
>
> In the shell version, the terms were identified by strings but in C
> version its done by bit manipulation and passing the integer value to
> the function.
>
> Using `--bisect-terms` subcommand is a temporary measure to port shell
> function in C so as to use the existing test suite. As more functions
> are ported, this subcommand will be retired and will be called by some
> other methods.
>
> Mentored-by: Lars Schneider <larsxschneider@gmail.com>
> Mentored-by: Christian Couder <chriscool@tuxfamily.org>
> Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
> ---
> builtin/bisect--helper.c | 74 +++++++++++++++++++++++++++++++++++++++++++++++-
> git-bisect.sh | 35 ++---------------------
> 2 files changed, 75 insertions(+), 34 deletions(-)
>
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 001096a..185a8ad 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -8,6 +8,13 @@
> #include "run-command.h"
> #include "prompt.h"
>
> +enum terms_defined {
> + TERM_BAD = 1,
> + TERM_GOOD = 2,
> + TERM_NEW = 4,
> + TERM_OLD = 8
> +};
> +
What does TERM stand for ?
It could be TERMinal, TERMinator or just TERM.
Something like BIS_TERM_DEF_BAD .. may be more intuitive,
and may avoid name clashes in the long run.
And why are the defines 1,2,4,8 ?
It looks as if a #define bitmap may be a better choice here ?
How do we do these kind of bit-wise opions otherwise ?
> static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
> static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
> static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
> @@ -26,6 +33,7 @@ static const char * const git_bisect_helper_usage[] = {
> N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
> N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
> N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
> + N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
> NULL
> };
>
> @@ -359,6 +367,43 @@ static int bisect_next_check(const struct bisect_terms *terms,
> return 0;
> }
>
> +static int get_terms(struct bisect_terms *terms)
> +{
> + FILE *fp;
> + int res;
> + fp = fopen(git_path_bisect_terms(), "r");
> + if (!fp)
> + return -1;
> +
> + bisect_terms_reset(terms);
> + res = strbuf_getline(&terms->term_bad, fp) == EOF ||
> + strbuf_getline(&terms->term_good, fp) == EOF;
> +
> + fclose(fp);
> + return res ? -1 : 0;
> +}
> +
> +static int bisect_terms(struct bisect_terms *terms, int term_defined)
> +{
> + if (get_terms(terms)) {
> + fprintf(stderr, "no terms defined\n");
> + return -1;
> + }
> + if (!term_defined) {
> + printf("Your current terms are %s for the old state\nand "
> + "%s for the new state.\n", terms->term_good.buf,
> + terms->term_bad.buf);
> + return 0;
> + }
> +
> + if (term_defined == TERM_GOOD || term_defined == TERM_OLD)
> + printf("%s\n", terms->term_good.buf);
> + if (term_defined == TERM_BAD || term_defined == TERM_NEW)
> + printf("%s\n", terms->term_bad.buf);
May be a switch-case ?
Or at least "else if" ?
> +
> + return 0;
> +}
> +
> int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> {
> enum {
> @@ -369,9 +414,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> CHECK_EXPECTED_REVS,
> BISECT_WRITE,
> CHECK_AND_SET_TERMS,
> - BISECT_NEXT_CHECK
> + BISECT_NEXT_CHECK,
> + BISECT_TERMS
> } cmdmode = 0;
> int no_checkout = 0, res = 0;
> + enum terms_defined term_defined = 0;
> struct option options[] = {
> OPT_CMDMODE(0, "next-all", &cmdmode,
> N_("perform 'git bisect next'"), NEXT_ALL),
> @@ -389,6 +436,16 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
> OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
> N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
> + OPT_CMDMODE(0, "bisect-terms", &cmdmode,
> + N_("print out the bisect terms"), BISECT_TERMS),
> + OPT_BIT(0, "term-bad", &term_defined,
> + N_("show the bad term"), TERM_BAD),
> + OPT_BIT(0, "term-good", &term_defined,
> + N_("show the good term"), TERM_GOOD),
> + OPT_BIT(0, "term-new", &term_defined,
> + N_("show the new term"), TERM_NEW),
> + OPT_BIT(0, "term-old", &term_defined,
> + N_("show the old term"), TERM_OLD),
> OPT_BOOL(0, "no-checkout", &no_checkout,
> N_("update BISECT_HEAD instead of checking out the current commit")),
> OPT_END()
> @@ -399,6 +456,16 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> argc = parse_options(argc, argv, prefix, options,
> git_bisect_helper_usage, 0);
>
> + if (cmdmode != BISECT_TERMS && term_defined)
> + die(_("--term-bad, --term-good, --term-new and --term-old "
> + "can be used only with --bisect-terms"));
> +
> + if (term_defined != 0 && term_defined != TERM_BAD &&
> + term_defined != TERM_GOOD && term_defined != TERM_NEW &&
> + term_defined != TERM_OLD)
> + die(_("only one option among --term-bad, --term-good, "
> + "--term-new and --term-old can be used."));
> +
[]
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v10 12/12] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-07-22 2:29 ` Torsten Bögershausen
@ 2016-07-22 14:07 ` Pranit Bauva
2016-07-25 16:53 ` Junio C Hamano
0 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-07-22 14:07 UTC (permalink / raw)
To: Torsten Bögershausen; +Cc: Git List
Hey Torsten,
On Fri, Jul 22, 2016 at 7:59 AM, Torsten Bögershausen <tboegi@web.de> wrote:
>
>
> On 07/20/2016 11:47 PM, Pranit Bauva wrote:
>>
>> Reimplement the `get_terms` and `bisect_terms` shell function in C and
>> add `bisect-terms` subcommand to `git bisect--helper` to call it from
>> git-bisect.sh .
>>
>> In the shell version, the terms were identified by strings but in C
>> version its done by bit manipulation and passing the integer value to
>> the function.
>>
>> Using `--bisect-terms` subcommand is a temporary measure to port shell
>> function in C so as to use the existing test suite. As more functions
>> are ported, this subcommand will be retired and will be called by some
>> other methods.
>>
>> Mentored-by: Lars Schneider <larsxschneider@gmail.com>
>> Mentored-by: Christian Couder <chriscool@tuxfamily.org>
>> Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
>> ---
>> builtin/bisect--helper.c | 74
>> +++++++++++++++++++++++++++++++++++++++++++++++-
>> git-bisect.sh | 35 ++---------------------
>> 2 files changed, 75 insertions(+), 34 deletions(-)
>>
>> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
>> index 001096a..185a8ad 100644
>> --- a/builtin/bisect--helper.c
>> +++ b/builtin/bisect--helper.c
>> @@ -8,6 +8,13 @@
>> #include "run-command.h"
>> #include "prompt.h"
>>
>> +enum terms_defined {
>> + TERM_BAD = 1,
>> + TERM_GOOD = 2,
>> + TERM_NEW = 4,
>> + TERM_OLD = 8
>> +};
>> +
>
> What does TERM stand for ?
> It could be TERMinal, TERMinator or just TERM.
> Something like BIS_TERM_DEF_BAD .. may be more intuitive,
> and may avoid name clashes in the long run.
>
> And why are the defines 1,2,4,8 ?
> It looks as if a #define bitmap may be a better choice here ?
> How do we do these kind of bit-wise opions otherwise ?
I am not sure as why bitmaps would be a better choice except for git's
source code. I saw the source code (especially config.c) and it uses
"#defines" bitmap style. I haven't been able to find this method
before. Also it uses "(1<<2)" instead of "4".
>> static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
>> static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
>> static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
>> @@ -26,6 +33,7 @@ static const char * const git_bisect_helper_usage[] = {
>> N_("git bisect--helper --bisect-write <state> <revision>
>> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
>> N_("git bisect--helper --bisect-check-and-set-terms <command>
>> <TERM_GOOD> <TERM_BAD>"),
>> N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD>
>> <TERM_BAD"),
>> + N_("git bisect--helper --bisect-terms [--term-good | --term-old |
>> --term-bad | --term-new]"),
>> NULL
>> };
>>
>> @@ -359,6 +367,43 @@ static int bisect_next_check(const struct
>> bisect_terms *terms,
>> return 0;
>> }
>>
>> +static int get_terms(struct bisect_terms *terms)
>> +{
>> + FILE *fp;
>> + int res;
>> + fp = fopen(git_path_bisect_terms(), "r");
>> + if (!fp)
>> + return -1;
>> +
>> + bisect_terms_reset(terms);
>> + res = strbuf_getline(&terms->term_bad, fp) == EOF ||
>> + strbuf_getline(&terms->term_good, fp) == EOF;
>> +
>> + fclose(fp);
>> + return res ? -1 : 0;
>> +}
>> +
>> +static int bisect_terms(struct bisect_terms *terms, int term_defined)
>> +{
>> + if (get_terms(terms)) {
>> + fprintf(stderr, "no terms defined\n");
>> + return -1;
>> + }
>> + if (!term_defined) {
>> + printf("Your current terms are %s for the old state\nand "
>> + "%s for the new state.\n", terms->term_good.buf,
>> + terms->term_bad.buf);
>> + return 0;
>> + }
>> +
>> + if (term_defined == TERM_GOOD || term_defined == TERM_OLD)
>> + printf("%s\n", terms->term_good.buf);
>> + if (term_defined == TERM_BAD || term_defined == TERM_NEW)
>> + printf("%s\n", terms->term_bad.buf);
>
> May be a switch-case ?
> Or at least "else if" ?
Yes. I will use a "else if". Thanks!
>> +
>> + return 0;
>> +}
>> +
>> int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
>> {
>> enum {
>> @@ -369,9 +414,11 @@ int cmd_bisect__helper(int argc, const char **argv,
>> const char *prefix)
>> CHECK_EXPECTED_REVS,
>> BISECT_WRITE,
>> CHECK_AND_SET_TERMS,
>> - BISECT_NEXT_CHECK
>> + BISECT_NEXT_CHECK,
>> + BISECT_TERMS
>> } cmdmode = 0;
>> int no_checkout = 0, res = 0;
>> + enum terms_defined term_defined = 0;
>> struct option options[] = {
>> OPT_CMDMODE(0, "next-all", &cmdmode,
>> N_("perform 'git bisect next'"), NEXT_ALL),
>> @@ -389,6 +436,16 @@ int cmd_bisect__helper(int argc, const char **argv,
>> const char *prefix)
>> N_("check and set terms in a bisection state"),
>> CHECK_AND_SET_TERMS),
>> OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
>> N_("check whether bad or good terms exist"),
>> BISECT_NEXT_CHECK),
>> + OPT_CMDMODE(0, "bisect-terms", &cmdmode,
>> + N_("print out the bisect terms"), BISECT_TERMS),
>> + OPT_BIT(0, "term-bad", &term_defined,
>> + N_("show the bad term"), TERM_BAD),
>> + OPT_BIT(0, "term-good", &term_defined,
>> + N_("show the good term"), TERM_GOOD),
>> + OPT_BIT(0, "term-new", &term_defined,
>> + N_("show the new term"), TERM_NEW),
>> + OPT_BIT(0, "term-old", &term_defined,
>> + N_("show the old term"), TERM_OLD),
>> OPT_BOOL(0, "no-checkout", &no_checkout,
>> N_("update BISECT_HEAD instead of checking out
>> the current commit")),
>> OPT_END()
>> @@ -399,6 +456,16 @@ int cmd_bisect__helper(int argc, const char **argv,
>> const char *prefix)
>> argc = parse_options(argc, argv, prefix, options,
>> git_bisect_helper_usage, 0);
>>
>> + if (cmdmode != BISECT_TERMS && term_defined)
>> + die(_("--term-bad, --term-good, --term-new and --term-old
>> "
>> + "can be used only with --bisect-terms"));
>> +
>> + if (term_defined != 0 && term_defined != TERM_BAD &&
>> + term_defined != TERM_GOOD && term_defined != TERM_NEW &&
>> + term_defined != TERM_OLD)
>> + die(_("only one option among --term-bad, --term-good, "
>> + "--term-new and --term-old can be used."));
>> +
>
> []
However I suspect handling "--term-good/--term-bad" is creating
problems in bisect_start(). I am finding a way around. If not then I
will have to get back to using "OPT_ARGUMENT" and handling it in the
individual function.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v10 12/12] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-07-22 14:07 ` Pranit Bauva
@ 2016-07-25 16:53 ` Junio C Hamano
2016-07-25 21:28 ` Christian Couder
2016-07-26 1:42 ` Torsten Bögershausen
0 siblings, 2 replies; 320+ messages in thread
From: Junio C Hamano @ 2016-07-25 16:53 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Torsten Bögershausen, Git List
Pranit Bauva <pranit.bauva@gmail.com> writes:
>>> +enum terms_defined {
>>> + TERM_BAD = 1,
>>> + TERM_GOOD = 2,
>>> + TERM_NEW = 4,
>>> + TERM_OLD = 8
>>> +};
>>> +
>>
>> What does TERM stand for ?
The terms (words) used to denote the newer and the older parts of
the history. Traditionally, as a regression-hunting tool (i.e. it
used to work, where did I break it?), we called older parts of the
history "good" and newer one "bad", but as people gained experience
with the tool, it was found that the pair of words was error-prone
to use for an opposite use case "I do not recall fixing it, but it
seems to have been fixed magically, when did that happen?", and a
more explicit "new" and "old" were introduced.
>> And why are the defines 1,2,4,8 ?
>> It looks as if a #define bitmap may be a better choice here ?
>> How do we do these kind of bit-wise opions otherwise ?
We might want to ask if these should even be bitwise option. A word
with individually controllable bits (i.e. "flag word") makes sense
only when the bits within it are largely independent. But the code
does this pretty much upfront:
>>> + if (term_defined != 0 && term_defined != TERM_BAD &&
>>> + term_defined != TERM_GOOD && term_defined != TERM_NEW &&
>>> + term_defined != TERM_OLD)
>>> + die(_("only one option among --term-bad, --term-good, "
>>> + "--term-new and --term-old can be used."));
which is a very strong indication that these bits are not.
I suspect that OPTION_CMDMODE would be a better choice to group
these four options and mark them mutually incompatible automatically
than OPT_BIT?
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v10 12/12] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-07-25 16:53 ` Junio C Hamano
@ 2016-07-25 21:28 ` Christian Couder
2016-07-26 1:42 ` Torsten Bögershausen
1 sibling, 0 replies; 320+ messages in thread
From: Christian Couder @ 2016-07-25 21:28 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Pranit Bauva, Torsten Bögershausen, Git List
On Mon, Jul 25, 2016 at 6:53 PM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>>> And why are the defines 1,2,4,8 ?
>>> It looks as if a #define bitmap may be a better choice here ?
>>> How do we do these kind of bit-wise opions otherwise ?
>
> We might want to ask if these should even be bitwise option. A word
> with individually controllable bits (i.e. "flag word") makes sense
> only when the bits within it are largely independent. But the code
> does this pretty much upfront:
>
>>>> + if (term_defined != 0 && term_defined != TERM_BAD &&
>>>> + term_defined != TERM_GOOD && term_defined != TERM_NEW &&
>>>> + term_defined != TERM_OLD)
>>>> + die(_("only one option among --term-bad, --term-good, "
>>>> + "--term-new and --term-old can be used."));
>
> which is a very strong indication that these bits are not.
>
> I suspect that OPTION_CMDMODE would be a better choice to group
> these four options and mark them mutually incompatible automatically
> than OPT_BIT?
I must say that Pranit used that at one point, but it felt weird to me
to use that for things that is not really a command.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v10 12/12] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-07-25 16:53 ` Junio C Hamano
2016-07-25 21:28 ` Christian Couder
@ 2016-07-26 1:42 ` Torsten Bögershausen
2016-07-26 17:32 ` Junio C Hamano
1 sibling, 1 reply; 320+ messages in thread
From: Torsten Bögershausen @ 2016-07-26 1:42 UTC (permalink / raw)
To: Junio C Hamano, Pranit Bauva; +Cc: Git List
On 07/25/2016 06:53 PM, Junio C Hamano wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>>>> >>> +enum terms_defined {
>>>> >>> + TERM_BAD = 1,
>>>> >>> + TERM_GOOD = 2,
>>>> >>> + TERM_NEW = 4,
>>>> >>> + TERM_OLD = 8
>>>> >>> +};
>>>> >>> +
>>> >>
>>> >> What does TERM stand for ?
> The terms (words) used to denote the newer and the older parts of
> the history. Traditionally, as a regression-hunting tool (i.e. it
> used to work, where did I break it?), we called older parts of the
> history "good" and newer one "bad", but as people gained experience
> with the tool, it was found that the pair of words was error-prone
> to use for an opposite use case "I do not recall fixing it, but it
> seems to have been fixed magically, when did that happen?", and a
> more explicit "new" and "old" were introduced.
>
Thanks for the explanation.
Is there any risk that a more generic term like "TERM_BAD" may collide
with some other definition some day ?
Would it make sense to call it GIT_BISECT_TERM_BAD, GBS_TERM_BAD,
BIS_TERM_BAD or something more unique ?
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v10 12/12] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-07-26 1:42 ` Torsten Bögershausen
@ 2016-07-26 17:32 ` Junio C Hamano
2016-07-27 4:20 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-07-26 17:32 UTC (permalink / raw)
To: Torsten Bögershausen; +Cc: Pranit Bauva, Git List
Torsten Bögershausen <tboegi@web.de> writes:
> On 07/25/2016 06:53 PM, Junio C Hamano wrote:
>> Pranit Bauva <pranit.bauva@gmail.com> writes:
>>
>>>>> >>> +enum terms_defined {
>>>>> >>> + TERM_BAD = 1,
>>>>> >>> + TERM_GOOD = 2,
>>>>> >>> + TERM_NEW = 4,
>>>>> >>> + TERM_OLD = 8
>>>>> >>> +};
>>>>> >>> +
>>>> >> ...
> Is there any risk that a more generic term like "TERM_BAD" may collide
> with some other definition some day ?
>
> Would it make sense to call it GIT_BISECT_TERM_BAD, GBS_TERM_BAD,
> BIS_TERM_BAD or something more unique ?
I am not sure if the scope of these symbols would ever escape
outside bisect-helper.c (and builtin/bisect.c eventually when we
retire git-bisect.sh), but BISECT_TERM_{GOOD,BAD,OLD,NEW} would not
be too bad.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v10 12/12] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-07-26 17:32 ` Junio C Hamano
@ 2016-07-27 4:20 ` Pranit Bauva
2016-07-27 16:13 ` Junio C Hamano
0 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-07-27 4:20 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Torsten Bögershausen, Git List
Hey Junio,
On Tue, Jul 26, 2016 at 11:02 PM, Junio C Hamano <gitster@pobox.com> wrote:
> Torsten Bögershausen <tboegi@web.de> writes:
>
>> On 07/25/2016 06:53 PM, Junio C Hamano wrote:
>>> Pranit Bauva <pranit.bauva@gmail.com> writes:
>>>
>>>>>> >>> +enum terms_defined {
>>>>>> >>> + TERM_BAD = 1,
>>>>>> >>> + TERM_GOOD = 2,
>>>>>> >>> + TERM_NEW = 4,
>>>>>> >>> + TERM_OLD = 8
>>>>>> >>> +};
>>>>>> >>> +
>>>>> >> ...
>> Is there any risk that a more generic term like "TERM_BAD" may collide
>> with some other definition some day ?
>>
>> Would it make sense to call it GIT_BISECT_TERM_BAD, GBS_TERM_BAD,
>> BIS_TERM_BAD or something more unique ?
>
> I am not sure if the scope of these symbols would ever escape
> outside bisect-helper.c (and builtin/bisect.c eventually when we
> retire git-bisect.sh), but BISECT_TERM_{GOOD,BAD,OLD,NEW} would not
> be too bad.
I agree that it wouldn't be too bad. This can be considered as low
hanging fruit and picked up after the completion of the project as
after the whole conversion, some re-ordering of code would need to be
done. For eg. there is read_bisect_terms() is in bisect.c while
get_terms() is in builtin/bisect--helper.c but they both do the same
stuff except the later one uses strbuf and a lot more important stuff.
Maybe after the whole conversion, the above enum (or #define bitmap)
should also be moved to bisect.h and be used consistently in bisect.c
too.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v10 12/12] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-07-27 4:20 ` Pranit Bauva
@ 2016-07-27 16:13 ` Junio C Hamano
0 siblings, 0 replies; 320+ messages in thread
From: Junio C Hamano @ 2016-07-27 16:13 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Torsten Bögershausen, Git List
Pranit Bauva <pranit.bauva@gmail.com> writes:
> On Tue, Jul 26, 2016 at 11:02 PM, Junio C Hamano <gitster@pobox.com> wrote:
>> Torsten Bögershausen <tboegi@web.de> writes:
>>
>>> On 07/25/2016 06:53 PM, Junio C Hamano wrote:
>>>> Pranit Bauva <pranit.bauva@gmail.com> writes:
>>>>
>>>>>>> >>> +enum terms_defined {
>>>>>>> >>> + TERM_BAD = 1,
>>>>>>> >>> + TERM_GOOD = 2,
>>>>>>> >>> + TERM_NEW = 4,
>>>>>>> >>> + TERM_OLD = 8
>>>>>>> >>> +};
>>>>>>> >>> +
>>>>>> >> ...
>>> Is there any risk that a more generic term like "TERM_BAD" may collide
>>> with some other definition some day ?
>>>
>>> Would it make sense to call it GIT_BISECT_TERM_BAD, GBS_TERM_BAD,
>>> BIS_TERM_BAD or something more unique ?
>>
>> I am not sure if the scope of these symbols would ever escape
>> outside bisect-helper.c (and builtin/bisect.c eventually when we
>> retire git-bisect.sh), but BISECT_TERM_{GOOD,BAD,OLD,NEW} would not
>> be too bad.
>
> I agree that it wouldn't be too bad. This can be considered as low
> hanging fruit and picked up after the completion of the project as
> after the whole conversion, some re-ordering of code would need to be
> done.
> For eg. there is read_bisect_terms() is in bisect.c while
> get_terms() is in builtin/bisect--helper.c but they both do the same
> stuff except the later one uses strbuf and a lot more important stuff.
The criteria to decide if a known "room for improvement" can be left
as a "can be later touched up" is "would it be a long-term
maintenance burden if it is left unfixed?", and from that point of
view, I actually view the latter as a part of the necessary
"polishing in response to review comments" for the initial version
of a new topic to land in the official project's tree.
As to TERM vs BISECT_TERM, I do not think it matters that much as I
said (IOW, I do not think it would make it a maintenance burden if
we kept using TERM_{BAD,GOOD,NEW,OLD}).
^ permalink raw reply [flat|nested] 320+ messages in thread
* [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2016-07-20 21:47 ` [PATCH v10 01/12] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
` (10 preceding siblings ...)
2016-07-20 21:47 ` [PATCH v10 04/12] bisect--helper: `bisect_clean_state` " Pranit Bauva
@ 2016-07-31 9:21 ` Pranit Bauva
2016-07-31 9:21 ` [RFC/PATCH v11 08/13] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C Pranit Bauva
` (13 more replies)
11 siblings, 14 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-31 9:21 UTC (permalink / raw)
To: git
`--next-all` is meant to be used as a subcommand to support multiple
"operation mode" though the current implementation does not contain any
other subcommand along side with `--next-all` but further commits will
include some more subcommands.
Helped-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 17 +++++++++++------
1 file changed, 11 insertions(+), 6 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 3324229..8111c91 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -10,11 +10,11 @@ static const char * const git_bisect_helper_usage[] = {
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
- int next_all = 0;
+ enum { NEXT_ALL = 1 } cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
- OPT_BOOL(0, "next-all", &next_all,
- N_("perform 'git bisect next'")),
+ OPT_CMDMODE(0, "next-all", &cmdmode,
+ N_("perform 'git bisect next'"), NEXT_ALL),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -23,9 +23,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
argc = parse_options(argc, argv, prefix, options,
git_bisect_helper_usage, 0);
- if (!next_all)
+ if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
- /* next-all */
- return bisect_next_all(prefix, no_checkout);
+ switch (cmdmode) {
+ case NEXT_ALL:
+ return bisect_next_all(prefix, no_checkout);
+ default:
+ die("BUG: unknown subcommand '%d'", cmdmode);
+ }
+ return 0;
}
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [RFC/PATCH v11 06/13] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file()
2016-07-31 9:21 ` [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
` (4 preceding siblings ...)
2016-07-31 9:21 ` [RFC/PATCH v11 05/13] t6030: explicitly test for bisection cleanup Pranit Bauva
@ 2016-07-31 9:21 ` Pranit Bauva
2016-07-31 9:21 ` [RFC/PATCH v11 04/13] bisect--helper: `bisect_clean_state` shell function in C Pranit Bauva
` (7 subsequent siblings)
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-31 9:21 UTC (permalink / raw)
To: git
is_empty_file() can help to refactor a lot of code. This will be very
helpful in porting "git bisect" to C.
Suggested-by: Torsten Bögershausen <tboegi@web.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/am.c | 20 ++------------------
cache.h | 3 +++
wrapper.c | 13 +++++++++++++
3 files changed, 18 insertions(+), 18 deletions(-)
diff --git a/builtin/am.c b/builtin/am.c
index 3dfe70b..6ee158f 100644
--- a/builtin/am.c
+++ b/builtin/am.c
@@ -30,22 +30,6 @@
#include "mailinfo.h"
/**
- * Returns 1 if the file is empty or does not exist, 0 otherwise.
- */
-static int is_empty_file(const char *filename)
-{
- struct stat st;
-
- if (stat(filename, &st) < 0) {
- if (errno == ENOENT)
- return 1;
- die_errno(_("could not stat %s"), filename);
- }
-
- return !st.st_size;
-}
-
-/**
* Returns the length of the first line of msg.
*/
static int linelen(const char *msg)
@@ -1323,7 +1307,7 @@ static int parse_mail(struct am_state *state, const char *mail)
goto finish;
}
- if (is_empty_file(am_path(state, "patch"))) {
+ if (is_empty_or_missing_file(am_path(state, "patch"))) {
printf_ln(_("Patch is empty. Was it split wrong?"));
die_user_resolve(state);
}
@@ -1911,7 +1895,7 @@ static void am_run(struct am_state *state, int resume)
resume = 0;
}
- if (!is_empty_file(am_path(state, "rewritten"))) {
+ if (!is_empty_or_missing_file(am_path(state, "rewritten"))) {
assert(state->rebasing);
copy_notes_for_rebase(state);
run_post_rewrite_hook(state);
diff --git a/cache.h b/cache.h
index 6049f86..91e2f81 100644
--- a/cache.h
+++ b/cache.h
@@ -1870,4 +1870,7 @@ void sleep_millisec(int millisec);
*/
void safe_create_dir(const char *dir, int share);
+/* Return 1 if the file is empty or does not exists, 0 otherwise. */
+extern int is_empty_or_missing_file(const char *filename);
+
#endif /* CACHE_H */
diff --git a/wrapper.c b/wrapper.c
index 5dc4e15..e70e4d1 100644
--- a/wrapper.c
+++ b/wrapper.c
@@ -696,3 +696,16 @@ void sleep_millisec(int millisec)
{
poll(NULL, 0, millisec);
}
+
+int is_empty_or_missing_file(const char *filename)
+{
+ struct stat st;
+
+ if (stat(filename, &st) < 0) {
+ if (errno == ENOENT)
+ return 1;
+ die_errno(_("could not stat %s"), filename);
+ }
+
+ return !st.st_size;
+}
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [RFC/PATCH v11 05/13] t6030: explicitly test for bisection cleanup
2016-07-31 9:21 ` [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
` (3 preceding siblings ...)
2016-07-31 9:21 ` [RFC/PATCH v11 03/13] bisect--helper: `write_terms` " Pranit Bauva
@ 2016-07-31 9:21 ` Pranit Bauva
2016-07-31 9:21 ` [RFC/PATCH v11 06/13] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
` (8 subsequent siblings)
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-07-31 9:21 UTC (permalink / raw)
To: git
Add test to explicitly check that 'git bisect reset' is working as
expected. This is already covered implicitly by the test suite.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
I faced this problem while converting `bisect_clean_state` and the tests
where showing breakages but it wasn't clear as to where exactly are they
breaking. This will patch will help in that. Also I tested the test
coverage of the test suite before this patch and it covers this (I did
this by purposely changing names of files in git-bisect.sh and running
the test suite).
---
t/t6030-bisect-porcelain.sh | 17 +++++++++++++++++
1 file changed, 17 insertions(+)
diff --git a/t/t6030-bisect-porcelain.sh b/t/t6030-bisect-porcelain.sh
index e74662b..a17f7a6 100755
--- a/t/t6030-bisect-porcelain.sh
+++ b/t/t6030-bisect-porcelain.sh
@@ -894,4 +894,21 @@ test_expect_success 'bisect start takes options and revs in any order' '
test_cmp expected actual
'
+test_expect_success 'git bisect reset cleans bisection state properly' '
+ git bisect reset &&
+ git bisect start &&
+ git bisect good $HASH1 &&
+ git bisect bad $HASH4 &&
+ git bisect reset &&
+ test -z "$(git for-each-ref "refs/bisect/*")" &&
+ test_path_is_missing "$GIT_DIR/BISECT_EXPECTED_REV" &&
+ test_path_is_missing "$GIT_DIR/BISECT_ANCESTORS_OK" &&
+ test_path_is_missing "$GIT_DIR/BISECT_LOG" &&
+ test_path_is_missing "$GIT_DIR/BISECT_RUN" &&
+ test_path_is_missing "$GIT_DIR/BISECT_TERMS" &&
+ test_path_is_missing "$GIT_DIR/head-name" &&
+ test_path_is_missing "$GIT_DIR/BISECT_HEAD" &&
+ test_path_is_missing "$GIT_DIR/BISECT_START"
+'
+
test_done
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [RFC/PATCH v11 03/13] bisect--helper: `write_terms` shell function in C
2016-07-31 9:21 ` [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
` (2 preceding siblings ...)
2016-07-31 9:21 ` [RFC/PATCH v11 02/13] bisect: rewrite `check_term_format` " Pranit Bauva
@ 2016-07-31 9:21 ` Pranit Bauva
2016-08-02 17:38 ` Junio C Hamano
2016-07-31 9:21 ` [RFC/PATCH v11 05/13] t6030: explicitly test for bisection cleanup Pranit Bauva
` (9 subsequent siblings)
13 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-07-31 9:21 UTC (permalink / raw)
To: git
Reimplement the `write_terms` shell function in C and add a `write-terms`
subcommand to `git bisect--helper` to call it from git-bisect.sh . Also
remove the subcommand `--check-term-format` as it can now be called from
inside the function write_terms() C implementation.
Also `|| exit` is added when calling write-terms subcommand from
git-bisect.sh so as to exit whenever there is an error.
Using `--write-terms` subcommand is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other method.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 36 +++++++++++++++++++++++++++++-------
git-bisect.sh | 22 +++++++---------------
2 files changed, 36 insertions(+), 22 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 48285d4..965bcc1 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -4,9 +4,11 @@
#include "bisect.h"
#include "refs.h"
+static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
+
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
- N_("git bisect--helper --check-term-format <term> <orig_term>"),
+ N_("git bisect--helper --write-terms <bad_term> <good_term>"),
NULL
};
@@ -56,18 +58,38 @@ static int check_term_format(const char *term, const char *orig_term)
return 0;
}
+static int write_terms(const char *bad, const char *good)
+{
+ FILE *fp;
+ 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;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
- CHECK_TERM_FMT
+ WRITE_TERMS
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
- OPT_CMDMODE(0, "check-term-format", &cmdmode,
- N_("check format of the term"), CHECK_TERM_FMT),
+ OPT_CMDMODE(0, "write-terms", &cmdmode,
+ N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -82,10 +104,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
switch (cmdmode) {
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
- case CHECK_TERM_FMT:
+ case WRITE_TERMS:
if (argc != 2)
- die(_("--check-term-format requires two arguments"));
- return check_term_format(argv[0], argv[1]);
+ die(_("--write-terms requires two arguments"));
+ return write_terms(argv[0], argv[1]);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 7d7965d..cd39bd0 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -210,7 +210,7 @@ bisect_start() {
eval "$eval true" &&
if test $must_write_terms -eq 1
then
- write_terms "$TERM_BAD" "$TERM_GOOD"
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD"
fi &&
echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
#
@@ -557,18 +557,6 @@ get_terms () {
fi
}
-write_terms () {
- TERM_BAD=$1
- TERM_GOOD=$2
- if test "$TERM_BAD" = "$TERM_GOOD"
- then
- die "$(gettext "please use two different terms")"
- fi
- git bisect--helper --check-term-format "$TERM_BAD" bad || exit
- git bisect--helper --check-term-format "$TERM_GOOD" good || exit
- printf '%s\n%s\n' "$TERM_BAD" "$TERM_GOOD" >"$GIT_DIR/BISECT_TERMS"
-}
-
check_and_set_terms () {
cmd="$1"
case "$cmd" in
@@ -582,13 +570,17 @@ check_and_set_terms () {
bad|good)
if ! test -s "$GIT_DIR/BISECT_TERMS"
then
- write_terms bad good
+ TERM_BAD=bad
+ TERM_GOOD=good
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
fi
;;
new|old)
if ! test -s "$GIT_DIR/BISECT_TERMS"
then
- write_terms new old
+ TERM_BAD=new
+ TERM_GOOD=old
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
fi
;;
esac ;;
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [RFC/PATCH v11 07/13] bisect--helper: `bisect_reset` shell function in C
2016-07-31 9:21 ` [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
` (8 preceding siblings ...)
2016-07-31 9:21 ` [RFC/PATCH v11 12/13] bisect--helper: `get_terms` & `bisect_terms` " Pranit Bauva
@ 2016-07-31 9:21 ` Pranit Bauva
2016-08-02 18:44 ` Junio C Hamano
2016-07-31 9:21 ` [RFC/PATCH v11 11/13] bisect--helper: `bisect_next_check` " Pranit Bauva
` (3 subsequent siblings)
13 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-07-31 9:21 UTC (permalink / raw)
To: git
Reimplement `bisect_reset` shell function in C and add a `--bisect-reset`
subcommand to `git bisect--helper` to call it from git-bisect.sh .
Using `bisect_reset` subcommand is a temporary measure to port shell
functions to C so as to use the existing test suite. As more functions
are ported, this subcommand would be retired and will be called by some
other method.
Note: --bisect-clean-state subcommand has not been retired as there are
still a function namely `bisect_start()` which still uses this
subcommand.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 47 ++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 28 ++--------------------------
2 files changed, 48 insertions(+), 27 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 10dfb68..0e09630 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -4,6 +4,8 @@
#include "bisect.h"
#include "refs.h"
#include "dir.h"
+#include "argv-array.h"
+#include "run-command.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
@@ -13,11 +15,13 @@ static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static GIT_PATH_FUNC(git_path_bisect_run, "BISECT_RUN")
static GIT_PATH_FUNC(git_path_head_name, "head-name")
static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
+static GIT_PATH_FUNC(git_path_bisect_head, "BISECT_HEAD")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-clean-state"),
+ N_("git bisect--helper --bisect-reset [<commit>]"),
NULL
};
@@ -124,12 +128,47 @@ static int bisect_clean_state(void)
return result;
}
+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, &oid))
+ return error(_("'%s' is not a valid commit"), commit);
+ strbuf_addstr(&branch, commit);
+ }
+
+ if (!file_exists(git_path_bisect_head())) {
+ struct argv_array argv = ARGV_ARRAY_INIT;
+ argv_array_pushl(&argv, "checkout", branch.buf, "--", NULL);
+ if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
+ error(_("Could not check out original HEAD '%s'. Try "
+ "'git bisect reset <commit>'."), branch.buf);
+ strbuf_release(&branch);
+ argv_array_clear(&argv);
+ return -1;
+ }
+ argv_array_clear(&argv);
+ }
+
+ strbuf_release(&branch);
+ return bisect_clean_state();
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
WRITE_TERMS,
- BISECT_CLEAN_STATE
+ BISECT_CLEAN_STATE,
+ BISECT_RESET
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -139,6 +178,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
+ OPT_CMDMODE(0, "bisect-reset", &cmdmode,
+ N_("reset the bisection state"), BISECT_RESET),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -161,6 +202,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc != 0)
die(_("--bisect-clean-state requires no arguments"));
return bisect_clean_state();
+ case BISECT_RESET:
+ if (argc > 1)
+ die(_("--bisect-reset requires either zero or one arguments"));
+ return bisect_reset(argc ? argv[0] : NULL);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index bbc57d2..18580b7 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -409,35 +409,11 @@ bisect_visualize() {
eval '"$@"' --bisect -- $(cat "$GIT_DIR/BISECT_NAMES")
}
-bisect_reset() {
- test -s "$GIT_DIR/BISECT_START" || {
- gettextln "We are not bisecting."
- return
- }
- case "$#" in
- 0) branch=$(cat "$GIT_DIR/BISECT_START") ;;
- 1) git rev-parse --quiet --verify "$1^{commit}" >/dev/null || {
- invalid="$1"
- die "$(eval_gettext "'\$invalid' is not a valid commit")"
- }
- branch="$1" ;;
- *)
- usage ;;
- esac
-
- if ! test -f "$GIT_DIR/BISECT_HEAD" && ! git checkout "$branch" --
- then
- die "$(eval_gettext "Could not check out original HEAD '\$branch'.
-Try 'git bisect reset <commit>'.")"
- fi
- git bisect--helper --bisect-clean-state || exit
-}
-
bisect_replay () {
file="$1"
test "$#" -eq 1 || die "$(gettext "No logfile given")"
test -r "$file" || die "$(eval_gettext "cannot read \$file for replaying")"
- bisect_reset
+ git bisect--helper --bisect-reset || exit
while read git bisect command rev
do
test "$git $bisect" = "git bisect" || test "$git" = "git-bisect" || continue
@@ -627,7 +603,7 @@ case "$#" in
visualize|view)
bisect_visualize "$@" ;;
reset)
- bisect_reset "$@" ;;
+ git bisect--helper --bisect-reset "$@" ;;
replay)
bisect_replay "$@" ;;
log)
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [RFC/PATCH v11 11/13] bisect--helper: `bisect_next_check` shell function in C
2016-07-31 9:21 ` [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
` (9 preceding siblings ...)
2016-07-31 9:21 ` [RFC/PATCH v11 07/13] bisect--helper: `bisect_reset` " Pranit Bauva
@ 2016-07-31 9:21 ` Pranit Bauva
2016-08-02 19:17 ` Junio C Hamano
2016-07-31 9:21 ` [RFC/PATCH v11 13/13] bisect--helper: `bisect_start` shell function partially " Pranit Bauva
` (2 subsequent siblings)
13 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-07-31 9:21 UTC (permalink / raw)
To: git
Reimplement `bisect_next_check` shell function in C and add
`bisect-next-check` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Using `--bisect-next-check` is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other methods.
bisect_voc() is removed as it is redundant and does not serve any useful
purpose. We are better off specifying "bad|new" "good|old" as and when
we require in bisect_next_check().
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 79 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 60 +++---------------------------------
2 files changed, 82 insertions(+), 57 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 99c9f90..71f4cf0 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -6,6 +6,7 @@
#include "dir.h"
#include "argv-array.h"
#include "run-command.h"
+#include "prompt.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
@@ -24,6 +25,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
+ N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
NULL
};
@@ -292,6 +294,71 @@ static int check_and_set_terms(struct bisect_terms *terms, const char *cmd)
return 0;
}
+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 0;
+}
+
+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.buf);
+ char *good_glob = xstrfmt("%s*", terms->term_good.buf);
+
+ if (ref_exists(bad_ref))
+ missing_bad = 0;
+ free(bad_ref);
+
+ for_each_glob_ref_in(mark_good, good_glob, "refs/bisect/",
+ (void *) &missing_good);
+ free(good_glob);
+
+ if (!missing_good && !missing_bad)
+ return 0;
+
+ if (!current_term)
+ return -1;
+
+ if (missing_good && !missing_bad && current_term &&
+ !strcmp(current_term, terms->term_good.buf)) {
+ char *yesno;
+ /*
+ * have bad (or new) but not good (or old). We could bisect
+ * although this is less optimum.
+ */
+ fprintf(stderr, "Warning: bisecting only with a %s commit\n",
+ terms->term_bad.buf);
+ if (!isatty(0))
+ return 0;
+ /*
+ * 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"))
+ return -1;
+ return 0;
+ }
+ if (!is_empty_or_missing_file(git_path_bisect_start()))
+ return error(_("You need to give me at least one good|old and "
+ "bad|new revision. You can use \"git bisect "
+ "bad|new\" and \"git bisect good|old\" for "
+ "that. \n"));
+ else
+ return error(_("You need to start by \"git bisect start\". "
+ "You then need to give me at least one good|"
+ "old and bad|new revision. You can use \"git "
+ "bisect bad|new\" and \"git bisect good|old\" "
+ " for that.\n"));
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -301,7 +368,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_RESET,
CHECK_EXPECTED_REVS,
BISECT_WRITE,
- CHECK_AND_SET_TERMS
+ CHECK_AND_SET_TERMS,
+ BISECT_NEXT_CHECK
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -319,6 +387,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
+ OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
+ N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -369,6 +439,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
strbuf_addstr(&terms.term_bad, argv[2]);
res = check_and_set_terms(&terms, argv[0]);
break;
+ case BISECT_NEXT_CHECK:
+ if (argc != 2 && argc != 3)
+ die(_("--bisect-next-check requires 2 or 3 arguments"));
+ strbuf_addstr(&terms.term_good, argv[0]);
+ strbuf_addstr(&terms.term_bad, argv[1]);
+ res = bisect_next_check(&terms, argc == 3 ? argv[2] : NULL);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index a41e69b..c2d6319 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -271,59 +271,14 @@ bisect_state() {
bisect_auto_next
}
-bisect_next_check() {
- missing_good= missing_bad=
- git show-ref -q --verify refs/bisect/$TERM_BAD || missing_bad=t
- test -n "$(git for-each-ref "refs/bisect/$TERM_GOOD-*")" || missing_good=t
-
- case "$missing_good,$missing_bad,$1" in
- ,,*)
- : have both $TERM_GOOD and $TERM_BAD - ok
- ;;
- *,)
- # do not have both but not asked to fail - just report.
- false
- ;;
- t,,"$TERM_GOOD")
- # have bad (or new) but not good (or old). we could bisect although
- # this is less optimum.
- eval_gettextln "Warning: bisecting only with a \$TERM_BAD commit." >&2
- if test -t 0
- then
- # TRANSLATORS: Make sure to include [Y] and [n] in your
- # translation. The program will only accept English input
- # at this point.
- gettext "Are you sure [Y/n]? " >&2
- read yesno
- case "$yesno" in [Nn]*) exit 1 ;; esac
- fi
- : bisect without $TERM_GOOD...
- ;;
- *)
- bad_syn=$(bisect_voc bad)
- good_syn=$(bisect_voc good)
- if test -s "$GIT_DIR/BISECT_START"
- then
-
- eval_gettextln "You need to give me at least one \$bad_syn and one \$good_syn revision.
-(You can use \"git bisect \$bad_syn\" and \"git bisect \$good_syn\" for that.)" >&2
- else
- eval_gettextln "You need to start by \"git bisect start\".
-You then need to give me at least one \$good_syn and one \$bad_syn revision.
-(You can use \"git bisect \$bad_syn\" and \"git bisect \$good_syn\" for that.)" >&2
- fi
- exit 1 ;;
- esac
-}
-
bisect_auto_next() {
- bisect_next_check && bisect_next || :
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD && bisect_next || :
}
bisect_next() {
case "$#" in 0) ;; *) usage ;; esac
bisect_autostart
- bisect_next_check $TERM_GOOD
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD $TERM_GOOD|| exit
# Perform all bisection computation, display and checkout
git bisect--helper --next-all $(test -f "$GIT_DIR/BISECT_HEAD" && echo --no-checkout)
@@ -355,7 +310,7 @@ bisect_next() {
}
bisect_visualize() {
- bisect_next_check fail
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD fail || exit
if test $# = 0
then
@@ -409,7 +364,7 @@ bisect_replay () {
}
bisect_run () {
- bisect_next_check fail
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD fail || exit
while true
do
@@ -482,13 +437,6 @@ get_terms () {
fi
}
-bisect_voc () {
- case "$1" in
- bad) echo "bad|new" ;;
- good) echo "good|old" ;;
- esac
-}
-
bisect_terms () {
get_terms
if ! test -s "$GIT_DIR/BISECT_TERMS"
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [RFC/PATCH v11 12/13] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-07-31 9:21 ` [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
` (7 preceding siblings ...)
2016-07-31 9:21 ` [RFC/PATCH v11 10/13] bisect--helper: `check_and_set_terms` " Pranit Bauva
@ 2016-07-31 9:21 ` Pranit Bauva
2016-08-02 19:22 ` Junio C Hamano
2016-07-31 9:21 ` [RFC/PATCH v11 07/13] bisect--helper: `bisect_reset` " Pranit Bauva
` (4 subsequent siblings)
13 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-07-31 9:21 UTC (permalink / raw)
To: git
Reimplement the `get_terms` and `bisect_terms` shell function in C and
add `bisect-terms` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
In the shell version, the terms were identified by strings but in C
version its done by bit manipulation and passing the integer value to
the function.
Using `--bisect-terms` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other methods.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 74 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 35 ++---------------------
2 files changed, 75 insertions(+), 34 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 71f4cf0..81a16a5 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -8,6 +8,13 @@
#include "run-command.h"
#include "prompt.h"
+enum terms_defined {
+ TERM_BAD = 1,
+ TERM_GOOD = 2,
+ TERM_NEW = 4,
+ TERM_OLD = 8
+};
+
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
@@ -26,6 +33,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
+ N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
NULL
};
@@ -359,6 +367,43 @@ static int bisect_next_check(const struct bisect_terms *terms,
return 0;
}
+static int get_terms(struct bisect_terms *terms)
+{
+ FILE *fp;
+ int res;
+ fp = fopen(git_path_bisect_terms(), "r");
+ if (!fp)
+ return -1;
+
+ bisect_terms_reset(terms);
+ res = strbuf_getline(&terms->term_bad, fp) == EOF ||
+ strbuf_getline(&terms->term_good, fp) == EOF;
+
+ fclose(fp);
+ return res ? -1 : 0;
+}
+
+static int bisect_terms(struct bisect_terms *terms, int term_defined)
+{
+ if (get_terms(terms)) {
+ fprintf(stderr, "no terms defined\n");
+ return -1;
+ }
+ if (!term_defined) {
+ printf("Your current terms are %s for the old state\nand "
+ "%s for the new state.\n", terms->term_good.buf,
+ terms->term_bad.buf);
+ return 0;
+ }
+
+ if (term_defined == TERM_GOOD || term_defined == TERM_OLD)
+ printf("%s\n", terms->term_good.buf);
+ if (term_defined == TERM_BAD || term_defined == TERM_NEW)
+ printf("%s\n", terms->term_bad.buf);
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -369,9 +414,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
CHECK_EXPECTED_REVS,
BISECT_WRITE,
CHECK_AND_SET_TERMS,
- BISECT_NEXT_CHECK
+ BISECT_NEXT_CHECK,
+ BISECT_TERMS
} cmdmode = 0;
int no_checkout = 0, res = 0;
+ enum terms_defined term_defined = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
@@ -389,6 +436,16 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
+ OPT_CMDMODE(0, "bisect-terms", &cmdmode,
+ N_("print out the bisect terms"), BISECT_TERMS),
+ OPT_BIT(0, "term-bad", &term_defined,
+ N_("show the bad term"), TERM_BAD),
+ OPT_BIT(0, "term-good", &term_defined,
+ N_("show the good term"), TERM_GOOD),
+ OPT_BIT(0, "term-new", &term_defined,
+ N_("show the new term"), TERM_NEW),
+ OPT_BIT(0, "term-old", &term_defined,
+ N_("show the old term"), TERM_OLD),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -399,6 +456,16 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
argc = parse_options(argc, argv, prefix, options,
git_bisect_helper_usage, 0);
+ if (cmdmode != BISECT_TERMS && term_defined)
+ die(_("--term-bad, --term-good, --term-new and --term-old "
+ "can be used only with --bisect-terms"));
+
+ if (term_defined != 0 && term_defined != TERM_BAD &&
+ term_defined != TERM_GOOD && term_defined != TERM_NEW &&
+ term_defined != TERM_OLD)
+ die(_("only one option among --term-bad, --term-good, "
+ "--term-new and --term-old can be used."));
+
if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
@@ -446,6 +513,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
strbuf_addstr(&terms.term_bad, argv[1]);
res = bisect_next_check(&terms, argc == 3 ? argv[2] : NULL);
break;
+ case BISECT_TERMS:
+ if (argc > 1)
+ die(_("--bisect-terms requires 0 or 1 argument"));
+ res = bisect_terms(&terms, term_defined);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index c2d6319..aea97c5f 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -355,7 +355,7 @@ bisect_replay () {
"$TERM_GOOD"|"$TERM_BAD"|skip)
git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
terms)
- bisect_terms $rev ;;
+ git bisect--helper --bisect-terms $rev || exit;;
*)
die "$(gettext "?? what are you talking about?")" ;;
esac
@@ -437,37 +437,6 @@ get_terms () {
fi
}
-bisect_terms () {
- get_terms
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- die "$(gettext "no terms defined")"
- fi
- case "$#" in
- 0)
- gettextln "Your current terms are $TERM_GOOD for the old state
-and $TERM_BAD for the new state."
- ;;
- 1)
- arg=$1
- case "$arg" in
- --term-good|--term-old)
- printf '%s\n' "$TERM_GOOD"
- ;;
- --term-bad|--term-new)
- printf '%s\n' "$TERM_BAD"
- ;;
- *)
- die "$(eval_gettext "invalid argument \$arg for 'git bisect terms'.
-Supported options are: --term-good|--term-old and --term-bad|--term-new.")"
- ;;
- esac
- ;;
- *)
- usage ;;
- esac
-}
-
case "$#" in
0)
usage ;;
@@ -498,7 +467,7 @@ case "$#" in
run)
bisect_run "$@" ;;
terms)
- bisect_terms "$@" ;;
+ git bisect--helper --bisect-terms "$@" || exit;;
*)
usage ;;
esac
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [RFC/PATCH v11 08/13] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C
2016-07-31 9:21 ` [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
@ 2016-07-31 9:21 ` Pranit Bauva
2016-08-02 18:46 ` Junio C Hamano
2016-07-31 9:21 ` [RFC/PATCH v11 09/13] bisect--helper: `bisect_write` " Pranit Bauva
` (12 subsequent siblings)
13 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-07-31 9:21 UTC (permalink / raw)
To: git
Reimplement `is_expected_rev` & `check_expected_revs` shell function in
C and add a `--check-expected-revs` subcommand to `git bisect--helper` to
call it from git-bisect.sh .
Using `--check-expected-revs` subcommand is a temporary measure to port
shell functions to C so as to use the existing test suite. As more
functions are ported, this subcommand would be retired and will be
called by some other method.
Helped-by: Eric Sunshine <sunshine@sunshineco.com>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 33 ++++++++++++++++++++++++++++++++-
git-bisect.sh | 20 ++------------------
2 files changed, 34 insertions(+), 19 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 0e09630..c0f7091 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -162,13 +162,40 @@ static int bisect_reset(const char *commit)
return bisect_clean_state();
}
+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) >= 0) {
+ strbuf_trim(&actual_hex);
+ res = !strcmp(actual_hex.buf, expected_hex);
+ }
+ strbuf_release(&actual_hex);
+ return res;
+}
+
+static int check_expected_revs(const char **revs, int rev_nr)
+{
+ int i;
+
+ for (i = 0; i < rev_nr; i++) {
+ if (!is_expected_rev(revs[i])) {
+ remove_path(git_path_bisect_ancestors_ok());
+ remove_path(git_path_bisect_expected_rev());
+ return 0;
+ }
+ }
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
WRITE_TERMS,
BISECT_CLEAN_STATE,
- BISECT_RESET
+ BISECT_RESET,
+ CHECK_EXPECTED_REVS
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -180,6 +207,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
N_("reset the bisection state"), BISECT_RESET),
+ OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
+ N_("check for expected revs"), CHECK_EXPECTED_REVS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -206,6 +235,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc > 1)
die(_("--bisect-reset requires either zero or one arguments"));
return bisect_reset(argc ? argv[0] : NULL);
+ case CHECK_EXPECTED_REVS:
+ return check_expected_revs(argv, argc);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 18580b7..4f6545e 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -238,22 +238,6 @@ bisect_write() {
test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
}
-is_expected_rev() {
- test -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
- test "$1" = $(cat "$GIT_DIR/BISECT_EXPECTED_REV")
-}
-
-check_expected_revs() {
- for _rev in "$@"; do
- if ! is_expected_rev "$_rev"
- then
- rm -f "$GIT_DIR/BISECT_ANCESTORS_OK"
- rm -f "$GIT_DIR/BISECT_EXPECTED_REV"
- return
- fi
- done
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -280,7 +264,7 @@ bisect_state() {
rev=$(git rev-parse --verify $(bisect_head)) ||
die "$(gettext "Bad rev input: $(bisect_head)")"
bisect_write "$state" "$rev"
- check_expected_revs "$rev" ;;
+ git bisect--helper --check-expected-revs "$rev" ;;
2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
shift
hash_list=''
@@ -294,7 +278,7 @@ bisect_state() {
do
bisect_write "$state" "$rev"
done
- check_expected_revs $hash_list ;;
+ git bisect--helper --check-expected-revs $hash_list ;;
*,"$TERM_BAD")
die "$(eval_gettext "'git bisect \$TERM_BAD' can take only one argument.")" ;;
*)
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [RFC/PATCH v11 09/13] bisect--helper: `bisect_write` shell function in C
2016-07-31 9:21 ` [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
2016-07-31 9:21 ` [RFC/PATCH v11 08/13] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C Pranit Bauva
@ 2016-07-31 9:21 ` Pranit Bauva
2016-08-02 20:25 ` Junio C Hamano
2016-07-31 9:21 ` [RFC/PATCH v11 02/13] bisect: rewrite `check_term_format` " Pranit Bauva
` (11 subsequent siblings)
13 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-07-31 9:21 UTC (permalink / raw)
To: git
Reimplement the `bisect_write` shell function in C and add a
`bisect-write` subcommand to `git bisect--helper` to call it from
git-bisect.sh
Using `--bisect-write` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other methods.
Note: bisect_write() uses two variables namely TERM_GOOD and TERM_BAD
from the global shell script thus we need to pass it to the subcommand
using the arguments. We then store them in a struct bisect_terms and
pass the memory address around functions.
This patch also introduces new methods namely bisect_state_init() and
bisect_terms_release() for easy memory management for the struct
bisect_terms.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 97 ++++++++++++++++++++++++++++++++++++++++++++----
git-bisect.sh | 25 ++-----------
2 files changed, 94 insertions(+), 28 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index c0f7091..70b953f 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -22,9 +22,27 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-clean-state"),
N_("git bisect--helper --bisect-reset [<commit>]"),
+ N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
NULL
};
+struct bisect_terms {
+ struct strbuf term_good;
+ struct strbuf term_bad;
+};
+
+static void bisect_terms_init(struct bisect_terms *terms)
+{
+ strbuf_init(&terms->term_good, 0);
+ strbuf_init(&terms->term_bad, 0);
+}
+
+static void bisect_terms_release(struct bisect_terms *terms)
+{
+ strbuf_release(&terms->term_good);
+ strbuf_release(&terms->term_bad);
+}
+
/*
* Check whether the string `term` belongs to the set of strings
* included in the variable arguments.
@@ -188,6 +206,52 @@ static int check_expected_revs(const char **revs, int rev_nr)
return 0;
}
+static int bisect_write(const char *state, const char *rev,
+ const struct bisect_terms *terms, int nolog)
+{
+ struct strbuf tag = STRBUF_INIT;
+ struct strbuf commit_name = STRBUF_INIT;
+ struct object_id oid;
+ struct commit *commit;
+ struct pretty_print_context pp = {0};
+ FILE *fp;
+
+ if (!strcmp(state, terms->term_bad.buf))
+ strbuf_addf(&tag, "refs/bisect/%s", state);
+ else if (one_of(state, terms->term_good.buf, "skip", NULL))
+ strbuf_addf(&tag, "refs/bisect/%s-%s", state, rev);
+ else
+ return error(_("Bad bisect_write argument: %s"), state);
+
+ if (get_oid(rev, &oid)) {
+ strbuf_release(&tag);
+ return error(_("couldn't get the oid of the rev '%s'"), rev);
+ }
+
+ if (update_ref(NULL, tag.buf, oid.hash, NULL, 0,
+ UPDATE_REFS_MSG_ON_ERR)) {
+ strbuf_release(&tag);
+ return -1;
+ }
+ strbuf_release(&tag);
+
+ fp = fopen(git_path_bisect_log(), "a");
+ if (!fp)
+ return error_errno(_("couldn't open the file '%s'"), git_path_bisect_log());
+
+ commit = lookup_commit_reference(oid.hash);
+ format_commit_message(commit, "%s", &commit_name, &pp);
+ fprintf(fp, "# %s: [%s] %s\n", state, sha1_to_hex(oid.hash),
+ commit_name.buf);
+ strbuf_release(&commit_name);
+
+ if (!nolog)
+ fprintf(fp, "git bisect %s %s\n", state, rev);
+
+ fclose(fp);
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -195,9 +259,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
WRITE_TERMS,
BISECT_CLEAN_STATE,
BISECT_RESET,
- CHECK_EXPECTED_REVS
+ CHECK_EXPECTED_REVS,
+ BISECT_WRITE
} cmdmode = 0;
- int no_checkout = 0;
+ int no_checkout = 0, res = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
@@ -209,10 +274,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("reset the bisection state"), BISECT_RESET),
OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
N_("check for expected revs"), CHECK_EXPECTED_REVS),
+ OPT_CMDMODE(0, "bisect-write", &cmdmode,
+ N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
};
+ struct bisect_terms terms;
+ bisect_terms_init(&terms);
argc = parse_options(argc, argv, prefix, options,
git_bisect_helper_usage, 0);
@@ -221,24 +290,38 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
usage_with_options(git_bisect_helper_usage, options);
switch (cmdmode) {
+ int nolog;
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
case WRITE_TERMS:
if (argc != 2)
die(_("--write-terms requires two arguments"));
- return write_terms(argv[0], argv[1]);
+ res = write_terms(argv[0], argv[1]);
+ break;
case BISECT_CLEAN_STATE:
if (argc != 0)
die(_("--bisect-clean-state requires no arguments"));
- return bisect_clean_state();
+ res = bisect_clean_state();
+ break;
case BISECT_RESET:
if (argc > 1)
die(_("--bisect-reset requires either zero or one arguments"));
- return bisect_reset(argc ? argv[0] : NULL);
+ res = bisect_reset(argc ? argv[0] : NULL);
+ break;
case CHECK_EXPECTED_REVS:
- return check_expected_revs(argv, argc);
+ res = check_expected_revs(argv, argc);
+ break;
+ case BISECT_WRITE:
+ if (argc != 4 && argc != 5)
+ die(_("--bisect-write requires either 4 or 5 arguments"));
+ nolog = (argc == 5) && !strcmp(argv[4], "nolog");
+ strbuf_addstr(&terms.term_good, argv[2]);
+ strbuf_addstr(&terms.term_bad, argv[3]);
+ res = bisect_write(argv[0], argv[1], &terms, nolog);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
- return 0;
+ bisect_terms_release(&terms);
+ return res;
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 4f6545e..b9896a4 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -145,7 +145,7 @@ bisect_start() {
0) state=$TERM_BAD ; bad_seen=1 ;;
*) state=$TERM_GOOD ;;
esac
- eval="$eval bisect_write '$state' '$rev' 'nolog' &&"
+ eval="$eval git bisect--helper --bisect-write '$state' '$rev' '$TERM_GOOD' '$TERM_BAD' 'nolog' &&"
done
#
# Verify HEAD.
@@ -221,23 +221,6 @@ bisect_start() {
trap '-' 0
}
-bisect_write() {
- state="$1"
- rev="$2"
- nolog="$3"
- case "$state" in
- "$TERM_BAD")
- tag="$state" ;;
- "$TERM_GOOD"|skip)
- tag="$state"-"$rev" ;;
- *)
- die "$(eval_gettext "Bad bisect_write argument: \$state")" ;;
- esac
- git update-ref "refs/bisect/$tag" "$rev" || exit
- echo "# $state: $(git show-branch $rev)" >>"$GIT_DIR/BISECT_LOG"
- test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -263,7 +246,7 @@ bisect_state() {
1,"$TERM_BAD"|1,"$TERM_GOOD"|1,skip)
rev=$(git rev-parse --verify $(bisect_head)) ||
die "$(gettext "Bad rev input: $(bisect_head)")"
- bisect_write "$state" "$rev"
+ git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
git bisect--helper --check-expected-revs "$rev" ;;
2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
shift
@@ -276,7 +259,7 @@ bisect_state() {
done
for rev in $hash_list
do
- bisect_write "$state" "$rev"
+ git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
done
git bisect--helper --check-expected-revs $hash_list ;;
*,"$TERM_BAD")
@@ -413,7 +396,7 @@ bisect_replay () {
cmd="bisect_start $rev"
eval "$cmd" ;;
"$TERM_GOOD"|"$TERM_BAD"|skip)
- bisect_write "$command" "$rev" ;;
+ git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
terms)
bisect_terms $rev ;;
*)
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [RFC/PATCH v11 02/13] bisect: rewrite `check_term_format` shell function in C
2016-07-31 9:21 ` [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
2016-07-31 9:21 ` [RFC/PATCH v11 08/13] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C Pranit Bauva
2016-07-31 9:21 ` [RFC/PATCH v11 09/13] bisect--helper: `bisect_write` " Pranit Bauva
@ 2016-07-31 9:21 ` Pranit Bauva
2016-08-02 17:31 ` Junio C Hamano
2016-07-31 9:21 ` [RFC/PATCH v11 03/13] bisect--helper: `write_terms` " Pranit Bauva
` (10 subsequent siblings)
13 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-07-31 9:21 UTC (permalink / raw)
To: git
Reimplement the `check_term_format` shell function in C and add
a `--check-term-format` subcommand to `git bisect--helper` to call it
from git-bisect.sh
Using `--check-term-format` subcommand is a temporary measure to port
shell function to C so as to use the existing test suite. As more
functions are ported, this subcommand will be retired and will
be called by some other method/subcommand. For eg. In conversion of
write_terms() of git-bisect.sh, the subcommand will be removed and
instead check_term_format() will be called in its C implementation while
a new subcommand will be introduced for write_terms().
Helped-by: Johannes Schindelein <Johannes.Schindelein@gmx.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 59 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 31 ++-----------------------
2 files changed, 60 insertions(+), 30 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 8111c91..48285d4 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -2,19 +2,72 @@
#include "cache.h"
#include "parse-options.h"
#include "bisect.h"
+#include "refs.h"
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
+ N_("git bisect--helper --check-term-format <term> <orig_term>"),
NULL
};
+/*
+ * Check whether the string `term` belongs to the set of strings
+ * included in the variable arguments.
+ */
+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",
+ "visualize", "replay", "log", "run", NULL))
+ 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;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
- enum { NEXT_ALL = 1 } cmdmode = 0;
+ enum {
+ NEXT_ALL = 1,
+ CHECK_TERM_FMT
+ } cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
+ OPT_CMDMODE(0, "check-term-format", &cmdmode,
+ N_("check format of the term"), CHECK_TERM_FMT),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -29,6 +82,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
switch (cmdmode) {
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
+ case CHECK_TERM_FMT:
+ if (argc != 2)
+ die(_("--check-term-format requires two arguments"));
+ return check_term_format(argv[0], argv[1]);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 5d1cb00..7d7965d 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -564,38 +564,11 @@ write_terms () {
then
die "$(gettext "please use two different terms")"
fi
- check_term_format "$TERM_BAD" bad
- check_term_format "$TERM_GOOD" good
+ git bisect--helper --check-term-format "$TERM_BAD" bad || exit
+ git bisect--helper --check-term-format "$TERM_GOOD" good || exit
printf '%s\n%s\n' "$TERM_BAD" "$TERM_GOOD" >"$GIT_DIR/BISECT_TERMS"
}
-check_term_format () {
- term=$1
- git check-ref-format refs/bisect/"$term" ||
- die "$(eval_gettext "'\$term' is not a valid term")"
- case "$term" in
- help|start|terms|skip|next|reset|visualize|replay|log|run)
- die "$(eval_gettext "can't use the builtin command '\$term' as a term")"
- ;;
- bad|new)
- if test "$2" != bad
- then
- # 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.
- die "$(eval_gettext "can't change the meaning of term '\$term'")"
- fi
- ;;
- good|old)
- if test "$2" != good
- then
- die "$(eval_gettext "can't change the meaning of term '\$term'")"
- fi
- ;;
- esac
-}
-
check_and_set_terms () {
cmd="$1"
case "$cmd" in
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [RFC/PATCH v11 10/13] bisect--helper: `check_and_set_terms` shell function in C
2016-07-31 9:21 ` [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
` (6 preceding siblings ...)
2016-07-31 9:21 ` [RFC/PATCH v11 04/13] bisect--helper: `bisect_clean_state` shell function in C Pranit Bauva
@ 2016-07-31 9:21 ` Pranit Bauva
2016-08-02 18:53 ` Junio C Hamano
2016-07-31 9:21 ` [RFC/PATCH v11 12/13] bisect--helper: `get_terms` & `bisect_terms` " Pranit Bauva
` (5 subsequent siblings)
13 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-07-31 9:21 UTC (permalink / raw)
To: git
Reimplement the `check_and_set_terms` shell function in C and add
`check-and-set-terms` subcommand to `git bisect--helper` to call it from
git-bisect.sh
Using `--check-and-set-terms` subcommand is a temporary measure to port
shell function in C so as to use the existing test suite. As more
functions are ported, this subcommand will be retired and will be called
by some other methods.
check_and_set_terms() sets and receives two global variables namely
TERM_GOOD and TERM_BAD in the shell script. Luckily the file BISECT_TERMS
also contains the value of those variables so its appropriate to evoke the
method get_terms() after calling the subcommand so that it retrieves the
value of TERM_GOOD and TERM_BAD from the file BISECT_TERMS. The two
global variables are passed as arguments to the subcommand.
Also introduce bisect_terms_reset() to empty the contents of `term_good`
and `term_bad` of `struct bisect_terms`.
Also introduce set_terms() to copy the `term_good` and `term_bad` into
`struct bisect_terms` and write it out to the file BISECT_TERMS.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 52 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 36 ++++-----------------------------
2 files changed, 55 insertions(+), 33 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 70b953f..99c9f90 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -23,6 +23,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-clean-state"),
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
+ N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
NULL
};
@@ -43,6 +44,12 @@ static void bisect_terms_release(struct bisect_terms *terms)
strbuf_release(&terms->term_bad);
}
+static void bisect_terms_reset(struct bisect_terms *term)
+{
+ strbuf_reset(&term->term_good);
+ strbuf_reset(&term->term_bad);
+}
+
/*
* Check whether the string `term` belongs to the set of strings
* included in the variable arguments.
@@ -252,6 +259,39 @@ static int bisect_write(const char *state, const char *rev,
return 0;
}
+static int set_terms(struct bisect_terms *terms, const char *bad,
+ const char *good)
+{
+ bisect_terms_reset(terms);
+ strbuf_addstr(&terms->term_good, good);
+ strbuf_addstr(&terms->term_bad, bad);
+ return write_terms(terms->term_bad.buf, terms->term_good.buf);
+}
+
+static int check_and_set_terms(struct bisect_terms *terms, const char *cmd)
+{
+ int no_term_file = is_empty_or_missing_file(git_path_bisect_terms());
+
+ if (one_of(cmd, "skip", "start", "terms", NULL))
+ return 0;
+
+ if (!no_term_file &&
+ strcmp(cmd, terms->term_bad.buf) &&
+ strcmp(cmd, terms->term_good.buf))
+ return error(_("Invalid command: you're currently in a "
+ "'%s' '%s' bisect"), terms->term_bad.buf,
+ terms->term_good.buf);
+
+ if (no_term_file) {
+ if (one_of(cmd, "bad", "good", NULL))
+ return set_terms(terms, "bad", "good");
+ if (one_of(cmd, "new", "old", NULL))
+ return set_terms(terms, "new", "old");
+ }
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -260,7 +300,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_CLEAN_STATE,
BISECT_RESET,
CHECK_EXPECTED_REVS,
- BISECT_WRITE
+ BISECT_WRITE,
+ CHECK_AND_SET_TERMS
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -276,6 +317,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check for expected revs"), CHECK_EXPECTED_REVS),
OPT_CMDMODE(0, "bisect-write", &cmdmode,
N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
+ OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
+ N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -319,6 +362,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
strbuf_addstr(&terms.term_bad, argv[3]);
res = bisect_write(argv[0], argv[1], &terms, nolog);
break;
+ case CHECK_AND_SET_TERMS:
+ if (argc != 3)
+ die(_("--check-and-set-terms requires 3 arguments"));
+ strbuf_addstr(&terms.term_good, argv[1]);
+ strbuf_addstr(&terms.term_bad, argv[2]);
+ res = check_and_set_terms(&terms, argv[0]);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index b9896a4..a41e69b 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -239,7 +239,8 @@ bisect_skip() {
bisect_state() {
bisect_autostart
state=$1
- check_and_set_terms $state
+ git bisect--helper --check-and-set-terms $state $TERM_GOOD $TERM_BAD || exit
+ get_terms
case "$#,$state" in
0,*)
die "$(gettext "Please call 'bisect_state' with at least one argument.")" ;;
@@ -390,7 +391,8 @@ bisect_replay () {
command="$bisect"
fi
get_terms
- check_and_set_terms "$command"
+ git bisect--helper --check-and-set-terms "$command" "$TERM_GOOD" "$TERM_BAD" || exit
+ get_terms
case "$command" in
start)
cmd="bisect_start $rev"
@@ -480,36 +482,6 @@ get_terms () {
fi
}
-check_and_set_terms () {
- cmd="$1"
- case "$cmd" in
- skip|start|terms) ;;
- *)
- if test -s "$GIT_DIR/BISECT_TERMS" && test "$cmd" != "$TERM_BAD" && test "$cmd" != "$TERM_GOOD"
- then
- die "$(eval_gettext "Invalid command: you're currently in a \$TERM_BAD/\$TERM_GOOD bisect.")"
- fi
- case "$cmd" in
- bad|good)
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- TERM_BAD=bad
- TERM_GOOD=good
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
- fi
- ;;
- new|old)
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- TERM_BAD=new
- TERM_GOOD=old
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
- fi
- ;;
- esac ;;
- esac
-}
-
bisect_voc () {
case "$1" in
bad) echo "bad|new" ;;
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [RFC/PATCH v11 13/13] bisect--helper: `bisect_start` shell function partially in C
2016-07-31 9:21 ` [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
` (10 preceding siblings ...)
2016-07-31 9:21 ` [RFC/PATCH v11 11/13] bisect--helper: `bisect_next_check` " Pranit Bauva
@ 2016-07-31 9:21 ` Pranit Bauva
2016-08-02 20:19 ` Junio C Hamano
2016-08-02 17:25 ` [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Junio C Hamano
2016-08-10 21:57 ` [PATCH v12 " Pranit Bauva
13 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-07-31 9:21 UTC (permalink / raw)
To: git
Reimplement the `bisect_start` shell function partially in C and add
`bisect-start` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
The last part is not converted because it calls another shell function.
`bisect_start` shell function will be completed after the `bisect_next`
shell function is ported in C.
Using `--bisect-start` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other methods.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
This patch contains a small bug. The option handling for `--term-good`
and `--term-bad` needs to be decided as it is now shared between
`--bisect-terms` and `--bisect-start` and the later one also requires
string support. Can comments on which approach would seem the most
feasible? Here[1] is a normal output of t6030 and here[2] is a verbose
output of [2].
[1]: http://paste.ubuntu.com/21252069/
[2]: http://paste.ubuntu.com/21252140/
---
builtin/bisect--helper.c | 232 ++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 132 +--------------------------
2 files changed, 232 insertions(+), 132 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 81a16a5..ab18786 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -404,6 +404,228 @@ static int bisect_terms(struct bisect_terms *terms, int term_defined)
return 0;
}
+static int bisect_start(struct bisect_terms *terms, int no_checkout,
+ const char **argv, int argc)
+{
+ int i, j, has_double_dash = 0, must_write_terms = 0, bad_seen = 0;
+ int flag;
+ struct string_list revs = STRING_LIST_INIT_DUP;
+ struct string_list states = STRING_LIST_INIT_DUP;
+ struct strbuf start_head = STRBUF_INIT;
+ const char *head;
+ unsigned char sha1[20];
+ FILE *fp;
+ struct object_id oid;
+
+ if (is_bare_repository())
+ no_checkout = 1;
+
+ for(i = 0; i < argc; i++) {
+ if (!strcmp(argv[i], "--")) {
+ has_double_dash = 1;
+ break;
+ }
+ if (!strcmp(argv[i], "--term-good")) {
+ must_write_terms = 1;
+ strbuf_reset(&terms->term_good);
+ strbuf_addstr(&terms->term_good, argv[++i]);
+ break;
+ }
+ if (!strcmp(argv[i], "--term-bad")) {
+ must_write_terms = 1;
+ strbuf_reset(&terms->term_bad);
+ strbuf_addstr(&terms->term_bad, argv[++i]);
+ break;
+ }
+ if (starts_with(argv[i], "--") &&
+ !one_of(argv[i], "--term-good", "--term-bad", NULL)) {
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ die(_("unrecognised option: '%s'"), argv[i]);
+ }
+ if (get_oid(argv[i], &oid) || has_double_dash) {
+ string_list_clear(&revs, 0);
+ string_list_clear(&revs, 0);
+ die(_("'%s' does not appear to be a valid revision"), argv[i]);
+ }
+ else
+ string_list_append(&revs, oid_to_hex(&oid));
+ }
+
+ for (j = 0; j < revs.nr; j++) {
+ struct strbuf state = STRBUF_INIT;
+ /*
+ * 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.
+ */
+ must_write_terms = 1;
+
+ if (bad_seen)
+ strbuf_addstr(&state, terms->term_good.buf);
+ else {
+ bad_seen = 1;
+ strbuf_addstr(&state, terms->term_bad.buf);
+ }
+ string_list_append(&states, state.buf);
+ strbuf_release(&state);
+ }
+
+ /*
+ * Verify HEAD
+ */
+ head = resolve_ref_unsafe("HEAD", 0, sha1, &flag);
+ if (!head) {
+ if (get_sha1("HEAD", sha1)) {
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ die(_("Bad HEAD - I need a HEAD"));
+ }
+ }
+ 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) {
+ struct argv_array argv = ARGV_ARRAY_INIT;
+ argv_array_pushl(&argv, "checkout", start_head.buf,
+ "--", NULL);
+ if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
+ error(_("checking out '%s' failed. Try again."),
+ start_head.buf);
+ strbuf_release(&start_head);
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ return -1;
+ }
+ }
+ } else {
+ if (starts_with(head, "refs/head/") || !get_oid(head, &oid)) {
+ /*
+ * 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())) {
+ strbuf_release(&start_head);
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ die(_("won't bisect on cg-seek'ed tree"));
+ }
+ if (starts_with(head, "refs/heads/")) {
+ strbuf_reset(&start_head);
+ strbuf_addstr(&start_head, head + 11);
+ }
+ else {
+ strbuf_reset(&start_head);
+ strbuf_addstr(&start_head, sha1_to_hex(sha1));
+ }
+ } else {
+ strbuf_release(&start_head);
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ die(_("Bad HEAD - strange symbolic ref"));
+ }
+ }
+
+ /*
+ * Get rid of any old bisect state.
+ */
+ if (bisect_clean_state()) {
+ return -1;
+ }
+
+ /*
+ * Write new start state
+ */
+ fp = fopen(git_path_bisect_start(), "w");
+ if (!fp) {
+ bisect_clean_state();
+ strbuf_release(&start_head);
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ return -1;
+ }
+ if (!fprintf(fp, "%s\n", start_head.buf)) {
+ fclose(fp);
+ bisect_clean_state();
+ strbuf_release(&start_head);
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ return -1;
+ }
+ fclose(fp);
+
+ if (no_checkout) {
+ get_oid(start_head.buf, &oid);
+ if (update_ref(NULL, "BISECT_HEAD", oid.hash, NULL, 0,
+ UPDATE_REFS_MSG_ON_ERR)) {
+ bisect_clean_state();
+ strbuf_release(&start_head);
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ return -1;
+ }
+ }
+ strbuf_release(&start_head);
+ fp = fopen(git_path_bisect_names(), "w");
+
+ for (; i < argc; i++) {
+ if (!fprintf(fp, "%s ", argv[i])) {
+ fclose(fp);
+ bisect_clean_state();
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ return -1;
+ }
+ }
+ fclose(fp);
+
+ for (j = 0; j < states.nr; j ++) {
+ if (bisect_write(states.items[j].string,
+ revs.items[j].string, terms, 1)) {
+ bisect_clean_state();
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ return -1;
+ }
+ }
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+
+ if (must_write_terms)
+ if (write_terms(terms->term_bad.buf, terms->term_good.buf)) {
+ bisect_clean_state();
+ return -1;
+ }
+
+ fp = fopen(git_path_bisect_log(), "a");
+ if (!fp) {
+ bisect_clean_state();
+ return -1;
+ }
+ if (!fprintf(fp, "git bisect start")) {
+ bisect_clean_state();
+ return -1;
+ }
+ for (i = 0; i < argc; i++) {
+ if (!fprintf(fp, " '%s'", argv[i])) {
+ fclose(fp);
+ bisect_clean_state();
+ return -1;
+ }
+ }
+ if (!fprintf(fp, "\n")) {
+ fclose(fp);
+ bisect_clean_state();
+ return -1;
+ }
+ fclose(fp);
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -415,7 +637,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_WRITE,
CHECK_AND_SET_TERMS,
BISECT_NEXT_CHECK,
- BISECT_TERMS
+ BISECT_TERMS,
+ BISECT_START
} cmdmode = 0;
int no_checkout = 0, res = 0;
enum terms_defined term_defined = 0;
@@ -446,6 +669,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("show the new term"), TERM_NEW),
OPT_BIT(0, "term-old", &term_defined,
N_("show the old term"), TERM_OLD),
+ OPT_CMDMODE(0, "bisect-start", &cmdmode,
+ N_("start the bisect session"), BISECT_START),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -518,6 +743,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
die(_("--bisect-terms requires 0 or 1 argument"));
res = bisect_terms(&terms, term_defined);
break;
+ case BISECT_START:
+ strbuf_addstr(&terms.term_good, "good");
+ strbuf_addstr(&terms.term_bad, "bad");
+ res = bisect_start(&terms, no_checkout, argv, argc);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index aea97c5f..51d0a71 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -72,122 +72,7 @@ bisect_autostart() {
}
bisect_start() {
- #
- # Check for one bad and then some good revisions.
- #
- has_double_dash=0
- for arg; do
- case "$arg" in --) has_double_dash=1; break ;; esac
- done
- orig_args=$(git rev-parse --sq-quote "$@")
- bad_seen=0
- eval=''
- must_write_terms=0
- revs=''
- if test "z$(git rev-parse --is-bare-repository)" != zfalse
- then
- mode=--no-checkout
- else
- mode=''
- fi
- while [ $# -gt 0 ]; do
- arg="$1"
- case "$arg" in
- --)
- shift
- break
- ;;
- --no-checkout)
- mode=--no-checkout
- shift ;;
- --term-good|--term-old)
- shift
- must_write_terms=1
- TERM_GOOD=$1
- shift ;;
- --term-good=*|--term-old=*)
- must_write_terms=1
- TERM_GOOD=${1#*=}
- shift ;;
- --term-bad|--term-new)
- shift
- must_write_terms=1
- TERM_BAD=$1
- shift ;;
- --term-bad=*|--term-new=*)
- must_write_terms=1
- TERM_BAD=${1#*=}
- shift ;;
- --*)
- die "$(eval_gettext "unrecognised option: '\$arg'")" ;;
- *)
- rev=$(git rev-parse -q --verify "$arg^{commit}") || {
- test $has_double_dash -eq 1 &&
- die "$(eval_gettext "'\$arg' does not appear to be a valid revision")"
- break
- }
- revs="$revs $rev"
- shift
- ;;
- esac
- done
-
- for rev in $revs
- do
- # 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.
- must_write_terms=1
-
- case $bad_seen in
- 0) state=$TERM_BAD ; bad_seen=1 ;;
- *) state=$TERM_GOOD ;;
- esac
- eval="$eval git bisect--helper --bisect-write '$state' '$rev' '$TERM_GOOD' '$TERM_BAD' 'nolog' &&"
- done
- #
- # Verify HEAD.
- #
- head=$(GIT_DIR="$GIT_DIR" git symbolic-ref -q HEAD) ||
- head=$(GIT_DIR="$GIT_DIR" git rev-parse --verify HEAD) ||
- die "$(gettext "Bad HEAD - I need a HEAD")"
-
- #
- # Check if we are bisecting.
- #
- start_head=''
- if test -s "$GIT_DIR/BISECT_START"
- then
- # Reset to the rev from where we started.
- start_head=$(cat "$GIT_DIR/BISECT_START")
- if test "z$mode" != "z--no-checkout"
- then
- git checkout "$start_head" -- ||
- die "$(eval_gettext "Checking out '\$start_head' failed. Try 'git bisect reset <valid-branch>'.")"
- fi
- else
- # Get rev from where we start.
- case "$head" in
- refs/heads/*|$_x40)
- # This error message should only be triggered by
- # cogito usage, and cogito users should understand
- # it relates to cg-seek.
- [ -s "$GIT_DIR/head-name" ] &&
- die "$(gettext "won't bisect on cg-seek'ed tree")"
- start_head="${head#refs/heads/}"
- ;;
- *)
- die "$(gettext "Bad HEAD - strange symbolic ref")"
- ;;
- esac
- fi
-
- #
- # Get rid of any old bisect state.
- #
- git bisect--helper --bisect-clean-state || exit
+ git bisect--helper --bisect-start $@ || exit
#
# Change state.
@@ -198,21 +83,6 @@ bisect_start() {
#
trap 'git bisect--helper --bisect-clean-state' 0
trap 'exit 255' 1 2 3 15
-
- #
- # Write new start state.
- #
- echo "$start_head" >"$GIT_DIR/BISECT_START" && {
- test "z$mode" != "z--no-checkout" ||
- git update-ref --no-deref BISECT_HEAD "$start_head"
- } &&
- git rev-parse --sq-quote "$@" >"$GIT_DIR/BISECT_NAMES" &&
- eval "$eval true" &&
- if test $must_write_terms -eq 1
- then
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD"
- fi &&
- echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
#
# Check if we can proceed to the next bisect state.
#
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [RFC/PATCH v11 04/13] bisect--helper: `bisect_clean_state` shell function in C
2016-07-31 9:21 ` [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
` (5 preceding siblings ...)
2016-07-31 9:21 ` [RFC/PATCH v11 06/13] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
@ 2016-07-31 9:21 ` Pranit Bauva
2016-08-02 17:46 ` Junio C Hamano
2016-07-31 9:21 ` [RFC/PATCH v11 10/13] bisect--helper: `check_and_set_terms` " Pranit Bauva
` (6 subsequent siblings)
13 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-07-31 9:21 UTC (permalink / raw)
To: git
Reimplement `bisect_clean_state` shell function in C and add a
`bisect-clean-state` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Using `--bisect-clean-state` subcommand is a measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by
bisect_reset() and bisect_start().
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 55 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 26 +++--------------------
2 files changed, 57 insertions(+), 24 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 965bcc1..10dfb68 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -3,12 +3,21 @@
#include "parse-options.h"
#include "bisect.h"
#include "refs.h"
+#include "dir.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
+static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
+static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
+static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
+static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
+static GIT_PATH_FUNC(git_path_bisect_run, "BISECT_RUN")
+static GIT_PATH_FUNC(git_path_head_name, "head-name")
+static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
+ N_("git bisect--helper --bisect-clean-state"),
NULL
};
@@ -78,11 +87,49 @@ static int write_terms(const char *bad, const char *good)
return (res < 0) ? -1 : 0;
}
+static int mark_for_removal(const char *refname, const struct object_id *oid,
+ int flag, void *cb_data)
+{
+ struct string_list *refs = cb_data;
+ char *ref = xstrfmt("refs/bisect/%s", refname);
+ string_list_append(refs, ref);
+ return 0;
+}
+
+static int bisect_clean_state(void)
+{
+ int result = 0;
+
+ /* There may be some refs packed during bisection */
+ struct string_list refs_for_removal = STRING_LIST_INIT_NODUP;
+ for_each_ref_in("refs/bisect/", mark_for_removal, (void *) &refs_for_removal);
+ string_list_append(&refs_for_removal, xstrdup("BISECT_HEAD"));
+ result = delete_refs(&refs_for_removal);
+ refs_for_removal.strdup_strings = 1;
+ string_list_clear(&refs_for_removal, 0);
+ remove_path(git_path_bisect_expected_rev());
+ remove_path(git_path_bisect_ancestors_ok());
+ remove_path(git_path_bisect_log());
+ remove_path(git_path_bisect_names());
+ remove_path(git_path_bisect_run());
+ remove_path(git_path_bisect_terms());
+ /* Cleanup head-name if it got left by an old version of git-bisect */
+ remove_path(git_path_head_name());
+ /*
+ * Cleanup BISECT_START last to support the --no-checkout option
+ * introduced in the commit 4796e823a.
+ */
+ remove_path(git_path_bisect_start());
+
+ return result;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
- WRITE_TERMS
+ WRITE_TERMS,
+ BISECT_CLEAN_STATE
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -90,6 +137,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("perform 'git bisect next'"), NEXT_ALL),
OPT_CMDMODE(0, "write-terms", &cmdmode,
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
+ OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
+ N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -108,6 +157,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc != 2)
die(_("--write-terms requires two arguments"));
return write_terms(argv[0], argv[1]);
+ case BISECT_CLEAN_STATE:
+ if (argc != 0)
+ die(_("--bisect-clean-state requires no arguments"));
+ return bisect_clean_state();
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index cd39bd0..bbc57d2 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -187,7 +187,7 @@ bisect_start() {
#
# Get rid of any old bisect state.
#
- bisect_clean_state || exit
+ git bisect--helper --bisect-clean-state || exit
#
# Change state.
@@ -196,7 +196,7 @@ bisect_start() {
# We have to trap this to be able to clean up using
# "bisect_clean_state".
#
- trap 'bisect_clean_state' 0
+ trap 'git bisect--helper --bisect-clean-state' 0
trap 'exit 255' 1 2 3 15
#
@@ -430,27 +430,7 @@ bisect_reset() {
die "$(eval_gettext "Could not check out original HEAD '\$branch'.
Try 'git bisect reset <commit>'.")"
fi
- bisect_clean_state
-}
-
-bisect_clean_state() {
- # There may be some refs packed during bisection.
- git for-each-ref --format='%(refname) %(objectname)' refs/bisect/\* |
- while read ref hash
- do
- git update-ref -d $ref $hash || exit
- done
- rm -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
- rm -f "$GIT_DIR/BISECT_ANCESTORS_OK" &&
- rm -f "$GIT_DIR/BISECT_LOG" &&
- rm -f "$GIT_DIR/BISECT_NAMES" &&
- rm -f "$GIT_DIR/BISECT_RUN" &&
- rm -f "$GIT_DIR/BISECT_TERMS" &&
- # Cleanup head-name if it got left by an old version of git-bisect
- rm -f "$GIT_DIR/head-name" &&
- git update-ref -d --no-deref BISECT_HEAD &&
- # clean up BISECT_START last
- rm -f "$GIT_DIR/BISECT_START"
+ git bisect--helper --bisect-clean-state || exit
}
bisect_replay () {
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2016-07-31 9:21 ` [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
` (11 preceding siblings ...)
2016-07-31 9:21 ` [RFC/PATCH v11 13/13] bisect--helper: `bisect_start` shell function partially " Pranit Bauva
@ 2016-08-02 17:25 ` Junio C Hamano
2016-08-10 21:57 ` [PATCH v12 " Pranit Bauva
13 siblings, 0 replies; 320+ messages in thread
From: Junio C Hamano @ 2016-08-02 17:25 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> `--next-all` is meant to be used as a subcommand to support multiple
> "operation mode" though the current implementation does not contain any
> other subcommand along side with `--next-all` but further commits will
> include some more subcommands.
Sounds sensible.
As long as the dispatch happens inside cmd_bisect__helper() itself,
limiting the enum definition local to the function also looks like a
good thing to do (and I do not see a reason why we need the world
outside this function to know about the enum in the future).
> Helped-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
> Mentored-by: Lars Schneider <larsxschneider@gmail.com>
> Mentored-by: Christian Couder <chriscool@tuxfamily.org>
> Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
> ---
> builtin/bisect--helper.c | 17 +++++++++++------
> 1 file changed, 11 insertions(+), 6 deletions(-)
>
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 3324229..8111c91 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -10,11 +10,11 @@ static const char * const git_bisect_helper_usage[] = {
>
> int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> {
> - int next_all = 0;
> + enum { NEXT_ALL = 1 } cmdmode = 0;
> int no_checkout = 0;
> struct option options[] = {
> - OPT_BOOL(0, "next-all", &next_all,
> - N_("perform 'git bisect next'")),
> + OPT_CMDMODE(0, "next-all", &cmdmode,
> + N_("perform 'git bisect next'"), NEXT_ALL),
> OPT_BOOL(0, "no-checkout", &no_checkout,
> N_("update BISECT_HEAD instead of checking out the current commit")),
> OPT_END()
> @@ -23,9 +23,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> argc = parse_options(argc, argv, prefix, options,
> git_bisect_helper_usage, 0);
>
> - if (!next_all)
> + if (!cmdmode)
> usage_with_options(git_bisect_helper_usage, options);
>
> - /* next-all */
> - return bisect_next_all(prefix, no_checkout);
> + switch (cmdmode) {
> + case NEXT_ALL:
> + return bisect_next_all(prefix, no_checkout);
> + default:
> + die("BUG: unknown subcommand '%d'", cmdmode);
> + }
> + return 0;
> }
>
> --
> https://github.com/git/git/pull/281
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 02/13] bisect: rewrite `check_term_format` shell function in C
2016-07-31 9:21 ` [RFC/PATCH v11 02/13] bisect: rewrite `check_term_format` " Pranit Bauva
@ 2016-08-02 17:31 ` Junio C Hamano
2016-08-03 20:20 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-02 17:31 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> +/*
> + * Check whether the string `term` belongs to the set of strings
> + * included in the variable arguments.
> + */
> +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;
> +}
It might be safer to mark this function with LAST_ARG_MUST_BE_NULL,
but because this is static to this function, it may not matter too
much. Just an observation, not a strong suggestion to change the
patch.
> +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);
Yup, that looks much more straight-forward than using a one-time-use
strbuf.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 03/13] bisect--helper: `write_terms` shell function in C
2016-07-31 9:21 ` [RFC/PATCH v11 03/13] bisect--helper: `write_terms` " Pranit Bauva
@ 2016-08-02 17:38 ` Junio C Hamano
2016-08-03 20:21 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-02 17:38 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> +static int write_terms(const char *bad, const char *good)
> +{
> + FILE *fp;
> + 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;
> +}
If fprintf(3) were a function that returns 0 on success and negative
on error (like fclose(3) is), the pattern to cascade the error
return with "res |= another_call()" is appropriate, but the made me
hiccup a bit while reading it. It is not wrong per-se and it would
certainly be making it worse if we did something silly like
res = fprintf(...) < 0 ? -1 : 0;
res |= fclose(fp);
so I guess what you have is the most succinct way to do this.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 04/13] bisect--helper: `bisect_clean_state` shell function in C
2016-07-31 9:21 ` [RFC/PATCH v11 04/13] bisect--helper: `bisect_clean_state` shell function in C Pranit Bauva
@ 2016-08-02 17:46 ` Junio C Hamano
2016-08-03 20:27 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-02 17:46 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> +static int bisect_clean_state(void)
> +{
> + int result = 0;
> +
> + /* There may be some refs packed during bisection */
> + struct string_list refs_for_removal = STRING_LIST_INIT_NODUP;
> + for_each_ref_in("refs/bisect/", mark_for_removal, (void *) &refs_for_removal);
> + string_list_append(&refs_for_removal, xstrdup("BISECT_HEAD"));
> + result = delete_refs(&refs_for_removal);
> + refs_for_removal.strdup_strings = 1;
> + string_list_clear(&refs_for_removal, 0);
> + remove_path(git_path_bisect_expected_rev());
> + remove_path(git_path_bisect_ancestors_ok());
> + remove_path(git_path_bisect_log());
> + remove_path(git_path_bisect_names());
> + remove_path(git_path_bisect_run());
> + remove_path(git_path_bisect_terms());
> + /* Cleanup head-name if it got left by an old version of git-bisect */
> + remove_path(git_path_head_name());
> + * Cleanup BISECT_START last to support the --no-checkout option
> + * introduced in the commit 4796e823a.
> + */
> + remove_path(git_path_bisect_start());
I can see that refs/files-backend.c misuses it already, but
remove_path() helper is about removing a path in the working tree,
together with any parent directory that becomes empty due to the
removal. You do not expect $GIT_DIR/ to become an empty directory
after removing $GIT_DIR/BISECT_LOG nor want to rmdir $GIT_DIR even
if it becomes empty. It is a wrong helper function to use here.
Also you do not seem to check the error from the function to smudge
the "result" you are returning from this function.
Isn't unlink_or_warn() more correct helper to use here?
> + return result;
> +}
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 07/13] bisect--helper: `bisect_reset` shell function in C
2016-07-31 9:21 ` [RFC/PATCH v11 07/13] bisect--helper: `bisect_reset` " Pranit Bauva
@ 2016-08-02 18:44 ` Junio C Hamano
0 siblings, 0 replies; 320+ messages in thread
From: Junio C Hamano @ 2016-08-02 18:44 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> + if (!file_exists(git_path_bisect_head())) {
> + struct argv_array argv = ARGV_ARRAY_INIT;
> + argv_array_pushl(&argv, "checkout", branch.buf, "--", NULL);
> + if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
> + error(_("Could not check out original HEAD '%s'. Try "
> + "'git bisect reset <commit>'."), branch.buf);
Somebody seems to have a keen eye. Looks much better with a space
after "Try" ;-)
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 08/13] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C
2016-07-31 9:21 ` [RFC/PATCH v11 08/13] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C Pranit Bauva
@ 2016-08-02 18:46 ` Junio C Hamano
0 siblings, 0 replies; 320+ messages in thread
From: Junio C Hamano @ 2016-08-02 18:46 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> + for (i = 0; i < rev_nr; i++) {
> + if (!is_expected_rev(revs[i])) {
> + remove_path(git_path_bisect_ancestors_ok());
> + remove_path(git_path_bisect_expected_rev());
> + return 0;
Same comment on the use of this helper function applies here, too.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 10/13] bisect--helper: `check_and_set_terms` shell function in C
2016-07-31 9:21 ` [RFC/PATCH v11 10/13] bisect--helper: `check_and_set_terms` " Pranit Bauva
@ 2016-08-02 18:53 ` Junio C Hamano
2016-08-03 20:29 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-02 18:53 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> Reimplement the `check_and_set_terms` shell function in C and add
> `check-and-set-terms` subcommand to `git bisect--helper` to call it from
> git-bisect.sh
>
> Using `--check-and-set-terms` subcommand is a temporary measure to port
> shell function in C so as to use the existing test suite. As more
> functions are ported, this subcommand will be retired and will be called
> by some other methods.
I think "this subcommand will be retired but its implementation will
be called by ..." would clarify the direction.
> + if (!no_term_file &&
> + strcmp(cmd, terms->term_bad.buf) &&
> + strcmp(cmd, terms->term_good.buf))
> + return error(_("Invalid command: you're currently in a "
> + "'%s' '%s' bisect"), terms->term_bad.buf,
This changes a message text, switching from "... good/bad bisect."
to "... 'good' 'bad' bisect". Intended?
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 11/13] bisect--helper: `bisect_next_check` shell function in C
2016-07-31 9:21 ` [RFC/PATCH v11 11/13] bisect--helper: `bisect_next_check` " Pranit Bauva
@ 2016-08-02 19:17 ` Junio C Hamano
2016-08-03 20:33 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-02 19:17 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> +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 0;
> +}
See below.
> +static int bisect_next_check(const struct bisect_terms *terms,
> + const char *current_term)
> +{
> + int missing_good = 1, missing_bad = 1;
It is somewhat unusual to start with "assume we are OK" and then
"it turns out that we are not".
> + char *bad_ref = xstrfmt("refs/bisect/%s", terms->term_bad.buf);
> + char *good_glob = xstrfmt("%s*", terms->term_good.buf);
The original runs
git for-each-ref "refs/bisect/$TERM_GOOD-*
but this one lacks the final dash.
> + if (ref_exists(bad_ref))
> + missing_bad = 0;
> + free(bad_ref);
> +
> + for_each_glob_ref_in(mark_good, good_glob, "refs/bisect/",
> + (void *) &missing_good);
> + free(good_glob);
The for-each helper does not return until it iterates over all the
matching refs, but you are only interested in seeing if at least one
exists. It may make sense to return 1 from mark_good() to terminate
the traversal early.
> + if (!missing_good && !missing_bad)
> + return 0;
> +
> + if (!current_term)
> + return -1;
> +
> + if (missing_good && !missing_bad && current_term &&
> + !strcmp(current_term, terms->term_good.buf)) {
> + char *yesno;
> + /*
> + * have bad (or new) but not good (or old). We could bisect
> + * although this is less optimum.
> + */
> + fprintf(stderr, "Warning: bisecting only with a %s commit\n",
> + terms->term_bad.buf);
In the original, this message goes through gettext.
> + if (!isatty(0))
> + return 0;
> + /*
> + * 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"))
> + return -1;
> + return 0;
> + }
When the control falls into the above if(){} block, the function
will always return. It will clarify that this is the end of such a
logical block to have a blank line here.
> + if (!is_empty_or_missing_file(git_path_bisect_start()))
> + return error(_("You need to give me at least one good|old and "
> + "bad|new revision. You can use \"git bisect "
> + "bad|new\" and \"git bisect good|old\" for "
> + "that. \n"));
> + else
> + return error(_("You need to start by \"git bisect start\". "
> + "You then need to give me at least one good|"
> + "old and bad|new revision. You can use \"git "
> + "bisect bad|new\" and \"git bisect good|old\" "
> + " for that.\n"));
The i18n on these two messages seem to be different from the
original, which asks bisect_voc to learn what 'bad' and 'good' are
called and attempts to use these words from the vocabulary.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 12/13] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-07-31 9:21 ` [RFC/PATCH v11 12/13] bisect--helper: `get_terms` & `bisect_terms` " Pranit Bauva
@ 2016-08-02 19:22 ` Junio C Hamano
2016-08-03 20:33 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-02 19:22 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> +static int bisect_terms(struct bisect_terms *terms, int term_defined)
> +{
> + if (get_terms(terms)) {
> + fprintf(stderr, "no terms defined\n");
> + return -1;
> + }
> + if (!term_defined) {
> + printf("Your current terms are %s for the old state\nand "
> + "%s for the new state.\n", terms->term_good.buf,
> + terms->term_bad.buf);
> + return 0;
> + }
In the original, all of the above messages go through gettext; this
rewrite should do the same.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 13/13] bisect--helper: `bisect_start` shell function partially in C
2016-07-31 9:21 ` [RFC/PATCH v11 13/13] bisect--helper: `bisect_start` shell function partially " Pranit Bauva
@ 2016-08-02 20:19 ` Junio C Hamano
2016-08-03 20:49 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-02 20:19 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> +static int bisect_start(struct bisect_terms *terms, int no_checkout,
> + const char **argv, int argc)
> +{
> + int i, j, has_double_dash = 0, must_write_terms = 0, bad_seen = 0;
> + int flag;
> + struct string_list revs = STRING_LIST_INIT_DUP;
> + struct string_list states = STRING_LIST_INIT_DUP;
> + struct strbuf start_head = STRBUF_INIT;
> + const char *head;
> + unsigned char sha1[20];
> + FILE *fp;
> + struct object_id oid;
> +
> + if (is_bare_repository())
> + no_checkout = 1;
> +
> + for(i = 0; i < argc; i++) {
SP after for.
> + if (!strcmp(argv[i], "--")) {
> + has_double_dash = 1;
> + break;
> + }
> + if (!strcmp(argv[i], "--term-good")) {
> + must_write_terms = 1;
> + strbuf_reset(&terms->term_good);
> + strbuf_addstr(&terms->term_good, argv[++i]);
> + break;
> + }
> + if (!strcmp(argv[i], "--term-bad")) {
> + must_write_terms = 1;
> + strbuf_reset(&terms->term_bad);
> + strbuf_addstr(&terms->term_bad, argv[++i]);
> + break;
> + }
The original was not careful, either, but what if the user ends the
command line with "--term-good", without anything after it?
Also the original is prepared to handle --term-good=boa; because
this function can be be called directly from the UI (i.e. "git
bisect start --term-good=boa"), not supporting that form would be
seen as a regression.
> + if (starts_with(argv[i], "--") &&
> + !one_of(argv[i], "--term-good", "--term-bad", NULL)) {
> + string_list_clear(&revs, 0);
> + string_list_clear(&states, 0);
> + die(_("unrecognised option: '%s'"), argv[i]);
> + }
> + if (get_oid(argv[i], &oid) || has_double_dash) {
Calling get_oid() alone is insufficient to make sure argv[i] refers
to an existing object that is a committish. The "^{commit}" suffix
in the original is there for a reason.
> + string_list_clear(&revs, 0);
> + string_list_clear(&revs, 0);
You seem to want the revs list really really clean ;-)
> + die(_("'%s' does not appear to be a valid revision"), argv[i]);
> + }
> + else
> + string_list_append(&revs, oid_to_hex(&oid));
> + }
> +
> + for (j = 0; j < revs.nr; j++) {
Why "j", not "i", as clearly the previous loop has finished at this
point? The only reason why replacing "j" with "i" would make this
function buggy would be if a later part of this function depended on
the value of "i" when the control left the above loop, but if that
were the case (I didn't check carefully), such a precious value that
has long term effect throughout the remainder of the function must
not be kept in an otherwise throw-away loop counter variable "i".
Introduce a new "int pathspec_pos" and set it to "i" immediately
after the "for (i = 0; i < argc; i++) { ... }" loop above, perhaps.
> + struct strbuf state = STRBUF_INIT;
> + /*
> + * 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.
> + */
> + must_write_terms = 1;
> +
> + if (bad_seen)
> + strbuf_addstr(&state, terms->term_good.buf);
> + else {
> + bad_seen = 1;
> + strbuf_addstr(&state, terms->term_bad.buf);
> + }
> + string_list_append(&states, state.buf);
> + strbuf_release(&state);
> + }
How about this instead?
/*
* that comment block goes here
*/
must_write_terms = !!revs.nr;
for (i = 0; i < revs.nr; i++) {
if (bad_seen)
string_list_append(&states, terms->term_good.buf);
else
string_list_append(&states, terms->term_bad.buf);
}
> +
> + /*
> + * Verify HEAD
> + */
> + head = resolve_ref_unsafe("HEAD", 0, sha1, &flag);
The last parameter is a set of flag bits, so call it flags.
> + if (!head) {
> + if (get_sha1("HEAD", sha1)) {
> + string_list_clear(&revs, 0);
> + string_list_clear(&states, 0);
> + die(_("Bad HEAD - I need a HEAD"));
We see many repeated calls to clear these two string lists before
exiting with failure, either by dying or return -1.
I wonder how bad the resulting code would look like if we employed
the standard pattern of having a "fail_return:" label at the end of
the function (after the "return" for the usual control flow) to
clear them. If the result becomes less readable (and I suspect that
you would end up making it less readable), leaving the current code
structure is OK.
> + }
> + }
> + 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) {
> + struct argv_array argv = ARGV_ARRAY_INIT;
> + argv_array_pushl(&argv, "checkout", start_head.buf,
> + "--", NULL);
> + if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
> + error(_("checking out '%s' failed. Try again."),
> + start_head.buf);
The original suggests to try "git bisect reset" here to recover.
> + strbuf_release(&start_head);
> + string_list_clear(&revs, 0);
> + string_list_clear(&states, 0);
> + return -1;
> + }
> + }
> + } else {
> + if (starts_with(head, "refs/head/") || !get_oid(head, &oid)) {
get_oid() is insufficient to ensure what you have in $head is
40-hex. I think you meant get_oid_hex() here.
> + /*
> + * 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())) {
> + strbuf_release(&start_head);
> + string_list_clear(&revs, 0);
> + string_list_clear(&states, 0);
> + die(_("won't bisect on cg-seek'ed tree"));
> + }
> + if (starts_with(head, "refs/heads/")) {
skip_prefix(), perhaps, if "head" is no longer used from here on?
> + /*
> + * Write new start state
> + */
> + fp = fopen(git_path_bisect_start(), "w");
> + if (!fp) {
> + bisect_clean_state();
> + strbuf_release(&start_head);
> + string_list_clear(&revs, 0);
> + string_list_clear(&states, 0);
> + return -1;
> + }
> + if (!fprintf(fp, "%s\n", start_head.buf)) {
man 3 fprintf and look for "Return Value"?
> + fclose(fp);
> + bisect_clean_state();
> + strbuf_release(&start_head);
> + string_list_clear(&revs, 0);
> + string_list_clear(&states, 0);
> + return -1;
> + }
> + fclose(fp);
Perhaps use write_file() instead of the above block of text?
> + if (no_checkout) {
> + get_oid(start_head.buf, &oid);
> + if (update_ref(NULL, "BISECT_HEAD", oid.hash, NULL, 0,
> + UPDATE_REFS_MSG_ON_ERR)) {
Doesn't the original use --no-deref for this update-ref call?
> + bisect_clean_state();
> + strbuf_release(&start_head);
> + string_list_clear(&revs, 0);
> + string_list_clear(&states, 0);
> + return -1;
> + }
> + }
> + strbuf_release(&start_head);
> + fp = fopen(git_path_bisect_names(), "w");
> +
> + for (; i < argc; i++) {
> + if (!fprintf(fp, "%s ", argv[i])) {
man 3 fprintf and look for "Return Value"?
More importantly, the original does --sq-quote so that BISECT_NAMES
file can be read back by a shell. This is important as argv[i] can
have whitespace in it, and you are concatenating them with SP in
between here. Also you are not terminating that line.
> + fclose(fp);
> + bisect_clean_state();
> + string_list_clear(&revs, 0);
> + string_list_clear(&states, 0);
> + return -1;
> + }
> + }
> + fclose(fp);
Perhaps
strbuf_reset(&bisect_names);
if (pathspec_pos < argc)
sq_quote_argv(&bisect_names, argv + pathspec_pos, 0);
write_file(git_path_bisect_names(), "%s\n", bisect_names.buf);
or something like that?
> + for (j = 0; j < states.nr; j ++) {
Again, is "i" still precious here? Style: drop SP between j and ++.
> + fp = fopen(git_path_bisect_log(), "a");
> + if (!fp) {
> + bisect_clean_state();
> + return -1;
> + }
> + if (!fprintf(fp, "git bisect start")) {
> + bisect_clean_state();
> + return -1;
> + }
> + for (i = 0; i < argc; i++) {
> + if (!fprintf(fp, " '%s'", argv[i])) {
> + fclose(fp);
> + bisect_clean_state();
> + return -1;
> + }
> + }
> + if (!fprintf(fp, "\n")) {
> + fclose(fp);
> + bisect_clean_state();
> + return -1;
> + }
Again, the original writes orig_args which was protected with --sq-quote.
> + fclose(fp);
> +
> + return 0;
> +}
> +
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 09/13] bisect--helper: `bisect_write` shell function in C
2016-07-31 9:21 ` [RFC/PATCH v11 09/13] bisect--helper: `bisect_write` " Pranit Bauva
@ 2016-08-02 20:25 ` Junio C Hamano
2016-08-02 22:17 ` Junio C Hamano
2016-08-03 20:51 ` Pranit Bauva
0 siblings, 2 replies; 320+ messages in thread
From: Junio C Hamano @ 2016-08-02 20:25 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> Reimplement the `bisect_write` shell function in C and add a
> `bisect-write` subcommand to `git bisect--helper` to call it from
> git-bisect.sh
Up to around this step we've seen these patches well enough and I
think with another reroll or two, they are in good enough shape to
be split out and frozen for 'next'. We may not be there quite yet,
but I think we are getting pretty close.
Thanks.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 09/13] bisect--helper: `bisect_write` shell function in C
2016-08-02 20:25 ` Junio C Hamano
@ 2016-08-02 22:17 ` Junio C Hamano
2016-08-03 20:52 ` Pranit Bauva
2016-08-03 20:51 ` Pranit Bauva
1 sibling, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-02 22:17 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Junio C Hamano <gitster@pobox.com> writes:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> Reimplement the `bisect_write` shell function in C and add a
>> `bisect-write` subcommand to `git bisect--helper` to call it from
>> git-bisect.sh
>
> Up to around this step we've seen these patches well enough and I
> think with another reroll or two, they are in good enough shape to
> be split out and frozen for 'next'. We may not be there quite yet,
> but I think we are getting pretty close.
>
> Thanks.
By the way, this series applied as a whole seems to break t6030.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 02/13] bisect: rewrite `check_term_format` shell function in C
2016-08-02 17:31 ` Junio C Hamano
@ 2016-08-03 20:20 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-03 20:20 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Tue, Aug 2, 2016 at 11:01 PM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> +/*
>> + * Check whether the string `term` belongs to the set of strings
>> + * included in the variable arguments.
>> + */
>> +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;
>> +}
>
> It might be safer to mark this function with LAST_ARG_MUST_BE_NULL,
> but because this is static to this function, it may not matter too
> much. Just an observation, not a strong suggestion to change the
> patch.
Yes, I could do that.
>> +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);
>
> Yup, that looks much more straight-forward than using a one-time-use
> strbuf.
Thanks!
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 03/13] bisect--helper: `write_terms` shell function in C
2016-08-02 17:38 ` Junio C Hamano
@ 2016-08-03 20:21 ` Pranit Bauva
2016-08-04 15:39 ` Junio C Hamano
0 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-03 20:21 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Tue, Aug 2, 2016 at 11:08 PM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> +static int write_terms(const char *bad, const char *good)
>> +{
>> + FILE *fp;
>> + 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;
>> +}
>
> If fprintf(3) were a function that returns 0 on success and negative
> on error (like fclose(3) is), the pattern to cascade the error
> return with "res |= another_call()" is appropriate, but the made me
> hiccup a bit while reading it. It is not wrong per-se and it would
> certainly be making it worse if we did something silly like
>
> res = fprintf(...) < 0 ? -1 : 0;
> res |= fclose(fp);
>
> so I guess what you have is the most succinct way to do this.
I agree with your point and your suggested code is better!
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 04/13] bisect--helper: `bisect_clean_state` shell function in C
2016-08-02 17:46 ` Junio C Hamano
@ 2016-08-03 20:27 ` Pranit Bauva
2016-08-04 15:45 ` Junio C Hamano
0 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-03 20:27 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Tue, Aug 2, 2016 at 11:16 PM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> +static int bisect_clean_state(void)
>> +{
>> + int result = 0;
>> +
>> + /* There may be some refs packed during bisection */
>> + struct string_list refs_for_removal = STRING_LIST_INIT_NODUP;
>> + for_each_ref_in("refs/bisect/", mark_for_removal, (void *) &refs_for_removal);
>> + string_list_append(&refs_for_removal, xstrdup("BISECT_HEAD"));
>> + result = delete_refs(&refs_for_removal);
>> + refs_for_removal.strdup_strings = 1;
>> + string_list_clear(&refs_for_removal, 0);
>> + remove_path(git_path_bisect_expected_rev());
>> + remove_path(git_path_bisect_ancestors_ok());
>> + remove_path(git_path_bisect_log());
>> + remove_path(git_path_bisect_names());
>> + remove_path(git_path_bisect_run());
>> + remove_path(git_path_bisect_terms());
>> + /* Cleanup head-name if it got left by an old version of git-bisect */
>> + remove_path(git_path_head_name());
>> + * Cleanup BISECT_START last to support the --no-checkout option
>> + * introduced in the commit 4796e823a.
>> + */
>> + remove_path(git_path_bisect_start());
>
> I can see that refs/files-backend.c misuses it already, but
> remove_path() helper is about removing a path in the working tree,
> together with any parent directory that becomes empty due to the
> removal. You do not expect $GIT_DIR/ to become an empty directory
> after removing $GIT_DIR/BISECT_LOG nor want to rmdir $GIT_DIR even
> if it becomes empty. It is a wrong helper function to use here.
>
> Also you do not seem to check the error from the function to smudge
> the "result" you are returning from this function.
Yes I should combine the results from every removal.
> Isn't unlink_or_warn() more correct helper to use here?
The shell code uses rm -f which is silent and it removes only if
present. So it makes me wonder which would be more appropriate
unlink_or_warn() or remove_or_warn() or remove_path(). Is
remove_path() different from its shell equivalent "rm -f"?
>> + return result;
>> +}
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 10/13] bisect--helper: `check_and_set_terms` shell function in C
2016-08-02 18:53 ` Junio C Hamano
@ 2016-08-03 20:29 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-03 20:29 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Wed, Aug 3, 2016 at 12:23 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> Reimplement the `check_and_set_terms` shell function in C and add
>> `check-and-set-terms` subcommand to `git bisect--helper` to call it from
>> git-bisect.sh
>>
>> Using `--check-and-set-terms` subcommand is a temporary measure to port
>> shell function in C so as to use the existing test suite. As more
>> functions are ported, this subcommand will be retired and will be called
>> by some other methods.
>
> I think "this subcommand will be retired but its implementation will
> be called by ..." would clarify the direction.
Sure. That seems better.
>> + if (!no_term_file &&
>> + strcmp(cmd, terms->term_bad.buf) &&
>> + strcmp(cmd, terms->term_good.buf))
>> + return error(_("Invalid command: you're currently in a "
>> + "'%s' '%s' bisect"), terms->term_bad.buf,
>
> This changes a message text, switching from "... good/bad bisect."
> to "... 'good' 'bad' bisect". Intended?
Nope its not intended but its a mistake from my side. Will rectify.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 11/13] bisect--helper: `bisect_next_check` shell function in C
2016-08-02 19:17 ` Junio C Hamano
@ 2016-08-03 20:33 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-03 20:33 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Wed, Aug 3, 2016 at 12:47 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> +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 0;
>> +}
>
> See below.
>
>> +static int bisect_next_check(const struct bisect_terms *terms,
>> + const char *current_term)
>> +{
>> + int missing_good = 1, missing_bad = 1;
>
> It is somewhat unusual to start with "assume we are OK" and then
> "it turns out that we are not".
>
>> + char *bad_ref = xstrfmt("refs/bisect/%s", terms->term_bad.buf);
>> + char *good_glob = xstrfmt("%s*", terms->term_good.buf);
>
> The original runs
>
> git for-each-ref "refs/bisect/$TERM_GOOD-*
>
> but this one lacks the final dash.
My bad. Will include it.
>> + if (ref_exists(bad_ref))
>> + missing_bad = 0;
>> + free(bad_ref);
>> +
>> + for_each_glob_ref_in(mark_good, good_glob, "refs/bisect/",
>> + (void *) &missing_good);
>> + free(good_glob);
>
> The for-each helper does not return until it iterates over all the
> matching refs, but you are only interested in seeing if at least one
> exists. It may make sense to return 1 from mark_good() to terminate
> the traversal early.
Seems a better way. Thanks!
>> + if (!missing_good && !missing_bad)
>> + return 0;
>> +
>> + if (!current_term)
>> + return -1;
>> +
>> + if (missing_good && !missing_bad && current_term &&
>> + !strcmp(current_term, terms->term_good.buf)) {
>> + char *yesno;
>> + /*
>> + * have bad (or new) but not good (or old). We could bisect
>> + * although this is less optimum.
>> + */
>> + fprintf(stderr, "Warning: bisecting only with a %s commit\n",
>> + terms->term_bad.buf);
>
> In the original, this message goes through gettext.
Will do.
>> + if (!isatty(0))
>> + return 0;
>> + /*
>> + * 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"))
>> + return -1;
>> + return 0;
>> + }
>
> When the control falls into the above if(){} block, the function
> will always return. It will clarify that this is the end of such a
> logical block to have a blank line here.
Will do.
>> + if (!is_empty_or_missing_file(git_path_bisect_start()))
>> + return error(_("You need to give me at least one good|old and "
>> + "bad|new revision. You can use \"git bisect "
>> + "bad|new\" and \"git bisect good|old\" for "
>> + "that. \n"));
>> + else
>> + return error(_("You need to start by \"git bisect start\". "
>> + "You then need to give me at least one good|"
>> + "old and bad|new revision. You can use \"git "
>> + "bisect bad|new\" and \"git bisect good|old\" "
>> + " for that.\n"));
>
> The i18n on these two messages seem to be different from the
> original, which asks bisect_voc to learn what 'bad' and 'good' are
> called and attempts to use these words from the vocabulary.
I have little idea about i18n. Will look more into it.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 12/13] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-08-02 19:22 ` Junio C Hamano
@ 2016-08-03 20:33 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-03 20:33 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Wed, Aug 3, 2016 at 12:52 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> +static int bisect_terms(struct bisect_terms *terms, int term_defined)
>> +{
>> + if (get_terms(terms)) {
>> + fprintf(stderr, "no terms defined\n");
>> + return -1;
>> + }
>> + if (!term_defined) {
>> + printf("Your current terms are %s for the old state\nand "
>> + "%s for the new state.\n", terms->term_good.buf,
>> + terms->term_bad.buf);
>> + return 0;
>> + }
>
> In the original, all of the above messages go through gettext; this
> rewrite should do the same.
Sure!
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 13/13] bisect--helper: `bisect_start` shell function partially in C
2016-08-02 20:19 ` Junio C Hamano
@ 2016-08-03 20:49 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-03 20:49 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Wed, Aug 3, 2016 at 1:49 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> +static int bisect_start(struct bisect_terms *terms, int no_checkout,
>> + const char **argv, int argc)
>> +{
>> + int i, j, has_double_dash = 0, must_write_terms = 0, bad_seen = 0;
>> + int flag;
>> + struct string_list revs = STRING_LIST_INIT_DUP;
>> + struct string_list states = STRING_LIST_INIT_DUP;
>> + struct strbuf start_head = STRBUF_INIT;
>> + const char *head;
>> + unsigned char sha1[20];
>> + FILE *fp;
>> + struct object_id oid;
>> +
>> + if (is_bare_repository())
>> + no_checkout = 1;
>> +
>> + for(i = 0; i < argc; i++) {
>
> SP after for.
Sure!
>> + if (!strcmp(argv[i], "--")) {
>> + has_double_dash = 1;
>> + break;
>> + }
>> + if (!strcmp(argv[i], "--term-good")) {
>> + must_write_terms = 1;
>> + strbuf_reset(&terms->term_good);
>> + strbuf_addstr(&terms->term_good, argv[++i]);
>> + break;
>> + }
>> + if (!strcmp(argv[i], "--term-bad")) {
>> + must_write_terms = 1;
>> + strbuf_reset(&terms->term_bad);
>> + strbuf_addstr(&terms->term_bad, argv[++i]);
>> + break;
>> + }
>
> The original was not careful, either, but what if the user ends the
> command line with "--term-good", without anything after it?
> Also the original is prepared to handle --term-good=boa; because
> this function can be be called directly from the UI (i.e. "git
> bisect start --term-good=boa"), not supporting that form would be
> seen as a regression.
I wanted to discuss this precisely by this RFC. I was initially
thinking of using OPT_ARGUMENT() for bisect_terms() which would in
turn cover up for bisect_start() too. Currently the code does not
support --term-good=boa because it treats --term-good as a boolean Do
you have any other thing in mind?
>> + if (starts_with(argv[i], "--") &&
>> + !one_of(argv[i], "--term-good", "--term-bad", NULL)) {
>> + string_list_clear(&revs, 0);
>> + string_list_clear(&states, 0);
>> + die(_("unrecognised option: '%s'"), argv[i]);
>> + }
>> + if (get_oid(argv[i], &oid) || has_double_dash) {
>
> Calling get_oid() alone is insufficient to make sure argv[i] refers
> to an existing object that is a committish. The "^{commit}" suffix
> in the original is there for a reason.
Yes sure!
>> + string_list_clear(&revs, 0);
>> + string_list_clear(&revs, 0);
>
> You seem to want the revs list really really clean ;-)
Haha! ;) My bad. Will remove the extra line!
>> + die(_("'%s' does not appear to be a valid revision"), argv[i]);
>> + }
>> + else
>> + string_list_append(&revs, oid_to_hex(&oid));
>> + }
>> +
>> + for (j = 0; j < revs.nr; j++) {
>
> Why "j", not "i", as clearly the previous loop has finished at this
> point? The only reason why replacing "j" with "i" would make this
> function buggy would be if a later part of this function depended on
> the value of "i" when the control left the above loop, but if that
> were the case (I didn't check carefully), such a precious value that
> has long term effect throughout the remainder of the function must
> not be kept in an otherwise throw-away loop counter variable "i".
>
> Introduce a new "int pathspec_pos" and set it to "i" immediately
> after the "for (i = 0; i < argc; i++) { ... }" loop above, perhaps.
I am using i afterwards for writing the arguments to BISECT_NAMES. But
I think it would be better to use pathspec_pos and discard j
altogether. Thanks!
>
>> + struct strbuf state = STRBUF_INIT;
>> + /*
>> + * 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.
>> + */
>> + must_write_terms = 1;
>> +
>> + if (bad_seen)
>> + strbuf_addstr(&state, terms->term_good.buf);
>> + else {
>> + bad_seen = 1;
>> + strbuf_addstr(&state, terms->term_bad.buf);
>> + }
>> + string_list_append(&states, state.buf);
>> + strbuf_release(&state);
>> + }
>
> How about this instead?
>
> /*
> * that comment block goes here
> */
> must_write_terms = !!revs.nr;
> for (i = 0; i < revs.nr; i++) {
> if (bad_seen)
> string_list_append(&states, terms->term_good.buf);
> else
> string_list_append(&states, terms->term_bad.buf);
> }
Seems better. Thanks!
>> +
>> + /*
>> + * Verify HEAD
>> + */
>> + head = resolve_ref_unsafe("HEAD", 0, sha1, &flag);
>
> The last parameter is a set of flag bits, so call it flags.
Sure!
>> + if (!head) {
>> + if (get_sha1("HEAD", sha1)) {
>> + string_list_clear(&revs, 0);
>> + string_list_clear(&states, 0);
>> + die(_("Bad HEAD - I need a HEAD"));
>
> We see many repeated calls to clear these two string lists before
> exiting with failure, either by dying or return -1.
>
> I wonder how bad the resulting code would look like if we employed
> the standard pattern of having a "fail_return:" label at the end of
> the function (after the "return" for the usual control flow) to
> clear them. If the result becomes less readable (and I suspect that
> you would end up making it less readable), leaving the current code
> structure is OK.
Its becoming really bad. I tried it once. Different things are being
cleaned up at different times which makes it all the more tedious to
maintain.
>> + }
>> + }
>> + 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) {
>> + struct argv_array argv = ARGV_ARRAY_INIT;
>> + argv_array_pushl(&argv, "checkout", start_head.buf,
>> + "--", NULL);
>> + if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
>> + error(_("checking out '%s' failed. Try again."),
>> + start_head.buf);
>
> The original suggests to try "git bisect reset" here to recover.
Will include it.
>> + strbuf_release(&start_head);
>> + string_list_clear(&revs, 0);
>> + string_list_clear(&states, 0);
>> + return -1;
>> + }
>> + }
>> + } else {
>> + if (starts_with(head, "refs/head/") || !get_oid(head, &oid)) {
>
> get_oid() is insufficient to ensure what you have in $head is
> 40-hex. I think you meant get_oid_hex() here.
Yes definitely. Might have been missed.
>> + /*
>> + * 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())) {
>> + strbuf_release(&start_head);
>> + string_list_clear(&revs, 0);
>> + string_list_clear(&states, 0);
>> + die(_("won't bisect on cg-seek'ed tree"));
>> + }
>> + if (starts_with(head, "refs/heads/")) {
>
> skip_prefix(), perhaps, if "head" is no longer used from here on?
Sure!
>> + /*
>> + * Write new start state
>> + */
>> + fp = fopen(git_path_bisect_start(), "w");
>> + if (!fp) {
>> + bisect_clean_state();
>> + strbuf_release(&start_head);
>> + string_list_clear(&revs, 0);
>> + string_list_clear(&states, 0);
>> + return -1;
>> + }
>> + if (!fprintf(fp, "%s\n", start_head.buf)) {
>
> man 3 fprintf and look for "Return Value"?
I should have been more careful about fprintf's return value.
>> + fclose(fp);
>> + bisect_clean_state();
>> + strbuf_release(&start_head);
>> + string_list_clear(&revs, 0);
>> + string_list_clear(&states, 0);
>> + return -1;
>> + }
>> + fclose(fp);
>
> Perhaps use write_file() instead of the above block of text?
Yes, that seems better. Thanks!
>> + if (no_checkout) {
>> + get_oid(start_head.buf, &oid);
>> + if (update_ref(NULL, "BISECT_HEAD", oid.hash, NULL, 0,
>> + UPDATE_REFS_MSG_ON_ERR)) {
>
> Doesn't the original use --no-deref for this update-ref call?
Yes, will change.
>> + bisect_clean_state();
>> + strbuf_release(&start_head);
>> + string_list_clear(&revs, 0);
>> + string_list_clear(&states, 0);
>> + return -1;
>> + }
>> + }
>> + strbuf_release(&start_head);
>> + fp = fopen(git_path_bisect_names(), "w");
>> +
>> + for (; i < argc; i++) {
>> + if (!fprintf(fp, "%s ", argv[i])) {
>
> man 3 fprintf and look for "Return Value"?
>
> More importantly, the original does --sq-quote so that BISECT_NAMES
> file can be read back by a shell. This is important as argv[i] can
> have whitespace in it, and you are concatenating them with SP in
> between here. Also you are not terminating that line.
Yes its a good idea to retain its --sq-quote nature.
>> + fclose(fp);
>> + bisect_clean_state();
>> + string_list_clear(&revs, 0);
>> + string_list_clear(&states, 0);
>> + return -1;
>> + }
>> + }
>> + fclose(fp);
>
> Perhaps
>
> strbuf_reset(&bisect_names);
> if (pathspec_pos < argc)
> sq_quote_argv(&bisect_names, argv + pathspec_pos, 0);
> write_file(git_path_bisect_names(), "%s\n", bisect_names.buf);
>
> or something like that?
Yes! Thanks! Looks pretty good to me.
>> + for (j = 0; j < states.nr; j ++) {
>
> Again, is "i" still precious here? Style: drop SP between j and ++.
After BISECT_NAMES, "i" ceases to be precious.
>> + fp = fopen(git_path_bisect_log(), "a");
>> + if (!fp) {
>> + bisect_clean_state();
>> + return -1;
>> + }
>> + if (!fprintf(fp, "git bisect start")) {
>> + bisect_clean_state();
>> + return -1;
>> + }
>> + for (i = 0; i < argc; i++) {
>> + if (!fprintf(fp, " '%s'", argv[i])) {
>> + fclose(fp);
>> + bisect_clean_state();
>> + return -1;
>> + }
>> + }
>> + if (!fprintf(fp, "\n")) {
>> + fclose(fp);
>> + bisect_clean_state();
>> + return -1;
>> + }
>
> Again, the original writes orig_args which was protected with --sq-quote.
Yes. Will take care of it.
>> + fclose(fp);
>> +
>> + return 0;
>> +}
>> +
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 09/13] bisect--helper: `bisect_write` shell function in C
2016-08-02 20:25 ` Junio C Hamano
2016-08-02 22:17 ` Junio C Hamano
@ 2016-08-03 20:51 ` Pranit Bauva
1 sibling, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-03 20:51 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Wed, Aug 3, 2016 at 1:55 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> Reimplement the `bisect_write` shell function in C and add a
>> `bisect-write` subcommand to `git bisect--helper` to call it from
>> git-bisect.sh
>
> Up to around this step we've seen these patches well enough and I
> think with another reroll or two, they are in good enough shape to
> be split out and frozen for 'next'. We may not be there quite yet,
> but I think we are getting pretty close.
Thanks for taking out your time to review this series. I will follow
up with the patches in a day or so. I think the first 11, many things
wouldn't change (except for your reviews). Most of the changes would
happen in 12 and 13 and more specifically the argument handling.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 09/13] bisect--helper: `bisect_write` shell function in C
2016-08-02 22:17 ` Junio C Hamano
@ 2016-08-03 20:52 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-03 20:52 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Wed, Aug 3, 2016 at 3:47 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Junio C Hamano <gitster@pobox.com> writes:
>
>> Pranit Bauva <pranit.bauva@gmail.com> writes:
>>
>>> Reimplement the `bisect_write` shell function in C and add a
>>> `bisect-write` subcommand to `git bisect--helper` to call it from
>>> git-bisect.sh
>>
>> Up to around this step we've seen these patches well enough and I
>> think with another reroll or two, they are in good enough shape to
>> be split out and frozen for 'next'. We may not be there quite yet,
>> but I think we are getting pretty close.
>>
>> Thanks.
>
> By the way, this series applied as a whole seems to break t6030.
This is only because of argument handling problem. I seemed to have
mentioned it in patch 13/13 and also gave the output of the tests.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 03/13] bisect--helper: `write_terms` shell function in C
2016-08-03 20:21 ` Pranit Bauva
@ 2016-08-04 15:39 ` Junio C Hamano
0 siblings, 0 replies; 320+ messages in thread
From: Junio C Hamano @ 2016-08-04 15:39 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Git List
Pranit Bauva <pranit.bauva@gmail.com> writes:
>>> + res = fprintf(fp, "%s\n%s\n", bad, good);
>>> + res |= fclose(fp);
>>> + return (res < 0) ? -1 : 0;
>>> +}
>>
>> If fprintf(3) were a function that returns 0 on success and negative
>> on error (like fclose(3) is), the pattern to cascade the error
>> return with "res |= another_call()" is appropriate, but the made me
>> hiccup a bit while reading it. It is not wrong per-se and it would
>> certainly be making it worse if we did something silly like
>>
>> res = fprintf(...) < 0 ? -1 : 0;
>> res |= fclose(fp);
>>
>> so I guess what you have is the most succinct way to do this.
>
> I agree with your point and your suggested code is better!
Puzzled... Read it again, I was not suggesting it---I was saying
"this could be a silly rewrite, which I think is making it worse".
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 04/13] bisect--helper: `bisect_clean_state` shell function in C
2016-08-03 20:27 ` Pranit Bauva
@ 2016-08-04 15:45 ` Junio C Hamano
2016-08-04 16:07 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-04 15:45 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Git List
Pranit Bauva <pranit.bauva@gmail.com> writes:
>> Also you do not seem to check the error from the function to smudge
>> the "result" you are returning from this function.
>
> Yes I should combine the results from every removal.
>
>> Isn't unlink_or_warn() more correct helper to use here?
>
> The shell code uses rm -f which is silent and it removes only if
> present.
Isn't that what unlink_or_warn() do? Call unlink() and happily
return if unlink() succeeds or errors with ENOENT (i.e. path didn't
exist in the first place), but otherwise reports an error (imagine:
EPERM).
> So it makes me wonder which would be more appropriate
> unlink_or_warn() or remove_or_warn() or remove_path(). Is
> remove_path() different from its shell equivalent "rm -f"?
Read it again.
>>> + remove_path(git_path_bisect_start());
>>
>> I can see that refs/files-backend.c misuses it already, but
>> remove_path() helper is about removing a path in the working tree,
>> together with any parent directory that becomes empty due to the
>> removal. You do not expect $GIT_DIR/ to become an empty directory
>> after removing $GIT_DIR/BISECT_LOG nor want to rmdir $GIT_DIR even
>> if it becomes empty. It is a wrong helper function to use here.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 04/13] bisect--helper: `bisect_clean_state` shell function in C
2016-08-04 15:45 ` Junio C Hamano
@ 2016-08-04 16:07 ` Pranit Bauva
2016-08-04 16:50 ` Junio C Hamano
0 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-04 16:07 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Thu, Aug 4, 2016 at 9:15 PM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>>> Also you do not seem to check the error from the function to smudge
>>> the "result" you are returning from this function.
>>
>> Yes I should combine the results from every removal.
>>
>>> Isn't unlink_or_warn() more correct helper to use here?
>>
>> The shell code uses rm -f which is silent and it removes only if
>> present.
>
> Isn't that what unlink_or_warn() do? Call unlink() and happily
> return if unlink() succeeds or errors with ENOENT (i.e. path didn't
> exist in the first place), but otherwise reports an error (imagine:
> EPERM).
Umm, I am confused. I tried "rm -f" with a non-existing file and it
does not show any warning or error.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 04/13] bisect--helper: `bisect_clean_state` shell function in C
2016-08-04 16:07 ` Pranit Bauva
@ 2016-08-04 16:50 ` Junio C Hamano
2016-08-04 16:57 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-04 16:50 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Git List
Pranit Bauva <pranit.bauva@gmail.com> writes:
> Hey Junio,
>
> On Thu, Aug 4, 2016 at 9:15 PM, Junio C Hamano <gitster@pobox.com> wrote:
>> Pranit Bauva <pranit.bauva@gmail.com> writes:
>>
>>>> Also you do not seem to check the error from the function to smudge
>>>> the "result" you are returning from this function.
>>>
>>> Yes I should combine the results from every removal.
>>>
>>>> Isn't unlink_or_warn() more correct helper to use here?
>>>
>>> The shell code uses rm -f which is silent and it removes only if
>>> present.
>>
>> Isn't that what unlink_or_warn() do? Call unlink() and happily
>> return if unlink() succeeds or errors with ENOENT (i.e. path didn't
>> exist in the first place), but otherwise reports an error (imagine:
>> EPERM).
>
> Umm, I am confused. I tried "rm -f" with a non-existing file and it
> does not show any warning or error.
You are, or you were? I hope it is the latter, iow, you are no
longer confused and now understand why unlink_or_warn() was
suggested.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [RFC/PATCH v11 04/13] bisect--helper: `bisect_clean_state` shell function in C
2016-08-04 16:50 ` Junio C Hamano
@ 2016-08-04 16:57 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-04 16:57 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Thu, Aug 4, 2016 at 10:20 PM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> Hey Junio,
>>
>> On Thu, Aug 4, 2016 at 9:15 PM, Junio C Hamano <gitster@pobox.com> wrote:
>>> Pranit Bauva <pranit.bauva@gmail.com> writes:
>>>
>>>>> Also you do not seem to check the error from the function to smudge
>>>>> the "result" you are returning from this function.
>>>>
>>>> Yes I should combine the results from every removal.
>>>>
>>>>> Isn't unlink_or_warn() more correct helper to use here?
>>>>
>>>> The shell code uses rm -f which is silent and it removes only if
>>>> present.
>>>
>>> Isn't that what unlink_or_warn() do? Call unlink() and happily
>>> return if unlink() succeeds or errors with ENOENT (i.e. path didn't
>>> exist in the first place), but otherwise reports an error (imagine:
>>> EPERM).
>>
>> Umm, I am confused. I tried "rm -f" with a non-existing file and it
>> does not show any warning or error.
>
> You are, or you were? I hope it is the latter, iow, you are no
> longer confused and now understand why unlink_or_warn() was
> suggested.
I meant to use past tense. Did not re-check before sending it.
^ permalink raw reply [flat|nested] 320+ messages in thread
* [PATCH v12 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2016-07-31 9:21 ` [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
` (12 preceding siblings ...)
2016-08-02 17:25 ` [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Junio C Hamano
@ 2016-08-10 21:57 ` Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 02/13] bisect: rewrite `check_term_format` shell function in C Pranit Bauva
` (13 more replies)
13 siblings, 14 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-10 21:57 UTC (permalink / raw)
To: git
`--next-all` is meant to be used as a subcommand to support multiple
"operation mode" though the current implementation does not contain any
other subcommand along side with `--next-all` but further commits will
include some more subcommands.
Helped-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 17 +++++++++++------
1 file changed, 11 insertions(+), 6 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 3324229..8111c91 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -10,11 +10,11 @@ static const char * const git_bisect_helper_usage[] = {
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
- int next_all = 0;
+ enum { NEXT_ALL = 1 } cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
- OPT_BOOL(0, "next-all", &next_all,
- N_("perform 'git bisect next'")),
+ OPT_CMDMODE(0, "next-all", &cmdmode,
+ N_("perform 'git bisect next'"), NEXT_ALL),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -23,9 +23,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
argc = parse_options(argc, argv, prefix, options,
git_bisect_helper_usage, 0);
- if (!next_all)
+ if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
- /* next-all */
- return bisect_next_all(prefix, no_checkout);
+ switch (cmdmode) {
+ case NEXT_ALL:
+ return bisect_next_all(prefix, no_checkout);
+ default:
+ die("BUG: unknown subcommand '%d'", cmdmode);
+ }
+ return 0;
}
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v12 10/13] bisect--helper: `check_and_set_terms` shell function in C
2016-08-10 21:57 ` [PATCH v12 " Pranit Bauva
` (6 preceding siblings ...)
2016-08-10 21:57 ` [PATCH v12 06/13] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
@ 2016-08-10 21:57 ` Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 04/13] bisect--helper: `bisect_clean_state` " Pranit Bauva
` (5 subsequent siblings)
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-10 21:57 UTC (permalink / raw)
To: git
Reimplement the `check_and_set_terms` shell function in C and add
`check-and-set-terms` subcommand to `git bisect--helper` to call it from
git-bisect.sh
Using `--check-and-set-terms` subcommand is a temporary measure to port
shell function in C so as to use the existing test suite. As more
functions are ported, this subcommand will be retired but its
implementation will be called by some other methods.
check_and_set_terms() sets and receives two global variables namely
TERM_GOOD and TERM_BAD in the shell script. Luckily the file BISECT_TERMS
also contains the value of those variables so its appropriate to evoke the
method get_terms() after calling the subcommand so that it retrieves the
value of TERM_GOOD and TERM_BAD from the file BISECT_TERMS. The two
global variables are passed as arguments to the subcommand.
Also introduce bisect_terms_reset() to empty the contents of `term_good`
and `term_bad` of `struct bisect_terms`.
Also introduce set_terms() to copy the `term_good` and `term_bad` into
`struct bisect_terms` and write it out to the file BISECT_TERMS.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 52 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 36 ++++-----------------------------
2 files changed, 55 insertions(+), 33 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 9f70edb..5c4350f 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -23,6 +23,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-clean-state"),
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
+ N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
NULL
};
@@ -43,6 +44,12 @@ static void bisect_terms_release(struct bisect_terms *terms)
strbuf_release(&terms->term_bad);
}
+static void bisect_terms_reset(struct bisect_terms *term)
+{
+ strbuf_reset(&term->term_good);
+ strbuf_reset(&term->term_bad);
+}
+
/*
* Check whether the string `term` belongs to the set of strings
* included in the variable arguments.
@@ -253,6 +260,39 @@ static int bisect_write(const char *state, const char *rev,
return 0;
}
+static int set_terms(struct bisect_terms *terms, const char *bad,
+ const char *good)
+{
+ bisect_terms_reset(terms);
+ strbuf_addstr(&terms->term_good, good);
+ strbuf_addstr(&terms->term_bad, bad);
+ return write_terms(terms->term_bad.buf, terms->term_good.buf);
+}
+
+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.buf) &&
+ strcmp(cmd, terms->term_good.buf))
+ return error(_("Invalid command: you're currently in a "
+ "%s/%s bisect"), terms->term_bad.buf,
+ terms->term_good.buf);
+
+ if (!has_term_file) {
+ if (one_of(cmd, "bad", "good", NULL))
+ return set_terms(terms, "bad", "good");
+ if (one_of(cmd, "new", "old", NULL))
+ return set_terms(terms, "new", "old");
+ }
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -261,7 +301,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_CLEAN_STATE,
BISECT_RESET,
CHECK_EXPECTED_REVS,
- BISECT_WRITE
+ BISECT_WRITE,
+ CHECK_AND_SET_TERMS
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -277,6 +318,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check for expected revs"), CHECK_EXPECTED_REVS),
OPT_CMDMODE(0, "bisect-write", &cmdmode,
N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
+ OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
+ N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -320,6 +363,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
strbuf_addstr(&terms.term_bad, argv[3]);
res = bisect_write(argv[0], argv[1], &terms, nolog);
break;
+ case CHECK_AND_SET_TERMS:
+ if (argc != 3)
+ die(_("--check-and-set-terms requires 3 arguments"));
+ strbuf_addstr(&terms.term_good, argv[1]);
+ strbuf_addstr(&terms.term_bad, argv[2]);
+ res = check_and_set_terms(&terms, argv[0]);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index b9896a4..a41e69b 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -239,7 +239,8 @@ bisect_skip() {
bisect_state() {
bisect_autostart
state=$1
- check_and_set_terms $state
+ git bisect--helper --check-and-set-terms $state $TERM_GOOD $TERM_BAD || exit
+ get_terms
case "$#,$state" in
0,*)
die "$(gettext "Please call 'bisect_state' with at least one argument.")" ;;
@@ -390,7 +391,8 @@ bisect_replay () {
command="$bisect"
fi
get_terms
- check_and_set_terms "$command"
+ git bisect--helper --check-and-set-terms "$command" "$TERM_GOOD" "$TERM_BAD" || exit
+ get_terms
case "$command" in
start)
cmd="bisect_start $rev"
@@ -480,36 +482,6 @@ get_terms () {
fi
}
-check_and_set_terms () {
- cmd="$1"
- case "$cmd" in
- skip|start|terms) ;;
- *)
- if test -s "$GIT_DIR/BISECT_TERMS" && test "$cmd" != "$TERM_BAD" && test "$cmd" != "$TERM_GOOD"
- then
- die "$(eval_gettext "Invalid command: you're currently in a \$TERM_BAD/\$TERM_GOOD bisect.")"
- fi
- case "$cmd" in
- bad|good)
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- TERM_BAD=bad
- TERM_GOOD=good
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
- fi
- ;;
- new|old)
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- TERM_BAD=new
- TERM_GOOD=old
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
- fi
- ;;
- esac ;;
- esac
-}
-
bisect_voc () {
case "$1" in
bad) echo "bad|new" ;;
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v12 03/13] bisect--helper: `write_terms` shell function in C
2016-08-10 21:57 ` [PATCH v12 " Pranit Bauva
` (3 preceding siblings ...)
2016-08-10 21:57 ` [PATCH v12 08/13] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function " Pranit Bauva
@ 2016-08-10 21:57 ` Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 07/13] bisect--helper: `bisect_reset` " Pranit Bauva
` (8 subsequent siblings)
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-10 21:57 UTC (permalink / raw)
To: git
Reimplement the `write_terms` shell function in C and add a `write-terms`
subcommand to `git bisect--helper` to call it from git-bisect.sh . Also
remove the subcommand `--check-term-format` as it can now be called from
inside the function write_terms() C implementation.
Also `|| exit` is added when calling write-terms subcommand from
git-bisect.sh so as to exit whenever there is an error.
Using `--write-terms` subcommand is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and its implementation will
be called by some other method.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 36 +++++++++++++++++++++++++++++-------
git-bisect.sh | 22 +++++++---------------
2 files changed, 36 insertions(+), 22 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index a47f1f2..30e1031 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -4,9 +4,11 @@
#include "bisect.h"
#include "refs.h"
+static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
+
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
- N_("git bisect--helper --check-term-format <term> <orig_term>"),
+ N_("git bisect--helper --write-terms <bad_term> <good_term>"),
NULL
};
@@ -57,18 +59,38 @@ static int check_term_format(const char *term, const char *orig_term)
return 0;
}
+static int write_terms(const char *bad, const char *good)
+{
+ FILE *fp;
+ 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;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
- CHECK_TERM_FMT
+ WRITE_TERMS
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
- OPT_CMDMODE(0, "check-term-format", &cmdmode,
- N_("check format of the term"), CHECK_TERM_FMT),
+ OPT_CMDMODE(0, "write-terms", &cmdmode,
+ N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -83,10 +105,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
switch (cmdmode) {
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
- case CHECK_TERM_FMT:
+ case WRITE_TERMS:
if (argc != 2)
- die(_("--check-term-format requires two arguments"));
- return check_term_format(argv[0], argv[1]);
+ die(_("--write-terms requires two arguments"));
+ return write_terms(argv[0], argv[1]);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 7d7965d..cd39bd0 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -210,7 +210,7 @@ bisect_start() {
eval "$eval true" &&
if test $must_write_terms -eq 1
then
- write_terms "$TERM_BAD" "$TERM_GOOD"
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD"
fi &&
echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
#
@@ -557,18 +557,6 @@ get_terms () {
fi
}
-write_terms () {
- TERM_BAD=$1
- TERM_GOOD=$2
- if test "$TERM_BAD" = "$TERM_GOOD"
- then
- die "$(gettext "please use two different terms")"
- fi
- git bisect--helper --check-term-format "$TERM_BAD" bad || exit
- git bisect--helper --check-term-format "$TERM_GOOD" good || exit
- printf '%s\n%s\n' "$TERM_BAD" "$TERM_GOOD" >"$GIT_DIR/BISECT_TERMS"
-}
-
check_and_set_terms () {
cmd="$1"
case "$cmd" in
@@ -582,13 +570,17 @@ check_and_set_terms () {
bad|good)
if ! test -s "$GIT_DIR/BISECT_TERMS"
then
- write_terms bad good
+ TERM_BAD=bad
+ TERM_GOOD=good
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
fi
;;
new|old)
if ! test -s "$GIT_DIR/BISECT_TERMS"
then
- write_terms new old
+ TERM_BAD=new
+ TERM_GOOD=old
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
fi
;;
esac ;;
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v12 07/13] bisect--helper: `bisect_reset` shell function in C
2016-08-10 21:57 ` [PATCH v12 " Pranit Bauva
` (4 preceding siblings ...)
2016-08-10 21:57 ` [PATCH v12 03/13] bisect--helper: `write_terms` " Pranit Bauva
@ 2016-08-10 21:57 ` Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 06/13] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
` (7 subsequent siblings)
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-10 21:57 UTC (permalink / raw)
To: git
Reimplement `bisect_reset` shell function in C and add a `--bisect-reset`
subcommand to `git bisect--helper` to call it from git-bisect.sh .
Using `bisect_reset` subcommand is a temporary measure to port shell
functions to C so as to use the existing test suite. As more functions
are ported, this subcommand would be retired but its implementation will
be called by some other method.
Note: --bisect-clean-state subcommand has not been retired as there are
still a function namely `bisect_start()` which still uses this
subcommand.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 47 ++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 28 ++--------------------------
2 files changed, 48 insertions(+), 27 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 3fffa78..409e268 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -4,6 +4,8 @@
#include "bisect.h"
#include "refs.h"
#include "dir.h"
+#include "argv-array.h"
+#include "run-command.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
@@ -13,11 +15,13 @@ static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static GIT_PATH_FUNC(git_path_bisect_run, "BISECT_RUN")
static GIT_PATH_FUNC(git_path_head_name, "head-name")
static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
+static GIT_PATH_FUNC(git_path_bisect_head, "BISECT_HEAD")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-clean-state"),
+ N_("git bisect--helper --bisect-reset [<commit>]"),
NULL
};
@@ -125,12 +129,47 @@ static int bisect_clean_state(void)
return result;
}
+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, &oid))
+ return error(_("'%s' is not a valid commit"), commit);
+ strbuf_addstr(&branch, commit);
+ }
+
+ if (!file_exists(git_path_bisect_head())) {
+ struct argv_array argv = ARGV_ARRAY_INIT;
+ argv_array_pushl(&argv, "checkout", branch.buf, "--", NULL);
+ if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
+ error(_("Could not check out original HEAD '%s'. Try "
+ "'git bisect reset <commit>'."), branch.buf);
+ strbuf_release(&branch);
+ argv_array_clear(&argv);
+ return -1;
+ }
+ argv_array_clear(&argv);
+ }
+
+ strbuf_release(&branch);
+ return bisect_clean_state();
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
WRITE_TERMS,
- BISECT_CLEAN_STATE
+ BISECT_CLEAN_STATE,
+ BISECT_RESET
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -140,6 +179,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
+ OPT_CMDMODE(0, "bisect-reset", &cmdmode,
+ N_("reset the bisection state"), BISECT_RESET),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -162,6 +203,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc != 0)
die(_("--bisect-clean-state requires no arguments"));
return bisect_clean_state();
+ case BISECT_RESET:
+ if (argc > 1)
+ die(_("--bisect-reset requires either zero or one arguments"));
+ return bisect_reset(argc ? argv[0] : NULL);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index bbc57d2..18580b7 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -409,35 +409,11 @@ bisect_visualize() {
eval '"$@"' --bisect -- $(cat "$GIT_DIR/BISECT_NAMES")
}
-bisect_reset() {
- test -s "$GIT_DIR/BISECT_START" || {
- gettextln "We are not bisecting."
- return
- }
- case "$#" in
- 0) branch=$(cat "$GIT_DIR/BISECT_START") ;;
- 1) git rev-parse --quiet --verify "$1^{commit}" >/dev/null || {
- invalid="$1"
- die "$(eval_gettext "'\$invalid' is not a valid commit")"
- }
- branch="$1" ;;
- *)
- usage ;;
- esac
-
- if ! test -f "$GIT_DIR/BISECT_HEAD" && ! git checkout "$branch" --
- then
- die "$(eval_gettext "Could not check out original HEAD '\$branch'.
-Try 'git bisect reset <commit>'.")"
- fi
- git bisect--helper --bisect-clean-state || exit
-}
-
bisect_replay () {
file="$1"
test "$#" -eq 1 || die "$(gettext "No logfile given")"
test -r "$file" || die "$(eval_gettext "cannot read \$file for replaying")"
- bisect_reset
+ git bisect--helper --bisect-reset || exit
while read git bisect command rev
do
test "$git $bisect" = "git bisect" || test "$git" = "git-bisect" || continue
@@ -627,7 +603,7 @@ case "$#" in
visualize|view)
bisect_visualize "$@" ;;
reset)
- bisect_reset "$@" ;;
+ git bisect--helper --bisect-reset "$@" ;;
replay)
bisect_replay "$@" ;;
log)
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v12 02/13] bisect: rewrite `check_term_format` shell function in C
2016-08-10 21:57 ` [PATCH v12 " Pranit Bauva
@ 2016-08-10 21:57 ` Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 09/13] bisect--helper: `bisect_write` " Pranit Bauva
` (12 subsequent siblings)
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-10 21:57 UTC (permalink / raw)
To: git
Reimplement the `check_term_format` shell function in C and add
a `--check-term-format` subcommand to `git bisect--helper` to call it
from git-bisect.sh
Using `--check-term-format` subcommand is a temporary measure to port
shell function to C so as to use the existing test suite. As more
functions are ported, this subcommand will be retired and its
implementation will be called by some other method/subcommand. For
eg. In conversion of write_terms() of git-bisect.sh, the subcommand will
be removed and instead check_term_format() will be called in its C
implementation while a new subcommand will be introduced for write_terms().
Helped-by: Johannes Schindelein <Johannes.Schindelein@gmx.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 60 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 31 ++-----------------------
2 files changed, 61 insertions(+), 30 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 8111c91..a47f1f2 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -2,19 +2,73 @@
#include "cache.h"
#include "parse-options.h"
#include "bisect.h"
+#include "refs.h"
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
+ N_("git bisect--helper --check-term-format <term> <orig_term>"),
NULL
};
+/*
+ * 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",
+ "visualize", "replay", "log", "run", NULL))
+ 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;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
- enum { NEXT_ALL = 1 } cmdmode = 0;
+ enum {
+ NEXT_ALL = 1,
+ CHECK_TERM_FMT
+ } cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
+ OPT_CMDMODE(0, "check-term-format", &cmdmode,
+ N_("check format of the term"), CHECK_TERM_FMT),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -29,6 +83,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
switch (cmdmode) {
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
+ case CHECK_TERM_FMT:
+ if (argc != 2)
+ die(_("--check-term-format requires two arguments"));
+ return check_term_format(argv[0], argv[1]);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 5d1cb00..7d7965d 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -564,38 +564,11 @@ write_terms () {
then
die "$(gettext "please use two different terms")"
fi
- check_term_format "$TERM_BAD" bad
- check_term_format "$TERM_GOOD" good
+ git bisect--helper --check-term-format "$TERM_BAD" bad || exit
+ git bisect--helper --check-term-format "$TERM_GOOD" good || exit
printf '%s\n%s\n' "$TERM_BAD" "$TERM_GOOD" >"$GIT_DIR/BISECT_TERMS"
}
-check_term_format () {
- term=$1
- git check-ref-format refs/bisect/"$term" ||
- die "$(eval_gettext "'\$term' is not a valid term")"
- case "$term" in
- help|start|terms|skip|next|reset|visualize|replay|log|run)
- die "$(eval_gettext "can't use the builtin command '\$term' as a term")"
- ;;
- bad|new)
- if test "$2" != bad
- then
- # 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.
- die "$(eval_gettext "can't change the meaning of term '\$term'")"
- fi
- ;;
- good|old)
- if test "$2" != good
- then
- die "$(eval_gettext "can't change the meaning of term '\$term'")"
- fi
- ;;
- esac
-}
-
check_and_set_terms () {
cmd="$1"
case "$cmd" in
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v12 13/13] bisect--helper: `bisect_start` shell function partially in C
2016-08-10 21:57 ` [PATCH v12 " Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 02/13] bisect: rewrite `check_term_format` shell function in C Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 09/13] bisect--helper: `bisect_write` " Pranit Bauva
@ 2016-08-10 21:57 ` Pranit Bauva
2016-08-12 19:25 ` Junio C Hamano
2016-08-13 7:34 ` Christian Couder
2016-08-10 21:57 ` [PATCH v12 08/13] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function " Pranit Bauva
` (10 subsequent siblings)
13 siblings, 2 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-10 21:57 UTC (permalink / raw)
To: git
Reimplement the `bisect_start` shell function partially in C and add
`bisect-start` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
The last part is not converted because it calls another shell function.
`bisect_start` shell function will be completed after the `bisect_next`
shell function is ported in C.
Using `--bisect-start` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other methods.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 254 ++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 133 +------------------------
2 files changed, 254 insertions(+), 133 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index f912010..80116ba 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -7,6 +7,7 @@
#include "argv-array.h"
#include "run-command.h"
#include "prompt.h"
+#include "quote.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
@@ -27,6 +28,8 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
+ N_("git bisect--helper --bisect start [--term-{old,good}=<term> --term-{new,bad}=<term>]"
+ "[--no-checkout] [<bad> [<good>...]] [--] [<paths>...]"),
NULL
};
@@ -431,6 +434,244 @@ static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
return 0;
}
+static int bisect_start(struct bisect_terms *terms, int no_checkout,
+ const char **argv, int argc)
+{
+ int i, has_double_dash = 0, must_write_terms = 0, bad_seen = 0;
+ int flags, pathspec_pos;
+ 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 strbuf orig_args = STRBUF_INIT;
+ const char *head;
+ unsigned char sha1[20];
+ FILE *fp;
+ struct object_id oid;
+
+ if (is_bare_repository())
+ no_checkout = 1;
+
+ for (i = 0; i < argc; i++) {
+ char *commit_id = xstrfmt("%s^{commit}", argv[i]);
+ if (!strcmp(argv[i], "--")) {
+ has_double_dash = 1;
+ break;
+ }
+ else if (!strcmp(argv[i], "--no-checkout"))
+ no_checkout = 1;
+ else if (!strcmp(argv[i], "--term-good") ||
+ !strcmp(argv[i], "--term-old")) {
+ must_write_terms = 1;
+ strbuf_reset(&terms->term_good);
+ strbuf_addstr(&terms->term_good, argv[++i]);
+ }
+ else if (skip_prefix(argv[i], "--term-good=", &argv[i])) {
+ must_write_terms = 1;
+ strbuf_reset(&terms->term_good);
+ strbuf_addstr(&terms->term_good, argv[i]);
+ }
+ else if (skip_prefix(argv[i], "--term-old=", &argv[i])) {
+ must_write_terms = 1;
+ strbuf_reset(&terms->term_good);
+ strbuf_addstr(&terms->term_good, argv[i]);
+ }
+ else if (!strcmp(argv[i], "--term-bad") ||
+ !strcmp(argv[i], "--term-new")) {
+ must_write_terms = 1;
+ strbuf_reset(&terms->term_bad);
+ strbuf_addstr(&terms->term_bad, argv[++i]);
+ }
+ else if (skip_prefix(argv[i], "--term-bad=", &argv[i])) {
+ must_write_terms = 1;
+ strbuf_reset(&terms->term_bad);
+ strbuf_addstr(&terms->term_bad, argv[i]);
+ }
+ else if (skip_prefix(argv[i], "--term-new=", &argv[i])) {
+ must_write_terms = 1;
+ strbuf_reset(&terms->term_good);
+ strbuf_addstr(&terms->term_good, argv[i]);
+ }
+ else if (starts_with(argv[i], "--") &&
+ !one_of(argv[i], "--term-good", "--term-bad", NULL)) {
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ die(_("unrecognised option: '%s'"), argv[i]);
+ }
+ else if (get_oid(argv[i], &oid) && !has_double_dash) {
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ free(commit_id);
+ die(_("'%s' does not appear to be a valid revision"), argv[i]);
+ }
+ else {
+ free(commit_id);
+ string_list_append(&revs, oid_to_hex(&oid));
+ }
+ }
+ 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.
+ */
+ must_write_terms |= !!revs.nr;
+ for (i = 0; i < revs.nr; i++) {
+ if (bad_seen)
+ string_list_append(&states, terms->term_good.buf);
+ else {
+ bad_seen = 1;
+ string_list_append(&states, terms->term_bad.buf);
+ }
+ }
+
+ /*
+ * Verify HEAD
+ */
+ head = resolve_ref_unsafe("HEAD", 0, sha1, &flags);
+ if (!head) {
+ if (get_sha1("HEAD", sha1)) {
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ die(_("Bad HEAD - I need a HEAD"));
+ }
+ }
+ 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) {
+ struct argv_array argv = ARGV_ARRAY_INIT;
+ argv_array_pushl(&argv, "checkout", start_head.buf,
+ "--", NULL);
+ if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
+ error(_("checking out '%s' failed. Try 'git "
+ "bisect start <valid-branch>'."),
+ start_head.buf);
+ strbuf_release(&start_head);
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ return -1;
+ }
+ }
+ } else {
+ if (starts_with(head, "refs/heads/") ||
+ !get_oid_hex(head, &oid) || ref_exists(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())) {
+ strbuf_release(&start_head);
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ die(_("won't bisect on cg-seek'ed tree"));
+ }
+ if (starts_with(head, "refs/heads/")) {
+ strbuf_reset(&start_head);
+ strbuf_addstr(&start_head, head + 11);
+ }
+ else {
+ strbuf_reset(&start_head);
+ strbuf_addstr(&start_head, sha1_to_hex(sha1));
+ }
+ } else {
+ strbuf_release(&start_head);
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ die(_("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
+ */
+ if (write_file(git_path_bisect_start(), "%s\n", start_head.buf)) {
+ bisect_clean_state();
+ strbuf_release(&start_head);
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ return -1;
+ }
+
+ if (no_checkout) {
+ get_oid(start_head.buf, &oid);
+ if (update_ref(NULL, "BISECT_HEAD", oid.hash, NULL, 0,
+ UPDATE_REFS_MSG_ON_ERR)) {
+ bisect_clean_state();
+ strbuf_release(&start_head);
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ return -1;
+ }
+ }
+ strbuf_release(&start_head);
+
+ if (pathspec_pos < argc - 1)
+ sq_quote_argv(&bisect_names, argv + pathspec_pos, 0);
+ write_file(git_path_bisect_names(), "%s\n", bisect_names.buf);
+ strbuf_release(&bisect_names);
+
+ for (i = 0; i < states.nr; i++) {
+ if (bisect_write(states.items[i].string,
+ revs.items[i].string, terms, 1)) {
+ bisect_clean_state();
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ return -1;
+ }
+ }
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+
+ if (must_write_terms)
+ if (write_terms(terms->term_bad.buf, terms->term_good.buf)) {
+ bisect_clean_state();
+ return -1;
+ }
+
+ fp = fopen(git_path_bisect_log(), "a");
+ if (!fp) {
+ bisect_clean_state();
+ return -1;
+ }
+ if (fprintf(fp, "git bisect start") < 1) {
+ bisect_clean_state();
+ return -1;
+ }
+ sq_quote_argv(&orig_args, argv, 0);
+ if (fprintf(fp, "%s", orig_args.buf) < 0) {
+ bisect_clean_state();
+ strbuf_release(&orig_args);
+ return -1;
+ }
+ strbuf_release(&orig_args);
+ if (fprintf(fp, "\n") < 1) {
+ fclose(fp);
+ bisect_clean_state();
+ return -1;
+ }
+ fclose(fp);
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -442,7 +683,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_WRITE,
CHECK_AND_SET_TERMS,
BISECT_NEXT_CHECK,
- BISECT_TERMS
+ BISECT_TERMS,
+ BISECT_START
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -464,6 +706,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
OPT_CMDMODE(0, "bisect-terms", &cmdmode,
N_("print out the bisect terms"), BISECT_TERMS),
+ OPT_CMDMODE(0, "bisect-start", &cmdmode,
+ N_("start the bisect session"), BISECT_START),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -472,7 +716,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
bisect_terms_init(&terms);
argc = parse_options(argc, argv, prefix, options,
- git_bisect_helper_usage, PARSE_OPT_KEEP_UNKNOWN);
+ git_bisect_helper_usage,
+ PARSE_OPT_KEEP_DASHDASH | PARSE_OPT_KEEP_UNKNOWN);
if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
@@ -526,6 +771,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
die(_("--bisect-terms requires 0 or 1 argument"));
res = bisect_terms(&terms, argv, argc);
break;
+ case BISECT_START:
+ strbuf_addstr(&terms.term_good, "good");
+ strbuf_addstr(&terms.term_bad, "bad");
+ res = bisect_start(&terms, no_checkout, argv, argc);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index aea97c5f..ee504ca 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -72,122 +72,7 @@ bisect_autostart() {
}
bisect_start() {
- #
- # Check for one bad and then some good revisions.
- #
- has_double_dash=0
- for arg; do
- case "$arg" in --) has_double_dash=1; break ;; esac
- done
- orig_args=$(git rev-parse --sq-quote "$@")
- bad_seen=0
- eval=''
- must_write_terms=0
- revs=''
- if test "z$(git rev-parse --is-bare-repository)" != zfalse
- then
- mode=--no-checkout
- else
- mode=''
- fi
- while [ $# -gt 0 ]; do
- arg="$1"
- case "$arg" in
- --)
- shift
- break
- ;;
- --no-checkout)
- mode=--no-checkout
- shift ;;
- --term-good|--term-old)
- shift
- must_write_terms=1
- TERM_GOOD=$1
- shift ;;
- --term-good=*|--term-old=*)
- must_write_terms=1
- TERM_GOOD=${1#*=}
- shift ;;
- --term-bad|--term-new)
- shift
- must_write_terms=1
- TERM_BAD=$1
- shift ;;
- --term-bad=*|--term-new=*)
- must_write_terms=1
- TERM_BAD=${1#*=}
- shift ;;
- --*)
- die "$(eval_gettext "unrecognised option: '\$arg'")" ;;
- *)
- rev=$(git rev-parse -q --verify "$arg^{commit}") || {
- test $has_double_dash -eq 1 &&
- die "$(eval_gettext "'\$arg' does not appear to be a valid revision")"
- break
- }
- revs="$revs $rev"
- shift
- ;;
- esac
- done
-
- for rev in $revs
- do
- # 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.
- must_write_terms=1
-
- case $bad_seen in
- 0) state=$TERM_BAD ; bad_seen=1 ;;
- *) state=$TERM_GOOD ;;
- esac
- eval="$eval git bisect--helper --bisect-write '$state' '$rev' '$TERM_GOOD' '$TERM_BAD' 'nolog' &&"
- done
- #
- # Verify HEAD.
- #
- head=$(GIT_DIR="$GIT_DIR" git symbolic-ref -q HEAD) ||
- head=$(GIT_DIR="$GIT_DIR" git rev-parse --verify HEAD) ||
- die "$(gettext "Bad HEAD - I need a HEAD")"
-
- #
- # Check if we are bisecting.
- #
- start_head=''
- if test -s "$GIT_DIR/BISECT_START"
- then
- # Reset to the rev from where we started.
- start_head=$(cat "$GIT_DIR/BISECT_START")
- if test "z$mode" != "z--no-checkout"
- then
- git checkout "$start_head" -- ||
- die "$(eval_gettext "Checking out '\$start_head' failed. Try 'git bisect reset <valid-branch>'.")"
- fi
- else
- # Get rev from where we start.
- case "$head" in
- refs/heads/*|$_x40)
- # This error message should only be triggered by
- # cogito usage, and cogito users should understand
- # it relates to cg-seek.
- [ -s "$GIT_DIR/head-name" ] &&
- die "$(gettext "won't bisect on cg-seek'ed tree")"
- start_head="${head#refs/heads/}"
- ;;
- *)
- die "$(gettext "Bad HEAD - strange symbolic ref")"
- ;;
- esac
- fi
-
- #
- # Get rid of any old bisect state.
- #
- git bisect--helper --bisect-clean-state || exit
+ git bisect--helper --bisect-start $@ || exit
#
# Change state.
@@ -198,24 +83,10 @@ bisect_start() {
#
trap 'git bisect--helper --bisect-clean-state' 0
trap 'exit 255' 1 2 3 15
-
- #
- # Write new start state.
- #
- echo "$start_head" >"$GIT_DIR/BISECT_START" && {
- test "z$mode" != "z--no-checkout" ||
- git update-ref --no-deref BISECT_HEAD "$start_head"
- } &&
- git rev-parse --sq-quote "$@" >"$GIT_DIR/BISECT_NAMES" &&
- eval "$eval true" &&
- if test $must_write_terms -eq 1
- then
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD"
- fi &&
- echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
#
# Check if we can proceed to the next bisect state.
#
+ get_terms
bisect_auto_next
trap '-' 0
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v12 12/13] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-08-10 21:57 ` [PATCH v12 " Pranit Bauva
` (10 preceding siblings ...)
2016-08-10 21:57 ` [PATCH v12 05/13] t6030: explicitly test for bisection cleanup Pranit Bauva
@ 2016-08-10 21:57 ` Pranit Bauva
2016-08-10 22:19 ` [PATCH v12 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 " Pranit Bauva
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-10 21:57 UTC (permalink / raw)
To: git
Reimplement the `get_terms` and `bisect_terms` shell function in C and
add `bisect-terms` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Using `--bisect-terms` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by some other methods.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 59 ++++++++++++++++++++++++++++++++++++++++++++++--
git-bisect.sh | 35 ++--------------------------
2 files changed, 59 insertions(+), 35 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index b6e9973..f912010 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -26,6 +26,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
+ N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
NULL
};
@@ -384,6 +385,52 @@ static int bisect_next_check(const struct bisect_terms *terms,
return 0;
}
+static int get_terms(struct bisect_terms *terms)
+{
+ FILE *fp;
+ int res;
+ fp = fopen(git_path_bisect_terms(), "r");
+ if (!fp)
+ return -1;
+
+ bisect_terms_reset(terms);
+ res = strbuf_getline(&terms->term_bad, fp) == EOF ||
+ strbuf_getline(&terms->term_good, fp) == EOF;
+
+ fclose(fp);
+ return res ? -1 : 0;
+}
+
+static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
+{
+ int i;
+
+ if (get_terms(terms)) {
+ fprintf(stderr, N_("no terms defined\n"));
+ return -1;
+ }
+ if (argc == 0) {
+ printf(N_("Your current terms are %s for the old state\nand "
+ "%s for the new state.\n"), terms->term_good.buf,
+ terms->term_bad.buf);
+ return 0;
+ }
+
+ for (i = 0; i < argc; i++) {
+ if (!strcmp(argv[i], "--term-good"))
+ printf(N_("%s\n"), terms->term_good.buf);
+ else if (!strcmp(argv[i], "--term-bad"))
+ printf(N_("%s\n"), terms->term_bad.buf);
+ else
+ printf(N_("invalid argument %s for 'git bisect "
+ "terms'.\nSupported options are: "
+ "--term-good|--term-old and "
+ "--term-bad|--term-new."), argv[i]);
+ }
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -394,7 +441,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
CHECK_EXPECTED_REVS,
BISECT_WRITE,
CHECK_AND_SET_TERMS,
- BISECT_NEXT_CHECK
+ BISECT_NEXT_CHECK,
+ BISECT_TERMS
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -414,6 +462,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
+ OPT_CMDMODE(0, "bisect-terms", &cmdmode,
+ N_("print out the bisect terms"), BISECT_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -422,7 +472,7 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
bisect_terms_init(&terms);
argc = parse_options(argc, argv, prefix, options,
- git_bisect_helper_usage, 0);
+ git_bisect_helper_usage, PARSE_OPT_KEEP_UNKNOWN);
if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
@@ -471,6 +521,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
strbuf_addstr(&terms.term_bad, argv[1]);
res = bisect_next_check(&terms, argc == 3 ? argv[2] : NULL);
break;
+ case BISECT_TERMS:
+ if (argc > 1)
+ die(_("--bisect-terms requires 0 or 1 argument"));
+ res = bisect_terms(&terms, argv, argc);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index c2d6319..aea97c5f 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -355,7 +355,7 @@ bisect_replay () {
"$TERM_GOOD"|"$TERM_BAD"|skip)
git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
terms)
- bisect_terms $rev ;;
+ git bisect--helper --bisect-terms $rev || exit;;
*)
die "$(gettext "?? what are you talking about?")" ;;
esac
@@ -437,37 +437,6 @@ get_terms () {
fi
}
-bisect_terms () {
- get_terms
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- die "$(gettext "no terms defined")"
- fi
- case "$#" in
- 0)
- gettextln "Your current terms are $TERM_GOOD for the old state
-and $TERM_BAD for the new state."
- ;;
- 1)
- arg=$1
- case "$arg" in
- --term-good|--term-old)
- printf '%s\n' "$TERM_GOOD"
- ;;
- --term-bad|--term-new)
- printf '%s\n' "$TERM_BAD"
- ;;
- *)
- die "$(eval_gettext "invalid argument \$arg for 'git bisect terms'.
-Supported options are: --term-good|--term-old and --term-bad|--term-new.")"
- ;;
- esac
- ;;
- *)
- usage ;;
- esac
-}
-
case "$#" in
0)
usage ;;
@@ -498,7 +467,7 @@ case "$#" in
run)
bisect_run "$@" ;;
terms)
- bisect_terms "$@" ;;
+ git bisect--helper --bisect-terms "$@" || exit;;
*)
usage ;;
esac
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v12 04/13] bisect--helper: `bisect_clean_state` shell function in C
2016-08-10 21:57 ` [PATCH v12 " Pranit Bauva
` (7 preceding siblings ...)
2016-08-10 21:57 ` [PATCH v12 10/13] bisect--helper: `check_and_set_terms` shell function in C Pranit Bauva
@ 2016-08-10 21:57 ` Pranit Bauva
2016-08-12 19:24 ` Junio C Hamano
2016-08-10 21:57 ` [PATCH v12 11/13] bisect--helper: `bisect_next_check` & bisect_voc " Pranit Bauva
` (4 subsequent siblings)
13 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-10 21:57 UTC (permalink / raw)
To: git
Reimplement `bisect_clean_state` shell function in C and add a
`bisect-clean-state` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Using `--bisect-clean-state` subcommand is a measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by bisect_reset() and bisect_start().
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 55 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 26 +++--------------------
2 files changed, 57 insertions(+), 24 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 30e1031..3fffa78 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -3,12 +3,21 @@
#include "parse-options.h"
#include "bisect.h"
#include "refs.h"
+#include "dir.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
+static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
+static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
+static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
+static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
+static GIT_PATH_FUNC(git_path_bisect_run, "BISECT_RUN")
+static GIT_PATH_FUNC(git_path_head_name, "head-name")
+static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
+ N_("git bisect--helper --bisect-clean-state"),
NULL
};
@@ -79,11 +88,49 @@ static int write_terms(const char *bad, const char *good)
return (res < 0) ? -1 : 0;
}
+static int mark_for_removal(const char *refname, const struct object_id *oid,
+ int flag, void *cb_data)
+{
+ struct string_list *refs = cb_data;
+ char *ref = xstrfmt("refs/bisect/%s", refname);
+ string_list_append(refs, ref);
+ return 0;
+}
+
+static int bisect_clean_state(void)
+{
+ int result = 0;
+
+ /* There may be some refs packed during bisection */
+ struct string_list refs_for_removal = STRING_LIST_INIT_NODUP;
+ for_each_ref_in("refs/bisect/", mark_for_removal, (void *) &refs_for_removal);
+ string_list_append(&refs_for_removal, xstrdup("BISECT_HEAD"));
+ result = delete_refs(&refs_for_removal);
+ refs_for_removal.strdup_strings = 1;
+ string_list_clear(&refs_for_removal, 0);
+ unlink_or_warn(git_path_bisect_expected_rev());
+ unlink_or_warn(git_path_bisect_ancestors_ok());
+ unlink_or_warn(git_path_bisect_log());
+ unlink_or_warn(git_path_bisect_names());
+ unlink_or_warn(git_path_bisect_run());
+ unlink_or_warn(git_path_bisect_terms());
+ /* Cleanup head-name if it got left by an old version of git-bisect */
+ unlink_or_warn(git_path_head_name());
+ /*
+ * Cleanup BISECT_START last to support the --no-checkout option
+ * introduced in the commit 4796e823a.
+ */
+ unlink_or_warn(git_path_bisect_start());
+
+ return result;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
- WRITE_TERMS
+ WRITE_TERMS,
+ BISECT_CLEAN_STATE
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -91,6 +138,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("perform 'git bisect next'"), NEXT_ALL),
OPT_CMDMODE(0, "write-terms", &cmdmode,
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
+ OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
+ N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -109,6 +158,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc != 2)
die(_("--write-terms requires two arguments"));
return write_terms(argv[0], argv[1]);
+ case BISECT_CLEAN_STATE:
+ if (argc != 0)
+ die(_("--bisect-clean-state requires no arguments"));
+ return bisect_clean_state();
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index cd39bd0..bbc57d2 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -187,7 +187,7 @@ bisect_start() {
#
# Get rid of any old bisect state.
#
- bisect_clean_state || exit
+ git bisect--helper --bisect-clean-state || exit
#
# Change state.
@@ -196,7 +196,7 @@ bisect_start() {
# We have to trap this to be able to clean up using
# "bisect_clean_state".
#
- trap 'bisect_clean_state' 0
+ trap 'git bisect--helper --bisect-clean-state' 0
trap 'exit 255' 1 2 3 15
#
@@ -430,27 +430,7 @@ bisect_reset() {
die "$(eval_gettext "Could not check out original HEAD '\$branch'.
Try 'git bisect reset <commit>'.")"
fi
- bisect_clean_state
-}
-
-bisect_clean_state() {
- # There may be some refs packed during bisection.
- git for-each-ref --format='%(refname) %(objectname)' refs/bisect/\* |
- while read ref hash
- do
- git update-ref -d $ref $hash || exit
- done
- rm -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
- rm -f "$GIT_DIR/BISECT_ANCESTORS_OK" &&
- rm -f "$GIT_DIR/BISECT_LOG" &&
- rm -f "$GIT_DIR/BISECT_NAMES" &&
- rm -f "$GIT_DIR/BISECT_RUN" &&
- rm -f "$GIT_DIR/BISECT_TERMS" &&
- # Cleanup head-name if it got left by an old version of git-bisect
- rm -f "$GIT_DIR/head-name" &&
- git update-ref -d --no-deref BISECT_HEAD &&
- # clean up BISECT_START last
- rm -f "$GIT_DIR/BISECT_START"
+ git bisect--helper --bisect-clean-state || exit
}
bisect_replay () {
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v12 08/13] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C
2016-08-10 21:57 ` [PATCH v12 " Pranit Bauva
` (2 preceding siblings ...)
2016-08-10 21:57 ` [PATCH v12 13/13] bisect--helper: `bisect_start` shell function partially " Pranit Bauva
@ 2016-08-10 21:57 ` Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 03/13] bisect--helper: `write_terms` " Pranit Bauva
` (9 subsequent siblings)
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-10 21:57 UTC (permalink / raw)
To: git
Reimplement `is_expected_rev` & `check_expected_revs` shell function in
C and add a `--check-expected-revs` subcommand to `git bisect--helper` to
call it from git-bisect.sh .
Using `--check-expected-revs` subcommand is a temporary measure to port
shell functions to C so as to use the existing test suite. As more
functions are ported, this subcommand would be retired but its
implementation will be called by some other method.
Helped-by: Eric Sunshine <sunshine@sunshineco.com>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 33 ++++++++++++++++++++++++++++++++-
git-bisect.sh | 20 ++------------------
2 files changed, 34 insertions(+), 19 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 409e268..c03042f 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -163,13 +163,40 @@ static int bisect_reset(const char *commit)
return bisect_clean_state();
}
+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) >= 0) {
+ strbuf_trim(&actual_hex);
+ res = !strcmp(actual_hex.buf, expected_hex);
+ }
+ strbuf_release(&actual_hex);
+ return res;
+}
+
+static int 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());
+ return 0;
+ }
+ }
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
WRITE_TERMS,
BISECT_CLEAN_STATE,
- BISECT_RESET
+ BISECT_RESET,
+ CHECK_EXPECTED_REVS
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -181,6 +208,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
N_("reset the bisection state"), BISECT_RESET),
+ OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
+ N_("check for expected revs"), CHECK_EXPECTED_REVS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -207,6 +236,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc > 1)
die(_("--bisect-reset requires either zero or one arguments"));
return bisect_reset(argc ? argv[0] : NULL);
+ case CHECK_EXPECTED_REVS:
+ return check_expected_revs(argv, argc);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 18580b7..4f6545e 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -238,22 +238,6 @@ bisect_write() {
test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
}
-is_expected_rev() {
- test -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
- test "$1" = $(cat "$GIT_DIR/BISECT_EXPECTED_REV")
-}
-
-check_expected_revs() {
- for _rev in "$@"; do
- if ! is_expected_rev "$_rev"
- then
- rm -f "$GIT_DIR/BISECT_ANCESTORS_OK"
- rm -f "$GIT_DIR/BISECT_EXPECTED_REV"
- return
- fi
- done
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -280,7 +264,7 @@ bisect_state() {
rev=$(git rev-parse --verify $(bisect_head)) ||
die "$(gettext "Bad rev input: $(bisect_head)")"
bisect_write "$state" "$rev"
- check_expected_revs "$rev" ;;
+ git bisect--helper --check-expected-revs "$rev" ;;
2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
shift
hash_list=''
@@ -294,7 +278,7 @@ bisect_state() {
do
bisect_write "$state" "$rev"
done
- check_expected_revs $hash_list ;;
+ git bisect--helper --check-expected-revs $hash_list ;;
*,"$TERM_BAD")
die "$(eval_gettext "'git bisect \$TERM_BAD' can take only one argument.")" ;;
*)
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v12 05/13] t6030: explicitly test for bisection cleanup
2016-08-10 21:57 ` [PATCH v12 " Pranit Bauva
` (9 preceding siblings ...)
2016-08-10 21:57 ` [PATCH v12 11/13] bisect--helper: `bisect_next_check` & bisect_voc " Pranit Bauva
@ 2016-08-10 21:57 ` Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 12/13] bisect--helper: `get_terms` & `bisect_terms` shell function in C Pranit Bauva
` (2 subsequent siblings)
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-10 21:57 UTC (permalink / raw)
To: git
Add test to explicitly check that 'git bisect reset' is working as
expected. This is already covered implicitly by the test suite.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
I faced this problem while converting `bisect_clean_state` and the tests
where showing breakages but it wasn't clear as to where exactly are they
breaking. This will patch will help in that. Also I tested the test
coverage of the test suite before this patch and it covers this (I did
this by purposely changing names of files in git-bisect.sh and running
the test suite).
---
t/t6030-bisect-porcelain.sh | 17 +++++++++++++++++
1 file changed, 17 insertions(+)
diff --git a/t/t6030-bisect-porcelain.sh b/t/t6030-bisect-porcelain.sh
index e74662b..a17f7a6 100755
--- a/t/t6030-bisect-porcelain.sh
+++ b/t/t6030-bisect-porcelain.sh
@@ -894,4 +894,21 @@ test_expect_success 'bisect start takes options and revs in any order' '
test_cmp expected actual
'
+test_expect_success 'git bisect reset cleans bisection state properly' '
+ git bisect reset &&
+ git bisect start &&
+ git bisect good $HASH1 &&
+ git bisect bad $HASH4 &&
+ git bisect reset &&
+ test -z "$(git for-each-ref "refs/bisect/*")" &&
+ test_path_is_missing "$GIT_DIR/BISECT_EXPECTED_REV" &&
+ test_path_is_missing "$GIT_DIR/BISECT_ANCESTORS_OK" &&
+ test_path_is_missing "$GIT_DIR/BISECT_LOG" &&
+ test_path_is_missing "$GIT_DIR/BISECT_RUN" &&
+ test_path_is_missing "$GIT_DIR/BISECT_TERMS" &&
+ test_path_is_missing "$GIT_DIR/head-name" &&
+ test_path_is_missing "$GIT_DIR/BISECT_HEAD" &&
+ test_path_is_missing "$GIT_DIR/BISECT_START"
+'
+
test_done
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v12 09/13] bisect--helper: `bisect_write` shell function in C
2016-08-10 21:57 ` [PATCH v12 " Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 02/13] bisect: rewrite `check_term_format` shell function in C Pranit Bauva
@ 2016-08-10 21:57 ` Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 13/13] bisect--helper: `bisect_start` shell function partially " Pranit Bauva
` (11 subsequent siblings)
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-10 21:57 UTC (permalink / raw)
To: git
Reimplement the `bisect_write` shell function in C and add a
`bisect-write` subcommand to `git bisect--helper` to call it from
git-bisect.sh
Using `--bisect-write` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by some other methods.
Note: bisect_write() uses two variables namely TERM_GOOD and TERM_BAD
from the global shell script thus we need to pass it to the subcommand
using the arguments. We then store them in a struct bisect_terms and
pass the memory address around functions.
This patch also introduces new methods namely bisect_state_init() and
bisect_terms_release() for easy memory management for the struct
bisect_terms.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 97 ++++++++++++++++++++++++++++++++++++++++++++----
git-bisect.sh | 25 ++-----------
2 files changed, 94 insertions(+), 28 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index c03042f..9f70edb 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -22,9 +22,27 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-clean-state"),
N_("git bisect--helper --bisect-reset [<commit>]"),
+ N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
NULL
};
+struct bisect_terms {
+ struct strbuf term_good;
+ struct strbuf term_bad;
+};
+
+static void bisect_terms_init(struct bisect_terms *terms)
+{
+ strbuf_init(&terms->term_good, 0);
+ strbuf_init(&terms->term_bad, 0);
+}
+
+static void bisect_terms_release(struct bisect_terms *terms)
+{
+ strbuf_release(&terms->term_good);
+ strbuf_release(&terms->term_bad);
+}
+
/*
* Check whether the string `term` belongs to the set of strings
* included in the variable arguments.
@@ -189,6 +207,52 @@ static int check_expected_revs(const char **revs, int rev_nr)
return 0;
}
+static int bisect_write(const char *state, const char *rev,
+ const struct bisect_terms *terms, int nolog)
+{
+ struct strbuf tag = STRBUF_INIT;
+ struct strbuf commit_name = STRBUF_INIT;
+ struct object_id oid;
+ struct commit *commit;
+ struct pretty_print_context pp = {0};
+ FILE *fp;
+
+ if (!strcmp(state, terms->term_bad.buf))
+ strbuf_addf(&tag, "refs/bisect/%s", state);
+ else if (one_of(state, terms->term_good.buf, "skip", NULL))
+ strbuf_addf(&tag, "refs/bisect/%s-%s", state, rev);
+ else
+ return error(_("Bad bisect_write argument: %s"), state);
+
+ if (get_oid(rev, &oid)) {
+ strbuf_release(&tag);
+ return error(_("couldn't get the oid of the rev '%s'"), rev);
+ }
+
+ if (update_ref(NULL, tag.buf, oid.hash, NULL, 0,
+ UPDATE_REFS_MSG_ON_ERR)) {
+ strbuf_release(&tag);
+ return -1;
+ }
+ strbuf_release(&tag);
+
+ fp = fopen(git_path_bisect_log(), "a");
+ if (!fp)
+ return error_errno(_("couldn't open the file '%s'"), git_path_bisect_log());
+
+ commit = lookup_commit_reference(oid.hash);
+ format_commit_message(commit, "%s", &commit_name, &pp);
+ fprintf(fp, "# %s: [%s] %s\n", state, sha1_to_hex(oid.hash),
+ commit_name.buf);
+ strbuf_release(&commit_name);
+
+ if (!nolog)
+ fprintf(fp, "git bisect %s %s\n", state, rev);
+
+ fclose(fp);
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -196,9 +260,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
WRITE_TERMS,
BISECT_CLEAN_STATE,
BISECT_RESET,
- CHECK_EXPECTED_REVS
+ CHECK_EXPECTED_REVS,
+ BISECT_WRITE
} cmdmode = 0;
- int no_checkout = 0;
+ int no_checkout = 0, res = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
@@ -210,10 +275,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("reset the bisection state"), BISECT_RESET),
OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
N_("check for expected revs"), CHECK_EXPECTED_REVS),
+ OPT_CMDMODE(0, "bisect-write", &cmdmode,
+ N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
};
+ struct bisect_terms terms;
+ bisect_terms_init(&terms);
argc = parse_options(argc, argv, prefix, options,
git_bisect_helper_usage, 0);
@@ -222,24 +291,38 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
usage_with_options(git_bisect_helper_usage, options);
switch (cmdmode) {
+ int nolog;
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
case WRITE_TERMS:
if (argc != 2)
die(_("--write-terms requires two arguments"));
- return write_terms(argv[0], argv[1]);
+ res = write_terms(argv[0], argv[1]);
+ break;
case BISECT_CLEAN_STATE:
if (argc != 0)
die(_("--bisect-clean-state requires no arguments"));
- return bisect_clean_state();
+ res = bisect_clean_state();
+ break;
case BISECT_RESET:
if (argc > 1)
die(_("--bisect-reset requires either zero or one arguments"));
- return bisect_reset(argc ? argv[0] : NULL);
+ res = bisect_reset(argc ? argv[0] : NULL);
+ break;
case CHECK_EXPECTED_REVS:
- return check_expected_revs(argv, argc);
+ res = check_expected_revs(argv, argc);
+ break;
+ case BISECT_WRITE:
+ if (argc != 4 && argc != 5)
+ die(_("--bisect-write requires either 4 or 5 arguments"));
+ nolog = (argc == 5) && !strcmp(argv[4], "nolog");
+ strbuf_addstr(&terms.term_good, argv[2]);
+ strbuf_addstr(&terms.term_bad, argv[3]);
+ res = bisect_write(argv[0], argv[1], &terms, nolog);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
- return 0;
+ bisect_terms_release(&terms);
+ return res;
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 4f6545e..b9896a4 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -145,7 +145,7 @@ bisect_start() {
0) state=$TERM_BAD ; bad_seen=1 ;;
*) state=$TERM_GOOD ;;
esac
- eval="$eval bisect_write '$state' '$rev' 'nolog' &&"
+ eval="$eval git bisect--helper --bisect-write '$state' '$rev' '$TERM_GOOD' '$TERM_BAD' 'nolog' &&"
done
#
# Verify HEAD.
@@ -221,23 +221,6 @@ bisect_start() {
trap '-' 0
}
-bisect_write() {
- state="$1"
- rev="$2"
- nolog="$3"
- case "$state" in
- "$TERM_BAD")
- tag="$state" ;;
- "$TERM_GOOD"|skip)
- tag="$state"-"$rev" ;;
- *)
- die "$(eval_gettext "Bad bisect_write argument: \$state")" ;;
- esac
- git update-ref "refs/bisect/$tag" "$rev" || exit
- echo "# $state: $(git show-branch $rev)" >>"$GIT_DIR/BISECT_LOG"
- test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -263,7 +246,7 @@ bisect_state() {
1,"$TERM_BAD"|1,"$TERM_GOOD"|1,skip)
rev=$(git rev-parse --verify $(bisect_head)) ||
die "$(gettext "Bad rev input: $(bisect_head)")"
- bisect_write "$state" "$rev"
+ git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
git bisect--helper --check-expected-revs "$rev" ;;
2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
shift
@@ -276,7 +259,7 @@ bisect_state() {
done
for rev in $hash_list
do
- bisect_write "$state" "$rev"
+ git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
done
git bisect--helper --check-expected-revs $hash_list ;;
*,"$TERM_BAD")
@@ -413,7 +396,7 @@ bisect_replay () {
cmd="bisect_start $rev"
eval "$cmd" ;;
"$TERM_GOOD"|"$TERM_BAD"|skip)
- bisect_write "$command" "$rev" ;;
+ git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
terms)
bisect_terms $rev ;;
*)
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v12 11/13] bisect--helper: `bisect_next_check` & bisect_voc shell function in C
2016-08-10 21:57 ` [PATCH v12 " Pranit Bauva
` (8 preceding siblings ...)
2016-08-10 21:57 ` [PATCH v12 04/13] bisect--helper: `bisect_clean_state` " Pranit Bauva
@ 2016-08-10 21:57 ` Pranit Bauva
2016-08-12 18:11 ` Junio C Hamano
2016-08-10 21:57 ` [PATCH v12 05/13] t6030: explicitly test for bisection cleanup Pranit Bauva
` (3 subsequent siblings)
13 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-10 21:57 UTC (permalink / raw)
To: git
Reimplement `bisect_next_check` shell function in C and add
`bisect-next-check` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Also reimplement `bisect_voc` shell function in C and call it from
`bisect_next_check` implementation in C.
Using `--bisect-next-check` is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by some other methods.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 103 ++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 60 ++-------------------------
2 files changed, 106 insertions(+), 57 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 5c4350f..b6e9973 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -6,6 +6,7 @@
#include "dir.h"
#include "argv-array.h"
#include "run-command.h"
+#include "prompt.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
@@ -24,6 +25,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
+ N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
NULL
};
@@ -293,6 +295,95 @@ static int check_and_set_terms(struct bisect_terms *terms, const char *cmd)
return 0;
}
+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;
+}
+
+static char *bisect_voc(char *revision_type)
+{
+ if (!strcmp(revision_type, "bad"))
+ return "bad|new";
+ if (!strcmp(revision_type, "good"))
+ return "good|old";
+
+ return NULL;
+}
+
+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.buf);
+ char *good_glob = xstrfmt("%s-*", terms->term_good.buf);
+ char *bad_syn, *good_syn;
+
+ if (ref_exists(bad_ref))
+ missing_bad = 0;
+ free(bad_ref);
+
+ for_each_glob_ref_in(mark_good, good_glob, "refs/bisect/",
+ (void *) &missing_good);
+ free(good_glob);
+
+ if (!missing_good && !missing_bad)
+ return 0;
+
+ if (!current_term)
+ return -1;
+
+ if (missing_good && !missing_bad && current_term &&
+ !strcmp(current_term, terms->term_good.buf)) {
+ char *yesno;
+ /*
+ * have bad (or new) but not good (or old). We could bisect
+ * although this is less optimum.
+ */
+ fprintf(stderr, N_("Warning: bisecting only with a %s commit\n"),
+ terms->term_bad.buf);
+ if (!isatty(0))
+ return 0;
+ /*
+ * 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"))
+ return -1;
+
+ return 0;
+ }
+ bad_syn = xstrdup(bisect_voc("bad"));
+ good_syn = xstrdup(bisect_voc("good"));
+ if (!is_empty_or_missing_file(git_path_bisect_start())) {
+ error(_("You need to give me at least one %s and "
+ "%s revision. You can use \"git bisect %s\" "
+ "and \"git bisect %s\" for that. \n"),
+ bad_syn, good_syn, bad_syn, good_syn);
+ free(bad_syn);
+ free(good_syn);
+ return -1;
+ }
+ else {
+ error(_("You need to start by \"git bisect start\". You "
+ "then need to give me at least one %s and %s "
+ "revision. You can use \"git bisect %s\" and "
+ "\"git bisect %s\" for that.\n"),
+ good_syn, bad_syn, bad_syn, good_syn);
+ free(bad_syn);
+ free(good_syn);
+ return -1;
+ }
+ free(bad_syn);
+ free(good_syn);
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -302,7 +393,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_RESET,
CHECK_EXPECTED_REVS,
BISECT_WRITE,
- CHECK_AND_SET_TERMS
+ CHECK_AND_SET_TERMS,
+ BISECT_NEXT_CHECK
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -320,6 +412,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
+ OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
+ N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -370,6 +464,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
strbuf_addstr(&terms.term_bad, argv[2]);
res = check_and_set_terms(&terms, argv[0]);
break;
+ case BISECT_NEXT_CHECK:
+ if (argc != 2 && argc != 3)
+ die(_("--bisect-next-check requires 2 or 3 arguments"));
+ strbuf_addstr(&terms.term_good, argv[0]);
+ strbuf_addstr(&terms.term_bad, argv[1]);
+ res = bisect_next_check(&terms, argc == 3 ? argv[2] : NULL);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index a41e69b..c2d6319 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -271,59 +271,14 @@ bisect_state() {
bisect_auto_next
}
-bisect_next_check() {
- missing_good= missing_bad=
- git show-ref -q --verify refs/bisect/$TERM_BAD || missing_bad=t
- test -n "$(git for-each-ref "refs/bisect/$TERM_GOOD-*")" || missing_good=t
-
- case "$missing_good,$missing_bad,$1" in
- ,,*)
- : have both $TERM_GOOD and $TERM_BAD - ok
- ;;
- *,)
- # do not have both but not asked to fail - just report.
- false
- ;;
- t,,"$TERM_GOOD")
- # have bad (or new) but not good (or old). we could bisect although
- # this is less optimum.
- eval_gettextln "Warning: bisecting only with a \$TERM_BAD commit." >&2
- if test -t 0
- then
- # TRANSLATORS: Make sure to include [Y] and [n] in your
- # translation. The program will only accept English input
- # at this point.
- gettext "Are you sure [Y/n]? " >&2
- read yesno
- case "$yesno" in [Nn]*) exit 1 ;; esac
- fi
- : bisect without $TERM_GOOD...
- ;;
- *)
- bad_syn=$(bisect_voc bad)
- good_syn=$(bisect_voc good)
- if test -s "$GIT_DIR/BISECT_START"
- then
-
- eval_gettextln "You need to give me at least one \$bad_syn and one \$good_syn revision.
-(You can use \"git bisect \$bad_syn\" and \"git bisect \$good_syn\" for that.)" >&2
- else
- eval_gettextln "You need to start by \"git bisect start\".
-You then need to give me at least one \$good_syn and one \$bad_syn revision.
-(You can use \"git bisect \$bad_syn\" and \"git bisect \$good_syn\" for that.)" >&2
- fi
- exit 1 ;;
- esac
-}
-
bisect_auto_next() {
- bisect_next_check && bisect_next || :
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD && bisect_next || :
}
bisect_next() {
case "$#" in 0) ;; *) usage ;; esac
bisect_autostart
- bisect_next_check $TERM_GOOD
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD $TERM_GOOD|| exit
# Perform all bisection computation, display and checkout
git bisect--helper --next-all $(test -f "$GIT_DIR/BISECT_HEAD" && echo --no-checkout)
@@ -355,7 +310,7 @@ bisect_next() {
}
bisect_visualize() {
- bisect_next_check fail
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD fail || exit
if test $# = 0
then
@@ -409,7 +364,7 @@ bisect_replay () {
}
bisect_run () {
- bisect_next_check fail
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD fail || exit
while true
do
@@ -482,13 +437,6 @@ get_terms () {
fi
}
-bisect_voc () {
- case "$1" in
- bad) echo "bad|new" ;;
- good) echo "good|old" ;;
- esac
-}
-
bisect_terms () {
get_terms
if ! test -s "$GIT_DIR/BISECT_TERMS"
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v12 06/13] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file()
2016-08-10 21:57 ` [PATCH v12 " Pranit Bauva
` (5 preceding siblings ...)
2016-08-10 21:57 ` [PATCH v12 07/13] bisect--helper: `bisect_reset` " Pranit Bauva
@ 2016-08-10 21:57 ` Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 10/13] bisect--helper: `check_and_set_terms` shell function in C Pranit Bauva
` (6 subsequent siblings)
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-10 21:57 UTC (permalink / raw)
To: git
is_empty_file() can help to refactor a lot of code. This will be very
helpful in porting "git bisect" to C.
Suggested-by: Torsten Bögershausen <tboegi@web.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/am.c | 20 ++------------------
cache.h | 3 +++
wrapper.c | 13 +++++++++++++
3 files changed, 18 insertions(+), 18 deletions(-)
diff --git a/builtin/am.c b/builtin/am.c
index 3dfe70b..6ee158f 100644
--- a/builtin/am.c
+++ b/builtin/am.c
@@ -30,22 +30,6 @@
#include "mailinfo.h"
/**
- * Returns 1 if the file is empty or does not exist, 0 otherwise.
- */
-static int is_empty_file(const char *filename)
-{
- struct stat st;
-
- if (stat(filename, &st) < 0) {
- if (errno == ENOENT)
- return 1;
- die_errno(_("could not stat %s"), filename);
- }
-
- return !st.st_size;
-}
-
-/**
* Returns the length of the first line of msg.
*/
static int linelen(const char *msg)
@@ -1323,7 +1307,7 @@ static int parse_mail(struct am_state *state, const char *mail)
goto finish;
}
- if (is_empty_file(am_path(state, "patch"))) {
+ if (is_empty_or_missing_file(am_path(state, "patch"))) {
printf_ln(_("Patch is empty. Was it split wrong?"));
die_user_resolve(state);
}
@@ -1911,7 +1895,7 @@ static void am_run(struct am_state *state, int resume)
resume = 0;
}
- if (!is_empty_file(am_path(state, "rewritten"))) {
+ if (!is_empty_or_missing_file(am_path(state, "rewritten"))) {
assert(state->rebasing);
copy_notes_for_rebase(state);
run_post_rewrite_hook(state);
diff --git a/cache.h b/cache.h
index 6049f86..91e2f81 100644
--- a/cache.h
+++ b/cache.h
@@ -1870,4 +1870,7 @@ void sleep_millisec(int millisec);
*/
void safe_create_dir(const char *dir, int share);
+/* Return 1 if the file is empty or does not exists, 0 otherwise. */
+extern int is_empty_or_missing_file(const char *filename);
+
#endif /* CACHE_H */
diff --git a/wrapper.c b/wrapper.c
index 5dc4e15..e70e4d1 100644
--- a/wrapper.c
+++ b/wrapper.c
@@ -696,3 +696,16 @@ void sleep_millisec(int millisec)
{
poll(NULL, 0, millisec);
}
+
+int is_empty_or_missing_file(const char *filename)
+{
+ struct stat st;
+
+ if (stat(filename, &st) < 0) {
+ if (errno == ENOENT)
+ return 1;
+ die_errno(_("could not stat %s"), filename);
+ }
+
+ return !st.st_size;
+}
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* Re: [PATCH v12 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2016-08-10 21:57 ` [PATCH v12 " Pranit Bauva
` (11 preceding siblings ...)
2016-08-10 21:57 ` [PATCH v12 12/13] bisect--helper: `get_terms` & `bisect_terms` shell function in C Pranit Bauva
@ 2016-08-10 22:19 ` Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 " Pranit Bauva
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-10 22:19 UTC (permalink / raw)
To: Git List; +Cc: Junio C Hamano, Christian Couder, Lars Schneider
Here[1] is the link for interdiff. Sorry could not send a cover patch
or put it in here. I am under a proxy which blocks IMAP/SMTP
connections and gmail wraps the lines.
[1]: http://paste.ubuntu.com/22794990/
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v12 11/13] bisect--helper: `bisect_next_check` & bisect_voc shell function in C
2016-08-10 21:57 ` [PATCH v12 11/13] bisect--helper: `bisect_next_check` & bisect_voc " Pranit Bauva
@ 2016-08-12 18:11 ` Junio C Hamano
2016-08-12 18:49 ` Junio C Hamano
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-12 18:11 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> +static char *bisect_voc(char *revision_type)
> +{
> + if (!strcmp(revision_type, "bad"))
> + return "bad|new";
> + if (!strcmp(revision_type, "good"))
> + return "good|old";
> +
> + return NULL;
> +}
I think you can return "const char *" from the above function. Then
you do not have to do xstrdup() on the return values to store in
bad_syn and good_syn, and you do not have to free(3) them.
> +static int bisect_next_check(const struct bisect_terms *terms,
> + const char *current_term)
> +{
> + ....
> + fprintf(stderr, N_("Warning: bisecting only with a %s commit\n"),
> + terms->term_bad.buf);
Hmph, is this N_() and not _()?
> + ....
> + }
> + bad_syn = xstrdup(bisect_voc("bad"));
> + good_syn = xstrdup(bisect_voc("good"));
> + ....
> + free(bad_syn);
> + free(good_syn);
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v12 11/13] bisect--helper: `bisect_next_check` & bisect_voc shell function in C
2016-08-12 18:11 ` Junio C Hamano
@ 2016-08-12 18:49 ` Junio C Hamano
2016-08-13 6:32 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-12 18:49 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Junio C Hamano <gitster@pobox.com> writes:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> +static int bisect_next_check(const struct bisect_terms *terms,
>> + const char *current_term)
>> +{
>> + ....
>> + fprintf(stderr, N_("Warning: bisecting only with a %s commit\n"),
>> + terms->term_bad.buf);
>
> Hmph, is this N_() and not _()?
I recall you saying that you are not familiar with i18n. As it is a
good skill to have outside the context of this project, let's do a
quick primer. GSoC is a learning experience ;-).
There is a runtime function "gettext()" that takes a string, which
is typically a printf format string, and gives another string. You
feed your message in the original language, meant to be used in the
C locale, and the function gives it translated into the end-user's
language, specified by environment variables like $LC_MESSAGES.
Since it is too cumbersome to write gettext() all the time, _()
exists as a short-hand for it. So running this
printf(_("Hello, world\n"));
would look up "Hello world\n" in database for the end-user's
language, and shows the translated message instead.
By scanning the source text, you can extract these constant strings
passed to gettext() or _(). This is done by the i18n coordinator
with the "msgmerge" program. By doing so, we learn "Hello, world\n"
must be translated, and then ask i18n team to translate it to their
language. The result is what we have in the l10n database. They
are in po/*.po files in our source tree.
Sometimes, the message you want to be translated may be in a
variable, e.g.
void greeting(const char *message)
{
printf(_(message));
}
int main(int ac, char **av)
{
int i;
const char *message[] = {
"Hello, world\n",
"Goodbye, everybody\n",
};
for (i = 0; i < ARRAY_SIZE(message); i++)
greeting(message[i]);
}
And scanning the source would not find "Hello, world\n" or "Goodby,
everybody\n" must be translated. We do not want to do this:
...
const char *message[] = {
*BAD* _("Hello, world\n"),
*BAD* _("Goodbye, everybody\n"),
};
...
because we do *NOT* want to call gettext() there (we call the
function at runtime inside greeting() instead). We use N_()
to mark such messages, like so:
...
const char *message[] = {
*GOOD* N_("Hello, world\n"),
*GOOD* N_("Goodbye, everybody\n"),
};
...
The N_() macro is a no-op at runtime. It just is there so that
"msgmerge" can notice that the constant string there is something
that needs to be thrown into the l10n database.
As a concrete example:
> @@ -24,6 +25,7 @@ static const char * const git_bisect_helper_usage[] = {
> N_("git bisect--helper --bisect-reset [<commit>]"),
> N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
> N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
> + N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
> NULL
> };
this is such a use of N_(). You want to keep untranslated message
in the git_bisect_helper_usage[] array, to be given to gettext(), or
more likely its short-hand _(), when these usage strings are used,
and make sure these strings will be in the l10n database so that
translators will give you translations to them to be used at
runtime.
> + /*
> + * have bad (or new) but not good (or old). We could bisect
> + * although this is less optimum.
> + */
> + fprintf(stderr, N_("Warning: bisecting only with a %s commit\n"),
> + terms->term_bad.buf);
This one wants to call gettext() function to give fprintf() the
translated warning message. It should be _().
> + /*
> + * 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);
Just like this one.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v12 04/13] bisect--helper: `bisect_clean_state` shell function in C
2016-08-10 21:57 ` [PATCH v12 04/13] bisect--helper: `bisect_clean_state` " Pranit Bauva
@ 2016-08-12 19:24 ` Junio C Hamano
0 siblings, 0 replies; 320+ messages in thread
From: Junio C Hamano @ 2016-08-12 19:24 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> +static int bisect_clean_state(void)
> +{
> + int result = 0;
> +
> + /* There may be some refs packed during bisection */
> + struct string_list refs_for_removal = STRING_LIST_INIT_NODUP;
> + for_each_ref_in("refs/bisect/", mark_for_removal, (void *) &refs_for_removal);
> + string_list_append(&refs_for_removal, xstrdup("BISECT_HEAD"));
> + result = delete_refs(&refs_for_removal);
I think this function has changed its signature recently. I am
planning to tag 2.10-rc0 this weekend, and it may be a good time to
rebase the series on to an updated codebase.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v12 13/13] bisect--helper: `bisect_start` shell function partially in C
2016-08-10 21:57 ` [PATCH v12 13/13] bisect--helper: `bisect_start` shell function partially " Pranit Bauva
@ 2016-08-12 19:25 ` Junio C Hamano
2016-08-13 6:33 ` Pranit Bauva
2016-08-13 7:34 ` Christian Couder
1 sibling, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-12 19:25 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> + ...
> + /*
> + * Write new start state
> + */
> + if (write_file(git_path_bisect_start(), "%s\n", start_head.buf)) {
I think this function has changed its signature recently. I am
planning to tag 2.10-rc0 this weekend, and it may be a good time to
rebase the series on to an updated codebase.
Thanks.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v12 11/13] bisect--helper: `bisect_next_check` & bisect_voc shell function in C
2016-08-12 18:49 ` Junio C Hamano
@ 2016-08-13 6:32 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-13 6:32 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Sat, Aug 13, 2016 at 12:19 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Junio C Hamano <gitster@pobox.com> writes:
>
>> Pranit Bauva <pranit.bauva@gmail.com> writes:
>>
>>> +static int bisect_next_check(const struct bisect_terms *terms,
>>> + const char *current_term)
>>> +{
>>> + ....
>>> + fprintf(stderr, N_("Warning: bisecting only with a %s commit\n"),
>>> + terms->term_bad.buf);
>>
>> Hmph, is this N_() and not _()?
>
> I recall you saying that you are not familiar with i18n. As it is a
> good skill to have outside the context of this project, let's do a
> quick primer. GSoC is a learning experience ;-).
True! :)
> There is a runtime function "gettext()" that takes a string, which
> is typically a printf format string, and gives another string. You
> feed your message in the original language, meant to be used in the
> C locale, and the function gives it translated into the end-user's
> language, specified by environment variables like $LC_MESSAGES.
>
> Since it is too cumbersome to write gettext() all the time, _()
> exists as a short-hand for it. So running this
>
> printf(_("Hello, world\n"));
>
> would look up "Hello world\n" in database for the end-user's
> language, and shows the translated message instead.
>
> By scanning the source text, you can extract these constant strings
> passed to gettext() or _(). This is done by the i18n coordinator
> with the "msgmerge" program. By doing so, we learn "Hello, world\n"
> must be translated, and then ask i18n team to translate it to their
> language. The result is what we have in the l10n database. They
> are in po/*.po files in our source tree.
>
> Sometimes, the message you want to be translated may be in a
> variable, e.g.
>
> void greeting(const char *message)
> {
> printf(_(message));
> }
>
> int main(int ac, char **av)
> {
> int i;
> const char *message[] = {
> "Hello, world\n",
> "Goodbye, everybody\n",
> };
> for (i = 0; i < ARRAY_SIZE(message); i++)
> greeting(message[i]);
> }
>
> And scanning the source would not find "Hello, world\n" or "Goodby,
> everybody\n" must be translated. We do not want to do this:
>
> ...
> const char *message[] = {
> *BAD* _("Hello, world\n"),
> *BAD* _("Goodbye, everybody\n"),
> };
> ...
>
> because we do *NOT* want to call gettext() there (we call the
> function at runtime inside greeting() instead). We use N_()
> to mark such messages, like so:
>
> ...
> const char *message[] = {
> *GOOD* N_("Hello, world\n"),
> *GOOD* N_("Goodbye, everybody\n"),
> };
> ...
>
> The N_() macro is a no-op at runtime. It just is there so that
> "msgmerge" can notice that the constant string there is something
> that needs to be thrown into the l10n database.
>
> As a concrete example:
>
>> @@ -24,6 +25,7 @@ static const char * const git_bisect_helper_usage[] = {
>> N_("git bisect--helper --bisect-reset [<commit>]"),
>> N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
>> N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
>> + N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
>> NULL
>> };
>
> this is such a use of N_(). You want to keep untranslated message
> in the git_bisect_helper_usage[] array, to be given to gettext(), or
> more likely its short-hand _(), when these usage strings are used,
> and make sure these strings will be in the l10n database so that
> translators will give you translations to them to be used at
> runtime.
>
>> + /*
>> + * have bad (or new) but not good (or old). We could bisect
>> + * although this is less optimum.
>> + */
>> + fprintf(stderr, N_("Warning: bisecting only with a %s commit\n"),
>> + terms->term_bad.buf);
>
> This one wants to call gettext() function to give fprintf() the
> translated warning message. It should be _().
>
>> + /*
>> + * 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);
>
> Just like this one.
Thanks a lot for taking time to explain this. I had searched a bit but
couldn't find the difference between _() and N_()!
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v12 13/13] bisect--helper: `bisect_start` shell function partially in C
2016-08-12 19:25 ` Junio C Hamano
@ 2016-08-13 6:33 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-13 6:33 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Sat, Aug 13, 2016 at 12:55 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> + ...
>> + /*
>> + * Write new start state
>> + */
>> + if (write_file(git_path_bisect_start(), "%s\n", start_head.buf)) {
>
> I think this function has changed its signature recently. I am
> planning to tag 2.10-rc0 this weekend, and it may be a good time to
> rebase the series on to an updated codebase.
>
> Thanks.
Yes sure will do that and send an updated version.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v12 13/13] bisect--helper: `bisect_start` shell function partially in C
2016-08-10 21:57 ` [PATCH v12 13/13] bisect--helper: `bisect_start` shell function partially " Pranit Bauva
2016-08-12 19:25 ` Junio C Hamano
@ 2016-08-13 7:34 ` Christian Couder
2016-08-13 13:50 ` Pranit Bauva
1 sibling, 1 reply; 320+ messages in thread
From: Christian Couder @ 2016-08-13 7:34 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
On Wed, Aug 10, 2016 at 11:57 PM, Pranit Bauva <pranit.bauva@gmail.com> wrote:
>
> @@ -431,6 +434,244 @@ static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
> return 0;
> }
>
> +static int bisect_start(struct bisect_terms *terms, int no_checkout,
> + const char **argv, int argc)
> +{
> + int i, has_double_dash = 0, must_write_terms = 0, bad_seen = 0;
> + int flags, pathspec_pos;
> + 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 strbuf orig_args = STRBUF_INIT;
> + const char *head;
> + unsigned char sha1[20];
> + FILE *fp;
> + struct object_id oid;
> +
> + if (is_bare_repository())
> + no_checkout = 1;
> +
> + for (i = 0; i < argc; i++) {
> + char *commit_id = xstrfmt("%s^{commit}", argv[i]);
> + if (!strcmp(argv[i], "--")) {
> + has_double_dash = 1;
> + break;
> + }
In the shell code there is a loop dedicated to checking if there is a
double dash in the arguments before the real argument parsing loop.
There is a reason for that.
If you do it in the same loop, has_double_dash will not be set when
the arguments that are before the double dash will be parsed.
> + else if (!strcmp(argv[i], "--no-checkout"))
> + no_checkout = 1;
> + else if (!strcmp(argv[i], "--term-good") ||
> + !strcmp(argv[i], "--term-old")) {
> + must_write_terms = 1;
> + strbuf_reset(&terms->term_good);
> + strbuf_addstr(&terms->term_good, argv[++i]);
> + }
> + else if (skip_prefix(argv[i], "--term-good=", &argv[i])) {
(Maybe you could put the "else if (...) {" on the same line as the "}" above.)
> + must_write_terms = 1;
> + strbuf_reset(&terms->term_good);
> + strbuf_addstr(&terms->term_good, argv[i]);
> + }
> + else if (skip_prefix(argv[i], "--term-old=", &argv[i])) {
> + must_write_terms = 1;
> + strbuf_reset(&terms->term_good);
> + strbuf_addstr(&terms->term_good, argv[i]);
> + }
> + else if (!strcmp(argv[i], "--term-bad") ||
> + !strcmp(argv[i], "--term-new")) {
> + must_write_terms = 1;
> + strbuf_reset(&terms->term_bad);
> + strbuf_addstr(&terms->term_bad, argv[++i]);
> + }
> + else if (skip_prefix(argv[i], "--term-bad=", &argv[i])) {
> + must_write_terms = 1;
> + strbuf_reset(&terms->term_bad);
> + strbuf_addstr(&terms->term_bad, argv[i]);
> + }
> + else if (skip_prefix(argv[i], "--term-new=", &argv[i])) {
> + must_write_terms = 1;
> + strbuf_reset(&terms->term_good);
> + strbuf_addstr(&terms->term_good, argv[i]);
> + }
> + else if (starts_with(argv[i], "--") &&
> + !one_of(argv[i], "--term-good", "--term-bad", NULL)) {
> + string_list_clear(&revs, 0);
> + string_list_clear(&states, 0);
> + die(_("unrecognised option: '%s'"), argv[i]);
> + }
> + else if (get_oid(argv[i], &oid) && !has_double_dash) {
And here checking "!has_double_dash" has no meaning if you check for a
double dash in the same loop, because there is a "break" after
has_double_dash is set above.
> + string_list_clear(&revs, 0);
> + string_list_clear(&states, 0);
> + free(commit_id);
> + die(_("'%s' does not appear to be a valid revision"), argv[i]);
> + }
> + else {
> + free(commit_id);
> + string_list_append(&revs, oid_to_hex(&oid));
> + }
> + }
> + pathspec_pos = i;
> +
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v12 13/13] bisect--helper: `bisect_start` shell function partially in C
2016-08-13 7:34 ` Christian Couder
@ 2016-08-13 13:50 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-13 13:50 UTC (permalink / raw)
To: Christian Couder; +Cc: git
Hey Christian,
On Sat, Aug 13, 2016 at 1:04 PM, Christian Couder
<christian.couder@gmail.com> wrote:
> On Wed, Aug 10, 2016 at 11:57 PM, Pranit Bauva <pranit.bauva@gmail.com> wrote:
>>
>> @@ -431,6 +434,244 @@ static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
>> return 0;
>> }
>>
>> +static int bisect_start(struct bisect_terms *terms, int no_checkout,
>> + const char **argv, int argc)
>> +{
>> + int i, has_double_dash = 0, must_write_terms = 0, bad_seen = 0;
>> + int flags, pathspec_pos;
>> + 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 strbuf orig_args = STRBUF_INIT;
>> + const char *head;
>> + unsigned char sha1[20];
>> + FILE *fp;
>> + struct object_id oid;
>> +
>> + if (is_bare_repository())
>> + no_checkout = 1;
>> +
>> + for (i = 0; i < argc; i++) {
>> + char *commit_id = xstrfmt("%s^{commit}", argv[i]);
>> + if (!strcmp(argv[i], "--")) {
>> + has_double_dash = 1;
>> + break;
>> + }
>
> In the shell code there is a loop dedicated to checking if there is a
> double dash in the arguments before the real argument parsing loop.
> There is a reason for that.
> If you do it in the same loop, has_double_dash will not be set when
> the arguments that are before the double dash will be parsed.
I had tried that before. But somehow I couldn't get it to run so I
reverted back. I have now successfully tried it and its working. You
can checkout the PR[1].
>> + else if (!strcmp(argv[i], "--no-checkout"))
>> + no_checkout = 1;
>> + else if (!strcmp(argv[i], "--term-good") ||
>> + !strcmp(argv[i], "--term-old")) {
>> + must_write_terms = 1;
>> + strbuf_reset(&terms->term_good);
>> + strbuf_addstr(&terms->term_good, argv[++i]);
>> + }
>> + else if (skip_prefix(argv[i], "--term-good=", &argv[i])) {
>
> (Maybe you could put the "else if (...) {" on the same line as the "}" above.)
>
>> + must_write_terms = 1;
>> + strbuf_reset(&terms->term_good);
>> + strbuf_addstr(&terms->term_good, argv[i]);
>> + }
>> + else if (skip_prefix(argv[i], "--term-old=", &argv[i])) {
>> + must_write_terms = 1;
>> + strbuf_reset(&terms->term_good);
>> + strbuf_addstr(&terms->term_good, argv[i]);
>> + }
>> + else if (!strcmp(argv[i], "--term-bad") ||
>> + !strcmp(argv[i], "--term-new")) {
>> + must_write_terms = 1;
>> + strbuf_reset(&terms->term_bad);
>> + strbuf_addstr(&terms->term_bad, argv[++i]);
>> + }
>> + else if (skip_prefix(argv[i], "--term-bad=", &argv[i])) {
>> + must_write_terms = 1;
>> + strbuf_reset(&terms->term_bad);
>> + strbuf_addstr(&terms->term_bad, argv[i]);
>> + }
>> + else if (skip_prefix(argv[i], "--term-new=", &argv[i])) {
>> + must_write_terms = 1;
>> + strbuf_reset(&terms->term_good);
>> + strbuf_addstr(&terms->term_good, argv[i]);
>> + }
>> + else if (starts_with(argv[i], "--") &&
>> + !one_of(argv[i], "--term-good", "--term-bad", NULL)) {
>> + string_list_clear(&revs, 0);
>> + string_list_clear(&states, 0);
>> + die(_("unrecognised option: '%s'"), argv[i]);
>> + }
>> + else if (get_oid(argv[i], &oid) && !has_double_dash) {
>
> And here checking "!has_double_dash" has no meaning if you check for a
> double dash in the same loop, because there is a "break" after
> has_double_dash is set above.
I think this is the situation in the shell script too.
>> + string_list_clear(&revs, 0);
>> + string_list_clear(&states, 0);
>> + free(commit_id);
>> + die(_("'%s' does not appear to be a valid revision"), argv[i]);
>> + }
>> + else {
>> + free(commit_id);
>> + string_list_append(&revs, oid_to_hex(&oid));
>> + }
>> + }
>> + pathspec_pos = i;
>> +
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* [PATCH v13 02/13] bisect: rewrite `check_term_format` shell function in C
2016-08-19 20:32 ` [PATCH v13 " Pranit Bauva
` (9 preceding siblings ...)
2016-08-19 20:32 ` [PATCH v13 11/13] bisect--helper: `bisect_next_check` & bisect_voc shell function in C Pranit Bauva
@ 2016-08-19 20:32 ` Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 03/13] bisect--helper: `write_terms` " Pranit Bauva
` (2 subsequent siblings)
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-19 20:32 UTC (permalink / raw)
To: git
Reimplement the `check_term_format` shell function in C and add
a `--check-term-format` subcommand to `git bisect--helper` to call it
from git-bisect.sh
Using `--check-term-format` subcommand is a temporary measure to port
shell function to C so as to use the existing test suite. As more
functions are ported, this subcommand will be retired and its
implementation will be called by some other method/subcommand. For
eg. In conversion of write_terms() of git-bisect.sh, the subcommand will
be removed and instead check_term_format() will be called in its C
implementation while a new subcommand will be introduced for write_terms().
Helped-by: Johannes Schindelein <Johannes.Schindelein@gmx.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 60 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 31 ++-----------------------
2 files changed, 61 insertions(+), 30 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 8111c91..a47f1f2 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -2,19 +2,73 @@
#include "cache.h"
#include "parse-options.h"
#include "bisect.h"
+#include "refs.h"
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
+ N_("git bisect--helper --check-term-format <term> <orig_term>"),
NULL
};
+/*
+ * 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",
+ "visualize", "replay", "log", "run", NULL))
+ 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;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
- enum { NEXT_ALL = 1 } cmdmode = 0;
+ enum {
+ NEXT_ALL = 1,
+ CHECK_TERM_FMT
+ } cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
+ OPT_CMDMODE(0, "check-term-format", &cmdmode,
+ N_("check format of the term"), CHECK_TERM_FMT),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -29,6 +83,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
switch (cmdmode) {
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
+ case CHECK_TERM_FMT:
+ if (argc != 2)
+ die(_("--check-term-format requires two arguments"));
+ return check_term_format(argv[0], argv[1]);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index ae3cb01..a727c59 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -564,38 +564,11 @@ write_terms () {
then
die "$(gettext "please use two different terms")"
fi
- check_term_format "$TERM_BAD" bad
- check_term_format "$TERM_GOOD" good
+ git bisect--helper --check-term-format "$TERM_BAD" bad || exit
+ git bisect--helper --check-term-format "$TERM_GOOD" good || exit
printf '%s\n%s\n' "$TERM_BAD" "$TERM_GOOD" >"$GIT_DIR/BISECT_TERMS"
}
-check_term_format () {
- term=$1
- git check-ref-format refs/bisect/"$term" ||
- die "$(eval_gettext "'\$term' is not a valid term")"
- case "$term" in
- help|start|terms|skip|next|reset|visualize|replay|log|run)
- die "$(eval_gettext "can't use the builtin command '\$term' as a term")"
- ;;
- bad|new)
- if test "$2" != bad
- then
- # 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.
- die "$(eval_gettext "can't change the meaning of term '\$term'")"
- fi
- ;;
- good|old)
- if test "$2" != good
- then
- die "$(eval_gettext "can't change the meaning of term '\$term'")"
- fi
- ;;
- esac
-}
-
check_and_set_terms () {
cmd="$1"
case "$cmd" in
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v13 13/13] bisect--helper: `bisect_start` shell function partially in C
2016-08-19 20:32 ` [PATCH v13 " Pranit Bauva
` (6 preceding siblings ...)
2016-08-19 20:32 ` [PATCH v13 06/13] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
@ 2016-08-19 20:32 ` Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 05/13] t6030: explicitly test for bisection cleanup Pranit Bauva
` (5 subsequent siblings)
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-19 20:32 UTC (permalink / raw)
To: git
Reimplement the `bisect_start` shell function partially in C and add
`bisect-start` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
The last part is not converted because it calls another shell function.
`bisect_start` shell function will be completed after the `bisect_next`
shell function is ported in C.
Using `--bisect-start` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other methods.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 252 +++++++++++++++++++++++++++++++++++++++++++++--
git-bisect.sh | 133 +------------------------
2 files changed, 246 insertions(+), 139 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index e1cf956..ff1dfc7 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -7,6 +7,7 @@
#include "argv-array.h"
#include "run-command.h"
#include "prompt.h"
+#include "quote.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
@@ -14,6 +15,8 @@ static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
static GIT_PATH_FUNC(git_path_bisect_head, "BISECT_HEAD")
+static GIT_PATH_FUNC(git_path_head_name, "head-name")
+static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
@@ -24,6 +27,8 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
+ N_("git bisect--helper --bisect start [--term-{old,good}=<term> --term-{new,bad}=<term>]"
+ "[--no-checkout] [<bad> [<good>...]] [--] [<paths>...]"),
NULL
};
@@ -303,7 +308,7 @@ static int bisect_next_check(const struct bisect_terms *terms,
* have bad (or new) but not good (or old). We could bisect
* although this is less optimum.
*/
- fprintf(stderr, N_("Warning: bisecting only with a %s commit\n"),
+ fprintf(stderr, _("Warning: bisecting only with a %s commit\n"),
terms->term_bad.buf);
if (!isatty(0))
return 0;
@@ -366,11 +371,11 @@ static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
int i;
if (get_terms(terms)) {
- fprintf(stderr, N_("no terms defined\n"));
+ fprintf(stderr, _("no terms defined\n"));
return -1;
}
if (argc == 0) {
- printf(N_("Your current terms are %s for the old state\nand "
+ printf(_("Your current terms are %s for the old state\nand "
"%s for the new state.\n"), terms->term_good.buf,
terms->term_bad.buf);
return 0;
@@ -378,11 +383,11 @@ static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
for (i = 0; i < argc; i++) {
if (!strcmp(argv[i], "--term-good"))
- printf(N_("%s\n"), terms->term_good.buf);
+ printf(_("%s\n"), terms->term_good.buf);
else if (!strcmp(argv[i], "--term-bad"))
- printf(N_("%s\n"), terms->term_bad.buf);
+ printf(_("%s\n"), terms->term_bad.buf);
else
- printf(N_("invalid argument %s for 'git bisect "
+ printf(_("invalid argument %s for 'git bisect "
"terms'.\nSupported options are: "
"--term-good|--term-old and "
"--term-bad|--term-new."), argv[i]);
@@ -391,6 +396,228 @@ static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
return 0;
}
+static int bisect_start(struct bisect_terms *terms, int no_checkout,
+ const char **argv, int argc)
+{
+ int i, has_double_dash = 0, must_write_terms = 0, bad_seen = 0;
+ int flags, pathspec_pos;
+ 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 strbuf orig_args = STRBUF_INIT;
+ const char *head;
+ unsigned char sha1[20];
+ FILE *fp;
+ struct object_id oid;
+
+ if (is_bare_repository())
+ no_checkout = 1;
+
+ for (i = 0; i < argc; i++) {
+ if (!strcmp(argv[i], "--")) {
+ has_double_dash = 1;
+ break;
+ }
+ }
+
+ for (i = 0; i < argc; i++) {
+ char *commit_id = xstrfmt("%s^{commit}", argv[i]);
+ if (!strcmp(argv[i], "--")) {
+ has_double_dash = 1;
+ break;
+ } else if (!strcmp(argv[i], "--no-checkout"))
+ no_checkout = 1;
+ else if (!strcmp(argv[i], "--term-good") ||
+ !strcmp(argv[i], "--term-old")) {
+ must_write_terms = 1;
+ strbuf_reset(&terms->term_good);
+ strbuf_addstr(&terms->term_good, argv[++i]);
+ } else if (skip_prefix(argv[i], "--term-good=", &argv[i])) {
+ must_write_terms = 1;
+ strbuf_reset(&terms->term_good);
+ strbuf_addstr(&terms->term_good, argv[i]);
+ } else if (skip_prefix(argv[i], "--term-old=", &argv[i])) {
+ must_write_terms = 1;
+ strbuf_reset(&terms->term_good);
+ strbuf_addstr(&terms->term_good, argv[i]);
+ } else if (!strcmp(argv[i], "--term-bad") ||
+ !strcmp(argv[i], "--term-new")) {
+ must_write_terms = 1;
+ strbuf_reset(&terms->term_bad);
+ strbuf_addstr(&terms->term_bad, argv[++i]);
+ } else if (skip_prefix(argv[i], "--term-bad=", &argv[i])) {
+ must_write_terms = 1;
+ strbuf_reset(&terms->term_bad);
+ strbuf_addstr(&terms->term_bad, argv[i]);
+ } else if (skip_prefix(argv[i], "--term-new=", &argv[i])) {
+ must_write_terms = 1;
+ strbuf_reset(&terms->term_good);
+ strbuf_addstr(&terms->term_good, argv[i]);
+ } else if (starts_with(argv[i], "--") &&
+ !one_of(argv[i], "--term-good", "--term-bad", NULL)) {
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ die(_("unrecognised option: '%s'"), argv[i]);
+ } else if (get_oid(argv[i], &oid) && has_double_dash) {
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ free(commit_id);
+ die(_("'%s' does not appear to be a valid revision"), argv[i]);
+ } else {
+ free(commit_id);
+ string_list_append(&revs, oid_to_hex(&oid));
+ }
+ }
+ 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.
+ */
+ must_write_terms |= !!revs.nr;
+ for (i = 0; i < revs.nr; i++) {
+ if (bad_seen)
+ string_list_append(&states, terms->term_good.buf);
+ else {
+ bad_seen = 1;
+ string_list_append(&states, terms->term_bad.buf);
+ }
+ }
+
+ /*
+ * Verify HEAD
+ */
+ head = resolve_ref_unsafe("HEAD", 0, sha1, &flags);
+ if (!head) {
+ if (get_sha1("HEAD", sha1)) {
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ die(_("Bad HEAD - I need a HEAD"));
+ }
+ }
+ 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) {
+ struct argv_array argv = ARGV_ARRAY_INIT;
+ argv_array_pushl(&argv, "checkout", start_head.buf,
+ "--", NULL);
+ if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
+ error(_("checking out '%s' failed. Try 'git "
+ "bisect start <valid-branch>'."),
+ start_head.buf);
+ strbuf_release(&start_head);
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ return -1;
+ }
+ }
+ } else {
+ if (starts_with(head, "refs/heads/") ||
+ !get_oid_hex(head, &oid) || ref_exists(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())) {
+ strbuf_release(&start_head);
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ die(_("won't bisect on cg-seek'ed tree"));
+ }
+ if (starts_with(head, "refs/heads/")) {
+ strbuf_reset(&start_head);
+ strbuf_addstr(&start_head, head + 11);
+ }
+ else {
+ strbuf_reset(&start_head);
+ strbuf_addstr(&start_head, sha1_to_hex(sha1));
+ }
+ } else {
+ strbuf_release(&start_head);
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ die(_("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);
+
+ if (no_checkout) {
+ get_oid(start_head.buf, &oid);
+ if (update_ref(NULL, "BISECT_HEAD", oid.hash, NULL, 0,
+ UPDATE_REFS_MSG_ON_ERR)) {
+ strbuf_release(&start_head);
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ return -1;
+ }
+ }
+ strbuf_release(&start_head);
+
+ if (pathspec_pos < argc - 1)
+ sq_quote_argv(&bisect_names, argv + pathspec_pos, 0);
+ write_file(git_path_bisect_names(), "%s\n", bisect_names.buf);
+ strbuf_release(&bisect_names);
+
+ for (i = 0; i < states.nr; i++) {
+ if (bisect_write(states.items[i].string,
+ revs.items[i].string, terms, 1)) {
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ return -1;
+ }
+ }
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+
+ if (must_write_terms)
+ if (write_terms(terms->term_bad.buf, terms->term_good.buf))
+ return -1;
+
+ fp = fopen(git_path_bisect_log(), "a");
+ if (!fp)
+ return -1;
+
+ if (fprintf(fp, "git bisect start") < 1)
+ return -1;
+
+ sq_quote_argv(&orig_args, argv, 0);
+ if (fprintf(fp, "%s", orig_args.buf) < 0) {
+ strbuf_release(&orig_args);
+ return -1;
+ }
+ strbuf_release(&orig_args);
+ if (fprintf(fp, "\n") < 1) {
+ fclose(fp);
+ return -1;
+ }
+ fclose(fp);
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -402,7 +629,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_WRITE,
CHECK_AND_SET_TERMS,
BISECT_NEXT_CHECK,
- BISECT_TERMS
+ BISECT_TERMS,
+ BISECT_START
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -424,6 +652,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
OPT_CMDMODE(0, "bisect-terms", &cmdmode,
N_("print out the bisect terms"), BISECT_TERMS),
+ OPT_CMDMODE(0, "bisect-start", &cmdmode,
+ N_("start the bisect session"), BISECT_START),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -432,7 +662,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
bisect_terms_init(&terms);
argc = parse_options(argc, argv, prefix, options,
- git_bisect_helper_usage, PARSE_OPT_KEEP_UNKNOWN);
+ git_bisect_helper_usage,
+ PARSE_OPT_KEEP_DASHDASH | PARSE_OPT_KEEP_UNKNOWN);
if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
@@ -486,6 +717,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
die(_("--bisect-terms requires 0 or 1 argument"));
res = bisect_terms(&terms, argv, argc);
break;
+ case BISECT_START:
+ strbuf_addstr(&terms.term_good, "good");
+ strbuf_addstr(&terms.term_bad, "bad");
+ res = bisect_start(&terms, no_checkout, argv, argc);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index d6c8b5a..f0896b3 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -71,122 +71,7 @@ bisect_autostart() {
}
bisect_start() {
- #
- # Check for one bad and then some good revisions.
- #
- has_double_dash=0
- for arg; do
- case "$arg" in --) has_double_dash=1; break ;; esac
- done
- orig_args=$(git rev-parse --sq-quote "$@")
- bad_seen=0
- eval=''
- must_write_terms=0
- revs=''
- if test "z$(git rev-parse --is-bare-repository)" != zfalse
- then
- mode=--no-checkout
- else
- mode=''
- fi
- while [ $# -gt 0 ]; do
- arg="$1"
- case "$arg" in
- --)
- shift
- break
- ;;
- --no-checkout)
- mode=--no-checkout
- shift ;;
- --term-good|--term-old)
- shift
- must_write_terms=1
- TERM_GOOD=$1
- shift ;;
- --term-good=*|--term-old=*)
- must_write_terms=1
- TERM_GOOD=${1#*=}
- shift ;;
- --term-bad|--term-new)
- shift
- must_write_terms=1
- TERM_BAD=$1
- shift ;;
- --term-bad=*|--term-new=*)
- must_write_terms=1
- TERM_BAD=${1#*=}
- shift ;;
- --*)
- die "$(eval_gettext "unrecognised option: '\$arg'")" ;;
- *)
- rev=$(git rev-parse -q --verify "$arg^{commit}") || {
- test $has_double_dash -eq 1 &&
- die "$(eval_gettext "'\$arg' does not appear to be a valid revision")"
- break
- }
- revs="$revs $rev"
- shift
- ;;
- esac
- done
-
- for rev in $revs
- do
- # 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.
- must_write_terms=1
-
- case $bad_seen in
- 0) state=$TERM_BAD ; bad_seen=1 ;;
- *) state=$TERM_GOOD ;;
- esac
- eval="$eval git bisect--helper --bisect-write '$state' '$rev' '$TERM_GOOD' '$TERM_BAD' 'nolog' &&"
- done
- #
- # Verify HEAD.
- #
- head=$(GIT_DIR="$GIT_DIR" git symbolic-ref -q HEAD) ||
- head=$(GIT_DIR="$GIT_DIR" git rev-parse --verify HEAD) ||
- die "$(gettext "Bad HEAD - I need a HEAD")"
-
- #
- # Check if we are bisecting.
- #
- start_head=''
- if test -s "$GIT_DIR/BISECT_START"
- then
- # Reset to the rev from where we started.
- start_head=$(cat "$GIT_DIR/BISECT_START")
- if test "z$mode" != "z--no-checkout"
- then
- git checkout "$start_head" -- ||
- die "$(eval_gettext "Checking out '\$start_head' failed. Try 'git bisect reset <valid-branch>'.")"
- fi
- else
- # Get rev from where we start.
- case "$head" in
- refs/heads/*|$_x40)
- # This error message should only be triggered by
- # cogito usage, and cogito users should understand
- # it relates to cg-seek.
- [ -s "$GIT_DIR/head-name" ] &&
- die "$(gettext "won't bisect on cg-seek'ed tree")"
- start_head="${head#refs/heads/}"
- ;;
- *)
- die "$(gettext "Bad HEAD - strange symbolic ref")"
- ;;
- esac
- fi
-
- #
- # Get rid of any old bisect state.
- #
- git bisect--helper --bisect-clean-state || exit
+ git bisect--helper --bisect-start $@ || exit
#
# Change state.
@@ -197,24 +82,10 @@ bisect_start() {
#
trap 'git bisect--helper --bisect-clean-state' 0
trap 'exit 255' 1 2 3 15
-
- #
- # Write new start state.
- #
- echo "$start_head" >"$GIT_DIR/BISECT_START" && {
- test "z$mode" != "z--no-checkout" ||
- git update-ref --no-deref BISECT_HEAD "$start_head"
- } &&
- git rev-parse --sq-quote "$@" >"$GIT_DIR/BISECT_NAMES" &&
- eval "$eval true" &&
- if test $must_write_terms -eq 1
- then
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD"
- fi &&
- echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
#
# Check if we can proceed to the next bisect state.
#
+ get_terms
bisect_auto_next
trap '-' 0
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v13 07/13] bisect--helper: `bisect_reset` shell function in C
2016-08-19 20:32 ` [PATCH v13 " Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 04/13] bisect--helper: `bisect_clean_state` shell function in C Pranit Bauva
@ 2016-08-19 20:32 ` Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 08/13] bisect--helper: `is_expected_rev` & `check_expected_revs` " Pranit Bauva
` (11 subsequent siblings)
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-19 20:32 UTC (permalink / raw)
To: git
Reimplement `bisect_reset` shell function in C and add a `--bisect-reset`
subcommand to `git bisect--helper` to call it from git-bisect.sh .
Using `bisect_reset` subcommand is a temporary measure to port shell
functions to C so as to use the existing test suite. As more functions
are ported, this subcommand would be retired but its implementation will
be called by some other method.
Note: --bisect-clean-state subcommand has not been retired as there are
still a function namely `bisect_start()` which still uses this
subcommand.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 48 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 28 ++--------------------------
2 files changed, 49 insertions(+), 27 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index e50934c..9aba094 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -3,17 +3,22 @@
#include "parse-options.h"
#include "bisect.h"
#include "refs.h"
+#include "dir.h"
+#include "argv-array.h"
+#include "run-command.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
+static GIT_PATH_FUNC(git_path_bisect_head, "BISECT_HEAD")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-clean-state"),
+ N_("git bisect--helper --bisect-reset [<commit>]"),
NULL
};
@@ -84,12 +89,47 @@ static int write_terms(const char *bad, const char *good)
return (res < 0) ? -1 : 0;
}
+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, &oid))
+ return error(_("'%s' is not a valid commit"), commit);
+ strbuf_addstr(&branch, commit);
+ }
+
+ if (!file_exists(git_path_bisect_head())) {
+ struct argv_array argv = ARGV_ARRAY_INIT;
+ argv_array_pushl(&argv, "checkout", branch.buf, "--", NULL);
+ if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
+ error(_("Could not check out original HEAD '%s'. Try "
+ "'git bisect reset <commit>'."), branch.buf);
+ strbuf_release(&branch);
+ argv_array_clear(&argv);
+ return -1;
+ }
+ argv_array_clear(&argv);
+ }
+
+ strbuf_release(&branch);
+ return bisect_clean_state();
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
WRITE_TERMS,
- BISECT_CLEAN_STATE
+ BISECT_CLEAN_STATE,
+ BISECT_RESET
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -99,6 +139,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
+ OPT_CMDMODE(0, "bisect-reset", &cmdmode,
+ N_("reset the bisection state"), BISECT_RESET),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -121,6 +163,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc != 0)
die(_("--bisect-clean-state requires no arguments"));
return bisect_clean_state();
+ case BISECT_RESET:
+ if (argc > 1)
+ die(_("--bisect-reset requires either zero or one arguments"));
+ return bisect_reset(argc ? argv[0] : NULL);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index f1202df..442397b 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -409,35 +409,11 @@ bisect_visualize() {
eval '"$@"' --bisect -- $(cat "$GIT_DIR/BISECT_NAMES")
}
-bisect_reset() {
- test -s "$GIT_DIR/BISECT_START" || {
- gettextln "We are not bisecting."
- return
- }
- case "$#" in
- 0) branch=$(cat "$GIT_DIR/BISECT_START") ;;
- 1) git rev-parse --quiet --verify "$1^{commit}" >/dev/null || {
- invalid="$1"
- die "$(eval_gettext "'\$invalid' is not a valid commit")"
- }
- branch="$1" ;;
- *)
- usage ;;
- esac
-
- if ! test -f "$GIT_DIR/BISECT_HEAD" && ! git checkout "$branch" --
- then
- die "$(eval_gettext "Could not check out original HEAD '\$branch'.
-Try 'git bisect reset <commit>'.")"
- fi
- git bisect--helper --bisect-clean-state || exit
-}
-
bisect_replay () {
file="$1"
test "$#" -eq 1 || die "$(gettext "No logfile given")"
test -r "$file" || die "$(eval_gettext "cannot read \$file for replaying")"
- bisect_reset
+ git bisect--helper --bisect-reset || exit
while read git bisect command rev
do
test "$git $bisect" = "git bisect" || test "$git" = "git-bisect" || continue
@@ -627,7 +603,7 @@ case "$#" in
visualize|view)
bisect_visualize "$@" ;;
reset)
- bisect_reset "$@" ;;
+ git bisect--helper --bisect-reset "$@" ;;
replay)
bisect_replay "$@" ;;
log)
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v13 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2016-08-10 21:57 ` [PATCH v12 " Pranit Bauva
` (12 preceding siblings ...)
2016-08-10 22:19 ` [PATCH v12 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
@ 2016-08-19 20:32 ` Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 04/13] bisect--helper: `bisect_clean_state` shell function in C Pranit Bauva
` (13 more replies)
13 siblings, 14 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-19 20:32 UTC (permalink / raw)
To: git
`--next-all` is meant to be used as a subcommand to support multiple
"operation mode" though the current implementation does not contain any
other subcommand along side with `--next-all` but further commits will
include some more subcommands.
Helped-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 17 +++++++++++------
1 file changed, 11 insertions(+), 6 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 3324229..8111c91 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -10,11 +10,11 @@ static const char * const git_bisect_helper_usage[] = {
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
- int next_all = 0;
+ enum { NEXT_ALL = 1 } cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
- OPT_BOOL(0, "next-all", &next_all,
- N_("perform 'git bisect next'")),
+ OPT_CMDMODE(0, "next-all", &cmdmode,
+ N_("perform 'git bisect next'"), NEXT_ALL),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -23,9 +23,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
argc = parse_options(argc, argv, prefix, options,
git_bisect_helper_usage, 0);
- if (!next_all)
+ if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
- /* next-all */
- return bisect_next_all(prefix, no_checkout);
+ switch (cmdmode) {
+ case NEXT_ALL:
+ return bisect_next_all(prefix, no_checkout);
+ default:
+ die("BUG: unknown subcommand '%d'", cmdmode);
+ }
+ return 0;
}
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v13 11/13] bisect--helper: `bisect_next_check` & bisect_voc shell function in C
2016-08-19 20:32 ` [PATCH v13 " Pranit Bauva
` (8 preceding siblings ...)
2016-08-19 20:32 ` [PATCH v13 05/13] t6030: explicitly test for bisection cleanup Pranit Bauva
@ 2016-08-19 20:32 ` Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 02/13] bisect: rewrite `check_term_format` " Pranit Bauva
` (3 subsequent siblings)
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-19 20:32 UTC (permalink / raw)
To: git
Reimplement `bisect_next_check` shell function in C and add
`bisect-next-check` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Also reimplement `bisect_voc` shell function in C and call it from
`bisect_next_check` implementation in C.
Using `--bisect-next-check` is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by some other methods.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 103 ++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 60 ++-------------------------
2 files changed, 106 insertions(+), 57 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 450426c..ada3220d 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -6,6 +6,7 @@
#include "dir.h"
#include "argv-array.h"
#include "run-command.h"
+#include "prompt.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
@@ -21,6 +22,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
+ N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
NULL
};
@@ -253,6 +255,95 @@ static int check_and_set_terms(struct bisect_terms *terms, const char *cmd)
return 0;
}
+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;
+}
+
+static char *bisect_voc(char *revision_type)
+{
+ if (!strcmp(revision_type, "bad"))
+ return "bad|new";
+ if (!strcmp(revision_type, "good"))
+ return "good|old";
+
+ return NULL;
+}
+
+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.buf);
+ char *good_glob = xstrfmt("%s-*", terms->term_good.buf);
+ char *bad_syn, *good_syn;
+
+ if (ref_exists(bad_ref))
+ missing_bad = 0;
+ free(bad_ref);
+
+ for_each_glob_ref_in(mark_good, good_glob, "refs/bisect/",
+ (void *) &missing_good);
+ free(good_glob);
+
+ if (!missing_good && !missing_bad)
+ return 0;
+
+ if (!current_term)
+ return -1;
+
+ if (missing_good && !missing_bad && current_term &&
+ !strcmp(current_term, terms->term_good.buf)) {
+ char *yesno;
+ /*
+ * have bad (or new) but not good (or old). We could bisect
+ * although this is less optimum.
+ */
+ fprintf(stderr, N_("Warning: bisecting only with a %s commit\n"),
+ terms->term_bad.buf);
+ if (!isatty(0))
+ return 0;
+ /*
+ * 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"))
+ return -1;
+
+ return 0;
+ }
+ bad_syn = xstrdup(bisect_voc("bad"));
+ good_syn = xstrdup(bisect_voc("good"));
+ if (!is_empty_or_missing_file(git_path_bisect_start())) {
+ error(_("You need to give me at least one %s and "
+ "%s revision. You can use \"git bisect %s\" "
+ "and \"git bisect %s\" for that. \n"),
+ bad_syn, good_syn, bad_syn, good_syn);
+ free(bad_syn);
+ free(good_syn);
+ return -1;
+ }
+ else {
+ error(_("You need to start by \"git bisect start\". You "
+ "then need to give me at least one %s and %s "
+ "revision. You can use \"git bisect %s\" and "
+ "\"git bisect %s\" for that.\n"),
+ good_syn, bad_syn, bad_syn, good_syn);
+ free(bad_syn);
+ free(good_syn);
+ return -1;
+ }
+ free(bad_syn);
+ free(good_syn);
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -262,7 +353,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_RESET,
CHECK_EXPECTED_REVS,
BISECT_WRITE,
- CHECK_AND_SET_TERMS
+ CHECK_AND_SET_TERMS,
+ BISECT_NEXT_CHECK
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -280,6 +372,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
+ OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
+ N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -330,6 +424,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
strbuf_addstr(&terms.term_bad, argv[2]);
res = check_and_set_terms(&terms, argv[0]);
break;
+ case BISECT_NEXT_CHECK:
+ if (argc != 2 && argc != 3)
+ die(_("--bisect-next-check requires 2 or 3 arguments"));
+ strbuf_addstr(&terms.term_good, argv[0]);
+ strbuf_addstr(&terms.term_bad, argv[1]);
+ res = bisect_next_check(&terms, argc == 3 ? argv[2] : NULL);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index bdf2227..fe6c9d0 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -271,59 +271,14 @@ bisect_state() {
bisect_auto_next
}
-bisect_next_check() {
- missing_good= missing_bad=
- git show-ref -q --verify refs/bisect/$TERM_BAD || missing_bad=t
- test -n "$(git for-each-ref "refs/bisect/$TERM_GOOD-*")" || missing_good=t
-
- case "$missing_good,$missing_bad,$1" in
- ,,*)
- : have both $TERM_GOOD and $TERM_BAD - ok
- ;;
- *,)
- # do not have both but not asked to fail - just report.
- false
- ;;
- t,,"$TERM_GOOD")
- # have bad (or new) but not good (or old). we could bisect although
- # this is less optimum.
- eval_gettextln "Warning: bisecting only with a \$TERM_BAD commit." >&2
- if test -t 0
- then
- # TRANSLATORS: Make sure to include [Y] and [n] in your
- # translation. The program will only accept English input
- # at this point.
- gettext "Are you sure [Y/n]? " >&2
- read yesno
- case "$yesno" in [Nn]*) exit 1 ;; esac
- fi
- : bisect without $TERM_GOOD...
- ;;
- *)
- bad_syn=$(bisect_voc bad)
- good_syn=$(bisect_voc good)
- if test -s "$GIT_DIR/BISECT_START"
- then
-
- eval_gettextln "You need to give me at least one \$bad_syn and one \$good_syn revision.
-(You can use \"git bisect \$bad_syn\" and \"git bisect \$good_syn\" for that.)" >&2
- else
- eval_gettextln "You need to start by \"git bisect start\".
-You then need to give me at least one \$good_syn and one \$bad_syn revision.
-(You can use \"git bisect \$bad_syn\" and \"git bisect \$good_syn\" for that.)" >&2
- fi
- exit 1 ;;
- esac
-}
-
bisect_auto_next() {
- bisect_next_check && bisect_next || :
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD && bisect_next || :
}
bisect_next() {
case "$#" in 0) ;; *) usage ;; esac
bisect_autostart
- bisect_next_check $TERM_GOOD
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD $TERM_GOOD|| exit
# Perform all bisection computation, display and checkout
git bisect--helper --next-all $(test -f "$GIT_DIR/BISECT_HEAD" && echo --no-checkout)
@@ -355,7 +310,7 @@ bisect_next() {
}
bisect_visualize() {
- bisect_next_check fail
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD fail || exit
if test $# = 0
then
@@ -409,7 +364,7 @@ bisect_replay () {
}
bisect_run () {
- bisect_next_check fail
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD fail || exit
while true
do
@@ -482,13 +437,6 @@ get_terms () {
fi
}
-bisect_voc () {
- case "$1" in
- bad) echo "bad|new" ;;
- good) echo "good|old" ;;
- esac
-}
-
bisect_terms () {
get_terms
if ! test -s "$GIT_DIR/BISECT_TERMS"
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v13 12/13] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-08-19 20:32 ` [PATCH v13 " Pranit Bauva
` (2 preceding siblings ...)
2016-08-19 20:32 ` [PATCH v13 08/13] bisect--helper: `is_expected_rev` & `check_expected_revs` " Pranit Bauva
@ 2016-08-19 20:32 ` Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 09/13] bisect--helper: `bisect_write` " Pranit Bauva
` (9 subsequent siblings)
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-19 20:32 UTC (permalink / raw)
To: git
Reimplement the `get_terms` and `bisect_terms` shell function in C and
add `bisect-terms` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Using `--bisect-terms` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by some other methods.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 59 ++++++++++++++++++++++++++++++++++++++++++++++--
git-bisect.sh | 35 ++--------------------------
2 files changed, 59 insertions(+), 35 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index ada3220d..e1cf956 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -23,6 +23,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
+ N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
NULL
};
@@ -344,6 +345,52 @@ static int bisect_next_check(const struct bisect_terms *terms,
return 0;
}
+static int get_terms(struct bisect_terms *terms)
+{
+ FILE *fp;
+ int res;
+ fp = fopen(git_path_bisect_terms(), "r");
+ if (!fp)
+ return -1;
+
+ bisect_terms_reset(terms);
+ res = strbuf_getline(&terms->term_bad, fp) == EOF ||
+ strbuf_getline(&terms->term_good, fp) == EOF;
+
+ fclose(fp);
+ return res ? -1 : 0;
+}
+
+static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
+{
+ int i;
+
+ if (get_terms(terms)) {
+ fprintf(stderr, N_("no terms defined\n"));
+ return -1;
+ }
+ if (argc == 0) {
+ printf(N_("Your current terms are %s for the old state\nand "
+ "%s for the new state.\n"), terms->term_good.buf,
+ terms->term_bad.buf);
+ return 0;
+ }
+
+ for (i = 0; i < argc; i++) {
+ if (!strcmp(argv[i], "--term-good"))
+ printf(N_("%s\n"), terms->term_good.buf);
+ else if (!strcmp(argv[i], "--term-bad"))
+ printf(N_("%s\n"), terms->term_bad.buf);
+ else
+ printf(N_("invalid argument %s for 'git bisect "
+ "terms'.\nSupported options are: "
+ "--term-good|--term-old and "
+ "--term-bad|--term-new."), argv[i]);
+ }
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -354,7 +401,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
CHECK_EXPECTED_REVS,
BISECT_WRITE,
CHECK_AND_SET_TERMS,
- BISECT_NEXT_CHECK
+ BISECT_NEXT_CHECK,
+ BISECT_TERMS
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -374,6 +422,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
+ OPT_CMDMODE(0, "bisect-terms", &cmdmode,
+ N_("print out the bisect terms"), BISECT_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -382,7 +432,7 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
bisect_terms_init(&terms);
argc = parse_options(argc, argv, prefix, options,
- git_bisect_helper_usage, 0);
+ git_bisect_helper_usage, PARSE_OPT_KEEP_UNKNOWN);
if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
@@ -431,6 +481,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
strbuf_addstr(&terms.term_bad, argv[1]);
res = bisect_next_check(&terms, argc == 3 ? argv[2] : NULL);
break;
+ case BISECT_TERMS:
+ if (argc > 1)
+ die(_("--bisect-terms requires 0 or 1 argument"));
+ res = bisect_terms(&terms, argv, argc);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index fe6c9d0..d6c8b5a 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -355,7 +355,7 @@ bisect_replay () {
"$TERM_GOOD"|"$TERM_BAD"|skip)
git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
terms)
- bisect_terms $rev ;;
+ git bisect--helper --bisect-terms $rev || exit;;
*)
die "$(gettext "?? what are you talking about?")" ;;
esac
@@ -437,37 +437,6 @@ get_terms () {
fi
}
-bisect_terms () {
- get_terms
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- die "$(gettext "no terms defined")"
- fi
- case "$#" in
- 0)
- gettextln "Your current terms are $TERM_GOOD for the old state
-and $TERM_BAD for the new state."
- ;;
- 1)
- arg=$1
- case "$arg" in
- --term-good|--term-old)
- printf '%s\n' "$TERM_GOOD"
- ;;
- --term-bad|--term-new)
- printf '%s\n' "$TERM_BAD"
- ;;
- *)
- die "$(eval_gettext "invalid argument \$arg for 'git bisect terms'.
-Supported options are: --term-good|--term-old and --term-bad|--term-new.")"
- ;;
- esac
- ;;
- *)
- usage ;;
- esac
-}
-
case "$#" in
0)
usage ;;
@@ -498,7 +467,7 @@ case "$#" in
run)
bisect_run "$@" ;;
terms)
- bisect_terms "$@" ;;
+ git bisect--helper --bisect-terms "$@" || exit;;
*)
usage ;;
esac
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v13 09/13] bisect--helper: `bisect_write` shell function in C
2016-08-19 20:32 ` [PATCH v13 " Pranit Bauva
` (3 preceding siblings ...)
2016-08-19 20:32 ` [PATCH v13 12/13] bisect--helper: `get_terms` & `bisect_terms` " Pranit Bauva
@ 2016-08-19 20:32 ` Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 10/13] bisect--helper: `check_and_set_terms` " Pranit Bauva
` (8 subsequent siblings)
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-19 20:32 UTC (permalink / raw)
To: git
Reimplement the `bisect_write` shell function in C and add a
`bisect-write` subcommand to `git bisect--helper` to call it from
git-bisect.sh
Using `--bisect-write` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by some other methods.
Note: bisect_write() uses two variables namely TERM_GOOD and TERM_BAD
from the global shell script thus we need to pass it to the subcommand
using the arguments. We then store them in a struct bisect_terms and
pass the memory address around functions.
This patch also introduces new methods namely bisect_state_init() and
bisect_terms_release() for easy memory management for the struct
bisect_terms.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 97 ++++++++++++++++++++++++++++++++++++++++++++----
git-bisect.sh | 25 ++-----------
2 files changed, 94 insertions(+), 28 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 711be75..5364960 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -19,9 +19,27 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-clean-state"),
N_("git bisect--helper --bisect-reset [<commit>]"),
+ N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
NULL
};
+struct bisect_terms {
+ struct strbuf term_good;
+ struct strbuf term_bad;
+};
+
+static void bisect_terms_init(struct bisect_terms *terms)
+{
+ strbuf_init(&terms->term_good, 0);
+ strbuf_init(&terms->term_bad, 0);
+}
+
+static void bisect_terms_release(struct bisect_terms *terms)
+{
+ strbuf_release(&terms->term_good);
+ strbuf_release(&terms->term_bad);
+}
+
/*
* Check whether the string `term` belongs to the set of strings
* included in the variable arguments.
@@ -149,6 +167,52 @@ static int check_expected_revs(const char **revs, int rev_nr)
return 0;
}
+static int bisect_write(const char *state, const char *rev,
+ const struct bisect_terms *terms, int nolog)
+{
+ struct strbuf tag = STRBUF_INIT;
+ struct strbuf commit_name = STRBUF_INIT;
+ struct object_id oid;
+ struct commit *commit;
+ struct pretty_print_context pp = {0};
+ FILE *fp;
+
+ if (!strcmp(state, terms->term_bad.buf))
+ strbuf_addf(&tag, "refs/bisect/%s", state);
+ else if (one_of(state, terms->term_good.buf, "skip", NULL))
+ strbuf_addf(&tag, "refs/bisect/%s-%s", state, rev);
+ else
+ return error(_("Bad bisect_write argument: %s"), state);
+
+ if (get_oid(rev, &oid)) {
+ strbuf_release(&tag);
+ return error(_("couldn't get the oid of the rev '%s'"), rev);
+ }
+
+ if (update_ref(NULL, tag.buf, oid.hash, NULL, 0,
+ UPDATE_REFS_MSG_ON_ERR)) {
+ strbuf_release(&tag);
+ return -1;
+ }
+ strbuf_release(&tag);
+
+ fp = fopen(git_path_bisect_log(), "a");
+ if (!fp)
+ return error_errno(_("couldn't open the file '%s'"), git_path_bisect_log());
+
+ commit = lookup_commit_reference(oid.hash);
+ format_commit_message(commit, "%s", &commit_name, &pp);
+ fprintf(fp, "# %s: [%s] %s\n", state, sha1_to_hex(oid.hash),
+ commit_name.buf);
+ strbuf_release(&commit_name);
+
+ if (!nolog)
+ fprintf(fp, "git bisect %s %s\n", state, rev);
+
+ fclose(fp);
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -156,9 +220,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
WRITE_TERMS,
BISECT_CLEAN_STATE,
BISECT_RESET,
- CHECK_EXPECTED_REVS
+ CHECK_EXPECTED_REVS,
+ BISECT_WRITE
} cmdmode = 0;
- int no_checkout = 0;
+ int no_checkout = 0, res = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
@@ -170,10 +235,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("reset the bisection state"), BISECT_RESET),
OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
N_("check for expected revs"), CHECK_EXPECTED_REVS),
+ OPT_CMDMODE(0, "bisect-write", &cmdmode,
+ N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
};
+ struct bisect_terms terms;
+ bisect_terms_init(&terms);
argc = parse_options(argc, argv, prefix, options,
git_bisect_helper_usage, 0);
@@ -182,24 +251,38 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
usage_with_options(git_bisect_helper_usage, options);
switch (cmdmode) {
+ int nolog;
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
case WRITE_TERMS:
if (argc != 2)
die(_("--write-terms requires two arguments"));
- return write_terms(argv[0], argv[1]);
+ res = write_terms(argv[0], argv[1]);
+ break;
case BISECT_CLEAN_STATE:
if (argc != 0)
die(_("--bisect-clean-state requires no arguments"));
- return bisect_clean_state();
+ res = bisect_clean_state();
+ break;
case BISECT_RESET:
if (argc > 1)
die(_("--bisect-reset requires either zero or one arguments"));
- return bisect_reset(argc ? argv[0] : NULL);
+ res = bisect_reset(argc ? argv[0] : NULL);
+ break;
case CHECK_EXPECTED_REVS:
- return check_expected_revs(argv, argc);
+ res = check_expected_revs(argv, argc);
+ break;
+ case BISECT_WRITE:
+ if (argc != 4 && argc != 5)
+ die(_("--bisect-write requires either 4 or 5 arguments"));
+ nolog = (argc == 5) && !strcmp(argv[4], "nolog");
+ strbuf_addstr(&terms.term_good, argv[2]);
+ strbuf_addstr(&terms.term_bad, argv[3]);
+ res = bisect_write(argv[0], argv[1], &terms, nolog);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
- return 0;
+ bisect_terms_release(&terms);
+ return res;
}
diff --git a/git-bisect.sh b/git-bisect.sh
index c3e43248..dfdec33 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -144,7 +144,7 @@ bisect_start() {
0) state=$TERM_BAD ; bad_seen=1 ;;
*) state=$TERM_GOOD ;;
esac
- eval="$eval bisect_write '$state' '$rev' 'nolog' &&"
+ eval="$eval git bisect--helper --bisect-write '$state' '$rev' '$TERM_GOOD' '$TERM_BAD' 'nolog' &&"
done
#
# Verify HEAD.
@@ -220,23 +220,6 @@ bisect_start() {
trap '-' 0
}
-bisect_write() {
- state="$1"
- rev="$2"
- nolog="$3"
- case "$state" in
- "$TERM_BAD")
- tag="$state" ;;
- "$TERM_GOOD"|skip)
- tag="$state"-"$rev" ;;
- *)
- die "$(eval_gettext "Bad bisect_write argument: \$state")" ;;
- esac
- git update-ref "refs/bisect/$tag" "$rev" || exit
- echo "# $state: $(git show-branch $rev)" >>"$GIT_DIR/BISECT_LOG"
- test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -263,7 +246,7 @@ bisect_state() {
bisected_head=$(bisect_head)
rev=$(git rev-parse --verify "$bisected_head") ||
die "$(eval_gettext "Bad rev input: \$bisected_head")"
- bisect_write "$state" "$rev"
+ git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
git bisect--helper --check-expected-revs "$rev" ;;
2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
shift
@@ -276,7 +259,7 @@ bisect_state() {
done
for rev in $hash_list
do
- bisect_write "$state" "$rev"
+ git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
done
git bisect--helper --check-expected-revs $hash_list ;;
*,"$TERM_BAD")
@@ -413,7 +396,7 @@ bisect_replay () {
cmd="bisect_start $rev"
eval "$cmd" ;;
"$TERM_GOOD"|"$TERM_BAD"|skip)
- bisect_write "$command" "$rev" ;;
+ git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
terms)
bisect_terms $rev ;;
*)
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v13 08/13] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C
2016-08-19 20:32 ` [PATCH v13 " Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 04/13] bisect--helper: `bisect_clean_state` shell function in C Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 07/13] bisect--helper: `bisect_reset` " Pranit Bauva
@ 2016-08-19 20:32 ` Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 12/13] bisect--helper: `get_terms` & `bisect_terms` " Pranit Bauva
` (10 subsequent siblings)
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-19 20:32 UTC (permalink / raw)
To: git
Reimplement `is_expected_rev` & `check_expected_revs` shell function in
C and add a `--check-expected-revs` subcommand to `git bisect--helper` to
call it from git-bisect.sh .
Using `--check-expected-revs` subcommand is a temporary measure to port
shell functions to C so as to use the existing test suite. As more
functions are ported, this subcommand would be retired but its
implementation will be called by some other method.
Helped-by: Eric Sunshine <sunshine@sunshineco.com>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 33 ++++++++++++++++++++++++++++++++-
git-bisect.sh | 20 ++------------------
2 files changed, 34 insertions(+), 19 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 9aba094..711be75 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -123,13 +123,40 @@ static int bisect_reset(const char *commit)
return bisect_clean_state();
}
+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) >= 0) {
+ strbuf_trim(&actual_hex);
+ res = !strcmp(actual_hex.buf, expected_hex);
+ }
+ strbuf_release(&actual_hex);
+ return res;
+}
+
+static int 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());
+ return 0;
+ }
+ }
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
WRITE_TERMS,
BISECT_CLEAN_STATE,
- BISECT_RESET
+ BISECT_RESET,
+ CHECK_EXPECTED_REVS
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -141,6 +168,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
N_("reset the bisection state"), BISECT_RESET),
+ OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
+ N_("check for expected revs"), CHECK_EXPECTED_REVS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -167,6 +196,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc > 1)
die(_("--bisect-reset requires either zero or one arguments"));
return bisect_reset(argc ? argv[0] : NULL);
+ case CHECK_EXPECTED_REVS:
+ return check_expected_revs(argv, argc);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 442397b..c3e43248 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -237,22 +237,6 @@ bisect_write() {
test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
}
-is_expected_rev() {
- test -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
- test "$1" = $(cat "$GIT_DIR/BISECT_EXPECTED_REV")
-}
-
-check_expected_revs() {
- for _rev in "$@"; do
- if ! is_expected_rev "$_rev"
- then
- rm -f "$GIT_DIR/BISECT_ANCESTORS_OK"
- rm -f "$GIT_DIR/BISECT_EXPECTED_REV"
- return
- fi
- done
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -280,7 +264,7 @@ bisect_state() {
rev=$(git rev-parse --verify "$bisected_head") ||
die "$(eval_gettext "Bad rev input: \$bisected_head")"
bisect_write "$state" "$rev"
- check_expected_revs "$rev" ;;
+ git bisect--helper --check-expected-revs "$rev" ;;
2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
shift
hash_list=''
@@ -294,7 +278,7 @@ bisect_state() {
do
bisect_write "$state" "$rev"
done
- check_expected_revs $hash_list ;;
+ git bisect--helper --check-expected-revs $hash_list ;;
*,"$TERM_BAD")
die "$(eval_gettext "'git bisect \$TERM_BAD' can take only one argument.")" ;;
*)
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v13 03/13] bisect--helper: `write_terms` shell function in C
2016-08-19 20:32 ` [PATCH v13 " Pranit Bauva
` (10 preceding siblings ...)
2016-08-19 20:32 ` [PATCH v13 02/13] bisect: rewrite `check_term_format` " Pranit Bauva
@ 2016-08-19 20:32 ` Pranit Bauva
2016-08-21 11:14 ` [PATCH v13 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-19 20:32 UTC (permalink / raw)
To: git
Reimplement the `write_terms` shell function in C and add a `write-terms`
subcommand to `git bisect--helper` to call it from git-bisect.sh . Also
remove the subcommand `--check-term-format` as it can now be called from
inside the function write_terms() C implementation.
Also `|| exit` is added when calling write-terms subcommand from
git-bisect.sh so as to exit whenever there is an error.
Using `--write-terms` subcommand is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and its implementation will
be called by some other method.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 36 +++++++++++++++++++++++++++++-------
git-bisect.sh | 22 +++++++---------------
2 files changed, 36 insertions(+), 22 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index a47f1f2..30e1031 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -4,9 +4,11 @@
#include "bisect.h"
#include "refs.h"
+static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
+
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
- N_("git bisect--helper --check-term-format <term> <orig_term>"),
+ N_("git bisect--helper --write-terms <bad_term> <good_term>"),
NULL
};
@@ -57,18 +59,38 @@ static int check_term_format(const char *term, const char *orig_term)
return 0;
}
+static int write_terms(const char *bad, const char *good)
+{
+ FILE *fp;
+ 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;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
- CHECK_TERM_FMT
+ WRITE_TERMS
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
- OPT_CMDMODE(0, "check-term-format", &cmdmode,
- N_("check format of the term"), CHECK_TERM_FMT),
+ OPT_CMDMODE(0, "write-terms", &cmdmode,
+ N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -83,10 +105,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
switch (cmdmode) {
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
- case CHECK_TERM_FMT:
+ case WRITE_TERMS:
if (argc != 2)
- die(_("--check-term-format requires two arguments"));
- return check_term_format(argv[0], argv[1]);
+ die(_("--write-terms requires two arguments"));
+ return write_terms(argv[0], argv[1]);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index a727c59..9ef6cb8 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -209,7 +209,7 @@ bisect_start() {
eval "$eval true" &&
if test $must_write_terms -eq 1
then
- write_terms "$TERM_BAD" "$TERM_GOOD"
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD"
fi &&
echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
#
@@ -557,18 +557,6 @@ get_terms () {
fi
}
-write_terms () {
- TERM_BAD=$1
- TERM_GOOD=$2
- if test "$TERM_BAD" = "$TERM_GOOD"
- then
- die "$(gettext "please use two different terms")"
- fi
- git bisect--helper --check-term-format "$TERM_BAD" bad || exit
- git bisect--helper --check-term-format "$TERM_GOOD" good || exit
- printf '%s\n%s\n' "$TERM_BAD" "$TERM_GOOD" >"$GIT_DIR/BISECT_TERMS"
-}
-
check_and_set_terms () {
cmd="$1"
case "$cmd" in
@@ -582,13 +570,17 @@ check_and_set_terms () {
bad|good)
if ! test -s "$GIT_DIR/BISECT_TERMS"
then
- write_terms bad good
+ TERM_BAD=bad
+ TERM_GOOD=good
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
fi
;;
new|old)
if ! test -s "$GIT_DIR/BISECT_TERMS"
then
- write_terms new old
+ TERM_BAD=new
+ TERM_GOOD=old
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
fi
;;
esac ;;
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v13 06/13] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file()
2016-08-19 20:32 ` [PATCH v13 " Pranit Bauva
` (5 preceding siblings ...)
2016-08-19 20:32 ` [PATCH v13 10/13] bisect--helper: `check_and_set_terms` " Pranit Bauva
@ 2016-08-19 20:32 ` Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 13/13] bisect--helper: `bisect_start` shell function partially in C Pranit Bauva
` (6 subsequent siblings)
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-19 20:32 UTC (permalink / raw)
To: git
is_empty_file() can help to refactor a lot of code. This will be very
helpful in porting "git bisect" to C.
Suggested-by: Torsten Bögershausen <tboegi@web.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/am.c | 20 ++------------------
cache.h | 3 +++
wrapper.c | 13 +++++++++++++
3 files changed, 18 insertions(+), 18 deletions(-)
diff --git a/builtin/am.c b/builtin/am.c
index 739b34d..9e1e9d6 100644
--- a/builtin/am.c
+++ b/builtin/am.c
@@ -30,22 +30,6 @@
#include "mailinfo.h"
/**
- * Returns 1 if the file is empty or does not exist, 0 otherwise.
- */
-static int is_empty_file(const char *filename)
-{
- struct stat st;
-
- if (stat(filename, &st) < 0) {
- if (errno == ENOENT)
- return 1;
- die_errno(_("could not stat %s"), filename);
- }
-
- return !st.st_size;
-}
-
-/**
* Returns the length of the first line of msg.
*/
static int linelen(const char *msg)
@@ -1324,7 +1308,7 @@ static int parse_mail(struct am_state *state, const char *mail)
goto finish;
}
- if (is_empty_file(am_path(state, "patch"))) {
+ if (is_empty_or_missing_file(am_path(state, "patch"))) {
printf_ln(_("Patch is empty. Was it split wrong?"));
die_user_resolve(state);
}
@@ -1896,7 +1880,7 @@ static void am_run(struct am_state *state, int resume)
resume = 0;
}
- if (!is_empty_file(am_path(state, "rewritten"))) {
+ if (!is_empty_or_missing_file(am_path(state, "rewritten"))) {
assert(state->rebasing);
copy_notes_for_rebase(state);
run_post_rewrite_hook(state);
diff --git a/cache.h b/cache.h
index b780a91..49f214b 100644
--- a/cache.h
+++ b/cache.h
@@ -1916,4 +1916,7 @@ void sleep_millisec(int millisec);
*/
void safe_create_dir(const char *dir, int share);
+/* Return 1 if the file is empty or does not exists, 0 otherwise. */
+extern int is_empty_or_missing_file(const char *filename);
+
#endif /* CACHE_H */
diff --git a/wrapper.c b/wrapper.c
index e7f1979..78f6431 100644
--- a/wrapper.c
+++ b/wrapper.c
@@ -679,3 +679,16 @@ void sleep_millisec(int millisec)
{
poll(NULL, 0, millisec);
}
+
+int is_empty_or_missing_file(const char *filename)
+{
+ struct stat st;
+
+ if (stat(filename, &st) < 0) {
+ if (errno == ENOENT)
+ return 1;
+ die_errno(_("could not stat %s"), filename);
+ }
+
+ return !st.st_size;
+}
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v13 04/13] bisect--helper: `bisect_clean_state` shell function in C
2016-08-19 20:32 ` [PATCH v13 " Pranit Bauva
@ 2016-08-19 20:32 ` Pranit Bauva
2016-08-21 11:18 ` Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 07/13] bisect--helper: `bisect_reset` " Pranit Bauva
` (12 subsequent siblings)
13 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-19 20:32 UTC (permalink / raw)
To: git
Reimplement `bisect_clean_state` shell function in C and add a
`bisect-clean-state` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Using `--bisect-clean-state` subcommand is a measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by bisect_reset() and bisect_start().
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
bisect.c | 43 +++++++++++++++++++++++++++++++++++++++++++
bisect.h | 2 ++
builtin/bisect--helper.c | 14 +++++++++++++-
git-bisect.sh | 26 +++-----------------------
4 files changed, 61 insertions(+), 24 deletions(-)
diff --git a/bisect.c b/bisect.c
index 6f512c2..45d598d 100644
--- a/bisect.c
+++ b/bisect.c
@@ -430,6 +430,12 @@ static int read_bisect_refs(void)
static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
+static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
+static GIT_PATH_FUNC(git_path_bisect_run, "BISECT_RUN")
+static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
+static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
+static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
+static GIT_PATH_FUNC(git_path_head_name, "head-name")
static void read_bisect_paths(struct argv_array *array)
{
@@ -1040,3 +1046,40 @@ int estimate_bisect_steps(int all)
return (e < 3 * x) ? n : n - 1;
}
+
+static int mark_for_removal(const char *refname, const struct object_id *oid,
+ int flag, void *cb_data)
+{
+ struct string_list *refs = cb_data;
+ char *ref = xstrfmt("refs/bisect%s", refname);
+ string_list_append(refs, ref);
+ return 0;
+}
+
+int bisect_clean_state(void)
+{
+ int result = 0;
+
+ /* There may be some refs packed during bisection */
+ struct string_list refs_for_removal = STRING_LIST_INIT_NODUP;
+ for_each_ref_in("refs/bisect", mark_for_removal, (void *) &refs_for_removal);
+ string_list_append(&refs_for_removal, xstrdup("BISECT_HEAD"));
+ result = delete_refs(&refs_for_removal, REF_NODEREF);
+ refs_for_removal.strdup_strings = 1;
+ string_list_clear(&refs_for_removal, 0);
+ unlink_or_warn(git_path_bisect_expected_rev());
+ unlink_or_warn(git_path_bisect_ancestors_ok());
+ unlink_or_warn(git_path_bisect_log());
+ unlink_or_warn(git_path_bisect_names());
+ unlink_or_warn(git_path_bisect_run());
+ unlink_or_warn(git_path_bisect_terms());
+ /* Cleanup head-name if it got left by an old version of git-bisect */
+ unlink_or_warn(git_path_head_name());
+ /*
+ * Cleanup BISECT_START last to support the --no-checkout option
+ * introduced in the commit 4796e823a.
+ */
+ unlink_or_warn(git_path_bisect_start());
+
+ return result;
+}
diff --git a/bisect.h b/bisect.h
index acd12ef..0ae63d4 100644
--- a/bisect.h
+++ b/bisect.h
@@ -28,4 +28,6 @@ extern int estimate_bisect_steps(int all);
extern void read_bisect_terms(const char **bad, const char **good);
+extern int bisect_clean_state(void);
+
#endif
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 30e1031..e50934c 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -5,10 +5,15 @@
#include "refs.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
+static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
+static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
+static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
+static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
+ N_("git bisect--helper --bisect-clean-state"),
NULL
};
@@ -83,7 +88,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
- WRITE_TERMS
+ WRITE_TERMS,
+ BISECT_CLEAN_STATE
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -91,6 +97,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("perform 'git bisect next'"), NEXT_ALL),
OPT_CMDMODE(0, "write-terms", &cmdmode,
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
+ OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
+ N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -109,6 +117,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc != 2)
die(_("--write-terms requires two arguments"));
return write_terms(argv[0], argv[1]);
+ case BISECT_CLEAN_STATE:
+ if (argc != 0)
+ die(_("--bisect-clean-state requires no arguments"));
+ return bisect_clean_state();
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 9ef6cb8..f1202df 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -186,7 +186,7 @@ bisect_start() {
#
# Get rid of any old bisect state.
#
- bisect_clean_state || exit
+ git bisect--helper --bisect-clean-state || exit
#
# Change state.
@@ -195,7 +195,7 @@ bisect_start() {
# We have to trap this to be able to clean up using
# "bisect_clean_state".
#
- trap 'bisect_clean_state' 0
+ trap 'git bisect--helper --bisect-clean-state' 0
trap 'exit 255' 1 2 3 15
#
@@ -430,27 +430,7 @@ bisect_reset() {
die "$(eval_gettext "Could not check out original HEAD '\$branch'.
Try 'git bisect reset <commit>'.")"
fi
- bisect_clean_state
-}
-
-bisect_clean_state() {
- # There may be some refs packed during bisection.
- git for-each-ref --format='%(refname) %(objectname)' refs/bisect/\* |
- while read ref hash
- do
- git update-ref -d $ref $hash || exit
- done
- rm -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
- rm -f "$GIT_DIR/BISECT_ANCESTORS_OK" &&
- rm -f "$GIT_DIR/BISECT_LOG" &&
- rm -f "$GIT_DIR/BISECT_NAMES" &&
- rm -f "$GIT_DIR/BISECT_RUN" &&
- rm -f "$GIT_DIR/BISECT_TERMS" &&
- # Cleanup head-name if it got left by an old version of git-bisect
- rm -f "$GIT_DIR/head-name" &&
- git update-ref -d --no-deref BISECT_HEAD &&
- # clean up BISECT_START last
- rm -f "$GIT_DIR/BISECT_START"
+ git bisect--helper --bisect-clean-state || exit
}
bisect_replay () {
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v13 10/13] bisect--helper: `check_and_set_terms` shell function in C
2016-08-19 20:32 ` [PATCH v13 " Pranit Bauva
` (4 preceding siblings ...)
2016-08-19 20:32 ` [PATCH v13 09/13] bisect--helper: `bisect_write` " Pranit Bauva
@ 2016-08-19 20:32 ` Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 06/13] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
` (7 subsequent siblings)
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-19 20:32 UTC (permalink / raw)
To: git
Reimplement the `check_and_set_terms` shell function in C and add
`check-and-set-terms` subcommand to `git bisect--helper` to call it from
git-bisect.sh
Using `--check-and-set-terms` subcommand is a temporary measure to port
shell function in C so as to use the existing test suite. As more
functions are ported, this subcommand will be retired but its
implementation will be called by some other methods.
check_and_set_terms() sets and receives two global variables namely
TERM_GOOD and TERM_BAD in the shell script. Luckily the file BISECT_TERMS
also contains the value of those variables so its appropriate to evoke the
method get_terms() after calling the subcommand so that it retrieves the
value of TERM_GOOD and TERM_BAD from the file BISECT_TERMS. The two
global variables are passed as arguments to the subcommand.
Also introduce bisect_terms_reset() to empty the contents of `term_good`
and `term_bad` of `struct bisect_terms`.
Also introduce set_terms() to copy the `term_good` and `term_bad` into
`struct bisect_terms` and write it out to the file BISECT_TERMS.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 52 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 36 ++++-----------------------------
2 files changed, 55 insertions(+), 33 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 5364960..450426c 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -20,6 +20,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-clean-state"),
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
+ N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
NULL
};
@@ -40,6 +41,12 @@ static void bisect_terms_release(struct bisect_terms *terms)
strbuf_release(&terms->term_bad);
}
+static void bisect_terms_reset(struct bisect_terms *term)
+{
+ strbuf_reset(&term->term_good);
+ strbuf_reset(&term->term_bad);
+}
+
/*
* Check whether the string `term` belongs to the set of strings
* included in the variable arguments.
@@ -213,6 +220,39 @@ static int bisect_write(const char *state, const char *rev,
return 0;
}
+static int set_terms(struct bisect_terms *terms, const char *bad,
+ const char *good)
+{
+ bisect_terms_reset(terms);
+ strbuf_addstr(&terms->term_good, good);
+ strbuf_addstr(&terms->term_bad, bad);
+ return write_terms(terms->term_bad.buf, terms->term_good.buf);
+}
+
+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.buf) &&
+ strcmp(cmd, terms->term_good.buf))
+ return error(_("Invalid command: you're currently in a "
+ "%s/%s bisect"), terms->term_bad.buf,
+ terms->term_good.buf);
+
+ if (!has_term_file) {
+ if (one_of(cmd, "bad", "good", NULL))
+ return set_terms(terms, "bad", "good");
+ if (one_of(cmd, "new", "old", NULL))
+ return set_terms(terms, "new", "old");
+ }
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -221,7 +261,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_CLEAN_STATE,
BISECT_RESET,
CHECK_EXPECTED_REVS,
- BISECT_WRITE
+ BISECT_WRITE,
+ CHECK_AND_SET_TERMS
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -237,6 +278,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check for expected revs"), CHECK_EXPECTED_REVS),
OPT_CMDMODE(0, "bisect-write", &cmdmode,
N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
+ OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
+ N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -280,6 +323,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
strbuf_addstr(&terms.term_bad, argv[3]);
res = bisect_write(argv[0], argv[1], &terms, nolog);
break;
+ case CHECK_AND_SET_TERMS:
+ if (argc != 3)
+ die(_("--check-and-set-terms requires 3 arguments"));
+ strbuf_addstr(&terms.term_good, argv[1]);
+ strbuf_addstr(&terms.term_bad, argv[2]);
+ res = check_and_set_terms(&terms, argv[0]);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index dfdec33..bdf2227 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -238,7 +238,8 @@ bisect_skip() {
bisect_state() {
bisect_autostart
state=$1
- check_and_set_terms $state
+ git bisect--helper --check-and-set-terms $state $TERM_GOOD $TERM_BAD || exit
+ get_terms
case "$#,$state" in
0,*)
die "Please call 'bisect_state' with at least one argument." ;;
@@ -390,7 +391,8 @@ bisect_replay () {
command="$bisect"
fi
get_terms
- check_and_set_terms "$command"
+ git bisect--helper --check-and-set-terms "$command" "$TERM_GOOD" "$TERM_BAD" || exit
+ get_terms
case "$command" in
start)
cmd="bisect_start $rev"
@@ -480,36 +482,6 @@ get_terms () {
fi
}
-check_and_set_terms () {
- cmd="$1"
- case "$cmd" in
- skip|start|terms) ;;
- *)
- if test -s "$GIT_DIR/BISECT_TERMS" && test "$cmd" != "$TERM_BAD" && test "$cmd" != "$TERM_GOOD"
- then
- die "$(eval_gettext "Invalid command: you're currently in a \$TERM_BAD/\$TERM_GOOD bisect.")"
- fi
- case "$cmd" in
- bad|good)
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- TERM_BAD=bad
- TERM_GOOD=good
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
- fi
- ;;
- new|old)
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- TERM_BAD=new
- TERM_GOOD=old
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
- fi
- ;;
- esac ;;
- esac
-}
-
bisect_voc () {
case "$1" in
bad) echo "bad|new" ;;
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v13 05/13] t6030: explicitly test for bisection cleanup
2016-08-19 20:32 ` [PATCH v13 " Pranit Bauva
` (7 preceding siblings ...)
2016-08-19 20:32 ` [PATCH v13 13/13] bisect--helper: `bisect_start` shell function partially in C Pranit Bauva
@ 2016-08-19 20:32 ` Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 11/13] bisect--helper: `bisect_next_check` & bisect_voc shell function in C Pranit Bauva
` (4 subsequent siblings)
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-19 20:32 UTC (permalink / raw)
To: git
Add test to explicitly check that 'git bisect reset' is working as
expected. This is already covered implicitly by the test suite.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
I faced this problem while converting `bisect_clean_state` and the tests
where showing breakages but it wasn't clear as to where exactly are they
breaking. This will patch will help in that. Also I tested the test
coverage of the test suite before this patch and it covers this (I did
this by purposely changing names of files in git-bisect.sh and running
the test suite).
---
t/t6030-bisect-porcelain.sh | 17 +++++++++++++++++
1 file changed, 17 insertions(+)
diff --git a/t/t6030-bisect-porcelain.sh b/t/t6030-bisect-porcelain.sh
index 5e5370f..18e7998 100755
--- a/t/t6030-bisect-porcelain.sh
+++ b/t/t6030-bisect-porcelain.sh
@@ -894,4 +894,21 @@ test_expect_success 'bisect start takes options and revs in any order' '
test_cmp expected actual
'
+test_expect_success 'git bisect reset cleans bisection state properly' '
+ git bisect reset &&
+ git bisect start &&
+ git bisect good $HASH1 &&
+ git bisect bad $HASH4 &&
+ git bisect reset &&
+ test -z "$(git for-each-ref "refs/bisect/*")" &&
+ test_path_is_missing "$GIT_DIR/BISECT_EXPECTED_REV" &&
+ test_path_is_missing "$GIT_DIR/BISECT_ANCESTORS_OK" &&
+ test_path_is_missing "$GIT_DIR/BISECT_LOG" &&
+ test_path_is_missing "$GIT_DIR/BISECT_RUN" &&
+ test_path_is_missing "$GIT_DIR/BISECT_TERMS" &&
+ test_path_is_missing "$GIT_DIR/head-name" &&
+ test_path_is_missing "$GIT_DIR/BISECT_HEAD" &&
+ test_path_is_missing "$GIT_DIR/BISECT_START"
+'
+
test_done
--
https://github.com/git/git/pull/281
^ permalink raw reply related [flat|nested] 320+ messages in thread
* Re: [PATCH v13 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2016-08-19 20:32 ` [PATCH v13 " Pranit Bauva
` (11 preceding siblings ...)
2016-08-19 20:32 ` [PATCH v13 03/13] bisect--helper: `write_terms` " Pranit Bauva
@ 2016-08-21 11:14 ` Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
13 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-21 11:14 UTC (permalink / raw)
To: Git List
Hey everyone,
On Sat, Aug 20, 2016 at 2:02 AM, Pranit Bauva <pranit.bauva@gmail.com> wrote:
> `--next-all` is meant to be used as a subcommand to support multiple
> "operation mode" though the current implementation does not contain any
> other subcommand along side with `--next-all` but further commits will
> include some more subcommands.
>
> Helped-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
> Mentored-by: Lars Schneider <larsxschneider@gmail.com>
> Mentored-by: Christian Couder <chriscool@tuxfamily.org>
> Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
> ---
> builtin/bisect--helper.c | 17 +++++++++++------
> 1 file changed, 11 insertions(+), 6 deletions(-)
>
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 3324229..8111c91 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -10,11 +10,11 @@ static const char * const git_bisect_helper_usage[] = {
>
> int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> {
> - int next_all = 0;
> + enum { NEXT_ALL = 1 } cmdmode = 0;
> int no_checkout = 0;
> struct option options[] = {
> - OPT_BOOL(0, "next-all", &next_all,
> - N_("perform 'git bisect next'")),
> + OPT_CMDMODE(0, "next-all", &cmdmode,
> + N_("perform 'git bisect next'"), NEXT_ALL),
> OPT_BOOL(0, "no-checkout", &no_checkout,
> N_("update BISECT_HEAD instead of checking out the current commit")),
> OPT_END()
> @@ -23,9 +23,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> argc = parse_options(argc, argv, prefix, options,
> git_bisect_helper_usage, 0);
>
> - if (!next_all)
> + if (!cmdmode)
> usage_with_options(git_bisect_helper_usage, options);
>
> - /* next-all */
> - return bisect_next_all(prefix, no_checkout);
> + switch (cmdmode) {
> + case NEXT_ALL:
> + return bisect_next_all(prefix, no_checkout);
> + default:
> + die("BUG: unknown subcommand '%d'", cmdmode);
> + }
> + return 0;
> }
This is the same series (except for patch 04/13) and rebased on v2.10-rc0.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v13 04/13] bisect--helper: `bisect_clean_state` shell function in C
2016-08-19 20:32 ` [PATCH v13 04/13] bisect--helper: `bisect_clean_state` shell function in C Pranit Bauva
@ 2016-08-21 11:18 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-21 11:18 UTC (permalink / raw)
To: Git List
Hey,
On Sat, Aug 20, 2016 at 2:02 AM, Pranit Bauva <pranit.bauva@gmail.com> wrote:
> Reimplement `bisect_clean_state` shell function in C and add a
> `bisect-clean-state` subcommand to `git bisect--helper` to call it from
> git-bisect.sh .
>
> Using `--bisect-clean-state` subcommand is a measure to port shell
> function to C so as to use the existing test suite. As more functions
> are ported, this subcommand will be retired but its implementation will
> be called by bisect_reset() and bisect_start().
>
> Mentored-by: Lars Schneider <larsxschneider@gmail.com>
> Mentored-by: Christian Couder <chriscool@tuxfamily.org>
> Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
> ---
> bisect.c | 43 +++++++++++++++++++++++++++++++++++++++++++
> bisect.h | 2 ++
> builtin/bisect--helper.c | 14 +++++++++++++-
> git-bisect.sh | 26 +++-----------------------
> 4 files changed, 61 insertions(+), 24 deletions(-)
>
> diff --git a/bisect.c b/bisect.c
> index 6f512c2..45d598d 100644
> --- a/bisect.c
> +++ b/bisect.c
> @@ -430,6 +430,12 @@ static int read_bisect_refs(void)
>
> static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
> static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
> +static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
> +static GIT_PATH_FUNC(git_path_bisect_run, "BISECT_RUN")
> +static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
> +static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
> +static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
> +static GIT_PATH_FUNC(git_path_head_name, "head-name")
>
> static void read_bisect_paths(struct argv_array *array)
> {
> @@ -1040,3 +1046,40 @@ int estimate_bisect_steps(int all)
>
> return (e < 3 * x) ? n : n - 1;
> }
> +
> +static int mark_for_removal(const char *refname, const struct object_id *oid,
> + int flag, void *cb_data)
> +{
> + struct string_list *refs = cb_data;
> + char *ref = xstrfmt("refs/bisect%s", refname);
> + string_list_append(refs, ref);
> + return 0;
> +}
> +
> +int bisect_clean_state(void)
> +{
> + int result = 0;
> +
> + /* There may be some refs packed during bisection */
> + struct string_list refs_for_removal = STRING_LIST_INIT_NODUP;
> + for_each_ref_in("refs/bisect", mark_for_removal, (void *) &refs_for_removal);
> + string_list_append(&refs_for_removal, xstrdup("BISECT_HEAD"));
> + result = delete_refs(&refs_for_removal, REF_NODEREF);
> + refs_for_removal.strdup_strings = 1;
> + string_list_clear(&refs_for_removal, 0);
> + unlink_or_warn(git_path_bisect_expected_rev());
> + unlink_or_warn(git_path_bisect_ancestors_ok());
> + unlink_or_warn(git_path_bisect_log());
> + unlink_or_warn(git_path_bisect_names());
> + unlink_or_warn(git_path_bisect_run());
> + unlink_or_warn(git_path_bisect_terms());
> + /* Cleanup head-name if it got left by an old version of git-bisect */
> + unlink_or_warn(git_path_head_name());
> + /*
> + * Cleanup BISECT_START last to support the --no-checkout option
> + * introduced in the commit 4796e823a.
> + */
> + unlink_or_warn(git_path_bisect_start());
> +
> + return result;
> +}
> diff --git a/bisect.h b/bisect.h
> index acd12ef..0ae63d4 100644
> --- a/bisect.h
> +++ b/bisect.h
> @@ -28,4 +28,6 @@ extern int estimate_bisect_steps(int all);
>
> extern void read_bisect_terms(const char **bad, const char **good);
>
> +extern int bisect_clean_state(void);
> +
> #endif
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 30e1031..e50934c 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -5,10 +5,15 @@
> #include "refs.h"
>
> static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
> +static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
> +static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
> +static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
> +static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
>
> static const char * const git_bisect_helper_usage[] = {
> N_("git bisect--helper --next-all [--no-checkout]"),
> N_("git bisect--helper --write-terms <bad_term> <good_term>"),
> + N_("git bisect--helper --bisect-clean-state"),
> NULL
> };
>
> @@ -83,7 +88,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> {
> enum {
> NEXT_ALL = 1,
> - WRITE_TERMS
> + WRITE_TERMS,
> + BISECT_CLEAN_STATE
> } cmdmode = 0;
> int no_checkout = 0;
> struct option options[] = {
> @@ -91,6 +97,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> N_("perform 'git bisect next'"), NEXT_ALL),
> OPT_CMDMODE(0, "write-terms", &cmdmode,
> N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
> + OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
> + N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
> OPT_BOOL(0, "no-checkout", &no_checkout,
> N_("update BISECT_HEAD instead of checking out the current commit")),
> OPT_END()
> @@ -109,6 +117,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> if (argc != 2)
> die(_("--write-terms requires two arguments"));
> return write_terms(argv[0], argv[1]);
> + case BISECT_CLEAN_STATE:
> + if (argc != 0)
> + die(_("--bisect-clean-state requires no arguments"));
> + return bisect_clean_state();
> default:
> die("BUG: unknown subcommand '%d'", cmdmode);
> }
> diff --git a/git-bisect.sh b/git-bisect.sh
> index 9ef6cb8..f1202df 100755
> --- a/git-bisect.sh
> +++ b/git-bisect.sh
> @@ -186,7 +186,7 @@ bisect_start() {
> #
> # Get rid of any old bisect state.
> #
> - bisect_clean_state || exit
> + git bisect--helper --bisect-clean-state || exit
>
> #
> # Change state.
> @@ -195,7 +195,7 @@ bisect_start() {
> # We have to trap this to be able to clean up using
> # "bisect_clean_state".
> #
> - trap 'bisect_clean_state' 0
> + trap 'git bisect--helper --bisect-clean-state' 0
> trap 'exit 255' 1 2 3 15
>
> #
> @@ -430,27 +430,7 @@ bisect_reset() {
> die "$(eval_gettext "Could not check out original HEAD '\$branch'.
> Try 'git bisect reset <commit>'.")"
> fi
> - bisect_clean_state
> -}
> -
> -bisect_clean_state() {
> - # There may be some refs packed during bisection.
> - git for-each-ref --format='%(refname) %(objectname)' refs/bisect/\* |
> - while read ref hash
> - do
> - git update-ref -d $ref $hash || exit
> - done
> - rm -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
> - rm -f "$GIT_DIR/BISECT_ANCESTORS_OK" &&
> - rm -f "$GIT_DIR/BISECT_LOG" &&
> - rm -f "$GIT_DIR/BISECT_NAMES" &&
> - rm -f "$GIT_DIR/BISECT_RUN" &&
> - rm -f "$GIT_DIR/BISECT_TERMS" &&
> - # Cleanup head-name if it got left by an old version of git-bisect
> - rm -f "$GIT_DIR/head-name" &&
> - git update-ref -d --no-deref BISECT_HEAD &&
> - # clean up BISECT_START last
> - rm -f "$GIT_DIR/BISECT_START"
> + git bisect--helper --bisect-clean-state || exit
> }
>
> bisect_replay () {
The change as compared to the v12 is that the function
`bisect_clean_state()` has been moved to bisect.c from
builtin/bisect--helper.c because in a future function conversion
(bisect_next()) I needed bisect_clean_state() in bisect.c because
bisect.c uses exit() whose signals can be easily trapped by the shell
function and then do the cleanup. But now it would be essential to
convert those exit() statements to return statements. This has been
done. One can find it here[1].
[1]: https://github.com/pranitbauva1997/git/pull/22
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* [PATCH v14 25/27] bisect--helper: retire `--bisect-autostart` subcommand
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (13 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 11/27] bisect--helper: `bisect_next_check` & bisect_voc shell function in C Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 07/27] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
` (13 subsequent siblings)
28 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
The `--bisect-autostart` subcommand is no longer used in the shell
script and the function `bisect_autostart()` is called from the C
implementation.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 11 -----------
1 file changed, 11 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 8982f29..a89e2f7 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -27,7 +27,6 @@ static const char * const git_bisect_helper_usage[] = {
"[--no-checkout] [<bad> [<good>...]] [--] [<paths>...]"),
N_("git bisect--helper --bisect-next"),
N_("git bisect--helper --bisect-auto-next"),
- N_("git bisect--helper --bisect-autostart"),
N_("git bisect--helper --bisect-state (bad|new) [<rev>]"),
N_("git bisect--helper --bisect-state (good|old) [<rev>...]"),
N_("git bisect--helper --bisect-replay <filename>"),
@@ -974,7 +973,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_START,
BISECT_NEXT,
BISECT_AUTO_NEXT,
- BISECT_AUTOSTART,
BISECT_STATE,
BISECT_LOG,
BISECT_REPLAY
@@ -993,8 +991,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("find the next bisection commit"), BISECT_NEXT),
OPT_CMDMODE(0, "bisect-auto-next", &cmdmode,
N_("verify the next bisection state then find the next bisection state"), BISECT_AUTO_NEXT),
- OPT_CMDMODE(0, "bisect-autostart", &cmdmode,
- N_("start the bisection if BISECT_START empty or missing"), BISECT_AUTOSTART),
OPT_CMDMODE(0, "bisect-state", &cmdmode,
N_("mark the state of ref (or refs)"), BISECT_STATE),
OPT_CMDMODE(0, "bisect-log", &cmdmode,
@@ -1050,13 +1046,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
get_terms(&terms);
res = bisect_auto_next(&terms, prefix);
break;
- case BISECT_AUTOSTART:
- if (argc)
- die(_("--bisect-autostart requires 0 arguments"));
- strbuf_addstr(&terms.term_good, "good");
- strbuf_addstr(&terms.term_bad, "bad");
- res = bisect_autostart(&terms);
- break;
case BISECT_STATE:
if (argc == 0)
die(_("--bisect-state requires at least 1 argument"));
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 13/27] bisect--helper: `bisect_start` shell function partially in C
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (9 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 16/27] bisect--helper: retire `--next-all` subcommand Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-25 19:02 ` Junio C Hamano
2016-08-23 11:53 ` [PATCH v14 26/27] bisect--helper: retire `--bisect-auto-next` subcommand Pranit Bauva
` (17 subsequent siblings)
28 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
Reimplement the `bisect_start` shell function partially in C and add
`bisect-start` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
The last part is not converted because it calls another shell function
`bisect_start` shell function will be completed after the `bisect_next`
shell function is ported in C.
Using `--bisect-start` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other methods.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 238 ++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 133 +-------------------------
2 files changed, 238 insertions(+), 133 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 44adf6b..c64996a 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -7,6 +7,7 @@
#include "argv-array.h"
#include "run-command.h"
#include "prompt.h"
+#include "quote.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
@@ -14,6 +15,8 @@ static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
static GIT_PATH_FUNC(git_path_bisect_head, "BISECT_HEAD")
+static GIT_PATH_FUNC(git_path_head_name, "head-name")
+static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
@@ -24,6 +27,8 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
+ N_("git bisect--helper --bisect start [--term-{old,good}=<term> --term-{new,bad}=<term>]"
+ "[--no-checkout] [<bad> [<good>...]] [--] [<paths>...]"),
NULL
};
@@ -391,6 +396,226 @@ static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
return 0;
}
+static int bisect_start(struct bisect_terms *terms, int no_checkout,
+ const char **argv, int argc)
+{
+ int i, has_double_dash = 0, must_write_terms = 0, bad_seen = 0;
+ int flags, pathspec_pos;
+ 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 strbuf orig_args = STRBUF_INIT;
+ const char *head;
+ unsigned char sha1[20];
+ FILE *fp;
+ struct object_id oid;
+
+ if (is_bare_repository())
+ no_checkout = 1;
+
+ for (i = 0; i < argc; i++) {
+ if (!strcmp(argv[i], "--")) {
+ has_double_dash = 1;
+ break;
+ }
+ }
+
+ for (i = 0; i < argc; i++) {
+ const char *commit_id = xstrfmt("%s^{commit}", argv[i]);
+ if (!strcmp(argv[i], "--")) {
+ has_double_dash = 1;
+ break;
+ } else if (!strcmp(argv[i], "--no-checkout"))
+ no_checkout = 1;
+ else if (!strcmp(argv[i], "--term-good") ||
+ !strcmp(argv[i], "--term-old")) {
+ must_write_terms = 1;
+ strbuf_reset(&terms->term_good);
+ strbuf_addstr(&terms->term_good, argv[++i]);
+ } else if (skip_prefix(argv[i], "--term-good=", &argv[i])) {
+ must_write_terms = 1;
+ strbuf_reset(&terms->term_good);
+ strbuf_addstr(&terms->term_good, argv[i]);
+ } else if (skip_prefix(argv[i], "--term-old=", &argv[i])) {
+ must_write_terms = 1;
+ strbuf_reset(&terms->term_good);
+ strbuf_addstr(&terms->term_good, argv[i]);
+ } else if (!strcmp(argv[i], "--term-bad") ||
+ !strcmp(argv[i], "--term-new")) {
+ must_write_terms = 1;
+ strbuf_reset(&terms->term_bad);
+ strbuf_addstr(&terms->term_bad, argv[++i]);
+ } else if (skip_prefix(argv[i], "--term-bad=", &argv[i])) {
+ must_write_terms = 1;
+ strbuf_reset(&terms->term_bad);
+ strbuf_addstr(&terms->term_bad, argv[i]);
+ } else if (skip_prefix(argv[i], "--term-new=", &argv[i])) {
+ must_write_terms = 1;
+ strbuf_reset(&terms->term_good);
+ strbuf_addstr(&terms->term_good, argv[i]);
+ } else if (starts_with(argv[i], "--") &&
+ !one_of(argv[i], "--term-good", "--term-bad", NULL)) {
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ die(_("unrecognised option: '%s'"), argv[i]);
+ } else if (get_oid(commit_id, &oid) && has_double_dash) {
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ die(_("'%s' does not appear to be a valid revision"), argv[i]);
+ } else {
+ string_list_append(&revs, oid_to_hex(&oid));
+ }
+ }
+ 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.
+ */
+ must_write_terms |= !!revs.nr;
+ for (i = 0; i < revs.nr; i++) {
+ if (bad_seen)
+ string_list_append(&states, terms->term_good.buf);
+ else {
+ bad_seen = 1;
+ string_list_append(&states, terms->term_bad.buf);
+ }
+ }
+
+ /*
+ * Verify HEAD
+ */
+ head = resolve_ref_unsafe("HEAD", 0, sha1, &flags);
+ if (!head) {
+ if (get_sha1("HEAD", sha1)) {
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ die(_("Bad HEAD - I need a HEAD"));
+ }
+ }
+ 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) {
+ struct argv_array argv = ARGV_ARRAY_INIT;
+ argv_array_pushl(&argv, "checkout", start_head.buf,
+ "--", NULL);
+ if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
+ error(_("checking out '%s' failed. Try 'git "
+ "bisect start <valid-branch>'."),
+ start_head.buf);
+ strbuf_release(&start_head);
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ return -1;
+ }
+ }
+ } else {
+ if (starts_with(head, "refs/heads/") ||
+ !get_oid_hex(head, &oid) || ref_exists(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())) {
+ strbuf_release(&start_head);
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ die(_("won't bisect on cg-seek'ed tree"));
+ }
+ if (starts_with(head, "refs/heads/")) {
+ strbuf_reset(&start_head);
+ strbuf_addstr(&start_head, head + 11);
+ }
+ else {
+ strbuf_reset(&start_head);
+ strbuf_addstr(&start_head, sha1_to_hex(sha1));
+ }
+ } else {
+ strbuf_release(&start_head);
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ die(_("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);
+
+ if (no_checkout) {
+ get_oid(start_head.buf, &oid);
+ if (update_ref(NULL, "BISECT_HEAD", oid.hash, NULL, 0,
+ UPDATE_REFS_MSG_ON_ERR)) {
+ strbuf_release(&start_head);
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ return -1;
+ }
+ }
+ strbuf_release(&start_head);
+
+ if (pathspec_pos < argc - 1)
+ sq_quote_argv(&bisect_names, argv + pathspec_pos, 0);
+ write_file(git_path_bisect_names(), "%s\n", bisect_names.buf);
+ strbuf_release(&bisect_names);
+
+ for (i = 0; i < states.nr; i++) {
+ if (bisect_write(states.items[i].string,
+ revs.items[i].string, terms, 1)) {
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ return -1;
+ }
+ }
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+
+ if (must_write_terms)
+ if (write_terms(terms->term_bad.buf, terms->term_good.buf))
+ return -1;
+
+ fp = fopen(git_path_bisect_log(), "a");
+ if (!fp)
+ return -1;
+
+ if (fprintf(fp, "git bisect start") < 1)
+ return -1;
+
+ sq_quote_argv(&orig_args, argv, 0);
+ if (fprintf(fp, "%s", orig_args.buf) < 0) {
+ strbuf_release(&orig_args);
+ return -1;
+ }
+ strbuf_release(&orig_args);
+ if (fprintf(fp, "\n") < 1) {
+ fclose(fp);
+ return -1;
+ }
+ fclose(fp);
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -402,7 +627,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_WRITE,
CHECK_AND_SET_TERMS,
BISECT_NEXT_CHECK,
- BISECT_TERMS
+ BISECT_TERMS,
+ BISECT_START
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -424,6 +650,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
OPT_CMDMODE(0, "bisect-terms", &cmdmode,
N_("print out the bisect terms"), BISECT_TERMS),
+ OPT_CMDMODE(0, "bisect-start", &cmdmode,
+ N_("start the bisect session"), BISECT_START),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -432,7 +660,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
bisect_terms_init(&terms);
argc = parse_options(argc, argv, prefix, options,
- git_bisect_helper_usage, PARSE_OPT_KEEP_UNKNOWN);
+ git_bisect_helper_usage,
+ PARSE_OPT_KEEP_DASHDASH | PARSE_OPT_KEEP_UNKNOWN);
if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
@@ -486,6 +715,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
die(_("--bisect-terms requires 0 or 1 argument"));
res = bisect_terms(&terms, argv, argc);
break;
+ case BISECT_START:
+ strbuf_addstr(&terms.term_good, "good");
+ strbuf_addstr(&terms.term_bad, "bad");
+ res = bisect_start(&terms, no_checkout, argv, argc);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index d6c8b5a..f0896b3 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -71,122 +71,7 @@ bisect_autostart() {
}
bisect_start() {
- #
- # Check for one bad and then some good revisions.
- #
- has_double_dash=0
- for arg; do
- case "$arg" in --) has_double_dash=1; break ;; esac
- done
- orig_args=$(git rev-parse --sq-quote "$@")
- bad_seen=0
- eval=''
- must_write_terms=0
- revs=''
- if test "z$(git rev-parse --is-bare-repository)" != zfalse
- then
- mode=--no-checkout
- else
- mode=''
- fi
- while [ $# -gt 0 ]; do
- arg="$1"
- case "$arg" in
- --)
- shift
- break
- ;;
- --no-checkout)
- mode=--no-checkout
- shift ;;
- --term-good|--term-old)
- shift
- must_write_terms=1
- TERM_GOOD=$1
- shift ;;
- --term-good=*|--term-old=*)
- must_write_terms=1
- TERM_GOOD=${1#*=}
- shift ;;
- --term-bad|--term-new)
- shift
- must_write_terms=1
- TERM_BAD=$1
- shift ;;
- --term-bad=*|--term-new=*)
- must_write_terms=1
- TERM_BAD=${1#*=}
- shift ;;
- --*)
- die "$(eval_gettext "unrecognised option: '\$arg'")" ;;
- *)
- rev=$(git rev-parse -q --verify "$arg^{commit}") || {
- test $has_double_dash -eq 1 &&
- die "$(eval_gettext "'\$arg' does not appear to be a valid revision")"
- break
- }
- revs="$revs $rev"
- shift
- ;;
- esac
- done
-
- for rev in $revs
- do
- # 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.
- must_write_terms=1
-
- case $bad_seen in
- 0) state=$TERM_BAD ; bad_seen=1 ;;
- *) state=$TERM_GOOD ;;
- esac
- eval="$eval git bisect--helper --bisect-write '$state' '$rev' '$TERM_GOOD' '$TERM_BAD' 'nolog' &&"
- done
- #
- # Verify HEAD.
- #
- head=$(GIT_DIR="$GIT_DIR" git symbolic-ref -q HEAD) ||
- head=$(GIT_DIR="$GIT_DIR" git rev-parse --verify HEAD) ||
- die "$(gettext "Bad HEAD - I need a HEAD")"
-
- #
- # Check if we are bisecting.
- #
- start_head=''
- if test -s "$GIT_DIR/BISECT_START"
- then
- # Reset to the rev from where we started.
- start_head=$(cat "$GIT_DIR/BISECT_START")
- if test "z$mode" != "z--no-checkout"
- then
- git checkout "$start_head" -- ||
- die "$(eval_gettext "Checking out '\$start_head' failed. Try 'git bisect reset <valid-branch>'.")"
- fi
- else
- # Get rev from where we start.
- case "$head" in
- refs/heads/*|$_x40)
- # This error message should only be triggered by
- # cogito usage, and cogito users should understand
- # it relates to cg-seek.
- [ -s "$GIT_DIR/head-name" ] &&
- die "$(gettext "won't bisect on cg-seek'ed tree")"
- start_head="${head#refs/heads/}"
- ;;
- *)
- die "$(gettext "Bad HEAD - strange symbolic ref")"
- ;;
- esac
- fi
-
- #
- # Get rid of any old bisect state.
- #
- git bisect--helper --bisect-clean-state || exit
+ git bisect--helper --bisect-start $@ || exit
#
# Change state.
@@ -197,24 +82,10 @@ bisect_start() {
#
trap 'git bisect--helper --bisect-clean-state' 0
trap 'exit 255' 1 2 3 15
-
- #
- # Write new start state.
- #
- echo "$start_head" >"$GIT_DIR/BISECT_START" && {
- test "z$mode" != "z--no-checkout" ||
- git update-ref --no-deref BISECT_HEAD "$start_head"
- } &&
- git rev-parse --sq-quote "$@" >"$GIT_DIR/BISECT_NAMES" &&
- eval "$eval true" &&
- if test $must_write_terms -eq 1
- then
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD"
- fi &&
- echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
#
# Check if we can proceed to the next bisect state.
#
+ get_terms
bisect_auto_next
trap '-' 0
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 14/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function in C
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (4 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 27/27] bisect--helper: remove the dequote in bisect_start() Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-25 20:30 ` Junio C Hamano
2016-08-23 11:53 ` [PATCH v14 10/27] bisect--helper: `check_and_set_terms` " Pranit Bauva
` (22 subsequent siblings)
28 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
Reimplement the `bisect_next` and the `bisect_auto_next` shell function
in C and add the subcommands to `git bisect--helper` to call it from
git-bisect.sh .
Along with this conversion of `bisect_start` has also finished and thus
it has been fully ported to C.
A lot of parts of bisect.c uses exit() and these signals are then
trapped in the `bisect_start` function. Since the shell script ceases
its existence it would be necessary to convert those exit() calls to
return statements so that errors can be reported efficiently in C code.
As more and more calls are happening to the subcommands in `git
bisect--helper`, more specifically when `bisect_start $rev` is converted to
`git bisect--helper --bisect-start $rev` it is necessary to dequote the
arguments because of shell to C conversion.
Using `--bisect-next` and `--bisect-auto-start` subcommands is a
temporary measure to port shell function to C so as to use the existing
test suite. As more functions are ported, this subcommand will be
retired and will be called by some other methods.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
bisect.c | 80 ++++++++++++------
builtin/bisect--helper.c | 206 ++++++++++++++++++++++++++++++++++++++++++-----
git-bisect.sh | 74 ++---------------
3 files changed, 249 insertions(+), 111 deletions(-)
diff --git a/bisect.c b/bisect.c
index 45d598d..68c583b 100644
--- a/bisect.c
+++ b/bisect.c
@@ -618,6 +618,12 @@ static void bisect_rev_setup(struct rev_info *revs, const char *prefix,
struct argv_array rev_argv = ARGV_ARRAY_INIT;
int i;
+ /*
+ * Since the code is slowly being converted to C, there might be
+ * instances where the revisions were initialized before. Thus
+ * we first need to reset it.
+ */
+ reset_revision_walk();
init_revisions(revs, prefix);
revs->abbrev = 0;
revs->commit_format = CMIT_FMT_UNSPECIFIED;
@@ -644,11 +650,11 @@ static void bisect_common(struct rev_info *revs)
mark_edges_uninteresting(revs, NULL);
}
-static void exit_if_skipped_commits(struct commit_list *tried,
+static int exit_if_skipped_commits(struct commit_list *tried,
const struct object_id *bad)
{
if (!tried)
- return;
+ return 0;
printf("There are only 'skip'ped commits left to test.\n"
"The first %s commit could be any of:\n", term_bad);
@@ -659,7 +665,7 @@ static void exit_if_skipped_commits(struct commit_list *tried,
if (bad)
printf("%s\n", oid_to_hex(bad));
printf(_("We cannot bisect more!\n"));
- exit(2);
+ return 2;
}
static int is_expected_rev(const struct object_id *oid)
@@ -700,7 +706,7 @@ static int bisect_checkout(const unsigned char *bisect_rev, int no_checkout)
int res;
res = run_command_v_opt(argv_checkout, RUN_GIT_CMD);
if (res)
- exit(res);
+ return res;
}
argv_show_branch[1] = bisect_rev_hex;
@@ -729,7 +735,7 @@ static struct commit **get_bad_and_good_commits(int *rev_nr)
return rev;
}
-static void handle_bad_merge_base(void)
+static int handle_bad_merge_base(void)
{
if (is_expected_rev(current_bad_oid)) {
char *bad_hex = oid_to_hex(current_bad_oid);
@@ -750,17 +756,18 @@ static void handle_bad_merge_base(void)
"between %s and [%s].\n"),
bad_hex, term_bad, term_good, bad_hex, good_hex);
}
- exit(3);
+ return 3;
}
fprintf(stderr, _("Some %s revs are not ancestor of the %s rev.\n"
"git bisect cannot work properly in this case.\n"
"Maybe you mistook %s and %s revs?\n"),
term_good, term_bad, term_good, term_bad);
- exit(1);
+ bisect_clean_state();
+ return 1;
}
-static void handle_skipped_merge_base(const unsigned char *mb)
+static int handle_skipped_merge_base(const unsigned char *mb)
{
char *mb_hex = sha1_to_hex(mb);
char *bad_hex = oid_to_hex(current_bad_oid);
@@ -773,6 +780,7 @@ static void handle_skipped_merge_base(const unsigned char *mb)
"We continue anyway."),
bad_hex, good_hex, term_bad, mb_hex, bad_hex);
free(good_hex);
+ return 0;
}
/*
@@ -784,10 +792,10 @@ static void handle_skipped_merge_base(const unsigned char *mb)
* - If one is "skipped", we can't know but we should warn.
* - If we don't know, we should check it out and ask the user to test.
*/
-static void check_merge_bases(int no_checkout)
+static int check_merge_bases(int no_checkout)
{
struct commit_list *result;
- int rev_nr;
+ int rev_nr, res = 0;
struct commit **rev = get_bad_and_good_commits(&rev_nr);
result = get_merge_bases_many(rev[0], rev_nr - 1, rev + 1);
@@ -795,19 +803,25 @@ static void check_merge_bases(int no_checkout)
for (; result; result = result->next) {
const unsigned char *mb = result->item->object.oid.hash;
if (!hashcmp(mb, current_bad_oid->hash)) {
- handle_bad_merge_base();
+ res = handle_bad_merge_base();
+ break;
} else if (0 <= sha1_array_lookup(&good_revs, mb)) {
continue;
} else if (0 <= sha1_array_lookup(&skipped_revs, mb)) {
- handle_skipped_merge_base(mb);
+ res = handle_skipped_merge_base(mb);
+ break;
} else {
printf(_("Bisecting: a merge base must be tested\n"));
- exit(bisect_checkout(mb, no_checkout));
+ res = bisect_checkout(mb, no_checkout);
+ if (!res)
+ exit(0);
+ break;
}
}
free(rev);
free_commit_list(result);
+ return res;
}
static int check_ancestors(const char *prefix)
@@ -845,11 +859,11 @@ static int check_ancestors(const char *prefix)
* If a merge base must be tested by the user, its source code will be
* checked out to be tested by the user and we will exit.
*/
-static void check_good_are_ancestors_of_bad(const char *prefix, int no_checkout)
+static int check_good_are_ancestors_of_bad(const char *prefix, int no_checkout)
{
char *filename = git_pathdup("BISECT_ANCESTORS_OK");
struct stat st;
- int fd;
+ int fd, res = 0;
if (!current_bad_oid)
die(_("a %s revision is needed"), term_bad);
@@ -864,7 +878,10 @@ static void check_good_are_ancestors_of_bad(const char *prefix, int no_checkout)
/* Check if all good revs are ancestor of the bad rev. */
if (check_ancestors(prefix))
- check_merge_bases(no_checkout);
+ res = check_merge_bases(no_checkout);
+
+ if (res)
+ return res;
/* Create file BISECT_ANCESTORS_OK. */
fd = open(filename, O_CREAT | O_TRUNC | O_WRONLY, 0600);
@@ -873,8 +890,11 @@ static void check_good_are_ancestors_of_bad(const char *prefix, int no_checkout)
filename);
else
close(fd);
+
+ return 0;
done:
free(filename);
+ return 0;
}
/*
@@ -944,7 +964,7 @@ int bisect_next_all(const char *prefix, int no_checkout)
{
struct rev_info revs;
struct commit_list *tried;
- int reaches = 0, all = 0, nr, steps;
+ int reaches = 0, all = 0, nr, steps, res;
const unsigned char *bisect_rev;
char steps_msg[32];
@@ -952,7 +972,9 @@ int bisect_next_all(const char *prefix, int no_checkout)
if (read_bisect_refs())
die(_("reading bisect refs failed"));
- check_good_are_ancestors_of_bad(prefix, no_checkout);
+ res = check_good_are_ancestors_of_bad(prefix, no_checkout);
+ if (res)
+ return res;
bisect_rev_setup(&revs, prefix, "%s", "^%s", 1);
revs.limited = 1;
@@ -964,34 +986,40 @@ int bisect_next_all(const char *prefix, int no_checkout)
revs.commits = managed_skipped(revs.commits, &tried);
if (!revs.commits) {
+ int res;
/*
* We should exit here only if the "bad"
* commit is also a "skip" commit.
*/
- exit_if_skipped_commits(tried, NULL);
+ res = exit_if_skipped_commits(tried, NULL);
+ if (res)
+ return res;
printf(_("%s was both %s and %s\n"),
oid_to_hex(current_bad_oid),
term_good,
term_bad);
- exit(1);
+ return 1;
}
if (!all) {
fprintf(stderr, _("No testable commit found.\n"
"Maybe you started with bad path parameters?\n"));
- exit(4);
+ return 4;
}
bisect_rev = revs.commits->item->object.oid.hash;
if (!hashcmp(bisect_rev, current_bad_oid->hash)) {
- exit_if_skipped_commits(tried, current_bad_oid);
+ res = exit_if_skipped_commits(tried, current_bad_oid);
+ if (res)
+ return res;
+
printf("%s is the first %s commit\n", sha1_to_hex(bisect_rev),
term_bad);
show_diff_tree(prefix, revs.commits->item);
/* This means the bisection process succeeded. */
- exit(10);
+ return 10;
}
nr = all - reaches - 1;
@@ -1005,7 +1033,11 @@ int bisect_next_all(const char *prefix, int no_checkout)
"Bisecting: %d revisions left to test after this %s\n",
nr), nr, steps_msg);
- return bisect_checkout(bisect_rev, no_checkout);
+ res = bisect_checkout(bisect_rev, no_checkout);
+ if (res)
+ bisect_clean_state();
+
+ return res;
}
static inline int log2i(int n)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index c64996a..ef7b3a1 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -8,6 +8,7 @@
#include "run-command.h"
#include "prompt.h"
#include "quote.h"
+#include "revision.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
@@ -29,6 +30,8 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
N_("git bisect--helper --bisect start [--term-{old,good}=<term> --term-{new,bad}=<term>]"
"[--no-checkout] [<bad> [<good>...]] [--] [<paths>...]"),
+ N_("git bisect--helper --bisect-next"),
+ N_("git bisect--helper --bisect-auto-next"),
NULL
};
@@ -396,6 +399,129 @@ static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
return 0;
}
+static int register_good_ref(const char *refname,
+ const struct object_id *oid, int flags,
+ void *cb_data)
+{
+ struct string_list *good_refs = cb_data;
+ string_list_append(good_refs, oid_to_hex(oid));
+ return 0;
+}
+
+static int bisect_next(struct bisect_terms *terms, const char *prefix)
+{
+ int res, no_checkout;
+
+ /* 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".
+ */
+ if (bisect_next_check(terms, terms->term_good.buf))
+ return -1;
+
+ no_checkout = !is_empty_or_missing_file(git_path_bisect_head());
+
+ /* Perform all bisection computation, display and checkout */
+ res = bisect_next_all(prefix , no_checkout);
+
+ if (res == 10) {
+ FILE *fp;
+ unsigned char sha1[20];
+ struct commit *commit;
+ struct pretty_print_context pp = {0};
+ struct strbuf commit_name = STRBUF_INIT;
+ char *bad_ref = xstrfmt("refs/bisect/%s",
+ terms->term_bad.buf);
+ read_ref(bad_ref, sha1);
+ commit = lookup_commit_reference(sha1);
+ format_commit_message(commit, "%s", &commit_name, &pp);
+ fp = fopen(git_path_bisect_log(), "a");
+ if (!fp) {
+ free(bad_ref);
+ strbuf_release(&commit_name);
+ return -1;
+ }
+ if (fprintf(fp, "# first %s commit: [%s] %s\n",
+ terms->term_bad.buf, sha1_to_hex(sha1),
+ commit_name.buf) < 1){
+ free(bad_ref);
+ strbuf_release(&commit_name);
+ fclose(fp);
+ return -1;
+ }
+ free(bad_ref);
+ strbuf_release(&commit_name);
+ fclose(fp);
+ return 0;
+ }
+ else if (res == 2) {
+ FILE *fp;
+ struct rev_info revs;
+ struct argv_array rev_argv = ARGV_ARRAY_INIT;
+ struct string_list good_revs = STRING_LIST_INIT_DUP;
+ struct pretty_print_context pp = {0};
+ struct commit *commit;
+ char *term_good = xstrfmt("%s-*", terms->term_good.buf);
+ int i;
+
+ fp = fopen(git_path_bisect_log(), "a");
+ if (!fp) {
+ free(term_good);
+ return -1;
+ }
+ if (fprintf(fp, "# only skipped commits left to test\n") < 1) {
+ free(term_good);
+ fclose(fp);
+ return -1;
+ }
+ for_each_glob_ref_in(register_good_ref, term_good,
+ "refs/bisect/", (void *) &good_revs);
+
+ free(term_good);
+ argv_array_pushl(&rev_argv, "skipped_commits", "refs/bisect/bad", "--not", NULL);
+ for (i = 0; i < good_revs.nr; i++)
+ argv_array_push(&rev_argv, good_revs.items[i].string);
+
+ /* It is important to reset the flags used by revision walks
+ * as the previous call to bisect_next_all() in turn
+ * setups a revision walk.
+ */
+ reset_revision_walk();
+ init_revisions(&revs, NULL);
+ rev_argv.argc = setup_revisions(rev_argv.argc, rev_argv.argv, &revs, NULL);
+ argv_array_clear(&rev_argv);
+ string_list_clear(&good_revs, 0);
+ if (prepare_revision_walk(&revs)) {
+ die(_("revision walk setup failed\n"));
+ }
+
+ while ((commit = get_revision(&revs)) != NULL) {
+ struct strbuf commit_name = STRBUF_INIT;
+ format_commit_message(commit, "%s",
+ &commit_name, &pp);
+ fprintf(fp, "# possible first %s commit: "
+ "[%s] %s\n", terms->term_bad.buf,
+ oid_to_hex(&commit->object.oid),
+ commit_name.buf);
+ strbuf_release(&commit_name);
+ }
+
+ fclose(fp);
+ return res;
+ }
+
+ return res;
+}
+
+static int bisect_auto_next(struct bisect_terms *terms, const char *prefix)
+{
+ if (!bisect_next_check(terms, NULL))
+ return bisect_next(terms, prefix);
+
+ return 0;
+}
+
static int bisect_start(struct bisect_terms *terms, int no_checkout,
const char **argv, int argc)
{
@@ -415,47 +541,67 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
no_checkout = 1;
for (i = 0; i < argc; i++) {
- if (!strcmp(argv[i], "--")) {
+ const char *arg;
+ if (starts_with(argv[i], "'"))
+ arg = sq_dequote(xstrdup(argv[i]));
+ else
+ arg = argv[i];
+ if (!strcmp(arg, "--")) {
has_double_dash = 1;
break;
}
}
for (i = 0; i < argc; i++) {
- const char *commit_id = xstrfmt("%s^{commit}", argv[i]);
+ const char *arg, *commit_id;
+ if (starts_with(argv[i], "'"))
+ arg = sq_dequote(xstrdup(argv[i]));
+ else
+ arg = argv[i];
+ commit_id = xstrfmt("%s^{commit}", arg);
if (!strcmp(argv[i], "--")) {
has_double_dash = 1;
break;
- } else if (!strcmp(argv[i], "--no-checkout"))
+ } else if (!strcmp(arg, "--no-checkout"))
no_checkout = 1;
- else if (!strcmp(argv[i], "--term-good") ||
- !strcmp(argv[i], "--term-old")) {
+ else if (!strcmp(arg, "--term-good") ||
+ !strcmp(arg, "--term-old")) {
+ const char *next_arg;
+ if (starts_with(argv[++i], "'"))
+ next_arg = sq_dequote(xstrdup(argv[i]));
+ else
+ next_arg = argv[i];
must_write_terms = 1;
strbuf_reset(&terms->term_good);
- strbuf_addstr(&terms->term_good, argv[++i]);
- } else if (skip_prefix(argv[i], "--term-good=", &argv[i])) {
+ strbuf_addstr(&terms->term_good, next_arg);
+ } else if (skip_prefix(arg, "--term-good=", &arg)) {
must_write_terms = 1;
strbuf_reset(&terms->term_good);
- strbuf_addstr(&terms->term_good, argv[i]);
- } else if (skip_prefix(argv[i], "--term-old=", &argv[i])) {
+ strbuf_addstr(&terms->term_good, arg);
+ } else if (skip_prefix(arg, "--term-old=", &arg)) {
must_write_terms = 1;
strbuf_reset(&terms->term_good);
- strbuf_addstr(&terms->term_good, argv[i]);
- } else if (!strcmp(argv[i], "--term-bad") ||
- !strcmp(argv[i], "--term-new")) {
+ strbuf_addstr(&terms->term_good, arg);
+ } else if (!strcmp(arg, "--term-bad") ||
+ !strcmp(arg, "--term-new")) {
+ const char *next_arg;
+ if (starts_with(argv[++i], "'"))
+ next_arg = sq_dequote(xstrdup(argv[i]));
+ else
+ next_arg = argv[i];
must_write_terms = 1;
strbuf_reset(&terms->term_bad);
- strbuf_addstr(&terms->term_bad, argv[++i]);
- } else if (skip_prefix(argv[i], "--term-bad=", &argv[i])) {
+ strbuf_addstr(&terms->term_bad, next_arg);
+ } else if (skip_prefix(arg, "--term-bad=", &arg)) {
must_write_terms = 1;
strbuf_reset(&terms->term_bad);
- strbuf_addstr(&terms->term_bad, argv[i]);
- } else if (skip_prefix(argv[i], "--term-new=", &argv[i])) {
+ strbuf_addstr(&terms->term_bad, arg);
+ } else if (skip_prefix(arg, "--term-new=", &arg)) {
must_write_terms = 1;
strbuf_reset(&terms->term_good);
- strbuf_addstr(&terms->term_good, argv[i]);
- } else if (starts_with(argv[i], "--") &&
- !one_of(argv[i], "--term-good", "--term-bad", NULL)) {
+ strbuf_addstr(&terms->term_good, arg);
+ } else if (starts_with(arg, "--") &&
+ !one_of(arg, "--term-good", "--term-bad", NULL)) {
string_list_clear(&revs, 0);
string_list_clear(&states, 0);
die(_("unrecognised option: '%s'"), argv[i]);
@@ -613,7 +759,7 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
}
fclose(fp);
- return 0;
+ return bisect_auto_next(terms, NULL);
}
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
@@ -628,7 +774,9 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
CHECK_AND_SET_TERMS,
BISECT_NEXT_CHECK,
BISECT_TERMS,
- BISECT_START
+ BISECT_START,
+ BISECT_NEXT,
+ BISECT_AUTO_NEXT,
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -652,6 +800,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("print out the bisect terms"), BISECT_TERMS),
OPT_CMDMODE(0, "bisect-start", &cmdmode,
N_("start the bisect session"), BISECT_START),
+ OPT_CMDMODE(0, "bisect-next", &cmdmode,
+ N_("find the next bisection commit"), BISECT_NEXT),
+ OPT_CMDMODE(0, "bisect-auto-next", &cmdmode,
+ N_("verify the next bisection state then find the next bisection state"), BISECT_AUTO_NEXT),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -720,6 +872,18 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
strbuf_addstr(&terms.term_bad, "bad");
res = bisect_start(&terms, no_checkout, argv, argc);
break;
+ case BISECT_NEXT:
+ if (argc)
+ die(_("--bisect-next requires 0 arguments"));
+ get_terms(&terms);
+ res = bisect_next(&terms, prefix);
+ break;
+ case BISECT_AUTO_NEXT:
+ if (argc)
+ die(_("--bisect-auto-next requires 0 arguments"));
+ get_terms(&terms);
+ res = bisect_auto_next(&terms, prefix);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index f0896b3..d574c44 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -63,34 +63,13 @@ bisect_autostart() {
[Nn]*)
exit ;;
esac
- bisect_start
+ git bisect--helper --bisect-start
else
exit 1
fi
}
}
-bisect_start() {
- git bisect--helper --bisect-start $@ || exit
-
- #
- # Change state.
- # 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".
- #
- trap 'git bisect--helper --bisect-clean-state' 0
- trap 'exit 255' 1 2 3 15
- #
- # Check if we can proceed to the next bisect state.
- #
- get_terms
- bisect_auto_next
-
- trap '-' 0
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -109,6 +88,7 @@ bisect_skip() {
bisect_state() {
bisect_autostart
state=$1
+ get_terms
git bisect--helper --check-and-set-terms $state $TERM_GOOD $TERM_BAD || exit
get_terms
case "$#,$state" in
@@ -139,45 +119,7 @@ bisect_state() {
*)
usage ;;
esac
- bisect_auto_next
-}
-
-bisect_auto_next() {
- git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD && bisect_next || :
-}
-
-bisect_next() {
- case "$#" in 0) ;; *) usage ;; esac
- bisect_autostart
- git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD $TERM_GOOD|| exit
-
- # Perform all bisection computation, display and checkout
- git bisect--helper --next-all $(test -f "$GIT_DIR/BISECT_HEAD" && echo --no-checkout)
- res=$?
-
- # Check if we should exit because bisection is finished
- if test $res -eq 10
- then
- bad_rev=$(git show-ref --hash --verify refs/bisect/$TERM_BAD)
- bad_commit=$(git show-branch $bad_rev)
- echo "# first $TERM_BAD commit: $bad_commit" >>"$GIT_DIR/BISECT_LOG"
- exit 0
- elif test $res -eq 2
- then
- echo "# only skipped commits left to test" >>"$GIT_DIR/BISECT_LOG"
- good_revs=$(git for-each-ref --format="%(objectname)" "refs/bisect/$TERM_GOOD-*")
- for skipped in $(git rev-list refs/bisect/$TERM_BAD --not $good_revs)
- do
- skipped_commit=$(git show-branch $skipped)
- echo "# possible first $TERM_BAD commit: $skipped_commit" >>"$GIT_DIR/BISECT_LOG"
- done
- exit $res
- fi
-
- # Check for an error in the bisection process
- test $res -ne 0 && exit $res
-
- return 0
+ git bisect--helper --bisect-auto-next || exit
}
bisect_visualize() {
@@ -221,8 +163,7 @@ bisect_replay () {
get_terms
case "$command" in
start)
- cmd="bisect_start $rev"
- eval "$cmd" ;;
+ eval "git bisect--helper --bisect-start $rev" ;;
"$TERM_GOOD"|"$TERM_BAD"|skip)
git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
terms)
@@ -231,7 +172,7 @@ bisect_replay () {
die "$(gettext "?? what are you talking about?")" ;;
esac
done <"$file"
- bisect_auto_next
+ git bisect--helper --bisect-auto-next
}
bisect_run () {
@@ -319,14 +260,15 @@ case "$#" in
help)
git bisect -h ;;
start)
- bisect_start "$@" ;;
+ git bisect--helper --bisect-start "$@" ;;
bad|good|new|old|"$TERM_BAD"|"$TERM_GOOD")
bisect_state "$cmd" "$@" ;;
skip)
bisect_skip "$@" ;;
next)
# Not sure we want "next" at the UI level anymore.
- bisect_next "$@" ;;
+ get_terms
+ git bisect--helper --bisect-next "$@" || exit ;;
visualize|view)
bisect_visualize "$@" ;;
reset)
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 16/27] bisect--helper: retire `--next-all` subcommand
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (8 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 12/27] bisect--helper: `get_terms` & `bisect_terms` shell function in C Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 13/27] bisect--helper: `bisect_start` shell function partially in C Pranit Bauva
` (18 subsequent siblings)
28 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
The `--next-all` subcommand is no longer used in the shell script and
the function `bisect_next_all()` is called from the C implementation of
`bisect_next()`.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 8 +-------
1 file changed, 1 insertion(+), 7 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index e351794..8cbcc3b 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -20,7 +20,6 @@ static GIT_PATH_FUNC(git_path_head_name, "head-name")
static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static const char * const git_bisect_helper_usage[] = {
- N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
@@ -764,8 +763,7 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
- NEXT_ALL = 1,
- WRITE_TERMS,
+ WRITE_TERMS = 1,
BISECT_RESET,
CHECK_EXPECTED_REVS,
BISECT_WRITE,
@@ -778,8 +776,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
- OPT_CMDMODE(0, "next-all", &cmdmode,
- N_("perform 'git bisect next'"), NEXT_ALL),
OPT_CMDMODE(0, "write-terms", &cmdmode,
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
@@ -816,8 +812,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
switch (cmdmode) {
int nolog;
- case NEXT_ALL:
- return bisect_next_all(prefix, no_checkout);
case WRITE_TERMS:
if (argc != 2)
die(_("--write-terms requires two arguments"));
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 06/27] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file()
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (22 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 03/27] bisect--helper: `write_terms` " Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 19/27] bisect--helper: retire `--check-expected-revs` subcommand Pranit Bauva
` (4 subsequent siblings)
28 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
is_empty_file() can help to refactor a lot of code. This will be very
helpful in porting "git bisect" to C.
Suggested-by: Torsten Bögershausen <tboegi@web.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/am.c | 20 ++------------------
cache.h | 3 +++
wrapper.c | 13 +++++++++++++
3 files changed, 18 insertions(+), 18 deletions(-)
diff --git a/builtin/am.c b/builtin/am.c
index 739b34d..9e1e9d6 100644
--- a/builtin/am.c
+++ b/builtin/am.c
@@ -30,22 +30,6 @@
#include "mailinfo.h"
/**
- * Returns 1 if the file is empty or does not exist, 0 otherwise.
- */
-static int is_empty_file(const char *filename)
-{
- struct stat st;
-
- if (stat(filename, &st) < 0) {
- if (errno == ENOENT)
- return 1;
- die_errno(_("could not stat %s"), filename);
- }
-
- return !st.st_size;
-}
-
-/**
* Returns the length of the first line of msg.
*/
static int linelen(const char *msg)
@@ -1324,7 +1308,7 @@ static int parse_mail(struct am_state *state, const char *mail)
goto finish;
}
- if (is_empty_file(am_path(state, "patch"))) {
+ if (is_empty_or_missing_file(am_path(state, "patch"))) {
printf_ln(_("Patch is empty. Was it split wrong?"));
die_user_resolve(state);
}
@@ -1896,7 +1880,7 @@ static void am_run(struct am_state *state, int resume)
resume = 0;
}
- if (!is_empty_file(am_path(state, "rewritten"))) {
+ if (!is_empty_or_missing_file(am_path(state, "rewritten"))) {
assert(state->rebasing);
copy_notes_for_rebase(state);
run_post_rewrite_hook(state);
diff --git a/cache.h b/cache.h
index b780a91..49f214b 100644
--- a/cache.h
+++ b/cache.h
@@ -1916,4 +1916,7 @@ void sleep_millisec(int millisec);
*/
void safe_create_dir(const char *dir, int share);
+/* Return 1 if the file is empty or does not exists, 0 otherwise. */
+extern int is_empty_or_missing_file(const char *filename);
+
#endif /* CACHE_H */
diff --git a/wrapper.c b/wrapper.c
index e7f1979..78f6431 100644
--- a/wrapper.c
+++ b/wrapper.c
@@ -679,3 +679,16 @@ void sleep_millisec(int millisec)
{
poll(NULL, 0, millisec);
}
+
+int is_empty_or_missing_file(const char *filename)
+{
+ struct stat st;
+
+ if (stat(filename, &st) < 0) {
+ if (errno == ENOENT)
+ return 1;
+ die_errno(_("could not stat %s"), filename);
+ }
+
+ return !st.st_size;
+}
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 27/27] bisect--helper: remove the dequote in bisect_start()
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (3 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 20/27] bisect--helper: retire `--write-terms` subcommand Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 14/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function in C Pranit Bauva
` (23 subsequent siblings)
28 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
Dequoting the arguments was introduced in 25b48b5c to port the function
`bisect_next()` but after the `bisect_replay()` porting, the dequoting
is carried out itself when it passes the arguments to `bisect_start()`
in a simpler way thus dequoting again isn't required. So remove the
extra "deqouting" code introduced by the commit 25b48b5c.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 59 ++++++++++++++++--------------------------------
1 file changed, 20 insertions(+), 39 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 7577b69e..8bf495c 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -541,67 +541,48 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
no_checkout = 1;
for (i = 0; i < argc; i++) {
- const char *arg;
- if (starts_with(argv[i], "'"))
- arg = sq_dequote(xstrdup(argv[i]));
- else
- arg = argv[i];
- if (!strcmp(arg, "--")) {
+ if (!strcmp(argv[i], "--")) {
has_double_dash = 1;
break;
}
}
for (i = 0; i < argc; i++) {
- const char *arg, *commit_id;
- if (starts_with(argv[i], "'"))
- arg = sq_dequote(xstrdup(argv[i]));
- else
- arg = argv[i];
- commit_id = xstrfmt("%s^{commit}", arg);
+ const char *commit_id;
+ commit_id = xstrfmt("%s^{commit}", argv[i]);
if (!strcmp(argv[i], "--")) {
has_double_dash = 1;
break;
- } else if (!strcmp(arg, "--no-checkout"))
+ } else if (!strcmp(argv[i], "--no-checkout"))
no_checkout = 1;
- else if (!strcmp(arg, "--term-good") ||
- !strcmp(arg, "--term-old")) {
- const char *next_arg;
- if (starts_with(argv[++i], "'"))
- next_arg = sq_dequote(xstrdup(argv[i]));
- else
- next_arg = argv[i];
+ else if (!strcmp(argv[i], "--term-good") ||
+ !strcmp(argv[i], "--term-old")) {
must_write_terms = 1;
strbuf_reset(&terms->term_good);
- strbuf_addstr(&terms->term_good, next_arg);
- } else if (skip_prefix(arg, "--term-good=", &arg)) {
+ strbuf_addstr(&terms->term_good, argv[++i]);
+ } else if (skip_prefix(argv[i], "--term-good=", &argv[i])) {
must_write_terms = 1;
strbuf_reset(&terms->term_good);
- strbuf_addstr(&terms->term_good, arg);
- } else if (skip_prefix(arg, "--term-old=", &arg)) {
+ strbuf_addstr(&terms->term_good, argv[i]);
+ } else if (skip_prefix(argv[i], "--term-old=", &argv[i])) {
must_write_terms = 1;
strbuf_reset(&terms->term_good);
- strbuf_addstr(&terms->term_good, arg);
- } else if (!strcmp(arg, "--term-bad") ||
- !strcmp(arg, "--term-new")) {
- const char *next_arg;
- if (starts_with(argv[++i], "'"))
- next_arg = sq_dequote(xstrdup(argv[i]));
- else
- next_arg = argv[i];
+ strbuf_addstr(&terms->term_good, argv[i]);
+ } else if (!strcmp(argv[i], "--term-bad") ||
+ !strcmp(argv[i], "--term-new")) {
must_write_terms = 1;
strbuf_reset(&terms->term_bad);
- strbuf_addstr(&terms->term_bad, next_arg);
- } else if (skip_prefix(arg, "--term-bad=", &arg)) {
+ strbuf_addstr(&terms->term_bad, argv[++i]);
+ } else if (skip_prefix(argv[i], "--term-bad=", &argv[i])) {
must_write_terms = 1;
strbuf_reset(&terms->term_bad);
- strbuf_addstr(&terms->term_bad, arg);
- } else if (skip_prefix(arg, "--term-new=", &arg)) {
+ strbuf_addstr(&terms->term_bad, argv[i]);
+ } else if (skip_prefix(argv[i], "--term-new=", &argv[i])) {
must_write_terms = 1;
strbuf_reset(&terms->term_good);
- strbuf_addstr(&terms->term_good, arg);
- } else if (starts_with(arg, "--") &&
- !one_of(arg, "--term-good", "--term-bad", NULL)) {
+ strbuf_addstr(&terms->term_good, argv[i]);
+ } else if (starts_with(argv[i], "--") &&
+ !one_of(argv[i], "--term-good", "--term-bad", NULL)) {
string_list_clear(&revs, 0);
string_list_clear(&states, 0);
die(_("unrecognised option: '%s'"), argv[i]);
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 05/27] t6030: explicitly test for bisection cleanup
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (11 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 26/27] bisect--helper: retire `--bisect-auto-next` subcommand Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 11/27] bisect--helper: `bisect_next_check` & bisect_voc shell function in C Pranit Bauva
` (15 subsequent siblings)
28 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
Add test to explicitly check that 'git bisect reset' is working as
expected. This is already covered implicitly by the test suite.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
I faced this problem while converting `bisect_clean_state` and the tests
where showing breakages but it wasn't clear as to where exactly are they
breaking. This will patch will help in that. Also I tested the test
coverage of the test suite before this patch and it covers this (I did
this by purposely changing names of files in git-bisect.sh and running
the test suite).
---
t/t6030-bisect-porcelain.sh | 17 +++++++++++++++++
1 file changed, 17 insertions(+)
diff --git a/t/t6030-bisect-porcelain.sh b/t/t6030-bisect-porcelain.sh
index 5e5370f..18e7998 100755
--- a/t/t6030-bisect-porcelain.sh
+++ b/t/t6030-bisect-porcelain.sh
@@ -894,4 +894,21 @@ test_expect_success 'bisect start takes options and revs in any order' '
test_cmp expected actual
'
+test_expect_success 'git bisect reset cleans bisection state properly' '
+ git bisect reset &&
+ git bisect start &&
+ git bisect good $HASH1 &&
+ git bisect bad $HASH4 &&
+ git bisect reset &&
+ test -z "$(git for-each-ref "refs/bisect/*")" &&
+ test_path_is_missing "$GIT_DIR/BISECT_EXPECTED_REV" &&
+ test_path_is_missing "$GIT_DIR/BISECT_ANCESTORS_OK" &&
+ test_path_is_missing "$GIT_DIR/BISECT_LOG" &&
+ test_path_is_missing "$GIT_DIR/BISECT_RUN" &&
+ test_path_is_missing "$GIT_DIR/BISECT_TERMS" &&
+ test_path_is_missing "$GIT_DIR/head-name" &&
+ test_path_is_missing "$GIT_DIR/BISECT_HEAD" &&
+ test_path_is_missing "$GIT_DIR/BISECT_START"
+'
+
test_done
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 19/27] bisect--helper: retire `--check-expected-revs` subcommand
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (23 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 06/27] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 04/27] bisect--helper: `bisect_clean_state` shell function in C Pranit Bauva
` (3 subsequent siblings)
28 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
The `--check-expected-revs` subcommand is no longer used in the shell
script and the function `check_expected_revs()` is called from the C
implementation of `bisect_next()`.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 6 ------
1 file changed, 6 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 861c07d..6cc990b 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -870,7 +870,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
enum {
WRITE_TERMS = 1,
BISECT_RESET,
- CHECK_EXPECTED_REVS,
BISECT_WRITE,
CHECK_AND_SET_TERMS,
BISECT_NEXT_CHECK,
@@ -887,8 +886,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
N_("reset the bisection state"), BISECT_RESET),
- OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
- N_("check for expected revs"), CHECK_EXPECTED_REVS),
OPT_CMDMODE(0, "bisect-write", &cmdmode,
N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
@@ -933,9 +930,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
die(_("--bisect-reset requires either zero or one arguments"));
res = bisect_reset(argc ? argv[0] : NULL);
break;
- case CHECK_EXPECTED_REVS:
- res = check_expected_revs(argv, argc);
- break;
case BISECT_WRITE:
if (argc != 4 && argc != 5)
die(_("--bisect-write requires either 4 or 5 arguments"));
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2016-08-19 20:32 ` [PATCH v13 " Pranit Bauva
` (12 preceding siblings ...)
2016-08-21 11:14 ` [PATCH v13 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 09/27] bisect--helper: `bisect_write` shell function in C Pranit Bauva
` (28 more replies)
13 siblings, 29 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
`--next-all` is meant to be used as a subcommand to support multiple
"operation mode" though the current implementation does not contain any
other subcommand along side with `--next-all` but further commits will
include some more subcommands.
Helped-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 17 +++++++++++------
1 file changed, 11 insertions(+), 6 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 3324229..8111c91 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -10,11 +10,11 @@ static const char * const git_bisect_helper_usage[] = {
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
- int next_all = 0;
+ enum { NEXT_ALL = 1 } cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
- OPT_BOOL(0, "next-all", &next_all,
- N_("perform 'git bisect next'")),
+ OPT_CMDMODE(0, "next-all", &cmdmode,
+ N_("perform 'git bisect next'"), NEXT_ALL),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -23,9 +23,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
argc = parse_options(argc, argv, prefix, options,
git_bisect_helper_usage, 0);
- if (!next_all)
+ if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
- /* next-all */
- return bisect_next_all(prefix, no_checkout);
+ switch (cmdmode) {
+ case NEXT_ALL:
+ return bisect_next_all(prefix, no_checkout);
+ default:
+ die("BUG: unknown subcommand '%d'", cmdmode);
+ }
+ return 0;
}
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 07/27] bisect--helper: `bisect_reset` shell function in C
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (14 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 25/27] bisect--helper: retire `--bisect-autostart` subcommand Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-24 21:12 ` Junio C Hamano
2016-08-23 11:53 ` [PATCH v14 18/27] bisect--helper: `bisect_state` & `bisect_head` " Pranit Bauva
` (12 subsequent siblings)
28 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
Reimplement `bisect_reset` shell function in C and add a `--bisect-reset`
subcommand to `git bisect--helper` to call it from git-bisect.sh .
Using `bisect_reset` subcommand is a temporary measure to port shell
functions to C so as to use the existing test suite. As more functions
are ported, this subcommand would be retired but its implementation will
be called by some other method.
Note: --bisect-clean-state subcommand has not been retired as there are
still a function namely `bisect_start()` which still uses this
subcommand.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 48 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 28 ++--------------------------
2 files changed, 49 insertions(+), 27 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index e50934c..9aba094 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -3,17 +3,22 @@
#include "parse-options.h"
#include "bisect.h"
#include "refs.h"
+#include "dir.h"
+#include "argv-array.h"
+#include "run-command.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
+static GIT_PATH_FUNC(git_path_bisect_head, "BISECT_HEAD")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-clean-state"),
+ N_("git bisect--helper --bisect-reset [<commit>]"),
NULL
};
@@ -84,12 +89,47 @@ static int write_terms(const char *bad, const char *good)
return (res < 0) ? -1 : 0;
}
+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, &oid))
+ return error(_("'%s' is not a valid commit"), commit);
+ strbuf_addstr(&branch, commit);
+ }
+
+ if (!file_exists(git_path_bisect_head())) {
+ struct argv_array argv = ARGV_ARRAY_INIT;
+ argv_array_pushl(&argv, "checkout", branch.buf, "--", NULL);
+ if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
+ error(_("Could not check out original HEAD '%s'. Try "
+ "'git bisect reset <commit>'."), branch.buf);
+ strbuf_release(&branch);
+ argv_array_clear(&argv);
+ return -1;
+ }
+ argv_array_clear(&argv);
+ }
+
+ strbuf_release(&branch);
+ return bisect_clean_state();
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
WRITE_TERMS,
- BISECT_CLEAN_STATE
+ BISECT_CLEAN_STATE,
+ BISECT_RESET
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -99,6 +139,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
+ OPT_CMDMODE(0, "bisect-reset", &cmdmode,
+ N_("reset the bisection state"), BISECT_RESET),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -121,6 +163,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc != 0)
die(_("--bisect-clean-state requires no arguments"));
return bisect_clean_state();
+ case BISECT_RESET:
+ if (argc > 1)
+ die(_("--bisect-reset requires either zero or one arguments"));
+ return bisect_reset(argc ? argv[0] : NULL);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index f1202df..442397b 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -409,35 +409,11 @@ bisect_visualize() {
eval '"$@"' --bisect -- $(cat "$GIT_DIR/BISECT_NAMES")
}
-bisect_reset() {
- test -s "$GIT_DIR/BISECT_START" || {
- gettextln "We are not bisecting."
- return
- }
- case "$#" in
- 0) branch=$(cat "$GIT_DIR/BISECT_START") ;;
- 1) git rev-parse --quiet --verify "$1^{commit}" >/dev/null || {
- invalid="$1"
- die "$(eval_gettext "'\$invalid' is not a valid commit")"
- }
- branch="$1" ;;
- *)
- usage ;;
- esac
-
- if ! test -f "$GIT_DIR/BISECT_HEAD" && ! git checkout "$branch" --
- then
- die "$(eval_gettext "Could not check out original HEAD '\$branch'.
-Try 'git bisect reset <commit>'.")"
- fi
- git bisect--helper --bisect-clean-state || exit
-}
-
bisect_replay () {
file="$1"
test "$#" -eq 1 || die "$(gettext "No logfile given")"
test -r "$file" || die "$(eval_gettext "cannot read \$file for replaying")"
- bisect_reset
+ git bisect--helper --bisect-reset || exit
while read git bisect command rev
do
test "$git $bisect" = "git bisect" || test "$git" = "git-bisect" || continue
@@ -627,7 +603,7 @@ case "$#" in
visualize|view)
bisect_visualize "$@" ;;
reset)
- bisect_reset "$@" ;;
+ git bisect--helper --bisect-reset "$@" ;;
replay)
bisect_replay "$@" ;;
log)
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 15/27] bisect--helper: retire `--bisect-clean-state` subcommand
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (6 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 10/27] bisect--helper: `check_and_set_terms` " Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-26 20:56 ` Junio C Hamano
2016-08-23 11:53 ` [PATCH v14 12/27] bisect--helper: `get_terms` & `bisect_terms` shell function in C Pranit Bauva
` (20 subsequent siblings)
28 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
The `bisect-clean-state` subcommand is no longer used in the shell
script while the C code uses `bisect_clean_state()` thus remove the
subcommand.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 9 ---------
1 file changed, 9 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index ef7b3a1..e351794 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -22,7 +22,6 @@ static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
- N_("git bisect--helper --bisect-clean-state"),
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
@@ -767,7 +766,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
enum {
NEXT_ALL = 1,
WRITE_TERMS,
- BISECT_CLEAN_STATE,
BISECT_RESET,
CHECK_EXPECTED_REVS,
BISECT_WRITE,
@@ -784,8 +782,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("perform 'git bisect next'"), NEXT_ALL),
OPT_CMDMODE(0, "write-terms", &cmdmode,
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
- OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
- N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
N_("reset the bisection state"), BISECT_RESET),
OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
@@ -827,11 +823,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
die(_("--write-terms requires two arguments"));
res = write_terms(argv[0], argv[1]);
break;
- case BISECT_CLEAN_STATE:
- if (argc != 0)
- die(_("--bisect-clean-state requires no arguments"));
- res = bisect_clean_state();
- break;
case BISECT_RESET:
if (argc > 1)
die(_("--bisect-reset requires either zero or one arguments"));
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 09/27] bisect--helper: `bisect_write` shell function in C
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-24 22:30 ` Junio C Hamano
2016-08-23 11:53 ` [PATCH v14 23/27] bisect--helper: retire `--bisect-write` subcommand Pranit Bauva
` (27 subsequent siblings)
28 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
Reimplement the `bisect_write` shell function in C and add a
`bisect-write` subcommand to `git bisect--helper` to call it from
git-bisect.sh
Using `--bisect-write` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by some other methods.
Note: bisect_write() uses two variables namely TERM_GOOD and TERM_BAD
from the global shell script thus we need to pass it to the subcommand
using the arguments. We then store them in a struct bisect_terms and
pass the memory address around functions.
This patch also introduces new methods namely bisect_state_init() and
bisect_terms_release() for easy memory management for the struct
bisect_terms.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 97 ++++++++++++++++++++++++++++++++++++++++++++----
git-bisect.sh | 25 ++-----------
2 files changed, 94 insertions(+), 28 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 711be75..5364960 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -19,9 +19,27 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-clean-state"),
N_("git bisect--helper --bisect-reset [<commit>]"),
+ N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
NULL
};
+struct bisect_terms {
+ struct strbuf term_good;
+ struct strbuf term_bad;
+};
+
+static void bisect_terms_init(struct bisect_terms *terms)
+{
+ strbuf_init(&terms->term_good, 0);
+ strbuf_init(&terms->term_bad, 0);
+}
+
+static void bisect_terms_release(struct bisect_terms *terms)
+{
+ strbuf_release(&terms->term_good);
+ strbuf_release(&terms->term_bad);
+}
+
/*
* Check whether the string `term` belongs to the set of strings
* included in the variable arguments.
@@ -149,6 +167,52 @@ static int check_expected_revs(const char **revs, int rev_nr)
return 0;
}
+static int bisect_write(const char *state, const char *rev,
+ const struct bisect_terms *terms, int nolog)
+{
+ struct strbuf tag = STRBUF_INIT;
+ struct strbuf commit_name = STRBUF_INIT;
+ struct object_id oid;
+ struct commit *commit;
+ struct pretty_print_context pp = {0};
+ FILE *fp;
+
+ if (!strcmp(state, terms->term_bad.buf))
+ strbuf_addf(&tag, "refs/bisect/%s", state);
+ else if (one_of(state, terms->term_good.buf, "skip", NULL))
+ strbuf_addf(&tag, "refs/bisect/%s-%s", state, rev);
+ else
+ return error(_("Bad bisect_write argument: %s"), state);
+
+ if (get_oid(rev, &oid)) {
+ strbuf_release(&tag);
+ return error(_("couldn't get the oid of the rev '%s'"), rev);
+ }
+
+ if (update_ref(NULL, tag.buf, oid.hash, NULL, 0,
+ UPDATE_REFS_MSG_ON_ERR)) {
+ strbuf_release(&tag);
+ return -1;
+ }
+ strbuf_release(&tag);
+
+ fp = fopen(git_path_bisect_log(), "a");
+ if (!fp)
+ return error_errno(_("couldn't open the file '%s'"), git_path_bisect_log());
+
+ commit = lookup_commit_reference(oid.hash);
+ format_commit_message(commit, "%s", &commit_name, &pp);
+ fprintf(fp, "# %s: [%s] %s\n", state, sha1_to_hex(oid.hash),
+ commit_name.buf);
+ strbuf_release(&commit_name);
+
+ if (!nolog)
+ fprintf(fp, "git bisect %s %s\n", state, rev);
+
+ fclose(fp);
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -156,9 +220,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
WRITE_TERMS,
BISECT_CLEAN_STATE,
BISECT_RESET,
- CHECK_EXPECTED_REVS
+ CHECK_EXPECTED_REVS,
+ BISECT_WRITE
} cmdmode = 0;
- int no_checkout = 0;
+ int no_checkout = 0, res = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
@@ -170,10 +235,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("reset the bisection state"), BISECT_RESET),
OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
N_("check for expected revs"), CHECK_EXPECTED_REVS),
+ OPT_CMDMODE(0, "bisect-write", &cmdmode,
+ N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
};
+ struct bisect_terms terms;
+ bisect_terms_init(&terms);
argc = parse_options(argc, argv, prefix, options,
git_bisect_helper_usage, 0);
@@ -182,24 +251,38 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
usage_with_options(git_bisect_helper_usage, options);
switch (cmdmode) {
+ int nolog;
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
case WRITE_TERMS:
if (argc != 2)
die(_("--write-terms requires two arguments"));
- return write_terms(argv[0], argv[1]);
+ res = write_terms(argv[0], argv[1]);
+ break;
case BISECT_CLEAN_STATE:
if (argc != 0)
die(_("--bisect-clean-state requires no arguments"));
- return bisect_clean_state();
+ res = bisect_clean_state();
+ break;
case BISECT_RESET:
if (argc > 1)
die(_("--bisect-reset requires either zero or one arguments"));
- return bisect_reset(argc ? argv[0] : NULL);
+ res = bisect_reset(argc ? argv[0] : NULL);
+ break;
case CHECK_EXPECTED_REVS:
- return check_expected_revs(argv, argc);
+ res = check_expected_revs(argv, argc);
+ break;
+ case BISECT_WRITE:
+ if (argc != 4 && argc != 5)
+ die(_("--bisect-write requires either 4 or 5 arguments"));
+ nolog = (argc == 5) && !strcmp(argv[4], "nolog");
+ strbuf_addstr(&terms.term_good, argv[2]);
+ strbuf_addstr(&terms.term_bad, argv[3]);
+ res = bisect_write(argv[0], argv[1], &terms, nolog);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
- return 0;
+ bisect_terms_release(&terms);
+ return res;
}
diff --git a/git-bisect.sh b/git-bisect.sh
index c3e43248..dfdec33 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -144,7 +144,7 @@ bisect_start() {
0) state=$TERM_BAD ; bad_seen=1 ;;
*) state=$TERM_GOOD ;;
esac
- eval="$eval bisect_write '$state' '$rev' 'nolog' &&"
+ eval="$eval git bisect--helper --bisect-write '$state' '$rev' '$TERM_GOOD' '$TERM_BAD' 'nolog' &&"
done
#
# Verify HEAD.
@@ -220,23 +220,6 @@ bisect_start() {
trap '-' 0
}
-bisect_write() {
- state="$1"
- rev="$2"
- nolog="$3"
- case "$state" in
- "$TERM_BAD")
- tag="$state" ;;
- "$TERM_GOOD"|skip)
- tag="$state"-"$rev" ;;
- *)
- die "$(eval_gettext "Bad bisect_write argument: \$state")" ;;
- esac
- git update-ref "refs/bisect/$tag" "$rev" || exit
- echo "# $state: $(git show-branch $rev)" >>"$GIT_DIR/BISECT_LOG"
- test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -263,7 +246,7 @@ bisect_state() {
bisected_head=$(bisect_head)
rev=$(git rev-parse --verify "$bisected_head") ||
die "$(eval_gettext "Bad rev input: \$bisected_head")"
- bisect_write "$state" "$rev"
+ git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
git bisect--helper --check-expected-revs "$rev" ;;
2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
shift
@@ -276,7 +259,7 @@ bisect_state() {
done
for rev in $hash_list
do
- bisect_write "$state" "$rev"
+ git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
done
git bisect--helper --check-expected-revs $hash_list ;;
*,"$TERM_BAD")
@@ -413,7 +396,7 @@ bisect_replay () {
cmd="bisect_start $rev"
eval "$cmd" ;;
"$TERM_GOOD"|"$TERM_BAD"|skip)
- bisect_write "$command" "$rev" ;;
+ git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
terms)
bisect_terms $rev ;;
*)
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 18/27] bisect--helper: `bisect_state` & `bisect_head` shell function in C
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (15 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 07/27] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 17/27] bisect--helper: `bisect_autostart` " Pranit Bauva
` (11 subsequent siblings)
28 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
Reimplement the `bisect_state` shell function in C and also add a
subcommand `--bisect-state` to `git-bisect--helper` to call it from
git-bisect.sh .
Using `--bisect-state` subcommand is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other methods.
`bisect_head` is called from `bisect_state` thus its not required to
introduce another subcommand.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 84 ++++++++++++++++++++++++++++++++++++++++++++++++
git-bisect.sh | 57 +++-----------------------------
2 files changed, 89 insertions(+), 52 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index a139592..861c07d 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -31,6 +31,8 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-next"),
N_("git bisect--helper --bisect-auto-next"),
N_("git bisect--helper --bisect-autostart"),
+ N_("git bisect--helper --bisect-state (bad|new) [<rev>]"),
+ N_("git bisect--helper --bisect-state (good|old) [<rev>...]"),
NULL
};
@@ -790,6 +792,79 @@ static int bisect_autostart(struct bisect_terms *terms)
return 0;
}
+static char *bisect_head(void)
+{
+ if (is_empty_or_missing_file(git_path_bisect_head()))
+ return "HEAD";
+ else
+ return "BISECT_HEAD";
+}
+
+static int bisect_state(struct bisect_terms *terms, const char **argv,
+ int argc)
+{
+ const char *state = argv[0];
+
+ get_terms(terms);
+ if (check_and_set_terms(terms, state))
+ return -1;
+
+ if (!argc)
+ die(_("Please call `--bisect-state` with at least one argument"));
+
+ if (argc == 1 && one_of(state, terms->term_good.buf,
+ terms->term_bad.buf, "skip", NULL)) {
+ const char *bisected_head = xstrdup(bisect_head());
+ const char *hex[1];
+ unsigned char sha1[20];
+
+ if (get_sha1(bisected_head, sha1))
+ die(_("Bad rev input: %s"), bisected_head);
+ if (bisect_write(state, sha1_to_hex(sha1), terms, 0))
+ return -1;
+
+ *hex = xstrdup(sha1_to_hex(sha1));
+ if (check_expected_revs(hex, 1))
+ return -1;
+ return bisect_auto_next(terms, NULL);
+ }
+
+ if ((argc == 2 && !strcmp(state, terms->term_bad.buf)) ||
+ one_of(state, terms->term_good.buf, "skip", NULL)) {
+ int i;
+ struct string_list hex = STRING_LIST_INIT_DUP;
+
+ for (i = 1; i < argc; i++) {
+ unsigned char sha1[20];
+
+ if (get_sha1(argv[i], sha1)) {
+ string_list_clear(&hex, 0);
+ die(_("Bad rev input: %s"), argv[i]);
+ }
+ string_list_append(&hex, sha1_to_hex(sha1));
+ }
+ for (i = 0; i < hex.nr; i++) {
+ const char **hex_string = (const char **) &hex.items[i].string;
+ if(bisect_write(state, *hex_string, terms, 0)) {
+ string_list_clear(&hex, 0);
+ return -1;
+ }
+ if (check_expected_revs(hex_string, 1)) {
+ string_list_clear(&hex, 0);
+ return -1;
+ }
+ }
+ string_list_clear(&hex, 0);
+ return bisect_auto_next(terms, NULL);
+ }
+
+ if (!strcmp(state, terms->term_bad.buf))
+ die(_("'git bisect %s' can take only one argument."),
+ terms->term_bad.buf);
+
+ return -1;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -804,6 +879,7 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_NEXT,
BISECT_AUTO_NEXT,
BISECT_AUTOSTART,
+ BISECT_STATE
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -829,6 +905,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("verify the next bisection state then find the next bisection state"), BISECT_AUTO_NEXT),
OPT_CMDMODE(0, "bisect-autostart", &cmdmode,
N_("start the bisection if BISECT_START empty or missing"), BISECT_AUTOSTART),
+ OPT_CMDMODE(0, "bisect-state", &cmdmode,
+ N_("mark the state of ref (or refs)"), BISECT_STATE),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -909,6 +987,12 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
strbuf_addstr(&terms.term_bad, "bad");
res = bisect_autostart(&terms);
break;
+ case BISECT_STATE:
+ if (argc == 0)
+ die(_("--bisect-state requires at least 1 argument"));
+ get_terms(&terms);
+ res = bisect_state(&terms, argv, argc);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index cd56551..a9eebbb 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -39,16 +39,6 @@ _x40="$_x40$_x40$_x40$_x40$_x40$_x40$_x40$_x40"
TERM_BAD=bad
TERM_GOOD=good
-bisect_head()
-{
- if test -f "$GIT_DIR/BISECT_HEAD"
- then
- echo BISECT_HEAD
- else
- echo HEAD
- fi
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -61,44 +51,7 @@ bisect_skip() {
esac
all="$all $revs"
done
- eval bisect_state 'skip' $all
-}
-
-bisect_state() {
- git bisect--helper --bisect-autostart
- state=$1
- get_terms
- git bisect--helper --check-and-set-terms $state $TERM_GOOD $TERM_BAD || exit
- get_terms
- case "$#,$state" in
- 0,*)
- die "Please call 'bisect_state' with at least one argument." ;;
- 1,"$TERM_BAD"|1,"$TERM_GOOD"|1,skip)
- bisected_head=$(bisect_head)
- rev=$(git rev-parse --verify "$bisected_head") ||
- die "$(eval_gettext "Bad rev input: \$bisected_head")"
- git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
- git bisect--helper --check-expected-revs "$rev" ;;
- 2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
- shift
- hash_list=''
- for rev in "$@"
- do
- sha=$(git rev-parse --verify "$rev^{commit}") ||
- die "$(eval_gettext "Bad rev input: \$rev")"
- hash_list="$hash_list $sha"
- done
- for rev in $hash_list
- do
- git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
- done
- git bisect--helper --check-expected-revs $hash_list ;;
- *,"$TERM_BAD")
- die "$(eval_gettext "'git bisect \$TERM_BAD' can take only one argument.")" ;;
- *)
- usage ;;
- esac
- git bisect--helper --bisect-auto-next || exit
+ eval git bisect--helper --bisect-state 'skip' $all
}
bisect_visualize() {
@@ -184,8 +137,8 @@ exit code \$res from '\$command' is < 0 or >= 128" >&2
state="$TERM_GOOD"
fi
- # We have to use a subshell because "bisect_state" can exit.
- ( bisect_state $state >"$GIT_DIR/BISECT_RUN" )
+ # We have to use a subshell because "--bisect-state" can exit.
+ ( git bisect--helper --bisect-state $state >"$GIT_DIR/BISECT_RUN" )
res=$?
cat "$GIT_DIR/BISECT_RUN"
@@ -200,7 +153,7 @@ exit code \$res from '\$command' is < 0 or >= 128" >&2
if [ $res -ne 0 ]
then
eval_gettextln "bisect run failed:
-'bisect_state \$state' exited with error code \$res" >&2
+'git bisect--helper --bisect-state \$state' exited with error code \$res" >&2
exit $res
fi
@@ -241,7 +194,7 @@ case "$#" in
start)
git bisect--helper --bisect-start "$@" ;;
bad|good|new|old|"$TERM_BAD"|"$TERM_GOOD")
- bisect_state "$cmd" "$@" ;;
+ git bisect--helper --bisect-state "$cmd" "$@" ;;
skip)
bisect_skip "$@" ;;
next)
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 21/27] bisect--helper: `bisect_log` shell function in C
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (18 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 22/27] bisect--helper: `bisect_replay` " Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-26 23:07 ` Junio C Hamano
2016-08-23 11:53 ` [PATCH v14 24/27] bisect--helper: retire `--check-and-set-terms` subcommand Pranit Bauva
` (8 subsequent siblings)
28 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
Reimplement the `bisect_log` shell function in C and also add
`--bisect-log` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Using `--bisect-log` subcommand is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other method.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 25 ++++++++++++++++++++++++-
git-bisect.sh | 7 +------
2 files changed, 25 insertions(+), 7 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 1b6e5d8..b57b0c8 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -864,6 +864,21 @@ static int bisect_state(struct bisect_terms *terms, const char **argv,
return -1;
}
+static int bisect_log(void)
+{
+ struct strbuf buf = STRBUF_INIT;
+
+ if (strbuf_read_file(&buf, git_path_bisect_log(), 256) < 0) {
+ strbuf_release(&buf);
+ return error(_("We are not bisecting.\n"));
+ }
+
+ printf("%s", buf.buf);
+ strbuf_release(&buf);
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -876,7 +891,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_NEXT,
BISECT_AUTO_NEXT,
BISECT_AUTOSTART,
- BISECT_STATE
+ BISECT_STATE,
+ BISECT_LOG
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -900,6 +916,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("start the bisection if BISECT_START empty or missing"), BISECT_AUTOSTART),
OPT_CMDMODE(0, "bisect-state", &cmdmode,
N_("mark the state of ref (or refs)"), BISECT_STATE),
+ OPT_CMDMODE(0, "bisect-log", &cmdmode,
+ N_("output the contents of BISECT_LOG"), BISECT_LOG),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -978,6 +996,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
get_terms(&terms);
res = bisect_state(&terms, argv, argc);
break;
+ case BISECT_LOG:
+ if (argc > 1)
+ die(_("--bisect-log requires 0 arguments"));
+ res = bisect_log();
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index a9eebbb..a47e3b5 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -166,11 +166,6 @@ exit code \$res from '\$command' is < 0 or >= 128" >&2
done
}
-bisect_log () {
- test -s "$GIT_DIR/BISECT_LOG" || die "$(gettext "We are not bisecting.")"
- cat "$GIT_DIR/BISECT_LOG"
-}
-
get_terms () {
if test -s "$GIT_DIR/BISECT_TERMS"
then
@@ -208,7 +203,7 @@ case "$#" in
replay)
bisect_replay "$@" ;;
log)
- bisect_log ;;
+ git bisect--helper --bisect-log ;;
run)
bisect_run "$@" ;;
terms)
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 24/27] bisect--helper: retire `--check-and-set-terms` subcommand
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (19 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 21/27] bisect--helper: `bisect_log` " Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 08/27] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C Pranit Bauva
` (7 subsequent siblings)
28 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
The `--check-and-set-terms` subcommand is no longer used in the shell
script and the function `check_and_set_terms()` is called from the C
implementation.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 11 -----------
1 file changed, 11 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 4ab6488..8982f29 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -21,7 +21,6 @@ static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-reset [<commit>]"),
- N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
N_("git bisect--helper --bisect start [--term-{old,good}=<term> --term-{new,bad}=<term>]"
@@ -970,7 +969,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
BISECT_RESET = 1,
- CHECK_AND_SET_TERMS,
BISECT_NEXT_CHECK,
BISECT_TERMS,
BISECT_START,
@@ -985,8 +983,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
struct option options[] = {
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
N_("reset the bisection state"), BISECT_RESET),
- OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
- N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
OPT_CMDMODE(0, "bisect-terms", &cmdmode,
@@ -1025,13 +1021,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
die(_("--bisect-reset requires either zero or one arguments"));
res = bisect_reset(argc ? argv[0] : NULL);
break;
- case CHECK_AND_SET_TERMS:
- if (argc != 3)
- die(_("--check-and-set-terms requires 3 arguments"));
- strbuf_addstr(&terms.term_good, argv[1]);
- strbuf_addstr(&terms.term_bad, argv[2]);
- res = check_and_set_terms(&terms, argv[0]);
- break;
case BISECT_NEXT_CHECK:
if (argc != 2 && argc != 3)
die(_("--bisect-next-check requires 2 or 3 arguments"));
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 17/27] bisect--helper: `bisect_autostart` shell function in C
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (16 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 18/27] bisect--helper: `bisect_state` & `bisect_head` " Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-26 21:09 ` Junio C Hamano
2016-08-23 11:53 ` [PATCH v14 22/27] bisect--helper: `bisect_replay` " Pranit Bauva
` (10 subsequent siblings)
28 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
Reimplement the `bisect_autostart` shell function in C and add the
C implementation from `bisect_next()` which was previously left
uncovered. Also add a subcommand `--bisect-autostart` to
`git bisect--helper` be called from `bisect_state()` from
git-bisect.sh .
Using `--bisect-autostart` subcommand is a temporary measure to port
shell function to C so as to use the existing test suite. As more
functions are ported, this subcommand will be retired and will be called
by `bisect_state()`.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 40 ++++++++++++++++++++++++++++++++++++++++
git-bisect.sh | 23 +----------------------
2 files changed, 41 insertions(+), 22 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 8cbcc3b..a139592 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -30,6 +30,7 @@ static const char * const git_bisect_helper_usage[] = {
"[--no-checkout] [<bad> [<good>...]] [--] [<paths>...]"),
N_("git bisect--helper --bisect-next"),
N_("git bisect--helper --bisect-auto-next"),
+ N_("git bisect--helper --bisect-autostart"),
NULL
};
@@ -38,6 +39,8 @@ struct bisect_terms {
struct strbuf term_bad;
};
+static int bisect_autostart(struct bisect_terms *terms);
+
static void bisect_terms_init(struct bisect_terms *terms)
{
strbuf_init(&terms->term_good, 0);
@@ -410,6 +413,7 @@ static int bisect_next(struct bisect_terms *terms, const char *prefix)
{
int res, no_checkout;
+ bisect_autostart(terms);
/* 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
@@ -760,6 +764,32 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
return bisect_auto_next(terms, NULL);
}
+static int bisect_autostart(struct bisect_terms *terms)
+{
+ if (is_empty_or_missing_file(git_path_bisect_start())) {
+ const char *yesno;
+ const char *argv[] = {NULL};
+ fprintf(stderr, _("You need to start by \"git bisect "
+ "start\"\n"));
+
+ if (!isatty(0))
+ return 1;
+
+ /*
+ * TRANSLATORS: Make sure to include [Y] and [n] in your
+ * translation. THe program will only accept English input
+ * at this point.
+ */
+ yesno = git_prompt(_("Do you want me to do it for you "
+ "[Y/n]? "), PROMPT_ECHO);
+ if (starts_with(yesno, "n") || starts_with(yesno, "N"))
+ exit(0);
+
+ return bisect_start(terms, 0, argv, 0);
+ }
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -773,6 +803,7 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_START,
BISECT_NEXT,
BISECT_AUTO_NEXT,
+ BISECT_AUTOSTART,
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -796,6 +827,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("find the next bisection commit"), BISECT_NEXT),
OPT_CMDMODE(0, "bisect-auto-next", &cmdmode,
N_("verify the next bisection state then find the next bisection state"), BISECT_AUTO_NEXT),
+ OPT_CMDMODE(0, "bisect-autostart", &cmdmode,
+ N_("start the bisection if BISECT_START empty or missing"), BISECT_AUTOSTART),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -869,6 +902,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
get_terms(&terms);
res = bisect_auto_next(&terms, prefix);
break;
+ case BISECT_AUTOSTART:
+ if (argc)
+ die(_("--bisect-autostart requires 0 arguments"));
+ strbuf_addstr(&terms.term_good, "good");
+ strbuf_addstr(&terms.term_bad, "bad");
+ res = bisect_autostart(&terms);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index d574c44..cd56551 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -49,27 +49,6 @@ bisect_head()
fi
}
-bisect_autostart() {
- test -s "$GIT_DIR/BISECT_START" || {
- gettextln "You need to start by \"git bisect start\"" >&2
- if test -t 0
- then
- # TRANSLATORS: Make sure to include [Y] and [n] in your
- # translation. The program will only accept English input
- # at this point.
- gettext "Do you want me to do it for you [Y/n]? " >&2
- read yesno
- case "$yesno" in
- [Nn]*)
- exit ;;
- esac
- git bisect--helper --bisect-start
- else
- exit 1
- fi
- }
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -86,7 +65,7 @@ bisect_skip() {
}
bisect_state() {
- bisect_autostart
+ git bisect--helper --bisect-autostart
state=$1
get_terms
git bisect--helper --check-and-set-terms $state $TERM_GOOD $TERM_BAD || exit
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 12/27] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (7 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 15/27] bisect--helper: retire `--bisect-clean-state` subcommand Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-25 18:05 ` Junio C Hamano
2016-08-23 11:53 ` [PATCH v14 16/27] bisect--helper: retire `--next-all` subcommand Pranit Bauva
` (19 subsequent siblings)
28 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
Reimplement the `get_terms` and `bisect_terms` shell function in C and
add `bisect-terms` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Using `--bisect-terms` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by some other methods.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 59 ++++++++++++++++++++++++++++++++++++++++++++++--
git-bisect.sh | 35 ++--------------------------
2 files changed, 59 insertions(+), 35 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index aca3908..44adf6b 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -23,6 +23,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
+ N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
NULL
};
@@ -344,6 +345,52 @@ static int bisect_next_check(const struct bisect_terms *terms,
return 0;
}
+static int get_terms(struct bisect_terms *terms)
+{
+ FILE *fp;
+ int res;
+ fp = fopen(git_path_bisect_terms(), "r");
+ if (!fp)
+ return -1;
+
+ bisect_terms_reset(terms);
+ res = strbuf_getline(&terms->term_bad, fp) == EOF ||
+ strbuf_getline(&terms->term_good, fp) == EOF;
+
+ fclose(fp);
+ return res ? -1 : 0;
+}
+
+static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
+{
+ int i;
+
+ if (get_terms(terms)) {
+ fprintf(stderr, _("no terms defined\n"));
+ return -1;
+ }
+ if (argc == 0) {
+ printf(_("Your current terms are %s for the old state\nand "
+ "%s for the new state.\n"), terms->term_good.buf,
+ terms->term_bad.buf);
+ return 0;
+ }
+
+ for (i = 0; i < argc; i++) {
+ if (!strcmp(argv[i], "--term-good"))
+ printf("%s\n", terms->term_good.buf);
+ else if (!strcmp(argv[i], "--term-bad"))
+ printf("%s\n", terms->term_bad.buf);
+ else
+ printf(_("invalid argument %s for 'git bisect "
+ "terms'.\nSupported options are: "
+ "--term-good|--term-old and "
+ "--term-bad|--term-new."), argv[i]);
+ }
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -354,7 +401,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
CHECK_EXPECTED_REVS,
BISECT_WRITE,
CHECK_AND_SET_TERMS,
- BISECT_NEXT_CHECK
+ BISECT_NEXT_CHECK,
+ BISECT_TERMS
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -374,6 +422,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
+ OPT_CMDMODE(0, "bisect-terms", &cmdmode,
+ N_("print out the bisect terms"), BISECT_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -382,7 +432,7 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
bisect_terms_init(&terms);
argc = parse_options(argc, argv, prefix, options,
- git_bisect_helper_usage, 0);
+ git_bisect_helper_usage, PARSE_OPT_KEEP_UNKNOWN);
if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
@@ -431,6 +481,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
strbuf_addstr(&terms.term_bad, argv[1]);
res = bisect_next_check(&terms, argc == 3 ? argv[2] : NULL);
break;
+ case BISECT_TERMS:
+ if (argc > 1)
+ die(_("--bisect-terms requires 0 or 1 argument"));
+ res = bisect_terms(&terms, argv, argc);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index fe6c9d0..d6c8b5a 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -355,7 +355,7 @@ bisect_replay () {
"$TERM_GOOD"|"$TERM_BAD"|skip)
git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
terms)
- bisect_terms $rev ;;
+ git bisect--helper --bisect-terms $rev || exit;;
*)
die "$(gettext "?? what are you talking about?")" ;;
esac
@@ -437,37 +437,6 @@ get_terms () {
fi
}
-bisect_terms () {
- get_terms
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- die "$(gettext "no terms defined")"
- fi
- case "$#" in
- 0)
- gettextln "Your current terms are $TERM_GOOD for the old state
-and $TERM_BAD for the new state."
- ;;
- 1)
- arg=$1
- case "$arg" in
- --term-good|--term-old)
- printf '%s\n' "$TERM_GOOD"
- ;;
- --term-bad|--term-new)
- printf '%s\n' "$TERM_BAD"
- ;;
- *)
- die "$(eval_gettext "invalid argument \$arg for 'git bisect terms'.
-Supported options are: --term-good|--term-old and --term-bad|--term-new.")"
- ;;
- esac
- ;;
- *)
- usage ;;
- esac
-}
-
case "$#" in
0)
usage ;;
@@ -498,7 +467,7 @@ case "$#" in
run)
bisect_run "$@" ;;
terms)
- bisect_terms "$@" ;;
+ git bisect--helper --bisect-terms "$@" || exit;;
*)
usage ;;
esac
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 04/27] bisect--helper: `bisect_clean_state` shell function in C
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (24 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 19/27] bisect--helper: retire `--check-expected-revs` subcommand Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-24 20:58 ` Junio C Hamano
2016-08-23 20:28 ` [PATCH v14 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Junio C Hamano
` (2 subsequent siblings)
28 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
Reimplement `bisect_clean_state` shell function in C and add a
`bisect-clean-state` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Using `--bisect-clean-state` subcommand is a measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by bisect_reset() and bisect_start().
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
bisect.c | 43 +++++++++++++++++++++++++++++++++++++++++++
bisect.h | 2 ++
builtin/bisect--helper.c | 14 +++++++++++++-
git-bisect.sh | 26 +++-----------------------
4 files changed, 61 insertions(+), 24 deletions(-)
diff --git a/bisect.c b/bisect.c
index 6f512c2..45d598d 100644
--- a/bisect.c
+++ b/bisect.c
@@ -430,6 +430,12 @@ static int read_bisect_refs(void)
static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
+static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
+static GIT_PATH_FUNC(git_path_bisect_run, "BISECT_RUN")
+static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
+static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
+static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
+static GIT_PATH_FUNC(git_path_head_name, "head-name")
static void read_bisect_paths(struct argv_array *array)
{
@@ -1040,3 +1046,40 @@ int estimate_bisect_steps(int all)
return (e < 3 * x) ? n : n - 1;
}
+
+static int mark_for_removal(const char *refname, const struct object_id *oid,
+ int flag, void *cb_data)
+{
+ struct string_list *refs = cb_data;
+ char *ref = xstrfmt("refs/bisect%s", refname);
+ string_list_append(refs, ref);
+ return 0;
+}
+
+int bisect_clean_state(void)
+{
+ int result = 0;
+
+ /* There may be some refs packed during bisection */
+ struct string_list refs_for_removal = STRING_LIST_INIT_NODUP;
+ for_each_ref_in("refs/bisect", mark_for_removal, (void *) &refs_for_removal);
+ string_list_append(&refs_for_removal, xstrdup("BISECT_HEAD"));
+ result = delete_refs(&refs_for_removal, REF_NODEREF);
+ refs_for_removal.strdup_strings = 1;
+ string_list_clear(&refs_for_removal, 0);
+ unlink_or_warn(git_path_bisect_expected_rev());
+ unlink_or_warn(git_path_bisect_ancestors_ok());
+ unlink_or_warn(git_path_bisect_log());
+ unlink_or_warn(git_path_bisect_names());
+ unlink_or_warn(git_path_bisect_run());
+ unlink_or_warn(git_path_bisect_terms());
+ /* Cleanup head-name if it got left by an old version of git-bisect */
+ unlink_or_warn(git_path_head_name());
+ /*
+ * Cleanup BISECT_START last to support the --no-checkout option
+ * introduced in the commit 4796e823a.
+ */
+ unlink_or_warn(git_path_bisect_start());
+
+ return result;
+}
diff --git a/bisect.h b/bisect.h
index acd12ef..0ae63d4 100644
--- a/bisect.h
+++ b/bisect.h
@@ -28,4 +28,6 @@ extern int estimate_bisect_steps(int all);
extern void read_bisect_terms(const char **bad, const char **good);
+extern int bisect_clean_state(void);
+
#endif
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 30e1031..e50934c 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -5,10 +5,15 @@
#include "refs.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
+static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
+static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
+static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
+static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
+ N_("git bisect--helper --bisect-clean-state"),
NULL
};
@@ -83,7 +88,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
- WRITE_TERMS
+ WRITE_TERMS,
+ BISECT_CLEAN_STATE
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -91,6 +97,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("perform 'git bisect next'"), NEXT_ALL),
OPT_CMDMODE(0, "write-terms", &cmdmode,
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
+ OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
+ N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -109,6 +117,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc != 2)
die(_("--write-terms requires two arguments"));
return write_terms(argv[0], argv[1]);
+ case BISECT_CLEAN_STATE:
+ if (argc != 0)
+ die(_("--bisect-clean-state requires no arguments"));
+ return bisect_clean_state();
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 9ef6cb8..f1202df 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -186,7 +186,7 @@ bisect_start() {
#
# Get rid of any old bisect state.
#
- bisect_clean_state || exit
+ git bisect--helper --bisect-clean-state || exit
#
# Change state.
@@ -195,7 +195,7 @@ bisect_start() {
# We have to trap this to be able to clean up using
# "bisect_clean_state".
#
- trap 'bisect_clean_state' 0
+ trap 'git bisect--helper --bisect-clean-state' 0
trap 'exit 255' 1 2 3 15
#
@@ -430,27 +430,7 @@ bisect_reset() {
die "$(eval_gettext "Could not check out original HEAD '\$branch'.
Try 'git bisect reset <commit>'.")"
fi
- bisect_clean_state
-}
-
-bisect_clean_state() {
- # There may be some refs packed during bisection.
- git for-each-ref --format='%(refname) %(objectname)' refs/bisect/\* |
- while read ref hash
- do
- git update-ref -d $ref $hash || exit
- done
- rm -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
- rm -f "$GIT_DIR/BISECT_ANCESTORS_OK" &&
- rm -f "$GIT_DIR/BISECT_LOG" &&
- rm -f "$GIT_DIR/BISECT_NAMES" &&
- rm -f "$GIT_DIR/BISECT_RUN" &&
- rm -f "$GIT_DIR/BISECT_TERMS" &&
- # Cleanup head-name if it got left by an old version of git-bisect
- rm -f "$GIT_DIR/head-name" &&
- git update-ref -d --no-deref BISECT_HEAD &&
- # clean up BISECT_START last
- rm -f "$GIT_DIR/BISECT_START"
+ git bisect--helper --bisect-clean-state || exit
}
bisect_replay () {
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 20/27] bisect--helper: retire `--write-terms` subcommand
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (2 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 02/27] bisect: rewrite `check_term_format` shell function in C Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 27/27] bisect--helper: remove the dequote in bisect_start() Pranit Bauva
` (24 subsequent siblings)
28 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
The `--write-terms` subcommand is no longer used in the shell script and
the function `write_terms()` is called from the C implementation of
`set_terms()` and `bisect_start()`.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 11 +----------
1 file changed, 1 insertion(+), 10 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 6cc990b..1b6e5d8 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -20,7 +20,6 @@ static GIT_PATH_FUNC(git_path_head_name, "head-name")
static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static const char * const git_bisect_helper_usage[] = {
- N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
@@ -868,8 +867,7 @@ static int bisect_state(struct bisect_terms *terms, const char **argv,
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
- WRITE_TERMS = 1,
- BISECT_RESET,
+ BISECT_RESET = 1,
BISECT_WRITE,
CHECK_AND_SET_TERMS,
BISECT_NEXT_CHECK,
@@ -882,8 +880,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
- OPT_CMDMODE(0, "write-terms", &cmdmode,
- N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
N_("reset the bisection state"), BISECT_RESET),
OPT_CMDMODE(0, "bisect-write", &cmdmode,
@@ -920,11 +916,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
switch (cmdmode) {
int nolog;
- case WRITE_TERMS:
- if (argc != 2)
- die(_("--write-terms requires two arguments"));
- res = write_terms(argv[0], argv[1]);
- break;
case BISECT_RESET:
if (argc > 1)
die(_("--bisect-reset requires either zero or one arguments"));
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 23/27] bisect--helper: retire `--bisect-write` subcommand
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 09/27] bisect--helper: `bisect_write` shell function in C Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 02/27] bisect: rewrite `check_term_format` shell function in C Pranit Bauva
` (26 subsequent siblings)
28 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
The `--bisect-write` subcommand is no longer used in the shell script
and the function `bisect_write()` is called from the C implementation.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 13 -------------
1 file changed, 13 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 9c1108d..4ab6488 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -21,7 +21,6 @@ static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-reset [<commit>]"),
- N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
@@ -971,7 +970,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
BISECT_RESET = 1,
- BISECT_WRITE,
CHECK_AND_SET_TERMS,
BISECT_NEXT_CHECK,
BISECT_TERMS,
@@ -987,8 +985,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
struct option options[] = {
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
N_("reset the bisection state"), BISECT_RESET),
- OPT_CMDMODE(0, "bisect-write", &cmdmode,
- N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
@@ -1024,20 +1020,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
usage_with_options(git_bisect_helper_usage, options);
switch (cmdmode) {
- int nolog;
case BISECT_RESET:
if (argc > 1)
die(_("--bisect-reset requires either zero or one arguments"));
res = bisect_reset(argc ? argv[0] : NULL);
break;
- case BISECT_WRITE:
- if (argc != 4 && argc != 5)
- die(_("--bisect-write requires either 4 or 5 arguments"));
- nolog = (argc == 5) && !strcmp(argv[4], "nolog");
- strbuf_addstr(&terms.term_good, argv[2]);
- strbuf_addstr(&terms.term_bad, argv[3]);
- res = bisect_write(argv[0], argv[1], &terms, nolog);
- break;
case CHECK_AND_SET_TERMS:
if (argc != 3)
die(_("--check-and-set-terms requires 3 arguments"));
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 10/27] bisect--helper: `check_and_set_terms` shell function in C
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (5 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 14/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function in C Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 15/27] bisect--helper: retire `--bisect-clean-state` subcommand Pranit Bauva
` (21 subsequent siblings)
28 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
Reimplement the `check_and_set_terms` shell function in C and add
`check-and-set-terms` subcommand to `git bisect--helper` to call it from
git-bisect.sh
Using `--check-and-set-terms` subcommand is a temporary measure to port
shell function in C so as to use the existing test suite. As more
functions are ported, this subcommand will be retired but its
implementation will be called by some other methods.
check_and_set_terms() sets and receives two global variables namely
TERM_GOOD and TERM_BAD in the shell script. Luckily the file BISECT_TERMS
also contains the value of those variables so its appropriate to evoke the
method get_terms() after calling the subcommand so that it retrieves the
value of TERM_GOOD and TERM_BAD from the file BISECT_TERMS. The two
global variables are passed as arguments to the subcommand.
Also introduce bisect_terms_reset() to empty the contents of `term_good`
and `term_bad` of `struct bisect_terms`.
Also introduce set_terms() to copy the `term_good` and `term_bad` into
`struct bisect_terms` and write it out to the file BISECT_TERMS.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 52 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 36 ++++-----------------------------
2 files changed, 55 insertions(+), 33 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 5364960..450426c 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -20,6 +20,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-clean-state"),
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
+ N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
NULL
};
@@ -40,6 +41,12 @@ static void bisect_terms_release(struct bisect_terms *terms)
strbuf_release(&terms->term_bad);
}
+static void bisect_terms_reset(struct bisect_terms *term)
+{
+ strbuf_reset(&term->term_good);
+ strbuf_reset(&term->term_bad);
+}
+
/*
* Check whether the string `term` belongs to the set of strings
* included in the variable arguments.
@@ -213,6 +220,39 @@ static int bisect_write(const char *state, const char *rev,
return 0;
}
+static int set_terms(struct bisect_terms *terms, const char *bad,
+ const char *good)
+{
+ bisect_terms_reset(terms);
+ strbuf_addstr(&terms->term_good, good);
+ strbuf_addstr(&terms->term_bad, bad);
+ return write_terms(terms->term_bad.buf, terms->term_good.buf);
+}
+
+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.buf) &&
+ strcmp(cmd, terms->term_good.buf))
+ return error(_("Invalid command: you're currently in a "
+ "%s/%s bisect"), terms->term_bad.buf,
+ terms->term_good.buf);
+
+ if (!has_term_file) {
+ if (one_of(cmd, "bad", "good", NULL))
+ return set_terms(terms, "bad", "good");
+ if (one_of(cmd, "new", "old", NULL))
+ return set_terms(terms, "new", "old");
+ }
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -221,7 +261,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_CLEAN_STATE,
BISECT_RESET,
CHECK_EXPECTED_REVS,
- BISECT_WRITE
+ BISECT_WRITE,
+ CHECK_AND_SET_TERMS
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -237,6 +278,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check for expected revs"), CHECK_EXPECTED_REVS),
OPT_CMDMODE(0, "bisect-write", &cmdmode,
N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
+ OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
+ N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -280,6 +323,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
strbuf_addstr(&terms.term_bad, argv[3]);
res = bisect_write(argv[0], argv[1], &terms, nolog);
break;
+ case CHECK_AND_SET_TERMS:
+ if (argc != 3)
+ die(_("--check-and-set-terms requires 3 arguments"));
+ strbuf_addstr(&terms.term_good, argv[1]);
+ strbuf_addstr(&terms.term_bad, argv[2]);
+ res = check_and_set_terms(&terms, argv[0]);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index dfdec33..bdf2227 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -238,7 +238,8 @@ bisect_skip() {
bisect_state() {
bisect_autostart
state=$1
- check_and_set_terms $state
+ git bisect--helper --check-and-set-terms $state $TERM_GOOD $TERM_BAD || exit
+ get_terms
case "$#,$state" in
0,*)
die "Please call 'bisect_state' with at least one argument." ;;
@@ -390,7 +391,8 @@ bisect_replay () {
command="$bisect"
fi
get_terms
- check_and_set_terms "$command"
+ git bisect--helper --check-and-set-terms "$command" "$TERM_GOOD" "$TERM_BAD" || exit
+ get_terms
case "$command" in
start)
cmd="bisect_start $rev"
@@ -480,36 +482,6 @@ get_terms () {
fi
}
-check_and_set_terms () {
- cmd="$1"
- case "$cmd" in
- skip|start|terms) ;;
- *)
- if test -s "$GIT_DIR/BISECT_TERMS" && test "$cmd" != "$TERM_BAD" && test "$cmd" != "$TERM_GOOD"
- then
- die "$(eval_gettext "Invalid command: you're currently in a \$TERM_BAD/\$TERM_GOOD bisect.")"
- fi
- case "$cmd" in
- bad|good)
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- TERM_BAD=bad
- TERM_GOOD=good
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
- fi
- ;;
- new|old)
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- TERM_BAD=new
- TERM_GOOD=old
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
- fi
- ;;
- esac ;;
- esac
-}
-
bisect_voc () {
case "$1" in
bad) echo "bad|new" ;;
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 03/27] bisect--helper: `write_terms` shell function in C
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (21 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 08/27] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 06/27] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
` (5 subsequent siblings)
28 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
Reimplement the `write_terms` shell function in C and add a `write-terms`
subcommand to `git bisect--helper` to call it from git-bisect.sh . Also
remove the subcommand `--check-term-format` as it can now be called from
inside the function write_terms() C implementation.
Also `|| exit` is added when calling write-terms subcommand from
git-bisect.sh so as to exit whenever there is an error.
Using `--write-terms` subcommand is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and its implementation will
be called by some other method.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 36 +++++++++++++++++++++++++++++-------
git-bisect.sh | 22 +++++++---------------
2 files changed, 36 insertions(+), 22 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index a47f1f2..30e1031 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -4,9 +4,11 @@
#include "bisect.h"
#include "refs.h"
+static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
+
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
- N_("git bisect--helper --check-term-format <term> <orig_term>"),
+ N_("git bisect--helper --write-terms <bad_term> <good_term>"),
NULL
};
@@ -57,18 +59,38 @@ static int check_term_format(const char *term, const char *orig_term)
return 0;
}
+static int write_terms(const char *bad, const char *good)
+{
+ FILE *fp;
+ 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;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
- CHECK_TERM_FMT
+ WRITE_TERMS
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
- OPT_CMDMODE(0, "check-term-format", &cmdmode,
- N_("check format of the term"), CHECK_TERM_FMT),
+ OPT_CMDMODE(0, "write-terms", &cmdmode,
+ N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -83,10 +105,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
switch (cmdmode) {
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
- case CHECK_TERM_FMT:
+ case WRITE_TERMS:
if (argc != 2)
- die(_("--check-term-format requires two arguments"));
- return check_term_format(argv[0], argv[1]);
+ die(_("--write-terms requires two arguments"));
+ return write_terms(argv[0], argv[1]);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index a727c59..9ef6cb8 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -209,7 +209,7 @@ bisect_start() {
eval "$eval true" &&
if test $must_write_terms -eq 1
then
- write_terms "$TERM_BAD" "$TERM_GOOD"
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD"
fi &&
echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
#
@@ -557,18 +557,6 @@ get_terms () {
fi
}
-write_terms () {
- TERM_BAD=$1
- TERM_GOOD=$2
- if test "$TERM_BAD" = "$TERM_GOOD"
- then
- die "$(gettext "please use two different terms")"
- fi
- git bisect--helper --check-term-format "$TERM_BAD" bad || exit
- git bisect--helper --check-term-format "$TERM_GOOD" good || exit
- printf '%s\n%s\n' "$TERM_BAD" "$TERM_GOOD" >"$GIT_DIR/BISECT_TERMS"
-}
-
check_and_set_terms () {
cmd="$1"
case "$cmd" in
@@ -582,13 +570,17 @@ check_and_set_terms () {
bad|good)
if ! test -s "$GIT_DIR/BISECT_TERMS"
then
- write_terms bad good
+ TERM_BAD=bad
+ TERM_GOOD=good
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
fi
;;
new|old)
if ! test -s "$GIT_DIR/BISECT_TERMS"
then
- write_terms new old
+ TERM_BAD=new
+ TERM_GOOD=old
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
fi
;;
esac ;;
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 26/27] bisect--helper: retire `--bisect-auto-next` subcommand
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (10 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 13/27] bisect--helper: `bisect_start` shell function partially in C Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 05/27] t6030: explicitly test for bisection cleanup Pranit Bauva
` (16 subsequent siblings)
28 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
The `--bisect-auto-next` subcommand is no longer used in the shell
script and the function `bisect_auto_next` is called from the C
implementation.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 10 ----------
1 file changed, 10 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index a89e2f7..7577b69e 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -26,7 +26,6 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect start [--term-{old,good}=<term> --term-{new,bad}=<term>]"
"[--no-checkout] [<bad> [<good>...]] [--] [<paths>...]"),
N_("git bisect--helper --bisect-next"),
- N_("git bisect--helper --bisect-auto-next"),
N_("git bisect--helper --bisect-state (bad|new) [<rev>]"),
N_("git bisect--helper --bisect-state (good|old) [<rev>...]"),
N_("git bisect--helper --bisect-replay <filename>"),
@@ -972,7 +971,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_TERMS,
BISECT_START,
BISECT_NEXT,
- BISECT_AUTO_NEXT,
BISECT_STATE,
BISECT_LOG,
BISECT_REPLAY
@@ -989,8 +987,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("start the bisect session"), BISECT_START),
OPT_CMDMODE(0, "bisect-next", &cmdmode,
N_("find the next bisection commit"), BISECT_NEXT),
- OPT_CMDMODE(0, "bisect-auto-next", &cmdmode,
- N_("verify the next bisection state then find the next bisection state"), BISECT_AUTO_NEXT),
OPT_CMDMODE(0, "bisect-state", &cmdmode,
N_("mark the state of ref (or refs)"), BISECT_STATE),
OPT_CMDMODE(0, "bisect-log", &cmdmode,
@@ -1040,12 +1036,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
get_terms(&terms);
res = bisect_next(&terms, prefix);
break;
- case BISECT_AUTO_NEXT:
- if (argc)
- die(_("--bisect-auto-next requires 0 arguments"));
- get_terms(&terms);
- res = bisect_auto_next(&terms, prefix);
- break;
case BISECT_STATE:
if (argc == 0)
die(_("--bisect-state requires at least 1 argument"));
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 02/27] bisect: rewrite `check_term_format` shell function in C
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 09/27] bisect--helper: `bisect_write` shell function in C Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 23/27] bisect--helper: retire `--bisect-write` subcommand Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 20/27] bisect--helper: retire `--write-terms` subcommand Pranit Bauva
` (25 subsequent siblings)
28 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
Reimplement the `check_term_format` shell function in C and add
a `--check-term-format` subcommand to `git bisect--helper` to call it
from git-bisect.sh
Using `--check-term-format` subcommand is a temporary measure to port
shell function to C so as to use the existing test suite. As more
functions are ported, this subcommand will be retired and its
implementation will be called by some other method/subcommand. For
eg. In conversion of write_terms() of git-bisect.sh, the subcommand will
be removed and instead check_term_format() will be called in its C
implementation while a new subcommand will be introduced for write_terms().
Helped-by: Johannes Schindelein <Johannes.Schindelein@gmx.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 60 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 31 ++-----------------------
2 files changed, 61 insertions(+), 30 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 8111c91..a47f1f2 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -2,19 +2,73 @@
#include "cache.h"
#include "parse-options.h"
#include "bisect.h"
+#include "refs.h"
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
+ N_("git bisect--helper --check-term-format <term> <orig_term>"),
NULL
};
+/*
+ * 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",
+ "visualize", "replay", "log", "run", NULL))
+ 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;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
- enum { NEXT_ALL = 1 } cmdmode = 0;
+ enum {
+ NEXT_ALL = 1,
+ CHECK_TERM_FMT
+ } cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
+ OPT_CMDMODE(0, "check-term-format", &cmdmode,
+ N_("check format of the term"), CHECK_TERM_FMT),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -29,6 +83,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
switch (cmdmode) {
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
+ case CHECK_TERM_FMT:
+ if (argc != 2)
+ die(_("--check-term-format requires two arguments"));
+ return check_term_format(argv[0], argv[1]);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index ae3cb01..a727c59 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -564,38 +564,11 @@ write_terms () {
then
die "$(gettext "please use two different terms")"
fi
- check_term_format "$TERM_BAD" bad
- check_term_format "$TERM_GOOD" good
+ git bisect--helper --check-term-format "$TERM_BAD" bad || exit
+ git bisect--helper --check-term-format "$TERM_GOOD" good || exit
printf '%s\n%s\n' "$TERM_BAD" "$TERM_GOOD" >"$GIT_DIR/BISECT_TERMS"
}
-check_term_format () {
- term=$1
- git check-ref-format refs/bisect/"$term" ||
- die "$(eval_gettext "'\$term' is not a valid term")"
- case "$term" in
- help|start|terms|skip|next|reset|visualize|replay|log|run)
- die "$(eval_gettext "can't use the builtin command '\$term' as a term")"
- ;;
- bad|new)
- if test "$2" != bad
- then
- # 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.
- die "$(eval_gettext "can't change the meaning of term '\$term'")"
- fi
- ;;
- good|old)
- if test "$2" != good
- then
- die "$(eval_gettext "can't change the meaning of term '\$term'")"
- fi
- ;;
- esac
-}
-
check_and_set_terms () {
cmd="$1"
case "$cmd" in
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 08/27] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (20 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 24/27] bisect--helper: retire `--check-and-set-terms` subcommand Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-24 22:13 ` Junio C Hamano
2016-08-23 11:53 ` [PATCH v14 03/27] bisect--helper: `write_terms` " Pranit Bauva
` (6 subsequent siblings)
28 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
Reimplement `is_expected_rev` & `check_expected_revs` shell function in
C and add a `--check-expected-revs` subcommand to `git bisect--helper` to
call it from git-bisect.sh .
Using `--check-expected-revs` subcommand is a temporary measure to port
shell functions to C so as to use the existing test suite. As more
functions are ported, this subcommand would be retired but its
implementation will be called by some other method.
Helped-by: Eric Sunshine <sunshine@sunshineco.com>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 33 ++++++++++++++++++++++++++++++++-
git-bisect.sh | 20 ++------------------
2 files changed, 34 insertions(+), 19 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 9aba094..711be75 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -123,13 +123,40 @@ static int bisect_reset(const char *commit)
return bisect_clean_state();
}
+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) >= 0) {
+ strbuf_trim(&actual_hex);
+ res = !strcmp(actual_hex.buf, expected_hex);
+ }
+ strbuf_release(&actual_hex);
+ return res;
+}
+
+static int 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());
+ return 0;
+ }
+ }
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
WRITE_TERMS,
BISECT_CLEAN_STATE,
- BISECT_RESET
+ BISECT_RESET,
+ CHECK_EXPECTED_REVS
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -141,6 +168,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
N_("reset the bisection state"), BISECT_RESET),
+ OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
+ N_("check for expected revs"), CHECK_EXPECTED_REVS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -167,6 +196,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc > 1)
die(_("--bisect-reset requires either zero or one arguments"));
return bisect_reset(argc ? argv[0] : NULL);
+ case CHECK_EXPECTED_REVS:
+ return check_expected_revs(argv, argc);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 442397b..c3e43248 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -237,22 +237,6 @@ bisect_write() {
test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
}
-is_expected_rev() {
- test -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
- test "$1" = $(cat "$GIT_DIR/BISECT_EXPECTED_REV")
-}
-
-check_expected_revs() {
- for _rev in "$@"; do
- if ! is_expected_rev "$_rev"
- then
- rm -f "$GIT_DIR/BISECT_ANCESTORS_OK"
- rm -f "$GIT_DIR/BISECT_EXPECTED_REV"
- return
- fi
- done
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -280,7 +264,7 @@ bisect_state() {
rev=$(git rev-parse --verify "$bisected_head") ||
die "$(eval_gettext "Bad rev input: \$bisected_head")"
bisect_write "$state" "$rev"
- check_expected_revs "$rev" ;;
+ git bisect--helper --check-expected-revs "$rev" ;;
2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
shift
hash_list=''
@@ -294,7 +278,7 @@ bisect_state() {
do
bisect_write "$state" "$rev"
done
- check_expected_revs $hash_list ;;
+ git bisect--helper --check-expected-revs $hash_list ;;
*,"$TERM_BAD")
die "$(eval_gettext "'git bisect \$TERM_BAD' can take only one argument.")" ;;
*)
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 22/27] bisect--helper: `bisect_replay` shell function in C
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (17 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 17/27] bisect--helper: `bisect_autostart` " Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-26 23:24 ` Junio C Hamano
2016-08-23 11:53 ` [PATCH v14 21/27] bisect--helper: `bisect_log` " Pranit Bauva
` (9 subsequent siblings)
28 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
Reimplement the `bisect_replay` shell function in C and also add
`--bisect-replay` subcommand to `git bisect--helper` to call it from
git-bisect.sh
Using `--bisect-replay` subcommand is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other method.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 100 ++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 32 +--------------
2 files changed, 100 insertions(+), 32 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index b57b0c8..9c1108d 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -32,6 +32,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-autostart"),
N_("git bisect--helper --bisect-state (bad|new) [<rev>]"),
N_("git bisect--helper --bisect-state (good|old) [<rev>...]"),
+ N_("git bisect--helper --bisect-replay <filename>"),
NULL
};
@@ -879,6 +880,93 @@ static int bisect_log(void)
return 0;
}
+static int get_next_word(struct strbuf *line, struct strbuf *word)
+{
+ int i;
+ for (i = 0; line->buf[i] != ' ' && line->buf[i] != '\0'; i++)
+ strbuf_addch(word, line->buf[i]);
+
+ return 0;
+}
+
+static int bisect_replay(struct bisect_terms *terms, const char *filename)
+{
+ struct strbuf line = STRBUF_INIT;
+ FILE *fp;
+
+ if (is_empty_or_missing_file(filename))
+ die(_("no such file with name '%s' exists"), filename);
+
+ if (bisect_reset(NULL))
+ return -1;
+
+ fp = fopen(filename, "r");
+
+ while (strbuf_getline(&line, fp) != EOF) {
+ struct strbuf command = STRBUF_INIT;
+ if (starts_with(line.buf, "git bisect ") ||
+ starts_with(line.buf, "git-bisect "))
+ strbuf_remove(&line, 0, 11);
+ else
+ continue;
+
+ get_terms(terms);
+ get_next_word(&line, &command);
+ if (check_and_set_terms(terms, command.buf)) {
+ strbuf_release(&line);
+ strbuf_release(&command);
+ }
+
+ if (line.buf[command.len] != '\0')
+ strbuf_remove(&line, 0, command.len + 1);
+ else
+ strbuf_remove(&line, 0, command.len);
+
+ if (!strcmp(command.buf, "start")) {
+ struct argv_array argv = ARGV_ARRAY_INIT;
+ sq_dequote_to_argv_array(line.buf, &argv);
+ if (bisect_start(terms, 0, argv.argv, argv.argc)) {
+ strbuf_release(&command);
+ strbuf_release(&line);
+ argv_array_clear(&argv);
+ return -1;
+ }
+ argv_array_clear(&argv);
+ continue;
+ }
+
+ if (one_of(command.buf, terms->term_good.buf,
+ terms->term_bad.buf, "skip", NULL)) {
+ if (bisect_write(command.buf, line.buf, terms, 0)) {
+ strbuf_release(&command);
+ strbuf_release(&line);
+ return -1;
+ }
+ continue;
+ }
+
+ if (!strcmp(command.buf, "terms")) {
+ struct argv_array argv = ARGV_ARRAY_INIT;
+ sq_dequote_to_argv_array(line. buf, &argv);
+ if (bisect_terms(terms, argv.argv, argv.argc)) {
+ strbuf_release(&command);
+ strbuf_release(&line);
+ argv_array_clear(&argv);
+ return -1;
+ }
+ argv_array_clear(&argv);
+ continue;
+ }
+
+ strbuf_release(&command);
+ strbuf_release(&line);
+ die(_("?? what are you talking about?"));
+ }
+ strbuf_release(&line);
+
+ return bisect_auto_next(terms, NULL);
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -892,7 +980,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_AUTO_NEXT,
BISECT_AUTOSTART,
BISECT_STATE,
- BISECT_LOG
+ BISECT_LOG,
+ BISECT_REPLAY
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -918,6 +1007,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("mark the state of ref (or refs)"), BISECT_STATE),
OPT_CMDMODE(0, "bisect-log", &cmdmode,
N_("output the contents of BISECT_LOG"), BISECT_LOG),
+ OPT_CMDMODE(0, "bisect-replay", &cmdmode,
+ N_("replay the bisection process from the given file"), BISECT_REPLAY),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -1001,6 +1092,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
die(_("--bisect-log requires 0 arguments"));
res = bisect_log();
break;
+ case BISECT_REPLAY:
+ if (argc != 1)
+ die(_("--bisect-replay requires 1 argument"));
+ strbuf_addstr(&terms.term_good, "good");
+ strbuf_addstr(&terms.term_bad, "bad");
+ res = bisect_replay(&terms, argv[0]);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index a47e3b5..bf66ee2 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -77,36 +77,6 @@ bisect_visualize() {
eval '"$@"' --bisect -- $(cat "$GIT_DIR/BISECT_NAMES")
}
-bisect_replay () {
- file="$1"
- test "$#" -eq 1 || die "$(gettext "No logfile given")"
- test -r "$file" || die "$(eval_gettext "cannot read \$file for replaying")"
- git bisect--helper --bisect-reset || exit
- while read git bisect command rev
- do
- test "$git $bisect" = "git bisect" || test "$git" = "git-bisect" || continue
- if test "$git" = "git-bisect"
- then
- rev="$command"
- command="$bisect"
- fi
- get_terms
- git bisect--helper --check-and-set-terms "$command" "$TERM_GOOD" "$TERM_BAD" || exit
- get_terms
- case "$command" in
- start)
- eval "git bisect--helper --bisect-start $rev" ;;
- "$TERM_GOOD"|"$TERM_BAD"|skip)
- git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
- terms)
- git bisect--helper --bisect-terms $rev || exit;;
- *)
- die "$(gettext "?? what are you talking about?")" ;;
- esac
- done <"$file"
- git bisect--helper --bisect-auto-next
-}
-
bisect_run () {
git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD fail || exit
@@ -201,7 +171,7 @@ case "$#" in
reset)
git bisect--helper --bisect-reset "$@" ;;
replay)
- bisect_replay "$@" ;;
+ git bisect--helper --bisect-replay "$@" ;;
log)
git bisect--helper --bisect-log ;;
run)
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v14 11/27] bisect--helper: `bisect_next_check` & bisect_voc shell function in C
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (12 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 05/27] t6030: explicitly test for bisection cleanup Pranit Bauva
@ 2016-08-23 11:53 ` Pranit Bauva
2016-08-24 22:40 ` Junio C Hamano
2016-08-23 11:53 ` [PATCH v14 25/27] bisect--helper: retire `--bisect-autostart` subcommand Pranit Bauva
` (14 subsequent siblings)
28 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 11:53 UTC (permalink / raw)
To: git
Reimplement `bisect_next_check` shell function in C and add
`bisect-next-check` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Also reimplement `bisect_voc` shell function in C and call it from
`bisect_next_check` implementation in C.
Using `--bisect-next-check` is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by some other methods.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 103 ++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 60 ++-------------------------
2 files changed, 106 insertions(+), 57 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 450426c..aca3908 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -6,6 +6,7 @@
#include "dir.h"
#include "argv-array.h"
#include "run-command.h"
+#include "prompt.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
@@ -21,6 +22,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
+ N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
NULL
};
@@ -253,6 +255,95 @@ static int check_and_set_terms(struct bisect_terms *terms, const char *cmd)
return 0;
}
+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;
+}
+
+static char *bisect_voc(char *revision_type)
+{
+ if (!strcmp(revision_type, "bad"))
+ return "bad|new";
+ if (!strcmp(revision_type, "good"))
+ return "good|old";
+
+ return NULL;
+}
+
+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.buf);
+ char *good_glob = xstrfmt("%s-*", terms->term_good.buf);
+ char *bad_syn, *good_syn;
+
+ if (ref_exists(bad_ref))
+ missing_bad = 0;
+ free(bad_ref);
+
+ for_each_glob_ref_in(mark_good, good_glob, "refs/bisect/",
+ (void *) &missing_good);
+ free(good_glob);
+
+ if (!missing_good && !missing_bad)
+ return 0;
+
+ if (!current_term)
+ return -1;
+
+ if (missing_good && !missing_bad && current_term &&
+ !strcmp(current_term, terms->term_good.buf)) {
+ char *yesno;
+ /*
+ * have bad (or new) but not good (or old). We could bisect
+ * although this is less optimum.
+ */
+ fprintf(stderr, _("Warning: bisecting only with a %s commit\n"),
+ terms->term_bad.buf);
+ if (!isatty(0))
+ return 0;
+ /*
+ * 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"))
+ return -1;
+
+ return 0;
+ }
+ bad_syn = xstrdup(bisect_voc("bad"));
+ good_syn = xstrdup(bisect_voc("good"));
+ if (!is_empty_or_missing_file(git_path_bisect_start())) {
+ error(_("You need to give me at least one %s and "
+ "%s revision. You can use \"git bisect %s\" "
+ "and \"git bisect %s\" for that. \n"),
+ bad_syn, good_syn, bad_syn, good_syn);
+ free(bad_syn);
+ free(good_syn);
+ return -1;
+ }
+ else {
+ error(_("You need to start by \"git bisect start\". You "
+ "then need to give me at least one %s and %s "
+ "revision. You can use \"git bisect %s\" and "
+ "\"git bisect %s\" for that.\n"),
+ good_syn, bad_syn, bad_syn, good_syn);
+ free(bad_syn);
+ free(good_syn);
+ return -1;
+ }
+ free(bad_syn);
+ free(good_syn);
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -262,7 +353,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_RESET,
CHECK_EXPECTED_REVS,
BISECT_WRITE,
- CHECK_AND_SET_TERMS
+ CHECK_AND_SET_TERMS,
+ BISECT_NEXT_CHECK
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -280,6 +372,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
+ OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
+ N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -330,6 +424,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
strbuf_addstr(&terms.term_bad, argv[2]);
res = check_and_set_terms(&terms, argv[0]);
break;
+ case BISECT_NEXT_CHECK:
+ if (argc != 2 && argc != 3)
+ die(_("--bisect-next-check requires 2 or 3 arguments"));
+ strbuf_addstr(&terms.term_good, argv[0]);
+ strbuf_addstr(&terms.term_bad, argv[1]);
+ res = bisect_next_check(&terms, argc == 3 ? argv[2] : NULL);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index bdf2227..fe6c9d0 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -271,59 +271,14 @@ bisect_state() {
bisect_auto_next
}
-bisect_next_check() {
- missing_good= missing_bad=
- git show-ref -q --verify refs/bisect/$TERM_BAD || missing_bad=t
- test -n "$(git for-each-ref "refs/bisect/$TERM_GOOD-*")" || missing_good=t
-
- case "$missing_good,$missing_bad,$1" in
- ,,*)
- : have both $TERM_GOOD and $TERM_BAD - ok
- ;;
- *,)
- # do not have both but not asked to fail - just report.
- false
- ;;
- t,,"$TERM_GOOD")
- # have bad (or new) but not good (or old). we could bisect although
- # this is less optimum.
- eval_gettextln "Warning: bisecting only with a \$TERM_BAD commit." >&2
- if test -t 0
- then
- # TRANSLATORS: Make sure to include [Y] and [n] in your
- # translation. The program will only accept English input
- # at this point.
- gettext "Are you sure [Y/n]? " >&2
- read yesno
- case "$yesno" in [Nn]*) exit 1 ;; esac
- fi
- : bisect without $TERM_GOOD...
- ;;
- *)
- bad_syn=$(bisect_voc bad)
- good_syn=$(bisect_voc good)
- if test -s "$GIT_DIR/BISECT_START"
- then
-
- eval_gettextln "You need to give me at least one \$bad_syn and one \$good_syn revision.
-(You can use \"git bisect \$bad_syn\" and \"git bisect \$good_syn\" for that.)" >&2
- else
- eval_gettextln "You need to start by \"git bisect start\".
-You then need to give me at least one \$good_syn and one \$bad_syn revision.
-(You can use \"git bisect \$bad_syn\" and \"git bisect \$good_syn\" for that.)" >&2
- fi
- exit 1 ;;
- esac
-}
-
bisect_auto_next() {
- bisect_next_check && bisect_next || :
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD && bisect_next || :
}
bisect_next() {
case "$#" in 0) ;; *) usage ;; esac
bisect_autostart
- bisect_next_check $TERM_GOOD
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD $TERM_GOOD|| exit
# Perform all bisection computation, display and checkout
git bisect--helper --next-all $(test -f "$GIT_DIR/BISECT_HEAD" && echo --no-checkout)
@@ -355,7 +310,7 @@ bisect_next() {
}
bisect_visualize() {
- bisect_next_check fail
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD fail || exit
if test $# = 0
then
@@ -409,7 +364,7 @@ bisect_replay () {
}
bisect_run () {
- bisect_next_check fail
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD fail || exit
while true
do
@@ -482,13 +437,6 @@ get_terms () {
fi
}
-bisect_voc () {
- case "$1" in
- bad) echo "bad|new" ;;
- good) echo "good|old" ;;
- esac
-}
-
bisect_terms () {
get_terms
if ! test -s "$GIT_DIR/BISECT_TERMS"
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* Re: [PATCH v14 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (25 preceding siblings ...)
2016-08-23 11:53 ` [PATCH v14 04/27] bisect--helper: `bisect_clean_state` shell function in C Pranit Bauva
@ 2016-08-23 20:28 ` Junio C Hamano
2016-08-23 21:07 ` Pranit Bauva
2016-08-23 21:24 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
28 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-23 20:28 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> `--next-all` is meant to be used as a subcommand to support multiple
> "operation mode" though the current implementation does not contain any
> other subcommand along side with `--next-all` but further commits will
> include some more subcommands.
>
> Helped-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
> Mentored-by: Lars Schneider <larsxschneider@gmail.com>
> Mentored-by: Christian Couder <chriscool@tuxfamily.org>
> Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
> ---
A series this size really needs a cover letter that describes what
changes were made relative to the previous round to help reviewers.
I also noticed something curious. All of your messages are dated
Date: Tue, 23 Aug 2016 11:53:53 +0000
and I think that is the same as all the previous series, but how are
you sending your patches? The reason why I ask is because this does
not allow readers to tell their mail reader to sort messages by the
sender's timestamp in order to see the messages in order (as a
matter of fact, git-send-email knows that readers are helped by this
feature, and backdates the first message of 10 patch series by 10
seconds, stamps the second message as later than the first by one
second, etc. to help them).
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2016-08-23 20:28 ` [PATCH v14 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Junio C Hamano
@ 2016-08-23 21:07 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 21:07 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List, Roberto Tyley, Roberto Tyley
Hey Junio,
On Wed, Aug 24, 2016 at 1:58 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> `--next-all` is meant to be used as a subcommand to support multiple
>> "operation mode" though the current implementation does not contain any
>> other subcommand along side with `--next-all` but further commits will
>> include some more subcommands.
>>
>> Helped-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
>> Mentored-by: Lars Schneider <larsxschneider@gmail.com>
>> Mentored-by: Christian Couder <chriscool@tuxfamily.org>
>> Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
>> ---
>
> A series this size really needs a cover letter that describes what
> changes were made relative to the previous round to help reviewers.
I am actually using SubmitGit these days as I am back in my campus and
IMAP/SMTP connections are blocked here. SubmitGit doesn't have the
option to include a cover letter. Though I can describe the changes by
including a separate email as a reply to 1st patch. I will send the
changes according to v12 since v13 wasn't commented on.
> I also noticed something curious. All of your messages are dated
>
> Date: Tue, 23 Aug 2016 11:53:53 +0000
>
> and I think that is the same as all the previous series, but how are
> you sending your patches? The reason why I ask is because this does
> not allow readers to tell their mail reader to sort messages by the
> sender's timestamp in order to see the messages in order (as a
> matter of fact, git-send-email knows that readers are helped by this
> feature, and backdates the first message of 10 patch series by 10
> seconds, stamps the second message as later than the first by one
> second, etc. to help them).
This might be a bug in SubmitGit. I didn't notice this previously.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (26 preceding siblings ...)
2016-08-23 20:28 ` [PATCH v14 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Junio C Hamano
@ 2016-08-23 21:24 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
28 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-23 21:24 UTC (permalink / raw)
To: Git List
Hey everyone,
Sending a "cover letter" to this series.
Changes with wrt v12[1] are:
* Rebased on v2.10-rc0
* Two function signatures had changed while the topic
develop so changed those.
* Correct the "mark for translation" messages properly as
I had previously used N_() in some places but I had to
actually use _().
* In the patch 04/27[2], bisect_clean_state() is put in bisect.c
rather than builtin/bisect--helper.c because I will need it
further when porting bisect_next() function.
* The patches from 14th are completely new to the series.
They port even more functions and remove some then unused
subcommands.
* 14th patch[3] is a tricky one as it changes a lot of things. I am
not sure whether to put this all in one patch or split it.
[1]: http://public-inbox.org/git/010201567675adc1-17e27495-6b36-40d1-836d-814da029fcc4-000000@eu-west-1.amazonses.com/
[2]: http://public-inbox.org/git/01020156b73fe66f-bfad6316-39d4-4577-8f75-d1b4b2031263-000000@eu-west-1.amazonses.com/
[3]: http://public-inbox.org/git/01020156b73fe6ce-3b204354-849b-40fd-93ff-2ebcf77df91c-000000@eu-west-1.amazonses.com/
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 04/27] bisect--helper: `bisect_clean_state` shell function in C
2016-08-23 11:53 ` [PATCH v14 04/27] bisect--helper: `bisect_clean_state` shell function in C Pranit Bauva
@ 2016-08-24 20:58 ` Junio C Hamano
0 siblings, 0 replies; 320+ messages in thread
From: Junio C Hamano @ 2016-08-24 20:58 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> Reimplement `bisect_clean_state` shell function in C and add a
> `bisect-clean-state` subcommand to `git bisect--helper` to call it from
> git-bisect.sh .
>
> Using `--bisect-clean-state` subcommand is a measure to port shell
> function to C so as to use the existing test suite. As more functions
> are ported, this subcommand will be retired but its implementation will
> be called by bisect_reset() and bisect_start().
>
> Mentored-by: Lars Schneider <larsxschneider@gmail.com>
> Mentored-by: Christian Couder <chriscool@tuxfamily.org>
> Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
> ---
This seems to be where this round diverges from the previous one.
This patch in this round has more stuff that used to be in
builtin/bisect--helper.c in the previous one in bisect.c. Because I
am not sure if the distinction would make that much of a difference
(after all, I do not think of a good reason why many bisect internals
need to be exposed to anything other than the eventual builtin/bisect.c
that retires git-bisect.sh), I am OK with the change to this patch
between the previous round and this round.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 07/27] bisect--helper: `bisect_reset` shell function in C
2016-08-23 11:53 ` [PATCH v14 07/27] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
@ 2016-08-24 21:12 ` Junio C Hamano
2016-08-26 13:46 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-24 21:12 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> +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) {
Hmm, tricky but correct to do the "< 1" comparison. If the file
does not exist, you'd get -1; if it fails to read it, you'd get -1;
if it turns out to be empty, you'd get 0.
> + printf("We are not bisecting.\n");
> + return 0;
> + }
> + strbuf_rtrim(&branch);
> + } else {
> + struct object_id oid;
> + if (get_oid(commit, &oid))
> + return error(_("'%s' is not a valid commit"), commit);
The original is
rev-parse --quiet --verify "$1^{commit}"
Unless the caller of this function already appended "^{commit}" to
whatever the user gave "bisect--helper bisect-reset", this
conversion is not equivalent. If you said
git bisect reset HEAD:
get_oid() would tell you that the top-level tree object of the
current commit exists in the object store, but the original is
meant to catch "That's not a commit, it's a tree!" before attempting
to run "git checkout" on it.
I think get_sha1_committish() is what you want to use here.
> + strbuf_addstr(&branch, commit);
> + }
Also this version fails to catch "bisect reset a b c" as an error, I
suspect.
> @@ -627,7 +603,7 @@ case "$#" in
> visualize|view)
> bisect_visualize "$@" ;;
> reset)
> - bisect_reset "$@" ;;
> + git bisect--helper --bisect-reset "$@" ;;
> replay)
> bisect_replay "$@" ;;
> log)
>
> --
> https://github.com/git/git/pull/287
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 08/27] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C
2016-08-23 11:53 ` [PATCH v14 08/27] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C Pranit Bauva
@ 2016-08-24 22:13 ` Junio C Hamano
2016-08-27 9:14 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-24 22:13 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> +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) >= 0) {
> + strbuf_trim(&actual_hex);
> + res = !strcmp(actual_hex.buf, expected_hex);
If it is known to have 40-hex:
(1) accepting ">= 0" seems way too lenient. You only expect a
41-byte file (or 42 if somebody would write CRLF, but I do not
think anybody other than yourself is expected to write into
this file, and you do not write CRLF yourself);
(2) strbuf_trim() is overly loose. You only want to trim the
terimnating LF and it is an error to have other trailing
whitespaces.
I think the latter is not a new problem and it is OK to leave it
as-is; limiting (1) to >= 40 may still be a good change, though,
because it makes the intention of the code clearer.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 09/27] bisect--helper: `bisect_write` shell function in C
2016-08-23 11:53 ` [PATCH v14 09/27] bisect--helper: `bisect_write` shell function in C Pranit Bauva
@ 2016-08-24 22:30 ` Junio C Hamano
2016-08-27 9:33 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-24 22:30 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> +struct bisect_terms {
> + struct strbuf term_good;
> + struct strbuf term_bad;
> +};
I think "struct strbuf" is overrated. For things like this, where
these fields will never change once it is set (and setting it is
done atomically, not incrementally), there is no good reason to use
define the fields as strbuf.
Only because you chose to use strbuf for these two fields, you have
to make unnecessarily copies of argv[] in the command parser, and
you have to remember to discard these copies later.
I think you can just say "const char *" in this case.
> +static int bisect_write(const char *state, const char *rev,
> + const struct bisect_terms *terms, int nolog)
> +{
> + struct strbuf tag = STRBUF_INIT;
> + struct strbuf commit_name = STRBUF_INIT;
> + struct object_id oid;
> + struct commit *commit;
> + struct pretty_print_context pp = {0};
> + FILE *fp;
> +
> + if (!strcmp(state, terms->term_bad.buf))
> + strbuf_addf(&tag, "refs/bisect/%s", state);
> + else if (one_of(state, terms->term_good.buf, "skip", NULL))
> + strbuf_addf(&tag, "refs/bisect/%s-%s", state, rev);
> + else
> + return error(_("Bad bisect_write argument: %s"), state);
OK.
> + if (get_oid(rev, &oid)) {
> + strbuf_release(&tag);
> + return error(_("couldn't get the oid of the rev '%s'"), rev);
> + }
> +
> + if (update_ref(NULL, tag.buf, oid.hash, NULL, 0,
> + UPDATE_REFS_MSG_ON_ERR)) {
> + strbuf_release(&tag);
> + return -1;
> + }
> + strbuf_release(&tag);
> +
> + fp = fopen(git_path_bisect_log(), "a");
> + if (!fp)
> + return error_errno(_("couldn't open the file '%s'"), git_path_bisect_log());
> +
> + commit = lookup_commit_reference(oid.hash);
> + format_commit_message(commit, "%s", &commit_name, &pp);
> + fprintf(fp, "# %s: [%s] %s\n", state, sha1_to_hex(oid.hash),
> + commit_name.buf);
> + strbuf_release(&commit_name);
> +
> + if (!nolog)
> + fprintf(fp, "git bisect %s %s\n", state, rev);
> +
> + fclose(fp);
> + return 0;
You seem to be _release()ing tag all over the place.
Would it make sense to have a single clean-up label at the end of
function, introduce a "int retval" variable and set it to -1 (or
whatever) when an error is detected and "goto" to the label? It may
make it harder to make such a leak. That is, to end the function
more like:
finish:
if (fp)
fclose(fp);
strbuf_release(&tag);
strbuf_release(&commit_name);
return retval;
}
and have sites with potential errors do something like this:
if (update_ref(...)) {
retval = -1;
goto finish;
}
> + struct bisect_terms terms;
> + bisect_terms_init(&terms);
With the type of "struct bisect_terms" members corrected, you do not
even need the _init() function.
> @@ -182,24 +251,38 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> usage_with_options(git_bisect_helper_usage, options);
>
> switch (cmdmode) {
> + int nolog;
> case NEXT_ALL:
> return bisect_next_all(prefix, no_checkout);
> case WRITE_TERMS:
> if (argc != 2)
> die(_("--write-terms requires two arguments"));
> - return write_terms(argv[0], argv[1]);
> + res = write_terms(argv[0], argv[1]);
> + break;
> case BISECT_CLEAN_STATE:
> if (argc != 0)
> die(_("--bisect-clean-state requires no arguments"));
> - return bisect_clean_state();
> + res = bisect_clean_state();
> + break;
> case BISECT_RESET:
> if (argc > 1)
> die(_("--bisect-reset requires either zero or one arguments"));
> - return bisect_reset(argc ? argv[0] : NULL);
> + res = bisect_reset(argc ? argv[0] : NULL);
> + break;
> case CHECK_EXPECTED_REVS:
> - return check_expected_revs(argv, argc);
> + res = check_expected_revs(argv, argc);
> + break;
> + case BISECT_WRITE:
> + if (argc != 4 && argc != 5)
> + die(_("--bisect-write requires either 4 or 5 arguments"));
> + nolog = (argc == 5) && !strcmp(argv[4], "nolog");
> + strbuf_addstr(&terms.term_good, argv[2]);
> + strbuf_addstr(&terms.term_bad, argv[3]);
Here,
terms.term_good = argv[2];
terms.term_bad = argv[3];
and then you do not need bisect_terms_release() at all.
> + res = bisect_write(argv[0], argv[1], &terms, nolog);
> + break;
> default:
> die("BUG: unknown subcommand '%d'", cmdmode);
> }
> - return 0;
> + bisect_terms_release(&terms);
> + return res;
> }
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 11/27] bisect--helper: `bisect_next_check` & bisect_voc shell function in C
2016-08-23 11:53 ` [PATCH v14 11/27] bisect--helper: `bisect_next_check` & bisect_voc shell function in C Pranit Bauva
@ 2016-08-24 22:40 ` Junio C Hamano
2016-08-27 9:35 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-24 22:40 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> +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;
> +}
> +
> +static char *bisect_voc(char *revision_type)
> +{
> + if (!strcmp(revision_type, "bad"))
> + return "bad|new";
> + if (!strcmp(revision_type, "good"))
> + return "good|old";
> +
> + return NULL;
> +}
> +
> +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.buf);
> + char *good_glob = xstrfmt("%s-*", terms->term_good.buf);
> + char *bad_syn, *good_syn;
> +
> + if (ref_exists(bad_ref))
> + missing_bad = 0;
> + free(bad_ref);
> +
> + for_each_glob_ref_in(mark_good, good_glob, "refs/bisect/",
> + (void *) &missing_good);
> + free(good_glob);
> +
> + if (!missing_good && !missing_bad)
> + return 0;
> +
> + if (!current_term)
> + return -1;
> +
> + if (missing_good && !missing_bad && current_term &&
> + !strcmp(current_term, terms->term_good.buf)) {
> + char *yesno;
> + /*
> + * have bad (or new) but not good (or old). We could bisect
> + * although this is less optimum.
> + */
> + fprintf(stderr, _("Warning: bisecting only with a %s commit\n"),
> + terms->term_bad.buf);
> + if (!isatty(0))
> + return 0;
> + /*
> + * 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"))
> + return -1;
> +
> + return 0;
> + }
> + bad_syn = xstrdup(bisect_voc("bad"));
> + good_syn = xstrdup(bisect_voc("good"));
> + if (!is_empty_or_missing_file(git_path_bisect_start())) {
> + error(_("You need to give me at least one %s and "
> + "%s revision. You can use \"git bisect %s\" "
> + "and \"git bisect %s\" for that. \n"),
> + bad_syn, good_syn, bad_syn, good_syn);
> + free(bad_syn);
> + free(good_syn);
> + return -1;
> + }
> + else {
> + error(_("You need to start by \"git bisect start\". You "
> + "then need to give me at least one %s and %s "
> + "revision. You can use \"git bisect %s\" and "
> + "\"git bisect %s\" for that.\n"),
> + good_syn, bad_syn, bad_syn, good_syn);
> + free(bad_syn);
> + free(good_syn);
> + return -1;
> + }
> + free(bad_syn);
> + free(good_syn);
> +
> + return 0;
This one looks OK, but I think the same "Wouldn't it become cleaner
to have a 'finish:' label at the end and jump there?" comment
applies to this implementation, too.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 12/27] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-08-23 11:53 ` [PATCH v14 12/27] bisect--helper: `get_terms` & `bisect_terms` shell function in C Pranit Bauva
@ 2016-08-25 18:05 ` Junio C Hamano
2016-08-27 9:48 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-25 18:05 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> +static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
> +{
> + int i;
> +
> + if (get_terms(terms)) {
> + fprintf(stderr, _("no terms defined\n"));
> + return -1;
> + }
> + if (argc == 0) {
> + printf(_("Your current terms are %s for the old state\nand "
> + "%s for the new state.\n"), terms->term_good.buf,
> + terms->term_bad.buf);
> + return 0;
> + }
> +
> + for (i = 0; i < argc; i++) {
> + if (!strcmp(argv[i], "--term-good"))
> + printf("%s\n", terms->term_good.buf);
> + else if (!strcmp(argv[i], "--term-bad"))
> + printf("%s\n", terms->term_bad.buf);
> + else
> + printf(_("invalid argument %s for 'git bisect "
> + "terms'.\nSupported options are: "
> + "--term-good|--term-old and "
> + "--term-bad|--term-new."), argv[i]);
> + }
The original took only one and gave one answer (and errored out when
the user asked for more), but this one loops. I can see either way
is OK and do not think of a good reason to favor one over the other;
unless there is a strong reason why you need this extended behaviour
that allows users to ask multiple questions, I'd say we should keep
the original behaviour.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 13/27] bisect--helper: `bisect_start` shell function partially in C
2016-08-23 11:53 ` [PATCH v14 13/27] bisect--helper: `bisect_start` shell function partially in C Pranit Bauva
@ 2016-08-25 19:02 ` Junio C Hamano
2016-08-25 19:43 ` Junio C Hamano
2016-08-27 19:47 ` Pranit Bauva
0 siblings, 2 replies; 320+ messages in thread
From: Junio C Hamano @ 2016-08-25 19:02 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> +static int bisect_start(struct bisect_terms *terms, int no_checkout,
> + const char **argv, int argc)
> +{
> + int i, has_double_dash = 0, must_write_terms = 0, bad_seen = 0;
> + int flags, pathspec_pos;
> + struct string_list revs = STRING_LIST_INIT_DUP;
> + struct string_list states = STRING_LIST_INIT_DUP;
The original has a single state, not states. Let's see if there is
a reason behind the name change....
> + unsigned char sha1[20];
> + struct object_id oid;
More on these below...
> + ...
> + for (i = 0; i < argc; i++) {
> + const char *commit_id = xstrfmt("%s^{commit}", argv[i]);
> + if (!strcmp(argv[i], "--")) {
> + has_double_dash = 1;
> + break;
> + } else if (!strcmp(argv[i], "--no-checkout"))
> + no_checkout = 1;
> + else if (!strcmp(argv[i], "--term-good") ||
> + ...
> + } else if (starts_with(argv[i], "--") &&
> + !one_of(argv[i], "--term-good", "--term-bad", NULL)) {
> + string_list_clear(&revs, 0);
> + string_list_clear(&states, 0);
> + die(_("unrecognised option: '%s'"), argv[i]);
> + } else if (get_oid(commit_id, &oid) && has_double_dash) {
> + string_list_clear(&revs, 0);
> + string_list_clear(&states, 0);
> + die(_("'%s' does not appear to be a valid revision"), argv[i]);
> + } else {
> + string_list_append(&revs, oid_to_hex(&oid));
> + }
> + }
What I do not understand is clearing the string list "states" inside
this loop. It may have been INIT_DUPed, but nothing in this loop
adds anything to it. Because "revs" does get extended in the loop,
it is understandable if you wanted to clear it before dying, but "if
you are dying anyway why bother clearing?" is also a valid stance to
take.
The same "perhaps want to use the 'retval' with goto 'finish:' pattern?"
comment applies here, too.
> + 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.
> + */
> + must_write_terms |= !!revs.nr;
> + for (i = 0; i < revs.nr; i++) {
> + if (bad_seen)
> + string_list_append(&states, terms->term_good.buf);
> + else {
> + bad_seen = 1;
> + string_list_append(&states, terms->term_bad.buf);
> + }
> + }
This is certainly different from the original. We used to do one
"bisect_write" per element in revs in the loop; we no longer do that
and instead collect them in states list. Each element in these two
lists, i.e. revs.item[i] and states.item[i], corresponds to each
other.
That explains why the variable is renamed to states. We haven't
seen enough to say if this behaviour change is a good idea or not.
> + /*
> + * Verify HEAD
> + */
> + head = resolve_ref_unsafe("HEAD", 0, sha1, &flags);
> + if (!head) {
> + if (get_sha1("HEAD", sha1)) {
> + string_list_clear(&revs, 0);
> + string_list_clear(&states, 0);
> + die(_("Bad HEAD - I need a HEAD"));
> + }
> + }
> + 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) {
> + struct argv_array argv = ARGV_ARRAY_INIT;
> + argv_array_pushl(&argv, "checkout", start_head.buf,
> + "--", NULL);
> + if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
> + error(_("checking out '%s' failed. Try 'git "
> + "bisect start <valid-branch>'."),
> + start_head.buf);
> + strbuf_release(&start_head);
> + string_list_clear(&revs, 0);
> + string_list_clear(&states, 0);
> + return -1;
The original died here, but you expect the caller to respond to a
negative return. I haven't read enough to judge if that is a good
idea, but doesn't it make sense to do the same throughout the
function consistently? I saw a few die()'s already in the command
line parsing loop--shouldn't they also return -1?
The original has called bisect_write already when we attempt this
checkout and the user will see the states in the filesystem. This
rewrite does not. What effect does this behaviour change have to
the end-user experience? The error message tells the end user to
run another "git bisect start" with a valid commit, and when that
happens, hopefully she will give us something we can check out, and
then we will hit the bisect_clean_state() call we see below before
starting to do anything meaningful, so I am guessing it won't, but
I just want to make sure that you thought about the ramifications
of the change above to delay calls to bisect_write.
> + }
> + }
> + } else {
> + if (starts_with(head, "refs/heads/") ||
> + !get_oid_hex(head, &oid) || ref_exists(head)) {
This ref_exists() check is new, and I think it should not be there.
In the original, if .git/HEAD pointed at refs/tags/v1.0, we would
have diagnosed it as a strange symbolic ref. This no longer does.
If you wanted to make sure that the branch exists, it should have
been
if ((starts_with(head, "refs/heads/") && ref_exists(head)) ||
!get_oid_hex(head, &oid)) {
anyway.
Also, why do you use get_oid_hex() here? You used get_sha1("HEAD",
sha1) in the early part of "Verify HEAD" above, which seems to be
perfectly adequate. That sha1 taken from get_sha1() is what you end
up using in the code below anyway. If you can stick to one or the
other, please do so.
> + /*
> + * 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())) {
> + strbuf_release(&start_head);
> + string_list_clear(&revs, 0);
> + string_list_clear(&states, 0);
> + die(_("won't bisect on cg-seek'ed tree"));
> + }
Not to be done as part of this series, but it probably is safe to
retire this part by now. Cogito has been dead for how many years?
> + if (starts_with(head, "refs/heads/")) {
> + strbuf_reset(&start_head);
> + strbuf_addstr(&start_head, head + 11);
skip_prefix?
> + }
> + else {
> + strbuf_reset(&start_head);
> + strbuf_addstr(&start_head, sha1_to_hex(sha1));
> + }
> + } else {
> + strbuf_release(&start_head);
> + string_list_clear(&revs, 0);
> + string_list_clear(&states, 0);
> + die(_("Bad HEAD - strange symbolic ref"));
> + }
> + }
I wonder the whole thing above is better restructured to avoid
repeated checks of the same thing.
if (is it 40-hex, i.e. detached?) {
stuff it to start_head;
} else if (skip_prefix(head, "refs/heads/", &branchname)) {
do the "cogito" check;
stuff it to start_head;
} else {
that's a strange symbolic ref HEAD you have there;
}
> + /*
> + * Get rid of any old bisect state.
> + */
> + if (bisect_clean_state()) {
> + return -1;
> + }
If we are going to get a lot more code inside {} in later patches,
then this single "return -1" enclosed inside a {} pair is
justifiable (but in that case we'd prefer an empty line after it to
separate it from the next comment block). Otherwise lose the {}.
> + /*
> + * 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".
> + */
That explains the "trap" statements in the original. Does it apply
to this code here?
> + /*
> + * Write new start state
> + */
> + write_file(git_path_bisect_start(), "%s\n", start_head.buf);
> +
> + if (no_checkout) {
> + get_oid(start_head.buf, &oid);
> + if (update_ref(NULL, "BISECT_HEAD", oid.hash, NULL, 0,
> + UPDATE_REFS_MSG_ON_ERR)) {
> + strbuf_release(&start_head);
> + string_list_clear(&revs, 0);
> + string_list_clear(&states, 0);
> + return -1;
> + }
> + }
> + strbuf_release(&start_head);
> +
> + if (pathspec_pos < argc - 1)
> + sq_quote_argv(&bisect_names, argv + pathspec_pos, 0);
> + write_file(git_path_bisect_names(), "%s\n", bisect_names.buf);
> + strbuf_release(&bisect_names);
> +
> + for (i = 0; i < states.nr; i++) {
> + if (bisect_write(states.items[i].string,
> + revs.items[i].string, terms, 1)) {
> + string_list_clear(&revs, 0);
> + string_list_clear(&states, 0);
> + return -1;
> + }
> + }
Hmph. I do not particuarly see why doing this in a separate loop
here, instead of doing it just like in the original, i.e. inside the
loop we already saw, is an improvement. It seems to me that the
only effect of this change is to make the code more complex by
forcing you to maintain (and clear) another string list "states" and
have a separate loop here.
Unless there is a reason why delaying calls to bisect_write() is a
good thing and I am not seeing it, that is.
> diff --git a/git-bisect.sh b/git-bisect.sh
> index d6c8b5a..f0896b3 100755
> --- a/git-bisect.sh
> +++ b/git-bisect.sh
> @@ -71,122 +71,7 @@ bisect_autostart() {
> }
>
> bisect_start() {
> -...
> + git bisect--helper --bisect-start $@ || exit
> ...
> + get_terms
Understandable. As the handling of the terms is done in the helper,
you need to read the terms it left in the filesystem. OK.
> bisect_auto_next
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 13/27] bisect--helper: `bisect_start` shell function partially in C
2016-08-25 19:02 ` Junio C Hamano
@ 2016-08-25 19:43 ` Junio C Hamano
2016-08-27 19:47 ` Pranit Bauva
1 sibling, 0 replies; 320+ messages in thread
From: Junio C Hamano @ 2016-08-25 19:43 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Junio C Hamano <gitster@pobox.com> writes:
>> + for (i = 0; i < revs.nr; i++) {
>> + if (bad_seen)
>> + string_list_append(&states, terms->term_good.buf);
>> + else {
>> + bad_seen = 1;
>> + string_list_append(&states, terms->term_bad.buf);
>> + }
>> + }
>
> This is certainly different from the original. We used to do one
> "bisect_write" per element in revs in the loop; we no longer do that
> and instead collect them in states list. Each element in these two
> lists, i.e. revs.item[i] and states.item[i], corresponds to each
> other.
>
> That explains why the variable is renamed to states. We haven't
> seen enough to say if this behaviour change is a good idea or not.
Ahh, I misread the original. It accumulates the writes to be
executed in $eval and does so at the end. So there is no change in
behaviour.
So please ignore that point in the previous message. That leaves
only the following points:
* Perhaps 'retval' with 'goto finish' pattern?
* ref_exists()? Perhaps use skip_prefix(head, "refs/heads/, &branch)?
* if (clean-state) { return -1 }?
* Is comment on trap relevant here?
Sorry, and thanks.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 14/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function in C
2016-08-23 11:53 ` [PATCH v14 14/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function in C Pranit Bauva
@ 2016-08-25 20:30 ` Junio C Hamano
2016-08-30 18:25 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-25 20:30 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> A lot of parts of bisect.c uses exit() and these signals are then
> trapped in the `bisect_start` function. Since the shell script ceases
> its existence it would be necessary to convert those exit() calls to
> return statements so that errors can be reported efficiently in C code.
Is efficiency really an issue? I think the real reason is that it
would make it impossible for the callers to handle errors, if you do
not convert and let the error codepaths exit().
> @@ -729,7 +735,7 @@ static struct commit **get_bad_and_good_commits(int *rev_nr)
> return rev;
> }
>
> -static void handle_bad_merge_base(void)
> +static int handle_bad_merge_base(void)
> {
> if (is_expected_rev(current_bad_oid)) {
> char *bad_hex = oid_to_hex(current_bad_oid);
> @@ -750,17 +756,18 @@ static void handle_bad_merge_base(void)
> "between %s and [%s].\n"),
> bad_hex, term_bad, term_good, bad_hex, good_hex);
> }
> - exit(3);
> + return 3;
> }
>
> fprintf(stderr, _("Some %s revs are not ancestor of the %s rev.\n"
> "git bisect cannot work properly in this case.\n"
> "Maybe you mistook %s and %s revs?\n"),
> term_good, term_bad, term_good, term_bad);
> - exit(1);
> + bisect_clean_state();
> + return 1;
What is the logic behind this function sometimes clean the state,
and some other times do not, when it makes an error-return? We see
above that "return 3" codepath leaves the state behind.
Either you forgot a necessary clean_state in "return 3" codepath,
or you forgot to document why the distinction exists in the in-code
comment for the function. I cannot tell which, but I am leaning
towards guessing that it is the former.
> -static void check_good_are_ancestors_of_bad(const char *prefix, int no_checkout)
> +static int check_good_are_ancestors_of_bad(const char *prefix, int no_checkout)
> {
> char *filename = git_pathdup("BISECT_ANCESTORS_OK");
> struct stat st;
> - int fd;
> + int fd, res = 0;
>
> if (!current_bad_oid)
> die(_("a %s revision is needed"), term_bad);
Can you let it die yere?
> @@ -873,8 +890,11 @@ static void check_good_are_ancestors_of_bad(const char *prefix, int no_checkout)
> filename);
> else
> close(fd);
> +
> + return 0;
> done:
> free(filename);
> + return 0;
> }
Who owns "filename"? The first "return 0" leaves it unfreed, and
when "goto done" is done, it is freed.
The above two may indicate that "perhaps 'retval + goto finish'
pattern?" is a really relevant suggestion for the earlier steps in
this series.
> if (!all) {
> fprintf(stderr, _("No testable commit found.\n"
> "Maybe you started with bad path parameters?\n"));
> - exit(4);
> + return 4;
> }
>
> bisect_rev = revs.commits->item->object.oid.hash;
>
> if (!hashcmp(bisect_rev, current_bad_oid->hash)) {
> - exit_if_skipped_commits(tried, current_bad_oid);
> + res = exit_if_skipped_commits(tried, current_bad_oid);
> + if (res)
> + return res;
> +
> printf("%s is the first %s commit\n", sha1_to_hex(bisect_rev),
> term_bad);
> show_diff_tree(prefix, revs.commits->item);
> /* This means the bisection process succeeded. */
> - exit(10);
> + return 10;
> }
>
> nr = all - reaches - 1;
> @@ -1005,7 +1033,11 @@ int bisect_next_all(const char *prefix, int no_checkout)
> "Bisecting: %d revisions left to test after this %s\n",
> nr), nr, steps_msg);
>
> - return bisect_checkout(bisect_rev, no_checkout);
> + res = bisect_checkout(bisect_rev, no_checkout);
> + if (res)
> + bisect_clean_state();
> +
> + return res;
> }
There were tons of "exit_if" that was converted to "if (res) return
res" above, instead of jumping here to cause clean_state to be
called. I cannot tell if this new call to clean_state() is wrong,
or all the earlier "return res" should come here. I am guessing the
latter.
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index c64996a..ef7b3a1 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -8,6 +8,7 @@
> #include "run-command.h"
> #include "prompt.h"
> #include "quote.h"
> +#include "revision.h"
>
> static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
> static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
> @@ -29,6 +30,8 @@ static const char * const git_bisect_helper_usage[] = {
> N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
> N_("git bisect--helper --bisect start [--term-{old,good}=<term> --term-{new,bad}=<term>]"
> "[--no-checkout] [<bad> [<good>...]] [--] [<paths>...]"),
> + N_("git bisect--helper --bisect-next"),
> + N_("git bisect--helper --bisect-auto-next"),
> NULL
> };
>
> @@ -396,6 +399,129 @@ static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
> return 0;
> }
>
> +static int register_good_ref(const char *refname,
> + const struct object_id *oid, int flags,
> + void *cb_data)
> +{
> + struct string_list *good_refs = cb_data;
> + string_list_append(good_refs, oid_to_hex(oid));
> + return 0;
> +}
> +
> +static int bisect_next(struct bisect_terms *terms, const char *prefix)
> +{
> + int res, no_checkout;
> +
> + /* In case of mistaken revs or checkout error, or signals received,
That's an unbalanced comment. You end the block with "*/" on its
own line, so you should start the block with "/*" on its own line.
There seems to be at least one more such comment in this patch but I
won't repeat.
> + * "bisect_auto_next" below may exit or misbehave.
> + * We have to trap this to be able to clean up using
> + * "bisect_clean_state".
> + */
"exit" meaning "call exit() to terminate the process", or something
else? If the latter, don't say "exit", but say "return error".
> + if (bisect_next_check(terms, terms->term_good.buf))
> + return -1;
Mental note. The "autostart" in the original is gone. Perhaps it
is done by next_check in this code, but we haven't seen that yet.
> + no_checkout = !is_empty_or_missing_file(git_path_bisect_head());
> +
> + /* Perform all bisection computation, display and checkout */
> + res = bisect_next_all(prefix , no_checkout);
> +
> + if (res == 10) {
> + FILE *fp;
> + unsigned char sha1[20];
> + struct commit *commit;
> + struct pretty_print_context pp = {0};
> + struct strbuf commit_name = STRBUF_INIT;
> + char *bad_ref = xstrfmt("refs/bisect/%s",
> + terms->term_bad.buf);
> + read_ref(bad_ref, sha1);
> + commit = lookup_commit_reference(sha1);
> + format_commit_message(commit, "%s", &commit_name, &pp);
> + fp = fopen(git_path_bisect_log(), "a");
> + if (!fp) {
> + free(bad_ref);
> + strbuf_release(&commit_name);
> + return -1;
> + }
> + if (fprintf(fp, "# first %s commit: [%s] %s\n",
> + terms->term_bad.buf, sha1_to_hex(sha1),
> + commit_name.buf) < 1){
> + free(bad_ref);
> + strbuf_release(&commit_name);
> + fclose(fp);
> + return -1;
> + }
> + free(bad_ref);
> + strbuf_release(&commit_name);
> + fclose(fp);
> + return 0;
Doesn't it bother you that you have to write free(bad_ref)...fclose(fp)
repeatedly?
> + }
> + else if (res == 2) {
> + FILE *fp;
> + struct rev_info revs;
> + struct argv_array rev_argv = ARGV_ARRAY_INIT;
> + struct string_list good_revs = STRING_LIST_INIT_DUP;
> + struct pretty_print_context pp = {0};
> + struct commit *commit;
> + char *term_good = xstrfmt("%s-*", terms->term_good.buf);
> + int i;
> +
> + fp = fopen(git_path_bisect_log(), "a");
> + if (!fp) {
> + free(term_good);
> + return -1;
> + }
> + if (fprintf(fp, "# only skipped commits left to test\n") < 1) {
> + free(term_good);
> + fclose(fp);
> + return -1;
> + }
> + for_each_glob_ref_in(register_good_ref, term_good,
> + "refs/bisect/", (void *) &good_revs);
> +
> + free(term_good);
Doesn't it bother you that you have to write free(term_good) repeatedly?
> + argv_array_pushl(&rev_argv, "skipped_commits", "refs/bisect/bad", "--not", NULL);
> + for (i = 0; i < good_revs.nr; i++)
> + argv_array_push(&rev_argv, good_revs.items[i].string);
> +
> + /* It is important to reset the flags used by revision walks
> + * as the previous call to bisect_next_all() in turn
> + * setups a revision walk.
> + */
> + reset_revision_walk();
> + init_revisions(&revs, NULL);
> + rev_argv.argc = setup_revisions(rev_argv.argc, rev_argv.argv, &revs, NULL);
> + argv_array_clear(&rev_argv);
> + string_list_clear(&good_revs, 0);
Are you sure that the revision walking machinery is prepared to see
the argv[] and elements in it you have given to setup_revisions()
gets cleared before it starts doing the real work in
prepare_revision_walk()? I am reasonably sure that the machinery
borrows strings like pathspec elements from the caller and expects
them to stay during revision traversal.
You seem to have acquired a habit of freeing and clearing things
early, which is bad. Instead, make it a habit of free/clear at the
end, and make sure all error paths go through that central freeing
site. That tends to future-proof your code better from leaking even
when later other people change it.
> + if (prepare_revision_walk(&revs)) {
> + die(_("revision walk setup failed\n"));
> + }
This one is still allowed to die, without clean_state?
> + while ((commit = get_revision(&revs)) != NULL) {
> + struct strbuf commit_name = STRBUF_INIT;
> + format_commit_message(commit, "%s",
> + &commit_name, &pp);
> + fprintf(fp, "# possible first %s commit: "
> + "[%s] %s\n", terms->term_bad.buf,
> + oid_to_hex(&commit->object.oid),
> + commit_name.buf);
> + strbuf_release(&commit_name);
> + }
> +
> + fclose(fp);
> + return res;
> + }
> +
> + return res;
> +}
> @@ -415,47 +541,67 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
> no_checkout = 1;
>
> for (i = 0; i < argc; i++) {
> - if (!strcmp(argv[i], "--")) {
> + const char *arg;
> + if (starts_with(argv[i], "'"))
> + arg = sq_dequote(xstrdup(argv[i]));
> + else
> + arg = argv[i];
> + if (!strcmp(arg, "--")) {
> has_double_dash = 1;
> break;
> }
> }
This is really bad; you are blindly assuming that anything that
begins with "'" begins with "'" because "git-bisect.sh" sq-quoted
and it never directly came from the command line that _wanted_ to
give you something that begins with a "'".
I suspect that you should be able to dequote on the calling script
side. Then all these ugliness would disappear.
> for (i = 0; i < argc; i++) {
> - const char *commit_id = xstrfmt("%s^{commit}", argv[i]);
> + const char *arg, *commit_id;
> + if (starts_with(argv[i], "'"))
> + arg = sq_dequote(xstrdup(argv[i]));
> + else
> + arg = argv[i];
Likewise.
> + commit_id = xstrfmt("%s^{commit}", arg);
In any case, I think a separate "const char *arg" that is an alias
to argv[i] in the loop is a very good idea to do from the very
beginning (i.e. should be done in a much much earlier patch in this
series).
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 07/27] bisect--helper: `bisect_reset` shell function in C
2016-08-24 21:12 ` Junio C Hamano
@ 2016-08-26 13:46 ` Pranit Bauva
2016-08-26 16:29 ` Junio C Hamano
0 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-26 13:46 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Thu, Aug 25, 2016 at 2:42 AM, Junio C Hamano <gitster@pobox.com> wrote:
>
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
> > +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) {
>
> Hmm, tricky but correct to do the "< 1" comparison. If the file
> does not exist, you'd get -1; if it fails to read it, you'd get -1;
> if it turns out to be empty, you'd get 0.
>
> > + printf("We are not bisecting.\n");
> > + return 0;
> > + }
> > + strbuf_rtrim(&branch);
> > + } else {
> > + struct object_id oid;
> > + if (get_oid(commit, &oid))
> > + return error(_("'%s' is not a valid commit"), commit);
>
> The original is
>
> rev-parse --quiet --verify "$1^{commit}"
>
> Unless the caller of this function already appended "^{commit}" to
> whatever the user gave "bisect--helper bisect-reset", this
> conversion is not equivalent. If you said
>
> git bisect reset HEAD:
>
> get_oid() would tell you that the top-level tree object of the
> current commit exists in the object store, but the original is
> meant to catch "That's not a commit, it's a tree!" before attempting
> to run "git checkout" on it.
>
> I think get_sha1_committish() is what you want to use here.
>
> > + strbuf_addstr(&branch, commit);
> > + }
>
Ya! get_sha1_committish() would be better. Thanks!
>
> Also this version fails to catch "bisect reset a b c" as an error, I
> suspect.
It didn't when I tried it right now. Could you please elaborate on why
you think it can fail? There might be a thing which I haven't tested.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 07/27] bisect--helper: `bisect_reset` shell function in C
2016-08-26 13:46 ` Pranit Bauva
@ 2016-08-26 16:29 ` Junio C Hamano
2016-08-27 10:52 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-26 16:29 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Git List
Pranit Bauva <pranit.bauva@gmail.com> writes:
>> Also this version fails to catch "bisect reset a b c" as an error, I
>> suspect.
>
> It didn't when I tried it right now. Could you please elaborate on why
> you think it can fail? There might be a thing which I haven't tested.
My bad. I just compared your bisect_reset() implementation that had
if (no specific commit) {
reset to the branch
} else {
reset to the commit
}
with the original
case $# in
0) reset to the branch ;;
1) reset to the commit ;;
*) give usage and die ;;
esac
and took the difference and reacted "ah, excess parameters are not
diagnosed in this function".
Your caller does complain about excess parameters without giving
usage, and that is what I missed.
I am not sure if you intended to change the behaviour in this case
to avoid giving the usage string; I tend to think it is a good
change, but I didn't see it mentioned in the proposed commit log,
which also contributed to my not noticing the test in the caller.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 15/27] bisect--helper: retire `--bisect-clean-state` subcommand
2016-08-23 11:53 ` [PATCH v14 15/27] bisect--helper: retire `--bisect-clean-state` subcommand Pranit Bauva
@ 2016-08-26 20:56 ` Junio C Hamano
0 siblings, 0 replies; 320+ messages in thread
From: Junio C Hamano @ 2016-08-26 20:56 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> The `bisect-clean-state` subcommand is no longer used in the shell
> script while the C code uses `bisect_clean_state()` thus remove the
> subcommand.
Good.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 17/27] bisect--helper: `bisect_autostart` shell function in C
2016-08-23 11:53 ` [PATCH v14 17/27] bisect--helper: `bisect_autostart` " Pranit Bauva
@ 2016-08-26 21:09 ` Junio C Hamano
0 siblings, 0 replies; 320+ messages in thread
From: Junio C Hamano @ 2016-08-26 21:09 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> @@ -410,6 +413,7 @@ static int bisect_next(struct bisect_terms *terms, const char *prefix)
> {
> int res, no_checkout;
>
> + bisect_autostart(terms);
> /* 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
This change is extremely hard to reason about.
Why wasn't auto-start done at the very beginning of this function
before? Why does this start calling it all of a sudden? Before
autostart was rewritten in C in this step, who made sure the shell
version of autostart was called before bisect_next is called (which
must have become unnecessary with this step, and I fully expected a
removal of such a call in the shell version, but I didn't find such
a change in this patch)?
Or is this series simply broken by lossage of autostart feature in
"bisect next" between the step where bisect_next is rewritten in C
and this step?
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 21/27] bisect--helper: `bisect_log` shell function in C
2016-08-23 11:53 ` [PATCH v14 21/27] bisect--helper: `bisect_log` " Pranit Bauva
@ 2016-08-26 23:07 ` Junio C Hamano
2016-08-27 20:16 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-26 23:07 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> +static int bisect_log(void)
> +{
> + struct strbuf buf = STRBUF_INIT;
> +
> + if (strbuf_read_file(&buf, git_path_bisect_log(), 256) < 0) {
> + strbuf_release(&buf);
> + return error(_("We are not bisecting.\n"));
> + }
> +
> + printf("%s", buf.buf);
> + strbuf_release(&buf);
> +
> + return 0;
> +}
Hmph, is it really necessary to slurp everything in a strbuf before
sending it out to the standard output? Wouldn't it be sufficient to
open a file descriptor for reading on the log file and then hand it
over to copy.c::copy_fd()?
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 22/27] bisect--helper: `bisect_replay` shell function in C
2016-08-23 11:53 ` [PATCH v14 22/27] bisect--helper: `bisect_replay` " Pranit Bauva
@ 2016-08-26 23:24 ` Junio C Hamano
0 siblings, 0 replies; 320+ messages in thread
From: Junio C Hamano @ 2016-08-26 23:24 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> +static int get_next_word(struct strbuf *line, struct strbuf *word)
> +{
> + int i;
> + for (i = 0; line->buf[i] != ' ' && line->buf[i] != '\0'; i++)
> + strbuf_addch(word, line->buf[i]);
> +
> + return 0;
> +}
This looks like a very non-standard way to use a string buffer. The
function does not even have to take line as a whole strbuf, because
the logic does not even look at line->len and relies on line->buf[]
to be NUL terminated, which means the first parameter should instead
be "const char *buf", and the caller would feed then line.buf to the
function.
And I highly suspect that this is a very suboptimal interface, if
the caller then has to compute up to which byte in the line.buf to
splice away to get to the "next word" again.
A better alternative with higher level of abstraction would instead
be to keep the two strbuf parameters as-is, but have this function
responsible for "moving" the first word of "line" strbuf into "word"
strbuf. Then the caller can repeatedly call this function to get
each word in "word" strbuf until "line" becomes empty if it wants to
implement "a word at a time" operation.
If that higher level of abstraction is too limiting for the caller
(and also that would be just as inefficient as the patch under
discussion), another alternative would be to have the caller
maintain "the current byte position in the input" and
do something like:
int pos = 0;
while (pos < line.len) {
strbuf_reset(&word);
get_next_word(line.buf, pos, word);
pos += word.len;
do a thing on "word";
}
to implement "a word at a time" operation. For this to work,
get_next_word() would need to skip the leading blanks itself, of
course.
In any case, I won't comment on the body of the function too deeply;
it will probably become a lot cleaner if you employed the "retval +
goto finish:" pattern for error handling. Use of dequote seems
correct from the cursory look, too.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 08/27] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C
2016-08-24 22:13 ` Junio C Hamano
@ 2016-08-27 9:14 ` Pranit Bauva
2016-08-29 17:17 ` Junio C Hamano
0 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-27 9:14 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Thu, Aug 25, 2016 at 3:43 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> +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) >= 0) {
>> + strbuf_trim(&actual_hex);
>> + res = !strcmp(actual_hex.buf, expected_hex);
>
> If it is known to have 40-hex:
>
> (1) accepting ">= 0" seems way too lenient. You only expect a
> 41-byte file (or 42 if somebody would write CRLF, but I do not
> think anybody other than yourself is expected to write into
> this file, and you do not write CRLF yourself);
>
> (2) strbuf_trim() is overly loose. You only want to trim the
> terimnating LF and it is an error to have other trailing
> whitespaces.
>
> I think the latter is not a new problem and it is OK to leave it
> as-is; limiting (1) to >= 40 may still be a good change, though,
> because it makes the intention of the code clearer.
I can do the first change. Since this wasn't present in the shell
code, I will also mention it in the commit message.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 09/27] bisect--helper: `bisect_write` shell function in C
2016-08-24 22:30 ` Junio C Hamano
@ 2016-08-27 9:33 ` Pranit Bauva
2016-08-27 21:22 ` Junio C Hamano
0 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-27 9:33 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Thu, Aug 25, 2016 at 4:00 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> +struct bisect_terms {
>> + struct strbuf term_good;
>> + struct strbuf term_bad;
>> +};
>
> I think "struct strbuf" is overrated. For things like this, where
> these fields will never change once it is set (and setting it is
> done atomically, not incrementally), there is no good reason to use
> define the fields as strbuf.
>
> Only because you chose to use strbuf for these two fields, you have
> to make unnecessarily copies of argv[] in the command parser, and
> you have to remember to discard these copies later.
>
> I think you can just say "const char *" in this case.
Using struct strbuf is not really overrated but in fact required. But
yes, for this patch it might seem as overrated. In the shell code
initally TERM_GOOD is set to "good" while TERM_BAD is set to "bad".
Now there are a lot of instances (one of which is bisect_start()
function) where this can change. So if we keep it as "const char *",
it would be right to change the value of it after wards. And we cannot
keep it as "char []" because we don't know its size before hand.
>> +static int bisect_write(const char *state, const char *rev,
>> + const struct bisect_terms *terms, int nolog)
>> +{
>> + struct strbuf tag = STRBUF_INIT;
>> + struct strbuf commit_name = STRBUF_INIT;
>> + struct object_id oid;
>> + struct commit *commit;
>> + struct pretty_print_context pp = {0};
>> + FILE *fp;
>> +
>> + if (!strcmp(state, terms->term_bad.buf))
>> + strbuf_addf(&tag, "refs/bisect/%s", state);
>> + else if (one_of(state, terms->term_good.buf, "skip", NULL))
>> + strbuf_addf(&tag, "refs/bisect/%s-%s", state, rev);
>> + else
>> + return error(_("Bad bisect_write argument: %s"), state);
>
> OK.
>
>> + if (get_oid(rev, &oid)) {
>> + strbuf_release(&tag);
>> + return error(_("couldn't get the oid of the rev '%s'"), rev);
>> + }
>> +
>> + if (update_ref(NULL, tag.buf, oid.hash, NULL, 0,
>> + UPDATE_REFS_MSG_ON_ERR)) {
>> + strbuf_release(&tag);
>> + return -1;
>> + }
>> + strbuf_release(&tag);
>> +
>> + fp = fopen(git_path_bisect_log(), "a");
>> + if (!fp)
>> + return error_errno(_("couldn't open the file '%s'"), git_path_bisect_log());
>> +
>> + commit = lookup_commit_reference(oid.hash);
>> + format_commit_message(commit, "%s", &commit_name, &pp);
>> + fprintf(fp, "# %s: [%s] %s\n", state, sha1_to_hex(oid.hash),
>> + commit_name.buf);
>> + strbuf_release(&commit_name);
>> +
>> + if (!nolog)
>> + fprintf(fp, "git bisect %s %s\n", state, rev);
>> +
>> + fclose(fp);
>> + return 0;
>
> You seem to be _release()ing tag all over the place.
>
> Would it make sense to have a single clean-up label at the end of
> function, introduce a "int retval" variable and set it to -1 (or
> whatever) when an error is detected and "goto" to the label? It may
> make it harder to make such a leak. That is, to end the function
> more like:
I think I could use goto for this function.
> finish:
> if (fp)
> fclose(fp);
> strbuf_release(&tag);
> strbuf_release(&commit_name);
> return retval;
> }
>
> and have sites with potential errors do something like this:
>
> if (update_ref(...)) {
> retval = -1;
> goto finish;
> }
>
>> + struct bisect_terms terms;
>> + bisect_terms_init(&terms);
>
> With the type of "struct bisect_terms" members corrected, you do not
> even need the _init() function.
Discussed above.
>> @@ -182,24 +251,38 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
>> usage_with_options(git_bisect_helper_usage, options);
>>
>> switch (cmdmode) {
>> + int nolog;
>> case NEXT_ALL:
>> return bisect_next_all(prefix, no_checkout);
>> case WRITE_TERMS:
>> if (argc != 2)
>> die(_("--write-terms requires two arguments"));
>> - return write_terms(argv[0], argv[1]);
>> + res = write_terms(argv[0], argv[1]);
>> + break;
>> case BISECT_CLEAN_STATE:
>> if (argc != 0)
>> die(_("--bisect-clean-state requires no arguments"));
>> - return bisect_clean_state();
>> + res = bisect_clean_state();
>> + break;
>> case BISECT_RESET:
>> if (argc > 1)
>> die(_("--bisect-reset requires either zero or one arguments"));
>> - return bisect_reset(argc ? argv[0] : NULL);
>> + res = bisect_reset(argc ? argv[0] : NULL);
>> + break;
>> case CHECK_EXPECTED_REVS:
>> - return check_expected_revs(argv, argc);
>> + res = check_expected_revs(argv, argc);
>> + break;
>> + case BISECT_WRITE:
>> + if (argc != 4 && argc != 5)
>> + die(_("--bisect-write requires either 4 or 5 arguments"));
>> + nolog = (argc == 5) && !strcmp(argv[4], "nolog");
>> + strbuf_addstr(&terms.term_good, argv[2]);
>> + strbuf_addstr(&terms.term_bad, argv[3]);
>
> Here,
>
> terms.term_good = argv[2];
> terms.term_bad = argv[3];
>
> and then you do not need bisect_terms_release() at all.
Discussed above.
>> + res = bisect_write(argv[0], argv[1], &terms, nolog);
>> + break;
>> default:
>> die("BUG: unknown subcommand '%d'", cmdmode);
>> }
>> - return 0;
>> + bisect_terms_release(&terms);
>> + return res;
>> }
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 11/27] bisect--helper: `bisect_next_check` & bisect_voc shell function in C
2016-08-24 22:40 ` Junio C Hamano
@ 2016-08-27 9:35 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-27 9:35 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Thu, Aug 25, 2016 at 4:10 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> +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;
>> +}
>> +
>> +static char *bisect_voc(char *revision_type)
>> +{
>> + if (!strcmp(revision_type, "bad"))
>> + return "bad|new";
>> + if (!strcmp(revision_type, "good"))
>> + return "good|old";
>> +
>> + return NULL;
>> +}
>> +
>> +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.buf);
>> + char *good_glob = xstrfmt("%s-*", terms->term_good.buf);
>> + char *bad_syn, *good_syn;
>> +
>> + if (ref_exists(bad_ref))
>> + missing_bad = 0;
>> + free(bad_ref);
>> +
>> + for_each_glob_ref_in(mark_good, good_glob, "refs/bisect/",
>> + (void *) &missing_good);
>> + free(good_glob);
>> +
>> + if (!missing_good && !missing_bad)
>> + return 0;
>> +
>> + if (!current_term)
>> + return -1;
>> +
>> + if (missing_good && !missing_bad && current_term &&
>> + !strcmp(current_term, terms->term_good.buf)) {
>> + char *yesno;
>> + /*
>> + * have bad (or new) but not good (or old). We could bisect
>> + * although this is less optimum.
>> + */
>> + fprintf(stderr, _("Warning: bisecting only with a %s commit\n"),
>> + terms->term_bad.buf);
>> + if (!isatty(0))
>> + return 0;
>> + /*
>> + * 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"))
>> + return -1;
>> +
>> + return 0;
>> + }
>> + bad_syn = xstrdup(bisect_voc("bad"));
>> + good_syn = xstrdup(bisect_voc("good"));
>> + if (!is_empty_or_missing_file(git_path_bisect_start())) {
>> + error(_("You need to give me at least one %s and "
>> + "%s revision. You can use \"git bisect %s\" "
>> + "and \"git bisect %s\" for that. \n"),
>> + bad_syn, good_syn, bad_syn, good_syn);
>> + free(bad_syn);
>> + free(good_syn);
>> + return -1;
>> + }
>> + else {
>> + error(_("You need to start by \"git bisect start\". You "
>> + "then need to give me at least one %s and %s "
>> + "revision. You can use \"git bisect %s\" and "
>> + "\"git bisect %s\" for that.\n"),
>> + good_syn, bad_syn, bad_syn, good_syn);
>> + free(bad_syn);
>> + free(good_syn);
>> + return -1;
>> + }
>> + free(bad_syn);
>> + free(good_syn);
>> +
>> + return 0;
>
> This one looks OK, but I think the same "Wouldn't it become cleaner
> to have a 'finish:' label at the end and jump there?" comment
> applies to this implementation, too.
For this goto can simply things. Will do!
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 12/27] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-08-25 18:05 ` Junio C Hamano
@ 2016-08-27 9:48 ` Pranit Bauva
2016-08-29 17:15 ` Junio C Hamano
0 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-27 9:48 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Thu, Aug 25, 2016 at 11:35 PM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> +static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
>> +{
>> + int i;
>> +
>> + if (get_terms(terms)) {
>> + fprintf(stderr, _("no terms defined\n"));
>> + return -1;
>> + }
>> + if (argc == 0) {
>> + printf(_("Your current terms are %s for the old state\nand "
>> + "%s for the new state.\n"), terms->term_good.buf,
>> + terms->term_bad.buf);
>> + return 0;
>> + }
>> +
>> + for (i = 0; i < argc; i++) {
>> + if (!strcmp(argv[i], "--term-good"))
>> + printf("%s\n", terms->term_good.buf);
>> + else if (!strcmp(argv[i], "--term-bad"))
>> + printf("%s\n", terms->term_bad.buf);
>> + else
>> + printf(_("invalid argument %s for 'git bisect "
>> + "terms'.\nSupported options are: "
>> + "--term-good|--term-old and "
>> + "--term-bad|--term-new."), argv[i]);
>> + }
>
> The original took only one and gave one answer (and errored out when
> the user asked for more), but this one loops. I can see either way
> is OK and do not think of a good reason to favor one over the other;
> unless there is a strong reason why you need this extended behaviour
> that allows users to ask multiple questions, I'd say we should keep
> the original behaviour.
True! I can just use return error() instead of printf. Also I noticed
that this is printing to stdout while the original printed it to
stderr. Thanks!
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 07/27] bisect--helper: `bisect_reset` shell function in C
2016-08-26 16:29 ` Junio C Hamano
@ 2016-08-27 10:52 ` Pranit Bauva
2016-08-29 17:06 ` Junio C Hamano
0 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-27 10:52 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Fri, Aug 26, 2016 at 9:59 PM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>>> Also this version fails to catch "bisect reset a b c" as an error, I
>>> suspect.
>>
>> It didn't when I tried it right now. Could you please elaborate on why
>> you think it can fail? There might be a thing which I haven't tested.
>
> My bad. I just compared your bisect_reset() implementation that had
>
> if (no specific commit) {
> reset to the branch
> } else {
> reset to the commit
> }
>
> with the original
>
> case $# in
> 0) reset to the branch ;;
> 1) reset to the commit ;;
> *) give usage and die ;;
> esac
>
> and took the difference and reacted "ah, excess parameters are not
> diagnosed in this function".
>
> Your caller does complain about excess parameters without giving
> usage, and that is what I missed.
>
> I am not sure if you intended to change the behaviour in this case
> to avoid giving the usage string; I tend to think it is a good
> change, but I didn't see it mentioned in the proposed commit log,
> which also contributed to my not noticing the test in the caller.
I could include this in the commit message. Its not really something
which we would want to test in the function because to the function,
we are not passing the raw arguments. Since we are removing that check
from the function but including it in cmd_bisect__helper(), I will
talk about it in the commit message.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 13/27] bisect--helper: `bisect_start` shell function partially in C
2016-08-25 19:02 ` Junio C Hamano
2016-08-25 19:43 ` Junio C Hamano
@ 2016-08-27 19:47 ` Pranit Bauva
2016-08-27 20:53 ` Junio C Hamano
1 sibling, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-08-27 19:47 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Fri, Aug 26, 2016 at 12:32 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> +static int bisect_start(struct bisect_terms *terms, int no_checkout,
>> + const char **argv, int argc)
>> +{
>> + int i, has_double_dash = 0, must_write_terms = 0, bad_seen = 0;
>> + int flags, pathspec_pos;
>> + struct string_list revs = STRING_LIST_INIT_DUP;
>> + struct string_list states = STRING_LIST_INIT_DUP;
>
> The original has a single state, not states. Let's see if there is
> a reason behind the name change....
>
>> + unsigned char sha1[20];
>> + struct object_id oid;
>
> More on these below...
>
>> + ...
>> + for (i = 0; i < argc; i++) {
>> + const char *commit_id = xstrfmt("%s^{commit}", argv[i]);
>> + if (!strcmp(argv[i], "--")) {
>> + has_double_dash = 1;
>> + break;
>> + } else if (!strcmp(argv[i], "--no-checkout"))
>> + no_checkout = 1;
>> + else if (!strcmp(argv[i], "--term-good") ||
>> + ...
>> + } else if (starts_with(argv[i], "--") &&
>> + !one_of(argv[i], "--term-good", "--term-bad", NULL)) {
>> + string_list_clear(&revs, 0);
>> + string_list_clear(&states, 0);
>> + die(_("unrecognised option: '%s'"), argv[i]);
>> + } else if (get_oid(commit_id, &oid) && has_double_dash) {
>> + string_list_clear(&revs, 0);
>> + string_list_clear(&states, 0);
>> + die(_("'%s' does not appear to be a valid revision"), argv[i]);
>> + } else {
>> + string_list_append(&revs, oid_to_hex(&oid));
>> + }
>> + }
>
> What I do not understand is clearing the string list "states" inside
> this loop. It may have been INIT_DUPed, but nothing in this loop
> adds anything to it. Because "revs" does get extended in the loop,
> it is understandable if you wanted to clear it before dying, but "if
> you are dying anyway why bother clearing?" is also a valid stance to
> take.
I think I should probably use return here instead of die().
> The same "perhaps want to use the 'retval' with goto 'finish:' pattern?"
> comment applies here, too.
Okay sure could do that.
>> + 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.
>> + */
>> + must_write_terms |= !!revs.nr;
>> + for (i = 0; i < revs.nr; i++) {
>> + if (bad_seen)
>> + string_list_append(&states, terms->term_good.buf);
>> + else {
>> + bad_seen = 1;
>> + string_list_append(&states, terms->term_bad.buf);
>> + }
>> + }
>
> This is certainly different from the original. We used to do one
> "bisect_write" per element in revs in the loop; we no longer do that
> and instead collect them in states list. Each element in these two
> lists, i.e. revs.item[i] and states.item[i], corresponds to each
> other.
>
> That explains why the variable is renamed to states. We haven't
> seen enough to say if this behaviour change is a good idea or not.
>
>> + /*
>> + * Verify HEAD
>> + */
>> + head = resolve_ref_unsafe("HEAD", 0, sha1, &flags);
>> + if (!head) {
>> + if (get_sha1("HEAD", sha1)) {
>> + string_list_clear(&revs, 0);
>> + string_list_clear(&states, 0);
>> + die(_("Bad HEAD - I need a HEAD"));
>> + }
>> + }
>> + 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) {
>> + struct argv_array argv = ARGV_ARRAY_INIT;
>> + argv_array_pushl(&argv, "checkout", start_head.buf,
>> + "--", NULL);
>> + if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
>> + error(_("checking out '%s' failed. Try 'git "
>> + "bisect start <valid-branch>'."),
>> + start_head.buf);
>> + strbuf_release(&start_head);
>> + string_list_clear(&revs, 0);
>> + string_list_clear(&states, 0);
>> + return -1;
>
> The original died here, but you expect the caller to respond to a
> negative return. I haven't read enough to judge if that is a good
> idea, but doesn't it make sense to do the same throughout the
> function consistently? I saw a few die()'s already in the command
> line parsing loop--shouldn't they also return -1?
Yes they should use return rather than die().
> The original has called bisect_write already when we attempt this
> checkout and the user will see the states in the filesystem. This
> rewrite does not. What effect does this behaviour change have to
> the end-user experience? The error message tells the end user to
> run another "git bisect start" with a valid commit, and when that
> happens, hopefully she will give us something we can check out, and
> then we will hit the bisect_clean_state() call we see below before
> starting to do anything meaningful, so I am guessing it won't, but
> I just want to make sure that you thought about the ramifications
> of the change above to delay calls to bisect_write.
>
>> + }
>> + }
>> + } else {
>> + if (starts_with(head, "refs/heads/") ||
>> + !get_oid_hex(head, &oid) || ref_exists(head)) {
>
> This ref_exists() check is new, and I think it should not be there.
> In the original, if .git/HEAD pointed at refs/tags/v1.0, we would
> have diagnosed it as a strange symbolic ref. This no longer does.
>
> If you wanted to make sure that the branch exists, it should have
> been
>
> if ((starts_with(head, "refs/heads/") && ref_exists(head)) ||
> !get_oid_hex(head, &oid)) {
>
> anyway.
I forgot to consider about tags. Thanks for reminding.
> Also, why do you use get_oid_hex() here? You used get_sha1("HEAD",
> sha1) in the early part of "Verify HEAD" above, which seems to be
> perfectly adequate. That sha1 taken from get_sha1() is what you end
> up using in the code below anyway. If you can stick to one or the
> other, please do so.
I should use get_sha1().
>> + /*
>> + * 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())) {
>> + strbuf_release(&start_head);
>> + string_list_clear(&revs, 0);
>> + string_list_clear(&states, 0);
>> + die(_("won't bisect on cg-seek'ed tree"));
>> + }
>
> Not to be done as part of this series, but it probably is safe to
> retire this part by now. Cogito has been dead for how many years?
Been around 10 years. Last update seemed around 2006. Here is the link[1].
>> + if (starts_with(head, "refs/heads/")) {
>> + strbuf_reset(&start_head);
>> + strbuf_addstr(&start_head, head + 11);
>
> skip_prefix?
Ya sure! That's a better way to go.
>> + }
>> + else {
>> + strbuf_reset(&start_head);
>> + strbuf_addstr(&start_head, sha1_to_hex(sha1));
>> + }
>> + } else {
>> + strbuf_release(&start_head);
>> + string_list_clear(&revs, 0);
>> + string_list_clear(&states, 0);
>> + die(_("Bad HEAD - strange symbolic ref"));
>> + }
>> + }
>
> I wonder the whole thing above is better restructured to avoid
> repeated checks of the same thing.
>
> if (is it 40-hex, i.e. detached?) {
> stuff it to start_head;
> } else if (skip_prefix(head, "refs/heads/", &branchname)) {
> do the "cogito" check;
> stuff it to start_head;
> } else {
> that's a strange symbolic ref HEAD you have there;
> }
I guess it changes the behaviour. Its a strange symbolic ref if it
does not start with "refs/heads".
>> + /*
>> + * Get rid of any old bisect state.
>> + */
>> + if (bisect_clean_state()) {
>> + return -1;
>> + }
>
> If we are going to get a lot more code inside {} in later patches,
> then this single "return -1" enclosed inside a {} pair is
> justifiable (but in that case we'd prefer an empty line after it to
> separate it from the next comment block). Otherwise lose the {}.
I had thought initially that I would need to keep something after
bisect_next() conversion. But it turns out that I actually don't.
>> + /*
>> + * 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".
>> + */
>
> That explains the "trap" statements in the original. Does it apply
> to this code here?
>
>> + /*
>> + * Write new start state
>> + */
>> + write_file(git_path_bisect_start(), "%s\n", start_head.buf);
>> +
>> + if (no_checkout) {
>> + get_oid(start_head.buf, &oid);
>> + if (update_ref(NULL, "BISECT_HEAD", oid.hash, NULL, 0,
>> + UPDATE_REFS_MSG_ON_ERR)) {
>> + strbuf_release(&start_head);
>> + string_list_clear(&revs, 0);
>> + string_list_clear(&states, 0);
>> + return -1;
>> + }
>> + }
>> + strbuf_release(&start_head);
>> +
>> + if (pathspec_pos < argc - 1)
>> + sq_quote_argv(&bisect_names, argv + pathspec_pos, 0);
>> + write_file(git_path_bisect_names(), "%s\n", bisect_names.buf);
>> + strbuf_release(&bisect_names);
>> +
>> + for (i = 0; i < states.nr; i++) {
>> + if (bisect_write(states.items[i].string,
>> + revs.items[i].string, terms, 1)) {
>> + string_list_clear(&revs, 0);
>> + string_list_clear(&states, 0);
>> + return -1;
>> + }
>> + }
>
> Hmph. I do not particuarly see why doing this in a separate loop
> here, instead of doing it just like in the original, i.e. inside the
> loop we already saw, is an improvement. It seems to me that the
> only effect of this change is to make the code more complex by
> forcing you to maintain (and clear) another string list "states" and
> have a separate loop here.
>
> Unless there is a reason why delaying calls to bisect_write() is a
> good thing and I am not seeing it, that is.
>
>> diff --git a/git-bisect.sh b/git-bisect.sh
>> index d6c8b5a..f0896b3 100755
>> --- a/git-bisect.sh
>> +++ b/git-bisect.sh
>> @@ -71,122 +71,7 @@ bisect_autostart() {
>> }
>>
>> bisect_start() {
>> -...
>> + git bisect--helper --bisect-start $@ || exit
>> ...
>> + get_terms
>
> Understandable. As the handling of the terms is done in the helper,
> you need to read the terms it left in the filesystem. OK.
>
>> bisect_auto_next
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 21/27] bisect--helper: `bisect_log` shell function in C
2016-08-26 23:07 ` Junio C Hamano
@ 2016-08-27 20:16 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-27 20:16 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Sat, Aug 27, 2016 at 4:37 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> +static int bisect_log(void)
>> +{
>> + struct strbuf buf = STRBUF_INIT;
>> +
>> + if (strbuf_read_file(&buf, git_path_bisect_log(), 256) < 0) {
>> + strbuf_release(&buf);
>> + return error(_("We are not bisecting.\n"));
>> + }
>> +
>> + printf("%s", buf.buf);
>> + strbuf_release(&buf);
>> +
>> + return 0;
>> +}
>
> Hmph, is it really necessary to slurp everything in a strbuf before
> sending it out to the standard output? Wouldn't it be sufficient to
> open a file descriptor for reading on the log file and then hand it
> over to copy.c::copy_fd()?
That is actually much better. Thanks!
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 13/27] bisect--helper: `bisect_start` shell function partially in C
2016-08-27 19:47 ` Pranit Bauva
@ 2016-08-27 20:53 ` Junio C Hamano
0 siblings, 0 replies; 320+ messages in thread
From: Junio C Hamano @ 2016-08-27 20:53 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Git List
Pranit Bauva <pranit.bauva@gmail.com> writes:
>> I wonder the whole thing above is better restructured to avoid
>> repeated checks of the same thing.
>>
>> if (is it 40-hex, i.e. detached?) {
>> stuff it to start_head;
>> } else if (skip_prefix(head, "refs/heads/", &branchname)) {
>> do the "cogito" check;
>> stuff it to start_head;
>> } else {
>> that's a strange symbolic ref HEAD you have there;
>> }
>
> I guess it changes the behaviour. Its a strange symbolic ref if it
> does not start with "refs/heads".
I did not think my suggestion would change the behaviour at all. It
would change the code structure a bit to make it more readable, though.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 09/27] bisect--helper: `bisect_write` shell function in C
2016-08-27 9:33 ` Pranit Bauva
@ 2016-08-27 21:22 ` Junio C Hamano
2016-08-30 6:42 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-27 21:22 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Git List
Pranit Bauva <pranit.bauva@gmail.com> writes:
>>> +struct bisect_terms {
>>> + struct strbuf term_good;
>>> + struct strbuf term_bad;
>>> +};
>>
>> I think "struct strbuf" is overrated. ...
>> I think you can just say "const char *" in this case.
>
> Using struct strbuf is not really overrated but in fact required. But
Nothing is required.
I can make your life easier by requiring you to never use struct
strbuf as a structure field type, though. You will almost never
need it unless you are building something exotic anyway.
Step back and think what "strbuf" is good for. It holds a pointer
to a piece of memory the field owns, over-allocates and knows the
size of allocation and usage. That is good if you need to
(1) frequently find out the length of the string; without a
separate .len member you would have to run strlen().
(2) incrementally add to the string in-place; as it overallocates,
appending to the string would not have to involve realloc()
every time and the cost of it is amortized.
(3) make complex operations like splicing another string in,
trimming substring out, etc.
You need to do none of the above to these fields. term.term_good is
either taken from an argv[] element, or you read from a line from a
file and set it. You may do some trivial computation and set it to
the result, like "the other field uses 'old', so this one need to be
set to 'new'". The user of the field either has the string and sets
it there, or reads the field's value as a whole string. No string
manipulation in the field in-place is needed.
> yes, for this patch it might seem as overrated. In the shell code
> initally TERM_GOOD is set to "good" while TERM_BAD is set to "bad".
> Now there are a lot of instances (one of which is bisect_start()
> function) where this can change. So if we keep it as "const char *",
> it would be right to change the value of it after wards. And we cannot
> keep it as "char []" because we don't know its size before hand.
You are not making sense. Nobody would suggest to use a fixed-size
char array in this structure. That wouldn't even work in the case
where you are stuffing what comes in an argv[] element in there,
e.g.
terms.term_good = argv[3];
And you can of course support changing the value of the field
without using strbuf. Just update the pointer to point at the piece
of memory that holds the new value.
In short, I do not see any good reason why the term_good field has
to be anything other than "char *term_good" or "const char *term_good".
Now, what you need to consider choosing between the two depends on
where these strings can come from. If they are known to be always
unchanging between the time you set it til the end of the program
(e.g. using an element in argv[]), you can just assign without
making any copy and you can use "const char *term_good". All other
cases, the structure needs to take the ownership, and you would need
to make a copy if you don't have the ownership, e.g.
terms.term_good = xstrdup(argv[3]);
You may be reading from a file, a line at a time and you may have a
line's content in a strbuf. You do not (yet) own the buffer after
reading it, e.g.
strbuf_getline(&buf, fp);
terms.term_good = strbuf_detach(&buf, NULL);
Of course, if you need to take ownership of the memory, you would
need to free(3) it as needed, which means the pattern to set the
field would become
free(terms.term_good);
terms.term_good = ... some new value ...;
Using strbuf as a local variable is good. It gives a higher level
of abstraction when you are actually performing string operations.
In most applications, however, a field in a struct is where the
result of a step of computation is kept, not a scratch-pad to
perform steps of computation in. When you are ready to update the
value of a field, you _have_ a completed string, and you can just
use "char *" field to point at it. There is no need for strbuf in
the field.
Don't look at the data structure used in trailer.[ch] as a model; it
is an example of a terribly bad implementation taste, a pattern that
should not be followed. Print it, not read it and burn it as a good
symbolic gesture.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 07/27] bisect--helper: `bisect_reset` shell function in C
2016-08-27 10:52 ` Pranit Bauva
@ 2016-08-29 17:06 ` Junio C Hamano
0 siblings, 0 replies; 320+ messages in thread
From: Junio C Hamano @ 2016-08-29 17:06 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Git List
Pranit Bauva <pranit.bauva@gmail.com> writes:
>> with the original
>>
>> case $# in
>> 0) reset to the branch ;;
>> 1) reset to the commit ;;
>> *) give usage and die ;;
>> esac
>>
>> and took the difference and reacted "ah, excess parameters are not
>> diagnosed in this function".
>>
>> Your caller does complain about excess parameters without giving
>> usage, and that is what I missed.
>>
>> I am not sure if you intended to change the behaviour in this case
>> to avoid giving the usage string; I tend to think it is a good
>> change, but I didn't see it mentioned in the proposed commit log,
>> which also contributed to my not noticing the test in the caller.
>
> I could include this in the commit message.
Nah, it was something anybody could notice with 2 more minutes of
reading and pondering from the patch text alone. Not worth spending
more time on the log message on this one.
Thanks.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 12/27] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-08-27 9:48 ` Pranit Bauva
@ 2016-08-29 17:15 ` Junio C Hamano
0 siblings, 0 replies; 320+ messages in thread
From: Junio C Hamano @ 2016-08-29 17:15 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Git List
Pranit Bauva <pranit.bauva@gmail.com> writes:
>>> +static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
>>> +{
>>> + int i;
>>> +
>>> + if (get_terms(terms)) {
>>> + fprintf(stderr, _("no terms defined\n"));
>>> + return -1;
>>> + }
>>> + if (argc == 0) {
>>> + printf(_("Your current terms are %s for the old state\nand "
>>> + "%s for the new state.\n"), terms->term_good.buf,
>>> + terms->term_bad.buf);
>>> + return 0;
>>> + }
>>> +
>>> + for (i = 0; i < argc; i++) {
>>> + if (!strcmp(argv[i], "--term-good"))
>>> + printf("%s\n", terms->term_good.buf);
>>> + else if (!strcmp(argv[i], "--term-bad"))
>>> + printf("%s\n", terms->term_bad.buf);
>>> + else
>>> + printf(_("invalid argument %s for 'git bisect "
>>> + "terms'.\nSupported options are: "
>>> + "--term-good|--term-old and "
>>> + "--term-bad|--term-new."), argv[i]);
>>> + }
>>
>> The original took only one and gave one answer (and errored out when
>> the user asked for more), but this one loops. I can see either way
>> is OK and do not think of a good reason to favor one over the other;
>> unless there is a strong reason why you need this extended behaviour
>> that allows users to ask multiple questions, I'd say we should keep
>> the original behaviour.
>
> True! I can just use return error() instead of printf. Also I noticed
> that this is printing to stdout while the original printed it to
> stderr. Thanks!
The original you removed because the above can take it over is this
in your patch.
-bisect_terms () {
- get_terms
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- die "$(gettext "no terms defined")"
- fi
- case "$#" in
- 0)
- gettextln "Your current terms are $TERM_GOOD for the old state
-and $TERM_BAD for the new state."
- ;;
- 1)
- arg=$1
- case "$arg" in
- --term-good|--term-old)
- printf '%s\n' "$TERM_GOOD"
- ;;
- --term-bad|--term-new)
- printf '%s\n' "$TERM_BAD"
- ;;
- *)
- die "$(eval_gettext "invalid argument \$arg for 'git bisect terms'.
-Supported options are: --term-good|--term-old and --term-bad|--term-new.")"
- ;;
- esac
- ;;
- *)
- usage ;;
- esac
-}
-
The fprintf() that says "no terms defined" can be made error(). The
"invalid argument" message used to be die in the original, and
should be sent to the standard error stream as you noticed.
But a bigger difference is that the original made sure that the
caller asked one question at a time. "terms --term-good --term-bad"
was responded with a "usage". That is no longer true in the
rewrite.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 08/27] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C
2016-08-27 9:14 ` Pranit Bauva
@ 2016-08-29 17:17 ` Junio C Hamano
0 siblings, 0 replies; 320+ messages in thread
From: Junio C Hamano @ 2016-08-29 17:17 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Git List
Pranit Bauva <pranit.bauva@gmail.com> writes:
> Hey Junio,
>
> On Thu, Aug 25, 2016 at 3:43 AM, Junio C Hamano <gitster@pobox.com> wrote:
>> Pranit Bauva <pranit.bauva@gmail.com> writes:
>>
>>> +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) >= 0) {
>>> + strbuf_trim(&actual_hex);
>>> + res = !strcmp(actual_hex.buf, expected_hex);
>>
>> If it is known to have 40-hex:
>>
>> (1) accepting ">= 0" seems way too lenient. You only expect a
>> 41-byte file (or 42 if somebody would write CRLF, but I do not
>> think anybody other than yourself is expected to write into
>> this file, and you do not write CRLF yourself);
>>
>> (2) strbuf_trim() is overly loose. You only want to trim the
>> terimnating LF and it is an error to have other trailing
>> whitespaces.
>>
>> I think the latter is not a new problem and it is OK to leave it
>> as-is; limiting (1) to >= 40 may still be a good change, though,
>> because it makes the intention of the code clearer.
>
> I can do the first change. Since this wasn't present in the shell
> code, I will also mention it in the commit message.
There is no need for that, as that was present in the original. The
original compared the string with something that is known to be
40-hex, so anything shorter than 40 wouldn't have matched.
It is merely a trivial and obvious optimization to do that in C
rewrite.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 09/27] bisect--helper: `bisect_write` shell function in C
2016-08-27 21:22 ` Junio C Hamano
@ 2016-08-30 6:42 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-30 6:42 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Sun, Aug 28, 2016 at 2:52 AM, Junio C Hamano <gitster@pobox.com> wrote:
>
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
> >>> +struct bisect_terms {
> >>> + struct strbuf term_good;
> >>> + struct strbuf term_bad;
> >>> +};
> >>
> >> I think "struct strbuf" is overrated. ...
> >> I think you can just say "const char *" in this case.
> >
> > Using struct strbuf is not really overrated but in fact required. But
>
> Nothing is required.
>
> I can make your life easier by requiring you to never use struct
> strbuf as a structure field type, though. You will almost never
> need it unless you are building something exotic anyway.
>
> Step back and think what "strbuf" is good for. It holds a pointer
> to a piece of memory the field owns, over-allocates and knows the
> size of allocation and usage. That is good if you need to
>
> (1) frequently find out the length of the string; without a
> separate .len member you would have to run strlen().
>
> (2) incrementally add to the string in-place; as it overallocates,
> appending to the string would not have to involve realloc()
> every time and the cost of it is amortized.
>
> (3) make complex operations like splicing another string in,
> trimming substring out, etc.
>
> You need to do none of the above to these fields. term.term_good is
> either taken from an argv[] element, or you read from a line from a
> file and set it. You may do some trivial computation and set it to
> the result, like "the other field uses 'old', so this one need to be
> set to 'new'". The user of the field either has the string and sets
> it there, or reads the field's value as a whole string. No string
> manipulation in the field in-place is needed.
>
> > yes, for this patch it might seem as overrated. In the shell code
> > initally TERM_GOOD is set to "good" while TERM_BAD is set to "bad".
> > Now there are a lot of instances (one of which is bisect_start()
> > function) where this can change. So if we keep it as "const char *",
> > it would be right to change the value of it after wards. And we cannot
> > keep it as "char []" because we don't know its size before hand.
>
> You are not making sense. Nobody would suggest to use a fixed-size
> char array in this structure. That wouldn't even work in the case
> where you are stuffing what comes in an argv[] element in there,
> e.g.
>
> terms.term_good = argv[3];
>
> And you can of course support changing the value of the field
> without using strbuf. Just update the pointer to point at the piece
> of memory that holds the new value.
>
> In short, I do not see any good reason why the term_good field has
> to be anything other than "char *term_good" or "const char *term_good".
>
> Now, what you need to consider choosing between the two depends on
> where these strings can come from. If they are known to be always
> unchanging between the time you set it til the end of the program
> (e.g. using an element in argv[]), you can just assign without
> making any copy and you can use "const char *term_good". All other
> cases, the structure needs to take the ownership, and you would need
> to make a copy if you don't have the ownership, e.g.
>
> terms.term_good = xstrdup(argv[3]);
>
> You may be reading from a file, a line at a time and you may have a
> line's content in a strbuf. You do not (yet) own the buffer after
> reading it, e.g.
>
> strbuf_getline(&buf, fp);
> terms.term_good = strbuf_detach(&buf, NULL);
>
> Of course, if you need to take ownership of the memory, you would
> need to free(3) it as needed, which means the pattern to set the
> field would become
>
> free(terms.term_good);
> terms.term_good = ... some new value ...;
>
> Using strbuf as a local variable is good. It gives a higher level
> of abstraction when you are actually performing string operations.
> In most applications, however, a field in a struct is where the
> result of a step of computation is kept, not a scratch-pad to
> perform steps of computation in. When you are ready to update the
> value of a field, you _have_ a completed string, and you can just
> use "char *" field to point at it. There is no need for strbuf in
> the field.
>
> Don't look at the data structure used in trailer.[ch] as a model; it
> is an example of a terribly bad implementation taste, a pattern that
> should not be followed. Print it, not read it and burn it as a good
> symbolic gesture.
Thanks for explaining when to use strbuf. I am convinced that the
thing I am aiming for can be done with the help of "const char *".
Though I will have to use strbuf in get_terms() and detach the string
buffer from there as you have mentioned previously.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 14/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function in C
2016-08-25 20:30 ` Junio C Hamano
@ 2016-08-30 18:25 ` Pranit Bauva
2016-08-30 18:44 ` Pranit Bauva
2016-08-30 19:33 ` Junio C Hamano
0 siblings, 2 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-30 18:25 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
[-- Attachment #1: Type: text/plain, Size: 17460 bytes --]
Hey Junio,
Sorry for a late replay.
On Fri, Aug 26, 2016 at 2:00 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> A lot of parts of bisect.c uses exit() and these signals are then
>> trapped in the `bisect_start` function. Since the shell script ceases
>> its existence it would be necessary to convert those exit() calls to
>> return statements so that errors can be reported efficiently in C code.
>
> Is efficiency really an issue? I think the real reason is that it
> would make it impossible for the callers to handle errors, if you do
> not convert and let the error codepaths exit().
I think I put the word "efficiently" wrongly over here. Will omit it.
>> @@ -729,7 +735,7 @@ static struct commit **get_bad_and_good_commits(int *rev_nr)
>> return rev;
>> }
>>
>> -static void handle_bad_merge_base(void)
>> +static int handle_bad_merge_base(void)
>> {
>> if (is_expected_rev(current_bad_oid)) {
>> char *bad_hex = oid_to_hex(current_bad_oid);
>> @@ -750,17 +756,18 @@ static void handle_bad_merge_base(void)
>> "between %s and [%s].\n"),
>> bad_hex, term_bad, term_good, bad_hex, good_hex);
>> }
>> - exit(3);
>> + return 3;
>> }
>>
>> fprintf(stderr, _("Some %s revs are not ancestor of the %s rev.\n"
>> "git bisect cannot work properly in this case.\n"
>> "Maybe you mistook %s and %s revs?\n"),
>> term_good, term_bad, term_good, term_bad);
>> - exit(1);
>> + bisect_clean_state();
>> + return 1;
>
> What is the logic behind this function sometimes clean the state,
> and some other times do not, when it makes an error-return? We see
> above that "return 3" codepath leaves the state behind.
>
> Either you forgot a necessary clean_state in "return 3" codepath,
> or you forgot to document why the distinction exists in the in-code
> comment for the function. I cannot tell which, but I am leaning
> towards guessing that it is the former.
This is a very tricky one. I have purposely not included this after a
lot of testing. I have hand tested with the original git and with this
branch. The reason why anyone wouldn't be able to catch this is
because its not covered in the test suite. I am including a patch with
this as an attachment (because I am behind a proxy right now but don't
worry I will include this as a commit in the next series). The
original behaviour of git does not clean the bisect state when this
situation occurs. On another note which you might have missed that
bisect_clean_state() is purposely put before return 1 which is covered
by the test suite. You can try removing it and see that there is a
broken tes. tI was thinking of including the tests after the whole
conversion but now I think including this before will make the
conversion more easier for review.
>> -static void check_good_are_ancestors_of_bad(const char *prefix, int no_checkout)
>> +static int check_good_are_ancestors_of_bad(const char *prefix, int no_checkout)
>> {
>> char *filename = git_pathdup("BISECT_ANCESTORS_OK");
>> struct stat st;
>> - int fd;
>> + int fd, res = 0;
>>
>> if (!current_bad_oid)
>> die(_("a %s revision is needed"), term_bad);
>
> Can you let it die yere?
Not really. I should change it to return error().
>> @@ -873,8 +890,11 @@ static void check_good_are_ancestors_of_bad(const char *prefix, int no_checkout)
>> filename);
>> else
>> close(fd);
>> +
>> + return 0;
>> done:
>> free(filename);
>> + return 0;
>> }
>
> Who owns "filename"? The first "return 0" leaves it unfreed, and
> when "goto done" is done, it is freed.
>
> The above two may indicate that "perhaps 'retval + goto finish'
> pattern?" is a really relevant suggestion for the earlier steps in
> this series.
Yes.
>> if (!all) {
>> fprintf(stderr, _("No testable commit found.\n"
>> "Maybe you started with bad path parameters?\n"));
>> - exit(4);
>> + return 4;
>> }
>>
>> bisect_rev = revs.commits->item->object.oid.hash;
>>
>> if (!hashcmp(bisect_rev, current_bad_oid->hash)) {
>> - exit_if_skipped_commits(tried, current_bad_oid);
>> + res = exit_if_skipped_commits(tried, current_bad_oid);
>> + if (res)
>> + return res;
>> +
>> printf("%s is the first %s commit\n", sha1_to_hex(bisect_rev),
>> term_bad);
>> show_diff_tree(prefix, revs.commits->item);
>> /* This means the bisection process succeeded. */
>> - exit(10);
>> + return 10;
>> }
>>
>> nr = all - reaches - 1;
>> @@ -1005,7 +1033,11 @@ int bisect_next_all(const char *prefix, int no_checkout)
>> "Bisecting: %d revisions left to test after this %s\n",
>> nr), nr, steps_msg);
>>
>> - return bisect_checkout(bisect_rev, no_checkout);
>> + res = bisect_checkout(bisect_rev, no_checkout);
>> + if (res)
>> + bisect_clean_state();
>> +
>> + return res;
>> }
>
> There were tons of "exit_if" that was converted to "if (res) return
> res" above, instead of jumping here to cause clean_state to be
> called. I cannot tell if this new call to clean_state() is wrong,
> or all the earlier "return res" should come here. I am guessing the
> latter.
No I don't think its wrong. It is advised in the comment
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".
to clean the bisection state *iff checkout fails* otherwise not.
Luckily this is already covered by the test suite. I think what you
meant is that bisect_clean_state() might be covered elsewhere too then
why perform cleanup here, right? bisect_clean_state() have been
carefully put where ever required only.
>> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
>> index c64996a..ef7b3a1 100644
>> --- a/builtin/bisect--helper.c
>> +++ b/builtin/bisect--helper.c
>> @@ -8,6 +8,7 @@
>> #include "run-command.h"
>> #include "prompt.h"
>> #include "quote.h"
>> +#include "revision.h"
>>
>> static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
>> static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
>> @@ -29,6 +30,8 @@ static const char * const git_bisect_helper_usage[] = {
>> N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
>> N_("git bisect--helper --bisect start [--term-{old,good}=<term> --term-{new,bad}=<term>]"
>> "[--no-checkout] [<bad> [<good>...]] [--] [<paths>...]"),
>> + N_("git bisect--helper --bisect-next"),
>> + N_("git bisect--helper --bisect-auto-next"),
>> NULL
>> };
>>
>> @@ -396,6 +399,129 @@ static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
>> return 0;
>> }
>>
>> +static int register_good_ref(const char *refname,
>> + const struct object_id *oid, int flags,
>> + void *cb_data)
>> +{
>> + struct string_list *good_refs = cb_data;
>> + string_list_append(good_refs, oid_to_hex(oid));
>> + return 0;
>> +}
>> +
>> +static int bisect_next(struct bisect_terms *terms, const char *prefix)
>> +{
>> + int res, no_checkout;
>> +
>> + /* In case of mistaken revs or checkout error, or signals received,
>
> That's an unbalanced comment. You end the block with "*/" on its
> own line, so you should start the block with "/*" on its own line.
> There seems to be at least one more such comment in this patch but I
> won't repeat.
I shall change this.
>> + * "bisect_auto_next" below may exit or misbehave.
>> + * We have to trap this to be able to clean up using
>> + * "bisect_clean_state".
>> + */
>
> "exit" meaning "call exit() to terminate the process", or something
> else? If the latter, don't say "exit", but say "return error".
Yes I think its necessary to change "exit" in comments to "return".
There are other places too in which I will have to change.
>> + if (bisect_next_check(terms, terms->term_good.buf))
>> + return -1;
>
> Mental note. The "autostart" in the original is gone. Perhaps it
> is done by next_check in this code, but we haven't seen that yet.
This will be added back again in a coming patch[1].
>> + no_checkout = !is_empty_or_missing_file(git_path_bisect_head());
>> +
>> + /* Perform all bisection computation, display and checkout */
>> + res = bisect_next_all(prefix , no_checkout);
>> +
>> + if (res == 10) {
>> + FILE *fp;
>> + unsigned char sha1[20];
>> + struct commit *commit;
>> + struct pretty_print_context pp = {0};
>> + struct strbuf commit_name = STRBUF_INIT;
>> + char *bad_ref = xstrfmt("refs/bisect/%s",
>> + terms->term_bad.buf);
>> + read_ref(bad_ref, sha1);
>> + commit = lookup_commit_reference(sha1);
>> + format_commit_message(commit, "%s", &commit_name, &pp);
>> + fp = fopen(git_path_bisect_log(), "a");
>> + if (!fp) {
>> + free(bad_ref);
>> + strbuf_release(&commit_name);
>> + return -1;
>> + }
>> + if (fprintf(fp, "# first %s commit: [%s] %s\n",
>> + terms->term_bad.buf, sha1_to_hex(sha1),
>> + commit_name.buf) < 1){
>> + free(bad_ref);
>> + strbuf_release(&commit_name);
>> + fclose(fp);
>> + return -1;
>> + }
>> + free(bad_ref);
>> + strbuf_release(&commit_name);
>> + fclose(fp);
>> + return 0;
>
> Doesn't it bother you that you have to write free(bad_ref)...fclose(fp)
> repeatedly?
My mind was more involved in the actual conversion and that was the
main part bothering me. I did all the "clean up" stuff after I did the
actual conversion. And since I was extremely happy after the porting
happened, the "cleanup stuff" didn't bother me much.
>> + }
>> + else if (res == 2) {
>> + FILE *fp;
>> + struct rev_info revs;
>> + struct argv_array rev_argv = ARGV_ARRAY_INIT;
>> + struct string_list good_revs = STRING_LIST_INIT_DUP;
>> + struct pretty_print_context pp = {0};
>> + struct commit *commit;
>> + char *term_good = xstrfmt("%s-*", terms->term_good.buf);
>> + int i;
>> +
>> + fp = fopen(git_path_bisect_log(), "a");
>> + if (!fp) {
>> + free(term_good);
>> + return -1;
>> + }
>> + if (fprintf(fp, "# only skipped commits left to test\n") < 1) {
>> + free(term_good);
>> + fclose(fp);
>> + return -1;
>> + }
>> + for_each_glob_ref_in(register_good_ref, term_good,
>> + "refs/bisect/", (void *) &good_revs);
>> +
>> + free(term_good);
>
> Doesn't it bother you that you have to write free(term_good) repeatedly?
>
>> + argv_array_pushl(&rev_argv, "skipped_commits", "refs/bisect/bad", "--not", NULL);
>> + for (i = 0; i < good_revs.nr; i++)
>> + argv_array_push(&rev_argv, good_revs.items[i].string);
>> +
>> + /* It is important to reset the flags used by revision walks
>> + * as the previous call to bisect_next_all() in turn
>> + * setups a revision walk.
>> + */
>> + reset_revision_walk();
>> + init_revisions(&revs, NULL);
>> + rev_argv.argc = setup_revisions(rev_argv.argc, rev_argv.argv, &revs, NULL);
>> + argv_array_clear(&rev_argv);
>> + string_list_clear(&good_revs, 0);
>
> Are you sure that the revision walking machinery is prepared to see
> the argv[] and elements in it you have given to setup_revisions()
> gets cleared before it starts doing the real work in
> prepare_revision_walk()? I am reasonably sure that the machinery
> borrows strings like pathspec elements from the caller and expects
> them to stay during revision traversal.
I have extremely little understanding of revision walking. All what I
know about revision walking is what's covered in
Documentation/technical/api-revision-walking.txt . There it is
mentioned that for multiple revision walking its necessary to reset.
What's happening is that there are multiple calls for revision
walking. Now bisect_next() in itself calls for revision walking two
times (the first one being with bisect_next_all and the next one
conditionally with skip). This is also the reason why I included a
reset_revision_walk() in bisect.c too in this patch. Before what used
to happen is that when git plumbing commands were called there was no
previous need for resetting the revision walk. Now that only a C code
exists after bisect_replay() conversion (I faced a problem in a
futuristic patch and thought it would be better to cover it up here),
there would be multiple calls to bisect_next(). Previously it wasn't a
problem because bisect_next_all() was a subcommand called from shell
script and for "skip" it was git-rev-list which did revision walking
as a separate thing. I didn't do reset previously and because of this
I used to get a NULL value in the revs.commits . It would be really
helpful if you could look more into it.
> You seem to have acquired a habit of freeing and clearing things
> early, which is bad. Instead, make it a habit of free/clear at the
> end, and make sure all error paths go through that central freeing
> site. That tends to future-proof your code better from leaking even
> when later other people change it.
Sure!
>> + if (prepare_revision_walk(&revs)) {
>> + die(_("revision walk setup failed\n"));
>> + }
>
> This one is still allowed to die, without clean_state?
I couldn't really test this part of code because I don't know how to
make this call fail. And this isn't covered by the test suite either.
BTW, here also it should be return error().
>> + while ((commit = get_revision(&revs)) != NULL) {
>> + struct strbuf commit_name = STRBUF_INIT;
>> + format_commit_message(commit, "%s",
>> + &commit_name, &pp);
>> + fprintf(fp, "# possible first %s commit: "
>> + "[%s] %s\n", terms->term_bad.buf,
>> + oid_to_hex(&commit->object.oid),
>> + commit_name.buf);
>> + strbuf_release(&commit_name);
>> + }
>> +
>> + fclose(fp);
>> + return res;
>> + }
>> +
>> + return res;
>> +}
>
>> @@ -415,47 +541,67 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
>> no_checkout = 1;
>>
>> for (i = 0; i < argc; i++) {
>> - if (!strcmp(argv[i], "--")) {
>> + const char *arg;
>> + if (starts_with(argv[i], "'"))
>> + arg = sq_dequote(xstrdup(argv[i]));
>> + else
>> + arg = argv[i];
>> + if (!strcmp(arg, "--")) {
>> has_double_dash = 1;
>> break;
>> }
>> }
>
> This is really bad; you are blindly assuming that anything that
> begins with " ' " begins with " ' " because "git-bisect.sh" sq-quoted
> and it never directly came from the command line that _wanted_ to
> give you something that begins with a " ' ".
>
> I suspect that you should be able to dequote on the calling script
> side. Then all these ugliness would disappear.
I had an unsuccessful attempt at it. Though this ugliness is removed
in the patch[2]. This is specifically because of the line in
bisect_replay() shell function which calls bisect_start().
>> for (i = 0; i < argc; i++) {
>> - const char *commit_id = xstrfmt("%s^{commit}", argv[i]);
>> + const char *arg, *commit_id;
>> + if (starts_with(argv[i], "'"))
>> + arg = sq_dequote(xstrdup(argv[i]));
>> + else
>> + arg = argv[i];
>
> Likewise.
>
>> + commit_id = xstrfmt("%s^{commit}", arg);
>
> In any case, I think a separate "const char *arg" that is an alias
> to argv[i] in the loop is a very good idea to do from the very
> beginning (i.e. should be done in a much much earlier patch in this
> series).
I will do it in the earlier patch.
[1]: http://public-inbox.org/git/01020156b73fe6d7-8b80c663-7c77-469e-811f-40200ec6dbb1-000000@eu-west-1.amazonses.com/
[2]: https://public-inbox.org/git/01020156b73fe6e4-d45cf1f7-03a3-4566-95d1-73788c5ab2f9-000000@eu-west-1.amazonses.com/
Regards,
Pranit Bauva
[-- Attachment #2: out2 --]
[-- Type: application/octet-stream, Size: 625 bytes --]
diff --git a/t/t6030-bisect-porcelain.sh b/t/t6030-bisect-porcelain.sh
index 18e7998..ffd66b1 100755
--- a/t/t6030-bisect-porcelain.sh
+++ b/t/t6030-bisect-porcelain.sh
@@ -911,4 +911,12 @@ test_expect_success 'git bisect reset cleans bisection state properly' '
test_path_is_missing "$GIT_DIR/BISECT_START"
'
+test_expect_success 'check whether bisection cleanup is not done with bad merge bases' '
+ HEAD=$(git rev-parse --verify HEAD) &&
+ git bisect start $HASH7 $SIDE_HASH7 &&
+ test_expect_code 3 git bisect bad >out 2>out &&
+ test_i18ngrep "The merge base " out &&
+ test -e .git/BISECT_START &&
+'
+
test_done
^ permalink raw reply related [flat|nested] 320+ messages in thread
* Re: [PATCH v14 14/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function in C
2016-08-30 18:25 ` Pranit Bauva
@ 2016-08-30 18:44 ` Pranit Bauva
2016-08-30 19:33 ` Junio C Hamano
1 sibling, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-30 18:44 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
[-- Attachment #1: Type: text/plain, Size: 2643 bytes --]
Hey Junio,
On Tue, Aug 30, 2016 at 11:55 PM, Pranit Bauva <pranit.bauva@gmail.com> wrote:
>
>>> @@ -729,7 +735,7 @@ static struct commit **get_bad_and_good_commits(int *rev_nr)
>>> return rev;
>>> }
>>>
>>> -static void handle_bad_merge_base(void)
>>> +static int handle_bad_merge_base(void)
>>> {
>>> if (is_expected_rev(current_bad_oid)) {
>>> char *bad_hex = oid_to_hex(current_bad_oid);
>>> @@ -750,17 +756,18 @@ static void handle_bad_merge_base(void)
>>> "between %s and [%s].\n"),
>>> bad_hex, term_bad, term_good, bad_hex, good_hex);
>>> }
>>> - exit(3);
>>> + return 3;
>>> }
>>>
>>> fprintf(stderr, _("Some %s revs are not ancestor of the %s rev.\n"
>>> "git bisect cannot work properly in this case.\n"
>>> "Maybe you mistook %s and %s revs?\n"),
>>> term_good, term_bad, term_good, term_bad);
>>> - exit(1);
>>> + bisect_clean_state();
>>> + return 1;
>>
>> What is the logic behind this function sometimes clean the state,
>> and some other times do not, when it makes an error-return? We see
>> above that "return 3" codepath leaves the state behind.
>>
>> Either you forgot a necessary clean_state in "return 3" codepath,
>> or you forgot to document why the distinction exists in the in-code
>> comment for the function. I cannot tell which, but I am leaning
>> towards guessing that it is the former.
>
> This is a very tricky one. I have purposely not included this after a
> lot of testing. I have hand tested with the original git and with this
> branch. The reason why anyone wouldn't be able to catch this is
> because its not covered in the test suite. I am including a patch with
> this as an attachment (because I am behind a proxy right now but don't
> worry I will include this as a commit in the next series). The
> original behaviour of git does not clean the bisect state when this
> situation occurs. On another note which you might have missed that
> bisect_clean_state() is purposely put before return 1 which is covered
> by the test suite. You can try removing it and see that there is a
> broken tes. tI was thinking of including the tests after the whole
> conversion but now I think including this before will make the
> conversion more easier for review.
The patch which I included as an attachment before will fail for
different reasons if you apply it on master branch. To test it on
master branch use the current attachment. Again sorry I couldn't
include this in the email itself.
Regards,
Pranit Bauva
[-- Attachment #2: out3 --]
[-- Type: application/octet-stream, Size: 453 bytes --]
diff --git a/t/t6030-bisect-porcelain.sh b/t/t6030-bisect-porcelain.sh
index 5e5370f..fa3f5b6 100755
--- a/t/t6030-bisect-porcelain.sh
+++ b/t/t6030-bisect-porcelain.sh
@@ -894,4 +894,10 @@ test_expect_success 'bisect start takes options and revs in any order' '
test_cmp expected actual
'
+test_expect_success 'c' '
+ git bisect start $SIDE7 $SIDE_HASH7 &&
+ test_must_fail git bisect bad >out 2>out &&
+ test -e .git/BISECT_START
+'
+
test_done
^ permalink raw reply related [flat|nested] 320+ messages in thread
* Re: [PATCH v14 14/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function in C
2016-08-30 18:25 ` Pranit Bauva
2016-08-30 18:44 ` Pranit Bauva
@ 2016-08-30 19:33 ` Junio C Hamano
2016-08-30 20:17 ` Pranit Bauva
1 sibling, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-08-30 19:33 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Git List
Pranit Bauva <pranit.bauva@gmail.com> writes:
> This is a very tricky one. I have purposely not included this after a
> lot of testing. I have hand tested with the original git and with this
> branch. The reason why anyone wouldn't be able to catch this is
> because its not covered in the test suite. I am including a patch with
> this as an attachment (because I am behind a proxy right now but don't
> worry I will include this as a commit in the next series). The
> original behaviour of git does not clean the bisect state when this
> situation occurs.
"We sometimes clean and we sometimes don't and this follows the
original" may be a valid justification but it is not a very useful
explanation. The real issue is if not cleaning is intended (and if
so why; otherwise, if it is clear that it is simply forgotten, we
can just fix it in the series as a follow-up step).
If not cleaning in some cases (but not others) is the right thing,
at least there needs an in-code comment to warn others against
"fixing" the lack of cleanups (e.g. "don't clean state here, because
the caller still wants to see what state we were for this and that
reason").
>>> + if (bisect_next_check(terms, terms->term_good.buf))
>>> + return -1;
>>
>> Mental note. The "autostart" in the original is gone. Perhaps it
>> is done by next_check in this code, but we haven't seen that yet.
>
> This will be added back again in a coming patch[1].
In other words, this series is broken at this step and the breakage
stay with the codebase until a later step?
I do not know if reordering the patches in the series is enough to
fix that, or if it is even worth to avoid such a temporary breakage.
It depends on how serious the circularity is, but I would understand
if it is too hard and not worth the effort (I think in a very early
review round some people advised against the bottom-up rewrite
because they anticipated this exact reason). At least the omission
(and later resurrection) needs to be mentioned in the log so that
people understand what is going on when they later need to bisect.
Thanks.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v14 14/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function in C
2016-08-30 19:33 ` Junio C Hamano
@ 2016-08-30 20:17 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-08-30 20:17 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Wed, Aug 31, 2016 at 1:03 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> This is a very tricky one. I have purposely not included this after a
>> lot of testing. I have hand tested with the original git and with this
>> branch. The reason why anyone wouldn't be able to catch this is
>> because its not covered in the test suite. I am including a patch with
>> this as an attachment (because I am behind a proxy right now but don't
>> worry I will include this as a commit in the next series). The
>> original behaviour of git does not clean the bisect state when this
>> situation occurs.
>
> "We sometimes clean and we sometimes don't and this follows the
> original" may be a valid justification but it is not a very useful
> explanation. The real issue is if not cleaning is intended (and if
> so why; otherwise, if it is clear that it is simply forgotten, we
> can just fix it in the series as a follow-up step).
I think we do want to recover from this "bad merge base" state and for
that not cleaning up is essential. The original behaviour of git seems
natural to me.
> If not cleaning in some cases (but not others) is the right thing,
> at least there needs an in-code comment to warn others against
> "fixing" the lack of cleanups (e.g. "don't clean state here, because
> the caller still wants to see what state we were for this and that
> reason").
I will mention it in the comments.
>>>> + if (bisect_next_check(terms, terms->term_good.buf))
>>>> + return -1;
>>>
>>> Mental note. The "autostart" in the original is gone. Perhaps it
>>> is done by next_check in this code, but we haven't seen that yet.
>>
>> This will be added back again in a coming patch[1].
>
> In other words, this series is broken at this step and the breakage
> stay with the codebase until a later step?
Broken though it passes the test suite.
> I do not know if reordering the patches in the series is enough to
> fix that, or if it is even worth to avoid such a temporary breakage.
> It depends on how serious the circularity is, but I would understand
> if it is too hard and not worth the effort (I think in a very early
> review round some people advised against the bottom-up rewrite
> because they anticipated this exact reason). At least the omission
> (and later resurrection) needs to be mentioned in the log so that
> people understand what is going on when they later need to bisect.
bisect_autostart() call from bisect_next() was introduced in the
earliest version of git-bisect in the commit 8cc6a0831 but it isn't
really a very big deal and I think it would be OK to skip it for a
very little while as any which ways the series in the end would fix
it. It is important to mention this in the commit message and I will
do it.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* [PATCH v15 05/27] t6030: explicitly test for bisection cleanup
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 02/27] bisect: rewrite `check_term_format` shell function in C Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 03/27] bisect--helper: `write_terms` " Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 09/27] bisect--helper: `bisect_write` shell function in C Pranit Bauva
` (24 subsequent siblings)
27 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
Add test to explicitly check that 'git bisect reset' is working as
expected. This is already covered implicitly by the test suite.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
I faced this problem while converting `bisect_clean_state` and the tests
where showing breakages but it wasn't clear as to where exactly are they
breaking. This will patch will help in that. Also I tested the test
coverage of the test suite before this patch and it covers this (I did
this by purposely changing names of files in git-bisect.sh and running
the test suite).
---
t/t6030-bisect-porcelain.sh | 17 +++++++++++++++++
1 file changed, 17 insertions(+)
diff --git a/t/t6030-bisect-porcelain.sh b/t/t6030-bisect-porcelain.sh
index 5e5370f..18e7998 100755
--- a/t/t6030-bisect-porcelain.sh
+++ b/t/t6030-bisect-porcelain.sh
@@ -894,4 +894,21 @@ test_expect_success 'bisect start takes options and revs in any order' '
test_cmp expected actual
'
+test_expect_success 'git bisect reset cleans bisection state properly' '
+ git bisect reset &&
+ git bisect start &&
+ git bisect good $HASH1 &&
+ git bisect bad $HASH4 &&
+ git bisect reset &&
+ test -z "$(git for-each-ref "refs/bisect/*")" &&
+ test_path_is_missing "$GIT_DIR/BISECT_EXPECTED_REV" &&
+ test_path_is_missing "$GIT_DIR/BISECT_ANCESTORS_OK" &&
+ test_path_is_missing "$GIT_DIR/BISECT_LOG" &&
+ test_path_is_missing "$GIT_DIR/BISECT_RUN" &&
+ test_path_is_missing "$GIT_DIR/BISECT_TERMS" &&
+ test_path_is_missing "$GIT_DIR/head-name" &&
+ test_path_is_missing "$GIT_DIR/BISECT_HEAD" &&
+ test_path_is_missing "$GIT_DIR/BISECT_START"
+'
+
test_done
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
` (27 preceding siblings ...)
2016-08-23 21:24 ` Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 02/27] bisect: rewrite `check_term_format` shell function in C Pranit Bauva
` (27 more replies)
28 siblings, 28 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
`--next-all` is meant to be used as a subcommand to support multiple
"operation mode" though the current implementation does not contain any
other subcommand along side with `--next-all` but further commits will
include some more subcommands.
Helped-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 17 +++++++++++------
1 file changed, 11 insertions(+), 6 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 3324229..8111c91 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -10,11 +10,11 @@ static const char * const git_bisect_helper_usage[] = {
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
- int next_all = 0;
+ enum { NEXT_ALL = 1 } cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
- OPT_BOOL(0, "next-all", &next_all,
- N_("perform 'git bisect next'")),
+ OPT_CMDMODE(0, "next-all", &cmdmode,
+ N_("perform 'git bisect next'"), NEXT_ALL),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -23,9 +23,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
argc = parse_options(argc, argv, prefix, options,
git_bisect_helper_usage, 0);
- if (!next_all)
+ if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
- /* next-all */
- return bisect_next_all(prefix, no_checkout);
+ switch (cmdmode) {
+ case NEXT_ALL:
+ return bisect_next_all(prefix, no_checkout);
+ default:
+ die("BUG: unknown subcommand '%d'", cmdmode);
+ }
+ return 0;
}
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 03/27] bisect--helper: `write_terms` shell function in C
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 02/27] bisect: rewrite `check_term_format` shell function in C Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 05/27] t6030: explicitly test for bisection cleanup Pranit Bauva
` (25 subsequent siblings)
27 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
Reimplement the `write_terms` shell function in C and add a `write-terms`
subcommand to `git bisect--helper` to call it from git-bisect.sh . Also
remove the subcommand `--check-term-format` as it can now be called from
inside the function write_terms() C implementation.
Also `|| exit` is added when calling write-terms subcommand from
git-bisect.sh so as to exit whenever there is an error.
Using `--write-terms` subcommand is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and its implementation will
be called by some other method.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 36 +++++++++++++++++++++++++++++-------
git-bisect.sh | 22 +++++++---------------
2 files changed, 36 insertions(+), 22 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index a47f1f2..65cf519 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -4,9 +4,11 @@
#include "bisect.h"
#include "refs.h"
+static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
+
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
- N_("git bisect--helper --check-term-format <term> <orig_term>"),
+ N_("git bisect--helper --write-terms <bad_term> <good_term>"),
NULL
};
@@ -57,18 +59,38 @@ static int check_term_format(const char *term, const char *orig_term)
return 0;
}
+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;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
- CHECK_TERM_FMT
+ WRITE_TERMS
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
- OPT_CMDMODE(0, "check-term-format", &cmdmode,
- N_("check format of the term"), CHECK_TERM_FMT),
+ OPT_CMDMODE(0, "write-terms", &cmdmode,
+ N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -83,10 +105,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
switch (cmdmode) {
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
- case CHECK_TERM_FMT:
+ case WRITE_TERMS:
if (argc != 2)
- die(_("--check-term-format requires two arguments"));
- return check_term_format(argv[0], argv[1]);
+ die(_("--write-terms requires two arguments"));
+ return write_terms(argv[0], argv[1]);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index a727c59..9ef6cb8 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -209,7 +209,7 @@ bisect_start() {
eval "$eval true" &&
if test $must_write_terms -eq 1
then
- write_terms "$TERM_BAD" "$TERM_GOOD"
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD"
fi &&
echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
#
@@ -557,18 +557,6 @@ get_terms () {
fi
}
-write_terms () {
- TERM_BAD=$1
- TERM_GOOD=$2
- if test "$TERM_BAD" = "$TERM_GOOD"
- then
- die "$(gettext "please use two different terms")"
- fi
- git bisect--helper --check-term-format "$TERM_BAD" bad || exit
- git bisect--helper --check-term-format "$TERM_GOOD" good || exit
- printf '%s\n%s\n' "$TERM_BAD" "$TERM_GOOD" >"$GIT_DIR/BISECT_TERMS"
-}
-
check_and_set_terms () {
cmd="$1"
case "$cmd" in
@@ -582,13 +570,17 @@ check_and_set_terms () {
bad|good)
if ! test -s "$GIT_DIR/BISECT_TERMS"
then
- write_terms bad good
+ TERM_BAD=bad
+ TERM_GOOD=good
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
fi
;;
new|old)
if ! test -s "$GIT_DIR/BISECT_TERMS"
then
- write_terms new old
+ TERM_BAD=new
+ TERM_GOOD=old
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
fi
;;
esac ;;
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 02/27] bisect: rewrite `check_term_format` shell function in C
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-11-14 22:20 ` Stephan Beyer
2016-10-14 14:14 ` [PATCH v15 03/27] bisect--helper: `write_terms` " Pranit Bauva
` (26 subsequent siblings)
27 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
Reimplement the `check_term_format` shell function in C and add
a `--check-term-format` subcommand to `git bisect--helper` to call it
from git-bisect.sh
Using `--check-term-format` subcommand is a temporary measure to port
shell function to C so as to use the existing test suite. As more
functions are ported, this subcommand will be retired and its
implementation will be called by some other method/subcommand. For
eg. In conversion of write_terms() of git-bisect.sh, the subcommand will
be removed and instead check_term_format() will be called in its C
implementation while a new subcommand will be introduced for write_terms().
Helped-by: Johannes Schindelein <Johannes.Schindelein@gmx.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 60 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 31 ++-----------------------
2 files changed, 61 insertions(+), 30 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 8111c91..a47f1f2 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -2,19 +2,73 @@
#include "cache.h"
#include "parse-options.h"
#include "bisect.h"
+#include "refs.h"
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
+ N_("git bisect--helper --check-term-format <term> <orig_term>"),
NULL
};
+/*
+ * 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",
+ "visualize", "replay", "log", "run", NULL))
+ 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;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
- enum { NEXT_ALL = 1 } cmdmode = 0;
+ enum {
+ NEXT_ALL = 1,
+ CHECK_TERM_FMT
+ } cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
+ OPT_CMDMODE(0, "check-term-format", &cmdmode,
+ N_("check format of the term"), CHECK_TERM_FMT),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -29,6 +83,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
switch (cmdmode) {
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
+ case CHECK_TERM_FMT:
+ if (argc != 2)
+ die(_("--check-term-format requires two arguments"));
+ return check_term_format(argv[0], argv[1]);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index ae3cb01..a727c59 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -564,38 +564,11 @@ write_terms () {
then
die "$(gettext "please use two different terms")"
fi
- check_term_format "$TERM_BAD" bad
- check_term_format "$TERM_GOOD" good
+ git bisect--helper --check-term-format "$TERM_BAD" bad || exit
+ git bisect--helper --check-term-format "$TERM_GOOD" good || exit
printf '%s\n%s\n' "$TERM_BAD" "$TERM_GOOD" >"$GIT_DIR/BISECT_TERMS"
}
-check_term_format () {
- term=$1
- git check-ref-format refs/bisect/"$term" ||
- die "$(eval_gettext "'\$term' is not a valid term")"
- case "$term" in
- help|start|terms|skip|next|reset|visualize|replay|log|run)
- die "$(eval_gettext "can't use the builtin command '\$term' as a term")"
- ;;
- bad|new)
- if test "$2" != bad
- then
- # 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.
- die "$(eval_gettext "can't change the meaning of term '\$term'")"
- fi
- ;;
- good|old)
- if test "$2" != good
- then
- die "$(eval_gettext "can't change the meaning of term '\$term'")"
- fi
- ;;
- esac
-}
-
check_and_set_terms () {
cmd="$1"
case "$cmd" in
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 06/27] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file()
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (7 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 10/27] bisect--helper: `check_and_set_terms` " Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 13/27] bisect--helper: `bisect_start` shell function partially in C Pranit Bauva
` (18 subsequent siblings)
27 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
is_empty_file() can help to refactor a lot of code. This will be very
helpful in porting "git bisect" to C.
Suggested-by: Torsten Bögershausen <tboegi@web.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/am.c | 20 ++------------------
cache.h | 3 +++
wrapper.c | 13 +++++++++++++
3 files changed, 18 insertions(+), 18 deletions(-)
diff --git a/builtin/am.c b/builtin/am.c
index 739b34d..9e1e9d6 100644
--- a/builtin/am.c
+++ b/builtin/am.c
@@ -30,22 +30,6 @@
#include "mailinfo.h"
/**
- * Returns 1 if the file is empty or does not exist, 0 otherwise.
- */
-static int is_empty_file(const char *filename)
-{
- struct stat st;
-
- if (stat(filename, &st) < 0) {
- if (errno == ENOENT)
- return 1;
- die_errno(_("could not stat %s"), filename);
- }
-
- return !st.st_size;
-}
-
-/**
* Returns the length of the first line of msg.
*/
static int linelen(const char *msg)
@@ -1324,7 +1308,7 @@ static int parse_mail(struct am_state *state, const char *mail)
goto finish;
}
- if (is_empty_file(am_path(state, "patch"))) {
+ if (is_empty_or_missing_file(am_path(state, "patch"))) {
printf_ln(_("Patch is empty. Was it split wrong?"));
die_user_resolve(state);
}
@@ -1896,7 +1880,7 @@ static void am_run(struct am_state *state, int resume)
resume = 0;
}
- if (!is_empty_file(am_path(state, "rewritten"))) {
+ if (!is_empty_or_missing_file(am_path(state, "rewritten"))) {
assert(state->rebasing);
copy_notes_for_rebase(state);
run_post_rewrite_hook(state);
diff --git a/cache.h b/cache.h
index b780a91..49f214b 100644
--- a/cache.h
+++ b/cache.h
@@ -1916,4 +1916,7 @@ void sleep_millisec(int millisec);
*/
void safe_create_dir(const char *dir, int share);
+/* Return 1 if the file is empty or does not exists, 0 otherwise. */
+extern int is_empty_or_missing_file(const char *filename);
+
#endif /* CACHE_H */
diff --git a/wrapper.c b/wrapper.c
index e7f1979..78f6431 100644
--- a/wrapper.c
+++ b/wrapper.c
@@ -679,3 +679,16 @@ void sleep_millisec(int millisec)
{
poll(NULL, 0, millisec);
}
+
+int is_empty_or_missing_file(const char *filename)
+{
+ struct stat st;
+
+ if (stat(filename, &st) < 0) {
+ if (errno == ENOENT)
+ return 1;
+ die_errno(_("could not stat %s"), filename);
+ }
+
+ return !st.st_size;
+}
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 22/27] bisect--helper: `bisect_log` shell function in C
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (11 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 07/27] bisect--helper: `bisect_reset` " Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-11-17 21:47 ` Stephan Beyer
2016-10-14 14:14 ` [PATCH v15 14/27] t6030: no cleanup with bad merge base Pranit Bauva
` (14 subsequent siblings)
27 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
Reimplement the `bisect_log` shell function in C and also add
`--bisect-log` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Using `--bisect-log` subcommand is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other method.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 27 ++++++++++++++++++++++++++-
git-bisect.sh | 7 +------
2 files changed, 27 insertions(+), 7 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 493034c..c18ca07 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -858,6 +858,23 @@ static int bisect_state(struct bisect_terms *terms, const char **argv,
return -1;
}
+static int bisect_log(void)
+{
+ int fd, status;
+ fd = open(git_path_bisect_log(), O_RDONLY);
+ if (fd < 0)
+ return -1;
+
+ status = copy_fd(fd, 1);
+ if (status) {
+ close(fd);
+ return -1;
+ }
+
+ close(fd);
+ return status;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -870,7 +887,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_NEXT,
BISECT_AUTO_NEXT,
BISECT_AUTOSTART,
- BISECT_STATE
+ BISECT_STATE,
+ BISECT_LOG
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -894,6 +912,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("start the bisection if BISECT_START empty or missing"), BISECT_AUTOSTART),
OPT_CMDMODE(0, "bisect-state", &cmdmode,
N_("mark the state of ref (or refs)"), BISECT_STATE),
+ OPT_CMDMODE(0, "bisect-log", &cmdmode,
+ N_("output the contents of BISECT_LOG"), BISECT_LOG),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -973,6 +993,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
get_terms(&terms);
res = bisect_state(&terms, argv, argc);
break;
+ case BISECT_LOG:
+ if (argc > 1)
+ die(_("--bisect-log requires 0 arguments"));
+ res = bisect_log();
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index a9eebbb..a47e3b5 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -166,11 +166,6 @@ exit code \$res from '\$command' is < 0 or >= 128" >&2
done
}
-bisect_log () {
- test -s "$GIT_DIR/BISECT_LOG" || die "$(gettext "We are not bisecting.")"
- cat "$GIT_DIR/BISECT_LOG"
-}
-
get_terms () {
if test -s "$GIT_DIR/BISECT_TERMS"
then
@@ -208,7 +203,7 @@ case "$#" in
replay)
bisect_replay "$@" ;;
log)
- bisect_log ;;
+ git bisect--helper --bisect-log ;;
run)
bisect_run "$@" ;;
terms)
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 10/27] bisect--helper: `check_and_set_terms` shell function in C
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (6 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 18/27] bisect--helper: `bisect_autostart` shell function in C Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-11-17 20:25 ` Stephan Beyer
2016-10-14 14:14 ` [PATCH v15 06/27] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
` (19 subsequent siblings)
27 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
Reimplement the `check_and_set_terms` shell function in C and add
`check-and-set-terms` subcommand to `git bisect--helper` to call it from
git-bisect.sh
Using `--check-and-set-terms` subcommand is a temporary measure to port
shell function in C so as to use the existing test suite. As more
functions are ported, this subcommand will be retired but its
implementation will be called by some other methods.
check_and_set_terms() sets and receives two global variables namely
TERM_GOOD and TERM_BAD in the shell script. Luckily the file BISECT_TERMS
also contains the value of those variables so its appropriate to evoke the
method get_terms() after calling the subcommand so that it retrieves the
value of TERM_GOOD and TERM_BAD from the file BISECT_TERMS. The two
global variables are passed as arguments to the subcommand.
Also introduce set_terms() to copy the `term_good` and `term_bad` into
`struct bisect_terms` and write it out to the file BISECT_TERMS.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 45 ++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 36 ++++--------------------------------
2 files changed, 48 insertions(+), 33 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 3f19b68..c6c11e3 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -20,6 +20,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-clean-state"),
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
+ N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
NULL
};
@@ -212,6 +213,38 @@ static int bisect_write(const char *state, const char *rev,
return retval;
}
+static int set_terms(struct bisect_terms *terms, const char *bad,
+ const char *good)
+{
+ terms->term_good = xstrdup(good);
+ terms->term_bad = xstrdup(bad);
+ return write_terms(terms->term_bad, terms->term_good);
+}
+
+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))
+ return set_terms(terms, "bad", "good");
+ if (one_of(cmd, "new", "old", NULL))
+ return set_terms(terms, "new", "old");
+ }
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -220,7 +253,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_CLEAN_STATE,
BISECT_RESET,
CHECK_EXPECTED_REVS,
- BISECT_WRITE
+ BISECT_WRITE,
+ CHECK_AND_SET_TERMS
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -236,6 +270,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check for expected revs"), CHECK_EXPECTED_REVS),
OPT_CMDMODE(0, "bisect-write", &cmdmode,
N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
+ OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
+ N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -278,6 +314,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
terms.term_bad = xstrdup(argv[3]);
res = bisect_write(argv[0], argv[1], &terms, nolog);
break;
+ case CHECK_AND_SET_TERMS:
+ if (argc != 3)
+ die(_("--check-and-set-terms requires 3 arguments"));
+ terms.term_good = xstrdup(argv[1]);
+ terms.term_bad = xstrdup(argv[2]);
+ res = check_and_set_terms(&terms, argv[0]);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index dfdec33..bdf2227 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -238,7 +238,8 @@ bisect_skip() {
bisect_state() {
bisect_autostart
state=$1
- check_and_set_terms $state
+ git bisect--helper --check-and-set-terms $state $TERM_GOOD $TERM_BAD || exit
+ get_terms
case "$#,$state" in
0,*)
die "Please call 'bisect_state' with at least one argument." ;;
@@ -390,7 +391,8 @@ bisect_replay () {
command="$bisect"
fi
get_terms
- check_and_set_terms "$command"
+ git bisect--helper --check-and-set-terms "$command" "$TERM_GOOD" "$TERM_BAD" || exit
+ get_terms
case "$command" in
start)
cmd="bisect_start $rev"
@@ -480,36 +482,6 @@ get_terms () {
fi
}
-check_and_set_terms () {
- cmd="$1"
- case "$cmd" in
- skip|start|terms) ;;
- *)
- if test -s "$GIT_DIR/BISECT_TERMS" && test "$cmd" != "$TERM_BAD" && test "$cmd" != "$TERM_GOOD"
- then
- die "$(eval_gettext "Invalid command: you're currently in a \$TERM_BAD/\$TERM_GOOD bisect.")"
- fi
- case "$cmd" in
- bad|good)
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- TERM_BAD=bad
- TERM_GOOD=good
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
- fi
- ;;
- new|old)
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- TERM_BAD=new
- TERM_GOOD=old
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
- fi
- ;;
- esac ;;
- esac
-}
-
bisect_voc () {
case "$1" in
bad) echo "bad|new" ;;
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 23/27] bisect--helper: `bisect_replay` shell function in C
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (24 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 27/27] bisect--helper: remove the dequote in bisect_start() Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-11-22 0:49 ` Stephan Beyer
2016-10-14 15:12 ` [PATCH v15 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
2016-10-27 16:59 ` [PATCH v15 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Junio C Hamano
27 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
Reimplement the `bisect_replay` shell function in C and also add
`--bisect-replay` subcommand to `git bisect--helper` to call it from
git-bisect.sh
Using `--bisect-replay` subcommand is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other method.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 125 ++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 32 +-----------
2 files changed, 124 insertions(+), 33 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index c18ca07..b367d8d 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -32,6 +32,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-autostart"),
N_("git bisect--helper --bisect-state (bad|new) [<rev>]"),
N_("git bisect--helper --bisect-state (good|old) [<rev>...]"),
+ N_("git bisect--helper --bisect-replay <filename>"),
NULL
};
@@ -601,7 +602,6 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
terms->term_good = arg;
} else if (!strcmp(arg, "--term-bad") ||
!strcmp(arg, "--term-new")) {
- const char *next_arg;
if (starts_with(argv[++i], "'"))
terms->term_bad = sq_dequote(xstrdup(argv[i]));
else
@@ -875,6 +875,117 @@ static int bisect_log(void)
return status;
}
+static int get_next_word(const char *line, int pos, struct strbuf *word)
+{
+ int i, len = strlen(line), begin = 0;
+ strbuf_reset(word);
+ for (i = pos; i < len; i++) {
+ if (line[i] == ' ' && begin)
+ return i + 1;
+
+ if (!begin)
+ begin = 1;
+ strbuf_addch(word, line[i]);
+ }
+
+ return i;
+}
+
+static int bisect_replay(struct bisect_terms *terms, const char *filename)
+{
+ struct strbuf line = STRBUF_INIT;
+ struct strbuf word = STRBUF_INIT;
+ FILE *fp = NULL;
+ int res = 0;
+
+ if (is_empty_or_missing_file(filename)) {
+ error(_("no such file with name '%s' exists"), filename);
+ res = -1;
+ goto finish;
+ }
+
+ if (bisect_reset(NULL)) {
+ res = -1;
+ goto finish;
+ }
+
+ fp = fopen(filename, "r");
+ if (!fp) {
+ res = -1;
+ goto finish;
+ }
+
+ while (strbuf_getline(&line, fp) != EOF) {
+ int pos = 0;
+ while (pos < line.len) {
+ pos = get_next_word(line.buf, pos, &word);
+
+ if (!strcmp(word.buf, "git")) {
+ continue;
+ } else if (!strcmp(word.buf, "git-bisect")) {
+ continue;
+ } else if (!strcmp(word.buf, "bisect")) {
+ continue;
+ } else if (!strcmp(word.buf, "#")) {
+ break;
+ }
+
+ get_terms(terms);
+ if (check_and_set_terms(terms, word.buf)) {
+ res = -1;
+ goto finish;
+ }
+
+ if (!strcmp(word.buf, "start")) {
+ struct argv_array argv = ARGV_ARRAY_INIT;
+ sq_dequote_to_argv_array(line.buf+pos, &argv);
+ if (bisect_start(terms, 0, argv.argv, argv.argc)) {
+ argv_array_clear(&argv);
+ res = -1;
+ goto finish;
+ }
+ argv_array_clear(&argv);
+ break;
+ }
+
+ if (one_of(word.buf, terms->term_good,
+ terms->term_bad, "skip", NULL)) {
+ if (bisect_write(word.buf, line.buf+pos, terms, 0)) {
+ res = -1;
+ goto finish;
+ }
+ break;
+ }
+
+ if (!strcmp(word.buf, "terms")) {
+ struct argv_array argv = ARGV_ARRAY_INIT;
+ sq_dequote_to_argv_array(line.buf+pos, &argv);
+ if (bisect_terms(terms, argv.argv, argv.argc)) {
+ argv_array_clear(&argv);
+ res = -1;
+ goto finish;
+ }
+ argv_array_clear(&argv);
+ break;
+ }
+
+ error(_("?? what are you talking about?"));
+ res = -1;
+ goto finish;
+ }
+ }
+ goto finish;
+finish:
+ if (fp)
+ fclose(fp);
+ strbuf_release(&line);
+ strbuf_release(&word);
+ if (res)
+ return -1;
+
+ return bisect_auto_next(terms, NULL);
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -888,7 +999,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_AUTO_NEXT,
BISECT_AUTOSTART,
BISECT_STATE,
- BISECT_LOG
+ BISECT_LOG,
+ BISECT_REPLAY
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -914,6 +1026,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("mark the state of ref (or refs)"), BISECT_STATE),
OPT_CMDMODE(0, "bisect-log", &cmdmode,
N_("output the contents of BISECT_LOG"), BISECT_LOG),
+ OPT_CMDMODE(0, "bisect-replay", &cmdmode,
+ N_("replay the bisection process from the given file"), BISECT_REPLAY),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -998,6 +1112,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
die(_("--bisect-log requires 0 arguments"));
res = bisect_log();
break;
+ case BISECT_REPLAY:
+ if (argc != 1)
+ die(_("--bisect-replay requires 1 argument"));
+ terms.term_good = "good";
+ terms.term_bad = "bad";
+ res = bisect_replay(&terms, argv[0]);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index a47e3b5..bf66ee2 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -77,36 +77,6 @@ bisect_visualize() {
eval '"$@"' --bisect -- $(cat "$GIT_DIR/BISECT_NAMES")
}
-bisect_replay () {
- file="$1"
- test "$#" -eq 1 || die "$(gettext "No logfile given")"
- test -r "$file" || die "$(eval_gettext "cannot read \$file for replaying")"
- git bisect--helper --bisect-reset || exit
- while read git bisect command rev
- do
- test "$git $bisect" = "git bisect" || test "$git" = "git-bisect" || continue
- if test "$git" = "git-bisect"
- then
- rev="$command"
- command="$bisect"
- fi
- get_terms
- git bisect--helper --check-and-set-terms "$command" "$TERM_GOOD" "$TERM_BAD" || exit
- get_terms
- case "$command" in
- start)
- eval "git bisect--helper --bisect-start $rev" ;;
- "$TERM_GOOD"|"$TERM_BAD"|skip)
- git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
- terms)
- git bisect--helper --bisect-terms $rev || exit;;
- *)
- die "$(gettext "?? what are you talking about?")" ;;
- esac
- done <"$file"
- git bisect--helper --bisect-auto-next
-}
-
bisect_run () {
git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD fail || exit
@@ -201,7 +171,7 @@ case "$#" in
reset)
git bisect--helper --bisect-reset "$@" ;;
replay)
- bisect_replay "$@" ;;
+ git bisect--helper --bisect-replay "$@" ;;
log)
git bisect--helper --bisect-log ;;
run)
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 04/27] bisect--helper: `bisect_clean_state` shell function in C
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (18 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 25/27] bisect--helper: retire `--bisect-autostart` subcommand Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-11-15 21:09 ` Stephan Beyer
2016-10-14 14:14 ` [PATCH v15 26/27] bisect--helper: retire `--bisect-auto-next` subcommand Pranit Bauva
` (7 subsequent siblings)
27 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
Reimplement `bisect_clean_state` shell function in C and add a
`bisect-clean-state` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Using `--bisect-clean-state` subcommand is a measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by bisect_reset() and bisect_start().
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
bisect.c | 43 +++++++++++++++++++++++++++++++++++++++++++
bisect.h | 2 ++
builtin/bisect--helper.c | 14 +++++++++++++-
git-bisect.sh | 26 +++-----------------------
4 files changed, 61 insertions(+), 24 deletions(-)
diff --git a/bisect.c b/bisect.c
index 6f512c2..45d598d 100644
--- a/bisect.c
+++ b/bisect.c
@@ -430,6 +430,12 @@ static int read_bisect_refs(void)
static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
+static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
+static GIT_PATH_FUNC(git_path_bisect_run, "BISECT_RUN")
+static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
+static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
+static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
+static GIT_PATH_FUNC(git_path_head_name, "head-name")
static void read_bisect_paths(struct argv_array *array)
{
@@ -1040,3 +1046,40 @@ int estimate_bisect_steps(int all)
return (e < 3 * x) ? n : n - 1;
}
+
+static int mark_for_removal(const char *refname, const struct object_id *oid,
+ int flag, void *cb_data)
+{
+ struct string_list *refs = cb_data;
+ char *ref = xstrfmt("refs/bisect%s", refname);
+ string_list_append(refs, ref);
+ return 0;
+}
+
+int bisect_clean_state(void)
+{
+ int result = 0;
+
+ /* There may be some refs packed during bisection */
+ struct string_list refs_for_removal = STRING_LIST_INIT_NODUP;
+ for_each_ref_in("refs/bisect", mark_for_removal, (void *) &refs_for_removal);
+ string_list_append(&refs_for_removal, xstrdup("BISECT_HEAD"));
+ result = delete_refs(&refs_for_removal, REF_NODEREF);
+ refs_for_removal.strdup_strings = 1;
+ string_list_clear(&refs_for_removal, 0);
+ unlink_or_warn(git_path_bisect_expected_rev());
+ unlink_or_warn(git_path_bisect_ancestors_ok());
+ unlink_or_warn(git_path_bisect_log());
+ unlink_or_warn(git_path_bisect_names());
+ unlink_or_warn(git_path_bisect_run());
+ unlink_or_warn(git_path_bisect_terms());
+ /* Cleanup head-name if it got left by an old version of git-bisect */
+ unlink_or_warn(git_path_head_name());
+ /*
+ * Cleanup BISECT_START last to support the --no-checkout option
+ * introduced in the commit 4796e823a.
+ */
+ unlink_or_warn(git_path_bisect_start());
+
+ return result;
+}
diff --git a/bisect.h b/bisect.h
index acd12ef..0ae63d4 100644
--- a/bisect.h
+++ b/bisect.h
@@ -28,4 +28,6 @@ extern int estimate_bisect_steps(int all);
extern void read_bisect_terms(const char **bad, const char **good);
+extern int bisect_clean_state(void);
+
#endif
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 65cf519..4254d61 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -5,10 +5,15 @@
#include "refs.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
+static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
+static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
+static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
+static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
+ N_("git bisect--helper --bisect-clean-state"),
NULL
};
@@ -83,7 +88,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
- WRITE_TERMS
+ WRITE_TERMS,
+ BISECT_CLEAN_STATE
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -91,6 +97,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("perform 'git bisect next'"), NEXT_ALL),
OPT_CMDMODE(0, "write-terms", &cmdmode,
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
+ OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
+ N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -109,6 +117,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc != 2)
die(_("--write-terms requires two arguments"));
return write_terms(argv[0], argv[1]);
+ case BISECT_CLEAN_STATE:
+ if (argc != 0)
+ die(_("--bisect-clean-state requires no arguments"));
+ return bisect_clean_state();
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 9ef6cb8..f1202df 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -186,7 +186,7 @@ bisect_start() {
#
# Get rid of any old bisect state.
#
- bisect_clean_state || exit
+ git bisect--helper --bisect-clean-state || exit
#
# Change state.
@@ -195,7 +195,7 @@ bisect_start() {
# We have to trap this to be able to clean up using
# "bisect_clean_state".
#
- trap 'bisect_clean_state' 0
+ trap 'git bisect--helper --bisect-clean-state' 0
trap 'exit 255' 1 2 3 15
#
@@ -430,27 +430,7 @@ bisect_reset() {
die "$(eval_gettext "Could not check out original HEAD '\$branch'.
Try 'git bisect reset <commit>'.")"
fi
- bisect_clean_state
-}
-
-bisect_clean_state() {
- # There may be some refs packed during bisection.
- git for-each-ref --format='%(refname) %(objectname)' refs/bisect/\* |
- while read ref hash
- do
- git update-ref -d $ref $hash || exit
- done
- rm -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
- rm -f "$GIT_DIR/BISECT_ANCESTORS_OK" &&
- rm -f "$GIT_DIR/BISECT_LOG" &&
- rm -f "$GIT_DIR/BISECT_NAMES" &&
- rm -f "$GIT_DIR/BISECT_RUN" &&
- rm -f "$GIT_DIR/BISECT_TERMS" &&
- # Cleanup head-name if it got left by an old version of git-bisect
- rm -f "$GIT_DIR/head-name" &&
- git update-ref -d --no-deref BISECT_HEAD &&
- # clean up BISECT_START last
- rm -f "$GIT_DIR/BISECT_START"
+ git bisect--helper --bisect-clean-state || exit
}
bisect_replay () {
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 09/27] bisect--helper: `bisect_write` shell function in C
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (2 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 05/27] t6030: explicitly test for bisection cleanup Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-11-17 9:40 ` Stephan Beyer
2016-10-14 14:14 ` [PATCH v15 20/27] bisect--helper: retire `--check-expected-revs` subcommand Pranit Bauva
` (23 subsequent siblings)
27 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
Reimplement the `bisect_write` shell function in C and add a
`bisect-write` subcommand to `git bisect--helper` to call it from
git-bisect.sh
Using `--bisect-write` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by some other methods.
Note: bisect_write() uses two variables namely TERM_GOOD and TERM_BAD
from the global shell script thus we need to pass it to the subcommand
using the arguments. We then store them in a struct bisect_terms and
pass the memory address around functions.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 94 ++++++++++++++++++++++++++++++++++++++++++++----
git-bisect.sh | 25 +++----------
2 files changed, 91 insertions(+), 28 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index c542e8b..3f19b68 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -19,9 +19,15 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-clean-state"),
N_("git bisect--helper --bisect-reset [<commit>]"),
+ N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
NULL
};
+struct bisect_terms {
+ const char *term_good;
+ const char *term_bad;
+};
+
/*
* Check whether the string `term` belongs to the set of strings
* included in the variable arguments.
@@ -149,6 +155,63 @@ static int check_expected_revs(const char **revs, int rev_nr)
return 0;
}
+static int bisect_write(const char *state, const char *rev,
+ const struct bisect_terms *terms, int nolog)
+{
+ struct strbuf tag = STRBUF_INIT;
+ struct strbuf commit_name = STRBUF_INIT;
+ struct object_id oid;
+ struct commit *commit;
+ struct pretty_print_context pp = {0};
+ FILE *fp = NULL;
+ int retval = 0;
+
+ 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 {
+ error(_("Bad bisect_write argument: %s"), state);
+ retval = -1;
+ goto finish;
+ }
+
+ if (get_oid(rev, &oid)) {
+ error(_("couldn't get the oid of the rev '%s'"), rev);
+ retval = -1;
+ goto finish;
+ }
+
+ if (update_ref(NULL, tag.buf, oid.hash, NULL, 0,
+ UPDATE_REFS_MSG_ON_ERR)) {
+ retval = -1;
+ goto finish;
+ }
+
+ fp = fopen(git_path_bisect_log(), "a");
+ if (!fp) {
+ error_errno(_("couldn't open the file '%s'"), git_path_bisect_log());
+ retval = -1;
+ goto finish;
+ }
+
+ commit = lookup_commit_reference(oid.hash);
+ format_commit_message(commit, "%s", &commit_name, &pp);
+ fprintf(fp, "# %s: [%s] %s\n", state, sha1_to_hex(oid.hash),
+ commit_name.buf);
+
+ if (!nolog)
+ fprintf(fp, "git bisect %s %s\n", state, rev);
+
+ goto finish;
+finish:
+ if (fp)
+ fclose(fp);
+ strbuf_release(&tag);
+ strbuf_release(&commit_name);
+ return retval;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -156,9 +219,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
WRITE_TERMS,
BISECT_CLEAN_STATE,
BISECT_RESET,
- CHECK_EXPECTED_REVS
+ CHECK_EXPECTED_REVS,
+ BISECT_WRITE
} cmdmode = 0;
- int no_checkout = 0;
+ int no_checkout = 0, res = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
@@ -170,10 +234,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("reset the bisection state"), BISECT_RESET),
OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
N_("check for expected revs"), CHECK_EXPECTED_REVS),
+ OPT_CMDMODE(0, "bisect-write", &cmdmode,
+ N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
};
+ struct bisect_terms terms;
argc = parse_options(argc, argv, prefix, options,
git_bisect_helper_usage, 0);
@@ -182,24 +249,37 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
usage_with_options(git_bisect_helper_usage, options);
switch (cmdmode) {
+ int nolog;
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
case WRITE_TERMS:
if (argc != 2)
die(_("--write-terms requires two arguments"));
- return write_terms(argv[0], argv[1]);
+ res = write_terms(argv[0], argv[1]);
+ break;
case BISECT_CLEAN_STATE:
if (argc != 0)
die(_("--bisect-clean-state requires no arguments"));
- return bisect_clean_state();
+ res = bisect_clean_state();
+ break;
case BISECT_RESET:
if (argc > 1)
die(_("--bisect-reset requires either zero or one arguments"));
- return bisect_reset(argc ? argv[0] : NULL);
+ res = bisect_reset(argc ? argv[0] : NULL);
+ break;
case CHECK_EXPECTED_REVS:
- return check_expected_revs(argv, argc);
+ res = check_expected_revs(argv, argc);
+ break;
+ case BISECT_WRITE:
+ if (argc != 4 && argc != 5)
+ die(_("--bisect-write requires either 4 or 5 arguments"));
+ nolog = (argc == 5) && !strcmp(argv[4], "nolog");
+ terms.term_good = xstrdup(argv[2]);
+ terms.term_bad = xstrdup(argv[3]);
+ res = bisect_write(argv[0], argv[1], &terms, nolog);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
- return 0;
+ return res;
}
diff --git a/git-bisect.sh b/git-bisect.sh
index c3e43248..dfdec33 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -144,7 +144,7 @@ bisect_start() {
0) state=$TERM_BAD ; bad_seen=1 ;;
*) state=$TERM_GOOD ;;
esac
- eval="$eval bisect_write '$state' '$rev' 'nolog' &&"
+ eval="$eval git bisect--helper --bisect-write '$state' '$rev' '$TERM_GOOD' '$TERM_BAD' 'nolog' &&"
done
#
# Verify HEAD.
@@ -220,23 +220,6 @@ bisect_start() {
trap '-' 0
}
-bisect_write() {
- state="$1"
- rev="$2"
- nolog="$3"
- case "$state" in
- "$TERM_BAD")
- tag="$state" ;;
- "$TERM_GOOD"|skip)
- tag="$state"-"$rev" ;;
- *)
- die "$(eval_gettext "Bad bisect_write argument: \$state")" ;;
- esac
- git update-ref "refs/bisect/$tag" "$rev" || exit
- echo "# $state: $(git show-branch $rev)" >>"$GIT_DIR/BISECT_LOG"
- test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -263,7 +246,7 @@ bisect_state() {
bisected_head=$(bisect_head)
rev=$(git rev-parse --verify "$bisected_head") ||
die "$(eval_gettext "Bad rev input: \$bisected_head")"
- bisect_write "$state" "$rev"
+ git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
git bisect--helper --check-expected-revs "$rev" ;;
2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
shift
@@ -276,7 +259,7 @@ bisect_state() {
done
for rev in $hash_list
do
- bisect_write "$state" "$rev"
+ git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
done
git bisect--helper --check-expected-revs $hash_list ;;
*,"$TERM_BAD")
@@ -413,7 +396,7 @@ bisect_replay () {
cmd="bisect_start $rev"
eval "$cmd" ;;
"$TERM_GOOD"|"$TERM_BAD"|skip)
- bisect_write "$command" "$rev" ;;
+ git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
terms)
bisect_terms $rev ;;
*)
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 20/27] bisect--helper: retire `--check-expected-revs` subcommand
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (3 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 09/27] bisect--helper: `bisect_write` shell function in C Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 17/27] bisect--helper: retire `--next-all` subcommand Pranit Bauva
` (22 subsequent siblings)
27 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
The `--check-expected-revs` subcommand is no longer used in the shell
script and the function `check_expected_revs()` is called from the C
implementation of `bisect_next()`.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 6 ------
1 file changed, 6 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 1481c6d..d5fe35b 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -864,7 +864,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
enum {
WRITE_TERMS = 1,
BISECT_RESET,
- CHECK_EXPECTED_REVS,
BISECT_WRITE,
CHECK_AND_SET_TERMS,
BISECT_NEXT_CHECK,
@@ -881,8 +880,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
N_("reset the bisection state"), BISECT_RESET),
- OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
- N_("check for expected revs"), CHECK_EXPECTED_REVS),
OPT_CMDMODE(0, "bisect-write", &cmdmode,
N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
@@ -926,9 +923,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
die(_("--bisect-reset requires either zero or one arguments"));
res = bisect_reset(argc ? argv[0] : NULL);
break;
- case CHECK_EXPECTED_REVS:
- res = check_expected_revs(argv, argc);
- break;
case BISECT_WRITE:
if (argc != 4 && argc != 5)
die(_("--bisect-write requires either 4 or 5 arguments"));
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 12/27] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (21 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 16/27] bisect--helper: retire `--bisect-clean-state` subcommand Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-11-17 21:32 ` Stephan Beyer
2016-10-14 14:14 ` [PATCH v15 24/27] bisect--helper: retire `--bisect-write` subcommand Pranit Bauva
` (4 subsequent siblings)
27 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
Reimplement the `get_terms` and `bisect_terms` shell function in C and
add `bisect-terms` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Using `--bisect-terms` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by some other methods.
Also use error() to report "no terms defined" and accordingly change the
test in t6030.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 72 +++++++++++++++++++++++++++++++++++++++++++--
git-bisect.sh | 35 ++--------------------
t/t6030-bisect-porcelain.sh | 2 +-
3 files changed, 73 insertions(+), 36 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 317d671..6a5878c 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -23,6 +23,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
+ N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
NULL
};
@@ -343,6 +344,65 @@ static int bisect_next_check(const struct bisect_terms *terms,
return retval;
}
+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;
+ }
+ strbuf_getline_lf(&str, fp);
+ terms->term_bad = strbuf_detach(&str, NULL);
+ strbuf_getline_lf(&str, fp);
+ terms->term_good = strbuf_detach(&str, NULL);
+ goto finish;
+finish:
+ if (fp)
+ fclose(fp);
+ strbuf_release(&str);
+ return res;
+}
+
+static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
+{
+ int i;
+ const char bisect_term_usage[] =
+"git bisect--helper --bisect-terms [--term-good | --term-bad | ]"
+"--term-old | --term-new";
+
+ if (get_terms(terms))
+ return error(_("no terms defined"));
+
+ if (argc > 1) {
+ usage(bisect_term_usage);
+ return -1;
+ }
+
+ if (argc == 0) {
+ printf(_("Your current terms are %s for the old state\nand "
+ "%s for the new state.\n"), terms->term_good,
+ terms->term_bad);
+ return 0;
+ }
+
+ for (i = 0; i < argc; i++) {
+ if (!strcmp(argv[i], "--term-good"))
+ printf("%s\n", terms->term_good);
+ else if (!strcmp(argv[i], "--term-bad"))
+ printf("%s\n", terms->term_bad);
+ else
+ die(_("invalid argument %s for 'git bisect "
+ "terms'.\nSupported options are: "
+ "--term-good|--term-old and "
+ "--term-bad|--term-new."), argv[i]);
+ }
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -353,7 +413,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
CHECK_EXPECTED_REVS,
BISECT_WRITE,
CHECK_AND_SET_TERMS,
- BISECT_NEXT_CHECK
+ BISECT_NEXT_CHECK,
+ BISECT_TERMS
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -373,6 +434,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
+ OPT_CMDMODE(0, "bisect-terms", &cmdmode,
+ N_("print out the bisect terms"), BISECT_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -380,7 +443,7 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
struct bisect_terms terms;
argc = parse_options(argc, argv, prefix, options,
- git_bisect_helper_usage, 0);
+ git_bisect_helper_usage, PARSE_OPT_KEEP_UNKNOWN);
if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
@@ -429,6 +492,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
terms.term_bad = xstrdup(argv[1]);
res = bisect_next_check(&terms, argc == 3 ? argv[2] : NULL);
break;
+ case BISECT_TERMS:
+ if (argc > 1)
+ die(_("--bisect-terms requires 0 or 1 argument"));
+ res = bisect_terms(&terms, argv, argc);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index fe6c9d0..d6c8b5a 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -355,7 +355,7 @@ bisect_replay () {
"$TERM_GOOD"|"$TERM_BAD"|skip)
git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
terms)
- bisect_terms $rev ;;
+ git bisect--helper --bisect-terms $rev || exit;;
*)
die "$(gettext "?? what are you talking about?")" ;;
esac
@@ -437,37 +437,6 @@ get_terms () {
fi
}
-bisect_terms () {
- get_terms
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- die "$(gettext "no terms defined")"
- fi
- case "$#" in
- 0)
- gettextln "Your current terms are $TERM_GOOD for the old state
-and $TERM_BAD for the new state."
- ;;
- 1)
- arg=$1
- case "$arg" in
- --term-good|--term-old)
- printf '%s\n' "$TERM_GOOD"
- ;;
- --term-bad|--term-new)
- printf '%s\n' "$TERM_BAD"
- ;;
- *)
- die "$(eval_gettext "invalid argument \$arg for 'git bisect terms'.
-Supported options are: --term-good|--term-old and --term-bad|--term-new.")"
- ;;
- esac
- ;;
- *)
- usage ;;
- esac
-}
-
case "$#" in
0)
usage ;;
@@ -498,7 +467,7 @@ case "$#" in
run)
bisect_run "$@" ;;
terms)
- bisect_terms "$@" ;;
+ git bisect--helper --bisect-terms "$@" || exit;;
*)
usage ;;
esac
diff --git a/t/t6030-bisect-porcelain.sh b/t/t6030-bisect-porcelain.sh
index 18e7998..e62e2a8 100755
--- a/t/t6030-bisect-porcelain.sh
+++ b/t/t6030-bisect-porcelain.sh
@@ -802,7 +802,7 @@ test_expect_success 'bisect terms needs 0 or 1 argument' '
test_must_fail git bisect terms only-one &&
test_must_fail git bisect terms 1 2 &&
test_must_fail git bisect terms 2>actual &&
- echo "no terms defined" >expected &&
+ echo "error: no terms defined" >expected &&
test_i18ncmp expected actual
'
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 13/27] bisect--helper: `bisect_start` shell function partially in C
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (8 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 06/27] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-11-15 23:19 ` Stephan Beyer
2016-11-20 20:01 ` Stephan Beyer
2016-10-14 14:14 ` [PATCH v15 15/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function " Pranit Bauva
` (17 subsequent siblings)
27 siblings, 2 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
Reimplement the `bisect_start` shell function partially in C and add
`bisect-start` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
The last part is not converted because it calls another shell function
`bisect_start` shell function will be completed after the `bisect_next`
shell function is ported in C.
Using `--bisect-start` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other methods.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 217 ++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 133 +----------------------------
2 files changed, 217 insertions(+), 133 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 6a5878c..1d3e17f 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -7,6 +7,7 @@
#include "argv-array.h"
#include "run-command.h"
#include "prompt.h"
+#include "quote.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
@@ -14,6 +15,8 @@ static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
static GIT_PATH_FUNC(git_path_bisect_head, "BISECT_HEAD")
+static GIT_PATH_FUNC(git_path_head_name, "head-name")
+static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
@@ -24,6 +27,8 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
+ N_("git bisect--helper --bisect start [--term-{old,good}=<term> --term-{new,bad}=<term>]"
+ "[--no-checkout] [<bad> [<good>...]] [--] [<paths>...]"),
NULL
};
@@ -403,6 +408,205 @@ static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
return 0;
}
+static int bisect_start(struct bisect_terms *terms, int no_checkout,
+ const char **argv, int argc)
+{
+ int i, has_double_dash = 0, must_write_terms = 0, bad_seen = 0;
+ int flags, pathspec_pos, retval = 0;
+ 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 strbuf orig_args = STRBUF_INIT;
+ const char *head;
+ unsigned char sha1[20];
+ FILE *fp = NULL;
+ struct object_id oid;
+
+ if (is_bare_repository())
+ no_checkout = 1;
+
+ for (i = 0; i < argc; i++) {
+ if (!strcmp(argv[i], "--")) {
+ has_double_dash = 1;
+ break;
+ }
+ }
+
+ for (i = 0; i < argc; i++) {
+ const char *commit_id = xstrfmt("%s^{commit}", argv[i]);
+ const char *arg = argv[i];
+ if (!strcmp(argv[i], "--")) {
+ has_double_dash = 1;
+ break;
+ } else if (!strcmp(arg, "--no-checkout")) {
+ no_checkout = 1;
+ } else if (!strcmp(arg, "--term-good") ||
+ !strcmp(arg, "--term-old")) {
+ must_write_terms = 1;
+ terms->term_good = xstrdup(argv[++i]);
+ } else if (skip_prefix(arg, "--term-good=", &arg)) {
+ must_write_terms = 1;
+ terms->term_good = xstrdup(arg);
+ } else if (skip_prefix(arg, "--term-old=", &arg)) {
+ must_write_terms = 1;
+ terms->term_good = xstrdup(arg);
+ } else if (!strcmp(arg, "--term-bad") ||
+ !strcmp(arg, "--term-new")) {
+ must_write_terms = 1;
+ terms->term_bad = xstrdup(argv[++i]);
+ } else if (skip_prefix(arg, "--term-bad=", &arg)) {
+ must_write_terms = 1;
+ terms->term_bad = xstrdup(arg);
+ } else if (skip_prefix(arg, "--term-new=", &arg)) {
+ must_write_terms = 1;
+ terms->term_good = xstrdup(arg);
+ } else if (starts_with(arg, "--") &&
+ !one_of(arg, "--term-good", "--term-bad", NULL)) {
+ die(_("unrecognised option: '%s'"), arg);
+ } else if (get_oid(commit_id, &oid) && has_double_dash) {
+ die(_("'%s' does not appear to be a valid revision"), argv[i]);
+ } else {
+ string_list_append(&revs, oid_to_hex(&oid));
+ }
+ }
+ 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.
+ */
+ must_write_terms |= !!revs.nr;
+ 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, sha1, &flags);
+ if (!head)
+ if (get_sha1("HEAD", sha1))
+ die(_("Bad HEAD - I need a HEAD"));
+
+ 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) {
+ struct argv_array argv = ARGV_ARRAY_INIT;
+ argv_array_pushl(&argv, "checkout", start_head.buf,
+ "--", NULL);
+ if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
+ error(_("checking out '%s' failed. Try 'git "
+ "bisect start <valid-branch>'."),
+ start_head.buf);
+ retval = -1;
+ goto finish;
+ }
+ }
+ } else {
+ if (!get_sha1(head, sha1) &&
+ !starts_with(head, "refs/heads/")) {
+ strbuf_reset(&start_head);
+ strbuf_addstr(&start_head, sha1_to_hex(sha1));
+ } else if (!get_sha1(head, sha1) &&
+ 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()))
+ die(_("won't bisect on cg-seek'ed tree"));
+ strbuf_addstr(&start_head, head);
+ } else {
+ die(_("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);
+
+ if (no_checkout) {
+ get_oid(start_head.buf, &oid);
+ if (update_ref(NULL, "BISECT_HEAD", oid.hash, NULL, 0,
+ UPDATE_REFS_MSG_ON_ERR)) {
+ retval = -1;
+ goto finish;
+ }
+ }
+
+ if (pathspec_pos < argc - 1)
+ sq_quote_argv(&bisect_names, argv + pathspec_pos, 0);
+ 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)) {
+ retval = -1;
+ goto finish;
+ }
+ }
+
+ if (must_write_terms)
+ if (write_terms(terms->term_bad, terms->term_good)) {
+ retval = -1;
+ goto finish;
+ }
+
+ fp = fopen(git_path_bisect_log(), "a");
+ if (!fp)
+ return -1;
+
+ if (fprintf(fp, "git bisect start") < 1) {
+ retval = -1;
+ goto finish;
+ }
+
+ sq_quote_argv(&orig_args, argv, 0);
+ if (fprintf(fp, "%s", orig_args.buf) < 0) {
+ retval = -1;
+ goto finish;
+ }
+ if (fprintf(fp, "\n") < 1) {
+ retval = -1;
+ goto finish;
+ }
+ goto finish;
+finish:
+ if (fp)
+ fclose(fp);
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ strbuf_release(&start_head);
+ strbuf_release(&bisect_names);
+ strbuf_release(&orig_args);
+ return retval;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -414,7 +618,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_WRITE,
CHECK_AND_SET_TERMS,
BISECT_NEXT_CHECK,
- BISECT_TERMS
+ BISECT_TERMS,
+ BISECT_START
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -436,6 +641,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
OPT_CMDMODE(0, "bisect-terms", &cmdmode,
N_("print out the bisect terms"), BISECT_TERMS),
+ OPT_CMDMODE(0, "bisect-start", &cmdmode,
+ N_("start the bisect session"), BISECT_START),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -443,7 +650,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
struct bisect_terms terms;
argc = parse_options(argc, argv, prefix, options,
- git_bisect_helper_usage, PARSE_OPT_KEEP_UNKNOWN);
+ git_bisect_helper_usage,
+ PARSE_OPT_KEEP_DASHDASH | PARSE_OPT_KEEP_UNKNOWN);
if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
@@ -497,6 +705,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
die(_("--bisect-terms requires 0 or 1 argument"));
res = bisect_terms(&terms, argv, argc);
break;
+ case BISECT_START:
+ terms.term_good = "good";
+ terms.term_bad = "bad";
+ res = bisect_start(&terms, no_checkout, argv, argc);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index d6c8b5a..f0896b3 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -71,122 +71,7 @@ bisect_autostart() {
}
bisect_start() {
- #
- # Check for one bad and then some good revisions.
- #
- has_double_dash=0
- for arg; do
- case "$arg" in --) has_double_dash=1; break ;; esac
- done
- orig_args=$(git rev-parse --sq-quote "$@")
- bad_seen=0
- eval=''
- must_write_terms=0
- revs=''
- if test "z$(git rev-parse --is-bare-repository)" != zfalse
- then
- mode=--no-checkout
- else
- mode=''
- fi
- while [ $# -gt 0 ]; do
- arg="$1"
- case "$arg" in
- --)
- shift
- break
- ;;
- --no-checkout)
- mode=--no-checkout
- shift ;;
- --term-good|--term-old)
- shift
- must_write_terms=1
- TERM_GOOD=$1
- shift ;;
- --term-good=*|--term-old=*)
- must_write_terms=1
- TERM_GOOD=${1#*=}
- shift ;;
- --term-bad|--term-new)
- shift
- must_write_terms=1
- TERM_BAD=$1
- shift ;;
- --term-bad=*|--term-new=*)
- must_write_terms=1
- TERM_BAD=${1#*=}
- shift ;;
- --*)
- die "$(eval_gettext "unrecognised option: '\$arg'")" ;;
- *)
- rev=$(git rev-parse -q --verify "$arg^{commit}") || {
- test $has_double_dash -eq 1 &&
- die "$(eval_gettext "'\$arg' does not appear to be a valid revision")"
- break
- }
- revs="$revs $rev"
- shift
- ;;
- esac
- done
-
- for rev in $revs
- do
- # 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.
- must_write_terms=1
-
- case $bad_seen in
- 0) state=$TERM_BAD ; bad_seen=1 ;;
- *) state=$TERM_GOOD ;;
- esac
- eval="$eval git bisect--helper --bisect-write '$state' '$rev' '$TERM_GOOD' '$TERM_BAD' 'nolog' &&"
- done
- #
- # Verify HEAD.
- #
- head=$(GIT_DIR="$GIT_DIR" git symbolic-ref -q HEAD) ||
- head=$(GIT_DIR="$GIT_DIR" git rev-parse --verify HEAD) ||
- die "$(gettext "Bad HEAD - I need a HEAD")"
-
- #
- # Check if we are bisecting.
- #
- start_head=''
- if test -s "$GIT_DIR/BISECT_START"
- then
- # Reset to the rev from where we started.
- start_head=$(cat "$GIT_DIR/BISECT_START")
- if test "z$mode" != "z--no-checkout"
- then
- git checkout "$start_head" -- ||
- die "$(eval_gettext "Checking out '\$start_head' failed. Try 'git bisect reset <valid-branch>'.")"
- fi
- else
- # Get rev from where we start.
- case "$head" in
- refs/heads/*|$_x40)
- # This error message should only be triggered by
- # cogito usage, and cogito users should understand
- # it relates to cg-seek.
- [ -s "$GIT_DIR/head-name" ] &&
- die "$(gettext "won't bisect on cg-seek'ed tree")"
- start_head="${head#refs/heads/}"
- ;;
- *)
- die "$(gettext "Bad HEAD - strange symbolic ref")"
- ;;
- esac
- fi
-
- #
- # Get rid of any old bisect state.
- #
- git bisect--helper --bisect-clean-state || exit
+ git bisect--helper --bisect-start $@ || exit
#
# Change state.
@@ -197,24 +82,10 @@ bisect_start() {
#
trap 'git bisect--helper --bisect-clean-state' 0
trap 'exit 255' 1 2 3 15
-
- #
- # Write new start state.
- #
- echo "$start_head" >"$GIT_DIR/BISECT_START" && {
- test "z$mode" != "z--no-checkout" ||
- git update-ref --no-deref BISECT_HEAD "$start_head"
- } &&
- git rev-parse --sq-quote "$@" >"$GIT_DIR/BISECT_NAMES" &&
- eval "$eval true" &&
- if test $must_write_terms -eq 1
- then
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD"
- fi &&
- echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
#
# Check if we can proceed to the next bisect state.
#
+ get_terms
bisect_auto_next
trap '-' 0
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 18/27] bisect--helper: `bisect_autostart` shell function in C
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (5 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 17/27] bisect--helper: retire `--next-all` subcommand Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-11-20 20:15 ` Stephan Beyer
2016-10-14 14:14 ` [PATCH v15 10/27] bisect--helper: `check_and_set_terms` " Pranit Bauva
` (20 subsequent siblings)
27 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
Reimplement the `bisect_autostart` shell function in C and add the
C implementation from `bisect_next()` which was previously left
uncovered. Also add a subcommand `--bisect-autostart` to
`git bisect--helper` be called from `bisect_state()` from
git-bisect.sh .
Using `--bisect-autostart` subcommand is a temporary measure to port
shell function to C so as to use the existing test suite. As more
functions are ported, this subcommand will be retired and will be called
by `bisect_state()`.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 40 ++++++++++++++++++++++++++++++++++++++++
git-bisect.sh | 23 +----------------------
2 files changed, 41 insertions(+), 22 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 502bf18..1767916 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -30,6 +30,7 @@ static const char * const git_bisect_helper_usage[] = {
"[--no-checkout] [<bad> [<good>...]] [--] [<paths>...]"),
N_("git bisect--helper --bisect-next"),
N_("git bisect--helper --bisect-auto-next"),
+ N_("git bisect--helper --bisect-autostart"),
NULL
};
@@ -38,6 +39,8 @@ struct bisect_terms {
const char *term_bad;
};
+static int bisect_autostart(struct bisect_terms *terms);
+
/*
* Check whether the string `term` belongs to the set of strings
* included in the variable arguments.
@@ -422,6 +425,7 @@ static int bisect_next(struct bisect_terms *terms, const char *prefix)
{
int res, no_checkout;
+ bisect_autostart(terms);
/*
* In case of mistaken revs or checkout error, or signals received,
* "bisect_auto_next" below may exit or misbehave.
@@ -754,6 +758,32 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
return retval || bisect_auto_next(terms, NULL);
}
+static int bisect_autostart(struct bisect_terms *terms)
+{
+ if (is_empty_or_missing_file(git_path_bisect_start())) {
+ const char *yesno;
+ const char *argv[] = {NULL};
+ fprintf(stderr, _("You need to start by \"git bisect "
+ "start\"\n"));
+
+ if (!isatty(0))
+ return 1;
+
+ /*
+ * TRANSLATORS: Make sure to include [Y] and [n] in your
+ * translation. THe program will only accept English input
+ * at this point.
+ */
+ yesno = git_prompt(_("Do you want me to do it for you "
+ "[Y/n]? "), PROMPT_ECHO);
+ if (starts_with(yesno, "n") || starts_with(yesno, "N"))
+ exit(0);
+
+ return bisect_start(terms, 0, argv, 0);
+ }
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -767,6 +797,7 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_START,
BISECT_NEXT,
BISECT_AUTO_NEXT,
+ BISECT_AUTOSTART,
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -790,6 +821,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("find the next bisection commit"), BISECT_NEXT),
OPT_CMDMODE(0, "bisect-auto-next", &cmdmode,
N_("verify the next bisection state then find the next bisection state"), BISECT_AUTO_NEXT),
+ OPT_CMDMODE(0, "bisect-autostart", &cmdmode,
+ N_("start the bisection if BISECT_START empty or missing"), BISECT_AUTOSTART),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -862,6 +895,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
get_terms(&terms);
res = bisect_auto_next(&terms, prefix);
break;
+ case BISECT_AUTOSTART:
+ if (argc)
+ die(_("--bisect-autostart requires 0 arguments"));
+ terms.term_good = "good";
+ terms.term_bad = "bad";
+ res = bisect_autostart(&terms);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index d574c44..cd56551 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -49,27 +49,6 @@ bisect_head()
fi
}
-bisect_autostart() {
- test -s "$GIT_DIR/BISECT_START" || {
- gettextln "You need to start by \"git bisect start\"" >&2
- if test -t 0
- then
- # TRANSLATORS: Make sure to include [Y] and [n] in your
- # translation. The program will only accept English input
- # at this point.
- gettext "Do you want me to do it for you [Y/n]? " >&2
- read yesno
- case "$yesno" in
- [Nn]*)
- exit ;;
- esac
- git bisect--helper --bisect-start
- else
- exit 1
- fi
- }
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -86,7 +65,7 @@ bisect_skip() {
}
bisect_state() {
- bisect_autostart
+ git bisect--helper --bisect-autostart
state=$1
get_terms
git bisect--helper --check-and-set-terms $state $TERM_GOOD $TERM_BAD || exit
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 21/27] bisect--helper: retire `--write-terms` subcommand
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (13 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 14/27] t6030: no cleanup with bad merge base Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 08/27] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C Pranit Bauva
` (12 subsequent siblings)
27 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
The `--write-terms` subcommand is no longer used in the shell script and
the function `write_terms()` is called from the C implementation of
`set_terms()` and `bisect_start()`.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 11 +----------
1 file changed, 1 insertion(+), 10 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index d5fe35b..493034c 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -20,7 +20,6 @@ static GIT_PATH_FUNC(git_path_head_name, "head-name")
static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static const char * const git_bisect_helper_usage[] = {
- N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
@@ -862,8 +861,7 @@ static int bisect_state(struct bisect_terms *terms, const char **argv,
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
- WRITE_TERMS = 1,
- BISECT_RESET,
+ BISECT_RESET = 1,
BISECT_WRITE,
CHECK_AND_SET_TERMS,
BISECT_NEXT_CHECK,
@@ -876,8 +874,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
- OPT_CMDMODE(0, "write-terms", &cmdmode,
- N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
N_("reset the bisection state"), BISECT_RESET),
OPT_CMDMODE(0, "bisect-write", &cmdmode,
@@ -913,11 +909,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
switch (cmdmode) {
int nolog;
- case WRITE_TERMS:
- if (argc != 2)
- die(_("--write-terms requires two arguments"));
- res = write_terms(argv[0], argv[1]);
- break;
case BISECT_RESET:
if (argc > 1)
die(_("--bisect-reset requires either zero or one arguments"));
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 19/27] bisect--helper: `bisect_state` & `bisect_head` shell function in C
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (16 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 11/27] bisect--helper: `bisect_next_check` & bisect_voc " Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-11-22 0:12 ` Stephan Beyer
2016-10-14 14:14 ` [PATCH v15 25/27] bisect--helper: retire `--bisect-autostart` subcommand Pranit Bauva
` (9 subsequent siblings)
27 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
Reimplement the `bisect_state` shell function in C and also add a
subcommand `--bisect-state` to `git-bisect--helper` to call it from
git-bisect.sh .
Using `--bisect-state` subcommand is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other methods.
`bisect_head` is called from `bisect_state` thus its not required to
introduce another subcommand.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 86 ++++++++++++++++++++++++++++++++++++++++++++++++
git-bisect.sh | 57 +++-----------------------------
2 files changed, 91 insertions(+), 52 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 1767916..1481c6d 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -31,6 +31,8 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-next"),
N_("git bisect--helper --bisect-auto-next"),
N_("git bisect--helper --bisect-autostart"),
+ N_("git bisect--helper --bisect-state (bad|new) [<rev>]"),
+ N_("git bisect--helper --bisect-state (good|old) [<rev>...]"),
NULL
};
@@ -784,6 +786,79 @@ static int bisect_autostart(struct bisect_terms *terms)
return 0;
}
+static char *bisect_head(void)
+{
+ if (is_empty_or_missing_file(git_path_bisect_head()))
+ return "HEAD";
+ else
+ return "BISECT_HEAD";
+}
+
+static int bisect_state(struct bisect_terms *terms, const char **argv,
+ int argc)
+{
+ const char *state = argv[0];
+
+ get_terms(terms);
+ if (check_and_set_terms(terms, state))
+ return -1;
+
+ if (!argc)
+ die(_("Please call `--bisect-state` with at least one argument"));
+
+ if (argc == 1 && one_of(state, terms->term_good,
+ terms->term_bad, "skip", NULL)) {
+ const char *bisected_head = xstrdup(bisect_head());
+ const char *hex[1];
+ unsigned char sha1[20];
+
+ if (get_sha1(bisected_head, sha1))
+ die(_("Bad rev input: %s"), bisected_head);
+ if (bisect_write(state, sha1_to_hex(sha1), terms, 0))
+ return -1;
+
+ *hex = xstrdup(sha1_to_hex(sha1));
+ if (check_expected_revs(hex, 1))
+ return -1;
+ return bisect_auto_next(terms, NULL);
+ }
+
+ if ((argc == 2 && !strcmp(state, terms->term_bad)) ||
+ one_of(state, terms->term_good, "skip", NULL)) {
+ int i;
+ struct string_list hex = STRING_LIST_INIT_DUP;
+
+ for (i = 1; i < argc; i++) {
+ unsigned char sha1[20];
+
+ if (get_sha1(argv[i], sha1)) {
+ string_list_clear(&hex, 0);
+ die(_("Bad rev input: %s"), argv[i]);
+ }
+ string_list_append(&hex, sha1_to_hex(sha1));
+ }
+ for (i = 0; i < hex.nr; i++) {
+ const char **hex_string = (const char **) &hex.items[i].string;
+ if(bisect_write(state, *hex_string, terms, 0)) {
+ string_list_clear(&hex, 0);
+ return -1;
+ }
+ if (check_expected_revs(hex_string, 1)) {
+ string_list_clear(&hex, 0);
+ return -1;
+ }
+ }
+ string_list_clear(&hex, 0);
+ return bisect_auto_next(terms, NULL);
+ }
+
+ if (!strcmp(state, terms->term_bad))
+ die(_("'git bisect %s' can take only one argument."),
+ terms->term_bad);
+
+ return -1;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -798,6 +873,7 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_NEXT,
BISECT_AUTO_NEXT,
BISECT_AUTOSTART,
+ BISECT_STATE
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -823,6 +899,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("verify the next bisection state then find the next bisection state"), BISECT_AUTO_NEXT),
OPT_CMDMODE(0, "bisect-autostart", &cmdmode,
N_("start the bisection if BISECT_START empty or missing"), BISECT_AUTOSTART),
+ OPT_CMDMODE(0, "bisect-state", &cmdmode,
+ N_("mark the state of ref (or refs)"), BISECT_STATE),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -902,6 +980,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
terms.term_bad = "bad";
res = bisect_autostart(&terms);
break;
+ case BISECT_STATE:
+ if (argc == 0)
+ die(_("--bisect-state requires at least 1 argument"));
+ terms.term_good = "good";
+ terms.term_bad = "bad";
+ get_terms(&terms);
+ res = bisect_state(&terms, argv, argc);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index cd56551..a9eebbb 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -39,16 +39,6 @@ _x40="$_x40$_x40$_x40$_x40$_x40$_x40$_x40$_x40"
TERM_BAD=bad
TERM_GOOD=good
-bisect_head()
-{
- if test -f "$GIT_DIR/BISECT_HEAD"
- then
- echo BISECT_HEAD
- else
- echo HEAD
- fi
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -61,44 +51,7 @@ bisect_skip() {
esac
all="$all $revs"
done
- eval bisect_state 'skip' $all
-}
-
-bisect_state() {
- git bisect--helper --bisect-autostart
- state=$1
- get_terms
- git bisect--helper --check-and-set-terms $state $TERM_GOOD $TERM_BAD || exit
- get_terms
- case "$#,$state" in
- 0,*)
- die "Please call 'bisect_state' with at least one argument." ;;
- 1,"$TERM_BAD"|1,"$TERM_GOOD"|1,skip)
- bisected_head=$(bisect_head)
- rev=$(git rev-parse --verify "$bisected_head") ||
- die "$(eval_gettext "Bad rev input: \$bisected_head")"
- git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
- git bisect--helper --check-expected-revs "$rev" ;;
- 2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
- shift
- hash_list=''
- for rev in "$@"
- do
- sha=$(git rev-parse --verify "$rev^{commit}") ||
- die "$(eval_gettext "Bad rev input: \$rev")"
- hash_list="$hash_list $sha"
- done
- for rev in $hash_list
- do
- git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
- done
- git bisect--helper --check-expected-revs $hash_list ;;
- *,"$TERM_BAD")
- die "$(eval_gettext "'git bisect \$TERM_BAD' can take only one argument.")" ;;
- *)
- usage ;;
- esac
- git bisect--helper --bisect-auto-next || exit
+ eval git bisect--helper --bisect-state 'skip' $all
}
bisect_visualize() {
@@ -184,8 +137,8 @@ exit code \$res from '\$command' is < 0 or >= 128" >&2
state="$TERM_GOOD"
fi
- # We have to use a subshell because "bisect_state" can exit.
- ( bisect_state $state >"$GIT_DIR/BISECT_RUN" )
+ # We have to use a subshell because "--bisect-state" can exit.
+ ( git bisect--helper --bisect-state $state >"$GIT_DIR/BISECT_RUN" )
res=$?
cat "$GIT_DIR/BISECT_RUN"
@@ -200,7 +153,7 @@ exit code \$res from '\$command' is < 0 or >= 128" >&2
if [ $res -ne 0 ]
then
eval_gettextln "bisect run failed:
-'bisect_state \$state' exited with error code \$res" >&2
+'git bisect--helper --bisect-state \$state' exited with error code \$res" >&2
exit $res
fi
@@ -241,7 +194,7 @@ case "$#" in
start)
git bisect--helper --bisect-start "$@" ;;
bad|good|new|old|"$TERM_BAD"|"$TERM_GOOD")
- bisect_state "$cmd" "$@" ;;
+ git bisect--helper --bisect-state "$cmd" "$@" ;;
skip)
bisect_skip "$@" ;;
next)
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 14/27] t6030: no cleanup with bad merge base
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (12 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 22/27] bisect--helper: `bisect_log` " Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-10-14 21:43 ` Junio C Hamano
2016-10-14 14:14 ` [PATCH v15 21/27] bisect--helper: retire `--write-terms` subcommand Pranit Bauva
` (13 subsequent siblings)
27 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
The bisection cleanup should be performed with bad merge base so that
the user can return to its original position with `git bisect reset`.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
t/t6030-bisect-porcelain.sh | 7 +++++++
1 file changed, 7 insertions(+)
diff --git a/t/t6030-bisect-porcelain.sh b/t/t6030-bisect-porcelain.sh
index e62e2a8..8ac77ee 100755
--- a/t/t6030-bisect-porcelain.sh
+++ b/t/t6030-bisect-porcelain.sh
@@ -911,4 +911,11 @@ test_expect_success 'git bisect reset cleans bisection state properly' '
test_path_is_missing "$GIT_DIR/BISECT_START"
'
+test_expect_success 'check whether bisection cleanup is not done with bad merges' '
+ git bisect start $HASH7 $SIDE_HASH7 &&
+ test_expect_failure git bisect bad >out 2>out &&
+ test_i18ngrep "The merge base" out &&
+ test -e .git/BISECT_START
+'
+
test_done
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 15/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function in C
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (9 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 13/27] bisect--helper: `bisect_start` shell function partially in C Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-11-20 20:01 ` Stephan Beyer
2016-11-21 21:35 ` Stephan Beyer
2016-10-14 14:14 ` [PATCH v15 07/27] bisect--helper: `bisect_reset` " Pranit Bauva
` (16 subsequent siblings)
27 siblings, 2 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
Reimplement the `bisect_next` and the `bisect_auto_next` shell function
in C and add the subcommands to `git bisect--helper` to call it from
git-bisect.sh .
Along with this conversion of `bisect_start` has also finished and thus
it has been fully ported to C.
A lot of parts of bisect.c uses exit() and these signals are then
trapped in the `bisect_start` function. Since the shell script ceases
its existence it would be necessary to convert those exit() calls to
return statements so that errors can be reported.
As more and more calls are happening to the subcommands in `git
bisect--helper`, more specifically when `bisect_start $rev` is converted to
`git bisect--helper --bisect-start $rev` it is necessary to dequote the
arguments because of shell to C conversion.
Using `--bisect-next` and `--bisect-auto-start` subcommands is a
temporary measure to port shell function to C so as to use the existing
test suite. As more functions are ported, this subcommand will be
retired and will be called by some other methods.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
bisect.c | 128 ++++++++++++++++++++++++--------
builtin/bisect--helper.c | 189 ++++++++++++++++++++++++++++++++++++++++++++---
git-bisect.sh | 74 ++-----------------
3 files changed, 285 insertions(+), 106 deletions(-)
diff --git a/bisect.c b/bisect.c
index 45d598d..7c97e85 100644
--- a/bisect.c
+++ b/bisect.c
@@ -618,6 +618,12 @@ static void bisect_rev_setup(struct rev_info *revs, const char *prefix,
struct argv_array rev_argv = ARGV_ARRAY_INIT;
int i;
+ /*
+ * Since the code is slowly being converted to C, there might be
+ * instances where the revisions were initialized before. Thus
+ * we first need to reset it.
+ */
+ reset_revision_walk();
init_revisions(revs, prefix);
revs->abbrev = 0;
revs->commit_format = CMIT_FMT_UNSPECIFIED;
@@ -638,17 +644,22 @@ static void bisect_rev_setup(struct rev_info *revs, const char *prefix,
static void bisect_common(struct rev_info *revs)
{
+ /*
+ * We don't want to clean the bisection state
+ * as we need to get back to where we started
+ * by using `git bisect reset`.
+ */
if (prepare_revision_walk(revs))
die("revision walk setup failed");
if (revs->tree_objects)
mark_edges_uninteresting(revs, NULL);
}
-static void exit_if_skipped_commits(struct commit_list *tried,
+static int exit_if_skipped_commits(struct commit_list *tried,
const struct object_id *bad)
{
if (!tried)
- return;
+ return 0;
printf("There are only 'skip'ped commits left to test.\n"
"The first %s commit could be any of:\n", term_bad);
@@ -659,7 +670,13 @@ static void exit_if_skipped_commits(struct commit_list *tried,
if (bad)
printf("%s\n", oid_to_hex(bad));
printf(_("We cannot bisect more!\n"));
- exit(2);
+
+ /*
+ * We don't want to clean the bisection state
+ * as we need to get back to where we started
+ * by using `git bisect reset`.
+ */
+ return 2;
}
static int is_expected_rev(const struct object_id *oid)
@@ -700,7 +717,7 @@ static int bisect_checkout(const unsigned char *bisect_rev, int no_checkout)
int res;
res = run_command_v_opt(argv_checkout, RUN_GIT_CMD);
if (res)
- exit(res);
+ return res;
}
argv_show_branch[1] = bisect_rev_hex;
@@ -729,7 +746,7 @@ static struct commit **get_bad_and_good_commits(int *rev_nr)
return rev;
}
-static void handle_bad_merge_base(void)
+static int handle_bad_merge_base(void)
{
if (is_expected_rev(current_bad_oid)) {
char *bad_hex = oid_to_hex(current_bad_oid);
@@ -750,17 +767,23 @@ static void handle_bad_merge_base(void)
"between %s and [%s].\n"),
bad_hex, term_bad, term_good, bad_hex, good_hex);
}
- exit(3);
+ /*
+ * We don't want to clean the bisection state
+ * as we need to get back to where we started
+ * by using `git bisect reset`.
+ */
+ return 3;
}
fprintf(stderr, _("Some %s revs are not ancestor of the %s rev.\n"
"git bisect cannot work properly in this case.\n"
"Maybe you mistook %s and %s revs?\n"),
term_good, term_bad, term_good, term_bad);
- exit(1);
+ bisect_clean_state();
+ return 1;
}
-static void handle_skipped_merge_base(const unsigned char *mb)
+static int handle_skipped_merge_base(const unsigned char *mb)
{
char *mb_hex = sha1_to_hex(mb);
char *bad_hex = oid_to_hex(current_bad_oid);
@@ -773,21 +796,22 @@ static void handle_skipped_merge_base(const unsigned char *mb)
"We continue anyway."),
bad_hex, good_hex, term_bad, mb_hex, bad_hex);
free(good_hex);
+ return 0;
}
/*
* "check_merge_bases" checks that merge bases are not "bad" (or "new").
*
* - If one is "bad" (or "new"), it means the user assumed something wrong
- * and we must exit with a non 0 error code.
+ * and we must return error with a non 0 error code.
* - If one is "good" (or "old"), that's good, we have nothing to do.
* - If one is "skipped", we can't know but we should warn.
* - If we don't know, we should check it out and ask the user to test.
*/
-static void check_merge_bases(int no_checkout)
+static int check_merge_bases(int no_checkout)
{
struct commit_list *result;
- int rev_nr;
+ int rev_nr, res = 0;
struct commit **rev = get_bad_and_good_commits(&rev_nr);
result = get_merge_bases_many(rev[0], rev_nr - 1, rev + 1);
@@ -795,19 +819,30 @@ static void check_merge_bases(int no_checkout)
for (; result; result = result->next) {
const unsigned char *mb = result->item->object.oid.hash;
if (!hashcmp(mb, current_bad_oid->hash)) {
- handle_bad_merge_base();
+ res = handle_bad_merge_base();
+ break;
} else if (0 <= sha1_array_lookup(&good_revs, mb)) {
continue;
} else if (0 <= sha1_array_lookup(&skipped_revs, mb)) {
- handle_skipped_merge_base(mb);
+ res = handle_skipped_merge_base(mb);
+ break;
} else {
printf(_("Bisecting: a merge base must be tested\n"));
- exit(bisect_checkout(mb, no_checkout));
+ res = bisect_checkout(mb, no_checkout);
+ /*
+ * We don't want to clean the bisection state
+ * as we need to get back to where we started
+ * by using `git bisect reset`.
+ */
+ if (!res)
+ exit(0);
+ break;
}
}
free(rev);
free_commit_list(result);
+ return res;
}
static int check_ancestors(const char *prefix)
@@ -843,16 +878,21 @@ static int check_ancestors(const char *prefix)
*
* If that's not the case, we need to check the merge bases.
* If a merge base must be tested by the user, its source code will be
- * checked out to be tested by the user and we will exit.
+ * checked out to be tested by the user and we will return.
*/
-static void check_good_are_ancestors_of_bad(const char *prefix, int no_checkout)
+static int check_good_are_ancestors_of_bad(const char *prefix, int no_checkout)
{
char *filename = git_pathdup("BISECT_ANCESTORS_OK");
struct stat st;
- int fd;
+ int fd, res = 0;
+ /*
+ * We don't want to clean the bisection state
+ * as we need to get back to where we started
+ * by using `git bisect reset`.
+ */
if (!current_bad_oid)
- die(_("a %s revision is needed"), term_bad);
+ error(_("a %s revision is needed"), term_bad);
/* Check if file BISECT_ANCESTORS_OK exists. */
if (!stat(filename, &st) && S_ISREG(st.st_mode))
@@ -864,7 +904,10 @@ static void check_good_are_ancestors_of_bad(const char *prefix, int no_checkout)
/* Check if all good revs are ancestor of the bad rev. */
if (check_ancestors(prefix))
- check_merge_bases(no_checkout);
+ res = check_merge_bases(no_checkout);
+
+ if (res)
+ goto done;
/* Create file BISECT_ANCESTORS_OK. */
fd = open(filename, O_CREAT | O_TRUNC | O_WRONLY, 0600);
@@ -873,8 +916,11 @@ static void check_good_are_ancestors_of_bad(const char *prefix, int no_checkout)
filename);
else
close(fd);
+
+ goto done;
done:
free(filename);
+ return res;
}
/*
@@ -933,7 +979,7 @@ void read_bisect_terms(const char **read_bad, const char **read_good)
}
/*
- * We use the convention that exiting with an exit code 10 means that
+ * We use the convention to return with an return code 10 means that
* the bisection process finished successfully.
* In this case the calling shell script should exit 0.
*
@@ -944,7 +990,7 @@ int bisect_next_all(const char *prefix, int no_checkout)
{
struct rev_info revs;
struct commit_list *tried;
- int reaches = 0, all = 0, nr, steps;
+ int reaches = 0, all = 0, nr, steps, res;
const unsigned char *bisect_rev;
char steps_msg[32];
@@ -952,7 +998,9 @@ int bisect_next_all(const char *prefix, int no_checkout)
if (read_bisect_refs())
die(_("reading bisect refs failed"));
- check_good_are_ancestors_of_bad(prefix, no_checkout);
+ res = check_good_are_ancestors_of_bad(prefix, no_checkout);
+ if (res)
+ return res;
bisect_rev_setup(&revs, prefix, "%s", "^%s", 1);
revs.limited = 1;
@@ -964,34 +1012,52 @@ int bisect_next_all(const char *prefix, int no_checkout)
revs.commits = managed_skipped(revs.commits, &tried);
if (!revs.commits) {
+ int res;
/*
- * We should exit here only if the "bad"
+ * We should return error here only if the "bad"
* commit is also a "skip" commit.
*/
- exit_if_skipped_commits(tried, NULL);
+ res = exit_if_skipped_commits(tried, NULL);
+ if (res)
+ return res;
printf(_("%s was both %s and %s\n"),
oid_to_hex(current_bad_oid),
term_good,
term_bad);
- exit(1);
+
+ /*
+ * We don't want to clean the bisection state
+ * as we need to get back to where we started
+ * by using `git bisect reset`.
+ */
+ return 1;
}
if (!all) {
fprintf(stderr, _("No testable commit found.\n"
"Maybe you started with bad path parameters?\n"));
- exit(4);
+
+ /*
+ * We don't want to clean the bisection state
+ * as we need to get back to where we started
+ * by using `git bisect reset`.
+ */
+ return 4;
}
bisect_rev = revs.commits->item->object.oid.hash;
if (!hashcmp(bisect_rev, current_bad_oid->hash)) {
- exit_if_skipped_commits(tried, current_bad_oid);
+ res = exit_if_skipped_commits(tried, current_bad_oid);
+ if (res)
+ return res;
+
printf("%s is the first %s commit\n", sha1_to_hex(bisect_rev),
term_bad);
show_diff_tree(prefix, revs.commits->item);
/* This means the bisection process succeeded. */
- exit(10);
+ return 10;
}
nr = all - reaches - 1;
@@ -1005,7 +1071,11 @@ int bisect_next_all(const char *prefix, int no_checkout)
"Bisecting: %d revisions left to test after this %s\n",
nr), nr, steps_msg);
- return bisect_checkout(bisect_rev, no_checkout);
+ res = bisect_checkout(bisect_rev, no_checkout);
+ if (res)
+ bisect_clean_state();
+
+ return res;
}
static inline int log2i(int n)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 1d3e17f..fcd7574 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -8,6 +8,7 @@
#include "run-command.h"
#include "prompt.h"
#include "quote.h"
+#include "revision.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
@@ -29,6 +30,8 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
N_("git bisect--helper --bisect start [--term-{old,good}=<term> --term-{new,bad}=<term>]"
"[--no-checkout] [<bad> [<good>...]] [--] [<paths>...]"),
+ N_("git bisect--helper --bisect-next"),
+ N_("git bisect--helper --bisect-auto-next"),
NULL
};
@@ -408,6 +411,136 @@ static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
return 0;
}
+static int register_good_ref(const char *refname,
+ const struct object_id *oid, int flags,
+ void *cb_data)
+{
+ struct string_list *good_refs = cb_data;
+ string_list_append(good_refs, oid_to_hex(oid));
+ return 0;
+}
+
+static int bisect_next(struct bisect_terms *terms, const char *prefix)
+{
+ int res, no_checkout;
+
+ /*
+ * 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".
+ */
+ if (bisect_next_check(terms, terms->term_good))
+ return -1;
+
+ no_checkout = !is_empty_or_missing_file(git_path_bisect_head());
+
+ /* Perform all bisection computation, display and checkout */
+ res = bisect_next_all(prefix , no_checkout);
+
+ if (res == 10) {
+ FILE *fp = NULL;
+ unsigned char sha1[20];
+ struct commit *commit;
+ struct pretty_print_context pp = {0};
+ struct strbuf commit_name = STRBUF_INIT;
+ char *bad_ref = xstrfmt("refs/bisect/%s",
+ terms->term_bad);
+ int retval = 0;
+
+ read_ref(bad_ref, sha1);
+ commit = lookup_commit_reference(sha1);
+ format_commit_message(commit, "%s", &commit_name, &pp);
+ fp = fopen(git_path_bisect_log(), "a");
+ if (!fp) {
+ retval = -1;
+ goto finish_10;
+ }
+ if (fprintf(fp, "# first %s commit: [%s] %s\n",
+ terms->term_bad, sha1_to_hex(sha1),
+ commit_name.buf) < 1){
+ retval = -1;
+ goto finish_10;
+ }
+ goto finish_10;
+ finish_10:
+ if (fp)
+ fclose(fp);
+ strbuf_release(&commit_name);
+ free(bad_ref);
+ return retval;
+ }
+ else if (res == 2) {
+ FILE *fp = NULL;
+ struct rev_info revs;
+ struct argv_array rev_argv = ARGV_ARRAY_INIT;
+ struct string_list good_revs = STRING_LIST_INIT_DUP;
+ struct pretty_print_context pp = {0};
+ struct commit *commit;
+ char *term_good = xstrfmt("%s-*", terms->term_good);
+ int i, retval = 0;
+
+ fp = fopen(git_path_bisect_log(), "a");
+ if (!fp) {
+ retval = -1;
+ goto finish_2;
+ }
+ if (fprintf(fp, "# only skipped commits left to test\n") < 1) {
+ retval = -1;
+ goto finish_2;
+ }
+ for_each_glob_ref_in(register_good_ref, term_good,
+ "refs/bisect/", (void *) &good_revs);
+
+ argv_array_pushl(&rev_argv, "skipped_commits", "refs/bisect/bad", "--not", NULL);
+ for (i = 0; i < good_revs.nr; i++)
+ argv_array_push(&rev_argv, good_revs.items[i].string);
+
+ /* It is important to reset the flags used by revision walks
+ * as the previous call to bisect_next_all() in turn
+ * setups a revision walk.
+ */
+ reset_revision_walk();
+ init_revisions(&revs, NULL);
+ rev_argv.argc = setup_revisions(rev_argv.argc, rev_argv.argv, &revs, NULL);
+ argv_array_clear(&rev_argv);
+ string_list_clear(&good_revs, 0);
+ if (prepare_revision_walk(&revs))
+ die(_("revision walk setup failed\n"));
+
+ while ((commit = get_revision(&revs)) != NULL) {
+ struct strbuf commit_name = STRBUF_INIT;
+ format_commit_message(commit, "%s",
+ &commit_name, &pp);
+ fprintf(fp, "# possible first %s commit: "
+ "[%s] %s\n", terms->term_bad,
+ oid_to_hex(&commit->object.oid),
+ commit_name.buf);
+ strbuf_release(&commit_name);
+ }
+ goto finish_2;
+ finish_2:
+ if (fp)
+ fclose(fp);
+ string_list_clear(&good_revs, 0);
+ argv_array_clear(&rev_argv);
+ free(term_good);
+ if (retval)
+ return retval;
+ else
+ return res;
+ }
+ return res;
+}
+
+static int bisect_auto_next(struct bisect_terms *terms, const char *prefix)
+{
+ if (!bisect_next_check(terms, NULL))
+ return bisect_next(terms, prefix);
+
+ return 0;
+}
+
static int bisect_start(struct bisect_terms *terms, int no_checkout,
const char **argv, int argc)
{
@@ -427,15 +560,24 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
no_checkout = 1;
for (i = 0; i < argc; i++) {
- if (!strcmp(argv[i], "--")) {
+ const char *arg;
+ if (starts_with(argv[i], "'"))
+ arg = sq_dequote(xstrdup(argv[i]));
+ else
+ arg = argv[i];
+ if (!strcmp(arg, "--")) {
has_double_dash = 1;
break;
}
}
for (i = 0; i < argc; i++) {
- const char *commit_id = xstrfmt("%s^{commit}", argv[i]);
- const char *arg = argv[i];
+ const char *arg, *commit_id;
+ if (starts_with(argv[i], "'"))
+ arg = sq_dequote(xstrdup(argv[i]));
+ else
+ arg = argv[i];
+ commit_id = xstrfmt("%s^{commit}", arg);
if (!strcmp(argv[i], "--")) {
has_double_dash = 1;
break;
@@ -443,24 +585,31 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
no_checkout = 1;
} else if (!strcmp(arg, "--term-good") ||
!strcmp(arg, "--term-old")) {
+ if (starts_with(argv[++i], "'"))
+ terms->term_good = sq_dequote(xstrdup(argv[i]));
+ else
+ terms->term_good = xstrdup(argv[i]);
must_write_terms = 1;
- terms->term_good = xstrdup(argv[++i]);
} else if (skip_prefix(arg, "--term-good=", &arg)) {
must_write_terms = 1;
- terms->term_good = xstrdup(arg);
+ terms->term_good = arg;
} else if (skip_prefix(arg, "--term-old=", &arg)) {
must_write_terms = 1;
- terms->term_good = xstrdup(arg);
+ terms->term_good = arg;
} else if (!strcmp(arg, "--term-bad") ||
!strcmp(arg, "--term-new")) {
+ const char *next_arg;
+ if (starts_with(argv[++i], "'"))
+ terms->term_bad = sq_dequote(xstrdup(argv[i]));
+ else
+ terms->term_bad = xstrdup(argv[i]);
must_write_terms = 1;
- terms->term_bad = xstrdup(argv[++i]);
} else if (skip_prefix(arg, "--term-bad=", &arg)) {
must_write_terms = 1;
- terms->term_bad = xstrdup(arg);
+ terms->term_bad = arg;
} else if (skip_prefix(arg, "--term-new=", &arg)) {
must_write_terms = 1;
- terms->term_good = xstrdup(arg);
+ terms->term_good = arg;
} else if (starts_with(arg, "--") &&
!one_of(arg, "--term-good", "--term-bad", NULL)) {
die(_("unrecognised option: '%s'"), arg);
@@ -604,7 +753,7 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
strbuf_release(&start_head);
strbuf_release(&bisect_names);
strbuf_release(&orig_args);
- return retval;
+ return retval || bisect_auto_next(terms, NULL);
}
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
@@ -619,7 +768,9 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
CHECK_AND_SET_TERMS,
BISECT_NEXT_CHECK,
BISECT_TERMS,
- BISECT_START
+ BISECT_START,
+ BISECT_NEXT,
+ BISECT_AUTO_NEXT,
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -643,6 +794,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("print out the bisect terms"), BISECT_TERMS),
OPT_CMDMODE(0, "bisect-start", &cmdmode,
N_("start the bisect session"), BISECT_START),
+ OPT_CMDMODE(0, "bisect-next", &cmdmode,
+ N_("find the next bisection commit"), BISECT_NEXT),
+ OPT_CMDMODE(0, "bisect-auto-next", &cmdmode,
+ N_("verify the next bisection state then find the next bisection state"), BISECT_AUTO_NEXT),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -710,6 +865,18 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
terms.term_bad = "bad";
res = bisect_start(&terms, no_checkout, argv, argc);
break;
+ case BISECT_NEXT:
+ if (argc)
+ die(_("--bisect-next requires 0 arguments"));
+ get_terms(&terms);
+ res = bisect_next(&terms, prefix);
+ break;
+ case BISECT_AUTO_NEXT:
+ if (argc)
+ die(_("--bisect-auto-next requires 0 arguments"));
+ get_terms(&terms);
+ res = bisect_auto_next(&terms, prefix);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index f0896b3..d574c44 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -63,34 +63,13 @@ bisect_autostart() {
[Nn]*)
exit ;;
esac
- bisect_start
+ git bisect--helper --bisect-start
else
exit 1
fi
}
}
-bisect_start() {
- git bisect--helper --bisect-start $@ || exit
-
- #
- # Change state.
- # 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".
- #
- trap 'git bisect--helper --bisect-clean-state' 0
- trap 'exit 255' 1 2 3 15
- #
- # Check if we can proceed to the next bisect state.
- #
- get_terms
- bisect_auto_next
-
- trap '-' 0
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -109,6 +88,7 @@ bisect_skip() {
bisect_state() {
bisect_autostart
state=$1
+ get_terms
git bisect--helper --check-and-set-terms $state $TERM_GOOD $TERM_BAD || exit
get_terms
case "$#,$state" in
@@ -139,45 +119,7 @@ bisect_state() {
*)
usage ;;
esac
- bisect_auto_next
-}
-
-bisect_auto_next() {
- git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD && bisect_next || :
-}
-
-bisect_next() {
- case "$#" in 0) ;; *) usage ;; esac
- bisect_autostart
- git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD $TERM_GOOD|| exit
-
- # Perform all bisection computation, display and checkout
- git bisect--helper --next-all $(test -f "$GIT_DIR/BISECT_HEAD" && echo --no-checkout)
- res=$?
-
- # Check if we should exit because bisection is finished
- if test $res -eq 10
- then
- bad_rev=$(git show-ref --hash --verify refs/bisect/$TERM_BAD)
- bad_commit=$(git show-branch $bad_rev)
- echo "# first $TERM_BAD commit: $bad_commit" >>"$GIT_DIR/BISECT_LOG"
- exit 0
- elif test $res -eq 2
- then
- echo "# only skipped commits left to test" >>"$GIT_DIR/BISECT_LOG"
- good_revs=$(git for-each-ref --format="%(objectname)" "refs/bisect/$TERM_GOOD-*")
- for skipped in $(git rev-list refs/bisect/$TERM_BAD --not $good_revs)
- do
- skipped_commit=$(git show-branch $skipped)
- echo "# possible first $TERM_BAD commit: $skipped_commit" >>"$GIT_DIR/BISECT_LOG"
- done
- exit $res
- fi
-
- # Check for an error in the bisection process
- test $res -ne 0 && exit $res
-
- return 0
+ git bisect--helper --bisect-auto-next || exit
}
bisect_visualize() {
@@ -221,8 +163,7 @@ bisect_replay () {
get_terms
case "$command" in
start)
- cmd="bisect_start $rev"
- eval "$cmd" ;;
+ eval "git bisect--helper --bisect-start $rev" ;;
"$TERM_GOOD"|"$TERM_BAD"|skip)
git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
terms)
@@ -231,7 +172,7 @@ bisect_replay () {
die "$(gettext "?? what are you talking about?")" ;;
esac
done <"$file"
- bisect_auto_next
+ git bisect--helper --bisect-auto-next
}
bisect_run () {
@@ -319,14 +260,15 @@ case "$#" in
help)
git bisect -h ;;
start)
- bisect_start "$@" ;;
+ git bisect--helper --bisect-start "$@" ;;
bad|good|new|old|"$TERM_BAD"|"$TERM_GOOD")
bisect_state "$cmd" "$@" ;;
skip)
bisect_skip "$@" ;;
next)
# Not sure we want "next" at the UI level anymore.
- bisect_next "$@" ;;
+ get_terms
+ git bisect--helper --bisect-next "$@" || exit ;;
visualize|view)
bisect_visualize "$@" ;;
reset)
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 07/27] bisect--helper: `bisect_reset` shell function in C
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (10 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 15/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function " Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-11-16 23:23 ` Stephan Beyer
2016-10-14 14:14 ` [PATCH v15 22/27] bisect--helper: `bisect_log` " Pranit Bauva
` (15 subsequent siblings)
27 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
Reimplement `bisect_reset` shell function in C and add a `--bisect-reset`
subcommand to `git bisect--helper` to call it from git-bisect.sh .
Using `bisect_reset` subcommand is a temporary measure to port shell
functions to C so as to use the existing test suite. As more functions
are ported, this subcommand would be retired but its implementation will
be called by some other method.
Note: --bisect-clean-state subcommand has not been retired as there are
still a function namely `bisect_start()` which still uses this
subcommand.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 48 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 28 ++--------------------------
2 files changed, 49 insertions(+), 27 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 4254d61..d84ba86 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -3,17 +3,22 @@
#include "parse-options.h"
#include "bisect.h"
#include "refs.h"
+#include "dir.h"
+#include "argv-array.h"
+#include "run-command.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
+static GIT_PATH_FUNC(git_path_bisect_head, "BISECT_HEAD")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-clean-state"),
+ N_("git bisect--helper --bisect-reset [<commit>]"),
NULL
};
@@ -84,12 +89,47 @@ static int write_terms(const char *bad, const char *good)
return (res < 0) ? -1 : 0;
}
+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 {
+ unsigned char sha1[20];
+ if (get_sha1_committish(commit, sha1))
+ return error(_("'%s' is not a valid commit"), commit);
+ strbuf_addstr(&branch, commit);
+ }
+
+ if (!file_exists(git_path_bisect_head())) {
+ struct argv_array argv = ARGV_ARRAY_INIT;
+ argv_array_pushl(&argv, "checkout", branch.buf, "--", NULL);
+ if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
+ error(_("Could not check out original HEAD '%s'. Try "
+ "'git bisect reset <commit>'."), branch.buf);
+ strbuf_release(&branch);
+ argv_array_clear(&argv);
+ return -1;
+ }
+ argv_array_clear(&argv);
+ }
+
+ strbuf_release(&branch);
+ return bisect_clean_state();
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
WRITE_TERMS,
- BISECT_CLEAN_STATE
+ BISECT_CLEAN_STATE,
+ BISECT_RESET
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -99,6 +139,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
+ OPT_CMDMODE(0, "bisect-reset", &cmdmode,
+ N_("reset the bisection state"), BISECT_RESET),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -121,6 +163,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc != 0)
die(_("--bisect-clean-state requires no arguments"));
return bisect_clean_state();
+ case BISECT_RESET:
+ if (argc > 1)
+ die(_("--bisect-reset requires either zero or one arguments"));
+ return bisect_reset(argc ? argv[0] : NULL);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index f1202df..442397b 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -409,35 +409,11 @@ bisect_visualize() {
eval '"$@"' --bisect -- $(cat "$GIT_DIR/BISECT_NAMES")
}
-bisect_reset() {
- test -s "$GIT_DIR/BISECT_START" || {
- gettextln "We are not bisecting."
- return
- }
- case "$#" in
- 0) branch=$(cat "$GIT_DIR/BISECT_START") ;;
- 1) git rev-parse --quiet --verify "$1^{commit}" >/dev/null || {
- invalid="$1"
- die "$(eval_gettext "'\$invalid' is not a valid commit")"
- }
- branch="$1" ;;
- *)
- usage ;;
- esac
-
- if ! test -f "$GIT_DIR/BISECT_HEAD" && ! git checkout "$branch" --
- then
- die "$(eval_gettext "Could not check out original HEAD '\$branch'.
-Try 'git bisect reset <commit>'.")"
- fi
- git bisect--helper --bisect-clean-state || exit
-}
-
bisect_replay () {
file="$1"
test "$#" -eq 1 || die "$(gettext "No logfile given")"
test -r "$file" || die "$(eval_gettext "cannot read \$file for replaying")"
- bisect_reset
+ git bisect--helper --bisect-reset || exit
while read git bisect command rev
do
test "$git $bisect" = "git bisect" || test "$git" = "git-bisect" || continue
@@ -627,7 +603,7 @@ case "$#" in
visualize|view)
bisect_visualize "$@" ;;
reset)
- bisect_reset "$@" ;;
+ git bisect--helper --bisect-reset "$@" ;;
replay)
bisect_replay "$@" ;;
log)
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 17/27] bisect--helper: retire `--next-all` subcommand
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (4 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 20/27] bisect--helper: retire `--check-expected-revs` subcommand Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 18/27] bisect--helper: `bisect_autostart` shell function in C Pranit Bauva
` (21 subsequent siblings)
27 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
The `--next-all` subcommand is no longer used in the shell script and
the function `bisect_next_all()` is called from the C implementation of
`bisect_next()`.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 8 +-------
1 file changed, 1 insertion(+), 7 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 45d9336..502bf18 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -20,7 +20,6 @@ static GIT_PATH_FUNC(git_path_head_name, "head-name")
static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static const char * const git_bisect_helper_usage[] = {
- N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
@@ -758,8 +757,7 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
- NEXT_ALL = 1,
- WRITE_TERMS,
+ WRITE_TERMS = 1,
BISECT_RESET,
CHECK_EXPECTED_REVS,
BISECT_WRITE,
@@ -772,8 +770,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
- OPT_CMDMODE(0, "next-all", &cmdmode,
- N_("perform 'git bisect next'"), NEXT_ALL),
OPT_CMDMODE(0, "write-terms", &cmdmode,
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
@@ -809,8 +805,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
switch (cmdmode) {
int nolog;
- case NEXT_ALL:
- return bisect_next_all(prefix, no_checkout);
case WRITE_TERMS:
if (argc != 2)
die(_("--write-terms requires two arguments"));
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 24/27] bisect--helper: retire `--bisect-write` subcommand
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (22 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 12/27] bisect--helper: `get_terms` & `bisect_terms` shell function in C Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 27/27] bisect--helper: remove the dequote in bisect_start() Pranit Bauva
` (3 subsequent siblings)
27 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
The `--bisect-write` subcommand is no longer used in the shell script
and the function `bisect_write()` is called from the C implementation.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 13 -------------
1 file changed, 13 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index b367d8d..7f676e2 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -21,7 +21,6 @@ static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-reset [<commit>]"),
- N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
@@ -990,7 +989,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
BISECT_RESET = 1,
- BISECT_WRITE,
CHECK_AND_SET_TERMS,
BISECT_NEXT_CHECK,
BISECT_TERMS,
@@ -1006,8 +1004,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
struct option options[] = {
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
N_("reset the bisection state"), BISECT_RESET),
- OPT_CMDMODE(0, "bisect-write", &cmdmode,
- N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
@@ -1042,20 +1038,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
usage_with_options(git_bisect_helper_usage, options);
switch (cmdmode) {
- int nolog;
case BISECT_RESET:
if (argc > 1)
die(_("--bisect-reset requires either zero or one arguments"));
res = bisect_reset(argc ? argv[0] : NULL);
break;
- case BISECT_WRITE:
- if (argc != 4 && argc != 5)
- die(_("--bisect-write requires either 4 or 5 arguments"));
- nolog = (argc == 5) && !strcmp(argv[4], "nolog");
- terms.term_good = xstrdup(argv[2]);
- terms.term_bad = xstrdup(argv[3]);
- res = bisect_write(argv[0], argv[1], &terms, nolog);
- break;
case CHECK_AND_SET_TERMS:
if (argc != 3)
die(_("--check-and-set-terms requires 3 arguments"));
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 26/27] bisect--helper: retire `--bisect-auto-next` subcommand
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (19 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 04/27] bisect--helper: `bisect_clean_state` shell function in C Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 16/27] bisect--helper: retire `--bisect-clean-state` subcommand Pranit Bauva
` (6 subsequent siblings)
27 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
The `--bisect-auto-next` subcommand is no longer used in the shell
script and the function `bisect_auto_next` is called from the C
implementation.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 10 ----------
1 file changed, 10 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 8653fde..d6c2efc 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -27,7 +27,6 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect start [--term-{old,good}=<term> --term-{new,bad}=<term>]"
"[--no-checkout] [<bad> [<good>...]] [--] [<paths>...]"),
N_("git bisect--helper --bisect-next"),
- N_("git bisect--helper --bisect-auto-next"),
N_("git bisect--helper --bisect-state (bad|new) [<rev>]"),
N_("git bisect--helper --bisect-state (good|old) [<rev>...]"),
N_("git bisect--helper --bisect-replay <filename>"),
@@ -993,7 +992,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_TERMS,
BISECT_START,
BISECT_NEXT,
- BISECT_AUTO_NEXT,
BISECT_STATE,
BISECT_LOG,
BISECT_REPLAY
@@ -1012,8 +1010,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("start the bisect session"), BISECT_START),
OPT_CMDMODE(0, "bisect-next", &cmdmode,
N_("find the next bisection commit"), BISECT_NEXT),
- OPT_CMDMODE(0, "bisect-auto-next", &cmdmode,
- N_("verify the next bisection state then find the next bisection state"), BISECT_AUTO_NEXT),
OPT_CMDMODE(0, "bisect-state", &cmdmode,
N_("mark the state of ref (or refs)"), BISECT_STATE),
OPT_CMDMODE(0, "bisect-log", &cmdmode,
@@ -1069,12 +1065,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
get_terms(&terms);
res = bisect_next(&terms, prefix);
break;
- case BISECT_AUTO_NEXT:
- if (argc)
- die(_("--bisect-auto-next requires 0 arguments"));
- get_terms(&terms);
- res = bisect_auto_next(&terms, prefix);
- break;
case BISECT_STATE:
if (argc == 0)
die(_("--bisect-state requires at least 1 argument"));
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 16/27] bisect--helper: retire `--bisect-clean-state` subcommand
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (20 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 26/27] bisect--helper: retire `--bisect-auto-next` subcommand Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 12/27] bisect--helper: `get_terms` & `bisect_terms` shell function in C Pranit Bauva
` (5 subsequent siblings)
27 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
The `bisect-clean-state` subcommand is no longer used in the shell
script while the C code uses `bisect_clean_state()` thus remove the
subcommand.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 9 ---------
1 file changed, 9 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index fcd7574..45d9336 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -22,7 +22,6 @@ static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
- N_("git bisect--helper --bisect-clean-state"),
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
@@ -761,7 +760,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
enum {
NEXT_ALL = 1,
WRITE_TERMS,
- BISECT_CLEAN_STATE,
BISECT_RESET,
CHECK_EXPECTED_REVS,
BISECT_WRITE,
@@ -778,8 +776,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("perform 'git bisect next'"), NEXT_ALL),
OPT_CMDMODE(0, "write-terms", &cmdmode,
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
- OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
- N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
N_("reset the bisection state"), BISECT_RESET),
OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
@@ -820,11 +816,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
die(_("--write-terms requires two arguments"));
res = write_terms(argv[0], argv[1]);
break;
- case BISECT_CLEAN_STATE:
- if (argc != 0)
- die(_("--bisect-clean-state requires no arguments"));
- res = bisect_clean_state();
- break;
case BISECT_RESET:
if (argc > 1)
die(_("--bisect-reset requires either zero or one arguments"));
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 08/27] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (14 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 21/27] bisect--helper: retire `--write-terms` subcommand Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-11-16 23:47 ` Stephan Beyer
2016-10-14 14:14 ` [PATCH v15 11/27] bisect--helper: `bisect_next_check` & bisect_voc " Pranit Bauva
` (11 subsequent siblings)
27 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
Reimplement `is_expected_rev` & `check_expected_revs` shell function in
C and add a `--check-expected-revs` subcommand to `git bisect--helper` to
call it from git-bisect.sh .
Using `--check-expected-revs` subcommand is a temporary measure to port
shell functions to C so as to use the existing test suite. As more
functions are ported, this subcommand would be retired but its
implementation will be called by some other method.
Helped-by: Eric Sunshine <sunshine@sunshineco.com>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 33 ++++++++++++++++++++++++++++++++-
git-bisect.sh | 20 ++------------------
2 files changed, 34 insertions(+), 19 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index d84ba86..c542e8b 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -123,13 +123,40 @@ static int bisect_reset(const char *commit)
return bisect_clean_state();
}
+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 int 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());
+ return 0;
+ }
+ }
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
WRITE_TERMS,
BISECT_CLEAN_STATE,
- BISECT_RESET
+ BISECT_RESET,
+ CHECK_EXPECTED_REVS
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -141,6 +168,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
N_("reset the bisection state"), BISECT_RESET),
+ OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
+ N_("check for expected revs"), CHECK_EXPECTED_REVS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -167,6 +196,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc > 1)
die(_("--bisect-reset requires either zero or one arguments"));
return bisect_reset(argc ? argv[0] : NULL);
+ case CHECK_EXPECTED_REVS:
+ return check_expected_revs(argv, argc);
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 442397b..c3e43248 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -237,22 +237,6 @@ bisect_write() {
test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
}
-is_expected_rev() {
- test -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
- test "$1" = $(cat "$GIT_DIR/BISECT_EXPECTED_REV")
-}
-
-check_expected_revs() {
- for _rev in "$@"; do
- if ! is_expected_rev "$_rev"
- then
- rm -f "$GIT_DIR/BISECT_ANCESTORS_OK"
- rm -f "$GIT_DIR/BISECT_EXPECTED_REV"
- return
- fi
- done
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -280,7 +264,7 @@ bisect_state() {
rev=$(git rev-parse --verify "$bisected_head") ||
die "$(eval_gettext "Bad rev input: \$bisected_head")"
bisect_write "$state" "$rev"
- check_expected_revs "$rev" ;;
+ git bisect--helper --check-expected-revs "$rev" ;;
2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
shift
hash_list=''
@@ -294,7 +278,7 @@ bisect_state() {
do
bisect_write "$state" "$rev"
done
- check_expected_revs $hash_list ;;
+ git bisect--helper --check-expected-revs $hash_list ;;
*,"$TERM_BAD")
die "$(eval_gettext "'git bisect \$TERM_BAD' can take only one argument.")" ;;
*)
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 25/27] bisect--helper: retire `--bisect-autostart` subcommand
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (17 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 19/27] bisect--helper: `bisect_state` & `bisect_head` " Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 04/27] bisect--helper: `bisect_clean_state` shell function in C Pranit Bauva
` (8 subsequent siblings)
27 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
The `--bisect-autostart` subcommand is no longer used in the shell
script and the function `bisect_autostart()` is called from the C
implementation.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 11 -----------
1 file changed, 11 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 7f676e2..8653fde 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -28,7 +28,6 @@ static const char * const git_bisect_helper_usage[] = {
"[--no-checkout] [<bad> [<good>...]] [--] [<paths>...]"),
N_("git bisect--helper --bisect-next"),
N_("git bisect--helper --bisect-auto-next"),
- N_("git bisect--helper --bisect-autostart"),
N_("git bisect--helper --bisect-state (bad|new) [<rev>]"),
N_("git bisect--helper --bisect-state (good|old) [<rev>...]"),
N_("git bisect--helper --bisect-replay <filename>"),
@@ -995,7 +994,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_START,
BISECT_NEXT,
BISECT_AUTO_NEXT,
- BISECT_AUTOSTART,
BISECT_STATE,
BISECT_LOG,
BISECT_REPLAY
@@ -1016,8 +1014,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("find the next bisection commit"), BISECT_NEXT),
OPT_CMDMODE(0, "bisect-auto-next", &cmdmode,
N_("verify the next bisection state then find the next bisection state"), BISECT_AUTO_NEXT),
- OPT_CMDMODE(0, "bisect-autostart", &cmdmode,
- N_("start the bisection if BISECT_START empty or missing"), BISECT_AUTOSTART),
OPT_CMDMODE(0, "bisect-state", &cmdmode,
N_("mark the state of ref (or refs)"), BISECT_STATE),
OPT_CMDMODE(0, "bisect-log", &cmdmode,
@@ -1079,13 +1075,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
get_terms(&terms);
res = bisect_auto_next(&terms, prefix);
break;
- case BISECT_AUTOSTART:
- if (argc)
- die(_("--bisect-autostart requires 0 arguments"));
- terms.term_good = "good";
- terms.term_bad = "bad";
- res = bisect_autostart(&terms);
- break;
case BISECT_STATE:
if (argc == 0)
die(_("--bisect-state requires at least 1 argument"));
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 11/27] bisect--helper: `bisect_next_check` & bisect_voc shell function in C
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (15 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 08/27] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-11-17 20:59 ` Stephan Beyer
2016-10-14 14:14 ` [PATCH v15 19/27] bisect--helper: `bisect_state` & `bisect_head` " Pranit Bauva
` (10 subsequent siblings)
27 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
Reimplement `bisect_next_check` shell function in C and add
`bisect-next-check` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Also reimplement `bisect_voc` shell function in C and call it from
`bisect_next_check` implementation in C.
Using `--bisect-next-check` is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by some other methods.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 110 ++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 60 ++------------------------
2 files changed, 113 insertions(+), 57 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index c6c11e3..317d671 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -6,6 +6,7 @@
#include "dir.h"
#include "argv-array.h"
#include "run-command.h"
+#include "prompt.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
@@ -21,6 +22,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
+ N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
NULL
};
@@ -245,6 +247,102 @@ static int check_and_set_terms(struct bisect_terms *terms, const char *cmd)
return 0;
}
+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;
+}
+
+static char *bisect_voc(char *revision_type)
+{
+ if (!strcmp(revision_type, "bad"))
+ return "bad|new";
+ if (!strcmp(revision_type, "good"))
+ return "good|old";
+
+ return NULL;
+}
+
+static int bisect_next_check(const struct bisect_terms *terms,
+ const char *current_term)
+{
+ int missing_good = 1, missing_bad = 1, retval = 0;
+ char *bad_ref = xstrfmt("refs/bisect/%s", terms->term_bad);
+ char *good_glob = xstrfmt("%s-*", terms->term_good);
+ char *bad_syn, *good_syn;
+
+ if (ref_exists(bad_ref))
+ missing_bad = 0;
+
+ for_each_glob_ref_in(mark_good, good_glob, "refs/bisect/",
+ (void *) &missing_good);
+
+ if (!missing_good && !missing_bad)
+ goto finish;
+
+ if (!current_term) {
+ retval = -1;
+ goto finish;
+ }
+
+ if (missing_good && !missing_bad && current_term &&
+ !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.
+ */
+ fprintf(stderr, _("Warning: bisecting only with a %s commit\n"),
+ terms->term_bad);
+ if (!isatty(0))
+ goto finish;
+ /*
+ * 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")) {
+ retval = -1;
+ goto finish;
+ }
+
+ goto finish;
+ }
+ bad_syn = xstrdup(bisect_voc("bad"));
+ good_syn = xstrdup(bisect_voc("good"));
+ if (!is_empty_or_missing_file(git_path_bisect_start())) {
+ error(_("You need to give me at least one %s and "
+ "%s revision. You can use \"git bisect %s\" "
+ "and \"git bisect %s\" for that. \n"),
+ bad_syn, good_syn, bad_syn, good_syn);
+ retval = -1;
+ goto finish;
+ }
+ else {
+ error(_("You need to start by \"git bisect start\". You "
+ "then need to give me at least one %s and %s "
+ "revision. You can use \"git bisect %s\" and "
+ "\"git bisect %s\" for that.\n"),
+ good_syn, bad_syn, bad_syn, good_syn);
+ retval = -1;
+ goto finish;
+ }
+ goto finish;
+finish:
+ if (!bad_ref)
+ free(bad_ref);
+ if (!good_glob)
+ free(good_glob);
+ if (!bad_syn)
+ free(bad_syn);
+ if (!good_syn)
+ free(good_syn);
+ return retval;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -254,7 +352,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_RESET,
CHECK_EXPECTED_REVS,
BISECT_WRITE,
- CHECK_AND_SET_TERMS
+ CHECK_AND_SET_TERMS,
+ BISECT_NEXT_CHECK
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -272,6 +371,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
+ OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
+ N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -321,6 +422,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
terms.term_bad = xstrdup(argv[2]);
res = check_and_set_terms(&terms, argv[0]);
break;
+ case BISECT_NEXT_CHECK:
+ if (argc != 2 && argc != 3)
+ die(_("--bisect-next-check requires 2 or 3 arguments"));
+ terms.term_good = xstrdup(argv[0]);
+ terms.term_bad = xstrdup(argv[1]);
+ res = bisect_next_check(&terms, argc == 3 ? argv[2] : NULL);
+ break;
default:
die("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index bdf2227..fe6c9d0 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -271,59 +271,14 @@ bisect_state() {
bisect_auto_next
}
-bisect_next_check() {
- missing_good= missing_bad=
- git show-ref -q --verify refs/bisect/$TERM_BAD || missing_bad=t
- test -n "$(git for-each-ref "refs/bisect/$TERM_GOOD-*")" || missing_good=t
-
- case "$missing_good,$missing_bad,$1" in
- ,,*)
- : have both $TERM_GOOD and $TERM_BAD - ok
- ;;
- *,)
- # do not have both but not asked to fail - just report.
- false
- ;;
- t,,"$TERM_GOOD")
- # have bad (or new) but not good (or old). we could bisect although
- # this is less optimum.
- eval_gettextln "Warning: bisecting only with a \$TERM_BAD commit." >&2
- if test -t 0
- then
- # TRANSLATORS: Make sure to include [Y] and [n] in your
- # translation. The program will only accept English input
- # at this point.
- gettext "Are you sure [Y/n]? " >&2
- read yesno
- case "$yesno" in [Nn]*) exit 1 ;; esac
- fi
- : bisect without $TERM_GOOD...
- ;;
- *)
- bad_syn=$(bisect_voc bad)
- good_syn=$(bisect_voc good)
- if test -s "$GIT_DIR/BISECT_START"
- then
-
- eval_gettextln "You need to give me at least one \$bad_syn and one \$good_syn revision.
-(You can use \"git bisect \$bad_syn\" and \"git bisect \$good_syn\" for that.)" >&2
- else
- eval_gettextln "You need to start by \"git bisect start\".
-You then need to give me at least one \$good_syn and one \$bad_syn revision.
-(You can use \"git bisect \$bad_syn\" and \"git bisect \$good_syn\" for that.)" >&2
- fi
- exit 1 ;;
- esac
-}
-
bisect_auto_next() {
- bisect_next_check && bisect_next || :
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD && bisect_next || :
}
bisect_next() {
case "$#" in 0) ;; *) usage ;; esac
bisect_autostart
- bisect_next_check $TERM_GOOD
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD $TERM_GOOD|| exit
# Perform all bisection computation, display and checkout
git bisect--helper --next-all $(test -f "$GIT_DIR/BISECT_HEAD" && echo --no-checkout)
@@ -355,7 +310,7 @@ bisect_next() {
}
bisect_visualize() {
- bisect_next_check fail
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD fail || exit
if test $# = 0
then
@@ -409,7 +364,7 @@ bisect_replay () {
}
bisect_run () {
- bisect_next_check fail
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD fail || exit
while true
do
@@ -482,13 +437,6 @@ get_terms () {
fi
}
-bisect_voc () {
- case "$1" in
- bad) echo "bad|new" ;;
- good) echo "good|old" ;;
- esac
-}
-
bisect_terms () {
get_terms
if ! test -s "$GIT_DIR/BISECT_TERMS"
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v15 27/27] bisect--helper: remove the dequote in bisect_start()
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (23 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 24/27] bisect--helper: retire `--bisect-write` subcommand Pranit Bauva
@ 2016-10-14 14:14 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 23/27] bisect--helper: `bisect_replay` shell function in C Pranit Bauva
` (2 subsequent siblings)
27 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 14:14 UTC (permalink / raw)
To: git
Dequoting the arguments was introduced in 25b48b5c to port the function
`bisect_next()` but after the `bisect_replay()` porting, the dequoting
is carried out itself when it passes the arguments to `bisect_start()`
in a simpler way thus dequoting again isn't required. So remove the
extra "deqouting" code introduced by the commit 25b48b5c.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 26 ++++++--------------------
1 file changed, 6 insertions(+), 20 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index d6c2efc..8cd6527 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -561,24 +561,16 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
no_checkout = 1;
for (i = 0; i < argc; i++) {
- const char *arg;
- if (starts_with(argv[i], "'"))
- arg = sq_dequote(xstrdup(argv[i]));
- else
- arg = argv[i];
- if (!strcmp(arg, "--")) {
+ if (!strcmp(argv[i], "--")) {
has_double_dash = 1;
break;
}
}
for (i = 0; i < argc; i++) {
- const char *arg, *commit_id;
- if (starts_with(argv[i], "'"))
- arg = sq_dequote(xstrdup(argv[i]));
- else
- arg = argv[i];
- commit_id = xstrfmt("%s^{commit}", arg);
+ const char *commit_id;
+ const char *arg = argv[i];
+ commit_id = xstrfmt("%s^{commit}", argv[i]);
if (!strcmp(argv[i], "--")) {
has_double_dash = 1;
break;
@@ -586,11 +578,8 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
no_checkout = 1;
} else if (!strcmp(arg, "--term-good") ||
!strcmp(arg, "--term-old")) {
- if (starts_with(argv[++i], "'"))
- terms->term_good = sq_dequote(xstrdup(argv[i]));
- else
- terms->term_good = xstrdup(argv[i]);
must_write_terms = 1;
+ terms->term_good = xstrdup(argv[++i]);
} else if (skip_prefix(arg, "--term-good=", &arg)) {
must_write_terms = 1;
terms->term_good = arg;
@@ -599,10 +588,7 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
terms->term_good = arg;
} else if (!strcmp(arg, "--term-bad") ||
!strcmp(arg, "--term-new")) {
- if (starts_with(argv[++i], "'"))
- terms->term_bad = sq_dequote(xstrdup(argv[i]));
- else
- terms->term_bad = xstrdup(argv[i]);
+ terms->term_bad = xstrdup(argv[++i]);
must_write_terms = 1;
} else if (skip_prefix(arg, "--term-bad=", &arg)) {
must_write_terms = 1;
--
https://github.com/git/git/pull/287
^ permalink raw reply related [flat|nested] 320+ messages in thread
* Re: [PATCH v15 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (25 preceding siblings ...)
2016-10-14 14:14 ` [PATCH v15 23/27] bisect--helper: `bisect_replay` shell function in C Pranit Bauva
@ 2016-10-14 15:12 ` Pranit Bauva
2017-09-29 6:49 ` [PATCH v16 1/6] " Pranit Bauva
2016-10-27 16:59 ` [PATCH v15 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Junio C Hamano
27 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-10-14 15:12 UTC (permalink / raw)
To: Git List; +Cc: Junio C Hamano, Christian Couder, Christian Couder,
Lars Schneider
Hey everyone,
It took me some time to get to the next version as I was a bit
preoccupied with my assignments and exams. The diff between the v14[1]
and v15[2] can be found here[3] because gmail web client will wrap the
lines. Thanks Junio for the reviews in v14. I have tried to solves
every issue raised in the previous round.
The major changes in this series are:
* Use the char * instead of struct strbuf in struct bisect_terms.
* Use goto mechanism for error handling.
* Use get_sha1_committish() instead of just get_oid() because there
is also ^{commit} at the end of the call from shell.
* Use skip_prefix() where ever required.
* Use return error() instead of die() where ever possible.
* Restructure a part in bisect_start() to make it more readable.
* Change the comments in bisect.c to use return instead of exit
because the code does it.
* Introduce a test to check for cleanups in after bad merge base to
make the patch 15/28 more understood.
* Also keeping comments in bisect.c to show at which places there
would be cleanups and where not.
* Restructure bisect_replay() and get_next_word().
[1]: http://public-inbox.org/git/01020156b73fe5b4-5dc768ab-b73b-4a21-ab92-018e2a7aa6f7-000000@eu-west-1.amazonses.com/T/#m7c26060fcf95abbd19f93742d7317eef87b915a1
[2]: http://public-inbox.org/git/01020157c38b19e0-81123fa5-5d9d-4f64-8f1b-ff336e83ebe4-000000@eu-west-1.amazonses.com/T/#u
[3]: http://paste.ubuntu.com/23323581/
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 14/27] t6030: no cleanup with bad merge base
2016-10-14 14:14 ` [PATCH v15 14/27] t6030: no cleanup with bad merge base Pranit Bauva
@ 2016-10-14 21:43 ` Junio C Hamano
2016-10-15 8:46 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2016-10-14 21:43 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> +test_expect_success 'check whether bisection cleanup is not done with bad merges' '
> + git bisect start $HASH7 $SIDE_HASH7 &&
> + test_expect_failure git bisect bad >out 2>out &&
I think you meant "test_must_fail" here.
> + test_i18ngrep "The merge base" out &&
> + test -e .git/BISECT_START
> +'
> +
> test_done
>
> --
> https://github.com/git/git/pull/287
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 14/27] t6030: no cleanup with bad merge base
2016-10-14 21:43 ` Junio C Hamano
@ 2016-10-15 8:46 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-10-15 8:46 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Sat, Oct 15, 2016 at 3:13 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> +test_expect_success 'check whether bisection cleanup is not done with bad merges' '
>> + git bisect start $HASH7 $SIDE_HASH7 &&
>> + test_expect_failure git bisect bad >out 2>out &&
>
> I think you meant "test_must_fail" here.
Oh yes! Thanks for pointing it out. I see that you have already
submitted a patch to catch this mistake which was previously ignored.
Thanks!
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
` (26 preceding siblings ...)
2016-10-14 15:12 ` [PATCH v15 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
@ 2016-10-27 16:59 ` Junio C Hamano
2016-10-27 20:14 ` Christian Couder
` (2 more replies)
27 siblings, 3 replies; 320+ messages in thread
From: Junio C Hamano @ 2016-10-27 16:59 UTC (permalink / raw)
To: git
Cc: Pranit Bauva, Christian Couder, Matthieu Moy, Alex Henrie,
Antoine Delaite
Cc'ed those who touched either "git-bisect.sh" or "builtin/bisect-helper.c"
in our relatively recent past.
Does any of you (and others on the list) have time and inclination
to review this series?
Thanks.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2016-10-27 16:59 ` [PATCH v15 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Junio C Hamano
@ 2016-10-27 20:14 ` Christian Couder
2016-10-28 6:02 ` Matthieu Moy
2016-11-15 21:40 ` Stephan Beyer
2 siblings, 0 replies; 320+ messages in thread
From: Christian Couder @ 2016-10-27 20:14 UTC (permalink / raw)
To: Junio C Hamano
Cc: git, Pranit Bauva, Matthieu Moy, Alex Henrie, Antoine Delaite
On Thu, Oct 27, 2016 at 6:59 PM, Junio C Hamano <gitster@pobox.com> wrote:
> Cc'ed those who touched either "git-bisect.sh" or "builtin/bisect-helper.c"
> in our relatively recent past.
>
> Does any of you (and others on the list) have time and inclination
> to review this series?
As part of my mentoring Pranit for the GSoC I already took a look at
those patches some months ago on GitHub.
I could take another look at them but my eyes will not be fresh
anymore, so I don know if it will be valuable.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2016-10-27 16:59 ` [PATCH v15 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Junio C Hamano
2016-10-27 20:14 ` Christian Couder
@ 2016-10-28 6:02 ` Matthieu Moy
2016-11-15 21:40 ` Stephan Beyer
2 siblings, 0 replies; 320+ messages in thread
From: Matthieu Moy @ 2016-10-28 6:02 UTC (permalink / raw)
To: Junio C Hamano
Cc: git, Pranit Bauva, Christian Couder, Alex Henrie, Antoine Delaite
Junio C Hamano <gitster@pobox.com> writes:
> Cc'ed those who touched either "git-bisect.sh" or "builtin/bisect-helper.c"
> in our relatively recent past.
>
> Does any of you (and others on the list) have time and inclination
> to review this series?
Unfortunately, I have essentially zero-bandwidth to do that in the near
future :-(.
--
Matthieu Moy
http://www-verimag.imag.fr/~moy/
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 02/27] bisect: rewrite `check_term_format` shell function in C
2016-10-14 14:14 ` [PATCH v15 02/27] bisect: rewrite `check_term_format` shell function in C Pranit Bauva
@ 2016-11-14 22:20 ` Stephan Beyer
2016-11-15 5:16 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2016-11-14 22:20 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Hi,
I saw in the recent "What's cooking" mail that this is still waiting
for review, so I thought I could interfere and help reviewing it from a
non-git-developer point of view.
But only two commits for today. The first one seems fine. The second
one makes me write this mail ;-)
On 10/14/2016 04:14 PM, Pranit Bauva wrote:
> +static int check_term_format(const char *term, const char *orig_term)
> +{
[...]
> + if (one_of(term, "help", "start", "skip", "next", "reset",
> + "visualize", "replay", "log", "run", NULL))
[... vs ...]
> -check_term_format () {
> - term=$1
> - git check-ref-format refs/bisect/"$term" ||
> - die "$(eval_gettext "'\$term' is not a valid term")"
> - case "$term" in
> - help|start|terms|skip|next|reset|visualize|replay|log|run)
Is there a reasons why "terms" has been dropped from the list?
Best
Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 02/27] bisect: rewrite `check_term_format` shell function in C
2016-11-14 22:20 ` Stephan Beyer
@ 2016-11-15 5:16 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-11-15 5:16 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
On Tue, Nov 15, 2016 at 3:50 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
> Hi,
>
> I saw in the recent "What's cooking" mail that this is still waiting
> for review, so I thought I could interfere and help reviewing it from a
> non-git-developer point of view.
> But only two commits for today. The first one seems fine. The second
> one makes me write this mail ;-)
Thanks a lot!
> On 10/14/2016 04:14 PM, Pranit Bauva wrote:
>> +static int check_term_format(const char *term, const char *orig_term)
>> +{
> [...]
>> + if (one_of(term, "help", "start", "skip", "next", "reset",
>> + "visualize", "replay", "log", "run", NULL))
> [... vs ...]
>> -check_term_format () {
>> - term=$1
>> - git check-ref-format refs/bisect/"$term" ||
>> - die "$(eval_gettext "'\$term' is not a valid term")"
>> - case "$term" in
>> - help|start|terms|skip|next|reset|visualize|replay|log|run)
>
> Is there a reasons why "terms" has been dropped from the list?
It is a mistake. I will rectify.. Thanks!
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 04/27] bisect--helper: `bisect_clean_state` shell function in C
2016-10-14 14:14 ` [PATCH v15 04/27] bisect--helper: `bisect_clean_state` shell function in C Pranit Bauva
@ 2016-11-15 21:09 ` Stephan Beyer
2016-11-15 21:40 ` Junio C Hamano
0 siblings, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2016-11-15 21:09 UTC (permalink / raw)
To: Pranit Bauva, git
Hi,
On 10/14/2016 04:14 PM, Pranit Bauva wrote:
> diff --git a/bisect.c b/bisect.c
> index 6f512c2..45d598d 100644
> --- a/bisect.c
> +++ b/bisect.c
> @@ -1040,3 +1046,40 @@ int estimate_bisect_steps(int all)
>
> return (e < 3 * x) ? n : n - 1;
> }
> +
> +static int mark_for_removal(const char *refname, const struct object_id *oid,
> + int flag, void *cb_data)
> +{
> + struct string_list *refs = cb_data;
> + char *ref = xstrfmt("refs/bisect%s", refname);
> + string_list_append(refs, ref);
> + return 0;
> +}
> +
> +int bisect_clean_state(void)
> +{
> + int result = 0;
> +
> + /* There may be some refs packed during bisection */
> + struct string_list refs_for_removal = STRING_LIST_INIT_NODUP;
> + for_each_ref_in("refs/bisect", mark_for_removal, (void *) &refs_for_removal);
> + string_list_append(&refs_for_removal, xstrdup("BISECT_HEAD"));
> + result = delete_refs(&refs_for_removal, REF_NODEREF);
> + refs_for_removal.strdup_strings = 1;
> + string_list_clear(&refs_for_removal, 0);
Does it have advantages to populate a list (with duplicated strings),
hand it to delete_refs(), and clear the list (and strings), instead of
just doing a single delete_ref() (or whatever name the singular function
has) in the callback?
I am only seeing the disadvantage: a list with duped strings.
> + unlink_or_warn(git_path_bisect_expected_rev());
[...]
> + unlink_or_warn(git_path_bisect_start());
Comparing it with the original shell code (which uses "rm -f"), I was
wondering a little after reading the function name unlink_or_warn()
here... Looking it up helped: despite its name, unlink_or_warn() is
really the function you have to use here ;D
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 65cf519..4254d61 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -5,10 +5,15 @@
> #include "refs.h"
>
> static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
> +static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
> +static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
> +static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
> +static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
This is perhaps a non-issue, but you do not need any of these new path
functions in *this* patch. I think nobody really cares, though, because
you will need them later.
Cheers
Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 04/27] bisect--helper: `bisect_clean_state` shell function in C
2016-11-15 21:09 ` Stephan Beyer
@ 2016-11-15 21:40 ` Junio C Hamano
2016-11-15 21:53 ` Stephan Beyer
2016-11-16 16:49 ` Pranit Bauva
0 siblings, 2 replies; 320+ messages in thread
From: Junio C Hamano @ 2016-11-15 21:40 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Pranit Bauva, git
Stephan Beyer <s-beyer@gmx.net> writes:
>> +int bisect_clean_state(void)
>> +{
>> + int result = 0;
>> +
>> + /* There may be some refs packed during bisection */
>> + struct string_list refs_for_removal = STRING_LIST_INIT_NODUP;
>> + for_each_ref_in("refs/bisect", mark_for_removal, (void *) &refs_for_removal);
>> + string_list_append(&refs_for_removal, xstrdup("BISECT_HEAD"));
>> + result = delete_refs(&refs_for_removal, REF_NODEREF);
>> + refs_for_removal.strdup_strings = 1;
>> + string_list_clear(&refs_for_removal, 0);
>
> Does it have advantages to populate a list (with duplicated strings),
> hand it to delete_refs(), and clear the list (and strings), instead of
> just doing a single delete_ref() (or whatever name the singular function
> has) in the callback?
Depending on ref backends, removing multiple refs may be a lot more
efficient than calling a single ref removal for the same set of
refs, and the comment upfront I think hints that the code was
written in the way exactly with that in mind. Removing N refs from
a packed refs file will involve a loop that runs N times, each
iteration loading the file, locating an entry among possibly 100s of
refs to remove, and then rewriting the file.
Besides, it is bad taste to delete each individual item being
iterated over in an interator in general, isn't it?
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2016-10-27 16:59 ` [PATCH v15 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Junio C Hamano
2016-10-27 20:14 ` Christian Couder
2016-10-28 6:02 ` Matthieu Moy
@ 2016-11-15 21:40 ` Stephan Beyer
2016-11-16 0:18 ` Junio C Hamano
2 siblings, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2016-11-15 21:40 UTC (permalink / raw)
To: Junio C Hamano, git
Cc: Pranit Bauva, Christian Couder, Matthieu Moy, Alex Henrie,
Antoine Delaite
Hi,
On 10/27/2016 06:59 PM, Junio C Hamano wrote:
> Does any of you (and others on the list) have time and inclination
> to review this series?
Me, currently. ;)
Besides the things I'm mentioning in respective patch e-mails, I wonder
why several bisect--helper commands are prefixed by "bisect"; I'm
talking about:
git bisect--helper --bisect-clean-state
git bisect--helper --bisect-reset
git bisect--helper --bisect-write
git bisect--helper --bisect-check-and-set-terms
git bisect--helper --bisect-next-check
git bisect--helper --bisect-terms
git bisect--helper --bisect-start
etc.
instead of
git bisect--helper --clean-state
git bisect--helper --reset
git bisect--helper --write
git bisect--helper --check-and-set-terms
git bisect--helper --next-check
git bisect--helper --terms
git bisect--helper --start
etc.
Well, I know *why* they have these names: because the shell function
names are simply reused. But I don't know why these prefixes are kept in
the bisect--helper command options. On the other hand, these command
names are not exposed to the user and may hence not be that important.(?)
~Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 04/27] bisect--helper: `bisect_clean_state` shell function in C
2016-11-15 21:40 ` Junio C Hamano
@ 2016-11-15 21:53 ` Stephan Beyer
2016-11-16 16:49 ` Pranit Bauva
1 sibling, 0 replies; 320+ messages in thread
From: Stephan Beyer @ 2016-11-15 21:53 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Pranit Bauva, git
On 11/15/2016 10:40 PM, Junio C Hamano wrote:
> Stephan Beyer <s-beyer@gmx.net> writes:
>
>>> +int bisect_clean_state(void)
>>> +{
>>> + int result = 0;
>>> +
>>> + /* There may be some refs packed during bisection */
>>> + struct string_list refs_for_removal = STRING_LIST_INIT_NODUP;
>>> + for_each_ref_in("refs/bisect", mark_for_removal, (void *) &refs_for_removal);
>>> + string_list_append(&refs_for_removal, xstrdup("BISECT_HEAD"));
>>> + result = delete_refs(&refs_for_removal, REF_NODEREF);
>>> + refs_for_removal.strdup_strings = 1;
>>> + string_list_clear(&refs_for_removal, 0);
>>
>> Does it have advantages to populate a list (with duplicated strings),
>> hand it to delete_refs(), and clear the list (and strings), instead of
>> just doing a single delete_ref() (or whatever name the singular function
>> has) in the callback?
>
> Depending on ref backends, removing multiple refs may be a lot more
> efficient than calling a single ref removal for the same set of
> refs, and the comment upfront I think hints that the code was
> written in the way exactly with that in mind. Removing N refs from
> a packed refs file will involve a loop that runs N times, each
> iteration loading the file, locating an entry among possibly 100s of
> refs to remove, and then rewriting the file.
Great, that's the reply I wanted to hear (and that I've considered but
wasn't sure of) ;)
[I did not want to dig into the sources and check if delete_refs() does
something smarter than invoking delete_ref() on each item of the list.]
~Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 13/27] bisect--helper: `bisect_start` shell function partially in C
2016-10-14 14:14 ` [PATCH v15 13/27] bisect--helper: `bisect_start` shell function partially in C Pranit Bauva
@ 2016-11-15 23:19 ` Stephan Beyer
2016-11-16 17:09 ` Pranit Bauva
2016-11-20 20:01 ` Stephan Beyer
1 sibling, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2016-11-15 23:19 UTC (permalink / raw)
To: Pranit Bauva, git
Hi,
On 10/14/2016 04:14 PM, Pranit Bauva wrote:
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 6a5878c..1d3e17f 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -24,6 +27,8 @@ static const char * const git_bisect_helper_usage[] = {
> N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
> N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
> N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
> + N_("git bisect--helper --bisect start [--term-{old,good}=<term> --term-{new,bad}=<term>]"
> + "[--no-checkout] [<bad> [<good>...]] [--] [<paths>...]"),
Typo: "--bisect start" with space instead of "-"
> @@ -403,6 +408,205 @@ static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
> return 0;
> }
>
> +static int bisect_start(struct bisect_terms *terms, int no_checkout,
> + const char **argv, int argc)
> +{
> + int i, has_double_dash = 0, must_write_terms = 0, bad_seen = 0;
> + int flags, pathspec_pos, retval = 0;
> + 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 strbuf orig_args = STRBUF_INIT;
> + const char *head;
> + unsigned char sha1[20];
> + FILE *fp = NULL;
> + struct object_id oid;
> +
> + if (is_bare_repository())
> + no_checkout = 1;
> +
> + for (i = 0; i < argc; i++) {
> + if (!strcmp(argv[i], "--")) {
> + has_double_dash = 1;
> + break;
> + }
> + }
> +
> + for (i = 0; i < argc; i++) {
> + const char *commit_id = xstrfmt("%s^{commit}", argv[i]);
> + const char *arg = argv[i];
> + if (!strcmp(argv[i], "--")) {
> + has_double_dash = 1;
This is without effect since has_double_dash is already set to 1 by the
loop above. I think you can remove this line.
> + break;
> + } else if (!strcmp(arg, "--no-checkout")) {
> + no_checkout = 1;
> + } else if (!strcmp(arg, "--term-good") ||
> + !strcmp(arg, "--term-old")) {
> + must_write_terms = 1;
> + terms->term_good = xstrdup(argv[++i]);
> + } else if (skip_prefix(arg, "--term-good=", &arg)) {
> + must_write_terms = 1;
> + terms->term_good = xstrdup(arg);
> + } else if (skip_prefix(arg, "--term-old=", &arg)) {
> + must_write_terms = 1;
> + terms->term_good = xstrdup(arg);
I think you can join the last two branches:
+ } else if (skip_prefix(arg, "--term-good=", &arg) ||
+ skip_prefix(arg, "--term-old=", &arg)) {
+ must_write_terms = 1;
+ terms->term_good = xstrdup(arg);
> + } else if (!strcmp(arg, "--term-bad") ||
> + !strcmp(arg, "--term-new")) {
> + must_write_terms = 1;
> + terms->term_bad = xstrdup(argv[++i]);
> + } else if (skip_prefix(arg, "--term-bad=", &arg)) {
> + must_write_terms = 1;
> + terms->term_bad = xstrdup(arg);
> + } else if (skip_prefix(arg, "--term-new=", &arg)) {
> + must_write_terms = 1;
> + terms->term_good = xstrdup(arg);
This has to be terms->term_bad = ...
Also, you can join the last two branches, again, ie,
+ } else if (skip_prefix(arg, "--term-bad=", &arg) ||
+ skip_prefix(arg, "--term-new=", &arg)) {
+ must_write_terms = 1;
+ terms->term_bad = xstrdup(arg);
> + } else if (starts_with(arg, "--") &&
> + !one_of(arg, "--term-good", "--term-bad", NULL)) {
> + die(_("unrecognised option: '%s'"), arg);
[...]
> + /*
> + * Verify HEAD
> + */
> + head = resolve_ref_unsafe("HEAD", 0, sha1, &flags);
> + if (!head)
> + if (get_sha1("HEAD", sha1))
> + die(_("Bad HEAD - I need a HEAD"));
> +
> + if (!is_empty_or_missing_file(git_path_bisect_start())) {
You were so eager to re-use the comments from the shell script, but you
forgot the "Check if we are bisecting." comment above this line ;-)
> + /* 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) {
> + struct argv_array argv = ARGV_ARRAY_INIT;
[...]
> + if (must_write_terms)
> + if (write_terms(terms->term_bad, terms->term_good)) {
> + retval = -1;
> + goto finish;
> + }
> +
bisect_start() is a pretty big function.
I think it can easily be decomposed in some smaller parts, for example,
the following lines ...
> + fp = fopen(git_path_bisect_log(), "a");
> + if (!fp)
> + return -1;
> +
> + if (fprintf(fp, "git bisect start") < 1) {
> + retval = -1;
> + goto finish;
> + }
> +
> + sq_quote_argv(&orig_args, argv, 0);
> + if (fprintf(fp, "%s", orig_args.buf) < 0) {
> + retval = -1;
> + goto finish;
> + }
> + if (fprintf(fp, "\n") < 1) {
> + retval = -1;
> + goto finish;
> + }
... could be in a function like
static int bisect_append_log(const char **argv)
{
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) {
retval = -1;
goto finish;
}
sq_quote_argv(&orig_args, argv, 0);
if (fprintf(fp, "%s", orig_args.buf) < 0 ||
fprintf(fp, "\n") < 1) {
retval = -1;
goto finish;
}
finish:
if (fp)
fclose(fp);
strbuf_release(&orig_args);
return retval;
}
and then simply call
retval = bisect_append_log(argv);
in bisect_start()... (This is totally untested.)
If you do not want that for some reason, you should at least fix
> + if (!fp)
> + return -1;
to retval = 1; goto finish; such that the other lists and strings are
released.
> + goto finish;
> +finish:
The "goto finish" right above the "finish" label is unnecessary.
> + if (fp)
> + fclose(fp);
> + string_list_clear(&revs, 0);
> + string_list_clear(&states, 0);
> + strbuf_release(&start_head);
> + strbuf_release(&bisect_names);
> + strbuf_release(&orig_args);
> + return retval;
> +}
> +
> int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> {
> enum {
By the way, there are two spaghetti-ish ways to get rid of the
retval = -1;
goto finish;
line pair:
goto fail;
and below the "return retval;" add
fail:
retval = -1;
goto finish;
and you can feel the touch of His Noodly Appendage. *scnr*
The other way is to keep the "goto finish" I deemed unnecessary (right
above the label), and expand it to:
goto finish;
fail:
retval = -1;
finish:
...
Cheers
Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2016-11-15 21:40 ` Stephan Beyer
@ 2016-11-16 0:18 ` Junio C Hamano
0 siblings, 0 replies; 320+ messages in thread
From: Junio C Hamano @ 2016-11-16 0:18 UTC (permalink / raw)
To: Stephan Beyer
Cc: git, Pranit Bauva, Christian Couder, Matthieu Moy, Alex Henrie,
Antoine Delaite
Stephan Beyer <s-beyer@gmx.net> writes:
> Besides the things I'm mentioning in respective patch e-mails, I wonder
> why several bisect--helper commands are prefixed by "bisect"; I'm
> talking about:
>
> git bisect--helper --bisect-clean-state
>...
> git bisect--helper --bisect-start
> etc.
>
> instead of
>
> git bisect--helper --clean-state
>...
> git bisect--helper --start
> etc.
>
> Well, I know *why* they have these names: because the shell function
> names are simply reused. But I don't know why these prefixes are kept in
> the bisect--helper command options. On the other hand, these command
> names are not exposed to the user and may hence not be that important.(?)
That's a good point ;-)
These are not intended to be end-user entry points, so names that
are bit longer than necessary does not bother me too much.
Hopefully the longer-term endgame would be not to need a separate
"bisect-helper" binary at all but to have a "git bisect" binary
making these requests as subroutine calls, and at that point, the
names of the functions would want to have "bisect" prefix.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 04/27] bisect--helper: `bisect_clean_state` shell function in C
2016-11-15 21:40 ` Junio C Hamano
2016-11-15 21:53 ` Stephan Beyer
@ 2016-11-16 16:49 ` Pranit Bauva
1 sibling, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-11-16 16:49 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Stephan Beyer, Git List
Hey Junio,
On Wed, Nov 16, 2016 at 3:10 AM, Junio C Hamano <gitster@pobox.com> wrote:
>
> Stephan Beyer <s-beyer@gmx.net> writes:
>
> >> +int bisect_clean_state(void)
> >> +{
> >> + int result = 0;
> >> +
> >> + /* There may be some refs packed during bisection */
> >> + struct string_list refs_for_removal = STRING_LIST_INIT_NODUP;
> >> + for_each_ref_in("refs/bisect", mark_for_removal, (void *) &refs_for_removal);
> >> + string_list_append(&refs_for_removal, xstrdup("BISECT_HEAD"));
> >> + result = delete_refs(&refs_for_removal, REF_NODEREF);
> >> + refs_for_removal.strdup_strings = 1;
> >> + string_list_clear(&refs_for_removal, 0);
> >
> > Does it have advantages to populate a list (with duplicated strings),
> > hand it to delete_refs(), and clear the list (and strings), instead of
> > just doing a single delete_ref() (or whatever name the singular function
> > has) in the callback?
>
> Depending on ref backends, removing multiple refs may be a lot more
> efficient than calling a single ref removal for the same set of
> refs, and the comment upfront I think hints that the code was
> written in the way exactly with that in mind. Removing N refs from
> a packed refs file will involve a loop that runs N times, each
> iteration loading the file, locating an entry among possibly 100s of
> refs to remove, and then rewriting the file.
>
> Besides, it is bad taste to delete each individual item being
> iterated over in an interator in general, isn't it?
>
Not just that, deleting a ref inside for_each*() is illegal because it
builds some kind of index and that is spoiled if anything is deleted
in between. Thus it gives a seg fault. See this[1]. I did the same
mistake when making this patch and I was confused about that was
happening but then Michael Haggerty pointed this out[2].
[1]: https://github.com/git/git/blob/v2.11.0-rc1/refs.h#L183-L191
[2]: http://public-inbox.org/git/574D122F.7080608@alum.mit.edu/
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 13/27] bisect--helper: `bisect_start` shell function partially in C
2016-11-15 23:19 ` Stephan Beyer
@ 2016-11-16 17:09 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-11-16 17:09 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
On Wed, Nov 16, 2016 at 4:49 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
> Hi,
>
> On 10/14/2016 04:14 PM, Pranit Bauva wrote:
>> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
>> index 6a5878c..1d3e17f 100644
>> --- a/builtin/bisect--helper.c
>> +++ b/builtin/bisect--helper.c
>> @@ -24,6 +27,8 @@ static const char * const git_bisect_helper_usage[] = {
>> N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
>> N_("git bisect--helper --bisect-next-check [<term>] <TERM_GOOD> <TERM_BAD"),
>> N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
>> + N_("git bisect--helper --bisect start [--term-{old,good}=<term> --term-{new,bad}=<term>]"
>> + "[--no-checkout] [<bad> [<good>...]] [--] [<paths>...]"),
>
> Typo: "--bisect start" with space instead of "-"
>
>> @@ -403,6 +408,205 @@ static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
>> return 0;
>> }
>>
>> +static int bisect_start(struct bisect_terms *terms, int no_checkout,
>> + const char **argv, int argc)
>> +{
>> + int i, has_double_dash = 0, must_write_terms = 0, bad_seen = 0;
>> + int flags, pathspec_pos, retval = 0;
>> + 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 strbuf orig_args = STRBUF_INIT;
>> + const char *head;
>> + unsigned char sha1[20];
>> + FILE *fp = NULL;
>> + struct object_id oid;
>> +
>> + if (is_bare_repository())
>> + no_checkout = 1;
>> +
>> + for (i = 0; i < argc; i++) {
>> + if (!strcmp(argv[i], "--")) {
>> + has_double_dash = 1;
>> + break;
>> + }
>> + }
>> +
>> + for (i = 0; i < argc; i++) {
>> + const char *commit_id = xstrfmt("%s^{commit}", argv[i]);
>> + const char *arg = argv[i];
>> + if (!strcmp(argv[i], "--")) {
>> + has_double_dash = 1;
>
> This is without effect since has_double_dash is already set to 1 by the
> loop above. I think you can remove this line.
True. I will remove this line.
>> + break;
>> + } else if (!strcmp(arg, "--no-checkout")) {
>> + no_checkout = 1;
>> + } else if (!strcmp(arg, "--term-good") ||
>> + !strcmp(arg, "--term-old")) {
>> + must_write_terms = 1;
>> + terms->term_good = xstrdup(argv[++i]);
>> + } else if (skip_prefix(arg, "--term-good=", &arg)) {
>> + must_write_terms = 1;
>> + terms->term_good = xstrdup(arg);
>> + } else if (skip_prefix(arg, "--term-old=", &arg)) {
>> + must_write_terms = 1;
>> + terms->term_good = xstrdup(arg);
>
> I think you can join the last two branches:
>
> + } else if (skip_prefix(arg, "--term-good=", &arg) ||
> + skip_prefix(arg, "--term-old=", &arg)) {
> + must_write_terms = 1;
> + terms->term_good = xstrdup(arg);
>
>> + } else if (!strcmp(arg, "--term-bad") ||
>> + !strcmp(arg, "--term-new")) {
>> + must_write_terms = 1;
>> + terms->term_bad = xstrdup(argv[++i]);
>> + } else if (skip_prefix(arg, "--term-bad=", &arg)) {
>> + must_write_terms = 1;
>> + terms->term_bad = xstrdup(arg);
>> + } else if (skip_prefix(arg, "--term-new=", &arg)) {
>> + must_write_terms = 1;
>> + terms->term_good = xstrdup(arg);
>
> This has to be terms->term_bad = ...
My bad.
> Also, you can join the last two branches, again, ie,
Sure!
> + } else if (skip_prefix(arg, "--term-bad=", &arg) ||
> + skip_prefix(arg, "--term-new=", &arg)) {
> + must_write_terms = 1;
> + terms->term_bad = xstrdup(arg);
>
>> + } else if (starts_with(arg, "--") &&
>> + !one_of(arg, "--term-good", "--term-bad", NULL)) {
>> + die(_("unrecognised option: '%s'"), arg);
> [...]
>> + /*
>> + * Verify HEAD
>> + */
>> + head = resolve_ref_unsafe("HEAD", 0, sha1, &flags);
>> + if (!head)
>> + if (get_sha1("HEAD", sha1))
>> + die(_("Bad HEAD - I need a HEAD"));
>> +
>> + if (!is_empty_or_missing_file(git_path_bisect_start())) {
>
> You were so eager to re-use the comments from the shell script, but you
> forgot the "Check if we are bisecting." comment above this line ;-)
I will add it back again.
>> + /* 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) {
>> + struct argv_array argv = ARGV_ARRAY_INIT;
> [...]
>> + if (must_write_terms)
>> + if (write_terms(terms->term_bad, terms->term_good)) {
>> + retval = -1;
>> + goto finish;
>> + }
>> +
>
> bisect_start() is a pretty big function.
> I think it can easily be decomposed in some smaller parts, for example,
> the following lines ...
>
>> + fp = fopen(git_path_bisect_log(), "a");
>> + if (!fp)
>> + return -1;
>> +
>> + if (fprintf(fp, "git bisect start") < 1) {
>> + retval = -1;
>> + goto finish;
>> + }
>> +
>> + sq_quote_argv(&orig_args, argv, 0);
>> + if (fprintf(fp, "%s", orig_args.buf) < 0) {
>> + retval = -1;
>> + goto finish;
>> + }
>> + if (fprintf(fp, "\n") < 1) {
>> + retval = -1;
>> + goto finish;
>> + }
>
> ... could be in a function like
>
> static int bisect_append_log(const char **argv)
> {
> 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) {
> retval = -1;
> goto finish;
> }
>
> sq_quote_argv(&orig_args, argv, 0);
> if (fprintf(fp, "%s", orig_args.buf) < 0 ||
> fprintf(fp, "\n") < 1) {
> retval = -1;
> goto finish;
> }
>
> finish:
> if (fp)
> fclose(fp);
> strbuf_release(&orig_args);
>
> return retval;
> }
>
> and then simply call
>
> retval = bisect_append_log(argv);
>
> in bisect_start()... (This is totally untested.)
I think this would be a better choice. Thanks!
> If you do not want that for some reason, you should at least fix
>
>> + if (!fp)
>> + return -1;
>
> to retval = 1; goto finish; such that the other lists and strings are
> released.
>
>> + goto finish;
>> +finish:
>
> The "goto finish" right above the "finish" label is unnecessary.
>
>> + if (fp)
>> + fclose(fp);
>> + string_list_clear(&revs, 0);
>> + string_list_clear(&states, 0);
>> + strbuf_release(&start_head);
>> + strbuf_release(&bisect_names);
>> + strbuf_release(&orig_args);
>> + return retval;
>> +}
>> +
>> int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
>> {
>> enum {
>
> By the way, there are two spaghetti-ish ways to get rid of the
>
> retval = -1;
> goto finish;
>
> line pair:
>
> goto fail;
>
> and below the "return retval;" add
>
> fail:
> retval = -1;
> goto finish;
>
> and you can feel the touch of His Noodly Appendage. *scnr*
Nice little trick.
> The other way is to keep the "goto finish" I deemed unnecessary (right
> above the label), and expand it to:
>
> goto finish;
> fail:
> retval = -1;
> finish:
> ...
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 07/27] bisect--helper: `bisect_reset` shell function in C
2016-10-14 14:14 ` [PATCH v15 07/27] bisect--helper: `bisect_reset` " Pranit Bauva
@ 2016-11-16 23:23 ` Stephan Beyer
2016-11-17 3:56 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2016-11-16 23:23 UTC (permalink / raw)
To: Pranit Bauva, git
Hi,
On 10/14/2016 04:14 PM, Pranit Bauva wrote:
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 4254d61..d84ba86 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -84,12 +89,47 @@ static int write_terms(const char *bad, const char *good)
> return (res < 0) ? -1 : 0;
> }
>
> +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");
I think this string should be marked for translation.
> + return 0;
> + }
> + strbuf_rtrim(&branch);
[...]
> @@ -121,6 +163,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> if (argc != 0)
> die(_("--bisect-clean-state requires no arguments"));
> return bisect_clean_state();
> + case BISECT_RESET:
> + if (argc > 1)
> + die(_("--bisect-reset requires either zero or one arguments"));
This error message is imho a little unspecific (but this might not be an
issue because bisect--helper commands are not really exposed to the
user). Maybe "--bisect-reset requires either no argument or a commit."?
> + return bisect_reset(argc ? argv[0] : NULL);
> default:
> die("BUG: unknown subcommand '%d'", cmdmode);
> }
~Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 08/27] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C
2016-10-14 14:14 ` [PATCH v15 08/27] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C Pranit Bauva
@ 2016-11-16 23:47 ` Stephan Beyer
2016-12-06 19:33 ` Pranit Bauva
2016-12-16 19:35 ` Pranit Bauva
0 siblings, 2 replies; 320+ messages in thread
From: Stephan Beyer @ 2016-11-16 23:47 UTC (permalink / raw)
To: Pranit Bauva, git
Hi,
On 10/14/2016 04:14 PM, Pranit Bauva wrote:
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index d84ba86..c542e8b 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -123,13 +123,40 @@ static int bisect_reset(const char *commit)
> return bisect_clean_state();
> }
>
> +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;
> +}
I am not sure it does what it should.
I would expect the following behavior from this function:
- file does not exist (or is "broken") => return 0
- actual_hex != expected_hex => return 0
- otherwise return 1
If I am not wrong, the code does the following instead:
- file does not exist (or is "broken") => return 0
- actual_hex != expected_hex => return 1
- otherwise => return 0
> +static int 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());
> + return 0;
> + }
> + }
> + return 0;
> +}
Here I am not sure what the function *should* do. However, I see that it
basically mimics the behavior of the shell function (assuming
is_expected_rev() is implemented correctly).
I don't understand why the return value is int and not void. To avoid a
"return 0;" line when calling this function?
> @@ -167,6 +196,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> if (argc > 1)
> die(_("--bisect-reset requires either zero or one arguments"));
> return bisect_reset(argc ? argv[0] : NULL);
> + case CHECK_EXPECTED_REVS:
> + return check_expected_revs(argv, argc);
I note that you check the correct number of arguments for some
subcommands and you do not check it for some other subcommands like this
one. (I don't care, I just want to mention it.)
> default:
> die("BUG: unknown subcommand '%d'", cmdmode);
> }
~Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 07/27] bisect--helper: `bisect_reset` shell function in C
2016-11-16 23:23 ` Stephan Beyer
@ 2016-11-17 3:56 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-11-17 3:56 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
On Thu, Nov 17, 2016 at 4:53 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
> Hi,
>
> On 10/14/2016 04:14 PM, Pranit Bauva wrote:
>> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
>> index 4254d61..d84ba86 100644
>> --- a/builtin/bisect--helper.c
>> +++ b/builtin/bisect--helper.c
>> @@ -84,12 +89,47 @@ static int write_terms(const char *bad, const char *good)
>> return (res < 0) ? -1 : 0;
>> }
>>
>> +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");
>
> I think this string should be marked for translation.
True. Thanks!
>> + return 0;
>> + }
>> + strbuf_rtrim(&branch);
> [...]
>> @@ -121,6 +163,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
>> if (argc != 0)
>> die(_("--bisect-clean-state requires no arguments"));
>> return bisect_clean_state();
>> + case BISECT_RESET:
>> + if (argc > 1)
>> + die(_("--bisect-reset requires either zero or one arguments"));
>
> This error message is imho a little unspecific (but this might not be an
> issue because bisect--helper commands are not really exposed to the
> user). Maybe "--bisect-reset requires either no argument or a commit."?
That sounds good.
>> + return bisect_reset(argc ? argv[0] : NULL);
>> default:
>> die("BUG: unknown subcommand '%d'", cmdmode);
>> }
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 09/27] bisect--helper: `bisect_write` shell function in C
2016-10-14 14:14 ` [PATCH v15 09/27] bisect--helper: `bisect_write` shell function in C Pranit Bauva
@ 2016-11-17 9:40 ` Stephan Beyer
2016-12-06 21:32 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2016-11-17 9:40 UTC (permalink / raw)
To: Pranit Bauva, git
Hi,
I've only got some minors to mention here ;)
On 10/14/2016 04:14 PM, Pranit Bauva wrote:
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index c542e8b..3f19b68 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -19,9 +19,15 @@ static const char * const git_bisect_helper_usage[] = {
> N_("git bisect--helper --write-terms <bad_term> <good_term>"),
> N_("git bisect--helper --bisect-clean-state"),
> N_("git bisect--helper --bisect-reset [<commit>]"),
> + N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
> NULL
> };
I wouldn't write "<TERM_GOOD <TERM_BAD>" in capital letters. I'd use
something like "<good_term> <bad_term>" as you have used for
--write-terms. Note that "git bisect --help" uses "<term-old>
<term-new>" in that context.
> @@ -149,6 +155,63 @@ static int check_expected_revs(const char **revs, int rev_nr)
> return 0;
> }
>
> +static int bisect_write(const char *state, const char *rev,
> + const struct bisect_terms *terms, int nolog)
> +{
> + struct strbuf tag = STRBUF_INIT;
> + struct strbuf commit_name = STRBUF_INIT;
> + struct object_id oid;
> + struct commit *commit;
> + struct pretty_print_context pp = {0};
> + FILE *fp = NULL;
> + int retval = 0;
> +
> + 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 {
> + error(_("Bad bisect_write argument: %s"), state);
> + retval = -1;
> + goto finish;
> + }
> +
> + if (get_oid(rev, &oid)) {
> + error(_("couldn't get the oid of the rev '%s'"), rev);
> + retval = -1;
> + goto finish;
> + }
> +
> + if (update_ref(NULL, tag.buf, oid.hash, NULL, 0,
> + UPDATE_REFS_MSG_ON_ERR)) {
> + retval = -1;
> + goto finish;
> + }
I'd like to mention that the "goto fail;" trick could apply in this
function, too.
> @@ -156,9 +219,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> WRITE_TERMS,
> BISECT_CLEAN_STATE,
> BISECT_RESET,
> - CHECK_EXPECTED_REVS
> + CHECK_EXPECTED_REVS,
> + BISECT_WRITE
> } cmdmode = 0;
> - int no_checkout = 0;
> + int no_checkout = 0, res = 0;
Why do you do this "direct return" -> "set res and return res" transition?
You don't need it in this patch, you do not need it in the subsequent
patches (you always set "res" exactly once after the initialization),
and you don't need cleanup code in this function.
> struct option options[] = {
> OPT_CMDMODE(0, "next-all", &cmdmode,
> N_("perform 'git bisect next'"), NEXT_ALL),
> @@ -170,10 +234,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> N_("reset the bisection state"), BISECT_RESET),
> OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
> N_("check for expected revs"), CHECK_EXPECTED_REVS),
> + OPT_CMDMODE(0, "bisect-write", &cmdmode,
> + N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
That info text is confusing, especially considering that there is a
"nolog" option. I think the action of bisect-write is two-fold: (1)
update the refs, (2) log.
> @@ -182,24 +249,37 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> usage_with_options(git_bisect_helper_usage, options);
>
> switch (cmdmode) {
> + int nolog;
> case NEXT_ALL:
> return bisect_next_all(prefix, no_checkout);
> case WRITE_TERMS:
> if (argc != 2)
> die(_("--write-terms requires two arguments"));
> - return write_terms(argv[0], argv[1]);
> + res = write_terms(argv[0], argv[1]);
> + break;
As indicated above, I think the direct "return ...;" is cleaner.
~Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 10/27] bisect--helper: `check_and_set_terms` shell function in C
2016-10-14 14:14 ` [PATCH v15 10/27] bisect--helper: `check_and_set_terms` " Pranit Bauva
@ 2016-11-17 20:25 ` Stephan Beyer
2016-12-06 22:43 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2016-11-17 20:25 UTC (permalink / raw)
To: Pranit Bauva, git
Hi Pranit,
On 10/14/2016 04:14 PM, Pranit Bauva wrote:
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 3f19b68..c6c11e3 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -20,6 +20,7 @@ static const char * const git_bisect_helper_usage[] = {
> N_("git bisect--helper --bisect-clean-state"),
> N_("git bisect--helper --bisect-reset [<commit>]"),
> N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
> + N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
Here's the same as in the previous patch... I'd not use
TERM_GOOD/TERM_BAD in capitals.
> NULL
> };
>
> @@ -212,6 +213,38 @@ static int bisect_write(const char *state, const char *rev,
> return retval;
> }
>
> +static int set_terms(struct bisect_terms *terms, const char *bad,
> + const char *good)
> +{
> + terms->term_good = xstrdup(good);
> + terms->term_bad = xstrdup(bad);
> + return write_terms(terms->term_bad, terms->term_good);
At this stage of the patch series I am wondering why you are setting
"terms" here, but I guess you'll need it later.
However, you are leaking memory here. Something like
free(terms->term_good);
free(terms->term_bad);
terms->term_good = xstrdup(good);
terms->term_bad = xstrdup(bad);
should be safe (because you've always used xstrdup() for the terms
members before). Or am I overseeing something?
> @@ -278,6 +314,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> terms.term_bad = xstrdup(argv[3]);
> res = bisect_write(argv[0], argv[1], &terms, nolog);
> break;
> + case CHECK_AND_SET_TERMS:
> + if (argc != 3)
> + die(_("--check-and-set-terms requires 3 arguments"));
> + terms.term_good = xstrdup(argv[1]);
> + terms.term_bad = xstrdup(argv[2]);
> + res = check_and_set_terms(&terms, argv[0]);
> + break;
Ha! When I reviewed the last patch, I asked you why you changed the code
from returning directly from each subcommand to setting res; break; and
then return res at the bottom of the function.
Now I see why this was useful. The two members of "terms" are again
leaking memory: you are allocating memory by using xstrdup() but you are
not freeing it.
(That also applies to the last patch.)
Cheers,
Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 11/27] bisect--helper: `bisect_next_check` & bisect_voc shell function in C
2016-10-14 14:14 ` [PATCH v15 11/27] bisect--helper: `bisect_next_check` & bisect_voc " Pranit Bauva
@ 2016-11-17 20:59 ` Stephan Beyer
2016-12-06 18:39 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2016-11-17 20:59 UTC (permalink / raw)
To: Pranit Bauva, git
Hi Pranit,
On 10/14/2016 04:14 PM, Pranit Bauva wrote:
> Also reimplement `bisect_voc` shell function in C and call it from
> `bisect_next_check` implementation in C.
Please don't! ;D
> +static char *bisect_voc(char *revision_type)
> +{
> + if (!strcmp(revision_type, "bad"))
> + return "bad|new";
> + if (!strcmp(revision_type, "good"))
> + return "good|old";
> +
> + return NULL;
> +}
Why not simply use something like this:
static const char *voc[] = {
"bad|new",
"good|old",
};
Then...
> +static int bisect_next_check(const struct bisect_terms *terms,
> + const char *current_term)
> +{
> + int missing_good = 1, missing_bad = 1, retval = 0;
> + char *bad_ref = xstrfmt("refs/bisect/%s", terms->term_bad);
> + char *good_glob = xstrfmt("%s-*", terms->term_good);
> + char *bad_syn, *good_syn;
...you don't need bad_syn and good_syn...
> + bad_syn = xstrdup(bisect_voc("bad"));
> + good_syn = xstrdup(bisect_voc("good"));
...and hence not these two lines...
> + if (!is_empty_or_missing_file(git_path_bisect_start())) {
> + error(_("You need to give me at least one %s and "
> + "%s revision. You can use \"git bisect %s\" "
> + "and \"git bisect %s\" for that. \n"),
> + bad_syn, good_syn, bad_syn, good_syn);
...and write
voc[0], voc[1], voc[0], voc[1]);
instead...
> + retval = -1;
> + goto finish;
> + }
> + else {
> + error(_("You need to start by \"git bisect start\". You "
> + "then need to give me at least one %s and %s "
> + "revision. You can use \"git bisect %s\" and "
> + "\"git bisect %s\" for that.\n"),
> + good_syn, bad_syn, bad_syn, good_syn);
...and here
voc[1], voc[0], voc[0], voc[1]);
...
> + retval = -1;
> + goto finish;
> + }
> + goto finish;
> +finish:
> + if (!bad_ref)
> + free(bad_ref);
> + if (!good_glob)
> + free(good_glob);
> + if (!bad_syn)
> + free(bad_syn);
> + if (!good_syn)
> + free(good_syn);
...and you can remove the 4 lines above.
> + return retval;
> +}
Besides that, there are again some things that I've already mentioned
and that can be applied here, too, for example, not capitalizing
TERM_GOOD and TERM_BAD, the goto fail simplification, the terms memory leak.
Cheers
Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 12/27] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-10-14 14:14 ` [PATCH v15 12/27] bisect--helper: `get_terms` & `bisect_terms` shell function in C Pranit Bauva
@ 2016-11-17 21:32 ` Stephan Beyer
2016-12-06 21:14 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2016-11-17 21:32 UTC (permalink / raw)
To: Pranit Bauva, git
Hi,
On 10/14/2016 04:14 PM, Pranit Bauva wrote:
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 317d671..6a5878c 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
[...]
> +static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
> +{
> + int i;
> + const char bisect_term_usage[] =
> +"git bisect--helper --bisect-terms [--term-good | --term-bad | ]"
> +"--term-old | --term-new";
Three things:
(1) Is that indentation intentional?
(2) You have a "]" at the end of the first part of the string instead of
the end of the second part.
(3) After the correction, bisect_term_usage and
git_bisect_helper_usage[7] are the same strings. I don't recommend to
use git_bisect_helper_usage[7] instead because keeping the index
up-to-date is a maintenance hell. (At the end of your patch series it is
a 3 instead of a 7.) However, if - for whatever reason - the usage of
bisect--helper --bisect-terms changes, you always have to sync the two
strings which is also nasty....
> +
> + if (get_terms(terms))
> + return error(_("no terms defined"));
> +
> + if (argc > 1) {
> + usage(bisect_term_usage);
> + return -1;
> + }
...and since you only use it once, why not simply do something like
return error(_("--bisect-term requires exactly one argument"));
and drop the definition of bisect_term_usage.
> +
> + if (argc == 0) {
> + printf(_("Your current terms are %s for the old state\nand "
> + "%s for the new state.\n"), terms->term_good,
> + terms->term_bad);
Very minor: It improves the readability if you'd split the string after
the \n and put the "and "in the next line.
> + return 0;
> + }
> +
> + for (i = 0; i < argc; i++) {
> + if (!strcmp(argv[i], "--term-good"))
> + printf("%s\n", terms->term_good);
> + else if (!strcmp(argv[i], "--term-bad"))
> + printf("%s\n", terms->term_bad);
> + else
> + die(_("invalid argument %s for 'git bisect "
> + "terms'.\nSupported options are: "
> + "--term-good|--term-old and "
> + "--term-bad|--term-new."), argv[i]);
Hm, "return error(...)" and "die(...)" seems to be quasi-equivalent in
this case. Because I am always looking from a library perspective, I'd
prefer "return error(...)".
> @@ -429,6 +492,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> terms.term_bad = xstrdup(argv[1]);
> res = bisect_next_check(&terms, argc == 3 ? argv[2] : NULL);
> break;
> + case BISECT_TERMS:
> + if (argc > 1)
> + die(_("--bisect-terms requires 0 or 1 argument"));
> + res = bisect_terms(&terms, argv, argc);
> + break;
Also here: "terms" is leaking...
~Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 22/27] bisect--helper: `bisect_log` shell function in C
2016-10-14 14:14 ` [PATCH v15 22/27] bisect--helper: `bisect_log` " Pranit Bauva
@ 2016-11-17 21:47 ` Stephan Beyer
2016-12-06 22:42 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2016-11-17 21:47 UTC (permalink / raw)
To: Pranit Bauva, git
Hi,
On 10/14/2016 04:14 PM, Pranit Bauva wrote:
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 493034c..c18ca07 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -858,6 +858,23 @@ static int bisect_state(struct bisect_terms *terms, const char **argv,
> return -1;
> }
>
> +static int bisect_log(void)
> +{
> + int fd, status;
> + fd = open(git_path_bisect_log(), O_RDONLY);
> + if (fd < 0)
> + return -1;
> +
> + status = copy_fd(fd, 1);
Perhaps
status = copy_fd(fd, STDOUT_FILENO);
> + if (status) {
> + close(fd);
> + return -1;
> + }
> +
> + close(fd);
> + return status;
> +}
That's weird.
Either get rid of the if() and actually use status:
status = copy_fd(fd, STDOUT_FILENO);
close(fd);
return status ? -1 : 0;
or get rid of status and use the if:
if (copy_fd(fd, STDOUT_FILENO)) {
close(fd);
return -1;
}
close(fd);
return 0;
I'd recommend the shorter variant ;)
~Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 13/27] bisect--helper: `bisect_start` shell function partially in C
2016-10-14 14:14 ` [PATCH v15 13/27] bisect--helper: `bisect_start` shell function partially in C Pranit Bauva
2016-11-15 23:19 ` Stephan Beyer
@ 2016-11-20 20:01 ` Stephan Beyer
2016-11-20 20:19 ` Stephan Beyer
1 sibling, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2016-11-20 20:01 UTC (permalink / raw)
To: Pranit Bauva, git
Hi,
On 10/14/2016 04:14 PM, Pranit Bauva wrote:
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 6a5878c..1d3e17f 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -403,6 +408,205 @@ static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
> return 0;
> }
>
> +static int bisect_start(struct bisect_terms *terms, int no_checkout,
> + const char **argv, int argc)
> +{
> + int i, has_double_dash = 0, must_write_terms = 0, bad_seen = 0;
> + int flags, pathspec_pos, retval = 0;
> + 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 strbuf orig_args = STRBUF_INIT;
> + const char *head;
> + unsigned char sha1[20];
> + FILE *fp = NULL;
> + struct object_id oid;
> +
> + if (is_bare_repository())
> + no_checkout = 1;
> +
> + for (i = 0; i < argc; i++) {
> + if (!strcmp(argv[i], "--")) {
> + has_double_dash = 1;
> + break;
> + }
> + }
> +
> + for (i = 0; i < argc; i++) {
> + const char *commit_id = xstrfmt("%s^{commit}", argv[i]);
> + const char *arg = argv[i];
> + if (!strcmp(argv[i], "--")) {
> + has_double_dash = 1;
> + break;
> + } else if (!strcmp(arg, "--no-checkout")) {
> + no_checkout = 1;
> + } else if (!strcmp(arg, "--term-good") ||
> + !strcmp(arg, "--term-old")) {
> + must_write_terms = 1;
> + terms->term_good = xstrdup(argv[++i]);
All these xstrdup() for the terms here and below will leak memory.
I recommend to use xstrdup() also at (*) below, and use
free(terms->term_good) above this line (and for every occurrence below,
of course).
> + } else if (skip_prefix(arg, "--term-good=", &arg)) {
> + must_write_terms = 1;
> + terms->term_good = xstrdup(arg);
[...]
> @@ -497,6 +705,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> die(_("--bisect-terms requires 0 or 1 argument"));
> res = bisect_terms(&terms, argv, argc);
> break;
> + case BISECT_START:
> + terms.term_good = "good";
> + terms.term_bad = "bad";
Here is (*): use xstrdup("good") etc.
And then, as already mentioned for another patch, free(terms.*) below.
I personally am a friend of small functions and would prefer something
like as follows... (This is a comment about several patches of your
series, not only this one.)
First, replace the current set_terms() by
static void set_terms(struct bisect_terms *terms, const char *bad,
const char *good)
{
terms->term_good = xstrdup(good);
terms->term_bad = xstrdup(bad);
}
ie, without calling write_terms(...).
And then replace the *current* set_terms() calls by set_terms(...);
write_terms(...); calls.
Second, add
static void get_default_terms(struct bisect_terms *terms)
{
set_terms(terms, "bad", "good");
}
and use this instead of the two lines quoted above (and all its other
occurrences).
Third, use the new set_terms() everywhere instead of settings terms
members directly (with the exception of get_terms()).
This sounds like a safer variant (with respect to leaks and handling
them) to me than doing it the current way.
~Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 15/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function in C
2016-10-14 14:14 ` [PATCH v15 15/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function " Pranit Bauva
@ 2016-11-20 20:01 ` Stephan Beyer
2016-12-31 10:23 ` Pranit Bauva
2016-11-21 21:35 ` Stephan Beyer
1 sibling, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2016-11-20 20:01 UTC (permalink / raw)
To: Pranit Bauva, git
Hi Pranit,
this one is hard to review because you do two or three commits in one here.
I think the first commit should be the exit()->return conversion, the
second commit is next and autonext, and the third commit is the pretty
trivial bisect_start commit ;) However, you did it this way and it's
always a hassle to split commit, so I don't really care...
However, I was reviewing this superficially, to be honest. This mail
skips the next and autonext part.
On 10/14/2016 04:14 PM, Pranit Bauva wrote:
> diff --git a/bisect.c b/bisect.c
> index 45d598d..7c97e85 100644
> --- a/bisect.c
> +++ b/bisect.c
> @@ -843,16 +878,21 @@ static int check_ancestors(const char *prefix)
> *
> * If that's not the case, we need to check the merge bases.
> * If a merge base must be tested by the user, its source code will be
> - * checked out to be tested by the user and we will exit.
> + * checked out to be tested by the user and we will return.
> */
> -static void check_good_are_ancestors_of_bad(const char *prefix, int no_checkout)
> +static int check_good_are_ancestors_of_bad(const char *prefix, int no_checkout)
> {
> char *filename = git_pathdup("BISECT_ANCESTORS_OK");
> struct stat st;
> - int fd;
> + int fd, res = 0;
>
> + /*
> + * We don't want to clean the bisection state
> + * as we need to get back to where we started
> + * by using `git bisect reset`.
> + */
> if (!current_bad_oid)
> - die(_("a %s revision is needed"), term_bad);
> + error(_("a %s revision is needed"), term_bad);
Only error() or return error()?
> @@ -873,8 +916,11 @@ static void check_good_are_ancestors_of_bad(const char *prefix, int no_checkout)
> filename);
> else
> close(fd);
> +
> + goto done;
> done:
I never understand why you do this. In case of adding a "fail" label
(and fail code like "res = -1;") between "goto done" and "done:", it's
fine... but without one this is just a nop.
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 1d3e17f..fcd7574 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -427,15 +560,24 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
> no_checkout = 1;
>
> for (i = 0; i < argc; i++) {
> - if (!strcmp(argv[i], "--")) {
> + const char *arg;
> + if (starts_with(argv[i], "'"))
> + arg = sq_dequote(xstrdup(argv[i]));
> + else
> + arg = argv[i];
One is xstrdup'ed, one is not, so there'll be a leak somewhere, and it's
an inconsistent leak... I guess it's a bad idea to do it this way ;)
(Also below.)
> @@ -443,24 +585,31 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
> no_checkout = 1;
> } else if (!strcmp(arg, "--term-good") ||
> !strcmp(arg, "--term-old")) {
> + if (starts_with(argv[++i], "'"))
> + terms->term_good = sq_dequote(xstrdup(argv[i]));
> + else
> + terms->term_good = xstrdup(argv[i]);
> must_write_terms = 1;
> - terms->term_good = xstrdup(argv[++i]);
> } else if (skip_prefix(arg, "--term-good=", &arg)) {
> must_write_terms = 1;
> - terms->term_good = xstrdup(arg);
> + terms->term_good = arg;
No ;) (See my other comments (to other patches) for the "terms" leaks.)
[This repeats several times below.]
> diff --git a/git-bisect.sh b/git-bisect.sh
> index f0896b3..d574c44 100755
> --- a/git-bisect.sh
> +++ b/git-bisect.sh
> @@ -109,6 +88,7 @@ bisect_skip() {
> bisect_state() {
> bisect_autostart
> state=$1
> + get_terms
> git bisect--helper --check-and-set-terms $state $TERM_GOOD $TERM_BAD || exit
> get_terms
> case "$#,$state" in
I can't say if this change is right or wrong. It looks right, but: How
does this relate to the other changes? Is this the right patch for it?
~Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 18/27] bisect--helper: `bisect_autostart` shell function in C
2016-10-14 14:14 ` [PATCH v15 18/27] bisect--helper: `bisect_autostart` shell function in C Pranit Bauva
@ 2016-11-20 20:15 ` Stephan Beyer
2016-12-06 19:47 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2016-11-20 20:15 UTC (permalink / raw)
To: Pranit Bauva, git
Hi,
On 10/14/2016 04:14 PM, Pranit Bauva wrote:
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 502bf18..1767916 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -422,6 +425,7 @@ static int bisect_next(...)
> {
> int res, no_checkout;
>
> + bisect_autostart(terms);
You are not checking for return values here. (The shell code simply
exited if there is no tty, but you don't.)
> @@ -754,6 +758,32 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
> return retval || bisect_auto_next(terms, NULL);
> }
>
> +static int bisect_autostart(struct bisect_terms *terms)
> +{
> + if (is_empty_or_missing_file(git_path_bisect_start())) {
> + const char *yesno;
> + const char *argv[] = {NULL};
> + fprintf(stderr, _("You need to start by \"git bisect "
> + "start\"\n"));
> +
> + if (!isatty(0))
isatty(STDIN_FILENO)?
> + return 1;
> +
> + /*
> + * TRANSLATORS: Make sure to include [Y] and [n] in your
> + * translation. THe program will only accept English input
Typo "THe"
> + * at this point.
> + */
Taking "at this point" into consideration, I think the Y and n can be
easily translated now that it is in C. I guess, by using...
> + yesno = git_prompt(_("Do you want me to do it for you "
> + "[Y/n]? "), PROMPT_ECHO);
> + if (starts_with(yesno, "n") || starts_with(yesno, "N"))
... starts_with(yesno, _("n")) || starts_with(yesno, _("N"))
here (but not sure). However, this would be an extra patch on top of
this series.
> + exit(0);
Shouldn't this also be "return 1;"? Saying "no" is the same outcome as
not having a tty to ask for yes or no.
> int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> {
> enum {
> @@ -790,6 +821,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> N_("find the next bisection commit"), BISECT_NEXT),
> OPT_CMDMODE(0, "bisect-auto-next", &cmdmode,
> N_("verify the next bisection state then find the next bisection state"), BISECT_AUTO_NEXT),
> + OPT_CMDMODE(0, "bisect-autostart", &cmdmode,
> + N_("start the bisection if BISECT_START empty or missing"), BISECT_AUTOSTART),
The word "is" is missing.
~Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 13/27] bisect--helper: `bisect_start` shell function partially in C
2016-11-20 20:01 ` Stephan Beyer
@ 2016-11-20 20:19 ` Stephan Beyer
0 siblings, 0 replies; 320+ messages in thread
From: Stephan Beyer @ 2016-11-20 20:19 UTC (permalink / raw)
To: Pranit Bauva, git
On 11/20/2016 09:01 PM, Stephan Beyer wrote:
> First, replace the current set_terms() by
>
> static void set_terms(struct bisect_terms *terms, const char *bad,
> const char *good)
> {
> terms->term_good = xstrdup(good);
> terms->term_bad = xstrdup(bad);
> }
>
> ie, without calling write_terms(...).
I did not want to confuse you here but I forgot to mention that there
should also be freeing code, i.e. initialize your terms to NULL in the
beginning of cmd_builtin__helper, and always free them if it is not
null. This freeing code could also be in an extra function free_terms()
and you call it in set_terms() and for cleanup in the end.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 15/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function in C
2016-10-14 14:14 ` [PATCH v15 15/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function " Pranit Bauva
2016-11-20 20:01 ` Stephan Beyer
@ 2016-11-21 21:35 ` Stephan Beyer
2016-12-31 10:43 ` Pranit Bauva
1 sibling, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2016-11-21 21:35 UTC (permalink / raw)
To: Pranit Bauva, git
Hi Pranit,
in this mail I review the "second part" of your patch: the transition of
bisect_next and bisect_auto_next to C.
On 10/14/2016 04:14 PM, Pranit Bauva wrote:
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 1d3e17f..fcd7574 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -408,6 +411,136 @@ static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
> return 0;
> }
>
> +static int register_good_ref(const char *refname,
> + const struct object_id *oid, int flags,
> + void *cb_data)
> +{
> + struct string_list *good_refs = cb_data;
> + string_list_append(good_refs, oid_to_hex(oid));
> + return 0;
> +}
> +
> +static int bisect_next(struct bisect_terms *terms, const char *prefix)
> +{
> + int res, no_checkout;
> +
> + /*
> + * 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".
> + */
The comment above makes no sense here, or does it?
> + if (bisect_next_check(terms, terms->term_good))
> + return -1;
> +
> + no_checkout = !is_empty_or_missing_file(git_path_bisect_head());
> +
> + /* Perform all bisection computation, display and checkout */
> + res = bisect_next_all(prefix , no_checkout);
Style: there is a space left of the comma.
> +
> + if (res == 10) {
> + FILE *fp = NULL;
> + unsigned char sha1[20];
> + struct commit *commit;
> + struct pretty_print_context pp = {0};
> + struct strbuf commit_name = STRBUF_INIT;
> + char *bad_ref = xstrfmt("refs/bisect/%s",
> + terms->term_bad);
> + int retval = 0;
> +
> + read_ref(bad_ref, sha1);
> + commit = lookup_commit_reference(sha1);
> + format_commit_message(commit, "%s", &commit_name, &pp);
> + fp = fopen(git_path_bisect_log(), "a");
> + if (!fp) {
> + retval = -1;
> + goto finish_10;
> + }
> + if (fprintf(fp, "# first %s commit: [%s] %s\n",
> + terms->term_bad, sha1_to_hex(sha1),
> + commit_name.buf) < 1){
> + retval = -1;
> + goto finish_10;
> + }
> + goto finish_10;
> + finish_10:
> + if (fp)
> + fclose(fp);
> + strbuf_release(&commit_name);
> + free(bad_ref);
> + return retval;
> + }
> + else if (res == 2) {
> + FILE *fp = NULL;
> + struct rev_info revs;
> + struct argv_array rev_argv = ARGV_ARRAY_INIT;
> + struct string_list good_revs = STRING_LIST_INIT_DUP;
> + struct pretty_print_context pp = {0};
> + struct commit *commit;
> + char *term_good = xstrfmt("%s-*", terms->term_good);
> + int i, retval = 0;
> +
> + fp = fopen(git_path_bisect_log(), "a");
> + if (!fp) {
> + retval = -1;
> + goto finish_2;
> + }
> + if (fprintf(fp, "# only skipped commits left to test\n") < 1) {
> + retval = -1;
> + goto finish_2;
> + }
> + for_each_glob_ref_in(register_good_ref, term_good,
> + "refs/bisect/", (void *) &good_revs);
> +
> + argv_array_pushl(&rev_argv, "skipped_commits", "refs/bisect/bad", "--not", NULL);
> + for (i = 0; i < good_revs.nr; i++)
> + argv_array_push(&rev_argv, good_revs.items[i].string);
> +
> + /* It is important to reset the flags used by revision walks
> + * as the previous call to bisect_next_all() in turn
> + * setups a revision walk.
> + */
> + reset_revision_walk();
> + init_revisions(&revs, NULL);
> + rev_argv.argc = setup_revisions(rev_argv.argc, rev_argv.argv, &revs, NULL);
> + argv_array_clear(&rev_argv);
> + string_list_clear(&good_revs, 0);
> + if (prepare_revision_walk(&revs))
> + die(_("revision walk setup failed\n"));
> +
> + while ((commit = get_revision(&revs)) != NULL) {
> + struct strbuf commit_name = STRBUF_INIT;
> + format_commit_message(commit, "%s",
> + &commit_name, &pp);
> + fprintf(fp, "# possible first %s commit: "
> + "[%s] %s\n", terms->term_bad,
> + oid_to_hex(&commit->object.oid),
> + commit_name.buf);
> + strbuf_release(&commit_name);
> + }
> + goto finish_2;
> + finish_2:
> + if (fp)
> + fclose(fp);
> + string_list_clear(&good_revs, 0);
> + argv_array_clear(&rev_argv);
> + free(term_good);
> + if (retval)
> + return retval;
> + else
> + return res;
> + }
> + return res;
> +}
It would be much nicer if you put the (res == 10) branch and the
(res == 2) branch into separate functions and just call them.
Then you also won't need ugly label naming like finish_10 or finish_2.
I'd also (again) recommend to use goto fail instead of setting retval to
-1 separately each time.
I'd also recommend to use a separate function to append to the bisect
log file. There is a lot of duplicated opening, checking, closing code;
IIRC such a function would also already be handy for some of the
previous patches.
> +
> +static int bisect_auto_next(struct bisect_terms *terms, const char *prefix)
> +{
> + if (!bisect_next_check(terms, NULL))
> + return bisect_next(terms, prefix);
> +
> + return 0;
> +}
Hmm, the handling of the return values is a little confusing. However,
if I understand the sh source correctly, it always returns success, no
matter if bisect_next failed or not. I do not know if you had something
special in mind here.
> int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> @@ -643,6 +794,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> N_("print out the bisect terms"), BISECT_TERMS),
> OPT_CMDMODE(0, "bisect-start", &cmdmode,
> N_("start the bisect session"), BISECT_START),
> + OPT_CMDMODE(0, "bisect-next", &cmdmode,
> + N_("find the next bisection commit"), BISECT_NEXT),
> + OPT_CMDMODE(0, "bisect-auto-next", &cmdmode,
> + N_("verify the next bisection state then find the next bisection state"), BISECT_AUTO_NEXT),
The next bisection *state* is found?
> diff --git a/git-bisect.sh b/git-bisect.sh
> index f0896b3..d574c44 100755
> --- a/git-bisect.sh
> +++ b/git-bisect.sh
> @@ -139,45 +119,7 @@ bisect_state() {
> *)
> usage ;;
> esac
> - bisect_auto_next
[...deleted lines...]
> + git bisect--helper --bisect-auto-next || exit
Why is the "|| exit" necessary?
> @@ -319,14 +260,15 @@ case "$#" in
> help)
> git bisect -h ;;
> start)
> - bisect_start "$@" ;;
> + git bisect--helper --bisect-start "$@" ;;
> bad|good|new|old|"$TERM_BAD"|"$TERM_GOOD")
> bisect_state "$cmd" "$@" ;;
> skip)
> bisect_skip "$@" ;;
> next)
> # Not sure we want "next" at the UI level anymore.
> - bisect_next "$@" ;;
> + get_terms
> + git bisect--helper --bisect-next "$@" || exit ;;
Why is the "|| exit" necessary? ;)
Furthermore:
Where is the bisect_autostart call from bisect_next() sh source gone?
Was it not necessary?
~Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 19/27] bisect--helper: `bisect_state` & `bisect_head` shell function in C
2016-10-14 14:14 ` [PATCH v15 19/27] bisect--helper: `bisect_state` & `bisect_head` " Pranit Bauva
@ 2016-11-22 0:12 ` Stephan Beyer
2016-12-06 22:40 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2016-11-22 0:12 UTC (permalink / raw)
To: Pranit Bauva, git
Hi,
On 10/14/2016 04:14 PM, Pranit Bauva wrote:
> Reimplement the `bisect_state` shell function in C and also add a
> subcommand `--bisect-state` to `git-bisect--helper` to call it from
> git-bisect.sh .
>
> Using `--bisect-state` subcommand is a temporary measure to port shell
> function to C so as to use the existing test suite. As more functions
> are ported, this subcommand will be retired and will be called by some
> other methods.
>
> `bisect_head` is called from `bisect_state` thus its not required to
> introduce another subcommand.
Missing comma before "thus", and "it is" (or "it's") instead of "its" :)
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 1767916..1481c6d 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -784,6 +786,79 @@ static int bisect_autostart(struct bisect_terms *terms)
> return 0;
> }
>
> +static char *bisect_head(void)
> +{
> + if (is_empty_or_missing_file(git_path_bisect_head()))
> + return "HEAD";
> + else
> + return "BISECT_HEAD";
> +}
This is very shellish.
In C I'd expect something like
static int bisect_head_sha1(unsigned char *sha)
{
int res;
if (is_empty_or_missing_file(git_path_bisect_head()))
res = get_sha1("HEAD", sha);
else
res = get_sha1("BISECT_HEAD", sha);
if (res)
return error(_("Could not find BISECT_HEAD or HEAD."));
return 0;
}
> +
> +static int bisect_state(struct bisect_terms *terms, const char **argv,
> + int argc)
> +{
> + const char *state = argv[0];
> +
> + get_terms(terms);
> + if (check_and_set_terms(terms, state))
> + return -1;
> +
> + if (!argc)
> + die(_("Please call `--bisect-state` with at least one argument"));
I think this check should move to cmd_bisect__helper. There are also the
other argument number checks.
> +
> + if (argc == 1 && one_of(state, terms->term_good,
> + terms->term_bad, "skip", NULL)) {
> + const char *bisected_head = xstrdup(bisect_head());
> + const char *hex[1];
Maybe:
const char *hex;
> + unsigned char sha1[20];
> +
> + if (get_sha1(bisected_head, sha1))
> + die(_("Bad rev input: %s"), bisected_head);
And instead of...
> + if (bisect_write(state, sha1_to_hex(sha1), terms, 0))
> + return -1;
> +
> + *hex = xstrdup(sha1_to_hex(sha1));
> + if (check_expected_revs(hex, 1))
> + return -1;
... simply:
hex = xstrdup(sha1_to_hex(sha1));
if (set_state(terms, state, hex)) {
free(hex);
return -1;
}
free(hex);
where:
static int set_state(struct bisect_terms *terms, const char *state,
const char *hex)
{
if (bisect_write(state, hex, terms, 0))
return -1;
if (check_expected_revs(&hex, 1))
return -1;
return 0;
}
> + return bisect_auto_next(terms, NULL);
> + }
> +
> + if ((argc == 2 && !strcmp(state, terms->term_bad)) ||
> + one_of(state, terms->term_good, "skip", NULL)) {
> + int i;
> + struct string_list hex = STRING_LIST_INIT_DUP;
> +
> + for (i = 1; i < argc; i++) {
> + unsigned char sha1[20];
> +
> + if (get_sha1(argv[i], sha1)) {
> + string_list_clear(&hex, 0);
> + die(_("Bad rev input: %s"), argv[i]);
> + }
> + string_list_append(&hex, sha1_to_hex(sha1));
> + }
> + for (i = 0; i < hex.nr; i++) {
... And replace this:
> + const char **hex_string = (const char **) &hex.items[i].string;
> + if(bisect_write(state, *hex_string, terms, 0)) {
> + string_list_clear(&hex, 0);
> + return -1;
> + }
> + if (check_expected_revs(hex_string, 1)) {
> + string_list_clear(&hex, 0);
> + return -1;
> + }
by:
const char *hex_str = hex.items[i].string;
if (set_state(terms, state, hex_string)) {
string_list_clear(&hex, 0);
return -1;
}
> + }
> + string_list_clear(&hex, 0);
> + return bisect_auto_next(terms, NULL);
> + }
> +
> + if (!strcmp(state, terms->term_bad))
> + die(_("'git bisect %s' can take only one argument."),
> + terms->term_bad);
> +
> + return -1;
> +}
> +
> int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> {
> enum {
> @@ -823,6 +899,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> N_("verify the next bisection state then find the next bisection state"), BISECT_AUTO_NEXT),
> OPT_CMDMODE(0, "bisect-autostart", &cmdmode,
> N_("start the bisection if BISECT_START empty or missing"), BISECT_AUTOSTART),
> + OPT_CMDMODE(0, "bisect-state", &cmdmode,
> + N_("mark the state of ref (or refs)"), BISECT_STATE),
"mark the state of the given revs"
Note that rev != ref
> @@ -902,6 +980,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> terms.term_bad = "bad";
> res = bisect_autostart(&terms);
> break;
> + case BISECT_STATE:
> + if (argc == 0)
> + die(_("--bisect-state requires at least 1 argument"));
"at least one revision"
> diff --git a/git-bisect.sh b/git-bisect.sh
> index cd56551..a9eebbb 100755
> --- a/git-bisect.sh
> +++ b/git-bisect.sh
> @@ -61,44 +51,7 @@ bisect_skip() {
> esac
> all="$all $revs"
> done
> - eval bisect_state 'skip' $all
[...deleted lines...]
> + eval git bisect--helper --bisect-state 'skip' $all
I think you don't need "eval" here any longer.
> @@ -184,8 +137,8 @@ exit code \$res from '\$command' is < 0 or >= 128" >&2
> state="$TERM_GOOD"
> fi
>
> - # We have to use a subshell because "bisect_state" can exit.
> - ( bisect_state $state >"$GIT_DIR/BISECT_RUN" )
> + # We have to use a subshell because "--bisect-state" can exit.
> + ( git bisect--helper --bisect-state $state >"$GIT_DIR/BISECT_RUN" )
The new comment is funny, but you don't need a subshell here any longer.
~Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 23/27] bisect--helper: `bisect_replay` shell function in C
2016-10-14 14:14 ` [PATCH v15 23/27] bisect--helper: `bisect_replay` shell function in C Pranit Bauva
@ 2016-11-22 0:49 ` Stephan Beyer
2016-12-06 23:02 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2016-11-22 0:49 UTC (permalink / raw)
To: Pranit Bauva, git
Okay Pranit,
this is the last patch for me to review in this series.
Now that I have a coarse overview of what you did, I have the general
remark that imho the "terms" variable should simply be global instead of
being passed around all the time.
I also had some other remarks but I forgot them... maybe they come to my
mind again when I see patch series v16.
I also want to remark again that I am not a Git developer and only
reviewed this because of my interest in git-bisect. So some of my
suggestions might conflict with other beliefs here. For example, I
consider it very bad style to leak memory... but Git is rather written
as a scripting tool than a genuine library, so perhaps many people here
do not care about it as long as it works...
On 10/14/2016 04:14 PM, Pranit Bauva wrote:
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index c18ca07..b367d8d 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -601,7 +602,6 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
> terms->term_good = arg;
> } else if (!strcmp(arg, "--term-bad") ||
> !strcmp(arg, "--term-new")) {
> - const char *next_arg;
This should already have been removed in patch 15/27, not here.
> @@ -875,6 +875,117 @@ static int bisect_log(void)
> return status;
> }
>
> +static int get_next_word(const char *line, int pos, struct strbuf *word)
> +{
> + int i, len = strlen(line), begin = 0;
> + strbuf_reset(word);
> + for (i = pos; i < len; i++) {
> + if (line[i] == ' ' && begin)
> + return i + 1;
> +
> + if (!begin)
> + begin = 1;
> + strbuf_addch(word, line[i]);
> + }
> +
> + return i;
> +}
> +
> +static int bisect_replay(struct bisect_terms *terms, const char *filename)
> +{
> + struct strbuf line = STRBUF_INIT;
> + struct strbuf word = STRBUF_INIT;
> + FILE *fp = NULL;
(The initialization is not necessary here.)
> + int res = 0;
> +
> + if (is_empty_or_missing_file(filename)) {
> + error(_("no such file with name '%s' exists"), filename);
The error message is misleading if the file exists but is empty.
Maybe something like "cannot read file '%s' for replaying"?
> + res = -1;
> + goto finish;
goto fail;
:D
> + }
> +
> + if (bisect_reset(NULL)) {
> + res = -1;
> + goto finish;
goto fail;
> + }
> +
> + fp = fopen(filename, "r");
> + if (!fp) {
> + res = -1;
> + goto finish;
goto fail;
> + }
> +
> + while (strbuf_getline(&line, fp) != EOF) {
> + int pos = 0;
> + while (pos < line.len) {
> + pos = get_next_word(line.buf, pos, &word);
> +
> + if (!strcmp(word.buf, "git")) {
> + continue;
> + } else if (!strcmp(word.buf, "git-bisect")) {
> + continue;
> + } else if (!strcmp(word.buf, "bisect")) {
> + continue;
> + } else if (!strcmp(word.buf, "#")) {
> + break;
Maybe it is more robust to check whether word.buf begins with #
> + }
> +
> + get_terms(terms);
> + if (check_and_set_terms(terms, word.buf)) {
> + res = -1;
> + goto finish;
goto fail;
> + }
> +
> + if (!strcmp(word.buf, "start")) {
> + struct argv_array argv = ARGV_ARRAY_INIT;
> + sq_dequote_to_argv_array(line.buf+pos, &argv);
> + if (bisect_start(terms, 0, argv.argv, argv.argc)) {
> + argv_array_clear(&argv);
> + res = -1;
> + goto finish;
goto fail;
> + }
> + argv_array_clear(&argv);
> + break;
> + }
> +
> + if (one_of(word.buf, terms->term_good,
> + terms->term_bad, "skip", NULL)) {
> + if (bisect_write(word.buf, line.buf+pos, terms, 0)) {
> + res = -1;
> + goto finish;
goto fail;
> + }
> + break;
> + }
> +
> + if (!strcmp(word.buf, "terms")) {
> + struct argv_array argv = ARGV_ARRAY_INIT;
> + sq_dequote_to_argv_array(line.buf+pos, &argv);
> + if (bisect_terms(terms, argv.argv, argv.argc)) {
> + argv_array_clear(&argv);
> + res = -1;
> + goto finish;
goto fail;
> + }
> + argv_array_clear(&argv);
> + break;
> + }
> +
> + error(_("?? what are you talking about?"));
I know this string is taken from the original source. However, even
something like error(_("Replay file contains rubbish (\"%s\")"),
word.buf) is more informative.
> + res = -1;
> + goto finish;
goto fail;
> + }
> + }
> + goto finish;
+fail:
+ res = -1;
I just wanted to make finally clear what I was referring to by the
"goto fail" trick. :D
Also I think the readability could be improved by extracting the body of
the outer while loop into an extra function replay_line(). Then most of
my suggested "goto fail;" lines simply become "return -1;" :)
> @@ -998,6 +1112,13 @@ int cmd_bisect__helper(...)
> die(_("--bisect-log requires 0 arguments"));
> res = bisect_log();
> break;
> + case BISECT_REPLAY:
> + if (argc != 1)
> + die(_("--bisect-replay requires 1 argument"));
I'd keep the (already translated) string from the original source:
"No logfile given"
Cheers,
Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 11/27] bisect--helper: `bisect_next_check` & bisect_voc shell function in C
2016-11-17 20:59 ` Stephan Beyer
@ 2016-12-06 18:39 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-12-06 18:39 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
Sorry for the late replies. My end semester exams just got over.
On Fri, Nov 18, 2016 at 2:29 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
>
> Hi Pranit,
>
> On 10/14/2016 04:14 PM, Pranit Bauva wrote:
> > Also reimplement `bisect_voc` shell function in C and call it from
> > `bisect_next_check` implementation in C.
>
> Please don't! ;D
>
> > +static char *bisect_voc(char *revision_type)
> > +{
> > + if (!strcmp(revision_type, "bad"))
> > + return "bad|new";
> > + if (!strcmp(revision_type, "good"))
> > + return "good|old";
> > +
> > + return NULL;
> > +}
>
> Why not simply use something like this:
>
> static const char *voc[] = {
> "bad|new",
> "good|old",
> };
>
> Then...
This probably seems a good idea.
> > +static int bisect_next_check(const struct bisect_terms *terms,
> > + const char *current_term)
> > +{
> > + int missing_good = 1, missing_bad = 1, retval = 0;
> > + char *bad_ref = xstrfmt("refs/bisect/%s", terms->term_bad);
> > + char *good_glob = xstrfmt("%s-*", terms->term_good);
> > + char *bad_syn, *good_syn;
>
> ...you don't need bad_syn and good_syn...
>
> > + bad_syn = xstrdup(bisect_voc("bad"));
> > + good_syn = xstrdup(bisect_voc("good"));
>
> ...and hence not these two lines...
>
> > + if (!is_empty_or_missing_file(git_path_bisect_start())) {
> > + error(_("You need to give me at least one %s and "
> > + "%s revision. You can use \"git bisect %s\" "
> > + "and \"git bisect %s\" for that. \n"),
> > + bad_syn, good_syn, bad_syn, good_syn);
>
> ...and write
> voc[0], voc[1], voc[0], voc[1]);
> instead...
>
> > + retval = -1;
> > + goto finish;
> > + }
> > + else {
> > + error(_("You need to start by \"git bisect start\". You "
> > + "then need to give me at least one %s and %s "
> > + "revision. You can use \"git bisect %s\" and "
> > + "\"git bisect %s\" for that.\n"),
> > + good_syn, bad_syn, bad_syn, good_syn);
>
> ...and here
> voc[1], voc[0], voc[0], voc[1]);
> ...
>
> > + retval = -1;
> > + goto finish;
> > + }
> > + goto finish;
> > +finish:
> > + if (!bad_ref)
> > + free(bad_ref);
> > + if (!good_glob)
> > + free(good_glob);
> > + if (!bad_syn)
> > + free(bad_syn);
> > + if (!good_syn)
> > + free(good_syn);
>
> ...and you can remove the 4 lines above.
>
> > + return retval;
> > +}
>
> Besides that, there are again some things that I've already mentioned
> and that can be applied here, too, for example, not capitalizing
> TERM_GOOD and TERM_BAD, the goto fail simplification, the terms memory leak.
Your suggestion simplifies things, I will use that.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 08/27] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C
2016-11-16 23:47 ` Stephan Beyer
@ 2016-12-06 19:33 ` Pranit Bauva
2016-12-16 19:00 ` Pranit Bauva
2016-12-16 19:35 ` Pranit Bauva
1 sibling, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-12-06 19:33 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
On Thu, Nov 17, 2016 at 5:17 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
> Hi,
>
> On 10/14/2016 04:14 PM, Pranit Bauva wrote:
>> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
>> index d84ba86..c542e8b 100644
>> --- a/builtin/bisect--helper.c
>> +++ b/builtin/bisect--helper.c
>> @@ -123,13 +123,40 @@ static int bisect_reset(const char *commit)
>> return bisect_clean_state();
>> }
>>
>> +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;
>> +}
>
> I am not sure it does what it should.
>
> I would expect the following behavior from this function:
> - file does not exist (or is "broken") => return 0
> - actual_hex != expected_hex => return 0
> - otherwise return 1
>
> If I am not wrong, the code does the following instead:
> - file does not exist (or is "broken") => return 0
> - actual_hex != expected_hex => return 1
> - otherwise => return 0
Yeah, you are right. I should update this. Thanks for pointing it out.
>> +static int 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());
>> + return 0;
>> + }
>> + }
>> + return 0;
>> +}
>
> Here I am not sure what the function *should* do. However, I see that it
> basically mimics the behavior of the shell function (assuming
> is_expected_rev() is implemented correctly).
>
> I don't understand why the return value is int and not void. To avoid a
> "return 0;" line when calling this function?
Initially I thought I would be using the return value but now I
realize that it is meaningless to do so. Using void seems better. :)
>> @@ -167,6 +196,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
>> if (argc > 1)
>> die(_("--bisect-reset requires either zero or one arguments"));
>> return bisect_reset(argc ? argv[0] : NULL);
>> + case CHECK_EXPECTED_REVS:
>> + return check_expected_revs(argv, argc);
>
> I note that you check the correct number of arguments for some
> subcommands and you do not check it for some other subcommands like this
> one. (I don't care, I just want to mention it.)
Here we should be able to accept any number of arguments. I think it
would be good to add a non-zero check though just to maintain the
uniformity. Though this is something programmer needs to be careful
about rather than the user.
>> default:
>> die("BUG: unknown subcommand '%d'", cmdmode);
>> }
>
> ~Stephan
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 18/27] bisect--helper: `bisect_autostart` shell function in C
2016-11-20 20:15 ` Stephan Beyer
@ 2016-12-06 19:47 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-12-06 19:47 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
On Mon, Nov 21, 2016 at 1:45 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
> Hi,
>
> On 10/14/2016 04:14 PM, Pranit Bauva wrote:
>> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
>> index 502bf18..1767916 100644
>> --- a/builtin/bisect--helper.c
>> +++ b/builtin/bisect--helper.c
>> @@ -422,6 +425,7 @@ static int bisect_next(...)
>> {
>> int res, no_checkout;
>>
>> + bisect_autostart(terms);
>
> You are not checking for return values here. (The shell code simply
> exited if there is no tty, but you don't.)
True. I didn't notice it carefully. Thanks for pointing it out.
>> @@ -754,6 +758,32 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
>> return retval || bisect_auto_next(terms, NULL);
>> }
>>
>> +static int bisect_autostart(struct bisect_terms *terms)
>> +{
>> + if (is_empty_or_missing_file(git_path_bisect_start())) {
>> + const char *yesno;
>> + const char *argv[] = {NULL};
>> + fprintf(stderr, _("You need to start by \"git bisect "
>> + "start\"\n"));
>> +
>> + if (!isatty(0))
>
> isatty(STDIN_FILENO)?
Seems better.
>> + return 1;
>> +
>> + /*
>> + * TRANSLATORS: Make sure to include [Y] and [n] in your
>> + * translation. THe program will only accept English input
>
> Typo "THe"
Sure.
>> + * at this point.
>> + */
>
> Taking "at this point" into consideration, I think the Y and n can be
> easily translated now that it is in C. I guess, by using...
>
>> + yesno = git_prompt(_("Do you want me to do it for you "
>> + "[Y/n]? "), PROMPT_ECHO);
>> + if (starts_with(yesno, "n") || starts_with(yesno, "N"))
>
> ... starts_with(yesno, _("n")) || starts_with(yesno, _("N"))
> here (but not sure). However, this would be an extra patch on top of
> this series.
Can add it as an extra patch. Thanks for informing.
>> + exit(0);
>
> Shouldn't this also be "return 1;"? Saying "no" is the same outcome as
> not having a tty to ask for yes or no.
Yes.
>> int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
>> {
>> enum {
>> @@ -790,6 +821,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
>> N_("find the next bisection commit"), BISECT_NEXT),
>> OPT_CMDMODE(0, "bisect-auto-next", &cmdmode,
>> N_("verify the next bisection state then find the next bisection state"), BISECT_AUTO_NEXT),
>> + OPT_CMDMODE(0, "bisect-autostart", &cmdmode,
>> + N_("start the bisection if BISECT_START empty or missing"), BISECT_AUTOSTART),
>
> The word "is" is missing.
Sure. Thanks for going through these patches very carefully.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 12/27] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-11-17 21:32 ` Stephan Beyer
@ 2016-12-06 21:14 ` Pranit Bauva
2016-12-06 23:05 ` Stephan Beyer
0 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-12-06 21:14 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
On Fri, Nov 18, 2016 at 3:02 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
> Hi,
>
> On 10/14/2016 04:14 PM, Pranit Bauva wrote:
>> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
>> index 317d671..6a5878c 100644
>> --- a/builtin/bisect--helper.c
>> +++ b/builtin/bisect--helper.c
> [...]
>> +static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
>> +{
>> + int i;
>> + const char bisect_term_usage[] =
>> +"git bisect--helper --bisect-terms [--term-good | --term-bad | ]"
>> +"--term-old | --term-new";
>
> Three things:
>
> (1) Is that indentation intentional?
Yes it was intentional but now I cannot recollect why. I think it was
because I found something similar. Nevertheless, I will fix this
indentation/
> (2) You have a "]" at the end of the first part of the string instead of
> the end of the second part.
This should be corrected.
> (3) After the correction, bisect_term_usage and
> git_bisect_helper_usage[7] are the same strings. I don't recommend to
> use git_bisect_helper_usage[7] instead because keeping the index
> up-to-date is a maintenance hell. (At the end of your patch series it is
> a 3 instead of a 7.) However, if - for whatever reason - the usage of
> bisect--helper --bisect-terms changes, you always have to sync the two
> strings which is also nasty....
>
>> +
>> + if (get_terms(terms))
>> + return error(_("no terms defined"));
>> +
>> + if (argc > 1) {
>> + usage(bisect_term_usage);
>> + return -1;
>> + }
>
> ...and since you only use it once, why not simply do something like
>
> return error(_("--bisect-term requires exactly one argument"));
>
> and drop the definition of bisect_term_usage.
Sure that would be better.
>> +
>> + if (argc == 0) {
>> + printf(_("Your current terms are %s for the old state\nand "
>> + "%s for the new state.\n"), terms->term_good,
>> + terms->term_bad);
>
> Very minor: It improves the readability if you'd split the string after
> the \n and put the "and "in the next line.
Ah. This is because of the message. If I do the other way, then it
won't match the output in one of the tests in t/t6030 thus, I am
keeping it that way in order to avoid modifying the file t/t6030.
>> + return 0;
>> + }
>> +
>> + for (i = 0; i < argc; i++) {
>> + if (!strcmp(argv[i], "--term-good"))
>> + printf("%s\n", terms->term_good);
>> + else if (!strcmp(argv[i], "--term-bad"))
>> + printf("%s\n", terms->term_bad);
>> + else
>> + die(_("invalid argument %s for 'git bisect "
>> + "terms'.\nSupported options are: "
>> + "--term-good|--term-old and "
>> + "--term-bad|--term-new."), argv[i]);
>
> Hm, "return error(...)" and "die(...)" seems to be quasi-equivalent in
> this case. Because I am always looking from a library perspective, I'd
> prefer "return error(...)".
I should use return error()
>> @@ -429,6 +492,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
>> terms.term_bad = xstrdup(argv[1]);
>> res = bisect_next_check(&terms, argc == 3 ? argv[2] : NULL);
>> break;
>> + case BISECT_TERMS:
>> + if (argc > 1)
>> + die(_("--bisect-terms requires 0 or 1 argument"));
>> + res = bisect_terms(&terms, argv, argc);
>> + break;
>
> Also here: "terms" is leaking...
Will have to free it.
> ~Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 09/27] bisect--helper: `bisect_write` shell function in C
2016-11-17 9:40 ` Stephan Beyer
@ 2016-12-06 21:32 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-12-06 21:32 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
On Thu, Nov 17, 2016 at 3:10 PM, Stephan Beyer <s-beyer@gmx.net> wrote:
> Hi,
>
> I've only got some minors to mention here ;)
>
> On 10/14/2016 04:14 PM, Pranit Bauva wrote:
>> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
>> index c542e8b..3f19b68 100644
>> --- a/builtin/bisect--helper.c
>> +++ b/builtin/bisect--helper.c
>> @@ -19,9 +19,15 @@ static const char * const git_bisect_helper_usage[] = {
>> N_("git bisect--helper --write-terms <bad_term> <good_term>"),
>> N_("git bisect--helper --bisect-clean-state"),
>> N_("git bisect--helper --bisect-reset [<commit>]"),
>> + N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
>> NULL
>> };
>
> I wouldn't write "<TERM_GOOD <TERM_BAD>" in capital letters. I'd use
> something like "<good_term> <bad_term>" as you have used for
> --write-terms. Note that "git bisect --help" uses "<term-old>
> <term-new>" in that context.
Keeping it in small does give less strain to the eye ;)
>> @@ -149,6 +155,63 @@ static int check_expected_revs(const char **revs, int rev_nr)
>> return 0;
>> }
>>
>> +static int bisect_write(const char *state, const char *rev,
>> + const struct bisect_terms *terms, int nolog)
>> +{
>> + struct strbuf tag = STRBUF_INIT;
>> + struct strbuf commit_name = STRBUF_INIT;
>> + struct object_id oid;
>> + struct commit *commit;
>> + struct pretty_print_context pp = {0};
>> + FILE *fp = NULL;
>> + int retval = 0;
>> +
>> + 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 {
>> + error(_("Bad bisect_write argument: %s"), state);
>> + retval = -1;
>> + goto finish;
>> + }
>> +
>> + if (get_oid(rev, &oid)) {
>> + error(_("couldn't get the oid of the rev '%s'"), rev);
>> + retval = -1;
>> + goto finish;
>> + }
>> +
>> + if (update_ref(NULL, tag.buf, oid.hash, NULL, 0,
>> + UPDATE_REFS_MSG_ON_ERR)) {
>> + retval = -1;
>> + goto finish;
>> + }
>
> I'd like to mention that the "goto fail;" trick could apply in this
> function, too.
Sure!
>> @@ -156,9 +219,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
>> WRITE_TERMS,
>> BISECT_CLEAN_STATE,
>> BISECT_RESET,
>> - CHECK_EXPECTED_REVS
>> + CHECK_EXPECTED_REVS,
>> + BISECT_WRITE
>> } cmdmode = 0;
>> - int no_checkout = 0;
>> + int no_checkout = 0, res = 0;
>
> Why do you do this "direct return" -> "set res and return res" transition?
> You don't need it in this patch, you do not need it in the subsequent
> patches (you always set "res" exactly once after the initialization),
> and you don't need cleanup code in this function.
Initially I was using strbuf but then I switched to const char *
according to Junio's suggestion. It seems that in this version I have
forgot to free the terms.
>> struct option options[] = {
>> OPT_CMDMODE(0, "next-all", &cmdmode,
>> N_("perform 'git bisect next'"), NEXT_ALL),
>> @@ -170,10 +234,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
>> N_("reset the bisection state"), BISECT_RESET),
>> OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
>> N_("check for expected revs"), CHECK_EXPECTED_REVS),
>> + OPT_CMDMODE(0, "bisect-write", &cmdmode,
>> + N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
>
> That info text is confusing, especially considering that there is a
> "nolog" option. I think the action of bisect-write is two-fold: (1)
> update the refs, (2) log.
I agree that it is confusing. I couldn't find a better way to describe
it and since this would be gone after the whole conversion, I didn't
bother putting more efforts there.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 19/27] bisect--helper: `bisect_state` & `bisect_head` shell function in C
2016-11-22 0:12 ` Stephan Beyer
@ 2016-12-06 22:40 ` Pranit Bauva
2016-12-06 23:54 ` Stephan Beyer
0 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-12-06 22:40 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
On Tue, Nov 22, 2016 at 5:42 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
> Hi,
>
> On 10/14/2016 04:14 PM, Pranit Bauva wrote:
>> Reimplement the `bisect_state` shell function in C and also add a
>> subcommand `--bisect-state` to `git-bisect--helper` to call it from
>> git-bisect.sh .
>>
>> Using `--bisect-state` subcommand is a temporary measure to port shell
>> function to C so as to use the existing test suite. As more functions
>> are ported, this subcommand will be retired and will be called by some
>> other methods.
>>
>> `bisect_head` is called from `bisect_state` thus its not required to
>> introduce another subcommand.
>
> Missing comma before "thus", and "it is" (or "it's") instead of "its" :)
Sure, will fix.
>> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
>> index 1767916..1481c6d 100644
>> --- a/builtin/bisect--helper.c
>> +++ b/builtin/bisect--helper.c
>> @@ -784,6 +786,79 @@ static int bisect_autostart(struct bisect_terms *terms)
>> return 0;
>> }
>>
>> +static char *bisect_head(void)
>> +{
>> + if (is_empty_or_missing_file(git_path_bisect_head()))
>> + return "HEAD";
>> + else
>> + return "BISECT_HEAD";
>> +}
>
> This is very shellish.
> In C I'd expect something like
>
> static int bisect_head_sha1(unsigned char *sha)
> {
> int res;
> if (is_empty_or_missing_file(git_path_bisect_head()))
> res = get_sha1("HEAD", sha);
> else
> res = get_sha1("BISECT_HEAD", sha);
>
> if (res)
> return error(_("Could not find BISECT_HEAD or HEAD."));
>
> return 0;
> }
>
>> +
>> +static int bisect_state(struct bisect_terms *terms, const char **argv,
>> + int argc)
>> +{
>> + const char *state = argv[0];
>> +
>> + get_terms(terms);
>> + if (check_and_set_terms(terms, state))
>> + return -1;
>> +
>> + if (!argc)
>> + die(_("Please call `--bisect-state` with at least one argument"));
>
> I think this check should move to cmd_bisect__helper. There are also the
> other argument number checks.
Not really. After the whole conversion, the cmdmode will cease to
exists while bisect_state will be called directly, thus it is
important to check it here.
>> +
>> + if (argc == 1 && one_of(state, terms->term_good,
>> + terms->term_bad, "skip", NULL)) {
>> + const char *bisected_head = xstrdup(bisect_head());
>> + const char *hex[1];
>
> Maybe:
> const char *hex;
>
>> + unsigned char sha1[20];
>> +
>> + if (get_sha1(bisected_head, sha1))
>> + die(_("Bad rev input: %s"), bisected_head);
>
> And instead of...
>
>> + if (bisect_write(state, sha1_to_hex(sha1), terms, 0))
>> + return -1;
>> +
>> + *hex = xstrdup(sha1_to_hex(sha1));
>> + if (check_expected_revs(hex, 1))
>> + return -1;
>
> ... simply:
>
> hex = xstrdup(sha1_to_hex(sha1));
> if (set_state(terms, state, hex)) {
> free(hex);
> return -1;
> }
> free(hex);
>
> where:
Yes I am planning to convert all places with hex rather than the sha1
but not yet, maybe in an another patch series because currently a lot
of things revolve around sha1 and changing its behaviour wouldn't
really be a part of a porting patch series.
> static int set_state(struct bisect_terms *terms, const char *state,
> const char *hex)
> {
> if (bisect_write(state, hex, terms, 0))
> return -1;
> if (check_expected_revs(&hex, 1))
> return -1;
> return 0;
> }
>
>> + return bisect_auto_next(terms, NULL);
>> + }
>> +
>> + if ((argc == 2 && !strcmp(state, terms->term_bad)) ||
>> + one_of(state, terms->term_good, "skip", NULL)) {
>> + int i;
>> + struct string_list hex = STRING_LIST_INIT_DUP;
>> +
>> + for (i = 1; i < argc; i++) {
>> + unsigned char sha1[20];
>> +
>> + if (get_sha1(argv[i], sha1)) {
>> + string_list_clear(&hex, 0);
>> + die(_("Bad rev input: %s"), argv[i]);
>> + }
>> + string_list_append(&hex, sha1_to_hex(sha1));
>> + }
>> + for (i = 0; i < hex.nr; i++) {
>
> ... And replace this:
>
>> + const char **hex_string = (const char **) &hex.items[i].string;
>> + if(bisect_write(state, *hex_string, terms, 0)) {
>> + string_list_clear(&hex, 0);
>> + return -1;
>> + }
>> + if (check_expected_revs(hex_string, 1)) {
>> + string_list_clear(&hex, 0);
>> + return -1;
>> + }
>
> by:
>
> const char *hex_str = hex.items[i].string;
> if (set_state(terms, state, hex_string)) {
> string_list_clear(&hex, 0);
> return -1;
> }
>
>> + }
>> + string_list_clear(&hex, 0);
>> + return bisect_auto_next(terms, NULL);
>> + }
>> +
>> + if (!strcmp(state, terms->term_bad))
>> + die(_("'git bisect %s' can take only one argument."),
>> + terms->term_bad);
>> +
>> + return -1;
>> +}
>> +
>> int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
>> {
>> enum {
>> @@ -823,6 +899,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
>> N_("verify the next bisection state then find the next bisection state"), BISECT_AUTO_NEXT),
>> OPT_CMDMODE(0, "bisect-autostart", &cmdmode,
>> N_("start the bisection if BISECT_START empty or missing"), BISECT_AUTOSTART),
>> + OPT_CMDMODE(0, "bisect-state", &cmdmode,
>> + N_("mark the state of ref (or refs)"), BISECT_STATE),
>
> "mark the state of the given revs"
>
> Note that rev != ref
Might have been a typo. Will fix.
>> @@ -902,6 +980,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
>> terms.term_bad = "bad";
>> res = bisect_autostart(&terms);
>> break;
>> + case BISECT_STATE:
>> + if (argc == 0)
>> + die(_("--bisect-state requires at least 1 argument"));
>
> "at least one revision"
Okay, that would make it more specific.
>> diff --git a/git-bisect.sh b/git-bisect.sh
>> index cd56551..a9eebbb 100755
>> --- a/git-bisect.sh
>> +++ b/git-bisect.sh
>> @@ -61,44 +51,7 @@ bisect_skip() {
>> esac
>> all="$all $revs"
>> done
>> - eval bisect_state 'skip' $all
> [...deleted lines...]
>> + eval git bisect--helper --bisect-state 'skip' $all
>
> I think you don't need "eval" here any longer.
Yes, I wouldn't
>> @@ -184,8 +137,8 @@ exit code \$res from '\$command' is < 0 or >= 128" >&2
>> state="$TERM_GOOD"
>> fi
>>
>> - # We have to use a subshell because "bisect_state" can exit.
>> - ( bisect_state $state >"$GIT_DIR/BISECT_RUN" )
>> + # We have to use a subshell because "--bisect-state" can exit.
>> + ( git bisect--helper --bisect-state $state >"$GIT_DIR/BISECT_RUN" )
True, but right now I didn't want to modify that part of the source
code to remove the comment. I will remove the comment all together
when I port bisect_run()
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 22/27] bisect--helper: `bisect_log` shell function in C
2016-11-17 21:47 ` Stephan Beyer
@ 2016-12-06 22:42 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-12-06 22:42 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
On Fri, Nov 18, 2016 at 3:17 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
> Hi,
>
> On 10/14/2016 04:14 PM, Pranit Bauva wrote:
>> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
>> index 493034c..c18ca07 100644
>> --- a/builtin/bisect--helper.c
>> +++ b/builtin/bisect--helper.c
>> @@ -858,6 +858,23 @@ static int bisect_state(struct bisect_terms *terms, const char **argv,
>> return -1;
>> }
>>
>> +static int bisect_log(void)
>> +{
>> + int fd, status;
>> + fd = open(git_path_bisect_log(), O_RDONLY);
>> + if (fd < 0)
>> + return -1;
>> +
>> + status = copy_fd(fd, 1);
>
> Perhaps
>
> status = copy_fd(fd, STDOUT_FILENO);
Sure!
>> + if (status) {
>> + close(fd);
>> + return -1;
>> + }
>> +
>> + close(fd);
>> + return status;
>> +}
>
> That's weird.
> Either get rid of the if() and actually use status:
>
> status = copy_fd(fd, STDOUT_FILENO);
>
> close(fd);
> return status ? -1 : 0;
This one seems better!
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 10/27] bisect--helper: `check_and_set_terms` shell function in C
2016-11-17 20:25 ` Stephan Beyer
@ 2016-12-06 22:43 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-12-06 22:43 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
On Fri, Nov 18, 2016 at 1:55 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
> Hi Pranit,
>
> On 10/14/2016 04:14 PM, Pranit Bauva wrote:
>> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
>> index 3f19b68..c6c11e3 100644
>> --- a/builtin/bisect--helper.c
>> +++ b/builtin/bisect--helper.c
>> @@ -20,6 +20,7 @@ static const char * const git_bisect_helper_usage[] = {
>> N_("git bisect--helper --bisect-clean-state"),
>> N_("git bisect--helper --bisect-reset [<commit>]"),
>> N_("git bisect--helper --bisect-write <state> <revision> <TERM_GOOD> <TERM_BAD> [<nolog>]"),
>> + N_("git bisect--helper --bisect-check-and-set-terms <command> <TERM_GOOD> <TERM_BAD>"),
>
> Here's the same as in the previous patch... I'd not use
> TERM_GOOD/TERM_BAD in capitals.
Sure.
>> NULL
>> };
>>
>> @@ -212,6 +213,38 @@ static int bisect_write(const char *state, const char *rev,
>> return retval;
>> }
>>
>> +static int set_terms(struct bisect_terms *terms, const char *bad,
>> + const char *good)
>> +{
>> + terms->term_good = xstrdup(good);
>> + terms->term_bad = xstrdup(bad);
>> + return write_terms(terms->term_bad, terms->term_good);
>
> At this stage of the patch series I am wondering why you are setting
> "terms" here, but I guess you'll need it later.
>
> However, you are leaking memory here. Something like
>
> free(terms->term_good);
> free(terms->term_bad);
> terms->term_good = xstrdup(good);
> terms->term_bad = xstrdup(bad);
>
> should be safe (because you've always used xstrdup() for the terms
> members before). Or am I overseeing something?
Yeah it is safe.
>> @@ -278,6 +314,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
>> terms.term_bad = xstrdup(argv[3]);
>> res = bisect_write(argv[0], argv[1], &terms, nolog);
>> break;
>> + case CHECK_AND_SET_TERMS:
>> + if (argc != 3)
>> + die(_("--check-and-set-terms requires 3 arguments"));
>> + terms.term_good = xstrdup(argv[1]);
>> + terms.term_bad = xstrdup(argv[2]);
>> + res = check_and_set_terms(&terms, argv[0]);
>> + break;
>
> Ha! When I reviewed the last patch, I asked you why you changed the code
> from returning directly from each subcommand to setting res; break; and
> then return res at the bottom of the function.
>
> Now I see why this was useful. The two members of "terms" are again
> leaking memory: you are allocating memory by using xstrdup() but you are
> not freeing it.
I will take care about freeing the memory.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 23/27] bisect--helper: `bisect_replay` shell function in C
2016-11-22 0:49 ` Stephan Beyer
@ 2016-12-06 23:02 ` Pranit Bauva
2016-12-06 23:20 ` Stephan Beyer
2016-12-06 23:40 ` Stephan Beyer
0 siblings, 2 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-12-06 23:02 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
On Tue, Nov 22, 2016 at 6:19 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
> Okay Pranit,
>
> this is the last patch for me to review in this series.
>
> Now that I have a coarse overview of what you did, I have the general
> remark that imho the "terms" variable should simply be global instead of
> being passed around all the time.
In a personal conversation with my mentors, we thought it is the best
fit to keep it in a struct and pass it around so that it is easier in
libification.
> I also had some other remarks but I forgot them... maybe they come to my
> mind again when I see patch series v16.
>
> I also want to remark again that I am not a Git developer and only
> reviewed this because of my interest in git-bisect. So some of my
> suggestions might conflict with other beliefs here. For example, I
> consider it very bad style to leak memory... but Git is rather written
> as a scripting tool than a genuine library, so perhaps many people here
> do not care about it as long as it works...
Thanks for taking out your time to review my series extremely
carefully. I will try to post a v16 next week probably.
> On 10/14/2016 04:14 PM, Pranit Bauva wrote:
>> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
>> index c18ca07..b367d8d 100644
>> --- a/builtin/bisect--helper.c
>> +++ b/builtin/bisect--helper.c
>> @@ -601,7 +602,6 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
>> terms->term_good = arg;
>> } else if (!strcmp(arg, "--term-bad") ||
>> !strcmp(arg, "--term-new")) {
>> - const char *next_arg;
>
> This should already have been removed in patch 15/27, not here.
>
>> @@ -875,6 +875,117 @@ static int bisect_log(void)
>> return status;
>> }
>>
>> +static int get_next_word(const char *line, int pos, struct strbuf *word)
>> +{
>> + int i, len = strlen(line), begin = 0;
>> + strbuf_reset(word);
>> + for (i = pos; i < len; i++) {
>> + if (line[i] == ' ' && begin)
>> + return i + 1;
>> +
>> + if (!begin)
>> + begin = 1;
>> + strbuf_addch(word, line[i]);
>> + }
>> +
>> + return i;
>> +}
>> +
>> +static int bisect_replay(struct bisect_terms *terms, const char *filename)
>> +{
>> + struct strbuf line = STRBUF_INIT;
>> + struct strbuf word = STRBUF_INIT;
>> + FILE *fp = NULL;
>
> (The initialization is not necessary here.)
Um. I think it is. Otherwise if it goes to the finish block before you
try to operate on fp, it will cause a seg fault.
>> + int res = 0;
>> +
>> + if (is_empty_or_missing_file(filename)) {
>> + error(_("no such file with name '%s' exists"), filename);
>
> The error message is misleading if the file exists but is empty.
> Maybe something like "cannot read file '%s' for replaying"?
Okay will change.
>> + res = -1;
>> + goto finish;
>
> goto fail;
> :D
>
>> + }
>> +
>> + if (bisect_reset(NULL)) {
>> + res = -1;
>> + goto finish;
>
> goto fail;
>
>> + }
>> +
>> + fp = fopen(filename, "r");
>> + if (!fp) {
>> + res = -1;
>> + goto finish;
>
> goto fail;
>
>> + }
>> +
>> + while (strbuf_getline(&line, fp) != EOF) {
>> + int pos = 0;
>> + while (pos < line.len) {
>> + pos = get_next_word(line.buf, pos, &word);
>> +
>> + if (!strcmp(word.buf, "git")) {
>> + continue;
>> + } else if (!strcmp(word.buf, "git-bisect")) {
>> + continue;
>> + } else if (!strcmp(word.buf, "bisect")) {
>> + continue;
>> + } else if (!strcmp(word.buf, "#")) {
>> + break;
>
> Maybe it is more robust to check whether word.buf begins with #
Assuming that you meant "# ", yes.
>> + }
>> +
>> + get_terms(terms);
>> + if (check_and_set_terms(terms, word.buf)) {
>> + res = -1;
>> + goto finish;
>
> goto fail;
>
>> + }
>> +
>> + if (!strcmp(word.buf, "start")) {
>> + struct argv_array argv = ARGV_ARRAY_INIT;
>> + sq_dequote_to_argv_array(line.buf+pos, &argv);
>> + if (bisect_start(terms, 0, argv.argv, argv.argc)) {
>> + argv_array_clear(&argv);
>> + res = -1;
>> + goto finish;
>
> goto fail;
>
>> + }
>> + argv_array_clear(&argv);
>> + break;
>> + }
>> +
>> + if (one_of(word.buf, terms->term_good,
>> + terms->term_bad, "skip", NULL)) {
>> + if (bisect_write(word.buf, line.buf+pos, terms, 0)) {
>> + res = -1;
>> + goto finish;
>
> goto fail;
>
>> + }
>> + break;
>> + }
>> +
>> + if (!strcmp(word.buf, "terms")) {
>> + struct argv_array argv = ARGV_ARRAY_INIT;
>> + sq_dequote_to_argv_array(line.buf+pos, &argv);
>> + if (bisect_terms(terms, argv.argv, argv.argc)) {
>> + argv_array_clear(&argv);
>> + res = -1;
>> + goto finish;
>
> goto fail;
>
>> + }
>> + argv_array_clear(&argv);
>> + break;
>> + }
>> +
>> + error(_("?? what are you talking about?"));
>
> I know this string is taken from the original source. However, even
> something like error(_("Replay file contains rubbish (\"%s\")"),
> word.buf) is more informative.
Okay will change.
>> + res = -1;
>> + goto finish;
>
> goto fail;
>
>> + }
>> + }
>> + goto finish;
>
> +fail:
> + res = -1;
>
> I just wanted to make finally clear what I was referring to by the
> "goto fail" trick. :D
I got it. Will update accordingly.
> Also I think the readability could be improved by extracting the body of
> the outer while loop into an extra function replay_line(). Then most of
> my suggested "goto fail;" lines simply become "return -1;" :)
>
>> @@ -998,6 +1112,13 @@ int cmd_bisect__helper(...)
>> die(_("--bisect-log requires 0 arguments"));
>> res = bisect_log();
>> break;
>> + case BISECT_REPLAY:
>> + if (argc != 1)
>> + die(_("--bisect-replay requires 1 argument"));
>
> I'd keep the (already translated) string from the original source:
> "No logfile given"
Sure
Regards.
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 12/27] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-12-06 21:14 ` Pranit Bauva
@ 2016-12-06 23:05 ` Stephan Beyer
2016-12-07 12:06 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2016-12-06 23:05 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Git List
Hey Pranit,
On 12/06/2016 10:14 PM, Pranit Bauva wrote:
>>> +
>>> + if (argc == 0) {
>>> + printf(_("Your current terms are %s for the old state\nand "
>>> + "%s for the new state.\n"), terms->term_good,
>>> + terms->term_bad);
>>
>> Very minor: It improves the readability if you'd split the string after
>> the \n and put the "and "in the next line.
>
> Ah. This is because of the message. If I do the other way, then it
> won't match the output in one of the tests in t/t6030 thus, I am
> keeping it that way in order to avoid modifying the file t/t6030.
I think I was unclear here. I was referring to the coding/layouting
style, not to the string. I mean like writing:
printf(_("Your current terms are %s for the old state\n"
"and "%s for the new state.\n"),
terms->term_good, terms->term_bad);
The string fed to _() is the same, but it is split in a different (imho
more readable) way: after the "\n", not after the "and ".
>>> + die(_("invalid argument %s for 'git bisect "
>>> + "terms'.\nSupported options are: "
>>> + "--term-good|--term-old and "
>>> + "--term-bad|--term-new."), argv[i]);
>>
>> Hm, "return error(...)" and "die(...)" seems to be quasi-equivalent in
>> this case. Because I am always looking from a library perspective, I'd
>> prefer "return error(...)".
>
> I should use return error()
When you reroll your patches, please also check if you always put _()
around your error()s ;) (Hmmm... On the other hand, it might be arguable
if translations are useful for errors that only occur when people hack
git-bisect or use the bisect--helper directly... This makes me feel like
all those errors should be prefixed by some "BUG: " marker since the
ordinary user only sees them when there is a bug. But I don't feel in
the position to decide or recommend such a thing, so it's just a thought.)
~Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 23/27] bisect--helper: `bisect_replay` shell function in C
2016-12-06 23:02 ` Pranit Bauva
@ 2016-12-06 23:20 ` Stephan Beyer
2016-12-06 23:40 ` Stephan Beyer
1 sibling, 0 replies; 320+ messages in thread
From: Stephan Beyer @ 2016-12-06 23:20 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Git List
Hey Pranit,
On 12/07/2016 12:02 AM, Pranit Bauva wrote:
>>> +static int bisect_replay(struct bisect_terms *terms, const char *filename)
>>> +{
>>> + struct strbuf line = STRBUF_INIT;
>>> + struct strbuf word = STRBUF_INIT;
>>> + FILE *fp = NULL;
>>
>> (The initialization is not necessary here.)
>
> Um. I think it is. Otherwise if it goes to the finish block before you
> try to operate on fp, it will cause a seg fault.
You are right, thanks!
>>> + while (strbuf_getline(&line, fp) != EOF) {
>>> + int pos = 0;
>>> + while (pos < line.len) {
>>> + pos = get_next_word(line.buf, pos, &word);
>>> +
>>> + if (!strcmp(word.buf, "git")) {
>>> + continue;
>>> + } else if (!strcmp(word.buf, "git-bisect")) {
>>> + continue;
>>> + } else if (!strcmp(word.buf, "bisect")) {
>>> + continue;
>>> + } else if (!strcmp(word.buf, "#")) {
>>> + break;
>>
>> Maybe it is more robust to check whether word.buf begins with #
>
> Assuming that you meant "# ", yes.
No, if I get it right "# " can never occur because the word.buf never
contains a space.
What I meant was that you are currently ignoring everything after a
"# ", so comments like
# foo
are ignored.
However, imagine a user changes the file by hand (he probably should not
do it but, hey, it's git: unixy, hacky ... and he thinks he knows what
he does) and then we have in the file something like
#foo
which makes perfectly sense when you are used to programming languages
with # as comment-till-eol marker. The problem is that your current code
does expect "#" as a single word and would hence not recognize #foo as a
comment.
I hope I made it clear why I suggested to test if the word *begins* with
"#" (not "# ").
~Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 23/27] bisect--helper: `bisect_replay` shell function in C
2016-12-06 23:02 ` Pranit Bauva
2016-12-06 23:20 ` Stephan Beyer
@ 2016-12-06 23:40 ` Stephan Beyer
2016-12-07 13:15 ` Christian Couder
1 sibling, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2016-12-06 23:40 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Git List, Christian Couder, Lars Schneider
Hi Pranit and Christian and Lars ;)
On 12/07/2016 12:02 AM, Pranit Bauva wrote:
> On Tue, Nov 22, 2016 at 6:19 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
>> Okay Pranit,
>>
>> this is the last patch for me to review in this series.
>>
>> Now that I have a coarse overview of what you did, I have the general
>> remark that imho the "terms" variable should simply be global instead of
>> being passed around all the time.
>
> In a personal conversation with my mentors, we thought it is the best
> fit to keep it in a struct and pass it around so that it is easier in
> libification.
I guess you had that conversation at the beginning of the project and I
think that at that stage I would have recommended it that way, too.
However, looking at the v15 bisect--helper.c, it looks like it is rather
a pain to do it that way. I mean, you use the terms like they were
global variables: you initialize them in cmd_bisect__helper() and then
you always pass them around; you update them "globally", never using
restricted scope, never ever use a second instantiation besides the one
of cmd_bisect__helper(). These are all signs that *in the current code*
using (static) global variables is the better way (making the code simpler).
The libification argument may be worth considering, though. I am not
sure if there is really a use-case where you need two different
instantiations of the terms, *except* if the lib allows bisecting with
different terms at the same time (in different repos, of course). Is the
lib "aware" of such use-cases like doing stuff in different repos at the
same time? If that's the case, not using global variables is the right
thing to do. In any other case I can imagine, I'd suggest to use global
variables.
~Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 19/27] bisect--helper: `bisect_state` & `bisect_head` shell function in C
2016-12-06 22:40 ` Pranit Bauva
@ 2016-12-06 23:54 ` Stephan Beyer
2016-12-08 6:43 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2016-12-06 23:54 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Git List
Hi Pranit,
On 12/06/2016 11:40 PM, Pranit Bauva wrote:
> On Tue, Nov 22, 2016 at 5:42 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
>> On 10/14/2016 04:14 PM, Pranit Bauva wrote:
>>> +static int bisect_state(struct bisect_terms *terms, const char **argv,
>>> + int argc)
>>> +{
>>> + const char *state = argv[0];
>>> +
>>> + get_terms(terms);
>>> + if (check_and_set_terms(terms, state))
>>> + return -1;
>>> +
>>> + if (!argc)
>>> + die(_("Please call `--bisect-state` with at least one argument"));
>>
>> I think this check should move to cmd_bisect__helper. There are also the
>> other argument number checks.
>
> Not really. After the whole conversion, the cmdmode will cease to
> exists while bisect_state will be called directly, thus it is
> important to check it here.
Okay, that's a point.
In that case, you should probably use "return error()" again and the
message (mentioning "--bisect-state") does not make sense when
--bisect-state ceases to exist.
>>> +
>>> + if (argc == 1 && one_of(state, terms->term_good,
>>> + terms->term_bad, "skip", NULL)) {
>>> + const char *bisected_head = xstrdup(bisect_head());
>>> + const char *hex[1];
>>
>> Maybe:
>> const char *hex;
>>
>>> + unsigned char sha1[20];
>>> +
>>> + if (get_sha1(bisected_head, sha1))
>>> + die(_("Bad rev input: %s"), bisected_head);
>>
>> And instead of...
>>
>>> + if (bisect_write(state, sha1_to_hex(sha1), terms, 0))
>>> + return -1;
>>> +
>>> + *hex = xstrdup(sha1_to_hex(sha1));
>>> + if (check_expected_revs(hex, 1))
>>> + return -1;
>>
>> ... simply:
>>
>> hex = xstrdup(sha1_to_hex(sha1));
>> if (set_state(terms, state, hex)) {
>> free(hex);
>> return -1;
>> }
>> free(hex);
>>
>> where:
>
> Yes I am planning to convert all places with hex rather than the sha1
> but not yet, maybe in an another patch series because currently a lot
> of things revolve around sha1 and changing its behaviour wouldn't
> really be a part of a porting patch series.
I was not suggesting a change of behavior, I was suggesting a simple
helper function set_state() to get rid of code duplication above and
some lines below:
>> ... And replace this:
>>
>>> + const char **hex_string = (const char **) &hex.items[i].string;
>>> + if(bisect_write(state, *hex_string, terms, 0)) {
>>> + string_list_clear(&hex, 0);
>>> + return -1;
>>> + }
>>> + if (check_expected_revs(hex_string, 1)) {
>>> + string_list_clear(&hex, 0);
>>> + return -1;
>>> + }
>>
>> by:
>>
>> const char *hex_str = hex.items[i].string;
>> if (set_state(terms, state, hex_string)) {
>> string_list_clear(&hex, 0);
>> return -1;
>> }
See?
>>> @@ -184,8 +137,8 @@ exit code \$res from '\$command' is < 0 or >= 128" >&2
>>> state="$TERM_GOOD"
>>> fi
>>>
>>> - # We have to use a subshell because "bisect_state" can exit.
>>> - ( bisect_state $state >"$GIT_DIR/BISECT_RUN" )
>>> + # We have to use a subshell because "--bisect-state" can exit.
>>> + ( git bisect--helper --bisect-state $state >"$GIT_DIR/BISECT_RUN" )
>>
>> The new comment is funny, but you don't need a subshell here any
>> longer.
>
> True, but right now I didn't want to modify that part of the source
> code to remove the comment. I will remove the comment all together
> when I port bisect_run()
For most of the patches, I was commenting on the current state, not on
the big picture.
Still I think that it is better to remove the comment and the subshell
instead of making the comment weird ("yes the builtin can exit, but why
do we need a subshell?" vs "yes the shell function calls exit, so we
need a subshell because we do not want to exit this shell script")
~Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 12/27] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2016-12-06 23:05 ` Stephan Beyer
@ 2016-12-07 12:06 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-12-07 12:06 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
On Wed, Dec 7, 2016 at 4:35 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
> Hey Pranit,
>
> On 12/06/2016 10:14 PM, Pranit Bauva wrote:
>>>> +
>>>> + if (argc == 0) {
>>>> + printf(_("Your current terms are %s for the old state\nand "
>>>> + "%s for the new state.\n"), terms->term_good,
>>>> + terms->term_bad);
>>>
>>> Very minor: It improves the readability if you'd split the string after
>>> the \n and put the "and "in the next line.
>>
>> Ah. This is because of the message. If I do the other way, then it
>> won't match the output in one of the tests in t/t6030 thus, I am
>> keeping it that way in order to avoid modifying the file t/t6030.
>
> I think I was unclear here. I was referring to the coding/layouting
> style, not to the string. I mean like writing:
>
> printf(_("Your current terms are %s for the old state\n"
> "and "%s for the new state.\n"),
> terms->term_good, terms->term_bad);
>
> The string fed to _() is the same, but it is split in a different (imho
> more readable) way: after the "\n", not after the "and ".
Thanks for clearing it out. This seems a sensible change.
>>>> + die(_("invalid argument %s for 'git bisect "
>>>> + "terms'.\nSupported options are: "
>>>> + "--term-good|--term-old and "
>>>> + "--term-bad|--term-new."), argv[i]);
>>>
>>> Hm, "return error(...)" and "die(...)" seems to be quasi-equivalent in
>>> this case. Because I am always looking from a library perspective, I'd
>>> prefer "return error(...)".
>>
>> I should use return error()
>
> When you reroll your patches, please also check if you always put _()
> around your error()s ;) (Hmmm... On the other hand, it might be arguable
> if translations are useful for errors that only occur when people hack
> git-bisect or use the bisect--helper directly... This makes me feel like
> all those errors should be prefixed by some "BUG: " marker since the
> ordinary user only sees them when there is a bug. But I don't feel in
> the position to decide or recommend such a thing, so it's just a thought.)
It is seems a good change, I will do it. Let other's comment on what
they think in the next re-roll.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 23/27] bisect--helper: `bisect_replay` shell function in C
2016-12-06 23:40 ` Stephan Beyer
@ 2016-12-07 13:15 ` Christian Couder
0 siblings, 0 replies; 320+ messages in thread
From: Christian Couder @ 2016-12-07 13:15 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Pranit Bauva, Git List, Christian Couder, Lars Schneider
Hi Stephan,
On Wed, Dec 7, 2016 at 12:40 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
> Hi Pranit and Christian and Lars ;)
>
> On 12/07/2016 12:02 AM, Pranit Bauva wrote:
>> On Tue, Nov 22, 2016 at 6:19 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
>>>
>>> Now that I have a coarse overview of what you did, I have the general
>>> remark that imho the "terms" variable should simply be global instead of
>>> being passed around all the time.
>>
>> In a personal conversation with my mentors, we thought it is the best
>> fit to keep it in a struct and pass it around so that it is easier in
>> libification.
>
> I guess you had that conversation at the beginning of the project and I
> think that at that stage I would have recommended it that way, too.
>
> However, looking at the v15 bisect--helper.c, it looks like it is rather
> a pain to do it that way. I mean, you use the terms like they were
> global variables: you initialize them in cmd_bisect__helper() and then
> you always pass them around; you update them "globally", never using
> restricted scope, never ever use a second instantiation besides the one
> of cmd_bisect__helper(). These are all signs that *in the current code*
> using (static) global variables is the better way (making the code simpler).
>
> The libification argument may be worth considering, though. I am not
> sure if there is really a use-case where you need two different
> instantiations of the terms, *except* if the lib allows bisecting with
> different terms at the same time (in different repos, of course). Is the
> lib "aware" of such use-cases like doing stuff in different repos at the
> same time? If that's the case, not using global variables is the right
> thing to do. In any other case I can imagine, I'd suggest to use global
> variables.
Yeah, I wanted to avoid global variables when there is no very good
reason for them to avoid possible libification work later.
And I don't think passing one parameter around to many functions is a
big burden.
Thanks for your reviews,
Christian.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 19/27] bisect--helper: `bisect_state` & `bisect_head` shell function in C
2016-12-06 23:54 ` Stephan Beyer
@ 2016-12-08 6:43 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-12-08 6:43 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
On Wed, Dec 7, 2016 at 5:24 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
> Hi Pranit,
>
> On 12/06/2016 11:40 PM, Pranit Bauva wrote:
>> On Tue, Nov 22, 2016 at 5:42 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
>>> On 10/14/2016 04:14 PM, Pranit Bauva wrote:
>>>> +static int bisect_state(struct bisect_terms *terms, const char **argv,
>>>> + int argc)
>>>> +{
>>>> + const char *state = argv[0];
>>>> +
>>>> + get_terms(terms);
>>>> + if (check_and_set_terms(terms, state))
>>>> + return -1;
>>>> +
>>>> + if (!argc)
>>>> + die(_("Please call `--bisect-state` with at least one argument"));
>>>
>>> I think this check should move to cmd_bisect__helper. There are also the
>>> other argument number checks.
>>
>> Not really. After the whole conversion, the cmdmode will cease to
>> exists while bisect_state will be called directly, thus it is
>> important to check it here.
>
> Okay, that's a point.
> In that case, you should probably use "return error()" again and the
> message (mentioning "--bisect-state") does not make sense when
> --bisect-state ceases to exist.
True. Will change accordingly.
>>>> +
>>>> + if (argc == 1 && one_of(state, terms->term_good,
>>>> + terms->term_bad, "skip", NULL)) {
>>>> + const char *bisected_head = xstrdup(bisect_head());
>>>> + const char *hex[1];
>>>
>>> Maybe:
>>> const char *hex;
>>>
>>>> + unsigned char sha1[20];
>>>> +
>>>> + if (get_sha1(bisected_head, sha1))
>>>> + die(_("Bad rev input: %s"), bisected_head);
>>>
>>> And instead of...
>>>
>>>> + if (bisect_write(state, sha1_to_hex(sha1), terms, 0))
>>>> + return -1;
>>>> +
>>>> + *hex = xstrdup(sha1_to_hex(sha1));
>>>> + if (check_expected_revs(hex, 1))
>>>> + return -1;
>>>
>>> ... simply:
>>>
>>> hex = xstrdup(sha1_to_hex(sha1));
>>> if (set_state(terms, state, hex)) {
>>> free(hex);
>>> return -1;
>>> }
>>> free(hex);
>>>
>>> where:
>>
>> Yes I am planning to convert all places with hex rather than the sha1
>> but not yet, maybe in an another patch series because currently a lot
>> of things revolve around sha1 and changing its behaviour wouldn't
>> really be a part of a porting patch series.
>
> I was not suggesting a change of behavior, I was suggesting a simple
> helper function set_state() to get rid of code duplication above and
> some lines below:
>
>>> ... And replace this:
>>>
>>>> + const char **hex_string = (const char **) &hex.items[i].string;
>>>> + if(bisect_write(state, *hex_string, terms, 0)) {
>>>> + string_list_clear(&hex, 0);
>>>> + return -1;
>>>> + }
>>>> + if (check_expected_revs(hex_string, 1)) {
>>>> + string_list_clear(&hex, 0);
>>>> + return -1;
>>>> + }
>>>
>>> by:
>>>
>>> const char *hex_str = hex.items[i].string;
>>> if (set_state(terms, state, hex_string)) {
>>> string_list_clear(&hex, 0);
>>> return -1;
>>> }
>
> See?
I can do this change of using set_state() keeping aside the sha1 to
hex and such change.
>>>> @@ -184,8 +137,8 @@ exit code \$res from '\$command' is < 0 or >= 128" >&2
>>>> state="$TERM_GOOD"
>>>> fi
>>>>
>>>> - # We have to use a subshell because "bisect_state" can exit.
>>>> - ( bisect_state $state >"$GIT_DIR/BISECT_RUN" )
>>>> + # We have to use a subshell because "--bisect-state" can exit.
>>>> + ( git bisect--helper --bisect-state $state >"$GIT_DIR/BISECT_RUN" )
>>>
>>> The new comment is funny, but you don't need a subshell here any
>>> longer.
>>
>> True, but right now I didn't want to modify that part of the source
>> code to remove the comment. I will remove the comment all together
>> when I port bisect_run()
> For most of the patches, I was commenting on the current state, not on
> the big picture.
>
> Still I think that it is better to remove the comment and the subshell
> instead of making the comment weird ("yes the builtin can exit, but why
> do we need a subshell?" vs "yes the shell function calls exit, so we
> need a subshell because we do not want to exit this shell script")
Sure I will remove the comment.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 08/27] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C
2016-12-06 19:33 ` Pranit Bauva
@ 2016-12-16 19:00 ` Pranit Bauva
2016-12-17 19:42 ` Stephan Beyer
0 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-12-16 19:00 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
On Wed, Dec 7, 2016 at 1:03 AM, Pranit Bauva <pranit.bauva@gmail.com> wrote:
>> I don't understand why the return value is int and not void. To avoid a
>> "return 0;" line when calling this function?
>
> Initially I thought I would be using the return value but now I
> realize that it is meaningless to do so. Using void seems better. :)
I just recollected when I was creating the next iteration of this
series that I will need that int.
>>> + case CHECK_EXPECTED_REVS:
>>> + return check_expected_revs(argv, argc);
See this.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 08/27] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C
2016-11-16 23:47 ` Stephan Beyer
2016-12-06 19:33 ` Pranit Bauva
@ 2016-12-16 19:35 ` Pranit Bauva
2016-12-17 19:55 ` Stephan Beyer
1 sibling, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-12-16 19:35 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
On Thu, Nov 17, 2016 at 5:17 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
> Hi,
>
> On 10/14/2016 04:14 PM, Pranit Bauva wrote:
>> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
>> index d84ba86..c542e8b 100644
>> --- a/builtin/bisect--helper.c
>> +++ b/builtin/bisect--helper.c
>> @@ -123,13 +123,40 @@ static int bisect_reset(const char *commit)
>> return bisect_clean_state();
>> }
>>
>> +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;
>> +}
>
> I am not sure it does what it should.
>
> I would expect the following behavior from this function:
> - file does not exist (or is "broken") => return 0
> - actual_hex != expected_hex => return 0
> - otherwise return 1
>
> If I am not wrong, the code does the following instead:
> - file does not exist (or is "broken") => return 0
> - actual_hex != expected_hex => return 1
> - otherwise => return 0
It seems that I didn't carefully see what the shell code is (or
apparently did a mistake in understanding it ;)). I think the C
version does exactly what the shell version does. Can you confirm it
once again, please?
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 08/27] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C
2016-12-16 19:00 ` Pranit Bauva
@ 2016-12-17 19:42 ` Stephan Beyer
0 siblings, 0 replies; 320+ messages in thread
From: Stephan Beyer @ 2016-12-17 19:42 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Git List
Hi Pranit,
On 12/16/2016 08:00 PM, Pranit Bauva wrote:
> On Wed, Dec 7, 2016 at 1:03 AM, Pranit Bauva <pranit.bauva@gmail.com> wrote:
>>> I don't understand why the return value is int and not void. To avoid a
>>> "return 0;" line when calling this function?
>>
>> Initially I thought I would be using the return value but now I
>> realize that it is meaningless to do so. Using void seems better. :)
>
> I just recollected when I was creating the next iteration of this
> series that I will need that int.
>
>>>> + case CHECK_EXPECTED_REVS:
>>>> + return check_expected_revs(argv, argc);
>
> See this.
This does not show that you need the "int", it just shows that you use
the return value of the function. But this return value is (in the
original shell code as well as in your v15) always 0. That is a sign
that the "void" return value makes more sense. Of course, then the line
above must be changed to
+ case CHECK_EXPECTED_REVS:
+ check_expected_revs(argv, argc);
+ return 0;
By the way, it also seems that the original function name
"check_expected_revs" was not the best choice (because the function
always returns 0, but the "check" implies that some semantically true or
false is returned).
On the other hand, it might also be useful (I cannot tell) to return
different values in check_expected_revs() — to signal the caller that
something changed or something did not change — but then ignore the
return value.
Best
Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 08/27] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C
2016-12-16 19:35 ` Pranit Bauva
@ 2016-12-17 19:55 ` Stephan Beyer
0 siblings, 0 replies; 320+ messages in thread
From: Stephan Beyer @ 2016-12-17 19:55 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Git List
Hi Pranit,
On 12/16/2016 08:35 PM, Pranit Bauva wrote:
> On Thu, Nov 17, 2016 at 5:17 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
>> On 10/14/2016 04:14 PM, Pranit Bauva wrote:
>>> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
>>> index d84ba86..c542e8b 100644
>>> --- a/builtin/bisect--helper.c
>>> +++ b/builtin/bisect--helper.c
>>> @@ -123,13 +123,40 @@ static int bisect_reset(const char *commit)
>>> return bisect_clean_state();
>>> }
>>>
>>> +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;
>>> +}
>>
>> I am not sure it does what it should.
>>
>> I would expect the following behavior from this function:
>> - file does not exist (or is "broken") => return 0
>> - actual_hex != expected_hex => return 0
>> - otherwise return 1
>>
>> If I am not wrong, the code does the following instead:
>> - file does not exist (or is "broken") => return 0
>> - actual_hex != expected_hex => return 1
>> - otherwise => return 0
>
> It seems that I didn't carefully see what the shell code is (or
> apparently did a mistake in understanding it ;)). I think the C
> version does exactly what the shell version does. Can you confirm it
> once again, please?
I check again...
The shell code does the following:
- file does not exist or is not a regular file => return false
- actual_hex != expected_hex => return false
- otherwise => return true
(false means a value != 0, true means 0)
Your code does the following:
- file cannot be read or is broken => return 0
- actual_hex != expected_hex => return 0
- otherwise => return 1
So you are very right, it seems I had a weird thinko (I probably missed
the "!" in front of strcmp or something) :)
Sorry for bothering,
Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 15/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function in C
2016-11-20 20:01 ` Stephan Beyer
@ 2016-12-31 10:23 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2016-12-31 10:23 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
Extremely sorry I just forgot to reply to this email before. I was
preparing from the next iteration when I saw this.
On Mon, Nov 21, 2016 at 1:31 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
> Hi Pranit,
>
> this one is hard to review because you do two or three commits in one here.
> I think the first commit should be the exit()->return conversion, the
> second commit is next and autonext, and the third commit is the pretty
> trivial bisect_start commit ;) However, you did it this way and it's
> always a hassle to split commit, so I don't really care...
I had confusion about how to split the commits, but then I then
decided to dump it all together so that it compiles (I was finding it
difficult to split into meaningful parts which also compiled).
> However, I was reviewing this superficially, to be honest. This mail
> skips the next and autonext part.
>
> On 10/14/2016 04:14 PM, Pranit Bauva wrote:
>> diff --git a/bisect.c b/bisect.c
>> index 45d598d..7c97e85 100644
>> --- a/bisect.c
>> +++ b/bisect.c
>> @@ -843,16 +878,21 @@ static int check_ancestors(const char *prefix)
>> *
>> * If that's not the case, we need to check the merge bases.
>> * If a merge base must be tested by the user, its source code will be
>> - * checked out to be tested by the user and we will exit.
>> + * checked out to be tested by the user and we will return.
>> */
>> -static void check_good_are_ancestors_of_bad(const char *prefix, int no_checkout)
>> +static int check_good_are_ancestors_of_bad(const char *prefix, int no_checkout)
>> {
>> char *filename = git_pathdup("BISECT_ANCESTORS_OK");
>> struct stat st;
>> - int fd;
>> + int fd, res = 0;
>>
>> + /*
>> + * We don't want to clean the bisection state
>> + * as we need to get back to where we started
>> + * by using `git bisect reset`.
>> + */
>> if (!current_bad_oid)
>> - die(_("a %s revision is needed"), term_bad);
>> + error(_("a %s revision is needed"), term_bad);
>
> Only error() or return error()?
It should be return error(). Thanks for pointing it out! :)
>> @@ -873,8 +916,11 @@ static void check_good_are_ancestors_of_bad(const char *prefix, int no_checkout)
>> filename);
>> else
>> close(fd);
>> +
>> + goto done;
>> done:
>
> I never understand why you do this. In case of adding a "fail" label
> (and fail code like "res = -1;") between "goto done" and "done:", it's
> fine... but without one this is just a nop.
I will just remove that line.
>> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
>> index 1d3e17f..fcd7574 100644
>> --- a/builtin/bisect--helper.c
>> +++ b/builtin/bisect--helper.c
>> @@ -427,15 +560,24 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
>> no_checkout = 1;
>>
>> for (i = 0; i < argc; i++) {
>> - if (!strcmp(argv[i], "--")) {
>> + const char *arg;
>> + if (starts_with(argv[i], "'"))
>> + arg = sq_dequote(xstrdup(argv[i]));
>> + else
>> + arg = argv[i];
>
> One is xstrdup'ed, one is not, so there'll be a leak somewhere, and it's
> an inconsistent leak... I guess it's a bad idea to do it this way ;)
> (Also below.)
Yes. I will use xstrdup() and it does leak.
>> @@ -443,24 +585,31 @@ static int bisect_start(struct bisect_terms *terms, int no_checkout,
>> no_checkout = 1;
>> } else if (!strcmp(arg, "--term-good") ||
>> !strcmp(arg, "--term-old")) {
>> + if (starts_with(argv[++i], "'"))
>> + terms->term_good = sq_dequote(xstrdup(argv[i]));
>> + else
>> + terms->term_good = xstrdup(argv[i]);
>> must_write_terms = 1;
>> - terms->term_good = xstrdup(argv[++i]);
>> } else if (skip_prefix(arg, "--term-good=", &arg)) {
>> must_write_terms = 1;
>> - terms->term_good = xstrdup(arg);
>> + terms->term_good = arg;
>
> No ;) (See my other comments (to other patches) for the "terms" leaks.)
Yes I have addressed this issue.
> [This repeats several times below.]
>
>> diff --git a/git-bisect.sh b/git-bisect.sh
>> index f0896b3..d574c44 100755
>> --- a/git-bisect.sh
>> +++ b/git-bisect.sh
>> @@ -109,6 +88,7 @@ bisect_skip() {
>> bisect_state() {
>> bisect_autostart
>> state=$1
>> + get_terms
>> git bisect--helper --check-and-set-terms $state $TERM_GOOD $TERM_BAD || exit
>> get_terms
>> case "$#,$state" in
>
> I can't say if this change is right or wrong. It looks right, but: How
> does this relate to the other changes? Is this the right patch for it?
This line is because of the following:
* TERM_BAD and TERM_GOOD are global but in the coming patch they
would be removed as global variables.
* To compensate for that, I will write out the state of TERM_BAD and
TERM_GOOD every time it is updated in the file BISECT_TERMS.
* So we will be reading it from there.
* It is quite possible that this is completely redundant as for now
but I really don't care to check for each case because I have removed
the shell function bisect_state() afterwards and then this line won't
create a problem there because we are using `struct bisect_terms`
there.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 15/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function in C
2016-11-21 21:35 ` Stephan Beyer
@ 2016-12-31 10:43 ` Pranit Bauva
2017-01-01 16:27 ` Stephan Beyer
0 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2016-12-31 10:43 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
On Tue, Nov 22, 2016 at 3:05 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
> Hi Pranit,
>
> in this mail I review the "second part" of your patch: the transition of
> bisect_next and bisect_auto_next to C.
>
> On 10/14/2016 04:14 PM, Pranit Bauva wrote:
>> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
>> index 1d3e17f..fcd7574 100644
>> --- a/builtin/bisect--helper.c
>> +++ b/builtin/bisect--helper.c
>> @@ -408,6 +411,136 @@ static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
>> return 0;
>> }
>>
>> +static int register_good_ref(const char *refname,
>> + const struct object_id *oid, int flags,
>> + void *cb_data)
>> +{
>> + struct string_list *good_refs = cb_data;
>> + string_list_append(good_refs, oid_to_hex(oid));
>> + return 0;
>> +}
>> +
>> +static int bisect_next(struct bisect_terms *terms, const char *prefix)
>> +{
>> + int res, no_checkout;
>> +
>> + /*
>> + * 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".
>> + */
>
> The comment above makes no sense here, or does it?
No it doesn't right now. I had this initally because I was trying to
keep bisect_clean_state() call inside this function but then I
realized it should be placed elsewhere. I will remove this.
>> + if (bisect_next_check(terms, terms->term_good))
>> + return -1;
>> +
>> + no_checkout = !is_empty_or_missing_file(git_path_bisect_head());
>> +
>> + /* Perform all bisection computation, display and checkout */
>> + res = bisect_next_all(prefix , no_checkout);
>
> Style: there is a space left of the comma.
Nice catch! ;) I have gone through this patch so many times, yet I
have forgot to notice this.
>> +
>> + if (res == 10) {
>> + FILE *fp = NULL;
>> + unsigned char sha1[20];
>> + struct commit *commit;
>> + struct pretty_print_context pp = {0};
>> + struct strbuf commit_name = STRBUF_INIT;
>> + char *bad_ref = xstrfmt("refs/bisect/%s",
>> + terms->term_bad);
>> + int retval = 0;
>> +
>> + read_ref(bad_ref, sha1);
>> + commit = lookup_commit_reference(sha1);
>> + format_commit_message(commit, "%s", &commit_name, &pp);
>> + fp = fopen(git_path_bisect_log(), "a");
>> + if (!fp) {
>> + retval = -1;
>> + goto finish_10;
>> + }
>> + if (fprintf(fp, "# first %s commit: [%s] %s\n",
>> + terms->term_bad, sha1_to_hex(sha1),
>> + commit_name.buf) < 1){
>> + retval = -1;
>> + goto finish_10;
>> + }
>> + goto finish_10;
>> + finish_10:
>> + if (fp)
>> + fclose(fp);
>> + strbuf_release(&commit_name);
>> + free(bad_ref);
>> + return retval;
>> + }
>> + else if (res == 2) {
>> + FILE *fp = NULL;
>> + struct rev_info revs;
>> + struct argv_array rev_argv = ARGV_ARRAY_INIT;
>> + struct string_list good_revs = STRING_LIST_INIT_DUP;
>> + struct pretty_print_context pp = {0};
>> + struct commit *commit;
>> + char *term_good = xstrfmt("%s-*", terms->term_good);
>> + int i, retval = 0;
>> +
>> + fp = fopen(git_path_bisect_log(), "a");
>> + if (!fp) {
>> + retval = -1;
>> + goto finish_2;
>> + }
>> + if (fprintf(fp, "# only skipped commits left to test\n") < 1) {
>> + retval = -1;
>> + goto finish_2;
>> + }
>> + for_each_glob_ref_in(register_good_ref, term_good,
>> + "refs/bisect/", (void *) &good_revs);
>> +
>> + argv_array_pushl(&rev_argv, "skipped_commits", "refs/bisect/bad", "--not", NULL);
>> + for (i = 0; i < good_revs.nr; i++)
>> + argv_array_push(&rev_argv, good_revs.items[i].string);
>> +
>> + /* It is important to reset the flags used by revision walks
>> + * as the previous call to bisect_next_all() in turn
>> + * setups a revision walk.
>> + */
>> + reset_revision_walk();
>> + init_revisions(&revs, NULL);
>> + rev_argv.argc = setup_revisions(rev_argv.argc, rev_argv.argv, &revs, NULL);
>> + argv_array_clear(&rev_argv);
>> + string_list_clear(&good_revs, 0);
>> + if (prepare_revision_walk(&revs))
>> + die(_("revision walk setup failed\n"));
>> +
>> + while ((commit = get_revision(&revs)) != NULL) {
>> + struct strbuf commit_name = STRBUF_INIT;
>> + format_commit_message(commit, "%s",
>> + &commit_name, &pp);
>> + fprintf(fp, "# possible first %s commit: "
>> + "[%s] %s\n", terms->term_bad,
>> + oid_to_hex(&commit->object.oid),
>> + commit_name.buf);
>> + strbuf_release(&commit_name);
>> + }
>> + goto finish_2;
>> + finish_2:
>> + if (fp)
>> + fclose(fp);
>> + string_list_clear(&good_revs, 0);
>> + argv_array_clear(&rev_argv);
>> + free(term_good);
>> + if (retval)
>> + return retval;
>> + else
>> + return res;
>> + }
>> + return res;
>> +}
>
> It would be much nicer if you put the (res == 10) branch and the
> (res == 2) branch into separate functions and just call them.
> Then you also won't need ugly label naming like finish_10 or finish_2.
> I'd also (again) recommend to use goto fail instead of setting retval to
> -1 separately each time.
Yes, that seems a better way to go! Thanks! :)
> I'd also recommend to use a separate function to append to the bisect
> log file. There is a lot of duplicated opening, checking, closing code;
> IIRC such a function would also already be handy for some of the
> previous patches.
True. I have made that function. Will reuse it here. Thanks! :)
>> +
>> +static int bisect_auto_next(struct bisect_terms *terms, const char *prefix)
>> +{
>> + if (!bisect_next_check(terms, NULL))
>> + return bisect_next(terms, prefix);
>> +
>> + return 0;
>> +}
>
> Hmm, the handling of the return values is a little confusing. However,
> if I understand the sh source correctly, it always returns success, no
> matter if bisect_next failed or not. I do not know if you had something
> special in mind here.
Umm. Shell code used to die() and thus exit with an error code. Thus
it is important to return the exit code. Handling return values was
*very confusing* for me too while writing this commit ;) A lot of
behaviour is changed in this commit regarding return values.
>> int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
>> @@ -643,6 +794,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
>> N_("print out the bisect terms"), BISECT_TERMS),
>> OPT_CMDMODE(0, "bisect-start", &cmdmode,
>> N_("start the bisect session"), BISECT_START),
>> + OPT_CMDMODE(0, "bisect-next", &cmdmode,
>> + N_("find the next bisection commit"), BISECT_NEXT),
>> + OPT_CMDMODE(0, "bisect-auto-next", &cmdmode,
>> + N_("verify the next bisection state then find the next bisection state"), BISECT_AUTO_NEXT),
>
> The next bisection *state* is found?
checkout is more appropriate. I don't remember why I used "find".
>> diff --git a/git-bisect.sh b/git-bisect.sh
>> index f0896b3..d574c44 100755
>> --- a/git-bisect.sh
>> +++ b/git-bisect.sh
>> @@ -139,45 +119,7 @@ bisect_state() {
>> *)
>> usage ;;
>> esac
>> - bisect_auto_next
> [...deleted lines...]
>> + git bisect--helper --bisect-auto-next || exit
>
> Why is the "|| exit" necessary?
Since it returning exit code, we need to quit, see earlier comment.
Earlier in shell script we used die() but now we are using return
error() thus we need to make it exit here too.
>> @@ -319,14 +260,15 @@ case "$#" in
>> help)
>> git bisect -h ;;
>> start)
>> - bisect_start "$@" ;;
>> + git bisect--helper --bisect-start "$@" ;;
>> bad|good|new|old|"$TERM_BAD"|"$TERM_GOOD")
>> bisect_state "$cmd" "$@" ;;
>> skip)
>> bisect_skip "$@" ;;
>> next)
>> # Not sure we want "next" at the UI level anymore.
>> - bisect_next "$@" ;;
>> + get_terms
>> + git bisect--helper --bisect-next "$@" || exit ;;
>
> Why is the "|| exit" necessary? ;)
Same as before.
>
> Furthermore:
> Where is the bisect_autostart call from bisect_next() sh source gone?
> Was it not necessary?
It is necessary, but I couldn't just incorporate it in one commit. The
functions are called in a circular fashion. Thus I skipped
bisect_autostart() as for now but then when I managed to port
bisect_autostart(), I called that function from this.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 15/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function in C
2016-12-31 10:43 ` Pranit Bauva
@ 2017-01-01 16:27 ` Stephan Beyer
2017-01-01 17:41 ` Pranit Bauva
0 siblings, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2017-01-01 16:27 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Git List
Hi Pranit,
On 12/31/2016 11:43 AM, Pranit Bauva wrote:
>>> +
>>> +static int bisect_auto_next(struct bisect_terms *terms, const char *prefix)
>>> +{
>>> + if (!bisect_next_check(terms, NULL))
>>> + return bisect_next(terms, prefix);
>>> +
>>> + return 0;
>>> +}
>>
>> Hmm, the handling of the return values is a little confusing. However,
>> if I understand the sh source correctly, it always returns success, no
>> matter if bisect_next failed or not. I do not know if you had something
>> special in mind here.
>
> Umm. Shell code used to die() and thus exit with an error code.
The invoked bisect_next shell code called "exit", right... you had to
replace this by passing return values. I get it. Thank you!
>>> int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
>>> @@ -643,6 +794,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
>>> N_("print out the bisect terms"), BISECT_TERMS),
>>> OPT_CMDMODE(0, "bisect-start", &cmdmode,
>>> N_("start the bisect session"), BISECT_START),
>>> + OPT_CMDMODE(0, "bisect-next", &cmdmode,
>>> + N_("find the next bisection commit"), BISECT_NEXT),
>>> + OPT_CMDMODE(0, "bisect-auto-next", &cmdmode,
>>> + N_("verify the next bisection state then find the next bisection state"), BISECT_AUTO_NEXT),
>>
>> The next bisection *state* is found?
>
> checkout is more appropriate. I don't remember why I used "find".
"checkout the next bisection commit" maybe?
Thanks,
Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v15 15/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function in C
2017-01-01 16:27 ` Stephan Beyer
@ 2017-01-01 17:41 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-01-01 17:41 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
On Sun, Jan 1, 2017 at 9:57 PM, Stephan Beyer <s-beyer@gmx.net> wrote:
>>>> int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
>>>> @@ -643,6 +794,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
>>>> N_("print out the bisect terms"), BISECT_TERMS),
>>>> OPT_CMDMODE(0, "bisect-start", &cmdmode,
>>>> N_("start the bisect session"), BISECT_START),
>>>> + OPT_CMDMODE(0, "bisect-next", &cmdmode,
>>>> + N_("find the next bisection commit"), BISECT_NEXT),
>>>> + OPT_CMDMODE(0, "bisect-auto-next", &cmdmode,
>>>> + N_("verify the next bisection state then find the next bisection state"), BISECT_AUTO_NEXT),
>>>
>>> The next bisection *state* is found?
>>
>> checkout is more appropriate. I don't remember why I used "find".
>
> "checkout the next bisection commit" maybe?
Seems better. Thanks!
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* [PATCH v16 2/6] bisect--helper: rewrite `check_term_format` shell function in C
2017-09-29 6:49 ` [PATCH v16 1/6] " Pranit Bauva
@ 2017-09-29 6:49 ` Pranit Bauva
2017-09-29 6:49 ` [PATCH v16 4/6] bisect--helper: `bisect_clean_state` " Pranit Bauva
` (6 subsequent siblings)
7 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-09-29 6:49 UTC (permalink / raw)
To: git
Reimplement the `check_term_format` shell function in C and add
a `--check-term-format` subcommand to `git bisect--helper` to call it
from git-bisect.sh
Using `--check-term-format` subcommand is a temporary measure to port
shell function to C so as to use the existing test suite. As more
functions are ported, this subcommand will be retired and its
implementation will be called by some other method/subcommand. For
eg. In conversion of write_terms() of git-bisect.sh, the subcommand will
be removed and instead check_term_format() will be called in its C
implementation while a new subcommand will be introduced for write_terms().
Helped-by: Johannes Schindelein <Johannes.Schindelein@gmx.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 60 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 31 ++-----------------------
2 files changed, 61 insertions(+), 30 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index b6ee0acb82765..db9091e249454 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -2,19 +2,73 @@
#include "cache.h"
#include "parse-options.h"
#include "bisect.h"
+#include "refs.h"
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
+ N_("git bisect--helper --check-term-format <term> <orig_term>"),
NULL
};
+/*
+ * 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",
+ "visualize", "replay", "log", "run", "terms", NULL))
+ 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;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
- enum { NEXT_ALL = 1 } cmdmode = 0;
+ enum {
+ NEXT_ALL = 1,
+ CHECK_TERM_FMT
+ } cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
+ OPT_CMDMODE(0, "check-term-format", &cmdmode,
+ N_("check format of the term"), CHECK_TERM_FMT),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -29,6 +83,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
switch (cmdmode) {
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
+ case CHECK_TERM_FMT:
+ if (argc != 2)
+ return error(_("--check-term-format requires two arguments"));
+ return check_term_format(argv[0], argv[1]);
default:
return error("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index ae3cb013e7d56..a727c59250f13 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -564,38 +564,11 @@ write_terms () {
then
die "$(gettext "please use two different terms")"
fi
- check_term_format "$TERM_BAD" bad
- check_term_format "$TERM_GOOD" good
+ git bisect--helper --check-term-format "$TERM_BAD" bad || exit
+ git bisect--helper --check-term-format "$TERM_GOOD" good || exit
printf '%s\n%s\n' "$TERM_BAD" "$TERM_GOOD" >"$GIT_DIR/BISECT_TERMS"
}
-check_term_format () {
- term=$1
- git check-ref-format refs/bisect/"$term" ||
- die "$(eval_gettext "'\$term' is not a valid term")"
- case "$term" in
- help|start|terms|skip|next|reset|visualize|replay|log|run)
- die "$(eval_gettext "can't use the builtin command '\$term' as a term")"
- ;;
- bad|new)
- if test "$2" != bad
- then
- # 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.
- die "$(eval_gettext "can't change the meaning of term '\$term'")"
- fi
- ;;
- good|old)
- if test "$2" != good
- then
- die "$(eval_gettext "can't change the meaning of term '\$term'")"
- fi
- ;;
- esac
-}
-
check_and_set_terms () {
cmd="$1"
case "$cmd" in
--
https://github.com/git/git/pull/410
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v16 5/6] t6030: explicitly test for bisection cleanup
2017-09-29 6:49 ` [PATCH v16 1/6] " Pranit Bauva
` (2 preceding siblings ...)
2017-09-29 6:49 ` [PATCH v16 3/6] bisect--helper: `write_terms` " Pranit Bauva
@ 2017-09-29 6:49 ` Pranit Bauva
2017-09-29 6:49 ` [PATCH v16 6/6] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C Pranit Bauva
` (3 subsequent siblings)
7 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-09-29 6:49 UTC (permalink / raw)
To: git
Add test to explicitly check that 'git bisect reset' is working as
expected. This is already covered implicitly by the test suite.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
I faced this problem while converting `bisect_clean_state` and the tests
where showing breakages but it wasn't clear as to where exactly are they
breaking. This will patch will help in that. Also I tested the test
coverage of the test suite before this patch and it covers this (I did
this by purposely changing names of files in git-bisect.sh and running
the test suite).
---
t/t6030-bisect-porcelain.sh | 17 +++++++++++++++++
1 file changed, 17 insertions(+)
diff --git a/t/t6030-bisect-porcelain.sh b/t/t6030-bisect-porcelain.sh
index 8c2c6eaef83fe..f84ff941c3624 100755
--- a/t/t6030-bisect-porcelain.sh
+++ b/t/t6030-bisect-porcelain.sh
@@ -894,4 +894,21 @@ test_expect_success 'bisect start takes options and revs in any order' '
test_cmp expected actual
'
+test_expect_success 'git bisect reset cleans bisection state properly' '
+ git bisect reset &&
+ git bisect start &&
+ git bisect good $HASH1 &&
+ git bisect bad $HASH4 &&
+ git bisect reset &&
+ test -z "$(git for-each-ref "refs/bisect/*")" &&
+ test_path_is_missing "$GIT_DIR/BISECT_EXPECTED_REV" &&
+ test_path_is_missing "$GIT_DIR/BISECT_ANCESTORS_OK" &&
+ test_path_is_missing "$GIT_DIR/BISECT_LOG" &&
+ test_path_is_missing "$GIT_DIR/BISECT_RUN" &&
+ test_path_is_missing "$GIT_DIR/BISECT_TERMS" &&
+ test_path_is_missing "$GIT_DIR/head-name" &&
+ test_path_is_missing "$GIT_DIR/BISECT_HEAD" &&
+ test_path_is_missing "$GIT_DIR/BISECT_START"
+'
+
test_done
--
https://github.com/git/git/pull/410
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v16 1/6] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2016-10-14 15:12 ` [PATCH v15 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
@ 2017-09-29 6:49 ` Pranit Bauva
2017-09-29 6:49 ` [PATCH v16 2/6] bisect--helper: rewrite `check_term_format` shell function in C Pranit Bauva
` (7 more replies)
0 siblings, 8 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-09-29 6:49 UTC (permalink / raw)
To: git
`--next-all` is meant to be used as a subcommand to support multiple
"operation mode" though the current implementation does not contain any
other subcommand along side with `--next-all` but further commits will
include some more subcommands.
Helped-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
Hey,
It has been a long time since this series appeared on the mailing list.
The previous version v15[1] is now split into many parts and I am
sending the first part right now, will focus on getting this merged and
then send out the next part.
The changes in this part:
* Stephan pointed out that "terms" was missing in patch 2 ie.
"bisect--helper: rewrite `check_term_format` shell function in C"
[1]:
https://public-inbox.org/git/CAFZEwPOjK25m84BgTF7AL72DL_K1dHf7OrYoX=_vky9r3GayNw@mail.gmail.com/
---
builtin/bisect--helper.c | 17 +++++++++++------
1 file changed, 11 insertions(+), 6 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 3324229025300..b6ee0acb82765 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -10,11 +10,11 @@ static const char * const git_bisect_helper_usage[] = {
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
- int next_all = 0;
+ enum { NEXT_ALL = 1 } cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
- OPT_BOOL(0, "next-all", &next_all,
- N_("perform 'git bisect next'")),
+ OPT_CMDMODE(0, "next-all", &cmdmode,
+ N_("perform 'git bisect next'"), NEXT_ALL),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -23,9 +23,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
argc = parse_options(argc, argv, prefix, options,
git_bisect_helper_usage, 0);
- if (!next_all)
+ if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
- /* next-all */
- return bisect_next_all(prefix, no_checkout);
+ switch (cmdmode) {
+ case NEXT_ALL:
+ return bisect_next_all(prefix, no_checkout);
+ default:
+ return error("BUG: unknown subcommand '%d'", cmdmode);
+ }
+ return 0;
}
--
https://github.com/git/git/pull/410
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v16 4/6] bisect--helper: `bisect_clean_state` shell function in C
2017-09-29 6:49 ` [PATCH v16 1/6] " Pranit Bauva
2017-09-29 6:49 ` [PATCH v16 2/6] bisect--helper: rewrite `check_term_format` shell function in C Pranit Bauva
@ 2017-09-29 6:49 ` Pranit Bauva
2017-09-29 6:49 ` [PATCH v16 3/6] bisect--helper: `write_terms` " Pranit Bauva
` (5 subsequent siblings)
7 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-09-29 6:49 UTC (permalink / raw)
To: git
Reimplement `bisect_clean_state` shell function in C and add a
`bisect-clean-state` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Using `--bisect-clean-state` subcommand is a measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by bisect_reset() and bisect_start().
Also introduce a function `mark_for_removal` to store the refs which
need to be removed while iterating through the refs.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
bisect.c | 42 ++++++++++++++++++++++++++++++++++++++++++
bisect.h | 2 ++
builtin/bisect--helper.c | 10 +++++++++-
git-bisect.sh | 26 +++-----------------------
4 files changed, 56 insertions(+), 24 deletions(-)
diff --git a/bisect.c b/bisect.c
index 2549eaf7b1515..d8c4425812eb0 100644
--- a/bisect.c
+++ b/bisect.c
@@ -433,7 +433,12 @@ static int read_bisect_refs(void)
static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
+static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
+static GIT_PATH_FUNC(git_path_bisect_run, "BISECT_RUN")
+static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
+static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
+static GIT_PATH_FUNC(git_path_head_name, "head-name")
static void read_bisect_paths(struct argv_array *array)
{
@@ -1043,3 +1048,40 @@ int estimate_bisect_steps(int all)
return (e < 3 * x) ? n : n - 1;
}
+
+static int mark_for_removal(const char *refname, const struct object_id *oid,
+ int flag, void *cb_data)
+{
+ struct string_list *refs = cb_data;
+ char *ref = xstrfmt("refs/bisect%s", refname);
+ string_list_append(refs, ref);
+ return 0;
+}
+
+int bisect_clean_state(void)
+{
+ int result = 0;
+
+ /* There may be some refs packed during bisection */
+ struct string_list refs_for_removal = STRING_LIST_INIT_NODUP;
+ for_each_ref_in("refs/bisect", mark_for_removal, (void *) &refs_for_removal);
+ string_list_append(&refs_for_removal, xstrdup("BISECT_HEAD"));
+ result = delete_refs("bisect: remove", &refs_for_removal, REF_NODEREF);
+ refs_for_removal.strdup_strings = 1;
+ string_list_clear(&refs_for_removal, 0);
+ unlink_or_warn(git_path_bisect_expected_rev());
+ unlink_or_warn(git_path_bisect_ancestors_ok());
+ unlink_or_warn(git_path_bisect_log());
+ unlink_or_warn(git_path_bisect_names());
+ unlink_or_warn(git_path_bisect_run());
+ unlink_or_warn(git_path_bisect_terms());
+ /* Cleanup head-name if it got left by an old version of git-bisect */
+ unlink_or_warn(git_path_head_name());
+ /*
+ * Cleanup BISECT_START last to support the --no-checkout option
+ * introduced in the commit 4796e823a.
+ */
+ unlink_or_warn(git_path_bisect_start());
+
+ return result;
+}
diff --git a/bisect.h b/bisect.h
index acd12ef802c61..0ae63d4616dc6 100644
--- a/bisect.h
+++ b/bisect.h
@@ -28,4 +28,6 @@ extern int estimate_bisect_steps(int all);
extern void read_bisect_terms(const char **bad, const char **good);
+extern int bisect_clean_state(void);
+
#endif
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 2bd2d396e335d..0f4d4e41cf233 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -9,6 +9,7 @@ static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
+ N_("git bisect--helper --bisect-clean-state"),
NULL
};
@@ -83,7 +84,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
- WRITE_TERMS
+ WRITE_TERMS,
+ BISECT_CLEAN_STATE
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -91,6 +93,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("perform 'git bisect next'"), NEXT_ALL),
OPT_CMDMODE(0, "write-terms", &cmdmode,
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
+ OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
+ N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -109,6 +113,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc != 2)
return error(_("--write-terms requires two arguments"));
return write_terms(argv[0], argv[1]);
+ case BISECT_CLEAN_STATE:
+ if (argc != 0)
+ return error(_("--bisect-clean-state requires no arguments"));
+ return bisect_clean_state();
default:
return error("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index a80fc44e524f2..045830c399873 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -186,7 +186,7 @@ bisect_start() {
#
# Get rid of any old bisect state.
#
- bisect_clean_state || exit
+ git bisect--helper --bisect-clean-state || exit
#
# Change state.
@@ -195,7 +195,7 @@ bisect_start() {
# We have to trap this to be able to clean up using
# "bisect_clean_state".
#
- trap 'bisect_clean_state' 0
+ trap 'git bisect--helper --bisect-clean-state' 0
trap 'exit 255' 1 2 3 15
#
@@ -430,27 +430,7 @@ bisect_reset() {
die "$(eval_gettext "Could not check out original HEAD '\$branch'.
Try 'git bisect reset <commit>'.")"
fi
- bisect_clean_state
-}
-
-bisect_clean_state() {
- # There may be some refs packed during bisection.
- git for-each-ref --format='%(refname) %(objectname)' refs/bisect/\* |
- while read ref hash
- do
- git update-ref -d $ref $hash || exit
- done
- rm -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
- rm -f "$GIT_DIR/BISECT_ANCESTORS_OK" &&
- rm -f "$GIT_DIR/BISECT_LOG" &&
- rm -f "$GIT_DIR/BISECT_NAMES" &&
- rm -f "$GIT_DIR/BISECT_RUN" &&
- rm -f "$GIT_DIR/BISECT_TERMS" &&
- # Cleanup head-name if it got left by an old version of git-bisect
- rm -f "$GIT_DIR/head-name" &&
- git update-ref -d --no-deref BISECT_HEAD &&
- # clean up BISECT_START last
- rm -f "$GIT_DIR/BISECT_START"
+ git bisect--helper --bisect-clean-state || exit
}
bisect_replay () {
--
https://github.com/git/git/pull/410
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v16 3/6] bisect--helper: `write_terms` shell function in C
2017-09-29 6:49 ` [PATCH v16 1/6] " Pranit Bauva
2017-09-29 6:49 ` [PATCH v16 2/6] bisect--helper: rewrite `check_term_format` shell function in C Pranit Bauva
2017-09-29 6:49 ` [PATCH v16 4/6] bisect--helper: `bisect_clean_state` " Pranit Bauva
@ 2017-09-29 6:49 ` Pranit Bauva
2017-09-29 6:49 ` [PATCH v16 5/6] t6030: explicitly test for bisection cleanup Pranit Bauva
` (4 subsequent siblings)
7 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-09-29 6:49 UTC (permalink / raw)
To: git
Reimplement the `write_terms` shell function in C and add a `write-terms`
subcommand to `git bisect--helper` to call it from git-bisect.sh . Also
remove the subcommand `--check-term-format` as it can now be called from
inside the function write_terms() C implementation.
Also `|| exit` is added when calling write-terms subcommand from
git-bisect.sh so as to exit whenever there is an error.
Using `--write-terms` subcommand is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and its implementation will
be called by some other method.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 36 +++++++++++++++++++++++++++++-------
git-bisect.sh | 22 +++++++---------------
2 files changed, 36 insertions(+), 22 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index db9091e249454..2bd2d396e335d 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -4,9 +4,11 @@
#include "bisect.h"
#include "refs.h"
+static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
+
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
- N_("git bisect--helper --check-term-format <term> <orig_term>"),
+ N_("git bisect--helper --write-terms <bad_term> <good_term>"),
NULL
};
@@ -57,18 +59,38 @@ static int check_term_format(const char *term, const char *orig_term)
return 0;
}
+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;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
- CHECK_TERM_FMT
+ WRITE_TERMS
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
- OPT_CMDMODE(0, "check-term-format", &cmdmode,
- N_("check format of the term"), CHECK_TERM_FMT),
+ OPT_CMDMODE(0, "write-terms", &cmdmode,
+ N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -83,10 +105,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
switch (cmdmode) {
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
- case CHECK_TERM_FMT:
+ case WRITE_TERMS:
if (argc != 2)
- return error(_("--check-term-format requires two arguments"));
- return check_term_format(argv[0], argv[1]);
+ return error(_("--write-terms requires two arguments"));
+ return write_terms(argv[0], argv[1]);
default:
return error("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index a727c59250f13..a80fc44e524f2 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -209,7 +209,7 @@ bisect_start() {
eval "$eval true" &&
if test $must_write_terms -eq 1
then
- write_terms "$TERM_BAD" "$TERM_GOOD"
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
fi &&
echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
#
@@ -557,18 +557,6 @@ get_terms () {
fi
}
-write_terms () {
- TERM_BAD=$1
- TERM_GOOD=$2
- if test "$TERM_BAD" = "$TERM_GOOD"
- then
- die "$(gettext "please use two different terms")"
- fi
- git bisect--helper --check-term-format "$TERM_BAD" bad || exit
- git bisect--helper --check-term-format "$TERM_GOOD" good || exit
- printf '%s\n%s\n' "$TERM_BAD" "$TERM_GOOD" >"$GIT_DIR/BISECT_TERMS"
-}
-
check_and_set_terms () {
cmd="$1"
case "$cmd" in
@@ -582,13 +570,17 @@ check_and_set_terms () {
bad|good)
if ! test -s "$GIT_DIR/BISECT_TERMS"
then
- write_terms bad good
+ TERM_BAD=bad
+ TERM_GOOD=good
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
fi
;;
new|old)
if ! test -s "$GIT_DIR/BISECT_TERMS"
then
- write_terms new old
+ TERM_BAD=new
+ TERM_GOOD=old
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
fi
;;
esac ;;
--
https://github.com/git/git/pull/410
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v16 6/6] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C
2017-09-29 6:49 ` [PATCH v16 1/6] " Pranit Bauva
` (3 preceding siblings ...)
2017-09-29 6:49 ` [PATCH v16 5/6] t6030: explicitly test for bisection cleanup Pranit Bauva
@ 2017-09-29 6:49 ` Pranit Bauva
2017-11-19 20:34 ` Christian Couder
2017-09-29 18:54 ` [PATCH v16 1/6] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Stephan Beyer
` (2 subsequent siblings)
7 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2017-09-29 6:49 UTC (permalink / raw)
To: git
Reimplement `is_expected_rev` & `check_expected_revs` shell function in
C and add a `--check-expected-revs` subcommand to `git bisect--helper` to
call it from git-bisect.sh .
Using `--check-expected-revs` subcommand is a temporary measure to port
shell functions to C so as to use the existing test suite. As more
functions are ported, this subcommand would be retired but its
implementation will be called by some other method.
Helped-by: Eric Sunshine <sunshine@sunshineco.com>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 34 +++++++++++++++++++++++++++++++++-
git-bisect.sh | 20 ++------------------
2 files changed, 35 insertions(+), 19 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 0f4d4e41cf233..35d2105f941c6 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -5,6 +5,8 @@
#include "refs.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
+static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
+static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
@@ -80,12 +82,37 @@ static int write_terms(const char *bad, const char *good)
return (res < 0) ? -1 : 0;
}
+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());
+ }
+ }
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
WRITE_TERMS,
- BISECT_CLEAN_STATE
+ BISECT_CLEAN_STATE,
+ CHECK_EXPECTED_REVS
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -95,6 +122,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
+ OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
+ N_("check for expected revs"), CHECK_EXPECTED_REVS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -117,6 +146,9 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc != 0)
return error(_("--bisect-clean-state requires no arguments"));
return bisect_clean_state();
+ case CHECK_EXPECTED_REVS:
+ check_expected_revs(argv, argc);
+ return 0;
default:
return error("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 045830c399873..0138a8860e377 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -237,22 +237,6 @@ bisect_write() {
test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
}
-is_expected_rev() {
- test -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
- test "$1" = $(cat "$GIT_DIR/BISECT_EXPECTED_REV")
-}
-
-check_expected_revs() {
- for _rev in "$@"; do
- if ! is_expected_rev "$_rev"
- then
- rm -f "$GIT_DIR/BISECT_ANCESTORS_OK"
- rm -f "$GIT_DIR/BISECT_EXPECTED_REV"
- return
- fi
- done
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -280,7 +264,7 @@ bisect_state() {
rev=$(git rev-parse --verify "$bisected_head") ||
die "$(eval_gettext "Bad rev input: \$bisected_head")"
bisect_write "$state" "$rev"
- check_expected_revs "$rev" ;;
+ git bisect--helper --check-expected-revs "$rev" ;;
2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
shift
hash_list=''
@@ -294,7 +278,7 @@ bisect_state() {
do
bisect_write "$state" "$rev"
done
- check_expected_revs $hash_list ;;
+ git bisect--helper --check-expected-revs $hash_list ;;
*,"$TERM_BAD")
die "$(eval_gettext "'git bisect \$TERM_BAD' can take only one argument.")" ;;
*)
--
https://github.com/git/git/pull/410
^ permalink raw reply related [flat|nested] 320+ messages in thread
* Re: [PATCH v16 1/6] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2017-09-29 6:49 ` [PATCH v16 1/6] " Pranit Bauva
` (4 preceding siblings ...)
2017-09-29 6:49 ` [PATCH v16 6/6] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C Pranit Bauva
@ 2017-09-29 18:54 ` Stephan Beyer
2017-09-29 21:10 ` Pranit Bauva
2017-09-30 12:59 ` Ramsay Jones
2017-10-27 15:06 ` [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
7 siblings, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2017-09-29 18:54 UTC (permalink / raw)
To: Pranit Bauva, git; +Cc: Junio C Hamano
Hi Pranit,
On 09/29/2017 08:49 AM, Pranit Bauva wrote:
> It has been a long time since this series appeared on the mailing list.
> The previous version v15[1] is now split into many parts and I am
> sending the first part right now, will focus on getting this merged and
> then send out the next part.
That's a good idea!
I just reviewed your series by assuming I did the v15 review well (it
took quite some time at least)... so I just diff'ed the v15 and the v16
patches. I am totally fine with it!
Thanks,
Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 1/6] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2017-09-29 18:54 ` [PATCH v16 1/6] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Stephan Beyer
@ 2017-09-29 21:10 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-09-29 21:10 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List, Junio C Hamano
Hey Stephan,
On Sat, Sep 30, 2017 at 12:24 AM, Stephan Beyer <s-beyer@gmx.net> wrote:
>
> Hi Pranit,
>
> On 09/29/2017 08:49 AM, Pranit Bauva wrote:
> > It has been a long time since this series appeared on the mailing list.
> > The previous version v15[1] is now split into many parts and I am
> > sending the first part right now, will focus on getting this merged and
> > then send out the next part.
>
> That's a good idea!
>
> I just reviewed your series by assuming I did the v15 review well (it
> took quite some time at least)... so I just diff'ed the v15 and the v16
> patches. I am totally fine with it!
Thanks for having the patience of waiting for it and reviewing it again.
Regards,
Pranit Bauva
www.bauva.com
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 1/6] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2017-09-29 6:49 ` [PATCH v16 1/6] " Pranit Bauva
` (5 preceding siblings ...)
2017-09-29 18:54 ` [PATCH v16 1/6] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Stephan Beyer
@ 2017-09-30 12:59 ` Ramsay Jones
2017-10-02 13:44 ` Pranit Bauva
2017-10-27 15:06 ` [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
7 siblings, 1 reply; 320+ messages in thread
From: Ramsay Jones @ 2017-09-30 12:59 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git, Junio C Hamano
On 29/09/17 07:49, Pranit Bauva wrote:
> `--next-all` is meant to be used as a subcommand to support multiple
> "operation mode" though the current implementation does not contain any
> other subcommand along side with `--next-all` but further commits will
> include some more subcommands.
>
> Helped-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
> Mentored-by: Lars Schneider <larsxschneider@gmail.com>
> Mentored-by: Christian Couder <chriscool@tuxfamily.org>
> Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
>
> ---
> Hey,
>
> It has been a long time since this series appeared on the mailing list.
> The previous version v15[1] is now split into many parts and I am
> sending the first part right now, will focus on getting this merged and
> then send out the next part.
>
> The changes in this part:
> * Stephan pointed out that "terms" was missing in patch 2 ie.
> "bisect--helper: rewrite `check_term_format` shell function in C"
>
> [1]:
> https://public-inbox.org/git/CAFZEwPOjK25m84BgTF7AL72DL_K1dHf7OrYoX=_vky9r3GayNw@mail.gmail.com/
Hi Pranit,
Just before Junio dropped your 'pb/bisect' branch from his
repository (and What's cooking), I fetched it locally with
the intention of finishing it off. (It would have been silly
to waste all your good work).
Although I have rebased your branch a few times, and added
a few commits while 'reading' the code, I haven't actually
added much to your branch (only 12 commits and I had meant
to squash some of those together)!
However, there were some bug fixes in there, so you may want
to take a look at:
git://repo.or.cz/git/raj.git branch 'bisect'
[the 'pb-bisect' branch was the original branch from Junio,
including the 'SQUASH' commit that I squashed!]
These patches seem to relate to patches 1-5 & 8 of the original
series. The diff between these patches and the first 6 patches
of my bisect branch is given below. Note that most of the diff
seems to be caused by swapping patch #6 for #8, but not all of
the hunks are caused by this.
Note that I moved some code between patches (e.g. some of the
GIT_PATH_FUNC()s moved out of patch #4, because they were not
used in that patch. Ah, is that why you moved patch #8 up?).
[Also I added the 'bisect clean' message to delet_refs() to
patch #4 as well.]
Look for []-ed comments in the commit messages for a note of
the changes I made to your original patches, in patches #2,
#4, #7-9, #11-12 and #14.
The commits I added, which are just WIP, are as follows:
$ git log --oneline bisect~12..bisect
7d7117040 (raj/bisect, bisect) bisect--helper: convert to struct object_id
188ea5855 bisect--helper: add the get_bad_commit() function
b75f46fb4 bisect--helper: add a log_commit() helper function
4afc34403 bisect--helper: reduce the scope of a variable
62495f6ae bisect--helper: remove useless sub-expression in condition
964f4e2b0 bisect--helper: set correct term from --term-new= option
62efc099f bisect--helper: remove redundant assignment to has_double_dash
d35950b92 bisect--helper: remove redundant goto's
b33f313ac bisect--helper: remove space just before \n in string
3eb407156 bisect--helper: remove some unnecessary braces
c2b89c9b8 bisect--helper: add some vertical whitespace
8c883701c bisect--helper: fix up some coding style issues
$
Again IIRC, there are a couple of bug fixes in these commits ...
I have to go now, so I will leave it with you. ;-)
Hope that helps.
ATB,
Ramsay Jones
-- >8 --
diff --git a/bisect.c b/bisect.c
index 2838d672d..b19311ca7 100644
--- a/bisect.c
+++ b/bisect.c
@@ -1066,7 +1066,7 @@ int bisect_clean_state(void)
struct string_list refs_for_removal = STRING_LIST_INIT_NODUP;
for_each_ref_in("refs/bisect", mark_for_removal, (void *) &refs_for_removal);
string_list_append(&refs_for_removal, xstrdup("BISECT_HEAD"));
- result = delete_refs("bisect: remove", &refs_for_removal, REF_NODEREF);
+ result = delete_refs("bisect: clean", &refs_for_removal, REF_NODEREF);
refs_for_removal.strdup_strings = 1;
string_list_clear(&refs_for_removal, 0);
unlink_or_warn(git_path_bisect_expected_rev());
diff --git a/builtin/am.c b/builtin/am.c
index c973bd96d..aa66f9915 100644
--- a/builtin/am.c
+++ b/builtin/am.c
@@ -32,22 +32,6 @@
#include "apply.h"
#include "string-list.h"
-/**
- * Returns 1 if the file is empty or does not exist, 0 otherwise.
- */
-static int is_empty_file(const char *filename)
-{
- struct stat st;
-
- if (stat(filename, &st) < 0) {
- if (errno == ENOENT)
- return 1;
- die_errno(_("could not stat %s"), filename);
- }
-
- return !st.st_size;
-}
-
/**
* Returns the length of the first line of msg.
*/
@@ -1300,7 +1284,7 @@ static int parse_mail(struct am_state *state, const char *mail)
goto finish;
}
- if (is_empty_file(am_path(state, "patch"))) {
+ if (is_empty_or_missing_file(am_path(state, "patch"))) {
printf_ln(_("Patch is empty."));
die_user_resolve(state);
}
@@ -1883,7 +1867,7 @@ static void am_run(struct am_state *state, int resume)
resume = 0;
}
- if (!is_empty_file(am_path(state, "rewritten"))) {
+ if (!is_empty_or_missing_file(am_path(state, "rewritten"))) {
assert(state->rebasing);
copy_notes_for_rebase(state);
run_post_rewrite_hook(state);
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 35d2105f9..2af024f60 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -5,8 +5,6 @@
#include "refs.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
-static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
-static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
@@ -45,8 +43,8 @@ static int check_term_format(const char *term, const char *orig_term)
if (res)
return error(_("'%s' is not a valid term"), term);
- if (one_of(term, "help", "start", "skip", "next", "reset",
- "visualize", "replay", "log", "run", "terms", NULL))
+ if (one_of(term, "help", "start", "terms", "skip", "next", "reset",
+ "visualize", "replay", "log", "run", NULL))
return error(_("can't use the builtin command '%s' as a term"), term);
/*
@@ -82,37 +80,12 @@ static int write_terms(const char *bad, const char *good)
return (res < 0) ? -1 : 0;
}
-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());
- }
- }
-}
-
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
WRITE_TERMS,
- BISECT_CLEAN_STATE,
- CHECK_EXPECTED_REVS
+ BISECT_CLEAN_STATE
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -122,8 +95,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
- OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
- N_("check for expected revs"), CHECK_EXPECTED_REVS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -140,17 +111,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
return bisect_next_all(prefix, no_checkout);
case WRITE_TERMS:
if (argc != 2)
- return error(_("--write-terms requires two arguments"));
+ die(_("--write-terms requires two arguments"));
return write_terms(argv[0], argv[1]);
case BISECT_CLEAN_STATE:
if (argc != 0)
- return error(_("--bisect-clean-state requires no arguments"));
+ die(_("--bisect-clean-state requires no arguments"));
return bisect_clean_state();
- case CHECK_EXPECTED_REVS:
- check_expected_revs(argv, argc);
- return 0;
default:
- return error("BUG: unknown subcommand '%d'", cmdmode);
+ die("BUG: unknown subcommand '%d'", cmdmode);
}
return 0;
}
diff --git a/cache.h b/cache.h
index 71fe09264..7a1901893 100644
--- a/cache.h
+++ b/cache.h
@@ -2029,4 +2029,7 @@ void sleep_millisec(int millisec);
*/
void safe_create_dir(const char *dir, int share);
+/* Return 1 if the file is empty or does not exists, 0 otherwise. */
+extern int is_empty_or_missing_file(const char *filename);
+
#endif /* CACHE_H */
diff --git a/git-bisect.sh b/git-bisect.sh
index 0138a8860..f1202dfb4 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -209,7 +209,7 @@ bisect_start() {
eval "$eval true" &&
if test $must_write_terms -eq 1
then
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD"
fi &&
echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
#
@@ -237,6 +237,22 @@ bisect_write() {
test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
}
+is_expected_rev() {
+ test -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
+ test "$1" = $(cat "$GIT_DIR/BISECT_EXPECTED_REV")
+}
+
+check_expected_revs() {
+ for _rev in "$@"; do
+ if ! is_expected_rev "$_rev"
+ then
+ rm -f "$GIT_DIR/BISECT_ANCESTORS_OK"
+ rm -f "$GIT_DIR/BISECT_EXPECTED_REV"
+ return
+ fi
+ done
+}
+
bisect_skip() {
all=''
for arg in "$@"
@@ -264,7 +280,7 @@ bisect_state() {
rev=$(git rev-parse --verify "$bisected_head") ||
die "$(eval_gettext "Bad rev input: \$bisected_head")"
bisect_write "$state" "$rev"
- git bisect--helper --check-expected-revs "$rev" ;;
+ check_expected_revs "$rev" ;;
2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
shift
hash_list=''
@@ -278,7 +294,7 @@ bisect_state() {
do
bisect_write "$state" "$rev"
done
- git bisect--helper --check-expected-revs $hash_list ;;
+ check_expected_revs $hash_list ;;
*,"$TERM_BAD")
die "$(eval_gettext "'git bisect \$TERM_BAD' can take only one argument.")" ;;
*)
diff --git a/wrapper.c b/wrapper.c
index 36630e5d1..975ca2f1b 100644
--- a/wrapper.c
+++ b/wrapper.c
@@ -690,3 +690,16 @@ int xgethostname(char *buf, size_t len)
buf[len - 1] = 0;
return ret;
}
+
+int is_empty_or_missing_file(const char *filename)
+{
+ struct stat st;
+
+ if (stat(filename, &st) < 0) {
+ if (errno == ENOENT)
+ return 1;
+ die_errno(_("could not stat %s"), filename);
+ }
+
+ return !st.st_size;
+}
^ permalink raw reply related [flat|nested] 320+ messages in thread
* Re: [PATCH v16 1/6] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2017-09-30 12:59 ` Ramsay Jones
@ 2017-10-02 13:44 ` Pranit Bauva
2017-10-03 0:48 ` Ramsay Jones
0 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2017-10-02 13:44 UTC (permalink / raw)
To: Ramsay Jones; +Cc: Git List, Junio C Hamano
Hey Ramsay,
On Sat, Sep 30, 2017 at 6:29 PM, Ramsay Jones
<ramsay@ramsayjones.plus.com> wrote:
> Hi Pranit,
>
> Just before Junio dropped your 'pb/bisect' branch from his
> repository (and What's cooking), I fetched it locally with
> the intention of finishing it off. (It would have been silly
> to waste all your good work).
Thanks!
> Although I have rebased your branch a few times, and added
> a few commits while 'reading' the code, I haven't actually
> added much to your branch (only 12 commits and I had meant
> to squash some of those together)!
>
> However, there were some bug fixes in there, so you may want
> to take a look at:
>
> git://repo.or.cz/git/raj.git branch 'bisect'
>
> [the 'pb-bisect' branch was the original branch from Junio,
> including the 'SQUASH' commit that I squashed!]
Yes, I have checked it out. I had worked on Stephan's review and
updated a few parts. I think you have included that as well as some of
your modifications. I will squash it in together and send the series
out in parts.
> These patches seem to relate to patches 1-5 & 8 of the original
> series. The diff between these patches and the first 6 patches
> of my bisect branch is given below. Note that most of the diff
> seems to be caused by swapping patch #6 for #8, but not all of
> the hunks are caused by this.
>
> Note that I moved some code between patches (e.g. some of the
> GIT_PATH_FUNC()s moved out of patch #4, because they were not
> used in that patch. Ah, is that why you moved patch #8 up?).
> [Also I added the 'bisect clean' message to delet_refs() to
> patch #4 as well.]
Even I thought keeping GIT_PATH_FUNC()s should be declared whenever
required. Did that change in this patch series.
> Look for []-ed comments in the commit messages for a note of
> the changes I made to your original patches, in patches #2,
> #4, #7-9, #11-12 and #14.
>
> The commits I added, which are just WIP, are as follows:
>
> $ git log --oneline bisect~12..bisect
> 7d7117040 (raj/bisect, bisect) bisect--helper: convert to struct object_id
> 188ea5855 bisect--helper: add the get_bad_commit() function
> b75f46fb4 bisect--helper: add a log_commit() helper function
> 4afc34403 bisect--helper: reduce the scope of a variable
> 62495f6ae bisect--helper: remove useless sub-expression in condition
> 964f4e2b0 bisect--helper: set correct term from --term-new= option
> 62efc099f bisect--helper: remove redundant assignment to has_double_dash
> d35950b92 bisect--helper: remove redundant goto's
> b33f313ac bisect--helper: remove space just before \n in string
> 3eb407156 bisect--helper: remove some unnecessary braces
> c2b89c9b8 bisect--helper: add some vertical whitespace
> 8c883701c bisect--helper: fix up some coding style issues
> $
>
> Again IIRC, there are a couple of bug fixes in these commits ...
There is actually a major bug in the later part of previous series
mostly in the bisect-next which actually caused delays. I think you
have fixed it in your commit 682d0bff0. Although I would need to have
a closer look at it. In original series, I did get a sigserv, and as
you mention it in the commit that you have fixed it.
> I have to go now, so I will leave it with you. ;-)
>
> Hope that helps.
>
> ATB,
> Ramsay Jones
Again Thanks!
>
> -- >8 --
> diff --git a/bisect.c b/bisect.c
> index 2838d672d..b19311ca7 100644
> --- a/bisect.c
> +++ b/bisect.c
> @@ -1066,7 +1066,7 @@ int bisect_clean_state(void)
> struct string_list refs_for_removal = STRING_LIST_INIT_NODUP;
> for_each_ref_in("refs/bisect", mark_for_removal, (void *) &refs_for_removal);
> string_list_append(&refs_for_removal, xstrdup("BISECT_HEAD"));
> - result = delete_refs("bisect: remove", &refs_for_removal, REF_NODEREF);
> + result = delete_refs("bisect: clean", &refs_for_removal, REF_NODEREF);
> refs_for_removal.strdup_strings = 1;
> string_list_clear(&refs_for_removal, 0);
> unlink_or_warn(git_path_bisect_expected_rev());
> diff --git a/builtin/am.c b/builtin/am.c
> index c973bd96d..aa66f9915 100644
> --- a/builtin/am.c
> +++ b/builtin/am.c
> @@ -32,22 +32,6 @@
> #include "apply.h"
> #include "string-list.h"
>
> -/**
> - * Returns 1 if the file is empty or does not exist, 0 otherwise.
> - */
> -static int is_empty_file(const char *filename)
> -{
> - struct stat st;
> -
> - if (stat(filename, &st) < 0) {
> - if (errno == ENOENT)
> - return 1;
> - die_errno(_("could not stat %s"), filename);
> - }
> -
> - return !st.st_size;
> -}
> -
> /**
> * Returns the length of the first line of msg.
> */
> @@ -1300,7 +1284,7 @@ static int parse_mail(struct am_state *state, const char *mail)
> goto finish;
> }
>
> - if (is_empty_file(am_path(state, "patch"))) {
> + if (is_empty_or_missing_file(am_path(state, "patch"))) {
> printf_ln(_("Patch is empty."));
> die_user_resolve(state);
> }
> @@ -1883,7 +1867,7 @@ static void am_run(struct am_state *state, int resume)
> resume = 0;
> }
>
> - if (!is_empty_file(am_path(state, "rewritten"))) {
> + if (!is_empty_or_missing_file(am_path(state, "rewritten"))) {
> assert(state->rebasing);
> copy_notes_for_rebase(state);
> run_post_rewrite_hook(state);
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 35d2105f9..2af024f60 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -5,8 +5,6 @@
> #include "refs.h"
>
> static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
> -static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
> -static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
>
> static const char * const git_bisect_helper_usage[] = {
> N_("git bisect--helper --next-all [--no-checkout]"),
> @@ -45,8 +43,8 @@ static int check_term_format(const char *term, const char *orig_term)
> if (res)
> return error(_("'%s' is not a valid term"), term);
>
> - if (one_of(term, "help", "start", "skip", "next", "reset",
> - "visualize", "replay", "log", "run", "terms", NULL))
> + if (one_of(term, "help", "start", "terms", "skip", "next", "reset",
> + "visualize", "replay", "log", "run", NULL))
> return error(_("can't use the builtin command '%s' as a term"), term);
>
> /*
> @@ -82,37 +80,12 @@ static int write_terms(const char *bad, const char *good)
> return (res < 0) ? -1 : 0;
> }
>
> -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());
> - }
> - }
> -}
> -
> int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> {
> enum {
> NEXT_ALL = 1,
> WRITE_TERMS,
> - BISECT_CLEAN_STATE,
> - CHECK_EXPECTED_REVS
> + BISECT_CLEAN_STATE
> } cmdmode = 0;
> int no_checkout = 0;
> struct option options[] = {
> @@ -122,8 +95,6 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> N_("write the terms to .git/BISECT_TERMS"), WRITE_TERMS),
> OPT_CMDMODE(0, "bisect-clean-state", &cmdmode,
> N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
> - OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
> - N_("check for expected revs"), CHECK_EXPECTED_REVS),
> OPT_BOOL(0, "no-checkout", &no_checkout,
> N_("update BISECT_HEAD instead of checking out the current commit")),
> OPT_END()
> @@ -140,17 +111,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> return bisect_next_all(prefix, no_checkout);
> case WRITE_TERMS:
> if (argc != 2)
> - return error(_("--write-terms requires two arguments"));
> + die(_("--write-terms requires two arguments"));
> return write_terms(argv[0], argv[1]);
> case BISECT_CLEAN_STATE:
> if (argc != 0)
> - return error(_("--bisect-clean-state requires no arguments"));
> + die(_("--bisect-clean-state requires no arguments"));
> return bisect_clean_state();
> - case CHECK_EXPECTED_REVS:
> - check_expected_revs(argv, argc);
> - return 0;
> default:
> - return error("BUG: unknown subcommand '%d'", cmdmode);
> + die("BUG: unknown subcommand '%d'", cmdmode);
I will keep the return rather than die since Christian and I had a few
conversations long back.
Regards,
Pranit Bauva
www.bauva.com
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 1/6] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2017-10-02 13:44 ` Pranit Bauva
@ 2017-10-03 0:48 ` Ramsay Jones
2017-10-03 3:51 ` Junio C Hamano
0 siblings, 1 reply; 320+ messages in thread
From: Ramsay Jones @ 2017-10-03 0:48 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Git List, Junio C Hamano
On 02/10/17 14:44, Pranit Bauva wrote:
[snip]
>> Look for []-ed comments in the commit messages for a note of
>> the changes I made to your original patches, in patches #2,
>> #4, #7-9, #11-12 and #14.
>>
>> The commits I added, which are just WIP, are as follows:
>>
>> $ git log --oneline bisect~12..bisect
>> 7d7117040 (raj/bisect, bisect) bisect--helper: convert to struct object_id
>> 188ea5855 bisect--helper: add the get_bad_commit() function
>> b75f46fb4 bisect--helper: add a log_commit() helper function
>> 4afc34403 bisect--helper: reduce the scope of a variable
>> 62495f6ae bisect--helper: remove useless sub-expression in condition
>> 964f4e2b0 bisect--helper: set correct term from --term-new= option
>> 62efc099f bisect--helper: remove redundant assignment to has_double_dash
>> d35950b92 bisect--helper: remove redundant goto's
>> b33f313ac bisect--helper: remove space just before \n in string
>> 3eb407156 bisect--helper: remove some unnecessary braces
>> c2b89c9b8 bisect--helper: add some vertical whitespace
>> 8c883701c bisect--helper: fix up some coding style issues
>> $
>>
>> Again IIRC, there are a couple of bug fixes in these commits ...
>
> There is actually a major bug in the later part of previous series
> mostly in the bisect-next which actually caused delays. I think you
> have fixed it in your commit 682d0bff0. Although I would need to have
> a closer look at it. In original series, I did get a sigserv, and as
> you mention it in the commit that you have fixed it.
Yes, I also meant to tidy that up by removing some, now
redundant, initialisation later in that function.
Note, that wasn't the only bug! (I have probably forgotten
some of them, but look at 964f4e2b0, for example).
ATB,
Ramsay Jones
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 1/6] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2017-10-03 0:48 ` Ramsay Jones
@ 2017-10-03 3:51 ` Junio C Hamano
2017-10-03 4:35 ` Pranit Bauva
2017-10-04 2:22 ` Ramsay Jones
0 siblings, 2 replies; 320+ messages in thread
From: Junio C Hamano @ 2017-10-03 3:51 UTC (permalink / raw)
To: Ramsay Jones; +Cc: Pranit Bauva, Git List
Ramsay Jones <ramsay@ramsayjones.plus.com> writes:
> On 02/10/17 14:44, Pranit Bauva wrote:
> [snip]
>>...
> Yes, I also meant to tidy that up by removing some, now
> redundant, initialisation later in that function.
>
> Note, that wasn't the only bug! (I have probably forgotten
> some of them, but look at 964f4e2b0, for example).
It seems that Pranit needs a bit more work to take known fixes from
your efforts and we should wait for the series to be rerolled?
Thanks both for working on this.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 1/6] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2017-10-03 3:51 ` Junio C Hamano
@ 2017-10-03 4:35 ` Pranit Bauva
2017-10-04 2:22 ` Ramsay Jones
1 sibling, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-10-03 4:35 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Ramsay Jones, Git List
Hey Junio,
On Tue, Oct 3, 2017 at 9:21 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Ramsay Jones <ramsay@ramsayjones.plus.com> writes:
>
>> On 02/10/17 14:44, Pranit Bauva wrote:
>> [snip]
>>>...
>> Yes, I also meant to tidy that up by removing some, now
>> redundant, initialisation later in that function.
>>
>> Note, that wasn't the only bug! (I have probably forgotten
>> some of them, but look at 964f4e2b0, for example).
>
> It seems that Pranit needs a bit more work to take known fixes from
> your efforts and we should wait for the series to be rerolled?
This series is the initial part of the whole series. Things started to
get a little problematic after bisect_start(). The reason I am doing
the series in parts so that I can get the part which is solid to be
merged and then start work on later parts since I don't have a time
constraint now.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 1/6] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2017-10-03 3:51 ` Junio C Hamano
2017-10-03 4:35 ` Pranit Bauva
@ 2017-10-04 2:22 ` Ramsay Jones
2017-10-04 4:07 ` Junio C Hamano
1 sibling, 1 reply; 320+ messages in thread
From: Ramsay Jones @ 2017-10-04 2:22 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Pranit Bauva, Git List
On 03/10/17 04:51, Junio C Hamano wrote:
> Ramsay Jones <ramsay@ramsayjones.plus.com> writes:
>
>> On 02/10/17 14:44, Pranit Bauva wrote:
>> [snip]
>>> ...
>> Yes, I also meant to tidy that up by removing some, now
>> redundant, initialisation later in that function.
>>
>> Note, that wasn't the only bug! (I have probably forgotten
>> some of them, but look at 964f4e2b0, for example).
>
> It seems that Pranit needs a bit more work to take known fixes from
> your efforts and we should wait for the series to be rerolled?
This series is just the first few patches from the original 28/29
patch series; in particular, patches 1-5 and 8 of that series.
If I compare just the first 5 patches, then the differences are
small and (maybe) not worth a re-roll. For some reason, I changed
the message passed to the delete_refs() call from "bisect: remove"
to "bisect: clean", we both added "terms" to the 'builtin command'
list but in different positions and some calls to die() have
been replaced with 'return error(...)'.
Viz:
$ git log --oneline v2.14.0..bisect~34
d8ce077c8 t6030: explicitly test for bisection cleanup
1fd8e44a1 bisect--helper: `bisect_clean_state` shell function in C
5aa9d18eb bisect--helper: `write_terms` shell function in C
1b94b2ff1 bisect: rewrite `check_term_format` shell function in C
a97a96ccf bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
$
$ git log --oneline v2.14.0..pranit~1
6012123c7 t6030: explicitly test for bisection cleanup
7c945c391 bisect--helper: `bisect_clean_state` shell function in C
9240c3962 bisect--helper: `write_terms` shell function in C
ba496589c bisect--helper: rewrite `check_term_format` shell function in C
f1563a33f bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
$
Note that the subject line of patch #2 has also been corrected
in this new series (bisect: -> bisect--helper:). I haven't
compared the commit messages.
$ git diff bisect~34 pranit~1
diff --git a/bisect.c b/bisect.c
index b19311ca7..2838d672d 100644
--- a/bisect.c
+++ b/bisect.c
@@ -1066,7 +1066,7 @@ int bisect_clean_state(void)
struct string_list refs_for_removal = STRING_LIST_INIT_NODUP;
for_each_ref_in("refs/bisect", mark_for_removal, (void *) &refs_for_removal);
string_list_append(&refs_for_removal, xstrdup("BISECT_HEAD"));
- result = delete_refs("bisect: clean", &refs_for_removal, REF_NODEREF);
+ result = delete_refs("bisect: remove", &refs_for_removal, REF_NODEREF);
refs_for_removal.strdup_strings = 1;
string_list_clear(&refs_for_removal, 0);
unlink_or_warn(git_path_bisect_expected_rev());
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 2af024f60..0f4d4e41c 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -43,8 +43,8 @@ static int check_term_format(const char *term, const char *orig_term)
if (res)
return error(_("'%s' is not a valid term"), term);
- if (one_of(term, "help", "start", "terms", "skip", "next", "reset",
- "visualize", "replay", "log", "run", NULL))
+ if (one_of(term, "help", "start", "skip", "next", "reset",
+ "visualize", "replay", "log", "run", "terms", NULL))
return error(_("can't use the builtin command '%s' as a term"), term);
/*
@@ -111,14 +111,14 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
return bisect_next_all(prefix, no_checkout);
case WRITE_TERMS:
if (argc != 2)
- die(_("--write-terms requires two arguments"));
+ return error(_("--write-terms requires two arguments"));
return write_terms(argv[0], argv[1]);
case BISECT_CLEAN_STATE:
if (argc != 0)
- die(_("--bisect-clean-state requires no arguments"));
+ return error(_("--bisect-clean-state requires no arguments"));
return bisect_clean_state();
default:
- die("BUG: unknown subcommand '%d'", cmdmode);
+ return error("BUG: unknown subcommand '%d'", cmdmode);
}
return 0;
}
diff --git a/git-bisect.sh b/git-bisect.sh
index f1202dfb4..045830c39 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -209,7 +209,7 @@ bisect_start() {
eval "$eval true" &&
if test $must_write_terms -eq 1
then
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD"
+ git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
fi &&
echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
#
$
So, the major differences and bug fixes are in later patches.
ATB,
Ramsay Jones
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 1/6] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL
2017-10-04 2:22 ` Ramsay Jones
@ 2017-10-04 4:07 ` Junio C Hamano
0 siblings, 0 replies; 320+ messages in thread
From: Junio C Hamano @ 2017-10-04 4:07 UTC (permalink / raw)
To: Ramsay Jones; +Cc: Pranit Bauva, Git List
Ramsay Jones <ramsay@ramsayjones.plus.com> writes:
> On 03/10/17 04:51, Junio C Hamano wrote:
>>
>> It seems that Pranit needs a bit more work to take known fixes from
>> your efforts and we should wait for the series to be rerolled?
>
> This series is just the first few patches from the original 28/29
> patch series; in particular, patches 1-5 and 8 of that series.
> ...
> So, the major differences and bug fixes are in later patches.
OK. So these are good to go separately (as prerequistes for the
follow-on work)--thanks for clarification.
^ permalink raw reply [flat|nested] 320+ messages in thread
* [PATCH v16 Part II 7/8] bisect--helper: `bisect_start` shell function partially in C
2017-10-27 15:06 ` [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
` (3 preceding siblings ...)
2017-10-27 15:06 ` [PATCH v16 Part II 8/8] t6030: make various test to pass GETTEXT_POISON tests Pranit Bauva
@ 2017-10-27 15:06 ` Pranit Bauva
2017-10-30 16:51 ` Stephan Beyer
2018-02-16 1:22 ` SZEDER Gábor
2017-10-27 15:06 ` [PATCH v16 Part II 5/8] bisect--helper: `bisect_next_check` shell function " Pranit Bauva
` (6 subsequent siblings)
11 siblings, 2 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-10-27 15:06 UTC (permalink / raw)
To: git
Reimplement the `bisect_start` shell function partially in C and add
`bisect-start` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
The last part is not converted because it calls another shell function
`bisect_start` shell function will be completed after the `bisect_next`
shell function is ported in C.
Using `--bisect-start` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other methods.
Also introduce a method `bisect_append_log_quoted` to keep things short
and crisp.
Helped-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Helped-by: Stephan Beyer <s-beyer@gmx.net>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 228 ++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 132 +--------------------------
2 files changed, 228 insertions(+), 132 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index ab0580ce0089a..4ac175c49e80c 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -7,6 +7,7 @@
#include "argv-array.h"
#include "run-command.h"
#include "prompt.h"
+#include "quote.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
@@ -14,6 +15,8 @@ static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
static GIT_PATH_FUNC(git_path_bisect_head, "BISECT_HEAD")
static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
+static GIT_PATH_FUNC(git_path_head_name, "head-name")
+static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
@@ -24,6 +27,8 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-check-and-set-terms <command> <good_term> <bad_term>"),
N_("git bisect--helper --bisect-next-check [<term>] <good_term> <bad_term>"),
N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
+ N_("git bisect--helper --bisect-start [--term-{old,good}=<term> --term-{new,bad}=<term>]"
+ "[--no-checkout] [<bad> [<good>...]] [--] [<paths>...]"),
NULL
};
@@ -401,6 +406,217 @@ static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
return 0;
}
+static int bisect_append_log_quoted(const char **argv)
+{
+ int retval = 0;
+ 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)
+ goto fail;
+
+ sq_quote_argv(&orig_args, argv, 0);
+ if (fprintf(fp, "%s\n", orig_args.buf) < 1)
+ goto fail;
+
+ goto finish;
+
+fail:
+ retval = -1;
+finish:
+ fclose(fp);
+ strbuf_release(&orig_args);
+ return retval;
+}
+
+static int bisect_start(struct bisect_terms *terms, int no_checkout,
+ const char **argv, int argc)
+{
+ int i, has_double_dash = 0, must_write_terms = 0, bad_seen = 0;
+ int flags, pathspec_pos, retval = 0;
+ 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;
+ } else if (!strcmp(arg, "--term-good") ||
+ !strcmp(arg, "--term-old")) {
+ must_write_terms = 1;
+ free((void *) terms->term_good);
+ terms->term_good = xstrdup(argv[++i]);
+ } 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")) {
+ must_write_terms = 1;
+ free((void *) terms->term_bad);
+ terms->term_bad = xstrdup(argv[++i]);
+ } 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);
+ } else if (starts_with(arg, "--") &&
+ !one_of(arg, "--term-good", "--term-bad", NULL)) {
+ return error(_("unrecognised 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.
+ */
+ must_write_terms |= !!revs.nr;
+ 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) {
+ struct argv_array argv = ARGV_ARRAY_INIT;
+
+ argv_array_pushl(&argv, "checkout", start_head.buf,
+ "--", NULL);
+ if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
+ error(_("checking out '%s' failed. Try 'git "
+ "bisect start <valid-branch>'."),
+ start_head.buf);
+ goto fail;
+ }
+ }
+ } 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, sha1_to_hex(head_oid.hash));
+ } 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);
+
+ if (no_checkout) {
+ get_oid(start_head.buf, &oid);
+ if (update_ref(NULL, "BISECT_HEAD", &oid, NULL, 0,
+ UPDATE_REFS_MSG_ON_ERR))
+ goto fail;
+ }
+
+ if (pathspec_pos < argc - 1)
+ sq_quote_argv(&bisect_names, argv + pathspec_pos, 0);
+ 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))
+ goto fail;
+
+ if (must_write_terms)
+ if (write_terms(terms->term_bad, terms->term_good))
+ goto fail;
+
+ retval = bisect_append_log_quoted(argv);
+ if (retval)
+ goto fail;
+
+ goto finish;
+
+fail:
+ retval = -1;
+finish:
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ strbuf_release(&start_head);
+ strbuf_release(&bisect_names);
+ return retval;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -412,7 +628,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_WRITE,
CHECK_AND_SET_TERMS,
BISECT_NEXT_CHECK,
- BISECT_TERMS
+ BISECT_TERMS,
+ BISECT_START
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -434,6 +651,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
OPT_CMDMODE(0, "bisect-terms", &cmdmode,
N_("print out the bisect terms"), BISECT_TERMS),
+ OPT_CMDMODE(0, "bisect-start", &cmdmode,
+ N_("start the bisect session"), BISECT_START),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -441,7 +660,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
struct bisect_terms terms;
argc = parse_options(argc, argv, prefix, options,
- git_bisect_helper_usage, PARSE_OPT_KEEP_UNKNOWN);
+ git_bisect_helper_usage,
+ PARSE_OPT_KEEP_DASHDASH | PARSE_OPT_KEEP_UNKNOWN);
if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
@@ -489,6 +709,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
return error(_("--bisect-terms requires 0 or 1 argument"));
res = bisect_terms(&terms, argv, argc);
break;
+ case BISECT_START:
+ set_terms(&terms, "bad", "good");
+ res = bisect_start(&terms, no_checkout, argv, argc);
+ break;
default:
return error("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 1bc5749f78484..9d2f8936198d2 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -71,122 +71,7 @@ bisect_autostart() {
}
bisect_start() {
- #
- # Check for one bad and then some good revisions.
- #
- has_double_dash=0
- for arg; do
- case "$arg" in --) has_double_dash=1; break ;; esac
- done
- orig_args=$(git rev-parse --sq-quote "$@")
- bad_seen=0
- eval=''
- must_write_terms=0
- revs=''
- if test "z$(git rev-parse --is-bare-repository)" != zfalse
- then
- mode=--no-checkout
- else
- mode=''
- fi
- while [ $# -gt 0 ]; do
- arg="$1"
- case "$arg" in
- --)
- shift
- break
- ;;
- --no-checkout)
- mode=--no-checkout
- shift ;;
- --term-good|--term-old)
- shift
- must_write_terms=1
- TERM_GOOD=$1
- shift ;;
- --term-good=*|--term-old=*)
- must_write_terms=1
- TERM_GOOD=${1#*=}
- shift ;;
- --term-bad|--term-new)
- shift
- must_write_terms=1
- TERM_BAD=$1
- shift ;;
- --term-bad=*|--term-new=*)
- must_write_terms=1
- TERM_BAD=${1#*=}
- shift ;;
- --*)
- die "$(eval_gettext "unrecognised option: '\$arg'")" ;;
- *)
- rev=$(git rev-parse -q --verify "$arg^{commit}") || {
- test $has_double_dash -eq 1 &&
- die "$(eval_gettext "'\$arg' does not appear to be a valid revision")"
- break
- }
- revs="$revs $rev"
- shift
- ;;
- esac
- done
-
- for rev in $revs
- do
- # 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.
- must_write_terms=1
-
- case $bad_seen in
- 0) state=$TERM_BAD ; bad_seen=1 ;;
- *) state=$TERM_GOOD ;;
- esac
- eval="$eval git bisect--helper --bisect-write '$state' '$rev' '$TERM_GOOD' '$TERM_BAD' 'nolog' &&"
- done
- #
- # Verify HEAD.
- #
- head=$(GIT_DIR="$GIT_DIR" git symbolic-ref -q HEAD) ||
- head=$(GIT_DIR="$GIT_DIR" git rev-parse --verify HEAD) ||
- die "$(gettext "Bad HEAD - I need a HEAD")"
-
- #
- # Check if we are bisecting.
- #
- start_head=''
- if test -s "$GIT_DIR/BISECT_START"
- then
- # Reset to the rev from where we started.
- start_head=$(cat "$GIT_DIR/BISECT_START")
- if test "z$mode" != "z--no-checkout"
- then
- git checkout "$start_head" -- ||
- die "$(eval_gettext "Checking out '\$start_head' failed. Try 'git bisect reset <valid-branch>'.")"
- fi
- else
- # Get rev from where we start.
- case "$head" in
- refs/heads/*|$_x40)
- # This error message should only be triggered by
- # cogito usage, and cogito users should understand
- # it relates to cg-seek.
- [ -s "$GIT_DIR/head-name" ] &&
- die "$(gettext "won't bisect on cg-seek'ed tree")"
- start_head="${head#refs/heads/}"
- ;;
- *)
- die "$(gettext "Bad HEAD - strange symbolic ref")"
- ;;
- esac
- fi
-
- #
- # Get rid of any old bisect state.
- #
- git bisect--helper --bisect-clean-state || exit
+ git bisect--helper --bisect-start $@ || exit
#
# Change state.
@@ -199,22 +84,9 @@ bisect_start() {
trap 'exit 255' 1 2 3 15
#
- # Write new start state.
- #
- echo "$start_head" >"$GIT_DIR/BISECT_START" && {
- test "z$mode" != "z--no-checkout" ||
- git update-ref --no-deref BISECT_HEAD "$start_head"
- } &&
- git rev-parse --sq-quote "$@" >"$GIT_DIR/BISECT_NAMES" &&
- eval "$eval true" &&
- if test $must_write_terms -eq 1
- then
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
- fi &&
- echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
- #
# Check if we can proceed to the next bisect state.
#
+ get_terms
bisect_auto_next
trap '-' 0
--
https://github.com/git/git/pull/420
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v16 Part II 2/8] bisect--helper: `bisect_write` shell function in C
2017-10-27 15:06 ` [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
@ 2017-10-27 15:06 ` Pranit Bauva
2017-10-27 17:28 ` Martin Ågren
` (3 more replies)
2017-10-27 15:06 ` [PATCH v16 Part II 6/8] bisect--helper: `get_terms` & `bisect_terms` " Pranit Bauva
` (10 subsequent siblings)
11 siblings, 4 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-10-27 15:06 UTC (permalink / raw)
To: git
Reimplement the `bisect_write` shell function in C and add a
`bisect-write` subcommand to `git bisect--helper` to call it from
git-bisect.sh
Using `--bisect-write` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by some other methods.
Note: bisect_write() uses two variables namely TERM_GOOD and TERM_BAD
from the global shell script thus we need to pass it to the subcommand
using the arguments. We then store them in a struct bisect_terms and
pass the memory address around functions.
Add a log_commit() helper function to write the contents of the commit message
header to a file which will be re-used in future parts of the code as
well.
Also introduce a function free_terms() to free the memory of `struct
bisect_terms` and set_terms() to set the values of members in `struct
bisect_terms`.
Helped-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 107 +++++++++++++++++++++++++++++++++++++++++++++--
git-bisect.sh | 25 ++---------
2 files changed, 108 insertions(+), 24 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 12754448f7b6a..6295f53c850a8 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -12,15 +12,37 @@ static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
static GIT_PATH_FUNC(git_path_bisect_head, "BISECT_HEAD")
+static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-clean-state"),
N_("git bisect--helper --bisect-reset [<commit>]"),
+ N_("git bisect--helper --bisect-write <state> <revision> <good_term> <bad_term> [<nolog>]"),
NULL
};
+struct bisect_terms {
+ const char *term_good;
+ const char *term_bad;
+};
+
+static void free_terms(struct bisect_terms *terms)
+{
+ if (!terms->term_good)
+ free((void *) terms->term_good);
+ if (!terms->term_bad)
+ free((void *) terms->term_bad);
+}
+
+static void set_terms(struct bisect_terms *terms, const char *bad,
+ const char *good)
+{
+ terms->term_good = xstrdup(good);
+ terms->term_bad = xstrdup(bad);
+}
+
/*
* Check whether the string `term` belongs to the set of strings
* included in the variable arguments.
@@ -146,6 +168,72 @@ static int bisect_reset(const char *commit)
return bisect_clean_state();
}
+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;
+ int retval = 0;
+
+ 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 {
+ error(_("Bad bisect_write argument: %s"), state);
+ goto fail;
+ }
+
+ if (get_oid(rev, &oid)) {
+ error(_("couldn't get the oid of the rev '%s'"), rev);
+ goto fail;
+ }
+
+ if (update_ref(NULL, tag.buf, &oid, NULL, 0,
+ UPDATE_REFS_MSG_ON_ERR))
+ goto fail;
+
+ fp = fopen(git_path_bisect_log(), "a");
+ if (!fp) {
+ error_errno(_("couldn't open the file '%s'"), git_path_bisect_log());
+ goto fail;
+ }
+
+ commit = lookup_commit_reference(&oid);
+ log_commit(fp, "%s", state, commit);
+
+ if (!nolog)
+ fprintf(fp, "git bisect %s %s\n", state, rev);
+
+ goto finish;
+
+fail:
+ retval = -1;
+finish:
+ if (fp)
+ fclose(fp);
+ strbuf_release(&tag);
+ return retval;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -153,9 +241,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
WRITE_TERMS,
BISECT_CLEAN_STATE,
CHECK_EXPECTED_REVS,
- BISECT_RESET
+ BISECT_RESET,
+ BISECT_WRITE
} cmdmode = 0;
- int no_checkout = 0;
+ int no_checkout = 0, res = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
@@ -167,10 +256,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check for expected revs"), CHECK_EXPECTED_REVS),
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
N_("reset the bisection state"), BISECT_RESET),
+ OPT_CMDMODE(0, "bisect-write", &cmdmode,
+ N_("update the refs according to the bisection state and may write it to BISECT_LOG"), BISECT_WRITE),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
};
+ struct bisect_terms terms;
argc = parse_options(argc, argv, prefix, options,
git_bisect_helper_usage, 0);
@@ -179,6 +271,7 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
usage_with_options(git_bisect_helper_usage, options);
switch (cmdmode) {
+ int nolog;
case NEXT_ALL:
return bisect_next_all(prefix, no_checkout);
case WRITE_TERMS:
@@ -196,8 +289,16 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc > 1)
return error(_("--bisect-reset requires either no argument or a commit"));
return bisect_reset(argc ? argv[0] : NULL);
+ case BISECT_WRITE:
+ if (argc != 4 && argc != 5)
+ return error(_("--bisect-write requires either 4 or 5 arguments"));
+ nolog = (argc == 5) && !strcmp(argv[4], "nolog");
+ set_terms(&terms, argv[3], argv[2]);
+ res = bisect_write(argv[0], argv[1], &terms, nolog);
+ break;
default:
return error("BUG: unknown subcommand '%d'", cmdmode);
}
- return 0;
+ free_terms(&terms);
+ return res;
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 4d403242482cf..1eab94ec943a1 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -144,7 +144,7 @@ bisect_start() {
0) state=$TERM_BAD ; bad_seen=1 ;;
*) state=$TERM_GOOD ;;
esac
- eval="$eval bisect_write '$state' '$rev' 'nolog' &&"
+ eval="$eval git bisect--helper --bisect-write '$state' '$rev' '$TERM_GOOD' '$TERM_BAD' 'nolog' &&"
done
#
# Verify HEAD.
@@ -220,23 +220,6 @@ bisect_start() {
trap '-' 0
}
-bisect_write() {
- state="$1"
- rev="$2"
- nolog="$3"
- case "$state" in
- "$TERM_BAD")
- tag="$state" ;;
- "$TERM_GOOD"|skip)
- tag="$state"-"$rev" ;;
- *)
- die "$(eval_gettext "Bad bisect_write argument: \$state")" ;;
- esac
- git update-ref "refs/bisect/$tag" "$rev" || exit
- echo "# $state: $(git show-branch $rev)" >>"$GIT_DIR/BISECT_LOG"
- test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -263,7 +246,7 @@ bisect_state() {
bisected_head=$(bisect_head)
rev=$(git rev-parse --verify "$bisected_head") ||
die "$(eval_gettext "Bad rev input: \$bisected_head")"
- bisect_write "$state" "$rev"
+ git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
git bisect--helper --check-expected-revs "$rev" ;;
2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
shift
@@ -276,7 +259,7 @@ bisect_state() {
done
for rev in $hash_list
do
- bisect_write "$state" "$rev"
+ git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
done
git bisect--helper --check-expected-revs $hash_list ;;
*,"$TERM_BAD")
@@ -413,7 +396,7 @@ bisect_replay () {
cmd="bisect_start $rev"
eval "$cmd" ;;
"$TERM_GOOD"|"$TERM_BAD"|skip)
- bisect_write "$command" "$rev" ;;
+ git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
terms)
bisect_terms $rev ;;
*)
--
https://github.com/git/git/pull/420
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v16 Part II 3/8] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file()
2017-10-27 15:06 ` [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
` (5 preceding siblings ...)
2017-10-27 15:06 ` [PATCH v16 Part II 5/8] bisect--helper: `bisect_next_check` shell function " Pranit Bauva
@ 2017-10-27 15:06 ` Pranit Bauva
2017-10-27 15:32 ` [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
` (4 subsequent siblings)
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-10-27 15:06 UTC (permalink / raw)
To: git
is_empty_file() can help to refactor a lot of code. This will be very
helpful in porting "git bisect" to C.
Suggested-by: Torsten Bögershausen <tboegi@web.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/am.c | 20 ++------------------
cache.h | 3 +++
wrapper.c | 13 +++++++++++++
3 files changed, 18 insertions(+), 18 deletions(-)
diff --git a/builtin/am.c b/builtin/am.c
index 4b6f1534f8840..2afaaabcdbecf 100644
--- a/builtin/am.c
+++ b/builtin/am.c
@@ -34,22 +34,6 @@
#include "packfile.h"
/**
- * Returns 1 if the file is empty or does not exist, 0 otherwise.
- */
-static int is_empty_file(const char *filename)
-{
- struct stat st;
-
- if (stat(filename, &st) < 0) {
- if (errno == ENOENT)
- return 1;
- die_errno(_("could not stat %s"), filename);
- }
-
- return !st.st_size;
-}
-
-/**
* Returns the length of the first line of msg.
*/
static int linelen(const char *msg)
@@ -1298,7 +1282,7 @@ static int parse_mail(struct am_state *state, const char *mail)
goto finish;
}
- if (is_empty_file(am_path(state, "patch"))) {
+ if (is_empty_or_missing_file(am_path(state, "patch"))) {
printf_ln(_("Patch is empty."));
die_user_resolve(state);
}
@@ -1880,7 +1864,7 @@ static void am_run(struct am_state *state, int resume)
resume = 0;
}
- if (!is_empty_file(am_path(state, "rewritten"))) {
+ if (!is_empty_or_missing_file(am_path(state, "rewritten"))) {
assert(state->rebasing);
copy_notes_for_rebase(state);
run_post_rewrite_hook(state);
diff --git a/cache.h b/cache.h
index 25adcf681531c..f05056a2d7fa1 100644
--- a/cache.h
+++ b/cache.h
@@ -1958,4 +1958,7 @@ void sleep_millisec(int millisec);
*/
void safe_create_dir(const char *dir, int share);
+/* Return 1 if the file is empty or does not exists, 0 otherwise. */
+extern int is_empty_or_missing_file(const char *filename);
+
#endif /* CACHE_H */
diff --git a/wrapper.c b/wrapper.c
index 61aba0b5c1bec..21c0fee2db459 100644
--- a/wrapper.c
+++ b/wrapper.c
@@ -690,3 +690,16 @@ int xgethostname(char *buf, size_t len)
buf[len - 1] = 0;
return ret;
}
+
+int is_empty_or_missing_file(const char *filename)
+{
+ struct stat st;
+
+ if (stat(filename, &st) < 0) {
+ if (errno == ENOENT)
+ return 1;
+ die_errno(_("could not stat %s"), filename);
+ }
+
+ return !st.st_size;
+}
--
https://github.com/git/git/pull/420
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v16 Part II 5/8] bisect--helper: `bisect_next_check` shell function in C
2017-10-27 15:06 ` [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
` (4 preceding siblings ...)
2017-10-27 15:06 ` [PATCH v16 Part II 7/8] bisect--helper: `bisect_start` shell function partially in C Pranit Bauva
@ 2017-10-27 15:06 ` Pranit Bauva
2017-10-27 17:35 ` Martin Ågren
` (4 more replies)
2017-10-27 15:06 ` [PATCH v16 Part II 3/8] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
` (5 subsequent siblings)
11 siblings, 5 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-10-27 15:06 UTC (permalink / raw)
To: git
Reimplement `bisect_next_check` shell function in C and add
`bisect-next-check` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
`bisect_voc` shell function is no longer useful now and is replaced by
using a char *[] of "new|bad" and "good|old" values.
Using `--bisect-next-check` is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by some other methods.
Helped-by: Stephan Beyer <s-beyer@gmx.net>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 91 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 60 +++----------------------------
2 files changed, 94 insertions(+), 57 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 65abf8a70c6d9..0f9c3e63821b8 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -6,6 +6,7 @@
#include "dir.h"
#include "argv-array.h"
#include "run-command.h"
+#include "prompt.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
@@ -21,6 +22,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write <state> <revision> <good_term> <bad_term> [<nolog>]"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <good_term> <bad_term>"),
+ N_("git bisect--helper --bisect-next-check [<term>] <good_term> <bad_term>"),
NULL
};
@@ -44,6 +46,11 @@ static void set_terms(struct bisect_terms *terms, const char *bad,
terms->term_bad = xstrdup(bad);
}
+static const char *voc[] = {
+ "bad|new",
+ "good|old"
+};
+
/*
* Check whether the string `term` belongs to the set of strings
* included in the variable arguments.
@@ -264,6 +271,79 @@ static int check_and_set_terms(struct bisect_terms *terms, const char *cmd)
return 0;
}
+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;
+}
+
+static int bisect_next_check(const struct bisect_terms *terms,
+ const char *current_term)
+{
+ int missing_good = 1, missing_bad = 1, retval = 0;
+ const char *bad_ref = xstrfmt("refs/bisect/%s", terms->term_bad);
+ const 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);
+
+ if (!missing_good && !missing_bad)
+ goto finish;
+
+ if (!current_term)
+ goto fail;
+
+ if (missing_good && !missing_bad && current_term &&
+ !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.
+ */
+ fprintf(stderr, _("Warning: bisecting only with a %s commit\n"),
+ terms->term_bad);
+ if (!isatty(0))
+ goto finish;
+ /*
+ * 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"))
+ goto fail;
+
+ goto finish;
+ }
+ if (!is_empty_or_missing_file(git_path_bisect_start())) {
+ error(_("You need to give me at least one %s and "
+ "%s revision. You can use \"git bisect %s\" "
+ "and \"git bisect %s\" for that.\n"),
+ voc[0], voc[1], voc[0], voc[1]);
+ goto fail;
+ } else {
+ error(_("You need to start by \"git bisect start\". You "
+ "then need to give me at least one %s and %s "
+ "revision. You can use \"git bisect %s\" and "
+ "\"git bisect %s\" for that.\n"),
+ voc[1], voc[0], voc[1], voc[0]);
+ goto fail;
+ }
+ goto finish;
+
+fail:
+ retval = -1;
+finish:
+ free((void *) good_glob);
+ free((void *) bad_ref);
+ return retval;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -273,7 +353,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
CHECK_EXPECTED_REVS,
BISECT_RESET,
BISECT_WRITE,
- CHECK_AND_SET_TERMS
+ CHECK_AND_SET_TERMS,
+ BISECT_NEXT_CHECK
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -291,6 +372,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("update the refs according to the bisection state and may write it to BISECT_LOG"), BISECT_WRITE),
OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
+ OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
+ N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -335,6 +418,12 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
set_terms(&terms, argv[2], argv[1]);
res = check_and_set_terms(&terms, argv[0]);
break;
+ 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;
default:
return error("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 0447b73aa588b..c21fafc62d71f 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -271,59 +271,14 @@ bisect_state() {
bisect_auto_next
}
-bisect_next_check() {
- missing_good= missing_bad=
- git show-ref -q --verify refs/bisect/$TERM_BAD || missing_bad=t
- test -n "$(git for-each-ref "refs/bisect/$TERM_GOOD-*")" || missing_good=t
-
- case "$missing_good,$missing_bad,$1" in
- ,,*)
- : have both $TERM_GOOD and $TERM_BAD - ok
- ;;
- *,)
- # do not have both but not asked to fail - just report.
- false
- ;;
- t,,"$TERM_GOOD")
- # have bad (or new) but not good (or old). we could bisect although
- # this is less optimum.
- eval_gettextln "Warning: bisecting only with a \$TERM_BAD commit." >&2
- if test -t 0
- then
- # TRANSLATORS: Make sure to include [Y] and [n] in your
- # translation. The program will only accept English input
- # at this point.
- gettext "Are you sure [Y/n]? " >&2
- read yesno
- case "$yesno" in [Nn]*) exit 1 ;; esac
- fi
- : bisect without $TERM_GOOD...
- ;;
- *)
- bad_syn=$(bisect_voc bad)
- good_syn=$(bisect_voc good)
- if test -s "$GIT_DIR/BISECT_START"
- then
-
- eval_gettextln "You need to give me at least one \$bad_syn and one \$good_syn revision.
-(You can use \"git bisect \$bad_syn\" and \"git bisect \$good_syn\" for that.)" >&2
- else
- eval_gettextln "You need to start by \"git bisect start\".
-You then need to give me at least one \$good_syn and one \$bad_syn revision.
-(You can use \"git bisect \$bad_syn\" and \"git bisect \$good_syn\" for that.)" >&2
- fi
- exit 1 ;;
- esac
-}
-
bisect_auto_next() {
- bisect_next_check && bisect_next || :
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD && bisect_next || :
}
bisect_next() {
case "$#" in 0) ;; *) usage ;; esac
bisect_autostart
- bisect_next_check $TERM_GOOD
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD $TERM_GOOD|| exit
# Perform all bisection computation, display and checkout
git bisect--helper --next-all $(test -f "$GIT_DIR/BISECT_HEAD" && echo --no-checkout)
@@ -355,7 +310,7 @@ bisect_next() {
}
bisect_visualize() {
- bisect_next_check fail
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD fail || exit
if test $# = 0
then
@@ -409,7 +364,7 @@ bisect_replay () {
}
bisect_run () {
- bisect_next_check fail
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD fail || exit
while true
do
@@ -482,13 +437,6 @@ get_terms () {
fi
}
-bisect_voc () {
- case "$1" in
- bad) echo "bad|new" ;;
- good) echo "good|old" ;;
- esac
-}
-
bisect_terms () {
get_terms
if ! test -s "$GIT_DIR/BISECT_TERMS"
--
https://github.com/git/git/pull/420
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v16 Part II 8/8] t6030: make various test to pass GETTEXT_POISON tests
2017-10-27 15:06 ` [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
` (2 preceding siblings ...)
2017-10-27 15:06 ` [PATCH v16 Part II 4/8] bisect--helper: `check_and_set_terms` " Pranit Bauva
@ 2017-10-27 15:06 ` Pranit Bauva
2017-10-27 15:06 ` [PATCH v16 Part II 7/8] bisect--helper: `bisect_start` shell function partially in C Pranit Bauva
` (7 subsequent siblings)
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-10-27 15:06 UTC (permalink / raw)
To: git
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
t/t6030-bisect-porcelain.sh | 120 ++++++++++++++++++++++----------------------
1 file changed, 60 insertions(+), 60 deletions(-)
diff --git a/t/t6030-bisect-porcelain.sh b/t/t6030-bisect-porcelain.sh
index 55835ee4a4715..f9e61c6540e57 100755
--- a/t/t6030-bisect-porcelain.sh
+++ b/t/t6030-bisect-porcelain.sh
@@ -133,21 +133,21 @@ test_expect_success 'bisect reset removes bisect state after --no-checkout' '
test_expect_success 'bisect start: back in good branch' '
git branch > branch.output &&
- grep "* other" branch.output > /dev/null &&
+ test_i18ngrep "* other" branch.output > /dev/null &&
git bisect start $HASH4 $HASH1 -- &&
git bisect good &&
git bisect start $HASH4 $HASH1 -- &&
git bisect bad &&
git bisect reset &&
git branch > branch.output &&
- grep "* other" branch.output > /dev/null
+ test_i18ngrep "* other" branch.output > /dev/null
'
test_expect_success 'bisect start: no ".git/BISECT_START" created if junk rev' '
git bisect reset &&
test_must_fail git bisect start $HASH4 foo -- &&
git branch > branch.output &&
- grep "* other" branch.output > /dev/null &&
+ test_i18ngrep "* other" branch.output > /dev/null &&
test_must_fail test -e .git/BISECT_START
'
@@ -158,14 +158,14 @@ test_expect_success 'bisect start: existing ".git/BISECT_START" not modified if
test_must_fail git bisect start $HASH4 foo -- &&
git branch > branch.output &&
test_i18ngrep "* (no branch, bisect started on other)" branch.output > /dev/null &&
- test_cmp saved .git/BISECT_START
+ test_i18ncmp saved .git/BISECT_START
'
test_expect_success 'bisect start: no ".git/BISECT_START" if mistaken rev' '
git bisect start $HASH4 $HASH1 -- &&
git bisect good &&
test_must_fail git bisect start $HASH1 $HASH4 -- &&
git branch > branch.output &&
- grep "* other" branch.output > /dev/null &&
+ test_i18ngrep "* other" branch.output > /dev/null &&
test_must_fail test -e .git/BISECT_START
'
@@ -174,7 +174,7 @@ test_expect_success 'bisect start: no ".git/BISECT_START" if checkout error' '
test_must_fail git bisect start $HASH4 $HASH1 -- &&
git branch &&
git branch > branch.output &&
- grep "* other" branch.output > /dev/null &&
+ test_i18ngrep "* other" branch.output > /dev/null &&
test_must_fail test -e .git/BISECT_START &&
test -z "$(git for-each-ref "refs/bisect/*")" &&
git checkout HEAD hello
@@ -189,7 +189,7 @@ test_expect_success 'bisect skip: successful result' '
git bisect start $HASH4 $HASH1 &&
git bisect skip &&
git bisect bad > my_bisect_log.txt &&
- grep "$HASH2 is the first bad commit" my_bisect_log.txt
+ test_i18ngrep "$HASH2 is the first bad commit" my_bisect_log.txt
'
# $HASH1 is good, $HASH4 is bad, we skip $HASH3 and $HASH2
@@ -200,11 +200,11 @@ test_expect_success 'bisect skip: cannot tell between 3 commits' '
git bisect start $HASH4 $HASH1 &&
git bisect skip &&
test_expect_code 2 git bisect skip >my_bisect_log.txt &&
- grep "first bad commit could be any of" my_bisect_log.txt &&
+ test_i18ngrep "first bad commit could be any of" my_bisect_log.txt &&
! grep $HASH1 my_bisect_log.txt &&
- grep $HASH2 my_bisect_log.txt &&
- grep $HASH3 my_bisect_log.txt &&
- grep $HASH4 my_bisect_log.txt
+ test_i18ngrep $HASH2 my_bisect_log.txt &&
+ test_i18ngrep $HASH3 my_bisect_log.txt &&
+ test_i18ngrep $HASH4 my_bisect_log.txt
'
# $HASH1 is good, $HASH4 is bad, we skip $HASH3
@@ -216,11 +216,11 @@ test_expect_success 'bisect skip: cannot tell between 2 commits' '
git bisect start $HASH4 $HASH1 &&
git bisect skip &&
test_expect_code 2 git bisect good >my_bisect_log.txt &&
- grep "first bad commit could be any of" my_bisect_log.txt &&
+ test_i18ngrep "first bad commit could be any of" my_bisect_log.txt &&
! grep $HASH1 my_bisect_log.txt &&
! grep $HASH2 my_bisect_log.txt &&
- grep $HASH3 my_bisect_log.txt &&
- grep $HASH4 my_bisect_log.txt
+ test_i18ngrep $HASH3 my_bisect_log.txt &&
+ test_i18ngrep $HASH4 my_bisect_log.txt
'
# $HASH1 is good, $HASH4 is both skipped and bad, we skip $HASH3
@@ -235,11 +235,11 @@ test_expect_success 'bisect skip: with commit both bad and skipped' '
git bisect good $HASH1 &&
git bisect skip &&
test_expect_code 2 git bisect good >my_bisect_log.txt &&
- grep "first bad commit could be any of" my_bisect_log.txt &&
+ test_i18ngrep "first bad commit could be any of" my_bisect_log.txt &&
! grep $HASH1 my_bisect_log.txt &&
- ! grep $HASH2 my_bisect_log.txt &&
- grep $HASH3 my_bisect_log.txt &&
- grep $HASH4 my_bisect_log.txt
+ ! rep $HASH2 my_bisect_log.txt &&
+ test_i18ngrep $HASH3 my_bisect_log.txt &&
+ test_i18ngrep $HASH4 my_bisect_log.txt
'
# We want to automatically find the commit that
@@ -254,7 +254,7 @@ test_expect_success \
git bisect good $HASH1 &&
git bisect bad $HASH4 &&
git bisect run ./test_script.sh > my_bisect_log.txt &&
- grep "$HASH3 is the first bad commit" my_bisect_log.txt &&
+ test_i18ngrep "$HASH3 is the first bad commit" my_bisect_log.txt &&
git bisect reset'
# We want to automatically find the commit that
@@ -267,7 +267,7 @@ test_expect_success \
chmod +x test_script.sh &&
git bisect start $HASH4 $HASH1 &&
git bisect run ./test_script.sh > my_bisect_log.txt &&
- grep "$HASH4 is the first bad commit" my_bisect_log.txt &&
+ test_i18ngrep "$HASH4 is the first bad commit" my_bisect_log.txt &&
git bisect reset'
# $HASH1 is good, $HASH5 is bad, we skip $HASH3
@@ -280,14 +280,14 @@ test_expect_success 'bisect skip: add line and then a new test' '
git bisect start $HASH5 $HASH1 &&
git bisect skip &&
git bisect good > my_bisect_log.txt &&
- grep "$HASH5 is the first bad commit" my_bisect_log.txt &&
+ test_i18ngrep "$HASH5 is the first bad commit" my_bisect_log.txt &&
git bisect log > log_to_replay.txt &&
git bisect reset
'
test_expect_success 'bisect skip and bisect replay' '
git bisect replay log_to_replay.txt > my_bisect_log.txt &&
- grep "$HASH5 is the first bad commit" my_bisect_log.txt &&
+ test_i18ngrep "$HASH5 is the first bad commit" my_bisect_log.txt &&
git bisect reset
'
@@ -307,11 +307,11 @@ test_expect_success 'bisect run & skip: cannot tell between 2' '
false
else
test $? -eq 2 &&
- grep "first bad commit could be any of" my_bisect_log.txt &&
+ test_i18ngrep "first bad commit could be any of" my_bisect_log.txt &&
! grep $HASH3 my_bisect_log.txt &&
! grep $HASH6 my_bisect_log.txt &&
- grep $HASH4 my_bisect_log.txt &&
- grep $HASH5 my_bisect_log.txt
+ test_i18ngrep $HASH4 my_bisect_log.txt &&
+ test_i18ngrep $HASH5 my_bisect_log.txt
fi
'
@@ -328,7 +328,7 @@ test_expect_success 'bisect run & skip: find first bad' '
chmod +x test_script.sh &&
git bisect start $HASH7 $HASH1 &&
git bisect run ./test_script.sh > my_bisect_log.txt &&
- grep "$HASH6 is the first bad commit" my_bisect_log.txt
+ test_i18ngrep "$HASH6 is the first bad commit" my_bisect_log.txt
'
test_expect_success 'bisect skip only one range' '
@@ -337,7 +337,7 @@ test_expect_success 'bisect skip only one range' '
git bisect skip $HASH1..$HASH5 &&
test "$HASH6" = "$(git rev-parse --verify HEAD)" &&
test_must_fail git bisect bad > my_bisect_log.txt &&
- grep "first bad commit could be any of" my_bisect_log.txt
+ test_i18ngrep "first bad commit could be any of" my_bisect_log.txt
'
test_expect_success 'bisect skip many ranges' '
@@ -346,7 +346,7 @@ test_expect_success 'bisect skip many ranges' '
git bisect skip $HASH2 $HASH2.. ..$HASH5 &&
test "$HASH6" = "$(git rev-parse --verify HEAD)" &&
test_must_fail git bisect bad > my_bisect_log.txt &&
- grep "first bad commit could be any of" my_bisect_log.txt
+ test_i18ngrep "first bad commit could be any of" my_bisect_log.txt
'
test_expect_success 'bisect starting with a detached HEAD' '
@@ -378,7 +378,7 @@ test_expect_success 'bisect does not create a "bisect" branch' '
rev_hash6=$(git rev-parse --verify HEAD) &&
test "$rev_hash6" = "$HASH6" &&
git bisect good > my_bisect_log.txt &&
- grep "$HASH7 is the first bad commit" my_bisect_log.txt &&
+ test_i18ngrep "$HASH7 is the first bad commit" my_bisect_log.txt &&
git bisect reset &&
rev_hash6=$(git rev-parse --verify bisect) &&
test "$rev_hash6" = "$HASH6" &&
@@ -405,26 +405,26 @@ test_expect_success 'side branch creation' '
test_expect_success 'good merge base when good and bad are siblings' '
git bisect start "$HASH7" "$SIDE_HASH7" > my_bisect_log.txt &&
test_i18ngrep "merge base must be tested" my_bisect_log.txt &&
- grep $HASH4 my_bisect_log.txt &&
+ test_i18ngrep $HASH4 my_bisect_log.txt &&
git bisect good > my_bisect_log.txt &&
! grep "merge base must be tested" my_bisect_log.txt &&
- grep $HASH6 my_bisect_log.txt &&
+ test_i18ngrep $HASH6 my_bisect_log.txt &&
git bisect reset
'
test_expect_success 'skipped merge base when good and bad are siblings' '
git bisect start "$SIDE_HASH7" "$HASH7" > my_bisect_log.txt &&
test_i18ngrep "merge base must be tested" my_bisect_log.txt &&
- grep $HASH4 my_bisect_log.txt &&
+ test_i18ngrep $HASH4 my_bisect_log.txt &&
git bisect skip > my_bisect_log.txt 2>&1 &&
- grep "warning" my_bisect_log.txt &&
- grep $SIDE_HASH6 my_bisect_log.txt &&
+ test_i18ngrep "warning" my_bisect_log.txt &&
+ test_i18ngrep $SIDE_HASH6 my_bisect_log.txt &&
git bisect reset
'
test_expect_success 'bad merge base when good and bad are siblings' '
git bisect start "$HASH7" HEAD > my_bisect_log.txt &&
test_i18ngrep "merge base must be tested" my_bisect_log.txt &&
- grep $HASH4 my_bisect_log.txt &&
+ test_i18ngrep $HASH4 my_bisect_log.txt &&
test_must_fail git bisect bad > my_bisect_log.txt 2>&1 &&
test_i18ngrep "merge base $HASH4 is bad" my_bisect_log.txt &&
test_i18ngrep "fixed between $HASH4 and \[$SIDE_HASH7\]" my_bisect_log.txt &&
@@ -454,8 +454,8 @@ test_expect_success 'many merge bases creation' '
B_HASH=$(git rev-parse --verify HEAD) &&
git merge-base --all "$A_HASH" "$B_HASH" > merge_bases.txt &&
test_line_count = 2 merge_bases.txt &&
- grep "$HASH5" merge_bases.txt &&
- grep "$SIDE_HASH5" merge_bases.txt
+ test_i18ngrep "$HASH5" merge_bases.txt &&
+ test_i18ngrep "$SIDE_HASH5" merge_bases.txt
'
test_expect_success 'good merge bases when good and bad are siblings' '
@@ -465,11 +465,11 @@ test_expect_success 'good merge bases when good and bad are siblings' '
test_i18ngrep "merge base must be tested" my_bisect_log2.txt &&
{
{
- grep "$SIDE_HASH5" my_bisect_log.txt &&
- grep "$HASH5" my_bisect_log2.txt
+ test_i18ngrep "$SIDE_HASH5" my_bisect_log.txt &&
+ test_i18ngrep "$HASH5" my_bisect_log2.txt
} || {
- grep "$SIDE_HASH5" my_bisect_log2.txt &&
- grep "$HASH5" my_bisect_log.txt
+ test_i18ngrep "$SIDE_HASH5" my_bisect_log2.txt &&
+ test_i18ngrep "$HASH5" my_bisect_log.txt
}
} &&
git bisect reset
@@ -478,7 +478,7 @@ test_expect_success 'good merge bases when good and bad are siblings' '
test_expect_success 'optimized merge base checks' '
git bisect start "$HASH7" "$SIDE_HASH7" > my_bisect_log.txt &&
test_i18ngrep "merge base must be tested" my_bisect_log.txt &&
- grep "$HASH4" my_bisect_log.txt &&
+ test_i18ngrep "$HASH4" my_bisect_log.txt &&
git bisect good > my_bisect_log2.txt &&
test -f ".git/BISECT_ANCESTORS_OK" &&
test "$HASH6" = $(git rev-parse --verify HEAD) &&
@@ -527,7 +527,7 @@ test_expect_success 'restricting bisection on one dir' '
para1=$(git rev-parse --verify HEAD) &&
test "$para1" = "$PARA_HASH1" &&
git bisect bad > my_bisect_log.txt &&
- grep "$PARA_HASH1 is the first bad commit" my_bisect_log.txt
+ test_i18ngrep "$PARA_HASH1 is the first bad commit" my_bisect_log.txt
'
test_expect_success 'restricting bisection on one dir and a file' '
@@ -545,7 +545,7 @@ test_expect_success 'restricting bisection on one dir and a file' '
para1=$(git rev-parse --verify HEAD) &&
test "$para1" = "$PARA_HASH1" &&
git bisect good > my_bisect_log.txt &&
- grep "$PARA_HASH4 is the first bad commit" my_bisect_log.txt
+ test_i18ngrep "$PARA_HASH4 is the first bad commit" my_bisect_log.txt
'
test_expect_success 'skipping away from skipped commit' '
@@ -576,7 +576,7 @@ test_expect_success 'test bisection on bare repo - --no-checkout specified' '
"test \$(git rev-list BISECT_HEAD ^$HASH2 --max-count=1 | wc -l) = 0" \
>../nocheckout.log
) &&
- grep "$HASH3 is the first bad commit" nocheckout.log
+ test_i18ngrep "$HASH3 is the first bad commit" nocheckout.log
'
@@ -591,7 +591,7 @@ test_expect_success 'test bisection on bare repo - --no-checkout defaulted' '
"test \$(git rev-list BISECT_HEAD ^$HASH2 --max-count=1 | wc -l) = 0" \
>../defaulted.log
) &&
- grep "$HASH3 is the first bad commit" defaulted.log
+ test_i18ngrep "$HASH3 is the first bad commit" defaulted.log
'
#
@@ -633,7 +633,7 @@ EOF
test_expect_success 'bisect fails if tree is broken on start commit' '
git bisect reset &&
test_must_fail git bisect start BROKEN_HASH7 BROKEN_HASH4 2>error.txt &&
- test_cmp expected.missing-tree.default error.txt
+ test_i18ncmp expected.missing-tree.default error.txt
'
test_expect_success 'bisect fails if tree is broken on trial commit' '
@@ -641,7 +641,7 @@ test_expect_success 'bisect fails if tree is broken on trial commit' '
test_must_fail git bisect start BROKEN_HASH9 BROKEN_HASH4 2>error.txt &&
git reset --hard broken &&
git checkout broken &&
- test_cmp expected.missing-tree.default error.txt
+ test_i18ncmp expected.missing-tree.default error.txt
'
check_same()
@@ -726,7 +726,7 @@ test_expect_success 'bisect log: successful result' '
git bisect start $HASH4 $HASH2 &&
git bisect good &&
git bisect log >bisect-log.txt &&
- test_cmp expected.bisect-log bisect-log.txt &&
+ test_i18ncmp expected.bisect-log bisect-log.txt &&
git bisect reset
'
@@ -746,7 +746,7 @@ test_expect_success 'bisect log: only skip commits left' '
git bisect start $HASH4 $HASH2 &&
test_must_fail git bisect skip &&
git bisect log >bisect-skip-log.txt &&
- test_cmp expected.bisect-skip-log bisect-skip-log.txt &&
+ test_i18ncmp expected.bisect-skip-log bisect-skip-log.txt &&
git bisect reset
'
@@ -780,14 +780,14 @@ test_expect_success 'bisect start with one new and old' '
git bisect new $HASH4 &&
git bisect new &&
git bisect new >bisect_result &&
- grep "$HASH2 is the first new commit" bisect_result &&
+ test_i18ngrep "$HASH2 is the first new commit" bisect_result &&
git bisect log >log_to_replay.txt &&
git bisect reset
'
test_expect_success 'bisect replay with old and new' '
git bisect replay log_to_replay.txt >bisect_result &&
- grep "$HASH2 is the first new commit" bisect_result &&
+ test_i18ngrep "$HASH2 is the first new commit" bisect_result &&
git bisect reset
'
@@ -811,10 +811,10 @@ test_expect_success 'bisect terms shows good/bad after start' '
git bisect start HEAD $HASH1 &&
git bisect terms --term-good >actual &&
echo good >expected &&
- test_cmp expected actual &&
+ test_i18ncmp expected actual &&
git bisect terms --term-bad >actual &&
echo bad >expected &&
- test_cmp expected actual
+ test_i18ncmp expected actual
'
test_expect_success 'bisect start with one term1 and term2' '
@@ -824,14 +824,14 @@ test_expect_success 'bisect start with one term1 and term2' '
git bisect term1 $HASH4 &&
git bisect term1 &&
git bisect term1 >bisect_result &&
- grep "$HASH2 is the first term1 commit" bisect_result &&
+ test_i18ngrep "$HASH2 is the first term1 commit" bisect_result &&
git bisect log >log_to_replay.txt &&
git bisect reset
'
test_expect_success 'bisect replay with term1 and term2' '
git bisect replay log_to_replay.txt >bisect_result &&
- grep "$HASH2 is the first term1 commit" bisect_result &&
+ test_i18ngrep "$HASH2 is the first term1 commit" bisect_result &&
git bisect reset
'
@@ -840,7 +840,7 @@ test_expect_success 'bisect start term1 term2' '
git bisect start --term-new term1 --term-old term2 $HASH4 $HASH1 &&
git bisect term1 &&
git bisect term1 >bisect_result &&
- grep "$HASH2 is the first term1 commit" bisect_result &&
+ test_i18ngrep "$HASH2 is the first term1 commit" bisect_result &&
git bisect log >log_to_replay.txt &&
git bisect reset
'
@@ -878,10 +878,10 @@ test_expect_success 'bisect start --term-* does store terms' '
test_i18ncmp expected actual &&
git bisect terms --term-bad >actual &&
echo one >expected &&
- test_cmp expected actual &&
+ test_i18ncmp expected actual &&
git bisect terms --term-good >actual &&
echo two >expected &&
- test_cmp expected actual
+ test_i18ncmp expected actual
'
test_expect_success 'bisect start takes options and revs in any order' '
@@ -891,7 +891,7 @@ test_expect_success 'bisect start takes options and revs in any order' '
$HASH1 --term-good three -- &&
(git bisect terms --term-bad && git bisect terms --term-good) >actual &&
printf "%s\n%s\n" bad-term three >expected &&
- test_cmp expected actual
+ test_i18ncmp expected actual
'
test_expect_success 'git bisect reset cleans bisection state properly' '
--
https://github.com/git/git/pull/420
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v16 Part II 4/8] bisect--helper: `check_and_set_terms` shell function in C
2017-10-27 15:06 ` [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
2017-10-27 15:06 ` [PATCH v16 Part II 2/8] bisect--helper: `bisect_write` " Pranit Bauva
2017-10-27 15:06 ` [PATCH v16 Part II 6/8] bisect--helper: `get_terms` & `bisect_terms` " Pranit Bauva
@ 2017-10-27 15:06 ` Pranit Bauva
2017-11-08 0:37 ` Ramsay Jones
2017-10-27 15:06 ` [PATCH v16 Part II 8/8] t6030: make various test to pass GETTEXT_POISON tests Pranit Bauva
` (8 subsequent siblings)
11 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2017-10-27 15:06 UTC (permalink / raw)
To: git
Reimplement the `check_and_set_terms` shell function in C and add
`check-and-set-terms` subcommand to `git bisect--helper` to call it from
git-bisect.sh
Using `--check-and-set-terms` subcommand is a temporary measure to port
shell function in C so as to use the existing test suite. As more
functions are ported, this subcommand will be retired but its
implementation will be called by some other methods.
check_and_set_terms() sets and receives two global variables namely
TERM_GOOD and TERM_BAD in the shell script. Luckily the file BISECT_TERMS
also contains the value of those variables so its appropriate to evoke the
method get_terms() after calling the subcommand so that it retrieves the
value of TERM_GOOD and TERM_BAD from the file BISECT_TERMS. The two
global variables are passed as arguments to the subcommand.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 41 ++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 36 ++++--------------------------------
2 files changed, 44 insertions(+), 33 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 6295f53c850a8..65abf8a70c6d9 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -20,6 +20,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-clean-state"),
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write <state> <revision> <good_term> <bad_term> [<nolog>]"),
+ N_("git bisect--helper --bisect-check-and-set-terms <command> <good_term> <bad_term>"),
NULL
};
@@ -234,6 +235,35 @@ static int bisect_write(const char *state, const char *rev,
return retval;
}
+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)) {
+ free_terms(terms);
+ set_terms(terms, "bad", "good");
+ return write_terms(terms->term_bad, terms->term_good);
+ }
+ else if (one_of(cmd, "new", "old", NULL)) {
+ free_terms(terms);
+ set_terms(terms, "new", "old");
+ return write_terms(terms->term_bad, terms->term_good);
+ }
+ }
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -242,7 +272,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_CLEAN_STATE,
CHECK_EXPECTED_REVS,
BISECT_RESET,
- BISECT_WRITE
+ BISECT_WRITE,
+ CHECK_AND_SET_TERMS
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -258,6 +289,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("reset the bisection state"), BISECT_RESET),
OPT_CMDMODE(0, "bisect-write", &cmdmode,
N_("update the refs according to the bisection state and may write it to BISECT_LOG"), BISECT_WRITE),
+ OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
+ N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -296,6 +329,12 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
set_terms(&terms, argv[3], argv[2]);
res = bisect_write(argv[0], argv[1], &terms, nolog);
break;
+ 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;
default:
return error("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 1eab94ec943a1..0447b73aa588b 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -238,7 +238,8 @@ bisect_skip() {
bisect_state() {
bisect_autostart
state=$1
- check_and_set_terms $state
+ git bisect--helper --check-and-set-terms $state $TERM_GOOD $TERM_BAD || exit
+ get_terms
case "$#,$state" in
0,*)
die "Please call 'bisect_state' with at least one argument." ;;
@@ -390,7 +391,8 @@ bisect_replay () {
command="$bisect"
fi
get_terms
- check_and_set_terms "$command"
+ git bisect--helper --check-and-set-terms "$command" "$TERM_GOOD" "$TERM_BAD" || exit
+ get_terms
case "$command" in
start)
cmd="bisect_start $rev"
@@ -480,36 +482,6 @@ get_terms () {
fi
}
-check_and_set_terms () {
- cmd="$1"
- case "$cmd" in
- skip|start|terms) ;;
- *)
- if test -s "$GIT_DIR/BISECT_TERMS" && test "$cmd" != "$TERM_BAD" && test "$cmd" != "$TERM_GOOD"
- then
- die "$(eval_gettext "Invalid command: you're currently in a \$TERM_BAD/\$TERM_GOOD bisect.")"
- fi
- case "$cmd" in
- bad|good)
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- TERM_BAD=bad
- TERM_GOOD=good
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
- fi
- ;;
- new|old)
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- TERM_BAD=new
- TERM_GOOD=old
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
- fi
- ;;
- esac ;;
- esac
-}
-
bisect_voc () {
case "$1" in
bad) echo "bad|new" ;;
--
https://github.com/git/git/pull/420
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C
2017-09-29 6:49 ` [PATCH v16 1/6] " Pranit Bauva
` (6 preceding siblings ...)
2017-09-30 12:59 ` Ramsay Jones
@ 2017-10-27 15:06 ` Pranit Bauva
2017-10-27 15:06 ` [PATCH v16 Part II 2/8] bisect--helper: `bisect_write` " Pranit Bauva
` (11 more replies)
7 siblings, 12 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-10-27 15:06 UTC (permalink / raw)
To: git
Reimplement `bisect_reset` shell function in C and add a `--bisect-reset`
subcommand to `git bisect--helper` to call it from git-bisect.sh .
Using `bisect_reset` subcommand is a temporary measure to port shell
functions to C so as to use the existing test suite. As more functions
are ported, this subcommand would be retired but its implementation will
be called by some other method.
Note: --bisect-clean-state subcommand has not been retired as there are
still a function namely `bisect_start()` which still uses this
subcommand.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
Hey,
This is the part 2 of the initial series[1] on bisect re-write. When I
submitted my patches of the part 1 of the bisect series, Ramsay informed
that he has been working on my previous patches and pointed me to his
patches. I have incorporated his changes into this series. Stephan did a
awesome job in reviewing my series and I have incorporated those changes
as well.
Ramsay's requested changes which have been incorporated:
* bisect--helper: convert to struct object_id: I have took out the bits
which were in this series and hand-picked them in this series.
* bisect--helper: add a log_commit() helper function: This function
might not seem to be very relevant in this part of the series, but it
is going to be in future parts of the series as described in
`188ea5855d93df` of Ramsay's git.git repo[2].
* bisect--helper: reduce scope of a variable in `bisect_start`
* bisect--helper: remove useless sub-expression in condition: I had
already done this change as suggested by Stephan.
* bisect--helper: set correct term from --term-new= option: I had
already done this change as suggested by Stephan.
* bisect--helper: remove redundant assignment to has_double_dash
* bisect--helper: remove redundant goto's
* bisect--helper: add some vertical whitespace
* bisect--helper: fixup some coding style issues
Ramsay's changes which I had already done ([]-ed comments):
* `bisect_write`: add a GIT_PATH_FUNC() removed earlier
* `bisect_write`: lookup_commit_reference() now takes an object_id
* `bisect_next_check`: addressed comments in Stephan's review and
Junio's squash
* `bisect_terms`: fixed up usage string and tested for --term-[good|old] and
--term-[bad|new] in bisect-terms subcommand argument processing:
instead of fixing up usage string, I just removed it as Stephan
suggested.
Stephan's requested changes which have been incorporated:
* Use goto's using `goto fail` and `goto finish`
* Marking strings for translation
* Stored res value and then returned it at the end
* Implement set_terms() and free_terms() for proper memory handling for
struct bisect_terms and fixed all leakages
* Remove bisect_voc() function
* Remove the bisect_term_usage string in bisect_terms()
* Use return error() every where instead of die()
* Improving readability of a message in bisect_terms()
* bisect_start(): fix some typos, remove has_double_dash, join the two
if branches, fix the bug when it should be terms->term_bad,
decomposed it into smaller functions by introducing
bisect_append_log()
A big thanks to Stephan and Ramsay for patiently reviewing my series and
helping me get this merged.
[1]:
https://public-inbox.org/git/0102015ecc65d695-22151d3b-752b-4c10-a3a3-b8ef52491664-000000@eu-west-1.amazonses.com/
[2]: git://repo.or.cz/git/raj.git
Regards,
Pranit Bauva
---
builtin/bisect--helper.c | 49 +++++++++++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 28 ++-------------------------
2 files changed, 50 insertions(+), 27 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 35d2105f941c6..12754448f7b6a 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -3,15 +3,21 @@
#include "parse-options.h"
#include "bisect.h"
#include "refs.h"
+#include "dir.h"
+#include "argv-array.h"
+#include "run-command.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
+static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
+static GIT_PATH_FUNC(git_path_bisect_head, "BISECT_HEAD")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-clean-state"),
+ N_("git bisect--helper --bisect-reset [<commit>]"),
NULL
};
@@ -106,13 +112,48 @@ static void check_expected_revs(const char **revs, int rev_nr)
}
}
+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)
+ return !printf(_("We are not bisecting.\n"));
+ 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);
+ }
+
+ if (!file_exists(git_path_bisect_head())) {
+ struct argv_array argv = ARGV_ARRAY_INIT;
+
+ argv_array_pushl(&argv, "checkout", branch.buf, "--", NULL);
+ if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
+ error(_("Could not check out original HEAD '%s'. Try "
+ "'git bisect reset <commit>'."), branch.buf);
+ strbuf_release(&branch);
+ argv_array_clear(&argv);
+ return -1;
+ }
+ argv_array_clear(&argv);
+ }
+
+ strbuf_release(&branch);
+ return bisect_clean_state();
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
WRITE_TERMS,
BISECT_CLEAN_STATE,
- CHECK_EXPECTED_REVS
+ CHECK_EXPECTED_REVS,
+ BISECT_RESET
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -124,6 +165,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
N_("check for expected revs"), CHECK_EXPECTED_REVS),
+ OPT_CMDMODE(0, "bisect-reset", &cmdmode,
+ N_("reset the bisection state"), BISECT_RESET),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -149,6 +192,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
case CHECK_EXPECTED_REVS:
check_expected_revs(argv, argc);
return 0;
+ case BISECT_RESET:
+ if (argc > 1)
+ return error(_("--bisect-reset requires either no argument or a commit"));
+ return bisect_reset(argc ? argv[0] : NULL);
default:
return error("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 0138a8860e377..4d403242482cf 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -393,35 +393,11 @@ bisect_visualize() {
eval '"$@"' --bisect -- $(cat "$GIT_DIR/BISECT_NAMES")
}
-bisect_reset() {
- test -s "$GIT_DIR/BISECT_START" || {
- gettextln "We are not bisecting."
- return
- }
- case "$#" in
- 0) branch=$(cat "$GIT_DIR/BISECT_START") ;;
- 1) git rev-parse --quiet --verify "$1^{commit}" >/dev/null || {
- invalid="$1"
- die "$(eval_gettext "'\$invalid' is not a valid commit")"
- }
- branch="$1" ;;
- *)
- usage ;;
- esac
-
- if ! test -f "$GIT_DIR/BISECT_HEAD" && ! git checkout "$branch" --
- then
- die "$(eval_gettext "Could not check out original HEAD '\$branch'.
-Try 'git bisect reset <commit>'.")"
- fi
- git bisect--helper --bisect-clean-state || exit
-}
-
bisect_replay () {
file="$1"
test "$#" -eq 1 || die "$(gettext "No logfile given")"
test -r "$file" || die "$(eval_gettext "cannot read \$file for replaying")"
- bisect_reset
+ git bisect--helper --bisect-reset || exit
while read git bisect command rev
do
test "$git $bisect" = "git bisect" || test "$git" = "git-bisect" || continue
@@ -611,7 +587,7 @@ case "$#" in
visualize|view)
bisect_visualize "$@" ;;
reset)
- bisect_reset "$@" ;;
+ git bisect--helper --bisect-reset "$@" ;;
replay)
bisect_replay "$@" ;;
log)
--
https://github.com/git/git/pull/420
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v16 Part II 6/8] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2017-10-27 15:06 ` [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
2017-10-27 15:06 ` [PATCH v16 Part II 2/8] bisect--helper: `bisect_write` " Pranit Bauva
@ 2017-10-27 15:06 ` Pranit Bauva
2017-10-27 20:04 ` Martin Ågren
` (2 more replies)
2017-10-27 15:06 ` [PATCH v16 Part II 4/8] bisect--helper: `check_and_set_terms` " Pranit Bauva
` (9 subsequent siblings)
11 siblings, 3 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-10-27 15:06 UTC (permalink / raw)
To: git
Reimplement the `get_terms` and `bisect_terms` shell function in C and
add `bisect-terms` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Using `--bisect-terms` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by some other methods.
Also use error() to report "no terms defined" and accordingly change the
test in t6030.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/bisect--helper.c | 69 +++++++++++++++++++++++++++++++++++++++++++--
git-bisect.sh | 35 ++---------------------
t/t6030-bisect-porcelain.sh | 2 +-
3 files changed, 70 insertions(+), 36 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 0f9c3e63821b8..ab0580ce0089a 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -23,6 +23,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-write <state> <revision> <good_term> <bad_term> [<nolog>]"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <good_term> <bad_term>"),
N_("git bisect--helper --bisect-next-check [<term>] <good_term> <bad_term>"),
+ N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
NULL
};
@@ -344,6 +345,62 @@ static int bisect_next_check(const struct bisect_terms *terms,
return retval;
}
+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)
+ goto fail;
+
+ 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);
+ goto finish;
+
+fail:
+ res = -1;
+finish:
+ if (fp)
+ fclose(fp);
+ strbuf_release(&str);
+ return res;
+}
+
+static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
+{
+ int i;
+
+ if (get_terms(terms))
+ return error(_("no terms defined"));
+
+ if (argc > 1)
+ return error(_("--bisect-term requires exactly one argument"));
+
+ if (argc == 0)
+ return !printf(_("Your current terms are %s for the old state\n"
+ "and %s for the new state.\n"),
+ terms->term_good, terms->term_bad);
+
+ for (i = 0; i < argc; i++) {
+ if (!strcmp(argv[i], "--term-good"))
+ printf(_("%s\n"), terms->term_good);
+ else if (!strcmp(argv[i], "--term-bad"))
+ printf(_("%s\n"), terms->term_bad);
+ else
+ error(_("BUG: invalid argument %s for 'git bisect terms'.\n"
+ "Supported options are: "
+ "--term-good|--term-old and "
+ "--term-bad|--term-new."), argv[i]);
+ }
+
+ return 0;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -354,7 +411,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_RESET,
BISECT_WRITE,
CHECK_AND_SET_TERMS,
- BISECT_NEXT_CHECK
+ BISECT_NEXT_CHECK,
+ BISECT_TERMS
} cmdmode = 0;
int no_checkout = 0, res = 0;
struct option options[] = {
@@ -374,6 +432,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
+ OPT_CMDMODE(0, "bisect-terms", &cmdmode,
+ N_("print out the bisect terms"), BISECT_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -381,7 +441,7 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
struct bisect_terms terms;
argc = parse_options(argc, argv, prefix, options,
- git_bisect_helper_usage, 0);
+ git_bisect_helper_usage, PARSE_OPT_KEEP_UNKNOWN);
if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
@@ -424,6 +484,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
set_terms(&terms, argv[1], argv[0]);
res = bisect_next_check(&terms, argc == 3 ? argv[2] : NULL);
break;
+ case BISECT_TERMS:
+ if (argc > 1)
+ return error(_("--bisect-terms requires 0 or 1 argument"));
+ res = bisect_terms(&terms, argv, argc);
+ break;
default:
return error("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index c21fafc62d71f..1bc5749f78484 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -355,7 +355,7 @@ bisect_replay () {
"$TERM_GOOD"|"$TERM_BAD"|skip)
git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
terms)
- bisect_terms $rev ;;
+ git bisect--helper --bisect-terms $rev || exit;;
*)
die "$(gettext "?? what are you talking about?")" ;;
esac
@@ -437,37 +437,6 @@ get_terms () {
fi
}
-bisect_terms () {
- get_terms
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- die "$(gettext "no terms defined")"
- fi
- case "$#" in
- 0)
- gettextln "Your current terms are $TERM_GOOD for the old state
-and $TERM_BAD for the new state."
- ;;
- 1)
- arg=$1
- case "$arg" in
- --term-good|--term-old)
- printf '%s\n' "$TERM_GOOD"
- ;;
- --term-bad|--term-new)
- printf '%s\n' "$TERM_BAD"
- ;;
- *)
- die "$(eval_gettext "invalid argument \$arg for 'git bisect terms'.
-Supported options are: --term-good|--term-old and --term-bad|--term-new.")"
- ;;
- esac
- ;;
- *)
- usage ;;
- esac
-}
-
case "$#" in
0)
usage ;;
@@ -498,7 +467,7 @@ case "$#" in
run)
bisect_run "$@" ;;
terms)
- bisect_terms "$@" ;;
+ git bisect--helper --bisect-terms "$@" || exit;;
*)
usage ;;
esac
diff --git a/t/t6030-bisect-porcelain.sh b/t/t6030-bisect-porcelain.sh
index f84ff941c3624..55835ee4a4715 100755
--- a/t/t6030-bisect-porcelain.sh
+++ b/t/t6030-bisect-porcelain.sh
@@ -802,7 +802,7 @@ test_expect_success 'bisect terms needs 0 or 1 argument' '
test_must_fail git bisect terms only-one &&
test_must_fail git bisect terms 1 2 &&
test_must_fail git bisect terms 2>actual &&
- echo "no terms defined" >expected &&
+ echo "error: no terms defined" >expected &&
test_i18ncmp expected actual
'
--
https://github.com/git/git/pull/420
^ permalink raw reply related [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C
2017-10-27 15:06 ` [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
` (6 preceding siblings ...)
2017-10-27 15:06 ` [PATCH v16 Part II 3/8] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
@ 2017-10-27 15:32 ` Pranit Bauva
2017-10-27 17:40 ` Junio C Hamano
` (3 subsequent siblings)
11 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-10-27 15:32 UTC (permalink / raw)
To: Git List
Hey,
I forgot to mention. One can find the travis build here[1] which is passing.
[1]: https://travis-ci.org/git/git/builds/293725346
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 2/8] bisect--helper: `bisect_write` shell function in C
2017-10-27 15:06 ` [PATCH v16 Part II 2/8] bisect--helper: `bisect_write` " Pranit Bauva
@ 2017-10-27 17:28 ` Martin Ågren
2017-10-30 17:35 ` Pranit Bauva
2017-10-27 18:19 ` Junio C Hamano
` (2 subsequent siblings)
3 siblings, 1 reply; 320+ messages in thread
From: Martin Ågren @ 2017-10-27 17:28 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
On 27 October 2017 at 17:06, Pranit Bauva <pranit.bauva@gmail.com> wrote:
> +static void free_terms(struct bisect_terms *terms)
> +{
> + if (!terms->term_good)
> + free((void *) terms->term_good);
> + if (!terms->term_bad)
> + free((void *) terms->term_bad);
> +}
These look like no-ops. Remove `!` for correctness, or `if (...)` for
simplicity, since `free()` can handle NULL.
You leave the pointers dangling, but you're ok for now since this is the
last thing that happens in `cmd_bisect__helper()`. Your later patches
add more users, but they're also ok, since they immediately assign new
values.
In case you (and others) find it useful, the below is a patch I've been
sitting on for a while as part of a series to plug various memory-leaks.
`FREE_AND_NULL_CONST()` would be useful in precisely these situations.
-- >8 --
Subject: git-compat-util: add FREE_AND_NULL_CONST() wrapper
Commit 481df65 ("git-compat-util: add a FREE_AND_NULL() wrapper around
free(ptr); ptr = NULL", 2017-06-15) added `FREE_AND_NULL()`. One
advantage of this macro is that it reduces risk of copy-paste errors and
reviewer-fatigue, especially when cleaning up more than just a single
pointer.
However, `FREE_AND_NULL()` can not be used with a const-pointer:
struct foo { const char *bar; }
...
FREE_AND_NULL(baz.bar);
This causes the compiler to barf as `free()` is called: "error: passing
argument 1 of ‘free’ discards ‘const’ qualifier from pointer target
type". A naive attempt to remedy this might look like this:
FREE_AND_NULL((void *)baz.bar);
Now the assignment is problematic: "error: lvalue required as left
operand of assignment".
Add a `FREE_AND_NULL_CONST()` wrapper macro which acts as
`FREE_AND_NULL()`, except it casts to `(void *)` when freeing. As a
demonstration, use this in two existing code paths that were identified
by some grepping. Future patches will use it to clean up struct-fields:
FREE_AND_NULL_CONST(baz.bar);
This macro is a slightly bigger hammer than `FREE_AND_NULL` and has a
slightly larger potential for misuse. Document that `FREE_AND_NULL`
should be preferred.
Signed-off-by: Martin Ågren <martin.agren@gmail.com>
---
argv-array.c | 3 +--
git-compat-util.h | 8 ++++++++
submodule.c | 3 +--
3 files changed, 10 insertions(+), 4 deletions(-)
diff --git a/argv-array.c b/argv-array.c
index 5d370fa33..433a5997a 100644
--- a/argv-array.c
+++ b/argv-array.c
@@ -59,8 +59,7 @@ void argv_array_pop(struct argv_array *array)
{
if (!array->argc)
return;
- free((char *)array->argv[array->argc - 1]);
- array->argv[array->argc - 1] = NULL;
+ FREE_AND_NULL_CONST(array->argv[array->argc - 1]);
array->argc--;
}
diff --git a/git-compat-util.h b/git-compat-util.h
index cedad4d58..ca3dcbc58 100644
--- a/git-compat-util.h
+++ b/git-compat-util.h
@@ -815,6 +815,14 @@ extern FILE *fopen_or_warn(const char *path, const char *mode);
*/
#define FREE_AND_NULL(p) do { free(p); (p) = NULL; } while (0)
+/*
+ * FREE_AND_NULL_CONST(ptr) is like FREE_AND_NULL(ptr) except it casts
+ * to (void *) when calling free. This is useful when handling, e.g., a
+ * `const char *`, but it can also be misused. Prefer FREE_AND_NULL, and
+ * use this only when you need to and it is safe to do so.
+ */
+#define FREE_AND_NULL_CONST(p) do { free((void *)(p)); (p) = NULL; } while (0)
+
#define ALLOC_ARRAY(x, alloc) (x) = xmalloc(st_mult(sizeof(*(x)), (alloc)))
#define REALLOC_ARRAY(x, alloc) (x) = xrealloc((x), st_mult(sizeof(*(x)), (alloc)))
diff --git a/submodule.c b/submodule.c
index 63e7094e1..7759f9050 100644
--- a/submodule.c
+++ b/submodule.c
@@ -364,8 +364,7 @@ int parse_submodule_update_strategy(const char *value,
{
enum submodule_update_type type;
- free((void*)dst->command);
- dst->command = NULL;
+ FREE_AND_NULL_CONST(dst->command);
type = parse_submodule_update_type(value);
if (type == SM_UPDATE_UNSPECIFIED)
--
2.15.0.rc2.5.g97dd00bb7
^ permalink raw reply related [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 5/8] bisect--helper: `bisect_next_check` shell function in C
2017-10-27 15:06 ` [PATCH v16 Part II 5/8] bisect--helper: `bisect_next_check` shell function " Pranit Bauva
@ 2017-10-27 17:35 ` Martin Ågren
2017-10-30 17:40 ` Pranit Bauva
2017-11-08 0:48 ` Ramsay Jones
` (3 subsequent siblings)
4 siblings, 1 reply; 320+ messages in thread
From: Martin Ågren @ 2017-10-27 17:35 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Git Mailing List, Jiang Xin
On 27 October 2017 at 17:06, Pranit Bauva <pranit.bauva@gmail.com> wrote:
> + /*
> + * have bad (or new) but not good (or old). We could bisect
> + * although this is less optimum.
> + */
> + fprintf(stderr, _("Warning: bisecting only with a %s commit\n"),
> + terms->term_bad);
Maybe this should use `warning()`?
> - # have bad (or new) but not good (or old). we could bisect although
> - # this is less optimum.
> - eval_gettextln "Warning: bisecting only with a \$TERM_BAD commit." >&2
I wonder if we can somehow pick up the existing translation? It would
now be fuzzy, in some sense, but since the string was originally in a
different file, maybe the po-tools won't be able to discover the
fuzzyness? We could add a TRANSLATORS-comment, so that the translators
know that this string matches an old one. There are more strings like
that in this patch, and maybe in some others as well, I haven't looked.
(Adding Jiang to cc.)
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C
2017-10-27 15:06 ` [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
` (7 preceding siblings ...)
2017-10-27 15:32 ` [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
@ 2017-10-27 17:40 ` Junio C Hamano
2017-10-30 17:26 ` Pranit Bauva
2017-10-30 13:22 ` Stephan Beyer
` (2 subsequent siblings)
11 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2017-10-27 17:40 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> +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)
> + return !printf(_("We are not bisecting.\n"));
> + 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);
The original checks "test -s BISECT_START" and complains, even when
an explicit commit is given. With this change, when the user is not
bisecting, giving "git bisect reset master" goes ahead---it is
likely that BISECT_HEAD does not exist and we may hit "Could not
check out" error, but if BISECT_HEAD is left behind from a previous
run (which is likely completely unrelated to whatever the user
currently is doing), we'd end up doing quite a random thing, no?
> + }
> +
> + if (!file_exists(git_path_bisect_head())) {
> + struct argv_array argv = ARGV_ARRAY_INIT;
> +
> + argv_array_pushl(&argv, "checkout", branch.buf, "--", NULL);
> + if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
> + error(_("Could not check out original HEAD '%s'. Try "
> + "'git bisect reset <commit>'."), branch.buf);
> + strbuf_release(&branch);
> + argv_array_clear(&argv);
> + return -1;
How does this return value affect the value eventually given to
exit(3), called by somewhere in git.c that called this function?
The call graph would be
common-main.c::main()
-> git.c::cmd_main()
-> handle_builtin()
. exit(run_builtin())
-> run_builtin()
. status = p->fn()
-> cmd_bisect__helper()
. return bisect_reset()
-> bisect_reset()
. return -1
. if (status) return status;
So the -1 is returned throughout the callchain and exit(3) ends up
getting it---which is not quite right. We shouldn't be giving
negative value to exit(3). bisect_clean_state() and other helper
functions may already share the same issue.
> + }
> + argv_array_clear(&argv);
> + }
> +
> + strbuf_release(&branch);
> + return bisect_clean_state();
> +}
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 2/8] bisect--helper: `bisect_write` shell function in C
2017-10-27 15:06 ` [PATCH v16 Part II 2/8] bisect--helper: `bisect_write` " Pranit Bauva
2017-10-27 17:28 ` Martin Ågren
@ 2017-10-27 18:19 ` Junio C Hamano
2017-10-30 17:38 ` Pranit Bauva
2017-10-30 13:38 ` Stephan Beyer
2017-11-08 0:26 ` Ramsay Jones
3 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2017-10-27 18:19 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
Pranit Bauva <pranit.bauva@gmail.com> writes:
> - bisect_write "$state" "$rev"
> + git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
I can see why two extra "terms" parameters need to be passed to this
helper at this step; looking at patches around 4/8 and 6/8 where C
code can directly find out what words are used for GOOD and BAD, we
should be able to lose these two extra parameters from this helper
by internally making a call to get_terms() from bisect_write() ;-)
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 6/8] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2017-10-27 15:06 ` [PATCH v16 Part II 6/8] bisect--helper: `get_terms` & `bisect_terms` " Pranit Bauva
@ 2017-10-27 20:04 ` Martin Ågren
2017-10-30 17:45 ` Pranit Bauva
2017-10-30 16:34 ` Stephan Beyer
2017-11-08 0:59 ` Ramsay Jones
2 siblings, 1 reply; 320+ messages in thread
From: Martin Ågren @ 2017-10-27 20:04 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Git Mailing List
On 27 October 2017 at 17:06, Pranit Bauva <pranit.bauva@gmail.com> wrote:
> + for (i = 0; i < argc; i++) {
> + if (!strcmp(argv[i], "--term-good"))
> + printf(_("%s\n"), terms->term_good);
> + else if (!strcmp(argv[i], "--term-bad"))
> + printf(_("%s\n"), terms->term_bad);
You seem to have lost --term-old and --term-new. I also wonder why these
would need translating. You break GETTEXT_POISON here, then fix it in
patch 8/8.
I'm not even sure you need patch 8/8. If I drop these two `_()`, I can
run `git rebase -ix "make GETTEXT_POISON=Yes test"` on the entire series
without failure. Patch 8/8 also switches to `test_i18ngrep` for some
usages of `git branch` and for some checks on `.git/BISECT_START`. I'm
not sure that's needed.
> + else
> + error(_("BUG: invalid argument %s for 'git bisect terms'.\n"
> + "Supported options are: "
> + "--term-good|--term-old and "
> + "--term-bad|--term-new."), argv[i]);
> + }
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C
2017-10-27 15:06 ` [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
` (8 preceding siblings ...)
2017-10-27 17:40 ` Junio C Hamano
@ 2017-10-30 13:22 ` Stephan Beyer
2017-10-30 17:27 ` Pranit Bauva
2017-11-08 0:07 ` Ramsay Jones
2019-01-02 15:38 ` [PATCH v17 0/7] git bisect: convert from shell to C Tanushree Tumane via GitGitGadget
11 siblings, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2017-10-30 13:22 UTC (permalink / raw)
To: Pranit Bauva, git
Hi Pranit,
On 10/27/2017 05:06 PM, Pranit Bauva wrote:
> A big thanks to Stephan and Ramsay for patiently reviewing my series and
> helping me get this merged.
You're welcome. ;)
In addition to the things mentioned by the other reviewers, only a minor
thing:
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 35d2105f941c6..12754448f7b6a 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
[...]> @@ -106,13 +112,48 @@ static void check_expected_revs(const char
**revs, int rev_nr)
> }
> }
>
> +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)
> + return !printf(_("We are not bisecting.\n"));
This is weird; I had to look up the return value of printf first before
I could understand what you are doing ;) I think that it is meant as a
shortcut for
printf(_("We are not bisecting.\n"));
return 0;
but please also express it with these two lines. (Or what is the point
of returning a non-zero value only in the case when nothing could be
printed?)
Best,
Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 2/8] bisect--helper: `bisect_write` shell function in C
2017-10-27 15:06 ` [PATCH v16 Part II 2/8] bisect--helper: `bisect_write` " Pranit Bauva
2017-10-27 17:28 ` Martin Ågren
2017-10-27 18:19 ` Junio C Hamano
@ 2017-10-30 13:38 ` Stephan Beyer
2017-10-30 16:24 ` Stephan Beyer
2017-11-08 0:26 ` Ramsay Jones
3 siblings, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2017-10-30 13:38 UTC (permalink / raw)
To: Pranit Bauva, git
Also just a minor in addition to the others:
> @@ -153,9 +241,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> WRITE_TERMS,
> BISECT_CLEAN_STATE,
> CHECK_EXPECTED_REVS,
> - BISECT_RESET
> + BISECT_RESET,
> + BISECT_WRITE
> } cmdmode = 0;
> - int no_checkout = 0;
> + int no_checkout = 0, res = 0;
This last change is not necessary. You never use "res".
Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 2/8] bisect--helper: `bisect_write` shell function in C
2017-10-30 13:38 ` Stephan Beyer
@ 2017-10-30 16:24 ` Stephan Beyer
0 siblings, 0 replies; 320+ messages in thread
From: Stephan Beyer @ 2017-10-30 16:24 UTC (permalink / raw)
To: Pranit Bauva, git
On 10/30/2017 02:38 PM, Stephan Beyer wrote:
> This last change is not necessary. You never use "res".
Whoops, ignore this!
I compared old and new diff and mixed something up, it seems.
Sorry,
Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 6/8] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2017-10-27 15:06 ` [PATCH v16 Part II 6/8] bisect--helper: `get_terms` & `bisect_terms` " Pranit Bauva
2017-10-27 20:04 ` Martin Ågren
@ 2017-10-30 16:34 ` Stephan Beyer
2017-10-30 17:31 ` Pranit Bauva
2017-11-08 0:59 ` Ramsay Jones
2 siblings, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2017-10-30 16:34 UTC (permalink / raw)
To: Pranit Bauva, git
On 10/27/2017 05:06 PM, Pranit Bauva wrote:
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 0f9c3e63821b8..ab0580ce0089a 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
[...]
> +static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
> +{
> + int i;
> +
> + if (get_terms(terms))
> + return error(_("no terms defined"));
> +
> + if (argc > 1)
> + return error(_("--bisect-term requires exactly one argument"));
> +
> + if (argc == 0)
> + return !printf(_("Your current terms are %s for the old state\n"
> + "and %s for the new state.\n"),
> + terms->term_good, terms->term_bad);
Same as in 1/8: you probably want "printf(...); return 0;" except there
is a good reason.
> +
> + for (i = 0; i < argc; i++) {
> + if (!strcmp(argv[i], "--term-good"))
> + printf(_("%s\n"), terms->term_good);
> + else if (!strcmp(argv[i], "--term-bad"))
> + printf(_("%s\n"), terms->term_bad);
The last two printfs: I think there is no point in translating "%s\n",
so using "%s\n" instead of _("%s\n") looks more reasonable.
> + else
> + error(_("BUG: invalid argument %s for 'git bisect terms'.\n"
> + "Supported options are: "
> + "--term-good|--term-old and "
> + "--term-bad|--term-new."), argv[i]);
Should this be "return error(...)"?
> + }
> +
> + return 0;
> +}
> +
Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 7/8] bisect--helper: `bisect_start` shell function partially in C
2017-10-27 15:06 ` [PATCH v16 Part II 7/8] bisect--helper: `bisect_start` shell function partially in C Pranit Bauva
@ 2017-10-30 16:51 ` Stephan Beyer
2017-10-30 17:28 ` Pranit Bauva
2018-02-16 1:22 ` SZEDER Gábor
1 sibling, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2017-10-30 16:51 UTC (permalink / raw)
To: Pranit Bauva, git
Hi,
> + return error(_("unrecognised option: '%s'"), arg);
Please write "unrecogni_z_ed".
Since the string for translation changed from
"unrecognised option: '$arg'"
to
"unrecognised option: '%s'"
anyway, it does not result in further work for the translators to
correct it to
"unrecognized option: '%s'"
Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C
2017-10-27 17:40 ` Junio C Hamano
@ 2017-10-30 17:26 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-10-30 17:26 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Fri, Oct 27, 2017 at 11:10 PM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> +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)
>> + return !printf(_("We are not bisecting.\n"));
>> + 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);
>
> The original checks "test -s BISECT_START" and complains, even when
> an explicit commit is given. With this change, when the user is not
> bisecting, giving "git bisect reset master" goes ahead---it is
> likely that BISECT_HEAD does not exist and we may hit "Could not
> check out" error, but if BISECT_HEAD is left behind from a previous
> run (which is likely completely unrelated to whatever the user
> currently is doing), we'd end up doing quite a random thing, no?
Yes. Thanks for mentioning this point. I don't quite remember things
right now about what made me do this change. There might have been
something which had made me do this change because this isn't just a
silly mistake. Any which ways, I couldn't recollect the reason (should
be more careful to put code comments).
>> + }
>> +
>> + if (!file_exists(git_path_bisect_head())) {
>> + struct argv_array argv = ARGV_ARRAY_INIT;
>> +
>> + argv_array_pushl(&argv, "checkout", branch.buf, "--", NULL);
>> + if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
>> + error(_("Could not check out original HEAD '%s'. Try "
>> + "'git bisect reset <commit>'."), branch.buf);
>> + strbuf_release(&branch);
>> + argv_array_clear(&argv);
>> + return -1;
>
> How does this return value affect the value eventually given to
> exit(3), called by somewhere in git.c that called this function?
>
> The call graph would be
>
> common-main.c::main()
> -> git.c::cmd_main()
> -> handle_builtin()
> . exit(run_builtin())
> -> run_builtin()
> . status = p->fn()
> -> cmd_bisect__helper()
> . return bisect_reset()
> -> bisect_reset()
> . return -1
> . if (status) return status;
>
> So the -1 is returned throughout the callchain and exit(3) ends up
> getting it---which is not quite right. We shouldn't be giving
> negative value to exit(3). bisect_clean_state() and other helper
> functions may already share the same issue.
I had totally missed that exit() takes only single byte value and thus
only positive integers. I think changing it to "return 1;" will do.
There are a few places in the previous series which use "return -1;"
which would need to be changed. I will resend that series.
>> + }
>> + argv_array_clear(&argv);
>> + }
>> +
>> + strbuf_release(&branch);
>> + return bisect_clean_state();
>> +}
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C
2017-10-30 13:22 ` Stephan Beyer
@ 2017-10-30 17:27 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-10-30 17:27 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
On Mon, Oct 30, 2017 at 6:52 PM, Stephan Beyer <s-beyer@gmx.net> wrote:
> Hi Pranit,
>> +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)
>> + return !printf(_("We are not bisecting.\n"));
>
> This is weird; I had to look up the return value of printf first before
> I could understand what you are doing ;) I think that it is meant as a
> shortcut for
>
> printf(_("We are not bisecting.\n"));
> return 0;
>
> but please also express it with these two lines. (Or what is the point
> of returning a non-zero value only in the case when nothing could be
> printed?)
I was just being a little lazy I suppose. I will stick to doing it in
two lines and avoiding fancy things.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 7/8] bisect--helper: `bisect_start` shell function partially in C
2017-10-30 16:51 ` Stephan Beyer
@ 2017-10-30 17:28 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-10-30 17:28 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
On Mon, Oct 30, 2017 at 10:21 PM, Stephan Beyer <s-beyer@gmx.net> wrote:
> Hi,
>
>> + return error(_("unrecognised option: '%s'"), arg);
>
> Please write "unrecogni_z_ed".
>
> Since the string for translation changed from
> "unrecognised option: '$arg'"
> to
> "unrecognised option: '%s'"
> anyway, it does not result in further work for the translators to
> correct it to
> "unrecognized option: '%s'"
Yeah Sure!
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 6/8] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2017-10-30 16:34 ` Stephan Beyer
@ 2017-10-30 17:31 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-10-30 17:31 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Git List
Hey Stephan,
On Mon, Oct 30, 2017 at 10:04 PM, Stephan Beyer <s-beyer@gmx.net> wrote:
> On 10/27/2017 05:06 PM, Pranit Bauva wrote:
>> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
>> index 0f9c3e63821b8..ab0580ce0089a 100644
>> --- a/builtin/bisect--helper.c
>> +++ b/builtin/bisect--helper.c
> [...]
>> +static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
>> +{
>> + int i;
>> +
>> + if (get_terms(terms))
>> + return error(_("no terms defined"));
>> +
>> + if (argc > 1)
>> + return error(_("--bisect-term requires exactly one argument"));
>> +
>> + if (argc == 0)
>> + return !printf(_("Your current terms are %s for the old state\n"
>> + "and %s for the new state.\n"),
>> + terms->term_good, terms->term_bad);
>
> Same as in 1/8: you probably want "printf(...); return 0;" except there
> is a good reason.
No good reason. I will make the change.
>> +
>> + for (i = 0; i < argc; i++) {
>> + if (!strcmp(argv[i], "--term-good"))
>> + printf(_("%s\n"), terms->term_good);
>> + else if (!strcmp(argv[i], "--term-bad"))
>> + printf(_("%s\n"), terms->term_bad);
>
> The last two printfs: I think there is no point in translating "%s\n",
> so using "%s\n" instead of _("%s\n") looks more reasonable.
Also this probably does weird things with GETTEXT_POISON. I am
investigating what's happening as Martin pointed out in other thread..
>> + else
>> + error(_("BUG: invalid argument %s for 'git bisect terms'.\n"
>> + "Supported options are: "
>> + "--term-good|--term-old and "
>> + "--term-bad|--term-new."), argv[i]);
>
> Should this be "return error(...)"?
Yeah. I missed this
>> + }
>> +
>> + return 0;
>> +}
>> +
>
> Stephan
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 2/8] bisect--helper: `bisect_write` shell function in C
2017-10-27 17:28 ` Martin Ågren
@ 2017-10-30 17:35 ` Pranit Bauva
2018-11-23 10:13 ` Johannes Schindelin
0 siblings, 1 reply; 320+ messages in thread
From: Pranit Bauva @ 2017-10-30 17:35 UTC (permalink / raw)
To: Martin Ågren; +Cc: Git List
Hey Martin,
On Fri, Oct 27, 2017 at 10:58 PM, Martin Ågren <martin.agren@gmail.com> wrote:
> On 27 October 2017 at 17:06, Pranit Bauva <pranit.bauva@gmail.com> wrote:
>> +static void free_terms(struct bisect_terms *terms)
>> +{
>> + if (!terms->term_good)
>> + free((void *) terms->term_good);
>> + if (!terms->term_bad)
>> + free((void *) terms->term_bad);
>> +}
>
> These look like no-ops. Remove `!` for correctness, or `if (...)` for
> simplicity, since `free()` can handle NULL.
I probably forgot to do this here. I will make the change.
> You leave the pointers dangling, but you're ok for now since this is the
> last thing that happens in `cmd_bisect__helper()`. Your later patches
> add more users, but they're also ok, since they immediately assign new
> values.
>
> In case you (and others) find it useful, the below is a patch I've been
> sitting on for a while as part of a series to plug various memory-leaks.
> `FREE_AND_NULL_CONST()` would be useful in precisely these situations.
Honestly, I wouldn't be the best person to judge this.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 2/8] bisect--helper: `bisect_write` shell function in C
2017-10-27 18:19 ` Junio C Hamano
@ 2017-10-30 17:38 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-10-30 17:38 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git List
Hey Junio,
On Fri, Oct 27, 2017 at 11:49 PM, Junio C Hamano <gitster@pobox.com> wrote:
> Pranit Bauva <pranit.bauva@gmail.com> writes:
>
>> - bisect_write "$state" "$rev"
>> + git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
>
> I can see why two extra "terms" parameters need to be passed to this
> helper at this step; looking at patches around 4/8 and 6/8 where C
> code can directly find out what words are used for GOOD and BAD, we
> should be able to lose these two extra parameters from this helper
> by internally making a call to get_terms() from bisect_write() ;-)
Yes quite true, but then after converting bisect_skip() we can
completely get rid of this line and then it won't be needed in the
ported C code.
PS: I have already ported that function but those patches are local as of now.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 5/8] bisect--helper: `bisect_next_check` shell function in C
2017-10-27 17:35 ` Martin Ågren
@ 2017-10-30 17:40 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-10-30 17:40 UTC (permalink / raw)
To: Martin Ågren; +Cc: Git Mailing List, Jiang Xin
Hey Martin,
On Fri, Oct 27, 2017 at 11:05 PM, Martin Ågren <martin.agren@gmail.com> wrote:
> On 27 October 2017 at 17:06, Pranit Bauva <pranit.bauva@gmail.com> wrote:
>> + /*
>> + * have bad (or new) but not good (or old). We could bisect
>> + * although this is less optimum.
>> + */
>> + fprintf(stderr, _("Warning: bisecting only with a %s commit\n"),
>> + terms->term_bad);
>
> Maybe this should use `warning()`?
Yeah. That would be better.
>> - # have bad (or new) but not good (or old). we could bisect although
>> - # this is less optimum.
>> - eval_gettextln "Warning: bisecting only with a \$TERM_BAD commit." >&2
>
> I wonder if we can somehow pick up the existing translation? It would
> now be fuzzy, in some sense, but since the string was originally in a
> different file, maybe the po-tools won't be able to discover the
> fuzzyness? We could add a TRANSLATORS-comment, so that the translators
> know that this string matches an old one. There are more strings like
> that in this patch, and maybe in some others as well, I haven't looked.
>
> (Adding Jiang to cc.)
Since I am re-rolling my previous series as well, I can make the
change in all patches.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 6/8] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2017-10-27 20:04 ` Martin Ågren
@ 2017-10-30 17:45 ` Pranit Bauva
0 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva @ 2017-10-30 17:45 UTC (permalink / raw)
To: Martin Ågren; +Cc: Git Mailing List
Hey Martin,
On Sat, Oct 28, 2017 at 1:34 AM, Martin Ågren <martin.agren@gmail.com> wrote:
> On 27 October 2017 at 17:06, Pranit Bauva <pranit.bauva@gmail.com> wrote:
>> + for (i = 0; i < argc; i++) {
>> + if (!strcmp(argv[i], "--term-good"))
>> + printf(_("%s\n"), terms->term_good);
>> + else if (!strcmp(argv[i], "--term-bad"))
>> + printf(_("%s\n"), terms->term_bad);
>
> You seem to have lost --term-old and --term-new. I also wonder why these
> would need translating. You break GETTEXT_POISON here, then fix it in
> patch 8/8.
>
> I'm not even sure you need patch 8/8. If I drop these two `_()`, I can
> run `git rebase -ix "make GETTEXT_POISON=Yes test"` on the entire series
> without failure. Patch 8/8 also switches to `test_i18ngrep` for some
> usages of `git branch` and for some checks on `.git/BISECT_START`. I'm
> not sure that's needed.
Maybe. I am not quite familiar with what does GETTEXT_POISON exactly
does, so I will probably investigate further in this.
Regards,
Pranit Bauva
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C
2017-10-27 15:06 ` [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
` (9 preceding siblings ...)
2017-10-30 13:22 ` Stephan Beyer
@ 2017-11-08 0:07 ` Ramsay Jones
2019-01-02 15:38 ` [PATCH v17 0/7] git bisect: convert from shell to C Tanushree Tumane via GitGitGadget
11 siblings, 0 replies; 320+ messages in thread
From: Ramsay Jones @ 2017-11-08 0:07 UTC (permalink / raw)
To: Pranit Bauva, git
On 27/10/17 16:06, Pranit Bauva wrote:
> Reimplement `bisect_reset` shell function in C and add a `--bisect-reset`
> subcommand to `git bisect--helper` to call it from git-bisect.sh .
>
> Using `bisect_reset` subcommand is a temporary measure to port shell
> functions to C so as to use the existing test suite. As more functions
> are ported, this subcommand would be retired but its implementation will
> be called by some other method.
>
> Note: --bisect-clean-state subcommand has not been retired as there are
> still a function namely `bisect_start()` which still uses this
> subcommand.
>
> Mentored-by: Lars Schneider <larsxschneider@gmail.com>
> Mentored-by: Christian Couder <chriscool@tuxfamily.org>
> Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
>
> ---
[snip]
Sorry for not responding sooner, I've been a bit busy.
Unfortunately, I have only had time to skim the patches, but
I haven't noticed anything too serious.
> builtin/bisect--helper.c | 49 +++++++++++++++++++++++++++++++++++++++++++++++-
> git-bisect.sh | 28 ++-------------------------
> 2 files changed, 50 insertions(+), 27 deletions(-)
>
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 35d2105f941c6..12754448f7b6a 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -3,15 +3,21 @@
> #include "parse-options.h"
> #include "bisect.h"
> #include "refs.h"
> +#include "dir.h"
> +#include "argv-array.h"
> +#include "run-command.h"
>
> static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
> static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
> static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
> +static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
> +static GIT_PATH_FUNC(git_path_bisect_head, "BISECT_HEAD")
>
> static const char * const git_bisect_helper_usage[] = {
> N_("git bisect--helper --next-all [--no-checkout]"),
> N_("git bisect--helper --write-terms <bad_term> <good_term>"),
> N_("git bisect--helper --bisect-clean-state"),
> + N_("git bisect--helper --bisect-reset [<commit>]"),
> NULL
> };
>
> @@ -106,13 +112,48 @@ static void check_expected_revs(const char **revs, int rev_nr)
> }
> }
>
> +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)
> + return !printf(_("We are not bisecting.\n"));
I've no idea what this is about! If printf encounters an error, then
this will be equivalent to !-1. If printf does not encounter an error,
then this will be !<length of output> (whatever that may be, given that
the string is marked for translation).
I would suggest that you don't want to do that. ;-)
ATB,
Ramsay Jones
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 2/8] bisect--helper: `bisect_write` shell function in C
2017-10-27 15:06 ` [PATCH v16 Part II 2/8] bisect--helper: `bisect_write` " Pranit Bauva
` (2 preceding siblings ...)
2017-10-30 13:38 ` Stephan Beyer
@ 2017-11-08 0:26 ` Ramsay Jones
3 siblings, 0 replies; 320+ messages in thread
From: Ramsay Jones @ 2017-11-08 0:26 UTC (permalink / raw)
To: Pranit Bauva, git
On 27/10/17 16:06, Pranit Bauva wrote:
> Reimplement the `bisect_write` shell function in C and add a
> `bisect-write` subcommand to `git bisect--helper` to call it from
> git-bisect.sh
>
> Using `--bisect-write` subcommand is a temporary measure to port shell
> function in C so as to use the existing test suite. As more functions
> are ported, this subcommand will be retired but its implementation will
> be called by some other methods.
>
> Note: bisect_write() uses two variables namely TERM_GOOD and TERM_BAD
> from the global shell script thus we need to pass it to the subcommand
> using the arguments. We then store them in a struct bisect_terms and
> pass the memory address around functions.
>
> Add a log_commit() helper function to write the contents of the commit message
> header to a file which will be re-used in future parts of the code as
> well.
>
> Also introduce a function free_terms() to free the memory of `struct
> bisect_terms` and set_terms() to set the values of members in `struct
> bisect_terms`.
>
> Helped-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
> Mentored-by: Lars Schneider <larsxschneider@gmail.com>
> Mentored-by: Christian Couder <chriscool@tuxfamily.org>
> Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
> ---
> builtin/bisect--helper.c | 107 +++++++++++++++++++++++++++++++++++++++++++++--
> git-bisect.sh | 25 ++---------
> 2 files changed, 108 insertions(+), 24 deletions(-)
>
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 12754448f7b6a..6295f53c850a8 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -12,15 +12,37 @@ static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
> static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
> static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
> static GIT_PATH_FUNC(git_path_bisect_head, "BISECT_HEAD")
> +static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
>
> static const char * const git_bisect_helper_usage[] = {
> N_("git bisect--helper --next-all [--no-checkout]"),
> N_("git bisect--helper --write-terms <bad_term> <good_term>"),
> N_("git bisect--helper --bisect-clean-state"),
> N_("git bisect--helper --bisect-reset [<commit>]"),
> + N_("git bisect--helper --bisect-write <state> <revision> <good_term> <bad_term> [<nolog>]"),
> NULL
> };
>
> +struct bisect_terms {
> + const char *term_good;
> + const char *term_bad;
> +};
> +
> +static void free_terms(struct bisect_terms *terms)
> +{
> + if (!terms->term_good)
> + free((void *) terms->term_good);> + if (!terms->term_bad)
> + free((void *) terms->term_bad);
You can pass a NULL pointer to free(), so the conditionals here
are not required.
> +}
> +
> +static void set_terms(struct bisect_terms *terms, const char *bad,
> + const char *good)
> +{
> + terms->term_good = xstrdup(good);
> + terms->term_bad = xstrdup(bad);
> +}
> +
> /*
> * Check whether the string `term` belongs to the set of strings
> * included in the variable arguments.
> @@ -146,6 +168,72 @@ static int bisect_reset(const char *commit)
> return bisect_clean_state();
> }
>
> +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;
> + int retval = 0;
> +
> + 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 {
> + error(_("Bad bisect_write argument: %s"), state);
> + goto fail;
> + }
> +
> + if (get_oid(rev, &oid)) {
> + error(_("couldn't get the oid of the rev '%s'"), rev);
> + goto fail;
> + }
> +
> + if (update_ref(NULL, tag.buf, &oid, NULL, 0,
> + UPDATE_REFS_MSG_ON_ERR))
> + goto fail;
> +
> + fp = fopen(git_path_bisect_log(), "a");
> + if (!fp) {
> + error_errno(_("couldn't open the file '%s'"), git_path_bisect_log());
> + goto fail;
> + }
> +
> + commit = lookup_commit_reference(&oid);
> + log_commit(fp, "%s", state, commit);
> +
> + if (!nolog)
> + fprintf(fp, "git bisect %s %s\n", state, rev);
> +
> + goto finish;
> +
> +fail:
> + retval = -1;
> +finish:
> + if (fp)
> + fclose(fp);
> + strbuf_release(&tag);
> + return retval;
> +}
> +
> int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> {
> enum {
> @@ -153,9 +241,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> WRITE_TERMS,
> BISECT_CLEAN_STATE,
> CHECK_EXPECTED_REVS,
> - BISECT_RESET
> + BISECT_RESET,
> + BISECT_WRITE
> } cmdmode = 0;
> - int no_checkout = 0;
> + int no_checkout = 0, res = 0;
> struct option options[] = {
> OPT_CMDMODE(0, "next-all", &cmdmode,
> N_("perform 'git bisect next'"), NEXT_ALL),
> @@ -167,10 +256,13 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
> N_("check for expected revs"), CHECK_EXPECTED_REVS),
> OPT_CMDMODE(0, "bisect-reset", &cmdmode,
> N_("reset the bisection state"), BISECT_RESET),
> + OPT_CMDMODE(0, "bisect-write", &cmdmode,
> + N_("update the refs according to the bisection state and may write it to BISECT_LOG"), BISECT_WRITE),
Is the "... and may write it to" necessary? ;-)
[The original was just: "write out the bisection state in BISECT_LOG"]
ATB,
Ramsay Jones
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 4/8] bisect--helper: `check_and_set_terms` shell function in C
2017-10-27 15:06 ` [PATCH v16 Part II 4/8] bisect--helper: `check_and_set_terms` " Pranit Bauva
@ 2017-11-08 0:37 ` Ramsay Jones
0 siblings, 0 replies; 320+ messages in thread
From: Ramsay Jones @ 2017-11-08 0:37 UTC (permalink / raw)
To: Pranit Bauva, git
On 27/10/17 16:06, Pranit Bauva wrote:
> Reimplement the `check_and_set_terms` shell function in C and add
> `check-and-set-terms` subcommand to `git bisect--helper` to call it from
> git-bisect.sh
>
> Using `--check-and-set-terms` subcommand is a temporary measure to port
> shell function in C so as to use the existing test suite. As more
> functions are ported, this subcommand will be retired but its
> implementation will be called by some other methods.
>
> check_and_set_terms() sets and receives two global variables namely
> TERM_GOOD and TERM_BAD in the shell script. Luckily the file BISECT_TERMS
> also contains the value of those variables so its appropriate to evoke the
> method get_terms() after calling the subcommand so that it retrieves the
> value of TERM_GOOD and TERM_BAD from the file BISECT_TERMS. The two
> global variables are passed as arguments to the subcommand.
>
> Mentored-by: Lars Schneider <larsxschneider@gmail.com>
> Mentored-by: Christian Couder <chriscool@tuxfamily.org>
> Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
> ---
> builtin/bisect--helper.c | 41 ++++++++++++++++++++++++++++++++++++++++-
> git-bisect.sh | 36 ++++--------------------------------
> 2 files changed, 44 insertions(+), 33 deletions(-)
>
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 6295f53c850a8..65abf8a70c6d9 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -20,6 +20,7 @@ static const char * const git_bisect_helper_usage[] = {
> N_("git bisect--helper --bisect-clean-state"),
> N_("git bisect--helper --bisect-reset [<commit>]"),
> N_("git bisect--helper --bisect-write <state> <revision> <good_term> <bad_term> [<nolog>]"),
> + N_("git bisect--helper --bisect-check-and-set-terms <command> <good_term> <bad_term>"),
> NULL
> };
>
> @@ -234,6 +235,35 @@ static int bisect_write(const char *state, const char *rev,
> return retval;
> }
>
> +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)) {
> + free_terms(terms);
> + set_terms(terms, "bad", "good");
> + return write_terms(terms->term_bad, terms->term_good);
> + }
> + else if (one_of(cmd, "new", "old", NULL)) {
cuddle the else: '} else if (one_of(....)) {'
OR, simply remove the else.
ATB,
Ramsay Jones
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 5/8] bisect--helper: `bisect_next_check` shell function in C
2017-10-27 15:06 ` [PATCH v16 Part II 5/8] bisect--helper: `bisect_next_check` shell function " Pranit Bauva
2017-10-27 17:35 ` Martin Ågren
@ 2017-11-08 0:48 ` Ramsay Jones
2017-11-12 19:19 ` Stephan Beyer
` (2 subsequent siblings)
4 siblings, 0 replies; 320+ messages in thread
From: Ramsay Jones @ 2017-11-08 0:48 UTC (permalink / raw)
To: Pranit Bauva, git
On 27/10/17 16:06, Pranit Bauva wrote:
> Reimplement `bisect_next_check` shell function in C and add
> `bisect-next-check` subcommand to `git bisect--helper` to call it from
> git-bisect.sh .
>
> `bisect_voc` shell function is no longer useful now and is replaced by
> using a char *[] of "new|bad" and "good|old" values.
>
> Using `--bisect-next-check` is a temporary measure to port shell
> function to C so as to use the existing test suite. As more functions
> are ported, this subcommand will be retired but its implementation will
> be called by some other methods.
>
> Helped-by: Stephan Beyer <s-beyer@gmx.net>
> Mentored-by: Lars Schneider <larsxschneider@gmail.com>
> Mentored-by: Christian Couder <chriscool@tuxfamily.org>
> Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
> ---
> builtin/bisect--helper.c | 91 +++++++++++++++++++++++++++++++++++++++++++++++-
> git-bisect.sh | 60 +++----------------------------
> 2 files changed, 94 insertions(+), 57 deletions(-)
>
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 65abf8a70c6d9..0f9c3e63821b8 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -6,6 +6,7 @@
> #include "dir.h"
> #include "argv-array.h"
> #include "run-command.h"
> +#include "prompt.h"
>
> static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
> static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
> @@ -21,6 +22,7 @@ static const char * const git_bisect_helper_usage[] = {
> N_("git bisect--helper --bisect-reset [<commit>]"),
> N_("git bisect--helper --bisect-write <state> <revision> <good_term> <bad_term> [<nolog>]"),
> N_("git bisect--helper --bisect-check-and-set-terms <command> <good_term> <bad_term>"),
> + N_("git bisect--helper --bisect-next-check [<term>] <good_term> <bad_term>"),
> NULL
> };
>
> @@ -44,6 +46,11 @@ static void set_terms(struct bisect_terms *terms, const char *bad,
> terms->term_bad = xstrdup(bad);
> }
>
> +static const char *voc[] = {
> + "bad|new",
> + "good|old"
> +};
> +
In my version I had this instead:
+static const char *vocab_bad = "bad|new";
+static const char *vocab_good = "good|old";
+
which I prefer, because ...
> /*
> * Check whether the string `term` belongs to the set of strings
> * included in the variable arguments.
> @@ -264,6 +271,79 @@ static int check_and_set_terms(struct bisect_terms *terms, const char *cmd)
> return 0;
> }
>
> +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;
> +}
> +
> +static int bisect_next_check(const struct bisect_terms *terms,
> + const char *current_term)
> +{
> + int missing_good = 1, missing_bad = 1, retval = 0;
> + const char *bad_ref = xstrfmt("refs/bisect/%s", terms->term_bad);
> + const 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);
> +
> + if (!missing_good && !missing_bad)
> + goto finish;
> +
> + if (!current_term)
> + goto fail;
> +
> + if (missing_good && !missing_bad && current_term &&
> + !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.
> + */
> + fprintf(stderr, _("Warning: bisecting only with a %s commit\n"),
> + terms->term_bad);
> + if (!isatty(0))
> + goto finish;
> + /*
> + * 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"))
> + goto fail;
> +
> + goto finish;
> + }
> + if (!is_empty_or_missing_file(git_path_bisect_start())) {
> + error(_("You need to give me at least one %s and "
> + "%s revision. You can use \"git bisect %s\" "
> + "and \"git bisect %s\" for that.\n"),
> + voc[0], voc[1], voc[0], voc[1]);
... this is (arguably) easier to read:
+ vocab_bad, vocab_good, vocab_bad, vocab_good);
> + goto fail;
> + } else {
> + error(_("You need to start by \"git bisect start\". You "
> + "then need to give me at least one %s and %s "
> + "revision. You can use \"git bisect %s\" and "
> + "\"git bisect %s\" for that.\n"),
> + voc[1], voc[0], voc[1], voc[0]);
ditto
ATB,
Ramsay Jones
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 6/8] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2017-10-27 15:06 ` [PATCH v16 Part II 6/8] bisect--helper: `get_terms` & `bisect_terms` " Pranit Bauva
2017-10-27 20:04 ` Martin Ågren
2017-10-30 16:34 ` Stephan Beyer
@ 2017-11-08 0:59 ` Ramsay Jones
2 siblings, 0 replies; 320+ messages in thread
From: Ramsay Jones @ 2017-11-08 0:59 UTC (permalink / raw)
To: Pranit Bauva, git
On 27/10/17 16:06, Pranit Bauva wrote:
> Reimplement the `get_terms` and `bisect_terms` shell function in C and
> add `bisect-terms` subcommand to `git bisect--helper` to call it from
> git-bisect.sh .
>
> Using `--bisect-terms` subcommand is a temporary measure to port shell
> function in C so as to use the existing test suite. As more functions
> are ported, this subcommand will be retired but its implementation will
> be called by some other methods.
>
> Also use error() to report "no terms defined" and accordingly change the
> test in t6030.
>
> Mentored-by: Lars Schneider <larsxschneider@gmail.com>
> Mentored-by: Christian Couder <chriscool@tuxfamily.org>
> Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
> ---
> builtin/bisect--helper.c | 69 +++++++++++++++++++++++++++++++++++++++++++--
> git-bisect.sh | 35 ++---------------------
> t/t6030-bisect-porcelain.sh | 2 +-
> 3 files changed, 70 insertions(+), 36 deletions(-)
>
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index 0f9c3e63821b8..ab0580ce0089a 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> @@ -23,6 +23,7 @@ static const char * const git_bisect_helper_usage[] = {
> N_("git bisect--helper --bisect-write <state> <revision> <good_term> <bad_term> [<nolog>]"),
> N_("git bisect--helper --bisect-check-and-set-terms <command> <good_term> <bad_term>"),
> N_("git bisect--helper --bisect-next-check [<term>] <good_term> <bad_term>"),
> + N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
> NULL
> };
>
> @@ -344,6 +345,62 @@ static int bisect_next_check(const struct bisect_terms *terms,
> return retval;
> }
>
> +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)
> + goto fail;
> +
> + 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);
> + goto finish;
> +
> +fail:
> + res = -1;
> +finish:
> + if (fp)
> + fclose(fp);
> + strbuf_release(&str);
> + return res;
> +}
> +
> +static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
> +{
> + int i;
> +
> + if (get_terms(terms))
> + return error(_("no terms defined"));
> +
> + if (argc > 1)
> + return error(_("--bisect-term requires exactly one argument"));
> +
> + if (argc == 0)
> + return !printf(_("Your current terms are %s for the old state\n"
> + "and %s for the new state.\n"),
> + terms->term_good, terms->term_bad);
Again, I don't think you want to do this. :-D
> +
> + for (i = 0; i < argc; i++) {
> + if (!strcmp(argv[i], "--term-good"))> + printf(_("%s\n"), terms->term_good);
> + else if (!strcmp(argv[i], "--term-bad"))
> + printf(_("%s\n"), terms->term_bad);
> + else
Here, you want to check for the pairs "--term-{good,old}" and
"--term-{bad,new}", so maybe this instead:
+ if (one_of(argv[i], "--term-good", "--term-old", NULL))
+ printf("%s\n", terms->term_good);
+ else if (one_of(argv[i], "--term-bad", "--term-new", NULL))
+ printf("%s\n", terms->term_bad);
+ else
> + error(_("BUG: invalid argument %s for 'git bisect terms'.\n"
> + "Supported options are: "
> + "--term-good|--term-old and "
> + "--term-bad|--term-new."), argv[i]);
> + }
> +
> + return 0;
> +}
> +
ATB,
Ramsay Jones
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 5/8] bisect--helper: `bisect_next_check` shell function in C
2017-10-27 15:06 ` [PATCH v16 Part II 5/8] bisect--helper: `bisect_next_check` shell function " Pranit Bauva
2017-10-27 17:35 ` Martin Ågren
2017-11-08 0:48 ` Ramsay Jones
@ 2017-11-12 19:19 ` Stephan Beyer
2017-11-12 19:27 ` Stephan Beyer
2017-11-12 20:03 ` Stephan Beyer
4 siblings, 0 replies; 320+ messages in thread
From: Stephan Beyer @ 2017-11-12 19:19 UTC (permalink / raw)
To: Pranit Bauva, git
Hi,
another minor:
On 10/27/2017 05:06 PM, Pranit Bauva wrote:
> @@ -264,6 +271,79 @@ static int check_and_set_terms(struct bisect_terms *terms, const char *cmd)
> return 0;
> }
>
> +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;
> +}
> +
> +static int bisect_next_check(const struct bisect_terms *terms,
> + const char *current_term)
> +{
> + int missing_good = 1, missing_bad = 1, retval = 0;
> + const char *bad_ref = xstrfmt("refs/bisect/%s", terms->term_bad);
> + const 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);
> +
> + if (!missing_good && !missing_bad)
> + goto finish;
> +
> + if (!current_term)
> + goto fail;
> +
> + if (missing_good && !missing_bad && current_term &&
This check for "current_term" is not necessary; it can be asserted to be
non-NULL, otherwise you would have jumped to "fail"
Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 5/8] bisect--helper: `bisect_next_check` shell function in C
2017-10-27 15:06 ` [PATCH v16 Part II 5/8] bisect--helper: `bisect_next_check` shell function " Pranit Bauva
` (2 preceding siblings ...)
2017-11-12 19:19 ` Stephan Beyer
@ 2017-11-12 19:27 ` Stephan Beyer
2017-11-12 20:03 ` Stephan Beyer
4 siblings, 0 replies; 320+ messages in thread
From: Stephan Beyer @ 2017-11-12 19:27 UTC (permalink / raw)
To: Pranit Bauva, git
> @@ -21,6 +22,7 @@ static const char * const git_bisect_helper_usage[] = {
> N_("git bisect--helper --bisect-reset [<commit>]"),
> N_("git bisect--helper --bisect-write <state> <revision> <good_term> <bad_term> [<nolog>]"),
> N_("git bisect--helper --bisect-check-and-set-terms <command> <good_term> <bad_term>"),
> + N_("git bisect--helper --bisect-next-check [<term>] <good_term> <bad_term>"),
I think the order is wrong. It is <good_term> <bad_term> [<term>]
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 5/8] bisect--helper: `bisect_next_check` shell function in C
2017-10-27 15:06 ` [PATCH v16 Part II 5/8] bisect--helper: `bisect_next_check` shell function " Pranit Bauva
` (3 preceding siblings ...)
2017-11-12 19:27 ` Stephan Beyer
@ 2017-11-12 20:03 ` Stephan Beyer
2017-11-13 3:56 ` Junio C Hamano
4 siblings, 1 reply; 320+ messages in thread
From: Stephan Beyer @ 2017-11-12 20:03 UTC (permalink / raw)
To: Pranit Bauva, git
Hi again ;)
On 10/27/2017 05:06 PM, Pranit Bauva wrote:
> @@ -44,6 +46,11 @@ static void set_terms(struct bisect_terms *terms, const char *bad,
> terms->term_bad = xstrdup(bad);
> }
>
> +static const char *voc[] = {
> + "bad|new",
> + "good|old"
> +};
> +
> /*
> * Check whether the string `term` belongs to the set of strings
> * included in the variable arguments.
> @@ -264,6 +271,79 @@ static int check_and_set_terms(struct bisect_terms *terms, const char *cmd)
> return 0;
> }
>
> +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;
> +}
> +
> +static int bisect_next_check(const struct bisect_terms *terms,
> + const char *current_term)
> +{
> + int missing_good = 1, missing_bad = 1, retval = 0;
> + const char *bad_ref = xstrfmt("refs/bisect/%s", terms->term_bad);
> + const 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);
> +
> + if (!missing_good && !missing_bad)
> + goto finish;
> +
> + if (!current_term)
> + goto fail;
> +
> + if (missing_good && !missing_bad && current_term &&
> + !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.
> + */
> + fprintf(stderr, _("Warning: bisecting only with a %s commit\n"),
> + terms->term_bad);
> + if (!isatty(0))
> + goto finish;
> + /*
> + * 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"))
> + goto fail;
> +
> + goto finish;
> + }
> + if (!is_empty_or_missing_file(git_path_bisect_start())) {
> + error(_("You need to give me at least one %s and "
> + "%s revision. You can use \"git bisect %s\" "
> + "and \"git bisect %s\" for that.\n"),
> + voc[0], voc[1], voc[0], voc[1]);
> + goto fail;
> + } else {
> + error(_("You need to start by \"git bisect start\". You "
> + "then need to give me at least one %s and %s "
> + "revision. You can use \"git bisect %s\" and "
> + "\"git bisect %s\" for that.\n"),
> + voc[1], voc[0], voc[1], voc[0]);
> + goto fail;
In both of the above "error" calls, you should drop the final "\n"
because "error" does that already.
On the other hand, you have dropped the "\n"s of the orginal error
messages. So it should probably be
_("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.")
and
_("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.")
Stephan
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 5/8] bisect--helper: `bisect_next_check` shell function in C
2017-11-12 20:03 ` Stephan Beyer
@ 2017-11-13 3:56 ` Junio C Hamano
0 siblings, 0 replies; 320+ messages in thread
From: Junio C Hamano @ 2017-11-13 3:56 UTC (permalink / raw)
To: Stephan Beyer; +Cc: Pranit Bauva, git
Stephan Beyer <s-beyer@gmx.net> writes:
> Hi again ;)
> ...
> In both of the above "error" calls, you should drop the final "\n"
> because "error" does that already.
>
> On the other hand, you have dropped the "\n"s of the orginal error
> messages. So it should probably be
>
> _("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.")
>
> and
>
> _("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.")
>
> Stephan
Thanks for reviews (not just this patch, but for reviews on other
patches, too).
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 6/6] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C
2017-09-29 6:49 ` [PATCH v16 6/6] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C Pranit Bauva
@ 2017-11-19 20:34 ` Christian Couder
2017-11-20 3:05 ` Junio C Hamano
0 siblings, 1 reply; 320+ messages in thread
From: Christian Couder @ 2017-11-19 20:34 UTC (permalink / raw)
To: Pranit Bauva; +Cc: git
On Fri, Sep 29, 2017 at 8:49 AM, Pranit Bauva <pranit.bauva@gmail.com> wrote:
> Reimplement `is_expected_rev` & `check_expected_revs` shell function in
> C and add a `--check-expected-revs` subcommand to `git bisect--helper` to
> call it from git-bisect.sh .
It looks like this patch forgot to add the `--check-expected-revs`
subcommand to the usage string.
Pranit could you send a fix for that?
Thanks,
Christian.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 6/6] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C
2017-11-19 20:34 ` Christian Couder
@ 2017-11-20 3:05 ` Junio C Hamano
2017-11-20 7:03 ` Christian Couder
0 siblings, 1 reply; 320+ messages in thread
From: Junio C Hamano @ 2017-11-20 3:05 UTC (permalink / raw)
To: Christian Couder; +Cc: Pranit Bauva, git
Christian Couder <christian.couder@gmail.com> writes:
> On Fri, Sep 29, 2017 at 8:49 AM, Pranit Bauva <pranit.bauva@gmail.com> wrote:
>> Reimplement `is_expected_rev` & `check_expected_revs` shell function in
>> C and add a `--check-expected-revs` subcommand to `git bisect--helper` to
>> call it from git-bisect.sh .
>
> It looks like this patch forgot to add the `--check-expected-revs`
> subcommand to the usage string.
Usage string of what? "git bisect"?
I do not think bisect--helper even needs to have end-user facing
"usage string", but "git bisect--helper -h" still gets the new thing
listed in its output for free thanks to parse-options API, so that
is not what you found "this patch forgot to add" and you are making
me scratch my head.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 6/6] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C
2017-11-20 3:05 ` Junio C Hamano
@ 2017-11-20 7:03 ` Christian Couder
0 siblings, 0 replies; 320+ messages in thread
From: Christian Couder @ 2017-11-20 7:03 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Pranit Bauva, git
On Mon, Nov 20, 2017 at 4:05 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Christian Couder <christian.couder@gmail.com> writes:
>
>> On Fri, Sep 29, 2017 at 8:49 AM, Pranit Bauva <pranit.bauva@gmail.com> wrote:
>>> Reimplement `is_expected_rev` & `check_expected_revs` shell function in
>>> C and add a `--check-expected-revs` subcommand to `git bisect--helper` to
>>> call it from git-bisect.sh .
>>
>> It looks like this patch forgot to add the `--check-expected-revs`
>> subcommand to the usage string.
>
> Usage string of what? "git bisect"?
bisect--helper
> I do not think bisect--helper even needs to have end-user facing
> "usage string", but "git bisect--helper -h" still gets the new thing
> listed in its output for free thanks to parse-options API, so that
> is not what you found "this patch forgot to add" and you are making
> me scratch my head.
Right now in master the usage string for bisect--helper is:
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-clean-state"),
NULL
};
So it lists 3 of the command modes out of 4. The missing one is for
--check-expected-revs.
For consistency I think it would be nice to add the missing one.
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 7/8] bisect--helper: `bisect_start` shell function partially in C
2017-10-27 15:06 ` [PATCH v16 Part II 7/8] bisect--helper: `bisect_start` shell function partially in C Pranit Bauva
2017-10-30 16:51 ` Stephan Beyer
@ 2018-02-16 1:22 ` SZEDER Gábor
1 sibling, 0 replies; 320+ messages in thread
From: SZEDER Gábor @ 2018-02-16 1:22 UTC (permalink / raw)
To: Pranit Bauva; +Cc: SZEDER Gábor, git
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> index ab0580ce0089a..4ac175c49e80c 100644
> --- a/builtin/bisect--helper.c
> +++ b/builtin/bisect--helper.c
> + /*
> + * 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) {
> + struct argv_array argv = ARGV_ARRAY_INIT;
> +
> + argv_array_pushl(&argv, "checkout", start_head.buf,
> + "--", NULL);
> + if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
> + error(_("checking out '%s' failed. Try 'git "
> + "bisect start <valid-branch>'."),
> + start_head.buf);
> + goto fail;
> + }
> + }
> + } 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, sha1_to_hex(head_oid.hash));
Please use oid_to_hex(&head_oid) instead of sha1_to_hex().
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 2/8] bisect--helper: `bisect_write` shell function in C
2017-10-30 17:35 ` Pranit Bauva
@ 2018-11-23 10:13 ` Johannes Schindelin
2018-11-23 12:22 ` Martin Ågren
0 siblings, 1 reply; 320+ messages in thread
From: Johannes Schindelin @ 2018-11-23 10:13 UTC (permalink / raw)
To: Pranit Bauva; +Cc: Martin Ågren, Tanushree Tumane, Git List
[-- Attachment #1: Type: text/plain, Size: 1621 bytes --]
Hi Pranit,
(Cc:ing Tanushree because they will try to pick up this patch series as
part of the Outreachy program.)
On Mon, 30 Oct 2017, Pranit Bauva wrote:
> On Fri, Oct 27, 2017 at 10:58 PM, Martin Ågren <martin.agren@gmail.com> wrote:
> > On 27 October 2017 at 17:06, Pranit Bauva <pranit.bauva@gmail.com> wrote:
> >> +static void free_terms(struct bisect_terms *terms)
> >> +{
> >> + if (!terms->term_good)
> >> + free((void *) terms->term_good);
> >> + if (!terms->term_bad)
> >> + free((void *) terms->term_bad);
> >> +}
> >
> > These look like no-ops. Remove `!` for correctness, or `if (...)` for
> > simplicity, since `free()` can handle NULL.
>
> I probably forgot to do this here. I will make the change.
>
> > You leave the pointers dangling, but you're ok for now since this is the
> > last thing that happens in `cmd_bisect__helper()`. Your later patches
> > add more users, but they're also ok, since they immediately assign new
> > values.
> >
> > In case you (and others) find it useful, the below is a patch I've been
> > sitting on for a while as part of a series to plug various memory-leaks.
> > `FREE_AND_NULL_CONST()` would be useful in precisely these situations.
>
> Honestly, I wouldn't be the best person to judge this.
Git's source code implicitly assumes that any `const` pointer refers to
memory owned by another code path. It is therefore probably not a good
idea to encourage `free()`ing a `const` pointer.
Which brings me back to the question: who really owns that allocated
memory to which `term_good` and `term_bad` refer?
Ciao,
Johannes
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 2/8] bisect--helper: `bisect_write` shell function in C
2018-11-23 10:13 ` Johannes Schindelin
@ 2018-11-23 12:22 ` Martin Ågren
2018-11-26 18:18 ` Johannes Schindelin
0 siblings, 1 reply; 320+ messages in thread
From: Martin Ågren @ 2018-11-23 12:22 UTC (permalink / raw)
To: Johannes Schindelin; +Cc: Pranit Bauva, tanushreetumane, Git Mailing List
On Fri, 23 Nov 2018 at 11:13, Johannes Schindelin
<Johannes.Schindelin@gmx.de> wrote:
> On Mon, 30 Oct 2017, Pranit Bauva wrote:
>
> > On Fri, Oct 27, 2017 at 10:58 PM, Martin Ågren <martin.agren@gmail.com> wrote:
> > > On 27 October 2017 at 17:06, Pranit Bauva <pranit.bauva@gmail.com> wrote:
> > >> +static void free_terms(struct bisect_terms *terms)
> > >> +{
> > >> + if (!terms->term_good)
> > >> + free((void *) terms->term_good);
> > >> + if (!terms->term_bad)
> > >> + free((void *) terms->term_bad);
> > >> +}
> > > You leave the pointers dangling, but you're ok for now since this is the
> > > last thing that happens in `cmd_bisect__helper()`. Your later patches
> > > add more users, but they're also ok, since they immediately assign new
> > > values.
> > >
> > > In case you (and others) find it useful, the below is a patch I've been
> > > sitting on for a while as part of a series to plug various memory-leaks.
> > > `FREE_AND_NULL_CONST()` would be useful in precisely these situations.
> >
> > Honestly, I wouldn't be the best person to judge this.
>
> Git's source code implicitly assumes that any `const` pointer refers to
> memory owned by another code path. It is therefore probably not a good
> idea to encourage `free()`ing a `const` pointer.
Yeah, I never submitted that patch as part of a real series. I remember
having a funky feeling about it, and whatever use-case I had for this
macro, I managed to solve the memory leak in some other way in a
rewrite.
Thanks for a sanity check.
Martin
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v16 Part II 2/8] bisect--helper: `bisect_write` shell function in C
2018-11-23 12:22 ` Martin Ågren
@ 2018-11-26 18:18 ` Johannes Schindelin
0 siblings, 0 replies; 320+ messages in thread
From: Johannes Schindelin @ 2018-11-26 18:18 UTC (permalink / raw)
To: Martin Ågren; +Cc: Pranit Bauva, tanushreetumane, Git Mailing List
[-- Attachment #1: Type: text/plain, Size: 1839 bytes --]
Hi Martin,
On Fri, 23 Nov 2018, Martin Ågren wrote:
> On Fri, 23 Nov 2018 at 11:13, Johannes Schindelin
> <Johannes.Schindelin@gmx.de> wrote:
> > On Mon, 30 Oct 2017, Pranit Bauva wrote:
> >
> > > On Fri, Oct 27, 2017 at 10:58 PM, Martin Ågren <martin.agren@gmail.com> wrote:
> > > > On 27 October 2017 at 17:06, Pranit Bauva <pranit.bauva@gmail.com> wrote:
> > > >> +static void free_terms(struct bisect_terms *terms)
> > > >> +{
> > > >> + if (!terms->term_good)
> > > >> + free((void *) terms->term_good);
> > > >> + if (!terms->term_bad)
> > > >> + free((void *) terms->term_bad);
> > > >> +}
>
> > > > You leave the pointers dangling, but you're ok for now since this is the
> > > > last thing that happens in `cmd_bisect__helper()`. Your later patches
> > > > add more users, but they're also ok, since they immediately assign new
> > > > values.
> > > >
> > > > In case you (and others) find it useful, the below is a patch I've been
> > > > sitting on for a while as part of a series to plug various memory-leaks.
> > > > `FREE_AND_NULL_CONST()` would be useful in precisely these situations.
> > >
> > > Honestly, I wouldn't be the best person to judge this.
> >
> > Git's source code implicitly assumes that any `const` pointer refers to
> > memory owned by another code path. It is therefore probably not a good
> > idea to encourage `free()`ing a `const` pointer.
>
> Yeah, I never submitted that patch as part of a real series. I remember
> having a funky feeling about it, and whatever use-case I had for this
> macro, I managed to solve the memory leak in some other way in a
> rewrite.
>
> Thanks for a sanity check.
I am glad you agree, and it's just fair that I contribute a sanity check
on this here list when I have benefitted so many times from the same.
Ciao,
Johannes
^ permalink raw reply [flat|nested] 320+ messages in thread
* [PATCH v17 0/7] git bisect: convert from shell to C
2017-10-27 15:06 ` [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
` (10 preceding siblings ...)
2017-11-08 0:07 ` Ramsay Jones
@ 2019-01-02 15:38 ` Tanushree Tumane via GitGitGadget
2019-01-02 15:38 ` [PATCH v17 1/7] bisect--helper: `bisect_reset` shell function in C Pranit Bauva via GitGitGadget
` (7 more replies)
11 siblings, 8 replies; 320+ messages in thread
From: Tanushree Tumane via GitGitGadget @ 2019-01-02 15:38 UTC (permalink / raw)
To: git; +Cc: Junio C Hamano
Changes since Pranit's v16:
===========================
bisect--helper: bisect_reset shell function in C
================================================
* The return !printf(...); construct was considered unsafe and disentangled
into printf(...); return 0;
* It is more elegant to release branch and argv first, and then return
error(...) than to error(...); release branch; clear argv; return -1;
* Prefix !! to bisect_reset(...) function call in cmd_bisect__helper(...)
because its return value will be given to exit()
bisect--helper: bisect_write shell function in C
================================================
* The option [--no-log] is passed before <state>.
* Remove const from struct bisect_terms variables because const pointers
refers to memory owned by another code path.
* Use FREE_AND_NULL(...) in free_terms(...).
* It makes more sense to free terms before set in set_terms(...) to avoid
memory leak.
* Remove fail: retval = -1; for cleaner code flow, replace goto fail; with
retval = -1; goto finish; or retval = error(...); goto finish;
* It is more consistent to introduce --no-log as option like --no-checkout.
* Initialize struct bisect_terms terms in cmd_bisect__helper(...).
* The return res; in cmd_bisect__helper(...) may return -1, so prefixed !!
to handle such cases.
bisect--helper: check_and_set_terms shell function in C
=======================================================
* free_terms() before set_terms() is obsolete as set_terms() frees terms
before set.
bisect--helper: bisect_next_check shell function in C
=====================================================
* [<term>] is first argument of bisect-next-check.
* vocab_good and vocab_bad for easier readability.
* Declare *_warning char pointers.
* Remove fail: label, its only job was to set retval = -1;.
bisect--helper: get_terms & bisect_terms shell function in C
============================================================
* Remove fail: label, its only job was to set res = -1;.
* Parse the argv in cmd_bisect__helper() and pass option to bisect_terms().
bisect--helper: bisect_start shell function partially in C
==========================================================
* Remove fail: label, its only job was to set retval = -1;.
* Spell correction unrecognised to unrecognized.
* if (revs.nr) must_write_terms = 1; is more readable than must_write_terms
|= !!revs.nr;.
* error() messages starts with small letters.
* sha1_to_hex() is old practice.
* sq_quote_argv() now requires only two args.
* Instead of nesting ifs, use &&.
Pranit Bauva (7):
bisect--helper: `bisect_reset` shell function in C
bisect--helper: `bisect_write` shell function in C
wrapper: move is_empty_file() and rename it as
is_empty_or_missing_file()
bisect--helper: `check_and_set_terms` shell function in C
bisect--helper: `bisect_next_check` shell function in C
bisect--helper: `get_terms` & `bisect_terms` shell function in C
bisect--helper: `bisect_start` shell function partially in C
builtin/am.c | 20 +-
builtin/bisect--helper.c | 563 +++++++++++++++++++++++++++++++++++-
cache.h | 3 +
git-bisect.sh | 314 ++------------------
t/t6030-bisect-porcelain.sh | 2 +-
wrapper.c | 13 +
6 files changed, 595 insertions(+), 320 deletions(-)
base-commit: 7f4e64169352e03476b0ea64e7e2973669e491a2
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-101%2Ftanushree27%2Fgit-bisect_part2_fixup-v17
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-101/tanushree27/git-bisect_part2_fixup-v17
Pull-Request: https://github.com/gitgitgadget/git/pull/101
Range-diff vs v16:
1: f1e89ba517 ! 1: 338ebdc97a bisect--helper: `bisect_reset` shell function in C
@@ -16,8 +16,9 @@
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
+ Mentored by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
- Signed-off-by: Junio C Hamano <gitster@pobox.com>
+ Signed-off-by: Tanushree Tumane <tanushreetumane@gmail.com>
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
--- a/builtin/bisect--helper.c
@@ -53,8 +54,10 @@
+ struct strbuf branch = STRBUF_INIT;
+
+ if (!commit) {
-+ if (strbuf_read_file(&branch, git_path_bisect_start(), 0) < 1)
-+ return !printf(_("We are not bisecting.\n"));
++ 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;
@@ -69,11 +72,11 @@
+
+ argv_array_pushl(&argv, "checkout", branch.buf, "--", NULL);
+ if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
-+ error(_("Could not check out original HEAD '%s'. Try "
-+ "'git bisect reset <commit>'."), branch.buf);
+ strbuf_release(&branch);
+ argv_array_clear(&argv);
-+ return -1;
++ return error(_("could not check out original"
++ " HEAD '%s'. Try 'git bisect"
++ "reset <commit>'."), branch.buf);
+ }
+ argv_array_clear(&argv);
+ }
@@ -110,7 +113,7 @@
+ case BISECT_RESET:
+ if (argc > 1)
+ return error(_("--bisect-reset requires either no argument or a commit"));
-+ return bisect_reset(argc ? argv[0] : NULL);
++ return !!bisect_reset(argc ? argv[0] : NULL);
default:
return error("BUG: unknown subcommand '%d'", cmdmode);
}
2: da4ac60ad4 ! 2: 7d6291d9dd bisect--helper: `bisect_write` shell function in C
@@ -27,8 +27,9 @@
Helped-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
+ Mentored-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
- Signed-off-by: Junio C Hamano <gitster@pobox.com>
+ Signed-off-by: Tanushree Tumane <tanushreetumane@gmail.com>
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
--- a/builtin/bisect--helper.c
@@ -44,27 +45,27 @@
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-clean-state"),
N_("git bisect--helper --bisect-reset [<commit>]"),
-+ N_("git bisect--helper --bisect-write <state> <revision> <good_term> <bad_term> [<nolog>]"),
++ N_("git bisect--helper --bisect-write [--no-log] <state> <revision> <good_term> <bad_term>"),
NULL
};
+struct bisect_terms {
-+ const char *term_good;
-+ const char *term_bad;
++ char *term_good;
++ char *term_bad;
+};
+
+static void free_terms(struct bisect_terms *terms)
+{
-+ if (!terms->term_good)
-+ free((void *) terms->term_good);
-+ if (!terms->term_bad)
-+ free((void *) terms->term_bad);
++ 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);
+}
+
@@ -105,35 +106,33 @@
+ } else if (one_of(state, terms->term_good, "skip", NULL)) {
+ strbuf_addf(&tag, "refs/bisect/%s-%s", state, rev);
+ } else {
-+ error(_("Bad bisect_write argument: %s"), state);
-+ goto fail;
++ retval = error(_("Bad bisect_write argument: %s"), state);
++ goto finish;
+ }
+
+ if (get_oid(rev, &oid)) {
-+ error(_("couldn't get the oid of the rev '%s'"), rev);
-+ goto fail;
++ retval = error(_("couldn't get the oid of the rev '%s'"), rev);
++ goto finish;
+ }
+
+ if (update_ref(NULL, tag.buf, &oid, NULL, 0,
-+ UPDATE_REFS_MSG_ON_ERR))
-+ goto fail;
++ UPDATE_REFS_MSG_ON_ERR)) {
++ retval = -1;
++ goto finish;
++ }
+
+ fp = fopen(git_path_bisect_log(), "a");
+ if (!fp) {
-+ error_errno(_("couldn't open the file '%s'"), git_path_bisect_log());
-+ goto fail;
++ retval = error_errno(_("couldn't open the file '%s'"), git_path_bisect_log());
++ goto finish;
+ }
+
-+ commit = lookup_commit_reference(&oid);
++ commit = lookup_commit_reference(the_repository, &oid);
+ log_commit(fp, "%s", state, commit);
+
+ if (!nolog)
+ fprintf(fp, "git bisect %s %s\n", state, rev);
+
-+ goto finish;
-+
-+fail:
-+ retval = -1;
+finish:
+ if (fp)
+ fclose(fp);
@@ -153,7 +152,7 @@
+ BISECT_WRITE
} cmdmode = 0;
- int no_checkout = 0;
-+ int no_checkout = 0, res = 0;
++ int no_checkout = 0, res = 0, nolog = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
@@ -162,31 +161,24 @@
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
N_("reset the bisection state"), BISECT_RESET),
+ OPT_CMDMODE(0, "bisect-write", &cmdmode,
-+ N_("update the refs according to the bisection state and may write it to BISECT_LOG"), BISECT_WRITE),
++ N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
++ OPT_BOOL(0, "no-log", &nolog,
++ N_("no log for BISECT_WRITE ")),
OPT_END()
};
-+ struct bisect_terms terms;
++ struct bisect_terms terms = { .term_good = NULL, .term_bad = NULL };
argc = parse_options(argc, argv, prefix, options,
git_bisect_helper_usage, 0);
-@@
- usage_with_options(git_bisect_helper_usage, options);
-
- switch (cmdmode) {
-+ int nolog;
- case NEXT_ALL:
- return bisect_next_all(prefix, no_checkout);
- case WRITE_TERMS:
@@
if (argc > 1)
return error(_("--bisect-reset requires either no argument or a commit"));
- return bisect_reset(argc ? argv[0] : NULL);
+ return !!bisect_reset(argc ? argv[0] : NULL);
+ case BISECT_WRITE:
+ if (argc != 4 && argc != 5)
+ return error(_("--bisect-write requires either 4 or 5 arguments"));
-+ nolog = (argc == 5) && !strcmp(argv[4], "nolog");
+ set_terms(&terms, argv[3], argv[2]);
+ res = bisect_write(argv[0], argv[1], &terms, nolog);
+ break;
@@ -195,7 +187,7 @@
}
- return 0;
+ free_terms(&terms);
-+ return res;
++ return !!res;
}
diff --git a/git-bisect.sh b/git-bisect.sh
3: 8874ae1a3a ! 3: 5f24e7cef2 wrapper: move is_empty_file() and rename it as is_empty_or_missing_file()
@@ -9,14 +9,13 @@
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
- Signed-off-by: Junio C Hamano <gitster@pobox.com>
diff --git a/builtin/am.c b/builtin/am.c
--- a/builtin/am.c
+++ b/builtin/am.c
@@
- #include "string-list.h"
#include "packfile.h"
+ #include "repository.h"
-/**
- * Returns 1 if the file is empty or does not exist, 0 otherwise.
@@ -61,7 +60,7 @@
+++ b/cache.h
@@
*/
- void safe_create_dir(const char *dir, int share);
+ extern int print_sha1_ellipsis(void);
+/* Return 1 if the file is empty or does not exists, 0 otherwise. */
+extern int is_empty_or_missing_file(const char *filename);
4: 7e9fdedc45 ! 4: 4e97a08a10 bisect--helper: `check_and_set_terms` shell function in C
@@ -20,8 +20,9 @@
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
+ Mentored-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
- Signed-off-by: Junio C Hamano <gitster@pobox.com>
+ Signed-off-by: Tanushree Tumane <tanushreetumane@gmail.com>
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
--- a/builtin/bisect--helper.c
@@ -29,7 +30,7 @@
@@
N_("git bisect--helper --bisect-clean-state"),
N_("git bisect--helper --bisect-reset [<commit>]"),
- N_("git bisect--helper --bisect-write <state> <revision> <good_term> <bad_term> [<nolog>]"),
+ N_("git bisect--helper --bisect-write [--no-log] <state> <revision> <good_term> <bad_term>"),
+ N_("git bisect--helper --bisect-check-and-set-terms <command> <good_term> <bad_term>"),
NULL
};
@@ -53,12 +54,10 @@
+
+ if (!has_term_file) {
+ if (one_of(cmd, "bad", "good", NULL)) {
-+ free_terms(terms);
+ set_terms(terms, "bad", "good");
+ return write_terms(terms->term_bad, terms->term_good);
+ }
-+ else if (one_of(cmd, "new", "old", NULL)) {
-+ free_terms(terms);
++ if (one_of(cmd, "new", "old", NULL)) {
+ set_terms(terms, "new", "old");
+ return write_terms(terms->term_bad, terms->term_good);
+ }
@@ -78,17 +77,17 @@
+ BISECT_WRITE,
+ CHECK_AND_SET_TERMS
} cmdmode = 0;
- int no_checkout = 0, res = 0;
+ int no_checkout = 0, res = 0, nolog = 0;
struct option options[] = {
@@
N_("reset the bisection state"), BISECT_RESET),
OPT_CMDMODE(0, "bisect-write", &cmdmode,
- N_("update the refs according to the bisection state and may write it to BISECT_LOG"), BISECT_WRITE),
+ N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
+ OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
+ N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
- OPT_END()
+ OPT_BOOL(0, "no-log", &nolog,
@@
set_terms(&terms, argv[3], argv[2]);
res = bisect_write(argv[0], argv[1], &terms, nolog);
5: ca12543868 ! 5: e9f400b1d6 bisect--helper: `bisect_next_check` shell function in C
@@ -17,8 +17,9 @@
Helped-by: Stephan Beyer <s-beyer@gmx.net>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
+ Mentored-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
- Signed-off-by: Junio C Hamano <gitster@pobox.com>
+ Signed-off-by: Tanushree Tumane <tanushreetumane@gmail.com>
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
--- a/builtin/bisect--helper.c
@@ -33,9 +34,9 @@
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
@@
N_("git bisect--helper --bisect-reset [<commit>]"),
- N_("git bisect--helper --bisect-write <state> <revision> <good_term> <bad_term> [<nolog>]"),
+ N_("git bisect--helper --bisect-write [--no-log] <state> <revision> <good_term> <bad_term>"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <good_term> <bad_term>"),
-+ N_("git bisect--helper --bisect-next-check [<term>] <good_term> <bad_term>"),
++ N_("git bisect--helper --bisect-next-check <good_term> <bad_term> [<term>]"),
NULL
};
@@ -43,10 +44,8 @@
terms->term_bad = xstrdup(bad);
}
-+static const char *voc[] = {
-+ "bad|new",
-+ "good|old"
-+};
++static const char *vocab_bad = "bad|new";
++static const char *vocab_good = "good|old";
+
/*
* Check whether the string `term` belongs to the set of strings
@@ -63,6 +62,15 @@
+ return 1;
+}
+
++static const char *need_bad_and_good_revision_warning =
++ 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.");
++
++static const char *need_bisect_start_warning =
++ 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.");
++
+static int bisect_next_check(const struct bisect_terms *terms,
+ const char *current_term)
+{
@@ -79,18 +87,19 @@
+ if (!missing_good && !missing_bad)
+ goto finish;
+
-+ if (!current_term)
-+ goto fail;
++ if (!current_term) {
++ retval = -1;
++ goto finish;
++ }
+
-+ if (missing_good && !missing_bad && current_term &&
++ 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.
+ */
-+ fprintf(stderr, _("Warning: bisecting only with a %s commit\n"),
-+ terms->term_bad);
++ warning(_("bisecting only with a %s commit"), terms->term_bad);
+ if (!isatty(0))
+ goto finish;
+ /*
@@ -100,28 +109,17 @@
+ */
+ yesno = git_prompt(_("Are you sure [Y/n]? "), PROMPT_ECHO);
+ if (starts_with(yesno, "N") || starts_with(yesno, "n"))
-+ goto fail;
-+
++ retval = -1;
+ goto finish;
+ }
+ if (!is_empty_or_missing_file(git_path_bisect_start())) {
-+ error(_("You need to give me at least one %s and "
-+ "%s revision. You can use \"git bisect %s\" "
-+ "and \"git bisect %s\" for that.\n"),
-+ voc[0], voc[1], voc[0], voc[1]);
-+ goto fail;
++ retval = error(_(need_bad_and_good_revision_warning),
++ vocab_bad, vocab_good, vocab_bad, vocab_good);
+ } else {
-+ error(_("You need to start by \"git bisect start\". You "
-+ "then need to give me at least one %s and %s "
-+ "revision. You can use \"git bisect %s\" and "
-+ "\"git bisect %s\" for that.\n"),
-+ voc[1], voc[0], voc[1], voc[0]);
-+ goto fail;
++ retval = error(_(need_bisect_start_warning),
++ vocab_good, vocab_bad, vocab_good, vocab_bad);
+ }
-+ goto finish;
+
-+fail:
-+ retval = -1;
+finish:
+ free((void *) good_glob);
+ free((void *) bad_ref);
@@ -139,17 +137,17 @@
+ CHECK_AND_SET_TERMS,
+ BISECT_NEXT_CHECK
} cmdmode = 0;
- int no_checkout = 0, res = 0;
+ int no_checkout = 0, res = 0, nolog = 0;
struct option options[] = {
@@
- N_("update the refs according to the bisection state and may write it to BISECT_LOG"), BISECT_WRITE),
+ N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
+ OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
+ N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
- OPT_END()
+ OPT_BOOL(0, "no-log", &nolog,
@@
set_terms(&terms, argv[2], argv[1]);
res = check_and_set_terms(&terms, argv[0]);
@@ -245,8 +243,8 @@
- bisect_next_check fail
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD fail || exit
- while true
- do
+ test -n "$*" || die "$(gettext "bisect run failed: no command provided.")"
+
@@
fi
}
6: db7b281c8c ! 6: f2b1706e5b bisect--helper: `get_terms` & `bisect_terms` shell function in C
@@ -14,18 +14,24 @@
Also use error() to report "no terms defined" and accordingly change the
test in t6030.
+ We need to use PARSE_OPT_KEEP_UNKNOWN here to allow for parameters that
+ look like options (e.g --term-good) but should not be parsed by
+ cmd_bisect__helper(). This change is safe because all other cmdmodes have
+ strict argc checks already.
+
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
+ Mentored-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
- Signed-off-by: Junio C Hamano <gitster@pobox.com>
+ Signed-off-by: Tanushree Tumane <tanushreetumane@gmail.com>
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@
- N_("git bisect--helper --bisect-write <state> <revision> <good_term> <bad_term> [<nolog>]"),
+ N_("git bisect--helper --bisect-write [--no-log] <state> <revision> <good_term> <bad_term>"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <good_term> <bad_term>"),
- N_("git bisect--helper --bisect-next-check [<term>] <good_term> <bad_term>"),
+ N_("git bisect--helper --bisect-next-check <good_term> <bad_term> [<term>]"),
+ N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
NULL
};
@@ -41,18 +47,17 @@
+ int res = 0;
+
+ fp = fopen(git_path_bisect_terms(), "r");
-+ if (!fp)
-+ goto fail;
++ 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);
-+ goto finish;
+
-+fail:
-+ res = -1;
+finish:
+ if (fp)
+ fclose(fp);
@@ -60,32 +65,26 @@
+ return res;
+}
+
-+static int bisect_terms(struct bisect_terms *terms, const char **argv, int argc)
++static int bisect_terms(struct bisect_terms *terms, const char *option)
+{
-+ int i;
-+
+ if (get_terms(terms))
+ return error(_("no terms defined"));
+
-+ if (argc > 1)
-+ return error(_("--bisect-term requires exactly one argument"));
-+
-+ if (argc == 0)
-+ return !printf(_("Your current terms are %s for the old state\n"
-+ "and %s for the new state.\n"),
-+ terms->term_good, terms->term_bad);
-+
-+ for (i = 0; i < argc; i++) {
-+ if (!strcmp(argv[i], "--term-good"))
-+ printf(_("%s\n"), terms->term_good);
-+ else if (!strcmp(argv[i], "--term-bad"))
-+ printf(_("%s\n"), terms->term_bad);
-+ else
-+ error(_("BUG: invalid argument %s for 'git bisect terms'.\n"
-+ "Supported options are: "
-+ "--term-good|--term-old and "
-+ "--term-bad|--term-new."), argv[i]);
++ 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;
+}
@@ -101,7 +100,7 @@
+ BISECT_NEXT_CHECK,
+ BISECT_TERMS
} cmdmode = 0;
- int no_checkout = 0, res = 0;
+ int no_checkout = 0, res = 0, nolog = 0;
struct option options[] = {
@@
N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
@@ -111,9 +110,9 @@
+ N_("print out the bisect terms"), BISECT_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
- OPT_END()
+ OPT_BOOL(0, "no-log", &nolog,
@@
- struct bisect_terms terms;
+ struct bisect_terms terms = { .term_good = NULL, .term_bad = NULL };
argc = parse_options(argc, argv, prefix, options,
- git_bisect_helper_usage, 0);
@@ -128,7 +127,7 @@
+ case BISECT_TERMS:
+ if (argc > 1)
+ return error(_("--bisect-terms requires 0 or 1 argument"));
-+ res = bisect_terms(&terms, argv, argc);
++ res = bisect_terms(&terms, argc == 1 ? argv[0] : NULL);
+ break;
default:
return error("BUG: unknown subcommand '%d'", cmdmode);
@@ -142,7 +141,7 @@
git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
terms)
- bisect_terms $rev ;;
-+ git bisect--helper --bisect-terms $rev || exit;;
++ git bisect--helper --bisect-terms $rev || exit;;
*)
die "$(gettext "?? what are you talking about?")" ;;
esac
7: e14e913797 ! 7: 87a033b858 bisect--helper: `bisect_start` shell function partially in C
@@ -6,7 +6,7 @@
`bisect-start` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
- The last part is not converted because it calls another shell function
+ The last part is not converted because it calls another shell function.
`bisect_start` shell function will be completed after the `bisect_next`
shell function is ported in C.
@@ -18,12 +18,17 @@
Also introduce a method `bisect_append_log_quoted` to keep things short
and crisp.
+ Note that we are a bit lax about command-line parsing because the helper
+ is not supposed to be called by the user directly (but only from the git
+ bisect script).
+
Helped-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Helped-by: Stephan Beyer <s-beyer@gmx.net>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
+ Mentored-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
- Signed-off-by: Junio C Hamano <gitster@pobox.com>
+ Signed-off-by: Tanushree Tumane <tanushreetumane@gmail.com>
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
--- a/builtin/bisect--helper.c
@@ -47,10 +52,10 @@
N_("git bisect--helper --next-all [--no-checkout]"),
@@
N_("git bisect--helper --bisect-check-and-set-terms <command> <good_term> <bad_term>"),
- N_("git bisect--helper --bisect-next-check [<term>] <good_term> <bad_term>"),
+ N_("git bisect--helper --bisect-next-check <good_term> <bad_term> [<term>]"),
N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
+ N_("git bisect--helper --bisect-start [--term-{old,good}=<term> --term-{new,bad}=<term>]"
-+ "[--no-checkout] [<bad> [<good>...]] [--] [<paths>...]"),
++ "[--no-checkout] [<bad> [<good>...]] [--] [<paths>...]"),
NULL
};
@@ -67,17 +72,15 @@
+ if (!fp)
+ return -1;
+
-+ if (fprintf(fp, "git bisect start") < 1)
-+ goto fail;
++ if (fprintf(fp, "git bisect start") < 1) {
++ retval = -1;
++ goto finish;
++ }
+
-+ sq_quote_argv(&orig_args, argv, 0);
++ sq_quote_argv(&orig_args, argv);
+ if (fprintf(fp, "%s\n", orig_args.buf) < 1)
-+ goto fail;
++ retval = -1;
+
-+ goto finish;
-+
-+fail:
-+ retval = -1;
+finish:
+ fclose(fp);
+ strbuf_release(&orig_args);
@@ -138,7 +141,7 @@
+ terms->term_bad = xstrdup(arg);
+ } else if (starts_with(arg, "--") &&
+ !one_of(arg, "--term-good", "--term-bad", NULL)) {
-+ return error(_("unrecognised option: '%s'"), arg);
++ return error(_("unrecognized option: '%s'"), arg);
+ } else {
+ char *commit_id = xstrfmt("%s^{commit}", arg);
+ if (get_oid(commit_id, &oid) && has_double_dash)
@@ -157,7 +160,8 @@
+ * set references named with the default terms, and won't be able
+ * to change afterwards.
+ */
-+ must_write_terms |= !!revs.nr;
++ if (revs.nr)
++ must_write_terms = 1;
+ for (i = 0; i < revs.nr; i++) {
+ if (bad_seen) {
+ string_list_append(&states, terms->term_good);
@@ -173,7 +177,7 @@
+ 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"));
++ return error(_("bad HEAD - I need a HEAD"));
+
+ /*
+ * Check if we are bisecting
@@ -188,10 +192,11 @@
+ argv_array_pushl(&argv, "checkout", start_head.buf,
+ "--", NULL);
+ if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
-+ error(_("checking out '%s' failed. Try 'git "
-+ "bisect start <valid-branch>'."),
-+ start_head.buf);
-+ goto fail;
++ retval = error(_("checking out '%s' failed."
++ " Try 'git bisect start "
++ "<valid-branch>'."),
++ start_head.buf);
++ goto finish;
+ }
+ }
+ } else {
@@ -199,7 +204,7 @@
+ if (!get_oid(head, &head_oid) &&
+ !starts_with(head, "refs/heads/")) {
+ strbuf_reset(&start_head);
-+ strbuf_addstr(&start_head, sha1_to_hex(head_oid.hash));
++ strbuf_addstr(&start_head, oid_to_hex(&head_oid));
+ } else if (!get_oid(head, &head_oid) &&
+ skip_prefix(head, "refs/heads/", &head)) {
+ /*
@@ -211,7 +216,7 @@
+ return error(_("won't bisect on cg-seek'ed tree"));
+ strbuf_addstr(&start_head, head);
+ } else {
-+ return error(_("Bad HEAD - strange symbolic ref"));
++ return error(_("bad HEAD - strange symbolic ref"));
+ }
+ }
+
@@ -236,31 +241,33 @@
+ if (no_checkout) {
+ get_oid(start_head.buf, &oid);
+ if (update_ref(NULL, "BISECT_HEAD", &oid, NULL, 0,
-+ UPDATE_REFS_MSG_ON_ERR))
-+ goto fail;
++ UPDATE_REFS_MSG_ON_ERR)) {
++ retval = -1;
++ goto finish;
++ }
+ }
+
+ if (pathspec_pos < argc - 1)
-+ sq_quote_argv(&bisect_names, argv + pathspec_pos, 0);
++ 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))
-+ goto fail;
++ revs.items[i].string, terms, 1)) {
++ retval = -1;
++ goto finish;
++ }
+
-+ if (must_write_terms)
-+ if (write_terms(terms->term_bad, terms->term_good))
-+ goto fail;
++ if (must_write_terms && write_terms(terms->term_bad,
++ terms->term_good)) {
++ retval = -1;
++ goto finish;
++ }
+
+ retval = bisect_append_log_quoted(argv);
+ if (retval)
-+ goto fail;
-+
-+ goto finish;
++ retval = -1;
+
-+fail:
-+ retval = -1;
+finish:
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
@@ -280,7 +287,7 @@
+ BISECT_TERMS,
+ BISECT_START
} cmdmode = 0;
- int no_checkout = 0, res = 0;
+ int no_checkout = 0, res = 0, nolog = 0;
struct option options[] = {
@@
N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
@@ -290,9 +297,9 @@
+ N_("start the bisect session"), BISECT_START),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
- OPT_END()
+ OPT_BOOL(0, "no-log", &nolog,
@@
- struct bisect_terms terms;
+ struct bisect_terms terms = { .term_good = NULL, .term_bad = NULL };
argc = parse_options(argc, argv, prefix, options,
- git_bisect_helper_usage, PARSE_OPT_KEEP_UNKNOWN);
@@ -303,7 +310,7 @@
usage_with_options(git_bisect_helper_usage, options);
@@
return error(_("--bisect-terms requires 0 or 1 argument"));
- res = bisect_terms(&terms, argv, argc);
+ res = bisect_terms(&terms, argc == 1 ? argv[0] : NULL);
break;
+ case BISECT_START:
+ set_terms(&terms, "bad", "good");
8: 161bbaced1 < -: ---------- t6030: make various test to pass GETTEXT_POISON tests
--
gitgitgadget
^ permalink raw reply [flat|nested] 320+ messages in thread
* [PATCH v17 1/7] bisect--helper: `bisect_reset` shell function in C
2019-01-02 15:38 ` [PATCH v17 0/7] git bisect: convert from shell to C Tanushree Tumane via GitGitGadget
@ 2019-01-02 15:38 ` Pranit Bauva via GitGitGadget
2019-01-02 15:38 ` [PATCH v17 3/7] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva via GitGitGadget
` (6 subsequent siblings)
7 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva via GitGitGadget @ 2019-01-02 15:38 UTC (permalink / raw)
To: git; +Cc: Junio C Hamano, Pranit Bauva
From: Pranit Bauva <pranit.bauva@gmail.com>
Reimplement `bisect_reset` shell function in C and add a `--bisect-reset`
subcommand to `git bisect--helper` to call it from git-bisect.sh .
Using `bisect_reset` subcommand is a temporary measure to port shell
functions to C so as to use the existing test suite. As more functions
are ported, this subcommand would be retired but its implementation will
be called by some other method.
Note: --bisect-clean-state subcommand has not been retired as there are
still a function namely `bisect_start()` which still uses this
subcommand.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Mentored by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
Signed-off-by: Tanushree Tumane <tanushreetumane@gmail.com>
---
builtin/bisect--helper.c | 51 +++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 28 ++--------------------
2 files changed, 52 insertions(+), 27 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 4b5fadcbe1..aa6495dc84 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -3,15 +3,21 @@
#include "parse-options.h"
#include "bisect.h"
#include "refs.h"
+#include "dir.h"
+#include "argv-array.h"
+#include "run-command.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
+static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
+static GIT_PATH_FUNC(git_path_bisect_head, "BISECT_HEAD")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-clean-state"),
+ N_("git bisect--helper --bisect-reset [<commit>]"),
NULL
};
@@ -106,13 +112,50 @@ static void check_expected_revs(const char **revs, int rev_nr)
}
}
+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);
+ }
+
+ if (!file_exists(git_path_bisect_head())) {
+ struct argv_array argv = ARGV_ARRAY_INIT;
+
+ argv_array_pushl(&argv, "checkout", branch.buf, "--", NULL);
+ if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
+ strbuf_release(&branch);
+ argv_array_clear(&argv);
+ return error(_("could not check out original"
+ " HEAD '%s'. Try 'git bisect"
+ "reset <commit>'."), branch.buf);
+ }
+ argv_array_clear(&argv);
+ }
+
+ strbuf_release(&branch);
+ return bisect_clean_state();
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
NEXT_ALL = 1,
WRITE_TERMS,
BISECT_CLEAN_STATE,
- CHECK_EXPECTED_REVS
+ CHECK_EXPECTED_REVS,
+ BISECT_RESET
} cmdmode = 0;
int no_checkout = 0;
struct option options[] = {
@@ -124,6 +167,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("cleanup the bisection state"), BISECT_CLEAN_STATE),
OPT_CMDMODE(0, "check-expected-revs", &cmdmode,
N_("check for expected revs"), CHECK_EXPECTED_REVS),
+ OPT_CMDMODE(0, "bisect-reset", &cmdmode,
+ N_("reset the bisection state"), BISECT_RESET),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_END()
@@ -149,6 +194,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
case CHECK_EXPECTED_REVS:
check_expected_revs(argv, argc);
return 0;
+ case BISECT_RESET:
+ if (argc > 1)
+ return error(_("--bisect-reset requires either no argument or a commit"));
+ return !!bisect_reset(argc ? argv[0] : NULL);
default:
return error("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 54cbfecc5a..afbfbc1f8e 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -393,35 +393,11 @@ bisect_visualize() {
eval '"$@"' --bisect -- $(cat "$GIT_DIR/BISECT_NAMES")
}
-bisect_reset() {
- test -s "$GIT_DIR/BISECT_START" || {
- gettextln "We are not bisecting."
- return
- }
- case "$#" in
- 0) branch=$(cat "$GIT_DIR/BISECT_START") ;;
- 1) git rev-parse --quiet --verify "$1^{commit}" >/dev/null || {
- invalid="$1"
- die "$(eval_gettext "'\$invalid' is not a valid commit")"
- }
- branch="$1" ;;
- *)
- usage ;;
- esac
-
- if ! test -f "$GIT_DIR/BISECT_HEAD" && ! git checkout "$branch" --
- then
- die "$(eval_gettext "Could not check out original HEAD '\$branch'.
-Try 'git bisect reset <commit>'.")"
- fi
- git bisect--helper --bisect-clean-state || exit
-}
-
bisect_replay () {
file="$1"
test "$#" -eq 1 || die "$(gettext "No logfile given")"
test -r "$file" || die "$(eval_gettext "cannot read \$file for replaying")"
- bisect_reset
+ git bisect--helper --bisect-reset || exit
while read git bisect command rev
do
test "$git $bisect" = "git bisect" || test "$git" = "git-bisect" || continue
@@ -613,7 +589,7 @@ case "$#" in
visualize|view)
bisect_visualize "$@" ;;
reset)
- bisect_reset "$@" ;;
+ git bisect--helper --bisect-reset "$@" ;;
replay)
bisect_replay "$@" ;;
log)
--
gitgitgadget
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v17 2/7] bisect--helper: `bisect_write` shell function in C
2019-01-02 15:38 ` [PATCH v17 0/7] git bisect: convert from shell to C Tanushree Tumane via GitGitGadget
2019-01-02 15:38 ` [PATCH v17 1/7] bisect--helper: `bisect_reset` shell function in C Pranit Bauva via GitGitGadget
2019-01-02 15:38 ` [PATCH v17 3/7] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva via GitGitGadget
@ 2019-01-02 15:38 ` Pranit Bauva via GitGitGadget
2019-01-02 15:38 ` [PATCH v17 4/7] bisect--helper: `check_and_set_terms` " Pranit Bauva via GitGitGadget
` (4 subsequent siblings)
7 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva via GitGitGadget @ 2019-01-02 15:38 UTC (permalink / raw)
To: git; +Cc: Junio C Hamano, Pranit Bauva
From: Pranit Bauva <pranit.bauva@gmail.com>
Reimplement the `bisect_write` shell function in C and add a
`bisect-write` subcommand to `git bisect--helper` to call it from
git-bisect.sh
Using `--bisect-write` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by some other methods.
Note: bisect_write() uses two variables namely TERM_GOOD and TERM_BAD
from the global shell script thus we need to pass it to the subcommand
using the arguments. We then store them in a struct bisect_terms and
pass the memory address around functions.
Add a log_commit() helper function to write the contents of the commit message
header to a file which will be re-used in future parts of the code as
well.
Also introduce a function free_terms() to free the memory of `struct
bisect_terms` and set_terms() to set the values of members in `struct
bisect_terms`.
Helped-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Mentored-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
Signed-off-by: Tanushree Tumane <tanushreetumane@gmail.com>
---
builtin/bisect--helper.c | 105 +++++++++++++++++++++++++++++++++++++--
git-bisect.sh | 25 ++--------
2 files changed, 106 insertions(+), 24 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index aa6495dc84..df821be4b2 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -12,15 +12,37 @@ static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
static GIT_PATH_FUNC(git_path_bisect_head, "BISECT_HEAD")
+static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
N_("git bisect--helper --write-terms <bad_term> <good_term>"),
N_("git bisect--helper --bisect-clean-state"),
N_("git bisect--helper --bisect-reset [<commit>]"),
+ N_("git bisect--helper --bisect-write [--no-log] <state> <revision> <good_term> <bad_term>"),
NULL
};
+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);
+}
+
/*
* Check whether the string `term` belongs to the set of strings
* included in the variable arguments.
@@ -148,6 +170,70 @@ static int bisect_reset(const char *commit)
return bisect_clean_state();
}
+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;
+ int retval = 0;
+
+ 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 {
+ retval = error(_("Bad bisect_write argument: %s"), state);
+ goto finish;
+ }
+
+ if (get_oid(rev, &oid)) {
+ retval = error(_("couldn't get the oid of the rev '%s'"), rev);
+ goto finish;
+ }
+
+ if (update_ref(NULL, tag.buf, &oid, NULL, 0,
+ UPDATE_REFS_MSG_ON_ERR)) {
+ retval = -1;
+ goto finish;
+ }
+
+ fp = fopen(git_path_bisect_log(), "a");
+ if (!fp) {
+ retval = error_errno(_("couldn't open the file '%s'"), git_path_bisect_log());
+ 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);
+ return retval;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -155,9 +241,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
WRITE_TERMS,
BISECT_CLEAN_STATE,
CHECK_EXPECTED_REVS,
- BISECT_RESET
+ BISECT_RESET,
+ BISECT_WRITE
} cmdmode = 0;
- int no_checkout = 0;
+ int no_checkout = 0, res = 0, nolog = 0;
struct option options[] = {
OPT_CMDMODE(0, "next-all", &cmdmode,
N_("perform 'git bisect next'"), NEXT_ALL),
@@ -169,10 +256,15 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check for expected revs"), CHECK_EXPECTED_REVS),
OPT_CMDMODE(0, "bisect-reset", &cmdmode,
N_("reset the bisection state"), BISECT_RESET),
+ OPT_CMDMODE(0, "bisect-write", &cmdmode,
+ N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
+ OPT_BOOL(0, "no-log", &nolog,
+ N_("no log for BISECT_WRITE ")),
OPT_END()
};
+ struct bisect_terms terms = { .term_good = NULL, .term_bad = NULL };
argc = parse_options(argc, argv, prefix, options,
git_bisect_helper_usage, 0);
@@ -198,8 +290,15 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
if (argc > 1)
return error(_("--bisect-reset requires either no argument or a commit"));
return !!bisect_reset(argc ? argv[0] : NULL);
+ 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;
default:
return error("BUG: unknown subcommand '%d'", cmdmode);
}
- return 0;
+ free_terms(&terms);
+ return !!res;
}
diff --git a/git-bisect.sh b/git-bisect.sh
index afbfbc1f8e..ebf445223c 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -144,7 +144,7 @@ bisect_start() {
0) state=$TERM_BAD ; bad_seen=1 ;;
*) state=$TERM_GOOD ;;
esac
- eval="$eval bisect_write '$state' '$rev' 'nolog' &&"
+ eval="$eval git bisect--helper --bisect-write '$state' '$rev' '$TERM_GOOD' '$TERM_BAD' 'nolog' &&"
done
#
# Verify HEAD.
@@ -220,23 +220,6 @@ bisect_start() {
trap '-' 0
}
-bisect_write() {
- state="$1"
- rev="$2"
- nolog="$3"
- case "$state" in
- "$TERM_BAD")
- tag="$state" ;;
- "$TERM_GOOD"|skip)
- tag="$state"-"$rev" ;;
- *)
- die "$(eval_gettext "Bad bisect_write argument: \$state")" ;;
- esac
- git update-ref "refs/bisect/$tag" "$rev" || exit
- echo "# $state: $(git show-branch $rev)" >>"$GIT_DIR/BISECT_LOG"
- test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
-}
-
bisect_skip() {
all=''
for arg in "$@"
@@ -263,7 +246,7 @@ bisect_state() {
bisected_head=$(bisect_head)
rev=$(git rev-parse --verify "$bisected_head") ||
die "$(eval_gettext "Bad rev input: \$bisected_head")"
- bisect_write "$state" "$rev"
+ git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
git bisect--helper --check-expected-revs "$rev" ;;
2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
shift
@@ -276,7 +259,7 @@ bisect_state() {
done
for rev in $hash_list
do
- bisect_write "$state" "$rev"
+ git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
done
git bisect--helper --check-expected-revs $hash_list ;;
*,"$TERM_BAD")
@@ -413,7 +396,7 @@ bisect_replay () {
cmd="bisect_start $rev"
eval "$cmd" ;;
"$TERM_GOOD"|"$TERM_BAD"|skip)
- bisect_write "$command" "$rev" ;;
+ git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
terms)
bisect_terms $rev ;;
*)
--
gitgitgadget
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v17 3/7] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file()
2019-01-02 15:38 ` [PATCH v17 0/7] git bisect: convert from shell to C Tanushree Tumane via GitGitGadget
2019-01-02 15:38 ` [PATCH v17 1/7] bisect--helper: `bisect_reset` shell function in C Pranit Bauva via GitGitGadget
@ 2019-01-02 15:38 ` Pranit Bauva via GitGitGadget
2019-01-02 15:38 ` [PATCH v17 2/7] bisect--helper: `bisect_write` shell function in C Pranit Bauva via GitGitGadget
` (5 subsequent siblings)
7 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva via GitGitGadget @ 2019-01-02 15:38 UTC (permalink / raw)
To: git; +Cc: Junio C Hamano, Pranit Bauva
From: Pranit Bauva <pranit.bauva@gmail.com>
is_empty_file() can help to refactor a lot of code. This will be very
helpful in porting "git bisect" to C.
Suggested-by: Torsten Bögershausen <tboegi@web.de>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
---
builtin/am.c | 20 ++------------------
cache.h | 3 +++
wrapper.c | 13 +++++++++++++
3 files changed, 18 insertions(+), 18 deletions(-)
diff --git a/builtin/am.c b/builtin/am.c
index 8f27f3375b..310eefe9e8 100644
--- a/builtin/am.c
+++ b/builtin/am.c
@@ -34,22 +34,6 @@
#include "packfile.h"
#include "repository.h"
-/**
- * Returns 1 if the file is empty or does not exist, 0 otherwise.
- */
-static int is_empty_file(const char *filename)
-{
- struct stat st;
-
- if (stat(filename, &st) < 0) {
- if (errno == ENOENT)
- return 1;
- die_errno(_("could not stat %s"), filename);
- }
-
- return !st.st_size;
-}
-
/**
* Returns the length of the first line of msg.
*/
@@ -1220,7 +1204,7 @@ static int parse_mail(struct am_state *state, const char *mail)
goto finish;
}
- if (is_empty_file(am_path(state, "patch"))) {
+ if (is_empty_or_missing_file(am_path(state, "patch"))) {
printf_ln(_("Patch is empty."));
die_user_resolve(state);
}
@@ -1803,7 +1787,7 @@ static void am_run(struct am_state *state, int resume)
resume = 0;
}
- if (!is_empty_file(am_path(state, "rewritten"))) {
+ if (!is_empty_or_missing_file(am_path(state, "rewritten"))) {
assert(state->rebasing);
copy_notes_for_rebase(state);
run_post_rewrite_hook(state);
diff --git a/cache.h b/cache.h
index ca36b44ee0..9ff7e56b74 100644
--- a/cache.h
+++ b/cache.h
@@ -1788,4 +1788,7 @@ void safe_create_dir(const char *dir, int share);
*/
extern int print_sha1_ellipsis(void);
+/* Return 1 if the file is empty or does not exists, 0 otherwise. */
+extern int is_empty_or_missing_file(const char *filename);
+
#endif /* CACHE_H */
diff --git a/wrapper.c b/wrapper.c
index e4fa9d84cd..ea3cf64d4c 100644
--- a/wrapper.c
+++ b/wrapper.c
@@ -690,3 +690,16 @@ int xgethostname(char *buf, size_t len)
buf[len - 1] = 0;
return ret;
}
+
+int is_empty_or_missing_file(const char *filename)
+{
+ struct stat st;
+
+ if (stat(filename, &st) < 0) {
+ if (errno == ENOENT)
+ return 1;
+ die_errno(_("could not stat %s"), filename);
+ }
+
+ return !st.st_size;
+}
--
gitgitgadget
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v17 4/7] bisect--helper: `check_and_set_terms` shell function in C
2019-01-02 15:38 ` [PATCH v17 0/7] git bisect: convert from shell to C Tanushree Tumane via GitGitGadget
` (2 preceding siblings ...)
2019-01-02 15:38 ` [PATCH v17 2/7] bisect--helper: `bisect_write` shell function in C Pranit Bauva via GitGitGadget
@ 2019-01-02 15:38 ` Pranit Bauva via GitGitGadget
2019-01-02 15:38 ` [PATCH v17 5/7] bisect--helper: `bisect_next_check` " Pranit Bauva via GitGitGadget
` (3 subsequent siblings)
7 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva via GitGitGadget @ 2019-01-02 15:38 UTC (permalink / raw)
To: git; +Cc: Junio C Hamano, Pranit Bauva
From: Pranit Bauva <pranit.bauva@gmail.com>
Reimplement the `check_and_set_terms` shell function in C and add
`check-and-set-terms` subcommand to `git bisect--helper` to call it from
git-bisect.sh
Using `--check-and-set-terms` subcommand is a temporary measure to port
shell function in C so as to use the existing test suite. As more
functions are ported, this subcommand will be retired but its
implementation will be called by some other methods.
check_and_set_terms() sets and receives two global variables namely
TERM_GOOD and TERM_BAD in the shell script. Luckily the file BISECT_TERMS
also contains the value of those variables so its appropriate to evoke the
method get_terms() after calling the subcommand so that it retrieves the
value of TERM_GOOD and TERM_BAD from the file BISECT_TERMS. The two
global variables are passed as arguments to the subcommand.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Mentored-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
Signed-off-by: Tanushree Tumane <tanushreetumane@gmail.com>
---
builtin/bisect--helper.c | 39 ++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 36 ++++--------------------------------
2 files changed, 42 insertions(+), 33 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index df821be4b2..02ea5a9611 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -20,6 +20,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-clean-state"),
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write [--no-log] <state> <revision> <good_term> <bad_term>"),
+ N_("git bisect--helper --bisect-check-and-set-terms <command> <good_term> <bad_term>"),
NULL
};
@@ -234,6 +235,33 @@ static int bisect_write(const char *state, const char *rev,
return retval;
}
+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;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -242,7 +270,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_CLEAN_STATE,
CHECK_EXPECTED_REVS,
BISECT_RESET,
- BISECT_WRITE
+ BISECT_WRITE,
+ CHECK_AND_SET_TERMS
} cmdmode = 0;
int no_checkout = 0, res = 0, nolog = 0;
struct option options[] = {
@@ -258,6 +287,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("reset the bisection state"), BISECT_RESET),
OPT_CMDMODE(0, "bisect-write", &cmdmode,
N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
+ OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
+ N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_BOOL(0, "no-log", &nolog,
@@ -296,6 +327,12 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
set_terms(&terms, argv[3], argv[2]);
res = bisect_write(argv[0], argv[1], &terms, nolog);
break;
+ 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;
default:
return error("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index ebf445223c..9e993a8187 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -238,7 +238,8 @@ bisect_skip() {
bisect_state() {
bisect_autostart
state=$1
- check_and_set_terms $state
+ git bisect--helper --check-and-set-terms $state $TERM_GOOD $TERM_BAD || exit
+ get_terms
case "$#,$state" in
0,*)
die "Please call 'bisect_state' with at least one argument." ;;
@@ -390,7 +391,8 @@ bisect_replay () {
command="$bisect"
fi
get_terms
- check_and_set_terms "$command"
+ git bisect--helper --check-and-set-terms "$command" "$TERM_GOOD" "$TERM_BAD" || exit
+ get_terms
case "$command" in
start)
cmd="bisect_start $rev"
@@ -482,36 +484,6 @@ get_terms () {
fi
}
-check_and_set_terms () {
- cmd="$1"
- case "$cmd" in
- skip|start|terms) ;;
- *)
- if test -s "$GIT_DIR/BISECT_TERMS" && test "$cmd" != "$TERM_BAD" && test "$cmd" != "$TERM_GOOD"
- then
- die "$(eval_gettext "Invalid command: you're currently in a \$TERM_BAD/\$TERM_GOOD bisect.")"
- fi
- case "$cmd" in
- bad|good)
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- TERM_BAD=bad
- TERM_GOOD=good
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
- fi
- ;;
- new|old)
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- TERM_BAD=new
- TERM_GOOD=old
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
- fi
- ;;
- esac ;;
- esac
-}
-
bisect_voc () {
case "$1" in
bad) echo "bad|new" ;;
--
gitgitgadget
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v17 5/7] bisect--helper: `bisect_next_check` shell function in C
2019-01-02 15:38 ` [PATCH v17 0/7] git bisect: convert from shell to C Tanushree Tumane via GitGitGadget
` (3 preceding siblings ...)
2019-01-02 15:38 ` [PATCH v17 4/7] bisect--helper: `check_and_set_terms` " Pranit Bauva via GitGitGadget
@ 2019-01-02 15:38 ` Pranit Bauva via GitGitGadget
2019-01-02 15:38 ` [PATCH v17 6/7] bisect--helper: `get_terms` & `bisect_terms` " Pranit Bauva via GitGitGadget
` (2 subsequent siblings)
7 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva via GitGitGadget @ 2019-01-02 15:38 UTC (permalink / raw)
To: git; +Cc: Junio C Hamano, Pranit Bauva
From: Pranit Bauva <pranit.bauva@gmail.com>
Reimplement `bisect_next_check` shell function in C and add
`bisect-next-check` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
`bisect_voc` shell function is no longer useful now and is replaced by
using a char *[] of "new|bad" and "good|old" values.
Using `--bisect-next-check` is a temporary measure to port shell
function to C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by some other methods.
Helped-by: Stephan Beyer <s-beyer@gmx.net>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Mentored-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
Signed-off-by: Tanushree Tumane <tanushreetumane@gmail.com>
---
builtin/bisect--helper.c | 88 +++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 60 ++-------------------------
2 files changed, 91 insertions(+), 57 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 02ea5a9611..38ae825b9a 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -6,6 +6,7 @@
#include "dir.h"
#include "argv-array.h"
#include "run-command.h"
+#include "prompt.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
@@ -21,6 +22,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-reset [<commit>]"),
N_("git bisect--helper --bisect-write [--no-log] <state> <revision> <good_term> <bad_term>"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <good_term> <bad_term>"),
+ N_("git bisect--helper --bisect-next-check <good_term> <bad_term> [<term>]"),
NULL
};
@@ -44,6 +46,9 @@ static void set_terms(struct bisect_terms *terms, const char *bad,
terms->term_bad = xstrdup(bad);
}
+static const char *vocab_bad = "bad|new";
+static const char *vocab_good = "good|old";
+
/*
* Check whether the string `term` belongs to the set of strings
* included in the variable arguments.
@@ -262,6 +267,78 @@ static int check_and_set_terms(struct bisect_terms *terms, const char *cmd)
return 0;
}
+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;
+}
+
+static const char *need_bad_and_good_revision_warning =
+ 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.");
+
+static const char *need_bisect_start_warning =
+ 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.");
+
+static int bisect_next_check(const struct bisect_terms *terms,
+ const char *current_term)
+{
+ int missing_good = 1, missing_bad = 1, retval = 0;
+ const char *bad_ref = xstrfmt("refs/bisect/%s", terms->term_bad);
+ const 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);
+
+ if (!missing_good && !missing_bad)
+ goto finish;
+
+ if (!current_term) {
+ retval = -1;
+ goto finish;
+ }
+
+ 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))
+ goto finish;
+ /*
+ * 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"))
+ retval = -1;
+ goto finish;
+ }
+ if (!is_empty_or_missing_file(git_path_bisect_start())) {
+ retval = error(_(need_bad_and_good_revision_warning),
+ vocab_bad, vocab_good, vocab_bad, vocab_good);
+ } else {
+ retval = error(_(need_bisect_start_warning),
+ vocab_good, vocab_bad, vocab_good, vocab_bad);
+ }
+
+finish:
+ free((void *) good_glob);
+ free((void *) bad_ref);
+ return retval;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -271,7 +348,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
CHECK_EXPECTED_REVS,
BISECT_RESET,
BISECT_WRITE,
- CHECK_AND_SET_TERMS
+ CHECK_AND_SET_TERMS,
+ BISECT_NEXT_CHECK
} cmdmode = 0;
int no_checkout = 0, res = 0, nolog = 0;
struct option options[] = {
@@ -289,6 +367,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("write out the bisection state in BISECT_LOG"), BISECT_WRITE),
OPT_CMDMODE(0, "check-and-set-terms", &cmdmode,
N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
+ OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
+ N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_BOOL(0, "no-log", &nolog,
@@ -333,6 +413,12 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
set_terms(&terms, argv[2], argv[1]);
res = check_and_set_terms(&terms, argv[0]);
break;
+ 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;
default:
return error("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 9e993a8187..5ef3e25621 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -271,59 +271,14 @@ bisect_state() {
bisect_auto_next
}
-bisect_next_check() {
- missing_good= missing_bad=
- git show-ref -q --verify refs/bisect/$TERM_BAD || missing_bad=t
- test -n "$(git for-each-ref "refs/bisect/$TERM_GOOD-*")" || missing_good=t
-
- case "$missing_good,$missing_bad,$1" in
- ,,*)
- : have both $TERM_GOOD and $TERM_BAD - ok
- ;;
- *,)
- # do not have both but not asked to fail - just report.
- false
- ;;
- t,,"$TERM_GOOD")
- # have bad (or new) but not good (or old). we could bisect although
- # this is less optimum.
- eval_gettextln "Warning: bisecting only with a \$TERM_BAD commit." >&2
- if test -t 0
- then
- # TRANSLATORS: Make sure to include [Y] and [n] in your
- # translation. The program will only accept English input
- # at this point.
- gettext "Are you sure [Y/n]? " >&2
- read yesno
- case "$yesno" in [Nn]*) exit 1 ;; esac
- fi
- : bisect without $TERM_GOOD...
- ;;
- *)
- bad_syn=$(bisect_voc bad)
- good_syn=$(bisect_voc good)
- if test -s "$GIT_DIR/BISECT_START"
- then
-
- eval_gettextln "You need to give me at least one \$bad_syn and one \$good_syn revision.
-(You can use \"git bisect \$bad_syn\" and \"git bisect \$good_syn\" for that.)" >&2
- else
- eval_gettextln "You need to start by \"git bisect start\".
-You then need to give me at least one \$good_syn and one \$bad_syn revision.
-(You can use \"git bisect \$bad_syn\" and \"git bisect \$good_syn\" for that.)" >&2
- fi
- exit 1 ;;
- esac
-}
-
bisect_auto_next() {
- bisect_next_check && bisect_next || :
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD && bisect_next || :
}
bisect_next() {
case "$#" in 0) ;; *) usage ;; esac
bisect_autostart
- bisect_next_check $TERM_GOOD
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD $TERM_GOOD|| exit
# Perform all bisection computation, display and checkout
git bisect--helper --next-all $(test -f "$GIT_DIR/BISECT_HEAD" && echo --no-checkout)
@@ -355,7 +310,7 @@ bisect_next() {
}
bisect_visualize() {
- bisect_next_check fail
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD fail || exit
if test $# = 0
then
@@ -409,7 +364,7 @@ bisect_replay () {
}
bisect_run () {
- bisect_next_check fail
+ git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD fail || exit
test -n "$*" || die "$(gettext "bisect run failed: no command provided.")"
@@ -484,13 +439,6 @@ get_terms () {
fi
}
-bisect_voc () {
- case "$1" in
- bad) echo "bad|new" ;;
- good) echo "good|old" ;;
- esac
-}
-
bisect_terms () {
get_terms
if ! test -s "$GIT_DIR/BISECT_TERMS"
--
gitgitgadget
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v17 6/7] bisect--helper: `get_terms` & `bisect_terms` shell function in C
2019-01-02 15:38 ` [PATCH v17 0/7] git bisect: convert from shell to C Tanushree Tumane via GitGitGadget
` (4 preceding siblings ...)
2019-01-02 15:38 ` [PATCH v17 5/7] bisect--helper: `bisect_next_check` " Pranit Bauva via GitGitGadget
@ 2019-01-02 15:38 ` Pranit Bauva via GitGitGadget
2019-01-02 15:38 ` [PATCH v17 7/7] bisect--helper: `bisect_start` shell function partially " Pranit Bauva via GitGitGadget
2019-01-03 1:19 ` [PATCH v17 0/7] git bisect: convert from shell to C Ramsay Jones
7 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva via GitGitGadget @ 2019-01-02 15:38 UTC (permalink / raw)
To: git; +Cc: Junio C Hamano, Pranit Bauva
From: Pranit Bauva <pranit.bauva@gmail.com>
Reimplement the `get_terms` and `bisect_terms` shell function in C and
add `bisect-terms` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
Using `--bisect-terms` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired but its implementation will
be called by some other methods.
Also use error() to report "no terms defined" and accordingly change the
test in t6030.
We need to use PARSE_OPT_KEEP_UNKNOWN here to allow for parameters that
look like options (e.g --term-good) but should not be parsed by
cmd_bisect__helper(). This change is safe because all other cmdmodes have
strict argc checks already.
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Mentored-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
Signed-off-by: Tanushree Tumane <tanushreetumane@gmail.com>
---
builtin/bisect--helper.c | 62 +++++++++++++++++++++++++++++++++++--
git-bisect.sh | 35 ++-------------------
t/t6030-bisect-porcelain.sh | 2 +-
3 files changed, 63 insertions(+), 36 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index 38ae825b9a..d61edd3c91 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -23,6 +23,7 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-write [--no-log] <state> <revision> <good_term> <bad_term>"),
N_("git bisect--helper --bisect-check-and-set-terms <command> <good_term> <bad_term>"),
N_("git bisect--helper --bisect-next-check <good_term> <bad_term> [<term>]"),
+ N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
NULL
};
@@ -339,6 +340,55 @@ static int bisect_next_check(const struct bisect_terms *terms,
return retval;
}
+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;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -349,7 +399,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_RESET,
BISECT_WRITE,
CHECK_AND_SET_TERMS,
- BISECT_NEXT_CHECK
+ BISECT_NEXT_CHECK,
+ BISECT_TERMS
} cmdmode = 0;
int no_checkout = 0, res = 0, nolog = 0;
struct option options[] = {
@@ -369,6 +420,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check and set terms in a bisection state"), CHECK_AND_SET_TERMS),
OPT_CMDMODE(0, "bisect-next-check", &cmdmode,
N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
+ OPT_CMDMODE(0, "bisect-terms", &cmdmode,
+ N_("print out the bisect terms"), BISECT_TERMS),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_BOOL(0, "no-log", &nolog,
@@ -378,7 +431,7 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
struct bisect_terms terms = { .term_good = NULL, .term_bad = NULL };
argc = parse_options(argc, argv, prefix, options,
- git_bisect_helper_usage, 0);
+ git_bisect_helper_usage, PARSE_OPT_KEEP_UNKNOWN);
if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
@@ -419,6 +472,11 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
set_terms(&terms, argv[1], argv[0]);
res = bisect_next_check(&terms, argc == 3 ? argv[2] : NULL);
break;
+ 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;
default:
return error("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index 5ef3e25621..bdb614e3c2 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -355,7 +355,7 @@ bisect_replay () {
"$TERM_GOOD"|"$TERM_BAD"|skip)
git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
terms)
- bisect_terms $rev ;;
+ git bisect--helper --bisect-terms $rev || exit;;
*)
die "$(gettext "?? what are you talking about?")" ;;
esac
@@ -439,37 +439,6 @@ get_terms () {
fi
}
-bisect_terms () {
- get_terms
- if ! test -s "$GIT_DIR/BISECT_TERMS"
- then
- die "$(gettext "no terms defined")"
- fi
- case "$#" in
- 0)
- gettextln "Your current terms are $TERM_GOOD for the old state
-and $TERM_BAD for the new state."
- ;;
- 1)
- arg=$1
- case "$arg" in
- --term-good|--term-old)
- printf '%s\n' "$TERM_GOOD"
- ;;
- --term-bad|--term-new)
- printf '%s\n' "$TERM_BAD"
- ;;
- *)
- die "$(eval_gettext "invalid argument \$arg for 'git bisect terms'.
-Supported options are: --term-good|--term-old and --term-bad|--term-new.")"
- ;;
- esac
- ;;
- *)
- usage ;;
- esac
-}
-
case "$#" in
0)
usage ;;
@@ -500,7 +469,7 @@ case "$#" in
run)
bisect_run "$@" ;;
terms)
- bisect_terms "$@" ;;
+ git bisect--helper --bisect-terms "$@" || exit;;
*)
usage ;;
esac
diff --git a/t/t6030-bisect-porcelain.sh b/t/t6030-bisect-porcelain.sh
index f84ff941c3..55835ee4a4 100755
--- a/t/t6030-bisect-porcelain.sh
+++ b/t/t6030-bisect-porcelain.sh
@@ -802,7 +802,7 @@ test_expect_success 'bisect terms needs 0 or 1 argument' '
test_must_fail git bisect terms only-one &&
test_must_fail git bisect terms 1 2 &&
test_must_fail git bisect terms 2>actual &&
- echo "no terms defined" >expected &&
+ echo "error: no terms defined" >expected &&
test_i18ncmp expected actual
'
--
gitgitgadget
^ permalink raw reply related [flat|nested] 320+ messages in thread
* [PATCH v17 7/7] bisect--helper: `bisect_start` shell function partially in C
2019-01-02 15:38 ` [PATCH v17 0/7] git bisect: convert from shell to C Tanushree Tumane via GitGitGadget
` (5 preceding siblings ...)
2019-01-02 15:38 ` [PATCH v17 6/7] bisect--helper: `get_terms` & `bisect_terms` " Pranit Bauva via GitGitGadget
@ 2019-01-02 15:38 ` Pranit Bauva via GitGitGadget
2019-01-03 1:19 ` [PATCH v17 0/7] git bisect: convert from shell to C Ramsay Jones
7 siblings, 0 replies; 320+ messages in thread
From: Pranit Bauva via GitGitGadget @ 2019-01-02 15:38 UTC (permalink / raw)
To: git; +Cc: Junio C Hamano, Pranit Bauva
From: Pranit Bauva <pranit.bauva@gmail.com>
Reimplement the `bisect_start` shell function partially in C and add
`bisect-start` subcommand to `git bisect--helper` to call it from
git-bisect.sh .
The last part is not converted because it calls another shell function.
`bisect_start` shell function will be completed after the `bisect_next`
shell function is ported in C.
Using `--bisect-start` subcommand is a temporary measure to port shell
function in C so as to use the existing test suite. As more functions
are ported, this subcommand will be retired and will be called by some
other methods.
Also introduce a method `bisect_append_log_quoted` to keep things short
and crisp.
Note that we are a bit lax about command-line parsing because the helper
is not supposed to be called by the user directly (but only from the git
bisect script).
Helped-by: Ramsay Jones <ramsay@ramsayjones.plus.com>
Helped-by: Stephan Beyer <s-beyer@gmx.net>
Mentored-by: Lars Schneider <larsxschneider@gmail.com>
Mentored-by: Christian Couder <chriscool@tuxfamily.org>
Mentored-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
Signed-off-by: Tanushree Tumane <tanushreetumane@gmail.com>
---
builtin/bisect--helper.c | 230 ++++++++++++++++++++++++++++++++++++++-
git-bisect.sh | 132 +---------------------
2 files changed, 230 insertions(+), 132 deletions(-)
diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
index d61edd3c91..22e669e3b1 100644
--- a/builtin/bisect--helper.c
+++ b/builtin/bisect--helper.c
@@ -7,6 +7,7 @@
#include "argv-array.h"
#include "run-command.h"
#include "prompt.h"
+#include "quote.h"
static GIT_PATH_FUNC(git_path_bisect_terms, "BISECT_TERMS")
static GIT_PATH_FUNC(git_path_bisect_expected_rev, "BISECT_EXPECTED_REV")
@@ -14,6 +15,8 @@ static GIT_PATH_FUNC(git_path_bisect_ancestors_ok, "BISECT_ANCESTORS_OK")
static GIT_PATH_FUNC(git_path_bisect_start, "BISECT_START")
static GIT_PATH_FUNC(git_path_bisect_head, "BISECT_HEAD")
static GIT_PATH_FUNC(git_path_bisect_log, "BISECT_LOG")
+static GIT_PATH_FUNC(git_path_head_name, "head-name")
+static GIT_PATH_FUNC(git_path_bisect_names, "BISECT_NAMES")
static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --next-all [--no-checkout]"),
@@ -24,6 +27,8 @@ static const char * const git_bisect_helper_usage[] = {
N_("git bisect--helper --bisect-check-and-set-terms <command> <good_term> <bad_term>"),
N_("git bisect--helper --bisect-next-check <good_term> <bad_term> [<term>]"),
N_("git bisect--helper --bisect-terms [--term-good | --term-old | --term-bad | --term-new]"),
+ N_("git bisect--helper --bisect-start [--term-{old,good}=<term> --term-{new,bad}=<term>]"
+ "[--no-checkout] [<bad> [<good>...]] [--] [<paths>...]"),
NULL
};
@@ -389,6 +394,219 @@ static int bisect_terms(struct bisect_terms *terms, const char *option)
return 0;
}
+static int bisect_append_log_quoted(const char **argv)
+{
+ int retval = 0;
+ 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) {
+ retval = -1;
+ goto finish;
+ }
+
+ sq_quote_argv(&orig_args, argv);
+ if (fprintf(fp, "%s\n", orig_args.buf) < 1)
+ retval = -1;
+
+finish:
+ fclose(fp);
+ strbuf_release(&orig_args);
+ return retval;
+}
+
+static int bisect_start(struct bisect_terms *terms, int no_checkout,
+ const char **argv, int argc)
+{
+ int i, has_double_dash = 0, must_write_terms = 0, bad_seen = 0;
+ int flags, pathspec_pos, retval = 0;
+ 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;
+ } else if (!strcmp(arg, "--term-good") ||
+ !strcmp(arg, "--term-old")) {
+ must_write_terms = 1;
+ free((void *) terms->term_good);
+ terms->term_good = xstrdup(argv[++i]);
+ } 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")) {
+ must_write_terms = 1;
+ free((void *) terms->term_bad);
+ terms->term_bad = xstrdup(argv[++i]);
+ } 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);
+ } else if (starts_with(arg, "--") &&
+ !one_of(arg, "--term-good", "--term-bad", NULL)) {
+ 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) {
+ struct argv_array argv = ARGV_ARRAY_INIT;
+
+ argv_array_pushl(&argv, "checkout", start_head.buf,
+ "--", NULL);
+ if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
+ retval = error(_("checking out '%s' failed."
+ " 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);
+
+ if (no_checkout) {
+ get_oid(start_head.buf, &oid);
+ if (update_ref(NULL, "BISECT_HEAD", &oid, NULL, 0,
+ UPDATE_REFS_MSG_ON_ERR)) {
+ retval = -1;
+ 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)) {
+ retval = -1;
+ goto finish;
+ }
+
+ if (must_write_terms && write_terms(terms->term_bad,
+ terms->term_good)) {
+ retval = -1;
+ goto finish;
+ }
+
+ retval = bisect_append_log_quoted(argv);
+ if (retval)
+ retval = -1;
+
+finish:
+ string_list_clear(&revs, 0);
+ string_list_clear(&states, 0);
+ strbuf_release(&start_head);
+ strbuf_release(&bisect_names);
+ return retval;
+}
+
int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
{
enum {
@@ -400,7 +618,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
BISECT_WRITE,
CHECK_AND_SET_TERMS,
BISECT_NEXT_CHECK,
- BISECT_TERMS
+ BISECT_TERMS,
+ BISECT_START
} cmdmode = 0;
int no_checkout = 0, res = 0, nolog = 0;
struct option options[] = {
@@ -422,6 +641,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
N_("check whether bad or good terms exist"), BISECT_NEXT_CHECK),
OPT_CMDMODE(0, "bisect-terms", &cmdmode,
N_("print out the bisect terms"), BISECT_TERMS),
+ OPT_CMDMODE(0, "bisect-start", &cmdmode,
+ N_("start the bisect session"), BISECT_START),
OPT_BOOL(0, "no-checkout", &no_checkout,
N_("update BISECT_HEAD instead of checking out the current commit")),
OPT_BOOL(0, "no-log", &nolog,
@@ -431,7 +652,8 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
struct bisect_terms terms = { .term_good = NULL, .term_bad = NULL };
argc = parse_options(argc, argv, prefix, options,
- git_bisect_helper_usage, PARSE_OPT_KEEP_UNKNOWN);
+ git_bisect_helper_usage,
+ PARSE_OPT_KEEP_DASHDASH | PARSE_OPT_KEEP_UNKNOWN);
if (!cmdmode)
usage_with_options(git_bisect_helper_usage, options);
@@ -477,6 +699,10 @@ int cmd_bisect__helper(int argc, const char **argv, const char *prefix)
return error(_("--bisect-terms requires 0 or 1 argument"));
res = bisect_terms(&terms, argc == 1 ? argv[0] : NULL);
break;
+ case BISECT_START:
+ set_terms(&terms, "bad", "good");
+ res = bisect_start(&terms, no_checkout, argv, argc);
+ break;
default:
return error("BUG: unknown subcommand '%d'", cmdmode);
}
diff --git a/git-bisect.sh b/git-bisect.sh
index bdb614e3c2..efee12b8b1 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -71,122 +71,7 @@ bisect_autostart() {
}
bisect_start() {
- #
- # Check for one bad and then some good revisions.
- #
- has_double_dash=0
- for arg; do
- case "$arg" in --) has_double_dash=1; break ;; esac
- done
- orig_args=$(git rev-parse --sq-quote "$@")
- bad_seen=0
- eval=''
- must_write_terms=0
- revs=''
- if test "z$(git rev-parse --is-bare-repository)" != zfalse
- then
- mode=--no-checkout
- else
- mode=''
- fi
- while [ $# -gt 0 ]; do
- arg="$1"
- case "$arg" in
- --)
- shift
- break
- ;;
- --no-checkout)
- mode=--no-checkout
- shift ;;
- --term-good|--term-old)
- shift
- must_write_terms=1
- TERM_GOOD=$1
- shift ;;
- --term-good=*|--term-old=*)
- must_write_terms=1
- TERM_GOOD=${1#*=}
- shift ;;
- --term-bad|--term-new)
- shift
- must_write_terms=1
- TERM_BAD=$1
- shift ;;
- --term-bad=*|--term-new=*)
- must_write_terms=1
- TERM_BAD=${1#*=}
- shift ;;
- --*)
- die "$(eval_gettext "unrecognised option: '\$arg'")" ;;
- *)
- rev=$(git rev-parse -q --verify "$arg^{commit}") || {
- test $has_double_dash -eq 1 &&
- die "$(eval_gettext "'\$arg' does not appear to be a valid revision")"
- break
- }
- revs="$revs $rev"
- shift
- ;;
- esac
- done
-
- for rev in $revs
- do
- # 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.
- must_write_terms=1
-
- case $bad_seen in
- 0) state=$TERM_BAD ; bad_seen=1 ;;
- *) state=$TERM_GOOD ;;
- esac
- eval="$eval git bisect--helper --bisect-write '$state' '$rev' '$TERM_GOOD' '$TERM_BAD' 'nolog' &&"
- done
- #
- # Verify HEAD.
- #
- head=$(GIT_DIR="$GIT_DIR" git symbolic-ref -q HEAD) ||
- head=$(GIT_DIR="$GIT_DIR" git rev-parse --verify HEAD) ||
- die "$(gettext "Bad HEAD - I need a HEAD")"
-
- #
- # Check if we are bisecting.
- #
- start_head=''
- if test -s "$GIT_DIR/BISECT_START"
- then
- # Reset to the rev from where we started.
- start_head=$(cat "$GIT_DIR/BISECT_START")
- if test "z$mode" != "z--no-checkout"
- then
- git checkout "$start_head" -- ||
- die "$(eval_gettext "Checking out '\$start_head' failed. Try 'git bisect reset <valid-branch>'.")"
- fi
- else
- # Get rev from where we start.
- case "$head" in
- refs/heads/*|$_x40)
- # This error message should only be triggered by
- # cogito usage, and cogito users should understand
- # it relates to cg-seek.
- [ -s "$GIT_DIR/head-name" ] &&
- die "$(gettext "won't bisect on cg-seek'ed tree")"
- start_head="${head#refs/heads/}"
- ;;
- *)
- die "$(gettext "Bad HEAD - strange symbolic ref")"
- ;;
- esac
- fi
-
- #
- # Get rid of any old bisect state.
- #
- git bisect--helper --bisect-clean-state || exit
+ git bisect--helper --bisect-start $@ || exit
#
# Change state.
@@ -198,23 +83,10 @@ bisect_start() {
trap 'git bisect--helper --bisect-clean-state' 0
trap 'exit 255' 1 2 3 15
- #
- # Write new start state.
- #
- echo "$start_head" >"$GIT_DIR/BISECT_START" && {
- test "z$mode" != "z--no-checkout" ||
- git update-ref --no-deref BISECT_HEAD "$start_head"
- } &&
- git rev-parse --sq-quote "$@" >"$GIT_DIR/BISECT_NAMES" &&
- eval "$eval true" &&
- if test $must_write_terms -eq 1
- then
- git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
- fi &&
- echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
#
# Check if we can proceed to the next bisect state.
#
+ get_terms
bisect_auto_next
trap '-' 0
--
gitgitgadget
^ permalink raw reply related [flat|nested] 320+ messages in thread
* Re: [PATCH v17 0/7] git bisect: convert from shell to C
2019-01-02 15:38 ` [PATCH v17 0/7] git bisect: convert from shell to C Tanushree Tumane via GitGitGadget
` (6 preceding siblings ...)
2019-01-02 15:38 ` [PATCH v17 7/7] bisect--helper: `bisect_start` shell function partially " Pranit Bauva via GitGitGadget
@ 2019-01-03 1:19 ` Ramsay Jones
2019-01-07 9:15 ` TANUSHREE TUMANE
7 siblings, 1 reply; 320+ messages in thread
From: Ramsay Jones @ 2019-01-03 1:19 UTC (permalink / raw)
To: Tanushree Tumane via GitGitGadget, git; +Cc: Junio C Hamano
On 02/01/2019 15:38, Tanushree Tumane via GitGitGadget wrote:
[snip]
> base-commit: 7f4e64169352e03476b0ea64e7e2973669e491a2
> Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-101%2Ftanushree27%2Fgit-bisect_part2_fixup-v17
> Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-101/tanushree27/git-bisect_part2_fixup-v17
> Pull-Request: https://github.com/gitgitgadget/git/pull/101
I didn't look at the patches, only the range-diff below, and the
only thing I noticed was ...
>
> Range-diff vs v16:
>
> 1: f1e89ba517 ! 1: 338ebdc97a bisect--helper: `bisect_reset` shell function in C
> @@ -16,8 +16,9 @@
>
> Mentored-by: Lars Schneider <larsxschneider@gmail.com>
> Mentored-by: Christian Couder <chriscool@tuxfamily.org>
> + Mentored by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
> Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
> - Signed-off-by: Junio C Hamano <gitster@pobox.com>
> + Signed-off-by: Tanushree Tumane <tanushreetumane@gmail.com>
>
> diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> --- a/builtin/bisect--helper.c
> @@ -53,8 +54,10 @@
> + struct strbuf branch = STRBUF_INIT;
> +
> + if (!commit) {
> -+ if (strbuf_read_file(&branch, git_path_bisect_start(), 0) < 1)
> -+ return !printf(_("We are not bisecting.\n"));
> ++ 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;
> @@ -69,11 +72,11 @@
> +
> + argv_array_pushl(&argv, "checkout", branch.buf, "--", NULL);
> + if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
> -+ error(_("Could not check out original HEAD '%s'. Try "
> -+ "'git bisect reset <commit>'."), branch.buf);
> + strbuf_release(&branch);
> + argv_array_clear(&argv);
> -+ return -1;
> ++ return error(_("could not check out original"
> ++ " HEAD '%s'. Try 'git bisect"
> ++ "reset <commit>'."), branch.buf);
... this 'branch.buf' will refer to the empty 'slopbuf', since
the call to 'strbuf_release(&branch)' now precedes this call
to error().
ATB,
Ramsay Jones
^ permalink raw reply [flat|nested] 320+ messages in thread
* Re: [PATCH v17 0/7] git bisect: convert from shell to C
2019-01-03 1:19 ` [PATCH v17 0/7] git bisect: convert from shell to C Ramsay Jones
@ 2019-01-07 9:15 ` TANUSHREE TUMANE
0 siblings, 0 replies; 320+ messages in thread
From: TANUSHREE TUMANE @ 2019-01-07 9:15 UTC (permalink / raw)
To: Ramsay Jones; +Cc: Tanushree Tumane via GitGitGadget, git, Junio C Hamano
Yes, you are right. I will revert this back.
On Fri, Jan 4, 2019 at 8:08 PM Ramsay Jones <ramsay@ramsayjones.plus.com> wrote:
>
>
>
> On 02/01/2019 15:38, Tanushree Tumane via GitGitGadget wrote:
> [snip]
> > base-commit: 7f4e64169352e03476b0ea64e7e2973669e491a2
> > Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-101%2Ftanushree27%2Fgit-bisect_part2_fixup-v17
> > Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-101/tanushree27/git-bisect_part2_fixup-v17
> > Pull-Request: https://github.com/gitgitgadget/git/pull/101
>
> I didn't look at the patches, only the range-diff below, and the
> only thing I noticed was ...
>
> >
> > Range-diff vs v16:
> >
> > 1: f1e89ba517 ! 1: 338ebdc97a bisect--helper: `bisect_reset` shell function in C
> > @@ -16,8 +16,9 @@
> >
> > Mentored-by: Lars Schneider <larsxschneider@gmail.com>
> > Mentored-by: Christian Couder <chriscool@tuxfamily.org>
> > + Mentored by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
> > Signed-off-by: Pranit Bauva <pranit.bauva@gmail.com>
> > - Signed-off-by: Junio C Hamano <gitster@pobox.com>
> > + Signed-off-by: Tanushree Tumane <tanushreetumane@gmail.com>
> >
> > diff --git a/builtin/bisect--helper.c b/builtin/bisect--helper.c
> > --- a/builtin/bisect--helper.c
> > @@ -53,8 +54,10 @@
> > + struct strbuf branch = STRBUF_INIT;
> > +
> > + if (!commit) {
> > -+ if (strbuf_read_file(&branch, git_path_bisect_start(), 0) < 1)
> > -+ return !printf(_("We are not bisecting.\n"));
> > ++ 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;
> > @@ -69,11 +72,11 @@
> > +
> > + argv_array_pushl(&argv, "checkout", branch.buf, "--", NULL);
> > + if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
> > -+ error(_("Could not check out original HEAD '%s'. Try "
> > -+ "'git bisect reset <commit>'."), branch.buf);
> > + strbuf_release(&branch);
> > + argv_array_clear(&argv);
> > -+ return -1;
> > ++ return error(_("could not check out original"
> > ++ " HEAD '%s'. Try 'git bisect"
> > ++ "reset <commit>'."), branch.buf);
>
> ... this 'branch.buf' will refer to the empty 'slopbuf', since
> the call to 'strbuf_release(&branch)' now precedes this call
> to error().
>
> ATB,
> Ramsay Jones
>
^ permalink raw reply [flat|nested] 320+ messages in thread
end of thread, other threads:[~2019-01-07 9:15 UTC | newest]
Thread overview: 320+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2016-07-12 22:35 [PATCH 0/9] Resend of gitster/pb/bisect Pranit Bauva
2016-07-12 22:35 ` [PATCH 1/9] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
2016-07-12 22:35 ` [PATCH 2/9] bisect: rewrite `check_term_format` shell function in C Pranit Bauva
2016-07-12 22:35 ` [PATCH 3/9] bisect--helper: `write_terms` " Pranit Bauva
2016-07-12 22:35 ` [PATCH 4/9] bisect--helper: `bisect_clean_state` " Pranit Bauva
2016-07-12 22:35 ` [PATCH 5/9] t6030: explicitly test for bisection cleanup Pranit Bauva
2016-07-12 22:35 ` [PATCH 6/9] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
2016-07-12 22:35 ` [PATCH 7/9] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
2016-07-12 22:35 ` [PATCH 8/9] bisect--helper: `is_expected_rev` & `check_expected_revs` " Pranit Bauva
2016-07-12 22:35 ` [PATCH 9/9] bisect--helper: `bisect_write` " Pranit Bauva
2016-07-13 7:47 ` [PATCH 0/9] Resend of gitster/pb/bisect Christian Couder
2016-07-20 16:00 ` Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 01/12] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 11/12] bisect--helper: `bisect_next_check` shell function in C Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 12/12] bisect--helper: `get_terms` & `bisect_terms` " Pranit Bauva
2016-07-22 2:29 ` Torsten Bögershausen
2016-07-22 14:07 ` Pranit Bauva
2016-07-25 16:53 ` Junio C Hamano
2016-07-25 21:28 ` Christian Couder
2016-07-26 1:42 ` Torsten Bögershausen
2016-07-26 17:32 ` Junio C Hamano
2016-07-27 4:20 ` Pranit Bauva
2016-07-27 16:13 ` Junio C Hamano
2016-07-20 21:47 ` [PATCH v10 06/12] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 10/12] bisect--helper: `check_and_set_terms` shell function in C Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 02/12] bisect: rewrite `check_term_format` " Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 05/12] t6030: explicitly test for bisection cleanup Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 07/12] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 08/12] bisect--helper: `is_expected_rev` & `check_expected_revs` " Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 09/12] bisect--helper: `bisect_write` " Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 03/12] bisect--helper: `write_terms` " Pranit Bauva
2016-07-20 21:47 ` [PATCH v10 04/12] bisect--helper: `bisect_clean_state` " Pranit Bauva
2016-07-31 9:21 ` [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
2016-07-31 9:21 ` [RFC/PATCH v11 08/13] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C Pranit Bauva
2016-08-02 18:46 ` Junio C Hamano
2016-07-31 9:21 ` [RFC/PATCH v11 09/13] bisect--helper: `bisect_write` " Pranit Bauva
2016-08-02 20:25 ` Junio C Hamano
2016-08-02 22:17 ` Junio C Hamano
2016-08-03 20:52 ` Pranit Bauva
2016-08-03 20:51 ` Pranit Bauva
2016-07-31 9:21 ` [RFC/PATCH v11 02/13] bisect: rewrite `check_term_format` " Pranit Bauva
2016-08-02 17:31 ` Junio C Hamano
2016-08-03 20:20 ` Pranit Bauva
2016-07-31 9:21 ` [RFC/PATCH v11 03/13] bisect--helper: `write_terms` " Pranit Bauva
2016-08-02 17:38 ` Junio C Hamano
2016-08-03 20:21 ` Pranit Bauva
2016-08-04 15:39 ` Junio C Hamano
2016-07-31 9:21 ` [RFC/PATCH v11 05/13] t6030: explicitly test for bisection cleanup Pranit Bauva
2016-07-31 9:21 ` [RFC/PATCH v11 06/13] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
2016-07-31 9:21 ` [RFC/PATCH v11 04/13] bisect--helper: `bisect_clean_state` shell function in C Pranit Bauva
2016-08-02 17:46 ` Junio C Hamano
2016-08-03 20:27 ` Pranit Bauva
2016-08-04 15:45 ` Junio C Hamano
2016-08-04 16:07 ` Pranit Bauva
2016-08-04 16:50 ` Junio C Hamano
2016-08-04 16:57 ` Pranit Bauva
2016-07-31 9:21 ` [RFC/PATCH v11 10/13] bisect--helper: `check_and_set_terms` " Pranit Bauva
2016-08-02 18:53 ` Junio C Hamano
2016-08-03 20:29 ` Pranit Bauva
2016-07-31 9:21 ` [RFC/PATCH v11 12/13] bisect--helper: `get_terms` & `bisect_terms` " Pranit Bauva
2016-08-02 19:22 ` Junio C Hamano
2016-08-03 20:33 ` Pranit Bauva
2016-07-31 9:21 ` [RFC/PATCH v11 07/13] bisect--helper: `bisect_reset` " Pranit Bauva
2016-08-02 18:44 ` Junio C Hamano
2016-07-31 9:21 ` [RFC/PATCH v11 11/13] bisect--helper: `bisect_next_check` " Pranit Bauva
2016-08-02 19:17 ` Junio C Hamano
2016-08-03 20:33 ` Pranit Bauva
2016-07-31 9:21 ` [RFC/PATCH v11 13/13] bisect--helper: `bisect_start` shell function partially " Pranit Bauva
2016-08-02 20:19 ` Junio C Hamano
2016-08-03 20:49 ` Pranit Bauva
2016-08-02 17:25 ` [RFC/PATCH v11 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Junio C Hamano
2016-08-10 21:57 ` [PATCH v12 " Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 02/13] bisect: rewrite `check_term_format` shell function in C Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 09/13] bisect--helper: `bisect_write` " Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 13/13] bisect--helper: `bisect_start` shell function partially " Pranit Bauva
2016-08-12 19:25 ` Junio C Hamano
2016-08-13 6:33 ` Pranit Bauva
2016-08-13 7:34 ` Christian Couder
2016-08-13 13:50 ` Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 08/13] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function " Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 03/13] bisect--helper: `write_terms` " Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 07/13] bisect--helper: `bisect_reset` " Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 06/13] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 10/13] bisect--helper: `check_and_set_terms` shell function in C Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 04/13] bisect--helper: `bisect_clean_state` " Pranit Bauva
2016-08-12 19:24 ` Junio C Hamano
2016-08-10 21:57 ` [PATCH v12 11/13] bisect--helper: `bisect_next_check` & bisect_voc " Pranit Bauva
2016-08-12 18:11 ` Junio C Hamano
2016-08-12 18:49 ` Junio C Hamano
2016-08-13 6:32 ` Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 05/13] t6030: explicitly test for bisection cleanup Pranit Bauva
2016-08-10 21:57 ` [PATCH v12 12/13] bisect--helper: `get_terms` & `bisect_terms` shell function in C Pranit Bauva
2016-08-10 22:19 ` [PATCH v12 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 " Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 04/13] bisect--helper: `bisect_clean_state` shell function in C Pranit Bauva
2016-08-21 11:18 ` Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 07/13] bisect--helper: `bisect_reset` " Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 08/13] bisect--helper: `is_expected_rev` & `check_expected_revs` " Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 12/13] bisect--helper: `get_terms` & `bisect_terms` " Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 09/13] bisect--helper: `bisect_write` " Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 10/13] bisect--helper: `check_and_set_terms` " Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 06/13] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 13/13] bisect--helper: `bisect_start` shell function partially in C Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 05/13] t6030: explicitly test for bisection cleanup Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 11/13] bisect--helper: `bisect_next_check` & bisect_voc shell function in C Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 02/13] bisect: rewrite `check_term_format` " Pranit Bauva
2016-08-19 20:32 ` [PATCH v13 03/13] bisect--helper: `write_terms` " Pranit Bauva
2016-08-21 11:14 ` [PATCH v13 01/13] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 01/27] " Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 09/27] bisect--helper: `bisect_write` shell function in C Pranit Bauva
2016-08-24 22:30 ` Junio C Hamano
2016-08-27 9:33 ` Pranit Bauva
2016-08-27 21:22 ` Junio C Hamano
2016-08-30 6:42 ` Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 23/27] bisect--helper: retire `--bisect-write` subcommand Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 02/27] bisect: rewrite `check_term_format` shell function in C Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 20/27] bisect--helper: retire `--write-terms` subcommand Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 27/27] bisect--helper: remove the dequote in bisect_start() Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 14/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function in C Pranit Bauva
2016-08-25 20:30 ` Junio C Hamano
2016-08-30 18:25 ` Pranit Bauva
2016-08-30 18:44 ` Pranit Bauva
2016-08-30 19:33 ` Junio C Hamano
2016-08-30 20:17 ` Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 10/27] bisect--helper: `check_and_set_terms` " Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 15/27] bisect--helper: retire `--bisect-clean-state` subcommand Pranit Bauva
2016-08-26 20:56 ` Junio C Hamano
2016-08-23 11:53 ` [PATCH v14 12/27] bisect--helper: `get_terms` & `bisect_terms` shell function in C Pranit Bauva
2016-08-25 18:05 ` Junio C Hamano
2016-08-27 9:48 ` Pranit Bauva
2016-08-29 17:15 ` Junio C Hamano
2016-08-23 11:53 ` [PATCH v14 16/27] bisect--helper: retire `--next-all` subcommand Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 13/27] bisect--helper: `bisect_start` shell function partially in C Pranit Bauva
2016-08-25 19:02 ` Junio C Hamano
2016-08-25 19:43 ` Junio C Hamano
2016-08-27 19:47 ` Pranit Bauva
2016-08-27 20:53 ` Junio C Hamano
2016-08-23 11:53 ` [PATCH v14 26/27] bisect--helper: retire `--bisect-auto-next` subcommand Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 05/27] t6030: explicitly test for bisection cleanup Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 11/27] bisect--helper: `bisect_next_check` & bisect_voc shell function in C Pranit Bauva
2016-08-24 22:40 ` Junio C Hamano
2016-08-27 9:35 ` Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 25/27] bisect--helper: retire `--bisect-autostart` subcommand Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 07/27] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
2016-08-24 21:12 ` Junio C Hamano
2016-08-26 13:46 ` Pranit Bauva
2016-08-26 16:29 ` Junio C Hamano
2016-08-27 10:52 ` Pranit Bauva
2016-08-29 17:06 ` Junio C Hamano
2016-08-23 11:53 ` [PATCH v14 18/27] bisect--helper: `bisect_state` & `bisect_head` " Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 17/27] bisect--helper: `bisect_autostart` " Pranit Bauva
2016-08-26 21:09 ` Junio C Hamano
2016-08-23 11:53 ` [PATCH v14 22/27] bisect--helper: `bisect_replay` " Pranit Bauva
2016-08-26 23:24 ` Junio C Hamano
2016-08-23 11:53 ` [PATCH v14 21/27] bisect--helper: `bisect_log` " Pranit Bauva
2016-08-26 23:07 ` Junio C Hamano
2016-08-27 20:16 ` Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 24/27] bisect--helper: retire `--check-and-set-terms` subcommand Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 08/27] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C Pranit Bauva
2016-08-24 22:13 ` Junio C Hamano
2016-08-27 9:14 ` Pranit Bauva
2016-08-29 17:17 ` Junio C Hamano
2016-08-23 11:53 ` [PATCH v14 03/27] bisect--helper: `write_terms` " Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 06/27] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 19/27] bisect--helper: retire `--check-expected-revs` subcommand Pranit Bauva
2016-08-23 11:53 ` [PATCH v14 04/27] bisect--helper: `bisect_clean_state` shell function in C Pranit Bauva
2016-08-24 20:58 ` Junio C Hamano
2016-08-23 20:28 ` [PATCH v14 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Junio C Hamano
2016-08-23 21:07 ` Pranit Bauva
2016-08-23 21:24 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 " Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 02/27] bisect: rewrite `check_term_format` shell function in C Pranit Bauva
2016-11-14 22:20 ` Stephan Beyer
2016-11-15 5:16 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 03/27] bisect--helper: `write_terms` " Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 05/27] t6030: explicitly test for bisection cleanup Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 09/27] bisect--helper: `bisect_write` shell function in C Pranit Bauva
2016-11-17 9:40 ` Stephan Beyer
2016-12-06 21:32 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 20/27] bisect--helper: retire `--check-expected-revs` subcommand Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 17/27] bisect--helper: retire `--next-all` subcommand Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 18/27] bisect--helper: `bisect_autostart` shell function in C Pranit Bauva
2016-11-20 20:15 ` Stephan Beyer
2016-12-06 19:47 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 10/27] bisect--helper: `check_and_set_terms` " Pranit Bauva
2016-11-17 20:25 ` Stephan Beyer
2016-12-06 22:43 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 06/27] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 13/27] bisect--helper: `bisect_start` shell function partially in C Pranit Bauva
2016-11-15 23:19 ` Stephan Beyer
2016-11-16 17:09 ` Pranit Bauva
2016-11-20 20:01 ` Stephan Beyer
2016-11-20 20:19 ` Stephan Beyer
2016-10-14 14:14 ` [PATCH v15 15/27] bisect--helper: `bisect_next` and `bisect_auto_next` shell function " Pranit Bauva
2016-11-20 20:01 ` Stephan Beyer
2016-12-31 10:23 ` Pranit Bauva
2016-11-21 21:35 ` Stephan Beyer
2016-12-31 10:43 ` Pranit Bauva
2017-01-01 16:27 ` Stephan Beyer
2017-01-01 17:41 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 07/27] bisect--helper: `bisect_reset` " Pranit Bauva
2016-11-16 23:23 ` Stephan Beyer
2016-11-17 3:56 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 22/27] bisect--helper: `bisect_log` " Pranit Bauva
2016-11-17 21:47 ` Stephan Beyer
2016-12-06 22:42 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 14/27] t6030: no cleanup with bad merge base Pranit Bauva
2016-10-14 21:43 ` Junio C Hamano
2016-10-15 8:46 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 21/27] bisect--helper: retire `--write-terms` subcommand Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 08/27] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C Pranit Bauva
2016-11-16 23:47 ` Stephan Beyer
2016-12-06 19:33 ` Pranit Bauva
2016-12-16 19:00 ` Pranit Bauva
2016-12-17 19:42 ` Stephan Beyer
2016-12-16 19:35 ` Pranit Bauva
2016-12-17 19:55 ` Stephan Beyer
2016-10-14 14:14 ` [PATCH v15 11/27] bisect--helper: `bisect_next_check` & bisect_voc " Pranit Bauva
2016-11-17 20:59 ` Stephan Beyer
2016-12-06 18:39 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 19/27] bisect--helper: `bisect_state` & `bisect_head` " Pranit Bauva
2016-11-22 0:12 ` Stephan Beyer
2016-12-06 22:40 ` Pranit Bauva
2016-12-06 23:54 ` Stephan Beyer
2016-12-08 6:43 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 25/27] bisect--helper: retire `--bisect-autostart` subcommand Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 04/27] bisect--helper: `bisect_clean_state` shell function in C Pranit Bauva
2016-11-15 21:09 ` Stephan Beyer
2016-11-15 21:40 ` Junio C Hamano
2016-11-15 21:53 ` Stephan Beyer
2016-11-16 16:49 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 26/27] bisect--helper: retire `--bisect-auto-next` subcommand Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 16/27] bisect--helper: retire `--bisect-clean-state` subcommand Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 12/27] bisect--helper: `get_terms` & `bisect_terms` shell function in C Pranit Bauva
2016-11-17 21:32 ` Stephan Beyer
2016-12-06 21:14 ` Pranit Bauva
2016-12-06 23:05 ` Stephan Beyer
2016-12-07 12:06 ` Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 24/27] bisect--helper: retire `--bisect-write` subcommand Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 27/27] bisect--helper: remove the dequote in bisect_start() Pranit Bauva
2016-10-14 14:14 ` [PATCH v15 23/27] bisect--helper: `bisect_replay` shell function in C Pranit Bauva
2016-11-22 0:49 ` Stephan Beyer
2016-12-06 23:02 ` Pranit Bauva
2016-12-06 23:20 ` Stephan Beyer
2016-12-06 23:40 ` Stephan Beyer
2016-12-07 13:15 ` Christian Couder
2016-10-14 15:12 ` [PATCH v15 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Pranit Bauva
2017-09-29 6:49 ` [PATCH v16 1/6] " Pranit Bauva
2017-09-29 6:49 ` [PATCH v16 2/6] bisect--helper: rewrite `check_term_format` shell function in C Pranit Bauva
2017-09-29 6:49 ` [PATCH v16 4/6] bisect--helper: `bisect_clean_state` " Pranit Bauva
2017-09-29 6:49 ` [PATCH v16 3/6] bisect--helper: `write_terms` " Pranit Bauva
2017-09-29 6:49 ` [PATCH v16 5/6] t6030: explicitly test for bisection cleanup Pranit Bauva
2017-09-29 6:49 ` [PATCH v16 6/6] bisect--helper: `is_expected_rev` & `check_expected_revs` shell function in C Pranit Bauva
2017-11-19 20:34 ` Christian Couder
2017-11-20 3:05 ` Junio C Hamano
2017-11-20 7:03 ` Christian Couder
2017-09-29 18:54 ` [PATCH v16 1/6] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Stephan Beyer
2017-09-29 21:10 ` Pranit Bauva
2017-09-30 12:59 ` Ramsay Jones
2017-10-02 13:44 ` Pranit Bauva
2017-10-03 0:48 ` Ramsay Jones
2017-10-03 3:51 ` Junio C Hamano
2017-10-03 4:35 ` Pranit Bauva
2017-10-04 2:22 ` Ramsay Jones
2017-10-04 4:07 ` Junio C Hamano
2017-10-27 15:06 ` [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
2017-10-27 15:06 ` [PATCH v16 Part II 2/8] bisect--helper: `bisect_write` " Pranit Bauva
2017-10-27 17:28 ` Martin Ågren
2017-10-30 17:35 ` Pranit Bauva
2018-11-23 10:13 ` Johannes Schindelin
2018-11-23 12:22 ` Martin Ågren
2018-11-26 18:18 ` Johannes Schindelin
2017-10-27 18:19 ` Junio C Hamano
2017-10-30 17:38 ` Pranit Bauva
2017-10-30 13:38 ` Stephan Beyer
2017-10-30 16:24 ` Stephan Beyer
2017-11-08 0:26 ` Ramsay Jones
2017-10-27 15:06 ` [PATCH v16 Part II 6/8] bisect--helper: `get_terms` & `bisect_terms` " Pranit Bauva
2017-10-27 20:04 ` Martin Ågren
2017-10-30 17:45 ` Pranit Bauva
2017-10-30 16:34 ` Stephan Beyer
2017-10-30 17:31 ` Pranit Bauva
2017-11-08 0:59 ` Ramsay Jones
2017-10-27 15:06 ` [PATCH v16 Part II 4/8] bisect--helper: `check_and_set_terms` " Pranit Bauva
2017-11-08 0:37 ` Ramsay Jones
2017-10-27 15:06 ` [PATCH v16 Part II 8/8] t6030: make various test to pass GETTEXT_POISON tests Pranit Bauva
2017-10-27 15:06 ` [PATCH v16 Part II 7/8] bisect--helper: `bisect_start` shell function partially in C Pranit Bauva
2017-10-30 16:51 ` Stephan Beyer
2017-10-30 17:28 ` Pranit Bauva
2018-02-16 1:22 ` SZEDER Gábor
2017-10-27 15:06 ` [PATCH v16 Part II 5/8] bisect--helper: `bisect_next_check` shell function " Pranit Bauva
2017-10-27 17:35 ` Martin Ågren
2017-10-30 17:40 ` Pranit Bauva
2017-11-08 0:48 ` Ramsay Jones
2017-11-12 19:19 ` Stephan Beyer
2017-11-12 19:27 ` Stephan Beyer
2017-11-12 20:03 ` Stephan Beyer
2017-11-13 3:56 ` Junio C Hamano
2017-10-27 15:06 ` [PATCH v16 Part II 3/8] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva
2017-10-27 15:32 ` [PATCH v16 Part II 1/8] bisect--helper: `bisect_reset` shell function in C Pranit Bauva
2017-10-27 17:40 ` Junio C Hamano
2017-10-30 17:26 ` Pranit Bauva
2017-10-30 13:22 ` Stephan Beyer
2017-10-30 17:27 ` Pranit Bauva
2017-11-08 0:07 ` Ramsay Jones
2019-01-02 15:38 ` [PATCH v17 0/7] git bisect: convert from shell to C Tanushree Tumane via GitGitGadget
2019-01-02 15:38 ` [PATCH v17 1/7] bisect--helper: `bisect_reset` shell function in C Pranit Bauva via GitGitGadget
2019-01-02 15:38 ` [PATCH v17 3/7] wrapper: move is_empty_file() and rename it as is_empty_or_missing_file() Pranit Bauva via GitGitGadget
2019-01-02 15:38 ` [PATCH v17 2/7] bisect--helper: `bisect_write` shell function in C Pranit Bauva via GitGitGadget
2019-01-02 15:38 ` [PATCH v17 4/7] bisect--helper: `check_and_set_terms` " Pranit Bauva via GitGitGadget
2019-01-02 15:38 ` [PATCH v17 5/7] bisect--helper: `bisect_next_check` " Pranit Bauva via GitGitGadget
2019-01-02 15:38 ` [PATCH v17 6/7] bisect--helper: `get_terms` & `bisect_terms` " Pranit Bauva via GitGitGadget
2019-01-02 15:38 ` [PATCH v17 7/7] bisect--helper: `bisect_start` shell function partially " Pranit Bauva via GitGitGadget
2019-01-03 1:19 ` [PATCH v17 0/7] git bisect: convert from shell to C Ramsay Jones
2019-01-07 9:15 ` TANUSHREE TUMANE
2016-10-27 16:59 ` [PATCH v15 01/27] bisect--helper: use OPT_CMDMODE instead of OPT_BOOL Junio C Hamano
2016-10-27 20:14 ` Christian Couder
2016-10-28 6:02 ` Matthieu Moy
2016-11-15 21:40 ` Stephan Beyer
2016-11-16 0:18 ` Junio C Hamano
Code repositories for project(s) associated with this public inbox
https://80x24.org/mirrors/git.git
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).