1
//
2
// Copyright (c) 2011-2019 Canonical Ltd
3
// Copyright (c) 2006-2010 Kirill Simonov
4
//
5
// Permission is hereby granted, free of charge, to any person obtaining a copy of
6
// this software and associated documentation files (the "Software"), to deal in
7
// the Software without restriction, including without limitation the rights to
8
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
9
// of the Software, and to permit persons to whom the Software is furnished to do
10
// so, subject to the following conditions:
11
//
12
// The above copyright notice and this permission notice shall be included in all
13
// copies or substantial portions of the Software.
14
//
15
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21
// SOFTWARE.
22

23
package yaml
24

25
import (
26
	"bytes"
27
	"fmt"
28
)
29

30
// Flush the buffer if needed.
31
func flush(emitter *yaml_emitter_t) bool {
32
	if emitter.buffer_pos+5 >= len(emitter.buffer) {
33
		return yaml_emitter_flush(emitter)
34
	}
35
	return true
36
}
37

38
// Put a character to the output buffer.
39
func put(emitter *yaml_emitter_t, value byte) bool {
40
	if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
41
		return false
42
	}
43
	emitter.buffer[emitter.buffer_pos] = value
44
	emitter.buffer_pos++
45
	emitter.column++
46
	return true
47
}
48

49
// Put a line break to the output buffer.
50
func put_break(emitter *yaml_emitter_t) bool {
51
	if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
52
		return false
53
	}
54
	switch emitter.line_break {
55
	case yaml_CR_BREAK:
56
		emitter.buffer[emitter.buffer_pos] = '\r'
57
		emitter.buffer_pos += 1
58
	case yaml_LN_BREAK:
59
		emitter.buffer[emitter.buffer_pos] = '\n'
60
		emitter.buffer_pos += 1
61
	case yaml_CRLN_BREAK:
62
		emitter.buffer[emitter.buffer_pos+0] = '\r'
63
		emitter.buffer[emitter.buffer_pos+1] = '\n'
64
		emitter.buffer_pos += 2
65
	default:
66
		panic("unknown line break setting")
67
	}
68
	if emitter.column == 0 {
69
		emitter.space_above = true
70
	}
71
	emitter.column = 0
72
	emitter.line++
73
	// [Go] Do this here and below and drop from everywhere else (see commented lines).
74
	emitter.indention = true
75
	return true
76
}
77

78
// Copy a character from a string into buffer.
79
func write(emitter *yaml_emitter_t, s []byte, i *int) bool {
80
	if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
81
		return false
82
	}
83
	p := emitter.buffer_pos
84
	w := width(s[*i])
85
	switch w {
86
	case 4:
87
		emitter.buffer[p+3] = s[*i+3]
88
		fallthrough
89
	case 3:
90
		emitter.buffer[p+2] = s[*i+2]
91
		fallthrough
92
	case 2:
93
		emitter.buffer[p+1] = s[*i+1]
94
		fallthrough
95
	case 1:
96
		emitter.buffer[p+0] = s[*i+0]
97
	default:
98
		panic("unknown character width")
99
	}
100
	emitter.column++
101
	emitter.buffer_pos += w
102
	*i += w
103
	return true
104
}
105

106
// Write a whole string into buffer.
107
func write_all(emitter *yaml_emitter_t, s []byte) bool {
108
	for i := 0; i < len(s); {
109
		if !write(emitter, s, &i) {
110
			return false
111
		}
112
	}
113
	return true
114
}
115

116
// Copy a line break character from a string into buffer.
117
func write_break(emitter *yaml_emitter_t, s []byte, i *int) bool {
118
	if s[*i] == '\n' {
119
		if !put_break(emitter) {
120
			return false
121
		}
122
		*i++
123
	} else {
124
		if !write(emitter, s, i) {
125
			return false
126
		}
127
		if emitter.column == 0 {
128
			emitter.space_above = true
129
		}
130
		emitter.column = 0
131
		emitter.line++
132
		// [Go] Do this here and above and drop from everywhere else (see commented lines).
133
		emitter.indention = true
134
	}
135
	return true
136
}
137

138
// Set an emitter error and return false.
139
func yaml_emitter_set_emitter_error(emitter *yaml_emitter_t, problem string) bool {
140
	emitter.error = yaml_EMITTER_ERROR
141
	emitter.problem = problem
142
	return false
143
}
144

145
// Emit an event.
146
func yaml_emitter_emit(emitter *yaml_emitter_t, event *yaml_event_t) bool {
147
	emitter.events = append(emitter.events, *event)
148
	for !yaml_emitter_need_more_events(emitter) {
149
		event := &emitter.events[emitter.events_head]
150
		if !yaml_emitter_analyze_event(emitter, event) {
151
			return false
152
		}
153
		if !yaml_emitter_state_machine(emitter, event) {
154
			return false
155
		}
156
		yaml_event_delete(event)
157
		emitter.events_head++
158
	}
159
	return true
160
}
161

162
// Check if we need to accumulate more events before emitting.
163
//
164
// We accumulate extra
165
//  - 1 event for DOCUMENT-START
166
//  - 2 events for SEQUENCE-START
167
//  - 3 events for MAPPING-START
168
//
169
func yaml_emitter_need_more_events(emitter *yaml_emitter_t) bool {
170
	if emitter.events_head == len(emitter.events) {
171
		return true
172
	}
173
	var accumulate int
174
	switch emitter.events[emitter.events_head].typ {
175
	case yaml_DOCUMENT_START_EVENT:
176
		accumulate = 1
177
		break
178
	case yaml_SEQUENCE_START_EVENT:
179
		accumulate = 2
180
		break
181
	case yaml_MAPPING_START_EVENT:
182
		accumulate = 3
183
		break
184
	default:
185
		return false
186
	}
187
	if len(emitter.events)-emitter.events_head > accumulate {
188
		return false
189
	}
190
	var level int
191
	for i := emitter.events_head; i < len(emitter.events); i++ {
192
		switch emitter.events[i].typ {
193
		case yaml_STREAM_START_EVENT, yaml_DOCUMENT_START_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT:
194
			level++
195
		case yaml_STREAM_END_EVENT, yaml_DOCUMENT_END_EVENT, yaml_SEQUENCE_END_EVENT, yaml_MAPPING_END_EVENT:
196
			level--
197
		}
198
		if level == 0 {
199
			return false
200
		}
201
	}
202
	return true
203
}
204

205
// Append a directive to the directives stack.
206
func yaml_emitter_append_tag_directive(emitter *yaml_emitter_t, value *yaml_tag_directive_t, allow_duplicates bool) bool {
207
	for i := 0; i < len(emitter.tag_directives); i++ {
208
		if bytes.Equal(value.handle, emitter.tag_directives[i].handle) {
209
			if allow_duplicates {
210
				return true
211
			}
212
			return yaml_emitter_set_emitter_error(emitter, "duplicate %TAG directive")
213
		}
214
	}
215

216
	// [Go] Do we actually need to copy this given garbage collection
217
	// and the lack of deallocating destructors?
218
	tag_copy := yaml_tag_directive_t{
219
		handle: make([]byte, len(value.handle)),
220
		prefix: make([]byte, len(value.prefix)),
221
	}
222
	copy(tag_copy.handle, value.handle)
223
	copy(tag_copy.prefix, value.prefix)
224
	emitter.tag_directives = append(emitter.tag_directives, tag_copy)
225
	return true
226
}
227

228
// Increase the indentation level.
229
func yaml_emitter_increase_indent(emitter *yaml_emitter_t, flow, indentless bool) bool {
230
	emitter.indents = append(emitter.indents, emitter.indent)
231
	if emitter.indent < 0 {
232
		if flow {
233
			emitter.indent = emitter.best_indent
234
		} else {
235
			emitter.indent = 0
236
		}
237
	} else if !indentless {
238
		// [Go] This was changed so that indentations are more regular.
239
		if emitter.states[len(emitter.states)-1] == yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE {
240
			// The first indent inside a sequence will just skip the "- " indicator.
241
			emitter.indent += 2
242
		} else {
243
			// Everything else aligns to the chosen indentation.
244
			emitter.indent = emitter.best_indent*((emitter.indent+emitter.best_indent)/emitter.best_indent)
245
		}
246
	}
247
	return true
248
}
249

