2 Format of STDIN stream:
14 new_blob ::= 'blob' lf
17 file_content ::= data;
19 new_commit ::= 'commit' sp ref_str lf
21 ('author' sp name '<' email '>' when lf)?
22 'committer' sp name '<' email '>' when lf
24 ('from' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf)?
25 ('merge' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf)*
30 file_change ::= file_clr
36 file_clr ::= 'deleteall' lf;
37 file_del ::= 'D' sp path_str lf;
38 file_rnm ::= 'R' sp path_str sp path_str lf;
39 file_cpy ::= 'C' sp path_str sp path_str lf;
40 file_obm ::= 'M' sp mode sp (hexsha1 | idnum) sp path_str lf;
41 file_inm ::= 'M' sp mode sp 'inline' sp path_str lf
44 new_tag ::= 'tag' sp tag_str lf
45 'from' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf
46 'tagger' sp name '<' email '>' when lf
50 reset_branch ::= 'reset' sp ref_str lf
51 ('from' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf)?
54 checkpoint ::= 'checkpoint' lf
57 progress ::= 'progress' sp not_lf* lf
60 # note: the first idnum in a stream should be 1 and subsequent
61 # idnums should not have gaps between values as this will cause
62 # the stream parser to reserve space for the gapped values. An
63 # idnum can be updated in the future to a new object by issuing
64 # a new mark directive with the old idnum.
66 mark ::= 'mark' sp idnum lf;
67 data ::= (delimited_data | exact_data)
70 # note: delim may be any string but must not contain lf.
71 # data_line may contain any data but must not be exactly
73 delimited_data ::= 'data' sp '<<' delim lf
77 # note: declen indicates the length of binary_data in bytes.
78 # declen does not include the lf preceeding the binary data.
80 exact_data ::= 'data' sp declen lf
83 # note: quoted strings are C-style quoting supporting \c for
84 # common escapes of 'c' (e..g \n, \t, \\, \") or \nnn where nnn
85 # is the signed byte value in octal. Note that the only
86 # characters which must actually be escaped to protect the
87 # stream formatting is: \, " and LF. Otherwise these values
91 sha1exp_str ::= sha1exp;
93 path_str ::= path | '"' quoted(path) '"' ;
94 mode ::= '100644' | '644'
99 declen ::= # unsigned 32 bit value, ascii base10 notation;
100 bigint ::= # unsigned integer value, ascii base10 notation;
101 binary_data ::= # file content, not interpreted;
103 when ::= raw_when | rfc2822_when;
104 raw_when ::= ts sp tz;
105 rfc2822_when ::= # Valid RFC 2822 date and time;
107 sp ::= # ASCII space character;
108 lf ::= # ASCII newline (LF) character;
110 # note: a colon (':') must precede the numerical value assigned to
111 # an idnum. This is to distinguish it from a ref or tag name as
112 # GIT does not permit ':' in ref or tag strings.
114 idnum ::= ':' bigint;
115 path ::= # GIT style file path, e.g. "a/b/c";
116 ref ::= # GIT ref name, e.g. "refs/heads/MOZ_GECKO_EXPERIMENT";
117 tag ::= # GIT tag name, e.g. "FIREFOX_1_5";
118 sha1exp ::= # Any valid GIT SHA1 expression;
119 hexsha1 ::= # SHA1 in hexadecimal format;
121 # note: name and email are UTF8 strings, however name must not
122 # contain '<' or lf and email must not contain any of the
123 # following: '<', '>', lf.
125 name ::= # valid GIT author/committer name;
126 email ::= # valid GIT author/committer email;
127 ts ::= # time since the epoch in seconds, ascii base10 notation;
128 tz ::= # GIT style timezone;
130 # note: comments may appear anywhere in the input, except
131 # within a data command. Any form of the data command
132 # always escapes the related input from comment processing.
134 # In case it is not clear, the '#' that starts the comment
135 # must be the first character on that the line (an lf have
138 comment ::= '#' not_lf* lf;
139 not_lf ::= # Any byte that is not ASCII newline (LF);
151 #include "csum-file.h"
155 #define PACK_ID_BITS 16
156 #define MAX_PACK_ID ((1<<PACK_ID_BITS)-1)
160 struct object_entry *next;
162 unsigned type : TYPE_BITS;
163 unsigned pack_id : PACK_ID_BITS;
164 unsigned char sha1[20];
167 struct object_entry_pool
169 struct object_entry_pool *next_pool;
170 struct object_entry *next_free;
171 struct object_entry *end;
172 struct object_entry entries[FLEX_ARRAY]; /* more */
178 struct object_entry *marked[1024];
179 struct mark_set *sets[1024];
195 struct mem_pool *next_pool;
198 char space[FLEX_ARRAY]; /* more */
203 struct atom_str *next_atom;
204 unsigned short str_len;
205 char str_dat[FLEX_ARRAY]; /* more */
211 struct tree_content *tree;
212 struct atom_str* name;
216 unsigned char sha1[20];
222 unsigned int entry_capacity; /* must match avail_tree_content */
223 unsigned int entry_count;
224 unsigned int delta_depth;
225 struct tree_entry *entries[FLEX_ARRAY]; /* more */
228 struct avail_tree_content
230 unsigned int entry_capacity; /* must match tree_content */
231 struct avail_tree_content *next_avail;
236 struct branch *table_next_branch;
237 struct branch *active_next_branch;
239 struct tree_entry branch_tree;
240 uintmax_t last_commit;
242 unsigned pack_id : PACK_ID_BITS;
243 unsigned char sha1[20];
248 struct tag *next_tag;
250 unsigned int pack_id;
251 unsigned char sha1[20];
262 struct hash_list *next;
263 unsigned char sha1[20];
272 /* Configured limits on output */
273 static unsigned long max_depth = 10;
274 static off_t max_packsize = (1LL << 32) - 1;
275 static int force_update;
277 /* Stats and misc. counters */
278 static uintmax_t alloc_count;
279 static uintmax_t marks_set_count;
280 static uintmax_t object_count_by_type[1 << TYPE_BITS];
281 static uintmax_t duplicate_count_by_type[1 << TYPE_BITS];
282 static uintmax_t delta_count_by_type[1 << TYPE_BITS];
283 static unsigned long object_count;
284 static unsigned long branch_count;
285 static unsigned long branch_load_count;
287 static FILE *pack_edges;
290 static size_t mem_pool_alloc = 2*1024*1024 - sizeof(struct mem_pool);
291 static size_t total_allocd;
292 static struct mem_pool *mem_pool;
294 /* Atom management */
295 static unsigned int atom_table_sz = 4451;
296 static unsigned int atom_cnt;
297 static struct atom_str **atom_table;
299 /* The .pack file being generated */
300 static unsigned int pack_id;
301 static struct packed_git *pack_data;
302 static struct packed_git **all_packs;
303 static unsigned long pack_size;
305 /* Table of objects we've written. */
306 static unsigned int object_entry_alloc = 5000;
307 static struct object_entry_pool *blocks;
308 static struct object_entry *object_table[1 << 16];
309 static struct mark_set *marks;
310 static const char* mark_file;
313 static struct last_object last_blob;
315 /* Tree management */
316 static unsigned int tree_entry_alloc = 1000;
317 static void *avail_tree_entry;
318 static unsigned int avail_tree_table_sz = 100;
319 static struct avail_tree_content **avail_tree_table;
320 static struct dbuf old_tree;
321 static struct dbuf new_tree;
324 static unsigned long max_active_branches = 5;
325 static unsigned long cur_active_branches;
326 static unsigned long branch_table_sz = 1039;
327 static struct branch **branch_table;
328 static struct branch *active_branches;
331 static struct tag *first_tag;
332 static struct tag *last_tag;
334 /* Input stream parsing */
335 static whenspec_type whenspec = WHENSPEC_RAW;
336 static struct strbuf command_buf;
337 static int unread_command_buf;
338 static uintmax_t next_mark;
339 static struct dbuf new_data;
342 static void alloc_objects(unsigned int cnt)
344 struct object_entry_pool *b;
346 b = xmalloc(sizeof(struct object_entry_pool)
347 + cnt * sizeof(struct object_entry));
348 b->next_pool = blocks;
349 b->next_free = b->entries;
350 b->end = b->entries + cnt;
355 static struct object_entry *new_object(unsigned char *sha1)
357 struct object_entry *e;
359 if (blocks->next_free == blocks->end)
360 alloc_objects(object_entry_alloc);
362 e = blocks->next_free++;
363 hashcpy(e->sha1, sha1);
367 static struct object_entry *find_object(unsigned char *sha1)
369 unsigned int h = sha1[0] << 8 | sha1[1];
370 struct object_entry *e;
371 for (e = object_table[h]; e; e = e->next)
372 if (!hashcmp(sha1, e->sha1))
377 static struct object_entry *insert_object(unsigned char *sha1)
379 unsigned int h = sha1[0] << 8 | sha1[1];
380 struct object_entry *e = object_table[h];
381 struct object_entry *p = NULL;
384 if (!hashcmp(sha1, e->sha1))
390 e = new_object(sha1);
400 static unsigned int hc_str(const char *s, size_t len)
408 static void *pool_alloc(size_t len)
413 for (p = mem_pool; p; p = p->next_pool)
414 if ((p->end - p->next_free >= len))
418 if (len >= (mem_pool_alloc/2)) {
422 total_allocd += sizeof(struct mem_pool) + mem_pool_alloc;
423 p = xmalloc(sizeof(struct mem_pool) + mem_pool_alloc);
424 p->next_pool = mem_pool;
425 p->next_free = p->space;
426 p->end = p->next_free + mem_pool_alloc;
431 /* round out to a pointer alignment */
432 if (len & (sizeof(void*) - 1))
433 len += sizeof(void*) - (len & (sizeof(void*) - 1));
438 static void *pool_calloc(size_t count, size_t size)
440 size_t len = count * size;
441 void *r = pool_alloc(len);
446 static char *pool_strdup(const char *s)
448 char *r = pool_alloc(strlen(s) + 1);
453 static void size_dbuf(struct dbuf *b, size_t maxlen)
456 if (b->capacity >= maxlen)
460 b->capacity = ((maxlen / 1024) + 1) * 1024;
461 b->buffer = xmalloc(b->capacity);
464 static void insert_mark(uintmax_t idnum, struct object_entry *oe)
466 struct mark_set *s = marks;
467 while ((idnum >> s->shift) >= 1024) {
468 s = pool_calloc(1, sizeof(struct mark_set));
469 s->shift = marks->shift + 10;
470 s->data.sets[0] = marks;
474 uintmax_t i = idnum >> s->shift;
475 idnum -= i << s->shift;
476 if (!s->data.sets[i]) {
477 s->data.sets[i] = pool_calloc(1, sizeof(struct mark_set));
478 s->data.sets[i]->shift = s->shift - 10;
482 if (!s->data.marked[idnum])
484 s->data.marked[idnum] = oe;
487 static struct object_entry *find_mark(uintmax_t idnum)
489 uintmax_t orig_idnum = idnum;
490 struct mark_set *s = marks;
491 struct object_entry *oe = NULL;
492 if ((idnum >> s->shift) < 1024) {
493 while (s && s->shift) {
494 uintmax_t i = idnum >> s->shift;
495 idnum -= i << s->shift;
499 oe = s->data.marked[idnum];
502 die("mark :%" PRIuMAX " not declared", orig_idnum);
506 static struct atom_str *to_atom(const char *s, unsigned short len)
508 unsigned int hc = hc_str(s, len) % atom_table_sz;
511 for (c = atom_table[hc]; c; c = c->next_atom)
512 if (c->str_len == len && !strncmp(s, c->str_dat, len))
515 c = pool_alloc(sizeof(struct atom_str) + len + 1);
517 strncpy(c->str_dat, s, len);
519 c->next_atom = atom_table[hc];
525 static struct branch *lookup_branch(const char *name)
527 unsigned int hc = hc_str(name, strlen(name)) % branch_table_sz;
530 for (b = branch_table[hc]; b; b = b->table_next_branch)
531 if (!strcmp(name, b->name))
536 static struct branch *new_branch(const char *name)
538 unsigned int hc = hc_str(name, strlen(name)) % branch_table_sz;
539 struct branch* b = lookup_branch(name);
542 die("Invalid attempt to create duplicate branch: %s", name);
543 switch (check_ref_format(name)) {
544 case 0: break; /* its valid */
545 case -2: break; /* valid, but too few '/', allow anyway */
547 die("Branch name doesn't conform to GIT standards: %s", name);
550 b = pool_calloc(1, sizeof(struct branch));
551 b->name = pool_strdup(name);
552 b->table_next_branch = branch_table[hc];
553 b->branch_tree.versions[0].mode = S_IFDIR;
554 b->branch_tree.versions[1].mode = S_IFDIR;
556 b->pack_id = MAX_PACK_ID;
557 branch_table[hc] = b;
562 static unsigned int hc_entries(unsigned int cnt)
564 cnt = cnt & 7 ? (cnt / 8) + 1 : cnt / 8;
565 return cnt < avail_tree_table_sz ? cnt : avail_tree_table_sz - 1;
568 static struct tree_content *new_tree_content(unsigned int cnt)
570 struct avail_tree_content *f, *l = NULL;
571 struct tree_content *t;
572 unsigned int hc = hc_entries(cnt);
574 for (f = avail_tree_table[hc]; f; l = f, f = f->next_avail)
575 if (f->entry_capacity >= cnt)
580 l->next_avail = f->next_avail;
582 avail_tree_table[hc] = f->next_avail;
584 cnt = cnt & 7 ? ((cnt / 8) + 1) * 8 : cnt;
585 f = pool_alloc(sizeof(*t) + sizeof(t->entries[0]) * cnt);
586 f->entry_capacity = cnt;
589 t = (struct tree_content*)f;
595 static void release_tree_entry(struct tree_entry *e);
596 static void release_tree_content(struct tree_content *t)
598 struct avail_tree_content *f = (struct avail_tree_content*)t;
599 unsigned int hc = hc_entries(f->entry_capacity);
600 f->next_avail = avail_tree_table[hc];
601 avail_tree_table[hc] = f;
604 static void release_tree_content_recursive(struct tree_content *t)
607 for (i = 0; i < t->entry_count; i++)
608 release_tree_entry(t->entries[i]);
609 release_tree_content(t);
612 static struct tree_content *grow_tree_content(
613 struct tree_content *t,
616 struct tree_content *r = new_tree_content(t->entry_count + amt);
617 r->entry_count = t->entry_count;
618 r->delta_depth = t->delta_depth;
619 memcpy(r->entries,t->entries,t->entry_count*sizeof(t->entries[0]));
620 release_tree_content(t);
624 static struct tree_entry *new_tree_entry(void)
626 struct tree_entry *e;
628 if (!avail_tree_entry) {
629 unsigned int n = tree_entry_alloc;
630 total_allocd += n * sizeof(struct tree_entry);
631 avail_tree_entry = e = xmalloc(n * sizeof(struct tree_entry));
633 *((void**)e) = e + 1;
639 e = avail_tree_entry;
640 avail_tree_entry = *((void**)e);
644 static void release_tree_entry(struct tree_entry *e)
647 release_tree_content_recursive(e->tree);
648 *((void**)e) = avail_tree_entry;
649 avail_tree_entry = e;
652 static struct tree_content *dup_tree_content(struct tree_content *s)
654 struct tree_content *d;
655 struct tree_entry *a, *b;
660 d = new_tree_content(s->entry_count);
661 for (i = 0; i < s->entry_count; i++) {
663 b = new_tree_entry();
664 memcpy(b, a, sizeof(*a));
665 if (a->tree && is_null_sha1(b->versions[1].sha1))
666 b->tree = dup_tree_content(a->tree);
671 d->entry_count = s->entry_count;
672 d->delta_depth = s->delta_depth;
677 static void start_packfile(void)
679 static char tmpfile[PATH_MAX];
680 struct packed_git *p;
681 struct pack_header hdr;
684 snprintf(tmpfile, sizeof(tmpfile),
685 "%s/tmp_pack_XXXXXX", get_object_directory());
686 pack_fd = xmkstemp(tmpfile);
687 p = xcalloc(1, sizeof(*p) + strlen(tmpfile) + 2);
688 strcpy(p->pack_name, tmpfile);
689 p->pack_fd = pack_fd;
691 hdr.hdr_signature = htonl(PACK_SIGNATURE);
692 hdr.hdr_version = htonl(2);
694 write_or_die(p->pack_fd, &hdr, sizeof(hdr));
697 pack_size = sizeof(hdr);
700 all_packs = xrealloc(all_packs, sizeof(*all_packs) * (pack_id + 1));
701 all_packs[pack_id] = p;
704 static int oecmp (const void *a_, const void *b_)
706 struct object_entry *a = *((struct object_entry**)a_);
707 struct object_entry *b = *((struct object_entry**)b_);
708 return hashcmp(a->sha1, b->sha1);
711 static char *create_index(void)
713 static char tmpfile[PATH_MAX];
716 struct object_entry **idx, **c, **last, *e;
717 struct object_entry_pool *o;
721 /* Build the sorted table of object IDs. */
722 idx = xmalloc(object_count * sizeof(struct object_entry*));
724 for (o = blocks; o; o = o->next_pool)
725 for (e = o->next_free; e-- != o->entries;)
726 if (pack_id == e->pack_id)
728 last = idx + object_count;
730 die("internal consistency error creating the index");
731 qsort(idx, object_count, sizeof(struct object_entry*), oecmp);
733 /* Generate the fan-out array. */
735 for (i = 0; i < 256; i++) {
736 struct object_entry **next = c;;
737 while (next < last) {
738 if ((*next)->sha1[0] != i)
742 array[i] = htonl(next - idx);
746 snprintf(tmpfile, sizeof(tmpfile),
747 "%s/tmp_idx_XXXXXX", get_object_directory());
748 idx_fd = xmkstemp(tmpfile);
749 f = sha1fd(idx_fd, tmpfile);
750 sha1write(f, array, 256 * sizeof(int));
752 for (c = idx; c != last; c++) {
753 uint32_t offset = htonl((*c)->offset);
754 sha1write(f, &offset, 4);
755 sha1write(f, (*c)->sha1, sizeof((*c)->sha1));
756 SHA1_Update(&ctx, (*c)->sha1, 20);
758 sha1write(f, pack_data->sha1, sizeof(pack_data->sha1));
759 sha1close(f, NULL, 1);
761 SHA1_Final(pack_data->sha1, &ctx);
765 static char *keep_pack(char *curr_index_name)
767 static char name[PATH_MAX];
768 static const char *keep_msg = "fast-import";
771 chmod(pack_data->pack_name, 0444);
772 chmod(curr_index_name, 0444);
774 snprintf(name, sizeof(name), "%s/pack/pack-%s.keep",
775 get_object_directory(), sha1_to_hex(pack_data->sha1));
776 keep_fd = open(name, O_RDWR|O_CREAT|O_EXCL, 0600);
778 die("cannot create keep file");
779 write(keep_fd, keep_msg, strlen(keep_msg));
782 snprintf(name, sizeof(name), "%s/pack/pack-%s.pack",
783 get_object_directory(), sha1_to_hex(pack_data->sha1));
784 if (move_temp_to_file(pack_data->pack_name, name))
785 die("cannot store pack file");
787 snprintf(name, sizeof(name), "%s/pack/pack-%s.idx",
788 get_object_directory(), sha1_to_hex(pack_data->sha1));
789 if (move_temp_to_file(curr_index_name, name))
790 die("cannot store index file");
794 static void unkeep_all_packs(void)
796 static char name[PATH_MAX];
799 for (k = 0; k < pack_id; k++) {
800 struct packed_git *p = all_packs[k];
801 snprintf(name, sizeof(name), "%s/pack/pack-%s.keep",
802 get_object_directory(), sha1_to_hex(p->sha1));
807 static void end_packfile(void)
809 struct packed_git *old_p = pack_data, *new_p;
817 fixup_pack_header_footer(pack_data->pack_fd, pack_data->sha1,
818 pack_data->pack_name, object_count);
819 close(pack_data->pack_fd);
820 idx_name = keep_pack(create_index());
822 /* Register the packfile with core git's machinary. */
823 new_p = add_packed_git(idx_name, strlen(idx_name), 1);
825 die("core git rejected index %s", idx_name);
826 new_p->windows = old_p->windows;
827 all_packs[pack_id] = new_p;
828 install_packed_git(new_p);
830 /* Print the boundary */
832 fprintf(pack_edges, "%s:", new_p->pack_name);
833 for (i = 0; i < branch_table_sz; i++) {
834 for (b = branch_table[i]; b; b = b->table_next_branch) {
835 if (b->pack_id == pack_id)
836 fprintf(pack_edges, " %s", sha1_to_hex(b->sha1));
839 for (t = first_tag; t; t = t->next_tag) {
840 if (t->pack_id == pack_id)
841 fprintf(pack_edges, " %s", sha1_to_hex(t->sha1));
843 fputc('\n', pack_edges);
850 unlink(old_p->pack_name);
853 /* We can't carry a delta across packfiles. */
854 free(last_blob.data);
855 last_blob.data = NULL;
857 last_blob.offset = 0;
861 static void cycle_packfile(void)
867 static size_t encode_header(
868 enum object_type type,
875 if (type < OBJ_COMMIT || type > OBJ_REF_DELTA)
876 die("bad type %d", type);
878 c = (type << 4) | (size & 15);
890 static int store_object(
891 enum object_type type,
894 struct last_object *last,
895 unsigned char *sha1out,
899 struct object_entry *e;
900 unsigned char hdr[96];
901 unsigned char sha1[20];
902 unsigned long hdrlen, deltalen;
906 hdrlen = sprintf((char*)hdr,"%s %lu", typename(type),
907 (unsigned long)datlen) + 1;
909 SHA1_Update(&c, hdr, hdrlen);
910 SHA1_Update(&c, dat, datlen);
911 SHA1_Final(sha1, &c);
913 hashcpy(sha1out, sha1);
915 e = insert_object(sha1);
917 insert_mark(mark, e);
919 duplicate_count_by_type[type]++;
921 } else if (find_sha1_pack(sha1, packed_git)) {
923 e->pack_id = MAX_PACK_ID;
924 e->offset = 1; /* just not zero! */
925 duplicate_count_by_type[type]++;
929 if (last && last->data && last->depth < max_depth) {
930 delta = diff_delta(last->data, last->len,
933 if (delta && deltalen >= datlen) {
940 memset(&s, 0, sizeof(s));
941 deflateInit(&s, zlib_compression_level);
944 s.avail_in = deltalen;
949 s.avail_out = deflateBound(&s, s.avail_in);
950 s.next_out = out = xmalloc(s.avail_out);
951 while (deflate(&s, Z_FINISH) == Z_OK)
955 /* Determine if we should auto-checkpoint. */
956 if ((pack_size + 60 + s.total_out) > max_packsize
957 || (pack_size + 60 + s.total_out) < pack_size) {
959 /* This new object needs to *not* have the current pack_id. */
960 e->pack_id = pack_id + 1;
963 /* We cannot carry a delta into the new pack. */
968 memset(&s, 0, sizeof(s));
969 deflateInit(&s, zlib_compression_level);
972 s.avail_out = deflateBound(&s, s.avail_in);
973 s.next_out = out = xrealloc(out, s.avail_out);
974 while (deflate(&s, Z_FINISH) == Z_OK)
981 e->pack_id = pack_id;
982 e->offset = pack_size;
984 object_count_by_type[type]++;
987 unsigned long ofs = e->offset - last->offset;
988 unsigned pos = sizeof(hdr) - 1;
990 delta_count_by_type[type]++;
993 hdrlen = encode_header(OBJ_OFS_DELTA, deltalen, hdr);
994 write_or_die(pack_data->pack_fd, hdr, hdrlen);
997 hdr[pos] = ofs & 127;
999 hdr[--pos] = 128 | (--ofs & 127);
1000 write_or_die(pack_data->pack_fd, hdr + pos, sizeof(hdr) - pos);
1001 pack_size += sizeof(hdr) - pos;
1005 hdrlen = encode_header(type, datlen, hdr);
1006 write_or_die(pack_data->pack_fd, hdr, hdrlen);
1007 pack_size += hdrlen;
1010 write_or_die(pack_data->pack_fd, out, s.total_out);
1011 pack_size += s.total_out;
1019 last->offset = e->offset;
1025 static void *gfi_unpack_entry(
1026 struct object_entry *oe,
1027 unsigned long *sizep)
1029 enum object_type type;
1030 struct packed_git *p = all_packs[oe->pack_id];
1032 p->pack_size = pack_size + 20;
1033 return unpack_entry(p, oe->offset, &type, sizep);
1036 static const char *get_mode(const char *str, uint16_t *modep)
1041 while ((c = *str++) != ' ') {
1042 if (c < '0' || c > '7')
1044 mode = (mode << 3) + (c - '0');
1050 static void load_tree(struct tree_entry *root)
1052 unsigned char* sha1 = root->versions[1].sha1;
1053 struct object_entry *myoe;
1054 struct tree_content *t;
1059 root->tree = t = new_tree_content(8);
1060 if (is_null_sha1(sha1))
1063 myoe = find_object(sha1);
1064 if (myoe && myoe->pack_id != MAX_PACK_ID) {
1065 if (myoe->type != OBJ_TREE)
1066 die("Not a tree: %s", sha1_to_hex(sha1));
1068 buf = gfi_unpack_entry(myoe, &size);
1070 enum object_type type;
1071 buf = read_sha1_file(sha1, &type, &size);
1072 if (!buf || type != OBJ_TREE)
1073 die("Can't load tree %s", sha1_to_hex(sha1));
1077 while (c != (buf + size)) {
1078 struct tree_entry *e = new_tree_entry();
1080 if (t->entry_count == t->entry_capacity)
1081 root->tree = t = grow_tree_content(t, t->entry_count);
1082 t->entries[t->entry_count++] = e;
1085 c = get_mode(c, &e->versions[1].mode);
1087 die("Corrupt mode in %s", sha1_to_hex(sha1));
1088 e->versions[0].mode = e->versions[1].mode;
1089 e->name = to_atom(c, strlen(c));
1090 c += e->name->str_len + 1;
1091 hashcpy(e->versions[0].sha1, (unsigned char*)c);
1092 hashcpy(e->versions[1].sha1, (unsigned char*)c);
1098 static int tecmp0 (const void *_a, const void *_b)
1100 struct tree_entry *a = *((struct tree_entry**)_a);
1101 struct tree_entry *b = *((struct tree_entry**)_b);
1102 return base_name_compare(
1103 a->name->str_dat, a->name->str_len, a->versions[0].mode,
1104 b->name->str_dat, b->name->str_len, b->versions[0].mode);
1107 static int tecmp1 (const void *_a, const void *_b)
1109 struct tree_entry *a = *((struct tree_entry**)_a);
1110 struct tree_entry *b = *((struct tree_entry**)_b);
1111 return base_name_compare(
1112 a->name->str_dat, a->name->str_len, a->versions[1].mode,
1113 b->name->str_dat, b->name->str_len, b->versions[1].mode);
1116 static void mktree(struct tree_content *t,
1126 qsort(t->entries,t->entry_count,sizeof(t->entries[0]),tecmp0);
1128 qsort(t->entries,t->entry_count,sizeof(t->entries[0]),tecmp1);
1130 for (i = 0; i < t->entry_count; i++) {
1131 if (t->entries[i]->versions[v].mode)
1132 maxlen += t->entries[i]->name->str_len + 34;
1135 size_dbuf(b, maxlen);
1137 for (i = 0; i < t->entry_count; i++) {
1138 struct tree_entry *e = t->entries[i];
1139 if (!e->versions[v].mode)
1141 c += sprintf(c, "%o", (unsigned int)e->versions[v].mode);
1143 strcpy(c, e->name->str_dat);
1144 c += e->name->str_len + 1;
1145 hashcpy((unsigned char*)c, e->versions[v].sha1);
1148 *szp = c - (char*)b->buffer;
1151 static void store_tree(struct tree_entry *root)
1153 struct tree_content *t = root->tree;
1154 unsigned int i, j, del;
1155 unsigned long new_len;
1156 struct last_object lo;
1157 struct object_entry *le;
1159 if (!is_null_sha1(root->versions[1].sha1))
1162 for (i = 0; i < t->entry_count; i++) {
1163 if (t->entries[i]->tree)
1164 store_tree(t->entries[i]);
1167 le = find_object(root->versions[0].sha1);
1168 if (!S_ISDIR(root->versions[0].mode)
1170 || le->pack_id != pack_id) {
1175 mktree(t, 0, &lo.len, &old_tree);
1176 lo.data = old_tree.buffer;
1177 lo.offset = le->offset;
1178 lo.depth = t->delta_depth;
1182 mktree(t, 1, &new_len, &new_tree);
1183 store_object(OBJ_TREE, new_tree.buffer, new_len,
1184 &lo, root->versions[1].sha1, 0);
1186 t->delta_depth = lo.depth;
1187 for (i = 0, j = 0, del = 0; i < t->entry_count; i++) {
1188 struct tree_entry *e = t->entries[i];
1189 if (e->versions[1].mode) {
1190 e->versions[0].mode = e->versions[1].mode;
1191 hashcpy(e->versions[0].sha1, e->versions[1].sha1);
1192 t->entries[j++] = e;
1194 release_tree_entry(e);
1198 t->entry_count -= del;
1201 static int tree_content_set(
1202 struct tree_entry *root,
1204 const unsigned char *sha1,
1205 const uint16_t mode,
1206 struct tree_content *subtree)
1208 struct tree_content *t = root->tree;
1211 struct tree_entry *e;
1213 slash1 = strchr(p, '/');
1219 die("Empty path component found in input");
1220 if (!slash1 && !S_ISDIR(mode) && subtree)
1221 die("Non-directories cannot have subtrees");
1223 for (i = 0; i < t->entry_count; i++) {
1225 if (e->name->str_len == n && !strncmp(p, e->name->str_dat, n)) {
1228 && e->versions[1].mode == mode
1229 && !hashcmp(e->versions[1].sha1, sha1))
1231 e->versions[1].mode = mode;
1232 hashcpy(e->versions[1].sha1, sha1);
1234 release_tree_content_recursive(e->tree);
1236 hashclr(root->versions[1].sha1);
1239 if (!S_ISDIR(e->versions[1].mode)) {
1240 e->tree = new_tree_content(8);
1241 e->versions[1].mode = S_IFDIR;
1245 if (tree_content_set(e, slash1 + 1, sha1, mode, subtree)) {
1246 hashclr(root->versions[1].sha1);
1253 if (t->entry_count == t->entry_capacity)
1254 root->tree = t = grow_tree_content(t, t->entry_count);
1255 e = new_tree_entry();
1256 e->name = to_atom(p, n);
1257 e->versions[0].mode = 0;
1258 hashclr(e->versions[0].sha1);
1259 t->entries[t->entry_count++] = e;
1261 e->tree = new_tree_content(8);
1262 e->versions[1].mode = S_IFDIR;
1263 tree_content_set(e, slash1 + 1, sha1, mode, subtree);
1266 e->versions[1].mode = mode;
1267 hashcpy(e->versions[1].sha1, sha1);
1269 hashclr(root->versions[1].sha1);
1273 static int tree_content_remove(
1274 struct tree_entry *root,
1276 struct tree_entry *backup_leaf)
1278 struct tree_content *t = root->tree;
1281 struct tree_entry *e;
1283 slash1 = strchr(p, '/');
1289 for (i = 0; i < t->entry_count; i++) {
1291 if (e->name->str_len == n && !strncmp(p, e->name->str_dat, n)) {
1292 if (!slash1 || !S_ISDIR(e->versions[1].mode))
1296 if (tree_content_remove(e, slash1 + 1, backup_leaf)) {
1297 for (n = 0; n < e->tree->entry_count; n++) {
1298 if (e->tree->entries[n]->versions[1].mode) {
1299 hashclr(root->versions[1].sha1);
1313 memcpy(backup_leaf, e, sizeof(*backup_leaf));
1315 release_tree_content_recursive(e->tree);
1317 e->versions[1].mode = 0;
1318 hashclr(e->versions[1].sha1);
1319 hashclr(root->versions[1].sha1);
1323 static int tree_content_get(
1324 struct tree_entry *root,
1326 struct tree_entry *leaf)
1328 struct tree_content *t = root->tree;
1331 struct tree_entry *e;
1333 slash1 = strchr(p, '/');
1339 for (i = 0; i < t->entry_count; i++) {
1341 if (e->name->str_len == n && !strncmp(p, e->name->str_dat, n)) {
1343 memcpy(leaf, e, sizeof(*leaf));
1344 if (e->tree && is_null_sha1(e->versions[1].sha1))
1345 leaf->tree = dup_tree_content(e->tree);
1350 if (!S_ISDIR(e->versions[1].mode))
1354 return tree_content_get(e, slash1 + 1, leaf);
1360 static int update_branch(struct branch *b)
1362 static const char *msg = "fast-import";
1363 struct ref_lock *lock;
1364 unsigned char old_sha1[20];
1366 if (read_ref(b->name, old_sha1))
1368 lock = lock_any_ref_for_update(b->name, old_sha1, 0);
1370 return error("Unable to lock %s", b->name);
1371 if (!force_update && !is_null_sha1(old_sha1)) {
1372 struct commit *old_cmit, *new_cmit;
1374 old_cmit = lookup_commit_reference_gently(old_sha1, 0);
1375 new_cmit = lookup_commit_reference_gently(b->sha1, 0);
1376 if (!old_cmit || !new_cmit) {
1378 return error("Branch %s is missing commits.", b->name);
1381 if (!in_merge_bases(old_cmit, &new_cmit, 1)) {
1383 warning("Not updating %s"
1384 " (new tip %s does not contain %s)",
1385 b->name, sha1_to_hex(b->sha1), sha1_to_hex(old_sha1));
1389 if (write_ref_sha1(lock, b->sha1, msg) < 0)
1390 return error("Unable to update %s", b->name);
1394 static void dump_branches(void)
1399 for (i = 0; i < branch_table_sz; i++) {
1400 for (b = branch_table[i]; b; b = b->table_next_branch)
1401 failure |= update_branch(b);
1405 static void dump_tags(void)
1407 static const char *msg = "fast-import";
1409 struct ref_lock *lock;
1410 char ref_name[PATH_MAX];
1412 for (t = first_tag; t; t = t->next_tag) {
1413 sprintf(ref_name, "tags/%s", t->name);
1414 lock = lock_ref_sha1(ref_name, NULL);
1415 if (!lock || write_ref_sha1(lock, t->sha1, msg) < 0)
1416 failure |= error("Unable to update %s", ref_name);
1420 static void dump_marks_helper(FILE *f,
1426 for (k = 0; k < 1024; k++) {
1427 if (m->data.sets[k])
1428 dump_marks_helper(f, (base + k) << m->shift,
1432 for (k = 0; k < 1024; k++) {
1433 if (m->data.marked[k])
1434 fprintf(f, ":%" PRIuMAX " %s\n", base + k,
1435 sha1_to_hex(m->data.marked[k]->sha1));
1440 static void dump_marks(void)
1442 static struct lock_file mark_lock;
1449 mark_fd = hold_lock_file_for_update(&mark_lock, mark_file, 0);
1451 failure |= error("Unable to write marks file %s: %s",
1452 mark_file, strerror(errno));
1456 f = fdopen(mark_fd, "w");
1458 rollback_lock_file(&mark_lock);
1459 failure |= error("Unable to write marks file %s: %s",
1460 mark_file, strerror(errno));
1464 dump_marks_helper(f, 0, marks);
1466 if (commit_lock_file(&mark_lock))
1467 failure |= error("Unable to write marks file %s: %s",
1468 mark_file, strerror(errno));
1471 static void read_next_command(void)
1474 if (unread_command_buf)
1475 unread_command_buf = 0;
1477 read_line(&command_buf, stdin, '\n');
1478 } while (!command_buf.eof && command_buf.buf[0] == '#');
1481 static void skip_optional_lf()
1483 int term_char = fgetc(stdin);
1484 if (term_char != '\n' && term_char != EOF)
1485 ungetc(term_char, stdin);
1488 static void cmd_mark(void)
1490 if (!prefixcmp(command_buf.buf, "mark :")) {
1491 next_mark = strtoumax(command_buf.buf + 6, NULL, 10);
1492 read_next_command();
1498 static void *cmd_data (size_t *size)
1503 if (prefixcmp(command_buf.buf, "data "))
1504 die("Expected 'data n' command, found: %s", command_buf.buf);
1506 if (!prefixcmp(command_buf.buf + 5, "<<")) {
1507 char *term = xstrdup(command_buf.buf + 5 + 2);
1508 size_t sz = 8192, term_len = command_buf.len - 5 - 2;
1510 buffer = xmalloc(sz);
1512 read_line(&command_buf, stdin, '\n');
1513 if (command_buf.eof)
1514 die("EOF in data (terminator '%s' not found)", term);
1515 if (term_len == command_buf.len
1516 && !strcmp(term, command_buf.buf))
1518 ALLOC_GROW(buffer, length + command_buf.len, sz);
1519 memcpy(buffer + length,
1521 command_buf.len - 1);
1522 length += command_buf.len - 1;
1523 buffer[length++] = '\n';
1529 length = strtoul(command_buf.buf + 5, NULL, 10);
1530 buffer = xmalloc(length);
1531 while (n < length) {
1532 size_t s = fread(buffer + n, 1, length - n, stdin);
1533 if (!s && feof(stdin))
1534 die("EOF in data (%lu bytes remaining)",
1535 (unsigned long)(length - n));
1545 static int validate_raw_date(const char *src, char *result, int maxlen)
1547 const char *orig_src = src;
1550 strtoul(src, &endp, 10);
1551 if (endp == src || *endp != ' ')
1555 if (*src != '-' && *src != '+')
1559 strtoul(src + 1, &endp, 10);
1560 if (endp == src || *endp || (endp - orig_src) >= maxlen)
1563 strcpy(result, orig_src);
1567 static char *parse_ident(const char *buf)
1573 gt = strrchr(buf, '>');
1575 die("Missing > in ident string: %s", buf);
1578 die("Missing space after > in ident string: %s", buf);
1580 name_len = gt - buf;
1581 ident = xmalloc(name_len + 24);
1582 strncpy(ident, buf, name_len);
1586 if (validate_raw_date(gt, ident + name_len, 24) < 0)
1587 die("Invalid raw date \"%s\" in ident: %s", gt, buf);
1589 case WHENSPEC_RFC2822:
1590 if (parse_date(gt, ident + name_len, 24) < 0)
1591 die("Invalid rfc2822 date \"%s\" in ident: %s", gt, buf);
1594 if (strcmp("now", gt))
1595 die("Date in ident must be 'now': %s", buf);
1596 datestamp(ident + name_len, 24);
1603 static void cmd_new_blob(void)
1608 read_next_command();
1612 if (store_object(OBJ_BLOB, d, l, &last_blob, NULL, next_mark))
1616 static void unload_one_branch(void)
1618 while (cur_active_branches
1619 && cur_active_branches >= max_active_branches) {
1620 uintmax_t min_commit = ULONG_MAX;
1621 struct branch *e, *l = NULL, *p = NULL;
1623 for (e = active_branches; e; e = e->active_next_branch) {
1624 if (e->last_commit < min_commit) {
1626 min_commit = e->last_commit;
1632 e = p->active_next_branch;
1633 p->active_next_branch = e->active_next_branch;
1635 e = active_branches;
1636 active_branches = e->active_next_branch;
1639 e->active_next_branch = NULL;
1640 if (e->branch_tree.tree) {
1641 release_tree_content_recursive(e->branch_tree.tree);
1642 e->branch_tree.tree = NULL;
1644 cur_active_branches--;
1648 static void load_branch(struct branch *b)
1650 load_tree(&b->branch_tree);
1653 b->active_next_branch = active_branches;
1654 active_branches = b;
1655 cur_active_branches++;
1656 branch_load_count++;
1660 static void file_change_m(struct branch *b)
1662 const char *p = command_buf.buf + 2;
1665 struct object_entry *oe = oe;
1666 unsigned char sha1[20];
1667 uint16_t mode, inline_data = 0;
1669 p = get_mode(p, &mode);
1671 die("Corrupt mode: %s", command_buf.buf);
1673 case S_IFREG | 0644:
1674 case S_IFREG | 0755:
1681 die("Corrupt mode: %s", command_buf.buf);
1686 oe = find_mark(strtoumax(p + 1, &x, 10));
1687 hashcpy(sha1, oe->sha1);
1689 } else if (!prefixcmp(p, "inline")) {
1693 if (get_sha1_hex(p, sha1))
1694 die("Invalid SHA1: %s", command_buf.buf);
1695 oe = find_object(sha1);
1699 die("Missing space after SHA1: %s", command_buf.buf);
1701 p_uq = unquote_c_style(p, &endp);
1704 die("Garbage after path in: %s", command_buf.buf);
1712 p = p_uq = xstrdup(p);
1713 read_next_command();
1715 if (store_object(OBJ_BLOB, d, l, &last_blob, sha1, 0))
1718 if (oe->type != OBJ_BLOB)
1719 die("Not a blob (actually a %s): %s",
1720 command_buf.buf, typename(oe->type));
1722 enum object_type type = sha1_object_info(sha1, NULL);
1724 die("Blob not found: %s", command_buf.buf);
1725 if (type != OBJ_BLOB)
1726 die("Not a blob (actually a %s): %s",
1727 typename(type), command_buf.buf);
1730 tree_content_set(&b->branch_tree, p, sha1, S_IFREG | mode, NULL);
1734 static void file_change_d(struct branch *b)
1736 const char *p = command_buf.buf + 2;
1740 p_uq = unquote_c_style(p, &endp);
1743 die("Garbage after path in: %s", command_buf.buf);
1746 tree_content_remove(&b->branch_tree, p, NULL);
1750 static void file_change_cr(struct branch *b, int rename)
1755 struct tree_entry leaf;
1757 s = command_buf.buf + 2;
1758 s_uq = unquote_c_style(s, &endp);
1761 die("Missing space after source: %s", command_buf.buf);
1764 endp = strchr(s, ' ');
1766 die("Missing space after source: %s", command_buf.buf);
1767 s_uq = xmalloc(endp - s + 1);
1768 memcpy(s_uq, s, endp - s);
1775 die("Missing dest: %s", command_buf.buf);
1778 d_uq = unquote_c_style(d, &endp);
1781 die("Garbage after dest in: %s", command_buf.buf);
1785 memset(&leaf, 0, sizeof(leaf));
1787 tree_content_remove(&b->branch_tree, s, &leaf);
1789 tree_content_get(&b->branch_tree, s, &leaf);
1790 if (!leaf.versions[1].mode)
1791 die("Path %s not in branch", s);
1792 tree_content_set(&b->branch_tree, d,
1793 leaf.versions[1].sha1,
1794 leaf.versions[1].mode,
1801 static void file_change_deleteall(struct branch *b)
1803 release_tree_content_recursive(b->branch_tree.tree);
1804 hashclr(b->branch_tree.versions[0].sha1);
1805 hashclr(b->branch_tree.versions[1].sha1);
1806 load_tree(&b->branch_tree);
1809 static void cmd_from_commit(struct branch *b, char *buf, unsigned long size)
1811 if (!buf || size < 46)
1812 die("Not a valid commit: %s", sha1_to_hex(b->sha1));
1813 if (memcmp("tree ", buf, 5)
1814 || get_sha1_hex(buf + 5, b->branch_tree.versions[1].sha1))
1815 die("The commit %s is corrupt", sha1_to_hex(b->sha1));
1816 hashcpy(b->branch_tree.versions[0].sha1,
1817 b->branch_tree.versions[1].sha1);
1820 static void cmd_from_existing(struct branch *b)
1822 if (is_null_sha1(b->sha1)) {
1823 hashclr(b->branch_tree.versions[0].sha1);
1824 hashclr(b->branch_tree.versions[1].sha1);
1829 buf = read_object_with_reference(b->sha1,
1830 commit_type, &size, b->sha1);
1831 cmd_from_commit(b, buf, size);
1836 static int cmd_from(struct branch *b)
1841 if (prefixcmp(command_buf.buf, "from "))
1844 if (b->branch_tree.tree) {
1845 release_tree_content_recursive(b->branch_tree.tree);
1846 b->branch_tree.tree = NULL;
1849 from = strchr(command_buf.buf, ' ') + 1;
1850 s = lookup_branch(from);
1852 die("Can't create a branch from itself: %s", b->name);
1854 unsigned char *t = s->branch_tree.versions[1].sha1;
1855 hashcpy(b->sha1, s->sha1);
1856 hashcpy(b->branch_tree.versions[0].sha1, t);
1857 hashcpy(b->branch_tree.versions[1].sha1, t);
1858 } else if (*from == ':') {
1859 uintmax_t idnum = strtoumax(from + 1, NULL, 10);
1860 struct object_entry *oe = find_mark(idnum);
1861 if (oe->type != OBJ_COMMIT)
1862 die("Mark :%" PRIuMAX " not a commit", idnum);
1863 hashcpy(b->sha1, oe->sha1);
1864 if (oe->pack_id != MAX_PACK_ID) {
1866 char *buf = gfi_unpack_entry(oe, &size);
1867 cmd_from_commit(b, buf, size);
1870 cmd_from_existing(b);
1871 } else if (!get_sha1(from, b->sha1))
1872 cmd_from_existing(b);
1874 die("Invalid ref name or SHA1 expression: %s", from);
1876 read_next_command();
1880 static struct hash_list *cmd_merge(unsigned int *count)
1882 struct hash_list *list = NULL, *n, *e = e;
1887 while (!prefixcmp(command_buf.buf, "merge ")) {
1888 from = strchr(command_buf.buf, ' ') + 1;
1889 n = xmalloc(sizeof(*n));
1890 s = lookup_branch(from);
1892 hashcpy(n->sha1, s->sha1);
1893 else if (*from == ':') {
1894 uintmax_t idnum = strtoumax(from + 1, NULL, 10);
1895 struct object_entry *oe = find_mark(idnum);
1896 if (oe->type != OBJ_COMMIT)
1897 die("Mark :%" PRIuMAX " not a commit", idnum);
1898 hashcpy(n->sha1, oe->sha1);
1899 } else if (!get_sha1(from, n->sha1)) {
1901 char *buf = read_object_with_reference(n->sha1,
1902 commit_type, &size, n->sha1);
1903 if (!buf || size < 46)
1904 die("Not a valid commit: %s", from);
1907 die("Invalid ref name or SHA1 expression: %s", from);
1916 read_next_command();
1921 static void cmd_new_commit(void)
1927 char *author = NULL;
1928 char *committer = NULL;
1929 struct hash_list *merge_list = NULL;
1930 unsigned int merge_count;
1932 /* Obtain the branch name from the rest of our command */
1933 sp = strchr(command_buf.buf, ' ') + 1;
1934 b = lookup_branch(sp);
1938 read_next_command();
1940 if (!prefixcmp(command_buf.buf, "author ")) {
1941 author = parse_ident(command_buf.buf + 7);
1942 read_next_command();
1944 if (!prefixcmp(command_buf.buf, "committer ")) {
1945 committer = parse_ident(command_buf.buf + 10);
1946 read_next_command();
1949 die("Expected committer but didn't get one");
1950 msg = cmd_data(&msglen);
1951 read_next_command();
1953 merge_list = cmd_merge(&merge_count);
1955 /* ensure the branch is active/loaded */
1956 if (!b->branch_tree.tree || !max_active_branches) {
1957 unload_one_branch();
1962 while (!command_buf.eof && command_buf.len > 1) {
1963 if (!prefixcmp(command_buf.buf, "M "))
1965 else if (!prefixcmp(command_buf.buf, "D "))
1967 else if (!prefixcmp(command_buf.buf, "R "))
1968 file_change_cr(b, 1);
1969 else if (!prefixcmp(command_buf.buf, "C "))
1970 file_change_cr(b, 0);
1971 else if (!strcmp("deleteall", command_buf.buf))
1972 file_change_deleteall(b);
1974 unread_command_buf = 1;
1977 read_next_command();
1980 /* build the tree and the commit */
1981 store_tree(&b->branch_tree);
1982 hashcpy(b->branch_tree.versions[0].sha1,
1983 b->branch_tree.versions[1].sha1);
1984 size_dbuf(&new_data, 114 + msglen
1987 ? strlen(author) + strlen(committer)
1988 : 2 * strlen(committer)));
1989 sp = new_data.buffer;
1990 sp += sprintf(sp, "tree %s\n",
1991 sha1_to_hex(b->branch_tree.versions[1].sha1));
1992 if (!is_null_sha1(b->sha1))
1993 sp += sprintf(sp, "parent %s\n", sha1_to_hex(b->sha1));
1994 while (merge_list) {
1995 struct hash_list *next = merge_list->next;
1996 sp += sprintf(sp, "parent %s\n", sha1_to_hex(merge_list->sha1));
2000 sp += sprintf(sp, "author %s\n", author ? author : committer);
2001 sp += sprintf(sp, "committer %s\n", committer);
2003 memcpy(sp, msg, msglen);
2009 if (!store_object(OBJ_COMMIT,
2010 new_data.buffer, sp - (char*)new_data.buffer,
2011 NULL, b->sha1, next_mark))
2012 b->pack_id = pack_id;
2013 b->last_commit = object_count_by_type[OBJ_COMMIT];
2016 static void cmd_new_tag(void)
2025 uintmax_t from_mark = 0;
2026 unsigned char sha1[20];
2028 /* Obtain the new tag name from the rest of our command */
2029 sp = strchr(command_buf.buf, ' ') + 1;
2030 t = pool_alloc(sizeof(struct tag));
2032 t->name = pool_strdup(sp);
2034 last_tag->next_tag = t;
2038 read_next_command();
2041 if (prefixcmp(command_buf.buf, "from "))
2042 die("Expected from command, got %s", command_buf.buf);
2043 from = strchr(command_buf.buf, ' ') + 1;
2044 s = lookup_branch(from);
2046 hashcpy(sha1, s->sha1);
2047 } else if (*from == ':') {
2048 struct object_entry *oe;
2049 from_mark = strtoumax(from + 1, NULL, 10);
2050 oe = find_mark(from_mark);
2051 if (oe->type != OBJ_COMMIT)
2052 die("Mark :%" PRIuMAX " not a commit", from_mark);
2053 hashcpy(sha1, oe->sha1);
2054 } else if (!get_sha1(from, sha1)) {
2058 buf = read_object_with_reference(sha1,
2059 commit_type, &size, sha1);
2060 if (!buf || size < 46)
2061 die("Not a valid commit: %s", from);
2064 die("Invalid ref name or SHA1 expression: %s", from);
2065 read_next_command();
2068 if (prefixcmp(command_buf.buf, "tagger "))
2069 die("Expected tagger command, got %s", command_buf.buf);
2070 tagger = parse_ident(command_buf.buf + 7);
2072 /* tag payload/message */
2073 read_next_command();
2074 msg = cmd_data(&msglen);
2076 /* build the tag object */
2077 size_dbuf(&new_data, 67+strlen(t->name)+strlen(tagger)+msglen);
2078 sp = new_data.buffer;
2079 sp += sprintf(sp, "object %s\n", sha1_to_hex(sha1));
2080 sp += sprintf(sp, "type %s\n", commit_type);
2081 sp += sprintf(sp, "tag %s\n", t->name);
2082 sp += sprintf(sp, "tagger %s\n", tagger);
2084 memcpy(sp, msg, msglen);
2089 if (store_object(OBJ_TAG, new_data.buffer,
2090 sp - (char*)new_data.buffer,
2092 t->pack_id = MAX_PACK_ID;
2094 t->pack_id = pack_id;
2097 static void cmd_reset_branch(void)
2102 /* Obtain the branch name from the rest of our command */
2103 sp = strchr(command_buf.buf, ' ') + 1;
2104 b = lookup_branch(sp);
2107 hashclr(b->branch_tree.versions[0].sha1);
2108 hashclr(b->branch_tree.versions[1].sha1);
2109 if (b->branch_tree.tree) {
2110 release_tree_content_recursive(b->branch_tree.tree);
2111 b->branch_tree.tree = NULL;
2116 read_next_command();
2117 if (!cmd_from(b) && command_buf.len > 1)
2118 unread_command_buf = 1;
2121 static void cmd_checkpoint(void)
2132 static void cmd_progress(void)
2134 fwrite(command_buf.buf, 1, command_buf.len - 1, stdout);
2135 fputc('\n', stdout);
2140 static void import_marks(const char *input_file)
2143 FILE *f = fopen(input_file, "r");
2145 die("cannot read %s: %s", input_file, strerror(errno));
2146 while (fgets(line, sizeof(line), f)) {
2149 unsigned char sha1[20];
2150 struct object_entry *e;
2152 end = strchr(line, '\n');
2153 if (line[0] != ':' || !end)
2154 die("corrupt mark line: %s", line);
2156 mark = strtoumax(line + 1, &end, 10);
2157 if (!mark || end == line + 1
2158 || *end != ' ' || get_sha1(end + 1, sha1))
2159 die("corrupt mark line: %s", line);
2160 e = find_object(sha1);
2162 enum object_type type = sha1_object_info(sha1, NULL);
2164 die("object not found: %s", sha1_to_hex(sha1));
2165 e = insert_object(sha1);
2167 e->pack_id = MAX_PACK_ID;
2168 e->offset = 1; /* just not zero! */
2170 insert_mark(mark, e);
2175 static const char fast_import_usage[] =
2176 "git-fast-import [--date-format=f] [--max-pack-size=n] [--depth=n] [--active-branches=n] [--export-marks=marks.file]";
2178 int main(int argc, const char **argv)
2180 int i, show_stats = 1;
2182 git_config(git_default_config);
2183 alloc_objects(object_entry_alloc);
2184 strbuf_init(&command_buf);
2185 atom_table = xcalloc(atom_table_sz, sizeof(struct atom_str*));
2186 branch_table = xcalloc(branch_table_sz, sizeof(struct branch*));
2187 avail_tree_table = xcalloc(avail_tree_table_sz, sizeof(struct avail_tree_content*));
2188 marks = pool_calloc(1, sizeof(struct mark_set));
2190 for (i = 1; i < argc; i++) {
2191 const char *a = argv[i];
2193 if (*a != '-' || !strcmp(a, "--"))
2195 else if (!prefixcmp(a, "--date-format=")) {
2196 const char *fmt = a + 14;
2197 if (!strcmp(fmt, "raw"))
2198 whenspec = WHENSPEC_RAW;
2199 else if (!strcmp(fmt, "rfc2822"))
2200 whenspec = WHENSPEC_RFC2822;
2201 else if (!strcmp(fmt, "now"))
2202 whenspec = WHENSPEC_NOW;
2204 die("unknown --date-format argument %s", fmt);
2206 else if (!prefixcmp(a, "--max-pack-size="))
2207 max_packsize = strtoumax(a + 16, NULL, 0) * 1024 * 1024;
2208 else if (!prefixcmp(a, "--depth="))
2209 max_depth = strtoul(a + 8, NULL, 0);
2210 else if (!prefixcmp(a, "--active-branches="))
2211 max_active_branches = strtoul(a + 18, NULL, 0);
2212 else if (!prefixcmp(a, "--import-marks="))
2213 import_marks(a + 15);
2214 else if (!prefixcmp(a, "--export-marks="))
2216 else if (!prefixcmp(a, "--export-pack-edges=")) {
2219 pack_edges = fopen(a + 20, "a");
2221 die("Cannot open %s: %s", a + 20, strerror(errno));
2222 } else if (!strcmp(a, "--force"))
2224 else if (!strcmp(a, "--quiet"))
2226 else if (!strcmp(a, "--stats"))
2229 die("unknown option %s", a);
2232 usage(fast_import_usage);
2234 prepare_packed_git();
2237 read_next_command();
2238 if (command_buf.eof)
2240 else if (!strcmp("blob", command_buf.buf))
2242 else if (!prefixcmp(command_buf.buf, "commit "))
2244 else if (!prefixcmp(command_buf.buf, "tag "))
2246 else if (!prefixcmp(command_buf.buf, "reset "))
2248 else if (!strcmp("checkpoint", command_buf.buf))
2250 else if (!prefixcmp(command_buf.buf, "progress "))
2253 die("Unsupported command: %s", command_buf.buf);
2266 uintmax_t total_count = 0, duplicate_count = 0;
2267 for (i = 0; i < ARRAY_SIZE(object_count_by_type); i++)
2268 total_count += object_count_by_type[i];
2269 for (i = 0; i < ARRAY_SIZE(duplicate_count_by_type); i++)
2270 duplicate_count += duplicate_count_by_type[i];
2272 fprintf(stderr, "%s statistics:\n", argv[0]);
2273 fprintf(stderr, "---------------------------------------------------------------------\n");
2274 fprintf(stderr, "Alloc'd objects: %10" PRIuMAX "\n", alloc_count);
2275 fprintf(stderr, "Total objects: %10" PRIuMAX " (%10" PRIuMAX " duplicates )\n", total_count, duplicate_count);
2276 fprintf(stderr, " blobs : %10" PRIuMAX " (%10" PRIuMAX " duplicates %10" PRIuMAX " deltas)\n", object_count_by_type[OBJ_BLOB], duplicate_count_by_type[OBJ_BLOB], delta_count_by_type[OBJ_BLOB]);
2277 fprintf(stderr, " trees : %10" PRIuMAX " (%10" PRIuMAX " duplicates %10" PRIuMAX " deltas)\n", object_count_by_type[OBJ_TREE], duplicate_count_by_type[OBJ_TREE], delta_count_by_type[OBJ_TREE]);
2278 fprintf(stderr, " commits: %10" PRIuMAX " (%10" PRIuMAX " duplicates %10" PRIuMAX " deltas)\n", object_count_by_type[OBJ_COMMIT], duplicate_count_by_type[OBJ_COMMIT], delta_count_by_type[OBJ_COMMIT]);
2279 fprintf(stderr, " tags : %10" PRIuMAX " (%10" PRIuMAX " duplicates %10" PRIuMAX " deltas)\n", object_count_by_type[OBJ_TAG], duplicate_count_by_type[OBJ_TAG], delta_count_by_type[OBJ_TAG]);
2280 fprintf(stderr, "Total branches: %10lu (%10lu loads )\n", branch_count, branch_load_count);
2281 fprintf(stderr, " marks: %10" PRIuMAX " (%10" PRIuMAX " unique )\n", (((uintmax_t)1) << marks->shift) * 1024, marks_set_count);
2282 fprintf(stderr, " atoms: %10u\n", atom_cnt);
2283 fprintf(stderr, "Memory total: %10" PRIuMAX " KiB\n", (total_allocd + alloc_count*sizeof(struct object_entry))/1024);
2284 fprintf(stderr, " pools: %10lu KiB\n", (unsigned long)(total_allocd/1024));
2285 fprintf(stderr, " objects: %10" PRIuMAX " KiB\n", (alloc_count*sizeof(struct object_entry))/1024);
2286 fprintf(stderr, "---------------------------------------------------------------------\n");
2288 fprintf(stderr, "---------------------------------------------------------------------\n");
2289 fprintf(stderr, "\n");
2292 return failure ? 1 : 0;