git@vger.kernel.org mailing list mirror (one of many)
 help / color / Atom feed
From: Derrick Stolee <stolee@gmail.com>
To: "git@vger.kernel.org" <git@vger.kernel.org>
Subject: Git Test Coverage Report (Sat Jan 19)
Date: Sat, 19 Jan 2019 20:07:07 -0500
Message-ID: <6addc879-a792-202f-2aeb-7097ea344894@gmail.com> (raw)

Here is today's test coverage report.

Also, there has been some feedback that it can be hard to manually match 
up uncovered lines with names at the bottom of the summary. The 
suggestion was to auto-generate an HTML report that could be posted to a 
public page and referenced in this mail for those who prefer that. Any 
suggestions for how that should look before we start building it?

Thanks,

-Stolee

[1] https://dev.azure.com/git/git/_build/results?buildId=307

---

pu: 32ea0d952e6add9269432e6e2b31fd552e5478c0
jch: bc1fa105c1c1d5870a7e2800526f0a7ebf17d064
next: aa96b0ce6b0fa4fa4cc6870f1a3aff3878967bfa
master: 16a465bc018d09e9d7bbbdc5f40a7fb99c21f8ef
master@{1}: 77556354bb7ac50450e3b28999e3576969869068

Uncovered code in 'pu' not in 'jch'
--------------------------------------

bisect.c
4f6d26b167  661) mark_edges_uninteresting(revs, NULL, 0);

blame.c
e1ff0a32e4  191) repo_read_index(r);
e1ff0a32e4  273) repo_read_index(r);
07d04b919e  482)     ent->s_lno + ent->num_lines == next->s_lno &&
07d04b919e  483)     ent->ignored == next->ignored) {
07d04b919e  735) split[0].ignored = split[1].ignored = split[2].ignored 
= e->ignored;
e7973c8519  859) struct blame_entry *samep = NULL, *diffp = NULL, 
*ignoredp = NULL;
07d04b919e  873) n->ignored = e->ignored;
07d04b919e  928) n->ignored = e->ignored;
e7973c8519  938) if (ignore_diffs) {
e7973c8519  940) blame_origin_decref(e->suspect);
e7973c8519  941) e->suspect = blame_origin_incref(parent);
e7973c8519  942) e->s_lno += offset;
07d04b919e  943) e->ignored = 1;
e7973c8519  944) e->next = ignoredp;
e7973c8519  945) ignoredp = e;
e7973c8519  947) e->next = diffp;
e7973c8519  948) diffp = e;
e7973c8519  952) if (ignoredp) {
e7973c8519  953) **dstq = reverse_blame(ignoredp, **dstq);
e7973c8519  954) *dstq = &ignoredp->next;
e7973c8519 1001) d.ignore_diffs = ignore_diffs;
e7973c8519 1013) blame_chunk(&d.dstq, &d.srcq, INT_MAX, d.offset, 
INT_MAX, parent, 0);
e7973c8519 1518) pass_blame_to_parent(sb, origin, porigin, 0);
e7973c8519 1526) if (oidset_contains(&sb->ignore_list, 
&commit->object.oid)) {
e7973c8519 1527) for (i = 0, sg = first_scapegoat(revs, commit, 
sb->reverse);
e7973c8519 1528)      i < num_sg && sg;
e7973c8519 1529)      sg = sg->next, i++) {
e7973c8519 1530) struct blame_origin *porigin = sg_origin[i];
e7973c8519 1532) if (!porigin)
e7973c8519 1533) continue;
e7973c8519 1534) pass_blame_to_parent(sb, origin, porigin, 1);
e7973c8519 1535) if (!origin->suspects)
e7973c8519 1536) goto finish;

builtin/am.c
1d18d7581c  515) finish_copy_notes_for_rewrite(the_repository, c, msg);
150fe065f7 1765)     !repo_index_has_changes(the_repository, NULL, NULL)) {
150fe065f7 1819) if (!repo_index_has_changes(the_repository, NULL, NULL)) {

builtin/blame.c
07d04b919e builtin/blame.c    484) if (mark_ignored_lines && ent->ignored) {
07d04b919e builtin/blame.c    485) length--;
07d04b919e builtin/blame.c    486) putchar('*');
e7973c8519 builtin/blame.c    704) if (!strcmp(var, "blame.ignorerevsfile"))
e7973c8519 builtin/blame.c    705) return 
git_config_pathname(&ignore_revs_file, var, value);
07d04b919e builtin/blame.c    706) if (!strcmp(var, 
"blame.markignoredlines")) {
07d04b919e builtin/blame.c    707) mark_ignored_lines = 
git_config_bool(var, value);
07d04b919e builtin/blame.c    708) return 0;
e7973c8519 builtin/blame.c    789) static void build_ignorelist(struct 
blame_scoreboard *sb,
e7973c8519 builtin/blame.c    795) oidset_init(&sb->ignore_list, 0);
e7973c8519 builtin/blame.c    796) if (ignore_revs_file)
e7973c8519 builtin/blame.c    797) oidset_parse_file(&sb->ignore_list, 
ignore_revs_file);
e7973c8519 builtin/blame.c    798) for_each_string_list_item(i, 
ignore_rev_list) {
e7973c8519 builtin/blame.c    799) if (get_oid_committish(i->string, &oid))
e7973c8519 builtin/blame.c    800) die(_("Can't find revision '%s' to 
ignore"), i->string);
e7973c8519 builtin/blame.c    801) oidset_insert(&sb->ignore_list, &oid);
e7973c8519 builtin/blame.c    803) }
acdd37769d builtin/blame.c    961) blame_date_width = sizeof("Thu Oct 19 
16:00");
acdd37769d builtin/blame.c    962) break;
e7973c8519 builtin/blame.c   1033) build_ignorelist(&sb, &ignore_rev_list);
e7973c8519 builtin/blame.c   1034) string_list_clear(&ignore_rev_list, 0);
4478671442 builtin/blame.c   1048) the_repository->index))

builtin/checkout.c
0d6caa2d08 builtin/checkout.c  751) init_merge_options(&o, the_repository);

builtin/commit.c
1d18d7581c builtin/commit.c 1689) commit_post_rewrite(the_repository, 
current_head, &oid);

builtin/config.c
a12c1ff3a5 builtin/config.c       85) die(_("only one config file at a 
time"));
a12c1ff3a5 builtin/config.c       88) die(_("--local can only be used 
inside a git repository"));
a12c1ff3a5 builtin/config.c       91) die(_("--blob can only be used 
inside a git repository"));
a12c1ff3a5 builtin/config.c       95) given_config_source.file = NULL;
a12c1ff3a5 builtin/config.c       96) given_config_source.use_stdin = 1;
a12c1ff3a5 builtin/config.c      110) die(_("$HOME not set"));
a12c1ff3a5 builtin/config.c      114) given_config_source.file = xdg_config;
a12c1ff3a5 builtin/config.c      115) free(user_config);
a12c1ff3a5 builtin/config.c      122) given_config_source.file = 
git_etc_gitconfig();
a12c1ff3a5 builtin/config.c      126) given_config_source.file = 
get_worktree_config(the_repository);
a12c1ff3a5 builtin/config.c      127) if (!given_config_source.file)
a12c1ff3a5 builtin/config.c      128) die(_("--worktree cannot be used 
with multiple "
6f11fd5edb builtin/config.c      185) static int option_move_cb(const 
struct option *opt,
6f11fd5edb builtin/config.c      188) BUG_ON_OPT_NEG(unset);
6f11fd5edb builtin/config.c      189) BUG_ON_OPT_ARG(arg);
6f11fd5edb builtin/config.c      191) set_config_source_file();
6f11fd5edb builtin/config.c      192) memcpy(&move_source, 
&given_config_source, sizeof(move_source));
6f11fd5edb builtin/config.c      194) memset(&given_config_source, 0, 
sizeof(given_config_source));
6f11fd5edb builtin/config.c      195) use_global_config = 0;
6f11fd5edb builtin/config.c      196) use_system_config = 0;
6f11fd5edb builtin/config.c      197) use_local_config = 0;
6f11fd5edb builtin/config.c      198) use_worktree_config = 0;
6f11fd5edb builtin/config.c      200) actions = opt->defval;
6f11fd5edb builtin/config.c      201) return 0;
6f11fd5edb builtin/config.c      471) static int 
collect_move_config(const char *key, const char *value, void *cb)
6f11fd5edb builtin/config.c      473) struct move_config_cb *data = cb;
6f11fd5edb builtin/config.c      475) switch (actions) {
6f11fd5edb builtin/config.c      477) if (strcasecmp(data->key, key))
6f11fd5edb builtin/config.c      478) return 0;
6f11fd5edb builtin/config.c      479) break;
6f11fd5edb builtin/config.c      481) if (regexec(&data->key_re, key, 0, 
NULL, 0))
6f11fd5edb builtin/config.c      482) return 0;
6f11fd5edb builtin/config.c      483) break;
6f11fd5edb builtin/config.c      485) if (wildmatch(data->key, key, 
WM_CASEFOLD))
6f11fd5edb builtin/config.c      486) return 0;
6f11fd5edb builtin/config.c      487) break;
6f11fd5edb builtin/config.c      492) string_list_append(&data->keys, 
key)->util = xstrdup(value);
6f11fd5edb builtin/config.c      493) return 0;
6f11fd5edb builtin/config.c      496) static int move_config(const char 
*key)
6f11fd5edb builtin/config.c      499) int i, ret = 0;
6f11fd5edb builtin/config.c      501) config_options.respect_includes = 0;
6f11fd5edb builtin/config.c      502) if (!move_source.file && 
!move_source.use_stdin && !move_source.blob)
6f11fd5edb builtin/config.c      503) die(_("unknown config source"));
6f11fd5edb builtin/config.c      505) string_list_init(&cb.keys, 1);
6f11fd5edb builtin/config.c      506) cb.key = key;
6f11fd5edb builtin/config.c      507) if (actions == ACTION_MOVE_REGEXP &&
6f11fd5edb builtin/config.c      508) regcomp(&cb.key_re, key, 
REG_EXTENDED | REG_ICASE))
6f11fd5edb builtin/config.c      509) die(_("invalid key pattern: %s"), 
key);
6f11fd5edb builtin/config.c      511) 
config_with_options(collect_move_config, &cb,
6f11fd5edb builtin/config.c      514) for (i = 0; i < cb.keys.nr && 
!ret; i++) {
6f11fd5edb builtin/config.c      515) const char *key = 
cb.keys.items[i].string;
6f11fd5edb builtin/config.c      516) const char *value = 
cb.keys.items[i].util;
6f11fd5edb builtin/config.c      517) const char *dest = 
given_config_source.file;
6f11fd5edb builtin/config.c      519) ret = 
git_config_set_multivar_in_file_gently(
6f11fd5edb builtin/config.c      527) if (!ret && move_source.file) {
6f11fd5edb builtin/config.c      528) for (i = 0; i < cb.keys.nr; i++) {
6f11fd5edb builtin/config.c      529) const char *key = 
cb.keys.items[i].string;
6f11fd5edb builtin/config.c      530) const char *src = move_source.file;
6f11fd5edb builtin/config.c      532) 
git_config_set_multivar_in_file_gently(
6f11fd5edb builtin/config.c      537) string_list_clear(&cb.keys, 1);
6f11fd5edb builtin/config.c      538) if (actions == ACTION_MOVE_REGEXP)
6f11fd5edb builtin/config.c      539) regfree(&cb.key_re);
6f11fd5edb builtin/config.c      540) return ret;
6f11fd5edb builtin/config.c      979) else if (actions == ACTION_MOVE ||
6f11fd5edb builtin/config.c      980)  actions == ACTION_MOVE_REGEXP ||
6f11fd5edb builtin/config.c      981)  actions == ACTION_MOVE_GLOB) {
6f11fd5edb builtin/config.c      982) check_write();
6f11fd5edb builtin/config.c      983) check_argc(argc, 1, 1);
6f11fd5edb builtin/config.c      984) return move_config(argv[0]);

builtin/describe.c
1b0d968b34 builtin/describe.c 638) 
repo_update_index_if_able(the_repository, &index_lock);

builtin/diff-tree.c
e1ff0a32e4 builtin/diff-tree.c 169) repo_read_index(the_repository);

builtin/grep.c
dba093ddc0 builtin/grep.c  403) static int grep_submodule(struct 
grep_opt *opt,
dba093ddc0 builtin/grep.c  409) struct repository *superproject = opt->repo;
dba093ddc0 builtin/grep.c  448) memcpy(&subopt, opt, sizeof(subopt));
b6b4172bfb builtin/grep.c  449) subopt.repo = &subrepo;
dba093ddc0 builtin/grep.c  472) hit = grep_tree(&subopt, pathspec, 
&tree, &base, base.len,
dba093ddc0 builtin/grep.c  473) object->type == OBJ_COMMIT);
dba093ddc0 builtin/grep.c  477) hit = grep_cache(&subopt, pathspec, 1);
dba093ddc0 builtin/grep.c  484) static int grep_cache(struct grep_opt *opt,
dba093ddc0 builtin/grep.c  487) struct repository *repo = opt->repo;
dba093ddc0 builtin/grep.c  525) hit |= grep_submodule(opt, pathspec, 
NULL, ce->name, ce->name);
dba093ddc0 builtin/grep.c  549) struct repository *repo = opt->repo;
b6b4172bfb builtin/grep.c  599) hit |= grep_submodule(opt, pathspec, 
&entry.oid,
dba093ddc0 builtin/grep.c  641) obj->type == OBJ_COMMIT);
dba093ddc0 builtin/grep.c  658) real_obj = deref_tag(opt->repo, 
list->objects[i].item,
dba093ddc0 builtin/grep.c  663) submodule_free(opt->repo);
dba093ddc0 builtin/grep.c  688) fill_directory(&dir, opt->repo->index, 
pathspec);
dba093ddc0 builtin/grep.c  690) if (!dir_path_match(opt->repo->index, 
dir.entries[i], pathspec, 0, NULL))
3a7a698e93 builtin/grep.c 1028) if (get_oid_with_context(the_repository, 
arg,
dba093ddc0 builtin/grep.c 1132) hit = grep_cache(&opt, &pathspec, cached);

builtin/log.c
3a7a698e93 builtin/log.c  513) if (get_oid_with_context(the_repository, 
obj_name,

builtin/merge-tree.c
4478671442 builtin/merge-tree.c  80) return 
merge_blobs(the_repository->index, path,

builtin/merge.c
08339886b9 builtin/merge.c  120) static enum parse_opt_result 
option_read_message(struct parse_opt_ctx_t *ctx,
9b4ae5190a builtin/merge.c  128) BUG_ON_OPT_ARG(arg_not_used);

builtin/notes.c
1d18d7581c builtin/notes.c  333) commit_notes(the_repository, t, msg);
1d18d7581c builtin/notes.c  336) 
finish_copy_notes_for_rewrite(the_repository, c, msg);
1d18d7581c builtin/notes.c  472) commit_notes(the_repository, t,
1d18d7581c builtin/notes.c  478) commit_notes(the_repository, t,
1d18d7581c builtin/notes.c  557) commit_notes(the_repository, t,
1d18d7581c builtin/notes.c  642) commit_notes(the_repository, t, logmsg);
1d18d7581c builtin/notes.c  943) commit_notes(the_repository, t,
1d18d7581c builtin/notes.c  972) commit_notes(the_repository, t,

builtin/pack-objects.c
3d036eb0d2 builtin/pack-objects.c 2716) sparse = git_config_bool(k, v);
3d036eb0d2 builtin/pack-objects.c 2717) return 0;

builtin/pack-redundant.c
a338d10395 builtin/pack-redundant.c 339) static int 
cmp_remaining_objects(const void *a, const void *b)
e4e2c2884e builtin/pack-redundant.c 341) struct pack_list *pl_a = 
*((struct pack_list **)a);
e4e2c2884e builtin/pack-redundant.c 342) struct pack_list *pl_b = 
*((struct pack_list **)b);
a338d10395 builtin/pack-redundant.c 344) if 
(pl_a->remaining_objects->size == pl_b->remaining_objects->size) {
a338d10395 builtin/pack-redundant.c 346) if (pl_a->all_objects_size == 
pl_b->all_objects_size)
a338d10395 builtin/pack-redundant.c 347) return 0;
a338d10395 builtin/pack-redundant.c 348) else if (pl_a->all_objects_size 
< pl_b->all_objects_size)
a338d10395 builtin/pack-redundant.c 349) return 1;
a338d10395 builtin/pack-redundant.c 351) return -1;
a338d10395 builtin/pack-redundant.c 352) } else if 
(pl_a->remaining_objects->size < pl_b->remaining_objects->size) {
e4e2c2884e builtin/pack-redundant.c 354) return 1;
e4e2c2884e builtin/pack-redundant.c 356) return -1;
e4e2c2884e builtin/pack-redundant.c 361) static void 
sort_pack_list(struct pack_list **pl)
e4e2c2884e builtin/pack-redundant.c 365) size_t n = pack_list_size(*pl);
e4e2c2884e builtin/pack-redundant.c 367) if (n < 2)
e4e2c2884e builtin/pack-redundant.c 368) return;
e4e2c2884e builtin/pack-redundant.c 371) ary = xcalloc(n, sizeof(struct 
pack_list *));
e4e2c2884e builtin/pack-redundant.c 372) for (n = 0, p = *pl; p; p = 
p->next)
e4e2c2884e builtin/pack-redundant.c 373) ary[n++] = p;
a338d10395 builtin/pack-redundant.c 375) QSORT(ary, n, 
cmp_remaining_objects);
e4e2c2884e builtin/pack-redundant.c 378) for (i = 0; i < n - 1; i++)
e4e2c2884e builtin/pack-redundant.c 379) ary[i]->next = ary[i + 1];
e4e2c2884e builtin/pack-redundant.c 380) ary[n - 1]->next = NULL;
e4e2c2884e builtin/pack-redundant.c 381) *pl = ary[0];
e4e2c2884e builtin/pack-redundant.c 383) free(ary);
e4e2c2884e builtin/pack-redundant.c 389) struct pack_list *pl, *unique = 
NULL, *non_unique = NULL;
cb7e0336fc builtin/pack-redundant.c 404) 
llist_sorted_difference_inplace(missing, pl->remaining_objects);
e4e2c2884e builtin/pack-redundant.c 408) *min = unique;
e4e2c2884e builtin/pack-redundant.c 416) unique_pack_objects = 
llist_copy(all_objects);
e4e2c2884e builtin/pack-redundant.c 417) 
llist_sorted_difference_inplace(unique_pack_objects, missing);
e4e2c2884e builtin/pack-redundant.c 420) pl = non_unique;
cb7e0336fc builtin/pack-redundant.c 422) 
llist_sorted_difference_inplace(pl->remaining_objects, unique_pack_objects);
e4e2c2884e builtin/pack-redundant.c 426) while (non_unique) {
e4e2c2884e builtin/pack-redundant.c 428) sort_pack_list(&non_unique);
cb7e0336fc builtin/pack-redundant.c 429) if 
(non_unique->remaining_objects->size == 0)
e4e2c2884e builtin/pack-redundant.c 430) break;
e4e2c2884e builtin/pack-redundant.c 432) pack_list_insert(min, non_unique);
cb7e0336fc builtin/pack-redundant.c 434) for (pl = non_unique->next; pl 
&& pl->remaining_objects->size > 0;  pl = pl->next)
cb7e0336fc builtin/pack-redundant.c 435) 
llist_sorted_difference_inplace(pl->remaining_objects, 
non_unique->remaining_objects);
e4e2c2884e builtin/pack-redundant.c 437) non_unique = non_unique->next;
cb7e0336fc builtin/pack-redundant.c 450) l = pl->remaining_objects->front;
cb7e0336fc builtin/pack-redundant.c 461) 
llist_sorted_difference_inplace(all_objects, pl->remaining_objects);
cb7e0336fc builtin/pack-redundant.c 490) 
llist_sorted_difference_inplace(all_objects, alt->remaining_objects);
cb7e0336fc builtin/pack-redundant.c 505) llist_init(&l.remaining_objects);
cb7e0336fc builtin/pack-redundant.c 514) 
llist_insert_back(l.remaining_objects, (const struct object_id *)(base + 
off));
a338d10395 builtin/pack-redundant.c 517) l.all_objects_size = 
l.remaining_objects->size;
cb7e0336fc builtin/pack-redundant.c 519) l.unique_objects = 
llist_copy(l.remaining_objects);
cb7e0336fc builtin/pack-redundant.c 615) 
llist_sorted_difference_inplace(pl->remaining_objects, ignore);

builtin/range-diff.c
26c50430dc 78) FREE_AND_NULL(options);

builtin/rebase--interactive.c
e5b1c9d929 builtin/rebase--interactive.c   17) static int 
edit_todo_file(unsigned flags)
e5b1c9d929 builtin/rebase--interactive.c   19) const char *todo_file = 
rebase_path_todo();
e5b1c9d929 builtin/rebase--interactive.c   20) struct todo_list 
todo_list = TODO_LIST_INIT,
e5b1c9d929 builtin/rebase--interactive.c   21) new_todo = TODO_LIST_INIT;
e5b1c9d929 builtin/rebase--interactive.c   23) if 
(strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
e5b1c9d929 builtin/rebase--interactive.c   24) return 
error_errno(_("could not read '%s'."), todo_file);
e5b1c9d929 builtin/rebase--interactive.c   26) 
strbuf_stripspace(&todo_list.buf, 1);
e5b1c9d929 builtin/rebase--interactive.c   27) if 
(!edit_todo_list(the_repository, &todo_list,
e5b1c9d929 builtin/rebase--interactive.c   28) &new_todo, NULL, NULL, 
flags) &&
e5b1c9d929 builtin/rebase--interactive.c   29) 
todo_list_write_to_file(the_repository, &new_todo, todo_file, NULL, NULL,
e5b1c9d929 builtin/rebase--interactive.c   31) return 
error_errno(_("could not write '%s'"), todo_file);
e5b1c9d929 builtin/rebase--interactive.c   33) 
todo_list_release(&todo_list);
e5b1c9d929 builtin/rebase--interactive.c   34) todo_list_release(&new_todo);
e5b1c9d929 builtin/rebase--interactive.c   36) return 0;
4d55dfd767 builtin/rebase--interactive.c   39) static int 
transform_todo_file(unsigned flags)
4d55dfd767 builtin/rebase--interactive.c   41) const char *todo_file = 
rebase_path_todo();
4d55dfd767 builtin/rebase--interactive.c   42) struct todo_list 
todo_list = TODO_LIST_INIT;
4d55dfd767 builtin/rebase--interactive.c   45) if 
(strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
4d55dfd767 builtin/rebase--interactive.c   46) return 
error_errno(_("could not read '%s'."), todo_file);
4d55dfd767 builtin/rebase--interactive.c   48) if 
(todo_list_parse_insn_buffer(the_repository, todo_list.buf.buf,
4d55dfd767 builtin/rebase--interactive.c   50) 
todo_list_release(&todo_list);
4d55dfd767 builtin/rebase--interactive.c   51) return error(_("unusable 
todo list: '%s'"), todo_file);
4d55dfd767 builtin/rebase--interactive.c   54) res = 
todo_list_write_to_file(the_repository, &todo_list, todo_file,
4d55dfd767 builtin/rebase--interactive.c   56) 
todo_list_release(&todo_list);
4d55dfd767 builtin/rebase--interactive.c   58) if (res)
4d55dfd767 builtin/rebase--interactive.c   59) return 
error_errno(_("could not write '%s'."), todo_file);
4d55dfd767 builtin/rebase--interactive.c   60) return 0;
0566a4f68e builtin/rebase--interactive.c  121) struct todo_list 
todo_list = TODO_LIST_INIT;
0566a4f68e builtin/rebase--interactive.c  147) ret = 
sequencer_make_script(the_repository, &todo_list.buf,
c1c074e0cc builtin/rebase--interactive.c  155) if 
(todo_list_parse_insn_buffer(the_repository, todo_list.buf.buf,
c1c074e0cc builtin/rebase--interactive.c  159) ret = 
complete_action(the_repository, opts, flags, shortrevisions, onto_name,
0566a4f68e builtin/rebase--interactive.c  165) 
todo_list_release(&todo_list);
8414c890aa builtin/rebase--interactive.c  269) if (cmd && *cmd) {
8414c890aa builtin/rebase--interactive.c  270) 
string_list_split(&commands, cmd, '\n', -1);
8414c890aa builtin/rebase--interactive.c  271) if 
(strlen(commands.items[commands.nr - 1].string) == 0)
8414c890aa builtin/rebase--interactive.c  272) --commands.nr;
e5b1c9d929 builtin/rebase--interactive.c  294) ret = edit_todo_file(flags);
4d55dfd767 builtin/rebase--interactive.c  307) ret = 
transform_todo_file(flags);
c27b32f0ec builtin/rebase--interactive.c  310) ret = 
check_todo_list_from_file(the_repository);
febebd99b6 builtin/rebase--interactive.c  313) ret = 
rearrange_squash_in_todo_file(the_repository);
8414c890aa builtin/rebase--interactive.c  316) ret = 
sequencer_add_exec_commands(the_repository, &commands);

builtin/rebase.c
b6b4172bfb  423) if (repo_read_index_unmerged(the_repository) < 0) {
e1ff0a32e4 1236) if (repo_read_index(the_repository) < 0)
1b0d968b34 1241) repo_update_index_if_able(the_repository, &lock_file);
e1ff0a32e4 1593) if (repo_read_index(the_repository) < 0)
1b0d968b34 1603) repo_update_index_if_able(the_repository, &lock_file);
e1ff0a32e4 1648) repo_read_index(the_repository) < 0)

