podman

1
package yaml
2

3
import (
4
	"bytes"
5
	"fmt"
6
)
7

8
// Flush the buffer if needed.
9
func flush(emitter *yaml_emitter_t) bool {
10
	if emitter.buffer_pos+5 >= len(emitter.buffer) {
11
		return yaml_emitter_flush(emitter)
12
	}
13
	return true
14
}
15

16
// Put a character to the output buffer.
17
func put(emitter *yaml_emitter_t, value byte) bool {
18
	if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
19
		return false
20
	}
21
	emitter.buffer[emitter.buffer_pos] = value
22
	emitter.buffer_pos++
23
	emitter.column++
24
	return true
25
}
26

27
// Put a line break to the output buffer.
28
func put_break(emitter *yaml_emitter_t) bool {
29
	if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
30
		return false
31
	}
32
	switch emitter.line_break {
33
	case yaml_CR_BREAK:
34
		emitter.buffer[emitter.buffer_pos] = '\r'
35
		emitter.buffer_pos += 1
36
	case yaml_LN_BREAK:
37
		emitter.buffer[emitter.buffer_pos] = '\n'
38
		emitter.buffer_pos += 1
39
	case yaml_CRLN_BREAK:
40
		emitter.buffer[emitter.buffer_pos+0] = '\r'
41
		emitter.buffer[emitter.buffer_pos+1] = '\n'
42
		emitter.buffer_pos += 2
43
	default:
44
		panic("unknown line break setting")
45
	}
46
	emitter.column = 0
47
	emitter.line++
48
	return true
49
}
50

51
// Copy a character from a string into buffer.
52
func write(emitter *yaml_emitter_t, s []byte, i *int) bool {
53
	if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
54
		return false
55
	}
56
	p := emitter.buffer_pos
57
	w := width(s[*i])
58
	switch w {
59
	case 4:
60
		emitter.buffer[p+3] = s[*i+3]
61
		fallthrough
62
	case 3:
63
		emitter.buffer[p+2] = s[*i+2]
64
		fallthrough
65
	case 2:
66
		emitter.buffer[p+1] = s[*i+1]
67
		fallthrough
68
	case 1:
69
		emitter.buffer[p+0] = s[*i+0]
70
	default:
71
		panic("unknown character width")
72
	}
73
	emitter.column++
74
	emitter.buffer_pos += w
75
	*i += w
76
	return true
77
}
78

79
// Write a whole string into buffer.
80
func write_all(emitter *yaml_emitter_t, s []byte) bool {
81
	for i := 0; i < len(s); {
82
		if !write(emitter, s, &i) {
83
			return false
84
		}
85
	}
86
	return true
87
}
88

89
// Copy a line break character from a string into buffer.
90
func write_break(emitter *yaml_emitter_t, s []byte, i *int) bool {
91
	if s[*i] == '\n' {
92
		if !put_break(emitter) {
93
			return false
94
		}
95
		*i++
96
	} else {
97
		if !write(emitter, s, i) {
98
			return false
99
		}
100
		emitter.column = 0
101
		emitter.line++
102
	}
103
	return true
104
}
105

106
// Set an emitter error and return false.
107
func yaml_emitter_set_emitter_error(emitter *yaml_emitter_t, problem string) bool {
108
	emitter.error = yaml_EMITTER_ERROR
109
	emitter.problem = problem
110
	return false
111
}
112

113
// Emit an event.
114
func yaml_emitter_emit(emitter *yaml_emitter_t, event *yaml_event_t) bool {
115
	emitter.events = append(emitter.events, *event)
116
	for !yaml_emitter_need_more_events(emitter) {
117
		event := &emitter.events[emitter.events_head]
118
		if !yaml_emitter_analyze_event(emitter, event) {
119
			return false
120
		}
121
		if !yaml_emitter_state_machine(emitter, event) {
122
			return false
123
		}
124
		yaml_event_delete(event)
125
		emitter.events_head++
126
	}
127
	return true
128
}
129

130
// Check if we need to accumulate more events before emitting.
131
//
132
// We accumulate extra
133
//  - 1 event for DOCUMENT-START
134
//  - 2 events for SEQUENCE-START
135
//  - 3 events for MAPPING-START
136
//
137
func yaml_emitter_need_more_events(emitter *yaml_emitter_t) bool {
138
	if emitter.events_head == len(emitter.events) {
139
		return true
140
	}
141
	var accumulate int
142
	switch emitter.events[emitter.events_head].typ {
143
	case yaml_DOCUMENT_START_EVENT:
144
		accumulate = 1
145
		break
146
	case yaml_SEQUENCE_START_EVENT:
147
		accumulate = 2
148
		break
149
	case yaml_MAPPING_START_EVENT:
150
		accumulate = 3
151
		break
152
	default:
153
		return false
154
	}
155
	if len(emitter.events)-emitter.events_head > accumulate {
156
		return false
157
	}
158
	var level int
159
	for i := emitter.events_head; i < len(emitter.events); i++ {
160
		switch emitter.events[i].typ {
161
		case yaml_STREAM_START_EVENT, yaml_DOCUMENT_START_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT:
162
			level++
163
		case yaml_STREAM_END_EVENT, yaml_DOCUMENT_END_EVENT, yaml_SEQUENCE_END_EVENT, yaml_MAPPING_END_EVENT:
164
			level--
165
		}
166
		if level == 0 {
167
			return false
168
		}
169
	}
170
	return true
171
}
172

173
// Append a directive to the directives stack.
174
func yaml_emitter_append_tag_directive(emitter *yaml_emitter_t, value *yaml_tag_directive_t, allow_duplicates bool) bool {
175
	for i := 0; i < len(emitter.tag_directives); i++ {
176
		if bytes.Equal(value.handle, emitter.tag_directives[i].handle) {
177
			if allow_duplicates {
178
				return true
179
			}
180
			return yaml_emitter_set_emitter_error(emitter, "duplicate %TAG directive")
181
		}
182
	}
183

184
	// [Go] Do we actually need to copy this given garbage collection
185
	// and the lack of deallocating destructors?
186
	tag_copy := yaml_tag_directive_t{
187
		handle: make([]byte, len(value.handle)),
188
		prefix: make([]byte, len(value.prefix)),
189
	}
190
	copy(tag_copy.handle, value.handle)
191
	copy(tag_copy.prefix, value.prefix)
192
	emitter.tag_directives = append(emitter.tag_directives, tag_copy)
193
	return true
194
}
195

196
// Increase the indentation level.
197
func yaml_emitter_increase_indent(emitter *yaml_emitter_t, flow, indentless bool) bool {
198
	emitter.indents = append(emitter.indents, emitter.indent)
199
	if emitter.indent < 0 {
200
		if flow {
201
			emitter.indent = emitter.best_indent
202
		} else {
203
			emitter.indent = 0
204
		}
205
	} else if !indentless {
206
		emitter.indent += emitter.best_indent
207
	}
208
	return true
209
}
210

