podman

1
package jsoniter
2

3
import (
4
	"encoding/json"
5
	"fmt"
6
	"io"
7
)
8

9
// ValueType the type for JSON element
10
type ValueType int
11

12
const (
13
	// InvalidValue invalid JSON element
14
	InvalidValue ValueType = iota
15
	// StringValue JSON element "string"
16
	StringValue
17
	// NumberValue JSON element 100 or 0.10
18
	NumberValue
19
	// NilValue JSON element null
20
	NilValue
21
	// BoolValue JSON element true or false
22
	BoolValue
23
	// ArrayValue JSON element []
24
	ArrayValue
25
	// ObjectValue JSON element {}
26
	ObjectValue
27
)
28

29
var hexDigits []byte
30
var valueTypes []ValueType
31

32
func init() {
33
	hexDigits = make([]byte, 256)
34
	for i := 0; i < len(hexDigits); i++ {
35
		hexDigits[i] = 255
36
	}
37
	for i := '0'; i <= '9'; i++ {
38
		hexDigits[i] = byte(i - '0')
39
	}
40
	for i := 'a'; i <= 'f'; i++ {
41
		hexDigits[i] = byte((i - 'a') + 10)
42
	}
43
	for i := 'A'; i <= 'F'; i++ {
44
		hexDigits[i] = byte((i - 'A') + 10)
45
	}
46
	valueTypes = make([]ValueType, 256)
47
	for i := 0; i < len(valueTypes); i++ {
48
		valueTypes[i] = InvalidValue
49
	}
50
	valueTypes['"'] = StringValue
51
	valueTypes['-'] = NumberValue
52
	valueTypes['0'] = NumberValue
53
	valueTypes['1'] = NumberValue
54
	valueTypes['2'] = NumberValue
55
	valueTypes['3'] = NumberValue
56
	valueTypes['4'] = NumberValue
57
	valueTypes['5'] = NumberValue
58
	valueTypes['6'] = NumberValue
59
	valueTypes['7'] = NumberValue
60
	valueTypes['8'] = NumberValue
61
	valueTypes['9'] = NumberValue
62
	valueTypes['t'] = BoolValue
63
	valueTypes['f'] = BoolValue
64
	valueTypes['n'] = NilValue
65
	valueTypes['['] = ArrayValue
66
	valueTypes['{'] = ObjectValue
67
}
68

69
// Iterator is a io.Reader like object, with JSON specific read functions.
70
// Error is not returned as return value, but stored as Error member on this iterator instance.
71
type Iterator struct {
72
	cfg              *frozenConfig
73
	reader           io.Reader
74
	buf              []byte
75
	head             int
76
	tail             int
77
	depth            int
78
	captureStartedAt int
79
	captured         []byte
80
	Error            error
81
	Attachment       interface{} // open for customized decoder
82
}
83

84
// NewIterator creates an empty Iterator instance
85
func NewIterator(cfg API) *Iterator {
86
	return &Iterator{
87
		cfg:    cfg.(*frozenConfig),
88
		reader: nil,
89
		buf:    nil,
90
		head:   0,
91
		tail:   0,
92
		depth:  0,
93
	}
94
}
95

96
// Parse creates an Iterator instance from io.Reader
97
func Parse(cfg API, reader io.Reader, bufSize int) *Iterator {
98
	return &Iterator{
99
		cfg:    cfg.(*frozenConfig),
100
		reader: reader,
101
		buf:    make([]byte, bufSize),
102
		head:   0,
103
		tail:   0,
104
		depth:  0,
105
	}
106
}
107

108
// ParseBytes creates an Iterator instance from byte array
109
func ParseBytes(cfg API, input []byte) *Iterator {
110
	return &Iterator{
111
		cfg:    cfg.(*frozenConfig),
112
		reader: nil,
113
		buf:    input,
114
		head:   0,
115
		tail:   len(input),
116
		depth:  0,
117
	}
118
}
119

120
// ParseString creates an Iterator instance from string
121
func ParseString(cfg API, input string) *Iterator {
122
	return ParseBytes(cfg, []byte(input))
123
}
124

125
// Pool returns a pool can provide more iterator with same configuration
126
func (iter *Iterator) Pool() IteratorPool {
127
	return iter.cfg
128
}
129

130
// Reset reuse iterator instance by specifying another reader
131
func (iter *Iterator) Reset(reader io.Reader) *Iterator {
132
	iter.reader = reader
133
	iter.head = 0
134
	iter.tail = 0
135
	iter.depth = 0
136
	return iter
137
}
138

139
// ResetBytes reuse iterator instance by specifying another byte array as input
140
func (iter *Iterator) ResetBytes(input []byte) *Iterator {
141
	iter.reader = nil
142
	iter.buf = input
143
	iter.head = 0
144
	iter.tail = len(input)
145
	iter.depth = 0
146
	return iter
147
}
148

149
// WhatIsNext gets ValueType of relatively next json element
150
func (iter *Iterator) WhatIsNext() ValueType {
151
	valueType := valueTypes[iter.nextToken()]
152
	iter.unreadByte()
153
	return valueType
154
}
155

156
func (iter *Iterator) skipWhitespacesWithoutLoadMore() bool {
157
	for i := iter.head; i < iter.tail; i++ {
158
		c := iter.buf[i]
159
		switch c {
160
		case ' ', '\n', '\t', '\r':
161
			continue
162
		}
163
		iter.head = i
164
		return false
165
	}
166
	return true
167
}
168

