Merge branch 'jk/nth-packed-object-id'

Code cleanup to use "struct object_id" more by replacing use of
"char *sha1"

* jk/nth-packed-object-id:
  packfile: drop nth_packed_object_sha1()
  packed_object_info(): use object_id internally for delta base
  packed_object_info(): use object_id for returning delta base
  pack-check: push oid lookup into loop
  pack-check: convert "internal error" die to a BUG()
  pack-bitmap: use object_id when loading on-disk bitmaps
  pack-objects: use object_id struct in pack-reuse code
  pack-objects: convert oe_set_delta_ext() to use object_id
  pack-objects: read delta base oid into object_id struct
  nth_packed_object_oid(): use customary integer return

diff --cc builtin/pack-objects.c
Simple merge

diff --cc pack-bitmap.c
index 82bfd6672ad249943725187b9bc141ba629c918d,1a067885a1b02cf9f3e26f53dce76dd400a20016..49a8d10d0cf99716ea37b78bec578ca96c17de20
--- 1/pack-bitmap.c
--- 2/pack-bitmap.c
+++ b/pack-bitmap.c
@@@ -715,179 -682,7 +715,179 @@@ static int in_bitmapped_pack(struct bit
        return 0;
  }
  
 -struct bitmap_index *prepare_bitmap_walk(struct rev_info *revs)
 +static struct bitmap *find_tip_blobs(struct bitmap_index *bitmap_git,
 +                                   struct object_list *tip_objects)
 +{
 +      struct bitmap *result = bitmap_new();
 +      struct object_list *p;
 +
 +      for (p = tip_objects; p; p = p->next) {
 +              int pos;
 +
 +              if (p->item->type != OBJ_BLOB)
 +                      continue;
 +
 +              pos = bitmap_position(bitmap_git, &p->item->oid);
 +              if (pos < 0)
 +                      continue;
 +
 +              bitmap_set(result, pos);
 +      }
 +
 +      return result;
 +}
 +
 +static void filter_bitmap_blob_none(struct bitmap_index *bitmap_git,
 +                                  struct object_list *tip_objects,
 +                                  struct bitmap *to_filter)
 +{
 +      struct eindex *eindex = &bitmap_git->ext_index;
 +      struct bitmap *tips;
 +      struct ewah_iterator it;
 +      eword_t mask;
 +      uint32_t i;
 +
 +      /*
 +       * The non-bitmap version of this filter never removes
 +       * blobs which the other side specifically asked for,
 +       * so we must match that behavior.
 +       */
 +      tips = find_tip_blobs(bitmap_git, tip_objects);
 +
 +      /*
 +       * We can use the blob type-bitmap to work in whole words
 +       * for the objects that are actually in the bitmapped packfile.
 +       */
 +      for (i = 0, init_type_iterator(&it, bitmap_git, OBJ_BLOB);
 +           i < to_filter->word_alloc && ewah_iterator_next(&mask, &it);
 +           i++) {
 +              if (i < tips->word_alloc)
 +                      mask &= ~tips->words[i];
 +              to_filter->words[i] &= ~mask;
 +      }
 +
 +      /*
 +       * Clear any blobs that weren't in the packfile (and so would not have
 +       * been caught by the loop above. We'll have to check them
 +       * individually.
 +       */
 +      for (i = 0; i < eindex->count; i++) {
 +              uint32_t pos = i + bitmap_git->pack->num_objects;
 +              if (eindex->objects[i]->type == OBJ_BLOB &&
 +                  bitmap_get(to_filter, pos) &&
 +                  !bitmap_get(tips, pos))
 +                      bitmap_unset(to_filter, pos);
 +      }
 +
 +      bitmap_free(tips);
 +}
 +
 +static unsigned long get_size_by_pos(struct bitmap_index *bitmap_git,
 +                                   uint32_t pos)
 +{
 +      struct packed_git *pack = bitmap_git->pack;
 +      unsigned long size;
 +      struct object_info oi = OBJECT_INFO_INIT;
 +
 +      oi.sizep = &size;
 +
 +      if (pos < pack->num_objects) {
 +              struct revindex_entry *entry = &pack->revindex[pos];
 +              if (packed_object_info(the_repository, pack,
 +                                     entry->offset, &oi) < 0) {
 +                      struct object_id oid;
-                       nth_packed_object_oid(&oid, pack, entry->nr);
++                      nth_packed_object_id(&oid, pack, entry->nr);
 +                      die(_("unable to get size of %s"), oid_to_hex(&oid));
 +              }
 +      } else {
 +              struct eindex *eindex = &bitmap_git->ext_index;
 +              struct object *obj = eindex->objects[pos - pack->num_objects];
 +              if (oid_object_info_extended(the_repository, &obj->oid, &oi, 0) < 0)
 +                      die(_("unable to get size of %s"), oid_to_hex(&obj->oid));
 +      }
 +
 +      return size;
 +}
 +
 +static void filter_bitmap_blob_limit(struct bitmap_index *bitmap_git,
 +                                   struct object_list *tip_objects,
 +                                   struct bitmap *to_filter,
 +                                   unsigned long limit)
 +{
 +      struct eindex *eindex = &bitmap_git->ext_index;
 +      struct bitmap *tips;
 +      struct ewah_iterator it;
 +      eword_t mask;
 +      uint32_t i;
 +
 +      tips = find_tip_blobs(bitmap_git, tip_objects);
 +
 +      for (i = 0, init_type_iterator(&it, bitmap_git, OBJ_BLOB);
 +           i < to_filter->word_alloc && ewah_iterator_next(&mask, &it);
 +           i++) {
 +              eword_t word = to_filter->words[i] & mask;
 +              unsigned offset;
 +
 +              for (offset = 0; offset < BITS_IN_EWORD; offset++) {
 +                      uint32_t pos;
 +
 +                      if ((word >> offset) == 0)
 +                              break;
 +                      offset += ewah_bit_ctz64(word >> offset);
 +                      pos = i * BITS_IN_EWORD + offset;
 +
 +                      if (!bitmap_get(tips, pos) &&
 +                          get_size_by_pos(bitmap_git, pos) >= limit)
 +                              bitmap_unset(to_filter, pos);
 +              }
 +      }
 +
 +      for (i = 0; i < eindex->count; i++) {
 +              uint32_t pos = i + bitmap_git->pack->num_objects;
 +              if (eindex->objects[i]->type == OBJ_BLOB &&
 +                  bitmap_get(to_filter, pos) &&
 +                  !bitmap_get(tips, pos) &&
 +                  get_size_by_pos(bitmap_git, pos) >= limit)
 +                      bitmap_unset(to_filter, pos);
 +      }
 +
 +      bitmap_free(tips);
 +}
 +
 +static int filter_bitmap(struct bitmap_index *bitmap_git,
 +                       struct object_list *tip_objects,
 +                       struct bitmap *to_filter,
 +                       struct list_objects_filter_options *filter)
 +{
 +      if (!filter || filter->choice == LOFC_DISABLED)
 +              return 0;
 +
 +      if (filter->choice == LOFC_BLOB_NONE) {
 +              if (bitmap_git)
 +                      filter_bitmap_blob_none(bitmap_git, tip_objects,
 +                                              to_filter);
 +              return 0;
 +      }
 +
 +      if (filter->choice == LOFC_BLOB_LIMIT) {
 +              if (bitmap_git)
 +                      filter_bitmap_blob_limit(bitmap_git, tip_objects,
 +                                               to_filter,
 +                                               filter->blob_limit_value);
 +              return 0;
 +      }
 +
 +      /* filter choice not handled */
 +      return -1;
 +}
 +
 +static int can_filter_bitmap(struct list_objects_filter_options *filter)
 +{
 +      return !filter_bitmap(NULL, NULL, NULL, filter);
 +}
 +
 +struct bitmap_index *prepare_bitmap_walk(struct rev_info *revs,
 +                                       struct list_objects_filter_options *filter)
  {
        unsigned int i;