[thirdparty/git.git] / builtin / reflog.c

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"
#include "config.h"
#include "gettext.h"
#include "revision.h"
#include "reachable.h"
#include "wildmatch.h"
#include "worktree.h"
#include "reflog.h"
#include "refs.h"
#include "parse-options.h"

#define BUILTIN_REFLOG_SHOW_USAGE \
	N_("git reflog [show] [<log-options>] [<ref>]")

#define BUILTIN_REFLOG_LIST_USAGE \
	N_("git reflog list")

#define BUILTIN_REFLOG_EXPIRE_USAGE \
	N_("git reflog expire [--expire=<time>] [--expire-unreachable=<time>]\n" \
	   "                  [--rewrite] [--updateref] [--stale-fix]\n" \
	   "                  [--dry-run | -n] [--verbose] [--all [--single-worktree] | <refs>...]")

#define BUILTIN_REFLOG_DELETE_USAGE \
	N_("git reflog delete [--rewrite] [--updateref]\n" \
	   "                  [--dry-run | -n] [--verbose] <ref>@{<specifier>}...")

#define BUILTIN_REFLOG_EXISTS_USAGE \
	N_("git reflog exists <ref>")

#define BUILTIN_REFLOG_DROP_USAGE \
	N_("git reflog drop [--all [--single-worktree] | <refs>...]")

static const char *const reflog_show_usage[] = {
	BUILTIN_REFLOG_SHOW_USAGE,
	NULL,
};

static const char *const reflog_list_usage[] = {
	BUILTIN_REFLOG_LIST_USAGE,
	NULL,
};

static const char *const reflog_expire_usage[] = {
	BUILTIN_REFLOG_EXPIRE_USAGE,
	NULL
};

static const char *const reflog_delete_usage[] = {
	BUILTIN_REFLOG_DELETE_USAGE,
	NULL
};

static const char *const reflog_exists_usage[] = {
	BUILTIN_REFLOG_EXISTS_USAGE,
	NULL,
};

static const char *const reflog_drop_usage[] = {
	BUILTIN_REFLOG_DROP_USAGE,
	NULL,
};

static const char *const reflog_usage[] = {
	BUILTIN_REFLOG_SHOW_USAGE,
	BUILTIN_REFLOG_LIST_USAGE,
	BUILTIN_REFLOG_EXPIRE_USAGE,
	BUILTIN_REFLOG_DELETE_USAGE,
	BUILTIN_REFLOG_DROP_USAGE,
	BUILTIN_REFLOG_EXISTS_USAGE,
	NULL
};

struct worktree_reflogs {
	struct worktree *worktree;
	struct string_list reflogs;
};

static int collect_reflog(const char *ref, void *cb_data)
{
	struct worktree_reflogs *cb = cb_data;
	struct worktree *worktree = cb->worktree;
	struct strbuf newref = STRBUF_INIT;

	/*
	 * Avoid collecting the same shared ref multiple times because
	 * they are available via all worktrees.
	 */
	if (!worktree->is_current &&
	    parse_worktree_ref(ref, NULL, NULL, NULL) == REF_WORKTREE_SHARED)
		return 0;

	strbuf_worktree_ref(worktree, &newref, ref);
	string_list_append_nodup(&cb->reflogs, strbuf_detach(&newref, NULL));

	return 0;
}

static int expire_unreachable_callback(const struct option *opt,
				 const char *arg,
				 int unset)
{
	struct reflog_expire_options *opts = opt->value;

	BUG_ON_OPT_NEG(unset);

	if (parse_expiry_date(arg, &opts->expire_unreachable))
		die(_("invalid timestamp '%s' given to '--%s'"),
		    arg, opt->long_name);

	opts->explicit_expiry |= REFLOG_EXPIRE_UNREACH;
	return 0;
}

