gopkg.in/yaml.v3/encode.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"
        "fmt"
        "io"
        "reflect"
        "regexp"
        "sort"
        "strconv"
        "strings"
        "time"
        "unicode/utf8"
)

type encoder struct {
        emitter  yaml_emitter_t
        event    yaml_event_t
        out      []byte
        flow     bool
        indent   int
        doneInit bool
}

func newEncoder() *encoder {
        e := &encoder{}
        yaml_emitter_initialize(&e.emitter)
        yaml_emitter_set_output_string(&e.emitter, &e.out)
        yaml_emitter_set_unicode(&e.emitter, true)
        return e
}

func newEncoderWithWriter(w io.Writer) *encoder {
        e := &encoder{}
        yaml_emitter_initialize(&e.emitter)
        yaml_emitter_set_output_writer(&e.emitter, w)
        yaml_emitter_set_unicode(&e.emitter, true)
        return e
}

func (e *encoder) init() {
        if e.doneInit {
                return
        }
        if e.indent == 0 {
                e.indent = 4
        }
        e.emitter.best_indent = e.indent
        yaml_stream_start_event_initialize(&e.event, yaml_UTF8_ENCODING)
        e.emit()
        e.doneInit = true
}

func (e *encoder) finish() {
        e.emitter.open_ended = false
        yaml_stream_end_event_initialize(&e.event)
        e.emit()
}

func (e *encoder) destroy() {
        yaml_emitter_delete(&e.emitter)
}

func (e *encoder) emit() {
        // This will internally delete the e.event value.
        e.must(yaml_emitter_emit(&e.emitter, &e.event))
}

func (e *encoder) must(ok bool) {
        if !ok {
                msg := e.emitter.problem
                if msg == "" {
                        msg = "unknown problem generating YAML content"
                }
                failf("%s", msg)
        }
}

func (e *encoder) marshalDoc(tag string, in reflect.Value) {
        e.init()
        var node *Node
        if in.IsValid() {
                node, _ = in.Interface().(*Node)
        }
        if node != nil && node.Kind == DocumentNode {
                e.nodev(in)
        } else {
                yaml_document_start_event_initialize(&e.event, nil, nil, true)
                e.emit()
                e.marshal(tag, in)
                yaml_document_end_event_initialize(&e.event, true)
                e.emit()
        }
}

func (e *encoder) marshal(tag string, in reflect.Value) {
        tag = shortTag(tag)
        if !in.IsValid() || in.Kind() == reflect.Ptr && in.IsNil() {
                e.nilv()
                return
        }
        iface := in.Interface()
        switch value := iface.(type) {
        case *Node:
                e.nodev(in)
                return
        case Node:
                if !in.CanAddr() {
                        var n = reflect.New(in.Type()).Elem()
                        n.Set(in)
                        in = n
                }
                e.nodev(in.Addr())
                return
        case time.Time:
                e.timev(tag, in)
                return
        case *time.Time:
                e.timev(tag, in.Elem())
                return
        case time.Duration:
                e.stringv(tag, reflect.ValueOf(value.String()))
                return
        case Marshaler:
                v, err := value.MarshalYAML()
                if err != nil {
                        fail(err)
                }
                if v == nil {
                        e.nilv()
                        return
                }
                e.marshal(tag, reflect.ValueOf(v))
                return
        case encoding.TextMarshaler:
                text, err := value.MarshalText()
                if err != nil {
                        fail(err)
                }
                in = reflect.ValueOf(string(text))
        case nil:
                e.nilv()
                return
        }
        switch in.Kind() {
        case reflect.Interface:
                e.marshal(tag, in.Elem())
        case reflect.Map:
                e.mapv(tag, in)
        case reflect.Ptr:
                e.marshal(tag, in.Elem())
        case reflect.Struct:
                e.structv(tag, in)
        case reflect.Slice, reflect.Array:
                e.slicev(tag, in)
        case reflect.String:
                e.stringv(tag, in)
        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
                e.intv(tag, in)
        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
                e.uintv(tag, in)
        case reflect.Float32, reflect.Float64:
                e.floatv(tag, in)
        case reflect.Bool:
                e.boolv(tag, in)
        default:
                panic("cannot marshal type: " + in.Type().String())
        }
}

func (e *encoder) mapv(tag string, in reflect.Value) {
        e.mappingv(tag, func() {
                keys := keyList(in.MapKeys())
                sort.Sort(keys)
                for _, k := range keys {
                        e.marshal("", k)
                        e.marshal("", in.MapIndex(k))
                }
        })
}