builtin/replace.c
4478671442 builtin/replace.c 298) if (index_fd(the_repository->index, 
oid, fd, &st, type, NULL, flags) < 0)

builtin/stash.c
f6bbd78127 builtin/stash--helper.c  117) static void 
free_stash_info(struct stash_info *info)
f6bbd78127 builtin/stash--helper.c  119) strbuf_release(&info->revision);
f6bbd78127 builtin/stash--helper.c  120) }
f6bbd78127 builtin/stash--helper.c  122) static void 
assert_stash_like(struct stash_info *info, const char *revision)
f6bbd78127 builtin/stash--helper.c  124) if (get_oidf(&info->b_commit, 
"%s^1", revision) ||
f6bbd78127 builtin/stash--helper.c  125) get_oidf(&info->w_tree, "%s:", 
revision) ||
f6bbd78127 builtin/stash--helper.c  126) get_oidf(&info->b_tree, 
"%s^1:", revision) ||
f6bbd78127 builtin/stash--helper.c  127) get_oidf(&info->i_tree, 
"%s^2:", revision))
f6bbd78127 builtin/stash--helper.c  128) die(_("'%s' is not a stash-like 
commit"), revision);
f6bbd78127 builtin/stash--helper.c  129) }
f6bbd78127 builtin/stash--helper.c  131) static int 
get_stash_info(struct stash_info *info, int argc, const char **argv)
f6bbd78127 builtin/stash--helper.c  137) const char *commit = NULL;
f6bbd78127 builtin/stash--helper.c  139) struct strbuf symbolic = 
STRBUF_INIT;
f6bbd78127 builtin/stash--helper.c  141) if (argc > 1) {
f6bbd78127 builtin/stash--helper.c  143) struct strbuf refs_msg = 
STRBUF_INIT;
f6bbd78127 builtin/stash--helper.c  145) for (i = 0; i < argc; i++)
f6bbd78127 builtin/stash--helper.c  146) strbuf_addf(&refs_msg, " '%s'", 
argv[i]);
f6bbd78127 builtin/stash--helper.c  148) fprintf_ln(stderr, _("Too many 
revisions specified:%s"),
f6bbd78127 builtin/stash--helper.c  150) strbuf_release(&refs_msg);
f6bbd78127 builtin/stash--helper.c  152) return -1;
f6bbd78127 builtin/stash--helper.c  155) if (argc == 1)
f6bbd78127 builtin/stash--helper.c  156) commit = argv[0];
f6bbd78127 builtin/stash--helper.c  158) strbuf_init(&info->revision, 0);
f6bbd78127 builtin/stash--helper.c  159) if (!commit) {
f6bbd78127 builtin/stash--helper.c  160) if (!ref_exists(ref_stash)) {
f6bbd78127 builtin/stash--helper.c  161) free_stash_info(info);
f6bbd78127 builtin/stash--helper.c  162) fprintf_ln(stderr, _("No stash 
entries found."));
f6bbd78127 builtin/stash--helper.c  163) return -1;
f6bbd78127 builtin/stash--helper.c  166) strbuf_addf(&info->revision, 
"%s@{0}", ref_stash);
f6bbd78127 builtin/stash--helper.c  167) } else if (strspn(commit, 
"0123456789") == strlen(commit)) {
f6bbd78127 builtin/stash--helper.c  168) strbuf_addf(&info->revision, 
"%s@{%s}", ref_stash, commit);
f6bbd78127 builtin/stash--helper.c  170) strbuf_addstr(&info->revision, 
commit);
f6bbd78127 builtin/stash--helper.c  173) revision = info->revision.buf;
f6bbd78127 builtin/stash--helper.c  175) if (get_oid(revision, 
&info->w_commit)) {
f6bbd78127 builtin/stash--helper.c  176) error(_("%s is not a valid 
reference"), revision);
f6bbd78127 builtin/stash--helper.c  177) free_stash_info(info);
f6bbd78127 builtin/stash--helper.c  178) return -1;
f6bbd78127 builtin/stash--helper.c  181) assert_stash_like(info, revision);
f6bbd78127 builtin/stash--helper.c  183) info->has_u = 
!get_oidf(&info->u_tree, "%s^3:", revision);
f6bbd78127 builtin/stash--helper.c  185) end_of_rev = 
strchrnul(revision, '@');
f6bbd78127 builtin/stash--helper.c  186) strbuf_add(&symbolic, revision, 
end_of_rev - revision);
f6bbd78127 builtin/stash--helper.c  188) ret = dwim_ref(symbolic.buf, 
symbolic.len, &dummy, &expanded_ref);
f6bbd78127 builtin/stash--helper.c  189) strbuf_release(&symbolic);
f6bbd78127 builtin/stash--helper.c  190) switch (ret) {
f6bbd78127 builtin/stash--helper.c  192) info->is_stash_ref = 0;
f6bbd78127 builtin/stash--helper.c  193) break;
f6bbd78127 builtin/stash--helper.c  195) info->is_stash_ref = 
!strcmp(expanded_ref, ref_stash);
f6bbd78127 builtin/stash--helper.c  196) break;
f6bbd78127 builtin/stash--helper.c  198) free_stash_info(info);
f6bbd78127 builtin/stash--helper.c  201) free(expanded_ref);
f6bbd78127 builtin/stash--helper.c  202) return !(ret == 0 || ret == 1);
cdca49bc4c builtin/stash--helper.c  205) static int do_clear_stash(void)
cdca49bc4c builtin/stash--helper.c  208) if (get_oid(ref_stash, &obj))
cdca49bc4c builtin/stash--helper.c  209) return 0;
cdca49bc4c builtin/stash--helper.c  211) return delete_ref(NULL, 
ref_stash, &obj, 0);
cdca49bc4c builtin/stash--helper.c  214) static int clear_stash(int 
argc, const char **argv, const char *prefix)
cdca49bc4c builtin/stash--helper.c  216) struct option options[] = {
cdca49bc4c builtin/stash--helper.c  220) argc = parse_options(argc, 
argv, prefix, options,
cdca49bc4c builtin/stash--helper.c  224) if (argc)
cdca49bc4c builtin/stash--helper.c  225) return error(_("git stash clear 
with parameters is "
cdca49bc4c builtin/stash--helper.c  228) return do_clear_stash();
f6bbd78127 builtin/stash--helper.c  231) static int reset_tree(struct 
object_id *i_tree, int update, int reset)
f6bbd78127 builtin/stash--helper.c  233) int nr_trees = 1;
f6bbd78127 builtin/stash--helper.c  237) struct lock_file lock_file = 
LOCK_INIT;
f6bbd78127 builtin/stash--helper.c  239) read_cache_preload(NULL);
f6bbd78127 builtin/stash--helper.c  240) if (refresh_cache(REFRESH_QUIET))
f6bbd78127 builtin/stash--helper.c  241) return -1;
f6bbd78127 builtin/stash--helper.c  243) hold_locked_index(&lock_file, 
LOCK_DIE_ON_ERROR);
f6bbd78127 builtin/stash--helper.c  245) memset(&opts, 0, sizeof(opts));
f6bbd78127 builtin/stash--helper.c  247) tree = parse_tree_indirect(i_tree);
f6bbd78127 builtin/stash--helper.c  248) if (parse_tree(tree))
f6bbd78127 builtin/stash--helper.c  249) return -1;
f6bbd78127 builtin/stash--helper.c  251) init_tree_desc(t, tree->buffer, 
tree->size);
f6bbd78127 builtin/stash--helper.c  253) opts.head_idx = 1;
f6bbd78127 builtin/stash--helper.c  254) opts.src_index = &the_index;
f6bbd78127 builtin/stash--helper.c  255) opts.dst_index = &the_index;
f6bbd78127 builtin/stash--helper.c  256) opts.merge = 1;
f6bbd78127 builtin/stash--helper.c  257) opts.reset = reset;
f6bbd78127 builtin/stash--helper.c  258) opts.update = update;
f6bbd78127 builtin/stash--helper.c  259) opts.fn = oneway_merge;
f6bbd78127 builtin/stash--helper.c  261) if (unpack_trees(nr_trees, t, 
&opts))
f6bbd78127 builtin/stash--helper.c  262) return -1;
f6bbd78127 builtin/stash--helper.c  264) if 
(write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
f6bbd78127 builtin/stash--helper.c  265) return error(_("unable to write 
new index file"));
f6bbd78127 builtin/stash--helper.c  267) return 0;
f6bbd78127 builtin/stash--helper.c  270) static int 
diff_tree_binary(struct strbuf *out, struct object_id *w_commit)
f6bbd78127 builtin/stash--helper.c  272) struct child_process cp = 
CHILD_PROCESS_INIT;
f6bbd78127 builtin/stash--helper.c  273) const char *w_commit_hex = 
oid_to_hex(w_commit);
f6bbd78127 builtin/stash--helper.c  279) cp.git_cmd = 1;
f6bbd78127 builtin/stash--helper.c  280) argv_array_pushl(&cp.args, 
"diff-tree", "--binary", NULL);
f6bbd78127 builtin/stash--helper.c  281) argv_array_pushf(&cp.args, 
"%s^2^..%s^2", w_commit_hex, w_commit_hex);
f6bbd78127 builtin/stash--helper.c  283) return pipe_command(&cp, NULL, 
0, out, 0, NULL, 0);
f6bbd78127 builtin/stash--helper.c  286) static int apply_cached(struct 
strbuf *out)
f6bbd78127 builtin/stash--helper.c  288) struct child_process cp = 
CHILD_PROCESS_INIT;
f6bbd78127 builtin/stash--helper.c  295) cp.git_cmd = 1;
f6bbd78127 builtin/stash--helper.c  296) argv_array_pushl(&cp.args, 
"apply", "--cached", NULL);
f6bbd78127 builtin/stash--helper.c  297) return pipe_command(&cp, 
out->buf, out->len, NULL, 0, NULL, 0);
f6bbd78127 builtin/stash--helper.c  300) static int reset_head(void)
f6bbd78127 builtin/stash--helper.c  302) struct child_process cp = 
CHILD_PROCESS_INIT;
f6bbd78127 builtin/stash--helper.c  308) cp.git_cmd = 1;
f6bbd78127 builtin/stash--helper.c  309) argv_array_push(&cp.args, "reset");
f6bbd78127 builtin/stash--helper.c  311) return run_command(&cp);
1f5a011d90 builtin/stash--helper.c  314) static void 
add_diff_to_buf(struct diff_queue_struct *q,
1f5a011d90 builtin/stash--helper.c  320) for (i = 0; i < q->nr; i++) {
1f5a011d90 builtin/stash--helper.c  321) strbuf_addstr(data, 
q->queue[i]->one->path);
1f5a011d90 builtin/stash--helper.c  328) strbuf_addch(data, '\0');
1f5a011d90 builtin/stash--helper.c  330) }
f6bbd78127 builtin/stash--helper.c  332) static int 
get_newly_staged(struct strbuf *out, struct object_id *c_tree)
f6bbd78127 builtin/stash--helper.c  334) struct child_process cp = 
CHILD_PROCESS_INIT;
f6bbd78127 builtin/stash--helper.c  335) const char *c_tree_hex = 
oid_to_hex(c_tree);
f6bbd78127 builtin/stash--helper.c  341) cp.git_cmd = 1;
f6bbd78127 builtin/stash--helper.c  342) argv_array_pushl(&cp.args, 
"diff-index", "--cached", "--name-only",
f6bbd78127 builtin/stash--helper.c  344) argv_array_push(&cp.args, 
c_tree_hex);
f6bbd78127 builtin/stash--helper.c  345) return pipe_command(&cp, NULL, 
0, out, 0, NULL, 0);
f6bbd78127 builtin/stash--helper.c  348) static int update_index(struct 
strbuf *out)
f6bbd78127 builtin/stash--helper.c  350) struct child_process cp = 
CHILD_PROCESS_INIT;
f6bbd78127 builtin/stash--helper.c  356) cp.git_cmd = 1;
f6bbd78127 builtin/stash--helper.c  357) argv_array_pushl(&cp.args, 
"update-index", "--add", "--stdin", NULL);
f6bbd78127 builtin/stash--helper.c  358) return pipe_command(&cp, 
out->buf, out->len, NULL, 0, NULL, 0);
f6bbd78127 builtin/stash--helper.c  361) static int 
restore_untracked(struct object_id *u_tree)
f6bbd78127 builtin/stash--helper.c  364) struct child_process cp = 
CHILD_PROCESS_INIT;
f6bbd78127 builtin/stash--helper.c  371) cp.git_cmd = 1;
f6bbd78127 builtin/stash--helper.c  372) argv_array_push(&cp.args, 
"read-tree");
f6bbd78127 builtin/stash--helper.c  373) argv_array_push(&cp.args, 
oid_to_hex(u_tree));
f6bbd78127 builtin/stash--helper.c  374) argv_array_pushf(&cp.env_array, 
"GIT_INDEX_FILE=%s",
f6bbd78127 builtin/stash--helper.c  376) if (run_command(&cp)) {
f6bbd78127 builtin/stash--helper.c  377) remove_path(stash_index_path.buf);
f6bbd78127 builtin/stash--helper.c  378) return -1;
f6bbd78127 builtin/stash--helper.c  381) child_process_init(&cp);
f6bbd78127 builtin/stash--helper.c  382) cp.git_cmd = 1;
f6bbd78127 builtin/stash--helper.c  383) argv_array_pushl(&cp.args, 
"checkout-index", "--all", NULL);
f6bbd78127 builtin/stash--helper.c  384) argv_array_pushf(&cp.env_array, 
"GIT_INDEX_FILE=%s",
f6bbd78127 builtin/stash--helper.c  387) res = run_command(&cp);
f6bbd78127 builtin/stash--helper.c  388) remove_path(stash_index_path.buf);
f6bbd78127 builtin/stash--helper.c  389) return res;
f6bbd78127 builtin/stash--helper.c  392) static int do_apply_stash(const 
char *prefix, struct stash_info *info,
f6bbd78127 builtin/stash--helper.c  396) int has_index = index;
f6bbd78127 builtin/stash--helper.c  403) read_cache_preload(NULL);
f6bbd78127 builtin/stash--helper.c  404) if (refresh_cache(REFRESH_QUIET))
f6bbd78127 builtin/stash--helper.c  405) return -1;
f6bbd78127 builtin/stash--helper.c  407) if 
(write_cache_as_tree(&c_tree, 0, NULL) || reset_tree(&c_tree, 0, 0))
f6bbd78127 builtin/stash--helper.c  408) return error(_("cannot apply a 
stash in the middle of a merge"));
f6bbd78127 builtin/stash--helper.c  410) if (index) {
f6bbd78127 builtin/stash--helper.c  411) if (oideq(&info->b_tree, 
&info->i_tree) ||
f6bbd78127 builtin/stash--helper.c  412)     oideq(&c_tree, 
&info->i_tree)) {
f6bbd78127 builtin/stash--helper.c  413) has_index = 0;
f6bbd78127 builtin/stash--helper.c  415) struct strbuf out = STRBUF_INIT;
f6bbd78127 builtin/stash--helper.c  417) if (diff_tree_binary(&out, 
&info->w_commit)) {
f6bbd78127 builtin/stash--helper.c  418) strbuf_release(&out);
f6bbd78127 builtin/stash--helper.c  419) return error(_("could not 
generate diff %s^!."),
f6bbd78127 builtin/stash--helper.c  423) ret = apply_cached(&out);
f6bbd78127 builtin/stash--helper.c  424) strbuf_release(&out);
f6bbd78127 builtin/stash--helper.c  425) if (ret)
f6bbd78127 builtin/stash--helper.c  426) return error(_("conflicts in 
index."
f6bbd78127 builtin/stash--helper.c  429) discard_cache();
f6bbd78127 builtin/stash--helper.c  430) read_cache();
f6bbd78127 builtin/stash--helper.c  431) if 
(write_cache_as_tree(&index_tree, 0, NULL))
f6bbd78127 builtin/stash--helper.c  432) return error(_("could not save 
index tree"));
f6bbd78127 builtin/stash--helper.c  434) reset_head();
f6bbd78127 builtin/stash--helper.c  438) if (info->has_u && 
restore_untracked(&info->u_tree))
f6bbd78127 builtin/stash--helper.c  439) return error(_("could not 
restore untracked files from stash"));
b6b4172bfb builtin/stash.c          441) init_merge_options(&o, 
the_repository);
f6bbd78127 builtin/stash--helper.c  443) o.branch1 = "Updated upstream";
f6bbd78127 builtin/stash--helper.c  444) o.branch2 = "Stashed changes";
f6bbd78127 builtin/stash--helper.c  446) if (oideq(&info->b_tree, &c_tree))
f6bbd78127 builtin/stash--helper.c  447) o.branch1 = "Version stash was 
based on";
f6bbd78127 builtin/stash--helper.c  449) if (quiet)
f6bbd78127 builtin/stash--helper.c  450) o.verbosity = 0;
f6bbd78127 builtin/stash--helper.c  452) if (o.verbosity >= 3)
f6bbd78127 builtin/stash--helper.c  453) printf_ln(_("Merging %s with 
%s"), o.branch1, o.branch2);
f6bbd78127 builtin/stash--helper.c  455) bases[0] = &info->b_tree;
f6bbd78127 builtin/stash--helper.c  457) ret = 
merge_recursive_generic(&o, &c_tree, &info->w_tree, 1, bases,
f6bbd78127 builtin/stash--helper.c  459) if (ret) {
f6bbd78127 builtin/stash--helper.c  460) rerere(0);
f6bbd78127 builtin/stash--helper.c  462) if (index)
f6bbd78127 builtin/stash--helper.c  463) fprintf_ln(stderr, _("Index was 
not unstashed."));
f6bbd78127 builtin/stash--helper.c  465) return ret;
f6bbd78127 builtin/stash--helper.c  468) if (has_index) {
f6bbd78127 builtin/stash--helper.c  469) if (reset_tree(&index_tree, 0, 0))
f6bbd78127 builtin/stash--helper.c  470) return -1;
f6bbd78127 builtin/stash--helper.c  472) struct strbuf out = STRBUF_INIT;
f6bbd78127 builtin/stash--helper.c  474) if (get_newly_staged(&out, 
&c_tree)) {
f6bbd78127 builtin/stash--helper.c  475) strbuf_release(&out);
f6bbd78127 builtin/stash--helper.c  476) return -1;
f6bbd78127 builtin/stash--helper.c  479) if (reset_tree(&c_tree, 0, 1)) {
f6bbd78127 builtin/stash--helper.c  480) strbuf_release(&out);
f6bbd78127 builtin/stash--helper.c  481) return -1;
f6bbd78127 builtin/stash--helper.c  484) ret = update_index(&out);
f6bbd78127 builtin/stash--helper.c  485) strbuf_release(&out);
f6bbd78127 builtin/stash--helper.c  486) if (ret)
f6bbd78127 builtin/stash--helper.c  487) return -1;
f6bbd78127 builtin/stash--helper.c  489) discard_cache();
f6bbd78127 builtin/stash--helper.c  492) if (quiet) {
f6bbd78127 builtin/stash--helper.c  493) if (refresh_cache(REFRESH_QUIET))
f6bbd78127 builtin/stash--helper.c  494) warning("could not refresh index");
f6bbd78127 builtin/stash--helper.c  496) struct child_process cp = 
CHILD_PROCESS_INIT;
f6bbd78127 builtin/stash--helper.c  503) cp.git_cmd = 1;
f6bbd78127 builtin/stash--helper.c  504) cp.dir = prefix;
f6bbd78127 builtin/stash--helper.c  505) argv_array_push(&cp.args, 
"status");
f6bbd78127 builtin/stash--helper.c  506) run_command(&cp);
f6bbd78127 builtin/stash--helper.c  509) return 0;
f6bbd78127 builtin/stash--helper.c  512) static int apply_stash(int 
argc, const char **argv, const char *prefix)
f6bbd78127 builtin/stash--helper.c  515) int quiet = 0;
f6bbd78127 builtin/stash--helper.c  516) int index = 0;
f6bbd78127 builtin/stash--helper.c  518) struct option options[] = {
f6bbd78127 builtin/stash--helper.c  525) argc = parse_options(argc, 
argv, prefix, options,
f6bbd78127 builtin/stash--helper.c  528) if (get_stash_info(&info, argc, 
argv))
f6bbd78127 builtin/stash--helper.c  529) return -1;
f6bbd78127 builtin/stash--helper.c  531) ret = do_apply_stash(prefix, 
&info, index, quiet);
f6bbd78127 builtin/stash--helper.c  532) free_stash_info(&info);
f6bbd78127 builtin/stash--helper.c  533) return ret;
cdca49bc4c builtin/stash--helper.c  536) static int do_drop_stash(const 
char *prefix, struct stash_info *info, int quiet)
cdca49bc4c builtin/stash--helper.c  539) struct child_process cp_reflog 
= CHILD_PROCESS_INIT;
cdca49bc4c builtin/stash--helper.c  540) struct child_process cp = 
CHILD_PROCESS_INIT;
cdca49bc4c builtin/stash--helper.c  547) cp_reflog.git_cmd = 1;
cdca49bc4c builtin/stash--helper.c  548) 
argv_array_pushl(&cp_reflog.args, "reflog", "delete", "--updateref",
cdca49bc4c builtin/stash--helper.c  550) 
argv_array_push(&cp_reflog.args, info->revision.buf);
cdca49bc4c builtin/stash--helper.c  551) ret = run_command(&cp_reflog);
cdca49bc4c builtin/stash--helper.c  552) if (!ret) {
cdca49bc4c builtin/stash--helper.c  553) if (!quiet)
cdca49bc4c builtin/stash--helper.c  554) printf_ln(_("Dropped %s (%s)"), 
info->revision.buf,
cdca49bc4c builtin/stash--helper.c  555) oid_to_hex(&info->w_commit));
cdca49bc4c builtin/stash--helper.c  557) return error(_("%s: Could not 
drop stash entry"),
cdca49bc4c builtin/stash--helper.c  565) cp.git_cmd = 1;
cdca49bc4c builtin/stash--helper.c  567) cp.no_stdout = 1;
cdca49bc4c builtin/stash--helper.c  568) argv_array_pushl(&cp.args, 
"rev-parse", "--verify", "--quiet", NULL);
cdca49bc4c builtin/stash--helper.c  569) argv_array_pushf(&cp.args, 
"%s@{0}", ref_stash);
cdca49bc4c builtin/stash--helper.c  570) ret = run_command(&cp);
cdca49bc4c builtin/stash--helper.c  573) if (ret)
cdca49bc4c builtin/stash--helper.c  574) do_clear_stash();
cdca49bc4c builtin/stash--helper.c  576) return 0;
cdca49bc4c builtin/stash--helper.c  579) static void 
assert_stash_ref(struct stash_info *info)
cdca49bc4c builtin/stash--helper.c  581) if (!info->is_stash_ref) {
cdca49bc4c builtin/stash--helper.c  582) free_stash_info(info);
cdca49bc4c builtin/stash--helper.c  583) error(_("'%s' is not a stash 
reference"), info->revision.buf);
cdca49bc4c builtin/stash--helper.c  584) exit(128);
cdca49bc4c builtin/stash--helper.c  586) }
cdca49bc4c builtin/stash--helper.c  588) static int drop_stash(int argc, 
const char **argv, const char *prefix)
cdca49bc4c builtin/stash--helper.c  591) int quiet = 0;
cdca49bc4c builtin/stash--helper.c  593) struct option options[] = {
cdca49bc4c builtin/stash--helper.c  598) argc = parse_options(argc, 
argv, prefix, options,
cdca49bc4c builtin/stash--helper.c  601) if (get_stash_info(&info, argc, 
argv))
cdca49bc4c builtin/stash--helper.c  602) return -1;
cdca49bc4c builtin/stash--helper.c  604) assert_stash_ref(&info);
cdca49bc4c builtin/stash--helper.c  606) ret = do_drop_stash(prefix, 
&info, quiet);
cdca49bc4c builtin/stash--helper.c  607) free_stash_info(&info);
cdca49bc4c builtin/stash--helper.c  608) return ret;
e1d01876a4 builtin/stash--helper.c  611) static int pop_stash(int argc, 
const char **argv, const char *prefix)
e1d01876a4 builtin/stash--helper.c  614) int index = 0;
e1d01876a4 builtin/stash--helper.c  615) int quiet = 0;
e1d01876a4 builtin/stash--helper.c  617) struct option options[] = {
e1d01876a4 builtin/stash--helper.c  624) argc = parse_options(argc, 
argv, prefix, options,
e1d01876a4 builtin/stash--helper.c  627) if (get_stash_info(&info, argc, 
argv))
e1d01876a4 builtin/stash--helper.c  628) return -1;
e1d01876a4 builtin/stash--helper.c  630) assert_stash_ref(&info);
e1d01876a4 builtin/stash--helper.c  631) if ((ret = 
do_apply_stash(prefix, &info, index, quiet)))
e1d01876a4 builtin/stash--helper.c  632) printf_ln(_("The stash entry is 
kept in case "
e1d01876a4 builtin/stash--helper.c  635) ret = do_drop_stash(prefix, 
&info, quiet);
e1d01876a4 builtin/stash--helper.c  637) free_stash_info(&info);
e1d01876a4 builtin/stash--helper.c  638) return ret;
f596f3366c builtin/stash--helper.c  641) static int branch_stash(int 
argc, const char **argv, const char *prefix)
f596f3366c builtin/stash--helper.c  644) const char *branch = NULL;
f596f3366c builtin/stash--helper.c  646) struct child_process cp = 
CHILD_PROCESS_INIT;
f596f3366c builtin/stash--helper.c  647) struct option options[] = {
f596f3366c builtin/stash--helper.c  651) argc = parse_options(argc, 
argv, prefix, options,
f596f3366c builtin/stash--helper.c  654) if (!argc) {
f596f3366c builtin/stash--helper.c  655) fprintf_ln(stderr, _("No branch 
name specified"));
f596f3366c builtin/stash--helper.c  656) return -1;
f596f3366c builtin/stash--helper.c  659) branch = argv[0];
f596f3366c builtin/stash--helper.c  661) if (get_stash_info(&info, argc 
- 1, argv + 1))
f596f3366c builtin/stash--helper.c  662) return -1;
f596f3366c builtin/stash--helper.c  664) cp.git_cmd = 1;
f596f3366c builtin/stash--helper.c  665) argv_array_pushl(&cp.args, 
"checkout", "-b", NULL);
f596f3366c builtin/stash--helper.c  666) argv_array_push(&cp.args, branch);
f596f3366c builtin/stash--helper.c  667) argv_array_push(&cp.args, 
oid_to_hex(&info.b_commit));
f596f3366c builtin/stash--helper.c  668) ret = run_command(&cp);
f596f3366c builtin/stash--helper.c  669) if (!ret)
f596f3366c builtin/stash--helper.c  670) ret = do_apply_stash(prefix, 
&info, 1, 0);
f596f3366c builtin/stash--helper.c  671) if (!ret && info.is_stash_ref)
f596f3366c builtin/stash--helper.c  672) ret = do_drop_stash(prefix, 
&info, 0);
f596f3366c builtin/stash--helper.c  674) free_stash_info(&info);
f596f3366c builtin/stash--helper.c  676) return ret;
9b77b07ba4 builtin/stash--helper.c  679) static int list_stash(int argc, 
const char **argv, const char *prefix)
9b77b07ba4 builtin/stash--helper.c  681) struct child_process cp = 
CHILD_PROCESS_INIT;
9b77b07ba4 builtin/stash--helper.c  682) struct option options[] = {
9b77b07ba4 builtin/stash--helper.c  686) argc = parse_options(argc, 
argv, prefix, options,
9b77b07ba4 builtin/stash--helper.c  690) if (!ref_exists(ref_stash))
9b77b07ba4 builtin/stash--helper.c  691) return 0;
9b77b07ba4 builtin/stash--helper.c  693) cp.git_cmd = 1;
9b77b07ba4 builtin/stash--helper.c  694) argv_array_pushl(&cp.args, 
"log", "--format=%gd: %gs", "-g",
9b77b07ba4 builtin/stash--helper.c  696) argv_array_pushv(&cp.args, argv);
9b77b07ba4 builtin/stash--helper.c  697) argv_array_push(&cp.args, 
ref_stash);
9b77b07ba4 builtin/stash--helper.c  698) argv_array_push(&cp.args, "--");
9b77b07ba4 builtin/stash--helper.c  699) return run_command(&cp);
b4493f269e builtin/stash--helper.c  705) static int 
git_stash_config(const char *var, const char *value, void *cb)
b4493f269e builtin/stash--helper.c  707) if (!strcmp(var, 
"stash.showstat")) {
b4493f269e builtin/stash--helper.c  708) show_stat = 
git_config_bool(var, value);
b4493f269e builtin/stash--helper.c  709) return 0;
b4493f269e builtin/stash--helper.c  711) if (!strcmp(var, 
"stash.showpatch")) {
b4493f269e builtin/stash--helper.c  712) show_patch = 
git_config_bool(var, value);
b4493f269e builtin/stash--helper.c  713) return 0;
b4493f269e builtin/stash--helper.c  715) return git_default_config(var, 
value, cb);
b4493f269e builtin/stash--helper.c  718) static int show_stash(int argc, 
const char **argv, const char *prefix)
b4493f269e builtin/stash--helper.c  721) int opts = 0;
b4493f269e builtin/stash--helper.c  722) int ret = 0;
b4493f269e builtin/stash--helper.c  725) struct argv_array stash_args = 
ARGV_ARRAY_INIT;
b4493f269e builtin/stash--helper.c  726) struct option options[] = {
b4493f269e builtin/stash--helper.c  730) init_diff_ui_defaults();
b4493f269e builtin/stash--helper.c  731) git_config(git_diff_ui_config, 
NULL);
b4493f269e builtin/stash--helper.c  732) init_revisions(&rev, prefix);
b4493f269e builtin/stash--helper.c  734) for (i = 1; i < argc; i++) {
b4493f269e builtin/stash--helper.c  735) if (argv[i][0] != '-')
b4493f269e builtin/stash--helper.c  736) argv_array_push(&stash_args, 
argv[i]);
b4493f269e builtin/stash--helper.c  738) opts++;
b4493f269e builtin/stash--helper.c  741) ret = get_stash_info(&info, 
stash_args.argc, stash_args.argv);
b4493f269e builtin/stash--helper.c  742) argv_array_clear(&stash_args);
b4493f269e builtin/stash--helper.c  743) if (ret)
b4493f269e builtin/stash--helper.c  744) return -1;
b4493f269e builtin/stash--helper.c  750) if (!opts) {
b4493f269e builtin/stash--helper.c  751) git_config(git_stash_config, NULL);
b4493f269e builtin/stash--helper.c  752) if (show_stat)
b4493f269e builtin/stash--helper.c  753) rev.diffopt.output_format = 
DIFF_FORMAT_DIFFSTAT;
b4493f269e builtin/stash--helper.c  755) if (show_patch)
b4493f269e builtin/stash--helper.c  756) rev.diffopt.output_format |= 
DIFF_FORMAT_PATCH;
b4493f269e builtin/stash--helper.c  758) if (!show_stat && !show_patch) {
b4493f269e builtin/stash--helper.c  759) free_stash_info(&info);
b4493f269e builtin/stash--helper.c  760) return 0;
b4493f269e builtin/stash--helper.c  764) argc = setup_revisions(argc, 
argv, &rev, NULL);
b4493f269e builtin/stash--helper.c  765) if (argc > 1) {
b4493f269e builtin/stash--helper.c  766) free_stash_info(&info);
51809c70ca builtin/stash.c          767) 
usage_with_options(git_stash_show_usage, options);
b4493f269e builtin/stash--helper.c  770) rev.diffopt.flags.recursive = 1;
b4493f269e builtin/stash--helper.c  771) setup_diff_pager(&rev.diffopt);
b4493f269e builtin/stash--helper.c  772) diff_tree_oid(&info.b_commit, 
&info.w_commit, "", &rev.diffopt);
b4493f269e builtin/stash--helper.c  773) log_tree_diff_flush(&rev);
b4493f269e builtin/stash--helper.c  775) free_stash_info(&info);
b4493f269e builtin/stash--helper.c  776) return 
diff_result_code(&rev.diffopt, 0);
847eb0b0a8 builtin/stash--helper.c  779) static int do_store_stash(const 
struct object_id *w_commit, const char *stash_msg,
847eb0b0a8 builtin/stash--helper.c  782) if (!stash_msg)
847eb0b0a8 builtin/stash--helper.c  783) stash_msg = "Created via \"git 
stash store\".";
847eb0b0a8 builtin/stash--helper.c  785) if (update_ref(stash_msg, 
ref_stash, w_commit, NULL,
847eb0b0a8 builtin/stash--helper.c  789) if (!quiet) {
847eb0b0a8 builtin/stash--helper.c  790) fprintf_ln(stderr, _("Cannot 
update %s with %s"),
847eb0b0a8 builtin/stash--helper.c  793) return -1;
847eb0b0a8 builtin/stash--helper.c  796) return 0;
847eb0b0a8 builtin/stash--helper.c  799) static int store_stash(int 
argc, const char **argv, const char *prefix)
847eb0b0a8 builtin/stash--helper.c  801) int quiet = 0;
847eb0b0a8 builtin/stash--helper.c  802) const char *stash_msg = NULL;
847eb0b0a8 builtin/stash--helper.c  805) struct option options[] = {
847eb0b0a8 builtin/stash--helper.c  812) argc = parse_options(argc, 
argv, prefix, options,
847eb0b0a8 builtin/stash--helper.c  816) if (argc != 1) {
847eb0b0a8 builtin/stash--helper.c  817) if (!quiet)
847eb0b0a8 builtin/stash--helper.c  818) fprintf_ln(stderr, _("\"git 
stash store\" requires one "
847eb0b0a8 builtin/stash--helper.c  820) return -1;
b6b4172bfb builtin/stash.c          823) if 
(get_oid_with_context(the_repository,
847eb0b0a8 builtin/stash--helper.c  826) if (!quiet)
847eb0b0a8 builtin/stash--helper.c  827) fprintf_ln(stderr, _("Cannot 
update %s with %s"),
847eb0b0a8 builtin/stash--helper.c  829) return -1;
847eb0b0a8 builtin/stash--helper.c  832) return do_store_stash(&obj, 
stash_msg, quiet);
1f5a011d90 builtin/stash--helper.c  835) static void 
add_pathspecs(struct argv_array *args,
1f5a011d90 builtin/stash--helper.c  839) for (i = 0; i < ps.nr; i++)
1f5a011d90 builtin/stash--helper.c  840) argv_array_push(args, 
ps.items[i].match);
1f5a011d90 builtin/stash--helper.c  841) }
1f5a011d90 builtin/stash--helper.c  850) static int 
get_untracked_files(struct pathspec ps, int include_untracked,
1f5a011d90 builtin/stash--helper.c  855) int found = 0;
1f5a011d90 builtin/stash--helper.c  859) memset(&dir, 0, sizeof(dir));
1f5a011d90 builtin/stash--helper.c  860) if (include_untracked != 
INCLUDE_ALL_FILES)
1f5a011d90 builtin/stash--helper.c  861) setup_standard_excludes(&dir);
1f5a011d90 builtin/stash--helper.c  863) seen = xcalloc(ps.nr, 1);
1f5a011d90 builtin/stash--helper.c  865) max_len = fill_directory(&dir, 
the_repository->index, &ps);
1f5a011d90 builtin/stash--helper.c  866) for (i = 0; i < dir.nr; i++) {
1f5a011d90 builtin/stash--helper.c  867) struct dir_entry *ent = 
dir.entries[i];
1f5a011d90 builtin/stash--helper.c  868) if (dir_path_match(&the_index, 
ent, &ps, max_len, seen)) {
1f5a011d90 builtin/stash--helper.c  869) found++;
1f5a011d90 builtin/stash--helper.c  870) strbuf_addstr(untracked_files, 
ent->name);
1f5a011d90 builtin/stash--helper.c  872) strbuf_addch(untracked_files, 0);
1f5a011d90 builtin/stash--helper.c  874) free(ent);
1f5a011d90 builtin/stash--helper.c  877) free(seen);
1f5a011d90 builtin/stash--helper.c  878) free(dir.entries);
1f5a011d90 builtin/stash--helper.c  879) free(dir.ignored);
1f5a011d90 builtin/stash--helper.c  880) clear_directory(&dir);
1f5a011d90 builtin/stash--helper.c  881) return found;
168e6cff5e builtin/stash--helper.c  892) static int 
check_changes_tracked_files(struct pathspec ps)
1f5a011d90 builtin/stash--helper.c  899) if (get_oid("HEAD", &dummy))
1f5a011d90 builtin/stash--helper.c  900) return -1;
1f5a011d90 builtin/stash--helper.c  902) if (read_cache() < 0)
1f5a011d90 builtin/stash--helper.c  903) return -1;
1f5a011d90 builtin/stash--helper.c  905) init_revisions(&rev, NULL);
1f5a011d90 builtin/stash--helper.c  906) rev.prune_data = ps;
1f5a011d90 builtin/stash--helper.c  908) rev.diffopt.flags.quick = 1;
1f5a011d90 builtin/stash--helper.c  909) 
rev.diffopt.flags.ignore_submodules = 1;
1f5a011d90 builtin/stash--helper.c  910) rev.abbrev = 0;
1f5a011d90 builtin/stash--helper.c  912) add_head_to_pending(&rev);
1f5a011d90 builtin/stash--helper.c  913) diff_setup_done(&rev.diffopt);
1f5a011d90 builtin/stash--helper.c  915) result = run_diff_index(&rev, 1);
1f5a011d90 builtin/stash--helper.c  916) if 
(diff_result_code(&rev.diffopt, result))
1f5a011d90 builtin/stash--helper.c  917) return 1;
1f5a011d90 builtin/stash--helper.c  919) object_array_clear(&rev.pending);
1f5a011d90 builtin/stash--helper.c  920) result = run_diff_files(&rev, 0);
1f5a011d90 builtin/stash--helper.c  921) if 
(diff_result_code(&rev.diffopt, result))
1f5a011d90 builtin/stash--helper.c  922) return 1;
168e6cff5e builtin/stash--helper.c  924) return 0;
168e6cff5e builtin/stash--helper.c  932) static int check_changes(struct 
pathspec ps, int include_untracked,
168e6cff5e builtin/stash--helper.c  935) int ret = 0;
168e6cff5e builtin/stash--helper.c  936) if 
(check_changes_tracked_files(ps))
168e6cff5e builtin/stash--helper.c  937) ret = 1;
1f5a011d90 builtin/stash--helper.c  939) if (include_untracked && 
get_untracked_files(ps, include_untracked,
168e6cff5e builtin/stash--helper.c  941) ret = 1;
168e6cff5e builtin/stash--helper.c  943) return ret;
1f5a011d90 builtin/stash--helper.c  946) static int 
save_untracked_files(struct stash_info *info, struct strbuf *msg,
1f5a011d90 builtin/stash--helper.c  949) int ret = 0;
1f5a011d90 builtin/stash--helper.c  950) struct strbuf untracked_msg = 
STRBUF_INIT;
1f5a011d90 builtin/stash--helper.c  951) struct child_process 
cp_upd_index = CHILD_PROCESS_INIT;
559edead8f builtin/stash--helper.c  952) struct index_state istate = { 
NULL };
1f5a011d90 builtin/stash--helper.c  954) cp_upd_index.git_cmd = 1;
1f5a011d90 builtin/stash--helper.c  955) 
argv_array_pushl(&cp_upd_index.args, "update-index", "-z", "--add",
1f5a011d90 builtin/stash--helper.c  957) 
argv_array_pushf(&cp_upd_index.env_array, "GIT_INDEX_FILE=%s",
1f5a011d90 builtin/stash--helper.c  960) strbuf_addf(&untracked_msg, 
"untracked files on %s\n", msg->buf);
1f5a011d90 builtin/stash--helper.c  961) if (pipe_command(&cp_upd_index, 
files.buf, files.len, NULL, 0,
1f5a011d90 builtin/stash--helper.c  963) ret = -1;
1f5a011d90 builtin/stash--helper.c  964) goto done;
559edead8f builtin/stash--helper.c  967) if 
(write_index_as_tree(&info->u_tree, &istate, stash_index_path.buf, 0,
1f5a011d90 builtin/stash--helper.c  969) ret = -1;
1f5a011d90 builtin/stash--helper.c  970) goto done;
1f5a011d90 builtin/stash--helper.c  973) if 
(commit_tree(untracked_msg.buf, untracked_msg.len,
1f5a011d90 builtin/stash--helper.c  974) &info->u_tree, NULL, 
&info->u_commit, NULL, NULL)) {
1f5a011d90 builtin/stash--helper.c  975) ret = -1;
1f5a011d90 builtin/stash--helper.c  976) goto done;
559edead8f builtin/stash--helper.c  980) discard_index(&istate);
1f5a011d90 builtin/stash--helper.c  981) strbuf_release(&untracked_msg);
1f5a011d90 builtin/stash--helper.c  982) remove_path(stash_index_path.buf);
1f5a011d90 builtin/stash--helper.c  983) return ret;
1f5a011d90 builtin/stash--helper.c  986) static int stash_patch(struct 
stash_info *info, struct pathspec ps,
1f5a011d90 builtin/stash--helper.c  989) int ret = 0;
1f5a011d90 builtin/stash--helper.c  990) struct child_process 
cp_read_tree = CHILD_PROCESS_INIT;
1f5a011d90 builtin/stash--helper.c  991) struct child_process cp_add_i = 
CHILD_PROCESS_INIT;
1f5a011d90 builtin/stash--helper.c  992) struct child_process 
cp_diff_tree = CHILD_PROCESS_INIT;
559edead8f builtin/stash--helper.c  993) struct index_state istate = { 
NULL };
1f5a011d90 builtin/stash--helper.c  995) remove_path(stash_index_path.buf);
1f5a011d90 builtin/stash--helper.c  997) cp_read_tree.git_cmd = 1;
1f5a011d90 builtin/stash--helper.c  998) 
argv_array_pushl(&cp_read_tree.args, "read-tree", "HEAD", NULL);
1f5a011d90 builtin/stash--helper.c  999) 
argv_array_pushf(&cp_read_tree.env_array, "GIT_INDEX_FILE=%s",
1f5a011d90 builtin/stash--helper.c 1001) if (run_command(&cp_read_tree)) {
1f5a011d90 builtin/stash--helper.c 1002) ret = -1;
1f5a011d90 builtin/stash--helper.c 1003) goto done;
1f5a011d90 builtin/stash--helper.c 1007) cp_add_i.git_cmd = 1;
1f5a011d90 builtin/stash--helper.c 1008) 
argv_array_pushl(&cp_add_i.args, "add--interactive", "--patch=stash",
1f5a011d90 builtin/stash--helper.c 1010) add_pathspecs(&cp_add_i.args, ps);
1f5a011d90 builtin/stash--helper.c 1011) 
argv_array_pushf(&cp_add_i.env_array, "GIT_INDEX_FILE=%s",
1f5a011d90 builtin/stash--helper.c 1013) if (run_command(&cp_add_i)) {
1f5a011d90 builtin/stash--helper.c 1014) ret = -1;
1f5a011d90 builtin/stash--helper.c 1015) goto done;
559edead8f builtin/stash--helper.c 1019) if 
(write_index_as_tree(&info->w_tree, &istate, stash_index_path.buf, 0,
1f5a011d90 builtin/stash--helper.c 1021) ret = -1;
1f5a011d90 builtin/stash--helper.c 1022) goto done;
1f5a011d90 builtin/stash--helper.c 1025) cp_diff_tree.git_cmd = 1;
1f5a011d90 builtin/stash--helper.c 1026) 
argv_array_pushl(&cp_diff_tree.args, "diff-tree", "-p", "HEAD",
1f5a011d90 builtin/stash--helper.c 1027) oid_to_hex(&info->w_tree), 
"--", NULL);
1f5a011d90 builtin/stash--helper.c 1028) if (pipe_command(&cp_diff_tree, 
NULL, 0, out_patch, 0, NULL, 0)) {
1f5a011d90 builtin/stash--helper.c 1029) ret = -1;
1f5a011d90 builtin/stash--helper.c 1030) goto done;
1f5a011d90 builtin/stash--helper.c 1033) if (!out_patch->len) {
9a95010a11 builtin/stash--helper.c 1034) if (!quiet)
9a95010a11 builtin/stash--helper.c 1035) fprintf_ln(stderr, _("No 
changes selected"));
1f5a011d90 builtin/stash--helper.c 1036) ret = 1;
559edead8f builtin/stash--helper.c 1040) discard_index(&istate);
1f5a011d90 builtin/stash--helper.c 1041) remove_path(stash_index_path.buf);
1f5a011d90 builtin/stash--helper.c 1042) return ret;
1f5a011d90 builtin/stash--helper.c 1045) static int 
stash_working_tree(struct stash_info *info, struct pathspec ps)
1f5a011d90 builtin/stash--helper.c 1047) int ret = 0;
1f5a011d90 builtin/stash--helper.c 1049) struct child_process 
cp_upd_index = CHILD_PROCESS_INIT;
1f5a011d90 builtin/stash--helper.c 1050) struct strbuf diff_output = 
STRBUF_INIT;
559edead8f builtin/stash--helper.c 1051) struct index_state istate = { 
NULL };
ed5d77f7d3 builtin/stash.c         1053) init_revisions(&rev, NULL);
1f5a011d90 builtin/stash--helper.c 1055) 
set_alternate_index_output(stash_index_path.buf);
1f5a011d90 builtin/stash--helper.c 1056) if (reset_tree(&info->i_tree, 
0, 0)) {
1f5a011d90 builtin/stash--helper.c 1057) ret = -1;
1f5a011d90 builtin/stash--helper.c 1058) goto done;
1f5a011d90 builtin/stash--helper.c 1060) set_alternate_index_output(NULL);
1f5a011d90 builtin/stash--helper.c 1062) rev.prune_data = ps;
1f5a011d90 builtin/stash--helper.c 1063) rev.diffopt.output_format = 
DIFF_FORMAT_CALLBACK;
1f5a011d90 builtin/stash--helper.c 1064) rev.diffopt.format_callback = 
add_diff_to_buf;
1f5a011d90 builtin/stash--helper.c 1065) 
rev.diffopt.format_callback_data = &diff_output;
1f5a011d90 builtin/stash--helper.c 1067) if 
(read_cache_preload(&rev.diffopt.pathspec) < 0) {
1f5a011d90 builtin/stash--helper.c 1068) ret = -1;
1f5a011d90 builtin/stash--helper.c 1069) goto done;
1f5a011d90 builtin/stash--helper.c 1072) add_pending_object(&rev, 
parse_object(the_repository, &info->b_commit),
1f5a011d90 builtin/stash--helper.c 1074) if (run_diff_index(&rev, 0)) {
1f5a011d90 builtin/stash--helper.c 1075) ret = -1;
1f5a011d90 builtin/stash--helper.c 1076) goto done;
1f5a011d90 builtin/stash--helper.c 1079) cp_upd_index.git_cmd = 1;
1f5a011d90 builtin/stash--helper.c 1080) 
argv_array_pushl(&cp_upd_index.args, "update-index", "-z", "--add",
1f5a011d90 builtin/stash--helper.c 1082) 
argv_array_pushf(&cp_upd_index.env_array, "GIT_INDEX_FILE=%s",
1f5a011d90 builtin/stash--helper.c 1085) if (pipe_command(&cp_upd_index, 
diff_output.buf, diff_output.len,
1f5a011d90 builtin/stash--helper.c 1087) ret = -1;
1f5a011d90 builtin/stash--helper.c 1088) goto done;
559edead8f builtin/stash--helper.c 1091) if 
(write_index_as_tree(&info->w_tree, &istate, stash_index_path.buf, 0,
1f5a011d90 builtin/stash--helper.c 1093) ret = -1;
1f5a011d90 builtin/stash--helper.c 1094) goto done;
559edead8f builtin/stash--helper.c 1098) discard_index(&istate);
1f5a011d90 builtin/stash--helper.c 1100) object_array_clear(&rev.pending);
1f5a011d90 builtin/stash--helper.c 1101) strbuf_release(&diff_output);
1f5a011d90 builtin/stash--helper.c 1102) remove_path(stash_index_path.buf);
1f5a011d90 builtin/stash--helper.c 1103) return ret;
1f5a011d90 builtin/stash--helper.c 1106) static int 
do_create_stash(struct pathspec ps, struct strbuf *stash_msg_buf,
1f5a011d90 builtin/stash--helper.c 1111) int ret = 0;
1f5a011d90 builtin/stash--helper.c 1112) int flags = 0;
1f5a011d90 builtin/stash--helper.c 1113) int untracked_commit_option = 0;
1f5a011d90 builtin/stash--helper.c 1114) const char *head_short_sha1 = NULL;
1f5a011d90 builtin/stash--helper.c 1115) const char *branch_ref = NULL;
1f5a011d90 builtin/stash--helper.c 1116) const char *branch_name = "(no 
branch)";
1f5a011d90 builtin/stash--helper.c 1117) struct commit *head_commit = NULL;
1f5a011d90 builtin/stash--helper.c 1118) struct commit_list *parents = NULL;
1f5a011d90 builtin/stash--helper.c 1119) struct strbuf msg = STRBUF_INIT;
1f5a011d90 builtin/stash--helper.c 1120) struct strbuf commit_tree_label 
= STRBUF_INIT;
1f5a011d90 builtin/stash--helper.c 1121) struct strbuf untracked_files = 
STRBUF_INIT;
1f5a011d90 builtin/stash--helper.c 1123) prepare_fallback_ident("git 
stash", "git@stash");
1f5a011d90 builtin/stash--helper.c 1125) read_cache_preload(NULL);
1f5a011d90 builtin/stash--helper.c 1126) refresh_cache(REFRESH_QUIET);
1f5a011d90 builtin/stash--helper.c 1128) if (get_oid("HEAD", 
&info->b_commit)) {
9a95010a11 builtin/stash--helper.c 1129) if (!quiet)
9a95010a11 builtin/stash--helper.c 1130) fprintf_ln(stderr, _("You do 
not have "
1f5a011d90 builtin/stash--helper.c 1132) ret = -1;
1f5a011d90 builtin/stash--helper.c 1133) goto done;
1f5a011d90 builtin/stash--helper.c 1135) head_commit = 
lookup_commit(the_repository, &info->b_commit);
168e6cff5e builtin/stash--helper.c 1138) if (!check_changes(ps, 
include_untracked, &untracked_files)) {
1f5a011d90 builtin/stash--helper.c 1139) ret = 1;
1f5a011d90 builtin/stash--helper.c 1140) goto done;
1f5a011d90 builtin/stash--helper.c 1143) branch_ref = 
resolve_ref_unsafe("HEAD", 0, NULL, &flags);
1f5a011d90 builtin/stash--helper.c 1144) if (flags & REF_ISSYMREF)
1f5a011d90 builtin/stash--helper.c 1145) branch_name = 
strrchr(branch_ref, '/') + 1;
1f5a011d90 builtin/stash--helper.c 1146) head_short_sha1 = 
find_unique_abbrev(&head_commit->object.oid,
1f5a011d90 builtin/stash--helper.c 1148) strbuf_addf(&msg, "%s: %s ", 
branch_name, head_short_sha1);
1f5a011d90 builtin/stash--helper.c 1149) 
pp_commit_easy(CMIT_FMT_ONELINE, head_commit, &msg);
1f5a011d90 builtin/stash--helper.c 1151) strbuf_addf(&commit_tree_label, 
"index on %s\n", msg.buf);
1f5a011d90 builtin/stash--helper.c 1152) commit_list_insert(head_commit, 
&parents);
1f5a011d90 builtin/stash--helper.c 1153) if 
(write_cache_as_tree(&info->i_tree, 0, NULL) ||
1f5a011d90 builtin/stash--helper.c 1154) 
commit_tree(commit_tree_label.buf, commit_tree_label.len,
1f5a011d90 builtin/stash--helper.c 1155) &info->i_tree, parents, 
&info->i_commit, NULL, NULL)) {
9a95010a11 builtin/stash--helper.c 1156) if (!quiet)
9a95010a11 builtin/stash--helper.c 1157) fprintf_ln(stderr, _("Cannot 
save the current "
1f5a011d90 builtin/stash--helper.c 1159) ret = -1;
1f5a011d90 builtin/stash--helper.c 1160) goto done;
168e6cff5e builtin/stash--helper.c 1163) if (include_untracked) {
1f5a011d90 builtin/stash--helper.c 1164) if (save_untracked_files(info, 
&msg, untracked_files)) {
9a95010a11 builtin/stash--helper.c 1165) if (!quiet)
9a95010a11 builtin/stash--helper.c 1166) fprintf_ln(stderr, _("Cannot save "
1f5a011d90 builtin/stash--helper.c 1168) ret = -1;
1f5a011d90 builtin/stash--helper.c 1169) goto done;
1f5a011d90 builtin/stash--helper.c 1171) untracked_commit_option = 1;
1f5a011d90 builtin/stash--helper.c 1173) if (patch_mode) {
9a95010a11 builtin/stash--helper.c 1174) ret = stash_patch(info, ps, 
patch, quiet);
1f5a011d90 builtin/stash--helper.c 1175) if (ret < 0) {
9a95010a11 builtin/stash--helper.c 1176) if (!quiet)
9a95010a11 builtin/stash--helper.c 1177) fprintf_ln(stderr, _("Cannot 
save the current "
1f5a011d90 builtin/stash--helper.c 1179) goto done;
1f5a011d90 builtin/stash--helper.c 1180) } else if (ret > 0) {
1f5a011d90 builtin/stash--helper.c 1181) goto done;
1f5a011d90 builtin/stash--helper.c 1184) if (stash_working_tree(info, ps)) {
9a95010a11 builtin/stash--helper.c 1185) if (!quiet)
9a95010a11 builtin/stash--helper.c 1186) fprintf_ln(stderr, _("Cannot 
save the current "
1f5a011d90 builtin/stash--helper.c 1188) ret = -1;
1f5a011d90 builtin/stash--helper.c 1189) goto done;
1f5a011d90 builtin/stash--helper.c 1193) if (!stash_msg_buf->len)
1f5a011d90 builtin/stash--helper.c 1194) strbuf_addf(stash_msg_buf, "WIP 
on %s", msg.buf);
1f5a011d90 builtin/stash--helper.c 1196) strbuf_insertf(stash_msg_buf, 
0, "On %s: ", branch_name);
1f5a011d90 builtin/stash--helper.c 1202) parents = NULL;
1f5a011d90 builtin/stash--helper.c 1203) if (untracked_commit_option)
1f5a011d90 builtin/stash--helper.c 1204) 
commit_list_insert(lookup_commit(the_repository,
1f5a011d90 builtin/stash--helper.c 1205) &info->u_commit),
1f5a011d90 builtin/stash--helper.c 1207) 
commit_list_insert(lookup_commit(the_repository, &info->i_commit),
1f5a011d90 builtin/stash--helper.c 1209) commit_list_insert(head_commit, 
&parents);
1f5a011d90 builtin/stash--helper.c 1211) if 
(commit_tree(stash_msg_buf->buf, stash_msg_buf->len, &info->w_tree,
9a95010a11 builtin/stash--helper.c 1213) if (!quiet)
9a95010a11 builtin/stash--helper.c 1214) fprintf_ln(stderr, _("Cannot 
record "
1f5a011d90 builtin/stash--helper.c 1216) ret = -1;
1f5a011d90 builtin/stash--helper.c 1217) goto done;
1f5a011d90 builtin/stash--helper.c 1221) strbuf_release(&commit_tree_label);
1f5a011d90 builtin/stash--helper.c 1222) strbuf_release(&msg);
1f5a011d90 builtin/stash--helper.c 1223) strbuf_release(&untracked_files);
1f5a011d90 builtin/stash--helper.c 1224) return ret;
1f5a011d90 builtin/stash--helper.c 1227) static int create_stash(int 
argc, const char **argv, const char *prefix)
1f5a011d90 builtin/stash--helper.c 1229) int ret = 0;
1f5a011d90 builtin/stash--helper.c 1230) struct strbuf stash_msg_buf = 
STRBUF_INIT;
51809c70ca builtin/stash.c         1235) 
strbuf_join_argv(&stash_msg_buf, argc - 1, ++argv, ' ');
1f5a011d90 builtin/stash--helper.c 1237) memset(&ps, 0, sizeof(ps));
168e6cff5e builtin/stash--helper.c 1238) if 
(!check_changes_tracked_files(ps))
168e6cff5e builtin/stash--helper.c 1239) return 0;
168e6cff5e builtin/stash--helper.c 1241) if (!(ret = do_create_stash(ps, 
&stash_msg_buf, 0, 0, &info, NULL, 0)))
1f5a011d90 builtin/stash--helper.c 1242) printf_ln("%s", 
oid_to_hex(&info.w_commit));
1f5a011d90 builtin/stash--helper.c 1244) strbuf_release(&stash_msg_buf);
168e6cff5e builtin/stash--helper.c 1245) return ret;
fa38428f76 builtin/stash--helper.c 1248) static int do_push_stash(struct 
pathspec ps, const char *stash_msg, int quiet,
fa38428f76 builtin/stash--helper.c 1251) int ret = 0;
fa38428f76 builtin/stash--helper.c 1253) struct strbuf patch = STRBUF_INIT;
fa38428f76 builtin/stash--helper.c 1254) struct strbuf stash_msg_buf = 
STRBUF_INIT;
168e6cff5e builtin/stash--helper.c 1255) struct strbuf untracked_files = 
STRBUF_INIT;
fa38428f76 builtin/stash--helper.c 1257) if (patch_mode && keep_index == -1)
fa38428f76 builtin/stash--helper.c 1258) keep_index = 1;
fa38428f76 builtin/stash--helper.c 1260) if (patch_mode && 
include_untracked) {
fa38428f76 builtin/stash--helper.c 1261) fprintf_ln(stderr, _("Can't use 
--patch and --include-untracked"
fa38428f76 builtin/stash--helper.c 1263) ret = -1;
fa38428f76 builtin/stash--helper.c 1264) goto done;
fa38428f76 builtin/stash--helper.c 1267) read_cache_preload(NULL);
fa38428f76 builtin/stash--helper.c 1268) if (!include_untracked && ps.nr) {
fa38428f76 builtin/stash--helper.c 1270) char *ps_matched = 
xcalloc(ps.nr, 1);
fa38428f76 builtin/stash--helper.c 1272) for (i = 0; i < active_nr; i++)
fa38428f76 builtin/stash--helper.c 1273) ce_path_match(&the_index, 
active_cache[i], &ps,
fa38428f76 builtin/stash--helper.c 1276) if 
(report_path_error(ps_matched, &ps, NULL)) {
fa38428f76 builtin/stash--helper.c 1277) fprintf_ln(stderr, _("Did you 
forget to 'git add'?"));
fa38428f76 builtin/stash--helper.c 1278) ret = -1;
fa38428f76 builtin/stash--helper.c 1279) free(ps_matched);
fa38428f76 builtin/stash--helper.c 1280) goto done;
fa38428f76 builtin/stash--helper.c 1282) free(ps_matched);
fa38428f76 builtin/stash--helper.c 1285) if (refresh_cache(REFRESH_QUIET)) {
fa38428f76 builtin/stash--helper.c 1286) ret = -1;
fa38428f76 builtin/stash--helper.c 1287) goto done;
168e6cff5e builtin/stash--helper.c 1290) if (!check_changes(ps, 
include_untracked, &untracked_files)) {
fa38428f76 builtin/stash--helper.c 1291) if (!quiet)
fa38428f76 builtin/stash--helper.c 1292) printf_ln(_("No local changes 
to save"));
fa38428f76 builtin/stash--helper.c 1293) goto done;
fa38428f76 builtin/stash--helper.c 1296) if (!reflog_exists(ref_stash) 
&& do_clear_stash()) {
fa38428f76 builtin/stash--helper.c 1297) ret = -1;
9a95010a11 builtin/stash--helper.c 1298) if (!quiet)
9a95010a11 builtin/stash--helper.c 1299) fprintf_ln(stderr, _("Cannot 
initialize stash"));
fa38428f76 builtin/stash--helper.c 1300) goto done;
fa38428f76 builtin/stash--helper.c 1303) if (stash_msg)
fa38428f76 builtin/stash--helper.c 1304) strbuf_addstr(&stash_msg_buf, 
stash_msg);
fa38428f76 builtin/stash--helper.c 1305) if (do_create_stash(ps, 
&stash_msg_buf, include_untracked, patch_mode,
fa38428f76 builtin/stash--helper.c 1307) ret = -1;
fa38428f76 builtin/stash--helper.c 1308) goto done;
fa38428f76 builtin/stash--helper.c 1311) if 
(do_store_stash(&info.w_commit, stash_msg_buf.buf, 1)) {
fa38428f76 builtin/stash--helper.c 1312) ret = -1;
9a95010a11 builtin/stash--helper.c 1313) if (!quiet)
9a95010a11 builtin/stash--helper.c 1314) fprintf_ln(stderr, _("Cannot 
save the current status"));
fa38428f76 builtin/stash--helper.c 1315) goto done;
9a95010a11 builtin/stash--helper.c 1318) if (!quiet)
9a95010a11 builtin/stash--helper.c 1319) printf_ln(_("Saved working 
directory and index state %s"),
fa38428f76 builtin/stash--helper.c 1322) if (!patch_mode) {
fa38428f76 builtin/stash--helper.c 1323) if (include_untracked && !ps.nr) {
fa38428f76 builtin/stash--helper.c 1324) struct child_process cp = 
CHILD_PROCESS_INIT;
fa38428f76 builtin/stash--helper.c 1326) cp.git_cmd = 1;
fa38428f76 builtin/stash--helper.c 1327) argv_array_pushl(&cp.args, 
"clean", "--force",
fa38428f76 builtin/stash--helper.c 1329) if (include_untracked == 
INCLUDE_ALL_FILES)
fa38428f76 builtin/stash--helper.c 1330) argv_array_push(&cp.args, "-x");
fa38428f76 builtin/stash--helper.c 1331) if (run_command(&cp)) {
fa38428f76 builtin/stash--helper.c 1332) ret = -1;
fa38428f76 builtin/stash--helper.c 1333) goto done;
fa38428f76 builtin/stash--helper.c 1336) if (ps.nr) {
fa38428f76 builtin/stash--helper.c 1337) struct child_process cp_add = 
CHILD_PROCESS_INIT;
fa38428f76 builtin/stash--helper.c 1338) struct child_process cp_diff = 
CHILD_PROCESS_INIT;
fa38428f76 builtin/stash--helper.c 1339) struct child_process cp_apply = 
CHILD_PROCESS_INIT;
fa38428f76 builtin/stash--helper.c 1340) struct strbuf out = STRBUF_INIT;
fa38428f76 builtin/stash--helper.c 1342) cp_add.git_cmd = 1;
fa38428f76 builtin/stash--helper.c 1343) argv_array_push(&cp_add.args, 
"add");
fa38428f76 builtin/stash--helper.c 1344) if (!include_untracked)
fa38428f76 builtin/stash--helper.c 1345) argv_array_push(&cp_add.args, 
"-u");
fa38428f76 builtin/stash--helper.c 1346) if (include_untracked == 
INCLUDE_ALL_FILES)
fa38428f76 builtin/stash--helper.c 1347) argv_array_push(&cp_add.args, 
"--force");
fa38428f76 builtin/stash--helper.c 1348) argv_array_push(&cp_add.args, 
"--");
fa38428f76 builtin/stash--helper.c 1349) add_pathspecs(&cp_add.args, ps);
fa38428f76 builtin/stash--helper.c 1350) if (run_command(&cp_add)) {
fa38428f76 builtin/stash--helper.c 1351) ret = -1;
fa38428f76 builtin/stash--helper.c 1352) goto done;
fa38428f76 builtin/stash--helper.c 1355) cp_diff.git_cmd = 1;
fa38428f76 builtin/stash--helper.c 1356) argv_array_pushl(&cp_diff.args, 
"diff-index", "-p",
fa38428f76 builtin/stash--helper.c 1359) add_pathspecs(&cp_diff.args, ps);
fa38428f76 builtin/stash--helper.c 1360) if (pipe_command(&cp_diff, 
NULL, 0, &out, 0, NULL, 0)) {
fa38428f76 builtin/stash--helper.c 1361) ret = -1;
fa38428f76 builtin/stash--helper.c 1362) goto done;
fa38428f76 builtin/stash--helper.c 1365) cp_apply.git_cmd = 1;
fa38428f76 builtin/stash--helper.c 1366) 
argv_array_pushl(&cp_apply.args, "apply", "--index",
fa38428f76 builtin/stash--helper.c 1368) if (pipe_command(&cp_apply, 
out.buf, out.len, NULL, 0,
fa38428f76 builtin/stash--helper.c 1370) ret = -1;
fa38428f76 builtin/stash--helper.c 1371) goto done;
fa38428f76 builtin/stash--helper.c 1374) struct child_process cp = 
CHILD_PROCESS_INIT;
fa38428f76 builtin/stash--helper.c 1375) cp.git_cmd = 1;
fa38428f76 builtin/stash--helper.c 1376) argv_array_pushl(&cp.args, 
"reset", "--hard", "-q",
fa38428f76 builtin/stash--helper.c 1378) if (run_command(&cp)) {
fa38428f76 builtin/stash--helper.c 1379) ret = -1;
fa38428f76 builtin/stash--helper.c 1380) goto done;
fa38428f76 builtin/stash--helper.c 1384) if (keep_index == 1 && 
!is_null_oid(&info.i_tree)) {
fa38428f76 builtin/stash--helper.c 1385) struct child_process cp_ls = 
CHILD_PROCESS_INIT;
fa38428f76 builtin/stash--helper.c 1386) struct child_process 
cp_checkout = CHILD_PROCESS_INIT;
fa38428f76 builtin/stash--helper.c 1387) struct strbuf out = STRBUF_INIT;
fa38428f76 builtin/stash--helper.c 1389) if (reset_tree(&info.i_tree, 0, 
1)) {
fa38428f76 builtin/stash--helper.c 1390) ret = -1;
fa38428f76 builtin/stash--helper.c 1391) goto done;
fa38428f76 builtin/stash--helper.c 1394) cp_ls.git_cmd = 1;
fa38428f76 builtin/stash--helper.c 1395) argv_array_pushl(&cp_ls.args, 
"ls-files", "-z",
fa38428f76 builtin/stash--helper.c 1398) add_pathspecs(&cp_ls.args, ps);
fa38428f76 builtin/stash--helper.c 1399) if (pipe_command(&cp_ls, NULL, 
0, &out, 0, NULL, 0)) {
fa38428f76 builtin/stash--helper.c 1400) ret = -1;
fa38428f76 builtin/stash--helper.c 1401) goto done;
fa38428f76 builtin/stash--helper.c 1404) cp_checkout.git_cmd = 1;
fa38428f76 builtin/stash--helper.c 1405) 
argv_array_pushl(&cp_checkout.args, "checkout-index",
fa38428f76 builtin/stash--helper.c 1407) if (pipe_command(&cp_checkout, 
out.buf, out.len, NULL,
fa38428f76 builtin/stash--helper.c 1409) ret = -1;
fa38428f76 builtin/stash--helper.c 1410) goto done;
fa38428f76 builtin/stash--helper.c 1413) goto done;
fa38428f76 builtin/stash--helper.c 1415) struct child_process cp = 
CHILD_PROCESS_INIT;
fa38428f76 builtin/stash--helper.c 1417) cp.git_cmd = 1;
fa38428f76 builtin/stash--helper.c 1418) argv_array_pushl(&cp.args, 
"apply", "-R", NULL);
fa38428f76 builtin/stash--helper.c 1420) if (pipe_command(&cp, 
patch.buf, patch.len, NULL, 0, NULL, 0)) {
9a95010a11 builtin/stash--helper.c 1421) if (!quiet)
9a95010a11 builtin/stash--helper.c 1422) fprintf_ln(stderr, _("Cannot 
remove "
fa38428f76 builtin/stash--helper.c 1424) ret = -1;
fa38428f76 builtin/stash--helper.c 1425) goto done;
fa38428f76 builtin/stash--helper.c 1428) if (keep_index < 1) {
fa38428f76 builtin/stash--helper.c 1429) struct child_process cp = 
CHILD_PROCESS_INIT;
fa38428f76 builtin/stash--helper.c 1431) cp.git_cmd = 1;
fa38428f76 builtin/stash--helper.c 1432) argv_array_pushl(&cp.args, 
"reset", "-q", "--", NULL);
fa38428f76 builtin/stash--helper.c 1433) add_pathspecs(&cp.args, ps);
fa38428f76 builtin/stash--helper.c 1434) if (run_command(&cp)) {
fa38428f76 builtin/stash--helper.c 1435) ret = -1;
fa38428f76 builtin/stash--helper.c 1436) goto done;
fa38428f76 builtin/stash--helper.c 1439) goto done;
fa38428f76 builtin/stash--helper.c 1443) strbuf_release(&stash_msg_buf);
fa38428f76 builtin/stash--helper.c 1444) return ret;
fa38428f76 builtin/stash--helper.c 1447) static int push_stash(int argc, 
const char **argv, const char *prefix)
fa38428f76 builtin/stash--helper.c 1449) int keep_index = -1;
fa38428f76 builtin/stash--helper.c 1450) int patch_mode = 0;
fa38428f76 builtin/stash--helper.c 1451) int include_untracked = 0;
fa38428f76 builtin/stash--helper.c 1452) int quiet = 0;
fa38428f76 builtin/stash--helper.c 1453) const char *stash_msg = NULL;
fa38428f76 builtin/stash--helper.c 1455) struct option options[] = {
51809c70ca builtin/stash.c         1470) if (argc)
51809c70ca builtin/stash.c         1471) argc = parse_options(argc, 
argv, prefix, options,
fa38428f76 builtin/stash--helper.c 1475) parse_pathspec(&ps, 0, 
PATHSPEC_PREFER_FULL, prefix, argv);
fa38428f76 builtin/stash--helper.c 1476) return do_push_stash(ps, 
stash_msg, quiet, keep_index, patch_mode,
cf5b27d699 builtin/stash--helper.c 1480) static int save_stash(int argc, 
const char **argv, const char *prefix)
cf5b27d699 builtin/stash--helper.c 1482) int keep_index = -1;
cf5b27d699 builtin/stash--helper.c 1483) int patch_mode = 0;
cf5b27d699 builtin/stash--helper.c 1484) int include_untracked = 0;
cf5b27d699 builtin/stash--helper.c 1485) int quiet = 0;
cf5b27d699 builtin/stash--helper.c 1486) int ret = 0;
cf5b27d699 builtin/stash--helper.c 1487) const char *stash_msg = NULL;
cf5b27d699 builtin/stash--helper.c 1489) struct strbuf stash_msg_buf = 
STRBUF_INIT;
cf5b27d699 builtin/stash--helper.c 1490) struct option options[] = {
cf5b27d699 builtin/stash--helper.c 1505) argc = parse_options(argc, 
argv, prefix, options,
cf5b27d699 builtin/stash--helper.c 1509) if (argc)
cf5b27d699 builtin/stash--helper.c 1510) stash_msg = 
strbuf_join_argv(&stash_msg_buf, argc, argv, ' ');
cf5b27d699 builtin/stash--helper.c 1512) memset(&ps, 0, sizeof(ps));
cf5b27d699 builtin/stash--helper.c 1513) ret = do_push_stash(ps, 
stash_msg, quiet, keep_index,
cf5b27d699 builtin/stash--helper.c 1516) strbuf_release(&stash_msg_buf);
cf5b27d699 builtin/stash--helper.c 1517) return ret;
bec65d5b78 builtin/stash.c         1527) return env;
26799a208f builtin/stash.c         1537) strbuf_trim(&out);
26799a208f builtin/stash.c         1538) ret = !strcmp("true", out.buf);
26799a208f builtin/stash.c         1539) strbuf_release(&out);
26799a208f builtin/stash.c         1555) const char *path = 
mkpath("%s/git-legacy-stash",
26799a208f builtin/stash.c         1558) if (sane_execvp(path, (char 
**)argv) < 0)
26799a208f builtin/stash.c         1559) die_errno(_("could not exec 
%s"), path);
f6bbd78127 builtin/stash--helper.c 1573) index_file = get_index_file();
f6bbd78127 builtin/stash--helper.c 1574) strbuf_addf(&stash_index_path, 
"%s.stash.%" PRIuMAX, index_file,
51809c70ca builtin/stash.c         1577) if (!argc)
51809c70ca builtin/stash.c         1578) return !!push_stash(0, NULL, 
prefix);
51809c70ca builtin/stash.c         1579) else if (!strcmp(argv[0], "apply"))
f6bbd78127 builtin/stash--helper.c 1580) return !!apply_stash(argc, 
argv, prefix);
cdca49bc4c builtin/stash--helper.c 1581) else if (!strcmp(argv[0], "clear"))
cdca49bc4c builtin/stash--helper.c 1582) return !!clear_stash(argc, 
argv, prefix);
cdca49bc4c builtin/stash--helper.c 1583) else if (!strcmp(argv[0], "drop"))
cdca49bc4c builtin/stash--helper.c 1584) return !!drop_stash(argc, argv, 
prefix);
e1d01876a4 builtin/stash--helper.c 1585) else if (!strcmp(argv[0], "pop"))
e1d01876a4 builtin/stash--helper.c 1586) return !!pop_stash(argc, argv, 
prefix);
f596f3366c builtin/stash--helper.c 1587) else if (!strcmp(argv[0], 
"branch"))
f596f3366c builtin/stash--helper.c 1588) return !!branch_stash(argc, 
argv, prefix);
9b77b07ba4 builtin/stash--helper.c 1589) else if (!strcmp(argv[0], "list"))
9b77b07ba4 builtin/stash--helper.c 1590) return !!list_stash(argc, argv, 
prefix);
b4493f269e builtin/stash--helper.c 1591) else if (!strcmp(argv[0], "show"))
b4493f269e builtin/stash--helper.c 1592) return !!show_stash(argc, argv, 
prefix);
847eb0b0a8 builtin/stash--helper.c 1593) else if (!strcmp(argv[0], "store"))
847eb0b0a8 builtin/stash--helper.c 1594) return !!store_stash(argc, 
argv, prefix);
1f5a011d90 builtin/stash--helper.c 1595) else if (!strcmp(argv[0], 
"create"))
1f5a011d90 builtin/stash--helper.c 1596) return !!create_stash(argc, 
argv, prefix);
fa38428f76 builtin/stash--helper.c 1597) else if (!strcmp(argv[0], "push"))
fa38428f76 builtin/stash--helper.c 1598) return !!push_stash(argc, argv, 
prefix);
cf5b27d699 builtin/stash--helper.c 1599) else if (!strcmp(argv[0], "save"))
cf5b27d699 builtin/stash--helper.c 1600) return !!save_stash(argc, argv, 
prefix);
51809c70ca builtin/stash.c         1601) else if (*argv[0] != '-')
51809c70ca builtin/stash.c         1602) 
usage_msg_opt(xstrfmt(_("unknown subcommand: %s"), argv[0]),
51809c70ca builtin/stash.c         1605) if (strcmp(argv[0], "-p")) {
51809c70ca builtin/stash.c         1606) while (++i < argc && 
strcmp(argv[i], "--")) {
51809c70ca builtin/stash.c         1611) if ((strlen(argv[i]) == 2) && 
*argv[i] == '-' &&
51809c70ca builtin/stash.c         1612)     strchr("akpqu", argv[i][1]))
51809c70ca builtin/stash.c         1613) continue;
51809c70ca builtin/stash.c         1615) if (!strcmp(argv[i], "--all") ||
51809c70ca builtin/stash.c         1616)     !strcmp(argv[i], 
"--keep-index") ||
51809c70ca builtin/stash.c         1617)     !strcmp(argv[i], 
"--no-keep-index") ||
51809c70ca builtin/stash.c         1618)     !strcmp(argv[i], "--patch") ||
51809c70ca builtin/stash.c         1619)     !strcmp(argv[i], "--quiet") ||
51809c70ca builtin/stash.c         1620)     !strcmp(argv[i], 
"--include-untracked"))
51809c70ca builtin/stash.c         1621) continue;
51809c70ca builtin/stash.c         1628) if (starts_with(argv[i], "-m") ||
51809c70ca builtin/stash.c         1629) starts_with(argv[i], "--message="))
51809c70ca builtin/stash.c         1630) continue;
51809c70ca builtin/stash.c         1632) 
usage_with_options(git_stash_usage, options);
51809c70ca builtin/stash.c         1636) argv_array_push(&args, "push");
51809c70ca builtin/stash.c         1637) argv_array_pushv(&args, argv);
51809c70ca builtin/stash.c         1638) return !!push_stash(args.argc, 
args.argv, prefix);

builtin/update-index.c
08339886b9 builtin/update-index.c  895) static enum parse_opt_result 
stdin_callback(
9b4ae5190a builtin/update-index.c  902) BUG_ON_OPT_ARG(arg);
08339886b9 builtin/update-index.c  910) static enum parse_opt_result 
unresolve_callback(
9b4ae5190a builtin/update-index.c  918) BUG_ON_OPT_ARG(arg);
08339886b9 builtin/update-index.c  931) static enum parse_opt_result 
reupdate_callback(
9b4ae5190a builtin/update-index.c  939) BUG_ON_OPT_ARG(arg);

builtin/upload-archive.c
6da1f1a920 builtin/upload-archive.c  86) 
register_allowed_protocol_version(protocol_v0);

commit-graph.c
97b202471c  885) for_each_object_in_pack(p, add_packed_commits, &oids,
97b202471c  932) for_each_packed_object(add_packed_commits, &oids,

config.c
06800238c6 1684) worktree_config = mkpathdup("%s/config.worktree", 
opts->git_dir);
06800238c6 1709) ret += git_config_from_file(fn, worktree_config, data);
8f7c7f5555 2147) int repo_config_set_gently(struct repository *r,
8f7c7f5555 2150) char *path = repo_git_path(r, "config");
8f7c7f5555 2151) int ret = git_config_set_multivar_in_file_gently(path, 
key, value, NULL, 0);
8f7c7f5555 2152) free(path);
8f7c7f5555 2153) return ret;
8f7c7f5555 2156) void repo_config_set(struct repository *r, const char 
*key, const char *value)
8f7c7f5555 2158) if (!repo_config_set_gently(r, key, value))
8f7c7f5555 2159) return;
8f7c7f5555 2160) if (value)
8f7c7f5555 2161) die(_("could not set '%s' to '%s'"), key, value);
8f7c7f5555 2163) die(_("could not unset '%s'"), key);
8f7c7f5555 2166) int repo_config_set_worktree_gently(struct repository *r,
8f7c7f5555 2172) path = get_worktree_config(r);
8f7c7f5555 2173) if (!path)
8f7c7f5555 2174) return CONFIG_INVALID_FILE;
8f7c7f5555 2175) ret = git_config_set_multivar_in_file_gently(path, key, 
value, NULL, 0);
8f7c7f5555 2176) free(path);
8f7c7f5555 2177) return ret;

