niki/vendor/gopkg.in/yaml.v3/decode.go

//

// Copyright (c) 2011-2019 Canonical Ltd

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//     http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

package yaml

import (
	"encoding"
	"encoding/base64"
	"fmt"
	"io"
	"math"
	"reflect"
	"strconv"
	"time"
)

// ----------------------------------------------------------------------------

// Parser, produces a node tree out of a libyaml event stream.

type parser struct {
	parser yaml_parser_t

	event yaml_event_t

	doc *Node

	anchors map[string]*Node

	doneInit bool

	textless bool
}

func newParser(b []byte) *parser {

	p := parser{}

	if !yaml_parser_initialize(&p.parser) {

		panic("failed to initialize YAML emitter")

	}

	if len(b) == 0 {

		b = []byte{'\n'}

	}

	yaml_parser_set_input_string(&p.parser, b)

	return &p

}

func newParserFromReader(r io.Reader) *parser {

	p := parser{}

	if !yaml_parser_initialize(&p.parser) {

		panic("failed to initialize YAML emitter")

	}

	yaml_parser_set_input_reader(&p.parser, r)

	return &p

}

func (p *parser) init() {

	if p.doneInit {

		return

	}

	p.anchors = make(map[string]*Node)

	p.expect(yaml_STREAM_START_EVENT)

	p.doneInit = true

}

func (p *parser) destroy() {

	if p.event.typ != yaml_NO_EVENT {

		yaml_event_delete(&p.event)

	}

	yaml_parser_delete(&p.parser)

}

// expect consumes an event from the event stream and

// checks that it's of the expected type.

func (p *parser) expect(e yaml_event_type_t) {

	if p.event.typ == yaml_NO_EVENT {

		if !yaml_parser_parse(&p.parser, &p.event) {

			p.fail()

		}

	}

	if p.event.typ == yaml_STREAM_END_EVENT {

		failf("attempted to go past the end of stream; corrupted value?")

	}

	if p.event.typ != e {

		p.parser.problem = fmt.Sprintf("expected %s event but got %s", e, p.event.typ)

		p.fail()

	}

	yaml_event_delete(&p.event)

	p.event.typ = yaml_NO_EVENT

}

// peek peeks at the next event in the event stream,

// puts the results into p.event and returns the event type.

func (p *parser) peek() yaml_event_type_t {

	if p.event.typ != yaml_NO_EVENT {

		return p.event.typ

	}

	// It's curious choice from the underlying API to generally return a

	// positive result on success, but on this case return true in an error

	// scenario. This was the source of bugs in the past (issue #666).

	if !yaml_parser_parse(&p.parser, &p.event) || p.parser.error != yaml_NO_ERROR {

		p.fail()

	}

	return p.event.typ

}

func (p *parser) fail() {

	var where string

	var line int

	if p.parser.context_mark.line != 0 {

		line = p.parser.context_mark.line

		// Scanner errors don't iterate line before returning error

		if p.parser.error == yaml_SCANNER_ERROR {

			line++

		}

	} else if p.parser.problem_mark.line != 0 {

		line = p.parser.problem_mark.line

		// Scanner errors don't iterate line before returning error

		if p.parser.error == yaml_SCANNER_ERROR {

			line++

		}

	}

	if line != 0 {

		where = "line " + strconv.Itoa(line) + ": "

	}

	var msg string

	if len(p.parser.problem) > 0 {

		msg = p.parser.problem

	} else {

		msg = "unknown problem parsing YAML content"

	}

	failf("%s%s", where, msg)

}

func (p *parser) anchor(n *Node, anchor []byte) {

	if anchor != nil {

		n.Anchor = string(anchor)

		p.anchors[n.Anchor] = n

	}

}

func (p *parser) parse() *Node {

	p.init()

	switch p.peek() {

	case yaml_SCALAR_EVENT:

		return p.scalar()

	case yaml_ALIAS_EVENT:

		return p.alias()

	case yaml_MAPPING_START_EVENT:

		return p.mapping()

	case yaml_SEQUENCE_START_EVENT:

		return p.sequence()

	case yaml_DOCUMENT_START_EVENT:

		return p.document()

	case yaml_STREAM_END_EVENT:

		// Happens when attempting to decode an empty buffer.

		return nil

	case yaml_TAIL_COMMENT_EVENT:

		panic("internal error: unexpected tail comment event (please report)")

	default:

		panic("internal error: attempted to parse unknown event (please report): " + p.event.typ.String())

	}

}