func (e *encoder) fieldByIndex(v reflect.Value, index []int) (field reflect.Value) {
        for _, num := range index {
                for {
                        if v.Kind() == reflect.Ptr {
                                if v.IsNil() {
                                        return reflect.Value{}
                                }
                                v = v.Elem()
                                continue
                        }
                        break
                }
                v = v.Field(num)
        }
        return v
}

func (e *encoder) structv(tag string, in reflect.Value) {
        sinfo, err := getStructInfo(in.Type())
        if err != nil {
                panic(err)
        }
        e.mappingv(tag, func() {
                for _, info := range sinfo.FieldsList {
                        var value reflect.Value
                        if info.Inline == nil {
                                value = in.Field(info.Num)
                        } else {
                                value = e.fieldByIndex(in, info.Inline)
                                if !value.IsValid() {
                                        continue
                                }
                        }
                        if info.OmitEmpty && isZero(value) {
                                continue
                        }
                        e.marshal("", reflect.ValueOf(info.Key))
                        e.flow = info.Flow
                        e.marshal("", value)
                }
                if sinfo.InlineMap >= 0 {
                        m := in.Field(sinfo.InlineMap)
                        if m.Len() > 0 {
                                e.flow = false
                                keys := keyList(m.MapKeys())
                                sort.Sort(keys)
                                for _, k := range keys {
                                        if _, found := sinfo.FieldsMap[k.String()]; found {
                                                panic(fmt.Sprintf("cannot have key %q in inlined map: conflicts with struct field", k.String()))
                                        }
                                        e.marshal("", k)
                                        e.flow = false
                                        e.marshal("", m.MapIndex(k))
                                }
                        }
                }
        })
}

func (e *encoder) mappingv(tag string, f func()) {
        implicit := tag == ""
        style := yaml_BLOCK_MAPPING_STYLE
        if e.flow {
                e.flow = false
                style = yaml_FLOW_MAPPING_STYLE
        }
        yaml_mapping_start_event_initialize(&e.event, nil, []byte(tag), implicit, style)
        e.emit()
        f()
        yaml_mapping_end_event_initialize(&e.event)
        e.emit()
}

func (e *encoder) slicev(tag string, in reflect.Value) {
        implicit := tag == ""
        style := yaml_BLOCK_SEQUENCE_STYLE
        if e.flow {
                e.flow = false
                style = yaml_FLOW_SEQUENCE_STYLE
        }
        e.must(yaml_sequence_start_event_initialize(&e.event, nil, []byte(tag), implicit, style))
        e.emit()
        n := in.Len()
        for i := 0; i < n; i++ {
                e.marshal("", in.Index(i))
        }
        e.must(yaml_sequence_end_event_initialize(&e.event))
        e.emit()
}

// isBase60 returns whether s is in base 60 notation as defined in YAML 1.1.
//
// The base 60 float notation in YAML 1.1 is a terrible idea and is unsupported
// in YAML 1.2 and by this package, but these should be marshalled quoted for
// the time being for compatibility with other parsers.
func isBase60Float(s string) (result bool) {
        // Fast path.
        if s == "" {
                return false
        }
        c := s[0]
        if !(c == '+' || c == '-' || c >= '0' && c <= '9') || strings.IndexByte(s, ':') < 0 {
                return false
        }
        // Do the full match.
        return base60float.MatchString(s)
}

// From http://yaml.org/type/float.html, except the regular expression there
// is bogus. In practice parsers do not enforce the "\.[0-9_]*" suffix.
var base60float = regexp.MustCompile(`^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+(?:\.[0-9_]*)?$`)

// isOldBool returns whether s is bool notation as defined in YAML 1.1.
//
// We continue to force strings that YAML 1.1 would interpret as booleans to be
// rendered as quotes strings so that the marshalled output valid for YAML 1.1
// parsing.
func isOldBool(s string) (result bool) {
        switch s {
        case "y", "Y", "yes", "Yes", "YES", "on", "On", "ON",
                "n", "N", "no", "No", "NO", "off", "Off", "OFF":
                return true
        default:
                return false
        }
}

