实现基础web服务器

vendor/github.com/bytedance/sonic/ast/api_amd64.go

@@ -0,0 +1,151 @@
+// +build amd64,go1.15,!go1.21
+
+/*
+ * Copyright 2022 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ast
+
+import (
+    `runtime`
+    `unsafe`
+
+    `github.com/bytedance/sonic/encoder`
+    `github.com/bytedance/sonic/internal/native`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+    uq `github.com/bytedance/sonic/unquote`
+    `github.com/chenzhuoyu/base64x`
+)
+
+var typeByte = rt.UnpackEface(byte(0)).Type
+
+//go:nocheckptr
+func quote(buf *[]byte, val string) {
+    *buf = append(*buf, '"')
+    if len(val) == 0 {
+        *buf = append(*buf, '"')
+        return
+    }
+
+    sp := rt.IndexChar(val, 0)
+    nb := len(val)
+    b := (*rt.GoSlice)(unsafe.Pointer(buf))
+
+    // input buffer
+    for nb > 0 {
+        // output buffer
+        dp := unsafe.Pointer(uintptr(b.Ptr) + uintptr(b.Len))
+        dn := b.Cap - b.Len
+        // call native.Quote, dn is byte count it outputs
+        ret := native.Quote(sp, nb, dp, &dn, 0)
+        // update *buf length
+        b.Len += dn
+
+        // no need more output
+        if ret >= 0 {
+            break
+        }
+
+        // double buf size
+        *b = growslice(typeByte, *b, b.Cap*2)
+        // ret is the complement of consumed input
+        ret = ^ret
+        // update input buffer
+        nb -= ret
+        sp = unsafe.Pointer(uintptr(sp) + uintptr(ret))
+    }
+
+    runtime.KeepAlive(buf)
+    runtime.KeepAlive(sp)
+    *buf = append(*buf, '"')
+}
+
+func unquote(src string) (string, types.ParsingError) {
+    return uq.String(src)
+}
+
+func decodeBase64(src string) ([]byte, error) {
+    return base64x.StdEncoding.DecodeString(src)
+}
+
+func encodeBase64(src []byte) string {
+    return base64x.StdEncoding.EncodeToString(src)
+}
+
+func (self *Parser) decodeValue() (val types.JsonState) {
+    sv := (*rt.GoString)(unsafe.Pointer(&self.s))
+    self.p = native.Value(sv.Ptr, sv.Len, self.p, &val, 0)
+    return
+}
+
+func (self *Parser) skip() (int, types.ParsingError) {
+    fsm := types.NewStateMachine()
+    start := native.SkipOne(&self.s, &self.p, fsm, 0)
+    types.FreeStateMachine(fsm)
+
+    if start < 0 {
+        return self.p, types.ParsingError(-start)
+    }
+    return start, 0
+}
+
+func (self *Node) encodeInterface(buf *[]byte) error {
+    //WARN: NOT compatible with json.Encoder
+    return encoder.EncodeInto(buf, self.packAny(), 0)
+}
+
+func (self *Parser) skipFast() (int, types.ParsingError) {
+    start := native.SkipOneFast(&self.s, &self.p)
+    if start < 0 {
+        return self.p, types.ParsingError(-start)
+    }
+    return start, 0
+}
+
+func (self *Parser) getByPath(path ...interface{}) (int, types.ParsingError) {
+    fsm := types.NewStateMachine()
+    start := native.GetByPath(&self.s, &self.p, &path, fsm)
+    types.FreeStateMachine(fsm)
+    runtime.KeepAlive(path)
+    if start < 0 {
+        return self.p, types.ParsingError(-start)
+    }
+    return start, 0
+}
+
+func (self *Searcher) GetByPath(path ...interface{}) (Node, error) {
+    var err types.ParsingError
+    var start int
+
+    self.parser.p = 0
+    start, err = self.parser.getByPath(path...)
+    if err != 0 {
+        // for compatibility with old version
+        if err == types.ERR_NOT_FOUND {
+            return Node{}, ErrNotExist
+        }
+        if err == types.ERR_UNSUPPORT_TYPE {
+            panic("path must be either int(>=0) or string")
+        }
+        return Node{}, self.parser.syntaxError(err)
+    }
+
+    t := switchRawType(self.parser.s[start])
+    if t == _V_NONE {
+        return Node{}, self.parser.ExportError(err)
+    }
+    return newRawNode(self.parser.s[start:self.parser.p], t), nil
+}

vendor/github.com/bytedance/sonic/ast/api_compat.go

@@ -0,0 +1,120 @@
+// +build !amd64 go1.21
+
+/*
+ * Copyright 2022 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ast
+
+import (
+    `encoding/base64`
+    `encoding/json`
+    `fmt`
+
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+func quote(buf *[]byte, val string) {
+    quoteString(buf, val)
+}
+
+func unquote(src string) (string, types.ParsingError) {
+    sp := rt.IndexChar(src, -1)
+    out, ok := unquoteBytes(rt.BytesFrom(sp, len(src)+2, len(src)+2))
+    if !ok {
+        return "", types.ERR_INVALID_ESCAPE
+    }
+    return rt.Mem2Str(out), 0
+}
+
+func decodeBase64(src string) ([]byte, error) {
+    return base64.StdEncoding.DecodeString(src)
+}
+
+func encodeBase64(src []byte) string {
+    return base64.StdEncoding.EncodeToString(src)
+}
+
+func (self *Parser) decodeValue() (val types.JsonState) {
+    e, v := decodeValue(self.s, self.p)
+    if e < 0 {
+        return v
+    }
+    self.p = e
+    return v
+}
+
+func (self *Parser) skip() (int, types.ParsingError) {
+    e, s := skipValue(self.s, self.p)
+    if e < 0 {
+        return self.p, types.ParsingError(-e)
+    }
+    self.p = e
+    return s, 0
+}
+
+func (self *Parser) skipFast() (int, types.ParsingError) {
+    e, s := skipValueFast(self.s, self.p)
+    if e < 0 {
+        return self.p, types.ParsingError(-e)
+    }
+    self.p = e
+    return s, 0
+}
+
+func (self *Node) encodeInterface(buf *[]byte) error {
+    out, err := json.Marshal(self.packAny())
+    if err != nil {
+        return err
+    }
+    *buf = append(*buf, out...)
+    return nil
+}
+
+func (self *Searcher) GetByPath(path ...interface{}) (Node, error) {
+    self.parser.p = 0
+
+    var err types.ParsingError
+    for _, p := range path {
+        if idx, ok := p.(int); ok && idx >= 0 {
+            if err = self.parser.searchIndex(idx); err != 0 {
+                return Node{}, self.parser.ExportError(err)
+            }
+        } else if key, ok := p.(string); ok {
+            if err = self.parser.searchKey(key); err != 0 {
+                return Node{}, self.parser.ExportError(err)
+            }
+        } else {
+            panic("path must be either int(>=0) or string")
+        }
+    }
+
+    var start = self.parser.p
+    if start, err = self.parser.skip(); err != 0 {
+        return Node{}, self.parser.ExportError(err)
+    }
+    ns := len(self.parser.s)
+    if self.parser.p > ns || start >= ns || start>=self.parser.p {
+        return Node{}, fmt.Errorf("skip %d char out of json boundary", start)
+    }
+
+    t := switchRawType(self.parser.s[start])
+    if t == _V_NONE {
+        return Node{}, self.parser.ExportError(err)
+    }
+
+    return newRawNode(self.parser.s[start:self.parser.p], t), nil
+}

vendor/github.com/bytedance/sonic/ast/decode.go

@@ -0,0 +1,575 @@
+/*
+ * Copyright 2022 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ast
+
+import (
+    `encoding/base64`
+    `runtime`
+    `strconv`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+const _blankCharsMask = (1 << ' ') | (1 << '\t') | (1 << '\r') | (1 << '\n')
+
+const (
+    bytesNull   = "null"
+    bytesTrue   = "true"
+    bytesFalse  = "false"
+    bytesObject = "{}"
+    bytesArray  = "[]"
+)
+
+func isSpace(c byte) bool {
+    return (int(1<<c) & _blankCharsMask) != 0
+}
+
+//go:nocheckptr
+func skipBlank(src string, pos int) int {
+    se := uintptr(rt.IndexChar(src, len(src)))
+    sp := uintptr(rt.IndexChar(src, pos))
+
+    for sp < se {
+        if !isSpace(*(*byte)(unsafe.Pointer(sp))) {
+            break
+        }
+        sp += 1
+    }
+    if sp >= se {
+        return -int(types.ERR_EOF)
+    }
+    runtime.KeepAlive(src)
+    return int(sp - uintptr(rt.IndexChar(src, 0)))
+}
+
+func decodeNull(src string, pos int) (ret int) {
+    ret = pos + 4
+    if ret > len(src) {
+        return -int(types.ERR_EOF)
+    }
+    if src[pos:ret] == bytesNull {
+        return ret
+    } else {
+        return -int(types.ERR_INVALID_CHAR)
+    }
+}
+
+func decodeTrue(src string, pos int) (ret int) {
+    ret = pos + 4
+    if ret > len(src) {
+        return -int(types.ERR_EOF)
+    }
+    if src[pos:ret] == bytesTrue {
+        return ret
+    } else {
+        return -int(types.ERR_INVALID_CHAR)
+    }
+
+}
+
+func decodeFalse(src string, pos int) (ret int) {
+    ret = pos + 5
+    if ret > len(src) {
+        return -int(types.ERR_EOF)
+    }
+    if src[pos:ret] == bytesFalse {
+        return ret
+    }
+    return -int(types.ERR_INVALID_CHAR)
+}
+
+//go:nocheckptr
+func decodeString(src string, pos int) (ret int, v string) {
+    ret, ep := skipString(src, pos)
+    if ep == -1 {
+        (*rt.GoString)(unsafe.Pointer(&v)).Ptr = rt.IndexChar(src, pos+1)
+        (*rt.GoString)(unsafe.Pointer(&v)).Len = ret - pos - 2
+        return ret, v
+    }
+
+    vv, ok := unquoteBytes(rt.Str2Mem(src[pos:ret]))
+    if !ok {
+        return -int(types.ERR_INVALID_CHAR), ""
+    }
+
+    runtime.KeepAlive(src)
+    return ret, rt.Mem2Str(vv)
+}
+
+func decodeBinary(src string, pos int) (ret int, v []byte) {
+    var vv string
+    ret, vv = decodeString(src, pos)
+    if ret < 0 {
+        return ret, nil
+    }
+    var err error
+    v, err = base64.StdEncoding.DecodeString(vv)
+    if err != nil {
+        return -int(types.ERR_INVALID_CHAR), nil
+    }
+    return ret, v
+}
+
+func isDigit(c byte) bool {
+    return c >= '0' && c <= '9'
+}
+
+//go:nocheckptr
+func decodeInt64(src string, pos int) (ret int, v int64, err error) {
+    sp := uintptr(rt.IndexChar(src, pos))
+    ss := uintptr(sp)
+    se := uintptr(rt.IndexChar(src, len(src)))
+    if uintptr(sp) >= se {
+        return -int(types.ERR_EOF), 0, nil
+    }
+
+    if c := *(*byte)(unsafe.Pointer(sp)); c == '-' {
+        sp += 1
+    }
+    if sp == se {
+        return -int(types.ERR_EOF), 0, nil
+    }
+
+    for ; sp < se; sp += uintptr(1) {
+        if !isDigit(*(*byte)(unsafe.Pointer(sp))) {
+            break
+        }
+    }
+
+    if sp < se {
+        if c := *(*byte)(unsafe.Pointer(sp)); c == '.' || c == 'e' || c == 'E' {
+            return -int(types.ERR_INVALID_NUMBER_FMT), 0, nil
+        }
+    }
+
+    var vv string
+    ret = int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr))
+    (*rt.GoString)(unsafe.Pointer(&vv)).Ptr = unsafe.Pointer(ss)
+    (*rt.GoString)(unsafe.Pointer(&vv)).Len = ret - pos
+
+    v, err = strconv.ParseInt(vv, 10, 64)
+    if err != nil {
+        //NOTICE: allow overflow here
+        if err.(*strconv.NumError).Err == strconv.ErrRange {
+            return ret, 0, err
+        }
+        return -int(types.ERR_INVALID_CHAR), 0, err
+    }
+
+    runtime.KeepAlive(src)
+    return ret, v, nil
+}
+
+func isNumberChars(c byte) bool {
+    return (c >= '0' && c <= '9') || c == '+' || c == '-' || c == 'e' || c == 'E' || c == '.'
+}
+
+//go:nocheckptr
+func decodeFloat64(src string, pos int) (ret int, v float64, err error) {
+    sp := uintptr(rt.IndexChar(src, pos))
+    ss := uintptr(sp)
+    se := uintptr(rt.IndexChar(src, len(src)))
+    if uintptr(sp) >= se {
+        return -int(types.ERR_EOF), 0, nil
+    }
+
+    if c := *(*byte)(unsafe.Pointer(sp)); c == '-' {
+        sp += 1
+    }
+    if sp == se {
+        return -int(types.ERR_EOF), 0, nil
+    }
+
+    for ; sp < se; sp += uintptr(1) {
+        if !isNumberChars(*(*byte)(unsafe.Pointer(sp))) {
+            break
+        }
+    }
+
+    var vv string
+    ret = int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr))
+    (*rt.GoString)(unsafe.Pointer(&vv)).Ptr = unsafe.Pointer(ss)
+    (*rt.GoString)(unsafe.Pointer(&vv)).Len = ret - pos
+
+    v, err = strconv.ParseFloat(vv, 64)
+    if err != nil {
+        //NOTICE: allow overflow here
+        if err.(*strconv.NumError).Err == strconv.ErrRange {
+            return ret, 0, err
+        }
+        return -int(types.ERR_INVALID_CHAR), 0, err
+    }
+
+    runtime.KeepAlive(src)
+    return ret, v, nil
+}
+
+func decodeValue(src string, pos int) (ret int, v types.JsonState) {
+    pos = skipBlank(src, pos)
+    if pos < 0 {
+        return pos, types.JsonState{Vt: types.ValueType(pos)}
+    }
+    switch c := src[pos]; c {
+    case 'n':
+        ret = decodeNull(src, pos)
+        if ret < 0 {
+            return ret, types.JsonState{Vt: types.ValueType(ret)}
+        }
+        return ret, types.JsonState{Vt: types.V_NULL}
+    case '"':
+        var ep int
+        ret, ep = skipString(src, pos)
+        if ret < 0 {
+            return ret, types.JsonState{Vt: types.ValueType(ret)}
+        }
+        return ret, types.JsonState{Vt: types.V_STRING, Iv: int64(pos + 1), Ep: ep}
+    case '{':
+        return pos + 1, types.JsonState{Vt: types.V_OBJECT}
+    case '[':
+        return pos + 1, types.JsonState{Vt: types.V_ARRAY}
+    case 't':
+        ret = decodeTrue(src, pos)
+        if ret < 0 {
+            return ret, types.JsonState{Vt: types.ValueType(ret)}
+        }
+        return ret, types.JsonState{Vt: types.V_TRUE}
+    case 'f':
+        ret = decodeFalse(src, pos)
+        if ret < 0 {
+            return ret, types.JsonState{Vt: types.ValueType(ret)}
+        }
+        return ret, types.JsonState{Vt: types.V_FALSE}
+    case '-', '+', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+        var iv int64
+        ret, iv, _ = decodeInt64(src, pos)
+        if ret >= 0 {
+            return ret, types.JsonState{Vt: types.V_INTEGER, Iv: iv, Ep: pos}
+        } else if ret != -int(types.ERR_INVALID_NUMBER_FMT) {
+            return ret, types.JsonState{Vt: types.ValueType(ret)}
+        }
+        var fv float64
+        ret, fv, _ = decodeFloat64(src, pos)
+        if ret >= 0 {
+            return ret, types.JsonState{Vt: types.V_DOUBLE, Dv: fv, Ep: pos}
+        } else {
+            return ret, types.JsonState{Vt: types.ValueType(ret)}
+        }
+    default:
+        return -int(types.ERR_INVALID_CHAR), types.JsonState{Vt:-types.ValueType(types.ERR_INVALID_CHAR)}
+    }
+}
+
+//go:nocheckptr
+func skipNumber(src string, pos int) (ret int) {
+    sp := uintptr(rt.IndexChar(src, pos))
+    se := uintptr(rt.IndexChar(src, len(src)))
+    if uintptr(sp) >= se {
+        return -int(types.ERR_EOF)
+    }
+
+    if c := *(*byte)(unsafe.Pointer(sp)); c == '-' {
+        sp += 1
+    }
+    ss := sp
+
+    var pointer bool
+    var exponent bool
+    var lastIsDigit bool
+    var nextNeedDigit = true
+
+    for ; sp < se; sp += uintptr(1) {
+        c := *(*byte)(unsafe.Pointer(sp))
+        if isDigit(c) {
+            lastIsDigit = true
+            nextNeedDigit = false
+            continue
+        } else if nextNeedDigit {
+            return -int(types.ERR_INVALID_CHAR)
+        } else if c == '.' {
+            if !lastIsDigit || pointer || exponent || sp == ss {
+                return -int(types.ERR_INVALID_CHAR)
+            }
+            pointer = true
+            lastIsDigit = false
+            nextNeedDigit = true
+            continue
+        } else if c == 'e' || c == 'E' {
+            if !lastIsDigit || exponent {
+                return -int(types.ERR_INVALID_CHAR)
+            }
+            if sp == se-1 {
+                return -int(types.ERR_EOF)
+            }
+            exponent = true
+            lastIsDigit = false
+            nextNeedDigit = false
+            continue
+        } else if c == '-' || c == '+' {
+            if prev := *(*byte)(unsafe.Pointer(sp - 1)); prev != 'e' && prev != 'E' {
+                return -int(types.ERR_INVALID_CHAR)
+            }
+            lastIsDigit = false
+            nextNeedDigit = true
+            continue
+        } else {
+            break
+        }
+    }
+
+    if nextNeedDigit {
+        return -int(types.ERR_EOF)
+    }
+
+    runtime.KeepAlive(src)
+    return int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr))
+}
+
+//go:nocheckptr
+func skipString(src string, pos int) (ret int, ep int) {
+    if pos+1 >= len(src) {
+        return -int(types.ERR_EOF), -1
+    }
+
+    sp := uintptr(rt.IndexChar(src, pos))
+    se := uintptr(rt.IndexChar(src, len(src)))
+
+    // not start with quote
+    if *(*byte)(unsafe.Pointer(sp)) != '"' {
+        return -int(types.ERR_INVALID_CHAR), -1
+    }
+    sp += 1
+
+    ep = -1
+    for sp < se {
+        c := *(*byte)(unsafe.Pointer(sp))
+        if c == '\\' {
+            if ep == -1 {
+                ep = int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr))
+            }
+            sp += 2
+            continue
+        }
+        sp += 1
+        if c == '"' {
+            return int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr)), ep
+        }
+    }
+
+    runtime.KeepAlive(src)
+    // not found the closed quote until EOF
+    return -int(types.ERR_EOF), -1
+}
+
+//go:nocheckptr
+func skipPair(src string, pos int, lchar byte, rchar byte) (ret int) {
+    if pos+1 >= len(src) {
+        return -int(types.ERR_EOF)
+    }
+
+    sp := uintptr(rt.IndexChar(src, pos))
+    se := uintptr(rt.IndexChar(src, len(src)))
+
+    if *(*byte)(unsafe.Pointer(sp)) != lchar {
+        return -int(types.ERR_INVALID_CHAR)
+    }
+
+    sp += 1
+    nbrace := 1
+    inquote := false
+
+    for sp < se {
+        c := *(*byte)(unsafe.Pointer(sp))
+        if c == '\\' {
+            sp += 2
+            continue
+        } else if c == '"' {
+            inquote = !inquote
+        } else if c == lchar {
+            if !inquote {
+                nbrace += 1
+            }
+        } else if c == rchar {
+            if !inquote {
+                nbrace -= 1
+                if nbrace == 0 {
+                    sp += 1
+                    break
+                }
+            }
+        }
+        sp += 1
+    }
+
+    if nbrace != 0 {
+        return -int(types.ERR_INVALID_CHAR)
+    }
+
+    runtime.KeepAlive(src)
+    return int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr))
+}
+
+func skipValueFast(src string, pos int) (ret int, start int) {
+    pos = skipBlank(src, pos)
+    if pos < 0 {
+        return pos, -1
+    }
+    switch c := src[pos]; c {
+    case 'n':
+        ret = decodeNull(src, pos)
+    case '"':
+        ret, _ = skipString(src, pos)
+    case '{':
+        ret = skipPair(src, pos, '{', '}')
+    case '[':
+        ret = skipPair(src, pos, '[', ']')
+    case 't':
+        ret = decodeTrue(src, pos)
+    case 'f':
+        ret = decodeFalse(src, pos)
+    case '-', '+', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+        ret = skipNumber(src, pos)
+    default:
+        ret = -int(types.ERR_INVALID_CHAR)
+    }
+    return ret, pos
+}
+
+func skipValue(src string, pos int) (ret int, start int) {
+    pos = skipBlank(src, pos)
+    if pos < 0 {
+        return pos, -1
+    }
+    switch c := src[pos]; c {
+    case 'n':
+        ret = decodeNull(src, pos)
+    case '"':
+        ret, _ = skipString(src, pos)
+    case '{':
+        ret, _ = skipObject(src, pos)
+    case '[':
+        ret, _ = skipArray(src, pos)
+    case 't':
+        ret = decodeTrue(src, pos)
+    case 'f':
+        ret = decodeFalse(src, pos)
+    case '-', '+', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+        ret = skipNumber(src, pos)
+    default:
+        ret = -int(types.ERR_INVALID_CHAR)
+    }
+    return ret, pos
+}
+
+func skipObject(src string, pos int) (ret int, start int) {
+    start = skipBlank(src, pos)
+    if start < 0 {
+        return start, -1
+    }
+
+    if src[start] != '{' {
+        return -int(types.ERR_INVALID_CHAR), -1
+    }
+
+    pos = start + 1
+    pos = skipBlank(src, pos)
+    if pos < 0 {
+        return pos, -1
+    }
+    if src[pos] == '}' {
+        return pos + 1, start
+    }
+
+    for {
+        pos, _ = skipString(src, pos)
+        if pos < 0 {
+            return pos, -1
+        }
+
+        pos = skipBlank(src, pos)
+        if pos < 0 {
+            return pos, -1
+        }
+        if src[pos] != ':' {
+            return -int(types.ERR_INVALID_CHAR), -1
+        }
+
+        pos++
+        pos, _ = skipValue(src, pos)
+        if pos < 0 {
+            return pos, -1
+        }
+
+        pos = skipBlank(src, pos)
+        if pos < 0 {
+            return pos, -1
+        }
+        if src[pos] == '}' {
+            return pos + 1, start
+        }
+        if src[pos] != ',' {
+            return -int(types.ERR_INVALID_CHAR), -1
+        }
+
+        pos++
+        pos = skipBlank(src, pos)
+        if pos < 0 {
+            return pos, -1
+        }
+
+    }
+}
+
+func skipArray(src string, pos int) (ret int, start int) {
+    start = skipBlank(src, pos)
+    if start < 0 {
+        return start, -1
+    }
+
+    if src[start] != '[' {
+        return -int(types.ERR_INVALID_CHAR), -1
+    }
+
+    pos = start + 1
+    pos = skipBlank(src, pos)
+    if pos < 0 {
+        return pos, -1
+    }
+    if src[pos] == ']' {
+        return pos + 1, start
+    }
+
+    for {
+        pos, _ = skipValue(src, pos)
+        if pos < 0 {
+            return pos, -1
+        }
+
+        pos = skipBlank(src, pos)
+        if pos < 0 {
+            return pos, -1
+        }
+        if src[pos] == ']' {
+            return pos + 1, start
+        }
+        if src[pos] != ',' {
+            return -int(types.ERR_INVALID_CHAR), -1
+        }
+        pos++
+    }
+}

vendor/github.com/bytedance/sonic/ast/encode.go

@@ -0,0 +1,259 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ast
+
+import (
+    `sync`
+    `unicode/utf8`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+const (
+    _MaxBuffer = 1024    // 1KB buffer size
+)
+
+func quoteString(e *[]byte, s string) {
+    *e = append(*e, '"')
+    start := 0
+    for i := 0; i < len(s); {
+        if b := s[i]; b < utf8.RuneSelf {
+            if safeSet[b] {
+                i++
+                continue
+            }
+            if start < i {
+                *e = append(*e, s[start:i]...)
+            }
+            *e = append(*e, '\\')
+            switch b {
+            case '\\', '"':
+                *e = append(*e, b)
+            case '\n':
+                *e = append(*e, 'n')
+            case '\r':
+                *e = append(*e, 'r')
+            case '\t':
+                *e = append(*e, 't')
+            default:
+                // This encodes bytes < 0x20 except for \t, \n and \r.
+                // If escapeHTML is set, it also escapes <, >, and &
+                // because they can lead to security holes when
+                // user-controlled strings are rendered into JSON
+                // and served to some browsers.
+                *e = append(*e, `u00`...)
+                *e = append(*e, hex[b>>4])
+                *e = append(*e, hex[b&0xF])
+            }
+            i++
+            start = i
+            continue
+        }
+        c, size := utf8.DecodeRuneInString(s[i:])
+        // if c == utf8.RuneError && size == 1 {
+        //     if start < i {
+        //         e.Write(s[start:i])
+        //     }
+        //     e.WriteString(`\ufffd`)
+        //     i += size
+        //     start = i
+        //     continue
+        // }
+        if c == '\u2028' || c == '\u2029' {
+            if start < i {
+                *e = append(*e, s[start:i]...)
+            }
+            *e = append(*e, `\u202`...)
+            *e = append(*e, hex[c&0xF])
+            i += size
+            start = i
+            continue
+        }
+        i += size
+    }
+    if start < len(s) {
+        *e = append(*e, s[start:]...)
+    }
+    *e = append(*e, '"')
+}
+
+var bytesPool   = sync.Pool{}
+
+func (self *Node) MarshalJSON() ([]byte, error) {
+    buf := newBuffer()
+    err := self.encode(buf)
+    if err != nil {
+        freeBuffer(buf)
+        return nil, err
+    }
+
+    ret := make([]byte, len(*buf))
+    copy(ret, *buf)
+    freeBuffer(buf)
+    return ret, err
+}
+
+func newBuffer() *[]byte {
+    if ret := bytesPool.Get(); ret != nil {
+        return ret.(*[]byte)
+    } else {
+        buf := make([]byte, 0, _MaxBuffer)
+        return &buf
+    }
+}
+
+func freeBuffer(buf *[]byte) {
+    *buf = (*buf)[:0]
+    bytesPool.Put(buf)
+}
+
+func (self *Node) encode(buf *[]byte) error {
+    if self.IsRaw() {
+        return self.encodeRaw(buf)
+    }
+    switch self.Type() {
+        case V_NONE  : return ErrNotExist
+        case V_ERROR : return self.Check()
+        case V_NULL  : return self.encodeNull(buf)
+        case V_TRUE  : return self.encodeTrue(buf)
+        case V_FALSE : return self.encodeFalse(buf)
+        case V_ARRAY : return self.encodeArray(buf)
+        case V_OBJECT: return self.encodeObject(buf)
+        case V_STRING: return self.encodeString(buf)
+        case V_NUMBER: return self.encodeNumber(buf)
+        case V_ANY   : return self.encodeInterface(buf)
+        default      : return ErrUnsupportType 
+    }
+}
+
+func (self *Node) encodeRaw(buf *[]byte) error {
+    raw, err := self.Raw()
+    if err != nil {
+        return err
+    }
+    *buf = append(*buf, raw...)
+    return nil
+}
+
+func (self *Node) encodeNull(buf *[]byte) error {
+    *buf = append(*buf, bytesNull...)
+    return nil
+}
+
+func (self *Node) encodeTrue(buf *[]byte) error {
+    *buf = append(*buf, bytesTrue...)
+    return nil
+}
+
+func (self *Node) encodeFalse(buf *[]byte) error {
+    *buf = append(*buf, bytesFalse...)
+    return nil
+}
+
+func (self *Node) encodeNumber(buf *[]byte) error {
+    str := rt.StrFrom(self.p, self.v)
+    *buf = append(*buf, str...)
+    return nil
+}
+
+func (self *Node) encodeString(buf *[]byte) error {
+    if self.v == 0 {
+        *buf = append(*buf, '"', '"')
+        return nil
+    }
+
+    quote(buf, rt.StrFrom(self.p, self.v))
+    return nil
+}
+
+func (self *Node) encodeArray(buf *[]byte) error {
+    if self.isLazy() {
+        if err := self.skipAllIndex(); err != nil {
+            return err
+        }
+    }
+
+    nb := self.len()
+    if nb == 0 {
+        *buf = append(*buf, bytesArray...)
+        return nil
+    }
+    
+    *buf = append(*buf, '[')
+
+    var p = (*Node)(self.p)
+    err := p.encode(buf)
+    if err != nil {
+        return err
+    }
+    for i := 1; i < nb; i++ {
+        *buf = append(*buf, ',')
+        p = p.unsafe_next()
+        err := p.encode(buf)
+        if err != nil {
+            return err
+        }
+    }
+
+    *buf = append(*buf, ']')
+    return nil
+}
+
+func (self *Pair) encode(buf *[]byte) error {
+    if len(*buf) == 0 {
+        *buf = append(*buf, '"', '"', ':')
+        return self.Value.encode(buf)
+    }
+
+    quote(buf, self.Key)
+    *buf = append(*buf, ':')
+
+    return self.Value.encode(buf)
+}
+
+func (self *Node) encodeObject(buf *[]byte) error {
+    if self.isLazy() {
+        if err := self.skipAllKey(); err != nil {
+            return err
+        }
+    }
+    
+    nb := self.len()
+    if nb == 0 {
+        *buf = append(*buf, bytesObject...)
+        return nil
+    }
+    
+    *buf = append(*buf, '{')
+
+    var p = (*Pair)(self.p)
+    err := p.encode(buf)
+    if err != nil {
+        return err
+    }
+    for i := 1; i < nb; i++ {
+        *buf = append(*buf, ',')
+        p = p.unsafe_next()
+        err := p.encode(buf)
+        if err != nil {
+            return err
+        }
+    }
+
+    *buf = append(*buf, '}')
+    return nil
+}

vendor/github.com/bytedance/sonic/ast/error.go

@@ -0,0 +1,98 @@
+package ast
+
+import (
+    `fmt`
+    `strings`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/native/types`
+)
+
+func (self *Parser) syntaxError(err types.ParsingError) SyntaxError {
+    return SyntaxError{
+        Pos : self.p,
+        Src : self.s,
+        Code: err,
+    }
+}
+
+func newSyntaxError(err SyntaxError) *Node {
+    msg := err.Description()
+    return &Node{
+        t: V_ERROR,
+        v: int64(err.Code),
+        p: unsafe.Pointer(&msg),
+    }
+}
+
+type SyntaxError struct {
+    Pos  int
+    Src  string
+    Code types.ParsingError
+    Msg  string
+}
+
+func (self SyntaxError) Error() string {
+    return fmt.Sprintf("%q", self.Description())
+}
+
+func (self SyntaxError) Description() string {
+    return "Syntax error " + self.description()
+}
+
+func (self SyntaxError) description() string {
+    i := 16
+    p := self.Pos - i
+    q := self.Pos + i
+
+    /* check for empty source */
+    if self.Src == "" {
+        return fmt.Sprintf("no sources available: %#v", self)
+    }
+
+    /* prevent slicing before the beginning */
+    if p < 0 {
+        p, q, i = 0, q - p, i + p
+    }
+
+    /* prevent slicing beyond the end */
+    if n := len(self.Src); q > n {
+        n = q - n
+        q = len(self.Src)
+
+        /* move the left bound if possible */
+        if p > n {
+            i += n
+            p -= n
+        }
+    }
+
+    /* left and right length */
+    x := clamp_zero(i)
+    y := clamp_zero(q - p - i - 1)
+
+    /* compose the error description */
+    return fmt.Sprintf(
+        "at index %d: %s\n\n\t%s\n\t%s^%s\n",
+        self.Pos,
+        self.Message(),
+        self.Src[p:q],
+        strings.Repeat(".", x),
+        strings.Repeat(".", y),
+    )
+}
+
+func (self SyntaxError) Message() string {
+    if self.Msg == "" {
+        return self.Code.Message()
+    }
+    return self.Msg
+}
+
+func clamp_zero(v int) int {
+    if v < 0 {
+        return 0
+    } else {
+        return v
+    }
+}

