Browse Source
This simplifies svn-fe a great deal and fulfills a longstanding wish: support for dumps with deltas in them, and incremental imports. The cost is that commandline usage of the svn-fe tool becomes a little more complicated since it no longer keeps state itself but instead reads blobs back from fast-import in order to copy them between revisions and apply deltas to them. Also removes a couple of custom data structures and replaces them with strbufs like other parts of Git. * 'svn-fe' of git://repo.or.cz/git/jrn: (32 commits) vcs-svn: reset first_commit_done in fast_export_init vcs-svn: do not initialize report_buffer twice vcs-svn: avoid hangs from corrupt deltas vcs-svn: guard against overflow when computing preimage length vcs-svn: cap number of bytes read from sliding view test-svn-fe: split off "test-svn-fe -d" into a separate function vcs-svn: implement text-delta handling vcs-svn: let deltas use data from preimage vcs-svn: let deltas use data from postimage vcs-svn: verify that deltas consume all inline data vcs-svn: implement copyfrom_data delta instruction vcs-svn: read instructions from deltas vcs-svn: read inline data from deltas vcs-svn: read the preimage when applying deltas vcs-svn: parse svndiff0 window header vcs-svn: skeleton of an svn delta parser vcs-svn: make buffer_read_binary API more convenient vcs-svn: learn to maintain a sliding view of a file Makefile: list one vcs-svn/xdiff object or header per line vcs-svn: avoid using ls command twice ... Conflicts: Makefile contrib/svn-fe/svn-fe.txtmaint
Junio C Hamano
13 years ago
28 changed files with 1432 additions and 1362 deletions
@ -1,117 +0,0 @@
@@ -1,117 +0,0 @@
|
||||
#!/bin/sh |
||||
|
||||
test_description='check infrastructure for svn importer' |
||||
|
||||
. ./test-lib.sh |
||||
uint32_max=4294967295 |
||||
|
||||
test_expect_success 'obj pool: store data' ' |
||||
cat <<-\EOF >expected && |
||||
0 |
||||
1 |
||||
EOF |
||||
|
||||
test-obj-pool <<-\EOF >actual && |
||||
alloc one 16 |
||||
set one 13 |
||||
test one 13 |
||||
reset one |
||||
EOF |
||||
test_cmp expected actual |
||||
' |
||||
|
||||
test_expect_success 'obj pool: NULL is offset ~0' ' |
||||
echo "$uint32_max" >expected && |
||||
echo null one | test-obj-pool >actual && |
||||
test_cmp expected actual |
||||
' |
||||
|
||||
test_expect_success 'obj pool: out-of-bounds access' ' |
||||
cat <<-EOF >expected && |
||||
0 |
||||
0 |
||||
$uint32_max |
||||
$uint32_max |
||||
16 |
||||
20 |
||||
$uint32_max |
||||
EOF |
||||
|
||||
test-obj-pool <<-\EOF >actual && |
||||
alloc one 16 |
||||
alloc two 16 |
||||
offset one 20 |
||||
offset two 20 |
||||
alloc one 5 |
||||
offset one 20 |
||||
free one 1 |
||||
offset one 20 |
||||
reset one |
||||
reset two |
||||
EOF |
||||
test_cmp expected actual |
||||
' |
||||
|
||||
test_expect_success 'obj pool: high-water mark' ' |
||||
cat <<-\EOF >expected && |
||||
0 |
||||
0 |
||||
10 |
||||
20 |
||||
20 |
||||
20 |
||||
EOF |
||||
|
||||
test-obj-pool <<-\EOF >actual && |
||||
alloc one 10 |
||||
committed one |
||||
alloc one 10 |
||||
commit one |
||||
committed one |
||||
alloc one 10 |
||||
free one 20 |
||||
committed one |
||||
reset one |
||||
EOF |
||||
test_cmp expected actual |
||||
' |
||||
|
||||
test_expect_success 'string pool' ' |
||||
echo a does not equal b >expected.differ && |
||||
echo a equals a >expected.match && |
||||
echo equals equals equals >expected.matchmore && |
||||
|
||||
test-string-pool "a,--b" >actual.differ && |
||||
test-string-pool "a,a" >actual.match && |
||||
test-string-pool "equals-equals" >actual.matchmore && |
||||
test_must_fail test-string-pool a,a,a && |
||||
test_must_fail test-string-pool a && |
||||
|
||||
test_cmp expected.differ actual.differ && |
||||
test_cmp expected.match actual.match && |
||||
test_cmp expected.matchmore actual.matchmore |
||||
' |
||||
|
||||
test_expect_success 'treap sort' ' |
||||
cat <<-\EOF >unsorted && |
||||
68 |
||||
12 |
||||
13 |
||||
13 |
||||
68 |
||||
13 |
||||
13 |
||||
21 |
||||
10 |
||||
11 |
||||
12 |
||||
13 |
||||
13 |
||||
EOF |
||||
sort unsorted >expected && |
||||
|
||||
test-treap <unsorted >actual && |
||||
test_cmp expected actual |
||||
' |
||||
|
||||
test_done |
||||
@ -0,0 +1,248 @@
@@ -0,0 +1,248 @@
|
||||
#!/bin/sh |
||||
|
||||
test_description='test parsing of svndiff0 files |
||||
|
||||
Using the "test-svn-fe -d" helper, check that svn-fe correctly |
||||
interprets deltas using various facilities (some from the spec, |
||||
some only learned from practice). |
||||
' |
||||
. ./test-lib.sh |
||||
|
||||
>empty |
||||
printf foo >preimage |
||||
|
||||
test_expect_success 'reject empty delta' ' |
||||
test_must_fail test-svn-fe -d preimage empty 0 |
||||
' |
||||
|
||||
test_expect_success 'delta can empty file' ' |
||||
printf "SVNQ" | q_to_nul >clear.delta && |
||||
test-svn-fe -d preimage clear.delta 4 >actual && |
||||
test_cmp empty actual |
||||
' |
||||
|
||||
test_expect_success 'reject svndiff2' ' |
||||
printf "SVN\002" >bad.filetype && |
||||
test_must_fail test-svn-fe -d preimage bad.filetype 4 |
||||
' |
||||
|
||||
test_expect_success 'one-window empty delta' ' |
||||
printf "SVNQ%s" "QQQQQ" | q_to_nul >clear.onewindow && |
||||
test-svn-fe -d preimage clear.onewindow 9 >actual && |
||||
test_cmp empty actual |
||||
' |
||||
|
||||
test_expect_success 'reject incomplete window header' ' |
||||
printf "SVNQ%s" "QQQQQ" | q_to_nul >clear.onewindow && |
||||
printf "SVNQ%s" "QQ" | q_to_nul >clear.partialwindow && |
||||
test_must_fail test-svn-fe -d preimage clear.onewindow 6 && |
||||
test_must_fail test-svn-fe -d preimage clear.partialwindow 6 |
||||
' |
||||
|
||||
test_expect_success 'reject declared delta longer than actual delta' ' |
||||
printf "SVNQ%s" "QQQQQ" | q_to_nul >clear.onewindow && |
||||
printf "SVNQ%s" "QQ" | q_to_nul >clear.partialwindow && |
||||
test_must_fail test-svn-fe -d preimage clear.onewindow 14 && |
||||
test_must_fail test-svn-fe -d preimage clear.partialwindow 9 |
||||
' |
||||
|
||||
test_expect_success 'two-window empty delta' ' |
||||
printf "SVNQ%s%s" "QQQQQ" "QQQQQ" | q_to_nul >clear.twowindow && |
||||
test-svn-fe -d preimage clear.twowindow 14 >actual && |
||||
test_must_fail test-svn-fe -d preimage clear.twowindow 13 && |
||||
test_cmp empty actual |
||||
' |
||||
|
||||
test_expect_success 'noisy zeroes' ' |
||||
printf "SVNQ%s" \ |
||||
"RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRQQQQQ" | |
||||
tr R "\200" | |
||||
q_to_nul >clear.noisy && |
||||
len=$(wc -c <clear.noisy) && |
||||
test-svn-fe -d preimage clear.noisy $len && |
||||
test_cmp empty actual |
||||
' |
||||
|
||||
test_expect_success 'reject variable-length int in magic' ' |
||||
printf "SVNRQ" | tr R "\200" | q_to_nul >clear.badmagic && |
||||
test_must_fail test-svn-fe -d preimage clear.badmagic 5 |
||||
' |
||||
|
||||
test_expect_success 'reject truncated integer' ' |
||||
printf "SVNQ%s%s" "QQQQQ" "QQQQRRQ" | |
||||
tr R "\200" | |
||||
q_to_nul >clear.fullint && |
||||
printf "SVNQ%s%s" "QQQQQ" "QQQQRR" | |
||||
tr RT "\201" | |
||||
q_to_nul >clear.partialint && |
||||
test_must_fail test-svn-fe -d preimage clear.fullint 15 && |
||||
test-svn-fe -d preimage clear.fullint 16 && |
||||
test_must_fail test-svn-fe -d preimage clear.partialint 15 |
||||
' |
||||
|
||||
test_expect_success 'nonempty (but unused) preimage view' ' |
||||
printf "SVNQ%b" "Q\003QQQ" | q_to_nul >clear.readpreimage && |
||||
test-svn-fe -d preimage clear.readpreimage 9 >actual && |
||||
test_cmp empty actual |
||||
' |
||||
|
||||
test_expect_success 'preimage view: right endpoint cannot backtrack' ' |
||||
printf "SVNQ%b%b" "Q\003QQQ" "Q\002QQQ" | |
||||
q_to_nul >clear.backtrack && |
||||
test_must_fail test-svn-fe -d preimage clear.backtrack 14 |
||||
' |
||||
|
||||
test_expect_success 'preimage view: left endpoint can advance' ' |
||||
printf "SVNQ%b%b" "Q\003QQQ" "\001\002QQQ" | |
||||
q_to_nul >clear.preshrink && |
||||
printf "SVNQ%b%b" "Q\003QQQ" "\001\001QQQ" | |
||||
q_to_nul >clear.shrinkbacktrack && |
||||
test-svn-fe -d preimage clear.preshrink 14 >actual && |
||||
test_must_fail test-svn-fe -d preimage clear.shrinkbacktrack 14 && |
||||
test_cmp empty actual |
||||
' |
||||
|
||||
test_expect_success 'preimage view: offsets compared by value' ' |
||||
printf "SVNQ%b%b" "\001\001QQQ" "\0200Q\003QQQ" | |
||||
q_to_nul >clear.noisybacktrack && |
||||
printf "SVNQ%b%b" "\001\001QQQ" "\0200\001\002QQQ" | |
||||
q_to_nul >clear.noisyadvance && |
||||
test_must_fail test-svn-fe -d preimage clear.noisybacktrack 15 && |
||||
test-svn-fe -d preimage clear.noisyadvance 15 && |
||||
test_cmp empty actual |
||||
' |
||||
|
||||
test_expect_success 'preimage view: reject truncated preimage' ' |
||||
printf "SVNQ%b" "\010QQQQ" | q_to_nul >clear.lateemptyread && |
||||
printf "SVNQ%b" "\010\001QQQ" | q_to_nul >clear.latenonemptyread && |
||||
printf "SVNQ%b" "\001\010QQQ" | q_to_nul >clear.longread && |
||||
test_must_fail test-svn-fe -d preimage clear.lateemptyread 9 && |
||||
test_must_fail test-svn-fe -d preimage clear.latenonemptyread 9 && |
||||
test_must_fail test-svn-fe -d preimage clear.longread 9 |
||||
' |
||||
|
||||
test_expect_success 'forbid unconsumed inline data' ' |
||||
printf "SVNQ%b%s%b%s" "QQQQ\003" "bar" "QQQQ\001" "x" | |
||||
q_to_nul >inline.clear && |
||||
test_must_fail test-svn-fe -d preimage inline.clear 18 >actual |
||||
' |
||||
|
||||
test_expect_success 'reject truncated inline data' ' |
||||
printf "SVNQ%b%s" "QQQQ\003" "b" | q_to_nul >inline.trunc && |
||||
test_must_fail test-svn-fe -d preimage inline.trunc 10 |
||||
' |
||||
|
||||
test_expect_success 'reject truncated inline data (after instruction section)' ' |
||||
printf "SVNQ%b%b%s" "QQ\001\001\003" "\0201" "b" | q_to_nul >insn.trunc && |
||||
test_must_fail test-svn-fe -d preimage insn.trunc 11 |
||||
' |
||||
|
||||
test_expect_success 'copyfrom_data' ' |
||||
echo hi >expect && |
||||
printf "SVNQ%b%b%b" "QQ\003\001\003" "\0203" "hi\n" | q_to_nul >copydat && |
||||
test-svn-fe -d preimage copydat 13 >actual && |
||||
test_cmp expect actual |
||||
' |
||||
|
||||
test_expect_success 'multiple copyfrom_data' ' |
||||
echo hi >expect && |
||||
printf "SVNQ%b%b%b%b%b" "QQ\003\002\003" "\0201\0202" "hi\n" \ |
||||
"QQQ\002Q" "\0200Q" | q_to_nul >copy.multi && |
||||
len=$(wc -c <copy.multi) && |
||||
test-svn-fe -d preimage copy.multi $len >actual && |
||||
test_cmp expect actual |
||||
' |
||||
|
||||
test_expect_success 'incomplete multiple insn' ' |
||||
printf "SVNQ%b%b%b" "QQ\003\002\003" "\0203\0200" "hi\n" | |
||||
q_to_nul >copy.partial && |
||||
len=$(wc -c <copy.partial) && |
||||
test_must_fail test-svn-fe -d preimage copy.partial $len |
||||
' |
||||
|
||||
test_expect_success 'catch attempt to copy missing data' ' |
||||
printf "SVNQ%b%b%s%b%s" "QQ\002\002\001" "\0201\0201" "X" \ |
||||
"QQQQ\002" "YZ" | |
||||
q_to_nul >copy.incomplete && |
||||
len=$(wc -c <copy.incomplete) && |
||||
test_must_fail test-svn-fe -d preimage copy.incomplete $len |
||||
' |
||||
|
||||
test_expect_success 'copyfrom target to repeat data' ' |
||||
printf foofoo >expect && |
||||
printf "SVNQ%b%b%s" "QQ\006\004\003" "\0203\0100\003Q" "foo" | |
||||
q_to_nul >copytarget.repeat && |
||||
len=$(wc -c <copytarget.repeat) && |
||||
test-svn-fe -d preimage copytarget.repeat $len >actual && |
||||
test_cmp expect actual |
||||
' |
||||
|
||||
test_expect_success 'copyfrom target out of order' ' |
||||
printf foooof >expect && |
||||
printf "SVNQ%b%b%s" \ |
||||
"QQ\006\007\003" "\0203\0101\002\0101\001\0101Q" "foo" | |
||||
q_to_nul >copytarget.reverse && |
||||
len=$(wc -c <copytarget.reverse) && |
||||
test-svn-fe -d preimage copytarget.reverse $len >actual && |
||||
test_cmp expect actual |
||||
' |
||||
|
||||
test_expect_success 'catch copyfrom future' ' |
||||
printf "SVNQ%b%b%s" "QQ\004\004\003" "\0202\0101\002\0201" "XYZ" | |
||||
q_to_nul >copytarget.infuture && |
||||
len=$(wc -c <copytarget.infuture) && |
||||
test_must_fail test-svn-fe -d preimage copytarget.infuture $len |
||||
' |
||||
|
||||
test_expect_success 'copy to sustain' ' |
||||
printf XYXYXYXYXYXZ >expect && |
||||
printf "SVNQ%b%b%s" "QQ\014\004\003" "\0202\0111Q\0201" "XYZ" | |
||||
q_to_nul >copytarget.sustain && |
||||
len=$(wc -c <copytarget.sustain) && |
||||
test-svn-fe -d preimage copytarget.sustain $len >actual && |
||||
test_cmp expect actual |
||||
' |
||||
|
||||
test_expect_success 'catch copy that overflows' ' |
||||
printf "SVNQ%b%b%s" "QQ\003\003\001" "\0201\0177Q" X | |
||||
q_to_nul >copytarget.overflow && |
||||
len=$(wc -c <copytarget.overflow) && |
||||
test_must_fail test-svn-fe -d preimage copytarget.overflow $len |
||||
' |
||||
|
||||
test_expect_success 'copyfrom source' ' |
||||
printf foo >expect && |
||||
printf "SVNQ%b%b" "Q\003\003\002Q" "\003Q" | q_to_nul >copysource.all && |
||||
test-svn-fe -d preimage copysource.all 11 >actual && |
||||
test_cmp expect actual |
||||
' |
||||
|
||||
test_expect_success 'copy backwards' ' |
||||
printf oof >expect && |
||||
printf "SVNQ%b%b" "Q\003\003\006Q" "\001\002\001\001\001Q" | |
||||
q_to_nul >copysource.rev && |
||||
test-svn-fe -d preimage copysource.rev 15 >actual && |
||||
test_cmp expect actual |
||||
' |
||||
|
||||
test_expect_success 'offsets are relative to window' ' |
||||
printf fo >expect && |
||||
printf "SVNQ%b%b%b%b" "Q\003\001\002Q" "\001Q" \ |
||||
"\002\001\001\002Q" "\001Q" | |
||||
q_to_nul >copysource.two && |
||||
test-svn-fe -d preimage copysource.two 18 >actual && |
||||
test_cmp expect actual |
||||
' |
||||
|
||||
test_expect_success 'example from notes/svndiff' ' |
||||
printf aaaaccccdddddddd >expect && |
||||
printf aaaabbbbcccc >source && |
||||
printf "SVNQ%b%b%s" "Q\014\020\007\001" \ |
||||
"\004Q\004\010\0201\0107\010" d | |
||||
q_to_nul >delta.example && |
||||
len=$(wc -c <delta.example) && |
||||
test-svn-fe -d source delta.example $len >actual && |
||||
test_cmp expect actual |
||||
' |
||||
|
||||
test_done |
||||
@ -1,116 +0,0 @@
@@ -1,116 +0,0 @@
|
||||
/* |
||||
* test-obj-pool.c: code to exercise the svn importer's object pool |
||||
*/ |
||||
|
||||
#include "cache.h" |
||||
#include "vcs-svn/obj_pool.h" |
||||
|
||||
enum pool { POOL_ONE, POOL_TWO }; |
||||
obj_pool_gen(one, int, 1) |
||||
obj_pool_gen(two, int, 4096) |
||||
|
||||
static uint32_t strtouint32(const char *s) |
||||
{ |
||||
char *end; |
||||
uintmax_t n = strtoumax(s, &end, 10); |
||||
if (*s == '\0' || (*end != '\n' && *end != '\0')) |
||||
die("invalid offset: %s", s); |
||||
return (uint32_t) n; |
||||
} |
||||
|
||||
static void handle_command(const char *command, enum pool pool, const char *arg) |
||||
{ |
||||
switch (*command) { |
||||
case 'a': |
||||
if (!prefixcmp(command, "alloc ")) { |
||||
uint32_t n = strtouint32(arg); |
||||
printf("%"PRIu32"\n", |
||||
pool == POOL_ONE ? |
||||
one_alloc(n) : two_alloc(n)); |
||||
return; |
||||
} |
||||
case 'c': |
||||
if (!prefixcmp(command, "commit ")) { |
||||
pool == POOL_ONE ? one_commit() : two_commit(); |
||||
return; |
||||
} |
||||
if (!prefixcmp(command, "committed ")) { |
||||
printf("%"PRIu32"\n", |
||||
pool == POOL_ONE ? |
||||
one_pool.committed : two_pool.committed); |
||||
return; |
||||
} |
||||
case 'f': |
||||
if (!prefixcmp(command, "free ")) { |
||||
uint32_t n = strtouint32(arg); |
||||
pool == POOL_ONE ? one_free(n) : two_free(n); |
||||
return; |
||||
} |
||||
case 'n': |
||||
if (!prefixcmp(command, "null ")) { |
||||
printf("%"PRIu32"\n", |
||||
pool == POOL_ONE ? |
||||
one_offset(NULL) : two_offset(NULL)); |
||||
return; |
||||
} |
||||
case 'o': |
||||
if (!prefixcmp(command, "offset ")) { |
||||
uint32_t n = strtouint32(arg); |
||||
printf("%"PRIu32"\n", |
||||
pool == POOL_ONE ? |
||||
one_offset(one_pointer(n)) : |
||||
two_offset(two_pointer(n))); |
||||
return; |
||||
} |
||||
case 'r': |
||||
if (!prefixcmp(command, "reset ")) { |
||||
pool == POOL_ONE ? one_reset() : two_reset(); |
||||
return; |
||||
} |
||||
case 's': |
||||
if (!prefixcmp(command, "set ")) { |
||||
uint32_t n = strtouint32(arg); |
||||
if (pool == POOL_ONE) |
||||
*one_pointer(n) = 1; |
||||
else |
||||
*two_pointer(n) = 1; |
||||
return; |
||||
} |
||||
case 't': |
||||
if (!prefixcmp(command, "test ")) { |
||||
uint32_t n = strtouint32(arg); |
||||
printf("%d\n", pool == POOL_ONE ? |
||||
*one_pointer(n) : *two_pointer(n)); |
||||
return; |
||||
} |
||||
default: |
||||
die("unrecognized command: %s", command); |
||||
} |
||||
} |
||||
|
||||
static void handle_line(const char *line) |
||||
{ |
||||
const char *arg = strchr(line, ' '); |
||||
enum pool pool; |
||||
|
||||
if (arg && !prefixcmp(arg + 1, "one")) |
||||
pool = POOL_ONE; |
||||
else if (arg && !prefixcmp(arg + 1, "two")) |
||||
pool = POOL_TWO; |
||||
else |
||||
die("no pool specified: %s", line); |
||||
|
||||
handle_command(line, pool, arg + strlen("one ")); |
||||
} |
||||
|
||||
int main(int argc, char *argv[]) |
||||
{ |
||||
struct strbuf sb = STRBUF_INIT; |
||||
if (argc != 1) |
||||
usage("test-obj-str < script"); |
||||
|
||||
while (strbuf_getline(&sb, stdin, '\n') != EOF) |
||||
handle_line(sb.buf); |
||||
strbuf_release(&sb); |
||||
return 0; |
||||
} |
||||
@ -1,31 +0,0 @@
@@ -1,31 +0,0 @@
|
||||
/* |
||||
* test-string-pool.c: code to exercise the svn importer's string pool |
||||
*/ |
||||
|
||||
#include "git-compat-util.h" |
||||
#include "vcs-svn/string_pool.h" |
||||
|
||||
int main(int argc, char *argv[]) |
||||
{ |
||||
const uint32_t unequal = pool_intern("does not equal"); |
||||
const uint32_t equal = pool_intern("equals"); |
||||
uint32_t buf[3]; |
||||
uint32_t n; |
||||
|
||||
if (argc != 2) |
||||
usage("test-string-pool <string>,<string>"); |
||||
|
||||
n = pool_tok_seq(3, buf, ",-", argv[1]); |
||||
if (n >= 3) |
||||
die("too many strings"); |
||||
if (n <= 1) |
||||
die("too few strings"); |
||||
|
||||
buf[2] = buf[1]; |
||||
buf[1] = (buf[0] == buf[2]) ? equal : unequal; |
||||
pool_print_seq(3, buf, ' ', stdout); |
||||
fputc('\n', stdout); |
||||
|
||||
pool_reset(); |
||||
return 0; |
||||
} |
||||
@ -1,70 +0,0 @@
@@ -1,70 +0,0 @@
|
||||
/* |
||||
* test-treap.c: code to exercise the svn importer's treap structure |
||||
*/ |
||||
|
||||
#include "cache.h" |
||||
#include "vcs-svn/obj_pool.h" |
||||
#include "vcs-svn/trp.h" |
||||
|
||||
struct int_node { |
||||
uintmax_t n; |
||||
struct trp_node children; |
||||
}; |
||||
|
||||
obj_pool_gen(node, struct int_node, 3) |
||||
|
||||
static int node_cmp(struct int_node *a, struct int_node *b) |
||||
{ |
||||
return (a->n > b->n) - (a->n < b->n); |
||||
} |
||||
|
||||
trp_gen(static, treap_, struct int_node, children, node, node_cmp) |
||||
|
||||
static void strtonode(struct int_node *item, const char *s) |
||||
{ |
||||
char *end; |
||||
item->n = strtoumax(s, &end, 10); |
||||
if (*s == '\0' || (*end != '\n' && *end != '\0')) |
||||
die("invalid integer: %s", s); |
||||
} |
||||
|
||||
int main(int argc, char *argv[]) |
||||
{ |
||||
struct strbuf sb = STRBUF_INIT; |
||||
struct trp_root root = { ~0U }; |
||||
uint32_t item; |
||||
|
||||
if (argc != 1) |
||||
usage("test-treap < ints"); |
||||
|
||||
while (strbuf_getline(&sb, stdin, '\n') != EOF) { |
||||
struct int_node *node = node_pointer(node_alloc(1)); |
||||
|
||||
item = node_offset(node); |
||||
strtonode(node, sb.buf); |
||||
node = treap_insert(&root, node_pointer(item)); |
||||
if (node_offset(node) != item) |
||||
die("inserted %"PRIu32" in place of %"PRIu32"", |
||||
node_offset(node), item); |
||||
} |
||||
|
||||
item = node_offset(treap_first(&root)); |
||||
while (~item) { |
||||
uint32_t next; |
||||
struct int_node *tmp = node_pointer(node_alloc(1)); |
||||
|
||||
tmp->n = node_pointer(item)->n; |
||||
next = node_offset(treap_next(&root, node_pointer(item))); |
||||
|
||||
treap_remove(&root, node_pointer(item)); |
||||
item = node_offset(treap_nsearch(&root, tmp)); |
||||
|
||||
if (item != next && (!~item || node_pointer(item)->n != tmp->n)) |
||||
die("found %"PRIuMAX" in place of %"PRIuMAX"", |
||||
~item ? node_pointer(item)->n : ~(uintmax_t) 0, |
||||
~next ? node_pointer(next)->n : ~(uintmax_t) 0); |
||||
printf("%"PRIuMAX"\n", tmp->n); |
||||
} |
||||
node_reset(); |
||||
return 0; |
||||
} |
||||
@ -1,16 +1,28 @@
@@ -1,16 +1,28 @@
|
||||
#ifndef FAST_EXPORT_H_ |
||||
#define FAST_EXPORT_H_ |
||||
|
||||
#include "line_buffer.h" |
||||
struct strbuf; |
||||
struct line_buffer; |
||||
|
||||
void fast_export_delete(uint32_t depth, uint32_t *path); |
||||
void fast_export_modify(uint32_t depth, uint32_t *path, uint32_t mode, |
||||
uint32_t mark); |
||||
void fast_export_commit(uint32_t revision, const char *author, |
||||
void fast_export_init(int fd); |
||||
void fast_export_deinit(void); |
||||
void fast_export_reset(void); |
||||
|
||||
void fast_export_delete(const char *path); |
||||
void fast_export_modify(const char *path, uint32_t mode, const char *dataref); |
||||
void fast_export_begin_commit(uint32_t revision, const char *author, |
||||
const struct strbuf *log, const char *uuid, |
||||
const char *url, unsigned long timestamp); |
||||
void fast_export_blob(uint32_t mode, uint32_t mark, uint32_t len, |
||||
struct line_buffer *input); |
||||
void fast_export_end_commit(uint32_t revision); |
||||
void fast_export_data(uint32_t mode, uint32_t len, struct line_buffer *input); |
||||
void fast_export_blob_delta(uint32_t mode, |
||||
uint32_t old_mode, const char *old_data, |
||||
uint32_t len, struct line_buffer *input); |
||||
|
||||
/* If there is no such file at that rev, returns -1, errno == ENOENT. */ |
||||
int fast_export_ls_rev(uint32_t rev, const char *path, |
||||
uint32_t *mode_out, struct strbuf *dataref_out); |
||||
int fast_export_ls(const char *path, |
||||
uint32_t *mode_out, struct strbuf *dataref_out); |
||||
|
||||
#endif |
||||
|
||||
@ -1,61 +0,0 @@
@@ -1,61 +0,0 @@
|
||||
/* |
||||
* Licensed under a two-clause BSD-style license. |
||||
* See LICENSE for details. |
||||
*/ |
||||
|
||||
#ifndef OBJ_POOL_H_ |
||||
#define OBJ_POOL_H_ |
||||
|
||||
#include "git-compat-util.h" |
||||
|
||||
#define MAYBE_UNUSED __attribute__((__unused__)) |
||||
|
||||
#define obj_pool_gen(pre, obj_t, initial_capacity) \ |
||||
static struct { \ |
||||
uint32_t committed; \ |
||||
uint32_t size; \ |
||||
uint32_t capacity; \ |
||||
obj_t *base; \ |
||||
} pre##_pool = {0, 0, 0, NULL}; \ |
||||
static MAYBE_UNUSED uint32_t pre##_alloc(uint32_t count) \ |
||||
{ \ |
||||
uint32_t offset; \ |
||||
if (pre##_pool.size + count > pre##_pool.capacity) { \ |
||||
while (pre##_pool.size + count > pre##_pool.capacity) \ |
||||
if (pre##_pool.capacity) \ |
||||
pre##_pool.capacity *= 2; \ |
||||
else \ |
||||
pre##_pool.capacity = initial_capacity; \ |
||||
pre##_pool.base = realloc(pre##_pool.base, \ |
||||
pre##_pool.capacity * sizeof(obj_t)); \ |
||||
} \ |
||||
offset = pre##_pool.size; \ |
||||
pre##_pool.size += count; \ |
||||
return offset; \ |
||||
} \ |
||||
static MAYBE_UNUSED void pre##_free(uint32_t count) \ |
||||
{ \ |
||||
pre##_pool.size -= count; \ |
||||
} \ |
||||
static MAYBE_UNUSED uint32_t pre##_offset(obj_t *obj) \ |
||||
{ \ |
||||
return obj == NULL ? ~0 : obj - pre##_pool.base; \ |
||||
} \ |
||||
static MAYBE_UNUSED obj_t *pre##_pointer(uint32_t offset) \ |
||||
{ \ |
||||
return offset >= pre##_pool.size ? NULL : &pre##_pool.base[offset]; \ |
||||
} \ |
||||
static MAYBE_UNUSED void pre##_commit(void) \ |
||||
{ \ |
||||
pre##_pool.committed = pre##_pool.size; \ |
||||
} \ |
||||
static MAYBE_UNUSED void pre##_reset(void) \ |
||||
{ \ |
||||
free(pre##_pool.base); \ |
||||
pre##_pool.base = NULL; \ |
||||
pre##_pool.size = 0; \ |
||||
pre##_pool.capacity = 0; \ |
||||
pre##_pool.committed = 0; \ |
||||
} |
||||
|
||||
#endif |
||||
@ -0,0 +1,79 @@
@@ -0,0 +1,79 @@
|
||||
/* |
||||
* Licensed under a two-clause BSD-style license. |
||||
* See LICENSE for details. |
||||
*/ |
||||
|
||||
#include "git-compat-util.h" |
||||
#include "sliding_window.h" |
||||
#include "line_buffer.h" |
||||
#include "strbuf.h" |
||||
|
||||
static int input_error(struct line_buffer *file) |
||||
{ |
||||
if (!buffer_ferror(file)) |
||||
return error("delta preimage ends early"); |
||||
return error("cannot read delta preimage: %s", strerror(errno)); |
||||
} |
||||
|
||||
static int skip_or_whine(struct line_buffer *file, off_t gap) |
||||
{ |
||||
if (buffer_skip_bytes(file, gap) != gap) |
||||
return input_error(file); |
||||
return 0; |
||||
} |
||||
|
||||
static int read_to_fill_or_whine(struct line_buffer *file, |
||||
struct strbuf *buf, size_t width) |
||||
{ |
||||
buffer_read_binary(file, buf, width - buf->len); |
||||
if (buf->len != width) |
||||
return input_error(file); |
||||
return 0; |
||||
} |
||||
|
||||
static int check_overflow(off_t a, size_t b) |
||||
{ |
||||
if (b > maximum_signed_value_of_type(off_t)) |
||||
return error("unrepresentable length in delta: " |
||||
"%"PRIuMAX" > OFF_MAX", (uintmax_t) b); |
||||
if (signed_add_overflows(a, (off_t) b)) |
||||
return error("unrepresentable offset in delta: " |
||||
"%"PRIuMAX" + %"PRIuMAX" > OFF_MAX", |
||||
(uintmax_t) a, (uintmax_t) b); |
||||
return 0; |
||||
} |
||||
|
||||
int move_window(struct sliding_view *view, off_t off, size_t width) |
||||
{ |
||||
off_t file_offset; |
||||
assert(view); |
||||
assert(view->width <= view->buf.len); |
||||
assert(!check_overflow(view->off, view->buf.len)); |
||||
|
||||
if (check_overflow(off, width)) |
||||
return -1; |
||||
if (off < view->off || off + width < view->off + view->width) |
||||
return error("invalid delta: window slides left"); |
||||
if (view->max_off >= 0 && view->max_off < off + width) |
||||
return error("delta preimage ends early"); |
||||
|
||||
file_offset = view->off + view->buf.len; |
||||
if (off < file_offset) { |
||||
/* Move the overlapping region into place. */ |
||||
strbuf_remove(&view->buf, 0, off - view->off); |
||||
} else { |
||||
/* Seek ahead to skip the gap. */ |
||||
if (skip_or_whine(view->file, off - file_offset)) |
||||
return -1; |
||||
strbuf_setlen(&view->buf, 0); |
||||
} |
||||
|
||||
if (view->buf.len > width) |
||||
; /* Already read. */ |
||||
else if (read_to_fill_or_whine(view->file, &view->buf, width)) |
||||
return -1; |
||||
|
||||
view->off = off; |
||||
view->width = width; |
||||
return 0; |
||||
} |
||||
@ -0,0 +1,18 @@
@@ -0,0 +1,18 @@
|
||||
#ifndef SLIDING_WINDOW_H_ |
||||
#define SLIDING_WINDOW_H_ |
||||
|
||||
#include "strbuf.h" |
||||
|
||||
struct sliding_view { |
||||
struct line_buffer *file; |
||||
off_t off; |
||||
size_t width; |
||||
off_t max_off; /* -1 means unlimited */ |
||||
struct strbuf buf; |
||||
}; |
||||
|
||||
#define SLIDING_VIEW_INIT(input, len) { (input), 0, 0, (len), STRBUF_INIT } |
||||
|
||||
extern int move_window(struct sliding_view *view, off_t off, size_t width); |
||||
|
||||
#endif |
||||
@ -1,102 +0,0 @@
@@ -1,102 +0,0 @@
|
||||
/* |
||||
* Licensed under a two-clause BSD-style license. |
||||
* See LICENSE for details. |
||||
*/ |
||||
|
||||
#include "git-compat-util.h" |
||||
#include "trp.h" |
||||
#include "obj_pool.h" |
||||
#include "string_pool.h" |
||||
|
||||
static struct trp_root tree = { ~0U }; |
||||
|
||||
struct node { |
||||
uint32_t offset; |
||||
struct trp_node children; |
||||
}; |
||||
|
||||
/* Two memory pools: one for struct node, and another for strings */ |
||||
obj_pool_gen(node, struct node, 4096) |
||||
obj_pool_gen(string, char, 4096) |
||||
|
||||
static char *node_value(struct node *node) |
||||
{ |
||||
return node ? string_pointer(node->offset) : NULL; |
||||
} |
||||
|
||||
static int node_cmp(struct node *a, struct node *b) |
||||
{ |
||||
return strcmp(node_value(a), node_value(b)); |
||||
} |
||||
|
||||
/* Build a Treap from the node structure (a trp_node w/ offset) */ |
||||
trp_gen(static, tree_, struct node, children, node, node_cmp) |
||||
|
||||
const char *pool_fetch(uint32_t entry) |
||||
{ |
||||
return node_value(node_pointer(entry)); |
||||
} |
||||
|
||||
uint32_t pool_intern(const char *key) |
||||
{ |
||||
/* Canonicalize key */ |
||||
struct node *match = NULL, *node; |
||||
uint32_t key_len; |
||||
if (key == NULL) |
||||
return ~0; |
||||
key_len = strlen(key) + 1; |
||||
node = node_pointer(node_alloc(1)); |
||||
node->offset = string_alloc(key_len); |
||||
strcpy(node_value(node), key); |
||||
match = tree_search(&tree, node); |
||||
if (!match) { |
||||
tree_insert(&tree, node); |
||||
} else { |
||||
node_free(1); |
||||
string_free(key_len); |
||||
node = match; |
||||
} |
||||
return node_offset(node); |
||||
} |
||||
|
||||
uint32_t pool_tok_r(char *str, const char *delim, char **saveptr) |
||||
{ |
||||
char *token = strtok_r(str, delim, saveptr); |
||||
return token ? pool_intern(token) : ~0; |
||||
} |
||||
|
||||
void pool_print_seq(uint32_t len, uint32_t *seq, char delim, FILE *stream) |
||||
{ |
||||
uint32_t i; |
||||
for (i = 0; i < len && ~seq[i]; i++) { |
||||
fputs(pool_fetch(seq[i]), stream); |
||||
if (i < len - 1 && ~seq[i + 1]) |
||||
fputc(delim, stream); |
||||
} |
||||
} |
||||
|
||||
uint32_t pool_tok_seq(uint32_t sz, uint32_t *seq, const char *delim, char *str) |
||||
{ |
||||
char *context = NULL; |
||||
uint32_t token = ~0U; |
||||
uint32_t length; |
||||
|
||||
if (sz == 0) |
||||
return ~0; |
||||
if (str) |
||||
token = pool_tok_r(str, delim, &context); |
||||
for (length = 0; length < sz; length++) { |
||||
seq[length] = token; |
||||
if (token == ~0) |
||||
return length; |
||||
token = pool_tok_r(NULL, delim, &context); |
||||
} |
||||
seq[sz - 1] = ~0; |
||||
return sz; |
||||
} |
||||
|
||||
void pool_reset(void) |
||||
{ |
||||
node_reset(); |
||||
string_reset(); |
||||
} |
||||
@ -1,11 +0,0 @@
@@ -1,11 +0,0 @@
|
||||
#ifndef STRING_POOL_H_ |
||||
#define STRING_POOL_H_ |
||||
|
||||
uint32_t pool_intern(const char *key); |
||||
const char *pool_fetch(uint32_t entry); |
||||
uint32_t pool_tok_r(char *str, const char *delim, char **saveptr); |
||||
void pool_print_seq(uint32_t len, uint32_t *seq, char delim, FILE *stream); |
||||
uint32_t pool_tok_seq(uint32_t sz, uint32_t *seq, const char *delim, char *str); |
||||
void pool_reset(void); |
||||
|
||||
#endif |
||||
@ -1,43 +0,0 @@
@@ -1,43 +0,0 @@
|
||||
string_pool API |
||||
=============== |
||||
|
||||
The string_pool API provides facilities for replacing strings |
||||
with integer keys that can be more easily compared and stored. |
||||
The facilities are designed so that one could teach Git without |
||||
too much trouble to store the information needed for these keys to |
||||
remain valid over multiple executions. |
||||
|
||||
Functions |
||||
--------- |
||||
|
||||
pool_intern:: |
||||
Include a string in the string pool and get its key. |
||||
If that string is already in the pool, retrieves its |
||||
existing key. |
||||
|
||||
pool_fetch:: |
||||
Retrieve the string associated to a given key. |
||||
|
||||
pool_tok_r:: |
||||
Extract the key of the next token from a string. |
||||
Interface mimics strtok_r. |
||||
|
||||
pool_print_seq:: |
||||
Print a sequence of strings named by key to a file, using the |
||||
specified delimiter to separate them. |
||||
|
||||
If NULL (key ~0) appears in the sequence, the sequence ends |
||||
early. |
||||
|
||||
pool_tok_seq:: |
||||
Split a string into tokens, storing the keys of segments |
||||
into a caller-provided array. |
||||
|
||||
Unless sz is 0, the array will always be ~0-terminated. |
||||
If there is not enough room for all the tokens, the |
||||
array holds as many tokens as fit in the entries before |
||||
the terminating ~0. Return value is the index after the |
||||
last token, or sz if the tokens did not fit. |
||||
|
||||
pool_reset:: |
||||
Deallocate storage for the string pool. |
||||
@ -0,0 +1,308 @@
@@ -0,0 +1,308 @@
|
||||
/* |
||||
* Licensed under a two-clause BSD-style license. |
||||
* See LICENSE for details. |
||||
*/ |
||||
|
||||
#include "git-compat-util.h" |
||||
#include "sliding_window.h" |
||||
#include "line_buffer.h" |
||||
#include "svndiff.h" |
||||
|
||||
/* |
||||
* svndiff0 applier |
||||
* |
||||
* See http://svn.apache.org/repos/asf/subversion/trunk/notes/svndiff. |
||||
* |
||||
* svndiff0 ::= 'SVN\0' window* |
||||
* window ::= int int int int int instructions inline_data; |
||||
* instructions ::= instruction*; |
||||
* instruction ::= view_selector int int |
||||
* | copyfrom_data int |
||||
* | packed_view_selector int |
||||
* | packed_copyfrom_data |
||||
* ; |
||||
* view_selector ::= copyfrom_source |
||||
* | copyfrom_target |
||||
* ; |
||||
* copyfrom_source ::= # binary 00 000000; |
||||
* copyfrom_target ::= # binary 01 000000; |
||||
* copyfrom_data ::= # binary 10 000000; |
||||
* packed_view_selector ::= # view_selector OR-ed with 6 bit value; |
||||
* packed_copyfrom_data ::= # copyfrom_data OR-ed with 6 bit value; |
||||
* int ::= highdigit* lowdigit; |
||||
* highdigit ::= # binary 1000 0000 OR-ed with 7 bit value; |
||||
* lowdigit ::= # 7 bit value; |
||||
*/ |
||||
|
||||
#define INSN_MASK 0xc0 |
||||
#define INSN_COPYFROM_SOURCE 0x00 |
||||
#define INSN_COPYFROM_TARGET 0x40 |
||||
#define INSN_COPYFROM_DATA 0x80 |
||||
#define OPERAND_MASK 0x3f |
||||
|
||||
#define VLI_CONTINUE 0x80 |
||||
#define VLI_DIGIT_MASK 0x7f |
||||
#define VLI_BITS_PER_DIGIT 7 |
||||
|
||||
struct window { |
||||
struct sliding_view *in; |
||||
struct strbuf out; |
||||
struct strbuf instructions; |
||||
struct strbuf data; |
||||
}; |
||||
|
||||
#define WINDOW_INIT(w) { (w), STRBUF_INIT, STRBUF_INIT, STRBUF_INIT } |
||||
|
||||
static void window_release(struct window *ctx) |
||||
{ |
||||
strbuf_release(&ctx->out); |
||||
strbuf_release(&ctx->instructions); |
||||
strbuf_release(&ctx->data); |
||||
} |
||||
|
||||
static int write_strbuf(struct strbuf *sb, FILE *out) |
||||
{ |
||||
if (fwrite(sb->buf, 1, sb->len, out) == sb->len) /* Success. */ |
||||
return 0; |
||||
return error("cannot write delta postimage: %s", strerror(errno)); |
||||
} |
||||
|
||||
static int error_short_read(struct line_buffer *input) |
||||
{ |
||||
if (buffer_ferror(input)) |
||||
return error("error reading delta: %s", strerror(errno)); |
||||
return error("invalid delta: unexpected end of file"); |
||||
} |
||||
|
||||
static int read_chunk(struct line_buffer *delta, off_t *delta_len, |
||||
struct strbuf *buf, size_t len) |
||||
{ |
||||
strbuf_reset(buf); |
||||
if (len > *delta_len || |
||||
buffer_read_binary(delta, buf, len) != len) |
||||
return error_short_read(delta); |
||||
*delta_len -= buf->len; |
||||
return 0; |
||||
} |
||||
|
||||
static int read_magic(struct line_buffer *in, off_t *len) |
||||
{ |
||||
static const char magic[] = {'S', 'V', 'N', '\0'}; |
||||
struct strbuf sb = STRBUF_INIT; |
||||
|
||||
if (read_chunk(in, len, &sb, sizeof(magic))) { |
||||
strbuf_release(&sb); |
||||
return -1; |
||||
} |
||||
if (memcmp(sb.buf, magic, sizeof(magic))) { |
||||
strbuf_release(&sb); |
||||
return error("invalid delta: unrecognized file type"); |
||||
} |
||||
strbuf_release(&sb); |
||||
return 0; |
||||
} |
||||
|
||||
static int read_int(struct line_buffer *in, uintmax_t *result, off_t *len) |
||||
{ |
||||
uintmax_t rv = 0; |
||||
off_t sz; |
||||
for (sz = *len; sz; sz--) { |
||||
const int ch = buffer_read_char(in); |
||||
if (ch == EOF) |
||||
break; |
||||
|
||||
rv <<= VLI_BITS_PER_DIGIT; |
||||
rv += (ch & VLI_DIGIT_MASK); |
||||
if (ch & VLI_CONTINUE) |
||||
continue; |
||||
|
||||
*result = rv; |
||||
*len = sz - 1; |
||||
return 0; |
||||
} |
||||
return error_short_read(in); |
||||
} |
||||
|
||||
static int parse_int(const char **buf, size_t *result, const char *end) |
||||
{ |
||||
size_t rv = 0; |
||||
const char *pos; |
||||
for (pos = *buf; pos != end; pos++) { |
||||
unsigned char ch = *pos; |
||||
|
||||
rv <<= VLI_BITS_PER_DIGIT; |
||||
rv += (ch & VLI_DIGIT_MASK); |
||||
if (ch & VLI_CONTINUE) |
||||
continue; |
||||
|
||||
*result = rv; |
||||
*buf = pos + 1; |
||||
return 0; |
||||
} |
||||
return error("invalid delta: unexpected end of instructions section"); |
||||
} |
||||
|
||||
static int read_offset(struct line_buffer *in, off_t *result, off_t *len) |
||||
{ |
||||
uintmax_t val; |
||||
if (read_int(in, &val, len)) |
||||
return -1; |
||||
if (val > maximum_signed_value_of_type(off_t)) |
||||
return error("unrepresentable offset in delta: %"PRIuMAX"", val); |
||||
*result = val; |
||||
return 0; |
||||
} |
||||
|
||||
static int read_length(struct line_buffer *in, size_t *result, off_t *len) |
||||
{ |
||||
uintmax_t val; |
||||
if (read_int(in, &val, len)) |
||||
return -1; |
||||
if (val > SIZE_MAX) |
||||
return error("unrepresentable length in delta: %"PRIuMAX"", val); |
||||
*result = val; |
||||
return 0; |
||||
} |
||||
|
||||
static int copyfrom_source(struct window *ctx, const char **instructions, |
||||
size_t nbytes, const char *insns_end) |
||||
{ |
||||
size_t offset; |
||||
if (parse_int(instructions, &offset, insns_end)) |
||||
return -1; |
||||
if (unsigned_add_overflows(offset, nbytes) || |
||||
offset + nbytes > ctx->in->width) |
||||
return error("invalid delta: copies source data outside view"); |
||||
strbuf_add(&ctx->out, ctx->in->buf.buf + offset, nbytes); |
||||
return 0; |
||||
} |
||||
|
||||
static int copyfrom_target(struct window *ctx, const char **instructions, |
||||
size_t nbytes, const char *instructions_end) |
||||
{ |
||||
size_t offset; |
||||
if (parse_int(instructions, &offset, instructions_end)) |
||||
return -1; |
||||
if (offset >= ctx->out.len) |
||||
return error("invalid delta: copies from the future"); |
||||
for (; nbytes > 0; nbytes--) |
||||
strbuf_addch(&ctx->out, ctx->out.buf[offset++]); |
||||
return 0; |
||||
} |
||||
|
||||
static int copyfrom_data(struct window *ctx, size_t *data_pos, size_t nbytes) |
||||
{ |
||||
const size_t pos = *data_pos; |
||||
if (unsigned_add_overflows(pos, nbytes) || |
||||
pos + nbytes > ctx->data.len) |
||||
return error("invalid delta: copies unavailable inline data"); |
||||
strbuf_add(&ctx->out, ctx->data.buf + pos, nbytes); |
||||
*data_pos += nbytes; |
||||
return 0; |
||||
} |
||||
|
||||
static int parse_first_operand(const char **buf, size_t *out, const char *end) |
||||
{ |
||||
size_t result = (unsigned char) *(*buf)++ & OPERAND_MASK; |
||||
if (result) { /* immediate operand */ |
||||
*out = result; |
||||
return 0; |
||||
} |
||||
return parse_int(buf, out, end); |
||||
} |
||||
|
||||
static int execute_one_instruction(struct window *ctx, |
||||
const char **instructions, size_t *data_pos) |
||||
{ |
||||
unsigned int instruction; |
||||
const char *insns_end = ctx->instructions.buf + ctx->instructions.len; |
||||
size_t nbytes; |
||||
assert(ctx); |
||||
assert(instructions && *instructions); |
||||
assert(data_pos); |
||||
|
||||
instruction = (unsigned char) **instructions; |
||||
if (parse_first_operand(instructions, &nbytes, insns_end)) |
||||
return -1; |
||||
switch (instruction & INSN_MASK) { |
||||
case INSN_COPYFROM_SOURCE: |
||||
return copyfrom_source(ctx, instructions, nbytes, insns_end); |
||||
case INSN_COPYFROM_TARGET: |
||||
return copyfrom_target(ctx, instructions, nbytes, insns_end); |
||||
case INSN_COPYFROM_DATA: |
||||
return copyfrom_data(ctx, data_pos, nbytes); |
||||
default: |
||||
return error("invalid delta: unrecognized instruction"); |
||||
} |
||||
} |
||||
|
||||
static int apply_window_in_core(struct window *ctx) |
||||
{ |
||||
const char *instructions; |
||||
size_t data_pos = 0; |
||||
|
||||
/* |
||||
* Fill ctx->out.buf using data from the source, target, |
||||
* and inline data views. |
||||
*/ |
||||
for (instructions = ctx->instructions.buf; |
||||
instructions != ctx->instructions.buf + ctx->instructions.len; |
||||
) |
||||
if (execute_one_instruction(ctx, &instructions, &data_pos)) |
||||
return -1; |
||||
if (data_pos != ctx->data.len) |
||||
return error("invalid delta: does not copy all inline data"); |
||||
return 0; |
||||
} |
||||
|
||||
static int apply_one_window(struct line_buffer *delta, off_t *delta_len, |
||||
struct sliding_view *preimage, FILE *out) |
||||
{ |
||||
struct window ctx = WINDOW_INIT(preimage); |
||||
size_t out_len; |
||||
size_t instructions_len; |
||||
size_t data_len; |
||||
assert(delta_len); |
||||
|
||||
/* "source view" offset and length already handled; */ |
||||
if (read_length(delta, &out_len, delta_len) || |
||||
read_length(delta, &instructions_len, delta_len) || |
||||
read_length(delta, &data_len, delta_len) || |
||||
read_chunk(delta, delta_len, &ctx.instructions, instructions_len) || |
||||
read_chunk(delta, delta_len, &ctx.data, data_len)) |
||||
goto error_out; |
||||
strbuf_grow(&ctx.out, out_len); |
||||
if (apply_window_in_core(&ctx)) |
||||
goto error_out; |
||||
if (ctx.out.len != out_len) { |
||||
error("invalid delta: incorrect postimage length"); |
||||
goto error_out; |
||||
} |
||||
if (write_strbuf(&ctx.out, out)) |
||||
goto error_out; |
||||
window_release(&ctx); |
||||
return 0; |
||||
error_out: |
||||
window_release(&ctx); |
||||
return -1; |
||||
} |
||||
|
||||
int svndiff0_apply(struct line_buffer *delta, off_t delta_len, |
||||
struct sliding_view *preimage, FILE *postimage) |
||||
{ |
||||
assert(delta && preimage && postimage); |
||||
|
||||
if (read_magic(delta, &delta_len)) |
||||
return -1; |
||||
while (delta_len) { /* For each window: */ |
||||
off_t pre_off; |
||||
size_t pre_len; |
||||
|
||||
if (read_offset(delta, &pre_off, &delta_len) || |
||||
read_length(delta, &pre_len, &delta_len) || |
||||
move_window(preimage, pre_off, pre_len) || |
||||
apply_one_window(delta, &delta_len, preimage, postimage)) |
||||
return -1; |
||||
} |
||||
return 0; |
||||
} |
||||
@ -0,0 +1,10 @@
@@ -0,0 +1,10 @@
|
||||
#ifndef SVNDIFF_H_ |
||||
#define SVNDIFF_H_ |
||||
|
||||
struct line_buffer; |
||||
struct sliding_view; |
||||
|
||||
extern int svndiff0_apply(struct line_buffer *delta, off_t delta_len, |
||||
struct sliding_view *preimage, FILE *postimage); |
||||
|
||||
#endif |
||||
@ -1,237 +0,0 @@
@@ -1,237 +0,0 @@
|
||||
/* |
||||
* C macro implementation of treaps. |
||||
* |
||||
* Usage: |
||||
* #include <stdint.h> |
||||
* #include "trp.h" |
||||
* trp_gen(...) |
||||
* |
||||
* Licensed under a two-clause BSD-style license. |
||||
* See LICENSE for details. |
||||
*/ |
||||
|
||||
#ifndef TRP_H_ |
||||
#define TRP_H_ |
||||
|
||||
#define MAYBE_UNUSED __attribute__((__unused__)) |
||||
|
||||
/* Node structure. */ |
||||
struct trp_node { |
||||
uint32_t trpn_left; |
||||
uint32_t trpn_right; |
||||
}; |
||||
|
||||
/* Root structure. */ |
||||
struct trp_root { |
||||
uint32_t trp_root; |
||||
}; |
||||
|
||||
/* Pointer/Offset conversion. */ |
||||
#define trpn_pointer(a_base, a_offset) (a_base##_pointer(a_offset)) |
||||
#define trpn_offset(a_base, a_pointer) (a_base##_offset(a_pointer)) |
||||
#define trpn_modify(a_base, a_offset) \ |
||||
do { \ |
||||
if ((a_offset) < a_base##_pool.committed) { \ |
||||
uint32_t old_offset = (a_offset);\ |
||||
(a_offset) = a_base##_alloc(1); \ |
||||
*trpn_pointer(a_base, a_offset) = \ |
||||
*trpn_pointer(a_base, old_offset); \ |
||||
} \ |
||||
} while (0) |
||||
|
||||
/* Left accessors. */ |
||||
#define trp_left_get(a_base, a_field, a_node) \ |
||||
(trpn_pointer(a_base, a_node)->a_field.trpn_left) |
||||
#define trp_left_set(a_base, a_field, a_node, a_left) \ |
||||
do { \ |
||||
trpn_modify(a_base, a_node); \ |
||||
trp_left_get(a_base, a_field, a_node) = (a_left); \ |
||||
} while (0) |
||||
|
||||
/* Right accessors. */ |
||||
#define trp_right_get(a_base, a_field, a_node) \ |
||||
(trpn_pointer(a_base, a_node)->a_field.trpn_right) |
||||
#define trp_right_set(a_base, a_field, a_node, a_right) \ |
||||
do { \ |
||||
trpn_modify(a_base, a_node); \ |
||||
trp_right_get(a_base, a_field, a_node) = (a_right); \ |
||||
} while (0) |
||||
|
||||
/* |
||||
* Fibonacci hash function. |
||||
* The multiplier is the nearest prime to (2^32 times (√5 - 1)/2). |
||||
* See Knuth §6.4: volume 3, 3rd ed, p518. |
||||
*/ |
||||
#define trpn_hash(a_node) (uint32_t) (2654435761u * (a_node)) |
||||
|
||||
/* Priority accessors. */ |
||||
#define trp_prio_get(a_node) trpn_hash(a_node) |
||||
|
||||
/* Node initializer. */ |
||||
#define trp_node_new(a_base, a_field, a_node) \ |
||||
do { \ |
||||
trp_left_set(a_base, a_field, (a_node), ~0); \ |
||||
trp_right_set(a_base, a_field, (a_node), ~0); \ |
||||
} while (0) |
||||
|
||||
/* Internal utility macros. */ |
||||
#define trpn_first(a_base, a_field, a_root, r_node) \ |
||||
do { \ |
||||
(r_node) = (a_root); \ |
||||
if ((r_node) == ~0) \ |
||||
return NULL; \ |
||||
while (~trp_left_get(a_base, a_field, (r_node))) \ |
||||
(r_node) = trp_left_get(a_base, a_field, (r_node)); \ |
||||
} while (0) |
||||
|
||||
#define trpn_rotate_left(a_base, a_field, a_node, r_node) \ |
||||
do { \ |
||||
(r_node) = trp_right_get(a_base, a_field, (a_node)); \ |
||||
trp_right_set(a_base, a_field, (a_node), \ |
||||
trp_left_get(a_base, a_field, (r_node))); \ |
||||
trp_left_set(a_base, a_field, (r_node), (a_node)); \ |
||||
} while (0) |
||||
|
||||
#define trpn_rotate_right(a_base, a_field, a_node, r_node) \ |
||||
do { \ |
||||
(r_node) = trp_left_get(a_base, a_field, (a_node)); \ |
||||
trp_left_set(a_base, a_field, (a_node), \ |
||||
trp_right_get(a_base, a_field, (r_node))); \ |
||||
trp_right_set(a_base, a_field, (r_node), (a_node)); \ |
||||
} while (0) |
||||
|
||||
#define trp_gen(a_attr, a_pre, a_type, a_field, a_base, a_cmp) \ |
||||
a_attr a_type MAYBE_UNUSED *a_pre##first(struct trp_root *treap) \ |
||||
{ \ |
||||
uint32_t ret; \ |
||||
trpn_first(a_base, a_field, treap->trp_root, ret); \ |
||||
return trpn_pointer(a_base, ret); \ |
||||
} \ |
||||
a_attr a_type MAYBE_UNUSED *a_pre##next(struct trp_root *treap, a_type *node) \ |
||||
{ \ |
||||
uint32_t ret; \ |
||||
uint32_t offset = trpn_offset(a_base, node); \ |
||||
if (~trp_right_get(a_base, a_field, offset)) { \ |
||||
trpn_first(a_base, a_field, \ |
||||
trp_right_get(a_base, a_field, offset), ret); \ |
||||
} else { \ |
||||
uint32_t tnode = treap->trp_root; \ |
||||
ret = ~0; \ |
||||
while (1) { \ |
||||
int cmp = (a_cmp)(trpn_pointer(a_base, offset), \ |
||||
trpn_pointer(a_base, tnode)); \ |
||||
if (cmp < 0) { \ |
||||
ret = tnode; \ |
||||
tnode = trp_left_get(a_base, a_field, tnode); \ |
||||
} else if (cmp > 0) { \ |
||||
tnode = trp_right_get(a_base, a_field, tnode); \ |
||||
} else { \ |
||||
break; \ |
||||
} \ |
||||
} \ |
||||
} \ |
||||
return trpn_pointer(a_base, ret); \ |
||||
} \ |
||||
a_attr a_type MAYBE_UNUSED *a_pre##search(struct trp_root *treap, a_type *key) \ |
||||
{ \ |
||||
int cmp; \ |
||||
uint32_t ret = treap->trp_root; \ |
||||
while (~ret && (cmp = (a_cmp)(key, trpn_pointer(a_base, ret)))) { \ |
||||
if (cmp < 0) { \ |
||||
ret = trp_left_get(a_base, a_field, ret); \ |
||||
} else { \ |
||||
ret = trp_right_get(a_base, a_field, ret); \ |
||||
} \ |
||||
} \ |
||||
return trpn_pointer(a_base, ret); \ |
||||
} \ |
||||
a_attr a_type MAYBE_UNUSED *a_pre##nsearch(struct trp_root *treap, a_type *key) \ |
||||
{ \ |
||||
int cmp; \ |
||||
uint32_t ret = treap->trp_root; \ |
||||
while (~ret && (cmp = (a_cmp)(key, trpn_pointer(a_base, ret)))) { \ |
||||
if (cmp < 0) { \ |
||||
if (!~trp_left_get(a_base, a_field, ret)) \ |
||||
break; \ |
||||
ret = trp_left_get(a_base, a_field, ret); \ |
||||
} else { \ |
||||
ret = trp_right_get(a_base, a_field, ret); \ |
||||
} \ |
||||
} \ |
||||
return trpn_pointer(a_base, ret); \ |
||||
} \ |
||||
a_attr uint32_t MAYBE_UNUSED a_pre##insert_recurse(uint32_t cur_node, uint32_t ins_node) \ |
||||
{ \ |
||||
if (cur_node == ~0) { \ |
||||
return ins_node; \ |
||||
} else { \ |
||||
uint32_t ret; \ |
||||
int cmp = (a_cmp)(trpn_pointer(a_base, ins_node), \ |
||||
trpn_pointer(a_base, cur_node)); \ |
||||
if (cmp < 0) { \ |
||||
uint32_t left = a_pre##insert_recurse( \ |
||||
trp_left_get(a_base, a_field, cur_node), ins_node); \ |
||||
trp_left_set(a_base, a_field, cur_node, left); \ |
||||
if (trp_prio_get(left) < trp_prio_get(cur_node)) \ |
||||
trpn_rotate_right(a_base, a_field, cur_node, ret); \ |
||||
else \ |
||||
ret = cur_node; \ |
||||
} else { \ |
||||
uint32_t right = a_pre##insert_recurse( \ |
||||
trp_right_get(a_base, a_field, cur_node), ins_node); \ |
||||
trp_right_set(a_base, a_field, cur_node, right); \ |
||||
if (trp_prio_get(right) < trp_prio_get(cur_node)) \ |
||||
trpn_rotate_left(a_base, a_field, cur_node, ret); \ |
||||
else \ |
||||
ret = cur_node; \ |
||||
} \ |
||||
return ret; \ |
||||
} \ |
||||
} \ |
||||
a_attr a_type *MAYBE_UNUSED a_pre##insert(struct trp_root *treap, a_type *node) \ |
||||
{ \ |
||||
uint32_t offset = trpn_offset(a_base, node); \ |
||||
trp_node_new(a_base, a_field, offset); \ |
||||
treap->trp_root = a_pre##insert_recurse(treap->trp_root, offset); \ |
||||
return trpn_pointer(a_base, offset); \ |
||||
} \ |
||||
a_attr uint32_t MAYBE_UNUSED a_pre##remove_recurse(uint32_t cur_node, uint32_t rem_node) \ |
||||
{ \ |
||||
int cmp = a_cmp(trpn_pointer(a_base, rem_node), \ |
||||
trpn_pointer(a_base, cur_node)); \ |
||||
if (cmp == 0) { \ |
||||
uint32_t ret; \ |
||||
uint32_t left = trp_left_get(a_base, a_field, cur_node); \ |
||||
uint32_t right = trp_right_get(a_base, a_field, cur_node); \ |
||||
if (left == ~0) { \ |
||||
if (right == ~0) \ |
||||
return ~0; \ |
||||
} else if (right == ~0 || trp_prio_get(left) < trp_prio_get(right)) { \ |
||||
trpn_rotate_right(a_base, a_field, cur_node, ret); \ |
||||
right = a_pre##remove_recurse(cur_node, rem_node); \ |
||||
trp_right_set(a_base, a_field, ret, right); \ |
||||
return ret; \ |
||||
} \ |
||||
trpn_rotate_left(a_base, a_field, cur_node, ret); \ |
||||
left = a_pre##remove_recurse(cur_node, rem_node); \ |
||||
trp_left_set(a_base, a_field, ret, left); \ |
||||
return ret; \ |
||||
} else if (cmp < 0) { \ |
||||
uint32_t left = a_pre##remove_recurse( \ |
||||
trp_left_get(a_base, a_field, cur_node), rem_node); \ |
||||
trp_left_set(a_base, a_field, cur_node, left); \ |
||||
return cur_node; \ |
||||
} else { \ |
||||
uint32_t right = a_pre##remove_recurse( \ |
||||
trp_right_get(a_base, a_field, cur_node), rem_node); \ |
||||
trp_right_set(a_base, a_field, cur_node, right); \ |
||||
return cur_node; \ |
||||
} \ |
||||
} \ |
||||
a_attr void MAYBE_UNUSED a_pre##remove(struct trp_root *treap, a_type *node) \ |
||||
{ \ |
||||
treap->trp_root = a_pre##remove_recurse(treap->trp_root, \ |
||||
trpn_offset(a_base, node)); \ |
||||
} \ |
||||
|
||||
#endif |
||||
@ -1,109 +0,0 @@
@@ -1,109 +0,0 @@
|
||||
Motivation |
||||
========== |
||||
|
||||
Treaps provide a memory-efficient binary search tree structure. |
||||
Insertion/deletion/search are about as about as fast in the average |
||||
case as red-black trees and the chances of worst-case behavior are |
||||
vanishingly small, thanks to (pseudo-)randomness. The bad worst-case |
||||
behavior is a small price to pay, given that treaps are much simpler |
||||
to implement. |
||||
|
||||
API |
||||
=== |
||||
|
||||
The trp API generates a data structure and functions to handle a |
||||
large growing set of objects stored in a pool. |
||||
|
||||
The caller: |
||||
|
||||
. Specifies parameters for the generated functions with the |
||||
trp_gen(static, foo_, ...) macro. |
||||
|
||||
. Allocates a `struct trp_root` variable and sets it to {~0}. |
||||
|
||||
. Adds new nodes to the set using `foo_insert`. Any pointers |
||||
to existing nodes cannot be relied upon any more, so the caller |
||||
might retrieve them anew with `foo_pointer`. |
||||
|
||||
. Can find a specific item in the set using `foo_search`. |
||||
|
||||
. Can iterate over items in the set using `foo_first` and `foo_next`. |
||||
|
||||
. Can remove an item from the set using `foo_remove`. |
||||
|
||||
Example: |
||||
|
||||
---- |
||||
struct ex_node { |
||||
const char *s; |
||||
struct trp_node ex_link; |
||||
}; |
||||
static struct trp_root ex_base = {~0}; |
||||
obj_pool_gen(ex, struct ex_node, 4096); |
||||
trp_gen(static, ex_, struct ex_node, ex_link, ex, strcmp) |
||||
struct ex_node *item; |
||||
|
||||
item = ex_pointer(ex_alloc(1)); |
||||
item->s = "hello"; |
||||
ex_insert(&ex_base, item); |
||||
item = ex_pointer(ex_alloc(1)); |
||||
item->s = "goodbye"; |
||||
ex_insert(&ex_base, item); |
||||
for (item = ex_first(&ex_base); item; item = ex_next(&ex_base, item)) |
||||
printf("%s\n", item->s); |
||||
---- |
||||
|
||||
Functions |
||||
--------- |
||||
|
||||
trp_gen(attr, foo_, node_type, link_field, pool, cmp):: |
||||
|
||||
Generate a type-specific treap implementation. |
||||
+ |
||||
. The storage class for generated functions will be 'attr' (e.g., `static`). |
||||
. Generated function names are prefixed with 'foo_' (e.g., `treap_`). |
||||
. Treap nodes will be of type 'node_type' (e.g., `struct treap_node`). |
||||
This type must be a struct with at least one `struct trp_node` field |
||||
to point to its children. |
||||
. The field used to access child nodes will be 'link_field'. |
||||
. All treap nodes must lie in the 'pool' object pool. |
||||
. Treap nodes must be totally ordered by the 'cmp' relation, with the |
||||
following prototype: |
||||
+ |
||||
int (*cmp)(node_type \*a, node_type \*b) |
||||
+ |
||||
and returning a value less than, equal to, or greater than zero |
||||
according to the result of comparison. |
||||
|
||||
node_type {asterisk}foo_insert(struct trp_root *treap, node_type \*node):: |
||||
|
||||
Insert node into treap. If inserted multiple times, |
||||
a node will appear in the treap multiple times. |
||||
+ |
||||
The return value is the address of the node within the treap, |
||||
which might differ from `node` if `pool_alloc` had to call |
||||
`realloc` to expand the pool. |
||||
|
||||
void foo_remove(struct trp_root *treap, node_type \*node):: |
||||
|
||||
Remove node from treap. Caller must ensure node is |
||||
present in treap before using this function. |
||||
|
||||
node_type *foo_search(struct trp_root \*treap, node_type \*key):: |
||||
|
||||
Search for a node that matches key. If no match is found, |
||||
result is NULL. |
||||
|
||||
node_type *foo_nsearch(struct trp_root \*treap, node_type \*key):: |
||||
|
||||
Like `foo_search`, but if the key is missing return what |
||||
would be key's successor, were key in treap (NULL if no |
||||
successor). |
||||
|
||||
node_type *foo_first(struct trp_root \*treap):: |
||||
|
||||
Find the first item from the treap, in sorted order. |
||||
|
||||
node_type *foo_next(struct trp_root \*treap, node_type \*node):: |
||||
|
||||
Find the next item. |
||||
Loading…
Reference in new issue