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 UNUSED,
  74         enum list_objects_filter_situation filter_situation,
  75         struct object *obj,
  76         const char *pathname UNUSED,
  77         const char *filename UNUSED,
  78         struct oidset *omits,
  79         void *filter_data_ UNUSED)
  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 UNUSED,
 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 UNUSED,
 163         enum list_objects_filter_situation filter_situation,
 164         struct object *obj,
 165         const char *pathname UNUSED,
 166         const char *filename UNUSED,
 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 UNUSED,
 278         const char *filename UNUSED,
 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         clear_pattern_list(&d->pl);
 518         free(d->array_frame);
 519         free(d);
 520 }
 521
 522 static void filter_sparse_oid__init(
 523         struct list_objects_filter_options *filter_options,
 524         struct filter *filter)
 525 {
 526         struct filter_sparse_data *d = xcalloc(1, sizeof(*d));
 527         struct object_context oc;
 528         struct object_id sparse_oid;
 529
 530         if (get_oid_with_context(the_repository,
 531                                  filter_options->sparse_oid_name,
 532                                  GET_OID_BLOB, &sparse_oid, &oc))
 533                 die(_("unable to access sparse blob in '%s'"),
 534                     filter_options->sparse_oid_name);
 535         if (add_patterns_from_blob_to_list(&sparse_oid, "", 0, &d->pl) < 0)
 536                 die(_("unable to parse sparse filter data in %s"),
 537                     oid_to_hex(&sparse_oid));
 538
 539         ALLOC_GROW(d->array_frame, d->nr + 1, d->alloc);
 540         d->array_frame[d->nr].default_match = 0; /* default to include */
 541         d->array_frame[d->nr].child_prov_omit = 0;
 542         d->nr++;
 543
 544         filter->filter_data = d;
 545         filter->filter_object_fn = filter_sparse;
 546         filter->free_fn = filter_sparse_free;
 547 }
 548
 549 /*
 550  * A filter for list-objects to omit large blobs.
 551  * And to OPTIONALLY collect a list of the omitted OIDs.
 552  */
 553 struct filter_object_type_data {
 554         enum object_type object_type;
 555 };
 556
 557 static enum list_objects_filter_result filter_object_type(
 558         struct repository *r UNUSED,
 559         enum list_objects_filter_situation filter_situation,
 560         struct object *obj,
 561         const char *pathname UNUSED,
 562         const char *filename UNUSED,
 563         struct oidset *omits UNUSED,
 564         void *filter_data_)
 565 {
 566         struct filter_object_type_data *filter_data = filter_data_;
 567
 568         switch (filter_situation) {
 569         default:
 570                 BUG("unknown filter_situation: %d", filter_situation);
 571
 572         case LOFS_TAG:
 573                 assert(obj->type == OBJ_TAG);
 574                 if (filter_data->object_type == OBJ_TAG)
 575                         return LOFR_MARK_SEEN | LOFR_DO_SHOW;
 576                 return LOFR_MARK_SEEN;
 577
 578         case LOFS_COMMIT:
 579                 assert(obj->type == OBJ_COMMIT);
 580                 if (filter_data->object_type == OBJ_COMMIT)
 581                         return LOFR_MARK_SEEN | LOFR_DO_SHOW;
 582                 return LOFR_MARK_SEEN;
 583
 584         case LOFS_BEGIN_TREE:
 585                 assert(obj->type == OBJ_TREE);
 586
 587                 /*
 588                  * If we only want to show commits or tags, then there is no
 589                  * need to walk down trees.
 590                  */
 591                 if (filter_data->object_type == OBJ_COMMIT ||
 592                     filter_data->object_type == OBJ_TAG)
 593                         return LOFR_SKIP_TREE;
 594
 595                 if (filter_data->object_type == OBJ_TREE)
 596                         return LOFR_MARK_SEEN | LOFR_DO_SHOW;
 597
 598                 return LOFR_MARK_SEEN;
 599
 600         case LOFS_BLOB:
 601                 assert(obj->type == OBJ_BLOB);
 602
 603                 if (filter_data->object_type == OBJ_BLOB)
 604                         return LOFR_MARK_SEEN | LOFR_DO_SHOW;
 605                 return LOFR_MARK_SEEN;
 606
 607         case LOFS_END_TREE:
 608                 return LOFR_ZERO;
 609         }
 610 }
 611
 612 static void filter_object_type__init(
 613         struct list_objects_filter_options *filter_options,
 614         struct filter *filter)
 615 {
 616         struct filter_object_type_data *d = xcalloc(1, sizeof(*d));
 617         d->object_type = filter_options->object_type;
 618
 619         filter->filter_data = d;
 620         filter->filter_object_fn = filter_object_type;
 621         filter->free_fn = free;
 622 }
 623
 624 /* A filter which only shows objects shown by all sub-filters. */
 625 struct combine_filter_data {
 626         struct subfilter *sub;
 627         size_t nr;
 628 };
 629
 630 static enum list_objects_filter_result process_subfilter(
 631         struct repository *r,
 632         enum list_objects_filter_situation filter_situation,
 633         struct object *obj,
 634         const char *pathname,
 635         const char *filename,
 636         struct subfilter *sub)
 637 {
 638         enum list_objects_filter_result result;
 639
 640         /*
 641          * Check and update is_skipping_tree before oidset_contains so
 642          * that is_skipping_tree gets unset even when the object is
 643          * marked as seen.  As of this writing, no filter uses
 644          * LOFR_MARK_SEEN on trees that also uses LOFR_SKIP_TREE, so the
 645          * ordering is only theoretically important. Be cautious if you
 646          * change the order of the below checks and more filters have
 647          * been added!
 648          */
 649         if (sub->is_skipping_tree) {
 650                 if (filter_situation == LOFS_END_TREE &&
 651                     oideq(&obj->oid, &sub->skip_tree))
 652                         sub->is_skipping_tree = 0;
 653                 else
 654                         return LOFR_ZERO;
 655         }
 656         if (oidset_contains(&sub->seen, &obj->oid))
 657                 return LOFR_ZERO;
 658
 659         result = list_objects_filter__filter_object(
 660                 r, filter_situation, obj, pathname, filename, sub->filter);
 661
 662         if (result & LOFR_MARK_SEEN)
 663                 oidset_insert(&sub->seen, &obj->oid);
 664
 665         if (result & LOFR_SKIP_TREE) {
 666                 sub->is_skipping_tree = 1;
 667                 sub->skip_tree = obj->oid;
 668         }
 669
 670         return result;
 671 }
 672
 673 static enum list_objects_filter_result filter_combine(
 674         struct repository *r,
 675         enum list_objects_filter_situation filter_situation,
 676         struct object *obj,
 677         const char *pathname,
 678         const char *filename,
 679         struct oidset *omits UNUSED,
 680         void *filter_data)
 681 {
 682         struct combine_filter_data *d = filter_data;
 683         enum list_objects_filter_result combined_result =
 684                 LOFR_DO_SHOW | LOFR_MARK_SEEN | LOFR_SKIP_TREE;
 685         size_t sub;
 686
 687         for (sub = 0; sub < d->nr; sub++) {
 688                 enum list_objects_filter_result sub_result = process_subfilter(
 689                         r, filter_situation, obj, pathname, filename,
 690                         &d->sub[sub]);
 691                 if (!(sub_result & LOFR_DO_SHOW))
 692                         combined_result &= ~LOFR_DO_SHOW;
 693                 if (!(sub_result & LOFR_MARK_SEEN))
 694                         combined_result &= ~LOFR_MARK_SEEN;
 695                 if (!d->sub[sub].is_skipping_tree)
 696                         combined_result &= ~LOFR_SKIP_TREE;
 697         }
 698
 699         return combined_result;
 700 }
 701
 702 static void filter_combine__free(void *filter_data)
 703 {
 704         struct combine_filter_data *d = filter_data;
 705         size_t sub;
 706         for (sub = 0; sub < d->nr; sub++) {
 707                 list_objects_filter__free(d->sub[sub].filter);
 708                 oidset_clear(&d->sub[sub].seen);
 709                 if (d->sub[sub].omits.set.size)
 710                         BUG("expected oidset to be cleared already");
 711         }
 712         free(d->sub);
 713         free(d);
 714 }
 715
 716 static void add_all(struct oidset *dest, struct oidset *src) {
 717         struct oidset_iter iter;
 718         struct object_id *src_oid;
 719
 720         oidset_iter_init(src, &iter);
 721         while ((src_oid = oidset_iter_next(&iter)) != NULL)
 722                 oidset_insert(dest, src_oid);
 723 }
 724
 725 static void filter_combine__finalize_omits(
 726         struct oidset *omits,
 727         void *filter_data)
 728 {
 729         struct combine_filter_data *d = filter_data;
 730         size_t sub;
 731
 732         for (sub = 0; sub < d->nr; sub++) {
 733                 add_all(omits, &d->sub[sub].omits);
 734                 oidset_clear(&d->sub[sub].omits);
 735         }
 736 }
 737
 738 static void filter_combine__init(
 739         struct list_objects_filter_options *filter_options,
 740         struct filter* filter)
 741 {
 742         struct combine_filter_data *d = xcalloc(1, sizeof(*d));
 743         size_t sub;
 744
 745         d->nr = filter_options->sub_nr;
 746         CALLOC_ARRAY(d->sub, d->nr);
 747         for (sub = 0; sub < d->nr; sub++)
 748                 d->sub[sub].filter = list_objects_filter__init(
 749                         filter->omits ? &d->sub[sub].omits : NULL,
 750                         &filter_options->sub[sub]);
 751
 752         filter->filter_data = d;
 753         filter->filter_object_fn = filter_combine;
 754         filter->free_fn = filter_combine__free;
 755         filter->finalize_omits_fn = filter_combine__finalize_omits;
 756 }
 757
 758 typedef void (*filter_init_fn)(
 759         struct list_objects_filter_options *filter_options,
 760         struct filter *filter);
 761
 762 /*
 763  * Must match "enum list_objects_filter_choice".
 764  */
 765 static filter_init_fn s_filters[] = {
 766         NULL,
 767         filter_blobs_none__init,
 768         filter_blobs_limit__init,
 769         filter_trees_depth__init,
 770         filter_sparse_oid__init,
 771         filter_object_type__init,
 772         filter_combine__init,
 773 };
 774
 775 struct filter *list_objects_filter__init(
 776         struct oidset *omitted,
 777         struct list_objects_filter_options *filter_options)
 778 {
 779         struct filter *filter;
 780         filter_init_fn init_fn;
 781
 782         assert((sizeof(s_filters) / sizeof(s_filters[0])) == LOFC__COUNT);
 783
 784         if (!filter_options)
 785                 return NULL;
 786
 787         if (filter_options->choice >= LOFC__COUNT)
 788                 BUG("invalid list-objects filter choice: %d",
 789                     filter_options->choice);
 790
 791         init_fn = s_filters[filter_options->choice];
 792         if (!init_fn)
 793                 return NULL;
 794
 795         CALLOC_ARRAY(filter, 1);
 796         filter->omits = omitted;
 797         init_fn(filter_options, filter);
 798         return filter;
 799 }
 800
 801 enum list_objects_filter_result list_objects_filter__filter_object(
 802         struct repository *r,
 803         enum list_objects_filter_situation filter_situation,
 804         struct object *obj,
 805         const char *pathname,
 806         const char *filename,
 807         struct filter *filter)
 808 {
 809         if (filter && (obj->flags & NOT_USER_GIVEN))
 810                 return filter->filter_object_fn(r, filter_situation, obj,
 811                                                 pathname, filename,
 812                                                 filter->omits,
 813                                                 filter->filter_data);
 814         /*
 815          * No filter is active or user gave object explicitly. In this case,
 816          * always show the object (except when LOFS_END_TREE, since this tree
 817          * had already been shown when LOFS_BEGIN_TREE).
 818          */
 819         if (filter_situation == LOFS_END_TREE)
 820                 return 0;
 821         return LOFR_MARK_SEEN | LOFR_DO_SHOW;
 822 }
 823
 824 void list_objects_filter__free(struct filter *filter)
 825 {
 826         if (!filter)
 827                 return;
 828         if (filter->finalize_omits_fn && filter->omits)
 829                 filter->finalize_omits_fn(filter->omits, filter->filter_data);
 830         filter->free_fn(filter->filter_data);
 831         free(filter);
 832 }