vendor/github.com/bytedance/sonic/ast/iterator.go

@@ -0,0 +1,164 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ast
+
+import (
+    `fmt`
+
+    `github.com/bytedance/sonic/internal/native/types`
+)
+
+type Pair struct {
+    Key   string
+    Value Node
+}
+
+// Values returns iterator for array's children traversal
+func (self *Node) Values() (ListIterator, error) {
+    if err := self.should(types.V_ARRAY, "an array"); err != nil {
+        return ListIterator{}, err
+    }
+    return ListIterator{Iterator{p: self}}, nil
+}
+
+// Properties returns iterator for object's children traversal
+func (self *Node) Properties() (ObjectIterator, error) {
+    if err := self.should(types.V_OBJECT, "an object"); err != nil {
+        return ObjectIterator{}, err
+    }
+    return ObjectIterator{Iterator{p: self}}, nil
+}
+
+type Iterator struct {
+    i int
+    p *Node
+}
+
+func (self *Iterator) Pos() int {
+    return self.i
+}
+
+func (self *Iterator) Len() int {
+    return self.p.len()
+}
+
+// HasNext reports if it is the end of iteration or has error.
+func (self *Iterator) HasNext() bool {
+    if !self.p.isLazy() {
+        return self.p.Valid() && self.i < self.p.len()
+    } else if self.p.t == _V_ARRAY_LAZY {
+        return self.p.skipNextNode().Valid()
+    } else if self.p.t == _V_OBJECT_LAZY {
+        pair := self.p.skipNextPair()
+        if pair == nil {
+            return false
+        }
+        return pair.Value.Valid()
+    }
+    return false
+}
+
+// ListIterator is specialized iterator for V_ARRAY
+type ListIterator struct {
+    Iterator
+}
+
+// ObjectIterator is specialized iterator for V_ARRAY
+type ObjectIterator struct {
+    Iterator
+}
+
+// Next scans through children of underlying V_ARRAY, 
+// copies each child to v, and returns .HasNext().
+func (self *ListIterator) Next(v *Node) bool {
+    if !self.HasNext() {
+        return false
+    } else {
+        *v, self.i = *self.p.nodeAt(self.i), self.i + 1
+        return true
+    }
+}
+
+// Next scans through children of underlying V_OBJECT, 
+// copies each child to v, and returns .HasNext().
+func (self *ObjectIterator) Next(p *Pair) bool {
+    if !self.HasNext() {
+        return false
+    } else {
+        *p, self.i = *self.p.pairAt(self.i), self.i + 1
+        return true
+    }
+}
+
+// Sequence represents scanning path of single-layer nodes.
+// Index indicates the value's order in both V_ARRAY and V_OBJECT json.
+// Key is the value's key (for V_OBJECT json only, otherwise it will be nil).
+type Sequence struct {
+    Index int 
+    Key *string
+    // Level int
+}
+
+// String is string representation of one Sequence
+func (s Sequence) String() string {
+    k := ""
+    if s.Key != nil {
+        k = *s.Key
+    }
+    return fmt.Sprintf("Sequence(%d, %q)", s.Index, k)
+}
+
+type Scanner func(path Sequence, node *Node) bool
+
+// ForEach scans one V_OBJECT node's children from JSON head to tail, 
+// and pass the Sequence and Node of corresponding JSON value.
+//
+// Especailly, if the node is not V_ARRAY or V_OBJECT, 
+// the node itself will be returned and Sequence.Index == -1.
+func (self *Node) ForEach(sc Scanner) error {
+    switch self.itype() {
+    case types.V_ARRAY:
+        ns, err := self.UnsafeArray()
+        if err != nil {
+            return err
+        }
+        for i := range ns {
+            if !sc(Sequence{i, nil}, &ns[i]) {
+                return err
+            }
+        }
+    case types.V_OBJECT:
+        ns, err := self.UnsafeMap()
+        if err != nil {
+            return err
+        }
+        for i := range ns {
+            if !sc(Sequence{i, &ns[i].Key}, &ns[i].Value) {
+                return err
+            }
+        }
+    default:
+        sc(Sequence{-1, nil}, self)
+    }
+    return self.Check()
+}
+
+type PairSlice []Pair
+
+func (self PairSlice) Sort() {
+    radixQsort(self, 0, maxDepth(len(self)))
+}