static int expire_total_callback(const struct option *opt,
				 const char *arg,
				 int unset)
{
	struct reflog_expire_options *opts = opt->value;

	BUG_ON_OPT_NEG(unset);

	if (parse_expiry_date(arg, &opts->expire_total))
		die(_("invalid timestamp '%s' given to '--%s'"),
		    arg, opt->long_name);

	opts->explicit_expiry |= REFLOG_EXPIRE_TOTAL;
	return 0;
}

static int cmd_reflog_show(int argc, const char **argv, const char *prefix,
			   struct repository *repo UNUSED)
{
	struct option options[] = {
		OPT_END()
	};

	parse_options(argc, argv, prefix, options, reflog_show_usage,
		      PARSE_OPT_KEEP_DASHDASH | PARSE_OPT_KEEP_ARGV0 |
		      PARSE_OPT_KEEP_UNKNOWN_OPT);

	return cmd_log_reflog(argc, argv, prefix, the_repository);
}

static int show_reflog(const char *refname, void *cb_data UNUSED)
{
	printf("%s\n", refname);
	return 0;
}

static int cmd_reflog_list(int argc, const char **argv, const char *prefix,
			   struct repository *repo UNUSED)
{
	struct option options[] = {
		OPT_END()
	};
	struct ref_store *ref_store;

	argc = parse_options(argc, argv, prefix, options, reflog_list_usage, 0);
	if (argc)
		return error(_("%s does not accept arguments: '%s'"),
			     "list", argv[0]);

	ref_store = get_main_ref_store(the_repository);

	return refs_for_each_reflog(ref_store, show_reflog, NULL);
}

static int cmd_reflog_expire(int argc, const char **argv, const char *prefix,
			     struct repository *repo UNUSED)
{
	timestamp_t now = time(NULL);
	struct reflog_expire_options opts = REFLOG_EXPIRE_OPTIONS_INIT(now);
	int i, status, do_all, single_worktree = 0;
	unsigned int flags = 0;
	int verbose = 0;
	reflog_expiry_should_prune_fn *should_prune_fn = should_expire_reflog_ent;
	const struct option options[] = {
		OPT_BIT('n', "dry-run", &flags, N_("do not actually prune any entries"),
			EXPIRE_REFLOGS_DRY_RUN),
		OPT_BIT(0, "rewrite", &flags,
			N_("rewrite the old SHA1 with the new SHA1 of the entry that now precedes it"),
			EXPIRE_REFLOGS_REWRITE),
		OPT_BIT(0, "updateref", &flags,
			N_("update the reference to the value of the top reflog entry"),
			EXPIRE_REFLOGS_UPDATE_REF),
		OPT_BOOL(0, "verbose", &verbose, N_("print extra information on screen")),
		OPT_CALLBACK_F(0, "expire", &opts, N_("timestamp"),
			       N_("prune entries older than the specified time"),
			       PARSE_OPT_NONEG,
			       expire_total_callback),
		OPT_CALLBACK_F(0, "expire-unreachable", &opts, N_("timestamp"),
			       N_("prune entries older than <time> that are not reachable from the current tip of the branch"),
			       PARSE_OPT_NONEG,
			       expire_unreachable_callback),
		OPT_BOOL(0, "stale-fix", &opts.stalefix,
			 N_("prune any reflog entries that point to broken commits")),
		OPT_BOOL(0, "all", &do_all, N_("process the reflogs of all references")),
		OPT_BOOL(0, "single-worktree", &single_worktree,
			 N_("limits processing to reflogs from the current worktree only")),
		OPT_END()
	};

	git_config(reflog_expire_config, &opts);

	save_commit_buffer = 0;
	do_all = status = 0;

	argc = parse_options(argc, argv, prefix, options, reflog_expire_usage, 0);

	if (verbose)
		should_prune_fn = should_expire_reflog_ent_verbose;

	/*
	 * We can trust the commits and objects reachable from refs
	 * even in older repository.  We cannot trust what's reachable
	 * from reflog if the repository was pruned with older git.
	 */
	if (opts.stalefix) {
		struct rev_info revs;

		repo_init_revisions(the_repository, &revs, prefix);
		revs.do_not_die_on_missing_objects = 1;
		revs.ignore_missing = 1;
		revs.ignore_missing_links = 1;
		if (verbose)
			printf(_("Marking reachable objects..."));
		mark_reachable_objects(&revs, 0, 0, NULL);
		release_revisions(&revs);
		if (verbose)
			putchar('\n');
	}

