revwalk.c 18.4 KB
Newer Older
1
/*
Edward Thomson committed
2
 * Copyright (C) the libgit2 contributors. All rights reserved.
3
 *
Vicent Marti committed
4 5
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
6 7
 */

8 9
#include "revwalk.h"

10
#include "commit.h"
Vicent Marti committed
11
#include "odb.h"
12
#include "pool.h"
13

14
#include "git2/revparse.h"
15
#include "merge.h"
16
#include "vector.h"
17

18 19
static int get_revision(git_commit_list_node **out, git_revwalk *walk, git_commit_list **list);

20 21
git_commit_list_node *git_revwalk__commit_lookup(
	git_revwalk *walk, const git_oid *oid)
22
{
23
	git_commit_list_node *commit;
24

25
	/* lookup and reserve space if not already present */
26 27
	if ((commit = git_oidmap_get(walk->commits, oid)) != NULL)
		return commit;
28

29
	commit = git_commit_list_alloc_node(walk);
30 31
	if (commit == NULL)
		return NULL;
32

33
	git_oid_cpy(&commit->oid, oid);
34

35 36
	if ((git_oidmap_set(walk->commits, &commit->oid, commit)) < 0)
		return NULL;
37 38

	return commit;
39
}
40

41
int git_revwalk__push_commit(git_revwalk *walk, const git_oid *oid, const git_revwalk__push_options *opts)
42
{
43
	git_oid commit_id;
44
	int error;
45
	git_object *obj, *oobj;
46
	git_commit_list_node *commit;
47
	git_commit_list *list;
48

49
	if ((error = git_object_lookup(&oobj, walk->repo, oid, GIT_OBJECT_ANY)) < 0)
50
		return error;
51

52
	error = git_object_peel(&obj, oobj, GIT_OBJECT_COMMIT);
53
	git_object_free(oobj);
54

55
	if (error == GIT_ENOTFOUND || error == GIT_EINVALIDSPEC || error == GIT_EPEEL) {
56
		/* If this comes from e.g. push_glob("tags"), ignore this */
57
		if (opts->from_glob)
58 59
			return 0;

60
		git_error_set(GIT_ERROR_INVALID, "object is not a committish");
61
		return error;
62
	}
63 64 65 66 67
	if (error < 0)
		return error;

	git_oid_cpy(&commit_id, git_object_id(obj));
	git_object_free(obj);
68

69
	commit = git_revwalk__commit_lookup(walk, &commit_id);
70
	if (commit == NULL)
71
		return -1; /* error already reported by failed lookup */
72

73 74 75 76
	/* A previous hide already told us we don't want this commit  */
	if (commit->uninteresting)
		return 0;

77
	if (opts->uninteresting) {
78
		walk->limited = 1;
79
		walk->did_hide = 1;
80
	} else {
81
		walk->did_push = 1;
82
	}
83

84
	commit->uninteresting = opts->uninteresting;
85
	list = walk->user_input;
86 87 88
	if ((opts->insert_by_date &&
	    git_commit_list_insert_by_date(commit, &list) == NULL) ||
	    git_commit_list_insert(commit, &list) == NULL) {
89
		git_error_set_oom();
90
		return -1;
91 92
	}

93 94
	walk->user_input = list;

95
	return 0;
96 97
}

98 99
int git_revwalk_push(git_revwalk *walk, const git_oid *oid)
{
100 101
	git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT;

102
	assert(walk && oid);
103 104

	return git_revwalk__push_commit(walk, oid, &opts);
105
}
106

107

108 109
int git_revwalk_hide(git_revwalk *walk, const git_oid *oid)
{
110
	git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT;
111
	assert(walk && oid);
112 113 114

	opts.uninteresting = 1;
	return git_revwalk__push_commit(walk, oid, &opts);
115
}
116

117
int git_revwalk__push_ref(git_revwalk *walk, const char *refname, const git_revwalk__push_options *opts)
118
{
119
	git_oid oid;
120

121
	if (git_reference_name_to_id(&oid, walk->repo, refname) < 0)
122 123
		return -1;

124
	return git_revwalk__push_commit(walk, &oid, opts);
125 126
}

