增加websocket支持

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

@@ -1,40 +1,36 @@
-// +build !amd64,!arm64 go1.23 !go1.16 arm64,!go1.20
+// +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.
-*/
+ * 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`
-    `unicode/utf8`
+    `fmt`
 
     `github.com/bytedance/sonic/internal/native/types`
     `github.com/bytedance/sonic/internal/rt`
 )
 
-func init() {
-    println("WARNING:(ast) sonic only supports Go1.16~1.22, but your environment is not suitable")
-}
-
 func quote(buf *[]byte, val string) {
     quoteString(buf, val)
 }
 
-// unquote unescapes a internal JSON string (it doesn't count quotas at the begining and end)
 func unquote(src string) (string, types.ParsingError) {
     sp := rt.IndexChar(src, -1)
     out, ok := unquoteBytes(rt.BytesFrom(sp, len(src)+2, len(src)+2))
@@ -44,9 +40,16 @@ func unquote(src string) (string, types.ParsingError) {
     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, self.dbuf == nil)
+    e, v := decodeValue(self.s, self.p)
     if e < 0 {
         return v
     }
@@ -81,34 +84,37 @@ func (self *Node) encodeInterface(buf *[]byte) error {
     return nil
 }
 
-func (self *Parser) getByPath(validate bool, path ...interface{}) (int, types.ParsingError) {
+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.searchIndex(idx); err != 0 {
-                return self.p, err
+            if err = self.parser.searchIndex(idx); err != 0 {
+                return Node{}, self.parser.ExportError(err)
             }
         } else if key, ok := p.(string); ok {
-            if err := self.searchKey(key); err != 0 {
-                return self.p, err
+            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 int
-    var e types.ParsingError
-    if validate {
-        start, e = self.skip()
-    } else {
-        start, e = self.skipFast()
+    var start = self.parser.p
+    if start, err = self.parser.skip(); err != 0 {
+        return Node{}, self.parser.ExportError(err)
     }
-    if e != 0 {
-        return self.p, e
+    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)
     }
-    return start, 0
-}
 
-func validate_utf8(str string) bool {
-    return utf8.ValidString(str)
-}
+    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

@@ -220,7 +220,7 @@ func decodeFloat64(src string, pos int) (ret int, v float64, err error) {
     return ret, v, nil
 }
 
-func decodeValue(src string, pos int, skipnum bool) (ret int, v types.JsonState) {
+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)}
@@ -256,30 +256,20 @@ func decodeValue(src string, pos int, skipnum bool) (ret int, v types.JsonState)
         }
         return ret, types.JsonState{Vt: types.V_FALSE}
     case '-', '+', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
-        if skipnum {
-            ret = skipNumber(src, pos)
-            if ret >= 0 {
-                return ret, types.JsonState{Vt: types.V_DOUBLE, Iv: 0, Ep: pos}
-            } else {
-                return ret, types.JsonState{Vt: types.ValueType(ret)}
-            }
-        } else {
-            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)}
-            }
+        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)}
     }
@@ -583,36 +573,3 @@ func skipArray(src string, pos int) (ret int, start int) {
         pos++
     }
 }
-
-// DecodeString decodes a JSON string from pos and return golang string.
-//   - needEsc indicates if to unescaped escaping chars
-//   - hasEsc tells if the returned string has escaping chars
-//   - validStr enables validating UTF8 charset
-//
-func _DecodeString(src string, pos int, needEsc bool, validStr bool) (v string, ret int, hasEsc bool) {
-    p := NewParserObj(src)
-    p.p = pos
-    switch val := p.decodeValue(); val.Vt {
-    case types.V_STRING:
-        str := p.s[val.Iv : p.p-1]
-        if validStr && !validate_utf8(str) {
-           return "", -int(types.ERR_INVALID_UTF8), false
-        }
-        /* fast path: no escape sequence */
-        if val.Ep == -1 {
-            return str, p.p, false
-        } else if !needEsc {
-            return str, p.p, true
-        }
-        /* unquote the string */
-        out, err := unquote(str)
-        /* check for errors */
-        if err != 0 {
-            return "", -int(err), true
-        } else {
-            return out, p.p, true
-        }
-    default:
-        return "", -int(_ERR_UNSUPPORT_TYPE), false
-    }
-}

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

@@ -19,6 +19,8 @@ package ast
 import (
     `sync`
     `unicode/utf8`
+
+    `github.com/bytedance/sonic/internal/rt`
 )
 
 const (
@@ -163,18 +165,18 @@ func (self *Node) encodeFalse(buf *[]byte) error {
 }
 
 func (self *Node) encodeNumber(buf *[]byte) error {
-    str := self.toString()
+    str := rt.StrFrom(self.p, self.v)
     *buf = append(*buf, str...)
     return nil
 }
 
 func (self *Node) encodeString(buf *[]byte) error {
-    if self.l == 0 {
+    if self.v == 0 {
         *buf = append(*buf, '"', '"')
         return nil
     }
 
-    quote(buf, self.toString())
+    quote(buf, rt.StrFrom(self.p, self.v))
     return nil
 }
 
@@ -193,17 +195,16 @@ func (self *Node) encodeArray(buf *[]byte) error {
     
     *buf = append(*buf, '[')
 
-    var started bool
-    for i := 0; i < nb; i++ {
-        n := self.nodeAt(i)
-        if !n.Exists() {
-            continue
-        }
-        if started {
-            *buf = append(*buf, ',')
-        }
-        started = true
-        if err := n.encode(buf); err != nil {
+    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
         }
     }
@@ -239,21 +240,20 @@ func (self *Node) encodeObject(buf *[]byte) error {
     
     *buf = append(*buf, '{')
 
-    var started bool
-    for i := 0; i < nb; i++ {
-        n := self.pairAt(i)
-        if n == nil || !n.Value.Exists() {
-            continue
-        }
-        if started {
-            *buf = append(*buf, ',')
-        }
-        started = true
-        if err := n.encode(buf); err != nil {
+    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

@@ -8,33 +8,6 @@ import (
     `github.com/bytedance/sonic/internal/native/types`
 )
 
-
-func newError(err types.ParsingError, msg string) *Node {
-    return &Node{
-        t: V_ERROR,
-        l: uint(err),
-        p: unsafe.Pointer(&msg),
-    }
-}
-
-// Error returns error message if the node is invalid
-func (self Node) Error() string {
-    if self.t != V_ERROR {
-        return ""
-    } else {
-        return *(*string)(self.p)
-    } 
-}
-
-func newSyntaxError(err SyntaxError) *Node {
-    msg := err.Description()
-    return &Node{
-        t: V_ERROR,
-        l: uint(err.Code),
-        p: unsafe.Pointer(&msg),
-    }
-}
-
 func (self *Parser) syntaxError(err types.ParsingError) SyntaxError {
     return SyntaxError{
         Pos : self.p,
@@ -43,17 +16,12 @@ func (self *Parser) syntaxError(err types.ParsingError) SyntaxError {
     }
 }
 
-func unwrapError(err error) *Node {
-    if se, ok := err.(*Node); ok {
-        return se
-    }else if sse, ok := err.(Node); ok {
-        return &sse
-    } else {
-        msg := err.Error()
-        return &Node{
-            t: V_ERROR,
-            p: unsafe.Pointer(&msg),
-        }
+func newSyntaxError(err SyntaxError) *Node {
+    msg := err.Description()
+    return &Node{
+        t: V_ERROR,
+        v: int64(err.Code),
+        p: unsafe.Pointer(&msg),
     }
 }
 

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

@@ -32,11 +32,7 @@ func (self *Node) Values() (ListIterator, error) {
     if err := self.should(types.V_ARRAY, "an array"); err != nil {
         return ListIterator{}, err
     }
-    return self.values(), nil
-}
-
-func (self *Node) values() ListIterator {
-    return ListIterator{Iterator{p: self}}
+    return ListIterator{Iterator{p: self}}, nil
 }
 
 // Properties returns iterator for object's children traversal
@@ -44,11 +40,7 @@ func (self *Node) Properties() (ObjectIterator, error) {
     if err := self.should(types.V_OBJECT, "an object"); err != nil {
         return ObjectIterator{}, err
     }
-    return self.properties(), nil
-}
-
-func (self *Node) properties() ObjectIterator {
-    return ObjectIterator{Iterator{p: self}}
+    return ObjectIterator{Iterator{p: self}}, nil
 }
 
 type Iterator struct {
@@ -90,54 +82,26 @@ type ObjectIterator struct {
     Iterator
 }
 
-func (self *ListIterator) next() *Node {
-next_start:
-    if !self.HasNext() {
-        return nil
-    } else {
-        n := self.p.nodeAt(self.i)
-        self.i++
-        if !n.Exists() {
-            goto next_start
-        }
-        return n
-    }
-}
-
 // Next scans through children of underlying V_ARRAY, 
 // copies each child to v, and returns .HasNext().
 func (self *ListIterator) Next(v *Node) bool {
-    n := self.next()
-    if n == nil {
-        return false
-    }
-    *v = *n
-    return true
-}
-
-func (self *ObjectIterator) next() *Pair {
-next_start:
     if !self.HasNext() {
-        return nil
+        return false
     } else {
-        n := self.p.pairAt(self.i)
-        self.i++
-        if n == nil || !n.Value.Exists() {
-            goto next_start
-        }
-        return n
+        *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 {
-    n := self.next()
-    if n == nil {
+    if !self.HasNext() {
         return false
+    } else {
+        *p, self.i = *self.p.pairAt(self.i), self.i + 1
+        return true
     }
-    *p = *n
-    return true
 }
 
 // Sequence represents scanning path of single-layer nodes.
@@ -165,39 +129,36 @@ type Scanner func(path Sequence, node *Node) bool
 //
 // Especailly, if the node is not V_ARRAY or V_OBJECT, 
 // the node itself will be returned and Sequence.Index == -1.
-// 
-// NOTICE: A unsetted node WON'T trigger sc, but its index still counts into Path.Index
 func (self *Node) ForEach(sc Scanner) error {
     switch self.itype() {
     case types.V_ARRAY:
-        iter, err := self.Values()
+        ns, err := self.UnsafeArray()
         if err != nil {
             return err
         }
-        v := iter.next()
-        for v != nil {
-            if !sc(Sequence{iter.i-1, nil}, v) {
-                return nil
+        for i := range ns {
+            if !sc(Sequence{i, nil}, &ns[i]) {
+                return err
             }
-            v = iter.next()
         }
     case types.V_OBJECT:
-        iter, err := self.Properties()
+        ns, err := self.UnsafeMap()
         if err != nil {
             return err
         }
-        v := iter.next()
-        for v != nil {
-            if !sc(Sequence{iter.i-1, &v.Key}, &v.Value) {
-                return nil
+        for i := range ns {
+            if !sc(Sequence{i, &ns[i].Key}, &ns[i].Value) {
+                return err
             }
-            v = iter.next()
         }
     default:
-        if self.Check() != nil {
-            return self
-        }
         sc(Sequence{-1, nil}, self)
     }
-    return nil
+    return self.Check()
 }
+
+type PairSlice []Pair
+
+func (self PairSlice) Sort() {
+    radixQsort(self, 0, maxDepth(len(self)))
+}

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

@@ -18,15 +18,11 @@ package ast
 
 import (
     `fmt`
-
     `github.com/bytedance/sonic/internal/native/types`
     `github.com/bytedance/sonic/internal/rt`
 )
 
-const (
-    _DEFAULT_NODE_CAP int = 8
-    _APPEND_GROW_SHIFT = 1
-)
+const _DEFAULT_NODE_CAP int = 16
 
 const (
     _ERR_NOT_FOUND      types.ParsingError = 33
@@ -34,10 +30,7 @@ const (
 )
 
 var (
-    // ErrNotExist means both key and value doesn't exist 
     ErrNotExist error = newError(_ERR_NOT_FOUND, "value not exists")
-
-    // ErrUnsupportType means API on the node is unsupported
     ErrUnsupportType error = newError(_ERR_UNSUPPORT_TYPE, "unsupported type")
 )
 
@@ -46,7 +39,6 @@ type Parser struct {
     s           string
     noLazy      bool
     skipValue   bool
-    dbuf        *byte
 }
 
 /** Parser Private Methods **/
@@ -115,7 +107,7 @@ func (self *Parser) lspace(sp int) int {
     return sp
 }
 
-func (self *Parser) decodeArray(ret *linkedNodes) (Node, types.ParsingError) {
+func (self *Parser) decodeArray(ret []Node) (Node, types.ParsingError) {
     sp := self.p
     ns := len(self.s)
 
@@ -127,7 +119,7 @@ func (self *Parser) decodeArray(ret *linkedNodes) (Node, types.ParsingError) {
     /* check for empty array */
     if self.s[self.p] == ']' {
         self.p++
-        return Node{t: types.V_ARRAY}, 0
+        return emptyArrayNode, 0
     }
 
     /* allocate array space and parse every element */
@@ -157,7 +149,7 @@ func (self *Parser) decodeArray(ret *linkedNodes) (Node, types.ParsingError) {
         }
 
         /* add the value to result */
-        ret.Push(val)
+        ret = append(ret, val)
         self.p = self.lspace(self.p)
 
         /* check for EOF */
@@ -168,17 +160,17 @@ func (self *Parser) decodeArray(ret *linkedNodes) (Node, types.ParsingError) {
         /* 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
+            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 *linkedPairs) (Node, types.ParsingError) {
+func (self *Parser) decodeObject(ret []Pair) (Node, types.ParsingError) {
     sp := self.p
     ns := len(self.s)
 
@@ -190,7 +182,7 @@ func (self *Parser) decodeObject(ret *linkedPairs) (Node, types.ParsingError) {
     /* check for empty object */
     if self.s[self.p] == '}' {
         self.p++
-        return Node{t: types.V_OBJECT}, 0
+        return emptyObjectNode, 0
     }
 
     /* decode each pair */
@@ -243,8 +235,7 @@ func (self *Parser) decodeObject(ret *linkedPairs) (Node, types.ParsingError) {
         }
 
         /* add the value to result */
-        // FIXME: ret's address may change here, thus previous referred node in ret may be invalid !!
-        ret.Push(Pair{Key: key, Value: val})
+        ret = append(ret, Pair{Key: key, Value: val})
         self.p = self.lspace(self.p)
 
         /* check for EOF */
@@ -255,11 +246,11 @@ func (self *Parser) decodeObject(ret *linkedPairs) (Node, types.ParsingError) {
         /* check for the next character */
         switch self.s[self.p] {
             case ',' : self.p++
-            case '}' : self.p++; return newObject(ret), 0
+            case '}' : self.p++; return NewObject(ret), 0
         default:
-            // if val.isLazy() {
-            //     return newLazyObject(self, ret), 0
-            // }
+            if val.isLazy() {
+                return newLazyObject(self, ret), 0
+            }
             return Node{}, types.ERR_INVALID_CHAR
         }
     }
@@ -299,23 +290,15 @@ func (self *Parser) Parse() (Node, types.ParsingError) {
         case types.V_FALSE   : return falseNode, 0
         case types.V_STRING  : return self.decodeString(val.Iv, val.Ep)
         case types.V_ARRAY:
-            if p := skipBlank(self.s, self.p); p >= self.p && self.s[p] == ']' {
-                self.p = p + 1
-                return Node{t: types.V_ARRAY}, 0
-            }
             if self.noLazy {
-                return self.decodeArray(new(linkedNodes))
+                return self.decodeArray(make([]Node, 0, _DEFAULT_NODE_CAP))
             }
-            return newLazyArray(self), 0
+            return newLazyArray(self, make([]Node, 0, _DEFAULT_NODE_CAP)), 0
         case types.V_OBJECT:
-            if p := skipBlank(self.s, self.p); p >= self.p && self.s[p] == '}' {
-                self.p = p + 1
-                return Node{t: types.V_OBJECT}, 0
-            }
             if self.noLazy {
-                return self.decodeObject(new(linkedPairs))
+                return self.decodeObject(make([]Pair, 0, _DEFAULT_NODE_CAP))
             }
-            return newLazyObject(self), 0
+            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)
@@ -446,7 +429,7 @@ func (self *Node) skipNextNode() *Node {
     }
 
     parser, stack := self.getParserAndArrayStack()
-    ret := &stack.v
+    ret := stack.v
     sp := parser.p
     ns := len(parser.s)
 
@@ -475,8 +458,7 @@ func (self *Node) skipNextNode() *Node {
     }
 
     /* add the value to result */
-    ret.Push(val)
-    self.l++
+    ret = append(ret, val)
     parser.p = parser.lspace(parser.p)
 
     /* check for EOF */
@@ -488,11 +470,12 @@ func (self *Node) skipNextNode() *Node {
     switch parser.s[parser.p] {
     case ',':
         parser.p++
-        return ret.At(ret.Len()-1)
+        self.setLazyArray(parser, ret)
+        return &ret[len(ret)-1]
     case ']':
         parser.p++
         self.setArray(ret)
-        return ret.At(ret.Len()-1)
+        return &ret[len(ret)-1]
     default:
         return newSyntaxError(parser.syntaxError(types.ERR_INVALID_CHAR))
     }
@@ -504,7 +487,7 @@ func (self *Node) skipNextPair() (*Pair) {
     }
 
     parser, stack := self.getParserAndObjectStack()
-    ret := &stack.v
+    ret := stack.v
     sp := parser.p
     ns := len(parser.s)
 
@@ -558,8 +541,7 @@ func (self *Node) skipNextPair() (*Pair) {
     }
 
     /* add the value to result */
-    ret.Push(Pair{Key: key, Value: val})
-    self.l++
+    ret = append(ret, Pair{Key: key, Value: val})
     parser.p = parser.lspace(parser.p)
 
     /* check for EOF */
@@ -571,11 +553,12 @@ func (self *Node) skipNextPair() (*Pair) {
     switch parser.s[parser.p] {
     case ',':
         parser.p++
-        return ret.At(ret.Len()-1)
+        self.setLazyObject(parser, ret)
+        return &ret[len(ret)-1]
     case '}':
         parser.p++
         self.setObject(ret)
-        return ret.At(ret.Len()-1)
+        return &ret[len(ret)-1]
     default:
         return &Pair{key, *newSyntaxError(parser.syntaxError(types.ERR_INVALID_CHAR))}
     }
@@ -618,30 +601,10 @@ func LoadsUseNumber(src string) (int, interface{}, error) {
     }
 }
 
-// NewParser returns pointer of new allocated parser
 func NewParser(src string) *Parser {
     return &Parser{s: src}
 }
 
-// NewParser returns new allocated parser
-func NewParserObj(src string) Parser {
-    return Parser{s: src}
-}
-
-// decodeNumber controls if parser decodes the number values instead of skip them
-//   WARN: once you set decodeNumber(true), please set decodeNumber(false) before you drop the parser 
-//   otherwise the memory CANNOT be reused
-func (self *Parser) decodeNumber(decode bool) {
-    if !decode && self.dbuf != nil {
-        types.FreeDbuf(self.dbuf)
-        self.dbuf = nil
-        return
-    }
-    if decode && self.dbuf == nil {
-        self.dbuf = types.NewDbuf()
-    }
-}
-
 // ExportError converts types.ParsingError to std Error
 func (self *Parser) ExportError(err types.ParsingError) error {
     if err == _ERR_NOT_FOUND {
@@ -652,9 +615,4 @@ func (self *Parser) ExportError(err types.ParsingError) error {
         Src : self.s,
         Code: err,
     }.Description())
-}
-
-func backward(src string, i int) int {
-    for ; i>=0 && isSpace(src[i]); i-- {}
-    return i
-}
+}

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

@@ -16,11 +16,6 @@
 
 package ast
 
-import (
-    `github.com/bytedance/sonic/internal/rt`
-    `github.com/bytedance/sonic/internal/native/types`
-)
-
 type Searcher struct {
     parser Parser
 }
@@ -33,106 +28,3 @@ func NewSearcher(str string) *Searcher {
         },
     }
 }
-
-// GetByPathCopy search in depth from top json and returns a **Copied** json node at the path location
-func (self *Searcher) GetByPathCopy(path ...interface{}) (Node, error) {
-    return self.getByPath(true, true, path...)
-}
-
-// GetByPathNoCopy search in depth from top json and returns a **Referenced** json node at the path location
-//
-// WARN: this search directly refer partial json from top json, which has faster speed,
-// may consumes more memory.
-func (self *Searcher) GetByPath(path ...interface{}) (Node, error) {
-    return self.getByPath(false, true, path...)
-}
-
-func (self *Searcher) getByPath(copystring bool, validate bool, path ...interface{}) (Node, error) {
-    var err types.ParsingError
-    var start int
-
-    self.parser.p = 0
-    start, err = self.parser.getByPath(validate, 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)
-    }
-
-    // copy string to reducing memory usage
-    var raw string
-    if copystring {
-        raw = rt.Mem2Str([]byte(self.parser.s[start:self.parser.p]))
-    } else {
-        raw = self.parser.s[start:self.parser.p]
-    }
-    return newRawNode(raw, t), nil
-}
-
-// GetByPath searches a path and returns relaction and types of target
-func _GetByPath(src string, path ...interface{}) (start int, end int, typ int, err error) {
-	p := NewParserObj(src)
-	s, e := p.getByPath(false, path...)
-	if e != 0 {
-		// for compatibility with old version
-		if e == types.ERR_NOT_FOUND {
-			return -1, -1, 0, ErrNotExist
-		}
-		if e == types.ERR_UNSUPPORT_TYPE {
-			panic("path must be either int(>=0) or string")
-		}
-		return -1, -1, 0, p.syntaxError(e)
-	}
-
-	t := switchRawType(p.s[s])
-	if t == _V_NONE {
-		return -1, -1, 0, ErrNotExist
-	}
-    if t == _V_NUMBER {
-        p.p = 1 + backward(p.s, p.p-1)
-    }
-	return s, p.p, int(t), nil
-}
-
-// ValidSyntax check if a json has a valid JSON syntax,
-// while not validate UTF-8 charset
-func _ValidSyntax(json string) bool {
-	p := NewParserObj(json)
-    _, e := p.skip()
-	if e != 0 {
-        return false
-    }
-   if skipBlank(p.s, p.p) != -int(types.ERR_EOF) {
-        return false
-   }
-   return true
-}
-
-// SkipFast skip a json value in fast-skip algs, 
-// while not strictly validate JSON syntax and UTF-8 charset.
-func _SkipFast(src string, i int) (int, int, error) {
-    p := NewParserObj(src)
-    p.p = i
-    s, e := p.skipFast()
-    if e != 0 {
-        return -1, -1, p.ExportError(e)
-    }
-    t := switchRawType(p.s[s])
-	if t == _V_NONE {
-		return -1, -1, ErrNotExist
-	}
-    if t == _V_NUMBER {
-        p.p = 1 + backward(p.s, p.p-1)
-    }
-    return s, p.p, nil
-}