211
// State dispatcher.
212
func yaml_emitter_state_machine(emitter *yaml_emitter_t, event *yaml_event_t) bool {
213
	switch emitter.state {
214
	default:
215
	case yaml_EMIT_STREAM_START_STATE:
216
		return yaml_emitter_emit_stream_start(emitter, event)
217

218
	case yaml_EMIT_FIRST_DOCUMENT_START_STATE:
219
		return yaml_emitter_emit_document_start(emitter, event, true)
220

221
	case yaml_EMIT_DOCUMENT_START_STATE:
222
		return yaml_emitter_emit_document_start(emitter, event, false)
223

224
	case yaml_EMIT_DOCUMENT_CONTENT_STATE:
225
		return yaml_emitter_emit_document_content(emitter, event)
226

227
	case yaml_EMIT_DOCUMENT_END_STATE:
228
		return yaml_emitter_emit_document_end(emitter, event)
229

230
	case yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE:
231
		return yaml_emitter_emit_flow_sequence_item(emitter, event, true)
232

233
	case yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE:
234
		return yaml_emitter_emit_flow_sequence_item(emitter, event, false)
235

236
	case yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE:
237
		return yaml_emitter_emit_flow_mapping_key(emitter, event, true)
238

239
	case yaml_EMIT_FLOW_MAPPING_KEY_STATE:
240
		return yaml_emitter_emit_flow_mapping_key(emitter, event, false)
241

242
	case yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE:
243
		return yaml_emitter_emit_flow_mapping_value(emitter, event, true)
244

245
	case yaml_EMIT_FLOW_MAPPING_VALUE_STATE:
246
		return yaml_emitter_emit_flow_mapping_value(emitter, event, false)
247

248
	case yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE:
249
		return yaml_emitter_emit_block_sequence_item(emitter, event, true)
250

251
	case yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE:
252
		return yaml_emitter_emit_block_sequence_item(emitter, event, false)
253

254
	case yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE:
255
		return yaml_emitter_emit_block_mapping_key(emitter, event, true)
256

257
	case yaml_EMIT_BLOCK_MAPPING_KEY_STATE:
258
		return yaml_emitter_emit_block_mapping_key(emitter, event, false)
259

260
	case yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE:
261
		return yaml_emitter_emit_block_mapping_value(emitter, event, true)
262

263
	case yaml_EMIT_BLOCK_MAPPING_VALUE_STATE:
264
		return yaml_emitter_emit_block_mapping_value(emitter, event, false)
265

266
	case yaml_EMIT_END_STATE:
267
		return yaml_emitter_set_emitter_error(emitter, "expected nothing after STREAM-END")
268
	}
269
	panic("invalid emitter state")
270
}
271

272
// Expect STREAM-START.
273
func yaml_emitter_emit_stream_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {
274
	if event.typ != yaml_STREAM_START_EVENT {
275
		return yaml_emitter_set_emitter_error(emitter, "expected STREAM-START")
276
	}
277
	if emitter.encoding == yaml_ANY_ENCODING {
278
		emitter.encoding = event.encoding
279
		if emitter.encoding == yaml_ANY_ENCODING {
280
			emitter.encoding = yaml_UTF8_ENCODING
281
		}
282
	}
283
	if emitter.best_indent < 2 || emitter.best_indent > 9 {
284
		emitter.best_indent = 2
285
	}
286
	if emitter.best_width >= 0 && emitter.best_width <= emitter.best_indent*2 {
287
		emitter.best_width = 80
288
	}
289
	if emitter.best_width < 0 {
290
		emitter.best_width = 1<<31 - 1
291
	}
292
	if emitter.line_break == yaml_ANY_BREAK {
293
		emitter.line_break = yaml_LN_BREAK
294
	}
295

296
	emitter.indent = -1
297
	emitter.line = 0
298
	emitter.column = 0
299
	emitter.whitespace = true
300
	emitter.indention = true
301

302
	if emitter.encoding != yaml_UTF8_ENCODING {
303
		if !yaml_emitter_write_bom(emitter) {
304
			return false
305
		}
306
	}
307
	emitter.state = yaml_EMIT_FIRST_DOCUMENT_START_STATE
308
	return true
309
}
310

311
// Expect DOCUMENT-START or STREAM-END.
312
func yaml_emitter_emit_document_start(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
313

314
	if event.typ == yaml_DOCUMENT_START_EVENT {
315

316
		if event.version_directive != nil {
317
			if !yaml_emitter_analyze_version_directive(emitter, event.version_directive) {
318
				return false
319
			}
320
		}
321

322
		for i := 0; i < len(event.tag_directives); i++ {
323
			tag_directive := &event.tag_directives[i]
324
			if !yaml_emitter_analyze_tag_directive(emitter, tag_directive) {
325
				return false
326
			}
327
			if !yaml_emitter_append_tag_directive(emitter, tag_directive, false) {
328
				return false
329
			}
330
		}
331

332
		for i := 0; i < len(default_tag_directives); i++ {
333
			tag_directive := &default_tag_directives[i]
334
			if !yaml_emitter_append_tag_directive(emitter, tag_directive, true) {
335
				return false
336
			}
337
		}
338

339
		implicit := event.implicit
340
		if !first || emitter.canonical {
341
			implicit = false
342
		}
343

344
		if emitter.open_ended && (event.version_directive != nil || len(event.tag_directives) > 0) {
345
			if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
346
				return false
347
			}
348
			if !yaml_emitter_write_indent(emitter) {
349
				return false
350
			}
351
		}
352

353
		if event.version_directive != nil {
354
			implicit = false
355
			if !yaml_emitter_write_indicator(emitter, []byte("%YAML"), true, false, false) {
356
				return false
357
			}
358
			if !yaml_emitter_write_indicator(emitter, []byte("1.1"), true, false, false) {
359
				return false
360
			}
361
			if !yaml_emitter_write_indent(emitter) {
362
				return false
363
			}
364
		}
365

366
		if len(event.tag_directives) > 0 {
367
			implicit = false
368
			for i := 0; i < len(event.tag_directives); i++ {
369
				tag_directive := &event.tag_directives[i]
370
				if !yaml_emitter_write_indicator(emitter, []byte("%TAG"), true, false, false) {
371
					return false
372
				}
373
				if !yaml_emitter_write_tag_handle(emitter, tag_directive.handle) {
374
					return false
375
				}
376
				if !yaml_emitter_write_tag_content(emitter, tag_directive.prefix, true) {
377
					return false
378
				}
379
				if !yaml_emitter_write_indent(emitter) {
380
					return false
381
				}
382
			}
383
		}
384

385
		if yaml_emitter_check_empty_document(emitter) {
386
			implicit = false
387
		}
388
		if !implicit {
389
			if !yaml_emitter_write_indent(emitter) {
390
				return false
391
			}
392
			if !yaml_emitter_write_indicator(emitter, []byte("---"), true, false, false) {
393
				return false
394
			}
395
			if emitter.canonical {
396
				if !yaml_emitter_write_indent(emitter) {
397
					return false
398
				}
399
			}
400
		}
401

402
		emitter.state = yaml_EMIT_DOCUMENT_CONTENT_STATE
403
		return true
404
	}
405

406
	if event.typ == yaml_STREAM_END_EVENT {
407
		if emitter.open_ended {
408
			if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
409
				return false
410
			}
411
			if !yaml_emitter_write_indent(emitter) {
412
				return false
413
			}
414
		}
415
		if !yaml_emitter_flush(emitter) {
416
			return false
417
		}
418
		emitter.state = yaml_EMIT_END_STATE
419
		return true
420
	}
421

422
	return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-START or STREAM-END")
423
}
424

