|
66
|
1 package yaml
|
|
|
2
|
|
|
3 import (
|
|
|
4 "io"
|
|
|
5 )
|
|
|
6
|
|
|
7 func yaml_insert_token(parser *yaml_parser_t, pos int, token *yaml_token_t) {
|
|
|
8 //fmt.Println("yaml_insert_token", "pos:", pos, "typ:", token.typ, "head:", parser.tokens_head, "len:", len(parser.tokens))
|
|
|
9
|
|
|
10 // Check if we can move the queue at the beginning of the buffer.
|
|
|
11 if parser.tokens_head > 0 && len(parser.tokens) == cap(parser.tokens) {
|
|
|
12 if parser.tokens_head != len(parser.tokens) {
|
|
|
13 copy(parser.tokens, parser.tokens[parser.tokens_head:])
|
|
|
14 }
|
|
|
15 parser.tokens = parser.tokens[:len(parser.tokens)-parser.tokens_head]
|
|
|
16 parser.tokens_head = 0
|
|
|
17 }
|
|
|
18 parser.tokens = append(parser.tokens, *token)
|
|
|
19 if pos < 0 {
|
|
|
20 return
|
|
|
21 }
|
|
|
22 copy(parser.tokens[parser.tokens_head+pos+1:], parser.tokens[parser.tokens_head+pos:])
|
|
|
23 parser.tokens[parser.tokens_head+pos] = *token
|
|
|
24 }
|
|
|
25
|
|
|
26 // Create a new parser object.
|
|
|
27 func yaml_parser_initialize(parser *yaml_parser_t) bool {
|
|
|
28 *parser = yaml_parser_t{
|
|
|
29 raw_buffer: make([]byte, 0, input_raw_buffer_size),
|
|
|
30 buffer: make([]byte, 0, input_buffer_size),
|
|
|
31 }
|
|
|
32 return true
|
|
|
33 }
|
|
|
34
|
|
|
35 // Destroy a parser object.
|
|
|
36 func yaml_parser_delete(parser *yaml_parser_t) {
|
|
|
37 *parser = yaml_parser_t{}
|
|
|
38 }
|
|
|
39
|
|
|
40 // String read handler.
|
|
|
41 func yaml_string_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {
|
|
|
42 if parser.input_pos == len(parser.input) {
|
|
|
43 return 0, io.EOF
|
|
|
44 }
|
|
|
45 n = copy(buffer, parser.input[parser.input_pos:])
|
|
|
46 parser.input_pos += n
|
|
|
47 return n, nil
|
|
|
48 }
|
|
|
49
|
|
|
50 // Reader read handler.
|
|
|
51 func yaml_reader_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {
|
|
|
52 return parser.input_reader.Read(buffer)
|
|
|
53 }
|
|
|
54
|
|
|
55 // Set a string input.
|
|
|
56 func yaml_parser_set_input_string(parser *yaml_parser_t, input []byte) {
|
|
|
57 if parser.read_handler != nil {
|
|
|
58 panic("must set the input source only once")
|
|
|
59 }
|
|
|
60 parser.read_handler = yaml_string_read_handler
|
|
|
61 parser.input = input
|
|
|
62 parser.input_pos = 0
|
|
|
63 }
|
|
|
64
|
|
|
65 // Set a file input.
|
|
|
66 func yaml_parser_set_input_reader(parser *yaml_parser_t, r io.Reader) {
|
|
|
67 if parser.read_handler != nil {
|
|
|
68 panic("must set the input source only once")
|
|
|
69 }
|
|
|
70 parser.read_handler = yaml_reader_read_handler
|
|
|
71 parser.input_reader = r
|
|
|
72 }
|
|
|
73
|
|
|
74 // Set the source encoding.
|
|
|
75 func yaml_parser_set_encoding(parser *yaml_parser_t, encoding yaml_encoding_t) {
|
|
|
76 if parser.encoding != yaml_ANY_ENCODING {
|
|
|
77 panic("must set the encoding only once")
|
|
|
78 }
|
|
|
79 parser.encoding = encoding
|
|
|
80 }
|
|
|
81
|
|
|
82 var disableLineWrapping = false
|
|
|
83
|
|
|
84 // Create a new emitter object.
|
|
|
85 func yaml_emitter_initialize(emitter *yaml_emitter_t) {
|
|
|
86 *emitter = yaml_emitter_t{
|
|
|
87 buffer: make([]byte, output_buffer_size),
|
|
|
88 raw_buffer: make([]byte, 0, output_raw_buffer_size),
|
|
|
89 states: make([]yaml_emitter_state_t, 0, initial_stack_size),
|
|
|
90 events: make([]yaml_event_t, 0, initial_queue_size),
|
|
|
91 }
|
|
|
92 if disableLineWrapping {
|
|
|
93 emitter.best_width = -1
|
|
|
94 }
|
|
|
95 }
|
|
|
96
|
|
|
97 // Destroy an emitter object.
|
|
|
98 func yaml_emitter_delete(emitter *yaml_emitter_t) {
|
|
|
99 *emitter = yaml_emitter_t{}
|
|
|
100 }
|
|
|
101
|
|
|
102 // String write handler.
|
|
|
103 func yaml_string_write_handler(emitter *yaml_emitter_t, buffer []byte) error {
|
|
|
104 *emitter.output_buffer = append(*emitter.output_buffer, buffer...)
|
|
|
105 return nil
|
|
|
106 }
|
|
|
107
|
|
|
108 // yaml_writer_write_handler uses emitter.output_writer to write the
|
|
|
109 // emitted text.
|
|
|
110 func yaml_writer_write_handler(emitter *yaml_emitter_t, buffer []byte) error {
|
|
|
111 _, err := emitter.output_writer.Write(buffer)
|
|
|
112 return err
|
|
|
113 }
|
|
|
114
|
|
|
115 // Set a string output.
|
|
|
116 func yaml_emitter_set_output_string(emitter *yaml_emitter_t, output_buffer *[]byte) {
|
|
|
117 if emitter.write_handler != nil {
|
|
|
118 panic("must set the output target only once")
|
|
|
119 }
|
|
|
120 emitter.write_handler = yaml_string_write_handler
|
|
|
121 emitter.output_buffer = output_buffer
|
|
|
122 }
|
|
|
123
|
|
|
124 // Set a file output.
|
|
|
125 func yaml_emitter_set_output_writer(emitter *yaml_emitter_t, w io.Writer) {
|
|
|
126 if emitter.write_handler != nil {
|
|
|
127 panic("must set the output target only once")
|
|
|
128 }
|
|
|
129 emitter.write_handler = yaml_writer_write_handler
|
|
|
130 emitter.output_writer = w
|
|
|
131 }
|
|
|
132
|
|
|
133 // Set the output encoding.
|
|
|
134 func yaml_emitter_set_encoding(emitter *yaml_emitter_t, encoding yaml_encoding_t) {
|
|
|
135 if emitter.encoding != yaml_ANY_ENCODING {
|
|
|
136 panic("must set the output encoding only once")
|
|
|
137 }
|
|
|
138 emitter.encoding = encoding
|
|
|
139 }
|
|
|
140
|
|
|
141 // Set the canonical output style.
|
|
|
142 func yaml_emitter_set_canonical(emitter *yaml_emitter_t, canonical bool) {
|
|
|
143 emitter.canonical = canonical
|
|
|
144 }
|
|
|
145
|
|
|
146 //// Set the indentation increment.
|
|
|
147 func yaml_emitter_set_indent(emitter *yaml_emitter_t, indent int) {
|
|
|
148 if indent < 2 || indent > 9 {
|
|
|
149 indent = 2
|
|
|
150 }
|
|
|
151 emitter.best_indent = indent
|
|
|
152 }
|
|
|
153
|
|
|
154 // Set the preferred line width.
|
|
|
155 func yaml_emitter_set_width(emitter *yaml_emitter_t, width int) {
|
|
|
156 if width < 0 {
|
|
|
157 width = -1
|
|
|
158 }
|
|
|
159 emitter.best_width = width
|
|
|
160 }
|
|
|
161
|
|
|
162 // Set if unescaped non-ASCII characters are allowed.
|
|
|
163 func yaml_emitter_set_unicode(emitter *yaml_emitter_t, unicode bool) {
|
|
|
164 emitter.unicode = unicode
|
|
|
165 }
|
|
|
166
|
|
|
167 // Set the preferred line break character.
|
|
|
168 func yaml_emitter_set_break(emitter *yaml_emitter_t, line_break yaml_break_t) {
|
|
|
169 emitter.line_break = line_break
|
|
|
170 }
|
|
|
171
|
|
|
172 ///*
|
|
|
173 // * Destroy a token object.
|
|
|
174 // */
|
|
|
175 //
|
|
|
176 //YAML_DECLARE(void)
|
|
|
177 //yaml_token_delete(yaml_token_t *token)
|
|
|
178 //{
|
|
|
179 // assert(token); // Non-NULL token object expected.
|
|
|
180 //
|
|
|
181 // switch (token.type)
|
|
|
182 // {
|
|
|
183 // case YAML_TAG_DIRECTIVE_TOKEN:
|
|
|
184 // yaml_free(token.data.tag_directive.handle);
|
|
|
185 // yaml_free(token.data.tag_directive.prefix);
|
|
|
186 // break;
|
|
|
187 //
|
|
|
188 // case YAML_ALIAS_TOKEN:
|
|
|
189 // yaml_free(token.data.alias.value);
|
|
|
190 // break;
|
|
|
191 //
|
|
|
192 // case YAML_ANCHOR_TOKEN:
|
|
|
193 // yaml_free(token.data.anchor.value);
|
|
|
194 // break;
|
|
|
195 //
|
|
|
196 // case YAML_TAG_TOKEN:
|
|
|
197 // yaml_free(token.data.tag.handle);
|
|
|
198 // yaml_free(token.data.tag.suffix);
|
|
|
199 // break;
|
|
|
200 //
|
|
|
201 // case YAML_SCALAR_TOKEN:
|
|
|
202 // yaml_free(token.data.scalar.value);
|
|
|
203 // break;
|
|
|
204 //
|
|
|
205 // default:
|
|
|
206 // break;
|
|
|
207 // }
|
|
|
208 //
|
|
|
209 // memset(token, 0, sizeof(yaml_token_t));
|
|
|
210 //}
|
|
|
211 //
|
|
|
212 ///*
|
|
|
213 // * Check if a string is a valid UTF-8 sequence.
|
|
|
214 // *
|
|
|
215 // * Check 'reader.c' for more details on UTF-8 encoding.
|
|
|
216 // */
|
|
|
217 //
|
|
|
218 //static int
|
|
|
219 //yaml_check_utf8(yaml_char_t *start, size_t length)
|
|
|
220 //{
|
|
|
221 // yaml_char_t *end = start+length;
|
|
|
222 // yaml_char_t *pointer = start;
|
|
|
223 //
|
|
|
224 // while (pointer < end) {
|
|
|
225 // unsigned char octet;
|
|
|
226 // unsigned int width;
|
|
|
227 // unsigned int value;
|
|
|
228 // size_t k;
|
|
|
229 //
|
|
|
230 // octet = pointer[0];
|
|
|
231 // width = (octet & 0x80) == 0x00 ? 1 :
|
|
|
232 // (octet & 0xE0) == 0xC0 ? 2 :
|
|
|
233 // (octet & 0xF0) == 0xE0 ? 3 :
|
|
|
234 // (octet & 0xF8) == 0xF0 ? 4 : 0;
|
|
|
235 // value = (octet & 0x80) == 0x00 ? octet & 0x7F :
|
|
|
236 // (octet & 0xE0) == 0xC0 ? octet & 0x1F :
|
|
|
237 // (octet & 0xF0) == 0xE0 ? octet & 0x0F :
|
|
|
238 // (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
|
|
|
239 // if (!width) return 0;
|
|
|
240 // if (pointer+width > end) return 0;
|
|
|
241 // for (k = 1; k < width; k ++) {
|
|
|
242 // octet = pointer[k];
|
|
|
243 // if ((octet & 0xC0) != 0x80) return 0;
|
|
|
244 // value = (value << 6) + (octet & 0x3F);
|
|
|
245 // }
|
|
|
246 // if (!((width == 1) ||
|
|
|
247 // (width == 2 && value >= 0x80) ||
|
|
|
248 // (width == 3 && value >= 0x800) ||
|
|
|
249 // (width == 4 && value >= 0x10000))) return 0;
|
|
|
250 //
|
|
|
251 // pointer += width;
|
|
|
252 // }
|
|
|
253 //
|
|
|
254 // return 1;
|
|
|
255 //}
|
|
|
256 //
|
|
|
257
|
|
|
258 // Create STREAM-START.
|
|
|
259 func yaml_stream_start_event_initialize(event *yaml_event_t, encoding yaml_encoding_t) {
|
|
|
260 *event = yaml_event_t{
|
|
|
261 typ: yaml_STREAM_START_EVENT,
|
|
|
262 encoding: encoding,
|
|
|
263 }
|
|
|
264 }
|
|
|
265
|
|
|
266 // Create STREAM-END.
|
|
|
267 func yaml_stream_end_event_initialize(event *yaml_event_t) {
|
|
|
268 *event = yaml_event_t{
|
|
|
269 typ: yaml_STREAM_END_EVENT,
|
|
|
270 }
|
|
|
271 }
|
|
|
272
|
|
|
273 // Create DOCUMENT-START.
|
|
|
274 func yaml_document_start_event_initialize(
|
|
|
275 event *yaml_event_t,
|
|
|
276 version_directive *yaml_version_directive_t,
|
|
|
277 tag_directives []yaml_tag_directive_t,
|
|
|
278 implicit bool,
|
|
|
279 ) {
|
|
|
280 *event = yaml_event_t{
|
|
|
281 typ: yaml_DOCUMENT_START_EVENT,
|
|
|
282 version_directive: version_directive,
|
|
|
283 tag_directives: tag_directives,
|
|
|
284 implicit: implicit,
|
|
|
285 }
|
|
|
286 }
|
|
|
287
|
|
|
288 // Create DOCUMENT-END.
|
|
|
289 func yaml_document_end_event_initialize(event *yaml_event_t, implicit bool) {
|
|
|
290 *event = yaml_event_t{
|
|
|
291 typ: yaml_DOCUMENT_END_EVENT,
|
|
|
292 implicit: implicit,
|
|
|
293 }
|
|
|
294 }
|
|
|
295
|
|
|
296 ///*
|
|
|
297 // * Create ALIAS.
|
|
|
298 // */
|
|
|
299 //
|
|
|
300 //YAML_DECLARE(int)
|
|
|
301 //yaml_alias_event_initialize(event *yaml_event_t, anchor *yaml_char_t)
|
|
|
302 //{
|
|
|
303 // mark yaml_mark_t = { 0, 0, 0 }
|
|
|
304 // anchor_copy *yaml_char_t = NULL
|
|
|
305 //
|
|
|
306 // assert(event) // Non-NULL event object is expected.
|
|
|
307 // assert(anchor) // Non-NULL anchor is expected.
|
|
|
308 //
|
|
|
309 // if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0
|
|
|
310 //
|
|
|
311 // anchor_copy = yaml_strdup(anchor)
|
|
|
312 // if (!anchor_copy)
|
|
|
313 // return 0
|
|
|
314 //
|
|
|
315 // ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark)
|
|
|
316 //
|
|
|
317 // return 1
|
|
|
318 //}
|
|
|
319
|
|
|
320 // Create SCALAR.
|
|
|
321 func yaml_scalar_event_initialize(event *yaml_event_t, anchor, tag, value []byte, plain_implicit, quoted_implicit bool, style yaml_scalar_style_t) bool {
|
|
|
322 *event = yaml_event_t{
|
|
|
323 typ: yaml_SCALAR_EVENT,
|
|
|
324 anchor: anchor,
|
|
|
325 tag: tag,
|
|
|
326 value: value,
|
|
|
327 implicit: plain_implicit,
|
|
|
328 quoted_implicit: quoted_implicit,
|
|
|
329 style: yaml_style_t(style),
|
|
|
330 }
|
|
|
331 return true
|
|
|
332 }
|
|
|
333
|
|
|
334 // Create SEQUENCE-START.
|
|
|
335 func yaml_sequence_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_sequence_style_t) bool {
|
|
|
336 *event = yaml_event_t{
|
|
|
337 typ: yaml_SEQUENCE_START_EVENT,
|
|
|
338 anchor: anchor,
|
|
|
339 tag: tag,
|
|
|
340 implicit: implicit,
|
|
|
341 style: yaml_style_t(style),
|
|
|
342 }
|
|
|
343 return true
|
|
|
344 }
|
|
|
345
|
|
|
346 // Create SEQUENCE-END.
|
|
|
347 func yaml_sequence_end_event_initialize(event *yaml_event_t) bool {
|
|
|
348 *event = yaml_event_t{
|
|
|
349 typ: yaml_SEQUENCE_END_EVENT,
|
|
|
350 }
|
|
|
351 return true
|
|
|
352 }
|
|
|
353
|
|
|
354 // Create MAPPING-START.
|
|
|
355 func yaml_mapping_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_mapping_style_t) {
|
|
|
356 *event = yaml_event_t{
|
|
|
357 typ: yaml_MAPPING_START_EVENT,
|
|
|
358 anchor: anchor,
|
|
|
359 tag: tag,
|
|
|
360 implicit: implicit,
|
|
|
361 style: yaml_style_t(style),
|
|
|
362 }
|
|
|
363 }
|
|
|
364
|
|
|
365 // Create MAPPING-END.
|
|
|
366 func yaml_mapping_end_event_initialize(event *yaml_event_t) {
|
|
|
367 *event = yaml_event_t{
|
|
|
368 typ: yaml_MAPPING_END_EVENT,
|
|
|
369 }
|
|
|
370 }
|
|
|
371
|
|
|
372 // Destroy an event object.
|
|
|
373 func yaml_event_delete(event *yaml_event_t) {
|
|
|
374 *event = yaml_event_t{}
|
|
|
375 }
|
|
|
376
|
|
|
377 ///*
|
|
|
378 // * Create a document object.
|
|
|
379 // */
|
|
|
380 //
|
|
|
381 //YAML_DECLARE(int)
|
|
|
382 //yaml_document_initialize(document *yaml_document_t,
|
|
|
383 // version_directive *yaml_version_directive_t,
|
|
|
384 // tag_directives_start *yaml_tag_directive_t,
|
|
|
385 // tag_directives_end *yaml_tag_directive_t,
|
|
|
386 // start_implicit int, end_implicit int)
|
|
|
387 //{
|
|
|
388 // struct {
|
|
|
389 // error yaml_error_type_t
|
|
|
390 // } context
|
|
|
391 // struct {
|
|
|
392 // start *yaml_node_t
|
|
|
393 // end *yaml_node_t
|
|
|
394 // top *yaml_node_t
|
|
|
395 // } nodes = { NULL, NULL, NULL }
|
|
|
396 // version_directive_copy *yaml_version_directive_t = NULL
|
|
|
397 // struct {
|
|
|
398 // start *yaml_tag_directive_t
|
|
|
399 // end *yaml_tag_directive_t
|
|
|
400 // top *yaml_tag_directive_t
|
|
|
401 // } tag_directives_copy = { NULL, NULL, NULL }
|
|
|
402 // value yaml_tag_directive_t = { NULL, NULL }
|
|
|
403 // mark yaml_mark_t = { 0, 0, 0 }
|
|
|
404 //
|
|
|
405 // assert(document) // Non-NULL document object is expected.
|
|
|
406 // assert((tag_directives_start && tag_directives_end) ||
|
|
|
407 // (tag_directives_start == tag_directives_end))
|
|
|
408 // // Valid tag directives are expected.
|
|
|
409 //
|
|
|
410 // if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error
|
|
|
411 //
|
|
|
412 // if (version_directive) {
|
|
|
413 // version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t))
|
|
|
414 // if (!version_directive_copy) goto error
|
|
|
415 // version_directive_copy.major = version_directive.major
|
|
|
416 // version_directive_copy.minor = version_directive.minor
|
|
|
417 // }
|
|
|
418 //
|
|
|
419 // if (tag_directives_start != tag_directives_end) {
|
|
|
420 // tag_directive *yaml_tag_directive_t
|
|
|
421 // if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
|
|
|
422 // goto error
|
|
|
423 // for (tag_directive = tag_directives_start
|
|
|
424 // tag_directive != tag_directives_end; tag_directive ++) {
|
|
|
425 // assert(tag_directive.handle)
|
|
|
426 // assert(tag_directive.prefix)
|
|
|
427 // if (!yaml_check_utf8(tag_directive.handle,
|
|
|
428 // strlen((char *)tag_directive.handle)))
|
|
|
429 // goto error
|
|
|
430 // if (!yaml_check_utf8(tag_directive.prefix,
|
|
|
431 // strlen((char *)tag_directive.prefix)))
|
|
|
432 // goto error
|
|
|
433 // value.handle = yaml_strdup(tag_directive.handle)
|
|
|
434 // value.prefix = yaml_strdup(tag_directive.prefix)
|
|
|
435 // if (!value.handle || !value.prefix) goto error
|
|
|
436 // if (!PUSH(&context, tag_directives_copy, value))
|
|
|
437 // goto error
|
|
|
438 // value.handle = NULL
|
|
|
439 // value.prefix = NULL
|
|
|
440 // }
|
|
|
441 // }
|
|
|
442 //
|
|
|
443 // DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy,
|
|
|
444 // tag_directives_copy.start, tag_directives_copy.top,
|
|
|
445 // start_implicit, end_implicit, mark, mark)
|
|
|
446 //
|
|
|
447 // return 1
|
|
|
448 //
|
|
|
449 //error:
|
|
|
450 // STACK_DEL(&context, nodes)
|
|
|
451 // yaml_free(version_directive_copy)
|
|
|
452 // while (!STACK_EMPTY(&context, tag_directives_copy)) {
|
|
|
453 // value yaml_tag_directive_t = POP(&context, tag_directives_copy)
|
|
|
454 // yaml_free(value.handle)
|
|
|
455 // yaml_free(value.prefix)
|
|
|
456 // }
|
|
|
457 // STACK_DEL(&context, tag_directives_copy)
|
|
|
458 // yaml_free(value.handle)
|
|
|
459 // yaml_free(value.prefix)
|
|
|
460 //
|
|
|
461 // return 0
|
|
|
462 //}
|
|
|
463 //
|
|
|
464 ///*
|
|
|
465 // * Destroy a document object.
|
|
|
466 // */
|
|
|
467 //
|
|
|
468 //YAML_DECLARE(void)
|
|
|
469 //yaml_document_delete(document *yaml_document_t)
|
|
|
470 //{
|
|
|
471 // struct {
|
|
|
472 // error yaml_error_type_t
|
|
|
473 // } context
|
|
|
474 // tag_directive *yaml_tag_directive_t
|
|
|
475 //
|
|
|
476 // context.error = YAML_NO_ERROR // Eliminate a compiler warning.
|
|
|
477 //
|
|
|
478 // assert(document) // Non-NULL document object is expected.
|
|
|
479 //
|
|
|
480 // while (!STACK_EMPTY(&context, document.nodes)) {
|
|
|
481 // node yaml_node_t = POP(&context, document.nodes)
|
|
|
482 // yaml_free(node.tag)
|
|
|
483 // switch (node.type) {
|
|
|
484 // case YAML_SCALAR_NODE:
|
|
|
485 // yaml_free(node.data.scalar.value)
|
|
|
486 // break
|
|
|
487 // case YAML_SEQUENCE_NODE:
|
|
|
488 // STACK_DEL(&context, node.data.sequence.items)
|
|
|
489 // break
|
|
|
490 // case YAML_MAPPING_NODE:
|
|
|
491 // STACK_DEL(&context, node.data.mapping.pairs)
|
|
|
492 // break
|
|
|
493 // default:
|
|
|
494 // assert(0) // Should not happen.
|
|
|
495 // }
|
|
|
496 // }
|
|
|
497 // STACK_DEL(&context, document.nodes)
|
|
|
498 //
|
|
|
499 // yaml_free(document.version_directive)
|
|
|
500 // for (tag_directive = document.tag_directives.start
|
|
|
501 // tag_directive != document.tag_directives.end
|
|
|
502 // tag_directive++) {
|
|
|
503 // yaml_free(tag_directive.handle)
|
|
|
504 // yaml_free(tag_directive.prefix)
|
|
|
505 // }
|
|
|
506 // yaml_free(document.tag_directives.start)
|
|
|
507 //
|
|
|
508 // memset(document, 0, sizeof(yaml_document_t))
|
|
|
509 //}
|
|
|
510 //
|
|
|
511 ///**
|
|
|
512 // * Get a document node.
|
|
|
513 // */
|
|
|
514 //
|
|
|
515 //YAML_DECLARE(yaml_node_t *)
|
|
|
516 //yaml_document_get_node(document *yaml_document_t, index int)
|
|
|
517 //{
|
|
|
518 // assert(document) // Non-NULL document object is expected.
|
|
|
519 //
|
|
|
520 // if (index > 0 && document.nodes.start + index <= document.nodes.top) {
|
|
|
521 // return document.nodes.start + index - 1
|
|
|
522 // }
|
|
|
523 // return NULL
|
|
|
524 //}
|
|
|
525 //
|
|
|
526 ///**
|
|
|
527 // * Get the root object.
|
|
|
528 // */
|
|
|
529 //
|
|
|
530 //YAML_DECLARE(yaml_node_t *)
|
|
|
531 //yaml_document_get_root_node(document *yaml_document_t)
|
|
|
532 //{
|
|
|
533 // assert(document) // Non-NULL document object is expected.
|
|
|
534 //
|
|
|
535 // if (document.nodes.top != document.nodes.start) {
|
|
|
536 // return document.nodes.start
|
|
|
537 // }
|
|
|
538 // return NULL
|
|
|
539 //}
|
|
|
540 //
|
|
|
541 ///*
|
|
|
542 // * Add a scalar node to a document.
|
|
|
543 // */
|
|
|
544 //
|
|
|
545 //YAML_DECLARE(int)
|
|
|
546 //yaml_document_add_scalar(document *yaml_document_t,
|
|
|
547 // tag *yaml_char_t, value *yaml_char_t, length int,
|
|
|
548 // style yaml_scalar_style_t)
|
|
|
549 //{
|
|
|
550 // struct {
|
|
|
551 // error yaml_error_type_t
|
|
|
552 // } context
|
|
|
553 // mark yaml_mark_t = { 0, 0, 0 }
|
|
|
554 // tag_copy *yaml_char_t = NULL
|
|
|
555 // value_copy *yaml_char_t = NULL
|
|
|
556 // node yaml_node_t
|
|
|
557 //
|
|
|
558 // assert(document) // Non-NULL document object is expected.
|
|
|
559 // assert(value) // Non-NULL value is expected.
|
|
|
560 //
|
|
|
561 // if (!tag) {
|
|
|
562 // tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG
|
|
|
563 // }
|
|
|
564 //
|
|
|
565 // if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
|
|
|
566 // tag_copy = yaml_strdup(tag)
|
|
|
567 // if (!tag_copy) goto error
|
|
|
568 //
|
|
|
569 // if (length < 0) {
|
|
|
570 // length = strlen((char *)value)
|
|
|
571 // }
|
|
|
572 //
|
|
|
573 // if (!yaml_check_utf8(value, length)) goto error
|
|
|
574 // value_copy = yaml_malloc(length+1)
|
|
|
575 // if (!value_copy) goto error
|
|
|
576 // memcpy(value_copy, value, length)
|
|
|
577 // value_copy[length] = '\0'
|
|
|
578 //
|
|
|
579 // SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark)
|
|
|
580 // if (!PUSH(&context, document.nodes, node)) goto error
|
|
|
581 //
|
|
|
582 // return document.nodes.top - document.nodes.start
|
|
|
583 //
|
|
|
584 //error:
|
|
|
585 // yaml_free(tag_copy)
|
|
|
586 // yaml_free(value_copy)
|
|
|
587 //
|
|
|
588 // return 0
|
|
|
589 //}
|
|
|
590 //
|
|
|
591 ///*
|
|
|
592 // * Add a sequence node to a document.
|
|
|
593 // */
|
|
|
594 //
|
|
|
595 //YAML_DECLARE(int)
|
|
|
596 //yaml_document_add_sequence(document *yaml_document_t,
|
|
|
597 // tag *yaml_char_t, style yaml_sequence_style_t)
|
|
|
598 //{
|
|
|
599 // struct {
|
|
|
600 // error yaml_error_type_t
|
|
|
601 // } context
|
|
|
602 // mark yaml_mark_t = { 0, 0, 0 }
|
|
|
603 // tag_copy *yaml_char_t = NULL
|
|
|
604 // struct {
|
|
|
605 // start *yaml_node_item_t
|
|
|
606 // end *yaml_node_item_t
|
|
|
607 // top *yaml_node_item_t
|
|
|
608 // } items = { NULL, NULL, NULL }
|
|
|
609 // node yaml_node_t
|
|
|
610 //
|
|
|
611 // assert(document) // Non-NULL document object is expected.
|
|
|
612 //
|
|
|
613 // if (!tag) {
|
|
|
614 // tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG
|
|
|
615 // }
|
|
|
616 //
|
|
|
617 // if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
|
|
|
618 // tag_copy = yaml_strdup(tag)
|
|
|
619 // if (!tag_copy) goto error
|
|
|
620 //
|
|
|
621 // if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error
|
|
|
622 //
|
|
|
623 // SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,
|
|
|
624 // style, mark, mark)
|
|
|
625 // if (!PUSH(&context, document.nodes, node)) goto error
|
|
|
626 //
|
|
|
627 // return document.nodes.top - document.nodes.start
|
|
|
628 //
|
|
|
629 //error:
|
|
|
630 // STACK_DEL(&context, items)
|
|
|
631 // yaml_free(tag_copy)
|
|
|
632 //
|
|
|
633 // return 0
|
|
|
634 //}
|
|
|
635 //
|
|
|
636 ///*
|
|
|
637 // * Add a mapping node to a document.
|
|
|
638 // */
|
|
|
639 //
|
|
|
640 //YAML_DECLARE(int)
|
|
|
641 //yaml_document_add_mapping(document *yaml_document_t,
|
|
|
642 // tag *yaml_char_t, style yaml_mapping_style_t)
|
|
|
643 //{
|
|
|
644 // struct {
|
|
|
645 // error yaml_error_type_t
|
|
|
646 // } context
|
|
|
647 // mark yaml_mark_t = { 0, 0, 0 }
|
|
|
648 // tag_copy *yaml_char_t = NULL
|
|
|
649 // struct {
|
|
|
650 // start *yaml_node_pair_t
|
|
|
651 // end *yaml_node_pair_t
|
|
|
652 // top *yaml_node_pair_t
|
|
|
653 // } pairs = { NULL, NULL, NULL }
|
|
|
654 // node yaml_node_t
|
|
|
655 //
|
|
|
656 // assert(document) // Non-NULL document object is expected.
|
|
|
657 //
|
|
|
658 // if (!tag) {
|
|
|
659 // tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG
|
|
|
660 // }
|
|
|
661 //
|
|
|
662 // if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
|
|
|
663 // tag_copy = yaml_strdup(tag)
|
|
|
664 // if (!tag_copy) goto error
|
|
|
665 //
|
|
|
666 // if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error
|
|
|
667 //
|
|
|
668 // MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,
|
|
|
669 // style, mark, mark)
|
|
|
670 // if (!PUSH(&context, document.nodes, node)) goto error
|
|
|
671 //
|
|
|
672 // return document.nodes.top - document.nodes.start
|
|
|
673 //
|
|
|
674 //error:
|
|
|
675 // STACK_DEL(&context, pairs)
|
|
|
676 // yaml_free(tag_copy)
|
|
|
677 //
|
|
|
678 // return 0
|
|
|
679 //}
|
|
|
680 //
|
|
|
681 ///*
|
|
|
682 // * Append an item to a sequence node.
|
|
|
683 // */
|
|
|
684 //
|
|
|
685 //YAML_DECLARE(int)
|
|
|
686 //yaml_document_append_sequence_item(document *yaml_document_t,
|
|
|
687 // sequence int, item int)
|
|
|
688 //{
|
|
|
689 // struct {
|
|
|
690 // error yaml_error_type_t
|
|
|
691 // } context
|
|
|
692 //
|
|
|
693 // assert(document) // Non-NULL document is required.
|
|
|
694 // assert(sequence > 0
|
|
|
695 // && document.nodes.start + sequence <= document.nodes.top)
|
|
|
696 // // Valid sequence id is required.
|
|
|
697 // assert(document.nodes.start[sequence-1].type == YAML_SEQUENCE_NODE)
|
|
|
698 // // A sequence node is required.
|
|
|
699 // assert(item > 0 && document.nodes.start + item <= document.nodes.top)
|
|
|
700 // // Valid item id is required.
|
|
|
701 //
|
|
|
702 // if (!PUSH(&context,
|
|
|
703 // document.nodes.start[sequence-1].data.sequence.items, item))
|
|
|
704 // return 0
|
|
|
705 //
|
|
|
706 // return 1
|
|
|
707 //}
|
|
|
708 //
|
|
|
709 ///*
|
|
|
710 // * Append a pair of a key and a value to a mapping node.
|
|
|
711 // */
|
|
|
712 //
|
|
|
713 //YAML_DECLARE(int)
|
|
|
714 //yaml_document_append_mapping_pair(document *yaml_document_t,
|
|
|
715 // mapping int, key int, value int)
|
|
|
716 //{
|
|
|
717 // struct {
|
|
|
718 // error yaml_error_type_t
|
|
|
719 // } context
|
|
|
720 //
|
|
|
721 // pair yaml_node_pair_t
|
|
|
722 //
|
|
|
723 // assert(document) // Non-NULL document is required.
|
|
|
724 // assert(mapping > 0
|
|
|
725 // && document.nodes.start + mapping <= document.nodes.top)
|
|
|
726 // // Valid mapping id is required.
|
|
|
727 // assert(document.nodes.start[mapping-1].type == YAML_MAPPING_NODE)
|
|
|
728 // // A mapping node is required.
|
|
|
729 // assert(key > 0 && document.nodes.start + key <= document.nodes.top)
|
|
|
730 // // Valid key id is required.
|
|
|
731 // assert(value > 0 && document.nodes.start + value <= document.nodes.top)
|
|
|
732 // // Valid value id is required.
|
|
|
733 //
|
|
|
734 // pair.key = key
|
|
|
735 // pair.value = value
|
|
|
736 //
|
|
|
737 // if (!PUSH(&context,
|
|
|
738 // document.nodes.start[mapping-1].data.mapping.pairs, pair))
|
|
|
739 // return 0
|
|
|
740 //
|
|
|
741 // return 1
|
|
|
742 //}
|
|
|
743 //
|
|
|
744 //
|
