| new_commit
| new_tag
| reset_branch
+ | checkpoint
;
new_blob ::= 'blob' lf
lf;
commit_msg ::= data;
- file_change ::= 'M' sp mode sp (hexsha1 | idnum) sp path_str lf
- | 'D' sp path_str lf
- ;
- mode ::= '644' | '755';
+ file_change ::= file_del | file_obm | file_inm;
+ file_del ::= 'D' sp path_str lf;
+ file_obm ::= 'M' sp mode sp (hexsha1 | idnum) sp path_str lf;
+ file_inm ::= 'M' sp mode sp 'inline' sp path_str lf
+ data;
new_tag ::= 'tag' sp tag_str lf
'from' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf
# a new mark directive with the old idnum.
#
mark ::= 'mark' sp idnum lf;
+ data ::= (delimited_data | exact_data)
+ lf;
+
+ # note: delim may be any string but must not contain lf.
+ # data_line may contain any data but must not be exactly
+ # delim.
+ delimited_data ::= 'data' sp '<<' delim lf
+ (data_line lf)*
+ delim lf;
# note: declen indicates the length of binary_data in bytes.
- # declen does not include the lf preceeding or trailing the
- # binary data.
+ # declen does not include the lf preceeding the binary data.
#
- data ::= 'data' sp declen lf
- binary_data
- lf;
+ exact_data ::= 'data' sp declen lf
+ binary_data;
# note: quoted strings are C-style quoting supporting \c for
# common escapes of 'c' (e..g \n, \t, \\, \") or \nnn where nnn
sha1exp_str ::= sha1exp | '"' quoted(sha1exp) '"' ;
tag_str ::= tag | '"' quoted(tag) '"' ;
path_str ::= path | '"' quoted(path) '"' ;
+ mode ::= '100644' | '644'
+ | '100755' | '755'
+ | '140000'
+ ;
declen ::= # unsigned 32 bit value, ascii base10 notation;
bigint ::= # unsigned integer value, ascii base10 notation;
struct object_entry
{
struct object_entry *next;
- unsigned long offset;
+ uint32_t offset;
unsigned type : TYPE_BITS;
unsigned pack_id : PACK_ID_BITS;
unsigned char sha1[20];
{
void *data;
unsigned long len;
- unsigned long offset;
+ uint32_t offset;
unsigned int depth;
unsigned no_free:1;
};
struct atom_str
{
struct atom_str *next_atom;
- unsigned int str_len;
+ unsigned short str_len;
char str_dat[FLEX_ARRAY]; /* more */
};
struct atom_str* name;
struct tree_entry_ms
{
- unsigned int mode;
+ uint16_t mode;
unsigned char sha1[20];
} versions[2];
};
/* Configured limits on output */
static unsigned long max_depth = 10;
static unsigned long max_packsize = (1LL << 32) - 1;
-static uintmax_t max_objects = -1;
/* Stats and misc. counters */
static uintmax_t alloc_count;
return oe;
}
-static struct atom_str* to_atom(const char *s, size_t len)
+static struct atom_str* to_atom(const char *s, unsigned short len)
{
unsigned int hc = hc_str(s, len) % atom_table_sz;
struct atom_str *c;
static void fixup_header_footer(void)
{
+ static const int buf_sz = 128 * 1024;
int pack_fd = pack_data->pack_fd;
SHA_CTX c;
- char hdr[8];
- unsigned long cnt;
+ struct pack_header hdr;
char *buf;
if (lseek(pack_fd, 0, SEEK_SET) != 0)
die("Failed seeking to start: %s", strerror(errno));
-
- SHA1_Init(&c);
- if (read_in_full(pack_fd, hdr, 8) != 8)
+ if (read_in_full(pack_fd, &hdr, sizeof(hdr)) != sizeof(hdr))
die("Unable to reread header of %s", pack_data->pack_name);
- SHA1_Update(&c, hdr, 8);
+ if (lseek(pack_fd, 0, SEEK_SET) != 0)
+ die("Failed seeking to start: %s", strerror(errno));
+ hdr.hdr_entries = htonl(object_count);
+ write_or_die(pack_fd, &hdr, sizeof(hdr));
- cnt = htonl(object_count);
- SHA1_Update(&c, &cnt, 4);
- write_or_die(pack_fd, &cnt, 4);
+ SHA1_Init(&c);
+ SHA1_Update(&c, &hdr, sizeof(hdr));
- buf = xmalloc(128 * 1024);
+ buf = xmalloc(buf_sz);
for (;;) {
- size_t n = xread(pack_fd, buf, 128 * 1024);
- if (n <= 0)
+ size_t n = xread(pack_fd, buf, buf_sz);
+ if (!n)
break;
+ if (n < 0)
+ die("Failed to checksum %s", pack_data->pack_name);
SHA1_Update(&c, buf, n);
}
free(buf);
struct sha1file *f;
struct object_entry **idx, **c, **last, *e;
struct object_entry_pool *o;
- unsigned int array[256];
+ uint32_t array[256];
int i, idx_fd;
/* Build the sorted table of object IDs. */
sha1write(f, array, 256 * sizeof(int));
SHA1_Init(&ctx);
for (c = idx; c != last; c++) {
- unsigned int offset = htonl((*c)->offset);
+ uint32_t offset = htonl((*c)->offset);
sha1write(f, &offset, 4);
sha1write(f, (*c)->sha1, sizeof((*c)->sha1));
SHA1_Update(&ctx, (*c)->sha1, 20);
deflateEnd(&s);
/* Determine if we should auto-checkpoint. */
- if ((object_count + 1) > max_objects
- || (object_count + 1) < object_count
- || (pack_size + 60 + s.total_out) > max_packsize
+ if ((pack_size + 60 + s.total_out) > max_packsize
|| (pack_size + 60 + s.total_out) < pack_size) {
/* This new object needs to *not* have the current pack_id. */
return unpack_entry(p, oe->offset, type, sizep);
}
-static const char *get_mode(const char *str, unsigned int *modep)
+static const char *get_mode(const char *str, uint16_t *modep)
{
unsigned char c;
- unsigned int mode = 0;
+ uint16_t mode = 0;
while ((c = *str++) != ' ') {
if (c < '0' || c > '7')
if (!c)
die("Corrupt mode in %s", sha1_to_hex(sha1));
e->versions[0].mode = e->versions[1].mode;
- e->name = to_atom(c, strlen(c));
+ e->name = to_atom(c, (unsigned short)strlen(c));
c += e->name->str_len + 1;
hashcpy(e->versions[0].sha1, (unsigned char*)c);
hashcpy(e->versions[1].sha1, (unsigned char*)c);
struct tree_entry *e = t->entries[i];
if (!e->versions[v].mode)
continue;
- c += sprintf(c, "%o", e->versions[v].mode);
+ c += sprintf(c, "%o", (unsigned int)e->versions[v].mode);
*c++ = ' ';
strcpy(c, e->name->str_dat);
c += e->name->str_len + 1;
struct tree_entry *root,
const char *p,
const unsigned char *sha1,
- const unsigned int mode)
+ const uint16_t mode)
{
struct tree_content *t = root->tree;
const char *slash1;
if (t->entry_count == t->entry_capacity)
root->tree = t = grow_tree_content(t, 8);
e = new_tree_entry();
- e->name = to_atom(p, n);
+ e->name = to_atom(p, (unsigned short)n);
e->versions[0].mode = 0;
hashclr(e->versions[0].sha1);
t->entries[t->entry_count++] = e;
static void* cmd_data (size_t *size)
{
- size_t n = 0;
- void *buffer;
size_t length;
+ char *buffer;
if (strncmp("data ", command_buf.buf, 5))
die("Expected 'data n' command, found: %s", command_buf.buf);
- length = strtoul(command_buf.buf + 5, NULL, 10);
- buffer = xmalloc(length);
-
- while (n < length) {
- size_t s = fread((char*)buffer + n, 1, length - n, stdin);
- if (!s && feof(stdin))
- die("EOF in data (%lu bytes remaining)", length - n);
- n += s;
+ if (!strncmp("<<", command_buf.buf + 5, 2)) {
+ char *term = xstrdup(command_buf.buf + 5 + 2);
+ size_t sz = 8192, term_len = command_buf.len - 5 - 2;
+ length = 0;
+ buffer = xmalloc(sz);
+ for (;;) {
+ read_next_command();
+ if (command_buf.eof)
+ die("EOF in data (terminator '%s' not found)", term);
+ if (term_len == command_buf.len
+ && !strcmp(term, command_buf.buf))
+ break;
+ if (sz < (length + command_buf.len)) {
+ sz = sz * 3 / 2 + 16;
+ if (sz < (length + command_buf.len))
+ sz = length + command_buf.len;
+ buffer = xrealloc(buffer, sz);
+ }
+ memcpy(buffer + length,
+ command_buf.buf,
+ command_buf.len - 1);
+ length += command_buf.len - 1;
+ buffer[length++] = '\n';
+ }
+ free(term);
+ }
+ else {
+ size_t n = 0;
+ length = strtoul(command_buf.buf + 5, NULL, 10);
+ buffer = xmalloc(length);
+ while (n < length) {
+ size_t s = fread(buffer + n, 1, length - n, stdin);
+ if (!s && feof(stdin))
+ die("EOF in data (%lu bytes remaining)", length - n);
+ n += s;
+ }
}
if (fgetc(stdin) != '\n')
const char *endp;
struct object_entry *oe;
unsigned char sha1[20];
- unsigned int mode;
+ uint16_t mode, inline_data = 0;
char type[20];
p = get_mode(p, &mode);
oe = find_mark(strtoumax(p + 1, &x, 10));
hashcpy(sha1, oe->sha1);
p = x;
+ } else if (!strncmp("inline", p, 6)) {
+ inline_data = 1;
+ p += 6;
} else {
if (get_sha1_hex(p, sha1))
die("Invalid SHA1: %s", command_buf.buf);
p = p_uq;
}
- if (oe) {
+ if (inline_data) {
+ size_t l;
+ void *d;
+ if (!p_uq)
+ p = p_uq = xstrdup(p);
+ read_next_command();
+ d = cmd_data(&l);
+ if (store_object(OBJ_BLOB, d, l, &last_blob, sha1, 0))
+ free(d);
+ } else if (oe) {
if (oe->type != OBJ_BLOB)
die("Not a blob (actually a %s): %s",
command_buf.buf, type_names[oe->type]);
}
static const char fast_import_usage[] =
-"git-fast-import [--objects=n] [--depth=n] [--active-branches=n] [--export-marks=marks.file] [--branch-log=log]";
+"git-fast-import [--depth=n] [--active-branches=n] [--export-marks=marks.file] [--branch-log=log]";
int main(int argc, const char **argv)
{
int i;
- uintmax_t est_obj_cnt = object_entry_alloc;
uintmax_t total_count, duplicate_count;
- setup_ident();
git_config(git_default_config);
for (i = 1; i < argc; i++) {
if (*a != '-' || !strcmp(a, "--"))
break;
- else if (!strncmp(a, "--objects=", 10))
- est_obj_cnt = strtoumax(a + 10, NULL, 0);
- else if (!strncmp(a, "--max-objects-per-pack=", 23))
- max_objects = strtoumax(a + 23, NULL, 0);
else if (!strncmp(a, "--max-pack-size=", 16))
max_packsize = strtoumax(a + 16, NULL, 0) * 1024 * 1024;
else if (!strncmp(a, "--depth=", 8))
if (i != argc)
usage(fast_import_usage);
- alloc_objects(est_obj_cnt);
+ alloc_objects(object_entry_alloc);
strbuf_init(&command_buf);
atom_table = xcalloc(atom_table_sz, sizeof(struct atom_str*));
fprintf(stderr, "%s statistics:\n", argv[0]);
fprintf(stderr, "---------------------------------------------------------------------\n");
- fprintf(stderr, "Alloc'd objects: %10ju (%10ju overflow )\n", alloc_count, alloc_count - est_obj_cnt);
+ fprintf(stderr, "Alloc'd objects: %10ju\n", alloc_count);
fprintf(stderr, "Total objects: %10ju (%10ju duplicates )\n", total_count, duplicate_count);
fprintf(stderr, " blobs : %10ju (%10ju duplicates %10ju deltas)\n", object_count_by_type[OBJ_BLOB], duplicate_count_by_type[OBJ_BLOB], delta_count_by_type[OBJ_BLOB]);
fprintf(stderr, " trees : %10ju (%10ju duplicates %10ju deltas)\n", object_count_by_type[OBJ_TREE], duplicate_count_by_type[OBJ_TREE], delta_count_by_type[OBJ_TREE]);
projects / thirdparty / git.git / blobdiff