425
// Expect the root node.
426
func yaml_emitter_emit_document_content(emitter *yaml_emitter_t, event *yaml_event_t) bool {
427
	emitter.states = append(emitter.states, yaml_EMIT_DOCUMENT_END_STATE)
428
	return yaml_emitter_emit_node(emitter, event, true, false, false, false)
429
}
430

431
// Expect DOCUMENT-END.
432
func yaml_emitter_emit_document_end(emitter *yaml_emitter_t, event *yaml_event_t) bool {
433
	if event.typ != yaml_DOCUMENT_END_EVENT {
434
		return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-END")
435
	}
436
	if !yaml_emitter_write_indent(emitter) {
437
		return false
438
	}
439
	if !event.implicit {
440
		// [Go] Allocate the slice elsewhere.
441
		if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
442
			return false
443
		}
444
		if !yaml_emitter_write_indent(emitter) {
445
			return false
446
		}
447
	}
448
	if !yaml_emitter_flush(emitter) {
449
		return false
450
	}
451
	emitter.state = yaml_EMIT_DOCUMENT_START_STATE
452
	emitter.tag_directives = emitter.tag_directives[:0]
453
	return true
454
}
455

456
// Expect a flow item node.
457
func yaml_emitter_emit_flow_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
458
	if first {
459
		if !yaml_emitter_write_indicator(emitter, []byte{'['}, true, true, false) {
460
			return false
461
		}
462
		if !yaml_emitter_increase_indent(emitter, true, false) {
463
			return false
464
		}
465
		emitter.flow_level++
466
	}
467

468
	if event.typ == yaml_SEQUENCE_END_EVENT {
469
		emitter.flow_level--
470
		emitter.indent = emitter.indents[len(emitter.indents)-1]
471
		emitter.indents = emitter.indents[:len(emitter.indents)-1]
472
		if emitter.canonical && !first {
473
			if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
474
				return false
475
			}
476
			if !yaml_emitter_write_indent(emitter) {
477
				return false
478
			}
479
		}
480
		if !yaml_emitter_write_indicator(emitter, []byte{']'}, false, false, false) {
481
			return false
482
		}
483
		emitter.state = emitter.states[len(emitter.states)-1]
484
		emitter.states = emitter.states[:len(emitter.states)-1]
485

486
		return true
487
	}
488

489
	if !first {
490
		if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
491
			return false
492
		}
493
	}
494

495
	if emitter.canonical || emitter.column > emitter.best_width {
496
		if !yaml_emitter_write_indent(emitter) {
497
			return false
498
		}
499
	}
500
	emitter.states = append(emitter.states, yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE)
501
	return yaml_emitter_emit_node(emitter, event, false, true, false, false)
502
}
503

504
// Expect a flow key node.
505
func yaml_emitter_emit_flow_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
506
	if first {
507
		if !yaml_emitter_write_indicator(emitter, []byte{'{'}, true, true, false) {
508
			return false
509
		}
510
		if !yaml_emitter_increase_indent(emitter, true, false) {
511
			return false
512
		}
513
		emitter.flow_level++
514
	}
515

516
	if event.typ == yaml_MAPPING_END_EVENT {
517
		emitter.flow_level--
518
		emitter.indent = emitter.indents[len(emitter.indents)-1]
519
		emitter.indents = emitter.indents[:len(emitter.indents)-1]
520
		if emitter.canonical && !first {
521
			if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
522
				return false
523
			}
524
			if !yaml_emitter_write_indent(emitter) {
525
				return false
526
			}
527
		}
528
		if !yaml_emitter_write_indicator(emitter, []byte{'}'}, false, false, false) {
529
			return false
530
		}
531
		emitter.state = emitter.states[len(emitter.states)-1]
532
		emitter.states = emitter.states[:len(emitter.states)-1]
533
		return true
534
	}
535

536
	if !first {
537
		if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
538
			return false
539
		}
540
	}
541
	if emitter.canonical || emitter.column > emitter.best_width {
542
		if !yaml_emitter_write_indent(emitter) {
543
			return false
544
		}
545
	}
546

547
	if !emitter.canonical && yaml_emitter_check_simple_key(emitter) {
548
		emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE)
549
		return yaml_emitter_emit_node(emitter, event, false, false, true, true)
550
	}
551
	if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, false) {
552
		return false
553
	}
554
	emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_VALUE_STATE)
555
	return yaml_emitter_emit_node(emitter, event, false, false, true, false)
556
}
557

558
// Expect a flow value node.
559
func yaml_emitter_emit_flow_mapping_value(emitter *yaml_emitter_t, event *yaml_event_t, simple bool) bool {
560
	if simple {
561
		if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) {
562
			return false
563
		}
564
	} else {
565
		if emitter.canonical || emitter.column > emitter.best_width {
566
			if !yaml_emitter_write_indent(emitter) {
567
				return false
568
			}
569
		}
570
		if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, false) {
571
			return false
572
		}
573
	}
574
	emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_KEY_STATE)
575
	return yaml_emitter_emit_node(emitter, event, false, false, true, false)
576
}
577

578
// Expect a block item node.
579
func yaml_emitter_emit_block_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
580
	if first {
581
		if !yaml_emitter_increase_indent(emitter, false, emitter.mapping_context && !emitter.indention) {
582
			return false
583
		}
584
	}
585
	if event.typ == yaml_SEQUENCE_END_EVENT {
586
		emitter.indent = emitter.indents[len(emitter.indents)-1]
587
		emitter.indents = emitter.indents[:len(emitter.indents)-1]
588
		emitter.state = emitter.states[len(emitter.states)-1]
589
		emitter.states = emitter.states[:len(emitter.states)-1]
590
		return true
591
	}
592
	if !yaml_emitter_write_indent(emitter) {
593
		return false
594
	}
595
	if !yaml_emitter_write_indicator(emitter, []byte{'-'}, true, false, true) {
596
		return false
597
	}
598
	emitter.states = append(emitter.states, yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE)
599
	return yaml_emitter_emit_node(emitter, event, false, true, false, false)
600
}
601

602
// Expect a block key node.
603
func yaml_emitter_emit_block_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
604
	if first {
605
		if !yaml_emitter_increase_indent(emitter, false, false) {
606
			return false
607
		}
608
	}
609
	if event.typ == yaml_MAPPING_END_EVENT {
610
		emitter.indent = emitter.indents[len(emitter.indents)-1]
611
		emitter.indents = emitter.indents[:len(emitter.indents)-1]
612
		emitter.state = emitter.states[len(emitter.states)-1]
613
		emitter.states = emitter.states[:len(emitter.states)-1]
614
		return true
615
	}
616
	if !yaml_emitter_write_indent(emitter) {
617
		return false
618
	}
619
	if yaml_emitter_check_simple_key(emitter) {
620
		emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE)
621
		return yaml_emitter_emit_node(emitter, event, false, false, true, true)
622
	}
623
	if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, true) {
624
		return false
625
	}
626
	emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_VALUE_STATE)
627
	return yaml_emitter_emit_node(emitter, event, false, false, true, false)
628
}
629

630
// Expect a block value node.
631
func yaml_emitter_emit_block_mapping_value(emitter *yaml_emitter_t, event *yaml_event_t, simple bool) bool {
632
	if simple {
633
		if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) {
634
			return false
635
		}
636
	} else {
637
		if !yaml_emitter_write_indent(emitter) {
638
			return false
639
		}
640
		if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, true) {
641
			return false
642
		}
643
	}
644
	emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_KEY_STATE)
645
	return yaml_emitter_emit_node(emitter, event, false, false, true, false)
