2 * "git fast-export" builtin command
4 * Copyright (C) 2007 Johannes E. Schindelin
10 #include "object-store.h"
19 #include "string-list.h"
21 #include "parse-options.h"
26 static const char *fast_export_usage
[] = {
27 N_("git fast-export [rev-list-opts]"),
32 static enum { ABORT
, VERBATIM
, WARN
, WARN_STRIP
, STRIP
} signed_tag_mode
= ABORT
;
33 static enum { ERROR
, DROP
, REWRITE
} tag_of_filtered_mode
= ERROR
;
34 static int fake_missing_tagger
;
35 static int use_done_feature
;
38 static struct string_list extra_refs
= STRING_LIST_INIT_NODUP
;
39 static struct refspec
*refspecs
;
40 static int refspecs_nr
;
43 static int parse_opt_signed_tag_mode(const struct option
*opt
,
44 const char *arg
, int unset
)
46 if (unset
|| !strcmp(arg
, "abort"))
47 signed_tag_mode
= ABORT
;
48 else if (!strcmp(arg
, "verbatim") || !strcmp(arg
, "ignore"))
49 signed_tag_mode
= VERBATIM
;
50 else if (!strcmp(arg
, "warn"))
51 signed_tag_mode
= WARN
;
52 else if (!strcmp(arg
, "warn-strip"))
53 signed_tag_mode
= WARN_STRIP
;
54 else if (!strcmp(arg
, "strip"))
55 signed_tag_mode
= STRIP
;
57 return error("Unknown signed-tags mode: %s", arg
);
61 static int parse_opt_tag_of_filtered_mode(const struct option
*opt
,
62 const char *arg
, int unset
)
64 if (unset
|| !strcmp(arg
, "abort"))
65 tag_of_filtered_mode
= ERROR
;
66 else if (!strcmp(arg
, "drop"))
67 tag_of_filtered_mode
= DROP
;
68 else if (!strcmp(arg
, "rewrite"))
69 tag_of_filtered_mode
= REWRITE
;
71 return error("Unknown tag-of-filtered mode: %s", arg
);
75 static struct decoration idnums
;
76 static uint32_t last_idnum
;
78 static int has_unshown_parent(struct commit
*commit
)
80 struct commit_list
*parent
;
82 for (parent
= commit
->parents
; parent
; parent
= parent
->next
)
83 if (!(parent
->item
->object
.flags
& SHOWN
) &&
84 !(parent
->item
->object
.flags
& UNINTERESTING
))
89 struct anonymized_entry
{
90 struct hashmap_entry hash
;
97 static int anonymized_entry_cmp(const void *unused_cmp_data
,
98 const void *va
, const void *vb
,
99 const void *unused_keydata
)
101 const struct anonymized_entry
*a
= va
, *b
= vb
;
102 return a
->orig_len
!= b
->orig_len
||
103 memcmp(a
->orig
, b
->orig
, a
->orig_len
);
107 * Basically keep a cache of X->Y so that we can repeatedly replace
108 * the same anonymized string with another. The actual generation
109 * is farmed out to the generate function.
111 static const void *anonymize_mem(struct hashmap
*map
,
112 void *(*generate
)(const void *, size_t *),
113 const void *orig
, size_t *len
)
115 struct anonymized_entry key
, *ret
;
118 hashmap_init(map
, anonymized_entry_cmp
, NULL
, 0);
120 hashmap_entry_init(&key
, memhash(orig
, *len
));
123 ret
= hashmap_get(map
, &key
, NULL
);
126 ret
= xmalloc(sizeof(*ret
));
127 hashmap_entry_init(&ret
->hash
, key
.hash
.hash
);
128 ret
->orig
= xstrdup(orig
);
129 ret
->orig_len
= *len
;
130 ret
->anon
= generate(orig
, len
);
131 ret
->anon_len
= *len
;
132 hashmap_put(map
, ret
);
135 *len
= ret
->anon_len
;
140 * We anonymize each component of a path individually,
141 * so that paths a/b and a/c will share a common root.
142 * The paths are cached via anonymize_mem so that repeated
143 * lookups for "a" will yield the same value.
145 static void anonymize_path(struct strbuf
*out
, const char *path
,
147 void *(*generate
)(const void *, size_t *))
150 const char *end_of_component
= strchrnul(path
, '/');
151 size_t len
= end_of_component
- path
;
152 const char *c
= anonymize_mem(map
, generate
, path
, &len
);
153 strbuf_add(out
, c
, len
);
154 path
= end_of_component
;
156 strbuf_addch(out
, *path
++);
160 /* Since intptr_t is C99, we do not use it here */
161 static inline uint32_t *mark_to_ptr(uint32_t mark
)
163 return ((uint32_t *)NULL
) + mark
;
166 static inline uint32_t ptr_to_mark(void * mark
)
168 return (uint32_t *)mark
- (uint32_t *)NULL
;
171 static inline void mark_object(struct object
*object
, uint32_t mark
)
173 add_decoration(&idnums
, object
, mark_to_ptr(mark
));
176 static inline void mark_next_object(struct object
*object
)
178 mark_object(object
, ++last_idnum
);
181 static int get_object_mark(struct object
*object
)
183 void *decoration
= lookup_decoration(&idnums
, object
);
186 return ptr_to_mark(decoration
);
189 static void show_progress(void)
191 static int counter
= 0;
194 if ((++counter
% progress
) == 0)
195 printf("progress %d objects\n", counter
);
199 * Ideally we would want some transformation of the blob data here
200 * that is unreversible, but would still be the same size and have
201 * the same data relationship to other blobs (so that we get the same
202 * delta and packing behavior as the original). But the first and last
203 * requirements there are probably mutually exclusive, so let's take
204 * the easy way out for now, and just generate arbitrary content.
206 * There's no need to cache this result with anonymize_mem, since
207 * we already handle blob content caching with marks.
209 static char *anonymize_blob(unsigned long *size
)
212 struct strbuf out
= STRBUF_INIT
;
213 strbuf_addf(&out
, "anonymous blob %d", counter
++);
215 return strbuf_detach(&out
, NULL
);
218 static void export_blob(const struct object_id
*oid
)
221 enum object_type type
;
223 struct object
*object
;
229 if (is_null_oid(oid
))
232 object
= lookup_object(oid
->hash
);
233 if (object
&& object
->flags
& SHOWN
)
237 buf
= anonymize_blob(&size
);
238 object
= (struct object
*)lookup_blob(oid
);
241 buf
= read_object_file(oid
, &type
, &size
);
243 die ("Could not read blob %s", oid_to_hex(oid
));
244 if (check_object_signature(oid
, buf
, size
, type_name(type
)) < 0)
245 die("sha1 mismatch in blob %s", oid_to_hex(oid
));
246 object
= parse_object_buffer(oid
, type
, size
, buf
, &eaten
);
250 die("Could not read blob %s", oid_to_hex(oid
));
252 mark_next_object(object
);
254 printf("blob\nmark :%"PRIu32
"\ndata %lu\n", last_idnum
, size
);
255 if (size
&& fwrite(buf
, size
, 1, stdout
) != 1)
256 die_errno ("Could not write blob '%s'", oid_to_hex(oid
));
261 object
->flags
|= SHOWN
;
266 static int depth_first(const void *a_
, const void *b_
)
268 const struct diff_filepair
*a
= *((const struct diff_filepair
**)a_
);
269 const struct diff_filepair
*b
= *((const struct diff_filepair
**)b_
);
270 const char *name_a
, *name_b
;
271 int len_a
, len_b
, len
;
274 name_a
= a
->one
? a
->one
->path
: a
->two
->path
;
275 name_b
= b
->one
? b
->one
->path
: b
->two
->path
;
277 len_a
= strlen(name_a
);
278 len_b
= strlen(name_b
);
279 len
= (len_a
< len_b
) ? len_a
: len_b
;
281 /* strcmp will sort 'd' before 'd/e', we want 'd/e' before 'd' */
282 cmp
= memcmp(name_a
, name_b
, len
);
289 * Move 'R'ename entries last so that all references of the file
290 * appear in the output before it is renamed (e.g., when a file
291 * was copied and renamed in the same commit).
293 return (a
->status
== 'R') - (b
->status
== 'R');
296 static void print_path_1(const char *path
)
298 int need_quote
= quote_c_style(path
, NULL
, NULL
, 0);
300 quote_c_style(path
, NULL
, stdout
, 0);
301 else if (strchr(path
, ' '))
302 printf("\"%s\"", path
);
307 static void *anonymize_path_component(const void *path
, size_t *len
)
310 struct strbuf out
= STRBUF_INIT
;
311 strbuf_addf(&out
, "path%d", counter
++);
312 return strbuf_detach(&out
, len
);
315 static void print_path(const char *path
)
320 static struct hashmap paths
;
321 static struct strbuf anon
= STRBUF_INIT
;
323 anonymize_path(&anon
, path
, &paths
, anonymize_path_component
);
324 print_path_1(anon
.buf
);
329 static void *generate_fake_oid(const void *old
, size_t *len
)
331 static uint32_t counter
= 1; /* avoid null sha1 */
332 unsigned char *out
= xcalloc(GIT_SHA1_RAWSZ
, 1);
333 put_be32(out
+ GIT_SHA1_RAWSZ
- 4, counter
++);
337 static const unsigned char *anonymize_sha1(const struct object_id
*oid
)
339 static struct hashmap sha1s
;
340 size_t len
= GIT_SHA1_RAWSZ
;
341 return anonymize_mem(&sha1s
, generate_fake_oid
, oid
, &len
);
344 static void show_filemodify(struct diff_queue_struct
*q
,
345 struct diff_options
*options
, void *data
)
348 struct string_list
*changed
= data
;
351 * Handle files below a directory first, in case they are all deleted
352 * and the directory changes to a file or symlink.
354 QSORT(q
->queue
, q
->nr
, depth_first
);
356 for (i
= 0; i
< q
->nr
; i
++) {
357 struct diff_filespec
*ospec
= q
->queue
[i
]->one
;
358 struct diff_filespec
*spec
= q
->queue
[i
]->two
;
360 switch (q
->queue
[i
]->status
) {
361 case DIFF_STATUS_DELETED
:
363 print_path(spec
->path
);
364 string_list_insert(changed
, spec
->path
);
368 case DIFF_STATUS_COPIED
:
369 case DIFF_STATUS_RENAMED
:
371 * If a change in the file corresponding to ospec->path
372 * has been observed, we cannot trust its contents
373 * because the diff is calculated based on the prior
374 * contents, not the current contents. So, declare a
375 * copy or rename only if there was no change observed.
377 if (!string_list_has_string(changed
, ospec
->path
)) {
378 printf("%c ", q
->queue
[i
]->status
);
379 print_path(ospec
->path
);
381 print_path(spec
->path
);
382 string_list_insert(changed
, spec
->path
);
385 if (!oidcmp(&ospec
->oid
, &spec
->oid
) &&
386 ospec
->mode
== spec
->mode
)
391 case DIFF_STATUS_TYPE_CHANGED
:
392 case DIFF_STATUS_MODIFIED
:
393 case DIFF_STATUS_ADDED
:
395 * Links refer to objects in another repositories;
396 * output the SHA-1 verbatim.
398 if (no_data
|| S_ISGITLINK(spec
->mode
))
399 printf("M %06o %s ", spec
->mode
,
400 sha1_to_hex(anonymize
?
401 anonymize_sha1(&spec
->oid
) :
404 struct object
*object
= lookup_object(spec
->oid
.hash
);
405 printf("M %06o :%d ", spec
->mode
,
406 get_object_mark(object
));
408 print_path(spec
->path
);
409 string_list_insert(changed
, spec
->path
);
414 die("Unexpected comparison status '%c' for %s, %s",
416 ospec
->path
? ospec
->path
: "none",
417 spec
->path
? spec
->path
: "none");
422 static const char *find_encoding(const char *begin
, const char *end
)
424 const char *needle
= "\nencoding ";
427 bol
= memmem(begin
, end
? end
- begin
: strlen(begin
),
428 needle
, strlen(needle
));
430 return git_commit_encoding
;
431 bol
+= strlen(needle
);
432 eol
= strchrnul(bol
, '\n');
437 static void *anonymize_ref_component(const void *old
, size_t *len
)
440 struct strbuf out
= STRBUF_INIT
;
441 strbuf_addf(&out
, "ref%d", counter
++);
442 return strbuf_detach(&out
, len
);
445 static const char *anonymize_refname(const char *refname
)
448 * If any of these prefixes is found, we will leave it intact
449 * so that tags remain tags and so forth.
451 static const char *prefixes
[] = {
457 static struct hashmap refs
;
458 static struct strbuf anon
= STRBUF_INIT
;
462 * We also leave "master" as a special case, since it does not reveal
463 * anything interesting.
465 if (!strcmp(refname
, "refs/heads/master"))
469 for (i
= 0; i
< ARRAY_SIZE(prefixes
); i
++) {
470 if (skip_prefix(refname
, prefixes
[i
], &refname
)) {
471 strbuf_addstr(&anon
, prefixes
[i
]);
476 anonymize_path(&anon
, refname
, &refs
, anonymize_ref_component
);
481 * We do not even bother to cache commit messages, as they are unlikely
482 * to be repeated verbatim, and it is not that interesting when they are.
484 static char *anonymize_commit_message(const char *old
)
487 return xstrfmt("subject %d\n\nbody\n", counter
++);
490 static struct hashmap idents
;
491 static void *anonymize_ident(const void *old
, size_t *len
)
494 struct strbuf out
= STRBUF_INIT
;
495 strbuf_addf(&out
, "User %d <user%d@example.com>", counter
, counter
);
497 return strbuf_detach(&out
, len
);
501 * Our strategy here is to anonymize the names and email addresses,
502 * but keep timestamps intact, as they influence things like traversal
503 * order (and by themselves should not be too revealing).
505 static void anonymize_ident_line(const char **beg
, const char **end
)
507 static struct strbuf buffers
[] = { STRBUF_INIT
, STRBUF_INIT
};
508 static unsigned which_buffer
;
511 struct ident_split split
;
512 const char *end_of_header
;
514 out
= &buffers
[which_buffer
++];
515 which_buffer
%= ARRAY_SIZE(buffers
);
518 /* skip "committer", "author", "tagger", etc */
519 end_of_header
= strchr(*beg
, ' ');
521 die("BUG: malformed line fed to anonymize_ident_line: %.*s",
522 (int)(*end
- *beg
), *beg
);
524 strbuf_add(out
, *beg
, end_of_header
- *beg
);
526 if (!split_ident_line(&split
, end_of_header
, *end
- end_of_header
) &&
531 len
= split
.mail_end
- split
.name_begin
;
532 ident
= anonymize_mem(&idents
, anonymize_ident
,
533 split
.name_begin
, &len
);
534 strbuf_add(out
, ident
, len
);
535 strbuf_addch(out
, ' ');
536 strbuf_add(out
, split
.date_begin
, split
.tz_end
- split
.date_begin
);
538 strbuf_addstr(out
, "Malformed Ident <malformed@example.com> 0 -0000");
542 *end
= out
->buf
+ out
->len
;
545 static void handle_commit(struct commit
*commit
, struct rev_info
*rev
,
546 struct string_list
*paths_of_changed_objects
)
548 int saved_output_format
= rev
->diffopt
.output_format
;
549 const char *commit_buffer
;
550 const char *author
, *author_end
, *committer
, *committer_end
;
551 const char *encoding
, *message
;
552 char *reencoded
= NULL
;
553 struct commit_list
*p
;
557 rev
->diffopt
.output_format
= DIFF_FORMAT_CALLBACK
;
559 parse_commit_or_die(commit
);
560 commit_buffer
= get_commit_buffer(commit
, NULL
);
561 author
= strstr(commit_buffer
, "\nauthor ");
563 die ("Could not find author in commit %s",
564 oid_to_hex(&commit
->object
.oid
));
566 author_end
= strchrnul(author
, '\n');
567 committer
= strstr(author_end
, "\ncommitter ");
569 die ("Could not find committer in commit %s",
570 oid_to_hex(&commit
->object
.oid
));
572 committer_end
= strchrnul(committer
, '\n');
573 message
= strstr(committer_end
, "\n\n");
574 encoding
= find_encoding(committer_end
, message
);
578 if (commit
->parents
&&
579 get_object_mark(&commit
->parents
->item
->object
) != 0 &&
581 parse_commit_or_die(commit
->parents
->item
);
582 diff_tree_oid(&commit
->parents
->item
->tree
->object
.oid
,
583 &commit
->tree
->object
.oid
, "", &rev
->diffopt
);
586 diff_root_tree_oid(&commit
->tree
->object
.oid
,
589 /* Export the referenced blobs, and remember the marks. */
590 for (i
= 0; i
< diff_queued_diff
.nr
; i
++)
591 if (!S_ISGITLINK(diff_queued_diff
.queue
[i
]->two
->mode
))
592 export_blob(&diff_queued_diff
.queue
[i
]->two
->oid
);
594 refname
= commit
->util
;
596 refname
= anonymize_refname(refname
);
597 anonymize_ident_line(&committer
, &committer_end
);
598 anonymize_ident_line(&author
, &author_end
);
601 mark_next_object(&commit
->object
);
603 reencoded
= anonymize_commit_message(message
);
604 else if (!is_encoding_utf8(encoding
))
605 reencoded
= reencode_string(message
, "UTF-8", encoding
);
606 if (!commit
->parents
)
607 printf("reset %s\n", refname
);
608 printf("commit %s\nmark :%"PRIu32
"\n%.*s\n%.*s\ndata %u\n%s",
610 (int)(author_end
- author
), author
,
611 (int)(committer_end
- committer
), committer
,
613 ? strlen(reencoded
) : message
614 ? strlen(message
) : 0),
615 reencoded
? reencoded
: message
? message
: "");
617 unuse_commit_buffer(commit
, commit_buffer
);
619 for (i
= 0, p
= commit
->parents
; p
; p
= p
->next
) {
620 int mark
= get_object_mark(&p
->item
->object
);
624 printf("from :%d\n", mark
);
626 printf("merge :%d\n", mark
);
631 printf("deleteall\n");
632 log_tree_diff_flush(rev
);
633 string_list_clear(paths_of_changed_objects
, 0);
634 rev
->diffopt
.output_format
= saved_output_format
;
641 static void *anonymize_tag(const void *old
, size_t *len
)
644 struct strbuf out
= STRBUF_INIT
;
645 strbuf_addf(&out
, "tag message %d", counter
++);
646 return strbuf_detach(&out
, len
);
649 static void handle_tail(struct object_array
*commits
, struct rev_info
*revs
,
650 struct string_list
*paths_of_changed_objects
)
652 struct commit
*commit
;
653 while (commits
->nr
) {
654 commit
= (struct commit
*)object_array_pop(commits
);
655 if (has_unshown_parent(commit
))
657 handle_commit(commit
, revs
, paths_of_changed_objects
);
661 static void handle_tag(const char *name
, struct tag
*tag
)
664 enum object_type type
;
666 const char *tagger
, *tagger_end
, *message
;
667 size_t message_size
= 0;
668 struct object
*tagged
;
672 /* Trees have no identifier in fast-export output, thus we have no way
673 * to output tags of trees, tags of tags of trees, etc. Simply omit
676 tagged
= tag
->tagged
;
677 while (tagged
->type
== OBJ_TAG
) {
678 tagged
= ((struct tag
*)tagged
)->tagged
;
680 if (tagged
->type
== OBJ_TREE
) {
681 warning("Omitting tag %s,\nsince tags of trees (or tags of tags of trees, etc.) are not supported.",
682 oid_to_hex(&tag
->object
.oid
));
686 buf
= read_object_file(&tag
->object
.oid
, &type
, &size
);
688 die ("Could not read tag %s", oid_to_hex(&tag
->object
.oid
));
689 message
= memmem(buf
, size
, "\n\n", 2);
692 message_size
= strlen(message
);
694 tagger
= memmem(buf
, message
? message
- buf
: size
, "\ntagger ", 8);
696 if (fake_missing_tagger
)
697 tagger
= "tagger Unspecified Tagger "
698 "<unspecified-tagger> 0 +0000";
701 tagger_end
= tagger
+ strlen(tagger
);
704 tagger_end
= strchrnul(tagger
, '\n');
706 anonymize_ident_line(&tagger
, &tagger_end
);
710 name
= anonymize_refname(name
);
712 static struct hashmap tags
;
713 message
= anonymize_mem(&tags
, anonymize_tag
,
714 message
, &message_size
);
718 /* handle signed tags */
720 const char *signature
= strstr(message
,
721 "\n-----BEGIN PGP SIGNATURE-----\n");
723 switch(signed_tag_mode
) {
725 die ("Encountered signed tag %s; use "
726 "--signed-tags=<mode> to handle it.",
727 oid_to_hex(&tag
->object
.oid
));
729 warning ("Exporting signed tag %s",
730 oid_to_hex(&tag
->object
.oid
));
735 warning ("Stripping signature from tag %s",
736 oid_to_hex(&tag
->object
.oid
));
739 message_size
= signature
+ 1 - message
;
744 /* handle tag->tagged having been filtered out due to paths specified */
745 tagged
= tag
->tagged
;
746 tagged_mark
= get_object_mark(tagged
);
748 switch(tag_of_filtered_mode
) {
750 die ("Tag %s tags unexported object; use "
751 "--tag-of-filtered-object=<mode> to handle it.",
752 oid_to_hex(&tag
->object
.oid
));
754 /* Ignore this tag altogether */
758 if (tagged
->type
!= OBJ_COMMIT
) {
759 die ("Tag %s tags unexported %s!",
760 oid_to_hex(&tag
->object
.oid
),
761 type_name(tagged
->type
));
763 p
= (struct commit
*)tagged
;
765 if (p
->parents
&& p
->parents
->next
)
767 if (p
->object
.flags
& UNINTERESTING
)
769 if (!(p
->object
.flags
& TREESAME
))
772 die ("Can't find replacement commit for tag %s\n",
773 oid_to_hex(&tag
->object
.oid
));
774 p
= p
->parents
->item
;
776 tagged_mark
= get_object_mark(&p
->object
);
780 if (starts_with(name
, "refs/tags/"))
782 printf("tag %s\nfrom :%d\n%.*s%sdata %d\n%.*s\n",
784 (int)(tagger_end
- tagger
), tagger
,
785 tagger
== tagger_end
? "" : "\n",
786 (int)message_size
, (int)message_size
, message
? message
: "");
790 static struct commit
*get_commit(struct rev_cmdline_entry
*e
, char *full_name
)
792 switch (e
->item
->type
) {
794 return (struct commit
*)e
->item
;
796 struct tag
*tag
= (struct tag
*)e
->item
;
798 /* handle nested tags */
799 while (tag
&& tag
->object
.type
== OBJ_TAG
) {
800 parse_object(&tag
->object
.oid
);
801 string_list_append(&extra_refs
, full_name
)->util
= tag
;
802 tag
= (struct tag
*)tag
->tagged
;
805 die("Tag %s points nowhere?", e
->name
);
806 return (struct commit
*)tag
;
814 static void get_tags_and_duplicates(struct rev_cmdline_info
*info
)
818 for (i
= 0; i
< info
->nr
; i
++) {
819 struct rev_cmdline_entry
*e
= info
->rev
+ i
;
820 struct object_id oid
;
821 struct commit
*commit
;
824 if (e
->flags
& UNINTERESTING
)
827 if (dwim_ref(e
->name
, strlen(e
->name
), &oid
, &full_name
) != 1)
832 private = apply_refspecs(refspecs
, refspecs_nr
, full_name
);
839 commit
= get_commit(e
, full_name
);
841 warning("%s: Unexpected object of type %s, skipping.",
843 type_name(e
->item
->type
));
847 switch(commit
->object
.type
) {
851 export_blob(&commit
->object
.oid
);
853 default: /* OBJ_TAG (nested tags) is already handled */
854 warning("Tag points to object of unexpected type %s, skipping.",
855 type_name(commit
->object
.type
));
860 * This ref will not be updated through a commit, lets make
861 * sure it gets properly updated eventually.
863 if (commit
->util
|| commit
->object
.flags
& SHOWN
)
864 string_list_append(&extra_refs
, full_name
)->util
= commit
;
866 commit
->util
= full_name
;
870 static void handle_tags_and_duplicates(void)
872 struct commit
*commit
;
875 for (i
= extra_refs
.nr
- 1; i
>= 0; i
--) {
876 const char *name
= extra_refs
.items
[i
].string
;
877 struct object
*object
= extra_refs
.items
[i
].util
;
878 switch (object
->type
) {
880 handle_tag(name
, (struct tag
*)object
);
884 name
= anonymize_refname(name
);
885 /* create refs pointing to already seen commits */
886 commit
= (struct commit
*)object
;
887 printf("reset %s\nfrom :%d\n\n", name
,
888 get_object_mark(&commit
->object
));
895 static void export_marks(char *file
)
899 struct decoration_entry
*deco
= idnums
.entries
;
903 f
= fopen_for_writing(file
);
905 die_errno("Unable to open marks file %s for writing.", file
);
907 for (i
= 0; i
< idnums
.size
; i
++) {
908 if (deco
->base
&& deco
->base
->type
== 1) {
909 mark
= ptr_to_mark(deco
->decoration
);
910 if (fprintf(f
, ":%"PRIu32
" %s\n", mark
,
911 oid_to_hex(&deco
->base
->oid
)) < 0) {
922 error("Unable to write marks file %s.", file
);
925 static void import_marks(char *input_file
)
928 FILE *f
= xfopen(input_file
, "r");
930 while (fgets(line
, sizeof(line
), f
)) {
932 char *line_end
, *mark_end
;
933 struct object_id oid
;
934 struct object
*object
;
935 struct commit
*commit
;
936 enum object_type type
;
938 line_end
= strchr(line
, '\n');
939 if (line
[0] != ':' || !line_end
)
940 die("corrupt mark line: %s", line
);
943 mark
= strtoumax(line
+ 1, &mark_end
, 10);
944 if (!mark
|| mark_end
== line
+ 1
945 || *mark_end
!= ' ' || get_oid_hex(mark_end
+ 1, &oid
))
946 die("corrupt mark line: %s", line
);
948 if (last_idnum
< mark
)
951 type
= oid_object_info(the_repository
, &oid
, NULL
);
953 die("object not found: %s", oid_to_hex(&oid
));
955 if (type
!= OBJ_COMMIT
)
959 commit
= lookup_commit(&oid
);
961 die("not a commit? can't happen: %s", oid_to_hex(&oid
));
963 object
= &commit
->object
;
965 if (object
->flags
& SHOWN
)
966 error("Object %s already has a mark", oid_to_hex(&oid
));
968 mark_object(object
, mark
);
970 object
->flags
|= SHOWN
;
975 static void handle_deletes(void)
978 for (i
= 0; i
< refspecs_nr
; i
++) {
979 struct refspec
*refspec
= &refspecs
[i
];
983 printf("reset %s\nfrom %s\n\n",
984 refspec
->dst
, sha1_to_hex(null_sha1
));
988 int cmd_fast_export(int argc
, const char **argv
, const char *prefix
)
990 struct rev_info revs
;
991 struct object_array commits
= OBJECT_ARRAY_INIT
;
992 struct commit
*commit
;
993 char *export_filename
= NULL
, *import_filename
= NULL
;
994 uint32_t lastimportid
;
995 struct string_list refspecs_list
= STRING_LIST_INIT_NODUP
;
996 struct string_list paths_of_changed_objects
= STRING_LIST_INIT_DUP
;
997 struct option options
[] = {
998 OPT_INTEGER(0, "progress", &progress
,
999 N_("show progress after <n> objects")),
1000 OPT_CALLBACK(0, "signed-tags", &signed_tag_mode
, N_("mode"),
1001 N_("select handling of signed tags"),
1002 parse_opt_signed_tag_mode
),
1003 OPT_CALLBACK(0, "tag-of-filtered-object", &tag_of_filtered_mode
, N_("mode"),
1004 N_("select handling of tags that tag filtered objects"),
1005 parse_opt_tag_of_filtered_mode
),
1006 OPT_STRING(0, "export-marks", &export_filename
, N_("file"),
1007 N_("Dump marks to this file")),
1008 OPT_STRING(0, "import-marks", &import_filename
, N_("file"),
1009 N_("Import marks from this file")),
1010 OPT_BOOL(0, "fake-missing-tagger", &fake_missing_tagger
,
1011 N_("Fake a tagger when tags lack one")),
1012 OPT_BOOL(0, "full-tree", &full_tree
,
1013 N_("Output full tree for each commit")),
1014 OPT_BOOL(0, "use-done-feature", &use_done_feature
,
1015 N_("Use the done feature to terminate the stream")),
1016 OPT_BOOL(0, "no-data", &no_data
, N_("Skip output of blob data")),
1017 OPT_STRING_LIST(0, "refspec", &refspecs_list
, N_("refspec"),
1018 N_("Apply refspec to exported refs")),
1019 OPT_BOOL(0, "anonymize", &anonymize
, N_("anonymize output")),
1024 usage_with_options (fast_export_usage
, options
);
1026 /* we handle encodings */
1027 git_config(git_default_config
, NULL
);
1029 init_revisions(&revs
, prefix
);
1030 revs
.topo_order
= 1;
1031 revs
.show_source
= 1;
1032 revs
.rewrite_parents
= 1;
1033 argc
= parse_options(argc
, argv
, prefix
, options
, fast_export_usage
,
1034 PARSE_OPT_KEEP_ARGV0
| PARSE_OPT_KEEP_UNKNOWN
);
1035 argc
= setup_revisions(argc
, argv
, &revs
, NULL
);
1037 usage_with_options (fast_export_usage
, options
);
1039 if (refspecs_list
.nr
) {
1040 const char **refspecs_str
;
1043 ALLOC_ARRAY(refspecs_str
, refspecs_list
.nr
);
1044 for (i
= 0; i
< refspecs_list
.nr
; i
++)
1045 refspecs_str
[i
] = refspecs_list
.items
[i
].string
;
1047 refspecs_nr
= refspecs_list
.nr
;
1048 refspecs
= parse_fetch_refspec(refspecs_nr
, refspecs_str
);
1050 string_list_clear(&refspecs_list
, 1);
1054 if (use_done_feature
)
1055 printf("feature done\n");
1057 if (import_filename
)
1058 import_marks(import_filename
);
1059 lastimportid
= last_idnum
;
1061 if (import_filename
&& revs
.prune_data
.nr
)
1064 get_tags_and_duplicates(&revs
.cmdline
);
1066 if (prepare_revision_walk(&revs
))
1067 die("revision walk setup failed");
1068 revs
.diffopt
.format_callback
= show_filemodify
;
1069 revs
.diffopt
.format_callback_data
= &paths_of_changed_objects
;
1070 revs
.diffopt
.flags
.recursive
= 1;
1071 while ((commit
= get_revision(&revs
))) {
1072 if (has_unshown_parent(commit
)) {
1073 add_object_array(&commit
->object
, NULL
, &commits
);
1076 handle_commit(commit
, &revs
, &paths_of_changed_objects
);
1077 handle_tail(&commits
, &revs
, &paths_of_changed_objects
);
1081 handle_tags_and_duplicates();
1084 if (export_filename
&& lastimportid
!= last_idnum
)
1085 export_marks(export_filename
);
1087 if (use_done_feature
)
1090 free_refspec(refspecs_nr
, refspecs
);