250
// State dispatcher.
251
func yaml_emitter_state_machine(emitter *yaml_emitter_t, event *yaml_event_t) bool {
252
	switch emitter.state {
253
	default:
254
	case yaml_EMIT_STREAM_START_STATE:
255
		return yaml_emitter_emit_stream_start(emitter, event)
256

257
	case yaml_EMIT_FIRST_DOCUMENT_START_STATE:
258
		return yaml_emitter_emit_document_start(emitter, event, true)
259

260
	case yaml_EMIT_DOCUMENT_START_STATE:
261
		return yaml_emitter_emit_document_start(emitter, event, false)
262

263
	case yaml_EMIT_DOCUMENT_CONTENT_STATE:
264
		return yaml_emitter_emit_document_content(emitter, event)
265

266
	case yaml_EMIT_DOCUMENT_END_STATE:
267
		return yaml_emitter_emit_document_end(emitter, event)
268

269
	case yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE:
270
		return yaml_emitter_emit_flow_sequence_item(emitter, event, true, false)
271

272
	case yaml_EMIT_FLOW_SEQUENCE_TRAIL_ITEM_STATE:
273
		return yaml_emitter_emit_flow_sequence_item(emitter, event, false, true)
274

275
	case yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE:
276
		return yaml_emitter_emit_flow_sequence_item(emitter, event, false, false)
277

278
	case yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE:
279
		return yaml_emitter_emit_flow_mapping_key(emitter, event, true, false)
280

281
	case yaml_EMIT_FLOW_MAPPING_TRAIL_KEY_STATE:
282
		return yaml_emitter_emit_flow_mapping_key(emitter, event, false, true)
283

284
	case yaml_EMIT_FLOW_MAPPING_KEY_STATE:
285
		return yaml_emitter_emit_flow_mapping_key(emitter, event, false, false)
286

287
	case yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE:
288
		return yaml_emitter_emit_flow_mapping_value(emitter, event, true)
289

290
	case yaml_EMIT_FLOW_MAPPING_VALUE_STATE:
291
		return yaml_emitter_emit_flow_mapping_value(emitter, event, false)
292

293
	case yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE:
294
		return yaml_emitter_emit_block_sequence_item(emitter, event, true)
295

296
	case yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE:
297
		return yaml_emitter_emit_block_sequence_item(emitter, event, false)
298

299
	case yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE:
300
		return yaml_emitter_emit_block_mapping_key(emitter, event, true)
301

302
	case yaml_EMIT_BLOCK_MAPPING_KEY_STATE:
303
		return yaml_emitter_emit_block_mapping_key(emitter, event, false)
304

305
	case yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE:
306
		return yaml_emitter_emit_block_mapping_value(emitter, event, true)
307

308
	case yaml_EMIT_BLOCK_MAPPING_VALUE_STATE:
309
		return yaml_emitter_emit_block_mapping_value(emitter, event, false)
310

311
	case yaml_EMIT_END_STATE:
312
		return yaml_emitter_set_emitter_error(emitter, "expected nothing after STREAM-END")
313
	}
314
	panic("invalid emitter state")
315
}
316

317
// Expect STREAM-START.
318
func yaml_emitter_emit_stream_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {
319
	if event.typ != yaml_STREAM_START_EVENT {
320
		return yaml_emitter_set_emitter_error(emitter, "expected STREAM-START")
321
	}
322
	if emitter.encoding == yaml_ANY_ENCODING {
323
		emitter.encoding = event.encoding
324
		if emitter.encoding == yaml_ANY_ENCODING {
325
			emitter.encoding = yaml_UTF8_ENCODING
326
		}
327
	}
328
	if emitter.best_indent < 2 || emitter.best_indent > 9 {
329
		emitter.best_indent = 2
330
	}
331
	if emitter.best_width >= 0 && emitter.best_width <= emitter.best_indent*2 {
332
		emitter.best_width = 80
333
	}
334
	if emitter.best_width < 0 {
335
		emitter.best_width = 1<<31 - 1
336
	}
337
	if emitter.line_break == yaml_ANY_BREAK {
338
		emitter.line_break = yaml_LN_BREAK
339
	}
340

341
	emitter.indent = -1
342
	emitter.line = 0
343
	emitter.column = 0
344
	emitter.whitespace = true
345
	emitter.indention = true
346
	emitter.space_above = true
347
	emitter.foot_indent = -1
348

349
	if emitter.encoding != yaml_UTF8_ENCODING {
350
		if !yaml_emitter_write_bom(emitter) {
351
			return false
352
		}
353
	}
354
	emitter.state = yaml_EMIT_FIRST_DOCUMENT_START_STATE
355
	return true
356
}
357

358
// Expect DOCUMENT-START or STREAM-END.
359
func yaml_emitter_emit_document_start(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
360

361
	if event.typ == yaml_DOCUMENT_START_EVENT {
362

363
		if event.version_directive != nil {
364
			if !yaml_emitter_analyze_version_directive(emitter, event.version_directive) {
365
				return false
366
			}
367
		}
368

369
		for i := 0; i < len(event.tag_directives); i++ {
370
			tag_directive := &event.tag_directives[i]
371
			if !yaml_emitter_analyze_tag_directive(emitter, tag_directive) {
372
				return false
373
			}
374
			if !yaml_emitter_append_tag_directive(emitter, tag_directive, false) {
375
				return false
376
			}
377
		}
378

379
		for i := 0; i < len(default_tag_directives); i++ {
380
			tag_directive := &default_tag_directives[i]
381
			if !yaml_emitter_append_tag_directive(emitter, tag_directive, true) {
382
				return false
383
			}
384
		}
385

386
		implicit := event.implicit
387
		if !first || emitter.canonical {
388
			implicit = false
389
		}
390

391
		if emitter.open_ended && (event.version_directive != nil || len(event.tag_directives) > 0) {
392
			if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
393
				return false
394
			}
395
			if !yaml_emitter_write_indent(emitter) {
396
				return false
397
			}
398
		}
399

400
		if event.version_directive != nil {
401
			implicit = false
402
			if !yaml_emitter_write_indicator(emitter, []byte("%YAML"), true, false, false) {
403
				return false
404
			}
405
			if !yaml_emitter_write_indicator(emitter, []byte("1.1"), true, false, false) {
406
				return false
407
			}
408
			if !yaml_emitter_write_indent(emitter) {
409
				return false
410
			}
411
		}
412

413
		if len(event.tag_directives) > 0 {
414
			implicit = false
415
			for i := 0; i < len(event.tag_directives); i++ {
416
				tag_directive := &event.tag_directives[i]
417
				if !yaml_emitter_write_indicator(emitter, []byte("%TAG"), true, false, false) {
418
					return false
419
				}
420
				if !yaml_emitter_write_tag_handle(emitter, tag_directive.handle) {
421
					return false
422
				}
423
				if !yaml_emitter_write_tag_content(emitter, tag_directive.prefix, true) {
424
					return false
425
				}
426
				if !yaml_emitter_write_indent(emitter) {
427
					return false
428
				}
429
			}
430
		}
431

432
		if yaml_emitter_check_empty_document(emitter) {
433
			implicit = false
434
		}
435
		if !implicit {
436
			if !yaml_emitter_write_indent(emitter) {
437
				return false
438
			}
439
			if !yaml_emitter_write_indicator(emitter, []byte("---"), true, false, false) {
440
				return false
441
			}
442
			if emitter.canonical || true {
443
				if !yaml_emitter_write_indent(emitter) {
444
					return false
445
				}
446
			}
447
		}
448

449
		if len(emitter.head_comment) > 0 {
450
			if !yaml_emitter_process_head_comment(emitter) {
451
				return false
452
			}
453
			if !put_break(emitter) {
454
				return false
455
			}
456
		}
457

458
		emitter.state = yaml_EMIT_DOCUMENT_CONTENT_STATE
459
		return true
460
	}
461

462
	if event.typ == yaml_STREAM_END_EVENT {
463
		if emitter.open_ended {
464
			if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
465
				return false
466
			}
467
			if !yaml_emitter_write_indent(emitter) {
468
				return false
469
			}
470
		}
471
		if !yaml_emitter_flush(emitter) {
472
			return false
473
		}
474
		emitter.state = yaml_EMIT_END_STATE
475
		return true
476
	}
477

478
	return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-START or STREAM-END")
479
}
480

481
// Expect the root node.
482
func yaml_emitter_emit_document_content(emitter *yaml_emitter_t, event *yaml_event_t) bool {
483
	emitter.states = append(emitter.states, yaml_EMIT_DOCUMENT_END_STATE)
484

485
	if !yaml_emitter_process_head_comment(emitter) {
486
		return false
487
	}
488
	if !yaml_emitter_emit_node(emitter, event, true, false, false, false) {
489
		return false
490
	}
491
	if !yaml_emitter_process_line_comment(emitter) {
492
		return false
493
	}
494
	if !yaml_emitter_process_foot_comment(emitter) {
495
		return false
496
	}
497
	return true
498
}
499

500
// Expect DOCUMENT-END.
501
func yaml_emitter_emit_document_end(emitter *yaml_emitter_t, event *yaml_event_t) bool {
502
	if event.typ != yaml_DOCUMENT_END_EVENT {
503
		return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-END")
504
	}
505
	// [Go] Force document foot separation.
506
	emitter.foot_indent = 0
507
	if !yaml_emitter_process_foot_comment(emitter) {
508
		return false
509
	}
510
	emitter.foot_indent = -1
511
	if !yaml_emitter_write_indent(emitter) {
512
		return false
513
	}
514
	if !event.implicit {
515
		// [Go] Allocate the slice elsewhere.
516
		if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
517
			return false
518
		}
519
		if !yaml_emitter_write_indent(emitter) {
520
			return false
521
		}
522
	}
