git.oblomov.eu Git - git/blob - list-objects-filter.c

   1 #include "cache.h"
   2 #include "dir.h"
   3 #include "tag.h"
   4 #include "commit.h"
   5 #include "tree.h"
   6 #include "blob.h"
   7 #include "diff.h"
   8 #include "tree-walk.h"
   9 #include "revision.h"
  10 #include "list-objects.h"
  11 #include "list-objects-filter.h"
  12 #include "list-objects-filter-options.h"
  13 #include "oidmap.h"
  14 #include "oidset.h"
  15 #include "object-store.h"
  16
  17 /* Remember to update object flag allocation in object.h */
  18 /*
  19  * FILTER_SHOWN_BUT_REVISIT -- we set this bit on tree objects
  20  * that have been shown, but should be revisited if they appear
  21  * in the traversal (until we mark it SEEN).  This is a way to
  22  * let us silently de-dup calls to show() in the caller.  This
  23  * is subtly different from the "revision.h:SHOWN" and the
  24  * "object-name.c:ONELINE_SEEN" bits.  And also different from
  25  * the non-de-dup usage in pack-bitmap.c
  26  */
  27 #define FILTER_SHOWN_BUT_REVISIT (1<<21)
  28
  29 struct subfilter {
  30         struct filter *filter;
  31         struct oidset seen;
  32         struct oidset omits;
  33         struct object_id skip_tree;
  34         unsigned is_skipping_tree : 1;
  35 };
  36
  37 struct filter {
  38         enum list_objects_filter_result (*filter_object_fn)(
  39                 struct repository *r,
  40                 enum list_objects_filter_situation filter_situation,
  41                 struct object *obj,
  42                 const char *pathname,
  43                 const char *filename,
  44                 struct oidset *omits,
  45                 void *filter_data);
  46
  47         /*
  48          * Optional. If this function is supplied and the filter needs
  49          * to collect omits, then this function is called once before
  50          * free_fn is called.
  51          *
  52          * This is required because the following two conditions hold:
  53          *
  54          *   a. A tree filter can add and remove objects as an object
  55          *      graph is traversed.
  56          *   b. A combine filter's omit set is the union of all its
  57          *      subfilters, which may include tree: filters.
  58          *
  59          * As such, the omits sets must be separate sets, and can only
  60          * be unioned after the traversal is completed.
  61          */
  62         void (*finalize_omits_fn)(struct oidset *omits, void *filter_data);
  63
  64         void (*free_fn)(void *filter_data);
  65
  66         void *filter_data;
  67
  68         /* If non-NULL, the filter collects a list of the omitted OIDs here. */
  69         struct oidset *omits;
  70 };
  71
  72 static enum list_objects_filter_result filter_blobs_none(
  73         struct repository *r,
  74         enum list_objects_filter_situation filter_situation,
  75         struct object *obj,
  76         const char *pathname,
  77         const char *filename,
  78         struct oidset *omits,
  79         void *filter_data_)
  80 {
  81         switch (filter_situation) {
  82         default:
  83                 BUG("unknown filter_situation: %d", filter_situation);
  84
  85         case LOFS_TAG:
  86                 assert(obj->type == OBJ_TAG);
  87                 /* always include all tag objects */
  88                 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
  89
  90         case LOFS_COMMIT:
  91                 assert(obj->type == OBJ_COMMIT);
  92                 /* always include all commit objects */
  93                 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
  94
  95         case LOFS_BEGIN_TREE:
  96                 assert(obj->type == OBJ_TREE);
  97                 /* always include all tree objects */
  98                 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
  99
 100         case LOFS_END_TREE:
 101                 assert(obj->type == OBJ_TREE);
 102                 return LOFR_ZERO;
 103
 104         case LOFS_BLOB:
 105                 assert(obj->type == OBJ_BLOB);
 106                 assert((obj->flags & SEEN) == 0);
 107
 108                 if (omits)
 109                         oidset_insert(omits, &obj->oid);
 110                 return LOFR_MARK_SEEN; /* but not LOFR_DO_SHOW (hard omit) */
 111         }
 112 }
 113
 114 static void filter_blobs_none__init(
 115         struct list_objects_filter_options *filter_options,
 116         struct filter *filter)
 117 {
 118         filter->filter_object_fn = filter_blobs_none;
 119         filter->free_fn = free;
 120 }
 121
 122 /*
 123  * A filter for list-objects to omit ALL trees and blobs from the traversal.
 124  * Can OPTIONALLY collect a list of the omitted OIDs.
 125  */
 126 struct filter_trees_depth_data {
 127         /*
 128          * Maps trees to the minimum depth at which they were seen. It is not
 129          * necessary to re-traverse a tree at deeper or equal depths than it has
 130          * already been traversed.
 131          *
 132          * We can't use LOFR_MARK_SEEN for tree objects since this will prevent
 133          * it from being traversed at shallower depths.
 134          */
 135         struct oidmap seen_at_depth;
 136
 137         unsigned long exclude_depth;
 138         unsigned long current_depth;
 139 };
 140
 141 struct seen_map_entry {
 142         struct oidmap_entry base;
 143         size_t depth;
 144 };
 145
 146 /* Returns 1 if the oid was in the omits set before it was invoked. */
 147 static int filter_trees_update_omits(
 148         struct object *obj,
 149         struct oidset *omits,
 150         int include_it)
 151 {
 152         if (!omits)
 153                 return 0;
 154
 155         if (include_it)
 156                 return oidset_remove(omits, &obj->oid);
 157         else
 158                 return oidset_insert(omits, &obj->oid);
 159 }
 160
 161 static enum list_objects_filter_result filter_trees_depth(
 162         struct repository *r,
 163         enum list_objects_filter_situation filter_situation,
 164         struct object *obj,
 165         const char *pathname,
 166         const char *filename,
 167         struct oidset *omits,
 168         void *filter_data_)
 169 {
 170         struct filter_trees_depth_data *filter_data = filter_data_;
 171         struct seen_map_entry *seen_info;
 172         int include_it = filter_data->current_depth <
 173                 filter_data->exclude_depth;
 174         int filter_res;
 175         int already_seen;
 176
 177         /*
 178          * Note that we do not use _MARK_SEEN in order to allow re-traversal in
 179          * case we encounter a tree or blob again at a shallower depth.
 180          */
 181
 182         switch (filter_situation) {
 183         default:
 184                 BUG("unknown filter_situation: %d", filter_situation);
 185
 186         case LOFS_TAG:
 187                 assert(obj->type == OBJ_TAG);
 188                 /* always include all tag objects */
 189                 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
 190
 191         case LOFS_COMMIT:
 192                 assert(obj->type == OBJ_COMMIT);
 193                 /* always include all commit objects */
 194                 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
 195
 196         case LOFS_END_TREE:
 197                 assert(obj->type == OBJ_TREE);
 198                 filter_data->current_depth--;
 199                 return LOFR_ZERO;
 200
 201         case LOFS_BLOB:
 202                 filter_trees_update_omits(obj, omits, include_it);
 203                 return include_it ? LOFR_MARK_SEEN | LOFR_DO_SHOW : LOFR_ZERO;
 204
 205         case LOFS_BEGIN_TREE:
 206                 seen_info = oidmap_get(
 207                         &filter_data->seen_at_depth, &obj->oid);
 208                 if (!seen_info) {
 209                         CALLOC_ARRAY(seen_info, 1);
 210                         oidcpy(&seen_info->base.oid, &obj->oid);
 211                         seen_info->depth = filter_data->current_depth;
 212                         oidmap_put(&filter_data->seen_at_depth, seen_info);
 213                         already_seen = 0;
 214                 } else {
 215                         already_seen =
 216                                 filter_data->current_depth >= seen_info->depth;
 217                 }
 218
 219                 if (already_seen) {
 220                         filter_res = LOFR_SKIP_TREE;
 221                 } else {
 222                         int been_omitted = filter_trees_update_omits(
 223                                 obj, omits, include_it);
 224                         seen_info->depth = filter_data->current_depth;
 225
 226                         if (include_it)
 227                                 filter_res = LOFR_DO_SHOW;
 228                         else if (omits && !been_omitted)
 229                                 /*
 230                                  * Must update omit information of children
 231                                  * recursively; they have not been omitted yet.
 232                                  */
 233                                 filter_res = LOFR_ZERO;
 234                         else
 235                                 filter_res = LOFR_SKIP_TREE;
 236                 }
 237
 238                 filter_data->current_depth++;
 239                 return filter_res;
 240         }
 241 }
 242
 243 static void filter_trees_free(void *filter_data) {
 244         struct filter_trees_depth_data *d = filter_data;
 245         if (!d)
 246                 return;
 247         oidmap_free(&d->seen_at_depth, 1);
 248         free(d);
 249 }
 250
 251 static void filter_trees_depth__init(
 252         struct list_objects_filter_options *filter_options,
 253         struct filter *filter)
 254 {
 255         struct filter_trees_depth_data *d = xcalloc(1, sizeof(*d));
 256         oidmap_init(&d->seen_at_depth, 0);
 257         d->exclude_depth = filter_options->tree_exclude_depth;
 258         d->current_depth = 0;
 259
 260         filter->filter_data = d;
 261         filter->filter_object_fn = filter_trees_depth;
 262         filter->free_fn = filter_trees_free;
 263 }
 264
 265 /*
 266  * A filter for list-objects to omit large blobs.
 267  * And to OPTIONALLY collect a list of the omitted OIDs.
 268  */
 269 struct filter_blobs_limit_data {
 270         unsigned long max_bytes;
 271 };
 272
 273 static enum list_objects_filter_result filter_blobs_limit(
 274         struct repository *r,
 275         enum list_objects_filter_situation filter_situation,
 276         struct object *obj,
 277         const char *pathname,
 278         const char *filename,
 279         struct oidset *omits,
 280         void *filter_data_)
 281 {
 282         struct filter_blobs_limit_data *filter_data = filter_data_;
 283         unsigned long object_length;
 284         enum object_type t;
 285
 286         switch (filter_situation) {
 287         default:
 288                 BUG("unknown filter_situation: %d", filter_situation);
 289
 290         case LOFS_TAG:
 291                 assert(obj->type == OBJ_TAG);
 292                 /* always include all tag objects */
 293                 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
 294
 295         case LOFS_COMMIT:
 296                 assert(obj->type == OBJ_COMMIT);
 297                 /* always include all commit objects */
 298                 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
 299
 300         case LOFS_BEGIN_TREE:
 301                 assert(obj->type == OBJ_TREE);
 302                 /* always include all tree objects */
 303                 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
 304
 305         case LOFS_END_TREE:
 306                 assert(obj->type == OBJ_TREE);
 307                 return LOFR_ZERO;
 308
 309         case LOFS_BLOB:
 310                 assert(obj->type == OBJ_BLOB);
 311                 assert((obj->flags & SEEN) == 0);
 312
 313                 t = oid_object_info(r, &obj->oid, &object_length);
 314                 if (t != OBJ_BLOB) { /* probably OBJ_NONE */
 315                         /*
 316                          * We DO NOT have the blob locally, so we cannot
 317                          * apply the size filter criteria.  Be conservative
 318                          * and force show it (and let the caller deal with
 319                          * the ambiguity).
 320                          */
 321                         goto include_it;
 322                 }
 323
 324                 if (object_length < filter_data->max_bytes)
 325                         goto include_it;
 326
 327                 if (omits)
 328                         oidset_insert(omits, &obj->oid);
 329                 return LOFR_MARK_SEEN; /* but not LOFR_DO_SHOW (hard omit) */
 330         }
 331
 332 include_it:
 333         if (omits)
 334                 oidset_remove(omits, &obj->oid);
 335         return LOFR_MARK_SEEN | LOFR_DO_SHOW;
 336 }
 337
 338 static void filter_blobs_limit__init(
 339         struct list_objects_filter_options *filter_options,
 340         struct filter *filter)
 341 {
 342         struct filter_blobs_limit_data *d = xcalloc(1, sizeof(*d));
 343         d->max_bytes = filter_options->blob_limit_value;
 344
 345         filter->filter_data = d;
 346         filter->filter_object_fn = filter_blobs_limit;
 347         filter->free_fn = free;
 348 }
 349
 350 /*
 351  * A filter driven by a sparse-checkout specification to only
 352  * include blobs that a sparse checkout would populate.
 353  *
 354  * The sparse-checkout spec can be loaded from a blob with the
 355  * given OID or from a local pathname.  We allow an OID because
 356  * the repo may be bare or we may be doing the filtering on the
 357  * server.
 358  */
 359 struct frame {
 360         /*
 361          * default_match is the usual default include/exclude value that
 362          * should be inherited as we recurse into directories based
 363          * upon pattern matching of the directory itself or of a
 364          * containing directory.
 365          */
 366         enum pattern_match_result default_match;
 367
 368         /*
 369          * 1 if the directory (recursively) contains any provisionally
 370          * omitted objects.
 371          *
 372          * 0 if everything (recursively) contained in this directory
 373          * has been explicitly included (SHOWN) in the result and
 374          * the directory may be short-cut later in the traversal.
 375          */
 376         unsigned child_prov_omit : 1;
 377 };
 378
 379 struct filter_sparse_data {
 380         struct pattern_list pl;
 381
 382         size_t nr, alloc;
 383         struct frame *array_frame;
 384 };
 385
 386 static enum list_objects_filter_result filter_sparse(
 387         struct repository *r,
 388         enum list_objects_filter_situation filter_situation,
 389         struct object *obj,
 390         const char *pathname,
 391         const char *filename,
 392         struct oidset *omits,
 393         void *filter_data_)
 394 {
 395         struct filter_sparse_data *filter_data = filter_data_;
 396         int dtype;
 397         struct frame *frame;
 398         enum pattern_match_result match;
 399
 400         switch (filter_situation) {
 401         default:
 402                 BUG("unknown filter_situation: %d", filter_situation);
 403
 404         case LOFS_TAG:
 405                 assert(obj->type == OBJ_TAG);
 406                 /* always include all tag objects */
 407                 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
 408
 409         case LOFS_COMMIT:
 410                 assert(obj->type == OBJ_COMMIT);
 411                 /* always include all commit objects */
 412                 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
 413
 414         case LOFS_BEGIN_TREE:
 415                 assert(obj->type == OBJ_TREE);
 416                 dtype = DT_DIR;
 417                 match = path_matches_pattern_list(pathname, strlen(pathname),
 418                                                   filename, &dtype, &filter_data->pl,
 419                                                   r->index);
 420                 if (match == UNDECIDED)
 421                         match = filter_data->array_frame[filter_data->nr - 1].default_match;
 422
 423                 ALLOC_GROW(filter_data->array_frame, filter_data->nr + 1,
 424                            filter_data->alloc);
 425                 filter_data->array_frame[filter_data->nr].default_match = match;
 426                 filter_data->array_frame[filter_data->nr].child_prov_omit = 0;
 427                 filter_data->nr++;
 428
 429                 /*
 430                  * A directory with this tree OID may appear in multiple
 431                  * places in the tree. (Think of a directory move or copy,
 432                  * with no other changes, so the OID is the same, but the
 433                  * full pathnames of objects within this directory are new
 434                  * and may match is_excluded() patterns differently.)
 435                  * So we cannot mark this directory as SEEN (yet), since
 436                  * that will prevent process_tree() from revisiting this
 437                  * tree object with other pathname prefixes.
 438                  *
 439                  * Only _DO_SHOW the tree object the first time we visit
 440                  * this tree object.
 441                  *
 442                  * We always show all tree objects.  A future optimization
 443                  * may want to attempt to narrow this.
 444                  */
 445                 if (obj->flags & FILTER_SHOWN_BUT_REVISIT)
 446                         return LOFR_ZERO;
 447                 obj->flags |= FILTER_SHOWN_BUT_REVISIT;
 448                 return LOFR_DO_SHOW;
 449
 450         case LOFS_END_TREE:
 451                 assert(obj->type == OBJ_TREE);
 452                 assert(filter_data->nr > 1);
 453
 454                 frame = &filter_data->array_frame[--filter_data->nr];
 455
 456                 /*
 457                  * Tell our parent directory if any of our children were
 458                  * provisionally omitted.
 459                  */
 460                 filter_data->array_frame[filter_data->nr - 1].child_prov_omit |=
 461                         frame->child_prov_omit;
 462
 463                 /*
 464                  * If there are NO provisionally omitted child objects (ALL child
 465                  * objects in this folder were INCLUDED), then we can mark the
 466                  * folder as SEEN (so we will not have to revisit it again).
 467                  */
 468                 if (!frame->child_prov_omit)
 469                         return LOFR_MARK_SEEN;
 470                 return LOFR_ZERO;
 471
 472         case LOFS_BLOB:
 473                 assert(obj->type == OBJ_BLOB);
 474                 assert((obj->flags & SEEN) == 0);
 475
 476                 frame = &filter_data->array_frame[filter_data->nr - 1];
 477
 478                 dtype = DT_REG;
 479                 match = path_matches_pattern_list(pathname, strlen(pathname),
 480                                             filename, &dtype, &filter_data->pl,
 481                                             r->index);
 482                 if (match == UNDECIDED)
 483                         match = frame->default_match;
 484                 if (match == MATCHED) {
 485                         if (omits)
 486                                 oidset_remove(omits, &obj->oid);
 487                         return LOFR_MARK_SEEN | LOFR_DO_SHOW;
 488                 }
 489
 490                 /*
 491                  * Provisionally omit it.  We've already established that
 492                  * this pathname is not in the sparse-checkout specification
 493                  * with the CURRENT pathname, so we *WANT* to omit this blob.
 494                  *
 495                  * However, a pathname elsewhere in the tree may also
 496                  * reference this same blob, so we cannot reject it yet.
 497                  * Leave the LOFR_ bits unset so that if the blob appears
 498                  * again in the traversal, we will be asked again.
 499                  */
 500                 if (omits)
 501                         oidset_insert(omits, &obj->oid);
 502
 503                 /*
 504                  * Remember that at least 1 blob in this tree was
 505                  * provisionally omitted.  This prevents us from short
 506                  * cutting the tree in future iterations.
 507                  */
 508                 frame->child_prov_omit = 1;
 509                 return LOFR_ZERO;
 510         }
 511 }
 512
 513
 514 static void filter_sparse_free(void *filter_data)
 515 {
 516         struct filter_sparse_data *d = filter_data;
 517         free(d->array_frame);
 518         free(d);
 519 }
 520
 521 static void filter_sparse_oid__init(
 522         struct list_objects_filter_options *filter_options,
 523         struct filter *filter)
 524 {
 525         struct filter_sparse_data *d = xcalloc(1, sizeof(*d));
 526         struct object_context oc;
 527         struct object_id sparse_oid;
 528
 529         if (get_oid_with_context(the_repository,
 530                                  filter_options->sparse_oid_name,
 531                                  GET_OID_BLOB, &sparse_oid, &oc))
 532                 die(_("unable to access sparse blob in '%s'"),
 533                     filter_options->sparse_oid_name);
 534         if (add_patterns_from_blob_to_list(&sparse_oid, "", 0, &d->pl) < 0)
 535                 die(_("unable to parse sparse filter data in %s"),
 536                     oid_to_hex(&sparse_oid));
 537
 538         ALLOC_GROW(d->array_frame, d->nr + 1, d->alloc);
 539         d->array_frame[d->nr].default_match = 0; /* default to include */
 540         d->array_frame[d->nr].child_prov_omit = 0;
 541         d->nr++;
 542
 543         filter->filter_data = d;
 544         filter->filter_object_fn = filter_sparse;
 545         filter->free_fn = filter_sparse_free;
 546 }
 547
 548 /*
 549  * A filter for list-objects to omit large blobs.
 550  * And to OPTIONALLY collect a list of the omitted OIDs.
 551  */
 552 struct filter_object_type_data {
 553         enum object_type object_type;
 554 };
 555
 556 static enum list_objects_filter_result filter_object_type(
 557         struct repository *r,
 558         enum list_objects_filter_situation filter_situation,
 559         struct object *obj,
 560         const char *pathname,
 561         const char *filename,
 562         struct oidset *omits,
 563         void *filter_data_)
 564 {
 565         struct filter_object_type_data *filter_data = filter_data_;
 566
 567         switch (filter_situation) {
 568         default:
 569                 BUG("unknown filter_situation: %d", filter_situation);
 570
 571         case LOFS_TAG:
 572                 assert(obj->type == OBJ_TAG);
 573                 if (filter_data->object_type == OBJ_TAG)
 574                         return LOFR_MARK_SEEN | LOFR_DO_SHOW;
 575                 return LOFR_MARK_SEEN;
 576
 577         case LOFS_COMMIT:
 578                 assert(obj->type == OBJ_COMMIT);
 579                 if (filter_data->object_type == OBJ_COMMIT)
 580                         return LOFR_MARK_SEEN | LOFR_DO_SHOW;
 581                 return LOFR_MARK_SEEN;
 582
 583         case LOFS_BEGIN_TREE:
 584                 assert(obj->type == OBJ_TREE);
 585
 586                 /*
 587                  * If we only want to show commits or tags, then there is no
 588                  * need to walk down trees.
 589                  */
 590                 if (filter_data->object_type == OBJ_COMMIT ||
 591                     filter_data->object_type == OBJ_TAG)
 592                         return LOFR_SKIP_TREE;
 593
 594                 if (filter_data->object_type == OBJ_TREE)
 595                         return LOFR_MARK_SEEN | LOFR_DO_SHOW;
 596
 597                 return LOFR_MARK_SEEN;
 598
 599         case LOFS_BLOB:
 600                 assert(obj->type == OBJ_BLOB);
 601
 602                 if (filter_data->object_type == OBJ_BLOB)
 603                         return LOFR_MARK_SEEN | LOFR_DO_SHOW;
 604                 return LOFR_MARK_SEEN;
 605
 606         case LOFS_END_TREE:
 607                 return LOFR_ZERO;
 608         }
 609 }
 610
 611 static void filter_object_type__init(
 612         struct list_objects_filter_options *filter_options,
 613         struct filter *filter)
 614 {
 615         struct filter_object_type_data *d = xcalloc(1, sizeof(*d));
 616         d->object_type = filter_options->object_type;
 617
 618         filter->filter_data = d;
 619         filter->filter_object_fn = filter_object_type;
 620         filter->free_fn = free;
 621 }
 622
 623 /* A filter which only shows objects shown by all sub-filters. */
 624 struct combine_filter_data {
 625         struct subfilter *sub;
 626         size_t nr;
 627 };
 628
 629 static enum list_objects_filter_result process_subfilter(
 630         struct repository *r,
 631         enum list_objects_filter_situation filter_situation,
 632         struct object *obj,
 633         const char *pathname,
 634         const char *filename,
 635         struct subfilter *sub)
 636 {
 637         enum list_objects_filter_result result;
 638
 639         /*
 640          * Check and update is_skipping_tree before oidset_contains so
 641          * that is_skipping_tree gets unset even when the object is
 642          * marked as seen.  As of this writing, no filter uses
 643          * LOFR_MARK_SEEN on trees that also uses LOFR_SKIP_TREE, so the
 644          * ordering is only theoretically important. Be cautious if you
 645          * change the order of the below checks and more filters have
 646          * been added!
 647          */
 648         if (sub->is_skipping_tree) {
 649                 if (filter_situation == LOFS_END_TREE &&
 650                     oideq(&obj->oid, &sub->skip_tree))
 651                         sub->is_skipping_tree = 0;
 652                 else
 653                         return LOFR_ZERO;
 654         }
 655         if (oidset_contains(&sub->seen, &obj->oid))
 656                 return LOFR_ZERO;
 657
 658         result = list_objects_filter__filter_object(
 659                 r, filter_situation, obj, pathname, filename, sub->filter);
 660
 661         if (result & LOFR_MARK_SEEN)
 662                 oidset_insert(&sub->seen, &obj->oid);
 663
 664         if (result & LOFR_SKIP_TREE) {
 665                 sub->is_skipping_tree = 1;
 666                 sub->skip_tree = obj->oid;
 667         }
 668
 669         return result;
 670 }
 671
 672 static enum list_objects_filter_result filter_combine(
 673         struct repository *r,
 674         enum list_objects_filter_situation filter_situation,
 675         struct object *obj,
 676         const char *pathname,
 677         const char *filename,
 678         struct oidset *omits,
 679         void *filter_data)
 680 {
 681         struct combine_filter_data *d = filter_data;
 682         enum list_objects_filter_result combined_result =
 683                 LOFR_DO_SHOW | LOFR_MARK_SEEN | LOFR_SKIP_TREE;
 684         size_t sub;
 685
 686         for (sub = 0; sub < d->nr; sub++) {
 687                 enum list_objects_filter_result sub_result = process_subfilter(
 688                         r, filter_situation, obj, pathname, filename,
 689                         &d->sub[sub]);
 690                 if (!(sub_result & LOFR_DO_SHOW))
 691                         combined_result &= ~LOFR_DO_SHOW;
 692                 if (!(sub_result & LOFR_MARK_SEEN))
 693                         combined_result &= ~LOFR_MARK_SEEN;
 694                 if (!d->sub[sub].is_skipping_tree)
 695                         combined_result &= ~LOFR_SKIP_TREE;
 696         }
 697
 698         return combined_result;
 699 }
 700
 701 static void filter_combine__free(void *filter_data)
 702 {
 703         struct combine_filter_data *d = filter_data;
 704         size_t sub;
 705         for (sub = 0; sub < d->nr; sub++) {
 706                 list_objects_filter__free(d->sub[sub].filter);
 707                 oidset_clear(&d->sub[sub].seen);
 708                 if (d->sub[sub].omits.set.size)
 709                         BUG("expected oidset to be cleared already");
 710         }
 711         free(d->sub);
 712 }
 713
 714 static void add_all(struct oidset *dest, struct oidset *src) {
 715         struct oidset_iter iter;
 716         struct object_id *src_oid;
 717
 718         oidset_iter_init(src, &iter);
 719         while ((src_oid = oidset_iter_next(&iter)) != NULL)
 720                 oidset_insert(dest, src_oid);
 721 }
 722
 723 static void filter_combine__finalize_omits(
 724         struct oidset *omits,
 725         void *filter_data)
 726 {
 727         struct combine_filter_data *d = filter_data;
 728         size_t sub;
 729
 730         for (sub = 0; sub < d->nr; sub++) {
 731                 add_all(omits, &d->sub[sub].omits);
 732                 oidset_clear(&d->sub[sub].omits);
 733         }
 734 }
 735
 736 static void filter_combine__init(
 737         struct list_objects_filter_options *filter_options,
 738         struct filter* filter)
 739 {
 740         struct combine_filter_data *d = xcalloc(1, sizeof(*d));
 741         size_t sub;
 742
 743         d->nr = filter_options->sub_nr;
 744         CALLOC_ARRAY(d->sub, d->nr);
 745         for (sub = 0; sub < d->nr; sub++)
 746                 d->sub[sub].filter = list_objects_filter__init(
 747                         filter->omits ? &d->sub[sub].omits : NULL,
 748                         &filter_options->sub[sub]);
 749
 750         filter->filter_data = d;
 751         filter->filter_object_fn = filter_combine;
 752         filter->free_fn = filter_combine__free;
 753         filter->finalize_omits_fn = filter_combine__finalize_omits;
 754 }
 755
 756 typedef void (*filter_init_fn)(
 757         struct list_objects_filter_options *filter_options,
 758         struct filter *filter);
 759
 760 /*
 761  * Must match "enum list_objects_filter_choice".
 762  */
 763 static filter_init_fn s_filters[] = {
 764         NULL,
 765         filter_blobs_none__init,
 766         filter_blobs_limit__init,
 767         filter_trees_depth__init,
 768         filter_sparse_oid__init,
 769         filter_object_type__init,
 770         filter_combine__init,
 771 };
 772
 773 struct filter *list_objects_filter__init(
 774         struct oidset *omitted,
 775         struct list_objects_filter_options *filter_options)
 776 {
 777         struct filter *filter;
 778         filter_init_fn init_fn;
 779
 780         assert((sizeof(s_filters) / sizeof(s_filters[0])) == LOFC__COUNT);
 781
 782         if (!filter_options)
 783                 return NULL;
 784
 785         if (filter_options->choice >= LOFC__COUNT)
 786                 BUG("invalid list-objects filter choice: %d",
 787                     filter_options->choice);
 788
 789         init_fn = s_filters[filter_options->choice];
 790         if (!init_fn)
 791                 return NULL;
 792
 793         CALLOC_ARRAY(filter, 1);
 794         filter->omits = omitted;
 795         init_fn(filter_options, filter);
 796         return filter;
 797 }
 798
 799 enum list_objects_filter_result list_objects_filter__filter_object(
 800         struct repository *r,
 801         enum list_objects_filter_situation filter_situation,
 802         struct object *obj,
 803         const char *pathname,
 804         const char *filename,
 805         struct filter *filter)
 806 {
 807         if (filter && (obj->flags & NOT_USER_GIVEN))
 808                 return filter->filter_object_fn(r, filter_situation, obj,
 809                                                 pathname, filename,
 810                                                 filter->omits,
 811                                                 filter->filter_data);
 812         /*
 813          * No filter is active or user gave object explicitly. In this case,
 814          * always show the object (except when LOFS_END_TREE, since this tree
 815          * had already been shown when LOFS_BEGIN_TREE).
 816          */
 817         if (filter_situation == LOFS_END_TREE)
 818                 return 0;
 819         return LOFR_MARK_SEEN | LOFR_DO_SHOW;
 820 }
 821
 822 void list_objects_filter__free(struct filter *filter)
 823 {
 824         if (!filter)
 825                 return;
 826         if (filter->finalize_omits_fn && filter->omits)
 827                 filter->finalize_omits_fn(filter->omits, filter->filter_data);
 828         filter->free_fn(filter->filter_data);
 829         free(filter);
 830 }