Source file src/encoding/xml/read.go

Documentation: encoding/xml

		 1  // Copyright 2009 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package xml
		 6  
		 7  import (
		 8  	"bytes"
		 9  	"encoding"
		10  	"errors"
		11  	"fmt"
		12  	"reflect"
		13  	"strconv"
		14  	"strings"
		15  )
		16  
		17  // BUG(rsc): Mapping between XML elements and data structures is inherently flawed:
		18  // an XML element is an order-dependent collection of anonymous
		19  // values, while a data structure is an order-independent collection
		20  // of named values.
		21  // See package json for a textual representation more suitable
		22  // to data structures.
		23  
		24  // Unmarshal parses the XML-encoded data and stores the result in
		25  // the value pointed to by v, which must be an arbitrary struct,
		26  // slice, or string. Well-formed data that does not fit into v is
		27  // discarded.
		28  //
		29  // Because Unmarshal uses the reflect package, it can only assign
		30  // to exported (upper case) fields. Unmarshal uses a case-sensitive
		31  // comparison to match XML element names to tag values and struct
		32  // field names.
		33  //
		34  // Unmarshal maps an XML element to a struct using the following rules.
		35  // In the rules, the tag of a field refers to the value associated with the
		36  // key 'xml' in the struct field's tag (see the example above).
		37  //
		38  //	 * If the struct has a field of type []byte or string with tag
		39  //			",innerxml", Unmarshal accumulates the raw XML nested inside the
		40  //			element in that field. The rest of the rules still apply.
		41  //
		42  //	 * If the struct has a field named XMLName of type Name,
		43  //			Unmarshal records the element name in that field.
		44  //
		45  //	 * If the XMLName field has an associated tag of the form
		46  //			"name" or "namespace-URL name", the XML element must have
		47  //			the given name (and, optionally, name space) or else Unmarshal
		48  //			returns an error.
		49  //
		50  //	 * If the XML element has an attribute whose name matches a
		51  //			struct field name with an associated tag containing ",attr" or
		52  //			the explicit name in a struct field tag of the form "name,attr",
		53  //			Unmarshal records the attribute value in that field.
		54  //
		55  //	 * If the XML element has an attribute not handled by the previous
		56  //			rule and the struct has a field with an associated tag containing
		57  //			",any,attr", Unmarshal records the attribute value in the first
		58  //			such field.
		59  //
		60  //	 * If the XML element contains character data, that data is
		61  //			accumulated in the first struct field that has tag ",chardata".
		62  //			The struct field may have type []byte or string.
		63  //			If there is no such field, the character data is discarded.
		64  //
		65  //	 * If the XML element contains comments, they are accumulated in
		66  //			the first struct field that has tag ",comment".	The struct
		67  //			field may have type []byte or string. If there is no such
		68  //			field, the comments are discarded.
		69  //
		70  //	 * If the XML element contains a sub-element whose name matches
		71  //			the prefix of a tag formatted as "a" or "a>b>c", unmarshal
		72  //			will descend into the XML structure looking for elements with the
		73  //			given names, and will map the innermost elements to that struct
		74  //			field. A tag starting with ">" is equivalent to one starting
		75  //			with the field name followed by ">".
		76  //
		77  //	 * If the XML element contains a sub-element whose name matches
		78  //			a struct field's XMLName tag and the struct field has no
		79  //			explicit name tag as per the previous rule, unmarshal maps
		80  //			the sub-element to that struct field.
		81  //
		82  //	 * If the XML element contains a sub-element whose name matches a
		83  //			field without any mode flags (",attr", ",chardata", etc), Unmarshal
		84  //			maps the sub-element to that struct field.
		85  //
		86  //	 * If the XML element contains a sub-element that hasn't matched any
		87  //			of the above rules and the struct has a field with tag ",any",
		88  //			unmarshal maps the sub-element to that struct field.
		89  //
		90  //	 * An anonymous struct field is handled as if the fields of its
		91  //			value were part of the outer struct.
		92  //
		93  //	 * A struct field with tag "-" is never unmarshaled into.
		94  //
		95  // If Unmarshal encounters a field type that implements the Unmarshaler
		96  // interface, Unmarshal calls its UnmarshalXML method to produce the value from
		97  // the XML element.	Otherwise, if the value implements
		98  // encoding.TextUnmarshaler, Unmarshal calls that value's UnmarshalText method.
		99  //
	 100  // Unmarshal maps an XML element to a string or []byte by saving the
	 101  // concatenation of that element's character data in the string or
	 102  // []byte. The saved []byte is never nil.
	 103  //
	 104  // Unmarshal maps an attribute value to a string or []byte by saving
	 105  // the value in the string or slice.
	 106  //
	 107  // Unmarshal maps an attribute value to an Attr by saving the attribute,
	 108  // including its name, in the Attr.
	 109  //
	 110  // Unmarshal maps an XML element or attribute value to a slice by
	 111  // extending the length of the slice and mapping the element or attribute
	 112  // to the newly created value.
	 113  //
	 114  // Unmarshal maps an XML element or attribute value to a bool by
	 115  // setting it to the boolean value represented by the string. Whitespace
	 116  // is trimmed and ignored.
	 117  //
	 118  // Unmarshal maps an XML element or attribute value to an integer or
	 119  // floating-point field by setting the field to the result of
	 120  // interpreting the string value in decimal. There is no check for
	 121  // overflow. Whitespace is trimmed and ignored.
	 122  //
	 123  // Unmarshal maps an XML element to a Name by recording the element
	 124  // name.
	 125  //
	 126  // Unmarshal maps an XML element to a pointer by setting the pointer
	 127  // to a freshly allocated value and then mapping the element to that value.
	 128  //
	 129  // A missing element or empty attribute value will be unmarshaled as a zero value.
	 130  // If the field is a slice, a zero value will be appended to the field. Otherwise, the
	 131  // field will be set to its zero value.
	 132  func Unmarshal(data []byte, v interface{}) error {
	 133  	return NewDecoder(bytes.NewReader(data)).Decode(v)
	 134  }
	 135  
	 136  // Decode works like Unmarshal, except it reads the decoder
	 137  // stream to find the start element.
	 138  func (d *Decoder) Decode(v interface{}) error {
	 139  	return d.DecodeElement(v, nil)
	 140  }
	 141  
	 142  // DecodeElement works like Unmarshal except that it takes
	 143  // a pointer to the start XML element to decode into v.
	 144  // It is useful when a client reads some raw XML tokens itself
	 145  // but also wants to defer to Unmarshal for some elements.
	 146  func (d *Decoder) DecodeElement(v interface{}, start *StartElement) error {
	 147  	val := reflect.ValueOf(v)
	 148  	if val.Kind() != reflect.Ptr {
	 149  		return errors.New("non-pointer passed to Unmarshal")
	 150  	}
	 151  	return d.unmarshal(val.Elem(), start, 0)
	 152  }
	 153  
	 154  // An UnmarshalError represents an error in the unmarshaling process.
	 155  type UnmarshalError string
	 156  
	 157  func (e UnmarshalError) Error() string { return string(e) }
	 158  
	 159  // Unmarshaler is the interface implemented by objects that can unmarshal
	 160  // an XML element description of themselves.
	 161  //
	 162  // UnmarshalXML decodes a single XML element
	 163  // beginning with the given start element.
	 164  // If it returns an error, the outer call to Unmarshal stops and
	 165  // returns that error.
	 166  // UnmarshalXML must consume exactly one XML element.
	 167  // One common implementation strategy is to unmarshal into
	 168  // a separate value with a layout matching the expected XML
	 169  // using d.DecodeElement, and then to copy the data from
	 170  // that value into the receiver.
	 171  // Another common strategy is to use d.Token to process the
	 172  // XML object one token at a time.
	 173  // UnmarshalXML may not use d.RawToken.
	 174  type Unmarshaler interface {
	 175  	UnmarshalXML(d *Decoder, start StartElement) error
	 176  }
	 177  
	 178  // UnmarshalerAttr is the interface implemented by objects that can unmarshal
	 179  // an XML attribute description of themselves.
	 180  //
	 181  // UnmarshalXMLAttr decodes a single XML attribute.
	 182  // If it returns an error, the outer call to Unmarshal stops and
	 183  // returns that error.
	 184  // UnmarshalXMLAttr is used only for struct fields with the
	 185  // "attr" option in the field tag.
	 186  type UnmarshalerAttr interface {
	 187  	UnmarshalXMLAttr(attr Attr) error
	 188  }
	 189  
	 190  // receiverType returns the receiver type to use in an expression like "%s.MethodName".
	 191  func receiverType(val interface{}) string {
	 192  	t := reflect.TypeOf(val)
	 193  	if t.Name() != "" {
	 194  		return t.String()
	 195  	}
	 196  	return "(" + t.String() + ")"
	 197  }
	 198  
	 199  // unmarshalInterface unmarshals a single XML element into val.
	 200  // start is the opening tag of the element.
	 201  func (d *Decoder) unmarshalInterface(val Unmarshaler, start *StartElement) error {
	 202  	// Record that decoder must stop at end tag corresponding to start.
	 203  	d.pushEOF()
	 204  
	 205  	d.unmarshalDepth++
	 206  	err := val.UnmarshalXML(d, *start)
	 207  	d.unmarshalDepth--
	 208  	if err != nil {
	 209  		d.popEOF()
	 210  		return err
	 211  	}
	 212  
	 213  	if !d.popEOF() {
	 214  		return fmt.Errorf("xml: %s.UnmarshalXML did not consume entire <%s> element", receiverType(val), start.Name.Local)
	 215  	}
	 216  
	 217  	return nil
	 218  }
	 219  
	 220  // unmarshalTextInterface unmarshals a single XML element into val.
	 221  // The chardata contained in the element (but not its children)
	 222  // is passed to the text unmarshaler.
	 223  func (d *Decoder) unmarshalTextInterface(val encoding.TextUnmarshaler) error {
	 224  	var buf []byte
	 225  	depth := 1
	 226  	for depth > 0 {
	 227  		t, err := d.Token()
	 228  		if err != nil {
	 229  			return err
	 230  		}
	 231  		switch t := t.(type) {
	 232  		case CharData:
	 233  			if depth == 1 {
	 234  				buf = append(buf, t...)
	 235  			}
	 236  		case StartElement:
	 237  			depth++
	 238  		case EndElement:
	 239  			depth--
	 240  		}
	 241  	}
	 242  	return val.UnmarshalText(buf)
	 243  }
	 244  
	 245  // unmarshalAttr unmarshals a single XML attribute into val.
	 246  func (d *Decoder) unmarshalAttr(val reflect.Value, attr Attr) error {
	 247  	if val.Kind() == reflect.Ptr {
	 248  		if val.IsNil() {
	 249  			val.Set(reflect.New(val.Type().Elem()))
	 250  		}
	 251  		val = val.Elem()
	 252  	}
	 253  	if val.CanInterface() && val.Type().Implements(unmarshalerAttrType) {
	 254  		// This is an unmarshaler with a non-pointer receiver,
	 255  		// so it's likely to be incorrect, but we do what we're told.
	 256  		return val.Interface().(UnmarshalerAttr).UnmarshalXMLAttr(attr)
	 257  	}
	 258  	if val.CanAddr() {
	 259  		pv := val.Addr()
	 260  		if pv.CanInterface() && pv.Type().Implements(unmarshalerAttrType) {
	 261  			return pv.Interface().(UnmarshalerAttr).UnmarshalXMLAttr(attr)
	 262  		}
	 263  	}
	 264  
	 265  	// Not an UnmarshalerAttr; try encoding.TextUnmarshaler.
	 266  	if val.CanInterface() && val.Type().Implements(textUnmarshalerType) {
	 267  		// This is an unmarshaler with a non-pointer receiver,
	 268  		// so it's likely to be incorrect, but we do what we're told.
	 269  		return val.Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(attr.Value))
	 270  	}
	 271  	if val.CanAddr() {
	 272  		pv := val.Addr()
	 273  		if pv.CanInterface() && pv.Type().Implements(textUnmarshalerType) {
	 274  			return pv.Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(attr.Value))
	 275  		}
	 276  	}
	 277  
	 278  	if val.Type().Kind() == reflect.Slice && val.Type().Elem().Kind() != reflect.Uint8 {
	 279  		// Slice of element values.
	 280  		// Grow slice.
	 281  		n := val.Len()
	 282  		val.Set(reflect.Append(val, reflect.Zero(val.Type().Elem())))
	 283  
	 284  		// Recur to read element into slice.
	 285  		if err := d.unmarshalAttr(val.Index(n), attr); err != nil {
	 286  			val.SetLen(n)
	 287  			return err
	 288  		}
	 289  		return nil
	 290  	}
	 291  
	 292  	if val.Type() == attrType {
	 293  		val.Set(reflect.ValueOf(attr))
	 294  		return nil
	 295  	}
	 296  
	 297  	return copyValue(val, []byte(attr.Value))
	 298  }
	 299  
	 300  var (
	 301  	attrType						= reflect.TypeOf(Attr{})
	 302  	unmarshalerType		 = reflect.TypeOf((*Unmarshaler)(nil)).Elem()
	 303  	unmarshalerAttrType = reflect.TypeOf((*UnmarshalerAttr)(nil)).Elem()
	 304  	textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
	 305  )
	 306  
	 307  const maxUnmarshalDepth = 10000
	 308  
	 309  var errExeceededMaxUnmarshalDepth = errors.New("exceeded max depth")
	 310  
	 311  // Unmarshal a single XML element into val.
	 312  func (d *Decoder) unmarshal(val reflect.Value, start *StartElement, depth int) error {
	 313  	if depth >= maxUnmarshalDepth {
	 314  		return errExeceededMaxUnmarshalDepth
	 315  	}
	 316  	// Find start element if we need it.
	 317  	if start == nil {
	 318  		for {
	 319  			tok, err := d.Token()
	 320  			if err != nil {
	 321  				return err
	 322  			}
	 323  			if t, ok := tok.(StartElement); ok {
	 324  				start = &t
	 325  				break
	 326  			}
	 327  		}
	 328  	}
	 329  
	 330  	// Load value from interface, but only if the result will be
	 331  	// usefully addressable.
	 332  	if val.Kind() == reflect.Interface && !val.IsNil() {
	 333  		e := val.Elem()
	 334  		if e.Kind() == reflect.Ptr && !e.IsNil() {
	 335  			val = e
	 336  		}
	 337  	}
	 338  
	 339  	if val.Kind() == reflect.Ptr {
	 340  		if val.IsNil() {
	 341  			val.Set(reflect.New(val.Type().Elem()))
	 342  		}
	 343  		val = val.Elem()
	 344  	}
	 345  
	 346  	if val.CanInterface() && val.Type().Implements(unmarshalerType) {
	 347  		// This is an unmarshaler with a non-pointer receiver,
	 348  		// so it's likely to be incorrect, but we do what we're told.
	 349  		return d.unmarshalInterface(val.Interface().(Unmarshaler), start)
	 350  	}
	 351  
	 352  	if val.CanAddr() {
	 353  		pv := val.Addr()
	 354  		if pv.CanInterface() && pv.Type().Implements(unmarshalerType) {
	 355  			return d.unmarshalInterface(pv.Interface().(Unmarshaler), start)
	 356  		}
	 357  	}
	 358  
	 359  	if val.CanInterface() && val.Type().Implements(textUnmarshalerType) {
	 360  		return d.unmarshalTextInterface(val.Interface().(encoding.TextUnmarshaler))
	 361  	}
	 362  
	 363  	if val.CanAddr() {
	 364  		pv := val.Addr()
	 365  		if pv.CanInterface() && pv.Type().Implements(textUnmarshalerType) {
	 366  			return d.unmarshalTextInterface(pv.Interface().(encoding.TextUnmarshaler))
	 367  		}
	 368  	}
	 369  
	 370  	var (
	 371  		data				 []byte
	 372  		saveData		 reflect.Value
	 373  		comment			[]byte
	 374  		saveComment	reflect.Value
	 375  		saveXML			reflect.Value
	 376  		saveXMLIndex int
	 377  		saveXMLData	[]byte
	 378  		saveAny			reflect.Value
	 379  		sv					 reflect.Value
	 380  		tinfo				*typeInfo
	 381  		err					error
	 382  	)
	 383  
	 384  	switch v := val; v.Kind() {
	 385  	default:
	 386  		return errors.New("unknown type " + v.Type().String())
	 387  
	 388  	case reflect.Interface:
	 389  		// TODO: For now, simply ignore the field. In the near
	 390  		//			 future we may choose to unmarshal the start
	 391  		//			 element on it, if not nil.
	 392  		return d.Skip()
	 393  
	 394  	case reflect.Slice:
	 395  		typ := v.Type()
	 396  		if typ.Elem().Kind() == reflect.Uint8 {
	 397  			// []byte
	 398  			saveData = v
	 399  			break
	 400  		}
	 401  
	 402  		// Slice of element values.
	 403  		// Grow slice.
	 404  		n := v.Len()
	 405  		v.Set(reflect.Append(val, reflect.Zero(v.Type().Elem())))
	 406  
	 407  		// Recur to read element into slice.
	 408  		if err := d.unmarshal(v.Index(n), start, depth+1); err != nil {
	 409  			v.SetLen(n)
	 410  			return err
	 411  		}
	 412  		return nil
	 413  
	 414  	case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, reflect.String:
	 415  		saveData = v
	 416  
	 417  	case reflect.Struct:
	 418  		typ := v.Type()
	 419  		if typ == nameType {
	 420  			v.Set(reflect.ValueOf(start.Name))
	 421  			break
	 422  		}
	 423  
	 424  		sv = v
	 425  		tinfo, err = getTypeInfo(typ)
	 426  		if err != nil {
	 427  			return err
	 428  		}
	 429  
	 430  		// Validate and assign element name.
	 431  		if tinfo.xmlname != nil {
	 432  			finfo := tinfo.xmlname
	 433  			if finfo.name != "" && finfo.name != start.Name.Local {
	 434  				return UnmarshalError("expected element type <" + finfo.name + "> but have <" + start.Name.Local + ">")
	 435  			}
	 436  			if finfo.xmlns != "" && finfo.xmlns != start.Name.Space {
	 437  				e := "expected element <" + finfo.name + "> in name space " + finfo.xmlns + " but have "
	 438  				if start.Name.Space == "" {
	 439  					e += "no name space"
	 440  				} else {
	 441  					e += start.Name.Space
	 442  				}
	 443  				return UnmarshalError(e)
	 444  			}
	 445  			fv := finfo.value(sv, initNilPointers)
	 446  			if _, ok := fv.Interface().(Name); ok {
	 447  				fv.Set(reflect.ValueOf(start.Name))
	 448  			}
	 449  		}
	 450  
	 451  		// Assign attributes.
	 452  		for _, a := range start.Attr {
	 453  			handled := false
	 454  			any := -1
	 455  			for i := range tinfo.fields {
	 456  				finfo := &tinfo.fields[i]
	 457  				switch finfo.flags & fMode {
	 458  				case fAttr:
	 459  					strv := finfo.value(sv, initNilPointers)
	 460  					if a.Name.Local == finfo.name && (finfo.xmlns == "" || finfo.xmlns == a.Name.Space) {
	 461  						if err := d.unmarshalAttr(strv, a); err != nil {
	 462  							return err
	 463  						}
	 464  						handled = true
	 465  					}
	 466  
	 467  				case fAny | fAttr:
	 468  					if any == -1 {
	 469  						any = i
	 470  					}
	 471  				}
	 472  			}
	 473  			if !handled && any >= 0 {
	 474  				finfo := &tinfo.fields[any]
	 475  				strv := finfo.value(sv, initNilPointers)
	 476  				if err := d.unmarshalAttr(strv, a); err != nil {
	 477  					return err
	 478  				}
	 479  			}
	 480  		}
	 481  
	 482  		// Determine whether we need to save character data or comments.
	 483  		for i := range tinfo.fields {
	 484  			finfo := &tinfo.fields[i]
	 485  			switch finfo.flags & fMode {
	 486  			case fCDATA, fCharData:
	 487  				if !saveData.IsValid() {
	 488  					saveData = finfo.value(sv, initNilPointers)
	 489  				}
	 490  
	 491  			case fComment:
	 492  				if !saveComment.IsValid() {
	 493  					saveComment = finfo.value(sv, initNilPointers)
	 494  				}
	 495  
	 496  			case fAny, fAny | fElement:
	 497  				if !saveAny.IsValid() {
	 498  					saveAny = finfo.value(sv, initNilPointers)
	 499  				}
	 500  
	 501  			case fInnerXML:
	 502  				if !saveXML.IsValid() {
	 503  					saveXML = finfo.value(sv, initNilPointers)
	 504  					if d.saved == nil {
	 505  						saveXMLIndex = 0
	 506  						d.saved = new(bytes.Buffer)
	 507  					} else {
	 508  						saveXMLIndex = d.savedOffset()
	 509  					}
	 510  				}
	 511  			}
	 512  		}
	 513  	}
	 514  
	 515  	// Find end element.
	 516  	// Process sub-elements along the way.
	 517  Loop:
	 518  	for {
	 519  		var savedOffset int
	 520  		if saveXML.IsValid() {
	 521  			savedOffset = d.savedOffset()
	 522  		}
	 523  		tok, err := d.Token()
	 524  		if err != nil {
	 525  			return err
	 526  		}
	 527  		switch t := tok.(type) {
	 528  		case StartElement:
	 529  			consumed := false
	 530  			if sv.IsValid() {
	 531  				// unmarshalPath can call unmarshal, so we need to pass the depth through so that
	 532  				// we can continue to enforce the maximum recusion limit.
	 533  				consumed, err = d.unmarshalPath(tinfo, sv, nil, &t, depth)
	 534  				if err != nil {
	 535  					return err
	 536  				}
	 537  				if !consumed && saveAny.IsValid() {
	 538  					consumed = true
	 539  					if err := d.unmarshal(saveAny, &t, depth+1); err != nil {
	 540  						return err
	 541  					}
	 542  				}
	 543  			}
	 544  			if !consumed {
	 545  				if err := d.Skip(); err != nil {
	 546  					return err
	 547  				}
	 548  			}
	 549  
	 550  		case EndElement:
	 551  			if saveXML.IsValid() {
	 552  				saveXMLData = d.saved.Bytes()[saveXMLIndex:savedOffset]
	 553  				if saveXMLIndex == 0 {
	 554  					d.saved = nil
	 555  				}
	 556  			}
	 557  			break Loop
	 558  
	 559  		case CharData:
	 560  			if saveData.IsValid() {
	 561  				data = append(data, t...)
	 562  			}
	 563  
	 564  		case Comment:
	 565  			if saveComment.IsValid() {
	 566  				comment = append(comment, t...)
	 567  			}
	 568  		}
	 569  	}
	 570  
	 571  	if saveData.IsValid() && saveData.CanInterface() && saveData.Type().Implements(textUnmarshalerType) {
	 572  		if err := saveData.Interface().(encoding.TextUnmarshaler).UnmarshalText(data); err != nil {
	 573  			return err
	 574  		}
	 575  		saveData = reflect.Value{}
	 576  	}
	 577  
	 578  	if saveData.IsValid() && saveData.CanAddr() {
	 579  		pv := saveData.Addr()
	 580  		if pv.CanInterface() && pv.Type().Implements(textUnmarshalerType) {
	 581  			if err := pv.Interface().(encoding.TextUnmarshaler).UnmarshalText(data); err != nil {
	 582  				return err
	 583  			}
	 584  			saveData = reflect.Value{}
	 585  		}
	 586  	}
	 587  
	 588  	if err := copyValue(saveData, data); err != nil {
	 589  		return err
	 590  	}
	 591  
	 592  	switch t := saveComment; t.Kind() {
	 593  	case reflect.String:
	 594  		t.SetString(string(comment))
	 595  	case reflect.Slice:
	 596  		t.Set(reflect.ValueOf(comment))
	 597  	}
	 598  
	 599  	switch t := saveXML; t.Kind() {
	 600  	case reflect.String:
	 601  		t.SetString(string(saveXMLData))
	 602  	case reflect.Slice:
	 603  		if t.Type().Elem().Kind() == reflect.Uint8 {
	 604  			t.Set(reflect.ValueOf(saveXMLData))
	 605  		}
	 606  	}
	 607  
	 608  	return nil
	 609  }
	 610  
	 611  func copyValue(dst reflect.Value, src []byte) (err error) {
	 612  	dst0 := dst
	 613  
	 614  	if dst.Kind() == reflect.Ptr {
	 615  		if dst.IsNil() {
	 616  			dst.Set(reflect.New(dst.Type().Elem()))
	 617  		}
	 618  		dst = dst.Elem()
	 619  	}
	 620  
	 621  	// Save accumulated data.
	 622  	switch dst.Kind() {
	 623  	case reflect.Invalid:
	 624  		// Probably a comment.
	 625  	default:
	 626  		return errors.New("cannot unmarshal into " + dst0.Type().String())
	 627  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
	 628  		if len(src) == 0 {
	 629  			dst.SetInt(0)
	 630  			return nil
	 631  		}
	 632  		itmp, err := strconv.ParseInt(strings.TrimSpace(string(src)), 10, dst.Type().Bits())
	 633  		if err != nil {
	 634  			return err
	 635  		}
	 636  		dst.SetInt(itmp)
	 637  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
	 638  		if len(src) == 0 {
	 639  			dst.SetUint(0)
	 640  			return nil
	 641  		}
	 642  		utmp, err := strconv.ParseUint(strings.TrimSpace(string(src)), 10, dst.Type().Bits())
	 643  		if err != nil {
	 644  			return err
	 645  		}
	 646  		dst.SetUint(utmp)
	 647  	case reflect.Float32, reflect.Float64:
	 648  		if len(src) == 0 {
	 649  			dst.SetFloat(0)
	 650  			return nil
	 651  		}
	 652  		ftmp, err := strconv.ParseFloat(strings.TrimSpace(string(src)), dst.Type().Bits())
	 653  		if err != nil {
	 654  			return err
	 655  		}
	 656  		dst.SetFloat(ftmp)
	 657  	case reflect.Bool:
	 658  		if len(src) == 0 {
	 659  			dst.SetBool(false)
	 660  			return nil
	 661  		}
	 662  		value, err := strconv.ParseBool(strings.TrimSpace(string(src)))
	 663  		if err != nil {
	 664  			return err
	 665  		}
	 666  		dst.SetBool(value)
	 667  	case reflect.String:
	 668  		dst.SetString(string(src))
	 669  	case reflect.Slice:
	 670  		if len(src) == 0 {
	 671  			// non-nil to flag presence
	 672  			src = []byte{}
	 673  		}
	 674  		dst.SetBytes(src)
	 675  	}
	 676  	return nil
	 677  }
	 678  
	 679  // unmarshalPath walks down an XML structure looking for wanted
	 680  // paths, and calls unmarshal on them.
	 681  // The consumed result tells whether XML elements have been consumed
	 682  // from the Decoder until start's matching end element, or if it's
	 683  // still untouched because start is uninteresting for sv's fields.
	 684  func (d *Decoder) unmarshalPath(tinfo *typeInfo, sv reflect.Value, parents []string, start *StartElement, depth int) (consumed bool, err error) {
	 685  	recurse := false
	 686  Loop:
	 687  	for i := range tinfo.fields {
	 688  		finfo := &tinfo.fields[i]
	 689  		if finfo.flags&fElement == 0 || len(finfo.parents) < len(parents) || finfo.xmlns != "" && finfo.xmlns != start.Name.Space {
	 690  			continue
	 691  		}
	 692  		for j := range parents {
	 693  			if parents[j] != finfo.parents[j] {
	 694  				continue Loop
	 695  			}
	 696  		}
	 697  		if len(finfo.parents) == len(parents) && finfo.name == start.Name.Local {
	 698  			// It's a perfect match, unmarshal the field.
	 699  			return true, d.unmarshal(finfo.value(sv, initNilPointers), start, depth+1)
	 700  		}
	 701  		if len(finfo.parents) > len(parents) && finfo.parents[len(parents)] == start.Name.Local {
	 702  			// It's a prefix for the field. Break and recurse
	 703  			// since it's not ok for one field path to be itself
	 704  			// the prefix for another field path.
	 705  			recurse = true
	 706  
	 707  			// We can reuse the same slice as long as we
	 708  			// don't try to append to it.
	 709  			parents = finfo.parents[:len(parents)+1]
	 710  			break
	 711  		}
	 712  	}
	 713  	if !recurse {
	 714  		// We have no business with this element.
	 715  		return false, nil
	 716  	}
	 717  	// The element is not a perfect match for any field, but one
	 718  	// or more fields have the path to this element as a parent
	 719  	// prefix. Recurse and attempt to match these.
	 720  	for {
	 721  		var tok Token
	 722  		tok, err = d.Token()
	 723  		if err != nil {
	 724  			return true, err
	 725  		}
	 726  		switch t := tok.(type) {
	 727  		case StartElement:
	 728  			// the recursion depth of unmarshalPath is limited to the path length specified
	 729  			// by the struct field tag, so we don't increment the depth here.
	 730  			consumed2, err := d.unmarshalPath(tinfo, sv, parents, &t, depth)
	 731  			if err != nil {
	 732  				return true, err
	 733  			}
	 734  			if !consumed2 {
	 735  				if err := d.Skip(); err != nil {
	 736  					return true, err
	 737  				}
	 738  			}
	 739  		case EndElement:
	 740  			return true, nil
	 741  		}
	 742  	}
	 743  }
	 744  
	 745  // Skip reads tokens until it has consumed the end element
	 746  // matching the most recent start element already consumed,
	 747  // skipping nested structures.
	 748  // It returns nil if it finds an end element matching the start
	 749  // element; otherwise it returns an error describing the problem.
	 750  func (d *Decoder) Skip() error {
	 751  	var depth int64
	 752  	for {
	 753  		tok, err := d.Token()
	 754  		if err != nil {
	 755  			return err
	 756  		}
	 757  		switch tok.(type) {
	 758  		case StartElement:
	 759  			depth++
	 760  		case EndElement:
	 761  			if depth == 0 {
	 762  				return nil
	 763  			}
	 764  			depth--
	 765  		}
	 766  	}
	 767  }
	 768  

View as plain text