523
	if !yaml_emitter_flush(emitter) {
524
		return false
525
	}
526
	emitter.state = yaml_EMIT_DOCUMENT_START_STATE
527
	emitter.tag_directives = emitter.tag_directives[:0]
528
	return true
529
}
530

531
// Expect a flow item node.
532
func yaml_emitter_emit_flow_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first, trail bool) bool {
533
	if first {
534
		if !yaml_emitter_write_indicator(emitter, []byte{'['}, true, true, false) {
535
			return false
536
		}
537
		if !yaml_emitter_increase_indent(emitter, true, false) {
538
			return false
539
		}
540
		emitter.flow_level++
541
	}
542

543
	if event.typ == yaml_SEQUENCE_END_EVENT {
544
		if emitter.canonical && !first && !trail {
545
			if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
546
				return false
547
			}
548
		}
549
		emitter.flow_level--
550
		emitter.indent = emitter.indents[len(emitter.indents)-1]
551
		emitter.indents = emitter.indents[:len(emitter.indents)-1]
552
		if emitter.column == 0 || emitter.canonical && !first {
553
			if !yaml_emitter_write_indent(emitter) {
554
				return false
555
			}
556
		}
557
		if !yaml_emitter_write_indicator(emitter, []byte{']'}, false, false, false) {
558
			return false
559
		}
560
		if !yaml_emitter_process_line_comment(emitter) {
561
			return false
562
		}
563
		if !yaml_emitter_process_foot_comment(emitter) {
564
			return false
565
		}
566
		emitter.state = emitter.states[len(emitter.states)-1]
567
		emitter.states = emitter.states[:len(emitter.states)-1]
568

569
		return true
570
	}
571

572
	if !first && !trail {
573
		if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
574
			return false
575
		}
576
	}
577

578
	if !yaml_emitter_process_head_comment(emitter) {
579
		return false
580
	}
581
	if emitter.column == 0 {
582
		if !yaml_emitter_write_indent(emitter) {
583
			return false
584
		}
585
	}
586

587
	if emitter.canonical || emitter.column > emitter.best_width {
588
		if !yaml_emitter_write_indent(emitter) {
589
			return false
590
		}
591
	}
592
	if len(emitter.line_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0 {
593
		emitter.states = append(emitter.states, yaml_EMIT_FLOW_SEQUENCE_TRAIL_ITEM_STATE)
594
	} else {
595
		emitter.states = append(emitter.states, yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE)
596
	}
597
	if !yaml_emitter_emit_node(emitter, event, false, true, false, false) {
598
		return false
599
	}
600
	if len(emitter.line_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0 {
601
		if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
602
			return false
603
		}
604
	}
605
	if !yaml_emitter_process_line_comment(emitter) {
606
		return false
607
	}
608
	if !yaml_emitter_process_foot_comment(emitter) {
609
		return false
610
	}
611
	return true
612
}
613

614
// Expect a flow key node.
615
func yaml_emitter_emit_flow_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first, trail bool) bool {
616
	if first {
617
		if !yaml_emitter_write_indicator(emitter, []byte{'{'}, true, true, false) {
618
			return false
619
		}
620
		if !yaml_emitter_increase_indent(emitter, true, false) {
621
			return false
622
		}
623
		emitter.flow_level++
624
	}
625

626
	if event.typ == yaml_MAPPING_END_EVENT {
627
		if (emitter.canonical || len(emitter.head_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0) && !first && !trail {
628
			if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
629
				return false
630
			}
631
		}
632
		if !yaml_emitter_process_head_comment(emitter) {
633
			return false
634
		}
635
		emitter.flow_level--
636
		emitter.indent = emitter.indents[len(emitter.indents)-1]
637
		emitter.indents = emitter.indents[:len(emitter.indents)-1]
638
		if emitter.canonical && !first {
639
			if !yaml_emitter_write_indent(emitter) {
640
				return false
641
			}
642
		}
643
		if !yaml_emitter_write_indicator(emitter, []byte{'}'}, false, false, false) {
644
			return false
645
		}
646
		if !yaml_emitter_process_line_comment(emitter) {
647
			return false
648
		}
649
		if !yaml_emitter_process_foot_comment(emitter) {
650
			return false
651
		}
652
		emitter.state = emitter.states[len(emitter.states)-1]
653
		emitter.states = emitter.states[:len(emitter.states)-1]
654
		return true
655
	}
656

657
	if !first && !trail {
658
		if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
659
			return false
660
		}
661
	}
662

663
	if !yaml_emitter_process_head_comment(emitter) {
664
		return false
665
	}
666

667
	if emitter.column == 0 {
668
		if !yaml_emitter_write_indent(emitter) {
669
			return false
670
		}
671
	}
672

673
	if emitter.canonical || emitter.column > emitter.best_width {
674
		if !yaml_emitter_write_indent(emitter) {
675
			return false
676
		}
677
	}
678

679
	if !emitter.canonical && yaml_emitter_check_simple_key(emitter) {
680
		emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE)
681
		return yaml_emitter_emit_node(emitter, event, false, false, true, true)
682
	}
683
	if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, false) {
684
		return false
685
	}
686
	emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_VALUE_STATE)
687
	return yaml_emitter_emit_node(emitter, event, false, false, true, false)
688
}
689

690
// Expect a flow value node.
691
func yaml_emitter_emit_flow_mapping_value(emitter *yaml_emitter_t, event *yaml_event_t, simple bool) bool {
692
	if simple {
693
		if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) {
694
			return false
695
		}
696
	} else {
697
		if emitter.canonical || emitter.column > emitter.best_width {
698
			if !yaml_emitter_write_indent(emitter) {
699
				return false
700
			}
701
		}
702
		if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, false) {
703
			return false
704
		}
705
	}
706
	if len(emitter.line_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0 {
707
		emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_TRAIL_KEY_STATE)
708
	} else {
709
		emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_KEY_STATE)
710
	}
711
	if !yaml_emitter_emit_node(emitter, event, false, false, true, false) {
712
		return false
713
	}
714
	if len(emitter.line_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0 {
715
		if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
716
			return false
717
		}
718
	}
719
	if !yaml_emitter_process_line_comment(emitter) {
720
		return false
721
	}
722
	if !yaml_emitter_process_foot_comment(emitter) {
723
		return false
724
	}
725
	return true
726
}
727

728
// Expect a block item node.
729
func yaml_emitter_emit_block_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
730
	if first {
731
		if !yaml_emitter_increase_indent(emitter, false, false) {
732
			return false
733
		}
734
	}
735
	if event.typ == yaml_SEQUENCE_END_EVENT {
736
		emitter.indent = emitter.indents[len(emitter.indents)-1]
737
		emitter.indents = emitter.indents[:len(emitter.indents)-1]
738
		emitter.state = emitter.states[len(emitter.states)-1]
739
		emitter.states = emitter.states[:len(emitter.states)-1]
740
		return true
741
	}
742
	if !yaml_emitter_process_head_comment(emitter) {
743
		return false
744
	}
745
	if !yaml_emitter_write_indent(emitter) {
746
		return false
747
	}
748
	if !yaml_emitter_write_indicator(emitter, []byte{'-'}, true, false, true) {
749
		return false
750
	}
751
	emitter.states = append(emitter.states, yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE)
752
	if !yaml_emitter_emit_node(emitter, event, false, true, false, false) {
753
		return false
754
	}
755
	if !yaml_emitter_process_line_comment(emitter) {
756
		return false
757
	}
758
	if !yaml_emitter_process_foot_comment(emitter) {
759
		return false
760
	}
761
	return true
762
}
763

764
// Expect a block key node.
765
func yaml_emitter_emit_block_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
766
	if first {
767
		if !yaml_emitter_increase_indent(emitter, false, false) {
768
			return false
769
		}
770
	}
771
	if !yaml_emitter_process_head_comment(emitter) {
772
		return false
773
	}
774
	if event.typ == yaml_MAPPING_END_EVENT {
775
		emitter.indent = emitter.indents[len(emitter.indents)-1]
776
		emitter.indents = emitter.indents[:len(emitter.indents)-1]
777
		emitter.state = emitter.states[len(emitter.states)-1]
778
		emitter.states = emitter.states[:len(emitter.states)-1]
779
		return true
780
	}
781
	if !yaml_emitter_write_indent(emitter) {
782
		return false
783
	}
784
	if len(emitter.line_comment) > 0 {
785
		// [Go] A line comment was provided for the key. That's unusual as the
786
		//      scanner associates line comments with the value. Either way,
787
		//      save the line comment and render it appropriately later.
788
		emitter.key_line_comment = emitter.line_comment
789
		emitter.line_comment = nil
790
	}