	if (do_all) {
		struct worktree_reflogs collected = {
			.reflogs = STRING_LIST_INIT_DUP,
		};
		struct string_list_item *item;
		struct worktree **worktrees, **p;

		worktrees = get_worktrees();
		for (p = worktrees; *p; p++) {
			if (single_worktree && !(*p)->is_current)
				continue;
			collected.worktree = *p;
			refs_for_each_reflog(get_worktree_ref_store(*p),
					     collect_reflog, &collected);
		}
		free_worktrees(worktrees);

		for_each_string_list_item(item, &collected.reflogs) {
			struct expire_reflog_policy_cb cb = {
				.opts = opts,
				.dry_run = !!(flags & EXPIRE_REFLOGS_DRY_RUN),
			};

			reflog_expire_options_set_refname(&cb.opts,  item->string);
			status |= refs_reflog_expire(get_main_ref_store(the_repository),
						     item->string, flags,
						     reflog_expiry_prepare,
						     should_prune_fn,
						     reflog_expiry_cleanup,
						     &cb);
		}
		string_list_clear(&collected.reflogs, 0);
	}

	for (i = 0; i < argc; i++) {
		char *ref;
		struct expire_reflog_policy_cb cb = { .opts = opts };

		if (!repo_dwim_log(the_repository, argv[i], strlen(argv[i]), NULL, &ref)) {
			status |= error(_("reflog could not be found: '%s'"), argv[i]);
			continue;
		}
		reflog_expire_options_set_refname(&cb.opts, ref);
		status |= refs_reflog_expire(get_main_ref_store(the_repository),
					     ref, flags,
					     reflog_expiry_prepare,
					     should_prune_fn,
					     reflog_expiry_cleanup,
					     &cb);
		free(ref);
	}
	return status;
}

static int cmd_reflog_delete(int argc, const char **argv, const char *prefix,
			     struct repository *repo UNUSED)
{
	int i, status = 0;
	unsigned int flags = 0;
	int verbose = 0;

	const struct option options[] = {
		OPT_BIT('n', "dry-run", &flags, N_("do not actually prune any entries"),
			EXPIRE_REFLOGS_DRY_RUN),
		OPT_BIT(0, "rewrite", &flags,
			N_("rewrite the old SHA1 with the new SHA1 of the entry that now precedes it"),
			EXPIRE_REFLOGS_REWRITE),
		OPT_BIT(0, "updateref", &flags,
			N_("update the reference to the value of the top reflog entry"),
			EXPIRE_REFLOGS_UPDATE_REF),
		OPT_BOOL(0, "verbose", &verbose, N_("print extra information on screen")),
		OPT_END()
	};

	argc = parse_options(argc, argv, prefix, options, reflog_delete_usage, 0);

	if (argc < 1)
		return error(_("no reflog specified to delete"));

	for (i = 0; i < argc; i++)
		status |= reflog_delete(argv[i], flags, verbose);

	return status;
}

static int cmd_reflog_exists(int argc, const char **argv, const char *prefix,
			     struct repository *repo UNUSED)
{
	struct option options[] = {
		OPT_END()
	};
	const char *refname;

	argc = parse_options(argc, argv, prefix, options, reflog_exists_usage,
			     0);
	if (!argc)
		usage_with_options(reflog_exists_usage, options);

	refname = argv[0];
	if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL))
		die(_("invalid ref format: %s"), refname);
	return !refs_reflog_exists(get_main_ref_store(the_repository),
				   refname);
}

