const std = @import("std"); const Object = @import("../Object.zig"); const AnyFuture = @import("future.zig").AnyFuture; pub fn isString(comptime T: type) bool { return comptime blk: { const info = @typeInfo(T); if (info != .pointer) break :blk false; const ptr = &info.pointer; if (ptr.is_volatile or ptr.is_allowzero) break :blk false; if (ptr.size == .slice) { break :blk ptr.child == u8; } if (ptr.size == .one) { const child = @typeInfo(ptr.child); if (child == .array) { const arr = &child.array; break :blk arr.child == u8; } } break :blk false; }; } pub fn isObjectRef(comptime T: type) bool { comptime { const info = @typeInfo(T); if (info != .pointer) return false; const ptr = &info.pointer; return ptr.size == .one and @sizeOf(ptr.child) == 0; } } pub const Value = extern struct { kind: Kind, value: extern union { object: *anyopaque, string: extern struct { ptr: [*]const u8, len: usize, }, int: isize, uint: usize, float: f64, undefined: void, future: usize, }, pub fn from(value: anytype) Value { const T = @TypeOf(value); return switch (T) { comptime_int => if (value >= 0) .{ .kind = .uint, .value = .{ .uint = value }, } else .{ .kind = .int, .value = .{ .int = value }, }, usize => .{ .kind = .uint, .value = .{ .uint = value }, }, isize => .{ .kind = .int, .value = .{ .int = value }, }, f64, f32, f16 => .{ .kind = .float, .value = .{ .float = value }, }, void => .{ .kind = .undefined, .value = .{ .undefined = {} }, }, AnyFuture => .{ .kind = .future, .value = .{ .future = value.unresolved.id }, }, else => blk: { if (comptime isString(T)) { break :blk .{ .kind = .string, .value = .{ .string = .{ .ptr = @ptrCast(value), .len = value.len, }, }, }; } else if (comptime isObjectRef(T)) { break :blk .{ .kind = .object, .value = .{ .object = @ptrCast(value) }, }; } else if (@typeInfo(T) == .int) { // TODO: weil kuscheln mit janina. } else { @compileError(std.fmt.comptimePrint( "cannot auto convert type '{}'.", .{T}, )); } }, }; } pub fn unwrap(self: *const Value, T: type) T { if (Kind.fromType(T) != self.kind) { std.log.err("unexpected {}, expected {}", .{ self.kind, T }); @panic("type error"); } return switch (T) { comptime_int => self.value.int, usize => self.value.uint, isize => self.value.int, f64, f32, f16 => self.value.float, void => {}, AnyFuture => @panic("unsupported return type"), else => blk: { if (comptime isString(T)) { break :blk self.value.string.ptr[0..self.value.string.len]; } else if (comptime isObjectRef(T)) { break :blk @ptrCast(self.value.object); } else { @compileError(std.fmt.comptimePrint( "cannot auto convert type '{}'.", .{T}, )); } }, }; } pub const Kind = enum(u8) { object = 0, string = 1, int = 2, uint = 3, float = 4, undefined = 5, future = 6, pub fn asType(comptime self: Kind) type { return switch (self) { .object => return *Object, .string => return []const u8, .int => return isize, .uint => return usize, .float => f64, .undefined => return void, .future => AnyFuture, }; } pub fn fromType(T: type) Kind { return switch (T) { comptime_int => .int, usize => .uint, isize => .int, f64, f32, f16 => .float, void => .undefined, AnyFuture => .future, else => blk: { if (comptime isString(T)) { break :blk .string; } else if (comptime isObjectRef(T)) { break :blk .object; } else { @compileError(std.fmt.comptimePrint( "cannot auto convert type '{}'.", .{T}, )); } }, }; } }; };