791
	if yaml_emitter_check_simple_key(emitter) {
792
		emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE)
793
		return yaml_emitter_emit_node(emitter, event, false, false, true, true)
794
	}
795
	if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, true) {
796
		return false
797
	}
798
	emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_VALUE_STATE)
799
	return yaml_emitter_emit_node(emitter, event, false, false, true, false)
800
}
801

802
// Expect a block value node.
803
func yaml_emitter_emit_block_mapping_value(emitter *yaml_emitter_t, event *yaml_event_t, simple bool) bool {
804
	if simple {
805
		if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) {
806
			return false
807
		}
808
	} else {
809
		if !yaml_emitter_write_indent(emitter) {
810
			return false
811
		}
812
		if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, true) {
813
			return false
814
		}
815
	}
816
	if len(emitter.key_line_comment) > 0 {
817
		// [Go] Line comments are generally associated with the value, but when there's
818
		//      no value on the same line as a mapping key they end up attached to the
819
		//      key itself.
820
		if event.typ == yaml_SCALAR_EVENT {
821
			if len(emitter.line_comment) == 0 {
822
				// A scalar is coming and it has no line comments by itself yet,
823
				// so just let it handle the line comment as usual. If it has a
824
				// line comment, we can't have both so the one from the key is lost.
825
				emitter.line_comment = emitter.key_line_comment
826
				emitter.key_line_comment = nil
827
			}
828
		} else if event.sequence_style() != yaml_FLOW_SEQUENCE_STYLE && (event.typ == yaml_MAPPING_START_EVENT || event.typ == yaml_SEQUENCE_START_EVENT) {
829
			// An indented block follows, so write the comment right now.
830
			emitter.line_comment, emitter.key_line_comment = emitter.key_line_comment, emitter.line_comment
831
			if !yaml_emitter_process_line_comment(emitter) {
832
				return false
833
			}
834
			emitter.line_comment, emitter.key_line_comment = emitter.key_line_comment, emitter.line_comment
835
		}
836
	}
837
	emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_KEY_STATE)
838
	if !yaml_emitter_emit_node(emitter, event, false, false, true, false) {
839
		return false
840
	}
841
	if !yaml_emitter_process_line_comment(emitter) {
842
		return false
843
	}
844
	if !yaml_emitter_process_foot_comment(emitter) {
845
		return false
846
	}
847
	return true
848
}
849

850
func yaml_emitter_silent_nil_event(emitter *yaml_emitter_t, event *yaml_event_t) bool {
851
	return event.typ == yaml_SCALAR_EVENT && event.implicit && !emitter.canonical && len(emitter.scalar_data.value) == 0
852
}
853

854
// Expect a node.
855
func yaml_emitter_emit_node(emitter *yaml_emitter_t, event *yaml_event_t,
856
	root bool, sequence bool, mapping bool, simple_key bool) bool {
857

858
	emitter.root_context = root
859
	emitter.sequence_context = sequence
860
	emitter.mapping_context = mapping
861
	emitter.simple_key_context = simple_key
862

863
	switch event.typ {
864
	case yaml_ALIAS_EVENT:
865
		return yaml_emitter_emit_alias(emitter, event)
866
	case yaml_SCALAR_EVENT:
867
		return yaml_emitter_emit_scalar(emitter, event)
868
	case yaml_SEQUENCE_START_EVENT:
869
		return yaml_emitter_emit_sequence_start(emitter, event)
870
	case yaml_MAPPING_START_EVENT:
871
		return yaml_emitter_emit_mapping_start(emitter, event)
872
	default:
873
		return yaml_emitter_set_emitter_error(emitter,
874
			fmt.Sprintf("expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS, but got %v", event.typ))
875
	}
876
}
877

878
// Expect ALIAS.
879
func yaml_emitter_emit_alias(emitter *yaml_emitter_t, event *yaml_event_t) bool {
880
	if !yaml_emitter_process_anchor(emitter) {
881
		return false
882
	}
883
	emitter.state = emitter.states[len(emitter.states)-1]
884
	emitter.states = emitter.states[:len(emitter.states)-1]
885
	return true
886
}
887

888
// Expect SCALAR.
889
func yaml_emitter_emit_scalar(emitter *yaml_emitter_t, event *yaml_event_t) bool {
890
	if !yaml_emitter_select_scalar_style(emitter, event) {
891
		return false
892
	}
893
	if !yaml_emitter_process_anchor(emitter) {
894
		return false
895
	}
896
	if !yaml_emitter_process_tag(emitter) {
897
		return false
898
	}
899
	if !yaml_emitter_increase_indent(emitter, true, false) {
900
		return false
901
	}
902
	if !yaml_emitter_process_scalar(emitter) {
903
		return false
904
	}
905
	emitter.indent = emitter.indents[len(emitter.indents)-1]
906
	emitter.indents = emitter.indents[:len(emitter.indents)-1]
907
	emitter.state = emitter.states[len(emitter.states)-1]
908
	emitter.states = emitter.states[:len(emitter.states)-1]
909
	return true
910
}
911

912
// Expect SEQUENCE-START.
913
func yaml_emitter_emit_sequence_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {
914
	if !yaml_emitter_process_anchor(emitter) {
915
		return false
916
	}
917
	if !yaml_emitter_process_tag(emitter) {
918
		return false
919
	}
920
	if emitter.flow_level > 0 || emitter.canonical || event.sequence_style() == yaml_FLOW_SEQUENCE_STYLE ||
921
		yaml_emitter_check_empty_sequence(emitter) {
922
		emitter.state = yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE
923
	} else {
924
		emitter.state = yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE
925
	}
926
	return true
927
}
928

929
// Expect MAPPING-START.
930
func yaml_emitter_emit_mapping_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {
931
	if !yaml_emitter_process_anchor(emitter) {
932
		return false
933
	}
934
	if !yaml_emitter_process_tag(emitter) {
935
		return false
936
	}
937
	if emitter.flow_level > 0 || emitter.canonical || event.mapping_style() == yaml_FLOW_MAPPING_STYLE ||
938
		yaml_emitter_check_empty_mapping(emitter) {
939
		emitter.state = yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE
940
	} else {
941
		emitter.state = yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE
942
	}
943
	return true
944
}
945

946
// Check if the document content is an empty scalar.
947
func yaml_emitter_check_empty_document(emitter *yaml_emitter_t) bool {
948
	return false // [Go] Huh?
949
}
950

951
// Check if the next events represent an empty sequence.
952
func yaml_emitter_check_empty_sequence(emitter *yaml_emitter_t) bool {
953
	if len(emitter.events)-emitter.events_head < 2 {
954
		return false
955
	}
956
	return emitter.events[emitter.events_head].typ == yaml_SEQUENCE_START_EVENT &&
957
		emitter.events[emitter.events_head+1].typ == yaml_SEQUENCE_END_EVENT
958
}
959

960
// Check if the next events represent an empty mapping.
961
func yaml_emitter_check_empty_mapping(emitter *yaml_emitter_t) bool {
962
	if len(emitter.events)-emitter.events_head < 2 {
963
		return false
964
	}
965
	return emitter.events[emitter.events_head].typ == yaml_MAPPING_START_EVENT &&
966
		emitter.events[emitter.events_head+1].typ == yaml_MAPPING_END_EVENT
967
}
968

969
// Check if the next node can be expressed as a simple key.
970
func yaml_emitter_check_simple_key(emitter *yaml_emitter_t) bool {
971
	length := 0
972
	switch emitter.events[emitter.events_head].typ {
973
	case yaml_ALIAS_EVENT:
974
		length += len(emitter.anchor_data.anchor)
975
	case yaml_SCALAR_EVENT:
976
		if emitter.scalar_data.multiline {
977
			return false
978
		}
979
		length += len(emitter.anchor_data.anchor) +
980
			len(emitter.tag_data.handle) +
981
			len(emitter.tag_data.suffix) +
982
			len(emitter.scalar_data.value)
983
	case yaml_SEQUENCE_START_EVENT:
984
		if !yaml_emitter_check_empty_sequence(emitter) {
985
			return false
986
		}
987
		length += len(emitter.anchor_data.anchor) +
988
			len(emitter.tag_data.handle) +
989
			len(emitter.tag_data.suffix)
990
	case yaml_MAPPING_START_EVENT:
991
		if !yaml_emitter_check_empty_mapping(emitter) {
992
			return false
993
		}
994
		length += len(emitter.anchor_data.anchor) +
995
			len(emitter.tag_data.handle) +
996
			len(emitter.tag_data.suffix)
997
	default:
998
		return false
999
	}
1000
	return length <= 128
1001
}
1002

