decode.go

Documentation: sigs.k8s.io/yaml/goyaml.v2

     1  package yaml
     2  
     3  import (
     4  	"encoding"
     5  	"encoding/base64"
     6  	"fmt"
     7  	"io"
     8  	"math"
     9  	"reflect"
    10  	"strconv"
    11  	"time"
    12  )
    13  
    14  const (
    15  	documentNode = 1 << iota
    16  	mappingNode
    17  	sequenceNode
    18  	scalarNode
    19  	aliasNode
    20  )
    21  
    22  type node struct {
    23  	kind         int
    24  	line, column int
    25  	tag          string
    26  	// For an alias node, alias holds the resolved alias.
    27  	alias    *node
    28  	value    string
    29  	implicit bool
    30  	children []*node
    31  	anchors  map[string]*node
    32  }
    33  
    34  // ----------------------------------------------------------------------------
    35  // Parser, produces a node tree out of a libyaml event stream.
    36  
    37  type parser struct {
    38  	parser   yaml_parser_t
    39  	event    yaml_event_t
    40  	doc      *node
    41  	doneInit bool
    42  }
    43  
    44  func newParser(b []byte) *parser {
    45  	p := parser{}
    46  	if !yaml_parser_initialize(&p.parser) {
    47  		panic("failed to initialize YAML emitter")
    48  	}
    49  	if len(b) == 0 {
    50  		b = []byte{'\n'}
    51  	}
    52  	yaml_parser_set_input_string(&p.parser, b)
    53  	return &p
    54  }
    55  
    56  func newParserFromReader(r io.Reader) *parser {
    57  	p := parser{}
    58  	if !yaml_parser_initialize(&p.parser) {
    59  		panic("failed to initialize YAML emitter")
    60  	}
    61  	yaml_parser_set_input_reader(&p.parser, r)
    62  	return &p
    63  }
    64  
    65  func (p *parser) init() {
    66  	if p.doneInit {
    67  		return
    68  	}
    69  	p.expect(yaml_STREAM_START_EVENT)
    70  	p.doneInit = true
    71  }
    72  
    73  func (p *parser) destroy() {
    74  	if p.event.typ != yaml_NO_EVENT {
    75  		yaml_event_delete(&p.event)
    76  	}
    77  	yaml_parser_delete(&p.parser)
    78  }
    79  
    80  // expect consumes an event from the event stream and
    81  // checks that it's of the expected type.
    82  func (p *parser) expect(e yaml_event_type_t) {
    83  	if p.event.typ == yaml_NO_EVENT {
    84  		if !yaml_parser_parse(&p.parser, &p.event) {
    85  			p.fail()
    86  		}
    87  	}
    88  	if p.event.typ == yaml_STREAM_END_EVENT {
    89  		failf("attempted to go past the end of stream; corrupted value?")
    90  	}
    91  	if p.event.typ != e {
    92  		p.parser.problem = fmt.Sprintf("expected %s event but got %s", e, p.event.typ)
    93  		p.fail()
    94  	}
    95  	yaml_event_delete(&p.event)
    96  	p.event.typ = yaml_NO_EVENT
    97  }
    98  
    99  // peek peeks at the next event in the event stream,
   100  // puts the results into p.event and returns the event type.
   101  func (p *parser) peek() yaml_event_type_t {
   102  	if p.event.typ != yaml_NO_EVENT {
   103  		return p.event.typ
   104  	}
   105  	if !yaml_parser_parse(&p.parser, &p.event) {
   106  		p.fail()
   107  	}
   108  	return p.event.typ
   109  }
   110  
   111  func (p *parser) fail() {
   112  	var where string
   113  	var line int
   114  	if p.parser.problem_mark.line != 0 {
   115  		line = p.parser.problem_mark.line
   116  		// Scanner errors don't iterate line before returning error
   117  		if p.parser.error == yaml_SCANNER_ERROR {
   118  			line++
   119  		}
   120  	} else if p.parser.context_mark.line != 0 {
   121  		line = p.parser.context_mark.line
   122  	}
   123  	if line != 0 {
   124  		where = "line " + strconv.Itoa(line) + ": "
   125  	}
   126  	var msg string
   127  	if len(p.parser.problem) > 0 {
   128  		msg = p.parser.problem
   129  	} else {
   130  		msg = "unknown problem parsing YAML content"
   131  	}
   132  	failf("%s%s", where, msg)
   133  }
   134  
   135  func (p *parser) anchor(n *node, anchor []byte) {
   136  	if anchor != nil {
   137  		p.doc.anchors[string(anchor)] = n
   138  	}
   139  }
   140  
   141  func (p *parser) parse() *node {
   142  	p.init()
   143  	switch p.peek() {
   144  	case yaml_SCALAR_EVENT:
   145  		return p.scalar()
   146  	case yaml_ALIAS_EVENT:
   147  		return p.alias()
   148  	case yaml_MAPPING_START_EVENT:
   149  		return p.mapping()
   150  	case yaml_SEQUENCE_START_EVENT:
   151  		return p.sequence()
   152  	case yaml_DOCUMENT_START_EVENT:
   153  		return p.document()
   154  	case yaml_STREAM_END_EVENT:
   155  		// Happens when attempting to decode an empty buffer.
   156  		return nil
   157  	default:
   158  		panic("attempted to parse unknown event: " + p.event.typ.String())
   159  	}
   160  }
   161  
   162  func (p *parser) node(kind int) *node {
   163  	return &node{
   164  		kind:   kind,
   165  		line:   p.event.start_mark.line,
   166  		column: p.event.start_mark.column,
   167  	}
   168  }
   169  
   170  func (p *parser) document() *node {
   171  	n := p.node(documentNode)
   172  	n.anchors = make(map[string]*node)
   173  	p.doc = n
   174  	p.expect(yaml_DOCUMENT_START_EVENT)
   175  	n.children = append(n.children, p.parse())
   176  	p.expect(yaml_DOCUMENT_END_EVENT)
   177  	return n
   178  }
   179  
   180  func (p *parser) alias() *node {
   181  	n := p.node(aliasNode)
   182  	n.value = string(p.event.anchor)
   183  	n.alias = p.doc.anchors[n.value]
   184  	if n.alias == nil {
   185  		failf("unknown anchor '%s' referenced", n.value)
   186  	}
   187  	p.expect(yaml_ALIAS_EVENT)
   188  	return n
   189  }
   190  
   191  func (p *parser) scalar() *node {
   192  	n := p.node(scalarNode)
   193  	n.value = string(p.event.value)
   194  	n.tag = string(p.event.tag)
   195  	n.implicit = p.event.implicit
   196  	p.anchor(n, p.event.anchor)
   197  	p.expect(yaml_SCALAR_EVENT)
   198  	return n
   199  }
   200  
   201  func (p *parser) sequence() *node {
   202  	n := p.node(sequenceNode)
   203  	p.anchor(n, p.event.anchor)
   204  	p.expect(yaml_SEQUENCE_START_EVENT)
   205  	for p.peek() != yaml_SEQUENCE_END_EVENT {
   206  		n.children = append(n.children, p.parse())
   207  	}
   208  	p.expect(yaml_SEQUENCE_END_EVENT)
   209  	return n
   210  }
   211  
   212  func (p *parser) mapping() *node {
   213  	n := p.node(mappingNode)
   214  	p.anchor(n, p.event.anchor)
   215  	p.expect(yaml_MAPPING_START_EVENT)
   216  	for p.peek() != yaml_MAPPING_END_EVENT {
   217  		n.children = append(n.children, p.parse(), p.parse())
   218  	}
   219  	p.expect(yaml_MAPPING_END_EVENT)
   220  	return n
   221  }
   222  
   223  // ----------------------------------------------------------------------------
   224  // Decoder, unmarshals a node into a provided value.
   225  
   226  type decoder struct {
   227  	doc     *node
   228  	aliases map[*node]bool
   229  	mapType reflect.Type
   230  	terrors []string
   231  	strict  bool
   232  
   233  	decodeCount int
   234  	aliasCount  int
   235  	aliasDepth  int
   236  }
   237  
   238  var (
   239  	mapItemType    = reflect.TypeOf(MapItem{})
   240  	durationType   = reflect.TypeOf(time.Duration(0))
   241  	defaultMapType = reflect.TypeOf(map[interface{}]interface{}{})
   242  	ifaceType      = defaultMapType.Elem()
   243  	timeType       = reflect.TypeOf(time.Time{})
   244  	ptrTimeType    = reflect.TypeOf(&time.Time{})
   245  )
   246  
   247  func newDecoder(strict bool) *decoder {
   248  	d := &decoder{mapType: defaultMapType, strict: strict}
   249  	d.aliases = make(map[*node]bool)
   250  	return d
   251  }
   252  
   253  func (d *decoder) terror(n *node, tag string, out reflect.Value) {
   254  	if n.tag != "" {
   255  		tag = n.tag
   256  	}
   257  	value := n.value
   258  	if tag != yaml_SEQ_TAG && tag != yaml_MAP_TAG {
   259  		if len(value) > 10 {
   260  			value = " `" + value[:7] + "...`"
   261  		} else {
   262  			value = " `" + value + "`"
   263  		}
   264  	}
   265  	d.terrors = append(d.terrors, fmt.Sprintf("line %d: cannot unmarshal %s%s into %s", n.line+1, shortTag(tag), value, out.Type()))
   266  }
   267  
   268  func (d *decoder) callUnmarshaler(n *node, u Unmarshaler) (good bool) {
   269  	terrlen := len(d.terrors)
   270  	err := u.UnmarshalYAML(func(v interface{}) (err error) {
   271  		defer handleErr(&err)
   272  		d.unmarshal(n, reflect.ValueOf(v))
   273  		if len(d.terrors) > terrlen {
   274  			issues := d.terrors[terrlen:]
   275  			d.terrors = d.terrors[:terrlen]
   276  			return &TypeError{issues}
   277  		}
   278  		return nil
   279  	})
   280  	if e, ok := err.(*TypeError); ok {
   281  		d.terrors = append(d.terrors, e.Errors...)
   282  		return false
   283  	}
   284  	if err != nil {
   285  		fail(err)
   286  	}
   287  	return true
   288  }
   289  
   290  // d.prepare initializes and dereferences pointers and calls UnmarshalYAML
   291  // if a value is found to implement it.
   292  // It returns the initialized and dereferenced out value, whether
   293  // unmarshalling was already done by UnmarshalYAML, and if so whether
   294  // its types unmarshalled appropriately.
   295  //
   296  // If n holds a null value, prepare returns before doing anything.
   297  func (d *decoder) prepare(n *node, out reflect.Value) (newout reflect.Value, unmarshaled, good bool) {
   298  	if n.tag == yaml_NULL_TAG || n.kind == scalarNode && n.tag == "" && (n.value == "null" || n.value == "~" || n.value == "" && n.implicit) {
   299  		return out, false, false
   300  	}
   301  	again := true
   302  	for again {
   303  		again = false
   304  		if out.Kind() == reflect.Ptr {
   305  			if out.IsNil() {
   306  				out.Set(reflect.New(out.Type().Elem()))
   307  			}
   308  			out = out.Elem()
   309  			again = true
   310  		}
   311  		if out.CanAddr() {
   312  			if u, ok := out.Addr().Interface().(Unmarshaler); ok {
   313  				good = d.callUnmarshaler(n, u)
   314  				return out, true, good
   315  			}
   316  		}
   317  	}
   318  	return out, false, false
   319  }
   320  
   321  const (
   322  	// 400,000 decode operations is ~500kb of dense object declarations, or
   323  	// ~5kb of dense object declarations with 10000% alias expansion
   324  	alias_ratio_range_low = 400000
   325  
   326  	// 4,000,000 decode operations is ~5MB of dense object declarations, or
   327  	// ~4.5MB of dense object declarations with 10% alias expansion
   328  	alias_ratio_range_high = 4000000
   329  
   330  	// alias_ratio_range is the range over which we scale allowed alias ratios
   331  	alias_ratio_range = float64(alias_ratio_range_high - alias_ratio_range_low)
   332  )
   333  
   334  func allowedAliasRatio(decodeCount int) float64 {
   335  	switch {
   336  	case decodeCount <= alias_ratio_range_low:
   337  		// allow 99% to come from alias expansion for small-to-medium documents
   338  		return 0.99
   339  	case decodeCount >= alias_ratio_range_high:
   340  		// allow 10% to come from alias expansion for very large documents
   341  		return 0.10
   342  	default:
   343  		// scale smoothly from 99% down to 10% over the range.
   344  		// this maps to 396,000 - 400,000 allowed alias-driven decodes over the range.
   345  		// 400,000 decode operations is ~100MB of allocations in worst-case scenarios (single-item maps).
   346  		return 0.99 - 0.89*(float64(decodeCount-alias_ratio_range_low)/alias_ratio_range)
   347  	}
   348  }
   349  
   350  func (d *decoder) unmarshal(n *node, out reflect.Value) (good bool) {
   351  	d.decodeCount++
   352  	if d.aliasDepth > 0 {
   353  		d.aliasCount++
   354  	}
   355  	if d.aliasCount > 100 && d.decodeCount > 1000 && float64(d.aliasCount)/float64(d.decodeCount) > allowedAliasRatio(d.decodeCount) {
   356  		failf("document contains excessive aliasing")
   357  	}
   358  	switch n.kind {
   359  	case documentNode:
   360  		return d.document(n, out)
   361  	case aliasNode:
   362  		return d.alias(n, out)
   363  	}
   364  	out, unmarshaled, good := d.prepare(n, out)
   365  	if unmarshaled {
   366  		return good
   367  	}
   368  	switch n.kind {
   369  	case scalarNode:
   370  		good = d.scalar(n, out)
   371  	case mappingNode:
   372  		good = d.mapping(n, out)
   373  	case sequenceNode:
   374  		good = d.sequence(n, out)
   375  	default:
   376  		panic("internal error: unknown node kind: " + strconv.Itoa(n.kind))
   377  	}
   378  	return good
   379  }
   380  
   381  func (d *decoder) document(n *node, out reflect.Value) (good bool) {
   382  	if len(n.children) == 1 {
   383  		d.doc = n
   384  		d.unmarshal(n.children[0], out)
   385  		return true
   386  	}
   387  	return false
   388  }
   389  
   390  func (d *decoder) alias(n *node, out reflect.Value) (good bool) {
   391  	if d.aliases[n] {
   392  		// TODO this could actually be allowed in some circumstances.
   393  		failf("anchor '%s' value contains itself", n.value)
   394  	}
   395  	d.aliases[n] = true
   396  	d.aliasDepth++
   397  	good = d.unmarshal(n.alias, out)
   398  	d.aliasDepth--
   399  	delete(d.aliases, n)
   400  	return good
   401  }
   402  
   403  var zeroValue reflect.Value
   404  
   405  func resetMap(out reflect.Value) {
   406  	for _, k := range out.MapKeys() {
   407  		out.SetMapIndex(k, zeroValue)
   408  	}
   409  }
   410  
   411  func (d *decoder) scalar(n *node, out reflect.Value) bool {
   412  	var tag string
   413  	var resolved interface{}
   414  	if n.tag == "" && !n.implicit {
   415  		tag = yaml_STR_TAG
   416  		resolved = n.value
   417  	} else {
   418  		tag, resolved = resolve(n.tag, n.value)
   419  		if tag == yaml_BINARY_TAG {
   420  			data, err := base64.StdEncoding.DecodeString(resolved.(string))
   421  			if err != nil {
   422  				failf("!!binary value contains invalid base64 data")
   423  			}
   424  			resolved = string(data)
   425  		}
   426  	}
   427  	if resolved == nil {
   428  		if out.Kind() == reflect.Map && !out.CanAddr() {
   429  			resetMap(out)
   430  		} else {
   431  			out.Set(reflect.Zero(out.Type()))
   432  		}
   433  		return true
   434  	}
   435  	if resolvedv := reflect.ValueOf(resolved); out.Type() == resolvedv.Type() {
   436  		// We've resolved to exactly the type we want, so use that.
   437  		out.Set(resolvedv)
   438  		return true
   439  	}
   440  	// Perhaps we can use the value as a TextUnmarshaler to
   441  	// set its value.
   442  	if out.CanAddr() {
   443  		u, ok := out.Addr().Interface().(encoding.TextUnmarshaler)
   444  		if ok {
   445  			var text []byte
   446  			if tag == yaml_BINARY_TAG {
   447  				text = []byte(resolved.(string))
   448  			} else {
   449  				// We let any value be unmarshaled into TextUnmarshaler.
   450  				// That might be more lax than we'd like, but the
   451  				// TextUnmarshaler itself should bowl out any dubious values.
   452  				text = []byte(n.value)
   453  			}
   454  			err := u.UnmarshalText(text)
   455  			if err != nil {
   456  				fail(err)
   457  			}
   458  			return true
   459  		}
   460  	}
   461  	switch out.Kind() {
   462  	case reflect.String:
   463  		if tag == yaml_BINARY_TAG {
   464  			out.SetString(resolved.(string))
   465  			return true
   466  		}
   467  		if resolved != nil {
   468  			out.SetString(n.value)
   469  			return true
   470  		}
   471  	case reflect.Interface:
   472  		if resolved == nil {
   473  			out.Set(reflect.Zero(out.Type()))
   474  		} else if tag == yaml_TIMESTAMP_TAG {
   475  			// It looks like a timestamp but for backward compatibility
   476  			// reasons we set it as a string, so that code that unmarshals
   477  			// timestamp-like values into interface{} will continue to
   478  			// see a string and not a time.Time.
   479  			// TODO(v3) Drop this.
   480  			out.Set(reflect.ValueOf(n.value))
   481  		} else {
   482  			out.Set(reflect.ValueOf(resolved))
   483  		}
   484  		return true
   485  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   486  		switch resolved := resolved.(type) {
   487  		case int:
   488  			if !out.OverflowInt(int64(resolved)) {
   489  				out.SetInt(int64(resolved))
   490  				return true
   491  			}
   492  		case int64:
   493  			if !out.OverflowInt(resolved) {
   494  				out.SetInt(resolved)
   495  				return true
   496  			}
   497  		case uint64:
   498  			if resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) {
   499  				out.SetInt(int64(resolved))
   500  				return true
   501  			}
   502  		case float64:
   503  			if resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) {
   504  				out.SetInt(int64(resolved))
   505  				return true
   506  			}
   507  		case string:
   508  			if out.Type() == durationType {
   509  				d, err := time.ParseDuration(resolved)
   510  				if err == nil {
   511  					out.SetInt(int64(d))
   512  					return true
   513  				}
   514  			}
   515  		}
   516  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   517  		switch resolved := resolved.(type) {
   518  		case int:
   519  			if resolved >= 0 && !out.OverflowUint(uint64(resolved)) {
   520  				out.SetUint(uint64(resolved))
   521  				return true
   522  			}
   523  		case int64:
   524  			if resolved >= 0 && !out.OverflowUint(uint64(resolved)) {
   525  				out.SetUint(uint64(resolved))
   526  				return true
   527  			}
   528  		case uint64:
   529  			if !out.OverflowUint(uint64(resolved)) {
   530  				out.SetUint(uint64(resolved))
   531  				return true
   532  			}
   533  		case float64:
   534  			if resolved <= math.MaxUint64 && !out.OverflowUint(uint64(resolved)) {
   535  				out.SetUint(uint64(resolved))
   536  				return true
   537  			}
   538  		}
   539  	case reflect.Bool:
   540  		switch resolved := resolved.(type) {
   541  		case bool:
   542  			out.SetBool(resolved)
   543  			return true
   544  		}
   545  	case reflect.Float32, reflect.Float64:
   546  		switch resolved := resolved.(type) {
   547  		case int:
   548  			out.SetFloat(float64(resolved))
   549  			return true
   550  		case int64:
   551  			out.SetFloat(float64(resolved))
   552  			return true
   553  		case uint64:
   554  			out.SetFloat(float64(resolved))
   555  			return true
   556  		case float64:
   557  			out.SetFloat(resolved)
   558  			return true
   559  		}
   560  	case reflect.Struct:
   561  		if resolvedv := reflect.ValueOf(resolved); out.Type() == resolvedv.Type() {
   562  			out.Set(resolvedv)
   563  			return true
   564  		}
   565  	case reflect.Ptr:
   566  		if out.Type().Elem() == reflect.TypeOf(resolved) {
   567  			// TODO DOes this make sense? When is out a Ptr except when decoding a nil value?
   568  			elem := reflect.New(out.Type().Elem())
   569  			elem.Elem().Set(reflect.ValueOf(resolved))
   570  			out.Set(elem)
   571  			return true
   572  		}
   573  	}
   574  	d.terror(n, tag, out)
   575  	return false
   576  }
   577  
   578  func settableValueOf(i interface{}) reflect.Value {
   579  	v := reflect.ValueOf(i)
   580  	sv := reflect.New(v.Type()).Elem()
   581  	sv.Set(v)
   582  	return sv
   583  }
   584  
   585  func (d *decoder) sequence(n *node, out reflect.Value) (good bool) {
   586  	l := len(n.children)
   587  
   588  	var iface reflect.Value
   589  	switch out.Kind() {
   590  	case reflect.Slice:
   591  		out.Set(reflect.MakeSlice(out.Type(), l, l))
   592  	case reflect.Array:
   593  		if l != out.Len() {
   594  			failf("invalid array: want %d elements but got %d", out.Len(), l)
   595  		}
   596  	case reflect.Interface:
   597  		// No type hints. Will have to use a generic sequence.
   598  		iface = out
   599  		out = settableValueOf(make([]interface{}, l))
   600  	default:
   601  		d.terror(n, yaml_SEQ_TAG, out)
   602  		return false
   603  	}
   604  	et := out.Type().Elem()
   605  
   606  	j := 0
   607  	for i := 0; i < l; i++ {
   608  		e := reflect.New(et).Elem()
   609  		if ok := d.unmarshal(n.children[i], e); ok {
   610  			out.Index(j).Set(e)
   611  			j++
   612  		}
   613  	}
   614  	if out.Kind() != reflect.Array {
   615  		out.Set(out.Slice(0, j))
   616  	}
   617  	if iface.IsValid() {
   618  		iface.Set(out)
   619  	}
   620  	return true
   621  }
   622  
   623  func (d *decoder) mapping(n *node, out reflect.Value) (good bool) {
   624  	switch out.Kind() {
   625  	case reflect.Struct:
   626  		return d.mappingStruct(n, out)
   627  	case reflect.Slice:
   628  		return d.mappingSlice(n, out)
   629  	case reflect.Map:
   630  		// okay
   631  	case reflect.Interface:
   632  		if d.mapType.Kind() == reflect.Map {
   633  			iface := out
   634  			out = reflect.MakeMap(d.mapType)
   635  			iface.Set(out)
   636  		} else {
   637  			slicev := reflect.New(d.mapType).Elem()
   638  			if !d.mappingSlice(n, slicev) {
   639  				return false
   640  			}
   641  			out.Set(slicev)
   642  			return true
   643  		}
   644  	default:
   645  		d.terror(n, yaml_MAP_TAG, out)
   646  		return false
   647  	}
   648  	outt := out.Type()
   649  	kt := outt.Key()
   650  	et := outt.Elem()
   651  
   652  	mapType := d.mapType
   653  	if outt.Key() == ifaceType && outt.Elem() == ifaceType {
   654  		d.mapType = outt
   655  	}
   656  
   657  	if out.IsNil() {
   658  		out.Set(reflect.MakeMap(outt))
   659  	}
   660  	l := len(n.children)
   661  	for i := 0; i < l; i += 2 {
   662  		if isMerge(n.children[i]) {
   663  			d.merge(n.children[i+1], out)
   664  			continue
   665  		}
   666  		k := reflect.New(kt).Elem()
   667  		if d.unmarshal(n.children[i], k) {
   668  			kkind := k.Kind()
   669  			if kkind == reflect.Interface {
   670  				kkind = k.Elem().Kind()
   671  			}
   672  			if kkind == reflect.Map || kkind == reflect.Slice {
   673  				failf("invalid map key: %#v", k.Interface())
   674  			}
   675  			e := reflect.New(et).Elem()
   676  			if d.unmarshal(n.children[i+1], e) {
   677  				d.setMapIndex(n.children[i+1], out, k, e)
   678  			}
   679  		}
   680  	}
   681  	d.mapType = mapType
   682  	return true
   683  }
   684  
   685  func (d *decoder) setMapIndex(n *node, out, k, v reflect.Value) {
   686  	if d.strict && out.MapIndex(k) != zeroValue {
   687  		d.terrors = append(d.terrors, fmt.Sprintf("line %d: key %#v already set in map", n.line+1, k.Interface()))
   688  		return
   689  	}
   690  	out.SetMapIndex(k, v)
   691  }
   692  
   693  func (d *decoder) mappingSlice(n *node, out reflect.Value) (good bool) {
   694  	outt := out.Type()
   695  	if outt.Elem() != mapItemType {
   696  		d.terror(n, yaml_MAP_TAG, out)
   697  		return false
   698  	}
   699  
   700  	mapType := d.mapType
   701  	d.mapType = outt
   702  
   703  	var slice []MapItem
   704  	var l = len(n.children)
   705  	for i := 0; i < l; i += 2 {
   706  		if isMerge(n.children[i]) {
   707  			d.merge(n.children[i+1], out)
   708  			continue
   709  		}
   710  		item := MapItem{}
   711  		k := reflect.ValueOf(&item.Key).Elem()
   712  		if d.unmarshal(n.children[i], k) {
   713  			v := reflect.ValueOf(&item.Value).Elem()
   714  			if d.unmarshal(n.children[i+1], v) {
   715  				slice = append(slice, item)
   716  			}
   717  		}
   718  	}
   719  	out.Set(reflect.ValueOf(slice))
   720  	d.mapType = mapType
   721  	return true
   722  }
   723  
   724  func (d *decoder) mappingStruct(n *node, out reflect.Value) (good bool) {
   725  	sinfo, err := getStructInfo(out.Type())
   726  	if err != nil {
   727  		panic(err)
   728  	}
   729  	name := settableValueOf("")
   730  	l := len(n.children)
   731  
   732  	var inlineMap reflect.Value
   733  	var elemType reflect.Type
   734  	if sinfo.InlineMap != -1 {
   735  		inlineMap = out.Field(sinfo.InlineMap)
   736  		inlineMap.Set(reflect.New(inlineMap.Type()).Elem())
   737  		elemType = inlineMap.Type().Elem()
   738  	}
   739  
   740  	var doneFields []bool
   741  	if d.strict {
   742  		doneFields = make([]bool, len(sinfo.FieldsList))
   743  	}
   744  	for i := 0; i < l; i += 2 {
   745  		ni := n.children[i]
   746  		if isMerge(ni) {
   747  			d.merge(n.children[i+1], out)
   748  			continue
   749  		}
   750  		if !d.unmarshal(ni, name) {
   751  			continue
   752  		}
   753  		if info, ok := sinfo.FieldsMap[name.String()]; ok {
   754  			if d.strict {
   755  				if doneFields[info.Id] {
   756  					d.terrors = append(d.terrors, fmt.Sprintf("line %d: field %s already set in type %s", ni.line+1, name.String(), out.Type()))
   757  					continue
   758  				}
   759  				doneFields[info.Id] = true
   760  			}
   761  			var field reflect.Value
   762  			if info.Inline == nil {
   763  				field = out.Field(info.Num)
   764  			} else {
   765  				field = out.FieldByIndex(info.Inline)
   766  			}
   767  			d.unmarshal(n.children[i+1], field)
   768  		} else if sinfo.InlineMap != -1 {
   769  			if inlineMap.IsNil() {
   770  				inlineMap.Set(reflect.MakeMap(inlineMap.Type()))
   771  			}
   772  			value := reflect.New(elemType).Elem()
   773  			d.unmarshal(n.children[i+1], value)
   774  			d.setMapIndex(n.children[i+1], inlineMap, name, value)
   775  		} else if d.strict {
   776  			d.terrors = append(d.terrors, fmt.Sprintf("line %d: field %s not found in type %s", ni.line+1, name.String(), out.Type()))
   777  		}
   778  	}
   779  	return true
   780  }
   781  
   782  func failWantMap() {
   783  	failf("map merge requires map or sequence of maps as the value")
   784  }
   785  
   786  func (d *decoder) merge(n *node, out reflect.Value) {
   787  	switch n.kind {
   788  	case mappingNode:
   789  		d.unmarshal(n, out)
   790  	case aliasNode:
   791  		if n.alias != nil && n.alias.kind != mappingNode {
   792  			failWantMap()
   793  		}
   794  		d.unmarshal(n, out)
   795  	case sequenceNode:
   796  		// Step backwards as earlier nodes take precedence.
   797  		for i := len(n.children) - 1; i >= 0; i-- {
   798  			ni := n.children[i]
   799  			if ni.kind == aliasNode {
   800  				if ni.alias != nil && ni.alias.kind != mappingNode {
   801  					failWantMap()
   802  				}
   803  			} else if ni.kind != mappingNode {
   804  				failWantMap()
   805  			}
   806  			d.unmarshal(ni, out)
   807  		}
   808  	default:
   809  		failWantMap()
   810  	}
   811  }
   812  
   813  func isMerge(n *node) bool {
   814  	return n.kind == scalarNode && n.value == "<<" && (n.implicit == true || n.tag == yaml_MERGE_TAG)
   815  }
   816
View as plain text