127
int git_revwalk__push_glob(git_revwalk *walk, const char *glob, const git_revwalk__push_options *given_opts)
128
{
129
	git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT;
130
	int error = 0;
131
	git_buf buf = GIT_BUF_INIT;
132 133
	git_reference *ref;
	git_reference_iterator *iter;
134
	size_t wildcard;
135 136 137

	assert(walk && glob);

138 139 140
	if (given_opts)
		memcpy(&opts, given_opts, sizeof(opts));

141
	/* refs/ is implied if not given in the glob */
142 143 144
	if (git__prefixcmp(glob, GIT_REFS_DIR) != 0)
		git_buf_joinpath(&buf, GIT_REFS_DIR, glob);
	else
145
		git_buf_puts(&buf, glob);
146
	GIT_ERROR_CHECK_ALLOC_BUF(&buf);
147 148

	/* If no '?', '*' or '[' exist, we append '/ *' to the glob */
149 150 151
	wildcard = strcspn(glob, "?*[");
	if (!glob[wildcard])
		git_buf_put(&buf, "/*", 2);
152

153 154
	if ((error = git_reference_iterator_glob_new(&iter, walk->repo, buf.ptr)) < 0)
		goto out;
155

156
	opts.from_glob = true;
157
	while ((error = git_reference_next(&ref, iter)) == 0) {
158
		error = git_revwalk__push_ref(walk, git_reference_name(ref), &opts);
159 160 161 162 163
		git_reference_free(ref);
		if (error < 0)
			break;
	}
	git_reference_iterator_free(iter);
164

165 166 167
	if (error == GIT_ITEROVER)
		error = 0;
out:
168
	git_buf_dispose(&buf);
169
	return error;
170 171 172 173
}

int git_revwalk_push_glob(git_revwalk *walk, const char *glob)
{
174
	git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT;
175
	assert(walk && glob);
176 177

	return git_revwalk__push_glob(walk, glob, &opts);
178 179 180 181
}

int git_revwalk_hide_glob(git_revwalk *walk, const char *glob)
{
182
	git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT;
183
	assert(walk && glob);
184 185 186

	opts.uninteresting = 1;
	return git_revwalk__push_glob(walk, glob, &opts);
187 188
}

189 190
int git_revwalk_push_head(git_revwalk *walk)
{
191
	git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT;
192
	assert(walk);
193 194

	return git_revwalk__push_ref(walk, GIT_HEAD_FILE, &opts);
195 196 197 198
}

int git_revwalk_hide_head(git_revwalk *walk)
{
199
	git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT;
200
	assert(walk);
201 202 203

	opts.uninteresting = 1;
	return git_revwalk__push_ref(walk, GIT_HEAD_FILE, &opts);
204 205 206 207
}

int git_revwalk_push_ref(git_revwalk *walk, const char *refname)
{
208
	git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT;
209
	assert(walk && refname);
210 211

	return git_revwalk__push_ref(walk, refname, &opts);
212 213
}

214 215
int git_revwalk_push_range(git_revwalk *walk, const char *range)
{
216
	git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT;
217
	git_revspec revspec;
218 219
	int error = 0;

220
	if ((error = git_revparse(&revspec, walk->repo, range)))
221
		return error;
Vicent Marti committed
222

223
	if (!revspec.to) {
224
		git_error_set(GIT_ERROR_INVALID, "invalid revspec: range not provided");
225 226 227 228
		error = GIT_EINVALIDSPEC;
		goto out;
	}

229
	if (revspec.flags & GIT_REVPARSE_MERGE_BASE) {
230
		/* TODO: support "<commit>...<commit>" */
231
		git_error_set(GIT_ERROR_INVALID, "symmetric differences not implemented in revwalk");
232 233
		error = GIT_EINVALIDSPEC;
		goto out;
234 235
	}

236 237
	opts.uninteresting = 1;
	if ((error = git_revwalk__push_commit(walk, git_object_id(revspec.from), &opts)))
238 239
		goto out;

240 241
	opts.uninteresting = 0;
	error = git_revwalk__push_commit(walk, git_object_id(revspec.to), &opts);
Vicent Marti committed
242 243

out:
244 245
	git_object_free(revspec.from);
	git_object_free(revspec.to);
246 247 248
	return error;
}