646
}
647

648
// Expect a node.
649
func yaml_emitter_emit_node(emitter *yaml_emitter_t, event *yaml_event_t,
650
	root bool, sequence bool, mapping bool, simple_key bool) bool {
651

652
	emitter.root_context = root
653
	emitter.sequence_context = sequence
654
	emitter.mapping_context = mapping
655
	emitter.simple_key_context = simple_key
656

657
	switch event.typ {
658
	case yaml_ALIAS_EVENT:
659
		return yaml_emitter_emit_alias(emitter, event)
660
	case yaml_SCALAR_EVENT:
661
		return yaml_emitter_emit_scalar(emitter, event)
662
	case yaml_SEQUENCE_START_EVENT:
663
		return yaml_emitter_emit_sequence_start(emitter, event)
664
	case yaml_MAPPING_START_EVENT:
665
		return yaml_emitter_emit_mapping_start(emitter, event)
666
	default:
667
		return yaml_emitter_set_emitter_error(emitter,
668
			fmt.Sprintf("expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS, but got %v", event.typ))
669
	}
670
}
671

672
// Expect ALIAS.
673
func yaml_emitter_emit_alias(emitter *yaml_emitter_t, event *yaml_event_t) bool {
674
	if !yaml_emitter_process_anchor(emitter) {
675
		return false
676
	}
677
	emitter.state = emitter.states[len(emitter.states)-1]
678
	emitter.states = emitter.states[:len(emitter.states)-1]
679
	return true
680
}
681

682
// Expect SCALAR.
683
func yaml_emitter_emit_scalar(emitter *yaml_emitter_t, event *yaml_event_t) bool {
684
	if !yaml_emitter_select_scalar_style(emitter, event) {
685
		return false
686
	}
687
	if !yaml_emitter_process_anchor(emitter) {
688
		return false
689
	}
690
	if !yaml_emitter_process_tag(emitter) {
691
		return false
692
	}
693
	if !yaml_emitter_increase_indent(emitter, true, false) {
694
		return false
695
	}
696
	if !yaml_emitter_process_scalar(emitter) {
697
		return false
698
	}
699
	emitter.indent = emitter.indents[len(emitter.indents)-1]
700
	emitter.indents = emitter.indents[:len(emitter.indents)-1]
701
	emitter.state = emitter.states[len(emitter.states)-1]
702
	emitter.states = emitter.states[:len(emitter.states)-1]
703
	return true
704
}
705

706
// Expect SEQUENCE-START.
707
func yaml_emitter_emit_sequence_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {
708
	if !yaml_emitter_process_anchor(emitter) {
709
		return false
710
	}
711
	if !yaml_emitter_process_tag(emitter) {
712
		return false
713
	}
714
	if emitter.flow_level > 0 || emitter.canonical || event.sequence_style() == yaml_FLOW_SEQUENCE_STYLE ||
715
		yaml_emitter_check_empty_sequence(emitter) {
716
		emitter.state = yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE
717
	} else {
718
		emitter.state = yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE
719
	}
720
	return true
721
}
722

723
// Expect MAPPING-START.
724
func yaml_emitter_emit_mapping_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {
725
	if !yaml_emitter_process_anchor(emitter) {
726
		return false
727
	}
728
	if !yaml_emitter_process_tag(emitter) {
729
		return false
730
	}
731
	if emitter.flow_level > 0 || emitter.canonical || event.mapping_style() == yaml_FLOW_MAPPING_STYLE ||
732
		yaml_emitter_check_empty_mapping(emitter) {
733
		emitter.state = yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE
734
	} else {
735
		emitter.state = yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE
736
	}
737
	return true
738
}
739

740
// Check if the document content is an empty scalar.
741
func yaml_emitter_check_empty_document(emitter *yaml_emitter_t) bool {
742
	return false // [Go] Huh?
743
}
744

745
// Check if the next events represent an empty sequence.
746
func yaml_emitter_check_empty_sequence(emitter *yaml_emitter_t) bool {
747
	if len(emitter.events)-emitter.events_head < 2 {
748
		return false
749
	}
750
	return emitter.events[emitter.events_head].typ == yaml_SEQUENCE_START_EVENT &&
751
		emitter.events[emitter.events_head+1].typ == yaml_SEQUENCE_END_EVENT
752
}
753

754
// Check if the next events represent an empty mapping.
755
func yaml_emitter_check_empty_mapping(emitter *yaml_emitter_t) bool {
756
	if len(emitter.events)-emitter.events_head < 2 {
757
		return false
758
	}
759
	return emitter.events[emitter.events_head].typ == yaml_MAPPING_START_EVENT &&
760
		emitter.events[emitter.events_head+1].typ == yaml_MAPPING_END_EVENT
761
}
762

763
// Check if the next node can be expressed as a simple key.
764
func yaml_emitter_check_simple_key(emitter *yaml_emitter_t) bool {
765
	length := 0
766
	switch emitter.events[emitter.events_head].typ {
767
	case yaml_ALIAS_EVENT:
768
		length += len(emitter.anchor_data.anchor)
769
	case yaml_SCALAR_EVENT:
770
		if emitter.scalar_data.multiline {
771
			return false
772
		}
773
		length += len(emitter.anchor_data.anchor) +
774
			len(emitter.tag_data.handle) +
775
			len(emitter.tag_data.suffix) +
776
			len(emitter.scalar_data.value)
777
	case yaml_SEQUENCE_START_EVENT:
778
		if !yaml_emitter_check_empty_sequence(emitter) {
779
			return false
780
		}
781
		length += len(emitter.anchor_data.anchor) +
782
			len(emitter.tag_data.handle) +
783
			len(emitter.tag_data.suffix)
784
	case yaml_MAPPING_START_EVENT:
785
		if !yaml_emitter_check_empty_mapping(emitter) {
786
			return false
787
		}
788
		length += len(emitter.anchor_data.anchor) +
789
			len(emitter.tag_data.handle) +
790
			len(emitter.tag_data.suffix)
791
	default:
792
		return false
793
	}
794
	return length <= 128
795
}
796

797
// Determine an acceptable scalar style.
798
func yaml_emitter_select_scalar_style(emitter *yaml_emitter_t, event *yaml_event_t) bool {
799

800
	no_tag := len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0
801
	if no_tag && !event.implicit && !event.quoted_implicit {
802
		return yaml_emitter_set_emitter_error(emitter, "neither tag nor implicit flags are specified")
803
	}
804

805
	style := event.scalar_style()
806
	if style == yaml_ANY_SCALAR_STYLE {
807
		style = yaml_PLAIN_SCALAR_STYLE
808
	}
809
	if emitter.canonical {
810
		style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
811
	}
812
	if emitter.simple_key_context && emitter.scalar_data.multiline {
813
		style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
814
	}
815

816
	if style == yaml_PLAIN_SCALAR_STYLE {
817
		if emitter.flow_level > 0 && !emitter.scalar_data.flow_plain_allowed ||
818
			emitter.flow_level == 0 && !emitter.scalar_data.block_plain_allowed {
819
			style = yaml_SINGLE_QUOTED_SCALAR_STYLE
820
		}
821
		if len(emitter.scalar_data.value) == 0 && (emitter.flow_level > 0 || emitter.simple_key_context) {
822
			style = yaml_SINGLE_QUOTED_SCALAR_STYLE
823
		}
824
		if no_tag && !event.implicit {
825
			style = yaml_SINGLE_QUOTED_SCALAR_STYLE
826
		}
827
	}
828
	if style == yaml_SINGLE_QUOTED_SCALAR_STYLE {
829
		if !emitter.scalar_data.single_quoted_allowed {
830
			style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
831
		}
832
	}
833
	if style == yaml_LITERAL_SCALAR_STYLE || style == yaml_FOLDED_SCALAR_STYLE {
834
		if !emitter.scalar_data.block_allowed || emitter.flow_level > 0 || emitter.simple_key_context {
835
			style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
836
		}
837
	}
838

839
	if no_tag && !event.quoted_implicit && style != yaml_PLAIN_SCALAR_STYLE {
840
		emitter.tag_data.handle = []byte{'!'}
841
	}
842
	emitter.scalar_data.style = style
843
	return true
844
}
845