connect.c
6da1f1a920 1085) strbuf_addch(&request, '\0');
6da1f1a920 1086) strbuf_addf(&request, "%s%c", version_advert->buf, '\0');
6da1f1a920 1103) if (variant == VARIANT_SSH) {
6da1f1a920 1106) argv_array_pushf(env, GIT_PROTOCOL_ENVIRONMENT "=%s",
6da1f1a920 1194) push_ssh_options(&detect.args, &detect.env_array, 
VARIANT_SSH,
6da1f1a920 1202) push_ssh_options(&conn->args, &conn->env_array, 
variant, port,
6da1f1a920 1241) conn = git_connect_git(fd, hostandport, path, prog,
6da1f1a920 1285) fill_ssh_args(conn, ssh_host, port, &version_advert,

date.c
acdd37769d  113) die("Timestamp too large for this system: %"PRItime, time);
6943bd42fb  137) gettimeofday(now, NULL);
acdd37769d  245) hide.date = 1;
acdd37769d  926) return DATE_HUMAN;
86177eb5c4  943) if (isatty(1) || pager_in_use())
86177eb5c4  944) format = p;
86177eb5c4  946) format = "default";

diff-no-index.c
963389f6e7 268) if (implicit_no_index)
963389f6e7 269) warning(_("Not a git repository. Use --no-index to "
963389f6e7 271) usage_with_options(diff_no_index_usage, options);
963389f6e7 305) return 1;