249 250
int git_revwalk_hide_ref(git_revwalk *walk, const char *refname)
{
251
	git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT;
252
	assert(walk && refname);
253 254
	opts.uninteresting = 1;
	return git_revwalk__push_ref(walk, refname, &opts);
255 256
}

257
static int revwalk_enqueue_timesort(git_revwalk *walk, git_commit_list_node *commit)
258
{
259 260
	return git_pqueue_insert(&walk->iterator_time, commit);
}
261

262
static int revwalk_enqueue_unsorted(git_revwalk *walk, git_commit_list_node *commit)
263
{
264
	return git_commit_list_insert(commit, &walk->iterator_rand) ? 0 : -1;
265
}
266

267
static int revwalk_next_timesort(git_commit_list_node **object_out, git_revwalk *walk)
268
{
269
	git_commit_list_node *next;
270

271 272 273 274 275 276
	while ((next = git_pqueue_pop(&walk->iterator_time)) != NULL) {
		/* Some commits might become uninteresting after being added to the list */
		if (!next->uninteresting) {
			*object_out = next;
			return 0;
		}
277
	}
278

279
	git_error_clear();
Russell Belfer committed
280
	return GIT_ITEROVER;
281 282
}

283
static int revwalk_next_unsorted(git_commit_list_node **object_out, git_revwalk *walk)
284
{
285
	int error;
286
	git_commit_list_node *next;
287

288
	while (!(error = get_revision(&next, walk, &walk->iterator_rand))) {
289 290 291 292 293
		/* Some commits might become uninteresting after being added to the list */
		if (!next->uninteresting) {
			*object_out = next;
			return 0;
		}
294
	}
295

296
	return error;
297
}
298

299
static int revwalk_next_toposort(git_commit_list_node **object_out, git_revwalk *walk)
300
{
301
	int error;
302
	git_commit_list_node *next;
303

304
	while (!(error = get_revision(&next, walk, &walk->iterator_topo))) {
305 306 307 308 309
		/* Some commits might become uninteresting after being added to the list */
		if (!next->uninteresting) {
			*object_out = next;
			return 0;
		}
310
	}
311

312
	return error;
313 314
}

315
static int revwalk_next_reverse(git_commit_list_node **object_out, git_revwalk *walk)
316
{
317
	*object_out = git_commit_list_pop(&walk->iterator_reverse);
Russell Belfer committed
318
	return *object_out ? 0 : GIT_ITEROVER;
319
}
320

321
static void mark_parents_uninteresting(git_commit_list_node *commit)
322
{
323 324
	unsigned short i;
	git_commit_list *parents = NULL;
325

326 327
	for (i = 0; i < commit->out_degree; i++)
		git_commit_list_insert(commit->parents[i], &parents);
328

329 330

	while (parents) {
331
		commit = git_commit_list_pop(&parents);
332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350

		while (commit) {
			if (commit->uninteresting)
				break;

			commit->uninteresting = 1;
			/*
			 * If we've reached this commit some other way
			 * already, we need to mark its parents uninteresting
			 * as well.
			 */
			if (!commit->parents)
				break;

			for (i = 0; i < commit->out_degree; i++)
				git_commit_list_insert(commit->parents[i], &parents);
			commit = commit->parents[0];
		}
	}
351 352
}

353
static int add_parents_to_list(git_revwalk *walk, git_commit_list_node *commit, git_commit_list **list)
354 355
{
	unsigned short i;
356
	int error;
357

358 359
	if (commit->added)
		return 0;
360

361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
	commit->added = 1;

	/*
	 * Go full on in the uninteresting case as we want to include
	 * as many of these as we can.
	 *
	 * Usually we haven't parsed the parent of a parent, but if we
	 * have it we reached it via other means so we want to mark
	 * its parents recursively too.
	 */
	if (commit->uninteresting) {
		for (i = 0; i < commit->out_degree; i++) {
			git_commit_list_node *p = commit->parents[i];
			p->uninteresting = 1;

			/* git does it gently here, but we don't like missing objects */
			if ((error = git_commit_list_parse(walk, p)) < 0)
				return error;

			if (p->parents)
				mark_parents_uninteresting(p);

			p->seen = 1;
			git_commit_list_insert_by_date(p, list);
		}

		return 0;
388 389
	}

390 391 392 393 394 395 396
	/*
	 * Now on to what we do if the commit is indeed
	 * interesting. Here we do want things like first-parent take
	 * effect as this is what we'll be showing.
	 */
	for (i = 0; i < commit->out_degree; i++) {
		git_commit_list_node *p = commit->parents[i];
397

398 399
		if ((error = git_commit_list_parse(walk, p)) < 0)
			return error;
400

401
		if (walk->hide_cb && walk->hide_cb(&p->oid, walk->hide_cb_payload))
402
			continue;
403

404 405 406 407 408 409 410 411 412 413
		if (!p->seen) {
			p->seen = 1;
			git_commit_list_insert_by_date(p, list);
		}

		if (walk->first_parent)
			break;
	}
	return 0;
}
414