846
// Write an anchor.
847
func yaml_emitter_process_anchor(emitter *yaml_emitter_t) bool {
848
	if emitter.anchor_data.anchor == nil {
849
		return true
850
	}
851
	c := []byte{'&'}
852
	if emitter.anchor_data.alias {
853
		c[0] = '*'
854
	}
855
	if !yaml_emitter_write_indicator(emitter, c, true, false, false) {
856
		return false
857
	}
858
	return yaml_emitter_write_anchor(emitter, emitter.anchor_data.anchor)
859
}
860

861
// Write a tag.
862
func yaml_emitter_process_tag(emitter *yaml_emitter_t) bool {
863
	if len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0 {
864
		return true
865
	}
866
	if len(emitter.tag_data.handle) > 0 {
867
		if !yaml_emitter_write_tag_handle(emitter, emitter.tag_data.handle) {
868
			return false
869
		}
870
		if len(emitter.tag_data.suffix) > 0 {
871
			if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) {
872
				return false
873
			}
874
		}
875
	} else {
876
		// [Go] Allocate these slices elsewhere.
877
		if !yaml_emitter_write_indicator(emitter, []byte("!<"), true, false, false) {
878
			return false
879
		}
880
		if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) {
881
			return false
882
		}
883
		if !yaml_emitter_write_indicator(emitter, []byte{'>'}, false, false, false) {
884
			return false
885
		}
886
	}
887
	return true
888
}
889

890
// Write a scalar.
891
func yaml_emitter_process_scalar(emitter *yaml_emitter_t) bool {
892
	switch emitter.scalar_data.style {
893
	case yaml_PLAIN_SCALAR_STYLE:
894
		return yaml_emitter_write_plain_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)
895

896
	case yaml_SINGLE_QUOTED_SCALAR_STYLE:
897
		return yaml_emitter_write_single_quoted_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)
898

899
	case yaml_DOUBLE_QUOTED_SCALAR_STYLE:
900
		return yaml_emitter_write_double_quoted_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)
901

902
	case yaml_LITERAL_SCALAR_STYLE:
903
		return yaml_emitter_write_literal_scalar(emitter, emitter.scalar_data.value)
904

905
	case yaml_FOLDED_SCALAR_STYLE:
906
		return yaml_emitter_write_folded_scalar(emitter, emitter.scalar_data.value)
907
	}
908
	panic("unknown scalar style")
909
}
910

911
// Check if a %YAML directive is valid.
912
func yaml_emitter_analyze_version_directive(emitter *yaml_emitter_t, version_directive *yaml_version_directive_t) bool {
913
	if version_directive.major != 1 || version_directive.minor != 1 {
914
		return yaml_emitter_set_emitter_error(emitter, "incompatible %YAML directive")
915
	}
916
	return true
917
}
918

919
// Check if a %TAG directive is valid.
920
func yaml_emitter_analyze_tag_directive(emitter *yaml_emitter_t, tag_directive *yaml_tag_directive_t) bool {
921
	handle := tag_directive.handle
922
	prefix := tag_directive.prefix
923
	if len(handle) == 0 {
924
		return yaml_emitter_set_emitter_error(emitter, "tag handle must not be empty")
925
	}
926
	if handle[0] != '!' {
927
		return yaml_emitter_set_emitter_error(emitter, "tag handle must start with '!'")
928
	}
929
	if handle[len(handle)-1] != '!' {
930
		return yaml_emitter_set_emitter_error(emitter, "tag handle must end with '!'")
931
	}
932
	for i := 1; i < len(handle)-1; i += width(handle[i]) {
933
		if !is_alpha(handle, i) {
934
			return yaml_emitter_set_emitter_error(emitter, "tag handle must contain alphanumerical characters only")
935
		}
936
	}
937
	if len(prefix) == 0 {
938
		return yaml_emitter_set_emitter_error(emitter, "tag prefix must not be empty")
939
	}
940
	return true
941
}
942

943
// Check if an anchor is valid.
944
func yaml_emitter_analyze_anchor(emitter *yaml_emitter_t, anchor []byte, alias bool) bool {
945
	if len(anchor) == 0 {
946
		problem := "anchor value must not be empty"
947
		if alias {
948
			problem = "alias value must not be empty"
949
		}
950
		return yaml_emitter_set_emitter_error(emitter, problem)
951
	}
952
	for i := 0; i < len(anchor); i += width(anchor[i]) {
953
		if !is_alpha(anchor, i) {
954
			problem := "anchor value must contain alphanumerical characters only"
955
			if alias {
956
				problem = "alias value must contain alphanumerical characters only"
957
			}
958
			return yaml_emitter_set_emitter_error(emitter, problem)
959
		}
960
	}
961
	emitter.anchor_data.anchor = anchor
962
	emitter.anchor_data.alias = alias
963
	return true
964
}
965

966
// Check if a tag is valid.
967
func yaml_emitter_analyze_tag(emitter *yaml_emitter_t, tag []byte) bool {
968
	if len(tag) == 0 {
969
		return yaml_emitter_set_emitter_error(emitter, "tag value must not be empty")
970
	}
971
	for i := 0; i < len(emitter.tag_directives); i++ {
972
		tag_directive := &emitter.tag_directives[i]
973
		if bytes.HasPrefix(tag, tag_directive.prefix) {
974
			emitter.tag_data.handle = tag_directive.handle
975
			emitter.tag_data.suffix = tag[len(tag_directive.prefix):]
976
			return true
977
		}
978
	}
979
	emitter.tag_data.suffix = tag
980
	return true
981
}
982

