kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity
Browse Source

Merge branch 'db/delta-applier' into db/text-delta 

* db/delta-applier:
  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

Conflicts:
	Makefile
	vcs-svn/LICENSE
maint
Jonathan Nieder 14 years ago
parent
c19d653c4f c846e41078
commit
e9f3f8b6f4
10 changed files with 741 additions and 26 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 55
      Makefile
  2. 248
      t/t9011-svn-da.sh
  3. 42
      test-svn-fe.c
  4. 2
      vcs-svn/LICENSE
  5. 6
      vcs-svn/line_buffer.c
  6. 2
      vcs-svn/line_buffer.h
  7. 77
      vcs-svn/sliding_window.c
  8. 17
      vcs-svn/sliding_window.h
  9. 308
      vcs-svn/svndiff.c
  10. 10
      vcs-svn/svndiff.h

55
Makefile
Unescape View File

@ -342,6 +342,11 @@ BUILTIN_OBJS =
BUILT_INS = BUILT_INS =
COMPAT_CFLAGS = COMPAT_CFLAGS =
COMPAT_OBJS = COMPAT_OBJS =
XDIFF_H =
XDIFF_OBJS =
VCSSVN_H =
VCSSVN_OBJS =
VCSSVN_TEST_OBJS =
EXTRA_CPPFLAGS = EXTRA_CPPFLAGS =
LIB_H = LIB_H =
LIB_OBJS = LIB_OBJS =
@ -1832,11 +1837,23 @@ GIT_OBJS := $(LIB_OBJS) $(BUILTIN_OBJS) $(PROGRAM_OBJS) $(TEST_OBJS) \
ifndef NO_CURL ifndef NO_CURL
GIT_OBJS += http.o http-walker.o remote-curl.o GIT_OBJS += http.o http-walker.o remote-curl.o
endif endif
XDIFF_OBJS = xdiff/xdiffi.o xdiff/xprepare.o xdiff/xutils.o xdiff/xemit.o \
xdiff/xmerge.o xdiff/xpatience.o XDIFF_OBJS += xdiff/xdiffi.o
VCSSVN_OBJS = vcs-svn/line_buffer.o vcs-svn/repo_tree.o \ XDIFF_OBJS += xdiff/xprepare.o
vcs-svn/fast_export.o vcs-svn/svndump.o XDIFF_OBJS += xdiff/xutils.o
VCSSVN_TEST_OBJS = test-line-buffer.o XDIFF_OBJS += xdiff/xemit.o
XDIFF_OBJS += xdiff/xmerge.o
XDIFF_OBJS += xdiff/xpatience.o

VCSSVN_OBJS += vcs-svn/line_buffer.o
VCSSVN_OBJS += vcs-svn/sliding_window.o
VCSSVN_OBJS += vcs-svn/repo_tree.o
VCSSVN_OBJS += vcs-svn/fast_export.o
VCSSVN_OBJS += vcs-svn/svndiff.o
VCSSVN_OBJS += vcs-svn/svndump.o

VCSSVN_TEST_OBJS += test-line-buffer.o

OBJECTS := $(GIT_OBJS) $(XDIFF_OBJS) $(VCSSVN_OBJS) OBJECTS := $(GIT_OBJS) $(XDIFF_OBJS) $(VCSSVN_OBJS)


dep_files := $(foreach f,$(OBJECTS),$(dir $f).depend/$(notdir $f).d) dep_files := $(foreach f,$(OBJECTS),$(dir $f).depend/$(notdir $f).d)
@ -1955,15 +1972,25 @@ connect.o transport.o http-backend.o: url.h
http-fetch.o http-walker.o remote-curl.o transport.o walker.o: walker.h http-fetch.o http-walker.o remote-curl.o transport.o walker.o: walker.h
http.o http-walker.o http-push.o http-fetch.o remote-curl.o: http.h url.h http.o http-walker.o http-push.o http-fetch.o remote-curl.o: http.h url.h


xdiff-interface.o $(XDIFF_OBJS): \ XDIFF_H += xdiff/xinclude.h
xdiff/xinclude.h xdiff/xmacros.h xdiff/xdiff.h xdiff/xtypes.h \ XDIFF_H += xdiff/xmacros.h
xdiff/xutils.h xdiff/xprepare.h xdiff/xdiffi.h xdiff/xemit.h XDIFF_H += xdiff/xdiff.h

XDIFF_H += xdiff/xtypes.h
$(VCSSVN_OBJS) $(VCSSVN_TEST_OBJS): $(LIB_H) \ XDIFF_H += xdiff/xutils.h
vcs-svn/line_buffer.h vcs-svn/repo_tree.h vcs-svn/fast_export.h \ XDIFF_H += xdiff/xprepare.h
vcs-svn/svndump.h XDIFF_H += xdiff/xdiffi.h

XDIFF_H += xdiff/xemit.h
test-svn-fe.o: vcs-svn/svndump.h
xdiff-interface.o $(XDIFF_OBJS): $(XDIFF_H)

VCSSVN_H += vcs-svn/line_buffer.h
VCSSVN_H += vcs-svn/sliding_window.h
VCSSVN_H += vcs-svn/repo_tree.h
VCSSVN_H += vcs-svn/fast_export.h
VCSSVN_H += vcs-svn/svndiff.h
VCSSVN_H += vcs-svn/svndump.h