415 416 417 418 419 420 421 422 423
/* How many unintersting commits we want to look at after we run out of interesting ones */
#define SLOP 5

static int still_interesting(git_commit_list *list, int64_t time, int slop)
{
	/* The empty list is pretty boring */
	if (!list)
		return 0;

424 425 426 427 428 429 430
	/*
	 * If the destination list has commits with an earlier date than our
	 * source, we want to reset the slop counter as we're not done.
	 */
	if (time <= list->item->time)
		return SLOP;

431 432
	for (; list; list = list->next) {
		/*
433
		 * If the destination list still contains interesting commits we
434 435 436 437 438
		 * want to continue looking.
		 */
		if (!list->item->uninteresting || list->item->time > time)
			return SLOP;
	}
439 440 441 442 443 444 445 446

	/* Everything's uninteresting, reduce the count */
	return slop - 1;
}

static int limit_list(git_commit_list **out, git_revwalk *walk, git_commit_list *commits)
{
	int error, slop = SLOP;
447
	int64_t time = INT64_MAX;
448 449 450 451 452 453 454 455 456 457 458 459 460 461 462
	git_commit_list *list = commits;
	git_commit_list *newlist = NULL;
	git_commit_list **p = &newlist;

	while (list) {
		git_commit_list_node *commit = git_commit_list_pop(&list);

		if ((error = add_parents_to_list(walk, commit, &list)) < 0)
			return error;

		if (commit->uninteresting) {
			mark_parents_uninteresting(commit);

			slop = still_interesting(list, time, slop);
			if (slop)
463 464
				continue;

465
			break;
466
		}
467

468 469
		if (walk->hide_cb && walk->hide_cb(&commit->oid, walk->hide_cb_payload))
			continue;
470 471 472

		time = commit->time;
		p = &git_commit_list_insert(commit, p)->next;
473 474
	}

475
	git_commit_list_free(&list);
476 477
	*out = newlist;
	return 0;
478 479
}

480 481 482 483 484
static int get_revision(git_commit_list_node **out, git_revwalk *walk, git_commit_list **list)
{
	int error;
	git_commit_list_node *commit;

485 486
	commit = git_commit_list_pop(list);
	if (!commit) {
487
		git_error_clear();
488 489 490 491 492 493 494 495 496
		return GIT_ITEROVER;
	}

	/*
	 * If we did not run limit_list and we must add parents to the
	 * list ourselves.
	 */
	if (!walk->limited) {
		if ((error = add_parents_to_list(walk, commit, list)) < 0)
497
			return error;
498 499 500 501
	}

	*out = commit;
	return 0;
502 503
}

