diff options
Diffstat (limited to 'vendor/github.com/zclconf/go-cty-yaml/emitterc.go')
-rw-r--r-- | vendor/github.com/zclconf/go-cty-yaml/emitterc.go | 1685 |
1 files changed, 1685 insertions, 0 deletions
diff --git a/vendor/github.com/zclconf/go-cty-yaml/emitterc.go b/vendor/github.com/zclconf/go-cty-yaml/emitterc.go new file mode 100644 index 0000000..a1c2cc5 --- /dev/null +++ b/vendor/github.com/zclconf/go-cty-yaml/emitterc.go | |||
@@ -0,0 +1,1685 @@ | |||
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 | } | ||