stage2 更多底层函数 stage1 layout正确使用 内置函数重新编写
This commit is contained in:
zzy committed
1 parent
fb0ff9b663
commit
4141e7d574
15 files changed
+2588
-122
No files matched your search
@@ -0,0 +1,780 @@
|
||||
// Expect retcode = 0
|
||||
// 轻量 JSON 解析 / 输出器（递归下降 + 节点池），用于验证底层库的拼装，未来服务 LSP。
|
||||
// 设计：
|
||||
// - 输入 ByteView，字符串/数字以“源切片”借用，不做解码，round-trip 保真；
|
||||
// - 节点池 Vec[JsonNode]；数组/对象子项存 Vec[JsonChild]，保留插入顺序；
|
||||
// - 错误带字节位置（error.spl）；输出写 ByteBuffer；缩进/数字用 ByteBuffer/fmt。
|
||||
// 限制：不做字符串转义解码、无递归深度保护、数字不做数值化（原样保存）。
|
||||
|
||||
type .{ .Error, .Status, .make, .at } = @import("error.spl");
|
||||
type .{ .ByteView, .ViewResult, .FindResult } = @import("byte_view.spl");
|
||||
type .{ .Vec } = @import("vec.spl");
|
||||
type .{ .ByteBuffer } = @import("byte_buffer.spl");
|
||||
type .{ .is_digit, .is_hex_digit, .is_space } = @import("ascii.spl");
|
||||
type .{ .append_i64, .append_u64 } = @import("fmt.spl");
|
||||
|
||||
type JsonKind = enum {
|
||||
Null,
|
||||
True,
|
||||
False,
|
||||
Number,
|
||||
String,
|
||||
Array,
|
||||
Object,
|
||||
}
|
||||
|
||||
// 数组元素或对象成员。数组时 key 为空视图；对象时 key 为源中的原始键文本。
|
||||
type JsonChild = struct {
|
||||
key: ByteView,
|
||||
val: usize,
|
||||
}
|
||||
|
||||
type JsonNode = struct {
|
||||
kind: JsonKind,
|
||||
text: ByteView,
|
||||
children: Vec,
|
||||
}
|
||||
|
||||
// 解析结果文档：nodes 拥有全部节点；root 为根节点下标。
|
||||
type Json = struct {
|
||||
nodes: Vec,
|
||||
root: usize,
|
||||
}
|
||||
|
||||
type JsonResult = enum {
|
||||
Ok: Json,
|
||||
Err: Error,
|
||||
}
|
||||
|
||||
type NodeResult = enum {
|
||||
Ok: usize,
|
||||
Err: Error,
|
||||
}
|
||||
|
||||
type Parser = struct {
|
||||
src: ByteView,
|
||||
pos: usize,
|
||||
nodes: Vec,
|
||||
}
|
||||
|
||||
fn blank_node(kind: JsonKind): JsonNode {
|
||||
ret JsonNode {
|
||||
.kind = kind,
|
||||
.text = ByteView.empty(),
|
||||
.children = Vec.blank(@sizeof(JsonChild), 8),
|
||||
};
|
||||
}
|
||||
|
||||
fn intern_node(p: *Parser, node: JsonNode): NodeResult {
|
||||
var index = p.nodes.len;
|
||||
var n = node;
|
||||
match Vec.push(&p.nodes, &n as *u8) {
|
||||
.Ok => {},
|
||||
.Err(error) => { ret .Err(error); },
|
||||
}
|
||||
ret .Ok(index);
|
||||
}
|
||||
|
||||
fn node_at(doc: *Json, index: usize): *JsonNode {
|
||||
match Vec.get(&doc.nodes, index) {
|
||||
.Ok(ptr) => { ret ptr as *JsonNode; },
|
||||
.Err(error) => { ret null; },
|
||||
}
|
||||
ret null;
|
||||
}
|
||||
|
||||
fn skip_ws(p: *Parser) {
|
||||
while p.pos < p.src.len && is_space(p.src.ptr[p.pos]) {
|
||||
p.pos = p.pos + 1;
|
||||
}
|
||||
}
|
||||
|
||||
// -1 表示 EOF。
|
||||
fn peek(p: *Parser): i32 {
|
||||
if p.pos >= p.src.len { ret -1; }
|
||||
ret p.src.ptr[p.pos] as i32;
|
||||
}
|
||||
|
||||
fn parse_string_raw(p: *Parser): ViewResult {
|
||||
if peek(p) != 34 { ret .Err(at(.InvalidFormat, p.pos)); }
|
||||
p.pos = p.pos + 1;
|
||||
var start = p.pos;
|
||||
while p.pos < p.src.len {
|
||||
var c = p.src.ptr[p.pos];
|
||||
if c == 34 { break; }
|
||||
if c == 92 { // '\\'
|
||||
p.pos = p.pos + 1;
|
||||
if p.pos >= p.src.len { ret .Err(at(.UnexpectedEnd, p.pos)); }
|
||||
if p.src.ptr[p.pos] == 117 { // 'u'
|
||||
var k: usize = 0;
|
||||
while k < 4 {
|
||||
p.pos = p.pos + 1;
|
||||
if p.pos >= p.src.len { ret .Err(at(.UnexpectedEnd, p.pos)); }
|
||||
if !is_hex_digit(p.src.ptr[p.pos]) { ret .Err(at(.InvalidDigit, p.pos)); }
|
||||
k = k + 1;
|
||||
}
|
||||
}
|
||||
} else if c < 32 {
|
||||
ret .Err(at(.InvalidFormat, p.pos));
|
||||
}
|
||||
p.pos = p.pos + 1;
|
||||
}
|
||||
if p.pos >= p.src.len { ret .Err(at(.UnexpectedEnd, p.pos)); }
|
||||
var end = p.pos;
|
||||
p.pos = p.pos + 1; // 收尾引号
|
||||
ret ByteView.slice(p.src, start, end);
|
||||
}
|
||||
|
||||
fn parse_literal(p: *Parser, word: []u8, kind: JsonKind): NodeResult {
|
||||
var i: usize = 0;
|
||||
while i < word.len {
|
||||
if p.pos + i >= p.src.len { ret .Err(at(.UnexpectedEnd, p.src.len)); }
|
||||
if p.src.ptr[p.pos + i] != word.ptr[i] {
|
||||
ret .Err(at(.InvalidFormat, p.pos + i));
|
||||
}
|
||||
i = i + 1;
|
||||
}
|
||||
p.pos = p.pos + word.len;
|
||||
var node = blank_node(kind);
|
||||
ret intern_node(p, node);
|
||||
}
|
||||
|
||||
fn parse_number(p: *Parser): NodeResult {
|
||||
var start = p.pos;
|
||||
if peek(p) == 45 { p.pos = p.pos + 1; } // '-'
|
||||
if p.pos >= p.src.len || !is_digit(p.src.ptr[p.pos]) {
|
||||
ret .Err(at(.InvalidDigit, p.pos));
|
||||
}
|
||||
if p.src.ptr[p.pos] == 48 { // 前导 0 后面不能接数字
|
||||
p.pos = p.pos + 1;
|
||||
} else {
|
||||
while p.pos < p.src.len && is_digit(p.src.ptr[p.pos]) {
|
||||
p.pos = p.pos + 1;
|
||||
}
|
||||
}
|
||||
if p.pos < p.src.len && p.src.ptr[p.pos] == 46 { // '.'
|
||||
p.pos = p.pos + 1;
|
||||
if p.pos >= p.src.len || !is_digit(p.src.ptr[p.pos]) {
|
||||
ret .Err(at(.InvalidDigit, p.pos));
|
||||
}
|
||||
while p.pos < p.src.len && is_digit(p.src.ptr[p.pos]) {
|
||||
p.pos = p.pos + 1;
|
||||
}
|
||||
}
|
||||
if p.pos < p.src.len && (p.src.ptr[p.pos] == 101 || p.src.ptr[p.pos] == 69) { // e/E
|
||||
p.pos = p.pos + 1;
|
||||
if p.pos < p.src.len && (p.src.ptr[p.pos] == 43 || p.src.ptr[p.pos] == 45) {
|
||||
p.pos = p.pos + 1;
|
||||
}
|
||||
if p.pos >= p.src.len || !is_digit(p.src.ptr[p.pos]) {
|
||||
ret .Err(at(.InvalidDigit, p.pos));
|
||||
}
|
||||
while p.pos < p.src.len && is_digit(p.src.ptr[p.pos]) {
|
||||
p.pos = p.pos + 1;
|
||||
}
|
||||
}
|
||||
|
||||
var text = ByteView.slice(p.src, start, p.pos);
|
||||
match text {
|
||||
.Ok(v) => {
|
||||
var node = blank_node(.Number);
|
||||
node.text = v;
|
||||
ret intern_node(p, node);
|
||||
},
|
||||
.Err(error) => { ret .Err(error); },
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_array(p: *Parser): NodeResult {
|
||||
p.pos = p.pos + 1; // '['
|
||||
var kids = Vec.blank(@sizeof(JsonChild), 8);
|
||||
|
||||
skip_ws(p);
|
||||
if peek(p) == 93 { // ']'
|
||||
p.pos = p.pos + 1;
|
||||
var empty = blank_node(.Array);
|
||||
empty.children = kids;
|
||||
ret intern_node(p, empty);
|
||||
}
|
||||
|
||||
while true {
|
||||
var element = parse_value(p);
|
||||
var index: usize = 0;
|
||||
match element {
|
||||
.Ok(v) => { index = v; },
|
||||
.Err(error) => { Vec.drop(&kids); ret .Err(error); },
|
||||
}
|
||||
var child = JsonChild { .key = ByteView.empty(), .val = index };
|
||||
match Vec.push(&kids, &child as *u8) {
|
||||
.Ok => {},
|
||||
.Err(error) => { Vec.drop(&kids); ret .Err(error); },
|
||||
}
|
||||
|
||||
skip_ws(p);
|
||||
var c = peek(p);
|
||||
if c == 44 { // ','
|
||||
p.pos = p.pos + 1;
|
||||
continue;
|
||||
}
|
||||
if c == 93 { // ']'
|
||||
p.pos = p.pos + 1;
|
||||
break;
|
||||
}
|
||||
Vec.drop(&kids);
|
||||
ret .Err(at(.InvalidFormat, p.pos));
|
||||
}
|
||||
|
||||
var node = blank_node(.Array);
|
||||
node.children = kids;
|
||||
ret intern_node(p, node);
|
||||
}
|
||||
|
||||
fn parse_object(p: *Parser): NodeResult {
|
||||
p.pos = p.pos + 1; // '{'
|
||||
var kids = Vec.blank(@sizeof(JsonChild), 8);
|
||||
|
||||
skip_ws(p);
|
||||
if peek(p) == 125 { // '}'
|
||||
p.pos = p.pos + 1;
|
||||
var empty = blank_node(.Object);
|
||||
empty.children = kids;
|
||||
ret intern_node(p, empty);
|
||||
}
|
||||
|
||||
while true {
|
||||
skip_ws(p);
|
||||
var key_view = ByteView.empty();
|
||||
match parse_string_raw(p) {
|
||||
.Ok(v) => { key_view = v; },
|
||||
.Err(error) => { Vec.drop(&kids); ret .Err(error); },
|
||||
}
|
||||
|
||||
skip_ws(p);
|
||||
if peek(p) != 58 { // ':'
|
||||
Vec.drop(&kids);
|
||||
ret .Err(at(.InvalidFormat, p.pos));
|
||||
}
|
||||
p.pos = p.pos + 1;
|
||||
|
||||
var value = parse_value(p);
|
||||
var index: usize = 0;
|
||||
match value {
|
||||
.Ok(v) => { index = v; },
|
||||
.Err(error) => { Vec.drop(&kids); ret .Err(error); },
|
||||
}
|
||||
|
||||
var child = JsonChild { .key = key_view, .val = index };
|
||||
match Vec.push(&kids, &child as *u8) {
|
||||
.Ok => {},
|
||||
.Err(error) => { Vec.drop(&kids); ret .Err(error); },
|
||||
}
|
||||
|
||||
skip_ws(p);
|
||||
var c = peek(p);
|
||||
if c == 44 { // ','
|
||||
p.pos = p.pos + 1;
|
||||
continue;
|
||||
}
|
||||
if c == 125 { // '}'
|
||||
p.pos = p.pos + 1;
|
||||
break;
|
||||
}
|
||||
Vec.drop(&kids);
|
||||
ret .Err(at(.InvalidFormat, p.pos));
|
||||
}
|
||||
|
||||
var node = blank_node(.Object);
|
||||
node.children = kids;
|
||||
ret intern_node(p, node);
|
||||
}
|
||||
|
||||
fn parse_value(p: *Parser): NodeResult {
|
||||
skip_ws(p);
|
||||
var c = peek(p);
|
||||
if c < 0 { ret .Err(at(.UnexpectedEnd, p.pos)); }
|
||||
var ch = c as u8;
|
||||
|
||||
if ch == 34 { // '"'
|
||||
var view = ByteView.empty();
|
||||
match parse_string_raw(p) {
|
||||
.Ok(v) => { view = v; },
|
||||
.Err(error) => { ret .Err(error); },
|
||||
}
|
||||
var node = blank_node(.String);
|
||||
node.text = view;
|
||||
ret intern_node(p, node);
|
||||
}
|
||||
if ch == 123 { ret parse_object(p); } // '{'
|
||||
if ch == 91 { ret parse_array(p); } // '['
|
||||
if ch == 116 { ret parse_literal(p, "true", .True); }
|
||||
if ch == 102 { ret parse_literal(p, "false", .False); }
|
||||
if ch == 110 { ret parse_literal(p, "null", .Null); }
|
||||
ret parse_number(p);
|
||||
}
|
||||
|
||||
fn drop_node_pool(pool: *Vec) {
|
||||
var i: usize = 0;
|
||||
while i < pool.*.len {
|
||||
match Vec.get(pool, i) {
|
||||
.Ok(ptr) => {
|
||||
var n = ptr as *JsonNode;
|
||||
Vec.drop(&n.children);
|
||||
},
|
||||
.Err(error) => {},
|
||||
}
|
||||
i = i + 1;
|
||||
}
|
||||
Vec.drop(pool);
|
||||
}
|
||||
|
||||
fn parse(src: ByteView): JsonResult {
|
||||
var p = Parser {
|
||||
.src = src,
|
||||
.pos = 0,
|
||||
.nodes = Vec.blank(@sizeof(JsonNode), 8),
|
||||
};
|
||||
|
||||
skip_ws(&p);
|
||||
var root: usize = 0;
|
||||
var result = parse_value(&p);
|
||||
match result {
|
||||
.Ok(index) => { root = index; },
|
||||
.Err(error) => {
|
||||
drop_node_pool(&p.nodes);
|
||||
ret .Err(error);
|
||||
},
|
||||
}
|
||||
|
||||
skip_ws(&p);
|
||||
if p.pos != src.len {
|
||||
drop_node_pool(&p.nodes);
|
||||
ret .Err(at(.InvalidFormat, p.pos));
|
||||
}
|
||||
|
||||
ret .Ok(Json { .nodes = p.nodes, .root = root });
|
||||
}
|
||||
|
||||
fn drop(doc: *Json) {
|
||||
drop_node_pool(&doc.nodes);
|
||||
}
|
||||
|
||||
fn root_index(doc: *Json): usize {
|
||||
ret doc.root;
|
||||
}
|
||||
|
||||
fn kind_of(doc: *Json, index: usize): JsonKind {
|
||||
var n = node_at(doc, index);
|
||||
if n == null { ret .Null; }
|
||||
ret n.kind;
|
||||
}
|
||||
|
||||
// 枚举 tag 取整（stage1 枚举 == 有缺陷，用 @enum2int 比较更稳妥）。
|
||||
fn kind_code(kind: JsonKind): usize {
|
||||
ret @enum2int(kind) as usize;
|
||||
}
|
||||
|
||||
fn text_of(doc: *Json, index: usize): ByteView {
|
||||
var n = node_at(doc, index);
|
||||
if n == null { ret ByteView.empty(); }
|
||||
ret n.text;
|
||||
}
|
||||
|
||||
fn array_count(doc: *Json, index: usize): usize {
|
||||
var n = node_at(doc, index);
|
||||
if n == null { ret 0; }
|
||||
match n.kind {
|
||||
.Array => { ret n.children.len; },
|
||||
_ => { ret 0; },
|
||||
}
|
||||
ret 0;
|
||||
}
|
||||
|
||||
fn array_at(doc: *Json, index: usize, i: usize): usize {
|
||||
var n = node_at(doc, index);
|
||||
if n == null { ret ~(0 as usize); }
|
||||
match n.kind {
|
||||
.Array => {
|
||||
if i >= n.children.len { ret ~(0 as usize); }
|
||||
match Vec.get(&n.children, i) {
|
||||
.Ok(ptr) => { ret (ptr as *JsonChild).val; },
|
||||
.Err(error) => { ret ~(0 as usize); },
|
||||
}
|
||||
},
|
||||
_ => { ret ~(0 as usize); },
|
||||
}
|
||||
ret ~(0 as usize);
|
||||
}
|
||||
|
||||
// 对象按键查找（线性，保持插入顺序）。找到返回节点下标。
|
||||
fn object_find(doc: *Json, index: usize, key: ByteView): FindResult {
|
||||
var n = node_at(doc, index);
|
||||
if n == null { ret .NotFound; }
|
||||
match n.kind {
|
||||
.Object => {
|
||||
var i: usize = 0;
|
||||
var count = n.children.len;
|
||||
while i < count {
|
||||
match Vec.get(&n.children, i) {
|
||||
.Ok(ptr) => {
|
||||
var child = ptr as *JsonChild;
|
||||
if ByteView.eq(child.key, key) { ret .Found(child.val); }
|
||||
},
|
||||
.Err(error) => {},
|
||||
}
|
||||
i = i + 1;
|
||||
}
|
||||
ret .NotFound;
|
||||
},
|
||||
_ => { ret .NotFound; },
|
||||
}
|
||||
ret .NotFound;
|
||||
}
|
||||
|
||||
fn emit_quoted(out: *ByteBuffer, text: ByteView): Status {
|
||||
match ByteBuffer.append_byte(out, 34) { // '"'
|
||||
.Ok => {},
|
||||
.Err(error) => { ret .Err(error); },
|
||||
}
|
||||
match ByteBuffer.append(out, ByteView.as_slice(text)) {
|
||||
.Ok => {},
|
||||
.Err(error) => { ret .Err(error); },
|
||||
}
|
||||
ret ByteBuffer.append_byte(out, 34);
|
||||
}
|
||||
|
||||
fn emit_indent(out: *ByteBuffer, indent: usize, depth: usize): Status {
|
||||
match ByteBuffer.append_byte(out, 10) { // '\n'
|
||||
.Ok => {},
|
||||
.Err(error) => { ret .Err(error); },
|
||||
}
|
||||
ret ByteBuffer.append_repeat(out, 32, depth * indent);
|
||||
}
|
||||
|
||||
fn emit(out: *ByteBuffer, doc: *Json, index: usize, indent: usize, depth: usize): Status {
|
||||
var n = node_at(doc, index);
|
||||
if n == null { ret .Err(make(.OutOfRange)); }
|
||||
|
||||
match n.kind {
|
||||
.Null => { ret ByteBuffer.append(out, "null"); },
|
||||
.True => { ret ByteBuffer.append(out, "true"); },
|
||||
.False => { ret ByteBuffer.append(out, "false"); },
|
||||
.Number => { ret ByteBuffer.append(out, ByteView.as_slice(n.text)); },
|
||||
.String => { ret emit_quoted(out, n.text); },
|
||||
.Array => { ret emit_children(out, doc, n, false, indent, depth); },
|
||||
.Object => { ret emit_children(out, doc, n, true, indent, depth); },
|
||||
}
|
||||
ret .Ok;
|
||||
}
|
||||
|
||||
fn emit_children(out: *ByteBuffer, doc: *Json, n: *JsonNode, is_object: bool, indent: usize,
|
||||
depth: usize): Status {
|
||||
var open_byte: u8 = 91; // '['
|
||||
var close_byte: u8 = 93; // ']'
|
||||
if is_object {
|
||||
open_byte = 123; // '{'
|
||||
close_byte = 125; // '}'
|
||||
}
|
||||
|
||||
match ByteBuffer.append_byte(out, open_byte) {
|
||||
.Ok => {},
|
||||
.Err(error) => { ret .Err(error); },
|
||||
}
|
||||
|
||||
var count = n.children.len;
|
||||
if count == 0 {
|
||||
ret ByteBuffer.append_byte(out, close_byte);
|
||||
}
|
||||
|
||||
var i: usize = 0;
|
||||
while i < count {
|
||||
if i != 0 {
|
||||
match ByteBuffer.append_byte(out, 44) { // ','
|
||||
.Ok => {},
|
||||
.Err(error) => { ret .Err(error); },
|
||||
}
|
||||
}
|
||||
if indent != 0 {
|
||||
match emit_indent(out, indent, depth + 1) {
|
||||
.Ok => {},
|
||||
.Err(error) => { ret .Err(error); },
|
||||
}
|
||||
}
|
||||
|
||||
match Vec.get(&n.children, i) {
|
||||
.Ok(ptr) => {
|
||||
var child = ptr as *JsonChild;
|
||||
if is_object {
|
||||
match emit_quoted(out, child.key) {
|
||||
.Ok => {},
|
||||
.Err(error) => { ret .Err(error); },
|
||||
}
|
||||
match ByteBuffer.append_byte(out, 58) { // ':'
|
||||
.Ok => {},
|
||||
.Err(error) => { ret .Err(error); },
|
||||
}
|
||||
if indent != 0 {
|
||||
match ByteBuffer.append_byte(out, 32) { // ' '
|
||||
.Ok => {},
|
||||
.Err(error) => { ret .Err(error); },
|
||||
}
|
||||
}
|
||||
}
|
||||
match emit(out, doc, child.val, indent, depth + 1) {
|
||||
.Ok => {},
|
||||
.Err(error) => { ret .Err(error); },
|
||||
}
|
||||
},
|
||||
.Err(error) => { ret .Err(error); },
|
||||
}
|
||||
i = i + 1;
|
||||
}
|
||||
|
||||
if indent != 0 {
|
||||
match emit_indent(out, indent, depth) {
|
||||
.Ok => {},
|
||||
.Err(error) => { ret .Err(error); },
|
||||
}
|
||||
}
|
||||
ret ByteBuffer.append_byte(out, close_byte);
|
||||
}
|
||||
|
||||
fn emit_compact(out: *ByteBuffer, doc: *Json): Status {
|
||||
ret emit(out, doc, doc.root, 0, 0);
|
||||
}
|
||||
|
||||
fn emit_pretty(out: *ByteBuffer, doc: *Json, indent: usize): Status {
|
||||
ret emit(out, doc, doc.root, indent, 0);
|
||||
}
|
||||
|
||||
// ---- 构造辅助（写 JSON 片段；字符串需由调用方保证已转义）----
|
||||
|
||||
fn write_int(out: *ByteBuffer, value: i64): Status {
|
||||
ret append_i64(out, value, 10, false);
|
||||
}
|
||||
|
||||
fn write_u64(out: *ByteBuffer, value: u64): Status {
|
||||
ret append_u64(out, value, 10, false);
|
||||
}
|
||||
|
||||
// ---- 测试辅助 ----
|
||||
|
||||
fn expect_ok(result: Status) {
|
||||
match result {
|
||||
.Ok => {},
|
||||
.Err(error) => { @assert(false, "unexpected json error"); },
|
||||
}
|
||||
}
|
||||
|
||||
fn expect_bytes(out: *ByteBuffer, expected: []u8) {
|
||||
var actual = ByteBuffer.as_slice(out.*);
|
||||
@assert(actual.len == expected.len, "emitted length");
|
||||
var i: usize = 0;
|
||||
while i < expected.len {
|
||||
@assert(actual.ptr[i] == expected.ptr[i], "emitted byte");
|
||||
i = i + 1;
|
||||
}
|
||||
}
|
||||
|
||||
fn expect_parse_error(result: JsonResult, pos: usize) {
|
||||
match result {
|
||||
.Ok(doc) => { @assert(false, "expected parse error"); },
|
||||
.Err(error) => {
|
||||
@assert(error.has_position, "positioned error");
|
||||
@assert(error.position == pos, "error position");
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn expect_kind(doc: *Json, index: usize, kind: JsonKind) {
|
||||
var n = node_at(doc, index);
|
||||
@assert(n != null, "node exists");
|
||||
@assert(kind_code(n.kind) == kind_code(kind), "node kind");
|
||||
}
|
||||
|
||||
fn expect_text(doc: *Json, index: usize, expected: []u8) {
|
||||
var got = text_of(doc, index);
|
||||
var want = ByteView.from_slice(expected);
|
||||
@assert(ByteView.eq(got, want), "node text");
|
||||
}
|
||||
|
||||
fn test_scalars() {
|
||||
var r = parse(ByteView.from_slice("null"));
|
||||
match r {
|
||||
.Ok(doc) => { expect_kind(&doc, root_index(&doc), .Null); drop(&doc); },
|
||||
.Err(error) => { @assert(false, "parse null"); },
|
||||
}
|
||||
|
||||
r = parse(ByteView.from_slice("true"));
|
||||
match r {
|
||||
.Ok(doc) => { expect_kind(&doc, root_index(&doc), .True); drop(&doc); },
|
||||
.Err(error) => { @assert(false, "parse true"); },
|
||||
}
|
||||
|
||||
r = parse(ByteView.from_slice("false"));
|
||||
match r {
|
||||
.Ok(doc) => { expect_kind(&doc, root_index(&doc), .False); drop(&doc); },
|
||||
.Err(error) => { @assert(false, "parse false"); },
|
||||
}
|
||||
|
||||
r = parse(ByteView.from_slice("-12.5e2"));
|
||||
match r {
|
||||
.Ok(doc) => {
|
||||
var idx = root_index(&doc);
|
||||
expect_kind(&doc, idx, .Number);
|
||||
expect_text(&doc, idx, "-12.5e2");
|
||||
drop(&doc);
|
||||
},
|
||||
.Err(error) => { @assert(false, "parse number"); },
|
||||
}
|
||||
|
||||
r = parse(ByteView.from_slice("\"hi\\n\""));
|
||||
match r {
|
||||
.Ok(doc) => {
|
||||
var idx = root_index(&doc);
|
||||
expect_kind(&doc, idx, .String);
|
||||
expect_text(&doc, idx, "hi\\n"); // 原始切片，未解码
|
||||
drop(&doc);
|
||||
},
|
||||
.Err(error) => { @assert(false, "parse string"); },
|
||||
}
|
||||
}
|
||||
|
||||
fn test_containers_and_lookup() {
|
||||
var text = "{\"a\":1,\"b\":[true,null,\"x\"],\"c\":{\"d\":2}}";
|
||||
var r = parse(ByteView.from_slice(text));
|
||||
match r {
|
||||
.Ok(doc) => {
|
||||
var root = root_index(&doc);
|
||||
expect_kind(&doc, root, .Object);
|
||||
|
||||
var a = ByteView.from_slice("a");
|
||||
match object_find(&doc, root, a) {
|
||||
.Found(idx) => {
|
||||
expect_kind(&doc, idx, .Number);
|
||||
expect_text(&doc, idx, "1");
|
||||
},
|
||||
.NotFound => { @assert(false, "find a"); },
|
||||
}
|
||||
|
||||
var b = ByteView.from_slice("b");
|
||||
var bidx: usize = 0;
|
||||
match object_find(&doc, root, b) {
|
||||
.Found(idx) => { bidx = idx; },
|
||||
.NotFound => { @assert(false, "find b"); },
|
||||
}
|
||||
expect_kind(&doc, bidx, .Array);
|
||||
@assert(array_count(&doc, bidx) == 3, "array count");
|
||||
expect_kind(&doc, array_at(&doc, bidx, 0), .True);
|
||||
expect_kind(&doc, array_at(&doc, bidx, 1), .Null);
|
||||
expect_text(&doc, array_at(&doc, bidx, 2), "x");
|
||||
|
||||
var c = ByteView.from_slice("c");
|
||||
var cidx: usize = 0;
|
||||
match object_find(&doc, root, c) {
|
||||
.Found(idx) => { cidx = idx; },
|
||||
.NotFound => { @assert(false, "find c"); },
|
||||
}
|
||||
var d = ByteView.from_slice("d");
|
||||
match object_find(&doc, cidx, d) {
|
||||
.Found(idx) => { expect_text(&doc, idx, "2"); },
|
||||
.NotFound => { @assert(false, "find c.d"); },
|
||||
}
|
||||
|
||||
var missing = ByteView.from_slice("zzz");
|
||||
match object_find(&doc, root, missing) {
|
||||
.Found(idx) => { @assert(false, "unexpected find"); },
|
||||
.NotFound => {},
|
||||
}
|
||||
|
||||
drop(&doc);
|
||||
},
|
||||
.Err(error) => { @assert(false, "parse object"); },
|
||||
}
|
||||
}
|
||||
|
||||
fn test_roundtrip_compact() {
|
||||
var text = "{\"a\":1,\"b\":[true,null,\"x\\n\"],\"c\":{},\"d\":[],\"e\":-3.5e-2}";
|
||||
var r = parse(ByteView.from_slice(text));
|
||||
match r {
|
||||
.Ok(doc) => {
|
||||
var out = ByteBuffer.new();
|
||||
expect_ok(emit_compact(&out, &doc));
|
||||
expect_bytes(&out, text);
|
||||
ByteBuffer.drop(&out);
|
||||
drop(&doc);
|
||||
},
|
||||
.Err(error) => { @assert(false, "parse for roundtrip"); },
|
||||
}
|
||||
}
|
||||
|
||||
fn test_pretty() {
|
||||
var text = "{\"a\":1,\"b\":[1,2]}";
|
||||
var r = parse(ByteView.from_slice(text));
|
||||
match r {
|
||||
.Ok(doc) => {
|
||||
var out = ByteBuffer.new();
|
||||
expect_ok(emit_pretty(&out, &doc, 2));
|
||||
var expected = "{\n \"a\": 1,\n \"b\": [\n 1,\n 2\n ]\n}";
|
||||
expect_bytes(&out, expected);
|
||||
ByteBuffer.drop(&out);
|
||||
drop(&doc);
|
||||
},
|
||||
.Err(error) => { @assert(false, "parse pretty"); },
|
||||
}
|
||||
}
|
||||
|
||||
fn test_errors() {
|
||||
expect_parse_error(parse(ByteView.from_slice("")), 0);
|
||||
expect_parse_error(parse(ByteView.from_slice("\"abc")), 4);
|
||||
expect_parse_error(parse(ByteView.from_slice("tru")), 3);
|
||||
expect_parse_error(parse(ByteView.from_slice("[1,]")), 3);
|
||||
expect_parse_error(parse(ByteView.from_slice("{\"a\":}")), 5);
|
||||
expect_parse_error(parse(ByteView.from_slice("1 2")), 2);
|
||||
expect_parse_error(parse(ByteView.from_slice("01")), 1);
|
||||
}
|
||||
|
||||
fn test_construction_helpers() {
|
||||
var out = ByteBuffer.new();
|
||||
expect_ok(ByteBuffer.append(&out, "{\"id\":"));
|
||||
expect_ok(write_u64(&out, 18446744073709551615));
|
||||
expect_ok(ByteBuffer.append(&out, ",\"n\":"));
|
||||
expect_ok(write_int(&out, -7));
|
||||
expect_ok(ByteBuffer.append(&out, "}"));
|
||||
expect_bytes(&out, "{\"id\":18446744073709551615,\"n\":-7}");
|
||||
ByteBuffer.drop(&out);
|
||||
}
|
||||
|
||||
fn test_large_array() {
|
||||
var out = ByteBuffer.new();
|
||||
expect_ok(ByteBuffer.append_byte(&out, 91)); // '['
|
||||
var i: usize = 0;
|
||||
while i < 1000 {
|
||||
if i != 0 { expect_ok(ByteBuffer.append_byte(&out, 44)); }
|
||||
expect_ok(ByteBuffer.append_byte(&out, 49)); // '1'
|
||||
i = i + 1;
|
||||
}
|
||||
expect_ok(ByteBuffer.append_byte(&out, 93)); // ']'
|
||||
|
||||
var text = ByteBuffer.as_slice(out);
|
||||
var r = parse(ByteView.from_slice(text));
|
||||
match r {
|
||||
.Ok(doc) => {
|
||||
expect_kind(&doc, root_index(&doc), .Array);
|
||||
@assert(array_count(&doc, root_index(&doc)) == 1000, "large array count");
|
||||
expect_kind(&doc, array_at(&doc, root_index(&doc), 999), .Number);
|
||||
drop(&doc);
|
||||
},
|
||||
.Err(error) => { @assert(false, "parse large array"); },
|
||||
}
|
||||
ByteBuffer.drop(&out);
|
||||
}
|
||||
|
||||
fn main() {
|
||||
test_scalars();
|
||||
test_containers_and_lookup();
|
||||
test_roundtrip_compact();
|
||||
test_pretty();
|
||||
test_errors();
|
||||
test_construction_helpers();
|
||||
test_large_array();
|
||||
}
|
||||
Reference in new issue
Block a user