504
static int sort_in_topological_order(git_commit_list **out, git_revwalk *walk, git_commit_list *list)
505
{
506
	git_commit_list *ll = NULL, *newlist, **pptr;
507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524
	git_commit_list_node *next;
	git_pqueue queue;
	git_vector_cmp queue_cmp = NULL;
	unsigned short i;
	int error;

	if (walk->sorting & GIT_SORT_TIME)
		queue_cmp = git_commit_list_time_cmp;

	if ((error = git_pqueue_init(&queue, 0, 8, queue_cmp)))
		return error;

	/*
	 * Start by resetting the in-degree to 1 for the commits in
	 * our list. We want to go through this list again, so we
	 * store it in the commit list as we extract it from the lower
	 * machinery.
	 */
525 526
	for (ll = list; ll; ll = ll->next) {
		ll->item->in_degree = 1;
527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589
	}

	/*
	 * Count up how many children each commit has. We limit
	 * ourselves to those commits in the original list (in-degree
	 * of 1) avoiding setting it for any parent that was hidden.
	 */
	for(ll = list; ll; ll = ll->next) {
		for (i = 0; i < ll->item->out_degree; ++i) {
			git_commit_list_node *parent = ll->item->parents[i];
			if (parent->in_degree)
				parent->in_degree++;
		}
	}

	/*
	 * Now we find the tips i.e. those not reachable from any other node
	 * i.e. those which still have an in-degree of 1.
	 */
	for(ll = list; ll; ll = ll->next) {
		if (ll->item->in_degree == 1) {
			if ((error = git_pqueue_insert(&queue, ll->item)))
				goto cleanup;
		}
	}

	/*
	 * We need to output the tips in the order that they came out of the
	 * traversal, so if we're not doing time-sorting, we need to reverse the
	 * pqueue in order to get them to come out as we inserted them.
	 */
	if ((walk->sorting & GIT_SORT_TIME) == 0)
		git_pqueue_reverse(&queue);


	pptr = &newlist;
	newlist = NULL;
	while ((next = git_pqueue_pop(&queue)) != NULL) {
		for (i = 0; i < next->out_degree; ++i) {
			git_commit_list_node *parent = next->parents[i];
			if (parent->in_degree == 0)
				continue;

			if (--parent->in_degree == 1) {
				if ((error = git_pqueue_insert(&queue, parent)))
					goto cleanup;
			}
		}

		/* All the children of 'item' have been emitted (since we got to it via the priority queue) */
		next->in_degree = 0;

		pptr = &git_commit_list_insert(next, pptr)->next;
	}

	*out = newlist;
	error = 0;

cleanup:
	git_pqueue_free(&queue);
	return error;
}

590 591
static int prepare_walk(git_revwalk *walk)
{
592
	int error = 0;
593
	git_commit_list *list, *commits = NULL;
594 595
	git_commit_list_node *next;

596 597
	/* If there were no pushes, we know that the walk is already over */
	if (!walk->did_push) {
598
		git_error_clear();
599 600 601
		return GIT_ITEROVER;
	}

602 603 604 605 606 607 608 609 610 611 612 613 614 615
	for (list = walk->user_input; list; list = list->next) {
		git_commit_list_node *commit = list->item;
		if ((error = git_commit_list_parse(walk, commit)) < 0)
			return error;

		if (commit->uninteresting)
			mark_parents_uninteresting(commit);

		if (!commit->seen) {
			commit->seen = 1;
			git_commit_list_insert(commit, &commits);
		}
	}

616
	if (walk->limited && (error = limit_list(&commits, walk, commits)) < 0)
617
		return error;
618

619
	if (walk->sorting & GIT_SORT_TOPOLOGICAL) {
620 621 622 623
		error = sort_in_topological_order(&walk->iterator_topo, walk, commits);
		git_commit_list_free(&commits);

		if (error < 0)
624
			return error;
625

626
		walk->get_next = &revwalk_next_toposort;
627 628 629 630 631 632 633 634 635 636 637
	} else if (walk->sorting & GIT_SORT_TIME) {
		for (list = commits; list && !error; list = list->next)
			error = walk->enqueue(walk, list->item);

		git_commit_list_free(&commits);

		if (error < 0)
			return error;
	} else {
		walk->iterator_rand = commits;
		walk->get_next = revwalk_next_unsorted;
638
	}
639

640
	if (walk->sorting & GIT_SORT_REVERSE) {
641

642
		while ((error = walk->get_next(&next, walk)) == 0)
643
			if (git_commit_list_insert(next, &walk->iterator_reverse) == NULL)
644
				return -1;
645

Russell Belfer committed
646
		if (error != GIT_ITEROVER)
647
			return error;
648

649 650
		walk->get_next = &revwalk_next_reverse;
	}
651

652
	walk->walking = 1;
653
	return 0;
654
}
655 656


