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
|
const std = @import("std");
const value = @import("../value.zig");
const ShortString = value.ShortString;
const OtherTag = value.OtherTag;
const Value = value.Value;
// Zig API
pub fn check(v: Value) bool {
return v.isOtherTag(.sstr) or v.isOtherTag(.qstr);
}
pub fn assert(v: Value) void {
if (!check(v)) {
v.dump();
@panic("not sstr");
}
}
pub fn checkQuoted(v: Value) bool {
return v.isOtherTag(.qstr);
}
// For now, ignore encoding, just treat it as []u8.
pub fn isValidSstr(s: []const u8) bool {
if (s.len > 6) {
return false;
}
for (s) |c| {
if (c == 0) {
return false;
}
}
return true;
}
fn assertValidSstr(s: []const u8) void {
if (!isValidSstr(s)) {
std.debug.print("invalid sstr: {s}\n", .{s});
@panic("invalid sstr");
}
}
// Different ways of doing the following have been tested, including manual
// shifting and bit masking, but memcpy always wins easily according to our
// micro-benchmarks, under both ReleaseSafe and ReleaseFast.
// Note: rune.zig uses equivalent code; probably good to keep in sync.
pub fn pack(s: []const u8) Value {
return _pack(s, .sstr);
}
pub fn packQuoted(s: []const u8) Value {
return _pack(s, .qstr);
}
fn _pack(s: []const u8, tag: OtherTag) Value {
assertValidSstr(s);
var v = Value{ .sstr = .{ .string = 0, .tag = tag } };
const dest: [*]u8 = @ptrCast(&v.sstr.string);
@memcpy(dest, s);
return v;
}
pub fn unpack(v: Value) ShortString {
assert(v);
const s: [6]u8 = @bitCast(v.sstr.string);
inline for (0..6) |i| {
if (s[i] == 0) return .{ .buffer = s, .len = i };
}
return .{ .buffer = s, .len = 6 };
}
// No Zisp API for sstr specifically, since it's a string. See string.zig.
|
