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