2 * "git fast-export" builtin command
4 * Copyright (C) 2007 Johannes E. Schindelin
11 #include "object-store.h"
20 #include "string-list.h"
22 #include "parse-options.h"
26 #include "commit-slab.h"
28 static const char *fast_export_usage[] = {
29 N_("git fast-export [rev-list-opts]"),
34 static enum { SIGNED_TAG_ABORT, VERBATIM, WARN, WARN_STRIP, STRIP } signed_tag_mode = SIGNED_TAG_ABORT;
35 static enum { TAG_FILTERING_ABORT, DROP, REWRITE } tag_of_filtered_mode = TAG_FILTERING_ABORT;
36 static enum { REENCODE_ABORT, REENCODE_YES, REENCODE_NO } reencode_mode = REENCODE_ABORT;
37 static int fake_missing_tagger;
38 static int use_done_feature;
41 static int reference_excluded_commits;
42 static int show_original_ids;
44 static struct string_list extra_refs = STRING_LIST_INIT_NODUP;
45 static struct string_list tag_refs = STRING_LIST_INIT_NODUP;
46 static struct refspec refspecs = REFSPEC_INIT_FETCH;
48 static struct revision_sources revision_sources;
50 static int parse_opt_signed_tag_mode(const struct option *opt,
51 const char *arg, int unset)
53 if (unset || !strcmp(arg, "abort"))
54 signed_tag_mode = SIGNED_TAG_ABORT;
55 else if (!strcmp(arg, "verbatim") || !strcmp(arg, "ignore"))
56 signed_tag_mode = VERBATIM;
57 else if (!strcmp(arg, "warn"))
58 signed_tag_mode = WARN;
59 else if (!strcmp(arg, "warn-strip"))
60 signed_tag_mode = WARN_STRIP;
61 else if (!strcmp(arg, "strip"))
62 signed_tag_mode = STRIP;
64 return error("Unknown signed-tags mode: %s", arg);
68 static int parse_opt_tag_of_filtered_mode(const struct option *opt,
69 const char *arg, int unset)
71 if (unset || !strcmp(arg, "abort"))
72 tag_of_filtered_mode = TAG_FILTERING_ABORT;
73 else if (!strcmp(arg, "drop"))
74 tag_of_filtered_mode = DROP;
75 else if (!strcmp(arg, "rewrite"))
76 tag_of_filtered_mode = REWRITE;
78 return error("Unknown tag-of-filtered mode: %s", arg);
82 static int parse_opt_reencode_mode(const struct option *opt,
83 const char *arg, int unset)
86 reencode_mode = REENCODE_ABORT;
90 switch (git_parse_maybe_bool(arg)) {
92 reencode_mode = REENCODE_NO;
95 reencode_mode = REENCODE_YES;
98 if (!strcasecmp(arg, "abort"))
99 reencode_mode = REENCODE_ABORT;
101 return error("Unknown reencoding mode: %s", arg);
107 static struct decoration idnums;
108 static uint32_t last_idnum;
110 static int has_unshown_parent(struct commit *commit)
112 struct commit_list *parent;
114 for (parent = commit->parents; parent; parent = parent->next)
115 if (!(parent->item->object.flags & SHOWN) &&
116 !(parent->item->object.flags & UNINTERESTING))
121 struct anonymized_entry {
122 struct hashmap_entry hash;
129 static int anonymized_entry_cmp(const void *unused_cmp_data,
130 const struct hashmap_entry *eptr,
131 const struct hashmap_entry *entry_or_key,
132 const void *unused_keydata)
134 const struct anonymized_entry *a, *b;
136 a = container_of(eptr, const struct anonymized_entry, hash);
137 b = container_of(entry_or_key, const struct anonymized_entry, hash);
139 return a->orig_len != b->orig_len ||
140 memcmp(a->orig, b->orig, a->orig_len);
144 * Basically keep a cache of X->Y so that we can repeatedly replace
145 * the same anonymized string with another. The actual generation
146 * is farmed out to the generate function.
148 static const char *anonymize_str(struct hashmap *map,
149 char *(*generate)(const char *, size_t),
150 const char *orig, size_t len)
152 struct anonymized_entry key, *ret;
155 hashmap_init(map, anonymized_entry_cmp, NULL, 0);
157 hashmap_entry_init(&key.hash, memhash(orig, len));
160 ret = hashmap_get_entry(map, &key, hash, NULL);
163 ret = xmalloc(sizeof(*ret));
164 hashmap_entry_init(&ret->hash, key.hash.hash);
165 ret->orig = xmemdupz(orig, len);
167 ret->anon = generate(orig, len);
168 ret->anon_len = strlen(ret->anon);
169 hashmap_put(map, &ret->hash);
176 * We anonymize each component of a path individually,
177 * so that paths a/b and a/c will share a common root.
178 * The paths are cached via anonymize_mem so that repeated
179 * lookups for "a" will yield the same value.
181 static void anonymize_path(struct strbuf *out, const char *path,
183 char *(*generate)(const char *, size_t))
186 const char *end_of_component = strchrnul(path, '/');
187 size_t len = end_of_component - path;
188 const char *c = anonymize_str(map, generate, path, len);
189 strbuf_addstr(out, c);
190 path = end_of_component;
192 strbuf_addch(out, *path++);
196 static inline void *mark_to_ptr(uint32_t mark)
198 return (void *)(uintptr_t)mark;
201 static inline uint32_t ptr_to_mark(void * mark)
203 return (uint32_t)(uintptr_t)mark;
206 static inline void mark_object(struct object *object, uint32_t mark)
208 add_decoration(&idnums, object, mark_to_ptr(mark));
211 static inline void mark_next_object(struct object *object)
213 mark_object(object, ++last_idnum);
216 static int get_object_mark(struct object *object)
218 void *decoration = lookup_decoration(&idnums, object);
221 return ptr_to_mark(decoration);
224 static struct commit *rewrite_commit(struct commit *p)
227 if (p->parents && p->parents->next)
229 if (p->object.flags & UNINTERESTING)
231 if (!(p->object.flags & TREESAME))
235 p = p->parents->item;
240 static void show_progress(void)
242 static int counter = 0;
245 if ((++counter % progress) == 0)
246 printf("progress %d objects\n", counter);
250 * Ideally we would want some transformation of the blob data here
251 * that is unreversible, but would still be the same size and have
252 * the same data relationship to other blobs (so that we get the same
253 * delta and packing behavior as the original). But the first and last
254 * requirements there are probably mutually exclusive, so let's take
255 * the easy way out for now, and just generate arbitrary content.
257 * There's no need to cache this result with anonymize_mem, since
258 * we already handle blob content caching with marks.
260 static char *anonymize_blob(unsigned long *size)
263 struct strbuf out = STRBUF_INIT;
264 strbuf_addf(&out, "anonymous blob %d", counter++);
266 return strbuf_detach(&out, NULL);
269 static void export_blob(const struct object_id *oid)
272 enum object_type type;
274 struct object *object;
280 if (is_null_oid(oid))
283 object = lookup_object(the_repository, oid);
284 if (object && object->flags & SHOWN)
288 buf = anonymize_blob(&size);
289 object = (struct object *)lookup_blob(the_repository, oid);
292 buf = read_object_file(oid, &type, &size);
294 die("could not read blob %s", oid_to_hex(oid));
295 if (check_object_signature(the_repository, oid, buf, size,
296 type_name(type)) < 0)
297 die("oid mismatch in blob %s", oid_to_hex(oid));
298 object = parse_object_buffer(the_repository, oid, type,
303 die("Could not read blob %s", oid_to_hex(oid));
305 mark_next_object(object);
307 printf("blob\nmark :%"PRIu32"\n", last_idnum);
308 if (show_original_ids)
309 printf("original-oid %s\n", oid_to_hex(oid));
310 printf("data %"PRIuMAX"\n", (uintmax_t)size);
311 if (size && fwrite(buf, size, 1, stdout) != 1)
312 die_errno("could not write blob '%s'", oid_to_hex(oid));
317 object->flags |= SHOWN;
322 static int depth_first(const void *a_, const void *b_)
324 const struct diff_filepair *a = *((const struct diff_filepair **)a_);
325 const struct diff_filepair *b = *((const struct diff_filepair **)b_);
326 const char *name_a, *name_b;
327 int len_a, len_b, len;
330 name_a = a->one ? a->one->path : a->two->path;
331 name_b = b->one ? b->one->path : b->two->path;
333 len_a = strlen(name_a);
334 len_b = strlen(name_b);
335 len = (len_a < len_b) ? len_a : len_b;
337 /* strcmp will sort 'd' before 'd/e', we want 'd/e' before 'd' */
338 cmp = memcmp(name_a, name_b, len);
345 * Move 'R'ename entries last so that all references of the file
346 * appear in the output before it is renamed (e.g., when a file
347 * was copied and renamed in the same commit).
349 return (a->status == 'R') - (b->status == 'R');
352 static void print_path_1(const char *path)
354 int need_quote = quote_c_style(path, NULL, NULL, 0);
356 quote_c_style(path, NULL, stdout, 0);
357 else if (strchr(path, ' '))
358 printf("\"%s\"", path);
363 static char *anonymize_path_component(const char *path, size_t len)
366 struct strbuf out = STRBUF_INIT;
367 strbuf_addf(&out, "path%d", counter++);
368 return strbuf_detach(&out, NULL);
371 static void print_path(const char *path)
376 static struct hashmap paths;
377 static struct strbuf anon = STRBUF_INIT;
379 anonymize_path(&anon, path, &paths, anonymize_path_component);
380 print_path_1(anon.buf);
385 static char *generate_fake_oid(const char *old, size_t len)
387 static uint32_t counter = 1; /* avoid null oid */
388 const unsigned hashsz = the_hash_algo->rawsz;
389 struct object_id oid;
390 char *hex = xmallocz(GIT_MAX_HEXSZ);
393 put_be32(oid.hash + hashsz - 4, counter++);
394 return oid_to_hex_r(hex, &oid);
397 static const char *anonymize_oid(const char *oid_hex)
399 static struct hashmap objs;
400 size_t len = strlen(oid_hex);
401 return anonymize_str(&objs, generate_fake_oid, oid_hex, len);
404 static void show_filemodify(struct diff_queue_struct *q,
405 struct diff_options *options, void *data)
408 struct string_list *changed = data;
411 * Handle files below a directory first, in case they are all deleted
412 * and the directory changes to a file or symlink.
414 QSORT(q->queue, q->nr, depth_first);
416 for (i = 0; i < q->nr; i++) {
417 struct diff_filespec *ospec = q->queue[i]->one;
418 struct diff_filespec *spec = q->queue[i]->two;
420 switch (q->queue[i]->status) {
421 case DIFF_STATUS_DELETED:
423 print_path(spec->path);
424 string_list_insert(changed, spec->path);
428 case DIFF_STATUS_COPIED:
429 case DIFF_STATUS_RENAMED:
431 * If a change in the file corresponding to ospec->path
432 * has been observed, we cannot trust its contents
433 * because the diff is calculated based on the prior
434 * contents, not the current contents. So, declare a
435 * copy or rename only if there was no change observed.
437 if (!string_list_has_string(changed, ospec->path)) {
438 printf("%c ", q->queue[i]->status);
439 print_path(ospec->path);
441 print_path(spec->path);
442 string_list_insert(changed, spec->path);
445 if (oideq(&ospec->oid, &spec->oid) &&
446 ospec->mode == spec->mode)
451 case DIFF_STATUS_TYPE_CHANGED:
452 case DIFF_STATUS_MODIFIED:
453 case DIFF_STATUS_ADDED:
455 * Links refer to objects in another repositories;
456 * output the SHA-1 verbatim.
458 if (no_data || S_ISGITLINK(spec->mode))
459 printf("M %06o %s ", spec->mode,
461 anonymize_oid(oid_to_hex(&spec->oid)) :
462 oid_to_hex(&spec->oid));
464 struct object *object = lookup_object(the_repository,
466 printf("M %06o :%d ", spec->mode,
467 get_object_mark(object));
469 print_path(spec->path);
470 string_list_insert(changed, spec->path);
475 die("Unexpected comparison status '%c' for %s, %s",
477 ospec->path ? ospec->path : "none",
478 spec->path ? spec->path : "none");
483 static const char *find_encoding(const char *begin, const char *end)
485 const char *needle = "\nencoding ";
488 bol = memmem(begin, end ? end - begin : strlen(begin),
489 needle, strlen(needle));
492 bol += strlen(needle);
493 eol = strchrnul(bol, '\n');
498 static char *anonymize_ref_component(const char *old, size_t len)
501 struct strbuf out = STRBUF_INIT;
502 strbuf_addf(&out, "ref%d", counter++);
503 return strbuf_detach(&out, NULL);
506 static const char *anonymize_refname(const char *refname)
509 * If any of these prefixes is found, we will leave it intact
510 * so that tags remain tags and so forth.
512 static const char *prefixes[] = {
518 static struct hashmap refs;
519 static struct strbuf anon = STRBUF_INIT;
523 * We also leave "master" as a special case, since it does not reveal
524 * anything interesting.
526 if (!strcmp(refname, "refs/heads/master"))
530 for (i = 0; i < ARRAY_SIZE(prefixes); i++) {
531 if (skip_prefix(refname, prefixes[i], &refname)) {
532 strbuf_addstr(&anon, prefixes[i]);
537 anonymize_path(&anon, refname, &refs, anonymize_ref_component);
542 * We do not even bother to cache commit messages, as they are unlikely
543 * to be repeated verbatim, and it is not that interesting when they are.
545 static char *anonymize_commit_message(const char *old)
548 return xstrfmt("subject %d\n\nbody\n", counter++);
551 static struct hashmap idents;
552 static char *anonymize_ident(const char *old, size_t len)
555 struct strbuf out = STRBUF_INIT;
556 strbuf_addf(&out, "User %d <user%d@example.com>", counter, counter);
558 return strbuf_detach(&out, NULL);
562 * Our strategy here is to anonymize the names and email addresses,
563 * but keep timestamps intact, as they influence things like traversal
564 * order (and by themselves should not be too revealing).
566 static void anonymize_ident_line(const char **beg, const char **end)
568 static struct strbuf buffers[] = { STRBUF_INIT, STRBUF_INIT };
569 static unsigned which_buffer;
572 struct ident_split split;
573 const char *end_of_header;
575 out = &buffers[which_buffer++];
576 which_buffer %= ARRAY_SIZE(buffers);
579 /* skip "committer", "author", "tagger", etc */
580 end_of_header = strchr(*beg, ' ');
582 BUG("malformed line fed to anonymize_ident_line: %.*s",
583 (int)(*end - *beg), *beg);
585 strbuf_add(out, *beg, end_of_header - *beg);
587 if (!split_ident_line(&split, end_of_header, *end - end_of_header) &&
592 len = split.mail_end - split.name_begin;
593 ident = anonymize_str(&idents, anonymize_ident,
594 split.name_begin, len);
595 strbuf_addstr(out, ident);
596 strbuf_addch(out, ' ');
597 strbuf_add(out, split.date_begin, split.tz_end - split.date_begin);
599 strbuf_addstr(out, "Malformed Ident <malformed@example.com> 0 -0000");
603 *end = out->buf + out->len;
606 static void handle_commit(struct commit *commit, struct rev_info *rev,
607 struct string_list *paths_of_changed_objects)
609 int saved_output_format = rev->diffopt.output_format;
610 const char *commit_buffer;
611 const char *author, *author_end, *committer, *committer_end;
612 const char *encoding, *message;
613 char *reencoded = NULL;
614 struct commit_list *p;
618 rev->diffopt.output_format = DIFF_FORMAT_CALLBACK;
620 parse_commit_or_die(commit);
621 commit_buffer = get_commit_buffer(commit, NULL);
622 author = strstr(commit_buffer, "\nauthor ");
624 die("could not find author in commit %s",
625 oid_to_hex(&commit->object.oid));
627 author_end = strchrnul(author, '\n');
628 committer = strstr(author_end, "\ncommitter ");
630 die("could not find committer in commit %s",
631 oid_to_hex(&commit->object.oid));
633 committer_end = strchrnul(committer, '\n');
634 message = strstr(committer_end, "\n\n");
635 encoding = find_encoding(committer_end, message);
639 if (commit->parents &&
640 (get_object_mark(&commit->parents->item->object) != 0 ||
641 reference_excluded_commits) &&
643 parse_commit_or_die(commit->parents->item);
644 diff_tree_oid(get_commit_tree_oid(commit->parents->item),
645 get_commit_tree_oid(commit), "", &rev->diffopt);
648 diff_root_tree_oid(get_commit_tree_oid(commit),
651 /* Export the referenced blobs, and remember the marks. */
652 for (i = 0; i < diff_queued_diff.nr; i++)
653 if (!S_ISGITLINK(diff_queued_diff.queue[i]->two->mode))
654 export_blob(&diff_queued_diff.queue[i]->two->oid);
656 refname = *revision_sources_at(&revision_sources, commit);
658 * FIXME: string_list_remove() below for each ref is overall
659 * O(N^2). Compared to a history walk and diffing trees, this is
660 * just lost in the noise in practice. However, theoretically a
661 * repo may have enough refs for this to become slow.
663 string_list_remove(&extra_refs, refname, 0);
665 refname = anonymize_refname(refname);
666 anonymize_ident_line(&committer, &committer_end);
667 anonymize_ident_line(&author, &author_end);
670 mark_next_object(&commit->object);
672 reencoded = anonymize_commit_message(message);
673 } else if (encoding) {
674 switch(reencode_mode) {
676 reencoded = reencode_string(message, "UTF-8", encoding);
681 die("Encountered commit-specific encoding %s in commit "
682 "%s; use --reencode=[yes|no] to handle it",
683 encoding, oid_to_hex(&commit->object.oid));
686 if (!commit->parents)
687 printf("reset %s\n", refname);
688 printf("commit %s\nmark :%"PRIu32"\n", refname, last_idnum);
689 if (show_original_ids)
690 printf("original-oid %s\n", oid_to_hex(&commit->object.oid));
691 printf("%.*s\n%.*s\n",
692 (int)(author_end - author), author,
693 (int)(committer_end - committer), committer);
694 if (!reencoded && encoding)
695 printf("encoding %s\n", encoding);
696 printf("data %u\n%s",
698 ? strlen(reencoded) : message
699 ? strlen(message) : 0),
700 reencoded ? reencoded : message ? message : "");
702 unuse_commit_buffer(commit, commit_buffer);
704 for (i = 0, p = commit->parents; p; p = p->next) {
705 struct object *obj = &p->item->object;
706 int mark = get_object_mark(obj);
708 if (!mark && !reference_excluded_commits)
715 printf(":%d\n", mark);
719 anonymize_oid(oid_to_hex(&obj->oid)) :
720 oid_to_hex(&obj->oid));
725 printf("deleteall\n");
726 log_tree_diff_flush(rev);
727 string_list_clear(paths_of_changed_objects, 0);
728 rev->diffopt.output_format = saved_output_format;
735 static char *anonymize_tag(const char *old, size_t len)
738 struct strbuf out = STRBUF_INIT;
739 strbuf_addf(&out, "tag message %d", counter++);
740 return strbuf_detach(&out, NULL);
743 static void handle_tail(struct object_array *commits, struct rev_info *revs,
744 struct string_list *paths_of_changed_objects)
746 struct commit *commit;
747 while (commits->nr) {
748 commit = (struct commit *)object_array_pop(commits);
749 if (has_unshown_parent(commit)) {
750 /* Queue again, to be handled later */
751 add_object_array(&commit->object, NULL, commits);
754 handle_commit(commit, revs, paths_of_changed_objects);
758 static void handle_tag(const char *name, struct tag *tag)
761 enum object_type type;
763 const char *tagger, *tagger_end, *message;
764 size_t message_size = 0;
765 struct object *tagged;
769 /* Trees have no identifier in fast-export output, thus we have no way
770 * to output tags of trees, tags of tags of trees, etc. Simply omit
773 tagged = tag->tagged;
774 while (tagged->type == OBJ_TAG) {
775 tagged = ((struct tag *)tagged)->tagged;
777 if (tagged->type == OBJ_TREE) {
778 warning("Omitting tag %s,\nsince tags of trees (or tags of tags of trees, etc.) are not supported.",
779 oid_to_hex(&tag->object.oid));
783 buf = read_object_file(&tag->object.oid, &type, &size);
785 die("could not read tag %s", oid_to_hex(&tag->object.oid));
786 message = memmem(buf, size, "\n\n", 2);
789 message_size = strlen(message);
791 tagger = memmem(buf, message ? message - buf : size, "\ntagger ", 8);
793 if (fake_missing_tagger)
794 tagger = "tagger Unspecified Tagger "
795 "<unspecified-tagger> 0 +0000";
798 tagger_end = tagger + strlen(tagger);
801 tagger_end = strchrnul(tagger, '\n');
803 anonymize_ident_line(&tagger, &tagger_end);
807 name = anonymize_refname(name);
809 static struct hashmap tags;
810 message = anonymize_str(&tags, anonymize_tag,
811 message, message_size);
815 /* handle signed tags */
817 const char *signature = strstr(message,
818 "\n-----BEGIN PGP SIGNATURE-----\n");
820 switch(signed_tag_mode) {
821 case SIGNED_TAG_ABORT:
822 die("encountered signed tag %s; use "
823 "--signed-tags=<mode> to handle it",
824 oid_to_hex(&tag->object.oid));
826 warning("exporting signed tag %s",
827 oid_to_hex(&tag->object.oid));
832 warning("stripping signature from tag %s",
833 oid_to_hex(&tag->object.oid));
836 message_size = signature + 1 - message;
841 /* handle tag->tagged having been filtered out due to paths specified */
842 tagged = tag->tagged;
843 tagged_mark = get_object_mark(tagged);
845 switch(tag_of_filtered_mode) {
846 case TAG_FILTERING_ABORT:
847 die("tag %s tags unexported object; use "
848 "--tag-of-filtered-object=<mode> to handle it",
849 oid_to_hex(&tag->object.oid));
851 /* Ignore this tag altogether */
855 if (tagged->type == OBJ_TAG && !mark_tags) {
856 die(_("Error: Cannot export nested tags unless --mark-tags is specified."));
857 } else if (tagged->type == OBJ_COMMIT) {
858 p = rewrite_commit((struct commit *)tagged);
860 printf("reset %s\nfrom %s\n\n",
861 name, oid_to_hex(&null_oid));
865 tagged_mark = get_object_mark(&p->object);
867 /* tagged->type is either OBJ_BLOB or OBJ_TAG */
868 tagged_mark = get_object_mark(tagged);
873 if (tagged->type == OBJ_TAG) {
874 printf("reset %s\nfrom %s\n\n",
875 name, oid_to_hex(&null_oid));
877 skip_prefix(name, "refs/tags/", &name);
878 printf("tag %s\n", name);
880 mark_next_object(&tag->object);
881 printf("mark :%"PRIu32"\n", last_idnum);
884 printf("from :%d\n", tagged_mark);
886 printf("from %s\n", oid_to_hex(&tagged->oid));
888 if (show_original_ids)
889 printf("original-oid %s\n", oid_to_hex(&tag->object.oid));
890 printf("%.*s%sdata %d\n%.*s\n",
891 (int)(tagger_end - tagger), tagger,
892 tagger == tagger_end ? "" : "\n",
893 (int)message_size, (int)message_size, message ? message : "");
897 static struct commit *get_commit(struct rev_cmdline_entry *e, char *full_name)
899 switch (e->item->type) {
901 return (struct commit *)e->item;
903 struct tag *tag = (struct tag *)e->item;
905 /* handle nested tags */
906 while (tag && tag->object.type == OBJ_TAG) {
907 parse_object(the_repository, &tag->object.oid);
908 string_list_append(&tag_refs, full_name)->util = tag;
909 tag = (struct tag *)tag->tagged;
912 die("Tag %s points nowhere?", e->name);
913 return (struct commit *)tag;
921 static void get_tags_and_duplicates(struct rev_cmdline_info *info)
925 for (i = 0; i < info->nr; i++) {
926 struct rev_cmdline_entry *e = info->rev + i;
927 struct object_id oid;
928 struct commit *commit;
931 if (e->flags & UNINTERESTING)
934 if (dwim_ref(e->name, strlen(e->name), &oid, &full_name) != 1)
939 private = apply_refspecs(&refspecs, full_name);
946 commit = get_commit(e, full_name);
948 warning("%s: Unexpected object of type %s, skipping.",
950 type_name(e->item->type));
954 switch(commit->object.type) {
958 export_blob(&commit->object.oid);
960 default: /* OBJ_TAG (nested tags) is already handled */
961 warning("Tag points to object of unexpected type %s, skipping.",
962 type_name(commit->object.type));
967 * Make sure this ref gets properly updated eventually, whether
968 * through a commit or manually at the end.
970 if (e->item->type != OBJ_TAG)
971 string_list_append(&extra_refs, full_name)->util = commit;
973 if (!*revision_sources_at(&revision_sources, commit))
974 *revision_sources_at(&revision_sources, commit) = full_name;
977 string_list_sort(&extra_refs);
978 string_list_remove_duplicates(&extra_refs, 0);
981 static void handle_tags_and_duplicates(struct string_list *extras)
983 struct commit *commit;
986 for (i = extras->nr - 1; i >= 0; i--) {
987 const char *name = extras->items[i].string;
988 struct object *object = extras->items[i].util;
991 switch (object->type) {
993 handle_tag(name, (struct tag *)object);
997 name = anonymize_refname(name);
998 /* create refs pointing to already seen commits */
999 commit = rewrite_commit((struct commit *)object);
1002 * Neither this object nor any of its
1003 * ancestors touch any relevant paths, so
1004 * it has been filtered to nothing. Delete
1007 printf("reset %s\nfrom %s\n\n",
1008 name, oid_to_hex(&null_oid));
1012 mark = get_object_mark(&commit->object);
1015 * Getting here means we have a commit which
1016 * was excluded by a negative refspec (e.g.
1017 * fast-export ^master master). If we are
1018 * referencing excluded commits, set the ref
1019 * to the exact commit. Otherwise, the user
1020 * wants the branch exported but every commit
1021 * in its history to be deleted, which basically
1022 * just means deletion of the ref.
1024 if (!reference_excluded_commits) {
1025 /* delete the ref */
1026 printf("reset %s\nfrom %s\n\n",
1027 name, oid_to_hex(&null_oid));
1030 /* set ref to commit using oid, not mark */
1031 printf("reset %s\nfrom %s\n\n", name,
1032 oid_to_hex(&commit->object.oid));
1036 printf("reset %s\nfrom :%d\n\n", name, mark
1044 static void export_marks(char *file)
1048 struct decoration_entry *deco = idnums.entries;
1052 f = fopen_for_writing(file);
1054 die_errno("Unable to open marks file %s for writing.", file);
1056 for (i = 0; i < idnums.size; i++) {
1057 if (deco->base && deco->base->type == 1) {
1058 mark = ptr_to_mark(deco->decoration);
1059 if (fprintf(f, ":%"PRIu32" %s\n", mark,
1060 oid_to_hex(&deco->base->oid)) < 0) {
1071 error("Unable to write marks file %s.", file);
1074 static void import_marks(char *input_file, int check_exists)
1080 if (check_exists && stat(input_file, &sb))
1083 f = xfopen(input_file, "r");
1084 while (fgets(line, sizeof(line), f)) {
1086 char *line_end, *mark_end;
1087 struct object_id oid;
1088 struct object *object;
1089 struct commit *commit;
1090 enum object_type type;
1092 line_end = strchr(line, '\n');
1093 if (line[0] != ':' || !line_end)
1094 die("corrupt mark line: %s", line);
1097 mark = strtoumax(line + 1, &mark_end, 10);
1098 if (!mark || mark_end == line + 1
1099 || *mark_end != ' ' || get_oid_hex(mark_end + 1, &oid))
1100 die("corrupt mark line: %s", line);
1102 if (last_idnum < mark)
1105 type = oid_object_info(the_repository, &oid, NULL);
1107 die("object not found: %s", oid_to_hex(&oid));
1109 if (type != OBJ_COMMIT)
1113 commit = lookup_commit(the_repository, &oid);
1115 die("not a commit? can't happen: %s", oid_to_hex(&oid));
1117 object = &commit->object;
1119 if (object->flags & SHOWN)
1120 error("Object %s already has a mark", oid_to_hex(&oid));
1122 mark_object(object, mark);
1124 object->flags |= SHOWN;
1129 static void handle_deletes(void)
1132 for (i = 0; i < refspecs.nr; i++) {
1133 struct refspec_item *refspec = &refspecs.items[i];
1137 printf("reset %s\nfrom %s\n\n",
1138 refspec->dst, oid_to_hex(&null_oid));
1142 int cmd_fast_export(int argc, const char **argv, const char *prefix)
1144 struct rev_info revs;
1145 struct object_array commits = OBJECT_ARRAY_INIT;
1146 struct commit *commit;
1147 char *export_filename = NULL,
1148 *import_filename = NULL,
1149 *import_filename_if_exists = NULL;
1150 uint32_t lastimportid;
1151 struct string_list refspecs_list = STRING_LIST_INIT_NODUP;
1152 struct string_list paths_of_changed_objects = STRING_LIST_INIT_DUP;
1153 struct option options[] = {
1154 OPT_INTEGER(0, "progress", &progress,
1155 N_("show progress after <n> objects")),
1156 OPT_CALLBACK(0, "signed-tags", &signed_tag_mode, N_("mode"),
1157 N_("select handling of signed tags"),
1158 parse_opt_signed_tag_mode),
1159 OPT_CALLBACK(0, "tag-of-filtered-object", &tag_of_filtered_mode, N_("mode"),
1160 N_("select handling of tags that tag filtered objects"),
1161 parse_opt_tag_of_filtered_mode),
1162 OPT_CALLBACK(0, "reencode", &reencode_mode, N_("mode"),
1163 N_("select handling of commit messages in an alternate encoding"),
1164 parse_opt_reencode_mode),
1165 OPT_STRING(0, "export-marks", &export_filename, N_("file"),
1166 N_("Dump marks to this file")),
1167 OPT_STRING(0, "import-marks", &import_filename, N_("file"),
1168 N_("Import marks from this file")),
1169 OPT_STRING(0, "import-marks-if-exists",
1170 &import_filename_if_exists,
1172 N_("Import marks from this file if it exists")),
1173 OPT_BOOL(0, "fake-missing-tagger", &fake_missing_tagger,
1174 N_("Fake a tagger when tags lack one")),
1175 OPT_BOOL(0, "full-tree", &full_tree,
1176 N_("Output full tree for each commit")),
1177 OPT_BOOL(0, "use-done-feature", &use_done_feature,
1178 N_("Use the done feature to terminate the stream")),
1179 OPT_BOOL(0, "no-data", &no_data, N_("Skip output of blob data")),
1180 OPT_STRING_LIST(0, "refspec", &refspecs_list, N_("refspec"),
1181 N_("Apply refspec to exported refs")),
1182 OPT_BOOL(0, "anonymize", &anonymize, N_("anonymize output")),
1183 OPT_BOOL(0, "reference-excluded-parents",
1184 &reference_excluded_commits, N_("Reference parents which are not in fast-export stream by object id")),
1185 OPT_BOOL(0, "show-original-ids", &show_original_ids,
1186 N_("Show original object ids of blobs/commits")),
1187 OPT_BOOL(0, "mark-tags", &mark_tags,
1188 N_("Label tags with mark ids")),
1194 usage_with_options (fast_export_usage, options);
1196 /* we handle encodings */
1197 git_config(git_default_config, NULL);
1199 repo_init_revisions(the_repository, &revs, prefix);
1200 init_revision_sources(&revision_sources);
1201 revs.topo_order = 1;
1202 revs.sources = &revision_sources;
1203 revs.rewrite_parents = 1;
1204 argc = parse_options(argc, argv, prefix, options, fast_export_usage,
1205 PARSE_OPT_KEEP_ARGV0 | PARSE_OPT_KEEP_UNKNOWN);
1206 argc = setup_revisions(argc, argv, &revs, NULL);
1208 usage_with_options (fast_export_usage, options);
1210 if (refspecs_list.nr) {
1213 for (i = 0; i < refspecs_list.nr; i++)
1214 refspec_append(&refspecs, refspecs_list.items[i].string);
1216 string_list_clear(&refspecs_list, 1);
1219 if (use_done_feature)
1220 printf("feature done\n");
1222 if (import_filename && import_filename_if_exists)
1223 die(_("Cannot pass both --import-marks and --import-marks-if-exists"));
1224 if (import_filename)
1225 import_marks(import_filename, 0);
1226 else if (import_filename_if_exists)
1227 import_marks(import_filename_if_exists, 1);
1228 lastimportid = last_idnum;
1230 if (import_filename && revs.prune_data.nr)
1233 get_tags_and_duplicates(&revs.cmdline);
1235 if (prepare_revision_walk(&revs))
1236 die("revision walk setup failed");
1237 revs.diffopt.format_callback = show_filemodify;
1238 revs.diffopt.format_callback_data = &paths_of_changed_objects;
1239 revs.diffopt.flags.recursive = 1;
1240 while ((commit = get_revision(&revs))) {
1241 if (has_unshown_parent(commit)) {
1242 add_object_array(&commit->object, NULL, &commits);
1245 handle_commit(commit, &revs, &paths_of_changed_objects);
1246 handle_tail(&commits, &revs, &paths_of_changed_objects);
1250 handle_tags_and_duplicates(&extra_refs);
1251 handle_tags_and_duplicates(&tag_refs);
1254 if (export_filename && lastimportid != last_idnum)
1255 export_marks(export_filename);
1257 if (use_done_feature)
1260 refspec_clear(&refspecs);