194 lines
7 KiB
Zig
194 lines
7 KiB
Zig
const std = @import("std");
|
|
const tp = @import("thespian");
|
|
const diffz = @import("diffz");
|
|
const Buffer = @import("Buffer");
|
|
const tracy = @import("tracy");
|
|
|
|
const module_name = @typeName(@This());
|
|
|
|
const diff_ = @import("diff.zig");
|
|
const Diff = diff_.LineDiff;
|
|
const Kind = diff_.LineDiffKind;
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
fn text_from_root(root: Buffer.Root, eol_mode: Buffer.EolMode) ![]const u8 {
|
|
var text: std.Io.Writer.Allocating = .init(std.heap.c_allocator);
|
|
defer text.deinit();
|
|
try root.store(&text.writer, eol_mode);
|
|
return text.toOwnedSlice();
|
|
}
|
|
|
|
pub const CallBack = fn (from: tp.pid_ref, data: usize, edits: []Diff) void;
|
|
|
|
pub fn diff_buffer(self: @This(), cb: *const CallBack, cb_data: usize, buffer: *const Buffer) tp.result {
|
|
const eol_mode = buffer.file_eol_mode;
|
|
const text_dst = text_from_root(buffer.root, eol_mode) catch |e| return tp.exit_error(e, @errorReturnTrace());
|
|
errdefer std.heap.c_allocator.free(text_dst);
|
|
const text_src = if (buffer.get_vcs_content()) |vcs_content|
|
|
std.heap.c_allocator.dupe(u8, vcs_content) catch |e| return tp.exit_error(e, @errorReturnTrace())
|
|
else
|
|
text_from_root(buffer.last_save orelse return, eol_mode) catch |e| return tp.exit_error(e, @errorReturnTrace());
|
|
errdefer std.heap.c_allocator.free(text_src);
|
|
const text_dst_ptr: usize = if (text_dst.len > 0) @intFromPtr(text_dst.ptr) else 0;
|
|
const text_src_ptr: usize = if (text_src.len > 0) @intFromPtr(text_src.ptr) else 0;
|
|
if (self.pid) |pid| try pid.send(.{ "D", @intFromPtr(cb), cb_data, text_dst_ptr, text_dst.len, text_src_ptr, text_src.len });
|
|
}
|
|
};
|
|
|
|
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);
|
|
errdefer allocator.destroy(self);
|
|
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 cb_data: usize = 0;
|
|
var text_dst_ptr: usize = 0;
|
|
var text_dst_len: usize = 0;
|
|
var text_src_ptr: usize = 0;
|
|
var text_src_len: usize = 0;
|
|
|
|
return if (try m.match(.{ "D", tp.extract(&cb), tp.extract(&cb_data), tp.extract(&text_dst_ptr), tp.extract(&text_dst_len), tp.extract(&text_src_ptr), tp.extract(&text_src_len) })) blk: {
|
|
const text_dst = if (text_dst_len > 0) @as([*]const u8, @ptrFromInt(text_dst_ptr))[0..text_dst_len] else "";
|
|
const text_src = if (text_src_len > 0) @as([*]const u8, @ptrFromInt(text_src_ptr))[0..text_src_len] else "";
|
|
const cb_: *AsyncDiffer.CallBack = if (cb == 0) return else @ptrFromInt(cb);
|
|
break :blk do_diff_async(from, cb_, cb_data, text_dst, text_src) catch |e| {
|
|
cb_(from, cb_data, &.{});
|
|
break :blk tp.exit_error(e, @errorReturnTrace());
|
|
};
|
|
} else if (try m.match(.{"shutdown"}))
|
|
tp.exit_normal();
|
|
}
|
|
|
|
fn do_diff_async(from: tp.pid_ref, cb: *AsyncDiffer.CallBack, cb_data: usize, text_dst: []const u8, text_src: []const u8) !void {
|
|
defer std.heap.c_allocator.free(text_dst);
|
|
defer std.heap.c_allocator.free(text_src);
|
|
|
|
var arena_ = std.heap.ArenaAllocator.init(allocator);
|
|
defer arena_.deinit();
|
|
const arena = arena_.allocator();
|
|
|
|
const edits = try diff(arena, text_dst, text_src);
|
|
cb(from, cb_data, edits);
|
|
}
|
|
};
|
|
|
|
pub fn diff(allocator: std.mem.Allocator, dst: []const u8, src: []const u8) error{OutOfMemory}![]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 diffs: std.ArrayList(Diff) = .empty;
|
|
errdefer diffs.deinit(allocator);
|
|
|
|
const dmp = diffz.default;
|
|
var diff_list = try diffz.diff(&dmp, arena, src, dst, false);
|
|
try diffz.diffCleanupSemantic(arena, &diff_list);
|
|
|
|
if (diff_list.items.len > 2)
|
|
try diffs.ensureTotalCapacity(allocator, (diff_list.items.len - 1) / 2);
|
|
|
|
var lines_dst: usize = 0;
|
|
var pos_dst: usize = 0;
|
|
var last_offset: usize = 0;
|
|
|
|
for (diff_list.items) |diffz_diff| {
|
|
switch (diffz_diff.operation) {
|
|
.equal => {
|
|
const dist = diffz_diff.text.len;
|
|
pos_dst += dist;
|
|
scan_eol(diffz_diff.text, &lines_dst, &last_offset);
|
|
},
|
|
.insert => {
|
|
const dist = diffz_diff.text.len;
|
|
pos_dst += dist;
|
|
const line_start_dst: usize = lines_dst;
|
|
scan_eol(diffz_diff.text, &lines_dst, &last_offset);
|
|
(try diffs.addOne(allocator)).* = .{
|
|
.kind = .insert,
|
|
.line = line_start_dst,
|
|
.lines = lines_dst - line_start_dst,
|
|
};
|
|
if (last_offset > 0)
|
|
(try diffs.addOne(allocator)).* = .{
|
|
.kind = .modify,
|
|
.line = line_start_dst,
|
|
.lines = 1,
|
|
};
|
|
},
|
|
.delete => {
|
|
pos_dst += 0;
|
|
var lines: usize = 0;
|
|
var diff_offset: usize = 0;
|
|
scan_eol(diffz_diff.text, &lines, &diff_offset);
|
|
(try diffs.addOne(allocator)).* = .{
|
|
.kind = .modify,
|
|
.line = lines_dst,
|
|
.lines = 1,
|
|
};
|
|
if (lines > 0)
|
|
(try diffs.addOne(allocator)).* = .{
|
|
.kind = .delete,
|
|
.line = lines_dst,
|
|
.lines = lines,
|
|
};
|
|
if (lines > 0 and diff_offset > 0)
|
|
(try diffs.addOne(allocator)).* = .{
|
|
.kind = .modify,
|
|
.line = lines_dst,
|
|
.lines = 1,
|
|
};
|
|
},
|
|
}
|
|
}
|
|
return diffs.toOwnedSlice(allocator);
|
|
}
|
|
|
|
fn scan_eol(chars: []const u8, lines: *usize, remain: *usize) void {
|
|
var pos = chars;
|
|
remain.* += pos.len;
|
|
while (pos.len > 0) {
|
|
if (pos[0] == '\n') {
|
|
remain.* = pos.len - 1;
|
|
lines.* += 1;
|
|
}
|
|
pos = pos[1..];
|
|
}
|
|
}
|