podman

1
/*
2
 * Copyright 2022 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 ast
18

19
import (
20
    `encoding/base64`
21
    `runtime`
22
    `strconv`
23
    `unsafe`
24

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

29
const _blankCharsMask = (1 << ' ') | (1 << '\t') | (1 << '\r') | (1 << '\n')
30

31
const (
32
    bytesNull   = "null"
33
    bytesTrue   = "true"
34
    bytesFalse  = "false"
35
    bytesObject = "{}"
36
    bytesArray  = "[]"
37
)
38

39
func isSpace(c byte) bool {
40
    return (int(1<<c) & _blankCharsMask) != 0
41
}
42

43
//go:nocheckptr
44
func skipBlank(src string, pos int) int {
45
    se := uintptr(rt.IndexChar(src, len(src)))
46
    sp := uintptr(rt.IndexChar(src, pos))
47

48
    for sp < se {
49
        if !isSpace(*(*byte)(unsafe.Pointer(sp))) {
50
            break
51
        }
52
        sp += 1
53
    }
54
    if sp >= se {
55
        return -int(types.ERR_EOF)
56
    }
57
    runtime.KeepAlive(src)
58
    return int(sp - uintptr(rt.IndexChar(src, 0)))
59
}
60

61
func decodeNull(src string, pos int) (ret int) {
62
    ret = pos + 4
63
    if ret > len(src) {
64
        return -int(types.ERR_EOF)
65
    }
66
    if src[pos:ret] == bytesNull {
67
        return ret
68
    } else {
69
        return -int(types.ERR_INVALID_CHAR)
70
    }
71
}
72

73
func decodeTrue(src string, pos int) (ret int) {
74
    ret = pos + 4
75
    if ret > len(src) {
76
        return -int(types.ERR_EOF)
77
    }
78
    if src[pos:ret] == bytesTrue {
79
        return ret
80
    } else {
81
        return -int(types.ERR_INVALID_CHAR)
82
    }
83

84
}
85

86
func decodeFalse(src string, pos int) (ret int) {
87
    ret = pos + 5
88
    if ret > len(src) {
89
        return -int(types.ERR_EOF)
90
    }
91
    if src[pos:ret] == bytesFalse {
92
        return ret
93
    }
94
    return -int(types.ERR_INVALID_CHAR)
95
}
96

97
//go:nocheckptr
98
func decodeString(src string, pos int) (ret int, v string) {
99
    ret, ep := skipString(src, pos)
100
    if ep == -1 {
101
        (*rt.GoString)(unsafe.Pointer(&v)).Ptr = rt.IndexChar(src, pos+1)
102
        (*rt.GoString)(unsafe.Pointer(&v)).Len = ret - pos - 2
103
        return ret, v
104
    }
105

106
    vv, ok := unquoteBytes(rt.Str2Mem(src[pos:ret]))
107
    if !ok {
108
        return -int(types.ERR_INVALID_CHAR), ""
109
    }
110

111
    runtime.KeepAlive(src)
112
    return ret, rt.Mem2Str(vv)
113
}
114

115
func decodeBinary(src string, pos int) (ret int, v []byte) {
116
    var vv string
117
    ret, vv = decodeString(src, pos)
118
    if ret < 0 {
119
        return ret, nil
120
    }
121
    var err error
122
    v, err = base64.StdEncoding.DecodeString(vv)
123
    if err != nil {
124
        return -int(types.ERR_INVALID_CHAR), nil
125
    }
126
    return ret, v
127
}
128

129
func isDigit(c byte) bool {
130
    return c >= '0' && c <= '9'
131
}
132

133
//go:nocheckptr
134
func decodeInt64(src string, pos int) (ret int, v int64, err error) {
135
    sp := uintptr(rt.IndexChar(src, pos))
136
    ss := uintptr(sp)
137
    se := uintptr(rt.IndexChar(src, len(src)))
138
    if uintptr(sp) >= se {
139
        return -int(types.ERR_EOF), 0, nil
140
    }
141

142
    if c := *(*byte)(unsafe.Pointer(sp)); c == '-' {
143
        sp += 1
144
    }
145
    if sp == se {
146
        return -int(types.ERR_EOF), 0, nil
147
    }
148

149
    for ; sp < se; sp += uintptr(1) {
150
        if !isDigit(*(*byte)(unsafe.Pointer(sp))) {
151
            break
152
        }
153
    }
154

155
    if sp < se {
156
        if c := *(*byte)(unsafe.Pointer(sp)); c == '.' || c == 'e' || c == 'E' {
157
            return -int(types.ERR_INVALID_NUMBER_FMT), 0, nil
158
        }
159
    }
160

161
    var vv string
162
    ret = int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr))
163
    (*rt.GoString)(unsafe.Pointer(&vv)).Ptr = unsafe.Pointer(ss)
164
    (*rt.GoString)(unsafe.Pointer(&vv)).Len = ret - pos
165

166
    v, err = strconv.ParseInt(vv, 10, 64)
167
    if err != nil {
168
        //NOTICE: allow overflow here
169
        if err.(*strconv.NumError).Err == strconv.ErrRange {
170
            return ret, 0, err
171
        }
172
        return -int(types.ERR_INVALID_CHAR), 0, err
173
    }
174

175
    runtime.KeepAlive(src)
176
    return ret, v, nil
177
}
178

179
func isNumberChars(c byte) bool {
180
    return (c >= '0' && c <= '9') || c == '+' || c == '-' || c == 'e' || c == 'E' || c == '.'
181
}
182

183
//go:nocheckptr
184
func decodeFloat64(src string, pos int) (ret int, v float64, err error) {
185
    sp := uintptr(rt.IndexChar(src, pos))
186
    ss := uintptr(sp)
187
    se := uintptr(rt.IndexChar(src, len(src)))
188
    if uintptr(sp) >= se {
189
        return -int(types.ERR_EOF), 0, nil
190
    }
191

192
    if c := *(*byte)(unsafe.Pointer(sp)); c == '-' {
193
        sp += 1
194
    }
195
    if sp == se {
196
        return -int(types.ERR_EOF), 0, nil
197
    }
198

199
    for ; sp < se; sp += uintptr(1) {
200
        if !isNumberChars(*(*byte)(unsafe.Pointer(sp))) {
201
            break
202
        }
203
    }
204

205
    var vv string
206
    ret = int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr))
207
    (*rt.GoString)(unsafe.Pointer(&vv)).Ptr = unsafe.Pointer(ss)
208
    (*rt.GoString)(unsafe.Pointer(&vv)).Len = ret - pos
209

210
    v, err = strconv.ParseFloat(vv, 64)
211
    if err != nil {
212
        //NOTICE: allow overflow here
213
        if err.(*strconv.NumError).Err == strconv.ErrRange {
214
            return ret, 0, err
215
        }
216
        return -int(types.ERR_INVALID_CHAR), 0, err
217
    }
218

219
    runtime.KeepAlive(src)
220
    return ret, v, nil
221
}
222

223
func decodeValue(src string, pos int, skipnum bool) (ret int, v types.JsonState) {
224
    pos = skipBlank(src, pos)
225
    if pos < 0 {
226
        return pos, types.JsonState{Vt: types.ValueType(pos)}
227
    }
228
    switch c := src[pos]; c {
229
    case 'n':
230
        ret = decodeNull(src, pos)
231
        if ret < 0 {
232
            return ret, types.JsonState{Vt: types.ValueType(ret)}
233
        }
234
        return ret, types.JsonState{Vt: types.V_NULL}
235
    case '"':
236
        var ep int
237
        ret, ep = skipString(src, pos)
238
        if ret < 0 {
239
            return ret, types.JsonState{Vt: types.ValueType(ret)}
240
        }
241
        return ret, types.JsonState{Vt: types.V_STRING, Iv: int64(pos + 1), Ep: ep}
242
    case '{':
243
        return pos + 1, types.JsonState{Vt: types.V_OBJECT}
244
    case '[':
245
        return pos + 1, types.JsonState{Vt: types.V_ARRAY}
246
    case 't':
247
        ret = decodeTrue(src, pos)
248
        if ret < 0 {
249
            return ret, types.JsonState{Vt: types.ValueType(ret)}
250
        }
251
        return ret, types.JsonState{Vt: types.V_TRUE}
252
    case 'f':
253
        ret = decodeFalse(src, pos)
254
        if ret < 0 {
255
            return ret, types.JsonState{Vt: types.ValueType(ret)}
256
        }
257
        return ret, types.JsonState{Vt: types.V_FALSE}
258
    case '-', '+', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
259
        if skipnum {
260
            ret = skipNumber(src, pos)
261
            if ret >= 0 {
262
                return ret, types.JsonState{Vt: types.V_DOUBLE, Iv: 0, Ep: pos}
263
            } else {
264
                return ret, types.JsonState{Vt: types.ValueType(ret)}
265
            }
266
        } else {
267
            var iv int64
268
            ret, iv, _ = decodeInt64(src, pos)
269
            if ret >= 0 {
270
                return ret, types.JsonState{Vt: types.V_INTEGER, Iv: iv, Ep: pos}
271
            } else if ret != -int(types.ERR_INVALID_NUMBER_FMT) {
272
                return ret, types.JsonState{Vt: types.ValueType(ret)}
273
            }
274
            var fv float64
275
            ret, fv, _ = decodeFloat64(src, pos)
276
            if ret >= 0 {
277
                return ret, types.JsonState{Vt: types.V_DOUBLE, Dv: fv, Ep: pos}
278
            } else {
279
                return ret, types.JsonState{Vt: types.ValueType(ret)}
280
            }
281
        }
282
        
283
    default:
284
        return -int(types.ERR_INVALID_CHAR), types.JsonState{Vt:-types.ValueType(types.ERR_INVALID_CHAR)}
285
    }
286
}
287

288
//go:nocheckptr
289
func skipNumber(src string, pos int) (ret int) {
290
    sp := uintptr(rt.IndexChar(src, pos))
291
    se := uintptr(rt.IndexChar(src, len(src)))
292
    if uintptr(sp) >= se {
293
        return -int(types.ERR_EOF)
294
    }
295

296
    if c := *(*byte)(unsafe.Pointer(sp)); c == '-' {
297
        sp += 1
298
    }
299
    ss := sp
300

301
    var pointer bool
302
    var exponent bool
303
    var lastIsDigit bool
304
    var nextNeedDigit = true
305

306
    for ; sp < se; sp += uintptr(1) {
307
        c := *(*byte)(unsafe.Pointer(sp))
308
        if isDigit(c) {
309
            lastIsDigit = true
310
            nextNeedDigit = false
311
            continue
312
        } else if nextNeedDigit {
313
            return -int(types.ERR_INVALID_CHAR)
314
        } else if c == '.' {
315
            if !lastIsDigit || pointer || exponent || sp == ss {
316
                return -int(types.ERR_INVALID_CHAR)
317
            }
318
            pointer = true
319
            lastIsDigit = false
320
            nextNeedDigit = true
321
            continue
322
        } else if c == 'e' || c == 'E' {
323
            if !lastIsDigit || exponent {
324
                return -int(types.ERR_INVALID_CHAR)
325
            }
326
            if sp == se-1 {
327
                return -int(types.ERR_EOF)
328
            }
329
            exponent = true
330
            lastIsDigit = false
331
            nextNeedDigit = false
332
            continue
333
        } else if c == '-' || c == '+' {
334
            if prev := *(*byte)(unsafe.Pointer(sp - 1)); prev != 'e' && prev != 'E' {
335
                return -int(types.ERR_INVALID_CHAR)
336
            }
337
            lastIsDigit = false
338
            nextNeedDigit = true
339
            continue
340
        } else {
341
            break
342
        }
343
    }
344

345
    if nextNeedDigit {
346
        return -int(types.ERR_EOF)
347
    }
348

349
    runtime.KeepAlive(src)
350
    return int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr))
351
}
352

353
//go:nocheckptr
354
func skipString(src string, pos int) (ret int, ep int) {
355
    if pos+1 >= len(src) {
356
        return -int(types.ERR_EOF), -1
357
    }
358

359
    sp := uintptr(rt.IndexChar(src, pos))
360
    se := uintptr(rt.IndexChar(src, len(src)))
361

362
    // not start with quote
363
    if *(*byte)(unsafe.Pointer(sp)) != '"' {
364
        return -int(types.ERR_INVALID_CHAR), -1
365
    }
366
    sp += 1
367

368
    ep = -1
369
    for sp < se {
370
        c := *(*byte)(unsafe.Pointer(sp))
371
        if c == '\\' {
372
            if ep == -1 {
373
                ep = int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr))
374
            }
375
            sp += 2
376
            continue
377
        }
378
        sp += 1
379
        if c == '"' {
380
            return int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr)), ep
381
        }
382
    }
383

384
    runtime.KeepAlive(src)
385
    // not found the closed quote until EOF
386
    return -int(types.ERR_EOF), -1
387
}
388

389
//go:nocheckptr
390
func skipPair(src string, pos int, lchar byte, rchar byte) (ret int) {
391
    if pos+1 >= len(src) {
392
        return -int(types.ERR_EOF)
393
    }
394

395
    sp := uintptr(rt.IndexChar(src, pos))
396
    se := uintptr(rt.IndexChar(src, len(src)))
397

398
    if *(*byte)(unsafe.Pointer(sp)) != lchar {
399
        return -int(types.ERR_INVALID_CHAR)
400
    }
401

402
    sp += 1
403
    nbrace := 1
404
    inquote := false
405

406
    for sp < se {
407
        c := *(*byte)(unsafe.Pointer(sp))
408
        if c == '\\' {
409
            sp += 2
410
            continue
411
        } else if c == '"' {
412
            inquote = !inquote
413
        } else if c == lchar {
414
            if !inquote {
415
                nbrace += 1
416
            }
417
        } else if c == rchar {
418
            if !inquote {
419
                nbrace -= 1
420
                if nbrace == 0 {
421
                    sp += 1
422
                    break
423
                }
424
            }
425
        }
426
        sp += 1
427
    }
428

429
    if nbrace != 0 {
430
        return -int(types.ERR_INVALID_CHAR)
431
    }
432

433
    runtime.KeepAlive(src)
434
    return int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr))
435
}
436

437
func skipValueFast(src string, pos int) (ret int, start int) {
438
    pos = skipBlank(src, pos)
439
    if pos < 0 {
440
        return pos, -1
441
    }
442
    switch c := src[pos]; c {
443
    case 'n':
444
        ret = decodeNull(src, pos)
445
    case '"':
446
        ret, _ = skipString(src, pos)
447
    case '{':
448
        ret = skipPair(src, pos, '{', '}')
449
    case '[':
450
        ret = skipPair(src, pos, '[', ']')
451
    case 't':
452
        ret = decodeTrue(src, pos)
453
    case 'f':
454
        ret = decodeFalse(src, pos)
455
    case '-', '+', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
456
        ret = skipNumber(src, pos)
457
    default:
458
        ret = -int(types.ERR_INVALID_CHAR)
459
    }
460
    return ret, pos
461
}
462

463
func skipValue(src string, pos int) (ret int, start int) {
464
    pos = skipBlank(src, pos)
465
    if pos < 0 {
466
        return pos, -1
467
    }
468
    switch c := src[pos]; c {
469
    case 'n':
470
        ret = decodeNull(src, pos)
471
    case '"':
472
        ret, _ = skipString(src, pos)
473
    case '{':
474
        ret, _ = skipObject(src, pos)
475
    case '[':
476
        ret, _ = skipArray(src, pos)
477
    case 't':
478
        ret = decodeTrue(src, pos)
479
    case 'f':
480
        ret = decodeFalse(src, pos)
481
    case '-', '+', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
482
        ret = skipNumber(src, pos)
483
    default:
484
        ret = -int(types.ERR_INVALID_CHAR)
485
    }
486
    return ret, pos
487
}
488

489
func skipObject(src string, pos int) (ret int, start int) {
490
    start = skipBlank(src, pos)
491
    if start < 0 {
492
        return start, -1
493
    }
494

495
    if src[start] != '{' {
496
        return -int(types.ERR_INVALID_CHAR), -1
497
    }
498

499
    pos = start + 1
500
    pos = skipBlank(src, pos)
501
    if pos < 0 {
502
        return pos, -1
503
    }
504
    if src[pos] == '}' {
505
        return pos + 1, start
506
    }
507

508
    for {
509
        pos, _ = skipString(src, pos)
510
        if pos < 0 {
511
            return pos, -1
512
        }
513

514
        pos = skipBlank(src, pos)
515
        if pos < 0 {
516
            return pos, -1
517
        }
518
        if src[pos] != ':' {
519
            return -int(types.ERR_INVALID_CHAR), -1
520
        }
521

522
        pos++
523
        pos, _ = skipValue(src, pos)
524
        if pos < 0 {
525
            return pos, -1
526
        }
527

528
        pos = skipBlank(src, pos)
529
        if pos < 0 {
530
            return pos, -1
531
        }
532
        if src[pos] == '}' {
533
            return pos + 1, start
534
        }
535
        if src[pos] != ',' {
536
            return -int(types.ERR_INVALID_CHAR), -1
537
        }
538

539
        pos++
540
        pos = skipBlank(src, pos)
541
        if pos < 0 {
542
            return pos, -1
543
        }
544

545
    }
546
}
547

548
func skipArray(src string, pos int) (ret int, start int) {
549
    start = skipBlank(src, pos)
550
    if start < 0 {
551
        return start, -1
552
    }
553

554
    if src[start] != '[' {
555
        return -int(types.ERR_INVALID_CHAR), -1
556
    }
557

558
    pos = start + 1
559
    pos = skipBlank(src, pos)
560
    if pos < 0 {
561
        return pos, -1
562
    }
563
    if src[pos] == ']' {
564
        return pos + 1, start
565
    }
566

567
    for {
568
        pos, _ = skipValue(src, pos)
569
        if pos < 0 {
570
            return pos, -1
571
        }
572

573
        pos = skipBlank(src, pos)
574
        if pos < 0 {
575
            return pos, -1
576
        }
577
        if src[pos] == ']' {
578
            return pos + 1, start
579
        }
580
        if src[pos] != ',' {
581
            return -int(types.ERR_INVALID_CHAR), -1
582
        }
583
        pos++
584
    }
585
}
586