Merge branch 'tg/conflict-marker-size' into maint
[git] / builtin / reflog.c
1 #include "builtin.h"
2 #include "config.h"
3 #include "lockfile.h"
4 #include "object-store.h"
5 #include "repository.h"
6 #include "commit.h"
7 #include "refs.h"
8 #include "dir.h"
9 #include "tree-walk.h"
10 #include "diff.h"
11 #include "revision.h"
12 #include "reachable.h"
13
14 /* NEEDSWORK: switch to using parse_options */
15 static const char reflog_expire_usage[] =
16 "git reflog expire [--expire=<time>] [--expire-unreachable=<time>] [--rewrite] [--updateref] [--stale-fix] [--dry-run | -n] [--verbose] [--all] <refs>...";
17 static const char reflog_delete_usage[] =
18 "git reflog delete [--rewrite] [--updateref] [--dry-run | -n] [--verbose] <refs>...";
19 static const char reflog_exists_usage[] =
20 "git reflog exists <ref>";
21
22 static timestamp_t default_reflog_expire;
23 static timestamp_t default_reflog_expire_unreachable;
24
25 struct cmd_reflog_expire_cb {
26         struct rev_info revs;
27         int stalefix;
28         timestamp_t expire_total;
29         timestamp_t expire_unreachable;
30         int recno;
31 };
32
33 struct expire_reflog_policy_cb {
34         enum {
35                 UE_NORMAL,
36                 UE_ALWAYS,
37                 UE_HEAD
38         } unreachable_expire_kind;
39         struct commit_list *mark_list;
40         unsigned long mark_limit;
41         struct cmd_reflog_expire_cb cmd;
42         struct commit *tip_commit;
43         struct commit_list *tips;
44 };
45
46 struct collected_reflog {
47         struct object_id oid;
48         char reflog[FLEX_ARRAY];
49 };
50
51 struct collect_reflog_cb {
52         struct collected_reflog **e;
53         int alloc;
54         int nr;
55 };
56
57 /* Remember to update object flag allocation in object.h */
58 #define INCOMPLETE      (1u<<10)
59 #define STUDYING        (1u<<11)
60 #define REACHABLE       (1u<<12)
61
62 static int tree_is_complete(const struct object_id *oid)
63 {
64         struct tree_desc desc;
65         struct name_entry entry;
66         int complete;
67         struct tree *tree;
68
69         tree = lookup_tree(the_repository, oid);
70         if (!tree)
71                 return 0;
72         if (tree->object.flags & SEEN)
73                 return 1;
74         if (tree->object.flags & INCOMPLETE)
75                 return 0;
76
77         if (!tree->buffer) {
78                 enum object_type type;
79                 unsigned long size;
80                 void *data = read_object_file(oid, &type, &size);
81                 if (!data) {
82                         tree->object.flags |= INCOMPLETE;
83                         return 0;
84                 }
85                 tree->buffer = data;
86                 tree->size = size;
87         }
88         init_tree_desc(&desc, tree->buffer, tree->size);
89         complete = 1;
90         while (tree_entry(&desc, &entry)) {
91                 if (!has_sha1_file(entry.oid->hash) ||
92                     (S_ISDIR(entry.mode) && !tree_is_complete(entry.oid))) {
93                         tree->object.flags |= INCOMPLETE;
94                         complete = 0;
95                 }
96         }
97         free_tree_buffer(tree);
98
99         if (complete)
100                 tree->object.flags |= SEEN;
101         return complete;
102 }
103
104 static int commit_is_complete(struct commit *commit)
105 {
106         struct object_array study;
107         struct object_array found;
108         int is_incomplete = 0;
109         int i;
110
111         /* early return */
112         if (commit->object.flags & SEEN)
113                 return 1;
114         if (commit->object.flags & INCOMPLETE)
115                 return 0;
116         /*
117          * Find all commits that are reachable and are not marked as
118          * SEEN.  Then make sure the trees and blobs contained are
119          * complete.  After that, mark these commits also as SEEN.
120          * If some of the objects that are needed to complete this
121          * commit are missing, mark this commit as INCOMPLETE.
122          */
123         memset(&study, 0, sizeof(study));
124         memset(&found, 0, sizeof(found));
125         add_object_array(&commit->object, NULL, &study);
126         add_object_array(&commit->object, NULL, &found);
127         commit->object.flags |= STUDYING;
128         while (study.nr) {
129                 struct commit *c;
130                 struct commit_list *parent;
131
132                 c = (struct commit *)object_array_pop(&study);
133                 if (!c->object.parsed && !parse_object(the_repository, &c->object.oid))
134                         c->object.flags |= INCOMPLETE;
135
136                 if (c->object.flags & INCOMPLETE) {
137                         is_incomplete = 1;
138                         break;
139                 }
140                 else if (c->object.flags & SEEN)
141                         continue;
142                 for (parent = c->parents; parent; parent = parent->next) {
143                         struct commit *p = parent->item;
144                         if (p->object.flags & STUDYING)
145                                 continue;
146                         p->object.flags |= STUDYING;
147                         add_object_array(&p->object, NULL, &study);
148                         add_object_array(&p->object, NULL, &found);
149                 }
150         }
151         if (!is_incomplete) {
152                 /*
153                  * make sure all commits in "found" array have all the
154                  * necessary objects.
155                  */
156                 for (i = 0; i < found.nr; i++) {
157                         struct commit *c =
158                                 (struct commit *)found.objects[i].item;
159                         if (!tree_is_complete(get_commit_tree_oid(c))) {
160                                 is_incomplete = 1;
161                                 c->object.flags |= INCOMPLETE;
162                         }
163                 }
164                 if (!is_incomplete) {
165                         /* mark all found commits as complete, iow SEEN */
166                         for (i = 0; i < found.nr; i++)
167                                 found.objects[i].item->flags |= SEEN;
168                 }
169         }
170         /* clear flags from the objects we traversed */
171         for (i = 0; i < found.nr; i++)
172                 found.objects[i].item->flags &= ~STUDYING;
173         if (is_incomplete)
174                 commit->object.flags |= INCOMPLETE;
175         else {
176                 /*
177                  * If we come here, we have (1) traversed the ancestry chain
178                  * from the "commit" until we reach SEEN commits (which are
179                  * known to be complete), and (2) made sure that the commits
180                  * encountered during the above traversal refer to trees that
181                  * are complete.  Which means that we know *all* the commits
182                  * we have seen during this process are complete.
183                  */
184                 for (i = 0; i < found.nr; i++)
185                         found.objects[i].item->flags |= SEEN;
186         }
187         /* free object arrays */
188         object_array_clear(&study);
189         object_array_clear(&found);
190         return !is_incomplete;
191 }
192
193 static int keep_entry(struct commit **it, struct object_id *oid)
194 {
195         struct commit *commit;
196
197         if (is_null_oid(oid))
198                 return 1;
199         commit = lookup_commit_reference_gently(the_repository, oid, 1);
200         if (!commit)
201                 return 0;
202
203         /*
204          * Make sure everything in this commit exists.
205          *
206          * We have walked all the objects reachable from the refs
207          * and cache earlier.  The commits reachable by this commit
208          * must meet SEEN commits -- and then we should mark them as
209          * SEEN as well.
210          */
211         if (!commit_is_complete(commit))
212                 return 0;
213         *it = commit;
214         return 1;
215 }
216
217 /*
218  * Starting from commits in the cb->mark_list, mark commits that are
219  * reachable from them.  Stop the traversal at commits older than
220  * the expire_limit and queue them back, so that the caller can call
221  * us again to restart the traversal with longer expire_limit.
222  */
223 static void mark_reachable(struct expire_reflog_policy_cb *cb)
224 {
225         struct commit_list *pending;
226         timestamp_t expire_limit = cb->mark_limit;
227         struct commit_list *leftover = NULL;
228
229         for (pending = cb->mark_list; pending; pending = pending->next)
230                 pending->item->object.flags &= ~REACHABLE;
231
232         pending = cb->mark_list;
233         while (pending) {
234                 struct commit_list *parent;
235                 struct commit *commit = pop_commit(&pending);
236                 if (commit->object.flags & REACHABLE)
237                         continue;
238                 if (parse_commit(commit))
239                         continue;
240                 commit->object.flags |= REACHABLE;
241                 if (commit->date < expire_limit) {
242                         commit_list_insert(commit, &leftover);
243                         continue;
244                 }
245                 commit->object.flags |= REACHABLE;
246                 parent = commit->parents;
247                 while (parent) {
248                         commit = parent->item;
249                         parent = parent->next;
250                         if (commit->object.flags & REACHABLE)
251                                 continue;
252                         commit_list_insert(commit, &pending);
253                 }
254         }
255         cb->mark_list = leftover;
256 }
257
258 static int unreachable(struct expire_reflog_policy_cb *cb, struct commit *commit, struct object_id *oid)
259 {
260         /*
261          * We may or may not have the commit yet - if not, look it
262          * up using the supplied sha1.
263          */
264         if (!commit) {
265                 if (is_null_oid(oid))
266                         return 0;
267
268                 commit = lookup_commit_reference_gently(the_repository, oid,
269                                                         1);
270
271                 /* Not a commit -- keep it */
272                 if (!commit)
273                         return 0;
274         }
275
276         /* Reachable from the current ref?  Don't prune. */
277         if (commit->object.flags & REACHABLE)
278                 return 0;
279
280         if (cb->mark_list && cb->mark_limit) {
281                 cb->mark_limit = 0; /* dig down to the root */
282                 mark_reachable(cb);
283         }
284
285         return !(commit->object.flags & REACHABLE);
286 }
287
288 /*
289  * Return true iff the specified reflog entry should be expired.
290  */
291 static int should_expire_reflog_ent(struct object_id *ooid, struct object_id *noid,
292                                     const char *email, timestamp_t timestamp, int tz,
293                                     const char *message, void *cb_data)
294 {
295         struct expire_reflog_policy_cb *cb = cb_data;
296         struct commit *old_commit, *new_commit;
297
298         if (timestamp < cb->cmd.expire_total)
299                 return 1;
300
301         old_commit = new_commit = NULL;
302         if (cb->cmd.stalefix &&
303             (!keep_entry(&old_commit, ooid) || !keep_entry(&new_commit, noid)))
304                 return 1;
305
306         if (timestamp < cb->cmd.expire_unreachable) {
307                 if (cb->unreachable_expire_kind == UE_ALWAYS)
308                         return 1;
309                 if (unreachable(cb, old_commit, ooid) || unreachable(cb, new_commit, noid))
310                         return 1;
311         }
312
313         if (cb->cmd.recno && --(cb->cmd.recno) == 0)
314                 return 1;
315
316         return 0;
317 }
318
319 static int push_tip_to_list(const char *refname, const struct object_id *oid,
320                             int flags, void *cb_data)
321 {
322         struct commit_list **list = cb_data;
323         struct commit *tip_commit;
324         if (flags & REF_ISSYMREF)
325                 return 0;
326         tip_commit = lookup_commit_reference_gently(the_repository, oid, 1);
327         if (!tip_commit)
328                 return 0;
329         commit_list_insert(tip_commit, list);
330         return 0;
331 }
332
333 static void reflog_expiry_prepare(const char *refname,
334                                   const struct object_id *oid,
335                                   void *cb_data)
336 {
337         struct expire_reflog_policy_cb *cb = cb_data;
338
339         if (!cb->cmd.expire_unreachable || !strcmp(refname, "HEAD")) {
340                 cb->tip_commit = NULL;
341                 cb->unreachable_expire_kind = UE_HEAD;
342         } else {
343                 cb->tip_commit = lookup_commit_reference_gently(the_repository,
344                                                                 oid, 1);
345                 if (!cb->tip_commit)
346                         cb->unreachable_expire_kind = UE_ALWAYS;
347                 else
348                         cb->unreachable_expire_kind = UE_NORMAL;
349         }
350
351         if (cb->cmd.expire_unreachable <= cb->cmd.expire_total)
352                 cb->unreachable_expire_kind = UE_ALWAYS;
353
354         cb->mark_list = NULL;
355         cb->tips = NULL;
356         if (cb->unreachable_expire_kind != UE_ALWAYS) {
357                 if (cb->unreachable_expire_kind == UE_HEAD) {
358                         struct commit_list *elem;
359
360                         for_each_ref(push_tip_to_list, &cb->tips);
361                         for (elem = cb->tips; elem; elem = elem->next)
362                                 commit_list_insert(elem->item, &cb->mark_list);
363                 } else {
364                         commit_list_insert(cb->tip_commit, &cb->mark_list);
365                 }
366                 cb->mark_limit = cb->cmd.expire_total;
367                 mark_reachable(cb);
368         }
369 }
370
371 static void reflog_expiry_cleanup(void *cb_data)
372 {
373         struct expire_reflog_policy_cb *cb = cb_data;
374
375         if (cb->unreachable_expire_kind != UE_ALWAYS) {
376                 if (cb->unreachable_expire_kind == UE_HEAD) {
377                         struct commit_list *elem;
378                         for (elem = cb->tips; elem; elem = elem->next)
379                                 clear_commit_marks(elem->item, REACHABLE);
380                         free_commit_list(cb->tips);
381                 } else {
382                         clear_commit_marks(cb->tip_commit, REACHABLE);
383                 }
384         }
385 }
386
387 static int collect_reflog(const char *ref, const struct object_id *oid, int unused, void *cb_data)
388 {
389         struct collected_reflog *e;
390         struct collect_reflog_cb *cb = cb_data;
391
392         FLEX_ALLOC_STR(e, reflog, ref);
393         oidcpy(&e->oid, oid);
394         ALLOC_GROW(cb->e, cb->nr + 1, cb->alloc);
395         cb->e[cb->nr++] = e;
396         return 0;
397 }
398
399 static struct reflog_expire_cfg {
400         struct reflog_expire_cfg *next;
401         timestamp_t expire_total;
402         timestamp_t expire_unreachable;
403         char pattern[FLEX_ARRAY];
404 } *reflog_expire_cfg, **reflog_expire_cfg_tail;
405
406 static struct reflog_expire_cfg *find_cfg_ent(const char *pattern, size_t len)
407 {
408         struct reflog_expire_cfg *ent;
409
410         if (!reflog_expire_cfg_tail)
411                 reflog_expire_cfg_tail = &reflog_expire_cfg;
412
413         for (ent = reflog_expire_cfg; ent; ent = ent->next)
414                 if (!strncmp(ent->pattern, pattern, len) &&
415                     ent->pattern[len] == '\0')
416                         return ent;
417
418         FLEX_ALLOC_MEM(ent, pattern, pattern, len);
419         *reflog_expire_cfg_tail = ent;
420         reflog_expire_cfg_tail = &(ent->next);
421         return ent;
422 }
423
424 /* expiry timer slot */
425 #define EXPIRE_TOTAL   01
426 #define EXPIRE_UNREACH 02
427
428 static int reflog_expire_config(const char *var, const char *value, void *cb)
429 {
430         const char *pattern, *key;
431         int pattern_len;
432         timestamp_t expire;
433         int slot;
434         struct reflog_expire_cfg *ent;
435
436         if (parse_config_key(var, "gc", &pattern, &pattern_len, &key) < 0)
437                 return git_default_config(var, value, cb);
438
439         if (!strcmp(key, "reflogexpire")) {
440                 slot = EXPIRE_TOTAL;
441                 if (git_config_expiry_date(&expire, var, value))
442                         return -1;
443         } else if (!strcmp(key, "reflogexpireunreachable")) {
444                 slot = EXPIRE_UNREACH;
445                 if (git_config_expiry_date(&expire, var, value))
446                         return -1;
447         } else
448                 return git_default_config(var, value, cb);
449
450         if (!pattern) {
451                 switch (slot) {
452                 case EXPIRE_TOTAL:
453                         default_reflog_expire = expire;
454                         break;
455                 case EXPIRE_UNREACH:
456                         default_reflog_expire_unreachable = expire;
457                         break;
458                 }
459                 return 0;
460         }
461
462         ent = find_cfg_ent(pattern, pattern_len);
463         if (!ent)
464                 return -1;
465         switch (slot) {
466         case EXPIRE_TOTAL:
467                 ent->expire_total = expire;
468                 break;
469         case EXPIRE_UNREACH:
470                 ent->expire_unreachable = expire;
471                 break;
472         }
473         return 0;
474 }
475
476 static void set_reflog_expiry_param(struct cmd_reflog_expire_cb *cb, int slot, const char *ref)
477 {
478         struct reflog_expire_cfg *ent;
479
480         if (slot == (EXPIRE_TOTAL|EXPIRE_UNREACH))
481                 return; /* both given explicitly -- nothing to tweak */
482
483         for (ent = reflog_expire_cfg; ent; ent = ent->next) {
484                 if (!wildmatch(ent->pattern, ref, 0)) {
485                         if (!(slot & EXPIRE_TOTAL))
486                                 cb->expire_total = ent->expire_total;
487                         if (!(slot & EXPIRE_UNREACH))
488                                 cb->expire_unreachable = ent->expire_unreachable;
489                         return;
490                 }
491         }
492
493         /*
494          * If unconfigured, make stash never expire
495          */
496         if (!strcmp(ref, "refs/stash")) {
497                 if (!(slot & EXPIRE_TOTAL))
498                         cb->expire_total = 0;
499                 if (!(slot & EXPIRE_UNREACH))
500                         cb->expire_unreachable = 0;
501                 return;
502         }
503
504         /* Nothing matched -- use the default value */
505         if (!(slot & EXPIRE_TOTAL))
506                 cb->expire_total = default_reflog_expire;
507         if (!(slot & EXPIRE_UNREACH))
508                 cb->expire_unreachable = default_reflog_expire_unreachable;
509 }
510
511 static int cmd_reflog_expire(int argc, const char **argv, const char *prefix)
512 {
513         struct expire_reflog_policy_cb cb;
514         timestamp_t now = time(NULL);
515         int i, status, do_all;
516         int explicit_expiry = 0;
517         unsigned int flags = 0;
518
519         default_reflog_expire_unreachable = now - 30 * 24 * 3600;
520         default_reflog_expire = now - 90 * 24 * 3600;
521         git_config(reflog_expire_config, NULL);
522
523         save_commit_buffer = 0;
524         do_all = status = 0;
525         memset(&cb, 0, sizeof(cb));
526
527         cb.cmd.expire_total = default_reflog_expire;
528         cb.cmd.expire_unreachable = default_reflog_expire_unreachable;
529
530         for (i = 1; i < argc; i++) {
531                 const char *arg = argv[i];
532                 if (!strcmp(arg, "--dry-run") || !strcmp(arg, "-n"))
533                         flags |= EXPIRE_REFLOGS_DRY_RUN;
534                 else if (starts_with(arg, "--expire=")) {
535                         if (parse_expiry_date(arg + 9, &cb.cmd.expire_total))
536                                 die(_("'%s' is not a valid timestamp"), arg);
537                         explicit_expiry |= EXPIRE_TOTAL;
538                 }
539                 else if (starts_with(arg, "--expire-unreachable=")) {
540                         if (parse_expiry_date(arg + 21, &cb.cmd.expire_unreachable))
541                                 die(_("'%s' is not a valid timestamp"), arg);
542                         explicit_expiry |= EXPIRE_UNREACH;
543                 }
544                 else if (!strcmp(arg, "--stale-fix"))
545                         cb.cmd.stalefix = 1;
546                 else if (!strcmp(arg, "--rewrite"))
547                         flags |= EXPIRE_REFLOGS_REWRITE;
548                 else if (!strcmp(arg, "--updateref"))
549                         flags |= EXPIRE_REFLOGS_UPDATE_REF;
550                 else if (!strcmp(arg, "--all"))
551                         do_all = 1;
552                 else if (!strcmp(arg, "--verbose"))
553                         flags |= EXPIRE_REFLOGS_VERBOSE;
554                 else if (!strcmp(arg, "--")) {
555                         i++;
556                         break;
557                 }
558                 else if (arg[0] == '-')
559                         usage(reflog_expire_usage);
560                 else
561                         break;
562         }
563
564         /*
565          * We can trust the commits and objects reachable from refs
566          * even in older repository.  We cannot trust what's reachable
567          * from reflog if the repository was pruned with older git.
568          */
569         if (cb.cmd.stalefix) {
570                 init_revisions(&cb.cmd.revs, prefix);
571                 if (flags & EXPIRE_REFLOGS_VERBOSE)
572                         printf("Marking reachable objects...");
573                 mark_reachable_objects(&cb.cmd.revs, 0, 0, NULL);
574                 if (flags & EXPIRE_REFLOGS_VERBOSE)
575                         putchar('\n');
576         }
577
578         if (do_all) {
579                 struct collect_reflog_cb collected;
580                 int i;
581
582                 memset(&collected, 0, sizeof(collected));
583                 for_each_reflog(collect_reflog, &collected);
584                 for (i = 0; i < collected.nr; i++) {
585                         struct collected_reflog *e = collected.e[i];
586                         set_reflog_expiry_param(&cb.cmd, explicit_expiry, e->reflog);
587                         status |= reflog_expire(e->reflog, &e->oid, flags,
588                                                 reflog_expiry_prepare,
589                                                 should_expire_reflog_ent,
590                                                 reflog_expiry_cleanup,
591                                                 &cb);
592                         free(e);
593                 }
594                 free(collected.e);
595         }
596
597         for (; i < argc; i++) {
598                 char *ref;
599                 struct object_id oid;
600                 if (!dwim_log(argv[i], strlen(argv[i]), &oid, &ref)) {
601                         status |= error("%s points nowhere!", argv[i]);
602                         continue;
603                 }
604                 set_reflog_expiry_param(&cb.cmd, explicit_expiry, ref);
605                 status |= reflog_expire(ref, &oid, flags,
606                                         reflog_expiry_prepare,
607                                         should_expire_reflog_ent,
608                                         reflog_expiry_cleanup,
609                                         &cb);
610         }
611         return status;
612 }
613
614 static int count_reflog_ent(struct object_id *ooid, struct object_id *noid,
615                 const char *email, timestamp_t timestamp, int tz,
616                 const char *message, void *cb_data)
617 {
618         struct expire_reflog_policy_cb *cb = cb_data;
619         if (!cb->cmd.expire_total || timestamp < cb->cmd.expire_total)
620                 cb->cmd.recno++;
621         return 0;
622 }
623
624 static int cmd_reflog_delete(int argc, const char **argv, const char *prefix)
625 {
626         struct expire_reflog_policy_cb cb;
627         int i, status = 0;
628         unsigned int flags = 0;
629
630         memset(&cb, 0, sizeof(cb));
631
632         for (i = 1; i < argc; i++) {
633                 const char *arg = argv[i];
634                 if (!strcmp(arg, "--dry-run") || !strcmp(arg, "-n"))
635                         flags |= EXPIRE_REFLOGS_DRY_RUN;
636                 else if (!strcmp(arg, "--rewrite"))
637                         flags |= EXPIRE_REFLOGS_REWRITE;
638                 else if (!strcmp(arg, "--updateref"))
639                         flags |= EXPIRE_REFLOGS_UPDATE_REF;
640                 else if (!strcmp(arg, "--verbose"))
641                         flags |= EXPIRE_REFLOGS_VERBOSE;
642                 else if (!strcmp(arg, "--")) {
643                         i++;
644                         break;
645                 }
646                 else if (arg[0] == '-')
647                         usage(reflog_delete_usage);
648                 else
649                         break;
650         }
651
652         if (argc - i < 1)
653                 return error("Nothing to delete?");
654
655         for ( ; i < argc; i++) {
656                 const char *spec = strstr(argv[i], "@{");
657                 struct object_id oid;
658                 char *ep, *ref;
659                 int recno;
660
661                 if (!spec) {
662                         status |= error("Not a reflog: %s", argv[i]);
663                         continue;
664                 }
665
666                 if (!dwim_log(argv[i], spec - argv[i], &oid, &ref)) {
667                         status |= error("no reflog for '%s'", argv[i]);
668                         continue;
669                 }
670
671                 recno = strtoul(spec + 2, &ep, 10);
672                 if (*ep == '}') {
673                         cb.cmd.recno = -recno;
674                         for_each_reflog_ent(ref, count_reflog_ent, &cb);
675                 } else {
676                         cb.cmd.expire_total = approxidate(spec + 2);
677                         for_each_reflog_ent(ref, count_reflog_ent, &cb);
678                         cb.cmd.expire_total = 0;
679                 }
680
681                 status |= reflog_expire(ref, &oid, flags,
682                                         reflog_expiry_prepare,
683                                         should_expire_reflog_ent,
684                                         reflog_expiry_cleanup,
685                                         &cb);
686                 free(ref);
687         }
688         return status;
689 }
690
691 static int cmd_reflog_exists(int argc, const char **argv, const char *prefix)
692 {
693         int i, start = 0;
694
695         for (i = 1; i < argc; i++) {
696                 const char *arg = argv[i];
697                 if (!strcmp(arg, "--")) {
698                         i++;
699                         break;
700                 }
701                 else if (arg[0] == '-')
702                         usage(reflog_exists_usage);
703                 else
704                         break;
705         }
706
707         start = i;
708
709         if (argc - start != 1)
710                 usage(reflog_exists_usage);
711
712         if (check_refname_format(argv[start], REFNAME_ALLOW_ONELEVEL))
713                 die("invalid ref format: %s", argv[start]);
714         return !reflog_exists(argv[start]);
715 }
716
717 /*
718  * main "reflog"
719  */
720
721 static const char reflog_usage[] =
722 "git reflog [ show | expire | delete | exists ]";
723
724 int cmd_reflog(int argc, const char **argv, const char *prefix)
725 {
726         if (argc > 1 && !strcmp(argv[1], "-h"))
727                 usage(reflog_usage);
728
729         /* With no command, we default to showing it. */
730         if (argc < 2 || *argv[1] == '-')
731                 return cmd_log_reflog(argc, argv, prefix);
732
733         if (!strcmp(argv[1], "show"))
734                 return cmd_log_reflog(argc - 1, argv + 1, prefix);
735
736         if (!strcmp(argv[1], "expire"))
737                 return cmd_reflog_expire(argc - 1, argv + 1, prefix);
738
739         if (!strcmp(argv[1], "delete"))
740                 return cmd_reflog_delete(argc - 1, argv + 1, prefix);
741
742         if (!strcmp(argv[1], "exists"))
743                 return cmd_reflog_exists(argc - 1, argv + 1, prefix);
744
745         return cmd_log_reflog(argc, argv, prefix);
746 }