mirror of
https://gitcode.com/JianFeeeee/HomeAgent.git
synced 2026-10-02 15:23:57 +00:00
feat(csrc): 第二刀 —— 零分配 JSON 扫描/取值层 ha_json_scan（含黄金对照）
C 化第二刀：为协议编解码层铺 JSON 底座。**本刀只交付库 + 验收，
未改 Go 生产路径**（接线是独立一步，库先验完再换产线）。
为什么是它：SSE 单块解析（parseOpenAICompatibleStreamChunkFull）是每个流式
chunk 都要跑的最热路径，实测 1937ns/13allocs（content 块）、3122ns/21allocs
（toolcall 块），而纯字节扫描理论下限 133ns/1alloc —— 差距 15~23×。
一次 1 万块的会话 = 1~2 万次堆分配，正是 GC 抖动的来源。
为什么不复用 SDK 的 remotedevice/ha_json.c（实测三缺陷，不可直接复用）：
① 无 \u 解码：\u4f60\u597d → ?0?d?d?0（非 ASCII 全靠转义时内容直接损坏）
② 只有 _get_int 无浮点：temperature:0.7 静默变 0
③ null 与「键缺失」不可区分
外加它是 DOM + malloc，与本层「不 malloc / 零拷贝 / 纯函数」正交。
设计：scan（结构，零分配零解码）+ extract（取值，按需解码）两段分离。
content 可能是很大的多模态数组，而 stringifyContent 只需要 text 字段拼起来；
若 scan 就解码并分配缓冲，等于把成本付给不需要它的调用方。
★ 被测试抓出 7 个真实缺陷（写 C 时同一逻辑我读三遍都认为正确）：
1 代理对合成成功后未跳过 unconditionally 的 U+FFFD 发射（😀 → 两个 FFFD）
2 过长编码检查用了只含首字节位的 cp（「你」→ 6 个 FFFD）
3 members_next 只报值起点不消费值 → 游标停在值前（模糊测试第一轮抓到）
4 扫描阶段不校验转义字符合法性（{"a":"\q"} C 判合法、json.Valid=false）
5 扫描阶段不校验 \u 后四位十六进制（同上）
6 get_int 接受前导零（007 / 00）
7 cgo 桥接把 C 结构体声明为 Go 局部变量 → 运行时 panic
（cgo argument has Go pointer to unpinned Go pointer）
其中 4 个是「静默分叉」——不崩、不报错，生产里表现为「内容少一个字符」
或「某些块被静默丢弃」，极难归因。这正是黄金对照不可省的理由。
★ 另纠正我自己两次错误的「真值」（比代码 bug 更危险，会变成错误规格）：
第一版真值表里 content:{} 的花括号少了一层，把「我写错 JSON」误读成
「Go 对 content 严格」。修正后实测发现一对方向相反的语义：
content 走 interface{} 宽松（{}→"{}"、true→"true"），
reasoning_content/usage/finish_reason 强类型严格（123 ⇒ 整块作废）。
照错误表写 C 会产出「比 Go 更严格」的实现，静默丢弃本该生效的块。
两个由缺陷倒逼的设计决定：
- members_next 返回**完整值 span** 并内部跳过 ⇒ 「返回 1」蕴含「成员良构」。
要求调用方自己推进游标的 API 是错的：忘一次就解析到上一个值且不报错。
- members_complete() 区分「正常扫到 }」与「输入畸形」，否则无法复刻 Go 严格性。
同时修两个基础设施目标对「多源文件/多测试」的适配：
- csrc-sanitize：每个契约测试各自链接（多个 main 合链会 multiple definition，
而报错被吞后会被误报成「本机无 sanitizer」——一个假的 SKIP）
- csrc-cross：多源文件改用 -fsyntax-only 逐文件（gcc 不支持多源单 -o）
实测（全部当场可复现）：
- C 契约测试 119 项断言全过；黄金对照 5 组全过（语法/成员/解码/整数/随机字节）
- libFuzzer 4948 万次运行零崩溃（121s）
- ASan+UBSan PASS（两个契约测试各跑）；gcc+clang 零告警；arm64 交叉编译 0 告警
- 全量 go test -count=1 ./... 0 FAIL；make build-linux-arm64 → ELF aarch64
- 纪律检查 SDK 公开接口 diff = 0 行（未触碰 SDK）
决策关闭（jianf 本轮裁决）：C 实现留主仓 csrc/（它本就是替换内核 Go 实现，
SDK 从未被触碰，跨端复用才需进 SDK 而它们不调用本层）；ha_json.c 不复用；
下一刀即协议编解码层。
This commit is contained in:
JianFeeeee
@ -115,6 +115,27 @@ func codecABIVersionMacroValue() int { return int(C.ha_abi_version_macro()) }
|
||||
func codecABIVersion() int { return int(C.ha_codec_abi_version()) }
|
||||
|
||||
|
||||
// cstr2 与 cstr 同义（返回 Go 的 string 版本），供 cgo 桥接层使用。
|
||||
// 名字不同是为了与测试文件里的辅助函数区分，避免包内重名。
|
||||
func cstr2(s string) (*C.char, C.size_t) { return cstr(s) }
|
||||
|
||||
// cstrb 取字节切片的首地址（供 C 侧写入目标缓冲）。
|
||||
func cstrb(b []byte) *C.char {
|
||||
if len(b) == 0 {
|
||||
return nil
|
||||
}
|
||||
return (*C.char)(unsafe.Pointer(&b[0]))
|
||||
}
|
||||
|
||||
// cstrp 返回 Go string 的底层字节首地址（不做空串短路，供
|
||||
// 「长度已知、可能为空」的取值场景使用）。
|
||||
func cstrp(s string) *C.char {
|
||||
if len(s) == 0 {
|
||||
return nil
|
||||
}
|
||||
return (*C.char)(unsafe.Pointer(unsafe.StringData(s)))
|
||||
}
|
||||
|
||||
// cstr 返回 s 的底层字节首地址与长度，供 C 侧零拷贝读取。
|
||||
//
|
||||
// 空串返回 (nil, 0)：调用方不应把 nil 传给会解引用的 C 函数。
|
||||
|
||||
269
internal/agent/api/codec_jsongolden_test.go
Normal file
269
internal/agent/api/codec_jsongolden_test.go
Normal file
@ -0,0 +1,269 @@
|
||||
//go:build cgo
|
||||
|
||||
package api
|
||||
|
||||
// codec_jsongolden_test.go —— ha_json_scan（C）与 encoding/json（Go）逐值对照。
|
||||
//
|
||||
// ============================ 这是本刀最重要的验收 ============================
|
||||
// 理由：C 侧手写扫描器最容易出的错不是崩溃，而是**静默的分叉** ——
|
||||
// 某个输入 Go 接受而 C 拒绝（或反之）、某个转义解码结果差一个字节。
|
||||
// 而这类分叉在生产里的表现是「内容偶尔少一个字符」「某些块被静默丢弃」，
|
||||
// 极难归因。因此必须有**同一批输入、两个实现、逐值比对**的测试。
|
||||
//
|
||||
// 参照第一刀的做法（codec_golden_test.go），此处比的是
|
||||
// C: ha_json_scan 的 scan / decode / get_int
|
||||
// Go: encoding/json 的等价行为
|
||||
//
|
||||
// 覆盖：语法严格性、键大小写不敏感、重复键后者胜、\u 与代理对、
|
||||
// 非法 UTF-8 → U+FFFD、整数溢出/小数/指数、畸形成员的辨别。
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"math/rand"
|
||||
"strconv"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// -----------------------------------------------------------------
|
||||
// 1. 语法严格性：C 的 skip 与 Go 的 json.Valid 必须一致
|
||||
// -----------------------------------------------------------------
|
||||
|
||||
func TestJSONGolden_SyntaxVsValid(t *testing.T) {
|
||||
cases := []string{
|
||||
`{}`, `{"a":1}`, `{"a":null}`, `{"a":true}`, `{"a":-1}`,
|
||||
`{"a":1.5}`, `{"a":1e2}`, `{"a":[]}`, `{"a":{}}`,
|
||||
`{"a":"b"}`, `{"a":"A"}`, ` {"a" : 1 } `,
|
||||
`{"a":"\u4f60\u597d"}`, `{"a":"\ud83d\ude00"}`,
|
||||
`{"a":{"b":[1,2,{"c":3}]}}`, `{"a":1,"b":2}`,
|
||||
`{"a":1,"a":2}`, // 重复键（合法）
|
||||
// 以下应与 json.Valid 一致地失败
|
||||
`{`, `}`, ``, `{"a"}`, `{"a":}`, `{"a":1,}`, `{'a':1}`,
|
||||
`{"a":01}`, `{"a":1.}`, `{"a":.5}`, `{"a":1e}`, `{"a":-}`,
|
||||
`{"a":tru}`, `{"a":1 "b":2}`, `{"a":"unclosed`,
|
||||
`{"a":"bad\ncontrol"}`, `{"a":"\q"}`, `{"a":"\u00"}`,
|
||||
`[1,2,]`, `{"a":[1,]}`, `{"a":1}{"b":2}`,
|
||||
`{"a":+1}`, `{"a":Infinity}`, `{"a":NaN}`,
|
||||
}
|
||||
for _, in := range cases {
|
||||
cOK := cjsSkipStrict(in)
|
||||
goOK := json.Valid([]byte(in))
|
||||
if cOK != goOK {
|
||||
t.Errorf("语法分歧 %q: C.skip=%v, json.Valid=%v", in, cOK, goOK)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------
|
||||
// 2. 成员迭代：C 与 Go 必须数到同样的键、且 complete 判定一致
|
||||
// -----------------------------------------------------------------
|
||||
|
||||
// goObjectKeysStrict 用 Go 自己的遍历统计键数；任何 unmarshal 失败即视为 0。
|
||||
func goKeys(in string) (int, bool) {
|
||||
var m map[string]json.RawMessage
|
||||
if err := json.Unmarshal([]byte(in), &m); err != nil {
|
||||
return 0, false
|
||||
}
|
||||
return len(m), true
|
||||
}
|
||||
|
||||
func TestJSONGolden_MembersCount(t *testing.T) {
|
||||
cases := []string{
|
||||
`{}`, `{"a":1}`, `{"a":1,"b":2}`, `{"a":1,"b":2,"c":3}`,
|
||||
`{"a":{"x":1},"b":[1,2]}`, `{"A":1,"a":2}`, // 大小写不同的键都算
|
||||
`{"":1}`, `{"a":"}"}`, `{"a":"{"}`, `{"a":"x,y,z"}`,
|
||||
`{"a":{"n":1},"b":{"n":2}}`,
|
||||
`{"a":1,}`, `{"a":1`, `{"a"}`, `{"a":}`,
|
||||
}
|
||||
for _, in := range cases {
|
||||
cInit, cCount, cComplete := cjsWalkMembers(in)
|
||||
|
||||
goCount, goOK := goKeys(in)
|
||||
|
||||
// init 的语义只是「首字符是 '{'」——它**不可能**知道对象是否闭合，
|
||||
// 所以不能用 Go 的 unmarshal ok 来判它（那是 complete 的职责）。
|
||||
// 这里分开断言：
|
||||
// init ↔ 首字符是 '{'
|
||||
// complete ↔ Go unmarshal 成功（整体良构）
|
||||
wantInit := strings.HasPrefix(strings.TrimSpace(in), "{")
|
||||
if cInit != wantInit {
|
||||
t.Errorf("init 分歧 %q: C.init=%v, 期望 %v", in, cInit, wantInit)
|
||||
continue
|
||||
}
|
||||
if !cInit {
|
||||
continue
|
||||
}
|
||||
if cComplete != goOK {
|
||||
t.Errorf("complete 分歧 %q: C=%v, Go=%v", in, cComplete, goOK)
|
||||
continue
|
||||
}
|
||||
if goOK && cCount != goCount {
|
||||
t.Errorf("成员数分歧 %q: C=%d, Go=%d", in, cCount, goCount)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------
|
||||
// 3. 字符串解码：C 与 Go 的 unquote 必须逐字节一致
|
||||
// -----------------------------------------------------------------
|
||||
|
||||
func TestJSONGolden_StringDecode(t *testing.T) {
|
||||
rawCases := []string{
|
||||
``, `a`, `hello world`, `中文`, `你好😀`,
|
||||
`\"`, `\\`, `\/`, `\b`, `\f`, `\n`, `\r`, `\t`,
|
||||
`\u0041`, `\u00e9`, `\u4f60\u597d`, `\ud83d\ude00`, `\u0000`,
|
||||
`mixed \u4e2d\u6587 and ascii`,
|
||||
`\ud83d` + `real`, // 孤立高代理
|
||||
`\udc00` + `real`, // 孤立低代理
|
||||
`\ud83dx`, // 高代理 + 非转义
|
||||
`\ud83d\u0041`, // 高代理 + 非低代理
|
||||
"\xff", "\xfe", "\xff\xfe", "\xc3", "\xc3\x28", "\xe0\x80\x80",
|
||||
"\xed\xa0\x80", "\xf5\x80\x80\x80", "\xf0\x9f\x98\x80", // 正常 4 字节
|
||||
"a\xffb", "\x80", "\xbf",
|
||||
`\uD83D\uDE00`, // 大写十六进制代理对
|
||||
}
|
||||
for _, raw := range rawCases {
|
||||
// Go 侧参照：把 raw 当作 JSON 字符串体的内容，解码
|
||||
goOut, goErr := goUnquoteBody(raw)
|
||||
doc := `"` + raw + `"`
|
||||
|
||||
// C 侧：先取字符串 span（去掉引号），再解码
|
||||
cRaw, rawOK := cjsScanString(doc)
|
||||
if !rawOK {
|
||||
if goErr == nil {
|
||||
t.Errorf("C 拒绝但 Go 接受: raw=%q", raw)
|
||||
}
|
||||
continue
|
||||
}
|
||||
cOut, cOK := cjsDecode(cRaw)
|
||||
|
||||
if goErr != nil {
|
||||
if cOK {
|
||||
t.Errorf("C 接受但 Go 报错: raw=%q -> %q", raw, cOut)
|
||||
}
|
||||
continue
|
||||
}
|
||||
if !cOK {
|
||||
t.Errorf("C 解码失败但 Go 成功: raw=%q 期望 %q", raw, goOut)
|
||||
continue
|
||||
}
|
||||
if cOut != goOut {
|
||||
t.Errorf("解码分歧 raw=%q:\n C = %q (% x)\n Go = %q (% x)",
|
||||
raw, cOut, cOut, goOut, goOut)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------
|
||||
// 4. 整数：C 与 Go（strconv.ParseInt 语义）一致
|
||||
// -----------------------------------------------------------------
|
||||
|
||||
func TestJSONGolden_GetInt(t *testing.T) {
|
||||
cases := []string{
|
||||
"0", "1", "-1", "12345", "-99999", "2147483647", "-2147483648",
|
||||
"9223372036854775807", "-9223372036854775808",
|
||||
"9223372036854775808", "-9223372036854775809",
|
||||
"99999999999999999999", "1.5", "1e2", "", "abc", "0x10", "+1", "007",
|
||||
"0", "-0", "00", "0.0", " 1", "1 ",
|
||||
}
|
||||
for _, in := range cases {
|
||||
cGot, cOK := cjsGetInt(in)
|
||||
var cVal int64 = cGot
|
||||
|
||||
// Go 参照：按 **JSON 整数语法**（而非 strconv 的宽松十进制）判定。
|
||||
// 差别在 "007"/"+1"：strconv.ParseInt 接受，但 JSON 语法禁止前导零与前导 +。
|
||||
// 本库的契约是「这是不是 JSON 整数」（以便调用方按
|
||||
// 「类型不匹配 ⇒ 整块作废」处理），故参照必须用同一判据。
|
||||
goOK := false
|
||||
var goVal int64
|
||||
if isJSONIntSyntax(in) {
|
||||
v, err := strconv.ParseInt(in, 10, 64)
|
||||
if err == nil {
|
||||
goOK, goVal = true, v
|
||||
}
|
||||
// 溢出（ErrRange）⇒ 与 C 一致：判为「不是可用整数」
|
||||
}
|
||||
if cOK != goOK {
|
||||
t.Errorf("整数可用性分歧 %q: C=%v, Go=%v", in, cOK, goOK)
|
||||
continue
|
||||
}
|
||||
if cOK && cVal != goVal {
|
||||
t.Errorf("整数值分歧 %q: C=%d, Go=%d", in, int64(cVal), goVal)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func isJSONIntSyntax(s string) bool {
|
||||
i := 0
|
||||
if i < len(s) && s[i] == '-' {
|
||||
i++
|
||||
}
|
||||
if i >= len(s) {
|
||||
return false
|
||||
}
|
||||
if s[i] == '0' {
|
||||
return i+1 == len(s)
|
||||
}
|
||||
if s[i] < '1' || s[i] > '9' {
|
||||
return false
|
||||
}
|
||||
for ; i < len(s); i++ {
|
||||
if s[i] < '0' || s[i] > '9' {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------
|
||||
// 5. 随机字节：两侧的「是否接受」必须一致（畸形输入等价性）
|
||||
// -----------------------------------------------------------------
|
||||
|
||||
func TestJSONGolden_RandomBytes(t *testing.T) {
|
||||
rng := rand.New(rand.NewSource(20260926))
|
||||
alphabet := []byte(`{}[]",:0123456789tfnul \` + "\n\t\xff\x80")
|
||||
mismatch := 0
|
||||
for iter := 0; iter < 20000 && mismatch < 5; iter++ {
|
||||
n := rng.Intn(40)
|
||||
b := make([]byte, n)
|
||||
for i := range b {
|
||||
b[i] = alphabet[rng.Intn(len(alphabet))]
|
||||
}
|
||||
cOK := cjsSkipStrict(string(b))
|
||||
goOK := json.Valid(b)
|
||||
if cOK != goOK {
|
||||
mismatch++
|
||||
t.Errorf("随机输入分歧 %q: C.skip=%v json.Valid=%v", b, cOK, goOK)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------
|
||||
// 6. ABI
|
||||
// -----------------------------------------------------------------
|
||||
|
||||
func TestJSONScanABIVersion(t *testing.T) {
|
||||
if got := cjsABIVersion(); got != 1000 {
|
||||
t.Errorf("ha_json_scan ABI = %d, 期望 1000 (1.0)", got)
|
||||
}
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------
|
||||
// 辅助
|
||||
// -----------------------------------------------------------------
|
||||
|
||||
// goUnquoteBody 用 encoding/json 自身解码一个 JSON 字符串体（raw = 不含两端引号）。
|
||||
//
|
||||
// ★ 正确做法是**直接把 body 原样**放进引号里交给 Unmarshal ——
|
||||
// body 里本来就带着它自己的转义（`\n` 是两个字节），若在此处再转义一遍，
|
||||
// 就把「转义序列」变成了「字面量」，参照值会整体跑偏。
|
||||
// 实测踩过：初版对 body 里的 `\` 和 `"` 做了二次转义，
|
||||
// 导致 Go 侧期望 `\n`（两字节）而 C 侧正确给出换行符 ——
|
||||
// 测试报了一堆「分歧」，其实错的是测试自己的参照。
|
||||
func goUnquoteBody(body string) (string, error) {
|
||||
var out string
|
||||
if err := json.Unmarshal([]byte(`"`+body+`"`), &out); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
210
internal/agent/api/codec_jsonscan_cgo.go
Normal file
210
internal/agent/api/codec_jsonscan_cgo.go
Normal file
@ -0,0 +1,210 @@
|
||||
//go:build cgo
|
||||
|
||||
package api
|
||||
|
||||
// codec_jsonscan_cgo.go — ha_json_scan（C）的 cgo 桥接。
|
||||
//
|
||||
// ============================ 为什么桥接在非测试文件里 ============================
|
||||
// Go **不允许在 _test.go 里用 cgo**（实测：use of cgo in test ... not supported）。
|
||||
// 而 C 侧静态链接函数没有对应的 Go 声明就没法调用 ⇒ 桥接必须落在这里，
|
||||
// 由 codec_jsongolden_test.go（纯 Go 测试）来验证其语义。
|
||||
//
|
||||
// 与 codec_cgo.go 同理：本包是 cgo-only（编解码层已完全 C 化），
|
||||
// 所以这些桥接函数在 CGO_ENABLED=0 下不存在，而那正是**有意的响亮失败**。
|
||||
|
||||
/*
|
||||
#cgo CFLAGS: -std=c99
|
||||
#include <stdlib.h>
|
||||
#include "ha_json_scan.h"
|
||||
|
||||
// cgo 编不了 C 宏，这里用一个小 helper 把 C 侧结果取出来。
|
||||
// span 指向 Go 传进来的原缓冲（零拷贝），Go 侧用 unsafe 读回。
|
||||
static ha_span go_scan_members(ha_json_members *m, ha_span *key) {
|
||||
ha_span val;
|
||||
if (!ha_json_members_next(m, key, &val)) {
|
||||
ha_span none;
|
||||
none.p = NULL;
|
||||
none.len = 0;
|
||||
return none;
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
static int go_members_complete(const ha_json_members *m) {
|
||||
return ha_json_members_complete(m);
|
||||
}
|
||||
|
||||
// 严格判定：整串**恰好**是一个 JSON 值（尾部只允许空白）。
|
||||
//
|
||||
// ★ 全部逻辑留在 C 侧，故意不让 Go 把 ha_json_scan 结构体传进来：
|
||||
// cgo 规则禁止「Go 指针指向的 Go 指针」。把 C 结构体声明成 Go 变量
|
||||
// 递给 C 时，若该变量因逃逸分析被堆分配，运行时无法证明它不含
|
||||
// Go 指针 ⇒ 直接 panic
|
||||
// （实测报 cgo argument has Go pointer to unpinned Go pointer）。
|
||||
// 正确做法是「只传裸指针 + 长度给 C，让 C 自己持有游标」——
|
||||
// 这也与库本身「零分配、调用方栈上持有」的设计一致。
|
||||
static int go_skip_strict(const char *s, size_t n) {
|
||||
ha_json_scan sc;
|
||||
ha_json_scan_init(&sc, s, n);
|
||||
if (!ha_json_skip(&sc)) {
|
||||
return 0;
|
||||
}
|
||||
(void)ha_json_scan_ws(&sc);
|
||||
return ha_json_scan_eof(&sc);
|
||||
}
|
||||
|
||||
static int go_skip(const char *s, size_t n) {
|
||||
ha_json_scan sc;
|
||||
ha_json_scan_init(&sc, s, n);
|
||||
return ha_json_skip(&sc);
|
||||
}
|
||||
|
||||
static int go_scan_string(const char *s, size_t n, size_t *out_len) {
|
||||
ha_json_scan sc;
|
||||
ha_json_scan_init(&sc, s, n);
|
||||
ha_span raw;
|
||||
if (!ha_json_scan_string(&sc, &raw)) {
|
||||
return 0;
|
||||
}
|
||||
*out_len = raw.len;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int go_decode(const char *p, size_t n, char *out, size_t cap, size_t *outlen) {
|
||||
ha_span raw;
|
||||
raw.p = p;
|
||||
raw.len = n;
|
||||
size_t k = ha_json_decode_string_into(raw, out, cap);
|
||||
if (k == (size_t)-1) {
|
||||
return 0;
|
||||
}
|
||||
*outlen = k;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int go_get_int(const char *p, size_t n, long long *out) {
|
||||
ha_span raw;
|
||||
raw.p = p;
|
||||
raw.len = n;
|
||||
return ha_json_get_int(raw, out);
|
||||
}
|
||||
|
||||
static int go_abi(void) { return ha_json_scan_abi_version(); }
|
||||
*/
|
||||
import "C"
|
||||
|
||||
import "unsafe"
|
||||
|
||||
// 供测试调用的 C 侧薄封装（C 的类型无法直接出现在测试文件里）
|
||||
|
||||
func cjsSkip(s string) bool {
|
||||
p, n := cstr2(s)
|
||||
return C.go_skip(p, n) == 1
|
||||
}
|
||||
|
||||
func cjsMembersInit(m *C.ha_json_members, s string) bool {
|
||||
p, n := cstr2(s)
|
||||
return C.ha_json_members_init(m, p, n) == 1
|
||||
}
|
||||
|
||||
// cjsMembersStep 推进一次迭代，只把**键**交回 Go。
|
||||
//
|
||||
// ★ 为什么只返回键：cgo 规则禁止把「Go 指针指向的 Go 指针」传给 C
|
||||
// （cgo argument has Go pointer to unpinned Go pointer）——若把 key 与
|
||||
// value 两个 span 都交回 Go，再在同一个调用里传回 C，就会构成
|
||||
// 「Go 切片 → Go 指针 → Go 指针」的未固定链，运行时直接 panic。
|
||||
// 所以每次跨语言只搬运**一个**字符串，其余信息留到下一次调用。
|
||||
//
|
||||
// ★ 值 span 只在需要时**在 C 侧**用（见 cjsWalkMembers）。
|
||||
func cjsMembersStep(m *C.ha_json_members) (key string, ok bool) {
|
||||
var ck C.ha_span
|
||||
v := C.go_scan_members(m, &ck)
|
||||
if v.p == nil {
|
||||
return "", false
|
||||
}
|
||||
return unsafeString(ck.p, int(ck.len)), true
|
||||
}
|
||||
|
||||
func cjsMembersComplete(m *C.ha_json_members) bool {
|
||||
return C.go_members_complete(m) == 1
|
||||
}
|
||||
|
||||
func cjsScanString(s string) (string, bool) {
|
||||
p, n := cstr2(s)
|
||||
var outLen C.size_t
|
||||
if C.go_scan_string(p, n, &outLen) == 0 {
|
||||
return "", false
|
||||
}
|
||||
// 去掉两端引号
|
||||
if n < 2 {
|
||||
return "", false
|
||||
}
|
||||
return string(s[1 : int(n)-1]), true
|
||||
}
|
||||
|
||||
func cjsDecode(raw string) (string, bool) {
|
||||
// 上界：每字节最坏变一个 3 字节 U+FFFD
|
||||
buf := make([]byte, len(raw)*3+16)
|
||||
var outLen C.size_t
|
||||
p := cstrp(raw)
|
||||
ok := C.go_decode(p, C.size_t(len(raw)), cstrb(buf), C.size_t(len(buf)), &outLen) == 1
|
||||
if !ok {
|
||||
return "", false
|
||||
}
|
||||
return string(buf[:int(outLen)]), true
|
||||
}
|
||||
|
||||
func cjsGetInt(s string) (int64, bool) {
|
||||
p, n := cstr2(s)
|
||||
var v C.longlong
|
||||
if C.go_get_int(p, n, &v) != 1 {
|
||||
return 0, false
|
||||
}
|
||||
return int64(v), true
|
||||
}
|
||||
|
||||
func cjsABIVersion() int { return int(C.go_abi()) }
|
||||
|
||||
// unsafeString 把 C 返回的 span（指向 Go 原缓冲）读成 Go string。
|
||||
func unsafeString(p *C.char, n int) string {
|
||||
if p == nil || n < 0 {
|
||||
return ""
|
||||
}
|
||||
bytes := (*[1 << 30]byte)(unsafe.Pointer(p))[:n:n]
|
||||
return string(bytes)
|
||||
}
|
||||
|
||||
// cjsWalkMembers 遍历一个对象字符串，返回 (init 成功, 成员数, 是否正常结束)。
|
||||
//
|
||||
// 存在的原因：Go 测试文件**不能引用 C 类型**（没有 cgo），
|
||||
// 而 ha_json_members 必须在 Go 栈上持有（零分配，见头文件设计约束）。
|
||||
// 故由本文件在内部持有并把结果压成三个 Go 值。
|
||||
func cjsWalkMembers(s string) (inited bool, count int, complete bool) {
|
||||
var m C.ha_json_members
|
||||
if !cjsMembersInit(&m, s) {
|
||||
return false, 0, false
|
||||
}
|
||||
for {
|
||||
_, ok := cjsMembersStep(&m)
|
||||
if !ok {
|
||||
break
|
||||
}
|
||||
count++
|
||||
if count > 100000 {
|
||||
break // 死循环保护
|
||||
}
|
||||
}
|
||||
return true, count, cjsMembersComplete(&m)
|
||||
}
|
||||
|
||||
// cjsSkipStrict 复刻 Go json.Unmarshal 的严格性：整个输入必须是**恰好一个**
|
||||
// JSON 值，尾部除空白外不得有残留。
|
||||
//
|
||||
// ★ 为什么测试不能只调 ha_json_skip：skip 的语义是「跳过这里的一个值」，
|
||||
// 它成功返回并不能证明「整串就是这一个值」。实测 `{"a":1}{"b":2}`
|
||||
// 在 skip 下成功，而 json.Valid=false —— 这正是两者职责的差别。
|
||||
// 内核协议层要的是严格语义，故这里显式做尾部校验。
|
||||
func cjsSkipStrict(s string) bool {
|
||||
p, n := cstr2(s)
|
||||
return C.go_skip_strict(p, n) == 1
|
||||
}
|
||||
1
internal/agent/api/ha_json_scan.c
Symbolic link
1
internal/agent/api/ha_json_scan.c
Symbolic link
@ -0,0 +1 @@
|
||||
../../../csrc/src/ha_json_scan.c
|
||||
1
internal/agent/api/ha_json_scan.h
Symbolic link
1
internal/agent/api/ha_json_scan.h
Symbolic link
@ -0,0 +1 @@
|
||||
../../../csrc/include/ha_json_scan.h
|
||||
Reference in New Issue
Block a user