vendor/github.com/bytedance/sonic/ast/parser.go

@@ -0,0 +1,618 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ast
+
+import (
+    `fmt`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+const _DEFAULT_NODE_CAP int = 16
+
+const (
+    _ERR_NOT_FOUND      types.ParsingError = 33
+    _ERR_UNSUPPORT_TYPE types.ParsingError = 34
+)
+
+var (
+    ErrNotExist error = newError(_ERR_NOT_FOUND, "value not exists")
+    ErrUnsupportType error = newError(_ERR_UNSUPPORT_TYPE, "unsupported type")
+)
+
+type Parser struct {
+    p           int
+    s           string
+    noLazy      bool
+    skipValue   bool
+}
+
+/** Parser Private Methods **/
+
+func (self *Parser) delim() types.ParsingError {
+    n := len(self.s)
+    p := self.lspace(self.p)
+
+    /* check for EOF */
+    if p >= n {
+        return types.ERR_EOF
+    }
+
+    /* check for the delimtier */
+    if self.s[p] != ':' {
+        return types.ERR_INVALID_CHAR
+    }
+
+    /* update the read pointer */
+    self.p = p + 1
+    return 0
+}
+
+func (self *Parser) object() types.ParsingError {
+    n := len(self.s)
+    p := self.lspace(self.p)
+
+    /* check for EOF */
+    if p >= n {
+        return types.ERR_EOF
+    }
+
+    /* check for the delimtier */
+    if self.s[p] != '{' {
+        return types.ERR_INVALID_CHAR
+    }
+
+    /* update the read pointer */
+    self.p = p + 1
+    return 0
+}
+
+func (self *Parser) array() types.ParsingError {
+    n := len(self.s)
+    p := self.lspace(self.p)
+
+    /* check for EOF */
+    if p >= n {
+        return types.ERR_EOF
+    }
+
+    /* check for the delimtier */
+    if self.s[p] != '[' {
+        return types.ERR_INVALID_CHAR
+    }
+
+    /* update the read pointer */
+    self.p = p + 1
+    return 0
+}
+
+func (self *Parser) lspace(sp int) int {
+    ns := len(self.s)
+    for ; sp<ns && isSpace(self.s[sp]); sp+=1 {}
+
+    return sp
+}
+
+func (self *Parser) decodeArray(ret []Node) (Node, types.ParsingError) {
+    sp := self.p
+    ns := len(self.s)
+
+    /* check for EOF */
+    if self.p = self.lspace(sp); self.p >= ns {
+        return Node{}, types.ERR_EOF
+    }
+
+    /* check for empty array */
+    if self.s[self.p] == ']' {
+        self.p++
+        return emptyArrayNode, 0
+    }
+
+    /* allocate array space and parse every element */
+    for {
+        var val Node
+        var err types.ParsingError
+
+        if self.skipValue {
+            /* skip the value */
+            var start int
+            if start, err = self.skipFast(); err != 0 {
+                return Node{}, err
+            }
+            if self.p > ns {
+                return Node{}, types.ERR_EOF
+            }
+            t := switchRawType(self.s[start])
+            if t == _V_NONE {
+                return Node{}, types.ERR_INVALID_CHAR
+            }
+            val = newRawNode(self.s[start:self.p], t)
+        }else{
+            /* decode the value */
+            if val, err = self.Parse(); err != 0 {
+                return Node{}, err
+            }
+        }
+
+        /* add the value to result */
+        ret = append(ret, val)
+        self.p = self.lspace(self.p)
+
+        /* check for EOF */
+        if self.p >= ns {
+            return Node{}, types.ERR_EOF
+        }
+
+        /* check for the next character */
+        switch self.s[self.p] {
+            case ',' : self.p++
+            case ']' : self.p++; return NewArray(ret), 0
+        default:
+            if val.isLazy() {
+                return newLazyArray(self, ret), 0
+            }
+            return Node{}, types.ERR_INVALID_CHAR
+        }
+    }
+}
+
+func (self *Parser) decodeObject(ret []Pair) (Node, types.ParsingError) {
+    sp := self.p
+    ns := len(self.s)
+
+    /* check for EOF */
+    if self.p = self.lspace(sp); self.p >= ns {
+        return Node{}, types.ERR_EOF
+    }
+
+    /* check for empty object */
+    if self.s[self.p] == '}' {
+        self.p++
+        return emptyObjectNode, 0
+    }
+
+    /* decode each pair */
+    for {
+        var val Node
+        var njs types.JsonState
+        var err types.ParsingError
+
+        /* decode the key */
+        if njs = self.decodeValue(); njs.Vt != types.V_STRING {
+            return Node{}, types.ERR_INVALID_CHAR
+        }
+
+        /* extract the key */
+        idx := self.p - 1
+        key := self.s[njs.Iv:idx]
+
+        /* check for escape sequence */
+        if njs.Ep != -1 {
+            if key, err = unquote(key); err != 0 {
+                return Node{}, err
+            }
+        }
+
+        /* expect a ':' delimiter */
+        if err = self.delim(); err != 0 {
+            return Node{}, err
+        }
+
+        
+        if self.skipValue {
+            /* skip the value */
+            var start int
+            if start, err = self.skipFast(); err != 0 {
+                return Node{}, err
+            }
+            if self.p > ns {
+                return Node{}, types.ERR_EOF
+            }
+            t := switchRawType(self.s[start])
+            if t == _V_NONE {
+                return Node{}, types.ERR_INVALID_CHAR
+            }
+            val = newRawNode(self.s[start:self.p], t)
+        } else {
+            /* decode the value */
+            if val, err = self.Parse(); err != 0 {
+                return Node{}, err
+            }
+        }
+
+        /* add the value to result */
+        ret = append(ret, Pair{Key: key, Value: val})
+        self.p = self.lspace(self.p)
+
+        /* check for EOF */
+        if self.p >= ns {
+            return Node{}, types.ERR_EOF
+        }
+
+        /* check for the next character */
+        switch self.s[self.p] {
+            case ',' : self.p++
+            case '}' : self.p++; return NewObject(ret), 0
+        default:
+            if val.isLazy() {
+                return newLazyObject(self, ret), 0
+            }
+            return Node{}, types.ERR_INVALID_CHAR
+        }
+    }
+}
+
+func (self *Parser) decodeString(iv int64, ep int) (Node, types.ParsingError) {
+    p := self.p - 1
+    s := self.s[iv:p]
+
+    /* fast path: no escape sequence */
+    if ep == -1 {
+        return NewString(s), 0
+    }
+
+    /* unquote the string */
+    out, err := unquote(s)
+
+    /* check for errors */
+    if err != 0 {
+        return Node{}, err
+    } else {
+        return newBytes(rt.Str2Mem(out)), 0
+    }
+}
+
+/** Parser Interface **/
+
+func (self *Parser) Pos() int {
+    return self.p
+}
+
+func (self *Parser) Parse() (Node, types.ParsingError) {
+    switch val := self.decodeValue(); val.Vt {
+        case types.V_EOF     : return Node{}, types.ERR_EOF
+        case types.V_NULL    : return nullNode, 0
+        case types.V_TRUE    : return trueNode, 0
+        case types.V_FALSE   : return falseNode, 0
+        case types.V_STRING  : return self.decodeString(val.Iv, val.Ep)
+        case types.V_ARRAY:
+            if self.noLazy {
+                return self.decodeArray(make([]Node, 0, _DEFAULT_NODE_CAP))
+            }
+            return newLazyArray(self, make([]Node, 0, _DEFAULT_NODE_CAP)), 0
+        case types.V_OBJECT:
+            if self.noLazy {
+                return self.decodeObject(make([]Pair, 0, _DEFAULT_NODE_CAP))
+            }
+            return newLazyObject(self, make([]Pair, 0, _DEFAULT_NODE_CAP)), 0
+        case types.V_DOUBLE  : return NewNumber(self.s[val.Ep:self.p]), 0
+        case types.V_INTEGER : return NewNumber(self.s[val.Ep:self.p]), 0
+        default              : return Node{}, types.ParsingError(-val.Vt)
+    }
+}
+
+func (self *Parser) searchKey(match string) types.ParsingError {
+    ns := len(self.s)
+    if err := self.object(); err != 0 {
+        return err
+    }
+
+    /* check for EOF */
+    if self.p = self.lspace(self.p); self.p >= ns {
+        return types.ERR_EOF
+    }
+
+    /* check for empty object */
+    if self.s[self.p] == '}' {
+        self.p++
+        return _ERR_NOT_FOUND
+    }
+
+    var njs types.JsonState
+    var err types.ParsingError
+    /* decode each pair */
+    for {
+
+        /* decode the key */
+        if njs = self.decodeValue(); njs.Vt != types.V_STRING {
+            return types.ERR_INVALID_CHAR
+        }
+
+        /* extract the key */
+        idx := self.p - 1
+        key := self.s[njs.Iv:idx]
+
+        /* check for escape sequence */
+        if njs.Ep != -1 {
+            if key, err = unquote(key); err != 0 {
+                return err
+            }
+        }
+
+        /* expect a ':' delimiter */
+        if err = self.delim(); err != 0 {
+            return err
+        }
+
+        /* skip value */
+        if key != match {
+            if _, err = self.skipFast(); err != 0 {
+                return err
+            }
+        } else {
+            return 0
+        }
+
+        /* check for EOF */
+        self.p = self.lspace(self.p)
+        if self.p >= ns {
+            return types.ERR_EOF
+        }
+
+        /* check for the next character */
+        switch self.s[self.p] {
+        case ',':
+            self.p++
+        case '}':
+            self.p++
+            return _ERR_NOT_FOUND
+        default:
+            return types.ERR_INVALID_CHAR
+        }
+    }
+}
+
+func (self *Parser) searchIndex(idx int) types.ParsingError {
+    ns := len(self.s)
+    if err := self.array(); err != 0 {
+        return err
+    }
+
+    /* check for EOF */
+    if self.p = self.lspace(self.p); self.p >= ns {
+        return types.ERR_EOF
+    }
+
+    /* check for empty array */
+    if self.s[self.p] == ']' {
+        self.p++
+        return _ERR_NOT_FOUND
+    }
+
+    var err types.ParsingError
+    /* allocate array space and parse every element */
+    for i := 0; i < idx; i++ {
+
+        /* decode the value */
+        if _, err = self.skipFast(); err != 0 {
+            return err
+        }
+
+        /* check for EOF */
+        self.p = self.lspace(self.p)
+        if self.p >= ns {
+            return types.ERR_EOF
+        }
+
+        /* check for the next character */
+        switch self.s[self.p] {
+        case ',':
+            self.p++
+        case ']':
+            self.p++
+            return _ERR_NOT_FOUND
+        default:
+            return types.ERR_INVALID_CHAR
+        }
+    }
+
+    return 0
+}
+
+func (self *Node) skipNextNode() *Node {
+    if !self.isLazy() {
+        return nil
+    }
+
+    parser, stack := self.getParserAndArrayStack()
+    ret := stack.v
+    sp := parser.p
+    ns := len(parser.s)
+
+    /* check for EOF */
+    if parser.p = parser.lspace(sp); parser.p >= ns {
+        return newSyntaxError(parser.syntaxError(types.ERR_EOF))
+    }
+
+    /* check for empty array */
+    if parser.s[parser.p] == ']' {
+        parser.p++
+        self.setArray(ret)
+        return nil
+    }
+
+    var val Node
+    /* skip the value */
+    if start, err := parser.skipFast(); err != 0 {
+        return newSyntaxError(parser.syntaxError(err))
+    } else {
+        t := switchRawType(parser.s[start])
+        if t == _V_NONE {
+            return newSyntaxError(parser.syntaxError(types.ERR_INVALID_CHAR))
+        }
+        val = newRawNode(parser.s[start:parser.p], t)
+    }
+
+    /* add the value to result */
+    ret = append(ret, val)
+    parser.p = parser.lspace(parser.p)
+
+    /* check for EOF */
+    if parser.p >= ns {
+        return newSyntaxError(parser.syntaxError(types.ERR_EOF))
+    }
+
+    /* check for the next character */
+    switch parser.s[parser.p] {
+    case ',':
+        parser.p++
+        self.setLazyArray(parser, ret)
+        return &ret[len(ret)-1]
+    case ']':
+        parser.p++
+        self.setArray(ret)
+        return &ret[len(ret)-1]
+    default:
+        return newSyntaxError(parser.syntaxError(types.ERR_INVALID_CHAR))
+    }
+}
+
+func (self *Node) skipNextPair() (*Pair) {
+    if !self.isLazy() {
+        return nil
+    }
+
+    parser, stack := self.getParserAndObjectStack()
+    ret := stack.v
+    sp := parser.p
+    ns := len(parser.s)
+
+    /* check for EOF */
+    if parser.p = parser.lspace(sp); parser.p >= ns {
+        return &Pair{"", *newSyntaxError(parser.syntaxError(types.ERR_EOF))}
+    }
+
+    /* check for empty object */
+    if parser.s[parser.p] == '}' {
+        parser.p++
+        self.setObject(ret)
+        return nil
+    }
+
+    /* decode one pair */
+    var val Node
+    var njs types.JsonState
+    var err types.ParsingError
+
+    /* decode the key */
+    if njs = parser.decodeValue(); njs.Vt != types.V_STRING {
+        return &Pair{"", *newSyntaxError(parser.syntaxError(types.ERR_INVALID_CHAR))}
+    }
+
+    /* extract the key */
+    idx := parser.p - 1
+    key := parser.s[njs.Iv:idx]
+
+    /* check for escape sequence */
+    if njs.Ep != -1 {
+        if key, err = unquote(key); err != 0 {
+            return &Pair{key, *newSyntaxError(parser.syntaxError(err))}
+        }
+    }
+
+    /* expect a ':' delimiter */
+    if err = parser.delim(); err != 0 {
+        return &Pair{key, *newSyntaxError(parser.syntaxError(err))}
+    }
+
+    /* skip the value */
+    if start, err := parser.skipFast(); err != 0 {
+        return &Pair{key, *newSyntaxError(parser.syntaxError(err))}
+    } else {
+        t := switchRawType(parser.s[start])
+        if t == _V_NONE {
+            return &Pair{key, *newSyntaxError(parser.syntaxError(types.ERR_INVALID_CHAR))}
+        }
+        val = newRawNode(parser.s[start:parser.p], t)
+    }
+
+    /* add the value to result */
+    ret = append(ret, Pair{Key: key, Value: val})
+    parser.p = parser.lspace(parser.p)
+
+    /* check for EOF */
+    if parser.p >= ns {
+        return &Pair{key, *newSyntaxError(parser.syntaxError(types.ERR_EOF))}
+    }
+
+    /* check for the next character */
+    switch parser.s[parser.p] {
+    case ',':
+        parser.p++
+        self.setLazyObject(parser, ret)
+        return &ret[len(ret)-1]
+    case '}':
+        parser.p++
+        self.setObject(ret)
+        return &ret[len(ret)-1]
+    default:
+        return &Pair{key, *newSyntaxError(parser.syntaxError(types.ERR_INVALID_CHAR))}
+    }
+}
+
+
+/** Parser Factory **/
+
+// Loads parse all json into interface{}
+func Loads(src string) (int, interface{}, error) {
+    ps := &Parser{s: src}
+    np, err := ps.Parse()
+
+    /* check for errors */
+    if err != 0 {
+        return 0, nil, ps.ExportError(err)
+    } else {
+        x, err := np.Interface()
+        if err != nil {
+            return 0, nil, err
+        }
+        return ps.Pos(), x, nil
+    }
+}
+
+// LoadsUseNumber parse all json into interface{}, with numeric nodes casted to json.Number
+func LoadsUseNumber(src string) (int, interface{}, error) {
+    ps := &Parser{s: src}
+    np, err := ps.Parse()
+
+    /* check for errors */
+    if err != 0 {
+        return 0, nil, err
+    } else {
+        x, err := np.InterfaceUseNumber()
+        if err != nil {
+            return 0, nil, err
+        }
+        return ps.Pos(), x, nil
+    }
+}
+
+func NewParser(src string) *Parser {
+    return &Parser{s: src}
+}
+
+// ExportError converts types.ParsingError to std Error
+func (self *Parser) ExportError(err types.ParsingError) error {
+    if err == _ERR_NOT_FOUND {
+        return ErrNotExist
+    }
+    return fmt.Errorf("%q", SyntaxError{
+        Pos : self.p,
+        Src : self.s,
+        Code: err,
+    }.Description())
+}

vendor/github.com/bytedance/sonic/ast/search.go

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ast
+
+type Searcher struct {
+    parser Parser
+}
+
+func NewSearcher(str string) *Searcher {
+    return &Searcher{
+        parser: Parser{
+            s:      str,
+            noLazy: false,
+        },
+    }
+}

vendor/github.com/bytedance/sonic/ast/sort.go

@@ -0,0 +1,206 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ast
+
+// Algorithm 3-way Radix Quicksort, d means the radix.
+// Reference: https://algs4.cs.princeton.edu/51radix/Quick3string.java.html
+func radixQsort(kvs PairSlice, d, maxDepth int) {
+    for len(kvs) > 11 {
+        // To avoid the worst case of quickSort (time: O(n^2)), use introsort here.
+        // Reference: https://en.wikipedia.org/wiki/Introsort and
+        // https://github.com/golang/go/issues/467
+        if maxDepth == 0 {
+            heapSort(kvs, 0, len(kvs))
+            return
+        }
+        maxDepth--
+
+        p := pivot(kvs, d)
+        lt, i, gt := 0, 0, len(kvs)
+        for i < gt {
+            c := byteAt(kvs[i].Key, d)
+            if c < p {
+                swap(kvs, lt, i)
+                i++
+                lt++
+            } else if c > p {
+                gt--
+                swap(kvs, i, gt)
+            } else {
+                i++
+            }
+        }
+
+        // kvs[0:lt] < v = kvs[lt:gt] < kvs[gt:len(kvs)]
+        // Native implemention:
+        //     radixQsort(kvs[:lt], d, maxDepth)
+        //     if p > -1 {
+        //         radixQsort(kvs[lt:gt], d+1, maxDepth)
+        //     }
+        //     radixQsort(kvs[gt:], d, maxDepth)
+        // Optimize as follows: make recursive calls only for the smaller parts.
+        // Reference: https://www.geeksforgeeks.org/quicksort-tail-call-optimization-reducing-worst-case-space-log-n/
+        if p == -1 {
+            if lt > len(kvs) - gt {
+                radixQsort(kvs[gt:], d, maxDepth)
+                kvs = kvs[:lt]
+            } else {
+                radixQsort(kvs[:lt], d, maxDepth)
+                kvs = kvs[gt:]
+            }
+        } else {
+            ml := maxThree(lt, gt-lt, len(kvs)-gt)
+            if ml == lt {
+                radixQsort(kvs[lt:gt], d+1, maxDepth)
+                radixQsort(kvs[gt:], d, maxDepth)
+                kvs = kvs[:lt]
+            } else if ml == gt-lt {
+                radixQsort(kvs[:lt], d, maxDepth)
+                radixQsort(kvs[gt:], d, maxDepth)
+                kvs = kvs[lt:gt]
+                d += 1
+            } else {
+                radixQsort(kvs[:lt], d, maxDepth)
+                radixQsort(kvs[lt:gt], d+1, maxDepth)
+                kvs = kvs[gt:] 
+            }
+        }
+    }
+    insertRadixSort(kvs, d)
+}
+
+func insertRadixSort(kvs PairSlice, d int) {
+    for i := 1; i < len(kvs); i++ {
+        for j := i; j > 0 && lessFrom(kvs[j].Key, kvs[j-1].Key, d); j-- {
+            swap(kvs, j, j-1)
+        }
+    }
+}
+
+func pivot(kvs PairSlice, d int) int {
+    m := len(kvs) >> 1
+    if len(kvs) > 40 {
+        // Tukey's ``Ninther,'' median of three mediankvs of three.
+        t := len(kvs) / 8
+        return medianThree(
+            medianThree(byteAt(kvs[0].Key, d), byteAt(kvs[t].Key, d), byteAt(kvs[2*t].Key, d)),
+            medianThree(byteAt(kvs[m].Key, d), byteAt(kvs[m-t].Key, d), byteAt(kvs[m+t].Key, d)),
+            medianThree(byteAt(kvs[len(kvs)-1].Key, d),
+                byteAt(kvs[len(kvs)-1-t].Key, d),
+                byteAt(kvs[len(kvs)-1-2*t].Key, d)))
+    }
+    return medianThree(byteAt(kvs[0].Key, d), byteAt(kvs[m].Key, d), byteAt(kvs[len(kvs)-1].Key, d))
+}
+
+func medianThree(i, j, k int) int {
+    if i > j {
+        i, j = j, i
+    } // i < j
+    if k < i {
+        return i
+    }
+    if k > j {
+        return j
+    }
+    return k
+}
+
+func maxThree(i, j, k int) int {
+    max := i
+    if max < j {
+        max = j
+    }
+    if max < k {
+        max = k
+    }
+    return max
+}
+
+// maxDepth returns a threshold at which quicksort should switch
+// to heapsort. It returnkvs 2*ceil(lg(n+1)).
+func maxDepth(n int) int {
+    var depth int
+    for i := n; i > 0; i >>= 1 {
+        depth++
+    }
+    return depth * 2
+}
+
+// siftDown implements the heap property on kvs[lo:hi].
+// first is an offset into the array where the root of the heap lies.
+func siftDown(kvs PairSlice, lo, hi, first int) {
+    root := lo
+    for {
+        child := 2*root + 1
+        if child >= hi {
+            break
+        }
+        if child+1 < hi && kvs[first+child].Key < kvs[first+child+1].Key {
+            child++
+        }
+        if kvs[first+root].Key >= kvs[first+child].Key {
+            return
+        }
+        swap(kvs, first+root, first+child)
+        root = child
+    }
+}
+
+func heapSort(kvs PairSlice, a, b int) {
+    first := a
+    lo := 0
+    hi := b - a
+
+    // Build heap with the greatest element at top.
+    for i := (hi - 1) / 2; i >= 0; i-- {
+        siftDown(kvs, i, hi, first)
+    }
+
+    // Pop elements, the largest first, into end of kvs.
+    for i := hi - 1; i >= 0; i-- {
+        swap(kvs, first, first+i)
+        siftDown(kvs, lo, i, first)
+    }
+}
+
+// Note that Pair.Key is NOT pointed to Pair.m when map key is integer after swap
+func swap(kvs PairSlice, a, b int) {
+    kvs[a].Key, kvs[b].Key = kvs[b].Key, kvs[a].Key
+    kvs[a].Value, kvs[b].Value = kvs[b].Value, kvs[a].Value
+}
+
+// Compare two strings from the pos d.
+func lessFrom(a, b string, d int) bool {
+    l := len(a)
+    if l > len(b) {
+        l = len(b)
+    }
+    for i := d; i < l; i++ {
+        if a[i] == b[i] {
+            continue
+        }
+        return a[i] < b[i]
+    }
+    return len(a) < len(b)
+}
+
+func byteAt(b string, p int) int {
+    if p < len(b) {
+        return int(b[p])
+    }
+    return -1
+}

vendor/github.com/bytedance/sonic/ast/stubs_go115.go

@@ -0,0 +1,55 @@
+// +build !go1.20
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ast
+
+import (
+    `unsafe`
+    `unicode/utf8`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+//go:noescape
+//go:linkname memmove runtime.memmove
+//goland:noinspection GoUnusedParameter
+func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
+
+//go:linkname unsafe_NewArray reflect.unsafe_NewArray
+//goland:noinspection GoUnusedParameter
+func unsafe_NewArray(typ *rt.GoType, n int) unsafe.Pointer
+
+//go:linkname growslice runtime.growslice
+//goland:noinspection GoUnusedParameter
+func growslice(et *rt.GoType, old rt.GoSlice, cap int) rt.GoSlice
+
+//go:nosplit
+func mem2ptr(s []byte) unsafe.Pointer {
+    return (*rt.GoSlice)(unsafe.Pointer(&s)).Ptr
+}
+
+var (
+    //go:linkname safeSet encoding/json.safeSet
+    safeSet [utf8.RuneSelf]bool
+
+    //go:linkname hex encoding/json.hex
+    hex string
+)
+
+//go:linkname unquoteBytes encoding/json.unquoteBytes
+func unquoteBytes(s []byte) (t []byte, ok bool)

vendor/github.com/bytedance/sonic/ast/stubs_go120.go

@@ -0,0 +1,55 @@
+// +build go1.20
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ast
+
+import (
+    `unsafe`
+    `unicode/utf8`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+//go:noescape
+//go:linkname memmove runtime.memmove
+//goland:noinspection GoUnusedParameter
+func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
+
+//go:linkname unsafe_NewArray reflect.unsafe_NewArray
+//goland:noinspection GoUnusedParameter
+func unsafe_NewArray(typ *rt.GoType, n int) unsafe.Pointer
+
+//go:linkname growslice reflect.growslice
+//goland:noinspection GoUnusedParameter
+func growslice(et *rt.GoType, old rt.GoSlice, cap int) rt.GoSlice
+
+//go:nosplit
+func mem2ptr(s []byte) unsafe.Pointer {
+    return (*rt.GoSlice)(unsafe.Pointer(&s)).Ptr
+}
+
+var (
+    //go:linkname safeSet encoding/json.safeSet
+    safeSet [utf8.RuneSelf]bool
+
+    //go:linkname hex encoding/json.hex
+    hex string
+)
+
+//go:linkname unquoteBytes encoding/json.unquoteBytes
+func unquoteBytes(s []byte) (t []byte, ok bool)