1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
const std = @import("std");
const Object = @import("../Object.zig");
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 const Value = extern struct {
kind: Kind,
value: extern union {
object: *Object,
string: extern struct {
ptr: [*]const u8,
len: usize,
},
int: isize,
uint: usize,
float: f64,
undefined: void,
},
pub fn from(value: anytype) Value {
const T = @TypeOf(value);
return switch (T) {
*Object => .{
.kind = .object,
.value = .{ .object = value },
},
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 = {} },
},
else => str: {
if (comptime isString(T)) {
break :str .{
.kind = .string,
.value = .{
.string = .{
.ptr = @ptrCast(value),
.len = value.len,
},
},
};
} else {
@compileError(std.fmt.comptimePrint(
"cannot auto convert type '{}'.",
.{T},
));
}
},
};
}
pub const Kind = enum(u8) {
uninit = 0,
object = 1,
string = 2,
int = 3,
uint = 4,
float = 5,
undefined = 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,
.uninit => @compileError("uninit has no associated type."),
};
}
};
};
|