diff.c
0eb03c4cd0 4745) width = strtoul(value, &end, 10);
0eb03c4cd0 4746) if (*end == ',')
0eb03c4cd0 4747) name_width = strtoul(end+1, &end, 10);
0eb03c4cd0 4748) if (*end == ',')
0eb03c4cd0 4749) count = strtoul(end+1, &end, 10);
0eb03c4cd0 4750) if (*end)
0eb03c4cd0 4751) return error(_("invalid --stat value: %s"), value);
0eb03c4cd0 4753) } else if (!strcmp(opt->long_name, "stat-width")) {
0eb03c4cd0 4754) width = strtoul(value, &end, 10);
0eb03c4cd0 4755) if (*end)
0eb03c4cd0 4756) return error(_("%s expects a numerical value"),
0eb03c4cd0 4758) } else if (!strcmp(opt->long_name, "stat-name-width")) {
0eb03c4cd0 4759) name_width = strtoul(value, &end, 10);
0eb03c4cd0 4760) if (*end)
0eb03c4cd0 4761) return error(_("%s expects a numerical value"),
0eb03c4cd0 4763) } else if (!strcmp(opt->long_name, "stat-graph-width")) {
0eb03c4cd0 4764) graph_width = strtoul(value, &end, 10);
0eb03c4cd0 4765) if (*end)
0eb03c4cd0 4766) return error(_("%s expects a numerical value"),
0eb03c4cd0 4768) } else if (!strcmp(opt->long_name, "stat-count")) {
0eb03c4cd0 4769) count = strtoul(value, &end, 10);
0eb03c4cd0 4770) if (*end)
0eb03c4cd0 4771) return error(_("%s expects a numerical value"),
b74a81799d 4836) static int diff_opt_diff_filter(const struct option 
*option,
b74a81799d 4839) struct diff_options *opt = option->value;
b74a81799d 4842) BUG_ON_OPT_NEG(unset);
b74a81799d 4873) return error(_("unknown change class '%c' in 
--diff-filter=%s"),
8b70e41773 4889) static int diff_opt_ws_error_highlight(const struct 
option *option,
8b70e41773 4892) struct diff_options *opt = option->value;
8b70e41773 4895) BUG_ON_OPT_NEG(unset);
8b70e41773 4896) if (val < 0)
8b70e41773 4897) return error("unknown value after ws-error-highlight=%.*s",
8b70e41773 4900) return 0;
5866e9ce9a 4903) static int diff_opt_find_object(const struct option 
*option,
5866e9ce9a 4906) struct diff_options *opt = option->value;
5866e9ce9a 4909) BUG_ON_OPT_NEG(unset);
5866e9ce9a 4911) return error(_("unable to resolve '%s'"), arg);
5866e9ce9a 4920) return 0;
b065b66077 4923) static int diff_opt_anchored(const struct option *opt,
b065b66077 4926) struct diff_options *options = opt->value;
b065b66077 4928) BUG_ON_OPT_NEG(unset);
b065b66077 4929) options->xdl_opts = DIFF_WITH_ALG(options, PATIENCE_DIFF);
b065b66077 4930) ALLOC_GROW(options->anchors, options->anchors_nr + 1,
b065b66077 4932) options->anchors[options->anchors_nr++] = xstrdup(arg);
b065b66077 4933) return 0;
6d0300b2e3 4936) static int diff_opt_binary(const struct option *opt,
6d0300b2e3 4939) struct diff_options *options = opt->value;
6d0300b2e3 4941) BUG_ON_OPT_NEG(unset);
6d0300b2e3 4942) BUG_ON_OPT_ARG(arg);
6d0300b2e3 4943) enable_patch_output(&options->output_format);
6d0300b2e3 4944) options->flags.binary = 1;
6d0300b2e3 4945) return 0;
b9b760ed1c 4948) static int diff_opt_break_rewrites(const struct option 
*opt,
b9b760ed1c 4951) int *break_opt = opt->value;
b9b760ed1c 4954) BUG_ON_OPT_NEG(unset);
b9b760ed1c 4955) if (!arg)
b9b760ed1c 4956) arg = "";
b9b760ed1c 4957) opt1 = parse_rename_score(&arg);
b9b760ed1c 4958) switch (*arg) {
b9b760ed1c 4960) opt2 = 0;
b9b760ed1c 4961) break;
b9b760ed1c 4963) arg++;
b9b760ed1c 4964) opt2 = parse_rename_score(&arg);
b9b760ed1c 4965) break;
b9b760ed1c 4967) if (*arg != 0)
b9b760ed1c 4968) return error(_("%s expects <n>/<m> form"), opt->long_name);
b9b760ed1c 4969) *break_opt = opt1 | (opt2 << 16);
b9b760ed1c 4970) return 0;
3d810d1860 4973) static int diff_opt_char(const struct option *opt,
3d810d1860 4976) char *value = opt->value;
3d810d1860 4978) BUG_ON_OPT_NEG(unset);
3d810d1860 4979) if (arg[1])
3d810d1860 4980) return error(_("%s expects a character, got '%s'"),
3d810d1860 4982) *value = arg[0];
3d810d1860 4983) return 0;
221d676696 4986) static int diff_opt_color_moved(const struct option *opt,
221d676696 4989) struct diff_options *options = opt->value;
221d676696 4991) if (unset) {
221d676696 4992) options->color_moved = COLOR_MOVED_NO;
221d676696 4993) } else if (!arg) {
221d676696 5004) return 0;
7c33a67a2e 5007) static int diff_opt_color_moved_ws(const struct option 
*opt,
7c33a67a2e 5010) struct diff_options *options = opt->value;
da9db54b3e 5013) if (unset) {
da9db54b3e 5015) return 0;
7c33a67a2e 5018) cm = parse_color_moved_ws(arg);
7c33a67a2e 5019) if (cm & COLOR_MOVED_WS_ERROR)
7c33a67a2e 5020) return error(_("invalid mode '%s' in 
--color-moved-ws"), arg);
7c33a67a2e 5021) options->color_moved_ws_handling = cm;
7c33a67a2e 5022) return 0;
f3b49b7f9e 5025) static int diff_opt_color_words(const struct option *opt,
f3b49b7f9e 5028) struct diff_options *options = opt->value;
f3b49b7f9e 5030) BUG_ON_OPT_NEG(unset);
f3b49b7f9e 5031) options->use_color = 1;
f3b49b7f9e 5032) options->word_diff = DIFF_WORDS_COLOR;
f3b49b7f9e 5033) options->word_regex = arg;
f3b49b7f9e 5034) return 0;
58c7ef398e 5037) static int diff_opt_compact_summary(const struct option 
*opt,
58c7ef398e 5040) struct diff_options *options = opt->value;
58c7ef398e 5042) BUG_ON_OPT_ARG(arg);
58c7ef398e 5043) if (unset) {
58c7ef398e 5044) options->flags.stat_with_summary = 0;
58c7ef398e 5046) options->flags.stat_with_summary = 1;
58c7ef398e 5047) options->output_format |= DIFF_FORMAT_DIFFSTAT;
58c7ef398e 5049) return 0;
1efc2689d6 5052) static int diff_opt_diff_algorithm(const struct option 
*opt,
1efc2689d6 5055) struct diff_options *options = opt->value;
1efc2689d6 5056) long value = parse_algorithm_value(arg);
1efc2689d6 5058) BUG_ON_OPT_NEG(unset);
1efc2689d6 5059) if (value < 0)
1efc2689d6 5060) return error(_("option diff-algorithm accepts \"myers\", "
1efc2689d6 5064) DIFF_XDL_CLR(options, NEED_MINIMAL);
1efc2689d6 5065) options->xdl_opts &= ~XDF_DIFF_ALGORITHM_MASK;
1efc2689d6 5066) options->xdl_opts |= value;
1efc2689d6 5067) return 0;
f8d10810d3 5070) static int diff_opt_dirstat(const struct option *opt,
f8d10810d3 5073) struct diff_options *options = opt->value;
f8d10810d3 5075) BUG_ON_OPT_NEG(unset);
f8d10810d3 5076) if (!strcmp(opt->long_name, "cumulative")) {
f8d10810d3 5077) if (arg)
f8d10810d3 5079) arg = "cumulative";
f8d10810d3 5080) } else if (!strcmp(opt->long_name, "dirstat-by-file"))
f8d10810d3 5081) parse_dirstat_opt(options, "files");
f8d10810d3 5082) parse_dirstat_opt(options, arg ? arg : "");
f8d10810d3 5083) return 0;
97e53999cd 5086) static int diff_opt_find_copies(const struct option *opt,
97e53999cd 5089) struct diff_options *options = opt->value;
97e53999cd 5091) BUG_ON_OPT_NEG(unset);
97e53999cd 5092) if (!arg)
97e53999cd 5093) arg = "";
97e53999cd 5094) options->rename_score = parse_rename_score(&arg);
97e53999cd 5095) if (*arg != 0)
97e53999cd 5096) return error(_("invalid argument to %s"), opt->long_name);
97e53999cd 5098) if (options->detect_rename == DIFF_DETECT_COPY)
97e53999cd 5099) options->flags.find_copies_harder = 1;
97e53999cd 5101) options->detect_rename = DIFF_DETECT_COPY;
97e53999cd 5103) return 0;
10e07ecc0c 5116) return error(_("invalid argument to %s"), opt->long_name);
c2dcec4fd2 5122) static int diff_opt_follow(const struct option *opt,
c2dcec4fd2 5125) struct diff_options *options = opt->value;
c2dcec4fd2 5127) BUG_ON_OPT_ARG(arg);
c2dcec4fd2 5128) if (unset) {
c2dcec4fd2 5129) options->flags.follow_renames = 0;
c2dcec4fd2 5130) options->flags.default_follow_renames = 0;
c2dcec4fd2 5132) options->flags.follow_renames = 1;
c2dcec4fd2 5134) return 0;
6c0ec4f728 5150) static int diff_opt_line_prefix(const struct option *opt,
6c0ec4f728 5153) struct diff_options *options = opt->value;
6c0ec4f728 5155) BUG_ON_OPT_NEG(unset);
6c0ec4f728 5156) options->line_prefix = optarg;
6c0ec4f728 5157) options->line_prefix_length = strlen(options->line_prefix);
6c0ec4f728 5158) graph_setup_line_prefix(options);
6c0ec4f728 5159) return 0;
059343267e 5162) static int diff_opt_no_prefix(const struct option *opt,
059343267e 5165) struct diff_options *options = opt->value;
059343267e 5167) BUG_ON_OPT_NEG(unset);
059343267e 5168) BUG_ON_OPT_ARG(optarg);
059343267e 5169) options->a_prefix = "";
059343267e 5170) options->b_prefix = "";
059343267e 5171) return 0;
3d810d1860 5174) static enum parse_opt_result diff_opt_output(struct 
parse_opt_ctx_t *ctx,
3d810d1860 5178) struct diff_options *options = opt->value;
3d810d1860 5181) BUG_ON_OPT_NEG(unset);
3d810d1860 5182) path = prefix_filename(ctx->prefix, arg);
3d810d1860 5183) options->file = xfopen(path, "w");
3d810d1860 5184) options->close_file = 1;
3d810d1860 5185) if (options->use_color != GIT_COLOR_ALWAYS)
3d810d1860 5186) options->use_color = GIT_COLOR_NEVER;
3d810d1860 5187) free(path);
3d810d1860 5188) return 0;
2156b1fd0c 5191) static int diff_opt_patience(const struct option *opt,
2156b1fd0c 5194) struct diff_options *options = opt->value;
2156b1fd0c 5197) BUG_ON_OPT_NEG(unset);
2156b1fd0c 5198) BUG_ON_OPT_ARG(arg);
2156b1fd0c 5199) options->xdl_opts = DIFF_WITH_ALG(options, PATIENCE_DIFF);
2156b1fd0c 5205) for (i = 0; i < options->anchors_nr; i++)
2156b1fd0c 5206) free(options->anchors[i]);
2156b1fd0c 5207) options->anchors_nr = 0;
2156b1fd0c 5208) return 0;
d071ebcc8a 5211) static int diff_opt_pickaxe_regex(const struct option *opt,
d071ebcc8a 5214) struct diff_options *options = opt->value;
d071ebcc8a 5216) BUG_ON_OPT_NEG(unset);
d071ebcc8a 5217) options->pickaxe = arg;
d071ebcc8a 5218) options->pickaxe_opts |= DIFF_PICKAXE_KIND_G;
d071ebcc8a 5219) return 0;
d071ebcc8a 5222) static int diff_opt_pickaxe_string(const struct option 
*opt,
d071ebcc8a 5225) struct diff_options *options = opt->value;
d071ebcc8a 5227) BUG_ON_OPT_NEG(unset);
d071ebcc8a 5228) options->pickaxe = arg;
d071ebcc8a 5229) options->pickaxe_opts |= DIFF_PICKAXE_KIND_S;
d071ebcc8a 5230) return 0;
350a71f2fc 5233) static int diff_opt_relative(const struct option *opt,
350a71f2fc 5236) struct diff_options *options = opt->value;
350a71f2fc 5238) BUG_ON_OPT_NEG(unset);
350a71f2fc 5239) options->flags.relative_name = 1;
350a71f2fc 5240) if (arg)
350a71f2fc 5241) options->prefix = arg;
350a71f2fc 5242) return 0;
1d2890f4f5 5245) static int diff_opt_submodule(const struct option *opt,
1d2890f4f5 5248) struct diff_options *options = opt->value;
1d2890f4f5 5250) BUG_ON_OPT_NEG(unset);
1d2890f4f5 5251) if (!arg)
1d2890f4f5 5252) arg = "log";
1d2890f4f5 5253) if (parse_submodule_params(options, arg))
1d2890f4f5 5254) return error(_("failed to parse --submodule option 
parameter: '%s'"),
1d2890f4f5 5256) return 0;
1d85988346 5259) static int diff_opt_textconv(const struct option *opt,
1d85988346 5262) struct diff_options *options = opt->value;
1d85988346 5264) BUG_ON_OPT_ARG(arg);
1d85988346 5265) if (unset) {
1d85988346 5266) options->flags.allow_textconv = 0;
1d85988346 5268) options->flags.allow_textconv = 1;
1d85988346 5269) options->flags.textconv_set_via_cmdline = 1;
1d85988346 5271) return 0;
6643eb7bbf 5284) return error(_("%s expects a numerical value"), 
"--unified");
08d080bf7f 5290) static int diff_opt_word_diff(const struct option *opt,
08d080bf7f 5293) struct diff_options *options = opt->value;
08d080bf7f 5295) BUG_ON_OPT_NEG(unset);
08d080bf7f 5296) if (arg) {
08d080bf7f 5308) return error(_("bad --word-diff argument: %s"), arg);
08d080bf7f 5313) return 0;
afe77a4dd9 5316) static int diff_opt_word_diff_regex(const struct option 
*opt,
afe77a4dd9 5319) struct diff_options *options = opt->value;
afe77a4dd9 5321) BUG_ON_OPT_NEG(unset);
afe77a4dd9 5322) if (options->word_diff == DIFF_WORDS_NONE)
afe77a4dd9 5323) options->word_diff = DIFF_WORDS_PLAIN;
afe77a4dd9 5324) options->word_regex = arg;
afe77a4dd9 5325) return 0;

fsck.c
ef644c4150  252) oidset_parse_file(&options->skiplist, buf + equal + 1);

ident.c
97f56073ce 568) static void set_env_if(const char *key, const char 
*value, int *given, int bit)
97f56073ce 570) if ((*given & bit) || getenv(key))
97f56073ce 571) return; /* nothing to do */
97f56073ce 572) setenv(key, value, 0);
97f56073ce 573) *given |= bit;
97f56073ce 576) void prepare_fallback_ident(const char *name, const char 
*email)
97f56073ce 578) set_env_if("GIT_AUTHOR_NAME", name,
97f56073ce 580) set_env_if("GIT_AUTHOR_EMAIL", email,
97f56073ce 582) set_env_if("GIT_COMMITTER_NAME", name,
97f56073ce 584) set_env_if("GIT_COMMITTER_EMAIL", email,
97f56073ce 586) }

list-objects-filter-options.c
3a7a698e93  74) if (!get_oid_with_context(the_repository, v0, GET_OID_BLOB,

list-objects.c
4f6d26b167 229) static void add_edge_parents(struct commit *commit,
4f6d26b167 236) for (parents = commit->parents; parents; parents = 
parents->next) {
4f6d26b167 237) struct commit *parent = parents->item;
4f6d26b167 238) struct tree *tree = get_commit_tree(parent);
4f6d26b167 240) if (!tree)
4f6d26b167 241) continue;
4f6d26b167 243) oidset_insert(set, &tree->object.oid);
4f6d26b167 245) if (!(parent->object.flags & UNINTERESTING))
4f6d26b167 246) continue;
4f6d26b167 247) tree->object.flags |= UNINTERESTING;
4f6d26b167 249) if (revs->edge_hint && !(parent->object.flags & SHOWN)) {
4f6d26b167 250) parent->object.flags |= SHOWN;
4f6d26b167 251) show_edge(parent);
4f6d26b167 254) }
4f6d26b167 265) oidset_init(&set, 16);
4f6d26b167 267) for (list = revs->commits; list; list = list->next) {
4f6d26b167 268) struct commit *commit = list->item;
4f6d26b167 269) struct tree *tree = get_commit_tree(commit);
4f6d26b167 271) if (commit->object.flags & UNINTERESTING)
4f6d26b167 272) tree->object.flags |= UNINTERESTING;
4f6d26b167 274) oidset_insert(&set, &tree->object.oid);
4f6d26b167 275) add_edge_parents(commit, revs, show_edge, &set);
4f6d26b167 278) mark_trees_uninteresting_sparse(revs->repo, &set);
4f6d26b167 279) oidset_clear(&set);
4f6d26b167 287) commit->object.flags |= SHOWN;
4f6d26b167 288) show_edge(commit);

merge-recursive.c
d7cf3a96e9  149) static struct tree *shift_tree_object(struct repository 
*repo,
d7cf3a96e9  163) return lookup_tree(repo, &shifted);
0d6caa2d08  428) struct index_state *istate = o->repo->index;
0d6caa2d08  430) if (unmerged_index(istate)) {
0d6caa2d08  433) for (i = 0; i < istate->cache_nr; i++) {
0d6caa2d08  434) const struct cache_entry *ce = istate->cache[i];
0d6caa2d08  442) if (!istate->cache_tree)
0d6caa2d08  443) istate->cache_tree = cache_tree();
0d6caa2d08  445) if (!cache_tree_fully_valid(istate->cache_tree) &&
0d6caa2d08  446)     cache_tree_update(istate, 0) < 0) {
d7cf3a96e9  451) result = lookup_tree(o->repo, &istate->cache_tree->oid);
0d6caa2d08  733) ce = index_file_exists(o->repo->index, path, strlen(path),
0d6caa2d08 1116) static int find_first_merges(struct repository *repo,
0d6caa2d08 1137) repo_init_revisions(repo, &revs, NULL);
d7cf3a96e9 1215) if (!(commit_base = lookup_commit_reference(o->repo, 
base)) ||
d7cf3a96e9 1216)     !(commit_a = lookup_commit_reference(o->repo, a)) ||
d7cf3a96e9 1217)     !(commit_b = lookup_commit_reference(o->repo, b))) {
0d6caa2d08 1267) parent_count = find_first_merges(o->repo, &merges, path,
0d6caa2d08 1416) if (!o->call_depth && would_lose_untracked(o, 
dest->path)) {
0d6caa2d08 1455)     (!o->call_depth && would_lose_untracked(o, path))) {
0d6caa2d08 1465) ret = remove_file_from_index(o->repo->index, path);
0d6caa2d08 1541) return remove_file_from_index(o->repo->index, dest->path);
0d6caa2d08 1622)     o->call_depth || would_lose_untracked(o, prev_path1));
0d6caa2d08 1625)     o->call_depth || would_lose_untracked(o, prev_path2));
0d6caa2d08 1732) if (dir_in_way(o->repo->index, path, !o->call_depth, 0)) {
0d6caa2d08 1737) } else if (would_lose_untracked(o, path)) {
0d6caa2d08 1798) remove_file_from_index(o->repo->index, a->path);
0d6caa2d08 1805) remove_file_from_index(o->repo->index, b->path);
0d6caa2d08 3057) if (renormalize_buffer(opt->repo->index, path, o.buf, 
o.len, &o) |
0d6caa2d08 3058)     renormalize_buffer(opt->repo->index, path, a.buf, 
a.len, &a))
0d6caa2d08 3139) if (dir_in_way(o->repo->index, path, !o->call_depth,
0d6caa2d08 3173) pos = index_name_pos(o->repo->index, path, strlen(path));
0d6caa2d08 3174) ce = o->repo->index->cache[pos];
0d6caa2d08 3193) remove_file_from_index(o->repo->index, path);
0d6caa2d08 3364) remove_file_from_index(o->repo->index, path);
d7cf3a96e9 3423) merge = shift_tree_object(o->repo, head, merge, 
o->subtree_shift);
d7cf3a96e9 3424) common = shift_tree_object(o->repo, head, common, 
o->subtree_shift);
d7cf3a96e9 3560) tree = lookup_tree(o->repo, 
o->repo->hash_algo->empty_tree);
d7cf3a96e9 3561) merged_common_ancestors = make_virtual_commit(o->repo, 
tree, "ancestor");
0d6caa2d08 3575) discard_index(o->repo->index);
d7cf3a96e9 3605) *result = make_virtual_commit(o->repo, mrtree, "merged 
tree");

merge.c
e1ff0a32e4  40) if (repo_read_index(r) < 0)

