From 3f3972503e2eb08a55f04d336d16765c7403ee74 Mon Sep 17 00:00:00 2001 From: bgk- Date: Tue, 30 Jul 2024 21:09:13 -0700 Subject: [PATCH] Update prints, revert to number as f32 --- src/backend/bytecode.zig | 68 +++++++++++--------------- src/export/main.zig | 2 +- src/export/value.zig | 2 +- src/frontend/ast.zig | 2 +- src/frontend/parser.zig | 2 +- src/runtime/builtins.zig | 18 +++---- src/runtime/vm.zig | 2 +- src/types/value.zig | 101 +++++++++++++++++++++------------------ test/compiler.test.zig | 5 -- test/locale.test.zig | 2 +- test/parser.test.zig | 4 +- test/runner.zig | 4 +- test/vm.test.zig | 60 +++++++++++------------ 13 files changed, 131 insertions(+), 141 deletions(-) diff --git a/src/backend/bytecode.zig b/src/backend/bytecode.zig index 5094093..9688afd 100644 --- a/src/backend/bytecode.zig +++ b/src/backend/bytecode.zig @@ -155,29 +155,28 @@ pub const Bytecode = struct { }; } - pub fn print(code: *Bytecode, writer: anytype) void { - writer.print("\n==BYTECODE==\n", .{}); - printInstructions(writer, code.instructions, code.constants); - writer.print("\n==DEBUG==\n", .{}); - printDebugInfo(writer, code.debug_info); + pub fn print(code: *Bytecode, writer: anytype) !void { + try writer.print("\n==BYTECODE==\n", .{}); + try printInstructions(writer, code.instructions); + try writer.print("\n==DEBUG==\n", .{}); + try printDebugInfo(writer, code.debug_info); } - pub fn printDebugInfo(writer: anytype, debug: []DebugInfo) void { + pub fn printDebugInfo(writer: anytype, debug: []DebugInfo) !void { for (debug) |info| { - writer.print("{s}\n", .{info.file}); + try writer.print("{s}\n", .{info.file}); for (info.ranges.items) |r| { - writer.print(" start: {}, end: {}, line: {}\n", .{ r.start, r.end, r.line }); + try writer.print(" start: {}, end: {}, line: {}\n", .{ r.start, r.end, r.line }); } } } - pub fn printInstructions(writer: anytype, instructions: []const u8, constants: ?[]Value) void { + pub fn printInstructions(writer: anytype, instructions: []const u8) !void { var i: usize = 0; while (i < instructions.len) { - errdefer writer.print("{any}", .{instructions[i..]}); - writer.print("{d:0>4} ", .{i}); + try writer.print("{d:0>4} ", .{i}); const op: OpCode = @enumFromInt(instructions[i]); - writer.print("{s: <16} ", .{op.toString()}); + try writer.print("{s: <16} ", .{op.toString()}); i += 1; switch (op) { .jump, @@ -189,19 +188,19 @@ pub const Bytecode = struct { .visit, => { const dest = std.mem.readVarInt(u32, instructions[i..(i + 4)], .little); - writer.print("{d: >8}", .{dest}); + try writer.print("{d: >8}", .{dest}); i += 4; }, .divert => { var count = instructions[i]; i += 1; const dest = std.mem.readVarInt(u32, instructions[i..(i + 4)], .little); - writer.print("{d: >8} ", .{dest}); + try writer.print("{d: >8} ", .{dest}); i += 4; count -= 1; while (count > 0) : (count -= 1) { const next = std.mem.readVarInt(u32, instructions[i..(i + 4)], .little); - writer.print(" {d}", .{next}); + try writer.print(" {d}", .{next}); i += 4; } }, @@ -212,7 +211,7 @@ pub const Bytecode = struct { .set, => { const dest = std.mem.readVarInt(u16, instructions[i..(i + 2)], .little); - writer.print("{d: >8}", .{dest}); + try writer.print("{d: >8}", .{dest}); i += 2; }, .call, @@ -223,22 +222,13 @@ pub const Bytecode = struct { .set_free, => { const dest = instructions[i]; - writer.print("{d: >8}", .{dest}); + try writer.print("{d: >8}", .{dest}); i += 1; }, .constant => { const index = std.mem.readVarInt(u32, instructions[i..(i + 4)], .little); - writer.print("{d: >8} ", .{index}); + try writer.print("{d: >8} ", .{index}); i += 4; - if (constants) |c| { - if (index >= c.len) { - writer.print("Constant Index {} out of bounds. Total length {}", .{ index, c.len }); - break; - } - var value = c[index]; - writer.print(" = ", .{}); - value.print(writer, c); - } }, .dialogue => { const has_speaker = instructions[i] == 1; @@ -246,9 +236,9 @@ pub const Bytecode = struct { _ = tag_count; const id = std.mem.readVarInt(u32, instructions[(i + 2)..(i + 6)], .little); i += 6; - writer.print("{: >8}", .{has_speaker}); - writer.print(" = ", .{}); - writer.print("{}", .{id}); + try writer.print("{: >8}", .{has_speaker}); + try writer.print(" = ", .{}); + try writer.print("{}", .{id}); }, .choice => { const dest = std.mem.readVarInt(u32, instructions[i..(i + 4)], .little); @@ -263,31 +253,27 @@ pub const Bytecode = struct { const tag_count = instructions[i + 1]; _ = tag_count; i += 1; - writer.print("{d: >8}", .{dest}); - writer.print(" unique: {}", .{is_unique}); + try writer.print("{d: >8}", .{dest}); + try writer.print(" unique: {}", .{is_unique}); }, .string, .closure => { const index = std.mem.readVarInt(u32, instructions[i..(i + 4)], .little); i += 4; - writer.print("{d: >8}", .{index}); + try writer.print("{d: >8}", .{index}); i += 1; - writer.print(" = ", .{}); - if (constants) |c| { - var value = c[index]; - value.print(writer, constants); - } + try writer.print(" = ", .{}); }, .prong => { const index = std.mem.readVarInt(u32, instructions[i..(i + 4)], .little); i += 4; - writer.print("{d: >8}", .{index}); + try writer.print("{d: >8}", .{index}); const count = instructions[i]; i += 1; - writer.print(" = {d}", .{count}); + try writer.print(" = {d}", .{count}); }, else => {}, } - writer.print("\n", .{}); + try writer.print("\n", .{}); } } }; diff --git a/src/export/main.zig b/src/export/main.zig index 443de50..c72a8a3 100644 --- a/src/export/main.zig +++ b/src/export/main.zig @@ -166,11 +166,11 @@ pub export fn setExtern(vm_ptr: usize, name_ptr: [*:0]const u8, exp_value: Expor const runner: *ExportRunner = @fieldParentPtr("runner", vm.runner); const logger = runner.logger; const name = std.mem.sliceTo(name_ptr, 0); - logger.log("Setting {s} to {s}", .{ name, @tagName(exp_value.tag) }, .debug); const value = exp_value.toValue(vm, @ptrFromInt(free_ptr)) catch |err| { logger.log("Could not create Value \"{s}\": {s}", .{ name, @errorName(err) }, .err); return; }; + logger.log("Setting {s} to {s}", .{ name, value }, .debug); vm.setExtern(name, value) catch |err| { logger.log("Could not set Export value \"{s}\": {s}", .{ name, @errorName(err) }, .err); diff --git a/src/export/value.zig b/src/export/value.zig index e820f5d..434592f 100644 --- a/src/export/value.zig +++ b/src/export/value.zig @@ -27,7 +27,7 @@ pub const ExportValue = extern struct { data: extern union { nil: void, bool: bool, - number: f64, + number: f32, string: ExportString, list: extern struct { items: [*c]ExportValue, diff --git a/src/frontend/ast.zig b/src/frontend/ast.zig index 150432e..1d132de 100644 --- a/src/frontend/ast.zig +++ b/src/frontend/ast.zig @@ -32,7 +32,7 @@ pub const Expression = struct { }, @"extern": void, boolean: bool, - number: f64, + number: f32, string: struct { raw: []const u8, value: []const u8, diff --git a/src/frontend/parser.zig b/src/frontend/parser.zig index b79927c..15f1c64 100644 --- a/src/frontend/parser.zig +++ b/src/frontend/parser.zig @@ -364,7 +364,7 @@ pub const Parser = struct { .identifier => try self.identifierExpression(), .number => blk: { const string_number = self.file.source[self.current_token.start..self.current_token.end]; - const value = try std.fmt.parseFloat(f64, string_number); + const value = try std.fmt.parseFloat(f32, string_number); break :blk .{ .token = start, .type = .{ diff --git a/src/runtime/builtins.zig b/src/runtime/builtins.zig index b094a15..c8232a6 100644 --- a/src/runtime/builtins.zig +++ b/src/runtime/builtins.zig @@ -21,10 +21,10 @@ pub const Rnd = struct { }, }; fn builtin(_: *Vm, args: []Value) Value { - if (r == null) r = std.rand.DefaultPrng.init(std.crypto.random.int(u64)); - const start = @as(i64, @intFromFloat(args[0].number)); - const end = @as(i64, @intFromFloat(args[1].number)); - return .{ .number = @as(f64, @floatFromInt(r.?.random().intRangeAtMost(i64, start, end))) }; + if (r == null) r = std.rand.DefaultPrng.init(std.crypto.random.int(u32)); + const start = @as(i32, @intFromFloat(args[0].number)); + const end = @as(i32, @intFromFloat(args[1].number)); + return .{ .number = @as(f32, @floatFromInt(r.?.random().intRangeAtMost(i32, start, end))) }; } }; @@ -47,7 +47,7 @@ const Rnd01 = struct { fn builtin(_: *Vm, args: []Value) Value { if (r == null) r = std.rand.DefaultPrng.init(std.crypto.random.int(u64)); _ = args; - return .{ .number = r.?.random().float(f64) }; + return .{ .number = r.?.random().float(f32) }; } }; @@ -88,9 +88,9 @@ const Print = struct { }, }; fn builtin(_: *Vm, args: []Value) Value { - const writer = std.debug; - args[0].print(writer, null); - writer.print("\n", .{}); + const writer = std.io.getStdErr().writer(); + args[0].print(writer) catch unreachable; + writer.print("\n", .{}) catch unreachable; return Void; } }; @@ -196,7 +196,7 @@ pub const Count = struct { .set => |s| s.count(), else => 0, }; - return .{ .number = @as(f64, @floatFromInt(count)) }; + return .{ .number = @as(f32, @floatFromInt(count)) }; } }; diff --git a/src/runtime/vm.zig b/src/runtime/vm.zig index 714708a..01d61ab 100644 --- a/src/runtime/vm.zig +++ b/src/runtime/vm.zig @@ -717,7 +717,7 @@ pub const Vm = struct { try self.push(builtins.Has.value); try self.push(target); } else if (std.mem.eql(u8, name, "count")) { - try self.push(.{ .number = @as(f64, @floatFromInt(o.data.string.len)) }); + try self.push(.{ .number = @as(f32, @floatFromInt(o.data.string.len)) }); } else return self.fail("Unknown method '{s}' on string. Only \"count\", \"has\" are allowed.", .{index.obj.data.string}); } }, diff --git a/src/types/value.zig b/src/types/value.zig index b63fc2b..b0e7718 100644 --- a/src/types/value.zig +++ b/src/types/value.zig @@ -45,7 +45,7 @@ pub const Value = union(Type) { void: void, nil: void, bool: bool, - number: f64, + number: f32, range: struct { start: i32, end: i32, @@ -205,7 +205,7 @@ pub const Value = union(Type) { pub fn getAtIndex(self: Value, index: usize) Value { return switch (self) { - .range => |r| .{ .number = @as(f64, @floatFromInt(r.start + @as(i64, @intCast(index)))) }, + .range => |r| .{ .number = @as(f32, @floatFromInt(r.start + @as(i64, @intCast(index)))) }, .obj => |o| switch (o.data) { .list => |l| l.items[index], .map => |m| .{ @@ -225,7 +225,7 @@ pub const Value = union(Type) { return switch (T) { bool => if (value) True else False, @TypeOf(null) => Nil, - f64 => .{ .number = value }, + f32 => .{ .number = value }, else => unreachable, }; } @@ -296,7 +296,7 @@ pub const Value = union(Type) { .number => { const val = try reader.readUntilDelimiterAlloc(allocator, 0, 128); defer allocator.free(val); - return .{ .number = try std.fmt.parseFloat(f64, val) }; + return .{ .number = try std.fmt.parseFloat(f32, val) }; }, .visit => { return .{ .visit = try reader.readInt(u32, .little) }; @@ -361,89 +361,98 @@ pub const Value = union(Type) { }; } - pub fn print(self: Value, writer: anytype, constants: ?[]Value) void { + pub fn format( + self: Value, + comptime _: []const u8, + _: std.fmt.FormatOptions, + writer: anytype, + ) !void { + return self.print(writer); + } + + pub fn print(self: Value, writer: anytype) !void { switch (self) { - .number => |n| writer.print("{d:.5}", .{n}), - .bool => |b| writer.print("{}", .{b}), - .nil => writer.print("nil", .{}), - .visit => |v| writer.print("{d}", .{v}), - .enum_value => |e| writer.print("{s}.{s}", .{ e.base.data.@"enum".name, e.base.data.@"enum".values[e.index] }), + .number => |n| try writer.print("{d:.5}", .{n}), + .bool => |b| try writer.print("{}", .{b}), + .nil => try writer.print("nil", .{}), + .visit => |v| try writer.print("{d}", .{v}), + .enum_value => |e| try writer.print("{s}.{s}", .{ e.base.data.@"enum".name, e.base.data.@"enum".values[e.index] }), .obj => |o| { switch (o.data) { - .string => |s| writer.print("{s}", .{s}), + .string => |s| try writer.print("{s}", .{s}), .list => |l| { - writer.print("List{{", .{}); + try writer.print("List{{", .{}); for (l.items, 0..) |item, i| { - item.print(writer, constants); + try item.print(writer); if (i != l.items.len - 1) - writer.print(", ", .{}); + try writer.print(", ", .{}); } - writer.print("}}", .{}); + try writer.print("}}", .{}); }, .map => |m| { - writer.print("Map{{", .{}); + try writer.print("Map{{", .{}); const keys = m.keys(); for (keys, 0..) |k, i| { - k.print(writer, constants); - writer.print(":", .{}); - m.get(k).?.print(writer, constants); + try k.print(writer); + try writer.print(":", .{}); + try m.get(k).?.print(writer); if (i != keys.len - 1) - writer.print(", ", .{}); + try writer.print(", ", .{}); } - writer.print("}}", .{}); + try writer.print("}}", .{}); }, .set => |s| { const keys = s.keys(); - writer.print("Set{{", .{}); + try writer.print("Set{{", .{}); for (keys, 0..) |k, i| { - k.print(writer, constants); + try k.print(writer); if (i != keys.len - 1) - writer.print(", ", .{}); + try writer.print(", ", .{}); } - writer.print("}}", .{}); + try writer.print("}}", .{}); }, .function => |f| { - writer.print("\nfn---\n", .{}); - Bytecode.printInstructions(writer, f.instructions, constants); - writer.print("---", .{}); + try writer.print("\nfn---\n", .{}); + try Bytecode.printInstructions(writer, f.instructions); + try writer.print("---", .{}); }, .closure => |c| { - writer.print("\ncl---\n", .{}); - Bytecode.printInstructions(writer, c.data.function.instructions, constants); - writer.print("---", .{}); + try writer.print("\ncl---\n", .{}); + try Bytecode.printInstructions(writer, c.data.function.instructions); + try writer.print("---", .{}); }, .class => |c| { - writer.print("{s}", .{c.name}); + try writer.print("{s}", .{c.name}); }, .instance => |i| { - writer.print("{s}.instance", .{i.base.data.class.name}); - writer.print(" {{\n", .{}); + try writer.print("{s}.instance", .{i.base.data.class.name}); + try writer.print(" {{\n", .{}); for (i.fields, 0..) |v, idx| { - writer.print(" {s}: ", .{i.base.data.class.fields[idx].name}); - v.print(writer, constants); - writer.print("\n", .{}); + try writer.print(" {s}: ", .{i.base.data.class.fields[idx].name}); + try v.print(writer); + try writer.print("\n", .{}); } - writer.print("}}", .{}); + try writer.print("}}", .{}); }, .@"enum" => |e| { - writer.print("{s}{{", .{e.name}); + try writer.print("{s}{{", .{e.name}); for (e.values, 0..) |val, i| { - writer.print("{s}", .{val}); + try writer.print("{s}", .{val}); if (i != e.values.len - 1) - writer.print(", ", .{}); + try writer.print(", ", .{}); } - writer.print("}}", .{}); + try writer.print("}}", .{}); }, .builtin => |b| { - writer.print("builtin {s}", .{b.name}); + try writer.print("builtin {s}", .{b.name}); }, else => { - writer.print("{s}", .{@tagName(o.data)}); + try writer.print("{s}", .{@tagName(o.data)}); }, } }, - .range => |r| writer.print("{}..{}", .{ r.start, r.end }), - else => writer.print("{s}", .{@tagName(self)}), + .range => |r| try writer.print("{}..{}", .{ r.start, r.end }), + else => try writer.print("{s}", .{@tagName(self)}), } } diff --git a/test/compiler.test.zig b/test/compiler.test.zig index 01b583f..9a910bb 100644 --- a/test/compiler.test.zig +++ b/test/compiler.test.zig @@ -1070,7 +1070,6 @@ test "Functions" { defer mod.deinit(); var bytecode = try compileSource(case.input, mod); defer bytecode.free(allocator); - errdefer bytecode.print(std.debug); for (case.instructions, 0..) |instruction, i| { errdefer std.log.warn("Error on: {}\n {s}", .{ i, case.input }); try testing.expectEqual(instruction, bytecode.instructions[i]); @@ -1274,7 +1273,6 @@ test "Builtin Functions" { defer mod.deinit(); var bytecode = try compileSource(case.input, mod); defer bytecode.free(allocator); - errdefer bytecode.print(std.debug); for (case.instructions, 0..) |instruction, i| { errdefer std.log.warn("Error on: {}", .{i}); try testing.expectEqual(instruction, bytecode.instructions[i]); @@ -1550,7 +1548,6 @@ test "Closures" { defer mod.deinit(); var bytecode = try compileSource(case.input, mod); defer bytecode.free(allocator); - errdefer bytecode.print(std.debug); for (case.instructions, 0..) |instruction, i| { errdefer std.log.warn("Error on: {}", .{i}); try testing.expectEqual(instruction, bytecode.instructions[i]); @@ -1623,7 +1620,6 @@ test "Classes" { defer mod.deinit(); var bytecode = try compileSource(case.input, mod); defer bytecode.free(allocator); - errdefer bytecode.print(std.debug); for (case.instructions, 0..) |instruction, i| { errdefer std.log.warn("Error on: {}", .{i}); try testing.expectEqual(instruction, bytecode.instructions[i]); @@ -1670,7 +1666,6 @@ test "Serialize" { const file = try std.fs.cwd().createFile("tmp.topi.byte", .{ .read = true }); defer std.fs.cwd().deleteFile("tmp.topi.byte") catch {}; defer file.close(); - // bytecode.print(std.debug); try bytecode.serialize(file.writer()); try file.seekTo(0); diff --git a/test/locale.test.zig b/test/locale.test.zig index 6a0c7d0..c41ce82 100644 --- a/test/locale.test.zig +++ b/test/locale.test.zig @@ -61,7 +61,7 @@ test "Update File Localization Ids" { var buf_reader = std.io.bufferedReader(file.reader()); const reader = buf_reader.reader(); - const out = std.io.getStdOut().writer(); + const out = std.io.getStdErr().writer(); while (true) { reader.streamUntilDelimiter(out, '\n', null) catch break; diff --git a/test/parser.test.zig b/test/parser.test.zig index 0f3a44e..9c9e456 100644 --- a/test/parser.test.zig +++ b/test/parser.test.zig @@ -143,8 +143,8 @@ test "Parse Iterable Types" { const test_cases = .{ .{ .input = "const stringList = List{\"item\"}", .id = "stringList", .item_value = [_][]const u8{"item"}, .mutable = false, .type = .list }, .{ .input = "const stringList = List{\"item1\", \"item2\"}", .id = "stringList", .item_value = [_][]const u8{ "item1", "item2" }, .mutable = false, .type = .list }, - .{ .input = "var floatSet = Set{2.0}", .id = "floatSet", .item_value = [_]f64{2.0}, .mutable = true, .type = .set }, - .{ .input = "var floatSet = Set{2.0, 3.4, 5.6}", .id = "floatSet", .item_value = [_]f64{ 2.0, 3.4, 5.6 }, .mutable = true, .type = .set }, + .{ .input = "var floatSet = Set{2.0}", .id = "floatSet", .item_value = [_]f32{2.0}, .mutable = true, .type = .set }, + .{ .input = "var floatSet = Set{2.0, 3.4, 5.6}", .id = "floatSet", .item_value = [_]f32{ 2.0, 3.4, 5.6 }, .mutable = true, .type = .set }, .{ .input = "var stringBoolMap = Map{\"key\":true}", .id = "stringBoolMap", .item_value = [_]bool{true}, .mutable = true, .type = .map }, .{ .input = "var stringBoolMap = Map{\"key1\":true, \"key2\": false, \"key3\": true}", .id = "stringBoolMap", .item_value = [_]bool{ true, false, true }, .mutable = true, .type = .map }, }; diff --git a/test/runner.zig b/test/runner.zig index 3e1101f..ad2ad09 100644 --- a/test/runner.zig +++ b/test/runner.zig @@ -47,8 +47,8 @@ pub const TestRunner = struct { }; } - pub fn onValueChanged(_: *Runner, vm: *Vm, name: []const u8, value: Value) void { + pub fn onValueChanged(_: *Runner, _: *Vm, name: []const u8, value: Value) void { std.debug.print("Value Changed Callback: {s}\n", .{name}); - value.print(std.debug, vm.bytecode.constants); + value.print(std.io.getStdErr().writer()) catch unreachable; } }; diff --git a/test/vm.test.zig b/test/vm.test.zig index 3f67ea0..1ec130e 100644 --- a/test/vm.test.zig +++ b/test/vm.test.zig @@ -18,22 +18,22 @@ pub fn initTestVm(source: []const u8, mod: *Module, debug: bool) !Vm { var bytecode = try compileSource(source, mod); errdefer bytecode.free(allocator); if (debug) { - bytecode.print(std.debug); + try bytecode.print(std.io.getStdErr().writer()); } return Vm.init(allocator, bytecode, &test_runner.runner); } test "Basics" { const test_cases = .{ - .{ .input = "1", .value = 1.0, .type = f64 }, - .{ .input = "2", .value = 2.0, .type = f64 }, - .{ .input = "1 + 2", .value = 3.0, .type = f64 }, - .{ .input = "-12", .value = -12.0, .type = f64 }, - .{ .input = "111 + 222", .value = 333.0, .type = f64 }, - .{ .input = "5 - 2", .value = 3.0, .type = f64 }, - .{ .input = "5 * 2", .value = 10.0, .type = f64 }, - .{ .input = "6 / 2", .value = 3.0, .type = f64 }, - .{ .input = "6 % 5", .value = 1.0, .type = f64 }, + .{ .input = "1", .value = 1.0, .type = f32 }, + .{ .input = "2", .value = 2.0, .type = f32 }, + .{ .input = "1 + 2", .value = 3.0, .type = f32 }, + .{ .input = "-12", .value = -12.0, .type = f32 }, + .{ .input = "111 + 222", .value = 333.0, .type = f32 }, + .{ .input = "5 - 2", .value = 3.0, .type = f32 }, + .{ .input = "5 * 2", .value = 10.0, .type = f32 }, + .{ .input = "6 / 2", .value = 3.0, .type = f32 }, + .{ .input = "6 % 5", .value = 1.0, .type = f32 }, .{ .input = "1 == 1", .value = true, .type = bool }, .{ .input = "1 != 1", .value = false, .type = bool }, .{ .input = "1 > 5", .value = false, .type = bool }, @@ -52,7 +52,7 @@ test "Basics" { defer vm.bytecode.free(testing.allocator); try vm.interpret(); switch (case.type) { - f64 => try testing.expect(case.value == vm.stack.previous().number), + f32 => try testing.expect(case.value == vm.stack.previous().number), bool => try testing.expect(case.value == vm.stack.previous().bool), else => continue, } @@ -159,13 +159,13 @@ test "Strings" { test "Lists" { const test_cases = .{ - .{ .input = "List{}", .value = [_]f64{} }, - .{ .input = "List{1,2,3}", .value = [_]f64{ 1, 2, 3 } }, - .{ .input = "List{1 + 2, 3 * 4, 5 + 6}", .value = [_]f64{ 3, 12, 11 } }, - .{ .input = "var l = List{} l.add(1) l", .value = [_]f64{1} }, - .{ .input = "var l = List{} l.add(1) l.add(2) l", .value = [_]f64{ 1, 2 } }, - .{ .input = "var l = List{} l.add(1) l.add(2) l.remove(1) l", .value = [_]f64{2} }, - .{ .input = "var l = List{1,2,3,4,5} l.remove(3) l", .value = [_]f64{ 1, 2, 4, 5 } }, + .{ .input = "List{}", .value = [_]f32{} }, + .{ .input = "List{1,2,3}", .value = [_]f32{ 1, 2, 3 } }, + .{ .input = "List{1 + 2, 3 * 4, 5 + 6}", .value = [_]f32{ 3, 12, 11 } }, + .{ .input = "var l = List{} l.add(1) l", .value = [_]f32{1} }, + .{ .input = "var l = List{} l.add(1) l.add(2) l", .value = [_]f32{ 1, 2 } }, + .{ .input = "var l = List{} l.add(1) l.add(2) l.remove(1) l", .value = [_]f32{2} }, + .{ .input = "var l = List{1,2,3,4,5} l.remove(3) l", .value = [_]f32{ 1, 2, 4, 5 } }, }; inline for (test_cases) |case| { @@ -184,11 +184,11 @@ test "Lists" { test "Maps" { const test_cases = .{ - .{ .input = "Map{}", .keys = [_]f64{}, .values = [_]f64{} }, - .{ .input = "Map{1:2, 3: 4}", .keys = [_]f64{ 1, 3 }, .values = [_]f64{ 2, 4 } }, - .{ .input = "Map{1 + 1: 2 * 2, 3 + 3: 4 * 4}", .keys = [_]f64{ 2, 6 }, .values = [_]f64{ 4, 16 } }, - .{ .input = "var m = Map{1:2} m.add(3, 4) m", .keys = [_]f64{ 1, 3 }, .values = [_]f64{ 2, 4 } }, - .{ .input = "var m = Map{1:2} m.add(3, 4) m.remove(1) m", .keys = [_]f64{3}, .values = [_]f64{4} }, + .{ .input = "Map{}", .keys = [_]f32{}, .values = [_]f32{} }, + .{ .input = "Map{1:2, 3: 4}", .keys = [_]f32{ 1, 3 }, .values = [_]f32{ 2, 4 } }, + .{ .input = "Map{1 + 1: 2 * 2, 3 + 3: 4 * 4}", .keys = [_]f32{ 2, 6 }, .values = [_]f32{ 4, 16 } }, + .{ .input = "var m = Map{1:2} m.add(3, 4) m", .keys = [_]f32{ 1, 3 }, .values = [_]f32{ 2, 4 } }, + .{ .input = "var m = Map{1:2} m.add(3, 4) m.remove(1) m", .keys = [_]f32{3}, .values = [_]f32{4} }, }; inline for (test_cases) |case| { @@ -212,11 +212,11 @@ test "Maps" { test "Sets" { const test_cases = .{ - .{ .input = "Set{}", .values = [_]f64{} }, - .{ .input = "Set{1, 2}", .values = [_]f64{ 1, 2 } }, - .{ .input = "Set{1 + 1, 3 + 3}", .values = [_]f64{ 2, 6 } }, - .{ .input = "var s = Set{1} s.add(2) s.add(1) s", .values = [_]f64{ 1, 2 } }, - .{ .input = "var s = Set{1} s.add(2) s.remove(1) s", .values = [_]f64{2} }, + .{ .input = "Set{}", .values = [_]f32{} }, + .{ .input = "Set{1, 2}", .values = [_]f32{ 1, 2 } }, + .{ .input = "Set{1 + 1, 3 + 3}", .values = [_]f32{ 2, 6 } }, + .{ .input = "var s = Set{1} s.add(2) s.add(1) s", .values = [_]f32{ 1, 2 } }, + .{ .input = "var s = Set{1} s.add(2) s.remove(1) s", .values = [_]f32{2} }, }; inline for (test_cases) |case| { @@ -510,11 +510,11 @@ test "Builtin Functions" { const test_cases = .{ .{ .input = "rnd(1, 10)", - .type = f64, + .type = f32, }, .{ .input = "rnd01()", - .type = f64, + .type = f32, }, }; inline for (test_cases) |case| {