+++ /dev/null
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// JSON (JavaScript Object Notation) parser.
-// See http://www.json.org/
-
-// The json package implements a simple parser and
-// representation for JSON (JavaScript Object Notation),
-// as defined at http://www.json.org/.
-package json
-
-import (
- "bytes"
- "strconv"
- "utf8"
-)
-
-// Strings
-//
-// Double quoted with escapes: \" \\ \/ \b \f \n \r \t \uXXXX.
-// No literal control characters, supposedly.
-// Have also seen \' and embedded newlines.
-
-func _UnHex(p string, r, l int) (v int, ok bool) {
- v = 0
- for i := r; i < l; i++ {
- if i >= len(p) {
- return 0, false
- }
- v *= 16
- switch {
- case '0' <= p[i] && p[i] <= '9':
- v += int(p[i] - '0')
- case 'a' <= p[i] && p[i] <= 'f':
- v += int(p[i] - 'a' + 10)
- case 'A' <= p[i] && p[i] <= 'F':
- v += int(p[i] - 'A' + 10)
- default:
- return 0, false
- }
- }
- return v, true
-}
-
-func _ToHex(b []byte, rune int) {
- const hexDigits = "0123456789abcdef"
- b[0] = hexDigits[rune>>12&0xf]
- b[1] = hexDigits[rune>>8&0xf]
- b[2] = hexDigits[rune>>4&0xf]
- b[3] = hexDigits[rune&0xf]
-}
-
-// Unquote unquotes the JSON-quoted string s,
-// returning a raw string t. If s is not a valid
-// JSON-quoted string, Unquote returns with ok set to false.
-func Unquote(s string) (t string, ok bool) {
- if len(s) < 2 || s[0] != '"' || s[len(s)-1] != '"' {
- return
- }
- b := make([]byte, len(s))
- w := 0
- for r := 1; r < len(s)-1; {
- switch {
- case s[r] == '\\':
- r++
- if r >= len(s)-1 {
- return
- }
- switch s[r] {
- default:
- return
- case '"', '\\', '/', '\'':
- b[w] = s[r]
- r++
- w++
- case 'b':
- b[w] = '\b'
- r++
- w++
- case 'f':
- b[w] = '\f'
- r++
- w++
- case 'n':
- b[w] = '\n'
- r++
- w++
- case 'r':
- b[w] = '\r'
- r++
- w++
- case 't':
- b[w] = '\t'
- r++
- w++
- case 'u':
- r++
- rune, ok := _UnHex(s, r, r+4)
- if !ok {
- return
- }
- r += 4
- w += utf8.EncodeRune(rune, b[w:])
- }
- // Control characters are invalid, but we've seen raw \n.
- case s[r] < ' ' && s[r] != '\n':
- if s[r] == '\n' {
- b[w] = '\n'
- r++
- w++
- break
- }
- return
- // ASCII
- case s[r] < utf8.RuneSelf:
- b[w] = s[r]
- r++
- w++
- // Coerce to well-formed UTF-8.
- default:
- rune, size := utf8.DecodeRuneInString(s[r:])
- r += size
- w += utf8.EncodeRune(rune, b[w:])
- }
- }
- return string(b[0:w]), true
-}
-
-// Quote quotes the raw string s using JSON syntax,
-// so that Unquote(Quote(s)) = s, true.
-func Quote(s string) string {
- chr := make([]byte, 6)
- chr0 := chr[0:1]
- b := new(bytes.Buffer)
- chr[0] = '"'
- b.Write(chr0)
-
- for _, rune := range s {
- switch {
- case rune == '"' || rune == '\\':
- chr[0] = '\\'
- chr[1] = byte(rune)
- b.Write(chr[0:2])
-
- case rune == '\b':
- chr[0] = '\\'
- chr[1] = 'b'
- b.Write(chr[0:2])
-
- case rune == '\f':
- chr[0] = '\\'
- chr[1] = 'f'
- b.Write(chr[0:2])
-
- case rune == '\n':
- chr[0] = '\\'
- chr[1] = 'n'
- b.Write(chr[0:2])
-
- case rune == '\r':
- chr[0] = '\\'
- chr[1] = 'r'
- b.Write(chr[0:2])
-
- case rune == '\t':
- chr[0] = '\\'
- chr[1] = 't'
- b.Write(chr[0:2])
-
- case 0x20 <= rune && rune < utf8.RuneSelf:
- chr[0] = byte(rune)
- b.Write(chr0)
-
- default:
- chr[0] = '\\'
- chr[1] = 'u'
- _ToHex(chr[2:6], rune)
- b.Write(chr)
- }
- }
- chr[0] = '"'
- b.Write(chr0)
- return b.String()
-}
-
-
-// _Lexer
-
-type _Lexer struct {
- s string
- i int
- kind int
- token string
-}
-
-func punct(c byte) bool {
- return c == '"' || c == '[' || c == ']' || c == ':' || c == '{' || c == '}' || c == ','
-}
-
-func white(c byte) bool { return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\v' }
-
-func skipwhite(p string, i int) int {
- for i < len(p) && white(p[i]) {
- i++
- }
- return i
-}
-
-func skiptoken(p string, i int) int {
- for i < len(p) && !punct(p[i]) && !white(p[i]) {
- i++
- }
- return i
-}
-
-func skipstring(p string, i int) int {
- for i++; i < len(p) && p[i] != '"'; i++ {
- if p[i] == '\\' {
- i++
- }
- }
- if i >= len(p) {
- return i
- }
- return i + 1
-}
-
-func (t *_Lexer) Next() {
- i, s := t.i, t.s
- i = skipwhite(s, i)
- if i >= len(s) {
- t.kind = 0
- t.token = ""
- t.i = len(s)
- return
- }
-
- c := s[i]
- switch {
- case c == '-' || '0' <= c && c <= '9':
- j := skiptoken(s, i)
- t.kind = '1'
- t.token = s[i:j]
- i = j
-
- case 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z':
- j := skiptoken(s, i)
- t.kind = 'a'
- t.token = s[i:j]
- i = j
-
- case c == '"':
- j := skipstring(s, i)
- t.kind = '"'
- t.token = s[i:j]
- i = j
-
- case c == '[', c == ']', c == ':', c == '{', c == '}', c == ',':
- t.kind = int(c)
- t.token = s[i : i+1]
- i++
-
- default:
- t.kind = '?'
- t.token = s[i : i+1]
- }
-
- t.i = i
-}
-
-
-// Parser
-//
-// Implements parsing but not the actions. Those are
-// carried out by the implementation of the Builder interface.
-// A Builder represents the object being created.
-// Calling a method like Int64(i) sets that object to i.
-// Calling a method like Elem(i) or Key(s) creates a
-// new builder for a subpiece of the object (logically,
-// an array element or a map key).
-//
-// There are two Builders, in other files.
-// The JsonBuilder builds a generic Json structure
-// in which maps are maps.
-// The StructBuilder copies data into a possibly
-// nested data structure, using the "map keys"
-// as struct field names.
-
-type _Value interface{}
-
-// BUG(rsc): The json Builder interface needs to be
-// reconciled with the xml Builder interface.
-
-// A Builder is an interface implemented by clients and passed
-// to the JSON parser. It gives clients full control over the
-// eventual representation returned by the parser.
-type Builder interface {
- // Set value
- Int64(i int64)
- Uint64(i uint64)
- Float64(f float64)
- String(s string)
- Bool(b bool)
- Null()
- Array()
- Map()
-
- // Create sub-Builders
- Elem(i int) Builder
- Key(s string) Builder
-
- // Flush changes to parent Builder if necessary.
- Flush()
-}
-
-func parse(lex *_Lexer, build Builder) bool {
- ok := false
-Switch:
- switch lex.kind {
- case 0:
- break
- case '1':
- // If the number is exactly an integer, use that.
- if i, err := strconv.Atoi64(lex.token); err == nil {
- build.Int64(i)
- ok = true
- } else if i, err := strconv.Atoui64(lex.token); err == nil {
- build.Uint64(i)
- ok = true
- } else
- // Fall back to floating point.
- if f, err := strconv.Atof64(lex.token); err == nil {
- build.Float64(f)
- ok = true
- }
-
- case 'a':
- switch lex.token {
- case "true":
- build.Bool(true)
- ok = true
- case "false":
- build.Bool(false)
- ok = true
- case "null":
- build.Null()
- ok = true
- }
-
- case '"':
- if str, ok1 := Unquote(lex.token); ok1 {
- build.String(str)
- ok = true
- }
-
- case '[':
- // array
- build.Array()
- lex.Next()
- n := 0
- for lex.kind != ']' {
- if n > 0 {
- if lex.kind != ',' {
- break Switch
- }
- lex.Next()
- }
- if !parse(lex, build.Elem(n)) {
- break Switch
- }
- n++
- }
- ok = true
-
- case '{':
- // map
- lex.Next()
- build.Map()
- n := 0
- for lex.kind != '}' {
- if n > 0 {
- if lex.kind != ',' {
- break Switch
- }
- lex.Next()
- }
- if lex.kind != '"' {
- break Switch
- }
- key, ok := Unquote(lex.token)
- if !ok {
- break Switch
- }
- lex.Next()
- if lex.kind != ':' {
- break Switch
- }
- lex.Next()
- if !parse(lex, build.Key(key)) {
- break Switch
- }
- n++
- }
- ok = true
- }
-
- if ok {
- lex.Next()
- }
- build.Flush()
- return ok
-}
-
-// Parse parses the JSON syntax string s and makes calls to
-// the builder to construct a parsed representation.
-// On success, it returns with ok set to true.
-// On error, it returns with ok set to false, errindx set
-// to the byte index in s where a syntax error occurred,
-// and errtok set to the offending token.
-func Parse(s string, builder Builder) (ok bool, errindx int, errtok string) {
- lex := new(_Lexer)
- lex.s = s
- lex.Next()
- if parse(lex, builder) {
- if lex.kind == 0 { // EOF
- return true, 0, ""
- }
- }
- return false, lex.i, lex.token
-}