notes-merge.c
1d18d7581c 652) create_notes_commit(o->repo, local_tree, parents, 
o->commit_msg.buf,
1d18d7581c 727) create_notes_commit(o->repo, partial_tree, 
partial_commit->parents, msg,

notes-utils.c
1d18d7581c   8) void create_notes_commit(struct repository *r,
1d18d7581c  25) struct commit *parent = lookup_commit(r, &parent_oid);
1d18d7581c  38) void commit_notes(struct repository *r, struct 
notes_tree *t, const char *msg)
1d18d7581c  54) create_notes_commit(r, t, NULL, buf.buf, buf.len, 
&commit_oid);
1d18d7581c 175) void finish_copy_notes_for_rewrite(struct repository *r,
1d18d7581c 181) commit_notes(r, c->trees[i], msg);

oidset.c
ef644c4150 39) void oidset_parse_file(struct oidset *set, const char *path)
ef644c4150 42) struct strbuf sb = STRBUF_INIT;
ef644c4150 45) fp = fopen(path, "r");
ef644c4150 46) if (!fp)
ef644c4150 47) die("Could not open skip list: %s", path);
ef644c4150 48) while (!strbuf_getline(&sb, fp)) {
ef644c4150 57) hash = strchr(sb.buf, '#');
ef644c4150 58) if (hash)
ef644c4150 59) strbuf_setlen(&sb, hash - sb.buf);
ef644c4150 60) strbuf_trim(&sb);
ef644c4150 61) if (!sb.len)
ef644c4150 62) continue;
ef644c4150 64) if (parse_oid_hex(sb.buf, &oid, &p) || *p != '\0')
ef644c4150 65) die("Invalid SHA-1: %s", sb.buf);
ef644c4150 66) oidset_insert(set, &oid);
ef644c4150 68) if (ferror(fp))
ef644c4150 69) die_errno("Could not read '%s'", path);
ef644c4150 70) fclose(fp);
ef644c4150 71) strbuf_release(&sb);
ef644c4150 72) }

parse-options-cb.c
8fc6b47cd5  26) v = the_hash_algo->hexsz;
08339886b9 173) enum parse_opt_result parse_opt_unknown_cb(struct 
parse_opt_ctx_t *ctx,
9b4ae5190a 177) BUG_ON_OPT_ARG(arg);
08339886b9 178) return PARSE_OPT_UNKNOWN;

parse-options.c
08339886b9  48) static enum parse_opt_result opt_command_mode_error(
08339886b9  74) return PARSE_OPT_ERROR;
9b4ae5190a 183) return (*opt->ll_callback)(p, opt, p_arg, p_unset);
9b4ae5190a 255) rc = (*numopt->ll_callback)(p, numopt, arg, 0);

pretty.c
4681fe38e1 1060) static int match_placeholder_arg_value(const char 
*to_parse, const char *candidate,
4681fe38e1 1067) if (valuestart) {
4681fe38e1 1068) if (*p != '=')
4681fe38e1 1069) return 0;
4681fe38e1 1070) *valuestart = p + 1;
4681fe38e1 1071) *valuelen = strcspn(*valuestart, ",)");
4681fe38e1 1072) p = *valuestart + *valuelen;
4681fe38e1 1085) static int match_placeholder_arg(const char *to_parse, 
const char *candidate,
4681fe38e1 1088) return match_placeholder_arg_value(to_parse, candidate, 
end, NULL, NULL);
b755bf6f83 1091) static int match_placeholder_bool_arg(const char 
*to_parse, const char *candidate,
b755bf6f83 1095) if (!skip_prefix(to_parse, candidate, &p))
b755bf6f83 1096) return 0;
b755bf6f83 1098) if (match_placeholder_arg(p, "=no", end) ||
b755bf6f83 1099)     match_placeholder_arg(p, "=off", end) ||
b755bf6f83 1100)     match_placeholder_arg(p, "=false", end)) {
b755bf6f83 1101) *val = 0;
b755bf6f83 1102) return 1;
b755bf6f83 1105) if (match_placeholder_arg(p, "", end) ||
b755bf6f83 1106)     match_placeholder_arg(p, "=yes", end) ||
b755bf6f83 1107)     match_placeholder_arg(p, "=on", end) ||
b755bf6f83 1108)     match_placeholder_arg(p, "=true", end)) {
b755bf6f83 1109) *val = 1;
b755bf6f83 1110) return 1;
4681fe38e1 1112) return 0;
4681fe38e1 1115) static int format_trailer_match_cb(const struct strbuf 
*key, void *ud)
4681fe38e1 1117) const struct string_list *list = ud;
4681fe38e1 1120) for_each_string_list_item (item, list) {
4681fe38e1 1121) if (key->len == (uintptr_t)item->util &&
4681fe38e1 1122)     !strncasecmp (item->string, key->buf, key->len))
4681fe38e1 1123) return 1;
b755bf6f83 1125) return 0;
18f8e81091 1143) return res;
4681fe38e1 1369) struct string_list filter_list = STRING_LIST_INIT_NODUP;
ced45aab72 1370) struct strbuf sepbuf = STRBUF_INIT;
ffd7cae405 1371) size_t ret = 0;
4681fe38e1 1381) if (match_placeholder_arg_value(arg, "key", &arg, 
&argval, &arglen)) {
4681fe38e1 1382) uintptr_t len = arglen;
4681fe38e1 1383) if (len && argval[len - 1] == ':')
4681fe38e1 1384) len--;
4681fe38e1 1385) string_list_append(&filter_list, argval)->util = (char 
*)len;
4681fe38e1 1387) opts.filter = format_trailer_match_cb;
4681fe38e1 1388) opts.filter_data = &filter_list;
ced45aab72 1390) } else if (match_placeholder_arg_value(arg, 
"separator", &arg, &argval, &arglen)) {
ced45aab72 1393) strbuf_reset(&sepbuf);
ced45aab72 1394) fmt = xstrndup(argval, arglen);
ced45aab72 1395) strbuf_expand(&sepbuf, fmt, strbuf_expand_literal_cb, 
NULL);
ced45aab72 1396) free(fmt);
ced45aab72 1397) opts.separator = &sepbuf;
4681fe38e1 1398) } else if (!match_placeholder_bool_arg(arg, "only", 
&arg, &opts.only_trailers) &&
e9da5de761 1399)    !match_placeholder_bool_arg(arg, "unfold", &arg, 
&opts.unfold) &&
e9da5de761 1400)    !match_placeholder_bool_arg(arg, "valueonly", &arg, 
&opts.value_only))
ffd7cae405 1406) ret = arg - placeholder + 1;
4681fe38e1 1408) string_list_clear (&filter_list, 0);
ced45aab72 1409) strbuf_release(&sepbuf);
ffd7cae405 1410) return ret;

protocol.c
6da1f1a920  31) return protocol_v0_string;
6da1f1a920  33) return protocol_v1_string;
6da1f1a920  37) die(_("Unrecognized protocol version"));
6da1f1a920  39) die(_("Unrecognized protocol_version"));
6da1f1a920  76) return;
6da1f1a920 112) ALLOC_ARRAY(tmp_allowed_versions, tmp_nr);
6da1f1a920 113) copy_array(tmp_allowed_versions, allowed_versions, tmp_nr,
6da1f1a920 122) for (i = 1; i < nr_allowed_versions; i++)
6da1f1a920 123) if (tmp_allowed_versions[i] == config_version) {
6da1f1a920 124) SWAP(tmp_allowed_versions[0],
6da1f1a920 131) strbuf_addf(advert, ":version=%s",
6da1f1a920 132) format_protocol_version(tmp_allowed_versions[i]));

rebase-interactive.c
c27b32f0ec  15) static enum missing_commit_check_level 
get_missing_commit_check_level(void)
c27b32f0ec  19) if (git_config_get_value("rebase.missingcommitscheck", 
&value) ||
c27b32f0ec  20) !strcasecmp("ignore", value))
c27b32f0ec  21) return MISSING_COMMIT_CHECK_IGNORE;
c27b32f0ec  22) if (!strcasecmp("warn", value))
c27b32f0ec  23) return MISSING_COMMIT_CHECK_WARN;
c27b32f0ec  24) if (!strcasecmp("error", value))
c27b32f0ec  25) return MISSING_COMMIT_CHECK_ERROR;
c27b32f0ec  26) warning(_("unrecognized setting %s for option "
c27b32f0ec  28) return MISSING_COMMIT_CHECK_IGNORE;
2dd989a694  31) void append_todo_help(unsigned keep_empty, int 
command_count,
2dd989a694  52) unsigned edit_todo = !(shortrevisions && shortonto);
2dd989a694  54) if (!edit_todo) {
2dd989a694  55) strbuf_addch(buf, '\n');
2dd989a694  56) strbuf_commented_addf(buf, Q_("Rebase %s onto %s (%d 
command)",
e5b1c9d929  90) int edit_todo_list(struct repository *r, struct 
todo_list *todo_list,
e5b1c9d929  95) unsigned initial = shortrevisions && shortonto;
e5b1c9d929  97) if (initial) {
e5b1c9d929  98) todo_list_write_to_file(r, todo_list, todo_file, 
shortrevisions, shortonto,
e5b1c9d929 101) if (copy_file(rebase_path_todo_backup(), todo_file, 0666))
e5b1c9d929 102) return error(_("could not copy '%s' to '%s'."), todo_file,
e5b1c9d929 105) todo_list_parse_insn_buffer(r, todo_list->buf.buf, 
todo_list);
e5b1c9d929 106) todo_list_write_to_file(r, todo_list, todo_file, NULL, 
NULL, -1,
e5b1c9d929 110) if (launch_sequence_editor(todo_file, &new_todo->buf, NULL))
e5b1c9d929 111) return -2;
e5b1c9d929 113) strbuf_stripspace(&new_todo->buf, 1);
e5b1c9d929 114) if (initial && new_todo->buf.len == 0)
e5b1c9d929 115) return -3;
e5b1c9d929 117) if (!initial)
e5b1c9d929 118) todo_list_parse_insn_buffer(r, new_todo->buf.buf, new_todo);
e5b1c9d929 120) return 0;
c27b32f0ec 123) define_commit_slab(commit_seen, unsigned char);
c27b32f0ec 130) int todo_list_check(struct todo_list *old_todo, struct 
todo_list *new_todo)
c27b32f0ec 132) enum missing_commit_check_level check_level = 
get_missing_commit_check_level();
c27b32f0ec 133) struct strbuf missing = STRBUF_INIT;
c27b32f0ec 134) int res = 0, i;
c27b32f0ec 137) init_commit_seen(&commit_seen);
c27b32f0ec 139) if (check_level == MISSING_COMMIT_CHECK_IGNORE)
c27b32f0ec 140) goto leave_check;
c27b32f0ec 143) for (i = 0; i < new_todo->nr; i++) {
c27b32f0ec 144) struct commit *commit = new_todo->items[i].commit;
c27b32f0ec 145) if (commit)
c27b32f0ec 146) *commit_seen_at(&commit_seen, commit) = 1;
c27b32f0ec 150) for (i = old_todo->nr - 1; i >= 0; i--) {
c27b32f0ec 151) struct todo_item *item = old_todo->items + i;
c27b32f0ec 152) struct commit *commit = item->commit;
c27b32f0ec 153) if (commit && !*commit_seen_at(&commit_seen, commit)) {
c27b32f0ec 154) strbuf_addf(&missing, " - %s %.*s\n",
c27b32f0ec 155) find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV),
c27b32f0ec 157)     old_todo->buf.buf + item->arg_offset);
c27b32f0ec 158) *commit_seen_at(&commit_seen, commit) = 1;
c27b32f0ec 163) if (!missing.len)
c27b32f0ec 164) goto leave_check;
c27b32f0ec 166) if (check_level == MISSING_COMMIT_CHECK_ERROR)
c27b32f0ec 167) res = 1;
c27b32f0ec 169) fprintf(stderr,
c27b32f0ec 174) fputs(missing.buf, stderr);
c27b32f0ec 175) strbuf_release(&missing);
c27b32f0ec 177) fprintf(stderr, _("To avoid this message, use \"drop\" to "
c27b32f0ec 184) clear_commit_seen(&commit_seen);
c27b32f0ec 185) return res;

remote-curl.c
6da1f1a920  344) return 0;
34a9469d6a  363) return;
34a9469d6a  373) die("invalid server response; expected service, got 
flush packet");
240fb9b7a0  392) } else if (!strcmp(line, "version 2")) {
34a9469d6a  397) d->proto_git = 1;
e586e7df7c  399) } else if (skip_prefix(line, "ERR ", &p)) {
e586e7df7c  400) die(_("remote error: %s"), p);

repository.c
rerere.c
e1ff0a32e4  598) if (repo_read_index(r) < 0)
3a95f31d1c  708) repo_hold_locked_index(r, &index_lock, LOCK_DIE_ON_ERROR);
e1ff0a32e4 1110) if (repo_read_index(r) < 0)

revision.c
d5d2e93577  109) static int path_and_oids_cmp(const void 
*hashmap_cmp_fn_data,
d5d2e93577  114) return strcmp(e1->path, e2->path);
d5d2e93577  117) static void paths_and_oids_init(struct hashmap *map)
d5d2e93577  119) hashmap_init(map, (hashmap_cmp_fn) path_and_oids_cmp, 
NULL, 0);
d5d2e93577  120) }
d5d2e93577  122) static void paths_and_oids_clear(struct hashmap *map)
d5d2e93577  126) hashmap_iter_init(map, &iter);
d5d2e93577  128) while ((entry = (struct path_and_oids_entry 
*)hashmap_iter_next(&iter))) {
d5d2e93577  129) oidset_clear(&entry->trees);
d5d2e93577  130) free(entry->path);
d5d2e93577  133) hashmap_free(map, 1);
d5d2e93577  134) }
d5d2e93577  136) static void paths_and_oids_insert(struct hashmap *map,
d5d2e93577  140) int hash = strhash(path);
d5d2e93577  144) hashmap_entry_init(&key, hash);
d5d2e93577  147) key.path = (char *)path;
d5d2e93577  148) oidset_init(&key.trees, 0);
d5d2e93577  150) if (!(entry = (struct path_and_oids_entry 
*)hashmap_get(map, &key, NULL))) {
d5d2e93577  151) entry = xcalloc(1, sizeof(struct path_and_oids_entry));
d5d2e93577  152) hashmap_entry_init(entry, hash);
d5d2e93577  153) entry->path = xstrdup(key.path);
d5d2e93577  154) oidset_init(&entry->trees, 16);
d5d2e93577  155) hashmap_put(map, entry);
d5d2e93577  158) oidset_insert(&entry->trees, oid);
d5d2e93577  159) }
d5d2e93577  161) static void add_children_by_path(struct repository *r,
d5d2e93577  168) if (!tree)
d5d2e93577  169) return;
d5d2e93577  171) if (parse_tree_gently(tree, 1) < 0)
d5d2e93577  172) return;
d5d2e93577  174) init_tree_desc(&desc, tree->buffer, tree->size);
d5d2e93577  175) while (tree_entry(&desc, &entry)) {
d5d2e93577  176) switch (object_type(entry.mode)) {
5dde8fc6df  178) paths_and_oids_insert(map, entry.path, &entry.oid);
d5d2e93577  180) if (tree->object.flags & UNINTERESTING) {
5dde8fc6df  181) struct tree *child = lookup_tree(r, &entry.oid);
d5d2e93577  182) if (child)
d5d2e93577  183) child->object.flags |= UNINTERESTING;
d5d2e93577  185) break;
d5d2e93577  187) if (tree->object.flags & UNINTERESTING) {
5dde8fc6df  188) struct blob *child = lookup_blob(r, &entry.oid);
d5d2e93577  189) if (child)
d5d2e93577  190) child->object.flags |= UNINTERESTING;
d5d2e93577  192) break;
d5d2e93577  195) break;
d5d2e93577  199) free_tree_buffer(tree);
f1f5de442f  202) void mark_trees_uninteresting_sparse(struct repository *r,
d5d2e93577  205) unsigned has_interesting = 0, has_uninteresting = 0;
f1f5de442f  212) oidset_iter_init(trees, &iter);
d5d2e93577  213) while ((!has_interesting || !has_uninteresting) &&
f1f5de442f  215) struct tree *tree = lookup_tree(r, oid);
f1f5de442f  217) if (!tree)
f1f5de442f  218) continue;
d5d2e93577  220) if (tree->object.flags & UNINTERESTING)
d5d2e93577  221) has_uninteresting = 1;
d5d2e93577  223) has_interesting = 1;
d5d2e93577  227) if (!has_uninteresting || !has_interesting)
d5d2e93577  228) return;
d5d2e93577  230) paths_and_oids_init(&map);
d5d2e93577  232) oidset_iter_init(trees, &iter);
d5d2e93577  233) while ((oid = oidset_iter_next(&iter))) {
d5d2e93577  234) struct tree *tree = lookup_tree(r, oid);
d5d2e93577  235) add_children_by_path(r, tree, &map);
d5d2e93577  238) hashmap_iter_init(&map, &map_iter);
d5d2e93577  239) while ((entry = hashmap_iter_next(&map_iter)))
d5d2e93577  240) mark_trees_uninteresting_sparse(r, &entry->trees);
d5d2e93577  242) paths_and_oids_clear(&map);
e1ff0a32e4 1690) repo_read_index(revs->repo);
3a7a698e93 1749) if (get_oid_with_context(revs->repo, a_name, oc_flags, 
&a_oid, a_oc) ||
3a7a698e93 1750)     get_oid_with_context(revs->repo, b_name, oc_flags, 
&b_oid, b_oc))

sequencer.c
e5b1c9d929   58) GIT_PATH_FUNC(rebase_path_todo_backup, 
"rebase-merge/git-rebase-todo.backup")
e1ff0a32e4  449) static int error_dirty_index(struct repository *repo, 
struct replay_opts *opts)
e1ff0a32e4  451) if (repo_read_index_unmerged(repo))
e1ff0a32e4  486) repo_read_index(r);
1d18d7581c 1118) void commit_post_rewrite(struct repository *r,
1d18d7581c 1128) finish_copy_notes_for_rewrite(r, cfg, "Notes added by 
'git commit --amend'");
1d18d7581c 1409) commit_post_rewrite(r, current_head, oid);
e1ff0a32e4 1745) return error_dirty_index(r, opts);
5d94d54564 1996) void todo_list_release(struct todo_list *todo_list)
d836079ec2 2024) item->arg_offset = bol - buf;
d836079ec2 2051) item->arg_offset = bol - buf;
d836079ec2 2063) item->arg_offset = bol - buf;
d836079ec2 2077) item->arg_offset = bol - buf;
d836079ec2 2089) bol = end_of_object_name + strspn(end_of_object_name, " 
\t");
d836079ec2 2090) item->arg_offset = bol - buf;
d836079ec2 2091) item->arg_len = (int)(eol - bol);
5d94d54564 2100) int todo_list_parse_insn_buffer(struct repository *r, 
char *buf,
2b71595d47 2107) todo_list->current = todo_list->nr = 0;
d836079ec2 2119) if (parse_insn_line(r, item, buf, p, eol)) {
2b71595d47 2122) item->command = TODO_COMMENT + 1;
d836079ec2 2123) item->arg_offset = p - buf;
2b71595d47 2124) item->arg_len = (int)(eol - p);
2b71595d47 2125) item->commit = NULL;
5d94d54564 2200) res = todo_list_parse_insn_buffer(r, 
todo_list->buf.buf, todo_list);
5d94d54564 2231)     !todo_list_parse_insn_buffer(r, done.buf.buf, &done))
d836079ec2 2468) item->arg_offset = 0;
e1ff0a32e4 2829) if (discard_index(r->index) < 0 || repo_read_index(r) < 0)
3a95f31d1c 2953) if (repo_hold_locked_index(r, &lock, 
LOCK_REPORT_ON_ERROR) < 0)
e1ff0a32e4 2998) if (repo_read_index_unmerged(r)) {
3a95f31d1c 3071) if (repo_hold_locked_index(r, &lock, 
LOCK_REPORT_ON_ERROR) < 0) {
e1ff0a32e4 3252)      repo_read_index(r) < 0))
e1ff0a32e4 3274) repo_read_index(r);
0d6caa2d08 3275) init_merge_options(&o, r);
d836079ec2 3507) const char *arg = todo_list->buf.buf + item->arg_offset;
d836079ec2 3595) char *end_of_arg = (char *)(arg + item->arg_len);
d836079ec2 3600) res = do_exec(r, arg);
d836079ec2 3618) if ((res = do_label(r, arg, item->arg_len)))
d836079ec2 3621) if ((res = do_reset(r, arg, item->arg_len, opts)))
e1ff0a32e4 3950) res = error_dirty_index(r, opts);
0566a4f68e 4372) strbuf_addf(out, "%s onto\n", cmd_label);
0566a4f68e 4382) strbuf_addf(out, "\n%c Branch %s\n", comment_line_char, 
entry->string);
0566a4f68e 4384) strbuf_addch(out, '\n');
0566a4f68e 4397) strbuf_addf(out, "%s %s\n", cmd_reset,
0566a4f68e 4411) strbuf_addf(out, "%s onto\n", cmd_reset);
0566a4f68e 4415) strbuf_addf(out, "%s %s # %s\n",
0566a4f68e 4425) strbuf_addf(out, "%s\n", entry->string);
0566a4f68e 4428) strbuf_addf(out, "%s %s\n",
0566a4f68e 4429)     cmd_label, entry->string);
0566a4f68e 4451) int sequencer_make_script(struct repository *r, struct 
strbuf *out, int argc,
0566a4f68e 4499) strbuf_addf(out, "%c ", comment_line_char);
0566a4f68e 4500) strbuf_addf(out, "%s %s ", insn,
0566a4f68e 4502) pretty_print_commit(&pp, commit, out);
0566a4f68e 4503) strbuf_addch(out, '\n');
8414c890aa 4508) static void todo_list_add_exec_commands(struct 
todo_list *todo_list,
8414c890aa 4511) struct strbuf *buf = &todo_list->buf;
8414c890aa 4512) size_t base_offset = buf->len;
8414c890aa 4513) int i, insert, nr = 0, alloc = 0;
8414c890aa 4514) struct todo_item *items = NULL, *base_items = NULL;
8414c890aa 4516) base_items = xcalloc(commands->nr, sizeof(struct 
todo_item));
8414c890aa 4517) for (i = 0; i < commands->nr; ++i) {
8414c890aa 4518) size_t command_len = strlen(commands->items[i].string);
8414c890aa 4520) strbuf_addstr(buf, commands->items[i].string);
8414c890aa 4521) strbuf_addch(buf, '\n');
8414c890aa 4523) base_items[i].command = TODO_EXEC;
8414c890aa 4524) base_items[i].offset_in_buf = base_offset;
8414c890aa 4525) base_items[i].arg_offset = base_offset + strlen("exec ");
8414c890aa 4526) base_items[i].arg_len = command_len - strlen("exec ");
8414c890aa 4528) base_offset += command_len + 1;
8414c890aa 4537) for (i = 0; i < todo_list->nr; i++) {
8414c890aa 4538) enum todo_command command = todo_list->items[i].command;
8414c890aa 4539) if (insert >= 0 && command != TODO_COMMENT && 
!is_fixup(command)) {
8414c890aa 4540) ALLOC_GROW(items, nr + commands->nr, alloc);
8414c890aa 4541) COPY_ARRAY(items + nr, base_items, commands->nr);
8414c890aa 4542) nr += commands->nr;
8414c890aa 4546) ALLOC_GROW(items, nr + 1, alloc);
8414c890aa 4547) items[nr++] = todo_list->items[i];
8414c890aa 4549) if (command == TODO_PICK || command == TODO_MERGE || 
is_fixup(command))
8414c890aa 4554) if (insert >= 0 || nr == todo_list->nr) {
8414c890aa 4555) ALLOC_GROW(items, nr + commands->nr, alloc);
8414c890aa 4556) COPY_ARRAY(items + nr, base_items, commands->nr);
8414c890aa 4557) nr += commands->nr;
8414c890aa 4560) free(base_items);
8414c890aa 4561) FREE_AND_NULL(todo_list->items);
8414c890aa 4562) todo_list->items = items;
8414c890aa 4563) todo_list->nr = nr;
8414c890aa 4564) todo_list->alloc = alloc;
8414c890aa 4571) int sequencer_add_exec_commands(struct repository *r,
8414c890aa 4579) return error_errno(_("could not read '%s'."), todo_file);
8414c890aa 4581) if (todo_list_parse_insn_buffer(r, todo_list.buf.buf, 
&todo_list)) {
8414c890aa 4586) todo_list_add_exec_commands(&todo_list, commands);
8414c890aa 4587) res = todo_list_write_to_file(r, &todo_list, todo_file, 
NULL, NULL, -1, 0);
0cce4a2756 4588) todo_list_release(&todo_list);
8414c890aa 4590) if (res)
8414c890aa 4591) return error_errno(_("could not write '%s'."), todo_file);
8414c890aa 4592) return 0;
cf18b3f6c9 4595) static void todo_list_to_strbuf(struct repository *r, 
struct todo_list *todo_list,
cf18b3f6c9 4599) int i, max = todo_list->nr;
cf18b3f6c9 4601) if (num > 0 && num < max)
cf18b3f6c9 4602) max = num;
cf18b3f6c9 4604) for (item = todo_list->items, i = 0; i < max; i++, 
item++) {
cf18b3f6c9 4607) strbuf_addf(buf, "%.*s\n", item->arg_len,
3ebafef416 4608)     todo_list->buf.buf + item->arg_offset);
cf18b3f6c9 4614) strbuf_addch(buf, command_to_char(item->command));
cf18b3f6c9 4616) strbuf_addstr(buf, command_to_string(item->command));
cf18b3f6c9 4626) strbuf_addstr(buf, " -c");
cf18b3f6c9 4628) strbuf_addstr(buf, " -C");
cf18b3f6c9 4631) strbuf_addf(buf, " %s", oid);
cf18b3f6c9 4636) strbuf_addch(buf, '\n');
cf18b3f6c9 4638) strbuf_addf(buf, " %.*s\n", item->arg_len,
3ebafef416 4639)     todo_list->buf.buf + item->arg_offset);
cf18b3f6c9 4643) int todo_list_write_to_file(struct repository *r, 
struct todo_list *todo_list,
cf18b3f6c9 4648) struct strbuf buf = STRBUF_INIT;
cf18b3f6c9 4650) todo_list_to_strbuf(r, todo_list, &buf, num, flags);
2dd989a694 4651) if (flags & TODO_LIST_APPEND_TODO_HELP)
2dd989a694 4652) append_todo_help(flags & TODO_LIST_KEEP_EMPTY, 
count_commands(todo_list),
cf18b3f6c9 4655) res = write_message(buf.buf, buf.len, file, 0);
3ebafef416 4656) strbuf_release(&buf);
cf18b3f6c9 4658) return res;
c27b32f0ec 4667) int check_todo_list_from_file(struct repository *r)
c27b32f0ec 4669) struct todo_list old_todo = TODO_LIST_INIT, new_todo = 
TODO_LIST_INIT;
c27b32f0ec 4670) int res = 0;
c27b32f0ec 4672) if (strbuf_read_file_or_whine(&new_todo.buf, 
rebase_path_todo()) < 0) {
878056005e 4673) res = -1;
c27b32f0ec 4674) goto out;
c27b32f0ec 4677) if (strbuf_read_file_or_whine(&old_todo.buf, 
rebase_path_todo_backup()) < 0) {
c27b32f0ec 4679) goto out;
c27b32f0ec 4682) res = todo_list_parse_insn_buffer(r, old_todo.buf.buf, 
&old_todo);
c27b32f0ec 4683) if (!res)
c27b32f0ec 4684) res = todo_list_parse_insn_buffer(r, new_todo.buf.buf, 
&new_todo);
c27b32f0ec 4685) if (!res)
c27b32f0ec 4686) res = todo_list_check(&old_todo, &new_todo);
c27b32f0ec 4687) if (res)
c27b32f0ec 4688) fprintf(stderr, _(edit_todo_list_advice));
c27b32f0ec 4690) todo_list_release(&old_todo);
c27b32f0ec 4691) todo_list_release(&new_todo);
98b29e0607 4697) static int skip_unnecessary_picks(struct repository *r,
98b29e0607 4704) for (i = 0; i < todo_list->nr; i++) {
98b29e0607 4705) struct todo_item *item = todo_list->items + i;
98b29e0607 4727) if (todo_list_write_to_file(r, todo_list, done_path, 
NULL, NULL, i, 0)) {
98b29e0607 4732) MOVE_ARRAY(todo_list->items, todo_list->items + i, 
todo_list->nr - i);
98b29e0607 4733) todo_list->nr -= i;
98b29e0607 4734) todo_list->current = 0;
98b29e0607 4736) if (is_fixup(peek_command(todo_list, 0)))
98b29e0607 4737) record_in_rewritten(output_oid, peek_command(todo_list, 
0));
c1c074e0cc 4751) struct todo_list new_todo = TODO_LIST_INIT;
c1c074e0cc 4752) struct strbuf *buf = &todo_list->buf;
c1c074e0cc 4759) if (buf->len == 0) {
c1c074e0cc 4760) struct todo_item *item = append_new_todo(todo_list);
c1c074e0cc 4761) item->command = TODO_NOOP;
c1c074e0cc 4762) item->commit = NULL;
c1c074e0cc 4763) item->arg_len = item->arg_offset = item->flags = 
item->offset_in_buf = 0;
c1c074e0cc 4766) if (autosquash && todo_list_rearrange_squash(todo_list))
8414c890aa 4769) if (commands->nr)
c1c074e0cc 4770) todo_list_add_exec_commands(todo_list, commands);
c1c074e0cc 4772) if (count_commands(todo_list) == 0) {
33bc1844f7 4779) res = edit_todo_list(r, todo_list, &new_todo, 
shortrevisions,
33bc1844f7 4781) if (res == -1)
33bc1844f7 4783) else if (res == -2) {
33bc1844f7 4788) } else if (res == -3) {
c1c074e0cc 4791) todo_list_release(&new_todo);
c1c074e0cc 4796) if (todo_list_parse_insn_buffer(r, new_todo.buf.buf, 
&new_todo) ||
c1c074e0cc 4797)     todo_list_check(todo_list, &new_todo)) {
c1c074e0cc 4798) fprintf(stderr, _(edit_todo_list_advice));
c1c074e0cc 4800) todo_list_release(&new_todo);
98b29e0607 4805) if (opts->allow_ff && skip_unnecessary_picks(r, 
&new_todo, &oid)) {
98b29e0607 4806) todo_list_release(&new_todo);
c1c074e0cc 4810) if (todo_list_write_to_file(r, &new_todo, todo_file, 
NULL, NULL, -1,
c1c074e0cc 4812) todo_list_release(&new_todo);
c1c074e0cc 4813) return error_errno(_("could not write '%s'"), todo_file);
c1c074e0cc 4816) todo_list_release(&new_todo);
febebd99b6 4851) static int todo_list_rearrange_squash(struct todo_list 
*todo_list)
febebd99b6 4854) int rearranged = 0, *next, *tail, i, nr = 0, alloc = 0;
febebd99b6 4857) struct todo_item *items = NULL;
febebd99b6 4870)      NULL, todo_list->nr);
febebd99b6 4871) ALLOC_ARRAY(next, todo_list->nr);
febebd99b6 4872) ALLOC_ARRAY(tail, todo_list->nr);
febebd99b6 4873) ALLOC_ARRAY(subjects, todo_list->nr);
febebd99b6 4874) for (i = 0; i < todo_list->nr; i++) {
febebd99b6 4876) struct todo_item *item = todo_list->items + i;
febebd99b6 4923) - todo_list->items;
febebd99b6 4936) todo_list->items[i].command =
febebd99b6 4954) for (i = 0; i < todo_list->nr; i++) {
febebd99b6 4955) enum todo_command command = todo_list->items[i].command;
febebd99b6 4966) ALLOC_GROW(items, nr + 1, alloc);
febebd99b6 4967) items[nr++] = todo_list->items[cur];
febebd99b6 4972) FREE_AND_NULL(todo_list->items);
febebd99b6 4973) todo_list->items = items;
febebd99b6 4974) todo_list->nr = nr;
febebd99b6 4975) todo_list->alloc = alloc;
febebd99b6 4980) for (i = 0; i < todo_list->nr; i++)
febebd99b6 4987) return 0;
febebd99b6 4990) int rearrange_squash_in_todo_file(struct repository *r)
febebd99b6 4992) const char *todo_file = rebase_path_todo();
febebd99b6 4993) struct todo_list todo_list = TODO_LIST_INIT;
febebd99b6 4994) int res = 0;
febebd99b6 4996) if (strbuf_read_file_or_whine(&todo_list.buf, 
todo_file) < 0)
febebd99b6 4997) return -1;
febebd99b6 4998) if (todo_list_parse_insn_buffer(r, todo_list.buf.buf, 
&todo_list) < 0) {
febebd99b6 4999) todo_list_release(&todo_list);
febebd99b6 5000) return -1;
febebd99b6 5003) res = todo_list_rearrange_squash(&todo_list);
febebd99b6 5004) if (!res)
febebd99b6 5005) res = todo_list_write_to_file(r, &todo_list, todo_file, 
NULL, NULL, -1, 0);
febebd99b6 5007) todo_list_release(&todo_list);
febebd99b6 5009) if (res)
febebd99b6 5010) return error_errno(_("could not write '%s'."), todo_file);
febebd99b6 5011) return 0;

