[dev.power64] code review 152570049: all: merge default into dev.power64

src/encoding/json/decode.go

 // Copyright 2010 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.
 
 // Represents JSON data structure using native Go types: booleans, floats,
 // strings, arrays, and maps.
 
 package json
 
 import (
@@ skipping 155 matching lines @@
         return strconv.ParseInt(string(n), 10, 64)
 }
 
 // decodeState represents the state while decoding a JSON value.
 type decodeState struct {
         data       []byte
         off        int // read offset in data
         scan       scanner
         nextscan   scanner // for calls to nextValue
         savedError error
-        tempstr    string // scratch space to avoid some allocations
         useNumber  bool
 }
 
 // errPhase is used for errors that should not happen unless
 // there is a bug in the JSON decoder or something is editing
 // the data slice while the decoder executes.
 var errPhase = errors.New("JSON decoder out of sync - data changing underfoot?")
 
 func (d *decodeState) init(data []byte) *decodeState {
         d.data = data
@@ skipping 99 matching lines @@
                 d.array(v)
 
         case scanBeginObject:
                 d.object(v)
 
         case scanBeginLiteral:
                 d.literal(v)
         }
 }
 
+type unquotedValue struct{}
+
+// valueQuoted is like value but decodes a
+// quoted string literal or literal null into an interface value.
+// If it finds anything other than a quoted string literal or null,
+// valueQuoted returns unquotedValue{}.
+func (d *decodeState) valueQuoted() interface{} {
+        switch op := d.scanWhile(scanSkipSpace); op {
+        default:
+                d.error(errPhase)
+
+        case scanBeginArray:
+                d.array(reflect.Value{})
+
+        case scanBeginObject:
+                d.object(reflect.Value{})
+
+        case scanBeginLiteral:
+                switch v := d.literalInterface().(type) {
+                case nil, string:
+                        return v
+                }
+        }
+        return unquotedValue{}
+}
+
 // indirect walks down v allocating pointers as needed,
 // until it gets to a non-pointer.
 // if it encounters an Unmarshaler, indirect stops and returns that.
 // if decodingNull is true, indirect stops at the last pointer so it can be set to nil.
 func (d *decodeState) indirect(v reflect.Value, decodingNull bool) (Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
         // If v is a named type and is addressable,
         // start with its address, so that if the type has pointer methods,
         // we find them.
         if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() {
                 v = v.Addr()
@@ skipping 131 matching lines @@
                         }
                 } else {
                         v.SetLen(i)
                 }
         }
         if i == 0 && v.Kind() == reflect.Slice {
                 v.Set(reflect.MakeSlice(v.Type(), 0, 0))
         }
 }
 
+var nullLiteral = []byte("null")
+
 // object consumes an object from d.data[d.off-1:], decoding into the value v.
-// the first byte of the object ('{') has been read already.
+// the first byte ('{') of the object has been read already.
 func (d *decodeState) object(v reflect.Value) {
         // Check for unmarshaler.
         u, ut, pv := d.indirect(v, false)
         if u != nil {
                 d.off--
                 err := u.UnmarshalJSON(d.next())
                 if err != nil {
                         d.error(err)
                 }
                 return
@@ skipping 12 matching lines @@
                 return
         }
 
         // Check type of target: struct or map[string]T
         switch v.Kind() {
         case reflect.Map:
                 // map must have string kind
                 t := v.Type()
                 if t.Key().Kind() != reflect.String {
                         d.saveError(&UnmarshalTypeError{"object", v.Type()})
-                        break
+                        d.off--
+                        d.next() // skip over { } in input
+                        return
                 }
                 if v.IsNil() {
                         v.Set(reflect.MakeMap(t))
                 }
         case reflect.Struct:
 
         default:
                 d.saveError(&UnmarshalTypeError{"object", v.Type()})
                 d.off--
                 d.next() // skip over { } in input
@@ skipping 65 matching lines @@
                 // Read : before value.
                 if op == scanSkipSpace {
                         op = d.scanWhile(scanSkipSpace)
                 }
                 if op != scanObjectKey {
                         d.error(errPhase)
                 }
 
                 // Read value.
                 if destring {
-                        d.value(reflect.ValueOf(&d.tempstr))
-                        d.literalStore([]byte(d.tempstr), subv, true)
-                        d.tempstr = "" // Zero scratch space for successive values.
+                        switch qv := d.valueQuoted().(type) {
+                        case nil:
+                                d.literalStore(nullLiteral, subv, false)
+                        case string:
+                                d.literalStore([]byte(qv), subv, true)
+                        default:
+                                d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into %v", item, v.Type()))
+                        }
                 } else {
                         d.value(subv)
                 }
 
                 // Write value back to map;
                 // if using struct, subv points into struct already.
                 if v.Kind() == reflect.Map {
                         kv := reflect.ValueOf(key).Convert(v.Type().Key())
                         v.SetMapIndex(kv, subv)
                 }
@@ skipping 461 matching lines @@
 
                 // Coerce to well-formed UTF-8.
                 default:
                         rr, size := utf8.DecodeRune(s[r:])
                         r += size
                         w += utf8.EncodeRune(b[w:], rr)
                 }
         }
         return b[0:w], true
 }