Began implementing the funge Field

1 files changed, 178 insertions, 0 deletions

diff --git a/src/field.zig b/src/field.zig
new file mode 100644
index 0000000..4f7bcea
--- /dev/null
+++ b/src/field.zig
@@ -0,0 +1,178 @@
+const std = @import("std");
+
+const Line = struct {
+    x: i64 = 0,
+    data: std.ArrayList(i64),
+    pub fn blank(l: *Line, x: i64) void {
+        const lx = @intCast(i64, l.data.items.len);
+        if (x > l.x and x < l.x + lx - 1) { // just set the value
+            l.data.items[@intCast(usize, x - l.x)] = ' ';
+        } else if (lx == 1) { // this was the last character on the line
+            l.data.items.len = 0;
+        } else if (x == l.x) { // we need to remove leading spaces
+            var i: usize = 1;
+            while (l.data.items[i] == ' ') : (i += 1) {}
+            l.x += @intCast(i64, i);
+            std.mem.copy(i64, l.data.items[0 .. l.data.items.len - i], l.data.items[i..]);
+            l.data.items.len -= i;
+        } else if (x == l.x + lx - 1) { // we need to remove trailing spaces
+            var i: usize = l.data.items.len - 1;
+            while (l.data.items[i - 1] == ' ') : (i -= 1) {}
+            l.data.items.len = i;
+        }
+    }
+    test "blank" {
+        var l = Line.init(std.testing.allocator);
+        defer l.deinit();
+        const initial = [_]i64{ 'b', 'a', '@', 'c', 'd', 'e', 'f' };
+        try l.data.appendSlice(initial[0..]);
+        l.x = -2;
+        l.blank(-3);
+        try std.testing.expectEqualSlices(i64, l.data.items, initial[0..]);
+        l.blank(8);
+        try std.testing.expectEqualSlices(i64, l.data.items, initial[0..]);
+        l.blank(0);
+        const zero = [_]i64{ 'b', 'a', ' ', 'c', 'd', 'e', 'f' };
+        try std.testing.expectEqual(l.x, -2);
+        try std.testing.expectEqualSlices(i64, l.data.items, zero[0..]);
+        l.blank(-2);
+        const moins2 = [_]i64{ 'a', ' ', 'c', 'd', 'e', 'f' };
+        try std.testing.expectEqual(l.x, -1);
+        try std.testing.expectEqualSlices(i64, l.data.items, moins2[0..]);
+        l.blank(-1);
+        const moins1 = [_]i64{ 'c', 'd', 'e', 'f' };
+        try std.testing.expectEqual(l.x, 1);
+        try std.testing.expectEqualSlices(i64, l.data.items, moins1[0..]);
+        l.blank(4);
+        const plus4 = [_]i64{ 'c', 'd', 'e' };
+        try std.testing.expectEqual(l.x, 1);
+        try std.testing.expectEqualSlices(i64, l.data.items, plus4[0..]);
+        l.blank(2);
+        const plus2 = [_]i64{ 'c', ' ', 'e' };
+        try std.testing.expectEqual(l.x, 1);
+        try std.testing.expectEqualSlices(i64, l.data.items, plus2[0..]);
+        l.blank(3);
+        const plus3 = [_]i64{'c'};
+        try std.testing.expectEqual(l.x, 1);
+        try std.testing.expectEqualSlices(i64, l.data.items, plus3[0..]);
+        l.blank(1);
+        try std.testing.expectEqual(l.data.items.len, 0);
+    }
+    pub fn deinit(self: *Line) void {
+        self.data.deinit();
+    }
+    pub fn init(allocator: std.mem.Allocator) Line {
+        const c = std.ArrayList(i64).init(allocator);
+        return Line{
+            .data = c,
+        };
+    }
+    pub fn set(l: *Line, x: i64, v: i64) !void {
+        if (l.data.items.len == 0) { // this is en empty line
+            l.x = x;
+            try l.data.append(v);
+            return;
+        }
+        const lx = @intCast(i64, l.data.items.len);
+        if (x >= l.x and x < l.x + lx) { // just set the value
+            l.data.items[@intCast(usize, x - l.x)] = v;
+        } else if (x < l.x) { // we need to shift right and add leading spaces
+            const oldLen = l.data.items.len;
+            l.data.items.len += @intCast(usize, l.x - x);
+            try l.data.ensureUnusedCapacity(l.data.items.len);
+            std.mem.copyBackwards(i64, l.data.items[@intCast(usize, l.x - x)..], l.data.items[0..oldLen]);
+            l.data.items[0] = v;
+            var i: usize = 1;
+            while (i < @intCast(usize, l.x - x)) : (i += 1) {
+                l.data.items[i] = ' ';
+            }
+            l.x = x;
+        } else { // we need to add trailing spaces
+            var i: usize = l.data.items.len;
+            while (i < x - l.x) : (i += 1) {
+                try l.data.append(' ');
+            }
+            try l.data.append(v);
+        }
+    }
+    test "set" {
+        var l = Line.init(std.testing.allocator);
+        defer l.deinit();
+        try l.set(-1, '@');
+        const zero = [_]i64{'@'};
+        try std.testing.expectEqual(l.x, -1);
+        try std.testing.expectEqualSlices(i64, l.data.items, zero[0..]);
+        try l.set(-1, 'a');
+        const a = [_]i64{'a'};
+        try std.testing.expectEqual(l.x, -1);
+        try std.testing.expectEqualSlices(i64, l.data.items, a[0..]);
+        try l.set(0, 'b');
+        const b = [_]i64{ 'a', 'b' };
+        try std.testing.expectEqual(l.x, -1);
+        try std.testing.expectEqualSlices(i64, l.data.items, b[0..]);
+        try l.set(2, 'c');
+        const c = [_]i64{ 'a', 'b', ' ', 'c' };
+        try std.testing.expectEqual(l.x, -1);
+        try std.testing.expectEqualSlices(i64, l.data.items, c[0..]);
+        try l.set(-2, 'd');
+        const d = [_]i64{ 'd', 'a', 'b', ' ', 'c' };
+        try std.testing.expectEqual(l.x, -2);
+        try std.testing.expectEqualSlices(i64, l.data.items, d[0..]);
+        try l.set(-4, 'e');
+        const e = [_]i64{ 'e', ' ', 'd', 'a', 'b', ' ', 'c' };
+        try std.testing.expectEqual(l.x, -4);
+        try std.testing.expectEqualSlices(i64, l.data.items, e[0..]);
+    }
+};
+
+const Field = struct {
+    allocator: std.mem.Allocator,
+    x: i64 = 0,
+    y: i64 = 0,
+    lines: std.ArrayList(Line),
+    lx: usize = 0,
+    pub fn blank(f: *Field, x: i64, y: i64) void {
+        const ly = @intCast(i64, f.lines.items.len);
+        if (y < f.y or y > f.y + ly) return; // outside the field
+        var l = &f.lines.items[@intCast(usize, y - f.y)];
+        if (l.data.items.len == 0) return; // the line is already empty
+        l.blank(x);
+        return; // TODO
+    }
+    pub fn deinit(self: *Field) void {
+        for (self.lines.items) |*l| {
+            l.deinit();
+        }
+        self.lines.deinit();
+    }
+    pub fn init(allocator: std.mem.Allocator) !Field {
+        var lines = std.ArrayList(Line).init(allocator);
+        var line = try lines.addOne();
+        line.* = Line.init(allocator);
+        try line.set(0, '@');
+        return Field{
+            .allocator = allocator,
+            .lines = lines,
+        };
+    }
+    //pub fn load(self: *Field, reader: std.io.Reader) {
+    //    var br = std.io.bufferedReader(reader);
+    //    var leadingSpaces:u64 = 0;
+    //    var trailingSpaces:u64 = 0;
+    //    var lastReadIsCR: bool = false;
+    //}
+    //pub fn set(self: *Field, x: i64, y: i64, v: i64) !void {
+    //    if (v == ' ') return self.blank(x, y);
+    //    return; // TODO
+    //}
+
+    //test "minimal" {
+    //    var f = try Field.init(std.testing.allocator);
+    //    defer f.deinit();
+    //    f.blank(0, 0);
+    //}
+};
+
+test "all" {
+    std.testing.refAllDecls(@This());
+}