@leroysheep / BookAlchemy
Code Commits Pulls CI/CD 81,972
jch
bisect jch maint master next seen test todo
c 830 lines 22 KB
Raw
1 #define USE_THE_REPOSITORY_VARIABLE
2
3 #include "git-compat-util.h"
4 #include "dir.h"
5 #include "gettext.h"
6 #include "hex.h"
7 #include "commit.h"
8 #include "diff.h"
9 #include "revision.h"
10 #include "list-objects-filter.h"
11 #include "list-objects-filter-options.h"
12 #include "oidmap.h"
13 #include "oidset.h"
14 #include "object-name.h"
15 #include "odb.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_clear(&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 size_t 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 = odb_read_object_info(r->objects, &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_id sparse_oid;
528
529 if (repo_get_oid_with_flags(the_repository,
530 filter_options->sparse_oid_name,
531 &sparse_oid, GET_OID_BLOB))
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 UNUSED,
558 enum list_objects_filter_situation filter_situation,
559 struct object *obj,
560 const char *pathname UNUSED,
561 const char *filename UNUSED,
562 struct oidset *omits UNUSED,
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 UNUSED,
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 free(d);
713 }
714
715 static void filter_combine__finalize_omits(
716 struct oidset *omits,
717 void *filter_data)
718 {
719 struct combine_filter_data *d = filter_data;
720 size_t sub;
721
722 for (sub = 0; sub < d->nr; sub++) {
723 oidset_insert_from_set(omits, &d->sub[sub].omits);
724 oidset_clear(&d->sub[sub].omits);
725 }
726 }
727
728 static void filter_combine__init(
729 struct list_objects_filter_options *filter_options,
730 struct filter* filter)
731 {
732 struct combine_filter_data *d = xcalloc(1, sizeof(*d));
733 size_t sub;
734
735 d->nr = filter_options->sub_nr;
736 CALLOC_ARRAY(d->sub, d->nr);
737 for (sub = 0; sub < d->nr; sub++)
738 d->sub[sub].filter = list_objects_filter__init(
739 filter->omits ? &d->sub[sub].omits : NULL,
740 &filter_options->sub[sub]);
741
742 filter->filter_data = d;
743 filter->filter_object_fn = filter_combine;
744 filter->free_fn = filter_combine__free;
745 filter->finalize_omits_fn = filter_combine__finalize_omits;
746 }
747
748 static void filter_auto__init(
749 struct list_objects_filter_options *filter_options UNUSED,
750 struct filter *filter UNUSED)
751 {
752 BUG("LOFC_AUTO should have been resolved before initializing the filter");
753 }
754
755 typedef void (*filter_init_fn)(
756 struct list_objects_filter_options *filter_options,
757 struct filter *filter);
758
759 /*
760 * Must match "enum list_objects_filter_choice".
761 */
762 static filter_init_fn s_filters[] = {
763 NULL,
764 filter_blobs_none__init,
765 filter_blobs_limit__init,
766 filter_trees_depth__init,
767 filter_sparse_oid__init,
768 filter_object_type__init,
769 filter_combine__init,
770 filter_auto__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 }