1003
// Determine an acceptable scalar style.
1004
func yaml_emitter_select_scalar_style(emitter *yaml_emitter_t, event *yaml_event_t) bool {
1005

1006
	no_tag := len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0
1007
	if no_tag && !event.implicit && !event.quoted_implicit {
1008
		return yaml_emitter_set_emitter_error(emitter, "neither tag nor implicit flags are specified")
1009
	}
1010

1011
	style := event.scalar_style()
1012
	if style == yaml_ANY_SCALAR_STYLE {
1013
		style = yaml_PLAIN_SCALAR_STYLE
1014
	}
1015
	if emitter.canonical {
1016
		style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
1017
	}
1018
	if emitter.simple_key_context && emitter.scalar_data.multiline {
1019
		style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
1020
	}
1021

1022
	if style == yaml_PLAIN_SCALAR_STYLE {
1023
		if emitter.flow_level > 0 && !emitter.scalar_data.flow_plain_allowed ||
1024
			emitter.flow_level == 0 && !emitter.scalar_data.block_plain_allowed {
1025
			style = yaml_SINGLE_QUOTED_SCALAR_STYLE
1026
		}
1027
		if len(emitter.scalar_data.value) == 0 && (emitter.flow_level > 0 || emitter.simple_key_context) {
1028
			style = yaml_SINGLE_QUOTED_SCALAR_STYLE
1029
		}
1030
		if no_tag && !event.implicit {
1031
			style = yaml_SINGLE_QUOTED_SCALAR_STYLE
1032
		}
1033
	}
1034
	if style == yaml_SINGLE_QUOTED_SCALAR_STYLE {
1035
		if !emitter.scalar_data.single_quoted_allowed {
1036
			style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
1037
		}
1038
	}
1039
	if style == yaml_LITERAL_SCALAR_STYLE || style == yaml_FOLDED_SCALAR_STYLE {
1040
		if !emitter.scalar_data.block_allowed || emitter.flow_level > 0 || emitter.simple_key_context {
1041
			style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
1042
		}
1043
	}
1044

1045
	if no_tag && !event.quoted_implicit && style != yaml_PLAIN_SCALAR_STYLE {
1046
		emitter.tag_data.handle = []byte{'!'}
1047
	}
1048
	emitter.scalar_data.style = style
1049
	return true
1050
}
1051

1052
// Write an anchor.
1053
func yaml_emitter_process_anchor(emitter *yaml_emitter_t) bool {
1054
	if emitter.anchor_data.anchor == nil {
1055
		return true
1056
	}
1057
	c := []byte{'&'}
1058
	if emitter.anchor_data.alias {
1059
		c[0] = '*'
1060
	}
1061
	if !yaml_emitter_write_indicator(emitter, c, true, false, false) {
1062
		return false
1063
	}
1064
	return yaml_emitter_write_anchor(emitter, emitter.anchor_data.anchor)
1065
}
1066

1067
// Write a tag.
1068
func yaml_emitter_process_tag(emitter *yaml_emitter_t) bool {
1069
	if len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0 {
1070
		return true
1071
	}
1072
	if len(emitter.tag_data.handle) > 0 {
1073
		if !yaml_emitter_write_tag_handle(emitter, emitter.tag_data.handle) {
1074
			return false
1075
		}
1076
		if len(emitter.tag_data.suffix) > 0 {
1077
			if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) {
1078
				return false
1079
			}
1080
		}
1081
	} else {
1082
		// [Go] Allocate these slices elsewhere.
1083
		if !yaml_emitter_write_indicator(emitter, []byte("!<"), true, false, false) {
1084
			return false
1085
		}
1086
		if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) {
1087
			return false
1088
		}
1089
		if !yaml_emitter_write_indicator(emitter, []byte{'>'}, false, false, false) {
1090
			return false
1091
		}
1092
	}
1093
	return true
1094
}
1095

1096
// Write a scalar.
1097
func yaml_emitter_process_scalar(emitter *yaml_emitter_t) bool {
1098
	switch emitter.scalar_data.style {
1099
	case yaml_PLAIN_SCALAR_STYLE:
1100
		return yaml_emitter_write_plain_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)
1101

1102
	case yaml_SINGLE_QUOTED_SCALAR_STYLE:
1103
		return yaml_emitter_write_single_quoted_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)
1104

1105
	case yaml_DOUBLE_QUOTED_SCALAR_STYLE:
1106
		return yaml_emitter_write_double_quoted_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)
1107

1108
	case yaml_LITERAL_SCALAR_STYLE:
1109
		return yaml_emitter_write_literal_scalar(emitter, emitter.scalar_data.value)
1110

1111
	case yaml_FOLDED_SCALAR_STYLE:
1112
		return yaml_emitter_write_folded_scalar(emitter, emitter.scalar_data.value)
1113
	}
1114
	panic("unknown scalar style")
1115
}
1116

1117
// Write a head comment.
1118
func yaml_emitter_process_head_comment(emitter *yaml_emitter_t) bool {
1119
	if len(emitter.tail_comment) > 0 {
1120
		if !yaml_emitter_write_indent(emitter) {
1121
			return false
1122
		}
1123
		if !yaml_emitter_write_comment(emitter, emitter.tail_comment) {
1124
			return false
1125
		}
1126
		emitter.tail_comment = emitter.tail_comment[:0]
1127
		emitter.foot_indent = emitter.indent
1128
		if emitter.foot_indent < 0 {
1129
			emitter.foot_indent = 0
1130
		}
1131
	}
1132

1133
	if len(emitter.head_comment) == 0 {
1134
		return true
1135
	}
1136
	if !yaml_emitter_write_indent(emitter) {
1137
		return false
1138
	}
1139
	if !yaml_emitter_write_comment(emitter, emitter.head_comment) {
1140
		return false
1141
	}
1142
	emitter.head_comment = emitter.head_comment[:0]
1143
	return true
1144
}
1145

1146
// Write an line comment.
1147
func yaml_emitter_process_line_comment(emitter *yaml_emitter_t) bool {
1148
	if len(emitter.line_comment) == 0 {
1149
		return true
1150
	}
1151
	if !emitter.whitespace {
1152
		if !put(emitter, ' ') {
1153
			return false
1154
		}
1155
	}
1156
	if !yaml_emitter_write_comment(emitter, emitter.line_comment) {
1157
		return false
1158
	}
1159
	emitter.line_comment = emitter.line_comment[:0]
1160
	return true
1161
}
1162

1163
// Write a foot comment.
1164
func yaml_emitter_process_foot_comment(emitter *yaml_emitter_t) bool {
1165
	if len(emitter.foot_comment) == 0 {
1166
		return true
1167
	}
1168
	if !yaml_emitter_write_indent(emitter) {
1169
		return false
1170
	}
1171
	if !yaml_emitter_write_comment(emitter, emitter.foot_comment) {
1172
		return false
1173
	}
1174
	emitter.foot_comment = emitter.foot_comment[:0]
1175
	emitter.foot_indent = emitter.indent
1176
	if emitter.foot_indent < 0 {
1177
		emitter.foot_indent = 0
1178
	}
1179
	return true
1180
}
1181

1182
// Check if a %YAML directive is valid.
1183
func yaml_emitter_analyze_version_directive(emitter *yaml_emitter_t, version_directive *yaml_version_directive_t) bool {
1184
	if version_directive.major != 1 || version_directive.minor != 1 {
1185
		return yaml_emitter_set_emitter_error(emitter, "incompatible %YAML directive")
1186
	}
1187
	return true
1188
}
1189

1190
// Check if a %TAG directive is valid.
1191
func yaml_emitter_analyze_tag_directive(emitter *yaml_emitter_t, tag_directive *yaml_tag_directive_t) bool {
1192
	handle := tag_directive.handle
1193
	prefix := tag_directive.prefix
1194
	if len(handle) == 0 {
1195
		return yaml_emitter_set_emitter_error(emitter, "tag handle must not be empty")
1196
	}
1197
	if handle[0] != '!' {
1198
		return yaml_emitter_set_emitter_error(emitter, "tag handle must start with '!'")
1199
	}
1200
	if handle[len(handle)-1] != '!' {
1201
		return yaml_emitter_set_emitter_error(emitter, "tag handle must end with '!'")
1202
	}
1203
	for i := 1; i < len(handle)-1; i += width(handle[i]) {
1204
		if !is_alpha(handle, i) {
1205
			return yaml_emitter_set_emitter_error(emitter, "tag handle must contain alphanumerical characters only")
1206
		}
1207
	}
1208
	if len(prefix) == 0 {
1209
		return yaml_emitter_set_emitter_error(emitter, "tag prefix must not be empty")
1210
	}
1211
	return true
1212
}
1213

