src/pkg/json/parse.go - go - Git at Google

 // 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
 }
	// 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
	}