264 lines
9.2 KiB
Zig
264 lines
9.2 KiB
Zig
const std = @import("std");
|
|
const tp = @import("thespian");
|
|
const dizzy = @import("dizzy");
|
|
const Buffer = @import("Buffer");
|
|
const tracy = @import("tracy");
|
|
|
|
const module_name = @typeName(@This());
|
|
|
|
pub const Kind = enum { insert, delete };
|
|
pub const Diff = struct {
|
|
kind: Kind,
|
|
line: usize,
|
|
offset: usize,
|
|
start: usize,
|
|
end: usize,
|
|
bytes: []const u8,
|
|
};
|
|
|
|
pub const Edit = struct {
|
|
kind: Kind,
|
|
start: usize,
|
|
end: usize,
|
|
bytes: []const u8,
|
|
};
|
|
|
|
pub fn create() !AsyncDiffer {
|
|
return .{ .pid = try Process.create() };
|
|
}
|
|
|
|
pub const AsyncDiffer = struct {
|
|
pid: ?tp.pid,
|
|
|
|
pub fn deinit(self: *@This()) void {
|
|
if (self.pid) |pid| {
|
|
pid.send(.{"shutdown"}) catch {};
|
|
pid.deinit();
|
|
self.pid = null;
|
|
}
|
|
}
|
|
|
|
pub const CallBack = fn (from: tp.pid_ref, edits: []Diff) void;
|
|
|
|
pub fn diff(self: @This(), cb: *const CallBack, root_dst: Buffer.Root, root_src: Buffer.Root, eol_mode: Buffer.EolMode) tp.result {
|
|
if (self.pid) |pid| try pid.send(.{ "D", @intFromPtr(cb), @intFromPtr(root_dst), @intFromPtr(root_src), @intFromEnum(eol_mode) });
|
|
}
|
|
};
|
|
|
|
const Process = struct {
|
|
receiver: Receiver,
|
|
|
|
const Receiver = tp.Receiver(*Process);
|
|
const allocator = std.heap.c_allocator;
|
|
|
|
pub fn create() !tp.pid {
|
|
const self = try allocator.create(Process);
|
|
self.* = .{
|
|
.receiver = Receiver.init(Process.receive, self),
|
|
};
|
|
return tp.spawn_link(allocator, self, Process.start, module_name);
|
|
}
|
|
|
|
fn start(self: *Process) tp.result {
|
|
errdefer self.deinit();
|
|
tp.receive(&self.receiver);
|
|
}
|
|
|
|
fn deinit(self: *Process) void {
|
|
allocator.destroy(self);
|
|
}
|
|
|
|
fn receive(self: *Process, from: tp.pid_ref, m: tp.message) tp.result {
|
|
errdefer self.deinit();
|
|
|
|
var cb: usize = 0;
|
|
var root_dst: usize = 0;
|
|
var root_src: usize = 0;
|
|
var eol_mode: Buffer.EolModeTag = @intFromEnum(Buffer.EolMode.lf);
|
|
|
|
return if (try m.match(.{ "D", tp.extract(&cb), tp.extract(&root_dst), tp.extract(&root_src), tp.extract(&eol_mode) }))
|
|
do_diff_async(from, cb, root_dst, root_src, @enumFromInt(eol_mode)) catch |e| tp.exit_error(e, @errorReturnTrace())
|
|
else if (try m.match(.{"shutdown"}))
|
|
tp.exit_normal();
|
|
}
|
|
|
|
fn do_diff_async(from_: tp.pid_ref, cb_addr: usize, root_dst_addr: usize, root_src_addr: usize, eol_mode: Buffer.EolMode) !void {
|
|
const cb_: *AsyncDiffer.CallBack = if (cb_addr == 0) return else @ptrFromInt(cb_addr);
|
|
const root_dst: Buffer.Root = if (root_dst_addr == 0) return else @ptrFromInt(root_dst_addr);
|
|
const root_src: Buffer.Root = if (root_src_addr == 0) return else @ptrFromInt(root_src_addr);
|
|
|
|
var arena_ = std.heap.ArenaAllocator.init(allocator);
|
|
defer arena_.deinit();
|
|
const arena = arena_.allocator();
|
|
|
|
var dst = std.ArrayList(u8).init(arena);
|
|
var src = std.ArrayList(u8).init(arena);
|
|
try root_dst.store(dst.writer(), eol_mode);
|
|
try root_src.store(src.writer(), eol_mode);
|
|
|
|
const edits = try diff(arena, dst.items, src.items);
|
|
cb_(from_, edits);
|
|
}
|
|
};
|
|
|
|
pub fn diff(allocator: std.mem.Allocator, dst: []const u8, src: []const u8) ![]Diff {
|
|
var arena_ = std.heap.ArenaAllocator.init(allocator);
|
|
defer arena_.deinit();
|
|
const arena = arena_.allocator();
|
|
const frame = tracy.initZone(@src(), .{ .name = "diff" });
|
|
defer frame.deinit();
|
|
|
|
var dizzy_edits = std.ArrayListUnmanaged(dizzy.Edit){};
|
|
var scratch = std.ArrayListUnmanaged(u32){};
|
|
var diffs = std.ArrayList(Diff).init(allocator);
|
|
|
|
const scratch_len = 4 * (dst.len + src.len) + 2;
|
|
try scratch.ensureTotalCapacity(arena, scratch_len);
|
|
scratch.items.len = scratch_len;
|
|
|
|
try dizzy.PrimitiveSliceDiffer(u8).diff(arena, &dizzy_edits, src, dst, scratch.items);
|
|
|
|
if (dizzy_edits.items.len > 2)
|
|
try diffs.ensureTotalCapacity((dizzy_edits.items.len - 1) / 2);
|
|
|
|
var lines_dst: usize = 0;
|
|
var pos_src: usize = 0;
|
|
var pos_dst: usize = 0;
|
|
var last_offset: usize = 0;
|
|
|
|
for (dizzy_edits.items) |dizzy_edit| {
|
|
switch (dizzy_edit.kind) {
|
|
.equal => {
|
|
const dist = dizzy_edit.range.end - dizzy_edit.range.start;
|
|
pos_src += dist;
|
|
pos_dst += dist;
|
|
scan_char(src[dizzy_edit.range.start..dizzy_edit.range.end], &lines_dst, '\n', &last_offset);
|
|
},
|
|
.insert => {
|
|
const dist = dizzy_edit.range.end - dizzy_edit.range.start;
|
|
pos_src += 0;
|
|
pos_dst += dist;
|
|
const line_start_dst: usize = lines_dst;
|
|
scan_char(dst[dizzy_edit.range.start..dizzy_edit.range.end], &lines_dst, '\n', null);
|
|
(try diffs.addOne()).* = .{
|
|
.kind = .insert,
|
|
.line = line_start_dst,
|
|
.offset = last_offset,
|
|
.start = dizzy_edit.range.start,
|
|
.end = dizzy_edit.range.end,
|
|
.bytes = dst[dizzy_edit.range.start..dizzy_edit.range.end],
|
|
};
|
|
},
|
|
.delete => {
|
|
const dist = dizzy_edit.range.end - dizzy_edit.range.start;
|
|
pos_src += dist;
|
|
pos_dst += 0;
|
|
(try diffs.addOne()).* = .{
|
|
.kind = .delete,
|
|
.line = lines_dst,
|
|
.offset = last_offset,
|
|
.start = dizzy_edit.range.start,
|
|
.end = dizzy_edit.range.end,
|
|
.bytes = src[dizzy_edit.range.start..dizzy_edit.range.end],
|
|
};
|
|
},
|
|
}
|
|
}
|
|
return diffs.toOwnedSlice();
|
|
}
|
|
|
|
pub fn get_edits(allocator: std.mem.Allocator, dst: []const u8, src: []const u8) ![]Edit {
|
|
var arena_ = std.heap.ArenaAllocator.init(allocator);
|
|
defer arena_.deinit();
|
|
const arena = arena_.allocator();
|
|
const frame = tracy.initZone(@src(), .{ .name = "diff" });
|
|
defer frame.deinit();
|
|
|
|
var dizzy_edits = std.ArrayListUnmanaged(dizzy.Edit){};
|
|
var scratch = std.ArrayListUnmanaged(u32){};
|
|
var edits = std.ArrayList(Edit).init(allocator);
|
|
|
|
const scratch_len = 4 * (dst.len + src.len) + 2;
|
|
try scratch.ensureTotalCapacity(arena, scratch_len);
|
|
scratch.items.len = scratch_len;
|
|
|
|
try dizzy.PrimitiveSliceDiffer(u8).diff(arena, &dizzy_edits, src, dst, scratch.items);
|
|
|
|
if (dizzy_edits.items.len > 2)
|
|
try edits.ensureTotalCapacity((dizzy_edits.items.len - 1) / 2);
|
|
|
|
var pos: usize = 0;
|
|
|
|
for (dizzy_edits.items) |dizzy_edit| {
|
|
switch (dizzy_edit.kind) {
|
|
.equal => {
|
|
const dist = dizzy_edit.range.end - dizzy_edit.range.start;
|
|
pos += dist;
|
|
},
|
|
.insert => {
|
|
(try edits.addOne()).* = .{
|
|
.kind = .insert,
|
|
.start = pos,
|
|
.end = pos,
|
|
.bytes = dst[dizzy_edit.range.start..dizzy_edit.range.end],
|
|
};
|
|
const dist = dizzy_edit.range.end - dizzy_edit.range.start;
|
|
pos += dist;
|
|
},
|
|
.delete => {
|
|
const dist = dizzy_edit.range.end - dizzy_edit.range.start;
|
|
pos += 0;
|
|
(try edits.addOne()).* = .{
|
|
.kind = .delete,
|
|
.start = pos,
|
|
.end = pos + dist,
|
|
.bytes = "",
|
|
};
|
|
},
|
|
}
|
|
}
|
|
return edits.toOwnedSlice();
|
|
}
|
|
|
|
fn scan_char(chars: []const u8, lines: *usize, char: u8, last_offset: ?*usize) void {
|
|
var pos = chars;
|
|
while (pos.len > 0) {
|
|
if (pos[0] == char) {
|
|
if (last_offset) |off| off.* = pos.len - 1;
|
|
lines.* += 1;
|
|
}
|
|
pos = pos[1..];
|
|
}
|
|
}
|
|
|
|
pub fn assert_edits_valid(allocator: std.mem.Allocator, dst: []const u8, src: []const u8, edits: []Edit) void {
|
|
const frame = tracy.initZone(@src(), .{ .name = "diff validate" });
|
|
defer frame.deinit();
|
|
var result = std.ArrayListUnmanaged(u8){};
|
|
var tmp = std.ArrayListUnmanaged(u8){};
|
|
defer result.deinit(allocator);
|
|
defer tmp.deinit(allocator);
|
|
result.appendSlice(allocator, src) catch @panic("assert_edits_valid OOM");
|
|
|
|
for (edits) |edit| {
|
|
tmp.clearRetainingCapacity();
|
|
tmp.appendSlice(allocator, result.items[0..edit.start]) catch @panic("assert_edits_valid OOM");
|
|
tmp.appendSlice(allocator, edit.bytes) catch @panic("assert_edits_valid OOM");
|
|
tmp.appendSlice(allocator, result.items[edit.end..]) catch @panic("assert_edits_valid OOM");
|
|
result.clearRetainingCapacity();
|
|
result.appendSlice(allocator, tmp.items) catch @panic("assert_edits_valid OOM");
|
|
}
|
|
|
|
if (!std.mem.eql(u8, dst, result.items)) {
|
|
write_file(src, "bad_diff_src") catch @panic("invalid edits write failed");
|
|
write_file(dst, "bad_diff_dst") catch @panic("invalid edits write failed");
|
|
write_file(result.items, "bad_diff_result") catch @panic("invalid edits write failed");
|
|
@panic("invalid edits");
|
|
}
|
|
}
|
|
|
|
fn write_file(data: []const u8, file_name: []const u8) !void {
|
|
var file = try std.fs.cwd().createFile(file_name, .{ .truncate = true });
|
|
defer file.close();
|
|
return file.writeAll(data);
|
|
}
|