1
2
3
4
5 package json
6
7 import (
8 "bytes"
9 "errors"
10 "io"
11 )
12
13
14 type Decoder struct {
15 r io.Reader
16 buf []byte
17 d decodeState
18 scanp int
19 scanned int64
20 scan scanner
21 err error
22
23 tokenState int
24 tokenStack []int
25 }
26
27
28
29
30
31 func NewDecoder(r io.Reader) *Decoder {
32 return &Decoder{r: r}
33 }
34
35
36
37 func (dec *Decoder) UseNumber() { dec.d.useNumber = true }
38
39
40
41
42 func (dec *Decoder) DisallowUnknownFields() { dec.d.disallowUnknownFields = true }
43
44
45
46
47
48
49 func (dec *Decoder) Decode(v interface{}) error {
50 if dec.err != nil {
51 return dec.err
52 }
53
54 if err := dec.tokenPrepareForDecode(); err != nil {
55 return err
56 }
57
58 if !dec.tokenValueAllowed() {
59 return &SyntaxError{msg: "not at beginning of value", Offset: dec.offset()}
60 }
61
62
63 n, err := dec.readValue()
64 if err != nil {
65 return err
66 }
67 dec.d.init(dec.buf[dec.scanp : dec.scanp+n])
68 dec.scanp += n
69
70
71
72
73 err = dec.d.unmarshal(v)
74
75
76 dec.tokenValueEnd()
77
78 return err
79 }
80
81
82
83 func (dec *Decoder) Buffered() io.Reader {
84 return bytes.NewReader(dec.buf[dec.scanp:])
85 }
86
87
88
89 func (dec *Decoder) readValue() (int, error) {
90 dec.scan.reset()
91
92 scanp := dec.scanp
93 var err error
94 Input:
95 for {
96
97 for i, c := range dec.buf[scanp:] {
98 dec.scan.bytes++
99 v := dec.scan.step(&dec.scan, c)
100 if v == scanEnd {
101 scanp += i
102 break Input
103 }
104
105
106
107 if (v == scanEndObject || v == scanEndArray) && dec.scan.step(&dec.scan, ' ') == scanEnd {
108 scanp += i + 1
109 break Input
110 }
111 if v == scanError {
112 dec.err = dec.scan.err
113 return 0, dec.scan.err
114 }
115 }
116 scanp = len(dec.buf)
117
118
119
120 if err != nil {
121 if err == io.EOF {
122 if dec.scan.step(&dec.scan, ' ') == scanEnd {
123 break Input
124 }
125 if nonSpace(dec.buf) {
126 err = io.ErrUnexpectedEOF
127 }
128 }
129 dec.err = err
130 return 0, err
131 }
132
133 n := scanp - dec.scanp
134 err = dec.refill()
135 scanp = dec.scanp + n
136 }
137 return scanp - dec.scanp, nil
138 }
139
140 func (dec *Decoder) refill() error {
141
142
143 if dec.scanp > 0 {
144 dec.scanned += int64(dec.scanp)
145 n := copy(dec.buf, dec.buf[dec.scanp:])
146 dec.buf = dec.buf[:n]
147 dec.scanp = 0
148 }
149
150
151 const minRead = 512
152 if cap(dec.buf)-len(dec.buf) < minRead {
153 newBuf := make([]byte, len(dec.buf), 2*cap(dec.buf)+minRead)
154 copy(newBuf, dec.buf)
155 dec.buf = newBuf
156 }
157
158
159 n, err := dec.r.Read(dec.buf[len(dec.buf):cap(dec.buf)])
160 dec.buf = dec.buf[0 : len(dec.buf)+n]
161
162 return err
163 }
164
165 func nonSpace(b []byte) bool {
166 for _, c := range b {
167 if !isSpace(c) {
168 return true
169 }
170 }
171 return false
172 }
173
174
175 type Encoder struct {
176 w io.Writer
177 err error
178 escapeHTML bool
179
180 indentBuf *bytes.Buffer
181 indentPrefix string
182 indentValue string
183 }
184
185
186 func NewEncoder(w io.Writer) *Encoder {
187 return &Encoder{w: w, escapeHTML: true}
188 }
189
190
191
192
193
194
195 func (enc *Encoder) Encode(v interface{}) error {
196 if enc.err != nil {
197 return enc.err
198 }
199 e := newEncodeState()
200 err := e.marshal(v, encOpts{escapeHTML: enc.escapeHTML})
201 if err != nil {
202 return err
203 }
204
205
206
207
208
209
210
211 e.WriteByte('\n')
212
213 b := e.Bytes()
214 if enc.indentPrefix != "" || enc.indentValue != "" {
215 if enc.indentBuf == nil {
216 enc.indentBuf = new(bytes.Buffer)
217 }
218 enc.indentBuf.Reset()
219 err = Indent(enc.indentBuf, b, enc.indentPrefix, enc.indentValue)
220 if err != nil {
221 return err
222 }
223 b = enc.indentBuf.Bytes()
224 }
225 if _, err = enc.w.Write(b); err != nil {
226 enc.err = err
227 }
228 encodeStatePool.Put(e)
229 return err
230 }
231
232
233
234
235 func (enc *Encoder) SetIndent(prefix, indent string) {
236 enc.indentPrefix = prefix
237 enc.indentValue = indent
238 }
239
240
241
242
243
244
245
246
247 func (enc *Encoder) SetEscapeHTML(on bool) {
248 enc.escapeHTML = on
249 }
250
251
252
253
254 type RawMessage []byte
255
256
257 func (m RawMessage) MarshalJSON() ([]byte, error) {
258 if m == nil {
259 return []byte("null"), nil
260 }
261 return m, nil
262 }
263
264
265 func (m *RawMessage) UnmarshalJSON(data []byte) error {
266 if m == nil {
267 return errors.New("json.RawMessage: UnmarshalJSON on nil pointer")
268 }
269 *m = append((*m)[0:0], data...)
270 return nil
271 }
272
273 var _ Marshaler = (*RawMessage)(nil)
274 var _ Unmarshaler = (*RawMessage)(nil)
275
276
277
278
279
280
281
282
283
284
285 type Token interface{}
286
287 const (
288 tokenTopValue = iota
289 tokenArrayStart
290 tokenArrayValue
291 tokenArrayComma
292 tokenObjectStart
293 tokenObjectKey
294 tokenObjectColon
295 tokenObjectValue
296 tokenObjectComma
297 )
298
299
300 func (dec *Decoder) tokenPrepareForDecode() error {
301
302
303
304 switch dec.tokenState {
305 case tokenArrayComma:
306 c, err := dec.peek()
307 if err != nil {
308 return err
309 }
310 if c != ',' {
311 return &SyntaxError{"expected comma after array element", dec.offset()}
312 }
313 dec.scanp++
314 dec.tokenState = tokenArrayValue
315 case tokenObjectColon:
316 c, err := dec.peek()
317 if err != nil {
318 return err
319 }
320 if c != ':' {
321 return &SyntaxError{"expected colon after object key", dec.offset()}
322 }
323 dec.scanp++
324 dec.tokenState = tokenObjectValue
325 }
326 return nil
327 }
328
329 func (dec *Decoder) tokenValueAllowed() bool {
330 switch dec.tokenState {
331 case tokenTopValue, tokenArrayStart, tokenArrayValue, tokenObjectValue:
332 return true
333 }
334 return false
335 }
336
337 func (dec *Decoder) tokenValueEnd() {
338 switch dec.tokenState {
339 case tokenArrayStart, tokenArrayValue:
340 dec.tokenState = tokenArrayComma
341 case tokenObjectValue:
342 dec.tokenState = tokenObjectComma
343 }
344 }
345
346
347 type Delim rune
348
349 func (d Delim) String() string {
350 return string(d)
351 }
352
353
354
355
356
357
358
359
360
361
362
363
364 func (dec *Decoder) Token() (Token, error) {
365 for {
366 c, err := dec.peek()
367 if err != nil {
368 return nil, err
369 }
370 switch c {
371 case '[':
372 if !dec.tokenValueAllowed() {
373 return dec.tokenError(c)
374 }
375 dec.scanp++
376 dec.tokenStack = append(dec.tokenStack, dec.tokenState)
377 dec.tokenState = tokenArrayStart
378 return Delim('['), nil
379
380 case ']':
381 if dec.tokenState != tokenArrayStart && dec.tokenState != tokenArrayComma {
382 return dec.tokenError(c)
383 }
384 dec.scanp++
385 dec.tokenState = dec.tokenStack[len(dec.tokenStack)-1]
386 dec.tokenStack = dec.tokenStack[:len(dec.tokenStack)-1]
387 dec.tokenValueEnd()
388 return Delim(']'), nil
389
390 case '{':
391 if !dec.tokenValueAllowed() {
392 return dec.tokenError(c)
393 }
394 dec.scanp++
395 dec.tokenStack = append(dec.tokenStack, dec.tokenState)
396 dec.tokenState = tokenObjectStart
397 return Delim('{'), nil
398
399 case '}':
400 if dec.tokenState != tokenObjectStart && dec.tokenState != tokenObjectComma {
401 return dec.tokenError(c)
402 }
403 dec.scanp++
404 dec.tokenState = dec.tokenStack[len(dec.tokenStack)-1]
405 dec.tokenStack = dec.tokenStack[:len(dec.tokenStack)-1]
406 dec.tokenValueEnd()
407 return Delim('}'), nil
408
409 case ':':
410 if dec.tokenState != tokenObjectColon {
411 return dec.tokenError(c)
412 }
413 dec.scanp++
414 dec.tokenState = tokenObjectValue
415 continue
416
417 case ',':
418 if dec.tokenState == tokenArrayComma {
419 dec.scanp++
420 dec.tokenState = tokenArrayValue
421 continue
422 }
423 if dec.tokenState == tokenObjectComma {
424 dec.scanp++
425 dec.tokenState = tokenObjectKey
426 continue
427 }
428 return dec.tokenError(c)
429
430 case '"':
431 if dec.tokenState == tokenObjectStart || dec.tokenState == tokenObjectKey {
432 var x string
433 old := dec.tokenState
434 dec.tokenState = tokenTopValue
435 err := dec.Decode(&x)
436 dec.tokenState = old
437 if err != nil {
438 return nil, err
439 }
440 dec.tokenState = tokenObjectColon
441 return x, nil
442 }
443 fallthrough
444
445 default:
446 if !dec.tokenValueAllowed() {
447 return dec.tokenError(c)
448 }
449 var x interface{}
450 if err := dec.Decode(&x); err != nil {
451 return nil, err
452 }
453 return x, nil
454 }
455 }
456 }
457
458 func (dec *Decoder) tokenError(c byte) (Token, error) {
459 var context string
460 switch dec.tokenState {
461 case tokenTopValue:
462 context = " looking for beginning of value"
463 case tokenArrayStart, tokenArrayValue, tokenObjectValue:
464 context = " looking for beginning of value"
465 case tokenArrayComma:
466 context = " after array element"
467 case tokenObjectKey:
468 context = " looking for beginning of object key string"
469 case tokenObjectColon:
470 context = " after object key"
471 case tokenObjectComma:
472 context = " after object key:value pair"
473 }
474 return nil, &SyntaxError{"invalid character " + quoteChar(c) + " " + context, dec.offset()}
475 }
476
477
478
479 func (dec *Decoder) More() bool {
480 c, err := dec.peek()
481 return err == nil && c != ']' && c != '}'
482 }
483
484 func (dec *Decoder) peek() (byte, error) {
485 var err error
486 for {
487 for i := dec.scanp; i < len(dec.buf); i++ {
488 c := dec.buf[i]
489 if isSpace(c) {
490 continue
491 }
492 dec.scanp = i
493 return c, nil
494 }
495
496 if err != nil {
497 return 0, err
498 }
499 err = dec.refill()
500 }
501 }
502
503 func (dec *Decoder) offset() int64 {
504 return dec.scanned + int64(dec.scanp)
505 }
506
View as plain text