git

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 "object-store-ll.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
	object_context_release(&oc);
549
}
550

551
/*
552
 * A filter for list-objects to omit large blobs.
553
 * And to OPTIONALLY collect a list of the omitted OIDs.
554
 */
555
struct filter_object_type_data {
556
	enum object_type object_type;
557
};
558

559
static enum list_objects_filter_result filter_object_type(
560
	struct repository *r UNUSED,
561
	enum list_objects_filter_situation filter_situation,
562
	struct object *obj,
563
	const char *pathname UNUSED,
564
	const char *filename UNUSED,
565
	struct oidset *omits UNUSED,
566
	void *filter_data_)
567
{
568
	struct filter_object_type_data *filter_data = filter_data_;
569

570
	switch (filter_situation) {
571
	default:
572
		BUG("unknown filter_situation: %d", filter_situation);
573

574
	case LOFS_TAG:
575
		assert(obj->type == OBJ_TAG);
576
		if (filter_data->object_type == OBJ_TAG)
577
			return LOFR_MARK_SEEN | LOFR_DO_SHOW;
578
		return LOFR_MARK_SEEN;
579

580
	case LOFS_COMMIT:
581
		assert(obj->type == OBJ_COMMIT);
582
		if (filter_data->object_type == OBJ_COMMIT)
583
			return LOFR_MARK_SEEN | LOFR_DO_SHOW;
584
		return LOFR_MARK_SEEN;
585

586
	case LOFS_BEGIN_TREE:
587
		assert(obj->type == OBJ_TREE);
588

589
		/*
590
		 * If we only want to show commits or tags, then there is no
591
		 * need to walk down trees.
592
		 */
593
		if (filter_data->object_type == OBJ_COMMIT ||
594
		    filter_data->object_type == OBJ_TAG)
595
			return LOFR_SKIP_TREE;
596

597
		if (filter_data->object_type == OBJ_TREE)
598
			return LOFR_MARK_SEEN | LOFR_DO_SHOW;
599

600
		return LOFR_MARK_SEEN;
601

602
	case LOFS_BLOB:
603
		assert(obj->type == OBJ_BLOB);
604

605
		if (filter_data->object_type == OBJ_BLOB)
606
			return LOFR_MARK_SEEN | LOFR_DO_SHOW;
607
		return LOFR_MARK_SEEN;
608

609
	case LOFS_END_TREE:
610
		return LOFR_ZERO;
611
	}
612
}
613

614
static void filter_object_type__init(
615
	struct list_objects_filter_options *filter_options,
616
	struct filter *filter)
617
{
618
	struct filter_object_type_data *d = xcalloc(1, sizeof(*d));
619
	d->object_type = filter_options->object_type;
620

621
	filter->filter_data = d;
622
	filter->filter_object_fn = filter_object_type;
623
	filter->free_fn = free;
624
}
625

626
/* A filter which only shows objects shown by all sub-filters. */
627
struct combine_filter_data {
628
	struct subfilter *sub;
629
	size_t nr;
630
};
631

632
static enum list_objects_filter_result process_subfilter(
633
	struct repository *r,
634
	enum list_objects_filter_situation filter_situation,
635
	struct object *obj,
636
	const char *pathname,
637
	const char *filename,
638
	struct subfilter *sub)
639
{
640
	enum list_objects_filter_result result;
641

642
	/*
643
	 * Check and update is_skipping_tree before oidset_contains so
644
	 * that is_skipping_tree gets unset even when the object is
645
	 * marked as seen.  As of this writing, no filter uses
646
	 * LOFR_MARK_SEEN on trees that also uses LOFR_SKIP_TREE, so the
647
	 * ordering is only theoretically important. Be cautious if you
648
	 * change the order of the below checks and more filters have
649
	 * been added!
650
	 */
651
	if (sub->is_skipping_tree) {
652
		if (filter_situation == LOFS_END_TREE &&
653
		    oideq(&obj->oid, &sub->skip_tree))
654
			sub->is_skipping_tree = 0;
655
		else
656
			return LOFR_ZERO;
657
	}
658
	if (oidset_contains(&sub->seen, &obj->oid))
659
		return LOFR_ZERO;
660

661
	result = list_objects_filter__filter_object(
662
		r, filter_situation, obj, pathname, filename, sub->filter);
663

664
	if (result & LOFR_MARK_SEEN)
665
		oidset_insert(&sub->seen, &obj->oid);
666

667
	if (result & LOFR_SKIP_TREE) {
668
		sub->is_skipping_tree = 1;
669
		sub->skip_tree = obj->oid;
670
	}
671

672
	return result;
673
}
674

675
static enum list_objects_filter_result filter_combine(
676
	struct repository *r,
677
	enum list_objects_filter_situation filter_situation,
678
	struct object *obj,
679
	const char *pathname,
680
	const char *filename,
681
	struct oidset *omits UNUSED,
682
	void *filter_data)
