2006-08-14 04:58:19 +00:00
|
|
|
/*
|
|
|
|
Format of STDIN stream:
|
|
|
|
|
|
|
|
stream ::= cmd*;
|
|
|
|
|
|
|
|
cmd ::= new_blob
|
2006-08-15 00:16:28 +00:00
|
|
|
| new_commit
|
2006-08-14 04:58:19 +00:00
|
|
|
| new_tag
|
2006-08-27 10:20:49 +00:00
|
|
|
| reset_branch
|
2007-02-05 21:05:11 +00:00
|
|
|
| checkpoint
|
2007-08-01 14:23:08 +00:00
|
|
|
| progress
|
2006-08-14 04:58:19 +00:00
|
|
|
;
|
|
|
|
|
2006-08-15 00:16:28 +00:00
|
|
|
new_blob ::= 'blob' lf
|
2007-07-15 08:57:40 +00:00
|
|
|
mark?
|
2006-08-15 00:16:28 +00:00
|
|
|
file_content;
|
|
|
|
file_content ::= data;
|
2006-08-14 04:58:19 +00:00
|
|
|
|
2006-08-15 00:16:28 +00:00
|
|
|
new_commit ::= 'commit' sp ref_str lf
|
2006-08-24 22:45:26 +00:00
|
|
|
mark?
|
2007-02-06 19:58:30 +00:00
|
|
|
('author' sp name '<' email '>' when lf)?
|
|
|
|
'committer' sp name '<' email '>' when lf
|
2006-08-24 22:45:26 +00:00
|
|
|
commit_msg
|
2006-08-25 02:38:13 +00:00
|
|
|
('from' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf)?
|
2007-01-12 03:21:38 +00:00
|
|
|
('merge' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf)*
|
2006-08-15 00:16:28 +00:00
|
|
|
file_change*
|
2007-08-01 06:22:53 +00:00
|
|
|
lf?;
|
2006-08-15 00:16:28 +00:00
|
|
|
commit_msg ::= data;
|
2006-08-14 04:58:19 +00:00
|
|
|
|
2007-07-15 05:40:37 +00:00
|
|
|
file_change ::= file_clr
|
|
|
|
| file_del
|
|
|
|
| file_rnm
|
|
|
|
| file_cpy
|
|
|
|
| file_obm
|
|
|
|
| file_inm;
|
2007-02-07 07:03:03 +00:00
|
|
|
file_clr ::= 'deleteall' lf;
|
2007-01-18 20:17:58 +00:00
|
|
|
file_del ::= 'D' sp path_str lf;
|
2007-07-10 02:58:23 +00:00
|
|
|
file_rnm ::= 'R' sp path_str sp path_str lf;
|
2007-07-15 05:40:37 +00:00
|
|
|
file_cpy ::= 'C' sp path_str sp path_str lf;
|
2007-01-18 20:17:58 +00:00
|
|
|
file_obm ::= 'M' sp mode sp (hexsha1 | idnum) sp path_str lf;
|
|
|
|
file_inm ::= 'M' sp mode sp 'inline' sp path_str lf
|
|
|
|
data;
|
2006-08-15 00:16:28 +00:00
|
|
|
|
|
|
|
new_tag ::= 'tag' sp tag_str lf
|
|
|
|
'from' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf
|
2007-07-15 08:57:40 +00:00
|
|
|
'tagger' sp name '<' email '>' when lf
|
2006-08-15 00:16:28 +00:00
|
|
|
tag_msg;
|
|
|
|
tag_msg ::= data;
|
|
|
|
|
2007-01-12 03:28:39 +00:00
|
|
|
reset_branch ::= 'reset' sp ref_str lf
|
|
|
|
('from' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf)?
|
2007-08-01 06:22:53 +00:00
|
|
|
lf?;
|
2006-08-27 10:20:49 +00:00
|
|
|
|
2007-01-15 11:35:41 +00:00
|
|
|
checkpoint ::= 'checkpoint' lf
|
2007-08-01 06:22:53 +00:00
|
|
|
lf?;
|
2007-01-15 11:35:41 +00:00
|
|
|
|
2007-08-01 14:23:08 +00:00
|
|
|
progress ::= 'progress' sp not_lf* lf
|
|
|
|
lf?;
|
|
|
|
|
2006-08-15 00:16:28 +00:00
|
|
|
# note: the first idnum in a stream should be 1 and subsequent
|
|
|
|
# idnums should not have gaps between values as this will cause
|
|
|
|
# the stream parser to reserve space for the gapped values. An
|
2007-07-15 08:57:40 +00:00
|
|
|
# idnum can be updated in the future to a new object by issuing
|
2006-08-15 00:16:28 +00:00
|
|
|
# a new mark directive with the old idnum.
|
2007-07-15 08:57:40 +00:00
|
|
|
#
|
2006-08-15 00:16:28 +00:00
|
|
|
mark ::= 'mark' sp idnum lf;
|
2007-01-18 18:14:27 +00:00
|
|
|
data ::= (delimited_data | exact_data)
|
2007-08-01 04:24:25 +00:00
|
|
|
lf?;
|
2007-01-18 18:14:27 +00:00
|
|
|
|
|
|
|
# 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)*
|
2007-07-15 08:57:40 +00:00
|
|
|
delim lf;
|
2006-08-15 00:16:28 +00:00
|
|
|
|
|
|
|
# note: declen indicates the length of binary_data in bytes.
|
2007-01-18 18:14:27 +00:00
|
|
|
# declen does not include the lf preceeding the binary data.
|
2006-08-15 00:16:28 +00:00
|
|
|
#
|
2007-01-18 18:14:27 +00:00
|
|
|
exact_data ::= 'data' sp declen lf
|
|
|
|
binary_data;
|
2006-08-15 00:16:28 +00:00
|
|
|
|
|
|
|
# note: quoted strings are C-style quoting supporting \c for
|
|
|
|
# common escapes of 'c' (e..g \n, \t, \\, \") or \nnn where nnn
|
2007-07-15 08:57:40 +00:00
|
|
|
# is the signed byte value in octal. Note that the only
|
2006-08-15 00:16:28 +00:00
|
|
|
# characters which must actually be escaped to protect the
|
|
|
|
# stream formatting is: \, " and LF. Otherwise these values
|
2007-07-15 08:57:40 +00:00
|
|
|
# are UTF8.
|
2006-08-15 00:16:28 +00:00
|
|
|
#
|
2007-02-06 01:30:37 +00:00
|
|
|
ref_str ::= ref;
|
|
|
|
sha1exp_str ::= sha1exp;
|
|
|
|
tag_str ::= tag;
|
2006-08-15 00:16:28 +00:00
|
|
|
path_str ::= path | '"' quoted(path) '"' ;
|
2007-01-18 20:17:58 +00:00
|
|
|
mode ::= '100644' | '644'
|
|
|
|
| '100755' | '755'
|
2007-02-06 20:46:11 +00:00
|
|
|
| '120000'
|
2007-01-18 20:17:58 +00:00
|
|
|
;
|
2006-08-15 00:16:28 +00:00
|
|
|
|
|
|
|
declen ::= # unsigned 32 bit value, ascii base10 notation;
|
2007-01-17 05:33:18 +00:00
|
|
|
bigint ::= # unsigned integer value, ascii base10 notation;
|
2006-08-14 04:58:19 +00:00
|
|
|
binary_data ::= # file content, not interpreted;
|
2006-08-15 00:16:28 +00:00
|
|
|
|
2007-02-06 19:58:30 +00:00
|
|
|
when ::= raw_when | rfc2822_when;
|
|
|
|
raw_when ::= ts sp tz;
|
|
|
|
rfc2822_when ::= # Valid RFC 2822 date and time;
|
|
|
|
|
2006-08-14 04:58:19 +00:00
|
|
|
sp ::= # ASCII space character;
|
|
|
|
lf ::= # ASCII newline (LF) character;
|
2006-08-15 00:16:28 +00:00
|
|
|
|
|
|
|
# note: a colon (':') must precede the numerical value assigned to
|
2007-07-15 08:57:40 +00:00
|
|
|
# an idnum. This is to distinguish it from a ref or tag name as
|
2006-08-15 00:16:28 +00:00
|
|
|
# GIT does not permit ':' in ref or tag strings.
|
2007-07-15 08:57:40 +00:00
|
|
|
#
|
2007-01-17 05:33:18 +00:00
|
|
|
idnum ::= ':' bigint;
|
2006-08-15 00:16:28 +00:00
|
|
|
path ::= # GIT style file path, e.g. "a/b/c";
|
|
|
|
ref ::= # GIT ref name, e.g. "refs/heads/MOZ_GECKO_EXPERIMENT";
|
|
|
|
tag ::= # GIT tag name, e.g. "FIREFOX_1_5";
|
2006-08-14 04:58:19 +00:00
|
|
|
sha1exp ::= # Any valid GIT SHA1 expression;
|
|
|
|
hexsha1 ::= # SHA1 in hexadecimal format;
|
2006-08-15 00:16:28 +00:00
|
|
|
|
|
|
|
# note: name and email are UTF8 strings, however name must not
|
2007-07-15 08:57:40 +00:00
|
|
|
# contain '<' or lf and email must not contain any of the
|
2006-08-15 00:16:28 +00:00
|
|
|
# following: '<', '>', lf.
|
2007-07-15 08:57:40 +00:00
|
|
|
#
|
2006-08-15 00:16:28 +00:00
|
|
|
name ::= # valid GIT author/committer name;
|
2006-08-14 04:58:19 +00:00
|
|
|
email ::= # valid GIT author/committer email;
|
2006-08-15 00:16:28 +00:00
|
|
|
ts ::= # time since the epoch in seconds, ascii base10 notation;
|
|
|
|
tz ::= # GIT style timezone;
|
2007-08-01 04:05:15 +00:00
|
|
|
|
|
|
|
# note: comments may appear anywhere in the input, except
|
|
|
|
# within a data command. Any form of the data command
|
|
|
|
# always escapes the related input from comment processing.
|
|
|
|
#
|
|
|
|
# In case it is not clear, the '#' that starts the comment
|
|
|
|
# must be the first character on that the line (an lf have
|
|
|
|
# preceeded it).
|
|
|
|
#
|
|
|
|
comment ::= '#' not_lf* lf;
|
|
|
|
not_lf ::= # Any byte that is not ASCII newline (LF);
|
2006-08-14 04:58:19 +00:00
|
|
|
*/
|
|
|
|
|
2006-08-05 06:04:21 +00:00
|
|
|
#include "builtin.h"
|
|
|
|
#include "cache.h"
|
|
|
|
#include "object.h"
|
|
|
|
#include "blob.h"
|
2006-08-14 04:58:19 +00:00
|
|
|
#include "tree.h"
|
2007-02-06 21:08:06 +00:00
|
|
|
#include "commit.h"
|
2006-08-05 06:04:21 +00:00
|
|
|
#include "delta.h"
|
|
|
|
#include "pack.h"
|
2006-08-14 04:58:19 +00:00
|
|
|
#include "refs.h"
|
2006-08-05 06:04:21 +00:00
|
|
|
#include "csum-file.h"
|
2006-08-15 00:16:28 +00:00
|
|
|
#include "quote.h"
|
2006-08-05 06:04:21 +00:00
|
|
|
|
2007-01-17 07:42:43 +00:00
|
|
|
#define PACK_ID_BITS 16
|
|
|
|
#define MAX_PACK_ID ((1<<PACK_ID_BITS)-1)
|
2007-11-14 04:48:42 +00:00
|
|
|
#define DEPTH_BITS 13
|
|
|
|
#define MAX_DEPTH ((1<<DEPTH_BITS)-1)
|
2007-01-17 07:42:43 +00:00
|
|
|
|
2006-08-08 04:03:59 +00:00
|
|
|
struct object_entry
|
|
|
|
{
|
|
|
|
struct object_entry *next;
|
2007-02-05 21:34:56 +00:00
|
|
|
uint32_t offset;
|
2007-11-14 04:48:42 +00:00
|
|
|
uint32_t type : TYPE_BITS,
|
|
|
|
pack_id : PACK_ID_BITS,
|
|
|
|
depth : DEPTH_BITS;
|
2006-08-08 04:03:59 +00:00
|
|
|
unsigned char sha1[20];
|
|
|
|
};
|
|
|
|
|
2006-08-14 04:58:19 +00:00
|
|
|
struct object_entry_pool
|
2006-08-08 04:03:59 +00:00
|
|
|
{
|
2006-08-14 04:58:19 +00:00
|
|
|
struct object_entry_pool *next_pool;
|
2006-08-08 04:03:59 +00:00
|
|
|
struct object_entry *next_free;
|
|
|
|
struct object_entry *end;
|
2006-08-08 04:46:13 +00:00
|
|
|
struct object_entry entries[FLEX_ARRAY]; /* more */
|
2006-08-08 04:03:59 +00:00
|
|
|
};
|
|
|
|
|
2006-08-23 08:17:45 +00:00
|
|
|
struct mark_set
|
|
|
|
{
|
|
|
|
union {
|
|
|
|
struct object_entry *marked[1024];
|
|
|
|
struct mark_set *sets[1024];
|
|
|
|
} data;
|
2007-01-17 05:57:23 +00:00
|
|
|
unsigned int shift;
|
2006-08-23 08:17:45 +00:00
|
|
|
};
|
|
|
|
|
2006-08-08 04:46:13 +00:00
|
|
|
struct last_object
|
|
|
|
{
|
2007-09-17 12:00:38 +00:00
|
|
|
struct strbuf data;
|
2007-02-05 21:34:56 +00:00
|
|
|
uint32_t offset;
|
2006-08-08 07:36:45 +00:00
|
|
|
unsigned int depth;
|
2007-09-17 12:00:38 +00:00
|
|
|
unsigned no_swap : 1;
|
2006-08-08 04:46:13 +00:00
|
|
|
};
|
|
|
|
|
2006-08-14 04:58:19 +00:00
|
|
|
struct mem_pool
|
|
|
|
{
|
|
|
|
struct mem_pool *next_pool;
|
|
|
|
char *next_free;
|
|
|
|
char *end;
|
|
|
|
char space[FLEX_ARRAY]; /* more */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct atom_str
|
|
|
|
{
|
|
|
|
struct atom_str *next_atom;
|
2007-02-05 21:34:56 +00:00
|
|
|
unsigned short str_len;
|
2006-08-14 04:58:19 +00:00
|
|
|
char str_dat[FLEX_ARRAY]; /* more */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct tree_content;
|
2006-08-08 07:36:45 +00:00
|
|
|
struct tree_entry
|
|
|
|
{
|
2006-08-14 04:58:19 +00:00
|
|
|
struct tree_content *tree;
|
|
|
|
struct atom_str* name;
|
2006-08-28 16:22:50 +00:00
|
|
|
struct tree_entry_ms
|
|
|
|
{
|
2007-02-05 21:34:56 +00:00
|
|
|
uint16_t mode;
|
2006-08-28 16:22:50 +00:00
|
|
|
unsigned char sha1[20];
|
|
|
|
} versions[2];
|
2006-08-08 07:36:45 +00:00
|
|
|
};
|
|
|
|
|
2006-08-14 04:58:19 +00:00
|
|
|
struct tree_content
|
2006-08-08 07:36:45 +00:00
|
|
|
{
|
2006-08-14 04:58:19 +00:00
|
|
|
unsigned int entry_capacity; /* must match avail_tree_content */
|
|
|
|
unsigned int entry_count;
|
2006-08-28 16:22:50 +00:00
|
|
|
unsigned int delta_depth;
|
2006-08-14 04:58:19 +00:00
|
|
|
struct tree_entry *entries[FLEX_ARRAY]; /* more */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct avail_tree_content
|
|
|
|
{
|
|
|
|
unsigned int entry_capacity; /* must match tree_content */
|
|
|
|
struct avail_tree_content *next_avail;
|
2006-08-08 07:36:45 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct branch
|
|
|
|
{
|
2006-08-14 04:58:19 +00:00
|
|
|
struct branch *table_next_branch;
|
|
|
|
struct branch *active_next_branch;
|
2006-08-08 07:36:45 +00:00
|
|
|
const char *name;
|
2006-08-14 04:58:19 +00:00
|
|
|
struct tree_entry branch_tree;
|
2007-01-17 07:42:43 +00:00
|
|
|
uintmax_t last_commit;
|
2007-03-05 17:31:09 +00:00
|
|
|
unsigned active : 1;
|
|
|
|
unsigned pack_id : PACK_ID_BITS;
|
2006-08-14 04:58:19 +00:00
|
|
|
unsigned char sha1[20];
|
2006-08-08 07:36:45 +00:00
|
|
|
};
|
|
|
|
|
2006-08-24 07:12:13 +00:00
|
|
|
struct tag
|
|
|
|
{
|
|
|
|
struct tag *next_tag;
|
|
|
|
const char *name;
|
2007-01-16 21:18:44 +00:00
|
|
|
unsigned int pack_id;
|
2006-08-24 07:12:13 +00:00
|
|
|
unsigned char sha1[20];
|
|
|
|
};
|
|
|
|
|
2007-01-12 03:21:38 +00:00
|
|
|
struct hash_list
|
|
|
|
{
|
|
|
|
struct hash_list *next;
|
|
|
|
unsigned char sha1[20];
|
|
|
|
};
|
2006-08-14 04:58:19 +00:00
|
|
|
|
2007-02-06 19:58:30 +00:00
|
|
|
typedef enum {
|
|
|
|
WHENSPEC_RAW = 1,
|
|
|
|
WHENSPEC_RFC2822,
|
|
|
|
WHENSPEC_NOW,
|
|
|
|
} whenspec_type;
|
|
|
|
|
2007-08-03 08:47:04 +00:00
|
|
|
struct recent_command
|
|
|
|
{
|
|
|
|
struct recent_command *prev;
|
|
|
|
struct recent_command *next;
|
|
|
|
char *buf;
|
|
|
|
};
|
|
|
|
|
2007-01-16 05:33:19 +00:00
|
|
|
/* Configured limits on output */
|
2006-08-23 06:00:31 +00:00
|
|
|
static unsigned long max_depth = 10;
|
2007-03-07 01:44:34 +00:00
|
|
|
static off_t max_packsize = (1LL << 32) - 1;
|
2007-02-06 21:08:06 +00:00
|
|
|
static int force_update;
|
2007-01-16 05:33:19 +00:00
|
|
|
|
|
|
|
/* Stats and misc. counters */
|
|
|
|
static uintmax_t alloc_count;
|
|
|
|
static uintmax_t marks_set_count;
|
|
|
|
static uintmax_t object_count_by_type[1 << TYPE_BITS];
|
|
|
|
static uintmax_t duplicate_count_by_type[1 << TYPE_BITS];
|
|
|
|
static uintmax_t delta_count_by_type[1 << TYPE_BITS];
|
2007-01-16 09:55:41 +00:00
|
|
|
static unsigned long object_count;
|
2006-08-08 07:36:45 +00:00
|
|
|
static unsigned long branch_count;
|
2006-08-23 08:31:12 +00:00
|
|
|
static unsigned long branch_load_count;
|
2007-02-06 21:08:06 +00:00
|
|
|
static int failure;
|
2007-02-12 00:45:56 +00:00
|
|
|
static FILE *pack_edges;
|
2006-08-08 04:46:13 +00:00
|
|
|
|
2006-08-14 04:58:19 +00:00
|
|
|
/* Memory pools */
|
|
|
|
static size_t mem_pool_alloc = 2*1024*1024 - sizeof(struct mem_pool);
|
|
|
|
static size_t total_allocd;
|
|
|
|
static struct mem_pool *mem_pool;
|
|
|
|
|
2006-08-15 00:16:28 +00:00
|
|
|
/* Atom management */
|
2006-08-14 04:58:19 +00:00
|
|
|
static unsigned int atom_table_sz = 4451;
|
|
|
|
static unsigned int atom_cnt;
|
|
|
|
static struct atom_str **atom_table;
|
|
|
|
|
|
|
|
/* The .pack file being generated */
|
2007-01-15 11:35:41 +00:00
|
|
|
static unsigned int pack_id;
|
2007-01-14 11:20:23 +00:00
|
|
|
static struct packed_git *pack_data;
|
2007-01-15 11:35:41 +00:00
|
|
|
static struct packed_git **all_packs;
|
2006-08-24 08:37:35 +00:00
|
|
|
static unsigned long pack_size;
|
2006-08-08 04:46:13 +00:00
|
|
|
|
|
|
|
/* Table of objects we've written. */
|
2006-08-28 16:22:50 +00:00
|
|
|
static unsigned int object_entry_alloc = 5000;
|
2006-08-14 04:58:19 +00:00
|
|
|
static struct object_entry_pool *blocks;
|
|
|
|
static struct object_entry *object_table[1 << 16];
|
2006-08-23 08:17:45 +00:00
|
|
|
static struct mark_set *marks;
|
2006-08-25 20:03:04 +00:00
|
|
|
static const char* mark_file;
|
2006-08-08 04:46:13 +00:00
|
|
|
|
|
|
|
/* Our last blob */
|
2007-09-17 12:00:38 +00:00
|
|
|
static struct last_object last_blob = { STRBUF_INIT, 0, 0, 0 };
|
2006-08-14 04:58:19 +00:00
|
|
|
|
|
|
|
/* Tree management */
|
|
|
|
static unsigned int tree_entry_alloc = 1000;
|
|
|
|
static void *avail_tree_entry;
|
|
|
|
static unsigned int avail_tree_table_sz = 100;
|
|
|
|
static struct avail_tree_content **avail_tree_table;
|
2007-09-17 11:48:17 +00:00
|
|
|
static struct strbuf old_tree = STRBUF_INIT;
|
|
|
|
static struct strbuf new_tree = STRBUF_INIT;
|
2006-08-06 17:51:39 +00:00
|
|
|
|
2006-08-08 07:36:45 +00:00
|
|
|
/* Branch data */
|
2006-08-23 06:00:31 +00:00
|
|
|
static unsigned long max_active_branches = 5;
|
|
|
|
static unsigned long cur_active_branches;
|
|
|
|
static unsigned long branch_table_sz = 1039;
|
2006-08-14 04:58:19 +00:00
|
|
|
static struct branch **branch_table;
|
|
|
|
static struct branch *active_branches;
|
|
|
|
|
2006-08-24 07:12:13 +00:00
|
|
|
/* Tag data */
|
|
|
|
static struct tag *first_tag;
|
|
|
|
static struct tag *last_tag;
|
|
|
|
|
2006-08-15 00:16:28 +00:00
|
|
|
/* Input stream parsing */
|
2007-02-06 19:58:30 +00:00
|
|
|
static whenspec_type whenspec = WHENSPEC_RAW;
|
2007-09-06 11:20:07 +00:00
|
|
|
static struct strbuf command_buf = STRBUF_INIT;
|
2007-08-01 06:22:53 +00:00
|
|
|
static int unread_command_buf;
|
2007-08-03 08:47:04 +00:00
|
|
|
static struct recent_command cmd_hist = {&cmd_hist, &cmd_hist, NULL};
|
|
|
|
static struct recent_command *cmd_tail = &cmd_hist;
|
|
|
|
static struct recent_command *rc_free;
|
|
|
|
static unsigned int cmd_save = 100;
|
2007-01-16 05:33:19 +00:00
|
|
|
static uintmax_t next_mark;
|
2007-09-17 11:48:17 +00:00
|
|
|
static struct strbuf new_data = STRBUF_INIT;
|
2006-08-15 00:16:28 +00:00
|
|
|
|
2007-08-03 06:00:37 +00:00
|
|
|
static void write_branch_report(FILE *rpt, struct branch *b)
|
|
|
|
{
|
|
|
|
fprintf(rpt, "%s:\n", b->name);
|
|
|
|
|
|
|
|
fprintf(rpt, " status :");
|
|
|
|
if (b->active)
|
|
|
|
fputs(" active", rpt);
|
|
|
|
if (b->branch_tree.tree)
|
|
|
|
fputs(" loaded", rpt);
|
|
|
|
if (is_null_sha1(b->branch_tree.versions[1].sha1))
|
|
|
|
fputs(" dirty", rpt);
|
|
|
|
fputc('\n', rpt);
|
|
|
|
|
|
|
|
fprintf(rpt, " tip commit : %s\n", sha1_to_hex(b->sha1));
|
|
|
|
fprintf(rpt, " old tree : %s\n", sha1_to_hex(b->branch_tree.versions[0].sha1));
|
|
|
|
fprintf(rpt, " cur tree : %s\n", sha1_to_hex(b->branch_tree.versions[1].sha1));
|
|
|
|
fprintf(rpt, " commit clock: %" PRIuMAX "\n", b->last_commit);
|
|
|
|
|
|
|
|
fputs(" last pack : ", rpt);
|
|
|
|
if (b->pack_id < MAX_PACK_ID)
|
|
|
|
fprintf(rpt, "%u", b->pack_id);
|
|
|
|
fputc('\n', rpt);
|
|
|
|
|
|
|
|
fputc('\n', rpt);
|
|
|
|
}
|
|
|
|
|
2007-08-21 03:38:14 +00:00
|
|
|
static void write_crash_report(const char *err)
|
2007-08-03 06:00:37 +00:00
|
|
|
{
|
|
|
|
char *loc = git_path("fast_import_crash_%d", getpid());
|
|
|
|
FILE *rpt = fopen(loc, "w");
|
|
|
|
struct branch *b;
|
|
|
|
unsigned long lu;
|
2007-08-03 08:47:04 +00:00
|
|
|
struct recent_command *rc;
|
2007-08-03 06:00:37 +00:00
|
|
|
|
|
|
|
if (!rpt) {
|
|
|
|
error("can't write crash report %s: %s", loc, strerror(errno));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(stderr, "fast-import: dumping crash report to %s\n", loc);
|
|
|
|
|
|
|
|
fprintf(rpt, "fast-import crash report:\n");
|
|
|
|
fprintf(rpt, " fast-import process: %d\n", getpid());
|
|
|
|
fprintf(rpt, " parent process : %d\n", getppid());
|
|
|
|
fprintf(rpt, " at %s\n", show_date(time(NULL), 0, DATE_LOCAL));
|
|
|
|
fputc('\n', rpt);
|
|
|
|
|
|
|
|
fputs("fatal: ", rpt);
|
2007-08-21 03:38:14 +00:00
|
|
|
fputs(err, rpt);
|
2007-08-03 06:00:37 +00:00
|
|
|
fputc('\n', rpt);
|
|
|
|
|
2007-08-03 08:47:04 +00:00
|
|
|
fputc('\n', rpt);
|
|
|
|
fputs("Most Recent Commands Before Crash\n", rpt);
|
|
|
|
fputs("---------------------------------\n", rpt);
|
|
|
|
for (rc = cmd_hist.next; rc != &cmd_hist; rc = rc->next) {
|
|
|
|
if (rc->next == &cmd_hist)
|
|
|
|
fputs("* ", rpt);
|
|
|
|
else
|
|
|
|
fputs(" ", rpt);
|
|
|
|
fputs(rc->buf, rpt);
|
|
|
|
fputc('\n', rpt);
|
|
|
|
}
|
|
|
|
|
2007-08-03 06:00:37 +00:00
|
|
|
fputc('\n', rpt);
|
|
|
|
fputs("Active Branch LRU\n", rpt);
|
|
|
|
fputs("-----------------\n", rpt);
|
|
|
|
fprintf(rpt, " active_branches = %lu cur, %lu max\n",
|
|
|
|
cur_active_branches,
|
|
|
|
max_active_branches);
|
|
|
|
fputc('\n', rpt);
|
|
|
|
fputs(" pos clock name\n", rpt);
|
|
|
|
fputs(" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n", rpt);
|
|
|
|
for (b = active_branches, lu = 0; b; b = b->active_next_branch)
|
|
|
|
fprintf(rpt, " %2lu) %6" PRIuMAX" %s\n",
|
|
|
|
++lu, b->last_commit, b->name);
|
|
|
|
|
|
|
|
fputc('\n', rpt);
|
|
|
|
fputs("Inactive Branches\n", rpt);
|
|
|
|
fputs("-----------------\n", rpt);
|
|
|
|
for (lu = 0; lu < branch_table_sz; lu++) {
|
|
|
|
for (b = branch_table[lu]; b; b = b->table_next_branch)
|
|
|
|
write_branch_report(rpt, b);
|
|
|
|
}
|
|
|
|
|
|
|
|
fputc('\n', rpt);
|
|
|
|
fputs("-------------------\n", rpt);
|
|
|
|
fputs("END OF CRASH REPORT\n", rpt);
|
|
|
|
fclose(rpt);
|
|
|
|
}
|
|
|
|
|
|
|
|
static NORETURN void die_nicely(const char *err, va_list params)
|
|
|
|
{
|
|
|
|
static int zombie;
|
2007-08-21 03:38:14 +00:00
|
|
|
char message[2 * PATH_MAX];
|
2007-08-03 06:00:37 +00:00
|
|
|
|
2007-08-21 03:38:14 +00:00
|
|
|
vsnprintf(message, sizeof(message), err, params);
|
2007-08-03 06:00:37 +00:00
|
|
|
fputs("fatal: ", stderr);
|
2007-08-21 03:38:14 +00:00
|
|
|
fputs(message, stderr);
|
2007-08-03 06:00:37 +00:00
|
|
|
fputc('\n', stderr);
|
|
|
|
|
|
|
|
if (!zombie) {
|
|
|
|
zombie = 1;
|
2007-08-21 03:38:14 +00:00
|
|
|
write_crash_report(message);
|
2007-08-03 06:00:37 +00:00
|
|
|
}
|
|
|
|
exit(128);
|
|
|
|
}
|
2006-08-08 07:36:45 +00:00
|
|
|
|
2007-01-15 05:16:23 +00:00
|
|
|
static void alloc_objects(unsigned int cnt)
|
2006-08-06 17:51:39 +00:00
|
|
|
{
|
2006-08-14 04:58:19 +00:00
|
|
|
struct object_entry_pool *b;
|
2006-08-08 04:03:59 +00:00
|
|
|
|
2006-08-14 04:58:19 +00:00
|
|
|
b = xmalloc(sizeof(struct object_entry_pool)
|
2006-08-08 04:03:59 +00:00
|
|
|
+ cnt * sizeof(struct object_entry));
|
2006-08-14 04:58:19 +00:00
|
|
|
b->next_pool = blocks;
|
2006-08-08 04:03:59 +00:00
|
|
|
b->next_free = b->entries;
|
|
|
|
b->end = b->entries + cnt;
|
|
|
|
blocks = b;
|
|
|
|
alloc_count += cnt;
|
|
|
|
}
|
2006-08-06 17:51:39 +00:00
|
|
|
|
2007-02-06 05:43:59 +00:00
|
|
|
static struct object_entry *new_object(unsigned char *sha1)
|
2006-08-06 17:51:39 +00:00
|
|
|
{
|
2006-08-08 04:03:59 +00:00
|
|
|
struct object_entry *e;
|
2006-08-06 17:51:39 +00:00
|
|
|
|
2006-08-08 04:03:59 +00:00
|
|
|
if (blocks->next_free == blocks->end)
|
2006-08-14 04:58:19 +00:00
|
|
|
alloc_objects(object_entry_alloc);
|
2006-08-06 17:51:39 +00:00
|
|
|
|
2006-08-08 04:03:59 +00:00
|
|
|
e = blocks->next_free++;
|
2006-08-28 14:46:58 +00:00
|
|
|
hashcpy(e->sha1, sha1);
|
2006-08-08 04:03:59 +00:00
|
|
|
return e;
|
2006-08-06 17:51:39 +00:00
|
|
|
}
|
|
|
|
|
2007-02-06 05:43:59 +00:00
|
|
|
static struct object_entry *find_object(unsigned char *sha1)
|
2006-08-14 04:58:19 +00:00
|
|
|
{
|
|
|
|
unsigned int h = sha1[0] << 8 | sha1[1];
|
|
|
|
struct object_entry *e;
|
|
|
|
for (e = object_table[h]; e; e = e->next)
|
2006-08-28 14:46:58 +00:00
|
|
|
if (!hashcmp(sha1, e->sha1))
|
2006-08-14 04:58:19 +00:00
|
|
|
return e;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-02-06 05:43:59 +00:00
|
|
|
static struct object_entry *insert_object(unsigned char *sha1)
|
2006-08-06 17:51:39 +00:00
|
|
|
{
|
|
|
|
unsigned int h = sha1[0] << 8 | sha1[1];
|
2006-08-08 04:03:59 +00:00
|
|
|
struct object_entry *e = object_table[h];
|
2006-08-14 04:58:19 +00:00
|
|
|
struct object_entry *p = NULL;
|
2006-08-06 17:51:39 +00:00
|
|
|
|
|
|
|
while (e) {
|
2006-08-28 14:46:58 +00:00
|
|
|
if (!hashcmp(sha1, e->sha1))
|
2006-08-06 17:51:39 +00:00
|
|
|
return e;
|
|
|
|
p = e;
|
|
|
|
e = e->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
e = new_object(sha1);
|
2006-08-14 04:58:19 +00:00
|
|
|
e->next = NULL;
|
2006-08-06 17:51:39 +00:00
|
|
|
e->offset = 0;
|
|
|
|
if (p)
|
|
|
|
p->next = e;
|
|
|
|
else
|
2006-08-08 04:03:59 +00:00
|
|
|
object_table[h] = e;
|
2006-08-06 17:51:39 +00:00
|
|
|
return e;
|
|
|
|
}
|
2006-08-05 06:04:21 +00:00
|
|
|
|
2006-08-14 04:58:19 +00:00
|
|
|
static unsigned int hc_str(const char *s, size_t len)
|
|
|
|
{
|
|
|
|
unsigned int r = 0;
|
|
|
|
while (len-- > 0)
|
|
|
|
r = r * 31 + *s++;
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2007-02-06 05:43:59 +00:00
|
|
|
static void *pool_alloc(size_t len)
|
2006-08-14 04:58:19 +00:00
|
|
|
{
|
|
|
|
struct mem_pool *p;
|
|
|
|
void *r;
|
|
|
|
|
|
|
|
for (p = mem_pool; p; p = p->next_pool)
|
|
|
|
if ((p->end - p->next_free >= len))
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (!p) {
|
|
|
|
if (len >= (mem_pool_alloc/2)) {
|
|
|
|
total_allocd += len;
|
|
|
|
return xmalloc(len);
|
|
|
|
}
|
|
|
|
total_allocd += sizeof(struct mem_pool) + mem_pool_alloc;
|
|
|
|
p = xmalloc(sizeof(struct mem_pool) + mem_pool_alloc);
|
|
|
|
p->next_pool = mem_pool;
|
|
|
|
p->next_free = p->space;
|
|
|
|
p->end = p->next_free + mem_pool_alloc;
|
|
|
|
mem_pool = p;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = p->next_free;
|
2006-08-24 08:46:29 +00:00
|
|
|
/* round out to a pointer alignment */
|
|
|
|
if (len & (sizeof(void*) - 1))
|
|
|
|
len += sizeof(void*) - (len & (sizeof(void*) - 1));
|
2006-08-14 04:58:19 +00:00
|
|
|
p->next_free += len;
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2007-02-06 05:43:59 +00:00
|
|
|
static void *pool_calloc(size_t count, size_t size)
|
2006-08-14 04:58:19 +00:00
|
|
|
{
|
|
|
|
size_t len = count * size;
|
|
|
|
void *r = pool_alloc(len);
|
|
|
|
memset(r, 0, len);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2007-02-06 05:43:59 +00:00
|
|
|
static char *pool_strdup(const char *s)
|
2006-08-14 04:58:19 +00:00
|
|
|
{
|
|
|
|
char *r = pool_alloc(strlen(s) + 1);
|
|
|
|
strcpy(r, s);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2007-01-16 05:33:19 +00:00
|
|
|
static void insert_mark(uintmax_t idnum, struct object_entry *oe)
|
2006-08-23 08:17:45 +00:00
|
|
|
{
|
|
|
|
struct mark_set *s = marks;
|
|
|
|
while ((idnum >> s->shift) >= 1024) {
|
|
|
|
s = pool_calloc(1, sizeof(struct mark_set));
|
|
|
|
s->shift = marks->shift + 10;
|
|
|
|
s->data.sets[0] = marks;
|
|
|
|
marks = s;
|
|
|
|
}
|
|
|
|
while (s->shift) {
|
2007-01-16 05:33:19 +00:00
|
|
|
uintmax_t i = idnum >> s->shift;
|
2006-08-23 08:17:45 +00:00
|
|
|
idnum -= i << s->shift;
|
|
|
|
if (!s->data.sets[i]) {
|
|
|
|
s->data.sets[i] = pool_calloc(1, sizeof(struct mark_set));
|
|
|
|
s->data.sets[i]->shift = s->shift - 10;
|
|
|
|
}
|
|
|
|
s = s->data.sets[i];
|
|
|
|
}
|
|
|
|
if (!s->data.marked[idnum])
|
|
|
|
marks_set_count++;
|
|
|
|
s->data.marked[idnum] = oe;
|
|
|
|
}
|
|
|
|
|
2007-02-06 05:43:59 +00:00
|
|
|
static struct object_entry *find_mark(uintmax_t idnum)
|
2006-08-23 08:17:45 +00:00
|
|
|
{
|
2007-01-16 05:33:19 +00:00
|
|
|
uintmax_t orig_idnum = idnum;
|
2006-08-23 08:17:45 +00:00
|
|
|
struct mark_set *s = marks;
|
|
|
|
struct object_entry *oe = NULL;
|
|
|
|
if ((idnum >> s->shift) < 1024) {
|
|
|
|
while (s && s->shift) {
|
2007-01-16 05:33:19 +00:00
|
|
|
uintmax_t i = idnum >> s->shift;
|
2006-08-23 08:17:45 +00:00
|
|
|
idnum -= i << s->shift;
|
|
|
|
s = s->data.sets[i];
|
|
|
|
}
|
|
|
|
if (s)
|
|
|
|
oe = s->data.marked[idnum];
|
|
|
|
}
|
|
|
|
if (!oe)
|
2007-02-21 01:34:56 +00:00
|
|
|
die("mark :%" PRIuMAX " not declared", orig_idnum);
|
2006-08-23 08:17:45 +00:00
|
|
|
return oe;
|
|
|
|
}
|
|
|
|
|
2007-02-06 05:43:59 +00:00
|
|
|
static struct atom_str *to_atom(const char *s, unsigned short len)
|
2006-08-14 04:58:19 +00:00
|
|
|
{
|
|
|
|
unsigned int hc = hc_str(s, len) % atom_table_sz;
|
|
|
|
struct atom_str *c;
|
|
|
|
|
|
|
|
for (c = atom_table[hc]; c; c = c->next_atom)
|
|
|
|
if (c->str_len == len && !strncmp(s, c->str_dat, len))
|
|
|
|
return c;
|
|
|
|
|
|
|
|
c = pool_alloc(sizeof(struct atom_str) + len + 1);
|
|
|
|
c->str_len = len;
|
|
|
|
strncpy(c->str_dat, s, len);
|
|
|
|
c->str_dat[len] = 0;
|
|
|
|
c->next_atom = atom_table[hc];
|
|
|
|
atom_table[hc] = c;
|
|
|
|
atom_cnt++;
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
2007-02-06 05:43:59 +00:00
|
|
|
static struct branch *lookup_branch(const char *name)
|
2006-08-14 04:58:19 +00:00
|
|
|
{
|
|
|
|
unsigned int hc = hc_str(name, strlen(name)) % branch_table_sz;
|
|
|
|
struct branch *b;
|
|
|
|
|
|
|
|
for (b = branch_table[hc]; b; b = b->table_next_branch)
|
|
|
|
if (!strcmp(name, b->name))
|
|
|
|
return b;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-02-06 05:43:59 +00:00
|
|
|
static struct branch *new_branch(const char *name)
|
2006-08-14 04:58:19 +00:00
|
|
|
{
|
|
|
|
unsigned int hc = hc_str(name, strlen(name)) % branch_table_sz;
|
|
|
|
struct branch* b = lookup_branch(name);
|
|
|
|
|
|
|
|
if (b)
|
|
|
|
die("Invalid attempt to create duplicate branch: %s", name);
|
2007-08-03 03:37:21 +00:00
|
|
|
switch (check_ref_format(name)) {
|
|
|
|
case 0: break; /* its valid */
|
|
|
|
case -2: break; /* valid, but too few '/', allow anyway */
|
|
|
|
default:
|
2006-08-15 00:16:28 +00:00
|
|
|
die("Branch name doesn't conform to GIT standards: %s", name);
|
2007-08-03 03:37:21 +00:00
|
|
|
}
|
2006-08-14 04:58:19 +00:00
|
|
|
|
|
|
|
b = pool_calloc(1, sizeof(struct branch));
|
|
|
|
b->name = pool_strdup(name);
|
|
|
|
b->table_next_branch = branch_table[hc];
|
2006-08-29 02:06:13 +00:00
|
|
|
b->branch_tree.versions[0].mode = S_IFDIR;
|
|
|
|
b->branch_tree.versions[1].mode = S_IFDIR;
|
2007-03-05 17:31:09 +00:00
|
|
|
b->active = 0;
|
2007-01-17 07:42:43 +00:00
|
|
|
b->pack_id = MAX_PACK_ID;
|
2006-08-14 04:58:19 +00:00
|
|
|
branch_table[hc] = b;
|
|
|
|
branch_count++;
|
|
|
|
return b;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int hc_entries(unsigned int cnt)
|
|
|
|
{
|
|
|
|
cnt = cnt & 7 ? (cnt / 8) + 1 : cnt / 8;
|
|
|
|
return cnt < avail_tree_table_sz ? cnt : avail_tree_table_sz - 1;
|
|
|
|
}
|
|
|
|
|
2007-02-06 05:43:59 +00:00
|
|
|
static struct tree_content *new_tree_content(unsigned int cnt)
|
2006-08-14 04:58:19 +00:00
|
|
|
{
|
|
|
|
struct avail_tree_content *f, *l = NULL;
|
|
|
|
struct tree_content *t;
|
|
|
|
unsigned int hc = hc_entries(cnt);
|
|
|
|
|
|
|
|
for (f = avail_tree_table[hc]; f; l = f, f = f->next_avail)
|
|
|
|
if (f->entry_capacity >= cnt)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (f) {
|
|
|
|
if (l)
|
|
|
|
l->next_avail = f->next_avail;
|
|
|
|
else
|
|
|
|
avail_tree_table[hc] = f->next_avail;
|
|
|
|
} else {
|
|
|
|
cnt = cnt & 7 ? ((cnt / 8) + 1) * 8 : cnt;
|
|
|
|
f = pool_alloc(sizeof(*t) + sizeof(t->entries[0]) * cnt);
|
|
|
|
f->entry_capacity = cnt;
|
|
|
|
}
|
|
|
|
|
|
|
|
t = (struct tree_content*)f;
|
|
|
|
t->entry_count = 0;
|
2006-08-28 16:22:50 +00:00
|
|
|
t->delta_depth = 0;
|
2006-08-14 04:58:19 +00:00
|
|
|
return t;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void release_tree_entry(struct tree_entry *e);
|
|
|
|
static void release_tree_content(struct tree_content *t)
|
|
|
|
{
|
|
|
|
struct avail_tree_content *f = (struct avail_tree_content*)t;
|
|
|
|
unsigned int hc = hc_entries(f->entry_capacity);
|
2006-08-23 05:33:47 +00:00
|
|
|
f->next_avail = avail_tree_table[hc];
|
|
|
|
avail_tree_table[hc] = f;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void release_tree_content_recursive(struct tree_content *t)
|
|
|
|
{
|
2006-08-14 04:58:19 +00:00
|
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < t->entry_count; i++)
|
|
|
|
release_tree_entry(t->entries[i]);
|
2006-08-23 05:33:47 +00:00
|
|
|
release_tree_content(t);
|
2006-08-14 04:58:19 +00:00
|
|
|
}
|
|
|
|
|
2007-02-06 05:43:59 +00:00
|
|
|
static struct tree_content *grow_tree_content(
|
2006-08-14 04:58:19 +00:00
|
|
|
struct tree_content *t,
|
|
|
|
int amt)
|
|
|
|
{
|
|
|
|
struct tree_content *r = new_tree_content(t->entry_count + amt);
|
|
|
|
r->entry_count = t->entry_count;
|
2006-08-28 16:22:50 +00:00
|
|
|
r->delta_depth = t->delta_depth;
|
2006-08-14 04:58:19 +00:00
|
|
|
memcpy(r->entries,t->entries,t->entry_count*sizeof(t->entries[0]));
|
|
|
|
release_tree_content(t);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2007-02-06 05:43:59 +00:00
|
|
|
static struct tree_entry *new_tree_entry(void)
|
2006-08-14 04:58:19 +00:00
|
|
|
{
|
|
|
|
struct tree_entry *e;
|
|
|
|
|
|
|
|
if (!avail_tree_entry) {
|
|
|
|
unsigned int n = tree_entry_alloc;
|
2006-08-25 18:53:32 +00:00
|
|
|
total_allocd += n * sizeof(struct tree_entry);
|
2006-08-14 04:58:19 +00:00
|
|
|
avail_tree_entry = e = xmalloc(n * sizeof(struct tree_entry));
|
2006-08-27 02:38:02 +00:00
|
|
|
while (n-- > 1) {
|
2006-08-14 04:58:19 +00:00
|
|
|
*((void**)e) = e + 1;
|
|
|
|
e++;
|
|
|
|
}
|
2006-08-27 03:37:31 +00:00
|
|
|
*((void**)e) = NULL;
|
2006-08-14 04:58:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
e = avail_tree_entry;
|
|
|
|
avail_tree_entry = *((void**)e);
|
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void release_tree_entry(struct tree_entry *e)
|
|
|
|
{
|
|
|
|
if (e->tree)
|
2006-08-23 05:33:47 +00:00
|
|
|
release_tree_content_recursive(e->tree);
|
2006-08-14 04:58:19 +00:00
|
|
|
*((void**)e) = avail_tree_entry;
|
|
|
|
avail_tree_entry = e;
|
|
|
|
}
|
|
|
|
|
2007-07-15 05:40:37 +00:00
|
|
|
static struct tree_content *dup_tree_content(struct tree_content *s)
|
|
|
|
{
|
|
|
|
struct tree_content *d;
|
|
|
|
struct tree_entry *a, *b;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
if (!s)
|
|
|
|
return NULL;
|
|
|
|
d = new_tree_content(s->entry_count);
|
|
|
|
for (i = 0; i < s->entry_count; i++) {
|
|
|
|
a = s->entries[i];
|
|
|
|
b = new_tree_entry();
|
|
|
|
memcpy(b, a, sizeof(*a));
|
|
|
|
if (a->tree && is_null_sha1(b->versions[1].sha1))
|
|
|
|
b->tree = dup_tree_content(a->tree);
|
|
|
|
else
|
|
|
|
b->tree = NULL;
|
|
|
|
d->entries[i] = b;
|
|
|
|
}
|
|
|
|
d->entry_count = s->entry_count;
|
|
|
|
d->delta_depth = s->delta_depth;
|
|
|
|
|
|
|
|
return d;
|
|
|
|
}
|
|
|
|
|
2007-01-17 06:47:25 +00:00
|
|
|
static void start_packfile(void)
|
2007-01-15 09:39:05 +00:00
|
|
|
{
|
2007-01-16 06:15:31 +00:00
|
|
|
static char tmpfile[PATH_MAX];
|
2007-01-15 11:35:41 +00:00
|
|
|
struct packed_git *p;
|
2007-01-15 09:39:05 +00:00
|
|
|
struct pack_header hdr;
|
2007-01-16 06:20:57 +00:00
|
|
|
int pack_fd;
|
2007-01-15 09:39:05 +00:00
|
|
|
|
2007-01-16 06:15:31 +00:00
|
|
|
snprintf(tmpfile, sizeof(tmpfile),
|
2007-03-24 15:58:22 +00:00
|
|
|
"%s/tmp_pack_XXXXXX", get_object_directory());
|
2007-08-14 19:45:58 +00:00
|
|
|
pack_fd = xmkstemp(tmpfile);
|
2007-01-16 06:15:31 +00:00
|
|
|
p = xcalloc(1, sizeof(*p) + strlen(tmpfile) + 2);
|
|
|
|
strcpy(p->pack_name, tmpfile);
|
2007-01-15 11:35:41 +00:00
|
|
|
p->pack_fd = pack_fd;
|
2007-01-15 09:39:05 +00:00
|
|
|
|
|
|
|
hdr.hdr_signature = htonl(PACK_SIGNATURE);
|
|
|
|
hdr.hdr_version = htonl(2);
|
|
|
|
hdr.hdr_entries = 0;
|
2007-01-16 06:20:57 +00:00
|
|
|
write_or_die(p->pack_fd, &hdr, sizeof(hdr));
|
2007-01-15 11:35:41 +00:00
|
|
|
|
|
|
|
pack_data = p;
|
2007-01-15 09:39:05 +00:00
|
|
|
pack_size = sizeof(hdr);
|
|
|
|
object_count = 0;
|
2007-01-15 11:35:41 +00:00
|
|
|
|
|
|
|
all_packs = xrealloc(all_packs, sizeof(*all_packs) * (pack_id + 1));
|
|
|
|
all_packs[pack_id] = p;
|
2007-01-15 09:39:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int oecmp (const void *a_, const void *b_)
|
|
|
|
{
|
|
|
|
struct object_entry *a = *((struct object_entry**)a_);
|
|
|
|
struct object_entry *b = *((struct object_entry**)b_);
|
|
|
|
return hashcmp(a->sha1, b->sha1);
|
|
|
|
}
|
|
|
|
|
2007-02-06 05:43:59 +00:00
|
|
|
static char *create_index(void)
|
2007-01-15 09:39:05 +00:00
|
|
|
{
|
2007-01-16 06:15:31 +00:00
|
|
|
static char tmpfile[PATH_MAX];
|
|
|
|
SHA_CTX ctx;
|
2007-01-15 09:39:05 +00:00
|
|
|
struct sha1file *f;
|
|
|
|
struct object_entry **idx, **c, **last, *e;
|
|
|
|
struct object_entry_pool *o;
|
2007-01-18 16:30:17 +00:00
|
|
|
uint32_t array[256];
|
2007-01-16 06:15:31 +00:00
|
|
|
int i, idx_fd;
|
2007-01-15 09:39:05 +00:00
|
|
|
|
|
|
|
/* Build the sorted table of object IDs. */
|
|
|
|
idx = xmalloc(object_count * sizeof(struct object_entry*));
|
|
|
|
c = idx;
|
|
|
|
for (o = blocks; o; o = o->next_pool)
|
2007-01-15 13:00:49 +00:00
|
|
|
for (e = o->next_free; e-- != o->entries;)
|
|
|
|
if (pack_id == e->pack_id)
|
|
|
|
*c++ = e;
|
2007-01-15 09:39:05 +00:00
|
|
|
last = idx + object_count;
|
2007-01-15 11:51:58 +00:00
|
|
|
if (c != last)
|
|
|
|
die("internal consistency error creating the index");
|
2007-01-15 09:39:05 +00:00
|
|
|
qsort(idx, object_count, sizeof(struct object_entry*), oecmp);
|
|
|
|
|
|
|
|
/* Generate the fan-out array. */
|
|
|
|
c = idx;
|
|
|
|
for (i = 0; i < 256; i++) {
|
|
|
|
struct object_entry **next = c;;
|
|
|
|
while (next < last) {
|
|
|
|
if ((*next)->sha1[0] != i)
|
|
|
|
break;
|
|
|
|
next++;
|
|
|
|
}
|
|
|
|
array[i] = htonl(next - idx);
|
|
|
|
c = next;
|
|
|
|
}
|
|
|
|
|
2007-01-16 06:15:31 +00:00
|
|
|
snprintf(tmpfile, sizeof(tmpfile),
|
2007-03-24 15:58:22 +00:00
|
|
|
"%s/tmp_idx_XXXXXX", get_object_directory());
|
2007-08-14 19:45:58 +00:00
|
|
|
idx_fd = xmkstemp(tmpfile);
|
2007-01-16 06:15:31 +00:00
|
|
|
f = sha1fd(idx_fd, tmpfile);
|
2007-01-15 09:39:05 +00:00
|
|
|
sha1write(f, array, 256 * sizeof(int));
|
2007-01-16 06:15:31 +00:00
|
|
|
SHA1_Init(&ctx);
|
2007-01-15 09:39:05 +00:00
|
|
|
for (c = idx; c != last; c++) {
|
2007-01-18 16:30:17 +00:00
|
|
|
uint32_t offset = htonl((*c)->offset);
|
2007-01-15 09:39:05 +00:00
|
|
|
sha1write(f, &offset, 4);
|
|
|
|
sha1write(f, (*c)->sha1, sizeof((*c)->sha1));
|
2007-01-16 06:15:31 +00:00
|
|
|
SHA1_Update(&ctx, (*c)->sha1, 20);
|
2007-01-15 09:39:05 +00:00
|
|
|
}
|
2007-01-16 05:44:48 +00:00
|
|
|
sha1write(f, pack_data->sha1, sizeof(pack_data->sha1));
|
2007-01-16 06:15:31 +00:00
|
|
|
sha1close(f, NULL, 1);
|
2007-01-15 09:39:05 +00:00
|
|
|
free(idx);
|
2007-01-16 06:15:31 +00:00
|
|
|
SHA1_Final(pack_data->sha1, &ctx);
|
|
|
|
return tmpfile;
|
|
|
|
}
|
|
|
|
|
2007-02-06 05:43:59 +00:00
|
|
|
static char *keep_pack(char *curr_index_name)
|
2007-01-16 06:15:31 +00:00
|
|
|
{
|
|
|
|
static char name[PATH_MAX];
|
2007-03-07 01:44:17 +00:00
|
|
|
static const char *keep_msg = "fast-import";
|
2007-01-16 06:15:31 +00:00
|
|
|
int keep_fd;
|
|
|
|
|
|
|
|
chmod(pack_data->pack_name, 0444);
|
|
|
|
chmod(curr_index_name, 0444);
|
|
|
|
|
|
|
|
snprintf(name, sizeof(name), "%s/pack/pack-%s.keep",
|
|
|
|
get_object_directory(), sha1_to_hex(pack_data->sha1));
|
|
|
|
keep_fd = open(name, O_RDWR|O_CREAT|O_EXCL, 0600);
|
|
|
|
if (keep_fd < 0)
|
|
|
|
die("cannot create keep file");
|
|
|
|
write(keep_fd, keep_msg, strlen(keep_msg));
|
|
|
|
close(keep_fd);
|
|
|
|
|
|
|
|
snprintf(name, sizeof(name), "%s/pack/pack-%s.pack",
|
|
|
|
get_object_directory(), sha1_to_hex(pack_data->sha1));
|
|
|
|
if (move_temp_to_file(pack_data->pack_name, name))
|
|
|
|
die("cannot store pack file");
|
|
|
|
|
|
|
|
snprintf(name, sizeof(name), "%s/pack/pack-%s.idx",
|
|
|
|
get_object_directory(), sha1_to_hex(pack_data->sha1));
|
|
|
|
if (move_temp_to_file(curr_index_name, name))
|
|
|
|
die("cannot store index file");
|
|
|
|
return name;
|
|
|
|
}
|
|
|
|
|
2007-01-17 06:47:25 +00:00
|
|
|
static void unkeep_all_packs(void)
|
2007-01-16 06:15:31 +00:00
|
|
|
{
|
|
|
|
static char name[PATH_MAX];
|
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < pack_id; k++) {
|
|
|
|
struct packed_git *p = all_packs[k];
|
|
|
|
snprintf(name, sizeof(name), "%s/pack/pack-%s.keep",
|
|
|
|
get_object_directory(), sha1_to_hex(p->sha1));
|
|
|
|
unlink(name);
|
|
|
|
}
|
2007-01-15 09:39:05 +00:00
|
|
|
}
|
|
|
|
|
2007-01-17 06:47:25 +00:00
|
|
|
static void end_packfile(void)
|
2007-01-15 09:39:05 +00:00
|
|
|
{
|
2007-01-15 11:35:41 +00:00
|
|
|
struct packed_git *old_p = pack_data, *new_p;
|
|
|
|
|
2007-01-15 11:39:39 +00:00
|
|
|
if (object_count) {
|
2007-01-16 06:15:31 +00:00
|
|
|
char *idx_name;
|
2007-01-16 21:18:44 +00:00
|
|
|
int i;
|
|
|
|
struct branch *b;
|
|
|
|
struct tag *t;
|
2007-01-16 06:15:31 +00:00
|
|
|
|
2007-05-02 16:13:14 +00:00
|
|
|
fixup_pack_header_footer(pack_data->pack_fd, pack_data->sha1,
|
|
|
|
pack_data->pack_name, object_count);
|
|
|
|
close(pack_data->pack_fd);
|
2007-01-16 06:15:31 +00:00
|
|
|
idx_name = keep_pack(create_index());
|
2007-01-15 11:39:39 +00:00
|
|
|
|
|
|
|
/* Register the packfile with core git's machinary. */
|
|
|
|
new_p = add_packed_git(idx_name, strlen(idx_name), 1);
|
|
|
|
if (!new_p)
|
|
|
|
die("core git rejected index %s", idx_name);
|
|
|
|
new_p->windows = old_p->windows;
|
2007-01-16 21:18:44 +00:00
|
|
|
all_packs[pack_id] = new_p;
|
2007-01-15 11:39:39 +00:00
|
|
|
install_packed_git(new_p);
|
2007-01-16 21:18:44 +00:00
|
|
|
|
|
|
|
/* Print the boundary */
|
2007-02-12 00:45:56 +00:00
|
|
|
if (pack_edges) {
|
|
|
|
fprintf(pack_edges, "%s:", new_p->pack_name);
|
|
|
|
for (i = 0; i < branch_table_sz; i++) {
|
|
|
|
for (b = branch_table[i]; b; b = b->table_next_branch) {
|
|
|
|
if (b->pack_id == pack_id)
|
|
|
|
fprintf(pack_edges, " %s", sha1_to_hex(b->sha1));
|
|
|
|
}
|
2007-01-16 21:18:44 +00:00
|
|
|
}
|
2007-02-12 00:45:56 +00:00
|
|
|
for (t = first_tag; t; t = t->next_tag) {
|
|
|
|
if (t->pack_id == pack_id)
|
|
|
|
fprintf(pack_edges, " %s", sha1_to_hex(t->sha1));
|
|
|
|
}
|
|
|
|
fputc('\n', pack_edges);
|
|
|
|
fflush(pack_edges);
|
2007-01-16 21:18:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pack_id++;
|
2007-01-15 11:39:39 +00:00
|
|
|
}
|
2007-01-16 06:17:47 +00:00
|
|
|
else
|
2007-01-15 11:39:39 +00:00
|
|
|
unlink(old_p->pack_name);
|
2007-01-15 11:35:41 +00:00
|
|
|
free(old_p);
|
|
|
|
|
|
|
|
/* We can't carry a delta across packfiles. */
|
2007-09-17 12:00:38 +00:00
|
|
|
strbuf_release(&last_blob.data);
|
2007-01-15 11:35:41 +00:00
|
|
|
last_blob.offset = 0;
|
|
|
|
last_blob.depth = 0;
|
2007-01-15 09:39:05 +00:00
|
|
|
}
|
|
|
|
|
2007-02-07 07:42:44 +00:00
|
|
|
static void cycle_packfile(void)
|
2007-01-15 13:00:49 +00:00
|
|
|
{
|
|
|
|
end_packfile();
|
|
|
|
start_packfile();
|
|
|
|
}
|
|
|
|
|
2006-08-15 00:16:28 +00:00
|
|
|
static size_t encode_header(
|
2006-08-08 04:46:13 +00:00
|
|
|
enum object_type type,
|
2006-08-15 00:16:28 +00:00
|
|
|
size_t size,
|
2006-08-08 04:46:13 +00:00
|
|
|
unsigned char *hdr)
|
2006-08-05 06:04:21 +00:00
|
|
|
{
|
|
|
|
int n = 1;
|
|
|
|
unsigned char c;
|
|
|
|
|
2007-01-14 07:44:18 +00:00
|
|
|
if (type < OBJ_COMMIT || type > OBJ_REF_DELTA)
|
2006-08-05 06:04:21 +00:00
|
|
|
die("bad type %d", type);
|
|
|
|
|
|
|
|
c = (type << 4) | (size & 15);
|
|
|
|
size >>= 4;
|
|
|
|
while (size) {
|
|
|
|
*hdr++ = c | 0x80;
|
|
|
|
c = size & 0x7f;
|
|
|
|
size >>= 7;
|
|
|
|
n++;
|
|
|
|
}
|
|
|
|
*hdr = c;
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2006-08-08 04:46:13 +00:00
|
|
|
static int store_object(
|
|
|
|
enum object_type type,
|
2007-09-17 11:48:17 +00:00
|
|
|
struct strbuf *dat,
|
2006-08-08 07:36:45 +00:00
|
|
|
struct last_object *last,
|
2006-08-23 08:17:45 +00:00
|
|
|
unsigned char *sha1out,
|
2007-01-16 05:33:19 +00:00
|
|
|
uintmax_t mark)
|
2006-08-05 06:04:21 +00:00
|
|
|
{
|
|
|
|
void *out, *delta;
|
2006-08-08 04:46:13 +00:00
|
|
|
struct object_entry *e;
|
|
|
|
unsigned char hdr[96];
|
|
|
|
unsigned char sha1[20];
|
2006-08-05 06:04:21 +00:00
|
|
|
unsigned long hdrlen, deltalen;
|
2006-08-08 04:46:13 +00:00
|
|
|
SHA_CTX c;
|
|
|
|
z_stream s;
|
|
|
|
|
2007-02-26 19:55:58 +00:00
|
|
|
hdrlen = sprintf((char*)hdr,"%s %lu", typename(type),
|
2007-09-17 11:48:17 +00:00
|
|
|
(unsigned long)dat->len) + 1;
|
2006-08-08 04:46:13 +00:00
|
|
|
SHA1_Init(&c);
|
|
|
|
SHA1_Update(&c, hdr, hdrlen);
|
2007-09-17 11:48:17 +00:00
|
|
|
SHA1_Update(&c, dat->buf, dat->len);
|
2006-08-08 04:46:13 +00:00
|
|
|
SHA1_Final(sha1, &c);
|
2006-08-08 07:36:45 +00:00
|
|
|
if (sha1out)
|
2006-08-28 14:46:58 +00:00
|
|
|
hashcpy(sha1out, sha1);
|
2006-08-08 04:46:13 +00:00
|
|
|
|
|
|
|
e = insert_object(sha1);
|
2006-08-23 08:17:45 +00:00
|
|
|
if (mark)
|
|
|
|
insert_mark(mark, e);
|
2006-08-08 04:46:13 +00:00
|
|
|
if (e->offset) {
|
2006-08-08 05:14:21 +00:00
|
|
|
duplicate_count_by_type[type]++;
|
2006-08-14 04:58:19 +00:00
|
|
|
return 1;
|
2007-04-20 15:23:45 +00:00
|
|
|
} else if (find_sha1_pack(sha1, packed_git)) {
|
|
|
|
e->type = type;
|
|
|
|
e->pack_id = MAX_PACK_ID;
|
|
|
|
e->offset = 1; /* just not zero! */
|
|
|
|
duplicate_count_by_type[type]++;
|
|
|
|
return 1;
|
2006-08-08 04:46:13 +00:00
|
|
|
}
|
2006-08-05 06:04:21 +00:00
|
|
|
|
2007-09-17 12:00:38 +00:00
|
|
|
if (last && last->data.buf && last->depth < max_depth) {
|
|
|
|
delta = diff_delta(last->data.buf, last->data.len,
|
2007-09-17 11:48:17 +00:00
|
|
|
dat->buf, dat->len,
|
2006-08-05 06:04:21 +00:00
|
|
|
&deltalen, 0);
|
2007-09-17 11:48:17 +00:00
|
|
|
if (delta && deltalen >= dat->len) {
|
2007-01-15 13:00:49 +00:00
|
|
|
free(delta);
|
|
|
|
delta = NULL;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
delta = NULL;
|
2006-08-05 06:04:21 +00:00
|
|
|
|
|
|
|
memset(&s, 0, sizeof(s));
|
|
|
|
deflateInit(&s, zlib_compression_level);
|
2007-01-15 13:00:49 +00:00
|
|
|
if (delta) {
|
|
|
|
s.next_in = delta;
|
|
|
|
s.avail_in = deltalen;
|
|
|
|
} else {
|
2007-09-17 11:48:17 +00:00
|
|
|
s.next_in = (void *)dat->buf;
|
|
|
|
s.avail_in = dat->len;
|
2007-01-15 13:00:49 +00:00
|
|
|
}
|
|
|
|
s.avail_out = deflateBound(&s, s.avail_in);
|
|
|
|
s.next_out = out = xmalloc(s.avail_out);
|
|
|
|
while (deflate(&s, Z_FINISH) == Z_OK)
|
|
|
|
/* nothing */;
|
|
|
|
deflateEnd(&s);
|
|
|
|
|
|
|
|
/* Determine if we should auto-checkpoint. */
|
2007-01-18 17:00:49 +00:00
|
|
|
if ((pack_size + 60 + s.total_out) > max_packsize
|
2007-01-15 13:00:49 +00:00
|
|
|
|| (pack_size + 60 + s.total_out) < pack_size) {
|
|
|
|
|
|
|
|
/* This new object needs to *not* have the current pack_id. */
|
|
|
|
e->pack_id = pack_id + 1;
|
2007-02-07 07:42:44 +00:00
|
|
|
cycle_packfile();
|
2007-01-15 13:00:49 +00:00
|
|
|
|
|
|
|
/* We cannot carry a delta into the new pack. */
|
|
|
|
if (delta) {
|
|
|
|
free(delta);
|
|
|
|
delta = NULL;
|
2007-01-16 04:40:27 +00:00
|
|
|
|
|
|
|
memset(&s, 0, sizeof(s));
|
|
|
|
deflateInit(&s, zlib_compression_level);
|
2007-09-17 11:48:17 +00:00
|
|
|
s.next_in = (void *)dat->buf;
|
|
|
|
s.avail_in = dat->len;
|
2007-01-16 04:40:27 +00:00
|
|
|
s.avail_out = deflateBound(&s, s.avail_in);
|
|
|
|
s.next_out = out = xrealloc(out, s.avail_out);
|
|
|
|
while (deflate(&s, Z_FINISH) == Z_OK)
|
|
|
|
/* nothing */;
|
|
|
|
deflateEnd(&s);
|
2007-01-15 13:00:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
e->type = type;
|
|
|
|
e->pack_id = pack_id;
|
|
|
|
e->offset = pack_size;
|
|
|
|
object_count++;
|
|
|
|
object_count_by_type[type]++;
|
2006-08-05 06:04:21 +00:00
|
|
|
|
|
|
|
if (delta) {
|
2007-01-14 11:20:23 +00:00
|
|
|
unsigned long ofs = e->offset - last->offset;
|
|
|
|
unsigned pos = sizeof(hdr) - 1;
|
|
|
|
|
2006-08-28 16:22:50 +00:00
|
|
|
delta_count_by_type[type]++;
|
2007-11-14 04:48:42 +00:00
|
|
|
e->depth = last->depth + 1;
|
2007-01-14 11:20:23 +00:00
|
|
|
|
|
|
|
hdrlen = encode_header(OBJ_OFS_DELTA, deltalen, hdr);
|
2007-01-16 06:20:57 +00:00
|
|
|
write_or_die(pack_data->pack_fd, hdr, hdrlen);
|
2007-01-14 11:20:23 +00:00
|
|
|
pack_size += hdrlen;
|
|
|
|
|
|
|
|
hdr[pos] = ofs & 127;
|
|
|
|
while (ofs >>= 7)
|
|
|
|
hdr[--pos] = 128 | (--ofs & 127);
|
2007-01-16 06:20:57 +00:00
|
|
|
write_or_die(pack_data->pack_fd, hdr + pos, sizeof(hdr) - pos);
|
2007-01-14 11:20:23 +00:00
|
|
|
pack_size += sizeof(hdr) - pos;
|
2006-08-05 06:04:21 +00:00
|
|
|
} else {
|
2007-11-14 04:48:42 +00:00
|
|
|
e->depth = 0;
|
2007-09-17 11:48:17 +00:00
|
|
|
hdrlen = encode_header(type, dat->len, hdr);
|
2007-01-16 06:20:57 +00:00
|
|
|
write_or_die(pack_data->pack_fd, hdr, hdrlen);
|
2006-08-24 08:37:35 +00:00
|
|
|
pack_size += hdrlen;
|
2006-08-05 06:04:21 +00:00
|
|
|
}
|
|
|
|
|
2007-01-16 06:20:57 +00:00
|
|
|
write_or_die(pack_data->pack_fd, out, s.total_out);
|
2006-08-24 08:37:35 +00:00
|
|
|
pack_size += s.total_out;
|
2006-08-05 06:04:21 +00:00
|
|
|
|
|
|
|
free(out);
|
2007-02-06 17:05:51 +00:00
|
|
|
free(delta);
|
2006-08-14 04:58:19 +00:00
|
|
|
if (last) {
|
2007-09-17 12:00:38 +00:00
|
|
|
if (last->no_swap) {
|
|
|
|
last->data = *dat;
|
|
|
|
} else {
|
2007-09-19 22:42:12 +00:00
|
|
|
strbuf_swap(&last->data, dat);
|
2007-09-17 12:00:38 +00:00
|
|
|
}
|
2007-01-14 11:20:23 +00:00
|
|
|
last->offset = e->offset;
|
2007-11-14 04:48:42 +00:00
|
|
|
last->depth = e->depth;
|
2006-08-14 04:58:19 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-01-15 11:35:41 +00:00
|
|
|
static void *gfi_unpack_entry(
|
|
|
|
struct object_entry *oe,
|
|
|
|
unsigned long *sizep)
|
2006-08-24 08:37:35 +00:00
|
|
|
{
|
2007-02-26 19:55:59 +00:00
|
|
|
enum object_type type;
|
2007-01-15 11:35:41 +00:00
|
|
|
struct packed_git *p = all_packs[oe->pack_id];
|
|
|
|
if (p == pack_data)
|
|
|
|
p->pack_size = pack_size + 20;
|
2007-02-26 19:55:59 +00:00
|
|
|
return unpack_entry(p, oe->offset, &type, sizep);
|
2006-08-24 08:37:35 +00:00
|
|
|
}
|
|
|
|
|
2007-02-05 21:34:56 +00:00
|
|
|
static const char *get_mode(const char *str, uint16_t *modep)
|
2006-08-14 04:58:19 +00:00
|
|
|
{
|
|
|
|
unsigned char c;
|
2007-02-05 21:34:56 +00:00
|
|
|
uint16_t mode = 0;
|
2006-08-14 04:58:19 +00:00
|
|
|
|
|
|
|
while ((c = *str++) != ' ') {
|
|
|
|
if (c < '0' || c > '7')
|
|
|
|
return NULL;
|
|
|
|
mode = (mode << 3) + (c - '0');
|
|
|
|
}
|
|
|
|
*modep = mode;
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void load_tree(struct tree_entry *root)
|
|
|
|
{
|
2006-08-28 16:22:50 +00:00
|
|
|
unsigned char* sha1 = root->versions[1].sha1;
|
2006-08-14 04:58:19 +00:00
|
|
|
struct object_entry *myoe;
|
|
|
|
struct tree_content *t;
|
|
|
|
unsigned long size;
|
|
|
|
char *buf;
|
|
|
|
const char *c;
|
|
|
|
|
|
|
|
root->tree = t = new_tree_content(8);
|
2006-08-28 16:22:50 +00:00
|
|
|
if (is_null_sha1(sha1))
|
2006-08-14 04:58:19 +00:00
|
|
|
return;
|
|
|
|
|
2006-08-28 16:22:50 +00:00
|
|
|
myoe = find_object(sha1);
|
2007-05-23 21:01:49 +00:00
|
|
|
if (myoe && myoe->pack_id != MAX_PACK_ID) {
|
2006-08-24 08:37:35 +00:00
|
|
|
if (myoe->type != OBJ_TREE)
|
2006-08-28 16:22:50 +00:00
|
|
|
die("Not a tree: %s", sha1_to_hex(sha1));
|
2007-11-14 04:48:42 +00:00
|
|
|
t->delta_depth = myoe->depth;
|
2007-01-15 11:35:41 +00:00
|
|
|
buf = gfi_unpack_entry(myoe, &size);
|
2006-08-14 04:58:19 +00:00
|
|
|
} else {
|
2007-02-26 19:55:59 +00:00
|
|
|
enum object_type type;
|
|
|
|
buf = read_sha1_file(sha1, &type, &size);
|
|
|
|
if (!buf || type != OBJ_TREE)
|
2006-08-28 16:22:50 +00:00
|
|
|
die("Can't load tree %s", sha1_to_hex(sha1));
|
2006-08-14 04:58:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
c = buf;
|
|
|
|
while (c != (buf + size)) {
|
|
|
|
struct tree_entry *e = new_tree_entry();
|
|
|
|
|
|
|
|
if (t->entry_count == t->entry_capacity)
|
2007-03-11 02:39:17 +00:00
|
|
|
root->tree = t = grow_tree_content(t, t->entry_count);
|
2006-08-14 04:58:19 +00:00
|
|
|
t->entries[t->entry_count++] = e;
|
|
|
|
|
|
|
|
e->tree = NULL;
|
2006-08-28 16:22:50 +00:00
|
|
|
c = get_mode(c, &e->versions[1].mode);
|
2006-08-14 04:58:19 +00:00
|
|
|
if (!c)
|
2006-08-28 16:22:50 +00:00
|
|
|
die("Corrupt mode in %s", sha1_to_hex(sha1));
|
|
|
|
e->versions[0].mode = e->versions[1].mode;
|
2007-03-12 19:48:37 +00:00
|
|
|
e->name = to_atom(c, strlen(c));
|
2006-08-14 04:58:19 +00:00
|
|
|
c += e->name->str_len + 1;
|
2006-08-28 16:22:50 +00:00
|
|
|
hashcpy(e->versions[0].sha1, (unsigned char*)c);
|
|
|
|
hashcpy(e->versions[1].sha1, (unsigned char*)c);
|
2006-08-14 04:58:19 +00:00
|
|
|
c += 20;
|
|
|
|
}
|
|
|
|
free(buf);
|
|
|
|
}
|
|
|
|
|
2006-08-28 16:22:50 +00:00
|
|
|
static int tecmp0 (const void *_a, const void *_b)
|
2006-08-14 04:58:19 +00:00
|
|
|
{
|
|
|
|
struct tree_entry *a = *((struct tree_entry**)_a);
|
|
|
|
struct tree_entry *b = *((struct tree_entry**)_b);
|
|
|
|
return base_name_compare(
|
2006-08-28 16:22:50 +00:00
|
|
|
a->name->str_dat, a->name->str_len, a->versions[0].mode,
|
|
|
|
b->name->str_dat, b->name->str_len, b->versions[0].mode);
|
2006-08-14 04:58:19 +00:00
|
|
|
}
|
|
|
|
|
2006-08-28 16:22:50 +00:00
|
|
|
static int tecmp1 (const void *_a, const void *_b)
|
2006-08-14 04:58:19 +00:00
|
|
|
{
|
2006-08-28 16:22:50 +00:00
|
|
|
struct tree_entry *a = *((struct tree_entry**)_a);
|
|
|
|
struct tree_entry *b = *((struct tree_entry**)_b);
|
|
|
|
return base_name_compare(
|
|
|
|
a->name->str_dat, a->name->str_len, a->versions[1].mode,
|
|
|
|
b->name->str_dat, b->name->str_len, b->versions[1].mode);
|
|
|
|
}
|
|
|
|
|
2007-09-17 11:48:17 +00:00
|
|
|
static void mktree(struct tree_content *t, int v, struct strbuf *b)
|
2006-08-28 16:22:50 +00:00
|
|
|
{
|
|
|
|
size_t maxlen = 0;
|
2006-08-14 04:58:19 +00:00
|
|
|
unsigned int i;
|
|
|
|
|
2006-08-28 16:22:50 +00:00
|
|
|
if (!v)
|
|
|
|
qsort(t->entries,t->entry_count,sizeof(t->entries[0]),tecmp0);
|
|
|
|
else
|
|
|
|
qsort(t->entries,t->entry_count,sizeof(t->entries[0]),tecmp1);
|
2006-08-14 04:58:19 +00:00
|
|
|
|
|
|
|
for (i = 0; i < t->entry_count; i++) {
|
2006-08-28 16:22:50 +00:00
|
|
|
if (t->entries[i]->versions[v].mode)
|
|
|
|
maxlen += t->entries[i]->name->str_len + 34;
|
2006-08-14 04:58:19 +00:00
|
|
|
}
|
|
|
|
|
2007-09-17 11:48:17 +00:00
|
|
|
strbuf_reset(b);
|
|
|
|
strbuf_grow(b, maxlen);
|
2006-08-14 04:58:19 +00:00
|
|
|
for (i = 0; i < t->entry_count; i++) {
|
|
|
|
struct tree_entry *e = t->entries[i];
|
2006-08-28 16:22:50 +00:00
|
|
|
if (!e->versions[v].mode)
|
|
|
|
continue;
|
2007-09-17 11:48:17 +00:00
|
|
|
strbuf_addf(b, "%o %s%c", (unsigned int)e->versions[v].mode,
|
|
|
|
e->name->str_dat, '\0');
|
|
|
|
strbuf_add(b, e->versions[v].sha1, 20);
|
2006-08-14 04:58:19 +00:00
|
|
|
}
|
2006-08-28 16:22:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void store_tree(struct tree_entry *root)
|
|
|
|
{
|
|
|
|
struct tree_content *t = root->tree;
|
|
|
|
unsigned int i, j, del;
|
2007-09-17 12:00:38 +00:00
|
|
|
struct last_object lo = { STRBUF_INIT, 0, 0, /* no_swap */ 1 };
|
2007-01-14 11:20:23 +00:00
|
|
|
struct object_entry *le;
|
2006-08-28 16:22:50 +00:00
|
|
|
|
|
|
|
if (!is_null_sha1(root->versions[1].sha1))
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < t->entry_count; i++) {
|
|
|
|
if (t->entries[i]->tree)
|
|
|
|
store_tree(t->entries[i]);
|
|
|
|
}
|
|
|
|
|
2007-01-14 11:20:23 +00:00
|
|
|
le = find_object(root->versions[0].sha1);
|
2007-09-17 12:00:38 +00:00
|
|
|
if (S_ISDIR(root->versions[0].mode) && le && le->pack_id == pack_id) {
|
2007-09-17 11:48:17 +00:00
|
|
|
mktree(t, 0, &old_tree);
|
2007-09-17 12:00:38 +00:00
|
|
|
lo.data = old_tree;
|
2007-01-14 11:20:23 +00:00
|
|
|
lo.offset = le->offset;
|
2006-08-28 16:22:50 +00:00
|
|
|
lo.depth = t->delta_depth;
|
|
|
|
}
|
|
|
|
|
2007-09-17 11:48:17 +00:00
|
|
|
mktree(t, 1, &new_tree);
|
|
|
|
store_object(OBJ_TREE, &new_tree, &lo, root->versions[1].sha1, 0);
|
2006-08-28 16:22:50 +00:00
|
|
|
|
|
|
|
t->delta_depth = lo.depth;
|
|
|
|
for (i = 0, j = 0, del = 0; i < t->entry_count; i++) {
|
|
|
|
struct tree_entry *e = t->entries[i];
|
|
|
|
if (e->versions[1].mode) {
|
|
|
|
e->versions[0].mode = e->versions[1].mode;
|
|
|
|
hashcpy(e->versions[0].sha1, e->versions[1].sha1);
|
|
|
|
t->entries[j++] = e;
|
|
|
|
} else {
|
|
|
|
release_tree_entry(e);
|
|
|
|
del++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
t->entry_count -= del;
|
2006-08-14 04:58:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int tree_content_set(
|
|
|
|
struct tree_entry *root,
|
|
|
|
const char *p,
|
|
|
|
const unsigned char *sha1,
|
2007-07-10 02:58:23 +00:00
|
|
|
const uint16_t mode,
|
|
|
|
struct tree_content *subtree)
|
2006-08-14 04:58:19 +00:00
|
|
|
{
|
|
|
|
struct tree_content *t = root->tree;
|
|
|
|
const char *slash1;
|
|
|
|
unsigned int i, n;
|
|
|
|
struct tree_entry *e;
|
|
|
|
|
|
|
|
slash1 = strchr(p, '/');
|
|
|
|
if (slash1)
|
|
|
|
n = slash1 - p;
|
|
|
|
else
|
|
|
|
n = strlen(p);
|
2007-04-29 00:01:27 +00:00
|
|
|
if (!n)
|
|
|
|
die("Empty path component found in input");
|
2007-07-10 02:58:23 +00:00
|
|
|
if (!slash1 && !S_ISDIR(mode) && subtree)
|
|
|
|
die("Non-directories cannot have subtrees");
|
2006-08-14 04:58:19 +00:00
|
|
|
|
|
|
|
for (i = 0; i < t->entry_count; i++) {
|
|
|
|
e = t->entries[i];
|
|
|
|
if (e->name->str_len == n && !strncmp(p, e->name->str_dat, n)) {
|
|
|
|
if (!slash1) {
|
2007-07-10 02:58:23 +00:00
|
|
|
if (!S_ISDIR(mode)
|
|
|
|
&& e->versions[1].mode == mode
|
2006-08-28 16:22:50 +00:00
|
|
|
&& !hashcmp(e->versions[1].sha1, sha1))
|
2006-08-14 04:58:19 +00:00
|
|
|
return 0;
|
2006-08-28 16:22:50 +00:00
|
|
|
e->versions[1].mode = mode;
|
|
|
|
hashcpy(e->versions[1].sha1, sha1);
|
2007-07-10 02:58:23 +00:00
|
|
|
if (e->tree)
|
2006-08-23 05:33:47 +00:00
|
|
|
release_tree_content_recursive(e->tree);
|
2007-07-10 02:58:23 +00:00
|
|
|
e->tree = subtree;
|
2006-08-28 16:22:50 +00:00
|
|
|
hashclr(root->versions[1].sha1);
|
2006-08-14 04:58:19 +00:00
|
|
|
return 1;
|
|
|
|
}
|
2006-08-28 16:22:50 +00:00
|
|
|
if (!S_ISDIR(e->versions[1].mode)) {
|
2006-08-14 04:58:19 +00:00
|
|
|
e->tree = new_tree_content(8);
|
2006-08-28 16:22:50 +00:00
|
|
|
e->versions[1].mode = S_IFDIR;
|
2006-08-14 04:58:19 +00:00
|
|
|
}
|
|
|
|
if (!e->tree)
|
|
|
|
load_tree(e);
|
2007-07-10 02:58:23 +00:00
|
|
|
if (tree_content_set(e, slash1 + 1, sha1, mode, subtree)) {
|
2006-08-28 16:22:50 +00:00
|
|
|
hashclr(root->versions[1].sha1);
|
2006-08-14 04:58:19 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (t->entry_count == t->entry_capacity)
|
2007-03-11 02:39:17 +00:00
|
|
|
root->tree = t = grow_tree_content(t, t->entry_count);
|
2006-08-14 04:58:19 +00:00
|
|
|
e = new_tree_entry();
|
2007-03-12 19:48:37 +00:00
|
|
|
e->name = to_atom(p, n);
|
2006-08-28 16:22:50 +00:00
|
|
|
e->versions[0].mode = 0;
|
|
|
|
hashclr(e->versions[0].sha1);
|
2006-08-14 04:58:19 +00:00
|
|
|
t->entries[t->entry_count++] = e;
|
|
|
|
if (slash1) {
|
|
|
|
e->tree = new_tree_content(8);
|
2006-08-28 16:22:50 +00:00
|
|
|
e->versions[1].mode = S_IFDIR;
|
2007-07-10 02:58:23 +00:00
|
|
|
tree_content_set(e, slash1 + 1, sha1, mode, subtree);
|
2006-08-14 04:58:19 +00:00
|
|
|
} else {
|
2007-07-10 02:58:23 +00:00
|
|
|
e->tree = subtree;
|
2006-08-28 16:22:50 +00:00
|
|
|
e->versions[1].mode = mode;
|
|
|
|
hashcpy(e->versions[1].sha1, sha1);
|
2006-08-14 04:58:19 +00:00
|
|
|
}
|
2006-08-28 16:22:50 +00:00
|
|
|
hashclr(root->versions[1].sha1);
|
2006-08-14 04:58:19 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-07-10 02:58:23 +00:00
|
|
|
static int tree_content_remove(
|
|
|
|
struct tree_entry *root,
|
|
|
|
const char *p,
|
|
|
|
struct tree_entry *backup_leaf)
|
2006-08-14 04:58:19 +00:00
|
|
|
{
|
|
|
|
struct tree_content *t = root->tree;
|
|
|
|
const char *slash1;
|
|
|
|
unsigned int i, n;
|
|
|
|
struct tree_entry *e;
|
|
|
|
|
|
|
|
slash1 = strchr(p, '/');
|
|
|
|
if (slash1)
|
|
|
|
n = slash1 - p;
|
|
|
|
else
|
|
|
|
n = strlen(p);
|
|
|
|
|
|
|
|
for (i = 0; i < t->entry_count; i++) {
|
|
|
|
e = t->entries[i];
|
|
|
|
if (e->name->str_len == n && !strncmp(p, e->name->str_dat, n)) {
|
2006-08-28 16:22:50 +00:00
|
|
|
if (!slash1 || !S_ISDIR(e->versions[1].mode))
|
2006-08-14 04:58:19 +00:00
|
|
|
goto del_entry;
|
|
|
|
if (!e->tree)
|
|
|
|
load_tree(e);
|
2007-07-10 02:58:23 +00:00
|
|
|
if (tree_content_remove(e, slash1 + 1, backup_leaf)) {
|
2006-08-29 01:43:04 +00:00
|
|
|
for (n = 0; n < e->tree->entry_count; n++) {
|
|
|
|
if (e->tree->entries[n]->versions[1].mode) {
|
|
|
|
hashclr(root->versions[1].sha1);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
2007-07-10 02:58:23 +00:00
|
|
|
backup_leaf = NULL;
|
2006-08-29 01:43:04 +00:00
|
|
|
goto del_entry;
|
2006-08-14 04:58:19 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
del_entry:
|
2007-07-10 02:58:23 +00:00
|
|
|
if (backup_leaf)
|
|
|
|
memcpy(backup_leaf, e, sizeof(*backup_leaf));
|
|
|
|
else if (e->tree)
|
2006-08-28 16:22:50 +00:00
|
|
|
release_tree_content_recursive(e->tree);
|
2007-07-10 02:58:23 +00:00
|
|
|
e->tree = NULL;
|
2006-08-28 16:22:50 +00:00
|
|
|
e->versions[1].mode = 0;
|
|
|
|
hashclr(e->versions[1].sha1);
|
|
|
|
hashclr(root->versions[1].sha1);
|
2006-08-08 04:46:13 +00:00
|
|
|
return 1;
|
2006-08-05 06:04:21 +00:00
|
|
|
}
|
|
|
|
|
2007-07-15 05:40:37 +00:00
|
|
|
static int tree_content_get(
|
|
|
|
struct tree_entry *root,
|
|
|
|
const char *p,
|
|
|
|
struct tree_entry *leaf)
|
|
|
|
{
|
|
|
|
struct tree_content *t = root->tree;
|
|
|
|
const char *slash1;
|
|
|
|
unsigned int i, n;
|
|
|
|
struct tree_entry *e;
|
|
|
|
|
|
|
|
slash1 = strchr(p, '/');
|
|
|
|
if (slash1)
|
|
|
|
n = slash1 - p;
|
|
|
|
else
|
|
|
|
n = strlen(p);
|
|
|
|
|
|
|
|
for (i = 0; i < t->entry_count; i++) {
|
|
|
|
e = t->entries[i];
|
|
|
|
if (e->name->str_len == n && !strncmp(p, e->name->str_dat, n)) {
|
|
|
|
if (!slash1) {
|
|
|
|
memcpy(leaf, e, sizeof(*leaf));
|
|
|
|
if (e->tree && is_null_sha1(e->versions[1].sha1))
|
|
|
|
leaf->tree = dup_tree_content(e->tree);
|
|
|
|
else
|
|
|
|
leaf->tree = NULL;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (!S_ISDIR(e->versions[1].mode))
|
|
|
|
return 0;
|
|
|
|
if (!e->tree)
|
|
|
|
load_tree(e);
|
|
|
|
return tree_content_get(e, slash1 + 1, leaf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-02-06 21:08:06 +00:00
|
|
|
static int update_branch(struct branch *b)
|
2006-08-14 04:58:19 +00:00
|
|
|
{
|
|
|
|
static const char *msg = "fast-import";
|
2007-02-06 21:08:06 +00:00
|
|
|
struct ref_lock *lock;
|
|
|
|
unsigned char old_sha1[20];
|
|
|
|
|
|
|
|
if (read_ref(b->name, old_sha1))
|
|
|
|
hashclr(old_sha1);
|
2007-05-09 10:33:20 +00:00
|
|
|
lock = lock_any_ref_for_update(b->name, old_sha1, 0);
|
2007-02-06 21:08:06 +00:00
|
|
|
if (!lock)
|
|
|
|
return error("Unable to lock %s", b->name);
|
|
|
|
if (!force_update && !is_null_sha1(old_sha1)) {
|
|
|
|
struct commit *old_cmit, *new_cmit;
|
|
|
|
|
|
|
|
old_cmit = lookup_commit_reference_gently(old_sha1, 0);
|
|
|
|
new_cmit = lookup_commit_reference_gently(b->sha1, 0);
|
|
|
|
if (!old_cmit || !new_cmit) {
|
|
|
|
unlock_ref(lock);
|
|
|
|
return error("Branch %s is missing commits.", b->name);
|
|
|
|
}
|
|
|
|
|
2007-02-14 00:50:32 +00:00
|
|
|
if (!in_merge_bases(old_cmit, &new_cmit, 1)) {
|
2007-02-06 21:08:06 +00:00
|
|
|
unlock_ref(lock);
|
2007-03-30 23:07:05 +00:00
|
|
|
warning("Not updating %s"
|
2007-02-06 21:08:06 +00:00
|
|
|
" (new tip %s does not contain %s)",
|
|
|
|
b->name, sha1_to_hex(b->sha1), sha1_to_hex(old_sha1));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (write_ref_sha1(lock, b->sha1, msg) < 0)
|
|
|
|
return error("Unable to update %s", b->name);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dump_branches(void)
|
|
|
|
{
|
2006-08-14 04:58:19 +00:00
|
|
|
unsigned int i;
|
|
|
|
struct branch *b;
|
|
|
|
|
|
|
|
for (i = 0; i < branch_table_sz; i++) {
|
2007-02-06 21:08:06 +00:00
|
|
|
for (b = branch_table[i]; b; b = b->table_next_branch)
|
|
|
|
failure |= update_branch(b);
|
2006-08-14 04:58:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-01-17 06:47:25 +00:00
|
|
|
static void dump_tags(void)
|
2006-08-24 07:12:13 +00:00
|
|
|
{
|
|
|
|
static const char *msg = "fast-import";
|
|
|
|
struct tag *t;
|
|
|
|
struct ref_lock *lock;
|
2007-02-06 21:08:06 +00:00
|
|
|
char ref_name[PATH_MAX];
|
2006-08-24 07:12:13 +00:00
|
|
|
|
|
|
|
for (t = first_tag; t; t = t->next_tag) {
|
2007-02-06 21:08:06 +00:00
|
|
|
sprintf(ref_name, "tags/%s", t->name);
|
|
|
|
lock = lock_ref_sha1(ref_name, NULL);
|
2006-08-24 07:12:13 +00:00
|
|
|
if (!lock || write_ref_sha1(lock, t->sha1, msg) < 0)
|
2007-02-06 21:08:06 +00:00
|
|
|
failure |= error("Unable to update %s", ref_name);
|
2006-08-24 07:12:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-08-25 20:03:04 +00:00
|
|
|
static void dump_marks_helper(FILE *f,
|
2007-01-16 05:33:19 +00:00
|
|
|
uintmax_t base,
|
2006-08-25 20:03:04 +00:00
|
|
|
struct mark_set *m)
|
|
|
|
{
|
2007-01-16 05:33:19 +00:00
|
|
|
uintmax_t k;
|
2006-08-25 20:03:04 +00:00
|
|
|
if (m->shift) {
|
|
|
|
for (k = 0; k < 1024; k++) {
|
|
|
|
if (m->data.sets[k])
|
|
|
|
dump_marks_helper(f, (base + k) << m->shift,
|
|
|
|
m->data.sets[k]);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (k = 0; k < 1024; k++) {
|
|
|
|
if (m->data.marked[k])
|
2007-02-21 01:34:56 +00:00
|
|
|
fprintf(f, ":%" PRIuMAX " %s\n", base + k,
|
2006-08-25 20:03:04 +00:00
|
|
|
sha1_to_hex(m->data.marked[k]->sha1));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-01-17 06:47:25 +00:00
|
|
|
static void dump_marks(void)
|
2006-08-25 20:03:04 +00:00
|
|
|
{
|
2007-03-07 23:05:38 +00:00
|
|
|
static struct lock_file mark_lock;
|
|
|
|
int mark_fd;
|
|
|
|
FILE *f;
|
|
|
|
|
|
|
|
if (!mark_file)
|
|
|
|
return;
|
|
|
|
|
|
|
|
mark_fd = hold_lock_file_for_update(&mark_lock, mark_file, 0);
|
|
|
|
if (mark_fd < 0) {
|
|
|
|
failure |= error("Unable to write marks file %s: %s",
|
|
|
|
mark_file, strerror(errno));
|
|
|
|
return;
|
2006-08-25 20:03:04 +00:00
|
|
|
}
|
2007-03-07 23:05:38 +00:00
|
|
|
|
|
|
|
f = fdopen(mark_fd, "w");
|
|
|
|
if (!f) {
|
|
|
|
rollback_lock_file(&mark_lock);
|
|
|
|
failure |= error("Unable to write marks file %s: %s",
|
|
|
|
mark_file, strerror(errno));
|
|
|
|
return;
|
2006-08-25 20:03:04 +00:00
|
|
|
}
|
2007-03-07 23:05:38 +00:00
|
|
|
|
|
|
|
dump_marks_helper(f, 0, marks);
|
|
|
|
fclose(f);
|
|
|
|
if (commit_lock_file(&mark_lock))
|
|
|
|
failure |= error("Unable to write marks file %s: %s",
|
|
|
|
mark_file, strerror(errno));
|
2006-08-25 20:03:04 +00:00
|
|
|
}
|
|
|
|
|
2007-09-17 09:19:04 +00:00
|
|
|
static int read_next_command(void)
|
2006-08-15 00:16:28 +00:00
|
|
|
{
|
2007-09-17 09:19:04 +00:00
|
|
|
static int stdin_eof = 0;
|
|
|
|
|
|
|
|
if (stdin_eof) {
|
|
|
|
unread_command_buf = 0;
|
|
|
|
return EOF;
|
|
|
|
}
|
|
|
|
|
2007-08-01 04:05:15 +00:00
|
|
|
do {
|
2007-08-03 08:47:04 +00:00
|
|
|
if (unread_command_buf) {
|
2007-08-01 06:22:53 +00:00
|
|
|
unread_command_buf = 0;
|
2007-08-03 08:47:04 +00:00
|
|
|
} else {
|
|
|
|
struct recent_command *rc;
|
|
|
|
|
2007-09-27 10:58:23 +00:00
|
|
|
strbuf_detach(&command_buf, NULL);
|
2007-09-17 09:19:04 +00:00
|
|
|
stdin_eof = strbuf_getline(&command_buf, stdin, '\n');
|
|
|
|
if (stdin_eof)
|
|
|
|
return EOF;
|
2007-08-03 08:47:04 +00:00
|
|
|
|
|
|
|
rc = rc_free;
|
|
|
|
if (rc)
|
|
|
|
rc_free = rc->next;
|
|
|
|
else {
|
|
|
|
rc = cmd_hist.next;
|
|
|
|
cmd_hist.next = rc->next;
|
|
|
|
cmd_hist.next->prev = &cmd_hist;
|
|
|
|
free(rc->buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
rc->buf = command_buf.buf;
|
|
|
|
rc->prev = cmd_tail;
|
|
|
|
rc->next = cmd_hist.prev;
|
|
|
|
rc->prev->next = rc;
|
|
|
|
cmd_tail = rc;
|
|
|
|
}
|
|
|
|
} while (command_buf.buf[0] == '#');
|
2007-09-17 09:19:04 +00:00
|
|
|
|
|
|
|
return 0;
|
2006-08-15 00:16:28 +00:00
|
|
|
}
|
|
|
|
|
2007-08-19 09:50:18 +00:00
|
|
|
static void skip_optional_lf(void)
|
2007-08-01 04:24:25 +00:00
|
|
|
{
|
|
|
|
int term_char = fgetc(stdin);
|
|
|
|
if (term_char != '\n' && term_char != EOF)
|
|
|
|
ungetc(term_char, stdin);
|
|
|
|
}
|
|
|
|
|
2007-01-17 06:47:25 +00:00
|
|
|
static void cmd_mark(void)
|
2006-08-15 00:16:28 +00:00
|
|
|
{
|
2007-02-20 09:54:00 +00:00
|
|
|
if (!prefixcmp(command_buf.buf, "mark :")) {
|
2007-01-16 05:33:19 +00:00
|
|
|
next_mark = strtoumax(command_buf.buf + 6, NULL, 10);
|
2006-08-15 00:16:28 +00:00
|
|
|
read_next_command();
|
|
|
|
}
|
|
|
|
else
|
2006-08-23 08:17:45 +00:00
|
|
|
next_mark = 0;
|
2006-08-15 00:16:28 +00:00
|
|
|
}
|
|
|
|
|
2007-09-17 11:48:17 +00:00
|
|
|
static void cmd_data(struct strbuf *sb)
|
2006-08-15 00:16:28 +00:00
|
|
|
{
|
2007-09-17 11:48:17 +00:00
|
|
|
strbuf_reset(sb);
|
2006-08-15 00:16:28 +00:00
|
|
|
|
2007-02-20 09:54:00 +00:00
|
|
|
if (prefixcmp(command_buf.buf, "data "))
|
2006-08-15 00:16:28 +00:00
|
|
|
die("Expected 'data n' command, found: %s", command_buf.buf);
|
|
|
|
|
2007-02-20 09:54:00 +00:00
|
|
|
if (!prefixcmp(command_buf.buf + 5, "<<")) {
|
2007-01-18 18:14:27 +00:00
|
|
|
char *term = xstrdup(command_buf.buf + 5 + 2);
|
2007-09-06 11:20:07 +00:00
|
|
|
size_t term_len = command_buf.len - 5 - 2;
|
|
|
|
|
2007-10-26 07:59:12 +00:00
|
|
|
strbuf_detach(&command_buf, NULL);
|
2007-01-18 18:14:27 +00:00
|
|
|
for (;;) {
|
2007-09-17 09:19:04 +00:00
|
|
|
if (strbuf_getline(&command_buf, stdin, '\n') == EOF)
|
2007-01-18 18:14:27 +00:00
|
|
|
die("EOF in data (terminator '%s' not found)", term);
|
|
|
|
if (term_len == command_buf.len
|
|
|
|
&& !strcmp(term, command_buf.buf))
|
|
|
|
break;
|
2007-09-17 11:48:17 +00:00
|
|
|
strbuf_addbuf(sb, &command_buf);
|
|
|
|
strbuf_addch(sb, '\n');
|
2007-01-18 18:14:27 +00:00
|
|
|
}
|
|
|
|
free(term);
|
|
|
|
}
|
|
|
|
else {
|
2007-09-06 11:20:07 +00:00
|
|
|
size_t n = 0, length;
|
|
|
|
|
2007-01-18 18:14:27 +00:00
|
|
|
length = strtoul(command_buf.buf + 5, NULL, 10);
|
2007-09-06 11:20:07 +00:00
|
|
|
|
2007-01-18 18:14:27 +00:00
|
|
|
while (n < length) {
|
2007-09-17 11:48:17 +00:00
|
|
|
size_t s = strbuf_fread(sb, length - n, stdin);
|
2007-01-18 18:14:27 +00:00
|
|
|
if (!s && feof(stdin))
|
2007-02-07 11:38:21 +00:00
|
|
|
die("EOF in data (%lu bytes remaining)",
|
|
|
|
(unsigned long)(length - n));
|
2007-01-18 18:14:27 +00:00
|
|
|
n += s;
|
|
|
|
}
|
2006-08-15 00:16:28 +00:00
|
|
|
}
|
|
|
|
|
2007-08-01 04:24:25 +00:00
|
|
|
skip_optional_lf();
|
2006-08-15 00:16:28 +00:00
|
|
|
}
|
|
|
|
|
2007-02-06 19:58:30 +00:00
|
|
|
static int validate_raw_date(const char *src, char *result, int maxlen)
|
|
|
|
{
|
|
|
|
const char *orig_src = src;
|
|
|
|
char *endp, sign;
|
|
|
|
|
|
|
|
strtoul(src, &endp, 10);
|
|
|
|
if (endp == src || *endp != ' ')
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
src = endp + 1;
|
|
|
|
if (*src != '-' && *src != '+')
|
|
|
|
return -1;
|
|
|
|
sign = *src;
|
|
|
|
|
|
|
|
strtoul(src + 1, &endp, 10);
|
|
|
|
if (endp == src || *endp || (endp - orig_src) >= maxlen)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
strcpy(result, orig_src);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *parse_ident(const char *buf)
|
|
|
|
{
|
|
|
|
const char *gt;
|
|
|
|
size_t name_len;
|
|
|
|
char *ident;
|
|
|
|
|
|
|
|
gt = strrchr(buf, '>');
|
|
|
|
if (!gt)
|
|
|
|
die("Missing > in ident string: %s", buf);
|
|
|
|
gt++;
|
|
|
|
if (*gt != ' ')
|
|
|
|
die("Missing space after > in ident string: %s", buf);
|
|
|
|
gt++;
|
|
|
|
name_len = gt - buf;
|
|
|
|
ident = xmalloc(name_len + 24);
|
|
|
|
strncpy(ident, buf, name_len);
|
|
|
|
|
|
|
|
switch (whenspec) {
|
|
|
|
case WHENSPEC_RAW:
|
|
|
|
if (validate_raw_date(gt, ident + name_len, 24) < 0)
|
|
|
|
die("Invalid raw date \"%s\" in ident: %s", gt, buf);
|
|
|
|
break;
|
|
|
|
case WHENSPEC_RFC2822:
|
|
|
|
if (parse_date(gt, ident + name_len, 24) < 0)
|
|
|
|
die("Invalid rfc2822 date \"%s\" in ident: %s", gt, buf);
|
|
|
|
break;
|
|
|
|
case WHENSPEC_NOW:
|
|
|
|
if (strcmp("now", gt))
|
|
|
|
die("Date in ident must be 'now': %s", buf);
|
|
|
|
datestamp(ident + name_len, 24);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ident;
|
|
|
|
}
|
|
|
|
|
2007-01-17 06:47:25 +00:00
|
|
|
static void cmd_new_blob(void)
|
2006-08-08 05:14:21 +00:00
|
|
|
{
|
2007-09-17 12:00:38 +00:00
|
|
|
static struct strbuf buf = STRBUF_INIT;
|
2006-08-15 00:16:28 +00:00
|
|
|
|
|
|
|
read_next_command();
|
|
|
|
cmd_mark();
|
2007-09-17 11:48:17 +00:00
|
|
|
cmd_data(&buf);
|
2007-09-17 12:00:38 +00:00
|
|
|
store_object(OBJ_BLOB, &buf, &last_blob, NULL, next_mark);
|
2006-08-08 05:14:21 +00:00
|
|
|
}
|
|
|
|
|
2007-01-17 06:47:25 +00:00
|
|
|
static void unload_one_branch(void)
|
2006-08-08 07:36:45 +00:00
|
|
|
{
|
2006-08-24 08:37:35 +00:00
|
|
|
while (cur_active_branches
|
|
|
|
&& cur_active_branches >= max_active_branches) {
|
2007-03-07 01:44:34 +00:00
|
|
|
uintmax_t min_commit = ULONG_MAX;
|
2006-08-14 04:58:19 +00:00
|
|
|
struct branch *e, *l = NULL, *p = NULL;
|
|
|
|
|
|
|
|
for (e = active_branches; e; e = e->active_next_branch) {
|
|
|
|
if (e->last_commit < min_commit) {
|
|
|
|
p = l;
|
|
|
|
min_commit = e->last_commit;
|
|
|
|
}
|
|
|
|
l = e;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (p) {
|
|
|
|
e = p->active_next_branch;
|
|
|
|
p->active_next_branch = e->active_next_branch;
|
|
|
|
} else {
|
|
|
|
e = active_branches;
|
|
|
|
active_branches = e->active_next_branch;
|
|
|
|
}
|
2007-03-05 17:31:09 +00:00
|
|
|
e->active = 0;
|
2006-08-14 04:58:19 +00:00
|
|
|
e->active_next_branch = NULL;
|
|
|
|
if (e->branch_tree.tree) {
|
2006-08-23 05:33:47 +00:00
|
|
|
release_tree_content_recursive(e->branch_tree.tree);
|
2006-08-14 04:58:19 +00:00
|
|
|
e->branch_tree.tree = NULL;
|
|
|
|
}
|
|
|
|
cur_active_branches--;
|
2006-08-08 07:36:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-08-14 04:58:19 +00:00
|
|
|
static void load_branch(struct branch *b)
|
2006-08-08 07:36:45 +00:00
|
|
|
{
|
2006-08-14 04:58:19 +00:00
|
|
|
load_tree(&b->branch_tree);
|
2007-03-05 17:31:09 +00:00
|
|
|
if (!b->active) {
|
|
|
|
b->active = 1;
|
|
|
|
b->active_next_branch = active_branches;
|
|
|
|
active_branches = b;
|
|
|
|
cur_active_branches++;
|
|
|
|
branch_load_count++;
|
|
|
|
}
|
2006-08-08 07:36:45 +00:00
|
|
|
}
|
|
|
|
|
2006-08-14 04:58:19 +00:00
|
|
|
static void file_change_m(struct branch *b)
|
2006-08-08 07:36:45 +00:00
|
|
|
{
|
2006-08-15 00:16:28 +00:00
|
|
|
const char *p = command_buf.buf + 2;
|
2007-09-19 22:42:14 +00:00
|
|
|
static struct strbuf uq = STRBUF_INIT;
|
2006-08-15 00:16:28 +00:00
|
|
|
const char *endp;
|
2007-02-06 05:26:49 +00:00
|
|
|
struct object_entry *oe = oe;
|
2006-08-14 04:58:19 +00:00
|
|
|
unsigned char sha1[20];
|
2007-02-05 21:34:56 +00:00
|
|
|
uint16_t mode, inline_data = 0;
|
2006-08-08 07:36:45 +00:00
|
|
|
|
2006-08-15 00:16:28 +00:00
|
|
|
p = get_mode(p, &mode);
|
|
|
|
if (!p)
|
|
|
|
die("Corrupt mode: %s", command_buf.buf);
|
|
|
|
switch (mode) {
|
|
|
|
case S_IFREG | 0644:
|
|
|
|
case S_IFREG | 0755:
|
2006-08-21 07:29:13 +00:00
|
|
|
case S_IFLNK:
|
2006-08-15 00:16:28 +00:00
|
|
|
case 0644:
|
|
|
|
case 0755:
|
|
|
|
/* ok */
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
die("Corrupt mode: %s", command_buf.buf);
|
|
|
|
}
|
|
|
|
|
2006-08-23 08:17:45 +00:00
|
|
|
if (*p == ':') {
|
|
|
|
char *x;
|
2007-01-16 05:33:19 +00:00
|
|
|
oe = find_mark(strtoumax(p + 1, &x, 10));
|
2007-01-12 02:25:01 +00:00
|
|
|
hashcpy(sha1, oe->sha1);
|
2006-08-23 08:17:45 +00:00
|
|
|
p = x;
|
2007-02-20 09:54:00 +00:00
|
|
|
} else if (!prefixcmp(p, "inline")) {
|
2007-01-18 20:17:58 +00:00
|
|
|
inline_data = 1;
|
|
|
|
p += 6;
|
2006-08-23 08:17:45 +00:00
|
|
|
} else {
|
|
|
|
if (get_sha1_hex(p, sha1))
|
|
|
|
die("Invalid SHA1: %s", command_buf.buf);
|
|
|
|
oe = find_object(sha1);
|
|
|
|
p += 40;
|
|
|
|
}
|
2006-08-15 00:16:28 +00:00
|
|
|
if (*p++ != ' ')
|
|
|
|
die("Missing space after SHA1: %s", command_buf.buf);
|
|
|
|
|
2007-09-19 22:42:14 +00:00
|
|
|
strbuf_reset(&uq);
|
|
|
|
if (!unquote_c_style(&uq, p, &endp)) {
|
2006-08-15 00:16:28 +00:00
|
|
|
if (*endp)
|
|
|
|
die("Garbage after path in: %s", command_buf.buf);
|
2007-09-19 22:42:14 +00:00
|
|
|
p = uq.buf;
|
2006-08-15 00:16:28 +00:00
|
|
|
}
|
2006-08-08 07:36:45 +00:00
|
|
|
|
2007-01-18 20:17:58 +00:00
|
|
|
if (inline_data) {
|
2007-09-17 12:00:38 +00:00
|
|
|
static struct strbuf buf = STRBUF_INIT;
|
2007-09-17 11:48:17 +00:00
|
|
|
|
2007-09-19 22:42:14 +00:00
|
|
|
if (p != uq.buf) {
|
|
|
|
strbuf_addstr(&uq, p);
|
|
|
|
p = uq.buf;
|
|
|
|
}
|
2007-01-18 20:17:58 +00:00
|
|
|
read_next_command();
|
2007-09-17 11:48:17 +00:00
|
|
|
cmd_data(&buf);
|
2007-09-17 12:00:38 +00:00
|
|
|
store_object(OBJ_BLOB, &buf, &last_blob, sha1, 0);
|
2007-01-18 20:17:58 +00:00
|
|
|
} else if (oe) {
|
2006-08-14 06:50:18 +00:00
|
|
|
if (oe->type != OBJ_BLOB)
|
2006-08-15 00:16:28 +00:00
|
|
|
die("Not a blob (actually a %s): %s",
|
2007-10-20 16:15:38 +00:00
|
|
|
typename(oe->type), command_buf.buf);
|
2006-08-14 06:50:18 +00:00
|
|
|
} else {
|
2007-02-26 19:55:59 +00:00
|
|
|
enum object_type type = sha1_object_info(sha1, NULL);
|
|
|
|
if (type < 0)
|
2006-08-15 00:16:28 +00:00
|
|
|
die("Blob not found: %s", command_buf.buf);
|
2007-02-26 19:55:59 +00:00
|
|
|
if (type != OBJ_BLOB)
|
2006-08-15 00:16:28 +00:00
|
|
|
die("Not a blob (actually a %s): %s",
|
2007-02-26 19:55:59 +00:00
|
|
|
typename(type), command_buf.buf);
|
2006-08-14 06:50:18 +00:00
|
|
|
}
|
2006-08-08 07:36:45 +00:00
|
|
|
|
2007-07-10 02:58:23 +00:00
|
|
|
tree_content_set(&b->branch_tree, p, sha1, S_IFREG | mode, NULL);
|
2006-08-14 04:58:19 +00:00
|
|
|
}
|
2006-08-08 07:36:45 +00:00
|
|
|
|
2006-08-14 04:58:19 +00:00
|
|
|
static void file_change_d(struct branch *b)
|
|
|
|
{
|
2006-08-15 00:16:28 +00:00
|
|
|
const char *p = command_buf.buf + 2;
|
2007-09-19 22:42:14 +00:00
|
|
|
static struct strbuf uq = STRBUF_INIT;
|
2006-08-15 00:16:28 +00:00
|
|
|
const char *endp;
|
|
|
|
|
2007-09-19 22:42:14 +00:00
|
|
|
strbuf_reset(&uq);
|
|
|
|
if (!unquote_c_style(&uq, p, &endp)) {
|
2006-08-15 00:16:28 +00:00
|
|
|
if (*endp)
|
|
|
|
die("Garbage after path in: %s", command_buf.buf);
|
2007-09-19 22:42:14 +00:00
|
|
|
p = uq.buf;
|
2006-08-15 00:16:28 +00:00
|
|
|
}
|
2007-07-10 02:58:23 +00:00
|
|
|
tree_content_remove(&b->branch_tree, p, NULL);
|
2006-08-08 07:36:45 +00:00
|
|
|
}
|
|
|
|
|
2007-07-15 05:40:37 +00:00
|
|
|
static void file_change_cr(struct branch *b, int rename)
|
2007-07-10 02:58:23 +00:00
|
|
|
{
|
|
|
|
const char *s, *d;
|
2007-09-19 22:42:14 +00:00
|
|
|
static struct strbuf s_uq = STRBUF_INIT;
|
|
|
|
static struct strbuf d_uq = STRBUF_INIT;
|
2007-07-10 02:58:23 +00:00
|
|
|
const char *endp;
|
|
|
|
struct tree_entry leaf;
|
|
|
|
|
|
|
|
s = command_buf.buf + 2;
|
2007-09-19 22:42:14 +00:00
|
|
|
strbuf_reset(&s_uq);
|
|
|
|
if (!unquote_c_style(&s_uq, s, &endp)) {
|
2007-07-10 02:58:23 +00:00
|
|
|
if (*endp != ' ')
|
|
|
|
die("Missing space after source: %s", command_buf.buf);
|
2007-09-19 22:42:14 +00:00
|
|
|
} else {
|
2007-07-10 02:58:23 +00:00
|
|
|
endp = strchr(s, ' ');
|
|
|
|
if (!endp)
|
|
|
|
die("Missing space after source: %s", command_buf.buf);
|
2007-09-19 22:42:14 +00:00
|
|
|
strbuf_add(&s_uq, s, endp - s);
|
2007-07-10 02:58:23 +00:00
|
|
|
}
|
2007-09-19 22:42:14 +00:00
|
|
|
s = s_uq.buf;
|
2007-07-10 02:58:23 +00:00
|
|
|
|
|
|
|
endp++;
|
|
|
|
if (!*endp)
|
|
|
|
die("Missing dest: %s", command_buf.buf);
|
|
|
|
|
|
|
|
d = endp;
|
2007-09-19 22:42:14 +00:00
|
|
|
strbuf_reset(&d_uq);
|
|
|
|
if (!unquote_c_style(&d_uq, d, &endp)) {
|
2007-07-10 02:58:23 +00:00
|
|
|
if (*endp)
|
|
|
|
die("Garbage after dest in: %s", command_buf.buf);
|
2007-09-19 22:42:14 +00:00
|
|
|
d = d_uq.buf;
|
2007-07-10 02:58:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
memset(&leaf, 0, sizeof(leaf));
|
2007-07-15 05:40:37 +00:00
|
|
|
if (rename)
|
|
|
|
tree_content_remove(&b->branch_tree, s, &leaf);
|
|
|
|
else
|
|
|
|
tree_content_get(&b->branch_tree, s, &leaf);
|
2007-07-10 02:58:23 +00:00
|
|
|
if (!leaf.versions[1].mode)
|
|
|
|
die("Path %s not in branch", s);
|
|
|
|
tree_content_set(&b->branch_tree, d,
|
|
|
|
leaf.versions[1].sha1,
|
|
|
|
leaf.versions[1].mode,
|
|
|
|
leaf.tree);
|
|
|
|
}
|
|
|
|
|
2007-02-07 07:03:03 +00:00
|
|
|
static void file_change_deleteall(struct branch *b)
|
|
|
|
{
|
|
|
|
release_tree_content_recursive(b->branch_tree.tree);
|
|
|
|
hashclr(b->branch_tree.versions[0].sha1);
|
|
|
|
hashclr(b->branch_tree.versions[1].sha1);
|
|
|
|
load_tree(&b->branch_tree);
|
|
|
|
}
|
|
|
|
|
2007-05-24 04:05:19 +00:00
|
|
|
static void cmd_from_commit(struct branch *b, char *buf, unsigned long size)
|
|
|
|
{
|
|
|
|
if (!buf || size < 46)
|
|
|
|
die("Not a valid commit: %s", sha1_to_hex(b->sha1));
|
|
|
|
if (memcmp("tree ", buf, 5)
|
|
|
|
|| get_sha1_hex(buf + 5, b->branch_tree.versions[1].sha1))
|
|
|
|
die("The commit %s is corrupt", sha1_to_hex(b->sha1));
|
|
|
|
hashcpy(b->branch_tree.versions[0].sha1,
|
|
|
|
b->branch_tree.versions[1].sha1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void cmd_from_existing(struct branch *b)
|
|
|
|
{
|
|
|
|
if (is_null_sha1(b->sha1)) {
|
|
|
|
hashclr(b->branch_tree.versions[0].sha1);
|
|
|
|
hashclr(b->branch_tree.versions[1].sha1);
|
|
|
|
} else {
|
|
|
|
unsigned long size;
|
|
|
|
char *buf;
|
|
|
|
|
|
|
|
buf = read_object_with_reference(b->sha1,
|
|
|
|
commit_type, &size, b->sha1);
|
|
|
|
cmd_from_commit(b, buf, size);
|
|
|
|
free(buf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-08-01 06:22:53 +00:00
|
|
|
static int cmd_from(struct branch *b)
|
2006-08-24 22:45:26 +00:00
|
|
|
{
|
2007-02-06 01:30:37 +00:00
|
|
|
const char *from;
|
2006-08-24 22:45:26 +00:00
|
|
|
struct branch *s;
|
|
|
|
|
2007-02-20 09:54:00 +00:00
|
|
|
if (prefixcmp(command_buf.buf, "from "))
|
2007-08-01 06:22:53 +00:00
|
|
|
return 0;
|
2006-08-24 22:45:26 +00:00
|
|
|
|
2007-02-12 09:08:43 +00:00
|
|
|
if (b->branch_tree.tree) {
|
|
|
|
release_tree_content_recursive(b->branch_tree.tree);
|
|
|
|
b->branch_tree.tree = NULL;
|
|
|
|
}
|
2006-08-24 22:45:26 +00:00
|
|
|
|
|
|
|
from = strchr(command_buf.buf, ' ') + 1;
|
|
|
|
s = lookup_branch(from);
|
|
|
|
if (b == s)
|
|
|
|
die("Can't create a branch from itself: %s", b->name);
|
|
|
|
else if (s) {
|
2006-08-28 16:22:50 +00:00
|
|
|
unsigned char *t = s->branch_tree.versions[1].sha1;
|
2006-08-28 14:46:58 +00:00
|
|
|
hashcpy(b->sha1, s->sha1);
|
2006-08-28 16:22:50 +00:00
|
|
|
hashcpy(b->branch_tree.versions[0].sha1, t);
|
|
|
|
hashcpy(b->branch_tree.versions[1].sha1, t);
|
2006-08-24 22:45:26 +00:00
|
|
|
} else if (*from == ':') {
|
2007-01-16 05:33:19 +00:00
|
|
|
uintmax_t idnum = strtoumax(from + 1, NULL, 10);
|
2006-08-24 22:45:26 +00:00
|
|
|
struct object_entry *oe = find_mark(idnum);
|
|
|
|
if (oe->type != OBJ_COMMIT)
|
2007-02-21 01:34:56 +00:00
|
|
|
die("Mark :%" PRIuMAX " not a commit", idnum);
|
2006-08-28 14:46:58 +00:00
|
|
|
hashcpy(b->sha1, oe->sha1);
|
2007-05-24 04:32:31 +00:00
|
|
|
if (oe->pack_id != MAX_PACK_ID) {
|
2006-08-24 22:45:26 +00:00
|
|
|
unsigned long size;
|
2007-05-24 04:32:31 +00:00
|
|
|
char *buf = gfi_unpack_entry(oe, &size);
|
|
|
|
cmd_from_commit(b, buf, size);
|
2006-08-24 22:45:26 +00:00
|
|
|
free(buf);
|
2007-05-24 04:32:31 +00:00
|
|
|
} else
|
|
|
|
cmd_from_existing(b);
|
2007-05-24 04:05:19 +00:00
|
|
|
} else if (!get_sha1(from, b->sha1))
|
|
|
|
cmd_from_existing(b);
|
|
|
|
else
|
2006-08-24 22:45:26 +00:00
|
|
|
die("Invalid ref name or SHA1 expression: %s", from);
|
|
|
|
|
|
|
|
read_next_command();
|
2007-08-01 06:22:53 +00:00
|
|
|
return 1;
|
2006-08-24 22:45:26 +00:00
|
|
|
}
|
|
|
|
|
2007-02-06 05:43:59 +00:00
|
|
|
static struct hash_list *cmd_merge(unsigned int *count)
|
2007-01-12 03:21:38 +00:00
|
|
|
{
|
2007-02-06 05:26:49 +00:00
|
|
|
struct hash_list *list = NULL, *n, *e = e;
|
2007-02-06 01:30:37 +00:00
|
|
|
const char *from;
|
2007-01-12 03:21:38 +00:00
|
|
|
struct branch *s;
|
|
|
|
|
|
|
|
*count = 0;
|
2007-02-20 09:54:00 +00:00
|
|
|
while (!prefixcmp(command_buf.buf, "merge ")) {
|
2007-01-12 03:21:38 +00:00
|
|
|
from = strchr(command_buf.buf, ' ') + 1;
|
|
|
|
n = xmalloc(sizeof(*n));
|
|
|
|
s = lookup_branch(from);
|
|
|
|
if (s)
|
|
|
|
hashcpy(n->sha1, s->sha1);
|
|
|
|
else if (*from == ':') {
|
2007-01-16 05:33:19 +00:00
|
|
|
uintmax_t idnum = strtoumax(from + 1, NULL, 10);
|
2007-01-12 03:21:38 +00:00
|
|
|
struct object_entry *oe = find_mark(idnum);
|
|
|
|
if (oe->type != OBJ_COMMIT)
|
2007-02-21 01:34:56 +00:00
|
|
|
die("Mark :%" PRIuMAX " not a commit", idnum);
|
2007-01-12 03:21:38 +00:00
|
|
|
hashcpy(n->sha1, oe->sha1);
|
2007-03-05 17:43:14 +00:00
|
|
|
} else if (!get_sha1(from, n->sha1)) {
|
|
|
|
unsigned long size;
|
|
|
|
char *buf = read_object_with_reference(n->sha1,
|
2007-03-05 17:49:02 +00:00
|
|
|
commit_type, &size, n->sha1);
|
2007-03-05 17:43:14 +00:00
|
|
|
if (!buf || size < 46)
|
|
|
|
die("Not a valid commit: %s", from);
|
|
|
|
free(buf);
|
|
|
|
} else
|
2007-01-12 03:21:38 +00:00
|
|
|
die("Invalid ref name or SHA1 expression: %s", from);
|
|
|
|
|
|
|
|
n->next = NULL;
|
|
|
|
if (list)
|
|
|
|
e->next = n;
|
|
|
|
else
|
|
|
|
list = n;
|
|
|
|
e = n;
|
2007-02-06 05:26:49 +00:00
|
|
|
(*count)++;
|
2007-01-12 03:21:38 +00:00
|
|
|
read_next_command();
|
|
|
|
}
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
2007-01-17 06:47:25 +00:00
|
|
|
static void cmd_new_commit(void)
|
2006-08-08 07:36:45 +00:00
|
|
|
{
|
2007-09-17 11:48:17 +00:00
|
|
|
static struct strbuf msg = STRBUF_INIT;
|
2006-08-15 00:16:28 +00:00
|
|
|
struct branch *b;
|
|
|
|
char *sp;
|
|
|
|
char *author = NULL;
|
|
|
|
char *committer = NULL;
|
2007-01-12 03:21:38 +00:00
|
|
|
struct hash_list *merge_list = NULL;
|
|
|
|
unsigned int merge_count;
|
2006-08-15 00:16:28 +00:00
|
|
|
|
|
|
|
/* Obtain the branch name from the rest of our command */
|
|
|
|
sp = strchr(command_buf.buf, ' ') + 1;
|
|
|
|
b = lookup_branch(sp);
|
2006-08-14 04:58:19 +00:00
|
|
|
if (!b)
|
2006-08-24 22:45:26 +00:00
|
|
|
b = new_branch(sp);
|
2006-08-15 00:16:28 +00:00
|
|
|
|
|
|
|
read_next_command();
|
|
|
|
cmd_mark();
|
2007-02-20 09:54:00 +00:00
|
|
|
if (!prefixcmp(command_buf.buf, "author ")) {
|
2007-02-06 19:58:30 +00:00
|
|
|
author = parse_ident(command_buf.buf + 7);
|
2006-08-15 00:16:28 +00:00
|
|
|
read_next_command();
|
|
|
|
}
|
2007-02-20 09:54:00 +00:00
|
|
|
if (!prefixcmp(command_buf.buf, "committer ")) {
|
2007-02-06 19:58:30 +00:00
|
|
|
committer = parse_ident(command_buf.buf + 10);
|
2006-08-15 00:16:28 +00:00
|
|
|
read_next_command();
|
|
|
|
}
|
|
|
|
if (!committer)
|
|
|
|
die("Expected committer but didn't get one");
|
2007-09-17 11:48:17 +00:00
|
|
|
cmd_data(&msg);
|
2006-08-25 02:38:13 +00:00
|
|
|
read_next_command();
|
|
|
|
cmd_from(b);
|
2007-01-12 03:21:38 +00:00
|
|
|
merge_list = cmd_merge(&merge_count);
|
2006-08-15 00:16:28 +00:00
|
|
|
|
|
|
|
/* ensure the branch is active/loaded */
|
2006-08-24 08:37:35 +00:00
|
|
|
if (!b->branch_tree.tree || !max_active_branches) {
|
2006-08-14 04:58:19 +00:00
|
|
|
unload_one_branch();
|
|
|
|
load_branch(b);
|
|
|
|
}
|
2006-08-08 07:36:45 +00:00
|
|
|
|
2006-08-14 04:58:19 +00:00
|
|
|
/* file_change* */
|
2007-09-17 09:19:04 +00:00
|
|
|
while (command_buf.len > 0) {
|
2007-08-01 06:22:53 +00:00
|
|
|
if (!prefixcmp(command_buf.buf, "M "))
|
2006-08-14 04:58:19 +00:00
|
|
|
file_change_m(b);
|
2007-02-20 09:54:00 +00:00
|
|
|
else if (!prefixcmp(command_buf.buf, "D "))
|
2006-08-14 04:58:19 +00:00
|
|
|
file_change_d(b);
|
2007-07-10 02:58:23 +00:00
|
|
|
else if (!prefixcmp(command_buf.buf, "R "))
|
2007-07-15 05:40:37 +00:00
|
|
|
file_change_cr(b, 1);
|
|
|
|
else if (!prefixcmp(command_buf.buf, "C "))
|
|
|
|
file_change_cr(b, 0);
|
2007-02-07 07:03:03 +00:00
|
|
|
else if (!strcmp("deleteall", command_buf.buf))
|
|
|
|
file_change_deleteall(b);
|
2007-08-01 06:22:53 +00:00
|
|
|
else {
|
|
|
|
unread_command_buf = 1;
|
|
|
|
break;
|
|
|
|
}
|
2007-09-17 09:19:04 +00:00
|
|
|
if (read_next_command() == EOF)
|
|
|
|
break;
|
2006-08-08 07:36:45 +00:00
|
|
|
}
|
|
|
|
|
2006-08-15 00:16:28 +00:00
|
|
|
/* build the tree and the commit */
|
2006-08-14 04:58:19 +00:00
|
|
|
store_tree(&b->branch_tree);
|
2006-08-29 02:06:13 +00:00
|
|
|
hashcpy(b->branch_tree.versions[0].sha1,
|
|
|
|
b->branch_tree.versions[1].sha1);
|
2007-09-17 11:48:17 +00:00
|
|
|
|
|
|
|
strbuf_reset(&new_data);
|
|
|
|
strbuf_addf(&new_data, "tree %s\n",
|
2006-08-28 16:22:50 +00:00
|
|
|
sha1_to_hex(b->branch_tree.versions[1].sha1));
|
2006-08-28 14:46:58 +00:00
|
|
|
if (!is_null_sha1(b->sha1))
|
2007-09-17 11:48:17 +00:00
|
|
|
strbuf_addf(&new_data, "parent %s\n", sha1_to_hex(b->sha1));
|
2007-01-12 03:21:38 +00:00
|
|
|
while (merge_list) {
|
|
|
|
struct hash_list *next = merge_list->next;
|
2007-09-17 11:48:17 +00:00
|
|
|
strbuf_addf(&new_data, "parent %s\n", sha1_to_hex(merge_list->sha1));
|
2007-01-12 03:21:38 +00:00
|
|
|
free(merge_list);
|
|
|
|
merge_list = next;
|
|
|
|
}
|
2007-09-17 11:48:17 +00:00
|
|
|
strbuf_addf(&new_data,
|
|
|
|
"author %s\n"
|
|
|
|
"committer %s\n"
|
|
|
|
"\n",
|
|
|
|
author ? author : committer, committer);
|
|
|
|
strbuf_addbuf(&new_data, &msg);
|
2007-02-06 17:05:51 +00:00
|
|
|
free(author);
|
2006-08-15 00:16:28 +00:00
|
|
|
free(committer);
|
|
|
|
|
2007-09-17 11:48:17 +00:00
|
|
|
if (!store_object(OBJ_COMMIT, &new_data, NULL, b->sha1, next_mark))
|
2007-01-17 07:42:43 +00:00
|
|
|
b->pack_id = pack_id;
|
2006-08-14 04:58:19 +00:00
|
|
|
b->last_commit = object_count_by_type[OBJ_COMMIT];
|
2006-08-08 07:36:45 +00:00
|
|
|
}
|
|
|
|
|
2007-01-17 06:47:25 +00:00
|
|
|
static void cmd_new_tag(void)
|
2006-08-24 07:12:13 +00:00
|
|
|
{
|
2007-09-17 11:48:17 +00:00
|
|
|
static struct strbuf msg = STRBUF_INIT;
|
2006-08-24 07:12:13 +00:00
|
|
|
char *sp;
|
|
|
|
const char *from;
|
|
|
|
char *tagger;
|
|
|
|
struct branch *s;
|
|
|
|
struct tag *t;
|
2007-01-16 05:33:19 +00:00
|
|
|
uintmax_t from_mark = 0;
|
2006-08-24 07:12:13 +00:00
|
|
|
unsigned char sha1[20];
|
|
|
|
|
|
|
|
/* Obtain the new tag name from the rest of our command */
|
|
|
|
sp = strchr(command_buf.buf, ' ') + 1;
|
|
|
|
t = pool_alloc(sizeof(struct tag));
|
|
|
|
t->next_tag = NULL;
|
|
|
|
t->name = pool_strdup(sp);
|
|
|
|
if (last_tag)
|
|
|
|
last_tag->next_tag = t;
|
|
|
|
else
|
|
|
|
first_tag = t;
|
|
|
|
last_tag = t;
|
|
|
|
read_next_command();
|
|
|
|
|
|
|
|
/* from ... */
|
2007-02-20 09:54:00 +00:00
|
|
|
if (prefixcmp(command_buf.buf, "from "))
|
2006-08-24 07:12:13 +00:00
|
|
|
die("Expected from command, got %s", command_buf.buf);
|
|
|
|
from = strchr(command_buf.buf, ' ') + 1;
|
|
|
|
s = lookup_branch(from);
|
|
|
|
if (s) {
|
2006-08-28 14:46:58 +00:00
|
|
|
hashcpy(sha1, s->sha1);
|
2006-08-24 07:12:13 +00:00
|
|
|
} else if (*from == ':') {
|
2007-02-06 05:26:49 +00:00
|
|
|
struct object_entry *oe;
|
2007-01-16 05:33:19 +00:00
|
|
|
from_mark = strtoumax(from + 1, NULL, 10);
|
2007-02-06 05:26:49 +00:00
|
|
|
oe = find_mark(from_mark);
|
2006-08-24 07:12:13 +00:00
|
|
|
if (oe->type != OBJ_COMMIT)
|
2007-02-21 01:34:56 +00:00
|
|
|
die("Mark :%" PRIuMAX " not a commit", from_mark);
|
2006-08-28 14:46:58 +00:00
|
|
|
hashcpy(sha1, oe->sha1);
|
2006-08-24 07:12:13 +00:00
|
|
|
} else if (!get_sha1(from, sha1)) {
|
|
|
|
unsigned long size;
|
|
|
|
char *buf;
|
|
|
|
|
|
|
|
buf = read_object_with_reference(sha1,
|
2007-02-26 19:55:58 +00:00
|
|
|
commit_type, &size, sha1);
|
2006-08-24 07:12:13 +00:00
|
|
|
if (!buf || size < 46)
|
|
|
|
die("Not a valid commit: %s", from);
|
|
|
|
free(buf);
|
|
|
|
} else
|
|
|
|
die("Invalid ref name or SHA1 expression: %s", from);
|
|
|
|
read_next_command();
|
|
|
|
|
|
|
|
/* tagger ... */
|
2007-02-20 09:54:00 +00:00
|
|
|
if (prefixcmp(command_buf.buf, "tagger "))
|
2006-08-24 07:12:13 +00:00
|
|
|
die("Expected tagger command, got %s", command_buf.buf);
|
2007-02-06 19:58:30 +00:00
|
|
|
tagger = parse_ident(command_buf.buf + 7);
|
2006-08-24 07:12:13 +00:00
|
|
|
|
|
|
|
/* tag payload/message */
|
|
|
|
read_next_command();
|
2007-09-17 11:48:17 +00:00
|
|
|
cmd_data(&msg);
|
2006-08-24 07:12:13 +00:00
|
|
|
|
|
|
|
/* build the tag object */
|
2007-09-17 11:48:17 +00:00
|
|
|
strbuf_reset(&new_data);
|
|
|
|
strbuf_addf(&new_data,
|
|
|
|
"object %s\n"
|
|
|
|
"type %s\n"
|
|
|
|
"tag %s\n"
|
|
|
|
"tagger %s\n"
|
|
|
|
"\n",
|
|
|
|
sha1_to_hex(sha1), commit_type, t->name, tagger);
|
|
|
|
strbuf_addbuf(&new_data, &msg);
|
2006-08-24 07:12:13 +00:00
|
|
|
free(tagger);
|
|
|
|
|
2007-09-17 11:48:17 +00:00
|
|
|
if (store_object(OBJ_TAG, &new_data, NULL, t->sha1, 0))
|
2007-01-17 07:42:43 +00:00
|
|
|
t->pack_id = MAX_PACK_ID;
|
|
|
|
else
|
|
|
|
t->pack_id = pack_id;
|
2006-08-24 07:12:13 +00:00
|
|
|
}
|
|
|
|
|
2007-01-17 06:47:25 +00:00
|
|
|
static void cmd_reset_branch(void)
|
2006-08-27 10:20:49 +00:00
|
|
|
{
|
|
|
|
struct branch *b;
|
|
|
|
char *sp;
|
|
|
|
|
|
|
|
/* Obtain the branch name from the rest of our command */
|
|
|
|
sp = strchr(command_buf.buf, ' ') + 1;
|
|
|
|
b = lookup_branch(sp);
|
|
|
|
if (b) {
|
2007-02-12 09:08:43 +00:00
|
|
|
hashclr(b->sha1);
|
|
|
|
hashclr(b->branch_tree.versions[0].sha1);
|
|
|
|
hashclr(b->branch_tree.versions[1].sha1);
|
2006-08-27 10:20:49 +00:00
|
|
|
if (b->branch_tree.tree) {
|
|
|
|
release_tree_content_recursive(b->branch_tree.tree);
|
|
|
|
b->branch_tree.tree = NULL;
|
|
|
|
}
|
|
|
|
}
|
2007-01-12 03:28:39 +00:00
|
|
|
else
|
|
|
|
b = new_branch(sp);
|
|
|
|
read_next_command();
|
2007-09-06 11:20:05 +00:00
|
|
|
if (!cmd_from(b) && command_buf.len > 0)
|
2007-08-01 06:22:53 +00:00
|
|
|
unread_command_buf = 1;
|
2006-08-27 10:20:49 +00:00
|
|
|
}
|
|
|
|
|
2007-01-17 06:47:25 +00:00
|
|
|
static void cmd_checkpoint(void)
|
2007-01-15 11:35:41 +00:00
|
|
|
{
|
2007-02-07 07:42:44 +00:00
|
|
|
if (object_count) {
|
|
|
|
cycle_packfile();
|
|
|
|
dump_branches();
|
|
|
|
dump_tags();
|
|
|
|
dump_marks();
|
|
|
|
}
|
2007-08-01 06:22:53 +00:00
|
|
|
skip_optional_lf();
|
2007-01-15 11:35:41 +00:00
|
|
|
}
|
|
|
|
|
2007-08-01 14:23:08 +00:00
|
|
|
static void cmd_progress(void)
|
|
|
|
{
|
2007-09-06 11:20:05 +00:00
|
|
|
fwrite(command_buf.buf, 1, command_buf.len, stdout);
|
2007-08-01 14:23:08 +00:00
|
|
|
fputc('\n', stdout);
|
|
|
|
fflush(stdout);
|
|
|
|
skip_optional_lf();
|
|
|
|
}
|
|
|
|
|
2007-03-07 23:07:26 +00:00
|
|
|
static void import_marks(const char *input_file)
|
|
|
|
{
|
|
|
|
char line[512];
|
|
|
|
FILE *f = fopen(input_file, "r");
|
|
|
|
if (!f)
|
|
|
|
die("cannot read %s: %s", input_file, strerror(errno));
|
|
|
|
while (fgets(line, sizeof(line), f)) {
|
|
|
|
uintmax_t mark;
|
|
|
|
char *end;
|
|
|
|
unsigned char sha1[20];
|
|
|
|
struct object_entry *e;
|
|
|
|
|
|
|
|
end = strchr(line, '\n');
|
|
|
|
if (line[0] != ':' || !end)
|
|
|
|
die("corrupt mark line: %s", line);
|
|
|
|
*end = 0;
|
|
|
|
mark = strtoumax(line + 1, &end, 10);
|
|
|
|
if (!mark || end == line + 1
|
|
|
|
|| *end != ' ' || get_sha1(end + 1, sha1))
|
|
|
|
die("corrupt mark line: %s", line);
|
|
|
|
e = find_object(sha1);
|
|
|
|
if (!e) {
|
|
|
|
enum object_type type = sha1_object_info(sha1, NULL);
|
|
|
|
if (type < 0)
|
|
|
|
die("object not found: %s", sha1_to_hex(sha1));
|
|
|
|
e = insert_object(sha1);
|
|
|
|
e->type = type;
|
|
|
|
e->pack_id = MAX_PACK_ID;
|
2007-04-20 15:23:45 +00:00
|
|
|
e->offset = 1; /* just not zero! */
|
2007-03-07 23:07:26 +00:00
|
|
|
}
|
|
|
|
insert_mark(mark, e);
|
|
|
|
}
|
|
|
|
fclose(f);
|
|
|
|
}
|
|
|
|
|
2006-08-23 06:00:31 +00:00
|
|
|
static const char fast_import_usage[] =
|
2007-02-06 19:58:30 +00:00
|
|
|
"git-fast-import [--date-format=f] [--max-pack-size=n] [--depth=n] [--active-branches=n] [--export-marks=marks.file]";
|
2006-08-23 06:00:31 +00:00
|
|
|
|
2006-08-06 17:51:39 +00:00
|
|
|
int main(int argc, const char **argv)
|
|
|
|
{
|
2007-08-03 08:47:04 +00:00
|
|
|
unsigned int i, show_stats = 1;
|
2006-08-06 17:51:39 +00:00
|
|
|
|
2006-08-14 04:58:19 +00:00
|
|
|
git_config(git_default_config);
|
2007-03-07 22:09:21 +00:00
|
|
|
alloc_objects(object_entry_alloc);
|
2007-09-10 10:35:04 +00:00
|
|
|
strbuf_init(&command_buf, 0);
|
2007-03-07 22:09:21 +00:00
|
|
|
atom_table = xcalloc(atom_table_sz, sizeof(struct atom_str*));
|
|
|
|
branch_table = xcalloc(branch_table_sz, sizeof(struct branch*));
|
|
|
|
avail_tree_table = xcalloc(avail_tree_table_sz, sizeof(struct avail_tree_content*));
|
|
|
|
marks = pool_calloc(1, sizeof(struct mark_set));
|
2006-08-14 04:58:19 +00:00
|
|
|
|
2006-08-23 06:00:31 +00:00
|
|
|
for (i = 1; i < argc; i++) {
|
|
|
|
const char *a = argv[i];
|
|
|
|
|
|
|
|
if (*a != '-' || !strcmp(a, "--"))
|
|
|
|
break;
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
else if (!prefixcmp(a, "--date-format=")) {
|
2007-02-06 19:58:30 +00:00
|
|
|
const char *fmt = a + 14;
|
|
|
|
if (!strcmp(fmt, "raw"))
|
|
|
|
whenspec = WHENSPEC_RAW;
|
|
|
|
else if (!strcmp(fmt, "rfc2822"))
|
|
|
|
whenspec = WHENSPEC_RFC2822;
|
|
|
|
else if (!strcmp(fmt, "now"))
|
|
|
|
whenspec = WHENSPEC_NOW;
|
|
|
|
else
|
|
|
|
die("unknown --date-format argument %s", fmt);
|
|
|
|
}
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
else if (!prefixcmp(a, "--max-pack-size="))
|
2007-01-16 05:33:19 +00:00
|
|
|
max_packsize = strtoumax(a + 16, NULL, 0) * 1024 * 1024;
|
2007-11-14 04:48:42 +00:00
|
|
|
else if (!prefixcmp(a, "--depth=")) {
|
2006-08-23 06:00:31 +00:00
|
|
|
max_depth = strtoul(a + 8, NULL, 0);
|
2007-11-14 04:48:42 +00:00
|
|
|
if (max_depth > MAX_DEPTH)
|
|
|
|
die("--depth cannot exceed %u", MAX_DEPTH);
|
|
|
|
}
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
else if (!prefixcmp(a, "--active-branches="))
|
2006-08-23 06:00:31 +00:00
|
|
|
max_active_branches = strtoul(a + 18, NULL, 0);
|
2007-03-07 23:07:26 +00:00
|
|
|
else if (!prefixcmp(a, "--import-marks="))
|
|
|
|
import_marks(a + 15);
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
else if (!prefixcmp(a, "--export-marks="))
|
2006-08-25 20:03:04 +00:00
|
|
|
mark_file = a + 15;
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
else if (!prefixcmp(a, "--export-pack-edges=")) {
|
2007-02-12 00:45:56 +00:00
|
|
|
if (pack_edges)
|
|
|
|
fclose(pack_edges);
|
|
|
|
pack_edges = fopen(a + 20, "a");
|
|
|
|
if (!pack_edges)
|
|
|
|
die("Cannot open %s: %s", a + 20, strerror(errno));
|
|
|
|
} else if (!strcmp(a, "--force"))
|
2007-02-06 21:08:06 +00:00
|
|
|
force_update = 1;
|
2007-02-07 07:19:31 +00:00
|
|
|
else if (!strcmp(a, "--quiet"))
|
|
|
|
show_stats = 0;
|
|
|
|
else if (!strcmp(a, "--stats"))
|
|
|
|
show_stats = 1;
|
2006-08-23 06:00:31 +00:00
|
|
|
else
|
|
|
|
die("unknown option %s", a);
|
|
|
|
}
|
2007-01-16 06:15:31 +00:00
|
|
|
if (i != argc)
|
2006-08-23 06:00:31 +00:00
|
|
|
usage(fast_import_usage);
|
|
|
|
|
2007-08-03 08:47:04 +00:00
|
|
|
rc_free = pool_alloc(cmd_save * sizeof(*rc_free));
|
|
|
|
for (i = 0; i < (cmd_save - 1); i++)
|
|
|
|
rc_free[i].next = &rc_free[i + 1];
|
|
|
|
rc_free[cmd_save - 1].next = NULL;
|
|
|
|
|
2007-04-20 15:23:45 +00:00
|
|
|
prepare_packed_git();
|
2007-01-15 09:39:05 +00:00
|
|
|
start_packfile();
|
2007-08-03 06:00:37 +00:00
|
|
|
set_die_routine(die_nicely);
|
2007-09-17 09:19:04 +00:00
|
|
|
while (read_next_command() != EOF) {
|
|
|
|
if (!strcmp("blob", command_buf.buf))
|
2006-08-15 00:16:28 +00:00
|
|
|
cmd_new_blob();
|
2007-02-20 09:54:00 +00:00
|
|
|
else if (!prefixcmp(command_buf.buf, "commit "))
|
2006-08-15 00:16:28 +00:00
|
|
|
cmd_new_commit();
|
2007-02-20 09:54:00 +00:00
|
|
|
else if (!prefixcmp(command_buf.buf, "tag "))
|
2006-08-24 07:12:13 +00:00
|
|
|
cmd_new_tag();
|
2007-02-20 09:54:00 +00:00
|
|
|
else if (!prefixcmp(command_buf.buf, "reset "))
|
2006-08-27 10:20:49 +00:00
|
|
|
cmd_reset_branch();
|
2007-01-15 11:35:41 +00:00
|
|
|
else if (!strcmp("checkpoint", command_buf.buf))
|
|
|
|
cmd_checkpoint();
|
2007-08-01 14:23:08 +00:00
|
|
|
else if (!prefixcmp(command_buf.buf, "progress "))
|
|
|
|
cmd_progress();
|
2006-08-15 00:16:28 +00:00
|
|
|
else
|
|
|
|
die("Unsupported command: %s", command_buf.buf);
|
2006-08-05 06:04:21 +00:00
|
|
|
}
|
2007-01-15 09:39:05 +00:00
|
|
|
end_packfile();
|
2006-08-15 00:16:28 +00:00
|
|
|
|
2006-08-14 04:58:19 +00:00
|
|
|
dump_branches();
|
2006-08-24 07:12:13 +00:00
|
|
|
dump_tags();
|
2007-01-16 06:15:31 +00:00
|
|
|
unkeep_all_packs();
|
2006-08-25 20:03:04 +00:00
|
|
|
dump_marks();
|
2006-08-06 17:51:39 +00:00
|
|
|
|
2007-02-12 00:45:56 +00:00
|
|
|
if (pack_edges)
|
|
|
|
fclose(pack_edges);
|
|
|
|
|
2007-02-07 07:19:31 +00:00
|
|
|
if (show_stats) {
|
|
|
|
uintmax_t total_count = 0, duplicate_count = 0;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(object_count_by_type); i++)
|
|
|
|
total_count += object_count_by_type[i];
|
|
|
|
for (i = 0; i < ARRAY_SIZE(duplicate_count_by_type); i++)
|
|
|
|
duplicate_count += duplicate_count_by_type[i];
|
|
|
|
|
|
|
|
fprintf(stderr, "%s statistics:\n", argv[0]);
|
|
|
|
fprintf(stderr, "---------------------------------------------------------------------\n");
|
2007-02-21 01:34:56 +00:00
|
|
|
fprintf(stderr, "Alloc'd objects: %10" PRIuMAX "\n", alloc_count);
|
|
|
|
fprintf(stderr, "Total objects: %10" PRIuMAX " (%10" PRIuMAX " duplicates )\n", total_count, duplicate_count);
|
|
|
|
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]);
|
|
|
|
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]);
|
|
|
|
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]);
|
|
|
|
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]);
|
2007-02-07 07:19:31 +00:00
|
|
|
fprintf(stderr, "Total branches: %10lu (%10lu loads )\n", branch_count, branch_load_count);
|
2007-02-21 01:34:56 +00:00
|
|
|
fprintf(stderr, " marks: %10" PRIuMAX " (%10" PRIuMAX " unique )\n", (((uintmax_t)1) << marks->shift) * 1024, marks_set_count);
|
2007-02-07 07:19:31 +00:00
|
|
|
fprintf(stderr, " atoms: %10u\n", atom_cnt);
|
2007-02-21 01:34:56 +00:00
|
|
|
fprintf(stderr, "Memory total: %10" PRIuMAX " KiB\n", (total_allocd + alloc_count*sizeof(struct object_entry))/1024);
|
2007-02-07 11:38:21 +00:00
|
|
|
fprintf(stderr, " pools: %10lu KiB\n", (unsigned long)(total_allocd/1024));
|
2007-02-21 01:34:56 +00:00
|
|
|
fprintf(stderr, " objects: %10" PRIuMAX " KiB\n", (alloc_count*sizeof(struct object_entry))/1024);
|
2007-02-07 07:19:31 +00:00
|
|
|
fprintf(stderr, "---------------------------------------------------------------------\n");
|
|
|
|
pack_report();
|
|
|
|
fprintf(stderr, "---------------------------------------------------------------------\n");
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
}
|
2006-08-05 06:04:21 +00:00
|
|
|
|
2007-02-06 21:08:06 +00:00
|
|
|
return failure ? 1 : 0;
|
2006-08-05 06:04:21 +00:00
|
|
|
}
|