vendor/libgit2-sys/libgit2/examples/merge.c - toolchain/rustc - Git at Google

 /*
  * libgit2 "merge" example - shows how to perform merges
  *
  * Written by the libgit2 contributors
  *
  * To the extent possible under law, the author(s) have dedicated all copyright
  * and related and neighboring rights to this software to the public domain
  * worldwide. This software is distributed without any warranty.
  *
  * You should have received a copy of the CC0 Public Domain Dedication along
  * with this software. If not, see
  * <http://creativecommons.org/publicdomain/zero/1.0/>.
  */

 #include "common.h"
 #include <assert.h>

 #ifdef _MSC_VER
 #define snprintf sprintf_s
 #endif

 /** The following example demonstrates how to do merges with libgit2.
  *
  * It will merge whatever commit-ish you pass in into the current branch.
  *
  * Recognized options are :
  *  --no-commit: don't actually commit the merge.
  *
  */

 typedef struct {
 	const char **heads;
 	size_t heads_count;

 	git_annotated_commit **annotated;
 	size_t annotated_count;

 	int no_commit : 1;
 } merge_options;

 static void print_usage(void)
 {
 	fprintf(stderr, "usage: merge [--no-commit] <commit...>\n");
 	exit(1);
 }

 static void merge_options_init(merge_options *opts)
 {
 	memset(opts, 0, sizeof(*opts));

 	opts->heads = NULL;
 	opts->heads_count = 0;
 	opts->annotated = NULL;
 	opts->annotated_count = 0;
 }

 static void opts_add_refish(merge_options *opts, const char *refish)
 {
 	size_t sz;

 	assert(opts != NULL);

 	sz = ++opts->heads_count * sizeof(opts->heads[0]);
 	opts->heads = xrealloc(opts->heads, sz);
 	opts->heads[opts->heads_count - 1] = refish;
 }

 static void parse_options(const char **repo_path, merge_options *opts, int argc, char **argv)
 {
 	struct args_info args = ARGS_INFO_INIT;

 	if (argc <= 1)
 		print_usage();

 	for (args.pos = 1; args.pos < argc; ++args.pos) {
 		const char *curr = argv[args.pos];

 		if (curr[0] != '-') {
 			opts_add_refish(opts, curr);
 		} else if (!strcmp(curr, "--no-commit")) {
 			opts->no_commit = 1;
 		} else if (match_str_arg(repo_path, &args, "--git-dir")) {
 			continue;
 		} else {
 			print_usage();
 		}
 	}
 }

 static int resolve_heads(git_repository *repo, merge_options *opts)
 {
 	git_annotated_commit **annotated = calloc(opts->heads_count, sizeof(git_annotated_commit *));
 	size_t annotated_count = 0, i;
 	int err = 0;

 	for (i = 0; i < opts->heads_count; i++) {
 		err = resolve_refish(&annotated[annotated_count++], repo, opts->heads[i]);
 		if (err != 0) {
 			fprintf(stderr, "failed to resolve refish %s: %s\n", opts->heads[i], git_error_last()->message);
 			annotated_count--;
 			continue;
 		}
 	}

 	if (annotated_count != opts->heads_count) {
 		fprintf(stderr, "unable to parse some refish\n");
 		free(annotated);
 		return -1;
 	}

 	opts->annotated = annotated;
 	opts->annotated_count = annotated_count;
 	return 0;
 }

 static int perform_fastforward(git_repository *repo, const git_oid *target_oid, int is_unborn)
 {
 	git_checkout_options ff_checkout_options = GIT_CHECKOUT_OPTIONS_INIT;
 	git_reference *target_ref;
 	git_reference *new_target_ref;
 	git_object *target = NULL;
 	int err = 0;

 	if (is_unborn) {
 		const char *symbolic_ref;
 		git_reference *head_ref;

 		/* HEAD reference is unborn, lookup manually so we don't try to resolve it */
 		err = git_reference_lookup(&head_ref, repo, "HEAD");
 		if (err != 0) {
 			fprintf(stderr, "failed to lookup HEAD ref\n");
 			return -1;
 		}

 		/* Grab the reference HEAD should be pointing to */
 		symbolic_ref = git_reference_symbolic_target(head_ref);

 		/* Create our master reference on the target OID */
 		err = git_reference_create(&target_ref, repo, symbolic_ref, target_oid, 0, NULL);
 		if (err != 0) {
 			fprintf(stderr, "failed to create master reference\n");
 			return -1;
 		}

 		git_reference_free(head_ref);
 	} else {
 		/* HEAD exists, just lookup and resolve */
 		err = git_repository_head(&target_ref, repo);
 		if (err != 0) {
 			fprintf(stderr, "failed to get HEAD reference\n");
 			return -1;
 		}
 	}

 	/* Lookup the target object */
 	err = git_object_lookup(&target, repo, target_oid, GIT_OBJECT_COMMIT);
 	if (err != 0) {
 		fprintf(stderr, "failed to lookup OID %s\n", git_oid_tostr_s(target_oid));
 		return -1;
 	}

 	/* Checkout the result so the workdir is in the expected state */
 	ff_checkout_options.checkout_strategy = GIT_CHECKOUT_SAFE;
 	err = git_checkout_tree(repo, target, &ff_checkout_options);
 	if (err != 0) {
 		fprintf(stderr, "failed to checkout HEAD reference\n");
 		return -1;
 	}

 	/* Move the target reference to the target OID */
 	err = git_reference_set_target(&new_target_ref, target_ref, target_oid, NULL);
 	if (err != 0) {
 		fprintf(stderr, "failed to move HEAD reference\n");
 		return -1;
 	}

 	git_reference_free(target_ref);
 	git_reference_free(new_target_ref);
 	git_object_free(target);

 	return 0;
 }

 static void output_conflicts(git_index *index)
 {
 	git_index_conflict_iterator *conflicts;
 	const git_index_entry *ancestor;
 	const git_index_entry *our;
 	const git_index_entry *their;
 	int err = 0;

 	check_lg2(git_index_conflict_iterator_new(&conflicts, index), "failed to create conflict iterator", NULL);

 	while ((err = git_index_conflict_next(&ancestor, &our, &their, conflicts)) == 0) {
 		fprintf(stderr, "conflict: a:%s o:%s t:%s\n",
 		        ancestor ? ancestor->path : "NULL",
 		        our->path ? our->path : "NULL",
 		        their->path ? their->path : "NULL");
 	}

 	if (err != GIT_ITEROVER) {
 		fprintf(stderr, "error iterating conflicts\n");
 	}

 	git_index_conflict_iterator_free(conflicts);
 }

 static int create_merge_commit(git_repository *repo, git_index *index, merge_options *opts)
 {
 	git_oid tree_oid, commit_oid;
 	git_tree *tree;
 	git_signature *sign;
 	git_reference *merge_ref = NULL;
 	git_annotated_commit *merge_commit;
 	git_reference *head_ref;
 	git_commit **parents = calloc(opts->annotated_count + 1, sizeof(git_commit *));
 	const char *msg_target = NULL;
 	size_t msglen = 0;
 	char *msg;
 	size_t i;
 	int err;

 	/* Grab our needed references */
 	check_lg2(git_repository_head(&head_ref, repo), "failed to get repo HEAD", NULL);
 	if (resolve_refish(&merge_commit, repo, opts->heads[0])) {
 		fprintf(stderr, "failed to resolve refish %s", opts->heads[0]);
 		return -1;
 	}

 	/* Maybe that's a ref, so DWIM it */
 	err = git_reference_dwim(&merge_ref, repo, opts->heads[0]);
 	check_lg2(err, "failed to DWIM reference", git_error_last()->message);

 	/* Grab a signature */
 	check_lg2(git_signature_now(&sign, "Me", "[email protected]"), "failed to create signature", NULL);

 #define MERGE_COMMIT_MSG "Merge %s '%s'"
 	/* Prepare a standard merge commit message */
 	if (merge_ref != NULL) {
 		check_lg2(git_branch_name(&msg_target, merge_ref), "failed to get branch name of merged ref", NULL);
 	} else {
 		msg_target = git_oid_tostr_s(git_annotated_commit_id(merge_commit));
 	}

 	msglen = snprintf(NULL, 0, MERGE_COMMIT_MSG, (merge_ref ? "branch" : "commit"), msg_target);
 	if (msglen > 0) msglen++;
 	msg = malloc(msglen);
 	err = snprintf(msg, msglen, MERGE_COMMIT_MSG, (merge_ref ? "branch" : "commit"), msg_target);

 	/* This is only to silence the compiler */
 	if (err < 0) goto cleanup;

 	/* Setup our parent commits */
 	err = git_reference_peel((git_object **)&parents[0], head_ref, GIT_OBJECT_COMMIT);
 	check_lg2(err, "failed to peel head reference", NULL);
 	for (i = 0; i < opts->annotated_count; i++) {
 		git_commit_lookup(&parents[i + 1], repo, git_annotated_commit_id(opts->annotated[i]));
 	}

 	/* Prepare our commit tree */
 	check_lg2(git_index_write_tree(&tree_oid, index), "failed to write merged tree", NULL);
 	check_lg2(git_tree_lookup(&tree, repo, &tree_oid), "failed to lookup tree", NULL);

 	/* Commit time ! */
 	err = git_commit_create(&commit_oid,
 	                        repo, git_reference_name(head_ref),
 	                        sign, sign,
 	                        NULL, msg,
 	                        tree,
 	                        opts->annotated_count + 1, (const git_commit **)parents);
 	check_lg2(err, "failed to create commit", NULL);

 	/* We're done merging, cleanup the repository state */
 	git_repository_state_cleanup(repo);

 cleanup:
 	free(parents);
 	return err;
 }

 int main(int argc, char **argv)
 {
 	git_repository *repo = NULL;
 	merge_options opts;
 	git_index *index;
 	git_repository_state_t state;
 	git_merge_analysis_t analysis;
 	git_merge_preference_t preference;
 	const char *path = ".";
 	int err = 0;

 	merge_options_init(&opts);
 	parse_options(&path, &opts, argc, argv);

 	git_libgit2_init();

 	check_lg2(git_repository_open_ext(&repo, path, 0, NULL),
 	          "Could not open repository", NULL);

 	state = git_repository_state(repo);
 	if (state != GIT_REPOSITORY_STATE_NONE) {
 		fprintf(stderr, "repository is in unexpected state %d\n", state);
 		goto cleanup;
 	}

 	err = resolve_heads(repo, &opts);
 	if (err != 0)
 		goto cleanup;

 	err = git_merge_analysis(&analysis, &preference,
 	                         repo,
 	                         (const git_annotated_commit **)opts.annotated,
 	                         opts.annotated_count);
 	check_lg2(err, "merge analysis failed", NULL);

 	if (analysis & GIT_MERGE_ANALYSIS_UP_TO_DATE) {
 		printf("Already up-to-date\n");
 		return 0;
 	} else if (analysis & GIT_MERGE_ANALYSIS_UNBORN ||
 	          (analysis & GIT_MERGE_ANALYSIS_FASTFORWARD &&
 	          !(preference & GIT_MERGE_PREFERENCE_NO_FASTFORWARD))) {
 		const git_oid *target_oid;
 		if (analysis & GIT_MERGE_ANALYSIS_UNBORN) {
 			printf("Unborn\n");
 		} else {
 			printf("Fast-forward\n");
 		}

 		/* Since this is a fast-forward, there can be only one merge head */
 		target_oid = git_annotated_commit_id(opts.annotated[0]);
 		assert(opts.annotated_count == 1);

 		return perform_fastforward(repo, target_oid, (analysis & GIT_MERGE_ANALYSIS_UNBORN));
 	} else if (analysis & GIT_MERGE_ANALYSIS_NORMAL) {
 		git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT;
 		git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;

 		merge_opts.flags = 0;
 		merge_opts.file_flags = GIT_MERGE_FILE_STYLE_DIFF3;

 		checkout_opts.checkout_strategy = GIT_CHECKOUT_FORCE|GIT_CHECKOUT_ALLOW_CONFLICTS;

 		if (preference & GIT_MERGE_PREFERENCE_FASTFORWARD_ONLY) {
 			printf("Fast-forward is preferred, but only a merge is possible\n");
 			return -1;
 		}

 		err = git_merge(repo,
 		                (const git_annotated_commit **)opts.annotated, opts.annotated_count,
 		                &merge_opts, &checkout_opts);
 		check_lg2(err, "merge failed", NULL);
 	}

 	/* If we get here, we actually performed the merge above */

 	check_lg2(git_repository_index(&index, repo), "failed to get repository index", NULL);

 	if (git_index_has_conflicts(index)) {
 		/* Handle conflicts */
 		output_conflicts(index);
 	} else if (!opts.no_commit) {
 		create_merge_commit(repo, index, &opts);
 		printf("Merge made\n");
 	}

 cleanup:
 	free(opts.heads);
 	free(opts.annotated);
 	git_repository_free(repo);
 	git_libgit2_shutdown();

 	return 0;
 }
	/*
	* libgit2 "merge" example - shows how to perform merges
	*
	* Written by the libgit2 contributors
	*
	* To the extent possible under law, the author(s) have dedicated all copyright
	* and related and neighboring rights to this software to the public domain
	* worldwide. This software is distributed without any warranty.
	*
	* You should have received a copy of the CC0 Public Domain Dedication along
	* with this software. If not, see
	* <http://creativecommons.org/publicdomain/zero/1.0/>.
	*/

	#include "common.h"
	#include <assert.h>

	#ifdef _MSC_VER
	#define snprintf sprintf_s
	#endif

	/** The following example demonstrates how to do merges with libgit2.
	*
	* It will merge whatever commit-ish you pass in into the current branch.
	*
	* Recognized options are :
	* --no-commit: don't actually commit the merge.
	*
	*/

	typedef struct {
	const char **heads;
	size_t heads_count;

	git_annotated_commit **annotated;
	size_t annotated_count;

	int no_commit : 1;
	} merge_options;

	static void print_usage(void)
	{
	fprintf(stderr, "usage: merge [--no-commit] <commit...>\n");
	exit(1);
	}

	static void merge_options_init(merge_options *opts)
	{
	memset(opts, 0, sizeof(*opts));

	opts->heads = NULL;
	opts->heads_count = 0;
	opts->annotated = NULL;
	opts->annotated_count = 0;
	}

	static void opts_add_refish(merge_options opts, const char refish)
	{
	size_t sz;

	assert(opts != NULL);

	sz = ++opts->heads_count * sizeof(opts->heads[0]);
	opts->heads = xrealloc(opts->heads, sz);
	opts->heads[opts->heads_count - 1] = refish;
	}

	static void parse_options(const char *repo_path, merge_options opts, int argc, char **argv)
	{
	struct args_info args = ARGS_INFO_INIT;

	if (argc <= 1)
	print_usage();

	for (args.pos = 1; args.pos < argc; ++args.pos) {
	const char *curr = argv[args.pos];

	if (curr[0] != '-') {
	opts_add_refish(opts, curr);
	} else if (!strcmp(curr, "--no-commit")) {
	opts->no_commit = 1;
	} else if (match_str_arg(repo_path, &args, "--git-dir")) {
	continue;
	} else {
	print_usage();
	}
	}
	}

	static int resolve_heads(git_repository repo, merge_options opts)
	{
	git_annotated_commit *annotated = calloc(opts->heads_count, sizeof(git_annotated_commit ));
	size_t annotated_count = 0, i;
	int err = 0;

	for (i = 0; i < opts->heads_count; i++) {
	err = resolve_refish(&annotated[annotated_count++], repo, opts->heads[i]);
	if (err != 0) {
	fprintf(stderr, "failed to resolve refish %s: %s\n", opts->heads[i], git_error_last()->message);
	annotated_count--;
	continue;
	}
	}

	if (annotated_count != opts->heads_count) {
	fprintf(stderr, "unable to parse some refish\n");
	free(annotated);
	return -1;
	}

	opts->annotated = annotated;
	opts->annotated_count = annotated_count;
	return 0;
	}

	static int perform_fastforward(git_repository repo, const git_oid target_oid, int is_unborn)
	{
	git_checkout_options ff_checkout_options = GIT_CHECKOUT_OPTIONS_INIT;
	git_reference *target_ref;
	git_reference *new_target_ref;
	git_object *target = NULL;
	int err = 0;

	if (is_unborn) {
	const char *symbolic_ref;
	git_reference *head_ref;

	/* HEAD reference is unborn, lookup manually so we don't try to resolve it */
	err = git_reference_lookup(&head_ref, repo, "HEAD");
	if (err != 0) {
	fprintf(stderr, "failed to lookup HEAD ref\n");
	return -1;
	}

	/* Grab the reference HEAD should be pointing to */
	symbolic_ref = git_reference_symbolic_target(head_ref);

	/* Create our master reference on the target OID */
	err = git_reference_create(&target_ref, repo, symbolic_ref, target_oid, 0, NULL);
	if (err != 0) {
	fprintf(stderr, "failed to create master reference\n");
	return -1;
	}

	git_reference_free(head_ref);
	} else {
	/* HEAD exists, just lookup and resolve */
	err = git_repository_head(&target_ref, repo);
	if (err != 0) {
	fprintf(stderr, "failed to get HEAD reference\n");
	return -1;
	}
	}

	/* Lookup the target object */
	err = git_object_lookup(&target, repo, target_oid, GIT_OBJECT_COMMIT);
	if (err != 0) {
	fprintf(stderr, "failed to lookup OID %s\n", git_oid_tostr_s(target_oid));
	return -1;
	}

	/* Checkout the result so the workdir is in the expected state */
	ff_checkout_options.checkout_strategy = GIT_CHECKOUT_SAFE;
	err = git_checkout_tree(repo, target, &ff_checkout_options);
	if (err != 0) {
	fprintf(stderr, "failed to checkout HEAD reference\n");
	return -1;
	}

	/* Move the target reference to the target OID */
	err = git_reference_set_target(&new_target_ref, target_ref, target_oid, NULL);
	if (err != 0) {
	fprintf(stderr, "failed to move HEAD reference\n");
	return -1;
	}

	git_reference_free(target_ref);
	git_reference_free(new_target_ref);
	git_object_free(target);

	return 0;
	}

	static void output_conflicts(git_index *index)
	{
	git_index_conflict_iterator *conflicts;
	const git_index_entry *ancestor;
	const git_index_entry *our;
	const git_index_entry *their;
	int err = 0;

	check_lg2(git_index_conflict_iterator_new(&conflicts, index), "failed to create conflict iterator", NULL);

	while ((err = git_index_conflict_next(&ancestor, &our, &their, conflicts)) == 0) {
	fprintf(stderr, "conflict: a:%s o:%s t:%s\n",
	ancestor ? ancestor->path : "NULL",
	our->path ? our->path : "NULL",
	their->path ? their->path : "NULL");
	}

	if (err != GIT_ITEROVER) {
	fprintf(stderr, "error iterating conflicts\n");
	}

	git_index_conflict_iterator_free(conflicts);
	}

	static int create_merge_commit(git_repository repo, git_index index, merge_options *opts)
	{
	git_oid tree_oid, commit_oid;
	git_tree *tree;
	git_signature *sign;
	git_reference *merge_ref = NULL;
	git_annotated_commit *merge_commit;
	git_reference *head_ref;
	git_commit *parents = calloc(opts->annotated_count + 1, sizeof(git_commit ));
	const char *msg_target = NULL;
	size_t msglen = 0;
	char *msg;
	size_t i;
	int err;

	/* Grab our needed references */
	check_lg2(git_repository_head(&head_ref, repo), "failed to get repo HEAD", NULL);
	if (resolve_refish(&merge_commit, repo, opts->heads[0])) {
	fprintf(stderr, "failed to resolve refish %s", opts->heads[0]);
	return -1;
	}

	/* Maybe that's a ref, so DWIM it */
	err = git_reference_dwim(&merge_ref, repo, opts->heads[0]);
	check_lg2(err, "failed to DWIM reference", git_error_last()->message);

	/* Grab a signature */
	check_lg2(git_signature_now(&sign, "Me", "[email protected]"), "failed to create signature", NULL);

	#define MERGE_COMMIT_MSG "Merge %s '%s'"
	/* Prepare a standard merge commit message */
	if (merge_ref != NULL) {
	check_lg2(git_branch_name(&msg_target, merge_ref), "failed to get branch name of merged ref", NULL);
	} else {
	msg_target = git_oid_tostr_s(git_annotated_commit_id(merge_commit));
	}

	msglen = snprintf(NULL, 0, MERGE_COMMIT_MSG, (merge_ref ? "branch" : "commit"), msg_target);
	if (msglen > 0) msglen++;
	msg = malloc(msglen);
	err = snprintf(msg, msglen, MERGE_COMMIT_MSG, (merge_ref ? "branch" : "commit"), msg_target);

	/* This is only to silence the compiler */
	if (err < 0) goto cleanup;

	/* Setup our parent commits */
	err = git_reference_peel((git_object **)&parents[0], head_ref, GIT_OBJECT_COMMIT);
	check_lg2(err, "failed to peel head reference", NULL);
	for (i = 0; i < opts->annotated_count; i++) {
	git_commit_lookup(&parents[i + 1], repo, git_annotated_commit_id(opts->annotated[i]));
	}

	/* Prepare our commit tree */
	check_lg2(git_index_write_tree(&tree_oid, index), "failed to write merged tree", NULL);
	check_lg2(git_tree_lookup(&tree, repo, &tree_oid), "failed to lookup tree", NULL);

	/* Commit time ! */
	err = git_commit_create(&commit_oid,
	repo, git_reference_name(head_ref),
	sign, sign,
	NULL, msg,
	tree,
	opts->annotated_count + 1, (const git_commit **)parents);
	check_lg2(err, "failed to create commit", NULL);

	/* We're done merging, cleanup the repository state */
	git_repository_state_cleanup(repo);

	cleanup:
	free(parents);
	return err;
	}

	int main(int argc, char **argv)
	{
	git_repository *repo = NULL;
	merge_options opts;
	git_index *index;
	git_repository_state_t state;
	git_merge_analysis_t analysis;
	git_merge_preference_t preference;
	const char *path = ".";
	int err = 0;

	merge_options_init(&opts);
	parse_options(&path, &opts, argc, argv);

	git_libgit2_init();

	check_lg2(git_repository_open_ext(&repo, path, 0, NULL),
	"Could not open repository", NULL);

	state = git_repository_state(repo);
	if (state != GIT_REPOSITORY_STATE_NONE) {
	fprintf(stderr, "repository is in unexpected state %d\n", state);
	goto cleanup;
	}

	err = resolve_heads(repo, &opts);
	if (err != 0)
	goto cleanup;

	err = git_merge_analysis(&analysis, &preference,
	repo,
	(const git_annotated_commit **)opts.annotated,
	opts.annotated_count);
	check_lg2(err, "merge analysis failed", NULL);

	if (analysis & GIT_MERGE_ANALYSIS_UP_TO_DATE) {
	printf("Already up-to-date\n");
	return 0;
	} else if (analysis & GIT_MERGE_ANALYSIS_UNBORN \|\|
	(analysis & GIT_MERGE_ANALYSIS_FASTFORWARD &&
	!(preference & GIT_MERGE_PREFERENCE_NO_FASTFORWARD))) {
	const git_oid *target_oid;
	if (analysis & GIT_MERGE_ANALYSIS_UNBORN) {
	printf("Unborn\n");
	} else {
	printf("Fast-forward\n");
	}

	/* Since this is a fast-forward, there can be only one merge head */
	target_oid = git_annotated_commit_id(opts.annotated[0]);
	assert(opts.annotated_count == 1);

	return perform_fastforward(repo, target_oid, (analysis & GIT_MERGE_ANALYSIS_UNBORN));
	} else if (analysis & GIT_MERGE_ANALYSIS_NORMAL) {
	git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT;
	git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;

	merge_opts.flags = 0;
	merge_opts.file_flags = GIT_MERGE_FILE_STYLE_DIFF3;

	checkout_opts.checkout_strategy = GIT_CHECKOUT_FORCE\|GIT_CHECKOUT_ALLOW_CONFLICTS;

	if (preference & GIT_MERGE_PREFERENCE_FASTFORWARD_ONLY) {
	printf("Fast-forward is preferred, but only a merge is possible\n");
	return -1;
	}

	err = git_merge(repo,
	(const git_annotated_commit **)opts.annotated, opts.annotated_count,
	&merge_opts, &checkout_opts);
	check_lg2(err, "merge failed", NULL);
	}

	/* If we get here, we actually performed the merge above */

	check_lg2(git_repository_index(&index, repo), "failed to get repository index", NULL);

	if (git_index_has_conflicts(index)) {
	/* Handle conflicts */
	output_conflicts(index);
	} else if (!opts.no_commit) {
	create_merge_commit(repo, index, &opts);
	printf("Merge made\n");
	}

	cleanup:
	free(opts.heads);
	free(opts.annotated);
	git_repository_free(repo);
	git_libgit2_shutdown();

	return 0;
	}