169
func (iter *Iterator) isObjectEnd() bool {
170
	c := iter.nextToken()
171
	if c == ',' {
172
		return false
173
	}
174
	if c == '}' {
175
		return true
176
	}
177
	iter.ReportError("isObjectEnd", "object ended prematurely, unexpected char "+string([]byte{c}))
178
	return true
179
}
180

181
func (iter *Iterator) nextToken() byte {
182
	// a variation of skip whitespaces, returning the next non-whitespace token
183
	for {
184
		for i := iter.head; i < iter.tail; i++ {
185
			c := iter.buf[i]
186
			switch c {
187
			case ' ', '\n', '\t', '\r':
188
				continue
189
			}
190
			iter.head = i + 1
191
			return c
192
		}
193
		if !iter.loadMore() {
194
			return 0
195
		}
196
	}
197
}
198

199
// ReportError record a error in iterator instance with current position.
200
func (iter *Iterator) ReportError(operation string, msg string) {
201
	if iter.Error != nil {
202
		if iter.Error != io.EOF {
203
			return
204
		}
205
	}
206
	peekStart := iter.head - 10
207
	if peekStart < 0 {
208
		peekStart = 0
209
	}
210
	peekEnd := iter.head + 10
211
	if peekEnd > iter.tail {
212
		peekEnd = iter.tail
213
	}
214
	parsing := string(iter.buf[peekStart:peekEnd])
215
	contextStart := iter.head - 50
216
	if contextStart < 0 {
217
		contextStart = 0
218
	}
219
	contextEnd := iter.head + 50
220
	if contextEnd > iter.tail {
221
		contextEnd = iter.tail
222
	}
223
	context := string(iter.buf[contextStart:contextEnd])
224
	iter.Error = fmt.Errorf("%s: %s, error found in #%v byte of ...|%s|..., bigger context ...|%s|...",
225
		operation, msg, iter.head-peekStart, parsing, context)
226
}
227

228
// CurrentBuffer gets current buffer as string for debugging purpose
229
func (iter *Iterator) CurrentBuffer() string {
230
	peekStart := iter.head - 10
231
	if peekStart < 0 {
232
		peekStart = 0
233
	}
234
	return fmt.Sprintf("parsing #%v byte, around ...|%s|..., whole buffer ...|%s|...", iter.head,
235
		string(iter.buf[peekStart:iter.head]), string(iter.buf[0:iter.tail]))
236
}
237

238
func (iter *Iterator) readByte() (ret byte) {
239
	if iter.head == iter.tail {
240
		if iter.loadMore() {
241
			ret = iter.buf[iter.head]
242
			iter.head++
243
			return ret
244
		}
245
		return 0
246
	}
247
	ret = iter.buf[iter.head]
248
	iter.head++
249
	return ret
250
}
251

252
func (iter *Iterator) loadMore() bool {
253
	if iter.reader == nil {
254
		if iter.Error == nil {
255
			iter.head = iter.tail
256
			iter.Error = io.EOF
257
		}
258
		return false
259
	}
260
	if iter.captured != nil {
261
		iter.captured = append(iter.captured,
262
			iter.buf[iter.captureStartedAt:iter.tail]...)
263
		iter.captureStartedAt = 0
264
	}
265
	for {
266
		n, err := iter.reader.Read(iter.buf)
267
		if n == 0 {
268
			if err != nil {
269
				if iter.Error == nil {
270
					iter.Error = err
271
				}
272
				return false
273
			}
274
		} else {
275
			iter.head = 0
276
			iter.tail = n
277
			return true
278
		}
279
	}
280
}
281

282
func (iter *Iterator) unreadByte() {
283
	if iter.Error != nil {
284
		return
285
	}
286
	iter.head--
287
	return
288
}
289

290
// Read read the next JSON element as generic interface{}.
291
func (iter *Iterator) Read() interface{} {
292
	valueType := iter.WhatIsNext()
293
	switch valueType {
294
	case StringValue:
295
		return iter.ReadString()
296
	case NumberValue:
297
		if iter.cfg.configBeforeFrozen.UseNumber {
298
			return json.Number(iter.readNumberAsString())
299
		}
300
		return iter.ReadFloat64()
301
	case NilValue:
302
		iter.skipFourBytes('n', 'u', 'l', 'l')
303
		return nil
304
	case BoolValue:
305
		return iter.ReadBool()
306
	case ArrayValue:
307
		arr := []interface{}{}
308
		iter.ReadArrayCB(func(iter *Iterator) bool {
309
			var elem interface{}
310
			iter.ReadVal(&elem)
311
			arr = append(arr, elem)
312
			return true
313
		})
314
		return arr
315
	case ObjectValue:
316
		obj := map[string]interface{}{}
317
		iter.ReadMapCB(func(Iter *Iterator, field string) bool {
318
			var elem interface{}
319
			iter.ReadVal(&elem)
320
			obj[field] = elem
321
			return true
322
		})
323
		return obj
324
	default:
325
		iter.ReportError("Read", fmt.Sprintf("unexpected value type: %v", valueType))
326
		return nil
327
	}
328
}
329

330
// limit maximum depth of nesting, as allowed by https://tools.ietf.org/html/rfc7159#section-9
331
const maxDepth = 10000
332

333
func (iter *Iterator) incrementDepth() (success bool) {
334
	iter.depth++
335
	if iter.depth <= maxDepth {
336
		return true
337
	}
338
	iter.ReportError("incrementDepth", "exceeded max depth")
339
	return false
340
}
341

342
func (iter *Iterator) decrementDepth() (success bool) {
343
	iter.depth--
344
	if iter.depth >= 0 {
345
		return true
346
	}
347
	iter.ReportError("decrementDepth", "unexpected negative nesting")
348
	return false
349
}
350