683
{
684
	struct combine_filter_data *d = filter_data;
685
	enum list_objects_filter_result combined_result =
686
		LOFR_DO_SHOW | LOFR_MARK_SEEN | LOFR_SKIP_TREE;
687
	size_t sub;
688

689
	for (sub = 0; sub < d->nr; sub++) {
690
		enum list_objects_filter_result sub_result = process_subfilter(
691
			r, filter_situation, obj, pathname, filename,
692
			&d->sub[sub]);
693
		if (!(sub_result & LOFR_DO_SHOW))
694
			combined_result &= ~LOFR_DO_SHOW;
695
		if (!(sub_result & LOFR_MARK_SEEN))
696
			combined_result &= ~LOFR_MARK_SEEN;
697
		if (!d->sub[sub].is_skipping_tree)
698
			combined_result &= ~LOFR_SKIP_TREE;
699
	}
700

701
	return combined_result;
702
}
703

704
static void filter_combine__free(void *filter_data)
705
{
706
	struct combine_filter_data *d = filter_data;
707
	size_t sub;
708
	for (sub = 0; sub < d->nr; sub++) {
709
		list_objects_filter__free(d->sub[sub].filter);
710
		oidset_clear(&d->sub[sub].seen);
711
		if (d->sub[sub].omits.set.size)
712
			BUG("expected oidset to be cleared already");
713
	}
714
	free(d->sub);
715
	free(d);
716
}
717

718
static void filter_combine__finalize_omits(
719
	struct oidset *omits,
720
	void *filter_data)
721
{
722
	struct combine_filter_data *d = filter_data;
723
	size_t sub;
724

725
	for (sub = 0; sub < d->nr; sub++) {
726
		oidset_insert_from_set(omits, &d->sub[sub].omits);
727
		oidset_clear(&d->sub[sub].omits);
728
	}
729
}
730

731
static void filter_combine__init(
732
	struct list_objects_filter_options *filter_options,
733
	struct filter* filter)
734
{
735
	struct combine_filter_data *d = xcalloc(1, sizeof(*d));
736
	size_t sub;
737

738
	d->nr = filter_options->sub_nr;
739
	CALLOC_ARRAY(d->sub, d->nr);
740
	for (sub = 0; sub < d->nr; sub++)
741
		d->sub[sub].filter = list_objects_filter__init(
742
			filter->omits ? &d->sub[sub].omits : NULL,
743
			&filter_options->sub[sub]);
744

745
	filter->filter_data = d;
746
	filter->filter_object_fn = filter_combine;
747
	filter->free_fn = filter_combine__free;
748
	filter->finalize_omits_fn = filter_combine__finalize_omits;
749
}
750

751
typedef void (*filter_init_fn)(
752
	struct list_objects_filter_options *filter_options,
753
	struct filter *filter);
754

755
/*
756
 * Must match "enum list_objects_filter_choice".
757
 */
758
static filter_init_fn s_filters[] = {
759
	NULL,
760
	filter_blobs_none__init,
761
	filter_blobs_limit__init,
762
	filter_trees_depth__init,
763
	filter_sparse_oid__init,
764
	filter_object_type__init,
765
	filter_combine__init,
766
};
767

768
struct filter *list_objects_filter__init(
769
	struct oidset *omitted,
770
	struct list_objects_filter_options *filter_options)
771
{
772
	struct filter *filter;
773
	filter_init_fn init_fn;
774

775
	assert((sizeof(s_filters) / sizeof(s_filters[0])) == LOFC__COUNT);
776

777
	if (!filter_options)
778
		return NULL;
779

780
	if (filter_options->choice >= LOFC__COUNT)
781
		BUG("invalid list-objects filter choice: %d",
782
		    filter_options->choice);
783

784
	init_fn = s_filters[filter_options->choice];
785
	if (!init_fn)
786
		return NULL;
787

788
	CALLOC_ARRAY(filter, 1);
789
	filter->omits = omitted;
790
	init_fn(filter_options, filter);
791
	return filter;
792
}
793

794
enum list_objects_filter_result list_objects_filter__filter_object(
795
	struct repository *r,
796
	enum list_objects_filter_situation filter_situation,
797
	struct object *obj,
798
	const char *pathname,
799
	const char *filename,
800
	struct filter *filter)
801
{
802
	if (filter && (obj->flags & NOT_USER_GIVEN))
803
		return filter->filter_object_fn(r, filter_situation, obj,
804
						pathname, filename,
805
						filter->omits,
806
						filter->filter_data);
807
	/*
808
	 * No filter is active or user gave object explicitly. In this case,
809
	 * always show the object (except when LOFS_END_TREE, since this tree
810
	 * had already been shown when LOFS_BEGIN_TREE).
811
	 */
812
	if (filter_situation == LOFS_END_TREE)
813
		return 0;
814
	return LOFR_MARK_SEEN | LOFR_DO_SHOW;
815
}
816

817
void list_objects_filter__free(struct filter *filter)
818
{
819
	if (!filter)
820
		return;
821
	if (filter->finalize_omits_fn && filter->omits)
822
		filter->finalize_omits_fn(filter->omits, filter->filter_data);
823
	filter->free_fn(filter->filter_data);
824
	free(filter);
825
}
826