Initial config

1 files changed, 273 insertions, 0 deletions

diff --git a/src/Row.zig b/src/Row.zig
new file mode 100644
index 0000000..633e338
--- /dev/null
+++ b/src/Row.zig
@@ -0,0 +1,273 @@
+const std = @import("std");
+
+const Allocator = std.mem.Allocator;
+const ArrayList = std.ArrayList;
+const Buffer = @import("Buffer.zig");
+const Config = @import("Config.zig");
+const Highlight = @import("highlight.zig").Highlight;
+const Row = @This();
+const StringBuilder = @import("StringBuilder.zig");
+
+allocator: Allocator,
+
+idx: usize,
+
+data: ArrayList(u8),
+rdata: ArrayList(u8),
+hldata: ArrayList(Highlight),
+
+ends_with_open_comment: bool,
+
+pub fn init(allocator: Allocator, idx: usize, data: []const u8) !Row {
+    var self = Row{
+        .allocator = allocator,
+
+        .idx = idx,
+
+        .data = ArrayList(u8).init(allocator),
+        .rdata = ArrayList(u8).init(allocator),
+        .hldata = ArrayList(Highlight).init(allocator),
+
+        .ends_with_open_comment = false,
+    };
+    errdefer self.deinit();
+
+    try self.data.appendSlice(data);
+    return self;
+}
+
+pub fn deinit(self: Row) void {
+    self.data.deinit();
+    self.rdata.deinit();
+    self.hldata.deinit();
+}
+
+pub fn appendString(self: *Row, buf: *Buffer, str: []const u8) !void {
+    try self.data.appendSlice(str);
+    return self.update(buf);
+}
+
+pub fn cleanWhiteSpace(self: *Row, buf: *Buffer) !void {
+    const orig_len = self.data.items.len;
+    while (self.data.items.len > 0) {
+        if (std.ascii.isBlank(self.data.items[self.data.items.len - 1])) {
+            _ = self.data.pop();
+        } else {
+            break;
+        }
+    }
+
+    if (orig_len != self.data.items.len) {
+        buf.dirty = true;
+        try self.update(buf);
+    }
+}
+
+pub fn cxToRx(self: Row, config: Config, cx: usize) usize {
+    var rx: usize = 0;
+    var i: usize = 0;
+    while (i < cx) : (i += 1) {
+        if (self.data.items[i] == '\t') {
+            rx += config.tab_stop - (rx % config.tab_stop);
+        } else {
+            rx += 1;
+        }
+    }
+
+    return rx;
+}
+
+pub fn deleteChar(self: *Row, buf: *Buffer, at: usize) !void {
+    _ = self.data.orderedRemove(at);
+    try self.update(buf);
+}
+
+pub fn indentation(self: Row, allocator: Allocator) ![]u8 {
+    var str = ArrayList(u8).init(allocator);
+    defer str.deinit();
+
+    var idx: usize = 0;
+    while (idx < self.data.items.len) : (idx += 1) {
+        if (!std.ascii.isBlank(self.data.items[idx])) {
+            break;
+        }
+    }
+
+    try str.appendSlice(self.data.items[0..idx]);
+    return str.toOwnedSlice();
+}
+
+pub fn insertChar(self: *Row, buf: *Buffer, at: usize, char: u8) !void {
+    try self.data.insert(at, char);
+    try self.update(buf);
+}
+
+pub fn rxToCx(self: Row, config: Config, rx: usize) usize {
+    if (rx == 0) {
+        return 0;
+    }
+
+    var cur_rx: usize = 0;
+    for (self.data.items) |char, cx| {
+        if (char == '\t') {
+            cur_rx += config.tab_stop - (cur_rx % config.tab_stop);
+        } else {
+            cur_rx += 1;
+        }
+
+        if (cur_rx >= rx) {
+            return cx + 1;
+        }
+    }
+
+    return self.data.items.len;
+}
+
+// TODO: I don't like that this is modifying both row and buffer (parent of row)
+pub fn update(self: *Row, buf: *Buffer) !void {
+    self.rdata.clearRetainingCapacity();
+
+    for (self.data.items) |char| {
+        if (char == '\t') {
+            const len = buf.config.tab_stop - self.rdata.items.len % buf.config.tab_stop;
+            try self.rdata.appendNTimes(' ', len);
+        } else {
+            try self.rdata.append(char);
+        }
+    }
+
+    try self.updateSyntax(buf);
+}
+
+const UpdateSyntaxError = std.mem.Allocator.Error;
+pub fn updateSyntax(self: *Row, buf: *Buffer) UpdateSyntaxError!void {
+    try self.hldata.resize(self.rdata.items.len);
+    std.mem.set(Highlight, self.hldata.items, .normal);
+    if (buf.syntax == null) {
+        return;
+    }
+
+    const syntax = buf.syntax.?;
+    const kw1 = syntax.keywords1;
+    const kw2 = syntax.keywords2;
+
+    var after_sep = true;
+    var in_comment = if (self.idx > 0) buf.rows.items[self.idx - 1].ends_with_open_comment else false;
+    var curr_str_quote: ?u8 = null;
+
+    var i: usize = 0;
+    main_loop: while (i < self.rdata.items.len) {
+        const prev_hl = if (i > 0) self.hldata.items[i - 1] else .normal;
+
+        if (syntax.singleline_comment_start) |scs| {
+            std.debug.assert(scs.len != 0);
+            if (curr_str_quote == null and !in_comment and scs.len + i <= self.rdata.items.len) {
+                if (std.mem.eql(u8, scs, self.rdata.items[i .. (i + scs.len)])) {
+                    std.mem.set(Highlight, self.hldata.items[i..], .comment);
+                    break;
+                }
+            }
+        }
+
+        if (syntax.multiline_comment_start) |mcs| {
+            std.debug.assert(mcs.len != 0);
+            if (syntax.multiline_comment_end) |mce| {
+                std.debug.assert(mce.len != 0);
+                if (curr_str_quote == null) {
+                    if (in_comment) {
+                        self.hldata.items[i] = .comment_ml;
+                        if (mce.len + i <= self.rdata.items.len
+                            and std.mem.eql(u8, mce, self.rdata.items[i .. (i + mce.len)])
+                        ) {
+                            std.mem.set(Highlight, self.hldata.items[i .. (i + mce.len)], .comment_ml);
+                            i += mce.len;
+                            in_comment = false;
+                            after_sep = true;
+                        } else {
+                            i += 1;
+                            continue;
+                        }
+                    } else if (mcs.len + i <= self.rdata.items.len
+                                   and std.mem.eql(u8, mcs, self.rdata.items[i .. (i + mcs.len)])) {
+                        std.mem.set(Highlight, self.hldata.items[i .. (i + mcs.len)], .comment_ml);
+                        i += mcs.len;
+                        in_comment = true;
+                        continue;
+                    }
+                }
+
+            }
+        }
+
+        const c = self.rdata.items[i];
+
+        if (syntax.flags.hl_strings) {
+            if (curr_str_quote) |quote| {
+                self.hldata.items[i] = .string;
+                i += 1;
+                // Pretty dumb way of detecting \" or \' but it works \shrug/
+                if (c == '\\' and i < self.rdata.items.len) {
+                    self.hldata.items[i] = .string;
+                    i += 1;
+                } else if (c == quote) {
+                    curr_str_quote = null;
+                    after_sep = true;
+                }
+
+                continue;
+            } else {
+                // TODO: Move this to syntax struct
+                if (c == '"' or c == '\'') {
+                    curr_str_quote = c;
+                    self.hldata.items[i] = .string;
+                    i += 1;
+                    continue;
+                }
+            }
+        }
+
+        if (syntax.flags.hl_numbers) {
+            if ((std.ascii.isDigit(c) and (after_sep or prev_hl == .number))
+                    or (c == '.' and prev_hl == .number)) {
+                after_sep = false;
+                self.hldata.items[i] = .number;
+                i += 1;
+                continue;
+            }
+        }
+
+        if (after_sep) {
+            for (kw1) |kw| {
+                if (i + kw.len <= self.rdata.items.len
+                    and std.mem.eql(u8, kw, self.rdata.items[i .. (i + kw.len)])
+                    and (i + kw.len == self.rdata.items.len or syntax.isSeparator(self.rdata.items[i + kw.len]))) {
+                    std.mem.set(Highlight, self.hldata.items[i .. (i + kw.len)], .keyword1);
+                    i += kw.len;
+                    after_sep = false;
+                    continue :main_loop;
+                }
+            }
+
+            for (kw2) |kw| {
+                if (i + kw.len <= self.rdata.items.len
+                    and std.mem.eql(u8, kw, self.rdata.items[i .. (i + kw.len)])
+                    and (i + kw.len == self.rdata.items.len or syntax.isSeparator(self.rdata.items[i + kw.len]))) {
+                    std.mem.set(Highlight, self.hldata.items[i .. (i + kw.len)], .keyword2);
+                    i += kw.len;
+                    after_sep = false;
+                    continue :main_loop;
+                }
+            }
+        }
+
+        after_sep = syntax.isSeparator(c);
+        i += 1;
+    }
+
+    if (in_comment != self.ends_with_open_comment) {
+        self.ends_with_open_comment = in_comment;
+        if (self.idx + 1 < buf.rows.items.len) {
+            try buf.rows.items[self.idx + 1].updateSyntax(buf);
+        }
+    }
+}