Merge branch 'sb/oid-object-info'
authorJunio C Hamano <gitster@pobox.com>
Wed, 23 May 2018 05:38:16 +0000 (14:38 +0900)
committerJunio C Hamano <gitster@pobox.com>
Wed, 23 May 2018 05:38:16 +0000 (14:38 +0900)
The codepath around object-info API has been taught to take the
repository object (which in turn tells the API which object store
the objects are to be located).

* sb/oid-object-info:
cache.h: allow oid_object_info to handle arbitrary repositories
packfile: add repository argument to cache_or_unpack_entry
packfile: add repository argument to unpack_entry
packfile: add repository argument to read_object
packfile: add repository argument to packed_object_info
packfile: add repository argument to packed_to_object_type
packfile: add repository argument to retry_bad_packed_offset
cache.h: add repository argument to oid_object_info
cache.h: add repository argument to oid_object_info_extended

20 files changed:
1  2 
blame.c
builtin/describe.c
builtin/fast-export.c
builtin/fetch.c
builtin/index-pack.c
builtin/pack-objects.c
builtin/tag.c
cache.h
commit-graph.c
fast-import.c
list-objects-filter.c
object.c
pack-bitmap-write.c
packfile.c
packfile.h
refs.c
sequencer.c
sha1-file.c
sha1-name.c
submodule.c
diff --combined blame.c
index f858525082d4bd8445d3c79b488bec693ea7760a,dfa24473dc6e3d3d6428ca0fcdff75861d0c1aec..0edea04a052d33f771f44ff5c70d45fedacbe54b
+++ b/blame.c
@@@ -81,7 -81,7 +81,7 @@@ static void verify_working_tree_path(st
                unsigned mode;
  
                if (!get_tree_entry(commit_oid, path, &blob_oid, &mode) &&
-                   oid_object_info(&blob_oid, NULL) == OBJ_BLOB)
+                   oid_object_info(the_repository, &blob_oid, NULL) == OBJ_BLOB)
                        return;
        }
  
