podman

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

17
package decoder
18

19
import (
20
    `encoding/json`
21
    `errors`
22
    `fmt`
23
    `reflect`
24
    `strconv`
25
    `strings`
26

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

31
type SyntaxError struct {
32
    Pos  int
33
    Src  string
34
    Code types.ParsingError
35
    Msg  string
36
}
37

38
func (self SyntaxError) Error() string {
39
    return fmt.Sprintf("%q", self.Description())
40
}
41

42
func (self SyntaxError) Description() string {
43
    return "Syntax error " + self.description()
44
}
45

46
func (self SyntaxError) description() string {
47
    /* check for empty source */
48
    if self.Src == "" {
49
        return fmt.Sprintf("no sources available: %#v", self)
50
    }
51

52
    p, x, q, y := calcBounds(len(self.Src), self.Pos)
53

54
    /* compose the error description */
55
    return fmt.Sprintf(
56
        "at index %d: %s\n\n\t%s\n\t%s^%s\n",
57
        self.Pos,
58
        self.Message(),
59
        self.Src[p:q],
60
        strings.Repeat(".", x),
61
        strings.Repeat(".", y),
62
    )
63
}
64

65
func calcBounds(size int, pos int) (lbound int, lwidth int, rbound int, rwidth int) {
66
    if pos >= size || pos < 0 {
67
        return 0, 0, size, 0
68
    }
69

70
    i := 16
71
    lbound = pos - i
72
    rbound = pos + i
73

74
    /* prevent slicing before the beginning */
75
    if lbound < 0 {
76
        lbound, rbound, i = 0, rbound - lbound, i + lbound
77
    }
78

79
    /* prevent slicing beyond the end */
80
    if n := size; rbound > n {
81
        n = rbound - n
82
        rbound = size
83

84
        /* move the left bound if possible */
85
        if lbound > n {
86
            i += n
87
            lbound -= n
88
        }
89
    }
90

91
    /* left and right length */
92
    lwidth = clamp_zero(i)
93
    rwidth = clamp_zero(rbound - lbound - i - 1)
94

95
    return
96
}
97

98
func (self SyntaxError) Message() string {
99
    if self.Msg == "" {
100
        return self.Code.Message()
101
    }
102
    return self.Msg
103
}
104

105
func clamp_zero(v int) int {
106
    if v < 0 {
107
        return 0
108
    } else {
109
        return v
110
    }
111
}
112

113
/** JIT Error Helpers **/
114

115
var stackOverflow = &json.UnsupportedValueError {
116
    Str   : "Value nesting too deep",
117
    Value : reflect.ValueOf("..."),
118
}
119

120
func error_wrap(src string, pos int, code types.ParsingError) error {
121
    return *error_wrap_heap(src, pos, code)
122
}
123

124
//go:noinline
125
func error_wrap_heap(src string, pos int, code types.ParsingError) *SyntaxError {
126
    return &SyntaxError {
127
        Pos  : pos,
128
        Src  : src,
129
        Code : code,
130
    }
131
}
132

133
func error_type(vt *rt.GoType) error {
134
    return &json.UnmarshalTypeError{Type: vt.Pack()}
135
}
136

137
type MismatchTypeError struct {
138
    Pos  int
139
    Src  string
140
    Type reflect.Type
141
}
142

143
func swithchJSONType (src string, pos int) string {
144
    var val string
145
    switch src[pos] {
146
        case 'f': fallthrough
147
        case 't': val = "bool"
148
        case '"': val = "string"
149
        case '{': val = "object"
150
        case '[': val = "array"
151
        case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': val = "number"        
152
    }
153
    return val
154
}
155

156
func (self MismatchTypeError) Error() string {
157
    se := SyntaxError {
158
        Pos  : self.Pos,
159
        Src  : self.Src,
160
        Code : types.ERR_MISMATCH,
161
    }
162
    return fmt.Sprintf("Mismatch type %s with value %s %q", self.Type.String(), swithchJSONType(self.Src, self.Pos), se.description())
163
}
164

165
func (self MismatchTypeError) Description() string {
166
    se := SyntaxError {
167
        Pos  : self.Pos,
168
        Src  : self.Src,
169
        Code : types.ERR_MISMATCH,
170
    }
171
    return fmt.Sprintf("Mismatch type %s with value %s %s", self.Type.String(), swithchJSONType(self.Src, self.Pos), se.description())
172
}
173

174
func error_mismatch(src string, pos int, vt *rt.GoType) error {
175
    return &MismatchTypeError {
176
        Pos  : pos,
177
        Src  : src,
178
        Type : vt.Pack(),
179
    }
180
}
181

182
func error_field(name string) error {
183
    return errors.New("json: unknown field " + strconv.Quote(name))
184
}
185

186
func error_value(value string, vtype reflect.Type) error {
187
    return &json.UnmarshalTypeError {
188
        Type  : vtype,
189
        Value : value,
190
    }
191
}
192