657 658
int git_revwalk_new(git_revwalk **revwalk_out, git_repository *repo)
{
659
	git_revwalk *walk = git__calloc(1, sizeof(git_revwalk));
660
	GIT_ERROR_CHECK_ALLOC(walk);
661

662 663 664
	if (git_oidmap_new(&walk->commits) < 0 ||
	    git_pqueue_init(&walk->iterator_time, 0, 8, git_commit_list_time_cmp) < 0 ||
	    git_pool_init(&walk->commit_pool, COMMIT_ALLOC) < 0)
665
		return -1;
666 667 668 669 670 671

	walk->get_next = &revwalk_next_unsorted;
	walk->enqueue = &revwalk_enqueue_unsorted;

	walk->repo = repo;

672
	if (git_repository_odb(&walk->odb, repo) < 0) {
673
		git_revwalk_free(walk);
674
		return -1;
675 676
	}

677
	*revwalk_out = walk;
678
	return 0;
679 680 681 682 683 684 685 686
}

void git_revwalk_free(git_revwalk *walk)
{
	if (walk == NULL)
		return;

	git_revwalk_reset(walk);
687
	git_odb_free(walk->odb);
688

689
	git_oidmap_free(walk->commits);
690
	git_pool_clear(&walk->commit_pool);
691
	git_pqueue_free(&walk->iterator_time);
692
	git__free(walk);
693 694 695 696 697 698 699 700
}

git_repository *git_revwalk_repository(git_revwalk *walk)
{
	assert(walk);
	return walk->repo;
}

701
int git_revwalk_sorting(git_revwalk *walk, unsigned int sort_mode)
702 703 704 705 706 707 708 709 710 711 712 713 714 715 716
{
	assert(walk);

	if (walk->walking)
		git_revwalk_reset(walk);

	walk->sorting = sort_mode;

	if (walk->sorting & GIT_SORT_TIME) {
		walk->get_next = &revwalk_next_timesort;
		walk->enqueue = &revwalk_enqueue_timesort;
	} else {
		walk->get_next = &revwalk_next_unsorted;
		walk->enqueue = &revwalk_enqueue_unsorted;
	}
717

718
	if (walk->sorting != GIT_SORT_NONE)
719
		walk->limited = 1;
720 721

	return 0;
722 723
}

724
int git_revwalk_simplify_first_parent(git_revwalk *walk)
725 726
{
	walk->first_parent = 1;
727
	return 0;
728 729
}

730 731 732
int git_revwalk_next(git_oid *oid, git_revwalk *walk)
{
	int error;
733
	git_commit_list_node *next;
734

735
	assert(walk && oid);
736

737
	if (!walk->walking) {
738
		if ((error = prepare_walk(walk)) < 0)
739
			return error;
740
	}
741

742
	error = walk->get_next(&next, walk);
743

Russell Belfer committed
744
	if (error == GIT_ITEROVER) {
745
		git_revwalk_reset(walk);
746
		git_error_clear();
Russell Belfer committed
747
		return GIT_ITEROVER;
748
	}
749

750 751
	if (!error)
		git_oid_cpy(oid, &next->oid);
752

753
	return error;
754 755
}

756
int git_revwalk_reset(git_revwalk *walk)
757
{
758
	git_commit_list_node *commit;
759

760
	assert(walk);
761

762
	git_oidmap_foreach_value(walk->commits, commit, {
763 764 765
		commit->seen = 0;
		commit->in_degree = 0;
		commit->topo_delay = 0;
766
		commit->uninteresting = 0;
767
		commit->added = 0;
768
		commit->flags = 0;
769
		});
770

771
	git_pqueue_clear(&walk->iterator_time);
772 773 774
	git_commit_list_free(&walk->iterator_topo);
	git_commit_list_free(&walk->iterator_rand);
	git_commit_list_free(&walk->iterator_reverse);
775
	git_commit_list_free(&walk->user_input);
776
	walk->first_parent = 0;
777
	walk->walking = 0;
778
	walk->limited = 0;
779
	walk->did_push = walk->did_hide = 0;
780
	walk->sorting = GIT_SORT_NONE;
781 782

	return 0;
783
}
784

785 786 787 788 789 790 791 792 793 794 795 796
int git_revwalk_add_hide_cb(
	git_revwalk *walk,
	git_revwalk_hide_cb hide_cb,
	void *payload)
{
	assert(walk);

	if (walk->walking)
		git_revwalk_reset(walk);

	walk->hide_cb = hide_cb;
	walk->hide_cb_payload = payload;
797 798 799

	if (hide_cb)
		walk->limited = 1;
800 801 802 803

	return 0;
}