podman

1
// +build !amd64 !go1.16 go1.22
2

3
/*
4
 * Copyright 2022 ByteDance Inc.
5
 *
6
 * Licensed under the Apache License, Version 2.0 (the "License");
7
 * you may not use this file except in compliance with the License.
8
 * You may obtain a copy of the License at
9
 *
10
 *     http://www.apache.org/licenses/LICENSE-2.0
11
 *
12
 * Unless required by applicable law or agreed to in writing, software
13
 * distributed under the License is distributed on an "AS IS" BASIS,
14
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15
 * See the License for the specific language governing permissions and
16
 * limitations under the License.
17
 */
18

19
package ast
20

21
import (
22
    `encoding/base64`
23
    `encoding/json`
24
    `fmt`
25

26
    `github.com/bytedance/sonic/internal/native/types`
27
    `github.com/bytedance/sonic/internal/rt`
28
)
29

30
func init() {
31
    println("WARNING: sonic only supports Go1.16~1.20 && CPU amd64, but your environment is not suitable")
32
}
33

34
func quote(buf *[]byte, val string) {
35
    quoteString(buf, val)
36
}
37

38
func unquote(src string) (string, types.ParsingError) {
39
    sp := rt.IndexChar(src, -1)
40
    out, ok := unquoteBytes(rt.BytesFrom(sp, len(src)+2, len(src)+2))
41
    if !ok {
42
        return "", types.ERR_INVALID_ESCAPE
43
    }
44
    return rt.Mem2Str(out), 0
45
}
46

47
func decodeBase64(src string) ([]byte, error) {
48
    return base64.StdEncoding.DecodeString(src)
49
}
50

51
func encodeBase64(src []byte) string {
52
    return base64.StdEncoding.EncodeToString(src)
53
}
54

55
func (self *Parser) decodeValue() (val types.JsonState) {
56
    e, v := decodeValue(self.s, self.p, self.dbuf == nil)
57
    if e < 0 {
58
        return v
59
    }
60
    self.p = e
61
    return v
62
}
63

64
func (self *Parser) skip() (int, types.ParsingError) {
65
    e, s := skipValue(self.s, self.p)
66
    if e < 0 {
67
        return self.p, types.ParsingError(-e)
68
    }
69
    self.p = e
70
    return s, 0
71
}
72

73
func (self *Parser) skipFast() (int, types.ParsingError) {
74
    e, s := skipValueFast(self.s, self.p)
75
    if e < 0 {
76
        return self.p, types.ParsingError(-e)
77
    }
78
    self.p = e
79
    return s, 0
80
}
81

82
func (self *Node) encodeInterface(buf *[]byte) error {
83
    out, err := json.Marshal(self.packAny())
84
    if err != nil {
85
        return err
86
    }
87
    *buf = append(*buf, out...)
88
    return nil
89
}
90

91
func (self *Searcher) GetByPath(path ...interface{}) (Node, error) {
92
    self.parser.p = 0
93

94
    var err types.ParsingError
95
    for _, p := range path {
96
        if idx, ok := p.(int); ok && idx >= 0 {
97
            if err = self.parser.searchIndex(idx); err != 0 {
98
                return Node{}, self.parser.ExportError(err)
99
            }
100
        } else if key, ok := p.(string); ok {
101
            if err = self.parser.searchKey(key); err != 0 {
102
                return Node{}, self.parser.ExportError(err)
103
            }
104
        } else {
105
            panic("path must be either int(>=0) or string")
106
        }
107
    }
108

109
    var start = self.parser.p
110
    if start, err = self.parser.skip(); err != 0 {
111
        return Node{}, self.parser.ExportError(err)
112
    }
113
    ns := len(self.parser.s)
114
    if self.parser.p > ns || start >= ns || start>=self.parser.p {
115
        return Node{}, fmt.Errorf("skip %d char out of json boundary", start)
116
    }
117

118
    t := switchRawType(self.parser.s[start])
119
    if t == _V_NONE {
120
        return Node{}, self.parser.ExportError(err)
121
    }
122

123
    return newRawNode(self.parser.s[start:self.parser.p], t), nil
124
}