1214
// Check if an anchor is valid.
1215
func yaml_emitter_analyze_anchor(emitter *yaml_emitter_t, anchor []byte, alias bool) bool {
1216
	if len(anchor) == 0 {
1217
		problem := "anchor value must not be empty"
1218
		if alias {
1219
			problem = "alias value must not be empty"
1220
		}
1221
		return yaml_emitter_set_emitter_error(emitter, problem)
1222
	}
1223
	for i := 0; i < len(anchor); i += width(anchor[i]) {
1224
		if !is_alpha(anchor, i) {
1225
			problem := "anchor value must contain alphanumerical characters only"
1226
			if alias {
1227
				problem = "alias value must contain alphanumerical characters only"
1228
			}
1229
			return yaml_emitter_set_emitter_error(emitter, problem)
1230
		}
1231
	}
1232
	emitter.anchor_data.anchor = anchor
1233
	emitter.anchor_data.alias = alias
1234
	return true
1235
}
1236

1237
// Check if a tag is valid.
1238
func yaml_emitter_analyze_tag(emitter *yaml_emitter_t, tag []byte) bool {
1239
	if len(tag) == 0 {
1240
		return yaml_emitter_set_emitter_error(emitter, "tag value must not be empty")
1241
	}
1242
	for i := 0; i < len(emitter.tag_directives); i++ {
1243
		tag_directive := &emitter.tag_directives[i]
1244
		if bytes.HasPrefix(tag, tag_directive.prefix) {
1245
			emitter.tag_data.handle = tag_directive.handle
1246
			emitter.tag_data.suffix = tag[len(tag_directive.prefix):]
1247
			return true
1248
		}
1249
	}
1250
	emitter.tag_data.suffix = tag
1251
	return true
1252
}
1253

1254
// Check if a scalar is valid.
1255
func yaml_emitter_analyze_scalar(emitter *yaml_emitter_t, value []byte) bool {
1256
	var (
1257
		block_indicators   = false
1258
		flow_indicators    = false
1259
		line_breaks        = false
1260
		special_characters = false
1261
		tab_characters     = false
1262

1263
		leading_space  = false
1264
		leading_break  = false
1265
		trailing_space = false
1266
		trailing_break = false
1267
		break_space    = false
1268
		space_break    = false
1269

1270
		preceded_by_whitespace = false
1271
		followed_by_whitespace = false
1272
		previous_space         = false
1273
		previous_break         = false
1274
	)
1275

1276
	emitter.scalar_data.value = value
1277

1278
	if len(value) == 0 {
1279
		emitter.scalar_data.multiline = false
1280
		emitter.scalar_data.flow_plain_allowed = false
1281
		emitter.scalar_data.block_plain_allowed = true
1282
		emitter.scalar_data.single_quoted_allowed = true
1283
		emitter.scalar_data.block_allowed = false
1284
		return true
1285
	}
1286

1287
	if len(value) >= 3 && ((value[0] == '-' && value[1] == '-' && value[2] == '-') || (value[0] == '.' && value[1] == '.' && value[2] == '.')) {
1288
		block_indicators = true
1289
		flow_indicators = true
1290
	}
1291

1292
	preceded_by_whitespace = true
1293
	for i, w := 0, 0; i < len(value); i += w {
1294
		w = width(value[i])
1295
		followed_by_whitespace = i+w >= len(value) || is_blank(value, i+w)
1296

1297
		if i == 0 {
1298
			switch value[i] {
1299
			case '#', ',', '[', ']', '{', '}', '&', '*', '!', '|', '>', '\'', '"', '%', '@', '`':
1300
				flow_indicators = true
1301
				block_indicators = true
1302
			case '?', ':':
1303
				flow_indicators = true
1304
				if followed_by_whitespace {
1305
					block_indicators = true
1306
				}
1307
			case '-':
1308
				if followed_by_whitespace {
1309
					flow_indicators = true
1310
					block_indicators = true
1311
				}
1312
			}
1313
		} else {
1314
			switch value[i] {
1315
			case ',', '?', '[', ']', '{', '}':
1316
				flow_indicators = true
1317
			case ':':
1318
				flow_indicators = true
1319
				if followed_by_whitespace {
1320
					block_indicators = true
1321
				}
1322
			case '#':
1323
				if preceded_by_whitespace {
1324
					flow_indicators = true
1325
					block_indicators = true
1326
				}
1327
			}
1328
		}
1329

1330
		if value[i] == '\t' {
1331
			tab_characters = true
1332
		} else if !is_printable(value, i) || !is_ascii(value, i) && !emitter.unicode {
1333
			special_characters = true
1334
		}
1335
		if is_space(value, i) {
1336
			if i == 0 {
1337
				leading_space = true
1338
			}
1339
			if i+width(value[i]) == len(value) {
1340
				trailing_space = true
1341
			}
1342
			if previous_break {
1343
				break_space = true
1344
			}
1345
			previous_space = true
1346
			previous_break = false
1347
		} else if is_break(value, i) {
1348
			line_breaks = true
1349
			if i == 0 {
1350
				leading_break = true
1351
			}
1352
			if i+width(value[i]) == len(value) {
1353
				trailing_break = true
1354
			}
1355
			if previous_space {
1356
				space_break = true
1357
			}
1358
			previous_space = false
1359
			previous_break = true
1360
		} else {
1361
			previous_space = false
1362
			previous_break = false
1363
		}
1364

1365
		// [Go]: Why 'z'? Couldn't be the end of the string as that's the loop condition.
1366
		preceded_by_whitespace = is_blankz(value, i)
1367
	}
1368

1369
	emitter.scalar_data.multiline = line_breaks
1370
	emitter.scalar_data.flow_plain_allowed = true
1371
	emitter.scalar_data.block_plain_allowed = true
1372
	emitter.scalar_data.single_quoted_allowed = true
1373
	emitter.scalar_data.block_allowed = true
1374

1375
	if leading_space || leading_break || trailing_space || trailing_break {
1376
		emitter.scalar_data.flow_plain_allowed = false
1377
		emitter.scalar_data.block_plain_allowed = false
1378
	}
1379
	if trailing_space {
1380
		emitter.scalar_data.block_allowed = false
1381
	}
1382
	if break_space {
1383
		emitter.scalar_data.flow_plain_allowed = false
1384
		emitter.scalar_data.block_plain_allowed = false
1385
		emitter.scalar_data.single_quoted_allowed = false
1386
	}
1387
	if space_break || tab_characters || special_characters {
1388
		emitter.scalar_data.flow_plain_allowed = false
1389
		emitter.scalar_data.block_plain_allowed = false
1390
		emitter.scalar_data.single_quoted_allowed = false
1391
	}
1392
	if space_break || special_characters {
1393
		emitter.scalar_data.block_allowed = false
1394
	}
1395
	if line_breaks {
1396
		emitter.scalar_data.flow_plain_allowed = false
1397
		emitter.scalar_data.block_plain_allowed = false
1398
	}
1399
	if flow_indicators {
1400
		emitter.scalar_data.flow_plain_allowed = false
1401
	}
1402
	if block_indicators {
1403
		emitter.scalar_data.block_plain_allowed = false
1404
	}
1405
	return true
1406
}
1407

1408
// Check if the event data is valid.
1409
func yaml_emitter_analyze_event(emitter *yaml_emitter_t, event *yaml_event_t) bool {
1410

1411
	emitter.anchor_data.anchor = nil
1412
	emitter.tag_data.handle = nil
1413
	emitter.tag_data.suffix = nil
1414
	emitter.scalar_data.value = nil
1415

1416
	if len(event.head_comment) > 0 {
1417
		emitter.head_comment = event.head_comment
1418
	}
1419
	if len(event.line_comment) > 0 {
1420
		emitter.line_comment = event.line_comment
1421
	}
1422
	if len(event.foot_comment) > 0 {
1423
		emitter.foot_comment = event.foot_comment
1424
	}
1425
	if len(event.tail_comment) > 0 {
1426
		emitter.tail_comment = event.tail_comment
1427
	}
1428

1429
	switch event.typ {
1430
	case yaml_ALIAS_EVENT:
1431
		if !yaml_emitter_analyze_anchor(emitter, event.anchor, true) {
1432
			return false
1433
		}
1434

1435
	case yaml_SCALAR_EVENT:
1436
		if len(event.anchor) > 0 {
1437
			if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
1438
				return false
1439
			}
1440
		}
1441
		if len(event.tag) > 0 && (emitter.canonical || (!event.implicit && !event.quoted_implicit)) {
1442
			if !yaml_emitter_analyze_tag(emitter, event.tag) {
1443
				return false
1444
			}
1445
		}
1446
		if !yaml_emitter_analyze_scalar(emitter, event.value) {
1447
			return false
1448
		}
1449

1450
	case yaml_SEQUENCE_START_EVENT:
1451
		if len(event.anchor) > 0 {
1452
			if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
1453
				return false
1454
			}
1455
		}
1456
		if len(event.tag) > 0 && (emitter.canonical || !event.implicit) {
1457
			if !yaml_emitter_analyze_tag(emitter, event.tag) {
1458
				return false
1459
			}
1460
		}
1461

1462
	case yaml_MAPPING_START_EVENT:
