p = p->next;
}
if (p) {
- free_commit_list(p->next);
+ commit_list_free(p->next);
p->next = NULL;
}
strbuf_release(&buf);
if (best) {
if (!(bisect_flags & FIND_BISECTION_ALL)) {
list->item = best->item;
- free_commit_list(list->next);
+ commit_list_free(list->next);
best = list;
best->next = NULL;
}
} else {
if (!show_all) {
if (!skipped_first || !*skipped_first) {
- free_commit_list(next);
- free_commit_list(filtered);
+ commit_list_free(next);
+ commit_list_free(filtered);
return list;
}
} else if (skipped_first && !*skipped_first) {
}
}
- free_commit_list(result);
+ commit_list_free(result);
return res;
}
res = bisect_checkout(bisect_rev, no_checkout);
cleanup:
- free_commit_list(tried);
+ commit_list_free(tried);
release_revisions(&revs);
strvec_clear(&rev_argv);
return res;
if (revs->first_parent_only &&
commit->parents &&
commit->parents->next) {
- free_commit_list(commit->parents->next);
+ commit_list_free(commit->parents->next);
commit->parents->next = NULL;
}
return commit->parents;
run_hooks(the_repository, "post-applypatch");
- free_commit_list(parents);
+ commit_list_free(parents);
strbuf_release(&sb);
}
ret = 0;
out:
- free_commit_list(parents);
+ commit_list_free(parents);
strbuf_release(&buffer);
return ret;
}
cleanup:
free_commit_extra_headers(extra);
- free_commit_list(parents);
+ commit_list_free(parents);
strbuf_release(&author_ident);
strbuf_release(&err);
strbuf_release(&sb);
describe_commit(pcd->current_commit, pcd->dst);
strbuf_addf(pcd->dst, ":%s", path);
}
- free_commit_list(pcd->revs->commits);
+ commit_list_free(pcd->revs->commits);
pcd->revs->commits = NULL;
}
}
struct commit *parent = lookup_commit(the_repository, &oid);
if (!pptr) {
/* Free the real parent list */
- free_commit_list(commit->parents);
+ commit_list_free(commit->parents);
commit->parents = NULL;
pptr = &(commit->parents);
}
}
}
- free_commit_list(stack);
+ commit_list_free(stack);
return result;
}
*/
free_commit_buffer(the_repository->parsed_objects,
commit);
- free_commit_list(commit->parents);
+ commit_list_free(commit->parents);
commit->parents = NULL;
}
if (saved_nrl < rev->diffopt.needed_rename_limit)
if (die_on_failure) {
die(_("could not find exact merge base"));
} else {
- free_commit_list(base_list);
+ commit_list_free(base_list);
return NULL;
}
}
base = base_list->item;
- free_commit_list(base_list);
+ commit_list_free(base_list);
} else {
if (die_on_failure)
die(_("failed to get upstream, if you want to record base commit automatically,\n"
if (die_on_failure) {
die(_("failed to find exact merge base"));
} else {
- free_commit_list(merge_base);
+ commit_list_free(merge_base);
free(rev);
return NULL;
}
}
rev[i] = merge_base->item;
- free_commit_list(merge_base);
+ commit_list_free(merge_base);
}
if (rev_nr % 2)
print_commit(sign, commit, verbose, abbrev, revs.diffopt.file);
}
- free_commit_list(list);
+ commit_list_free(list);
free_patch_ids(&ids);
return 0;
}
if (repo_get_merge_bases_many_dirty(the_repository, rev[0],
rev_nr - 1, rev + 1, &result) < 0) {
- free_commit_list(result);
+ commit_list_free(result);
return -1;
}
break;
}
- free_commit_list(result);
+ commit_list_free(result);
return 0;
}
for (rev = revs; rev; rev = rev->next)
printf("%s\n", oid_to_hex(&rev->item->object.oid));
- free_commit_list(revs);
+ commit_list_free(revs);
return 0;
}
commit_list_insert(get_commit_reference(args[i]), &revs);
if (get_octopus_merge_bases(revs, &result) < 0) {
- free_commit_list(revs);
- free_commit_list(result);
+ commit_list_free(revs);
+ commit_list_free(result);
return 128;
}
- free_commit_list(revs);
+ commit_list_free(revs);
reduce_heads_replace(&result);
if (!result)
break;
}
- free_commit_list(result);
+ commit_list_free(result);
return 0;
}
die(_("refusing to merge unrelated histories"));
merge_bases = commit_list_reverse(merge_bases);
merge_incore_recursive(&opt, merge_bases, parent1, parent2, &result);
- free_commit_list(merge_bases);
+ commit_list_free(merge_bases);
}
if (result.clean < 0)
LOCK_DIE_ON_ERROR);
clean = merge_ort_recursive(&o, head, remoteheads->item,
reversed, &result);
- free_commit_list(reversed);
+ commit_list_free(reversed);
strbuf_release(&o.obuf);
if (clean < 0) {
finish(head, remoteheads, &result_commit, "In-index merge");
remove_merge_branch_state(the_repository);
- free_commit_list(parents);
+ commit_list_free(parents);
return 0;
}
struct object_id result_commit;
write_tree_trivial(result_tree);
- free_commit_list(common);
+ commit_list_free(common);
parents = remoteheads;
if (!head_subsumed || fast_forward == FF_NO)
commit_list_insert(head, &parents);
strbuf_release(&buf);
remove_merge_branch_state(the_repository);
- free_commit_list(parents);
+ commit_list_free(parents);
return 0;
}
/* Find what parents to record by checking independent ones. */
parents = reduce_heads(remoteheads);
- free_commit_list(remoteheads);
+ commit_list_free(remoteheads);
remoteheads = NULL;
remotes = &remoteheads;
exit(128);
common_item = common_one->item;
- free_commit_list(common_one);
+ commit_list_free(common_one);
if (!oideq(&common_item->object.oid, &j->item->object.oid)) {
up_to_date = 0;
break;
done:
if (!automerge_was_ok) {
- free_commit_list(common);
- free_commit_list(remoteheads);
+ commit_list_free(common);
+ commit_list_free(remoteheads);
}
strbuf_release(&buf);
free(branch_to_free);
if (get_octopus_merge_bases(revs, &result) < 0)
exit(128);
- free_commit_list(revs);
+ commit_list_free(revs);
reduce_heads_replace(&result);
if (!result)
return 1;
oidcpy(merge_base, &result->item->object.oid);
- free_commit_list(result);
+ commit_list_free(result);
return 0;
}
commit_list_insert(head, &list);
merge_head = lookup_commit_reference(the_repository, orig_merge_head);
ret = repo_is_descendant_of(the_repository, merge_head, list);
- free_commit_list(list);
+ commit_list_free(list);
if (ret < 0)
exit(128);
return ret;
theirs = lookup_commit_reference(the_repository, &merge_heads->oid[i]);
commit_list_insert(theirs, &list);
ok = repo_is_descendant_of(the_repository, ours, list);
- free_commit_list(list);
+ commit_list_free(list);
if (ok < 0)
exit(128);
if (!ok)
res = 1;
done:
- free_commit_list(merge_bases);
+ commit_list_free(merge_bases);
return res && is_linear_history(onto, head);
}
else
oidcpy(branch_base, &merge_bases->item->object.oid);
- free_commit_list(merge_bases);
+ commit_list_free(merge_bases);
}
static int parse_opt_am(const struct option *opt, const char *arg, int unset)
static void finish_commit(struct commit *commit)
{
- free_commit_list(commit->parents);
+ commit_list_free(commit->parents);
commit->parents = NULL;
free_commit_buffer(the_repository->parsed_objects,
commit);
out:
for (size_t i = 0; i < ARRAY_SIZE(reflog_msg); i++)
free(reflog_msg[i]);
- free_commit_list(seen);
+ commit_list_free(seen);
clear_prio_queue(&queue);
free(args_copy);
free(head);
goto done;
}
- free_commit_list(parents);
+ commit_list_free(parents);
parents = NULL;
if (include_untracked) {
strbuf_release(&commit_tree_label);
strbuf_release(&msg);
strbuf_release(&untracked_files);
- free_commit_list(parents);
+ commit_list_free(parents);
free(branch_name_buf);
return ret;
}
out:
if (this && buffer)
repo_unuse_commit_buffer(r, this, buffer);
- free_commit_list(items);
+ commit_list_free(items);
free(msg);
return res;
next = commit_list_append(prev, next);
next = commit_list_append(stash, next);
res = write_commit_with_parents(r, &out, &stash->object.oid, parents);
- free_commit_list(parents);
+ commit_list_free(parents);
if (res)
goto out;
prev = lookup_commit_reference(r, &out);
puts(oid_to_hex(&prev->object.oid));
out:
strbuf_release(&revision);
- free_commit_list(items);
+ commit_list_free(items);
return res;
}
do {
if (g->chunk_extra_edges_size / sizeof(uint32_t) <= parent_data_pos) {
error(_("commit-graph extra-edges pointer out of bounds"));
- free_commit_list(item->parents);
+ commit_list_free(item->parents);
item->parents = NULL;
item->object.parsed = 0;
return 0;
continue;
if (repo_parse_commit(r, p)) {
clear_prio_queue(&queue);
- free_commit_list(*result);
+ commit_list_free(*result);
*result = NULL;
/*
* At this stage, we know that the commit is
}
if (paint_down_to_common(r, one, n, twos, 0, 0, &list)) {
- free_commit_list(list);
+ commit_list_free(list);
return -1;
}
struct commit_list *bases = NULL;
if (repo_get_merge_bases(the_repository, i->item,
j->item, &bases) < 0) {
- free_commit_list(bases);
- free_commit_list(*result);
+ commit_list_free(bases);
+ commit_list_free(*result);
*result = NULL;
return -1;
}
for (k = bases; k; k = k->next)
end = k;
}
- free_commit_list(*result);
+ commit_list_free(*result);
*result = new_commits;
}
return 0;
work, min_generation, 0, &common)) {
clear_commit_marks(array[i], all_flags);
clear_commit_marks_many(filled, work, all_flags);
- free_commit_list(common);
+ commit_list_free(common);
free(work);
free(redundant);
free(filled_index);
redundant[filled_index[j]] = 1;
clear_commit_marks(array[i], all_flags);
clear_commit_marks_many(filled, work, all_flags);
- free_commit_list(common);
+ commit_list_free(common);
}
/* Now collect the result */
if (!parents)
pop_commit(&stack);
}
- free_commit_list(stack);
+ commit_list_free(stack);
}
free(sorted);
CALLOC_ARRAY(rslt, cnt);
for (list = *result, i = 0; list; list = list->next)
rslt[i++] = list->item;
- free_commit_list(*result);
+ commit_list_free(*result);
*result = NULL;
clear_commit_marks(one, all_flags);
int result;
commit_list_insert(commit, &from_list);
result = can_all_from_reach(from_list, with_commit, 0);
- free_commit_list(from_list);
+ commit_list_free(from_list);
return result;
} else {
while (with_commit) {
ret = 1;
clear_commit_marks(commit, all_flags);
clear_commit_marks_many(nr_reference, reference, all_flags);
- free_commit_list(bases);
+ commit_list_free(bases);
return ret;
}
next = commit_list_append(commit, next);
res = repo_is_descendant_of(r, reference, list);
- free_commit_list(list);
+ commit_list_free(list);
return res;
}
void reduce_heads_replace(struct commit_list **heads)
{
struct commit_list *result = reduce_heads(*heads);
- free_commit_list(*heads);
+ commit_list_free(*heads);
*heads = result;
}
new_commit, old_commit_list);
if (ret < 0)
exit(128);
- free_commit_list(old_commit_list);
+ commit_list_free(old_commit_list);
return ret;
}
done:
free(commits);
repo_clear_commit_marks(r, SEEN);
- free_commit_list(stack);
+ commit_list_free(stack);
}
/*
if (!c->object.parsed)
return;
- free_commit_list(c->parents);
+ commit_list_free(c->parents);
c->parents = NULL;
c->object.parsed = 0;
}
set_commit_tree(c, NULL);
free_commit_buffer(pool, c);
c->index = 0;
- free_commit_list(c->parents);
+ commit_list_free(c->parents);
c->object.parsed = 0;
}
* same error, but that's good, since it lets our caller know
* the result cannot be trusted.
*/
- free_commit_list(item->parents);
+ commit_list_free(item->parents);
item->parents = NULL;
tail += size;
return next;
}
-void free_commit_list(struct commit_list *list)
+void commit_list_free(struct commit_list *list)
{
while (list)
pop_commit(&list);
prio_queue_reverse(&queue);
/* We no longer need the commit list */
- free_commit_list(orig);
+ commit_list_free(orig);
pptr = list;
*list = NULL;
cleanup_return:
free(revs.commit);
- free_commit_list(bases);
+ commit_list_free(bases);
free(full_refname);
return ret;
}
/* Modify list in-place to reverse it, returning new head; list will be tail */
struct commit_list *commit_list_reverse(struct commit_list *list);
-void free_commit_list(struct commit_list *list);
+void commit_list_free(struct commit_list *list);
/*
* Deprecated compatibility functions for `struct commit_list`, to be removed
return commit_list_reverse(l);
}
+static inline void free_commit_list(struct commit_list *l)
+{
+ commit_list_free(l);
+}
+
struct rev_info; /* in revision.h, it circularly uses enum cmit_fmt */
const char *repo_logmsg_reencode(struct repository *r,
(
free(E);
|
- free_commit_list(E);
+ commit_list_free(E);
)
@@
(
free(E);
|
- free_commit_list(E);
+ commit_list_free(E);
)
@@
@@
- if (E)
- {
- free_commit_list(E);
+ commit_list_free(E);
E = NULL;
- }
- if (E) {
+ if (E)
S
- free_commit_list(E);
+ commit_list_free(E);
- }
oidcpy(mb, &merge_bases->item->object.oid);
- free_commit_list(merge_bases);
+ commit_list_free(merge_bases);
}
void run_diff_index(struct rev_info *revs, unsigned int option)
clear_commit_marks((struct commit *)branch, flags);
clear_commit_marks(head, flags);
- free_commit_list(rev->commits);
+ commit_list_free(rev->commits);
rev->commits = NULL;
rev->pending.nr = 0;
* don't follow any other path in history
*/
add_line_range(rev, parent, cand[i]);
- free_commit_list(commit->parents);
+ commit_list_free(commit->parents);
commit_list_append(parent, &commit->parents);
ret = 0;
log_tree_diff_flush(opt);
/* Cleanup */
- free_commit_list(bases);
+ commit_list_free(bases);
cleanup_additional_headers(&opt->diffopt);
strbuf_release(&parent1_desc);
strbuf_release(&parent2_desc);
repo_hold_locked_index(opt->repo, &lock, LOCK_DIE_ON_ERROR);
clean = merge_ort_recursive(opt, head_commit, next_commit, ca,
result);
- free_commit_list(ca);
+ commit_list_free(ca);
if (clean < 0) {
rollback_lock_file(&lock);
return clean;
opt->ancestor = NULL; /* avoid accidental re-use of opt->ancestor */
out:
- free_commit_list(merge_bases);
+ commit_list_free(merge_bases);
}
void merge_incore_nonrecursive(struct merge_options *opt,
commit_list_insert(local, &parents);
create_notes_commit(o->repo, local_tree, parents, o->commit_msg.buf,
o->commit_msg.len, result_oid);
- free_commit_list(parents);
+ commit_list_free(parents);
}
found_result:
- free_commit_list(bases);
+ commit_list_free(bases);
strbuf_release(&(o->commit_msg));
trace_printf("notes_merge(): result = %i, result_oid = %.7s\n",
result, oid_to_hex(result_oid));
NULL))
die("Failed to commit notes tree to database");
- free_commit_list(parents_to_free);
+ commit_list_free(parents_to_free);
}
void commit_notes(struct repository *r, struct notes_tree *t, const char *msg)
commit_list_insert((struct commit *)o, &list);
ret = get_oid_oneline(r, prefix, oid, list);
- free_commit_list(list);
+ commit_list_free(list);
free(prefix);
return ret;
}
if (!two)
return -1;
if (repo_get_merge_bases(r, one, two, &mbs) < 0) {
- free_commit_list(mbs);
+ commit_list_free(mbs);
return -1;
}
if (!mbs || mbs->next)
st = 0;
oidcpy(oid, &mbs->item->object.oid);
}
- free_commit_list(mbs);
+ commit_list_free(mbs);
return st;
}
refs_head_ref(get_main_ref_store(repo), handle_one_ref, &cb);
ret = get_oid_oneline(repo, name + 2, oid, list);
- free_commit_list(list);
+ commit_list_free(list);
return ret;
}
if (namelen < 3 ||
static void clear_bb_commit(struct bb_commit *commit)
{
- free_commit_list(commit->reverse_edges);
+ commit_list_free(commit->reverse_edges);
bitmap_free(commit->commit_mask);
bitmap_free(commit->bitmap);
}
p_ent->maximal = 1;
else {
p_ent->maximal = 0;
- free_commit_list(p_ent->reverse_edges);
+ commit_list_free(p_ent->reverse_edges);
p_ent->reverse_edges = NULL;
}
"num_maximal_commits", num_maximal);
release_revisions(&revs);
- free_commit_list(reusable);
+ commit_list_free(reusable);
}
static void bitmap_builder_clear(struct bitmap_builder *bb)
{
strvec_clear(&filter->exclude);
oid_array_clear(&filter->points_at);
- free_commit_list(filter->with_commit);
- free_commit_list(filter->no_commit);
- free_commit_list(filter->reachable_from);
- free_commit_list(filter->unreachable_from);
+ commit_list_free(filter->with_commit);
+ commit_list_free(filter->no_commit);
+ commit_list_free(filter->reachable_from);
+ commit_list_free(filter->unreachable_from);
ref_filter_init(filter);
}
case UE_HEAD:
for (elem = cb->tips; elem; elem = elem->next)
clear_commit_marks(elem->item, REACHABLE);
- free_commit_list(cb->tips);
+ commit_list_free(cb->tips);
break;
case UE_NORMAL:
clear_commit_marks(cb->tip_commit, REACHABLE);
}
for (elem = cb->mark_list; elem; elem = elem->next)
clear_commit_marks(elem->item, REACHABLE);
- free_commit_list(cb->mark_list);
+ commit_list_free(cb->mark_list);
}
int count_reflog_ent(const char *refname UNUSED,
clear_commit_marks_many(src_commits.nr, src_commits.items,
reachable_flag);
commit_stack_clear(&src_commits);
- free_commit_list(found_commits);
+ commit_list_free(found_commits);
}
string_list_clear(&src_tag, 0);
continue;
}
- free_commit_list(parent->next);
+ commit_list_free(parent->next);
parent->next = NULL;
while (commit->parents != parent)
pop_commit(&commit->parents);
die("cannot simplify commit %s (invalid %s)",
oid_to_hex(&commit->object.oid),
oid_to_hex(&p->object.oid));
- free_commit_list(p->parents);
+ commit_list_free(p->parents);
p->parents = NULL;
}
/* fallthrough */
p->item->object.flags &= ~(TMP_MARK | ANCESTRY_PATH);
for (p = bottoms; p; p = p->next)
p->item->object.flags &= ~(TMP_MARK | ANCESTRY_PATH);
- free_commit_list(rlist);
+ commit_list_free(rlist);
}
/*
}
}
- free_commit_list(original_list);
+ commit_list_free(original_list);
revs->commits = newlist;
return 0;
}
exit(128);
add_rev_cmdline_list(revs, bases, REV_CMD_MERGE_BASE, UNINTERESTING | BOTTOM);
add_pending_commit_list(revs, bases, UNINTERESTING | BOTTOM);
- free_commit_list(bases);
+ commit_list_free(bases);
head->object.flags |= SYMMETRIC_LEFT;
if (!istate->cache_nr)
return dotdot_missing(arg, dotdot, revs, symmetric);
if (repo_get_merge_bases(the_repository, a, b, &exclude) < 0) {
- free_commit_list(exclude);
+ commit_list_free(exclude);
return -1;
}
add_rev_cmdline_list(revs, exclude, REV_CMD_MERGE_BASE,
flags_exclude);
add_pending_commit_list(revs, exclude, flags_exclude);
- free_commit_list(exclude);
+ commit_list_free(exclude);
b_flags = flags;
a_flags = flags | SYMMETRIC_LEFT;
static void free_void_commit_list(void *list)
{
- free_commit_list(list);
+ commit_list_free(list);
}
void release_revisions(struct rev_info *revs)
{
- free_commit_list(revs->commits);
- free_commit_list(revs->ancestry_path_bottoms);
+ commit_list_free(revs->commits);
+ commit_list_free(revs->ancestry_path_bottoms);
release_display_notes(&revs->notes_opt);
object_array_clear(&revs->pending);
object_array_clear(&revs->boundary_commits);
if (i != cnt || cnt+marked != orig_cnt)
die("mark_redundant_parents %d %d %d %d", orig_cnt, cnt, i, marked);
- free_commit_list(h);
+ commit_list_free(h);
return marked;
}
static void free_saved_parent(struct commit_list **parents)
{
if (*parents != EMPTY_PARENT_LIST)
- free_commit_list(*parents);
+ commit_list_free(*parents);
}
static void free_saved_parents(struct rev_info *revs)
if (revs->linear)
commit->object.flags |= TRACK_LINEAR;
}
- free_commit_list(revs->previous_parents);
+ commit_list_free(revs->previous_parents);
revs->previous_parents = commit_list_copy(commit->parents);
}
* boundary commits anyway. (This is what the code has always
* done.)
*/
- free_commit_list(revs->commits);
+ commit_list_free(revs->commits);
revs->commits = NULL;
/*
reversed = NULL;
while ((c = get_revision_internal(revs)))
commit_list_insert(c, &reversed);
- free_commit_list(revs->commits);
+ commit_list_free(revs->commits);
revs->commits = reversed;
revs->reverse = 0;
revs->reverse_output_stage = 1;
graph_update(revs->graph, c);
if (!c) {
free_saved_parents(revs);
- free_commit_list(revs->previous_parents);
+ commit_list_free(revs->previous_parents);
revs->previous_parents = NULL;
}
return c;
out:
free_commit_extra_headers(extra);
- free_commit_list(parents);
+ commit_list_free(parents);
strbuf_release(&err);
strbuf_release(&commit_msg);
free(amend_author);
res |= try_merge_command(r, opts->strategy,
opts->xopts.nr, opts->xopts.v,
common, oid_to_hex(&head), remotes);
- free_commit_list(common);
- free_commit_list(remotes);
+ commit_list_free(common);
+ commit_list_free(remotes);
}
/*
leave_merge:
strbuf_release(&ref_name);
rollback_lock_file(&lock);
- free_commit_list(to_merge);
- free_commit_list(bases);
+ commit_list_free(to_merge);
+ commit_list_free(bases);
return ret;
}
oidset_insert(&shown, oid);
}
- free_commit_list(list);
+ commit_list_free(list);
}
- free_commit_list(commits);
- free_commit_list(tips);
+ commit_list_free(commits);
+ commit_list_free(tips);
strbuf_release(&label_from_message);
strbuf_release(&oneline);
oidcpy(&graft->oid, oid);
graft->nr_parent = -1;
if (commit && commit->object.parsed) {
- free_commit_list(commit->parents);
+ commit_list_free(commit->parents);
commit->parents = NULL;
}
return register_commit_graft(r, graft, 0);
break;
}
}
- free_commit_list(not_shallow_list);
+ commit_list_free(not_shallow_list);
/*
* Now we can clean up NOT_SHALLOW on border commits. Having
print_submodule_diff_summary(sub, &rev, o);
out:
- free_commit_list(merge_bases);
+ commit_list_free(merge_bases);
release_revisions(&rev);
clear_commit_marks(left, ~0);
clear_commit_marks(right, ~0);
done:
strbuf_release(&sb);
- free_commit_list(merge_bases);
+ commit_list_free(merge_bases);
if (left)
clear_commit_marks(left, ~0);
if (right)
exit(128);
printf("%s(A,X):\n", av[1]);
print_sorted_commit_ids(list);
- free_commit_list(list);
+ commit_list_free(list);
} else if (!strcmp(av[1], "reduce_heads")) {
struct commit_list *list = reduce_heads(X);
printf("%s(X):\n", av[1]);
print_sorted_commit_ids(list);
- free_commit_list(list);
+ commit_list_free(list);
} else if (!strcmp(av[1], "can_all_from_reach")) {
printf("%s(X,Y):%d\n", av[1], can_all_from_reach(X, Y, 1));
} else if (!strcmp(av[1], "can_all_from_reach_with_flag")) {
die(_("too many commits marked reachable"));
print_sorted_commit_ids(list);
- free_commit_list(list);
+ commit_list_free(list);
}
object_array_clear(&X_obj);
strbuf_release(&buf);
- free_commit_list(X);
- free_commit_list(Y);
+ commit_list_free(X);
+ commit_list_free(Y);
commit_stack_clear(&X_stack);
commit_stack_clear(&Y_stack);
return 0;
projects / thirdparty / git.git / commitdiff