sha1-name.c
4e763fae87 sha1-name.c 1523) int get_oidf(struct object_id *oid, const 
char *fmt, ...)
4e763fae87 sha1-name.c 1527) struct strbuf sb = STRBUF_INIT;
4e763fae87 sha1-name.c 1529) va_start(ap, fmt);
4e763fae87 sha1-name.c 1530) strbuf_vaddf(&sb, fmt, ap);
4e763fae87 sha1-name.c 1531) va_end(ap);
4e763fae87 sha1-name.c 1533) ret = get_oid(sb.buf, oid);
4e763fae87 sha1-name.c 1534) strbuf_release(&sb);
4e763fae87 sha1-name.c 1536) return ret;
3a7a698e93 sha1-name.c 1624) static void 
diagnose_invalid_index_path(struct index_state *istate,
3a7a698e93 sha1-name.c 1638) pos = index_name_pos(istate, filename, 
namelen);
3a7a698e93 sha1-name.c 1641) if (pos < istate->cache_nr) {
3a7a698e93 sha1-name.c 1642) ce = istate->cache[pos];
3a7a698e93 sha1-name.c 1654) pos = index_name_pos(istate, fullname.buf, 
fullname.len);
3a7a698e93 sha1-name.c 1657) if (pos < istate->cache_nr) {
3a7a698e93 sha1-name.c 1658) ce = istate->cache[pos];
3a7a698e93 sha1-name.c 1771) diagnose_invalid_index_path(repo->index, 
stage, prefix, cp);

strbuf.c
bfc3fe33f6  252) void strbuf_vinsertf(struct strbuf *sb, size_t pos, 
const char *fmt, va_list ap)
bfc3fe33f6  258) if (pos > sb->len)
bfc3fe33f6  259) die("`pos' is too far after the end of the buffer");
bfc3fe33f6  260) va_copy(cp, ap);
bfc3fe33f6  261) len = vsnprintf(sb->buf + sb->len, 0, fmt, cp);
bfc3fe33f6  262) va_end(cp);
bfc3fe33f6  263) if (len < 0)
bfc3fe33f6  265) if (!len)
bfc3fe33f6  266) return; /* nothing to do */
bfc3fe33f6  267) if (unsigned_add_overflows(sb->len, len))
bfc3fe33f6  268) die("you want to use way too much memory");
bfc3fe33f6  269) strbuf_grow(sb, len);
bfc3fe33f6  270) memmove(sb->buf + pos + len, sb->buf + pos, sb->len - pos);
bfc3fe33f6  272) save = sb->buf[pos + len];
bfc3fe33f6  273) len2 = vsnprintf(sb->buf + pos, sb->alloc - sb->len, 
fmt, ap);
bfc3fe33f6  274) sb->buf[pos + len] = save;
bfc3fe33f6  275) if (len2 != len)
bfc3fe33f6  277) strbuf_setlen(sb, sb->len + len);
bfc3fe33f6  280) void strbuf_insertf(struct strbuf *sb, size_t pos, 
const char *fmt, ...)
bfc3fe33f6  283) va_start(ap, fmt);
bfc3fe33f6  284) strbuf_vinsertf(sb, pos, fmt, ap);
bfc3fe33f6  285) va_end(ap);
bfc3fe33f6  286) }
0c1599c33c  307) const char *strbuf_join_argv(struct strbuf *buf,
0c1599c33c  310) if (!argc)
0c1599c33c  311) return buf->buf;
0c1599c33c  313) strbuf_addstr(buf, *argv);
0c1599c33c  314) while (--argc) {
0c1599c33c  315) strbuf_addch(buf, delim);
0c1599c33c  316) strbuf_addstr(buf, *(++argv));
0c1599c33c  319) return buf->buf;
18f8e81091  442) strbuf_addch(sb, '\n');
18f8e81091  443) return 1;
18f8e81091  446) ch = hex2chr(placeholder + 1);
18f8e81091  447) if (ch < 0)
18f8e81091  448) return 0;
18f8e81091  449) strbuf_addch(sb, ch);
18f8e81091  450) return 3;

trailer.c
ced45aab72 1132) size_t origlen = out->len;
ced45aab72 1136) if (!opts->only_trailers && !opts->unfold && 
!opts->filter && !opts->separator) {
4681fe38e1 1151) if (!opts->filter || opts->filter(&tok, 
opts->filter_data)) {
4681fe38e1 1152) if (opts->unfold)
4681fe38e1 1153) unfold_value(&val);
ced45aab72 1155) if (opts->separator && out->len != origlen)
ced45aab72 1156) strbuf_addbuf(out, opts->separator);
e9da5de761 1157) if (!opts->value_only)
e9da5de761 1158) strbuf_addf(out, "%s: ", tok.buf);
e9da5de761 1159) strbuf_addbuf(out, &val);
ced45aab72 1160) if (!opts->separator)
ced45aab72 1161) strbuf_addch(out, '\n');
ced45aab72 1167) if (opts->separator && out->len != origlen) {
ced45aab72 1168) strbuf_addbuf(out, opts->separator);
ced45aab72 1171) if (opts->separator) {
ced45aab72 1172) strbuf_rtrim(out);

worktree.c
2ec5633ff4 587) char *get_worktree_config(struct repository *r)
2ec5633ff4 589) struct worktree **worktrees = get_worktrees(0);
2ec5633ff4 592) if (repository_format_worktree_config)
2ec5633ff4 593) path = repo_git_path(r, "config.worktree");
2ec5633ff4 594) else if (worktrees[0] && worktrees[1])
2ec5633ff4 595) path = NULL;
2ec5633ff4 597) path = repo_git_path(r, "config");
2ec5633ff4 599) free_worktrees(worktrees);
2ec5633ff4 600) return path;

wrapper.c
5efde212fc  70) die("Out of memory, malloc failed (tried to allocate %" 
PRIuMAX " bytes)",
5efde212fc  73) error("Out of memory, malloc failed (tried to allocate 
%" PRIuMAX " bytes)",

wt-status.c
3a95f31d1c 2378) fd = repo_hold_locked_index(r, &lock_file, 0);
1b0d968b34 2381) repo_update_index_if_able(r, &lock_file);

Commits introducing uncovered code:
Ævar Arnfjörð Bjarmason      97b202471: commit-graph write: use pack 
order when finding commits
Alban Gruin      0566a4f68: sequencer: make sequencer_make_script() 
write its script to a strbuf
Alban Gruin      2b71595d4: sequencer: changes in parse_insn_buffer()
Alban Gruin      2dd989a69: rebase-interactive: append_todo_help() changes
Alban Gruin      33bc1844f: sequencer: use edit_todo_list() in 
complete_action()
Alban Gruin      3ebafef41: sequencer: refactor transform_todos() to 
work on a todo_list
Alban Gruin      4d55dfd76: rebase-interactive: move 
transform_todo_file() to rebase--interactive.c
Alban Gruin      5d94d5456: sequencer: make the todo_list structure public
Alban Gruin      8414c890a: sequencer: refactor 
sequencer_add_exec_commands() to work on a todo_list
Alban Gruin      98b29e060: sequencer: refactor skip_unnecessary_picks() 
to work on a todo_list
Alban Gruin      c1c074e0c: sequencer: change complete_action() to use 
the refactored functions
Alban Gruin      c27b32f0e: sequencer: refactor check_todo_list() to 
work on a todo_list
Alban Gruin      cf18b3f6c: sequencer: introduce todo_list_write_to_file()
Alban Gruin      d836079ec: sequencer: remove the 'arg' field from todo_item
Alban Gruin      e5b1c9d92: rebase-interactive: rewrite edit_todo_list() 
to handle the initial edit
Alban Gruin      febebd99b: sequencer: refactor rearrange_squash() to 
work on a todo_list
Anders Waldenborg      18f8e8109: strbuf: separate callback for 
strbuf_expand:ing literals
Anders Waldenborg      4681fe38e: pretty: allow showing specific trailers
Anders Waldenborg      b755bf6f8: pretty: allow %(trailers) options with 
explicit value
Anders Waldenborg      ced45aab7: pretty: add support for separator 
option in %(trailers)
Anders Waldenborg      e9da5de76: pretty: add support for "valueonly" 
option in %(trailers)
Anders Waldenborg      ffd7cae40: pretty: single return path in 
%(trailers) handling
Barret Rhoden      07d04b919: blame: add a config option to mark ignored 
lines
Barret Rhoden      e7973c851: blame: add the ability to ignore commits 
and their changes
Barret Rhoden      ef644c415: Move init_skiplist() outside of fsck
Derrick Stolee      3d036eb0d: pack-objects: create pack.useSparse setting
Derrick Stolee      4f6d26b16: list-objects: consume sparse tree walk
Derrick Stolee      d5d2e9357: revision: implement sparse algorithm
Derrick Stolee      f1f5de442: revision: add mark_tree_uninteresting_sparse
Jeff King      240fb9b7a: remote-curl: tighten "version 2" check for 
smart-http
Jeff King      34a9469d6: remote-curl: refactor smart-http discovery
Jiang Xin      a338d1039: pack-redundant: consistent sort method
Jiang Xin      cb7e0336f: pack-redundant: rename pack_list.all_objects
Joel Teichroeb      cdca49bc4: stash: convert drop and clear to builtin
Joel Teichroeb      e1d01876a: stash: convert pop to builtin
Joel Teichroeb      f596f3366: stash: convert branch to builtin
Joel Teichroeb      f6bbd7812: stash: convert apply to builtin
Johannes Schindelin      26799a208: stash: optionally use the scripted 
version again
Johannes Schindelin      97f56073c: ident: add the ability to provide a 
"fallback identity"
Johannes Schindelin      bec65d5b7: tests: add a special setup where 
stash.useBuiltin is off
Josh Steadmon      6da1f1a92: protocol: advertise multiple supported 
versions
Josh Steadmon      e586e7df7: remote-curl: die on server-side errors
Junio C Hamano      5dde8fc6d: Merge branch 'ds/push-sparse-tree-walk' 
into pu
Junio C Hamano      b6b4172bf: Merge branch 'nd/the-index-final' into pu
Liam Beguin      0cce4a275: rebase -i -x: add exec commands via the 
rebase--helper
Linus Torvalds      acdd37769: Add 'human' date format
Martin Koegler      5efde212f: zlib.c: use size_t for size
Matthew Kraai      ed5d77f7d: stash: fix segmentation fault when files 
were added with intent
Nguyễn Thái Ngọc Duy      059343267: diff.c: convert --no-prefix
Nguyễn Thái Ngọc Duy      06800238c: config.c: avoid git_path() in 
do_git_config_sequence()
Nguyễn Thái Ngọc Duy      08339886b: parse-options: avoid magic return codes
Nguyễn Thái Ngọc Duy      08d080bf7: diff.c: convert --word-diff
Nguyễn Thái Ngọc Duy      0d6caa2d0: merge-recursive.c: remove implicit 
dependency on the_index
Nguyễn Thái Ngọc Duy      0eb03c4cd: diff.c: convert --stat*
Nguyễn Thái Ngọc Duy      10e07ecc0: diff.c: convert -M|--find-renames
Nguyễn Thái Ngọc Duy      150fe065f: read-cache.c: remove the_* from 
index_has_changes()
Nguyễn Thái Ngọc Duy      1b0d968b3: read-cache.c: replace 
update_index_if_able with repo_&
Nguyễn Thái Ngọc Duy      1d18d7581: notes-utils.c: remove 
the_repository references
Nguyễn Thái Ngọc Duy      1d2890f4f: diff.c: convert --submodule
Nguyễn Thái Ngọc Duy      1d8598834: diff.c: convert --textconv
Nguyễn Thái Ngọc Duy      1efc2689d: diff.c: convert --diff-algorithm
Nguyễn Thái Ngọc Duy      2156b1fd0: diff.c: convert --patience
Nguyễn Thái Ngọc Duy      221d67669: diff.c: convert --color-moved
Nguyễn Thái Ngọc Duy      26c50430d: range-diff: use parse_options() 
instead of diff_opt_parse()
Nguyễn Thái Ngọc Duy      2ec5633ff: worktree.c: add get_worktree_config()
Nguyễn Thái Ngọc Duy      350a71f2f: diff.c: convert --relative
Nguyễn Thái Ngọc Duy      3a7a698e9: sha1-name.c: remove implicit 
dependency on the_index
Nguyễn Thái Ngọc Duy      3a95f31d1: repository.c: replace 
hold_locked_index() with repo_hold_locked_index()
Nguyễn Thái Ngọc Duy      3d810d186: diff.c: convert --output-*
Nguyễn Thái Ngọc Duy      447867144: cache.h: flip 
NO_THE_INDEX_COMPATIBILITY_MACROS switch
Nguyễn Thái Ngọc Duy      5866e9ce9: diff.c: convert --find-object
Nguyễn Thái Ngọc Duy      58c7ef398: diff.c: convert --[no-]compact-summary
Nguyễn Thái Ngọc Duy      6643eb7bb: diff.c: convert -U|--unified
Nguyễn Thái Ngọc Duy      6c0ec4f72: diff.c: convert --line-prefix
Nguyễn Thái Ngọc Duy      6d0300b2e: diff.c: convert --binary
Nguyễn Thái Ngọc Duy      6f11fd5ed: config: add --move-to
Nguyễn Thái Ngọc Duy      7c33a67a2: diff.c: convert --color-moved-ws
Nguyễn Thái Ngọc Duy      8b70e4177: diff.c: convert --ws-error-highlight
Nguyễn Thái Ngọc Duy      8f7c7f555: config.c: add 
repo_config_set_worktree_gently()
Nguyễn Thái Ngọc Duy      8fc6b47cd: diff.c: convert --[no-]abbrev
Nguyễn Thái Ngọc Duy      963389f6e: diff --no-index: use 
parse_options() instead of diff_opt_parse()
Nguyễn Thái Ngọc Duy      97e53999c: diff.c: convert -C|--find-copies
Nguyễn Thái Ngọc Duy      9b4ae5190: parse-options: allow ll_callback 
with OPTION_CALLBACK
Nguyễn Thái Ngọc Duy      a12c1ff3a: config: factor out 
set_config_source_file()
Nguyễn Thái Ngọc Duy      afe77a4dd: diff.c: convert --word-diff-regex
Nguyễn Thái Ngọc Duy      b065b6607: diff.c: convert --anchored
Nguyễn Thái Ngọc Duy      b74a81799: diff.c: convert --diff-filter
Nguyễn Thái Ngọc Duy      b9b760ed1: diff.c: convert -B|--break-rewrites
Nguyễn Thái Ngọc Duy      c2dcec4fd: diff.c: convert --[no-]follow
Nguyễn Thái Ngọc Duy      d071ebcc8: diff.c: convert -S|-G
Nguyễn Thái Ngọc Duy      d7cf3a96e: merge-recursive.c: remove implicit 
dependency on the_repository
Nguyễn Thái Ngọc Duy      da9db54b3: diff.c: allow --no-color-moved-ws
Nguyễn Thái Ngọc Duy      dba093ddc: grep: use grep_opt->repo instead of 
explict repo argument
Nguyễn Thái Ngọc Duy      e1ff0a32e: read-cache.c: kill read_index()
Nguyễn Thái Ngọc Duy      f3b49b7f9: diff.c: convert --color-words
Nguyễn Thái Ngọc Duy      f8d10810d: diff.c: convert --dirstat and friends
Paul-Sebastian Ungureanu      0c1599c33: strbuf.c: add `strbuf_join_argv()`
Paul-Sebastian Ungureanu      168e6cff5: stash: optimize 
`get_untracked_files()` and `check_changes()`
Paul-Sebastian Ungureanu      1f5a011d9: stash: convert create to builtin
Paul-Sebastian Ungureanu      4e763fae8: sha1-name.c: add `get_oidf()` 
which acts like `get_oid()`
Paul-Sebastian Ungureanu      51809c70c: stash: convert 
`stash--helper.c` into `stash.c`
Paul-Sebastian Ungureanu      559edead8: stash: replace all `write-tree` 
child processes with API calls
Paul-Sebastian Ungureanu      847eb0b0a: stash: convert store to builtin
Paul-Sebastian Ungureanu      9a95010a1: stash: make push -q quiet
Paul-Sebastian Ungureanu      9b77b07ba: stash: convert list to builtin
Paul-Sebastian Ungureanu      b4493f269: stash: convert show to builtin
Paul-Sebastian Ungureanu      bfc3fe33f: strbuf.c: add 
`strbuf_insertf()` and `strbuf_vinsertf()`
Paul-Sebastian Ungureanu      cf5b27d69: stash: convert save to builtin
Paul-Sebastian Ungureanu      fa38428f7: stash: convert push to builtin
René Scharfe      878056005: sequencer: factor out 
strbuf_read_file_or_whine()
Stephen P. Smith      6943bd42f: Add `human` format to test-tool
Stephen P. Smith      86177eb5c: Remove the proposed use of auto as 
secondary way to specify human
Sun Chao      e4e2c2884: pack-redundant: new algorithm to find min packs



Uncovered code in 'jch' not in 'next'
----------------------------------------

builtin/archive.c
01f9ec64c8 builtin/archive.c  63) if (starts_with(reader.line, "NACK "))
01f9ec64c8 builtin/archive.c  64) die(_("git archive: NACK %s"), 
reader.line + 5);