1463
		if len(event.anchor) > 0 {
1464
			if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
1465
				return false
1466
			}
1467
		}
1468
		if len(event.tag) > 0 && (emitter.canonical || !event.implicit) {
1469
			if !yaml_emitter_analyze_tag(emitter, event.tag) {
1470
				return false
1471
			}
1472
		}
1473
	}
1474
	return true
1475
}
1476

1477
// Write the BOM character.
1478
func yaml_emitter_write_bom(emitter *yaml_emitter_t) bool {
1479
	if !flush(emitter) {
1480
		return false
1481
	}
1482
	pos := emitter.buffer_pos
1483
	emitter.buffer[pos+0] = '\xEF'
1484
	emitter.buffer[pos+1] = '\xBB'
1485
	emitter.buffer[pos+2] = '\xBF'
1486
	emitter.buffer_pos += 3
1487
	return true
1488
}
1489

1490
func yaml_emitter_write_indent(emitter *yaml_emitter_t) bool {
1491
	indent := emitter.indent
1492
	if indent < 0 {
1493
		indent = 0
1494
	}
1495
	if !emitter.indention || emitter.column > indent || (emitter.column == indent && !emitter.whitespace) {
1496
		if !put_break(emitter) {
1497
			return false
1498
		}
1499
	}
1500
	if emitter.foot_indent == indent {
1501
		if !put_break(emitter) {
1502
			return false
1503
		}
1504
	}
1505
	for emitter.column < indent {
1506
		if !put(emitter, ' ') {
1507
			return false
1508
		}
1509
	}
1510
	emitter.whitespace = true
1511
	//emitter.indention = true
1512
	emitter.space_above = false
1513
	emitter.foot_indent = -1
1514
	return true
1515
}
1516

1517
func yaml_emitter_write_indicator(emitter *yaml_emitter_t, indicator []byte, need_whitespace, is_whitespace, is_indention bool) bool {
1518
	if need_whitespace && !emitter.whitespace {
1519
		if !put(emitter, ' ') {
1520
			return false
1521
		}
1522
	}
1523
	if !write_all(emitter, indicator) {
1524
		return false
1525
	}
1526
	emitter.whitespace = is_whitespace
1527
	emitter.indention = (emitter.indention && is_indention)
1528
	emitter.open_ended = false
1529
	return true
1530
}
1531

1532
func yaml_emitter_write_anchor(emitter *yaml_emitter_t, value []byte) bool {
1533
	if !write_all(emitter, value) {
1534
		return false
1535
	}
1536
	emitter.whitespace = false
1537
	emitter.indention = false
1538
	return true
1539
}
1540

1541
func yaml_emitter_write_tag_handle(emitter *yaml_emitter_t, value []byte) bool {
1542
	if !emitter.whitespace {
1543
		if !put(emitter, ' ') {
1544
			return false
1545
		}
1546
	}
1547
	if !write_all(emitter, value) {
1548
		return false
1549
	}
1550
	emitter.whitespace = false
1551
	emitter.indention = false
1552
	return true
1553
}
1554

1555
func yaml_emitter_write_tag_content(emitter *yaml_emitter_t, value []byte, need_whitespace bool) bool {
1556
	if need_whitespace && !emitter.whitespace {
1557
		if !put(emitter, ' ') {
1558
			return false
1559
		}
1560
	}
1561
	for i := 0; i < len(value); {
1562
		var must_write bool
1563
		switch value[i] {
1564
		case ';', '/', '?', ':', '@', '&', '=', '+', '$', ',', '_', '.', '~', '*', '\'', '(', ')', '[', ']':
1565
			must_write = true
1566
		default:
1567
			must_write = is_alpha(value, i)
1568
		}
1569
		if must_write {
1570
			if !write(emitter, value, &i) {
1571
				return false
1572
			}
1573
		} else {
1574
			w := width(value[i])
1575
			for k := 0; k < w; k++ {
1576
				octet := value[i]
1577
				i++
1578
				if !put(emitter, '%') {
1579
					return false
1580
				}
1581

1582
				c := octet >> 4
1583
				if c < 10 {
1584
					c += '0'
1585
				} else {
1586
					c += 'A' - 10
1587
				}
1588
				if !put(emitter, c) {
1589
					return false
1590
				}
1591

1592
				c = octet & 0x0f
1593
				if c < 10 {
1594
					c += '0'
1595
				} else {
1596
					c += 'A' - 10
1597
				}
1598
				if !put(emitter, c) {
1599
					return false
1600
				}
1601
			}
1602
		}
1603
	}
1604
	emitter.whitespace = false
1605
	emitter.indention = false
1606
	return true
1607
}
1608

1609
func yaml_emitter_write_plain_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
1610
	if len(value) > 0 && !emitter.whitespace {
1611
		if !put(emitter, ' ') {
1612
			return false
1613
		}
1614
	}
1615

1616
	spaces := false
1617
	breaks := false
1618
	for i := 0; i < len(value); {
1619
		if is_space(value, i) {
1620
			if allow_breaks && !spaces && emitter.column > emitter.best_width && !is_space(value, i+1) {
1621
				if !yaml_emitter_write_indent(emitter) {
1622
					return false
1623
				}
1624
				i += width(value[i])
1625
			} else {
1626
				if !write(emitter, value, &i) {
1627
					return false
1628
				}
1629
			}
1630
			spaces = true
1631
		} else if is_break(value, i) {
1632
			if !breaks && value[i] == '\n' {
1633
				if !put_break(emitter) {
1634
					return false
1635
				}
1636
			}
1637
			if !write_break(emitter, value, &i) {
1638
				return false
1639
			}
1640
			//emitter.indention = true
1641
			breaks = true
1642
		} else {
1643
			if breaks {
1644
				if !yaml_emitter_write_indent(emitter) {
1645
					return false
1646
				}
1647
			}
1648
			if !write(emitter, value, &i) {
1649
				return false
1650
			}
1651
			emitter.indention = false
1652
			spaces = false
1653
			breaks = false
1654
		}
1655
	}
1656

1657
	if len(value) > 0 {
1658
		emitter.whitespace = false
1659
	}
1660
	emitter.indention = false
1661
	if emitter.root_context {
1662
		emitter.open_ended = true
1663
	}
1664

1665
	return true
1666
}
1667

1668
func yaml_emitter_write_single_quoted_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
1669

1670
	if !yaml_emitter_write_indicator(emitter, []byte{'\''}, true, false, false) {
1671
		return false
1672
	}
1673

1674
	spaces := false
1675
	breaks := false
1676
	for i := 0; i < len(value); {
1677
		if is_space(value, i) {
1678
			if allow_breaks && !spaces && emitter.column > emitter.best_width && i > 0 && i < len(value)-1 && !is_space(value, i+1) {
1679
				if !yaml_emitter_write_indent(emitter) {
1680
					return false
1681
				}
1682
				i += width(value[i])
1683
			} else {
1684
				if !write(emitter, value, &i) {
1685
					return false
1686
				}
1687
			}
1688
			spaces = true
1689
		} else if is_break(value, i) {
1690
			if !breaks && value[i] == '\n' {
1691
				if !put_break(emitter) {
1692
					return false
1693
				}
1694
			}
1695
			if !write_break(emitter, value, &i) {
1696
				return false
1697
			}
1698
			//emitter.indention = true
1699
			breaks = true
1700
		} else {
1701
			if breaks {
1702
				if !yaml_emitter_write_indent(emitter) {
1703
					return false
1704
				}
1705
			}
1706
			if value[i] == '\'' {
1707
				if !put(emitter, '\'') {
1708
					return false
1709
				}
1710
			}
1711
			if !write(emitter, value, &i) {
1712
				return false
1713
			}
1714
			emitter.indention = false
1715
			spaces = false
1716
			breaks = false
1717
		}
1718
	}
1719
	if !yaml_emitter_write_indicator(emitter, []byte{'\''}, false, false, false) {
1720
		return false
1721
	}
1722
	emitter.whitespace = false
1723
	emitter.indention = false
1724
	return true
1725
}
1726

1727
func yaml_emitter_write_double_quoted_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
1728
	spaces := false
1729
	if !yaml_emitter_write_indicator(emitter, []byte{'"'}, true, false, false) {
1730
		return false
1731
	}
1732