@@@ -504,7 -504,7 +504,7 @@@ static int fill_blob_sha1_and_mode(stru
                return 0;
        if (get_tree_entry(&origin->commit->object.oid, origin->path, &origin->blob_oid, &origin->mode))
                goto error_out;
-       if (oid_object_info(&origin->blob_oid, NULL) != OBJ_BLOB)
+       if (oid_object_info(the_repository, &origin->blob_oid, NULL) != OBJ_BLOB)
                goto error_out;
        return 0;
   error_out:
@@@ -551,10 -551,10 +551,10 @@@ static struct blame_origin *find_origin
        diff_setup_done(&diff_opts);
  
        if (is_null_oid(&origin->commit->object.oid))
 -              do_diff_cache(&parent->tree->object.oid, &diff_opts);
 +              do_diff_cache(get_commit_tree_oid(parent), &diff_opts);
        else
 -              diff_tree_oid(&parent->tree->object.oid,
 -                            &origin->commit->tree->object.oid,
 +              diff_tree_oid(get_commit_tree_oid(parent),
 +                            get_commit_tree_oid(origin->commit),
                              "", &diff_opts);
        diffcore_std(&diff_opts);
  
@@@ -620,10 -620,10 +620,10 @@@ static struct blame_origin *find_rename
        diff_setup_done(&diff_opts);
  
        if (is_null_oid(&origin->commit->object.oid))
 -              do_diff_cache(&parent->tree->object.oid, &diff_opts);
 +              do_diff_cache(get_commit_tree_oid(parent), &diff_opts);
        else
 -              diff_tree_oid(&parent->tree->object.oid,
 -                            &origin->commit->tree->object.oid,
 +              diff_tree_oid(get_commit_tree_oid(parent),
 +                            get_commit_tree_oid(origin->commit),
                              "", &diff_opts);
        diffcore_std(&diff_opts);
  
@@@ -1255,10 -1255,10 +1255,10 @@@ static void find_copy_in_parent(struct 
                diff_opts.flags.find_copies_harder = 1;
  
        if (is_null_oid(&target->commit->object.oid))
 -              do_diff_cache(&parent->tree->object.oid, &diff_opts);
 +              do_diff_cache(get_commit_tree_oid(parent), &diff_opts);
        else
 -              diff_tree_oid(&parent->tree->object.oid,
 -                            &target->commit->tree->object.oid,
 +              diff_tree_oid(get_commit_tree_oid(parent),
 +                            get_commit_tree_oid(target->commit),
                              "", &diff_opts);
  
        if (!diff_opts.flags.find_copies_harder)
diff --combined builtin/describe.c
index b5afc4584632d35afe26f4c3d0dfb09e777518b1,66c497f7896b597974e1c0fb2db7ff22e051d894..a4160e7f5d1321e08be78f86d63b780a1711616f
@@@ -6,7 -6,7 +6,7 @@@
  #include "blob.h"
  #include "refs.h"
  #include "builtin.h"
 -#include "exec_cmd.h"
 +#include "exec-cmd.h"
  #include "parse-options.h"
  #include "revision.h"
  #include "diff.h"
@@@ -502,7 -502,7 +502,7 @@@ static void describe(const char *arg, i
  
        if (cmit)
                describe_commit(&oid, &sb);
-       else if (oid_object_info(&oid, NULL) == OBJ_BLOB)
+       else if (oid_object_info(the_repository, &oid, NULL) == OBJ_BLOB)
                describe_blob(oid, &sb);
        else
                die(_("%s is neither a commit nor blob"), arg);
diff --combined builtin/fast-export.c
index ea776e602a9ec72648e48a749e45bed339e482ab,373c794873efd8f771afc7a750aabf067d83411c..68a762fbeaa1363d6b0d709f1500b1925796a711
@@@ -578,11 -578,11 +578,11 @@@ static void handle_commit(struct commi
            get_object_mark(&commit->parents->item->object) != 0 &&
            !full_tree) {
                parse_commit_or_die(commit->parents->item);
 -              diff_tree_oid(&commit->parents->item->tree->object.oid,
 -                            &commit->tree->object.oid, "", &rev->diffopt);
 +              diff_tree_oid(get_commit_tree_oid(commit->parents->item),
 +                            get_commit_tree_oid(commit), "", &rev->diffopt);
        }
        else
 -              diff_root_tree_oid(&commit->tree->object.oid,
 +              diff_root_tree_oid(get_commit_tree_oid(commit),
                                   "", &rev->diffopt);
  
        /* Export the referenced blobs, and remember the marks. */
@@@ -651,11 -651,8 +651,11 @@@ static void handle_tail(struct object_a
        struct commit *commit;
        while (commits->nr) {
                commit = (struct commit *)object_array_pop(commits);
 -              if (has_unshown_parent(commit))
 +              if (has_unshown_parent(commit)) {
 +                      /* Queue again, to be handled later */
 +                      add_object_array(&commit->object, NULL, commits);
                        return;
 +              }
                handle_commit(commit, revs, paths_of_changed_objects);
        }
  }
@@@ -950,7 -947,7 +950,7 @@@ static void import_marks(char *input_fi
                if (last_idnum < mark)
                        last_idnum = mark;
  
-               type = oid_object_info(&oid, NULL);
+               type = oid_object_info(the_repository, &oid, NULL);
                if (type < 0)
                        die("object not found: %s", oid_to_hex(&oid));
  
diff --combined builtin/fetch.c
index 5a6f6b2dcae1ca36ac74a543202e89bd22ccf198,73be393b2eaa37aa0831b7c5b767569b6deb3cc0..1f037e8e4b8ba41b66314c5dd9633e0164f86c0e
@@@ -62,7 -62,6 +62,7 @@@ static int shown_url = 0
  static int refmap_alloc, refmap_nr;
  static const char **refmap_array;
  static struct list_objects_filter_options filter_options;
 +static struct string_list server_options = STRING_LIST_INIT_DUP;
  
  static int git_fetch_config(const char *k, const char *v, void *cb)
  {
@@@ -171,7 -170,6 +171,7 @@@ static struct option builtin_fetch_opti
                 N_("accept refs that update .git/shallow")),
        { OPTION_CALLBACK, 0, "refmap", NULL, N_("refmap"),
          N_("specify fetch refmap"), PARSE_OPT_NONEG, parse_refmap_arg },
 +      OPT_STRING_LIST('o', "server-option", &server_options, N_("server-specific"), N_("option to transmit")),
        OPT_SET_INT('4', "ipv4", &family, N_("use IPv4 addresses only"),
                        TRANSPORT_FAMILY_IPV4),
        OPT_SET_INT('6', "ipv6", &family, N_("use IPv6 addresses only"),
@@@ -266,7 -264,7 +266,7 @@@ static void find_non_local_tags(struct 
        struct string_list_item *item = NULL;
  
        for_each_ref(add_existing, &existing_refs);
 -      for (ref = transport_get_remote_refs(transport); ref; ref = ref->next) {
 +      for (ref = transport_get_remote_refs(transport, NULL); ref; ref = ref->next) {
                if (!starts_with(ref->name, "refs/tags/"))
                        continue;
  
@@@ -348,28 -346,11 +348,28 @@@ static struct ref *get_ref_map(struct t
        struct ref *rm;
        struct ref *ref_map = NULL;
        struct ref **tail = &ref_map;
 +      struct argv_array ref_prefixes = ARGV_ARRAY_INIT;
  
        /* opportunistically-updated references: */
        struct ref *orefs = NULL, **oref_tail = &orefs;
  
 -      const struct ref *remote_refs = transport_get_remote_refs(transport);
 +      const struct ref *remote_refs;
 +
 +      for (i = 0; i < refspec_count; i++) {
 +              if (!refspecs[i].exact_sha1) {
 +                      const char *glob = strchr(refspecs[i].src, '*');
 +                      if (glob)
 +                              argv_array_pushf(&ref_prefixes, "%.*s",
 +                                               (int)(glob - refspecs[i].src),
 +                                               refspecs[i].src);
 +                      else
 +                              expand_ref_prefix(&ref_prefixes, refspecs[i].src);
 +              }
 +      }
 +
 +      remote_refs = transport_get_remote_refs(transport, &ref_prefixes);
 +
 +      argv_array_clear(&ref_prefixes);
  
        if (refspec_count) {
                struct refspec *fetch_refspec;
@@@ -656,7 -637,7 +656,7 @@@ static int update_local_ref(struct ref 
        struct branch *current_branch = branch_get(NULL);
        const char *pretty_ref = prettify_refname(ref->name);
  
-       type = oid_object_info(&ref->new_oid, NULL);
+       type = oid_object_info(the_repository, &ref->new_oid, NULL);
        if (type < 0)
                die(_("object %s not found"), oid_to_hex(&ref->new_oid));
  
@@@ -1419,9 -1400,6 +1419,9 @@@ static int fetch_one(struct remote *rem
                }
        }
  
 +      if (server_options.nr)
 +              gtransport->server_options = &server_options;
 +
        sigchain_push_common(unlock_pack_on_signal);
        atexit(unlock_pack);
        refspec = parse_fetch_refspec(ref_nr, refs);
diff --combined builtin/index-pack.c
index a2cd29d8f49586d9683f6ebb83421b45d3fa824d,2d04a596f508196d185e04899f9f3066ad94f57a..e2f670bef9ec6af7dfeaf8f507c9a9f80968c4df
@@@ -9,7 -9,7 +9,7 @@@
  #include "tree.h"
  #include "progress.h"
  #include "fsck.h"
 -#include "exec_cmd.h"
 +#include "exec-cmd.h"
  #include "streaming.h"
  #include "thread-utils.h"
  #include "packfile.h"
@@@ -223,7 -223,7 +223,7 @@@ static unsigned check_object(struct obj
  
        if (!(obj->flags & FLAG_CHECKED)) {
                unsigned long size;
-               int type = oid_object_info(&obj->oid, &size);
+               int type = oid_object_info(the_repository, &obj->oid, &size);
                if (type <= 0)
                        die(_("did not receive expected object %s"),
                              oid_to_hex(&obj->oid));
@@@ -812,7 -812,7 +812,7 @@@ static void sha1_object(const void *dat
                enum object_type has_type;
                unsigned long has_size;
                read_lock();
-               has_type = oid_object_info(oid, &has_size);
+               has_type = oid_object_info(the_repository, oid, &has_size);
                if (has_type < 0)
                        die(_("cannot read existing object info %s"), oid_to_hex(oid));
                if (has_type != type || has_size != size)
@@@ -1271,7 -1271,7 +1271,7 @@@ static void conclude_pack(int fix_thin_
                            nr_objects - nr_objects_initial);
                stop_progress_msg(&progress, msg.buf);
                strbuf_release(&msg);
 -              hashclose(f, tail_hash, 0);
 +              finalize_hashfile(f, tail_hash, 0);
                hashcpy(read_hash, pack_hash);
                fixup_pack_header_footer(output_fd, pack_hash,
                                         curr_pack, nr_objects,
@@@ -1593,7 -1593,7 +1593,7 @@@ static void read_idx_option(struct pack
        /*
         * Get rid of the idx file as we do not need it anymore.
         * NEEDSWORK: extract this bit from free_pack_by_name() in
 -       * sha1_file.c, perhaps?  It shouldn't matter very much as we
 +       * sha1-file.c, perhaps?  It shouldn't matter very much as we
         * know we haven't installed this pack (hence we never have
         * read anything from it).
         */
diff --combined builtin/pack-objects.c
index 0bfd33ea2777f2d4cc9856eafca54d883245bd10,d65eb4a94781d7b86b42af05f89df058a2773787..4ce6a93281ad6eb60519528e523b25de0d0be07f
@@@ -30,7 -30,6 +30,7 @@@
  #include "list.h"
  #include "packfile.h"
  #include "object-store.h"
 +#include "dir.h"
  
  static const char *pack_usage[] = {
        N_("git pack-objects --stdout [<options>...] [< <ref-list> | < <object-list>]"),
@@@ -46,7 -45,7 +46,7 @@@
  static struct packing_data to_pack;
  
  static struct pack_idx_entry **written_list;
 -static uint32_t nr_result, nr_written;
 +static uint32_t nr_result, nr_written, nr_seen;
  
  static int non_empty;
  static int reuse_delta = 1, reuse_object = 1;
@@@ -56,8 -55,7 +56,8 @@@ static int pack_loose_unreachable
  static int local;
  static int have_non_local_packs;
  static int incremental;
 -static int ignore_packed_keep;
 +static int ignore_packed_keep_on_disk;
 +static int ignore_packed_keep_in_core;
  static int allow_ofs_delta;
  static struct pack_idx_option pack_idx_opts;
  static const char *base_name;
@@@ -82,7 -80,7 +82,7 @@@ static uint16_t write_bitmap_options
  static int exclude_promisor_objects;
  
  static unsigned long delta_cache_size = 0;
 -static unsigned long max_delta_cache_size = 256 * 1024 * 1024;
 +static unsigned long max_delta_cache_size = DEFAULT_DELTA_CACHE_SIZE;
  static unsigned long cache_max_small_delta_size = 1000;
  
  static unsigned long window_memory_limit = 0;
@@@ -839,11 -837,11 +839,11 @@@ static void write_pack_file(void
                 * If so, rewrite it like in fast-import
                 */
                if (pack_to_stdout) {
 -                      hashclose(f, oid.hash, CSUM_CLOSE);
 +                      finalize_hashfile(f, oid.hash, CSUM_HASH_IN_STREAM | CSUM_CLOSE);
                } else if (nr_written == nr_remaining) {
 -                      hashclose(f, oid.hash, CSUM_FSYNC);
 +                      finalize_hashfile(f, oid.hash, CSUM_HASH_IN_STREAM | CSUM_FSYNC | CSUM_CLOSE);
                } else {
 -                      int fd = hashclose(f, oid.hash, 0);
 +                      int fd = finalize_hashfile(f, oid.hash, 0);
                        fixup_pack_header_footer(fd, oid.hash, pack_tmp_name,
                                                 nr_written, oid.hash, offset);
                        close(fd);
@@@ -984,16 -982,13 +984,16 @@@ static int want_found_object(int exclud
         * Otherwise, we signal "-1" at the end to tell the caller that we do
         * not know either way, and it needs to check more packs.
         */
 -      if (!ignore_packed_keep &&
 +      if (!ignore_packed_keep_on_disk &&
 +          !ignore_packed_keep_in_core &&
            (!local || !have_non_local_packs))
                return 1;
  
        if (local && !p->pack_local)
                return 0;
 -      if (ignore_packed_keep && p->pack_local && p->pack_keep)
 +      if (p->pack_local &&
 +          ((ignore_packed_keep_on_disk && p->pack_keep) ||
 +           (ignore_packed_keep_in_core && p->pack_keep_in_core)))
                return 0;
  
        /* we don't know yet; keep looking for more packs */
@@@ -1096,8 -1091,6 +1096,8 @@@ static int add_object_entry(const struc
        off_t found_offset = 0;
        uint32_t index_pos;
  
 +      display_progress(progress_state, ++nr_seen);
 +
        if (have_duplicate_entry(oid, exclude, &index_pos))
                return 0;
  
        create_object_entry(oid, type, pack_name_hash(name),
                            exclude, name && no_try_delta(name),
                            index_pos, found_pack, found_offset);
 -
 -      display_progress(progress_state, nr_result);
        return 1;
  }
  
@@@ -1123,8 -1118,6 +1123,8 @@@ static int add_object_entry_from_bitmap
  {
        uint32_t index_pos;
  
 +      display_progress(progress_state, ++nr_seen);
 +
        if (have_duplicate_entry(oid, 0, &index_pos))
                return 0;
  
                return 0;
  
        create_object_entry(oid, type, name_hash, 0, 0, index_pos, pack, offset);
 -
 -      display_progress(progress_state, nr_result);
        return 1;
  }
  
@@@ -1521,7 -1516,8 +1521,8 @@@ static void check_object(struct object_
                unuse_pack(&w_curs);
        }
  
-       entry->type = oid_object_info(&entry->idx.oid, &entry->size);
+       entry->type = oid_object_info(the_repository, &entry->idx.oid,
+                                     &entry->size);
        /*
         * The error condition is checked in prepare_pack().  This is
         * to permit a missing preferred base object to be ignored
@@@ -1576,14 -1572,16 +1577,16 @@@ static void drop_reused_delta(struct ob
  
        oi.sizep = &entry->size;
        oi.typep = &entry->type;
-       if (packed_object_info(entry->in_pack, entry->in_pack_offset, &oi) < 0) {
+       if (packed_object_info(the_repository, entry->in_pack,
+                              entry->in_pack_offset, &oi) < 0) {
                /*
                 * We failed to get the info from this pack for some reason;
                 * fall back to sha1_object_info, which may find another copy.
                 * And if that fails, the error will be recorded in entry->type
                 * and dealt with in prepare_pack().
                 */
-               entry->type = oid_object_info(&entry->idx.oid, &entry->size);
+               entry->type = oid_object_info(the_repository, &entry->idx.oid,
+                                             &entry->size);
        }
  }
  
@@@ -1716,10 -1714,6 +1719,10 @@@ static void get_object_details(void
        uint32_t i;
        struct object_entry **sorted_by_offset;
  
 +      if (progress)
 +              progress_state = start_progress(_("Counting objects"),
 +                                              to_pack.nr_objects);
 +
        sorted_by_offset = xcalloc(to_pack.nr_objects, sizeof(struct object_entry *));
        for (i = 0; i < to_pack.nr_objects; i++)
                sorted_by_offset[i] = to_pack.objects + i;
                check_object(entry);
                if (big_file_threshold < entry->size)
                        entry->no_try_delta = 1;
 +              display_progress(progress_state, i + 1);
        }
 +      stop_progress(&progress_state);
  
        /*
         * This must happen in a second pass, since we rely on the delta
@@@ -2686,7 -2678,7 +2689,7 @@@ static void add_objects_in_unpacked_pac
                struct object_id oid;
                struct object *o;
  
 -              if (!p->pack_local || p->pack_keep)
 +              if (!p->pack_local || p->pack_keep || p->pack_keep_in_core)
                        continue;
                if (open_pack_index(p))
                        die("cannot open pack index");
  static int add_loose_object(const struct object_id *oid, const char *path,
                            void *data)
  {
-       enum object_type type = oid_object_info(oid, NULL);
+       enum object_type type = oid_object_info(the_repository, oid, NULL);
  
        if (type < 0) {
                warning("loose object at %s could not be examined", path);
@@@ -2749,8 -2741,7 +2752,8 @@@ static int has_sha1_pack_kept_or_nonloc
                                        get_packed_git(the_repository);
  
        while (p) {
 -              if ((!p->pack_local || p->pack_keep) &&
 +              if ((!p->pack_local || p->pack_keep ||
 +                              p->pack_keep_in_core) &&
                        find_pack_entry_one(oid->hash, p)) {
                        last_found = p;
                        return 1;
@@@ -2793,7 -2784,7 +2796,7 @@@ static void loosen_unused_packed_object
        struct object_id oid;
  
        for (p = get_packed_git(the_repository); p; p = p->next) {
 -              if (!p->pack_local || p->pack_keep)
 +              if (!p->pack_local || p->pack_keep || p->pack_keep_in_core)
                        continue;
  
                if (open_pack_index(p))
@@@ -2819,8 -2810,7 +2822,8 @@@ static int pack_options_allow_reuse(voi
  {
        return pack_to_stdout &&
               allow_ofs_delta &&
 -             !ignore_packed_keep &&
 +             !ignore_packed_keep_on_disk &&
 +             !ignore_packed_keep_in_core &&
               (!local || !have_non_local_packs) &&
               !incremental;
  }
@@@ -2929,32 -2919,6 +2932,32 @@@ static void get_object_list(int ac, con
        oid_array_clear(&recent_objects);
  }
  
 +static void add_extra_kept_packs(const struct string_list *names)
 +{
 +      struct packed_git *p;
 +
 +      if (!names->nr)
 +              return;
 +
 +      for (p = get_packed_git(the_repository); p; p = p->next) {
 +              const char *name = basename(p->pack_name);
 +              int i;
 +
 +              if (!p->pack_local)
 +                      continue;
 +
 +              for (i = 0; i < names->nr; i++)
 +                      if (!fspathcmp(name, names->items[i].string))
 +                              break;
 +
 +              if (i < names->nr) {
 +                      p->pack_keep_in_core = 1;
 +                      ignore_packed_keep_in_core = 1;
 +                      continue;
 +              }
 +      }
 +}
 +
  static int option_parse_index_version(const struct option *opt,
                                      const char *arg, int unset)
  {
@@@ -2994,7 -2958,6 +2997,7 @@@ int cmd_pack_objects(int argc, const ch
        struct argv_array rp = ARGV_ARRAY_INIT;
        int rev_list_unpacked = 0, rev_list_all = 0, rev_list_reflog = 0;
        int rev_list_index = 0;
 +      struct string_list keep_pack_list = STRING_LIST_INIT_NODUP;
        struct option pack_objects_options[] = {
                OPT_SET_INT('q', "quiet", &progress,
                            N_("do not show progress meter"), 0),
                         N_("create thin packs")),
                OPT_BOOL(0, "shallow", &shallow,
                         N_("create packs suitable for shallow fetches")),
 -              OPT_BOOL(0, "honor-pack-keep", &ignore_packed_keep,
 +              OPT_BOOL(0, "honor-pack-keep", &ignore_packed_keep_on_disk,
                         N_("ignore packs that have companion .keep file")),
 +              OPT_STRING_LIST(0, "keep-pack", &keep_pack_list, N_("name"),
 +                              N_("ignore this pack")),
                OPT_INTEGER(0, "compression", &pack_compression_level,
                            N_("pack compression level")),
                OPT_SET_INT(0, "keep-true-parents", &grafts_replace_parents,
        if (progress && all_progress_implied)
                progress = 2;
  
 -      if (ignore_packed_keep) {
 +      add_extra_kept_packs(&keep_pack_list);
 +      if (ignore_packed_keep_on_disk) {
                struct packed_git *p;
                for (p = get_packed_git(the_repository); p; p = p->next)
                        if (p->pack_local && p->pack_keep)
                                break;
                if (!p) /* no keep-able packs found */
 -                      ignore_packed_keep = 0;
 +                      ignore_packed_keep_on_disk = 0;
        }
        if (local) {
                /*
 -               * unlike ignore_packed_keep above, we do not want to
 -               * unset "local" based on looking at packs, as it
 -               * also covers non-local objects
 +               * unlike ignore_packed_keep_on_disk above, we do not
 +               * want to unset "local" based on looking at packs, as
 +               * it also covers non-local objects
                 */
                struct packed_git *p;
                for (p = get_packed_git(the_repository); p; p = p->next) {
        }
  
        if (progress)
 -              progress_state = start_progress(_("Counting objects"), 0);
 +              progress_state = start_progress(_("Enumerating objects"), 0);
        if (!use_internal_rev_list)
                read_object_list_from_stdin();
        else {
diff --combined builtin/tag.c
index 46a5c6a1da17fa12ff65f33889527ec76869c3cd,26d7729f57b73a36b0345141b072b840a34e0722..5d0dd112408419a0090cbe179d69c0ea709f22a7
@@@ -118,7 -118,7 +118,7 @@@ static int verify_tag(const char *name
                return -1;
  
        if (format->format)
 -              pretty_print_ref(name, oid->hash, format);
 +              pretty_print_ref(name, oid, format);
  
        return 0;
  }
@@@ -212,7 -212,7 +212,7 @@@ static void create_tag(const struct obj
        struct strbuf header = STRBUF_INIT;
        char *path = NULL;
  
-       type = oid_object_info(object, NULL);
+       type = oid_object_info(the_repository, object, NULL);
        if (type <= OBJ_NONE)
            die(_("bad object type."));
  
@@@ -298,7 -298,7 +298,7 @@@ static void create_reflog_msg(const str
        }
  
        strbuf_addstr(sb, " (");
-       type = oid_object_info(oid, NULL);
+       type = oid_object_info(the_repository, oid, NULL);
        switch (type) {
        default:
                strbuf_addstr(sb, "object of unknown type");
diff --combined cache.h
index 2fabadd248b6f7118cd790dd19f7d65b4246eef0,3a4d80e92bf739788294346198d1b52dfc01f0e5..f436744363196ee477f5eb2e8cabc968deb5fad1
+++ b/cache.h
@@@ -373,11 -373,6 +373,11 @@@ extern void free_name_hash(struct index
  #define read_blob_data_from_cache(path, sz) read_blob_data_from_index(&the_index, (path), (sz))
  #endif
  
 +/*
 + * Values in this enum (except those outside the 3 bit range) are part
 + * of pack file format. See Documentation/technical/pack-format.txt
 + * for more information.
 + */
  enum object_type {
        OBJ_BAD = -1,
        OBJ_NONE = 0,
@@@ -433,7 -428,6 +433,7 @@@ static inline enum object_type object_t
  #define GIT_ICASE_PATHSPECS_ENVIRONMENT "GIT_ICASE_PATHSPECS"
  #define GIT_QUARANTINE_ENVIRONMENT "GIT_QUARANTINE_PATH"
  #define GIT_OPTIONAL_LOCKS_ENVIRONMENT "GIT_OPTIONAL_LOCKS"
 +#define GIT_TEXT_DOMAIN_DIR_ENVIRONMENT "GIT_TEXTDOMAINDIR"
  
  /*
   * Environment variable used in handshaking the wire protocol.
@@@ -483,7 -477,7 +483,7 @@@ extern const char *get_git_common_dir(v
  extern char *get_object_directory(void);
  extern char *get_index_file(void);
  extern char *get_graft_file(void);
 -extern int set_git_dir(const char *path);
 +extern void set_git_dir(const char *path);
  extern int get_common_dir_noenv(struct strbuf *sb, const char *gitdir);
  extern int get_common_dir(struct strbuf *sb, const char *gitdir);
  extern const char *get_git_namespace(void);
@@@ -811,7 -805,6 +811,7 @@@ extern char *git_replace_ref_base
  
  extern int fsync_object_files;
  extern int core_preload_index;
 +extern int core_commit_graph;
  extern int core_apply_sparse_checkout;
  extern int precomposed_unicode;
  extern int protect_hfs;
@@@ -1199,7 -1192,7 +1199,7 @@@ static inline void *read_object_file(co
  }
  
  /* Read and unpack an object file into memory, write memory to an object file */
extern int oid_object_info(const struct object_id *, unsigned long *);
int oid_object_info(struct repository *r, const struct object_id *, unsigned long *);
  
  extern int hash_object_file(const void *buf, unsigned long len,
                            const char *type, struct object_id *oid);
@@@ -1680,7 -1673,10 +1680,10 @@@ struct object_info 
  #define OBJECT_INFO_QUICK 8
  /* Do not check loose object */
  #define OBJECT_INFO_IGNORE_LOOSE 16
- extern int oid_object_info_extended(const struct object_id *, struct object_info *, unsigned flags);
+ int oid_object_info_extended(struct repository *r,
+                            const struct object_id *,
+                            struct object_info *, unsigned flags);
  
  /*
   * Set this to 0 to prevent sha1_object_info_extended() from fetching missing
diff --combined commit-graph.c
index 3a183abd1ff4dee77bc342c706812f015fa5f437,0000000000000000000000000000000000000000..4c6127088ff96282fbcdc98ef5767281e52846e9
mode 100644,000000..100644
--- /dev/null
@@@ -1,761 -1,0 +1,761 @@@
-       if (packed_object_info(pack, offset, &oi) < 0)
 +#include "cache.h"
 +#include "config.h"
 +#include "git-compat-util.h"
 +#include "lockfile.h"
 +#include "pack.h"
 +#include "packfile.h"
 +#include "commit.h"
 +#include "object.h"
 +#include "revision.h"
 +#include "sha1-lookup.h"
 +#include "commit-graph.h"
 +#include "object-store.h"
 +
 +#define GRAPH_SIGNATURE 0x43475048 /* "CGPH" */
 +#define GRAPH_CHUNKID_OIDFANOUT 0x4f494446 /* "OIDF" */
 +#define GRAPH_CHUNKID_OIDLOOKUP 0x4f49444c /* "OIDL" */
 +#define GRAPH_CHUNKID_DATA 0x43444154 /* "CDAT" */
 +#define GRAPH_CHUNKID_LARGEEDGES 0x45444745 /* "EDGE" */
 +
 +#define GRAPH_DATA_WIDTH 36
 +
 +#define GRAPH_VERSION_1 0x1
 +#define GRAPH_VERSION GRAPH_VERSION_1
 +
 +#define GRAPH_OID_VERSION_SHA1 1
 +#define GRAPH_OID_LEN_SHA1 GIT_SHA1_RAWSZ
 +#define GRAPH_OID_VERSION GRAPH_OID_VERSION_SHA1
 +#define GRAPH_OID_LEN GRAPH_OID_LEN_SHA1
 +
 +#define GRAPH_OCTOPUS_EDGES_NEEDED 0x80000000
 +#define GRAPH_PARENT_MISSING 0x7fffffff
 +#define GRAPH_EDGE_LAST_MASK 0x7fffffff
 +#define GRAPH_PARENT_NONE 0x70000000
 +
 +#define GRAPH_LAST_EDGE 0x80000000
 +
 +#define GRAPH_FANOUT_SIZE (4 * 256)
 +#define GRAPH_CHUNKLOOKUP_WIDTH 12
 +#define GRAPH_MIN_SIZE (5 * GRAPH_CHUNKLOOKUP_WIDTH + GRAPH_FANOUT_SIZE + \
 +                      GRAPH_OID_LEN + 8)
 +
 +char *get_commit_graph_filename(const char *obj_dir)
 +{
 +      return xstrfmt("%s/info/commit-graph", obj_dir);
 +}
 +
 +static struct commit_graph *alloc_commit_graph(void)
 +{
 +      struct commit_graph *g = xcalloc(1, sizeof(*g));
 +      g->graph_fd = -1;
 +
 +      return g;
 +}
 +
 +struct commit_graph *load_commit_graph_one(const char *graph_file)
 +{
 +      void *graph_map;
 +      const unsigned char *data, *chunk_lookup;
 +      size_t graph_size;
 +      struct stat st;
 +      uint32_t i;
 +      struct commit_graph *graph;
 +      int fd = git_open(graph_file);
 +      uint64_t last_chunk_offset;
 +      uint32_t last_chunk_id;
 +      uint32_t graph_signature;
 +      unsigned char graph_version, hash_version;
 +
 +      if (fd < 0)
 +              return NULL;
 +      if (fstat(fd, &st)) {
 +              close(fd);
 +              return NULL;
 +      }
 +      graph_size = xsize_t(st.st_size);
 +
 +      if (graph_size < GRAPH_MIN_SIZE) {
 +              close(fd);
 +              die("graph file %s is too small", graph_file);
 +      }
 +      graph_map = xmmap(NULL, graph_size, PROT_READ, MAP_PRIVATE, fd, 0);
 +      data = (const unsigned char *)graph_map;
 +
 +      graph_signature = get_be32(data);
 +      if (graph_signature != GRAPH_SIGNATURE) {
 +              error("graph signature %X does not match signature %X",
 +                    graph_signature, GRAPH_SIGNATURE);
 +              goto cleanup_fail;
 +      }
 +
 +      graph_version = *(unsigned char*)(data + 4);
 +      if (graph_version != GRAPH_VERSION) {
 +              error("graph version %X does not match version %X",
 +                    graph_version, GRAPH_VERSION);
 +              goto cleanup_fail;
 +      }
 +
 +      hash_version = *(unsigned char*)(data + 5);
 +      if (hash_version != GRAPH_OID_VERSION) {
 +              error("hash version %X does not match version %X",
 +                    hash_version, GRAPH_OID_VERSION);
 +              goto cleanup_fail;
 +      }
 +
 +      graph = alloc_commit_graph();
 +
 +      graph->hash_len = GRAPH_OID_LEN;
 +      graph->num_chunks = *(unsigned char*)(data + 6);
 +      graph->graph_fd = fd;
 +      graph->data = graph_map;
 +      graph->data_len = graph_size;
 +
 +      last_chunk_id = 0;
 +      last_chunk_offset = 8;
 +      chunk_lookup = data + 8;
 +      for (i = 0; i < graph->num_chunks; i++) {
 +              uint32_t chunk_id = get_be32(chunk_lookup + 0);
 +              uint64_t chunk_offset = get_be64(chunk_lookup + 4);
 +              int chunk_repeated = 0;
 +
 +              chunk_lookup += GRAPH_CHUNKLOOKUP_WIDTH;
 +
 +              if (chunk_offset > graph_size - GIT_MAX_RAWSZ) {
 +                      error("improper chunk offset %08x%08x", (uint32_t)(chunk_offset >> 32),
 +                            (uint32_t)chunk_offset);
 +                      goto cleanup_fail;
 +              }
 +
 +              switch (chunk_id) {
 +              case GRAPH_CHUNKID_OIDFANOUT:
 +                      if (graph->chunk_oid_fanout)
 +                              chunk_repeated = 1;
 +                      else
 +                              graph->chunk_oid_fanout = (uint32_t*)(data + chunk_offset);
 +                      break;
 +
 +              case GRAPH_CHUNKID_OIDLOOKUP:
 +                      if (graph->chunk_oid_lookup)
 +                              chunk_repeated = 1;
 +                      else
 +                              graph->chunk_oid_lookup = data + chunk_offset;
 +                      break;
 +
 +              case GRAPH_CHUNKID_DATA:
 +                      if (graph->chunk_commit_data)
 +                              chunk_repeated = 1;
 +                      else
 +                              graph->chunk_commit_data = data + chunk_offset;
 +                      break;
 +
 +              case GRAPH_CHUNKID_LARGEEDGES:
 +                      if (graph->chunk_large_edges)
 +                              chunk_repeated = 1;
 +                      else
 +                              graph->chunk_large_edges = data + chunk_offset;
 +                      break;
 +              }
 +
 +              if (chunk_repeated) {
 +                      error("chunk id %08x appears multiple times", chunk_id);
 +                      goto cleanup_fail;
 +              }
 +
 +              if (last_chunk_id == GRAPH_CHUNKID_OIDLOOKUP)
 +              {
 +                      graph->num_commits = (chunk_offset - last_chunk_offset)
 +                                           / graph->hash_len;
 +              }
 +
 +              last_chunk_id = chunk_id;
 +              last_chunk_offset = chunk_offset;
 +      }
 +
 +      return graph;
 +
 +cleanup_fail:
 +      munmap(graph_map, graph_size);
 +      close(fd);
 +      exit(1);
 +}
 +
 +/* global storage */
 +static struct commit_graph *commit_graph = NULL;
 +
 +static void prepare_commit_graph_one(const char *obj_dir)
 +{
 +      char *graph_name;
 +
 +      if (commit_graph)
 +              return;
 +
 +      graph_name = get_commit_graph_filename(obj_dir);
 +      commit_graph = load_commit_graph_one(graph_name);
 +
 +      FREE_AND_NULL(graph_name);
 +}
 +
 +static int prepare_commit_graph_run_once = 0;
 +static void prepare_commit_graph(void)
 +{
 +      struct alternate_object_database *alt;
 +      char *obj_dir;
 +
 +      if (prepare_commit_graph_run_once)
 +              return;
 +      prepare_commit_graph_run_once = 1;
 +
 +      obj_dir = get_object_directory();
 +      prepare_commit_graph_one(obj_dir);
 +      prepare_alt_odb(the_repository);
 +      for (alt = the_repository->objects->alt_odb_list;
 +           !commit_graph && alt;
 +           alt = alt->next)
 +              prepare_commit_graph_one(alt->path);
 +}
 +
 +static void close_commit_graph(void)
 +{
 +      if (!commit_graph)
 +              return;
 +
 +      if (commit_graph->graph_fd >= 0) {
 +              munmap((void *)commit_graph->data, commit_graph->data_len);
 +              commit_graph->data = NULL;
 +              close(commit_graph->graph_fd);
 +      }
 +
 +      FREE_AND_NULL(commit_graph);
 +}
 +
 +static int bsearch_graph(struct commit_graph *g, struct object_id *oid, uint32_t *pos)
 +{
 +      return bsearch_hash(oid->hash, g->chunk_oid_fanout,
 +                          g->chunk_oid_lookup, g->hash_len, pos);
 +}
 +
 +static struct commit_list **insert_parent_or_die(struct commit_graph *g,
 +                                               uint64_t pos,
 +                                               struct commit_list **pptr)
 +{
 +      struct commit *c;
 +      struct object_id oid;
 +      hashcpy(oid.hash, g->chunk_oid_lookup + g->hash_len * pos);
 +      c = lookup_commit(&oid);
 +      if (!c)
 +              die("could not find commit %s", oid_to_hex(&oid));
 +      c->graph_pos = pos;
 +      return &commit_list_insert(c, pptr)->next;
 +}
 +
 +static int fill_commit_in_graph(struct commit *item, struct commit_graph *g, uint32_t pos)
 +{
 +      uint32_t edge_value;
 +      uint32_t *parent_data_ptr;
 +      uint64_t date_low, date_high;
 +      struct commit_list **pptr;
 +      const unsigned char *commit_data = g->chunk_commit_data + (g->hash_len + 16) * pos;
 +
 +      item->object.parsed = 1;
 +      item->graph_pos = pos;
 +
 +      item->maybe_tree = NULL;
 +
 +      date_high = get_be32(commit_data + g->hash_len + 8) & 0x3;
 +      date_low = get_be32(commit_data + g->hash_len + 12);
 +      item->date = (timestamp_t)((date_high << 32) | date_low);
 +
 +      pptr = &item->parents;
 +
 +      edge_value = get_be32(commit_data + g->hash_len);
 +      if (edge_value == GRAPH_PARENT_NONE)
 +              return 1;
 +      pptr = insert_parent_or_die(g, edge_value, pptr);
 +
 +      edge_value = get_be32(commit_data + g->hash_len + 4);
 +      if (edge_value == GRAPH_PARENT_NONE)
 +              return 1;
 +      if (!(edge_value & GRAPH_OCTOPUS_EDGES_NEEDED)) {
 +              pptr = insert_parent_or_die(g, edge_value, pptr);
 +              return 1;
 +      }
 +
 +      parent_data_ptr = (uint32_t*)(g->chunk_large_edges +
 +                        4 * (uint64_t)(edge_value & GRAPH_EDGE_LAST_MASK));
 +      do {
 +              edge_value = get_be32(parent_data_ptr);
 +              pptr = insert_parent_or_die(g,
 +                                          edge_value & GRAPH_EDGE_LAST_MASK,
 +                                          pptr);
 +              parent_data_ptr++;
 +      } while (!(edge_value & GRAPH_LAST_EDGE));
 +
 +      return 1;
 +}
 +
 +int parse_commit_in_graph(struct commit *item)
 +{
 +      if (!core_commit_graph)
 +              return 0;
 +      if (item->object.parsed)
 +              return 1;
 +
 +      prepare_commit_graph();
 +      if (commit_graph) {
 +              uint32_t pos;
 +              int found;
 +              if (item->graph_pos != COMMIT_NOT_FROM_GRAPH) {
 +                      pos = item->graph_pos;
 +                      found = 1;
 +              } else {
 +                      found = bsearch_graph(commit_graph, &(item->object.oid), &pos);
 +              }
 +
 +              if (found)
 +                      return fill_commit_in_graph(item, commit_graph, pos);
 +      }
 +
 +      return 0;
 +}
 +
 +static struct tree *load_tree_for_commit(struct commit_graph *g, struct commit *c)
 +{
 +      struct object_id oid;
 +      const unsigned char *commit_data = g->chunk_commit_data +
 +                                         GRAPH_DATA_WIDTH * (c->graph_pos);
 +
 +      hashcpy(oid.hash, commit_data);
 +      c->maybe_tree = lookup_tree(&oid);
 +
 +      return c->maybe_tree;
 +}
 +
 +struct tree *get_commit_tree_in_graph(const struct commit *c)
 +{
 +      if (c->maybe_tree)
 +              return c->maybe_tree;
 +      if (c->graph_pos == COMMIT_NOT_FROM_GRAPH)
 +              BUG("get_commit_tree_in_graph called from non-commit-graph commit");
 +
 +      return load_tree_for_commit(commit_graph, (struct commit *)c);
 +}
 +
 +static void write_graph_chunk_fanout(struct hashfile *f,
 +                                   struct commit **commits,
 +                                   int nr_commits)
 +{
 +      int i, count = 0;
 +      struct commit **list = commits;
 +
 +      /*
 +       * Write the first-level table (the list is sorted,
 +       * but we use a 256-entry lookup to be able to avoid
 +       * having to do eight extra binary search iterations).
 +       */
 +      for (i = 0; i < 256; i++) {
 +              while (count < nr_commits) {
 +                      if ((*list)->object.oid.hash[0] != i)
 +                              break;
 +                      count++;
 +                      list++;
 +              }
 +
 +              hashwrite_be32(f, count);
 +      }
 +}
 +
 +static void write_graph_chunk_oids(struct hashfile *f, int hash_len,
 +                                 struct commit **commits, int nr_commits)
 +{
 +      struct commit **list = commits;
 +      int count;
 +      for (count = 0; count < nr_commits; count++, list++)
 +              hashwrite(f, (*list)->object.oid.hash, (int)hash_len);
 +}
 +
 +static const unsigned char *commit_to_sha1(size_t index, void *table)
 +{
 +      struct commit **commits = table;
 +      return commits[index]->object.oid.hash;
 +}
 +
 +static void write_graph_chunk_data(struct hashfile *f, int hash_len,
 +                                 struct commit **commits, int nr_commits)
 +{
 +      struct commit **list = commits;
 +      struct commit **last = commits + nr_commits;
 +      uint32_t num_extra_edges = 0;
 +
 +      while (list < last) {
 +              struct commit_list *parent;
 +              int edge_value;
 +              uint32_t packedDate[2];
 +
 +              parse_commit(*list);
 +              hashwrite(f, get_commit_tree_oid(*list)->hash, hash_len);
 +
 +              parent = (*list)->parents;
 +
 +              if (!parent)
 +                      edge_value = GRAPH_PARENT_NONE;
 +              else {
 +                      edge_value = sha1_pos(parent->item->object.oid.hash,
 +                                            commits,
 +                                            nr_commits,
 +                                            commit_to_sha1);
 +
 +                      if (edge_value < 0)
 +                              edge_value = GRAPH_PARENT_MISSING;
 +              }
 +
 +              hashwrite_be32(f, edge_value);
 +
 +              if (parent)
 +                      parent = parent->next;
 +
 +              if (!parent)
 +                      edge_value = GRAPH_PARENT_NONE;
 +              else if (parent->next)
 +                      edge_value = GRAPH_OCTOPUS_EDGES_NEEDED | num_extra_edges;
 +              else {
 +                      edge_value = sha1_pos(parent->item->object.oid.hash,
 +                                            commits,
 +                                            nr_commits,
 +                                            commit_to_sha1);
 +                      if (edge_value < 0)
 +                              edge_value = GRAPH_PARENT_MISSING;
 +              }
 +
 +              hashwrite_be32(f, edge_value);
 +
 +              if (edge_value & GRAPH_OCTOPUS_EDGES_NEEDED) {
 +                      do {
 +                              num_extra_edges++;
 +                              parent = parent->next;
 +                      } while (parent);
 +              }
 +
 +              if (sizeof((*list)->date) > 4)
 +                      packedDate[0] = htonl(((*list)->date >> 32) & 0x3);
 +              else
 +                      packedDate[0] = 0;
 +
 +              packedDate[1] = htonl((*list)->date);
 +              hashwrite(f, packedDate, 8);
 +
 +              list++;
 +      }
 +}
 +
 +static void write_graph_chunk_large_edges(struct hashfile *f,
 +                                        struct commit **commits,
 +                                        int nr_commits)
 +{
 +      struct commit **list = commits;
 +      struct commit **last = commits + nr_commits;
 +      struct commit_list *parent;
 +
 +      while (list < last) {
 +              int num_parents = 0;
 +              for (parent = (*list)->parents; num_parents < 3 && parent;
 +                   parent = parent->next)
 +                      num_parents++;
 +
 +              if (num_parents <= 2) {
 +                      list++;
 +                      continue;
 +              }
 +
 +              /* Since num_parents > 2, this initializer is safe. */
 +              for (parent = (*list)->parents->next; parent; parent = parent->next) {
 +                      int edge_value = sha1_pos(parent->item->object.oid.hash,
 +                                                commits,
 +                                                nr_commits,
 +                                                commit_to_sha1);
 +
 +                      if (edge_value < 0)
 +                              edge_value = GRAPH_PARENT_MISSING;
 +                      else if (!parent->next)
 +                              edge_value |= GRAPH_LAST_EDGE;
 +
 +                      hashwrite_be32(f, edge_value);
 +              }
 +
 +              list++;
 +      }
 +}
 +
 +static int commit_compare(const void *_a, const void *_b)
 +{
 +      const struct object_id *a = (const struct object_id *)_a;
 +      const struct object_id *b = (const struct object_id *)_b;
 +      return oidcmp(a, b);
 +}
 +
 +struct packed_commit_list {
 +      struct commit **list;
 +      int nr;
 +      int alloc;
 +};
 +
 +struct packed_oid_list {
 +      struct object_id *list;
 +      int nr;
 +      int alloc;
 +};
 +
 +static int add_packed_commits(const struct object_id *oid,
 +                            struct packed_git *pack,
 +                            uint32_t pos,
 +                            void *data)
 +{
 +      struct packed_oid_list *list = (struct packed_oid_list*)data;
 +      enum object_type type;
 +      off_t offset = nth_packed_object_offset(pack, pos);
 +      struct object_info oi = OBJECT_INFO_INIT;
 +
 +      oi.typep = &type;
++      if (packed_object_info(the_repository, pack, offset, &oi) < 0)
 +              die("unable to get type of object %s", oid_to_hex(oid));
 +
 +      if (type != OBJ_COMMIT)
 +              return 0;
 +
 +      ALLOC_GROW(list->list, list->nr + 1, list->alloc);
 +      oidcpy(&(list->list[list->nr]), oid);
 +      list->nr++;
 +
 +      return 0;
 +}
 +
 +static void add_missing_parents(struct packed_oid_list *oids, struct commit *commit)
 +{
 +      struct commit_list *parent;
 +      for (parent = commit->parents; parent; parent = parent->next) {
 +              if (!(parent->item->object.flags & UNINTERESTING)) {
 +                      ALLOC_GROW(oids->list, oids->nr + 1, oids->alloc);
 +                      oidcpy(&oids->list[oids->nr], &(parent->item->object.oid));
 +                      oids->nr++;
 +                      parent->item->object.flags |= UNINTERESTING;
 +              }
 +      }
 +}
 +
 +static void close_reachable(struct packed_oid_list *oids)
 +{
 +      int i;
 +      struct commit *commit;
 +
 +      for (i = 0; i < oids->nr; i++) {
 +              commit = lookup_commit(&oids->list[i]);
 +              if (commit)
 +                      commit->object.flags |= UNINTERESTING;
 +      }
 +
 +      /*
 +       * As this loop runs, oids->nr may grow, but not more
 +       * than the number of missing commits in the reachable
 +       * closure.
 +       */
 +      for (i = 0; i < oids->nr; i++) {
 +              commit = lookup_commit(&oids->list[i]);
 +
 +              if (commit && !parse_commit(commit))
 +                      add_missing_parents(oids, commit);
 +      }
 +
 +      for (i = 0; i < oids->nr; i++) {
 +              commit = lookup_commit(&oids->list[i]);
 +
 +              if (commit)
 +                      commit->object.flags &= ~UNINTERESTING;
 +      }
 +}
 +
 +void write_commit_graph(const char *obj_dir,
 +                      const char **pack_indexes,
 +                      int nr_packs,
 +                      const char **commit_hex,
 +                      int nr_commits,
 +                      int append)
 +{
 +      struct packed_oid_list oids;
 +      struct packed_commit_list commits;
 +      struct hashfile *f;
 +      uint32_t i, count_distinct = 0;
 +      char *graph_name;
 +      int fd;
 +      struct lock_file lk = LOCK_INIT;
 +      uint32_t chunk_ids[5];
 +      uint64_t chunk_offsets[5];
 +      int num_chunks;
 +      int num_extra_edges;
 +      struct commit_list *parent;
 +
 +      oids.nr = 0;
 +      oids.alloc = approximate_object_count() / 4;
 +
 +      if (append) {
 +              prepare_commit_graph_one(obj_dir);
 +              if (commit_graph)
 +                      oids.alloc += commit_graph->num_commits;
 +      }
 +
 +      if (oids.alloc < 1024)
 +              oids.alloc = 1024;
 +      ALLOC_ARRAY(oids.list, oids.alloc);
 +
 +      if (append && commit_graph) {
 +              for (i = 0; i < commit_graph->num_commits; i++) {
 +                      const unsigned char *hash = commit_graph->chunk_oid_lookup +
 +                              commit_graph->hash_len * i;
 +                      hashcpy(oids.list[oids.nr++].hash, hash);
 +              }
 +      }
 +
 +      if (pack_indexes) {
 +              struct strbuf packname = STRBUF_INIT;
 +              int dirlen;
 +              strbuf_addf(&packname, "%s/pack/", obj_dir);
 +              dirlen = packname.len;
 +              for (i = 0; i < nr_packs; i++) {
 +                      struct packed_git *p;
 +                      strbuf_setlen(&packname, dirlen);
 +                      strbuf_addstr(&packname, pack_indexes[i]);
 +                      p = add_packed_git(packname.buf, packname.len, 1);
 +                      if (!p)
 +                              die("error adding pack %s", packname.buf);
 +                      if (open_pack_index(p))
 +                              die("error opening index for %s", packname.buf);
 +                      for_each_object_in_pack(p, add_packed_commits, &oids);
 +                      close_pack(p);
 +              }
 +              strbuf_release(&packname);
 +      }
 +
 +      if (commit_hex) {
 +              for (i = 0; i < nr_commits; i++) {
 +                      const char *end;
 +                      struct object_id oid;
 +                      struct commit *result;
 +
 +                      if (commit_hex[i] && parse_oid_hex(commit_hex[i], &oid, &end))
 +                              continue;
 +
 +                      result = lookup_commit_reference_gently(&oid, 1);
 +
 +                      if (result) {
 +                              ALLOC_GROW(oids.list, oids.nr + 1, oids.alloc);
 +                              oidcpy(&oids.list[oids.nr], &(result->object.oid));
 +                              oids.nr++;
 +                      }
 +              }
 +      }
 +
 +      if (!pack_indexes && !commit_hex)
 +              for_each_packed_object(add_packed_commits, &oids, 0);
 +
 +      close_reachable(&oids);
 +
 +      QSORT(oids.list, oids.nr, commit_compare);
 +
 +      count_distinct = 1;
 +      for (i = 1; i < oids.nr; i++) {
 +              if (oidcmp(&oids.list[i-1], &oids.list[i]))
 +                      count_distinct++;
 +      }
 +
 +      if (count_distinct >= GRAPH_PARENT_MISSING)
 +              die(_("the commit graph format cannot write %d commits"), count_distinct);
 +
 +      commits.nr = 0;
 +      commits.alloc = count_distinct;
 +      ALLOC_ARRAY(commits.list, commits.alloc);
 +
 +      num_extra_edges = 0;
 +      for (i = 0; i < oids.nr; i++) {
 +              int num_parents = 0;
 +              if (i > 0 && !oidcmp(&oids.list[i-1], &oids.list[i]))
 +                      continue;
 +
 +              commits.list[commits.nr] = lookup_commit(&oids.list[i]);
 +              parse_commit(commits.list[commits.nr]);
 +
 +              for (parent = commits.list[commits.nr]->parents;
 +                   parent; parent = parent->next)
 +                      num_parents++;
 +
 +              if (num_parents > 2)
 +                      num_extra_edges += num_parents - 1;
 +
 +              commits.nr++;
 +      }
 +      num_chunks = num_extra_edges ? 4 : 3;
 +
 +      if (commits.nr >= GRAPH_PARENT_MISSING)
 +              die(_("too many commits to write graph"));
 +
 +      graph_name = get_commit_graph_filename(obj_dir);
 +      fd = hold_lock_file_for_update(&lk, graph_name, 0);
 +
 +      if (fd < 0) {
 +              struct strbuf folder = STRBUF_INIT;
 +              strbuf_addstr(&folder, graph_name);
 +              strbuf_setlen(&folder, strrchr(folder.buf, '/') - folder.buf);
 +
 +              if (mkdir(folder.buf, 0777) < 0)
 +                      die_errno(_("cannot mkdir %s"), folder.buf);
 +              strbuf_release(&folder);
 +
 +              fd = hold_lock_file_for_update(&lk, graph_name, LOCK_DIE_ON_ERROR);
 +
 +              if (fd < 0)
 +                      die_errno("unable to create '%s'", graph_name);
 +      }
 +
 +      f = hashfd(lk.tempfile->fd, lk.tempfile->filename.buf);
 +
 +      hashwrite_be32(f, GRAPH_SIGNATURE);
 +
 +      hashwrite_u8(f, GRAPH_VERSION);
 +      hashwrite_u8(f, GRAPH_OID_VERSION);
 +      hashwrite_u8(f, num_chunks);
 +      hashwrite_u8(f, 0); /* unused padding byte */
 +
 +      chunk_ids[0] = GRAPH_CHUNKID_OIDFANOUT;
 +      chunk_ids[1] = GRAPH_CHUNKID_OIDLOOKUP;
 +      chunk_ids[2] = GRAPH_CHUNKID_DATA;
 +      if (num_extra_edges)
 +              chunk_ids[3] = GRAPH_CHUNKID_LARGEEDGES;
 +      else
 +              chunk_ids[3] = 0;
 +      chunk_ids[4] = 0;
 +
 +      chunk_offsets[0] = 8 + (num_chunks + 1) * GRAPH_CHUNKLOOKUP_WIDTH;
 +      chunk_offsets[1] = chunk_offsets[0] + GRAPH_FANOUT_SIZE;
 +      chunk_offsets[2] = chunk_offsets[1] + GRAPH_OID_LEN * commits.nr;
 +      chunk_offsets[3] = chunk_offsets[2] + (GRAPH_OID_LEN + 16) * commits.nr;
 +      chunk_offsets[4] = chunk_offsets[3] + 4 * num_extra_edges;
 +
 +      for (i = 0; i <= num_chunks; i++) {
 +              uint32_t chunk_write[3];
 +
 +              chunk_write[0] = htonl(chunk_ids[i]);
 +              chunk_write[1] = htonl(chunk_offsets[i] >> 32);
 +              chunk_write[2] = htonl(chunk_offsets[i] & 0xffffffff);
 +              hashwrite(f, chunk_write, 12);
 +      }
 +
 +      write_graph_chunk_fanout(f, commits.list, commits.nr);
 +      write_graph_chunk_oids(f, GRAPH_OID_LEN, commits.list, commits.nr);
 +      write_graph_chunk_data(f, GRAPH_OID_LEN, commits.list, commits.nr);
 +      write_graph_chunk_large_edges(f, commits.list, commits.nr);
 +
 +      close_commit_graph();
 +      finalize_hashfile(f, NULL, CSUM_HASH_IN_STREAM | CSUM_FSYNC);
 +      commit_lock_file(&lk);
 +
 +      free(oids.list);
 +      oids.alloc = 0;
 +      oids.nr = 0;
 +}
diff --combined fast-import.c
index 34edf3fb8f9012bf2fcaf231604ebb490e66940c,b009353e93ef1399542689173062c6ea3275dcc9..b2338fa8eb20d5c52d2bf03d73dca050721c292c
@@@ -170,7 -170,6 +170,7 @@@ Format of STDIN stream
  #include "run-command.h"
  #include "packfile.h"
  #include "object-store.h"
 +#include "mem-pool.h"
  
  #define PACK_ID_BITS 16
  #define MAX_PACK_ID ((1<<PACK_ID_BITS)-1)
@@@ -212,6 -211,13 +212,6 @@@ struct last_object 
        unsigned no_swap : 1;
  };
  
 -struct mem_pool {
 -      struct mem_pool *next_pool;
 -      char *next_free;
 -      char *end;
 -      uintmax_t space[FLEX_ARRAY]; /* more */
 -};
 -
  struct atom_str {
        struct atom_str *next_atom;
        unsigned short str_len;
@@@ -300,8 -306,9 +300,8 @@@ static int global_argc
  static const char **global_argv;
  
  /* Memory pools */
 -static size_t mem_pool_alloc = 2*1024*1024 - sizeof(struct mem_pool);
 -static size_t total_allocd;
 -static struct mem_pool *mem_pool;
 +static struct mem_pool fi_mem_pool =  {NULL, 2*1024*1024 -
 +                                     sizeof(struct mp_block), 0 };
  
  /* Atom management */
  static unsigned int atom_table_sz = 4451;
@@@ -336,7 -343,6 +336,7 @@@ static unsigned int tree_entry_alloc = 
  static void *avail_tree_entry;
  static unsigned int avail_tree_table_sz = 100;
  static struct avail_tree_content **avail_tree_table;
 +static size_t tree_entry_allocd;
  static struct strbuf old_tree = STRBUF_INIT;
  static struct strbuf new_tree = STRBUF_INIT;
  
@@@ -630,10 -636,49 +630,10 @@@ static unsigned int hc_str(const char *
        return r;
  }
  
 -static void *pool_alloc(size_t len)
 -{
 -      struct mem_pool *p;
 -      void *r;
 -
 -      /* round up to a 'uintmax_t' alignment */
 -      if (len & (sizeof(uintmax_t) - 1))
 -              len += sizeof(uintmax_t) - (len & (sizeof(uintmax_t) - 1));
 -
 -      for (p = mem_pool; p; p = p->next_pool)
 -              if ((p->end - p->next_free >= len))
 -                      break;
 -
 -      if (!p) {
 -              if (len >= (mem_pool_alloc/2)) {
 -                      total_allocd += len;
 -                      return xmalloc(len);
 -              }
 -              total_allocd += sizeof(struct mem_pool) + mem_pool_alloc;
 -              p = xmalloc(st_add(sizeof(struct mem_pool), mem_pool_alloc));
 -              p->next_pool = mem_pool;
 -              p->next_free = (char *) p->space;
 -              p->end = p->next_free + mem_pool_alloc;
 -              mem_pool = p;
 -      }
 -
 -      r = p->next_free;
 -      p->next_free += len;
 -      return r;
 -}
 -
 -static void *pool_calloc(size_t count, size_t size)
 -{
 -      size_t len = count * size;
 -      void *r = pool_alloc(len);
 -      memset(r, 0, len);
 -      return r;
 -}
 -
  static char *pool_strdup(const char *s)
  {
        size_t len = strlen(s) + 1;
 -      char *r = pool_alloc(len);
 +      char *r = mem_pool_alloc(&fi_mem_pool, len);
        memcpy(r, s, len);
        return r;
  }
@@@ -642,7 -687,7 +642,7 @@@ static void insert_mark(uintmax_t idnum
  {
        struct mark_set *s = marks;
        while ((idnum >> s->shift) >= 1024) {
 -              s = pool_calloc(1, sizeof(struct mark_set));
 +              s = mem_pool_calloc(&fi_mem_pool, 1, sizeof(struct mark_set));
                s->shift = marks->shift + 10;
                s->data.sets[0] = marks;
                marks = s;
                uintmax_t i = idnum >> s->shift;
                idnum -= i << s->shift;
                if (!s->data.sets[i]) {
 -                      s->data.sets[i] = pool_calloc(1, sizeof(struct mark_set));
 +                      s->data.sets[i] = mem_pool_calloc(&fi_mem_pool, 1, sizeof(struct mark_set));
                        s->data.sets[i]->shift = s->shift - 10;
                }
                s = s->data.sets[i];
@@@ -689,7 -734,7 +689,7 @@@ static struct atom_str *to_atom(const c
                if (c->str_len == len && !strncmp(s, c->str_dat, len))
                        return c;
  
 -      c = pool_alloc(sizeof(struct atom_str) + len + 1);
 +      c = mem_pool_alloc(&fi_mem_pool, sizeof(struct atom_str) + len + 1);
        c->str_len = len;
        memcpy(c->str_dat, s, len);
        c->str_dat[len] = 0;
@@@ -720,7 -765,7 +720,7 @@@ static struct branch *new_branch(const 
        if (check_refname_format(name, REFNAME_ALLOW_ONELEVEL))
                die("Branch name doesn't conform to GIT standards: %s", name);
  
 -      b = pool_calloc(1, sizeof(struct branch));
 +      b = mem_pool_calloc(&fi_mem_pool, 1, sizeof(struct branch));
        b->name = pool_strdup(name);
        b->table_next_branch = branch_table[hc];
        b->branch_tree.versions[0].mode = S_IFDIR;
@@@ -756,7 -801,7 +756,7 @@@ static struct tree_content *new_tree_co
                        avail_tree_table[hc] = f->next_avail;
        } else {
                cnt = cnt & 7 ? ((cnt / 8) + 1) * 8 : cnt;
 -              f = pool_alloc(sizeof(*t) + sizeof(t->entries[0]) * cnt);
 +              f = mem_pool_alloc(&fi_mem_pool, sizeof(*t) + sizeof(t->entries[0]) * cnt);
                f->entry_capacity = cnt;
        }
  
@@@ -801,7 -846,7 +801,7 @@@ static struct tree_entry *new_tree_entr
  
        if (!avail_tree_entry) {
                unsigned int n = tree_entry_alloc;
 -              total_allocd += n * sizeof(struct tree_entry);
 +              tree_entry_allocd += n * sizeof(struct tree_entry);
                ALLOC_ARRAY(e, n);
                avail_tree_entry = e;
                while (n-- > 1) {
@@@ -973,7 -1018,7 +973,7 @@@ static void end_packfile(void
                struct tag *t;
  
                close_pack_windows(pack_data);
 -              hashclose(pack_file, cur_pack_oid.hash, 0);
 +              finalize_hashfile(pack_file, cur_pack_oid.hash, 0);
                fixup_pack_header_footer(pack_data->pack_fd, pack_data->sha1,
                                    pack_data->pack_name, object_count,
                                    cur_pack_oid.hash, pack_size);
@@@ -1331,7 -1376,7 +1331,7 @@@ static void *gfi_unpack_entry
                 */
                p->pack_size = pack_size + the_hash_algo->rawsz;
        }
-       return unpack_entry(p, oe->idx.offset, &type, sizep);
+       return unpack_entry(the_repository, p, oe->idx.offset, &type, sizep);
  }
  
  static const char *get_mode(const char *str, uint16_t *modep)
@@@ -1872,7 -1917,8 +1872,8 @@@ static void read_marks(void
                        die("corrupt mark line: %s", line);
                e = find_object(&oid);
                if (!e) {
-                       enum object_type type = oid_object_info(&oid, NULL);
+                       enum object_type type = oid_object_info(the_repository,
+                                                               &oid, NULL);
                        if (type < 0)
                                die("object not found: %s", oid_to_hex(&oid));
                        e = insert_object(&oid);
@@@ -2402,7 -2448,8 +2403,8 @@@ static void file_change_m(const char *p
                enum object_type expected = S_ISDIR(mode) ?
                                                OBJ_TREE: OBJ_BLOB;
                enum object_type type = oe ? oe->type :
-                                       oid_object_info(&oid, NULL);
+                                       oid_object_info(the_repository, &oid,
+                                                       NULL);
                if (type < 0)
                        die("%s not found: %s",
                                        S_ISDIR(mode) ?  "Tree" : "Blob",
@@@ -2563,7 -2610,8 +2565,8 @@@ static void note_change_n(const char *p
                        die("Not a blob (actually a %s): %s",
                                type_name(oe->type), command_buf.buf);
        } else if (!is_null_oid(&oid)) {
-               enum object_type type = oid_object_info(&oid, NULL);
+               enum object_type type = oid_object_info(the_repository, &oid,
+                                                       NULL);
                if (type < 0)
                        die("Blob not found: %s", command_buf.buf);
                if (type != OBJ_BLOB)
@@@ -2822,7 -2870,7 +2825,7 @@@ static void parse_new_tag(const char *a
        enum object_type type;
        const char *v;
  
 -      t = pool_alloc(sizeof(struct tag));
 +      t = mem_pool_alloc(&fi_mem_pool, sizeof(struct tag));
        memset(t, 0, sizeof(struct tag));
        t->name = pool_strdup(arg);
        if (last_tag)
        } else if (!get_oid(from, &oid)) {
                struct object_entry *oe = find_object(&oid);
                if (!oe) {
-                       type = oid_object_info(&oid, NULL);
+                       type = oid_object_info(the_repository, &oid, NULL);
                        if (type < 0)
                                die("Not a valid object: %s", from);
                } else
@@@ -3008,7 -3056,8 +3011,8 @@@ static struct object_entry *dereference
        unsigned long size;
        char *buf = NULL;
        if (!oe) {
-               enum object_type type = oid_object_info(oid, NULL);
+               enum object_type type = oid_object_info(the_repository, oid,
+                                                       NULL);
                if (type < 0)
                        die("object not found: %s", oid_to_hex(oid));
                /* cache it! */
@@@ -3421,12 -3470,12 +3425,12 @@@ int cmd_main(int argc, const char **arg
        atom_table = xcalloc(atom_table_sz, sizeof(struct atom_str*));
        branch_table = xcalloc(branch_table_sz, sizeof(struct branch*));
        avail_tree_table = xcalloc(avail_tree_table_sz, sizeof(struct avail_tree_content*));
 -      marks = pool_calloc(1, sizeof(struct mark_set));
 +      marks = mem_pool_calloc(&fi_mem_pool, 1, sizeof(struct mark_set));
  
        global_argc = argc;
        global_argv = argv;
  
 -      rc_free = pool_alloc(cmd_save * sizeof(*rc_free));
 +      rc_free = mem_pool_alloc(&fi_mem_pool, cmd_save * sizeof(*rc_free));
        for (i = 0; i < (cmd_save - 1); i++)
                rc_free[i].next = &rc_free[i + 1];
        rc_free[cmd_save - 1].next = NULL;
                fprintf(stderr, "Total branches:  %10lu (%10lu loads     )\n", branch_count, branch_load_count);
                fprintf(stderr, "      marks:     %10" PRIuMAX " (%10" PRIuMAX " unique    )\n", (((uintmax_t)1) << marks->shift) * 1024, marks_set_count);
                fprintf(stderr, "      atoms:     %10u\n", atom_cnt);
 -              fprintf(stderr, "Memory total:    %10" PRIuMAX " KiB\n", (total_allocd + alloc_count*sizeof(struct object_entry))/1024);
 -              fprintf(stderr, "       pools:    %10lu KiB\n", (unsigned long)(total_allocd/1024));
 +              fprintf(stderr, "Memory total:    %10" PRIuMAX " KiB\n", (tree_entry_allocd + fi_mem_pool.pool_alloc + alloc_count*sizeof(struct object_entry))/1024);
 +              fprintf(stderr, "       pools:    %10lu KiB\n", (unsigned long)((tree_entry_allocd + fi_mem_pool.pool_alloc) /1024));
                fprintf(stderr, "     objects:    %10" PRIuMAX " KiB\n", (alloc_count*sizeof(struct object_entry))/1024);
                fprintf(stderr, "---------------------------------------------------------------------\n");
                pack_report();
diff --combined list-objects-filter.c
index 247717561f8fb6e2320b0128cad4325a4fca7da5,ea94fe8af28d00763f57483e9d8a53dd6197105f..5b14d2711ad3791169f5d8cbc03836b4254bd55c
@@@ -19,7 -19,7 +19,7 @@@
   * in the traversal (until we mark it SEEN).  This is a way to
   * let us silently de-dup calls to show() in the caller.  This
   * is subtly different from the "revision.h:SHOWN" and the
 - * "sha1_name.c:ONELINE_SEEN" bits.  And also different from
 + * "sha1-name.c:ONELINE_SEEN" bits.  And also different from
   * the non-de-dup usage in pack-bitmap.c
   */
  #define FILTER_SHOWN_BUT_REVISIT (1<<21)
@@@ -117,7 -117,7 +117,7 @@@ static enum list_objects_filter_result 
                assert(obj->type == OBJ_BLOB);
                assert((obj->flags & SEEN) == 0);
  
-               t = oid_object_info(&obj->oid, &object_length);
+               t = oid_object_info(the_repository, &obj->oid, &object_length);
                if (t != OBJ_BLOB) { /* probably OBJ_NONE */
                        /*
                         * We DO NOT have the blob locally, so we cannot
diff --combined object.c
index 97245fdea25c2d1342e0d4e791d82e2aeadaed7c,5044d08e96c287b722fcf300dfdf960fe27d2442..f7f4de3aaf6d42a6dde5811b37aa8239ac183754
+++ b/object.c
@@@ -257,7 -257,7 +257,7 @@@ struct object *parse_object(const struc
  
        if ((obj && obj->type == OBJ_BLOB && has_object_file(oid)) ||
            (!obj && has_object_file(oid) &&
-            oid_object_info(oid, NULL) == OBJ_BLOB)) {
+            oid_object_info(the_repository, oid, NULL) == OBJ_BLOB)) {
                if (check_object_signature(repl, NULL, 0, NULL) < 0) {
                        error("sha1 mismatch %s", oid_to_hex(oid));
                        return NULL;
@@@ -481,9 -481,6 +481,9 @@@ void raw_object_store_clear(struct raw_
        FREE_AND_NULL(o->objectdir);
        FREE_AND_NULL(o->alternate_db);
  
 +      oidmap_free(o->replace_map, 1);
 +      FREE_AND_NULL(o->replace_map);
 +
        free_alt_odbs(o);
        o->alt_odb_tail = NULL;
  
diff --combined pack-bitmap-write.c
index 9d1bb054bbbee6631bc2c9acae529da813548367,cd1903e717a141a0e8e695dd6750092af27120fe..f202b64911d325e060549738fa0e88b3ada9b408
@@@ -73,7 -73,8 +73,8 @@@ void bitmap_writer_build_type_index(str
                        break;
  
                default:
-                       real_type = oid_object_info(&entry->idx.oid, NULL);
+                       real_type = oid_object_info(the_repository,
+                                                   &entry->idx.oid, NULL);
                        break;
                }
  
@@@ -534,7 -535,7 +535,7 @@@ void bitmap_writer_finish(struct pack_i
        if (options & BITMAP_OPT_HASH_CACHE)
                write_hash_cache(f, index, index_nr);
  
 -      hashclose(f, NULL, CSUM_FSYNC);
 +      finalize_hashfile(f, NULL, CSUM_HASH_IN_STREAM | CSUM_FSYNC | CSUM_CLOSE);
  
        if (adjust_shared_perm(tmp_file.buf))
                die_errno("unable to make temporary bitmap file readable");
diff --combined packfile.c
index bfe2385f2a2b43984449f0cd49e92ce5541c998c,55d383ed0a974c6752a9ad4bff933f9c11446484..9e7e693fb55d539aa7efcf909c6b07c6d153ae39
@@@ -304,7 -304,7 +304,7 @@@ void close_pack_index(struct packed_gi
        }
  }
  
 -static void close_pack(struct packed_git *p)
 +void close_pack(struct packed_git *p)
  {
        close_pack_windows(p);
        close_pack_fd(p);
@@@ -1104,7 -1104,9 +1104,9 @@@ static const unsigned char *get_delta_b
                return NULL;
  }
  
- static int retry_bad_packed_offset(struct packed_git *p, off_t obj_offset)
+ static int retry_bad_packed_offset(struct repository *r,
+                                  struct packed_git *p,
+                                  off_t obj_offset)
  {
        int type;
        struct revindex_entry *revidx;
                return OBJ_BAD;
        nth_packed_object_oid(&oid, p, revidx->nr);
        mark_bad_packed_object(p, oid.hash);
-       type = oid_object_info(&oid, NULL);
+       type = oid_object_info(r, &oid, NULL);
        if (type <= OBJ_NONE)
                return OBJ_BAD;
        return type;
  
  #define POI_STACK_PREALLOC 64
  
- static enum object_type packed_to_object_type(struct packed_git *p,
+ static enum object_type packed_to_object_type(struct repository *r,
+                                             struct packed_git *p,
                                              off_t obj_offset,
                                              enum object_type type,
                                              struct pack_window **w_curs,
                if (type <= OBJ_NONE) {
                        /* If getting the base itself fails, we first
                         * retry the base, otherwise unwind */
-                       type = retry_bad_packed_offset(p, base_offset);
+                       type = retry_bad_packed_offset(r, p, base_offset);
                        if (type > OBJ_NONE)
                                goto out;
                        goto unwind;
@@@ -1181,7 -1184,7 +1184,7 @@@ out
  unwind:
        while (poi_stack_nr) {
                obj_offset = poi_stack[--poi_stack_nr];
-               type = retry_bad_packed_offset(p, obj_offset);
+               type = retry_bad_packed_offset(r, p, obj_offset);
                if (type > OBJ_NONE)
                        goto out;
        }
@@@ -1268,14 -1271,15 +1271,15 @@@ static void detach_delta_base_cache_ent
        free(ent);
  }
  
- static void *cache_or_unpack_entry(struct packed_git *p, off_t base_offset,
-       unsigned long *base_size, enum object_type *type)
+ static void *cache_or_unpack_entry(struct repository *r, struct packed_git *p,
+                                  off_t base_offset, unsigned long *base_size,
+                                  enum object_type *type)
  {
        struct delta_base_cache_entry *ent;
  
        ent = get_delta_base_cache_entry(p, base_offset);
        if (!ent)
-               return unpack_entry(p, base_offset, type, base_size);
+               return unpack_entry(r, p, base_offset, type, base_size);
  
        if (type)
                *type = ent->type;
@@@ -1329,8 -1333,8 +1333,8 @@@ static void add_delta_base_cache(struc
        hashmap_add(&delta_base_cache, ent);
  }
  
- int packed_object_info(struct packed_git *p, off_t obj_offset,
-                      struct object_info *oi)
+ int packed_object_info(struct repository *r, struct packed_git *p,
+                      off_t obj_offset, struct object_info *oi)
  {
        struct pack_window *w_curs = NULL;
        unsigned long size;
         * a "real" type later if the caller is interested.
         */
        if (oi->contentp) {
-               *oi->contentp = cache_or_unpack_entry(p, obj_offset, oi->sizep,
+               *oi->contentp = cache_or_unpack_entry(r, p, obj_offset, oi->sizep,
                                                      &type);
                if (!*oi->contentp)
                        type = OBJ_BAD;
  
        if (oi->typep || oi->type_name) {
                enum object_type ptot;
-               ptot = packed_to_object_type(p, obj_offset, type, &w_curs,
-                                            curpos);
+               ptot = packed_to_object_type(r, p, obj_offset,
+                                            type, &w_curs, curpos);
                if (oi->typep)
                        *oi->typep = ptot;
                if (oi->type_name) {
@@@ -1465,7 -1469,9 +1469,9 @@@ struct unpack_entry_stack_ent 
        unsigned long size;
  };
  
- static void *read_object(const struct object_id *oid, enum object_type *type,
+ static void *read_object(struct repository *r,
+                        const struct object_id *oid,
+                        enum object_type *type,
                         unsigned long *size)
  {
        struct object_info oi = OBJECT_INFO_INIT;
        oi.sizep = size;
        oi.contentp = &content;
  
-       if (oid_object_info_extended(oid, &oi, 0) < 0)
+       if (oid_object_info_extended(r, oid, &oi, 0) < 0)
                return NULL;
        return content;
  }
  
- void *unpack_entry(struct packed_git *p, off_t obj_offset,
+ void *unpack_entry(struct repository *r, struct packed_git *p, off_t obj_offset,
                   enum object_type *final_type, unsigned long *final_size)
  {
        struct pack_window *w_curs = NULL;
                                      oid_to_hex(&base_oid), (uintmax_t)obj_offset,
                                      p->pack_name);
                                mark_bad_packed_object(p, base_oid.hash);
-                               base = read_object(&base_oid, &type, &base_size);
+                               base = read_object(r, &base_oid, &type, &base_size);
                                external_base = base;
                        }
                }
@@@ -1869,7 -1875,7 +1875,7 @@@ int has_pack_index(const unsigned char 
        return 1;
  }
  
 -static int for_each_object_in_pack(struct packed_git *p, each_packed_object_fn cb, void *data)
 +int for_each_object_in_pack(struct packed_git *p, each_packed_object_fn cb, void *data)
  {
        uint32_t i;
        int r = 0;
@@@ -1944,7 -1950,7 +1950,7 @@@ static int add_promisor_object(const st
                struct commit *commit = (struct commit *) obj;
                struct commit_list *parents = commit->parents;
  
 -              oidset_insert(set, &commit->tree->object.oid);
 +              oidset_insert(set, get_commit_tree_oid(commit));
                for (; parents; parents = parents->next)
                        oidset_insert(set, &parents->item->object.oid);
        } else if (obj->type == OBJ_TAG) {
diff --combined packfile.h
index 9c2f885994546df4271e6a57d253cdae820b025c,fdfddb89b534c84a220e8d96235843f3a6cf4161..bfd0b5399de090c2e404a4e210eeaa59586ca7cc
@@@ -65,7 -65,6 +65,7 @@@ extern void close_pack_index(struct pac
  
  extern unsigned char *use_pack(struct packed_git *, struct pack_window **, off_t, unsigned long *);
  extern void close_pack_windows(struct packed_git *);
 +extern void close_pack(struct packed_git *);
  extern void close_all_packs(struct raw_object_store *o);
  extern void unuse_pack(struct pack_window **);
  extern void clear_delta_base_cache(void);
@@@ -116,7 -115,7 +116,7 @@@ extern off_t nth_packed_object_offset(c
  extern off_t find_pack_entry_one(const unsigned char *sha1, struct packed_git *);
  
  extern int is_pack_valid(struct packed_git *);
- extern void *unpack_entry(struct packed_git *, off_t, enum object_type *, unsigned long *);
+ extern void *unpack_entry(struct repository *r, struct packed_git *, off_t, enum object_type *, unsigned long *);
  extern unsigned long unpack_object_header_buffer(const unsigned char *buf, unsigned long len, enum object_type *type, unsigned long *sizep);
  extern unsigned long get_size_from_delta(struct packed_git *, struct pack_window **, off_t);
  extern int unpack_object_header(struct packed_git *, struct pack_window **, off_t *, unsigned long *);
@@@ -126,7 -125,9 +126,9 @@@ extern void release_pack_memory(size_t)
  /* global flag to enable extra checks when accessing packed objects */
  extern int do_check_packed_object_crc;
  
- extern int packed_object_info(struct packed_git *pack, off_t offset, struct object_info *);
+ extern int packed_object_info(struct repository *r,
+                             struct packed_git *pack,
+                             off_t offset, struct object_info *);
  
  extern void mark_bad_packed_object(struct packed_git *p, const unsigned char *sha1);
  extern const struct packed_git *has_packed_and_bad(const unsigned char *sha1);
@@@ -155,7 -156,6 +157,7 @@@ typedef int each_packed_object_fn(cons
                                  struct packed_git *pack,
                                  uint32_t pos,
                                  void *data);
 +extern int for_each_object_in_pack(struct packed_git *p, each_packed_object_fn, void *data);
  extern int for_each_packed_object(each_packed_object_fn, void *, unsigned flags);
  
  /*
diff --combined refs.c
index 2e4a42f45963c5f8725b339cdab7b6a52e685e4d,27c88ba7689f781c79f2026aabca00395637b27e..6fa3a4962a91a87e88c8cd12fd79a2dc4e714b58
--- 1/refs.c
--- 2/refs.c
+++ b/refs.c
@@@ -13,7 -13,6 +13,7 @@@
  #include "tag.h"
  #include "submodule.h"
  #include "worktree.h"
 +#include "argv-array.h"
  #include "repository.h"
  
  /*
@@@ -303,7 -302,7 +303,7 @@@ enum peel_status peel_object(const stru
        struct object *o = lookup_unknown_object(name->hash);
  
        if (o->type == OBJ_NONE) {
-               int type = oid_object_info(name, NULL);
+               int type = oid_object_info(the_repository, name, NULL);
                if (type < 0 || !object_as_type(o, type, 0))
                        return PEEL_INVALID;
        }
@@@ -503,19 -502,6 +503,19 @@@ int refname_match(const char *abbrev_na
        return 0;
  }
  
 +/*
 + * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
 + * the results to 'prefixes'
 + */
 +void expand_ref_prefix(struct argv_array *prefixes, const char *prefix)
 +{
 +      const char **p;
 +      int len = strlen(prefix);
 +
 +      for (p = ref_rev_parse_rules; *p; p++)
 +              argv_array_pushf(prefixes, *p, len, prefix);
 +}
 +
  /*
   * *string and *len will only be substituted, and *string returned (for
   * later free()ing) if the string passed in is a magic short-hand form
@@@ -1668,9 -1654,6 +1668,9 @@@ struct ref_store *get_main_ref_store(st
        if (r->refs)
                return r->refs;
  
 +      if (!r->gitdir)
 +              BUG("attempting to get main_ref_store outside of repository");
 +
        r->refs = ref_store_init(r->gitdir, REF_STORE_ALL_CAPS);
        return r->refs;
  }
diff --combined sequencer.c
index 2f69f5a0d3a64628dbab60f939b1f40f5f689316,44f0518b9c4d5d11dcab3a2177015837c1cdab1c..f10033b9dcb7fcd7368bff3c556e9d4b49fbf25f
@@@ -7,7 -7,7 +7,7 @@@
  #include "sequencer.h"
  #include "tag.h"
  #include "run-command.h"
 -#include "exec_cmd.h"
 +#include "exec-cmd.h"
  #include "utf8.h"
  #include "cache-tree.h"
  #include "diff.h"
@@@ -127,7 -127,6 +127,7 @@@ static GIT_PATH_FUNC(rebase_path_rewrit
  static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
  static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
  static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
 +static GIT_PATH_FUNC(rebase_path_signoff, "rebase-merge/signoff")
  static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
  static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
  static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
@@@ -500,8 -499,8 +500,8 @@@ static int do_recursive_merge(struct co
        o.show_rename_progress = 1;
  
        head_tree = parse_tree_indirect(head);
 -      next_tree = next ? next->tree : empty_tree();
 -      base_tree = base ? base->tree : empty_tree();
 +      next_tree = next ? get_commit_tree(next) : empty_tree();
 +      base_tree = base ? get_commit_tree(base) : empty_tree();
  
        for (xopt = opts->xopts; xopt != opts->xopts + opts->xopts_nr; xopt++)
                parse_merge_opt(&o, *xopt);
@@@ -562,7 -561,7 +562,7 @@@ static int is_index_unchanged(void
                        return error(_("unable to update cache tree"));
  
        return !oidcmp(&active_cache_tree->oid,
 -                     &head_commit->tree->object.oid);
 +                     get_commit_tree_oid(head_commit));
  }
  
  static int write_author_script(const char *message)
@@@ -1119,7 -1118,7 +1119,7 @@@ static int try_to_commit(struct strbuf 
        }
  
        if (!(flags & ALLOW_EMPTY) && !oidcmp(current_head ?
 -                                            &current_head->tree->object.oid :
 +                                            get_commit_tree_oid(current_head) :
                                              &empty_tree_oid, &tree)) {
                res = 1; /* run 'git commit' to display error message */
                goto out;
                goto out;
        }
  
 +      reset_ident_date();
 +
        if (commit_tree_extended(msg->buf, msg->len, &tree, parents,
                                 oid, author, opts->gpg_sign, extra)) {
                res = error(_("failed to write commit object"));
@@@ -1219,12 -1216,12 +1219,12 @@@ static int is_original_commit_empty(str
                if (parse_commit(parent))
                        return error(_("could not parse parent commit %s"),
                                oid_to_hex(&parent->object.oid));
 -              ptree_oid = &parent->tree->object.oid;
 +              ptree_oid = get_commit_tree_oid(parent);
        } else {
                ptree_oid = the_hash_algo->empty_tree; /* commit is root */
        }
  
 -      return !oidcmp(ptree_oid, &commit->tree->object.oid);
 +      return !oidcmp(ptree_oid, get_commit_tree_oid(commit));
  }
  
  /*
@@@ -1607,7 -1604,7 +1607,7 @@@ static int do_pick_commit(enum todo_com
                }
        }
  
 -      if (opts->signoff)
 +      if (opts->signoff && !is_fixup(command))
                append_signoff(&msgbuf, 0, 0);
  
        if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
@@@ -2046,11 -2043,6 +2046,11 @@@ static int read_populate_opts(struct re
                if (file_exists(rebase_path_verbose()))
                        opts->verbose = 1;
  
 +              if (file_exists(rebase_path_signoff())) {
 +                      opts->allow_ff = 0;
 +                      opts->signoff = 1;
 +              }
 +
                read_strategy_opts(opts, &buf);
                strbuf_release(&buf);
  
@@@ -2884,7 -2876,8 +2884,8 @@@ int sequencer_pick_revisions(struct rep
  
                if (!get_oid(name, &oid)) {
                        if (!lookup_commit_reference_gently(&oid, 1)) {
-                               enum object_type type = oid_object_info(&oid,
+                               enum object_type type = oid_object_info(the_repository,
+                                                                       &oid,
                                                                        NULL);
                                return error(_("%s: can't cherry-pick a %s"),
                                        name, type_name(type));
@@@ -3009,7 -3002,7 +3010,7 @@@ int sequencer_make_script(FILE *out, in
        init_revisions(&revs, NULL);
        revs.verbose_header = 1;
        revs.max_parents = 1;
 -      revs.cherry_pick = 1;
 +      revs.cherry_mark = 1;
        revs.limited = 1;
        revs.reverse = 1;
        revs.right_only = 1;
                return error(_("make_script: error preparing revisions"));
  
        while ((commit = get_revision(&revs))) {
 +              int is_empty  = is_original_commit_empty(commit);
 +
 +              if (!is_empty && (commit->object.flags & PATCHSAME))
 +                      continue;
                strbuf_reset(&buf);
 -              if (!keep_empty && is_original_commit_empty(commit))
 +              if (!keep_empty && is_empty)
                        strbuf_addf(&buf, "%c ", comment_line_char);
                strbuf_addf(&buf, "%s %s ", insn,
                            oid_to_hex(&commit->object.oid));
diff --combined sha1-file.c
index 46072602fff00bc08960f08568e8bdb84255c60e,0000000000000000000000000000000000000000..f66059ed7dd9aa8040568094a7ad6fa316d18e55
mode 100644,000000..100644
--- /dev/null
@@@ -1,2255 -1,0 +1,2260 @@@
- int oid_object_info_extended(const struct object_id *oid, struct object_info *oi, unsigned flags)
 +/*
 + * GIT - The information manager from hell
 + *
 + * Copyright (C) Linus Torvalds, 2005
 + *
 + * This handles basic git sha1 object files - packing, unpacking,
 + * creation etc.
 + */
 +#include "cache.h"
 +#include "config.h"
 +#include "string-list.h"
 +#include "lockfile.h"
 +#include "delta.h"
 +#include "pack.h"
 +#include "blob.h"
 +#include "commit.h"
 +#include "run-command.h"
 +#include "tag.h"
 +#include "tree.h"
 +#include "tree-walk.h"
 +#include "refs.h"
 +#include "pack-revindex.h"
 +#include "sha1-lookup.h"
 +#include "bulk-checkin.h"
 +#include "repository.h"
 +#include "replace-object.h"
 +#include "streaming.h"
 +#include "dir.h"
 +#include "list.h"
 +#include "mergesort.h"
 +#include "quote.h"
 +#include "packfile.h"
 +#include "fetch-object.h"
 +#include "object-store.h"
 +
 +/* The maximum size for an object header. */
 +#define MAX_HEADER_LEN 32
 +
 +const unsigned char null_sha1[GIT_MAX_RAWSZ];
 +const struct object_id null_oid;
 +const struct object_id empty_tree_oid = {
 +      EMPTY_TREE_SHA1_BIN_LITERAL
 +};
 +const struct object_id empty_blob_oid = {
 +      EMPTY_BLOB_SHA1_BIN_LITERAL
 +};
 +
 +static void git_hash_sha1_init(git_hash_ctx *ctx)
 +{
 +      git_SHA1_Init(&ctx->sha1);
 +}
 +
 +static void git_hash_sha1_update(git_hash_ctx *ctx, const void *data, size_t len)
 +{
 +      git_SHA1_Update(&ctx->sha1, data, len);
 +}
 +
 +static void git_hash_sha1_final(unsigned char *hash, git_hash_ctx *ctx)
 +{
 +      git_SHA1_Final(hash, &ctx->sha1);
 +}
 +
 +static void git_hash_unknown_init(git_hash_ctx *ctx)
 +{
 +      die("trying to init unknown hash");
 +}
 +
 +static void git_hash_unknown_update(git_hash_ctx *ctx, const void *data, size_t len)
 +{
 +      die("trying to update unknown hash");
 +}
 +
 +static void git_hash_unknown_final(unsigned char *hash, git_hash_ctx *ctx)
 +{
 +      die("trying to finalize unknown hash");
 +}
 +
 +const struct git_hash_algo hash_algos[GIT_HASH_NALGOS] = {
 +      {
 +              NULL,
 +              0x00000000,
 +              0,
 +              0,
 +              git_hash_unknown_init,
 +              git_hash_unknown_update,
 +              git_hash_unknown_final,
 +              NULL,
 +              NULL,
 +      },
 +      {
 +              "sha-1",
 +              /* "sha1", big-endian */
 +              0x73686131,
 +              GIT_SHA1_RAWSZ,
 +              GIT_SHA1_HEXSZ,
 +              git_hash_sha1_init,
 +              git_hash_sha1_update,
 +              git_hash_sha1_final,
 +              &empty_tree_oid,
 +              &empty_blob_oid,
 +      },
 +};
 +
 +/*
 + * This is meant to hold a *small* number of objects that you would
 + * want read_sha1_file() to be able to return, but yet you do not want
 + * to write them into the object store (e.g. a browse-only
 + * application).
 + */
 +static struct cached_object {
 +      unsigned char sha1[20];
 +      enum object_type type;
 +      void *buf;
 +      unsigned long size;
 +} *cached_objects;
 +static int cached_object_nr, cached_object_alloc;
 +
 +static struct cached_object empty_tree = {
 +      EMPTY_TREE_SHA1_BIN_LITERAL,
 +      OBJ_TREE,
 +      "",
 +      0
 +};
 +
 +static struct cached_object *find_cached_object(const unsigned char *sha1)
 +{
 +      int i;
 +      struct cached_object *co = cached_objects;
 +
 +      for (i = 0; i < cached_object_nr; i++, co++) {
 +              if (!hashcmp(co->sha1, sha1))
 +                      return co;
 +      }
 +      if (!hashcmp(sha1, empty_tree.sha1))
 +              return &empty_tree;
 +      return NULL;
 +}
 +
 +
 +static int get_conv_flags(unsigned flags)
 +{
 +      if (flags & HASH_RENORMALIZE)
 +              return CONV_EOL_RENORMALIZE;
 +      else if (flags & HASH_WRITE_OBJECT)
 +              return global_conv_flags_eol | CONV_WRITE_OBJECT;
 +      else
 +              return 0;
 +}
 +
 +
 +int mkdir_in_gitdir(const char *path)
 +{
 +      if (mkdir(path, 0777)) {
 +              int saved_errno = errno;
 +              struct stat st;
 +              struct strbuf sb = STRBUF_INIT;
 +
 +              if (errno != EEXIST)
 +                      return -1;
 +              /*
 +               * Are we looking at a path in a symlinked worktree
 +               * whose original repository does not yet have it?
 +               * e.g. .git/rr-cache pointing at its original
 +               * repository in which the user hasn't performed any
 +               * conflict resolution yet?
 +               */
 +              if (lstat(path, &st) || !S_ISLNK(st.st_mode) ||
 +                  strbuf_readlink(&sb, path, st.st_size) ||
 +                  !is_absolute_path(sb.buf) ||
 +                  mkdir(sb.buf, 0777)) {
 +                      strbuf_release(&sb);
 +                      errno = saved_errno;
 +                      return -1;
 +              }
 +              strbuf_release(&sb);
 +      }
 +      return adjust_shared_perm(path);
 +}
 +
 +enum scld_error safe_create_leading_directories(char *path)
 +{
 +      char *next_component = path + offset_1st_component(path);
 +      enum scld_error ret = SCLD_OK;
 +
 +      while (ret == SCLD_OK && next_component) {
 +              struct stat st;
 +              char *slash = next_component, slash_character;
 +
 +              while (*slash && !is_dir_sep(*slash))
 +                      slash++;
 +
 +              if (!*slash)
 +                      break;
 +
 +              next_component = slash + 1;
 +              while (is_dir_sep(*next_component))
 +                      next_component++;
 +              if (!*next_component)
 +                      break;
 +
 +              slash_character = *slash;
 +              *slash = '\0';
 +              if (!stat(path, &st)) {
 +                      /* path exists */
 +                      if (!S_ISDIR(st.st_mode)) {
 +                              errno = ENOTDIR;
 +                              ret = SCLD_EXISTS;
 +                      }
 +              } else if (mkdir(path, 0777)) {
 +                      if (errno == EEXIST &&
 +                          !stat(path, &st) && S_ISDIR(st.st_mode))
 +                              ; /* somebody created it since we checked */
 +                      else if (errno == ENOENT)
 +                              /*
 +                               * Either mkdir() failed because
 +                               * somebody just pruned the containing
 +                               * directory, or stat() failed because
 +                               * the file that was in our way was
 +                               * just removed.  Either way, inform
 +                               * the caller that it might be worth
 +                               * trying again:
 +                               */
 +                              ret = SCLD_VANISHED;
 +                      else
 +                              ret = SCLD_FAILED;
 +              } else if (adjust_shared_perm(path)) {
 +                      ret = SCLD_PERMS;
 +              }
 +              *slash = slash_character;
 +      }
 +      return ret;
 +}
 +
 +enum scld_error safe_create_leading_directories_const(const char *path)
 +{
 +      int save_errno;
 +      /* path points to cache entries, so xstrdup before messing with it */
 +      char *buf = xstrdup(path);
 +      enum scld_error result = safe_create_leading_directories(buf);
 +
 +      save_errno = errno;
 +      free(buf);
 +      errno = save_errno;
 +      return result;
 +}
 +
 +int raceproof_create_file(const char *path, create_file_fn fn, void *cb)
 +{
 +      /*
 +       * The number of times we will try to remove empty directories
 +       * in the way of path. This is only 1 because if another
 +       * process is racily creating directories that conflict with
 +       * us, we don't want to fight against them.
 +       */
 +      int remove_directories_remaining = 1;
 +
 +      /*
 +       * The number of times that we will try to create the
 +       * directories containing path. We are willing to attempt this
 +       * more than once, because another process could be trying to
 +       * clean up empty directories at the same time as we are
 +       * trying to create them.
 +       */
 +      int create_directories_remaining = 3;
 +
 +      /* A scratch copy of path, filled lazily if we need it: */
 +      struct strbuf path_copy = STRBUF_INIT;
 +
 +      int ret, save_errno;
 +
 +      /* Sanity check: */
 +      assert(*path);
 +
 +retry_fn:
 +      ret = fn(path, cb);
 +      save_errno = errno;
 +      if (!ret)
 +              goto out;
 +
 +      if (errno == EISDIR && remove_directories_remaining-- > 0) {
 +              /*
 +               * A directory is in the way. Maybe it is empty; try
 +               * to remove it:
 +               */
 +              if (!path_copy.len)
 +                      strbuf_addstr(&path_copy, path);
 +
 +              if (!remove_dir_recursively(&path_copy, REMOVE_DIR_EMPTY_ONLY))
 +                      goto retry_fn;
 +      } else if (errno == ENOENT && create_directories_remaining-- > 0) {
 +              /*
 +               * Maybe the containing directory didn't exist, or
 +               * maybe it was just deleted by a process that is
 +               * racing with us to clean up empty directories. Try
 +               * to create it:
 +               */
 +              enum scld_error scld_result;
 +
 +              if (!path_copy.len)
 +                      strbuf_addstr(&path_copy, path);
 +
 +              do {
 +                      scld_result = safe_create_leading_directories(path_copy.buf);
 +                      if (scld_result == SCLD_OK)
 +                              goto retry_fn;
 +              } while (scld_result == SCLD_VANISHED && create_directories_remaining-- > 0);
 +      }
 +
 +out:
 +      strbuf_release(&path_copy);
 +      errno = save_errno;
 +      return ret;
 +}
 +
 +static void fill_sha1_path(struct strbuf *buf, const unsigned char *sha1)
 +{
 +      int i;
 +      for (i = 0; i < 20; i++) {
 +              static char hex[] = "0123456789abcdef";
 +              unsigned int val = sha1[i];
 +              strbuf_addch(buf, hex[val >> 4]);
 +              strbuf_addch(buf, hex[val & 0xf]);
 +              if (!i)
 +                      strbuf_addch(buf, '/');
 +      }
 +}
 +
 +void sha1_file_name(struct repository *r, struct strbuf *buf, const unsigned char *sha1)
 +{
 +      strbuf_addstr(buf, r->objects->objectdir);
 +      strbuf_addch(buf, '/');
 +      fill_sha1_path(buf, sha1);
 +}
 +
 +struct strbuf *alt_scratch_buf(struct alternate_object_database *alt)
 +{
 +      strbuf_setlen(&alt->scratch, alt->base_len);
 +      return &alt->scratch;
 +}
 +
 +static const char *alt_sha1_path(struct alternate_object_database *alt,
 +                               const unsigned char *sha1)
 +{
 +      struct strbuf *buf = alt_scratch_buf(alt);
 +      fill_sha1_path(buf, sha1);
 +      return buf->buf;
 +}
 +
 +/*
 + * Return non-zero iff the path is usable as an alternate object database.
 + */
 +static int alt_odb_usable(struct raw_object_store *o,
 +                        struct strbuf *path,
 +                        const char *normalized_objdir)
 +{
 +      struct alternate_object_database *alt;
 +
 +      /* Detect cases where alternate disappeared */
 +      if (!is_directory(path->buf)) {
 +              error("object directory %s does not exist; "
 +                    "check .git/objects/info/alternates.",
 +                    path->buf);
 +              return 0;
 +      }
 +
 +      /*
 +       * Prevent the common mistake of listing the same
 +       * thing twice, or object directory itself.
 +       */
 +      for (alt = o->alt_odb_list; alt; alt = alt->next) {
 +              if (!fspathcmp(path->buf, alt->path))
 +                      return 0;
 +      }
 +      if (!fspathcmp(path->buf, normalized_objdir))
 +              return 0;
 +
 +      return 1;
 +}
 +
 +/*
 + * Prepare alternate object database registry.
 + *
 + * The variable alt_odb_list points at the list of struct
 + * alternate_object_database.  The elements on this list come from
 + * non-empty elements from colon separated ALTERNATE_DB_ENVIRONMENT
 + * environment variable, and $GIT_OBJECT_DIRECTORY/info/alternates,
 + * whose contents is similar to that environment variable but can be
 + * LF separated.  Its base points at a statically allocated buffer that
 + * contains "/the/directory/corresponding/to/.git/objects/...", while
 + * its name points just after the slash at the end of ".git/objects/"
 + * in the example above, and has enough space to hold 40-byte hex
 + * SHA1, an extra slash for the first level indirection, and the
 + * terminating NUL.
 + */
 +static void read_info_alternates(struct repository *r,
 +                               const char *relative_base,
 +                               int depth);
 +static int link_alt_odb_entry(struct repository *r, const char *entry,
 +      const char *relative_base, int depth, const char *normalized_objdir)
 +{
 +      struct alternate_object_database *ent;
 +      struct strbuf pathbuf = STRBUF_INIT;
 +
 +      if (!is_absolute_path(entry) && relative_base) {
 +              strbuf_realpath(&pathbuf, relative_base, 1);
 +              strbuf_addch(&pathbuf, '/');
 +      }
 +      strbuf_addstr(&pathbuf, entry);
 +
 +      if (strbuf_normalize_path(&pathbuf) < 0 && relative_base) {
 +              error("unable to normalize alternate object path: %s",
 +                    pathbuf.buf);
 +              strbuf_release(&pathbuf);
 +              return -1;
 +      }
 +
 +      /*
 +       * The trailing slash after the directory name is given by
 +       * this function at the end. Remove duplicates.
 +       */
 +      while (pathbuf.len && pathbuf.buf[pathbuf.len - 1] == '/')
 +              strbuf_setlen(&pathbuf, pathbuf.len - 1);
 +
 +      if (!alt_odb_usable(r->objects, &pathbuf, normalized_objdir)) {
 +              strbuf_release(&pathbuf);
 +              return -1;
 +      }
 +
 +      ent = alloc_alt_odb(pathbuf.buf);
 +
 +      /* add the alternate entry */
 +      *r->objects->alt_odb_tail = ent;
 +      r->objects->alt_odb_tail = &(ent->next);
 +      ent->next = NULL;
 +
 +      /* recursively add alternates */
 +      read_info_alternates(r, pathbuf.buf, depth + 1);
 +
 +      strbuf_release(&pathbuf);
 +      return 0;
 +}
 +
 +static const char *parse_alt_odb_entry(const char *string,
 +                                     int sep,
 +                                     struct strbuf *out)
 +{
 +      const char *end;
 +
 +      strbuf_reset(out);
 +
 +      if (*string == '#') {
 +              /* comment; consume up to next separator */
 +              end = strchrnul(string, sep);
 +      } else if (*string == '"' && !unquote_c_style(out, string, &end)) {
 +              /*
 +               * quoted path; unquote_c_style has copied the
 +               * data for us and set "end". Broken quoting (e.g.,
 +               * an entry that doesn't end with a quote) falls
 +               * back to the unquoted case below.
 +               */
 +      } else {
 +              /* normal, unquoted path */
 +              end = strchrnul(string, sep);
 +              strbuf_add(out, string, end - string);
 +      }
 +
 +      if (*end)
 +              end++;
 +      return end;
 +}
 +
 +static void link_alt_odb_entries(struct repository *r, const char *alt,
 +                               int sep, const char *relative_base, int depth)
 +{
 +      struct strbuf objdirbuf = STRBUF_INIT;
 +      struct strbuf entry = STRBUF_INIT;
 +
 +      if (!alt || !*alt)
 +              return;
 +
 +      if (depth > 5) {
 +              error("%s: ignoring alternate object stores, nesting too deep.",
 +                              relative_base);
 +              return;
 +      }
 +
 +      strbuf_add_absolute_path(&objdirbuf, r->objects->objectdir);
 +      if (strbuf_normalize_path(&objdirbuf) < 0)
 +              die("unable to normalize object directory: %s",
 +                  objdirbuf.buf);
 +
 +      while (*alt) {
 +              alt = parse_alt_odb_entry(alt, sep, &entry);
 +              if (!entry.len)
 +                      continue;
 +              link_alt_odb_entry(r, entry.buf,
 +                                 relative_base, depth, objdirbuf.buf);
 +      }
 +      strbuf_release(&entry);
 +      strbuf_release(&objdirbuf);
 +}
 +
 +static void read_info_alternates(struct repository *r,
 +                               const char *relative_base,
 +                               int depth)
 +{
 +      char *path;
 +      struct strbuf buf = STRBUF_INIT;
 +
 +      path = xstrfmt("%s/info/alternates", relative_base);
 +      if (strbuf_read_file(&buf, path, 1024) < 0) {
 +              warn_on_fopen_errors(path);
 +              free(path);
 +              return;
 +      }
 +
 +      link_alt_odb_entries(r, buf.buf, '\n', relative_base, depth);
 +      strbuf_release(&buf);
 +      free(path);
 +}
 +
 +struct alternate_object_database *alloc_alt_odb(const char *dir)
 +{
 +      struct alternate_object_database *ent;
 +
 +      FLEX_ALLOC_STR(ent, path, dir);
 +      strbuf_init(&ent->scratch, 0);
 +      strbuf_addf(&ent->scratch, "%s/", dir);
 +      ent->base_len = ent->scratch.len;
 +
 +      return ent;
 +}
 +
 +void add_to_alternates_file(const char *reference)
 +{
 +      struct lock_file lock = LOCK_INIT;
 +      char *alts = git_pathdup("objects/info/alternates");
 +      FILE *in, *out;
 +      int found = 0;
 +
 +      hold_lock_file_for_update(&lock, alts, LOCK_DIE_ON_ERROR);
 +      out = fdopen_lock_file(&lock, "w");
 +      if (!out)
 +              die_errno("unable to fdopen alternates lockfile");
 +
 +      in = fopen(alts, "r");
 +      if (in) {
 +              struct strbuf line = STRBUF_INIT;
 +
 +              while (strbuf_getline(&line, in) != EOF) {
 +                      if (!strcmp(reference, line.buf)) {
 +                              found = 1;
 +                              break;
 +                      }
 +                      fprintf_or_die(out, "%s\n", line.buf);
 +              }
 +
 +              strbuf_release(&line);
 +              fclose(in);
 +      }
 +      else if (errno != ENOENT)
 +              die_errno("unable to read alternates file");
 +
 +      if (found) {
 +              rollback_lock_file(&lock);
 +      } else {
 +              fprintf_or_die(out, "%s\n", reference);
 +              if (commit_lock_file(&lock))
 +                      die_errno("unable to move new alternates file into place");
 +              if (the_repository->objects->alt_odb_tail)
 +                      link_alt_odb_entries(the_repository, reference,
 +                                           '\n', NULL, 0);
 +      }
 +      free(alts);
 +}
 +
 +void add_to_alternates_memory(const char *reference)
 +{
 +      /*
 +       * Make sure alternates are initialized, or else our entry may be
 +       * overwritten when they are.
 +       */
 +      prepare_alt_odb(the_repository);
 +
 +      link_alt_odb_entries(the_repository, reference,
 +                           '\n', NULL, 0);
 +}
 +
 +/*
 + * Compute the exact path an alternate is at and returns it. In case of
 + * error NULL is returned and the human readable error is added to `err`
 + * `path` may be relative and should point to $GITDIR.
 + * `err` must not be null.
 + */
 +char *compute_alternate_path(const char *path, struct strbuf *err)
 +{
 +      char *ref_git = NULL;
 +      const char *repo, *ref_git_s;
 +      int seen_error = 0;
 +
 +      ref_git_s = real_path_if_valid(path);
 +      if (!ref_git_s) {
 +              seen_error = 1;
 +              strbuf_addf(err, _("path '%s' does not exist"), path);
 +              goto out;
 +      } else
 +              /*
 +               * Beware: read_gitfile(), real_path() and mkpath()
 +               * return static buffer
 +               */
 +              ref_git = xstrdup(ref_git_s);
 +
 +      repo = read_gitfile(ref_git);
 +      if (!repo)
 +              repo = read_gitfile(mkpath("%s/.git", ref_git));
 +      if (repo) {
 +              free(ref_git);
 +              ref_git = xstrdup(repo);
 +      }
 +
 +      if (!repo && is_directory(mkpath("%s/.git/objects", ref_git))) {
 +              char *ref_git_git = mkpathdup("%s/.git", ref_git);
 +              free(ref_git);
 +              ref_git = ref_git_git;
 +      } else if (!is_directory(mkpath("%s/objects", ref_git))) {
 +              struct strbuf sb = STRBUF_INIT;
 +              seen_error = 1;
 +              if (get_common_dir(&sb, ref_git)) {
 +                      strbuf_addf(err,
 +                                  _("reference repository '%s' as a linked "
 +                                    "checkout is not supported yet."),
 +                                  path);
 +                      goto out;
 +              }
 +
 +              strbuf_addf(err, _("reference repository '%s' is not a "
 +                                      "local repository."), path);
 +              goto out;
 +      }
 +
 +      if (!access(mkpath("%s/shallow", ref_git), F_OK)) {
 +              strbuf_addf(err, _("reference repository '%s' is shallow"),
 +                          path);
 +              seen_error = 1;
 +              goto out;
 +      }
 +
 +      if (!access(mkpath("%s/info/grafts", ref_git), F_OK)) {
 +              strbuf_addf(err,
 +                          _("reference repository '%s' is grafted"),
 +                          path);
 +              seen_error = 1;
 +              goto out;
 +      }
 +
 +out:
 +      if (seen_error) {
 +              FREE_AND_NULL(ref_git);
 +      }
 +
 +      return ref_git;
 +}
 +
 +int foreach_alt_odb(alt_odb_fn fn, void *cb)
 +{
 +      struct alternate_object_database *ent;
 +      int r = 0;
 +
 +      prepare_alt_odb(the_repository);
 +      for (ent = the_repository->objects->alt_odb_list; ent; ent = ent->next) {
 +              r = fn(ent, cb);
 +              if (r)
 +                      break;
 +      }
 +      return r;
 +}
 +
 +void prepare_alt_odb(struct repository *r)
 +{
 +      if (r->objects->alt_odb_tail)
 +              return;
 +
 +      r->objects->alt_odb_tail = &r->objects->alt_odb_list;
 +      link_alt_odb_entries(r, r->objects->alternate_db, PATH_SEP, NULL, 0);
 +
 +      read_info_alternates(r, r->objects->objectdir, 0);
 +}
 +
 +/* Returns 1 if we have successfully freshened the file, 0 otherwise. */
 +static int freshen_file(const char *fn)
 +{
 +      struct utimbuf t;
 +      t.actime = t.modtime = time(NULL);
 +      return !utime(fn, &t);
 +}
 +
 +/*
 + * All of the check_and_freshen functions return 1 if the file exists and was
 + * freshened (if freshening was requested), 0 otherwise. If they return
 + * 0, you should not assume that it is safe to skip a write of the object (it
 + * either does not exist on disk, or has a stale mtime and may be subject to
 + * pruning).
 + */
 +int check_and_freshen_file(const char *fn, int freshen)
 +{
 +      if (access(fn, F_OK))
 +              return 0;
 +      if (freshen && !freshen_file(fn))
 +              return 0;
 +      return 1;
 +}
 +
 +static int check_and_freshen_local(const unsigned char *sha1, int freshen)
 +{
 +      static struct strbuf buf = STRBUF_INIT;
 +
 +      strbuf_reset(&buf);
 +      sha1_file_name(the_repository, &buf, sha1);
 +
 +      return check_and_freshen_file(buf.buf, freshen);
 +}
 +
 +static int check_and_freshen_nonlocal(const unsigned char *sha1, int freshen)
 +{
 +      struct alternate_object_database *alt;
 +      prepare_alt_odb(the_repository);
 +      for (alt = the_repository->objects->alt_odb_list; alt; alt = alt->next) {
 +              const char *path = alt_sha1_path(alt, sha1);
 +              if (check_and_freshen_file(path, freshen))
 +                      return 1;
 +      }
 +      return 0;
 +}
 +
 +static int check_and_freshen(const unsigned char *sha1, int freshen)
 +{
 +      return check_and_freshen_local(sha1, freshen) ||
 +             check_and_freshen_nonlocal(sha1, freshen);
 +}
 +
 +int has_loose_object_nonlocal(const unsigned char *sha1)
 +{
 +      return check_and_freshen_nonlocal(sha1, 0);
 +}
 +
 +static int has_loose_object(const unsigned char *sha1)
 +{
 +      return check_and_freshen(sha1, 0);
 +}
 +
 +static void mmap_limit_check(size_t length)
 +{
 +      static size_t limit = 0;
 +      if (!limit) {
 +              limit = git_env_ulong("GIT_MMAP_LIMIT", 0);
 +              if (!limit)
 +                      limit = SIZE_MAX;
 +      }
 +      if (length > limit)
 +              die("attempting to mmap %"PRIuMAX" over limit %"PRIuMAX,
 +                  (uintmax_t)length, (uintmax_t)limit);
 +}
 +
 +void *xmmap_gently(void *start, size_t length,
 +                int prot, int flags, int fd, off_t offset)
 +{
 +      void *ret;
 +
 +      mmap_limit_check(length);
 +      ret = mmap(start, length, prot, flags, fd, offset);
 +      if (ret == MAP_FAILED) {
 +              if (!length)
 +                      return NULL;
 +              release_pack_memory(length);
 +              ret = mmap(start, length, prot, flags, fd, offset);
 +      }
 +      return ret;
 +}
 +
 +void *xmmap(void *start, size_t length,
 +      int prot, int flags, int fd, off_t offset)
 +{
 +      void *ret = xmmap_gently(start, length, prot, flags, fd, offset);
 +      if (ret == MAP_FAILED)
 +              die_errno("mmap failed");
 +      return ret;
 +}
 +
 +/*
 + * With an in-core object data in "map", rehash it to make sure the
 + * object name actually matches "sha1" to detect object corruption.
 + * With "map" == NULL, try reading the object named with "sha1" using
 + * the streaming interface and rehash it to do the same.
 + */
 +int check_object_signature(const struct object_id *oid, void *map,
 +                         unsigned long size, const char *type)
 +{
 +      struct object_id real_oid;
 +      enum object_type obj_type;
 +      struct git_istream *st;
 +      git_hash_ctx c;
 +      char hdr[MAX_HEADER_LEN];
 +      int hdrlen;
 +
 +      if (map) {
 +              hash_object_file(map, size, type, &real_oid);
 +              return oidcmp(oid, &real_oid) ? -1 : 0;
 +      }
 +
 +      st = open_istream(oid, &obj_type, &size, NULL);
 +      if (!st)
 +              return -1;
 +
 +      /* Generate the header */
 +      hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %lu", type_name(obj_type), size) + 1;
 +
 +      /* Sha1.. */
 +      the_hash_algo->init_fn(&c);
 +      the_hash_algo->update_fn(&c, hdr, hdrlen);
 +      for (;;) {
 +              char buf[1024 * 16];
 +              ssize_t readlen = read_istream(st, buf, sizeof(buf));
 +
 +              if (readlen < 0) {
 +                      close_istream(st);
 +                      return -1;
 +              }
 +              if (!readlen)
 +                      break;
 +              the_hash_algo->update_fn(&c, buf, readlen);
 +      }
 +      the_hash_algo->final_fn(real_oid.hash, &c);
 +      close_istream(st);
 +      return oidcmp(oid, &real_oid) ? -1 : 0;
 +}
 +
 +int git_open_cloexec(const char *name, int flags)
 +{
 +      int fd;
 +      static int o_cloexec = O_CLOEXEC;
 +
 +      fd = open(name, flags | o_cloexec);
 +      if ((o_cloexec & O_CLOEXEC) && fd < 0 && errno == EINVAL) {
 +              /* Try again w/o O_CLOEXEC: the kernel might not support it */
 +              o_cloexec &= ~O_CLOEXEC;
 +              fd = open(name, flags | o_cloexec);
 +      }
 +
 +#if defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
 +      {
 +              static int fd_cloexec = FD_CLOEXEC;
 +
 +              if (!o_cloexec && 0 <= fd && fd_cloexec) {
 +                      /* Opened w/o O_CLOEXEC?  try with fcntl(2) to add it */
 +                      int flags = fcntl(fd, F_GETFD);
 +                      if (fcntl(fd, F_SETFD, flags | fd_cloexec))
 +                              fd_cloexec = 0;
 +              }
 +      }
 +#endif
 +      return fd;
 +}
 +
 +/*
 + * Find "sha1" as a loose object in the local repository or in an alternate.
 + * Returns 0 on success, negative on failure.
 + *
 + * The "path" out-parameter will give the path of the object we found (if any).
 + * Note that it may point to static storage and is only valid until another
 + * call to sha1_file_name(), etc.
 + */
 +static int stat_sha1_file(struct repository *r, const unsigned char *sha1,
 +                        struct stat *st, const char **path)
 +{
 +      struct alternate_object_database *alt;
 +      static struct strbuf buf = STRBUF_INIT;
 +
 +      strbuf_reset(&buf);
 +      sha1_file_name(r, &buf, sha1);
 +      *path = buf.buf;
 +
 +      if (!lstat(*path, st))
 +              return 0;
 +
 +      prepare_alt_odb(r);
 +      errno = ENOENT;
 +      for (alt = r->objects->alt_odb_list; alt; alt = alt->next) {
 +              *path = alt_sha1_path(alt, sha1);
 +              if (!lstat(*path, st))
 +                      return 0;
 +      }
 +
 +      return -1;
 +}
 +
 +/*
 + * Like stat_sha1_file(), but actually open the object and return the
 + * descriptor. See the caveats on the "path" parameter above.
 + */
 +static int open_sha1_file(struct repository *r,
 +                        const unsigned char *sha1, const char **path)
 +{
 +      int fd;
 +      struct alternate_object_database *alt;
 +      int most_interesting_errno;
 +      static struct strbuf buf = STRBUF_INIT;
 +
 +      strbuf_reset(&buf);
 +      sha1_file_name(r, &buf, sha1);
 +      *path = buf.buf;
 +
 +      fd = git_open(*path);
 +      if (fd >= 0)
 +              return fd;
 +      most_interesting_errno = errno;
 +
 +      prepare_alt_odb(r);
 +      for (alt = r->objects->alt_odb_list; alt; alt = alt->next) {
 +              *path = alt_sha1_path(alt, sha1);
 +              fd = git_open(*path);
 +              if (fd >= 0)
 +                      return fd;
 +              if (most_interesting_errno == ENOENT)
 +                      most_interesting_errno = errno;
 +      }
 +      errno = most_interesting_errno;
 +      return -1;
 +}
 +
 +/*
 + * Map the loose object at "path" if it is not NULL, or the path found by
 + * searching for a loose object named "sha1".
 + */
 +static void *map_sha1_file_1(struct repository *r, const char *path,
 +                           const unsigned char *sha1, unsigned long *size)
 +{
 +      void *map;
 +      int fd;
 +
 +      if (path)
 +              fd = git_open(path);
 +      else
 +              fd = open_sha1_file(r, sha1, &path);
 +      map = NULL;
 +      if (fd >= 0) {
 +              struct stat st;
 +
 +              if (!fstat(fd, &st)) {
 +                      *size = xsize_t(st.st_size);
 +                      if (!*size) {
 +                              /* mmap() is forbidden on empty files */
 +                              error("object file %s is empty", path);
 +                              return NULL;
 +                      }
 +                      map = xmmap(NULL, *size, PROT_READ, MAP_PRIVATE, fd, 0);
 +              }
 +              close(fd);
 +      }
 +      return map;
 +}
 +
 +void *map_sha1_file(struct repository *r,
 +                  const unsigned char *sha1, unsigned long *size)
 +{
 +      return map_sha1_file_1(r, NULL, sha1, size);
 +}
 +
 +static int unpack_sha1_short_header(git_zstream *stream,
 +                                  unsigned char *map, unsigned long mapsize,
 +                                  void *buffer, unsigned long bufsiz)
 +{
 +      /* Get the data stream */
 +      memset(stream, 0, sizeof(*stream));
 +      stream->next_in = map;
 +      stream->avail_in = mapsize;
 +      stream->next_out = buffer;
 +      stream->avail_out = bufsiz;
 +
 +      git_inflate_init(stream);
 +      return git_inflate(stream, 0);
 +}
 +
 +int unpack_sha1_header(git_zstream *stream,
 +                     unsigned char *map, unsigned long mapsize,
 +                     void *buffer, unsigned long bufsiz)
 +{
 +      int status = unpack_sha1_short_header(stream, map, mapsize,
 +                                            buffer, bufsiz);
 +
 +      if (status < Z_OK)
 +              return status;
 +
 +      /* Make sure we have the terminating NUL */
 +      if (!memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer))
 +              return -1;
 +      return 0;
 +}
 +
 +static int unpack_sha1_header_to_strbuf(git_zstream *stream, unsigned char *map,
 +                                      unsigned long mapsize, void *buffer,
 +                                      unsigned long bufsiz, struct strbuf *header)
 +{
 +      int status;
 +
 +      status = unpack_sha1_short_header(stream, map, mapsize, buffer, bufsiz);
 +      if (status < Z_OK)
 +              return -1;
 +
 +      /*
 +       * Check if entire header is unpacked in the first iteration.
 +       */
 +      if (memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer))
 +              return 0;
 +
 +      /*
 +       * buffer[0..bufsiz] was not large enough.  Copy the partial
 +       * result out to header, and then append the result of further
 +       * reading the stream.
 +       */
 +      strbuf_add(header, buffer, stream->next_out - (unsigned char *)buffer);
 +      stream->next_out = buffer;
 +      stream->avail_out = bufsiz;
 +
 +      do {
 +              status = git_inflate(stream, 0);
 +              strbuf_add(header, buffer, stream->next_out - (unsigned char *)buffer);
 +              if (memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer))
 +                      return 0;
 +              stream->next_out = buffer;
 +              stream->avail_out = bufsiz;
 +      } while (status != Z_STREAM_END);
 +      return -1;
 +}
 +
 +static void *unpack_sha1_rest(git_zstream *stream, void *buffer, unsigned long size, const unsigned char *sha1)
 +{
 +      int bytes = strlen(buffer) + 1;
 +      unsigned char *buf = xmallocz(size);
 +      unsigned long n;
 +      int status = Z_OK;
 +
 +      n = stream->total_out - bytes;
 +      if (n > size)
 +              n = size;
 +      memcpy(buf, (char *) buffer + bytes, n);
 +      bytes = n;
 +      if (bytes <= size) {
 +              /*
 +               * The above condition must be (bytes <= size), not
 +               * (bytes < size).  In other words, even though we
 +               * expect no more output and set avail_out to zero,
 +               * the input zlib stream may have bytes that express
 +               * "this concludes the stream", and we *do* want to
 +               * eat that input.
 +               *
 +               * Otherwise we would not be able to test that we
 +               * consumed all the input to reach the expected size;
 +               * we also want to check that zlib tells us that all
 +               * went well with status == Z_STREAM_END at the end.
 +               */
 +              stream->next_out = buf + bytes;
 +              stream->avail_out = size - bytes;
 +              while (status == Z_OK)
 +                      status = git_inflate(stream, Z_FINISH);
 +      }
 +      if (status == Z_STREAM_END && !stream->avail_in) {
 +              git_inflate_end(stream);
 +              return buf;
 +      }
 +
 +      if (status < 0)
 +              error("corrupt loose object '%s'", sha1_to_hex(sha1));
 +      else if (stream->avail_in)
 +              error("garbage at end of loose object '%s'",
 +                    sha1_to_hex(sha1));
 +      free(buf);
 +      return NULL;
 +}
 +
 +/*
 + * We used to just use "sscanf()", but that's actually way
 + * too permissive for what we want to check. So do an anal
 + * object header parse by hand.
 + */
 +static int parse_sha1_header_extended(const char *hdr, struct object_info *oi,
 +                             unsigned int flags)
 +{
 +      const char *type_buf = hdr;
 +      unsigned long size;
 +      int type, type_len = 0;
 +
 +      /*
 +       * The type can be of any size but is followed by
 +       * a space.
 +       */
 +      for (;;) {
 +              char c = *hdr++;
 +              if (!c)
 +                      return -1;
 +              if (c == ' ')
 +                      break;
 +              type_len++;
 +      }
 +
 +      type = type_from_string_gently(type_buf, type_len, 1);
 +      if (oi->type_name)
 +              strbuf_add(oi->type_name, type_buf, type_len);
 +      /*
 +       * Set type to 0 if its an unknown object and
 +       * we're obtaining the type using '--allow-unknown-type'
 +       * option.
 +       */
 +      if ((flags & OBJECT_INFO_ALLOW_UNKNOWN_TYPE) && (type < 0))
 +              type = 0;
 +      else if (type < 0)
 +              die("invalid object type");
 +      if (oi->typep)
 +              *oi->typep = type;
 +
 +      /*
 +       * The length must follow immediately, and be in canonical
 +       * decimal format (ie "010" is not valid).
 +       */
 +      size = *hdr++ - '0';
 +      if (size > 9)
 +              return -1;
 +      if (size) {
 +              for (;;) {
 +                      unsigned long c = *hdr - '0';
 +                      if (c > 9)
 +                              break;
 +                      hdr++;
 +                      size = size * 10 + c;
 +              }
 +      }
 +
 +      if (oi->sizep)
 +              *oi->sizep = size;
 +
 +      /*
 +       * The length must be followed by a zero byte
 +       */
 +      return *hdr ? -1 : type;
 +}
 +
 +int parse_sha1_header(const char *hdr, unsigned long *sizep)
 +{
 +      struct object_info oi = OBJECT_INFO_INIT;
 +
 +      oi.sizep = sizep;
 +      return parse_sha1_header_extended(hdr, &oi, 0);
 +}
 +
 +static int sha1_loose_object_info(struct repository *r,
 +                                const unsigned char *sha1,
 +                                struct object_info *oi, int flags)
 +{
 +      int status = 0;
 +      unsigned long mapsize;
 +      void *map;
 +      git_zstream stream;
 +      char hdr[MAX_HEADER_LEN];
 +      struct strbuf hdrbuf = STRBUF_INIT;
 +      unsigned long size_scratch;
 +
 +      if (oi->delta_base_sha1)
 +              hashclr(oi->delta_base_sha1);
 +
 +      /*
 +       * If we don't care about type or size, then we don't
 +       * need to look inside the object at all. Note that we
 +       * do not optimize out the stat call, even if the
 +       * caller doesn't care about the disk-size, since our
 +       * return value implicitly indicates whether the
 +       * object even exists.
 +       */
 +      if (!oi->typep && !oi->type_name && !oi->sizep && !oi->contentp) {
 +              const char *path;
 +              struct stat st;
 +              if (stat_sha1_file(r, sha1, &st, &path) < 0)
 +                      return -1;
 +              if (oi->disk_sizep)
 +                      *oi->disk_sizep = st.st_size;
 +              return 0;
 +      }
 +
 +      map = map_sha1_file(r, sha1, &mapsize);
 +      if (!map)
 +              return -1;
 +
 +      if (!oi->sizep)
 +              oi->sizep = &size_scratch;
 +
 +      if (oi->disk_sizep)
 +              *oi->disk_sizep = mapsize;
 +      if ((flags & OBJECT_INFO_ALLOW_UNKNOWN_TYPE)) {
 +              if (unpack_sha1_header_to_strbuf(&stream, map, mapsize, hdr, sizeof(hdr), &hdrbuf) < 0)
 +                      status = error("unable to unpack %s header with --allow-unknown-type",
 +                                     sha1_to_hex(sha1));
 +      } else if (unpack_sha1_header(&stream, map, mapsize, hdr, sizeof(hdr)) < 0)
 +              status = error("unable to unpack %s header",
 +                             sha1_to_hex(sha1));
 +      if (status < 0)
 +              ; /* Do nothing */
 +      else if (hdrbuf.len) {
 +              if ((status = parse_sha1_header_extended(hdrbuf.buf, oi, flags)) < 0)
 +                      status = error("unable to parse %s header with --allow-unknown-type",
 +                                     sha1_to_hex(sha1));
 +      } else if ((status = parse_sha1_header_extended(hdr, oi, flags)) < 0)
 +              status = error("unable to parse %s header", sha1_to_hex(sha1));
 +
 +      if (status >= 0 && oi->contentp) {
 +              *oi->contentp = unpack_sha1_rest(&stream, hdr,
 +                                               *oi->sizep, sha1);
 +              if (!*oi->contentp) {
 +                      git_inflate_end(&stream);
 +                      status = -1;
 +              }
 +      } else
 +              git_inflate_end(&stream);
 +
 +      munmap(map, mapsize);
 +      if (status && oi->typep)
 +              *oi->typep = status;
 +      if (oi->sizep == &size_scratch)
 +              oi->sizep = NULL;
 +      strbuf_release(&hdrbuf);
 +      oi->whence = OI_LOOSE;
 +      return (status < 0) ? status : 0;
 +}
 +
 +int fetch_if_missing = 1;
 +
-               real = lookup_replace_object(the_repository, oid);
++int oid_object_info_extended(struct repository *r, const struct object_id *oid,
++                           struct object_info *oi, unsigned flags)
 +{
 +      static struct object_info blank_oi = OBJECT_INFO_INIT;
 +      struct pack_entry e;
 +      int rtype;
 +      const struct object_id *real = oid;
 +      int already_retried = 0;
 +
 +      if (flags & OBJECT_INFO_LOOKUP_REPLACE)
-               if (find_pack_entry(the_repository, real->hash, &e))
++              real = lookup_replace_object(r, oid);
 +
 +      if (is_null_oid(real))
 +              return -1;
 +
 +      if (!oi)
 +              oi = &blank_oi;
 +
 +      if (!(flags & OBJECT_INFO_SKIP_CACHED)) {
 +              struct cached_object *co = find_cached_object(real->hash);
 +              if (co) {
 +                      if (oi->typep)
 +                              *(oi->typep) = co->type;
 +                      if (oi->sizep)
 +                              *(oi->sizep) = co->size;
 +                      if (oi->disk_sizep)
 +                              *(oi->disk_sizep) = 0;
 +                      if (oi->delta_base_sha1)
 +                              hashclr(oi->delta_base_sha1);
 +                      if (oi->type_name)
 +                              strbuf_addstr(oi->type_name, type_name(co->type));
 +                      if (oi->contentp)
 +                              *oi->contentp = xmemdupz(co->buf, co->size);
 +                      oi->whence = OI_CACHED;
 +                      return 0;
 +              }
 +      }
 +
 +      while (1) {
-               if (!sha1_loose_object_info(the_repository, real->hash, oi, flags))
++              if (find_pack_entry(r, real->hash, &e))
 +                      break;
 +
 +              if (flags & OBJECT_INFO_IGNORE_LOOSE)
 +                      return -1;
 +
 +              /* Most likely it's a loose object. */
-                       reprepare_packed_git(the_repository);
-                       if (find_pack_entry(the_repository, real->hash, &e))
++              if (!sha1_loose_object_info(r, real->hash, oi, flags))
 +                      return 0;
 +
 +              /* Not a loose object; someone else may have just packed it. */
 +              if (!(flags & OBJECT_INFO_QUICK)) {
-                   !already_retried) {
++                      reprepare_packed_git(r);
++                      if (find_pack_entry(r, real->hash, &e))
 +                              break;
 +              }
 +
 +              /* Check if it is a missing object */
 +              if (fetch_if_missing && repository_format_partial_clone &&
-                        * TODO Investigate haveing fetch_object() return
++                  !already_retried && r == the_repository) {
 +                      /*
-       rtype = packed_object_info(e.p, e.offset, oi);
++                       * TODO Investigate having fetch_object() return
 +                       * TODO error/success and stopping the music here.
++                       * TODO Pass a repository struct through fetch_object,
++                       * such that arbitrary repositories work.
 +                       */
 +                      fetch_object(repository_format_partial_clone, real->hash);
 +                      already_retried = 1;
 +                      continue;
 +              }
 +
 +              return -1;
 +      }
 +
 +      if (oi == &blank_oi)
 +              /*
 +               * We know that the caller doesn't actually need the
 +               * information below, so return early.
 +               */
 +              return 0;
-               return oid_object_info_extended(real, oi, 0);
++      rtype = packed_object_info(r, e.p, e.offset, oi);
 +      if (rtype < 0) {
 +              mark_bad_packed_object(e.p, real->hash);
- int oid_object_info(const struct object_id *oid, unsigned long *sizep)
++              return oid_object_info_extended(r, real, oi, 0);
 +      } else if (oi->whence == OI_PACKED) {
 +              oi->u.packed.offset = e.offset;
 +              oi->u.packed.pack = e.p;
 +              oi->u.packed.is_delta = (rtype == OBJ_REF_DELTA ||
 +                                       rtype == OBJ_OFS_DELTA);
 +      }
 +
 +      return 0;
 +}
 +
 +/* returns enum object_type or negative */
-       if (oid_object_info_extended(oid, &oi,
-                                    OBJECT_INFO_LOOKUP_REPLACE) < 0)
++int oid_object_info(struct repository *r,
++                  const struct object_id *oid,
++                  unsigned long *sizep)
 +{
 +      enum object_type type;
 +      struct object_info oi = OBJECT_INFO_INIT;
 +
 +      oi.typep = &type;
 +      oi.sizep = sizep;
-       if (oid_object_info_extended(&oid, &oi, 0) < 0)
++      if (oid_object_info_extended(r, oid, &oi,
++                                    OBJECT_INFO_LOOKUP_REPLACE) < 0)
 +              return -1;
 +      return type;
 +}
 +
 +static void *read_object(const unsigned char *sha1, enum object_type *type,
 +                       unsigned long *size)
 +{
 +      struct object_id oid;
 +      struct object_info oi = OBJECT_INFO_INIT;
 +      void *content;
 +      oi.typep = type;
 +      oi.sizep = size;
 +      oi.contentp = &content;
 +
 +      hashcpy(oid.hash, sha1);
 +
-       return oid_object_info_extended(&oid, NULL,
++      if (oid_object_info_extended(the_repository, &oid, &oi, 0) < 0)
 +              return NULL;
 +      return content;
 +}
 +
 +int pretend_object_file(void *buf, unsigned long len, enum object_type type,
 +                      struct object_id *oid)
 +{
 +      struct cached_object *co;
 +
 +      hash_object_file(buf, len, type_name(type), oid);
 +      if (has_sha1_file(oid->hash) || find_cached_object(oid->hash))
 +              return 0;
 +      ALLOC_GROW(cached_objects, cached_object_nr + 1, cached_object_alloc);
 +      co = &cached_objects[cached_object_nr++];
 +      co->size = len;
 +      co->type = type;
 +      co->buf = xmalloc(len);
 +      memcpy(co->buf, buf, len);
 +      hashcpy(co->sha1, oid->hash);
 +      return 0;
 +}
 +
 +/*
 + * This function dies on corrupt objects; the callers who want to
 + * deal with them should arrange to call read_object() and give error
 + * messages themselves.
 + */
 +void *read_object_file_extended(const struct object_id *oid,
 +                              enum object_type *type,
 +                              unsigned long *size,
 +                              int lookup_replace)
 +{
 +      void *data;
 +      const struct packed_git *p;
 +      const char *path;
 +      struct stat st;
 +      const struct object_id *repl = lookup_replace ?
 +              lookup_replace_object(the_repository, oid) : oid;
 +
 +      errno = 0;
 +      data = read_object(repl->hash, type, size);
 +      if (data)
 +              return data;
 +
 +      if (errno && errno != ENOENT)
 +              die_errno("failed to read object %s", oid_to_hex(oid));
 +
 +      /* die if we replaced an object with one that does not exist */
 +      if (repl != oid)
 +              die("replacement %s not found for %s",
 +                  oid_to_hex(repl), oid_to_hex(oid));
 +
 +      if (!stat_sha1_file(the_repository, repl->hash, &st, &path))
 +              die("loose object %s (stored in %s) is corrupt",
 +                  oid_to_hex(repl), path);
 +
 +      if ((p = has_packed_and_bad(repl->hash)) != NULL)
 +              die("packed object %s (stored in %s) is corrupt",
 +                  oid_to_hex(repl), p->pack_name);
 +
 +      return NULL;
 +}
 +
 +void *read_object_with_reference(const struct object_id *oid,
 +                               const char *required_type_name,
 +                               unsigned long *size,
 +                               struct object_id *actual_oid_return)
 +{
 +      enum object_type type, required_type;
 +      void *buffer;
 +      unsigned long isize;
 +      struct object_id actual_oid;
 +
 +      required_type = type_from_string(required_type_name);
 +      oidcpy(&actual_oid, oid);
 +      while (1) {
 +              int ref_length = -1;
 +              const char *ref_type = NULL;
 +
 +              buffer = read_object_file(&actual_oid, &type, &isize);
 +              if (!buffer)
 +                      return NULL;
 +              if (type == required_type) {
 +                      *size = isize;
 +                      if (actual_oid_return)
 +                              oidcpy(actual_oid_return, &actual_oid);
 +                      return buffer;
 +              }
 +              /* Handle references */
 +              else if (type == OBJ_COMMIT)
 +                      ref_type = "tree ";
 +              else if (type == OBJ_TAG)
 +                      ref_type = "object ";
 +              else {
 +                      free(buffer);
 +                      return NULL;
 +              }
 +              ref_length = strlen(ref_type);
 +
 +              if (ref_length + GIT_SHA1_HEXSZ > isize ||
 +                  memcmp(buffer, ref_type, ref_length) ||
 +                  get_oid_hex((char *) buffer + ref_length, &actual_oid)) {
 +                      free(buffer);
 +                      return NULL;
 +              }
 +              free(buffer);
 +              /* Now we have the ID of the referred-to object in
 +               * actual_oid.  Check again. */
 +      }
 +}
 +
 +static void write_object_file_prepare(const void *buf, unsigned long len,
 +                                    const char *type, struct object_id *oid,
 +                                    char *hdr, int *hdrlen)
 +{
 +      git_hash_ctx c;
 +
 +      /* Generate the header */
 +      *hdrlen = xsnprintf(hdr, *hdrlen, "%s %lu", type, len)+1;
 +
 +      /* Sha1.. */
 +      the_hash_algo->init_fn(&c);
 +      the_hash_algo->update_fn(&c, hdr, *hdrlen);
 +      the_hash_algo->update_fn(&c, buf, len);
 +      the_hash_algo->final_fn(oid->hash, &c);
 +}
 +
 +/*
 + * Move the just written object into its final resting place.
 + */
 +int finalize_object_file(const char *tmpfile, const char *filename)
 +{
 +      int ret = 0;
 +
 +      if (object_creation_mode == OBJECT_CREATION_USES_RENAMES)
 +              goto try_rename;
 +      else if (link(tmpfile, filename))
 +              ret = errno;
 +
 +      /*
 +       * Coda hack - coda doesn't like cross-directory links,
 +       * so we fall back to a rename, which will mean that it
 +       * won't be able to check collisions, but that's not a
 +       * big deal.
 +       *
 +       * The same holds for FAT formatted media.
 +       *
 +       * When this succeeds, we just return.  We have nothing
 +       * left to unlink.
 +       */
 +      if (ret && ret != EEXIST) {
 +      try_rename:
 +              if (!rename(tmpfile, filename))
 +                      goto out;
 +              ret = errno;
 +      }
 +      unlink_or_warn(tmpfile);
 +      if (ret) {
 +              if (ret != EEXIST) {
 +                      return error_errno("unable to write sha1 filename %s", filename);
 +              }
 +              /* FIXME!!! Collision check here ? */
 +      }
 +
 +out:
 +      if (adjust_shared_perm(filename))
 +              return error("unable to set permission to '%s'", filename);
 +      return 0;
 +}
 +
 +static int write_buffer(int fd, const void *buf, size_t len)
 +{
 +      if (write_in_full(fd, buf, len) < 0)
 +              return error_errno("file write error");
 +      return 0;
 +}
 +
 +int hash_object_file(const void *buf, unsigned long len, const char *type,
 +                   struct object_id *oid)
 +{
 +      char hdr[MAX_HEADER_LEN];
 +      int hdrlen = sizeof(hdr);
 +      write_object_file_prepare(buf, len, type, oid, hdr, &hdrlen);
 +      return 0;
 +}
 +
 +/* Finalize a file on disk, and close it. */
 +static void close_sha1_file(int fd)
 +{
 +      if (fsync_object_files)
 +              fsync_or_die(fd, "sha1 file");
 +      if (close(fd) != 0)
 +              die_errno("error when closing sha1 file");
 +}
 +
 +/* Size of directory component, including the ending '/' */
 +static inline int directory_size(const char *filename)
 +{
 +      const char *s = strrchr(filename, '/');
 +      if (!s)
 +              return 0;
 +      return s - filename + 1;
 +}
 +
 +/*
 + * This creates a temporary file in the same directory as the final
 + * 'filename'
 + *
 + * We want to avoid cross-directory filename renames, because those
 + * can have problems on various filesystems (FAT, NFS, Coda).
 + */
 +static int create_tmpfile(struct strbuf *tmp, const char *filename)
 +{
 +      int fd, dirlen = directory_size(filename);
 +
 +      strbuf_reset(tmp);
 +      strbuf_add(tmp, filename, dirlen);
 +      strbuf_addstr(tmp, "tmp_obj_XXXXXX");
 +      fd = git_mkstemp_mode(tmp->buf, 0444);
 +      if (fd < 0 && dirlen && errno == ENOENT) {
 +              /*
 +               * Make sure the directory exists; note that the contents
 +               * of the buffer are undefined after mkstemp returns an
 +               * error, so we have to rewrite the whole buffer from
 +               * scratch.
 +               */
 +              strbuf_reset(tmp);
 +              strbuf_add(tmp, filename, dirlen - 1);
 +              if (mkdir(tmp->buf, 0777) && errno != EEXIST)
 +                      return -1;
 +              if (adjust_shared_perm(tmp->buf))
 +                      return -1;
 +
 +              /* Try again */
 +              strbuf_addstr(tmp, "/tmp_obj_XXXXXX");
 +              fd = git_mkstemp_mode(tmp->buf, 0444);
 +      }
 +      return fd;
 +}
 +
 +static int write_loose_object(const struct object_id *oid, char *hdr,
 +                            int hdrlen, const void *buf, unsigned long len,
 +                            time_t mtime)
 +{
 +      int fd, ret;
 +      unsigned char compressed[4096];
 +      git_zstream stream;
 +      git_hash_ctx c;
 +      struct object_id parano_oid;
 +      static struct strbuf tmp_file = STRBUF_INIT;
 +      static struct strbuf filename = STRBUF_INIT;
 +
 +      strbuf_reset(&filename);
 +      sha1_file_name(the_repository, &filename, oid->hash);
 +
 +      fd = create_tmpfile(&tmp_file, filename.buf);
 +      if (fd < 0) {
 +              if (errno == EACCES)
 +                      return error("insufficient permission for adding an object to repository database %s", get_object_directory());
 +              else
 +                      return error_errno("unable to create temporary file");
 +      }
 +
 +      /* Set it up */
 +      git_deflate_init(&stream, zlib_compression_level);
 +      stream.next_out = compressed;
 +      stream.avail_out = sizeof(compressed);
 +      the_hash_algo->init_fn(&c);
 +
 +      /* First header.. */
 +      stream.next_in = (unsigned char *)hdr;
 +      stream.avail_in = hdrlen;
 +      while (git_deflate(&stream, 0) == Z_OK)
 +              ; /* nothing */
 +      the_hash_algo->update_fn(&c, hdr, hdrlen);
 +
 +      /* Then the data itself.. */
 +      stream.next_in = (void *)buf;
 +      stream.avail_in = len;
 +      do {
 +              unsigned char *in0 = stream.next_in;
 +              ret = git_deflate(&stream, Z_FINISH);
 +              the_hash_algo->update_fn(&c, in0, stream.next_in - in0);
 +              if (write_buffer(fd, compressed, stream.next_out - compressed) < 0)
 +                      die("unable to write sha1 file");
 +              stream.next_out = compressed;
 +              stream.avail_out = sizeof(compressed);
 +      } while (ret == Z_OK);
 +
 +      if (ret != Z_STREAM_END)
 +              die("unable to deflate new object %s (%d)", oid_to_hex(oid),
 +                  ret);
 +      ret = git_deflate_end_gently(&stream);
 +      if (ret != Z_OK)
 +              die("deflateEnd on object %s failed (%d)", oid_to_hex(oid),
 +                  ret);
 +      the_hash_algo->final_fn(parano_oid.hash, &c);
 +      if (oidcmp(oid, &parano_oid) != 0)
 +              die("confused by unstable object source data for %s",
 +                  oid_to_hex(oid));
 +
 +      close_sha1_file(fd);
 +
 +      if (mtime) {
 +              struct utimbuf utb;
 +              utb.actime = mtime;
 +              utb.modtime = mtime;
 +              if (utime(tmp_file.buf, &utb) < 0)
 +                      warning_errno("failed utime() on %s", tmp_file.buf);
 +      }
 +
 +      return finalize_object_file(tmp_file.buf, filename.buf);
 +}
 +
 +static int freshen_loose_object(const unsigned char *sha1)
 +{
 +      return check_and_freshen(sha1, 1);
 +}
 +
 +static int freshen_packed_object(const unsigned char *sha1)
 +{
 +      struct pack_entry e;
 +      if (!find_pack_entry(the_repository, sha1, &e))
 +              return 0;
 +      if (e.p->freshened)
 +              return 1;
 +      if (!freshen_file(e.p->pack_name))
 +              return 0;
 +      e.p->freshened = 1;
 +      return 1;
 +}
 +
 +int write_object_file(const void *buf, unsigned long len, const char *type,
 +                    struct object_id *oid)
 +{
 +      char hdr[MAX_HEADER_LEN];
 +      int hdrlen = sizeof(hdr);
 +
 +      /* Normally if we have it in the pack then we do not bother writing
 +       * it out into .git/objects/??/?{38} file.
 +       */
 +      write_object_file_prepare(buf, len, type, oid, hdr, &hdrlen);
 +      if (freshen_packed_object(oid->hash) || freshen_loose_object(oid->hash))
 +              return 0;
 +      return write_loose_object(oid, hdr, hdrlen, buf, len, 0);
 +}
 +
 +int hash_object_file_literally(const void *buf, unsigned long len,
 +                             const char *type, struct object_id *oid,
 +                             unsigned flags)
 +{
 +      char *header;
 +      int hdrlen, status = 0;
 +
 +      /* type string, SP, %lu of the length plus NUL must fit this */
 +      hdrlen = strlen(type) + MAX_HEADER_LEN;
 +      header = xmalloc(hdrlen);
 +      write_object_file_prepare(buf, len, type, oid, header, &hdrlen);
 +
 +      if (!(flags & HASH_WRITE_OBJECT))
 +              goto cleanup;
 +      if (freshen_packed_object(oid->hash) || freshen_loose_object(oid->hash))
 +              goto cleanup;
 +      status = write_loose_object(oid, header, hdrlen, buf, len, 0);
 +
 +cleanup:
 +      free(header);
 +      return status;
 +}
 +
 +int force_object_loose(const struct object_id *oid, time_t mtime)
 +{
 +      void *buf;
 +      unsigned long len;
 +      enum object_type type;
 +      char hdr[MAX_HEADER_LEN];
 +      int hdrlen;
 +      int ret;
 +
 +      if (has_loose_object(oid->hash))
 +              return 0;
 +      buf = read_object(oid->hash, &type, &len);
 +      if (!buf)
 +              return error("cannot read sha1_file for %s", oid_to_hex(oid));
 +      hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %lu", type_name(type), len) + 1;
 +      ret = write_loose_object(oid, hdr, hdrlen, buf, len, mtime);
 +      free(buf);
 +
 +      return ret;
 +}
 +
 +int has_sha1_file_with_flags(const unsigned char *sha1, int flags)
 +{
 +      struct object_id oid;
 +      if (!startup_info->have_repository)
 +              return 0;
 +      hashcpy(oid.hash, sha1);
-       enum object_type type = oid_object_info(oid, NULL);
++      return oid_object_info_extended(the_repository, &oid, NULL,
 +                                      flags | OBJECT_INFO_SKIP_CACHED) >= 0;
 +}
 +
 +int has_object_file(const struct object_id *oid)
 +{
 +      return has_sha1_file(oid->hash);
 +}
 +
 +int has_object_file_with_flags(const struct object_id *oid, int flags)
 +{
 +      return has_sha1_file_with_flags(oid->hash, flags);
 +}
 +
 +static void check_tree(const void *buf, size_t size)
 +{
 +      struct tree_desc desc;
 +      struct name_entry entry;
 +
 +      init_tree_desc(&desc, buf, size);
 +      while (tree_entry(&desc, &entry))
 +              /* do nothing
 +               * tree_entry() will die() on malformed entries */
 +              ;
 +}
 +
 +static void check_commit(const void *buf, size_t size)
 +{
 +      struct commit c;
 +      memset(&c, 0, sizeof(c));
 +      if (parse_commit_buffer(&c, buf, size))
 +              die("corrupt commit");
 +}
 +
 +static void check_tag(const void *buf, size_t size)
 +{
 +      struct tag t;
 +      memset(&t, 0, sizeof(t));
 +      if (parse_tag_buffer(&t, buf, size))
 +              die("corrupt tag");
 +}
 +
 +static int index_mem(struct object_id *oid, void *buf, size_t size,
 +                   enum object_type type,
 +                   const char *path, unsigned flags)
 +{
 +      int ret, re_allocated = 0;
 +      int write_object = flags & HASH_WRITE_OBJECT;
 +
 +      if (!type)
 +              type = OBJ_BLOB;
 +
 +      /*
 +       * Convert blobs to git internal format
 +       */
 +      if ((type == OBJ_BLOB) && path) {
 +              struct strbuf nbuf = STRBUF_INIT;
 +              if (convert_to_git(&the_index, path, buf, size, &nbuf,
 +                                 get_conv_flags(flags))) {
 +                      buf = strbuf_detach(&nbuf, &size);
 +                      re_allocated = 1;
 +              }
 +      }
 +      if (flags & HASH_FORMAT_CHECK) {
 +              if (type == OBJ_TREE)
 +                      check_tree(buf, size);
 +              if (type == OBJ_COMMIT)
 +                      check_commit(buf, size);
 +              if (type == OBJ_TAG)
 +                      check_tag(buf, size);
 +      }
 +
 +      if (write_object)
 +              ret = write_object_file(buf, size, type_name(type), oid);
 +      else
 +              ret = hash_object_file(buf, size, type_name(type), oid);
 +      if (re_allocated)
 +              free(buf);
 +      return ret;
 +}
 +
 +static int index_stream_convert_blob(struct object_id *oid, int fd,
 +                                   const char *path, unsigned flags)
 +{
 +      int ret;
 +      const int write_object = flags & HASH_WRITE_OBJECT;
 +      struct strbuf sbuf = STRBUF_INIT;
 +
 +      assert(path);
 +      assert(would_convert_to_git_filter_fd(path));
 +
 +      convert_to_git_filter_fd(&the_index, path, fd, &sbuf,
 +                               get_conv_flags(flags));
 +
 +      if (write_object)
 +              ret = write_object_file(sbuf.buf, sbuf.len, type_name(OBJ_BLOB),
 +                                      oid);
 +      else
 +              ret = hash_object_file(sbuf.buf, sbuf.len, type_name(OBJ_BLOB),
 +                                     oid);
 +      strbuf_release(&sbuf);
 +      return ret;
 +}
 +
 +static int index_pipe(struct object_id *oid, int fd, enum object_type type,
 +                    const char *path, unsigned flags)
 +{
 +      struct strbuf sbuf = STRBUF_INIT;
 +      int ret;
 +
 +      if (strbuf_read(&sbuf, fd, 4096) >= 0)
 +              ret = index_mem(oid, sbuf.buf, sbuf.len, type, path, flags);
 +      else
 +              ret = -1;
 +      strbuf_release(&sbuf);
 +      return ret;
 +}
 +
 +#define SMALL_FILE_SIZE (32*1024)
 +
 +static int index_core(struct object_id *oid, int fd, size_t size,
 +                    enum object_type type, const char *path,
 +                    unsigned flags)
 +{
 +      int ret;
 +
 +      if (!size) {
 +              ret = index_mem(oid, "", size, type, path, flags);
 +      } else if (size <= SMALL_FILE_SIZE) {
 +              char *buf = xmalloc(size);
 +              ssize_t read_result = read_in_full(fd, buf, size);
 +              if (read_result < 0)
 +                      ret = error_errno("read error while indexing %s",
 +                                        path ? path : "<unknown>");
 +              else if (read_result != size)
 +                      ret = error("short read while indexing %s",
 +                                  path ? path : "<unknown>");
 +              else
 +                      ret = index_mem(oid, buf, size, type, path, flags);
 +              free(buf);
 +      } else {
 +              void *buf = xmmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
 +              ret = index_mem(oid, buf, size, type, path, flags);
 +              munmap(buf, size);
 +      }
 +      return ret;
 +}
 +
 +/*
 + * This creates one packfile per large blob unless bulk-checkin
 + * machinery is "plugged".
 + *
 + * This also bypasses the usual "convert-to-git" dance, and that is on
 + * purpose. We could write a streaming version of the converting
 + * functions and insert that before feeding the data to fast-import
 + * (or equivalent in-core API described above). However, that is
 + * somewhat complicated, as we do not know the size of the filter
 + * result, which we need to know beforehand when writing a git object.
 + * Since the primary motivation for trying to stream from the working
 + * tree file and to avoid mmaping it in core is to deal with large
 + * binary blobs, they generally do not want to get any conversion, and
 + * callers should avoid this code path when filters are requested.
 + */
 +static int index_stream(struct object_id *oid, int fd, size_t size,
 +                      enum object_type type, const char *path,
 +                      unsigned flags)
 +{
 +      return index_bulk_checkin(oid, fd, size, type, path, flags);
 +}
 +
 +int index_fd(struct object_id *oid, int fd, struct stat *st,
 +           enum object_type type, const char *path, unsigned flags)
 +{
 +      int ret;
 +
 +      /*
 +       * Call xsize_t() only when needed to avoid potentially unnecessary
 +       * die() for large files.
 +       */
 +      if (type == OBJ_BLOB && path && would_convert_to_git_filter_fd(path))
 +              ret = index_stream_convert_blob(oid, fd, path, flags);
 +      else if (!S_ISREG(st->st_mode))
 +              ret = index_pipe(oid, fd, type, path, flags);
 +      else if (st->st_size <= big_file_threshold || type != OBJ_BLOB ||
 +               (path && would_convert_to_git(&the_index, path)))
 +              ret = index_core(oid, fd, xsize_t(st->st_size), type, path,
 +                               flags);
 +      else
 +              ret = index_stream(oid, fd, xsize_t(st->st_size), type, path,
 +                                 flags);
 +      close(fd);
 +      return ret;
 +}
 +
 +int index_path(struct object_id *oid, const char *path, struct stat *st, unsigned flags)
 +{
 +      int fd;
 +      struct strbuf sb = STRBUF_INIT;
 +      int rc = 0;
 +
 +      switch (st->st_mode & S_IFMT) {
 +      case S_IFREG:
 +              fd = open(path, O_RDONLY);
 +              if (fd < 0)
 +                      return error_errno("open(\"%s\")", path);
 +              if (index_fd(oid, fd, st, OBJ_BLOB, path, flags) < 0)
 +                      return error("%s: failed to insert into database",
 +                                   path);
 +              break;
 +      case S_IFLNK:
 +              if (strbuf_readlink(&sb, path, st->st_size))
 +                      return error_errno("readlink(\"%s\")", path);
 +              if (!(flags & HASH_WRITE_OBJECT))
 +                      hash_object_file(sb.buf, sb.len, blob_type, oid);
 +              else if (write_object_file(sb.buf, sb.len, blob_type, oid))
 +                      rc = error("%s: failed to insert into database", path);
 +              strbuf_release(&sb);
 +              break;
 +      case S_IFDIR:
 +              return resolve_gitlink_ref(path, "HEAD", oid);
 +      default:
 +              return error("%s: unsupported file type", path);
 +      }
 +      return rc;
 +}
 +
 +int read_pack_header(int fd, struct pack_header *header)
 +{
 +      if (read_in_full(fd, header, sizeof(*header)) != sizeof(*header))
 +              /* "eof before pack header was fully read" */
 +              return PH_ERROR_EOF;
 +
 +      if (header->hdr_signature != htonl(PACK_SIGNATURE))
 +              /* "protocol error (pack signature mismatch detected)" */
 +              return PH_ERROR_PACK_SIGNATURE;
 +      if (!pack_version_ok(header->hdr_version))
 +              /* "protocol error (pack version unsupported)" */
 +              return PH_ERROR_PROTOCOL;
 +      return 0;
 +}
 +
 +void assert_oid_type(const struct object_id *oid, enum object_type expect)
 +{
++      enum object_type type = oid_object_info(the_repository, oid, NULL);
 +      if (type < 0)
 +              die("%s is not a valid object", oid_to_hex(oid));
 +      if (type != expect)
 +              die("%s is not a valid '%s' object", oid_to_hex(oid),
 +                  type_name(expect));
 +}
 +
 +int for_each_file_in_obj_subdir(unsigned int subdir_nr,
 +                              struct strbuf *path,
 +                              each_loose_object_fn obj_cb,
 +                              each_loose_cruft_fn cruft_cb,
 +                              each_loose_subdir_fn subdir_cb,
 +                              void *data)
 +{
 +      size_t origlen, baselen;
 +      DIR *dir;
 +      struct dirent *de;
 +      int r = 0;
 +      struct object_id oid;
 +
 +      if (subdir_nr > 0xff)
 +              BUG("invalid loose object subdirectory: %x", subdir_nr);
 +
 +      origlen = path->len;
 +      strbuf_complete(path, '/');
 +      strbuf_addf(path, "%02x", subdir_nr);
 +
 +      dir = opendir(path->buf);
 +      if (!dir) {
 +              if (errno != ENOENT)
 +                      r = error_errno("unable to open %s", path->buf);
 +              strbuf_setlen(path, origlen);
 +              return r;
 +      }
 +
 +      oid.hash[0] = subdir_nr;
 +      strbuf_addch(path, '/');
 +      baselen = path->len;
 +
 +      while ((de = readdir(dir))) {
 +              size_t namelen;
 +              if (is_dot_or_dotdot(de->d_name))
 +                      continue;
 +
 +              namelen = strlen(de->d_name);
 +              strbuf_setlen(path, baselen);
 +              strbuf_add(path, de->d_name, namelen);
 +              if (namelen == GIT_SHA1_HEXSZ - 2 &&
 +                  !hex_to_bytes(oid.hash + 1, de->d_name,
 +                                GIT_SHA1_RAWSZ - 1)) {
 +                      if (obj_cb) {
 +                              r = obj_cb(&oid, path->buf, data);
 +                              if (r)
 +                                      break;
 +                      }
 +                      continue;
 +              }
 +
 +              if (cruft_cb) {
 +                      r = cruft_cb(de->d_name, path->buf, data);
 +                      if (r)
 +                              break;
 +              }
 +      }
 +      closedir(dir);
 +
 +      strbuf_setlen(path, baselen - 1);
 +      if (!r && subdir_cb)
 +              r = subdir_cb(subdir_nr, path->buf, data);
 +
 +      strbuf_setlen(path, origlen);
 +
 +      return r;
 +}
 +
 +int for_each_loose_file_in_objdir_buf(struct strbuf *path,
 +                          each_loose_object_fn obj_cb,
 +                          each_loose_cruft_fn cruft_cb,
 +                          each_loose_subdir_fn subdir_cb,
 +                          void *data)
 +{
 +      int r = 0;
 +      int i;
 +
 +      for (i = 0; i < 256; i++) {
 +              r = for_each_file_in_obj_subdir(i, path, obj_cb, cruft_cb,
 +                                              subdir_cb, data);
 +              if (r)
 +                      break;
 +      }
 +
 +      return r;
 +}
 +
 +int for_each_loose_file_in_objdir(const char *path,
 +                                each_loose_object_fn obj_cb,
 +                                each_loose_cruft_fn cruft_cb,
 +                                each_loose_subdir_fn subdir_cb,
 +                                void *data)
 +{
 +      struct strbuf buf = STRBUF_INIT;
 +      int r;
 +
 +      strbuf_addstr(&buf, path);
 +      r = for_each_loose_file_in_objdir_buf(&buf, obj_cb, cruft_cb,
 +                                            subdir_cb, data);
 +      strbuf_release(&buf);
 +
 +      return r;
 +}
 +
 +struct loose_alt_odb_data {
 +      each_loose_object_fn *cb;
 +      void *data;
 +};
 +
 +static int loose_from_alt_odb(struct alternate_object_database *alt,
 +                            void *vdata)
 +{
 +      struct loose_alt_odb_data *data = vdata;
 +      struct strbuf buf = STRBUF_INIT;
 +      int r;
 +
 +      strbuf_addstr(&buf, alt->path);
 +      r = for_each_loose_file_in_objdir_buf(&buf,
 +                                            data->cb, NULL, NULL,
 +                                            data->data);
 +      strbuf_release(&buf);
 +      return r;
 +}
 +
 +int for_each_loose_object(each_loose_object_fn cb, void *data, unsigned flags)
 +{
 +      struct loose_alt_odb_data alt;
 +      int r;
 +
 +      r = for_each_loose_file_in_objdir(get_object_directory(),
 +                                        cb, NULL, NULL, data);
 +      if (r)
 +              return r;
 +
 +      if (flags & FOR_EACH_OBJECT_LOCAL_ONLY)
 +              return 0;
 +
 +      alt.cb = cb;
 +      alt.data = data;
 +      return foreach_alt_odb(loose_from_alt_odb, &alt);
 +}
 +
 +static int check_stream_sha1(git_zstream *stream,
 +                           const char *hdr,
 +                           unsigned long size,
 +                           const char *path,
 +                           const unsigned char *expected_sha1)
 +{
 +      git_hash_ctx c;
 +      unsigned char real_sha1[GIT_MAX_RAWSZ];
 +      unsigned char buf[4096];
 +      unsigned long total_read;
 +      int status = Z_OK;
 +
 +      the_hash_algo->init_fn(&c);
 +      the_hash_algo->update_fn(&c, hdr, stream->total_out);
 +
 +      /*
 +       * We already read some bytes into hdr, but the ones up to the NUL
 +       * do not count against the object's content size.
 +       */
 +      total_read = stream->total_out - strlen(hdr) - 1;
 +
 +      /*
 +       * This size comparison must be "<=" to read the final zlib packets;
 +       * see the comment in unpack_sha1_rest for details.
 +       */
 +      while (total_read <= size &&
 +             (status == Z_OK || status == Z_BUF_ERROR)) {
 +              stream->next_out = buf;
 +              stream->avail_out = sizeof(buf);
 +              if (size - total_read < stream->avail_out)
 +                      stream->avail_out = size - total_read;
 +              status = git_inflate(stream, Z_FINISH);
 +              the_hash_algo->update_fn(&c, buf, stream->next_out - buf);
 +              total_read += stream->next_out - buf;
 +      }
 +      git_inflate_end(stream);
 +
 +      if (status != Z_STREAM_END) {
 +              error("corrupt loose object '%s'", sha1_to_hex(expected_sha1));
 +              return -1;
 +      }
 +      if (stream->avail_in) {
 +              error("garbage at end of loose object '%s'",
 +                    sha1_to_hex(expected_sha1));
 +              return -1;
 +      }
 +
 +      the_hash_algo->final_fn(real_sha1, &c);
 +      if (hashcmp(expected_sha1, real_sha1)) {
 +              error("sha1 mismatch for %s (expected %s)", path,
 +                    sha1_to_hex(expected_sha1));
 +              return -1;
 +      }
 +
 +      return 0;
 +}
 +
 +int read_loose_object(const char *path,
 +                    const struct object_id *expected_oid,
 +                    enum object_type *type,
 +                    unsigned long *size,
 +                    void **contents)
 +{
 +      int ret = -1;
 +      void *map = NULL;
 +      unsigned long mapsize;
 +      git_zstream stream;
 +      char hdr[MAX_HEADER_LEN];
 +
 +      *contents = NULL;
 +
 +      map = map_sha1_file_1(the_repository, path, NULL, &mapsize);
 +      if (!map) {
 +              error_errno("unable to mmap %s", path);
 +              goto out;
 +      }
 +
 +      if (unpack_sha1_header(&stream, map, mapsize, hdr, sizeof(hdr)) < 0) {
 +              error("unable to unpack header of %s", path);
 +              goto out;
 +      }
 +
 +      *type = parse_sha1_header(hdr, size);
 +      if (*type < 0) {
 +              error("unable to parse header of %s", path);
 +              git_inflate_end(&stream);
 +              goto out;
 +      }
 +
 +      if (*type == OBJ_BLOB) {
 +              if (check_stream_sha1(&stream, hdr, *size, path, expected_oid->hash) < 0)
 +                      goto out;
 +      } else {
 +              *contents = unpack_sha1_rest(&stream, hdr, *size, expected_oid->hash);
 +              if (!*contents) {
 +                      error("unable to unpack contents of %s", path);
 +                      git_inflate_end(&stream);
 +                      goto out;
 +              }
 +              if (check_object_signature(expected_oid, *contents,
 +                                       *size, type_name(*type))) {
 +                      error("sha1 mismatch for %s (expected %s)", path,
 +                            oid_to_hex(expected_oid));
 +                      free(*contents);
 +                      goto out;
 +              }
 +      }
 +
 +      ret = 0; /* everything checks out */
 +
 +out:
 +      if (map)
 +              munmap(map, mapsize);
 +      return ret;
 +}
diff --combined sha1-name.c
index bd99fd822bd4c6948eb401ae305192bdaa8ce36e,0000000000000000000000000000000000000000..80030b159a74cb768c4cfc483e9b51da38baa0d6
mode 100644,000000..100644
--- /dev/null
@@@ -1,1734 -1,0 +1,1734 @@@
-       int kind = oid_object_info(oid, NULL);
 +#include "cache.h"
 +#include "config.h"
 +#include "tag.h"
 +#include "commit.h"
 +#include "tree.h"
 +#include "blob.h"
 +#include "tree-walk.h"
 +#include "refs.h"
 +#include "remote.h"
 +#include "dir.h"
 +#include "sha1-array.h"
 +#include "packfile.h"
 +#include "object-store.h"
 +#include "repository.h"
 +
 +static int get_oid_oneline(const char *, struct object_id *, struct commit_list *);
 +
 +typedef int (*disambiguate_hint_fn)(const struct object_id *, void *);
 +
 +struct disambiguate_state {
 +      int len; /* length of prefix in hex chars */
 +      char hex_pfx[GIT_MAX_HEXSZ + 1];
 +      struct object_id bin_pfx;
 +
 +      disambiguate_hint_fn fn;
 +      void *cb_data;
 +      struct object_id candidate;
 +      unsigned candidate_exists:1;
 +      unsigned candidate_checked:1;
 +      unsigned candidate_ok:1;
 +      unsigned disambiguate_fn_used:1;
 +      unsigned ambiguous:1;
 +      unsigned always_call_fn:1;
 +};
 +
 +static void update_candidates(struct disambiguate_state *ds, const struct object_id *current)
 +{
 +      if (ds->always_call_fn) {
 +              ds->ambiguous = ds->fn(current, ds->cb_data) ? 1 : 0;
 +              return;
 +      }
 +      if (!ds->candidate_exists) {
 +              /* this is the first candidate */
 +              oidcpy(&ds->candidate, current);
 +              ds->candidate_exists = 1;
 +              return;
 +      } else if (!oidcmp(&ds->candidate, current)) {
 +              /* the same as what we already have seen */
 +              return;
 +      }
 +
 +      if (!ds->fn) {
 +              /* cannot disambiguate between ds->candidate and current */
 +              ds->ambiguous = 1;
 +              return;
 +      }
 +
 +      if (!ds->candidate_checked) {
 +              ds->candidate_ok = ds->fn(&ds->candidate, ds->cb_data);
 +              ds->disambiguate_fn_used = 1;
 +              ds->candidate_checked = 1;
 +      }
 +
 +      if (!ds->candidate_ok) {
 +              /* discard the candidate; we know it does not satisfy fn */
 +              oidcpy(&ds->candidate, current);
 +              ds->candidate_checked = 0;
 +              return;
 +      }
 +
 +      /* if we reach this point, we know ds->candidate satisfies fn */
 +      if (ds->fn(current, ds->cb_data)) {
 +              /*
 +               * if both current and candidate satisfy fn, we cannot
 +               * disambiguate.
 +               */
 +              ds->candidate_ok = 0;
 +              ds->ambiguous = 1;
 +      }
 +
 +      /* otherwise, current can be discarded and candidate is still good */
 +}
 +
 +static int append_loose_object(const struct object_id *oid, const char *path,
 +                             void *data)
 +{
 +      oid_array_append(data, oid);
 +      return 0;
 +}
 +
 +static int match_sha(unsigned, const unsigned char *, const unsigned char *);
 +
 +static void find_short_object_filename(struct disambiguate_state *ds)
 +{
 +      int subdir_nr = ds->bin_pfx.hash[0];
 +      struct alternate_object_database *alt;
 +      static struct alternate_object_database *fakeent;
 +
 +      if (!fakeent) {
 +              /*
 +               * Create a "fake" alternate object database that
 +               * points to our own object database, to make it
 +               * easier to get a temporary working space in
 +               * alt->name/alt->base while iterating over the
 +               * object databases including our own.
 +               */
 +              fakeent = alloc_alt_odb(get_object_directory());
 +      }
 +      fakeent->next = the_repository->objects->alt_odb_list;
 +
 +      for (alt = fakeent; alt && !ds->ambiguous; alt = alt->next) {
 +              int pos;
 +
 +              if (!alt->loose_objects_subdir_seen[subdir_nr]) {
 +                      struct strbuf *buf = alt_scratch_buf(alt);
 +                      for_each_file_in_obj_subdir(subdir_nr, buf,
 +                                                  append_loose_object,
 +                                                  NULL, NULL,
 +                                                  &alt->loose_objects_cache);
 +                      alt->loose_objects_subdir_seen[subdir_nr] = 1;
 +              }
 +
 +              pos = oid_array_lookup(&alt->loose_objects_cache, &ds->bin_pfx);
 +              if (pos < 0)
 +                      pos = -1 - pos;
 +              while (!ds->ambiguous && pos < alt->loose_objects_cache.nr) {
 +                      const struct object_id *oid;
 +                      oid = alt->loose_objects_cache.oid + pos;
 +                      if (!match_sha(ds->len, ds->bin_pfx.hash, oid->hash))
 +                              break;
 +                      update_candidates(ds, oid);
 +                      pos++;
 +              }
 +      }
 +}
 +
 +static int match_sha(unsigned len, const unsigned char *a, const unsigned char *b)
 +{
 +      do {
 +              if (*a != *b)
 +                      return 0;
 +              a++;
 +              b++;
 +              len -= 2;
 +      } while (len > 1);
 +      if (len)
 +              if ((*a ^ *b) & 0xf0)
 +                      return 0;
 +      return 1;
 +}
 +
 +static void unique_in_pack(struct packed_git *p,
 +                         struct disambiguate_state *ds)
 +{
 +      uint32_t num, i, first = 0;
 +      const struct object_id *current = NULL;
 +
 +      if (open_pack_index(p) || !p->num_objects)
 +              return;
 +
 +      num = p->num_objects;
 +      bsearch_pack(&ds->bin_pfx, p, &first);
 +
 +      /*
 +       * At this point, "first" is the location of the lowest object
 +       * with an object name that could match "bin_pfx".  See if we have
 +       * 0, 1 or more objects that actually match(es).
 +       */
 +      for (i = first; i < num && !ds->ambiguous; i++) {
 +              struct object_id oid;
 +              current = nth_packed_object_oid(&oid, p, i);
 +              if (!match_sha(ds->len, ds->bin_pfx.hash, current->hash))
 +                      break;
 +              update_candidates(ds, current);
 +      }
 +}
 +
 +static void find_short_packed_object(struct disambiguate_state *ds)
 +{
 +      struct packed_git *p;
 +
 +      for (p = get_packed_git(the_repository); p && !ds->ambiguous;
 +           p = p->next)
 +              unique_in_pack(p, ds);
 +}
 +
 +#define SHORT_NAME_NOT_FOUND (-1)
 +#define SHORT_NAME_AMBIGUOUS (-2)
 +
 +static int finish_object_disambiguation(struct disambiguate_state *ds,
 +                                      struct object_id *oid)
 +{
 +      if (ds->ambiguous)
 +              return SHORT_NAME_AMBIGUOUS;
 +
 +      if (!ds->candidate_exists)
 +              return SHORT_NAME_NOT_FOUND;
 +
 +      if (!ds->candidate_checked)
 +              /*
 +               * If this is the only candidate, there is no point
 +               * calling the disambiguation hint callback.
 +               *
 +               * On the other hand, if the current candidate
 +               * replaced an earlier candidate that did _not_ pass
 +               * the disambiguation hint callback, then we do have
 +               * more than one objects that match the short name
 +               * given, so we should make sure this one matches;
 +               * otherwise, if we discovered this one and the one
 +               * that we previously discarded in the reverse order,
 +               * we would end up showing different results in the
 +               * same repository!
 +               */
 +              ds->candidate_ok = (!ds->disambiguate_fn_used ||
 +                                  ds->fn(&ds->candidate, ds->cb_data));
 +
 +      if (!ds->candidate_ok)
 +              return SHORT_NAME_AMBIGUOUS;
 +
 +      oidcpy(oid, &ds->candidate);
 +      return 0;
 +}
 +
 +static int disambiguate_commit_only(const struct object_id *oid, void *cb_data_unused)
 +{
-       kind = oid_object_info(oid, NULL);
++      int kind = oid_object_info(the_repository, oid, NULL);
 +      return kind == OBJ_COMMIT;
 +}
 +
 +static int disambiguate_committish_only(const struct object_id *oid, void *cb_data_unused)
 +{
 +      struct object *obj;
 +      int kind;
 +
-       int kind = oid_object_info(oid, NULL);
++      kind = oid_object_info(the_repository, oid, NULL);
 +      if (kind == OBJ_COMMIT)
 +              return 1;
 +      if (kind != OBJ_TAG)
 +              return 0;
 +
 +      /* We need to do this the hard way... */
 +      obj = deref_tag(parse_object(oid), NULL, 0);
 +      if (obj && obj->type == OBJ_COMMIT)
 +              return 1;
 +      return 0;
 +}
 +
 +static int disambiguate_tree_only(const struct object_id *oid, void *cb_data_unused)
 +{
-       kind = oid_object_info(oid, NULL);
++      int kind = oid_object_info(the_repository, oid, NULL);
 +      return kind == OBJ_TREE;
 +}
 +
 +static int disambiguate_treeish_only(const struct object_id *oid, void *cb_data_unused)
 +{
 +      struct object *obj;
 +      int kind;
 +
-       int kind = oid_object_info(oid, NULL);
++      kind = oid_object_info(the_repository, oid, NULL);
 +      if (kind == OBJ_TREE || kind == OBJ_COMMIT)
 +              return 1;
 +      if (kind != OBJ_TAG)
 +              return 0;
 +
 +      /* We need to do this the hard way... */
 +      obj = deref_tag(parse_object(oid), NULL, 0);
 +      if (obj && (obj->type == OBJ_TREE || obj->type == OBJ_COMMIT))
 +              return 1;
 +      return 0;
 +}
 +
 +static int disambiguate_blob_only(const struct object_id *oid, void *cb_data_unused)
 +{
-       type = oid_object_info(oid, NULL);
++      int kind = oid_object_info(the_repository, oid, NULL);
 +      return kind == OBJ_BLOB;
 +}
 +
 +static disambiguate_hint_fn default_disambiguate_hint;
 +
 +int set_disambiguate_hint_config(const char *var, const char *value)
 +{
 +      static const struct {
 +              const char *name;
 +              disambiguate_hint_fn fn;
 +      } hints[] = {
 +              { "none", NULL },
 +              { "commit", disambiguate_commit_only },
 +              { "committish", disambiguate_committish_only },
 +              { "tree", disambiguate_tree_only },
 +              { "treeish", disambiguate_treeish_only },
 +              { "blob", disambiguate_blob_only }
 +      };
 +      int i;
 +
 +      if (!value)
 +              return config_error_nonbool(var);
 +
 +      for (i = 0; i < ARRAY_SIZE(hints); i++) {
 +              if (!strcasecmp(value, hints[i].name)) {
 +                      default_disambiguate_hint = hints[i].fn;
 +                      return 0;
 +              }
 +      }
 +
 +      return error("unknown hint type for '%s': %s", var, value);
 +}
 +
 +static int init_object_disambiguation(const char *name, int len,
 +                                    struct disambiguate_state *ds)
 +{
 +      int i;
 +
 +      if (len < MINIMUM_ABBREV || len > GIT_SHA1_HEXSZ)
 +              return -1;
 +
 +      memset(ds, 0, sizeof(*ds));
 +
 +      for (i = 0; i < len ;i++) {
 +              unsigned char c = name[i];
 +              unsigned char val;
 +              if (c >= '0' && c <= '9')
 +                      val = c - '0';
 +              else if (c >= 'a' && c <= 'f')
 +                      val = c - 'a' + 10;
 +              else if (c >= 'A' && c <='F') {
 +                      val = c - 'A' + 10;
 +                      c -= 'A' - 'a';
 +              }
 +              else
 +                      return -1;
 +              ds->hex_pfx[i] = c;
 +              if (!(i & 1))
 +                      val <<= 4;
 +              ds->bin_pfx.hash[i >> 1] |= val;
 +      }
 +
 +      ds->len = len;
 +      ds->hex_pfx[len] = '\0';
 +      prepare_alt_odb(the_repository);
 +      return 0;
 +}
 +
 +static int show_ambiguous_object(const struct object_id *oid, void *data)
 +{
 +      const struct disambiguate_state *ds = data;
 +      struct strbuf desc = STRBUF_INIT;
 +      int type;
 +
 +
 +      if (ds->fn && !ds->fn(oid, ds->cb_data))
 +              return 0;
 +
++      type = oid_object_info(the_repository, oid, NULL);
 +      if (type == OBJ_COMMIT) {
 +              struct commit *commit = lookup_commit(oid);
 +              if (commit) {
 +                      struct pretty_print_context pp = {0};
 +                      pp.date_mode.type = DATE_SHORT;
 +                      format_commit_message(commit, " %ad - %s", &desc, &pp);
 +              }
 +      } else if (type == OBJ_TAG) {
 +              struct tag *tag = lookup_tag(oid);
 +              if (!parse_tag(tag) && tag->tag)
 +                      strbuf_addf(&desc, " %s", tag->tag);
 +      }
 +
 +      advise("  %s %s%s",
 +             find_unique_abbrev(oid, DEFAULT_ABBREV),
 +             type_name(type) ? type_name(type) : "unknown type",
 +             desc.buf);
 +
 +      strbuf_release(&desc);
 +      return 0;
 +}
 +
 +static int get_short_oid(const char *name, int len, struct object_id *oid,
 +                        unsigned flags)
 +{
 +      int status;
 +      struct disambiguate_state ds;
 +      int quietly = !!(flags & GET_OID_QUIETLY);
 +
 +      if (init_object_disambiguation(name, len, &ds) < 0)
 +              return -1;
 +
 +      if (HAS_MULTI_BITS(flags & GET_OID_DISAMBIGUATORS))
 +              die("BUG: multiple get_short_oid disambiguator flags");
 +
 +      if (flags & GET_OID_COMMIT)
 +              ds.fn = disambiguate_commit_only;
 +      else if (flags & GET_OID_COMMITTISH)
 +              ds.fn = disambiguate_committish_only;
 +      else if (flags & GET_OID_TREE)
 +              ds.fn = disambiguate_tree_only;
 +      else if (flags & GET_OID_TREEISH)
 +              ds.fn = disambiguate_treeish_only;
 +      else if (flags & GET_OID_BLOB)
 +              ds.fn = disambiguate_blob_only;
 +      else
 +              ds.fn = default_disambiguate_hint;
 +
 +      find_short_object_filename(&ds);
 +      find_short_packed_object(&ds);
 +      status = finish_object_disambiguation(&ds, oid);
 +
 +      if (!quietly && (status == SHORT_NAME_AMBIGUOUS)) {
 +              error(_("short SHA1 %s is ambiguous"), ds.hex_pfx);
 +
 +              /*
 +               * We may still have ambiguity if we simply saw a series of
 +               * candidates that did not satisfy our hint function. In
 +               * that case, we still want to show them, so disable the hint
 +               * function entirely.
 +               */
 +              if (!ds.ambiguous)
 +                      ds.fn = NULL;
 +
 +              advise(_("The candidates are:"));
 +              for_each_abbrev(ds.hex_pfx, show_ambiguous_object, &ds);
 +      }
 +
 +      return status;
 +}
 +
 +static int collect_ambiguous(const struct object_id *oid, void *data)
 +{
 +      oid_array_append(data, oid);
 +      return 0;
 +}
 +
 +int for_each_abbrev(const char *prefix, each_abbrev_fn fn, void *cb_data)
 +{
 +      struct oid_array collect = OID_ARRAY_INIT;
 +      struct disambiguate_state ds;
 +      int ret;
 +
 +      if (init_object_disambiguation(prefix, strlen(prefix), &ds) < 0)
 +              return -1;
 +
 +      ds.always_call_fn = 1;
 +      ds.fn = collect_ambiguous;
 +      ds.cb_data = &collect;
 +      find_short_object_filename(&ds);
 +      find_short_packed_object(&ds);
 +
 +      ret = oid_array_for_each_unique(&collect, fn, cb_data);
 +      oid_array_clear(&collect);
 +      return ret;
 +}
 +
 +/*
 + * Return the slot of the most-significant bit set in "val". There are various
 + * ways to do this quickly with fls() or __builtin_clzl(), but speed is
 + * probably not a big deal here.
 + */
 +static unsigned msb(unsigned long val)
 +{
 +      unsigned r = 0;
 +      while (val >>= 1)
 +              r++;
 +      return r;
 +}
 +
 +struct min_abbrev_data {
 +      unsigned int init_len;
 +      unsigned int cur_len;
 +      char *hex;
 +      const struct object_id *oid;
 +};
 +
 +static inline char get_hex_char_from_oid(const struct object_id *oid,
 +                                       unsigned int pos)
 +{
 +      static const char hex[] = "0123456789abcdef";
 +
 +      if ((pos & 1) == 0)
 +              return hex[oid->hash[pos >> 1] >> 4];
 +      else
 +              return hex[oid->hash[pos >> 1] & 0xf];
 +}
 +
 +static int extend_abbrev_len(const struct object_id *oid, void *cb_data)
 +{
 +      struct min_abbrev_data *mad = cb_data;
 +
 +      unsigned int i = mad->init_len;
 +      while (mad->hex[i] && mad->hex[i] == get_hex_char_from_oid(oid, i))
 +              i++;
 +
 +      if (i < GIT_MAX_RAWSZ && i >= mad->cur_len)
 +              mad->cur_len = i + 1;
 +
 +      return 0;
 +}
 +
 +static void find_abbrev_len_for_pack(struct packed_git *p,
 +                                   struct min_abbrev_data *mad)
 +{
 +      int match = 0;
 +      uint32_t num, first = 0;
 +      struct object_id oid;
 +      const struct object_id *mad_oid;
 +
 +      if (open_pack_index(p) || !p->num_objects)
 +              return;
 +
 +      num = p->num_objects;
 +      mad_oid = mad->oid;
 +      match = bsearch_pack(mad_oid, p, &first);
 +
 +      /*
 +       * first is now the position in the packfile where we would insert
 +       * mad->hash if it does not exist (or the position of mad->hash if
 +       * it does exist). Hence, we consider a maximum of two objects
 +       * nearby for the abbreviation length.
 +       */
 +      mad->init_len = 0;
 +      if (!match) {
 +              if (nth_packed_object_oid(&oid, p, first))
 +                      extend_abbrev_len(&oid, mad);
 +      } else if (first < num - 1) {
 +              if (nth_packed_object_oid(&oid, p, first + 1))
 +                      extend_abbrev_len(&oid, mad);
 +      }
 +      if (first > 0) {
 +              if (nth_packed_object_oid(&oid, p, first - 1))
 +                      extend_abbrev_len(&oid, mad);
 +      }
 +      mad->init_len = mad->cur_len;
 +}
 +
 +static void find_abbrev_len_packed(struct min_abbrev_data *mad)
 +{
 +      struct packed_git *p;
 +
 +      for (p = get_packed_git(the_repository); p; p = p->next)
 +              find_abbrev_len_for_pack(p, mad);
 +}
 +
 +int find_unique_abbrev_r(char *hex, const struct object_id *oid, int len)
 +{
 +      struct disambiguate_state ds;
 +      struct min_abbrev_data mad;
 +      struct object_id oid_ret;
 +      if (len < 0) {
 +              unsigned long count = approximate_object_count();
 +              /*
 +               * Add one because the MSB only tells us the highest bit set,
 +               * not including the value of all the _other_ bits (so "15"
 +               * is only one off of 2^4, but the MSB is the 3rd bit.
 +               */
 +              len = msb(count) + 1;
 +              /*
 +               * We now know we have on the order of 2^len objects, which
 +               * expects a collision at 2^(len/2). But we also care about hex
 +               * chars, not bits, and there are 4 bits per hex. So all
 +               * together we need to divide by 2 and round up.
 +               */
 +              len = DIV_ROUND_UP(len, 2);
 +              /*
 +               * For very small repos, we stick with our regular fallback.
 +               */
 +              if (len < FALLBACK_DEFAULT_ABBREV)
 +                      len = FALLBACK_DEFAULT_ABBREV;
 +      }
 +
 +      oid_to_hex_r(hex, oid);
 +      if (len == GIT_SHA1_HEXSZ || !len)
 +              return GIT_SHA1_HEXSZ;
 +
 +      mad.init_len = len;
 +      mad.cur_len = len;
 +      mad.hex = hex;
 +      mad.oid = oid;
 +
 +      find_abbrev_len_packed(&mad);
 +
 +      if (init_object_disambiguation(hex, mad.cur_len, &ds) < 0)
 +              return -1;
 +
 +      ds.fn = extend_abbrev_len;
 +      ds.always_call_fn = 1;
 +      ds.cb_data = (void *)&mad;
 +
 +      find_short_object_filename(&ds);
 +      (void)finish_object_disambiguation(&ds, &oid_ret);
 +
 +      hex[mad.cur_len] = 0;
 +      return mad.cur_len;
 +}
 +
 +const char *find_unique_abbrev(const struct object_id *oid, int len)
 +{
 +      static int bufno;
 +      static char hexbuffer[4][GIT_MAX_HEXSZ + 1];
 +      char *hex = hexbuffer[bufno];
 +      bufno = (bufno + 1) % ARRAY_SIZE(hexbuffer);
 +      find_unique_abbrev_r(hex, oid, len);
 +      return hex;
 +}
 +
 +static int ambiguous_path(const char *path, int len)
 +{
 +      int slash = 1;
 +      int cnt;
 +
 +      for (cnt = 0; cnt < len; cnt++) {
 +              switch (*path++) {
 +              case '\0':
 +                      break;
 +              case '/':
 +                      if (slash)
 +                              break;
 +                      slash = 1;
 +                      continue;
 +              case '.':
 +                      continue;
 +              default:
 +                      slash = 0;
 +                      continue;
 +              }
 +              break;
 +      }
 +      return slash;
 +}
 +
 +static inline int at_mark(const char *string, int len,
 +                        const char **suffix, int nr)
 +{
 +      int i;
 +
 +      for (i = 0; i < nr; i++) {
 +              int suffix_len = strlen(suffix[i]);
 +              if (suffix_len <= len
 +                  && !strncasecmp(string, suffix[i], suffix_len))
 +                      return suffix_len;
 +      }
 +      return 0;
 +}
 +
 +static inline int upstream_mark(const char *string, int len)
 +{
 +      const char *suffix[] = { "@{upstream}", "@{u}" };
 +      return at_mark(string, len, suffix, ARRAY_SIZE(suffix));
 +}
 +
 +static inline int push_mark(const char *string, int len)
 +{
 +      const char *suffix[] = { "@{push}" };
 +      return at_mark(string, len, suffix, ARRAY_SIZE(suffix));
 +}
 +
 +static int get_oid_1(const char *name, int len, struct object_id *oid, unsigned lookup_flags);
 +static int interpret_nth_prior_checkout(const char *name, int namelen, struct strbuf *buf);
 +
 +static int get_oid_basic(const char *str, int len, struct object_id *oid,
 +                        unsigned int flags)
 +{
 +      static const char *warn_msg = "refname '%.*s' is ambiguous.";
 +      static const char *object_name_msg = N_(
 +      "Git normally never creates a ref that ends with 40 hex characters\n"
 +      "because it will be ignored when you just specify 40-hex. These refs\n"
 +      "may be created by mistake. For example,\n"
 +      "\n"
 +      "  git checkout -b $br $(git rev-parse ...)\n"
 +      "\n"
 +      "where \"$br\" is somehow empty and a 40-hex ref is created. Please\n"
 +      "examine these refs and maybe delete them. Turn this message off by\n"
 +      "running \"git config advice.objectNameWarning false\"");
 +      struct object_id tmp_oid;
 +      char *real_ref = NULL;
 +      int refs_found = 0;
 +      int at, reflog_len, nth_prior = 0;
 +
 +      if (len == GIT_SHA1_HEXSZ && !get_oid_hex(str, oid)) {
 +              if (warn_ambiguous_refs && warn_on_object_refname_ambiguity) {
 +                      refs_found = dwim_ref(str, len, &tmp_oid, &real_ref);
 +                      if (refs_found > 0) {
 +                              warning(warn_msg, len, str);
 +                              if (advice_object_name_warning)
 +                                      fprintf(stderr, "%s\n", _(object_name_msg));
 +                      }
 +                      free(real_ref);
 +              }
 +              return 0;
 +      }
 +
 +      /* basic@{time or number or -number} format to query ref-log */
 +      reflog_len = at = 0;
 +      if (len && str[len-1] == '}') {
 +              for (at = len-4; at >= 0; at--) {
 +                      if (str[at] == '@' && str[at+1] == '{') {
 +                              if (str[at+2] == '-') {
 +                                      if (at != 0)
 +                                              /* @{-N} not at start */
 +                                              return -1;
 +                                      nth_prior = 1;
 +                                      continue;
 +                              }
 +                              if (!upstream_mark(str + at, len - at) &&
 +                                  !push_mark(str + at, len - at)) {
 +                                      reflog_len = (len-1) - (at+2);
 +                                      len = at;
 +                              }
 +                              break;
 +                      }
 +              }
 +      }
 +
 +      /* Accept only unambiguous ref paths. */
 +      if (len && ambiguous_path(str, len))
 +              return -1;
 +
 +      if (nth_prior) {
 +              struct strbuf buf = STRBUF_INIT;
 +              int detached;
 +
 +              if (interpret_nth_prior_checkout(str, len, &buf) > 0) {
 +                      detached = (buf.len == GIT_SHA1_HEXSZ && !get_oid_hex(buf.buf, oid));
 +                      strbuf_release(&buf);
 +                      if (detached)
 +                              return 0;
 +              }
 +      }
 +
 +      if (!len && reflog_len)
 +              /* allow "@{...}" to mean the current branch reflog */
 +              refs_found = dwim_ref("HEAD", 4, oid, &real_ref);
 +      else if (reflog_len)
 +              refs_found = dwim_log(str, len, oid, &real_ref);
 +      else
 +              refs_found = dwim_ref(str, len, oid, &real_ref);
 +
 +      if (!refs_found)
 +              return -1;
 +
 +      if (warn_ambiguous_refs && !(flags & GET_OID_QUIETLY) &&
 +          (refs_found > 1 ||
 +           !get_short_oid(str, len, &tmp_oid, GET_OID_QUIETLY)))
 +              warning(warn_msg, len, str);
 +
 +      if (reflog_len) {
 +              int nth, i;
 +              timestamp_t at_time;
 +              timestamp_t co_time;
 +              int co_tz, co_cnt;
 +
 +              /* Is it asking for N-th entry, or approxidate? */
 +              for (i = nth = 0; 0 <= nth && i < reflog_len; i++) {
 +                      char ch = str[at+2+i];
 +                      if ('0' <= ch && ch <= '9')
 +                              nth = nth * 10 + ch - '0';
 +                      else
 +                              nth = -1;
 +              }
 +              if (100000000 <= nth) {
 +                      at_time = nth;
 +                      nth = -1;
 +              } else if (0 <= nth)
 +                      at_time = 0;
 +              else {
 +                      int errors = 0;
 +                      char *tmp = xstrndup(str + at + 2, reflog_len);
 +                      at_time = approxidate_careful(tmp, &errors);
 +                      free(tmp);
 +                      if (errors) {
 +                              free(real_ref);
 +                              return -1;
 +                      }
 +              }
 +              if (read_ref_at(real_ref, flags, at_time, nth, oid, NULL,
 +                              &co_time, &co_tz, &co_cnt)) {
 +                      if (!len) {
 +                              if (starts_with(real_ref, "refs/heads/")) {
 +                                      str = real_ref + 11;
 +                                      len = strlen(real_ref + 11);
 +                              } else {
 +                                      /* detached HEAD */
 +                                      str = "HEAD";
 +                                      len = 4;
 +                              }
 +                      }
 +                      if (at_time) {
 +                              if (!(flags & GET_OID_QUIETLY)) {
 +                                      warning("Log for '%.*s' only goes "
 +                                              "back to %s.", len, str,
 +                                              show_date(co_time, co_tz, DATE_MODE(RFC2822)));
 +                              }
 +                      } else {
 +                              if (flags & GET_OID_QUIETLY) {
 +                                      exit(128);
 +                              }
 +                              die("Log for '%.*s' only has %d entries.",
 +                                  len, str, co_cnt);
 +                      }
 +              }
 +      }
 +
 +      free(real_ref);
 +      return 0;
 +}
 +
 +static int get_parent(const char *name, int len,
 +                    struct object_id *result, int idx)
 +{
 +      struct object_id oid;
 +      int ret = get_oid_1(name, len, &oid, GET_OID_COMMITTISH);
 +      struct commit *commit;
 +      struct commit_list *p;
 +
 +      if (ret)
 +              return ret;
 +      commit = lookup_commit_reference(&oid);
 +      if (parse_commit(commit))
 +              return -1;
 +      if (!idx) {
 +              oidcpy(result, &commit->object.oid);
 +              return 0;
 +      }
 +      p = commit->parents;
 +      while (p) {
 +              if (!--idx) {
 +                      oidcpy(result, &p->item->object.oid);
 +                      return 0;
 +              }
 +              p = p->next;
 +      }
 +      return -1;
 +}
 +
 +static int get_nth_ancestor(const char *name, int len,
 +                          struct object_id *result, int generation)
 +{
 +      struct object_id oid;
 +      struct commit *commit;
 +      int ret;
 +
 +      ret = get_oid_1(name, len, &oid, GET_OID_COMMITTISH);
 +      if (ret)
 +              return ret;
 +      commit = lookup_commit_reference(&oid);
 +      if (!commit)
 +              return -1;
 +
 +      while (generation--) {
 +              if (parse_commit(commit) || !commit->parents)
 +                      return -1;
 +              commit = commit->parents->item;
 +      }
 +      oidcpy(result, &commit->object.oid);
 +      return 0;
 +}
 +
 +struct object *peel_to_type(const char *name, int namelen,
 +                          struct object *o, enum object_type expected_type)
 +{
 +      if (name && !namelen)
 +              namelen = strlen(name);
 +      while (1) {
 +              if (!o || (!o->parsed && !parse_object(&o->oid)))
 +                      return NULL;
 +              if (expected_type == OBJ_ANY || o->type == expected_type)
 +                      return o;
 +              if (o->type == OBJ_TAG)
 +                      o = ((struct tag*) o)->tagged;
 +              else if (o->type == OBJ_COMMIT)
 +                      o = &(get_commit_tree(((struct commit *)o))->object);
 +              else {
 +                      if (name)
 +                              error("%.*s: expected %s type, but the object "
 +                                    "dereferences to %s type",
 +                                    namelen, name, type_name(expected_type),
 +                                    type_name(o->type));
 +                      return NULL;
 +              }
 +      }
 +}
 +
 +static int peel_onion(const char *name, int len, struct object_id *oid,
 +                    unsigned lookup_flags)
 +{
 +      struct object_id outer;
 +      const char *sp;
 +      unsigned int expected_type = 0;
 +      struct object *o;
 +
 +      /*
 +       * "ref^{type}" dereferences ref repeatedly until you cannot
 +       * dereference anymore, or you get an object of given type,
 +       * whichever comes first.  "ref^{}" means just dereference
 +       * tags until you get a non-tag.  "ref^0" is a shorthand for
 +       * "ref^{commit}".  "commit^{tree}" could be used to find the
 +       * top-level tree of the given commit.
 +       */
 +      if (len < 4 || name[len-1] != '}')
 +              return -1;
 +
 +      for (sp = name + len - 1; name <= sp; sp--) {
 +              int ch = *sp;
 +              if (ch == '{' && name < sp && sp[-1] == '^')
 +                      break;
 +      }
 +      if (sp <= name)
 +              return -1;
 +
 +      sp++; /* beginning of type name, or closing brace for empty */
 +      if (starts_with(sp, "commit}"))
 +              expected_type = OBJ_COMMIT;
 +      else if (starts_with(sp, "tag}"))
 +              expected_type = OBJ_TAG;
 +      else if (starts_with(sp, "tree}"))
 +              expected_type = OBJ_TREE;
 +      else if (starts_with(sp, "blob}"))
 +              expected_type = OBJ_BLOB;
 +      else if (starts_with(sp, "object}"))
 +              expected_type = OBJ_ANY;
 +      else if (sp[0] == '}')
 +              expected_type = OBJ_NONE;
 +      else if (sp[0] == '/')
 +              expected_type = OBJ_COMMIT;
 +      else
 +              return -1;
 +
 +      lookup_flags &= ~GET_OID_DISAMBIGUATORS;
 +      if (expected_type == OBJ_COMMIT)
 +              lookup_flags |= GET_OID_COMMITTISH;
 +      else if (expected_type == OBJ_TREE)
 +              lookup_flags |= GET_OID_TREEISH;
 +
 +      if (get_oid_1(name, sp - name - 2, &outer, lookup_flags))
 +              return -1;
 +
 +      o = parse_object(&outer);
 +      if (!o)
 +              return -1;
 +      if (!expected_type) {
 +              o = deref_tag(o, name, sp - name - 2);
 +              if (!o || (!o->parsed && !parse_object(&o->oid)))
 +                      return -1;
 +              oidcpy(oid, &o->oid);
 +              return 0;
 +      }
 +
 +      /*
 +       * At this point, the syntax look correct, so
 +       * if we do not get the needed object, we should
 +       * barf.
 +       */
 +      o = peel_to_type(name, len, o, expected_type);
 +      if (!o)
 +              return -1;
 +
 +      oidcpy(oid, &o->oid);
 +      if (sp[0] == '/') {
 +              /* "$commit^{/foo}" */
 +              char *prefix;
 +              int ret;
 +              struct commit_list *list = NULL;
 +
 +              /*
 +               * $commit^{/}. Some regex implementation may reject.
 +               * We don't need regex anyway. '' pattern always matches.
 +               */
 +              if (sp[1] == '}')
 +                      return 0;
 +
 +              prefix = xstrndup(sp + 1, name + len - 1 - (sp + 1));
 +              commit_list_insert((struct commit *)o, &list);
 +              ret = get_oid_oneline(prefix, oid, list);
 +              free(prefix);
 +              return ret;
 +      }
 +      return 0;
 +}
 +
 +static int get_describe_name(const char *name, int len, struct object_id *oid)
 +{
 +      const char *cp;
 +      unsigned flags = GET_OID_QUIETLY | GET_OID_COMMIT;
 +
 +      for (cp = name + len - 1; name + 2 <= cp; cp--) {
 +              char ch = *cp;
 +              if (!isxdigit(ch)) {
 +                      /* We must be looking at g in "SOMETHING-g"
 +                       * for it to be describe output.
 +                       */
 +                      if (ch == 'g' && cp[-1] == '-') {
 +                              cp++;
 +                              len -= cp - name;
 +                              return get_short_oid(cp, len, oid, flags);
 +                      }
 +              }
 +      }
 +      return -1;
 +}
 +
 +static int get_oid_1(const char *name, int len, struct object_id *oid, unsigned lookup_flags)
 +{
 +      int ret, has_suffix;
 +      const char *cp;
 +
 +      /*
 +       * "name~3" is "name^^^", "name~" is "name~1", and "name^" is "name^1".
 +       */
 +      has_suffix = 0;
 +      for (cp = name + len - 1; name <= cp; cp--) {
 +              int ch = *cp;
 +              if ('0' <= ch && ch <= '9')
 +                      continue;
 +              if (ch == '~' || ch == '^')
 +                      has_suffix = ch;
 +              break;
 +      }
 +
 +      if (has_suffix) {
 +              int num = 0;
 +              int len1 = cp - name;
 +              cp++;
 +              while (cp < name + len)
 +                      num = num * 10 + *cp++ - '0';
 +              if (!num && len1 == len - 1)
 +                      num = 1;
 +              if (has_suffix == '^')
 +                      return get_parent(name, len1, oid, num);
 +              /* else if (has_suffix == '~') -- goes without saying */
 +              return get_nth_ancestor(name, len1, oid, num);
 +      }
 +
 +      ret = peel_onion(name, len, oid, lookup_flags);
 +      if (!ret)
 +              return 0;
 +
 +      ret = get_oid_basic(name, len, oid, lookup_flags);
 +      if (!ret)
 +              return 0;
 +
 +      /* It could be describe output that is "SOMETHING-gXXXX" */
 +      ret = get_describe_name(name, len, oid);
 +      if (!ret)
 +              return 0;
 +
 +      return get_short_oid(name, len, oid, lookup_flags);
 +}
 +
 +/*
 + * This interprets names like ':/Initial revision of "git"' by searching
 + * through history and returning the first commit whose message starts
 + * the given regular expression.
 + *
 + * For negative-matching, prefix the pattern-part with '!-', like: ':/!-WIP'.
 + *
 + * For a literal '!' character at the beginning of a pattern, you have to repeat
 + * that, like: ':/!!foo'
 + *
 + * For future extension, all other sequences beginning with ':/!' are reserved.
 + */
 +
 +/* Remember to update object flag allocation in object.h */
 +#define ONELINE_SEEN (1u<<20)
 +
 +static int handle_one_ref(const char *path, const struct object_id *oid,
 +                        int flag, void *cb_data)
 +{
 +      struct commit_list **list = cb_data;
 +      struct object *object = parse_object(oid);
 +      if (!object)
 +              return 0;
 +      if (object->type == OBJ_TAG) {
 +              object = deref_tag(object, path, strlen(path));
 +              if (!object)
 +                      return 0;
 +      }
 +      if (object->type != OBJ_COMMIT)
 +              return 0;
 +      commit_list_insert((struct commit *)object, list);
 +      return 0;
 +}
 +
 +static int get_oid_oneline(const char *prefix, struct object_id *oid,
 +                          struct commit_list *list)
 +{
 +      struct commit_list *backup = NULL, *l;
 +      int found = 0;
 +      int negative = 0;
 +      regex_t regex;
 +
 +      if (prefix[0] == '!') {
 +              prefix++;
 +
 +              if (prefix[0] == '-') {
 +                      prefix++;
 +                      negative = 1;
 +              } else if (prefix[0] != '!') {
 +                      return -1;
 +              }
 +      }
 +
 +      if (regcomp(&regex, prefix, REG_EXTENDED))
 +              return -1;
 +
 +      for (l = list; l; l = l->next) {
 +              l->item->object.flags |= ONELINE_SEEN;
 +              commit_list_insert(l->item, &backup);
 +      }
 +      while (list) {
 +              const char *p, *buf;
 +              struct commit *commit;
 +              int matches;
 +
 +              commit = pop_most_recent_commit(&list, ONELINE_SEEN);
 +              if (!parse_object(&commit->object.oid))
 +                      continue;
 +              buf = get_commit_buffer(commit, NULL);
 +              p = strstr(buf, "\n\n");
 +              matches = negative ^ (p && !regexec(&regex, p + 2, 0, NULL, 0));
 +              unuse_commit_buffer(commit, buf);
 +
 +              if (matches) {
 +                      oidcpy(oid, &commit->object.oid);
 +                      found = 1;
 +                      break;
 +              }
 +      }
 +      regfree(&regex);
 +      free_commit_list(list);
 +      for (l = backup; l; l = l->next)
 +              clear_commit_marks(l->item, ONELINE_SEEN);
 +      free_commit_list(backup);
 +      return found ? 0 : -1;
 +}
 +
 +struct grab_nth_branch_switch_cbdata {
 +      int remaining;
 +      struct strbuf buf;
 +};
 +
 +static int grab_nth_branch_switch(struct object_id *ooid, struct object_id *noid,
 +                                const char *email, timestamp_t timestamp, int tz,
 +                                const char *message, void *cb_data)
 +{
 +      struct grab_nth_branch_switch_cbdata *cb = cb_data;
 +      const char *match = NULL, *target = NULL;
 +      size_t len;
 +
 +      if (skip_prefix(message, "checkout: moving from ", &match))
 +              target = strstr(match, " to ");
 +
 +      if (!match || !target)
 +              return 0;
 +      if (--(cb->remaining) == 0) {
 +              len = target - match;
 +              strbuf_reset(&cb->buf);
 +              strbuf_add(&cb->buf, match, len);
 +              return 1; /* we are done */
 +      }
 +      return 0;
 +}
 +
 +/*
 + * Parse @{-N} syntax, return the number of characters parsed
 + * if successful; otherwise signal an error with negative value.
 + */
 +static int interpret_nth_prior_checkout(const char *name, int namelen,
 +                                      struct strbuf *buf)
 +{
 +      long nth;
 +      int retval;
 +      struct grab_nth_branch_switch_cbdata cb;
 +      const char *brace;
 +      char *num_end;
 +
 +      if (namelen < 4)
 +              return -1;
 +      if (name[0] != '@' || name[1] != '{' || name[2] != '-')
 +              return -1;
 +      brace = memchr(name, '}', namelen);
 +      if (!brace)
 +              return -1;
 +      nth = strtol(name + 3, &num_end, 10);
 +      if (num_end != brace)
 +              return -1;
 +      if (nth <= 0)
 +              return -1;
 +      cb.remaining = nth;
 +      strbuf_init(&cb.buf, 20);
 +
 +      retval = 0;
 +      if (0 < for_each_reflog_ent_reverse("HEAD", grab_nth_branch_switch, &cb)) {
 +              strbuf_reset(buf);
 +              strbuf_addbuf(buf, &cb.buf);
 +              retval = brace - name + 1;
 +      }
 +
 +      strbuf_release(&cb.buf);
 +      return retval;
 +}
 +
 +int get_oid_mb(const char *name, struct object_id *oid)
 +{
 +      struct commit *one, *two;
 +      struct commit_list *mbs;
 +      struct object_id oid_tmp;
 +      const char *dots;
 +      int st;
 +
 +      dots = strstr(name, "...");
 +      if (!dots)
 +              return get_oid(name, oid);
 +      if (dots == name)
 +              st = get_oid("HEAD", &oid_tmp);
 +      else {
 +              struct strbuf sb;
 +              strbuf_init(&sb, dots - name);
 +              strbuf_add(&sb, name, dots - name);
 +              st = get_oid_committish(sb.buf, &oid_tmp);
 +              strbuf_release(&sb);
 +      }
 +      if (st)
 +              return st;
 +      one = lookup_commit_reference_gently(&oid_tmp, 0);
 +      if (!one)
 +              return -1;
 +
 +      if (get_oid_committish(dots[3] ? (dots + 3) : "HEAD", &oid_tmp))
 +              return -1;
 +      two = lookup_commit_reference_gently(&oid_tmp, 0);
 +      if (!two)
 +              return -1;
 +      mbs = get_merge_bases(one, two);
 +      if (!mbs || mbs->next)
 +              st = -1;
 +      else {
 +              st = 0;
 +              oidcpy(oid, &mbs->item->object.oid);
 +      }
 +      free_commit_list(mbs);
 +      return st;
 +}
 +
 +/* parse @something syntax, when 'something' is not {.*} */
 +static int interpret_empty_at(const char *name, int namelen, int len, struct strbuf *buf)
 +{
 +      const char *next;
 +
 +      if (len || name[1] == '{')
 +              return -1;
 +
 +      /* make sure it's a single @, or @@{.*}, not @foo */
 +      next = memchr(name + len + 1, '@', namelen - len - 1);
 +      if (next && next[1] != '{')
 +              return -1;
 +      if (!next)
 +              next = name + namelen;
 +      if (next != name + 1)
 +              return -1;
 +
 +      strbuf_reset(buf);
 +      strbuf_add(buf, "HEAD", 4);
 +      return 1;
 +}
 +
 +static int reinterpret(const char *name, int namelen, int len,
 +                     struct strbuf *buf, unsigned allowed)
 +{
 +      /* we have extra data, which might need further processing */
 +      struct strbuf tmp = STRBUF_INIT;
 +      int used = buf->len;
 +      int ret;
 +
 +      strbuf_add(buf, name + len, namelen - len);
 +      ret = interpret_branch_name(buf->buf, buf->len, &tmp, allowed);
 +      /* that data was not interpreted, remove our cruft */
 +      if (ret < 0) {
 +              strbuf_setlen(buf, used);
 +              return len;
 +      }
 +      strbuf_reset(buf);
 +      strbuf_addbuf(buf, &tmp);
 +      strbuf_release(&tmp);
 +      /* tweak for size of {-N} versus expanded ref name */
 +      return ret - used + len;
 +}
 +
 +static void set_shortened_ref(struct strbuf *buf, const char *ref)
 +{
 +      char *s = shorten_unambiguous_ref(ref, 0);
 +      strbuf_reset(buf);
 +      strbuf_addstr(buf, s);
 +      free(s);
 +}
 +
 +static int branch_interpret_allowed(const char *refname, unsigned allowed)
 +{
 +      if (!allowed)
 +              return 1;
 +
 +      if ((allowed & INTERPRET_BRANCH_LOCAL) &&
 +          starts_with(refname, "refs/heads/"))
 +              return 1;
 +      if ((allowed & INTERPRET_BRANCH_REMOTE) &&
 +          starts_with(refname, "refs/remotes/"))
 +              return 1;
 +
 +      return 0;
 +}
 +
 +static int interpret_branch_mark(const char *name, int namelen,
 +                               int at, struct strbuf *buf,
 +                               int (*get_mark)(const char *, int),
 +                               const char *(*get_data)(struct branch *,
 +                                                       struct strbuf *),
 +                               unsigned allowed)
 +{
 +      int len;
 +      struct branch *branch;
 +      struct strbuf err = STRBUF_INIT;
 +      const char *value;
 +
 +      len = get_mark(name + at, namelen - at);
 +      if (!len)
 +              return -1;
 +
 +      if (memchr(name, ':', at))
 +              return -1;
 +
 +      if (at) {
 +              char *name_str = xmemdupz(name, at);
 +              branch = branch_get(name_str);
 +              free(name_str);
 +      } else
 +              branch = branch_get(NULL);
 +
 +      value = get_data(branch, &err);
 +      if (!value)
 +              die("%s", err.buf);
 +
 +      if (!branch_interpret_allowed(value, allowed))
 +              return -1;
 +
 +      set_shortened_ref(buf, value);
 +      return len + at;
 +}
 +
 +int interpret_branch_name(const char *name, int namelen, struct strbuf *buf,
 +                        unsigned allowed)
 +{
 +      char *at;
 +      const char *start;
 +      int len;
 +
 +      if (!namelen)
 +              namelen = strlen(name);
 +
 +      if (!allowed || (allowed & INTERPRET_BRANCH_LOCAL)) {
 +              len = interpret_nth_prior_checkout(name, namelen, buf);
 +              if (!len) {
 +                      return len; /* syntax Ok, not enough switches */
 +              } else if (len > 0) {
 +                      if (len == namelen)
 +                              return len; /* consumed all */
 +                      else
 +                              return reinterpret(name, namelen, len, buf, allowed);
 +              }
 +      }
 +
 +      for (start = name;
 +           (at = memchr(start, '@', namelen - (start - name)));
 +           start = at + 1) {
 +
 +              if (!allowed || (allowed & INTERPRET_BRANCH_HEAD)) {
 +                      len = interpret_empty_at(name, namelen, at - name, buf);
 +                      if (len > 0)
 +                              return reinterpret(name, namelen, len, buf,
 +                                                 allowed);
 +              }
 +
 +              len = interpret_branch_mark(name, namelen, at - name, buf,
 +                                          upstream_mark, branch_get_upstream,
 +                                          allowed);
 +              if (len > 0)
 +                      return len;
 +
 +              len = interpret_branch_mark(name, namelen, at - name, buf,
 +                                          push_mark, branch_get_push,
 +                                          allowed);
 +              if (len > 0)
 +                      return len;
 +      }
 +
 +      return -1;
 +}
 +
 +void strbuf_branchname(struct strbuf *sb, const char *name, unsigned allowed)
 +{
 +      int len = strlen(name);
 +      int used = interpret_branch_name(name, len, sb, allowed);
 +
 +      if (used < 0)
 +              used = 0;
 +      strbuf_add(sb, name + used, len - used);
 +}
 +
 +int strbuf_check_branch_ref(struct strbuf *sb, const char *name)
 +{
 +      if (startup_info->have_repository)
 +              strbuf_branchname(sb, name, INTERPRET_BRANCH_LOCAL);
 +      else
 +              strbuf_addstr(sb, name);
 +
 +      /*
 +       * This splice must be done even if we end up rejecting the
 +       * name; builtin/branch.c::copy_or_rename_branch() still wants
 +       * to see what the name expanded to so that "branch -m" can be
 +       * used as a tool to correct earlier mistakes.
 +       */
 +      strbuf_splice(sb, 0, 0, "refs/heads/", 11);
 +
 +      if (*name == '-' ||
 +          !strcmp(sb->buf, "refs/heads/HEAD"))
 +              return -1;
 +
 +      return check_refname_format(sb->buf, 0);
 +}
 +
 +/*
 + * This is like "get_oid_basic()", except it allows "object ID expressions",
 + * notably "xyz^" for "parent of xyz"
 + */
 +int get_oid(const char *name, struct object_id *oid)
 +{
 +      struct object_context unused;
 +      return get_oid_with_context(name, 0, oid, &unused);
 +}
 +
 +
 +/*
 + * Many callers know that the user meant to name a commit-ish by
 + * syntactical positions where the object name appears.  Calling this
 + * function allows the machinery to disambiguate shorter-than-unique
 + * abbreviated object names between commit-ish and others.
 + *
 + * Note that this does NOT error out when the named object is not a
 + * commit-ish. It is merely to give a hint to the disambiguation
 + * machinery.
 + */
 +int get_oid_committish(const char *name, struct object_id *oid)
 +{
 +      struct object_context unused;
 +      return get_oid_with_context(name, GET_OID_COMMITTISH,
 +                                  oid, &unused);
 +}
 +
 +int get_oid_treeish(const char *name, struct object_id *oid)
 +{
 +      struct object_context unused;
 +      return get_oid_with_context(name, GET_OID_TREEISH,
 +                                  oid, &unused);
 +}
 +
 +int get_oid_commit(const char *name, struct object_id *oid)
 +{
 +      struct object_context unused;
 +      return get_oid_with_context(name, GET_OID_COMMIT,
 +                                  oid, &unused);
 +}
 +
 +int get_oid_tree(const char *name, struct object_id *oid)
 +{
 +      struct object_context unused;
 +      return get_oid_with_context(name, GET_OID_TREE,
 +                                  oid, &unused);
 +}
 +
 +int get_oid_blob(const char *name, struct object_id *oid)
 +{
 +      struct object_context unused;
 +      return get_oid_with_context(name, GET_OID_BLOB,
 +                                  oid, &unused);
 +}
 +
 +/* Must be called only when object_name:filename doesn't exist. */
 +static void diagnose_invalid_oid_path(const char *prefix,
 +                                    const char *filename,
 +                                    const struct object_id *tree_oid,
 +                                    const char *object_name,
 +                                    int object_name_len)
 +{
 +      struct object_id oid;
 +      unsigned mode;
 +
 +      if (!prefix)
 +              prefix = "";
 +
 +      if (file_exists(filename))
 +              die("Path '%s' exists on disk, but not in '%.*s'.",
 +                  filename, object_name_len, object_name);
 +      if (is_missing_file_error(errno)) {
 +              char *fullname = xstrfmt("%s%s", prefix, filename);
 +
 +              if (!get_tree_entry(tree_oid, fullname, &oid, &mode)) {
 +                      die("Path '%s' exists, but not '%s'.\n"
 +                          "Did you mean '%.*s:%s' aka '%.*s:./%s'?",
 +                          fullname,
 +                          filename,
 +                          object_name_len, object_name,
 +                          fullname,
 +                          object_name_len, object_name,
 +                          filename);
 +              }
 +              die("Path '%s' does not exist in '%.*s'",
 +                  filename, object_name_len, object_name);
 +      }
 +}
 +
 +/* Must be called only when :stage:filename doesn't exist. */
 +static void diagnose_invalid_index_path(int stage,
 +                                      const char *prefix,
 +                                      const char *filename)
 +{
 +      const struct cache_entry *ce;
 +      int pos;
 +      unsigned namelen = strlen(filename);
 +      struct strbuf fullname = STRBUF_INIT;
 +
 +      if (!prefix)
 +              prefix = "";
 +
 +      /* Wrong stage number? */
 +      pos = cache_name_pos(filename, namelen);
 +      if (pos < 0)
 +              pos = -pos - 1;
 +      if (pos < active_nr) {
 +              ce = active_cache[pos];
 +              if (ce_namelen(ce) == namelen &&
 +                  !memcmp(ce->name, filename, namelen))
 +                      die("Path '%s' is in the index, but not at stage %d.\n"
 +                          "Did you mean ':%d:%s'?",
 +                          filename, stage,
 +                          ce_stage(ce), filename);
 +      }
 +
 +      /* Confusion between relative and absolute filenames? */
 +      strbuf_addstr(&fullname, prefix);
 +      strbuf_addstr(&fullname, filename);
 +      pos = cache_name_pos(fullname.buf, fullname.len);
 +      if (pos < 0)
 +              pos = -pos - 1;
 +      if (pos < active_nr) {
 +              ce = active_cache[pos];
 +              if (ce_namelen(ce) == fullname.len &&
 +                  !memcmp(ce->name, fullname.buf, fullname.len))
 +                      die("Path '%s' is in the index, but not '%s'.\n"
 +                          "Did you mean ':%d:%s' aka ':%d:./%s'?",
 +                          fullname.buf, filename,
 +                          ce_stage(ce), fullname.buf,
 +                          ce_stage(ce), filename);
 +      }
 +
 +      if (file_exists(filename))
 +              die("Path '%s' exists on disk, but not in the index.", filename);
 +      if (is_missing_file_error(errno))
 +              die("Path '%s' does not exist (neither on disk nor in the index).",
 +                  filename);
 +
 +      strbuf_release(&fullname);
 +}
 +
 +
 +static char *resolve_relative_path(const char *rel)
 +{
 +      if (!starts_with(rel, "./") && !starts_with(rel, "../"))
 +              return NULL;
 +
 +      if (!is_inside_work_tree())
 +              die("relative path syntax can't be used outside working tree.");
 +
 +      /* die() inside prefix_path() if resolved path is outside worktree */
 +      return prefix_path(startup_info->prefix,
 +                         startup_info->prefix ? strlen(startup_info->prefix) : 0,
 +                         rel);
 +}
 +
 +static int get_oid_with_context_1(const char *name,
 +                                unsigned flags,
 +                                const char *prefix,
 +                                struct object_id *oid,
 +                                struct object_context *oc)
 +{
 +      int ret, bracket_depth;
 +      int namelen = strlen(name);
 +      const char *cp;
 +      int only_to_die = flags & GET_OID_ONLY_TO_DIE;
 +
 +      if (only_to_die)
 +              flags |= GET_OID_QUIETLY;
 +
 +      memset(oc, 0, sizeof(*oc));
 +      oc->mode = S_IFINVALID;
 +      strbuf_init(&oc->symlink_path, 0);
 +      ret = get_oid_1(name, namelen, oid, flags);
 +      if (!ret)
 +              return ret;
 +      /*
 +       * sha1:path --> object name of path in ent sha1
 +       * :path -> object name of absolute path in index
 +       * :./path -> object name of path relative to cwd in index
 +       * :[0-3]:path -> object name of path in index at stage
 +       * :/foo -> recent commit matching foo
 +       */
 +      if (name[0] == ':') {
 +              int stage = 0;
 +              const struct cache_entry *ce;
 +              char *new_path = NULL;
 +              int pos;
 +              if (!only_to_die && namelen > 2 && name[1] == '/') {
 +                      struct commit_list *list = NULL;
 +
 +                      for_each_ref(handle_one_ref, &list);
 +                      commit_list_sort_by_date(&list);
 +                      return get_oid_oneline(name + 2, oid, list);
 +              }
 +              if (namelen < 3 ||
 +                  name[2] != ':' ||
 +                  name[1] < '0' || '3' < name[1])
 +                      cp = name + 1;
 +              else {
 +                      stage = name[1] - '0';
 +                      cp = name + 3;
 +              }
 +              new_path = resolve_relative_path(cp);
 +              if (!new_path) {
 +                      namelen = namelen - (cp - name);
 +              } else {
 +                      cp = new_path;
 +                      namelen = strlen(cp);
 +              }
 +
 +              if (flags & GET_OID_RECORD_PATH)
 +                      oc->path = xstrdup(cp);
 +
 +              if (!active_cache)
 +                      read_cache();
 +              pos = cache_name_pos(cp, namelen);
 +              if (pos < 0)
 +                      pos = -pos - 1;
 +              while (pos < active_nr) {
 +                      ce = active_cache[pos];
 +                      if (ce_namelen(ce) != namelen ||
 +                          memcmp(ce->name, cp, namelen))
 +                              break;
 +                      if (ce_stage(ce) == stage) {
 +                              oidcpy(oid, &ce->oid);
 +                              oc->mode = ce->ce_mode;
 +                              free(new_path);
 +                              return 0;
 +                      }
 +                      pos++;
 +              }
 +              if (only_to_die && name[1] && name[1] != '/')
 +                      diagnose_invalid_index_path(stage, prefix, cp);
 +              free(new_path);
 +              return -1;
 +      }
 +      for (cp = name, bracket_depth = 0; *cp; cp++) {
 +              if (*cp == '{')
 +                      bracket_depth++;
 +              else if (bracket_depth && *cp == '}')
 +                      bracket_depth--;
 +              else if (!bracket_depth && *cp == ':')
 +                      break;
 +      }
 +      if (*cp == ':') {
 +              struct object_id tree_oid;
 +              int len = cp - name;
 +              unsigned sub_flags = flags;
 +
 +              sub_flags &= ~GET_OID_DISAMBIGUATORS;
 +              sub_flags |= GET_OID_TREEISH;
 +
 +              if (!get_oid_1(name, len, &tree_oid, sub_flags)) {
 +                      const char *filename = cp+1;
 +                      char *new_filename = NULL;
 +
 +                      new_filename = resolve_relative_path(filename);
 +                      if (new_filename)
 +                              filename = new_filename;
 +                      if (flags & GET_OID_FOLLOW_SYMLINKS) {
 +                              ret = get_tree_entry_follow_symlinks(tree_oid.hash,
 +                                      filename, oid->hash, &oc->symlink_path,
 +                                      &oc->mode);
 +                      } else {
 +                              ret = get_tree_entry(&tree_oid, filename, oid,
 +                                                   &oc->mode);
 +                              if (ret && only_to_die) {
 +                                      diagnose_invalid_oid_path(prefix,
 +                                                                 filename,
 +                                                                 &tree_oid,
 +                                                                 name, len);
 +                              }
 +                      }
 +                      hashcpy(oc->tree, tree_oid.hash);
 +                      if (flags & GET_OID_RECORD_PATH)
 +                              oc->path = xstrdup(filename);
 +
 +                      free(new_filename);
 +                      return ret;
 +              } else {
 +                      if (only_to_die)
 +                              die("Invalid object name '%.*s'.", len, name);
 +              }
 +      }
 +      return ret;
 +}
 +
 +/*
 + * Call this function when you know "name" given by the end user must
 + * name an object but it doesn't; the function _may_ die with a better
 + * diagnostic message than "no such object 'name'", e.g. "Path 'doc' does not
 + * exist in 'HEAD'" when given "HEAD:doc", or it may return in which case
 + * you have a chance to diagnose the error further.
 + */
 +void maybe_die_on_misspelt_object_name(const char *name, const char *prefix)
 +{
 +      struct object_context oc;
 +      struct object_id oid;
 +      get_oid_with_context_1(name, GET_OID_ONLY_TO_DIE, prefix, &oid, &oc);
 +}
 +
 +int get_oid_with_context(const char *str, unsigned flags, struct object_id *oid, struct object_context *oc)
 +{
 +      if (flags & GET_OID_FOLLOW_SYMLINKS && flags & GET_OID_ONLY_TO_DIE)
 +              die("BUG: incompatible flags for get_sha1_with_context");
 +      return get_oid_with_context_1(str, flags, NULL, oid, oc);
 +}
diff --combined submodule.c
index 74d35b25779f4f771cc9d9ababe3a75cb04ac81c,bb133e9b932dea4d151afc40eaea0bd6bfed56e2..8fd8e5d178d4d6a8d7cf4fb465d96bb323fd02ee
@@@ -96,7 -96,7 +96,7 @@@ int update_path_in_gitmodules(const cha
        if (is_gitmodules_unmerged(&the_index))
                die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
  
 -      submodule = submodule_from_path(&null_oid, oldpath);
 +      submodule = submodule_from_path(the_repository, &null_oid, oldpath);
        if (!submodule || !submodule->name) {
                warning(_("Could not find section in .gitmodules where path=%s"), oldpath);
                return -1;
@@@ -130,7 -130,7 +130,7 @@@ int remove_path_from_gitmodules(const c
        if (is_gitmodules_unmerged(&the_index))
                die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
  
 -      submodule = submodule_from_path(&null_oid, path);
 +      submodule = submodule_from_path(the_repository, &null_oid, path);
        if (!submodule || !submodule->name) {
                warning(_("Could not find section in .gitmodules where path=%s"), path);
                return -1;
@@@ -174,8 -174,7 +174,8 @@@ done
  void set_diffopt_flags_from_submodule_config(struct diff_options *diffopt,
                                             const char *path)
  {
 -      const struct submodule *submodule = submodule_from_path(&null_oid, path);
 +      const struct submodule *submodule = submodule_from_path(the_repository,
 +                                                              &null_oid, path);
        if (submodule) {
                const char *ignore;
                char *key;
@@@ -231,7 -230,7 +231,7 @@@ int is_submodule_active(struct reposito
        const struct string_list *sl;
        const struct submodule *module;
  
 -      module = submodule_from_cache(repo, &null_oid, path);
 +      module = submodule_from_path(repo, &null_oid, path);
  
        /* early return if there isn't a path->module mapping */
        if (!module)
@@@ -675,7 -674,7 +675,7 @@@ const struct submodule *submodule_from_
        if (!should_update_submodules())
                return NULL;
  
 -      return submodule_from_path(&null_oid, ce->name);
 +      return submodule_from_path(the_repository, &null_oid, ce->name);
  }
  
  static struct oid_array *submodule_commits(struct string_list *submodules,
@@@ -732,14 -731,13 +732,14 @@@ static void collect_changed_submodules_
                if (!S_ISGITLINK(p->two->mode))
                        continue;
  
 -              submodule = submodule_from_path(commit_oid, p->two->path);
 +              submodule = submodule_from_path(the_repository,
 +                                              commit_oid, p->two->path);
                if (submodule)
                        name = submodule->name;
                else {
                        name = default_name_or_path(p->two->path);
                        /* make sure name does not collide with existing one */
 -                      submodule = submodule_from_name(commit_oid, name);
 +                      submodule = submodule_from_name(the_repository, commit_oid, name);
                        if (submodule) {
                                warning("Submodule in commit %s at path: "
                                        "'%s' collides with a submodule named "
@@@ -820,7 -818,7 +820,7 @@@ static int check_has_commit(const struc
  {
        struct has_commit_data *cb = data;
  
-       enum object_type type = oid_object_info(oid, NULL);
+       enum object_type type = oid_object_info(the_repository, oid, NULL);
  
        switch (type) {
        case OBJ_COMMIT:
@@@ -947,7 -945,7 +947,7 @@@ int find_unpushed_submodules(struct oid
                const struct submodule *submodule;
                const char *path = NULL;
  
 -              submodule = submodule_from_name(&null_oid, name->string);
 +              submodule = submodule_from_name(the_repository, &null_oid, name->string);
                if (submodule)
                        path = submodule->path;
                else
@@@ -1115,7 -1113,7 +1115,7 @@@ static void calculate_changed_submodule
        const struct string_list_item *name;
  
        /* No need to check if there are no submodules configured */
 -      if (!submodule_from_path(NULL, NULL))
 +      if (!submodule_from_path(the_repository, NULL, NULL))
                return;
  
        argv_array_push(&argv, "--"); /* argv[0] program name */
                const struct submodule *submodule;
                const char *path = NULL;
  
 -              submodule = submodule_from_name(&null_oid, name->string);
 +              submodule = submodule_from_name(the_repository, &null_oid, name->string);
                if (submodule)
                        path = submodule->path;
                else
@@@ -1164,7 -1162,7 +1164,7 @@@ int submodule_touches_in_range(struct o
        int ret;
  
        /* No need to check if there are no submodules configured */
 -      if (!submodule_from_path(NULL, NULL))
 +      if (!submodule_from_path(the_repository, NULL, NULL))
                return 0;
  
        argv_array_push(&args, "--"); /* args[0] program name */
@@@ -1236,7 -1234,7 +1236,7 @@@ static int get_next_submodule(struct ch
                if (!S_ISGITLINK(ce->ce_mode))
                        continue;
  
 -              submodule = submodule_from_cache(spf->r, &null_oid, ce->name);
 +              submodule = submodule_from_path(spf->r, &null_oid, ce->name);
                if (!submodule) {
                        const char *name = default_name_or_path(ce->name);
                        if (name) {
@@@ -1606,7 -1604,7 +1606,7 @@@ int submodule_move_head(const char *pat
        if (old_head && !is_submodule_populated_gently(path, error_code_ptr))
                return 0;
  
 -      sub = submodule_from_path(&null_oid, path);
 +      sub = submodule_from_path(the_repository, &null_oid, path);
  
        if (!sub)
                die("BUG: could not get submodule information for '%s'", path);
                } else {
                        char *gitdir = xstrfmt("%s/modules/%s",
                                    get_git_common_dir(), sub->name);
 -                      connect_work_tree_and_git_dir(path, gitdir);
 +                      connect_work_tree_and_git_dir(path, gitdir, 0);
                        free(gitdir);
  
                        /* make sure the index is clean as well */
                if (old_head && (flags & SUBMODULE_MOVE_HEAD_FORCE)) {
                        char *gitdir = xstrfmt("%s/modules/%s",
                                    get_git_common_dir(), sub->name);
 -                      connect_work_tree_and_git_dir(path, gitdir);
 +                      connect_work_tree_and_git_dir(path, gitdir, 1);
                        free(gitdir);
                }
        }
@@@ -1888,7 -1886,7 +1888,7 @@@ static void relocate_single_git_dir_int
  
        real_old_git_dir = real_pathdup(old_git_dir, 1);
  
 -      sub = submodule_from_path(&null_oid, path);
 +      sub = submodule_from_path(the_repository, &null_oid, path);
        if (!sub)
                die(_("could not lookup name for submodule '%s'"), path);
  
@@@ -1944,11 -1942,11 +1944,11 @@@ void absorb_git_dir_into_superproject(c
                * superproject did not rewrite the git file links yet,
                * fix it now.
                */
 -              sub = submodule_from_path(&null_oid, path);
 +              sub = submodule_from_path(the_repository, &null_oid, path);
                if (!sub)
                        die(_("could not lookup name for submodule '%s'"), path);
                connect_work_tree_and_git_dir(path,
 -                      git_path("modules/%s", sub->name));
 +                      git_path("modules/%s", sub->name), 0);
        } else {
                /* Is it already absorbed into the superprojects git dir? */
                char *real_sub_git_dir = real_pathdup(sub_git_dir, 1);
@@@ -2090,7 -2088,7 +2090,7 @@@ int submodule_to_gitdir(struct strbuf *
                strbuf_addstr(buf, git_dir);
        }
        if (!is_git_directory(buf->buf)) {
 -              sub = submodule_from_path(&null_oid, submodule);
 +              sub = submodule_from_path(the_repository, &null_oid, submodule);
                if (!sub) {
                        ret = -1;
                        goto cleanup;