builtin/bisect--helper.c
5e82c3dd22 builtin/bisect--helper.c 162) if (get_oid_commit(commit, &oid))
5e82c3dd22 builtin/bisect--helper.c 163) return error(_("'%s' is not a 
valid commit"), commit);
5e82c3dd22 builtin/bisect--helper.c 164) strbuf_addstr(&branch, commit);
5e82c3dd22 builtin/bisect--helper.c 172) strbuf_release(&branch);
5e82c3dd22 builtin/bisect--helper.c 173) argv_array_clear(&argv);
5e82c3dd22 builtin/bisect--helper.c 174) return error(_("could not check 
out original"
0f30233a11 builtin/bisect--helper.c 215) retval = error(_("Bad 
bisect_write argument: %s"), state);
0f30233a11 builtin/bisect--helper.c 216) goto finish;
0f30233a11 builtin/bisect--helper.c 220) retval = error(_("couldn't get 
the oid of the rev '%s'"), rev);
0f30233a11 builtin/bisect--helper.c 221) goto finish;
0f30233a11 builtin/bisect--helper.c 226) retval = -1;
0f30233a11 builtin/bisect--helper.c 227) goto finish;
0f30233a11 builtin/bisect--helper.c 232) retval = 
error_errno(_("couldn't open the file '%s'"), git_path_bisect_log());
0f30233a11 builtin/bisect--helper.c 233) goto finish;
129a6cf344 builtin/bisect--helper.c 329) yesno = git_prompt(_("Are you 
sure [Y/n]? "), PROMPT_ECHO);
129a6cf344 builtin/bisect--helper.c 330) if (starts_with(yesno, "N") || 
starts_with(yesno, "n"))
129a6cf344 builtin/bisect--helper.c 331) retval = -1;
129a6cf344 builtin/bisect--helper.c 332) goto finish;
129a6cf344 builtin/bisect--helper.c 338) retval = 
error(_(need_bisect_start_warning),
450ebb7359 builtin/bisect--helper.c 389) return error(_("invalid 
argument %s for 'git bisect terms'.\n"
06f5608c14 builtin/bisect--helper.c 404) return -1;
06f5608c14 builtin/bisect--helper.c 407) retval = -1;
06f5608c14 builtin/bisect--helper.c 408) goto finish;
06f5608c14 builtin/bisect--helper.c 413) retval = -1;
06f5608c14 builtin/bisect--helper.c 452) no_checkout = 1;
06f5608c14 builtin/bisect--helper.c 474)  !one_of(arg, "--term-good", 
"--term-bad", NULL)) {
06f5608c14 builtin/bisect--helper.c 475) return error(_("unrecognized 
option: '%s'"), arg);
06f5608c14 builtin/bisect--helper.c 510) if (get_oid("HEAD", &head_oid))
06f5608c14 builtin/bisect--helper.c 511) return error(_("bad HEAD - I 
need a HEAD"));
06f5608c14 builtin/bisect--helper.c 526) retval = error(_("checking out 
'%s' failed."
06f5608c14 builtin/bisect--helper.c 547) return error(_("won't bisect on 
cg-seek'ed tree"));
06f5608c14 builtin/bisect--helper.c 550) return error(_("bad HEAD - 
strange symbolic ref"));
06f5608c14 builtin/bisect--helper.c 558) return -1;
06f5608c14 builtin/bisect--helper.c 576) retval = -1;
06f5608c14 builtin/bisect--helper.c 577) goto finish;
06f5608c14 builtin/bisect--helper.c 588) retval = -1;
06f5608c14 builtin/bisect--helper.c 589) goto finish;
06f5608c14 builtin/bisect--helper.c 600) retval = -1;
5e82c3dd22 builtin/bisect--helper.c 677) return error(_("--bisect-reset 
requires either no argument or a commit"));
0f30233a11 builtin/bisect--helper.c 681) return error(_("--bisect-write 
requires either 4 or 5 arguments"));
4fbdbd5bff builtin/bisect--helper.c 687) return 
error(_("--check-and-set-terms requires 3 arguments"));
129a6cf344 builtin/bisect--helper.c 693) return 
error(_("--bisect-next-check requires 2 or 3 arguments"));

builtin/branch.c
711d28e2e4 builtin/branch.c 370) strbuf_addf(&local, 
"%s%%(if:notequals=*)%%(HEAD)%%(then)%%(if)%%(worktreepath)%%(then)%%(worktreepath) 
%%(end)%%(end)%s",
0ecb1fc726 builtin/branch.c 460) die(_("could not resolve HEAD"));
0ecb1fc726 builtin/branch.c 466) die(_("HEAD (%s) points outside of 
refs/heads/"), refname);

builtin/multi-pack-index.c
334e9745a6 49) die(_("--batch-size option is only for 'repack' 
subcommand"));

builtin/pull.c
b19eee9066 647) argv_array_push(&args, opt_cleanup);

builtin/rebase.c
21853626ea  258) write_file(state_dir_path("verbose", opts), "%s", "");
21853626ea  260) write_file(state_dir_path("strategy", opts), "%s",
21853626ea  263) write_file(state_dir_path("strategy_opts", opts), "%s",
21853626ea  270) write_file(state_dir_path("gpg_sign_opt", opts), "%s",
21853626ea  273) write_file(state_dir_path("strategy", opts), "--signoff");
c5233708c5  396) ret = -1;
c5233708c5  397) goto leave_reset_head;
c5233708c5  401) ret = error(_("could not determine HEAD revision"));
c5233708c5  402) goto leave_reset_head;
c5233708c5  423) ret = error(_("could not read index"));
c5233708c5  424) goto leave_reset_head;
c5233708c5  428) ret = error(_("failed to find tree of %s"),
c5233708c5  430) goto leave_reset_head;
c5233708c5  434) ret = error(_("failed to find tree of %s"), 
oid_to_hex(oid));
c5233708c5  435) goto leave_reset_head;
c5233708c5  447) ret = error(_("could not write index"));
c5233708c5  448) goto leave_reset_head;
c5233708c5  466) } else if (old_orig)
c5233708c5  467) delete_ref(NULL, "ORIG_HEAD", old_orig, 0);
21853626ea  542) argv_array_push(&am.args, opts->gpg_sign_opt);
21853626ea  574) status = error_errno(_("could not open '%s' for writing"),
21853626ea  576) free(rebased_patches);
21853626ea  577) argv_array_clear(&am.args);
21853626ea  578) return status;
21853626ea  587) argv_array_split(&format_patch.args,
21853626ea  588)  opts->git_format_patch_opt.buf);
21853626ea  596) unlink(rebased_patches);
21853626ea  597) free(rebased_patches);
21853626ea  598) argv_array_clear(&am.args);
21853626ea  600) reset_head(&opts->orig_head, "checkout", 
opts->head_name, 0,
21853626ea  602) error(_("\ngit encountered an error while preparing the "
21853626ea  609) strbuf_release(&revisions);
21853626ea  610) return status;
21853626ea  616) status = error_errno(_("could not open '%s' for reading"),
21853626ea  618) free(rebased_patches);
21853626ea  619) argv_array_clear(&am.args);
21853626ea  620) return status;

builtin/receive-pack.c
01f9ec64c8 builtin/receive-pack.c 1587)     reader->line + 8);
01f9ec64c8 builtin/receive-pack.c 1621) die("protocol error: got an 
unexpected packet");

builtin/remote.c
f39a9c6547 builtin/remote.c 1551) die(_("--save-to-push cannot be used 
with other options"));
f39a9c6547 builtin/remote.c 1575) die(_("--save-to-push can only be used 
when only one url is defined"));

commit-graph.c
aa658574bf  127) return NULL;
aa658574bf  130) return NULL;
aa658574bf  186) free(graph);
aa658574bf  187) return NULL;
aa658574bf  222) free(graph);
aa658574bf  223) return NULL;
64415806e8  933) display_progress(oids.progress, approx_nr_objects);

config.c
7e43b32b58 1488) return git_ident_config(var, value, cb);
7e43b32b58 1491) return git_ident_config(var, value, cb);

fetch-pack.c
01f9ec64c8  154) die(_("git fetch-pack: expected a flush packet after 
shallow list"));
01f9ec64c8  358) die(_("invalid shallow line: %s"), reader.line);
01f9ec64c8  364) die(_("invalid unshallow line: %s"), reader.line);
01f9ec64c8  366) die(_("object not found: %s"), reader.line);
01f9ec64c8  369) die(_("error in object: %s"), reader.line);
01f9ec64c8  371) die(_("no shallow found: %s"), reader.line);
01f9ec64c8  374) die(_("expected shallow/unshallow, got %s"), reader.line);
0bbc0bc574 1128) packet_buf_write(&req_buf, "sideband-all");
0bbc0bc574 1350) reader.use_sideband = 1;
0bbc0bc574 1351) reader.me = "fetch-pack";

http-walker.c
514c5fdd03 http-walker.c 550) loose_object_path(the_repository, &buf, 
&req->oid);

ident.c
7e43b32b58 373) email = git_author_email.buf;
7e43b32b58 375) email = git_committer_email.buf;
7e43b32b58 394) name = git_author_name.buf;
7e43b32b58 396) name = git_committer_name.buf;
7e43b32b58 504) if (!value)
7e43b32b58 505) return config_error_nonbool(var);
7e43b32b58 506) strbuf_reset(&git_author_name);
7e43b32b58 507) strbuf_addstr(&git_author_name, value);
7e43b32b58 508) author_ident_explicitly_given |= IDENT_NAME_GIVEN;
7e43b32b58 509) ident_config_given |= IDENT_NAME_GIVEN;
7e43b32b58 510) return 0;
7e43b32b58 514) if (!value)
7e43b32b58 515) return config_error_nonbool(var);
7e43b32b58 516) strbuf_reset(&git_author_email);
7e43b32b58 517) strbuf_addstr(&git_author_email, value);
7e43b32b58 518) author_ident_explicitly_given |= IDENT_MAIL_GIVEN;
7e43b32b58 519) ident_config_given |= IDENT_MAIL_GIVEN;
7e43b32b58 520) return 0;
7e43b32b58 524) if (!value)
7e43b32b58 525) return config_error_nonbool(var);
7e43b32b58 526) strbuf_reset(&git_committer_name);
7e43b32b58 527) strbuf_addstr(&git_committer_name, value);
7e43b32b58 528) committer_ident_explicitly_given |= IDENT_NAME_GIVEN;
7e43b32b58 529) ident_config_given |= IDENT_NAME_GIVEN;
7e43b32b58 530) return 0;
7e43b32b58 534) if (!value)
7e43b32b58 535) return config_error_nonbool(var);
7e43b32b58 536) strbuf_reset(&git_committer_email);
7e43b32b58 537) strbuf_addstr(&git_committer_email, value);
7e43b32b58 538) committer_ident_explicitly_given |= IDENT_MAIL_GIVEN;
7e43b32b58 539) ident_config_given |= IDENT_MAIL_GIVEN;
7e43b32b58 540) return 0;

midx.c
e7a330ee26  428) close_pack(packs->info[packs->nr].p);
e7a330ee26  429) FREE_AND_NULL(packs->info[packs->nr].p);
14b7185175  815) error(_("did not see pack-file %s to drop"),
14b7185175  817) drop_index++;
14b7185175  818) missing_drops++;
14b7185175  819) i--;
14b7185175  826) result = 1;
14b7185175  827) goto cleanup;
14b7185175 1073) return 0;
14b7185175 1088) continue;
14b7185175 1091) continue;
17d0bf5a7d 1142) return 0;
17d0bf5a7d 1151) continue;
17d0bf5a7d 1164) continue;
17d0bf5a7d 1187) error(_("could not start pack-objects"));
17d0bf5a7d 1188) result = 1;
17d0bf5a7d 1189) goto cleanup;
17d0bf5a7d 1206) error(_("could not finish pack-objects"));
17d0bf5a7d 1207) result = 1;
17d0bf5a7d 1208) goto cleanup;

packfile.c
9133688752  369) strbuf_release(&buf);
9133688752  370) return;

pkt-line.c
0bbc0bc574 505) if (demultiplex_sideband(reader->me, reader->buffer,
0bbc0bc574 508) break;
0bbc0bc574 509) }

read-cache.c
ee70c12820 1736) if (advice_unknown_index_extension) {
ee70c12820 1737) warning(_("ignoring optional %.4s index extension"), ext);
ee70c12820 1738) advise(_("This is likely due to the file having been 
written by a newer\n"

ref-filter.c
a9fb549b1d  467) return 0;

remote-curl.c
01f9ec64c8  427) die("invalid server response; got '%s'", reader.line);
01f9ec64c8  439) }

send-pack.c
01f9ec64c8 143) return error(_("unable to parse remote unpack status: 
%s"), reader->line);
01f9ec64c8 162) error("invalid ref status from remote: %s", reader->line);
01f9ec64c8 579) receive_unpack_status(&reader);

sequencer.c
899b49c446 2394) opts->quiet = 1;

sha1-file.c
514c5fdd03 sha1-file.c 1291) status = error(_("unable to parse %s 
header"), oid_to_hex(oid));
00a7760e81 sha1-file.c 2305) the_hash_algo->final_fn(real_oid.hash, &c);
00a7760e81 sha1-file.c 2306) if (!oideq(expected_oid, &real_oid)) {

sideband.c
fbd76cd450 128) suffix = ANSI_SUFFIX;
fbd76cd450 138) strbuf_addf(scratch,
fbd76cd450 140)     scratch->len ? "\n" : "", me);
fbd76cd450 141) *sideband_type = SIDEBAND_PROTOCOL_ERROR;
fbd76cd450 142) goto cleanup;
0bbc0bc574 150) die("remote error: %s", buf + 1);
fbd76cd450 195) strbuf_addf(scratch, "%s%s: protocol error: bad band #%d",
fbd76cd450 196)     scratch->len ? "\n" : "", me, band);
fbd76cd450 197) *sideband_type = SIDEBAND_PROTOCOL_ERROR;
fbd76cd450 198) break;
0bbc0bc574 203) die("%s", scratch->buf);

upload-pack.c
01f9ec64c8  432) die("git upload-pack: expected SHA1 list, got '%s'", 
reader->line);
0bbc0bc574 1066) allow_sideband_all = git_config_bool(var, value);
07c3c2aa16 1306)      allow_sideband_all) &&
07c3c2aa16 1307)     !strcmp(arg, "sideband-all")) {
0bbc0bc574 1308) data->writer.use_sideband = 1;
0bbc0bc574 1309) continue;
bc2e795cea 1441) deepen(&data->writer, INFINITE_DEPTH, 
data->deepen_relative,
07c3c2aa16 1544)    &allow_sideband_all_value) &&

worktree.c
ebefff3c73 465) clear_repository_format(&format);

wrapper.c
e3b1e3bdc0 701) die_errno(_("could not stat %s"), filename);

Commits introducing uncovered code:
Ævar Arnfjörð Bjarmason      64415806e: commit-graph write: show 
progress for object search
Daniels Umanovskis      0ecb1fc72: branch: introduce --show-current 
display option
Denton Liu      b19eee906: merge: add scissors line on merge conflict
Denton Liu      f39a9c654: remote: add --save-to-push option to git 
remote set-url
Derrick Stolee      14b718517: multi-pack-index: implement 'expire' 
subcommand
Derrick Stolee      17d0bf5a7: midx: implement midx_repack()
Derrick Stolee      334e9745a: multi-pack-index: prepare 'repack' subcommand
Derrick Stolee      913368875: repack: refactor pack deletion for future use
Derrick Stolee      e7a330ee2: midx: refactor permutation logic and pack 
sorting
Elijah Newren      899b49c44: git-rebase, sequencer: extend --quiet 
option for the interactive machinery
Jeff King      00a7760e8: sha1-file: modernize loose header/stream functions
Jeff King      514c5fdd0: sha1-file: modernize loose object file functions
Johannes Schindelin      21853626e: built-in rebase: call `git am` directly
Johannes Schindelin      c5233708c: rebase: move `reset_head()` into a 
better spot
Jonathan Nieder      ee70c1282: index: offer advice for unknown index 
extensions
Jonathan Tan      07c3c2aa1: tests: define GIT_TEST_SIDEBAND_ALL
Jonathan Tan      0bbc0bc57: {fetch,upload}-pack: sideband v2 fetch response
Jonathan Tan      bc2e795ce: pkt-line: introduce struct packet_writer
Jonathan Tan      fbd76cd45: sideband: reverse its dependency on pkt-line
Josh Steadmon      aa658574b: commit-graph, fuzz: add fuzzer for 
commit-graph
Martin Ågren      ebefff3c7: setup: add `clear_repository_format()`
Masaya Suzuki      01f9ec64c: Use packet_reader instead of packet_read_line
Nickolai Belakovski      711d28e2e: branch: add an extra verbose output 
displaying worktree path for checked out branch
Nickolai Belakovski      a9fb549b1: ref-filter: add worktreepath atom
Pranit Bauva      06f5608c1: bisect--helper: `bisect_start` shell 
function partially in C
Pranit Bauva      0f30233a1: bisect--helper: `bisect_write` shell 
function in C
Pranit Bauva      129a6cf34: bisect--helper: `bisect_next_check` shell 
function in C
Pranit Bauva      450ebb735: bisect--helper: `get_terms` & 
`bisect_terms` shell function in C
Pranit Bauva      4fbdbd5bf: bisect--helper: `check_and_set_terms` shell 
function in C
Pranit Bauva      5e82c3dd2: bisect--helper: `bisect_reset` shell 
function in C
Pranit Bauva      e3b1e3bdc: wrapper: move is_empty_file() and rename it 
as is_empty_or_missing_file()
William Hubbs      7e43b32b5: Add author and committer configuration 
settings



Uncovered code in 'next' not in 'master'
--------------------------------------------

builtin/checkout.c
091e04bc8c builtin/checkout.c  302) return;
091e04bc8c builtin/checkout.c 1268) die(_("'%s' cannot be used with 
switching branches"),

builtin/fetch-pack.c
4316ff3068 builtin/fetch-pack.c 226) get_remote_refs(fd[1], &reader, 
&ref, 0, NULL, NULL);
4316ff3068 builtin/fetch-pack.c 227) break;

builtin/fetch.c
e01378753d builtin/fetch.c 1479) die(_("--filter can only be used with 
the remote "
e01378753d builtin/fetch.c 1648) die(_("--filter can only be used with 
the remote "

builtin/rebase.c
81ef8ee75d  773) return -1;
d421afa0c6 1258) die(_("--reschedule-failed-exec requires an interactive 
rebase"));
d421afa0c6 1296) die(_("error: cannot combine '--preserve-merges' with "

diff.c
b73bcbac4a  308) ret = 0;
21536d077f  812)        (s[off] == '\r' && off < len - 1))
21536d077f  813) off++;
b73bcbac4a 5112) options->color_moved_ws_handling = 0;

entry.c
hex.c
47edb64997  93) char *sha1_to_hex_r(char *buffer, const unsigned char *sha1)
47edb64997  95) return hash_to_hex_algop_r(buffer, sha1, 
&hash_algos[GIT_HASH_SHA1]);
47edb64997 116) char *hash_to_hex(const unsigned char *hash)
47edb64997 118) return hash_to_hex_algop(hash, the_hash_algo);

http-push.c
ea82b2a085 1314) p = process_tree(lookup_tree(the_repository, &entry.oid),

http.c
e6cf87b12d 1999) if (fflush(result)) {
e6cf87b12d 2000) error_errno("unable to flush a file");
e6cf87b12d 2001) return HTTP_START_FAILED;
e6cf87b12d 2003) rewind(result);
e6cf87b12d 2004) if (ftruncate(fileno(result), 0) < 0) {
e6cf87b12d 2005) error_errno("unable to truncate a file");
e6cf87b12d 2006) return HTTP_START_FAILED;
e6cf87b12d 2008) break;

list-objects-filter.c
c813a7c35f 199) return;

match-trees.c
f55ac4311a 231) hashcpy(tree_oid.hash, rewrite_here);
f55ac4311a 232) status = splice_tree(&tree_oid, subpath, oid2, &subtree);

pretty.c
ad6f028f06 1204) return 0;

remote-curl.c
b79bdd8c12  566) return size;

sha1-file.c
2f90b9d9b4 sha1-file.c  172) int hash_algo_by_name(const char *name)
2f90b9d9b4 sha1-file.c  175) if (!name)
2f90b9d9b4 sha1-file.c  176) return GIT_HASH_UNKNOWN;
2f90b9d9b4 sha1-file.c  177) for (i = 1; i < GIT_HASH_NALGOS; i++)
2f90b9d9b4 sha1-file.c  178) if (!strcmp(name, hash_algos[i].name))
2f90b9d9b4 sha1-file.c  179) return i;
2f90b9d9b4 sha1-file.c  180) return GIT_HASH_UNKNOWN;
2f90b9d9b4 sha1-file.c  183) int hash_algo_by_id(uint32_t format_id)
2f90b9d9b4 sha1-file.c  186) for (i = 1; i < GIT_HASH_NALGOS; i++)
2f90b9d9b4 sha1-file.c  187) if (format_id == hash_algos[i].format_id)
2f90b9d9b4 sha1-file.c  188) return i;
2f90b9d9b4 sha1-file.c  189) return GIT_HASH_UNKNOWN;

submodule.c
26f80ccfc1 1398) strbuf_release(&gitdir);
be76c21282 1521) struct fetch_task *task = task_cb;
be76c21282 1525) fetch_task_release(task);

tree-walk.c
0a3faa45b1  530) oidcpy(result, &oid);

tree.c
60c38b9e4a 104) commit = lookup_commit(r, &entry.oid);

upload-pack.c
87c2d9d310  147) sq_quote_buf(&buf, expanded_filter_spec.buf);

Commits introducing uncovered code:
brian m. carlson      0a3faa45b: tree-walk: copy object ID before use
brian m. carlson      2f90b9d9b: sha1-file: provide functions to look up 
hash algorithms
brian m. carlson      47edb6499: hex: introduce functions to print 
arbitrary hashes
brian m. carlson      ea82b2a08: tree-walk: store object_id in a 
separate member
brian m. carlson      f55ac4311: match-trees: use hashcpy to splice trees
Christian Couder      e01378753: fetch: fix extensions.partialclone name 
in error message
Issac Trotts      ad6f028f0: log: add %S option (like --source) to log 
--format
Johannes Schindelin      81ef8ee75: rebase: introduce a shortcut for 
--reschedule-failed-exec
Johannes Schindelin      d421afa0c: rebase: introduce 
--reschedule-failed-exec
Jonathan Tan      4316ff306: fetch-pack: support protocol version 2
Josh Steadmon      87c2d9d31: filter-options: expand scaled numbers
Junio C Hamano      60c38b9e4: Merge branch 'bc/tree-walk-oid' into next
Masaya Suzuki      b79bdd8c1: remote-curl: unset CURLOPT_FAILONERROR
Masaya Suzuki      e6cf87b12: http: enable keep_error for HTTP requests
Matthew DeVore      c813a7c35: list-objects-filter: teach tree:# how to 
handle >0
Phillip Wood      21536d077: diff --color-moved-ws: modify 
allow-indentation-change
Phillip Wood      b73bcbac4: diff: allow --no-color-moved-ws
Stefan Beller      26f80ccfc: submodule: migrate get_next_submodule to 
use repository structs
Stefan Beller      be76c2128: fetch: ensure submodule objects fetched
Thomas Gummerer      091e04bc8: checkout: introduce --{,no-}overlay option



Uncovered code in 'master' not in 'master@{1}'
----------------------------------------------------

builtin/submodule--helper.c
builtin/worktree.c
00a6d4d1d2 752) found_submodules = 1;
00a6d4d1d2 753) break;

commit-graph.c
ref-filter.c
1867ce6cbe  236) oi_deref.info.sizep = &oi_deref.size;
1867ce6cbe  245) return strbuf_addf_ret(err, -1, _("unrecognized 
%%(objectsize) argument: %s"), arg);
33311fa1ad  253) return strbuf_addf_ret(err, -1, _("%%(deltabase) does 
not take arguments"));

setup.c
07098b81a4 1093) if (!nongit_ok)
07098b81a4 1094) die(_("not a git repository (or any parent up to mount 
point %s)\n"
07098b81a4 1097) *nongit_ok = 1;
07098b81a4 1098) break;

transport-helper.c
3b3357626e 1029) static int has_attribute(const char *attrs, const char 
*attr)

Commits introducing uncovered code:
Erin Dahlgren      07098b81a: Simplify handling of 
setup_git_directory_gently() failure cases.
Nguyễn Thái Ngọc Duy      00a6d4d1d: worktree: allow to (re)move 
worktrees with uninitialized submodules
Nguyễn Thái Ngọc Duy      3b3357626: style: the opening '{' of a 
function is in a separate line
Olga Telezhnaya      1867ce6cb: ref-filter: add objectsize:disk option
Olga Telezhnaya      33311fa1a: ref-filter: add deltabase option


             reply index

Thread overview: 5+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2019-01-20  1:07 Derrick Stolee [this message]
2019-01-24 18:15 ` Junio C Hamano
2019-01-24 19:18   ` Derrick Stolee
2019-01-24 19:39     ` Ramsay Jones
2019-01-24 20:56       ` Derrick Stolee

Reply instructions:

You may reply publically to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

  List information: http://vger.kernel.org/majordomo-info.html

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=6addc879-a792-202f-2aeb-7097ea344894@gmail.com \
    --to=stolee@gmail.com \
    --cc=git@vger.kernel.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link

git@vger.kernel.org mailing list mirror (one of many)

Archives are clonable:
	git clone --mirror https://public-inbox.org/git
	git clone --mirror http://ou63pmih66umazou.onion/git
	git clone --mirror http://czquwvybam4bgbro.onion/git
	git clone --mirror http://hjrcffqmbrq6wope.onion/git

Newsgroups are available over NNTP:
	nntp://news.public-inbox.org/inbox.comp.version-control.git
	nntp://ou63pmih66umazou.onion/inbox.comp.version-control.git
	nntp://czquwvybam4bgbro.onion/inbox.comp.version-control.git
	nntp://hjrcffqmbrq6wope.onion/inbox.comp.version-control.git
	nntp://news.gmane.org/gmane.comp.version-control.git

 note: .onion URLs require Tor: https://www.torproject.org/
       or Tor2web: https://www.tor2web.org/

AGPL code for this site: git clone https://public-inbox.org/ public-inbox