983
// Check if a scalar is valid.
984
func yaml_emitter_analyze_scalar(emitter *yaml_emitter_t, value []byte) bool {
985
	var (
986
		block_indicators   = false
987
		flow_indicators    = false
988
		line_breaks        = false
989
		special_characters = false
990

991
		leading_space  = false
992
		leading_break  = false
993
		trailing_space = false
994
		trailing_break = false
995
		break_space    = false
996
		space_break    = false
997

998
		preceded_by_whitespace = false
999
		followed_by_whitespace = false
1000
		previous_space         = false
1001
		previous_break         = false
1002
	)
1003

1004
	emitter.scalar_data.value = value
1005

1006
	if len(value) == 0 {
1007
		emitter.scalar_data.multiline = false
1008
		emitter.scalar_data.flow_plain_allowed = false
1009
		emitter.scalar_data.block_plain_allowed = true
1010
		emitter.scalar_data.single_quoted_allowed = true
1011
		emitter.scalar_data.block_allowed = false
1012
		return true
1013
	}
1014

1015
	if len(value) >= 3 && ((value[0] == '-' && value[1] == '-' && value[2] == '-') || (value[0] == '.' && value[1] == '.' && value[2] == '.')) {
1016
		block_indicators = true
1017
		flow_indicators = true
1018
	}
1019

1020
	preceded_by_whitespace = true
1021
	for i, w := 0, 0; i < len(value); i += w {
1022
		w = width(value[i])
1023
		followed_by_whitespace = i+w >= len(value) || is_blank(value, i+w)
1024

1025
		if i == 0 {
1026
			switch value[i] {
1027
			case '#', ',', '[', ']', '{', '}', '&', '*', '!', '|', '>', '\'', '"', '%', '@', '`':
1028
				flow_indicators = true
1029
				block_indicators = true
1030
			case '?', ':':
1031
				flow_indicators = true
1032
				if followed_by_whitespace {
1033
					block_indicators = true
1034
				}
1035
			case '-':
1036
				if followed_by_whitespace {
1037
					flow_indicators = true
1038
					block_indicators = true
1039
				}
1040
			}
1041
		} else {
1042
			switch value[i] {
1043
			case ',', '?', '[', ']', '{', '}':
1044
				flow_indicators = true
1045
			case ':':
1046
				flow_indicators = true
1047
				if followed_by_whitespace {
1048
					block_indicators = true
1049
				}
1050
			case '#':
1051
				if preceded_by_whitespace {
1052
					flow_indicators = true
1053
					block_indicators = true
1054
				}
1055
			}
1056
		}
1057

1058
		if !is_printable(value, i) || !is_ascii(value, i) && !emitter.unicode {
1059
			special_characters = true
1060
		}
1061
		if is_space(value, i) {
1062
			if i == 0 {
1063
				leading_space = true
1064
			}
1065
			if i+width(value[i]) == len(value) {
1066
				trailing_space = true
1067
			}
1068
			if previous_break {
1069
				break_space = true
1070
			}
1071
			previous_space = true
1072
			previous_break = false
1073
		} else if is_break(value, i) {
1074
			line_breaks = true
1075
			if i == 0 {
1076
				leading_break = true
1077
			}
1078
			if i+width(value[i]) == len(value) {
1079
				trailing_break = true
1080
			}
1081
			if previous_space {
1082
				space_break = true
1083
			}
1084
			previous_space = false
1085
			previous_break = true
1086
		} else {
1087
			previous_space = false
1088
			previous_break = false
1089
		}
1090

1091
		// [Go]: Why 'z'? Couldn't be the end of the string as that's the loop condition.
1092
		preceded_by_whitespace = is_blankz(value, i)
1093
	}
1094

1095
	emitter.scalar_data.multiline = line_breaks
1096
	emitter.scalar_data.flow_plain_allowed = true
1097
	emitter.scalar_data.block_plain_allowed = true
1098
	emitter.scalar_data.single_quoted_allowed = true
1099
	emitter.scalar_data.block_allowed = true
1100

1101
	if leading_space || leading_break || trailing_space || trailing_break {
1102
		emitter.scalar_data.flow_plain_allowed = false
1103
		emitter.scalar_data.block_plain_allowed = false
1104
	}
1105
	if trailing_space {
1106
		emitter.scalar_data.block_allowed = false
1107
	}
1108
	if break_space {
1109
		emitter.scalar_data.flow_plain_allowed = false
1110
		emitter.scalar_data.block_plain_allowed = false
1111
		emitter.scalar_data.single_quoted_allowed = false
1112
	}
1113
	if space_break || special_characters {
1114
		emitter.scalar_data.flow_plain_allowed = false
1115
		emitter.scalar_data.block_plain_allowed = false
1116
		emitter.scalar_data.single_quoted_allowed = false
1117
		emitter.scalar_data.block_allowed = false
1118
	}
1119
	if line_breaks {
1120
		emitter.scalar_data.flow_plain_allowed = false
1121
		emitter.scalar_data.block_plain_allowed = false
1122
	}
1123
	if flow_indicators {
1124
		emitter.scalar_data.flow_plain_allowed = false
1125
	}
1126
	if block_indicators {
1127
		emitter.scalar_data.block_plain_allowed = false
1128
	}
1129
	return true
1130
}
1131

1132
// Check if the event data is valid.
1133
func yaml_emitter_analyze_event(emitter *yaml_emitter_t, event *yaml_event_t) bool {
1134

1135
	emitter.anchor_data.anchor = nil
1136
	emitter.tag_data.handle = nil
1137
	emitter.tag_data.suffix = nil
1138
	emitter.scalar_data.value = nil
1139

1140
	switch event.typ {
1141
	case yaml_ALIAS_EVENT:
1142
		if !yaml_emitter_analyze_anchor(emitter, event.anchor, true) {
1143
			return false
1144
		}
1145

1146
	case yaml_SCALAR_EVENT:
1147
		if len(event.anchor) > 0 {
1148
			if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
1149
				return false
1150
			}
1151
		}
1152
		if len(event.tag) > 0 && (emitter.canonical || (!event.implicit && !event.quoted_implicit)) {
1153
			if !yaml_emitter_analyze_tag(emitter, event.tag) {
1154
				return false
1155
			}
1156
		}
1157
		if !yaml_emitter_analyze_scalar(emitter, event.value) {
1158
			return false
1159
		}
1160

1161
	case yaml_SEQUENCE_START_EVENT:
1162
		if len(event.anchor) > 0 {
1163
			if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
1164
				return false
1165
			}
1166
		}
1167
		if len(event.tag) > 0 && (emitter.canonical || !event.implicit) {
1168
			if !yaml_emitter_analyze_tag(emitter, event.tag) {
1169
				return false
1170
			}
1171
		}
1172

1173
	case yaml_MAPPING_START_EVENT:
1174
		if len(event.anchor) > 0 {
1175
			if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
1176
				return false
1177
			}
1178
		}
1179
		if len(event.tag) > 0 && (emitter.canonical || !event.implicit) {
1180
			if !yaml_emitter_analyze_tag(emitter, event.tag) {
1181
				return false
1182
			}
1183
		}
1184
	}
1185
	return true
1186
}
1187

1188
// Write the BOM character.
1189
func yaml_emitter_write_bom(emitter *yaml_emitter_t) bool {
1190
	if !flush(emitter) {
1191
		return false
1192
	}
1193
	pos := emitter.buffer_pos
1194
	emitter.buffer[pos+0] = '\xEF'
1195
	emitter.buffer[pos+1] = '\xBB'
1196
	emitter.buffer[pos+2] = '\xBF'
1197
	emitter.buffer_pos += 3
1198
	return true
1199
}
1200

1201
func yaml_emitter_write_indent(emitter *yaml_emitter_t) bool {
1202
	indent := emitter.indent
1203
	if indent < 0 {
1204
		indent = 0
1205
	}
1206
	if !emitter.indention || emitter.column > indent || (emitter.column == indent && !emitter.whitespace) {
1207
		if !put_break(emitter) {
1208
			return false
1209
		}
1210
	}
1211
	for emitter.column < indent {
1212
		if !put(emitter, ' ') {
1213
			return false
1214
		}
1215
	}
1216
	emitter.whitespace = true
1217
	emitter.indention = true
1218
	return true
1219
}
1220