static int cmd_reflog_drop(int argc, const char **argv, const char *prefix,
			   struct repository *repo)
{
	int ret = 0, do_all = 0, single_worktree = 0;
	const struct option options[] = {
		OPT_BOOL(0, "all", &do_all, N_("drop the reflogs of all references")),
		OPT_BOOL(0, "single-worktree", &single_worktree,
			 N_("drop reflogs from the current worktree only")),
		OPT_END()
	};

	argc = parse_options(argc, argv, prefix, options, reflog_drop_usage, 0);

	if (argc && do_all)
		usage(_("references specified along with --all"));

	if (do_all) {
		struct worktree_reflogs collected = {
			.reflogs = STRING_LIST_INIT_DUP,
		};
		struct string_list_item *item;
		struct worktree **worktrees, **p;

		worktrees = get_worktrees();
		for (p = worktrees; *p; p++) {
			if (single_worktree && !(*p)->is_current)
				continue;
			collected.worktree = *p;
			refs_for_each_reflog(get_worktree_ref_store(*p),
					     collect_reflog, &collected);
		}
		free_worktrees(worktrees);

		for_each_string_list_item(item, &collected.reflogs)
			ret |= refs_delete_reflog(get_main_ref_store(repo),
						     item->string);
		string_list_clear(&collected.reflogs, 0);

		return ret;
	}

	for (int i = 0; i < argc; i++) {
		char *ref;
		if (!repo_dwim_log(repo, argv[i], strlen(argv[i]), NULL, &ref)) {
			ret |= error(_("reflog could not be found: '%s'"), argv[i]);
			continue;
		}

		ret |= refs_delete_reflog(get_main_ref_store(repo), ref);
		free(ref);
	}

	return ret;
}

/*
 * main "reflog"
 */
int cmd_reflog(int argc,
	       const char **argv,
	       const char *prefix,
	       struct repository *repository)
{
	parse_opt_subcommand_fn *fn = NULL;
	struct option options[] = {
		OPT_SUBCOMMAND("show", &fn, cmd_reflog_show),
		OPT_SUBCOMMAND("list", &fn, cmd_reflog_list),
		OPT_SUBCOMMAND("expire", &fn, cmd_reflog_expire),
		OPT_SUBCOMMAND("delete", &fn, cmd_reflog_delete),
		OPT_SUBCOMMAND("exists", &fn, cmd_reflog_exists),
		OPT_SUBCOMMAND("drop", &fn, cmd_reflog_drop),
		OPT_END()
	};