func (p *parser) node(kind Kind, defaultTag, tag, value string) *Node {

	var style Style

	if tag != "" && tag != "!" {

		tag = shortTag(tag)

		style = TaggedStyle

	} else if defaultTag != "" {

		tag = defaultTag

	} else if kind == ScalarNode {

		tag, _ = resolve("", value)

	}

	n := &Node{

		Kind: kind,

		Tag: tag,

		Value: value,

		Style: style,
	}

	if !p.textless {

		n.Line = p.event.start_mark.line + 1

		n.Column = p.event.start_mark.column + 1

		n.HeadComment = string(p.event.head_comment)

		n.LineComment = string(p.event.line_comment)

		n.FootComment = string(p.event.foot_comment)

	}

	return n

}

func (p *parser) parseChild(parent *Node) *Node {

	child := p.parse()

	parent.Content = append(parent.Content, child)

	return child

}

func (p *parser) document() *Node {

	n := p.node(DocumentNode, "", "", "")

	p.doc = n

	p.expect(yaml_DOCUMENT_START_EVENT)

	p.parseChild(n)

	if p.peek() == yaml_DOCUMENT_END_EVENT {

		n.FootComment = string(p.event.foot_comment)

	}

	p.expect(yaml_DOCUMENT_END_EVENT)

	return n

}

func (p *parser) alias() *Node {

	n := p.node(AliasNode, "", "", string(p.event.anchor))

	n.Alias = p.anchors[n.Value]

	if n.Alias == nil {

		failf("unknown anchor '%s' referenced", n.Value)

	}

	p.expect(yaml_ALIAS_EVENT)

	return n

}

func (p *parser) scalar() *Node {

	var parsedStyle = p.event.scalar_style()

	var nodeStyle Style

	switch {

	case parsedStyle&yaml_DOUBLE_QUOTED_SCALAR_STYLE != 0:

		nodeStyle = DoubleQuotedStyle

	case parsedStyle&yaml_SINGLE_QUOTED_SCALAR_STYLE != 0:

		nodeStyle = SingleQuotedStyle

	case parsedStyle&yaml_LITERAL_SCALAR_STYLE != 0:

		nodeStyle = LiteralStyle

	case parsedStyle&yaml_FOLDED_SCALAR_STYLE != 0:

		nodeStyle = FoldedStyle

	}

	var nodeValue = string(p.event.value)

	var nodeTag = string(p.event.tag)

	var defaultTag string

	if nodeStyle == 0 {

		if nodeValue == "<<" {

			defaultTag = mergeTag

		}

	} else {

		defaultTag = strTag

	}

	n := p.node(ScalarNode, defaultTag, nodeTag, nodeValue)

	n.Style |= nodeStyle

	p.anchor(n, p.event.anchor)

	p.expect(yaml_SCALAR_EVENT)

	return n

}

func (p *parser) sequence() *Node {

	n := p.node(SequenceNode, seqTag, string(p.event.tag), "")

	if p.event.sequence_style()&yaml_FLOW_SEQUENCE_STYLE != 0 {

		n.Style |= FlowStyle

	}

	p.anchor(n, p.event.anchor)

	p.expect(yaml_SEQUENCE_START_EVENT)

	for p.peek() != yaml_SEQUENCE_END_EVENT {

		p.parseChild(n)

	}

	n.LineComment = string(p.event.line_comment)

	n.FootComment = string(p.event.foot_comment)

	p.expect(yaml_SEQUENCE_END_EVENT)

	return n

}

func (p *parser) mapping() *Node {

	n := p.node(MappingNode, mapTag, string(p.event.tag), "")

	block := true

	if p.event.mapping_style()&yaml_FLOW_MAPPING_STYLE != 0 {

		block = false

		n.Style |= FlowStyle

	}

	p.anchor(n, p.event.anchor)

	p.expect(yaml_MAPPING_START_EVENT)

	for p.peek() != yaml_MAPPING_END_EVENT {

		k := p.parseChild(n)

		if block && k.FootComment != "" {

			// Must be a foot comment for the prior value when being dedented.

			if len(n.Content) > 2 {

				n.Content[len(n.Content)-3].FootComment = k.FootComment

				k.FootComment = ""

			}

		}

		v := p.parseChild(n)

		if k.FootComment == "" && v.FootComment != "" {

			k.FootComment = v.FootComment

			v.FootComment = ""

		}

		if p.peek() == yaml_TAIL_COMMENT_EVENT {

			if k.FootComment == "" {

				k.FootComment = string(p.event.foot_comment)

			}

			p.expect(yaml_TAIL_COMMENT_EVENT)

		}

	}

	n.LineComment = string(p.event.line_comment)

	n.FootComment = string(p.event.foot_comment)

	if n.Style&FlowStyle == 0 && n.FootComment != "" && len(n.Content) > 1 {

		n.Content[len(n.Content)-2].FootComment = n.FootComment

		n.FootComment = ""

	}

	p.expect(yaml_MAPPING_END_EVENT)

	return n

}

// ----------------------------------------------------------------------------

// Decoder, unmarshals a node into a provided value.

type decoder struct {
	doc *Node

	aliases map[*Node]bool

	terrors []string

	stringMapType reflect.Type

	generalMapType reflect.Type

	knownFields bool

	uniqueKeys bool

	decodeCount int

	aliasCount int

	aliasDepth int

	mergedFields map[interface{}]bool
}

var (
	nodeType = reflect.TypeOf(Node{})

	durationType = reflect.TypeOf(time.Duration(0))

	stringMapType = reflect.TypeOf(map[string]interface{}{})

	generalMapType = reflect.TypeOf(map[interface{}]interface{}{})

	ifaceType = generalMapType.Elem()

	timeType = reflect.TypeOf(time.Time{})

	ptrTimeType = reflect.TypeOf(&time.Time{})
)

func newDecoder() *decoder {

	d := &decoder{

		stringMapType: stringMapType,

		generalMapType: generalMapType,

		uniqueKeys: true,
	}

	d.aliases = make(map[*Node]bool)

	return d

}

func (d *decoder) terror(n *Node, tag string, out reflect.Value) {

	if n.Tag != "" {

		tag = n.Tag

	}

	value := n.Value

	if tag != seqTag && tag != mapTag {

		if len(value) > 10 {

			value = " `" + value[:7] + "...`"

		} else {

			value = " `" + value + "`"

		}

	}

	d.terrors = append(d.terrors, fmt.Sprintf("line %d: cannot unmarshal %s%s into %s", n.Line, shortTag(tag), value, out.Type()))

}

func (d *decoder) callUnmarshaler(n *Node, u Unmarshaler) (good bool) {

	err := u.UnmarshalYAML(n)

	if e, ok := err.(*TypeError); ok {

		d.terrors = append(d.terrors, e.Errors...)

		return false

	}

	if err != nil {

		fail(err)

	}

	return true

}

func (d *decoder) callObsoleteUnmarshaler(n *Node, u obsoleteUnmarshaler) (good bool) {

	terrlen := len(d.terrors)

	err := u.UnmarshalYAML(func(v interface{}) (err error) {

		defer handleErr(&err)

		d.unmarshal(n, reflect.ValueOf(v))

		if len(d.terrors) > terrlen {

			issues := d.terrors[terrlen:]

			d.terrors = d.terrors[:terrlen]

			return &TypeError{issues}

		}

		return nil

	})

	if e, ok := err.(*TypeError); ok {

		d.terrors = append(d.terrors, e.Errors...)

		return false

	}

	if err != nil {

		fail(err)

	}

	return true

}

// d.prepare initializes and dereferences pointers and calls UnmarshalYAML

// if a value is found to implement it.

// It returns the initialized and dereferenced out value, whether

// unmarshalling was already done by UnmarshalYAML, and if so whether

// its types unmarshalled appropriately.

//

// If n holds a null value, prepare returns before doing anything.

func (d *decoder) prepare(n *Node, out reflect.Value) (newout reflect.Value, unmarshaled, good bool) {

	if n.ShortTag() == nullTag {

		return out, false, false

	}

	again := true

	for again {

		again = false

		if out.Kind() == reflect.Ptr {

			if out.IsNil() {

				out.Set(reflect.New(out.Type().Elem()))

			}

			out = out.Elem()

			again = true

		}

		if out.CanAddr() {

			outi := out.Addr().Interface()

			if u, ok := outi.(Unmarshaler); ok {

				good = d.callUnmarshaler(n, u)

				return out, true, good

			}

			if u, ok := outi.(obsoleteUnmarshaler); ok {

				good = d.callObsoleteUnmarshaler(n, u)

				return out, true, good

			}

		}

	}

	return out, false, false

}

func (d *decoder) fieldByIndex(n *Node, v reflect.Value, index []int) (field reflect.Value) {

	if n.ShortTag() == nullTag {

		return reflect.Value{}

	}

	for _, num := range index {

		for {

			if v.Kind() == reflect.Ptr {

				if v.IsNil() {

					v.Set(reflect.New(v.Type().Elem()))

				}

				v = v.Elem()

				continue

			}

			break

		}

		v = v.Field(num)

	}

	return v

}

const (

	// 400,000 decode operations is ~500kb of dense object declarations, or

	// ~5kb of dense object declarations with 10000% alias expansion

	alias_ratio_range_low = 400000

	// 4,000,000 decode operations is ~5MB of dense object declarations, or

	// ~4.5MB of dense object declarations with 10% alias expansion

	alias_ratio_range_high = 4000000

	// alias_ratio_range is the range over which we scale allowed alias ratios

	alias_ratio_range = float64(alias_ratio_range_high - alias_ratio_range_low)
)

func allowedAliasRatio(decodeCount int) float64 {

	switch {

	case decodeCount <= alias_ratio_range_low:

		// allow 99% to come from alias expansion for small-to-medium documents

		return 0.99

	case decodeCount >= alias_ratio_range_high:

		// allow 10% to come from alias expansion for very large documents

		return 0.10

	default:

		// scale smoothly from 99% down to 10% over the range.

		// this maps to 396,000 - 400,000 allowed alias-driven decodes over the range.

		// 400,000 decode operations is ~100MB of allocations in worst-case scenarios (single-item maps).

		return 0.99 - 0.89*(float64(decodeCount-alias_ratio_range_low)/alias_ratio_range)

	}

}

func (d *decoder) unmarshal(n *Node, out reflect.Value) (good bool) {

	d.decodeCount++

	if d.aliasDepth > 0 {

		d.aliasCount++

	}

	if d.aliasCount > 100 && d.decodeCount > 1000 && float64(d.aliasCount)/float64(d.decodeCount) > allowedAliasRatio(d.decodeCount) {

		failf("document contains excessive aliasing")

	}

	if out.Type() == nodeType {

		out.Set(reflect.ValueOf(n).Elem())

		return true

	}

	switch n.Kind {

	case DocumentNode:

		return d.document(n, out)

	case AliasNode:

		return d.alias(n, out)

	}

	out, unmarshaled, good := d.prepare(n, out)

	if unmarshaled {

		return good

	}

	switch n.Kind {

	case ScalarNode:

		good = d.scalar(n, out)

	case MappingNode:

		good = d.mapping(n, out)

	case SequenceNode:

		good = d.sequence(n, out)

	case 0:

		if n.IsZero() {

			return d.null(out)

		}

		fallthrough

	default:

		failf("cannot decode node with unknown kind %d", n.Kind)

	}

	return good

}

func (d *decoder) document(n *Node, out reflect.Value) (good bool) {

	if len(n.Content) == 1 {

		d.doc = n

		d.unmarshal(n.Content[0], out)

		return true

	}

	return false

}

func (d *decoder) alias(n *Node, out reflect.Value) (good bool) {

	if d.aliases[n] {

		// TODO this could actually be allowed in some circumstances.

		failf("anchor '%s' value contains itself", n.Value)

	}

	d.aliases[n] = true

	d.aliasDepth++

	good = d.unmarshal(n.Alias, out)

	d.aliasDepth--

	delete(d.aliases, n)

	return good

}

var zeroValue reflect.Value

func resetMap(out reflect.Value) {

	for _, k := range out.MapKeys() {

		out.SetMapIndex(k, zeroValue)

	}

}

func (d *decoder) null(out reflect.Value) bool {

	if out.CanAddr() {

		switch out.Kind() {

		case reflect.Interface, reflect.Ptr, reflect.Map, reflect.Slice:

			out.Set(reflect.Zero(out.Type()))

			return true

		}

	}

	return false

}

func (d *decoder) scalar(n *Node, out reflect.Value) bool {

	var tag string

	var resolved interface{}

	if n.indicatedString() {

		tag = strTag

		resolved = n.Value

	} else {

		tag, resolved = resolve(n.Tag, n.Value)

		if tag == binaryTag {

			data, err := base64.StdEncoding.DecodeString(resolved.(string))

			if err != nil {

				failf("!!binary value contains invalid base64 data")

			}

			resolved = string(data)

		}

	}

	if resolved == nil {

		return d.null(out)

	}

	if resolvedv := reflect.ValueOf(resolved); out.Type() == resolvedv.Type() {

		// We've resolved to exactly the type we want, so use that.

		out.Set(resolvedv)

		return true

	}

	// Perhaps we can use the value as a TextUnmarshaler to

	// set its value.

	if out.CanAddr() {

		u, ok := out.Addr().Interface().(encoding.TextUnmarshaler)

		if ok {

			var text []byte

			if tag == binaryTag {

				text = []byte(resolved.(string))

			} else {

				// We let any value be unmarshaled into TextUnmarshaler.

				// That might be more lax than we'd like, but the

				// TextUnmarshaler itself should bowl out any dubious values.

				text = []byte(n.Value)

			}

			err := u.UnmarshalText(text)

			if err != nil {

				fail(err)

			}

			return true

		}

	}

	switch out.Kind() {

	case reflect.String:

		if tag == binaryTag {

			out.SetString(resolved.(string))

			return true

		}

		out.SetString(n.Value)

		return true

	case reflect.Interface:

		out.Set(reflect.ValueOf(resolved))

		return true

	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:

		// This used to work in v2, but it's very unfriendly.

		isDuration := out.Type() == durationType

		switch resolved := resolved.(type) {

		case int:

			if !isDuration && !out.OverflowInt(int64(resolved)) {

				out.SetInt(int64(resolved))

				return true

			}

		case int64:

			if !isDuration && !out.OverflowInt(resolved) {

				out.SetInt(resolved)

				return true

			}

		case uint64:

			if !isDuration && resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) {

				out.SetInt(int64(resolved))

				return true

			}

		case float64:

			if !isDuration && resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) {

				out.SetInt(int64(resolved))

				return true

			}

		case string:

			if out.Type() == durationType {

				d, err := time.ParseDuration(resolved)

				if err == nil {

					out.SetInt(int64(d))

					return true

				}

			}

		}

	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:

		switch resolved := resolved.(type) {

		case int:

			if resolved >= 0 && !out.OverflowUint(uint64(resolved)) {

				out.SetUint(uint64(resolved))

				return true

			}

		case int64:

			if resolved >= 0 && !out.OverflowUint(uint64(resolved)) {

				out.SetUint(uint64(resolved))

				return true

			}

		case uint64:

			if !out.OverflowUint(uint64(resolved)) {

				out.SetUint(uint64(resolved))

				return true

			}

		case float64:

			if resolved <= math.MaxUint64 && !out.OverflowUint(uint64(resolved)) {

				out.SetUint(uint64(resolved))

				return true

			}

		}

	case reflect.Bool:

		switch resolved := resolved.(type) {

		case bool:

			out.SetBool(resolved)

			return true

		case string:

			// This offers some compatibility with the 1.1 spec (https://yaml.org/type/bool.html).

			// It only works if explicitly attempting to unmarshal into a typed bool value.

			switch resolved {

			case "y", "Y", "yes", "Yes", "YES", "on", "On", "ON":

				out.SetBool(true)

				return true

			case "n", "N", "no", "No", "NO", "off", "Off", "OFF":

				out.SetBool(false)

				return true

			}

		}

	case reflect.Float32, reflect.Float64:

		switch resolved := resolved.(type) {

		case int:

			out.SetFloat(float64(resolved))

			return true

		case int64:

			out.SetFloat(float64(resolved))

			return true

		case uint64:

			out.SetFloat(float64(resolved))

			return true

		case float64:

			out.SetFloat(resolved)

			return true

		}

	case reflect.Struct:

		if resolvedv := reflect.ValueOf(resolved); out.Type() == resolvedv.Type() {

			out.Set(resolvedv)

			return true

		}

	case reflect.Ptr:

		panic("yaml internal error: please report the issue")

	}

	d.terror(n, tag, out)

	return false

}

func settableValueOf(i interface{}) reflect.Value {

	v := reflect.ValueOf(i)

	sv := reflect.New(v.Type()).Elem()

	sv.Set(v)

	return sv

}

func (d *decoder) sequence(n *Node, out reflect.Value) (good bool) {

	l := len(n.Content)

	var iface reflect.Value

	switch out.Kind() {

	case reflect.Slice:

		out.Set(reflect.MakeSlice(out.Type(), l, l))

	case reflect.Array:

		if l != out.Len() {

			failf("invalid array: want %d elements but got %d", out.Len(), l)

		}

	case reflect.Interface:

		// No type hints. Will have to use a generic sequence.

		iface = out

		out = settableValueOf(make([]interface{}, l))

	default:

		d.terror(n, seqTag, out)

		return false

	}

	et := out.Type().Elem()

	j := 0

	for i := 0; i < l; i++ {

		e := reflect.New(et).Elem()

		if ok := d.unmarshal(n.Content[i], e); ok {

			out.Index(j).Set(e)

			j++

		}

	}

	if out.Kind() != reflect.Array {

		out.Set(out.Slice(0, j))

	}

	if iface.IsValid() {

		iface.Set(out)

	}

	return true

}

func (d *decoder) mapping(n *Node, out reflect.Value) (good bool) {

	l := len(n.Content)

	if d.uniqueKeys {

		nerrs := len(d.terrors)

		for i := 0; i < l; i += 2 {

			ni := n.Content[i]

			for j := i + 2; j < l; j += 2 {

				nj := n.Content[j]

				if ni.Kind == nj.Kind && ni.Value == nj.Value {

					d.terrors = append(d.terrors, fmt.Sprintf("line %d: mapping key %#v already defined at line %d", nj.Line, nj.Value, ni.Line))

				}

			}

		}

		if len(d.terrors) > nerrs {

			return false

		}

	}

	switch out.Kind() {

	case reflect.Struct:

		return d.mappingStruct(n, out)

	case reflect.Map:

		// okay

	case reflect.Interface:

		iface := out

		if isStringMap(n) {

			out = reflect.MakeMap(d.stringMapType)

		} else {

			out = reflect.MakeMap(d.generalMapType)

		}

		iface.Set(out)

	default:

		d.terror(n, mapTag, out)

		return false

	}

	outt := out.Type()

	kt := outt.Key()

	et := outt.Elem()

	stringMapType := d.stringMapType

	generalMapType := d.generalMapType

	if outt.Elem() == ifaceType {

		if outt.Key().Kind() == reflect.String {

			d.stringMapType = outt

		} else if outt.Key() == ifaceType {

			d.generalMapType = outt

		}

	}

	mergedFields := d.mergedFields

	d.mergedFields = nil

	var mergeNode *Node

	mapIsNew := false

	if out.IsNil() {

		out.Set(reflect.MakeMap(outt))

		mapIsNew = true

	}

	for i := 0; i < l; i += 2 {

		if isMerge(n.Content[i]) {

			mergeNode = n.Content[i+1]

			continue

		}

		k := reflect.New(kt).Elem()

		if d.unmarshal(n.Content[i], k) {

			if mergedFields != nil {

				ki := k.Interface()

				if mergedFields[ki] {

					continue

				}

				mergedFields[ki] = true

			}

			kkind := k.Kind()

			if kkind == reflect.Interface {

				kkind = k.Elem().Kind()

			}

			if kkind == reflect.Map || kkind == reflect.Slice {

				failf("invalid map key: %#v", k.Interface())

			}

			e := reflect.New(et).Elem()

			if d.unmarshal(n.Content[i+1], e) || n.Content[i+1].ShortTag() == nullTag && (mapIsNew || !out.MapIndex(k).IsValid()) {

				out.SetMapIndex(k, e)

			}

		}

	}

	d.mergedFields = mergedFields

	if mergeNode != nil {

		d.merge(n, mergeNode, out)

	}

	d.stringMapType = stringMapType

	d.generalMapType = generalMapType

	return true

}

func isStringMap(n *Node) bool {

	if n.Kind != MappingNode {

		return false

	}

	l := len(n.Content)

	for i := 0; i < l; i += 2 {

		shortTag := n.Content[i].ShortTag()

		if shortTag != strTag && shortTag != mergeTag {

			return false

		}

	}

	return true

}

func (d *decoder) mappingStruct(n *Node, out reflect.Value) (good bool) {

	sinfo, err := getStructInfo(out.Type())

	if err != nil {

		panic(err)

	}

	var inlineMap reflect.Value

	var elemType reflect.Type

	if sinfo.InlineMap != -1 {

		inlineMap = out.Field(sinfo.InlineMap)

		elemType = inlineMap.Type().Elem()

	}

	for _, index := range sinfo.InlineUnmarshalers {

		field := d.fieldByIndex(n, out, index)

		d.prepare(n, field)

	}

	mergedFields := d.mergedFields

	d.mergedFields = nil

	var mergeNode *Node

	var doneFields []bool

	if d.uniqueKeys {

		doneFields = make([]bool, len(sinfo.FieldsList))

	}

	name := settableValueOf("")

	l := len(n.Content)

	for i := 0; i < l; i += 2 {

		ni := n.Content[i]

		if isMerge(ni) {

			mergeNode = n.Content[i+1]

			continue

		}

		if !d.unmarshal(ni, name) {

			continue

		}

		sname := name.String()

		if mergedFields != nil {

			if mergedFields[sname] {

				continue

			}

			mergedFields[sname] = true

		}

		if info, ok := sinfo.FieldsMap[sname]; ok {

			if d.uniqueKeys {

				if doneFields[info.Id] {

					d.terrors = append(d.terrors, fmt.Sprintf("line %d: field %s already set in type %s", ni.Line, name.String(), out.Type()))

					continue

				}

				doneFields[info.Id] = true

			}

			var field reflect.Value

			if info.Inline == nil {

				field = out.Field(info.Num)

			} else {

				field = d.fieldByIndex(n, out, info.Inline)

			}

			d.unmarshal(n.Content[i+1], field)

		} else if sinfo.InlineMap != -1 {

			if inlineMap.IsNil() {

				inlineMap.Set(reflect.MakeMap(inlineMap.Type()))

			}

			value := reflect.New(elemType).Elem()

			d.unmarshal(n.Content[i+1], value)

			inlineMap.SetMapIndex(name, value)

		} else if d.knownFields {

			d.terrors = append(d.terrors, fmt.Sprintf("line %d: field %s not found in type %s", ni.Line, name.String(), out.Type()))

		}

	}

	d.mergedFields = mergedFields

	if mergeNode != nil {

		d.merge(n, mergeNode, out)

	}

	return true

}

func failWantMap() {

	failf("map merge requires map or sequence of maps as the value")

}

func (d *decoder) merge(parent *Node, merge *Node, out reflect.Value) {

	mergedFields := d.mergedFields

	if mergedFields == nil {

		d.mergedFields = make(map[interface{}]bool)

		for i := 0; i < len(parent.Content); i += 2 {

			k := reflect.New(ifaceType).Elem()

			if d.unmarshal(parent.Content[i], k) {

				d.mergedFields[k.Interface()] = true

			}

		}

	}

	switch merge.Kind {

	case MappingNode:

		d.unmarshal(merge, out)

	case AliasNode:

		if merge.Alias != nil && merge.Alias.Kind != MappingNode {

			failWantMap()

		}

		d.unmarshal(merge, out)

	case SequenceNode:

		for i := 0; i < len(merge.Content); i++ {

			ni := merge.Content[i]

			if ni.Kind == AliasNode {

				if ni.Alias != nil && ni.Alias.Kind != MappingNode {

					failWantMap()

				}

			} else if ni.Kind != MappingNode {

				failWantMap()

			}

			d.unmarshal(ni, out)

		}

	default:

		failWantMap()

	}

	d.mergedFields = mergedFields

}

func isMerge(n *Node) bool {

	return n.Kind == ScalarNode && n.Value == "<<" && (n.Tag == "" || n.Tag == "!" || shortTag(n.Tag) == mergeTag)

}