1221
func yaml_emitter_write_indicator(emitter *yaml_emitter_t, indicator []byte, need_whitespace, is_whitespace, is_indention bool) bool {
1222
	if need_whitespace && !emitter.whitespace {
1223
		if !put(emitter, ' ') {
1224
			return false
1225
		}
1226
	}
1227
	if !write_all(emitter, indicator) {
1228
		return false
1229
	}
1230
	emitter.whitespace = is_whitespace
1231
	emitter.indention = (emitter.indention && is_indention)
1232
	emitter.open_ended = false
1233
	return true
1234
}
1235

1236
func yaml_emitter_write_anchor(emitter *yaml_emitter_t, value []byte) bool {
1237
	if !write_all(emitter, value) {
1238
		return false
1239
	}
1240
	emitter.whitespace = false
1241
	emitter.indention = false
1242
	return true
1243
}
1244

1245
func yaml_emitter_write_tag_handle(emitter *yaml_emitter_t, value []byte) bool {
1246
	if !emitter.whitespace {
1247
		if !put(emitter, ' ') {
1248
			return false
1249
		}
1250
	}
1251
	if !write_all(emitter, value) {
1252
		return false
1253
	}
1254
	emitter.whitespace = false
1255
	emitter.indention = false
1256
	return true
1257
}
1258

1259
func yaml_emitter_write_tag_content(emitter *yaml_emitter_t, value []byte, need_whitespace bool) bool {
1260
	if need_whitespace && !emitter.whitespace {
1261
		if !put(emitter, ' ') {
1262
			return false
1263
		}
1264
	}
1265
	for i := 0; i < len(value); {
1266
		var must_write bool
1267
		switch value[i] {
1268
		case ';', '/', '?', ':', '@', '&', '=', '+', '$', ',', '_', '.', '~', '*', '\'', '(', ')', '[', ']':
1269
			must_write = true
1270
		default:
1271
			must_write = is_alpha(value, i)
1272
		}
1273
		if must_write {
1274
			if !write(emitter, value, &i) {
1275
				return false
1276
			}
1277
		} else {
1278
			w := width(value[i])
1279
			for k := 0; k < w; k++ {
1280
				octet := value[i]
1281
				i++
1282
				if !put(emitter, '%') {
1283
					return false
1284
				}
1285

1286
				c := octet >> 4
1287
				if c < 10 {
1288
					c += '0'
1289
				} else {
1290
					c += 'A' - 10
1291
				}
1292
				if !put(emitter, c) {
1293
					return false
1294
				}
1295

1296
				c = octet & 0x0f
1297
				if c < 10 {
1298
					c += '0'
1299
				} else {
1300
					c += 'A' - 10
1301
				}
1302
				if !put(emitter, c) {
1303
					return false
1304
				}
1305
			}
1306
		}
1307
	}
1308
	emitter.whitespace = false
1309
	emitter.indention = false
1310
	return true
1311
}
1312

1313
func yaml_emitter_write_plain_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
1314
	if !emitter.whitespace {
1315
		if !put(emitter, ' ') {
1316
			return false
1317
		}
1318
	}
1319

1320
	spaces := false
1321
	breaks := false
1322
	for i := 0; i < len(value); {
1323
		if is_space(value, i) {
1324
			if allow_breaks && !spaces && emitter.column > emitter.best_width && !is_space(value, i+1) {
1325
				if !yaml_emitter_write_indent(emitter) {
1326
					return false
1327
				}
1328
				i += width(value[i])
1329
			} else {
1330
				if !write(emitter, value, &i) {
1331
					return false
1332
				}
1333
			}
1334
			spaces = true
1335
		} else if is_break(value, i) {
1336
			if !breaks && value[i] == '\n' {
1337
				if !put_break(emitter) {
1338
					return false
1339
				}
1340
			}
1341
			if !write_break(emitter, value, &i) {
1342
				return false
1343
			}
1344
			emitter.indention = true
1345
			breaks = true
1346
		} else {
1347
			if breaks {
1348
				if !yaml_emitter_write_indent(emitter) {
1349
					return false
1350
				}
1351
			}
1352
			if !write(emitter, value, &i) {
1353
				return false
1354
			}
1355
			emitter.indention = false
1356
			spaces = false
1357
			breaks = false
1358
		}
1359
	}
1360

1361
	emitter.whitespace = false
1362
	emitter.indention = false
1363
	if emitter.root_context {
1364
		emitter.open_ended = true
1365
	}
1366

1367
	return true
1368
}
1369

1370
func yaml_emitter_write_single_quoted_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
1371

1372
	if !yaml_emitter_write_indicator(emitter, []byte{'\''}, true, false, false) {
1373
		return false
1374
	}
1375

1376
	spaces := false
1377
	breaks := false
1378
	for i := 0; i < len(value); {
1379
		if is_space(value, i) {
1380
			if allow_breaks && !spaces && emitter.column > emitter.best_width && i > 0 && i < len(value)-1 && !is_space(value, i+1) {
1381
				if !yaml_emitter_write_indent(emitter) {
1382
					return false
1383
				}
1384
				i += width(value[i])
1385
			} else {
1386
				if !write(emitter, value, &i) {
1387
					return false
1388
				}
1389
			}
1390
			spaces = true
1391
		} else if is_break(value, i) {
1392
			if !breaks && value[i] == '\n' {
1393
				if !put_break(emitter) {
1394
					return false
1395
				}
1396
			}
1397
			if !write_break(emitter, value, &i) {
1398
				return false
1399
			}
1400
			emitter.indention = true
1401
			breaks = true
1402
		} else {
1403
			if breaks {
1404
				if !yaml_emitter_write_indent(emitter) {
1405
					return false
1406
				}
1407
			}
1408
			if value[i] == '\'' {
1409
				if !put(emitter, '\'') {
1410
					return false
1411
				}
1412
			}
1413
			if !write(emitter, value, &i) {
1414
				return false
1415
			}
1416
			emitter.indention = false
1417
			spaces = false
1418
			breaks = false
1419
		}
1420
	}
1421
	if !yaml_emitter_write_indicator(emitter, []byte{'\''}, false, false, false) {
1422
		return false
1423
	}
1424
	emitter.whitespace = false
1425
	emitter.indention = false
1426
	return true
1427
}
1428

1429
func yaml_emitter_write_double_quoted_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
1430
	spaces := false
1431
	if !yaml_emitter_write_indicator(emitter, []byte{'"'}, true, false, false) {
1432
		return false
1433
	}
1434