1733
	for i := 0; i < len(value); {
1734
		if !is_printable(value, i) || (!emitter.unicode && !is_ascii(value, i)) ||
1735
			is_bom(value, i) || is_break(value, i) ||
1736
			value[i] == '"' || value[i] == '\\' {
1737

1738
			octet := value[i]
1739

1740
			var w int
1741
			var v rune
1742
			switch {
1743
			case octet&0x80 == 0x00:
1744
				w, v = 1, rune(octet&0x7F)
1745
			case octet&0xE0 == 0xC0:
1746
				w, v = 2, rune(octet&0x1F)
1747
			case octet&0xF0 == 0xE0:
1748
				w, v = 3, rune(octet&0x0F)
1749
			case octet&0xF8 == 0xF0:
1750
				w, v = 4, rune(octet&0x07)
1751
			}
1752
			for k := 1; k < w; k++ {
1753
				octet = value[i+k]
1754
				v = (v << 6) + (rune(octet) & 0x3F)
1755
			}
1756
			i += w
1757

1758
			if !put(emitter, '\\') {
1759
				return false
1760
			}
1761

1762
			var ok bool
1763
			switch v {
1764
			case 0x00:
1765
				ok = put(emitter, '0')
1766
			case 0x07:
1767
				ok = put(emitter, 'a')
1768
			case 0x08:
1769
				ok = put(emitter, 'b')
1770
			case 0x09:
1771
				ok = put(emitter, 't')
1772
			case 0x0A:
1773
				ok = put(emitter, 'n')
1774
			case 0x0b:
1775
				ok = put(emitter, 'v')
1776
			case 0x0c:
1777
				ok = put(emitter, 'f')
1778
			case 0x0d:
1779
				ok = put(emitter, 'r')
1780
			case 0x1b:
1781
				ok = put(emitter, 'e')
1782
			case 0x22:
1783
				ok = put(emitter, '"')
1784
			case 0x5c:
1785
				ok = put(emitter, '\\')
1786
			case 0x85:
1787
				ok = put(emitter, 'N')
1788
			case 0xA0:
1789
				ok = put(emitter, '_')
1790
			case 0x2028:
1791
				ok = put(emitter, 'L')
1792
			case 0x2029:
1793
				ok = put(emitter, 'P')
1794
			default:
1795
				if v <= 0xFF {
1796
					ok = put(emitter, 'x')
1797
					w = 2
1798
				} else if v <= 0xFFFF {
1799
					ok = put(emitter, 'u')
1800
					w = 4
1801
				} else {
1802
					ok = put(emitter, 'U')
1803
					w = 8
1804
				}
1805
				for k := (w - 1) * 4; ok && k >= 0; k -= 4 {
1806
					digit := byte((v >> uint(k)) & 0x0F)
1807
					if digit < 10 {
1808
						ok = put(emitter, digit+'0')
1809
					} else {
1810
						ok = put(emitter, digit+'A'-10)
1811
					}
1812
				}
1813
			}
1814
			if !ok {
1815
				return false
1816
			}
1817
			spaces = false
1818
		} else if is_space(value, i) {
1819
			if allow_breaks && !spaces && emitter.column > emitter.best_width && i > 0 && i < len(value)-1 {
1820
				if !yaml_emitter_write_indent(emitter) {
1821
					return false
1822
				}
1823
				if is_space(value, i+1) {
1824
					if !put(emitter, '\\') {
1825
						return false
1826
					}
1827
				}
1828
				i += width(value[i])
1829
			} else if !write(emitter, value, &i) {
1830
				return false
1831
			}
1832
			spaces = true
1833
		} else {
1834
			if !write(emitter, value, &i) {
1835
				return false
1836
			}
1837
			spaces = false
1838
		}
1839
	}
1840
	if !yaml_emitter_write_indicator(emitter, []byte{'"'}, false, false, false) {
1841
		return false
1842
	}
1843
	emitter.whitespace = false
1844
	emitter.indention = false
1845
	return true
1846
}
1847

1848
func yaml_emitter_write_block_scalar_hints(emitter *yaml_emitter_t, value []byte) bool {
1849
	if is_space(value, 0) || is_break(value, 0) {
1850
		indent_hint := []byte{'0' + byte(emitter.best_indent)}
1851
		if !yaml_emitter_write_indicator(emitter, indent_hint, false, false, false) {
1852
			return false
1853
		}
1854
	}
1855

1856
	emitter.open_ended = false
1857

1858
	var chomp_hint [1]byte
1859
	if len(value) == 0 {
1860
		chomp_hint[0] = '-'
1861
	} else {
1862
		i := len(value) - 1
1863
		for value[i]&0xC0 == 0x80 {
1864
			i--
1865
		}
1866
		if !is_break(value, i) {
1867
			chomp_hint[0] = '-'
1868
		} else if i == 0 {
1869
			chomp_hint[0] = '+'
1870
			emitter.open_ended = true
1871
		} else {
1872
			i--
1873
			for value[i]&0xC0 == 0x80 {
1874
				i--
1875
			}
1876
			if is_break(value, i) {
1877
				chomp_hint[0] = '+'
1878
				emitter.open_ended = true
1879
			}
1880
		}
1881
	}
1882
	if chomp_hint[0] != 0 {
1883
		if !yaml_emitter_write_indicator(emitter, chomp_hint[:], false, false, false) {
1884
			return false
1885
		}
1886
	}
1887
	return true
1888
}
1889

1890
func yaml_emitter_write_literal_scalar(emitter *yaml_emitter_t, value []byte) bool {
1891
	if !yaml_emitter_write_indicator(emitter, []byte{'|'}, true, false, false) {
1892
		return false
1893
	}
1894
	if !yaml_emitter_write_block_scalar_hints(emitter, value) {
1895
		return false
1896
	}
1897
	if !yaml_emitter_process_line_comment(emitter) {
1898
		return false
1899
	}
1900
	//emitter.indention = true
1901
	emitter.whitespace = true
1902
	breaks := true
1903
	for i := 0; i < len(value); {
1904
		if is_break(value, i) {
1905
			if !write_break(emitter, value, &i) {
1906
				return false
1907
			}
1908
			//emitter.indention = true
1909
			breaks = true
1910
		} else {
1911
			if breaks {
1912
				if !yaml_emitter_write_indent(emitter) {
1913
					return false
1914
				}
1915
			}
1916
			if !write(emitter, value, &i) {
1917
				return false
1918
			}
1919
			emitter.indention = false
1920
			breaks = false
1921
		}
1922
	}
1923

1924
	return true
1925
}
1926

1927
func yaml_emitter_write_folded_scalar(emitter *yaml_emitter_t, value []byte) bool {
1928
	if !yaml_emitter_write_indicator(emitter, []byte{'>'}, true, false, false) {
1929
		return false
1930
	}
1931
	if !yaml_emitter_write_block_scalar_hints(emitter, value) {
1932
		return false
1933
	}
1934
	if !yaml_emitter_process_line_comment(emitter) {
1935
		return false
1936
	}
1937

1938
	//emitter.indention = true
1939
	emitter.whitespace = true
1940

1941
	breaks := true
1942
	leading_spaces := true
1943
	for i := 0; i < len(value); {
1944
		if is_break(value, i) {
1945
			if !breaks && !leading_spaces && value[i] == '\n' {
1946
				k := 0
1947
				for is_break(value, k) {
1948
					k += width(value[k])
1949
				}
1950
				if !is_blankz(value, k) {
1951
					if !put_break(emitter) {
1952
						return false
1953
					}
1954
				}
1955
			}
1956
			if !write_break(emitter, value, &i) {
1957
				return false
1958
			}
1959
			//emitter.indention = true
1960
			breaks = true
1961
		} else {
1962
			if breaks {
1963
				if !yaml_emitter_write_indent(emitter) {
1964
					return false
1965
				}
1966
				leading_spaces = is_blank(value, i)
1967
			}
1968
			if !breaks && is_space(value, i) && !is_space(value, i+1) && emitter.column > emitter.best_width {
1969
				if !yaml_emitter_write_indent(emitter) {
1970
					return false
1971
				}
1972
				i += width(value[i])
1973
			} else {
1974
				if !write(emitter, value, &i) {
1975
					return false
1976
				}
1977
			}
1978
			emitter.indention = false
1979
			breaks = false
1980
		}
1981
	}
1982
	return true
1983
}
1984

1985
func yaml_emitter_write_comment(emitter *yaml_emitter_t, comment []byte) bool {
1986
	breaks := false
1987
	pound := false
1988
	for i := 0; i < len(comment); {
1989
		if is_break(comment, i) {
1990
			if !write_break(emitter, comment, &i) {
1991
				return false
1992
			}
1993
			//emitter.indention = true
1994
			breaks = true
1995
			pound = false
1996
		} else {
1997
			if breaks && !yaml_emitter_write_indent(emitter) {
1998
				return false
1999
			}
2000
			if !pound {
2001
				if comment[i] != '#' && (!put(emitter, '#') || !put(emitter, ' ')) {
2002
					return false
2003
				}
2004
				pound = true
2005
			}
2006
			if !write(emitter, comment, &i) {
2007
				return false
2008
			}
2009
			emitter.indention = false
2010
			breaks = false
2011
		}
2012
	}
2013
	if !breaks && !put_break(emitter) {
2014
		return false
2015
	}
2016

2017
	emitter.whitespace = true
2018
	//emitter.indention = true
2019
	return true
2020
}
2021

2022