// Top-level module // Copyright (C) 2024 Nguyễn Gia Phong // // This file is part of jz. // // jz is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published // by the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // jz is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with jz. If not, see . const SourceLocation = std.builtin.SourceLocation; const Struct = std.builtin.Type.Struct; const StructField = std.builtin.Type.StructField; const Tuple = std.meta.Tuple; const assert = std.debug.assert; const c = @cImport(@cInclude("janet.h")); const expectEqual = std.testing.expectEqual; const log10 = std.math.log10; const std = @import("std"); const zeroes = std.mem.zeroes; /// Initialize global Janet state, that is thread local. pub fn init() void { _ = c.janet_init(); } /// Free resources managed by Janet. pub const deinit = c.janet_deinit; /// Janet environment Table. pub const Table = c.JanetTable; /// Return a core environment Table based on the given optional one. pub const coreEnv = c.janet_core_env; /// Janet value structure. pub const Value = c.Janet; /// Evaluate the Janet program given in str. pub fn eval(env: *Table, str: []const u8, src: [*:0]const u8) !Value { var ret: Value = undefined; const errflags = c.janet_dobytes(env, str.ptr, @intCast(str.len), src, &ret); // Errors are already logged by Janet, // among them only one is returned and not machine-readable. return if (errflags == 0) ret else error.JanetError; } /// Wrap native type in Janet value. fn wrap(x: anytype) Value { return switch (@TypeOf(x)) { f64 => c.janet_wrap_number(x), bool => c.janet_wrap_boolean(@intFromBool(x)), [*:0]const u8 => c.janet_wrap_string(x), i32 => c.janet_wrap_integer(x), else => unreachable, }; } /// Unwrap to native type. fn unwrap(comptime T: type, x: Value) T { return switch (T) { [*:0]const u8 => c.janet_unwrap_string(x), bool => c.janet_unwrap_boolean(x) != 0, f64 => c.janet_unwrap_number(x), i32 => c.janet_unwrap_integer(x), else => unreachable, }; } test "isomorphism" { inline for (.{ true, @as(i32, 42069), @as(f64, 420.69), @as([*:0]const u8, "foobar"), }) |x| try expectEqual(x, unwrap(@TypeOf(x), wrap(x))); } fn get(comptime T: type, argv: [*c]Value, n: i32) T { return switch (T) { f64 => c.janet_getnumber(argv, n), [*:0]const u8 => c.janet_getcstring(argv, n), bool => c.janet_getboolean(argv, n) != 0, i32 => c.janet_getinteger(argv, n), i64 => c.janet_getinteger64(argv, n), usize => c.janet_size(argv, n), else => unreachable, }; } pub fn def(env: *Table, comptime fun: anytype, reg: struct { prefix: ?[*:0]const u8 = null, name: [*:0]const u8, documentation: [*:0]const u8, source: SourceLocation, }) void { const function = @typeInfo(@TypeOf(fun)).Fn; if (function.is_generic) @compileError("fun is generic"); if (function.is_var_args) @compileError("fun is variadic"); const n = function.params.len; comptime var fields: [n]type = undefined; inline for (&fields, function.params) |*field, param| field.* = param.type.?; const cfun = struct { fn cfun(argc: i32, argv: [*c]Value) callconv(.C) Value { c.janet_fixarity(argc, n); var args: Tuple(&fields) = undefined; inline for (&args, function.params, 0..) |*arg, param, i| arg.* = get(param.type.?, argv, i); const result = @call(.auto, fun, args); return wrap(result); } }.cfun; const cfuns = [_]c.JanetRegExt{ .{ .name = reg.name, .cfun = cfun, .documentation = reg.documentation, .source_file = reg.source.file, .source_line = @bitCast(reg.source.line), }, zeroes(c.JanetRegExt), }; if (reg.prefix) |prefix| c.janet_cfuns_ext_prefix(env, prefix, &cfuns) else c.janet_cfuns_ext(env, null, &cfuns); } test def { init(); defer deinit(); var env = coreEnv(null); def(env, struct { fn add(a: i32, b: i32) i32 { return a + b; } }.add, .{ .name = "add", .documentation = "(add a b)\n\nReturn a + b.", .source = @src(), }); try expectEqual(unwrap(i32, try eval(env, "(add 3 7)", "add")), 10); }