|
74
|
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 }
|