func (e *encoder) stringv(tag string, in reflect.Value) {
        var style yaml_scalar_style_t
        s := in.String()
        canUsePlain := true
        switch {
        case !utf8.ValidString(s):
                if tag == binaryTag {
                        failf("explicitly tagged !!binary data must be base64-encoded")
                }
                if tag != "" {
                        failf("cannot marshal invalid UTF-8 data as %s", shortTag(tag))
                }
                // It can't be encoded directly as YAML so use a binary tag
                // and encode it as base64.
                tag = binaryTag
                s = encodeBase64(s)
        case tag == "":
                // Check to see if it would resolve to a specific
                // tag when encoded unquoted. If it doesn't,
                // there's no need to quote it.
                rtag, _ := resolve("", s)
                canUsePlain = rtag == strTag && !(isBase60Float(s) || isOldBool(s))
        }
        // Note: it's possible for user code to emit invalid YAML
        // if they explicitly specify a tag and a string containing
        // text that's incompatible with that tag.
        switch {
        case strings.Contains(s, "\n"):
                if e.flow {
                        style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
                } else {
                        style = yaml_LITERAL_SCALAR_STYLE
                }
        case canUsePlain:
                style = yaml_PLAIN_SCALAR_STYLE
        default:
                style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
        }
        e.emitScalar(s, "", tag, style, nil, nil, nil, nil)
}

func (e *encoder) boolv(tag string, in reflect.Value) {
        var s string
        if in.Bool() {
                s = "true"
        } else {
                s = "false"
        }
        e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
}

func (e *encoder) intv(tag string, in reflect.Value) {
        s := strconv.FormatInt(in.Int(), 10)
        e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
}

func (e *encoder) uintv(tag string, in reflect.Value) {
        s := strconv.FormatUint(in.Uint(), 10)
        e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
}

func (e *encoder) timev(tag string, in reflect.Value) {
        t := in.Interface().(time.Time)
        s := t.Format(time.RFC3339Nano)
        e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
}

func (e *encoder) floatv(tag string, in reflect.Value) {
        // Issue #352: When formatting, use the precision of the underlying value
        precision := 64
        if in.Kind() == reflect.Float32 {
                precision = 32
        }

        s := strconv.FormatFloat(in.Float(), 'g', -1, precision)
        switch s {
        case "+Inf":
                s = ".inf"
        case "-Inf":
                s = "-.inf"
        case "NaN":
                s = ".nan"
        }
        e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
}