1435
	for i := 0; i < len(value); {
1436
		if !is_printable(value, i) || (!emitter.unicode && !is_ascii(value, i)) ||
1437
			is_bom(value, i) || is_break(value, i) ||
1438
			value[i] == '"' || value[i] == '\\' {
1439

1440
			octet := value[i]
1441

1442
			var w int
1443
			var v rune
1444
			switch {
1445
			case octet&0x80 == 0x00:
1446
				w, v = 1, rune(octet&0x7F)
1447
			case octet&0xE0 == 0xC0:
1448
				w, v = 2, rune(octet&0x1F)
1449
			case octet&0xF0 == 0xE0:
1450
				w, v = 3, rune(octet&0x0F)
1451
			case octet&0xF8 == 0xF0:
1452
				w, v = 4, rune(octet&0x07)
1453
			}
1454
			for k := 1; k < w; k++ {
1455
				octet = value[i+k]
1456
				v = (v << 6) + (rune(octet) & 0x3F)
1457
			}
1458
			i += w
1459

1460
			if !put(emitter, '\\') {
1461
				return false
1462
			}
1463

1464
			var ok bool
1465
			switch v {
1466
			case 0x00:
1467
				ok = put(emitter, '0')
1468
			case 0x07:
1469
				ok = put(emitter, 'a')
1470
			case 0x08:
1471
				ok = put(emitter, 'b')
1472
			case 0x09:
1473
				ok = put(emitter, 't')
1474
			case 0x0A:
1475
				ok = put(emitter, 'n')
1476
			case 0x0b:
1477
				ok = put(emitter, 'v')
1478
			case 0x0c:
1479
				ok = put(emitter, 'f')
1480
			case 0x0d:
1481
				ok = put(emitter, 'r')
1482
			case 0x1b:
1483
				ok = put(emitter, 'e')
1484
			case 0x22:
1485
				ok = put(emitter, '"')
1486
			case 0x5c:
1487
				ok = put(emitter, '\\')
1488
			case 0x85:
1489
				ok = put(emitter, 'N')
1490
			case 0xA0:
1491
				ok = put(emitter, '_')
1492
			case 0x2028:
1493
				ok = put(emitter, 'L')
1494
			case 0x2029:
1495
				ok = put(emitter, 'P')
1496
			default:
1497
				if v <= 0xFF {
1498
					ok = put(emitter, 'x')
1499
					w = 2
1500
				} else if v <= 0xFFFF {
1501
					ok = put(emitter, 'u')
1502
					w = 4
1503
				} else {
1504
					ok = put(emitter, 'U')
1505
					w = 8
1506
				}
1507
				for k := (w - 1) * 4; ok && k >= 0; k -= 4 {
1508
					digit := byte((v >> uint(k)) & 0x0F)
1509
					if digit < 10 {
1510
						ok = put(emitter, digit+'0')
1511
					} else {
1512
						ok = put(emitter, digit+'A'-10)
1513
					}
1514
				}
1515
			}
1516
			if !ok {
1517
				return false
1518
			}
1519
			spaces = false
1520
		} else if is_space(value, i) {
1521
			if allow_breaks && !spaces && emitter.column > emitter.best_width && i > 0 && i < len(value)-1 {
1522
				if !yaml_emitter_write_indent(emitter) {
1523
					return false
1524
				}
1525
				if is_space(value, i+1) {
1526
					if !put(emitter, '\\') {
1527
						return false
1528
					}
1529
				}
1530
				i += width(value[i])
1531
			} else if !write(emitter, value, &i) {
1532
				return false
1533
			}
1534
			spaces = true
1535
		} else {
1536
			if !write(emitter, value, &i) {
1537
				return false
1538
			}
1539
			spaces = false
1540
		}
1541
	}
1542
	if !yaml_emitter_write_indicator(emitter, []byte{'"'}, false, false, false) {
1543
		return false
1544
	}
1545
	emitter.whitespace = false
1546
	emitter.indention = false
1547
	return true
1548
}
1549

1550
func yaml_emitter_write_block_scalar_hints(emitter *yaml_emitter_t, value []byte) bool {
1551
	if is_space(value, 0) || is_break(value, 0) {
1552
		indent_hint := []byte{'0' + byte(emitter.best_indent)}
1553
		if !yaml_emitter_write_indicator(emitter, indent_hint, false, false, false) {
1554
			return false
1555
		}
1556
	}
1557

1558
	emitter.open_ended = false
1559

1560
	var chomp_hint [1]byte
1561
	if len(value) == 0 {
1562
		chomp_hint[0] = '-'
1563
	} else {
1564
		i := len(value) - 1
1565
		for value[i]&0xC0 == 0x80 {
1566
			i--
1567
		}
1568
		if !is_break(value, i) {
1569
			chomp_hint[0] = '-'
1570
		} else if i == 0 {
1571
			chomp_hint[0] = '+'
1572
			emitter.open_ended = true
1573
		} else {
1574
			i--
1575
			for value[i]&0xC0 == 0x80 {
1576
				i--
1577
			}
1578
			if is_break(value, i) {
1579
				chomp_hint[0] = '+'
1580
				emitter.open_ended = true
1581
			}
1582
		}
1583
	}
1584
	if chomp_hint[0] != 0 {
1585
		if !yaml_emitter_write_indicator(emitter, chomp_hint[:], false, false, false) {
1586
			return false
1587
		}
1588
	}
1589
	return true
1590
}
1591

1592
func yaml_emitter_write_literal_scalar(emitter *yaml_emitter_t, value []byte) bool {
1593
	if !yaml_emitter_write_indicator(emitter, []byte{'|'}, true, false, false) {
1594
		return false
1595
	}
1596
	if !yaml_emitter_write_block_scalar_hints(emitter, value) {
1597
		return false
1598
	}
1599
	if !put_break(emitter) {
1600
		return false
1601
	}
1602
	emitter.indention = true
1603
	emitter.whitespace = true
1604
	breaks := true
1605
	for i := 0; i < len(value); {
1606
		if is_break(value, i) {
1607
			if !write_break(emitter, value, &i) {
1608
				return false
1609
			}
1610
			emitter.indention = true
1611
			breaks = true
1612
		} else {
1613
			if breaks {
1614
				if !yaml_emitter_write_indent(emitter) {
1615
					return false
1616
				}
1617
			}
1618
			if !write(emitter, value, &i) {
1619
				return false
1620
			}
1621
			emitter.indention = false
1622
			breaks = false
1623
		}
1624
	}
1625

1626
	return true
1627
}
1628

1629
func yaml_emitter_write_folded_scalar(emitter *yaml_emitter_t, value []byte) bool {
1630
	if !yaml_emitter_write_indicator(emitter, []byte{'>'}, true, false, false) {
1631
		return false
1632
	}
1633
	if !yaml_emitter_write_block_scalar_hints(emitter, value) {
1634
		return false
1635
	}
1636

1637
	if !put_break(emitter) {
1638
		return false
1639
	}
1640
	emitter.indention = true
1641
	emitter.whitespace = true
1642

1643
	breaks := true
1644
	leading_spaces := true
1645
	for i := 0; i < len(value); {
1646
		if is_break(value, i) {
1647
			if !breaks && !leading_spaces && value[i] == '\n' {
1648
				k := 0
1649
				for is_break(value, k) {
1650
					k += width(value[k])
1651
				}
1652
				if !is_blankz(value, k) {
1653
					if !put_break(emitter) {
1654
						return false
1655
					}
1656
				}
1657
			}
1658
			if !write_break(emitter, value, &i) {
1659
				return false
1660
			}
1661
			emitter.indention = true
1662
			breaks = true
1663
		} else {
1664
			if breaks {
1665
				if !yaml_emitter_write_indent(emitter) {
1666
					return false
1667
				}
1668
				leading_spaces = is_blank(value, i)
1669
			}
1670
			if !breaks && is_space(value, i) && !is_space(value, i+1) && emitter.column > emitter.best_width {
1671
				if !yaml_emitter_write_indent(emitter) {
1672
					return false
1673
				}
1674
				i += width(value[i])
1675
			} else {
1676
				if !write(emitter, value, &i) {
1677
					return false
1678
				}
1679
			}
1680
			emitter.indention = false
1681
			breaks = false
1682
		}
1683
	}
1684
	return true
1685
}
1686