1
2
3
4
5 package json
6
7
8
9
10
11
12
13
14
15
16 import "strconv"
17
18
19 func Valid(data []byte) bool {
20 return checkValid(data, &scanner{}) == nil
21 }
22
23
24
25 func checkValid(data []byte, scan *scanner) error {
26 scan.reset()
27 for _, c := range data {
28 scan.bytes++
29 if scan.step(scan, c) == scanError {
30 return scan.err
31 }
32 }
33 if scan.eof() == scanError {
34 return scan.err
35 }
36 return nil
37 }
38
39
40
41
42 func nextValue(data []byte, scan *scanner) (value, rest []byte, err error) {
43 scan.reset()
44 for i, c := range data {
45 v := scan.step(scan, c)
46 if v >= scanEndObject {
47 switch v {
48
49
50
51 case scanEndObject, scanEndArray:
52 if scan.step(scan, ' ') == scanEnd {
53 return data[:i+1], data[i+1:], nil
54 }
55 case scanError:
56 return nil, nil, scan.err
57 case scanEnd:
58 return data[:i], data[i:], nil
59 }
60 }
61 }
62 if scan.eof() == scanError {
63 return nil, nil, scan.err
64 }
65 return data, nil, nil
66 }
67
68
69 type SyntaxError struct {
70 msg string
71 Offset int64
72 }
73
74 func (e *SyntaxError) Error() string { return e.msg }
75
76
77
78
79
80
81
82
83
84
85
86
87
88 type scanner struct {
89
90
91
92
93 step func(*scanner, byte) int
94
95
96 endTop bool
97
98
99 parseState []int
100
101
102 err error
103
104
105 redo bool
106 redoCode int
107 redoState func(*scanner, byte) int
108
109
110 bytes int64
111 }
112
113
114
115
116
117
118
119
120 const (
121
122 scanContinue = iota
123 scanBeginLiteral
124 scanBeginObject
125 scanObjectKey
126 scanObjectValue
127 scanEndObject
128 scanBeginArray
129 scanArrayValue
130 scanEndArray
131 scanSkipSpace
132
133
134 scanEnd
135 scanError
136 )
137
138
139
140
141
142 const (
143 parseObjectKey = iota
144 parseObjectValue
145 parseArrayValue
146 )
147
148
149
150 func (s *scanner) reset() {
151 s.step = stateBeginValue
152 s.parseState = s.parseState[0:0]
153 s.err = nil
154 s.redo = false
155 s.endTop = false
156 }
157
158
159
160 func (s *scanner) eof() int {
161 if s.err != nil {
162 return scanError
163 }
164 if s.endTop {
165 return scanEnd
166 }
167 s.step(s, ' ')
168 if s.endTop {
169 return scanEnd
170 }
171 if s.err == nil {
172 s.err = &SyntaxError{"unexpected end of JSON input", s.bytes}
173 }
174 return scanError
175 }
176
177
178 func (s *scanner) pushParseState(p int) {
179 s.parseState = append(s.parseState, p)
180 }
181
182
183
184 func (s *scanner) popParseState() {
185 n := len(s.parseState) - 1
186 s.parseState = s.parseState[0:n]
187 s.redo = false
188 if n == 0 {
189 s.step = stateEndTop
190 s.endTop = true
191 } else {
192 s.step = stateEndValue
193 }
194 }
195
196 func isSpace(c byte) bool {
197 return c == ' ' || c == '\t' || c == '\r' || c == '\n'
198 }
199
200
201 func stateBeginValueOrEmpty(s *scanner, c byte) int {
202 if c <= ' ' && isSpace(c) {
203 return scanSkipSpace
204 }
205 if c == ']' {
206 return stateEndValue(s, c)
207 }
208 return stateBeginValue(s, c)
209 }
210
211
212 func stateBeginValue(s *scanner, c byte) int {
213 if c <= ' ' && isSpace(c) {
214 return scanSkipSpace
215 }
216 switch c {
217 case '{':
218 s.step = stateBeginStringOrEmpty
219 s.pushParseState(parseObjectKey)
220 return scanBeginObject
221 case '[':
222 s.step = stateBeginValueOrEmpty
223 s.pushParseState(parseArrayValue)
224 return scanBeginArray
225 case '"':
226 s.step = stateInString
227 return scanBeginLiteral
228 case '-':
229 s.step = stateNeg
230 return scanBeginLiteral
231 case '0':
232 s.step = state0
233 return scanBeginLiteral
234 case 't':
235 s.step = stateT
236 return scanBeginLiteral
237 case 'f':
238 s.step = stateF
239 return scanBeginLiteral
240 case 'n':
241 s.step = stateN
242 return scanBeginLiteral
243 }
244 if '1' <= c && c <= '9' {
245 s.step = state1
246 return scanBeginLiteral
247 }
248 return s.error(c, "looking for beginning of value")
249 }
250
251
252 func stateBeginStringOrEmpty(s *scanner, c byte) int {
253 if c <= ' ' && isSpace(c) {
254 return scanSkipSpace
255 }
256 if c == '}' {
257 n := len(s.parseState)
258 s.parseState[n-1] = parseObjectValue
259 return stateEndValue(s, c)
260 }
261 return stateBeginString(s, c)
262 }
263
264
265 func stateBeginString(s *scanner, c byte) int {
266 if c <= ' ' && isSpace(c) {
267 return scanSkipSpace
268 }
269 if c == '"' {
270 s.step = stateInString
271 return scanBeginLiteral
272 }
273 return s.error(c, "looking for beginning of object key string")
274 }
275
276
277
278 func stateEndValue(s *scanner, c byte) int {
279 n := len(s.parseState)
280 if n == 0 {
281
282 s.step = stateEndTop
283 s.endTop = true
284 return stateEndTop(s, c)
285 }
286 if c <= ' ' && isSpace(c) {
287 s.step = stateEndValue
288 return scanSkipSpace
289 }
290 ps := s.parseState[n-1]
291 switch ps {
292 case parseObjectKey:
293 if c == ':' {
294 s.parseState[n-1] = parseObjectValue
295 s.step = stateBeginValue
296 return scanObjectKey
297 }
298 return s.error(c, "after object key")
299 case parseObjectValue:
300 if c == ',' {
301 s.parseState[n-1] = parseObjectKey
302 s.step = stateBeginString
303 return scanObjectValue
304 }
305 if c == '}' {
306 s.popParseState()
307 return scanEndObject
308 }
309 return s.error(c, "after object key:value pair")
310 case parseArrayValue:
311 if c == ',' {
312 s.step = stateBeginValue
313 return scanArrayValue
314 }
315 if c == ']' {
316 s.popParseState()
317 return scanEndArray
318 }
319 return s.error(c, "after array element")
320 }
321 return s.error(c, "")
322 }
323
324
325
326
327 func stateEndTop(s *scanner, c byte) int {
328 if c != ' ' && c != '\t' && c != '\r' && c != '\n' {
329
330 s.error(c, "after top-level value")
331 }
332 return scanEnd
333 }
334
335
336 func stateInString(s *scanner, c byte) int {
337 if c == '"' {
338 s.step = stateEndValue
339 return scanContinue
340 }
341 if c == '\\' {
342 s.step = stateInStringEsc
343 return scanContinue
344 }
345 if c < 0x20 {
346 return s.error(c, "in string literal")
347 }
348 return scanContinue
349 }
350
351
352 func stateInStringEsc(s *scanner, c byte) int {
353 switch c {
354 case 'b', 'f', 'n', 'r', 't', '\\', '/', '"':
355 s.step = stateInString
356 return scanContinue
357 case 'u':
358 s.step = stateInStringEscU
359 return scanContinue
360 }
361 return s.error(c, "in string escape code")
362 }
363
364
365 func stateInStringEscU(s *scanner, c byte) int {
366 if '0' <= c && c <= '9' || 'a' <= c && c <= 'f' || 'A' <= c && c <= 'F' {
367 s.step = stateInStringEscU1
368 return scanContinue
369 }
370
371 return s.error(c, "in \\u hexadecimal character escape")
372 }
373
374
375 func stateInStringEscU1(s *scanner, c byte) int {
376 if '0' <= c && c <= '9' || 'a' <= c && c <= 'f' || 'A' <= c && c <= 'F' {
377 s.step = stateInStringEscU12
378 return scanContinue
379 }
380
381 return s.error(c, "in \\u hexadecimal character escape")
382 }
383
384
385 func stateInStringEscU12(s *scanner, c byte) int {
386 if '0' <= c && c <= '9' || 'a' <= c && c <= 'f' || 'A' <= c && c <= 'F' {
387 s.step = stateInStringEscU123
388 return scanContinue
389 }
390
391 return s.error(c, "in \\u hexadecimal character escape")
392 }
393
394
395 func stateInStringEscU123(s *scanner, c byte) int {
396 if '0' <= c && c <= '9' || 'a' <= c && c <= 'f' || 'A' <= c && c <= 'F' {
397 s.step = stateInString
398 return scanContinue
399 }
400
401 return s.error(c, "in \\u hexadecimal character escape")
402 }
403
404
405 func stateNeg(s *scanner, c byte) int {
406 if c == '0' {
407 s.step = state0
408 return scanContinue
409 }
410 if '1' <= c && c <= '9' {
411 s.step = state1
412 return scanContinue
413 }
414 return s.error(c, "in numeric literal")
415 }
416
417
418
419 func state1(s *scanner, c byte) int {
420 if '0' <= c && c <= '9' {
421 s.step = state1
422 return scanContinue
423 }
424 return state0(s, c)
425 }
426
427
428 func state0(s *scanner, c byte) int {
429 if c == '.' {
430 s.step = stateDot
431 return scanContinue
432 }
433 if c == 'e' || c == 'E' {
434 s.step = stateE
435 return scanContinue
436 }
437 return stateEndValue(s, c)
438 }
439
440
441
442 func stateDot(s *scanner, c byte) int {
443 if '0' <= c && c <= '9' {
444 s.step = stateDot0
445 return scanContinue
446 }
447 return s.error(c, "after decimal point in numeric literal")
448 }
449
450
451
452 func stateDot0(s *scanner, c byte) int {
453 if '0' <= c && c <= '9' {
454 return scanContinue
455 }
456 if c == 'e' || c == 'E' {
457 s.step = stateE
458 return scanContinue
459 }
460 return stateEndValue(s, c)
461 }
462
463
464
465 func stateE(s *scanner, c byte) int {
466 if c == '+' || c == '-' {
467 s.step = stateESign
468 return scanContinue
469 }
470 return stateESign(s, c)
471 }
472
473
474
475 func stateESign(s *scanner, c byte) int {
476 if '0' <= c && c <= '9' {
477 s.step = stateE0
478 return scanContinue
479 }
480 return s.error(c, "in exponent of numeric literal")
481 }
482
483
484
485
486 func stateE0(s *scanner, c byte) int {
487 if '0' <= c && c <= '9' {
488 return scanContinue
489 }
490 return stateEndValue(s, c)
491 }
492
493
494 func stateT(s *scanner, c byte) int {
495 if c == 'r' {
496 s.step = stateTr
497 return scanContinue
498 }
499 return s.error(c, "in literal true (expecting 'r')")
500 }
501
502
503 func stateTr(s *scanner, c byte) int {
504 if c == 'u' {
505 s.step = stateTru
506 return scanContinue
507 }
508 return s.error(c, "in literal true (expecting 'u')")
509 }
510
511
512 func stateTru(s *scanner, c byte) int {
513 if c == 'e' {
514 s.step = stateEndValue
515 return scanContinue
516 }
517 return s.error(c, "in literal true (expecting 'e')")
518 }
519
520
521 func stateF(s *scanner, c byte) int {
522 if c == 'a' {
523 s.step = stateFa
524 return scanContinue
525 }
526 return s.error(c, "in literal false (expecting 'a')")
527 }
528
529
530 func stateFa(s *scanner, c byte) int {
531 if c == 'l' {
532 s.step = stateFal
533 return scanContinue
534 }
535 return s.error(c, "in literal false (expecting 'l')")
536 }
537
538
539 func stateFal(s *scanner, c byte) int {
540 if c == 's' {
541 s.step = stateFals
542 return scanContinue
543 }
544 return s.error(c, "in literal false (expecting 's')")
545 }
546
547
548 func stateFals(s *scanner, c byte) int {
549 if c == 'e' {
550 s.step = stateEndValue
551 return scanContinue
552 }
553 return s.error(c, "in literal false (expecting 'e')")
554 }
555
556
557 func stateN(s *scanner, c byte) int {
558 if c == 'u' {
559 s.step = stateNu
560 return scanContinue
561 }
562 return s.error(c, "in literal null (expecting 'u')")
563 }
564
565
566 func stateNu(s *scanner, c byte) int {
567 if c == 'l' {
568 s.step = stateNul
569 return scanContinue
570 }
571 return s.error(c, "in literal null (expecting 'l')")
572 }
573
574
575 func stateNul(s *scanner, c byte) int {
576 if c == 'l' {
577 s.step = stateEndValue
578 return scanContinue
579 }
580 return s.error(c, "in literal null (expecting 'l')")
581 }
582
583
584
585 func stateError(s *scanner, c byte) int {
586 return scanError
587 }
588
589
590 func (s *scanner) error(c byte, context string) int {
591 s.step = stateError
592 s.err = &SyntaxError{"invalid character " + quoteChar(c) + " " + context, s.bytes}
593 return scanError
594 }
595
596
597 func quoteChar(c byte) string {
598
599 if c == '\'' {
600 return `'\''`
601 }
602 if c == '"' {
603 return `'"'`
604 }
605
606
607 s := strconv.Quote(string(c))
608 return "'" + s[1:len(s)-1] + "'"
609 }
610
611
612
613 func (s *scanner) undo(scanCode int) {
614 if s.redo {
615 panic("json: invalid use of scanner")
616 }
617 s.redoCode = scanCode
618 s.redoState = s.step
619 s.step = stateRedo
620 s.redo = true
621 }
622
623
624 func stateRedo(s *scanner, c byte) int {
625 s.redo = false
626 s.step = s.redoState
627 return s.redoCode
628 }
629
View as plain text