func (e *encoder) nilv() {
        e.emitScalar("null", "", "", yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
}

func (e *encoder) emitScalar(value, anchor, tag string, style yaml_scalar_style_t, head, line, foot, tail []byte) {
        // TODO Kill this function. Replace all initialize calls by their underlining Go literals.
        implicit := tag == ""
        if !implicit {
                tag = longTag(tag)
        }
        e.must(yaml_scalar_event_initialize(&e.event, []byte(anchor), []byte(tag), []byte(value), implicit, implicit, style))
        e.event.head_comment = head
        e.event.line_comment = line
        e.event.foot_comment = foot
        e.event.tail_comment = tail
        e.emit()
}

func (e *encoder) nodev(in reflect.Value) {
        e.node(in.Interface().(*Node), "")
}

func (e *encoder) node(node *Node, tail string) {
        // Zero nodes behave as nil.
        if node.Kind == 0 && node.IsZero() {
                e.nilv()
                return
        }

        // If the tag was not explicitly requested, and dropping it won't change the
        // implicit tag of the value, don't include it in the presentation.
        var tag = node.Tag
        var stag = shortTag(tag)
        var forceQuoting bool
        if tag != "" && node.Style&TaggedStyle == 0 {
                if node.Kind == ScalarNode {
                        if stag == strTag && node.Style&(SingleQuotedStyle|DoubleQuotedStyle|LiteralStyle|FoldedStyle) != 0 {
                                tag = ""
                        } else {
                                rtag, _ := resolve("", node.Value)
                                if rtag == stag {
                                        tag = ""
                                } else if stag == strTag {
                                        tag = ""
                                        forceQuoting = true
                                }
                        }
                } else {
                        var rtag string
                        switch node.Kind {
                        case MappingNode:
                                rtag = mapTag
                        case SequenceNode:
                                rtag = seqTag
                        }
                        if rtag == stag {
                                tag = ""
                        }
                }
        }

        switch node.Kind {
        case DocumentNode:
                yaml_document_start_event_initialize(&e.event, nil, nil, true)
                e.event.head_comment = []byte(node.HeadComment)
                e.emit()
                for _, node := range node.Content {
                        e.node(node, "")
                }
                yaml_document_end_event_initialize(&e.event, true)
                e.event.foot_comment = []byte(node.FootComment)
                e.emit()

        case SequenceNode:
                style := yaml_BLOCK_SEQUENCE_STYLE
                if node.Style&FlowStyle != 0 {
                        style = yaml_FLOW_SEQUENCE_STYLE
                }
                e.must(yaml_sequence_start_event_initialize(&e.event, []byte(node.Anchor), []byte(longTag(tag)), tag == "", style))
                e.event.head_comment = []byte(node.HeadComment)
                e.emit()
                for _, node := range node.Content {
                        e.node(node, "")
                }
                e.must(yaml_sequence_end_event_initialize(&e.event))
                e.event.line_comment = []byte(node.LineComment)
                e.event.foot_comment = []byte(node.FootComment)
                e.emit()

        case MappingNode:
                style := yaml_BLOCK_MAPPING_STYLE
                if node.Style&FlowStyle != 0 {
                        style = yaml_FLOW_MAPPING_STYLE
                }
                yaml_mapping_start_event_initialize(&e.event, []byte(node.Anchor), []byte(longTag(tag)), tag == "", style)
                e.event.tail_comment = []byte(tail)
                e.event.head_comment = []byte(node.HeadComment)
                e.emit()

                // The tail logic below moves the foot comment of prior keys to the following key,
                // since the value for each key may be a nested structure and the foot needs to be
                // processed only the entirety of the value is streamed. The last tail is processed
                // with the mapping end event.
                var tail string
                for i := 0; i+1 < len(node.Content); i += 2 {
                        k := node.Content[i]
                        foot := k.FootComment
                        if foot != "" {
                                kopy := *k
                                kopy.FootComment = ""
                                k = &kopy
                        }
                        e.node(k, tail)
                        tail = foot

                        v := node.Content[i+1]
                        e.node(v, "")
                }

                yaml_mapping_end_event_initialize(&e.event)
                e.event.tail_comment = []byte(tail)
                e.event.line_comment = []byte(node.LineComment)
                e.event.foot_comment = []byte(node.FootComment)
                e.emit()

        case AliasNode:
                yaml_alias_event_initialize(&e.event, []byte(node.Value))
                e.event.head_comment = []byte(node.HeadComment)
                e.event.line_comment = []byte(node.LineComment)
                e.event.foot_comment = []byte(node.FootComment)
                e.emit()

        case ScalarNode:
                value := node.Value
                if !utf8.ValidString(value) {
                        if stag == binaryTag {
                                failf("explicitly tagged !!binary data must be base64-encoded")
                        }
                        if stag != "" {
                                failf("cannot marshal invalid UTF-8 data as %s", stag)
                        }
                        // It can't be encoded directly as YAML so use a binary tag
                        // and encode it as base64.
                        tag = binaryTag
                        value = encodeBase64(value)
                }

                style := yaml_PLAIN_SCALAR_STYLE
                switch {
                case node.Style&DoubleQuotedStyle != 0:
                        style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
                case node.Style&SingleQuotedStyle != 0:
                        style = yaml_SINGLE_QUOTED_SCALAR_STYLE
                case node.Style&LiteralStyle != 0:
                        style = yaml_LITERAL_SCALAR_STYLE
                case node.Style&FoldedStyle != 0:
                        style = yaml_FOLDED_SCALAR_STYLE
                case strings.Contains(value, "\n"):
                        style = yaml_LITERAL_SCALAR_STYLE
                case forceQuoting:
                        style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
                }

                e.emitScalar(value, node.Anchor, tag, style, []byte(node.HeadComment), []byte(node.LineComment), []byte(node.FootComment), []byte(tail))
        default:
                failf("cannot encode node with unknown kind %d", node.Kind)
        }
}
1	yakumo_izuru	1.1	//
2			// Copyright (c) 2011-2019 Canonical Ltd
3			//
4			// Licensed under the Apache License, Version 2.0 (the "License");
5			// you may not use this file except in compliance with the License.
6			// You may obtain a copy of the License at
7			//
8			// http://www.apache.org/licenses/LICENSE-2.0
9			//
10			// Unless required by applicable law or agreed to in writing, software
11			// distributed under the License is distributed on an "AS IS" BASIS,
12			// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13			// See the License for the specific language governing permissions and
14			// limitations under the License.
15
16			package yaml
17
18			import (
19			"encoding"
20			"fmt"
21			"io"
22			"reflect"
23			"regexp"
24			"sort"
25			"strconv"
26			"strings"
27			"time"
28			"unicode/utf8"
29			)
30
31			type encoder struct {
32			emitter yaml_emitter_t
33			event yaml_event_t
34			out []byte
35			flow bool
36			indent int
37			doneInit bool
38			}
39
40			func newEncoder() *encoder {
41			e := &encoder{}
42			yaml_emitter_initialize(&e.emitter)
43			yaml_emitter_set_output_string(&e.emitter, &e.out)
44			yaml_emitter_set_unicode(&e.emitter, true)
45			return e
46			}
47
48			func newEncoderWithWriter(w io.Writer) *encoder {
49			e := &encoder{}
50			yaml_emitter_initialize(&e.emitter)
51			yaml_emitter_set_output_writer(&e.emitter, w)
52			yaml_emitter_set_unicode(&e.emitter, true)
53			return e
54			}
55
56			func (e *encoder) init() {
57			if e.doneInit {
58			return
59			}
60			if e.indent == 0 {
61			e.indent = 4
62			}
63			e.emitter.best_indent = e.indent
64			yaml_stream_start_event_initialize(&e.event, yaml_UTF8_ENCODING)
65			e.emit()
66			e.doneInit = true
67			}
68
69			func (e *encoder) finish() {
70			e.emitter.open_ended = false
71			yaml_stream_end_event_initialize(&e.event)
72			e.emit()
73			}
74
75			func (e *encoder) destroy() {
76			yaml_emitter_delete(&e.emitter)
77			}
78
79			func (e *encoder) emit() {
80			// This will internally delete the e.event value.
81			e.must(yaml_emitter_emit(&e.emitter, &e.event))
82			}
83
84			func (e *encoder) must(ok bool) {
85			if !ok {
86			msg := e.emitter.problem
87			if msg == "" {
88			msg = "unknown problem generating YAML content"
89			}
90			failf("%s", msg)
91			}
92			}
93
94			func (e *encoder) marshalDoc(tag string, in reflect.Value) {
95			e.init()
96			var node *Node
97			if in.IsValid() {
98			node, _ = in.Interface().(*Node)
99			}
100			if node != nil && node.Kind == DocumentNode {
101			e.nodev(in)
102			} else {
103			yaml_document_start_event_initialize(&e.event, nil, nil, true)
104			e.emit()
105			e.marshal(tag, in)
106			yaml_document_end_event_initialize(&e.event, true)
107			e.emit()
108			}
109			}
110
111			func (e *encoder) marshal(tag string, in reflect.Value) {
112			tag = shortTag(tag)
113			if !in.IsValid() \|\| in.Kind() == reflect.Ptr && in.IsNil() {
114			e.nilv()
115			return
116			}
117			iface := in.Interface()
118			switch value := iface.(type) {
119			case *Node:
120			e.nodev(in)
121			return
122			case Node:
123			if !in.CanAddr() {
124			var n = reflect.New(in.Type()).Elem()
125			n.Set(in)
126			in = n
127			}
128			e.nodev(in.Addr())
129			return
130			case time.Time:
131			e.timev(tag, in)
132			return
133			case *time.Time:
134			e.timev(tag, in.Elem())
135			return
136			case time.Duration:
137			e.stringv(tag, reflect.ValueOf(value.String()))
138			return
139			case Marshaler:
140			v, err := value.MarshalYAML()
141			if err != nil {
142			fail(err)
143			}
144			if v == nil {
145			e.nilv()
146			return
147			}
148			e.marshal(tag, reflect.ValueOf(v))
149			return
150			case encoding.TextMarshaler:
151			text, err := value.MarshalText()
152			if err != nil {
153			fail(err)
154			}
155			in = reflect.ValueOf(string(text))
156			case nil:
157			e.nilv()
158			return
159			}
160			switch in.Kind() {
161			case reflect.Interface:
162			e.marshal(tag, in.Elem())
163			case reflect.Map:
164			e.mapv(tag, in)
165			case reflect.Ptr:
166			e.marshal(tag, in.Elem())
167			case reflect.Struct:
168			e.structv(tag, in)
169			case reflect.Slice, reflect.Array:
170			e.slicev(tag, in)
171			case reflect.String:
172			e.stringv(tag, in)
173			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
174			e.intv(tag, in)
175			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
176			e.uintv(tag, in)
177			case reflect.Float32, reflect.Float64:
178			e.floatv(tag, in)
179			case reflect.Bool:
180			e.boolv(tag, in)
181			default:
182			panic("cannot marshal type: " + in.Type().String())
183			}
184			}
185
186			func (e *encoder) mapv(tag string, in reflect.Value) {
187			e.mappingv(tag, func() {
188			keys := keyList(in.MapKeys())
189			sort.Sort(keys)
190			for _, k := range keys {
191			e.marshal("", k)
192			e.marshal("", in.MapIndex(k))
193			}
194			})
195			}
196
197			func (e *encoder) fieldByIndex(v reflect.Value, index []int) (field reflect.Value) {
198			for _, num := range index {
199			for {
200			if v.Kind() == reflect.Ptr {
201			if v.IsNil() {
202			return reflect.Value{}
203			}
204			v = v.Elem()
205			continue
206			}
207			break
208			}
209			v = v.Field(num)
210			}
211			return v
212			}
213
214			func (e *encoder) structv(tag string, in reflect.Value) {
215			sinfo, err := getStructInfo(in.Type())
216			if err != nil {
217			panic(err)
218			}
219			e.mappingv(tag, func() {
220			for _, info := range sinfo.FieldsList {
221			var value reflect.Value
222			if info.Inline == nil {
223			value = in.Field(info.Num)
224			} else {
225			value = e.fieldByIndex(in, info.Inline)
226			if !value.IsValid() {
227			continue
228			}
229			}
230			if info.OmitEmpty && isZero(value) {
231			continue
232			}
233			e.marshal("", reflect.ValueOf(info.Key))
234			e.flow = info.Flow
235			e.marshal("", value)
236			}
237			if sinfo.InlineMap >= 0 {
238			m := in.Field(sinfo.InlineMap)
239			if m.Len() > 0 {
240			e.flow = false
241			keys := keyList(m.MapKeys())
242			sort.Sort(keys)
243			for _, k := range keys {
244			if _, found := sinfo.FieldsMap[k.String()]; found {
245			panic(fmt.Sprintf("cannot have key %q in inlined map: conflicts with struct field", k.String()))
246			}
247			e.marshal("", k)
248			e.flow = false
249			e.marshal("", m.MapIndex(k))
250			}
251			}
252			}
253			})
254			}
255
256			func (e *encoder) mappingv(tag string, f func()) {
257			implicit := tag == ""
258			style := yaml_BLOCK_MAPPING_STYLE
259			if e.flow {
260			e.flow = false
261			style = yaml_FLOW_MAPPING_STYLE
262			}
263			yaml_mapping_start_event_initialize(&e.event, nil, []byte(tag), implicit, style)
264			e.emit()
265			f()
266			yaml_mapping_end_event_initialize(&e.event)
267			e.emit()
268			}
269
270			func (e *encoder) slicev(tag string, in reflect.Value) {
271			implicit := tag == ""
272			style := yaml_BLOCK_SEQUENCE_STYLE
273			if e.flow {
274			e.flow = false
275			style = yaml_FLOW_SEQUENCE_STYLE
276			}
277			e.must(yaml_sequence_start_event_initialize(&e.event, nil, []byte(tag), implicit, style))
278			e.emit()
279			n := in.Len()
280			for i := 0; i < n; i++ {
281			e.marshal("", in.Index(i))
282			}
283			e.must(yaml_sequence_end_event_initialize(&e.event))
284			e.emit()
285			}
286
287			// isBase60 returns whether s is in base 60 notation as defined in YAML 1.1.
288			//
289			// The base 60 float notation in YAML 1.1 is a terrible idea and is unsupported
290			// in YAML 1.2 and by this package, but these should be marshalled quoted for
291			// the time being for compatibility with other parsers.
292			func isBase60Float(s string) (result bool) {
293			// Fast path.
294			if s == "" {
295			return false
296			}
297			c := s[0]
298			if !(c == '+' \|\| c == '-' \|\| c >= '0' && c <= '9') \|\| strings.IndexByte(s, ':') < 0 {
299			return false
300			}
301			// Do the full match.
302			return base60float.MatchString(s)
303			}
304
305			// From http://yaml.org/type/float.html, except the regular expression there
306			// is bogus. In practice parsers do not enforce the "\.[0-9_]*" suffix.
307			var base60float = regexp.MustCompile(`^[-+]?[0-9][0-9_](?::[0-5]?[0-9])+(?:\.[0-9_])?$`)
308
309			// isOldBool returns whether s is bool notation as defined in YAML 1.1.
310			//
311			// We continue to force strings that YAML 1.1 would interpret as booleans to be
312			// rendered as quotes strings so that the marshalled output valid for YAML 1.1
313			// parsing.
314			func isOldBool(s string) (result bool) {
315			switch s {
316			case "y", "Y", "yes", "Yes", "YES", "on", "On", "ON",
317			"n", "N", "no", "No", "NO", "off", "Off", "OFF":
318			return true
319			default:
320			return false
321			}
322			}
323
324			func (e *encoder) stringv(tag string, in reflect.Value) {
325			var style yaml_scalar_style_t
326			s := in.String()
327			canUsePlain := true
328			switch {
329			case !utf8.ValidString(s):
330			if tag == binaryTag {
331			failf("explicitly tagged !!binary data must be base64-encoded")
332			}
333			if tag != "" {
334			failf("cannot marshal invalid UTF-8 data as %s", shortTag(tag))
335			}
336			// It can't be encoded directly as YAML so use a binary tag
337			// and encode it as base64.
338			tag = binaryTag
339			s = encodeBase64(s)
340			case tag == "":
341			// Check to see if it would resolve to a specific
342			// tag when encoded unquoted. If it doesn't,
343			// there's no need to quote it.
344			rtag, _ := resolve("", s)
345			canUsePlain = rtag == strTag && !(isBase60Float(s) \|\| isOldBool(s))
346			}
347			// Note: it's possible for user code to emit invalid YAML
348			// if they explicitly specify a tag and a string containing
349			// text that's incompatible with that tag.
350			switch {
351			case strings.Contains(s, "\n"):
352			if e.flow {
353			style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
354			} else {
355			style = yaml_LITERAL_SCALAR_STYLE
356			}
357			case canUsePlain:
358			style = yaml_PLAIN_SCALAR_STYLE
359			default:
360			style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
361			}
362			e.emitScalar(s, "", tag, style, nil, nil, nil, nil)
363			}
364
365			func (e *encoder) boolv(tag string, in reflect.Value) {
366			var s string
367			if in.Bool() {
368			s = "true"
369			} else {
370			s = "false"
371			}
372			e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
373			}
374
375			func (e *encoder) intv(tag string, in reflect.Value) {
376			s := strconv.FormatInt(in.Int(), 10)
377			e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
378			}
379
380			func (e *encoder) uintv(tag string, in reflect.Value) {
381			s := strconv.FormatUint(in.Uint(), 10)
382			e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
383			}
384
385			func (e *encoder) timev(tag string, in reflect.Value) {
386			t := in.Interface().(time.Time)
387			s := t.Format(time.RFC3339Nano)
388			e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
389			}
390
391			func (e *encoder) floatv(tag string, in reflect.Value) {
392			// Issue #352: When formatting, use the precision of the underlying value
393			precision := 64
394			if in.Kind() == reflect.Float32 {
395			precision = 32
396			}
397
398			s := strconv.FormatFloat(in.Float(), 'g', -1, precision)
399			switch s {
400			case "+Inf":
401			s = ".inf"
402			case "-Inf":
403			s = "-.inf"
404			case "NaN":
405			s = ".nan"
406			}
407			e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
408			}
409
410			func (e *encoder) nilv() {
411			e.emitScalar("null", "", "", yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
412			}
413
414			func (e *encoder) emitScalar(value, anchor, tag string, style yaml_scalar_style_t, head, line, foot, tail []byte) {
415			// TODO Kill this function. Replace all initialize calls by their underlining Go literals.
416			implicit := tag == ""
417			if !implicit {
418			tag = longTag(tag)
419			}
420			e.must(yaml_scalar_event_initialize(&e.event, []byte(anchor), []byte(tag), []byte(value), implicit, implicit, style))
421			e.event.head_comment = head
422			e.event.line_comment = line
423			e.event.foot_comment = foot
424			e.event.tail_comment = tail
425			e.emit()
426			}
427
428			func (e *encoder) nodev(in reflect.Value) {
429			e.node(in.Interface().(*Node), "")
430			}
431
432			func (e encoder) node(node Node, tail string) {
433			// Zero nodes behave as nil.
434			if node.Kind == 0 && node.IsZero() {
435			e.nilv()
436			return
437			}
438
439			// If the tag was not explicitly requested, and dropping it won't change the
440			// implicit tag of the value, don't include it in the presentation.
441			var tag = node.Tag
442			var stag = shortTag(tag)
443			var forceQuoting bool
444			if tag != "" && node.Style&TaggedStyle == 0 {
445			if node.Kind == ScalarNode {
446			if stag == strTag && node.Style&(SingleQuotedStyle\|DoubleQuotedStyle\|LiteralStyle\|FoldedStyle) != 0 {
447			tag = ""
448			} else {
449			rtag, _ := resolve("", node.Value)
450			if rtag == stag {
451			tag = ""
452			} else if stag == strTag {
453			tag = ""
454			forceQuoting = true
455			}
456			}
457			} else {
458			var rtag string
459			switch node.Kind {
460			case MappingNode:
461			rtag = mapTag
462			case SequenceNode:
463			rtag = seqTag
464			}
465			if rtag == stag {
466			tag = ""
467			}
468			}
469			}
470
471			switch node.Kind {
472			case DocumentNode:
473			yaml_document_start_event_initialize(&e.event, nil, nil, true)
474			e.event.head_comment = []byte(node.HeadComment)
475			e.emit()
476			for _, node := range node.Content {
477			e.node(node, "")
478			}
479			yaml_document_end_event_initialize(&e.event, true)
480			e.event.foot_comment = []byte(node.FootComment)
481			e.emit()
482
483			case SequenceNode:
484			style := yaml_BLOCK_SEQUENCE_STYLE
485			if node.Style&FlowStyle != 0 {
486			style = yaml_FLOW_SEQUENCE_STYLE
487			}
488			e.must(yaml_sequence_start_event_initialize(&e.event, []byte(node.Anchor), []byte(longTag(tag)), tag == "", style))
489			e.event.head_comment = []byte(node.HeadComment)
490			e.emit()
491			for _, node := range node.Content {
492			e.node(node, "")
493			}
494			e.must(yaml_sequence_end_event_initialize(&e.event))
495			e.event.line_comment = []byte(node.LineComment)
496			e.event.foot_comment = []byte(node.FootComment)
497			e.emit()
498
499			case MappingNode:
500			style := yaml_BLOCK_MAPPING_STYLE
501			if node.Style&FlowStyle != 0 {
502			style = yaml_FLOW_MAPPING_STYLE
503			}
504			yaml_mapping_start_event_initialize(&e.event, []byte(node.Anchor), []byte(longTag(tag)), tag == "", style)
505			e.event.tail_comment = []byte(tail)
506			e.event.head_comment = []byte(node.HeadComment)
507			e.emit()
508
509			// The tail logic below moves the foot comment of prior keys to the following key,
510			// since the value for each key may be a nested structure and the foot needs to be
511			// processed only the entirety of the value is streamed. The last tail is processed
512			// with the mapping end event.
513			var tail string
514			for i := 0; i+1 < len(node.Content); i += 2 {
515			k := node.Content[i]
516			foot := k.FootComment
517			if foot != "" {
518			kopy := *k
519			kopy.FootComment = ""
520			k = &kopy
521			}
522			e.node(k, tail)
523			tail = foot
524
525			v := node.Content[i+1]
526			e.node(v, "")
527			}
528
529			yaml_mapping_end_event_initialize(&e.event)
530			e.event.tail_comment = []byte(tail)
531			e.event.line_comment = []byte(node.LineComment)
532			e.event.foot_comment = []byte(node.FootComment)
533			e.emit()
534
535			case AliasNode:
536			yaml_alias_event_initialize(&e.event, []byte(node.Value))
537			e.event.head_comment = []byte(node.HeadComment)
538			e.event.line_comment = []byte(node.LineComment)
539			e.event.foot_comment = []byte(node.FootComment)
540			e.emit()
541
542			case ScalarNode:
543			value := node.Value
544			if !utf8.ValidString(value) {
545			if stag == binaryTag {
546			failf("explicitly tagged !!binary data must be base64-encoded")
547			}
548			if stag != "" {
549			failf("cannot marshal invalid UTF-8 data as %s", stag)
550			}
551			// It can't be encoded directly as YAML so use a binary tag
552			// and encode it as base64.
553			tag = binaryTag
554			value = encodeBase64(value)
555			}
556
557			style := yaml_PLAIN_SCALAR_STYLE
558			switch {
559			case node.Style&DoubleQuotedStyle != 0:
560			style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
561			case node.Style&SingleQuotedStyle != 0:
562			style = yaml_SINGLE_QUOTED_SCALAR_STYLE
563			case node.Style&LiteralStyle != 0:
564			style = yaml_LITERAL_SCALAR_STYLE
565			case node.Style&FoldedStyle != 0:
566			style = yaml_FOLDED_SCALAR_STYLE
567			case strings.Contains(value, "\n"):
568			style = yaml_LITERAL_SCALAR_STYLE
569			case forceQuoting:
570			style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
571			}
572
573			e.emitScalar(value, node.Anchor, tag, style, []byte(node.HeadComment), []byte(node.LineComment), []byte(node.FootComment), []byte(tail))
574			default:
575			failf("cannot encode node with unknown kind %d", node.Kind)
576			}
577			}
nishi@chaotic.ninja	ViewVC Help
Powered by ViewVC 1.3.0-dev