Show More
@@ -15,64 +15,62 b' from . import _bdiff' | |||
|
15 | 15 | ffi = _bdiff.ffi |
|
16 | 16 | lib = _bdiff.lib |
|
17 | 17 | |
|
18 | if True: | |
|
19 | if True: | |
|
20 | def blocks(sa, sb): | |
|
21 | a = ffi.new("struct bdiff_line**") | |
|
22 | b = ffi.new("struct bdiff_line**") | |
|
23 | ac = ffi.new("char[]", str(sa)) | |
|
24 | bc = ffi.new("char[]", str(sb)) | |
|
25 | l = ffi.new("struct bdiff_hunk*") | |
|
26 | try: | |
|
27 | an = lib.bdiff_splitlines(ac, len(sa), a) | |
|
28 | bn = lib.bdiff_splitlines(bc, len(sb), b) | |
|
29 | if not a[0] or not b[0]: | |
|
30 | raise MemoryError | |
|
31 | count = lib.bdiff_diff(a[0], an, b[0], bn, l) | |
|
32 |
|
|
|
33 | raise MemoryError | |
|
34 | rl = [None] * count | |
|
35 | h = l.next | |
|
36 | i = 0 | |
|
37 |
|
|
|
38 | rl[i] = (h.a1, h.a2, h.b1, h.b2) | |
|
39 | h = h.next | |
|
40 | i += 1 | |
|
41 | finally: | |
|
42 | lib.free(a[0]) | |
|
43 | lib.free(b[0]) | |
|
44 | lib.bdiff_freehunks(l.next) | |
|
45 | return rl | |
|
18 | def blocks(sa, sb): | |
|
19 | a = ffi.new("struct bdiff_line**") | |
|
20 | b = ffi.new("struct bdiff_line**") | |
|
21 | ac = ffi.new("char[]", str(sa)) | |
|
22 | bc = ffi.new("char[]", str(sb)) | |
|
23 | l = ffi.new("struct bdiff_hunk*") | |
|
24 | try: | |
|
25 | an = lib.bdiff_splitlines(ac, len(sa), a) | |
|
26 | bn = lib.bdiff_splitlines(bc, len(sb), b) | |
|
27 | if not a[0] or not b[0]: | |
|
28 | raise MemoryError | |
|
29 | count = lib.bdiff_diff(a[0], an, b[0], bn, l) | |
|
30 | if count < 0: | |
|
31 | raise MemoryError | |
|
32 | rl = [None] * count | |
|
33 | h = l.next | |
|
34 | i = 0 | |
|
35 | while h: | |
|
36 | rl[i] = (h.a1, h.a2, h.b1, h.b2) | |
|
37 | h = h.next | |
|
38 | i += 1 | |
|
39 | finally: | |
|
40 | lib.free(a[0]) | |
|
41 | lib.free(b[0]) | |
|
42 | lib.bdiff_freehunks(l.next) | |
|
43 | return rl | |
|
46 | 44 | |
|
47 |
|
|
|
48 |
|
|
|
49 |
|
|
|
50 |
|
|
|
51 |
|
|
|
52 |
|
|
|
53 |
|
|
|
54 |
|
|
|
55 |
|
|
|
56 |
|
|
|
57 |
|
|
|
58 |
|
|
|
59 |
|
|
|
60 |
|
|
|
61 |
|
|
|
62 |
|
|
|
63 |
|
|
|
64 |
|
|
|
65 |
|
|
|
66 |
|
|
|
67 |
|
|
|
68 | (a[0] + h.a1).l - a[0].l, lgt)) | |
|
69 |
|
|
|
70 |
|
|
|
71 |
|
|
|
72 |
|
|
|
45 | def bdiff(sa, sb): | |
|
46 | a = ffi.new("struct bdiff_line**") | |
|
47 | b = ffi.new("struct bdiff_line**") | |
|
48 | ac = ffi.new("char[]", str(sa)) | |
|
49 | bc = ffi.new("char[]", str(sb)) | |
|
50 | l = ffi.new("struct bdiff_hunk*") | |
|
51 | try: | |
|
52 | an = lib.bdiff_splitlines(ac, len(sa), a) | |
|
53 | bn = lib.bdiff_splitlines(bc, len(sb), b) | |
|
54 | if not a[0] or not b[0]: | |
|
55 | raise MemoryError | |
|
56 | count = lib.bdiff_diff(a[0], an, b[0], bn, l) | |
|
57 | if count < 0: | |
|
58 | raise MemoryError | |
|
59 | rl = [] | |
|
60 | h = l.next | |
|
61 | la = lb = 0 | |
|
62 | while h: | |
|
63 | if h.a1 != la or h.b1 != lb: | |
|
64 | lgt = (b[0] + h.b1).l - (b[0] + lb).l | |
|
65 | rl.append(struct.pack(">lll", (a[0] + la).l - a[0].l, | |
|
66 | (a[0] + h.a1).l - a[0].l, lgt)) | |
|
67 | rl.append(str(ffi.buffer((b[0] + lb).l, lgt))) | |
|
68 | la = h.a2 | |
|
69 | lb = h.b2 | |
|
70 | h = h.next | |
|
73 | 71 | |
|
74 |
|
|
|
75 |
|
|
|
76 |
|
|
|
77 |
|
|
|
78 |
|
|
|
72 | finally: | |
|
73 | lib.free(a[0]) | |
|
74 | lib.free(b[0]) | |
|
75 | lib.bdiff_freehunks(l.next) | |
|
76 | return "".join(rl) |
@@ -14,37 +14,35 b' from . import _mpatch' | |||
|
14 | 14 | ffi = _mpatch.ffi |
|
15 | 15 | lib = _mpatch.lib |
|
16 | 16 | |
|
17 | if True: | |
|
18 | if True: | |
|
19 | @ffi.def_extern() | |
|
20 | def cffi_get_next_item(arg, pos): | |
|
21 | all, bins = ffi.from_handle(arg) | |
|
22 | container = ffi.new("struct mpatch_flist*[1]") | |
|
23 | to_pass = ffi.new("char[]", str(bins[pos])) | |
|
24 | all.append(to_pass) | |
|
25 | r = lib.mpatch_decode(to_pass, len(to_pass) - 1, container) | |
|
26 | if r < 0: | |
|
27 | return ffi.NULL | |
|
28 | return container[0] | |
|
17 | @ffi.def_extern() | |
|
18 | def cffi_get_next_item(arg, pos): | |
|
19 | all, bins = ffi.from_handle(arg) | |
|
20 | container = ffi.new("struct mpatch_flist*[1]") | |
|
21 | to_pass = ffi.new("char[]", str(bins[pos])) | |
|
22 | all.append(to_pass) | |
|
23 | r = lib.mpatch_decode(to_pass, len(to_pass) - 1, container) | |
|
24 | if r < 0: | |
|
25 | return ffi.NULL | |
|
26 | return container[0] | |
|
29 | 27 | |
|
30 |
|
|
|
31 |
|
|
|
32 |
|
|
|
33 |
|
|
|
34 |
|
|
|
35 |
|
|
|
36 |
|
|
|
37 |
|
|
|
38 |
|
|
|
39 |
|
|
|
40 |
|
|
|
41 |
|
|
|
42 |
|
|
|
43 |
|
|
|
44 |
|
|
|
45 |
|
|
|
46 |
|
|
|
47 |
|
|
|
48 |
|
|
|
49 |
|
|
|
50 |
|
|
|
28 | def patches(text, bins): | |
|
29 | lgt = len(bins) | |
|
30 | all = [] | |
|
31 | if not lgt: | |
|
32 | return text | |
|
33 | arg = (all, bins) | |
|
34 | patch = lib.mpatch_fold(ffi.new_handle(arg), | |
|
35 | lib.cffi_get_next_item, 0, lgt) | |
|
36 | if not patch: | |
|
37 | raise mpatchError("cannot decode chunk") | |
|
38 | outlen = lib.mpatch_calcsize(len(text), patch) | |
|
39 | if outlen < 0: | |
|
40 | lib.mpatch_lfree(patch) | |
|
41 | raise mpatchError("inconsistency detected") | |
|
42 | buf = ffi.new("char[]", outlen) | |
|
43 | if lib.mpatch_apply(buf, text, len(text), patch) < 0: | |
|
44 | lib.mpatch_lfree(patch) | |
|
45 | raise mpatchError("error applying patches") | |
|
46 | res = ffi.buffer(buf, outlen)[:] | |
|
47 | lib.mpatch_lfree(patch) | |
|
48 | return res |
General Comments 0
You need to be logged in to leave comments.
Login now