$(VCSSVN_OBJS) $(VCSSVN_TEST_OBJS): $(LIB_H) $(VCSSVN_H)
endif endif


exec_cmd.s exec_cmd.o: EXTRA_CPPFLAGS = \ exec_cmd.s exec_cmd.o: EXTRA_CPPFLAGS = \

248
t/t9011-svn-da.sh
Unescape View File

@ -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

42
test-svn-fe.c
Unescape View File

@ -4,15 +4,41 @@


#include "git-compat-util.h" #include "git-compat-util.h"
#include "vcs-svn/svndump.h" #include "vcs-svn/svndump.h"
#include "vcs-svn/svndiff.h"
#include "vcs-svn/sliding_window.h"
#include "vcs-svn/line_buffer.h"


int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
if (argc != 2) static const char test_svnfe_usage[] =
usage("test-svn-fe <file>"); "test-svn-fe (<dumpfile> | [-d] <preimage> <delta> <len>)";
if (svndump_init(argv[1])) if (argc == 2) {
return 1; if (svndump_init(argv[1]))
svndump_read(NULL); return 1;
svndump_deinit(); svndump_read(NULL);
svndump_reset(); svndump_deinit();
return 0; svndump_reset();
return 0;
}
if (argc == 5 && !strcmp(argv[1], "-d")) {
struct line_buffer preimage = LINE_BUFFER_INIT;
struct line_buffer delta = LINE_BUFFER_INIT;
struct sliding_view preimage_view = SLIDING_VIEW_INIT(&preimage);
if (buffer_init(&preimage, argv[2]))
die_errno("cannot open preimage");
if (buffer_init(&delta, argv[3]))
die_errno("cannot open delta");
if (svndiff0_apply(&delta, (off_t) strtoull(argv[4], NULL, 0),
&preimage_view, stdout))
return 1;
if (buffer_deinit(&preimage))
die_errno("cannot close preimage");
if (buffer_deinit(&delta))
die_errno("cannot close delta");
buffer_reset(&preimage);
strbuf_release(&preimage_view.buf);
buffer_reset(&delta);
return 0;
}
usage(test_svnfe_usage);
} }

2
vcs-svn/LICENSE
Unescape View File

@ -1,6 +1,8 @@
Copyright (C) 2010 David Barr <david.barr@cordelta.com>. Copyright (C) 2010 David Barr <david.barr@cordelta.com>.
All rights reserved. All rights reserved.


Copyright (C) 2010 Jonathan Nieder <jrnieder@gmail.com>.

Copyright (C) 2005 Stefan Hegny, hydrografix Consulting GmbH, Copyright (C) 2005 Stefan Hegny, hydrografix Consulting GmbH,
Frankfurt/Main, Germany Frankfurt/Main, Germany
and others, see http://svn2cc.sarovar.org and others, see http://svn2cc.sarovar.org

6
vcs-svn/line_buffer.c
Unescape View File

@ -91,10 +91,10 @@ char *buffer_read_line(struct line_buffer *buf)
return buf->line_buffer; return buf->line_buffer;
} }


void buffer_read_binary(struct line_buffer *buf, size_t buffer_read_binary(struct line_buffer *buf,
struct strbuf *sb, uint32_t size) struct strbuf *sb, size_t size)
{ {
strbuf_fread(sb, size, buf->infile); return strbuf_fread(sb, size, buf->infile);
} }


off_t buffer_copy_bytes(struct line_buffer *buf, off_t nbytes) off_t buffer_copy_bytes(struct line_buffer *buf, off_t nbytes)

2
vcs-svn/line_buffer.h
Unescape View File

@ -23,7 +23,7 @@ long buffer_tmpfile_prepare_to_read(struct line_buffer *buf);
int buffer_ferror(struct line_buffer *buf); int buffer_ferror(struct line_buffer *buf);
char *buffer_read_line(struct line_buffer *buf); char *buffer_read_line(struct line_buffer *buf);
int buffer_read_char(struct line_buffer *buf); int buffer_read_char(struct line_buffer *buf);
void buffer_read_binary(struct line_buffer *buf, struct strbuf *sb, uint32_t len); size_t buffer_read_binary(struct line_buffer *buf, struct strbuf *sb, size_t len);
/* Returns number of bytes read (not necessarily written). */ /* Returns number of bytes read (not necessarily written). */
off_t buffer_copy_bytes(struct line_buffer *buf, off_t len); off_t buffer_copy_bytes(struct line_buffer *buf, off_t len);
off_t buffer_skip_bytes(struct line_buffer *buf, off_t len); off_t buffer_skip_bytes(struct line_buffer *buf, off_t len);

77
vcs-svn/sliding_window.c
Unescape View File

@ -0,0 +1,77 @@
/*
* 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");

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;
}

17
vcs-svn/sliding_window.h
Unescape View File

@ -0,0 +1,17 @@
#ifndef SLIDING_WINDOW_H_
#define SLIDING_WINDOW_H_

#include "strbuf.h"

struct sliding_view {
struct line_buffer *file;
off_t off;
size_t width;
struct strbuf buf;
};

#define SLIDING_VIEW_INIT(input) { (input), 0, 0, STRBUF_INIT }

extern int move_window(struct sliding_view *view, off_t off, size_t width);

#endif

308
vcs-svn/svndiff.c
Unescape View File

@ -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;
}

10
vcs-svn/svndiff.h
Unescape View File

@ -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
Write Preview
Loading…
Cancel
Save