Source file src/encoding/xml/read.go

     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)
   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	// Unmarshal a single XML element into val.
   308	func (d *Decoder) unmarshal(val reflect.Value, start *StartElement) error {
   309		// Find start element if we need it.
   310		if start == nil {
   311			for {
   312				tok, err := d.Token()
   313				if err != nil {
   314					return err
   315				}
   316				if t, ok := tok.(StartElement); ok {
   317					start = &t
   318					break
   319				}
   320			}
   321		}
   322	
   323		// Load value from interface, but only if the result will be
   324		// usefully addressable.
   325		if val.Kind() == reflect.Interface && !val.IsNil() {
   326			e := val.Elem()
   327			if e.Kind() == reflect.Ptr && !e.IsNil() {
   328				val = e
   329			}
   330		}
   331	
   332		if val.Kind() == reflect.Ptr {
   333			if val.IsNil() {
   334				val.Set(reflect.New(val.Type().Elem()))
   335			}
   336			val = val.Elem()
   337		}
   338	
   339		if val.CanInterface() && val.Type().Implements(unmarshalerType) {
   340			// This is an unmarshaler with a non-pointer receiver,
   341			// so it's likely to be incorrect, but we do what we're told.
   342			return d.unmarshalInterface(val.Interface().(Unmarshaler), start)
   343		}
   344	
   345		if val.CanAddr() {
   346			pv := val.Addr()
   347			if pv.CanInterface() && pv.Type().Implements(unmarshalerType) {
   348				return d.unmarshalInterface(pv.Interface().(Unmarshaler), start)
   349			}
   350		}
   351	
   352		if val.CanInterface() && val.Type().Implements(textUnmarshalerType) {
   353			return d.unmarshalTextInterface(val.Interface().(encoding.TextUnmarshaler))
   354		}
   355	
   356		if val.CanAddr() {
   357			pv := val.Addr()
   358			if pv.CanInterface() && pv.Type().Implements(textUnmarshalerType) {
   359				return d.unmarshalTextInterface(pv.Interface().(encoding.TextUnmarshaler))
   360			}
   361		}
   362	
   363		var (
   364			data         []byte
   365			saveData     reflect.Value
   366			comment      []byte
   367			saveComment  reflect.Value
   368			saveXML      reflect.Value
   369			saveXMLIndex int
   370			saveXMLData  []byte
   371			saveAny      reflect.Value
   372			sv           reflect.Value
   373			tinfo        *typeInfo
   374			err          error
   375		)
   376	
   377		switch v := val; v.Kind() {
   378		default:
   379			return errors.New("unknown type " + v.Type().String())
   380	
   381		case reflect.Interface:
   382			// TODO: For now, simply ignore the field. In the near
   383			//       future we may choose to unmarshal the start
   384			//       element on it, if not nil.
   385			return d.Skip()
   386	
   387		case reflect.Slice:
   388			typ := v.Type()
   389			if typ.Elem().Kind() == reflect.Uint8 {
   390				// []byte
   391				saveData = v
   392				break
   393			}
   394	
   395			// Slice of element values.
   396			// Grow slice.
   397			n := v.Len()
   398			v.Set(reflect.Append(val, reflect.Zero(v.Type().Elem())))
   399	
   400			// Recur to read element into slice.
   401			if err := d.unmarshal(v.Index(n), start); err != nil {
   402				v.SetLen(n)
   403				return err
   404			}
   405			return nil
   406	
   407		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:
   408			saveData = v
   409	
   410		case reflect.Struct:
   411			typ := v.Type()
   412			if typ == nameType {
   413				v.Set(reflect.ValueOf(start.Name))
   414				break
   415			}
   416	
   417			sv = v
   418			tinfo, err = getTypeInfo(typ)
   419			if err != nil {
   420				return err
   421			}
   422	
   423			// Validate and assign element name.
   424			if tinfo.xmlname != nil {
   425				finfo := tinfo.xmlname
   426				if finfo.name != "" && finfo.name != start.Name.Local {
   427					return UnmarshalError("expected element type <" + finfo.name + "> but have <" + start.Name.Local + ">")
   428				}
   429				if finfo.xmlns != "" && finfo.xmlns != start.Name.Space {
   430					e := "expected element <" + finfo.name + "> in name space " + finfo.xmlns + " but have "
   431					if start.Name.Space == "" {
   432						e += "no name space"
   433					} else {
   434						e += start.Name.Space
   435					}
   436					return UnmarshalError(e)
   437				}
   438				fv := finfo.value(sv)
   439				if _, ok := fv.Interface().(Name); ok {
   440					fv.Set(reflect.ValueOf(start.Name))
   441				}
   442			}
   443	
   444			// Assign attributes.
   445			for _, a := range start.Attr {
   446				handled := false
   447				any := -1
   448				for i := range tinfo.fields {
   449					finfo := &tinfo.fields[i]
   450					switch finfo.flags & fMode {
   451					case fAttr:
   452						strv := finfo.value(sv)
   453						if a.Name.Local == finfo.name && (finfo.xmlns == "" || finfo.xmlns == a.Name.Space) {
   454							if err := d.unmarshalAttr(strv, a); err != nil {
   455								return err
   456							}
   457							handled = true
   458						}
   459	
   460					case fAny | fAttr:
   461						if any == -1 {
   462							any = i
   463						}
   464					}
   465				}
   466				if !handled && any >= 0 {
   467					finfo := &tinfo.fields[any]
   468					strv := finfo.value(sv)
   469					if err := d.unmarshalAttr(strv, a); err != nil {
   470						return err
   471					}
   472				}
   473			}
   474	
   475			// Determine whether we need to save character data or comments.
   476			for i := range tinfo.fields {
   477				finfo := &tinfo.fields[i]
   478				switch finfo.flags & fMode {
   479				case fCDATA, fCharData:
   480					if !saveData.IsValid() {
   481						saveData = finfo.value(sv)
   482					}
   483	
   484				case fComment:
   485					if !saveComment.IsValid() {
   486						saveComment = finfo.value(sv)
   487					}
   488	
   489				case fAny, fAny | fElement:
   490					if !saveAny.IsValid() {
   491						saveAny = finfo.value(sv)
   492					}
   493	
   494				case fInnerXml:
   495					if !saveXML.IsValid() {
   496						saveXML = finfo.value(sv)
   497						if d.saved == nil {
   498							saveXMLIndex = 0
   499							d.saved = new(bytes.Buffer)
   500						} else {
   501							saveXMLIndex = d.savedOffset()
   502						}
   503					}
   504				}
   505			}
   506		}
   507	
   508		// Find end element.
   509		// Process sub-elements along the way.
   510	Loop:
   511		for {
   512			var savedOffset int
   513			if saveXML.IsValid() {
   514				savedOffset = d.savedOffset()
   515			}
   516			tok, err := d.Token()
   517			if err != nil {
   518				return err
   519			}
   520			switch t := tok.(type) {
   521			case StartElement:
   522				consumed := false
   523				if sv.IsValid() {
   524					consumed, err = d.unmarshalPath(tinfo, sv, nil, &t)
   525					if err != nil {
   526						return err
   527					}
   528					if !consumed && saveAny.IsValid() {
   529						consumed = true
   530						if err := d.unmarshal(saveAny, &t); err != nil {
   531							return err
   532						}
   533					}
   534				}
   535				if !consumed {
   536					if err := d.Skip(); err != nil {
   537						return err
   538					}
   539				}
   540	
   541			case EndElement:
   542				if saveXML.IsValid() {
   543					saveXMLData = d.saved.Bytes()[saveXMLIndex:savedOffset]
   544					if saveXMLIndex == 0 {
   545						d.saved = nil
   546					}
   547				}
   548				break Loop
   549	
   550			case CharData:
   551				if saveData.IsValid() {
   552					data = append(data, t...)
   553				}
   554	
   555			case Comment:
   556				if saveComment.IsValid() {
   557					comment = append(comment, t...)
   558				}
   559			}
   560		}
   561	
   562		if saveData.IsValid() && saveData.CanInterface() && saveData.Type().Implements(textUnmarshalerType) {
   563			if err := saveData.Interface().(encoding.TextUnmarshaler).UnmarshalText(data); err != nil {
   564				return err
   565			}
   566			saveData = reflect.Value{}
   567		}
   568	
   569		if saveData.IsValid() && saveData.CanAddr() {
   570			pv := saveData.Addr()
   571			if pv.CanInterface() && pv.Type().Implements(textUnmarshalerType) {
   572				if err := pv.Interface().(encoding.TextUnmarshaler).UnmarshalText(data); err != nil {
   573					return err
   574				}
   575				saveData = reflect.Value{}
   576			}
   577		}
   578	
   579		if err := copyValue(saveData, data); err != nil {
   580			return err
   581		}
   582	
   583		switch t := saveComment; t.Kind() {
   584		case reflect.String:
   585			t.SetString(string(comment))
   586		case reflect.Slice:
   587			t.Set(reflect.ValueOf(comment))
   588		}
   589	
   590		switch t := saveXML; t.Kind() {
   591		case reflect.String:
   592			t.SetString(string(saveXMLData))
   593		case reflect.Slice:
   594			if t.Type().Elem().Kind() == reflect.Uint8 {
   595				t.Set(reflect.ValueOf(saveXMLData))
   596			}
   597		}
   598	
   599		return nil
   600	}
   601	
   602	func copyValue(dst reflect.Value, src []byte) (err error) {
   603		dst0 := dst
   604	
   605		if dst.Kind() == reflect.Ptr {
   606			if dst.IsNil() {
   607				dst.Set(reflect.New(dst.Type().Elem()))
   608			}
   609			dst = dst.Elem()
   610		}
   611	
   612		// Save accumulated data.
   613		switch dst.Kind() {
   614		case reflect.Invalid:
   615			// Probably a comment.
   616		default:
   617			return errors.New("cannot unmarshal into " + dst0.Type().String())
   618		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   619			if len(src) == 0 {
   620				dst.SetInt(0)
   621				return nil
   622			}
   623			itmp, err := strconv.ParseInt(strings.TrimSpace(string(src)), 10, dst.Type().Bits())
   624			if err != nil {
   625				return err
   626			}
   627			dst.SetInt(itmp)
   628		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   629			if len(src) == 0 {
   630				dst.SetUint(0)
   631				return nil
   632			}
   633			utmp, err := strconv.ParseUint(strings.TrimSpace(string(src)), 10, dst.Type().Bits())
   634			if err != nil {
   635				return err
   636			}
   637			dst.SetUint(utmp)
   638		case reflect.Float32, reflect.Float64:
   639			if len(src) == 0 {
   640				dst.SetFloat(0)
   641				return nil
   642			}
   643			ftmp, err := strconv.ParseFloat(strings.TrimSpace(string(src)), dst.Type().Bits())
   644			if err != nil {
   645				return err
   646			}
   647			dst.SetFloat(ftmp)
   648		case reflect.Bool:
   649			if len(src) == 0 {
   650				dst.SetBool(false)
   651				return nil
   652			}
   653			value, err := strconv.ParseBool(strings.TrimSpace(string(src)))
   654			if err != nil {
   655				return err
   656			}
   657			dst.SetBool(value)
   658		case reflect.String:
   659			dst.SetString(string(src))
   660		case reflect.Slice:
   661			if len(src) == 0 {
   662				// non-nil to flag presence
   663				src = []byte{}
   664			}
   665			dst.SetBytes(src)
   666		}
   667		return nil
   668	}
   669	
   670	// unmarshalPath walks down an XML structure looking for wanted
   671	// paths, and calls unmarshal on them.
   672	// The consumed result tells whether XML elements have been consumed
   673	// from the Decoder until start's matching end element, or if it's
   674	// still untouched because start is uninteresting for sv's fields.
   675	func (d *Decoder) unmarshalPath(tinfo *typeInfo, sv reflect.Value, parents []string, start *StartElement) (consumed bool, err error) {
   676		recurse := false
   677	Loop:
   678		for i := range tinfo.fields {
   679			finfo := &tinfo.fields[i]
   680			if finfo.flags&fElement == 0 || len(finfo.parents) < len(parents) || finfo.xmlns != "" && finfo.xmlns != start.Name.Space {
   681				continue
   682			}
   683			for j := range parents {
   684				if parents[j] != finfo.parents[j] {
   685					continue Loop
   686				}
   687			}
   688			if len(finfo.parents) == len(parents) && finfo.name == start.Name.Local {
   689				// It's a perfect match, unmarshal the field.
   690				return true, d.unmarshal(finfo.value(sv), start)
   691			}
   692			if len(finfo.parents) > len(parents) && finfo.parents[len(parents)] == start.Name.Local {
   693				// It's a prefix for the field. Break and recurse
   694				// since it's not ok for one field path to be itself
   695				// the prefix for another field path.
   696				recurse = true
   697	
   698				// We can reuse the same slice as long as we
   699				// don't try to append to it.
   700				parents = finfo.parents[:len(parents)+1]
   701				break
   702			}
   703		}
   704		if !recurse {
   705			// We have no business with this element.
   706			return false, nil
   707		}
   708		// The element is not a perfect match for any field, but one
   709		// or more fields have the path to this element as a parent
   710		// prefix. Recurse and attempt to match these.
   711		for {
   712			var tok Token
   713			tok, err = d.Token()
   714			if err != nil {
   715				return true, err
   716			}
   717			switch t := tok.(type) {
   718			case StartElement:
   719				consumed2, err := d.unmarshalPath(tinfo, sv, parents, &t)
   720				if err != nil {
   721					return true, err
   722				}
   723				if !consumed2 {
   724					if err := d.Skip(); err != nil {
   725						return true, err
   726					}
   727				}
   728			case EndElement:
   729				return true, nil
   730			}
   731		}
   732	}
   733	
   734	// Skip reads tokens until it has consumed the end element
   735	// matching the most recent start element already consumed.
   736	// It recurs if it encounters a start element, so it can be used to
   737	// skip nested structures.
   738	// It returns nil if it finds an end element matching the start
   739	// element; otherwise it returns an error describing the problem.
   740	func (d *Decoder) Skip() error {
   741		for {
   742			tok, err := d.Token()
   743			if err != nil {
   744				return err
   745			}
   746			switch tok.(type) {
   747			case StartElement:
   748				if err := d.Skip(); err != nil {
   749					return err
   750				}
   751			case EndElement:
   752				return nil
   753			}
   754		}
   755	}
   756	

View as plain text