refactor: unvendor cbor module and pull it from thespian
This commit is contained in:
parent
a98e9f9f2c
commit
6329b890e4
4 changed files with 7 additions and 915 deletions
|
|
@ -7,6 +7,7 @@ pub fn build(b: *std.Build) void {
|
|||
const clap_dep = b.dependency("clap", .{ .target = target, .optimize = optimize });
|
||||
const themes_dep = b.dependency("themes", .{});
|
||||
const syntax_dep = b.dependency("syntax", .{ .target = target, .optimize = optimize });
|
||||
const thespian_dep = b.dependency("thespian", .{});
|
||||
|
||||
const exe = b.addExecutable(.{
|
||||
.name = "zat",
|
||||
|
|
@ -18,6 +19,7 @@ pub fn build(b: *std.Build) void {
|
|||
exe.root_module.addImport("theme", themes_dep.module("theme"));
|
||||
exe.root_module.addImport("themes", themes_dep.module("themes"));
|
||||
exe.root_module.addImport("clap", clap_dep.module("clap"));
|
||||
exe.root_module.addImport("cbor", b.createModule(.{ .root_source_file = thespian_dep.path("src/cbor.zig") }));
|
||||
b.installArtifact(exe);
|
||||
|
||||
const run_cmd = b.addRunArtifact(exe);
|
||||
|
|
|
|||
|
|
@ -14,6 +14,10 @@
|
|||
.url = "https://github.com/neurocyte/flow-syntax/archive/e58df221cc9ea8086fdb26df348f04429361d1f0.tar.gz",
|
||||
.hash = "1220f1772359f6c1fc04df79b3f9aa5899efc87b3b8d0e65f44b40df66260cf79183",
|
||||
},
|
||||
.thespian = .{
|
||||
.url = "https://github.com/neurocyte/thespian/archive/a740c03c11ab22b93c050bfc27cb936be86f9b39.tar.gz",
|
||||
.hash = "1220ecd65090063ac90cd462b09ba603736cb03f4863d831c4f6c46189d2b1a1267a",
|
||||
},
|
||||
},
|
||||
.paths = .{
|
||||
"build.zig",
|
||||
|
|
|
|||
914
src/cbor.zig
914
src/cbor.zig
|
|
@ -1,914 +0,0 @@
|
|||
const std = @import("std");
|
||||
|
||||
const eql = std.mem.eql;
|
||||
const bufPrint = std.fmt.bufPrint;
|
||||
const fixedBufferStream = std.io.fixedBufferStream;
|
||||
const maxInt = std.math.maxInt;
|
||||
const minInt = std.math.minInt;
|
||||
const json = std.json;
|
||||
const fba = std.heap.FixedBufferAllocator;
|
||||
|
||||
pub const CborError = error{
|
||||
CborIntegerTooLarge,
|
||||
CborIntegerTooSmall,
|
||||
CborInvalidType,
|
||||
CborTooShort,
|
||||
OutOfMemory,
|
||||
};
|
||||
|
||||
pub const CborJsonError = error{
|
||||
BufferUnderrun,
|
||||
CborIntegerTooLarge,
|
||||
CborIntegerTooSmall,
|
||||
CborInvalidType,
|
||||
CborTooShort,
|
||||
CborUnsupportedType,
|
||||
NoSpaceLeft,
|
||||
OutOfMemory,
|
||||
Overflow,
|
||||
SyntaxError,
|
||||
UnexpectedEndOfInput,
|
||||
};
|
||||
|
||||
const cbor_magic_null: u8 = 0xf6;
|
||||
const cbor_magic_true: u8 = 0xf5;
|
||||
const cbor_magic_false: u8 = 0xf4;
|
||||
|
||||
const cbor_magic_type_array: u8 = 4;
|
||||
const cbor_magic_type_map: u8 = 5;
|
||||
|
||||
const value_type = enum(u8) {
|
||||
number,
|
||||
bytes,
|
||||
string,
|
||||
array,
|
||||
map,
|
||||
tag,
|
||||
boolean,
|
||||
null,
|
||||
any,
|
||||
more,
|
||||
unknown,
|
||||
};
|
||||
pub const number = value_type.number;
|
||||
pub const bytes = value_type.bytes;
|
||||
pub const string = value_type.string;
|
||||
pub const array = value_type.array;
|
||||
pub const map = value_type.map;
|
||||
pub const tag = value_type.tag;
|
||||
pub const boolean = value_type.boolean;
|
||||
pub const null_ = value_type.null;
|
||||
pub const any = value_type.any;
|
||||
pub const more = value_type.more;
|
||||
|
||||
const null_value_buf = [_]u8{0xF6};
|
||||
pub const null_value: []const u8 = &null_value_buf;
|
||||
|
||||
pub fn isNull(val: []const u8) bool {
|
||||
return eql(u8, val, null_value);
|
||||
}
|
||||
|
||||
fn isAny(value: anytype) bool {
|
||||
return if (comptime @TypeOf(value) == value_type) value == value_type.any else false;
|
||||
}
|
||||
|
||||
fn isMore(value: anytype) bool {
|
||||
return if (comptime @TypeOf(value) == value_type) value == value_type.more else false;
|
||||
}
|
||||
|
||||
fn write(writer: anytype, value: u8) @TypeOf(writer).Error!void {
|
||||
_ = try writer.write(&[_]u8{value});
|
||||
}
|
||||
|
||||
fn writeTypedVal(writer: anytype, type_: u8, value: u64) @TypeOf(writer).Error!void {
|
||||
const t: u8 = type_ << 5;
|
||||
if (value < 24) {
|
||||
try write(writer, t | @as(u8, @truncate(value)));
|
||||
} else if (value < 256) {
|
||||
try write(writer, t | 24);
|
||||
try write(writer, @as(u8, @truncate(value)));
|
||||
} else if (value < 65536) {
|
||||
try write(writer, t | 25);
|
||||
try write(writer, @as(u8, @truncate(value >> 8)));
|
||||
try write(writer, @as(u8, @truncate(value)));
|
||||
} else if (value < 4294967296) {
|
||||
try write(writer, t | 26);
|
||||
try write(writer, @as(u8, @truncate(value >> 24)));
|
||||
try write(writer, @as(u8, @truncate(value >> 16)));
|
||||
try write(writer, @as(u8, @truncate(value >> 8)));
|
||||
try write(writer, @as(u8, @truncate(value)));
|
||||
} else {
|
||||
try write(writer, t | 27);
|
||||
try write(writer, @as(u8, @truncate(value >> 56)));
|
||||
try write(writer, @as(u8, @truncate(value >> 48)));
|
||||
try write(writer, @as(u8, @truncate(value >> 40)));
|
||||
try write(writer, @as(u8, @truncate(value >> 32)));
|
||||
try write(writer, @as(u8, @truncate(value >> 24)));
|
||||
try write(writer, @as(u8, @truncate(value >> 16)));
|
||||
try write(writer, @as(u8, @truncate(value >> 8)));
|
||||
try write(writer, @as(u8, @truncate(value)));
|
||||
}
|
||||
}
|
||||
|
||||
pub fn writeArrayHeader(writer: anytype, sz: usize) @TypeOf(writer).Error!void {
|
||||
return writeTypedVal(writer, cbor_magic_type_array, sz);
|
||||
}
|
||||
|
||||
pub fn writeMapHeader(writer: anytype, sz: usize) @TypeOf(writer).Error!void {
|
||||
return writeTypedVal(writer, cbor_magic_type_map, sz);
|
||||
}
|
||||
|
||||
pub fn writeArray(writer: anytype, args: anytype) @TypeOf(writer).Error!void {
|
||||
const args_type_info = @typeInfo(@TypeOf(args));
|
||||
if (args_type_info != .Struct) @compileError("expected tuple or struct argument");
|
||||
const fields_info = args_type_info.Struct.fields;
|
||||
try writeArrayHeader(writer, fields_info.len);
|
||||
inline for (fields_info) |field_info|
|
||||
try writeValue(writer, @field(args, field_info.name));
|
||||
}
|
||||
|
||||
fn writeI64(writer: anytype, value: i64) @TypeOf(writer).Error!void {
|
||||
return if (value < 0)
|
||||
writeTypedVal(writer, 1, @as(u64, @bitCast(-(value + 1))))
|
||||
else
|
||||
writeTypedVal(writer, 0, @as(u64, @bitCast(value)));
|
||||
}
|
||||
|
||||
fn writeU64(writer: anytype, value: u64) @TypeOf(writer).Error!void {
|
||||
return writeTypedVal(writer, 0, value);
|
||||
}
|
||||
|
||||
fn writeString(writer: anytype, s: []const u8) @TypeOf(writer).Error!void {
|
||||
try writeTypedVal(writer, 3, s.len);
|
||||
_ = try writer.write(s);
|
||||
}
|
||||
|
||||
fn writeBool(writer: anytype, value: bool) @TypeOf(writer).Error!void {
|
||||
return write(writer, if (value) cbor_magic_true else cbor_magic_false);
|
||||
}
|
||||
|
||||
fn writeNull(writer: anytype) @TypeOf(writer).Error!void {
|
||||
return write(writer, cbor_magic_null);
|
||||
}
|
||||
|
||||
fn writeErrorset(writer: anytype, err: anyerror) @TypeOf(writer).Error!void {
|
||||
var buf: [256]u8 = undefined;
|
||||
const errmsg = try bufPrint(&buf, "error.{s}", .{@errorName(err)});
|
||||
return writeString(writer, errmsg);
|
||||
}
|
||||
|
||||
pub fn writeValue(writer: anytype, value: anytype) @TypeOf(writer).Error!void {
|
||||
const T = @TypeOf(value);
|
||||
switch (@typeInfo(T)) {
|
||||
.Int, .ComptimeInt => return if (T == u64) writeU64(writer, value) else writeI64(writer, @intCast(value)),
|
||||
.Bool => return writeBool(writer, value),
|
||||
.Optional => return if (value) |v| writeValue(writer, v) else writeNull(writer),
|
||||
.ErrorUnion => return if (value) |v| writeValue(writer, v) else |err| writeValue(writer, err),
|
||||
.ErrorSet => return writeErrorset(writer, value),
|
||||
.Union => |info| {
|
||||
if (info.tag_type) |TagType| {
|
||||
comptime var v = void;
|
||||
inline for (info.fields) |u_field| {
|
||||
if (value == @field(TagType, u_field.name))
|
||||
v = @field(value, u_field.name);
|
||||
}
|
||||
try writeArray(writer, .{
|
||||
@typeName(T),
|
||||
@tagName(@as(TagType, value)),
|
||||
v,
|
||||
});
|
||||
} else {
|
||||
try writeArray(writer, .{@typeName(T)});
|
||||
}
|
||||
},
|
||||
.Struct => |info| {
|
||||
if (info.is_tuple) {
|
||||
if (info.fields.len == 0) return writeNull(writer);
|
||||
try writeArrayHeader(writer, info.fields.len);
|
||||
inline for (info.fields) |f|
|
||||
try writeValue(writer, @field(value, f.name));
|
||||
} else {
|
||||
if (info.fields.len == 0) return writeNull(writer);
|
||||
try writeMapHeader(writer, info.fields.len);
|
||||
inline for (info.fields) |f| {
|
||||
try writeString(writer, f.name);
|
||||
try writeValue(writer, @field(value, f.name));
|
||||
}
|
||||
}
|
||||
},
|
||||
.Pointer => |ptr_info| switch (ptr_info.size) {
|
||||
.One => return writeValue(writer, value.*),
|
||||
.Many, .C => @compileError("cannot write type '" ++ @typeName(T) ++ "' to cbor stream"),
|
||||
.Slice => {
|
||||
if (ptr_info.child == u8) return writeString(writer, value);
|
||||
if (value.len == 0) return writeNull(writer);
|
||||
try writeArrayHeader(writer, value.len);
|
||||
for (value) |elem|
|
||||
try writeValue(writer, elem);
|
||||
},
|
||||
},
|
||||
.Array => |info| {
|
||||
if (info.child == u8) return writeString(writer, &value);
|
||||
if (value.len == 0) return writeNull(writer);
|
||||
try writeArrayHeader(writer, value.len);
|
||||
for (value) |elem|
|
||||
try writeValue(writer, elem);
|
||||
},
|
||||
.Vector => |info| {
|
||||
try writeArrayHeader(writer, info.len);
|
||||
var i: usize = 0;
|
||||
while (i < info.len) : (i += 1) {
|
||||
try writeValue(writer, value[i]);
|
||||
}
|
||||
},
|
||||
.Null => try writeNull(writer),
|
||||
else => @compileError("cannot write type '" ++ @typeName(T) ++ "' to cbor stream"),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn fmt(buf: []u8, value: anytype) []const u8 {
|
||||
var stream = fixedBufferStream(buf);
|
||||
writeValue(stream.writer(), value) catch unreachable;
|
||||
return stream.getWritten();
|
||||
}
|
||||
|
||||
const CborType = struct { type: u8, minor: u5, major: u3 };
|
||||
|
||||
pub fn decodeType(iter: *[]const u8) error{CborTooShort}!CborType {
|
||||
if (iter.len < 1)
|
||||
return error.CborTooShort;
|
||||
const type_: u8 = iter.*[0];
|
||||
const bits: packed struct { minor: u5, major: u3 } = @bitCast(type_);
|
||||
iter.* = iter.*[1..];
|
||||
return .{ .type = type_, .minor = bits.minor, .major = bits.major };
|
||||
}
|
||||
|
||||
fn decodeUIntLengthRecurse(iter: *[]const u8, length: usize, acc: u64) !u64 {
|
||||
if (iter.len < 1)
|
||||
return error.CborTooShort;
|
||||
const v: u8 = iter.*[0];
|
||||
iter.* = iter.*[1..];
|
||||
var i = acc | v;
|
||||
if (length == 1)
|
||||
return i;
|
||||
i <<= 8;
|
||||
// return @call(.always_tail, decodeUIntLengthRecurse, .{ iter, length - 1, i }); FIXME: @call(.always_tail) seems broken as of 0.11.0-dev.2964+e9cbdb2cf
|
||||
return decodeUIntLengthRecurse(iter, length - 1, i);
|
||||
}
|
||||
|
||||
fn decodeUIntLength(iter: *[]const u8, length: usize) !u64 {
|
||||
return decodeUIntLengthRecurse(iter, length, 0);
|
||||
}
|
||||
|
||||
fn decodePInt(iter: *[]const u8, minor: u5) !u64 {
|
||||
if (minor < 24) return minor;
|
||||
return switch (minor) {
|
||||
24 => decodeUIntLength(iter, 1), // 1 byte
|
||||
25 => decodeUIntLength(iter, 2), // 2 byte
|
||||
26 => decodeUIntLength(iter, 4), // 4 byte
|
||||
27 => decodeUIntLength(iter, 8), // 8 byte
|
||||
else => error.CborInvalidType,
|
||||
};
|
||||
}
|
||||
|
||||
fn decodeNInt(iter: *[]const u8, minor: u5) CborError!i64 {
|
||||
return -@as(i64, @intCast(try decodePInt(iter, minor) + 1));
|
||||
}
|
||||
|
||||
pub fn decodeMapHeader(iter: *[]const u8) CborError!usize {
|
||||
const t = try decodeType(iter);
|
||||
if (t.type == cbor_magic_null)
|
||||
return 0;
|
||||
if (t.major != 5)
|
||||
return error.CborInvalidType;
|
||||
return decodePInt(iter, t.minor);
|
||||
}
|
||||
|
||||
pub fn decodeArrayHeader(iter: *[]const u8) CborError!usize {
|
||||
const t = try decodeType(iter);
|
||||
if (t.type == cbor_magic_null)
|
||||
return 0;
|
||||
if (t.major != 4)
|
||||
return error.CborInvalidType;
|
||||
return decodePInt(iter, t.minor);
|
||||
}
|
||||
|
||||
fn decodeString(iter_: *[]const u8, minor: u5) CborError![]const u8 {
|
||||
var iter = iter_.*;
|
||||
const len = try decodePInt(&iter, minor);
|
||||
if (iter.len < len)
|
||||
return error.CborTooShort;
|
||||
const s = iter[0..len];
|
||||
iter = iter[len..];
|
||||
iter_.* = iter;
|
||||
return s;
|
||||
}
|
||||
|
||||
fn decodeBytes(iter: *[]const u8, minor: u5) CborError![]const u8 {
|
||||
return decodeString(iter, minor);
|
||||
}
|
||||
|
||||
fn decodeJsonArray(iter_: *[]const u8, minor: u5, arr: *json.Array) CborError!bool {
|
||||
var iter = iter_.*;
|
||||
var n = try decodePInt(&iter, minor);
|
||||
while (n > 0) {
|
||||
const value = try arr.addOne();
|
||||
if (!try matchJsonValue(&iter, value, arr.allocator))
|
||||
return false;
|
||||
n -= 1;
|
||||
}
|
||||
iter_.* = iter;
|
||||
return true;
|
||||
}
|
||||
|
||||
fn decodeJsonObject(iter_: *[]const u8, minor: u5, obj: *json.ObjectMap) CborError!bool {
|
||||
var iter = iter_.*;
|
||||
var n = try decodePInt(&iter, minor);
|
||||
while (n > 0) {
|
||||
var key: []u8 = undefined;
|
||||
var value: json.Value = .null;
|
||||
|
||||
if (!try matchString(&iter, &key))
|
||||
return false;
|
||||
if (!try matchJsonValue(&iter, &value, obj.allocator))
|
||||
return false;
|
||||
|
||||
_ = try obj.getOrPutValue(key, value);
|
||||
n -= 1;
|
||||
}
|
||||
iter_.* = iter;
|
||||
return true;
|
||||
}
|
||||
|
||||
pub fn matchInt(comptime T: type, iter_: *[]const u8, val: *T) CborError!bool {
|
||||
var iter = iter_.*;
|
||||
const t = try decodeType(&iter);
|
||||
val.* = switch (t.major) {
|
||||
0 => blk: { // positive integer
|
||||
const v = try decodePInt(&iter, t.minor);
|
||||
if (v > maxInt(T))
|
||||
return error.CborIntegerTooLarge;
|
||||
break :blk @intCast(v);
|
||||
},
|
||||
1 => blk: { // negative integer
|
||||
const v = try decodeNInt(&iter, t.minor);
|
||||
if (v < minInt(T))
|
||||
return error.CborIntegerTooSmall;
|
||||
break :blk @intCast(v);
|
||||
},
|
||||
|
||||
else => return false,
|
||||
};
|
||||
iter_.* = iter;
|
||||
return true;
|
||||
}
|
||||
|
||||
pub fn matchIntValue(comptime T: type, iter: *[]const u8, val: T) CborError!bool {
|
||||
var v: T = 0;
|
||||
return if (try matchInt(T, iter, &v)) v == val else false;
|
||||
}
|
||||
|
||||
pub fn matchBool(iter_: *[]const u8, v: *bool) CborError!bool {
|
||||
var iter = iter_.*;
|
||||
const t = try decodeType(&iter);
|
||||
if (t.major == 7) { // special
|
||||
if (t.type == cbor_magic_false) {
|
||||
v.* = false;
|
||||
iter_.* = iter;
|
||||
return true;
|
||||
}
|
||||
if (t.type == cbor_magic_true) {
|
||||
v.* = true;
|
||||
iter_.* = iter;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
fn matchBoolValue(iter: *[]const u8, val: bool) CborError!bool {
|
||||
var v: bool = false;
|
||||
return if (try matchBool(iter, &v)) v == val else false;
|
||||
}
|
||||
|
||||
fn skipString(iter: *[]const u8, minor: u5) CborError!void {
|
||||
const len = try decodePInt(iter, minor);
|
||||
if (iter.len < len)
|
||||
return error.CborTooShort;
|
||||
iter.* = iter.*[len..];
|
||||
}
|
||||
|
||||
fn skipBytes(iter: *[]const u8, minor: u5) CborError!void {
|
||||
return skipString(iter, minor);
|
||||
}
|
||||
|
||||
fn skipArray(iter: *[]const u8, minor: u5) CborError!void {
|
||||
var len = try decodePInt(iter, minor);
|
||||
while (len > 0) {
|
||||
try skipValue(iter);
|
||||
len -= 1;
|
||||
}
|
||||
}
|
||||
|
||||
fn skipMap(iter: *[]const u8, minor: u5) CborError!void {
|
||||
var len = try decodePInt(iter, minor);
|
||||
len *= 2;
|
||||
while (len > 0) {
|
||||
try skipValue(iter);
|
||||
len -= 1;
|
||||
}
|
||||
}
|
||||
|
||||
pub fn skipValue(iter: *[]const u8) CborError!void {
|
||||
const t = try decodeType(iter);
|
||||
try skipValueType(iter, t.major, t.minor);
|
||||
}
|
||||
|
||||
fn skipValueType(iter: *[]const u8, major: u3, minor: u5) CborError!void {
|
||||
switch (major) {
|
||||
0 => { // positive integer
|
||||
_ = try decodePInt(iter, minor);
|
||||
},
|
||||
1 => { // negative integer
|
||||
_ = try decodeNInt(iter, minor);
|
||||
},
|
||||
2 => { // bytes
|
||||
try skipBytes(iter, minor);
|
||||
},
|
||||
3 => { // string
|
||||
try skipString(iter, minor);
|
||||
},
|
||||
4 => { // array
|
||||
try skipArray(iter, minor);
|
||||
},
|
||||
5 => { // map
|
||||
try skipMap(iter, minor);
|
||||
},
|
||||
6 => { // tag
|
||||
return error.CborInvalidType;
|
||||
},
|
||||
7 => { // special
|
||||
return;
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn matchType(iter_: *[]const u8, v: *value_type) CborError!bool {
|
||||
var iter = iter_.*;
|
||||
const t = try decodeType(&iter);
|
||||
try skipValueType(&iter, t.major, t.minor);
|
||||
switch (t.major) {
|
||||
0, 1 => v.* = value_type.number, // positive integer or negative integer
|
||||
2 => v.* = value_type.bytes, // bytes
|
||||
3 => v.* = value_type.string, // string
|
||||
4 => v.* = value_type.array, // array
|
||||
5 => v.* = value_type.map, // map
|
||||
7 => { // special
|
||||
if (t.type == cbor_magic_null) {
|
||||
v.* = value_type.null;
|
||||
} else {
|
||||
if (t.type == cbor_magic_false or t.type == cbor_magic_true) {
|
||||
v.* = value_type.boolean;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
},
|
||||
else => return false,
|
||||
}
|
||||
iter_.* = iter;
|
||||
return true;
|
||||
}
|
||||
|
||||
fn matchValueType(iter: *[]const u8, t: value_type) CborError!bool {
|
||||
var v: value_type = value_type.unknown;
|
||||
return if (try matchType(iter, &v)) (t == value_type.any or t == v) else false;
|
||||
}
|
||||
|
||||
pub fn matchString(iter_: *[]const u8, val: *[]const u8) CborError!bool {
|
||||
var iter = iter_.*;
|
||||
const t = try decodeType(&iter);
|
||||
val.* = switch (t.major) {
|
||||
2 => try decodeBytes(&iter, t.minor), // bytes
|
||||
3 => try decodeString(&iter, t.minor), // string
|
||||
else => return false,
|
||||
};
|
||||
iter_.* = iter;
|
||||
return true;
|
||||
}
|
||||
|
||||
fn matchStringValue(iter: *[]const u8, lit: []const u8) CborError!bool {
|
||||
var val: []const u8 = undefined;
|
||||
return if (try matchString(iter, &val)) eql(u8, val, lit) else false;
|
||||
}
|
||||
|
||||
fn matchError(comptime T: type) noreturn {
|
||||
@compileError("cannot match type '" ++ @typeName(T) ++ "' to cbor stream");
|
||||
}
|
||||
|
||||
pub fn matchValue(iter: *[]const u8, value: anytype) CborError!bool {
|
||||
if (@TypeOf(value) == value_type)
|
||||
return matchValueType(iter, value);
|
||||
const T = comptime @TypeOf(value);
|
||||
if (comptime isExtractor(T))
|
||||
return value.extract(iter);
|
||||
return switch (comptime @typeInfo(T)) {
|
||||
.Int => return matchIntValue(T, iter, value),
|
||||
.ComptimeInt => return matchIntValue(i64, iter, value),
|
||||
.Bool => matchBoolValue(iter, value),
|
||||
.Pointer => |info| switch (info.size) {
|
||||
.One => matchValue(iter, value.*),
|
||||
.Many, .C => matchError(T),
|
||||
.Slice => if (info.child == u8) matchStringValue(iter, value) else matchArray(iter, value, info),
|
||||
},
|
||||
.Struct => |info| if (info.is_tuple)
|
||||
matchArray(iter, value, info)
|
||||
else
|
||||
matchError(T),
|
||||
.Array => |info| if (info.child == u8) matchStringValue(iter, &value) else matchArray(iter, value, info),
|
||||
else => @compileError("cannot match value type '" ++ @typeName(T) ++ "' to cbor stream"),
|
||||
};
|
||||
}
|
||||
|
||||
fn matchJsonValue(iter_: *[]const u8, v: *json.Value, a: std.mem.Allocator) CborError!bool {
|
||||
var iter = iter_.*;
|
||||
const t = try decodeType(&iter);
|
||||
const ret = switch (t.major) {
|
||||
0 => ret: { // positive integer
|
||||
v.* = json.Value{ .integer = @intCast(try decodePInt(&iter, t.minor)) };
|
||||
break :ret true;
|
||||
},
|
||||
1 => ret: { // negative integer
|
||||
v.* = json.Value{ .integer = try decodeNInt(&iter, t.minor) };
|
||||
break :ret true;
|
||||
},
|
||||
2 => ret: { // bytes
|
||||
break :ret false;
|
||||
},
|
||||
3 => ret: { // string
|
||||
v.* = json.Value{ .string = try decodeString(&iter, t.minor) };
|
||||
break :ret true;
|
||||
},
|
||||
4 => ret: { // array
|
||||
v.* = json.Value{ .array = json.Array.init(a) };
|
||||
break :ret try decodeJsonArray(&iter, t.minor, &v.array);
|
||||
},
|
||||
5 => ret: { // map
|
||||
v.* = json.Value{ .object = json.ObjectMap.init(a) };
|
||||
break :ret try decodeJsonObject(&iter, t.minor, &v.object);
|
||||
},
|
||||
6 => ret: { // tag
|
||||
break :ret false;
|
||||
},
|
||||
7 => ret: { // special
|
||||
switch (t.type) {
|
||||
cbor_magic_false => {
|
||||
v.* = json.Value{ .bool = false };
|
||||
break :ret true;
|
||||
},
|
||||
cbor_magic_true => {
|
||||
v.* = json.Value{ .bool = true };
|
||||
break :ret true;
|
||||
},
|
||||
cbor_magic_null => {
|
||||
v.* = json.Value{ .null = {} };
|
||||
break :ret true;
|
||||
},
|
||||
else => break :ret false,
|
||||
}
|
||||
},
|
||||
};
|
||||
if (ret) iter_.* = iter;
|
||||
return ret;
|
||||
}
|
||||
|
||||
fn matchArrayMore(iter_: *[]const u8, n_: u64) CborError!bool {
|
||||
var iter = iter_.*;
|
||||
var n = n_;
|
||||
while (n > 0) {
|
||||
if (!try matchValue(&iter, value_type.any))
|
||||
return false;
|
||||
n -= 1;
|
||||
}
|
||||
iter_.* = iter;
|
||||
return true;
|
||||
}
|
||||
|
||||
fn matchArray(iter_: *[]const u8, arr: anytype, info: anytype) CborError!bool {
|
||||
var iter = iter_.*;
|
||||
var n = try decodeArrayHeader(&iter);
|
||||
inline for (info.fields) |f| {
|
||||
const value = @field(arr, f.name);
|
||||
if (isMore(value))
|
||||
break;
|
||||
} else if (info.fields.len != n)
|
||||
return false;
|
||||
inline for (info.fields) |f| {
|
||||
const value = @field(arr, f.name);
|
||||
if (isMore(value))
|
||||
return matchArrayMore(&iter, n);
|
||||
if (n == 0) return false;
|
||||
const matched = try matchValue(&iter, @field(arr, f.name));
|
||||
if (!matched) return false;
|
||||
n -= 1;
|
||||
}
|
||||
if (n == 0) iter_.* = iter;
|
||||
return n == 0;
|
||||
}
|
||||
|
||||
fn matchJsonObject(iter_: *[]const u8, obj: *json.ObjectMap) !bool {
|
||||
var iter = iter_.*;
|
||||
const t = try decodeType(&iter);
|
||||
if (t.type == cbor_magic_null)
|
||||
return true;
|
||||
if (t.major != 5)
|
||||
return error.CborInvalidType;
|
||||
const ret = try decodeJsonObject(&iter, t.minor, obj);
|
||||
if (ret) iter_.* = iter;
|
||||
return ret;
|
||||
}
|
||||
|
||||
pub fn match(buf: []const u8, pattern: anytype) CborError!bool {
|
||||
var iter: []const u8 = buf;
|
||||
return matchValue(&iter, pattern);
|
||||
}
|
||||
|
||||
fn extractError(comptime T: type) noreturn {
|
||||
@compileError("cannot extract type '" ++ @typeName(T) ++ "' from cbor stream");
|
||||
}
|
||||
|
||||
fn hasExtractorTag(info: anytype) bool {
|
||||
if (info.is_tuple) return false;
|
||||
inline for (info.decls) |decl| {
|
||||
if (comptime eql(u8, decl.name, "EXTRACTOR_TAG"))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
fn isExtractor(comptime T: type) bool {
|
||||
return comptime switch (@typeInfo(T)) {
|
||||
.Struct => |info| hasExtractorTag(info),
|
||||
else => false,
|
||||
};
|
||||
}
|
||||
|
||||
const JsonValueExtractor = struct {
|
||||
dest: *T,
|
||||
const Self = @This();
|
||||
pub const EXTRACTOR_TAG = struct {};
|
||||
const T = json.Value;
|
||||
|
||||
pub fn init(dest: *T) Self {
|
||||
return .{ .dest = dest };
|
||||
}
|
||||
|
||||
pub fn extract(self: Self, iter: *[]const u8) CborError!bool {
|
||||
var null_heap_: [0]u8 = undefined;
|
||||
var heap = fba.init(&null_heap_);
|
||||
return matchJsonValue(iter, self.dest, heap.allocator());
|
||||
}
|
||||
};
|
||||
|
||||
const JsonObjectExtractor = struct {
|
||||
dest: *T,
|
||||
const Self = @This();
|
||||
pub const EXTRACTOR_TAG = struct {};
|
||||
const T = json.ObjectMap;
|
||||
|
||||
pub fn init(dest: *T) Self {
|
||||
return .{ .dest = dest };
|
||||
}
|
||||
|
||||
pub fn extract(self: Self, iter: *[]const u8) CborError!bool {
|
||||
return matchJsonObject(iter, self.dest);
|
||||
}
|
||||
};
|
||||
|
||||
fn Extractor(comptime T: type) type {
|
||||
if (T == json.Value)
|
||||
return JsonValueExtractor;
|
||||
if (T == json.ObjectMap)
|
||||
return JsonObjectExtractor;
|
||||
return struct {
|
||||
dest: *T,
|
||||
const Self = @This();
|
||||
pub const EXTRACTOR_TAG = struct {};
|
||||
|
||||
pub fn init(dest: *T) Self {
|
||||
return .{ .dest = dest };
|
||||
}
|
||||
|
||||
pub fn extract(self: Self, iter: *[]const u8) CborError!bool {
|
||||
switch (comptime @typeInfo(T)) {
|
||||
.Int, .ComptimeInt => return matchInt(T, iter, self.dest),
|
||||
.Bool => return matchBool(iter, self.dest),
|
||||
.Pointer => |ptr_info| switch (ptr_info.size) {
|
||||
.Slice => {
|
||||
if (ptr_info.child == u8) return matchString(iter, self.dest) else extractError(T);
|
||||
},
|
||||
else => extractError(T),
|
||||
},
|
||||
else => extractError(T),
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
fn ExtractorType(comptime T: type) type {
|
||||
const T_type_info = @typeInfo(T);
|
||||
if (T_type_info != .Pointer) @compileError("extract requires a pointer argument");
|
||||
return Extractor(T_type_info.Pointer.child);
|
||||
}
|
||||
|
||||
pub fn extract(dest: anytype) ExtractorType(@TypeOf(dest)) {
|
||||
comptime {
|
||||
if (!isExtractor(ExtractorType(@TypeOf(dest))))
|
||||
@compileError("isExtractor self check failed for " ++ @typeName(ExtractorType(@TypeOf(dest))));
|
||||
}
|
||||
return ExtractorType(@TypeOf(dest)).init(dest);
|
||||
}
|
||||
|
||||
const CborExtractor = struct {
|
||||
dest: *[]const u8,
|
||||
const Self = @This();
|
||||
pub const EXTRACTOR_TAG = struct {};
|
||||
|
||||
pub fn init(dest: *[]const u8) Self {
|
||||
return .{ .dest = dest };
|
||||
}
|
||||
|
||||
pub fn extract(self: Self, iter: *[]const u8) CborError!bool {
|
||||
const b = iter.*;
|
||||
try skipValue(iter);
|
||||
self.dest.* = b[0..(b.len - iter.len)];
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
pub fn extract_cbor(dest: *[]const u8) CborExtractor {
|
||||
return CborExtractor.init(dest);
|
||||
}
|
||||
|
||||
pub fn JsonStream(comptime T: type) type {
|
||||
return struct {
|
||||
const Writer = T.Writer;
|
||||
const JsonWriter = json.WriteStream(Writer, .{ .checked_to_fixed_depth = 256 });
|
||||
|
||||
fn jsonWriteArray(w: *JsonWriter, iter: *[]const u8, minor: u5) !void {
|
||||
var count = try decodePInt(iter, minor);
|
||||
try w.beginArray();
|
||||
while (count > 0) : (count -= 1) {
|
||||
try jsonWriteValue(w, iter);
|
||||
}
|
||||
try w.endArray();
|
||||
}
|
||||
|
||||
fn jsonWriteMap(w: *JsonWriter, iter: *[]const u8, minor: u5) !void {
|
||||
var count = try decodePInt(iter, minor);
|
||||
try w.beginObject();
|
||||
while (count > 0) : (count -= 1) {
|
||||
const t = try decodeType(iter);
|
||||
if (t.major != 3) return error.CborInvalidType;
|
||||
try w.objectField(try decodeString(iter, t.minor));
|
||||
try jsonWriteValue(w, iter);
|
||||
}
|
||||
try w.endObject();
|
||||
}
|
||||
|
||||
pub fn jsonWriteValue(w: *JsonWriter, iter: *[]const u8) (CborJsonError || Writer.Error)!void {
|
||||
const t = try decodeType(iter);
|
||||
if (t.type == cbor_magic_false)
|
||||
return w.write(false);
|
||||
if (t.type == cbor_magic_true)
|
||||
return w.write(true);
|
||||
if (t.type == cbor_magic_null)
|
||||
return w.write(null);
|
||||
return switch (t.major) {
|
||||
0 => w.write(try decodePInt(iter, t.minor)), // positive integer
|
||||
1 => w.write(try decodeNInt(iter, t.minor)), // negative integer
|
||||
2 => error.CborUnsupportedType, // bytes
|
||||
3 => w.write(try decodeString(iter, t.minor)), // string
|
||||
4 => jsonWriteArray(w, iter, t.minor), // array
|
||||
5 => jsonWriteMap(w, iter, t.minor), // map
|
||||
else => error.CborInvalidType,
|
||||
};
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
pub fn toJson(cbor_buf: []const u8, json_buf: []u8) CborJsonError![]const u8 {
|
||||
var fbs = fixedBufferStream(json_buf);
|
||||
var s = json.writeStream(fbs.writer(), .{});
|
||||
var iter: []const u8 = cbor_buf;
|
||||
try JsonStream(@TypeOf(fbs)).jsonWriteValue(&s, &iter);
|
||||
return fbs.getWritten();
|
||||
}
|
||||
|
||||
pub fn toJsonPretty(cbor_buf: []const u8, json_buf: []u8) CborJsonError![]const u8 {
|
||||
var fbs = fixedBufferStream(json_buf);
|
||||
var s = json.writeStream(fbs.writer(), .{ .whitespace = .indent_1 });
|
||||
var iter: []const u8 = cbor_buf;
|
||||
try JsonStream(@TypeOf(fbs)).jsonWriteValue(&s, &iter);
|
||||
return fbs.getWritten();
|
||||
}
|
||||
|
||||
fn writeJsonValue(writer: anytype, value: json.Value) !void {
|
||||
try switch (value) {
|
||||
.array => |_| unreachable,
|
||||
.object => |_| unreachable,
|
||||
.null => writeNull(writer),
|
||||
.float => |_| error.CborUnsupportedType,
|
||||
inline else => |v| writeValue(writer, v),
|
||||
};
|
||||
}
|
||||
|
||||
fn jsonScanUntil(writer: anytype, scanner: *json.Scanner, end_token: anytype) CborJsonError!usize {
|
||||
var partial = try std.BoundedArray(u8, 4096).init(0);
|
||||
var count: usize = 0;
|
||||
|
||||
var token = try scanner.next();
|
||||
while (token != end_token) : (token = try scanner.next()) {
|
||||
count += 1;
|
||||
switch (token) {
|
||||
.object_begin => try writeJsonObject(writer, scanner),
|
||||
.array_begin => try writeJsonArray(writer, scanner),
|
||||
|
||||
.true => try writeBool(writer, true),
|
||||
.false => try writeBool(writer, false),
|
||||
.null => try writeNull(writer),
|
||||
|
||||
.number => |v| {
|
||||
try partial.appendSlice(v);
|
||||
try writeJsonValue(writer, json.Value.parseFromNumberSlice(partial.slice()));
|
||||
try partial.resize(0);
|
||||
},
|
||||
.partial_number => |v| {
|
||||
try partial.appendSlice(v);
|
||||
count -= 1;
|
||||
},
|
||||
|
||||
.string => |v| {
|
||||
try partial.appendSlice(v);
|
||||
try writeString(writer, partial.slice());
|
||||
try partial.resize(0);
|
||||
},
|
||||
.partial_string => |v| {
|
||||
try partial.appendSlice(v);
|
||||
count -= 1;
|
||||
},
|
||||
.partial_string_escaped_1 => |v| {
|
||||
try partial.appendSlice(&v);
|
||||
count -= 1;
|
||||
},
|
||||
.partial_string_escaped_2 => |v| {
|
||||
try partial.appendSlice(&v);
|
||||
count -= 1;
|
||||
},
|
||||
.partial_string_escaped_3 => |v| {
|
||||
try partial.appendSlice(&v);
|
||||
count -= 1;
|
||||
},
|
||||
.partial_string_escaped_4 => |v| {
|
||||
try partial.appendSlice(&v);
|
||||
count -= 1;
|
||||
},
|
||||
|
||||
else => return error.SyntaxError,
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
pub const local_heap_size = 4096 * 16;
|
||||
|
||||
fn writeJsonArray(writer_: anytype, scanner: *json.Scanner) CborJsonError!void {
|
||||
var buf: [local_heap_size]u8 = undefined;
|
||||
var stream = fixedBufferStream(&buf);
|
||||
const writer = stream.writer();
|
||||
const count = try jsonScanUntil(writer, scanner, .array_end);
|
||||
try writeArrayHeader(writer_, count);
|
||||
try writer_.writeAll(stream.getWritten());
|
||||
}
|
||||
|
||||
fn writeJsonObject(writer_: anytype, scanner: *json.Scanner) CborJsonError!void {
|
||||
var buf: [local_heap_size]u8 = undefined;
|
||||
var stream = fixedBufferStream(&buf);
|
||||
const writer = stream.writer();
|
||||
const count = try jsonScanUntil(writer, scanner, .object_end);
|
||||
try writeMapHeader(writer_, count / 2);
|
||||
try writer_.writeAll(stream.getWritten());
|
||||
}
|
||||
|
||||
pub fn fromJson(json_buf: []const u8, cbor_buf: []u8) ![]const u8 {
|
||||
var local_heap_: [local_heap_size]u8 = undefined;
|
||||
var heap = fba.init(&local_heap_);
|
||||
var stream = fixedBufferStream(cbor_buf);
|
||||
const writer = stream.writer();
|
||||
|
||||
var scanner = json.Scanner.initCompleteInput(heap.allocator(), json_buf);
|
||||
defer scanner.deinit();
|
||||
|
||||
_ = try jsonScanUntil(writer, &scanner, .end_of_document);
|
||||
return stream.getWritten();
|
||||
}
|
||||
|
|
@ -1,4 +1,5 @@
|
|||
const std = @import("std");
|
||||
const cbor = @import("cbor");
|
||||
|
||||
const application_name = "flow";
|
||||
|
||||
|
|
@ -12,7 +13,6 @@ pub fn read_config(a: std.mem.Allocator, buf: *?[]const u8) config {
|
|||
}
|
||||
|
||||
fn read_json_config_file(a: std.mem.Allocator, file_name: []const u8, buf: *?[]const u8) !config {
|
||||
const cbor = @import("cbor.zig");
|
||||
var file = std.fs.openFileAbsolute(file_name, .{ .mode = .read_only }) catch |e| switch (e) {
|
||||
error.FileNotFound => return .{},
|
||||
else => return e,
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue