567 lines
12 KiB
Go
567 lines
12 KiB
Go
package yaml
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"fmt"
|
|
"reflect"
|
|
"strconv"
|
|
"time"
|
|
)
|
|
|
|
const (
|
|
documentNode = 1 << iota
|
|
mappingNode
|
|
sequenceNode
|
|
scalarNode
|
|
aliasNode
|
|
)
|
|
|
|
type node struct {
|
|
kind int
|
|
line, column int
|
|
tag string
|
|
value string
|
|
implicit bool
|
|
children []*node
|
|
anchors map[string]*node
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Parser, produces a node tree out of a libyaml event stream.
|
|
|
|
type parser struct {
|
|
parser yaml_parser_t
|
|
event yaml_event_t
|
|
doc *node
|
|
}
|
|
|
|
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)
|
|
|
|
p.skip()
|
|
if p.event.typ != yaml_STREAM_START_EVENT {
|
|
panic("Expected stream start event, got " + strconv.Itoa(int(p.event.typ)))
|
|
}
|
|
p.skip()
|
|
return &p
|
|
}
|
|
|
|
func (p *parser) destroy() {
|
|
if p.event.typ != yaml_NO_EVENT {
|
|
yaml_event_delete(&p.event)
|
|
}
|
|
yaml_parser_delete(&p.parser)
|
|
}
|
|
|
|
func (p *parser) skip() {
|
|
if p.event.typ != yaml_NO_EVENT {
|
|
if p.event.typ == yaml_STREAM_END_EVENT {
|
|
fail("Attempted to go past the end of stream. Corrupted value?")
|
|
}
|
|
yaml_event_delete(&p.event)
|
|
}
|
|
if !yaml_parser_parse(&p.parser, &p.event) {
|
|
p.fail()
|
|
}
|
|
}
|
|
|
|
func (p *parser) fail() {
|
|
var where string
|
|
var line int
|
|
if p.parser.problem_mark.line != 0 {
|
|
line = p.parser.problem_mark.line
|
|
} else if p.parser.context_mark.line != 0 {
|
|
line = p.parser.context_mark.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"
|
|
}
|
|
fail(where + msg)
|
|
}
|
|
|
|
func (p *parser) anchor(n *node, anchor []byte) {
|
|
if anchor != nil {
|
|
p.doc.anchors[string(anchor)] = n
|
|
}
|
|
}
|
|
|
|
func (p *parser) parse() *node {
|
|
switch p.event.typ {
|
|
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
|
|
default:
|
|
panic("Attempted to parse unknown event: " + strconv.Itoa(int(p.event.typ)))
|
|
}
|
|
panic("unreachable")
|
|
}
|
|
|
|
func (p *parser) node(kind int) *node {
|
|
return &node{
|
|
kind: kind,
|
|
line: p.event.start_mark.line,
|
|
column: p.event.start_mark.column,
|
|
}
|
|
}
|
|
|
|
func (p *parser) document() *node {
|
|
n := p.node(documentNode)
|
|
n.anchors = make(map[string]*node)
|
|
p.doc = n
|
|
p.skip()
|
|
n.children = append(n.children, p.parse())
|
|
if p.event.typ != yaml_DOCUMENT_END_EVENT {
|
|
panic("Expected end of document event but got " + strconv.Itoa(int(p.event.typ)))
|
|
}
|
|
p.skip()
|
|
return n
|
|
}
|
|
|
|
func (p *parser) alias() *node {
|
|
n := p.node(aliasNode)
|
|
n.value = string(p.event.anchor)
|
|
p.skip()
|
|
return n
|
|
}
|
|
|
|
func (p *parser) scalar() *node {
|
|
n := p.node(scalarNode)
|
|
n.value = string(p.event.value)
|
|
n.tag = string(p.event.tag)
|
|
n.implicit = p.event.implicit
|
|
p.anchor(n, p.event.anchor)
|
|
p.skip()
|
|
return n
|
|
}
|
|
|
|
func (p *parser) sequence() *node {
|
|
n := p.node(sequenceNode)
|
|
p.anchor(n, p.event.anchor)
|
|
p.skip()
|
|
for p.event.typ != yaml_SEQUENCE_END_EVENT {
|
|
n.children = append(n.children, p.parse())
|
|
}
|
|
p.skip()
|
|
return n
|
|
}
|
|
|
|
func (p *parser) mapping() *node {
|
|
n := p.node(mappingNode)
|
|
p.anchor(n, p.event.anchor)
|
|
p.skip()
|
|
for p.event.typ != yaml_MAPPING_END_EVENT {
|
|
n.children = append(n.children, p.parse(), p.parse())
|
|
}
|
|
p.skip()
|
|
return n
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Decoder, unmarshals a node into a provided value.
|
|
|
|
type decoder struct {
|
|
doc *node
|
|
aliases map[string]bool
|
|
}
|
|
|
|
func newDecoder() *decoder {
|
|
d := &decoder{}
|
|
d.aliases = make(map[string]bool)
|
|
return d
|
|
}
|
|
|
|
// d.setter deals with setters and pointer dereferencing and initialization.
|
|
//
|
|
// It's a slightly convoluted case to handle properly:
|
|
//
|
|
// - nil pointers should be initialized, unless being set to nil
|
|
// - we don't know at this point yet what's the value to SetYAML() with.
|
|
// - we can't separate pointer deref/init and setter checking, because
|
|
// a setter may be found while going down a pointer chain.
|
|
//
|
|
// Thus, here is how it takes care of it:
|
|
//
|
|
// - out is provided as a pointer, so that it can be replaced.
|
|
// - when looking at a non-setter ptr, *out=ptr.Elem(), unless tag=!!null
|
|
// - when a setter is found, *out=interface{}, and a set() function is
|
|
// returned to call SetYAML() with the value of *out once it's defined.
|
|
//
|
|
func (d *decoder) setter(tag string, out *reflect.Value, good *bool) (set func()) {
|
|
if (*out).Kind() != reflect.Ptr && (*out).CanAddr() {
|
|
setter, _ := (*out).Addr().Interface().(Setter)
|
|
if setter != nil {
|
|
var arg interface{}
|
|
*out = reflect.ValueOf(&arg).Elem()
|
|
return func() {
|
|
*good = setter.SetYAML(shortTag(tag), arg)
|
|
}
|
|
}
|
|
}
|
|
again := true
|
|
for again {
|
|
again = false
|
|
setter, _ := (*out).Interface().(Setter)
|
|
if tag != yaml_NULL_TAG || setter != nil {
|
|
if pv := (*out); pv.Kind() == reflect.Ptr {
|
|
if pv.IsNil() {
|
|
*out = reflect.New(pv.Type().Elem()).Elem()
|
|
pv.Set((*out).Addr())
|
|
} else {
|
|
*out = pv.Elem()
|
|
}
|
|
setter, _ = pv.Interface().(Setter)
|
|
again = true
|
|
}
|
|
}
|
|
if setter != nil {
|
|
var arg interface{}
|
|
*out = reflect.ValueOf(&arg).Elem()
|
|
return func() {
|
|
*good = setter.SetYAML(shortTag(tag), arg)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (d *decoder) unmarshal(n *node, out reflect.Value) (good bool) {
|
|
switch n.kind {
|
|
case documentNode:
|
|
good = d.document(n, out)
|
|
case scalarNode:
|
|
good = d.scalar(n, out)
|
|
case aliasNode:
|
|
good = d.alias(n, out)
|
|
case mappingNode:
|
|
good = d.mapping(n, out)
|
|
case sequenceNode:
|
|
good = d.sequence(n, out)
|
|
default:
|
|
panic("Internal error: unknown node kind: " + strconv.Itoa(n.kind))
|
|
}
|
|
return
|
|
}
|
|
|
|
func (d *decoder) document(n *node, out reflect.Value) (good bool) {
|
|
if len(n.children) == 1 {
|
|
d.doc = n
|
|
d.unmarshal(n.children[0], out)
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (d *decoder) alias(n *node, out reflect.Value) (good bool) {
|
|
an, ok := d.doc.anchors[n.value]
|
|
if !ok {
|
|
fail("Unknown anchor '" + n.value + "' referenced")
|
|
}
|
|
if d.aliases[n.value] {
|
|
fail("Anchor '" + n.value + "' value contains itself")
|
|
}
|
|
d.aliases[n.value] = true
|
|
good = d.unmarshal(an, out)
|
|
delete(d.aliases, n.value)
|
|
return good
|
|
}
|
|
|
|
var zeroValue reflect.Value
|
|
|
|
func resetMap(out reflect.Value) {
|
|
for _, k := range out.MapKeys() {
|
|
out.SetMapIndex(k, zeroValue)
|
|
}
|
|
}
|
|
|
|
var durationType = reflect.TypeOf(time.Duration(0))
|
|
|
|
func (d *decoder) scalar(n *node, out reflect.Value) (good bool) {
|
|
var tag string
|
|
var resolved interface{}
|
|
if n.tag == "" && !n.implicit {
|
|
tag = yaml_STR_TAG
|
|
resolved = n.value
|
|
} else {
|
|
tag, resolved = resolve(n.tag, n.value)
|
|
if tag == yaml_BINARY_TAG {
|
|
data, err := base64.StdEncoding.DecodeString(resolved.(string))
|
|
if err != nil {
|
|
fail("!!binary value contains invalid base64 data")
|
|
}
|
|
resolved = string(data)
|
|
}
|
|
}
|
|
if set := d.setter(tag, &out, &good); set != nil {
|
|
defer set()
|
|
}
|
|
if resolved == nil {
|
|
if out.Kind() == reflect.Map && !out.CanAddr() {
|
|
resetMap(out)
|
|
} else {
|
|
out.Set(reflect.Zero(out.Type()))
|
|
}
|
|
good = true
|
|
return
|
|
}
|
|
switch out.Kind() {
|
|
case reflect.String:
|
|
if tag == yaml_BINARY_TAG {
|
|
out.SetString(resolved.(string))
|
|
good = true
|
|
} else if resolved != nil {
|
|
out.SetString(n.value)
|
|
good = true
|
|
}
|
|
case reflect.Interface:
|
|
if resolved == nil {
|
|
out.Set(reflect.Zero(out.Type()))
|
|
} else {
|
|
out.Set(reflect.ValueOf(resolved))
|
|
}
|
|
good = true
|
|
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
switch resolved := resolved.(type) {
|
|
case int:
|
|
if !out.OverflowInt(int64(resolved)) {
|
|
out.SetInt(int64(resolved))
|
|
good = true
|
|
}
|
|
case int64:
|
|
if !out.OverflowInt(resolved) {
|
|
out.SetInt(resolved)
|
|
good = true
|
|
}
|
|
case float64:
|
|
if resolved < 1<<63-1 && !out.OverflowInt(int64(resolved)) {
|
|
out.SetInt(int64(resolved))
|
|
good = true
|
|
}
|
|
case string:
|
|
if out.Type() == durationType {
|
|
d, err := time.ParseDuration(resolved)
|
|
if err == nil {
|
|
out.SetInt(int64(d))
|
|
good = true
|
|
}
|
|
}
|
|
}
|
|
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
|
switch resolved := resolved.(type) {
|
|
case int:
|
|
if resolved >= 0 {
|
|
out.SetUint(uint64(resolved))
|
|
good = true
|
|
}
|
|
case int64:
|
|
if resolved >= 0 {
|
|
out.SetUint(uint64(resolved))
|
|
good = true
|
|
}
|
|
case float64:
|
|
if resolved < 1<<64-1 && !out.OverflowUint(uint64(resolved)) {
|
|
out.SetUint(uint64(resolved))
|
|
good = true
|
|
}
|
|
}
|
|
case reflect.Bool:
|
|
switch resolved := resolved.(type) {
|
|
case bool:
|
|
out.SetBool(resolved)
|
|
good = true
|
|
}
|
|
case reflect.Float32, reflect.Float64:
|
|
switch resolved := resolved.(type) {
|
|
case int:
|
|
out.SetFloat(float64(resolved))
|
|
good = true
|
|
case int64:
|
|
out.SetFloat(float64(resolved))
|
|
good = true
|
|
case float64:
|
|
out.SetFloat(resolved)
|
|
good = true
|
|
}
|
|
case reflect.Ptr:
|
|
if out.Type().Elem() == reflect.TypeOf(resolved) {
|
|
elem := reflect.New(out.Type().Elem())
|
|
elem.Elem().Set(reflect.ValueOf(resolved))
|
|
out.Set(elem)
|
|
good = true
|
|
}
|
|
}
|
|
return good
|
|
}
|
|
|
|
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) {
|
|
if set := d.setter(yaml_SEQ_TAG, &out, &good); set != nil {
|
|
defer set()
|
|
}
|
|
var iface reflect.Value
|
|
if out.Kind() == reflect.Interface {
|
|
// No type hints. Will have to use a generic sequence.
|
|
iface = out
|
|
out = settableValueOf(make([]interface{}, 0))
|
|
}
|
|
|
|
if out.Kind() != reflect.Slice {
|
|
return false
|
|
}
|
|
et := out.Type().Elem()
|
|
|
|
l := len(n.children)
|
|
for i := 0; i < l; i++ {
|
|
e := reflect.New(et).Elem()
|
|
if ok := d.unmarshal(n.children[i], e); ok {
|
|
out.Set(reflect.Append(out, e))
|
|
}
|
|
}
|
|
if iface.IsValid() {
|
|
iface.Set(out)
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (d *decoder) mapping(n *node, out reflect.Value) (good bool) {
|
|
if set := d.setter(yaml_MAP_TAG, &out, &good); set != nil {
|
|
defer set()
|
|
}
|
|
if out.Kind() == reflect.Struct {
|
|
return d.mappingStruct(n, out)
|
|
}
|
|
|
|
if out.Kind() == reflect.Interface {
|
|
// No type hints. Will have to use a generic map.
|
|
iface := out
|
|
out = settableValueOf(make(map[interface{}]interface{}))
|
|
iface.Set(out)
|
|
}
|
|
|
|
if out.Kind() != reflect.Map {
|
|
return false
|
|
}
|
|
outt := out.Type()
|
|
kt := outt.Key()
|
|
et := outt.Elem()
|
|
|
|
if out.IsNil() {
|
|
out.Set(reflect.MakeMap(outt))
|
|
}
|
|
l := len(n.children)
|
|
for i := 0; i < l; i += 2 {
|
|
if isMerge(n.children[i]) {
|
|
d.merge(n.children[i+1], out)
|
|
continue
|
|
}
|
|
k := reflect.New(kt).Elem()
|
|
if d.unmarshal(n.children[i], k) {
|
|
kkind := k.Kind()
|
|
if kkind == reflect.Interface {
|
|
kkind = k.Elem().Kind()
|
|
}
|
|
if kkind == reflect.Map || kkind == reflect.Slice {
|
|
fail(fmt.Sprintf("invalid map key: %#v", k.Interface()))
|
|
}
|
|
e := reflect.New(et).Elem()
|
|
if d.unmarshal(n.children[i+1], e) {
|
|
out.SetMapIndex(k, e)
|
|
}
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (d *decoder) mappingStruct(n *node, out reflect.Value) (good bool) {
|
|
sinfo, err := getStructInfo(out.Type())
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
name := settableValueOf("")
|
|
l := len(n.children)
|
|
for i := 0; i < l; i += 2 {
|
|
ni := n.children[i]
|
|
if isMerge(ni) {
|
|
d.merge(n.children[i+1], out)
|
|
continue
|
|
}
|
|
if !d.unmarshal(ni, name) {
|
|
continue
|
|
}
|
|
if info, ok := sinfo.FieldsMap[name.String()]; ok {
|
|
var field reflect.Value
|
|
if info.Inline == nil {
|
|
field = out.Field(info.Num)
|
|
} else {
|
|
field = out.FieldByIndex(info.Inline)
|
|
}
|
|
d.unmarshal(n.children[i+1], field)
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (d *decoder) merge(n *node, out reflect.Value) {
|
|
const wantMap = "map merge requires map or sequence of maps as the value"
|
|
switch n.kind {
|
|
case mappingNode:
|
|
d.unmarshal(n, out)
|
|
case aliasNode:
|
|
an, ok := d.doc.anchors[n.value]
|
|
if ok && an.kind != mappingNode {
|
|
fail(wantMap)
|
|
}
|
|
d.unmarshal(n, out)
|
|
case sequenceNode:
|
|
// Step backwards as earlier nodes take precedence.
|
|
for i := len(n.children) - 1; i >= 0; i-- {
|
|
ni := n.children[i]
|
|
if ni.kind == aliasNode {
|
|
an, ok := d.doc.anchors[ni.value]
|
|
if ok && an.kind != mappingNode {
|
|
fail(wantMap)
|
|
}
|
|
} else if ni.kind != mappingNode {
|
|
fail(wantMap)
|
|
}
|
|
d.unmarshal(ni, out)
|
|
}
|
|
default:
|
|
fail(wantMap)
|
|
}
|
|
}
|
|
|
|
func isMerge(n *node) bool {
|
|
return n.kind == scalarNode && n.value == "<<" && (n.implicit == true || n.tag == yaml_MERGE_TAG)
|
|
}
|