code review 5694044: encoding/xml: handle anonymous pointer fields

src/pkg/encoding/xml/read.go

 // 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.
 
 package xml
 
 import (
         "bytes"
         "errors"
         "reflect"
@@ skipping 230 matching lines @@
                         }
                         if finfo.xmlns != "" && finfo.xmlns != start.Name.Space {
                                 e := "expected element <" + finfo.name + "> in name space " + finfo.xmlns + " but have "
                                 if start.Name.Space == "" {
                                         e += "no name space"
                                 } else {
                                         e += start.Name.Space
                                 }
                                 return UnmarshalError(e)
                         }
-                        fv := finfo.Value(sv)
+                        fv := finfo.value(sv)
                         if _, ok := fv.Interface().(Name); ok {
                                 fv.Set(reflect.ValueOf(start.Name))
                         }
                 }
 
                 // Assign attributes.
                 // Also, determine whether we need to save character data or comments.
                 for i := range tinfo.fields {
                         finfo := &tinfo.fields[i]
                         switch finfo.flags & fMode {
                         case fAttr:
-                                strv := finfo.Value(sv)
+                                strv := finfo.value(sv)
                                 // Look for attribute.
                                 for _, a := range start.Attr {
                                         if a.Name.Local == finfo.name {
                                                 copyValue(strv, []byte(a.Value))
                                                 break
                                         }
                                 }
 
                         case fCharData:
                                 if !saveData.IsValid() {
-                                        saveData = finfo.Value(sv)
+                                        saveData = finfo.value(sv)
                                 }
 
                         case fComment:
                                 if !saveComment.IsValid() {
-                                        saveComment = finfo.Value(sv)
+                                        saveComment = finfo.value(sv)
                                 }
 
                         case fAny:
                                 if !saveAny.IsValid() {
-                                        saveAny = finfo.Value(sv)
+                                        saveAny = finfo.value(sv)
                                 }
 
                         case fInnerXml:
                                 if !saveXML.IsValid() {
-                                        saveXML = finfo.Value(sv)
+                                        saveXML = finfo.value(sv)
                                         if p.saved == nil {
                                                 saveXMLIndex = 0
                                                 p.saved = new(bytes.Buffer)
                                         } else {
                                                 saveXMLIndex = p.savedOffset()
                                         }
                                 }
                         }
                 }
         }
@@ skipping 154 matching lines @@
                 if finfo.flags&fElement == 0 || len(finfo.parents) < len(parents) {
                         continue
                 }
                 for j := range parents {
                         if parents[j] != finfo.parents[j] {
                                 continue Loop
                         }
                 }
                 if len(finfo.parents) == len(parents) && finfo.name == start.Name.Local {
                         // It's a perfect match, unmarshal the field.
-                        return true, p.unmarshal(finfo.Value(sv), start)
+                        return true, p.unmarshal(finfo.value(sv), start)
                 }
                 if len(finfo.parents) > len(parents) && finfo.parents[len(parents)] == start.Name.Local {
                         // It's a prefix for the field. Break and recurse
                         // since it's not ok for one field path to be itself
                         // the prefix for another field path.
                         recurse = true
 
                         // We can reuse the same slice as long as we
                         // don't try to append to it.
                         parents = finfo.parents[:len(parents)+1]
@@ skipping 47 matching lines @@
                 case StartElement:
                         if err := d.Skip(); err != nil {
                                 return err
                         }
                 case EndElement:
                         return nil
                 }
         }
         panic("unreachable")
 }