	argc = parse_options(argc, argv, prefix, options, reflog_usage,
			     PARSE_OPT_SUBCOMMAND_OPTIONAL |
			     PARSE_OPT_KEEP_DASHDASH | PARSE_OPT_KEEP_ARGV0 |
			     PARSE_OPT_KEEP_UNKNOWN_OPT);
	if (fn)
		return fn(argc - 1, argv + 1, prefix, repository);
	else
		return cmd_log_reflog(argc, argv, prefix, repository);
}
Commit	Line	Data
	1	#define USE_THE_REPOSITORY_VARIABLE
	2
	3	#include "builtin.h"
	4	#include "config.h"
	5	#include "gettext.h"
	6	#include "revision.h"
	7	#include "reachable.h"
	8	#include "wildmatch.h"
	9	#include "worktree.h"
	10	#include "reflog.h"
	11	#include "refs.h"
	12	#include "parse-options.h"
	13
	14	#define BUILTIN_REFLOG_SHOW_USAGE \
	15	N_("git reflog [show] [<log-options>] [<ref>]")
	16
	17	#define BUILTIN_REFLOG_LIST_USAGE \
	18	N_("git reflog list")
	19
	20	#define BUILTIN_REFLOG_EXPIRE_USAGE \
	21	N_("git reflog expire [--expire=<time>] [--expire-unreachable=<time>]\n" \
	22	" [--rewrite] [--updateref] [--stale-fix]\n" \
	23	" [--dry-run \| -n] [--verbose] [--all [--single-worktree] \| <refs>...]")
	24
	25	#define BUILTIN_REFLOG_DELETE_USAGE \
	26	N_("git reflog delete [--rewrite] [--updateref]\n" \
	27	" [--dry-run \| -n] [--verbose] <ref>@{<specifier>}...")
	28
	29	#define BUILTIN_REFLOG_EXISTS_USAGE \
	30	N_("git reflog exists <ref>")
	31
	32	#define BUILTIN_REFLOG_DROP_USAGE \
	33	N_("git reflog drop [--all [--single-worktree] \| <refs>...]")
	34
	35	static const char *const reflog_show_usage[] = {
	36	BUILTIN_REFLOG_SHOW_USAGE,
	37	NULL,
	38	};
	39
	40	static const char *const reflog_list_usage[] = {
	41	BUILTIN_REFLOG_LIST_USAGE,
	42	NULL,
	43	};
	44
	45	static const char *const reflog_expire_usage[] = {
	46	BUILTIN_REFLOG_EXPIRE_USAGE,
	47	NULL
	48	};
	49
	50	static const char *const reflog_delete_usage[] = {
	51	BUILTIN_REFLOG_DELETE_USAGE,
	52	NULL
	53	};
	54
	55	static const char *const reflog_exists_usage[] = {
	56	BUILTIN_REFLOG_EXISTS_USAGE,
	57	NULL,
	58	};
	59
	60	static const char *const reflog_drop_usage[] = {
	61	BUILTIN_REFLOG_DROP_USAGE,
	62	NULL,
	63	};
	64
	65	static const char *const reflog_usage[] = {
	66	BUILTIN_REFLOG_SHOW_USAGE,
	67	BUILTIN_REFLOG_LIST_USAGE,
	68	BUILTIN_REFLOG_EXPIRE_USAGE,
	69	BUILTIN_REFLOG_DELETE_USAGE,
	70	BUILTIN_REFLOG_DROP_USAGE,
	71	BUILTIN_REFLOG_EXISTS_USAGE,
	72	NULL
	73	};
	74
	75	struct worktree_reflogs {
	76	struct worktree *worktree;
	77	struct string_list reflogs;
	78	};
	79
	80	static int collect_reflog(const char ref, void cb_data)
	81	{
	82	struct worktree_reflogs *cb = cb_data;
	83	struct worktree *worktree = cb->worktree;
	84	struct strbuf newref = STRBUF_INIT;
	85
	86	/*
	87	* Avoid collecting the same shared ref multiple times because
	88	* they are available via all worktrees.
	89	*/
	90	if (!worktree->is_current &&
	91	parse_worktree_ref(ref, NULL, NULL, NULL) == REF_WORKTREE_SHARED)
	92	return 0;
	93
	94	strbuf_worktree_ref(worktree, &newref, ref);
	95	string_list_append_nodup(&cb->reflogs, strbuf_detach(&newref, NULL));
	96
	97	return 0;
	98	}
	99
	100	static int expire_unreachable_callback(const struct option *opt,
	101	const char *arg,
	102	int unset)
	103	{
	104	struct reflog_expire_options *opts = opt->value;
	105
	106	BUG_ON_OPT_NEG(unset);
	107
	108	if (parse_expiry_date(arg, &opts->expire_unreachable))
	109	die(_("invalid timestamp '%s' given to '--%s'"),
	110	arg, opt->long_name);
	111
	112	opts->explicit_expiry \|= REFLOG_EXPIRE_UNREACH;
	113	return 0;
	114	}
	115
	116	static int expire_total_callback(const struct option *opt,
	117	const char *arg,
	118	int unset)
	119	{
	120	struct reflog_expire_options *opts = opt->value;
	121
	122	BUG_ON_OPT_NEG(unset);
	123
	124	if (parse_expiry_date(arg, &opts->expire_total))
	125	die(_("invalid timestamp '%s' given to '--%s'"),
	126	arg, opt->long_name);
	127
	128	opts->explicit_expiry \|= REFLOG_EXPIRE_TOTAL;
	129	return 0;
	130	}
	131
	132	static int cmd_reflog_show(int argc, const char *argv, const char prefix,
	133	struct repository *repo UNUSED)
	134	{
	135	struct option options[] = {
	136	OPT_END()
	137	};
	138
	139	parse_options(argc, argv, prefix, options, reflog_show_usage,
	140	PARSE_OPT_KEEP_DASHDASH \| PARSE_OPT_KEEP_ARGV0 \|
	141	PARSE_OPT_KEEP_UNKNOWN_OPT);
	142
	143	return cmd_log_reflog(argc, argv, prefix, the_repository);
	144	}
	145
	146	static int show_reflog(const char refname, void cb_data UNUSED)
	147	{
	148	printf("%s\n", refname);
	149	return 0;
	150	}
	151
	152	static int cmd_reflog_list(int argc, const char *argv, const char prefix,
	153	struct repository *repo UNUSED)
	154	{
	155	struct option options[] = {
	156	OPT_END()
	157	};
	158	struct ref_store *ref_store;
	159
	160	argc = parse_options(argc, argv, prefix, options, reflog_list_usage, 0);
	161	if (argc)
	162	return error(_("%s does not accept arguments: '%s'"),
	163	"list", argv[0]);
	164
	165	ref_store = get_main_ref_store(the_repository);
	166
	167	return refs_for_each_reflog(ref_store, show_reflog, NULL);
	168	}
	169
	170	static int cmd_reflog_expire(int argc, const char *argv, const char prefix,
	171	struct repository *repo UNUSED)
	172	{
	173	timestamp_t now = time(NULL);
	174	struct reflog_expire_options opts = REFLOG_EXPIRE_OPTIONS_INIT(now);
	175	int i, status, do_all, single_worktree = 0;
	176	unsigned int flags = 0;
	177	int verbose = 0;
	178	reflog_expiry_should_prune_fn *should_prune_fn = should_expire_reflog_ent;
	179	const struct option options[] = {
	180	OPT_BIT('n', "dry-run", &flags, N_("do not actually prune any entries"),
	181	EXPIRE_REFLOGS_DRY_RUN),
	182	OPT_BIT(0, "rewrite", &flags,
	183	N_("rewrite the old SHA1 with the new SHA1 of the entry that now precedes it"),
	184	EXPIRE_REFLOGS_REWRITE),
	185	OPT_BIT(0, "updateref", &flags,
	186	N_("update the reference to the value of the top reflog entry"),
	187	EXPIRE_REFLOGS_UPDATE_REF),
	188	OPT_BOOL(0, "verbose", &verbose, N_("print extra information on screen")),
	189	OPT_CALLBACK_F(0, "expire", &opts, N_("timestamp"),
	190	N_("prune entries older than the specified time"),
	191	PARSE_OPT_NONEG,
	192	expire_total_callback),
	193	OPT_CALLBACK_F(0, "expire-unreachable", &opts, N_("timestamp"),
	194	N_("prune entries older than <time> that are not reachable from the current tip of the branch"),
	195	PARSE_OPT_NONEG,
	196	expire_unreachable_callback),
	197	OPT_BOOL(0, "stale-fix", &opts.stalefix,
	198	N_("prune any reflog entries that point to broken commits")),
	199	OPT_BOOL(0, "all", &do_all, N_("process the reflogs of all references")),
	200	OPT_BOOL(0, "single-worktree", &single_worktree,
	201	N_("limits processing to reflogs from the current worktree only")),
	202	OPT_END()
	203	};
	204
	205	git_config(reflog_expire_config, &opts);
	206
	207	save_commit_buffer = 0;
	208	do_all = status = 0;
	209
	210	argc = parse_options(argc, argv, prefix, options, reflog_expire_usage, 0);
	211
	212	if (verbose)
	213	should_prune_fn = should_expire_reflog_ent_verbose;
	214
	215	/*
	216	* We can trust the commits and objects reachable from refs
	217	* even in older repository. We cannot trust what's reachable
	218	* from reflog if the repository was pruned with older git.
	219	*/
	220	if (opts.stalefix) {
	221	struct rev_info revs;
	222
	223	repo_init_revisions(the_repository, &revs, prefix);
	224	revs.do_not_die_on_missing_objects = 1;
	225	revs.ignore_missing = 1;
	226	revs.ignore_missing_links = 1;
	227	if (verbose)
	228	printf(_("Marking reachable objects..."));
	229	mark_reachable_objects(&revs, 0, 0, NULL);
	230	release_revisions(&revs);
	231	if (verbose)
	232	putchar('\n');
	233	}
	234
	235	if (do_all) {
	236	struct worktree_reflogs collected = {
	237	.reflogs = STRING_LIST_INIT_DUP,
	238	};
	239	struct string_list_item *item;
	240	struct worktree worktrees, p;
	241
	242	worktrees = get_worktrees();
	243	for (p = worktrees; *p; p++) {
	244	if (single_worktree && !(*p)->is_current)
	245	continue;
	246	collected.worktree = *p;
	247	refs_for_each_reflog(get_worktree_ref_store(*p),
	248	collect_reflog, &collected);
	249	}
	250	free_worktrees(worktrees);
	251
	252	for_each_string_list_item(item, &collected.reflogs) {
	253	struct expire_reflog_policy_cb cb = {
	254	.opts = opts,
	255	.dry_run = !!(flags & EXPIRE_REFLOGS_DRY_RUN),
	256	};
	257
	258	reflog_expire_options_set_refname(&cb.opts, item->string);
	259	status \|= refs_reflog_expire(get_main_ref_store(the_repository),
	260	item->string, flags,
	261	reflog_expiry_prepare,
	262	should_prune_fn,
	263	reflog_expiry_cleanup,
	264	&cb);
	265	}
	266	string_list_clear(&collected.reflogs, 0);
	267	}
	268
	269	for (i = 0; i < argc; i++) {
	270	char *ref;
	271	struct expire_reflog_policy_cb cb = { .opts = opts };
	272
	273	if (!repo_dwim_log(the_repository, argv[i], strlen(argv[i]), NULL, &ref)) {
	274	status \|= error(_("reflog could not be found: '%s'"), argv[i]);
	275	continue;
	276	}
	277	reflog_expire_options_set_refname(&cb.opts, ref);
	278	status \|= refs_reflog_expire(get_main_ref_store(the_repository),
	279	ref, flags,
	280	reflog_expiry_prepare,
	281	should_prune_fn,
	282	reflog_expiry_cleanup,
	283	&cb);
	284	free(ref);
	285	}
	286	return status;
	287	}
	288
	289	static int cmd_reflog_delete(int argc, const char *argv, const char prefix,
	290	struct repository *repo UNUSED)
	291	{
	292	int i, status = 0;
	293	unsigned int flags = 0;
	294	int verbose = 0;
	295
	296	const struct option options[] = {
	297	OPT_BIT('n', "dry-run", &flags, N_("do not actually prune any entries"),
	298	EXPIRE_REFLOGS_DRY_RUN),
	299	OPT_BIT(0, "rewrite", &flags,
	300	N_("rewrite the old SHA1 with the new SHA1 of the entry that now precedes it"),
	301	EXPIRE_REFLOGS_REWRITE),
	302	OPT_BIT(0, "updateref", &flags,
	303	N_("update the reference to the value of the top reflog entry"),
	304	EXPIRE_REFLOGS_UPDATE_REF),
	305	OPT_BOOL(0, "verbose", &verbose, N_("print extra information on screen")),
	306	OPT_END()
	307	};
	308
	309	argc = parse_options(argc, argv, prefix, options, reflog_delete_usage, 0);
	310
	311	if (argc < 1)
	312	return error(_("no reflog specified to delete"));
	313
	314	for (i = 0; i < argc; i++)
	315	status \|= reflog_delete(argv[i], flags, verbose);
	316
	317	return status;
	318	}
	319
	320	static int cmd_reflog_exists(int argc, const char *argv, const char prefix,
	321	struct repository *repo UNUSED)
	322	{
	323	struct option options[] = {
	324	OPT_END()
	325	};
	326	const char *refname;
	327
	328	argc = parse_options(argc, argv, prefix, options, reflog_exists_usage,
	329	0);
	330	if (!argc)
	331	usage_with_options(reflog_exists_usage, options);
	332
	333	refname = argv[0];
	334	if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL))
	335	die(_("invalid ref format: %s"), refname);
	336	return !refs_reflog_exists(get_main_ref_store(the_repository),
	337	refname);
	338	}
	339
	340	static int cmd_reflog_drop(int argc, const char *argv, const char prefix,
	341	struct repository *repo)
	342	{
	343	int ret = 0, do_all = 0, single_worktree = 0;
	344	const struct option options[] = {
	345	OPT_BOOL(0, "all", &do_all, N_("drop the reflogs of all references")),
	346	OPT_BOOL(0, "single-worktree", &single_worktree,
	347	N_("drop reflogs from the current worktree only")),
	348	OPT_END()
	349	};
	350
	351	argc = parse_options(argc, argv, prefix, options, reflog_drop_usage, 0);
	352
	353	if (argc && do_all)
	354	usage(_("references specified along with --all"));
	355
	356	if (do_all) {
	357	struct worktree_reflogs collected = {
	358	.reflogs = STRING_LIST_INIT_DUP,
	359	};
	360	struct string_list_item *item;
	361	struct worktree worktrees, p;
	362
	363	worktrees = get_worktrees();
	364	for (p = worktrees; *p; p++) {
	365	if (single_worktree && !(*p)->is_current)
	366	continue;
	367	collected.worktree = *p;
	368	refs_for_each_reflog(get_worktree_ref_store(*p),
	369	collect_reflog, &collected);
	370	}
	371	free_worktrees(worktrees);
	372
	373	for_each_string_list_item(item, &collected.reflogs)
	374	ret \|= refs_delete_reflog(get_main_ref_store(repo),
	375	item->string);
	376	string_list_clear(&collected.reflogs, 0);
	377
	378	return ret;
	379	}
	380
	381	for (int i = 0; i < argc; i++) {
	382	char *ref;
	383	if (!repo_dwim_log(repo, argv[i], strlen(argv[i]), NULL, &ref)) {
	384	ret \|= error(_("reflog could not be found: '%s'"), argv[i]);
	385	continue;
	386	}
	387
	388	ret \|= refs_delete_reflog(get_main_ref_store(repo), ref);
	389	free(ref);
	390	}
	391
	392	return ret;
	393	}
	394
	395	/*
	396	* main "reflog"
	397	*/
	398	int cmd_reflog(int argc,
	399	const char **argv,
	400	const char *prefix,
	401	struct repository *repository)
	402	{
	403	parse_opt_subcommand_fn *fn = NULL;
	404	struct option options[] = {
	405	OPT_SUBCOMMAND("show", &fn, cmd_reflog_show),
	406	OPT_SUBCOMMAND("list", &fn, cmd_reflog_list),
	407	OPT_SUBCOMMAND("expire", &fn, cmd_reflog_expire),
	408	OPT_SUBCOMMAND("delete", &fn, cmd_reflog_delete),
	409	OPT_SUBCOMMAND("exists", &fn, cmd_reflog_exists),
	410	OPT_SUBCOMMAND("drop", &fn, cmd_reflog_drop),
	411	OPT_END()
	412	};
	413
	414	argc = parse_options(argc, argv, prefix, options, reflog_usage,
	415	PARSE_OPT_SUBCOMMAND_OPTIONAL \|
	416	PARSE_OPT_KEEP_DASHDASH \| PARSE_OPT_KEEP_ARGV0 \|
	417	PARSE_OPT_KEEP_UNKNOWN_OPT);
	418	if (fn)
	419	return fn(argc - 1, argv + 1, prefix, repository);
	420	else
	421	return cmd_log_reflog(argc, argv, prefix, repository);
	422	}